xgplayer-transmuxer 3.0.0-alpha.2

package/es/codec/hevc.js

@@ -0,0 +1,202 @@
+import _classCallCheck from '@babel/runtime/helpers/classCallCheck';
+import _createClass from '@babel/runtime/helpers/createClass';
+import { NALu } from './nalu.js';
+import { ExpGolomb } from '../utils/exp-golomb.js';
+
+var HEVC = /*#__PURE__*/function () {
+  function HEVC() {
+    _classCallCheck(this, HEVC);
+  }
+
+  _createClass(HEVC, null, [{
+    key: "parseHEVCDecoderConfigurationRecord",
+    value: function parseHEVCDecoderConfigurationRecord(data) {
+      if (data.length < 23) return;
+      var nalUnitSize = (data[21] & 3) + 1;
+      var spsParsed;
+      var spsArr = [];
+      var ppsArr = [];
+      var vpsArr = [];
+      var offset = 23;
+      var numOfArrays = data[22];
+      var nalUnitType;
+      var numNalus;
+      var nalSize;
+
+      for (var i = 0; i < numOfArrays; i++) {
+        nalUnitType = data[offset] & 0x3f;
+        numNalus = data[offset + 1] << 8 | data[offset + 2];
+        offset += 3;
+
+        for (var j = 0; j < numNalus; j++) {
+          nalSize = data[offset] << 8 | data[offset + 1];
+          offset += 2;
+          if (!nalSize) continue;
+
+          switch (nalUnitType) {
+            case 32:
+              vpsArr.push(data.subarray(offset, offset + nalSize));
+              break;
+
+            case 33:
+              {
+                var sps = data.subarray(offset, offset + nalSize);
+                if (!spsParsed) spsParsed = HEVC.parseSPS(NALu.removeEPB(sps));
+                spsArr.push(sps);
+              }
+              break;
+
+            case 34:
+              ppsArr.push(data.subarray(offset, offset + nalSize));
+              break;
+          }
+
+          offset += nalSize;
+        }
+      }
+
+      return {
+        sps: spsParsed,
+        spsArr: spsArr,
+        ppsArr: ppsArr,
+        vpsArr: vpsArr,
+        nalUnitSize: nalUnitSize
+      };
+    }
+  }, {
+    key: "parseSPS",
+    value: function parseSPS(unit) {
+      var eg = new ExpGolomb(unit);
+      eg.readUByte();
+      eg.readUByte();
+      eg.readBits(4);
+      var spsMaxSubLayersMinus1 = eg.readBits(3);
+      eg.readBits(1);
+
+      var tierLevel = this._parseProfileTierLevel(eg, spsMaxSubLayersMinus1);
+
+      eg.readUEG(); // sps_seq_parameter_set_id
+
+      var chromaFormatIdc = eg.readUEG();
+      var chromaFormat = 420;
+      if (chromaFormatIdc <= 3) chromaFormat = [0, 420, 422, 444][chromaFormatIdc];
+      var separateColourPlaneFlag = 0;
+
+      if (chromaFormatIdc === 3) {
+        separateColourPlaneFlag = eg.readBits(1);
+      }
+
+      var width = eg.readUEG(); // pic_width_in_luma_samples
+
+      var height = eg.readUEG(); // pic_height_in_luma_samples
+
+      var conformanceWindowFlag = eg.readBits(1);
+      var confWinLeftOffset;
+      var confWinRightOffset;
+      var confWinTopOffset;
+      var confWinBottomOffset;
+
+      if (conformanceWindowFlag === 1) {
+        confWinLeftOffset = eg.readUEG(); // conf_win_left_offset
+
+        confWinRightOffset = eg.readUEG(); // conf_win_right_offset
+
+        confWinTopOffset = eg.readUEG(); // conf_win_top_offset
+
+        confWinBottomOffset = eg.readUEG(); // conf_win_bottom_offset
+      }
+
+      var bitDepthLumaMinus8 = eg.readUEG(); // bit_depth_luma_minus8
+
+      var bitDepthChromaMinus8 = eg.readUEG(); // bit_depth_chroma_minus8
+
+      if (conformanceWindowFlag === 1) {
+        var subWidthC = (chromaFormatIdc === 1 || chromaFormatIdc === 2) && separateColourPlaneFlag === 0 ? 2 : 1;
+        var subHeightC = chromaFormatIdc === 1 && separateColourPlaneFlag === 0 ? 2 : 1;
+        width -= subWidthC * (confWinRightOffset + confWinLeftOffset);
+        height -= subHeightC * (confWinBottomOffset + confWinTopOffset);
+      }
+
+      return {
+        codec: 'hev1.1.6.L93.B0',
+        width: width,
+        height: height,
+        chromaFormat: chromaFormat,
+        bitDepthLumaMinus8: bitDepthLumaMinus8,
+        bitDepthChromaMinus8: bitDepthChromaMinus8,
+        generalProfileSpace: tierLevel.generalProfileSpace,
+        generalTierFlag: tierLevel.generalTierFlag,
+        generalProfileIdc: tierLevel.generalProfileIdc,
+        generalLevelIdc: tierLevel.generalLevelIdc
+      };
+    }
+  }, {
+    key: "_parseProfileTierLevel",
+    value: function _parseProfileTierLevel(eg, maxSubLayersMinus1) {
+      var profilePresentFlag = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1;
+      var generalProfileSpace;
+      var generalTierFlag;
+      var generalProfileIdc;
+
+      if (profilePresentFlag) {
+        generalProfileSpace = eg.readBits(2);
+        generalTierFlag = eg.readBits(1);
+        generalProfileIdc = eg.readBits(5);
+      }
+
+      eg.readBits(32);
+      eg.readBits(1); // general_progressive_source_flag
+
+      eg.readBits(1); // general_interlaced_source_flag
+
+      eg.readBits(1); // general_non_packed_constraint_flag
+
+      eg.readBits(1); // general_frame_only_constraint_flag
+
+      eg.readBits(16);
+      eg.readBits(16);
+      eg.readBits(12);
+      var generalLevelIdc = eg.readUByte();
+      var subLayerProfilePresentFlag = [];
+      var subLayerLevelPresentFlag = [];
+
+      for (var j = 0; j < maxSubLayersMinus1; j++) {
+        subLayerProfilePresentFlag[j] = eg.readBits(1);
+        subLayerLevelPresentFlag[j] = eg.readBits(1);
+      }
+
+      if (maxSubLayersMinus1 > 0) {
+        eg.readBits((8 - maxSubLayersMinus1) * 2);
+      }
+
+      for (var i = 0; i < maxSubLayersMinus1; i++) {
+        if (subLayerProfilePresentFlag[i] !== 0) {
+          eg.readBits(2);
+          eg.readBits(1);
+          eg.readBits(5);
+          eg.readBits(16);
+          eg.readBits(16);
+          eg.readBits(4);
+          eg.readBits(16);
+          eg.readBits(16);
+          eg.readBits(12);
+        }
+
+        if (subLayerLevelPresentFlag[i] !== 0) {
+          eg.readBits(8);
+        }
+      }
+
+      return {
+        generalProfileSpace: generalProfileSpace,
+        generalTierFlag: generalTierFlag,
+        generalProfileIdc: generalProfileIdc,
+        generalLevelIdc: generalLevelIdc
+      };
+    }
+  }]);
+
+  return HEVC;
+}();
+
+export { HEVC };

package/es/codec/index.d.ts

@@ -0,0 +1,4 @@
+export { AVC } from "./avc";
+export { AAC } from "./aac";
+export { HEVC } from "./hevc";
+export { NALu } from "./nalu";

package/es/codec/nalu.d.ts

@@ -0,0 +1,11 @@
+export class NALu {
+    static parseAnnexB(data: any): any[];
+    static parseAvcC(data: any, size?: number): any[];
+    static parseSEI(unit: any): {
+        payload: any;
+        type: number;
+        size: number;
+        uuid: string;
+    };
+    static removeEPB(uint: any): any;
+}

package/es/codec/nalu.js

@@ -0,0 +1,194 @@
+import _classCallCheck from '@babel/runtime/helpers/classCallCheck';
+import _createClass from '@babel/runtime/helpers/createClass';
+import 'core-js/modules/es.object.to-string.js';
+import 'core-js/modules/es.regexp.to-string.js';
+import 'core-js/modules/es.array.iterator.js';
+import 'core-js/modules/es.typed-array.uint8-array.js';
+import 'core-js/modules/es.typed-array.copy-within.js';
+import 'core-js/modules/es.typed-array.every.js';
+import 'core-js/modules/es.typed-array.fill.js';
+import 'core-js/modules/es.typed-array.filter.js';
+import 'core-js/modules/es.typed-array.find.js';
+import 'core-js/modules/es.typed-array.find-index.js';
+import 'core-js/modules/es.typed-array.for-each.js';
+import 'core-js/modules/es.typed-array.includes.js';
+import 'core-js/modules/es.typed-array.index-of.js';
+import 'core-js/modules/es.typed-array.iterator.js';
+import 'core-js/modules/es.typed-array.join.js';
+import 'core-js/modules/es.typed-array.last-index-of.js';
+import 'core-js/modules/es.typed-array.map.js';
+import 'core-js/modules/es.typed-array.reduce.js';
+import 'core-js/modules/es.typed-array.reduce-right.js';
+import 'core-js/modules/es.typed-array.reverse.js';
+import 'core-js/modules/es.typed-array.set.js';
+import 'core-js/modules/es.typed-array.slice.js';
+import 'core-js/modules/es.typed-array.some.js';
+import 'core-js/modules/es.typed-array.sort.js';
+import 'core-js/modules/es.typed-array.subarray.js';
+import 'core-js/modules/es.typed-array.to-locale-string.js';
+import 'core-js/modules/es.typed-array.to-string.js';
+import { readBig32 } from '../utils/index.js';
+
+var NALu = /*#__PURE__*/function () {
+  function NALu() {
+    _classCallCheck(this, NALu);
+  }
+
+  _createClass(NALu, null, [{
+    key: "parseAnnexB",
+    value: function parseAnnexB(data) {
+      var len = data.length;
+      var start = 2;
+      var end = 0;
+
+      while (data[start] != null && data[start] !== 1) {
+        start++;
+      }
+
+      start++;
+      end = start + 2;
+      if (end >= len) return [];
+      var units = [];
+
+      while (end < len) {
+        switch (data[end]) {
+          case 0:
+            if (data[end - 1] !== 0) {
+              end += 2;
+              break;
+            } else if (data[end - 2] !== 0) {
+              end++;
+              break;
+            }
+
+            if (start !== end - 2) units.push(data.subarray(start, end - 2));
+
+            do {
+              end++;
+            } while (data[end] !== 1 && end < len);
+
+            start = end + 1;
+            end = start + 2;
+            break;
+
+          case 1:
+            if (data[end - 1] !== 0 || data[end - 2] !== 0) {
+              end += 3;
+              break;
+            }
+
+            if (start !== end - 2) units.push(data.subarray(start, end - 2));
+            start = end + 1;
+            end = start + 2;
+            break;
+
+          default:
+            end += 3;
+            break;
+        }
+      }
+
+      if (start < len) units.push(data.subarray(start));
+      return units;
+    }
+  }, {
+    key: "parseAvcC",
+    value: function parseAvcC(data) {
+      var size = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 4;
+      if (data.length < 4) return;
+      var dataLen = data.length;
+      var units = [];
+      var offset = 0;
+      var length;
+
+      while (offset + size < dataLen) {
+        length = readBig32(data, offset);
+        if (size === 3) length >>>= 8;
+        offset += size;
+        if (!length) continue;
+
+        if (offset + length > dataLen) {
+          break;
+        }
+
+        units.push(data.subarray(offset, offset + length));
+        offset += length;
+      }
+
+      return units;
+    }
+  }, {
+    key: "parseSEI",
+    value: function parseSEI(unit) {
+      var len = unit.length;
+      var i = 1;
+      var type = 0;
+      var size = 0;
+      var uuid = '';
+
+      while (unit[i] === 255) {
+        type += 255;
+        i++;
+      }
+
+      type += unit[i++];
+
+      while (unit[i] === 255) {
+        size += 255;
+        i++;
+      }
+
+      size += unit[i++];
+
+      if (type === 5 && len > i + 16) {
+        for (var j = 0; j < 16; j++) {
+          uuid += unit[i].toString(16);
+          i++;
+        }
+      }
+
+      return {
+        payload: unit.subarray(i),
+        type: type,
+        size: size,
+        uuid: uuid
+      };
+    }
+  }, {
+    key: "removeEPB",
+    value: function removeEPB(uint) {
+      var length = uint.byteLength;
+      var emulationPreventionBytesPositions = [];
+      var i = 1;
+
+      while (i < length - 2) {
+        if (uint[i] === 0 && uint[i + 1] === 0 && uint[i + 2] === 0x03) {
+          emulationPreventionBytesPositions.push(i + 2);
+          i += 2;
+        } else {
+          i++;
+        }
+      }
+
+      if (!emulationPreventionBytesPositions.length) return uint;
+      var newLength = length - emulationPreventionBytesPositions.length;
+      var newData = new Uint8Array(newLength);
+      var sourceIndex = 0;
+
+      for (i = 0; i < newLength; sourceIndex++, i++) {
+        if (sourceIndex === emulationPreventionBytesPositions[0]) {
+          sourceIndex++;
+          emulationPreventionBytesPositions.shift();
+        }
+
+        newData[i] = uint[sourceIndex];
+      }
+
+      return newData;
+    }
+  }]);
+
+  return NALu;
+}();
+
+export { NALu };

package/es/flv/amf.d.ts

@@ -0,0 +1,16 @@
+export class AMF {
+    static parse(data: any): {};
+    static _parseValue(view: any): any;
+    static _parseString(view: any): {
+        data: string;
+        size: any;
+    };
+    static _parseObject(view: any): {
+        data: {
+            name: string;
+            value: any;
+        };
+        size: any;
+        isEnd: any;
+    };
+}

package/es/flv/amf.js

@@ -0,0 +1,247 @@
+import _classCallCheck from '@babel/runtime/helpers/classCallCheck';
+import _createClass from '@babel/runtime/helpers/createClass';
+import 'core-js/modules/es.object.to-string.js';
+import 'core-js/modules/es.function.name.js';
+import 'core-js/modules/es.array.iterator.js';
+import 'core-js/modules/es.typed-array.uint8-array.js';
+import 'core-js/modules/es.typed-array.copy-within.js';
+import 'core-js/modules/es.typed-array.every.js';
+import 'core-js/modules/es.typed-array.fill.js';
+import 'core-js/modules/es.typed-array.filter.js';
+import 'core-js/modules/es.typed-array.find.js';
+import 'core-js/modules/es.typed-array.find-index.js';
+import 'core-js/modules/es.typed-array.for-each.js';
+import 'core-js/modules/es.typed-array.includes.js';
+import 'core-js/modules/es.typed-array.index-of.js';
+import 'core-js/modules/es.typed-array.iterator.js';
+import 'core-js/modules/es.typed-array.join.js';
+import 'core-js/modules/es.typed-array.last-index-of.js';
+import 'core-js/modules/es.typed-array.map.js';
+import 'core-js/modules/es.typed-array.reduce.js';
+import 'core-js/modules/es.typed-array.reduce-right.js';
+import 'core-js/modules/es.typed-array.reverse.js';
+import 'core-js/modules/es.typed-array.set.js';
+import 'core-js/modules/es.typed-array.slice.js';
+import 'core-js/modules/es.typed-array.some.js';
+import 'core-js/modules/es.typed-array.sort.js';
+import 'core-js/modules/es.typed-array.subarray.js';
+import 'core-js/modules/es.typed-array.to-locale-string.js';
+import 'core-js/modules/es.typed-array.to-string.js';
+import { UTF8 } from '../utils/utf8.js';
+
+var AMF = /*#__PURE__*/function () {
+  function AMF() {
+    _classCallCheck(this, AMF);
+  }
+
+  _createClass(AMF, null, [{
+    key: "parse",
+    value: function parse(data) {
+      if (data.length < 3) return;
+      var ret = {};
+
+      var name = AMF._parseValue(new DataView(data.buffer, data.byteOffset, data.byteLength));
+
+      var value = AMF._parseValue(new DataView(data.buffer, data.byteOffset + name.size, data.byteLength - name.size));
+
+      ret[name.data] = value.data;
+      return ret;
+    }
+  }, {
+    key: "_parseValue",
+    value: function _parseValue(view) {
+      var dataLen = view.byteLength;
+      var type = view.getUint8(0);
+      var offset = 1;
+      var isEnd = false;
+      var value;
+
+      switch (type) {
+        case 0:
+          // Number(Double) type
+          value = view.getFloat64(1);
+          offset += 8;
+          break;
+
+        case 1:
+          {
+            // Boolean type
+            value = !!view.getUint8(1);
+            offset += 1;
+            break;
+          }
+
+        case 2:
+          {
+            // String type
+            var _AMF$_parseString = AMF._parseString(new DataView(view.buffer, view.byteOffset + offset, view.byteLength - offset)),
+                data = _AMF$_parseString.data,
+                size = _AMF$_parseString.size;
+
+            value = data;
+            offset += size;
+          }
+          break;
+
+        case 3:
+          {
+            // Object(s) type
+            value = {};
+            var terminal = 0;
+
+            if ((view.getUint32(dataLen - 4) & 0x00FFFFFF) === 9) {
+              terminal = 3;
+            }
+
+            while (offset < dataLen - 4) {
+              // 4 === type(UI8) + ScriptDataObjectEnd(UI24)
+              var _AMF$_parseObject = AMF._parseObject(new DataView(view.buffer, view.byteOffset + offset, view.byteLength - offset - terminal)),
+                  _size = _AMF$_parseObject.size,
+                  _data = _AMF$_parseObject.data,
+                  _isEnd = _AMF$_parseObject.isEnd;
+
+              if (_isEnd) break;
+              value[_data.name] = _data.value;
+              offset += _size;
+            }
+
+            if (offset <= dataLen - 3) {
+              var marker = view.getUint32(offset - 1) & 0x00FFFFFF;
+              if (marker === 9) offset += 3;
+            }
+          }
+          break;
+
+        case 8:
+          {
+            // ECMA array type (Mixed array)
+            value = {};
+            offset += 4; // ECMAArrayLength(UI32)
+
+            var _terminal = 0; // workaround for malformed MixedArrays which has missing ScriptDataObjectEnd
+
+            if ((view.getUint32(dataLen - 4) & 0x00FFFFFF) === 9) {
+              _terminal = 3;
+            }
+
+            while (offset < dataLen - 8) {
+              // 8 === type(UI8) + ECMAArrayLength(UI32) + ScriptDataVariableEnd(UI24)
+              var _AMF$_parseObject2 = AMF._parseObject(new DataView(view.buffer, view.byteOffset + offset, view.byteLength - offset - _terminal)),
+                  _size2 = _AMF$_parseObject2.size,
+                  _data2 = _AMF$_parseObject2.data,
+                  _isEnd2 = _AMF$_parseObject2.isEnd;
+
+              if (_isEnd2) break;
+              value[_data2.name] = _data2.value;
+              offset += _size2;
+            }
+
+            if (offset <= dataLen - 3) {
+              var _marker = view.getUint32(offset - 1) & 0x00FFFFFF;
+
+              if (_marker === 9) {
+                offset += 3;
+              }
+            }
+          }
+          break;
+
+        case 9:
+          // ScriptDataObjectEnd
+          value = undefined;
+          offset = 1;
+          isEnd = true;
+          break;
+
+        case 10:
+          {
+            // Strict array type
+            value = [];
+            var strictArrayLength = view.getUint32(1);
+            offset += 4;
+
+            for (var i = 0; i < strictArrayLength; i++) {
+              var _AMF$_parseValue = AMF._parseValue(new DataView(view.buffer, view.byteOffset + offset, view.byteLength - offset)),
+                  _data3 = _AMF$_parseValue.data,
+                  _size3 = _AMF$_parseValue.size;
+
+              value.push(_data3);
+              offset += _size3;
+            }
+          }
+          break;
+
+        case 11:
+          {
+            // Date type
+            var timestamp = view.getFloat64(offset) + view.getInt16(offset + 8) * 60000;
+            value = new Date(timestamp);
+            offset += 10;
+          }
+          break;
+
+        case 12:
+          {
+            // Long string type
+            var length = view.getUint32(1);
+            offset += 4;
+            value = '';
+
+            if (length > 0) {
+              value = UTF8.decode(new Uint8Array(view.buffer, view.byteOffset + offset, length));
+            }
+
+            offset += length;
+          }
+          break;
+
+        default:
+          offset = dataLen;
+          break;
+      }
+
+      return {
+        data: value,
+        size: offset,
+        isEnd: isEnd
+      };
+    }
+  }, {
+    key: "_parseString",
+    value: function _parseString(view) {
+      var length = view.getUint16(0);
+      var data = '';
+
+      if (length > 0) {
+        data = UTF8.decode(new Uint8Array(view.buffer, view.byteOffset + 2, length));
+      }
+
+      return {
+        data: data,
+        size: 2 + length
+      };
+    }
+  }, {
+    key: "_parseObject",
+    value: function _parseObject(view) {
+      if (view.byteLength < 3) return;
+
+      var name = AMF._parseString(view);
+
+      var value = AMF._parseValue(new DataView(view.buffer, view.byteOffset + name.size, view.byteLength - name.size));
+
+      return {
+        data: {
+          name: name.data,
+          value: value.data
+        },
+        size: name.size + value.size,
+        isEnd: value.isEnd
+      };
+    }
+  }]);
+
+  return AMF;
+}();
+
+export { AMF };

package/es/flv/fixer.d.ts

@@ -0,0 +1,31 @@
+export class FlvFixer {
+    constructor(videoTrack: any, audioTrack: any, metadataTrack: any);
+    videoTrack: any;
+    audioTrack: any;
+    metadataTrack: any;
+    _baseDts: number;
+    _baseDtsInited: boolean;
+    _audioNextPts: any;
+    _videoNextDts: any;
+    _audioTimestampBreak: number;
+    _videoTimestampBreak: number;
+    _lastAudioExceptionGapDot: number;
+    _lastAudioExceptionOverlapDot: number;
+    _lastAudioExceptionLargeGapDot: number;
+    _lastVideoExceptionLargeGapDot: number;
+    _lastVideoExceptionChunkFirstDtsDot: number;
+    /**
+     * @param {number} startTime 点播seek到的时间点
+     * @param {boolean} discontinuity 是否换流
+     * @param {boolean} contiguous 前后chunk时间戳是否连续
+     */
+    fix(startTime?: number, discontinuity?: boolean, contiguous?: boolean): void;
+    _videoLastSample: any;
+    _fixVideo(videoTrack: any): void;
+    _fixAudio(audioTrack: any): void;
+    _calculateBaseDts(audioTrack: any, videoTrack: any): boolean;
+    _resetBaseDtsWhenStreamBreaked(): void;
+    _doFixAudioInternal(audioTrack: any, samples: any, timescale: any): void;
+    _getG711Duration(track: any): number;
+    _getSilentFrame(track: any): Uint8Array;
+}