mkvmuxer: Colour accessors/mutators.
Make data members of Colour and children private, and add accessors and mutators for the changes members. Change-Id: I203f6b4e8047cd4dae5c1b662649b535e05148fd
This commit is contained in:
Tom Finegan
parent
ce52f6e31d
commit
027861614c
@ -32,9 +32,9 @@ bool MasteringMetadataValuePresent(double value) {
|
||||
bool CopyMasteringMetadata(const mkvparser::MasteringMetadata& parser_mm,
|
||||
mkvmuxer::MasteringMetadata* muxer_mm) {
|
||||
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))
|
||||
muxer_mm->luminance_min = parser_mm.luminance_min;
|
||||
muxer_mm->set_luminance_min(parser_mm.luminance_min);
|
||||
|
||||
PrimaryChromaticityPtr r_ptr(NULL);
|
||||
PrimaryChromaticityPtr g_ptr(NULL);
|
||||
@ -76,34 +76,37 @@ bool CopyColour(const mkvparser::Colour& parser_colour,
|
||||
return false;
|
||||
|
||||
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))
|
||||
muxer_colour->bits_per_channel = parser_colour.bits_per_channel;
|
||||
if (ColourValuePresent(parser_colour.chroma_subsampling_horz))
|
||||
muxer_colour->chroma_subsampling_horz =
|
||||
parser_colour.chroma_subsampling_horz;
|
||||
if (ColourValuePresent(parser_colour.chroma_subsampling_vert))
|
||||
muxer_colour->chroma_subsampling_vert =
|
||||
parser_colour.chroma_subsampling_vert;
|
||||
muxer_colour->set_bits_per_channel(parser_colour.bits_per_channel);
|
||||
if (ColourValuePresent(parser_colour.chroma_subsampling_horz)) {
|
||||
muxer_colour->set_chroma_subsampling_horz(
|
||||
parser_colour.chroma_subsampling_horz);
|
||||
}
|
||||
if (ColourValuePresent(parser_colour.chroma_subsampling_vert)) {
|
||||
muxer_colour->set_chroma_subsampling_vert(
|
||||
parser_colour.chroma_subsampling_vert);
|
||||
}
|
||||
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))
|
||||
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))
|
||||
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))
|
||||
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))
|
||||
muxer_colour->range = parser_colour.range;
|
||||
if (ColourValuePresent(parser_colour.transfer_characteristics))
|
||||
muxer_colour->transfer_characteristics =
|
||||
parser_colour.transfer_characteristics;
|
||||
muxer_colour->set_range(parser_colour.range);
|
||||
if (ColourValuePresent(parser_colour.transfer_characteristics)) {
|
||||
muxer_colour->set_transfer_characteristics(
|
||||
parser_colour.transfer_characteristics);
|
||||
}
|
||||
if (ColourValuePresent(parser_colour.primaries))
|
||||
muxer_colour->primaries = parser_colour.primaries;
|
||||
muxer_colour->set_primaries(parser_colour.primaries);
|
||||
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))
|
||||
muxer_colour->max_fall = parser_colour.max_fall;
|
||||
muxer_colour->set_max_fall(parser_colour.max_fall);
|
||||
|
||||
if (parser_colour.mastering_metadata) {
|
||||
mkvmuxer::MasteringMetadata muxer_mm;
|
||||
|
||||
@ -68,7 +68,7 @@ bool CopyChromaticity(const PrimaryChromaticity* src,
|
||||
if (!dst)
|
||||
return false;
|
||||
|
||||
dst->reset(new (std::nothrow) PrimaryChromaticity(src->x, src->y));
|
||||
dst->reset(new (std::nothrow) PrimaryChromaticity(src->x(), src->y()));
|
||||
if (!dst->get())
|
||||
return false;
|
||||
|
||||
@ -950,14 +950,15 @@ void Track::set_name(const char* name) {
|
||||
//
|
||||
// Colour and its child elements
|
||||
|
||||
uint64_t PrimaryChromaticity::PrimaryChromaticityPayloadSize(
|
||||
uint64_t PrimaryChromaticity::PrimaryChromaticitySize(
|
||||
libwebm::MkvId x_id, libwebm::MkvId y_id) const {
|
||||
return EbmlElementSize(x_id, x) + EbmlElementSize(y_id, y);
|
||||
return EbmlElementSize(x_id, x_) + EbmlElementSize(y_id, y_);
|
||||
}
|
||||
|
||||
bool PrimaryChromaticity::Write(IMkvWriter* writer, libwebm::MkvId x_id,
|
||||
libwebm::MkvId y_id) const {
|
||||
return WriteEbmlElement(writer, x_id, x) && WriteEbmlElement(writer, y_id, y);
|
||||
return WriteEbmlElement(writer, x_id, x_) &&
|
||||
WriteEbmlElement(writer, y_id, y_);
|
||||
}
|
||||
|
||||
uint64_t MasteringMetadata::MasteringMetadataSize() const {
|
||||
@ -978,12 +979,12 @@ bool MasteringMetadata::Write(IMkvWriter* writer) const {
|
||||
|
||||
if (!WriteEbmlMasterElement(writer, libwebm::kMkvMasteringMetadata, size))
|
||||
return false;
|
||||
if (luminance_max != kValueNotPresent &&
|
||||
!WriteEbmlElement(writer, libwebm::kMkvLuminanceMax, luminance_max)) {
|
||||
if (luminance_max_ != kValueNotPresent &&
|
||||
!WriteEbmlElement(writer, libwebm::kMkvLuminanceMax, luminance_max_)) {
|
||||
return false;
|
||||
}
|
||||
if (luminance_min != kValueNotPresent &&
|
||||
!WriteEbmlElement(writer, libwebm::kMkvLuminanceMin, luminance_min)) {
|
||||
if (luminance_min_ != kValueNotPresent &&
|
||||
!WriteEbmlElement(writer, libwebm::kMkvLuminanceMin, luminance_min_)) {
|
||||
return false;
|
||||
}
|
||||
if (r_ &&
|
||||
@ -1044,25 +1045,25 @@ bool MasteringMetadata::SetChromaticity(
|
||||
uint64_t MasteringMetadata::PayloadSize() const {
|
||||
uint64_t size = 0;
|
||||
|
||||
if (luminance_max != kValueNotPresent)
|
||||
size += EbmlElementSize(libwebm::kMkvLuminanceMax, luminance_max);
|
||||
if (luminance_min != kValueNotPresent)
|
||||
size += EbmlElementSize(libwebm::kMkvLuminanceMin, luminance_min);
|
||||
if (luminance_max_ != kValueNotPresent)
|
||||
size += EbmlElementSize(libwebm::kMkvLuminanceMax, luminance_max_);
|
||||
if (luminance_min_ != kValueNotPresent)
|
||||
size += EbmlElementSize(libwebm::kMkvLuminanceMin, luminance_min_);
|
||||
|
||||
if (r_) {
|
||||
size += r_->PrimaryChromaticityPayloadSize(
|
||||
libwebm::kMkvPrimaryRChromaticityX, libwebm::kMkvPrimaryRChromaticityY);
|
||||
size += r_->PrimaryChromaticitySize(libwebm::kMkvPrimaryRChromaticityX,
|
||||
libwebm::kMkvPrimaryRChromaticityY);
|
||||
}
|
||||
if (g_) {
|
||||
size += g_->PrimaryChromaticityPayloadSize(
|
||||
libwebm::kMkvPrimaryGChromaticityX, libwebm::kMkvPrimaryGChromaticityY);
|
||||
size += g_->PrimaryChromaticitySize(libwebm::kMkvPrimaryGChromaticityX,
|
||||
libwebm::kMkvPrimaryGChromaticityY);
|
||||
}
|
||||
if (b_) {
|
||||
size += b_->PrimaryChromaticityPayloadSize(
|
||||
libwebm::kMkvPrimaryBChromaticityX, libwebm::kMkvPrimaryBChromaticityY);
|
||||
size += b_->PrimaryChromaticitySize(libwebm::kMkvPrimaryBChromaticityX,
|
||||
libwebm::kMkvPrimaryBChromaticityY);
|
||||
}
|
||||
if (white_point_) {
|
||||
size += white_point_->PrimaryChromaticityPayloadSize(
|
||||
size += white_point_->PrimaryChromaticitySize(
|
||||
libwebm::kMkvWhitePointChromaticityX,
|
||||
libwebm::kMkvWhitePointChromaticityY);
|
||||
}
|
||||
@ -1089,70 +1090,70 @@ bool Colour::Write(IMkvWriter* writer) const {
|
||||
if (!WriteEbmlMasterElement(writer, libwebm::kMkvColour, size))
|
||||
return false;
|
||||
|
||||
if (matrix_coefficients != kValueNotPresent &&
|
||||
if (matrix_coefficients_ != kValueNotPresent &&
|
||||
!WriteEbmlElement(writer, libwebm::kMkvMatrixCoefficients,
|
||||
static_cast<uint64>(matrix_coefficients))) {
|
||||
static_cast<uint64>(matrix_coefficients_))) {
|
||||
return false;
|
||||
}
|
||||
if (bits_per_channel != kValueNotPresent &&
|
||||
if (bits_per_channel_ != kValueNotPresent &&
|
||||
!WriteEbmlElement(writer, libwebm::kMkvBitsPerChannel,
|
||||
static_cast<uint64>(bits_per_channel))) {
|
||||
static_cast<uint64>(bits_per_channel_))) {
|
||||
return false;
|
||||
}
|
||||
if (chroma_subsampling_horz != kValueNotPresent &&
|
||||
if (chroma_subsampling_horz_ != kValueNotPresent &&
|
||||
!WriteEbmlElement(writer, libwebm::kMkvChromaSubsamplingHorz,
|
||||
static_cast<uint64>(chroma_subsampling_horz))) {
|
||||
static_cast<uint64>(chroma_subsampling_horz_))) {
|
||||
return false;
|
||||
}
|
||||
if (chroma_subsampling_vert != kValueNotPresent &&
|
||||
if (chroma_subsampling_vert_ != kValueNotPresent &&
|
||||
!WriteEbmlElement(writer, libwebm::kMkvChromaSubsamplingVert,
|
||||
static_cast<uint64>(chroma_subsampling_vert))) {
|
||||
static_cast<uint64>(chroma_subsampling_vert_))) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (cb_subsampling_horz != kValueNotPresent &&
|
||||
if (cb_subsampling_horz_ != kValueNotPresent &&
|
||||
!WriteEbmlElement(writer, libwebm::kMkvCbSubsamplingHorz,
|
||||
static_cast<uint64>(cb_subsampling_horz))) {
|
||||
static_cast<uint64>(cb_subsampling_horz_))) {
|
||||
return false;
|
||||
}
|
||||
if (cb_subsampling_vert != kValueNotPresent &&
|
||||
if (cb_subsampling_vert_ != kValueNotPresent &&
|
||||
!WriteEbmlElement(writer, libwebm::kMkvCbSubsamplingVert,
|
||||
static_cast<uint64>(cb_subsampling_vert))) {
|
||||
static_cast<uint64>(cb_subsampling_vert_))) {
|
||||
return false;
|
||||
}
|
||||
if (chroma_siting_horz != kValueNotPresent &&
|
||||
if (chroma_siting_horz_ != kValueNotPresent &&
|
||||
!WriteEbmlElement(writer, libwebm::kMkvChromaSitingHorz,
|
||||
static_cast<uint64>(chroma_siting_horz))) {
|
||||
static_cast<uint64>(chroma_siting_horz_))) {
|
||||
return false;
|
||||
}
|
||||
if (chroma_siting_vert != kValueNotPresent &&
|
||||
if (chroma_siting_vert_ != kValueNotPresent &&
|
||||
!WriteEbmlElement(writer, libwebm::kMkvChromaSitingVert,
|
||||
static_cast<uint64>(chroma_siting_vert))) {
|
||||
static_cast<uint64>(chroma_siting_vert_))) {
|
||||
return false;
|
||||
}
|
||||
if (range != kValueNotPresent &&
|
||||
if (range_ != kValueNotPresent &&
|
||||
!WriteEbmlElement(writer, libwebm::kMkvRange,
|
||||
static_cast<uint64>(range))) {
|
||||
static_cast<uint64>(range_))) {
|
||||
return false;
|
||||
}
|
||||
if (transfer_characteristics != kValueNotPresent &&
|
||||
if (transfer_characteristics_ != kValueNotPresent &&
|
||||
!WriteEbmlElement(writer, libwebm::kMkvTransferCharacteristics,
|
||||
static_cast<uint64>(transfer_characteristics))) {
|
||||
static_cast<uint64>(transfer_characteristics_))) {
|
||||
return false;
|
||||
}
|
||||
if (primaries != kValueNotPresent &&
|
||||
if (primaries_ != kValueNotPresent &&
|
||||
!WriteEbmlElement(writer, libwebm::kMkvPrimaries,
|
||||
static_cast<uint64>(primaries))) {
|
||||
static_cast<uint64>(primaries_))) {
|
||||
return false;
|
||||
}
|
||||
if (max_cll != kValueNotPresent &&
|
||||
if (max_cll_ != kValueNotPresent &&
|
||||
!WriteEbmlElement(writer, libwebm::kMkvMaxCLL,
|
||||
static_cast<uint64>(max_cll))) {
|
||||
static_cast<uint64>(max_cll_))) {
|
||||
return false;
|
||||
}
|
||||
if (max_fall != kValueNotPresent &&
|
||||
if (max_fall_ != kValueNotPresent &&
|
||||
!WriteEbmlElement(writer, libwebm::kMkvMaxFALL,
|
||||
static_cast<uint64>(max_fall))) {
|
||||
static_cast<uint64>(max_fall_))) {
|
||||
return false;
|
||||
}
|
||||
|
||||
@ -1167,8 +1168,8 @@ bool Colour::SetMasteringMetadata(const MasteringMetadata& mastering_metadata) {
|
||||
if (!mm_ptr.get())
|
||||
return false;
|
||||
|
||||
mm_ptr->luminance_max = mastering_metadata.luminance_max;
|
||||
mm_ptr->luminance_min = mastering_metadata.luminance_min;
|
||||
mm_ptr->set_luminance_max(mastering_metadata.luminance_max());
|
||||
mm_ptr->set_luminance_min(mastering_metadata.luminance_min());
|
||||
|
||||
if (!mm_ptr->SetChromaticity(mastering_metadata.r(), mastering_metadata.g(),
|
||||
mastering_metadata.b(),
|
||||
@ -1184,43 +1185,56 @@ bool Colour::SetMasteringMetadata(const MasteringMetadata& mastering_metadata) {
|
||||
uint64_t Colour::PayloadSize() const {
|
||||
uint64_t size = 0;
|
||||
|
||||
if (matrix_coefficients != kValueNotPresent)
|
||||
if (matrix_coefficients_ != kValueNotPresent) {
|
||||
size += EbmlElementSize(libwebm::kMkvMatrixCoefficients,
|
||||
static_cast<uint64>(matrix_coefficients));
|
||||
if (bits_per_channel != kValueNotPresent)
|
||||
static_cast<uint64>(matrix_coefficients_));
|
||||
}
|
||||
if (bits_per_channel_ != kValueNotPresent) {
|
||||
size += EbmlElementSize(libwebm::kMkvBitsPerChannel,
|
||||
static_cast<uint64>(bits_per_channel));
|
||||
if (chroma_subsampling_horz != kValueNotPresent)
|
||||
static_cast<uint64>(bits_per_channel_));
|
||||
}
|
||||
if (chroma_subsampling_horz_ != kValueNotPresent) {
|
||||
size += EbmlElementSize(libwebm::kMkvChromaSubsamplingHorz,
|
||||
static_cast<uint64>(chroma_subsampling_horz));
|
||||
if (chroma_subsampling_vert != kValueNotPresent)
|
||||
static_cast<uint64>(chroma_subsampling_horz_));
|
||||
}
|
||||
if (chroma_subsampling_vert_ != kValueNotPresent) {
|
||||
size += EbmlElementSize(libwebm::kMkvChromaSubsamplingVert,
|
||||
static_cast<uint64>(chroma_subsampling_vert));
|
||||
if (cb_subsampling_horz != kValueNotPresent)
|
||||
static_cast<uint64>(chroma_subsampling_vert_));
|
||||
}
|
||||
if (cb_subsampling_horz_ != kValueNotPresent) {
|
||||
size += EbmlElementSize(libwebm::kMkvCbSubsamplingHorz,
|
||||
static_cast<uint64>(cb_subsampling_horz));
|
||||
if (cb_subsampling_vert != kValueNotPresent)
|
||||
static_cast<uint64>(cb_subsampling_horz_));
|
||||
}
|
||||
if (cb_subsampling_vert_ != kValueNotPresent) {
|
||||
size += EbmlElementSize(libwebm::kMkvCbSubsamplingVert,
|
||||
static_cast<uint64>(cb_subsampling_vert));
|
||||
if (chroma_siting_horz != kValueNotPresent)
|
||||
static_cast<uint64>(cb_subsampling_vert_));
|
||||
}
|
||||
if (chroma_siting_horz_ != kValueNotPresent) {
|
||||
size += EbmlElementSize(libwebm::kMkvChromaSitingHorz,
|
||||
static_cast<uint64>(chroma_siting_horz));
|
||||
if (chroma_siting_vert != kValueNotPresent)
|
||||
static_cast<uint64>(chroma_siting_horz_));
|
||||
}
|
||||
if (chroma_siting_vert_ != kValueNotPresent) {
|
||||
size += EbmlElementSize(libwebm::kMkvChromaSitingVert,
|
||||
static_cast<uint64>(chroma_siting_vert));
|
||||
if (range != kValueNotPresent)
|
||||
size += EbmlElementSize(libwebm::kMkvRange, static_cast<uint64>(range));
|
||||
if (transfer_characteristics != kValueNotPresent)
|
||||
static_cast<uint64>(chroma_siting_vert_));
|
||||
}
|
||||
if (range_ != kValueNotPresent) {
|
||||
size += EbmlElementSize(libwebm::kMkvRange, static_cast<uint64>(range_));
|
||||
}
|
||||
if (transfer_characteristics_ != kValueNotPresent) {
|
||||
size += EbmlElementSize(libwebm::kMkvTransferCharacteristics,
|
||||
static_cast<uint64>(transfer_characteristics));
|
||||
if (primaries != kValueNotPresent)
|
||||
static_cast<uint64>(transfer_characteristics_));
|
||||
}
|
||||
if (primaries_ != kValueNotPresent) {
|
||||
size += EbmlElementSize(libwebm::kMkvPrimaries,
|
||||
static_cast<uint64>(primaries_));
|
||||
}
|
||||
if (max_cll_ != kValueNotPresent) {
|
||||
size += EbmlElementSize(libwebm::kMkvMaxCLL, static_cast<uint64>(max_cll_));
|
||||
}
|
||||
if (max_fall_ != kValueNotPresent) {
|
||||
size +=
|
||||
EbmlElementSize(libwebm::kMkvPrimaries, static_cast<uint64>(primaries));
|
||||
if (max_cll != kValueNotPresent)
|
||||
size += EbmlElementSize(libwebm::kMkvMaxCLL, static_cast<uint64>(max_cll));
|
||||
if (max_fall != kValueNotPresent)
|
||||
size +=
|
||||
EbmlElementSize(libwebm::kMkvMaxFALL, static_cast<uint64>(max_fall));
|
||||
EbmlElementSize(libwebm::kMkvMaxFALL, static_cast<uint64>(max_fall_));
|
||||
}
|
||||
|
||||
if (mastering_metadata_)
|
||||
size += mastering_metadata_->MasteringMetadataSize();
|
||||
@ -1265,7 +1279,8 @@ bool Projection::Write(IMkvWriter* writer) const {
|
||||
if (!WriteEbmlElement(writer, libwebm::kMkvProjectionPoseYaw, pose_yaw_))
|
||||
return false;
|
||||
|
||||
if (!WriteEbmlElement(writer, libwebm::kMkvProjectionPosePitch, pose_pitch_)) {
|
||||
if (!WriteEbmlElement(writer, libwebm::kMkvProjectionPosePitch,
|
||||
pose_pitch_)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
@ -1457,19 +1472,19 @@ bool VideoTrack::SetColour(const Colour& colour) {
|
||||
return false;
|
||||
}
|
||||
|
||||
colour_ptr->matrix_coefficients = colour.matrix_coefficients;
|
||||
colour_ptr->bits_per_channel = colour.bits_per_channel;
|
||||
colour_ptr->chroma_subsampling_horz = colour.chroma_subsampling_horz;
|
||||
colour_ptr->chroma_subsampling_vert = colour.chroma_subsampling_vert;
|
||||
colour_ptr->cb_subsampling_horz = colour.cb_subsampling_horz;
|
||||
colour_ptr->cb_subsampling_vert = colour.cb_subsampling_vert;
|
||||
colour_ptr->chroma_siting_horz = colour.chroma_siting_horz;
|
||||
colour_ptr->chroma_siting_vert = colour.chroma_siting_vert;
|
||||
colour_ptr->range = colour.range;
|
||||
colour_ptr->transfer_characteristics = colour.transfer_characteristics;
|
||||
colour_ptr->primaries = colour.primaries;
|
||||
colour_ptr->max_cll = colour.max_cll;
|
||||
colour_ptr->max_fall = colour.max_fall;
|
||||
colour_ptr->set_matrix_coefficients(colour.matrix_coefficients());
|
||||
colour_ptr->set_bits_per_channel(colour.bits_per_channel());
|
||||
colour_ptr->set_chroma_subsampling_horz(colour.chroma_subsampling_horz());
|
||||
colour_ptr->set_chroma_subsampling_vert(colour.chroma_subsampling_vert());
|
||||
colour_ptr->set_cb_subsampling_horz(colour.cb_subsampling_horz());
|
||||
colour_ptr->set_cb_subsampling_vert(colour.cb_subsampling_vert());
|
||||
colour_ptr->set_chroma_siting_horz(colour.chroma_siting_horz());
|
||||
colour_ptr->set_chroma_siting_vert(colour.chroma_siting_vert());
|
||||
colour_ptr->set_range(colour.range());
|
||||
colour_ptr->set_transfer_characteristics(colour.transfer_characteristics());
|
||||
colour_ptr->set_primaries(colour.primaries());
|
||||
colour_ptr->set_max_cll(colour.max_cll());
|
||||
colour_ptr->set_max_fall(colour.max_fall());
|
||||
delete colour_;
|
||||
colour_ = colour_ptr.release();
|
||||
return true;
|
||||
|
||||
@ -354,17 +354,27 @@ class ContentEncoding {
|
||||
|
||||
///////////////////////////////////////////////////////////////
|
||||
// Colour element.
|
||||
struct PrimaryChromaticity {
|
||||
PrimaryChromaticity(float x_val, float y_val) : x(x_val), y(y_val) {}
|
||||
PrimaryChromaticity() : x(0), y(0) {}
|
||||
class PrimaryChromaticity {
|
||||
public:
|
||||
PrimaryChromaticity(float x_val, float y_val) : x_(x_val), y_(y_val) {}
|
||||
PrimaryChromaticity() : x_(0), y_(0) {}
|
||||
~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 Write(IMkvWriter* writer, libwebm::MkvId x_id,
|
||||
libwebm::MkvId y_id) const;
|
||||
|
||||
float x;
|
||||
float y;
|
||||
float x() const { return x_; }
|
||||
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 {
|
||||
@ -372,8 +382,8 @@ class MasteringMetadata {
|
||||
static const float kValueNotPresent;
|
||||
|
||||
MasteringMetadata()
|
||||
: luminance_max(kValueNotPresent),
|
||||
luminance_min(kValueNotPresent),
|
||||
: luminance_max_(kValueNotPresent),
|
||||
luminance_min_(kValueNotPresent),
|
||||
r_(NULL),
|
||||
g_(NULL),
|
||||
b_(NULL),
|
||||
@ -399,13 +409,21 @@ class MasteringMetadata {
|
||||
const PrimaryChromaticity* b() const { return b_; }
|
||||
const PrimaryChromaticity* white_point() const { return white_point_; }
|
||||
|
||||
float luminance_max;
|
||||
float luminance_min;
|
||||
float luminance_max() const { return luminance_max_; }
|
||||
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:
|
||||
// Returns size of MasteringMetadata child elements.
|
||||
uint64_t PayloadSize() const;
|
||||
|
||||
float luminance_max_;
|
||||
float luminance_min_;
|
||||
PrimaryChromaticity* r_;
|
||||
PrimaryChromaticity* g_;
|
||||
PrimaryChromaticity* b_;
|
||||
@ -416,19 +434,19 @@ class Colour {
|
||||
public:
|
||||
static const uint64_t kValueNotPresent;
|
||||
Colour()
|
||||
: matrix_coefficients(kValueNotPresent),
|
||||
bits_per_channel(kValueNotPresent),
|
||||
chroma_subsampling_horz(kValueNotPresent),
|
||||
chroma_subsampling_vert(kValueNotPresent),
|
||||
cb_subsampling_horz(kValueNotPresent),
|
||||
cb_subsampling_vert(kValueNotPresent),
|
||||
chroma_siting_horz(kValueNotPresent),
|
||||
chroma_siting_vert(kValueNotPresent),
|
||||
range(kValueNotPresent),
|
||||
transfer_characteristics(kValueNotPresent),
|
||||
primaries(kValueNotPresent),
|
||||
max_cll(kValueNotPresent),
|
||||
max_fall(kValueNotPresent),
|
||||
: matrix_coefficients_(kValueNotPresent),
|
||||
bits_per_channel_(kValueNotPresent),
|
||||
chroma_subsampling_horz_(kValueNotPresent),
|
||||
chroma_subsampling_vert_(kValueNotPresent),
|
||||
cb_subsampling_horz_(kValueNotPresent),
|
||||
cb_subsampling_vert_(kValueNotPresent),
|
||||
chroma_siting_horz_(kValueNotPresent),
|
||||
chroma_siting_vert_(kValueNotPresent),
|
||||
range_(kValueNotPresent),
|
||||
transfer_characteristics_(kValueNotPresent),
|
||||
primaries_(kValueNotPresent),
|
||||
max_cll_(kValueNotPresent),
|
||||
max_fall_(kValueNotPresent),
|
||||
mastering_metadata_(NULL) {}
|
||||
~Colour() { delete mastering_metadata_; }
|
||||
|
||||
@ -443,24 +461,71 @@ class Colour {
|
||||
return mastering_metadata_;
|
||||
}
|
||||
|
||||
uint64_t matrix_coefficients;
|
||||
uint64_t bits_per_channel;
|
||||
uint64_t chroma_subsampling_horz;
|
||||
uint64_t chroma_subsampling_vert;
|
||||
uint64_t cb_subsampling_horz;
|
||||
uint64_t cb_subsampling_vert;
|
||||
uint64_t chroma_siting_horz;
|
||||
uint64_t chroma_siting_vert;
|
||||
uint64_t range;
|
||||
uint64_t transfer_characteristics;
|
||||
uint64_t primaries;
|
||||
uint64_t max_cll;
|
||||
uint64_t max_fall;
|
||||
uint64_t matrix_coefficients() const { return matrix_coefficients_; }
|
||||
void set_matrix_coefficients(uint64_t matrix_coefficients) {
|
||||
matrix_coefficients_ = matrix_coefficients;
|
||||
}
|
||||
uint64_t bits_per_channel() const { return bits_per_channel_; }
|
||||
void set_bits_per_channel(uint64_t bits_per_channel) {
|
||||
bits_per_channel_ = bits_per_channel;
|
||||
}
|
||||
uint64_t chroma_subsampling_horz() const { return chroma_subsampling_horz_; }
|
||||
void set_chroma_subsampling_horz(uint64_t chroma_subsampling_horz) {
|
||||
chroma_subsampling_horz_ = chroma_subsampling_horz;
|
||||
}
|
||||
uint64_t chroma_subsampling_vert() const { return chroma_subsampling_vert_; }
|
||||
void set_chroma_subsampling_vert(uint64_t chroma_subsampling_vert) {
|
||||
chroma_subsampling_vert_ = chroma_subsampling_vert;
|
||||
}
|
||||
uint64_t cb_subsampling_horz() const { return cb_subsampling_horz_; }
|
||||
void set_cb_subsampling_horz(uint64_t cb_subsampling_horz) {
|
||||
cb_subsampling_horz_ = cb_subsampling_horz;
|
||||
}
|
||||
uint64_t cb_subsampling_vert() const { return cb_subsampling_vert_; }
|
||||
void set_cb_subsampling_vert(uint64_t cb_subsampling_vert) {
|
||||
cb_subsampling_vert_ = cb_subsampling_vert;
|
||||
}
|
||||
uint64_t chroma_siting_horz() const { return chroma_siting_horz_; }
|
||||
void set_chroma_siting_horz(uint64_t chroma_siting_horz) {
|
||||
chroma_siting_horz_ = chroma_siting_horz;
|
||||
}
|
||||
uint64_t chroma_siting_vert() const { return chroma_siting_vert_; }
|
||||
void set_chroma_siting_vert(uint64_t chroma_siting_vert) {
|
||||
chroma_siting_vert_ = chroma_siting_vert;
|
||||
}
|
||||
uint64_t range() const { return range_; }
|
||||
void set_range(uint64_t range) { range_ = range; }
|
||||
uint64_t transfer_characteristics() const {
|
||||
return transfer_characteristics_;
|
||||
}
|
||||
void set_transfer_characteristics(uint64_t transfer_characteristics) {
|
||||
transfer_characteristics_ = transfer_characteristics;
|
||||
}
|
||||
uint64_t primaries() const { return primaries_; }
|
||||
void set_primaries(uint64_t primaries) { primaries_ = primaries; }
|
||||
uint64_t max_cll() const { return max_cll_; }
|
||||
void set_max_cll(uint64_t max_cll) { max_cll_ = max_cll; }
|
||||
uint64_t max_fall() const { return max_fall_; }
|
||||
void set_max_fall(uint64_t max_fall) { max_fall_ = max_fall; }
|
||||
|
||||
private:
|
||||
// Returns size of Colour child elements.
|
||||
uint64_t PayloadSize() const;
|
||||
|
||||
uint64_t matrix_coefficients_;
|
||||
uint64_t bits_per_channel_;
|
||||
uint64_t chroma_subsampling_horz_;
|
||||
uint64_t chroma_subsampling_vert_;
|
||||
uint64_t cb_subsampling_horz_;
|
||||
uint64_t cb_subsampling_vert_;
|
||||
uint64_t chroma_siting_horz_;
|
||||
uint64_t chroma_siting_vert_;
|
||||
uint64_t range_;
|
||||
uint64_t transfer_characteristics_;
|
||||
uint64_t primaries_;
|
||||
uint64_t max_cll_;
|
||||
uint64_t max_fall_;
|
||||
|
||||
MasteringMetadata* mastering_metadata_;
|
||||
};
|
||||
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user