@alessmicrosystems/mpegts.js 1.8.1 → 1.8.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alessmicrosystems/mpegts.js",
-  "version": "1.8.1",
+  "version": "1.8.2",
   "description": "HTML5 MPEG2-TS Stream Player",
   "main": "./dist/mpegts.js",
   "types": "./d.ts/mpegts.d.ts",

package/src/demux/ts-demuxer.ts

@@ -99,7 +99,7 @@ type AudioData = {
 type StashedAudioPayload = {
     codec: 'aac' | 'aac-loas' | 'ac-3' | 'ec-3' | 'opus' | 'mp3';
     data: Uint8Array;
-    pts: number;
+    pts: number | undefined;
 };
 
 class TSDemuxer extends BaseDemuxer {
@@ -164,6 +164,10 @@ class TSDemuxer extends BaseDemuxer {
     private stashed_audio_before_video_init_: Array<StashedAudioPayload> = [];
     private _last_dispatch_block_reason_: string = '';
     private video_init_dispatch_time_: number = 0;
+    private audio_wrap_log_count_: number = 0;
+    private audio_stale_drop_log_count_: number = 0;
+    private audio_startup_align_log_count_: number = 0;
+    private audio_startup_drop_log_count_: number = 0;
     // The PID currently being decoded as the active audio stream.
     // 0 means "use whatever common_pids picks" (default first audio).
     private active_audio_pid_: number = 0;
@@ -1072,6 +1076,11 @@ class TSDemuxer extends BaseDemuxer {
                     pmt.common_pids.eac3 = 0;
                     this.selectAudioPid(fallback.pid);
                 }
+            } else if (is_new_pmt) {
+                const cfgPref = this.config_?.preferredAudioPid;
+                if (cfgPref && pmt.all_audio_pids.some(a => a.pid === cfgPref)) {
+                    this.selectAudioPid(cfgPref);
+                }
             }
             // Emit available track info to the player layer
             if (is_new_pmt && this.onTracksUpdated && (pmt.all_audio_pids.length > 1 || pmt.subtitle_pids.length > 0)) {
@@ -1458,6 +1467,61 @@ class TSDemuxer extends BaseDemuxer {
         }
     }
 
+    private normalizeIncomingAudioPtsMilliseconds(base_pts_ms: number | undefined): number | undefined {
+        if (base_pts_ms == undefined || this.audio_last_sample_pts_ == undefined) {
+            return base_pts_ms;
+        }
+
+        const halfWrapMs = 0x100000000 / this.timescale_;
+        const fullWrapMs = 0x200000000 / this.timescale_;
+
+        if (base_pts_ms + halfWrapMs < this.audio_last_sample_pts_) {
+            const normalized = base_pts_ms + fullWrapMs;
+            this.audio_wrap_log_count_++;
+            if (this.audio_wrap_log_count_ <= 3 || this.audio_wrap_log_count_ % 25 === 0) {
+                Log.w(this.TAG, `[muvie] Audio timestamp wrap normalized (#${this.audio_wrap_log_count_}): ${base_pts_ms}ms -> ${normalized}ms (last=${this.audio_last_sample_pts_}ms)`);
+            }
+            return normalized;
+        }
+
+        if (base_pts_ms > this.audio_last_sample_pts_ + halfWrapMs) {
+            this.audio_stale_drop_log_count_++;
+            if (this.audio_stale_drop_log_count_ <= 3 || this.audio_stale_drop_log_count_ % 25 === 0) {
+                Log.w(this.TAG, `[muvie] Dropping stale pre-wrap audio timestamp (#${this.audio_stale_drop_log_count_}) ${base_pts_ms}ms (last=${this.audio_last_sample_pts_}ms)`);
+            }
+            return undefined;
+        }
+
+        return base_pts_ms;
+    }
+
+    private getStartupAudioAnchorMilliseconds(): number | undefined {
+        if (this.video_track_.samples.length > 0) {
+            return this.video_track_.samples[0].dts;
+        }
+        return undefined;
+    }
+
+    private normalizeStartupAudioPtsMilliseconds(base_pts_ms: number | undefined): number | undefined {
+        if (base_pts_ms == undefined || this.audio_last_sample_pts_ != undefined) {
+            return base_pts_ms;
+        }
+        const anchor = this.getStartupAudioAnchorMilliseconds();
+        if (anchor == undefined) {
+            return base_pts_ms;
+        }
+        const maxStartupDriftMs = 5000;
+        const drift = base_pts_ms - anchor;
+        if (Math.abs(drift) > maxStartupDriftMs) {
+            this.audio_startup_align_log_count_++;
+            if (this.audio_startup_align_log_count_ <= 3 || this.audio_startup_align_log_count_ % 25 === 0) {
+                Log.w(this.TAG, `[muvie] Startup audio anchor normalize (#${this.audio_startup_align_log_count_}): ${base_pts_ms}ms -> ${anchor}ms (video=${anchor}ms drift=${Math.round(drift)}ms)`);
+            }
+            return anchor;
+        }
+        return base_pts_ms;
+    }
+
     private stashAudioBeforeVideoInit(codec: StashedAudioPayload['codec'], data: Uint8Array, pts: number) {
         this.stashed_audio_before_video_init_.push({codec, data, pts});
     }
@@ -1465,9 +1529,22 @@ class TSDemuxer extends BaseDemuxer {
     private dispatchAudioVideoMediaSegment() {
         // Flush any audio that was stashed before video init dispatched.
         if (this.video_init_segment_dispatched_ && this.stashed_audio_before_video_init_.length > 0) {
-            const count = this.stashed_audio_before_video_init_.length;
+            const anchor = this.getStartupAudioAnchorMilliseconds();
+            let stash = this.stashed_audio_before_video_init_;
+            if (anchor != undefined) {
+                const maxStartupLeadMs = 1500;
+                const before = stash.length;
+                stash = stash.filter((item) => item.pts == undefined || (item.pts / this.timescale_) >= (anchor - maxStartupLeadMs));
+                const dropped = before - stash.length;
+                if (dropped > 0) {
+                    this.audio_startup_drop_log_count_++;
+                    if (this.audio_startup_drop_log_count_ <= 3 || this.audio_startup_drop_log_count_ % 25 === 0) {
+                        Log.w(this.TAG, `[muvie] Dropped ${dropped} stale startup audio payload(s) before video anchor ${anchor}ms (#${this.audio_startup_drop_log_count_})`);
+                    }
+                }
+            }
+            const count = stash.length;
             Log.v(this.TAG, `[muvie] Flushing ${count} stashed audio payload(s) now that video init is dispatched`);
-            const stash = this.stashed_audio_before_video_init_;
             this.stashed_audio_before_video_init_ = [];
             for (const item of stash) {
                 switch (item.codec) {
@@ -1558,6 +1635,11 @@ class TSDemuxer extends BaseDemuxer {
 
         if (pts != undefined) {
             base_pts_ms = pts / this.timescale_;
+            base_pts_ms = this.normalizeStartupAudioPtsMilliseconds(base_pts_ms);
+            base_pts_ms = this.normalizeIncomingAudioPtsMilliseconds(base_pts_ms);
+            if (base_pts_ms == undefined) {
+                return;
+            }
         }
         if (this.audio_metadata_.codec === 'aac') {
             if (pts == undefined && this.audio_last_sample_pts_ != undefined) {
@@ -1652,6 +1734,11 @@ class TSDemuxer extends BaseDemuxer {
 
         if (pts != undefined) {
             base_pts_ms = pts / this.timescale_;
+            base_pts_ms = this.normalizeStartupAudioPtsMilliseconds(base_pts_ms);
+            base_pts_ms = this.normalizeIncomingAudioPtsMilliseconds(base_pts_ms);
+            if (base_pts_ms == undefined) {
+                return;
+            }
         }
         if (this.audio_metadata_.codec === 'aac') {
             if (pts == undefined && this.audio_last_sample_pts_ != undefined) {
@@ -1738,6 +1825,11 @@ class TSDemuxer extends BaseDemuxer {
 
         if (pts != undefined) {
             base_pts_ms = pts / this.timescale_;
+            base_pts_ms = this.normalizeStartupAudioPtsMilliseconds(base_pts_ms);
+            base_pts_ms = this.normalizeIncomingAudioPtsMilliseconds(base_pts_ms);
+            if (base_pts_ms == undefined) {
+                return;
+            }
         }
 
         if (this.audio_metadata_.codec === 'ac-3') {
@@ -1811,6 +1903,11 @@ class TSDemuxer extends BaseDemuxer {
 
         if (pts != undefined) {
             base_pts_ms = pts / this.timescale_;
+            base_pts_ms = this.normalizeStartupAudioPtsMilliseconds(base_pts_ms);
+            base_pts_ms = this.normalizeIncomingAudioPtsMilliseconds(base_pts_ms);
+            if (base_pts_ms == undefined) {
+                return;
+            }
         }
 
         if (this.audio_metadata_.codec === 'ec-3') {
@@ -1884,6 +1981,11 @@ class TSDemuxer extends BaseDemuxer {
 
         if (pts != undefined) {
             base_pts_ms = pts / this.timescale_;
+            base_pts_ms = this.normalizeStartupAudioPtsMilliseconds(base_pts_ms);
+            base_pts_ms = this.normalizeIncomingAudioPtsMilliseconds(base_pts_ms);
+            if (base_pts_ms == undefined) {
+                return;
+            }
         }
         if (this.audio_metadata_.codec === 'opus') {
             if (pts == undefined && this.audio_last_sample_pts_ != undefined) {
@@ -1961,7 +2063,6 @@ class TSDemuxer extends BaseDemuxer {
         let bit_rate = 0;
         let object_type = 34;  // Layer-3, listed in MPEG-4 Audio Object Types
 
-        let codec = 'mp3';
         switch (ver) {
             case 0:  // MPEG 2.5
                 sample_rate = _mpegAudioV25SampleRateTable[sampling_freq_index];
@@ -2005,6 +2106,16 @@ class TSDemuxer extends BaseDemuxer {
             data: sample
         } as const;
 
+        let pts_ms: number | undefined;
+        if (pts != undefined) {
+            pts_ms = pts / this.timescale_;
+            pts_ms = this.normalizeStartupAudioPtsMilliseconds(pts_ms);
+            pts_ms = this.normalizeIncomingAudioPtsMilliseconds(pts_ms);
+            if (pts_ms == undefined) {
+                return;
+            }
+        }
+
 
         if (this.audio_init_segment_dispatched_ == false) {
             this.audio_metadata_ = {
@@ -2024,8 +2135,8 @@ class TSDemuxer extends BaseDemuxer {
         let mp3_sample = {
             unit: data,
             length: data.byteLength,
-            pts: pts / this.timescale_,
-            dts: pts / this.timescale_
+            pts: pts_ms,
+            dts: pts_ms
         };
         this.audio_track_.samples.push(mp3_sample);
         this.audio_track_.length += data.byteLength;

package/src/remux/mp4-remuxer.js

@@ -65,6 +65,8 @@ class MP4Remuxer {
         this._mp3UseMpegAudio = !Browser.firefox;
 
         this._fillAudioTimestampGap = this._config.fixAudioTimestampGap;
+        this._audioDiscontinuityResetLogCount = 0;
+        this._audioGapFillLogCount = 0;
     }
 
     destroy() {
@@ -86,6 +88,11 @@ class MP4Remuxer {
         return this;
     }
 
+    _shouldLogLimited(counterName) {
+        this[counterName] = (this[counterName] || 0) + 1;
+        return this[counterName] <= 3 || this[counterName] % 25 === 0;
+    }
+
     /* prototype: function onInitSegment(type: string, initSegment: ArrayBuffer): void
        InitSegment: {
            type: string,
@@ -251,6 +258,10 @@ class MP4Remuxer {
         let dtsCorrection = undefined;
         let firstDts = -1, lastDts = -1, lastPts = -1;
         let refSampleDuration = this._audioMeta.refSampleDuration;
+        const hardDiscontinuityThreshold = Math.max(
+            30000,
+            refSampleDuration != null ? refSampleDuration * 180 : 30000
+        );
 
         let mpegRawTrack = this._audioMeta.codec === 'mp3' && this._mp3UseMpegAudio;
         let firstSegmentAfterSeek = this._dtsBaseInited && this._audioNextDts === undefined;
@@ -376,19 +387,35 @@ class MP4Remuxer {
 
                 dtsCorrection = originalDts - curRefDts;
                 if (dtsCorrection <= -maxAudioFramesDrift * refSampleDuration) {
+                    if (Math.abs(dtsCorrection) > hardDiscontinuityThreshold) {
+                        if (this._shouldLogLimited('_audioDiscontinuityResetLogCount')) {
+                            Log.w(this.TAG, `Audio discontinuity reset (#${this._audioDiscontinuityResetLogCount}): backward ${Math.round(dtsCorrection)} ms, codec=${this._audioMeta.codec}`);
+                        }
+                        dts = Math.floor(originalDts);
+                        sampleDuration = Math.floor(refSampleDuration);
+                        this._audioNextDts = dts + sampleDuration;
+                    } else {
                     // If we're overlapping by more than maxAudioFramesDrift number of frame, drop this sample
-                    Log.w(this.TAG, `Dropping 1 audio frame (originalDts: ${originalDts} ms ,curRefDts: ${curRefDts} ms)  due to dtsCorrection: ${dtsCorrection} ms overlap.`);
-                    continue;
+                        Log.w(this.TAG, `Dropping 1 audio frame (originalDts: ${originalDts} ms ,curRefDts: ${curRefDts} ms)  due to dtsCorrection: ${dtsCorrection} ms overlap.`);
+                        continue;
+                    }
                 }
                 else if (dtsCorrection >= maxAudioFramesDrift * refSampleDuration && this._fillAudioTimestampGap && !Browser.safari) {
                     // Silent frame generation, if large timestamp gap detected && config.fixAudioTimestampGap
+                    let frameCount = Math.floor(dtsCorrection / refSampleDuration);
+                    if (frameCount > 180 || dtsCorrection > hardDiscontinuityThreshold) {
+                        if (this._shouldLogLimited('_audioDiscontinuityResetLogCount')) {
+                            Log.w(this.TAG, `Audio discontinuity reset (#${this._audioDiscontinuityResetLogCount}): forward ${Math.round(dtsCorrection)} ms, frames=${frameCount}, codec=${this._audioMeta.codec}`);
+                        }
+                        dts = Math.floor(originalDts);
+                        sampleDuration = Math.floor(refSampleDuration);
+                        this._audioNextDts = dts + sampleDuration;
+                    } else {
                     needFillSilentFrames = true;
                     // We need to insert silent frames to fill timestamp gap
-                    let frameCount = Math.floor(dtsCorrection / refSampleDuration);
-                    Log.w(this.TAG, 'Large audio timestamp gap detected, may cause AV sync to drift. ' +
-                        'Silent frames will be generated to avoid unsync.\n' +
-                        `originalDts: ${originalDts} ms, curRefDts: ${curRefDts} ms, ` +
-                        `dtsCorrection: ${Math.round(dtsCorrection)} ms, generate: ${frameCount} frames`);
+                    if (this._shouldLogLimited('_audioGapFillLogCount')) {
+                        Log.w(this.TAG, `Audio gap fill (#${this._audioGapFillLogCount}): correction=${Math.round(dtsCorrection)} ms, frames=${frameCount}, codec=${this._audioMeta.codec}`);
+                    }
 
 
                     dts = Math.floor(curRefDts);
@@ -428,6 +455,7 @@ class MP4Remuxer {
                     }
 
                     this._audioNextDts = curRefDts + refSampleDuration;
+                    }
 
                 } else {
 
@@ -478,7 +506,9 @@ class MP4Remuxer {
 
             if (needFillSilentFrames) {
                 // Silent frames should be inserted after wrong-duration frame
-                mp4Samples.push.apply(mp4Samples, silentFrames);
+                for (let j = 0; j < silentFrames.length; j++) {
+                    mp4Samples.push(silentFrames[j]);
+                }
             }
         }