hls.js 1.5.14-0.canary.10431 → 1.5.14-0.canary.10432

package/package.json

@@ -130,5 +130,5 @@
     "url-toolkit": "2.2.5",
     "wrangler": "3.63.2"
   },
-  "version": "1.5.14-0.canary.10431"
+  "version": "1.5.14-0.canary.10432"
 }

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

@@ -365,6 +365,10 @@ export default class BaseStreamController
 
   protected onHandlerDestroying() {
     this.stopLoad();
+    if (this.transmuxer) {
+      this.transmuxer.destroy();
+      this.transmuxer = null;
+    }
     super.onHandlerDestroying();
     // @ts-ignore
     this.hls = this.onMediaSeeking = this.onMediaEnded = null;
@@ -1931,10 +1935,7 @@ export default class BaseStreamController
   }
 
   protected resetTransmuxer() {
-    if (this.transmuxer) {
-      this.transmuxer.destroy();
-      this.transmuxer = null;
-    }
+    this.transmuxer?.reset();
   }
 
   protected recoverWorkerError(data: ErrorData) {

package/src/demux/audio/aacdemuxer.ts

@@ -4,16 +4,16 @@
 import BaseAudioDemuxer from './base-audio-demuxer';
 import * as ADTS from './adts';
 import * as MpegAudio from './mpegaudio';
-import { logger } from '../../utils/logger';
 import { getId3Data } from '@svta/common-media-library/id3/getId3Data';
 import type { HlsEventEmitter } from '../../events';
 import type { HlsConfig } from '../../config';
+import type { ILogger } from '../../utils/logger';
 
 class AACDemuxer extends BaseAudioDemuxer {
   private readonly observer: HlsEventEmitter;
   private readonly config: HlsConfig;
 
-  constructor(observer, config) {
+  constructor(observer: HlsEventEmitter, config) {
     super();
     this.observer = observer;
     this.config = config;
@@ -42,7 +42,7 @@ class AACDemuxer extends BaseAudioDemuxer {
   }
 
   // Source for probe info - https://wiki.multimedia.cx/index.php?title=ADTS
-  static probe(data: Uint8Array | undefined): boolean {
+  static probe(data: Uint8Array | undefined, logger: ILogger): boolean {
     if (!data) {
       return false;
     }

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

@@ -8,7 +8,7 @@ import type { AudioFrame, DemuxedAudioTrack } from '../../types/demuxer';
 export class AC3Demuxer extends BaseAudioDemuxer {
   private readonly observer: HlsEventEmitter;
 
-  constructor(observer) {
+  constructor(observer: HlsEventEmitter) {
     super();
     this.observer = observer;
   }

package/src/demux/inject-worker.ts

@@ -1,6 +1,9 @@
 // ensure the worker ends up in the bundle
 // If the worker should not be included this gets aliased to empty.js
 import './transmuxer-worker';
+import { version } from '../version';
+
+const workerStore: Record<string, WorkerContext> = {};
 
 export function hasUMDWorker(): boolean {
   return typeof __HLS_WORKER_BUNDLE__ === 'function';
@@ -10,9 +13,15 @@ export type WorkerContext = {
   worker: Worker;
   objectURL?: string;
   scriptURL?: string;
+  clientCount: number;
 };
 
 export function injectWorker(): WorkerContext {
+  const workerContext = workerStore[version];
+  if (workerContext) {
+    workerContext.clientCount++;
+    return workerContext;
+  }
   const blob = new self.Blob(
     [
       `var exports={};var module={exports:exports};function define(f){f()};define.amd=true;(${__HLS_WORKER_BUNDLE__.toString()})(true);`,
@@ -23,19 +32,44 @@ export function injectWorker(): WorkerContext {
   );
   const objectURL = self.URL.createObjectURL(blob);
   const worker = new self.Worker(objectURL);
-
-  return {
+  const result = {
     worker,
     objectURL,
+    clientCount: 1,
   };
+  workerStore[version] = result;
+  return result;
 }
 
 export function loadWorker(path: string): WorkerContext {
+  const workerContext = workerStore[path];
+  if (workerContext) {
+    workerContext.clientCount++;
+    return workerContext;
+  }
   const scriptURL = new self.URL(path, self.location.href).href;
   const worker = new self.Worker(scriptURL);
-
-  return {
+  const result = {
     worker,
     scriptURL,
+    clientCount: 1,
   };
+  workerStore[path] = result;
+  return result;
+}
+
+export function removeWorkerFromStore(path?: string | null) {
+  const workerContext = workerStore[path || version];
+  if (workerContext) {
+    const clientCount = workerContext.clientCount--;
+    if (clientCount === 1) {
+      const { worker, objectURL } = workerContext;
+      delete workerStore[path || version];
+      if (objectURL) {
+        // revoke the Object URL that was used to create transmuxer worker, so as not to leak it
+        self.URL.revokeObjectURL(objectURL);
+      }
+      worker.terminate();
+    }
+  }
 }

package/src/demux/transmuxer-interface.ts

@@ -3,6 +3,7 @@ import {
   hasUMDWorker,
   injectWorker,
   loadWorker,
+  removeWorkerFromStore as removeWorkerClient,
 } from './inject-worker';
 import { Events } from '../events';
 import Transmuxer, {
@@ -10,29 +11,30 @@ import Transmuxer, {
   TransmuxState,
   isPromise,
 } from '../demux/transmuxer';
-import { logger } from '../utils/logger';
 import { ErrorTypes, ErrorDetails } from '../errors';
 import { EventEmitter } from 'eventemitter3';
 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 { ErrorData, FragDecryptedData } from '../types/events';
 import type { PlaylistLevelType } from '../types/loader';
 import type { RationalTimestamp } from '../utils/timescale-conversion';
 
+let transmuxerInstanceCount: number = 0;
+
 export default class TransmuxerInterface {
   public error: Error | null = null;
   private hls: Hls;
   private id: PlaylistLevelType;
+  private instanceNo: number = transmuxerInstanceCount++;
   private observer: HlsEventEmitter;
   private frag: MediaFragment | null = null;
   private part: Part | null = null;
   private useWorker: boolean;
   private workerContext: WorkerContext | null = null;
-  private onwmsg?: (
-    event: MessageEvent<{ event: string; data?: any } | null>,
-  ) => void;
   private transmuxer: Transmuxer | null = null;
   private onTransmuxComplete: (transmuxResult: TransmuxerResult) => void;
   private onFlush: (chunkMeta: ChunkMetadata) => void;
@@ -50,11 +52,16 @@ export default class TransmuxerInterface {
     this.onTransmuxComplete = onTransmuxComplete;
     this.onFlush = onFlush;
 
-    const forwardMessage = (ev, data) => {
+    const forwardMessage = (
+      ev: Events.ERROR | Events.FRAG_DECRYPTED,
+      data: ErrorData | FragDecryptedData,
+    ) => {
       data = data || {};
-      data.frag = this.frag;
-      data.id = this.id;
+      data.frag = this.frag || undefined;
       if (ev === Events.ERROR) {
+        data = data as ErrorData;
+        data.parent = this.id;
+        data.part = this.part;
         this.error = data.error;
       }
       this.hls.trigger(ev, data);
@@ -70,6 +77,7 @@ export default class TransmuxerInterface {
     );
 
     if (this.useWorker && typeof Worker !== 'undefined') {
+      const logger = this.hls.logger;
       const canCreateWorker = config.workerPath || hasUMDWorker();
       if (canCreateWorker) {
         try {
@@ -80,28 +88,14 @@ export default class TransmuxerInterface {
             logger.log(`injecting Web Worker for "${id}"`);
             this.workerContext = injectWorker();
           }
-          this.onwmsg = (event) => this.onWorkerMessage(event);
           const { worker } = this.workerContext;
-          worker.addEventListener('message', this.onwmsg);
-          worker.onerror = (event) => {
-            const error = new Error(
-              `${event.message}  (${event.filename}:${event.lineno})`,
-            );
-            config.enableWorker = false;
-            logger.warn(`Error in "${id}" Web Worker, fallback to inline`);
-            this.hls.trigger(Events.ERROR, {
-              type: ErrorTypes.OTHER_ERROR,
-              details: ErrorDetails.INTERNAL_EXCEPTION,
-              fatal: false,
-              event: 'demuxerWorker',
-              error,
-            });
-          };
+          worker.addEventListener('message', this.onWorkerMessage);
+          worker.addEventListener('error', this.onWorkerError);
           worker.postMessage({
+            instanceNo: this.instanceNo,
             cmd: 'init',
             typeSupported: m2tsTypeSupported,
-            vendor: '',
-            id: id,
+            id,
             config: JSON.stringify(config),
           });
         } catch (err) {
@@ -109,7 +103,7 @@ export default class TransmuxerInterface {
             `Error setting up "${id}" Web Worker, fallback to inline`,
             err,
           );
-          this.resetWorker();
+          this.terminateWorker();
           this.error = null;
           this.transmuxer = new Transmuxer(
             this.observer,
@@ -117,6 +111,7 @@ export default class TransmuxerInterface {
             config,
             '',
             id,
+            hls.logger,
           );
         }
         return;
@@ -129,27 +124,46 @@ export default class TransmuxerInterface {
       config,
       '',
       id,
+      hls.logger,
     );
   }
 
-  resetWorker() {
+  reset() {
+    this.frag = null;
+    this.part = null;
     if (this.workerContext) {
-      const { worker, objectURL } = this.workerContext;
-      if (objectURL) {
-        // revoke the Object URL that was used to create transmuxer worker, so as not to leak it
-        self.URL.revokeObjectURL(objectURL);
-      }
-      worker.removeEventListener('message', this.onwmsg as any);
-      worker.onerror = null;
-      worker.terminate();
+      const instanceNo = this.instanceNo;
+      this.instanceNo = transmuxerInstanceCount++;
+      const config = this.hls.config;
+      const m2tsTypeSupported = getM2TSSupportedAudioTypes(
+        config.preferManagedMediaSource,
+      );
+      this.workerContext.worker.postMessage({
+        instanceNo: this.instanceNo,
+        cmd: 'reset',
+        resetNo: instanceNo,
+        typeSupported: m2tsTypeSupported,
+        id: this.id,
+        config: JSON.stringify(config),
+      });
+    }
+  }
+
+  private terminateWorker() {
+    if (this.workerContext) {
+      const { worker } = this.workerContext;
       this.workerContext = null;
+      worker.removeEventListener('message', this.onWorkerMessage);
+      worker.removeEventListener('error', this.onWorkerError);
+      removeWorkerClient(this.hls.config.workerPath);
     }
   }
 
   destroy() {
     if (this.workerContext) {
-      this.resetWorker();
-      this.onwmsg = undefined;
+      this.terminateWorker();
+      // @ts-ignore
+      this.onWorkerMessage = this.onWorkerError = null;
     } else {
       const transmuxer = this.transmuxer;
       if (transmuxer) {
@@ -162,6 +176,7 @@ export default class TransmuxerInterface {
       observer.removeAllListeners();
     }
     this.frag = null;
+    this.part = null;
     // @ts-ignore
     this.observer = null;
     // @ts-ignore
@@ -181,7 +196,7 @@ export default class TransmuxerInterface {
     defaultInitPTS?: RationalTimestamp,
   ) {
     chunkMeta.transmuxing.start = self.performance.now();
-    const { transmuxer } = this;
+    const { instanceNo, transmuxer } = this;
     const timeOffset = part ? part.start : frag.start;
     // TODO: push "clear-lead" decrypt data for unencrypted fragments in streams with encrypted ones
     const decryptdata = frag.decryptdata;
@@ -219,7 +234,8 @@ export default class TransmuxerInterface {
       initSegmentChange,
     );
     if (!contiguous || discontinuity || initSegmentChange) {
-      logger.log(`[transmuxer-interface, ${frag.type}]: Starting new transmux session for sn: ${chunkMeta.sn} p: ${chunkMeta.part} level: ${chunkMeta.level} id: ${chunkMeta.id}
+      this.hls.logger
+        .log(`[transmuxer-interface, ${frag.type}]: Starting new transmux session for sn: ${chunkMeta.sn} p: ${chunkMeta.part} level: ${chunkMeta.level} id: ${chunkMeta.id}
         discontinuity: ${discontinuity}
         trackSwitch: ${trackSwitch}
         contiguous: ${contiguous}
@@ -244,6 +260,7 @@ export default class TransmuxerInterface {
       // post fragment payload as transferable objects for ArrayBuffer (no copy)
       this.workerContext.worker.postMessage(
         {
+          instanceNo,
           cmd: 'demux',
           data,
           decryptdata,
@@ -260,7 +277,6 @@ export default class TransmuxerInterface {
         state,
       );
       if (isPromise(transmuxResult)) {
-        transmuxer.async = true;
         transmuxResult
           .then((data) => {
             this.handleTransmuxComplete(data);
@@ -273,7 +289,6 @@ export default class TransmuxerInterface {
             );
           });
       } else {
-        transmuxer.async = false;
         this.handleTransmuxComplete(transmuxResult as TransmuxerResult);
       }
     }
@@ -281,20 +296,17 @@ export default class TransmuxerInterface {
 
   flush(chunkMeta: ChunkMetadata) {
     chunkMeta.transmuxing.start = self.performance.now();
-    const { transmuxer } = this;
+    const { instanceNo, transmuxer } = this;
     if (this.workerContext) {
       1;
       this.workerContext.worker.postMessage({
+        instanceNo,
         cmd: 'flush',
         chunkMeta,
       });
     } else if (transmuxer) {
-      let transmuxResult = transmuxer.flush(chunkMeta);
-      const asyncFlush = isPromise(transmuxResult);
-      if (asyncFlush || transmuxer.async) {
-        if (!isPromise(transmuxResult)) {
-          transmuxResult = Promise.resolve(transmuxResult);
-        }
+      const transmuxResult = transmuxer.flush(chunkMeta);
+      if (isPromise(transmuxResult)) {
         transmuxResult
           .then((data) => {
             this.handleFlushResult(data, chunkMeta);
@@ -307,10 +319,7 @@ export default class TransmuxerInterface {
             );
           });
       } else {
-        this.handleFlushResult(
-          transmuxResult as Array<TransmuxerResult>,
-          chunkMeta,
-        );
+        this.handleFlushResult(transmuxResult, chunkMeta);
       }
     }
   }
@@ -329,6 +338,7 @@ export default class TransmuxerInterface {
       details: ErrorDetails.FRAG_PARSING_ERROR,
       chunkMeta,
       frag: this.frag || undefined,
+      part: this.part || undefined,
       fatal: false,
       error,
       err: error,
@@ -346,18 +356,16 @@ export default class TransmuxerInterface {
     this.onFlush(chunkMeta);
   }
 
-  private onWorkerMessage(
-    event: MessageEvent<{ event: string; data?: any } | null>,
-  ) {
+  private onWorkerMessage = (
+    event: MessageEvent<{
+      event: string;
+      data?: any;
+      instanceNo?: number;
+    } | null>,
+  ) => {
     const data = event.data;
-    if (!data?.event) {
-      logger.warn(
-        `worker message received with no ${data ? 'event name' : 'data'}`,
-      );
-      return;
-    }
     const hls = this.hls;
-    if (!this.hls) {
+    if (!hls || !data?.event || data.instanceNo !== this.instanceNo) {
       return;
     }
     switch (data.event) {
@@ -381,26 +389,49 @@ export default class TransmuxerInterface {
       }
 
       // pass logs from the worker thread to the main logger
-      case 'workerLog':
-        if (logger[data.data.logType]) {
-          logger[data.data.logType](data.data.message);
+      case 'workerLog': {
+        if (hls.logger[data.data.logType]) {
+          hls.logger[data.data.logType](data.data.message);
         }
         break;
+      }
 
       default: {
         data.data = data.data || {};
         data.data.frag = this.frag;
+        data.data.part = this.part;
         data.data.id = this.id;
         hls.trigger(data.event as keyof HlsListeners, data.data);
         break;
       }
     }
-  }
+  };
+
+  private onWorkerError = (event) => {
+    if (!this.hls) {
+      return;
+    }
+    const error = new Error(
+      `${event.message}  (${event.filename}:${event.lineno})`,
+    );
+    this.hls.config.enableWorker = false;
+    this.hls.logger.warn(
+      `Error in "${this.id}" Web Worker, fallback to inline`,
+    );
+    this.hls.trigger(Events.ERROR, {
+      type: ErrorTypes.OTHER_ERROR,
+      details: ErrorDetails.INTERNAL_EXCEPTION,
+      fatal: false,
+      event: 'demuxerWorker',
+      error,
+    });
+  };
 
   private configureTransmuxer(config: TransmuxConfig) {
-    const { transmuxer } = this;
+    const { instanceNo, transmuxer } = this;
     if (this.workerContext) {
       this.workerContext.worker.postMessage({
+        instanceNo,
         cmd: 'configure',
         config,
       });