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.Lazy');
  14. goog.require('shaka.util.Mp4Parser');
  15. goog.require('shaka.util.Platform');
  16. goog.require('shaka.util.Uint8ArrayUtils');
  19. /**
  20.  * @summary
  21.  * A collection of methods to work around content issues on various platforms.
  22.  */
  23. shaka.media.ContentWorkarounds = class {
  24.   /**
  25.    * Transform the init segment into a new init segment buffer that indicates
  26.    * encryption.  If the init segment already indicates encryption, return the
  27.    * original init segment.
  28.    *
  29.    * Should only be called for MP4 init segments, and only on platforms that
  30.    * need this workaround.
  31.    *
  32.    * @param {!BufferSource} initSegmentBuffer
  33.    * @param {?string} uri
  34.    * @return {!Uint8Array}
  35.    * @see https://github.com/shaka-project/shaka-player/issues/2759
  36.    */
  37.   static fakeEncryption(initSegmentBuffer, uri) {
  38.     const ContentWorkarounds = shaka.media.ContentWorkarounds;
  39.     const initSegment = shaka.util.BufferUtils.toUint8(initSegmentBuffer);
  40.     let modifiedInitSegment = initSegment;
  41.     let isEncrypted = false;
  42.     /** @type {shaka.extern.ParsedBox} */
  43.     let stsdBox;
  44.     const ancestorBoxes = [];
  46.     const onSimpleAncestorBox = (box) => {
  47.       ancestorBoxes.push(box);
  48.       shaka.util.Mp4Parser.children(box);
  49.     };
  51.     const onEncryptionMetadataBox = (box) => {
  52.       isEncrypted = true;
  53.     };
  55.     // Multiplexed content could have multiple boxes that we need to modify.
  56.     // Add to this array in order of box offset.  This will be important later,
  57.     // when we process the boxes.
  58.     /** @type {!Array<{box: shaka.extern.ParsedBox, newType: number}>} */
  59.     const boxesToModify = [];
  61.     new shaka.util.Mp4Parser()
  62.         .box('moov', onSimpleAncestorBox)
  63.         .box('trak', onSimpleAncestorBox)
  64.         .box('mdia', onSimpleAncestorBox)
  65.         .box('minf', onSimpleAncestorBox)
  66.         .box('stbl', onSimpleAncestorBox)
  67.         .fullBox('stsd', (box) => {
  68.           stsdBox = box;
  69.           ancestorBoxes.push(box);
  70.           shaka.util.Mp4Parser.sampleDescription(box);
  71.         })
  72.         .fullBox('encv', onEncryptionMetadataBox)
  73.         .fullBox('enca', onEncryptionMetadataBox)
  74.         .fullBox('dvav', (box) => {
  75.           boxesToModify.push({
  76.             box,
  77.             newType: ContentWorkarounds.BOX_TYPE_ENCV_,
  78.           });
  79.         })
  80.         .fullBox('dva1', (box) => {
  81.           boxesToModify.push({
  82.             box,
  83.             newType: ContentWorkarounds.BOX_TYPE_ENCV_,
  84.           });
  85.         })
  86.         .fullBox('dvh1', (box) => {
  87.           boxesToModify.push({
  88.             box,
  89.             newType: ContentWorkarounds.BOX_TYPE_ENCV_,
  90.           });
  91.         })
  92.         .fullBox('dvhe', (box) => {
  93.           boxesToModify.push({
  94.             box,
  95.             newType: ContentWorkarounds.BOX_TYPE_ENCV_,
  96.           });
  97.         })
  98.         .fullBox('dvc1', (box) => {
  99.           boxesToModify.push({
  100.             box,
  101.             newType: ContentWorkarounds.BOX_TYPE_ENCV_,
  102.           });
  103.         })
  104.         .fullBox('dvi1', (box) => {
  105.           boxesToModify.push({
  106.             box,
  107.             newType: ContentWorkarounds.BOX_TYPE_ENCV_,
  108.           });
  109.         })
  110.         .fullBox('hev1', (box) => {
  111.           boxesToModify.push({
  112.             box,
  113.             newType: ContentWorkarounds.BOX_TYPE_ENCV_,
  114.           });
  115.         })
  116.         .fullBox('hvc1', (box) => {
  117.           boxesToModify.push({
  118.             box,
  119.             newType: ContentWorkarounds.BOX_TYPE_ENCV_,
  120.           });
  121.         })
  122.         .fullBox('avc1', (box) => {
  123.           boxesToModify.push({
  124.             box,
  125.             newType: ContentWorkarounds.BOX_TYPE_ENCV_,
  126.           });
  127.         })
  128.         .fullBox('avc3', (box) => {
  129.           boxesToModify.push({
  130.             box,
  131.             newType: ContentWorkarounds.BOX_TYPE_ENCV_,
  132.           });
  133.         })
  134.         .fullBox('ac-3', (box) => {
  135.           boxesToModify.push({
  136.             box,
  137.             newType: ContentWorkarounds.BOX_TYPE_ENCA_,
  138.           });
  139.         })
  140.         .fullBox('ec-3', (box) => {
  141.           boxesToModify.push({
  142.             box,
  143.             newType: ContentWorkarounds.BOX_TYPE_ENCA_,
  144.           });
  145.         })
  146.         .fullBox('ac-4', (box) => {
  147.           boxesToModify.push({
  148.             box,
  149.             newType: ContentWorkarounds.BOX_TYPE_ENCA_,
  150.           });
  151.         })
  152.         .fullBox('mp4a', (box) => {
  153.           boxesToModify.push({
  154.             box,
  155.             newType: ContentWorkarounds.BOX_TYPE_ENCA_,
  156.           });
  157.         }).parse(initSegment);
  159.     if (isEncrypted) {
  160.       shaka.log.debug('Init segment already indicates encryption.');
  161.       return initSegment;
  162.     }
  164.     if (boxesToModify.length == 0 || !stsdBox) {
  165.       shaka.log.error('Failed to find boxes needed to fake encryption!');
  166.       shaka.log.v2('Failed init segment (hex):',
  167.           shaka.util.Uint8ArrayUtils.toHex(initSegment));
  168.       throw new shaka.util.Error(
  169.           shaka.util.Error.Severity.CRITICAL,
  170.           shaka.util.Error.Category.MEDIA,
  171.           shaka.util.Error.Code.CONTENT_TRANSFORMATION_FAILED,
  172.           uri);
  173.     }
  175.     // Modify boxes in order from largest offset to smallest, so that earlier
  176.     // boxes don't have their offsets changed before we process them.
  177.     boxesToModify.reverse();  // in place!
  178.     for (const workItem of boxesToModify) {
  179.       const insertedBoxType =
  180.           shaka.util.Mp4Parser.typeToString(workItem.newType);
  181.       shaka.log.debug(`Inserting "${insertedBoxType}" box into init segment.`);
  182.       modifiedInitSegment = ContentWorkarounds.insertEncryptionMetadata_(
  183.           modifiedInitSegment, stsdBox, workItem.box, ancestorBoxes,
  184.           workItem.newType);
  185.     }
  187.     // Edge Windows needs the unmodified init segment to be appended after the
  188.     // patched one, otherwise video element throws following error:
  189.     // CHUNK_DEMUXER_ERROR_APPEND_FAILED: Sample encryption info is not
  190.     // available.
  191.     if (shaka.util.Platform.isEdge() && shaka.util.Platform.isWindows() &&
  192.         !shaka.util.Platform.isXboxOne()) {
  193.       const doubleInitSegment = new Uint8Array(initSegment.byteLength +
  194.         modifiedInitSegment.byteLength);
  195.       doubleInitSegment.set(modifiedInitSegment);
  196.       doubleInitSegment.set(initSegment, modifiedInitSegment.byteLength);
  197.       return doubleInitSegment;
  198.     }
  200.     return modifiedInitSegment;
  201.   }
  203.   /**
  204.    * Insert an encryption metadata box ("encv" or "enca" box) into the MP4 init
  205.    * segment, based on the source box ("mp4a", "avc1", etc).  Returns a new
  206.    * buffer containing the modified init segment.
  207.    *
  208.    * @param {!Uint8Array} initSegment
  209.    * @param {shaka.extern.ParsedBox} stsdBox
  210.    * @param {shaka.extern.ParsedBox} sourceBox
  211.    * @param {!Array<shaka.extern.ParsedBox>} ancestorBoxes
  212.    * @param {number} metadataBoxType
  213.    * @return {!Uint8Array}
  214.    * @private
  215.    */
  216.   static insertEncryptionMetadata_(
  217.       initSegment, stsdBox, sourceBox, ancestorBoxes, metadataBoxType) {
  218.     const ContentWorkarounds = shaka.media.ContentWorkarounds;
  219.     const metadataBoxArray = ContentWorkarounds.createEncryptionMetadata_(
  220.         initSegment, sourceBox, metadataBoxType);
  222.     // Construct a new init segment array with room for the encryption metadata
  223.     // box we're adding.
  224.     const newInitSegment =
  225.         new Uint8Array(initSegment.byteLength + metadataBoxArray.byteLength);
  227.     // For Xbox One & Edge, we cut and insert at the start of the source box.
  228.     // For other platforms, we cut and insert at the end of the source box. It's
  229.     // not clear why this is necessary on Xbox One, but it seems to be evidence
  230.     // of another bug in the firmware implementation of MediaSource & EME.
  231.     const cutPoint =
  232.       (shaka.util.Platform.isXboxOne() || shaka.util.Platform.isEdge()) ?
  233.         sourceBox.start :
  234.         sourceBox.start + sourceBox.size;
  236.     // The data before the cut point will be copied to the same location as
  237.     // before.  The data after that will be appended after the added metadata
  238.     // box.
  239.     const beforeData = initSegment.subarray(0, cutPoint);
  240.     const afterData = initSegment.subarray(cutPoint);
  242.     newInitSegment.set(beforeData);
  243.     newInitSegment.set(metadataBoxArray, cutPoint);
  244.     newInitSegment.set(afterData, cutPoint + metadataBoxArray.byteLength);
  246.     // The parents up the chain from the encryption metadata box need their
  247.     // sizes adjusted to account for the added box.  These offsets should not be
  248.     // changed, because they should all be within the first section we copy.
  249.     for (const box of ancestorBoxes) {
  250.       goog.asserts.assert(box.start < cutPoint,
  251.           'Ancestor MP4 box found in the wrong location!  ' +
  252.           'Modified init segment will not make sense!');
  253.       ContentWorkarounds.updateBoxSize_(
  254.           newInitSegment, box.start, box.size + metadataBoxArray.byteLength);
  255.     }
  257.     // Add one to the sample entries field of the "stsd" box.  This is a 4-byte
  258.     // field just past the box header.
  259.     const stsdBoxView = shaka.util.BufferUtils.toDataView(
  260.         newInitSegment, stsdBox.start);
  261.     const stsdBoxHeaderSize = shaka.util.Mp4Parser.headerSize(stsdBox);
  262.     const numEntries = stsdBoxView.getUint32(stsdBoxHeaderSize);
  263.     stsdBoxView.setUint32(stsdBoxHeaderSize, numEntries + 1);
  265.     return newInitSegment;
  266.   }
  268.   /**
  269.    * Create an encryption metadata box ("encv" or "enca" box), based on the
  270.    * source box ("mp4a", "avc1", etc).  Returns a new buffer containing the
  271.    * encryption metadata box.
  272.    *
  273.    * @param {!Uint8Array} initSegment
  274.    * @param {shaka.extern.ParsedBox} sourceBox
  275.    * @param {number} metadataBoxType
  276.    * @return {!Uint8Array}
  277.    * @private
  278.    */
  279.   static createEncryptionMetadata_(initSegment, sourceBox, metadataBoxType) {
  280.     const ContentWorkarounds = shaka.media.ContentWorkarounds;
  281.     const sinfBoxArray = ContentWorkarounds.CANNED_SINF_BOX_.value();
  283.     // Create a subarray which points to the source box data.
  284.     const sourceBoxArray = initSegment.subarray(
  285.         /* start= */ sourceBox.start,
  286.         /* end= */ sourceBox.start + sourceBox.size);
  288.     // Create a view on the source box array.
  289.     const sourceBoxView = shaka.util.BufferUtils.toDataView(sourceBoxArray);
  291.     // Create an array to hold the new encryption metadata box, which is based
  292.     // on the source box.
  293.     const metadataBoxArray = new Uint8Array(
  294.         sourceBox.size + sinfBoxArray.byteLength);
  296.     // Copy the source box into the new array.
  297.     metadataBoxArray.set(sourceBoxArray, /* targetOffset= */ 0);
  299.     // Change the box type.
  300.     const metadataBoxView = shaka.util.BufferUtils.toDataView(metadataBoxArray);
  301.     metadataBoxView.setUint32(
  302.         ContentWorkarounds.BOX_TYPE_OFFSET_, metadataBoxType);
  304.     // Append the "sinf" box to the encryption metadata box.
  305.     metadataBoxArray.set(sinfBoxArray, /* targetOffset= */ sourceBox.size);
  307.     // Update the "sinf" box's format field (in the child "frma" box) to reflect
  308.     // the format of the original source box.
  309.     const sourceBoxType = sourceBoxView.getUint32(
  310.         ContentWorkarounds.BOX_TYPE_OFFSET_);
  311.     metadataBoxView.setUint32(
  312.         sourceBox.size + ContentWorkarounds.CANNED_SINF_BOX_FORMAT_OFFSET_,
  313.         sourceBoxType);
  315.     // Now update the encryption metadata box size.
  316.     ContentWorkarounds.updateBoxSize_(
  317.         metadataBoxArray, /* boxStart= */ 0, metadataBoxArray.byteLength);
  319.     return metadataBoxArray;
  320.   }
  322.   /**
  323.    * Modify an MP4 box's size field in-place.
  324.    *
  325.    * @param {!Uint8Array} dataArray
  326.    * @param {number} boxStart The start position of the box in dataArray.
  327.    * @param {number} newBoxSize The new size of the box.
  328.    * @private
  329.    */
  330.   static updateBoxSize_(dataArray, boxStart, newBoxSize) {
  331.     const ContentWorkarounds = shaka.media.ContentWorkarounds;
  332.     const boxView = shaka.util.BufferUtils.toDataView(dataArray, boxStart);
  333.     const sizeField = boxView.getUint32(ContentWorkarounds.BOX_SIZE_OFFSET_);
  334.     if (sizeField == 0) { // Means "the rest of the box".
  335.       // No adjustment needed for this box.
  336.     } else if (sizeField == 1) { // Means "use 64-bit size box".
  337.       // Set the 64-bit int in two 32-bit parts.
  338.       // The high bits should definitely be 0 in practice, but we're being
  339.       // thorough here.
  340.       boxView.setUint32(ContentWorkarounds.BOX_SIZE_64_OFFSET_,
  341.           newBoxSize >> 32);
  342.       boxView.setUint32(ContentWorkarounds.BOX_SIZE_64_OFFSET_ + 4,
  343.           newBoxSize & 0xffffffff);
  344.     } else { // Normal 32-bit size field.
  345.       // Not checking the size of the value here, since a box larger than 4GB is
  346.       // unrealistic.
  347.       boxView.setUint32(ContentWorkarounds.BOX_SIZE_OFFSET_, newBoxSize);
  348.     }
  349.   }
  351.   /**
  352.    * Transform the init segment into a new init segment buffer that indicates
  353.    * EC-3 as audio codec instead of AC-3. Even though any EC-3 decoder should
  354.    * be able to decode AC-3 streams, there are platforms that do not accept
  355.    * AC-3 as codec.
  356.    *
  357.    * Should only be called for MP4 init segments, and only on platforms that
  358.    * need this workaround. Returns a new buffer containing the modified init
  359.    * segment.
  360.    *
  361.    * @param {!BufferSource} initSegmentBuffer
  362.    * @return {!Uint8Array}
  363.    */
  364.   static fakeEC3(initSegmentBuffer) {
  365.     const ContentWorkarounds = shaka.media.ContentWorkarounds;
  366.     const initSegment = shaka.util.BufferUtils.toUint8(initSegmentBuffer);
  367.     const ancestorBoxes = [];
  369.     const onSimpleAncestorBox = (box) => {
  370.       ancestorBoxes.push({start: box.start, size: box.size});
  371.       shaka.util.Mp4Parser.children(box);
  372.     };
  374.     new shaka.util.Mp4Parser()
  375.         .box('moov', onSimpleAncestorBox)
  376.         .box('trak', onSimpleAncestorBox)
  377.         .box('mdia', onSimpleAncestorBox)
  378.         .box('minf', onSimpleAncestorBox)
  379.         .box('stbl', onSimpleAncestorBox)
  380.         .box('stsd', (box) => {
  381.           ancestorBoxes.push({start: box.start, size: box.size});
  382.           const stsdBoxView = shaka.util.BufferUtils.toDataView(
  383.               initSegment, box.start);
  384.           for (let i=0; i<box.size; i++) {
  385.             const codecTag = stsdBoxView.getUint32(i);
  386.             if (codecTag == ContentWorkarounds.BOX_TYPE_AC_3_) {
  387.               stsdBoxView.setUint32(i, ContentWorkarounds.BOX_TYPE_EC_3_);
  388.             } else if (codecTag == ContentWorkarounds.BOX_TYPE_DAC3_) {
  389.               stsdBoxView.setUint32(i, ContentWorkarounds.BOX_TYPE_DEC3_);
  390.             }
  391.           }
  392.         }).parse(initSegment);
  394.     return initSegment;
  395.   }
  396. };
  398. /**
  399.  * A canned "sinf" box for use when adding fake encryption metadata to init
  400.  * segments.
  401.  *
  402.  * @const {!shaka.util.Lazy.<!Uint8Array>}
  403.  * @private
  404.  * @see https://github.com/shaka-project/shaka-player/issues/2759
  405.  */
  406. shaka.media.ContentWorkarounds.CANNED_SINF_BOX_ =
  407.     new shaka.util.Lazy(() => new Uint8Array([
  408.       // sinf box
  409.       // Size: 0x50 = 80
  410.       0x00, 0x00, 0x00, 0x50,
  412.       // Type: sinf
  413.       0x73, 0x69, 0x6e, 0x66,
  415.       // Children of sinf...
  417.       // frma box
  418.       // Size: 0x0c = 12
  419.       0x00, 0x00, 0x00, 0x0c,
  421.       // Type: frma (child of sinf)
  422.       0x66, 0x72, 0x6d, 0x61,
  424.       // Format: filled in later based on the source box ("avc1", "mp4a", etc)
  425.       0x00, 0x00, 0x00, 0x00,
  426.       // end of frma box
  428.       // schm box
  429.       // Size: 0x14 = 20
  430.       0x00, 0x00, 0x00, 0x14,
  432.       // Type: schm (child of sinf)
  433.       0x73, 0x63, 0x68, 0x6d,
  435.       // Version: 0, Flags: 0
  436.       0x00, 0x00, 0x00, 0x00,
  438.       // Scheme: cenc
  439.       0x63, 0x65, 0x6e, 0x63,
  441.       // Scheme version: 1.0
  442.       0x00, 0x01, 0x00, 0x00,
  443.       // end of schm box
  445.       // schi box
  446.       // Size: 0x28 = 40
  447.       0x00, 0x00, 0x00, 0x28,
  449.       // Type: schi (child of sinf)
  450.       0x73, 0x63, 0x68, 0x69,
  452.       // Children of schi...
  454.       // tenc box
  455.       // Size: 0x20 = 32
  456.       0x00, 0x00, 0x00, 0x20,
  458.       // Type: tenc (child of schi)
  459.       0x74, 0x65, 0x6e, 0x63,
  461.       // Version: 0, Flags: 0
  462.       0x00, 0x00, 0x00, 0x00,
  464.       // Reserved fields
  465.       0x00, 0x00,
  467.       // Default protected: true
  468.       0x01,
  470.       // Default per-sample IV size: 8
  471.       0x08,
  473.       // Default key ID: all zeros (dummy)
  474.       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  475.       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  476.       // end of tenc box
  478.       // end of schi box
  480.       // end of sinf box
  481.     ]));
  483. /**
  484.  * The location of the format field in the "frma" box inside the canned "sinf"
  485.  * box above.
  486.  *
  487.  * @const {number}
  488.  * @private
  489.  */
  490. shaka.media.ContentWorkarounds.CANNED_SINF_BOX_FORMAT_OFFSET_ = 0x10;
  492. /**
  493.  * Offset to a box's size field.
  494.  *
  495.  * @const {number}
  496.  * @private
  497.  */
  498. shaka.media.ContentWorkarounds.BOX_SIZE_OFFSET_ = 0;
  500. /**
  501.  * Offset to a box's type field.
  502.  *
  503.  * @const {number}
  504.  * @private
  505.  */
  506. shaka.media.ContentWorkarounds.BOX_TYPE_OFFSET_ = 4;
  508. /**
  509.  * Offset to a box's 64-bit size field, if it has one.
  510.  *
  511.  * @const {number}
  512.  * @private
  513.  */
  514. shaka.media.ContentWorkarounds.BOX_SIZE_64_OFFSET_ = 8;
  516. /**
  517.  * Box type for "encv".
  518.  *
  519.  * @const {number}
  520.  * @private
  521.  */
  522. shaka.media.ContentWorkarounds.BOX_TYPE_ENCV_ = 0x656e6376;
  524. /**
  525.  * Box type for "enca".
  526.  *
  527.  * @const {number}
  528.  * @private
  529.  */
  530. shaka.media.ContentWorkarounds.BOX_TYPE_ENCA_ = 0x656e6361;
  532. /**
  533.  * Box type for "ac-3".
  534.  *
  535.  * @const {number}
  536.  * @private
  537.  */
  538. shaka.media.ContentWorkarounds.BOX_TYPE_AC_3_ = 0x61632d33;
  540. /**
  541.  * Box type for "dac3".
  542.  *
  543.  * @const {number}
  544.  * @private
  545.  */
  546. shaka.media.ContentWorkarounds.BOX_TYPE_DAC3_ = 0x64616333;
  548. /**
  549.  * Box type for "ec-3".
  550.  *
  551.  * @const {number}
  552.  * @private
  553.  */
  554. shaka.media.ContentWorkarounds.BOX_TYPE_EC_3_ = 0x65632d33;
  556. /**
  557.  * Box type for "dec3".
  558.  *
  559.  * @const {number}
  560.  * @private
  561.  */
  562. shaka.media.ContentWorkarounds.BOX_TYPE_DEC3_ = 0x64656333;