hls.js 1.5.7-0.canary.10040 → 1.5.7

package/src/remux/mp4-generator.ts

@@ -28,8 +28,6 @@ class MP4 {
     MP4.types = {
       avc1: [], // codingname
       avcC: [],
-      hvc1: [],
-      hvcC: [],
       btrt: [],
       dinf: [],
       dref: [],
@@ -841,10 +839,8 @@ class MP4 {
         return MP4.box(MP4.types.stsd, MP4.STSD, MP4.ac3(track));
       }
       return MP4.box(MP4.types.stsd, MP4.STSD, MP4.mp4a(track));
-    } else if (track.segmentCodec === 'avc') {
-      return MP4.box(MP4.types.stsd, MP4.STSD, MP4.avc1(track));
     } else {
-      return MP4.box(MP4.types.stsd, MP4.STSD, MP4.hvc1(track));
+      return MP4.box(MP4.types.stsd, MP4.STSD, MP4.avc1(track));
     }
   }
 
@@ -1127,197 +1123,6 @@ class MP4 {
     const result = appendUint8Array(MP4.FTYP, movie);
     return result;
   }
-
-  static hvc1(track) {
-    const ps = track.params;
-    const units = [track.vps, track.sps, track.pps];
-    const NALuLengthSize = 4;
-    const config = new Uint8Array([
-      0x01,
-      (ps.general_profile_space << 6) |
-        (ps.general_tier_flag ? 32 : 0) |
-        ps.general_profile_idc,
-      ps.general_profile_compatibility_flags[0],
-      ps.general_profile_compatibility_flags[1],
-      ps.general_profile_compatibility_flags[2],
-      ps.general_profile_compatibility_flags[3],
-      ps.general_constraint_indicator_flags[0],
-      ps.general_constraint_indicator_flags[1],
-      ps.general_constraint_indicator_flags[2],
-      ps.general_constraint_indicator_flags[3],
-      ps.general_constraint_indicator_flags[4],
-      ps.general_constraint_indicator_flags[5],
-      ps.general_level_idc,
-      240 | (ps.min_spatial_segmentation_idc >> 8),
-      255 & ps.min_spatial_segmentation_idc,
-      252 | ps.parallelismType,
-      252 | ps.chroma_format_idc,
-      248 | ps.bit_depth_luma_minus8,
-      248 | ps.bit_depth_chroma_minus8,
-      0x00,
-      parseInt(ps.frame_rate.fps),
-      (NALuLengthSize - 1) |
-        (ps.temporal_id_nested << 2) |
-        (ps.num_temporal_layers << 3) |
-        (ps.frame_rate.fixed ? 64 : 0),
-      units.length,
-    ]);
-
-    // compute hvcC size in bytes
-    let length = config.length;
-    for (let i = 0; i < units.length; i += 1) {
-      length += 3;
-      for (let j = 0; j < units[i].length; j += 1) {
-        length += 2 + units[i][j].length;
-      }
-    }
-
-    const hvcC = new Uint8Array(length);
-    hvcC.set(config, 0);
-    length = config.length;
-    // append parameter set units: one vps, one or more sps and pps
-    const iMax = units.length - 1;
-    for (let i = 0; i < units.length; i += 1) {
-      hvcC.set(
-        new Uint8Array([
-          (32 + i) | (i === iMax ? 128 : 0),
-          0x00,
-          units[i].length,
-        ]),
-        length,
-      );
-      length += 3;
-      for (let j = 0; j < units[i].length; j += 1) {
-        hvcC.set(
-          new Uint8Array([units[i][j].length >> 8, units[i][j].length & 255]),
-          length,
-        );
-        length += 2;
-        hvcC.set(units[i][j], length);
-        length += units[i][j].length;
-      }
-    }
-    const hvcc = MP4.box(MP4.types.hvcC, hvcC);
-    const width = track.width;
-    const height = track.height;
-    const hSpacing = track.pixelRatio[0];
-    const vSpacing = track.pixelRatio[1];
-
-    return MP4.box(
-      MP4.types.hvc1,
-      new Uint8Array([
-        0x00,
-        0x00,
-        0x00, // reserved
-        0x00,
-        0x00,
-        0x00, // reserved
-        0x00,
-        0x01, // data_reference_index
-        0x00,
-        0x00, // pre_defined
-        0x00,
-        0x00, // reserved
-        0x00,
-        0x00,
-        0x00,
-        0x00,
-        0x00,
-        0x00,
-        0x00,
-        0x00,
-        0x00,
-        0x00,
-        0x00,
-        0x00, // pre_defined
-        (width >> 8) & 0xff,
-        width & 0xff, // width
-        (height >> 8) & 0xff,
-        height & 0xff, // height
-        0x00,
-        0x48,
-        0x00,
-        0x00, // horizresolution
-        0x00,
-        0x48,
-        0x00,
-        0x00, // vertresolution
-        0x00,
-        0x00,
-        0x00,
-        0x00, // reserved
-        0x00,
-        0x01, // frame_count
-        0x12,
-        0x64,
-        0x61,
-        0x69,
-        0x6c, // dailymotion/hls.js
-        0x79,
-        0x6d,
-        0x6f,
-        0x74,
-        0x69,
-        0x6f,
-        0x6e,
-        0x2f,
-        0x68,
-        0x6c,
-        0x73,
-        0x2e,
-        0x6a,
-        0x73,
-        0x00,
-        0x00,
-        0x00,
-        0x00,
-        0x00,
-        0x00,
-        0x00,
-        0x00,
-        0x00,
-        0x00,
-        0x00,
-        0x00,
-        0x00, // compressorname
-        0x00,
-        0x18, // depth = 24
-        0x11,
-        0x11,
-      ]), // pre_defined = -1
-      hvcc,
-      MP4.box(
-        MP4.types.btrt,
-        new Uint8Array([
-          0x00,
-          0x1c,
-          0x9c,
-          0x80, // bufferSizeDB
-          0x00,
-          0x2d,
-          0xc6,
-          0xc0, // maxBitrate
-          0x00,
-          0x2d,
-          0xc6,
-          0xc0,
-        ]),
-      ), // avgBitrate
-      MP4.box(
-        MP4.types.pasp,
-        new Uint8Array([
-          hSpacing >> 24, // hSpacing
-          (hSpacing >> 16) & 0xff,
-          (hSpacing >> 8) & 0xff,
-          hSpacing & 0xff,
-          vSpacing >> 24, // vSpacing
-          (vSpacing >> 16) & 0xff,
-          (vSpacing >> 8) & 0xff,
-          vSpacing & 0xff,
-        ]),
-      ),
-    );
-  }
 }
 
 export default MP4;

package/src/remux/mp4-remuxer.ts

@@ -29,7 +29,6 @@ import type { TrackSet } from '../types/track';
 import type { SourceBufferName } from '../types/buffer';
 import type { Fragment } from '../loader/fragment';
 import type { HlsConfig } from '../config';
-import type { TypeSupported } from '../utils/codecs';
 
 const MAX_SILENT_FRAME_DURATION = 10 * 1000; // 10 seconds
 const AAC_SAMPLES_PER_FRAME = 1024;
@@ -42,7 +41,7 @@ let safariWebkitVersion: number | null = null;
 export default class MP4Remuxer implements Remuxer {
   private observer: HlsEventEmitter;
   private config: HlsConfig;
-  private typeSupported: TypeSupported;
+  private typeSupported: any;
   private ISGenerated: boolean = false;
   private _initPTS: RationalTimestamp | null = null;
   private _initDTS: RationalTimestamp | null = null;
@@ -516,7 +515,7 @@ export default class MP4Remuxer implements Remuxer {
       if (foundHole || foundOverlap) {
         if (foundHole) {
           logger.warn(
-            `${(track.segmentCodec || '').toUpperCase()}: ${toMsFromMpegTsClock(
+            `AVC: ${toMsFromMpegTsClock(
               delta,
               true,
             )} ms (${delta}dts) hole between fragments detected at ${timeOffset.toFixed(
@@ -525,7 +524,7 @@ export default class MP4Remuxer implements Remuxer {
           );
         } else {
           logger.warn(
-            `${(track.segmentCodec || '').toUpperCase()}: ${toMsFromMpegTsClock(
+            `AVC: ${toMsFromMpegTsClock(
               -delta,
               true,
             )} ms (${delta}dts) overlapping between fragments detected at ${timeOffset.toFixed(
@@ -544,27 +543,12 @@ export default class MP4Remuxer implements Remuxer {
             inputSamples[0].dts = firstDTS;
             inputSamples[0].pts = firstPTS;
           } else {
-            let isPTSOrderRetained = true;
             for (let i = 0; i < inputSamples.length; i++) {
-              if (inputSamples[i].dts > firstPTS && isPTSOrderRetained) {
+              if (inputSamples[i].dts > firstPTS) {
                 break;
               }
-
-              const prevPTS = inputSamples[i].pts;
               inputSamples[i].dts -= delta;
               inputSamples[i].pts -= delta;
-
-              // check to see if this sample's PTS order has changed
-              // relative to the next one
-              if (i < inputSamples.length - 1) {
-                const nextSamplePTS = inputSamples[i + 1].pts;
-                const currentSamplePTS = inputSamples[i].pts;
-
-                const currentOrder = nextSamplePTS <= currentSamplePTS;
-                const prevOrder = nextSamplePTS <= prevPTS;
-
-                isPTSOrderRetained = currentOrder == prevOrder;
-              }
             }
           }
           logger.log(
@@ -759,7 +743,7 @@ export default class MP4Remuxer implements Remuxer {
         }
       }
     }
-    // next AVC/HEVC sample DTS should be equal to last sample DTS + last sample duration (in PES timescale)
+    // next AVC sample DTS should be equal to last sample DTS + last sample duration (in PES timescale)
     mp4SampleDuration =
       stretchedLastFrame || !mp4SampleDuration
         ? averageSampleDuration
@@ -943,7 +927,7 @@ export default class MP4Remuxer implements Remuxer {
           for (let j = 0; j < missing; j++) {
             const newStamp = Math.max(nextPts as number, 0);
             let fillFrame = AAC.getSilentFrame(
-              track.parsedCodec || track.manifestCodec || track.codec,
+              track.manifestCodec || track.codec,
               track.channelCount,
             );
             if (!fillFrame) {
@@ -1093,7 +1077,7 @@ export default class MP4Remuxer implements Remuxer {
     const nbSamples: number = Math.ceil((endDTS - startDTS) / frameDuration);
     // silent frame
     const silentFrame: Uint8Array | undefined = AAC.getSilentFrame(
-      track.parsedCodec || track.manifestCodec || track.codec,
+      track.manifestCodec || track.codec,
       track.channelCount,
     );
 

package/src/task-loop.ts

@@ -1,5 +1,3 @@
-import { type ILogger, Logger } from './utils/logger';
-
 /**
  * @ignore
  * Sub-class specialization of EventHandler base class.
@@ -29,14 +27,13 @@ import { type ILogger, Logger } from './utils/logger';
  * we are limiting the task execution per call stack to exactly one, but scheduling/post-poning further
  * task processing on the next main loop iteration (also known as "next tick" in the Node/JS runtime lingo).
  */
-export default class TaskLoop extends Logger {
+export default class TaskLoop {
   private readonly _boundTick: () => void;
   private _tickTimer: number | null = null;
   private _tickInterval: number | null = null;
   private _tickCallCount = 0;
 
-  constructor(label: string, logger: ILogger) {
-    super(label, logger);
+  constructor() {
     this._boundTick = this.tick.bind(this);
   }
 

package/src/types/component-api.ts

@@ -15,6 +15,4 @@ export interface AbrComponentAPI extends ComponentAPI {
 export interface NetworkComponentAPI extends ComponentAPI {
   startLoad(startPosition: number): void;
   stopLoad(): void;
-  pauseBuffering?(): void;
-  resumeBuffering?(): void;
 }

package/src/types/demuxer.ts

@@ -64,7 +64,6 @@ export interface DemuxedAudioTrack extends DemuxedTrack {
   segmentCodec?: string;
   channelCount?: number;
   manifestCodec?: string;
-  parsedCodec?: string;
   samples: AudioSample[];
 }
 
@@ -73,14 +72,12 @@ export interface DemuxedVideoTrackBase extends DemuxedTrack {
   height?: number;
   pixelRatio?: [number, number];
   audFound?: boolean;
-  vps?: Uint8Array[];
   pps?: Uint8Array[];
   sps?: Uint8Array[];
   naluState?: number;
   segmentCodec?: string;
   manifestCodec?: string;
   samples: VideoSample[] | Uint8Array;
-  params?: object;
 }
 
 export interface DemuxedVideoTrack extends DemuxedVideoTrackBase {

package/src/types/events.ts

@@ -42,10 +42,6 @@ export interface MediaAttachedData {
   mediaSource?: MediaSource;
 }
 
-export interface MediaEndedData {
-  stalled: boolean;
-}
-
 export interface BufferCodecsData {
   video?: Track;
   audio?: Track;

package/src/utils/buffer-helper.ts

@@ -35,13 +35,19 @@ export class BufferHelper {
    * Return true if `media`'s buffered include `position`
    */
   static isBuffered(media: Bufferable, position: number): boolean {
-    if (media) {
-      const buffered = BufferHelper.getBuffered(media);
-      for (let i = buffered.length; i--; ) {
-        if (position >= buffered.start(i) && position <= buffered.end(i)) {
-          return true;
+    try {
+      if (media) {
+        const buffered = BufferHelper.getBuffered(media);
+        for (let i = 0; i < buffered.length; i++) {
+          if (position >= buffered.start(i) && position <= buffered.end(i)) {
+            return true;
+          }
         }
       }
+    } catch (error) {
+      // this is to catch
+      // InvalidStateError: Failed to read the 'buffered' property from 'SourceBuffer':
+      // This SourceBuffer has been removed from the parent media source
     }
     return false;
   }
@@ -51,15 +57,21 @@ export class BufferHelper {
     pos: number,
     maxHoleDuration: number,
   ): BufferInfo {
-    if (media) {
-      const vbuffered = BufferHelper.getBuffered(media);
-      if (vbuffered.length) {
+    try {
+      if (media) {
+        const vbuffered = BufferHelper.getBuffered(media);
         const buffered: BufferTimeRange[] = [];
-        for (let i = 0; i < vbuffered.length; i++) {
+        let i: number;
+        for (i = 0; i < vbuffered.length; i++) {
           buffered.push({ start: vbuffered.start(i), end: vbuffered.end(i) });
         }
-        return BufferHelper.bufferedInfo(buffered, pos, maxHoleDuration);
+
+        return this.bufferedInfo(buffered, pos, maxHoleDuration);
       }
+    } catch (error) {
+      // this is to catch
+      // InvalidStateError: Failed to read the 'buffered' property from 'SourceBuffer':
+      // This SourceBuffer has been removed from the parent media source
     }
     return { len: 0, start: pos, end: pos, nextStart: undefined };
   }
@@ -76,7 +88,14 @@ export class BufferHelper {
   } {
     pos = Math.max(0, pos);
     // sort on buffer.start/smaller end (IE does not always return sorted buffered range)
-    buffered.sort((a, b) => a.start - b.start || b.end - a.end);
+    buffered.sort(function (a, b) {
+      const diff = a.start - b.start;
+      if (diff) {
+        return diff;
+      } else {
+        return b.end - a.end;
+      }
+    });
 
     let buffered2: BufferTimeRange[] = [];
     if (maxHoleDuration) {
@@ -145,7 +164,7 @@ export class BufferHelper {
    */
   static getBuffered(media: Bufferable): TimeRanges {
     try {
-      return media.buffered || noopBuffered;
+      return media.buffered;
     } catch (e) {
       logger.log('failed to get media.buffered', e);
       return noopBuffered;

package/src/utils/codecs.ts

@@ -147,15 +147,12 @@ function getCodecCompatibleNameLower(
     return CODEC_COMPATIBLE_NAMES[lowerCaseCodec]!;
   }
 
+  // Idealy fLaC and Opus would be first (spec-compliant) but
+  // some browsers will report that fLaC is supported then fail.
+  // see: https://bugs.chromium.org/p/chromium/issues/detail?id=1422728
   const codecsToCheck = {
-    // Idealy fLaC and Opus would be first (spec-compliant) but
-    // some browsers will report that fLaC is supported then fail.
-    // see: https://bugs.chromium.org/p/chromium/issues/detail?id=1422728
     flac: ['flac', 'fLaC', 'FLAC'],
     opus: ['opus', 'Opus'],
-    // Replace audio codec info if browser does not support mp4a.40.34,
-    // and demuxer can fallback to 'audio/mpeg' or 'audio/mp4;codecs="mp3"'
-    'mp4a.40.34': ['mp3'],
   }[lowerCaseCodec];
 
   for (let i = 0; i < codecsToCheck.length; i++) {
@@ -168,18 +165,13 @@ function getCodecCompatibleNameLower(
     ) {
       CODEC_COMPATIBLE_NAMES[lowerCaseCodec] = codecsToCheck[i];
       return codecsToCheck[i];
-    } else if (
-      codecsToCheck[i] === 'mp3' &&
-      getMediaSource(preferManagedMediaSource)?.isTypeSupported('audio/mpeg')
-    ) {
-      return '';
     }
   }
 
   return lowerCaseCodec;
 }
 
-const AUDIO_CODEC_REGEXP = /flac|opus|mp4a\.40\.34/i;
+const AUDIO_CODEC_REGEXP = /flac|opus/i;
 export function getCodecCompatibleName(
   codec: string,
   preferManagedMediaSource = true,
@@ -193,7 +185,7 @@ export function getCodecCompatibleName(
 }
 
 export function pickMostCompleteCodecName(
-  parsedCodec: string | undefined,
+  parsedCodec: string,
   levelCodec: string | undefined,
 ): string | undefined {
   // Parsing of mp4a codecs strings in mp4-tools from media is incomplete as of d8c6c7a
@@ -217,24 +209,3 @@ export function convertAVC1ToAVCOTI(codec: string) {
   }
   return codec;
 }
-
-export interface TypeSupported {
-  mpeg: boolean;
-  mp3: boolean;
-  ac3: boolean;
-}
-
-export function getM2TSSupportedAudioTypes(
-  preferManagedMediaSource: boolean,
-): TypeSupported {
-  const MediaSource = getMediaSource(preferManagedMediaSource) || {
-    isTypeSupported: () => false,
-  };
-  return {
-    mpeg: MediaSource.isTypeSupported('audio/mpeg'),
-    mp3: MediaSource.isTypeSupported('audio/mp4; codecs="mp3"'),
-    ac3: __USE_M2TS_ADVANCED_CODECS__
-      ? MediaSource.isTypeSupported('audio/mp4; codecs="ac-3"')
-      : false,
-  };
-}

package/src/utils/logger.ts

@@ -11,25 +11,6 @@ export interface ILogger {
   error: ILogFunction;
 }
 
-export class Logger implements ILogger {
-  trace: ILogFunction;
-  debug: ILogFunction;
-  log: ILogFunction;
-  warn: ILogFunction;
-  info: ILogFunction;
-  error: ILogFunction;
-
-  constructor(label: string, logger: ILogger) {
-    const lb = `[${label}]:`;
-    this.trace = noop;
-    this.debug = logger.debug.bind(null, lb);
-    this.log = logger.log.bind(null, lb);
-    this.warn = logger.warn.bind(null, lb);
-    this.info = logger.info.bind(null, lb);
-    this.error = logger.error.bind(null, lb);
-  }
-}
-
 const noop: ILogFunction = function () {};
 
 const fakeLogger: ILogger = {
@@ -41,9 +22,7 @@ const fakeLogger: ILogger = {
   error: noop,
 };
 
-function createLogger() {
-  return Object.assign({}, fakeLogger);
-}
+let exportedLogger: ILogger = fakeLogger;
 
 // let lastCallTime;
 // function formatMsgWithTimeInfo(type, msg) {
@@ -54,37 +33,33 @@ function createLogger() {
 //   return msg;
 // }
 
-function consolePrintFn(type: string, id: string | undefined): ILogFunction {
+function consolePrintFn(type: string): ILogFunction {
   const func: ILogFunction = self.console[type];
-  return func
-    ? func.bind(self.console, `${id ? '[' + id + '] ' : ''}[${type}] >`)
-    : noop;
+  if (func) {
+    return func.bind(self.console, `[${type}] >`);
+  }
+  return noop;
 }
 
-function getLoggerFn(
-  key: string,
-  debugConfig: boolean | Partial<ILogger>,
-  id: string | undefined,
-): ILogFunction {
-  return debugConfig[key]
-    ? debugConfig[key].bind(debugConfig)
-    : consolePrintFn(key, id);
+function exportLoggerFunctions(
+  debugConfig: boolean | ILogger,
+  ...functions: string[]
+): void {
+  functions.forEach(function (type) {
+    exportedLogger[type] = debugConfig[type]
+      ? debugConfig[type].bind(debugConfig)
+      : consolePrintFn(type);
+  });
 }
 
-const exportedLogger: ILogger = createLogger();
-
-export function enableLogs(
-  debugConfig: boolean | ILogger,
-  context: string,
-  id?: string | undefined,
-): ILogger {
+export function enableLogs(debugConfig: boolean | ILogger, id: string): void {
   // check that console is available
-  const newLogger = createLogger();
   if (
     (typeof console === 'object' && debugConfig === true) ||
     typeof debugConfig === 'object'
   ) {
-    const keys: (keyof ILogger)[] = [
+    exportLoggerFunctions(
+      debugConfig,
       // Remove out from list here to hard-disable a log-level
       // 'trace',
       'debug',
@@ -92,24 +67,19 @@ export function enableLogs(
       'info',
       'warn',
       'error',
-    ];
-    keys.forEach((key) => {
-      newLogger[key] = getLoggerFn(key, debugConfig, id);
-    });
+    );
     // Some browsers don't allow to use bind on console object anyway
     // fallback to default if needed
     try {
-      newLogger.log(
-        `Debug logs enabled for "${context}" in hls.js version ${__VERSION__}`,
+      exportedLogger.log(
+        `Debug logs enabled for "${id}" in hls.js version ${__VERSION__}`,
       );
     } catch (e) {
-      /* log fn threw an exception. All logger methods are no-ops. */
-      return createLogger();
+      exportedLogger = fakeLogger;
     }
+  } else {
+    exportedLogger = fakeLogger;
   }
-  // global exported logger uses the log methods from last call to `enableLogs`
-  Object.assign(exportedLogger, newLogger);
-  return newLogger;
 }
 
 export const logger: ILogger = exportedLogger;

package/src/utils/mp4-tools.ts

@@ -327,7 +327,7 @@ function parseStsd(stsd: Uint8Array): { codec: string; encrypted: boolean } {
     case 'mp4a': {
       const codecBox = findBox(sampleEntries, [fourCC])[0];
       const esdsBox = findBox(codecBox.subarray(28), ['esds'])[0];
-      if (esdsBox && esdsBox.length > 7) {
+      if (esdsBox && esdsBox.length > 12) {
         let i = 4;
         // ES Descriptor tag
         if (esdsBox[i++] !== 0x03) {
@@ -478,9 +478,7 @@ function parseStsd(stsd: Uint8Array): { codec: string; encrypted: boolean } {
 
 function skipBERInteger(bytes: Uint8Array, i: number): number {
   const limit = i + 5;
-  while (bytes[i++] & 0x80 && i < limit) {
-    /* do nothing */
-  }
+  while (bytes[i++] & 0x80 && i < limit) {}
   return i;
 }
 

package/src/crypt/decrypter-aes-mode.ts

@@ -1,4 +0,0 @@
-export const enum DecrypterAesMode {
-  cbc = 0,
-  ctr = 1,
-}