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.    * Transform the init segment into a new init segment buffer that indicates
  27.    * encryption.  If the init segment already indicates encryption, return the
  28.    * original init segment.
  29.    *
  30.    * Should only be called for MP4 init segments, and only on platforms that
  31.    * need this workaround.
  32.    *
  33.    * @param {!shaka.extern.Stream} stream
  34.    * @param {!BufferSource} initSegmentBuffer
  35.    * @param {?string} uri
  36.    * @return {!Uint8Array}
  37.    * @see https://github.com/shaka-project/shaka-player/issues/2759
  38.    */
  39.   static fakeEncryption(stream, initSegmentBuffer, uri) {
  40.     const ContentWorkarounds = shaka.media.ContentWorkarounds;
  41.     const initSegment = shaka.util.BufferUtils.toUint8(initSegmentBuffer);
  42.     let modifiedInitSegment = initSegment;
  43.     let isEncrypted = false;
  44.     /** @type {shaka.extern.ParsedBox} */
  45.     let stsdBox;
  46.     const ancestorBoxes = [];
  48.     const onSimpleAncestorBox = (box) => {
  49.       ancestorBoxes.push(box);
  50.       shaka.util.Mp4Parser.children(box);
  51.     };
  53.     const onEncryptionMetadataBox = (box) => {
  54.       isEncrypted = true;
  55.       box.parser.stop();
  56.     };
  58.     // Multiplexed content could have multiple boxes that we need to modify.
  59.     // Add to this array in order of box offset.  This will be important later,
  60.     // when we process the boxes.
  61.     /** @type {!Array<{box: shaka.extern.ParsedBox, newType: number}>} */
  62.     const boxesToModify = [];
  64.     const pushEncv = (box) => {
  65.       boxesToModify.push({
  66.         box,
  67.         newType: ContentWorkarounds.BOX_TYPE_ENCV_,
  68.       });
  69.     };
  71.     const pushEnca = (box) => {
  72.       boxesToModify.push({
  73.         box,
  74.         newType: ContentWorkarounds.BOX_TYPE_ENCA_,
  75.       });
  76.     };
  78.     new shaka.util.Mp4Parser()
  79.         .box('moov', onSimpleAncestorBox)
  80.         .box('trak', onSimpleAncestorBox)
  81.         .box('mdia', onSimpleAncestorBox)
  82.         .box('minf', onSimpleAncestorBox)
  83.         .box('stbl', onSimpleAncestorBox)
  84.         .fullBox('stsd', (box) => {
  85.           stsdBox = box;
  86.           ancestorBoxes.push(box);
  87.           shaka.util.Mp4Parser.sampleDescription(box);
  88.         })
  89.         .fullBox('encv', onEncryptionMetadataBox)
  90.         .fullBox('enca', onEncryptionMetadataBox)
  91.         .fullBox('dvav', pushEncv)
  92.         .fullBox('dva1', pushEncv)
  93.         .fullBox('dvh1', pushEncv)
  94.         .fullBox('dvhe', pushEncv)
  95.         .fullBox('dvc1', pushEncv)
  96.         .fullBox('dvi1', pushEncv)
  97.         .fullBox('hev1', pushEncv)
  98.         .fullBox('hvc1', pushEncv)
  99.         .fullBox('avc1', pushEncv)
  100.         .fullBox('avc3', pushEncv)
  101.         .fullBox('ac-3', pushEnca)
  102.         .fullBox('ec-3', pushEnca)
  103.         .fullBox('ac-4', pushEnca)
  104.         .fullBox('Opus', pushEnca)
  105.         .fullBox('fLaC', pushEnca)
  106.         .fullBox('mp4a', pushEnca)
  107.         .parse(initSegment);
  109.     if (isEncrypted) {
  110.       shaka.log.debug('Init segment already indicates encryption.');
  111.       return initSegment;
  112.     }
  114.     if (boxesToModify.length == 0 || !stsdBox) {
  115.       shaka.log.error('Failed to find boxes needed to fake encryption!');
  116.       shaka.log.v2('Failed init segment (hex):',
  117.           shaka.util.Uint8ArrayUtils.toHex(initSegment));
  118.       throw new shaka.util.Error(
  119.           shaka.util.Error.Severity.CRITICAL,
  120.           shaka.util.Error.Category.MEDIA,
  121.           shaka.util.Error.Code.CONTENT_TRANSFORMATION_FAILED,
  122.           uri);
  123.     }
  125.     // Modify boxes in order from largest offset to smallest, so that earlier
  126.     // boxes don't have their offsets changed before we process them.
  127.     boxesToModify.reverse();  // in place!
  128.     for (const workItem of boxesToModify) {
  129.       const insertedBoxType =
  130.           shaka.util.Mp4Parser.typeToString(workItem.newType);
  131.       shaka.log.debug(`Inserting "${insertedBoxType}" box into init segment.`);
  132.       modifiedInitSegment = ContentWorkarounds.insertEncryptionMetadata_(
  133.           stream, modifiedInitSegment, stsdBox, workItem.box, ancestorBoxes,
  134.           workItem.newType);
  135.     }
  137.     // Edge Windows needs the unmodified init segment to be appended after the
  138.     // patched one, otherwise video element throws following error:
  139.     // CHUNK_DEMUXER_ERROR_APPEND_FAILED: Sample encryption info is not
  140.     // available.
  141.     if (shaka.util.Platform.isEdge() && shaka.util.Platform.isWindows() &&
  142.         !shaka.util.Platform.isXboxOne()) {
  143.       const doubleInitSegment = new Uint8Array(initSegment.byteLength +
  144.         modifiedInitSegment.byteLength);
  145.       doubleInitSegment.set(modifiedInitSegment);
  146.       doubleInitSegment.set(initSegment, modifiedInitSegment.byteLength);
  147.       return doubleInitSegment;
  148.     }
  150.     return modifiedInitSegment;
  151.   }
  153.   /**
  154.    * @param {!BufferSource} mediaSegmentBuffer
  155.    * @return {!Uint8Array}
  156.    */
  157.   static fakeMediaEncryption(mediaSegmentBuffer) {
  158.     const mediaSegment = shaka.util.BufferUtils.toUint8(mediaSegmentBuffer);
  159.     const mdatBoxes = [];
  160.     new shaka.util.Mp4Parser()
  161.         .box('mdat', (box) => {
  162.           mdatBoxes.push(box);
  163.         })
  164.         .parse(mediaSegment);
  166.     const newSegmentChunks = [];
  167.     for (let i = 0; i < mdatBoxes.length; i++) {
  168.       const prevMdat = mdatBoxes[i - 1];
  169.       const currMdat = mdatBoxes[i];
  170.       const chunkStart = prevMdat ? prevMdat.start + prevMdat.size : 0;
  171.       const chunkEnd = currMdat.start + currMdat.size;
  172.       const chunk = mediaSegment.subarray(chunkStart, chunkEnd);
  173.       newSegmentChunks.push(
  174.           shaka.media.ContentWorkarounds.fakeMediaEncryptionInChunk_(chunk));
  175.     }
  176.     return shaka.util.Uint8ArrayUtils.concat(...newSegmentChunks);
  177.   }
  179.   /**
  180.    * @param {!Uint8Array} chunk
  181.    * @return {!Uint8Array}
  182.    * @private
  183.    */
  184.   static fakeMediaEncryptionInChunk_(chunk) {
  185.     // Which track from stsd we want to use, 1-based.
  186.     const desiredSampleDescriptionIndex = 2;
  187.     let tfhdBox;
  188.     let trunBox;
  189.     let parsedTfhd;
  190.     let parsedTrun;
  191.     const ancestorBoxes = [];
  192.     const onSimpleAncestorBox = (box) => {
  193.       ancestorBoxes.push(box);
  194.       shaka.util.Mp4Parser.children(box);
  195.     };
  196.     const onTfhdBox = (box) => {
  197.       tfhdBox = box;
  198.       parsedTfhd = shaka.util.Mp4BoxParsers.parseTFHD(box.reader, box.flags);
  199.     };
  200.     const onTrunBox = (box) => {
  201.       trunBox = box;
  202.       parsedTrun = shaka.util.Mp4BoxParsers.parseTRUN(box.reader, box.version,
  203.           box.flags);
  204.     };
  205.     new shaka.util.Mp4Parser()
  206.         .box('moof', onSimpleAncestorBox)
  207.         .box('traf', onSimpleAncestorBox)
  208.         .fullBox('tfhd', onTfhdBox)
  209.         .fullBox('trun', onTrunBox)
  210.         .parse(chunk);
  211.     if (parsedTfhd && parsedTfhd.sampleDescriptionIndex !==
  212.         desiredSampleDescriptionIndex) {
  213.       const sdiPosition = tfhdBox.start +
  214.           shaka.util.Mp4Parser.headerSize(tfhdBox) +
  215.           4 + // track_id
  216.           (parsedTfhd.baseDataOffset !== null ? 8 : 0);
  217.       const dataview = shaka.util.BufferUtils.toDataView(chunk);
  218.       if (parsedTfhd.sampleDescriptionIndex !== null) {
  219.         dataview.setUint32(sdiPosition, desiredSampleDescriptionIndex);
  220.       } else {
  221.         const sdiSize = 4; // uint32
  223.         // first, update size & flags of tfhd
  224.         shaka.media.ContentWorkarounds.updateBoxSize_(chunk,
  225.             tfhdBox.start, tfhdBox.size + sdiSize);
  226.         const versionAndFlags = dataview.getUint32(tfhdBox.start + 8);
  227.         dataview.setUint32(tfhdBox.start + 8, versionAndFlags | 0x000002);
  229.         // second, update trun
  230.         if (parsedTrun && parsedTrun.dataOffset !== null) {
  231.           const newDataOffset = parsedTrun.dataOffset + sdiSize;
  232.           const dataOffsetPosition = trunBox.start +
  233.               shaka.util.Mp4Parser.headerSize(trunBox) +
  234.               4; // sample count
  235.           dataview.setInt32(dataOffsetPosition, newDataOffset);
  236.         }
  237.         const beforeSdi = chunk.subarray(0, sdiPosition);
  238.         const afterSdi = chunk.subarray(sdiPosition);
  239.         chunk = new Uint8Array(chunk.byteLength + sdiSize);
  240.         chunk.set(beforeSdi);
  242.         const bytes = [];
  243.         for (let byte = sdiSize - 1; byte >= 0; byte--) {
  244.           bytes.push((desiredSampleDescriptionIndex >> (8 * byte)) & 0xff);
  245.         }
  246.         chunk.set(new Uint8Array(bytes), sdiPosition);
  247.         chunk.set(afterSdi, sdiPosition + sdiSize);
  248.         for (const box of ancestorBoxes) {
  249.           shaka.media.ContentWorkarounds.updateBoxSize_(chunk, box.start,
  250.               box.size + sdiSize);
  251.         }
  252.       }
  253.     }
  255.     return chunk;
  256.   }
  258.   /**
  259.    * Insert an encryption metadata box ("encv" or "enca" box) into the MP4 init
  260.    * segment, based on the source box ("mp4a", "avc1", etc).  Returns a new
  261.    * buffer containing the modified init segment.
  262.    *
  263.    * @param {!shaka.extern.Stream} stream
  264.    * @param {!Uint8Array} initSegment
  265.    * @param {shaka.extern.ParsedBox} stsdBox
  266.    * @param {shaka.extern.ParsedBox} sourceBox
  267.    * @param {!Array<shaka.extern.ParsedBox>} ancestorBoxes
  268.    * @param {number} metadataBoxType
  269.    * @return {!Uint8Array}
  270.    * @private
  271.    */
  272.   static insertEncryptionMetadata_(
  273.       stream, initSegment, stsdBox, sourceBox, ancestorBoxes, metadataBoxType) {
  274.     const ContentWorkarounds = shaka.media.ContentWorkarounds;
  275.     const metadataBoxArray = ContentWorkarounds.createEncryptionMetadata_(
  276.         stream, initSegment, sourceBox, metadataBoxType);
  278.     // Construct a new init segment array with room for the encryption metadata
  279.     // box we're adding.
  280.     const newInitSegment =
  281.         new Uint8Array(initSegment.byteLength + metadataBoxArray.byteLength);
  283.     // For Xbox One & Edge, we cut and insert at the start of the source box.
  284.     // For other platforms, we cut and insert at the end of the source box. It's
  285.     // not clear why this is necessary on Xbox One, but it seems to be evidence
  286.     // of another bug in the firmware implementation of MediaSource & EME.
  287.     const cutPoint = (shaka.util.Platform.isApple() ||
  288.       shaka.util.Platform.isXboxOne() || shaka.util.Platform.isEdge()) ?
  289.         sourceBox.start :
  290.         sourceBox.start + sourceBox.size;
  292.     // The data before the cut point will be copied to the same location as
  293.     // before.  The data after that will be appended after the added metadata
  294.     // box.
  295.     const beforeData = initSegment.subarray(0, cutPoint);
  296.     const afterData = initSegment.subarray(cutPoint);
  298.     newInitSegment.set(beforeData);
  299.     newInitSegment.set(metadataBoxArray, cutPoint);
  300.     newInitSegment.set(afterData, cutPoint + metadataBoxArray.byteLength);
  302.     // The parents up the chain from the encryption metadata box need their
  303.     // sizes adjusted to account for the added box.  These offsets should not be
  304.     // changed, because they should all be within the first section we copy.
  305.     for (const box of ancestorBoxes) {
  306.       goog.asserts.assert(box.start < cutPoint,
  307.           'Ancestor MP4 box found in the wrong location!  ' +
  308.           'Modified init segment will not make sense!');
  309.       ContentWorkarounds.updateBoxSize_(
  310.           newInitSegment, box.start, box.size + metadataBoxArray.byteLength);
  311.     }
  313.     // Add one to the sample entries field of the "stsd" box.  This is a 4-byte
  314.     // field just past the box header.
  315.     const stsdBoxView = shaka.util.BufferUtils.toDataView(
  316.         newInitSegment, stsdBox.start);
  317.     const stsdBoxHeaderSize = shaka.util.Mp4Parser.headerSize(stsdBox);
  318.     const numEntries = stsdBoxView.getUint32(stsdBoxHeaderSize);
  319.     stsdBoxView.setUint32(stsdBoxHeaderSize, numEntries + 1);
  321.     return newInitSegment;
  322.   }
  324.   /**
  325.    * Create an encryption metadata box ("encv" or "enca" box), based on the
  326.    * source box ("mp4a", "avc1", etc).  Returns a new buffer containing the
  327.    * encryption metadata box.
  328.    *
  329.    * @param {!shaka.extern.Stream} stream
  330.    * @param {!Uint8Array} initSegment
  331.    * @param {shaka.extern.ParsedBox} sourceBox
  332.    * @param {number} metadataBoxType
  333.    * @return {!Uint8Array}
  334.    * @private
  335.    */
  336.   static createEncryptionMetadata_(stream, initSegment, sourceBox,
  337.       metadataBoxType) {
  338.     const ContentWorkarounds = shaka.media.ContentWorkarounds;
  340.     const mp4Generator = new shaka.util.Mp4Generator([]);
  341.     const sinfBoxArray = mp4Generator.sinf(stream, sourceBox.name);
  343.     // Create a subarray which points to the source box data.
  344.     const sourceBoxArray = initSegment.subarray(
  345.         /* start= */ sourceBox.start,
  346.         /* end= */ sourceBox.start + sourceBox.size);
  348.     // Create an array to hold the new encryption metadata box, which is based
  349.     // on the source box.
  350.     const metadataBoxArray = new Uint8Array(
  351.         sourceBox.size + sinfBoxArray.byteLength);
  353.     // Copy the source box into the new array.
  354.     metadataBoxArray.set(sourceBoxArray, /* targetOffset= */ 0);
  356.     // Change the box type.
  357.     const metadataBoxView = shaka.util.BufferUtils.toDataView(metadataBoxArray);
  358.     metadataBoxView.setUint32(
  359.         ContentWorkarounds.BOX_TYPE_OFFSET_, metadataBoxType);
  361.     // Append the "sinf" box to the encryption metadata box.
  362.     metadataBoxArray.set(sinfBoxArray, /* targetOffset= */ sourceBox.size);
  364.     // Now update the encryption metadata box size.
  365.     ContentWorkarounds.updateBoxSize_(
  366.         metadataBoxArray, /* boxStart= */ 0, metadataBoxArray.byteLength);
  368.     return metadataBoxArray;
  369.   }
  371.   /**
  372.    * Modify an MP4 box's size field in-place.
  373.    *
  374.    * @param {!Uint8Array} dataArray
  375.    * @param {number} boxStart The start position of the box in dataArray.
  376.    * @param {number} newBoxSize The new size of the box.
  377.    * @private
  378.    */
  379.   static updateBoxSize_(dataArray, boxStart, newBoxSize) {
  380.     const ContentWorkarounds = shaka.media.ContentWorkarounds;
  381.     const boxView = shaka.util.BufferUtils.toDataView(dataArray, boxStart);
  382.     const sizeField = boxView.getUint32(ContentWorkarounds.BOX_SIZE_OFFSET_);
  383.     if (sizeField == 0) { // Means "the rest of the box".
  384.       // No adjustment needed for this box.
  385.     } else if (sizeField == 1) { // Means "use 64-bit size box".
  386.       // Set the 64-bit int in two 32-bit parts.
  387.       // The high bits should definitely be 0 in practice, but we're being
  388.       // thorough here.
  389.       boxView.setUint32(ContentWorkarounds.BOX_SIZE_64_OFFSET_,
  390.           newBoxSize >> 32);
  391.       boxView.setUint32(ContentWorkarounds.BOX_SIZE_64_OFFSET_ + 4,
  392.           newBoxSize & 0xffffffff);
  393.     } else { // Normal 32-bit size field.
  394.       // Not checking the size of the value here, since a box larger than 4GB is
  395.       // unrealistic.
  396.       boxView.setUint32(ContentWorkarounds.BOX_SIZE_OFFSET_, newBoxSize);
  397.     }
  398.   }
  400.   /**
  401.    * Transform the init segment into a new init segment buffer that indicates
  402.    * EC-3 as audio codec instead of AC-3. Even though any EC-3 decoder should
  403.    * be able to decode AC-3 streams, there are platforms that do not accept
  404.    * AC-3 as codec.
  405.    *
  406.    * Should only be called for MP4 init segments, and only on platforms that
  407.    * need this workaround. Returns a new buffer containing the modified init
  408.    * segment.
  409.    *
  410.    * @param {!BufferSource} initSegmentBuffer
  411.    * @return {!Uint8Array}
  412.    */
  413.   static fakeEC3(initSegmentBuffer) {
  414.     const ContentWorkarounds = shaka.media.ContentWorkarounds;
  415.     const initSegment = shaka.util.BufferUtils.toUint8(initSegmentBuffer);
  416.     const ancestorBoxes = [];
  418.     const onSimpleAncestorBox = (box) => {
  419.       ancestorBoxes.push({start: box.start, size: box.size});
  420.       shaka.util.Mp4Parser.children(box);
  421.     };
  423.     new shaka.util.Mp4Parser()
  424.         .box('moov', onSimpleAncestorBox)
  425.         .box('trak', onSimpleAncestorBox)
  426.         .box('mdia', onSimpleAncestorBox)
  427.         .box('minf', onSimpleAncestorBox)
  428.         .box('stbl', onSimpleAncestorBox)
  429.         .box('stsd', (box) => {
  430.           ancestorBoxes.push({start: box.start, size: box.size});
  431.           const stsdBoxView = shaka.util.BufferUtils.toDataView(
  432.               initSegment, box.start);
  433.           // "size - 3" is because we immediately read a uint32.
  434.           for (let i = 0; i < box.size -3; i++) {
  435.             const codecTag = stsdBoxView.getUint32(i);
  436.             if (codecTag == ContentWorkarounds.BOX_TYPE_AC_3_) {
  437.               stsdBoxView.setUint32(i, ContentWorkarounds.BOX_TYPE_EC_3_);
  438.             } else if (codecTag == ContentWorkarounds.BOX_TYPE_DAC3_) {
  439.               stsdBoxView.setUint32(i, ContentWorkarounds.BOX_TYPE_DEC3_);
  440.             }
  441.           }
  442.         }).parse(initSegment);
  444.     return initSegment;
  445.   }
  446. };
  448. /**
  449.  * Offset to a box's size field.
  450.  *
  451.  * @const {number}
  452.  * @private
  453.  */
  454. shaka.media.ContentWorkarounds.BOX_SIZE_OFFSET_ = 0;
  456. /**
  457.  * Offset to a box's type field.
  458.  *
  459.  * @const {number}
  460.  * @private
  461.  */
  462. shaka.media.ContentWorkarounds.BOX_TYPE_OFFSET_ = 4;
  464. /**
  465.  * Offset to a box's 64-bit size field, if it has one.
  466.  *
  467.  * @const {number}
  468.  * @private
  469.  */
  470. shaka.media.ContentWorkarounds.BOX_SIZE_64_OFFSET_ = 8;
  472. /**
  473.  * Box type for "encv".
  474.  *
  475.  * @const {number}
  476.  * @private
  477.  */
  478. shaka.media.ContentWorkarounds.BOX_TYPE_ENCV_ = 0x656e6376;
  480. /**
  481.  * Box type for "enca".
  482.  *
  483.  * @const {number}
  484.  * @private
  485.  */
  486. shaka.media.ContentWorkarounds.BOX_TYPE_ENCA_ = 0x656e6361;
  488. /**
  489.  * Box type for "ac-3".
  490.  *
  491.  * @const {number}
  492.  * @private
  493.  */
  494. shaka.media.ContentWorkarounds.BOX_TYPE_AC_3_ = 0x61632d33;
  496. /**
  497.  * Box type for "dac3".
  498.  *
  499.  * @const {number}
  500.  * @private
  501.  */
  502. shaka.media.ContentWorkarounds.BOX_TYPE_DAC3_ = 0x64616333;
  504. /**
  505.  * Box type for "ec-3".
  506.  *
  507.  * @const {number}
  508.  * @private
  509.  */
  510. shaka.media.ContentWorkarounds.BOX_TYPE_EC_3_ = 0x65632d33;
  512. /**
  513.  * Box type for "dec3".
  514.  *
  515.  * @const {number}
  516.  * @private
  517.  */
  518. shaka.media.ContentWorkarounds.BOX_TYPE_DEC3_ = 0x64656333;