shaka-player 4.7.12 → 4.8.0

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;