shaka-player 4.4.3 → 4.5.0

package/lib/util/ts_parser.js

@@ -427,10 +427,34 @@ shaka.util.TsParser = class {
    * @export
    */
   parseAvcNalus(pes, nextPes) {
+    shaka.Deprecate.deprecateFeature(5,
+        'TsParser',
+        'Please use parseNalus function instead.');
+    return this.parseNalus(pes, nextPes);
+  }
+
+  /**
+   * 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.MPEG_PES=} nextPes
+   * @param {?shaka.extern.VideoNalu=} lastNalu
+   * @return {!Array.<shaka.extern.VideoNalu>}
+   * @export
+   */
+  parseNalus(pes, nextPes, 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 +472,6 @@ shaka.util.TsParser = class {
     // Extracted from the first byte.
     let lastNaluType = 0;
 
-    let tryToFinishLastNalu = false;
-
     /** @type {?shaka.extern.VideoNalu} */
     let infoOfLastNalu;
 
@@ -457,25 +479,25 @@ shaka.util.TsParser = class {
       const value = data[i];
       if (!value) {
         numZeros++;
-      } else if (numZeros >= 2 && value == 1 && tryToFinishLastNalu) {
+      } else if (numZeros >= 2 && value == 1 && lastNalu) {
         // 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;
+          return [];
         }
-        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;
+        lastNalu.data = shaka.util.Uint8ArrayUtils.concat(
+            lastNalu.data, data.subarray(0, lastByteToKeep));
+        lastNalu.fullData = shaka.util.Uint8ArrayUtils.concat(
+            lastNalu.fullData, data.subarray(0, lastByteToKeep));
+        return [];
       } else if (numZeros >= 2 && value == 1) {
         // 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 +513,17 @@ shaka.util.TsParser = class {
             time: time,
           };
           nalus.push(nalu);
+        } else if (lastNalu) {
+          const overflow = i - numZeros;
+          if (overflow > 0) {
+            lastNalu.data = shaka.util.Uint8ArrayUtils.concat(
+                lastNalu.data, data.subarray(0, overflow));
+          }
         }
 
         // 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 +531,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,27 +544,17 @@ 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 (nextPes) {
+          this.parseNalus(nextPes, /* nextPes= */ null, infoOfLastNalu);
         }
       }
     }
@@ -540,6 +562,12 @@ shaka.util.TsParser = class {
     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;
   }
 
@@ -664,9 +692,6 @@ 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];
@@ -674,7 +699,7 @@ shaka.util.TsParser = class {
       if (i + 1 < videoData.length) {
         nextPes = videoData[i + 1];
       }
-      nalus.push(...this.parseAvcNalus(pes, nextPes));
+      nalus.push(...this.parseNalus(pes, nextPes));
     }
     return nalus;
   }
@@ -703,6 +728,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 +861,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 +1082,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/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.5 (latest)
+ - v4.4 (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.5.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",

package/roadmap.md

@@ -9,22 +9,32 @@ The goals of future milestones are fluid until we begin that development cycle,
 so the exact milestone for future features is not pre-determined.
 
 Candidate features for future release cycles:
- - Preload API
-   https://github.com/shaka-project/shaka-player/issues/880
  - Official TypeScript defs, generated from source
    https://github.com/shaka-project/shaka-player/issues/1030
  - Background fetch for offline storage
    https://github.com/shaka-project/shaka-player/issues/879
  - Smaller, more modular binary
 
-v4.5 - 2023 Q4 or 2024 Q1
+v4.6 - 2024 Q1
+ - Content Steering
+   https://github.com/shaka-project/shaka-player/issues/5704
+ - Preload API
+   https://github.com/shaka-project/shaka-player/issues/880
+ - New DASH protocol for Low Latency.
+ - ManagedMediaSource
+   https://github.com/shaka-project/shaka-player/issues/5271
+
+=====
+
+v4.5 - 2023 Q4
  - Built-in transmuxer support for muxed content streams (audio+video)
  - Built-in transmuxer support for H265 streams
  - Remove optional mux.js dependency
  - Codec switching
    https://github.com/shaka-project/shaka-player/issues/1528
-
-=====
+ - AES-128 in DASH.
+   https://github.com/shaka-project/shaka-player/issues/5622
+ - AWS Elemental MediaTailor
 
 v4.4 - 2023 Q3
  - Built-in transmuxer for common cases, no mux.js required:

package/shaka-player.uncompiled.js

@@ -72,12 +72,12 @@ goog.require('shaka.transmuxer.ADTS');
 goog.require('shaka.transmuxer.Ec3');
 goog.require('shaka.transmuxer.Ec3Transmuxer');
 goog.require('shaka.transmuxer.H264');
+goog.require('shaka.transmuxer.H265');
 goog.require('shaka.transmuxer.Mp3Transmuxer');
 goog.require('shaka.transmuxer.MpegAudio');
 goog.require('shaka.transmuxer.MpegTsTransmuxer');
 goog.require('shaka.transmuxer.TransmuxerEngine');
 goog.require('shaka.transmuxer.MssTransmuxer');
-goog.require('shaka.transmuxer.MuxjsTransmuxer');
 goog.require('shaka.transmuxer.TsTransmuxer');
 goog.require('shaka.ui.Controls');
 goog.require('shaka.ui.PlayButton');
@@ -100,6 +100,7 @@ goog.require('shaka.ui.Overlay');
 goog.require('shaka.ui.PipButton');
 goog.require('shaka.ui.PlaybackRateSelection');
 goog.require('shaka.ui.PresentationTimeTracker');
+goog.require('shaka.ui.RemoteButton');
 goog.require('shaka.ui.ResolutionSelection');
 goog.require('shaka.ui.RewindButton');
 goog.require('shaka.ui.SkipAdButton');

package/support.html

@@ -38,7 +38,6 @@
 }
 
     </style>
-    <script defer src="node_modules/mux.js/dist/mux.min.js"></script>
     <script src="dist/shaka-player.compiled.js"></script>
     <script>
       function whenLoaded(fn) {

package/test/cast/cast_receiver_integration.js

@@ -139,6 +139,53 @@ filterDescribe('CastReceiver', castReceiverIntegrationSupport, () => {
     }
   });
 
+  describe('state changed event', () => {
+    it('does not trigger a stack overflow', async () => {
+      const p = waitForLoadedData();
+
+      // We had a regression in which polling attributes eventually triggered a
+      // stack overflow because of a state change event that fired every time
+      // we checked the state.  The error itself got swallowed and hidden
+      // inside CastReceiver, but would cause tests to disconnect in some
+      // environments (consistently in GitHub Actions VMs, inconsistently
+      // elsewhere).
+      //
+      // Testing for this is subtle: if we try to catch the error, it will be
+      // caught at a point when the stack has already or is about to overflow.
+      // Then if we call "fail", Jasmine will grow the stack further,
+      // triggering *another* overflow inside of fail(), causing our test to
+      // *pass*.  So we need to fail fast.  The best way I have found is to
+      // catch the very first recursion of pollAttributes_, long before we
+      // overflow, fail, then return early to avoid the actual recursion.
+      const original = /** @type {?} */(receiver).pollAttributes_;
+      let numRecursions = 0;
+      // eslint-disable-next-line no-restricted-syntax
+      /** @type {?} */(receiver).pollAttributes_ = function() {
+        try {
+          if (numRecursions > 0) {
+            fail('Found recursion in pollAttributes_!');
+            return undefined;
+          }
+
+          numRecursions++;
+          return original.apply(receiver, arguments);
+        } finally {
+          numRecursions--;
+        }
+      };
+
+      // Start the process of loading by sending a fake init message.
+      fakeConnectedSenders(1);
+      fakeIncomingMessage({
+        type: 'init',
+        initState: fakeInitState,
+        appData: {},
+      }, mockShakaMessageBus);
+
+      await p;
+    });
+  });
+
   describe('without drm', () => {
     it('sends reasonably-sized updates', async () => {
       // Use an unencrypted asset.