xgplayer-mp4 1.2.4 → 2.0.2

package/src/parse/box/MP4DecConfigDescrTag.js

@@ -5,6 +5,9 @@ Box.MP4DecConfigDescrTag = function (stream) {
   let box = new Box()
   let size
   box.type = stream.readUint8()
+  if (box.type !== 4) {
+    return box
+  }
   size = stream.readUint8()
   if (size === 0x80) {
     box.extend = true

package/src/parse/box/MP4DecSpecificDescrTag.js

@@ -4,6 +4,10 @@ Box.MP4DecSpecificDescrTag = function (stream) {
   let box = new Box()
   let size, dataSize
   box.type = stream.readUint8()
+  if (box.type !== 5) {
+    stream.position = stream.position - 1
+    return box
+  }
   size = stream.readUint8()
   if (size === 0x80) {
     box.extend = true

package/src/parse/box/avcC.js

@@ -1,5 +1,7 @@
 import Box from '../box'
 import Stream from '../stream'
+import SpsParser from './sps'
+
 Box.avcC = function () {
   let stream = new Stream(this.data)
   this.configVersion = stream.readUint8()
@@ -12,8 +14,9 @@ Box.avcC = function () {
   this.sequenceLength = sequenceLength
   let sequence = []
   for (let i = 0; i < sequenceLength; i++) {
-    sequence.push(Number(stream.readUint8()).toString(16))
+    sequence.push(stream.readUint8())
   }
+  this.spsInfo = SpsParser.parseSPS(new Uint8Array(sequence))
   this.ppsCount = stream.readUint8()
   let ppsLength = stream.readUint16()
   this.ppsLength = ppsLength

package/src/parse/box/elst.js

@@ -7,9 +7,6 @@ Box.elst = function () {
   this.flag = Stream.readByte(stream.dataview, 3)
   let entries = []
   let entry_count = stream.readUint32()
-  this.empty_duration = 0; // empty duration of the first edit list entry
-  this.start_time = 0; // start time of the media
-  let edit_start_index = 0;
   this.entries = entries
   for (let i = 0; i < entry_count; i++) {
     let entry = {}
@@ -23,17 +20,7 @@ Box.elst = function () {
     }
     entry.media_rate_integer = stream.readInt16()
     entry.media_rate_fraction = stream.readInt16()
-
-    if (i === 0 && entry.media_time === -1) {
-        /* if empty, the first entry is the start time of the stream
-          * relative to the presentation itself */
-        this.empty_duration = entry.segment_duration;
-        edit_start_index = 1;
-    } else if (i === edit_start_index && entry.media_time >= 0) {
-        this.start_time = entry.media_time;
-    }
   }
-
   delete this.subBox
   delete this.data
   stream = null

package/src/parse/box/esds.js

@@ -5,8 +5,13 @@ Box.esds = function () {
   let stream = new Stream(this.data)
   this.version = stream.readUint8()
   this.flag = Stream.readByte(stream.dataview, 3)
-  let box = Box.MP4ESDescrTag(stream)
-  this.subBox.push(box)
-  delete this.data
-  stream = null
+  try {
+    let box = Box.MP4ESDescrTag(stream)
+    this.subBox.push(box)
+    delete this.data
+    stream = null
+  }catch(e) {
+    console.error(e)
+  }
+  
 }

package/src/parse/box/frma.js

@@ -0,0 +1,10 @@
+import Box from '../box'
+import Stream from '../stream'
+
+Box.frma = function () {
+  let stream = new Stream(this.data)
+  this.data_format = '';
+  for (var i = 0; i < 4; i++) {
+    this.data_format += String.fromCharCode(stream.readUint8());
+  }
+}

package/src/parse/box/golomb.js

@@ -0,0 +1,88 @@
+class Golomb {
+  constructor (uint8array) {
+    this.TAG = 'Golomb'
+    this._buffer = uint8array
+    this._bufferIndex = 0
+    this._totalBytes = uint8array.byteLength
+    this._totalBits = uint8array.byteLength * 8
+    this._currentWord = 0
+    this._currentWordBitsLeft = 0
+  }
+
+  destroy () {
+    this._buffer = null
+  }
+
+  _fillCurrentWord () {
+    let bufferBytesLeft = this._totalBytes - this._bufferIndex
+    if (bufferBytesLeft <= 0) {
+      // TODO 异常处理
+    }
+
+    let bytesRead = Math.min(4, bufferBytesLeft)
+    let word = new Uint8Array(4)
+    word.set(this._buffer.subarray(this._bufferIndex, this._bufferIndex + bytesRead))
+    this._currentWord = new DataView(word.buffer).getUint32(0)
+
+    this._bufferIndex += bytesRead
+    this._currentWordBitsLeft = bytesRead * 8
+  }
+
+  readBits (size) {
+    let bits = Math.min(this._currentWordBitsLeft, size);// :uint
+    let valu = this._currentWord >>> (32 - bits);
+    if (size > 32) {
+      throw new Error('Cannot read more than 32 bits at a time');
+    }
+    this._currentWordBitsLeft -= bits;
+    if (this._currentWordBitsLeft > 0) {
+      this._currentWord <<= bits;
+    } else if (this._totalBytes - this._bufferIndex > 0) {
+      this._fillCurrentWord();
+    }
+
+    bits = size - bits;
+    if (bits > 0 && this._currentWordBitsLeft) {
+      return valu << bits | this.readBits(bits);
+    } else {
+      return valu;
+    }
+  }
+
+  readBool () {
+    return this.readBits(1) === 1
+  }
+
+  readByte () {
+    return this.readBits(8)
+  }
+
+  _skipLeadingZero () {
+    let zeroCount
+    for (zeroCount = 0; zeroCount < this._currentWordBitsLeft; zeroCount++) {
+      if ((this._currentWord & (0x80000000 >>> zeroCount)) !== 0) {
+        this._currentWord <<= zeroCount
+        this._currentWordBitsLeft -= zeroCount
+        return zeroCount
+      }
+    }
+    this._fillCurrentWord()
+    return zeroCount + this._skipLeadingZero()
+  }
+
+  readUEG () { // unsigned exponential golomb
+    let leadingZeros = this._skipLeadingZero()
+    return this.readBits(leadingZeros + 1) - 1
+  }
+
+  readSEG () { // signed exponential golomb
+    let value = this.readUEG()
+    if (value & 0x01) {
+      return (value + 1) >>> 1
+    } else {
+      return -1 * (value >>> 1)
+    }
+  }
+}
+
+export default Golomb

package/src/parse/box/hvc1.js

@@ -0,0 +1,30 @@
+import Box from '../box'
+import Stream from '../stream'
+
+Box.hvc1 = function () {
+  let stream = new Stream(this.data)
+  let self = this
+  stream.skip(6)
+  this.dataReferenceIndex = stream.readUint16()
+  stream.skip(16)
+  this.width = stream.readUint16()
+  this.height = stream.readUint16()
+  this.horizresolution = stream.readUint32()
+  this.vertresolution = stream.readUint32()
+  stream.skip(4)
+  this.frameCount = stream.readUint16()
+  stream.skip(1)
+  for (let i = 0; i < 31; i++) {
+    String.fromCharCode(stream.readUint8())
+  }
+  this.depth = stream.readUint16()
+  stream.skip(2)
+  while (stream.position < stream.buffer.byteLength) {
+    let box = new Box()
+    box.readHeader(stream)
+    self.subBox.push(box)
+    box.readBody(stream)
+  }
+  // delete this.data
+  stream = null
+}

package/src/parse/box/hvcC.js

@@ -0,0 +1,55 @@
+import Box from '../box'
+import Stream from '../stream'
+import SpsParser from './sps'
+
+Box.hvcC = function () {
+  let stream = new Stream(this.data)
+  this.configVersion = stream.readUint8()
+  this.profile = stream.readUint8()
+  this.profileCompatibility = stream.readUint32()
+  this.constraintIndicatorFlags = []
+  for (let i = 0; i < 6; i++) {
+    this.constraintIndicatorFlags.push(Number(stream.readUint8()).toString(16))
+  }
+  this.levelIdc = stream.readUint8()
+  this.profileCompatibilityIndications = stream.readUint32()
+  this.bitDepthLumaMinus8 = stream.readUint8()
+  this.bitDepthChromaMinus8 = stream.readUint8()
+  this.avgFrameRate = stream.readUint16()
+  this.constantFrameRate = stream.readUint8()
+  this.numOfArrays = stream.readUint8()
+
+  this.vpsHeader = stream.readUint24()
+  this.vpsLength = stream.readUint16()
+  let vps = []
+  for (let i = 0; i < this.vpsLength; i++) {
+    vps.push(Number(stream.readUint8()).toString(16))
+  }
+  this.vps = vps
+
+  this.spsHeader = stream.readUint24()
+  this.spsLength = stream.readUint16()
+  let sps = []
+  for (let i = 0; i < this.spsLength; i++) {
+    sps.push(Number(stream.readUint8()).toString(16))
+  }
+  // this.spsInfo = SpsParser.parseSPS(new Uint8Array(sps))
+  this.sequence = sps
+
+  this.ppsHeader = stream.readUint24()
+  this.ppsLength = stream.readUint16()
+  let pps = []
+  for (let i = 0; i < this.ppsLength; i++) {
+    pps.push(Number(stream.readUint8()).toString(16))
+  }
+  this.pps = pps
+
+  let last = []; let dataviewLength = stream.dataview.byteLength
+  while (stream.position < dataviewLength) {
+    last.push(stream.readUint8())
+  }
+  this.last = last
+  delete this.subBox
+  // delete this.data
+  stream = null
+}

package/src/parse/box/pasp.js

@@ -2,8 +2,7 @@ import Box from '../box'
 import Stream from '../stream'
 Box.pasp = function () {
   let stream = new Stream(this.data)
-  this.content = stream.buffer.slice(0, this.size - 8)
-  delete this.subBox
-  delete this.data
+	this.hSpacing = stream.readUint32();
+	this.vSpacing = stream.readUint32();
   stream = null
 }

package/src/parse/box/schm.js

@@ -0,0 +1,18 @@
+import Box from '../box'
+import Stream from '../stream'
+
+
+Box.schm = function () {
+  let stream = new Stream(this.data)
+	this.scheme_version = stream.readUint32();
+  this.scheme_type = '';
+  for (var i = 0; i < 4; i++) {
+    this.scheme_type += String.fromCharCode(stream.readUint8());
+  }
+	if (this.flags & 0x000001) {
+    this.scheme_uri = '';
+    for (var i = 0; i < this.size - this.hdr_size - 8; i++) {
+      this.scheme_uri += String.fromCharCode(stream.readUint8());
+    }
+	}
+}

package/src/parse/box/sps.js

@@ -0,0 +1,286 @@
+/* eslint-disable camelcase  */
+/* eslint-disable one-var  */
+import Golomb from './golomb'
+
+class SPSParser {
+  static _ebsp2rbsp (uint8array) {
+    let src = uint8array
+    let srcLength = src.byteLength
+    let dst = new Uint8Array(srcLength)
+    let dstIdx = 0
+
+    for (let i = 0; i < srcLength; i++) {
+      if (i >= 2) {
+        if (src[i] === 0x03 && src[i - 1] === 0x00 && src[i - 2] === 0x00) {
+          continue
+        }
+      }
+      dst[dstIdx] = src[i]
+      dstIdx++
+    }
+
+    return new Uint8Array(dst.buffer, 0, dstIdx)
+  }
+
+  static parseSPS (uint8array) {
+    let rbsp = SPSParser._ebsp2rbsp(uint8array)
+    let gb = new Golomb(rbsp)
+
+    gb.readByte()
+    let profileIdc = gb.readByte()
+    gb.readByte()
+    let levelIdc = gb.readByte()
+    gb.readUEG()
+
+    let profile_string = SPSParser.getProfileString(profileIdc)
+    let level_string = SPSParser.getLevelString(levelIdc)
+    let chroma_format_idc = 1
+    let chroma_format = 420
+    let chroma_format_table = [0, 420, 422, 444]
+    let bit_depth = 8
+
+    if (profileIdc === 100 || profileIdc === 110 || profileIdc === 122 ||
+      profileIdc === 244 || profileIdc === 44 || profileIdc === 83 ||
+      profileIdc === 86 || profileIdc === 118 || profileIdc === 128 ||
+      profileIdc === 138 || profileIdc === 144) {
+      chroma_format_idc = gb.readUEG()
+      if (chroma_format_idc === 3) {
+        gb.readBits(1)
+      }
+      if (chroma_format_idc <= 3) {
+        chroma_format = chroma_format_table[chroma_format_idc]
+      }
+
+      bit_depth = gb.readUEG() + 8
+      gb.readUEG()
+      gb.readBits(1)
+      if (gb.readBool()) {
+        let scaling_list_count = (chroma_format_idc !== 3) ? 8 : 12
+        for (let i = 0; i < scaling_list_count; i++) {
+          if (gb.readBool()) {
+            if (i < 6) {
+              SPSParser._skipScalingList(gb, 16)
+            } else {
+              SPSParser._skipScalingList(gb, 64)
+            }
+          }
+        }
+      }
+    }
+    gb.readUEG()
+    let pic_order_cnt_type = gb.readUEG()
+    if (pic_order_cnt_type === 0) {
+      gb.readUEG()
+    } else if (pic_order_cnt_type === 1) {
+      gb.readBits(1)
+      gb.readSEG()
+      gb.readSEG()
+      let num_ref_frames_in_pic_order_cnt_cycle = gb.readUEG()
+      for (let i = 0; i < num_ref_frames_in_pic_order_cnt_cycle; i++) {
+        gb.readSEG()
+      }
+    }
+    gb.readUEG()
+    gb.readBits(1)
+
+    let pic_width_in_mbs_minus1 = gb.readUEG()
+    let pic_height_in_map_units_minus1 = gb.readUEG()
+
+    let frame_mbs_only_flag = gb.readBits(1)
+    if (frame_mbs_only_flag === 0) {
+      gb.readBits(1)
+    }
+    gb.readBits(1)
+
+    let frame_crop_left_offset = 0
+    let frame_crop_right_offset = 0
+    let frame_crop_top_offset = 0
+    let frame_crop_bottom_offset = 0
+
+    let frame_cropping_flag = gb.readBool()
+    if (frame_cropping_flag) {
+      frame_crop_left_offset = gb.readUEG()
+      frame_crop_right_offset = gb.readUEG()
+      frame_crop_top_offset = gb.readUEG()
+      frame_crop_bottom_offset = gb.readUEG()
+    }
+
+    let par_width = 1, par_height = 1
+    let fps = 0, fps_fixed = true, fps_num = 0, fps_den = 0
+
+    let vui_parameters_present_flag = gb.readBool()
+    if (vui_parameters_present_flag) {
+      if (gb.readBool()) { // aspect_ratio_info_present_flag
+        let aspect_ratio_idc = gb.readByte()
+        let par_w_table = [1, 12, 10, 16, 40, 24, 20, 32, 80, 18, 15, 64, 160, 4, 3, 2]
+        let par_h_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) {
+          par_width = par_w_table[aspect_ratio_idc - 1]
+          par_height = par_h_table[aspect_ratio_idc - 1]
+        } else if (aspect_ratio_idc === 255) {
+          par_width = gb.readByte() << 8 | gb.readByte()
+          par_height = gb.readByte() << 8 | gb.readByte()
+        }
+      }
+
+      if (gb.readBool()) {
+        gb.readBool()
+      }
+      if (gb.readBool()) {
+        gb.readBits(4)
+        if (gb.readBool()) {
+          gb.readBits(24)
+        }
+      }
+      if (gb.readBool()) {
+        gb.readUEG()
+        gb.readUEG()
+      }
+      if (gb.readBool()) {
+        let num_units_in_tick = gb.readBits(32)
+        let time_scale = gb.readBits(32)
+        fps_fixed = gb.readBool()
+
+        fps_num = time_scale
+        fps_den = num_units_in_tick * 2
+        fps = fps_num / fps_den
+      }
+    }
+
+    let parScale = 1
+    if (par_width !== 1 || par_height !== 1) {
+      parScale = par_width / par_height
+    }
+
+    let crop_unit_x = 0, crop_unit_y = 0
+    if (chroma_format_idc === 0) {
+      crop_unit_x = 1
+      crop_unit_y = 2 - frame_mbs_only_flag
+    } else {
+      let sub_wc = (chroma_format_idc === 3) ? 1 : 2
+      let sub_hc = (chroma_format_idc === 1) ? 2 : 1
+      crop_unit_x = sub_wc
+      crop_unit_y = sub_hc * (2 - frame_mbs_only_flag)
+    }
+
+    let codec_width = (pic_width_in_mbs_minus1 + 1) * 16
+    let codec_height = (2 - frame_mbs_only_flag) * ((pic_height_in_map_units_minus1 + 1) * 16)
+
+    codec_width -= (frame_crop_left_offset + frame_crop_right_offset) * crop_unit_x
+    codec_height -= (frame_crop_top_offset + frame_crop_bottom_offset) * crop_unit_y
+
+    let present_width = Math.ceil(codec_width * parScale)
+
+    gb.destroy()
+    gb = null
+
+    return {
+      profile_string: profile_string,
+      level_string: level_string,
+      bit_depth: bit_depth,
+      chroma_format: chroma_format,
+      chroma_format_string: SPSParser.getChromaFormatString(chroma_format),
+
+      frame_rate: {
+        fixed: fps_fixed,
+        fps: fps,
+        fps_den: fps_den,
+        fps_num: fps_num
+      },
+
+      par_ratio: {
+        width: par_width,
+        height: par_height
+      },
+
+      codec_size: {
+        width: codec_width,
+        height: codec_height
+      },
+
+      present_size: {
+        width: present_width,
+        height: codec_height
+      }
+    }
+  }
+
+  static _skipScalingList (gb, count) {
+    let last_scale = 8, next_scale = 8
+    let delta_scale = 0
+    for (let i = 0; i < count; i++) {
+      if (next_scale !== 0) {
+        delta_scale = gb.readSEG()
+        next_scale = (last_scale + delta_scale + 256) % 256
+      }
+      last_scale = (next_scale === 0) ? last_scale : next_scale
+    }
+  }
+
+  static getProfileString (profileIdc) {
+    switch (profileIdc) {
+      case 66:
+        return 'Baseline'
+      case 77:
+        return 'Main'
+      case 88:
+        return 'Extended'
+      case 100:
+        return 'High'
+      case 110:
+        return 'High10'
+      case 122:
+        return 'High422'
+      case 244:
+        return 'High444'
+      default:
+        return 'Unknown'
+    }
+  }
+
+  static getLevelString (levelIdc) {
+    return (levelIdc / 10).toFixed(1)
+  }
+
+  static getChromaFormatString (chroma) {
+    switch (chroma) {
+      case 420:
+        return '4:2:0'
+      case 422:
+        return '4:2:2'
+      case 444:
+        return '4:4:4'
+      default:
+        return 'Unknown'
+    }
+  }
+
+  static toVideoMeta (spsConfig) {
+    let meta = {}
+    if (spsConfig && spsConfig.codec_size) {
+      meta.codecWidth = spsConfig.codec_size.width
+      meta.codecHeight = spsConfig.codec_size.height
+      meta.presentWidth = spsConfig.present_size.width
+      meta.presentHeight = spsConfig.present_size.height
+    }
+
+    meta.profile = spsConfig.profile_string
+    meta.level = spsConfig.level_string
+    meta.bitDepth = spsConfig.bit_depth
+    meta.chromaFormat = spsConfig.chroma_format
+
+    meta.parRatio = {
+      width: spsConfig.par_ratio.width,
+      height: spsConfig.par_ratio.height
+    }
+
+    meta.frameRate = spsConfig.frame_rate
+
+    let fpsDen = meta.frameRate.fps_den
+    let fpsNum = meta.frameRate.fps_num
+    meta.refSampleDuration = Math.floor(meta.timescale * (fpsDen / fpsNum))
+  }
+}
+
+export default SPSParser

package/src/parse/box/stsz.js

@@ -10,7 +10,12 @@ Box.stsz = function () {
   let entries = []
   this.entries = entries
   for (let i = 0, count = this.count; i < count; i++) {
-    entries.push(stream.readUint32())
+    if (this.sampleSize) {
+      entries.push(this.sampleSize)
+    }
+    else {
+      entries.push(stream.readUint32())
+    }
   }
   delete this.subBox
   delete this.data

package/src/parse/box/tfhd.js

@@ -0,0 +1,43 @@
+import Box from '../box'
+import Stream from '../stream'
+
+Box.tfhd = function () {
+    let stream = new Stream(this.data)
+    this.version = stream.readUint8()
+    this.flag = Stream.readByte(stream.dataview, 3)
+
+    // trackId: view.getUint32(4)
+    this.track_id = stream.readUint32();
+
+    let baseDataOffsetPresent = (this.flag & 0xff) & 0x01;
+    let sampleDescriptionIndexPresent = (this.flag & 0xff) & 0x02;
+    let defaultSampleDurationPresent = (this.flag & 0xff) & 0x08;
+    let defaultSampleSizePresent = (this.flag & 0xff) & 0x10;
+    let defaultSampleFlagsPresent = (this.flag & 0xff) & 0x20;
+
+    let i = 8;
+    if (baseDataOffsetPresent) {
+        i += 4; // truncate top 4 bytes
+        this.baseDataOffset = stream.readUint32();
+        i += 4;
+    }
+    if (sampleDescriptionIndexPresent) {
+        this.sampleDescriptionIndex = stream.readUint32();
+        i += 4;
+    }
+    if (defaultSampleDurationPresent) {
+        this.defaultSampleDuration = stream.readUint32();
+        i += 4;
+    }
+    if (defaultSampleSizePresent) {
+        this.defaultSampleSize = stream.readUint32();
+        i += 4;
+    }
+    if (defaultSampleFlagsPresent) {
+        this.defaultSampleFlags = stream.readUint32();
+    }
+
+    delete this.subBox
+    delete this.data
+    stream = null
+}

package/src/parse/box.js

@@ -25,6 +25,10 @@ class Box {
         uuid.push(stream.readUint8())
       }
     }
+    if (this.type === 'pssh') {
+      this.version = stream.readUint8();
+      this.flags = stream.readUint8();
+    }
   }
   readBody (stream) {
     let end = this.size - stream.position + this.start
@@ -61,6 +65,6 @@ class Box {
   }
 }
 
-Box.containerBox = ['moov', 'trak', 'edts', 'mdia', 'minf', 'dinf', 'stbl', 'mvex', 'moof', 'traf', 'mfra']
+Box.containerBox = ['moov', 'trak', 'edts', 'mdia', 'minf', 'dinf', 'stbl', 'mvex', 'moof', 'traf', 'mfra', 'sinf', 'schi']
 
 export default Box

package/src/parse/stream.js

@@ -90,6 +90,10 @@ class Stream {
   readUint16 () {
     return Stream.readByte(this.dataview, 2)
   }
+  
+  readUint24 () {
+    return Stream.readByte(this.dataview, 3)
+  }
 
   readUint32 () {
     return Stream.readByte(this.dataview, 4)