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

package/src/remux/mp4-generator.ts

@@ -28,8 +28,6 @@ class MP4 {
     MP4.types = {
       avc1: [], // codingname
       avcC: [],
-      hvc1: [],
-      hvcC: [],
       btrt: [],
       dinf: [],
       dref: [],
@@ -841,10 +839,8 @@ class MP4 {
         return MP4.box(MP4.types.stsd, MP4.STSD, MP4.ac3(track));
       }
       return MP4.box(MP4.types.stsd, MP4.STSD, MP4.mp4a(track));
-    } else if (track.segmentCodec === 'avc') {
-      return MP4.box(MP4.types.stsd, MP4.STSD, MP4.avc1(track));
     } else {
-      return MP4.box(MP4.types.stsd, MP4.STSD, MP4.hvc1(track));
+      return MP4.box(MP4.types.stsd, MP4.STSD, MP4.avc1(track));
     }
   }
 
@@ -1127,197 +1123,6 @@ class MP4 {
     const result = appendUint8Array(MP4.FTYP, movie);
     return result;
   }
-
-  static hvc1(track) {
-    const ps = track.params;
-    const units = [track.vps, track.sps, track.pps];
-    const NALuLengthSize = 4;
-    const config = new Uint8Array([
-      0x01,
-      (ps.general_profile_space << 6) |
-        (ps.general_tier_flag ? 32 : 0) |
-        ps.general_profile_idc,
-      ps.general_profile_compatibility_flags[0],
-      ps.general_profile_compatibility_flags[1],
-      ps.general_profile_compatibility_flags[2],
-      ps.general_profile_compatibility_flags[3],
-      ps.general_constraint_indicator_flags[0],
-      ps.general_constraint_indicator_flags[1],
-      ps.general_constraint_indicator_flags[2],
-      ps.general_constraint_indicator_flags[3],
-      ps.general_constraint_indicator_flags[4],
-      ps.general_constraint_indicator_flags[5],
-      ps.general_level_idc,
-      240 | (ps.min_spatial_segmentation_idc >> 8),
-      255 & ps.min_spatial_segmentation_idc,
-      252 | ps.parallelismType,
-      252 | ps.chroma_format_idc,
-      248 | ps.bit_depth_luma_minus8,
-      248 | ps.bit_depth_chroma_minus8,
-      0x00,
-      parseInt(ps.frame_rate.fps),
-      (NALuLengthSize - 1) |
-        (ps.temporal_id_nested << 2) |
-        (ps.num_temporal_layers << 3) |
-        (ps.frame_rate.fixed ? 64 : 0),
-      units.length,
-    ]);
-
-    // compute hvcC size in bytes
-    let length = config.length;
-    for (let i = 0; i < units.length; i += 1) {
-      length += 3;
-      for (let j = 0; j < units[i].length; j += 1) {
-        length += 2 + units[i][j].length;
-      }
-    }
-
-    const hvcC = new Uint8Array(length);
-    hvcC.set(config, 0);
-    length = config.length;
-    // append parameter set units: one vps, one or more sps and pps
-    const iMax = units.length - 1;
-    for (let i = 0; i < units.length; i += 1) {
-      hvcC.set(
-        new Uint8Array([
-          (32 + i) | (i === iMax ? 128 : 0),
-          0x00,
-          units[i].length,
-        ]),
-        length,
-      );
-      length += 3;
-      for (let j = 0; j < units[i].length; j += 1) {
-        hvcC.set(
-          new Uint8Array([units[i][j].length >> 8, units[i][j].length & 255]),
-          length,
-        );
-        length += 2;
-        hvcC.set(units[i][j], length);
-        length += units[i][j].length;
-      }
-    }
-    const hvcc = MP4.box(MP4.types.hvcC, hvcC);
-    const width = track.width;
-    const height = track.height;
-    const hSpacing = track.pixelRatio[0];
-    const vSpacing = track.pixelRatio[1];
-
-    return MP4.box(
-      MP4.types.hvc1,
-      new Uint8Array([
-        0x00,
-        0x00,
-        0x00, // reserved
-        0x00,
-        0x00,
-        0x00, // reserved
-        0x00,
-        0x01, // data_reference_index
-        0x00,
-        0x00, // pre_defined
-        0x00,
-        0x00, // reserved
-        0x00,
-        0x00,
-        0x00,
-        0x00,
-        0x00,
-        0x00,
-        0x00,
-        0x00,
-        0x00,
-        0x00,
-        0x00,
-        0x00, // pre_defined
-        (width >> 8) & 0xff,
-        width & 0xff, // width
-        (height >> 8) & 0xff,
-        height & 0xff, // height
-        0x00,
-        0x48,
-        0x00,
-        0x00, // horizresolution
-        0x00,
-        0x48,
-        0x00,
-        0x00, // vertresolution
-        0x00,
-        0x00,
-        0x00,
-        0x00, // reserved
-        0x00,
-        0x01, // frame_count
-        0x12,
-        0x64,
-        0x61,
-        0x69,
-        0x6c, // dailymotion/hls.js
-        0x79,
-        0x6d,
-        0x6f,
-        0x74,
-        0x69,
-        0x6f,
-        0x6e,
-        0x2f,
-        0x68,
-        0x6c,
-        0x73,
-        0x2e,
-        0x6a,
-        0x73,
-        0x00,
-        0x00,
-        0x00,
-        0x00,
-        0x00,
-        0x00,
-        0x00,
-        0x00,
-        0x00,
-        0x00,
-        0x00,
-        0x00,
-        0x00, // compressorname
-        0x00,
-        0x18, // depth = 24
-        0x11,
-        0x11,
-      ]), // pre_defined = -1
-      hvcc,
-      MP4.box(
-        MP4.types.btrt,
-        new Uint8Array([
-          0x00,
-          0x1c,
-          0x9c,
-          0x80, // bufferSizeDB
-          0x00,
-          0x2d,
-          0xc6,
-          0xc0, // maxBitrate
-          0x00,
-          0x2d,
-          0xc6,
-          0xc0,
-        ]),
-      ), // avgBitrate
-      MP4.box(
-        MP4.types.pasp,
-        new Uint8Array([
-          hSpacing >> 24, // hSpacing
-          (hSpacing >> 16) & 0xff,
-          (hSpacing >> 8) & 0xff,
-          hSpacing & 0xff,
-          vSpacing >> 24, // vSpacing
-          (vSpacing >> 16) & 0xff,
-          (vSpacing >> 8) & 0xff,
-          vSpacing & 0xff,
-        ]),
-      ),
-    );
-  }
 }
 
 export default MP4;

package/src/remux/mp4-remuxer.ts

@@ -3,7 +3,8 @@ import MP4 from './mp4-generator';
 import type { HlsEventEmitter } from '../events';
 import { Events } from '../events';
 import { ErrorTypes, ErrorDetails } from '../errors';
-import type {
+import { logger } from '../utils/logger';
+import {
   InitSegmentData,
   Remuxer,
   RemuxerResult,
@@ -26,9 +27,8 @@ import type {
 } from '../types/demuxer';
 import type { TrackSet } from '../types/track';
 import type { SourceBufferName } from '../types/buffer';
+import type { Fragment } from '../loader/fragment';
 import type { HlsConfig } from '../config';
-import type { TypeSupported } from '../utils/codecs';
-import type { ILogger } from '../utils/logger';
 
 const MAX_SILENT_FRAME_DURATION = 10 * 1000; // 10 seconds
 const AAC_SAMPLES_PER_FRAME = 1024;
@@ -39,10 +39,9 @@ let chromeVersion: number | null = null;
 let safariWebkitVersion: number | null = null;
 
 export default class MP4Remuxer implements Remuxer {
-  private readonly logger: ILogger;
-  private readonly observer: HlsEventEmitter;
-  private readonly config: HlsConfig;
-  private readonly typeSupported: TypeSupported;
+  private observer: HlsEventEmitter;
+  private config: HlsConfig;
+  private typeSupported: any;
   private ISGenerated: boolean = false;
   private _initPTS: RationalTimestamp | null = null;
   private _initDTS: RationalTimestamp | null = null;
@@ -60,13 +59,12 @@ export default class MP4Remuxer implements Remuxer {
   constructor(
     observer: HlsEventEmitter,
     config: HlsConfig,
-    typeSupported: TypeSupported,
-    logger: ILogger,
+    typeSupported,
+    vendor = '',
   ) {
     this.observer = observer;
     this.config = config;
     this.typeSupported = typeSupported;
-    this.logger = logger;
     this.ISGenerated = false;
 
     if (chromeVersion === null) {
@@ -86,18 +84,18 @@ export default class MP4Remuxer implements Remuxer {
   }
 
   resetTimeStamp(defaultTimeStamp: RationalTimestamp | null) {
-    this.logger.log('[mp4-remuxer]: initPTS & initDTS reset');
+    logger.log('[mp4-remuxer]: initPTS & initDTS reset');
     this._initPTS = this._initDTS = defaultTimeStamp;
   }
 
   resetNextTimestamp() {
-    this.logger.log('[mp4-remuxer]: reset next timestamp');
+    logger.log('[mp4-remuxer]: reset next timestamp');
     this.isVideoContiguous = false;
     this.isAudioContiguous = false;
   }
 
   resetInitSegment() {
-    this.logger.log('[mp4-remuxer]: ISGenerated flag reset');
+    logger.log('[mp4-remuxer]: ISGenerated flag reset');
     this.ISGenerated = false;
     this.videoTrackConfig = undefined;
   }
@@ -117,7 +115,7 @@ export default class MP4Remuxer implements Remuxer {
       }
     }, videoSamples[0].pts);
     if (rolloverDetected) {
-      this.logger.debug('PTS rollover detected');
+      logger.debug('PTS rollover detected');
     }
     return startPTS;
   }
@@ -161,18 +159,15 @@ export default class MP4Remuxer implements Remuxer {
       if (this.ISGenerated) {
         const config = this.videoTrackConfig;
         if (
-          (config &&
-            (videoTrack.width !== config.width ||
-              videoTrack.height !== config.height ||
-              videoTrack.pixelRatio?.[0] !== config.pixelRatio?.[0] ||
-              videoTrack.pixelRatio?.[1] !== config.pixelRatio?.[1])) ||
-          (!config && enoughVideoSamples) ||
-          (this.nextAudioPts === null && enoughAudioSamples)
+          config &&
+          (videoTrack.width !== config.width ||
+            videoTrack.height !== config.height ||
+            videoTrack.pixelRatio?.[0] !== config.pixelRatio?.[0] ||
+            videoTrack.pixelRatio?.[1] !== config.pixelRatio?.[1])
         ) {
           this.resetInitSegment();
         }
-      }
-      if (!this.ISGenerated) {
+      } else {
         initSegment = this.generateIS(
           audioTrack,
           videoTrack,
@@ -190,7 +185,7 @@ export default class MP4Remuxer implements Remuxer {
         if (!isVideoContiguous && this.config.forceKeyFrameOnDiscontinuity) {
           independent = true;
           if (firstKeyFrameIndex > 0) {
-            this.logger.warn(
+            logger.warn(
               `[mp4-remuxer]: Dropped ${firstKeyFrameIndex} out of ${length} video samples due to a missing keyframe`,
             );
             const startPTS = this.getVideoStartPts(videoTrack.samples);
@@ -201,7 +196,7 @@ export default class MP4Remuxer implements Remuxer {
               videoTrack.inputTimeScale;
             firstKeyFramePTS = videoTimeOffset;
           } else if (firstKeyFrameIndex === -1) {
-            this.logger.warn(
+            logger.warn(
               `[mp4-remuxer]: No keyframe found out of ${length} video samples`,
             );
             independent = false;
@@ -227,7 +222,7 @@ export default class MP4Remuxer implements Remuxer {
         if (enoughAudioSamples) {
           // if initSegment was generated without audio samples, regenerate it again
           if (!audioTrack.samplerate) {
-            this.logger.warn(
+            logger.warn(
               '[mp4-remuxer]: regenerate InitSegment as audio detected',
             );
             initSegment = this.generateIS(
@@ -252,7 +247,7 @@ export default class MP4Remuxer implements Remuxer {
             const audioTrackLength = audio ? audio.endPTS - audio.startPTS : 0;
             // if initSegment was generated without video samples, regenerate it again
             if (!videoTrack.inputTimeScale) {
-              this.logger.warn(
+              logger.warn(
                 '[mp4-remuxer]: regenerate InitSegment as video detected',
               );
               initSegment = this.generateIS(
@@ -519,8 +514,8 @@ export default class MP4Remuxer implements Remuxer {
       const foundOverlap = delta < -1;
       if (foundHole || foundOverlap) {
         if (foundHole) {
-          this.logger.warn(
-            `${(track.segmentCodec || '').toUpperCase()}: ${toMsFromMpegTsClock(
+          logger.warn(
+            `AVC: ${toMsFromMpegTsClock(
               delta,
               true,
             )} ms (${delta}dts) hole between fragments detected at ${timeOffset.toFixed(
@@ -528,8 +523,8 @@ export default class MP4Remuxer implements Remuxer {
             )}`,
           );
         } else {
-          this.logger.warn(
-            `${(track.segmentCodec || '').toUpperCase()}: ${toMsFromMpegTsClock(
+          logger.warn(
+            `AVC: ${toMsFromMpegTsClock(
               -delta,
               true,
             )} ms (${delta}dts) overlapping between fragments detected at ${timeOffset.toFixed(
@@ -548,30 +543,15 @@ export default class MP4Remuxer implements Remuxer {
             inputSamples[0].dts = firstDTS;
             inputSamples[0].pts = firstPTS;
           } else {
-            let isPTSOrderRetained = true;
             for (let i = 0; i < inputSamples.length; i++) {
-              if (inputSamples[i].dts > firstPTS && isPTSOrderRetained) {
+              if (inputSamples[i].dts > firstPTS) {
                 break;
               }
-
-              const prevPTS = inputSamples[i].pts;
               inputSamples[i].dts -= delta;
               inputSamples[i].pts -= delta;
-
-              // check to see if this sample's PTS order has changed
-              // relative to the next one
-              if (i < inputSamples.length - 1) {
-                const nextSamplePTS = inputSamples[i + 1].pts;
-                const currentSamplePTS = inputSamples[i].pts;
-
-                const currentOrder = nextSamplePTS <= currentSamplePTS;
-                const prevOrder = nextSamplePTS <= prevPTS;
-
-                isPTSOrderRetained = currentOrder == prevOrder;
-              }
             }
           }
-          this.logger.log(
+          logger.log(
             `Video: Initial PTS/DTS adjusted: ${toMsFromMpegTsClock(
               firstPTS,
               true,
@@ -693,7 +673,7 @@ export default class MP4Remuxer implements Remuxer {
             } else {
               stretchedLastFrame = true;
             }
-            this.logger.log(
+            logger.log(
               `[mp4-remuxer]: It is approximately ${
                 deltaToFrameEnd / 90
               } ms to the next segment; using duration ${
@@ -742,7 +722,7 @@ export default class MP4Remuxer implements Remuxer {
           averageSampleDuration / maxDtsDelta < 0.025 &&
           outputSamples[0].cts === 0
         ) {
-          this.logger.warn(
+          logger.warn(
             'Found irregular gaps in sample duration. Using PTS instead of DTS to determine MP4 sample duration.',
           );
           let dts = firstDTS;
@@ -763,7 +743,7 @@ export default class MP4Remuxer implements Remuxer {
         }
       }
     }
-    // next AVC/HEVC sample DTS should be equal to last sample DTS + last sample duration (in PES timescale)
+    // next AVC sample DTS should be equal to last sample DTS + last sample duration (in PES timescale)
     mp4SampleDuration =
       stretchedLastFrame || !mp4SampleDuration
         ? averageSampleDuration
@@ -905,7 +885,7 @@ export default class MP4Remuxer implements Remuxer {
           alignedWithVideo
         ) {
           if (i === 0) {
-            this.logger.warn(
+            logger.warn(
               `Audio frame @ ${(pts / inputTimeScale).toFixed(
                 3,
               )}s overlaps nextAudioPts by ${Math.round(
@@ -937,7 +917,7 @@ export default class MP4Remuxer implements Remuxer {
           if (i === 0) {
             this.nextAudioPts = nextAudioPts = nextPts;
           }
-          this.logger.warn(
+          logger.warn(
             `[mp4-remuxer]: Injecting ${missing} audio frame @ ${(
               nextPts / inputTimeScale
             ).toFixed(3)}s due to ${Math.round(
@@ -947,11 +927,11 @@ export default class MP4Remuxer implements Remuxer {
           for (let j = 0; j < missing; j++) {
             const newStamp = Math.max(nextPts as number, 0);
             let fillFrame = AAC.getSilentFrame(
-              track.parsedCodec || track.manifestCodec || track.codec,
+              track.manifestCodec || track.codec,
               track.channelCount,
             );
             if (!fillFrame) {
-              this.logger.log(
+              logger.log(
                 '[mp4-remuxer]: Unable to get silent frame for given audio codec; duplicating last frame instead.',
               );
               fillFrame = sample.unit.subarray();
@@ -1070,6 +1050,55 @@ export default class MP4Remuxer implements Remuxer {
     this.isAudioContiguous = true;
     return audioData;
   }
+
+  remuxEmptyAudio(
+    track: DemuxedAudioTrack,
+    timeOffset: number,
+    contiguous: boolean,
+    videoData: Fragment,
+  ): RemuxedTrack | undefined {
+    const inputTimeScale: number = track.inputTimeScale;
+    const mp4timeScale: number = track.samplerate
+      ? track.samplerate
+      : inputTimeScale;
+    const scaleFactor: number = inputTimeScale / mp4timeScale;
+    const nextAudioPts: number | null = this.nextAudioPts;
+    // sync with video's timestamp
+    const initDTS = this._initDTS as RationalTimestamp;
+    const init90kHz = (initDTS.baseTime * 90000) / initDTS.timescale;
+    const startDTS: number =
+      (nextAudioPts !== null
+        ? nextAudioPts
+        : videoData.startDTS * inputTimeScale) + init90kHz;
+    const endDTS: number = videoData.endDTS * inputTimeScale + init90kHz;
+    // one sample's duration value
+    const frameDuration: number = scaleFactor * AAC_SAMPLES_PER_FRAME;
+    // samples count of this segment's duration
+    const nbSamples: number = Math.ceil((endDTS - startDTS) / frameDuration);
+    // silent frame
+    const silentFrame: Uint8Array | undefined = AAC.getSilentFrame(
+      track.manifestCodec || track.codec,
+      track.channelCount,
+    );
+
+    logger.warn('[mp4-remuxer]: remux empty Audio');
+    // Can't remux if we can't generate a silent frame...
+    if (!silentFrame) {
+      logger.trace(
+        '[mp4-remuxer]: Unable to remuxEmptyAudio since we were unable to get a silent frame for given audio codec',
+      );
+      return;
+    }
+
+    const samples: Array<any> = [];
+    for (let i = 0; i < nbSamples; i++) {
+      const stamp = startDTS + i * frameDuration;
+      samples.push({ unit: silentFrame, pts: stamp, dts: stamp });
+    }
+    track.samples = samples;
+
+    return this.remuxAudio(track, timeOffset, contiguous, false);
+  }
 }
 
 export function normalizePts(value: number, reference: number | null): number {

package/src/remux/passthrough-remuxer.ts

@@ -14,9 +14,8 @@ import {
   parseInitSegment,
 } from '../utils/mp4-tools';
 import { ElementaryStreamTypes } from '../loader/fragment';
+import { logger } from '../utils/logger';
 import { getCodecCompatibleName } from '../utils/codecs';
-import type { HlsEventEmitter } from '../events';
-import type { HlsConfig } from '../config';
 import type { TrackSet } from '../types/track';
 import type {
   InitSegmentData,
@@ -31,12 +30,9 @@ import type {
   PassthroughTrack,
 } from '../types/demuxer';
 import type { DecryptData } from '../loader/level-key';
-import type { TypeSupported } from '../utils/codecs';
-import type { ILogger } from '../utils/logger';
 import type { RationalTimestamp } from '../utils/timescale-conversion';
 
 class PassThroughRemuxer implements Remuxer {
-  private readonly logger: ILogger;
   private emitInitSegment: boolean = false;
   private audioCodec?: string;
   private videoCodec?: string;
@@ -45,15 +41,6 @@ class PassThroughRemuxer implements Remuxer {
   private initTracks?: TrackSet;
   private lastEndTime: number | null = null;
 
-  constructor(
-    observer: HlsEventEmitter,
-    config: HlsConfig,
-    typeSupported: TypeSupported,
-    logger: ILogger,
-  ) {
-    this.logger = logger;
-  }
-
   public destroy() {}
 
   public resetTimeStamp(defaultInitPTS: RationalTimestamp | null) {
@@ -124,7 +111,7 @@ class PassThroughRemuxer implements Remuxer {
         id: 'main',
       };
     } else {
-      this.logger.warn(
+      logger.warn(
         '[passthrough-remuxer.ts]: initSegment does not contain moov or trak boxes.',
       );
     }
@@ -173,9 +160,7 @@ class PassThroughRemuxer implements Remuxer {
     }
     if (!initData?.length) {
       // We can't remux if the initSegment could not be generated
-      this.logger.warn(
-        '[passthrough-remuxer.ts]: Failed to generate initSegment.',
-      );
+      logger.warn('[passthrough-remuxer.ts]: Failed to generate initSegment.');
       return result;
     }
     if (this.emitInitSegment) {
@@ -192,8 +177,8 @@ class PassThroughRemuxer implements Remuxer {
     ) {
       initSegment.initPTS = decodeTime - timeOffset;
       if (initPTS && initPTS.timescale === 1) {
-        this.logger.warn(
-          `Adjusting initPTS @${timeOffset} from ${initPTS.baseTime / initPTS.timescale} to ${initSegment.initPTS}`,
+        logger.warn(
+          `Adjusting initPTS by ${initSegment.initPTS - initPTS.baseTime}`,
         );
       }
       this.initPTS = initPTS = {
@@ -211,7 +196,7 @@ class PassThroughRemuxer implements Remuxer {
     if (duration > 0) {
       this.lastEndTime = endTime;
     } else {
-      this.logger.warn('Duration parsed from mp4 should be greater than zero');
+      logger.warn('Duration parsed from mp4 should be greater than zero');
       this.resetNextTimestamp();
     }
 
@@ -299,14 +284,14 @@ function getParsedTrackCodec(
       return getCodecCompatibleName(parsedCodec, preferManagedMediaSource);
     }
     const result = 'mp4a.40.5';
-    this.logger.info(
+    logger.info(
       `Parsed audio codec "${parsedCodec}" or audio object type not handled. Using "${result}"`,
     );
     return result;
   }
   // Provide defaults based on codec type
   // This allows for some playback of some fmp4 playlists without CODECS defined in manifest
-  this.logger.warn(`Unhandled video codec "${parsedCodec}"`);
+  logger.warn(`Unhandled video codec "${parsedCodec}"`);
   if (parsedCodec === 'hvc1' || parsedCodec === 'hev1') {
     return 'hvc1.1.6.L120.90';
   }

package/src/task-loop.ts

@@ -1,5 +1,3 @@
-import { type ILogger, Logger } from './utils/logger';
-
 /**
  * @ignore
  * Sub-class specialization of EventHandler base class.
@@ -29,14 +27,13 @@ import { type ILogger, Logger } from './utils/logger';
  * we are limiting the task execution per call stack to exactly one, but scheduling/post-poning further
  * task processing on the next main loop iteration (also known as "next tick" in the Node/JS runtime lingo).
  */
-export default class TaskLoop extends Logger {
+export default class TaskLoop {
   private readonly _boundTick: () => void;
   private _tickTimer: number | null = null;
   private _tickInterval: number | null = null;
   private _tickCallCount = 0;
 
-  constructor(label: string, logger: ILogger) {
-    super(label, logger);
+  constructor() {
     this._boundTick = this.tick.bind(this);
   }
 

package/src/types/component-api.ts

@@ -1,4 +1,4 @@
-import type EwmaBandWidthEstimator from '../utils/ewma-bandwidth-estimator';
+import EwmaBandWidthEstimator from '../utils/ewma-bandwidth-estimator';
 
 export interface ComponentAPI {
   destroy(): void;
@@ -15,6 +15,4 @@ export interface AbrComponentAPI extends ComponentAPI {
 export interface NetworkComponentAPI extends ComponentAPI {
   startLoad(startPosition: number): void;
   stopLoad(): void;
-  pauseBuffering?(): void;
-  resumeBuffering?(): void;
 }

package/src/types/demuxer.ts

@@ -64,7 +64,6 @@ export interface DemuxedAudioTrack extends DemuxedTrack {
   segmentCodec?: string;
   channelCount?: number;
   manifestCodec?: string;
-  parsedCodec?: string;
   samples: AudioSample[];
 }
 
@@ -73,14 +72,12 @@ export interface DemuxedVideoTrackBase extends DemuxedTrack {
   height?: number;
   pixelRatio?: [number, number];
   audFound?: boolean;
-  vps?: Uint8Array[];
   pps?: Uint8Array[];
   sps?: Uint8Array[];
   naluState?: number;
   segmentCodec?: string;
   manifestCodec?: string;
   samples: VideoSample[] | Uint8Array;
-  params?: object;
 }
 
 export interface DemuxedVideoTrack extends DemuxedVideoTrackBase {