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 {!Array.<!Uint8Array>}
  18.    */
  19.   process(naluData) {
  20.     const seiPayloads = [];
  21.     const naluClone = this.removeEmu(naluData);
  23.     // The following is an implementation of section 7.3.2.3.1
  24.     // in Rec. ITU-T H.264 (06/2019), the H.264 spec.
  25.     let offset = 0;
  27.     while (offset < naluClone.length) {
  28.       let payloadType = 0; // SEI payload type as defined by H.264 spec
  29.       while (naluClone[offset] == 0xFF) {
  30.         payloadType += 255;
  31.         offset++;
  32.       }
  33.       payloadType += naluClone[offset++];
  35.       let payloadSize = 0; // SEI payload size as defined by H.264 spec
  36.       while (naluClone[offset] == 0xFF) {
  37.         payloadSize += 255;
  38.         offset++;
  39.       }
  40.       payloadSize += naluClone[offset++];
  42.       // Payload type 4 is user_data_registered_itu_t_t35, as per the H.264
  43.       // spec. This payload type contains caption data.
  44.       if (payloadType == 0x04) {
  45.         seiPayloads.push(naluClone.subarray(offset, offset + payloadSize));
  46.       }
  47.       offset += payloadSize;
  48.     }
  50.     return seiPayloads;
  51.   }
  54.   /**
  55.    * Removes H.264 emulation prevention bytes from the byte array.
  56.    *
  57.    * Note: Remove bytes by shifting will cause Chromium (VDA) to complain
  58.    * about conformance. Recreating a new array solves it.
  59.    *
  60.    * @param {!Uint8Array} naluData NALU from which EMUs should be removed.
  61.    * @return {!Uint8Array} The NALU with the emulation prevention byte removed.
  62.    */
  63.   removeEmu(naluData) {
  64.     let naluClone = naluData;
  65.     let zeroCount = 0;
  66.     let src = 0;
  67.     while (src < naluClone.length) {
  68.       if (zeroCount == 2 && naluClone[src] == 0x03) {
  69.         // 0x00, 0x00, 0x03 pattern detected
  70.         zeroCount = 0;
  72.         // Splice the array and recreate a new one, instead of shifting bytes
  73.         const newArr = [...naluClone];
  74.         newArr.splice(src, 1);
  75.         naluClone = new Uint8Array(newArr);
  76.       } else {
  77.         if (naluClone[src] == 0x00) {
  78.           zeroCount++;
  79.         } else {
  80.           zeroCount = 0;
  81.         }
  82.       }
  83.       src++;
  84.     }
  85.     return naluClone;
  86.   }
  87. };