hls.js 1.5.13-0.canary.10408 → 1.5.13-0.canary.10411

package/package.json

@@ -130,5 +130,5 @@
     "url-toolkit": "2.2.5",
     "wrangler": "3.62.0"
   },
-  "version": "1.5.13-0.canary.10408"
+  "version": "1.5.13-0.canary.10411"
 }

package/src/controller/audio-stream-controller.ts

@@ -403,18 +403,34 @@ class AudioStreamController
       return;
     }
 
+    // Request audio segments up to one fragment ahead of main stream-controller
+    const mainFragLoading = this.mainFragLoading?.frag;
     if (
       this.startFragRequested &&
-      (!trackDetails.live || targetBufferTime < this.hls.liveSyncPosition!)
+      mainFragLoading &&
+      mainFragLoading.sn !== 'initSegment' &&
+      frag.sn !== 'initSegment' &&
+      !frag.endList &&
+      (!trackDetails.live ||
+        (!this.loadingParts && targetBufferTime < this.hls.liveSyncPosition!))
     ) {
-      // Request audio segments up to one fragment ahead of main buffer
-      const mainFragLoading = this.mainFragLoading;
-      const mainTargetBufferEnd = mainFragLoading
-        ? (mainFragLoading.part || mainFragLoading.frag).end
-        : null;
-      const atBufferSyncLimit =
-        mainTargetBufferEnd !== null && frag.start > mainTargetBufferEnd;
-      if (atBufferSyncLimit && !frag.endList) {
+      let mainFrag = mainFragLoading;
+      if (frag.start > mainFrag.end) {
+        // Get buffered frag at target position from tracker (loaded out of sequence)
+        const mainFragAtPos = this.fragmentTracker.getFragAtPos(
+          targetBufferTime,
+          PlaylistLevelType.MAIN,
+        );
+        if (mainFragAtPos && mainFragAtPos.end > mainFragLoading.end) {
+          mainFrag = mainFragAtPos;
+          this.mainFragLoading = {
+            frag: mainFragAtPos,
+            targetBufferTime: null,
+          };
+        }
+      }
+      const atBufferSyncLimit = frag.start > mainFrag.end;
+      if (atBufferSyncLimit) {
         return;
       }
     }

package/src/controller/base-stream-controller.ts

@@ -101,7 +101,7 @@ export default class BaseStreamController
   protected decrypter: Decrypter;
   protected initPTS: RationalTimestamp[] = [];
   protected buffering: boolean = true;
-  private loadingParts: boolean = false;
+  protected loadingParts: boolean = false;
   private loopSn?: string | number;
 
   constructor(

package/src/remux/mp4-remuxer.ts

@@ -1069,56 +1069,6 @@ export default class MP4Remuxer implements Remuxer {
     this.isAudioContiguous = true;
     return audioData;
   }
-
-  remuxEmptyAudio(
-    track: DemuxedAudioTrack,
-    timeOffset: number,
-    contiguous: boolean,
-    videoData: Fragment,
-  ): RemuxedTrack | undefined {
-    const inputTimeScale: number = track.inputTimeScale;
-    const mp4timeScale: number = track.samplerate
-      ? track.samplerate
-      : inputTimeScale;
-    const scaleFactor: number = inputTimeScale / mp4timeScale;
-    const nextAudioPts: number | null = this.nextAudioPts;
-    // sync with video's timestamp
-    const initDTS = this._initDTS as RationalTimestamp;
-    const init90kHz = (initDTS.baseTime * 90000) / initDTS.timescale;
-    const startDTS: number =
-      (nextAudioPts !== null
-        ? nextAudioPts
-        : (videoData.startDTS as number) * inputTimeScale) + init90kHz;
-    const endDTS: number =
-      (videoData.endDTS as number) * inputTimeScale + init90kHz;
-    // one sample's duration value
-    const frameDuration: number = scaleFactor * AAC_SAMPLES_PER_FRAME;
-    // samples count of this segment's duration
-    const nbSamples: number = Math.ceil((endDTS - startDTS) / frameDuration);
-    // silent frame
-    const silentFrame: Uint8Array | undefined = AAC.getSilentFrame(
-      track.parsedCodec || track.manifestCodec || track.codec,
-      track.channelCount,
-    );
-
-    logger.warn('[mp4-remuxer]: remux empty Audio');
-    // Can't remux if we can't generate a silent frame...
-    if (!silentFrame) {
-      logger.trace(
-        '[mp4-remuxer]: Unable to remuxEmptyAudio since we were unable to get a silent frame for given audio codec',
-      );
-      return;
-    }
-
-    const samples: Array<any> = [];
-    for (let i = 0; i < nbSamples; i++) {
-      const stamp = startDTS + i * frameDuration;
-      samples.push({ unit: silentFrame, pts: stamp, dts: stamp });
-    }
-    track.samples = samples;
-
-    return this.remuxAudio(track, timeOffset, contiguous, false);
-  }
 }
 
 export function normalizePts(value: number, reference: number | null): number {

package/src/utils/codecs.ts

@@ -206,16 +206,20 @@ export function pickMostCompleteCodecName(
 
 export function convertAVC1ToAVCOTI(codec: string) {
   // Convert avc1 codec string from RFC-4281 to RFC-6381 for MediaSource.isTypeSupported
-  const avcdata = codec.split('.');
-  if (avcdata.length > 2) {
-    let result = avcdata.shift() + '.';
-    result += parseInt(avcdata.shift() as string).toString(16);
-    result += ('000' + parseInt(avcdata.shift() as string).toString(16)).slice(
-      -4,
-    );
-    return result;
+  // Examples: avc1.66.30 to avc1.42001e and avc1.77.30,avc1.66.30 to avc1.4d001e,avc1.42001e.
+  const codecs = codec.split(',');
+  for (let i = 0; i < codecs.length; i++) {
+    const avcdata = codecs[i].split('.');
+    if (avcdata.length > 2) {
+      let result = avcdata.shift() + '.';
+      result += parseInt(avcdata.shift() as string).toString(16);
+      result += (
+        '000' + parseInt(avcdata.shift() as string).toString(16)
+      ).slice(-4);
+      codecs[i] = result;
+    }
   }
-  return codec;
+  return codecs.join(',');
 }
 
 export interface TypeSupported {