Source: lib/media/manifest_filterer.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2023 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. goog.provide('shaka.media.ManifestFilterer');
  9. goog.require('goog.asserts');
  10. goog.require('shaka.util.StreamUtils');
  11. goog.require('shaka.media.DrmEngine');
  12. goog.require('shaka.util.Error');
  14. /**
  15.  * A class that handles the filtering of manifests.
  16.  * Allows for manifest filtering to be done both by the player and by a
  17.  * preload manager.
  18.  */
  19. shaka.media.ManifestFilterer = class {
  20.   /**
  21.    * @param {?shaka.extern.PlayerConfiguration} config
  22.    * @param {{width: number, height: number}} maxHwRes
  23.    * @param {?shaka.media.DrmEngine} drmEngine
  24.    */
  25.   constructor(config, maxHwRes, drmEngine) {
  26.     goog.asserts.assert(config, 'Must have config');
  28.     /** @private {!shaka.extern.PlayerConfiguration} */
  29.     this.config_ = config;
  31.     /** @private {{width: number, height: number}} */
  32.     this.maxHwRes_ = maxHwRes;
  34.     /** @private {?shaka.media.DrmEngine} drmEngine */
  35.     this.drmEngine_ = drmEngine;
  36.   }
  38.   /** @param {!shaka.media.DrmEngine} drmEngine */
  39.   setDrmEngine(drmEngine) {
  40.     this.drmEngine_ = drmEngine;
  41.   }
  43.   /**
  44.    * Filters a manifest, removing unplayable streams/variants and  choosing
  45.    * the codecs.
  46.    *
  47.    * @param {?shaka.extern.Manifest} manifest
  48.    * @return {!Promise.<boolean>} tracksChanged
  49.    */
  50.   async filterManifest(manifest) {
  51.     goog.asserts.assert(manifest, 'Manifest should exist!');
  52.     await shaka.util.StreamUtils.filterManifest(this.drmEngine_, manifest,
  53.         this.config_.drm.preferredKeySystems);
  54.     shaka.util.StreamUtils.chooseCodecsAndFilterManifest(
  55.         manifest,
  56.         this.config_.preferredVideoCodecs,
  57.         this.config_.preferredAudioCodecs,
  58.         this.config_.preferredDecodingAttributes);
  59.     this.checkPlayableVariants_(manifest);
  60.     return this.filterManifestWithRestrictions(manifest);
  61.   }
  64.   /**
  65.    * @param {?shaka.extern.Manifest} manifest
  66.    * @return {boolean} tracksChanged
  67.    */
  68.   applyRestrictions(manifest) {
  69.     return shaka.util.StreamUtils.applyRestrictions(
  70.         manifest.variants, this.config_.restrictions, this.maxHwRes_);
  71.   }
  74.   /**
  75.    * Apply the restrictions configuration to the manifest, and check if there's
  76.    * a variant that meets the restrictions.
  77.    *
  78.    * @param {?shaka.extern.Manifest} manifest
  79.    * @return {boolean} tracksChanged
  80.    */
  81.   filterManifestWithRestrictions(manifest) {
  82.     const tracksChanged = this.applyRestrictions(manifest);
  84.     if (manifest) {
  85.       // We may need to create new sessions for any new init data.
  86.       const currentDrmInfo =
  87.           this.drmEngine_ ? this.drmEngine_.getDrmInfo() : null;
  88.       // DrmEngine.newInitData() requires mediaKeys to be available.
  89.       if (currentDrmInfo && this.drmEngine_.getMediaKeys()) {
  90.         for (const variant of manifest.variants) {
  91.           this.processDrmInfos(currentDrmInfo.keySystem, variant.video);
  92.           this.processDrmInfos(currentDrmInfo.keySystem, variant.audio);
  93.         }
  94.       }
  95.       this.checkRestrictedVariants(manifest);
  96.     }
  98.     return tracksChanged;
  99.   }
  101.   /**
  102.    * Confirm some variants are playable. Otherwise, throw an exception.
  103.    * @param {!shaka.extern.Manifest} manifest
  104.    * @private
  105.    */
  106.   checkPlayableVariants_(manifest) {
  107.     const valid = manifest.variants.some(shaka.util.StreamUtils.isPlayable);
  109.     // If none of the variants are playable, throw
  110.     // CONTENT_UNSUPPORTED_BY_BROWSER.
  111.     if (!valid) {
  112.       throw new shaka.util.Error(
  113.           shaka.util.Error.Severity.CRITICAL,
  114.           shaka.util.Error.Category.MANIFEST,
  115.           shaka.util.Error.Code.CONTENT_UNSUPPORTED_BY_BROWSER);
  116.     }
  117.   }
  119.   /**
  120.    * @param {string} keySystem
  121.    * @param {?shaka.extern.Stream} stream
  122.    */
  123.   processDrmInfos(keySystem, stream) {
  124.     if (!stream) {
  125.       return;
  126.     }
  128.     for (const drmInfo of stream.drmInfos) {
  129.       // Ignore any data for different key systems.
  130.       if (drmInfo.keySystem == keySystem) {
  131.         for (const initData of (drmInfo.initData || [])) {
  132.           this.drmEngine_.newInitData(
  133.               initData.initDataType, initData.initData);
  134.         }
  135.       }
  136.     }
  137.   }
  139.   /**
  140.    * Checks if the variants are all restricted, and throw an appropriate
  141.    * exception if so.
  142.    *
  143.    * @param {shaka.extern.Manifest} manifest
  144.    */
  145.   checkRestrictedVariants(manifest) {
  146.     const restrictedStatuses = shaka.media.ManifestFilterer.restrictedStatuses;
  147.     const keyStatusMap =
  148.         this.drmEngine_ ? this.drmEngine_.getKeyStatuses() : {};
  149.     const keyIds = Object.keys(keyStatusMap);
  150.     const isGlobalStatus = keyIds.length && keyIds[0] == '00';
  152.     let hasPlayable = false;
  153.     let hasAppRestrictions = false;
  155.     /** @type {!Set.<string>} */
  156.     const missingKeys = new Set();
  158.     /** @type {!Set.<string>} */
  159.     const badKeyStatuses = new Set();
  161.     for (const variant of manifest.variants) {
  162.       // TODO: Combine with onKeyStatus_.
  163.       const streams = [];
  164.       if (variant.audio) {
  165.         streams.push(variant.audio);
  166.       }
  167.       if (variant.video) {
  168.         streams.push(variant.video);
  169.       }
  171.       for (const stream of streams) {
  172.         if (stream.keyIds.size) {
  173.           for (const keyId of stream.keyIds) {
  174.             const keyStatus = keyStatusMap[isGlobalStatus ? '00' : keyId];
  175.             if (!keyStatus) {
  176.               missingKeys.add(keyId);
  177.             } else if (restrictedStatuses.includes(keyStatus)) {
  178.               badKeyStatuses.add(keyStatus);
  179.             }
  180.           }
  181.         }  // if (stream.keyIds.size)
  182.       }
  184.       if (!variant.allowedByApplication) {
  185.         hasAppRestrictions = true;
  186.       } else if (variant.allowedByKeySystem) {
  187.         hasPlayable = true;
  188.       }
  189.     }
  191.     if (!hasPlayable) {
  192.       /** @type {shaka.extern.RestrictionInfo} */
  193.       const data = {
  194.         hasAppRestrictions,
  195.         missingKeys: Array.from(missingKeys),
  196.         restrictedKeyStatuses: Array.from(badKeyStatuses),
  197.       };
  198.       throw new shaka.util.Error(
  199.           shaka.util.Error.Severity.CRITICAL,
  200.           shaka.util.Error.Category.MANIFEST,
  201.           shaka.util.Error.Code.RESTRICTIONS_CANNOT_BE_MET,
  202.           data);
  203.     }
  204.   }
  205. };
  207. /**
  208.  * These are the EME key statuses that represent restricted playback.
  209.  * 'usable', 'released', 'output-downscaled', 'status-pending' are statuses
  210.  * of the usable keys.  'expired' status is being handled separately in
  211.  * DrmEngine.
  212.  *
  213.  * @const {!Array.<string>}
  214.  */
  215. shaka.media.ManifestFilterer.restrictedStatuses =
  216.     ['output-restricted', 'internal-error'];