hls.js 1.6.0-beta.1.0.canary.10750 → 1.6.0-beta.1.0.canary.10752

package/package.json

@@ -130,5 +130,5 @@
     "url-toolkit": "2.2.5",
     "wrangler": "3.85.0"
   },
-  "version": "1.6.0-beta.1.0.canary.10750"
+  "version": "1.6.0-beta.1.0.canary.10752"
 }

package/src/controller/abr-controller.ts

@@ -285,9 +285,10 @@ class AbrController extends Logger implements AbrComponentAPI {
     const bwEstimate: number = this.getBwEstimate();
     const levels = hls.levels;
     const level = levels[frag.level];
-    const expectedLen =
-      stats.total ||
-      Math.max(stats.loaded, Math.round((duration * level.averageBitrate) / 8));
+    const expectedLen = Math.max(
+      stats.loaded,
+      Math.round((duration * (frag.bitrate || level.averageBitrate)) / 8),
+    );
     let timeStreaming = loadedFirstByte ? timeLoading - ttfb : timeLoading;
     if (timeStreaming < 1 && loadedFirstByte) {
       timeStreaming = Math.min(timeLoading, (stats.loaded * 8) / bwEstimate);
@@ -880,8 +881,8 @@ class AbrController extends Logger implements AbrComponentAPI {
         currentFragDuration &&
         bufferStarvationDelay >= currentFragDuration * 2 &&
         maxStarvationDelay === 0
-          ? levels[i].averageBitrate
-          : levels[i].maxBitrate;
+          ? levelInfo.averageBitrate
+          : levelInfo.maxBitrate;
       const fetchDuration: number = this.getTimeToLoadFrag(
         ttfbEstimateSec,
         adjustedbw,

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

@@ -477,18 +477,19 @@ export default class BaseStreamController
   }
 
   private _loadFragForPlayback(
-    frag: Fragment,
+    fragment: Fragment,
     level: Level,
     targetBufferTime: number,
   ) {
     const progressCallback: FragmentLoadProgressCallback = (
       data: FragLoadedData,
     ) => {
+      const frag = data.frag;
       if (this.fragContextChanged(frag)) {
         this.warn(
-          `Fragment ${frag.sn}${
-            data.part ? ' p: ' + data.part.index : ''
-          } of level ${frag.level} was dropped during download.`,
+          `${frag.type} sn: ${frag.sn}${
+            data.part ? ' part: ' + data.part.index : ''
+          } of ${this.fragInfo(frag, false, data.part)}) was dropped during download.`,
         );
         this.fragmentTracker.removeFragment(frag);
         return;
@@ -497,13 +498,14 @@ export default class BaseStreamController
       this._handleFragmentLoadProgress(data);
     };
 
-    this._doFragLoad(frag, level, targetBufferTime, progressCallback)
+    this._doFragLoad(fragment, level, targetBufferTime, progressCallback)
       .then((data) => {
         if (!data) {
           // if we're here we probably needed to backtrack or are waiting for more parts
           return;
         }
         const state = this.state;
+        const frag = data.frag;
         if (this.fragContextChanged(frag)) {
           if (
             state === State.FRAG_LOADING ||
@@ -530,7 +532,7 @@ export default class BaseStreamController
           return;
         }
         this.warn(`Frag error: ${reason?.message || reason}`);
-        this.resetFragmentLoading(frag);
+        this.resetFragmentLoading(fragment);
       });
   }
 
@@ -608,10 +610,11 @@ export default class BaseStreamController
     this.hls.trigger(Events.BUFFER_FLUSHING, flushScope);
   }
 
-  protected _loadInitSegment(frag: Fragment, level: Level) {
-    this._doFragLoad(frag, level)
+  protected _loadInitSegment(fragment: Fragment, level: Level) {
+    this._doFragLoad(fragment, level)
       .then((data) => {
-        if (!data || this.fragContextChanged(frag) || !this.levels) {
+        const frag = data?.frag;
+        if (!frag || this.fragContextChanged(frag) || !this.levels) {
           throw new Error('init load aborted');
         }
 
@@ -619,7 +622,7 @@ export default class BaseStreamController
       })
       .then((data: FragLoadedData) => {
         const { hls } = this;
-        const { payload } = data;
+        const { frag, payload } = data;
         const decryptData = frag.decryptdata;
 
         // check to see if the payload needs to be decrypted
@@ -671,7 +674,7 @@ export default class BaseStreamController
           return;
         }
         this.warn(reason);
-        this.resetFragmentLoading(frag);
+        this.resetFragmentLoading(fragment);
       });
   }
 
@@ -705,7 +708,7 @@ export default class BaseStreamController
     this.log(
       `Buffered ${frag.type} sn: ${frag.sn}${
         part ? ' part: ' + part.index : ''
-      } of ${this.fragInfo(frag)} > buffer:${
+      } of ${this.fragInfo(frag, false, part)} > buffer:${
         media
           ? TimeRanges.toString(BufferHelper.getBuffered(media))
           : '(detached)'
@@ -823,12 +826,11 @@ export default class BaseStreamController
         const partIndex = this.getNextPart(partList, frag, targetBufferTime);
         if (partIndex > -1) {
           const part = partList[partIndex];
+          frag = this.fragCurrent = part.fragment;
           this.log(
-            `Loading part sn: ${frag.sn} p: ${part.index} cc: ${
+            `Loading ${frag.type} sn: ${frag.sn} part: ${part.index} (${partIndex}/${partList.length - 1}) of ${this.fragInfo(frag, false, part)}) cc: ${
               frag.cc
-            } of playlist [${details.startSN}-${
-              details.endSN
-            }] parts [0-${partIndex}-${partList.length - 1}] ${this.playlistLabel()}: ${frag.level}, target: ${parseFloat(
+            } [${details.startSN}-${details.endSN}], target: ${parseFloat(
               targetBufferTime.toFixed(3),
             )}`,
           );
@@ -1947,7 +1949,7 @@ export default class BaseStreamController
     this.log(
       `Parsed ${frag.type} sn: ${frag.sn}${
         part ? ' part: ' + part.index : ''
-      } of ${this.fragInfo(frag)})`,
+      } of ${this.fragInfo(frag, false, part)})`,
     );
     this.hls.trigger(Events.FRAG_PARSED, { frag, part });
   }
@@ -1956,10 +1958,16 @@ export default class BaseStreamController
     return this.playlistType === PlaylistLevelType.MAIN ? 'level' : 'track';
   }
 
-  private fragInfo(frag: Fragment, pts: boolean = true): string {
-    return `${this.playlistLabel()} ${frag.level} (frag:[${((pts ? frag.startPTS : frag.start) ?? NaN).toFixed(3)}-${(
-      (pts ? frag.endPTS : frag.end) ?? NaN
-    ).toFixed(3)}]`;
+  private fragInfo(
+    frag: Fragment,
+    pts: boolean = true,
+    part?: Part | null,
+  ): string {
+    return `${this.playlistLabel()} ${frag.level} (${part ? 'part' : 'frag'}:[${((pts && !part ? frag.startPTS : (part || frag).start) ?? NaN).toFixed(3)}-${(
+      (pts && !part ? frag.endPTS : (part || frag).end) ?? NaN
+    ).toFixed(
+      3,
+    )}]${part && frag.type === 'main' ? 'INDEPENDENT=' + (part.independent ? 'YES' : 'NO') : ''}`;
   }
 
   protected resetTransmuxer() {

package/src/controller/stream-controller.ts

@@ -1151,11 +1151,12 @@ export default class StreamController
     return audioCodec;
   }
 
-  private _loadBitrateTestFrag(frag: Fragment, level: Level) {
-    frag.bitrateTest = true;
-    this._doFragLoad(frag, level).then((data) => {
+  private _loadBitrateTestFrag(fragment: Fragment, level: Level) {
+    fragment.bitrateTest = true;
+    this._doFragLoad(fragment, level).then((data) => {
       const { hls } = this;
-      if (!data || this.fragContextChanged(frag)) {
+      const frag = data?.frag;
+      if (!frag || this.fragContextChanged(frag)) {
         return;
       }
       level.fragmentError = 0;

package/src/demux/transmuxer-interface.ts

@@ -12,13 +12,13 @@ import Transmuxer, {
 } from '../demux/transmuxer';
 import { ErrorDetails, ErrorTypes } from '../errors';
 import { Events } from '../events';
+import { PlaylistLevelType } from '../types/loader';
 import { getM2TSSupportedAudioTypes } from '../utils/codecs';
 import type { WorkerContext } from './inject-worker';
 import type { HlsEventEmitter, HlsListeners } from '../events';
 import type Hls from '../hls';
 import type { MediaFragment, Part } from '../loader/fragment';
 import type { ErrorData, FragDecryptedData } from '../types/events';
-import type { PlaylistLevelType } from '../types/loader';
 import type { ChunkMetadata, TransmuxerResult } from '../types/transmuxer';
 import type { RationalTimestamp } from '../utils/timescale-conversion';
 
@@ -234,7 +234,9 @@ export default class TransmuxerInterface {
     );
     if (!contiguous || discontinuity || initSegmentChange) {
       this.hls.logger
-        .log(`[transmuxer-interface, ${frag.type}]: Starting new transmux session for sn: ${chunkMeta.sn} p: ${chunkMeta.part} level: ${chunkMeta.level} id: ${chunkMeta.id}
+        .log(`[transmuxer-interface]: Starting new transmux session for ${frag.type} sn: ${chunkMeta.sn}${
+        chunkMeta.part > -1 ? ' part: ' + chunkMeta.part : ''
+      } ${this.id === PlaylistLevelType.MAIN ? 'level' : 'track'}: ${chunkMeta.level} id: ${chunkMeta.id}
         discontinuity: ${discontinuity}
         trackSwitch: ${trackSwitch}
         contiguous: ${contiguous}

package/src/demux/transmuxer.ts

@@ -290,7 +290,7 @@ export default class Transmuxer {
     const { accurateTimeOffset, timeOffset } = this.currentTransmuxState;
     this.logger.log(
       `[transmuxer.ts]: Flushed ${this.id} sn: ${chunkMeta.sn}${
-        chunkMeta.part > -1 ? ' p: ' + chunkMeta.part : ''
+        chunkMeta.part > -1 ? ' part: ' + chunkMeta.part : ''
       } of ${this.id === PlaylistLevelType.MAIN ? 'level' : 'track'} ${chunkMeta.level}`,
     );
     const remuxResult = this.remuxer!.remux(

package/src/loader/fragment-loader.ts

@@ -1,7 +1,7 @@
 import { ErrorDetails, ErrorTypes } from '../errors';
 import { getLoaderConfigWithoutReties } from '../utils/error-helper';
-import type { HlsConfig } from '../config';
 import type { BaseSegment, Fragment, Part } from './fragment';
+import type { HlsConfig } from '../config';
 import type {
   ErrorData,
   FragLoadedData,

package/src/loader/fragment.ts

@@ -159,6 +159,8 @@ export class Fragment extends BaseSegment {
   private _decryptdata: LevelKey | null = null;
   private _programDateTime: number | null = null;
   private _ref: MediaFragmentRef | null = null;
+  // Approximate bit rate of the fragment expressed in bits per second (bps) as indicated by the last EXT-X-BITRATE (kbps) tag
+  private _bitrate?: number;
 
   public rawProgramDateTime: string | null = null;
   public tagList: Array<string[]> = [];
@@ -219,6 +221,37 @@ export class Fragment extends BaseSegment {
     this.type = type;
   }
 
+  get byteLength(): number | null {
+    if (this.hasStats) {
+      const total = this.stats.total;
+      if (total) {
+        return total;
+      }
+    }
+    if (this.byteRange) {
+      const start = this.byteRange[0];
+      const end = this.byteRange[1];
+      if (Number.isFinite(start) && Number.isFinite(end)) {
+        return (end as number) - (start as number);
+      }
+    }
+    return null;
+  }
+
+  get bitrate(): number | null {
+    if (this.byteLength) {
+      return (this.byteLength * 8) / this.duration;
+    }
+    if (this._bitrate) {
+      return this._bitrate;
+    }
+    return null;
+  }
+
+  set bitrate(value: number) {
+    this._bitrate = value;
+  }
+
   get decryptdata(): LevelKey | null {
     const { levelkeys } = this;
     if (!levelkeys && !this._decryptdata) {

package/src/loader/m3u8-parser.ts

@@ -314,6 +314,7 @@ export default class M3U8Parser {
     let currentPart = 0;
     let totalduration = 0;
     let discontinuityCounter = 0;
+    let currentBitrate = 0;
     let prevFrag: Fragment | null = null;
     let frag: Fragment = new Fragment(type, base);
     let result: RegExpExecArray | RegExpMatchArray | null;
@@ -338,6 +339,9 @@ export default class M3U8Parser {
         frag.start = totalduration;
         frag.sn = currentSN;
         frag.cc = discontinuityCounter;
+        if (currentBitrate) {
+          frag.bitrate = currentBitrate;
+        }
         frag.level = id;
         if (currentInitSegment) {
           frag.initSegment = currentInitSegment;
@@ -481,6 +485,12 @@ export default class M3U8Parser {
             break;
           case 'BITRATE':
             frag.tagList.push([tag, value1]);
+            currentBitrate = parseInt(value1) * 1000;
+            if (Number.isFinite(currentBitrate)) {
+              frag.bitrate = currentBitrate;
+            } else {
+              currentBitrate = 0;
+            }
             break;
           case 'DATERANGE': {
             const dateRangeAttr = new AttrList(value1, level);