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.    * @return {!Uint8Array}
  34.    * @see https://github.com/shaka-project/shaka-player/issues/2759
  35.    */
  36.   static fakeEncryption(initSegmentBuffer) {
  37.     const ContentWorkarounds = shaka.media.ContentWorkarounds;
  38.     let initSegment = shaka.util.BufferUtils.toUint8(initSegmentBuffer);
  39.     let isEncrypted = false;
  40.     /** @type {shaka.extern.ParsedBox} */
  41.     let stsdBox;
  42.     const ancestorBoxes = [];
  44.     const onSimpleAncestorBox = (box) => {
  45.       ancestorBoxes.push(box);
  46.       shaka.util.Mp4Parser.children(box);
  47.     };
  49.     const onEncryptionMetadataBox = (box) => {
  50.       isEncrypted = true;
  51.     };
  53.     // Multiplexed content could have multiple boxes that we need to modify.
  54.     // Add to this array in order of box offset.  This will be important later,
  55.     // when we process the boxes.
  56.     /** @type {!Array.<{box: shaka.extern.ParsedBox, newType: number}>} */
  57.     const boxesToModify = [];
  59.     new shaka.util.Mp4Parser()
  60.         .box('moov', onSimpleAncestorBox)
  61.         .box('trak', onSimpleAncestorBox)
  62.         .box('mdia', onSimpleAncestorBox)
  63.         .box('minf', onSimpleAncestorBox)
  64.         .box('stbl', onSimpleAncestorBox)
  65.         .fullBox('stsd', (box) => {
  66.           stsdBox = box;
  67.           ancestorBoxes.push(box);
  68.           shaka.util.Mp4Parser.sampleDescription(box);
  69.         })
  70.         .fullBox('encv', onEncryptionMetadataBox)
  71.         .fullBox('enca', onEncryptionMetadataBox)
  72.         .fullBox('avc1', (box) => {
  73.           boxesToModify.push({
  74.             box,
  75.             newType: ContentWorkarounds.BOX_TYPE_ENCV_,
  76.           });
  77.         })
  78.         .fullBox('avc3', (box) => {
  79.           boxesToModify.push({
  80.             box,
  81.             newType: ContentWorkarounds.BOX_TYPE_ENCV_,
  82.           });
  83.         })
  84.         .fullBox('ac-3', (box) => {
  85.           boxesToModify.push({
  86.             box,
  87.             newType: ContentWorkarounds.BOX_TYPE_ENCA_,
  88.           });
  89.         })
  90.         .fullBox('ec-3', (box) => {
  91.           boxesToModify.push({
  92.             box,
  93.             newType: ContentWorkarounds.BOX_TYPE_ENCA_,
  94.           });
  95.         })
  96.         .fullBox('mp4a', (box) => {
  97.           boxesToModify.push({
  98.             box,
  99.             newType: ContentWorkarounds.BOX_TYPE_ENCA_,
  100.           });
  101.         }).parse(initSegment);
  103.     if (isEncrypted) {
  104.       shaka.log.debug('Init segment already indicates encryption.');
  105.       return initSegment;
  106.     }
  108.     if (boxesToModify.length == 0 || !stsdBox) {
  109.       shaka.log.error('Failed to find boxes needed to fake encryption!');
  110.       shaka.log.v2('Failed init segment (hex):',
  111.           shaka.util.Uint8ArrayUtils.toHex(initSegment));
  112.       throw new shaka.util.Error(
  113.           shaka.util.Error.Severity.CRITICAL,
  114.           shaka.util.Error.Category.MEDIA,
  115.           shaka.util.Error.Code.CONTENT_TRANSFORMATION_FAILED);
  116.     }
  118.     // Modify boxes in order from largest offset to smallest, so that earlier
  119.     // boxes don't have their offsets changed before we process them.
  120.     boxesToModify.reverse();  // in place!
  121.     for (const workItem of boxesToModify) {
  122.       const insertedBoxType =
  123.           shaka.util.Mp4Parser.typeToString(workItem.newType);
  124.       shaka.log.debug(`Inserting "${insertedBoxType}" box into init segment.`);
  125.       initSegment = ContentWorkarounds.insertEncryptionMetadata_(
  126.           initSegment, stsdBox, workItem.box, ancestorBoxes, workItem.newType);
  127.     }
  129.     return initSegment;
  130.   }
  132.   /**
  133.    * Insert an encryption metadata box ("encv" or "enca" box) into the MP4 init
  134.    * segment, based on the source box ("mp4a", "avc1", etc).  Returns a new
  135.    * buffer containing the modified init segment.
  136.    *
  137.    * @param {!Uint8Array} initSegment
  138.    * @param {shaka.extern.ParsedBox} stsdBox
  139.    * @param {shaka.extern.ParsedBox} sourceBox
  140.    * @param {!Array.<shaka.extern.ParsedBox>} ancestorBoxes
  141.    * @param {number} metadataBoxType
  142.    * @return {!Uint8Array}
  143.    * @private
  144.    */
  145.   static insertEncryptionMetadata_(
  146.       initSegment, stsdBox, sourceBox, ancestorBoxes, metadataBoxType) {
  147.     const ContentWorkarounds = shaka.media.ContentWorkarounds;
  148.     const metadataBoxArray = ContentWorkarounds.createEncryptionMetadata_(
  149.         initSegment, sourceBox, metadataBoxType);
  151.     // Construct a new init segment array with room for the encryption metadata
  152.     // box we're adding.
  153.     const newInitSegment =
  154.         new Uint8Array(initSegment.byteLength + metadataBoxArray.byteLength);
  156.     // For Xbox One, we cut and insert at the start of the source box.  For
  157.     // other platforms, we cut and insert at the end of the source box.  It's
  158.     // not clear why this is necessary on Xbox One, but it seems to be evidence
  159.     // of another bug in the firmware implementation of MediaSource & EME.
  160.     const cutPoint = shaka.util.Platform.isXboxOne() ?
  161.         sourceBox.start :
  162.         sourceBox.start + sourceBox.size;
  164.     // The data before the cut point will be copied to the same location as
  165.     // before.  The data after that will be appended after the added metadata
  166.     // box.
  167.     const beforeData = initSegment.subarray(0, cutPoint);
  168.     const afterData = initSegment.subarray(cutPoint);
  170.     newInitSegment.set(beforeData);
  171.     newInitSegment.set(metadataBoxArray, cutPoint);
  172.     newInitSegment.set(afterData, cutPoint + metadataBoxArray.byteLength);
  174.     // The parents up the chain from the encryption metadata box need their
  175.     // sizes adjusted to account for the added box.  These offsets should not be
  176.     // changed, because they should all be within the first section we copy.
  177.     for (const box of ancestorBoxes) {
  178.       goog.asserts.assert(box.start < cutPoint,
  179.           'Ancestor MP4 box found in the wrong location!  ' +
  180.           'Modified init segment will not make sense!');
  181.       ContentWorkarounds.updateBoxSize_(
  182.           newInitSegment, box.start, box.size + metadataBoxArray.byteLength);
  183.     }
  185.     // Add one to the sample entries field of the "stsd" box.  This is a 4-byte
  186.     // field just past the box header.
  187.     const stsdBoxView = shaka.util.BufferUtils.toDataView(
  188.         newInitSegment, stsdBox.start);
  189.     const stsdBoxHeaderSize = shaka.util.Mp4Parser.headerSize(stsdBox);
  190.     const numEntries = stsdBoxView.getUint32(stsdBoxHeaderSize);
  191.     stsdBoxView.setUint32(stsdBoxHeaderSize, numEntries + 1);
  193.     return newInitSegment;
  194.   }
  196.   /**
  197.    * Create an encryption metadata box ("encv" or "enca" box), based on the
  198.    * source box ("mp4a", "avc1", etc).  Returns a new buffer containing the
  199.    * encryption metadata box.
  200.    *
  201.    * @param {!Uint8Array} initSegment
  202.    * @param {shaka.extern.ParsedBox} sourceBox
  203.    * @param {number} metadataBoxType
  204.    * @return {!Uint8Array}
  205.    * @private
  206.    */
  207.   static createEncryptionMetadata_(initSegment, sourceBox, metadataBoxType) {
  208.     const ContentWorkarounds = shaka.media.ContentWorkarounds;
  209.     const sinfBoxArray = ContentWorkarounds.CANNED_SINF_BOX_.value();
  211.     // Create a subarray which points to the source box data.
  212.     const sourceBoxArray = initSegment.subarray(
  213.         /* start= */ sourceBox.start,
  214.         /* end= */ sourceBox.start + sourceBox.size);
  216.     // Create a view on the source box array.
  217.     const sourceBoxView = shaka.util.BufferUtils.toDataView(sourceBoxArray);
  219.     // Create an array to hold the new encryption metadata box, which is based
  220.     // on the source box.
  221.     const metadataBoxArray = new Uint8Array(
  222.         sourceBox.size + sinfBoxArray.byteLength);
  224.     // Copy the source box into the new array.
  225.     metadataBoxArray.set(sourceBoxArray, /* targetOffset= */ 0);
  227.     // Change the box type.
  228.     const metadataBoxView = shaka.util.BufferUtils.toDataView(metadataBoxArray);
  229.     metadataBoxView.setUint32(
  230.         ContentWorkarounds.BOX_TYPE_OFFSET_, metadataBoxType);
  232.     // Append the "sinf" box to the encryption metadata box.
  233.     metadataBoxArray.set(sinfBoxArray, /* targetOffset= */ sourceBox.size);
  235.     // Update the "sinf" box's format field (in the child "frma" box) to reflect
  236.     // the format of the original source box.
  237.     const sourceBoxType = sourceBoxView.getUint32(
  238.         ContentWorkarounds.BOX_TYPE_OFFSET_);
  239.     metadataBoxView.setUint32(
  240.         sourceBox.size + ContentWorkarounds.CANNED_SINF_BOX_FORMAT_OFFSET_,
  241.         sourceBoxType);
  243.     // Now update the encryption metadata box size.
  244.     ContentWorkarounds.updateBoxSize_(
  245.         metadataBoxArray, /* boxStart= */ 0, metadataBoxArray.byteLength);
  247.     return metadataBoxArray;
  248.   }
  250.   /**
  251.    * Modify an MP4 box's size field in-place.
  252.    *
  253.    * @param {!Uint8Array} dataArray
  254.    * @param {number} boxStart The start position of the box in dataArray.
  255.    * @param {number} newBoxSize The new size of the box.
  256.    * @private
  257.    */
  258.   static updateBoxSize_(dataArray, boxStart, newBoxSize) {
  259.     const ContentWorkarounds = shaka.media.ContentWorkarounds;
  260.     const boxView = shaka.util.BufferUtils.toDataView(dataArray, boxStart);
  261.     const sizeField = boxView.getUint32(ContentWorkarounds.BOX_SIZE_OFFSET_);
  262.     if (sizeField == 0) { // Means "the rest of the box".
  263.       // No adjustment needed for this box.
  264.     } else if (sizeField == 1) { // Means "use 64-bit size box".
  265.       // Set the 64-bit int in two 32-bit parts.
  266.       // The high bits should definitely be 0 in practice, but we're being
  267.       // thorough here.
  268.       boxView.setUint32(ContentWorkarounds.BOX_SIZE_64_OFFSET_,
  269.           newBoxSize >> 32);
  270.       boxView.setUint32(ContentWorkarounds.BOX_SIZE_64_OFFSET_ + 4,
  271.           newBoxSize & 0xffffffff);
  272.     } else { // Normal 32-bit size field.
  273.       // Not checking the size of the value here, since a box larger than 4GB is
  274.       // unrealistic.
  275.       boxView.setUint32(ContentWorkarounds.BOX_SIZE_OFFSET_, newBoxSize);
  276.     }
  277.   }
  278. };
  280. /**
  281.  * A canned "sinf" box for use when adding fake encryption metadata to init
  282.  * segments.
  283.  *
  284.  * @const {!shaka.util.Lazy.<!Uint8Array>}
  285.  * @private
  286.  * @see https://github.com/shaka-project/shaka-player/issues/2759
  287.  */
  288. shaka.media.ContentWorkarounds.CANNED_SINF_BOX_ =
  289.     new shaka.util.Lazy(() => new Uint8Array([
  290.       // sinf box
  291.       // Size: 0x50 = 80
  292.       0x00, 0x00, 0x00, 0x50,
  294.       // Type: sinf
  295.       0x73, 0x69, 0x6e, 0x66,
  297.       // Children of sinf...
  299.       // frma box
  300.       // Size: 0x0c = 12
  301.       0x00, 0x00, 0x00, 0x0c,
  303.       // Type: frma (child of sinf)
  304.       0x66, 0x72, 0x6d, 0x61,
  306.       // Format: filled in later based on the source box ("avc1", "mp4a", etc)
  307.       0x00, 0x00, 0x00, 0x00,
  308.       // end of frma box
  310.       // schm box
  311.       // Size: 0x14 = 20
  312.       0x00, 0x00, 0x00, 0x14,
  314.       // Type: schm (child of sinf)
  315.       0x73, 0x63, 0x68, 0x6d,
  317.       // Version: 0, Flags: 0
  318.       0x00, 0x00, 0x00, 0x00,
  320.       // Scheme: cenc
  321.       0x63, 0x65, 0x6e, 0x63,
  323.       // Scheme version: 1.0
  324.       0x00, 0x01, 0x00, 0x00,
  325.       // end of schm box
  327.       // schi box
  328.       // Size: 0x28 = 40
  329.       0x00, 0x00, 0x00, 0x28,
  331.       // Type: schi (child of sinf)
  332.       0x73, 0x63, 0x68, 0x69,
  334.       // Children of schi...
  336.       // tenc box
  337.       // Size: 0x20 = 32
  338.       0x00, 0x00, 0x00, 0x20,
  340.       // Type: tenc (child of schi)
  341.       0x74, 0x65, 0x6e, 0x63,
  343.       // Version: 0, Flags: 0
  344.       0x00, 0x00, 0x00, 0x00,
  346.       // Reserved fields
  347.       0x00, 0x00,
  349.       // Default protected: true
  350.       0x01,
  352.       // Default per-sample IV size: 8
  353.       0x08,
  355.       // Default key ID: all zeros (dummy)
  356.       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  357.       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  358.       // end of tenc box
  360.       // end of schi box
  362.       // end of sinf box
  363.     ]));
  365. /**
  366.  * The location of the format field in the "frma" box inside the canned "sinf"
  367.  * box above.
  368.  *
  369.  * @const {number}
  370.  * @private
  371.  */
  372. shaka.media.ContentWorkarounds.CANNED_SINF_BOX_FORMAT_OFFSET_ = 0x10;
  374. /**
  375.  * Offset to a box's size field.
  376.  *
  377.  * @const {number}
  378.  * @private
  379.  */
  380. shaka.media.ContentWorkarounds.BOX_SIZE_OFFSET_ = 0;
  382. /**
  383.  * Offset to a box's type field.
  384.  *
  385.  * @const {number}
  386.  * @private
  387.  */
  388. shaka.media.ContentWorkarounds.BOX_TYPE_OFFSET_ = 4;
  390. /**
  391.  * Offset to a box's 64-bit size field, if it has one.
  392.  *
  393.  * @const {number}
  394.  * @private
  395.  */
  396. shaka.media.ContentWorkarounds.BOX_SIZE_64_OFFSET_ = 8;
  398. /**
  399.  * Box type for "encv".
  400.  *
  401.  * @const {number}
  402.  * @private
  403.  */
  404. shaka.media.ContentWorkarounds.BOX_TYPE_ENCV_ = 0x656e6376;
  406. /**
  407.  * Box type for "enca".
  408.  *
  409.  * @const {number}
  410.  * @private
  411.  */
  412. shaka.media.ContentWorkarounds.BOX_TYPE_ENCA_ = 0x656e6361;