hls.js 1.6.0-beta.4.0.canary.11051 → 1.6.0-beta.4.0.canary.11054

package/package.json

@@ -134,5 +134,5 @@
     "url-toolkit": "2.2.5",
     "wrangler": "3.114.1"
   },
-  "version": "1.6.0-beta.4.0.canary.11051"
+  "version": "1.6.0-beta.4.0.canary.11054"
 }

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

@@ -157,7 +157,6 @@ export default class BaseStreamController
 
   protected onTickEnd() {}
 
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   public startLoad(startPosition: number): void {}
 
   public stopLoad() {
@@ -746,7 +745,6 @@ export default class BaseStreamController
     transmuxer.flush(chunkMeta);
   }
 
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   protected _handleFragmentLoadProgress(
     frag: PartsLoadedData | FragLoadedData,
   ) {}

package/src/controller/eme-controller.ts

@@ -554,7 +554,7 @@ class EMEController extends Logger implements ComponentAPI {
     this.keyFormatPromise.then((keySystemFormat) => {
       const keySystem = keySystemFormatToKeySystemDomain(keySystemFormat);
 
-      let keyId: Uint8Array | null | undefined;
+      let keyId: Uint8Array<ArrayBuffer> | null | undefined;
       let keySystemDomain: KeySystems | undefined;
 
       if (initDataType === 'sinf') {
@@ -574,7 +574,7 @@ class EMEController extends Logger implements ComponentAPI {
               `'schm' box missing or not cbcs/cenc with schi > tenc`,
             );
           }
-          keyId = tenc.subarray(8, 24);
+          keyId = new Uint8Array(tenc.subarray(8, 24));
           keySystemDomain = KeySystems.FAIRPLAY;
         } catch (error) {
           this.warn(`${logMessage} Failed to parse sinf: ${error}`);
@@ -629,7 +629,7 @@ class EMEController extends Logger implements ComponentAPI {
         if (psshInfo.version === 0 && psshInfo.data) {
           if (keySystemDomain === KeySystems.WIDEVINE) {
             const offset = psshInfo.data.length - 22;
-            keyId = psshInfo.data.subarray(offset, offset + 16);
+            keyId = new Uint8Array(psshInfo.data.subarray(offset, offset + 16));
           } else if (keySystemDomain === KeySystems.PLAYREADY) {
             keyId = parsePlayReadyWRM(psshInfo.data);
           }
@@ -696,7 +696,7 @@ class EMEController extends Logger implements ComponentAPI {
                 keySystemToKeySystemFormat(keySystem) ?? '',
               );
               decryptdata.pssh = new Uint8Array(initData);
-              decryptdata.keyId = keyId as Uint8Array;
+              decryptdata.keyId = keyId;
               return this.attemptSetMediaKeys(keySystem, mediaKeys).then(() => {
                 this.throwIfDestroyed();
                 const keySessionContext = this.createMediaKeySessionContext({

package/src/crypt/aes-decryptor.ts

@@ -1,12 +1,10 @@
-import { sliceUint8 } from '../utils/typed-array';
-
 // PKCS7
-export function removePadding(array: Uint8Array): Uint8Array {
+export function removePadding(array: Uint8Array<ArrayBuffer>) {
   const outputBytes = array.byteLength;
   const paddingBytes =
     outputBytes && new DataView(array.buffer).getUint8(outputBytes - 1);
   if (paddingBytes) {
-    return sliceUint8(array, 0, outputBytes - paddingBytes);
+    return array.slice(0, outputBytes - paddingBytes);
   }
   return array;
 }
@@ -216,7 +214,11 @@ export default class AESDecryptor {
     );
   }
 
-  decrypt(inputArrayBuffer: ArrayBuffer, offset: number, aesIV: ArrayBuffer) {
+  decrypt(
+    inputArrayBuffer: ArrayBufferLike,
+    offset: number,
+    aesIV: ArrayBuffer,
+  ) {
     const nRounds = this.keySize + 6;
     const invKeySchedule = this.invKeySchedule;
     const invSBOX = this.invSBox;

package/src/crypt/decrypter.ts

@@ -4,7 +4,6 @@ import { DecrypterAesMode } from './decrypter-aes-mode';
 import FastAESKey from './fast-aes-key';
 import { logger } from '../utils/logger';
 import { appendUint8Array } from '../utils/mp4-tools';
-import { sliceUint8 } from '../utils/typed-array';
 import type { HlsConfig } from '../config';
 
 const CHUNK_SIZE = 16; // 16 bytes, 128 bits
@@ -16,7 +15,7 @@ export default class Decrypter {
   private softwareDecrypter: AESDecryptor | null = null;
   private key: ArrayBuffer | null = null;
   private fastAesKey: FastAESKey | null = null;
-  private remainderData: Uint8Array | null = null;
+  private remainderData: Uint8Array<ArrayBuffer> | null = null;
   private currentIV: ArrayBuffer | null = null;
   private currentResult: ArrayBuffer | null = null;
   private useSoftware: boolean;
@@ -55,7 +54,7 @@ export default class Decrypter {
     return this.useSoftware;
   }
 
-  public flush(): Uint8Array | null {
+  public flush(): Uint8Array<ArrayBuffer> | null {
     const { currentResult, remainderData } = this;
     if (!currentResult || remainderData) {
       this.reset();
@@ -142,7 +141,7 @@ export default class Decrypter {
     const result = currentResult;
 
     this.currentResult = softwareDecrypter.decrypt(currentChunk.buffer, 0, iv);
-    this.currentIV = sliceUint8(currentChunk, -16).buffer;
+    this.currentIV = currentChunk.slice(-16).buffer;
 
     if (!result) {
       return null;
@@ -151,7 +150,7 @@ export default class Decrypter {
   }
 
   public webCryptoDecrypt(
-    data: Uint8Array,
+    data: Uint8Array<ArrayBuffer>,
     key: ArrayBuffer,
     iv: ArrayBuffer,
     aesMode: DecrypterAesMode,
@@ -210,8 +209,8 @@ export default class Decrypter {
     let currentChunk = data;
     const splitPoint = data.length - (data.length % CHUNK_SIZE);
     if (splitPoint !== data.length) {
-      currentChunk = sliceUint8(data, 0, splitPoint);
-      this.remainderData = sliceUint8(data, splitPoint);
+      currentChunk = data.slice(0, splitPoint);
+      this.remainderData = data.slice(splitPoint);
     }
     return currentChunk;
   }

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

@@ -13,7 +13,6 @@ import {
   MetadataSchema,
 } from '../../types/demuxer';
 import { appendUint8Array } from '../../utils/mp4-tools';
-import { sliceUint8 } from '../../utils/typed-array';
 import { dummyTrack } from '../dummy-demuxed-track';
 import type { RationalTimestamp } from '../../utils/timescale-conversion';
 
@@ -129,7 +128,7 @@ class BaseAudioDemuxer implements Demuxer {
         offset++;
       }
       if (offset === length && lastDataIndex !== length) {
-        const partialData = sliceUint8(data, lastDataIndex);
+        const partialData = data.slice(lastDataIndex);
         if (this.cachedData) {
           this.cachedData = appendUint8Array(this.cachedData, partialData);
         } else {

package/src/demux/sample-aes.ts

@@ -8,7 +8,7 @@ import { discardEPB } from '../utils/mp4-tools';
 import type { HlsConfig } from '../config';
 import type { HlsEventEmitter } from '../events';
 import type {
-  AudioSample,
+  AACAudioSample,
   DemuxedVideoTrackBase,
   KeyData,
   VideoSample,
@@ -37,7 +37,7 @@ class SampleAesDecrypter {
 
   // AAC - encrypt all full 16 bytes blocks starting from offset 16
   private decryptAacSample(
-    samples: AudioSample[],
+    samples: AACAudioSample[],
     sampleIndex: number,
     callback: () => void,
   ) {
@@ -67,7 +67,7 @@ class SampleAesDecrypter {
   }
 
   decryptAacSamples(
-    samples: AudioSample[],
+    samples: AACAudioSample[],
     sampleIndex: number,
     callback: () => void,
   ) {
@@ -109,10 +109,7 @@ class SampleAesDecrypter {
     return encryptedData;
   }
 
-  getAvcDecryptedUnit(
-    decodedData: Uint8Array,
-    decryptedData: ArrayLike<number> | ArrayBuffer | SharedArrayBuffer,
-  ) {
+  getAvcDecryptedUnit(decodedData: Uint8Array, decryptedData: ArrayBufferLike) {
     const uint8DecryptedData = new Uint8Array(decryptedData);
     let inputPos = 0;
     for (
@@ -139,15 +136,13 @@ class SampleAesDecrypter {
     const decodedData = discardEPB(curUnit.data);
     const encryptedData = this.getAvcEncryptedData(decodedData);
 
-    this.decryptBuffer(encryptedData.buffer).then(
-      (decryptedBuffer: ArrayBuffer) => {
-        curUnit.data = this.getAvcDecryptedUnit(decodedData, decryptedBuffer);
+    this.decryptBuffer(encryptedData.buffer).then((decryptedBuffer) => {
+      curUnit.data = this.getAvcDecryptedUnit(decodedData, decryptedBuffer);
 
-        if (!this.decrypter.isSync()) {
-          this.decryptAvcSamples(samples, sampleIndex, unitIndex + 1, callback);
-        }
-      },
-    );
+      if (!this.decrypter.isSync()) {
+        this.decryptAvcSamples(samples, sampleIndex, unitIndex + 1, callback);
+      }
+    });
   }
 
   decryptAvcSamples(

package/src/demux/transmuxer.ts

@@ -95,7 +95,7 @@ export default class Transmuxer {
     const stats = chunkMeta.transmuxing;
     stats.executeStart = now();
 
-    let uintData: Uint8Array = new Uint8Array(data);
+    let uintData: Uint8Array<ArrayBuffer> = new Uint8Array(data);
     const { currentTransmuxState, transmuxConfig } = this;
     if (state) {
       this.currentTransmuxState = state;

package/src/demux/tsdemuxer.ts

@@ -34,7 +34,7 @@ import { appendUint8Array, RemuxerTrackIdConfig } from '../utils/mp4-tools';
 import type { HlsConfig } from '../config';
 import type { HlsEventEmitter } from '../events';
 import type BaseVideoParser from './video/base-video-parser';
-import type { AudioFrame } from '../types/demuxer';
+import type { AudioFrame, DemuxedAAC } from '../types/demuxer';
 import type { TypeSupported } from '../utils/codecs';
 import type { ILogger } from '../utils/logger';
 
@@ -564,15 +564,19 @@ class TSDemuxer implements Demuxer {
     return new Promise((resolve) => {
       const { audioTrack, videoTrack } = demuxResult;
       if (audioTrack.samples && audioTrack.segmentCodec === 'aac') {
-        sampleAes.decryptAacSamples(audioTrack.samples, 0, () => {
-          if (videoTrack.samples) {
-            sampleAes.decryptAvcSamples(videoTrack.samples, 0, 0, () => {
+        sampleAes.decryptAacSamples(
+          (audioTrack as DemuxedAAC).samples,
+          0,
+          () => {
+            if (videoTrack.samples) {
+              sampleAes.decryptAvcSamples(videoTrack.samples, 0, 0, () => {
+                resolve(demuxResult);
+              });
+            } else {
               resolve(demuxResult);
-            });
-          } else {
-            resolve(demuxResult);
-          }
-        });
+            }
+          },
+        );
       } else if (videoTrack.samples) {
         sampleAes.decryptAvcSamples(videoTrack.samples, 0, 0, () => {
           resolve(demuxResult);

package/src/loader/level-key.ts

@@ -4,17 +4,17 @@ import { logger } from '../utils/logger';
 import { KeySystemFormats, parsePlayReadyWRM } from '../utils/mediakeys-helper';
 import { mp4pssh } from '../utils/mp4-tools';
 
-let keyUriToKeyIdMap: { [uri: string]: Uint8Array } = {};
+let keyUriToKeyIdMap: { [uri: string]: Uint8Array<ArrayBuffer> } = {};
 
 export interface DecryptData {
   uri: string;
   method: string;
   keyFormat: string;
   keyFormatVersions: number[];
-  iv: Uint8Array | null;
-  key: Uint8Array | null;
-  keyId: Uint8Array | null;
-  pssh: Uint8Array | null;
+  iv: Uint8Array<ArrayBuffer> | null;
+  key: Uint8Array<ArrayBuffer> | null;
+  keyId: Uint8Array<ArrayBuffer> | null;
+  pssh: Uint8Array<ArrayBuffer> | null;
   encrypted: boolean;
   isCommonEncryption: boolean;
 }
@@ -26,9 +26,9 @@ export class LevelKey implements DecryptData {
   public readonly keyFormatVersions: number[];
   public readonly encrypted: boolean;
   public readonly isCommonEncryption: boolean;
-  public iv: Uint8Array | null = null;
-  public key: Uint8Array | null = null;
-  public keyId: Uint8Array | null = null;
+  public iv: Uint8Array<ArrayBuffer> | null = null;
+  public key: Uint8Array<ArrayBuffer> | null = null;
+  public keyId: Uint8Array<ArrayBuffer> | null = null;
   public pssh: Uint8Array<ArrayBuffer> | null = null;
 
   static clearKeyUriToKeyIdMap() {
@@ -40,7 +40,7 @@ export class LevelKey implements DecryptData {
     uri: string,
     format: string,
     formatversions: number[] = [1],
-    iv: Uint8Array | null = null,
+    iv: Uint8Array<ArrayBuffer> | null = null,
   ) {
     this.method = method;
     this.uri = uri;
@@ -174,7 +174,7 @@ export class LevelKey implements DecryptData {
   }
 }
 
-function createInitializationVector(segmentNumber: number): Uint8Array {
+function createInitializationVector(segmentNumber: number) {
   const uint8View = new Uint8Array(16);
   for (let i = 12; i < 16; i++) {
     uint8View[i] = (segmentNumber >> (8 * (15 - i))) & 0xff;

package/src/types/demuxer.ts

@@ -69,6 +69,11 @@ export interface DemuxedAudioTrack extends DemuxedTrack {
   samples: AudioSample[];
 }
 
+export type DemuxedAAC = DemuxedAudioTrack & {
+  segmentCodec: 'aac';
+  samples: AACAudioSample[];
+};
+
 export type DemuxedAC3 = DemuxedAudioTrack & {
   segmentCodec: 'ac3';
   config: Uint8Array;
@@ -180,6 +185,10 @@ export type AudioSample = {
   pts: number;
 };
 
+export type AACAudioSample = {
+  unit: Uint8Array<ArrayBuffer>;
+};
+
 export type AudioFrame = {
   sample: AudioSample;
   length: number;
@@ -193,6 +202,6 @@ export interface ElementaryStreamData {
 
 export interface KeyData {
   method: string;
-  key: Uint8Array;
-  iv: Uint8Array;
+  key: Uint8Array<ArrayBuffer>;
+  iv: Uint8Array<ArrayBuffer>;
 }

package/src/utils/chunker.ts

@@ -1,5 +1,4 @@
 import { appendUint8Array } from './mp4-tools';
-import { sliceUint8 } from './typed-array';
 
 export default class Chunker {
   private chunkSize: number;
@@ -29,10 +28,10 @@ export default class Chunker {
       let offset = 0;
       const len = temp.length;
       while (offset < len - chunkSize) {
-        result.push(sliceUint8(temp, offset, offset + chunkSize));
+        result.push(temp.slice(offset, offset + chunkSize));
         offset += chunkSize;
       }
-      this.cache = sliceUint8(temp, offset);
+      this.cache = temp.slice(offset);
     } else {
       result.push(temp);
     }

package/src/utils/mediakeys-helper.ts

@@ -166,7 +166,7 @@ function createMediaKeySystemConfigurations(
   return [baseConfig];
 }
 
-export function parsePlayReadyWRM(keyBytes: Uint8Array): Uint8Array | null {
+export function parsePlayReadyWRM(keyBytes: Uint8Array) {
   const keyBytesUtf16 = new Uint16Array(
     keyBytes.buffer,
     keyBytes.byteOffset,

package/src/utils/mp4-tools.ts

@@ -1,6 +1,5 @@
 import { utf8ArrayToStr } from '@svta/common-media-library/utils/utf8ArrayToStr';
 import Hex from './hex';
-import { sliceUint8 } from './typed-array';
 import { ElementaryStreamTypes } from '../loader/fragment';
 import { logger } from '../utils/logger';
 import type { KeySystemIds } from './mediakeys-helper';
@@ -834,8 +833,8 @@ export function segmentValidRange(data: Uint8Array): SegmentedRange {
   }
   const last = moofs[moofs.length - 1];
   // Offset by 8 bytes; findBox offsets the start by as much
-  segmentedRange.valid = sliceUint8(data, 0, last.byteOffset - 8);
-  segmentedRange.remainder = sliceUint8(data, last.byteOffset - 8);
+  segmentedRange.valid = data.slice(0, last.byteOffset - 8);
+  segmentedRange.remainder = data.slice(last.byteOffset - 8);
   return segmentedRange;
 }
 
@@ -844,14 +843,10 @@ export interface SegmentedRange {
   remainder: Uint8Array | null;
 }
 
-export function appendUint8Array(
-  data1: Uint8Array,
-  data2: Uint8Array,
-): Uint8Array {
+export function appendUint8Array(data1: Uint8Array, data2: Uint8Array) {
   const temp = new Uint8Array(data1.length + data2.length);
   temp.set(data1);
   temp.set(data2, data1.length);
-
   return temp;
 }
 

package/src/utils/numeric-encoding-utils.ts

@@ -21,8 +21,6 @@ export function base64UrlEncode(input: Uint8Array): string {
   return base64ToBase64Url(base64Encode(input));
 }
 
-export function base64Decode(
-  base64encodedStr: string,
-): Uint8Array<ArrayBuffer> {
+export function base64Decode(base64encodedStr: string) {
   return Uint8Array.from(atob(base64encodedStr), (c) => c.charCodeAt(0));
 }

package/src/utils/vttparser.ts

@@ -5,7 +5,6 @@
 import VTTCue from './vttcue';
 
 class StringDecoder {
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   decode(data: string | any, options?: Object): string | never {
     if (!data) {
       return '';

package/src/utils/typed-array.ts

@@ -1,11 +0,0 @@
-export function sliceUint8(
-  array: Uint8Array,
-  start?: number,
-  end?: number,
-): Uint8Array {
-  // @ts-expect-error This polyfills IE11 usage of Uint8Array slice.
-  // It always exists in the TypeScript definition so fails, but it fails at runtime on IE11.
-  return Uint8Array.prototype.slice
-    ? array.slice(start, end)
-    : new Uint8Array(Array.prototype.slice.call(array, start, end));
-}