shaka-player 4.3.10 → 4.4.0

package/lib/transmuxer/ac3.js

@@ -0,0 +1,142 @@
+/*! @license
+ * Shaka Player
+ * Copyright 2016 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('shaka.transmuxer.Ac3');
+
+
+/**
+ * AC3 utils
+ */
+shaka.transmuxer.Ac3 = class {
+  /**
+   * @param {!Uint8Array} data
+   * @param {!number} offset
+   * @return {?{sampleRate: number, channelCount: number,
+   *          audioConfig: !Uint8Array, frameLength: number}}
+   */
+  static parseFrame(data, offset) {
+    if (offset + 8 > data.length) {
+      // not enough bytes left
+      return null;
+    }
+
+    if (data[offset] !== 0x0b || data[offset + 1] !== 0x77) {
+      // invalid magic
+      return null;
+    }
+
+    // get sample rate
+    const samplingRateCode = data[offset + 4] >> 6;
+    if (samplingRateCode >= 3) {
+      // invalid sampling rate
+      return null;
+    }
+
+    const samplingRateMap = [48000, 44100, 32000];
+
+    // get frame size
+    const frameSizeCode = data[offset + 4] & 0x3f;
+    const frameSizeMap = [
+      64, 69, 96, 64, 70, 96, 80, 87, 120, 80, 88, 120, 96, 104, 144, 96, 105,
+      144, 112, 121, 168, 112, 122, 168, 128, 139, 192, 128, 140, 192, 160,
+      174, 240, 160, 175, 240, 192, 208, 288, 192, 209, 288, 224, 243, 336,
+      224, 244, 336, 256, 278, 384, 256, 279, 384, 320, 348, 480, 320, 349,
+      480, 384, 417, 576, 384, 418, 576, 448, 487, 672, 448, 488, 672, 512,
+      557, 768, 512, 558, 768, 640, 696, 960, 640, 697, 960, 768, 835, 1152,
+      768, 836, 1152, 896, 975, 1344, 896, 976, 1344, 1024, 1114, 1536, 1024,
+      1115, 1536, 1152, 1253, 1728, 1152, 1254, 1728, 1280, 1393, 1920, 1280,
+      1394, 1920,
+    ];
+
+    const frameLength = frameSizeMap[frameSizeCode * 3 + samplingRateCode] * 2;
+    if (offset + frameLength > data.length) {
+      return null;
+    }
+
+    // get channel count
+    const channelMode = data[offset + 6] >> 5;
+    let skipCount = 0;
+    if (channelMode === 2) {
+      skipCount += 2;
+    } else {
+      if ((channelMode & 1) && channelMode !== 1) {
+        skipCount += 2;
+      }
+      if (channelMode & 4) {
+        skipCount += 2;
+      }
+    }
+
+    const lowFrequencyEffectsChannelOn =
+      (((data[offset + 6] << 8) | data[offset + 7]) >> (12 - skipCount)) & 1;
+
+    const channelsMap = [2, 1, 2, 3, 3, 4, 4, 5];
+
+    // Audio config for DAC3 box
+    const bitStreamIdentification = data[offset + 5] >> 3;
+    const bitStreamMode = data[offset + 5] & 7;
+
+    const config = new Uint8Array([
+      (samplingRateCode << 6) |
+          (bitStreamIdentification << 1) |
+          (bitStreamMode >> 2),
+      ((bitStreamMode & 3) << 6) |
+          (channelMode << 3) |
+          (lowFrequencyEffectsChannelOn << 2) |
+          (frameSizeCode >> 4),
+      (frameSizeCode << 4) & 0xe0,
+    ]);
+
+    return {
+      sampleRate: samplingRateMap[samplingRateCode],
+      channelCount: channelsMap[channelMode] + lowFrequencyEffectsChannelOn,
+      audioConfig: config,
+      frameLength: frameLength,
+    };
+  }
+
+  /**
+   * @param {!Uint8Array} data
+   * @param {!number} offset
+   * @return {boolean}
+   */
+  static probe(data, offset) {
+    // look for the ac-3 sync bytes
+    if (data[offset] === 0x0b &&
+      data[offset + 1] === 0x77) {
+      // check the bsid (bitStreamIdentification) to confirm ac-3
+      let bsid = 0;
+      let numBits = 5;
+      offset += numBits;
+      /** @type {?number} */
+      let temp = null;
+      /** @type {?number} */
+      let mask = null;
+      /** @type {?number} */
+      let byte = null;
+      while (numBits > 0) {
+        byte = data[offset];
+        // read remaining bits, upto 8 bits at a time
+        const bits = Math.min(numBits, 8);
+        const shift = 8 - bits;
+        mask = (0xff000000 >>> (24 + shift)) << shift;
+        temp = (byte & mask) >> shift;
+        bsid = !bsid ? temp : (bsid << bits) | temp;
+        offset += 1;
+        numBits -= bits;
+      }
+      if (bsid < 16) {
+        return true;
+      }
+    }
+    return false;
+  }
+};
+
+/**
+ * @const {number}
+ */
+shaka.transmuxer.Ac3.AC3_SAMPLES_PER_FRAME = 1536;

package/lib/transmuxer/ac3_transmuxer.js

@@ -0,0 +1,212 @@
+/*! @license
+ * Shaka Player
+ * Copyright 2016 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('shaka.transmuxer.Ac3Transmuxer');
+
+goog.require('shaka.media.Capabilities');
+goog.require('shaka.transmuxer.Ac3');
+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.Ac3Transmuxer = 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.isAc3Container_(mimeType)) {
+      return false;
+    }
+    const ContentType = shaka.util.ManifestParserUtils.ContentType;
+    return Capabilities.isTypeSupported(
+        this.convertCodecs(ContentType.AUDIO, mimeType));
+  }
+
+
+  /**
+   * Check if the mimetype is 'audio/ac3'.
+   * @param {string} mimeType
+   * @return {boolean}
+   * @private
+   */
+  isAc3Container_(mimeType) {
+    return mimeType.toLowerCase().split(';')[0] == 'audio/ac3';
+  }
+
+
+  /**
+   * @override
+   * @export
+   */
+  convertCodecs(contentType, mimeType) {
+    if (this.isAc3Container_(mimeType)) {
+      return 'audio/mp4; codecs="ac-3"';
+    }
+    return mimeType;
+  }
+
+
+  /**
+   * @override
+   * @export
+   */
+  getOrginalMimeType() {
+    return this.originalMimeType_;
+  }
+
+
+  /**
+   * @override
+   * @export
+   */
+  transmux(data, stream, reference, duration) {
+    const Ac3 = shaka.transmuxer.Ac3;
+    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 (Ac3.probe(uint8ArrayData, offset)) {
+        break;
+      }
+    }
+
+    let timestamp = reference.endTime * 1000;
+
+    const frames = shaka.util.Id3Utils.getID3Frames(id3Data);
+    if (frames.length && reference) {
+      const metadataTimestamp = frames.find((frame) => {
+        return frame.description ===
+            'com.apple.streaming.transportStreamTimestamp';
+      });
+      if (metadataTimestamp) {
+        timestamp = /** @type {!number} */(metadataTimestamp.data);
+      }
+    }
+
+    /** @type {number} */
+    let sampleRate = 0;
+
+    /** @type {!Uint8Array} */
+    let audioConfig = new Uint8Array([]);
+
+    /** @type {!Array.<shaka.util.Mp4Generator.Mp4Sample>} */
+    const samples = [];
+
+    while (offset < uint8ArrayData.length) {
+      const frame = Ac3.parseFrame(uint8ArrayData, offset);
+      if (!frame) {
+        return Promise.reject(new shaka.util.Error(
+            shaka.util.Error.Severity.CRITICAL,
+            shaka.util.Error.Category.MEDIA,
+            shaka.util.Error.Code.TRANSMUXING_FAILED));
+      }
+      stream.audioSamplingRate = frame.sampleRate;
+      stream.channelsCount = frame.channelCount;
+      sampleRate = frame.sampleRate;
+      audioConfig = frame.audioConfig;
+
+      const frameData = uint8ArrayData.subarray(
+          offset, offset + frame.frameLength);
+
+      samples.push({
+        data: frameData,
+        size: frame.frameLength,
+        duration: Ac3.AC3_SAMPLES_PER_FRAME,
+        cts: 0,
+        flags: {
+          isLeading: 0,
+          isDependedOn: 0,
+          hasRedundancy: 0,
+          degradPrio: 0,
+          dependsOn: 2,
+          isNonSync: 0,
+        },
+      });
+      offset += frame.frameLength;
+    }
+    /** @type {number} */
+    const baseMediaDecodeTime = Math.floor(timestamp * sampleRate / 1000);
+
+    /** @type {shaka.util.Mp4Generator.StreamInfo} */
+    const streamInfo = {
+      id: stream.id,
+      type: shaka.util.ManifestParserUtils.ContentType.AUDIO,
+      encrypted: stream.encrypted && stream.drmInfos.length > 0,
+      timescale: sampleRate,
+      duration: duration,
+      videoNalus: [],
+      audioConfig: audioConfig,
+      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/ac3',
+    () => new shaka.transmuxer.Ac3Transmuxer('audio/ac3'),
+    shaka.transmuxer.TransmuxerEngine.PluginPriority.FALLBACK);

package/lib/transmuxer/adts.js

@@ -0,0 +1,232 @@
+/*! @license
+ * Shaka Player
+ * Copyright 2016 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('shaka.transmuxer.ADTS');
+
+
+/**
+ * ADTS utils
+ */
+shaka.transmuxer.ADTS = class {
+  /**
+   * @param {!Uint8Array} data
+   * @param {!number} offset
+   * @return {?{headerLength: number, frameLength: number}}
+   */
+  static parseHeader(data, offset) {
+    const ADTS = shaka.transmuxer.ADTS;
+    // The protection skip bit tells us if we have 2 bytes of CRC data at the
+    // end of the ADTS header
+    const headerLength = ADTS.getHeaderLength(data, offset);
+    if (offset + headerLength <= data.length) {
+      // retrieve frame size
+      const frameLength = ADTS.getFullFrameLength(data, offset) - headerLength;
+      if (frameLength > 0) {
+        return {
+          headerLength,
+          frameLength,
+        };
+      }
+    }
+    return null;
+  }
+
+  /**
+   * @param {!Uint8Array} data
+   * @param {!number} offset
+   * @return {?{sampleRate: number, channelCount: number, codec: string}}
+   */
+  static parseInfo(data, offset) {
+    const adtsSamplingRates = [
+      96000,
+      88200,
+      64000,
+      48000,
+      44100,
+      32000,
+      24000,
+      22050,
+      16000,
+      12000,
+      11025,
+      8000,
+      7350,
+    ];
+    const adtsSamplingIndex = (data[offset + 2] & 0x3c) >>> 2;
+    if (adtsSamplingIndex > adtsSamplingRates.length - 1) {
+      return null;
+    }
+    const adtsObjectType = ((data[offset + 2] & 0xc0) >>> 6) + 1;
+    let adtsChannelConfig = (data[offset + 2] & 0x01) << 2;
+    adtsChannelConfig |= (data[offset + 3] & 0xc0) >>> 6;
+    return {
+      sampleRate: adtsSamplingRates[adtsSamplingIndex],
+      channelCount: adtsChannelConfig,
+      codec: 'mp4a.40.' + adtsObjectType,
+    };
+  }
+
+  /**
+   * @param {!Uint8Array} data
+   * @param {!number} offset
+   * @return {boolean}
+   */
+  static isHeaderPattern(data, offset) {
+    return data[offset] === 0xff && (data[offset + 1] & 0xf6) === 0xf0;
+  }
+
+  /**
+   * @param {!Uint8Array} data
+   * @param {!number} offset
+   * @return {number}
+   */
+  static getHeaderLength(data, offset) {
+    return data[offset + 1] & 0x01 ? 7 : 9;
+  }
+
+  /**
+   * @param {!Uint8Array} data
+   * @param {!number} offset
+   * @return {number}
+   */
+  static getFullFrameLength(data, offset) {
+    return ((data[offset + 3] & 0x03) << 11) |
+        (data[offset + 4] << 3) |
+        ((data[offset + 5] & 0xe0) >>> 5);
+  }
+
+  /**
+   * @param {!Uint8Array} data
+   * @param {!number} offset
+   * @return {boolean}
+   */
+  static isHeader(data, offset) {
+    const ADTS = shaka.transmuxer.ADTS;
+    // Look for ADTS header | 1111 1111 | 1111 X00X | where X can be
+    // either 0 or 1
+    // Layer bits (position 14 and 15) in header should be always 0 for ADTS
+    // More info https://wiki.multimedia.cx/index.php?title=ADTS
+    return offset + 1 < data.length && ADTS.isHeaderPattern(data, offset);
+  }
+
+  /**
+   * @param {!Uint8Array} data
+   * @param {!number} offset
+   * @return {boolean}
+   */
+  static probe(data, offset) {
+    const ADTS = shaka.transmuxer.ADTS;
+    // same as isHeader but we also check that ADTS frame follows last ADTS
+    // frame or end of data is reached
+    if (ADTS.isHeader(data, offset)) {
+      // ADTS header Length
+      const headerLength = ADTS.getHeaderLength(data, offset);
+      if (offset + headerLength >= data.length) {
+        return false;
+      }
+      // ADTS frame Length
+      const frameLength = ADTS.getFullFrameLength(data, offset);
+      if (frameLength <= headerLength) {
+        return false;
+      }
+
+      const newOffset = offset + frameLength;
+      return newOffset === data.length || ADTS.isHeader(data, newOffset);
+    }
+    return false;
+  }
+
+  /**
+   * @param {!number} samplerate
+   * @return {number}
+   */
+  static getFrameDuration(samplerate) {
+    return (shaka.transmuxer.ADTS.AAC_SAMPLES_PER_FRAME * 90000) / samplerate;
+  }
+
+  /**
+   * @param {string} codec
+   * @param {number} channelCount
+   * @return {?Uint8Array}
+   */
+  static getSilentFrame(codec, channelCount) {
+    switch (codec) {
+      case 'mp4a.40.2':
+        if (channelCount === 1) {
+          return new Uint8Array([0x00, 0xc8, 0x00, 0x80, 0x23, 0x80]);
+        } else if (channelCount === 2) {
+          return new Uint8Array([
+            0x21, 0x00, 0x49, 0x90, 0x02, 0x19, 0x00, 0x23, 0x80,
+          ]);
+        } else if (channelCount === 3) {
+          return new Uint8Array([
+            0x00, 0xc8, 0x00, 0x80, 0x20, 0x84, 0x01, 0x26, 0x40, 0x08, 0x64,
+            0x00, 0x8e,
+          ]);
+        } else if (channelCount === 4) {
+          return new Uint8Array([
+            0x00, 0xc8, 0x00, 0x80, 0x20, 0x84, 0x01, 0x26, 0x40, 0x08, 0x64,
+            0x00, 0x80, 0x2c, 0x80, 0x08, 0x02, 0x38,
+          ]);
+        } else if (channelCount === 5) {
+          return new Uint8Array([
+            0x00, 0xc8, 0x00, 0x80, 0x20, 0x84, 0x01, 0x26, 0x40, 0x08, 0x64,
+            0x00, 0x82, 0x30, 0x04, 0x99, 0x00, 0x21, 0x90, 0x02, 0x38,
+          ]);
+        } else if (channelCount === 6) {
+          return new Uint8Array([
+            0x00, 0xc8, 0x00, 0x80, 0x20, 0x84, 0x01, 0x26, 0x40, 0x08, 0x64,
+            0x00, 0x82, 0x30, 0x04, 0x99, 0x00, 0x21, 0x90, 0x02, 0x00, 0xb2,
+            0x00, 0x20, 0x08, 0xe0,
+          ]);
+        }
+        break;
+      // handle HE-AAC below (mp4a.40.5 / mp4a.40.29)
+      default:
+        if (channelCount === 1) {
+          // eslint-disable-next-line max-len
+          // ffmpeg -y -f lavfi -i "aevalsrc=0:d=0.05" -c:a libfdk_aac -profile:a aac_he -b:a 4k output.aac && hexdump -v -e '16/1 "0x%x," "\n"' -v output.aac
+          return new Uint8Array([
+            0x1, 0x40, 0x22, 0x80, 0xa3, 0x4e, 0xe6, 0x80, 0xba, 0x8, 0x0, 0x0,
+            0x0, 0x1c, 0x6, 0xf1, 0xc1, 0xa, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a,
+            0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a,
+            0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a,
+            0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a,
+            0x5a, 0x5e,
+          ]);
+        } else if (channelCount === 2) {
+          // eslint-disable-next-line max-len
+          // ffmpeg -y -f lavfi -i "aevalsrc=0|0:d=0.05" -c:a libfdk_aac -profile:a aac_he_v2 -b:a 4k output.aac && hexdump -v -e '16/1 "0x%x," "\n"' -v output.aac
+          return new Uint8Array([
+            0x1, 0x40, 0x22, 0x80, 0xa3, 0x5e, 0xe6, 0x80, 0xba, 0x8, 0x0, 0x0,
+            0x0, 0x0, 0x95, 0x0, 0x6, 0xf1, 0xa1, 0xa, 0x5a, 0x5a, 0x5a, 0x5a,
+            0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a,
+            0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a,
+            0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a,
+            0x5a, 0x5e,
+          ]);
+        } else if (channelCount === 3) {
+          // eslint-disable-next-line max-len
+          // ffmpeg -y -f lavfi -i "aevalsrc=0|0|0:d=0.05" -c:a libfdk_aac -profile:a aac_he_v2 -b:a 4k output.aac && hexdump -v -e '16/1 "0x%x," "\n"' -v output.aac
+          return new Uint8Array([
+            0x1, 0x40, 0x22, 0x80, 0xa3, 0x5e, 0xe6, 0x80, 0xba, 0x8, 0x0, 0x0,
+            0x0, 0x0, 0x95, 0x0, 0x6, 0xf1, 0xa1, 0xa, 0x5a, 0x5a, 0x5a, 0x5a,
+            0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a,
+            0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a,
+            0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a,
+            0x5a, 0x5e,
+          ]);
+        }
+        break;
+    }
+    return null;
+  }
+};
+
+/**
+ * @const {number}
+ */
+shaka.transmuxer.ADTS.AAC_SAMPLES_PER_FRAME = 1024;

package/lib/transmuxer/ec3.js

@@ -0,0 +1,103 @@
+/*! @license
+ * Shaka Player
+ * Copyright 2016 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('shaka.transmuxer.Ec3');
+
+goog.require('shaka.util.ExpGolomb');
+
+
+/**
+ * EC3 utils
+ */
+shaka.transmuxer.Ec3 = class {
+  /**
+   * @param {!Uint8Array} data
+   * @param {!number} offset
+   * @return {?{sampleRate: number, channelCount: number,
+   *          audioConfig: !Uint8Array, frameLength: number}}
+   */
+  static parseFrame(data, offset) {
+    if (offset + 8 > data.length) {
+      // not enough bytes left
+      return null;
+    }
+
+    if (!shaka.transmuxer.Ec3.probe(data, offset)) {
+      return null;
+    }
+
+    const gb = new shaka.util.ExpGolomb(data.subarray(offset + 2));
+    // Skip stream_type
+    gb.skipBits(2);
+    // Skip sub_stream_id
+    gb.skipBits(3);
+    const frameLength = (gb.readBits(11) + 1) << 1;
+    let samplingRateCode = gb.readBits(2);
+    let sampleRate = null;
+    let numBlocksCode = null;
+    if (samplingRateCode == 0x03) {
+      samplingRateCode = gb.readBits(2);
+      sampleRate = [24000, 22060, 16000][samplingRateCode];
+      numBlocksCode = 3;
+    } else {
+      sampleRate = [48000, 44100, 32000][samplingRateCode];
+      numBlocksCode = gb.readBits(2);
+    }
+
+    const channelMode = gb.readBits(3);
+    const lowFrequencyEffectsChannelOn = gb.readBits(1);
+    const bitStreamIdentification = gb.readBits(5);
+
+    if (offset + frameLength > data.byteLength) {
+      return null;
+    }
+
+    const channelsMap = [2, 1, 2, 3, 3, 4, 4, 5];
+
+    const numBlocksMap = [1, 2, 3, 6];
+
+    const numBlocks = numBlocksMap[numBlocksCode];
+
+    const dataRateSub =
+        Math.floor((frameLength * sampleRate) / (numBlocks * 16));
+
+    const config = new Uint8Array([
+      ((dataRateSub & 0x1FE0) >> 5),
+      ((dataRateSub & 0x001F) << 3), // num_ind_sub = zero
+      (sampleRate << 6) | (bitStreamIdentification << 1) | (0 << 0),
+      (0 << 7) | (0 << 4) |
+      (channelMode << 1) | (lowFrequencyEffectsChannelOn << 0),
+      (0 << 5) | (0 << 1) | (0 << 0),
+    ]);
+
+    return {
+      sampleRate,
+      channelCount: channelsMap[channelMode] + lowFrequencyEffectsChannelOn,
+      audioConfig: config,
+      frameLength,
+    };
+  }
+
+  /**
+   * @param {!Uint8Array} data
+   * @param {!number} offset
+   * @return {boolean}
+   */
+  static probe(data, offset) {
+    // search 16-bit 0x0B77 syncword
+    const syncword = (data[offset] << 8) | (data[offset + 1] << 0);
+    if (syncword === 0x0B77) {
+      return true;
+    } else {
+      return false;
+    }
+  }
+};
+
+/**
+ * @const {number}
+ */
+shaka.transmuxer.Ec3.EC3_SAMPLES_PER_FRAME = 1536;