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

package/src/demux/audio/adts.ts

@@ -17,6 +17,7 @@ type AudioConfig = {
   samplerate: number;
   channelCount: number;
   codec: string;
+  parsedCodec: string;
   manifestCodec: string;
 };
 
@@ -32,6 +33,7 @@ export function getAudioConfig(
   audioCodec: string,
 ): AudioConfig | void {
   let adtsObjectType: number;
+  let originalAdtsObjectType: number;
   let adtsExtensionSamplingIndex: number;
   let adtsChannelConfig: number;
   let config: number[];
@@ -42,7 +44,8 @@ export function getAudioConfig(
     8000, 7350,
   ];
   // byte 2
-  adtsObjectType = ((data[offset + 2] & 0xc0) >>> 6) + 1;
+  adtsObjectType = originalAdtsObjectType =
+    ((data[offset + 2] & 0xc0) >>> 6) + 1;
   const adtsSamplingIndex = (data[offset + 2] & 0x3c) >>> 2;
   if (adtsSamplingIndex > adtsSamplingRates.length - 1) {
     const error = new Error(`invalid ADTS sampling index:${adtsSamplingIndex}`);
@@ -61,8 +64,8 @@ export function getAudioConfig(
   logger.log(
     `manifest codec:${audioCodec}, ADTS type:${adtsObjectType}, samplingIndex:${adtsSamplingIndex}`,
   );
-  // firefox: freq less than 24kHz = AAC SBR (HE-AAC)
-  if (/firefox/i.test(userAgent)) {
+  // Firefox and Pale Moon: freq less than 24kHz = AAC SBR (HE-AAC)
+  if (/firefox|palemoon/i.test(userAgent)) {
     if (adtsSamplingIndex >= 6) {
       adtsObjectType = 5;
       config = new Array(4);
@@ -167,6 +170,7 @@ export function getAudioConfig(
     samplerate: adtsSamplingRates[adtsSamplingIndex],
     channelCount: adtsChannelConfig,
     codec: 'mp4a.40.' + adtsObjectType,
+    parsedCodec: 'mp4a.40.' + originalAdtsObjectType,
     manifestCodec,
   };
 }
@@ -244,8 +248,9 @@ export function initTrackConfig(
     track.channelCount = config.channelCount;
     track.codec = config.codec;
     track.manifestCodec = config.manifestCodec;
+    track.parsedCodec = config.parsedCodec;
     logger.log(
-      `parsed codec:${track.codec}, rate:${config.samplerate}, channels:${config.channelCount}`,
+      `parsed codec:${track.parsedCodec}, codec:${track.codec}, rate:${config.samplerate}, channels:${config.channelCount}`,
     );
   }
 }

package/src/demux/audio/base-audio-demuxer.ts

@@ -1,19 +1,21 @@
-import * as ID3 from '../id3';
 import {
-  DemuxerResult,
-  Demuxer,
-  DemuxedAudioTrack,
-  AudioFrame,
-  DemuxedMetadataTrack,
-  DemuxedVideoTrackBase,
-  DemuxedUserdataTrack,
-  KeyData,
+  type DemuxerResult,
+  type Demuxer,
+  type DemuxedAudioTrack,
+  type AudioFrame,
+  type DemuxedMetadataTrack,
+  type DemuxedVideoTrackBase,
+  type DemuxedUserdataTrack,
+  type KeyData,
   MetadataSchema,
 } from '../../types/demuxer';
 import { dummyTrack } from '../dummy-demuxed-track';
 import { appendUint8Array } from '../../utils/mp4-tools';
 import { sliceUint8 } from '../../utils/typed-array';
 import { RationalTimestamp } from '../../utils/timescale-conversion';
+import { getId3Data } from '@svta/common-media-library/id3/getId3Data';
+import { getId3Timestamp } from '@svta/common-media-library/id3/getId3Timestamp';
+import { canParseId3 } from '@svta/common-media-library/id3/canParseId3';
 
 class BaseAudioDemuxer implements Demuxer {
   protected _audioTrack!: DemuxedAudioTrack;
@@ -69,12 +71,12 @@ class BaseAudioDemuxer implements Demuxer {
       this.cachedData = null;
     }
 
-    let id3Data: Uint8Array | undefined = ID3.getID3Data(data, 0);
+    let id3Data: Uint8Array | undefined = getId3Data(data, 0);
     let offset = id3Data ? id3Data.length : 0;
     let lastDataIndex;
     const track = this._audioTrack;
     const id3Track = this._id3Track;
-    const timestamp = id3Data ? ID3.getTimeStamp(id3Data) : undefined;
+    const timestamp = id3Data ? getId3Timestamp(id3Data) : undefined;
     const length = data.length;
 
     if (
@@ -111,9 +113,9 @@ class BaseAudioDemuxer implements Demuxer {
         } else {
           offset = length;
         }
-      } else if (ID3.canParse(data, offset)) {
-        // after a ID3.canParse, a call to ID3.getID3Data *should* always returns some data
-        id3Data = ID3.getID3Data(data, offset)!;
+      } else if (canParseId3(data, offset)) {
+        // after a canParse, a call to getId3Data *should* always returns some data
+        id3Data = getId3Data(data, offset)!;
         id3Track.samples.push({
           pts: this.lastPTS,
           dts: this.lastPTS,

package/src/demux/audio/mp3demuxer.ts

@@ -2,10 +2,11 @@
  * MP3 demuxer
  */
 import BaseAudioDemuxer from './base-audio-demuxer';
-import { getID3Data, getTimeStamp } from '../id3';
 import { getAudioBSID } from './dolby';
 import { logger } from '../../utils/logger';
 import * as MpegAudio from './mpegaudio';
+import { getId3Data } from '@svta/common-media-library/id3/getId3Data';
+import { getId3Timestamp } from '@svta/common-media-library/id3/getId3Timestamp';
 
 class MP3Demuxer extends BaseAudioDemuxer {
   resetInitSegment(
@@ -39,7 +40,7 @@ class MP3Demuxer extends BaseAudioDemuxer {
     // Look for MPEG header | 1111 1111 | 111X XYZX | where X can be either 0 or 1 and Y or Z should be 1
     // Layer bits (position 14 and 15) in header should be always different from 0 (Layer I or Layer II or Layer III)
     // More info http://www.mp3-tech.org/programmer/frame_header.html
-    const id3Data = getID3Data(data, 0);
+    const id3Data = getId3Data(data, 0);
     let offset = id3Data?.length || 0;
 
     // Check for ac-3|ec-3 sync bytes and return false if present
@@ -47,7 +48,7 @@ class MP3Demuxer extends BaseAudioDemuxer {
       id3Data &&
       data[offset] === 0x0b &&
       data[offset + 1] === 0x77 &&
-      getTimeStamp(id3Data) !== undefined &&
+      getId3Timestamp(id3Data) !== undefined &&
       // check the bsid to confirm ac-3 or ec-3 (not mp3)
       getAudioBSID(data, offset) <= 16
     ) {

package/src/demux/audio/mpegaudio.ts

@@ -1,7 +1,7 @@
 /**
  *  MPEG parser helper
  */
-import { DemuxedAudioTrack } from '../../types/demuxer';
+import type { DemuxedAudioTrack } from '../../types/demuxer';
 
 let chromeVersion: number | null = null;
 

package/src/demux/mp4demuxer.ts

@@ -2,13 +2,13 @@
  * MP4 demuxer
  */
 import {
-  Demuxer,
-  DemuxerResult,
-  PassthroughTrack,
-  DemuxedAudioTrack,
-  DemuxedUserdataTrack,
-  DemuxedMetadataTrack,
-  KeyData,
+  type Demuxer,
+  type DemuxerResult,
+  type PassthroughTrack,
+  type DemuxedAudioTrack,
+  type DemuxedUserdataTrack,
+  type DemuxedMetadataTrack,
+  type KeyData,
   MetadataSchema,
 } from '../types/demuxer';
 import {

package/src/demux/sample-aes.ts

@@ -4,6 +4,7 @@
 
 import { HlsConfig } from '../config';
 import Decrypter from '../crypt/decrypter';
+import { DecrypterAesMode } from '../crypt/decrypter-aes-mode';
 import { HlsEventEmitter } from '../events';
 import type {
   AudioSample,
@@ -30,6 +31,7 @@ class SampleAesDecrypter {
       encryptedData,
       this.keyData.key.buffer,
       this.keyData.iv.buffer,
+      DecrypterAesMode.cbc,
     );
   }
 

package/src/demux/transmuxer-interface.ts

@@ -12,14 +12,13 @@ import Transmuxer, {
 } from '../demux/transmuxer';
 import { logger } from '../utils/logger';
 import { ErrorTypes, ErrorDetails } from '../errors';
-import { getMediaSource } from '../utils/mediasource-helper';
 import { EventEmitter } from 'eventemitter3';
-import { Fragment, Part } from '../loader/fragment';
+import { MediaFragment, Part } from '../loader/fragment';
+import { getM2TSSupportedAudioTypes } from '../utils/codecs';
 import type { ChunkMetadata, TransmuxerResult } from '../types/transmuxer';
 import type Hls from '../hls';
 import type { HlsEventEmitter, HlsListeners } from '../events';
 import type { PlaylistLevelType } from '../types/loader';
-import type { TypeSupported } from './tsdemuxer';
 import type { RationalTimestamp } from '../utils/timescale-conversion';
 
 export default class TransmuxerInterface {
@@ -27,7 +26,7 @@ export default class TransmuxerInterface {
   private hls: Hls;
   private id: PlaylistLevelType;
   private observer: HlsEventEmitter;
-  private frag: Fragment | null = null;
+  private frag: MediaFragment | null = null;
   private part: Part | null = null;
   private useWorker: boolean;
   private workerContext: WorkerContext | null = null;
@@ -66,16 +65,9 @@ export default class TransmuxerInterface {
     this.observer.on(Events.FRAG_DECRYPTED, forwardMessage);
     this.observer.on(Events.ERROR, forwardMessage);
 
-    const MediaSource = getMediaSource(config.preferManagedMediaSource) || {
-      isTypeSupported: () => false,
-    };
-    const m2tsTypeSupported: TypeSupported = {
-      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,
-    };
+    const m2tsTypeSupported = getM2TSSupportedAudioTypes(
+      config.preferManagedMediaSource,
+    );
 
     if (this.useWorker && typeof Worker !== 'undefined') {
       const canCreateWorker = config.workerPath || hasUMDWorker();
@@ -181,7 +173,7 @@ export default class TransmuxerInterface {
     initSegmentData: Uint8Array | undefined,
     audioCodec: string | undefined,
     videoCodec: string | undefined,
-    frag: Fragment,
+    frag: MediaFragment,
     part: Part | null,
     duration: number,
     accurateTimeOffset: boolean,
@@ -197,7 +189,7 @@ export default class TransmuxerInterface {
 
     const discontinuity = !(lastFrag && frag.cc === lastFrag.cc);
     const trackSwitch = !(lastFrag && chunkMeta.level === lastFrag.level);
-    const snDiff = lastFrag ? chunkMeta.sn - (lastFrag.sn as number) : -1;
+    const snDiff = lastFrag ? chunkMeta.sn - lastFrag.sn : -1;
     const partDiff = this.part ? chunkMeta.part - this.part.index : -1;
     const progressive =
       snDiff === 0 &&

package/src/demux/transmuxer-worker.ts

@@ -1,6 +1,6 @@
 import Transmuxer, { isPromise } from '../demux/transmuxer';
 import { Events } from '../events';
-import { ILogFunction, enableLogs, logger } from '../utils/logger';
+import { enableLogs, type ILogFunction, type ILogger } from '../utils/logger';
 import { EventEmitter } from 'eventemitter3';
 import { ErrorDetails, ErrorTypes } from '../errors';
 import type { RemuxedTrack, RemuxerResult } from '../types/remuxer';
@@ -21,7 +21,7 @@ function startWorker(self) {
   observer.on(Events.ERROR, forwardMessage);
 
   // forward logger events to main thread
-  const forwardWorkerLogs = () => {
+  const forwardWorkerLogs = (logger: ILogger) => {
     for (const logFn in logger) {
       const func: ILogFunction = (message?) => {
         forwardMessage('workerLog', {
@@ -46,8 +46,8 @@ function startWorker(self) {
           '',
           data.id,
         );
-        enableLogs(config.debug, data.id);
-        forwardWorkerLogs();
+        const logger = enableLogs(config.debug, data.id);
+        forwardWorkerLogs(logger);
         forwardMessage('init', null);
         break;
       }

package/src/demux/transmuxer.ts

@@ -4,18 +4,23 @@ import { ErrorTypes, ErrorDetails } from '../errors';
 import Decrypter from '../crypt/decrypter';
 import AACDemuxer from './audio/aacdemuxer';
 import MP4Demuxer from '../demux/mp4demuxer';
-import TSDemuxer, { TypeSupported } from '../demux/tsdemuxer';
+import TSDemuxer 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 { logger } from '../utils/logger';
+import {
+  isFullSegmentEncryption,
+  getAesModeFromFullSegmentMethod,
+} from '../utils/encryption-methods-util';
 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 { PlaylistLevelType } from '../types/loader';
+import type { TypeSupported } from '../utils/codecs';
 import type { RationalTimestamp } from '../utils/timescale-conversion';
 import { optionalSelf } from '../utils/global';
 
@@ -114,8 +119,10 @@ export default class Transmuxer {
     } = transmuxConfig;
 
     const keyData = getEncryptionType(uintData, decryptdata);
-    if (keyData && keyData.method === 'AES-128') {
+    if (keyData && isFullSegmentEncryption(keyData.method)) {
       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
@@ -124,6 +131,7 @@ 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;
@@ -137,7 +145,12 @@ export default class Transmuxer {
         uintData = new Uint8Array(decryptedData);
       } else {
         this.decryptionPromise = decrypter
-          .webCryptoDecrypt(uintData, keyData.key.buffer, keyData.iv.buffer)
+          .webCryptoDecrypt(
+            uintData,
+            keyData.key.buffer,
+            keyData.iv.buffer,
+            aesMode,
+          )
           .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

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 NAL units and AAC/ADTS samples from PES packet
+ * extract AVC/H264 (or HEVC/H265) 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,7 +12,9 @@
 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';
@@ -20,20 +22,21 @@ 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 {
-  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 { AudioFrame } from '../types/demuxer';
+import type { AudioFrame } from '../types/demuxer';
 
 export type ParsedTimestamp = {
   pts?: number;
@@ -48,12 +51,6 @@ 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 {
@@ -74,7 +71,7 @@ class TSDemuxer implements Demuxer {
   private _txtTrack?: DemuxedUserdataTrack;
   private aacOverFlow: AudioFrame | null = null;
   private remainderData: Uint8Array | null = null;
-  private videoParser: AvcVideoParser;
+  private videoParser: BaseVideoParser | null;
 
   constructor(
     observer: HlsEventEmitter,
@@ -84,7 +81,7 @@ class TSDemuxer implements Demuxer {
     this.observer = observer;
     this.config = config;
     this.typeSupported = typeSupported;
-    this.videoParser = new AvcVideoParser();
+    this.videoParser = null;
   }
 
   static probe(data: Uint8Array) {
@@ -292,13 +289,27 @@ class TSDemuxer implements Demuxer {
           case videoPid:
             if (stt) {
               if (videoData && (pes = parsePES(videoData))) {
-                this.videoParser.parseAVCPES(
-                  videoTrack,
-                  textTrack,
-                  pes,
-                  false,
-                  this._duration,
-                );
+                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,
+                    this._duration,
+                  );
+                }
               }
 
               videoData = { data: [], size: 0 };
@@ -467,14 +478,28 @@ class TSDemuxer implements Demuxer {
     // try to parse last PES packets
     let pes: PES | null;
     if (videoData && (pes = parsePES(videoData))) {
-      this.videoParser.parseAVCPES(
-        videoTrack as DemuxedVideoTrack,
-        textTrack as DemuxedUserdataTrack,
-        pes,
-        true,
-        this._duration,
-      );
-      videoTrack.pesData = null;
+      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,
+          this._duration,
+        );
+        videoTrack.pesData = null;
+      }
     } else {
       // either avcData null or PES truncated, keep it for next frag parsing
       videoTrack.pesData = videoData;
@@ -864,9 +889,21 @@ function parsePMT(
         emitParsingError(observer, new Error('Unsupported EC-3 in M2TS found'));
         return result;
 
-      case 0x24:
-        emitParsingError(observer, new Error('Unsupported HEVC 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'),
+          );
+          return result;
+        }
+        break;
 
       default:
         // logger.log('unknown stream type:' + data[offset]);