xgplayer-transmuxer 3.0.0-alpha.2

package/es/codec/aac.d.ts

@@ -0,0 +1,34 @@
+export class AAC {
+    static FREQ: number[];
+    static getRateIndexByRate(rate: any): number;
+    static parseADTS(data: any, pts: any): {
+        skip: number;
+        remaining: any;
+        frames: {
+            pts: any;
+            data: any;
+        }[];
+        samplingFrequencyIndex: number;
+        sampleRate: number;
+        objectType: number;
+        channelCount: number;
+        codec: string;
+        config: number[];
+        originCodec: string;
+    };
+    static parseAudioSpecificConfig(data: any): {
+        samplingFrequencyIndex: number;
+        sampleRate: number;
+        objectType: number;
+        channelCount: number;
+        config: number[];
+        codec: string;
+        originCodec: string;
+    };
+    static getFrameDuration(rate: any, timescale?: number): number;
+    static _getConfig(samplingIndex: any, channelCount: any, originObjectType: any): {
+        config: number[];
+        codec: string;
+    };
+    static getSilentFrame(codec: any, channelCount: any): Uint8Array;
+}

package/es/codec/aac.js

@@ -0,0 +1,242 @@
+import _classCallCheck from '@babel/runtime/helpers/classCallCheck';
+import _createClass from '@babel/runtime/helpers/createClass';
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import 'core-js/modules/es.array.iterator.js';
+import 'core-js/modules/es.object.to-string.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 { isFirefox, isAndroid } from '../utils/env.js';
+
+var AAC = /*#__PURE__*/function () {
+  function AAC() {
+    _classCallCheck(this, AAC);
+  }
+
+  _createClass(AAC, null, [{
+    key: "getRateIndexByRate",
+    value: function getRateIndexByRate(rate) {
+      return AAC.FREQ.indexOf(rate);
+    }
+  }, {
+    key: "parseADTS",
+    value: function parseADTS(data, pts) {
+      var len = data.length;
+      var i = 0;
+
+      while (i + 2 < len) {
+        if (data[i] === 0xff && (data[i + 1] & 0xf6) === 0xf0) {
+          break;
+        }
+
+        i++;
+      }
+
+      if (i >= len) return;
+      var skip = i;
+      var frames = [];
+      var samplingFrequencyIndex = (data[i + 2] & 0x3c) >>> 2;
+      var sampleRate = AAC.FREQ[samplingFrequencyIndex];
+      if (!sampleRate) throw new Error("Invalid sampling index: ".concat(samplingFrequencyIndex));
+      var objectType = ((data[i + 2] & 0xc0) >>> 6) + 1;
+      var channelCount = (data[i + 2] & 1) << 2 | (data[i + 3] & 0xc0) >>> 6;
+
+      var _AAC$_getConfig = AAC._getConfig(samplingFrequencyIndex, channelCount, objectType),
+          config = _AAC$_getConfig.config,
+          codec = _AAC$_getConfig.codec;
+
+      var protectionSkipBytes;
+      var frameLength;
+      var frameIndex = 0;
+      var duration = AAC.getFrameDuration(sampleRate);
+
+      while (i + 7 < len) {
+        if (data[i] !== 0xff || (data[i + 1] & 0xF6) !== 0xf0) {
+          i++;
+          continue;
+        }
+
+        frameLength = (data[i + 3] & 0x03) << 11 | data[i + 4] << 3 | (data[i + 5] & 0xe0) >> 5;
+        if (len - i < frameLength) break;
+        protectionSkipBytes = (~data[i + 1] & 0x01) * 2;
+        frames.push({
+          pts: pts + frameIndex * duration,
+          data: data.subarray(i + 7 + protectionSkipBytes, i + frameLength)
+        });
+        frameIndex++;
+        i += frameLength;
+      }
+
+      return {
+        skip: skip,
+        remaining: i >= len ? undefined : data.subarray(i),
+        frames: frames,
+        samplingFrequencyIndex: samplingFrequencyIndex,
+        sampleRate: sampleRate,
+        objectType: objectType,
+        channelCount: channelCount,
+        codec: codec,
+        config: config,
+        originCodec: "mp4a.40.".concat(objectType)
+      };
+    }
+  }, {
+    key: "parseAudioSpecificConfig",
+    value: function parseAudioSpecificConfig(data) {
+      if (!data.length) return;
+      var objectType = data[0] >>> 3;
+      var samplingFrequencyIndex = (data[0] & 0x07) << 1 | data[1] >>> 7;
+      var channelCount = (data[1] & 0x78) >>> 3;
+      var sampleRate = AAC.FREQ[samplingFrequencyIndex];
+      if (!sampleRate) throw new Error("Invalid sampling index: ".concat(samplingFrequencyIndex));
+
+      var _AAC$_getConfig2 = AAC._getConfig(samplingFrequencyIndex, channelCount, objectType),
+          config = _AAC$_getConfig2.config,
+          codec = _AAC$_getConfig2.codec;
+
+      return {
+        samplingFrequencyIndex: samplingFrequencyIndex,
+        sampleRate: sampleRate,
+        objectType: objectType,
+        channelCount: channelCount,
+        config: config,
+        codec: codec,
+        originCodec: "mp4a.40.".concat(objectType)
+      };
+    }
+  }, {
+    key: "getFrameDuration",
+    value: function getFrameDuration(rate) {
+      var timescale = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 90000;
+      return 1024 * timescale / rate;
+    }
+  }, {
+    key: "_getConfig",
+    value: function _getConfig(samplingIndex, channelCount, originObjectType) {
+      var config = [];
+      var objectType;
+      var extensionSamplingIndex;
+
+      if (isFirefox) {
+        if (samplingIndex >= 6) {
+          // use SBR (HE-AAC)
+          objectType = 5;
+          extensionSamplingIndex = samplingIndex - 3;
+        } else {
+          // use LC-AAC
+          objectType = 2;
+          extensionSamplingIndex = samplingIndex;
+        }
+      } else if (isAndroid) {
+        // use LC-AAC
+        objectType = 2;
+        extensionSamplingIndex = samplingIndex;
+      } else {
+        // use HE-AAC
+        objectType = originObjectType;
+        extensionSamplingIndex = samplingIndex;
+
+        if (samplingIndex >= 6) {
+          extensionSamplingIndex = samplingIndex - 3;
+        } else if (channelCount === 1) {
+          // Mono channel, use LC-AAC
+          objectType = 2;
+          extensionSamplingIndex = samplingIndex;
+        }
+      }
+
+      config[0] = objectType << 3;
+      config[0] |= (samplingIndex & 0x0e) >> 1;
+      config[1] = (samplingIndex & 0x01) << 7;
+      config[1] |= channelCount << 3;
+
+      if (objectType === 5) {
+        config[1] |= (extensionSamplingIndex & 0x0e) >> 1;
+        config[2] = (extensionSamplingIndex & 0x01) << 7;
+        config[2] |= 2 << 2;
+        config[3] = 0;
+      }
+
+      return {
+        config: config,
+        codec: "mp4a.40.".concat(objectType)
+      };
+    }
+    /* c8 ignore next 65 */
+
+  }, {
+    key: "getSilentFrame",
+    value: function getSilentFrame(codec, channelCount) {
+      switch (codec) {
+        case 'mp4a.40.2':
+          if (channelCount === 1) {
+            return new Uint8Array([0x00, 0xc8, 0x00, 0x80, 0x23, 0x80]);
+          }
+
+          if (channelCount === 2) {
+            return new Uint8Array([0x21, 0x00, 0x49, 0x90, 0x02, 0x19, 0x00, 0x23, 0x80]);
+          }
+
+          if (channelCount === 3) {
+            return new Uint8Array([0x00, 0xc8, 0x00, 0x80, 0x20, 0x84, 0x01, 0x26, 0x40, 0x08, 0x64, 0x00, 0x8e]);
+          }
+
+          if (channelCount === 4) {
+            return new Uint8Array([0x00, 0xc8, 0x00, 0x80, 0x20, 0x84, 0x01, 0x26, 0x40, 0x08, 0x64, 0x00, 0x80, 0x2c, 0x80, 0x08, 0x02, 0x38]);
+          }
+
+          if (channelCount === 5) {
+            return new Uint8Array([0x00, 0xc8, 0x00, 0x80, 0x20, 0x84, 0x01, 0x26, 0x40, 0x08, 0x64, 0x00, 0x82, 0x30, 0x04, 0x99, 0x00, 0x21, 0x90, 0x02, 0x38]);
+          }
+
+          if (channelCount === 6) {
+            return new Uint8Array([0x00, 0xc8, 0x00, 0x80, 0x20, 0x84, 0x01, 0x26, 0x40, 0x08, 0x64, 0x00, 0x82, 0x30, 0x04, 0x99, 0x00, 0x21, 0x90, 0x02, 0x00, 0xb2, 0x00, 0x20, 0x08, 0xe0]);
+          }
+
+          break;
+
+        default:
+          if (channelCount === 1) {
+            return new Uint8Array([0x1, 0x40, 0x22, 0x80, 0xa3, 0x4e, 0xe6, 0x80, 0xba, 0x8, 0x0, 0x0, 0x0, 0x1c, 0x6, 0xf1, 0xc1, 0xa, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5e]);
+          }
+
+          if (channelCount === 2) {
+            return new Uint8Array([0x1, 0x40, 0x22, 0x80, 0xa3, 0x5e, 0xe6, 0x80, 0xba, 0x8, 0x0, 0x0, 0x0, 0x0, 0x95, 0x0, 0x6, 0xf1, 0xa1, 0xa, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5e]);
+          }
+
+          if (channelCount === 3) {
+            return new Uint8Array([0x1, 0x40, 0x22, 0x80, 0xa3, 0x5e, 0xe6, 0x80, 0xba, 0x8, 0x0, 0x0, 0x0, 0x0, 0x95, 0x0, 0x6, 0xf1, 0xa1, 0xa, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5e]);
+          }
+
+          break;
+      }
+    }
+  }]);
+
+  return AAC;
+}();
+
+_defineProperty(AAC, "FREQ", [96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050, 16000, 12000, 11025, 8000, 7350]);
+
+export { AAC };

package/es/codec/avc.d.ts

@@ -0,0 +1,35 @@
+export class AVC {
+    static parseAVCDecoderConfigurationRecord(data: any): {
+        sps: {
+            codec: string;
+            profileIdc: any;
+            profileCompatibility: any;
+            levelIdc: any;
+            chromaFormat: number;
+            width: number;
+            height: number;
+            sarRatio: number[];
+            fpsNum: any;
+            fpsDen: number;
+            fps: number;
+            fixedFrame: boolean;
+        };
+        spsArr: any[];
+        ppsArr: any[];
+        nalUnitSize: number;
+    };
+    static parseSPS(unit: any): {
+        codec: string;
+        profileIdc: any;
+        profileCompatibility: any;
+        levelIdc: any;
+        chromaFormat: number;
+        width: number;
+        height: number;
+        sarRatio: number[];
+        fpsNum: any;
+        fpsDen: number;
+        fps: number;
+        fixedFrame: boolean;
+    };
+}

package/es/codec/avc.js

@@ -0,0 +1,250 @@
+import _classCallCheck from '@babel/runtime/helpers/classCallCheck';
+import _createClass from '@babel/runtime/helpers/createClass';
+import { NALu } from './nalu.js';
+import { getAvcCodec } from '../utils/index.js';
+import { ExpGolomb } from '../utils/exp-golomb.js';
+
+var AVC = /*#__PURE__*/function () {
+  function AVC() {
+    _classCallCheck(this, AVC);
+  }
+
+  _createClass(AVC, null, [{
+    key: "parseAVCDecoderConfigurationRecord",
+    value: function parseAVCDecoderConfigurationRecord(data) {
+      if (data.length < 7) return;
+      var nalUnitSize = (data[4] & 3) + 1;
+      var spsParsed;
+      var spsArr = [];
+      var ppsArr = [];
+      var offset = 6;
+      var spsCount = data[5] & 0x1f;
+      var spsSize;
+
+      for (var i = 0; i < spsCount; i++) {
+        spsSize = data[offset] << 8 | data[offset + 1];
+        offset += 2;
+        if (!spsSize) continue;
+        var sps = data.subarray(offset, offset + spsSize);
+        offset += spsSize;
+        spsArr.push(sps);
+
+        if (!spsParsed) {
+          spsParsed = AVC.parseSPS(NALu.removeEPB(sps));
+        }
+      }
+
+      var ppsCount = data[offset];
+      offset++;
+      var ppsSize;
+
+      for (var _i = 0; _i < ppsCount; _i++) {
+        ppsSize = data[offset] << 8 | data[offset + 1];
+        offset += 2;
+        if (!ppsSize) continue;
+        ppsArr.push(data.subarray(offset, offset + ppsSize));
+        offset += ppsSize;
+      }
+
+      return {
+        sps: spsParsed,
+        spsArr: spsArr,
+        ppsArr: ppsArr,
+        nalUnitSize: nalUnitSize
+      };
+    }
+  }, {
+    key: "parseSPS",
+    value: function parseSPS(unit) {
+      var eg = new ExpGolomb(unit);
+      eg.readUByte();
+      var profileIdc = eg.readUByte();
+      var profileCompatibility = eg.readUByte();
+      var levelIdc = eg.readUByte();
+      eg.skipUEG();
+      var chromaFormat = 420;
+
+      if (profileIdc === 100 || profileIdc === 110 || profileIdc === 122 || profileIdc === 244 || profileIdc === 44 || profileIdc === 83 || profileIdc === 86 || profileIdc === 118 || profileIdc === 128 || profileIdc === 138 || profileIdc === 144) {
+        var chromaFormatIdc = eg.readUEG();
+        if (chromaFormatIdc <= 3) chromaFormat = [0, 420, 422, 444][chromaFormatIdc];
+        if (chromaFormatIdc === 3) eg.skipBits(1);
+        eg.skipUEG();
+        eg.skipUEG();
+        eg.skipBits(1);
+
+        if (eg.readBool()) {
+          var scalingListCount = chromaFormatIdc !== 3 ? 8 : 12;
+
+          for (var i = 0; i < scalingListCount; i++) {
+            if (eg.readBool()) {
+              if (i < 6) {
+                eg.skipScalingList(16);
+              } else {
+                eg.skipScalingList(64);
+              }
+            }
+          }
+        }
+      }
+
+      eg.skipUEG();
+      var picOrderCntType = eg.readUEG();
+
+      if (picOrderCntType === 0) {
+        eg.readUEG();
+      } else if (picOrderCntType === 1) {
+        eg.skipBits(1);
+        eg.skipUEG();
+        eg.skipUEG();
+        var numRefFramesInPicOrderCntCycle = eg.readUEG();
+
+        for (var _i2 = 0; _i2 < numRefFramesInPicOrderCntCycle; _i2++) {
+          eg.skipUEG();
+        }
+      }
+
+      eg.skipUEG();
+      eg.skipBits(1);
+      var picWidthInMbsMinus1 = eg.readUEG();
+      var picHeightInMapUnitsMinus1 = eg.readUEG();
+      var frameMbsOnlyFlag = eg.readBits(1);
+      if (frameMbsOnlyFlag === 0) eg.skipBits(1);
+      eg.skipBits(1);
+      var frameCropLeftOffset = 0;
+      var frameCropRightOffset = 0;
+      var frameCropTopOffset = 0;
+      var frameCropBottomOffset = 0;
+
+      if (eg.readBool()) {
+        frameCropLeftOffset = eg.readUEG();
+        frameCropRightOffset = eg.readUEG();
+        frameCropTopOffset = eg.readUEG();
+        frameCropBottomOffset = eg.readUEG();
+      }
+
+      var sarRatio;
+      var fixedFrame;
+      var fpsNum;
+      var fpsDen;
+      var fps;
+
+      if (eg.readBool()) {
+        if (eg.readBool()) {
+          var aspectRatioIdc = eg.readUByte();
+
+          switch (aspectRatioIdc) {
+            case 1:
+              sarRatio = [1, 1];
+              break;
+
+            case 2:
+              sarRatio = [12, 11];
+              break;
+
+            case 3:
+              sarRatio = [10, 11];
+              break;
+
+            case 4:
+              sarRatio = [16, 11];
+              break;
+
+            case 5:
+              sarRatio = [40, 33];
+              break;
+
+            case 6:
+              sarRatio = [24, 11];
+              break;
+
+            case 7:
+              sarRatio = [20, 11];
+              break;
+
+            case 8:
+              sarRatio = [32, 11];
+              break;
+
+            case 9:
+              sarRatio = [80, 33];
+              break;
+
+            case 10:
+              sarRatio = [18, 11];
+              break;
+
+            case 11:
+              sarRatio = [15, 11];
+              break;
+
+            case 12:
+              sarRatio = [64, 33];
+              break;
+
+            case 13:
+              sarRatio = [160, 99];
+              break;
+
+            case 14:
+              sarRatio = [4, 3];
+              break;
+
+            case 15:
+              sarRatio = [3, 2];
+              break;
+
+            case 16:
+              sarRatio = [2, 1];
+              break;
+
+            case 255:
+              {
+                sarRatio = [eg.readUByte() << 8 | eg.readUByte(), eg.readUByte() << 8 | eg.readUByte()];
+                break;
+              }
+          }
+        }
+
+        if (eg.readBool()) eg.readBool();
+
+        if (eg.readBool()) {
+          eg.readBits(4);
+          if (eg.readBool()) eg.readBits(24);
+        }
+
+        if (eg.readBool()) {
+          eg.readUEG();
+          eg.readUEG();
+        }
+
+        if (eg.readBool()) {
+          var numUnitsInTick = eg.readBits(32);
+          var timeScale = eg.readBits(32);
+          fixedFrame = eg.readBool();
+          fpsNum = timeScale;
+          fpsDen = numUnitsInTick * 2;
+          fps = fpsNum / fpsDen;
+        }
+      }
+
+      return {
+        codec: getAvcCodec(unit.subarray(1, 4)),
+        profileIdc: profileIdc,
+        profileCompatibility: profileCompatibility,
+        levelIdc: levelIdc,
+        chromaFormat: chromaFormat,
+        width: Math.ceil((picWidthInMbsMinus1 + 1) * 16 - 2 * (frameCropLeftOffset + frameCropRightOffset)),
+        height: (2 - frameMbsOnlyFlag) * (picHeightInMapUnitsMinus1 + 1) * 16 - (frameMbsOnlyFlag ? 2 : 4) * (frameCropTopOffset + frameCropBottomOffset),
+        sarRatio: sarRatio,
+        fpsNum: fpsNum,
+        fpsDen: fpsDen,
+        fps: fps,
+        fixedFrame: fixedFrame
+      };
+    }
+  }]);
+
+  return AVC;
+}();
+
+export { AVC };

package/es/codec/hevc.d.ts

@@ -0,0 +1,38 @@
+export class HEVC {
+    static parseHEVCDecoderConfigurationRecord(data: any): {
+        sps: {
+            codec: string;
+            width: number;
+            height: number;
+            chromaFormat: number;
+            bitDepthLumaMinus8: number;
+            bitDepthChromaMinus8: number;
+            generalProfileSpace: any;
+            generalTierFlag: any;
+            generalProfileIdc: any;
+            generalLevelIdc: any;
+        };
+        spsArr: any[];
+        ppsArr: any[];
+        vpsArr: any[];
+        nalUnitSize: number;
+    };
+    static parseSPS(unit: any): {
+        codec: string;
+        width: number;
+        height: number;
+        chromaFormat: number;
+        bitDepthLumaMinus8: number;
+        bitDepthChromaMinus8: number;
+        generalProfileSpace: any;
+        generalTierFlag: any;
+        generalProfileIdc: any;
+        generalLevelIdc: any;
+    };
+    static _parseProfileTierLevel(eg: any, maxSubLayersMinus1: any, profilePresentFlag?: number): {
+        generalProfileSpace: any;
+        generalTierFlag: any;
+        generalProfileIdc: any;
+        generalLevelIdc: any;
+    };
+}