clang-format on mkvmuxer.[ch]pp

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

Change-Id: I9bcd14710adbad4f32aa1a6be2ea7e40fb715e91

mkvmuxer.cpp

@@ -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,
+bool ChunkedCopy(mkvparser::IMkvReader* source, mkvmuxer::IMkvWriter* dst,
-                 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,
+  const uint64 track_pos_size =
-                                                      size) + size;
+      EbmlMasterElementSize(kMkvCueTrackPositions, size) + size;
-  const uint64 payload_size = EbmlElementSize(kMkvCueTime, time_) +
+  const uint64 payload_size =
-                              track_pos_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,
+  const uint64 track_pos_size =
-                                                      size) + size;
+      EbmlMasterElementSize(kMkvCueTrackPositions, size) + size;
-  const uint64 payload_size = EbmlElementSize(kMkvCueTime, time_) +
+  const uint64 payload_size =
-                              track_pos_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() {
+ContentEncoding::~ContentEncoding() { delete[] enc_key_id_; }
-  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,
+  const uint64 encodings_size =
-                                                      encoding_size) +
+      EbmlMasterElementSize(kMkvContentEncoding, encoding_size) + 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,
+  const uint64 size =
-                                            encoding_size) +
+      EbmlMasterElementSize(kMkvContentEncoding, encoding_size) + 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,
+  if (!WriteEbmlElement(writer, kMkvContentEncKeyID, enc_key_id_,
-                        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,
+    encoding_size +=
-                                           encryption_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,
+  uint64 encryption_size =
-                                           enc_key_id_,
+      EbmlElementSize(kMkvContentEncKeyID, enc_key_id_, enc_key_id_length_);
-                                           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,
+    size += EbmlElementSize(kMkvCodecPrivate, codec_private_,
-                            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,
+    size +=
-                                  content_encodings_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,
+    size += EbmlElementSize(kMkvCodecPrivate, codec_private_,
-                            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,
+    if (!WriteEbmlElement(writer, kMkvMaxBlockAdditionID,
-                          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,
+    if (!WriteEbmlElement(writer, kMkvCodecPrivate, codec_private_,
-                          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,
+    if (!WriteEbmlMasterElement(writer, kMkvContentEncodings,
-                                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 &&
+  if (stereo_mode != kMono && stereo_mode != kSideBySideLeftIsFirst &&
-      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 &&
+  if (alpha_mode != kNoAlpha && alpha_mode != kAlpha)
-      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,
+    if (!WriteEbmlElement(writer, kMkvFrameRate,
-                          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),
+    : Track(seed), bit_depth_(0), channels_(1), sample_rate_(0.0) {}
-      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,
+  uint64 size =
-                                static_cast<float>(sample_rate_));
+      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,
+  uint64 size =
-                                static_cast<float>(sample_rate_));
+      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,
+  if (!WriteEbmlElement(writer, kMkvSamplingFrequency,
-                        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) {
+bool Chapter::set_id(const char* id) { return StrCpy(id, &id_); }
-  return StrCpy(id, &id_);
-}
 
-void Chapter::set_time(const Segment& segment,
+void Chapter::set_time(const Segment& segment, uint64 start_ns, uint64 end_ns) {
-                       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,
+bool Chapter::add_string(const char* title, const char* language,
-                         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 =
+  uint64 payload_size = EbmlElementSize(kMkvChapterStringUID, id_) +
-      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) +
+      EbmlMasterElementSize(kMkvChapterAtom, payload_size) + 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) +
+      EbmlMasterElementSize(kMkvChapterDisplay, payload_size) + 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::Chapters() : chapters_size_(0), chapters_count_(0), chapters_(NULL) {}
-    : 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 {
+int Chapters::Count() const { return chapters_count_; }
-  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) +
+      EbmlMasterElementSize(kMkvEditionEntry, payload_size) + 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,
+bool Cluster::AddFrame(const uint8* frame, uint64 length, uint64 track_number,
-                       uint64 length,
+                       uint64 abs_timecode, bool is_key) {
-                       uint64 track_number,
+  return DoWriteBlock(frame, length, track_number, abs_timecode, is_key ? 1 : 0,
-                       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,
+bool Cluster::AddFrameWithAdditional(const uint8* frame, uint64 length,
-                                     uint64 length,
                                      const uint8* additional,
-                                     uint64 additional_length,
+                                     uint64 additional_length, uint64 add_id,
-                                     uint64 add_id,
+                                     uint64 track_number, uint64 abs_timecode,
-                                     uint64 track_number,
-                                     uint64 abs_timecode,
                                      bool is_key) {
-  return DoWriteBlockWithAdditional(frame,
+  return DoWriteBlockWithAdditional(
-                                    length,
+      frame, length, additional, additional_length, add_id, track_number,
-                                    additional,
+      abs_timecode, is_key ? 1 : 0, &WriteBlockWithAdditional);
-                                    additional_length,
-                                    add_id,
-                                    track_number,
-                                    abs_timecode,
-                                    is_key ? 1 : 0,
-                                    &WriteBlockWithAdditional);
 }
 
-bool Cluster::AddFrameWithDiscardPadding(const uint8* frame,
+bool Cluster::AddFrameWithDiscardPadding(const uint8* frame, uint64 length,
-                                         uint64 length,
                                          int64 discard_padding,
                                          uint64 track_number,
-                                         uint64 abs_timecode,
+                                         uint64 abs_timecode, bool is_key) {
-                                         bool is_key) {
+  return DoWriteBlockWithDiscardPadding(
-  return DoWriteBlockWithDiscardPadding(frame,
+      frame, length, discard_padding, track_number, abs_timecode,
-                                        length,
+      is_key ? 1 : 0, &WriteBlockWithDiscardPadding);
-                                        discard_padding,
-                                        track_number,
-                                        abs_timecode,
-                                        is_key ? 1 : 0,
-                                        &WriteBlockWithDiscardPadding);
 }
 
-bool Cluster::AddMetadata(const uint8* frame,
+bool Cluster::AddMetadata(const uint8* frame, uint64 length,
-                          uint64 length,
+                          uint64 track_number, uint64 abs_timecode,
-                          uint64 track_number,
-                          uint64 abs_timecode,
                           uint64 duration_timecode) {
-  return DoWriteBlock(frame,
+  return DoWriteBlock(frame, length, track_number, abs_timecode,
-                      length,
+                      duration_timecode, &WriteMetadataBlock);
-                      track_number,
-                      abs_timecode,
-                      duration_timecode,
-                      &WriteMetadataBlock);
 }
 
-void Cluster::AddPayloadSize(uint64 size) {
+void Cluster::AddPayloadSize(uint64 size) { payload_size_ += 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,
+      EbmlMasterElementSize(kMkvCluster, 0xFFFFFFFFFFFFFFFFULL) + payload_size_;
-                            0xFFFFFFFFFFFFFFFFULL) + payload_size_;
   return element_size;
 }
 
@@ -1624,13 +1538,9 @@ int64 Cluster::GetRelativeTimecode(int64 abs_timecode) const {
   return rel_timecode;
 }
 
-bool Cluster::DoWriteBlock(
+bool Cluster::DoWriteBlock(const uint8* frame, uint64 length,
-    const uint8* frame,
+                           uint64 track_number, uint64 abs_timecode,
-    uint64 length,
+                           uint64 generic_arg, WriteBlock write_block) {
-    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_,
+  const uint64 element_size = (*write_block)(
-                                             frame,
+      writer_, frame, length, track_number, rel_timecode, generic_arg);
-                                             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,
+    const uint8* frame, uint64 length, const uint8* additional,
-    uint64 length,
+    uint64 additional_length, uint64 add_id, uint64 track_number,
-    const uint8* additional,
+    uint64 abs_timecode, uint64 generic_arg, WriteBlockAdditional write_block) {
-    uint64 additional_length,
+  if (frame == NULL || length == 0 || additional == NULL ||
-    uint64 add_id,
+      additional_length == 0)
-    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_,
+  const uint64 element_size =
-                                             frame,
+      (*write_block)(writer_, frame, length, additional, additional_length,
-                                             length,
+                     add_id, track_number, rel_timecode, generic_arg);
-                                             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,
+    const uint8* frame, uint64 length, int64 discard_padding,
-    uint64 length,
+    uint64 track_number, uint64 abs_timecode, uint64 generic_arg,
-    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_,
+  const uint64 element_size =
-                                             frame,
+      (*write_block)(writer_, frame, length, discard_padding, track_number,
-                                             length,
+                     rel_timecode, generic_arg);
-                                             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(
+        entry_size[i] =
-            kMkvSeekID,
+            EbmlElementSize(kMkvSeekID, static_cast<uint64>(seek_entry_id_[i]));
-            static_cast<uint64>(seek_entry_id_[i]));
         entry_size[i] += EbmlElementSize(kMkvSeekPosition, seek_entry_pos_[i]);
 
-        payload_size += EbmlMasterElementSize(kMkvSeek, entry_size[i]) +
+        payload_size +=
-                        entry_size[i];
+            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,
+        if (!WriteEbmlElement(writer, kMkvSeekID,
-                              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,
+        EbmlMasterElementSize(kMkvSeekHead, total_entry_size) +
-                              total_entry_size) + 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,
+  sprintf_s(temp, sizeof(temp) / sizeof(temp[0]), "libwebm-%d.%d.%d.%d", major,
-            sizeof(temp)/sizeof(temp[0]),
+            minor, build, revision);
-            "libwebm-%d.%d.%d.%d",
-            major,
-            minor,
-            build,
-            revision);
 #else
-  snprintf(temp,
+  snprintf(temp, sizeof(temp) / sizeof(temp[0]), "libwebm-%d.%d.%d.%d", major,
-           sizeof(temp)/sizeof(temp[0]),
+           minor, build, revision);
-           "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,
+      if (!WriteEbmlElement(writer, kMkvDuration,
-                            kMkvDuration,
                             static_cast<float>(duration_)))
         return false;
 
@@ -2135,8 +2006,7 @@ Segment::~Segment() {
   }
 }
 
-void Segment::MoveCuesBeforeClustersHelper(uint64 diff,
+void Segment::MoveCuesBeforeClustersHelper(uint64 diff, int32 index,
-                                           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 +
+  const uint64 cue_size_diff =
-                                                cue_point_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() -
+  const int64 cluster_offset =
-                               GetUIntSize(kMkvCluster);
+      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) ||
+      WriteUIntSize(writer, segment_size, 8) || writer->Position(pos))
-      writer->Position(pos))
     return false;
   return true;
 }
@@ -2335,9 +2204,7 @@ Track* Segment::AddTrack(int32 number) {
   return track;
 }
 
-Chapter* Segment::AddChapter() {
+Chapter* Segment::AddChapter() { return chapters_.AddChapter(&seed_); }
-  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,
+uint64 Segment::AddAudioTrack(int32 sample_rate, int32 channels, int32 number) {
-                              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,
+bool Segment::AddFrame(const uint8* frame, uint64 length, uint64 track_number,
-                       uint64 length,
+                       uint64 timestamp, bool is_key) {
-                       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,
+  if (!cluster->AddFrame(frame, length, track_number, abs_timecode, is_key))
-                         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,
+bool Segment::AddFrameWithAdditional(const uint8* frame, uint64 length,
-                                     uint64 length,
                                      const uint8* additional,
-                                     uint64 additional_length,
+                                     uint64 additional_length, uint64 add_id,
-                                     uint64 add_id,
+                                     uint64 track_number, uint64 timestamp,
-                                     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,
+  if (!cluster->AddFrameWithAdditional(frame, length, additional,
-                                       length,
+                                       additional_length, add_id, track_number,
-                                       additional,
+                                       abs_timecode, is_key))
-                                       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,
+bool Segment::AddFrameWithDiscardPadding(const uint8* frame, uint64 length,
-                                         uint64 length,
                                          int64 discard_padding,
-                                         uint64 track_number,
+                                         uint64 track_number, uint64 timestamp,
-                                         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,
+  if (!cluster->AddFrameWithDiscardPadding(
-                                           discard_padding,
+          frame, length, discard_padding, track_number, abs_timecode, is_key)) {
-                                           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,
+bool Segment::AddMetadata(const uint8* frame, uint64 length,
-                          uint64 length,
+                          uint64 track_number, uint64 timestamp_ns,
-                          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,
+  if (!cluster->AddMetadata(frame, length, track_number, abs_timecode,
-                            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()) &&
+      !tracks_.TrackIsVideo(frame->track_number()) && frame->duration() > 0) {
-      frame->duration() > 0) {
+    return AddMetadata(frame->frame(), frame->length(), frame->track_number(),
-    return AddMetadata(frame->frame(),
+                       frame->timestamp(), frame->duration());
-                       frame->length(),
-                       frame->track_number(),
-                       frame->timestamp(),
-                       frame->duration());
   } else if (frame->additional() && frame->additional_length() > 0) {
-    return AddFrameWithAdditional(frame->frame(),
+    return AddFrameWithAdditional(
-                                  frame->length(),
+        frame->frame(), frame->length(), frame->additional(),
-                                  frame->additional(),
+        frame->additional_length(), frame->add_id(), frame->track_number(),
-                                  frame->additional_length(),
+        frame->timestamp(), frame->is_key());
-                                  frame->add_id(),
-                                  frame->track_number(),
-                                  frame->timestamp(),
-                                  frame->is_key());
   } else if (frame->discard_padding() > 0) {
-    return AddFrameWithDiscardPadding(frame->frame(), frame->length(),
+    return AddFrameWithDiscardPadding(
-                                      frame->discard_padding(),
+        frame->frame(), frame->length(), frame->discard_padding(),
-                                      frame->track_number(),
+        frame->track_number(), frame->timestamp(), frame->is_key());
-                                      frame->timestamp(),
-                                      frame->is_key());
   } else {
-    return AddFrame(frame->frame(),
+    return AddFrame(frame->frame(), frame->length(), frame->track_number(),
-                    frame->length(),
+                    frame->timestamp(), frame->is_key());
-                    frame->track_number(),
-                    frame->timestamp(),
-                    frame->is_key());
   }
 }
 
-void Segment::OutputCues(bool output_cues) {
+void Segment::OutputCues(bool output_cues) { output_cues_ = 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() {
+void Segment::ForceNewClusterOnNextFrame() { force_new_cluster_ = true; }
-  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,
+int Segment::TestFrame(uint64 track_number, uint64 frame_timestamp_ns,
-                       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,
+                                     uint64 frame_timestamp_ns, bool is_key) {
-                                     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(),
+      if (!cluster->AddFrameWithDiscardPadding(
-                                               frame->length(),
+              frame->frame(), frame->length(), frame->discard_padding(),
-                                               frame->discard_padding(),
+              frame->track_number(), frame_timecode, frame->is_key())) {
-                                               frame->track_number(),
-                                               frame_timecode,
-                                               frame->is_key())) {
         return -1;
       }
     } else {
-      if (!cluster->AddFrame(frame->frame(),
+      if (!cluster->AddFrame(frame->frame(), frame->length(),
-                             frame->length(),
+                             frame->track_number(), frame_timecode,
-                             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(),
+        if (!cluster->AddFrameWithDiscardPadding(
-                                                 frame_prev->length(),
+                frame_prev->frame(), frame_prev->length(), discard_padding,
-                                                 discard_padding,
+                frame_prev->track_number(), frame_timecode,
-                                                 frame_prev->track_number(),
-                                                 frame_timecode,
                 frame_prev->is_key())) {
           return false;
         }
       } else {
-        if (!cluster->AddFrame(frame_prev->frame(),
+        if (!cluster->AddFrame(frame_prev->frame(), frame_prev->length(),
-                               frame_prev->length(),
+                               frame_prev->track_number(), frame_timecode,
-                               frame_prev->track_number(),
-                               frame_timecode,
                                frame_prev->is_key())) {
           return false;
         }

mkvmuxer.hpp

@@ -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,
+bool ChunkedCopy(mkvparser::IMkvReader* source, IMkvWriter* dst, int64 start,
-                 int64 start, int64 size);
+                 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,
+  bool AddAdditionalData(const uint8* additional, uint64 length, uint64 add_id);
-                         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 {
+  enum { kCTR = 1 };
-    kCTR = 1
-  };
 
   ContentEncAESSettings();
   ~ContentEncAESSettings() {}
@@ -402,10 +399,7 @@ class VideoTrack : public Track {
     kSideBySideRightIsFirst = 11
   };
 
-  enum AlphaMode {
+  enum AlphaMode { kNoAlpha = 0, kAlpha = 1 };
-    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 {
+  enum { kVideo = 0x1, kAudio = 0x2 };
-    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,
+  void set_time(const Segment& segment, uint64 start_time_ns,
-                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,
+  bool add_string(const char* title, const char* language, const char* country);
-                  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,
+  bool AddFrame(const uint8* frame, uint64 length, uint64 track_number,
-                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,
+  bool AddFrameWithAdditional(const uint8* frame, uint64 length,
-                              uint64 length,
+                              const uint8* additional, uint64 additional_length,
-                              const uint8* additional,
+                              uint64 add_id, uint64 track_number,
-                              uint64 additional_length,
+                              uint64 abs_timecode, bool is_key);
-                              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,
+  bool AddFrameWithDiscardPadding(const uint8* frame, uint64 length,
-                                  uint64 length,
+                                  int64 discard_padding, uint64 track_number,
-                                  int64 discard_padding,
+                                  uint64 abs_timecode, bool is_key);
-                                  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,
+  bool AddMetadata(const uint8* frame, uint64 length, uint64 track_number,
-                   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,
+  typedef uint64 (*WriteBlock)(IMkvWriter* writer, const uint8* data,
-                               const uint8* data,
+                               uint64 length, uint64 track_number,
-                               uint64 length,
+                               int64 timecode, uint64 generic_arg);
-                               uint64 track_number,
-                               int64 timecode,
-                               uint64 generic_arg);
 
   //  Signature that matches WriteBlockWithAdditional
   //  in the muxer utilities package.
-  typedef uint64 (*WriteBlockAdditional)(IMkvWriter* writer,
+  typedef uint64 (*WriteBlockAdditional)(IMkvWriter* writer, const uint8* data,
-                                         const uint8* data,
+                                         uint64 length, const uint8* additional,
-                                         uint64 length,
-                                         const uint8* additional,
                                          uint64 add_id,
                                          uint64 additional_length,
-                                         uint64 track_number,
+                                         uint64 track_number, int64 timecode,
-                                         int64 timecode,
                                          uint64 is_key);
 
   //  Signature that matches WriteBlockWithDiscardPadding
   //  in the muxer utilities package.
   typedef uint64 (*WriteBlockDiscardPadding)(IMkvWriter* writer,
-                                             const uint8* data,
+                                             const uint8* data, uint64 length,
-                                             uint64 length,
                                              int64 discard_padding,
                                              uint64 track_number,
-                                             int64 timecode,
+                                             int64 timecode, uint64 is_key);
-                                             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,
+  bool DoWriteBlock(const uint8* frame, uint64 length, uint64 track_number,
-                    uint64 length,
+                    uint64 absolute_timecode, uint64 generic_arg,
-                    uint64 track_number,
-                    uint64 absolute_timecode,
-                    uint64 generic_arg,
                     WriteBlock write_block);
 
   // Used to implement AddFrameWithAdditional
-  bool DoWriteBlockWithAdditional(const uint8* frame,
+  bool DoWriteBlockWithAdditional(const uint8* frame, uint64 length,
-                                  uint64 length,
                                   const uint8* additional,
-                                  uint64 additional_length,
+                                  uint64 additional_length, uint64 add_id,
-                                  uint64 add_id,
+                                  uint64 track_number, uint64 absolute_timecode,
-                                  uint64 track_number,
-                                  uint64 absolute_timecode,
                                   uint64 generic_arg,
                                   WriteBlockAdditional write_block);
 
   // Used to implement AddFrameWithDiscardPadding
-  bool DoWriteBlockWithDiscardPadding(const uint8* frame,
+  bool DoWriteBlockWithDiscardPadding(const uint8* frame, uint64 length,
-                                      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 {
+  enum Mode { kLive = 0x1, kFile = 0x2 };
-    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,
+  bool AddFrame(const uint8* frame, uint64 length, uint64 track_number,
-                uint64 length,
+                uint64 timestamp_ns, bool is_key);
-                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,
+  bool AddMetadata(const uint8* frame, uint64 length, uint64 track_number,
-                   uint64 length,
+                   uint64 timestamp_ns, uint64 duration_ns);
-                   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,
+  bool AddFrameWithAdditional(const uint8* frame, uint64 length,
-                              uint64 length,
+                              const uint8* additional, uint64 additional_length,
-                              const uint8* additional,
+                              uint64 add_id, uint64 track_number,
-                              uint64 additional_length,
+                              uint64 timestamp, bool is_key);
-                              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,
+  bool AddFrameWithDiscardPadding(const uint8* frame, uint64 length,
-                                  uint64 length,
+                                  int64 discard_padding, uint64 track_number,
-                                  int64 discard_padding,
+                                  uint64 timestamp, bool is_key);
-                                  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();