hls.js 1.5.14-0.canary.10559 → 1.5.15

package/src/demux/transmuxer.ts

@@ -4,31 +4,28 @@ import { ErrorTypes, ErrorDetails } from '../errors';
 import Decrypter from '../crypt/decrypter';
 import AACDemuxer from './audio/aacdemuxer';
 import MP4Demuxer from '../demux/mp4demuxer';
-import TSDemuxer from '../demux/tsdemuxer';
+import TSDemuxer, { TypeSupported } from '../demux/tsdemuxer';
 import MP3Demuxer from './audio/mp3demuxer';
 import { AC3Demuxer } from './audio/ac3-demuxer';
 import MP4Remuxer from '../remux/mp4-remuxer';
 import PassThroughRemuxer from '../remux/passthrough-remuxer';
-import { PlaylistLevelType } from '../types/loader';
-import {
-  isFullSegmentEncryption,
-  getAesModeFromFullSegmentMethod,
-} from '../utils/encryption-methods-util';
+import { logger } from '../utils/logger';
 import type { Demuxer, DemuxerResult, KeyData } from '../types/demuxer';
 import type { Remuxer } from '../types/remuxer';
 import type { TransmuxerResult, ChunkMetadata } from '../types/transmuxer';
 import type { HlsConfig } from '../config';
 import type { DecryptData } from '../loader/level-key';
-import type { TypeSupported } from '../utils/codecs';
-import type { ILogger } from '../utils/logger';
+import type { PlaylistLevelType } from '../types/loader';
 import type { RationalTimestamp } from '../utils/timescale-conversion';
+import { optionalSelf } from '../utils/global';
 
-let now: () => number;
+let now;
 // performance.now() not available on WebWorker, at least on Safari Desktop
 try {
   now = self.performance.now.bind(self.performance);
 } catch (err) {
-  now = Date.now;
+  logger.debug('Unable to use Performance API on this environment');
+  now = optionalSelf?.Date.now;
 }
 
 type MuxConfig =
@@ -50,11 +47,11 @@ if (__USE_M2TS_ADVANCED_CODECS__) {
 }
 
 export default class Transmuxer {
-  private asyncResult: boolean = false;
-  private logger: ILogger;
+  public async: boolean = false;
   private observer: HlsEventEmitter;
   private typeSupported: TypeSupported;
   private config: HlsConfig;
+  private vendor: string;
   private id: PlaylistLevelType;
   private demuxer?: Demuxer;
   private remuxer?: Remuxer;
@@ -70,13 +67,12 @@ export default class Transmuxer {
     config: HlsConfig,
     vendor: string,
     id: PlaylistLevelType,
-    logger: ILogger,
   ) {
     this.observer = observer;
     this.typeSupported = typeSupported;
     this.config = config;
+    this.vendor = vendor;
     this.id = id;
-    this.logger = logger;
   }
 
   configure(transmuxConfig: TransmuxConfig) {
@@ -118,10 +114,8 @@ export default class Transmuxer {
     } = transmuxConfig;
 
     const keyData = getEncryptionType(uintData, decryptdata);
-    if (keyData && isFullSegmentEncryption(keyData.method)) {
+    if (keyData && keyData.method === 'AES-128') {
       const decrypter = this.getDecrypter();
-      const aesMode = getAesModeFromFullSegmentMethod(keyData.method);
-
       // Software decryption is synchronous; webCrypto is not
       if (decrypter.isSync()) {
         // Software decryption is progressive. Progressive decryption may not return a result on each call. Any cached
@@ -130,7 +124,6 @@ export default class Transmuxer {
           uintData,
           keyData.key.buffer,
           keyData.iv.buffer,
-          aesMode,
         );
         // For Low-Latency HLS Parts, decrypt in place, since part parsing is expected on push progress
         const loadingParts = chunkMeta.part > -1;
@@ -143,14 +136,8 @@ export default class Transmuxer {
         }
         uintData = new Uint8Array(decryptedData);
       } else {
-        this.asyncResult = true;
         this.decryptionPromise = decrypter
-          .webCryptoDecrypt(
-            uintData,
-            keyData.key.buffer,
-            keyData.iv.buffer,
-            aesMode,
-          )
+          .webCryptoDecrypt(uintData, keyData.key.buffer, keyData.iv.buffer)
           .then((decryptedData): TransmuxerResult => {
             // Calling push here is important; if flush() is called while this is still resolving, this ensures that
             // the decrypted data has been transmuxed
@@ -162,7 +149,7 @@ export default class Transmuxer {
             this.decryptionPromise = null;
             return result;
           });
-        return this.decryptionPromise;
+        return this.decryptionPromise!;
       }
     }
 
@@ -170,7 +157,7 @@ export default class Transmuxer {
     if (resetMuxers) {
       const error = this.configureTransmuxer(uintData);
       if (error) {
-        this.logger.warn(`[transmuxer] ${error.message}`);
+        logger.warn(`[transmuxer] ${error.message}`);
         this.observer.emit(Events.ERROR, Events.ERROR, {
           type: ErrorTypes.MEDIA_ERROR,
           details: ErrorDetails.FRAG_PARSING_ERROR,
@@ -208,8 +195,6 @@ export default class Transmuxer {
       accurateTimeOffset,
       chunkMeta,
     );
-    this.asyncResult = isPromise(result);
-
     const currentState = this.currentTransmuxState;
 
     currentState.contiguous = true;
@@ -230,7 +215,6 @@ export default class Transmuxer {
     const { decrypter, currentTransmuxState, decryptionPromise } = this;
 
     if (decryptionPromise) {
-      this.asyncResult = true;
       // Upon resolution, the decryption promise calls push() and returns its TransmuxerResult up the stack. Therefore
       // only flushing is required for async decryption
       return decryptionPromise.then(() => {
@@ -257,16 +241,11 @@ export default class Transmuxer {
     if (!demuxer || !remuxer) {
       // If probing failed, then Hls.js has been given content its not able to handle
       stats.executeEnd = now();
-      const emptyResults = [emptyResult(chunkMeta)];
-      if (this.asyncResult) {
-        return Promise.resolve(emptyResults);
-      }
-      return emptyResults;
+      return [emptyResult(chunkMeta)];
     }
 
     const demuxResultOrPromise = demuxer.flush(timeOffset);
     if (isPromise(demuxResultOrPromise)) {
-      this.asyncResult = true;
       // Decrypt final SAMPLE-AES samples
       return demuxResultOrPromise.then((demuxResult) => {
         this.flushRemux(transmuxResults, demuxResult, chunkMeta);
@@ -275,9 +254,6 @@ export default class Transmuxer {
     }
 
     this.flushRemux(transmuxResults, demuxResultOrPromise, chunkMeta);
-    if (this.asyncResult) {
-      return Promise.resolve(transmuxResults);
-    }
     return transmuxResults;
   }
 
@@ -288,10 +264,10 @@ export default class Transmuxer {
   ) {
     const { audioTrack, videoTrack, id3Track, textTrack } = demuxResult;
     const { accurateTimeOffset, timeOffset } = this.currentTransmuxState;
-    this.logger.log(
-      `[transmuxer.ts]: Flushed ${this.id} sn: ${chunkMeta.sn}${
+    logger.log(
+      `[transmuxer.ts]: Flushed fragment ${chunkMeta.sn}${
         chunkMeta.part > -1 ? ' p: ' + chunkMeta.part : ''
-      } of ${this.id === PlaylistLevelType.MAIN ? 'level' : 'track'} ${chunkMeta.level}`,
+      } of level ${chunkMeta.level}`,
     );
     const remuxResult = this.remuxer!.remux(
       audioTrack,
@@ -445,11 +421,11 @@ export default class Transmuxer {
   }
 
   private configureTransmuxer(data: Uint8Array): void | Error {
-    const { config, observer, typeSupported } = this;
+    const { config, observer, typeSupported, vendor } = this;
     // probe for content type
     let mux;
     for (let i = 0, len = muxConfig.length; i < len; i++) {
-      if (muxConfig[i].demux?.probe(data, this.logger)) {
+      if (muxConfig[i].demux?.probe(data)) {
         mux = muxConfig[i];
         break;
       }
@@ -463,10 +439,10 @@ export default class Transmuxer {
     const Remuxer: MuxConfig['remux'] = mux.remux;
     const Demuxer: MuxConfig['demux'] = mux.demux;
     if (!remuxer || !(remuxer instanceof Remuxer)) {
-      this.remuxer = new Remuxer(observer, config, typeSupported, this.logger);
+      this.remuxer = new Remuxer(observer, config, typeSupported, vendor);
     }
     if (!demuxer || !(demuxer instanceof Demuxer)) {
-      this.demuxer = new Demuxer(observer, config, typeSupported, this.logger);
+      this.demuxer = new Demuxer(observer, config, typeSupported);
       this.probe = Demuxer.probe;
     }
   }

package/src/demux/tsdemuxer.ts

@@ -2,7 +2,7 @@
  * highly optimized TS demuxer:
  * parse PAT, PMT
  * extract PES packet from audio and video PIDs
- * extract AVC/H264 (or HEVC/H265) NAL units and AAC/ADTS samples from PES packet
+ * extract AVC/H264 NAL units and AAC/ADTS samples from PES packet
  * trigger the remuxer upon parsing completion
  * it also tries to workaround as best as it can audio codec switch (HE-AAC to AAC and vice versa), without having to restart the MediaSource.
  * it also controls the remuxing process :
@@ -12,31 +12,28 @@
 import * as ADTS from './audio/adts';
 import * as MpegAudio from './audio/mpegaudio';
 import * as AC3 from './audio/ac3-demuxer';
-import BaseVideoParser from './video/base-video-parser';
 import AvcVideoParser from './video/avc-video-parser';
-import HevcVideoParser from './video/hevc-video-parser';
 import SampleAesDecrypter from './sample-aes';
 import { Events } from '../events';
 import { appendUint8Array, RemuxerTrackIdConfig } from '../utils/mp4-tools';
+import { logger } from '../utils/logger';
 import { ErrorTypes, ErrorDetails } from '../errors';
 import type { HlsConfig } from '../config';
 import type { HlsEventEmitter } from '../events';
-import type { TypeSupported } from '../utils/codecs';
-import type { ILogger } from '../utils/logger';
 import {
+  DemuxedVideoTrack,
+  DemuxedAudioTrack,
+  DemuxedTrack,
+  Demuxer,
+  DemuxerResult,
+  VideoSample,
+  DemuxedMetadataTrack,
+  DemuxedUserdataTrack,
+  ElementaryStreamData,
+  KeyData,
   MetadataSchema,
-  type DemuxedVideoTrack,
-  type DemuxedAudioTrack,
-  type DemuxedTrack,
-  type Demuxer,
-  type DemuxerResult,
-  type VideoSample,
-  type DemuxedMetadataTrack,
-  type DemuxedUserdataTrack,
-  type ElementaryStreamData,
-  type KeyData,
 } from '../types/demuxer';
-import type { AudioFrame } from '../types/demuxer';
+import { AudioFrame } from '../types/demuxer';
 
 export type ParsedTimestamp = {
   pts?: number;
@@ -51,18 +48,24 @@ export type PES = ParsedTimestamp & {
 export type ParsedVideoSample = ParsedTimestamp &
   Omit<VideoSample, 'pts' | 'dts'>;
 
+export interface TypeSupported {
+  mpeg: boolean;
+  mp3: boolean;
+  ac3: boolean;
+}
+
 const PACKET_LENGTH = 188;
 
 class TSDemuxer implements Demuxer {
-  private readonly logger: ILogger;
   private readonly observer: HlsEventEmitter;
   private readonly config: HlsConfig;
-  private readonly typeSupported: TypeSupported;
+  private typeSupported: TypeSupported;
 
   private sampleAes: SampleAesDecrypter | null = null;
   private pmtParsed: boolean = false;
   private audioCodec?: string;
   private videoCodec?: string;
+  private _duration: number = 0;
   private _pmtId: number = -1;
 
   private _videoTrack?: DemuxedVideoTrack;
@@ -71,22 +74,20 @@ class TSDemuxer implements Demuxer {
   private _txtTrack?: DemuxedUserdataTrack;
   private aacOverFlow: AudioFrame | null = null;
   private remainderData: Uint8Array | null = null;
-  private videoParser: BaseVideoParser | null;
+  private videoParser: AvcVideoParser;
 
   constructor(
     observer: HlsEventEmitter,
     config: HlsConfig,
     typeSupported: TypeSupported,
-    logger: ILogger,
   ) {
     this.observer = observer;
     this.config = config;
     this.typeSupported = typeSupported;
-    this.logger = logger;
-    this.videoParser = null;
+    this.videoParser = new AvcVideoParser();
   }
 
-  static probe(data: Uint8Array, logger: ILogger) {
+  static probe(data: Uint8Array) {
     const syncOffset = TSDemuxer.syncOffset(data);
     if (syncOffset > 0) {
       logger.warn(
@@ -181,7 +182,6 @@ class TSDemuxer implements Demuxer {
     this._pmtId = -1;
 
     this._videoTrack = TSDemuxer.createTrack('video') as DemuxedVideoTrack;
-    this._videoTrack.duration = trackDuration;
     this._audioTrack = TSDemuxer.createTrack(
       'audio',
       trackDuration,
@@ -195,6 +195,7 @@ class TSDemuxer implements Demuxer {
     this.remainderData = null;
     this.audioCodec = audioCodec;
     this.videoCodec = videoCodec;
+    this._duration = trackDuration;
   }
 
   public resetTimeStamp() {}
@@ -290,22 +291,14 @@ class TSDemuxer implements Demuxer {
         switch (pid) {
           case videoPid:
             if (stt) {
-              if (videoData && (pes = parsePES(videoData, this.logger))) {
-                if (this.videoParser === null) {
-                  switch (videoTrack.segmentCodec) {
-                    case 'avc':
-                      this.videoParser = new AvcVideoParser();
-                      break;
-                    case 'hevc':
-                      if (__USE_M2TS_ADVANCED_CODECS__) {
-                        this.videoParser = new HevcVideoParser();
-                      }
-                      break;
-                  }
-                }
-                if (this.videoParser !== null) {
-                  this.videoParser.parsePES(videoTrack, textTrack, pes, false);
-                }
+              if (videoData && (pes = parsePES(videoData))) {
+                this.videoParser.parseAVCPES(
+                  videoTrack,
+                  textTrack,
+                  pes,
+                  false,
+                  this._duration,
+                );
               }
 
               videoData = { data: [], size: 0 };
@@ -317,7 +310,7 @@ class TSDemuxer implements Demuxer {
             break;
           case audioPid:
             if (stt) {
-              if (audioData && (pes = parsePES(audioData, this.logger))) {
+              if (audioData && (pes = parsePES(audioData))) {
                 switch (audioTrack.segmentCodec) {
                   case 'aac':
                     this.parseAACPES(audioTrack, pes);
@@ -341,7 +334,7 @@ class TSDemuxer implements Demuxer {
             break;
           case id3Pid:
             if (stt) {
-              if (id3Data && (pes = parsePES(id3Data, this.logger))) {
+              if (id3Data && (pes = parsePES(id3Data))) {
                 this.parseID3PES(id3Track, pes);
               }
 
@@ -358,7 +351,7 @@ class TSDemuxer implements Demuxer {
             }
 
             pmtId = this._pmtId = parsePAT(data, offset);
-            // this.logger.log('PMT PID:'  + this._pmtId);
+            // logger.log('PMT PID:'  + this._pmtId);
             break;
           case pmtId: {
             if (stt) {
@@ -371,7 +364,6 @@ class TSDemuxer implements Demuxer {
               this.typeSupported,
               isSampleAes,
               this.observer,
-              this.logger,
             );
 
             // only update track id if track PID found while parsing PMT
@@ -397,7 +389,7 @@ class TSDemuxer implements Demuxer {
             }
 
             if (unknownPID !== null && !pmtParsed) {
-              this.logger.warn(
+              logger.warn(
                 `MPEG-TS PMT found at ${start} after unknown PID '${unknownPID}'. Backtracking to sync byte @${syncOffset} to parse all TS packets.`,
               );
               unknownPID = null;
@@ -425,8 +417,6 @@ class TSDemuxer implements Demuxer {
         new Error(
           `Found ${tsPacketErrors} TS packet/s that do not start with 0x47`,
         ),
-        undefined,
-        this.logger,
       );
     }
 
@@ -476,34 +466,21 @@ class TSDemuxer implements Demuxer {
     const id3Data = id3Track.pesData;
     // try to parse last PES packets
     let pes: PES | null;
-    if (videoData && (pes = parsePES(videoData, this.logger))) {
-      if (this.videoParser === null) {
-        switch (videoTrack.segmentCodec) {
-          case 'avc':
-            this.videoParser = new AvcVideoParser();
-            break;
-          case 'hevc':
-            if (__USE_M2TS_ADVANCED_CODECS__) {
-              this.videoParser = new HevcVideoParser();
-            }
-            break;
-        }
-      }
-      if (this.videoParser !== null) {
-        this.videoParser.parsePES(
-          videoTrack as DemuxedVideoTrack,
-          textTrack as DemuxedUserdataTrack,
-          pes,
-          true,
-        );
-        videoTrack.pesData = null;
-      }
+    if (videoData && (pes = parsePES(videoData))) {
+      this.videoParser.parseAVCPES(
+        videoTrack as DemuxedVideoTrack,
+        textTrack as DemuxedUserdataTrack,
+        pes,
+        true,
+        this._duration,
+      );
+      videoTrack.pesData = null;
     } else {
       // either avcData null or PES truncated, keep it for next frag parsing
       videoTrack.pesData = videoData;
     }
 
-    if (audioData && (pes = parsePES(audioData, this.logger))) {
+    if (audioData && (pes = parsePES(audioData))) {
       switch (audioTrack.segmentCodec) {
         case 'aac':
           this.parseAACPES(audioTrack, pes);
@@ -520,7 +497,7 @@ class TSDemuxer implements Demuxer {
       audioTrack.pesData = null;
     } else {
       if (audioData?.size) {
-        this.logger.log(
+        logger.log(
           'last AAC PES packet truncated,might overlap between fragments',
         );
       }
@@ -529,7 +506,7 @@ class TSDemuxer implements Demuxer {
       audioTrack.pesData = audioData;
     }
 
-    if (id3Data && (pes = parsePES(id3Data, this.logger))) {
+    if (id3Data && (pes = parsePES(id3Data))) {
       this.parseID3PES(id3Track, pes);
       id3Track.pesData = null;
     } else {
@@ -582,21 +559,7 @@ class TSDemuxer implements Demuxer {
   }
 
   public destroy() {
-    if (this.observer) {
-      this.observer.removeAllListeners();
-    }
-    // @ts-ignore
-    this.config = this.logger = this.observer = null;
-    this.aacOverFlow =
-      this.videoParser =
-      this.remainderData =
-      this.sampleAes =
-        null;
-    this._videoTrack =
-      this._audioTrack =
-      this._id3Track =
-      this._txtTrack =
-        undefined;
+    this._duration = 0;
   }
 
   private parseAACPES(track: DemuxedAudioTrack, pes: PES) {
@@ -637,12 +600,7 @@ class TSDemuxer implements Demuxer {
       } else {
         reason = 'No ADTS header found in AAC PES';
       }
-      emitParsingError(
-        this.observer,
-        new Error(reason),
-        recoverable,
-        this.logger,
-      );
+      emitParsingError(this.observer, new Error(reason), recoverable);
       if (!recoverable) {
         return;
       }
@@ -665,7 +623,7 @@ class TSDemuxer implements Demuxer {
       const frameDuration = ADTS.getFrameDuration(track.samplerate as number);
       pts = aacOverFlow.sample.pts + frameDuration;
     } else {
-      this.logger.warn('[tsdemuxer]: AAC PES unknown PTS');
+      logger.warn('[tsdemuxer]: AAC PES unknown PTS');
       return;
     }
 
@@ -696,7 +654,7 @@ class TSDemuxer implements Demuxer {
     let offset = 0;
     const pts = pes.pts;
     if (pts === undefined) {
-      this.logger.warn('[tsdemuxer]: MPEG PES unknown PTS');
+      logger.warn('[tsdemuxer]: MPEG PES unknown PTS');
       return;
     }
 
@@ -728,7 +686,7 @@ class TSDemuxer implements Demuxer {
       const data = pes.data;
       const pts = pes.pts;
       if (pts === undefined) {
-        this.logger.warn('[tsdemuxer]: AC3 PES unknown PTS');
+        logger.warn('[tsdemuxer]: AC3 PES unknown PTS');
         return;
       }
       const length = data.length;
@@ -747,7 +705,7 @@ class TSDemuxer implements Demuxer {
 
   private parseID3PES(id3Track: DemuxedMetadataTrack, pes: PES) {
     if (pes.pts === undefined) {
-      this.logger.warn('[tsdemuxer]: ID3 PES unknown PTS');
+      logger.warn('[tsdemuxer]: ID3 PES unknown PTS');
       return;
     }
     const id3Sample = Object.assign({}, pes as Required<PES>, {
@@ -774,7 +732,6 @@ function parsePMT(
   typeSupported: TypeSupported,
   isSampleAes: boolean,
   observer: HlsEventEmitter,
-  logger: ILogger,
 ) {
   const result = {
     audioPid: -1,
@@ -797,7 +754,7 @@ function parsePMT(
     switch (data[offset]) {
       case 0xcf: // SAMPLE-AES AAC
         if (!isSampleAes) {
-          logEncryptedSamplesFoundInUnencryptedStream('ADTS AAC', logger);
+          logEncryptedSamplesFoundInUnencryptedStream('ADTS AAC');
           break;
         }
       /* falls through */
@@ -820,7 +777,7 @@ function parsePMT(
 
       case 0xdb: // SAMPLE-AES AVC
         if (!isSampleAes) {
-          logEncryptedSamplesFoundInUnencryptedStream('H.264', logger);
+          logEncryptedSamplesFoundInUnencryptedStream('H.264');
           break;
         }
       /* falls through */
@@ -848,7 +805,7 @@ function parsePMT(
 
       case 0xc1: // SAMPLE-AES AC3
         if (!isSampleAes) {
-          logEncryptedSamplesFoundInUnencryptedStream('AC-3', logger);
+          logEncryptedSamplesFoundInUnencryptedStream('AC-3');
           break;
         }
       /* falls through */
@@ -904,31 +861,12 @@ function parsePMT(
       case 0xc2: // SAMPLE-AES EC3
       /* falls through */
       case 0x87:
-        emitParsingError(
-          observer,
-          new Error('Unsupported EC-3 in M2TS found'),
-          undefined,
-          logger,
-        );
+        emitParsingError(observer, new Error('Unsupported EC-3 in M2TS found'));
         return result;
 
-      case 0x24: // ITU-T Rec. H.265 and ISO/IEC 23008-2 (HEVC)
-        if (__USE_M2TS_ADVANCED_CODECS__) {
-          if (result.videoPid === -1) {
-            result.videoPid = pid;
-            result.segmentVideoCodec = 'hevc';
-            logger.log('HEVC in M2TS found');
-          }
-        } else {
-          emitParsingError(
-            observer,
-            new Error('Unsupported HEVC in M2TS found'),
-            undefined,
-            logger,
-          );
-          return result;
-        }
-        break;
+      case 0x24:
+        emitParsingError(observer, new Error('Unsupported HEVC in M2TS found'));
+        return result;
 
       default:
         // logger.log('unknown stream type:' + data[offset]);
@@ -944,8 +882,7 @@ function parsePMT(
 function emitParsingError(
   observer: HlsEventEmitter,
   error: Error,
-  levelRetry: boolean | undefined,
-  logger: ILogger,
+  levelRetry?: boolean,
 ) {
   logger.warn(`parsing error: ${error.message}`);
   observer.emit(Events.ERROR, Events.ERROR, {
@@ -958,14 +895,11 @@ function emitParsingError(
   });
 }
 
-function logEncryptedSamplesFoundInUnencryptedStream(
-  type: string,
-  logger: ILogger,
-) {
+function logEncryptedSamplesFoundInUnencryptedStream(type: string) {
   logger.log(`${type} with AES-128-CBC encryption found in unencrypted stream`);
 }
 
-function parsePES(stream: ElementaryStreamData, logger: ILogger): PES | null {
+function parsePES(stream: ElementaryStreamData): PES | null {
   let i = 0;
   let frag: Uint8Array;
   let pesLen: number;