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

clang-format on mkvmuxer.[ch]pp

Browse Source 
Conformance of mkvmuxer.[ch]pp to Google C++ style guide.

Change-Id: I9bcd14710adbad4f32aa1a6be2ea7e40fb715e91
This commit is contained in:
Vignesh Venkatasubramanian 2014-04-11 11:41:01 -07:00
parent ce775929a6
commit fb6b6e6444
2 changed files with 276 additions and 519 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

510
mkvmuxer.cpp
View File

@ -61,11 +61,9 @@ bool StrCpy(const char* src, char** dst_ptr) {
//
// IMkvWriter Class
IMkvWriter::IMkvWriter() {
}
IMkvWriter::IMkvWriter() {}
IMkvWriter::~IMkvWriter() {
}
IMkvWriter::~IMkvWriter() {}
bool WriteEbmlHeader(IMkvWriter* writer) {
// Level 0
@ -97,8 +95,7 @@ bool WriteEbmlHeader(IMkvWriter* writer) {
return true;
}
bool ChunkedCopy(mkvparser::IMkvReader* source,
mkvmuxer::IMkvWriter* dst,
bool ChunkedCopy(mkvparser::IMkvReader* source, mkvmuxer::IMkvWriter* dst,
mkvmuxer::int64 start, int64 size) {
// TODO(vigneshv): Check if this is a reasonable value.
const uint32 kBufSize = 2048;
@ -130,8 +127,7 @@ Frame::Frame()
length_(0),
track_number_(0),
timestamp_(0),
discard_padding_(0) {
}
discard_padding_(0) {}
Frame::~Frame() {
delete[] frame_;
@ -177,11 +173,9 @@ CuePoint::CuePoint()
track_(0),
cluster_pos_(0),
block_number_(1),
output_block_number_(true) {
}
output_block_number_(true) {}
CuePoint::~CuePoint() {
}
CuePoint::~CuePoint() {}
bool CuePoint::Write(IMkvWriter* writer) const {
if (!writer || track_ < 1 || cluster_pos_ < 1)
@ -191,10 +185,10 @@ bool CuePoint::Write(IMkvWriter* writer) const {
size += EbmlElementSize(kMkvCueTrack, track_);
if (output_block_number_ && block_number_ > 1)
size += EbmlElementSize(kMkvCueBlockNumber, block_number_);
const uint64 track_pos_size = EbmlMasterElementSize(kMkvCueTrackPositions,
size) + size;
const uint64 payload_size = EbmlElementSize(kMkvCueTime, time_) +
track_pos_size;
const uint64 track_pos_size =
EbmlMasterElementSize(kMkvCueTrackPositions, size) + size;
const uint64 payload_size =
EbmlElementSize(kMkvCueTime, time_) + track_pos_size;
if (!WriteEbmlMasterElement(writer, kMkvCuePoint, payload_size))
return false;
@ -231,10 +225,10 @@ uint64 CuePoint::PayloadSize() const {
size += EbmlElementSize(kMkvCueTrack, track_);
if (output_block_number_ && block_number_ > 1)
size += EbmlElementSize(kMkvCueBlockNumber, block_number_);
const uint64 track_pos_size = EbmlMasterElementSize(kMkvCueTrackPositions,
size) + size;
const uint64 payload_size = EbmlElementSize(kMkvCueTime, time_) +
track_pos_size;
const uint64 track_pos_size =
EbmlMasterElementSize(kMkvCueTrackPositions, size) + size;
const uint64 payload_size =
EbmlElementSize(kMkvCueTime, time_) + track_pos_size;
return payload_size;
}
@ -252,8 +246,7 @@ Cues::Cues()
: cue_entries_capacity_(0),
cue_entries_size_(0),
cue_entries_(NULL),
output_block_number_(true) {
}
output_block_number_(true) {}
Cues::~Cues() {
if (cue_entries_) {
@ -402,12 +395,9 @@ ContentEncoding::ContentEncoding()
encoding_order_(0),
encoding_scope_(1),
encoding_type_(1),
enc_key_id_length_(0) {
}
enc_key_id_length_(0) {}
ContentEncoding::~ContentEncoding() {
delete [] enc_key_id_;
}
ContentEncoding::~ContentEncoding() { delete[] enc_key_id_; }
bool ContentEncoding::SetEncryptionID(const uint8* id, uint64 length) {
if (!id || length < 1)
@ -429,9 +419,8 @@ bool ContentEncoding::SetEncryptionID(const uint8* id, uint64 length) {
uint64 ContentEncoding::Size() const {
const uint64 encryption_size = EncryptionSize();
const uint64 encoding_size = EncodingSize(0, encryption_size);
const uint64 encodings_size = EbmlMasterElementSize(kMkvContentEncoding,
encoding_size) +
encoding_size;
const uint64 encodings_size =
EbmlMasterElementSize(kMkvContentEncoding, encoding_size) + encoding_size;
return encodings_size;
}
@ -439,9 +428,8 @@ uint64 ContentEncoding::Size() const {
bool ContentEncoding::Write(IMkvWriter* writer) const {
const uint64 encryption_size = EncryptionSize();
const uint64 encoding_size = EncodingSize(0, encryption_size);
const uint64 size = EbmlMasterElementSize(kMkvContentEncoding,
encoding_size) +
encoding_size;
const uint64 size =
EbmlMasterElementSize(kMkvContentEncoding, encoding_size) + encoding_size;
const int64 payload_position = writer->Position();
if (payload_position < 0)
@ -460,9 +448,7 @@ bool ContentEncoding::Write(IMkvWriter* writer) const {
return false;
if (!WriteEbmlElement(writer, kMkvContentEncAlgo, enc_algo_))
return false;
if (!WriteEbmlElement(writer,
kMkvContentEncKeyID,
enc_key_id_,
if (!WriteEbmlElement(writer, kMkvContentEncKeyID, enc_key_id_,
enc_key_id_length_))
return false;
@ -486,8 +472,8 @@ uint64 ContentEncoding::EncodingSize(uint64 compresion_size,
uint64 encoding_size = 0;
if (encryption_size > 0) {
encoding_size += EbmlMasterElementSize(kMkvContentEncryption,
encryption_size) +
encoding_size +=
EbmlMasterElementSize(kMkvContentEncryption, encryption_size) +
encryption_size;
}
encoding_size += EbmlElementSize(kMkvContentEncodingType, encoding_type_);
@ -500,9 +486,8 @@ uint64 ContentEncoding::EncodingSize(uint64 compresion_size,
uint64 ContentEncoding::EncryptionSize() const {
const uint64 aes_size = enc_aes_settings_.Size();
uint64 encryption_size = EbmlElementSize(kMkvContentEncKeyID,
enc_key_id_,
enc_key_id_length_);
uint64 encryption_size =
EbmlElementSize(kMkvContentEncKeyID, enc_key_id_, enc_key_id_length_);
encryption_size += EbmlElementSize(kMkvContentEncAlgo, enc_algo_);
return encryption_size + aes_size;
@ -526,8 +511,7 @@ Track::Track(unsigned int* seed)
default_duration_(0),
codec_private_length_(0),
content_encoding_entries_(NULL),
content_encoding_entries_size_(0) {
}
content_encoding_entries_size_(0) {}
Track::~Track() {
delete[] codec_id_;
@ -588,8 +572,7 @@ uint64 Track::PayloadSize() const {
if (codec_id_)
size += EbmlElementSize(kMkvCodecID, codec_id_);
if (codec_private_)
size += EbmlElementSize(kMkvCodecPrivate,
codec_private_,
size += EbmlElementSize(kMkvCodecPrivate, codec_private_,
codec_private_length_);
if (language_)
size += EbmlElementSize(kMkvLanguage, language_);
@ -611,8 +594,8 @@ uint64 Track::PayloadSize() const {
content_encodings_size += encoding->Size();
}
size += EbmlMasterElementSize(kMkvContentEncodings,
content_encodings_size) +
size +=
EbmlMasterElementSize(kMkvContentEncodings, content_encodings_size) +
content_encodings_size;
}
@ -642,8 +625,7 @@ bool Track::Write(IMkvWriter* writer) const {
if (codec_id_)
size += EbmlElementSize(kMkvCodecID, codec_id_);
if (codec_private_)
size += EbmlElementSize(kMkvCodecPrivate,
codec_private_,
size += EbmlElementSize(kMkvCodecPrivate, codec_private_,
codec_private_length_);
if (language_)
size += EbmlElementSize(kMkvLanguage, language_);
@ -669,8 +651,7 @@ bool Track::Write(IMkvWriter* writer) const {
if (!WriteEbmlElement(writer, kMkvTrackType, type_))
return false;
if (max_block_additional_id_) {
if (!WriteEbmlElement(writer,
kMkvMaxBlockAdditionID,
if (!WriteEbmlElement(writer, kMkvMaxBlockAdditionID,
max_block_additional_id_)) {
return false;
}
@ -692,9 +673,7 @@ bool Track::Write(IMkvWriter* writer) const {
return false;
}
if (codec_private_) {
if (!WriteEbmlElement(writer,
kMkvCodecPrivate,
codec_private_,
if (!WriteEbmlElement(writer, kMkvCodecPrivate, codec_private_,
codec_private_length_))
return false;
}
@ -719,8 +698,7 @@ bool Track::Write(IMkvWriter* writer) const {
content_encodings_size += encoding->Size();
}
if (!WriteEbmlMasterElement(writer,
kMkvContentEncodings,
if (!WriteEbmlMasterElement(writer, kMkvContentEncodings,
content_encodings_size))
return false;
@ -815,15 +793,12 @@ VideoTrack::VideoTrack(unsigned int* seed)
height_(0),
stereo_mode_(0),
alpha_mode_(0),
width_(0) {
}
width_(0) {}
VideoTrack::~VideoTrack() {
}
VideoTrack::~VideoTrack() {}
bool VideoTrack::SetStereoMode(uint64 stereo_mode) {
if (stereo_mode != kMono &&
stereo_mode != kSideBySideLeftIsFirst &&
if (stereo_mode != kMono && stereo_mode != kSideBySideLeftIsFirst &&
stereo_mode != kTopBottomRightIsFirst &&
stereo_mode != kTopBottomLeftIsFirst &&
stereo_mode != kSideBySideRightIsFirst)
@ -834,8 +809,7 @@ bool VideoTrack::SetStereoMode(uint64 stereo_mode) {
}
bool VideoTrack::SetAlphaMode(uint64 alpha_mode) {
if (alpha_mode != kNoAlpha &&
alpha_mode != kAlpha)
if (alpha_mode != kNoAlpha && alpha_mode != kAlpha)
return false;
alpha_mode_ = alpha_mode;
@ -881,8 +855,7 @@ bool VideoTrack::Write(IMkvWriter* writer) const {
if (!WriteEbmlElement(writer, kMkvAlphaMode, alpha_mode_))
return false;
if (frame_rate_ > 0.0)
if (!WriteEbmlElement(writer,
kMkvFrameRate,
if (!WriteEbmlElement(writer, kMkvFrameRate,
static_cast<float>(frame_rate_)))
return false;
@ -916,20 +889,15 @@ uint64 VideoTrack::VideoPayloadSize() const {
// AudioTrack Class
AudioTrack::AudioTrack(unsigned int* seed)
: Track(seed),
bit_depth_(0),
channels_(1),
sample_rate_(0.0) {
}
: Track(seed), bit_depth_(0), channels_(1), sample_rate_(0.0) {}
AudioTrack::~AudioTrack() {
}
AudioTrack::~AudioTrack() {}
uint64 AudioTrack::PayloadSize() const {
const uint64 parent_size = Track::PayloadSize();
uint64 size = EbmlElementSize(kMkvSamplingFrequency,
static_cast<float>(sample_rate_));
uint64 size =
EbmlElementSize(kMkvSamplingFrequency, static_cast<float>(sample_rate_));
size += EbmlElementSize(kMkvChannels, channels_);
if (bit_depth_ > 0)
size += EbmlElementSize(kMkvBitDepth, bit_depth_);
@ -943,8 +911,8 @@ bool AudioTrack::Write(IMkvWriter* writer) const {
return false;
// Calculate AudioSettings size.
uint64 size = EbmlElementSize(kMkvSamplingFrequency,
static_cast<float>(sample_rate_));
uint64 size =
EbmlElementSize(kMkvSamplingFrequency, static_cast<float>(sample_rate_));
size += EbmlElementSize(kMkvChannels, channels_);
if (bit_depth_ > 0)
size += EbmlElementSize(kMkvBitDepth, bit_depth_);
@ -956,8 +924,7 @@ bool AudioTrack::Write(IMkvWriter* writer) const {
if (payload_position < 0)
return false;
if (!WriteEbmlElement(writer,
kMkvSamplingFrequency,
if (!WriteEbmlElement(writer, kMkvSamplingFrequency,
static_cast<float>(sample_rate_)))
return false;
if (!WriteEbmlElement(writer, kMkvChannels, channels_))
@ -983,11 +950,7 @@ const char Tracks::kVorbisCodecId[] = "A_VORBIS";
const char Tracks::kVp8CodecId[] = "V_VP8";
const char Tracks::kVp9CodecId[] = "V_VP9";
Tracks::Tracks()
: track_entries_(NULL),
track_entries_size_(0) {
}
Tracks::Tracks() : track_entries_(NULL), track_entries_size_(0) {}
Tracks::~Tracks() {
if (track_entries_) {
@ -1133,21 +1096,16 @@ bool Tracks::Write(IMkvWriter* writer) const {
//
// Chapter Class
bool Chapter::set_id(const char* id) {
return StrCpy(id, &id_);
}
bool Chapter::set_id(const char* id) { return StrCpy(id, &id_); }
void Chapter::set_time(const Segment& segment,
uint64 start_ns,
uint64 end_ns) {
void Chapter::set_time(const Segment& segment, uint64 start_ns, uint64 end_ns) {
const SegmentInfo* const info = segment.GetSegmentInfo();
const uint64 timecode_scale = info->timecode_scale();
start_timecode_ = start_ns / timecode_scale;
end_timecode_ = end_ns / timecode_scale;
}
bool Chapter::add_string(const char* title,
const char* language,
bool Chapter::add_string(const char* title, const char* language,
const char* country) {
if (!ExpandDisplaysArray())
return false;
@ -1179,8 +1137,7 @@ Chapter::Chapter() {
// active on the array.
}
Chapter::~Chapter() {
}
Chapter::~Chapter() {}
void Chapter::Init(unsigned int* seed) {
id_ = NULL;
@ -1237,8 +1194,7 @@ bool Chapter::ExpandDisplaysArray() {
}
uint64 Chapter::WriteAtom(IMkvWriter* writer) const {
uint64 payload_size =
EbmlElementSize(kMkvChapterStringUID, id_) +
uint64 payload_size = EbmlElementSize(kMkvChapterStringUID, id_) +
EbmlElementSize(kMkvChapterUID, uid_) +
EbmlElementSize(kMkvChapterTimeStart, start_timecode_) +
EbmlElementSize(kMkvChapterTimeEnd, end_timecode_);
@ -1249,8 +1205,7 @@ uint64 Chapter::WriteAtom(IMkvWriter* writer) const {
}
const uint64 atom_size =
EbmlMasterElementSize(kMkvChapterAtom, payload_size) +
payload_size;
EbmlMasterElementSize(kMkvChapterAtom, payload_size) + payload_size;
if (writer == NULL)
return atom_size;
@ -1321,8 +1276,7 @@ uint64 Chapter::Display::WriteDisplay(IMkvWriter* writer) const {
payload_size += EbmlElementSize(kMkvChapCountry, country_);
const uint64 display_size =
EbmlMasterElementSize(kMkvChapterDisplay, payload_size) +
payload_size;
EbmlMasterElementSize(kMkvChapterDisplay, payload_size) + payload_size;
if (writer == NULL)
return display_size;
@ -1357,11 +1311,7 @@ uint64 Chapter::Display::WriteDisplay(IMkvWriter* writer) const {
//
// Chapters Class
Chapters::Chapters()
: chapters_size_(0),
chapters_count_(0),
chapters_(NULL) {
}
Chapters::Chapters() : chapters_size_(0), chapters_count_(0), chapters_(NULL) {}
Chapters::~Chapters() {
while (chapters_count_ > 0) {
@ -1373,9 +1323,7 @@ Chapters::~Chapters() {
chapters_ = NULL;
}
int Chapters::Count() const {
return chapters_count_;
}
int Chapters::Count() const { return chapters_count_; }
Chapter* Chapters::AddChapter(unsigned int* seed) {
if (!ExpandChaptersArray())
@ -1442,8 +1390,7 @@ uint64 Chapters::WriteEdition(IMkvWriter* writer) const {
}
const uint64 edition_size =
EbmlMasterElementSize(kMkvEditionEntry, payload_size) +
payload_size;
EbmlMasterElementSize(kMkvEditionEntry, payload_size) + payload_size;
if (writer == NULL) // return size only
return edition_size;
@ -1481,11 +1428,9 @@ Cluster::Cluster(uint64 timecode, int64 cues_pos)
position_for_cues_(cues_pos),
size_position_(-1),
timecode_(timecode),
writer_(NULL) {
}
writer_(NULL) {}
Cluster::~Cluster() {
}
Cluster::~Cluster() {}
bool Cluster::Init(IMkvWriter* ptr_writer) {
if (!ptr_writer) {
@ -1495,69 +1440,39 @@ bool Cluster::Init(IMkvWriter* ptr_writer) {
return true;
}
bool Cluster::AddFrame(const uint8* frame,
uint64 length,
uint64 track_number,
uint64 abs_timecode,
bool is_key) {
return DoWriteBlock(frame,
length,
track_number,
abs_timecode,
is_key ? 1 : 0,
bool Cluster::AddFrame(const uint8* frame, uint64 length, uint64 track_number,
uint64 abs_timecode, bool is_key) {
return DoWriteBlock(frame, length, track_number, abs_timecode, is_key ? 1 : 0,
&WriteSimpleBlock);
}
bool Cluster::AddFrameWithAdditional(const uint8* frame,
uint64 length,
bool Cluster::AddFrameWithAdditional(const uint8* frame, uint64 length,
const uint8* additional,
uint64 additional_length,
uint64 add_id,
uint64 track_number,
uint64 abs_timecode,
uint64 additional_length, uint64 add_id,
uint64 track_number, uint64 abs_timecode,
bool is_key) {
return DoWriteBlockWithAdditional(frame,
length,
additional,
additional_length,
add_id,
track_number,
abs_timecode,
is_key ? 1 : 0,
&WriteBlockWithAdditional);
return DoWriteBlockWithAdditional(
frame, length, additional, additional_length, add_id, track_number,
abs_timecode, is_key ? 1 : 0, &WriteBlockWithAdditional);
}
bool Cluster::AddFrameWithDiscardPadding(const uint8* frame,
uint64 length,
bool Cluster::AddFrameWithDiscardPadding(const uint8* frame, uint64 length,
int64 discard_padding,
uint64 track_number,
uint64 abs_timecode,
bool is_key) {
return DoWriteBlockWithDiscardPadding(frame,
length,
discard_padding,
track_number,
abs_timecode,
is_key ? 1 : 0,
&WriteBlockWithDiscardPadding);
uint64 abs_timecode, bool is_key) {
return DoWriteBlockWithDiscardPadding(
frame, length, discard_padding, track_number, abs_timecode,
is_key ? 1 : 0, &WriteBlockWithDiscardPadding);
}
bool Cluster::AddMetadata(const uint8* frame,
uint64 length,
uint64 track_number,
uint64 abs_timecode,
bool Cluster::AddMetadata(const uint8* frame, uint64 length,
uint64 track_number, uint64 abs_timecode,
uint64 duration_timecode) {
return DoWriteBlock(frame,
length,
track_number,
abs_timecode,
duration_timecode,
&WriteMetadataBlock);
return DoWriteBlock(frame, length, track_number, abs_timecode,
duration_timecode, &WriteMetadataBlock);
}
void Cluster::AddPayloadSize(uint64 size) {
payload_size_ += size;
}
void Cluster::AddPayloadSize(uint64 size) { payload_size_ += size; }
bool Cluster::Finalize() {
if (!writer_ || finalized_ || size_position_ == -1)
@ -1583,8 +1498,7 @@ bool Cluster::Finalize() {
uint64 Cluster::Size() const {
const uint64 element_size =
EbmlMasterElementSize(kMkvCluster,
0xFFFFFFFFFFFFFFFFULL) + payload_size_;
EbmlMasterElementSize(kMkvCluster, 0xFFFFFFFFFFFFFFFFULL) + payload_size_;
return element_size;
}
@ -1624,13 +1538,9 @@ int64 Cluster::GetRelativeTimecode(int64 abs_timecode) const {
return rel_timecode;
}
bool Cluster::DoWriteBlock(
const uint8* frame,
uint64 length,
uint64 track_number,
uint64 abs_timecode,
uint64 generic_arg,
WriteBlock write_block) {
bool Cluster::DoWriteBlock(const uint8* frame, uint64 length,
uint64 track_number, uint64 abs_timecode,
uint64 generic_arg, WriteBlock write_block) {
if (frame == NULL || length == 0)
return false;
@ -1644,12 +1554,8 @@ bool Cluster::DoWriteBlock(
if (!PreWriteBlock(write_block))
return false;
const uint64 element_size = (*write_block)(writer_,
frame,
length,
track_number,
rel_timecode,
generic_arg);
const uint64 element_size = (*write_block)(
writer_, frame, length, track_number, rel_timecode, generic_arg);
if (element_size == 0)
return false;
@ -1658,17 +1564,11 @@ bool Cluster::DoWriteBlock(
}
bool Cluster::DoWriteBlockWithAdditional(
const uint8* frame,
uint64 length,
const uint8* additional,
uint64 additional_length,
uint64 add_id,
uint64 track_number,
uint64 abs_timecode,
uint64 generic_arg,
WriteBlockAdditional write_block) {
if (frame == NULL || length == 0 ||
additional == NULL || additional_length == 0)
const uint8* frame, uint64 length, const uint8* additional,
uint64 additional_length, uint64 add_id, uint64 track_number,
uint64 abs_timecode, uint64 generic_arg, WriteBlockAdditional write_block) {
if (frame == NULL || length == 0 || additional == NULL ||
additional_length == 0)
return false;
if (!IsValidTrackNumber(track_number))
@ -1681,15 +1581,9 @@ bool Cluster::DoWriteBlockWithAdditional(
if (!PreWriteBlock(write_block))
return false;
const uint64 element_size = (*write_block)(writer_,
frame,
length,
additional,
additional_length,
add_id,
track_number,
rel_timecode,
generic_arg);
const uint64 element_size =
(*write_block)(writer_, frame, length, additional, additional_length,
add_id, track_number, rel_timecode, generic_arg);
if (element_size == 0)
return false;
@ -1698,12 +1592,8 @@ bool Cluster::DoWriteBlockWithAdditional(
}
bool Cluster::DoWriteBlockWithDiscardPadding(
const uint8* frame,
uint64 length,
int64 discard_padding,
uint64 track_number,
uint64 abs_timecode,
uint64 generic_arg,
const uint8* frame, uint64 length, int64 discard_padding,
uint64 track_number, uint64 abs_timecode, uint64 generic_arg,
WriteBlockDiscardPadding write_block) {
if (frame == NULL || length == 0 || discard_padding <= 0)
return false;
@ -1718,13 +1608,9 @@ bool Cluster::DoWriteBlockWithDiscardPadding(
if (!PreWriteBlock(write_block))
return false;
const uint64 element_size = (*write_block)(writer_,
frame,
length,
discard_padding,
track_number,
rel_timecode,
generic_arg);
const uint64 element_size =
(*write_block)(writer_, frame, length, discard_padding, track_number,
rel_timecode, generic_arg);
if (element_size == 0)
return false;
@ -1766,8 +1652,7 @@ SeekHead::SeekHead() : start_pos_(0ULL) {
}
}
SeekHead::~SeekHead() {
}
SeekHead::~SeekHead() {}
bool SeekHead::Finalize(IMkvWriter* writer) const {
if (writer->Seekable()) {
@ -1779,13 +1664,12 @@ bool SeekHead::Finalize(IMkvWriter* writer) const {
for (int32 i = 0; i < kSeekEntryCount; ++i) {
if (seek_entry_id_[i] != 0) {
entry_size[i] = EbmlElementSize(
kMkvSeekID,
static_cast<uint64>(seek_entry_id_[i]));
entry_size[i] =
EbmlElementSize(kMkvSeekID, static_cast<uint64>(seek_entry_id_[i]));
entry_size[i] += EbmlElementSize(kMkvSeekPosition, seek_entry_pos_[i]);
payload_size += EbmlMasterElementSize(kMkvSeek, entry_size[i]) +
entry_size[i];
payload_size +=
EbmlMasterElementSize(kMkvSeek, entry_size[i]) + entry_size[i];
}
}
@ -1805,8 +1689,7 @@ bool SeekHead::Finalize(IMkvWriter* writer) const {
if (!WriteEbmlMasterElement(writer, kMkvSeek, entry_size[i]))
return false;
if (!WriteEbmlElement(writer,
kMkvSeekID,
if (!WriteEbmlElement(writer, kMkvSeekID,
static_cast<uint64>(seek_entry_id_[i])))
return false;
@ -1817,8 +1700,8 @@ bool SeekHead::Finalize(IMkvWriter* writer) const {
const uint64 total_entry_size = kSeekEntryCount * MaxEntrySize();
const uint64 total_size =
EbmlMasterElementSize(kMkvSeekHead,
total_entry_size) + total_entry_size;
EbmlMasterElementSize(kMkvSeekHead, total_entry_size) +
total_entry_size;
const int64 size_left = total_size - (writer->Position() - start_pos_);
const uint64 bytes_written = WriteVoidElement(writer, size_left);
@ -1897,8 +1780,7 @@ SegmentInfo::SegmentInfo()
timecode_scale_(1000000ULL),
writing_app_(NULL),
date_utc_(LLONG_MIN),
duration_pos_(-1) {
}
duration_pos_(-1) {}
SegmentInfo::~SegmentInfo() {
delete[] muxing_app_;
@ -1913,21 +1795,11 @@ bool SegmentInfo::Init() {
GetVersion(&major, &minor, &build, &revision);
char temp[256];
#ifdef _MSC_VER
sprintf_s(temp,
sizeof(temp)/sizeof(temp[0]),
"libwebm-%d.%d.%d.%d",
major,
minor,
build,
revision);
sprintf_s(temp, sizeof(temp) / sizeof(temp[0]), "libwebm-%d.%d.%d.%d", major,
minor, build, revision);
#else
snprintf(temp,
sizeof(temp)/sizeof(temp[0]),
"libwebm-%d.%d.%d.%d",
major,
minor,
build,
revision);
snprintf(temp, sizeof(temp) / sizeof(temp[0]), "libwebm-%d.%d.%d.%d", major,
minor, build, revision);
#endif
const size_t app_len = strlen(temp) + 1;
@ -1964,8 +1836,7 @@ bool SegmentInfo::Finalize(IMkvWriter* writer) const {
if (writer->Position(duration_pos_))
return false;
if (!WriteEbmlElement(writer,
kMkvDuration,
if (!WriteEbmlElement(writer, kMkvDuration,
static_cast<float>(duration_)))
return false;
@ -2135,8 +2006,7 @@ Segment::~Segment() {
}
}
void Segment::MoveCuesBeforeClustersHelper(uint64 diff,
int32 index,
void Segment::MoveCuesBeforeClustersHelper(uint64 diff, int32 index,
uint64* cues_size) {
const uint64 old_cues_size = *cues_size;
CuePoint* const cue_point = cues_.GetCueByIndex(index);
@ -2153,8 +2023,8 @@ void Segment::MoveCuesBeforeClustersHelper(uint64 diff,
// Let d = a + b + c. Now d is the new size of the Cues element which is
// passed on to the next recursive call.
const uint64 cue_point_size_diff = cue_point->Size() - old_cue_point_size;
const uint64 cue_size_diff = GetCodedUIntSize(*cues_size +
cue_point_size_diff) -
const uint64 cue_size_diff =
GetCodedUIntSize(*cues_size + cue_point_size_diff) -
GetCodedUIntSize(*cues_size);
*cues_size += cue_point_size_diff + cue_size_diff;
diff = *cues_size - old_cues_size;
@ -2201,8 +2071,8 @@ bool Segment::CopyAndMoveCuesBeforeClusters(mkvparser::IMkvReader* reader,
IMkvWriter* writer) {
if (!writer->Seekable() || chunking_)
return false;
const int64 cluster_offset = cluster_list_[0]->size_position() -
GetUIntSize(kMkvCluster);
const int64 cluster_offset =
cluster_list_[0]->size_position() - GetUIntSize(kMkvCluster);
// Copy the headers.
if (!ChunkedCopy(reader, writer, 0, cluster_offset))
@ -2228,8 +2098,7 @@ bool Segment::CopyAndMoveCuesBeforeClusters(mkvparser::IMkvReader* reader,
const int64 pos = writer->Position();
const int64 segment_size = writer->Position() - payload_pos_;
if (writer->Position(size_position_) ||
WriteUIntSize(writer, segment_size, 8) ||
writer->Position(pos))
WriteUIntSize(writer, segment_size, 8) || writer->Position(pos))
return false;
return true;
}
@ -2335,9 +2204,7 @@ Track* Segment::AddTrack(int32 number) {
return track;
}
Chapter* Segment::AddChapter() {
return chapters_.AddChapter(&seed_);
}
Chapter* Segment::AddChapter() { return chapters_.AddChapter(&seed_); }
uint64 Segment::AddVideoTrack(int32 width, int32 height, int32 number) {
VideoTrack* const track = new (std::nothrow) VideoTrack(&seed_); // NOLINT
@ -2378,9 +2245,7 @@ bool Segment::AddCuePoint(uint64 timestamp, uint64 track) {
return true;
}
uint64 Segment::AddAudioTrack(int32 sample_rate,
int32 channels,
int32 number) {
uint64 Segment::AddAudioTrack(int32 sample_rate, int32 channels, int32 number) {
AudioTrack* const track = new (std::nothrow) AudioTrack(&seed_); // NOLINT
if (!track)
return 0;
@ -2395,11 +2260,8 @@ uint64 Segment::AddAudioTrack(int32 sample_rate,
return track->number();
}
bool Segment::AddFrame(const uint8* frame,
uint64 length,
uint64 track_number,
uint64 timestamp,
bool is_key) {
bool Segment::AddFrame(const uint8* frame, uint64 length, uint64 track_number,
uint64 timestamp, bool is_key) {
if (!frame)
return false;
@ -2440,11 +2302,7 @@ bool Segment::AddFrame(const uint8* frame,
const uint64 timecode_scale = segment_info_.timecode_scale();
const uint64 abs_timecode = timestamp / timecode_scale;
if (!cluster->AddFrame(frame,
length,
track_number,
abs_timecode,
is_key))
if (!cluster->AddFrame(frame, length, track_number, abs_timecode, is_key))
return false;
if (new_cuepoint_ && cues_track_ == track_number) {
@ -2458,13 +2316,10 @@ bool Segment::AddFrame(const uint8* frame,
return true;
}
bool Segment::AddFrameWithAdditional(const uint8* frame,
uint64 length,
bool Segment::AddFrameWithAdditional(const uint8* frame, uint64 length,
const uint8* additional,
uint64 additional_length,
uint64 add_id,
uint64 track_number,
uint64 timestamp,
uint64 additional_length, uint64 add_id,
uint64 track_number, uint64 timestamp,
bool is_key) {
if (frame == NULL || additional == NULL)
return false;
@ -2506,14 +2361,9 @@ bool Segment::AddFrameWithAdditional(const uint8* frame,
const uint64 timecode_scale = segment_info_.timecode_scale();
const uint64 abs_timecode = timestamp / timecode_scale;
if (!cluster->AddFrameWithAdditional(frame,
length,
additional,
additional_length,
add_id,
track_number,
abs_timecode,
is_key))
if (!cluster->AddFrameWithAdditional(frame, length, additional,
additional_length, add_id, track_number,
abs_timecode, is_key))
return false;
if (new_cuepoint_ && cues_track_ == track_number) {
@ -2527,11 +2377,9 @@ bool Segment::AddFrameWithAdditional(const uint8* frame,
return true;
}
bool Segment::AddFrameWithDiscardPadding(const uint8* frame,
uint64 length,
bool Segment::AddFrameWithDiscardPadding(const uint8* frame, uint64 length,
int64 discard_padding,
uint64 track_number,
uint64 timestamp,
uint64 track_number, uint64 timestamp,
bool is_key) {
if (frame == NULL || discard_padding <= 0)
return false;
@ -2574,11 +2422,8 @@ bool Segment::AddFrameWithDiscardPadding(const uint8* frame,
const uint64 timecode_scale = segment_info_.timecode_scale();
const uint64 abs_timecode = timestamp / timecode_scale;
if (!cluster->AddFrameWithDiscardPadding(frame, length,
discard_padding,
track_number,
abs_timecode,
is_key)) {
if (!cluster->AddFrameWithDiscardPadding(
frame, length, discard_padding, track_number, abs_timecode, is_key)) {
return false;
}
@ -2593,10 +2438,8 @@ bool Segment::AddFrameWithDiscardPadding(const uint8* frame,
return true;
}
bool Segment::AddMetadata(const uint8* frame,
uint64 length,
uint64 track_number,
uint64 timestamp_ns,
bool Segment::AddMetadata(const uint8* frame, uint64 length,
uint64 track_number, uint64 timestamp_ns,
uint64 duration_ns) {
if (!frame)
return false;
@ -2623,10 +2466,7 @@ bool Segment::AddMetadata(const uint8* frame,
const uint64 abs_timecode = timestamp_ns / timecode_scale;
const uint64 duration_timecode = duration_ns / timecode_scale;
if (!cluster->AddMetadata(frame,
length,
track_number,
abs_timecode,
if (!cluster->AddMetadata(frame, length, track_number, abs_timecode,
duration_timecode))
return false;
@ -2639,40 +2479,25 @@ bool Segment::AddMetadata(const uint8* frame,
bool Segment::AddGenericFrame(const Frame* frame) {
last_block_duration_ = frame->duration();
if (!tracks_.TrackIsAudio(frame->track_number()) &&
!tracks_.TrackIsVideo(frame->track_number()) &&
frame->duration() > 0) {
return AddMetadata(frame->frame(),
frame->length(),
frame->track_number(),
frame->timestamp(),
frame->duration());
!tracks_.TrackIsVideo(frame->track_number()) && frame->duration() > 0) {
return AddMetadata(frame->frame(), frame->length(), frame->track_number(),
frame->timestamp(), frame->duration());
} else if (frame->additional() && frame->additional_length() > 0) {
return AddFrameWithAdditional(frame->frame(),
frame->length(),
frame->additional(),
frame->additional_length(),
frame->add_id(),
frame->track_number(),
frame->timestamp(),
frame->is_key());
return AddFrameWithAdditional(
frame->frame(), frame->length(), frame->additional(),
frame->additional_length(), frame->add_id(), frame->track_number(),
frame->timestamp(), frame->is_key());
} else if (frame->discard_padding() > 0) {
return AddFrameWithDiscardPadding(frame->frame(), frame->length(),
frame->discard_padding(),
frame->track_number(),
frame->timestamp(),
frame->is_key());
return AddFrameWithDiscardPadding(
frame->frame(), frame->length(), frame->discard_padding(),
frame->track_number(), frame->timestamp(), frame->is_key());
} else {
return AddFrame(frame->frame(),
frame->length(),
frame->track_number(),
frame->timestamp(),
frame->is_key());
return AddFrame(frame->frame(), frame->length(), frame->track_number(),
frame->timestamp(), frame->is_key());
}
}
void Segment::OutputCues(bool output_cues) {
output_cues_ = output_cues;
}
void Segment::OutputCues(bool output_cues) { output_cues_ = output_cues; }
bool Segment::SetChunking(bool chunking, const char* filename) {
if (chunk_count_ > 0)
@ -2762,9 +2587,7 @@ bool Segment::CuesTrack(uint64 track_number) {
return true;
}
void Segment::ForceNewClusterOnNextFrame() {
force_new_cluster_ = true;
}
void Segment::ForceNewClusterOnNextFrame() { force_new_cluster_ = true; }
Track* Segment::GetTrackByNumber(uint64 track_number) const {
return tracks_.GetTrackByNumber(track_number);
@ -2833,8 +2656,7 @@ bool Segment::WriteSegmentHeader() {
// Here we are testing whether to create a new cluster, given a frame
// having time frame_timestamp_ns.
//
int Segment::TestFrame(uint64 track_number,
uint64 frame_timestamp_ns,
int Segment::TestFrame(uint64 track_number, uint64 frame_timestamp_ns,
bool is_key) const {
if (force_new_cluster_)
return 1;
@ -2982,8 +2804,7 @@ bool Segment::MakeNewCluster(uint64 frame_timestamp_ns) {
}
bool Segment::DoNewClusterProcessing(uint64 track_number,
uint64 frame_timestamp_ns,
bool is_key) {
uint64 frame_timestamp_ns, bool is_key) {
for (;;) {
// Based on the characteristics of the current frame and current
// cluster, decide whether to create a new cluster.
@ -3145,19 +2966,14 @@ int Segment::WriteFramesAll() {
const uint64 frame_timecode = frame_timestamp / timecode_scale;
if (frame->discard_padding() > 0) {
if (!cluster->AddFrameWithDiscardPadding(frame->frame(),
frame->length(),
frame->discard_padding(),
frame->track_number(),
frame_timecode,
frame->is_key())) {
if (!cluster->AddFrameWithDiscardPadding(
frame->frame(), frame->length(), frame->discard_padding(),
frame->track_number(), frame_timecode, frame->is_key())) {
return -1;
}
} else {
if (!cluster->AddFrame(frame->frame(),
frame->length(),
frame->track_number(),
frame_timecode,
if (!cluster->AddFrame(frame->frame(), frame->length(),
frame->track_number(), frame_timecode,
frame->is_key())) {
return -1;
}
@ -3210,19 +3026,15 @@ bool Segment::WriteFramesLessThan(uint64 timestamp) {
const int64 discard_padding = frame_prev->discard_padding();
if (discard_padding > 0) {
if (!cluster->AddFrameWithDiscardPadding(frame_prev->frame(),
frame_prev->length(),
discard_padding,
frame_prev->track_number(),
frame_timecode,
if (!cluster->AddFrameWithDiscardPadding(
frame_prev->frame(), frame_prev->length(), discard_padding,
frame_prev->track_number(), frame_timecode,
frame_prev->is_key())) {
return false;
}
} else {
if (!cluster->AddFrame(frame_prev->frame(),
frame_prev->length(),
frame_prev->track_number(),
frame_timecode,
if (!cluster->AddFrame(frame_prev->frame(), frame_prev->length(),
frame_prev->track_number(), frame_timecode,
frame_prev->is_key())) {
return false;
}

141
mkvmuxer.hpp
View File

@ -60,8 +60,8 @@ class IMkvWriter {
bool WriteEbmlHeader(IMkvWriter* writer);
// Copies in Chunk from source to destination between the given byte positions
bool ChunkedCopy(mkvparser::IMkvReader* source, IMkvWriter* dst,
int64 start, int64 size);
bool ChunkedCopy(mkvparser::IMkvReader* source, IMkvWriter* dst, int64 start,
int64 size);
///////////////////////////////////////////////////////////////
// Class to hold data the will be written to a block.
@ -74,8 +74,7 @@ class Frame {
bool Init(const uint8* frame, uint64 length);
// Copies |additional| data into |additional_|. Returns true on success.
bool AddAdditionalData(const uint8* additional, uint64 length,
uint64 add_id);
bool AddAdditionalData(const uint8* additional, uint64 length, uint64 add_id);
uint64 add_id() const { return add_id_; }
const uint8* additional() const { return additional_; }
@ -223,9 +222,7 @@ class Cues {
// ContentEncAESSettings element
class ContentEncAESSettings {
public:
enum {
kCTR = 1
};
enum { kCTR = 1 };
ContentEncAESSettings();
~ContentEncAESSettings() {}
@ -402,10 +399,7 @@ class VideoTrack : public Track {
kSideBySideRightIsFirst = 11
};
enum AlphaMode {
kNoAlpha = 0,
kAlpha = 1
};
enum AlphaMode { kNoAlpha = 0, kAlpha = 1 };
// The |seed| parameter is used to synthesize a UID for the track.
explicit VideoTrack(unsigned int* seed);
@ -489,10 +483,7 @@ class AudioTrack : public Track {
class Tracks {
public:
// Audio and video type defined by the Matroska specs.
enum {
kVideo = 0x1,
kAudio = 0x2
};
enum { kVideo = 0x1, kAudio = 0x2 };
// Opus, Vorbis, VP8, and VP9 codec ids defined by the Matroska specs.
static const char kOpusCodecId[];
static const char kVorbisCodecId[];
@ -549,8 +540,7 @@ class Chapter {
// Converts the nanosecond start and stop times of this chapter to
// their corresponding timecode values, and stores them that way.
void set_time(const Segment& segment,
uint64 start_time_ns,
void set_time(const Segment& segment, uint64 start_time_ns,
uint64 end_time_ns);
// Sets the uid for this chapter. Primarily used to enable
@ -573,9 +563,7 @@ class Chapter {
// http://www.iana.org/domains/root/db/
//
// The function returns false if the string could not be allocated.
bool add_string(const char* title,
const char* language,
const char* country);
bool add_string(const char* title, const char* language, const char* country);
private:
friend class Chapters;
@ -729,9 +717,7 @@ class Cluster {
// timecode: Absolute (not relative to cluster) timestamp of the
// frame, expressed in timecode units.
// is_key: Flag telling whether or not this frame is a key frame.
bool AddFrame(const uint8* frame,
uint64 length,
uint64 track_number,
bool AddFrame(const uint8* frame, uint64 length, uint64 track_number,
uint64 timecode, // timecode units (absolute)
bool is_key);
@ -748,14 +734,10 @@ class Cluster {
// abs_timecode: Absolute (not relative to cluster) timestamp of the
// frame, expressed in timecode units.
// is_key: Flag telling whether or not this frame is a key frame.
bool AddFrameWithAdditional(const uint8* frame,
uint64 length,
const uint8* additional,
uint64 additional_length,
uint64 add_id,
uint64 track_number,
uint64 abs_timecode,
bool is_key);
bool AddFrameWithAdditional(const uint8* frame, uint64 length,
const uint8* additional, uint64 additional_length,
uint64 add_id, uint64 track_number,
uint64 abs_timecode, bool is_key);
// Adds a frame to be output in the file. The frame is written out through
// |writer_| if successful. Returns true on success.
@ -768,12 +750,9 @@ class Cluster {
// abs_timecode: Absolute (not relative to cluster) timestamp of the
// frame, expressed in timecode units.
// is_key: Flag telling whether or not this frame is a key frame.
bool AddFrameWithDiscardPadding(const uint8* frame,
uint64 length,
int64 discard_padding,
uint64 track_number,
uint64 abs_timecode,
bool is_key);
bool AddFrameWithDiscardPadding(const uint8* frame, uint64 length,
int64 discard_padding, uint64 track_number,
uint64 abs_timecode, bool is_key);
// Writes a frame of metadata to the output medium; returns true on
// success.
@ -789,9 +768,7 @@ class Cluster {
// The metadata frame is written as a block group, with a duration
// sub-element but no reference time sub-elements (indicating that
// it is considered a keyframe, per Matroska semantics).
bool AddMetadata(const uint8* frame,
uint64 length,
uint64 track_number,
bool AddMetadata(const uint8* frame, uint64 length, uint64 track_number,
uint64 timecode, // timecode units (absolute)
uint64 duration); // timecode units
@ -814,34 +791,26 @@ class Cluster {
private:
// Signature that matches either of WriteSimpleBlock or WriteMetadataBlock
// in the muxer utilities package.
typedef uint64 (*WriteBlock)(IMkvWriter* writer,
const uint8* data,
uint64 length,
uint64 track_number,
int64 timecode,
uint64 generic_arg);
typedef uint64 (*WriteBlock)(IMkvWriter* writer, const uint8* data,
uint64 length, uint64 track_number,
int64 timecode, uint64 generic_arg);
// Signature that matches WriteBlockWithAdditional
// in the muxer utilities package.
typedef uint64 (*WriteBlockAdditional)(IMkvWriter* writer,
const uint8* data,
uint64 length,
const uint8* additional,
typedef uint64 (*WriteBlockAdditional)(IMkvWriter* writer, const uint8* data,
uint64 length, const uint8* additional,
uint64 add_id,
uint64 additional_length,
uint64 track_number,
int64 timecode,
uint64 track_number, int64 timecode,
uint64 is_key);
// Signature that matches WriteBlockWithDiscardPadding
// in the muxer utilities package.
typedef uint64 (*WriteBlockDiscardPadding)(IMkvWriter* writer,
const uint8* data,
uint64 length,
const uint8* data, uint64 length,
int64 discard_padding,
uint64 track_number,
int64 timecode,
uint64 is_key);
int64 timecode, uint64 is_key);
// Utility method that confirms that blocks can still be added, and that the
// cluster header has been written. Used by |DoWriteBlock*|. Returns true
@ -863,27 +832,20 @@ class Cluster {
int64 GetRelativeTimecode(int64 abs_timecode) const;
// Used to implement AddFrame and AddMetadata.
bool DoWriteBlock(const uint8* frame,
uint64 length,
uint64 track_number,
uint64 absolute_timecode,
uint64 generic_arg,
bool DoWriteBlock(const uint8* frame, uint64 length, uint64 track_number,
uint64 absolute_timecode, uint64 generic_arg,
WriteBlock write_block);
// Used to implement AddFrameWithAdditional
bool DoWriteBlockWithAdditional(const uint8* frame,
uint64 length,
bool DoWriteBlockWithAdditional(const uint8* frame, uint64 length,
const uint8* additional,
uint64 additional_length,
uint64 add_id,
uint64 track_number,
uint64 absolute_timecode,
uint64 additional_length, uint64 add_id,
uint64 track_number, uint64 absolute_timecode,
uint64 generic_arg,
WriteBlockAdditional write_block);
// Used to implement AddFrameWithDiscardPadding
bool DoWriteBlockWithDiscardPadding(const uint8* frame,
uint64 length,
bool DoWriteBlockWithDiscardPadding(const uint8* frame, uint64 length,
int64 discard_padding,
uint64 track_number,
uint64 absolute_timecode,
@ -1028,10 +990,7 @@ class SegmentInfo {
// |Init| must be called before any other method in this class.
class Segment {
public:
enum Mode {
kLive = 0x1,
kFile = 0x2
};
enum Mode { kLive = 0x1, kFile = 0x2 };
enum CuesPosition {
kAfterClusters = 0x0, // Position Cues after Clusters - Default
@ -1079,11 +1038,8 @@ class Segment {
// functions.
// timestamp: Timestamp of the frame in nanoseconds from 0.
// is_key: Flag telling whether or not this frame is a key frame.
bool AddFrame(const uint8* frame,
uint64 length,
uint64 track_number,
uint64 timestamp_ns,
bool is_key);
bool AddFrame(const uint8* frame, uint64 length, uint64 track_number,
uint64 timestamp_ns, bool is_key);
// Writes a frame of metadata to the output medium; returns true on
// success.
@ -1099,11 +1055,8 @@ class Segment {
// The metadata frame is written as a block group, with a duration
// sub-element but no reference time sub-elements (indicating that
// it is considered a keyframe, per Matroska semantics).
bool AddMetadata(const uint8* frame,
uint64 length,
uint64 track_number,
uint64 timestamp_ns,
uint64 duration_ns);
bool AddMetadata(const uint8* frame, uint64 length, uint64 track_number,
uint64 timestamp_ns, uint64 duration_ns);
// Writes a frame with additional data to the output medium; returns true on
// success.
@ -1118,14 +1071,10 @@ class Segment {
// timestamp: Absolute timestamp of the frame, expressed in nanosecond
// units.
// is_key: Flag telling whether or not this frame is a key frame.
bool AddFrameWithAdditional(const uint8* frame,
uint64 length,
const uint8* additional,
uint64 additional_length,
uint64 add_id,
uint64 track_number,
uint64 timestamp,
bool is_key);
bool AddFrameWithAdditional(const uint8* frame, uint64 length,
const uint8* additional, uint64 additional_length,
uint64 add_id, uint64 track_number,
uint64 timestamp, bool is_key);
// Writes a frame with DiscardPadding to the output medium; returns true on
// success.
@ -1138,12 +1087,9 @@ class Segment {
// timestamp: Absolute timestamp of the frame, expressed in nanosecond
// units.
// is_key: Flag telling whether or not this frame is a key frame.
bool AddFrameWithDiscardPadding(const uint8* frame,
uint64 length,
int64 discard_padding,
uint64 track_number,
uint64 timestamp,
bool is_key);
bool AddFrameWithDiscardPadding(const uint8* frame, uint64 length,
int64 discard_padding, uint64 track_number,
uint64 timestamp, bool is_key);
// Writes a Frame to the output medium. Chooses the correct way of writing
// the frame (Block vs SimpleBlock) based on the parameters passed.
@ -1277,7 +1223,6 @@ class Segment {
// was necessary but creation was not successful.
bool DoNewClusterProcessing(uint64 track_num, uint64 timestamp_ns, bool key);
// Adjusts Cue Point values (to place Cues before Clusters) so that they
// reflect the correct offsets.
void MoveCuesBeforeClusters();