shaka-player 4.4.3 → 4.5.0

package/lib/transmuxer/mpeg_ts_transmuxer.js

@@ -128,8 +128,9 @@ shaka.transmuxer.MpegTsTransmuxer = class {
    * @override
    * @export
    */
-  transmux(data) {
+  transmux(data, stream, reference, duration, contentType) {
     const MpegAudio = shaka.transmuxer.MpegAudio;
+    const ContentType = shaka.util.ManifestParserUtils.ContentType;
     const Uint8ArrayUtils = shaka.util.Uint8ArrayUtils;
 
     if (!this.tsParser_) {
@@ -142,7 +143,7 @@ shaka.transmuxer.MpegTsTransmuxer = class {
 
     const tsParser = this.tsParser_.parse(uint8ArrayData);
     const codecs = tsParser.getCodecs();
-    if (codecs.audio != 'mp3' || codecs.video) {
+    if (codecs.audio != 'mp3' || contentType != ContentType.AUDIO) {
       return Promise.reject(new shaka.util.Error(
           shaka.util.Error.Severity.CRITICAL,
           shaka.util.Error.Category.MEDIA,

package/lib/transmuxer/ts_transmuxer.js

@@ -11,6 +11,7 @@ goog.require('shaka.transmuxer.Ac3');
 goog.require('shaka.transmuxer.ADTS');
 goog.require('shaka.transmuxer.Ec3');
 goog.require('shaka.transmuxer.H264');
+goog.require('shaka.transmuxer.H265');
 goog.require('shaka.transmuxer.MpegAudio');
 goog.require('shaka.transmuxer.TransmuxerEngine');
 goog.require('shaka.util.BufferUtils');
@@ -21,6 +22,8 @@ goog.require('shaka.util.Mp4Generator');
 goog.require('shaka.util.TsParser');
 goog.require('shaka.util.Uint8ArrayUtils');
 
+goog.requireType('shaka.media.SegmentReference');
+
 
 /**
  * @implements {shaka.extern.Transmuxer}
@@ -80,11 +83,6 @@ shaka.transmuxer.TsTransmuxer = class {
     const videoCodec = shaka.util.ManifestParserUtils.guessCodecsSafe(
         ContentType.VIDEO, allCodecs);
 
-    // We don't support muxed content yet.
-    if (audioCodec && videoCodec) {
-      return false;
-    }
-
     const TsTransmuxer = shaka.transmuxer.TsTransmuxer;
 
     if (audioCodec) {
@@ -179,7 +177,11 @@ shaka.transmuxer.TsTransmuxer = class {
         switch (codecs.video) {
           case 'avc':
             streamInfo =
-              this.getAvcStreamInfo_(tsParser, stream, duration);
+              this.getAvcStreamInfo_(tsParser, stream, duration, reference);
+            break;
+          case 'hvc':
+            streamInfo =
+              this.getHvcStreamInfo_(tsParser, stream, duration, reference);
             break;
         }
         if (streamInfo) {
@@ -191,7 +193,7 @@ shaka.transmuxer.TsTransmuxer = class {
         switch (codecs.audio) {
           case 'aac':
             streamInfo =
-              this.getAacStreamInfo_(tsParser, stream, duration);
+              this.getAacStreamInfo_(tsParser, stream, duration, reference);
             break;
           case 'ac3':
             streamInfo =
@@ -242,10 +244,11 @@ shaka.transmuxer.TsTransmuxer = class {
    * @param {shaka.util.TsParser} tsParser
    * @param {shaka.extern.Stream} stream
    * @param {number} duration
+   * @param {?shaka.media.SegmentReference} reference
    * @return {shaka.util.Mp4Generator.StreamInfo}
    * @private
    */
-  getAacStreamInfo_(tsParser, stream, duration) {
+  getAacStreamInfo_(tsParser, stream, duration, reference) {
     const ADTS = shaka.transmuxer.ADTS;
     const timescale = shaka.util.TsParser.Timescale;
 
@@ -306,10 +309,58 @@ shaka.transmuxer.TsTransmuxer = class {
     }
 
     if (!info || firstPts == null) {
-      throw new shaka.util.Error(
-          shaka.util.Error.Severity.CRITICAL,
-          shaka.util.Error.Category.MEDIA,
-          shaka.util.Error.Code.TRANSMUXING_FAILED);
+      if (!tsParser.getVideoData().length) {
+        throw new shaka.util.Error(
+            shaka.util.Error.Severity.CRITICAL,
+            shaka.util.Error.Category.MEDIA,
+            shaka.util.Error.Code.TRANSMUXING_FAILED);
+      }
+
+      firstPts = reference.startTime * timescale;
+
+      const allCodecs = shaka.util.MimeUtils.splitCodecs(stream.codecs);
+      const audioCodec = shaka.util.ManifestParserUtils.guessCodecsSafe(
+          shaka.util.ManifestParserUtils.ContentType.AUDIO, allCodecs);
+      if (!audioCodec || !stream.channelsCount || !stream.audioSamplingRate) {
+        throw new shaka.util.Error(
+            shaka.util.Error.Severity.CRITICAL,
+            shaka.util.Error.Category.MEDIA,
+            shaka.util.Error.Code.TRANSMUXING_FAILED);
+      }
+      info = {
+        sampleRate: stream.audioSamplingRate,
+        channelCount: stream.channelsCount,
+        codec: audioCodec,
+      };
+      const silenceFrame =
+          ADTS.getSilentFrame(audioCodec, stream.channelsCount);
+      if (!silenceFrame) {
+        throw new shaka.util.Error(
+            shaka.util.Error.Severity.CRITICAL,
+            shaka.util.Error.Category.MEDIA,
+            shaka.util.Error.Code.TRANSMUXING_FAILED);
+      }
+      const segmentDuration =
+          (reference.endTime - reference.startTime) * timescale;
+      const finalPTs = firstPts + segmentDuration;
+      let currentPts = firstPts;
+      while (currentPts < finalPTs) {
+        samples.push({
+          data: silenceFrame,
+          size: silenceFrame.byteLength,
+          duration: ADTS.AAC_SAMPLES_PER_FRAME,
+          cts: 0,
+          flags: {
+            isLeading: 0,
+            isDependedOn: 0,
+            hasRedundancy: 0,
+            degradPrio: 0,
+            dependsOn: 2,
+            isNonSync: 0,
+          },
+        });
+        currentPts += ADTS.AAC_SAMPLES_PER_FRAME / info.sampleRate * timescale;
+      }
     }
 
     /** @type {number} */
@@ -609,10 +660,11 @@ shaka.transmuxer.TsTransmuxer = class {
    * @param {shaka.util.TsParser} tsParser
    * @param {shaka.extern.Stream} stream
    * @param {number} duration
+   * @param {?shaka.media.SegmentReference} reference
    * @return {shaka.util.Mp4Generator.StreamInfo}
    * @private
    */
-  getAvcStreamInfo_(tsParser, stream, duration) {
+  getAvcStreamInfo_(tsParser, stream, duration, reference) {
     const H264 = shaka.transmuxer.H264;
     const timescale = shaka.util.TsParser.Timescale;
 
@@ -630,7 +682,7 @@ shaka.transmuxer.TsTransmuxer = class {
       if (i + 1 < videoData.length) {
         nextPes = videoData[i + 1];
       }
-      const dataNalus = tsParser.parseAvcNalus(pes, nextPes);
+      const dataNalus = tsParser.parseNalus(pes, nextPes);
       nalus = nalus.concat(dataNalus);
       const frame = H264.parseFrame(dataNalus);
       if (!frame) {
@@ -642,8 +694,10 @@ shaka.transmuxer.TsTransmuxer = class {
       let duration;
       if (i + 1 < videoData.length) {
         duration = (videoData[i + 1].dts || 0) - (pes.dts || 0);
-      } else {
+      } else if (videoData.length > 1) {
         duration = (pes.dts || 0) - (videoData[i - 1].dts || 0);
+      } else {
+        duration = (reference.endTime - reference.startTime) * timescale;
       }
       samples.push({
         data: frame.data,
@@ -690,6 +744,96 @@ shaka.transmuxer.TsTransmuxer = class {
       stream: stream,
     };
   }
+
+
+  /**
+   * @param {shaka.util.TsParser} tsParser
+   * @param {shaka.extern.Stream} stream
+   * @param {number} duration
+   * @param {?shaka.media.SegmentReference} reference
+   * @return {shaka.util.Mp4Generator.StreamInfo}
+   * @private
+   */
+  getHvcStreamInfo_(tsParser, stream, duration, reference) {
+    const H265 = shaka.transmuxer.H265;
+    const timescale = shaka.util.TsParser.Timescale;
+
+    /** @type {!Array.<shaka.util.Mp4Generator.Mp4Sample>} */
+    const samples = [];
+
+    /** @type {?number} */
+    let baseMediaDecodeTime = null;
+
+    let nalus = [];
+    const videoData = tsParser.getVideoData();
+    for (let i = 0; i < videoData.length; i++) {
+      const pes = videoData[i];
+      let nextPes;
+      if (i + 1 < videoData.length) {
+        nextPes = videoData[i + 1];
+      }
+      const dataNalus = tsParser.parseNalus(pes, nextPes);
+      nalus = nalus.concat(dataNalus);
+      const frame = H265.parseFrame(dataNalus);
+      if (!frame) {
+        continue;
+      }
+      if (baseMediaDecodeTime == null && pes.dts != null) {
+        baseMediaDecodeTime = pes.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);
+      } else {
+        duration = (reference.endTime - reference.startTime) * timescale;
+      }
+      samples.push({
+        data: frame.data,
+        size: frame.data.byteLength,
+        duration: duration,
+        cts: Math.round((pes.pts || 0) - (pes.dts || 0)),
+        flags: {
+          isLeading: 0,
+          isDependedOn: 0,
+          hasRedundancy: 0,
+          degradPrio: 0,
+          dependsOn: frame.isKeyframe ? 2 : 1,
+          isNonSync: frame.isKeyframe ? 0 : 1,
+        },
+      });
+    }
+
+    const info = H265.parseInfo(nalus);
+
+    if (!info || baseMediaDecodeTime == null) {
+      throw new shaka.util.Error(
+          shaka.util.Error.Severity.CRITICAL,
+          shaka.util.Error.Category.MEDIA,
+          shaka.util.Error.Code.TRANSMUXING_FAILED);
+    }
+    stream.height = info.height;
+    stream.width = info.width;
+
+    return {
+      id: stream.id,
+      type: shaka.util.ManifestParserUtils.ContentType.VIDEO,
+      codecs: 'hvc1',
+      encrypted: stream.encrypted && stream.drmInfos.length > 0,
+      timescale: timescale,
+      duration: duration,
+      videoNalus: [],
+      audioConfig: new Uint8Array([]),
+      videoConfig: info.videoConfig,
+      data: {
+        sequenceNumber: this.frameIndex_,
+        baseMediaDecodeTime: baseMediaDecodeTime,
+        samples: samples,
+      },
+      stream: stream,
+    };
+  }
 };
 
 /**
@@ -713,6 +857,7 @@ shaka.transmuxer.TsTransmuxer.SUPPORTED_AUDIO_CODECS_ = [
  */
 shaka.transmuxer.TsTransmuxer.SUPPORTED_VIDEO_CODECS_ = [
   'avc',
+  'hevc',
 ];
 
 

package/lib/util/error.js

@@ -728,15 +728,8 @@ shaka.util.Error.Code = {
    */
   'NO_WEB_CRYPTO_API': 4042,
 
-  /**
-   * AES-128 iv length should be 16 bytes.
-   */
-  'HLS_AES_128_INVALID_IV_LENGTH': 4043,
-
-  /**
-   * AES-128 encryption key length should be 16 bytes.
-   */
-  'HLS_AES_128_INVALID_KEY_LENGTH': 4044,
+  // RETIRED: 'HLS_AES_128_INVALID_IV_LENGTH': 4043,
+  // RETIRED: 'HLS_AES_128_INVALID_KEY_LENGTH': 4044,
 
   /**
    * External thumbnails tracks cannot be added to live streams.
@@ -754,6 +747,26 @@ shaka.util.Error.Code = {
    */
   'MSS_LIVE_CONTENT_NOT_SUPPORTED': 4047,
 
+  /**
+   * AES-128 iv length should be 16 bytes.
+   */
+  'AES_128_INVALID_IV_LENGTH': 4048,
+
+  /**
+   * AES-128 encryption key length should be 16 bytes.
+   */
+  'AES_128_INVALID_KEY_LENGTH': 4049,
+
+  /**
+   * The DASH Manifest specifies conflicting AES-128 keys.
+   */
+  'DASH_CONFLICTING_AES_128': 4050,
+
+  /**
+   * The DASH Manifest specifies a unsupported AES-128 encryption.
+   */
+  'DASH_UNSUPPORTED_AES_128': 4051,
+
 
   // RETIRED: 'INCONSISTENT_BUFFER_STATE': 5000,
   // RETIRED: 'INVALID_SEGMENT_INDEX': 5001,
@@ -1107,4 +1120,10 @@ shaka.util.Error.Code = {
    * for the previous request to complete before initiating a new one.
    */
   'CURRENT_DAI_REQUEST_NOT_FINISHED': 10004,
+
+  /**
+   * MediaTailor Ad Manager needs to be initialized to enable MediaTailor
+   * Ad Insertion. Call adManager.initMediaTailor() to do it.
+   */
+  'MT_AD_MANAGER_NOT_INITIALIZED': 10005,
 };

package/lib/util/exp_golomb.js

@@ -17,6 +17,7 @@
 
 goog.provide('shaka.util.ExpGolomb');
 
+goog.require('shaka.util.BufferUtils');
 goog.require('shaka.util.DataViewReader');
 
 
@@ -31,13 +32,17 @@ goog.require('shaka.util.DataViewReader');
 shaka.util.ExpGolomb = class {
   /**
    * @param {!Uint8Array} data
+   * @param {boolean=} convertEbsp2rbsp
    */
-  constructor(data) {
+  constructor(data, convertEbsp2rbsp = false) {
     /** @private {!Uint8Array} */
     this.data_ = data;
+    if (convertEbsp2rbsp) {
+      this.data_ = this.ebsp2rbsp_(data);
+    }
 
     /** @private {number} */
-    this.workingBytesAvailable_ = data.byteLength;
+    this.workingBytesAvailable_ = this.data_.byteLength;
 
     // the current word being examined
     /** @private {number} */
@@ -48,6 +53,29 @@ shaka.util.ExpGolomb = class {
     this.workingBitsAvailable_ = 0;
   }
 
+  /**
+   * @param {!Uint8Array} data
+   * @return {!Uint8Array}
+   * @private
+   */
+  ebsp2rbsp_(data) {
+    const ret = new Uint8Array(data.byteLength);
+    let retIndex = 0;
+
+    for (let i = 0; i < data.byteLength; i++) {
+      if (i >= 2) {
+        // Unescape: Skip 0x03 after 00 00
+        if (data[i] == 0x03 && data[i - 1] == 0x00 && data[i - 2] == 0x00) {
+          continue;
+        }
+      }
+      ret[retIndex] = data[i];
+      retIndex++;
+    }
+
+    return shaka.util.BufferUtils.toUint8(ret, 0, retIndex);
+  }
+
   /**
    * Load the next word
    *

package/lib/util/fake_event.js

@@ -164,9 +164,11 @@ shaka.util.FakeEvent.EventName = {
   Error: 'error',
   ExpirationUpdated: 'expirationupdated',
   GapJumped: 'gapjumped',
+  KeyStatusChanged: 'keystatuschanged',
   Loaded: 'loaded',
   Loading: 'loading',
   ManifestParsed: 'manifestparsed',
+  ManifestUpdated: 'manifestupdated',
   MediaQualityChanged: 'mediaqualitychanged',
   Metadata: 'metadata',
   OnStateChange: 'onstatechange',
@@ -175,6 +177,7 @@ shaka.util.FakeEvent.EventName = {
   SegmentAppended: 'segmentappended',
   SessionDataEvent: 'sessiondata',
   StallDetected: 'stalldetected',
+  StateChanged: 'statechanged',
   Streaming: 'streaming',
   TextChanged: 'textchanged',
   TextTrackVisibility: 'texttrackvisibility',

package/lib/util/mp4_generator.js

@@ -624,7 +624,6 @@ shaka.util.Mp4Generator = class {
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
 
     const id = streamInfo.id + 1;
-    const bandwidth = streamInfo.stream.bandwidth || 0;
     const channelsCount = streamInfo.stream.channelsCount || 2;
     const audioSamplingRate = streamInfo.stream.audioSamplingRate || 44100;
 
@@ -670,9 +669,10 @@ shaka.util.Mp4Generator = class {
       0x11, // length
       0x40, // object type
       0x15,  // streamType
-      0x00, 0x06, 0x00, // bufferSizeDB
-      ...this.breakNumberIntoBytes_(bandwidth, 4), // maxBitrate
-      ...this.breakNumberIntoBytes_(bandwidth, 4), // avgBitrate
+      0x00, 0x00, 0x00, // bufferSizeDB
+      0x00, 0x00, 0x00, 0x00, // maxBitrate
+      0x00, 0x00, 0x00, 0x00, // avgBitrate
+
       // DecoderSpecificInfo
       0x05, // tag, DecoderSpecificInfoTag
       0x02, // length

package/lib/util/periods.js

@@ -1495,6 +1495,7 @@ shaka.util.PeriodCombiner = class {
     return {
       id: 0,
       originalId: '',
+      groupId: null,
       primary: false,
       type,
       mimeType: '',
@@ -1532,6 +1533,7 @@ shaka.util.PeriodCombiner = class {
     return {
       id: 0,
       originalId: '',
+      groupId: null,
       createSegmentIndex: () => Promise.resolve(),
       segmentIndex: new shaka.media.SegmentIndex([]),
       mimeType: '',

package/lib/util/platform.js

@@ -154,6 +154,26 @@ shaka.util.Platform = class {
             'Chrome/38.0.2125.122 Safari/537.36');
   }
 
+  /**
+   * Check if the current platform is a WebOS 4.
+   *
+   * @return {boolean}
+   */
+  static isWebOS4() {
+    // See: http://webostv.developer.lge.com/discover/specifications/web-engine/
+    return !!navigator.userAgent.match(/webOS\/4/i);
+  }
+
+  /**
+   * Check if the current platform is a WebOS 4.
+   *
+   * @return {boolean}
+   */
+  static isWebOS5() {
+    // See: http://webostv.developer.lge.com/discover/specifications/web-engine/
+    return !!navigator.userAgent.match(/webOS\/5/i);
+  }
+
   /**
    * Check if the current platform is a Google Chromecast.
    *
@@ -460,6 +480,26 @@ shaka.util.Platform = class {
     return true;
   }
 
+  /**
+   * Returns if codec switching SMOOTH is known reliable device support.
+   *
+   * Some devices are known not to support `MediaSource.changeType`
+   * well. These devices should use the reload strategy. If a device
+   * reports that it supports `changeType` but support it reliabley
+   * it should be added to this list.
+   *
+   * @return {boolean}
+   */
+  static supportsSmoothCodecSwitching() {
+    const Platform = shaka.util.Platform;
+    if (Platform.isTizen2() || Platform.isTizen3() ||
+        Platform.isTizen4() || Platform.isWebOS3() ||
+        Platform.isWebOS4() || Platform.isWebOS5()) {
+      return false;
+    }
+    return true;
+  }
+
   /**
    * Returns true if MediaKeys is polyfilled
    *

package/lib/util/player_configuration.js

@@ -9,6 +9,7 @@ goog.provide('shaka.util.PlayerConfiguration');
 goog.require('goog.asserts');
 goog.require('shaka.abr.SimpleAbrManager');
 goog.require('shaka.config.AutoShowText');
+goog.require('shaka.config.CodecSwitchingStrategy');
 goog.require('shaka.log');
 goog.require('shaka.net.NetworkingEngine');
 goog.require('shaka.util.ConfigUtils');
@@ -133,6 +134,7 @@ shaka.util.PlayerConfiguration = class {
               element);
         },
         sequenceMode: false,
+        enableAudioGroups: false,
       },
       hls: {
         ignoreTextStreamFailures: false,
@@ -307,7 +309,13 @@ shaka.util.PlayerConfiguration = class {
       drawLogo: false,
     };
 
+    let codecSwitchingStrategy = shaka.config.CodecSwitchingStrategy.RELOAD;
+    if (shaka.util.Platform.supportsSmoothCodecSwitching()) {
+      codecSwitchingStrategy = shaka.config.CodecSwitchingStrategy.SMOOTH;
+    }
+
     const mediaSource = {
+      codecSwitchingStrategy: codecSwitchingStrategy,
       sourceBufferExtraFeatures: '',
       forceTransmux: false,
       insertFakeEncryptionInInit: true,

package/lib/util/state_history.js

@@ -40,13 +40,15 @@ shaka.util.StateHistory = class {
 
   /**
    * @param {string} state
+   * @return {boolean} True if this changed the state
    */
   update(state) {
     // |open_| will only be |null| when we first call |update|.
     if (this.open_ == null) {
       this.start_(state);
+      return true;
     } else {
-      this.update_(state);
+      return this.update_(state);
     }
   }
 
@@ -116,6 +118,7 @@ shaka.util.StateHistory = class {
 
   /**
    * @param {string} state
+   * @return {boolean} True if this changed the state
    * @private
    */
   update_(state) {
@@ -131,7 +134,7 @@ shaka.util.StateHistory = class {
 
     // If the state has not changed, there is no need to add a new entry.
     if (this.open_.state == state) {
-      return;
+      return false;
     }
 
     // We have changed states, so "close" the open state.
@@ -142,6 +145,7 @@ shaka.util.StateHistory = class {
       state: state,
       duration: 0,
     };
+    return true;
   }
 
   /**