hls.js 1.5.13 → 1.5.14-0.canary.10417

package/src/remux/mp4-generator.ts

@@ -28,6 +28,8 @@ class MP4 {
     MP4.types = {
       avc1: [], // codingname
       avcC: [],
+      hvc1: [],
+      hvcC: [],
       btrt: [],
       dinf: [],
       dref: [],
@@ -839,8 +841,10 @@ 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 {
+    } 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));
     }
   }
 
@@ -1123,6 +1127,197 @@ 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

@@ -4,7 +4,7 @@ import type { HlsEventEmitter } from '../events';
 import { Events } from '../events';
 import { ErrorTypes, ErrorDetails } from '../errors';
 import { logger } from '../utils/logger';
-import {
+import type {
   InitSegmentData,
   Remuxer,
   RemuxerResult,
@@ -29,6 +29,7 @@ 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;
@@ -41,7 +42,7 @@ let safariWebkitVersion: number | null = null;
 export default class MP4Remuxer implements Remuxer {
   private observer: HlsEventEmitter;
   private config: HlsConfig;
-  private typeSupported: any;
+  private typeSupported: TypeSupported;
   private ISGenerated: boolean = false;
   private _initPTS: RationalTimestamp | null = null;
   private _initDTS: RationalTimestamp | null = null;
@@ -159,15 +160,18 @@ export default class MP4Remuxer implements Remuxer {
       if (this.ISGenerated) {
         const config = this.videoTrackConfig;
         if (
-          config &&
-          (videoTrack.width !== config.width ||
-            videoTrack.height !== config.height ||
-            videoTrack.pixelRatio?.[0] !== config.pixelRatio?.[0] ||
-            videoTrack.pixelRatio?.[1] !== config.pixelRatio?.[1])
+          (config &&
+            (videoTrack.width !== config.width ||
+              videoTrack.height !== config.height ||
+              videoTrack.pixelRatio?.[0] !== config.pixelRatio?.[0] ||
+              videoTrack.pixelRatio?.[1] !== config.pixelRatio?.[1])) ||
+          (!config && enoughVideoSamples) ||
+          (this.nextAudioPts === null && enoughAudioSamples)
         ) {
           this.resetInitSegment();
         }
-      } else {
+      }
+      if (!this.ISGenerated) {
         initSegment = this.generateIS(
           audioTrack,
           videoTrack,
@@ -515,7 +519,7 @@ export default class MP4Remuxer implements Remuxer {
       if (foundHole || foundOverlap) {
         if (foundHole) {
           logger.warn(
-            `AVC: ${toMsFromMpegTsClock(
+            `${(track.segmentCodec || '').toUpperCase()}: ${toMsFromMpegTsClock(
               delta,
               true,
             )} ms (${delta}dts) hole between fragments detected at ${timeOffset.toFixed(
@@ -524,7 +528,7 @@ export default class MP4Remuxer implements Remuxer {
           );
         } else {
           logger.warn(
-            `AVC: ${toMsFromMpegTsClock(
+            `${(track.segmentCodec || '').toUpperCase()}: ${toMsFromMpegTsClock(
               -delta,
               true,
             )} ms (${delta}dts) overlapping between fragments detected at ${timeOffset.toFixed(
@@ -543,12 +547,27 @@ 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) {
+              if (inputSamples[i].dts > firstPTS && isPTSOrderRetained) {
                 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(
@@ -743,7 +762,7 @@ export default class MP4Remuxer implements Remuxer {
         }
       }
     }
-    // next AVC sample DTS should be equal to last sample DTS + last sample duration (in PES timescale)
+    // next AVC/HEVC sample DTS should be equal to last sample DTS + last sample duration (in PES timescale)
     mp4SampleDuration =
       stretchedLastFrame || !mp4SampleDuration
         ? averageSampleDuration
@@ -927,7 +946,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.manifestCodec || track.codec,
+              track.parsedCodec || track.manifestCodec || track.codec,
               track.channelCount,
             );
             if (!fillFrame) {
@@ -1050,55 +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 * inputTimeScale) + init90kHz;
-    const endDTS: number = videoData.endDTS * 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.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/remux/passthrough-remuxer.ts

@@ -178,7 +178,7 @@ class PassThroughRemuxer implements Remuxer {
       initSegment.initPTS = decodeTime - timeOffset;
       if (initPTS && initPTS.timescale === 1) {
         logger.warn(
-          `Adjusting initPTS by ${initSegment.initPTS - initPTS.baseTime}`,
+          `Adjusting initPTS @${timeOffset} from ${initPTS.baseTime / initPTS.timescale} to ${initSegment.initPTS}`,
         );
       }
       this.initPTS = initPTS = {

package/src/task-loop.ts

@@ -1,3 +1,5 @@
+import { type ILogger, Logger } from './utils/logger';
+
 /**
  * @ignore
  * Sub-class specialization of EventHandler base class.
@@ -27,13 +29,14 @@
  * 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 {
+export default class TaskLoop extends Logger {
   private readonly _boundTick: () => void;
   private _tickTimer: number | null = null;
   private _tickInterval: number | null = null;
   private _tickCallCount = 0;
 
-  constructor() {
+  constructor(label: string, logger: ILogger) {
+    super(label, logger);
     this._boundTick = this.tick.bind(this);
   }
 

package/src/types/component-api.ts

@@ -1,4 +1,4 @@
-import EwmaBandWidthEstimator from '../utils/ewma-bandwidth-estimator';
+import type EwmaBandWidthEstimator from '../utils/ewma-bandwidth-estimator';
 
 export interface ComponentAPI {
   destroy(): void;
@@ -15,4 +15,6 @@ 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,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

@@ -1,7 +1,4 @@
-// eslint-disable-next-line import/no-duplicates
-import type { Fragment } from '../loader/fragment';
-// eslint-disable-next-line import/no-duplicates
-import type { Part } from '../loader/fragment';
+import type { Fragment, MediaFragment, Part } from '../loader/fragment';
 import type { LevelDetails } from '../loader/level-details';
 import type {
   HdcpLevel,
@@ -42,6 +39,10 @@ export interface MediaAttachedData {
   mediaSource?: MediaSource;
 }
 
+export interface MediaEndedData {
+  stalled: boolean;
+}
+
 export interface BufferCodecsData {
   video?: Track;
   audio?: Track;
@@ -191,6 +192,18 @@ export interface LevelUpdatedData {
   level: number;
 }
 
+export interface AudioTrackUpdatedData {
+  details: LevelDetails;
+  id: number;
+  groupId: string;
+}
+
+export interface SubtitleTrackUpdatedData {
+  details: LevelDetails;
+  id: number;
+  groupId: string;
+}
+
 export interface LevelPTSUpdatedData {
   details: LevelDetails;
   level: Level;
@@ -316,8 +329,8 @@ export interface NonNativeTextTracksData {
 }
 
 export interface InitPTSFoundData {
-  id: string;
-  frag: Fragment;
+  id: PlaylistLevelType;
+  frag: MediaFragment;
   initPTS: number;
   timescale: number;
 }

package/src/types/fragment-tracker.ts

@@ -1,9 +1,9 @@
-import type { Fragment } from '../loader/fragment';
+import type { MediaFragment } from '../loader/fragment';
 import type { SourceBufferName } from './buffer';
 import type { FragLoadedData } from './events';
 
 export interface FragmentEntity {
-  body: Fragment;
+  body: MediaFragment;
   // appendedPTS is the latest buffered presentation time within the fragment's time range.
   // It is used to determine: which fragment is appended at any given position, and hls.currentLevel.
   appendedPTS: number | null;

package/src/types/media-playlist.ts

@@ -1,6 +1,7 @@
 import type { AttrList } from '../utils/attr-list';
 import type { LevelDetails } from '../loader/level-details';
-import type { VideoRange } from './level';
+import type { Level, VideoRange } from './level';
+import type { PlaylistLevelType } from './loader';
 
 export type AudioPlaylistType = 'AUDIO';
 
@@ -10,9 +11,16 @@ export type SubtitlePlaylistType = 'SUBTITLES' | 'CLOSED-CAPTIONS';
 
 export type MediaPlaylistType = MainPlaylistType | SubtitlePlaylistType;
 
+export type MediaSelection = {
+  [PlaylistLevelType.MAIN]: Level;
+  [PlaylistLevelType.AUDIO]?: MediaPlaylist;
+  [PlaylistLevelType.SUBTITLE]?: MediaPlaylist;
+};
+
 export type VideoSelectionOption = {
   preferHDR?: boolean;
   allowedVideoRanges?: Array<VideoRange>;
+  videoCodec?: string;
 };
 
 export type AudioSelectionOption = {

package/src/types/remuxer.ts

@@ -1,5 +1,5 @@
 import type { TrackSet } from './track';
-import {
+import type {
   DemuxedAudioTrack,
   DemuxedMetadataTrack,
   DemuxedUserdataTrack,

package/src/utils/attr-list.ts

@@ -1,3 +1,8 @@
+import type { LevelDetails } from '../loader/level-details';
+import type { ParsedMultivariantPlaylist } from '../loader/m3u8-parser';
+import { logger } from './logger';
+import { substituteVariables } from './variable-substitution';
+
 const DECIMAL_RESOLUTION_REGEX = /^(\d+)x(\d+)$/;
 const ATTR_LIST_REGEX = /(.+?)=(".*?"|.*?)(?:,|$)/g;
 
@@ -5,9 +10,15 @@ const ATTR_LIST_REGEX = /(.+?)=(".*?"|.*?)(?:,|$)/g;
 export class AttrList {
   [key: string]: any;
 
-  constructor(attrs: string | Record<string, any>) {
+  constructor(
+    attrs: string | Record<string, any>,
+    parsed?: Pick<
+      ParsedMultivariantPlaylist | LevelDetails,
+      'variableList' | 'hasVariableRefs' | 'playlistParsingError'
+    >,
+  ) {
     if (typeof attrs === 'string') {
-      attrs = AttrList.parseAttrList(attrs);
+      attrs = AttrList.parseAttrList(attrs, parsed);
     }
     Object.assign(this, attrs);
   }
@@ -63,6 +74,20 @@ export class AttrList {
     return this[attrName];
   }
 
+  enumeratedStringList<T extends { [key: string]: boolean }>(
+    attrName: string,
+    dict: T,
+  ): { [key in keyof T]: boolean } {
+    const attrValue = this[attrName];
+    return (attrValue ? attrValue.split(/[ ,]+/) : []).reduce(
+      (result: { [key in keyof T]: boolean }, identifier: string) => {
+        result[identifier.toLowerCase() as keyof T] = true;
+        return result;
+      },
+      dict,
+    );
+  }
+
   bool(attrName: string): boolean {
     return this[attrName] === 'YES';
   }
@@ -84,21 +109,83 @@ export class AttrList {
     };
   }
 
-  static parseAttrList(input: string): Record<string, any> {
-    let match;
+  static parseAttrList(
+    input: string,
+    parsed?: Pick<
+      ParsedMultivariantPlaylist | LevelDetails,
+      'variableList' | 'hasVariableRefs' | 'playlistParsingError'
+    >,
+  ): Record<string, string> {
+    let match: RegExpExecArray | null;
     const attrs = {};
     const quote = '"';
     ATTR_LIST_REGEX.lastIndex = 0;
     while ((match = ATTR_LIST_REGEX.exec(input)) !== null) {
+      const name = match[1].trim();
       let value = match[2];
-
-      if (
+      const quotedString =
         value.indexOf(quote) === 0 &&
-        value.lastIndexOf(quote) === value.length - 1
-      ) {
+        value.lastIndexOf(quote) === value.length - 1;
+      let hexadecimalSequence = false;
+      if (quotedString) {
         value = value.slice(1, -1);
+      } else {
+        switch (name) {
+          case 'IV':
+          case 'SCTE35-CMD':
+          case 'SCTE35-IN':
+          case 'SCTE35-OUT':
+            hexadecimalSequence = true;
+        }
+      }
+      if (parsed && (quotedString || hexadecimalSequence)) {
+        if (__USE_VARIABLE_SUBSTITUTION__) {
+          value = substituteVariables(parsed, value);
+        }
+      } else if (!hexadecimalSequence && !quotedString) {
+        switch (name) {
+          case 'CLOSED-CAPTIONS':
+            if (value === 'NONE') {
+              break;
+            }
+          // falls through
+          case 'ALLOWED-CPC':
+          case 'CLASS':
+          case 'ASSOC-LANGUAGE':
+          case 'AUDIO':
+          case 'BYTERANGE':
+          case 'CHANNELS':
+          case 'CHARACTERISTICS':
+          case 'CODECS':
+          case 'DATA-ID':
+          case 'END-DATE':
+          case 'GROUP-ID':
+          case 'ID':
+          case 'IMPORT':
+          case 'INSTREAM-ID':
+          case 'KEYFORMAT':
+          case 'KEYFORMATVERSIONS':
+          case 'LANGUAGE':
+          case 'NAME':
+          case 'PATHWAY-ID':
+          case 'QUERYPARAM':
+          case 'RECENTLY-REMOVED-DATERANGES':
+          case 'SERVER-URI':
+          case 'STABLE-RENDITION-ID':
+          case 'STABLE-VARIANT-ID':
+          case 'START-DATE':
+          case 'SUBTITLES':
+          case 'SUPPLEMENTAL-CODECS':
+          case 'URI':
+          case 'VALUE':
+          case 'VIDEO':
+          case 'X-ASSET-LIST':
+          case 'X-ASSET-URI':
+            // Since we are not checking tag:attribute combination, just warn rather than ignoring attribute
+            logger.warn(`${input}: attribute ${name} is missing quotes`);
+          // continue;
+        }
       }
-      const name = match[1].trim();
       attrs[name] = value;
     }
     return attrs;