xgplayer-transmuxer 3.0.0-alpha.2

package/es/model/metadata-track.js

@@ -0,0 +1,100 @@
+import 'core-js/modules/es.reflect.construct.js';
+import _createClass from '@babel/runtime/helpers/createClass';
+import _inherits from '@babel/runtime/helpers/inherits';
+import _possibleConstructorReturn from '@babel/runtime/helpers/possibleConstructorReturn';
+import _getPrototypeOf from '@babel/runtime/helpers/getPrototypeOf';
+import _classCallCheck from '@babel/runtime/helpers/classCallCheck';
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import { TrackType } from './types.js';
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+var Sample = // second
+
+/**
+ * @param {Object} data
+ * @param {number} pts
+ */
+function Sample(data, pts) {
+  _classCallCheck(this, Sample);
+
+  _defineProperty(this, "time", 0);
+
+  this.data = data;
+  this.originPts = this.pts = pts;
+};
+
+var FlvScriptSample = /*#__PURE__*/function (_Sample) {
+  _inherits(FlvScriptSample, _Sample);
+
+  var _super = _createSuper(FlvScriptSample);
+
+  function FlvScriptSample() {
+    _classCallCheck(this, FlvScriptSample);
+
+    return _super.apply(this, arguments);
+  }
+
+  return FlvScriptSample;
+}(Sample);
+var SeiSample = /*#__PURE__*/function (_Sample2) {
+  _inherits(SeiSample, _Sample2);
+
+  var _super2 = _createSuper(SeiSample);
+
+  function SeiSample() {
+    _classCallCheck(this, SeiSample);
+
+    return _super2.apply(this, arguments);
+  }
+
+  return SeiSample;
+}(Sample);
+var MetadataTrack = /*#__PURE__*/function () {
+  function MetadataTrack() {
+    _classCallCheck(this, MetadataTrack);
+
+    _defineProperty(this, "id", 3);
+
+    _defineProperty(this, "type", TrackType.METADATA);
+
+    _defineProperty(this, "timescale", 0);
+
+    _defineProperty(this, "flvScriptSamples", []);
+
+    _defineProperty(this, "seiSamples", []);
+  }
+
+  _createClass(MetadataTrack, [{
+    key: "exist",
+    value:
+    /**
+     * @returns {boolean}
+     */
+    function exist() {
+      return !!((this.flvScriptSamples.length || this.seiSamples.length) && this.timescale);
+    }
+  }, {
+    key: "reset",
+    value: function reset() {
+      this.timescale = 0;
+      this.flvScriptSamples = [];
+      this.seiSamples = [];
+    }
+    /**
+     * @returns {boolean}
+     */
+
+  }, {
+    key: "hasSample",
+    value: function hasSample() {
+      return !!(this.flvScriptSamples.length || this.seiSamples.length);
+    }
+  }]);
+
+  return MetadataTrack;
+}();
+
+export { FlvScriptSample, MetadataTrack, SeiSample };

package/es/model/types.d.ts

@@ -0,0 +1,26 @@
+export type TrackType = string;
+export namespace TrackType {
+    const VIDEO: string;
+    const AUDIO: string;
+    const METADATA: string;
+}
+export type VideoCodecType = string;
+export namespace VideoCodecType {
+    const AVC: string;
+    const HEVC: string;
+}
+export type AudioCodecType = string;
+export namespace AudioCodecType {
+    const AAC: string;
+    const G711PCMA: string;
+    const G711PCMU: string;
+}
+export type WarningType = string;
+export namespace WarningType {
+    const LARGE_AV_SHIFT: string;
+    const LARGE_VIDEO_GAP: string;
+    const LARGE_VIDEO_GAP_BETWEEN_CHUNK: string;
+    const LARGE_AUDIO_GAP: string;
+    const AUDIO_FILLED: string;
+    const AUDIO_DROPPED: string;
+}

package/es/model/types.js

@@ -0,0 +1,31 @@
+/** @enum {string} */
+var TrackType = {
+  VIDEO: 'video',
+  AUDIO: 'audio',
+  METADATA: 'metadata'
+};
+/** @enum {string} */
+
+var VideoCodecType = {
+  AVC: 'avc',
+  HEVC: 'hevc'
+};
+/** @enum {string} */
+
+var AudioCodecType = {
+  AAC: 'aac',
+  G711PCMA: 'g7110a',
+  G711PCMU: 'g7110m'
+};
+/** @enum {string} */
+
+var WarningType = {
+  LARGE_AV_SHIFT: 'LARGE_AV_SHIFT',
+  LARGE_VIDEO_GAP: 'LARGE_VIDEO_GAP',
+  LARGE_VIDEO_GAP_BETWEEN_CHUNK: 'LARGE_VIDEO_GAP_BETWEEN_CHUNK',
+  LARGE_AUDIO_GAP: 'LARGE_AUDIO_GAP',
+  AUDIO_FILLED: 'AUDIO_FILLED',
+  AUDIO_DROPPED: 'AUDIO_DROPPED'
+};
+
+export { AudioCodecType, TrackType, VideoCodecType, WarningType };

package/es/model/video-sample.d.ts

@@ -0,0 +1,44 @@
+/**
+ * @typedef {Object} VideoFlag
+ * @property {number} [isLeading=0]
+ * @property {number} [dependsOn=1]
+ * @property {number} [isDependedOn=0]
+ * @property {number} [hasRedundancy=0]
+ * @property {number} [paddingValue=0]
+ * @property {number} [degradationPriority=0]
+ * @property {number} [isNonSyncSample=1]
+ */
+export class VideoSample {
+    /**
+     * @param {number} pts
+     * @param {number} dts
+     * @param {Uint8Array[]} [units]
+     */
+    constructor(pts: number, dts: number, units?: Uint8Array[]);
+    /** @type {VideoFlag} */
+    flag: VideoFlag;
+    keyframe: boolean;
+    gopId: number;
+    duration: number;
+    size: number;
+    units: any[];
+    chromaFormat: number;
+    originPts: number;
+    pts: number;
+    originDts: number;
+    dts: number;
+    /**
+     * @returns {number}
+     */
+    get cts(): number;
+    setToKeyframe(): void;
+}
+export type VideoFlag = {
+    isLeading?: number;
+    dependsOn?: number;
+    isDependedOn?: number;
+    hasRedundancy?: number;
+    paddingValue?: number;
+    degradationPriority?: number;
+    isNonSyncSample?: number;
+};

package/es/model/video-sample.js

@@ -0,0 +1,66 @@
+import _classCallCheck from '@babel/runtime/helpers/classCallCheck';
+import _createClass from '@babel/runtime/helpers/createClass';
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+
+/**
+ * @typedef {Object} VideoFlag
+ * @property {number} [isLeading=0]
+ * @property {number} [dependsOn=1]
+ * @property {number} [isDependedOn=0]
+ * @property {number} [hasRedundancy=0]
+ * @property {number} [paddingValue=0]
+ * @property {number} [degradationPriority=0]
+ * @property {number} [isNonSyncSample=1]
+ */
+var VideoSample = /*#__PURE__*/function () {
+  /** @type {VideoFlag} */
+
+  /**
+   * @param {number} pts
+   * @param {number} dts
+   * @param {Uint8Array[]} [units]
+   */
+  function VideoSample(pts, dts, units) {
+    _classCallCheck(this, VideoSample);
+
+    _defineProperty(this, "flag", {});
+
+    _defineProperty(this, "keyframe", false);
+
+    _defineProperty(this, "gopId", 0);
+
+    _defineProperty(this, "duration", 0);
+
+    _defineProperty(this, "size", 0);
+
+    _defineProperty(this, "units", []);
+
+    _defineProperty(this, "chromaFormat", 420);
+
+    this.originPts = this.pts = pts;
+    this.originDts = this.dts = dts;
+    if (units) this.units = units;
+  }
+  /**
+   * @returns {number}
+   */
+
+
+  _createClass(VideoSample, [{
+    key: "cts",
+    get: function get() {
+      return this.pts - this.dts;
+    }
+  }, {
+    key: "setToKeyframe",
+    value: function setToKeyframe() {
+      this.keyframe = true;
+      this.flag.dependsOn = 2;
+      this.flag.isNonSyncSample = 0;
+    }
+  }]);
+
+  return VideoSample;
+}();
+
+export { VideoSample };

package/es/model/video-track.d.ts

@@ -0,0 +1,45 @@
+export class VideoTrack {
+    /** @readonly */
+    readonly id: 1;
+    /** @readonly */
+    readonly type: string;
+    codecType: string;
+    pid: number;
+    /** @type {Uint8Array} */
+    hvcC: Uint8Array;
+    codec: string;
+    timescale: number;
+    formatTimescale: number;
+    sequenceNumber: number;
+    baseMediaDecodeTime: number;
+    baseDts: number;
+    duration: number;
+    warnings: any[];
+    /** @type {import('./video-sample').VideoSample[]} */
+    samples: import('./video-sample').VideoSample[];
+    /** @type {Uint8Array[]} */
+    pps: Uint8Array[];
+    /** @type {Uint8Array[]} */
+    sps: Uint8Array[];
+    /** @type {Uint8Array[]} */
+    vps: Uint8Array[];
+    fpsNum: number;
+    fpsDen: number;
+    /** @type {[number, number]} */
+    sarRatio: [number, number];
+    width: number;
+    height: number;
+    nalUnitSize: number;
+    present: boolean;
+    /** @type {any} */
+    ext: any;
+    reset(): void;
+    /**
+     * @returns {boolean}
+     */
+    exist(): boolean;
+    /**
+     * @returns {boolean}
+     */
+    hasSample(): boolean;
+}

package/es/model/video-track.js

@@ -0,0 +1,99 @@
+import _classCallCheck from '@babel/runtime/helpers/classCallCheck';
+import _createClass from '@babel/runtime/helpers/createClass';
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import { TrackType, VideoCodecType } from './types.js';
+
+var VideoTrack = /*#__PURE__*/function () {
+  function VideoTrack() {
+    _classCallCheck(this, VideoTrack);
+
+    _defineProperty(this, "id", 1);
+
+    _defineProperty(this, "type", TrackType.VIDEO);
+
+    _defineProperty(this, "codecType", VideoCodecType.AVC);
+
+    _defineProperty(this, "pid", -1);
+
+    _defineProperty(this, "hvcC", null);
+
+    _defineProperty(this, "codec", '');
+
+    _defineProperty(this, "timescale", 0);
+
+    _defineProperty(this, "formatTimescale", 0);
+
+    _defineProperty(this, "sequenceNumber", 0);
+
+    _defineProperty(this, "baseMediaDecodeTime", 0);
+
+    _defineProperty(this, "baseDts", 0);
+
+    _defineProperty(this, "duration", 0);
+
+    _defineProperty(this, "warnings", []);
+
+    _defineProperty(this, "samples", []);
+
+    _defineProperty(this, "pps", []);
+
+    _defineProperty(this, "sps", []);
+
+    _defineProperty(this, "vps", []);
+
+    _defineProperty(this, "fpsNum", 0);
+
+    _defineProperty(this, "fpsDen", 0);
+
+    _defineProperty(this, "sarRatio", []);
+
+    _defineProperty(this, "width", 0);
+
+    _defineProperty(this, "height", 0);
+
+    _defineProperty(this, "nalUnitSize", 4);
+
+    _defineProperty(this, "present", false);
+
+    _defineProperty(this, "ext", void 0);
+  }
+
+  _createClass(VideoTrack, [{
+    key: "reset",
+    value: function reset() {
+      this.sequenceNumber = this.width = this.height = this.fpsDen = this.fpsNum = this.duration = this.baseMediaDecodeTime = this.timescale = 0;
+      this.codec = '';
+      this.present = false;
+      this.pid = -1;
+      this.pps = [];
+      this.sps = [];
+      this.vps = [];
+      this.sarRatio = [];
+      this.samples = [];
+      this.warnings = [];
+      this.hvcC = null;
+    }
+    /**
+     * @returns {boolean}
+     */
+
+  }, {
+    key: "exist",
+    value: function exist() {
+      return !!(this.pps.length && this.sps.length && this.codec);
+    }
+    /**
+     * @returns {boolean}
+     */
+
+  }, {
+    key: "hasSample",
+    value: function hasSample() {
+      return !!this.samples.length;
+    }
+  }]);
+
+  return VideoTrack;
+}();
+
+export { VideoTrack };

package/es/mp4/fmp4-remuxer.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @typedef {Object} RemuxResult
+ * @property {Uint8Array} [videoInitSegment]
+ * @property {Uint8Array} [audioInitSegment]
+ * @property {Uint8Array} [videoSegment]
+ * @property {Uint8Array} [audioSegment]
+ */
+export class FMP4Remuxer {
+    /**
+     * @param {import('../model').VideoTrack} videoTrack
+     * @param {import('../model').AudioTrack} audioTrack
+     */
+    constructor(videoTrack: import('../model').VideoTrack, audioTrack: import('../model').AudioTrack, options: any);
+    videoTrack: import("../model").VideoTrack;
+    audioTrack: import("../model").AudioTrack;
+    log: Logger;
+    /**
+     * @param {boolean} [createInit=false]
+     * @returns {RemuxResult}
+     */
+    remux(createInit?: boolean): RemuxResult;
+    _remuxVideo(): Uint8Array;
+    _remuxAudio(): Uint8Array;
+    reset(): void;
+}
+export type RemuxResult = {
+    videoInitSegment?: Uint8Array;
+    audioInitSegment?: Uint8Array;
+    videoSegment?: Uint8Array;
+    audioSegment?: Uint8Array;
+};
+import { Logger } from "./logger";

package/es/mp4/fmp4-remuxer.js

@@ -0,0 +1,172 @@
+import _classCallCheck from '@babel/runtime/helpers/classCallCheck';
+import _createClass from '@babel/runtime/helpers/createClass';
+import 'core-js/modules/web.dom-collections.for-each.js';
+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 { MP4 } from './mp4.js';
+import { concatUint8Array } from '../utils/index.js';
+import { Logger } from './logger.js';
+
+/**
+ * @typedef {Object} RemuxResult
+ * @property {Uint8Array} [videoInitSegment]
+ * @property {Uint8Array} [audioInitSegment]
+ * @property {Uint8Array} [videoSegment]
+ * @property {Uint8Array} [audioSegment]
+ */
+
+var FMP4Remuxer = /*#__PURE__*/function () {
+  /**
+   * @param {import('../model').VideoTrack} videoTrack
+   * @param {import('../model').AudioTrack} audioTrack
+   */
+  function FMP4Remuxer(videoTrack, audioTrack, options) {
+    _classCallCheck(this, FMP4Remuxer);
+
+    this.videoTrack = videoTrack;
+    this.audioTrack = audioTrack;
+    this.log = new Logger('FMP4Remuxer', options && options.openLog ? !options.openLog : true);
+  }
+  /**
+   * @param {boolean} [createInit=false]
+   * @returns {RemuxResult}
+   */
+
+
+  _createClass(FMP4Remuxer, [{
+    key: "remux",
+    value: function remux() {
+      var createInit = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+      var videoTrack = this.videoTrack;
+      var audioTrack = this.audioTrack;
+      var hasVideo = videoTrack.exist();
+      var hasAudio = audioTrack.exist();
+      videoTrack.duration = videoTrack.duration || 0xffffffff;
+      audioTrack.duration = audioTrack.duration || 0xffffffff;
+      var videoInitSegment;
+      var audioInitSegment;
+      var initSegment;
+      var tracks = [];
+
+      if (createInit) {
+        if (hasVideo) videoInitSegment = MP4.initSegment([this.videoTrack]);
+        if (hasAudio) audioInitSegment = MP4.initSegment([this.audioTrack]);
+
+        if (hasVideo) {
+          tracks.push(this.videoTrack);
+        }
+
+        if (hasAudio) {
+          tracks.push(this.audioTrack);
+        }
+
+        initSegment = MP4.initSegment(tracks);
+      }
+
+      var videoSegment;
+      var audioSegment;
+      if (hasVideo && videoTrack.hasSample()) videoSegment = this._remuxVideo();
+      this.log.debug('[remuxVideo],len,', videoSegment ? videoSegment.byteLength : 0);
+      if (hasAudio && audioTrack.hasSample()) audioSegment = this._remuxAudio();
+      this.log.debug('[remuxAudio],len,', audioSegment ? audioSegment.byteLength : 0);
+      videoTrack.samples = [];
+      audioTrack.samples = [];
+      return {
+        initSegment: initSegment,
+        videoInitSegment: videoInitSegment,
+        audioInitSegment: audioInitSegment,
+        videoSegment: videoSegment,
+        audioSegment: audioSegment
+      };
+    }
+  }, {
+    key: "_remuxVideo",
+    value: function _remuxVideo() {
+      var track = this.videoTrack;
+      var samples = track.samples;
+      var mdatSize = 0;
+      samples.forEach(function (s) {
+        mdatSize += s.units.reduce(function (t, c) {
+          return t + c.byteLength;
+        }, 0);
+        mdatSize += s.units.length * 4;
+      });
+      var mdatData = new Uint8Array(mdatSize);
+      var mdatView = new DataView(mdatData.buffer);
+
+      var _loop = function _loop(i, l, _offset, _sample) {
+        _sample = samples[i];
+        var sampleSize = 0;
+
+        _sample.units.forEach(function (u) {
+          mdatView.setUint32(_offset, u.byteLength);
+          _offset += 4;
+          mdatData.set(u, _offset);
+          _offset += u.byteLength;
+          sampleSize += 4 + u.byteLength;
+        });
+
+        _sample.size = sampleSize;
+        offset = _offset;
+        sample = _sample;
+      };
+
+      for (var i = 0, l = samples.length, offset = 0, sample; i < l; i++) {
+        _loop(i, l, offset, sample);
+      }
+
+      var moof = MP4.moof(this.videoTrack.sequenceNumber++, [track]);
+      var mdat = MP4.mdat(mdatData);
+      return concatUint8Array(moof, mdat);
+    }
+  }, {
+    key: "_remuxAudio",
+    value: function _remuxAudio() {
+      var track = this.audioTrack;
+      var moof = MP4.moof(this.audioTrack.sequenceNumber++, [track]);
+      var mdatData = new Uint8Array(track.samples.reduce(function (t, c) {
+        return t + c.size;
+      }, 0));
+      track.samples.reduce(function (offset, s) {
+        mdatData.set(s.data, offset);
+        return offset + s.size;
+      }, 0);
+      var mdat = MP4.mdat(mdatData);
+      return concatUint8Array(moof, mdat);
+    }
+  }, {
+    key: "reset",
+    value: function reset() {
+      this.videoTrack.reset();
+      this.audioTrack.reset();
+    }
+  }]);
+
+  return FMP4Remuxer;
+}();
+
+export { FMP4Remuxer };

package/es/mp4/index.d.ts

@@ -0,0 +1,4 @@
+export { FMP4Remuxer } from "./fmp4-remuxer";
+export { MP4Remuxer } from "./mp4-remuxer";
+export { MP4Parser } from "./mp4-parser";
+export { MP4Demuxer } from "./mp4-demuxer";

package/es/mp4/logger.d.ts

@@ -0,0 +1,13 @@
+export class Logger {
+    static disabled: boolean;
+    static enable(): void;
+    static disable(): void;
+    constructor(name: any, enable: any);
+    name: any;
+    _prefix: string;
+    debug(...args: any[]): void;
+    log(...args: any[]): void;
+    warn(...args: any[]): void;
+    error(...args: any[]): void;
+    table(...args: any[]): void;
+}