shaka-player 4.3.11 → 4.4.1

package/lib/transmuxer/mp3_transmuxer.js

@@ -0,0 +1,205 @@
+/*! @license
+ * Shaka Player
+ * Copyright 2016 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('shaka.transmuxer.Mp3Transmuxer');
+
+goog.require('shaka.media.Capabilities');
+goog.require('shaka.transmuxer.MpegAudio');
+goog.require('shaka.transmuxer.TransmuxerEngine');
+goog.require('shaka.util.BufferUtils');
+goog.require('shaka.util.Error');
+goog.require('shaka.util.Id3Utils');
+goog.require('shaka.util.ManifestParserUtils');
+goog.require('shaka.util.Mp4Generator');
+goog.require('shaka.util.Uint8ArrayUtils');
+
+
+/**
+ * @implements {shaka.extern.Transmuxer}
+ * @export
+ */
+shaka.transmuxer.Mp3Transmuxer = class {
+  /**
+   * @param {string} mimeType
+   */
+  constructor(mimeType) {
+    /** @private {string} */
+    this.originalMimeType_ = mimeType;
+
+    /** @private {number} */
+    this.frameIndex_ = 0;
+
+    /** @private {!Map.<number, !Uint8Array>} */
+    this.initSegments = new Map();
+  }
+
+
+  /**
+   * @override
+   * @export
+   */
+  destroy() {
+    this.initSegments.clear();
+  }
+
+
+  /**
+   * Check if the mime type and the content type is supported.
+   * @param {string} mimeType
+   * @param {string=} contentType
+   * @return {boolean}
+   * @override
+   * @export
+   */
+  isSupported(mimeType, contentType) {
+    const Capabilities = shaka.media.Capabilities;
+
+    if (!this.isMpegContainer_(mimeType)) {
+      return false;
+    }
+    const ContentType = shaka.util.ManifestParserUtils.ContentType;
+    return Capabilities.isTypeSupported(
+        this.convertCodecs(ContentType.AUDIO, mimeType));
+  }
+
+
+  /**
+   * Check if the mimetype is 'audio/mpeg'.
+   * @param {string} mimeType
+   * @return {boolean}
+   * @private
+   */
+  isMpegContainer_(mimeType) {
+    return mimeType.toLowerCase().split(';')[0] == 'audio/mpeg';
+  }
+
+
+  /**
+   * @override
+   * @export
+   */
+  convertCodecs(contentType, mimeType) {
+    if (this.isMpegContainer_(mimeType)) {
+      return 'audio/mp4; codecs="mp3"';
+    }
+    return mimeType;
+  }
+
+
+  /**
+   * @override
+   * @export
+   */
+  getOrginalMimeType() {
+    return this.originalMimeType_;
+  }
+
+
+  /**
+   * @override
+   * @export
+   */
+  transmux(data, stream, reference, duration) {
+    const MpegAudio = shaka.transmuxer.MpegAudio;
+    const Uint8ArrayUtils = shaka.util.Uint8ArrayUtils;
+
+    const uint8ArrayData = shaka.util.BufferUtils.toUint8(data);
+
+    const id3Data = shaka.util.Id3Utils.getID3Data(uint8ArrayData);
+    let offset = id3Data.length;
+    for (; offset < uint8ArrayData.length; offset++) {
+      if (MpegAudio.probe(uint8ArrayData, offset)) {
+        break;
+      }
+    }
+
+    const timescale = 90000;
+    let firstHeader;
+
+    /** @type {!Array.<shaka.util.Mp4Generator.Mp4Sample>} */
+    const samples = [];
+
+    while (offset < uint8ArrayData.length) {
+      const header = MpegAudio.parseHeader(uint8ArrayData, offset);
+      if (!header) {
+        return Promise.reject(new shaka.util.Error(
+            shaka.util.Error.Severity.CRITICAL,
+            shaka.util.Error.Category.MEDIA,
+            shaka.util.Error.Code.TRANSMUXING_FAILED));
+      }
+      if (!firstHeader) {
+        firstHeader = header;
+      }
+      if (offset + header.frameLength <= uint8ArrayData.length) {
+        samples.push({
+          data: uint8ArrayData.subarray(offset, offset + header.frameLength),
+          size: header.frameLength,
+          duration: MpegAudio.MPEG_AUDIO_SAMPLE_PER_FRAME,
+          cts: 0,
+          flags: {
+            isLeading: 0,
+            isDependedOn: 0,
+            hasRedundancy: 0,
+            degradPrio: 0,
+            dependsOn: 2,
+            isNonSync: 0,
+          },
+        });
+      }
+      offset += header.frameLength;
+    }
+    if (!firstHeader) {
+      return Promise.reject(new shaka.util.Error(
+          shaka.util.Error.Severity.CRITICAL,
+          shaka.util.Error.Category.MEDIA,
+          shaka.util.Error.Code.TRANSMUXING_FAILED));
+    }
+    /** @type {number} */
+    const sampleRate = firstHeader.sampleRate;
+    /** @type {number} */
+    const frameDuration =
+        firstHeader.samplesPerFrame * timescale / firstHeader.sampleRate;
+    /** @type {number} */
+    const baseMediaDecodeTime = this.frameIndex_ * frameDuration;
+
+    /** @type {shaka.util.Mp4Generator.StreamInfo} */
+    const streamInfo = {
+      id: stream.id,
+      type: shaka.util.ManifestParserUtils.ContentType.AUDIO,
+      codecs: 'mp3',
+      encrypted: stream.encrypted && stream.drmInfos.length > 0,
+      timescale: sampleRate,
+      duration: duration,
+      videoNalus: [],
+      audioConfig: new Uint8Array([]),
+      videoConfig: new Uint8Array([]),
+      data: {
+        sequenceNumber: this.frameIndex_,
+        baseMediaDecodeTime: baseMediaDecodeTime,
+        samples: samples,
+      },
+      stream: stream,
+    };
+    const mp4Generator = new shaka.util.Mp4Generator([streamInfo]);
+    let initSegment;
+    if (!this.initSegments.has(stream.id)) {
+      initSegment = mp4Generator.initSegment();
+      this.initSegments.set(stream.id, initSegment);
+    } else {
+      initSegment = this.initSegments.get(stream.id);
+    }
+    const segmentData = mp4Generator.segmentData();
+
+    this.frameIndex_++;
+    const transmuxData = Uint8ArrayUtils.concat(initSegment, segmentData);
+    return Promise.resolve(transmuxData);
+  }
+};
+
+shaka.transmuxer.TransmuxerEngine.registerTransmuxer(
+    'audio/mpeg',
+    () => new shaka.transmuxer.Mp3Transmuxer('audio/mpeg'),
+    shaka.transmuxer.TransmuxerEngine.PluginPriority.FALLBACK);

package/lib/transmuxer/mpeg_audio.js

@@ -0,0 +1,196 @@
+/*! @license
+ * Shaka Player
+ * Copyright 2016 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('shaka.transmuxer.MpegAudio');
+
+
+/**
+ *  MPEG parser utils
+ *
+ *  @see https://en.wikipedia.org/wiki/MP3
+ */
+shaka.transmuxer.MpegAudio = class {
+  /**
+   * @param {!Uint8Array} data
+   * @param {!number} offset
+   * @return {?{sampleRate: number, channelCount: number,
+   * frameLength: number, samplesPerFrame: number}}
+   */
+  static parseHeader(data, offset) {
+    const MpegAudio = shaka.transmuxer.MpegAudio;
+
+    const mpegVersion = (data[offset + 1] >> 3) & 3;
+    const mpegLayer = (data[offset + 1] >> 1) & 3;
+    const bitRateIndex = (data[offset + 2] >> 4) & 15;
+    const sampleRateIndex = (data[offset + 2] >> 2) & 3;
+    if (mpegVersion !== 1 && bitRateIndex !== 0 &&
+      bitRateIndex !== 15 && sampleRateIndex !== 3) {
+      const paddingBit = (data[offset + 2] >> 1) & 1;
+      const channelMode = data[offset + 3] >> 6;
+      let columnInBitrates = 0;
+      if (mpegVersion === 3) {
+        columnInBitrates = 3 - mpegLayer;
+      } else {
+        columnInBitrates = mpegLayer === 3 ? 3 : 4;
+      }
+      const bitRate = MpegAudio.BITRATES_MAP_[
+          columnInBitrates * 14 + bitRateIndex - 1] * 1000;
+      const columnInSampleRates =
+        mpegVersion === 3 ? 0 : mpegVersion === 2 ? 1 : 2;
+      const sampleRate = MpegAudio.SAMPLINGRATE_MAP_[
+          columnInSampleRates * 3 + sampleRateIndex];
+      // If bits of channel mode are `11` then it is a single channel (Mono)
+      const channelCount = channelMode === 3 ? 1 : 2;
+      const sampleCoefficient =
+          MpegAudio.SAMPLES_COEFFICIENTS_[mpegVersion][mpegLayer];
+      const bytesInSlot = MpegAudio.BYTES_IN_SLOT_[mpegLayer];
+      const samplesPerFrame = sampleCoefficient * 8 * bytesInSlot;
+      const frameLength =
+        Math.floor((sampleCoefficient * bitRate) / sampleRate + paddingBit) *
+        bytesInSlot;
+
+      const userAgent = navigator.userAgent || '';
+      // This affect to Tizen also for example.
+      const result = userAgent.match(/Chrome\/(\d+)/i);
+      const chromeVersion = result ? parseInt(result[1], 10) : 0;
+      const needChromeFix = !!chromeVersion && chromeVersion <= 87;
+
+      if (needChromeFix && mpegLayer === 2 &&
+        bitRate >= 224000 && channelMode === 0) {
+        // Work around bug in Chromium by setting channelMode
+        // to dual-channel (01) instead of stereo (00)
+        data[offset + 3] = data[offset + 3] | 0x80;
+      }
+
+      return {sampleRate, channelCount, frameLength, samplesPerFrame};
+    }
+    return null;
+  }
+
+  /**
+   * @param {!Uint8Array} data
+   * @param {!number} offset
+   * @return {boolean}
+   */
+  static isHeaderPattern(data, offset) {
+    return (
+      data[offset] === 0xff &&
+      (data[offset + 1] & 0xe0) === 0xe0 &&
+      (data[offset + 1] & 0x06) !== 0x00
+    );
+  }
+
+  /**
+   * @param {!Uint8Array} data
+   * @param {!number} offset
+   * @return {boolean}
+   */
+  static isHeader(data, offset) {
+    // Look for MPEG header | 1111 1111 | 111X XYZX | where X can be either
+    // 0 or 1 and Y or Z should be 1
+    // Layer bits (position 14 and 15) in header should be always different
+    // from 0 (Layer I or Layer II or Layer III)
+    // More info http://www.mp3-tech.org/programmer/frame_header.html
+    return offset + 1 < data.length &&
+      shaka.transmuxer.MpegAudio.isHeaderPattern(data, offset);
+  }
+
+  /**
+   * @param {!Uint8Array} data
+   * @param {!number} offset
+   * @return {boolean}
+   */
+  static probe(data, offset) {
+    const MpegAudio = shaka.transmuxer.MpegAudio;
+    // same as isHeader but we also check that MPEG frame follows last
+    // MPEG frame or end of data is reached
+    if (offset + 1 < data.length &&
+        MpegAudio.isHeaderPattern(data, offset)) {
+      // MPEG header Length
+      const headerLength = 4;
+      // MPEG frame Length
+      const header = MpegAudio.parseHeader(data, offset);
+      let frameLength = headerLength;
+      if (header && header.frameLength) {
+        frameLength = header.frameLength;
+      }
+
+      const newOffset = offset + frameLength;
+      return newOffset === data.length ||
+          MpegAudio.isHeader(data, newOffset);
+    }
+    return false;
+  }
+};
+
+
+/**
+ * @private {!Array.<number>}
+ */
+shaka.transmuxer.MpegAudio.BITRATES_MAP_ = [
+  32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448, 32, 48, 56,
+  64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384, 32, 40, 48, 56, 64, 80,
+  96, 112, 128, 160, 192, 224, 256, 320, 32, 48, 56, 64, 80, 96, 112, 128, 144,
+  160, 176, 192, 224, 256, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144,
+  160,
+];
+
+/**
+ * @private {!Array.<number>}
+ */
+shaka.transmuxer.MpegAudio.SAMPLINGRATE_MAP_ = [
+  44100, 48000, 32000, 22050, 24000, 16000, 11025, 12000, 8000,
+];
+
+/**
+ * @private {!Array.<!Array.<number>>}
+ */
+shaka.transmuxer.MpegAudio.SAMPLES_COEFFICIENTS_ = [
+  // MPEG 2.5
+  [
+    0, // Reserved
+    72, // Layer3
+    144, // Layer2
+    12, // Layer1
+  ],
+  // Reserved
+  [
+    0, // Reserved
+    0, // Layer3
+    0, // Layer2
+    0, // Layer1
+  ],
+  // MPEG 2
+  [
+    0, // Reserved
+    72, // Layer3
+    144, // Layer2
+    12, // Layer1
+  ],
+  // MPEG 1
+  [
+    0, // Reserved
+    144, // Layer3
+    144, // Layer2
+    12, // Layer1
+  ],
+];
+
+
+/**
+ * @private {!Array.<number>}
+ */
+shaka.transmuxer.MpegAudio.BYTES_IN_SLOT_ = [
+  0, // Reserved
+  1, // Layer3
+  1, // Layer2
+  4, // Layer1
+];
+
+/**
+ * @const {number}
+ */
+shaka.transmuxer.MpegAudio.MPEG_AUDIO_SAMPLE_PER_FRAME = 1152;

package/lib/transmuxer/mpeg_ts_transmuxer.js

@@ -0,0 +1,182 @@
+/*! @license
+ * Shaka Player
+ * Copyright 2016 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('shaka.transmuxer.MpegTsTransmuxer');
+
+goog.require('shaka.media.Capabilities');
+goog.require('shaka.transmuxer.MpegAudio');
+goog.require('shaka.transmuxer.TransmuxerEngine');
+goog.require('shaka.util.BufferUtils');
+goog.require('shaka.util.Error');
+goog.require('shaka.util.ManifestParserUtils');
+goog.require('shaka.util.MimeUtils');
+goog.require('shaka.util.TsParser');
+goog.require('shaka.util.Uint8ArrayUtils');
+
+/**
+ * @fileoverview
+ *
+ * This transmuxer takes an audio-only TS with MP3, and converts it to
+ * raw MP3(audio/mpeg). We don't do it in ts_transmuxer.js because the
+ * output of it is always MP4. This transmuxer is necessary because the only
+ * browser that supports MP3 in MP4 is Firefox(audio/mp4; codecs="mp3"),
+ * other browsers don't support it.
+ */
+
+/**
+ * @implements {shaka.extern.Transmuxer}
+ * @export
+ */
+shaka.transmuxer.MpegTsTransmuxer = class {
+  /**
+   * @param {string} mimeType
+   */
+  constructor(mimeType) {
+    /** @private {string} */
+    this.originalMimeType_ = mimeType;
+
+    /** @private {?shaka.util.TsParser} */
+    this.tsParser_ = null;
+  }
+
+
+  /**
+   * @override
+   * @export
+   */
+  destroy() {
+    // Nothing
+  }
+
+
+  /**
+   * Check if the mime type and the content type is supported.
+   * @param {string} mimeType
+   * @param {string=} contentType
+   * @return {boolean}
+   * @override
+   * @export
+   */
+  isSupported(mimeType, contentType) {
+    const Capabilities = shaka.media.Capabilities;
+
+    if (!this.isTsContainer_(mimeType)) {
+      return false;
+    }
+
+    const ContentType = shaka.util.ManifestParserUtils.ContentType;
+    const MimeUtils = shaka.util.MimeUtils;
+
+    const codecs = MimeUtils.getCodecs(mimeType);
+    const allCodecs = MimeUtils.splitCodecs(codecs);
+
+    const audioCodec = shaka.util.ManifestParserUtils.guessCodecsSafe(
+        ContentType.AUDIO, allCodecs);
+    const videoCodec = shaka.util.ManifestParserUtils.guessCodecsSafe(
+        ContentType.VIDEO, allCodecs);
+
+    if (!audioCodec || videoCodec) {
+      return false;
+    }
+    const normalizedCodec = MimeUtils.getNormalizedCodec(audioCodec);
+
+    if (normalizedCodec != 'mp3') {
+      return false;
+    }
+
+    return Capabilities.isTypeSupported(
+        this.convertCodecs(ContentType.AUDIO, mimeType));
+  }
+
+
+  /**
+   * Check if the mimetype is 'video/mp2t'.
+   * @param {string} mimeType
+   * @return {boolean}
+   * @private
+   */
+  isTsContainer_(mimeType) {
+    return mimeType.toLowerCase().split(';')[0] == 'video/mp2t';
+  }
+
+
+  /**
+   * @override
+   * @export
+   */
+  convertCodecs(contentType, mimeType) {
+    if (this.isTsContainer_(mimeType)) {
+      return 'audio/mpeg';
+    }
+    return mimeType;
+  }
+
+
+  /**
+   * @override
+   * @export
+   */
+  getOrginalMimeType() {
+    return this.originalMimeType_;
+  }
+
+
+  /**
+   * @override
+   * @export
+   */
+  transmux(data) {
+    const MpegAudio = shaka.transmuxer.MpegAudio;
+    const Uint8ArrayUtils = shaka.util.Uint8ArrayUtils;
+
+    if (!this.tsParser_) {
+      this.tsParser_ = new shaka.util.TsParser();
+    } else {
+      this.tsParser_.clearData();
+    }
+
+    const uint8ArrayData = shaka.util.BufferUtils.toUint8(data);
+
+    const tsParser = this.tsParser_.parse(uint8ArrayData);
+    const codecs = tsParser.getCodecs();
+    if (codecs.audio != 'mp3' || codecs.video) {
+      return Promise.reject(new shaka.util.Error(
+          shaka.util.Error.Severity.CRITICAL,
+          shaka.util.Error.Category.MEDIA,
+          shaka.util.Error.Code.TRANSMUXING_FAILED));
+    }
+
+    let transmuxData = new Uint8Array([]);
+
+    for (const audioData of tsParser.getAudioData()) {
+      const data = audioData.data;
+      if (!data) {
+        continue;
+      }
+      let offset = 0;
+      while (offset < data.length) {
+        const header = MpegAudio.parseHeader(data, offset);
+        if (!header) {
+          offset++;
+          continue;
+        }
+        if (offset + header.frameLength <= data.length) {
+          transmuxData = Uint8ArrayUtils.concat(transmuxData,
+              data.subarray(offset, offset + header.frameLength));
+        }
+        offset += header.frameLength;
+      }
+    }
+
+    return Promise.resolve(transmuxData);
+  }
+};
+
+
+shaka.transmuxer.TransmuxerEngine.registerTransmuxer(
+    'video/mp2t',
+    () => new shaka.transmuxer.MpegTsTransmuxer('video/mp2t'),
+    shaka.transmuxer.TransmuxerEngine.PluginPriority.PREFERRED_SECONDARY);