shaka-player 4.4.3 → 4.6.0

package/lib/util/ts_parser.js

@@ -35,6 +35,9 @@ shaka.util.TsParser = class {
     /** @private {!Array.<Uint8Array>} */
     this.videoData_ = [];
 
+    /** @private {!Array.<shaka.extern.MPEG_PES>} */
+    this.videoPes_ = [];
+
     /** @private {?number} */
     this.audioPid_ = null;
 
@@ -44,6 +47,9 @@ shaka.util.TsParser = class {
     /** @private {!Array.<Uint8Array>} */
     this.audioData_ = [];
 
+    /** @private {!Array.<shaka.extern.MPEG_PES>} */
+    this.audioPes_ = [];
+
     /** @private {?number} */
     this.id3Pid_ = null;
 
@@ -58,7 +64,9 @@ shaka.util.TsParser = class {
    */
   clearData() {
     this.videoData_ = [];
+    this.videoPes_ = [];
     this.audioData_ = [];
+    this.audioPes_ = [];
     this.id3Data_ = [];
   }
 
@@ -360,6 +368,7 @@ shaka.util.TsParser = class {
       packetLength: ((data[4] << 8) | data[5]),
       pts: null,
       dts: null,
+      nalus: [],
     };
 
     // if PES parsed length is not zero and greater than total received length,
@@ -427,10 +436,33 @@ shaka.util.TsParser = class {
    * @export
    */
   parseAvcNalus(pes, nextPes) {
+    shaka.Deprecate.deprecateFeature(5,
+        'TsParser',
+        'Please use parseNalus function instead.');
+    return this.parseNalus(pes);
+  }
+
+  /**
+   * Parse AVC and HVC Nalus
+   *
+   * The code is based on hls.js
+   * Credit to https://github.com/video-dev/hls.js/blob/master/src/demux/tsdemuxer.ts
+   *
+   * @param {shaka.extern.MPEG_PES} pes
+   * @param {?shaka.extern.VideoNalu=} lastNalu
+   * @return {!Array.<shaka.extern.VideoNalu>}
+   * @export
+   */
+  parseNalus(pes, lastNalu) {
     const timescale = shaka.util.TsParser.Timescale;
     const time = pes.pts ? pes.pts / timescale : null;
-    let data = pes.data;
-    let len = data.byteLength;
+    const data = pes.data;
+    const len = data.byteLength;
+
+    let naluHeaderSize = 1;
+    if (this.videoCodec_ == 'hvc') {
+      naluHeaderSize = 2;
+    }
 
     // A NALU does not contain is its size.
     // The Annex B specification solves this by requiring ‘Start Codes’ to
@@ -448,8 +480,6 @@ shaka.util.TsParser = class {
     // Extracted from the first byte.
     let lastNaluType = 0;
 
-    let tryToFinishLastNalu = false;
-
     /** @type {?shaka.extern.VideoNalu} */
     let infoOfLastNalu;
 
@@ -457,25 +487,25 @@ shaka.util.TsParser = class {
       const value = data[i];
       if (!value) {
         numZeros++;
-      } else if (numZeros >= 2 && value == 1 && tryToFinishLastNalu) {
-        // If we are scanning the next PES, we need append the data to the
-        // previous Nalu and don't scan for more nalus.
-        const startCodeSize = numZeros > 3 ? 3 : numZeros;
-        const lastByteToKeep = i - startCodeSize;
-        // Optimization
-        if (lastByteToKeep == 0) {
-          break;
-        }
-        infoOfLastNalu.data = shaka.util.Uint8ArrayUtils.concat(
-            infoOfLastNalu.data, data.subarray(0, lastByteToKeep));
-        infoOfLastNalu.fullData = shaka.util.Uint8ArrayUtils.concat(
-            infoOfLastNalu.fullData, data.subarray(0, lastByteToKeep));
-        break;
       } else if (numZeros >= 2 && value == 1) {
+        if (lastNalu && !nalus.length && lastNaluStart == -1) {
+          // If we are scanning the next PES, we need append the data to the
+          // previous Nalu and don't scan for more nalus.
+          const startCodeSize = numZeros > 3 ? 3 : numZeros;
+          const lastByteToKeep = i - startCodeSize;
+          // Optimization
+          if (lastByteToKeep != 0) {
+            const prevData = data.subarray(0, lastByteToKeep);
+            lastNalu.data = shaka.util.Uint8ArrayUtils.concat(
+                lastNalu.data, prevData);
+            lastNalu.fullData = shaka.util.Uint8ArrayUtils.concat(
+                lastNalu.fullData, prevData);
+          }
+        }
         // We just read a start code.  Consume the NALU we passed, if any.
         if (lastNaluStart >= 0) {
-          // Because the start position includes the type, skip the first byte.
-          const firstByteToKeep = lastNaluStart + 1;
+          // Because the start position includes the header size.
+          const firstByteToKeep = lastNaluStart + naluHeaderSize;
 
           // Compute the last byte to keep.  The start code is at most 3 zeros.
           // Any earlier zeros are not part of the start code.
@@ -491,11 +521,20 @@ shaka.util.TsParser = class {
             time: time,
           };
           nalus.push(nalu);
+        } else if (lastNalu && !nalus.length) {
+          const overflow = i - numZeros;
+          if (overflow > 0) {
+            const prevData = data.subarray(0, overflow);
+            lastNalu.data = shaka.util.Uint8ArrayUtils.concat(
+                lastNalu.data, prevData);
+            lastNalu.fullData = shaka.util.Uint8ArrayUtils.concat(
+                lastNalu.fullData, prevData);
+          }
         }
 
         // We just read a start code, so there should be another byte here, at
         // least, for the NALU type.  Check just in case.
-        if (i >= len - 1) {
+        if (i >= len - naluHeaderSize) {
           shaka.log.warning('Malformed TS, incomplete NALU, ignoring.');
           return nalus;
         }
@@ -503,7 +542,11 @@ shaka.util.TsParser = class {
         // Advance and read the type of the next NALU.
         i++;
         lastNaluStart = i;
-        lastNaluType = data[i] & 0x1f;
+        if (this.videoCodec_ == 'hvc') {
+          lastNaluType = (data[i] >> 1) & 0x3f;
+        } else {
+          lastNaluType = data[i] & 0x1f;
+        }
         numZeros = 0;
       } else {
         numZeros = 0;
@@ -512,34 +555,27 @@ shaka.util.TsParser = class {
       // unfinished Nalu, we will try to use the next PES to complete the
       // unfinished Nalu.
       if (i >= (len - 1) && lastNaluStart >= 0 && numZeros >= 0) {
-        if (tryToFinishLastNalu) {
-          infoOfLastNalu.data = shaka.util.Uint8ArrayUtils.concat(
-              infoOfLastNalu.data, data);
-          infoOfLastNalu.fullData = shaka.util.Uint8ArrayUtils.concat(
-              infoOfLastNalu.fullData, data);
-        } else {
-          tryToFinishLastNalu = true;
-          // The rest of the buffer was a NALU.
-          // Because the start position includes the type, skip the first byte.
-          const firstByteToKeep = lastNaluStart + 1;
-          infoOfLastNalu = {
-            data: data.subarray(firstByteToKeep, len),
-            fullData: data.subarray(lastNaluStart, len),
-            type: lastNaluType,
-            time: time,
-          };
-          if (nextPes && pes.packetLength == 0) {
-            data = nextPes.data;
-            len = data.byteLength;
-            i = -1;
-          }
-        }
+        // The rest of the buffer was a NALU.
+        // Because the start position includes the header size.
+        const firstByteToKeep = lastNaluStart + naluHeaderSize;
+        infoOfLastNalu = {
+          data: data.subarray(firstByteToKeep, len),
+          fullData: data.subarray(lastNaluStart, len),
+          type: lastNaluType,
+          time: time,
+        };
       }
     }
 
     if (infoOfLastNalu) {
       nalus.push(infoOfLastNalu);
     }
+    if (!nalus.length && lastNalu) {
+      lastNalu.data = shaka.util.Uint8ArrayUtils.concat(
+          lastNalu.data, data);
+      lastNalu.fullData = shaka.util.Uint8ArrayUtils.concat(
+          lastNalu.fullData, data);
+    }
     return nalus;
   }
 
@@ -574,73 +610,122 @@ shaka.util.TsParser = class {
    * @export
    */
   getAudioData() {
-    const audio = [];
-    for (const audioData of this.audioData_) {
-      const pes = this.parsePES_(audioData);
-      if (pes) {
-        audio.push(pes);
+    if (this.audioData_.length && !this.audioPes_.length) {
+      let sort = false;
+      for (const audioData of this.audioData_) {
+        const pes = this.parsePES_(audioData);
+        if (pes && pes.pts != null && pes.dts != null) {
+          if (this.audioPes_.length &&
+              pes.dts < (this.audioPes_[this.audioPes_.length - 1].dts || 0)) {
+            sort = true;
+          }
+          this.audioPes_.push(pes);
+        } else if (this.audioPes_.length) {
+          const data = pes ? pes.data : audioData;
+          if (!data) {
+            continue;
+          }
+          const previousPes = this.audioPes_.pop();
+          previousPes.data =
+              shaka.util.Uint8ArrayUtils.concat(previousPes.data, data);
+          this.audioPes_.push(previousPes);
+        }
+      }
+      if (sort) {
+        this.audioPes_ = this.audioPes_.sort((a, b) => {
+          const deltadts = (a.dts || 0) - (b.dts || 0);
+          const deltapts = (a.pts || 0) - (b.pts || 0);
+          return deltadts || deltapts;
+        });
       }
     }
-    return audio;
+    return this.audioPes_;
   }
 
   /**
    * Return the audio data
    *
+   * @param {boolean=} naluProcessing
    * @return {!Array.<shaka.extern.MPEG_PES>}
    * @export
    */
-  getVideoData() {
-    const Uint8ArrayUtils = shaka.util.Uint8ArrayUtils;
-    const video = [];
-    for (const videoData of this.videoData_) {
-      const pes = this.parsePES_(videoData);
-      if (pes && pes.pts != null && pes.dts != null) {
-        video.push(pes);
-      } else if (video.length) {
-        const data = pes ? pes.data : videoData;
-        if (!data) {
-          continue;
+  getVideoData(naluProcessing = true) {
+    if (this.videoData_.length && !this.videoPes_.length) {
+      let sort = false;
+      for (const videoData of this.videoData_) {
+        const pes = this.parsePES_(videoData);
+        if (pes && pes.pts != null && pes.dts != null) {
+          if (this.videoPes_.length &&
+              pes.dts < (this.videoPes_[this.videoPes_.length - 1].dts || 0)) {
+            sort = true;
+          }
+          this.videoPes_.push(pes);
+        } else if (this.videoPes_.length) {
+          const data = pes ? pes.data : videoData;
+          if (!data) {
+            continue;
+          }
+          const previousPes = this.videoPes_.pop();
+          previousPes.data =
+              shaka.util.Uint8ArrayUtils.concat(previousPes.data, data);
+          this.videoPes_.push(previousPes);
         }
-        const previousPes = video.pop();
-        previousPes.data =
-            Uint8ArrayUtils.concat(previousPes.data, data);
-        video.push(previousPes);
       }
+      if (naluProcessing) {
+        let lastNalu;
+        for (const pes of this.videoPes_) {
+          pes.nalus = this.parseNalus(pes, lastNalu);
+          if (pes.nalus.length) {
+            lastNalu = pes.nalus[pes.nalus.length - 1];
+          }
+        }
+        this.videoPes_ = this.videoPes_.filter((pes) => {
+          return pes.nalus.length;
+        });
+      }
+      if (sort) {
+        this.videoPes_ = this.videoPes_.sort((a, b) => {
+          const deltadts = (a.dts || 0) - (b.dts || 0);
+          const deltapts = (a.pts || 0) - (b.pts || 0);
+          return deltadts || deltapts;
+        });
+      }
+    }
+    if (!naluProcessing) {
+      const prevVideoPes = this.videoPes_;
+      this.videoPes_ = [];
+      return prevVideoPes;
     }
-    return video;
+    return this.videoPes_;
   }
 
   /**
    * Return the start time for the audio and video
    *
-   * @return {{audio: ?number, video: ?number}}
+   * @param {string} contentType
+   * @return {?number}
    * @export
    */
-  getStartTime() {
+  getStartTime(contentType) {
     const timescale = shaka.util.TsParser.Timescale;
-    let audioStartTime = null;
-    for (const pes of this.getAudioData()) {
-      if (pes && pes.pts != null) {
-        const startTime = Math.min(pes.dts, pes.pts) / timescale;
-        if (audioStartTime == null || audioStartTime > startTime) {
-          audioStartTime = startTime;
-        }
+    if (contentType == 'audio') {
+      let audioStartTime = null;
+      const audioData = this.getAudioData();
+      if (audioData.length) {
+        const pes = audioData[0];
+        audioStartTime = Math.min(pes.dts, pes.pts) / timescale;
       }
-    }
-    let videoStartTime = null;
-    for (const pes of this.getVideoData()) {
-      if (pes && pes.pts != null) {
-        const startTime = Math.min(pes.dts, pes.pts) / timescale;
-        if (videoStartTime == null || videoStartTime > startTime) {
-          videoStartTime = startTime;
-        }
+      return audioStartTime;
+    } else if (contentType == 'video') {
+      let videoStartTime = null;
+      const videoData = this.getVideoData(/* naluProcessing= */ false);
+      if (videoData.length) {
+        const pes = videoData[0];
+        videoStartTime = Math.min(pes.dts, pes.pts) / timescale;
       }
+      return videoStartTime;
     }
-    return {
-      audio: audioStartTime,
-      video: videoStartTime,
-    };
+    return null;
   }
 
   /**
@@ -664,17 +749,8 @@ shaka.util.TsParser = class {
    */
   getVideoNalus() {
     const nalus = [];
-    if (this.videoCodec_ != 'avc') {
-      return nalus;
-    }
-    const videoData = this.getVideoData();
-    for (let i = 0; i < videoData.length; i++) {
-      const pes = videoData[i];
-      let nextPes;
-      if (i + 1 < videoData.length) {
-        nextPes = videoData[i + 1];
-      }
-      nalus.push(...this.parseAvcNalus(pes, nextPes));
+    for (const pes of this.getVideoData()) {
+      nalus.push(...pes.nalus);
     }
     return nalus;
   }
@@ -703,6 +779,19 @@ shaka.util.TsParser = class {
    * @export
    */
   getVideoInfo() {
+    if (this.videoCodec_ == 'hvc') {
+      return this.getHvcInfo_();
+    }
+    return this.getAvcInfo_();
+  }
+
+  /**
+   * Return the video information for AVC
+   *
+   * @return {{height: ?string, width: ?string, codec: ?string}}
+   * @private
+   */
+  getAvcInfo_() {
     const TsParser = shaka.util.TsParser;
     const videoInfo = {
       height: null,
@@ -823,6 +912,146 @@ shaka.util.TsParser = class {
     return videoInfo;
   }
 
+  /**
+   * Return the video information for HVC
+   *
+   * @return {{height: ?string, width: ?string, codec: ?string}}
+   * @private
+   */
+  getHvcInfo_() {
+    const TsParser = shaka.util.TsParser;
+    const videoInfo = {
+      height: null,
+      width: null,
+      codec: null,
+    };
+    const videoNalus = this.getVideoNalus();
+    if (!videoNalus.length) {
+      return videoInfo;
+    }
+    const spsNalu = videoNalus.find((nalu) => {
+      return nalu.type == TsParser.H265_NALU_TYPE_SPS_;
+    });
+    if (!spsNalu) {
+      return videoInfo;
+    }
+
+    const gb = new shaka.util.ExpGolomb(
+        spsNalu.fullData, /* convertEbsp2rbsp= */ true);
+
+    // remove NALu Header
+    gb.readUnsignedByte();
+    gb.readUnsignedByte();
+
+    // SPS
+    gb.readBits(4); // video_paramter_set_id
+    const maxSubLayersMinus1 = gb.readBits(3);
+    gb.readBoolean(); // temporal_id_nesting_flag
+
+    // profile_tier_level begin
+    const generalProfileSpace = gb.readBits(2);
+    const generalTierFlag = gb.readBits(1);
+    const generalProfileIdc = gb.readBits(5);
+    const generalProfileCompatibilityFlags = gb.readBits(32);
+    const generalConstraintIndicatorFlags1 = gb.readUnsignedByte();
+    const generalConstraintIndicatorFlags2 = gb.readUnsignedByte();
+    const generalConstraintIndicatorFlags3 = gb.readUnsignedByte();
+    const generalConstraintIndicatorFlags4 = gb.readUnsignedByte();
+    const generalConstraintIndicatorFlags5 = gb.readUnsignedByte();
+    const generalConstraintIndicatorFlags6 = gb.readUnsignedByte();
+    const generalLevelIdc = gb.readUnsignedByte();
+    const subLayerProfilePresentFlag = [];
+    const subLayerLevelPresentFlag = [];
+    for (let i = 0; i < maxSubLayersMinus1; i++) {
+      subLayerProfilePresentFlag.push(gb.readBoolean());
+      subLayerLevelPresentFlag.push(gb.readBoolean());
+    }
+    if (maxSubLayersMinus1 > 0) {
+      for (let i = maxSubLayersMinus1; i < 8; i++) {
+        gb.readBits(2);
+      }
+    }
+    for (let i = 0; i < maxSubLayersMinus1; i++) {
+      if (subLayerProfilePresentFlag[i]) {
+        gb.readBits(88);
+      }
+      if (subLayerLevelPresentFlag[i]) {
+        gb.readUnsignedByte();
+      }
+    }
+    // profile_tier_level end
+
+    gb.readUnsignedExpGolomb(); // seq_parameter_set_id
+    const chromaFormatIdc = gb.readUnsignedExpGolomb();
+    if (chromaFormatIdc == 3) {
+      gb.readBits(1); // separate_colour_plane_flag
+    }
+    const picWidthInLumaSamples = gb.readUnsignedExpGolomb();
+    const picHeightInLumaSamples = gb.readUnsignedExpGolomb();
+    let leftOffset = 0;
+    let rightOffset = 0;
+    let topOffset = 0;
+    let bottomOffset = 0;
+    const conformanceWindowFlag = gb.readBoolean();
+    if (conformanceWindowFlag) {
+      leftOffset += gb.readUnsignedExpGolomb();
+      rightOffset += gb.readUnsignedExpGolomb();
+      topOffset += gb.readUnsignedExpGolomb();
+      bottomOffset += gb.readUnsignedExpGolomb();
+    }
+
+    const subWc = chromaFormatIdc === 1 || chromaFormatIdc === 2 ? 2 : 1;
+    const subHc = chromaFormatIdc === 1 ? 2 : 1;
+    videoInfo.width =
+        String(picWidthInLumaSamples - (leftOffset + rightOffset) * subWc);
+    videoInfo.height =
+        String(picHeightInLumaSamples - (topOffset + bottomOffset) * subHc);
+
+    const reverseBits = (integer) => {
+      let result = 0;
+      for (let i = 0; i < 32; i++) {
+        result |= ((integer >> i) & 1) << (31 - i);
+      }
+      return result >>> 0;
+    };
+
+    const profileSpace = ['', 'A', 'B', 'C'][generalProfileSpace];
+    const profileCompatibility = reverseBits(generalProfileCompatibilityFlags);
+    const tierFlag = generalTierFlag == 1 ? 'H' : 'L';
+
+    let codec = 'hvc1';
+    codec += '.' + profileSpace + generalProfileIdc;
+    codec += '.' + profileCompatibility.toString(16).toUpperCase();
+    codec += '.' + tierFlag + generalLevelIdc;
+    if (generalConstraintIndicatorFlags6) {
+      codec += '.' +
+          generalConstraintIndicatorFlags6.toString(16).toUpperCase();
+    }
+    if (generalConstraintIndicatorFlags5) {
+      codec += '.' +
+          generalConstraintIndicatorFlags5.toString(16).toUpperCase();
+    }
+    if (generalConstraintIndicatorFlags4) {
+      codec += '.' +
+          generalConstraintIndicatorFlags4.toString(16).toUpperCase();
+    }
+    if (generalConstraintIndicatorFlags3) {
+      codec += '.' +
+          generalConstraintIndicatorFlags3.toString(16).toUpperCase();
+    }
+    if (generalConstraintIndicatorFlags2) {
+      codec += '.' +
+          generalConstraintIndicatorFlags2.toString(16).toUpperCase();
+    }
+    if (generalConstraintIndicatorFlags1) {
+      codec += '.' +
+          generalConstraintIndicatorFlags1.toString(16).toUpperCase();
+    }
+    videoInfo.codec = codec;
+
+    return videoInfo;
+  }
+
   /**
    * Convert a byte to 2 digits of hex.  (Only handles values 0-255.)
    *
@@ -904,6 +1133,14 @@ shaka.util.TsParser.PacketLength_ = 188;
 shaka.util.TsParser.H264_NALU_TYPE_SPS_ = 0x07;
 
 
+/**
+ * NALU type for Sequence Parameter Set (SPS) for H.265.
+ * @const {number}
+ * @private
+ */
+shaka.util.TsParser.H265_NALU_TYPE_SPS_ = 0x21;
+
+
 /**
  * Values of profile_idc that indicate additional fields are included in the
  * SPS.

package/lib/util/uint8array_utils.js

@@ -115,7 +115,11 @@ shaka.util.Uint8ArrayUtils = class {
     const result = new Uint8Array(totalLength);
     let offset = 0;
     for (const arr of varArgs) {
-      result.set(shaka.util.BufferUtils.toUint8(arr), offset);
+      if (arr instanceof Uint8Array) {
+        result.set(arr, offset);
+      } else {
+        result.set(shaka.util.BufferUtils.toUint8(arr), offset);
+      }
       offset += arr.byteLength;
     }
     return result;

package/lib/util/xml_utils.js

@@ -397,6 +397,11 @@ shaka.util.XmlUtils = class {
       return null;
     }
 
+    // Cobalt browser doesn't support document.createNodeIterator.
+    if (!('createNodeIterator' in document)) {
+      return rootElem;
+    }
+
     // SECURITY: Verify that the document does not contain elements from the
     // HTML or SVG namespaces, which could trigger script execution and XSS.
     const iterator = document.createNodeIterator(

package/maintained-branches.md

@@ -2,8 +2,9 @@
 
 We are currently maintaining the following branches of Shaka Player:
 
- - v4.4 (latest)
- - v4.3 (previous, also in use by the Cast Application Framework)
+ - v4.6 (latest)
+ - v4.5 (previous)
+ - v4.3 (in use by the Cast Application Framework)
  - No active LTS branches at this time
 
 Other branches are no longer receiving bug fixes, and we recommend you upgrade

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "shaka-player",
   "description": "DASH/EME video player library",
-  "version": "4.4.3",
+  "version": "4.6.0",
   "homepage": "https://github.com/shaka-project/shaka-player",
   "author": "Google",
   "maintainers": [
@@ -48,11 +48,10 @@
     "karma-sourcemap-loader": "^0.3.8",
     "karma-spec-reporter": "^0.0.34",
     "karma-webdriver-launcher": "^1.0.8",
-    "lcevc_dil.js": "^1.1.20",
+    "lcevc_dec.js": "^1.0.0",
     "less": "https://gitpkg.now.sh/joeyparrish/less.js/packages/less?28c63a43",
     "less-plugin-clean-css": "github:austingardner/less-plugin-clean-css#4e9e77bf",
     "material-design-lite": "^1.3.0",
-    "mux.js": "^6.2.0",
     "open-sans-fonts": "^1.6.2",
     "postcss-less": "^6.0.0",
     "pwacompat": "^2.0.17",
@@ -75,12 +74,11 @@
       "eme-encryption-scheme-polyfill/index.js",
       "es6-promise-polyfill/promise.min.js",
       "google-closure-library/closure/goog/base.js",
-      "lcevc_dil.js/dist/lcevc_dil.min.js",
-      "lcevc_dil.js/dist/liblcevc_dpi.wasm",
+      "lcevc_dec.js/dist/lcevc_dec.min.js",
+      "lcevc_dec.js/dist/liblcevc_dpi.wasm",
       "less/dist/less.js",
       "material-design-lite/dist/material.indigo-blue.min.css",
       "material-design-lite/dist/material.min.js",
-      "mux.js/dist/mux.min.js",
       "popper.js/dist/umd/popper.min.js",
       "pwacompat/pwacompat.min.js",
       "tippy.js/umd/index.min.js",