Source: lib/cea/sei_processor.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. goog.provide('shaka.cea.SeiProcessor');
  10. /**
  11.  * H.264 SEI NALU Parser used for extracting 708 closed caption packets.
  12.  */
  13. shaka.cea.SeiProcessor = class {
  14.   /**
  15.    * Processes supplemental enhancement information data.
  16.    * @param {!Uint8Array} naluData NALU from which SEI data is to be processed.
  17.    * @return {!Iterable.<!Uint8Array>}
  18.    */
  19.   * process(naluData) {
  20.     const naluClone = this.removeEmu(naluData);
  22.     // The following is an implementation of section 7.3.2.3.1
  23.     // in Rec. ITU-T H.264 (06/2019), the H.264 spec.
  24.     let offset = 0;
  26.     while (offset < naluClone.length) {
  27.       let payloadType = 0; // SEI payload type as defined by H.264 spec
  28.       while (naluClone[offset] == 0xFF) {
  29.         payloadType += 255;
  30.         offset++;
  31.       }
  32.       payloadType += naluClone[offset++];
  34.       let payloadSize = 0; // SEI payload size as defined by H.264 spec
  35.       while (naluClone[offset] == 0xFF) {
  36.         payloadSize += 255;
  37.         offset++;
  38.       }
  39.       payloadSize += naluClone[offset++];
  41.       // Payload type 4 is user_data_registered_itu_t_t35, as per the H.264
  42.       // spec. This payload type contains caption data.
  43.       if (payloadType == 0x04) {
  44.         yield naluClone.subarray(offset, offset + payloadSize);
  45.       }
  46.       offset += payloadSize;
  47.     }
  48.   }
  51.   /**
  52.    * Removes H.264 emulation prevention bytes from the byte array.
  53.    *
  54.    * Note: Remove bytes by shifting will cause Chromium (VDA) to complain
  55.    * about conformance. Recreating a new array solves it.
  56.    *
  57.    * @param {!Uint8Array} naluData NALU from which EMUs should be removed.
  58.    * @return {!Uint8Array} The NALU with the emulation prevention byte removed.
  59.    */
  60.   removeEmu(naluData) {
  61.     let naluClone = naluData;
  62.     let zeroCount = 0;
  63.     let src = 0;
  64.     while (src < naluClone.length) {
  65.       if (zeroCount == 2 && naluClone[src] == 0x03) {
  66.         // 0x00, 0x00, 0x03 pattern detected
  67.         zeroCount = 0;
  69.         // Splice the array and recreate a new one, instead of shifting bytes
  70.         const newArr = [...naluClone];
  71.         newArr.splice(src, 1);
  72.         naluClone = new Uint8Array(newArr);
  73.       } else {
  74.         if (naluClone[src] == 0x00) {
  75.           zeroCount++;
  76.         } else {
  77.           zeroCount = 0;
  78.         }
  79.       }
  80.       src++;
  81.     }
  82.     return naluClone;
  83.   }
  84. };