vp_codec_configuration_record.h

// 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
 
#ifndef PACKAGER_MEDIA_CODECS_VP_CODEC_CONFIGURATION_RECORD_H_
#define PACKAGER_MEDIA_CODECS_VP_CODEC_CONFIGURATION_RECORD_H_
 
#include <cstdint>
#include <optional>
#include <string>
#include <vector>
 
#include <packager/macros/classes.h>
#include <packager/media/base/video_stream_info.h>
 
namespace shaka {
namespace media {
 
enum AVColorPrimaries {
  AVCOL_PRI_RESERVED0 = 0,
  AVCOL_PRI_BT709 = 1,
  AVCOL_PRI_UNSPECIFIED = 2,
  AVCOL_PRI_RESERVED = 3,
  AVCOL_PRI_BT470M = 4,
  AVCOL_PRI_BT470BG = 5,
  AVCOL_PRI_SMPTE170M = 6,
  AVCOL_PRI_SMPTE240M = 7,
  AVCOL_PRI_FILM = 8,
  AVCOL_PRI_BT2020 = 9,
  AVCOL_PRI_SMPTE428 = 10,
  AVCOL_PRI_SMPTEST428_1 = AVCOL_PRI_SMPTE428,
  AVCOL_PRI_SMPTE431 = 11,
  AVCOL_PRI_SMPTE432 = 12,
  AVCOL_PRI_NB
};
 
enum AVColorTransferCharacteristic {
  AVCOL_TRC_RESERVED0 = 0,
  AVCOL_TRC_BT709 = 1,
  AVCOL_TRC_UNSPECIFIED = 2,
  AVCOL_TRC_RESERVED = 3,
  AVCOL_TRC_GAMMA22 = 4,
  AVCOL_TRC_GAMMA28 = 5,
  AVCOL_TRC_SMPTE170M = 6,
  AVCOL_TRC_SMPTE240M = 7,
  AVCOL_TRC_LINEAR = 8,
  AVCOL_TRC_LOG = 9,
  AVCOL_TRC_LOG_SQRT = 10,
  AVCOL_TRC_IEC61966_2_4 = 11,
  AVCOL_TRC_BT1361_ECG = 12,
  AVCOL_TRC_IEC61966_2_1 = 13,
  AVCOL_TRC_BT2020_10 = 14,
  AVCOL_TRC_BT2020_12 = 15,
  AVCOL_TRC_SMPTE2084 = 16,
  AVCOL_TRC_SMPTEST2084 = AVCOL_TRC_SMPTE2084,
  AVCOL_TRC_SMPTE428 = 17,
  AVCOL_TRC_SMPTEST428_1 = AVCOL_TRC_SMPTE428,
  AVCOL_TRC_ARIB_STD_B67 = 18,
  AVCOL_TRC_NB
};
 
enum AVColorSpace {
  AVCOL_SPC_RGB = 0,
  AVCOL_SPC_BT709 = 1,
  AVCOL_SPC_UNSPECIFIED = 2,
  AVCOL_SPC_RESERVED = 3,
  AVCOL_SPC_FCC = 4,
  AVCOL_SPC_BT470BG = 5,
  AVCOL_SPC_SMPTE170M = 6,
  AVCOL_SPC_SMPTE240M = 7,
  AVCOL_SPC_YCOCG = 8,
  AVCOL_SPC_BT2020_NCL = 9,
  AVCOL_SPC_BT2020_CL = 10,
  AVCOL_SPC_SMPTE2085 = 11,
  AVCOL_SPC_NB
};
 
enum AVChromaLocation {
  AVCHROMA_LOC_UNSPECIFIED = 0,
  AVCHROMA_LOC_LEFT = 1,
  AVCHROMA_LOC_CENTER = 2,
  AVCHROMA_LOC_TOPLEFT = 3,
  AVCHROMA_LOC_TOP = 4,
  AVCHROMA_LOC_BOTTOMLEFT = 5,
  AVCHROMA_LOC_BOTTOM = 6,
  AVCHROMA_LOC_NB
};
 
class VPCodecConfigurationRecord {
 public:
  enum ChromaSubsampling {
    CHROMA_420_VERTICAL = 0,
    CHROMA_420_COLLOCATED_WITH_LUMA = 1,
    CHROMA_422 = 2,
    CHROMA_444 = 3,
    CHROMA_440 = 4,
  };
  enum ChromaSitingValues {
    kUnspecified = 0,
    kLeftCollocated = 1,
    kTopCollocated = kLeftCollocated,
    kHalf = 2,
  };
 
  VPCodecConfigurationRecord();
  VPCodecConfigurationRecord(
      uint8_t profile,
      uint8_t level,
      uint8_t bit_depth,
      uint8_t chroma_subsampling,
      bool video_full_range_flag,
      uint8_t color_primaries,
      uint8_t transfer_characteristics,
      uint8_t matrix_coefficients,
      const std::vector<uint8_t>& codec_initialization_data);
  ~VPCodecConfigurationRecord();
 
  bool ParseMP4(const std::vector<uint8_t>& data);
 
  bool ParseWebM(const std::vector<uint8_t>& data);
 
  void SetVP9Level(uint16_t width,
                   uint16_t height,
                   double sample_duration_seconds);
 
  void WriteMP4(std::vector<uint8_t>* data) const;
 
  void WriteWebM(std::vector<uint8_t>* data) const;
 
  std::string GetCodecString(Codec codec) const;
 
  void MergeFrom(const VPCodecConfigurationRecord& other);
 
  void SetChromaSubsampling(uint8_t subsampling_x, uint8_t subsampling_y);
  void SetChromaSubsampling(ChromaSubsampling chroma_subsampling);
  void SetChromaLocation(uint8_t chroma_siting_x, uint8_t chroma_siting_y);
 
  void set_profile(uint8_t profile) { profile_ = profile; }
  void set_level(uint8_t level) { level_ = level; }
  void set_bit_depth(uint8_t bit_depth) { bit_depth_ = bit_depth; }
  void set_video_full_range_flag(bool video_full_range_flag) {
    video_full_range_flag_ = video_full_range_flag;
  }
  void set_color_primaries(uint8_t color_primaries) {
    color_primaries_ = color_primaries;
  }
  void set_transfer_characteristics(uint8_t transfer_characteristics) {
    transfer_characteristics_ = transfer_characteristics;
  }
  void set_matrix_coefficients(uint8_t matrix_coefficients) {
    matrix_coefficients_ = matrix_coefficients;
  }
 
  bool is_profile_set() const { return static_cast<bool>(profile_); }
  bool is_level_set() const { return static_cast<bool>(level_); }
  bool is_bit_depth_set() const { return static_cast<bool>(bit_depth_); }
  bool is_chroma_subsampling_set() const {
    return static_cast<bool>(chroma_subsampling_);
  }
  bool is_video_full_range_flag_set() const {
    return static_cast<bool>(video_full_range_flag_);
  }
  bool is_color_primaries_set() const {
    return static_cast<bool>(color_primaries_);
  }
  bool is_transfer_characteristics_set() const {
    return static_cast<bool>(transfer_characteristics_);
  }
  bool is_matrix_coefficients_set() const {
    return static_cast<bool>(matrix_coefficients_);
  }
  bool is_chroma_location_set() const {
    return static_cast<bool>(chroma_location_);
  }
 
  uint8_t profile() const { return profile_.value_or(0); }
  uint8_t level() const { return level_.value_or(10); }
  uint8_t bit_depth() const { return bit_depth_.value_or(8); }
  uint8_t chroma_subsampling() const {
    return chroma_subsampling_.value_or(CHROMA_420_COLLOCATED_WITH_LUMA);
  }
  bool video_full_range_flag() const {
    return video_full_range_flag_.value_or(false);
  }
  uint8_t color_primaries() const {
    return color_primaries_.value_or(AVCOL_PRI_UNSPECIFIED);
  }
  uint8_t transfer_characteristics() const {
    return transfer_characteristics_.value_or(AVCOL_TRC_UNSPECIFIED);
  }
  uint8_t matrix_coefficients() const {
    return matrix_coefficients_.value_or(AVCOL_SPC_UNSPECIFIED);
  }
  uint8_t chroma_location() const {
    return chroma_location_.value_or(AVCHROMA_LOC_UNSPECIFIED);
  }
 
 private:
  void UpdateChromaSubsamplingIfNeeded();
 
  std::optional<uint8_t> profile_;
  std::optional<uint8_t> level_;
  std::optional<uint8_t> bit_depth_;
  std::optional<uint8_t> chroma_subsampling_;
  std::optional<bool> video_full_range_flag_;
  std::optional<uint8_t> color_primaries_;
  std::optional<uint8_t> transfer_characteristics_;
  std::optional<uint8_t> matrix_coefficients_;
  std::vector<uint8_t> codec_initialization_data_;
 
  // Not in the decoder config. It is there to help determine chroma subsampling
  // format.
  std::optional<uint8_t> chroma_location_;
  // Not using DISALLOW_COPY_AND_ASSIGN here intentionally to allow the compiler
  // generated copy constructor and assignment operator. Since the internal data
  // is small, the performance impact is minimal.
};
 
}  // namespace media
}  // namespace shaka
 
#endif  // PACKAGER_MEDIA_CODECS_VP_CODEC_CONFIGURATION_RECORD_H_