hls.js 1.5.2-0.canary.9969 → 1.5.2-0.canary.9971

package/dist/hls.light.mjs

@@ -431,7 +431,7 @@ function enableLogs(debugConfig, context, id) {
     // Some browsers don't allow to use bind on console object anyway
     // fallback to default if needed
     try {
-      newLogger.log(`Debug logs enabled for "${context}" in hls.js version ${"1.5.2-0.canary.9969"}`);
+      newLogger.log(`Debug logs enabled for "${context}" in hls.js version ${"1.5.2-0.canary.9971"}`);
     } catch (e) {
       /* log fn threw an exception. All logger methods are no-ops. */
       return createLogger();
@@ -7245,6 +7245,7 @@ class BufferController extends Logger {
       this.resetBuffer(type);
     });
     this._initSourceBuffer();
+    this.hls.resumeBuffering();
   }
   resetBuffer(type) {
     const sb = this.sourceBuffer[type];
@@ -11953,6 +11954,7 @@ class BaseStreamController extends TaskLoop {
     this.startFragRequested = false;
     this.decrypter = void 0;
     this.initPTS = [];
+    this.buffering = true;
     this.onMediaSeeking = () => {
       const {
         config,
@@ -12058,6 +12060,12 @@ class BaseStreamController extends TaskLoop {
     this.clearNextTick();
     this.state = State.STOPPED;
   }
+  pauseBuffering() {
+    this.buffering = false;
+  }
+  resumeBuffering() {
+    this.buffering = true;
+  }
   _streamEnded(bufferInfo, levelDetails) {
     // If playlist is live, there is another buffered range after the current range, nothing buffered, media is detached,
     // of nothing loading/loaded return false
@@ -14066,6 +14074,110 @@ class BaseVideoParser {
       logger.log(VideoSample.pts + '/' + VideoSample.dts + ':' + VideoSample.debug);
     }
   }
+  parseNALu(track, array) {
+    const len = array.byteLength;
+    let state = track.naluState || 0;
+    const lastState = state;
+    const units = [];
+    let i = 0;
+    let value;
+    let overflow;
+    let unitType;
+    let lastUnitStart = -1;
+    let lastUnitType = 0;
+    // logger.log('PES:' + Hex.hexDump(array));
+
+    if (state === -1) {
+      // special use case where we found 3 or 4-byte start codes exactly at the end of previous PES packet
+      lastUnitStart = 0;
+      // NALu type is value read from offset 0
+      lastUnitType = this.getNALuType(array, 0);
+      state = 0;
+      i = 1;
+    }
+    while (i < len) {
+      value = array[i++];
+      // optimization. state 0 and 1 are the predominant case. let's handle them outside of the switch/case
+      if (!state) {
+        state = value ? 0 : 1;
+        continue;
+      }
+      if (state === 1) {
+        state = value ? 0 : 2;
+        continue;
+      }
+      // here we have state either equal to 2 or 3
+      if (!value) {
+        state = 3;
+      } else if (value === 1) {
+        overflow = i - state - 1;
+        if (lastUnitStart >= 0) {
+          const unit = {
+            data: array.subarray(lastUnitStart, overflow),
+            type: lastUnitType
+          };
+          // logger.log('pushing NALU, type/size:' + unit.type + '/' + unit.data.byteLength);
+          units.push(unit);
+        } else {
+          // lastUnitStart is undefined => this is the first start code found in this PES packet
+          // first check if start code delimiter is overlapping between 2 PES packets,
+          // ie it started in last packet (lastState not zero)
+          // and ended at the beginning of this PES packet (i <= 4 - lastState)
+          const lastUnit = this.getLastNalUnit(track.samples);
+          if (lastUnit) {
+            if (lastState && i <= 4 - lastState) {
+              // start delimiter overlapping between PES packets
+              // strip start delimiter bytes from the end of last NAL unit
+              // check if lastUnit had a state different from zero
+              if (lastUnit.state) {
+                // strip last bytes
+                lastUnit.data = lastUnit.data.subarray(0, lastUnit.data.byteLength - lastState);
+              }
+            }
+            // If NAL units are not starting right at the beginning of the PES packet, push preceding data into previous NAL unit.
+
+            if (overflow > 0) {
+              // logger.log('first NALU found with overflow:' + overflow);
+              lastUnit.data = appendUint8Array(lastUnit.data, array.subarray(0, overflow));
+              lastUnit.state = 0;
+            }
+          }
+        }
+        // check if we can read unit type
+        if (i < len) {
+          unitType = this.getNALuType(array, i);
+          // logger.log('find NALU @ offset:' + i + ',type:' + unitType);
+          lastUnitStart = i;
+          lastUnitType = unitType;
+          state = 0;
+        } else {
+          // not enough byte to read unit type. let's read it on next PES parsing
+          state = -1;
+        }
+      } else {
+        state = 0;
+      }
+    }
+    if (lastUnitStart >= 0 && state >= 0) {
+      const unit = {
+        data: array.subarray(lastUnitStart, len),
+        type: lastUnitType,
+        state: state
+      };
+      units.push(unit);
+      // logger.log('pushing NALU, type/size/state:' + unit.type + '/' + unit.data.byteLength + '/' + state);
+    }
+    // no NALu found
+    if (units.length === 0) {
+      // append pes.data to previous NAL unit
+      const lastUnit = this.getLastNalUnit(track.samples);
+      if (lastUnit) {
+        lastUnit.data = appendUint8Array(lastUnit.data, array);
+      }
+    }
+    track.naluState = state;
+    return units;
+  }
 }
 
 /**
@@ -14208,21 +14320,171 @@ class ExpGolomb {
   readUInt() {
     return this.readBits(32);
   }
+}
+
+class AvcVideoParser extends BaseVideoParser {
+  parsePES(track, textTrack, pes, last, duration) {
+    const units = this.parseNALu(track, pes.data);
+    let VideoSample = this.VideoSample;
+    let push;
+    let spsfound = false;
+    // free pes.data to save up some memory
+    pes.data = null;
+
+    // if new NAL units found and last sample still there, let's push ...
+    // this helps parsing streams with missing AUD (only do this if AUD never found)
+    if (VideoSample && units.length && !track.audFound) {
+      this.pushAccessUnit(VideoSample, track);
+      VideoSample = this.VideoSample = this.createVideoSample(false, pes.pts, pes.dts, '');
+    }
+    units.forEach(unit => {
+      var _VideoSample2;
+      switch (unit.type) {
+        // NDR
+        case 1:
+          {
+            let iskey = false;
+            push = true;
+            const data = unit.data;
+            // only check slice type to detect KF in case SPS found in same packet (any keyframe is preceded by SPS ...)
+            if (spsfound && data.length > 4) {
+              // retrieve slice type by parsing beginning of NAL unit (follow H264 spec, slice_header definition) to detect keyframe embedded in NDR
+              const sliceType = this.readSliceType(data);
+              // 2 : I slice, 4 : SI slice, 7 : I slice, 9: SI slice
+              // SI slice : A slice that is coded using intra prediction only and using quantisation of the prediction samples.
+              // An SI slice can be coded such that its decoded samples can be constructed identically to an SP slice.
+              // I slice: A slice that is not an SI slice that is decoded using intra prediction only.
+              // if (sliceType === 2 || sliceType === 7) {
+              if (sliceType === 2 || sliceType === 4 || sliceType === 7 || sliceType === 9) {
+                iskey = true;
+              }
+            }
+            if (iskey) {
+              var _VideoSample;
+              // if we have non-keyframe data already, that cannot belong to the same frame as a keyframe, so force a push
+              if ((_VideoSample = VideoSample) != null && _VideoSample.frame && !VideoSample.key) {
+                this.pushAccessUnit(VideoSample, track);
+                VideoSample = this.VideoSample = null;
+              }
+            }
+            if (!VideoSample) {
+              VideoSample = this.VideoSample = this.createVideoSample(true, pes.pts, pes.dts, '');
+            }
+            VideoSample.frame = true;
+            VideoSample.key = iskey;
+            break;
+            // IDR
+          }
+        case 5:
+          push = true;
+          // handle PES not starting with AUD
+          // if we have frame data already, that cannot belong to the same frame, so force a push
+          if ((_VideoSample2 = VideoSample) != null && _VideoSample2.frame && !VideoSample.key) {
+            this.pushAccessUnit(VideoSample, track);
+            VideoSample = this.VideoSample = null;
+          }
+          if (!VideoSample) {
+            VideoSample = this.VideoSample = this.createVideoSample(true, pes.pts, pes.dts, '');
+          }
+          VideoSample.key = true;
+          VideoSample.frame = true;
+          break;
+        // SEI
+        case 6:
+          {
+            push = true;
+            parseSEIMessageFromNALu(unit.data, 1, pes.pts, textTrack.samples);
+            break;
+            // SPS
+          }
+        case 7:
+          {
+            var _track$pixelRatio, _track$pixelRatio2;
+            push = true;
+            spsfound = true;
+            const sps = unit.data;
+            const config = this.readSPS(sps);
+            if (!track.sps || track.width !== config.width || track.height !== config.height || ((_track$pixelRatio = track.pixelRatio) == null ? void 0 : _track$pixelRatio[0]) !== config.pixelRatio[0] || ((_track$pixelRatio2 = track.pixelRatio) == null ? void 0 : _track$pixelRatio2[1]) !== config.pixelRatio[1]) {
+              track.width = config.width;
+              track.height = config.height;
+              track.pixelRatio = config.pixelRatio;
+              track.sps = [sps];
+              track.duration = duration;
+              const codecarray = sps.subarray(1, 4);
+              let codecstring = 'avc1.';
+              for (let i = 0; i < 3; i++) {
+                let h = codecarray[i].toString(16);
+                if (h.length < 2) {
+                  h = '0' + h;
+                }
+                codecstring += h;
+              }
+              track.codec = codecstring;
+            }
+            break;
+          }
+        // PPS
+        case 8:
+          push = true;
+          track.pps = [unit.data];
+          break;
+        // AUD
+        case 9:
+          push = true;
+          track.audFound = true;
+          if (VideoSample) {
+            this.pushAccessUnit(VideoSample, track);
+          }
+          VideoSample = this.VideoSample = this.createVideoSample(false, pes.pts, pes.dts, '');
+          break;
+        // Filler Data
+        case 12:
+          push = true;
+          break;
+        default:
+          push = false;
+          if (VideoSample) {
+            VideoSample.debug += 'unknown NAL ' + unit.type + ' ';
+          }
+          break;
+      }
+      if (VideoSample && push) {
+        const units = VideoSample.units;
+        units.push(unit);
+      }
+    });
+    // if last PES packet, push samples
+    if (last && VideoSample) {
+      this.pushAccessUnit(VideoSample, track);
+      this.VideoSample = null;
+    }
+  }
+  getNALuType(data, offset) {
+    return data[offset] & 0x1f;
+  }
+  readSliceType(data) {
+    const eg = new ExpGolomb(data);
+    // skip NALu type
+    eg.readUByte();
+    // discard first_mb_in_slice
+    eg.readUEG();
+    // return slice_type
+    return eg.readUEG();
+  }
 
   /**
-   * Advance the ExpGolomb decoder past a scaling list. The scaling
-   * list is optionally transmitted as part of a sequence parameter
+   * The scaling list is optionally transmitted as part of a sequence parameter
    * set and is not relevant to transmuxing.
    * @param count the number of entries in this scaling list
    * @see Recommendation ITU-T H.264, Section 7.3.2.1.1.1
    */
-  skipScalingList(count) {
+  skipScalingList(count, reader) {
     let lastScale = 8;
     let nextScale = 8;
     let deltaScale;
     for (let j = 0; j < count; j++) {
       if (nextScale !== 0) {
-        deltaScale = this.readEG();
+        deltaScale = reader.readEG();
         nextScale = (lastScale + deltaScale + 256) % 256;
       }
       lastScale = nextScale === 0 ? lastScale : nextScale;
@@ -14237,7 +14499,8 @@ class ExpGolomb {
    * sequence parameter set, including the dimensions of the
    * associated video frames.
    */
-  readSPS() {
+  readSPS(sps) {
+    const eg = new ExpGolomb(sps);
     let frameCropLeftOffset = 0;
     let frameCropRightOffset = 0;
     let frameCropTopOffset = 0;
@@ -14245,13 +14508,13 @@ class ExpGolomb {
     let numRefFramesInPicOrderCntCycle;
     let scalingListCount;
     let i;
-    const readUByte = this.readUByte.bind(this);
-    const readBits = this.readBits.bind(this);
-    const readUEG = this.readUEG.bind(this);
-    const readBoolean = this.readBoolean.bind(this);
-    const skipBits = this.skipBits.bind(this);
-    const skipEG = this.skipEG.bind(this);
-    const skipUEG = this.skipUEG.bind(this);
+    const readUByte = eg.readUByte.bind(eg);
+    const readBits = eg.readBits.bind(eg);
+    const readUEG = eg.readUEG.bind(eg);
+    const readBoolean = eg.readBoolean.bind(eg);
+    const skipBits = eg.skipBits.bind(eg);
+    const skipEG = eg.skipEG.bind(eg);
+    const skipUEG = eg.skipUEG.bind(eg);
     const skipScalingList = this.skipScalingList.bind(this);
     readUByte();
     const profileIdc = readUByte(); // profile_idc
@@ -14276,9 +14539,9 @@ class ExpGolomb {
           if (readBoolean()) {
             // seq_scaling_list_present_flag[ i ]
             if (i < 6) {
-              skipScalingList(16);
+              skipScalingList(16, eg);
             } else {
-              skipScalingList(64);
+              skipScalingList(64, eg);
             }
           }
         }
@@ -14383,19 +14646,15 @@ class ExpGolomb {
       pixelRatio: pixelRatio
     };
   }
-  readSliceType() {
-    // skip NALu type
-    this.readUByte();
-    // discard first_mb_in_slice
-    this.readUEG();
-    // return slice_type
-    return this.readUEG();
-  }
 }
 
-class AvcVideoParser extends BaseVideoParser {
-  parseAVCPES(track, textTrack, pes, last, duration) {
-    const units = this.parseAVCNALu(track, pes.data);
+class HevcVideoParser extends BaseVideoParser {
+  constructor(...args) {
+    super(...args);
+    this.initVPS = null;
+  }
+  parsePES(track, textTrack, pes, last, duration) {
+    const units = this.parseNALu(track, pes.data);
     let VideoSample = this.VideoSample;
     let push;
     let spsfound = false;
@@ -14411,42 +14670,49 @@ class AvcVideoParser extends BaseVideoParser {
     units.forEach(unit => {
       var _VideoSample2;
       switch (unit.type) {
-        // NDR
+        // NON-IDR, NON RANDOM ACCESS SLICE
+        case 0:
         case 1:
-          {
-            let iskey = false;
-            push = true;
-            const data = unit.data;
-            // only check slice type to detect KF in case SPS found in same packet (any keyframe is preceded by SPS ...)
-            if (spsfound && data.length > 4) {
-              // retrieve slice type by parsing beginning of NAL unit (follow H264 spec, slice_header definition) to detect keyframe embedded in NDR
-              const sliceType = new ExpGolomb(data).readSliceType();
-              // 2 : I slice, 4 : SI slice, 7 : I slice, 9: SI slice
-              // SI slice : A slice that is coded using intra prediction only and using quantisation of the prediction samples.
-              // An SI slice can be coded such that its decoded samples can be constructed identically to an SP slice.
-              // I slice: A slice that is not an SI slice that is decoded using intra prediction only.
-              // if (sliceType === 2 || sliceType === 7) {
-              if (sliceType === 2 || sliceType === 4 || sliceType === 7 || sliceType === 9) {
-                iskey = true;
-              }
-            }
-            if (iskey) {
-              var _VideoSample;
-              // if we have non-keyframe data already, that cannot belong to the same frame as a keyframe, so force a push
-              if ((_VideoSample = VideoSample) != null && _VideoSample.frame && !VideoSample.key) {
-                this.pushAccessUnit(VideoSample, track);
-                VideoSample = this.VideoSample = null;
-              }
-            }
-            if (!VideoSample) {
-              VideoSample = this.VideoSample = this.createVideoSample(true, pes.pts, pes.dts, '');
+        case 2:
+        case 3:
+        case 4:
+        case 5:
+        case 6:
+        case 7:
+        case 8:
+        case 9:
+          if (!VideoSample) {
+            VideoSample = this.VideoSample = this.createVideoSample(false, pes.pts, pes.dts, '');
+          }
+          VideoSample.frame = true;
+          push = true;
+          break;
+
+        // CRA, BLA (random access picture)
+        case 16:
+        case 17:
+        case 18:
+        case 21:
+          push = true;
+          if (spsfound) {
+            var _VideoSample;
+            // handle PES not starting with AUD
+            // if we have frame data already, that cannot belong to the same frame, so force a push
+            if ((_VideoSample = VideoSample) != null && _VideoSample.frame && !VideoSample.key) {
+              this.pushAccessUnit(VideoSample, track);
+              VideoSample = this.VideoSample = null;
             }
-            VideoSample.frame = true;
-            VideoSample.key = iskey;
-            break;
-            // IDR
           }
-        case 5:
+          if (!VideoSample) {
+            VideoSample = this.VideoSample = this.createVideoSample(true, pes.pts, pes.dts, '');
+          }
+          VideoSample.key = true;
+          VideoSample.frame = true;
+          break;
+
+        // IDR
+        case 19:
+        case 20:
           push = true;
           // handle PES not starting with AUD
           // if we have frame data already, that cannot belong to the same frame, so force a push
@@ -14460,48 +14726,76 @@ class AvcVideoParser extends BaseVideoParser {
           VideoSample.key = true;
           VideoSample.frame = true;
           break;
+
         // SEI
-        case 6:
-          {
-            push = true;
-            parseSEIMessageFromNALu(unit.data, 1, pes.pts, textTrack.samples);
-            break;
-            // SPS
+        case 39:
+          push = true;
+          parseSEIMessageFromNALu(unit.data, 2,
+          // NALu header size
+          pes.pts, textTrack.samples);
+          break;
+
+        // VPS
+        case 32:
+          push = true;
+          if (!track.vps) {
+            const config = this.readVPS(unit.data);
+            track.params = _objectSpread2({}, config);
+            this.initVPS = unit.data;
           }
-        case 7:
-          {
-            var _track$pixelRatio, _track$pixelRatio2;
-            push = true;
-            spsfound = true;
-            const sps = unit.data;
-            const expGolombDecoder = new ExpGolomb(sps);
-            const config = expGolombDecoder.readSPS();
-            if (!track.sps || track.width !== config.width || track.height !== config.height || ((_track$pixelRatio = track.pixelRatio) == null ? void 0 : _track$pixelRatio[0]) !== config.pixelRatio[0] || ((_track$pixelRatio2 = track.pixelRatio) == null ? void 0 : _track$pixelRatio2[1]) !== config.pixelRatio[1]) {
+          track.vps = [unit.data];
+          break;
+
+        // SPS
+        case 33:
+          push = true;
+          spsfound = true;
+          if (typeof track.params === 'object') {
+            if (track.vps !== undefined && track.vps[0] !== this.initVPS && track.sps !== undefined && !this.matchSPS(track.sps[0], unit.data)) {
+              this.initVPS = track.vps[0];
+              track.sps = track.pps = undefined;
+            }
+            if (!track.sps) {
+              const config = this.readSPS(unit.data);
               track.width = config.width;
               track.height = config.height;
               track.pixelRatio = config.pixelRatio;
-              track.sps = [sps];
               track.duration = duration;
-              const codecarray = sps.subarray(1, 4);
-              let codecstring = 'avc1.';
-              for (let i = 0; i < 3; i++) {
-                let h = codecarray[i].toString(16);
-                if (h.length < 2) {
-                  h = '0' + h;
-                }
-                codecstring += h;
+              track.codec = config.codecString;
+              track.sps = [];
+              for (const prop in config.params) {
+                track.params[prop] = config.params[prop];
               }
-              track.codec = codecstring;
             }
-            break;
+            if (track.vps !== undefined && track.vps[0] === this.initVPS) {
+              track.sps.push(unit.data);
+            }
+          }
+          if (!VideoSample) {
+            VideoSample = this.VideoSample = this.createVideoSample(true, pes.pts, pes.dts, '');
           }
+          VideoSample.key = true;
+          break;
+
         // PPS
-        case 8:
+        case 34:
           push = true;
-          track.pps = [unit.data];
+          if (typeof track.params === 'object') {
+            if (!track.pps) {
+              track.pps = [];
+              const config = this.readPPS(unit.data);
+              for (const prop in config) {
+                track.params[prop] = config[prop];
+              }
+            }
+            if (this.initVPS !== null || track.pps.length === 0) {
+              track.pps.push(unit.data);
+            }
+          }
           break;
-        // AUD
-        case 9:
+
+        // ACCESS UNIT DELIMITER
+        case 35:
           push = true;
           track.audFound = true;
           if (VideoSample) {
@@ -14509,14 +14803,10 @@ class AvcVideoParser extends BaseVideoParser {
           }
           VideoSample = this.VideoSample = this.createVideoSample(false, pes.pts, pes.dts, '');
           break;
-        // Filler Data
-        case 12:
-          push = true;
-          break;
         default:
           push = false;
           if (VideoSample) {
-            VideoSample.debug += 'unknown NAL ' + unit.type + ' ';
+            VideoSample.debug += 'unknown or irrelevant NAL ' + unit.type + ' ';
           }
           break;
       }
@@ -14531,109 +14821,423 @@ class AvcVideoParser extends BaseVideoParser {
       this.VideoSample = null;
     }
   }
-  parseAVCNALu(track, array) {
-    const len = array.byteLength;
-    let state = track.naluState || 0;
-    const lastState = state;
-    const units = [];
-    let i = 0;
-    let value;
-    let overflow;
-    let unitType;
-    let lastUnitStart = -1;
-    let lastUnitType = 0;
-    // logger.log('PES:' + Hex.hexDump(array));
-
-    if (state === -1) {
-      // special use case where we found 3 or 4-byte start codes exactly at the end of previous PES packet
-      lastUnitStart = 0;
-      // NALu type is value read from offset 0
-      lastUnitType = array[0] & 0x1f;
-      state = 0;
-      i = 1;
-    }
-    while (i < len) {
-      value = array[i++];
-      // optimization. state 0 and 1 are the predominant case. let's handle them outside of the switch/case
-      if (!state) {
-        state = value ? 0 : 1;
-        continue;
-      }
-      if (state === 1) {
-        state = value ? 0 : 2;
-        continue;
+  getNALuType(data, offset) {
+    return (data[offset] & 0x7e) >>> 1;
+  }
+  ebsp2rbsp(arr) {
+    const dst = new Uint8Array(arr.byteLength);
+    let dstIdx = 0;
+    for (let i = 0; i < arr.byteLength; i++) {
+      if (i >= 2) {
+        // Unescape: Skip 0x03 after 00 00
+        if (arr[i] === 0x03 && arr[i - 1] === 0x00 && arr[i - 2] === 0x00) {
+          continue;
+        }
       }
-      // here we have state either equal to 2 or 3
-      if (!value) {
-        state = 3;
-      } else if (value === 1) {
-        overflow = i - state - 1;
-        if (lastUnitStart >= 0) {
-          const unit = {
-            data: array.subarray(lastUnitStart, overflow),
-            type: lastUnitType
-          };
-          // logger.log('pushing NALU, type/size:' + unit.type + '/' + unit.data.byteLength);
-          units.push(unit);
-        } else {
-          // lastUnitStart is undefined => this is the first start code found in this PES packet
-          // first check if start code delimiter is overlapping between 2 PES packets,
-          // ie it started in last packet (lastState not zero)
-          // and ended at the beginning of this PES packet (i <= 4 - lastState)
-          const lastUnit = this.getLastNalUnit(track.samples);
-          if (lastUnit) {
-            if (lastState && i <= 4 - lastState) {
-              // start delimiter overlapping between PES packets
-              // strip start delimiter bytes from the end of last NAL unit
-              // check if lastUnit had a state different from zero
-              if (lastUnit.state) {
-                // strip last bytes
-                lastUnit.data = lastUnit.data.subarray(0, lastUnit.data.byteLength - lastState);
-              }
-            }
-            // If NAL units are not starting right at the beginning of the PES packet, push preceding data into previous NAL unit.
+      dst[dstIdx] = arr[i];
+      dstIdx++;
+    }
+    return new Uint8Array(dst.buffer, 0, dstIdx);
+  }
+  readVPS(vps) {
+    const eg = new ExpGolomb(vps);
+    // remove header
+    eg.readUByte();
+    eg.readUByte();
+    eg.readBits(4); // video_parameter_set_id
+    eg.skipBits(2);
+    eg.readBits(6); // max_layers_minus1
+    const max_sub_layers_minus1 = eg.readBits(3);
+    const temporal_id_nesting_flag = eg.readBoolean();
+    // ...vui fps can be here, but empty fps value is not critical for metadata
 
-            if (overflow > 0) {
-              // logger.log('first NALU found with overflow:' + overflow);
-              lastUnit.data = appendUint8Array(lastUnit.data, array.subarray(0, overflow));
-              lastUnit.state = 0;
+    return {
+      numTemporalLayers: max_sub_layers_minus1 + 1,
+      temporalIdNested: temporal_id_nesting_flag
+    };
+  }
+  readSPS(sps) {
+    const eg = new ExpGolomb(this.ebsp2rbsp(sps));
+    eg.readUByte();
+    eg.readUByte();
+    eg.readBits(4); //video_parameter_set_id
+    const max_sub_layers_minus1 = eg.readBits(3);
+    eg.readBoolean(); // temporal_id_nesting_flag
+
+    // profile_tier_level
+    const general_profile_space = eg.readBits(2);
+    const general_tier_flag = eg.readBoolean();
+    const general_profile_idc = eg.readBits(5);
+    const general_profile_compatibility_flags_1 = eg.readUByte();
+    const general_profile_compatibility_flags_2 = eg.readUByte();
+    const general_profile_compatibility_flags_3 = eg.readUByte();
+    const general_profile_compatibility_flags_4 = eg.readUByte();
+    const general_constraint_indicator_flags_1 = eg.readUByte();
+    const general_constraint_indicator_flags_2 = eg.readUByte();
+    const general_constraint_indicator_flags_3 = eg.readUByte();
+    const general_constraint_indicator_flags_4 = eg.readUByte();
+    const general_constraint_indicator_flags_5 = eg.readUByte();
+    const general_constraint_indicator_flags_6 = eg.readUByte();
+    const general_level_idc = eg.readUByte();
+    const sub_layer_profile_present_flags = [];
+    const sub_layer_level_present_flags = [];
+    for (let i = 0; i < max_sub_layers_minus1; i++) {
+      sub_layer_profile_present_flags.push(eg.readBoolean());
+      sub_layer_level_present_flags.push(eg.readBoolean());
+    }
+    if (max_sub_layers_minus1 > 0) {
+      for (let i = max_sub_layers_minus1; i < 8; i++) {
+        eg.readBits(2);
+      }
+    }
+    for (let i = 0; i < max_sub_layers_minus1; i++) {
+      if (sub_layer_profile_present_flags[i]) {
+        eg.readUByte(); // sub_layer_profile_space, sub_layer_tier_flag, sub_layer_profile_idc
+        eg.readUByte();
+        eg.readUByte();
+        eg.readUByte();
+        eg.readUByte(); // sub_layer_profile_compatibility_flag
+        eg.readUByte();
+        eg.readUByte();
+        eg.readUByte();
+        eg.readUByte();
+        eg.readUByte();
+        eg.readUByte();
+      }
+      if (sub_layer_level_present_flags[i]) {
+        eg.readUByte();
+      }
+    }
+    eg.readUEG(); // seq_parameter_set_id
+    const chroma_format_idc = eg.readUEG();
+    if (chroma_format_idc == 3) {
+      eg.skipBits(1); //separate_colour_plane_flag
+    }
+    const pic_width_in_luma_samples = eg.readUEG();
+    const pic_height_in_luma_samples = eg.readUEG();
+    const conformance_window_flag = eg.readBoolean();
+    let pic_left_offset = 0,
+      pic_right_offset = 0,
+      pic_top_offset = 0,
+      pic_bottom_offset = 0;
+    if (conformance_window_flag) {
+      pic_left_offset += eg.readUEG();
+      pic_right_offset += eg.readUEG();
+      pic_top_offset += eg.readUEG();
+      pic_bottom_offset += eg.readUEG();
+    }
+    const bit_depth_luma_minus8 = eg.readUEG();
+    const bit_depth_chroma_minus8 = eg.readUEG();
+    const log2_max_pic_order_cnt_lsb_minus4 = eg.readUEG();
+    const sub_layer_ordering_info_present_flag = eg.readBoolean();
+    for (let i = sub_layer_ordering_info_present_flag ? 0 : max_sub_layers_minus1; i <= max_sub_layers_minus1; i++) {
+      eg.skipUEG(); // max_dec_pic_buffering_minus1[i]
+      eg.skipUEG(); // max_num_reorder_pics[i]
+      eg.skipUEG(); // max_latency_increase_plus1[i]
+    }
+    eg.skipUEG(); // log2_min_luma_coding_block_size_minus3
+    eg.skipUEG(); // log2_diff_max_min_luma_coding_block_size
+    eg.skipUEG(); // log2_min_transform_block_size_minus2
+    eg.skipUEG(); // log2_diff_max_min_transform_block_size
+    eg.skipUEG(); // max_transform_hierarchy_depth_inter
+    eg.skipUEG(); // max_transform_hierarchy_depth_intra
+    const scaling_list_enabled_flag = eg.readBoolean();
+    if (scaling_list_enabled_flag) {
+      const sps_scaling_list_data_present_flag = eg.readBoolean();
+      if (sps_scaling_list_data_present_flag) {
+        for (let sizeId = 0; sizeId < 4; sizeId++) {
+          for (let matrixId = 0; matrixId < (sizeId === 3 ? 2 : 6); matrixId++) {
+            const scaling_list_pred_mode_flag = eg.readBoolean();
+            if (!scaling_list_pred_mode_flag) {
+              eg.readUEG(); // scaling_list_pred_matrix_id_delta
+            } else {
+              const coefNum = Math.min(64, 1 << 4 + (sizeId << 1));
+              if (sizeId > 1) {
+                eg.readEG();
+              }
+              for (let i = 0; i < coefNum; i++) {
+                eg.readEG();
+              }
             }
           }
         }
-        // check if we can read unit type
-        if (i < len) {
-          unitType = array[i] & 0x1f;
-          // logger.log('find NALU @ offset:' + i + ',type:' + unitType);
-          lastUnitStart = i;
-          lastUnitType = unitType;
-          state = 0;
-        } else {
-          // not enough byte to read unit type. let's read it on next PES parsing
-          state = -1;
+      }
+    }
+    eg.readBoolean(); // amp_enabled_flag
+    eg.readBoolean(); // sample_adaptive_offset_enabled_flag
+    const pcm_enabled_flag = eg.readBoolean();
+    if (pcm_enabled_flag) {
+      eg.readUByte();
+      eg.skipUEG();
+      eg.skipUEG();
+      eg.readBoolean();
+    }
+    const num_short_term_ref_pic_sets = eg.readUEG();
+    let num_delta_pocs = 0;
+    for (let i = 0; i < num_short_term_ref_pic_sets; i++) {
+      let inter_ref_pic_set_prediction_flag = false;
+      if (i !== 0) {
+        inter_ref_pic_set_prediction_flag = eg.readBoolean();
+      }
+      if (inter_ref_pic_set_prediction_flag) {
+        if (i === num_short_term_ref_pic_sets) {
+          eg.readUEG();
+        }
+        eg.readBoolean();
+        eg.readUEG();
+        let next_num_delta_pocs = 0;
+        for (let j = 0; j <= num_delta_pocs; j++) {
+          const used_by_curr_pic_flag = eg.readBoolean();
+          let use_delta_flag = false;
+          if (!used_by_curr_pic_flag) {
+            use_delta_flag = eg.readBoolean();
+          }
+          if (used_by_curr_pic_flag || use_delta_flag) {
+            next_num_delta_pocs++;
+          }
         }
+        num_delta_pocs = next_num_delta_pocs;
       } else {
-        state = 0;
+        const num_negative_pics = eg.readUEG();
+        const num_positive_pics = eg.readUEG();
+        num_delta_pocs = num_negative_pics + num_positive_pics;
+        for (let j = 0; j < num_negative_pics; j++) {
+          eg.readUEG();
+          eg.readBoolean();
+        }
+        for (let j = 0; j < num_positive_pics; j++) {
+          eg.readUEG();
+          eg.readBoolean();
+        }
       }
     }
-    if (lastUnitStart >= 0 && state >= 0) {
-      const unit = {
-        data: array.subarray(lastUnitStart, len),
-        type: lastUnitType,
-        state: state
-      };
-      units.push(unit);
-      // logger.log('pushing NALU, type/size/state:' + unit.type + '/' + unit.data.byteLength + '/' + state);
-    }
-    // no NALu found
-    if (units.length === 0) {
-      // append pes.data to previous NAL unit
-      const lastUnit = this.getLastNalUnit(track.samples);
-      if (lastUnit) {
-        lastUnit.data = appendUint8Array(lastUnit.data, array);
+    const long_term_ref_pics_present_flag = eg.readBoolean();
+    if (long_term_ref_pics_present_flag) {
+      const num_long_term_ref_pics_sps = eg.readUEG();
+      for (let i = 0; i < num_long_term_ref_pics_sps; i++) {
+        for (let j = 0; j < log2_max_pic_order_cnt_lsb_minus4 + 4; j++) {
+          eg.readBits(1);
+        }
+        eg.readBits(1);
+      }
+    }
+    let min_spatial_segmentation_idc = 0;
+    let sar_width = 1,
+      sar_height = 1;
+    let fps_fixed = true,
+      fps_den = 1,
+      fps_num = 0;
+    eg.readBoolean(); // sps_temporal_mvp_enabled_flag
+    eg.readBoolean(); // strong_intra_smoothing_enabled_flag
+    let default_display_window_flag = false;
+    const vui_parameters_present_flag = eg.readBoolean();
+    if (vui_parameters_present_flag) {
+      const aspect_ratio_info_present_flag = eg.readBoolean();
+      if (aspect_ratio_info_present_flag) {
+        const aspect_ratio_idc = eg.readUByte();
+        const sar_width_table = [1, 12, 10, 16, 40, 24, 20, 32, 80, 18, 15, 64, 160, 4, 3, 2];
+        const sar_height_table = [1, 11, 11, 11, 33, 11, 11, 11, 33, 11, 11, 33, 99, 3, 2, 1];
+        if (aspect_ratio_idc > 0 && aspect_ratio_idc < 16) {
+          sar_width = sar_width_table[aspect_ratio_idc - 1];
+          sar_height = sar_height_table[aspect_ratio_idc - 1];
+        } else if (aspect_ratio_idc === 255) {
+          sar_width = eg.readBits(16);
+          sar_height = eg.readBits(16);
+        }
       }
+      const overscan_info_present_flag = eg.readBoolean();
+      if (overscan_info_present_flag) {
+        eg.readBoolean();
+      }
+      const video_signal_type_present_flag = eg.readBoolean();
+      if (video_signal_type_present_flag) {
+        eg.readBits(3);
+        eg.readBoolean();
+        const colour_description_present_flag = eg.readBoolean();
+        if (colour_description_present_flag) {
+          eg.readUByte();
+          eg.readUByte();
+          eg.readUByte();
+        }
+      }
+      const chroma_loc_info_present_flag = eg.readBoolean();
+      if (chroma_loc_info_present_flag) {
+        eg.readUEG();
+        eg.readUEG();
+      }
+      eg.readBoolean(); // neutral_chroma_indication_flag
+      eg.readBoolean(); // field_seq_flag
+      eg.readBoolean(); // frame_field_info_present_flag
+      default_display_window_flag = eg.readBoolean();
+      if (default_display_window_flag) {
+        pic_left_offset += eg.readUEG();
+        pic_right_offset += eg.readUEG();
+        pic_top_offset += eg.readUEG();
+        pic_bottom_offset += eg.readUEG();
+      }
+      const vui_timing_info_present_flag = eg.readBoolean();
+      if (vui_timing_info_present_flag) {
+        fps_den = eg.readBits(32);
+        fps_num = eg.readBits(32);
+        const vui_poc_proportional_to_timing_flag = eg.readBoolean();
+        if (vui_poc_proportional_to_timing_flag) {
+          eg.readUEG();
+        }
+        const vui_hrd_parameters_present_flag = eg.readBoolean();
+        if (vui_hrd_parameters_present_flag) {
+          //const commonInfPresentFlag = true;
+          //if (commonInfPresentFlag) {
+          const nal_hrd_parameters_present_flag = eg.readBoolean();
+          const vcl_hrd_parameters_present_flag = eg.readBoolean();
+          let sub_pic_hrd_params_present_flag = false;
+          if (nal_hrd_parameters_present_flag || vcl_hrd_parameters_present_flag) {
+            sub_pic_hrd_params_present_flag = eg.readBoolean();
+            if (sub_pic_hrd_params_present_flag) {
+              eg.readUByte();
+              eg.readBits(5);
+              eg.readBoolean();
+              eg.readBits(5);
+            }
+            eg.readBits(4); // bit_rate_scale
+            eg.readBits(4); // cpb_size_scale
+            if (sub_pic_hrd_params_present_flag) {
+              eg.readBits(4);
+            }
+            eg.readBits(5);
+            eg.readBits(5);
+            eg.readBits(5);
+          }
+          //}
+          for (let i = 0; i <= max_sub_layers_minus1; i++) {
+            fps_fixed = eg.readBoolean(); // fixed_pic_rate_general_flag
+            const fixed_pic_rate_within_cvs_flag = fps_fixed || eg.readBoolean();
+            let low_delay_hrd_flag = false;
+            if (fixed_pic_rate_within_cvs_flag) {
+              eg.readEG();
+            } else {
+              low_delay_hrd_flag = eg.readBoolean();
+            }
+            const cpb_cnt = low_delay_hrd_flag ? 1 : eg.readUEG() + 1;
+            if (nal_hrd_parameters_present_flag) {
+              for (let j = 0; j < cpb_cnt; j++) {
+                eg.readUEG();
+                eg.readUEG();
+                if (sub_pic_hrd_params_present_flag) {
+                  eg.readUEG();
+                  eg.readUEG();
+                }
+                eg.skipBits(1);
+              }
+            }
+            if (vcl_hrd_parameters_present_flag) {
+              for (let j = 0; j < cpb_cnt; j++) {
+                eg.readUEG();
+                eg.readUEG();
+                if (sub_pic_hrd_params_present_flag) {
+                  eg.readUEG();
+                  eg.readUEG();
+                }
+                eg.skipBits(1);
+              }
+            }
+          }
+        }
+      }
+      const bitstream_restriction_flag = eg.readBoolean();
+      if (bitstream_restriction_flag) {
+        eg.readBoolean(); // tiles_fixed_structure_flag
+        eg.readBoolean(); // motion_vectors_over_pic_boundaries_flag
+        eg.readBoolean(); // restricted_ref_pic_lists_flag
+        min_spatial_segmentation_idc = eg.readUEG();
+      }
+    }
+    let width = pic_width_in_luma_samples,
+      height = pic_height_in_luma_samples;
+    if (conformance_window_flag || default_display_window_flag) {
+      let chroma_scale_w = 1,
+        chroma_scale_h = 1;
+      if (chroma_format_idc === 1) {
+        // YUV 420
+        chroma_scale_w = chroma_scale_h = 2;
+      } else if (chroma_format_idc == 2) {
+        // YUV 422
+        chroma_scale_w = 2;
+      }
+      width = pic_width_in_luma_samples - chroma_scale_w * pic_right_offset - chroma_scale_w * pic_left_offset;
+      height = pic_height_in_luma_samples - chroma_scale_h * pic_bottom_offset - chroma_scale_h * pic_top_offset;
+    }
+    const profile_space_string = general_profile_space ? ['A', 'B', 'C'][general_profile_space] : '';
+    const profile_compatibility_buf = general_profile_compatibility_flags_1 << 24 | general_profile_compatibility_flags_2 << 16 | general_profile_compatibility_flags_3 << 8 | general_profile_compatibility_flags_4;
+    let profile_compatibility_rev = 0;
+    for (let i = 0; i < 32; i++) {
+      profile_compatibility_rev = (profile_compatibility_rev | (profile_compatibility_buf >> i & 1) << 31 - i) >>> 0; // reverse bit position (and cast as UInt32)
+    }
+    let profile_compatibility_flags_string = profile_compatibility_rev.toString(16);
+    if (general_profile_idc === 1 && profile_compatibility_flags_string === '2') {
+      profile_compatibility_flags_string = '6';
+    }
+    const tier_flag_string = general_tier_flag ? 'H' : 'L';
+    return {
+      codecString: `hvc1.${profile_space_string}${general_profile_idc}.${profile_compatibility_flags_string}.${tier_flag_string}${general_level_idc}.B0`,
+      params: {
+        general_tier_flag,
+        general_profile_idc,
+        general_profile_space,
+        general_profile_compatibility_flags: [general_profile_compatibility_flags_1, general_profile_compatibility_flags_2, general_profile_compatibility_flags_3, general_profile_compatibility_flags_4],
+        general_constraint_indicator_flags: [general_constraint_indicator_flags_1, general_constraint_indicator_flags_2, general_constraint_indicator_flags_3, general_constraint_indicator_flags_4, general_constraint_indicator_flags_5, general_constraint_indicator_flags_6],
+        general_level_idc,
+        bit_depth: bit_depth_luma_minus8 + 8,
+        bit_depth_luma_minus8,
+        bit_depth_chroma_minus8,
+        min_spatial_segmentation_idc,
+        chroma_format_idc: chroma_format_idc,
+        frame_rate: {
+          fixed: fps_fixed,
+          fps: fps_num / fps_den
+        }
+      },
+      width,
+      height,
+      pixelRatio: [sar_width, sar_height]
+    };
+  }
+  readPPS(pps) {
+    const eg = new ExpGolomb(this.ebsp2rbsp(pps));
+    eg.readUByte();
+    eg.readUByte();
+    eg.skipUEG(); // pic_parameter_set_id
+    eg.skipUEG(); // seq_parameter_set_id
+    eg.skipBits(2); // dependent_slice_segments_enabled_flag, output_flag_present_flag
+    eg.skipBits(3); // num_extra_slice_header_bits
+    eg.skipBits(2); // sign_data_hiding_enabled_flag, cabac_init_present_flag
+    eg.skipUEG();
+    eg.skipUEG();
+    eg.skipEG(); // init_qp_minus26
+    eg.skipBits(2); // constrained_intra_pred_flag, transform_skip_enabled_flag
+    const cu_qp_delta_enabled_flag = eg.readBoolean();
+    if (cu_qp_delta_enabled_flag) {
+      eg.skipUEG();
+    }
+    eg.skipEG(); // cb_qp_offset
+    eg.skipEG(); // cr_qp_offset
+    eg.skipBits(4); // pps_slice_chroma_qp_offsets_present_flag, weighted_pred_flag, weighted_bipred_flag, transquant_bypass_enabled_flag
+    const tiles_enabled_flag = eg.readBoolean();
+    const entropy_coding_sync_enabled_flag = eg.readBoolean();
+    let parallelismType = 1; // slice-based parallel decoding
+    if (entropy_coding_sync_enabled_flag && tiles_enabled_flag) {
+      parallelismType = 0; // mixed-type parallel decoding
+    } else if (entropy_coding_sync_enabled_flag) {
+      parallelismType = 3; // wavefront-based parallel decoding
+    } else if (tiles_enabled_flag) {
+      parallelismType = 2; // tile-based parallel decoding
     }
-    track.naluState = state;
-    return units;
+    return {
+      parallelismType
+    };
+  }
+  matchSPS(sps1, sps2) {
+    // compare without headers and VPS related params
+    return String.fromCharCode.apply(null, sps1).substr(3) === String.fromCharCode.apply(null, sps2).substr(3);
   }
 }
 
@@ -14765,7 +15369,7 @@ class TSDemuxer {
     this.observer = observer;
     this.config = config;
     this.typeSupported = typeSupported;
-    this.videoParser = new AvcVideoParser();
+    this.videoParser = null;
   }
   static probe(data) {
     const syncOffset = TSDemuxer.syncOffset(data);
@@ -14930,7 +15534,19 @@ class TSDemuxer {
           case videoPid:
             if (stt) {
               if (videoData && (pes = parsePES(videoData))) {
-                this.videoParser.parseAVCPES(videoTrack, textTrack, pes, false, this._duration);
+                if (this.videoParser === null) {
+                  switch (videoTrack.segmentCodec) {
+                    case 'avc':
+                      this.videoParser = new AvcVideoParser();
+                      break;
+                    case 'hevc':
+                      this.videoParser = new HevcVideoParser();
+                      break;
+                  }
+                }
+                if (this.videoParser !== null) {
+                  this.videoParser.parsePES(videoTrack, textTrack, pes, false, this._duration);
+                }
               }
               videoData = {
                 data: [],
@@ -15092,8 +15708,20 @@ class TSDemuxer {
     // try to parse last PES packets
     let pes;
     if (videoData && (pes = parsePES(videoData))) {
-      this.videoParser.parseAVCPES(videoTrack, textTrack, pes, true, this._duration);
-      videoTrack.pesData = null;
+      if (this.videoParser === null) {
+        switch (videoTrack.segmentCodec) {
+          case 'avc':
+            this.videoParser = new AvcVideoParser();
+            break;
+          case 'hevc':
+            this.videoParser = new HevcVideoParser();
+            break;
+        }
+      }
+      if (this.videoParser !== null) {
+        this.videoParser.parsePES(videoTrack, textTrack, pes, true, this._duration);
+        videoTrack.pesData = null;
+      }
     } else {
       // either avcData null or PES truncated, keep it for next frag parsing
       videoTrack.pesData = videoData;
@@ -15396,7 +16024,12 @@ function parsePMT(data, offset, typeSupported, isSampleAes) {
         logger.warn('Unsupported EC-3 in M2TS found');
         break;
       case 0x24:
-        logger.warn('Unsupported HEVC in M2TS found');
+        // ITU-T Rec. H.265 and ISO/IEC 23008-2 (HEVC)
+        if (result.videoPid === -1) {
+          result.videoPid = pid;
+          result.segmentVideoCodec = 'hevc';
+          logger.log('HEVC in M2TS found');
+        }
         break;
     }
     // move to the next table entry
@@ -15619,6 +16252,8 @@ class MP4 {
       avc1: [],
       // codingname
       avcC: [],
+      hvc1: [],
+      hvcC: [],
       btrt: [],
       dinf: [],
       dref: [],
@@ -16043,8 +16678,10 @@ 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 {
+    } 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));
     }
   }
   static tkhd(track) {
@@ -16182,6 +16819,84 @@ 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])));
+  }
 }
 MP4.types = void 0;
 MP4.HDLR_TYPES = void 0;
@@ -16557,9 +17272,9 @@ class MP4Remuxer {
       const foundOverlap = delta < -1;
       if (foundHole || foundOverlap) {
         if (foundHole) {
-          logger.warn(`AVC: ${toMsFromMpegTsClock(delta, true)} ms (${delta}dts) hole between fragments detected at ${timeOffset.toFixed(3)}`);
+          logger.warn(`${(track.segmentCodec || '').toUpperCase()}: ${toMsFromMpegTsClock(delta, true)} ms (${delta}dts) hole between fragments detected at ${timeOffset.toFixed(3)}`);
         } else {
-          logger.warn(`AVC: ${toMsFromMpegTsClock(-delta, true)} ms (${delta}dts) overlapping between fragments detected at ${timeOffset.toFixed(3)}`);
+          logger.warn(`${(track.segmentCodec || '').toUpperCase()}: ${toMsFromMpegTsClock(-delta, true)} ms (${delta}dts) overlapping between fragments detected at ${timeOffset.toFixed(3)}`);
         }
         if (!foundOverlap || nextAvcDts >= inputSamples[0].pts || chromeVersion) {
           firstDTS = nextAvcDts;
@@ -16733,7 +17448,7 @@ class MP4Remuxer {
         }
       }
     }
-    // next AVC sample DTS should be equal to last sample DTS + last sample duration (in PES timescale)
+    // next AVC/HEVC sample DTS should be equal to last sample DTS + last sample duration (in PES timescale)
     mp4SampleDuration = stretchedLastFrame || !mp4SampleDuration ? averageSampleDuration : mp4SampleDuration;
     this.nextAvcDts = nextAvcDts = lastDTS + mp4SampleDuration;
     this.videoSampleDuration = mp4SampleDuration;
@@ -18849,7 +19564,7 @@ class StreamController extends BaseStreamController {
     if (this.altAudio && this.audioOnly) {
       return;
     }
-    if (!(levels != null && levels[level])) {
+    if (!this.buffering || !(levels != null && levels[level])) {
       return;
     }
     const levelInfo = levels[level];
@@ -19809,7 +20524,7 @@ class Hls {
    * Get the video-dev/hls.js package version.
    */
   static get version() {
-    return "1.5.2-0.canary.9969";
+    return "1.5.2-0.canary.9971";
   }
 
   /**
@@ -19878,7 +20593,6 @@ class Hls {
     this.logger = void 0;
     this.coreComponents = void 0;
     this.networkControllers = void 0;
-    this.started = false;
     this._emitter = new EventEmitter();
     this._autoLevelCapping = -1;
     this._maxHdcpLevel = null;
@@ -20093,7 +20807,6 @@ class Hls {
    */
   startLoad(startPosition = -1) {
     this.logger.log(`startLoad(${startPosition})`);
-    this.started = true;
     this.networkControllers.forEach(controller => {
       controller.startLoad(startPosition);
     });
@@ -20104,33 +20817,30 @@ class Hls {
    */
   stopLoad() {
     this.logger.log('stopLoad');
-    this.started = false;
     this.networkControllers.forEach(controller => {
       controller.stopLoad();
     });
   }
 
   /**
-   * Resumes stream controller segment loading if previously started.
+   * Resumes stream controller segment loading after `pauseBuffering` has been called.
    */
   resumeBuffering() {
-    if (this.started) {
-      this.networkControllers.forEach(controller => {
-        if ('fragmentLoader' in controller) {
-          controller.startLoad(-1);
-        }
-      });
-    }
+    this.networkControllers.forEach(controller => {
+      if (controller.resumeBuffering) {
+        controller.resumeBuffering();
+      }
+    });
   }
 
   /**
-   * Stops stream controller segment loading without changing 'started' state like stopLoad().
+   * Prevents stream controller from loading new segments until `resumeBuffering` is called.
    * This allows for media buffering to be paused without interupting playlist loading.
    */
   pauseBuffering() {
     this.networkControllers.forEach(controller => {
-      if ('fragmentLoader' in controller) {
-        controller.stopLoad();
+      if (controller.pauseBuffering) {
+        controller.pauseBuffering();
       }
     });
   }