shaka-player 4.12.4 → 4.12.6

package/lib/transmuxer/h264.js

@@ -196,71 +196,28 @@ shaka.transmuxer.H264 = class {
   }
 
   /**
-   * @param {!Array.<shaka.extern.VideoNalu>} nalus
-   * @return {?{data: !Uint8Array, isKeyframe: boolean}}
+   * @param {!Array.<shaka.extern.MPEG_PES>} videoData
+   * @return {!Array.<shaka.extern.VideoSample>}
    */
-  static parseFrame(nalus) {
+  static getVideoSamples(videoData) {
     const H264 = shaka.transmuxer.H264;
-    let isKeyframe = false;
-    const nalusData = [];
-    const spsNalu = nalus.find((nalu) => {
-      return nalu.type == H264.NALU_TYPE_SPS_;
-    });
-    let avcSample = false;
-    for (const nalu of nalus) {
-      let push = false;
-      switch (nalu.type) {
-        case H264.NALU_TYPE_NDR_: {
-          avcSample = true;
-          push = true;
-          const data = nalu.data;
-          // Only check slice type to detect KF in case SPS found in same packet
-          // (any keyframe is preceded by SPS ...)
-          if (spsNalu && data.length > 4) {
-            // retrieve slice type by parsing beginning of NAL unit (follow
-            // H264 spec,slice_header definition) to detect keyframe embedded
-            // in NDR
-            const sliceType = new shaka.util.ExpGolomb(data).readSliceType();
-            // 2 : I slice, 4 : SI slice, 7 : I slice, 9: SI slice
-            // SI slice : A slice that is coded using intra prediction only and
-            // using quantisation of the prediction samples.
-            // An SI slice can be coded such that its decoded samples can be
-            // constructed identically to an SP slice.
-            // I slice: A slice that is not an SI slice that is decoded using
-            // intra prediction only.
-            if (sliceType === 2 || sliceType === 4 ||
-                sliceType === 7 || sliceType === 9) {
-              isKeyframe = true;
-            }
-          }
-          break;
-        }
-        case H264.NALU_TYPE_IDR_:
-          avcSample = true;
-          push = true;
-          isKeyframe = true;
-          break;
-        case H264.NALU_TYPE_SEI_:
-          push = true;
-          break;
-        case H264.NALU_TYPE_SPS_:
-          push = true;
-          break;
-        case H264.NALU_TYPE_PPS_:
-          push = true;
-          break;
-        case H264.NALU_TYPE_AUD_:
-          push = true;
-          avcSample = true;
-          break;
-        case H264.NALU_TYPE_FILLER_DATA_:
-          push = true;
-          break;
-        default:
-          push = false;
-          break;
+
+    /** @type {!Array.<shaka.extern.VideoSample>} */
+    const videoSamples = [];
+    /** @type {?shaka.extern.VideoSample} */
+    let lastVideoSample = null;
+    /** @type {boolean} */
+    let audFound = false;
+
+    const addLastVideoSample = () => {
+      if (!lastVideoSample) {
+        return;
       }
-      if (avcSample && push) {
+      if (!lastVideoSample.nalus.length || !lastVideoSample.frame) {
+        return;
+      }
+      const nalusData = [];
+      for (const nalu of lastVideoSample.nalus) {
         const size = nalu.fullData.byteLength;
         const naluLength = new Uint8Array(4);
         naluLength[0] = (size >> 24) & 0xff;
@@ -270,15 +227,131 @@ shaka.transmuxer.H264 = class {
         nalusData.push(naluLength);
         nalusData.push(nalu.fullData);
       }
-    }
-    if (!nalusData.length) {
-      return null;
-    }
-    const data = shaka.util.Uint8ArrayUtils.concat(...nalusData);
-    return {
-      data,
-      isKeyframe,
+      lastVideoSample.data = shaka.util.Uint8ArrayUtils.concat(...nalusData);
+      videoSamples.push(lastVideoSample);
+    };
+
+    const createLastVideoSample = (pes) => {
+      lastVideoSample = {
+        data: new Uint8Array([]),
+        frame: false,
+        isKeyframe: false,
+        pts: pes.pts,
+        dts: pes.dts,
+        nalus: [],
+      };
     };
+
+    for (let i = 0; i < videoData.length; i++) {
+      const pes = videoData[i];
+      const nalus = pes.nalus;
+      let spsFound = false;
+
+      // If new NAL units found and last sample still there, let's push ...
+      // This helps parsing streams with missing AUD
+      // (only do this if AUD never found)
+      if (lastVideoSample && nalus.length && !audFound) {
+        addLastVideoSample();
+        createLastVideoSample(pes);
+      }
+
+      for (const nalu of pes.nalus) {
+        let push = false;
+        switch (nalu.type) {
+          case H264.NALU_TYPE_NDR_: {
+            let isKeyframe = false;
+            push = true;
+            const data = nalu.data;
+            // Only check slice type to detect KF in case SPS found in same
+            // packet (any keyframe is preceded by SPS ...)
+            if (spsFound && data.length > 4) {
+              // retrieve slice type by parsing beginning of NAL unit (follow
+              // H264 spec,slice_header definition) to detect keyframe embedded
+              // in NDR
+              const sliceType = new shaka.util.ExpGolomb(data).readSliceType();
+              // 2 : I slice, 4 : SI slice, 7 : I slice, 9: SI slice
+              // SI slice : A slice that is coded using intra prediction only
+              // and using quantisation of the prediction samples.
+              // An SI slice can be coded such that its decoded samples can be
+              // constructed identically to an SP slice.
+              // I slice: A slice that is not an SI slice that is decoded using
+              // intra prediction only.
+              if (sliceType === 2 || sliceType === 4 ||
+                  sliceType === 7 || sliceType === 9) {
+                isKeyframe = true;
+              }
+            }
+            if (isKeyframe) {
+              // If we have non-keyframe data already, that cannot belong to
+              // the same frame as a keyframe, so force a push
+              if (lastVideoSample &&
+                  lastVideoSample.frame && !lastVideoSample.isKeyframe) {
+                addLastVideoSample();
+                lastVideoSample = null;
+              }
+            }
+            if (!lastVideoSample) {
+              createLastVideoSample(pes);
+            }
+            lastVideoSample.frame = true;
+            lastVideoSample.isKeyframe = isKeyframe;
+            break;
+          }
+          case H264.NALU_TYPE_IDR_: {
+            push = true;
+            // Handle PES not starting with AUD
+            // If we have frame data already, that cannot belong to the same
+            // frame, so force a push
+            if (lastVideoSample &&
+                lastVideoSample.frame && !lastVideoSample.isKeyframe) {
+              addLastVideoSample();
+              lastVideoSample = null;
+            }
+            if (!lastVideoSample) {
+              createLastVideoSample(pes);
+            }
+            lastVideoSample.frame = true;
+            lastVideoSample.isKeyframe = true;
+            break;
+          }
+          case H264.NALU_TYPE_SEI_:
+            push = true;
+            break;
+          case H264.NALU_TYPE_SPS_:
+            push = true;
+            spsFound = true;
+            break;
+          case H264.NALU_TYPE_PPS_:
+            push = true;
+            break;
+          case H264.NALU_TYPE_AUD_:
+            push = true;
+            audFound = true;
+            if (lastVideoSample && lastVideoSample.frame) {
+              addLastVideoSample();
+              lastVideoSample = null;
+            }
+            if (!lastVideoSample) {
+              createLastVideoSample(pes);
+            }
+            break;
+          case H264.NALU_TYPE_FILLER_DATA_:
+            push = true;
+            break;
+          default:
+            push = false;
+            break;
+        }
+        if (lastVideoSample && push) {
+          lastVideoSample.nalus.push(nalu);
+        }
+      }
+    }
+
+    // If last PES packet, push samples
+    addLastVideoSample();
+
+    return videoSamples;
   }
 };
 

package/lib/transmuxer/mp3_transmuxer.js

@@ -34,6 +34,9 @@ shaka.transmuxer.Mp3Transmuxer = class {
 
     /** @private {!Map.<string, !Uint8Array>} */
     this.initSegments = new Map();
+
+    /** @private {?Uint8Array} */
+    this.lastInitSegment_ = null;
   }
 
 
@@ -196,11 +199,16 @@ shaka.transmuxer.Mp3Transmuxer = class {
     } else {
       initSegment = this.initSegments.get(initSegmentKey);
     }
+    const appendInitSegment = this.lastInitSegment_ !== initSegment;
     const segmentData = mp4Generator.segmentData();
-
+    this.lastInitSegment_ = initSegment;
     this.frameIndex_++;
-    const transmuxData = Uint8ArrayUtils.concat(initSegment, segmentData);
-    return Promise.resolve(transmuxData);
+    if (appendInitSegment) {
+      const transmuxData = Uint8ArrayUtils.concat(initSegment, segmentData);
+      return Promise.resolve(transmuxData);
+    } else {
+      return Promise.resolve(segmentData);
+    }
   }
 };
 

package/lib/transmuxer/ts_transmuxer.js

@@ -52,6 +52,9 @@ shaka.transmuxer.TsTransmuxer = class {
 
     /** @private {?shaka.transmuxer.AacTransmuxer} */
     this.aacTransmuxer_ = null;
+
+    /** @private {?Uint8Array} */
+    this.lastInitSegment_ = null;
   }
 
 
@@ -293,11 +296,16 @@ shaka.transmuxer.TsTransmuxer = class {
     } else {
       initSegment = this.initSegments.get(initSegmentKey);
     }
+    const appendInitSegment = this.lastInitSegment_ !== initSegment;
     const segmentData = mp4Generator.segmentData();
-
+    this.lastInitSegment_ = initSegment;
     this.frameIndex_++;
-    const transmuxData = Uint8ArrayUtils.concat(initSegment, segmentData);
-    return Promise.resolve(transmuxData);
+    if (appendInitSegment) {
+      const transmuxData = Uint8ArrayUtils.concat(initSegment, segmentData);
+      return Promise.resolve(transmuxData);
+    } else {
+      return Promise.resolve(segmentData);
+    }
   }
 
 
@@ -312,6 +320,7 @@ shaka.transmuxer.TsTransmuxer = class {
   getAacStreamInfo_(tsParser, stream, duration, reference) {
     const ADTS = shaka.transmuxer.ADTS;
     const timescale = shaka.util.TsParser.Timescale;
+    const Uint8ArrayUtils = shaka.util.Uint8ArrayUtils;
 
     /** @type {!Array.<shaka.util.Mp4Generator.Mp4Sample>} */
     const samples = [];
@@ -320,12 +329,41 @@ shaka.transmuxer.TsTransmuxer = class {
 
     let firstPts = null;
 
+    /** @type {?number} */
+    let nextStartOffset = null;
+    /** @type {?Uint8Array} */
+    let overflowBytes = null;
+
     for (const audioData of tsParser.getAudioData()) {
-      const data = audioData.data;
+      let data = audioData.data;
       if (!data) {
         continue;
       }
       let offset = 0;
+      if (nextStartOffset == -1 && overflowBytes) {
+        data = Uint8ArrayUtils.concat(overflowBytes, audioData.data);
+        nextStartOffset = null;
+      } else if (nextStartOffset != null && overflowBytes) {
+        offset = Math.max(0, nextStartOffset);
+        const missingFrameData =
+            Uint8ArrayUtils.concat(overflowBytes, data.subarray(0, offset));
+        samples.push({
+          data: missingFrameData,
+          size: missingFrameData.byteLength,
+          duration: ADTS.AAC_SAMPLES_PER_FRAME,
+          cts: 0,
+          flags: {
+            isLeading: 0,
+            isDependedOn: 0,
+            hasRedundancy: 0,
+            degradPrio: 0,
+            dependsOn: 2,
+            isNonSync: 0,
+          },
+        });
+        overflowBytes = null;
+        nextStartOffset = null;
+      }
       info = ADTS.parseInfo(data, offset);
       if (!info) {
         throw new shaka.util.Error(
@@ -342,12 +380,16 @@ shaka.transmuxer.TsTransmuxer = class {
       while (offset < data.length) {
         const header = ADTS.parseHeader(data, offset);
         if (!header) {
-          // We will increment one byte each time until we find the header.
-          offset++;
-          continue;
+          overflowBytes = data.subarray(offset, data.length);
+          nextStartOffset = -1;
+          break;
         }
         const length = header.headerLength + header.frameLength;
-        if (offset + length <= data.length) {
+        nextStartOffset = Math.max(0, offset + length - data.length);
+        if (nextStartOffset != 0) {
+          overflowBytes = data.subarray(
+              offset + header.headerLength, offset + length);
+        } else if (offset + length <= data.length) {
           const frameData = data.subarray(
               offset + header.headerLength, offset + length);
 
@@ -865,50 +907,48 @@ shaka.transmuxer.TsTransmuxer = class {
     /** @type {?number} */
     let baseMediaDecodeTime = null;
 
-    const nalus = [];
     const videoData = tsParser.getVideoData();
-    if (!videoData.length) {
+    const videoSamples = H264.getVideoSamples(videoData);
+    if (!videoSamples.length) {
       throw new shaka.util.Error(
           shaka.util.Error.Severity.CRITICAL,
           shaka.util.Error.Category.MEDIA,
           shaka.util.Error.Code.TRANSMUXING_NO_VIDEO_DATA,
           reference ? reference.getUris()[0] : null);
     }
-    for (let i = 0; i < videoData.length; i++) {
-      const pes = videoData[i];
-      const dataNalus = pes.nalus;
-      nalus.push(...dataNalus);
-      const frame = H264.parseFrame(dataNalus);
-      if (!frame) {
-        continue;
-      }
+    for (let i = 0; i < videoSamples.length; i++) {
+      const videoSample = videoSamples[i];
       if (baseMediaDecodeTime == null) {
-        baseMediaDecodeTime = pes.dts;
+        baseMediaDecodeTime = videoSample.dts;
       }
       let duration;
-      if (i + 1 < videoData.length) {
-        duration = (videoData[i + 1].dts || 0) - (pes.dts || 0);
-      } else if (videoData.length > 1) {
-        duration = (pes.dts || 0) - (videoData[i - 1].dts || 0);
+      if (i + 1 < videoSamples.length) {
+        duration = (videoSamples[i + 1].dts || 0) - (videoSample.dts || 0);
+      } else if (videoSamples.length > 1) {
+        duration = (videoSample.dts || 0) - (videoSamples[i - 1].dts || 0);
       } else {
         duration = (reference.endTime - reference.startTime) * timescale;
       }
       samples.push({
-        data: frame.data,
-        size: frame.data.byteLength,
+        data: videoSample.data,
+        size: videoSample.data.byteLength,
         duration: duration,
-        cts: Math.round((pes.pts || 0) - (pes.dts || 0)),
+        cts: Math.round((videoSample.pts || 0) - (videoSample.dts || 0)),
         flags: {
           isLeading: 0,
           isDependedOn: 0,
           hasRedundancy: 0,
           degradPrio: 0,
-          dependsOn: frame.isKeyframe ? 2 : 1,
-          isNonSync: frame.isKeyframe ? 0 : 1,
+          dependsOn: videoSample.isKeyframe ? 2 : 1,
+          isNonSync: videoSample.isKeyframe ? 0 : 1,
         },
       });
     }
 
+    const nalus = [];
+    for (const pes of videoData) {
+      nalus.push(...pes.nalus);
+    }
     const info = H264.parseInfo(nalus);
 
     if (!info || baseMediaDecodeTime == null) {

package/lib/util/drm_utils.js

@@ -113,6 +113,26 @@ shaka.util.DrmUtils = class {
     return drmInfo ? drmInfo.keySystem : '';
   }
 
+  /**
+   * @param {?string} keySystem
+   * @return {boolean}
+   */
+  static isClearKeySystem(keySystem) {
+    return keySystem === 'org.w3.clearkey';
+  }
+
+  /**
+   * @param {?string} keySystem
+   * @return {boolean}
+   */
+  static isWidevineKeySystem(keySystem) {
+    if (keySystem) {
+      return !!keySystem.match(/^com\.widevine\.alpha/);
+    }
+
+    return false;
+  }
+
   /**
    * @param {?string} keySystem
    * @return {boolean}

package/lib/util/mime_utils.js

@@ -179,6 +179,9 @@ shaka.util.MimeUtils = class {
         return 'vvc'; // H266
       case base === 'dvh1':
       case base === 'dvhe':
+        if (profile && profile.startsWith('05')) {
+          return 'dovi-p5'; // Dolby Vision profile 5
+        }
         return 'dovi-hevc'; // Dolby Vision based in HEVC
       case base === 'dvav':
       case base === 'dva1':

package/lib/util/object_utils.js

@@ -89,4 +89,87 @@ shaka.util.ObjectUtils = class {
     }
     return clone;
   }
+
+
+  /**
+   * Constructs a string out of a value, similar to the JSON.stringify method.
+   * Unlike that method, this guarantees that the order of the keys in an
+   * object is alphabetical, so it can be used as a way to reliably compare two
+   * objects.
+   *
+   * @param {?} value
+   * @return {string}
+   */
+  static alphabeticalKeyOrderStringify(value) {
+    if (Array.isArray(value)) {
+      return shaka.util.ObjectUtils.arrayStringify_(value);
+    } else if (typeof value == 'function') {
+      // For safety, skip functions.  For function x,
+      // x.prototype.constructor.prototype === x.prototype, so all functions
+      // contain circular references if treated like Objects.
+      return '';
+    } else if (value instanceof Object) {
+      return shaka.util.ObjectUtils.objectStringify_(value);
+    } else {
+      return JSON.stringify(value);
+    }
+  }
+
+
+  /**
+   * Helper for alphabeticalKeyOrderStringify for objects.
+   *
+   * @param {!Object} obj
+   * @return {string}
+   * @private
+   */
+  static objectStringify_(obj) {
+    // NOTE: This excludes prototype chain keys.  For now, this is intended for
+    // anonymous objects only, so we don't care.  If that changes, go back to a
+    // for-in loop.
+    const keys = Object.keys(obj);
+    // Alphabetically sort the keys, so they will be in a reliable order.
+    keys.sort();
+
+    const terms = [];
+    for (const key of keys) {
+      const escapedKey = JSON.stringify(key);
+      const value = obj[key];
+      if (value !== undefined) {
+        const escapedValue =
+            shaka.util.ObjectUtils.alphabeticalKeyOrderStringify(value);
+        if (escapedValue) {
+          terms.push(escapedKey + ':' + escapedValue);
+        }
+      }
+    }
+    return '{' + terms.join(',') + '}';
+  }
+
+
+  /**
+   * Helper for alphabeticalKeyOrderStringify for arrays.
+   *
+   * This could itself be JSON.stringify, except we want objects within the
+   * array to go through our own stringifiers.
+   *
+   * @param {!Array} arr
+   * @return {string}
+   * @private
+   */
+  static arrayStringify_(arr) {
+    const terms = [];
+    for (let index = 0; index < arr.length; index++) {
+      const escapedKey = index.toString();
+      const value = arr[index];
+      if (value !== undefined) {
+        const escapedValue =
+            shaka.util.ObjectUtils.alphabeticalKeyOrderStringify(value);
+        if (escapedValue) {
+          terms.push(escapedKey + ':' + escapedValue);
+        }
+      }
+    }
+    return '[' + terms.join(',') + ']';
+  }
 };

package/lib/util/platform.js

@@ -780,46 +780,6 @@ shaka.util.Platform = class {
         shaka.log.alwaysWarn('Tizen: Error detecting screen size, default ' +
             'screen size 1920x1080.');
       }
-    } else if (Platform.isXboxOne()) {
-      maxResolution.width = 1920;
-      maxResolution.height = 1080;
-      try {
-        let winRT = undefined;
-
-        // Try to access to WinRT for WebView, if it's not defined,
-        // try to access to WinRT for WebView2, if it's not defined either,
-        // let it throw.
-        if (typeof Windows !== 'undefined') {
-          winRT = Windows;
-        } else {
-          winRT = chrome.webview.hostObjects.sync.Windows;
-        }
-
-        const protectionCapabilities =
-            new winRT.Media.Protection.ProtectionCapabilities();
-        const protectionResult =
-            winRT.Media.Protection.ProtectionCapabilityResult;
-        // isTypeSupported may return "maybe", which means the operation is not
-        // completed. This means we need to retry
-        // https://learn.microsoft.com/en-us/uwp/api/windows.media.protection.protectioncapabilityresult?view=winrt-22621
-        let result = null;
-        const type =
-            'video/mp4;codecs="hvc1,mp4a";features="decode-res-x=3840,' +
-            'decode-res-y=2160,decode-bitrate=20000,decode-fps=30,' +
-            'decode-bpc=10,display-res-x=3840,display-res-y=2160,' +
-            'display-bpc=8"';
-        const keySystem = 'com.microsoft.playready.recommendation';
-        do {
-          result = protectionCapabilities.isTypeSupported(type, keySystem);
-        } while (result === protectionResult.maybe);
-        if (result === protectionResult.probably) {
-          maxResolution.width = 3840;
-          maxResolution.height = 2160;
-        }
-      } catch (e) {
-        shaka.log.alwaysWarn('Xbox: Error detecting screen size, default ' +
-            'screen size 1920x1080.');
-      }
     } else if (Platform.isWebOS()) {
       try {
         const deviceInfo =
@@ -866,6 +826,54 @@ shaka.util.Platform = class {
         maxResolution.width = 1920;
         maxResolution.height = 1080;
       }
+    } else {
+      // For Xbox and UWP apps.
+      let winRT = undefined;
+      try {
+        // Try to access to WinRT for WebView, if it's not defined,
+        // try to access to WinRT for WebView2, if it's not defined either,
+        // let it throw.
+        if (typeof Windows !== 'undefined') {
+          winRT = Windows;
+        } else {
+          winRT = chrome.webview.hostObjects.sync.Windows;
+        }
+      } catch (e) {}
+      if (winRT) {
+        maxResolution.width = 1920;
+        maxResolution.height = 1080;
+        try {
+          const protectionCapabilities =
+              new winRT.Media.Protection.ProtectionCapabilities();
+          const protectionResult =
+              winRT.Media.Protection.ProtectionCapabilityResult;
+          // isTypeSupported may return "maybe", which means the operation
+          // is not completed. This means we need to retry
+          // https://learn.microsoft.com/en-us/uwp/api/windows.media.protection.protectioncapabilityresult?view=winrt-22621
+          let result = null;
+          const type =
+              'video/mp4;codecs="hvc1,mp4a";features="decode-res-x=3840,' +
+              'decode-res-y=2160,decode-bitrate=20000,decode-fps=30,' +
+              'decode-bpc=10,display-res-x=3840,display-res-y=2160,' +
+              'display-bpc=8"';
+          const keySystem = 'com.microsoft.playready.recommendation';
+          do {
+            result = protectionCapabilities.isTypeSupported(type, keySystem);
+          } while (result === protectionResult.maybe);
+          if (result === protectionResult.probably) {
+            maxResolution.width = 3840;
+            maxResolution.height = 2160;
+          }
+        } catch (e) {
+          shaka.log.alwaysWarn('Xbox: Error detecting screen size, default ' +
+              'screen size 1920x1080.');
+        }
+      } else if (Platform.isXboxOne()) {
+        maxResolution.width = 1920;
+        maxResolution.height = 1080;
+        shaka.log.alwaysWarn('Xbox: Error detecting screen size, default ' +
+            'screen size 1920x1080.');
+      }
     }
     return maxResolution;
   }