xgplayer-mp4 1.2.4 → 2.0.2

package/src/util/getHeaders.js

@@ -0,0 +1,18 @@
+export default function getResponseHeaders(xhr) {
+    const headerMap = {};
+    if (xhr instanceof window.XMLHttpRequest) {
+        try {
+            const headers = xhr.getAllResponseHeaders();
+
+            const arr = headers.trim().split(/[\r\n]+/);
+            arr.forEach(function (line) {
+                const parts = line.split(': ');
+                const header = parts.shift();
+                const value = parts.join(': ');
+                headerMap[header] = value;
+            });
+        } catch (error) {
+        }
+    }
+    return headerMap;
+}

package/src/util/index.js

@@ -64,11 +64,12 @@ util.sum = function (...rst) {
  * @param  {Number} sample_order [帧次序]
  * @return {Object}              [块的位置和当前帧的偏移数]
  */
-util.stscOffset = function (stsc, sample_order) {
+util.stscOffset = function (stsc, sample_order, stscObj) {
   let chunk_index; let samples_offset = ''
-  let chunk_start = stsc.entries.filter((item) => {
-    return item.first_sample <= sample_order && sample_order < item.first_sample + item.chunk_count * item.samples_per_chunk
-  })[0]
+  // let chunk_start = stsc.entries.filter((item) => {
+  //   return item.first_sample <= sample_order && sample_order < item.first_sample + item.chunk_count * item.samples_per_chunk
+  // })[0]
+  let chunk_start = stscObj[sample_order];
   if (!chunk_start) {
     let last_chunk = stsc.entries.pop()
     stsc.entries.push(last_chunk)
@@ -91,9 +92,11 @@ util.stscOffset = function (stsc, sample_order) {
   }
 }
 
-util.seekSampleOffset = function (stsc, stco, stsz, order, mdatStart) {
-  let chunkOffset = util.stscOffset(stsc, order + 1)
-  let result = stco.entries[chunkOffset.chunk_index - 1] + util.sum.apply(null, stsz.entries.slice(chunkOffset.samples_offset[0] - 1, chunkOffset.samples_offset[1] - 1)) - mdatStart
+util.seekSampleOffset = function (stsc, stco, stsz, order, mdatStart, stscObj) {
+  let chunkOffset = util.stscOffset(stsc, order + 1, stscObj)
+  let sum =  util.sum.apply(null, stsz.entries.slice(chunkOffset.samples_offset[0] - 1, chunkOffset.samples_offset[1] - 1))
+  let ss = stco.entries[chunkOffset.chunk_index - 1]
+  let result = ss + sum - mdatStart
   if (result === undefined) {
     throw `result=${result},stco.length=${stco.entries.length},sum=${util.sum.apply(null, stsz.entries.slice(0, order))}`
   } else if (result < 0) {
@@ -102,7 +105,7 @@ util.seekSampleOffset = function (stsc, stco, stsz, order, mdatStart) {
   return result
 }
 
-util.seekSampleTime = function (stts, ctts, order, time_offset=0) {
+util.seekSampleTime = function (stts, cttsObj, order) {
   let time; let duration; let count = 0; let startTime = 0; let offset = 0
   stts.entry.every(item => {
     duration = item.sampleDuration
@@ -115,22 +118,14 @@ util.seekSampleTime = function (stts, ctts, order, time_offset=0) {
       return true
     }
   })
-  if (ctts) {
-    let ct = 0
-    ctts.entry.every(item => {
-      ct += item.count
-      if (order < ct) {
-        offset = item.offset
-        return false
-      } else {
-        return true
-      }
-    })
+  if (cttsObj) {
+    if(cttsObj[order]){
+      offset = cttsObj[order]
+    }
   }
   if (!time) {
     time = startTime + (order - count) * duration
   }
-  time -= time_offset
   return {time, duration, offset}
 }
 
@@ -159,4 +154,127 @@ util.seekTrakDuration = function (trak, timeScale) {
   return Number(duration / timeScale).toFixed(4)
 }
 
+util.StringToArrayBuffer = function (str) {
+  let arr = new ArrayBuffer(str.length)
+  let view = new Uint8Array(arr)
+  for (let i = 0; i < str.length; i++) {
+    view[i] = str.charCodeAt(i)
+  }
+  return arr
+}
+/**
+ * Convert a hex string to a Uint8Array.
+ * @param {string} str
+ * @return {!Uint8Array}
+ * @export
+ */
+util.fromHex = function (str) {
+  let arr = new Uint8Array(str.length / 2)
+  for (let i = 0; i < str.length; i += 2) {
+    arr[i / 2] = window.parseInt(str.substr(i, 2), 16)
+  }
+  return arr
+}
+util.fromCharCode = function (array) {
+  let max = 16000
+  let ret = ''
+  for (let i = 0; i < array.length; i += max) {
+    let subArray = array.subarray(i, i + max)
+    ret += String.fromCharCode.apply(null, subArray)
+  }
+
+  return ret
+}
+util.ArrayBufferToString = function (arr) {
+  let str = ''
+  let view = new Uint8Array(arr)
+  for (let i = 0; i < view.length; i++) {
+    str += String.fromCharCode(view[i])
+  }
+  return str
+}
+util.Base64ToHex = function (str) {
+  let bin = window.atob(str.replace(/-/g, '+').replace(/_/g, '/'))
+  let res = ''
+  for (let i = 0; i < bin.length; i++) {
+    res += ('0' + bin.charCodeAt(i).toString(16)).substr(-2)
+  }
+  return res
+}
+
+/**
+ * Convert a Uint8Array to a base64 string.  The output will always use the
+ * alternate encoding/alphabet also known as "base64url".
+ * @param {!Uint8Array} arr
+ * @param {boolean=} padding If true, pad the output with equals signs.
+ *   Defaults to true.
+ * @return {string}
+ * @export
+ */
+util.toBase64 = function (arr, padding) {
+  // btoa expects a "raw string" where each character is interpreted as a byte.
+  let bytes = util.fromCharCode(arr)
+  padding = (padding === undefined) ? true : padding
+  let base64 = window.btoa(bytes).replace(/\+/g, '-').replace(/\//g, '_')
+  return padding ? base64 : base64.replace(/=*$/, '')
+}
+
+util.toUTF8 = function (str) {
+  // http://stackoverflow.com/a/13691499
+  // Converts the given string to a URI encoded string.  If a character falls
+  // in the ASCII range, it is not converted; otherwise it will be converted to
+  // a series of URI escape sequences according to UTF-8.
+  // Example: 'g#€' -> 'g#%E3%82%AC'
+  let encoded = encodeURIComponent(str)
+  // Convert each escape sequence individually into a character.  Each escape
+  // sequence is interpreted as a code-point, so if an escape sequence happens
+  // to be part of a multi-byte sequence, each byte will be converted to a
+  // single character.
+  // Example: 'g#%E3%82%AC' -> '\x67\x35\xe3\x82\xac'
+  let utf8 = unescape(encoded)
+
+  let result = new Uint8Array(utf8.length)
+  for (let i = 0; i < utf8.length; ++i) {
+    result[i] = utf8.charCodeAt(i)
+  }
+  return result.buffer
+}
+
+util.bufferToString = function (value) {
+  return ("0"+(Number(value).toString(16))).slice(-2).toUpperCase()
+}
+util.strToBuf = function (str) {
+  let buffer = []
+  for(let i = 0; i < str.length; i = i + 2) {
+    buffer.push(
+      parseInt(str[i] + str[i + 1], 16)
+    )
+  }
+  return new Uint8Array(buffer)
+}
+util.str2hex = function (str) {
+  if(str === "") {
+    return ""
+  }
+  let arr = [];
+  for(let i = 0; i < str.length; i++) {
+    arr.push(str.charCodeAt(i))
+  }
+  return arr
+}
+util.parse = function (a) {
+  if (!Array.isArray(a)) {
+    let arr = [];
+    let value = '';
+    for(let i = 0; i < a.length; i++) {
+      if (i % 2) {
+        value = a[i - 1] + a[ i ]
+        arr.push(parseInt(value, 16))
+        value = ''
+      }
+    }
+    return arr
+  }
+  return a.map(item => {return parseInt(item, 16)})
+}
 export default util

package/src/util/intervalTimer.js

@@ -0,0 +1,36 @@
+// 替代setInterval
+class IntervalTimer {
+    constructor() {
+        this.timeID = null;
+        this.func = null;
+    }
+
+    repeat(func, ms) {
+        this.timeID = 1;
+        this.repeatInterval(func, ms);
+    }
+
+    repeatInterval(func, ms) {
+        if (!this.timeID) return;
+        if (this.func === null) {
+            this.func = func;
+        }
+
+        if (this.func !== func) {
+            return;
+        }
+        if (this.timeID) clearTimeout(this.timeID);
+        this.timeID = null;
+        this.timeID = setTimeout(() => {
+            func();
+            this.repeatInterval(func, ms);
+        }, ms);
+    }
+
+    clear() {
+        clearTimeout(this.timeID);
+        this.timeID = null;
+    }
+}
+
+export default IntervalTimer;

package/src/util/isSupport.js

@@ -0,0 +1,20 @@
+exports.isMSBrowser = function () {
+  let ua = window.navigator.userAgent
+  let msie = ua.indexOf('MSIE ')
+  let trident = ua.indexOf('Trident/')
+  return msie > 0 || trident > 0
+}
+
+exports.isMediaSourceSupported = function () {
+  const mediaSource = (window.MediaSource = window.MediaSource || window.WebKitMediaSource)
+  return mediaSource && typeof mediaSource.isTypeSupported === 'function'
+}
+
+exports.isSupported = function () {
+  return exports.isMediaSourceSupported()
+    && !exports.isMSBrowser() 
+}
+
+exports.isSupportedWithXgmse = function () {
+  return !exports.isMSBrowser() 
+}

package/src/util/proxyPromise.js

@@ -0,0 +1,27 @@
+
+export default class ProxyPromise {
+ 
+  constructor() {
+    let resolvePromise;
+    let rejectPromise;
+
+    const promise = new Promise(((resolve, reject) => {
+      resolvePromise = resolve;
+      rejectPromise = reject;
+    }));
+
+    const publicPromise = promise
+    publicPromise.resolve = resolvePromise;
+    publicPromise.reject = rejectPromise;
+
+    return publicPromise;
+  }
+
+
+  /** @param {T=} value */
+  resolve(value) {}
+
+
+  /** @param {*=} reason */
+  reject(reason) {}
+};

package/src/util/timer.js

@@ -0,0 +1,46 @@
+export default class Timer{
+ 
+    constructor(onTick) {
+      this.onTick_ = onTick;
+      this.cancelPending_ = null;
+    }
+
+    tickAfter(delayInSeconds, callback = null) {
+ 
+      this.stop();
+      let alive = true;
+      let timeoutId = null;
+  
+      this.cancelPending_ = () => {
+        window.clearTimeout(timeoutId);
+        alive = false;
+      };
+  
+      const onTick = () => {
+        if (alive) {
+          this.onTick_();
+          if(callback){
+              callback();
+          }
+        }
+      };
+  
+      timeoutId = window.setTimeout(onTick, delayInSeconds * 1000);
+  
+      return this;
+    }
+
+    tickEvery(seconds){
+       this.tickAfter(seconds, ()=>{
+           this.tickEvery(seconds);
+       })
+    }
+
+
+    stop() {
+      if (this.cancelPending_) {
+        this.cancelPending_();
+        this.cancelPending_ = null;
+      }
+    }
+  }

package/src/util/xhr.js

@@ -0,0 +1,46 @@
+class XHR {
+  constructor ({url, method = 'GET', type = 'arraybuffer', data = {}} = {}) {
+    return new Promise((resolve, reject) => {
+      let R = new window.XMLHttpRequest()
+      let _method = method.toUpperCase()
+      let _data = []
+      if (type) {
+        R.responseType = type
+      }
+      for (let k in data) {
+        _data.push(`k=${data[k]}`)
+      }
+      if (_method === 'GET') {
+        R.open(_method, `${url}?${_data.join('&')}`)
+        R.send()
+      } else if (_method === 'POST') {
+
+        // if (url.indexOf('data:application/json;base64') === 0) {
+          R.open(_method, url, true)
+          // R.timeout = 0
+          // R.withCredentials = false
+          R.setRequestHeader('Content-Type', 'application/json');
+          R.send(JSON.stringify(data))
+        // } else {
+        //   R.open(_method, url)
+        //   R.setRequestHeader('Content-type', 'application/x-www-form-urlencoded')
+        //   R.send(_data.join('&'))
+        // }
+      } else {
+        throw new Error(`xhr ${_method} is not supported`)
+      }
+      R.onload = () => {
+        if (R.status === 200 || R.status === 206) {
+          resolve(R)
+        } else {
+          reject(R)
+        }
+      }
+      R.onerror = () => {
+        reject(R)
+      }
+    })
+  }
+}
+
+export default XHR

package/version.json

@@ -1,3 +1,3 @@
 {
-  "version": "1.2.4"
+  "version": "2.0.2"
 }

package/webpack.config.js

@@ -1,4 +1,6 @@
+const UglifyJsPlugin = require('uglifyjs-webpack-plugin')
 const polyfill = []
+const argv = require('yargs').argv;
 
 const umd = {
   entry: polyfill.concat(['./src/index.js']),
@@ -7,32 +9,24 @@ const umd = {
     path: `${__dirname}/dist`,
     filename: 'index.js',
     library: 'xgplayer-mp4',
+    globalObject: 'this',
     libraryTarget: 'umd'
   },
   mode: 'production',
   module: {
-    rules: [{
-      test: /\.js$/,
-      loader: 'babel-loader'
-    }, {
-      test: /\.scss$/,
-      use: [
-        'style-loader',
-        {
-          loader: 'css-loader',
-          options: {
-            importLoaders: 1,
-            minimize: true
-          }
-        },
-        'postcss-loader',
-        'sass-loader'
-      ]
-    }]
+    rules: [
+      {
+        test: /\.js$/,
+        loader: 'babel-loader'
+      }
+    ]
   },
   externals: {
     'xgplayer': 'xgplayer'
   },
+  node: {
+    fs: 'empty',
+  },
   optimization: {
     minimize: true
   }
@@ -43,34 +37,46 @@ const client = {
   devtool: 'source-map',
   output: {
     path: `${__dirname}/browser`,
-    filename: 'index.js'
+    filename: 'index.js',
+    library: 'Mp4Player',
+    libraryTarget: 'window'
   },
+  // devtool: argv.watch ? 'source-map' : 'none',
   module: {
-    rules: [{
-      test: /\.js$/,
-      loader: 'babel-loader'
-    }, {
-      test: /\.scss$/,
-      use: [
-        'style-loader',
-        {
-          loader: 'css-loader',
-          options: {
-            importLoaders: 1,
-            minimize: true
-          }
-        },
-        'postcss-loader',
-        'sass-loader'
-      ]
-    }]
+    rules: [
+      {
+        test: /\.js$/,
+        loader: 'babel-loader'
+      }
+    ]
   },
+  mode: 'production',
   externals: {
     'xgplayer': 'Player'
   },
-  mode: 'production',
+  node: {
+    fs: 'empty',
+  },
   optimization: {
-    minimize: true
+    minimize: true,
+    minimizer: [
+      new UglifyJsPlugin({
+        test: [/\.(js|jsx)$/],
+        exclude: [/node_modules/],
+        parallel: true,
+        sourceMap: true,
+        uglifyOptions: {
+          warnings: false,
+          compress: {
+            inline: 1,
+            keep_fnames: true
+          },
+          mangle: {
+            keep_fnames: true
+          }
+        }
+      })
+    ],
   }
 }
 

package/src/util/download.js

@@ -1,13 +0,0 @@
-class Download {
-  constructor (filename, content) {
-    let aLink = document.createElement('a')
-    let blob = new Blob([content])
-    let evt = document.createEvent('MouseEvents')
-    evt.initEvent('click', false, false)
-    aLink.download = filename
-    aLink.href = URL.createObjectURL(blob)
-    aLink.dispatchEvent(evt)
-  }
-}
-
-export default Download

package/src/write/box/MP4DecConfigDescrTag.js

@@ -1,21 +0,0 @@
-import Box from '../box'
-import Stream from '../stream'
-Box.MP4DecConfigDescrTag = function (data, output) {
-  let stream = new Stream(new Uint8Array(data.size).buffer)
-  stream.writeUint8(data.type)
-  if (data.extend) {
-    for (let i = 0; i < 3; i++) {
-      stream.writeUint8(0x80)
-    }
-    stream.writeUint8(data.size - 5)
-  } else {
-    stream.writeUint8(data.size - 2)
-  }
-  stream.writeUint8(data.typeID)
-  stream.writeUint8(data.streamUint)
-  stream.writeUint24(data.bufferSize)
-  stream.writeUint32(data.maximum)
-  stream.writeUint32(data.average)
-  output.write(new Uint8Array(stream.buffer.slice(0, stream.position)))
-  Box.MP4DecSpecificDescrTag(data.subBox[0], output)
-}

package/src/write/box/MP4DecSpecificDescrTag.js

@@ -1,19 +0,0 @@
-import Box from '../box'
-import Stream from '../stream'
-
-Box.MP4DecSpecificDescrTag = function (data, output) {
-  let stream = new Stream(new Uint8Array(data.size).buffer)
-  stream.writeUint8(data.type)
-  if (data.extend) {
-    for (let i = 0; i < 3; i++) {
-      stream.writeUint8(0x80)
-    }
-    stream.writeUint8(data.size - 5)
-  } else {
-    stream.writeUint8(data.size - 2)
-  }
-  data.EScode.forEach(item => {
-    stream.writeUint8(Number(`0x${item}`))
-  })
-  output.write(new Uint8Array(stream.buffer.slice(0, stream.position)))
-}

package/src/write/box/MP4ESDescrTag.js

@@ -1,19 +0,0 @@
-import Box from '../box'
-import Stream from '../stream'
-Box.MP4ESDescrTag = function (data, output) {
-  let stream = new Stream(new Uint8Array(data.size).buffer)
-  stream.writeUint8(data.type)
-  if (data.extend) {
-    for (let i = 0; i < 3; i++) {
-      stream.writeUint8(0x80)
-    }
-    stream.writeUint8(data.size - 5)
-  } else {
-    stream.writeUint8(data.size - 2)
-  }
-  stream.writeUint16(data.esID)
-  stream.writeUint8(data.priority)
-  output.write(new Uint8Array(stream.buffer.slice(0, stream.position)))
-  Box.MP4DecConfigDescrTag(data.subBox[0], output)
-  Box.SLConfigDescriptor(data.subBox[1], output)
-}

package/src/write/box/SLConfigDescriptor.js

@@ -1,16 +0,0 @@
-import Box from '../box'
-import Stream from '../stream'
-Box.SLConfigDescriptor = function (data, output) {
-  let stream = new Stream(new Uint8Array(data.size).buffer)
-  stream.writeUint8(data.type)
-  if (data.extend) {
-    for (let i = 0; i < 3; i++) {
-      stream.writeUint8(0x80)
-    }
-    stream.writeUint8(data.size - 5)
-  } else {
-    stream.writeUint8(data.size - 2)
-  }
-  stream.writeUint8(data.SL)
-  output.write(new Uint8Array(stream.buffer.slice(0, stream.position)))
-}

package/src/write/box/avc1.js

@@ -1,33 +0,0 @@
-import Box from '../box'
-Box.avc1 = function (data, output) {
-  let stream = this.stream
-  stream.fill(6)
-  stream.writeUint16(data.dataReferenceIndex)
-  stream.fill(16)
-  stream.writeUint16(data.width)
-  stream.writeUint16(data.height)
-  stream.writeUint32(data.horizresolution)
-  stream.writeUint32(data.vertresolution)
-  stream.fill(4)
-  stream.writeUint16(data.frameCount)
-  stream.fill(32)
-  stream.writeUint16(data.depth)
-  stream.fill(2)
-  output.write(new Uint8Array(stream.buffer.slice(0, stream.position)))
-  let self = this
-  data.subBox.forEach(item => {
-    let box = new Box(item, self.output)
-    self.subBox.push(box)
-    box.writeBody()
-  })
-  let writeSize = stream.position
-  self.subBox.forEach(item => {
-    writeSize += item.stream.position + 8
-  })
-  if (writeSize !== data.size - 8) {
-    throw new Error(`${data.type} box incomplete`)
-  } else {
-    self.outputSize = writeSize
-  }
-  delete this.data
-}

package/src/write/box/avcC.js

@@ -1,32 +0,0 @@
-import Box from '../box'
-Box.avcC = function (data, output) {
-  let stream = this.stream
-  stream.writeUint8(data.configVersion)
-  stream.writeUint8(data.profile)
-  stream.writeUint8(data.profileCompatibility)
-  stream.writeUint8(data.AVCLevelIndication)
-  stream.writeUint8(data.lengthSizeMinusOne - 1)
-  stream.writeUint8(data.numOfSequenceParameterSets)
-  stream.writeUint16(data.sequenceLength)
-  data.sequence.forEach(item => {
-    stream.writeUint8(Number('0x' + item))
-  })
-  stream.writeUint8(data.ppsCount)
-  stream.writeUint16(data.ppsLength)
-  data.pps.forEach(item => {
-    stream.writeUint8(Number('0x' + item))
-  })
-  if (data.last.length) {
-    data.last.forEach(item => {
-      stream.writeUint8(item)
-    })
-  }
-
-  output.write(new Uint8Array(stream.buffer.slice(0, stream.position)))
-  if (stream.position !== data.size - 8) {
-    throw new Error(`${data.type} box incomplete`)
-  } else {
-    this.outputSize = stream.position
-  }
-  delete this.data
-}

package/src/write/box/btrt.js

@@ -1,14 +0,0 @@
-import Box from '../box';
-Box.btrt = function (data, output) {
-    let stream = this.stream;
-    stream.writeUint32(this.bufferSizeDB);
-    stream.writeUint32(this.maxBitrate);
-    stream.writeUint32(this.avgBitrate);
-    output.write(new Uint8Array(stream.buffer.slice(0, stream.position)));
-    if (stream.position !== data.size - 8) {
-        throw `${data.type} box incomplete`;
-    } else {
-        this.outputSize = stream.position;
-    }
-    delete this.data;
-};