Source: lib/transmuxer/mpeg_audio.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. goog.provide('shaka.transmuxer.MpegAudio');
  10. /**
  11.  *  MPEG parser utils
  12.  *
  13.  *  @see https://en.wikipedia.org/wiki/MP3
  14.  */
  15. shaka.transmuxer.MpegAudio = class {
  16.   /**
  17.    * @param {!Uint8Array} data
  18.    * @param {!number} offset
  19.    * @return {?{
  20.    *   sampleRate: number,
  21.    *   channelCount: number,
  22.    *   frameLength: number,
  23.    *   samplesPerFrame: number,
  24.    * }}
  25.    */
  26.   static parseHeader(data, offset) {
  27.     const MpegAudio = shaka.transmuxer.MpegAudio;
  29.     const mpegVersion = (data[offset + 1] >> 3) & 3;
  30.     const mpegLayer = (data[offset + 1] >> 1) & 3;
  31.     const bitRateIndex = (data[offset + 2] >> 4) & 15;
  32.     const sampleRateIndex = (data[offset + 2] >> 2) & 3;
  33.     if (mpegVersion !== 1 && bitRateIndex !== 0 &&
  34.       bitRateIndex !== 15 && sampleRateIndex !== 3) {
  35.       const paddingBit = (data[offset + 2] >> 1) & 1;
  36.       const channelMode = data[offset + 3] >> 6;
  37.       let columnInBitrates = 0;
  38.       if (mpegVersion === 3) {
  39.         columnInBitrates = 3 - mpegLayer;
  40.       } else {
  41.         columnInBitrates = mpegLayer === 3 ? 3 : 4;
  42.       }
  43.       const bitRate = MpegAudio.BITRATES_MAP_[
  44.           columnInBitrates * 14 + bitRateIndex - 1] * 1000;
  45.       const columnInSampleRates =
  46.         mpegVersion === 3 ? 0 : mpegVersion === 2 ? 1 : 2;
  47.       const sampleRate = MpegAudio.SAMPLING_RATE_MAP_[
  48.           columnInSampleRates * 3 + sampleRateIndex];
  49.       // If bits of channel mode are `11` then it is a single channel (Mono)
  50.       const channelCount = channelMode === 3 ? 1 : 2;
  51.       const sampleCoefficient =
  52.           MpegAudio.SAMPLES_COEFFICIENTS_[mpegVersion][mpegLayer];
  53.       const bytesInSlot = MpegAudio.BYTES_IN_SLOT_[mpegLayer];
  54.       const samplesPerFrame = sampleCoefficient * 8 * bytesInSlot;
  55.       const frameLength =
  56.         Math.floor((sampleCoefficient * bitRate) / sampleRate + paddingBit) *
  57.         bytesInSlot;
  59.       const userAgent = navigator.userAgent || '';
  60.       // This affect to Tizen also for example.
  61.       const result = userAgent.match(/Chrome\/(\d+)/i);
  62.       const chromeVersion = result ? parseInt(result[1], 10) : 0;
  63.       const needChromeFix = !!chromeVersion && chromeVersion <= 87;
  65.       if (needChromeFix && mpegLayer === 2 &&
  66.         bitRate >= 224000 && channelMode === 0) {
  67.         // Work around bug in Chromium by setting channelMode
  68.         // to dual-channel (01) instead of stereo (00)
  69.         data[offset + 3] = data[offset + 3] | 0x80;
  70.       }
  72.       return {sampleRate, channelCount, frameLength, samplesPerFrame};
  73.     }
  74.     return null;
  75.   }
  77.   /**
  78.    * @param {!Uint8Array} data
  79.    * @param {!number} offset
  80.    * @return {boolean}
  81.    */
  82.   static isHeaderPattern(data, offset) {
  83.     return (
  84.       data[offset] === 0xff &&
  85.       (data[offset + 1] & 0xe0) === 0xe0 &&
  86.       (data[offset + 1] & 0x06) !== 0x00
  87.     );
  88.   }
  90.   /**
  91.    * @param {!Uint8Array} data
  92.    * @param {!number} offset
  93.    * @return {boolean}
  94.    */
  95.   static isHeader(data, offset) {
  96.     // Look for MPEG header | 1111 1111 | 111X XYZX | where X can be either
  97.     // 0 or 1 and Y or Z should be 1
  98.     // Layer bits (position 14 and 15) in header should be always different
  99.     // from 0 (Layer I or Layer II or Layer III)
  100.     // More info http://www.mp3-tech.org/programmer/frame_header.html
  101.     return offset + 1 < data.length &&
  102.       shaka.transmuxer.MpegAudio.isHeaderPattern(data, offset);
  103.   }
  105.   /**
  106.    * @param {!Uint8Array} data
  107.    * @param {!number} offset
  108.    * @return {boolean}
  109.    */
  110.   static probe(data, offset) {
  111.     const MpegAudio = shaka.transmuxer.MpegAudio;
  112.     // same as isHeader but we also check that MPEG frame follows last
  113.     // MPEG frame or end of data is reached
  114.     if (offset + 1 < data.length &&
  115.         MpegAudio.isHeaderPattern(data, offset)) {
  116.       // MPEG header Length
  117.       const headerLength = 4;
  118.       // MPEG frame Length
  119.       const header = MpegAudio.parseHeader(data, offset);
  120.       let frameLength = headerLength;
  121.       if (header && header.frameLength) {
  122.         frameLength = header.frameLength;
  123.       }
  125.       const newOffset = offset + frameLength;
  126.       return newOffset === data.length ||
  127.           MpegAudio.isHeader(data, newOffset);
  128.     }
  129.     return false;
  130.   }
  131. };
  134. /**
  135.  * @private {!Array<number>}
  136.  */
  137. shaka.transmuxer.MpegAudio.BITRATES_MAP_ = [
  138.   32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448, 32, 48, 56,
  139.   64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384, 32, 40, 48, 56, 64, 80,
  140.   96, 112, 128, 160, 192, 224, 256, 320, 32, 48, 56, 64, 80, 96, 112, 128, 144,
  141.   160, 176, 192, 224, 256, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144,
  142.   160,
  143. ];
  145. /**
  146.  * @private {!Array<number>}
  147.  */
  148. shaka.transmuxer.MpegAudio.SAMPLING_RATE_MAP_ = [
  149.   44100, 48000, 32000, 22050, 24000, 16000, 11025, 12000, 8000,
  150. ];
  152. /**
  153.  * @private {!Array<!Array<number>>}
  154.  */
  155. shaka.transmuxer.MpegAudio.SAMPLES_COEFFICIENTS_ = [
  156.   // MPEG 2.5
  157.   [
  158.     0, // Reserved
  159.     72, // Layer3
  160.     144, // Layer2
  161.     12, // Layer1
  162.   ],
  163.   // Reserved
  164.   [
  165.     0, // Reserved
  166.     0, // Layer3
  167.     0, // Layer2
  168.     0, // Layer1
  169.   ],
  170.   // MPEG 2
  171.   [
  172.     0, // Reserved
  173.     72, // Layer3
  174.     144, // Layer2
  175.     12, // Layer1
  176.   ],
  177.   // MPEG 1
  178.   [
  179.     0, // Reserved
  180.     144, // Layer3
  181.     144, // Layer2
  182.     12, // Layer1
  183.   ],
  184. ];
  187. /**
  188.  * @private {!Array<number>}
  189.  */
  190. shaka.transmuxer.MpegAudio.BYTES_IN_SLOT_ = [
  191.   0, // Reserved
  192.   1, // Layer3
  193.   1, // Layer2
  194.   4, // Layer1
  195. ];
  197. /**
  198.  * @const {number}
  199.  */
  200. shaka.transmuxer.MpegAudio.MPEG_AUDIO_SAMPLE_PER_FRAME = 1152;