shaka-player 4.7.13 → 4.8.1

package/lib/media/segment_reference.js

@@ -32,11 +32,11 @@ shaka.media.InitSegmentReference = class {
    *   the quality of the media associated with this init segment.
    * @param {(null|number)=} timescale
    * @param {(null|BufferSource)=} segmentData
-   * @param {?shaka.extern.aes128Key=} aes128Key
+   * @param {?shaka.extern.aesKey=} aesKey
    *  The segment's AES-128-CBC full segment encryption key and iv.
    */
   constructor(uris, startByte, endByte, mediaQuality = null, timescale = null,
-      segmentData = null, aes128Key = null) {
+      segmentData = null, aesKey = null) {
     /** @type {function():!Array.<string>} */
     this.getUris = uris;
 
@@ -55,8 +55,8 @@ shaka.media.InitSegmentReference = class {
     /** @type {BufferSource|null} */
     this.segmentData = segmentData;
 
-    /** @type {?shaka.extern.aes128Key} */
-    this.aes128Key = aes128Key;
+    /** @type {?shaka.extern.aesKey} */
+    this.aesKey = aesKey;
 
     /** @type {?string} */
     this.codecs = null;
@@ -206,7 +206,7 @@ shaka.media.SegmentReference = class {
    * @param {shaka.media.SegmentReference.Status=} status
    *  The segment status is used to indicate that a segment does not exist or is
    *  not available.
-   * @param {?shaka.extern.aes128Key=} aes128Key
+   * @param {?shaka.extern.aesKey=} aesKey
    *  The segment's AES-128-CBC full segment encryption key and iv.
    * @param {boolean=} allPartialSegments
    *  Indicate if the segment has all partial segments
@@ -216,7 +216,7 @@ shaka.media.SegmentReference = class {
       timestampOffset, appendWindowStart, appendWindowEnd,
       partialReferences = [], tilesLayout = '', tileDuration = null,
       syncTime = null, status = shaka.media.SegmentReference.Status.AVAILABLE,
-      aes128Key = null, allPartialSegments = false) {
+      aesKey = null, allPartialSegments = false) {
     // A preload hinted Partial Segment has the same startTime and endTime.
     goog.asserts.assert(startTime <= endTime,
         'startTime must be less than or equal to endTime');
@@ -288,8 +288,8 @@ shaka.media.SegmentReference = class {
     /** @type {boolean} */
     this.byterangeOptimization = false;
 
-    /** @type {?shaka.extern.aes128Key} */
-    this.aes128Key = aes128Key;
+    /** @type {?shaka.extern.aesKey} */
+    this.aesKey = aesKey;
 
     /** @type {?shaka.media.SegmentReference.ThumbnailSprite} */
     this.thumbnailSprite = null;
@@ -320,6 +320,9 @@ shaka.media.SegmentReference = class {
 
     /** @type {?string} */
     this.mimeType = null;
+
+    /** @type {BufferSource|null} */
+    this.segmentData = null;
   }
 
   /**
@@ -598,6 +601,38 @@ shaka.media.SegmentReference = class {
       this.offset(offset);
     }
   }
+
+  /**
+   * Set the segment data.
+   *
+   * @param {!BufferSource} segmentData
+   * @export
+   */
+  setSegmentData(segmentData) {
+    this.segmentData = segmentData;
+  }
+
+  /**
+   * Return the segment data.
+   *
+   * @return {?BufferSource}
+   * @export
+   */
+  getSegmentData() {
+    return this.segmentData;
+  }
+
+  /**
+   * Updates the init segment reference and propagates the update to all partial
+   * references.
+   * @param {shaka.media.InitSegmentReference} initSegmentReference
+   */
+  updateInitSegmentReference(initSegmentReference) {
+    this.initSegmentReference = initSegmentReference;
+    for (const partialReference of this.partialReferences) {
+      partialReference.updateInitSegmentReference(initSegmentReference);
+    }
+  }
 };
 
 

package/lib/media/segment_utils.js

@@ -8,8 +8,10 @@ goog.provide('shaka.media.SegmentUtils');
 
 goog.require('goog.asserts');
 goog.require('shaka.log');
+goog.require('shaka.media.Capabilities');
 goog.require('shaka.media.ClosedCaptionParser');
 goog.require('shaka.util.BufferUtils');
+goog.require('shaka.util.ManifestParserUtils');
 goog.require('shaka.util.MimeUtils');
 goog.require('shaka.util.Mp4BoxParsers');
 goog.require('shaka.util.Mp4Parser');
@@ -38,6 +40,7 @@ shaka.media.SegmentUtils = class {
       channelCount: null,
       sampleRate: null,
       closedCaptions: new Map(),
+      videoRange: null,
     };
   }
 
@@ -121,6 +124,7 @@ shaka.media.SegmentUtils = class {
       channelCount: null,
       sampleRate: null,
       closedCaptions: closedCaptions,
+      videoRange: null,
     };
   }
 
@@ -133,7 +137,8 @@ shaka.media.SegmentUtils = class {
     const Mp4Parser = shaka.util.Mp4Parser;
     const SegmentUtils = shaka.media.SegmentUtils;
 
-    const codecs = [];
+    const audioCodecs = [];
+    const videoCodecs = [];
 
     let hasAudio = false;
     let hasVideo = false;
@@ -143,38 +148,38 @@ shaka.media.SegmentUtils = class {
       switch (codecLC) {
         case 'avc1':
         case 'avc3':
-          codecs.push(codecLC + '.42E01E');
+          videoCodecs.push(codecLC + '.42E01E');
           hasVideo = true;
           break;
         case 'hev1':
         case 'hvc1':
-          codecs.push(codecLC + '.1.6.L93.90');
+          videoCodecs.push(codecLC + '.1.6.L93.90');
           hasVideo = true;
           break;
         case 'dvh1':
         case 'dvhe':
-          codecs.push(codecLC + '.05.04');
+          videoCodecs.push(codecLC + '.05.04');
           hasVideo = true;
           break;
         case 'vp09':
-          codecs.push(codecLC + '.00.10.08');
+          videoCodecs.push(codecLC + '.00.10.08');
           hasVideo = true;
           break;
         case 'av01':
-          codecs.push(codecLC + '.0.01M.08');
+          videoCodecs.push(codecLC + '.0.01M.08');
           hasVideo = true;
           break;
         case 'mp4a':
           // We assume AAC, but this can be wrong since mp4a supports
           // others codecs
-          codecs.push('mp4a.40.2');
+          audioCodecs.push('mp4a.40.2');
           hasAudio = true;
           break;
         case 'ac-3':
         case 'ec-3':
         case 'opus':
         case 'flac':
-          codecs.push(codecLC);
+          audioCodecs.push(codecLC);
           hasAudio = true;
           break;
       }
@@ -192,6 +197,11 @@ shaka.media.SegmentUtils = class {
     let channelCount = null;
     /** @type {?number} */
     let sampleRate = null;
+    /** @type {?string} */
+    let realVideoRange = null;
+
+    /** @type {?string} */
+    let baseBox;
 
     new Mp4Parser()
         .box('moov', Mp4Parser.children)
@@ -232,7 +242,7 @@ shaka.media.SegmentUtils = class {
         })
         .box('esds', (box) => {
           const parsedESDSBox = shaka.util.Mp4BoxParsers.parseESDS(box.reader);
-          codecs.push(parsedESDSBox.codec);
+          audioCodecs.push(parsedESDSBox.codec);
           hasAudio = true;
         })
         .box('ac-3', codecBoxParser)
@@ -244,23 +254,110 @@ shaka.media.SegmentUtils = class {
         // VIDEO
         // These are the various boxes that signal a codec.
         .box('avc1', (box) => {
-          const parsedAVCBox =
-              shaka.util.Mp4BoxParsers.parseAVC(box.reader, box.name);
-          codecs.push(parsedAVCBox.codec);
-          hasVideo = true;
+          baseBox = box.name;
+          Mp4Parser.visualSampleEntry(box);
         })
         .box('avc3', (box) => {
-          const parsedAVCBox =
-              shaka.util.Mp4BoxParsers.parseAVC(box.reader, box.name);
-          codecs.push(parsedAVCBox.codec);
+          baseBox = box.name;
+          Mp4Parser.visualSampleEntry(box);
+        })
+        .box('hev1', (box) => {
+          baseBox = box.name;
+          Mp4Parser.visualSampleEntry(box);
+        })
+        .box('hvc1', (box) => {
+          baseBox = box.name;
+          Mp4Parser.visualSampleEntry(box);
+        })
+        .box('dva1', (box) => {
+          baseBox = box.name;
+          Mp4Parser.visualSampleEntry(box);
+        })
+        .box('dvav', (box) => {
+          baseBox = box.name;
+          Mp4Parser.visualSampleEntry(box);
+        })
+        .box('dvh1', (box) => {
+          baseBox = box.name;
+          Mp4Parser.visualSampleEntry(box);
+        })
+        .box('dvhe', (box) => {
+          baseBox = box.name;
+          Mp4Parser.visualSampleEntry(box);
+        })
+        .box('vp09', (box) => {
+          baseBox = box.name;
+          Mp4Parser.visualSampleEntry(box);
+        })
+        .box('av01', (box) => {
+          baseBox = box.name;
+          Mp4Parser.visualSampleEntry(box);
+        })
+        .box('avcC', (box) => {
+          let codecBase = baseBox || '';
+          switch (baseBox) {
+            case 'dvav':
+              codecBase = 'avc3';
+              break;
+            case 'dva1':
+              codecBase = 'avc1';
+              break;
+          }
+          const parsedAVCCBox = shaka.util.Mp4BoxParsers.parseAVCC(
+              codecBase, box.reader, box.name);
+          videoCodecs.push(parsedAVCCBox.codec);
+          hasVideo = true;
+        })
+        .box('hvcC', (box) => {
+          let codecBase = baseBox || '';
+          switch (baseBox) {
+            case 'dvh1':
+              codecBase = 'hvc1';
+              break;
+            case 'dvhe':
+              codecBase = 'hev1';
+              break;
+          }
+          const parsedHVCCBox = shaka.util.Mp4BoxParsers.parseHVCC(
+              codecBase, box.reader, box.name);
+          videoCodecs.push(parsedHVCCBox.codec);
+          hasVideo = true;
+        })
+        .box('dvcC', (box) => {
+          let codecBase = baseBox || '';
+          switch (baseBox) {
+            case 'hvc1':
+              codecBase = 'dvh1';
+              break;
+            case 'hev1':
+              codecBase = 'dvhe';
+              break;
+            case 'avc1':
+              codecBase = 'dva1';
+              break;
+            case 'avc3':
+              codecBase = 'dvav';
+              break;
+          }
+          const parsedDVCCBox = shaka.util.Mp4BoxParsers.parseDVCC(
+              codecBase, box.reader, box.name);
+          videoCodecs.push(parsedDVCCBox.codec);
+          hasVideo = true;
+        })
+        .fullBox('vpcC', (box) => {
+          const codecBase = baseBox || '';
+          const parsedVPCCBox = shaka.util.Mp4BoxParsers.parseVPCC(
+              codecBase, box.reader, box.name);
+          videoCodecs.push(parsedVPCCBox.codec);
+          hasVideo = true;
+        })
+        .box('av1C', (box) => {
+          const codecBase = baseBox || '';
+          const parsedAV1CBox = shaka.util.Mp4BoxParsers.parseAV1C(
+              codecBase, box.reader, box.name);
+          videoCodecs.push(parsedAV1CBox.codec);
           hasVideo = true;
         })
-        .box('hev1', codecBoxParser)
-        .box('hvc1', codecBoxParser)
-        .box('dvh1', codecBoxParser)
-        .box('dvhe', codecBoxParser)
-        .box('vp09', codecBoxParser)
-        .box('av01', codecBoxParser)
 
         // This signals an encrypted sample, which we can go inside of to
         // find the codec used.
@@ -273,8 +370,13 @@ shaka.media.SegmentUtils = class {
           addCodec(codec);
         })
 
+        .box('colr', (box) => {
+          const {videoRange} = shaka.util.Mp4BoxParsers.parseCOLR(box.reader);
+          realVideoRange = videoRange;
+        })
+
         .parse(initData || data, /* partialOkay= */ true);
-    if (!codecs.length) {
+    if (!audioCodecs.length && !videoCodecs.length) {
       return null;
     }
     const onlyAudio = hasAudio && !hasVideo;
@@ -290,19 +392,45 @@ shaka.media.SegmentUtils = class {
       }
       captionParser.reset();
     }
+    const codecs = audioCodecs.concat(videoCodecs);
     return {
       type: onlyAudio ? 'audio' : 'video',
       mimeType: onlyAudio ? 'audio/mp4' : 'video/mp4',
-      codecs: SegmentUtils.filterDuplicateCodecs_(codecs).join(', '),
+      codecs: SegmentUtils.codecsFiltering(codecs).join(', '),
       language: language,
       height: height,
       width: width,
       channelCount: channelCount,
       sampleRate: sampleRate,
       closedCaptions: closedCaptions,
+      videoRange: realVideoRange,
     };
   }
 
+  /**
+   * @param {!Array.<string>} codecs
+   * @return {!Array.<string>} codecs
+   */
+  static codecsFiltering(codecs) {
+    const ContentType = shaka.util.ManifestParserUtils.ContentType;
+    const ManifestParserUtils = shaka.util.ManifestParserUtils;
+    const SegmentUtils = shaka.media.SegmentUtils;
+    const allCodecs = SegmentUtils.filterDuplicateCodecs_(codecs);
+    const audioCodecs =
+        ManifestParserUtils.guessAllCodecsSafe(ContentType.AUDIO, allCodecs);
+    const videoCodecs =
+        ManifestParserUtils.guessAllCodecsSafe(ContentType.VIDEO, allCodecs);
+    const textCodecs =
+        ManifestParserUtils.guessAllCodecsSafe(ContentType.TEXT, allCodecs);
+    const validVideoCodecs = SegmentUtils.chooseBetterCodecs_(videoCodecs);
+    const finalCodecs =
+        audioCodecs.concat(validVideoCodecs).concat(textCodecs);
+    if (allCodecs.length && !finalCodecs.length) {
+      return allCodecs;
+    }
+    return finalCodecs;
+  }
+
   /**
    * @param {!Array.<string>} codecs
    * @return {!Array.<string>} codecs
@@ -323,6 +451,59 @@ shaka.media.SegmentUtils = class {
     }
     return ret;
   }
+
+  /**
+   * Prioritizes Dolby Vision if supported. This is necessary because with
+   * Dolby Vision we could have hvcC and dvcC boxes at the same time.
+   *
+   * @param {!Array.<string>} codecs
+   * @return {!Array.<string>} codecs
+   * @private
+   */
+  static chooseBetterCodecs_(codecs) {
+    if (codecs.length <= 1) {
+      return codecs;
+    }
+    const dolbyVision = codecs.find((codec) => {
+      return codec.startsWith('dvh1.') || codec.startsWith('dvhe.');
+    });
+    if (!dolbyVision) {
+      return codecs;
+    }
+    const type = `video/mp4; codecs="${dolbyVision}"'`;
+    if (shaka.media.Capabilities.isTypeSupported(type)) {
+      return [dolbyVision];
+    }
+    return codecs.filter((codec) => codec != dolbyVision);
+  }
+
+  /**
+   * @param {!BufferSource} data
+   * @return {?string}
+   */
+  static getDefaultKID(data) {
+    const Mp4Parser = shaka.util.Mp4Parser;
+
+    let defaultKID = null;
+    new Mp4Parser()
+        .box('moov', Mp4Parser.children)
+        .box('trak', Mp4Parser.children)
+        .box('mdia', Mp4Parser.children)
+        .box('minf', Mp4Parser.children)
+        .box('stbl', Mp4Parser.children)
+        .fullBox('stsd', Mp4Parser.sampleDescription)
+        .box('encv', Mp4Parser.visualSampleEntry)
+        .box('enca', Mp4Parser.audioSampleEntry)
+        .box('sinf', Mp4Parser.children)
+        .box('schi', Mp4Parser.children)
+        .fullBox('tenc', (box) => {
+          const parsedTENCBox = shaka.util.Mp4BoxParsers.parseTENC(box.reader);
+          defaultKID = parsedTENCBox.defaultKID;
+        })
+
+        .parse(data, /* partialOkay= */ true);
+    return defaultKID;
+  }
 };
 
 
@@ -336,7 +517,8 @@ shaka.media.SegmentUtils = class {
  *   width: ?string,
  *   channelCount: ?number,
  *   sampleRate: ?number,
- *   closedCaptions: Map.<string, string>
+ *   closedCaptions: Map.<string, string>,
+ *   videoRange: ?string
  * }}
  *
  * @property {string} type
@@ -348,5 +530,6 @@ shaka.media.SegmentUtils = class {
  * @property {?number} channelCount
  * @property {?number} sampleRate
  * @property {Map.<string, string>} closedCaptions
+ * @property {?string} videoRange
  */
 shaka.media.SegmentUtils.BasicInfo;