Commit 69eab5cd authored by James Zern's avatar James Zern

roll libwebm snapshot

git log --no-merges --oneline 32d5ac4..a97c484
9096786 mkvparser: fix float conversion warning
84e8257 disable -Wdeprecated-declarations in legacy code
a98f495 AddGenericFrame: fix memory leak on failure
da131dd AddCuePoint: fix memory leak on failure
b0cea9c Add(Audio|Video)Track: fix memory leak on failure
5261a67 webm_info: check vp9 ParseUncompressedHeader return
85f7e2e webm_info,PrintVP9Info: validate alt ref sizes
9b97ca1 vp9_header_parser_tests: check parser return
300d6d8 CuePoint::Find: check Track pointer
50c44bb webm_info,OutputCues: fix indexing of tracks
a0d27f0 mkvparser,Block::Parse: remove incorrect assert
784fc1b vttdemux,CloseFiles: check file pointer before closing
b4522c1 .gitattributes: force mkv/webm to be treated as binary
a118f3d Add test for projection parse failures.
d398479 Add test for primary chromaticity parse failures.
9bbec4c Fix permissions on test file.
2cef4d5 mkvparser:Parse: s/FLT_MIN/-FLT_MAX/
35a3c88 mkvmuxer: Turn off estimate_file_duration_ by default
5a41830 mkvparser: Avoid double free when Chromaticity parse fails.
67e3ffa mkvparser: Avoid casts of values too large for float in
Projection elements.
...

Change-Id: I45acb22902ff0a46a5d339dc51181d5d141a8dcc
parent e3afdd89
URL: https://chromium.googlesource.com/webm/libwebm URL: https://chromium.googlesource.com/webm/libwebm
Version: 32d5ac49414a8914ec1e1f285f3f927c6e8ec29d Version: a97c484bfd6b5de4b1b61efe33089b55d810b412
License: BSD License: BSD
License File: LICENSE.txt License File: LICENSE.txt
...@@ -7,4 +7,4 @@ Description: ...@@ -7,4 +7,4 @@ Description:
libwebm is used to handle WebM container I/O. libwebm is used to handle WebM container I/O.
Local Changes: Local Changes:
* <none> * Add V_AV1 codec id
...@@ -14,6 +14,7 @@ ...@@ -14,6 +14,7 @@
#include <cstdio> #include <cstdio>
#include <cstdlib> #include <cstdlib>
#include <cstring>
#include <fstream> #include <fstream>
#include <ios> #include <ios>
...@@ -21,13 +22,23 @@ namespace libwebm { ...@@ -21,13 +22,23 @@ namespace libwebm {
std::string GetTempFileName() { std::string GetTempFileName() {
#if !defined _MSC_VER && !defined __MINGW32__ #if !defined _MSC_VER && !defined __MINGW32__
char temp_file_name_template[] = "libwebm_temp.XXXXXX"; std::string temp_file_name_template_str =
std::string(std::getenv("TEST_TMPDIR") ? std::getenv("TEST_TMPDIR") :
".") +
"/libwebm_temp.XXXXXX";
char* temp_file_name_template =
new char[temp_file_name_template_str.length() + 1];
memset(temp_file_name_template, 0, temp_file_name_template_str.length() + 1);
temp_file_name_template_str.copy(temp_file_name_template,
temp_file_name_template_str.length(), 0);
int fd = mkstemp(temp_file_name_template); int fd = mkstemp(temp_file_name_template);
std::string temp_file_name =
(fd != -1) ? std::string(temp_file_name_template) : std::string();
delete[] temp_file_name_template;
if (fd != -1) { if (fd != -1) {
close(fd); close(fd);
return std::string(temp_file_name_template);
} }
return std::string(); return temp_file_name;
#else #else
char tmp_file_name[_MAX_PATH]; char tmp_file_name[_MAX_PATH];
errno_t err = tmpnam_s(tmp_file_name); errno_t err = tmpnam_s(tmp_file_name);
......
...@@ -7,12 +7,15 @@ ...@@ -7,12 +7,15 @@
// be found in the AUTHORS file in the root of the source tree. // be found in the AUTHORS file in the root of the source tree.
#include "hdr_util.h" #include "hdr_util.h"
#include <climits>
#include <cstddef> #include <cstddef>
#include <new> #include <new>
#include "mkvparser/mkvparser.h" #include "mkvparser/mkvparser.h"
namespace libwebm { namespace libwebm {
const int Vp9CodecFeatures::kValueNotPresent = INT_MAX;
bool CopyPrimaryChromaticity(const mkvparser::PrimaryChromaticity& parser_pc, bool CopyPrimaryChromaticity(const mkvparser::PrimaryChromaticity& parser_pc,
PrimaryChromaticityPtr* muxer_pc) { PrimaryChromaticityPtr* muxer_pc) {
muxer_pc->reset(new (std::nothrow) muxer_pc->reset(new (std::nothrow)
...@@ -29,9 +32,9 @@ bool MasteringMetadataValuePresent(double value) { ...@@ -29,9 +32,9 @@ bool MasteringMetadataValuePresent(double value) {
bool CopyMasteringMetadata(const mkvparser::MasteringMetadata& parser_mm, bool CopyMasteringMetadata(const mkvparser::MasteringMetadata& parser_mm,
mkvmuxer::MasteringMetadata* muxer_mm) { mkvmuxer::MasteringMetadata* muxer_mm) {
if (MasteringMetadataValuePresent(parser_mm.luminance_max)) if (MasteringMetadataValuePresent(parser_mm.luminance_max))
muxer_mm->luminance_max = parser_mm.luminance_max; muxer_mm->set_luminance_max(parser_mm.luminance_max);
if (MasteringMetadataValuePresent(parser_mm.luminance_min)) if (MasteringMetadataValuePresent(parser_mm.luminance_min))
muxer_mm->luminance_min = parser_mm.luminance_min; muxer_mm->set_luminance_min(parser_mm.luminance_min);
PrimaryChromaticityPtr r_ptr(NULL); PrimaryChromaticityPtr r_ptr(NULL);
PrimaryChromaticityPtr g_ptr(NULL); PrimaryChromaticityPtr g_ptr(NULL);
...@@ -73,34 +76,37 @@ bool CopyColour(const mkvparser::Colour& parser_colour, ...@@ -73,34 +76,37 @@ bool CopyColour(const mkvparser::Colour& parser_colour,
return false; return false;
if (ColourValuePresent(parser_colour.matrix_coefficients)) if (ColourValuePresent(parser_colour.matrix_coefficients))
muxer_colour->matrix_coefficients = parser_colour.matrix_coefficients; muxer_colour->set_matrix_coefficients(parser_colour.matrix_coefficients);
if (ColourValuePresent(parser_colour.bits_per_channel)) if (ColourValuePresent(parser_colour.bits_per_channel))
muxer_colour->bits_per_channel = parser_colour.bits_per_channel; muxer_colour->set_bits_per_channel(parser_colour.bits_per_channel);
if (ColourValuePresent(parser_colour.chroma_subsampling_horz)) if (ColourValuePresent(parser_colour.chroma_subsampling_horz)) {
muxer_colour->chroma_subsampling_horz = muxer_colour->set_chroma_subsampling_horz(
parser_colour.chroma_subsampling_horz; parser_colour.chroma_subsampling_horz);
if (ColourValuePresent(parser_colour.chroma_subsampling_vert)) }
muxer_colour->chroma_subsampling_vert = if (ColourValuePresent(parser_colour.chroma_subsampling_vert)) {
parser_colour.chroma_subsampling_vert; muxer_colour->set_chroma_subsampling_vert(
parser_colour.chroma_subsampling_vert);
}
if (ColourValuePresent(parser_colour.cb_subsampling_horz)) if (ColourValuePresent(parser_colour.cb_subsampling_horz))
muxer_colour->cb_subsampling_horz = parser_colour.cb_subsampling_horz; muxer_colour->set_cb_subsampling_horz(parser_colour.cb_subsampling_horz);
if (ColourValuePresent(parser_colour.cb_subsampling_vert)) if (ColourValuePresent(parser_colour.cb_subsampling_vert))
muxer_colour->cb_subsampling_vert = parser_colour.cb_subsampling_vert; muxer_colour->set_cb_subsampling_vert(parser_colour.cb_subsampling_vert);
if (ColourValuePresent(parser_colour.chroma_siting_horz)) if (ColourValuePresent(parser_colour.chroma_siting_horz))
muxer_colour->chroma_siting_horz = parser_colour.chroma_siting_horz; muxer_colour->set_chroma_siting_horz(parser_colour.chroma_siting_horz);
if (ColourValuePresent(parser_colour.chroma_siting_vert)) if (ColourValuePresent(parser_colour.chroma_siting_vert))
muxer_colour->chroma_siting_vert = parser_colour.chroma_siting_vert; muxer_colour->set_chroma_siting_vert(parser_colour.chroma_siting_vert);
if (ColourValuePresent(parser_colour.range)) if (ColourValuePresent(parser_colour.range))
muxer_colour->range = parser_colour.range; muxer_colour->set_range(parser_colour.range);
if (ColourValuePresent(parser_colour.transfer_characteristics)) if (ColourValuePresent(parser_colour.transfer_characteristics)) {
muxer_colour->transfer_characteristics = muxer_colour->set_transfer_characteristics(
parser_colour.transfer_characteristics; parser_colour.transfer_characteristics);
}
if (ColourValuePresent(parser_colour.primaries)) if (ColourValuePresent(parser_colour.primaries))
muxer_colour->primaries = parser_colour.primaries; muxer_colour->set_primaries(parser_colour.primaries);
if (ColourValuePresent(parser_colour.max_cll)) if (ColourValuePresent(parser_colour.max_cll))
muxer_colour->max_cll = parser_colour.max_cll; muxer_colour->set_max_cll(parser_colour.max_cll);
if (ColourValuePresent(parser_colour.max_fall)) if (ColourValuePresent(parser_colour.max_fall))
muxer_colour->max_fall = parser_colour.max_fall; muxer_colour->set_max_fall(parser_colour.max_fall);
if (parser_colour.mastering_metadata) { if (parser_colour.mastering_metadata) {
mkvmuxer::MasteringMetadata muxer_mm; mkvmuxer::MasteringMetadata muxer_mm;
...@@ -116,8 +122,8 @@ bool CopyColour(const mkvparser::Colour& parser_colour, ...@@ -116,8 +122,8 @@ bool CopyColour(const mkvparser::Colour& parser_colour,
// //
// 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 // 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// | ID Byte | Length | | // | ID Byte | Length | |
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
// | | // | |
// : Bytes 1..Length of Codec Feature : // : Bytes 1..Length of Codec Feature :
// | | // | |
...@@ -132,51 +138,83 @@ bool CopyColour(const mkvparser::Colour& parser_colour, ...@@ -132,51 +138,83 @@ bool CopyColour(const mkvparser::Colour& parser_colour,
// //
// The X bit is reserved. // The X bit is reserved.
// //
// Currently only profile level is supported. ID byte must be set to 1, and
// length must be 1. Supported values are:
//
// 10: Level 1
// 11: Level 1.1
// 20: Level 2
// 21: Level 2.1
// 30: Level 3
// 31: Level 3.1
// 40: Level 4
// 41: Level 4.1
// 50: Level 5
// 51: Level 5.1
// 52: Level 5.2
// 60: Level 6
// 61: Level 6.1
// 62: Level 6.2
//
// See the following link for more information: // See the following link for more information:
// http://www.webmproject.org/vp9/profiles/ // http://www.webmproject.org/vp9/profiles/
int ParseVpxCodecPrivate(const uint8_t* private_data, int32_t length) { bool ParseVpxCodecPrivate(const uint8_t* private_data, int32_t length,
const int kVpxCodecPrivateLength = 3; Vp9CodecFeatures* features) {
if (!private_data || length != kVpxCodecPrivateLength) const int kVpxCodecPrivateMinLength = 3;
return 0; if (!private_data || !features || length < kVpxCodecPrivateMinLength)
return false;
const uint8_t id_byte = *private_data;
if (id_byte != 1)
return 0;
const int kVpxProfileLength = 1;
const uint8_t length_byte = private_data[1];
if (length_byte != kVpxProfileLength)
return 0;
const int level = static_cast<int>(private_data[2]);
const int kNumLevels = 14;
const int levels[kNumLevels] = {10, 11, 20, 21, 30, 31, 40,
41, 50, 51, 52, 60, 61, 62};
for (int i = 0; i < kNumLevels; ++i) { const uint8_t kVp9ProfileId = 1;
if (level == levels[i]) const uint8_t kVp9LevelId = 2;
return level; const uint8_t kVp9BitDepthId = 3;
} const uint8_t kVp9ChromaSubsamplingId = 4;
const int kVpxFeatureLength = 1;
int offset = 0;
// Set features to not set.
features->profile = Vp9CodecFeatures::kValueNotPresent;
features->level = Vp9CodecFeatures::kValueNotPresent;
features->bit_depth = Vp9CodecFeatures::kValueNotPresent;
features->chroma_subsampling = Vp9CodecFeatures::kValueNotPresent;
do {
const uint8_t id_byte = private_data[offset++];
const uint8_t length_byte = private_data[offset++];
if (length_byte != kVpxFeatureLength)
return false;
if (id_byte == kVp9ProfileId) {
const int priv_profile = static_cast<int>(private_data[offset++]);
if (priv_profile < 0 || priv_profile > 3)
return false;
if (features->profile != Vp9CodecFeatures::kValueNotPresent &&
features->profile != priv_profile) {
return false;
}
features->profile = priv_profile;
} else if (id_byte == kVp9LevelId) {
const int priv_level = static_cast<int>(private_data[offset++]);
const int kNumLevels = 14;
const int levels[kNumLevels] = {10, 11, 20, 21, 30, 31, 40,
41, 50, 51, 52, 60, 61, 62};
for (int i = 0; i < kNumLevels; ++i) {
if (priv_level == levels[i]) {
if (features->level != Vp9CodecFeatures::kValueNotPresent &&
features->level != priv_level) {
return false;
}
features->level = priv_level;
break;
}
}
if (features->level == Vp9CodecFeatures::kValueNotPresent)
return false;
} else if (id_byte == kVp9BitDepthId) {
const int priv_profile = static_cast<int>(private_data[offset++]);
if (priv_profile != 8 && priv_profile != 10 && priv_profile != 12)
return false;
if (features->bit_depth != Vp9CodecFeatures::kValueNotPresent &&
features->bit_depth != priv_profile) {
return false;
}
features->bit_depth = priv_profile;
} else if (id_byte == kVp9ChromaSubsamplingId) {
const int priv_profile = static_cast<int>(private_data[offset++]);
if (priv_profile != 0 && priv_profile != 2 && priv_profile != 3)
return false;
if (features->chroma_subsampling != Vp9CodecFeatures::kValueNotPresent &&
features->chroma_subsampling != priv_profile) {
return false;
}
features->chroma_subsampling = priv_profile;
} else {
// Invalid ID.
return false;
}
} while (offset + kVpxCodecPrivateMinLength <= length);
return 0; return true;
} }
} // namespace libwebm } // namespace libwebm
...@@ -28,7 +28,34 @@ namespace libwebm { ...@@ -28,7 +28,34 @@ namespace libwebm {
// TODO(tomfinegan): These should be moved to libwebm_utils once c++11 is // TODO(tomfinegan): These should be moved to libwebm_utils once c++11 is
// required by libwebm. // required by libwebm.
// Features of the VP9 codec that may be set in the CodecPrivate of a VP9 video
// stream. A value of kValueNotPresent represents that the value was not set in
// the CodecPrivate.
struct Vp9CodecFeatures {
static const int kValueNotPresent;
Vp9CodecFeatures()
: profile(kValueNotPresent),
level(kValueNotPresent),
bit_depth(kValueNotPresent),
chroma_subsampling(kValueNotPresent) {}
~Vp9CodecFeatures() {}
int profile;
int level;
int bit_depth;
int chroma_subsampling;
};
// disable deprecation warnings for auto_ptr
#if defined(__GNUC__) && __GNUC__ >= 5
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#endif
typedef std::auto_ptr<mkvmuxer::PrimaryChromaticity> PrimaryChromaticityPtr; typedef std::auto_ptr<mkvmuxer::PrimaryChromaticity> PrimaryChromaticityPtr;
#if defined(__GNUC__) && __GNUC__ >= 5
#pragma GCC diagnostic pop
#endif
bool CopyPrimaryChromaticity(const mkvparser::PrimaryChromaticity& parser_pc, bool CopyPrimaryChromaticity(const mkvparser::PrimaryChromaticity& parser_pc,
PrimaryChromaticityPtr* muxer_pc); PrimaryChromaticityPtr* muxer_pc);
...@@ -43,8 +70,9 @@ bool ColourValuePresent(long long value); ...@@ -43,8 +70,9 @@ bool ColourValuePresent(long long value);
bool CopyColour(const mkvparser::Colour& parser_colour, bool CopyColour(const mkvparser::Colour& parser_colour,
mkvmuxer::Colour* muxer_colour); mkvmuxer::Colour* muxer_colour);
// Returns VP9 profile upon success or 0 upon failure. // Returns true if |features| is set to one or more valid values.
int ParseVpxCodecPrivate(const uint8_t* private_data, int32_t length); bool ParseVpxCodecPrivate(const uint8_t* private_data, int32_t length,
Vp9CodecFeatures* features);
} // namespace libwebm } // namespace libwebm
......
...@@ -124,6 +124,14 @@ enum MkvId { ...@@ -124,6 +124,14 @@ enum MkvId {
kMkvLuminanceMin = 0x55DA, kMkvLuminanceMin = 0x55DA,
// end mastering metadata // end mastering metadata
// end colour // end colour
// projection
kMkvProjection = 0x7670,
kMkvProjectionType = 0x7671,
kMkvProjectionPrivate = 0x7672,
kMkvProjectionPoseYaw = 0x7673,
kMkvProjectionPosePitch = 0x7674,
kMkvProjectionPoseRoll = 0x7675,
// end projection
// audio // audio
kMkvAudio = 0xE1, kMkvAudio = 0xE1,
kMkvSamplingFrequency = 0xB5, kMkvSamplingFrequency = 0xB5,
......
This diff is collapsed.
...@@ -64,6 +64,12 @@ class IMkvWriter { ...@@ -64,6 +64,12 @@ class IMkvWriter {
LIBWEBM_DISALLOW_COPY_AND_ASSIGN(IMkvWriter); LIBWEBM_DISALLOW_COPY_AND_ASSIGN(IMkvWriter);
}; };
// Writes out the EBML header for a WebM file, but allows caller to specify
// DocType. This function must be called before any other libwebm writing
// functions are called.
bool WriteEbmlHeader(IMkvWriter* writer, uint64_t doc_type_version,
const char* const doc_type);
// Writes out the EBML header for a WebM file. This function must be called // Writes out the EBML header for a WebM file. This function must be called
// before any other libwebm writing functions are called. // before any other libwebm writing functions are called.
bool WriteEbmlHeader(IMkvWriter* writer, uint64_t doc_type_version); bool WriteEbmlHeader(IMkvWriter* writer, uint64_t doc_type_version);
...@@ -348,26 +354,42 @@ class ContentEncoding { ...@@ -348,26 +354,42 @@ class ContentEncoding {
/////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////
// Colour element. // Colour element.
struct PrimaryChromaticity { class PrimaryChromaticity {
PrimaryChromaticity(float x_val, float y_val) : x(x_val), y(y_val) {} public:
PrimaryChromaticity() : x(0), y(0) {} static const float kChromaticityMin;
static const float kChromaticityMax;
PrimaryChromaticity(float x_val, float y_val) : x_(x_val), y_(y_val) {}
PrimaryChromaticity() : x_(0), y_(0) {}
~PrimaryChromaticity() {} ~PrimaryChromaticity() {}
uint64_t PrimaryChromaticityPayloadSize(libwebm::MkvId x_id,
libwebm::MkvId y_id) const; // Returns sum of |x_id| and |y_id| element id sizes and payload sizes.
uint64_t PrimaryChromaticitySize(libwebm::MkvId x_id,
libwebm::MkvId y_id) const;
bool Valid() const;
bool Write(IMkvWriter* writer, libwebm::MkvId x_id, bool Write(IMkvWriter* writer, libwebm::MkvId x_id,
libwebm::MkvId y_id) const; libwebm::MkvId y_id) const;
float x; float x() const { return x_; }
float y; void set_x(float new_x) { x_ = new_x; }
float y() const { return y_; }
void set_y(float new_y) { y_ = new_y; }
private:
float x_;
float y_;
}; };
class MasteringMetadata { class MasteringMetadata {
public: public:
static const float kValueNotPresent; static const float kValueNotPresent;
static const float kMinLuminance;
static const float kMinLuminanceMax;
static const float kMaxLuminanceMax;
MasteringMetadata() MasteringMetadata()
: luminance_max(kValueNotPresent), : luminance_max_(kValueNotPresent),
luminance_min(kValueNotPresent), luminance_min_(kValueNotPresent),
r_(NULL), r_(NULL),
g_(NULL), g_(NULL),
b_(NULL), b_(NULL),
...@@ -381,6 +403,7 @@ class MasteringMetadata { ...@@ -381,6 +403,7 @@ class MasteringMetadata {
// Returns total size of the MasteringMetadata element. // Returns total size of the MasteringMetadata element.
uint64_t MasteringMetadataSize() const; uint64_t MasteringMetadataSize() const;
bool Valid() const;
bool Write(IMkvWriter* writer) const; bool Write(IMkvWriter* writer) const;
// Copies non-null chromaticity. // Copies non-null chromaticity.
...@@ -393,13 +416,21 @@ class MasteringMetadata { ...@@ -393,13 +416,21 @@ class MasteringMetadata {
const PrimaryChromaticity* b() const { return b_; } const PrimaryChromaticity* b() const { return b_; }
const PrimaryChromaticity* white_point() const { return white_point_; } const PrimaryChromaticity* white_point() const { return white_point_; }
float luminance_max; float luminance_max() const { return luminance_max_; }
float luminance_min; void set_luminance_max(float luminance_max) {
luminance_max_ = luminance_max;
}
float luminance_min() const { return luminance_min_; }
void set_luminance_min(float luminance_min) {
luminance_min_ = luminance_min;
}
private: private:
// Returns size of MasteringMetadata child elements. // Returns size of MasteringMetadata child elements.
uint64_t PayloadSize() const; uint64_t PayloadSize() const;
float luminance_max_;
float luminance_min_;
PrimaryChromaticity* r_; PrimaryChromaticity* r_;
PrimaryChromaticity* g_; PrimaryChromaticity* g_;
PrimaryChromaticity* b_; PrimaryChromaticity* b_;
...@@ -408,26 +439,90 @@ class MasteringMetadata { ...@@ -408,26 +439,90 @@ class MasteringMetadata {
class Colour { class Colour {
public: public:
enum MatrixCoefficients {
kGbr = 0,
kBt709 = 1,
kUnspecifiedMc = 2,
kReserved = 3,
kFcc = 4,
kBt470bg = 5,
kSmpte170MMc = 6,
kSmpte240MMc = 7,
kYcocg = 8,
kBt2020NonConstantLuminance = 9,
kBt2020ConstantLuminance = 10,
};
enum ChromaSitingHorz {
kUnspecifiedCsh = 0,
kLeftCollocated = 1,
kHalfCsh = 2,
};
enum ChromaSitingVert {
kUnspecifiedCsv = 0,
kTopCollocated = 1,
kHalfCsv = 2,
};
enum Range {
kUnspecifiedCr = 0,
kBroadcastRange = 1,
kFullRange = 2,
kMcTcDefined = 3, // Defined by MatrixCoefficients/TransferCharacteristics.
};
enum TransferCharacteristics {
kIturBt709Tc = 1,
kUnspecifiedTc = 2,
kReservedTc = 3,
kGamma22Curve = 4,
kGamma28Curve = 5,
kSmpte170MTc = 6,
kSmpte240MTc = 7,
kLinear = 8,
kLog = 9,
kLogSqrt = 10,
kIec6196624 = 11,
kIturBt1361ExtendedColourGamut = 12,
kIec6196621 = 13,
kIturBt202010bit = 14,
kIturBt202012bit = 15,
kSmpteSt2084 = 16,
kSmpteSt4281Tc = 17,
kAribStdB67Hlg = 18,
};
enum Primaries {
kReservedP0 = 0,
kIturBt709P = 1,
kUnspecifiedP = 2,
kReservedP3 = 3,
kIturBt470M = 4,
kIturBt470Bg = 5,
kSmpte170MP = 6,
kSmpte240MP = 7,
kFilm = 8,
kIturBt2020 = 9,
kSmpteSt4281P = 10,
kJedecP22Phosphors = 22,
};
static const uint64_t kValueNotPresent; static const uint64_t kValueNotPresent;
Colour() Colour()
: matrix_coefficients(kValueNotPresent), : matrix_coefficients_(kValueNotPresent),
bits_per_channel(kValueNotPresent), bits_per_channel_(kValueNotPresent),
chroma_subsampling_horz(kValueNotPresent), chroma_subsampling_horz_(kValueNotPresent),
chroma_subsampling_vert(kValueNotPresent),