hls.js 1.5.7 → 1.5.8-0.canary.10044

package/src/controller/subtitle-stream-controller.ts

@@ -9,6 +9,10 @@ import { PlaylistLevelType } from '../types/loader';
 import { Level } from '../types/level';
 import { subtitleOptionsIdentical } from '../utils/media-option-attributes';
 import { ErrorDetails, ErrorTypes } from '../errors';
+import {
+  isFullSegmentEncryption,
+  getAesModeFromFullSegmentMethod,
+} from '../utils/encryption-methods-util';
 import type { NetworkComponentAPI } from '../types/component-api';
 import type Hls from '../hls';
 import type { FragmentTracker } from './fragment-tracker';
@@ -51,25 +55,22 @@ export class SubtitleStreamController
       hls,
       fragmentTracker,
       keyLoader,
-      '[subtitle-stream-controller]',
+      'subtitle-stream-controller',
       PlaylistLevelType.SUBTITLE,
     );
-    this._registerListeners();
+    this.registerListeners();
   }
 
   protected onHandlerDestroying() {
-    this._unregisterListeners();
+    this.unregisterListeners();
     super.onHandlerDestroying();
     this.mainDetails = null;
   }
 
-  private _registerListeners() {
+  protected registerListeners() {
+    super.registerListeners();
     const { hls } = this;
-    hls.on(Events.MEDIA_ATTACHED, this.onMediaAttached, this);
-    hls.on(Events.MEDIA_DETACHING, this.onMediaDetaching, this);
-    hls.on(Events.MANIFEST_LOADING, this.onManifestLoading, this);
     hls.on(Events.LEVEL_LOADED, this.onLevelLoaded, this);
-    hls.on(Events.ERROR, this.onError, this);
     hls.on(Events.SUBTITLE_TRACKS_UPDATED, this.onSubtitleTracksUpdated, this);
     hls.on(Events.SUBTITLE_TRACK_SWITCH, this.onSubtitleTrackSwitch, this);
     hls.on(Events.SUBTITLE_TRACK_LOADED, this.onSubtitleTrackLoaded, this);
@@ -78,13 +79,10 @@ export class SubtitleStreamController
     hls.on(Events.FRAG_BUFFERED, this.onFragBuffered, this);
   }
 
-  private _unregisterListeners() {
+  protected unregisterListeners() {
+    super.unregisterListeners();
     const { hls } = this;
-    hls.off(Events.MEDIA_ATTACHED, this.onMediaAttached, this);
-    hls.off(Events.MEDIA_DETACHING, this.onMediaDetaching, this);
-    hls.off(Events.MANIFEST_LOADING, this.onManifestLoading, this);
     hls.off(Events.LEVEL_LOADED, this.onLevelLoaded, this);
-    hls.off(Events.ERROR, this.onError, this);
     hls.off(Events.SUBTITLE_TRACKS_UPDATED, this.onSubtitleTracksUpdated, this);
     hls.off(Events.SUBTITLE_TRACK_SWITCH, this.onSubtitleTrackSwitch, this);
     hls.off(Events.SUBTITLE_TRACK_LOADED, this.onSubtitleTrackLoaded, this);
@@ -107,21 +105,21 @@ export class SubtitleStreamController
     this.tick();
   }
 
-  onManifestLoading() {
+  protected onManifestLoading() {
     this.mainDetails = null;
     this.fragmentTracker.removeAllFragments();
   }
 
-  onMediaDetaching(): void {
+  protected onMediaDetaching(): void {
     this.tracksBuffered = [];
     super.onMediaDetaching();
   }
 
-  onLevelLoaded(event: Events.LEVEL_LOADED, data: LevelLoadedData) {
+  private onLevelLoaded(event: Events.LEVEL_LOADED, data: LevelLoadedData) {
     this.mainDetails = data.details;
   }
 
-  onSubtitleFragProcessed(
+  private onSubtitleFragProcessed(
     event: Events.SUBTITLE_FRAG_PROCESSED,
     data: SubtitleFragProcessed,
   ) {
@@ -162,7 +160,10 @@ export class SubtitleStreamController
     this.fragBufferedComplete(frag, null);
   }
 
-  onBufferFlushing(event: Events.BUFFER_FLUSHING, data: BufferFlushingData) {
+  private onBufferFlushing(
+    event: Events.BUFFER_FLUSHING,
+    data: BufferFlushingData,
+  ) {
     const { startOffset, endOffset } = data;
     if (startOffset === 0 && endOffset !== Number.POSITIVE_INFINITY) {
       const endOffsetSubtitles = endOffset - 1;
@@ -191,7 +192,7 @@ export class SubtitleStreamController
     }
   }
 
-  onFragBuffered(event: Events.FRAG_BUFFERED, data: FragBufferedData) {
+  private onFragBuffered(event: Events.FRAG_BUFFERED, data: FragBufferedData) {
     if (!this.loadedmetadata && data.frag.type === PlaylistLevelType.MAIN) {
       if (this.media?.buffered.length) {
         this.loadedmetadata = true;
@@ -200,7 +201,7 @@ export class SubtitleStreamController
   }
 
   // If something goes wrong, proceed to next frag, if we were processing one.
-  onError(event: Events.ERROR, data: ErrorData) {
+  protected onError(event: Events.ERROR, data: ErrorData) {
     const frag = data.frag;
 
     if (frag?.type === PlaylistLevelType.SUBTITLE) {
@@ -214,7 +215,7 @@ export class SubtitleStreamController
   }
 
   // Got all new subtitle levels.
-  onSubtitleTracksUpdated(
+  private onSubtitleTracksUpdated(
     event: Events.SUBTITLE_TRACKS_UPDATED,
     { subtitleTracks }: SubtitleTracksUpdatedData,
   ) {
@@ -239,7 +240,7 @@ export class SubtitleStreamController
     this.mediaBuffer = null;
   }
 
-  onSubtitleTrackSwitch(
+  private onSubtitleTrackSwitch(
     event: Events.SUBTITLE_TRACK_SWITCH,
     data: TrackSwitchedData,
   ) {
@@ -257,13 +258,13 @@ export class SubtitleStreamController
     } else {
       this.mediaBuffer = null;
     }
-    if (currentTrack) {
+    if (currentTrack && this.state !== State.STOPPED) {
       this.setInterval(TICK_INTERVAL);
     }
   }
 
   // Got a new set of subtitle fragments.
-  onSubtitleTrackLoaded(
+  private onSubtitleTrackLoaded(
     event: Events.SUBTITLE_TRACK_LOADED,
     data: TrackLoadedData,
   ) {
@@ -360,7 +361,7 @@ export class SubtitleStreamController
       payload.byteLength > 0 &&
       decryptData?.key &&
       decryptData.iv &&
-      decryptData.method === 'AES-128'
+      isFullSegmentEncryption(decryptData.method)
     ) {
       const startTime = performance.now();
       // decrypt the subtitles
@@ -369,6 +370,7 @@ export class SubtitleStreamController
           new Uint8Array(payload),
           decryptData.key.buffer,
           decryptData.iv.buffer,
+          getAesModeFromFullSegmentMethod(decryptData.method),
         )
         .catch((err) => {
           hls.trigger(Events.ERROR, {
@@ -419,15 +421,9 @@ export class SubtitleStreamController
         config.maxBufferHole,
       );
       const { end: targetBufferTime, len: bufferLen } = bufferedInfo;
-
-      const mainBufferInfo = this.getFwdBufferInfo(
-        this.media,
-        PlaylistLevelType.MAIN,
-      );
       const trackDetails = track.details as LevelDetails;
       const maxBufLen =
-        this.getMaxBufferLength(mainBufferInfo?.len) +
-        trackDetails.levelTargetDuration;
+        this.hls.maxBufferLength + trackDetails.levelTargetDuration;
 
       if (bufferLen > maxBufLen) {
         return;
@@ -483,14 +479,6 @@ export class SubtitleStreamController
     }
   }
 
-  protected getMaxBufferLength(mainBufferLength?: number): number {
-    const maxConfigBuffer = super.getMaxBufferLength();
-    if (!mainBufferLength) {
-      return maxConfigBuffer;
-    }
-    return Math.max(maxConfigBuffer, mainBufferLength);
-  }
-
   protected loadFragment(
     frag: Fragment,
     level: Level,

package/src/controller/subtitle-track-controller.ts

@@ -35,13 +35,14 @@ class SubtitleTrackController extends BasePlaylistController {
   private currentTrack: MediaPlaylist | null = null;
   private selectDefaultTrack: boolean = true;
   private queuedDefaultTrack: number = -1;
-  private asyncPollTrackChange: () => void = () => this.pollTrackChange(0);
   private useTextTrackPolling: boolean = false;
   private subtitlePollingInterval: number = -1;
   private _subtitleDisplay: boolean = true;
 
+  private asyncPollTrackChange = () => this.pollTrackChange(0);
+
   constructor(hls: Hls) {
-    super(hls, '[subtitle-track-controller]');
+    super(hls, 'subtitle-track-controller');
     this.registerListeners();
   }
 
@@ -50,7 +51,8 @@ class SubtitleTrackController extends BasePlaylistController {
     this.tracks.length = 0;
     this.tracksInGroup.length = 0;
     this.currentTrack = null;
-    this.onTextTracksChanged = this.asyncPollTrackChange = null as any;
+    // @ts-ignore
+    this.onTextTracksChanged = this.asyncPollTrackChange = null;
     super.destroy();
   }
 

package/src/controller/timeline-controller.ts

@@ -28,7 +28,6 @@ import type {
   BufferFlushingData,
   FragLoadingData,
 } from '../types/events';
-import { logger } from '../utils/logger';
 import type Hls from '../hls';
 import type { ComponentAPI } from '../types/component-api';
 import type { HlsConfig } from '../config';
@@ -136,17 +135,12 @@ export class TimelineController implements ComponentAPI {
   }
 
   private initCea608Parsers() {
-    if (
-      this.config.enableCEA708Captions &&
-      (!this.cea608Parser1 || !this.cea608Parser2)
-    ) {
-      const channel1 = new OutputFilter(this, 'textTrack1');
-      const channel2 = new OutputFilter(this, 'textTrack2');
-      const channel3 = new OutputFilter(this, 'textTrack3');
-      const channel4 = new OutputFilter(this, 'textTrack4');
-      this.cea608Parser1 = new Cea608Parser(1, channel1, channel2);
-      this.cea608Parser2 = new Cea608Parser(3, channel3, channel4);
-    }
+    const channel1 = new OutputFilter(this, 'textTrack1');
+    const channel2 = new OutputFilter(this, 'textTrack2');
+    const channel3 = new OutputFilter(this, 'textTrack3');
+    const channel4 = new OutputFilter(this, 'textTrack4');
+    this.cea608Parser1 = new Cea608Parser(1, channel1, channel2);
+    this.cea608Parser2 = new Cea608Parser(3, channel3, channel4);
   }
 
   public addCues(
@@ -410,7 +404,7 @@ export class TimelineController implements ComponentAPI {
             .filter((t) => t !== null)
             .map((t) => (t as TextTrack).label);
           if (unusedTextTracks.length) {
-            logger.warn(
+            this.hls.logger.warn(
               `Media element contains unused subtitle tracks: ${unusedTextTracks.join(
                 ', ',
               )}. Replace media element for each source to clear TextTracks and captions menu.`,
@@ -468,21 +462,19 @@ export class TimelineController implements ComponentAPI {
   }
 
   private onFragLoading(event: Events.FRAG_LOADING, data: FragLoadingData) {
-    this.initCea608Parsers();
-    const { cea608Parser1, cea608Parser2, lastCc, lastSn, lastPartIndex } =
-      this;
-    if (!this.enabled || !cea608Parser1 || !cea608Parser2) {
-      return;
-    }
     // if this frag isn't contiguous, clear the parser so cues with bad start/end times aren't added to the textTrack
-    if (data.frag.type === PlaylistLevelType.MAIN) {
+    if (this.enabled && data.frag.type === PlaylistLevelType.MAIN) {
+      const { cea608Parser1, cea608Parser2, lastSn } = this;
+      if (!cea608Parser1 || !cea608Parser2) {
+        return;
+      }
       const { cc, sn } = data.frag;
-      const partIndex = data?.part?.index ?? -1;
+      const partIndex = data.part?.index ?? -1;
       if (
         !(
           sn === lastSn + 1 ||
-          (sn === lastSn && partIndex === lastPartIndex + 1) ||
-          cc === lastCc
+          (sn === lastSn && partIndex === this.lastPartIndex + 1) ||
+          cc === this.lastCc
         )
       ) {
         cea608Parser1.reset();
@@ -550,7 +542,7 @@ export class TimelineController implements ComponentAPI {
         });
       },
       (error) => {
-        logger.log(`Failed to parse IMSC1: ${error}`);
+        hls.logger.log(`Failed to parse IMSC1: ${error}`);
         hls.trigger(Events.SUBTITLE_FRAG_PROCESSED, {
           success: false,
           frag: frag,
@@ -597,7 +589,7 @@ export class TimelineController implements ComponentAPI {
           this._fallbackToIMSC1(frag, payload);
         }
         // Something went wrong while parsing. Trigger event with success false.
-        logger.log(`Failed to parse VTT cue: ${error}`);
+        hls.logger.log(`Failed to parse VTT cue: ${error}`);
         if (missingInitPTS && maxAvCC > frag.cc) {
           return;
         }
@@ -669,9 +661,7 @@ export class TimelineController implements ComponentAPI {
     event: Events.FRAG_PARSING_USERDATA,
     data: FragParsingUserdataData,
   ) {
-    this.initCea608Parsers();
-    const { cea608Parser1, cea608Parser2 } = this;
-    if (!this.enabled || !cea608Parser1 || !cea608Parser2) {
+    if (!this.enabled || !this.config.enableCEA708Captions) {
       return;
     }
     const { frag, samples } = data;
@@ -686,9 +676,12 @@ export class TimelineController implements ComponentAPI {
     for (let i = 0; i < samples.length; i++) {
       const ccBytes = samples[i].bytes;
       if (ccBytes) {
+        if (!this.cea608Parser1) {
+          this.initCea608Parsers();
+        }
         const ccdatas = this.extractCea608Data(ccBytes);
-        cea608Parser1.addData(samples[i].pts, ccdatas[0]);
-        cea608Parser2.addData(samples[i].pts, ccdatas[1]);
+        this.cea608Parser1!.addData(samples[i].pts, ccdatas[0]);
+        this.cea608Parser2!.addData(samples[i].pts, ccdatas[1]);
       }
     }
   }

package/src/crypt/aes-crypto.ts

@@ -1,13 +1,32 @@
+import { DecrypterAesMode } from './decrypter-aes-mode';
+
 export default class AESCrypto {
   private subtle: SubtleCrypto;
   private aesIV: Uint8Array;
+  private aesMode: DecrypterAesMode;
 
-  constructor(subtle: SubtleCrypto, iv: Uint8Array) {
+  constructor(subtle: SubtleCrypto, iv: Uint8Array, aesMode: DecrypterAesMode) {
     this.subtle = subtle;
     this.aesIV = iv;
+    this.aesMode = aesMode;
   }
 
   decrypt(data: ArrayBuffer, key: CryptoKey) {
-    return this.subtle.decrypt({ name: 'AES-CBC', iv: this.aesIV }, key, data);
+    switch (this.aesMode) {
+      case DecrypterAesMode.cbc:
+        return this.subtle.decrypt(
+          { name: 'AES-CBC', iv: this.aesIV },
+          key,
+          data,
+        );
+      case DecrypterAesMode.ctr:
+        return this.subtle.decrypt(
+          { name: 'AES-CTR', counter: this.aesIV, length: 64 }, //64 : NIST SP800-38A standard suggests that the counter should occupy half of the counter block
+          key,
+          data,
+        );
+      default:
+        throw new Error(`[AESCrypto] invalid aes mode ${this.aesMode}`);
+    }
   }
 }

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

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

package/src/crypt/decrypter.ts

@@ -4,6 +4,7 @@ import AESDecryptor, { removePadding } from './aes-decryptor';
 import { logger } from '../utils/logger';
 import { appendUint8Array } from '../utils/mp4-tools';
 import { sliceUint8 } from '../utils/typed-array';
+import { DecrypterAesMode } from './decrypter-aes-mode';
 import type { HlsConfig } from '../config';
 
 const CHUNK_SIZE = 16; // 16 bytes, 128 bits
@@ -19,9 +20,10 @@ export default class Decrypter {
   private currentIV: ArrayBuffer | null = null;
   private currentResult: ArrayBuffer | null = null;
   private useSoftware: boolean;
+  private enableSoftwareAES: boolean;
 
   constructor(config: HlsConfig, { removePKCS7Padding = true } = {}) {
-    this.useSoftware = config.enableSoftwareAES;
+    this.enableSoftwareAES = config.enableSoftwareAES;
     this.removePKCS7Padding = removePKCS7Padding;
     // built in decryptor expects PKCS7 padding
     if (removePKCS7Padding) {
@@ -36,9 +38,7 @@ export default class Decrypter {
         /* no-op */
       }
     }
-    if (this.subtle === null) {
-      this.useSoftware = true;
-    }
+    this.useSoftware = this.subtle === null;
   }
 
   destroy() {
@@ -82,10 +82,11 @@ export default class Decrypter {
     data: Uint8Array | ArrayBuffer,
     key: ArrayBuffer,
     iv: ArrayBuffer,
+    aesMode: DecrypterAesMode,
   ): Promise<ArrayBuffer> {
     if (this.useSoftware) {
       return new Promise((resolve, reject) => {
-        this.softwareDecrypt(new Uint8Array(data), key, iv);
+        this.softwareDecrypt(new Uint8Array(data), key, iv, aesMode);
         const decryptResult = this.flush();
         if (decryptResult) {
           resolve(decryptResult.buffer);
@@ -94,7 +95,7 @@ export default class Decrypter {
         }
       });
     }
-    return this.webCryptoDecrypt(new Uint8Array(data), key, iv);
+    return this.webCryptoDecrypt(new Uint8Array(data), key, iv, aesMode);
   }
 
   // Software decryption is progressive. Progressive decryption may not return a result on each call. Any cached
@@ -103,8 +104,13 @@ export default class Decrypter {
     data: Uint8Array,
     key: ArrayBuffer,
     iv: ArrayBuffer,
+    aesMode: DecrypterAesMode,
   ): ArrayBuffer | null {
     const { currentIV, currentResult, remainderData } = this;
+    if (aesMode !== DecrypterAesMode.cbc || key.byteLength !== 16) {
+      logger.warn('SoftwareDecrypt: can only handle AES-128-CBC');
+      return null;
+    }
     this.logOnce('JS AES decrypt');
     // The output is staggered during progressive parsing - the current result is cached, and emitted on the next call
     // This is done in order to strip PKCS7 padding, which is found at the end of each segment. We only know we've reached
@@ -147,21 +153,22 @@ export default class Decrypter {
     data: Uint8Array,
     key: ArrayBuffer,
     iv: ArrayBuffer,
+    aesMode: DecrypterAesMode,
   ): Promise<ArrayBuffer> {
     const subtle = this.subtle;
     if (this.key !== key || !this.fastAesKey) {
       this.key = key;
-      this.fastAesKey = new FastAESKey(subtle, key);
+      this.fastAesKey = new FastAESKey(subtle, key, aesMode);
     }
     return this.fastAesKey
       .expandKey()
-      .then((aesKey) => {
+      .then((aesKey: CryptoKey) => {
         // decrypt using web crypto
         if (!subtle) {
           return Promise.reject(new Error('web crypto not initialized'));
         }
         this.logOnce('WebCrypto AES decrypt');
-        const crypto = new AESCrypto(subtle, new Uint8Array(iv));
+        const crypto = new AESCrypto(subtle, new Uint8Array(iv), aesMode);
         return crypto.decrypt(data.buffer, aesKey);
       })
       .catch((err) => {
@@ -169,19 +176,26 @@ export default class Decrypter {
           `[decrypter]: WebCrypto Error, disable WebCrypto API, ${err.name}: ${err.message}`,
         );
 
-        return this.onWebCryptoError(data, key, iv);
+        return this.onWebCryptoError(data, key, iv, aesMode);
       });
   }
 
-  private onWebCryptoError(data, key, iv): ArrayBuffer | never {
-    this.useSoftware = true;
-    this.logEnabled = true;
-    this.softwareDecrypt(data, key, iv);
-    const decryptResult = this.flush();
-    if (decryptResult) {
-      return decryptResult.buffer;
+  private onWebCryptoError(data, key, iv, aesMode): ArrayBuffer | never {
+    const enableSoftwareAES = this.enableSoftwareAES;
+    if (enableSoftwareAES) {
+      this.useSoftware = true;
+      this.logEnabled = true;
+      this.softwareDecrypt(data, key, iv, aesMode);
+      const decryptResult = this.flush();
+      if (decryptResult) {
+        return decryptResult.buffer;
+      }
     }
-    throw new Error('WebCrypto and softwareDecrypt: failed to decrypt data');
+    throw new Error(
+      'WebCrypto' +
+        (enableSoftwareAES ? ' and softwareDecrypt' : '') +
+        ': failed to decrypt data',
+    );
   }
 
   private getValidChunk(data: Uint8Array): Uint8Array {

package/src/crypt/fast-aes-key.ts

@@ -1,16 +1,35 @@
+import { DecrypterAesMode } from './decrypter-aes-mode';
+
 export default class FastAESKey {
   private subtle: any;
   private key: ArrayBuffer;
+  private aesMode: DecrypterAesMode;
 
-  constructor(subtle, key) {
+  constructor(subtle, key, aesMode: DecrypterAesMode) {
     this.subtle = subtle;
     this.key = key;
+    this.aesMode = aesMode;
   }
 
   expandKey() {
-    return this.subtle.importKey('raw', this.key, { name: 'AES-CBC' }, false, [
-      'encrypt',
-      'decrypt',
-    ]);
+    const subtleAlgoName = getSubtleAlgoName(this.aesMode);
+    return this.subtle.importKey(
+      'raw',
+      this.key,
+      { name: subtleAlgoName },
+      false,
+      ['encrypt', 'decrypt'],
+    );
+  }
+}
+
+function getSubtleAlgoName(aesMode: DecrypterAesMode) {
+  switch (aesMode) {
+    case DecrypterAesMode.cbc:
+      return 'AES-CBC';
+    case DecrypterAesMode.ctr:
+      return 'AES-CTR';
+    default:
+      throw new Error(`[FastAESKey] invalid aes mode ${aesMode}`);
   }
 }

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/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 { getM2TSSupportedAudioTypes } from '../utils/codecs';
 import type { ChunkMetadata, TransmuxerResult } from '../types/transmuxer';
 import type Hls from '../hls';
 import type { HlsEventEmitter } from '../events';
 import type { PlaylistLevelType } from '../types/loader';
-import type { TypeSupported } from './tsdemuxer';
 import type { RationalTimestamp } from '../utils/timescale-conversion';
 
 export default class TransmuxerInterface {
@@ -64,16 +63,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,
+    );
 
     // navigator.vendor is not always available in Web Worker
     // refer to https://developer.mozilla.org/en-US/docs/Web/API/WorkerGlobalScope/navigator

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.vendor,
           data.id,
         );
-        enableLogs(config.debug, data.id);
-        forwardWorkerLogs();
+        const logger = enableLogs(config.debug, data.id);
+        forwardWorkerLogs(logger);
         forwardMessage('init', null);
         break;
       }