shaka-player 4.5.0 → 4.6.0

package/lib/media/segment_prefetch.js

@@ -4,12 +4,15 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+goog.provide('shaka.media.SegmentPrefetch');
+
 goog.require('goog.asserts');
-goog.require('shaka.net.NetworkingEngine');
+goog.require('shaka.log');
 goog.require('shaka.media.InitSegmentReference');
 goog.require('shaka.media.SegmentReference');
-goog.provide('shaka.media.SegmentPrefetch');
-goog.require('shaka.log');
+goog.require('shaka.net.NetworkingEngine');
+goog.require('shaka.util.Uint8ArrayUtils');
+
 
 /**
  * @summary
@@ -37,8 +40,9 @@ shaka.media.SegmentPrefetch = class {
     this.fetchDispatcher_ = fetchDispatcher;
 
     /**
-     * @private {!Map.<shaka.media.SegmentReference,
-     *           !shaka.media.SegmentPrefetchOperation>}
+     * @private {!Map.<
+     *        !(shaka.media.SegmentReference|shaka.media.InitSegmentReference),
+     *        !shaka.media.SegmentPrefetchOperation>}
      */
     this.segmentPrefetchMap_ = new Map();
   }
@@ -47,9 +51,10 @@ shaka.media.SegmentPrefetch = class {
    * Fetch next segments ahead of current segment.
    *
    * @param {(!shaka.media.SegmentReference)} startReference
+   * @param {boolean=} skipFirst
    * @public
    */
-  prefetchSegments(startReference) {
+  prefetchSegments(startReference, skipFirst = false) {
     goog.asserts.assert(this.prefetchLimit_ > 0,
         'SegmentPrefetch can not be used when prefetchLimit <= 0.');
 
@@ -65,6 +70,14 @@ shaka.media.SegmentPrefetch = class {
       return;
     }
     let reference = startReference;
+    if (skipFirst) {
+      reference = iterator.next().value;
+      if (reference &&
+          reference.startTime == startReference.startTime &&
+          reference.endTime == startReference.endTime) {
+        reference = null;
+      }
+    }
     while (this.segmentPrefetchMap_.size < this.prefetchLimit_ &&
             reference != null) {
       // By default doesn't prefech preload partial segments when using
@@ -88,9 +101,38 @@ shaka.media.SegmentPrefetch = class {
     }
   }
 
+  /**
+   * Fetch init segment.
+   *
+   * @param {!shaka.media.InitSegmentReference} initSegmentReference
+   * @public
+   */
+  prefetchInitSegment(initSegmentReference) {
+    goog.asserts.assert(this.prefetchLimit_ > 0,
+        'SegmentPrefetch can not be used when prefetchLimit <= 0.');
+
+    const logPrefix = shaka.media.SegmentPrefetch.logPrefix_(this.stream_);
+    if (!this.stream_.segmentIndex) {
+      shaka.log.info(logPrefix, 'missing segmentIndex');
+      return;
+    }
+
+    if (this.segmentPrefetchMap_.size < this.prefetchLimit_) {
+      if (!this.segmentPrefetchMap_.has(initSegmentReference)) {
+        const segmentPrefetchOperation =
+          new shaka.media.SegmentPrefetchOperation(this.fetchDispatcher_);
+        segmentPrefetchOperation.dispatchFetch(
+            initSegmentReference, this.stream_);
+        this.segmentPrefetchMap_.set(
+            initSegmentReference, segmentPrefetchOperation);
+      }
+    }
+  }
+
   /**
    * Get the result of prefetched segment if already exists.
-   * @param {(!shaka.media.SegmentReference)} reference
+   * @param {!(shaka.media.SegmentReference|shaka.media.InitSegmentReference)}
+   *        reference
    * @param {?function(BufferSource):!Promise=} streamDataCallback
    * @return {?shaka.net.NetworkingEngine.PendingRequest} op
    * @public
@@ -98,8 +140,6 @@ shaka.media.SegmentPrefetch = class {
   getPrefetchedSegment(reference, streamDataCallback) {
     goog.asserts.assert(this.prefetchLimit_ > 0,
         'SegmentPrefetch can not be used when prefetchLimit <= 0.');
-    goog.asserts.assert(reference instanceof shaka.media.SegmentReference,
-        'getPrefetchedSegment is only used for shaka.media.SegmentReference.');
 
     const logPrefix = shaka.media.SegmentPrefetch.logPrefix_(this.stream_);
 
@@ -109,16 +149,30 @@ shaka.media.SegmentPrefetch = class {
         segmentPrefetchOperation.setStreamDataCallback(streamDataCallback);
       }
       this.segmentPrefetchMap_.delete(reference);
-      shaka.log.debug(
-          logPrefix,
-          'reused prefetched segment at time:', reference.startTime,
-          'mapSize', this.segmentPrefetchMap_.size);
+      if (reference instanceof shaka.media.SegmentReference) {
+        shaka.log.debug(
+            logPrefix,
+            'reused prefetched segment at time:', reference.startTime,
+            'mapSize', this.segmentPrefetchMap_.size);
+      } else {
+        shaka.log.debug(
+            logPrefix,
+            'reused prefetched init segment at time, mapSize',
+            this.segmentPrefetchMap_.size);
+      }
       return segmentPrefetchOperation.getOperation();
     } else {
-      shaka.log.debug(
-          logPrefix,
-          'missed segment at time:', reference.startTime,
-          'mapSize', this.segmentPrefetchMap_.size);
+      if (reference instanceof shaka.media.SegmentReference) {
+        shaka.log.debug(
+            logPrefix,
+            'reused prefetched segment at time:', reference.startTime,
+            'mapSize', this.segmentPrefetchMap_.size);
+      } else {
+        shaka.log.debug(
+            logPrefix,
+            'reused prefetched init segment at time, mapSize',
+            this.segmentPrefetchMap_.size);
+      }
       return null;
     }
   }
@@ -174,7 +228,8 @@ shaka.media.SegmentPrefetch = class {
 
   /**
    * Remove a segment from prefetch map and abort it.
-   * @param {(!shaka.media.SegmentReference)} reference
+   * @param {!(shaka.media.SegmentReference|shaka.media.InitSegmentReference)}
+   *        reference
    * @private
    */
   abortPrefetchedSegment_(reference) {
@@ -183,9 +238,13 @@ shaka.media.SegmentPrefetch = class {
     this.segmentPrefetchMap_.delete(reference);
     if (segmentPrefetchOperation) {
       segmentPrefetchOperation.abort();
-      shaka.log.info(
-          logPrefix,
-          'pop and abort prefetched segment at time:', reference.startTime);
+      if (reference instanceof shaka.media.SegmentReference) {
+        shaka.log.info(
+            logPrefix,
+            'pop and abort prefetched segment at time:', reference.startTime);
+      } else {
+        shaka.log.info(logPrefix, 'pop and abort prefetched init segment');
+      }
     }
   }
 
@@ -221,16 +280,25 @@ shaka.media.SegmentPrefetchOperation = class {
   /**
    * Fetch a segments
    *
-   * @param {!shaka.media.SegmentReference}
-   *   reference
+   * @param {!(shaka.media.SegmentReference|shaka.media.InitSegmentReference)}
+   *        reference
    * @param {!shaka.extern.Stream} stream
    * @public
    */
   dispatchFetch(reference, stream) {
+    // We need to store the data, because streamDataCallback_ might not be
+    // available when you start getting the first data.
+    let buffered = new Uint8Array(0);
     this.operation_ = this.fetchDispatcher_(
         reference, stream, async (data) => {
+          if (buffered.byteLength > 0) {
+            buffered = shaka.util.Uint8ArrayUtils.concat(buffered, data);
+          } else {
+            buffered = data;
+          }
           if (this.streamDataCallback_) {
-            await this.streamDataCallback_(data);
+            await this.streamDataCallback_(buffered);
+            buffered = new Uint8Array(0);
           }
         });
   }

package/lib/media/segment_reference.js

@@ -198,13 +198,15 @@ shaka.media.SegmentReference = class {
    *  not available.
    * @param {?shaka.extern.aes128Key=} aes128Key
    *  The segment's AES-128-CBC full segment encryption key and iv.
+   * @param {boolean=} allPartialSegments
+   *  Indicate if the segment has all partial segments
    */
   constructor(
       startTime, endTime, uris, startByte, endByte, initSegmentReference,
       timestampOffset, appendWindowStart, appendWindowEnd,
       partialReferences = [], tilesLayout = '', tileDuration = null,
       syncTime = null, status = shaka.media.SegmentReference.Status.AVAILABLE,
-      aes128Key = null) {
+      aes128Key = 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');
@@ -284,6 +286,24 @@ shaka.media.SegmentReference = class {
 
     /** @type {number} */
     this.discontinuitySequence = 0;
+
+    /** @type {boolean} */
+    this.allPartialSegments = allPartialSegments;
+
+    /** @type {boolean} */
+    this.partial = false;
+
+    /** @type {boolean} */
+    this.lastPartial = false;
+
+    for (const partial of this.partialReferences) {
+      partial.markAsPartial();
+    }
+    if (this.allPartialSegments && this.partialReferences.length) {
+      const lastPartial =
+          this.partialReferences[this.partialReferences.length - 1];
+      lastPartial.markAsLastPartial();
+    }
   }
 
   /**
@@ -359,6 +379,14 @@ shaka.media.SegmentReference = class {
     return this.partialReferences.length > 0;
   }
 
+  /**
+   * Returns true if it contains all partial SegmentReferences.
+   * @return {boolean}
+   */
+  hasAllPartialSegments() {
+    return this.allPartialSegments;
+  }
+
   /**
    * Returns the segment's tiles layout. Only defined in image segments.
    *
@@ -437,6 +465,44 @@ shaka.media.SegmentReference = class {
     return this.independent;
   }
 
+  /**
+   * Mark the reference as partial.
+   *
+   * @export
+   */
+  markAsPartial() {
+    this.partial = true;
+  }
+
+  /**
+   * Returns true if the segment is partial.
+   *
+   * @return {boolean}
+   * @export
+   */
+  isPartial() {
+    return this.partial;
+  }
+
+  /**
+   * Mark the reference as being the last part of the full segment
+   *
+   * @export
+   */
+  markAsLastPartial() {
+    this.lastPartial = true;
+  }
+
+  /**
+   * Returns true if reference as being the last part of the full segment.
+   *
+   * @return {boolean}
+   * @export
+   */
+  isLastPartial() {
+    return this.lastPartial;
+  }
+
   /**
    * Mark the reference as byterange optimization.
    *

package/lib/media/segment_utils.js

@@ -0,0 +1,343 @@
+/*! @license
+ * Shaka Player
+ * Copyright 2016 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('shaka.media.SegmentUtils');
+
+goog.require('goog.asserts');
+goog.require('shaka.log');
+goog.require('shaka.media.ClosedCaptionParser');
+goog.require('shaka.util.BufferUtils');
+goog.require('shaka.util.MimeUtils');
+goog.require('shaka.util.Mp4BoxParsers');
+goog.require('shaka.util.Mp4Parser');
+goog.require('shaka.util.TsParser');
+
+
+/**
+ * @summary Utility functions for segment parsing.
+ */
+shaka.media.SegmentUtils = class {
+  /**
+   * @param {string} mimeType
+   * @return {shaka.media.SegmentUtils.BasicInfo}
+   */
+  static getBasicInfoFromMimeType(mimeType) {
+    const baseMimeType = shaka.util.MimeUtils.getBasicType(mimeType);
+    const type = baseMimeType.split('/')[0];
+    const codecs = shaka.util.MimeUtils.getCodecs(mimeType);
+    return {
+      type: type,
+      mimeType: baseMimeType,
+      codecs: codecs,
+      language: null,
+      height: null,
+      width: null,
+      channelCount: null,
+      sampleRate: null,
+      closedCaptions: new Map(),
+    };
+  }
+
+  /**
+   * @param {!BufferSource} data
+   * @return {?shaka.media.SegmentUtils.BasicInfo}
+   */
+  static getBasicInfoFromTs(data) {
+    const uint8ArrayData = shaka.util.BufferUtils.toUint8(data);
+    const tsParser = new shaka.util.TsParser().parse(uint8ArrayData);
+    const tsCodecs = tsParser.getCodecs();
+    const videoInfo = tsParser.getVideoInfo();
+    const codecs = [];
+    let hasAudio = false;
+    let hasVideo = false;
+    switch (tsCodecs.audio) {
+      case 'aac':
+        codecs.push('mp4a.40.2');
+        hasAudio = true;
+        break;
+      case 'mp3':
+        codecs.push('mp4a.40.34');
+        hasAudio = true;
+        break;
+      case 'ac3':
+        codecs.push('ac-3');
+        hasAudio = true;
+        break;
+      case 'ec3':
+        codecs.push('ec-3');
+        hasAudio = true;
+        break;
+    }
+    switch (tsCodecs.video) {
+      case 'avc':
+        if (videoInfo.codec) {
+          codecs.push(videoInfo.codec);
+        } else {
+          codecs.push('avc1.42E01E');
+        }
+        hasVideo = true;
+        break;
+      case 'hvc':
+        if (videoInfo.codec) {
+          codecs.push(videoInfo.codec);
+        } else {
+          codecs.push('hvc1.1.6.L93.90');
+        }
+        hasVideo = true;
+        break;
+    }
+    if (!codecs.length) {
+      return null;
+    }
+    const onlyAudio = hasAudio && !hasVideo;
+    const closedCaptions = new Map();
+    if (hasVideo) {
+      const captionParser = new shaka.media.ClosedCaptionParser('video/mp2t');
+      captionParser.parseFrom(data);
+      for (const stream of captionParser.getStreams()) {
+        closedCaptions.set(stream, stream);
+      }
+      captionParser.reset();
+    }
+    return {
+      type: onlyAudio ? 'audio' : 'video',
+      mimeType: 'video/mp2t',
+      codecs: codecs.join(', '),
+      language: null,
+      height: videoInfo.height,
+      width: videoInfo.width,
+      channelCount: null,
+      sampleRate: null,
+      closedCaptions: closedCaptions,
+    };
+  }
+
+  /**
+   * @param {?BufferSource} initData
+   * @param {!BufferSource} data
+   * @return {?shaka.media.SegmentUtils.BasicInfo}
+   */
+  static getBasicInfoFromMp4(initData, data) {
+    const Mp4Parser = shaka.util.Mp4Parser;
+    const SegmentUtils = shaka.media.SegmentUtils;
+
+    const codecs = [];
+
+    let hasAudio = false;
+    let hasVideo = false;
+
+    const addCodec = (codec) => {
+      const codecLC = codec.toLowerCase();
+      switch (codecLC) {
+        case 'avc1':
+        case 'avc3':
+          codecs.push(codecLC + '.42E01E');
+          hasVideo = true;
+          break;
+        case 'hev1':
+        case 'hvc1':
+          codecs.push(codecLC + '.1.6.L93.90');
+          hasVideo = true;
+          break;
+        case 'dvh1':
+        case 'dvhe':
+          codecs.push(codecLC + '.05.04');
+          hasVideo = true;
+          break;
+        case 'vp09':
+          codecs.push(codecLC + '.00.10.08');
+          hasVideo = true;
+          break;
+        case 'av01':
+          codecs.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');
+          hasAudio = true;
+          break;
+        case 'ac-3':
+        case 'ec-3':
+        case 'opus':
+        case 'flac':
+          codecs.push(codecLC);
+          hasAudio = true;
+          break;
+      }
+    };
+
+    const codecBoxParser = (box) => addCodec(box.name);
+
+    /** @type {?string} */
+    let language = null;
+    /** @type {?string} */
+    let height = null;
+    /** @type {?string} */
+    let width = null;
+    /** @type {?number} */
+    let channelCount = null;
+    /** @type {?number} */
+    let sampleRate = null;
+
+    new Mp4Parser()
+        .box('moov', Mp4Parser.children)
+        .box('trak', Mp4Parser.children)
+        .fullBox('tkhd', (box) => {
+          goog.asserts.assert(
+              box.version != null,
+              'TKHD is a full box and should have a valid version.');
+          const parsedTKHDBox = shaka.util.Mp4BoxParsers.parseTKHD(
+              box.reader, box.version);
+          height = String(parsedTKHDBox.height);
+          width = String(parsedTKHDBox.width);
+        })
+        .box('mdia', Mp4Parser.children)
+        .fullBox('mdhd', (box) => {
+          goog.asserts.assert(
+              box.version != null,
+              'MDHD is a full box and should have a valid version.');
+          const parsedMDHDBox = shaka.util.Mp4BoxParsers.parseMDHD(
+              box.reader, box.version);
+          language = parsedMDHDBox.language;
+        })
+        .box('minf', Mp4Parser.children)
+        .box('stbl', Mp4Parser.children)
+        .fullBox('stsd', Mp4Parser.sampleDescription)
+
+        // AUDIO
+        // These are the various boxes that signal a codec.
+        .box('mp4a', (box) => {
+          const parsedMP4ABox = shaka.util.Mp4BoxParsers.parseMP4A(box.reader);
+          channelCount = parsedMP4ABox.channelCount;
+          sampleRate = parsedMP4ABox.sampleRate;
+          if (box.reader.hasMoreData()) {
+            Mp4Parser.children(box);
+          } else {
+            codecBoxParser(box);
+          }
+        })
+        .box('esds', (box) => {
+          const parsedESDSBox = shaka.util.Mp4BoxParsers.parseESDS(box.reader);
+          codecs.push(parsedESDSBox.codec);
+          hasAudio = true;
+        })
+        .box('ac-3', codecBoxParser)
+        .box('ec-3', codecBoxParser)
+        .box('opus', codecBoxParser)
+        .box('Opus', codecBoxParser)
+        .box('fLaC', codecBoxParser)
+
+        // 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;
+        })
+        .box('avc3', (box) => {
+          const parsedAVCBox =
+              shaka.util.Mp4BoxParsers.parseAVC(box.reader, box.name);
+          codecs.push(parsedAVCBox.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.
+        // Note: If encrypted, you can only have audio or video, not both.
+        .box('enca', Mp4Parser.visualSampleEntry)
+        .box('encv', Mp4Parser.visualSampleEntry)
+        .box('sinf', Mp4Parser.children)
+        .box('frma', (box) => {
+          const {codec} = shaka.util.Mp4BoxParsers.parseFRMA(box.reader);
+          addCodec(codec);
+        })
+
+        .parse(initData || data, /* partialOkay= */ true);
+    if (!codecs.length) {
+      return null;
+    }
+    const onlyAudio = hasAudio && !hasVideo;
+    const closedCaptions = new Map();
+    if (hasVideo) {
+      const captionParser = new shaka.media.ClosedCaptionParser('video/mp4');
+      if (initData) {
+        captionParser.init(initData);
+      }
+      captionParser.parseFrom(data);
+      for (const stream of captionParser.getStreams()) {
+        closedCaptions.set(stream, stream);
+      }
+      captionParser.reset();
+    }
+    return {
+      type: onlyAudio ? 'audio' : 'video',
+      mimeType: onlyAudio ? 'audio/mp4' : 'video/mp4',
+      codecs: SegmentUtils.filterDuplicateCodecs_(codecs).join(', '),
+      language: language,
+      height: height,
+      width: width,
+      channelCount: channelCount,
+      sampleRate: sampleRate,
+      closedCaptions: closedCaptions,
+    };
+  }
+
+  /**
+   * @param {!Array.<string>} codecs
+   * @return {!Array.<string>} codecs
+   * @private
+   */
+  static filterDuplicateCodecs_(codecs) {
+    // Filter out duplicate codecs.
+    const seen = new Set();
+    const ret = [];
+    for (const codec of codecs) {
+      const shortCodec = shaka.util.MimeUtils.getCodecBase(codec);
+      if (!seen.has(shortCodec)) {
+        ret.push(codec);
+        seen.add(shortCodec);
+      } else {
+        shaka.log.debug('Ignoring duplicate codec');
+      }
+    }
+    return ret;
+  }
+};
+
+
+/**
+ * @typedef {{
+ *   type: string,
+ *   mimeType: string,
+ *   codecs: string,
+ *   language: ?string,
+ *   height: ?string,
+ *   width: ?string,
+ *   channelCount: ?number,
+ *   sampleRate: ?number,
+ *   closedCaptions: Map.<string, string>
+ * }}
+ *
+ * @property {string} type
+ * @property {string} mimeType
+ * @property {string} codecs
+ * @property {?string} language
+ * @property {?string} height
+ * @property {?string} width
+ * @property {?number} channelCount
+ * @property {?number} sampleRate
+ * @property {Map.<string, string>} closedCaptions
+ */
+shaka.media.SegmentUtils.BasicInfo;

package/lib/media/stall_detector.js

@@ -174,9 +174,6 @@ shaka.media.StallDetector.MediaElementImplementation = class {
     if (this.mediaElement_.paused) {
       return false;
     }
-    if (this.mediaElement_.playbackRate == 0) {
-      return false;
-    }
 
     // If we have don't have enough content, we are not stalled, we are
     // buffering.