twitch flash player reversing

wasm twitch player tracks the following segmentmetadata keys:
cmd: "ld_lat_data" (live data) or "commercial" (ad)
stream_offset
commercial
commercial_id
length (ad length?)


Interesting keys/track:
stream_offset (aka stream time elapsed at current segment)
transc_r (transcoding receive time aka TDEN?)
transc_s (transcoding send time encoded aka TDTG?)


Translations:
TDEN: 2020-01-27T14:46:21 (hls_latency_broadcaster)
TDTG: 2020-01-27T14:46:21 (hls_latency_encoder)
broadc_s: 1 (hls_latency_broadcaster_send_time)
ingest_r: 2 (hls_latency_ingest_receive_time)
ingest_s: 3 (hls_latency_ingest_send_time)
stream_offset: stream_offset
transc_r: 1580136381680 = 2020-01-27T14:46:21.680Z (hls_latency_transcode_receive_time)
transc_s: 1580136381685 = 2020-01-27T14:46:21.685Z (hls_latency_transcode_send_time)

private static const MAX_DELAY_CORRECTION:Number = 100;
private var _latencyToEncoderMS:Number = NaN;

private var _latencyToBroadcasterMS:Number = NaN;

private var _serverTimeOffsetMS:Number = NaN;

private var _delayCorrection:Number = 0;
private var _scheduledDelay:Number = 0;

private var _timeOffset:Number = -1;

this._hls.setLatency(_loc4_); (default 8000)

private static const ID3_BROADCASTING_TIME:String = "TDEN";
private static const ID3_ENCODING_TIME:String = "TDTG";

 private function calculateServerTimeOffset() : void
      {
         var _loc3_:Number = NaN;
         var _loc1_:Object = this._hls.getExtraInfo(false);
         var _loc2_:Object = _loc1_["SERVER-TIME"];
         this._serverTimeOffsetMS = NaN;
         if(_loc2_)
         {
            _loc3_ = new Date().getTime();
            if(String(Number(_loc2_)) === String(_loc2_))
            {
               this._serverTimeOffsetMS = 1000 * Number(_loc2_) - _loc3_;
               this.log("Offset to server time is " + this._serverTimeOffsetMS + " ms");
            }
            else
            {
               this.log("server time in wrong format: " + _loc2_);
            }
         }
      }

ExternalInterface.addCallback("hls_time",function():Array
            {
               return [time,bufferLength];
            });

override public function get time() : Number
      {
         if(this._isSeekingTo >= 0)
         {
            return this._isSeekingTo;
         }
         if(this._timeOffset < 0)
         {
            return 0;
         }
         return super.time + this._timeOffset;
      }

this._metaDataTimestamp

private function parseISOTime(param1:String) : Number
      {
         var _loc2_:* = param1.replace(/\-/g,"/").replace("T"," ") + " UTC+0000";
         return Date.parse(_loc2_);
      }

 private function getDelayFromMetaData(param1:String) : Number
      {
         var _loc2_:Number = NaN;
         var _loc3_:Number = NaN;
         if(!isNaN(this._serverTimeOffsetMS) && this._metaDataTimestamp)
         {
            _loc2_ = this._metaDataTimestamp.getTime() + this._serverTimeOffsetMS;
            if(!isNaN(_loc2_) && param1 in this._metaData)
            {
               _loc3_ = this.parseISOTime(this._metaData[param1]);
               if(!isNaN(_loc3_))
               {
                  return _loc2_ - _loc3_;
               }
            }
         }
         return NaN;
      }

private function onID3Received(param1:Object) : void
      {
         var _loc2_:* = null;
         this._metaData = {};
         this._metaDataTimestamp = new Date();
         for(_loc2_ in param1)
         {
            if(param1.hasOwnProperty(_loc2_))
            {
               this._metaData[_loc2_] = param1[_loc2_];
            }
         }
         this._latencyToEncoderMS = this.getDelayFromMetaData(ID3_ENCODING_TIME);
         this._latencyToBroadcasterMS = this.getDelayFromMetaData(ID3_BROADCASTING_TIME);
         this.dispatchEvent(new Event(EVENT_METADATA_RECEIVED));
}

super.client = {
            "onPlayStatus":this.onPlayStatus,
            "onID3Received":this.onID3Received,
            "onMetaData":this.onMetaData
         };

private function calibrateDelay() : void
      {
         var _loc1_:Number = NaN;
         if(this._scheduledDelay > MAX_DELAY_CORRECTION / 2)
         {
            _loc1_ = this._scheduledTime - getTimer();
            this._delayCorrection = 0.6 * this._delayCorrection + 0.4 * _loc1_;
            this._delayCorrection = Math.max(this._delayCorrection,-MAX_DELAY_CORRECTION);
            this._delayCorrection = Math.min(this._delayCorrection,MAX_DELAY_CORRECTION);
         }
      }

private function updateTimingData(param1:Number) : void
      {
         if(this._timeOffset < 0)
         {
            this._timeOffset = param1;
         }
      }

 this.updateTimingData(firstPTS / 1000);