hevc_decoder_configuration_record.cc

// Copyright 2015 Google LLC. All rights reserved.
//
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file or at
// https://developers.google.com/open-source/licenses/bsd
 
#include <packager/media/codecs/hevc_decoder_configuration_record.h>
 
#include <cstddef>
#include <cstdint>
#include <iterator>
#include <string>
#include <vector>
 
#include <absl/log/check.h>
#include <absl/log/log.h>
#include <absl/strings/escaping.h>
#include <absl/strings/str_format.h>
#include <absl/strings/str_join.h>
 
#include <packager/media/base/buffer_reader.h>
#include <packager/media/base/fourccs.h>
#include <packager/media/base/rcheck.h>
#include <packager/media/codecs/h265_parser.h>
#include <packager/utils/bytes_to_string_view.h>
 
namespace shaka {
namespace media {
 
namespace {
 
// ISO/IEC 14496-15:2014 Annex E.
std::string GeneralProfileSpaceAsString(uint8_t general_profile_space) {
  switch (general_profile_space) {
    case 0:
      return "";
    case 1:
      return "A";
    case 2:
      return "B";
    case 3:
      return "C";
    default:
      LOG(WARNING) << "Unexpected general_profile_space "
                   << general_profile_space;
      return "";
  }
}
 
std::string TrimLeadingZeros(const std::string& str) {
  DCHECK_GT(str.size(), 0u);
  for (size_t i = 0; i < str.size(); ++i) {
    if (str[i] == '0')
      continue;
    return str.substr(i);
  }
  return "0";
}
 
// Encode the 32 bits input, but in reverse bit order, i.e. bit [31] as the most
// significant bit, followed by, bit [30], and down to bit [0] as the least
// significant bit, where bits [i] for i in the range of 0 to 31, inclusive, are
// specified in ISO/IEC 23008‐2, encoded in hexadecimal (leading zeroes may be
// omitted).
std::string ReverseBitsAndHexEncode(uint32_t x) {
  x = ((x & 0x55555555) << 1) | ((x & 0xAAAAAAAA) >> 1);
  x = ((x & 0x33333333) << 2) | ((x & 0xCCCCCCCC) >> 2);
  x = ((x & 0x0F0F0F0F) << 4) | ((x & 0xF0F0F0F0) >> 4);
  const uint8_t bytes[] = {static_cast<uint8_t>(x & 0xFF),
                           static_cast<uint8_t>((x >> 8) & 0xFF),
                           static_cast<uint8_t>((x >> 16) & 0xFF),
                           static_cast<uint8_t>((x >> 24) & 0xFF)};
  return TrimLeadingZeros(absl::BytesToHexString(
      byte_array_to_string_view(bytes, std::size(bytes))));
}
 
}  // namespace
 
HEVCDecoderConfigurationRecord::HEVCDecoderConfigurationRecord() = default;
 
HEVCDecoderConfigurationRecord::~HEVCDecoderConfigurationRecord() = default;
 
bool HEVCDecoderConfigurationRecord::ParseInternal() {
  BufferReader reader(data(), data_size());
 
  uint8_t profile_indication = 0;
  uint8_t length_size_minus_one = 0;
  uint8_t num_of_arrays = 0;
  if (!layered_) {
    RCHECK(reader.Read1(&version_) && version_ == 1 &&
           reader.Read1(&profile_indication) &&
           reader.Read4(&general_profile_compatibility_flags_) &&
           reader.ReadToVector(&general_constraint_indicator_flags_, 6) &&
           reader.Read1(&general_level_idc_) &&
           reader.SkipBytes(8) &&  // Skip uninterested fields.
           reader.Read1(&length_size_minus_one) &&
           reader.Read1(&num_of_arrays));
 
    general_profile_space_ = profile_indication >> 6;
    RCHECK(general_profile_space_ <= 3u);
    general_tier_flag_ = ((profile_indication >> 5) & 1) == 1;
    general_profile_idc_ = profile_indication & 0x1f;
  } else {
    RCHECK(reader.Read1(&version_) && version_ == 1 &&
           reader.SkipBytes(3) &&  // Skip uninterested fields.
           reader.Read1(&length_size_minus_one) &&
           reader.Read1(&num_of_arrays));
  }
  if ((length_size_minus_one & 0x3) == 2) {
    LOG(ERROR) << "Invalid NALU length size.";
    return false;
  }
  set_nalu_length_size((length_size_minus_one & 0x3) + 1);
 
  if (parser_ == nullptr) {
    if (internal_parser_used_ == true)
      parser_ = &internal_parser_;
    else {
      LOG(ERROR) << "Internal parser is not used, but parser_ is not set!";
      return false;
    }
  }
 
  for (int i = 0; i < num_of_arrays; i++) {
    uint8_t nal_unit_type;
    uint16_t num_nalus;
    RCHECK(reader.Read1(&nal_unit_type));
    nal_unit_type &= 0x3f;
    RCHECK(reader.Read2(&num_nalus));
    for (int j = 0; j < num_nalus; j++) {
      uint16_t nalu_length;
      RCHECK(reader.Read2(&nalu_length));
      uint64_t nalu_offset = reader.pos();
      RCHECK(reader.SkipBytes(nalu_length));
 
      Nalu nalu;
      RCHECK(nalu.Initialize(Nalu::kH265, data() + nalu_offset, nalu_length));
      RCHECK(nalu.type() == nal_unit_type);
      AddNalu(nalu);
 
      if (nalu.type() == Nalu::H265_VPS) {
        int vps_id = 0;
        RCHECK(parser_->ParseVps(nalu, &vps_id) == H265Parser::kOk);
      } else if (nalu.type() == Nalu::H265_SPS) {
        int sps_id = 0;
        RCHECK(parser_->ParseSps(nalu, &sps_id) == H265Parser::kOk);
        const H265Sps* sps = parser_->GetSps(sps_id);
        if (!layered_) {
          set_transfer_characteristics(
              sps->vui_parameters.transfer_characteristics);
          set_color_primaries(sps->vui_parameters.color_primaries);
          set_matrix_coefficients(sps->vui_parameters.matrix_coefficients);
        } else {
          // Get profile/tier/level info from the SPS/VPS.
          const int* general_profile_tier_level_data =
              sps->general_profile_tier_level_data;
          general_profile_space_ =
              (general_profile_tier_level_data[0] & 0xFF) >> 6;
          RCHECK(general_profile_space_ <= 3u);
          general_tier_flag_ =
              ((general_profile_tier_level_data[0] & 0x3F) >> 5) == 1;
          general_profile_idc_ = general_profile_tier_level_data[0] & 0x1F;
          general_profile_compatibility_flags_ =
              ((general_profile_tier_level_data[1] & 0xFF) << 24) |
              ((general_profile_tier_level_data[2] & 0xFF) << 16) |
              ((general_profile_tier_level_data[3] & 0xFF) << 8) |
              (general_profile_tier_level_data[4] & 0xFF);
          general_constraint_indicator_flags_.resize(6);
          for (int k = 0; k < 6; ++k) {
            general_constraint_indicator_flags_[i] =
                general_profile_tier_level_data[5 + i] & 0xFF;
          }
          general_level_idc_ = general_profile_tier_level_data[11] & 0xFF;
        }
      }
    }
  }
 
  // TODO(kqyang): Parse SPS to get resolutions.
  return true;
}
 
std::string HEVCDecoderConfigurationRecord::GetCodecString(
    FourCC codec_fourcc) const {
  // ISO/IEC 14496-15:2014 Annex E.
  std::vector<std::string> fields;
  fields.push_back(FourCCToString(codec_fourcc));
  fields.push_back(GeneralProfileSpaceAsString(general_profile_space_) +
                   absl::StrFormat("%d", general_profile_idc_));
  fields.push_back(
      ReverseBitsAndHexEncode(general_profile_compatibility_flags_));
  fields.push_back((general_tier_flag_ ? "H" : "L") +
                   absl::StrFormat("%d", general_level_idc_));
 
  // Remove trailing bytes that are zero.
  std::vector<uint8_t> constraints = general_constraint_indicator_flags_;
  size_t size = constraints.size();
  for (; size > 0; --size) {
    if (constraints[size - 1] != 0)
      break;
  }
  constraints.resize(size);
  for (uint8_t constraint : constraints)
    fields.push_back(TrimLeadingZeros(
        absl::BytesToHexString(byte_array_to_string_view(&constraint, 1))));
 
  return absl::StrJoin(fields, ".");
}
 
bool HEVCDecoderConfigurationRecord::ParseLHEVCConfig(
    const std::vector<uint8_t>& data) {
  layered_ = true;
  return Parse(data.data(), data.size());
}
 
}  // namespace media
}  // namespace shaka