hls.js 1.5.14-0.canary.10515 → 1.5.14

package/src/demux/transmuxer-interface.ts

@@ -3,7 +3,6 @@ import {
   hasUMDWorker,
   injectWorker,
   loadWorker,
-  removeWorkerFromStore as removeWorkerClient,
 } from './inject-worker';
 import { Events } from '../events';
 import Transmuxer, {
@@ -11,30 +10,30 @@ import Transmuxer, {
   TransmuxState,
   isPromise,
 } from '../demux/transmuxer';
+import { logger } from '../utils/logger';
 import { ErrorTypes, ErrorDetails } from '../errors';
+import { getMediaSource } from '../utils/mediasource-helper';
 import { EventEmitter } from 'eventemitter3';
-import { MediaFragment, Part } from '../loader/fragment';
-import { getM2TSSupportedAudioTypes } from '../utils/codecs';
-
+import { Fragment, Part } from '../loader/fragment';
 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 { TypeSupported } from './tsdemuxer';
 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 frag: Fragment | 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;
@@ -52,16 +51,11 @@ export default class TransmuxerInterface {
     this.onTransmuxComplete = onTransmuxComplete;
     this.onFlush = onFlush;
 
-    const forwardMessage = (
-      ev: Events.ERROR | Events.FRAG_DECRYPTED,
-      data: ErrorData | FragDecryptedData,
-    ) => {
+    const forwardMessage = (ev, data) => {
       data = data || {};
-      data.frag = this.frag || undefined;
+      data.frag = this.frag;
+      data.id = this.id;
       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);
@@ -72,12 +66,18 @@ export default class TransmuxerInterface {
     this.observer.on(Events.FRAG_DECRYPTED, forwardMessage);
     this.observer.on(Events.ERROR, forwardMessage);
 
-    const m2tsTypeSupported = getM2TSSupportedAudioTypes(
-      config.preferManagedMediaSource,
-    );
+    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,
+    };
 
     if (this.useWorker && typeof Worker !== 'undefined') {
-      const logger = this.hls.logger;
       const canCreateWorker = config.workerPath || hasUMDWorker();
       if (canCreateWorker) {
         try {
@@ -88,14 +88,28 @@ 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.onWorkerMessage);
-          worker.addEventListener('error', this.onWorkerError);
+          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.postMessage({
-            instanceNo: this.instanceNo,
             cmd: 'init',
             typeSupported: m2tsTypeSupported,
-            id,
+            vendor: '',
+            id: id,
             config: JSON.stringify(config),
           });
         } catch (err) {
@@ -103,7 +117,7 @@ export default class TransmuxerInterface {
             `Error setting up "${id}" Web Worker, fallback to inline`,
             err,
           );
-          this.terminateWorker();
+          this.resetWorker();
           this.error = null;
           this.transmuxer = new Transmuxer(
             this.observer,
@@ -111,7 +125,6 @@ export default class TransmuxerInterface {
             config,
             '',
             id,
-            hls.logger,
           );
         }
         return;
@@ -124,46 +137,27 @@ export default class TransmuxerInterface {
       config,
       '',
       id,
-      hls.logger,
     );
   }
 
-  reset() {
-    this.frag = null;
-    this.part = null;
+  resetWorker() {
     if (this.workerContext) {
-      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;
+      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();
       this.workerContext = null;
-      worker.removeEventListener('message', this.onWorkerMessage);
-      worker.removeEventListener('error', this.onWorkerError);
-      removeWorkerClient(this.hls.config.workerPath);
     }
   }
 
   destroy() {
     if (this.workerContext) {
-      this.terminateWorker();
-      // @ts-ignore
-      this.onWorkerMessage = this.onWorkerError = null;
+      this.resetWorker();
+      this.onwmsg = undefined;
     } else {
       const transmuxer = this.transmuxer;
       if (transmuxer) {
@@ -176,7 +170,6 @@ export default class TransmuxerInterface {
       observer.removeAllListeners();
     }
     this.frag = null;
-    this.part = null;
     // @ts-ignore
     this.observer = null;
     // @ts-ignore
@@ -188,7 +181,7 @@ export default class TransmuxerInterface {
     initSegmentData: Uint8Array | undefined,
     audioCodec: string | undefined,
     videoCodec: string | undefined,
-    frag: MediaFragment,
+    frag: Fragment,
     part: Part | null,
     duration: number,
     accurateTimeOffset: boolean,
@@ -196,7 +189,7 @@ export default class TransmuxerInterface {
     defaultInitPTS?: RationalTimestamp,
   ) {
     chunkMeta.transmuxing.start = self.performance.now();
-    const { instanceNo, transmuxer } = this;
+    const { 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;
@@ -204,7 +197,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 : -1;
+    const snDiff = lastFrag ? chunkMeta.sn - (lastFrag.sn as number) : -1;
     const partDiff = this.part ? chunkMeta.part - this.part.index : -1;
     const progressive =
       snDiff === 0 &&
@@ -234,8 +227,7 @@ export default class TransmuxerInterface {
       initSegmentChange,
     );
     if (!contiguous || discontinuity || initSegmentChange) {
-      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}
+      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}
@@ -260,7 +252,6 @@ export default class TransmuxerInterface {
       // post fragment payload as transferable objects for ArrayBuffer (no copy)
       this.workerContext.worker.postMessage(
         {
-          instanceNo,
           cmd: 'demux',
           data,
           decryptdata,
@@ -277,6 +268,7 @@ export default class TransmuxerInterface {
         state,
       );
       if (isPromise(transmuxResult)) {
+        transmuxer.async = true;
         transmuxResult
           .then((data) => {
             this.handleTransmuxComplete(data);
@@ -289,6 +281,7 @@ export default class TransmuxerInterface {
             );
           });
       } else {
+        transmuxer.async = false;
         this.handleTransmuxComplete(transmuxResult as TransmuxerResult);
       }
     }
@@ -296,17 +289,20 @@ export default class TransmuxerInterface {
 
   flush(chunkMeta: ChunkMetadata) {
     chunkMeta.transmuxing.start = self.performance.now();
-    const { instanceNo, transmuxer } = this;
+    const { transmuxer } = this;
     if (this.workerContext) {
       1;
       this.workerContext.worker.postMessage({
-        instanceNo,
         cmd: 'flush',
         chunkMeta,
       });
     } else if (transmuxer) {
-      const transmuxResult = transmuxer.flush(chunkMeta);
-      if (isPromise(transmuxResult)) {
+      let transmuxResult = transmuxer.flush(chunkMeta);
+      const asyncFlush = isPromise(transmuxResult);
+      if (asyncFlush || transmuxer.async) {
+        if (!isPromise(transmuxResult)) {
+          transmuxResult = Promise.resolve(transmuxResult);
+        }
         transmuxResult
           .then((data) => {
             this.handleFlushResult(data, chunkMeta);
@@ -319,7 +315,10 @@ export default class TransmuxerInterface {
             );
           });
       } else {
-        this.handleFlushResult(transmuxResult, chunkMeta);
+        this.handleFlushResult(
+          transmuxResult as Array<TransmuxerResult>,
+          chunkMeta,
+        );
       }
     }
   }
@@ -338,7 +337,6 @@ export default class TransmuxerInterface {
       details: ErrorDetails.FRAG_PARSING_ERROR,
       chunkMeta,
       frag: this.frag || undefined,
-      part: this.part || undefined,
       fatal: false,
       error,
       err: error,
@@ -356,16 +354,18 @@ export default class TransmuxerInterface {
     this.onFlush(chunkMeta);
   }
 
-  private onWorkerMessage = (
-    event: MessageEvent<{
-      event: string;
-      data?: any;
-      instanceNo?: number;
-    } | null>,
-  ) => {
+  private onWorkerMessage(
+    event: MessageEvent<{ event: string; data?: any } | 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 (!hls || !data?.event || data.instanceNo !== this.instanceNo) {
+    if (!this.hls) {
       return;
     }
     switch (data.event) {
@@ -389,49 +389,26 @@ export default class TransmuxerInterface {
       }
 
       // pass logs from the worker thread to the main logger
-      case 'workerLog': {
-        if (hls.logger[data.data.logType]) {
-          hls.logger[data.data.logType](data.data.message);
+      case 'workerLog':
+        if (logger[data.data.logType]) {
+          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 { instanceNo, transmuxer } = this;
+    const { transmuxer } = this;
     if (this.workerContext) {
       this.workerContext.worker.postMessage({
-        instanceNo,
         cmd: 'configure',
         config,
       });

package/src/demux/transmuxer-worker.ts

@@ -1,126 +1,119 @@
 import Transmuxer, { isPromise } from '../demux/transmuxer';
 import { Events } from '../events';
-import { enableLogs, type ILogFunction, type ILogger } from '../utils/logger';
+import { ILogFunction, enableLogs, logger } from '../utils/logger';
 import { EventEmitter } from 'eventemitter3';
 import { ErrorDetails, ErrorTypes } from '../errors';
 import type { RemuxedTrack, RemuxerResult } from '../types/remuxer';
 import type { TransmuxerResult, ChunkMetadata } from '../types/transmuxer';
 
-const transmuxers: (Transmuxer | undefined)[] = [];
-
 if (typeof __IN_WORKER__ !== 'undefined' && __IN_WORKER__) {
-  startWorker();
+  startWorker(self);
 }
 
-function startWorker() {
+function startWorker(self) {
+  const observer = new EventEmitter();
+  const forwardMessage = (ev, data) => {
+    self.postMessage({ event: ev, data: data });
+  };
+
+  // forward events to main thread
+  observer.on(Events.FRAG_DECRYPTED, forwardMessage);
+  observer.on(Events.ERROR, forwardMessage);
+
+  // forward logger events to main thread
+  const forwardWorkerLogs = () => {
+    for (const logFn in logger) {
+      const func: ILogFunction = (message?) => {
+        forwardMessage('workerLog', {
+          logType: logFn,
+          message,
+        });
+      };
+
+      logger[logFn] = func;
+    }
+  };
+
   self.addEventListener('message', (ev) => {
     const data = ev.data;
-    const instanceNo = data.instanceNo;
-    if (instanceNo === undefined) {
-      return;
-    }
-    const transmuxer = transmuxers[instanceNo];
-    if (data.cmd === 'reset') {
-      delete transmuxers[data.resetNo];
-      if (transmuxer) {
-        transmuxer.destroy();
-      }
-      data.cmd = 'init';
-    }
-    if (data.cmd === 'init') {
-      const config = JSON.parse(data.config);
-      const observer = new EventEmitter();
-      observer.on(Events.FRAG_DECRYPTED, forwardMessage);
-      observer.on(Events.ERROR, forwardMessage);
-      const logger = enableLogs(config.debug, data.id);
-      forwardWorkerLogs(logger, instanceNo);
-      transmuxers[instanceNo] = new Transmuxer(
-        observer,
-        data.typeSupported,
-        config,
-        '',
-        data.id,
-        logger,
-      );
-      forwardMessage('init', null, instanceNo);
-      return;
-    }
-    if (!transmuxer) {
-      return;
-    }
     switch (data.cmd) {
+      case 'init': {
+        const config = JSON.parse(data.config);
+        self.transmuxer = new Transmuxer(
+          observer,
+          data.typeSupported,
+          config,
+          '',
+          data.id,
+        );
+        enableLogs(config.debug, data.id);
+        forwardWorkerLogs();
+        forwardMessage('init', null);
+        break;
+      }
       case 'configure': {
-        transmuxer.configure(data.config);
+        self.transmuxer.configure(data.config);
         break;
       }
       case 'demux': {
         const transmuxResult: TransmuxerResult | Promise<TransmuxerResult> =
-          transmuxer.push(
+          self.transmuxer.push(
             data.data,
             data.decryptdata,
             data.chunkMeta,
             data.state,
           );
         if (isPromise(transmuxResult)) {
+          self.transmuxer.async = true;
           transmuxResult
             .then((data) => {
-              emitTransmuxComplete(self, data, instanceNo);
+              emitTransmuxComplete(self, data);
             })
             .catch((error) => {
-              forwardMessage(
-                Events.ERROR,
-                {
-                  instanceNo,
-                  type: ErrorTypes.MEDIA_ERROR,
-                  details: ErrorDetails.FRAG_PARSING_ERROR,
-                  chunkMeta: data.chunkMeta,
-                  fatal: false,
-                  error,
-                  err: error,
-                  reason: `transmuxer-worker push error`,
-                },
-                instanceNo,
-              );
+              forwardMessage(Events.ERROR, {
+                type: ErrorTypes.MEDIA_ERROR,
+                details: ErrorDetails.FRAG_PARSING_ERROR,
+                chunkMeta: data.chunkMeta,
+                fatal: false,
+                error,
+                err: error,
+                reason: `transmuxer-worker push error`,
+              });
             });
         } else {
-          emitTransmuxComplete(self, transmuxResult, instanceNo);
+          self.transmuxer.async = false;
+          emitTransmuxComplete(self, transmuxResult);
         }
         break;
       }
       case 'flush': {
-        const chunkMeta = data.chunkMeta as ChunkMetadata;
-        const transmuxResult = transmuxer.flush(chunkMeta);
-        if (isPromise(transmuxResult)) {
+        const id = data.chunkMeta;
+        let transmuxResult = self.transmuxer.flush(id);
+        const asyncFlush = isPromise(transmuxResult);
+        if (asyncFlush || self.transmuxer.async) {
+          if (!isPromise(transmuxResult)) {
+            transmuxResult = Promise.resolve(transmuxResult);
+          }
           transmuxResult
             .then((results: Array<TransmuxerResult>) => {
-              handleFlushResult(
-                self,
-                results as Array<TransmuxerResult>,
-                chunkMeta,
-                instanceNo,
-              );
+              handleFlushResult(self, results as Array<TransmuxerResult>, id);
             })
             .catch((error) => {
-              forwardMessage(
-                Events.ERROR,
-                {
-                  type: ErrorTypes.MEDIA_ERROR,
-                  details: ErrorDetails.FRAG_PARSING_ERROR,
-                  chunkMeta: data.chunkMeta,
-                  fatal: false,
-                  error,
-                  err: error,
-                  reason: `transmuxer-worker flush error`,
-                },
-                instanceNo,
-              );
+              forwardMessage(Events.ERROR, {
+                type: ErrorTypes.MEDIA_ERROR,
+                details: ErrorDetails.FRAG_PARSING_ERROR,
+                chunkMeta: data.chunkMeta,
+                fatal: false,
+                error,
+                err: error,
+                reason: `transmuxer-worker flush error`,
+              });
             });
         } else {
           handleFlushResult(
             self,
             transmuxResult as Array<TransmuxerResult>,
-            chunkMeta,
-            instanceNo,
+            id,
           );
         }
         break;
@@ -134,7 +127,6 @@ function startWorker() {
 function emitTransmuxComplete(
   self: any,
   transmuxResult: TransmuxerResult,
-  instanceNo: number,
 ): boolean {
   if (isEmptyResult(transmuxResult.remuxResult)) {
     return false;
@@ -148,7 +140,7 @@ function emitTransmuxComplete(
     addToTransferable(transferable, video);
   }
   self.postMessage(
-    { event: 'transmuxComplete', data: transmuxResult, instanceNo },
+    { event: 'transmuxComplete', data: transmuxResult },
     transferable,
   );
   return true;
@@ -172,42 +164,16 @@ function handleFlushResult(
   self: any,
   results: Array<TransmuxerResult>,
   chunkMeta: ChunkMetadata,
-  instanceNo: number,
 ) {
   const parsed = results.reduce(
-    (parsed, result) =>
-      emitTransmuxComplete(self, result, instanceNo) || parsed,
+    (parsed, result) => emitTransmuxComplete(self, result) || parsed,
     false,
   );
   if (!parsed) {
     // Emit at least one "transmuxComplete" message even if media is not found to update stream-controller state to PARSING
-    self.postMessage({
-      event: 'transmuxComplete',
-      data: results[0],
-      instanceNo,
-    });
-  }
-  self.postMessage({ event: 'flush', data: chunkMeta, instanceNo });
-}
-
-function forwardMessage(event, data, instanceNo) {
-  self.postMessage({ event, data, instanceNo });
-}
-
-function forwardWorkerLogs(logger: ILogger, instanceNo: number) {
-  for (const logFn in logger) {
-    const func: ILogFunction = (message?) => {
-      forwardMessage(
-        'workerLog',
-        {
-          logType: logFn,
-          message,
-        },
-        instanceNo,
-      );
-    };
-    logger[logFn] = func;
+    self.postMessage({ event: 'transmuxComplete', data: results[0] });
   }
+  self.postMessage({ event: 'flush', data: chunkMeta });
 }
 
 function isEmptyResult(remuxResult: RemuxerResult) {