Source: lib/media/content_workarounds.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. goog.provide('shaka.media.ContentWorkarounds');
  9. goog.require('goog.asserts');
  10. goog.require('shaka.log');
  11. goog.require('shaka.util.BufferUtils');
  12. goog.require('shaka.util.Error');
  13. goog.require('shaka.util.Mp4BoxParsers');
  14. goog.require('shaka.util.Mp4Generator');
  15. goog.require('shaka.util.Mp4Parser');
  16. goog.require('shaka.util.Platform');
  17. goog.require('shaka.util.Uint8ArrayUtils');
  20. /**
  21.  * @summary
  22.  * A collection of methods to work around content issues on various platforms.
  23.  */
  24. shaka.media.ContentWorkarounds = class {
  25.   /**
  26.    * For EAC-3 audio, the "enca" box ChannelCount field
  27.    * MUST always be set to 2.
  28.    * See ETSI TS 102 366 V1.2.1 Sec F.3
  29.    *
  30.    * Clients SHOULD ignore this value; however, it has been discovered that
  31.    * some user agents don't, and instead, invalid values here can cause decoder
  32.    * failures to be thrown (this has been observed with Chromecast).
  33.    *
  34.    * Given that this value MUST be hard-coded to 2, and that clients "SHALL"
  35.    * ignore the value, it seems safe to manipulate the value to be 2 even when
  36.    * the packager has provided a different value.
  37.    * @param {!BufferSource} initSegmentBuffer
  38.    * @return {!Uint8Array}
  39.    */
  40.   static correctEnca(initSegmentBuffer) {
  41.     const initSegment = shaka.util.BufferUtils.toUint8(initSegmentBuffer);
  42.     const modifiedInitSegment = initSegment;
  44.     /**
  45.      * Skip reserved bytes: 6
  46.      * Skip data_reference_index: 2
  47.      * Skip reserved bytes: 8
  48.      */
  49.     const encaChannelCountOffset = 16;
  51.     /** @type {?DataView} */
  52.     let encaBoxDataView = null;
  54.     new shaka.util.Mp4Parser()
  55.         .box('moov', shaka.util.Mp4Parser.children)
  56.         .box('trak', shaka.util.Mp4Parser.children)
  57.         .box('mdia', shaka.util.Mp4Parser.children)
  58.         .box('minf', shaka.util.Mp4Parser.children)
  59.         .box('stbl', shaka.util.Mp4Parser.children)
  60.         .fullBox('stsd', shaka.util.Mp4Parser.sampleDescription)
  61.         .box('enca', (box) => {
  62.           encaBoxDataView = box.reader.getDataView();
  63.           return shaka.util.Mp4Parser.audioSampleEntry(box);
  64.         })
  65.         .box('sinf', shaka.util.Mp4Parser.children)
  66.         .box('frma', (box) => {
  67.           box.parser.stop();
  68.           const {codec} = shaka.util.Mp4BoxParsers.parseFRMA(box.reader);
  69.           if (codec === 'ec-3' &&
  70.                 encaBoxDataView &&
  71.                 encaBoxDataView.getUint16(encaChannelCountOffset) !== 2
  72.           ) {
  73.             encaBoxDataView.setUint16(encaChannelCountOffset, 2);
  74.           }
  75.         })
  76.         .parse(initSegment);
  78.     return modifiedInitSegment;
  79.   }
  81.   /**
  82.    * Transform the init segment into a new init segment buffer that indicates
  83.    * encryption.  If the init segment already indicates encryption, return the
  84.    * original init segment.
  85.    *
  86.    * Should only be called for MP4 init segments, and only on platforms that
  87.    * need this workaround.
  88.    *
  89.    * @param {!shaka.extern.Stream} stream
  90.    * @param {!BufferSource} initSegmentBuffer
  91.    * @param {?string} uri
  92.    * @return {!Uint8Array}
  93.    * @see https://github.com/shaka-project/shaka-player/issues/2759
  94.    */
  95.   static fakeEncryption(stream, initSegmentBuffer, uri) {
  96.     const ContentWorkarounds = shaka.media.ContentWorkarounds;
  97.     const initSegment = shaka.util.BufferUtils.toUint8(initSegmentBuffer);
  98.     let modifiedInitSegment = initSegment;
  99.     let isEncrypted = false;
  100.     /** @type {shaka.extern.ParsedBox} */
  101.     let stsdBox;
  102.     const ancestorBoxes = [];
  104.     const onSimpleAncestorBox = (box) => {
  105.       ancestorBoxes.push(box);
  106.       shaka.util.Mp4Parser.children(box);
  107.     };
  109.     const onEncryptionMetadataBox = (box) => {
  110.       isEncrypted = true;
  111.       box.parser.stop();
  112.     };
  114.     // Multiplexed content could have multiple boxes that we need to modify.
  115.     // Add to this array in order of box offset.  This will be important later,
  116.     // when we process the boxes.
  117.     /** @type {!Array<{box: shaka.extern.ParsedBox, newType: number}>} */
  118.     const boxesToModify = [];
  120.     const pushEncv = (box) => {
  121.       boxesToModify.push({
  122.         box,
  123.         newType: ContentWorkarounds.BOX_TYPE_ENCV_,
  124.       });
  125.     };
  127.     const pushEnca = (box) => {
  128.       boxesToModify.push({
  129.         box,
  130.         newType: ContentWorkarounds.BOX_TYPE_ENCA_,
  131.       });
  132.     };
  134.     new shaka.util.Mp4Parser()
  135.         .box('moov', onSimpleAncestorBox)
  136.         .box('trak', onSimpleAncestorBox)
  137.         .box('mdia', onSimpleAncestorBox)
  138.         .box('minf', onSimpleAncestorBox)
  139.         .box('stbl', onSimpleAncestorBox)
  140.         .fullBox('stsd', (box) => {
  141.           stsdBox = box;
  142.           ancestorBoxes.push(box);
  143.           shaka.util.Mp4Parser.sampleDescription(box);
  144.         })
  145.         .fullBox('encv', onEncryptionMetadataBox)
  146.         .fullBox('enca', onEncryptionMetadataBox)
  147.         .fullBox('dvav', pushEncv)
  148.         .fullBox('dva1', pushEncv)
  149.         .fullBox('dvh1', pushEncv)
  150.         .fullBox('dvhe', pushEncv)
  151.         .fullBox('dvc1', pushEncv)
  152.         .fullBox('dvi1', pushEncv)
  153.         .fullBox('hev1', pushEncv)
  154.         .fullBox('hvc1', pushEncv)
  155.         .fullBox('avc1', pushEncv)
  156.         .fullBox('avc3', pushEncv)
  157.         .fullBox('ac-3', pushEnca)
  158.         .fullBox('ec-3', pushEnca)
  159.         .fullBox('ac-4', pushEnca)
  160.         .fullBox('Opus', pushEnca)
  161.         .fullBox('fLaC', pushEnca)
  162.         .fullBox('mp4a', pushEnca)
  163.         .parse(initSegment);
  165.     if (isEncrypted) {
  166.       shaka.log.debug('Init segment already indicates encryption.');
  167.       return initSegment;
  168.     }
  170.     if (boxesToModify.length == 0 || !stsdBox) {
  171.       shaka.log.error('Failed to find boxes needed to fake encryption!');
  172.       shaka.log.v2('Failed init segment (hex):',
  173.           shaka.util.Uint8ArrayUtils.toHex(initSegment));
  174.       throw new shaka.util.Error(
  175.           shaka.util.Error.Severity.CRITICAL,
  176.           shaka.util.Error.Category.MEDIA,
  177.           shaka.util.Error.Code.CONTENT_TRANSFORMATION_FAILED,
  178.           uri);
  179.     }
  181.     // Modify boxes in order from largest offset to smallest, so that earlier
  182.     // boxes don't have their offsets changed before we process them.
  183.     boxesToModify.reverse();  // in place!
  184.     for (const workItem of boxesToModify) {
  185.       const insertedBoxType =
  186.           shaka.util.Mp4Parser.typeToString(workItem.newType);
  187.       shaka.log.debug(`Inserting "${insertedBoxType}" box into init segment.`);
  188.       modifiedInitSegment = ContentWorkarounds.insertEncryptionMetadata_(
  189.           stream, modifiedInitSegment, stsdBox, workItem.box, ancestorBoxes,
  190.           workItem.newType);
  191.     }
  193.     // Edge Windows needs the unmodified init segment to be appended after the
  194.     // patched one, otherwise video element throws following error:
  195.     // CHUNK_DEMUXER_ERROR_APPEND_FAILED: Sample encryption info is not
  196.     // available.
  197.     if (shaka.util.Platform.isEdge() && shaka.util.Platform.isWindows() &&
  198.         !shaka.util.Platform.isXboxOne()) {
  199.       const doubleInitSegment = new Uint8Array(initSegment.byteLength +
  200.         modifiedInitSegment.byteLength);
  201.       doubleInitSegment.set(modifiedInitSegment);
  202.       doubleInitSegment.set(initSegment, modifiedInitSegment.byteLength);
  203.       return doubleInitSegment;
  204.     }
  206.     return modifiedInitSegment;
  207.   }
  209.   /**
  210.    * @param {!BufferSource} mediaSegmentBuffer
  211.    * @return {!Uint8Array}
  212.    */
  213.   static fakeMediaEncryption(mediaSegmentBuffer) {
  214.     const mediaSegment = shaka.util.BufferUtils.toUint8(mediaSegmentBuffer);
  215.     const mdatBoxes = [];
  216.     new shaka.util.Mp4Parser()
  217.         .box('mdat', (box) => {
  218.           mdatBoxes.push(box);
  219.         })
  220.         .parse(mediaSegment);
  222.     const newSegmentChunks = [];
  223.     for (let i = 0; i < mdatBoxes.length; i++) {
  224.       const prevMdat = mdatBoxes[i - 1];
  225.       const currMdat = mdatBoxes[i];
  226.       const chunkStart = prevMdat ? prevMdat.start + prevMdat.size : 0;
  227.       const chunkEnd = currMdat.start + currMdat.size;
  228.       const chunk = mediaSegment.subarray(chunkStart, chunkEnd);
  229.       newSegmentChunks.push(
  230.           shaka.media.ContentWorkarounds.fakeMediaEncryptionInChunk_(chunk));
  231.     }
  232.     return shaka.util.Uint8ArrayUtils.concat(...newSegmentChunks);
  233.   }
  235.   /**
  236.    * @param {!Uint8Array} chunk
  237.    * @return {!Uint8Array}
  238.    * @private
  239.    */
  240.   static fakeMediaEncryptionInChunk_(chunk) {
  241.     // Which track from stsd we want to use, 1-based.
  242.     const desiredSampleDescriptionIndex = 2;
  243.     let tfhdBox;
  244.     let trunBox;
  245.     let parsedTfhd;
  246.     let parsedTrun;
  247.     const ancestorBoxes = [];
  248.     const onSimpleAncestorBox = (box) => {
  249.       ancestorBoxes.push(box);
  250.       shaka.util.Mp4Parser.children(box);
  251.     };
  252.     const onTfhdBox = (box) => {
  253.       tfhdBox = box;
  254.       parsedTfhd = shaka.util.Mp4BoxParsers.parseTFHD(box.reader, box.flags);
  255.     };
  256.     const onTrunBox = (box) => {
  257.       trunBox = box;
  258.       parsedTrun = shaka.util.Mp4BoxParsers.parseTRUN(box.reader, box.version,
  259.           box.flags);
  260.     };
  261.     new shaka.util.Mp4Parser()
  262.         .box('moof', onSimpleAncestorBox)
  263.         .box('traf', onSimpleAncestorBox)
  264.         .fullBox('tfhd', onTfhdBox)
  265.         .fullBox('trun', onTrunBox)
  266.         .parse(chunk);
  267.     if (parsedTfhd && parsedTfhd.sampleDescriptionIndex !==
  268.         desiredSampleDescriptionIndex) {
  269.       const sdiPosition = tfhdBox.start +
  270.           shaka.util.Mp4Parser.headerSize(tfhdBox) +
  271.           4 + // track_id
  272.           (parsedTfhd.baseDataOffset !== null ? 8 : 0);
  273.       const dataview = shaka.util.BufferUtils.toDataView(chunk);
  274.       if (parsedTfhd.sampleDescriptionIndex !== null) {
  275.         dataview.setUint32(sdiPosition, desiredSampleDescriptionIndex);
  276.       } else {
  277.         const sdiSize = 4; // uint32
  279.         // first, update size & flags of tfhd
  280.         shaka.media.ContentWorkarounds.updateBoxSize_(chunk,
  281.             tfhdBox.start, tfhdBox.size + sdiSize);
  282.         const versionAndFlags = dataview.getUint32(tfhdBox.start + 8);
  283.         dataview.setUint32(tfhdBox.start + 8, versionAndFlags | 0x000002);
  285.         // second, update trun
  286.         if (parsedTrun && parsedTrun.dataOffset !== null) {
  287.           const newDataOffset = parsedTrun.dataOffset + sdiSize;
  288.           const dataOffsetPosition = trunBox.start +
  289.               shaka.util.Mp4Parser.headerSize(trunBox) +
  290.               4; // sample count
  291.           dataview.setInt32(dataOffsetPosition, newDataOffset);
  292.         }
  293.         const beforeSdi = chunk.subarray(0, sdiPosition);
  294.         const afterSdi = chunk.subarray(sdiPosition);
  295.         chunk = new Uint8Array(chunk.byteLength + sdiSize);
  296.         chunk.set(beforeSdi);
  298.         const bytes = [];
  299.         for (let byte = sdiSize - 1; byte >= 0; byte--) {
  300.           bytes.push((desiredSampleDescriptionIndex >> (8 * byte)) & 0xff);
  301.         }
  302.         chunk.set(new Uint8Array(bytes), sdiPosition);
  303.         chunk.set(afterSdi, sdiPosition + sdiSize);
  304.         for (const box of ancestorBoxes) {
  305.           shaka.media.ContentWorkarounds.updateBoxSize_(chunk, box.start,
  306.               box.size + sdiSize);
  307.         }
  308.       }
  309.     }
  311.     return chunk;
  312.   }
  314.   /**
  315.    * Insert an encryption metadata box ("encv" or "enca" box) into the MP4 init
  316.    * segment, based on the source box ("mp4a", "avc1", etc).  Returns a new
  317.    * buffer containing the modified init segment.
  318.    *
  319.    * @param {!shaka.extern.Stream} stream
  320.    * @param {!Uint8Array} initSegment
  321.    * @param {shaka.extern.ParsedBox} stsdBox
  322.    * @param {shaka.extern.ParsedBox} sourceBox
  323.    * @param {!Array<shaka.extern.ParsedBox>} ancestorBoxes
  324.    * @param {number} metadataBoxType
  325.    * @return {!Uint8Array}
  326.    * @private
  327.    */
  328.   static insertEncryptionMetadata_(
  329.       stream, initSegment, stsdBox, sourceBox, ancestorBoxes, metadataBoxType) {
  330.     const ContentWorkarounds = shaka.media.ContentWorkarounds;
  331.     const metadataBoxArray = ContentWorkarounds.createEncryptionMetadata_(
  332.         stream, initSegment, sourceBox, metadataBoxType);
  334.     // Construct a new init segment array with room for the encryption metadata
  335.     // box we're adding.
  336.     const newInitSegment =
  337.         new Uint8Array(initSegment.byteLength + metadataBoxArray.byteLength);
  339.     // For Xbox One & Edge, we cut and insert at the start of the source box.
  340.     // For other platforms, we cut and insert at the end of the source box. It's
  341.     // not clear why this is necessary on Xbox One, but it seems to be evidence
  342.     // of another bug in the firmware implementation of MediaSource & EME.
  343.     const cutPoint = (shaka.util.Platform.isApple() ||
  344.       shaka.util.Platform.isXboxOne() || shaka.util.Platform.isEdge()) ?
  345.         sourceBox.start :
  346.         sourceBox.start + sourceBox.size;
  348.     // The data before the cut point will be copied to the same location as
  349.     // before.  The data after that will be appended after the added metadata
  350.     // box.
  351.     const beforeData = initSegment.subarray(0, cutPoint);
  352.     const afterData = initSegment.subarray(cutPoint);
  354.     newInitSegment.set(beforeData);
  355.     newInitSegment.set(metadataBoxArray, cutPoint);
  356.     newInitSegment.set(afterData, cutPoint + metadataBoxArray.byteLength);
  358.     // The parents up the chain from the encryption metadata box need their
  359.     // sizes adjusted to account for the added box.  These offsets should not be
  360.     // changed, because they should all be within the first section we copy.
  361.     for (const box of ancestorBoxes) {
  362.       goog.asserts.assert(box.start < cutPoint,
  363.           'Ancestor MP4 box found in the wrong location!  ' +
  364.           'Modified init segment will not make sense!');
  365.       ContentWorkarounds.updateBoxSize_(
  366.           newInitSegment, box.start, box.size + metadataBoxArray.byteLength);
  367.     }
  369.     // Add one to the sample entries field of the "stsd" box.  This is a 4-byte
  370.     // field just past the box header.
  371.     const stsdBoxView = shaka.util.BufferUtils.toDataView(
  372.         newInitSegment, stsdBox.start);
  373.     const stsdBoxHeaderSize = shaka.util.Mp4Parser.headerSize(stsdBox);
  374.     const numEntries = stsdBoxView.getUint32(stsdBoxHeaderSize);
  375.     stsdBoxView.setUint32(stsdBoxHeaderSize, numEntries + 1);
  377.     return newInitSegment;
  378.   }
  380.   /**
  381.    * Create an encryption metadata box ("encv" or "enca" box), based on the
  382.    * source box ("mp4a", "avc1", etc).  Returns a new buffer containing the
  383.    * encryption metadata box.
  384.    *
  385.    * @param {!shaka.extern.Stream} stream
  386.    * @param {!Uint8Array} initSegment
  387.    * @param {shaka.extern.ParsedBox} sourceBox
  388.    * @param {number} metadataBoxType
  389.    * @return {!Uint8Array}
  390.    * @private
  391.    */
  392.   static createEncryptionMetadata_(stream, initSegment, sourceBox,
  393.       metadataBoxType) {
  394.     const ContentWorkarounds = shaka.media.ContentWorkarounds;
  396.     const mp4Generator = new shaka.util.Mp4Generator([]);
  397.     const sinfBoxArray = mp4Generator.sinf(stream, sourceBox.name);
  399.     // Create a subarray which points to the source box data.
  400.     const sourceBoxArray = initSegment.subarray(
  401.         /* start= */ sourceBox.start,
  402.         /* end= */ sourceBox.start + sourceBox.size);
  404.     // Create an array to hold the new encryption metadata box, which is based
  405.     // on the source box.
  406.     const metadataBoxArray = new Uint8Array(
  407.         sourceBox.size + sinfBoxArray.byteLength);
  409.     // Copy the source box into the new array.
  410.     metadataBoxArray.set(sourceBoxArray, /* targetOffset= */ 0);
  412.     // Change the box type.
  413.     const metadataBoxView = shaka.util.BufferUtils.toDataView(metadataBoxArray);
  414.     metadataBoxView.setUint32(
  415.         ContentWorkarounds.BOX_TYPE_OFFSET_, metadataBoxType);
  417.     // Append the "sinf" box to the encryption metadata box.
  418.     metadataBoxArray.set(sinfBoxArray, /* targetOffset= */ sourceBox.size);
  420.     // Now update the encryption metadata box size.
  421.     ContentWorkarounds.updateBoxSize_(
  422.         metadataBoxArray, /* boxStart= */ 0, metadataBoxArray.byteLength);
  424.     return metadataBoxArray;
  425.   }
  427.   /**
  428.    * Modify an MP4 box's size field in-place.
  429.    *
  430.    * @param {!Uint8Array} dataArray
  431.    * @param {number} boxStart The start position of the box in dataArray.
  432.    * @param {number} newBoxSize The new size of the box.
  433.    * @private
  434.    */
  435.   static updateBoxSize_(dataArray, boxStart, newBoxSize) {
  436.     const ContentWorkarounds = shaka.media.ContentWorkarounds;
  437.     const boxView = shaka.util.BufferUtils.toDataView(dataArray, boxStart);
  438.     const sizeField = boxView.getUint32(ContentWorkarounds.BOX_SIZE_OFFSET_);
  439.     if (sizeField == 0) { // Means "the rest of the box".
  440.       // No adjustment needed for this box.
  441.     } else if (sizeField == 1) { // Means "use 64-bit size box".
  442.       // Set the 64-bit int in two 32-bit parts.
  443.       // The high bits should definitely be 0 in practice, but we're being
  444.       // thorough here.
  445.       boxView.setUint32(ContentWorkarounds.BOX_SIZE_64_OFFSET_,
  446.           newBoxSize >> 32);
  447.       boxView.setUint32(ContentWorkarounds.BOX_SIZE_64_OFFSET_ + 4,
  448.           newBoxSize & 0xffffffff);
  449.     } else { // Normal 32-bit size field.
  450.       // Not checking the size of the value here, since a box larger than 4GB is
  451.       // unrealistic.
  452.       boxView.setUint32(ContentWorkarounds.BOX_SIZE_OFFSET_, newBoxSize);
  453.     }
  454.   }
  456.   /**
  457.    * Transform the init segment into a new init segment buffer that indicates
  458.    * EC-3 as audio codec instead of AC-3. Even though any EC-3 decoder should
  459.    * be able to decode AC-3 streams, there are platforms that do not accept
  460.    * AC-3 as codec.
  461.    *
  462.    * Should only be called for MP4 init segments, and only on platforms that
  463.    * need this workaround. Returns a new buffer containing the modified init
  464.    * segment.
  465.    *
  466.    * @param {!BufferSource} initSegmentBuffer
  467.    * @return {!Uint8Array}
  468.    */
  469.   static fakeEC3(initSegmentBuffer) {
  470.     const ContentWorkarounds = shaka.media.ContentWorkarounds;
  471.     const initSegment = shaka.util.BufferUtils.toUint8(initSegmentBuffer);
  472.     const ancestorBoxes = [];
  474.     const onSimpleAncestorBox = (box) => {
  475.       ancestorBoxes.push({start: box.start, size: box.size});
  476.       shaka.util.Mp4Parser.children(box);
  477.     };
  479.     new shaka.util.Mp4Parser()
  480.         .box('moov', onSimpleAncestorBox)
  481.         .box('trak', onSimpleAncestorBox)
  482.         .box('mdia', onSimpleAncestorBox)
  483.         .box('minf', onSimpleAncestorBox)
  484.         .box('stbl', onSimpleAncestorBox)
  485.         .box('stsd', (box) => {
  486.           ancestorBoxes.push({start: box.start, size: box.size});
  487.           const stsdBoxView = shaka.util.BufferUtils.toDataView(
  488.               initSegment, box.start);
  489.           // "size - 3" is because we immediately read a uint32.
  490.           for (let i = 0; i < box.size -3; i++) {
  491.             const codecTag = stsdBoxView.getUint32(i);
  492.             if (codecTag == ContentWorkarounds.BOX_TYPE_AC_3_) {
  493.               stsdBoxView.setUint32(i, ContentWorkarounds.BOX_TYPE_EC_3_);
  494.             } else if (codecTag == ContentWorkarounds.BOX_TYPE_DAC3_) {
  495.               stsdBoxView.setUint32(i, ContentWorkarounds.BOX_TYPE_DEC3_);
  496.             }
  497.           }
  498.         }).parse(initSegment);
  500.     return initSegment;
  501.   }
  502. };
  504. /**
  505.  * Offset to a box's size field.
  506.  *
  507.  * @const {number}
  508.  * @private
  509.  */
  510. shaka.media.ContentWorkarounds.BOX_SIZE_OFFSET_ = 0;
  512. /**
  513.  * Offset to a box's type field.
  514.  *
  515.  * @const {number}
  516.  * @private
  517.  */
  518. shaka.media.ContentWorkarounds.BOX_TYPE_OFFSET_ = 4;
  520. /**
  521.  * Offset to a box's 64-bit size field, if it has one.
  522.  *
  523.  * @const {number}
  524.  * @private
  525.  */
  526. shaka.media.ContentWorkarounds.BOX_SIZE_64_OFFSET_ = 8;
  528. /**
  529.  * Box type for "encv".
  530.  *
  531.  * @const {number}
  532.  * @private
  533.  */
  534. shaka.media.ContentWorkarounds.BOX_TYPE_ENCV_ = 0x656e6376;
  536. /**
  537.  * Box type for "enca".
  538.  *
  539.  * @const {number}
  540.  * @private
  541.  */
  542. shaka.media.ContentWorkarounds.BOX_TYPE_ENCA_ = 0x656e6361;
  544. /**
  545.  * Box type for "ac-3".
  546.  *
  547.  * @const {number}
  548.  * @private
  549.  */
  550. shaka.media.ContentWorkarounds.BOX_TYPE_AC_3_ = 0x61632d33;
  552. /**
  553.  * Box type for "dac3".
  554.  *
  555.  * @const {number}
  556.  * @private
  557.  */
  558. shaka.media.ContentWorkarounds.BOX_TYPE_DAC3_ = 0x64616333;
  560. /**
  561.  * Box type for "ec-3".
  562.  *
  563.  * @const {number}
  564.  * @private
  565.  */
  566. shaka.media.ContentWorkarounds.BOX_TYPE_EC_3_ = 0x65632d33;
  568. /**
  569.  * Box type for "dec3".
  570.  *
  571.  * @const {number}
  572.  * @private
  573.  */
  574. shaka.media.ContentWorkarounds.BOX_TYPE_DEC3_ = 0x64656333;