generic-library/webm
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Fix bug with calculating master element sizes.

Browse Source 
There was a potential bug with calculating the size of a master
element. The size was being calculated with a straight unsigned
integer when it should have been calculated with a coded
integer.

Change-Id: I68422ecdb7818af51ded2953a8914fcdc8858f7a
This commit is contained in:
Frank Galligan 2012-01-24 18:21:54 -05:00
parent 7a9a72f984
commit 000944c4e4
3 changed files with 109 additions and 136 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

194
mkvmuxer.cpp
View File

@ -32,13 +32,13 @@ IMkvWriter::~IMkvWriter() {
bool WriteEbmlHeader(IMkvWriter* writer) { bool WriteEbmlHeader(IMkvWriter* writer) {
// Level 0 // Level 0
uint64 size = EbmlElementSize(kMkvEBMLVersion, 1ULL, false); uint64 size = EbmlElementSize(kMkvEBMLVersion, 1ULL);
size += EbmlElementSize(kMkvEBMLReadVersion, 1ULL, false); size += EbmlElementSize(kMkvEBMLReadVersion, 1ULL);
size += EbmlElementSize(kMkvEBMLMaxIDLength, 4ULL, false); size += EbmlElementSize(kMkvEBMLMaxIDLength, 4ULL);
size += EbmlElementSize(kMkvEBMLMaxSizeLength, 8ULL, false); size += EbmlElementSize(kMkvEBMLMaxSizeLength, 8ULL);
size += EbmlElementSize(kMkvDocType, "webm", false); size += EbmlElementSize(kMkvDocType, "webm");
size += EbmlElementSize(kMkvDocTypeVersion, 2ULL, false); size += EbmlElementSize(kMkvDocTypeVersion, 2ULL);
size += EbmlElementSize(kMkvDocTypeReadVersion, 2ULL, false); size += EbmlElementSize(kMkvDocTypeReadVersion, 2ULL);
if (!WriteEbmlMasterElement(writer, kMkvEBML, size)) if (!WriteEbmlMasterElement(writer, kMkvEBML, size))
return false; return false;
@ -108,14 +108,13 @@ bool CuePoint::Write(IMkvWriter* writer) const {
if (!writer || track_ < 1 || cluster_pos_ < 1) if (!writer || track_ < 1 || cluster_pos_ < 1)
return false; return false;
uint64 size = EbmlElementSize(kMkvCueClusterPosition, cluster_pos_, false); uint64 size = EbmlElementSize(kMkvCueClusterPosition, cluster_pos_);
size += EbmlElementSize(kMkvCueTrack, track_, false); size += EbmlElementSize(kMkvCueTrack, track_);
if (output_block_number_ && block_number_ > 1) if (output_block_number_ && block_number_ > 1)
size += EbmlElementSize(kMkvCueBlockNumber, block_number_, false); size += EbmlElementSize(kMkvCueBlockNumber, block_number_);
const uint64 track_pos_size = EbmlElementSize(kMkvCueTrackPositions, const uint64 track_pos_size = EbmlMasterElementSize(kMkvCueTrackPositions,
size, size) + size;
true) + size; const uint64 payload_size = EbmlElementSize(kMkvCueTime, time_) +
const uint64 payload_size = EbmlElementSize(kMkvCueTime, time_, false) +
track_pos_size; track_pos_size;
if (!WriteEbmlMasterElement(writer, kMkvCuePoint, payload_size)) if (!WriteEbmlMasterElement(writer, kMkvCuePoint, payload_size))
@ -149,14 +148,13 @@ bool CuePoint::Write(IMkvWriter* writer) const {
} }
uint64 CuePoint::PayloadSize() const { uint64 CuePoint::PayloadSize() const {
uint64 size = EbmlElementSize(kMkvCueClusterPosition, cluster_pos_, false); uint64 size = EbmlElementSize(kMkvCueClusterPosition, cluster_pos_);
size += EbmlElementSize(kMkvCueTrack, track_, false); size += EbmlElementSize(kMkvCueTrack, track_);
if (output_block_number_ && block_number_ > 1) if (output_block_number_ && block_number_ > 1)
size += EbmlElementSize(kMkvCueBlockNumber, block_number_, false); size += EbmlElementSize(kMkvCueBlockNumber, block_number_);
const uint64 track_pos_size = EbmlElementSize(kMkvCueTrackPositions, const uint64 track_pos_size = EbmlMasterElementSize(kMkvCueTrackPositions,
size, size) + size;
true) + size; const uint64 payload_size = EbmlElementSize(kMkvCueTime, time_) +
const uint64 payload_size = EbmlElementSize(kMkvCueTime, time_, false) +
track_pos_size; track_pos_size;
return payload_size; return payload_size;
@ -164,7 +162,7 @@ uint64 CuePoint::PayloadSize() const {
uint64 CuePoint::Size() const { uint64 CuePoint::Size() const {
const uint64 payload_size = PayloadSize(); const uint64 payload_size = PayloadSize();
return EbmlElementSize(kMkvCuePoint, payload_size, true) + payload_size; return EbmlMasterElementSize(kMkvCuePoint, payload_size) + payload_size;
} }
/////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////
@ -303,9 +301,8 @@ bool ContentEncoding::SetEncryptionID(const uint8* id, uint64 length) {
uint64 ContentEncoding::Size() const { uint64 ContentEncoding::Size() const {
const uint64 encryption_size = EncryptionSize(); const uint64 encryption_size = EncryptionSize();
const uint64 encoding_size = EncodingSize(0, encryption_size); const uint64 encoding_size = EncodingSize(0, encryption_size);
const uint64 encodings_size = EbmlElementSize(kMkvContentEncoding, const uint64 encodings_size = EbmlMasterElementSize(kMkvContentEncoding,
encoding_size, encoding_size) +
true) +
encoding_size; encoding_size;
return encodings_size; return encodings_size;
@ -314,9 +311,8 @@ uint64 ContentEncoding::Size() const {
bool ContentEncoding::Write(IMkvWriter* writer) const { bool ContentEncoding::Write(IMkvWriter* writer) const {
const uint64 encryption_size = EncryptionSize(); const uint64 encryption_size = EncryptionSize();
const uint64 encoding_size = EncodingSize(0, encryption_size); const uint64 encoding_size = EncodingSize(0, encryption_size);
const uint64 size = EbmlElementSize(kMkvContentEncoding, const uint64 size = EbmlMasterElementSize(kMkvContentEncoding,
encoding_size, encoding_size) +
true) +
encoding_size; encoding_size;
const int64 payload_position = writer->Position(); const int64 payload_position = writer->Position();
@ -359,20 +355,13 @@ uint64 ContentEncoding::EncodingSize(uint64 compresion_size,
uint64 encoding_size = 0; uint64 encoding_size = 0;
if (encryption_size > 0) { if (encryption_size > 0) {
encoding_size += EbmlElementSize(kMkvContentEncryption, encoding_size += EbmlMasterElementSize(kMkvContentEncryption,
encryption_size, encryption_size) +
true) +
encryption_size; encryption_size;
} }
encoding_size += EbmlElementSize(kMkvContentEncodingType, encoding_size += EbmlElementSize(kMkvContentEncodingType, encoding_type_);
encoding_type_, encoding_size += EbmlElementSize(kMkvContentEncodingScope, encoding_scope_);
false); encoding_size += EbmlElementSize(kMkvContentEncodingOrder, encoding_order_);
encoding_size += EbmlElementSize(kMkvContentEncodingScope,
encoding_scope_,
false);
encoding_size += EbmlElementSize(kMkvContentEncodingOrder,
encoding_order_,
false);
return encoding_size; return encoding_size;
} }
@ -380,9 +369,8 @@ uint64 ContentEncoding::EncodingSize(uint64 compresion_size,
uint64 ContentEncoding::EncryptionSize() const { uint64 ContentEncoding::EncryptionSize() const {
uint64 encryption_size = EbmlElementSize(kMkvContentEncKeyID, uint64 encryption_size = EbmlElementSize(kMkvContentEncKeyID,
enc_key_id_, enc_key_id_,
enc_key_id_length_, enc_key_id_length_);
false); encryption_size += EbmlElementSize(kMkvContentEncAlgo, enc_algo_);
encryption_size += EbmlElementSize(kMkvContentEncAlgo, enc_algo_, false);
return encryption_size; return encryption_size;
} }
@ -455,20 +443,19 @@ ContentEncoding* Track::GetContentEncodingByIndex(uint32 index) const {
} }
uint64 Track::PayloadSize() const { uint64 Track::PayloadSize() const {
uint64 size = EbmlElementSize(kMkvTrackNumber, number_, false); uint64 size = EbmlElementSize(kMkvTrackNumber, number_);
size += EbmlElementSize(kMkvTrackUID, uid_, false); size += EbmlElementSize(kMkvTrackUID, uid_);
size += EbmlElementSize(kMkvTrackType, type_, false); size += EbmlElementSize(kMkvTrackType, type_);
if (codec_id_) if (codec_id_)
size += EbmlElementSize(kMkvCodecID, codec_id_, false); size += EbmlElementSize(kMkvCodecID, codec_id_);
if (codec_private_) if (codec_private_)
size += EbmlElementSize(kMkvCodecPrivate, size += EbmlElementSize(kMkvCodecPrivate,
codec_private_, codec_private_,
codec_private_length_, codec_private_length_);
false);
if (language_) if (language_)
size += EbmlElementSize(kMkvLanguage, language_, false); size += EbmlElementSize(kMkvLanguage, language_);
if (name_) if (name_)
size += EbmlElementSize(kMkvName, name_, false); size += EbmlElementSize(kMkvName, name_);
if (content_encoding_entries_size_ > 0) { if (content_encoding_entries_size_ > 0) {
uint64 content_encodings_size = 0; uint64 content_encodings_size = 0;
@ -477,9 +464,8 @@ uint64 Track::PayloadSize() const {
content_encodings_size += encoding->Size(); content_encodings_size += encoding->Size();
} }
size += EbmlElementSize(kMkvContentEncodings, size += EbmlMasterElementSize(kMkvContentEncodings,
content_encodings_size, content_encodings_size) +
true) +
content_encodings_size; content_encodings_size;
} }
@ -488,7 +474,7 @@ uint64 Track::PayloadSize() const {
uint64 Track::Size() const { uint64 Track::Size() const {
uint64 size = Track::PayloadSize(); uint64 size = Track::PayloadSize();
size += EbmlElementSize(kMkvTrackEntry, size, true); size += EbmlMasterElementSize(kMkvTrackEntry, size);
return size; return size;
} }
@ -504,20 +490,19 @@ bool Track::Write(IMkvWriter* writer) const {
if (!WriteEbmlMasterElement(writer, kMkvTrackEntry, payload_size)) if (!WriteEbmlMasterElement(writer, kMkvTrackEntry, payload_size))
return false; return false;
uint64 size = EbmlElementSize(kMkvTrackNumber, number_, false); uint64 size = EbmlElementSize(kMkvTrackNumber, number_);
size += EbmlElementSize(kMkvTrackUID, uid_, false); size += EbmlElementSize(kMkvTrackUID, uid_);
size += EbmlElementSize(kMkvTrackType, type_, false); size += EbmlElementSize(kMkvTrackType, type_);
if (codec_id_) if (codec_id_)
size += EbmlElementSize(kMkvCodecID, codec_id_, false); size += EbmlElementSize(kMkvCodecID, codec_id_);
if (codec_private_) if (codec_private_)
size += EbmlElementSize(kMkvCodecPrivate, size += EbmlElementSize(kMkvCodecPrivate,
codec_private_, codec_private_,
codec_private_length_, codec_private_length_);
false);
if (language_) if (language_)
size += EbmlElementSize(kMkvLanguage, language_, false); size += EbmlElementSize(kMkvLanguage, language_);
if (name_) if (name_)
size += EbmlElementSize(kMkvName, name_, false); size += EbmlElementSize(kMkvName, name_);
const int64 payload_position = writer->Position(); const int64 payload_position = writer->Position();
if (payload_position < 0) if (payload_position < 0)
@ -698,7 +683,7 @@ uint64 VideoTrack::PayloadSize() const {
const uint64 parent_size = Track::PayloadSize(); const uint64 parent_size = Track::PayloadSize();
uint64 size = VideoPayloadSize(); uint64 size = VideoPayloadSize();
size += EbmlElementSize(kMkvVideo, size, true); size += EbmlMasterElementSize(kMkvVideo, size);
return parent_size + size; return parent_size + size;
} }
@ -707,7 +692,7 @@ uint64 VideoTrack::Size() const {
const uint64 parent_size = Track::Size(); const uint64 parent_size = Track::Size();
uint64 size = VideoPayloadSize(); uint64 size = VideoPayloadSize();
size += EbmlElementSize(kMkvVideo, size, true); size += EbmlMasterElementSize(kMkvVideo, size);
return parent_size + size; return parent_size + size;
} }
@ -753,18 +738,16 @@ bool VideoTrack::Write(IMkvWriter* writer) const {
} }
uint64 VideoTrack::VideoPayloadSize() const { uint64 VideoTrack::VideoPayloadSize() const {
uint64 size = EbmlElementSize(kMkvPixelWidth, width_, false); uint64 size = EbmlElementSize(kMkvPixelWidth, width_);
size += EbmlElementSize(kMkvPixelHeight, height_, false); size += EbmlElementSize(kMkvPixelHeight, height_);
if (display_width_ > 0) if (display_width_ > 0)
size += EbmlElementSize(kMkvDisplayWidth, display_width_, false); size += EbmlElementSize(kMkvDisplayWidth, display_width_);
if (display_height_ > 0) if (display_height_ > 0)
size += EbmlElementSize(kMkvDisplayHeight, display_height_, false); size += EbmlElementSize(kMkvDisplayHeight, display_height_);
if (stereo_mode_ > kMono) if (stereo_mode_ > kMono)
size += EbmlElementSize(kMkvStereoMode, stereo_mode_, false); size += EbmlElementSize(kMkvStereoMode, stereo_mode_);
if (frame_rate_ > 0.0) if (frame_rate_ > 0.0)
size += EbmlElementSize(kMkvFrameRate, size += EbmlElementSize(kMkvFrameRate, static_cast<float>(frame_rate_));
static_cast<float>(frame_rate_),
false);
return size; return size;
} }
@ -786,12 +769,11 @@ uint64 AudioTrack::PayloadSize() const {
const uint64 parent_size = Track::PayloadSize(); const uint64 parent_size = Track::PayloadSize();
uint64 size = EbmlElementSize(kMkvSamplingFrequency, uint64 size = EbmlElementSize(kMkvSamplingFrequency,
static_cast<float>(sample_rate_), static_cast<float>(sample_rate_));
false); size += EbmlElementSize(kMkvChannels, channels_);
size += EbmlElementSize(kMkvChannels, channels_, false);
if (bit_depth_ > 0) if (bit_depth_ > 0)
size += EbmlElementSize(kMkvBitDepth, bit_depth_, false); size += EbmlElementSize(kMkvBitDepth, bit_depth_);
size += EbmlElementSize(kMkvAudio, size, true); size += EbmlMasterElementSize(kMkvAudio, size);
return parent_size + size; return parent_size + size;
} }
@ -800,12 +782,11 @@ uint64 AudioTrack::Size() const {
const uint64 parent_size = Track::Size(); const uint64 parent_size = Track::Size();
uint64 size = EbmlElementSize(kMkvSamplingFrequency, uint64 size = EbmlElementSize(kMkvSamplingFrequency,
static_cast<float>(sample_rate_), static_cast<float>(sample_rate_));
false); size += EbmlElementSize(kMkvChannels, channels_);
size += EbmlElementSize(kMkvChannels, channels_, false);
if (bit_depth_ > 0) if (bit_depth_ > 0)
size += EbmlElementSize(kMkvBitDepth, bit_depth_, false); size += EbmlElementSize(kMkvBitDepth, bit_depth_);
size += EbmlElementSize(kMkvAudio, size, true); size += EbmlMasterElementSize(kMkvAudio, size);
return parent_size + size; return parent_size + size;
} }
@ -816,11 +797,10 @@ bool AudioTrack::Write(IMkvWriter* writer) const {
// Calculate AudioSettings size. // Calculate AudioSettings size.
uint64 size = EbmlElementSize(kMkvSamplingFrequency, uint64 size = EbmlElementSize(kMkvSamplingFrequency,
static_cast<float>(sample_rate_), static_cast<float>(sample_rate_));
false); size += EbmlElementSize(kMkvChannels, channels_);
size += EbmlElementSize(kMkvChannels, channels_, false);
if (bit_depth_ > 0) if (bit_depth_ > 0)
size += EbmlElementSize(kMkvBitDepth, bit_depth_, false); size += EbmlElementSize(kMkvBitDepth, bit_depth_);
if (!WriteEbmlMasterElement(writer, kMkvAudio, size)) if (!WriteEbmlMasterElement(writer, kMkvAudio, size))
return false; return false;
@ -1070,9 +1050,8 @@ bool Cluster::Finalize() {
uint64 Cluster::Size() const { uint64 Cluster::Size() const {
const uint64 element_size = const uint64 element_size =
EbmlElementSize(kMkvCluster, EbmlMasterElementSize(kMkvCluster,
0xFFFFFFFFFFFFFFFFULL, 0xFFFFFFFFFFFFFFFFULL) + payload_size_;
true) + payload_size_;
return element_size; return element_size;
} }
@ -1093,7 +1072,7 @@ bool Cluster::WriteClusterHeader() {
if (!WriteEbmlElement(writer_, kMkvTimecode, timecode())) if (!WriteEbmlElement(writer_, kMkvTimecode, timecode()))
return false; return false;
AddPayloadSize(EbmlElementSize(kMkvTimecode, timecode(), false)); AddPayloadSize(EbmlElementSize(kMkvTimecode, timecode()));
header_written_ = true; header_written_ = true;
return true; return true;
@ -1125,13 +1104,10 @@ bool SeekHead::Finalize(IMkvWriter* writer) const {
if (seek_entry_id_[i] != 0) { if (seek_entry_id_[i] != 0) {
entry_size[i] = EbmlElementSize( entry_size[i] = EbmlElementSize(
kMkvSeekID, kMkvSeekID,
static_cast<uint64>(seek_entry_id_[i]), static_cast<uint64>(seek_entry_id_[i]));
false); entry_size[i] += EbmlElementSize(kMkvSeekPosition, seek_entry_pos_[i]);
entry_size[i] += EbmlElementSize(kMkvSeekPosition,
seek_entry_pos_[i],
false);
payload_size += EbmlElementSize(kMkvSeek, entry_size[i], true) + payload_size += EbmlMasterElementSize(kMkvSeek, entry_size[i]) +
entry_size[i]; entry_size[i];
} }
} }
@ -1163,9 +1139,9 @@ bool SeekHead::Finalize(IMkvWriter* writer) const {
} }
const uint64 total_entry_size = kSeekEntryCount * MaxEntrySize(); const uint64 total_entry_size = kSeekEntryCount * MaxEntrySize();
const uint64 total_size = EbmlElementSize(kMkvSeekHead, const uint64 total_size =
total_entry_size, EbmlMasterElementSize(kMkvSeekHead,
true) + total_entry_size; total_entry_size) + total_entry_size;
const int64 size_left = total_size - (writer->Position() - start_pos_); const int64 size_left = total_size - (writer->Position() - start_pos_);
const uint64 bytes_written = WriteVoidElement(writer, size_left); const uint64 bytes_written = WriteVoidElement(writer, size_left);
@ -1181,7 +1157,7 @@ bool SeekHead::Finalize(IMkvWriter* writer) const {
bool SeekHead::Write(IMkvWriter* writer) { bool SeekHead::Write(IMkvWriter* writer) {
const uint64 entry_size = kSeekEntryCount * MaxEntrySize(); const uint64 entry_size = kSeekEntryCount * MaxEntrySize();
const uint64 size = EbmlElementSize(kMkvSeekHead, entry_size, true); const uint64 size = EbmlMasterElementSize(kMkvSeekHead, entry_size);
start_pos_ = writer->Position(); start_pos_ = writer->Position();
@ -1205,10 +1181,10 @@ bool SeekHead::AddSeekEntry(uint32 id, uint64 pos) {
uint64 SeekHead::MaxEntrySize() const { uint64 SeekHead::MaxEntrySize() const {
const uint64 max_entry_payload_size = const uint64 max_entry_payload_size =
EbmlElementSize(kMkvSeekID, 0xffffffffULL, false) + EbmlElementSize(kMkvSeekID, 0xffffffffULL) +
EbmlElementSize(kMkvSeekPosition, 0xffffffffffffffffULL, false); EbmlElementSize(kMkvSeekPosition, 0xffffffffffffffffULL);
const uint64 max_entry_size = const uint64 max_entry_size =
EbmlElementSize(kMkvSeek, max_entry_payload_size, true) + EbmlMasterElementSize(kMkvSeek, max_entry_payload_size) +
max_entry_payload_size; max_entry_payload_size;
return max_entry_size; return max_entry_size;
@ -1307,13 +1283,11 @@ bool SegmentInfo::Write(IMkvWriter* writer) {
if (!writer || !muxing_app_ || !writing_app_) if (!writer || !muxing_app_ || !writing_app_)
return false; return false;
uint64 size = EbmlElementSize(kMkvTimecodeScale, timecode_scale_, false); uint64 size = EbmlElementSize(kMkvTimecodeScale, timecode_scale_);
if (duration_ > 0.0) if (duration_ > 0.0)
size += EbmlElementSize(kMkvDuration, size += EbmlElementSize(kMkvDuration, static_cast<float>(duration_));
static_cast<float>(duration_), size += EbmlElementSize(kMkvMuxingApp, muxing_app_);
false); size += EbmlElementSize(kMkvWritingApp, writing_app_);
size += EbmlElementSize(kMkvMuxingApp, muxing_app_, false);
size += EbmlElementSize(kMkvWritingApp, writing_app_, false);
if (!WriteEbmlMasterElement(writer, kMkvInfo, size)) if (!WriteEbmlMasterElement(writer, kMkvInfo, size))
return false; return false;

35
mkvmuxerutil.cpp
View File

@ -59,7 +59,17 @@ int32 GetUIntSize(uint64 value) {
return 8; return 8;
} }
uint64 EbmlElementSize(uint64 type, uint64 value, bool master) { uint64 EbmlMasterElementSize(uint64 type, uint64 value) {
// Size of EBML ID
int32 ebml_size = GetUIntSize(type);
// Datasize
ebml_size += GetCodedUIntSize(value);
return ebml_size;
}
uint64 EbmlElementSize(uint64 type, uint64 value) {
// Size of EBML ID // Size of EBML ID
int32 ebml_size = GetUIntSize(type); int32 ebml_size = GetUIntSize(type);
@ -67,13 +77,12 @@ uint64 EbmlElementSize(uint64 type, uint64 value, bool master) {
ebml_size += GetUIntSize(value); ebml_size += GetUIntSize(value);
// Size of Datasize // Size of Datasize
if (!master) ebml_size++;
ebml_size++;
return ebml_size; return ebml_size;
} }
uint64 EbmlElementSize(uint64 type, float value, bool master) { uint64 EbmlElementSize(uint64 type, float value) {
// Size of EBML ID // Size of EBML ID
uint64 ebml_size = GetUIntSize(type); uint64 ebml_size = GetUIntSize(type);
@ -81,13 +90,12 @@ uint64 EbmlElementSize(uint64 type, float value, bool master) {
ebml_size += sizeof(value); ebml_size += sizeof(value);
// Size of Datasize // Size of Datasize
if (!master) ebml_size++;
ebml_size++;
return ebml_size; return ebml_size;
} }
uint64 EbmlElementSize(uint64 type, const char* value, bool master) { uint64 EbmlElementSize(uint64 type, const char* value) {
if (!value) if (!value)
return 0; return 0;
@ -98,16 +106,12 @@ uint64 EbmlElementSize(uint64 type, const char* value, bool master) {
ebml_size += strlen(value); ebml_size += strlen(value);
// Size of Datasize // Size of Datasize
if (!master) ebml_size++;
ebml_size++;
return ebml_size; return ebml_size;
} }
uint64 EbmlElementSize(uint64 type, uint64 EbmlElementSize(uint64 type, const uint8* value, uint64 size) {
const uint8* value,
uint64 size,
bool master) {
if (!value) if (!value)
return 0; return 0;
@ -118,8 +122,7 @@ uint64 EbmlElementSize(uint64 type,
ebml_size += size; ebml_size += size;
// Size of Datasize // Size of Datasize
if (!master) ebml_size += GetCodedUIntSize(size);
ebml_size += GetCodedUIntSize(size);
return ebml_size; return ebml_size;
} }
@ -347,7 +350,7 @@ uint64 WriteVoidElement(IMkvWriter* writer, uint64 size) {
// Subtract one for the void ID and the coded size. // Subtract one for the void ID and the coded size.
uint64 void_entry_size = size - 1 - GetCodedUIntSize(size-1); uint64 void_entry_size = size - 1 - GetCodedUIntSize(size-1);
uint64 void_size = EbmlElementSize(kMkvVoid, void_entry_size, true) + uint64 void_size = EbmlMasterElementSize(kMkvVoid, void_entry_size) +
void_entry_size; void_entry_size;
if (void_size != size) if (void_size != size)

16
mkvmuxerutil.hpp
View File

@ -20,16 +20,12 @@ const uint64 kEbmlUnknownValue = 0x01FFFFFFFFFFFFFFULL;
// Writes out |value| in Big Endian order. Returns 0 on success. // Writes out |value| in Big Endian order. Returns 0 on success.
int32 SerializeInt(IMkvWriter* writer, int64 value, int32 size); int32 SerializeInt(IMkvWriter* writer, int64 value, int32 size);
// Returns the size in bytes of the element. |master| must be set to true if // Returns the size in bytes of the element.
// the element is an Mkv master element. uint64 EbmlMasterElementSize(uint64 type, uint64 value);
// TODO(fgalligan): Change these functions so they are master element aware. uint64 EbmlElementSize(uint64 type, uint64 value);
uint64 EbmlElementSize(uint64 type, uint64 value, bool master); uint64 EbmlElementSize(uint64 type, float value);
uint64 EbmlElementSize(uint64 type, float value, bool master); uint64 EbmlElementSize(uint64 type, const char* value);
uint64 EbmlElementSize(uint64 type, const char* value, bool master); uint64 EbmlElementSize(uint64 type, const uint8* value, uint64 size);
uint64 EbmlElementSize(uint64 type,
const uint8* value,
uint64 size,
bool master);
// Creates an EBML coded number from |value| and writes it out. The size of // Creates an EBML coded number from |value| and writes it out. The size of
// the coded number is determined by the value of |value|. |value| must not // the coded number is determined by the value of |value|. |value| must not