shaka-player 4.9.8 → 4.9.9

package/lib/cea/mp4_cea_parser.js

@@ -164,53 +164,62 @@ shaka.cea.Mp4CeaParser = class {
     /** @type {!Array<!shaka.extern.ICeaParser.CaptionPacket>} **/
     const captionPackets = [];
 
-    // Fields that are found in MOOF boxes
-    let defaultSampleDuration = this.defaultSampleDuration_;
-    let defaultSampleSize = this.defaultSampleSize_;
     let moofOffset = 0;
-    /** @type {!Array<shaka.util.ParsedTRUNBox>} */
-    let parsedTRUNs = [];
-    let baseMediaDecodeTime = null;
-    let timescale = shaka.cea.CeaUtils.DEFAULT_TIMESCALE_VALUE;
+
+    /** @type {!Array<!shaka.cea.Mp4CeaParser.ParsedTRAF>} */
+    let parsedTRAFs = [];
 
     new Mp4Parser()
         .box('moof', (box) => {
           moofOffset = box.start;
-          // trun box parsing is reset on each moof.
-          parsedTRUNs = [];
+          // traf box parsing is reset on each moof.
+          parsedTRAFs = [];
+          Mp4Parser.children(box);
+        })
+        .box('traf', (box) => {
+          parsedTRAFs.push({
+            baseMediaDecodeTime: null,
+            defaultSampleDuration: this.defaultSampleDuration_,
+            defaultSampleSize: this.defaultSampleSize_,
+            parsedTRUNs: [],
+            timescale: shaka.cea.CeaUtils.DEFAULT_TIMESCALE_VALUE,
+          });
           Mp4Parser.children(box);
         })
-        .box('traf', Mp4Parser.children)
         .fullBox('trun', (box) => {
           goog.asserts.assert(
-              box.version != null && box.flags!=null,
+              box.version != null && box.flags != null,
               'TRUN is a full box and should have a valid version & flags.');
 
+          const lastTRAF = parsedTRAFs[parsedTRAFs.length - 1];
+
           const parsedTRUN = shaka.util.Mp4BoxParsers.parseTRUN(
               box.reader, box.version, box.flags);
-          parsedTRUNs.push(parsedTRUN);
+          lastTRAF.parsedTRUNs.push(parsedTRUN);
         })
         .fullBox('tfhd', (box) => {
           goog.asserts.assert(
               box.flags != null,
               'TFHD is a full box and should have valid flags.');
 
+          const lastTRAF = parsedTRAFs[parsedTRAFs.length - 1];
+
           const parsedTFHD = shaka.util.Mp4BoxParsers.parseTFHD(
               box.reader, box.flags);
 
           // If specified, defaultSampleDuration and defaultSampleSize
           // override the ones specified in the TREX box
-          defaultSampleDuration = parsedTFHD.defaultSampleDuration ||
+          lastTRAF.defaultSampleDuration = parsedTFHD.defaultSampleDuration ||
               this.defaultSampleDuration_;
 
-          defaultSampleSize = parsedTFHD.defaultSampleSize ||
+          lastTRAF.defaultSampleSize = parsedTFHD.defaultSampleSize ||
               this.defaultSampleSize_;
 
           const trackId = parsedTFHD.trackId;
 
           // Get the timescale from the track Id
           if (this.trackIdToTimescale_.has(trackId)) {
-            timescale = this.trackIdToTimescale_.get(trackId);
+            lastTRAF.timescale = this.trackIdToTimescale_.get(trackId);
           }
         })
         .fullBox('tfdt', (box) => {
@@ -218,27 +227,37 @@ shaka.cea.Mp4CeaParser = class {
               box.version != null,
               'TFDT is a full box and should have a valid version.');
 
+          const lastTRAF = parsedTRAFs[parsedTRAFs.length - 1];
+
           const parsedTFDT = shaka.util.Mp4BoxParsers.parseTFDTInaccurate(
               box.reader, box.version);
 
-          baseMediaDecodeTime = parsedTFDT.baseMediaDecodeTime;
+          lastTRAF.baseMediaDecodeTime = parsedTFDT.baseMediaDecodeTime;
         })
         .box('mdat', (box) => {
-          if (baseMediaDecodeTime === null) {
-            // This field should have been populated by the Base Media Decode
-            // Time in the tfdt box.
-            shaka.log.alwaysWarn(
-                'Unable to find base media decode time for CEA captions!');
-            throw new shaka.util.Error(
-                shaka.util.Error.Severity.CRITICAL,
-                shaka.util.Error.Category.TEXT,
-                shaka.util.Error.Code.INVALID_MP4_CEA);
-          }
-
           const offset = moofOffset - box.start - 8;
-          this.parseMdat_(box.reader, baseMediaDecodeTime, timescale,
-              defaultSampleDuration, defaultSampleSize, offset, parsedTRUNs,
-              captionPackets);
+          const initialPosition = box.reader.getPosition();
+          for (const parsedTRAF of parsedTRAFs) {
+            if (parsedTRAF.baseMediaDecodeTime === null) {
+              // This field should have been populated by the Base Media Decode
+              // Time in the tfdt box.
+              shaka.log.alwaysWarn(
+                  'Unable to find base media decode time for CEA captions!');
+              throw new shaka.util.Error(
+                  shaka.util.Error.Severity.CRITICAL,
+                  shaka.util.Error.Category.TEXT,
+                  shaka.util.Error.Code.INVALID_MP4_CEA);
+            }
+            box.reader.seek(initialPosition);
+            this.parseMdat_(box.reader,
+                parsedTRAF.baseMediaDecodeTime,
+                parsedTRAF.timescale,
+                parsedTRAF.defaultSampleDuration,
+                parsedTRAF.defaultSampleSize,
+                offset,
+                parsedTRAF.parsedTRUNs,
+                captionPackets);
+          }
         })
         .parse(mediaSegment, /* partialOkay= */ false);
 
@@ -315,7 +334,7 @@ shaka.cea.Mp4CeaParser = class {
           timeOffset = sampleData[sampleIndex].sampleCompositionTimeOffset || 0;
         }
 
-        const pts = (time + timeOffset)/timescale;
+        const pts = (time + timeOffset) / timescale;
         for (const packet of this.seiProcessor_
             .process(reader.readBytes(naluSize - naluHeaderSize))) {
           captionPackets.push({
@@ -384,5 +403,22 @@ shaka.cea.Mp4CeaParser.CodecBitstreamMap_ = {
   'dvhe': shaka.cea.Mp4CeaParser.BitstreamFormat.H265,
 };
 
+/**
+ * @typedef {{
+ *    baseMediaDecodeTime: ?number,
+ *    defaultSampleDuration: number,
+ *    defaultSampleSize: number,
+ *    parsedTRUNs: !Array<shaka.util.ParsedTRUNBox>,
+ *    timescale: number
+ * }}
+ *
+ * @property {?number} baseMediaDecodeTime
+ * @property {number} defaultSampleDuration
+ * @property {number} defaultSampleSize
+ * @property {!Array<shaka.util.ParsedTRUNBox>} parsedTRUNs
+ * @property {?number} timescale
+ */
+shaka.cea.Mp4CeaParser.ParsedTRAF;
+
 shaka.media.ClosedCaptionParser.registerParser('video/mp4',
     () => new shaka.cea.Mp4CeaParser());

package/lib/hls/hls_parser.js

@@ -2319,24 +2319,32 @@ shaka.hls.HlsParser = class {
           this.config_.hls.disableCodecGuessing) ||
           (this.needsClosedCaptionsDetection_ && type == ContentType.VIDEO &&
           !this.config_.hls.disableClosedCaptionsDetection)) {
-        this.needsClosedCaptionsDetection_ = false;
-
-        const basicInfo = await this.getMediaPlaylistBasicInfo_(
-            playlist, getUris, mediaVariables);
-
-        goog.asserts.assert(
-            type === basicInfo.type, 'Media types should match!');
-
-        if (basicInfo.closedCaptions.size && (!closedCaptions ||
-            closedCaptions.size != basicInfo.closedCaptions.size)) {
-          closedCaptions = basicInfo.closedCaptions;
-          closedCaptionsUpdated = true;
+        let canRequestBasicInfo = playlist.segments.length > 0;
+        if (canRequestBasicInfo) {
+          const segment = playlist.segments[0];
+          if (shaka.hls.Utils.getFirstTagWithName(segment.tags, 'EXT-X-GAP')) {
+            canRequestBasicInfo = false;
+          }
         }
+        if (canRequestBasicInfo) {
+          this.needsClosedCaptionsDetection_ = false;
+          const basicInfo = await this.getMediaPlaylistBasicInfo_(
+              playlist, getUris, mediaVariables);
+
+          goog.asserts.assert(
+              type === basicInfo.type, 'Media types should match!');
+
+          if (basicInfo.closedCaptions.size && (!closedCaptions ||
+              closedCaptions.size != basicInfo.closedCaptions.size)) {
+            closedCaptions = basicInfo.closedCaptions;
+            closedCaptionsUpdated = true;
+          }
 
-        if (!this.codecInfoInManifest_ &&
-            this.config_.hls.disableCodecGuessing) {
-          mimeType = basicInfo.mimeType;
-          codecs = basicInfo.codecs;
+          if (!this.codecInfoInManifest_ &&
+              this.config_.hls.disableCodecGuessing) {
+            mimeType = basicInfo.mimeType;
+            codecs = basicInfo.codecs;
+          }
         }
       }
 
@@ -3944,9 +3952,14 @@ shaka.hls.HlsParser = class {
         'Playlist should have segments!');
     const middleSegmentIdx = Math.trunc((playlist.segments.length - 1) / 2);
 
+    const middleSegment = playlist.segments[middleSegmentIdx];
+    if (shaka.hls.Utils.getFirstTagWithName(middleSegment.tags, 'EXT-X-GAP')) {
+      return this.guessMimeTypeFallback_(contentType);
+    }
+
     const middleSegmentUris = shaka.hls.Utils.constructSegmentUris(
         getUris(),
-        playlist.segments[middleSegmentIdx].verbatimSegmentUri,
+        middleSegment.verbatimSegmentUri,
         variables);
 
     const parsedUri = new goog.Uri(middleSegmentUris[0]);

package/lib/hls/manifest_text_parser.js

@@ -312,4 +312,5 @@ shaka.hls.ManifestTextParser.SEGMENT_TAGS = [
   'EXT-X-KEY',
   'EXT-X-DATERANGE',
   'EXT-X-MAP',
+  'EXT-X-GAP',
 ];

package/lib/media/segment_utils.js

@@ -140,7 +140,7 @@ shaka.media.SegmentUtils = class {
     const SegmentUtils = shaka.media.SegmentUtils;
 
     const audioCodecs = [];
-    const videoCodecs = [];
+    let videoCodecs = [];
 
     let hasAudio = false;
     let hasVideo = false;
@@ -360,6 +360,13 @@ shaka.media.SegmentUtils = class {
         })
 
         .box('colr', (box) => {
+          videoCodecs = videoCodecs.map((codec) => {
+            if (codec.startsWith('av01.')) {
+              return shaka.util.Mp4BoxParsers.updateAV1CodecWithCOLRBox(
+                  codec, box.reader);
+            }
+            return codec;
+          });
           const {videoRange, colorGamut} =
               shaka.util.Mp4BoxParsers.parseCOLR(box.reader);
           realVideoRange = videoRange;

package/lib/media/streaming_engine.js

@@ -2691,7 +2691,10 @@ shaka.media.StreamingEngine = class {
     }
 
     // First fire an error event.
-    this.playerInterface_.onError(error);
+    if (!error.handled ||
+        error.code != shaka.util.Error.Code.SEGMENT_MISSING) {
+      this.playerInterface_.onError(error);
+    }
 
     // If the error was not handled by the application, call the failure
     // callback.

package/lib/player.js

@@ -7459,7 +7459,7 @@ shaka.Player.TYPICAL_BUFFERING_THRESHOLD_ = 0.5;
  * @export
  */
 // eslint-disable-next-line no-useless-concat
-shaka.Player.version = 'v4.9.8' + '-uncompiled';  // x-release-please-version
+shaka.Player.version = 'v4.9.9' + '-uncompiled';  // x-release-please-version
 
 // Initialize the deprecation system using the version string we just set
 // on the player.

package/lib/util/mp4_box_parsers.js

@@ -604,6 +604,42 @@ shaka.util.Mp4BoxParsers = class {
     };
   }
 
+  /**
+   * Parses AV1 codec string with COLR box information.
+   *
+   * AV1 codec info: https://aomediacodec.github.io/av1-isobmff/#codecsparam
+   *
+   * @param {string} codec
+   * @param {!shaka.util.DataViewReader} reader
+   * @return {string}
+   */
+  static updateAV1CodecWithCOLRBox(codec, reader) {
+    const Mp4BoxParsers = shaka.util.Mp4BoxParsers;
+    const initialPosition = reader.getPosition();
+    const data = reader.readBytes(4);
+    let colorType = '';
+    colorType += String.fromCharCode(data[0]);
+    colorType += String.fromCharCode(data[1]);
+    colorType += String.fromCharCode(data[2]);
+    colorType += String.fromCharCode(data[3]);
+    if (colorType === 'nclx') {
+      const colorPrimaries = reader.readUint16();
+      const transferCharacteristics = reader.readUint16();
+      const matrixCoefficients = reader.readUint16();
+      const videoFullRangeFlag = reader.readUint8() >> 7;
+      const codecParts = codec.split('.');
+      if (codecParts.length == 10) {
+        codecParts[6] = Mp4BoxParsers.addLeadingZero_(colorPrimaries);
+        codecParts[7] = Mp4BoxParsers.addLeadingZero_(transferCharacteristics);
+        codecParts[8] = Mp4BoxParsers.addLeadingZero_(matrixCoefficients);
+        codecParts[9] = String(videoFullRangeFlag);
+        codec = codecParts.join('.');
+      }
+    }
+    reader.seek(initialPosition);
+    return codec;
+  }
+
   /**
    * Convert a number to hex
    * @param {number} x

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "shaka-player",
   "description": "DASH/EME video player library",
-  "version": "4.9.8",
+  "version": "4.9.9",
   "homepage": "https://github.com/shaka-project/shaka-player",
   "author": "Google",
   "maintainers": [