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

package/dist/hls.light.js

@@ -525,7 +525,7 @@
       // 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.9970");
+        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();
@@ -14390,6 +14390,110 @@
         logger.log(VideoSample.pts + '/' + VideoSample.dts + ':' + VideoSample.debug);
       }
     };
+    _proto.parseNALu = function parseNALu(track, array) {
+      var len = array.byteLength;
+      var state = track.naluState || 0;
+      var lastState = state;
+      var units = [];
+      var i = 0;
+      var value;
+      var overflow;
+      var unitType;
+      var lastUnitStart = -1;
+      var 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) {
+            var 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)
+            var 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) {
+        var _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
+        var _lastUnit = this.getLastNalUnit(track.samples);
+        if (_lastUnit) {
+          _lastUnit.data = appendUint8Array(_lastUnit.data, array);
+        }
+      }
+      track.naluState = state;
+      return units;
+    };
     return BaseVideoParser;
   }();
 
@@ -14544,22 +14648,179 @@
     ;
     _proto.readUInt = function readUInt() {
       return this.readBits(32);
+    };
+    return ExpGolomb;
+  }();
+
+  var AvcVideoParser = /*#__PURE__*/function (_BaseVideoParser) {
+    _inheritsLoose(AvcVideoParser, _BaseVideoParser);
+    function AvcVideoParser() {
+      return _BaseVideoParser.apply(this, arguments) || this;
+    }
+    var _proto = AvcVideoParser.prototype;
+    _proto.parsePES = function parsePES(track, textTrack, pes, last, duration) {
+      var _this = this;
+      var units = this.parseNALu(track, pes.data);
+      var VideoSample = this.VideoSample;
+      var push;
+      var 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(function (unit) {
+        var _VideoSample2;
+        switch (unit.type) {
+          // NDR
+          case 1:
+            {
+              var iskey = false;
+              push = true;
+              var 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
+                var 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;
+              var sps = unit.data;
+              var 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;
+                var codecarray = sps.subarray(1, 4);
+                var codecstring = 'avc1.';
+                for (var i = 0; i < 3; i++) {
+                  var 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) {
+          var _units = VideoSample.units;
+          _units.push(unit);
+        }
+      });
+      // if last PES packet, push samples
+      if (last && VideoSample) {
+        this.pushAccessUnit(VideoSample, track);
+        this.VideoSample = null;
+      }
+    };
+    _proto.getNALuType = function getNALuType(data, offset) {
+      return data[offset] & 0x1f;
+    };
+    _proto.readSliceType = function readSliceType(data) {
+      var 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
      */;
-    _proto.skipScalingList = function skipScalingList(count) {
+    _proto.skipScalingList = function skipScalingList(count, reader) {
       var lastScale = 8;
       var nextScale = 8;
       var deltaScale;
       for (var j = 0; j < count; j++) {
         if (nextScale !== 0) {
-          deltaScale = this.readEG();
+          deltaScale = reader.readEG();
           nextScale = (lastScale + deltaScale + 256) % 256;
         }
         lastScale = nextScale === 0 ? lastScale : nextScale;
@@ -14574,7 +14835,8 @@
      * sequence parameter set, including the dimensions of the
      * associated video frames.
      */;
-    _proto.readSPS = function readSPS() {
+    _proto.readSPS = function readSPS(sps) {
+      var eg = new ExpGolomb(sps);
       var frameCropLeftOffset = 0;
       var frameCropRightOffset = 0;
       var frameCropTopOffset = 0;
@@ -14582,13 +14844,13 @@
       var numRefFramesInPicOrderCntCycle;
       var scalingListCount;
       var i;
-      var readUByte = this.readUByte.bind(this);
-      var readBits = this.readBits.bind(this);
-      var readUEG = this.readUEG.bind(this);
-      var readBoolean = this.readBoolean.bind(this);
-      var skipBits = this.skipBits.bind(this);
-      var skipEG = this.skipEG.bind(this);
-      var skipUEG = this.skipUEG.bind(this);
+      var readUByte = eg.readUByte.bind(eg);
+      var readBits = eg.readBits.bind(eg);
+      var readUEG = eg.readUEG.bind(eg);
+      var readBoolean = eg.readBoolean.bind(eg);
+      var skipBits = eg.skipBits.bind(eg);
+      var skipEG = eg.skipEG.bind(eg);
+      var skipUEG = eg.skipUEG.bind(eg);
       var skipScalingList = this.skipScalingList.bind(this);
       readUByte();
       var profileIdc = readUByte(); // profile_idc
@@ -14613,9 +14875,9 @@
             if (readBoolean()) {
               // seq_scaling_list_present_flag[ i ]
               if (i < 6) {
-                skipScalingList(16);
+                skipScalingList(16, eg);
               } else {
-                skipScalingList(64);
+                skipScalingList(64, eg);
               }
             }
           }
@@ -14720,26 +14982,24 @@
         pixelRatio: pixelRatio
       };
     };
-    _proto.readSliceType = function readSliceType() {
-      // skip NALu type
-      this.readUByte();
-      // discard first_mb_in_slice
-      this.readUEG();
-      // return slice_type
-      return this.readUEG();
-    };
-    return ExpGolomb;
-  }();
+    return AvcVideoParser;
+  }(BaseVideoParser);
 
-  var AvcVideoParser = /*#__PURE__*/function (_BaseVideoParser) {
-    _inheritsLoose(AvcVideoParser, _BaseVideoParser);
-    function AvcVideoParser() {
-      return _BaseVideoParser.apply(this, arguments) || this;
+  var HevcVideoParser = /*#__PURE__*/function (_BaseVideoParser) {
+    _inheritsLoose(HevcVideoParser, _BaseVideoParser);
+    function HevcVideoParser() {
+      var _this;
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      _this = _BaseVideoParser.call.apply(_BaseVideoParser, [this].concat(args)) || this;
+      _this.initVPS = null;
+      return _this;
     }
-    var _proto = AvcVideoParser.prototype;
-    _proto.parseAVCPES = function parseAVCPES(track, textTrack, pes, last, duration) {
-      var _this = this;
-      var units = this.parseAVCNALu(track, pes.data);
+    var _proto = HevcVideoParser.prototype;
+    _proto.parsePES = function parsePES(track, textTrack, pes, last, duration) {
+      var _this2 = this;
+      var units = this.parseNALu(track, pes.data);
       var VideoSample = this.VideoSample;
       var push;
       var spsfound = false;
@@ -14755,112 +15015,143 @@
       units.forEach(function (unit) {
         var _VideoSample2;
         switch (unit.type) {
-          // NDR
+          // NON-IDR, NON RANDOM ACCESS SLICE
+          case 0:
           case 1:
-            {
-              var iskey = false;
-              push = true;
-              var 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
-                var 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 = _this2.VideoSample = _this2.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) {
+                _this2.pushAccessUnit(VideoSample, track);
+                VideoSample = _this2.VideoSample = null;
               }
-              VideoSample.frame = true;
-              VideoSample.key = iskey;
-              break;
-              // IDR
             }
-          case 5:
+            if (!VideoSample) {
+              VideoSample = _this2.VideoSample = _this2.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
             if ((_VideoSample2 = VideoSample) != null && _VideoSample2.frame && !VideoSample.key) {
-              _this.pushAccessUnit(VideoSample, track);
-              VideoSample = _this.VideoSample = null;
+              _this2.pushAccessUnit(VideoSample, track);
+              VideoSample = _this2.VideoSample = null;
             }
             if (!VideoSample) {
-              VideoSample = _this.VideoSample = _this.createVideoSample(true, pes.pts, pes.dts, '');
+              VideoSample = _this2.VideoSample = _this2.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 39:
+            push = true;
+            parseSEIMessageFromNALu(unit.data, 2,
+            // NALu header size
+            pes.pts, textTrack.samples);
+            break;
+
+          // VPS
+          case 32:
+            push = true;
+            if (!track.vps) {
+              var config = _this2.readVPS(unit.data);
+              track.params = _objectSpread2({}, config);
+              _this2.initVPS = unit.data;
             }
-          case 7:
-            {
-              var _track$pixelRatio, _track$pixelRatio2;
-              push = true;
-              spsfound = true;
-              var sps = unit.data;
-              var expGolombDecoder = new ExpGolomb(sps);
-              var 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.width = config.width;
-                track.height = config.height;
-                track.pixelRatio = config.pixelRatio;
-                track.sps = [sps];
+            track.vps = [unit.data];
+            break;
+
+          // SPS
+          case 33:
+            push = true;
+            spsfound = true;
+            if (typeof track.params === 'object') {
+              if (track.vps !== undefined && track.vps[0] !== _this2.initVPS && track.sps !== undefined && !_this2.matchSPS(track.sps[0], unit.data)) {
+                _this2.initVPS = track.vps[0];
+                track.sps = track.pps = undefined;
+              }
+              if (!track.sps) {
+                var _config = _this2.readSPS(unit.data);
+                track.width = _config.width;
+                track.height = _config.height;
+                track.pixelRatio = _config.pixelRatio;
                 track.duration = duration;
-                var codecarray = sps.subarray(1, 4);
-                var codecstring = 'avc1.';
-                for (var i = 0; i < 3; i++) {
-                  var h = codecarray[i].toString(16);
-                  if (h.length < 2) {
-                    h = '0' + h;
-                  }
-                  codecstring += h;
+                track.codec = _config.codecString;
+                track.sps = [];
+                for (var prop in _config.params) {
+                  track.params[prop] = _config.params[prop];
                 }
-                track.codec = codecstring;
               }
-              break;
+              if (track.vps !== undefined && track.vps[0] === _this2.initVPS) {
+                track.sps.push(unit.data);
+              }
+            }
+            if (!VideoSample) {
+              VideoSample = _this2.VideoSample = _this2.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 = [];
+                var _config2 = _this2.readPPS(unit.data);
+                for (var _prop in _config2) {
+                  track.params[_prop] = _config2[_prop];
+                }
+              }
+              if (_this2.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) {
-              _this.pushAccessUnit(VideoSample, track);
+              _this2.pushAccessUnit(VideoSample, track);
             }
-            VideoSample = _this.VideoSample = _this.createVideoSample(false, pes.pts, pes.dts, '');
-            break;
-          // Filler Data
-          case 12:
-            push = true;
+            VideoSample = _this2.VideoSample = _this2.createVideoSample(false, pes.pts, pes.dts, '');
             break;
           default:
             push = false;
             if (VideoSample) {
-              VideoSample.debug += 'unknown NAL ' + unit.type + ' ';
+              VideoSample.debug += 'unknown or irrelevant NAL ' + unit.type + ' ';
             }
             break;
         }
@@ -14875,111 +15166,425 @@
         this.VideoSample = null;
       }
     };
-    _proto.parseAVCNALu = function parseAVCNALu(track, array) {
-      var len = array.byteLength;
-      var state = track.naluState || 0;
-      var lastState = state;
-      var units = [];
-      var i = 0;
-      var value;
-      var overflow;
-      var unitType;
-      var lastUnitStart = -1;
-      var 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;
+    _proto.getNALuType = function getNALuType(data, offset) {
+      return (data[offset] & 0x7e) >>> 1;
+    };
+    _proto.ebsp2rbsp = function ebsp2rbsp(arr) {
+      var dst = new Uint8Array(arr.byteLength);
+      var dstIdx = 0;
+      for (var 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) {
-            var 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)
-            var 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);
+    };
+    _proto.readVPS = function readVPS(vps) {
+      var 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
+      var max_sub_layers_minus1 = eg.readBits(3);
+      var 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
+      };
+    };
+    _proto.readSPS = function readSPS(sps) {
+      var eg = new ExpGolomb(this.ebsp2rbsp(sps));
+      eg.readUByte();
+      eg.readUByte();
+      eg.readBits(4); //video_parameter_set_id
+      var max_sub_layers_minus1 = eg.readBits(3);
+      eg.readBoolean(); // temporal_id_nesting_flag
+
+      // profile_tier_level
+      var general_profile_space = eg.readBits(2);
+      var general_tier_flag = eg.readBoolean();
+      var general_profile_idc = eg.readBits(5);
+      var general_profile_compatibility_flags_1 = eg.readUByte();
+      var general_profile_compatibility_flags_2 = eg.readUByte();
+      var general_profile_compatibility_flags_3 = eg.readUByte();
+      var general_profile_compatibility_flags_4 = eg.readUByte();
+      var general_constraint_indicator_flags_1 = eg.readUByte();
+      var general_constraint_indicator_flags_2 = eg.readUByte();
+      var general_constraint_indicator_flags_3 = eg.readUByte();
+      var general_constraint_indicator_flags_4 = eg.readUByte();
+      var general_constraint_indicator_flags_5 = eg.readUByte();
+      var general_constraint_indicator_flags_6 = eg.readUByte();
+      var general_level_idc = eg.readUByte();
+      var sub_layer_profile_present_flags = [];
+      var sub_layer_level_present_flags = [];
+      for (var 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 (var _i = max_sub_layers_minus1; _i < 8; _i++) {
+          eg.readBits(2);
+        }
+      }
+      for (var _i2 = 0; _i2 < max_sub_layers_minus1; _i2++) {
+        if (sub_layer_profile_present_flags[_i2]) {
+          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[_i2]) {
+          eg.readUByte();
+        }
+      }
+      eg.readUEG(); // seq_parameter_set_id
+      var chroma_format_idc = eg.readUEG();
+      if (chroma_format_idc == 3) {
+        eg.skipBits(1); //separate_colour_plane_flag
+      }
+      var pic_width_in_luma_samples = eg.readUEG();
+      var pic_height_in_luma_samples = eg.readUEG();
+      var conformance_window_flag = eg.readBoolean();
+      var 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();
+      }
+      var bit_depth_luma_minus8 = eg.readUEG();
+      var bit_depth_chroma_minus8 = eg.readUEG();
+      var log2_max_pic_order_cnt_lsb_minus4 = eg.readUEG();
+      var sub_layer_ordering_info_present_flag = eg.readBoolean();
+      for (var _i3 = sub_layer_ordering_info_present_flag ? 0 : max_sub_layers_minus1; _i3 <= max_sub_layers_minus1; _i3++) {
+        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
+      var scaling_list_enabled_flag = eg.readBoolean();
+      if (scaling_list_enabled_flag) {
+        var sps_scaling_list_data_present_flag = eg.readBoolean();
+        if (sps_scaling_list_data_present_flag) {
+          for (var sizeId = 0; sizeId < 4; sizeId++) {
+            for (var matrixId = 0; matrixId < (sizeId === 3 ? 2 : 6); matrixId++) {
+              var scaling_list_pred_mode_flag = eg.readBoolean();
+              if (!scaling_list_pred_mode_flag) {
+                eg.readUEG(); // scaling_list_pred_matrix_id_delta
+              } else {
+                var coefNum = Math.min(64, 1 << 4 + (sizeId << 1));
+                if (sizeId > 1) {
+                  eg.readEG();
+                }
+                for (var _i4 = 0; _i4 < coefNum; _i4++) {
+                  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
+      var pcm_enabled_flag = eg.readBoolean();
+      if (pcm_enabled_flag) {
+        eg.readUByte();
+        eg.skipUEG();
+        eg.skipUEG();
+        eg.readBoolean();
+      }
+      var num_short_term_ref_pic_sets = eg.readUEG();
+      var num_delta_pocs = 0;
+      for (var _i5 = 0; _i5 < num_short_term_ref_pic_sets; _i5++) {
+        var inter_ref_pic_set_prediction_flag = false;
+        if (_i5 !== 0) {
+          inter_ref_pic_set_prediction_flag = eg.readBoolean();
+        }
+        if (inter_ref_pic_set_prediction_flag) {
+          if (_i5 === num_short_term_ref_pic_sets) {
+            eg.readUEG();
+          }
+          eg.readBoolean();
+          eg.readUEG();
+          var next_num_delta_pocs = 0;
+          for (var j = 0; j <= num_delta_pocs; j++) {
+            var used_by_curr_pic_flag = eg.readBoolean();
+            var 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;
+          var num_negative_pics = eg.readUEG();
+          var num_positive_pics = eg.readUEG();
+          num_delta_pocs = num_negative_pics + num_positive_pics;
+          for (var _j = 0; _j < num_negative_pics; _j++) {
+            eg.readUEG();
+            eg.readBoolean();
+          }
+          for (var _j2 = 0; _j2 < num_positive_pics; _j2++) {
+            eg.readUEG();
+            eg.readBoolean();
+          }
         }
       }
-      if (lastUnitStart >= 0 && state >= 0) {
-        var _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
-        var _lastUnit = this.getLastNalUnit(track.samples);
-        if (_lastUnit) {
-          _lastUnit.data = appendUint8Array(_lastUnit.data, array);
+      var long_term_ref_pics_present_flag = eg.readBoolean();
+      if (long_term_ref_pics_present_flag) {
+        var num_long_term_ref_pics_sps = eg.readUEG();
+        for (var _i6 = 0; _i6 < num_long_term_ref_pics_sps; _i6++) {
+          for (var _j3 = 0; _j3 < log2_max_pic_order_cnt_lsb_minus4 + 4; _j3++) {
+            eg.readBits(1);
+          }
+          eg.readBits(1);
+        }
+      }
+      var min_spatial_segmentation_idc = 0;
+      var sar_width = 1,
+        sar_height = 1;
+      var fps_fixed = true,
+        fps_den = 1,
+        fps_num = 0;
+      eg.readBoolean(); // sps_temporal_mvp_enabled_flag
+      eg.readBoolean(); // strong_intra_smoothing_enabled_flag
+      var default_display_window_flag = false;
+      var vui_parameters_present_flag = eg.readBoolean();
+      if (vui_parameters_present_flag) {
+        var aspect_ratio_info_present_flag = eg.readBoolean();
+        if (aspect_ratio_info_present_flag) {
+          var aspect_ratio_idc = eg.readUByte();
+          var sar_width_table = [1, 12, 10, 16, 40, 24, 20, 32, 80, 18, 15, 64, 160, 4, 3, 2];
+          var 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);
+          }
+        }
+        var overscan_info_present_flag = eg.readBoolean();
+        if (overscan_info_present_flag) {
+          eg.readBoolean();
+        }
+        var video_signal_type_present_flag = eg.readBoolean();
+        if (video_signal_type_present_flag) {
+          eg.readBits(3);
+          eg.readBoolean();
+          var colour_description_present_flag = eg.readBoolean();
+          if (colour_description_present_flag) {
+            eg.readUByte();
+            eg.readUByte();
+            eg.readUByte();
+          }
+        }
+        var 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();
+        }
+        var vui_timing_info_present_flag = eg.readBoolean();
+        if (vui_timing_info_present_flag) {
+          fps_den = eg.readBits(32);
+          fps_num = eg.readBits(32);
+          var vui_poc_proportional_to_timing_flag = eg.readBoolean();
+          if (vui_poc_proportional_to_timing_flag) {
+            eg.readUEG();
+          }
+          var vui_hrd_parameters_present_flag = eg.readBoolean();
+          if (vui_hrd_parameters_present_flag) {
+            //const commonInfPresentFlag = true;
+            //if (commonInfPresentFlag) {
+            var nal_hrd_parameters_present_flag = eg.readBoolean();
+            var vcl_hrd_parameters_present_flag = eg.readBoolean();
+            var 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 (var _i7 = 0; _i7 <= max_sub_layers_minus1; _i7++) {
+              fps_fixed = eg.readBoolean(); // fixed_pic_rate_general_flag
+              var fixed_pic_rate_within_cvs_flag = fps_fixed || eg.readBoolean();
+              var low_delay_hrd_flag = false;
+              if (fixed_pic_rate_within_cvs_flag) {
+                eg.readEG();
+              } else {
+                low_delay_hrd_flag = eg.readBoolean();
+              }
+              var cpb_cnt = low_delay_hrd_flag ? 1 : eg.readUEG() + 1;
+              if (nal_hrd_parameters_present_flag) {
+                for (var _j4 = 0; _j4 < cpb_cnt; _j4++) {
+                  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 (var _j5 = 0; _j5 < cpb_cnt; _j5++) {
+                  eg.readUEG();
+                  eg.readUEG();
+                  if (sub_pic_hrd_params_present_flag) {
+                    eg.readUEG();
+                    eg.readUEG();
+                  }
+                  eg.skipBits(1);
+                }
+              }
+            }
+          }
         }
+        var 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();
+        }
+      }
+      var width = pic_width_in_luma_samples,
+        height = pic_height_in_luma_samples;
+      if (conformance_window_flag || default_display_window_flag) {
+        var 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;
+      }
+      var profile_space_string = general_profile_space ? ['A', 'B', 'C'][general_profile_space] : '';
+      var 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;
+      var profile_compatibility_rev = 0;
+      for (var _i8 = 0; _i8 < 32; _i8++) {
+        profile_compatibility_rev = (profile_compatibility_rev | (profile_compatibility_buf >> _i8 & 1) << 31 - _i8) >>> 0; // reverse bit position (and cast as UInt32)
+      }
+      var profile_compatibility_flags_string = profile_compatibility_rev.toString(16);
+      if (general_profile_idc === 1 && profile_compatibility_flags_string === '2') {
+        profile_compatibility_flags_string = '6';
+      }
+      var 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_tier_flag,
+          general_profile_idc: general_profile_idc,
+          general_profile_space: 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: general_level_idc,
+          bit_depth: bit_depth_luma_minus8 + 8,
+          bit_depth_luma_minus8: bit_depth_luma_minus8,
+          bit_depth_chroma_minus8: bit_depth_chroma_minus8,
+          min_spatial_segmentation_idc: min_spatial_segmentation_idc,
+          chroma_format_idc: chroma_format_idc,
+          frame_rate: {
+            fixed: fps_fixed,
+            fps: fps_num / fps_den
+          }
+        },
+        width: width,
+        height: height,
+        pixelRatio: [sar_width, sar_height]
+      };
+    };
+    _proto.readPPS = function readPPS(pps) {
+      var 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
+      var 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
+      var tiles_enabled_flag = eg.readBoolean();
+      var entropy_coding_sync_enabled_flag = eg.readBoolean();
+      var 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: parallelismType
+      };
     };
-    return AvcVideoParser;
+    _proto.matchSPS = function 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);
+    };
+    return HevcVideoParser;
   }(BaseVideoParser);
 
   /**
@@ -15116,7 +15721,7 @@
       this.observer = observer;
       this.config = config;
       this.typeSupported = typeSupported;
-      this.videoParser = new AvcVideoParser();
+      this.videoParser = null;
     }
     TSDemuxer.probe = function probe(data) {
       var syncOffset = TSDemuxer.syncOffset(data);
@@ -15286,7 +15891,19 @@
             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: [],
@@ -15444,8 +16061,20 @@
       // try to parse last PES packets
       var 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;
@@ -15747,7 +16376,12 @@
           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
@@ -15975,6 +16609,8 @@
         avc1: [],
         // codingname
         avcC: [],
+        hvc1: [],
+        hvcC: [],
         btrt: [],
         dinf: [],
         dref: [],
@@ -16402,8 +17038,10 @@
           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));
       }
     };
     MP4.tkhd = function tkhd(track) {
@@ -16541,6 +17179,84 @@
       var result = appendUint8Array(MP4.FTYP, movie);
       return result;
     };
+    MP4.hvc1 = function hvc1(track) {
+      var ps = track.params;
+      var units = [track.vps, track.sps, track.pps];
+      var NALuLengthSize = 4;
+      var 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
+      var length = config.length;
+      for (var i = 0; i < units.length; i += 1) {
+        length += 3;
+        for (var j = 0; j < units[i].length; j += 1) {
+          length += 2 + units[i][j].length;
+        }
+      }
+      var hvcC = new Uint8Array(length);
+      hvcC.set(config, 0);
+      length = config.length;
+      // append parameter set units: one vps, one or more sps and pps
+      var iMax = units.length - 1;
+      for (var _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 (var _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;
+        }
+      }
+      var hvcc = MP4.box(MP4.types.hvcC, hvcC);
+      var width = track.width;
+      var height = track.height;
+      var hSpacing = track.pixelRatio[0];
+      var 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])));
+    };
     return MP4;
   }();
   MP4.types = void 0;
@@ -16927,9 +17643,9 @@
         var 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;
@@ -17103,7 +17819,7 @@
           }
         }
       }
-      // 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;
@@ -21151,7 +21867,7 @@
        * Get the video-dev/hls.js package version.
        */
       function get() {
-        return "1.5.2-0.canary.9970";
+        return "1.5.2-0.canary.9971";
       }
     }, {
       key: "Events",