shaka-player 4.4.3 → 4.6.0

package/lib/transmuxer/mp3_transmuxer.js

@@ -93,7 +93,7 @@ shaka.transmuxer.Mp3Transmuxer = class {
    * @override
    * @export
    */
-  getOrginalMimeType() {
+  getOriginalMimeType() {
     return this.originalMimeType_;
   }
 

package/lib/transmuxer/mpeg_ts_transmuxer.js

@@ -119,7 +119,7 @@ shaka.transmuxer.MpegTsTransmuxer = class {
    * @override
    * @export
    */
-  getOrginalMimeType() {
+  getOriginalMimeType() {
     return this.originalMimeType_;
   }
 
@@ -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/mss_transmuxer.js

@@ -208,7 +208,7 @@ shaka.transmuxer.MssTransmuxer = class {
    * @override
    * @export
    */
-  getOrginalMimeType() {
+  getOriginalMimeType() {
     return this.originalMimeType_;
   }
 

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}
@@ -72,7 +75,11 @@ shaka.transmuxer.TsTransmuxer = class {
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
     const MimeUtils = shaka.util.MimeUtils;
 
-    const codecs = MimeUtils.getCodecs(mimeType);
+    let convertedMimeType = mimeType;
+    if (contentType) {
+      convertedMimeType = this.convertCodecs(contentType, mimeType);
+    }
+    const codecs = MimeUtils.getCodecs(convertedMimeType);
     const allCodecs = MimeUtils.splitCodecs(codecs);
 
     const audioCodec = shaka.util.ManifestParserUtils.guessCodecsSafe(
@@ -80,11 +87,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) {
@@ -136,7 +138,8 @@ shaka.transmuxer.TsTransmuxer = class {
       // MediaSource.isTypeSupported('audio/mp4; codecs="mp4a.40.34"') -> false
       // MediaSource.isTypeSupported('audio/mp4; codecs="mp3"') -> true
       const codecs = shaka.util.MimeUtils.getCodecs(mimeType)
-          .replace('mp4a.40.34', 'mp3');
+          .replace('mp4a.40.34', 'mp3').split(',')
+          .map(this.getCorrectVideoCodecs_).join(',');
       if (contentType == ContentType.AUDIO) {
         return `audio/mp4; codecs="${codecs}"`;
       }
@@ -146,11 +149,34 @@ shaka.transmuxer.TsTransmuxer = class {
   }
 
 
+  /**
+   * @param {string} codec
+   * @return {string}
+   * @private
+   */
+  getCorrectVideoCodecs_(codec) {
+    if (codec.includes('avc1')) {
+      // Convert avc1 codec string from RFC-4281 to RFC-6381 for
+      // MediaSource.isTypeSupported
+      // Example, convert avc1.66.30 to avc1.42001e (0x42 == 66 and 0x1e == 30)
+      const avcdata = codec.split('.');
+      if (avcdata.length == 3) {
+        let result = avcdata.shift() + '.';
+        result += parseInt(avcdata.shift(), 10).toString(16);
+        result +=
+            ('000' + parseInt(avcdata.shift(), 10).toString(16)).slice(-4);
+        return result;
+      }
+    }
+    return codec;
+  }
+
+
   /**
    * @override
    * @export
    */
-  getOrginalMimeType() {
+  getOriginalMimeType() {
     return this.originalMimeType_;
   }
 
@@ -179,7 +205,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 +221,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 +272,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 +337,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 +688,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;
 
@@ -626,11 +706,7 @@ shaka.transmuxer.TsTransmuxer = class {
     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.parseAvcNalus(pes, nextPes);
+      const dataNalus = pes.nalus;
       nalus = nalus.concat(dataNalus);
       const frame = H264.parseFrame(dataNalus);
       if (!frame) {
@@ -642,8 +718,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 +768,92 @@ 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];
+      const dataNalus = pes.nalus;
+      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 +877,7 @@ shaka.transmuxer.TsTransmuxer.SUPPORTED_AUDIO_CODECS_ = [
  */
 shaka.transmuxer.TsTransmuxer.SUPPORTED_VIDEO_CODECS_ = [
   'avc',
+  'hevc',
 ];
 
 

package/lib/util/buffer_utils.js

@@ -110,6 +110,23 @@ shaka.util.BufferUtils = class {
     return shaka.util.BufferUtils.view_(data, offset, length, Uint8Array);
   }
 
+  /**
+   * Creates a new Uint16Array view on the same buffer.  This clamps the values
+   * to be within the same view (i.e. you can't use this to move past the end
+   * of the view, even if the underlying buffer is larger).  However, you can
+   * pass a negative offset to access the data before the view.
+   *
+   * @param {BufferSource} data
+   * @param {number=} offset The offset from the beginning of this data's view
+   *   to start the new view at.
+   * @param {number=} length The byte length of the new view.
+   * @return {!Uint16Array}
+   * @export
+   */
+  static toUint16(data, offset = 0, length = Infinity) {
+    return shaka.util.BufferUtils.view_(data, offset, length, Uint16Array);
+  }
+
   /**
    * Creates a DataView over the given buffer.
    *
@@ -135,15 +152,20 @@ shaka.util.BufferUtils = class {
    */
   static view_(data, offset, length, Type) {
     const buffer = shaka.util.BufferUtils.unsafeGetArrayBuffer_(data);
+    let bytesPerElement = 1;
+    if ('BYTES_PER_ELEMENT' in Type) {
+      bytesPerElement = Type.BYTES_PER_ELEMENT;
+    }
     // Absolute end of the |data| view within |buffer|.
     /** @suppress {strictMissingProperties} */
-    const dataEnd = (data.byteOffset || 0) + data.byteLength;
+    const dataEnd = ((data.byteOffset || 0) + data.byteLength) /
+      bytesPerElement;
     // Absolute start of the result within |buffer|.
     /** @suppress {strictMissingProperties} */
-    const rawStart = (data.byteOffset || 0) + offset;
-    const start = Math.max(0, Math.min(rawStart, dataEnd));
+    const rawStart = ((data.byteOffset || 0) + offset) / bytesPerElement;
+    const start = Math.floor(Math.max(0, Math.min(rawStart, dataEnd)));
     // Absolute end of the result within |buffer|.
-    const end = Math.min(start + Math.max(length, 0), dataEnd);
+    const end = Math.floor(Math.min(start + Math.max(length, 0), dataEnd));
     return new Type(buffer, start, end - start);
   }
 };