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

package/src/demux/transmuxer-worker.ts

@@ -6,114 +6,121 @@ 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(self);
+  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 = (logger: ILogger) => {
-    for (const logFn in logger) {
-      const func: ILogFunction = (message?) => {
-        forwardMessage('workerLog', {
-          logType: logFn,
-          message,
-        });
-      };
-
-      logger[logFn] = func;
-    }
-  };
-
+function startWorker() {
   self.addEventListener('message', (ev) => {
     const data = ev.data;
-    switch (data.cmd) {
-      case 'init': {
-        const config = JSON.parse(data.config);
-        self.transmuxer = new Transmuxer(
-          observer,
-          data.typeSupported,
-          config,
-          '',
-          data.id,
-        );
-        const logger = enableLogs(config.debug, data.id);
-        forwardWorkerLogs(logger);
-        forwardMessage('init', null);
-        break;
+    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 'configure': {
-        self.transmuxer.configure(data.config);
+        transmuxer.configure(data.config);
         break;
       }
       case 'demux': {
         const transmuxResult: TransmuxerResult | Promise<TransmuxerResult> =
-          self.transmuxer.push(
+          transmuxer.push(
             data.data,
             data.decryptdata,
             data.chunkMeta,
             data.state,
           );
         if (isPromise(transmuxResult)) {
-          self.transmuxer.async = true;
           transmuxResult
             .then((data) => {
-              emitTransmuxComplete(self, data);
+              emitTransmuxComplete(self, data, instanceNo);
             })
             .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 push 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,
+              );
             });
         } else {
-          self.transmuxer.async = false;
-          emitTransmuxComplete(self, transmuxResult);
+          emitTransmuxComplete(self, transmuxResult, instanceNo);
         }
         break;
       }
       case 'flush': {
-        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);
-          }
+        const chunkMeta = data.chunkMeta as ChunkMetadata;
+        const transmuxResult = transmuxer.flush(chunkMeta);
+        if (isPromise(transmuxResult)) {
           transmuxResult
             .then((results: Array<TransmuxerResult>) => {
-              handleFlushResult(self, results as Array<TransmuxerResult>, id);
+              handleFlushResult(
+                self,
+                results as Array<TransmuxerResult>,
+                chunkMeta,
+                instanceNo,
+              );
             })
             .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`,
-              });
+              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,
+              );
             });
         } else {
           handleFlushResult(
             self,
             transmuxResult as Array<TransmuxerResult>,
-            id,
+            chunkMeta,
+            instanceNo,
           );
         }
         break;
@@ -127,6 +134,7 @@ function startWorker(self) {
 function emitTransmuxComplete(
   self: any,
   transmuxResult: TransmuxerResult,
+  instanceNo: number,
 ): boolean {
   if (isEmptyResult(transmuxResult.remuxResult)) {
     return false;
@@ -140,7 +148,7 @@ function emitTransmuxComplete(
     addToTransferable(transferable, video);
   }
   self.postMessage(
-    { event: 'transmuxComplete', data: transmuxResult },
+    { event: 'transmuxComplete', data: transmuxResult, instanceNo },
     transferable,
   );
   return true;
@@ -164,16 +172,42 @@ function handleFlushResult(
   self: any,
   results: Array<TransmuxerResult>,
   chunkMeta: ChunkMetadata,
+  instanceNo: number,
 ) {
   const parsed = results.reduce(
-    (parsed, result) => emitTransmuxComplete(self, result) || parsed,
+    (parsed, result) =>
+      emitTransmuxComplete(self, result, instanceNo) || 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] });
+    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: 'flush', data: chunkMeta });
 }
 
 function isEmptyResult(remuxResult: RemuxerResult) {

package/src/demux/transmuxer.ts

@@ -9,7 +9,7 @@ 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 { PlaylistLevelType } from '../types/loader';
 import {
   isFullSegmentEncryption,
   getAesModeFromFullSegmentMethod,
@@ -19,18 +19,16 @@ 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 { ILogger } from '../utils/logger';
 import type { RationalTimestamp } from '../utils/timescale-conversion';
-import { optionalSelf } from '../utils/global';
 
-let now;
+let now: () => number;
 // performance.now() not available on WebWorker, at least on Safari Desktop
 try {
   now = self.performance.now.bind(self.performance);
 } catch (err) {
-  logger.debug('Unable to use Performance API on this environment');
-  now = optionalSelf?.Date.now;
+  now = Date.now;
 }
 
 type MuxConfig =
@@ -52,7 +50,8 @@ if (__USE_M2TS_ADVANCED_CODECS__) {
 }
 
 export default class Transmuxer {
-  public async: boolean = false;
+  private asyncResult: boolean = false;
+  private logger: ILogger;
   private observer: HlsEventEmitter;
   private typeSupported: TypeSupported;
   private config: HlsConfig;
@@ -72,12 +71,14 @@ export default class Transmuxer {
     config: HlsConfig,
     vendor: string,
     id: PlaylistLevelType,
+    logger: ILogger,
   ) {
     this.observer = observer;
     this.typeSupported = typeSupported;
     this.config = config;
     this.vendor = vendor;
     this.id = id;
+    this.logger = logger;
   }
 
   configure(transmuxConfig: TransmuxConfig) {
@@ -144,6 +145,7 @@ export default class Transmuxer {
         }
         uintData = new Uint8Array(decryptedData);
       } else {
+        this.asyncResult = true;
         this.decryptionPromise = decrypter
           .webCryptoDecrypt(
             uintData,
@@ -162,7 +164,7 @@ export default class Transmuxer {
             this.decryptionPromise = null;
             return result;
           });
-        return this.decryptionPromise!;
+        return this.decryptionPromise;
       }
     }
 
@@ -170,7 +172,7 @@ export default class Transmuxer {
     if (resetMuxers) {
       const error = this.configureTransmuxer(uintData);
       if (error) {
-        logger.warn(`[transmuxer] ${error.message}`);
+        this.logger.warn(`[transmuxer] ${error.message}`);
         this.observer.emit(Events.ERROR, Events.ERROR, {
           type: ErrorTypes.MEDIA_ERROR,
           details: ErrorDetails.FRAG_PARSING_ERROR,
@@ -208,6 +210,8 @@ export default class Transmuxer {
       accurateTimeOffset,
       chunkMeta,
     );
+    this.asyncResult = isPromise(result);
+
     const currentState = this.currentTransmuxState;
 
     currentState.contiguous = true;
@@ -228,6 +232,7 @@ export default class Transmuxer {
     const { decrypter, currentTransmuxState, decryptionPromise } = this;
 
     if (decryptionPromise) {
+      this.asyncResult = true;
       // Upon resolution, the decryption promise calls push() and returns its TransmuxerResult up the stack. Therefore
       // only flushing is required for async decryption
       return decryptionPromise.then(() => {
@@ -254,11 +259,16 @@ export default class Transmuxer {
     if (!demuxer || !remuxer) {
       // If probing failed, then Hls.js has been given content its not able to handle
       stats.executeEnd = now();
-      return [emptyResult(chunkMeta)];
+      const emptyResults = [emptyResult(chunkMeta)];
+      if (this.asyncResult) {
+        return Promise.resolve(emptyResults);
+      }
+      return emptyResults;
     }
 
     const demuxResultOrPromise = demuxer.flush(timeOffset);
     if (isPromise(demuxResultOrPromise)) {
+      this.asyncResult = true;
       // Decrypt final SAMPLE-AES samples
       return demuxResultOrPromise.then((demuxResult) => {
         this.flushRemux(transmuxResults, demuxResult, chunkMeta);
@@ -267,6 +277,9 @@ export default class Transmuxer {
     }
 
     this.flushRemux(transmuxResults, demuxResultOrPromise, chunkMeta);
+    if (this.asyncResult) {
+      return Promise.resolve(transmuxResults);
+    }
     return transmuxResults;
   }
 
@@ -277,10 +290,10 @@ export default class Transmuxer {
   ) {
     const { audioTrack, videoTrack, id3Track, textTrack } = demuxResult;
     const { accurateTimeOffset, timeOffset } = this.currentTransmuxState;
-    logger.log(
-      `[transmuxer.ts]: Flushed fragment ${chunkMeta.sn}${
+    this.logger.log(
+      `[transmuxer.ts]: Flushed ${this.id} sn: ${chunkMeta.sn}${
         chunkMeta.part > -1 ? ' p: ' + chunkMeta.part : ''
-      } of level ${chunkMeta.level}`,
+      } of ${this.id === PlaylistLevelType.MAIN ? 'level' : 'track'} ${chunkMeta.level}`,
     );
     const remuxResult = this.remuxer!.remux(
       audioTrack,
@@ -438,7 +451,7 @@ export default class Transmuxer {
     // probe for content type
     let mux;
     for (let i = 0, len = muxConfig.length; i < len; i++) {
-      if (muxConfig[i].demux?.probe(data)) {
+      if (muxConfig[i].demux?.probe(data, this.logger)) {
         mux = muxConfig[i];
         break;
       }
@@ -452,10 +465,10 @@ export default class Transmuxer {
     const Remuxer: MuxConfig['remux'] = mux.remux;
     const Demuxer: MuxConfig['demux'] = mux.demux;
     if (!remuxer || !(remuxer instanceof Remuxer)) {
-      this.remuxer = new Remuxer(observer, config, typeSupported, vendor);
+      this.remuxer = new Remuxer(observer, config, typeSupported, this.logger);
     }
     if (!demuxer || !(demuxer instanceof Demuxer)) {
-      this.demuxer = new Demuxer(observer, config, typeSupported);
+      this.demuxer = new Demuxer(observer, config, typeSupported, this.logger);
       this.probe = Demuxer.probe;
     }
   }

package/src/demux/tsdemuxer.ts

@@ -18,11 +18,11 @@ import HevcVideoParser from './video/hevc-video-parser';
 import SampleAesDecrypter from './sample-aes';
 import { Events } from '../events';
 import { appendUint8Array, RemuxerTrackIdConfig } from '../utils/mp4-tools';
-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 type { ILogger } from '../utils/logger';
 import {
   MetadataSchema,
   type DemuxedVideoTrack,
@@ -54,9 +54,10 @@ export type ParsedVideoSample = ParsedTimestamp &
 const PACKET_LENGTH = 188;
 
 class TSDemuxer implements Demuxer {
+  private readonly logger: ILogger;
   private readonly observer: HlsEventEmitter;
   private readonly config: HlsConfig;
-  private typeSupported: TypeSupported;
+  private readonly typeSupported: TypeSupported;
 
   private sampleAes: SampleAesDecrypter | null = null;
   private pmtParsed: boolean = false;
@@ -77,14 +78,16 @@ class TSDemuxer implements Demuxer {
     observer: HlsEventEmitter,
     config: HlsConfig,
     typeSupported: TypeSupported,
+    logger: ILogger,
   ) {
     this.observer = observer;
     this.config = config;
     this.typeSupported = typeSupported;
+    this.logger = logger;
     this.videoParser = null;
   }
 
-  static probe(data: Uint8Array) {
+  static probe(data: Uint8Array, logger: ILogger) {
     const syncOffset = TSDemuxer.syncOffset(data);
     if (syncOffset > 0) {
       logger.warn(
@@ -288,7 +291,7 @@ class TSDemuxer implements Demuxer {
         switch (pid) {
           case videoPid:
             if (stt) {
-              if (videoData && (pes = parsePES(videoData))) {
+              if (videoData && (pes = parsePES(videoData, this.logger))) {
                 if (this.videoParser === null) {
                   switch (videoTrack.segmentCodec) {
                     case 'avc':
@@ -321,7 +324,7 @@ class TSDemuxer implements Demuxer {
             break;
           case audioPid:
             if (stt) {
-              if (audioData && (pes = parsePES(audioData))) {
+              if (audioData && (pes = parsePES(audioData, this.logger))) {
                 switch (audioTrack.segmentCodec) {
                   case 'aac':
                     this.parseAACPES(audioTrack, pes);
@@ -345,7 +348,7 @@ class TSDemuxer implements Demuxer {
             break;
           case id3Pid:
             if (stt) {
-              if (id3Data && (pes = parsePES(id3Data))) {
+              if (id3Data && (pes = parsePES(id3Data, this.logger))) {
                 this.parseID3PES(id3Track, pes);
               }
 
@@ -362,7 +365,7 @@ class TSDemuxer implements Demuxer {
             }
 
             pmtId = this._pmtId = parsePAT(data, offset);
-            // logger.log('PMT PID:'  + this._pmtId);
+            // this.logger.log('PMT PID:'  + this._pmtId);
             break;
           case pmtId: {
             if (stt) {
@@ -375,6 +378,7 @@ class TSDemuxer implements Demuxer {
               this.typeSupported,
               isSampleAes,
               this.observer,
+              this.logger,
             );
 
             // only update track id if track PID found while parsing PMT
@@ -400,7 +404,7 @@ class TSDemuxer implements Demuxer {
             }
 
             if (unknownPID !== null && !pmtParsed) {
-              logger.warn(
+              this.logger.warn(
                 `MPEG-TS PMT found at ${start} after unknown PID '${unknownPID}'. Backtracking to sync byte @${syncOffset} to parse all TS packets.`,
               );
               unknownPID = null;
@@ -428,6 +432,8 @@ class TSDemuxer implements Demuxer {
         new Error(
           `Found ${tsPacketErrors} TS packet/s that do not start with 0x47`,
         ),
+        undefined,
+        this.logger,
       );
     }
 
@@ -477,7 +483,7 @@ class TSDemuxer implements Demuxer {
     const id3Data = id3Track.pesData;
     // try to parse last PES packets
     let pes: PES | null;
-    if (videoData && (pes = parsePES(videoData))) {
+    if (videoData && (pes = parsePES(videoData, this.logger))) {
       if (this.videoParser === null) {
         switch (videoTrack.segmentCodec) {
           case 'avc':
@@ -505,7 +511,7 @@ class TSDemuxer implements Demuxer {
       videoTrack.pesData = videoData;
     }
 
-    if (audioData && (pes = parsePES(audioData))) {
+    if (audioData && (pes = parsePES(audioData, this.logger))) {
       switch (audioTrack.segmentCodec) {
         case 'aac':
           this.parseAACPES(audioTrack, pes);
@@ -522,7 +528,7 @@ class TSDemuxer implements Demuxer {
       audioTrack.pesData = null;
     } else {
       if (audioData?.size) {
-        logger.log(
+        this.logger.log(
           'last AAC PES packet truncated,might overlap between fragments',
         );
       }
@@ -531,7 +537,7 @@ class TSDemuxer implements Demuxer {
       audioTrack.pesData = audioData;
     }
 
-    if (id3Data && (pes = parsePES(id3Data))) {
+    if (id3Data && (pes = parsePES(id3Data, this.logger))) {
       this.parseID3PES(id3Track, pes);
       id3Track.pesData = null;
     } else {
@@ -625,7 +631,12 @@ class TSDemuxer implements Demuxer {
       } else {
         reason = 'No ADTS header found in AAC PES';
       }
-      emitParsingError(this.observer, new Error(reason), recoverable);
+      emitParsingError(
+        this.observer,
+        new Error(reason),
+        recoverable,
+        this.logger,
+      );
       if (!recoverable) {
         return;
       }
@@ -648,7 +659,7 @@ class TSDemuxer implements Demuxer {
       const frameDuration = ADTS.getFrameDuration(track.samplerate as number);
       pts = aacOverFlow.sample.pts + frameDuration;
     } else {
-      logger.warn('[tsdemuxer]: AAC PES unknown PTS');
+      this.logger.warn('[tsdemuxer]: AAC PES unknown PTS');
       return;
     }
 
@@ -679,7 +690,7 @@ class TSDemuxer implements Demuxer {
     let offset = 0;
     const pts = pes.pts;
     if (pts === undefined) {
-      logger.warn('[tsdemuxer]: MPEG PES unknown PTS');
+      this.logger.warn('[tsdemuxer]: MPEG PES unknown PTS');
       return;
     }
 
@@ -711,7 +722,7 @@ class TSDemuxer implements Demuxer {
       const data = pes.data;
       const pts = pes.pts;
       if (pts === undefined) {
-        logger.warn('[tsdemuxer]: AC3 PES unknown PTS');
+        this.logger.warn('[tsdemuxer]: AC3 PES unknown PTS');
         return;
       }
       const length = data.length;
@@ -730,7 +741,7 @@ class TSDemuxer implements Demuxer {
 
   private parseID3PES(id3Track: DemuxedMetadataTrack, pes: PES) {
     if (pes.pts === undefined) {
-      logger.warn('[tsdemuxer]: ID3 PES unknown PTS');
+      this.logger.warn('[tsdemuxer]: ID3 PES unknown PTS');
       return;
     }
     const id3Sample = Object.assign({}, pes as Required<PES>, {
@@ -757,6 +768,7 @@ function parsePMT(
   typeSupported: TypeSupported,
   isSampleAes: boolean,
   observer: HlsEventEmitter,
+  logger: ILogger,
 ) {
   const result = {
     audioPid: -1,
@@ -779,7 +791,7 @@ function parsePMT(
     switch (data[offset]) {
       case 0xcf: // SAMPLE-AES AAC
         if (!isSampleAes) {
-          logEncryptedSamplesFoundInUnencryptedStream('ADTS AAC');
+          logEncryptedSamplesFoundInUnencryptedStream('ADTS AAC', this.logger);
           break;
         }
       /* falls through */
@@ -802,7 +814,7 @@ function parsePMT(
 
       case 0xdb: // SAMPLE-AES AVC
         if (!isSampleAes) {
-          logEncryptedSamplesFoundInUnencryptedStream('H.264');
+          logEncryptedSamplesFoundInUnencryptedStream('H.264', this.logger);
           break;
         }
       /* falls through */
@@ -830,7 +842,7 @@ function parsePMT(
 
       case 0xc1: // SAMPLE-AES AC3
         if (!isSampleAes) {
-          logEncryptedSamplesFoundInUnencryptedStream('AC-3');
+          logEncryptedSamplesFoundInUnencryptedStream('AC-3', this.logger);
           break;
         }
       /* falls through */
@@ -886,7 +898,12 @@ function parsePMT(
       case 0xc2: // SAMPLE-AES EC3
       /* falls through */
       case 0x87:
-        emitParsingError(observer, new Error('Unsupported EC-3 in M2TS found'));
+        emitParsingError(
+          observer,
+          new Error('Unsupported EC-3 in M2TS found'),
+          undefined,
+          this.logger,
+        );
         return result;
 
       case 0x24: // ITU-T Rec. H.265 and ISO/IEC 23008-2 (HEVC)
@@ -900,6 +917,8 @@ function parsePMT(
           emitParsingError(
             observer,
             new Error('Unsupported HEVC in M2TS found'),
+            undefined,
+            this.logger,
           );
           return result;
         }
@@ -919,7 +938,8 @@ function parsePMT(
 function emitParsingError(
   observer: HlsEventEmitter,
   error: Error,
-  levelRetry?: boolean,
+  levelRetry: boolean | undefined,
+  logger: ILogger,
 ) {
   logger.warn(`parsing error: ${error.message}`);
   observer.emit(Events.ERROR, Events.ERROR, {
@@ -932,11 +952,14 @@ function emitParsingError(
   });
 }
 
-function logEncryptedSamplesFoundInUnencryptedStream(type: string) {
+function logEncryptedSamplesFoundInUnencryptedStream(
+  type: string,
+  logger: ILogger,
+) {
   logger.log(`${type} with AES-128-CBC encryption found in unencrypted stream`);
 }
 
-function parsePES(stream: ElementaryStreamData): PES | null {
+function parsePES(stream: ElementaryStreamData, logger: ILogger): PES | null {
   let i = 0;
   let frag: Uint8Array;
   let pesLen: number;