hls.js 1.5.3 → 1.5.5-0.canary.9977

package/src/types/demuxer.ts

@@ -64,6 +64,7 @@ export interface DemuxedAudioTrack extends DemuxedTrack {
   segmentCodec?: string;
   channelCount?: number;
   manifestCodec?: string;
+  parsedCodec?: string;
   samples: AudioSample[];
 }
 
@@ -72,12 +73,14 @@ 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,6 +42,10 @@ export interface MediaAttachedData {
   mediaSource?: MediaSource;
 }
 
+export interface MediaEndedData {
+  stalled: boolean;
+}
+
 export interface BufferCodecsData {
   video?: Track;
   audio?: Track;

package/src/utils/codecs.ts

@@ -147,12 +147,15 @@ 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++) {
@@ -165,13 +168,18 @@ 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/i;
+const AUDIO_CODEC_REGEXP = /flac|opus|mp4a\.40\.34/i;
 export function getCodecCompatibleName(
   codec: string,
   preferManagedMediaSource = true,
@@ -209,3 +217,24 @@ 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/encryption-methods-util.ts

@@ -0,0 +1,21 @@
+import { DecrypterAesMode } from '../crypt/decrypter-aes-mode';
+
+export function isFullSegmentEncryption(method: string): boolean {
+  return (
+    method === 'AES-128' || method === 'AES-256' || method === 'AES-256-CTR'
+  );
+}
+
+export function getAesModeFromFullSegmentMethod(
+  method: string,
+): DecrypterAesMode {
+  switch (method) {
+    case 'AES-128':
+    case 'AES-256':
+      return DecrypterAesMode.cbc;
+    case 'AES-256-CTR':
+      return DecrypterAesMode.ctr;
+    default:
+      throw new Error(`invalid full segment method ${method}`);
+  }
+}

package/src/utils/logger.ts

@@ -11,6 +11,25 @@ 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 = {
@@ -22,7 +41,9 @@ const fakeLogger: ILogger = {
   error: noop,
 };
 
-let exportedLogger: ILogger = fakeLogger;
+function createLogger() {
+  return Object.assign({}, fakeLogger);
+}
 
 // let lastCallTime;
 // function formatMsgWithTimeInfo(type, msg) {
@@ -33,33 +54,37 @@ let exportedLogger: ILogger = fakeLogger;
 //   return msg;
 // }
 
-function consolePrintFn(type: string): ILogFunction {
+function consolePrintFn(type: string, id: string | undefined): ILogFunction {
   const func: ILogFunction = self.console[type];
-  if (func) {
-    return func.bind(self.console, `[${type}] >`);
-  }
-  return noop;
+  return func
+    ? func.bind(self.console, `${id ? '[' + id + '] ' : ''}[${type}] >`)
+    : noop;
 }
 
-function exportLoggerFunctions(
-  debugConfig: boolean | ILogger,
-  ...functions: string[]
-): void {
-  functions.forEach(function (type) {
-    exportedLogger[type] = debugConfig[type]
-      ? debugConfig[type].bind(debugConfig)
-      : consolePrintFn(type);
-  });
+function getLoggerFn(
+  key: string,
+  debugConfig: boolean | Partial<ILogger>,
+  id: string | undefined,
+): ILogFunction {
+  return debugConfig[key]
+    ? debugConfig[key].bind(debugConfig)
+    : consolePrintFn(key, id);
 }
 
-export function enableLogs(debugConfig: boolean | ILogger, id: string): void {
+let exportedLogger: ILogger = createLogger();
+
+export function enableLogs(
+  debugConfig: boolean | ILogger,
+  context: string,
+  id?: string | undefined,
+): ILogger {
   // check that console is available
+  const newLogger = createLogger();
   if (
     (typeof console === 'object' && debugConfig === true) ||
     typeof debugConfig === 'object'
   ) {
-    exportLoggerFunctions(
-      debugConfig,
+    const keys: (keyof ILogger)[] = [
       // Remove out from list here to hard-disable a log-level
       // 'trace',
       'debug',
@@ -67,19 +92,23 @@ export function enableLogs(debugConfig: boolean | ILogger, id: string): void {
       '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 {
-      exportedLogger.log(
-        `Debug logs enabled for "${id}" in hls.js version ${__VERSION__}`,
+      newLogger.log(
+        `Debug logs enabled for "${context}" in hls.js version ${__VERSION__}`,
       );
     } catch (e) {
-      exportedLogger = fakeLogger;
+      /* log fn threw an exception. All logger methods are no-ops. */
+      return createLogger();
     }
-  } else {
-    exportedLogger = fakeLogger;
   }
+  exportedLogger = newLogger;
+  return newLogger;
 }
 
 export const logger: ILogger = exportedLogger;

package/src/utils/mp4-tools.ts

@@ -38,6 +38,13 @@ export function readUint32(buffer: Uint8Array, offset: number): number {
   return val < 0 ? 4294967296 + val : val;
 }
 
+export function readUint64(buffer: Uint8Array, offset: number) {
+  let result = readUint32(buffer, offset);
+  result *= Math.pow(2, 32);
+  result += readUint32(buffer, offset + 4);
+  return result;
+}
+
 export function readSint32(buffer: Uint8Array, offset: number): number {
   return (
     (buffer[offset] << 24) |
@@ -125,15 +132,15 @@ export function parseSegmentIndex(sidx: Uint8Array): SidxInfo | null {
   const timescale = readUint32(sidx, index);
   index += 4;
 
-  // TODO: parse earliestPresentationTime and firstOffset
-  // usually zero in our case
-  const earliestPresentationTime = 0;
-  const firstOffset = 0;
+  let earliestPresentationTime = 0;
+  let firstOffset = 0;
 
   if (version === 0) {
-    index += 8;
+    earliestPresentationTime = readUint32(sidx, (index += 4));
+    firstOffset = readUint32(sidx, (index += 4));
   } else {
-    index += 16;
+    earliestPresentationTime = readUint64(sidx, (index += 8));
+    firstOffset = readUint64(sidx, (index += 8));
   }
 
   // skip reserved
@@ -677,19 +684,31 @@ export function getDuration(data: Uint8Array, initData: InitData) {
   }
   if (videoDuration === 0 && audioDuration === 0) {
     // If duration samples are not available in the traf use sidx subsegment_duration
+    let sidxMinStart = Infinity;
+    let sidxMaxEnd = 0;
     let sidxDuration = 0;
     const sidxs = findBox(data, ['sidx']);
     for (let i = 0; i < sidxs.length; i++) {
       const sidx = parseSegmentIndex(sidxs[i]);
       if (sidx?.references) {
-        sidxDuration += sidx.references.reduce(
+        sidxMinStart = Math.min(
+          sidxMinStart,
+          sidx.earliestPresentationTime / sidx.timescale,
+        );
+        const subSegmentDuration = sidx.references.reduce(
           (dur, ref) => dur + ref.info.duration || 0,
           0,
         );
+        sidxMaxEnd = Math.max(
+          sidxMaxEnd,
+          subSegmentDuration + sidx.earliestPresentationTime / sidx.timescale,
+        );
+        sidxDuration = sidxMaxEnd - sidxMinStart;
       }
     }
-
-    return sidxDuration;
+    if (sidxDuration && Number.isFinite(sidxDuration)) {
+      return sidxDuration;
+    }
   }
   if (videoDuration) {
     return videoDuration;