diff --git a/CMakeLists.txt b/CMakeLists.txt index 0aa8c95..e1a9513 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -37,6 +37,9 @@ else () STRING "" FORCE) endif () +set(CMAKE_CXX_FLAGS "-D__STDC_CONSTANT_MACROS ${CMAKE_CXX_FLAGS}") +set(CMAKE_CXX_FLAGS "-D__STDC_LIMIT_MACROS ${CMAKE_CXX_FLAGS}") + # mkvparser section. # TODO(tomfinegan): move to mkvparser/CMakeLists.txt. add_library(mkvparser STATIC diff --git a/Makefile.unix b/Makefile.unix index 9658c19..987fe40 100644 --- a/Makefile.unix +++ b/Makefile.unix @@ -1,5 +1,5 @@ CXX := g++ -CXXFLAGS := -W -Wall -g -MMD -MP +CXXFLAGS := -W -Wall -g -MMD -MP -D__STDC_CONSTANT_MACROS -D__STDC_LIMIT_MACROS LIBWEBMA := libwebm.a LIBWEBMSO := libwebm.so WEBMOBJS := mkvmuxer.o mkvmuxerutil.o mkvwriter.o diff --git a/mkvmuxer.cpp b/mkvmuxer.cpp index 8d212fa..ba6f244 100644 --- a/mkvmuxer.cpp +++ b/mkvmuxer.cpp @@ -8,7 +8,6 @@ #include "mkvmuxer.hpp" -#define __STDC_LIMIT_MACROS #include #include @@ -34,7 +33,7 @@ namespace libwebm { namespace mkvmuxer { const float MasteringMetadata::kValueNotPresent = FLT_MAX; -const uint64 Colour::kValueNotPresent = UINT64_MAX; +const uint64_t Colour::kValueNotPresent = UINT64_MAX; namespace { // Deallocate the string designated by |dst|, and then copy the |src| @@ -88,31 +87,31 @@ IMkvWriter::IMkvWriter() {} IMkvWriter::~IMkvWriter() {} -bool WriteEbmlHeader(IMkvWriter* writer, uint64 doc_type_version) { +bool WriteEbmlHeader(IMkvWriter* writer, uint64_t doc_type_version) { // Level 0 - uint64 size = EbmlElementSize(kMkvEBMLVersion, 1ULL); - size += EbmlElementSize(kMkvEBMLReadVersion, 1ULL); - size += EbmlElementSize(kMkvEBMLMaxIDLength, 4ULL); - size += EbmlElementSize(kMkvEBMLMaxSizeLength, 8ULL); + uint64_t size = EbmlElementSize(kMkvEBMLVersion, UINT64_C(1)); + size += EbmlElementSize(kMkvEBMLReadVersion, UINT64_C(1)); + size += EbmlElementSize(kMkvEBMLMaxIDLength, UINT64_C(4)); + size += EbmlElementSize(kMkvEBMLMaxSizeLength, UINT64_C(8)); size += EbmlElementSize(kMkvDocType, "webm"); size += EbmlElementSize(kMkvDocTypeVersion, doc_type_version); - size += EbmlElementSize(kMkvDocTypeReadVersion, 2ULL); + size += EbmlElementSize(kMkvDocTypeReadVersion, UINT64_C(2)); if (!WriteEbmlMasterElement(writer, kMkvEBML, size)) return false; - if (!WriteEbmlElement(writer, kMkvEBMLVersion, 1ULL)) + if (!WriteEbmlElement(writer, kMkvEBMLVersion, UINT64_C(1))) return false; - if (!WriteEbmlElement(writer, kMkvEBMLReadVersion, 1ULL)) + if (!WriteEbmlElement(writer, kMkvEBMLReadVersion, UINT64_C(1))) return false; - if (!WriteEbmlElement(writer, kMkvEBMLMaxIDLength, 4ULL)) + if (!WriteEbmlElement(writer, kMkvEBMLMaxIDLength, UINT64_C(4))) return false; - if (!WriteEbmlElement(writer, kMkvEBMLMaxSizeLength, 8ULL)) + if (!WriteEbmlElement(writer, kMkvEBMLMaxSizeLength, UINT64_C(8))) return false; if (!WriteEbmlElement(writer, kMkvDocType, "webm")) return false; if (!WriteEbmlElement(writer, kMkvDocTypeVersion, doc_type_version)) return false; - if (!WriteEbmlElement(writer, kMkvDocTypeReadVersion, 2ULL)) + if (!WriteEbmlElement(writer, kMkvDocTypeReadVersion, UINT64_C(2))) return false; return true; @@ -123,16 +122,16 @@ bool WriteEbmlHeader(IMkvWriter* writer) { } bool ChunkedCopy(mkvparser::IMkvReader* source, mkvmuxer::IMkvWriter* dst, - int64 start, int64 size) { + int64_t start, int64_t size) { // TODO(vigneshv): Check if this is a reasonable value. - const uint32 kBufSize = 2048; - uint8* buf = new uint8[kBufSize]; - int64 offset = start; + const uint32_t kBufSize = 2048; + uint8_t* buf = new uint8_t[kBufSize]; + int64_t offset = start; while (size > 0) { - const int64 read_len = (size > kBufSize) ? kBufSize : size; + const int64_t read_len = (size > kBufSize) ? kBufSize : size; if (source->Read(offset, static_cast(read_len), buf)) return false; - dst->Write(buf, static_cast(read_len)); + dst->Write(buf, static_cast(read_len)); offset += read_len; size -= read_len; } @@ -192,9 +191,9 @@ bool Frame::CopyFrom(const Frame& frame) { return true; } -bool Frame::Init(const uint8* frame, uint64 length) { - uint8* const data = - new (std::nothrow) uint8[static_cast(length)]; // NOLINT +bool Frame::Init(const uint8_t* frame, uint64_t length) { + uint8_t* const data = + new (std::nothrow) uint8_t[static_cast(length)]; // NOLINT if (!data) return false; @@ -206,10 +205,10 @@ bool Frame::Init(const uint8* frame, uint64 length) { return true; } -bool Frame::AddAdditionalData(const uint8* additional, uint64 length, - uint64 add_id) { - uint8* const data = - new (std::nothrow) uint8[static_cast(length)]; // NOLINT +bool Frame::AddAdditionalData(const uint8_t* additional, uint64_t length, + uint64_t add_id) { + uint8_t* const data = + new (std::nothrow) uint8_t[static_cast(length)]; // NOLINT if (!data) return false; @@ -243,12 +242,12 @@ bool Frame::CanBeSimpleBlock() const { return additional_ == NULL && discard_padding_ == 0 && duration_ == 0; } -void Frame::set_duration(uint64 duration) { +void Frame::set_duration(uint64_t duration) { duration_ = duration; duration_set_ = true; } -void Frame::set_reference_block_timestamp(int64 reference_block_timestamp) { +void Frame::set_reference_block_timestamp(int64_t reference_block_timestamp) { reference_block_timestamp_ = reference_block_timestamp; reference_block_timestamp_set_ = true; } @@ -270,19 +269,19 @@ bool CuePoint::Write(IMkvWriter* writer) const { if (!writer || track_ < 1 || cluster_pos_ < 1) return false; - uint64 size = EbmlElementSize(kMkvCueClusterPosition, cluster_pos_); + uint64_t size = EbmlElementSize(kMkvCueClusterPosition, cluster_pos_); size += EbmlElementSize(kMkvCueTrack, track_); if (output_block_number_ && block_number_ > 1) size += EbmlElementSize(kMkvCueBlockNumber, block_number_); - const uint64 track_pos_size = + const uint64_t track_pos_size = EbmlMasterElementSize(kMkvCueTrackPositions, size) + size; - const uint64 payload_size = + const uint64_t payload_size = EbmlElementSize(kMkvCueTime, time_) + track_pos_size; if (!WriteEbmlMasterElement(writer, kMkvCuePoint, payload_size)) return false; - const int64 payload_position = writer->Position(); + const int64_t payload_position = writer->Position(); if (payload_position < 0) return false; @@ -299,31 +298,31 @@ bool CuePoint::Write(IMkvWriter* writer) const { if (!WriteEbmlElement(writer, kMkvCueBlockNumber, block_number_)) return false; - const int64 stop_position = writer->Position(); + const int64_t stop_position = writer->Position(); if (stop_position < 0) return false; - if (stop_position - payload_position != static_cast(payload_size)) + if (stop_position - payload_position != static_cast(payload_size)) return false; return true; } -uint64 CuePoint::PayloadSize() const { - uint64 size = EbmlElementSize(kMkvCueClusterPosition, cluster_pos_); +uint64_t CuePoint::PayloadSize() const { + uint64_t size = EbmlElementSize(kMkvCueClusterPosition, cluster_pos_); size += EbmlElementSize(kMkvCueTrack, track_); if (output_block_number_ && block_number_ > 1) size += EbmlElementSize(kMkvCueBlockNumber, block_number_); - const uint64 track_pos_size = + const uint64_t track_pos_size = EbmlMasterElementSize(kMkvCueTrackPositions, size) + size; - const uint64 payload_size = + const uint64_t payload_size = EbmlElementSize(kMkvCueTime, time_) + track_pos_size; return payload_size; } -uint64 CuePoint::Size() const { - const uint64 payload_size = PayloadSize(); +uint64_t CuePoint::Size() const { + const uint64_t payload_size = PayloadSize(); return EbmlMasterElementSize(kMkvCuePoint, payload_size) + payload_size; } @@ -339,7 +338,7 @@ Cues::Cues() Cues::~Cues() { if (cue_entries_) { - for (int32 i = 0; i < cue_entries_size_; ++i) { + for (int32_t i = 0; i < cue_entries_size_; ++i) { CuePoint* const cue = cue_entries_[i]; delete cue; } @@ -353,7 +352,7 @@ bool Cues::AddCue(CuePoint* cue) { if ((cue_entries_size_ + 1) > cue_entries_capacity_) { // Add more CuePoints. - const int32 new_capacity = + const int32_t new_capacity = (!cue_entries_capacity_) ? 2 : cue_entries_capacity_ * 2; if (new_capacity < 1) @@ -364,7 +363,7 @@ bool Cues::AddCue(CuePoint* cue) { if (!cues) return false; - for (int32 i = 0; i < cue_entries_size_; ++i) { + for (int32_t i = 0; i < cue_entries_size_; ++i) { cues[i] = cue_entries_[i]; } @@ -379,7 +378,7 @@ bool Cues::AddCue(CuePoint* cue) { return true; } -CuePoint* Cues::GetCueByIndex(int32 index) const { +CuePoint* Cues::GetCueByIndex(int32_t index) const { if (cue_entries_ == NULL) return NULL; @@ -389,9 +388,9 @@ CuePoint* Cues::GetCueByIndex(int32 index) const { return cue_entries_[index]; } -uint64 Cues::Size() { - uint64 size = 0; - for (int32 i = 0; i < cue_entries_size_; ++i) +uint64_t Cues::Size() { + uint64_t size = 0; + for (int32_t i = 0; i < cue_entries_size_; ++i) size += GetCueByIndex(i)->Size(); size += EbmlMasterElementSize(kMkvCues, size); return size; @@ -401,8 +400,8 @@ bool Cues::Write(IMkvWriter* writer) const { if (!writer) return false; - uint64 size = 0; - for (int32 i = 0; i < cue_entries_size_; ++i) { + uint64_t size = 0; + for (int32_t i = 0; i < cue_entries_size_; ++i) { const CuePoint* const cue = GetCueByIndex(i); if (!cue) @@ -414,22 +413,22 @@ bool Cues::Write(IMkvWriter* writer) const { if (!WriteEbmlMasterElement(writer, kMkvCues, size)) return false; - const int64 payload_position = writer->Position(); + const int64_t payload_position = writer->Position(); if (payload_position < 0) return false; - for (int32 i = 0; i < cue_entries_size_; ++i) { + for (int32_t i = 0; i < cue_entries_size_; ++i) { const CuePoint* const cue = GetCueByIndex(i); if (!cue->Write(writer)) return false; } - const int64 stop_position = writer->Position(); + const int64_t stop_position = writer->Position(); if (stop_position < 0) return false; - if (stop_position - payload_position != static_cast(size)) + if (stop_position - payload_position != static_cast(size)) return false; return true; @@ -441,36 +440,36 @@ bool Cues::Write(IMkvWriter* writer) const { ContentEncAESSettings::ContentEncAESSettings() : cipher_mode_(kCTR) {} -uint64 ContentEncAESSettings::Size() const { - const uint64 payload = PayloadSize(); - const uint64 size = +uint64_t ContentEncAESSettings::Size() const { + const uint64_t payload = PayloadSize(); + const uint64_t size = EbmlMasterElementSize(kMkvContentEncAESSettings, payload) + payload; return size; } bool ContentEncAESSettings::Write(IMkvWriter* writer) const { - const uint64 payload = PayloadSize(); + const uint64_t payload = PayloadSize(); if (!WriteEbmlMasterElement(writer, kMkvContentEncAESSettings, payload)) return false; - const int64 payload_position = writer->Position(); + const int64_t payload_position = writer->Position(); if (payload_position < 0) return false; if (!WriteEbmlElement(writer, kMkvAESSettingsCipherMode, cipher_mode_)) return false; - const int64 stop_position = writer->Position(); + const int64_t stop_position = writer->Position(); if (stop_position < 0 || - stop_position - payload_position != static_cast(payload)) + stop_position - payload_position != static_cast(payload)) return false; return true; } -uint64 ContentEncAESSettings::PayloadSize() const { - uint64 size = EbmlElementSize(kMkvAESSettingsCipherMode, cipher_mode_); +uint64_t ContentEncAESSettings::PayloadSize() const { + uint64_t size = EbmlElementSize(kMkvAESSettingsCipherMode, cipher_mode_); return size; } @@ -488,14 +487,14 @@ ContentEncoding::ContentEncoding() ContentEncoding::~ContentEncoding() { delete[] enc_key_id_; } -bool ContentEncoding::SetEncryptionID(const uint8* id, uint64 length) { +bool ContentEncoding::SetEncryptionID(const uint8_t* id, uint64_t length) { if (!id || length < 1) return false; delete[] enc_key_id_; enc_key_id_ = - new (std::nothrow) uint8[static_cast(length)]; // NOLINT + new (std::nothrow) uint8_t[static_cast(length)]; // NOLINT if (!enc_key_id_) return false; @@ -505,22 +504,22 @@ bool ContentEncoding::SetEncryptionID(const uint8* id, uint64 length) { return true; } -uint64 ContentEncoding::Size() const { - const uint64 encryption_size = EncryptionSize(); - const uint64 encoding_size = EncodingSize(0, encryption_size); - const uint64 encodings_size = +uint64_t ContentEncoding::Size() const { + const uint64_t encryption_size = EncryptionSize(); + const uint64_t encoding_size = EncodingSize(0, encryption_size); + const uint64_t encodings_size = EbmlMasterElementSize(kMkvContentEncoding, encoding_size) + encoding_size; return encodings_size; } bool ContentEncoding::Write(IMkvWriter* writer) const { - const uint64 encryption_size = EncryptionSize(); - const uint64 encoding_size = EncodingSize(0, encryption_size); - const uint64 size = + const uint64_t encryption_size = EncryptionSize(); + const uint64_t encoding_size = EncodingSize(0, encryption_size); + const uint64_t size = EbmlMasterElementSize(kMkvContentEncoding, encoding_size) + encoding_size; - const int64 payload_position = writer->Position(); + const int64_t payload_position = writer->Position(); if (payload_position < 0) return false; @@ -544,21 +543,21 @@ bool ContentEncoding::Write(IMkvWriter* writer) const { if (!enc_aes_settings_.Write(writer)) return false; - const int64 stop_position = writer->Position(); + const int64_t stop_position = writer->Position(); if (stop_position < 0 || - stop_position - payload_position != static_cast(size)) + stop_position - payload_position != static_cast(size)) return false; return true; } -uint64 ContentEncoding::EncodingSize(uint64 compresion_size, - uint64 encryption_size) const { +uint64_t ContentEncoding::EncodingSize(uint64_t compresion_size, + uint64_t encryption_size) const { // TODO(fgalligan): Add support for compression settings. if (compresion_size != 0) return 0; - uint64 encoding_size = 0; + uint64_t encoding_size = 0; if (encryption_size > 0) { encoding_size += @@ -572,10 +571,10 @@ uint64 ContentEncoding::EncodingSize(uint64 compresion_size, return encoding_size; } -uint64 ContentEncoding::EncryptionSize() const { - const uint64 aes_size = enc_aes_settings_.Size(); +uint64_t ContentEncoding::EncryptionSize() const { + const uint64_t aes_size = enc_aes_settings_.Size(); - uint64 encryption_size = + uint64_t encryption_size = EbmlElementSize(kMkvContentEncKeyID, enc_key_id_, enc_key_id_length_); encryption_size += EbmlElementSize(kMkvContentEncAlgo, enc_algo_); @@ -609,7 +608,7 @@ Track::~Track() { delete[] name_; if (content_encoding_entries_) { - for (uint32 i = 0; i < content_encoding_entries_size_; ++i) { + for (uint32_t i = 0; i < content_encoding_entries_size_; ++i) { ContentEncoding* const encoding = content_encoding_entries_[i]; delete encoding; } @@ -618,7 +617,7 @@ Track::~Track() { } bool Track::AddContentEncoding() { - const uint32 count = content_encoding_entries_size_ + 1; + const uint32_t count = content_encoding_entries_size_ + 1; ContentEncoding** const content_encoding_entries = new (std::nothrow) ContentEncoding*[count]; // NOLINT @@ -632,7 +631,7 @@ bool Track::AddContentEncoding() { return false; } - for (uint32 i = 0; i < content_encoding_entries_size_; ++i) { + for (uint32_t i = 0; i < content_encoding_entries_size_; ++i) { content_encoding_entries[i] = content_encoding_entries_[i]; } @@ -644,7 +643,7 @@ bool Track::AddContentEncoding() { return true; } -ContentEncoding* Track::GetContentEncodingByIndex(uint32 index) const { +ContentEncoding* Track::GetContentEncodingByIndex(uint32_t index) const { if (content_encoding_entries_ == NULL) return NULL; @@ -654,8 +653,8 @@ ContentEncoding* Track::GetContentEncodingByIndex(uint32 index) const { return content_encoding_entries_[index]; } -uint64 Track::PayloadSize() const { - uint64 size = EbmlElementSize(kMkvTrackNumber, number_); +uint64_t Track::PayloadSize() const { + uint64_t size = EbmlElementSize(kMkvTrackNumber, number_); size += EbmlElementSize(kMkvTrackUID, uid_); size += EbmlElementSize(kMkvTrackType, type_); if (codec_id_) @@ -677,8 +676,8 @@ uint64 Track::PayloadSize() const { size += EbmlElementSize(kMkvDefaultDuration, default_duration_); if (content_encoding_entries_size_ > 0) { - uint64 content_encodings_size = 0; - for (uint32 i = 0; i < content_encoding_entries_size_; ++i) { + uint64_t content_encodings_size = 0; + for (uint32_t i = 0; i < content_encoding_entries_size_; ++i) { ContentEncoding* const encoding = content_encoding_entries_[i]; content_encodings_size += encoding->Size(); } @@ -691,8 +690,8 @@ uint64 Track::PayloadSize() const { return size; } -uint64 Track::Size() const { - uint64 size = PayloadSize(); +uint64_t Track::Size() const { + uint64_t size = PayloadSize(); size += EbmlMasterElementSize(kMkvTrackEntry, size); return size; } @@ -707,12 +706,12 @@ bool Track::Write(IMkvWriter* writer) const { // |size| may be bigger than what is written out in this function because // derived classes may write out more data in the Track element. - const uint64 payload_size = PayloadSize(); + const uint64_t payload_size = PayloadSize(); if (!WriteEbmlMasterElement(writer, kMkvTrackEntry, payload_size)) return false; - uint64 size = EbmlElementSize(kMkvTrackNumber, number_); + uint64_t size = EbmlElementSize(kMkvTrackNumber, number_); size += EbmlElementSize(kMkvTrackUID, uid_); size += EbmlElementSize(kMkvTrackType, type_); if (codec_id_) @@ -733,7 +732,7 @@ bool Track::Write(IMkvWriter* writer) const { if (default_duration_) size += EbmlElementSize(kMkvDefaultDuration, default_duration_); - const int64 payload_position = writer->Position(); + const int64_t payload_position = writer->Position(); if (payload_position < 0) return false; @@ -779,14 +778,14 @@ bool Track::Write(IMkvWriter* writer) const { return false; } - int64 stop_position = writer->Position(); + int64_t stop_position = writer->Position(); if (stop_position < 0 || - stop_position - payload_position != static_cast(size)) + stop_position - payload_position != static_cast(size)) return false; if (content_encoding_entries_size_ > 0) { - uint64 content_encodings_size = 0; - for (uint32 i = 0; i < content_encoding_entries_size_; ++i) { + uint64_t content_encodings_size = 0; + for (uint32_t i = 0; i < content_encoding_entries_size_; ++i) { ContentEncoding* const encoding = content_encoding_entries_[i]; content_encodings_size += encoding->Size(); } @@ -795,7 +794,7 @@ bool Track::Write(IMkvWriter* writer) const { content_encodings_size)) return false; - for (uint32 i = 0; i < content_encoding_entries_size_; ++i) { + for (uint32_t i = 0; i < content_encoding_entries_size_; ++i) { ContentEncoding* const encoding = content_encoding_entries_[i]; if (!encoding->Write(writer)) return false; @@ -808,14 +807,14 @@ bool Track::Write(IMkvWriter* writer) const { return true; } -bool Track::SetCodecPrivate(const uint8* codec_private, uint64 length) { +bool Track::SetCodecPrivate(const uint8_t* codec_private, uint64_t length) { if (!codec_private || length < 1) return false; delete[] codec_private_; codec_private_ = - new (std::nothrow) uint8[static_cast(length)]; // NOLINT + new (std::nothrow) uint8_t[static_cast(length)]; // NOLINT if (!codec_private_) return false; @@ -878,8 +877,8 @@ void Track::set_name(const char* name) { // // Colour and its child elements -uint64 PrimaryChromaticity::PrimaryChromaticityPayloadSize(MkvId x_id, - MkvId y_id) const { +uint64_t PrimaryChromaticity::PrimaryChromaticityPayloadSize(MkvId x_id, + MkvId y_id) const { return EbmlElementSize(x_id, x) + EbmlElementSize(y_id, y); } @@ -888,8 +887,8 @@ bool PrimaryChromaticity::Write(IMkvWriter* writer, MkvId x_id, return WriteEbmlElement(writer, x_id, x) && WriteEbmlElement(writer, y_id, y); } -uint64 MasteringMetadata::MasteringMetadataSize() const { - uint64 size = PayloadSize(); +uint64_t MasteringMetadata::MasteringMetadataSize() const { + uint64_t size = PayloadSize(); if (size > 0) size += EbmlMasterElementSize(kMkvMasteringMetadata, size); @@ -898,7 +897,7 @@ uint64 MasteringMetadata::MasteringMetadataSize() const { } bool MasteringMetadata::Write(IMkvWriter* writer) const { - const uint64 size = PayloadSize(); + const uint64_t size = PayloadSize(); // Don't write an empty element. if (size == 0) @@ -969,8 +968,8 @@ bool MasteringMetadata::SetChromaticity( return true; } -uint64 MasteringMetadata::PayloadSize() const { - uint64 size = 0; +uint64_t MasteringMetadata::PayloadSize() const { + uint64_t size = 0; if (luminance_max != kValueNotPresent) size += EbmlElementSize(kMkvLuminanceMax, luminance_max); @@ -997,8 +996,8 @@ uint64 MasteringMetadata::PayloadSize() const { return size; } -uint64 Colour::ColourSize() const { - uint64 size = PayloadSize(); +uint64_t Colour::ColourSize() const { + uint64_t size = PayloadSize(); if (size > 0) size += EbmlMasterElementSize(kMkvColour, size); @@ -1007,7 +1006,7 @@ uint64 Colour::ColourSize() const { } bool Colour::Write(IMkvWriter* writer) const { - const uint64 size = PayloadSize(); + const uint64_t size = PayloadSize(); // Don't write an empty element. if (size == 0) @@ -1098,8 +1097,8 @@ bool Colour::SetMasteringMetadata(const MasteringMetadata& mastering_metadata) { return true; } -uint64 Colour::PayloadSize() const { - uint64 size = 0; +uint64_t Colour::PayloadSize() const { + uint64_t size = 0; if (matrix_coefficients != kValueNotPresent) size += EbmlElementSize(kMkvMatrixCoefficients, matrix_coefficients); @@ -1156,7 +1155,7 @@ VideoTrack::VideoTrack(unsigned int* seed) VideoTrack::~VideoTrack() { delete colour_; } -bool VideoTrack::SetStereoMode(uint64 stereo_mode) { +bool VideoTrack::SetStereoMode(uint64_t stereo_mode) { if (stereo_mode != kMono && stereo_mode != kSideBySideLeftIsFirst && stereo_mode != kTopBottomRightIsFirst && stereo_mode != kTopBottomLeftIsFirst && @@ -1167,7 +1166,7 @@ bool VideoTrack::SetStereoMode(uint64 stereo_mode) { return true; } -bool VideoTrack::SetAlphaMode(uint64 alpha_mode) { +bool VideoTrack::SetAlphaMode(uint64_t alpha_mode) { if (alpha_mode != kNoAlpha && alpha_mode != kAlpha) return false; @@ -1175,10 +1174,10 @@ bool VideoTrack::SetAlphaMode(uint64 alpha_mode) { return true; } -uint64 VideoTrack::PayloadSize() const { - const uint64 parent_size = Track::PayloadSize(); +uint64_t VideoTrack::PayloadSize() const { + const uint64_t parent_size = Track::PayloadSize(); - uint64 size = VideoPayloadSize(); + uint64_t size = VideoPayloadSize(); size += EbmlMasterElementSize(kMkvVideo, size); return parent_size + size; @@ -1188,12 +1187,12 @@ bool VideoTrack::Write(IMkvWriter* writer) const { if (!Track::Write(writer)) return false; - const uint64 size = VideoPayloadSize(); + const uint64_t size = VideoPayloadSize(); if (!WriteEbmlMasterElement(writer, kMkvVideo, size)) return false; - const int64 payload_position = writer->Position(); + const int64_t payload_position = writer->Position(); if (payload_position < 0) return false; @@ -1244,9 +1243,9 @@ bool VideoTrack::Write(IMkvWriter* writer) const { return false; } - const int64 stop_position = writer->Position(); + const int64_t stop_position = writer->Position(); if (stop_position < 0 || - stop_position - payload_position != static_cast(size)) { + stop_position - payload_position != static_cast(size)) { return false; } @@ -1280,8 +1279,8 @@ bool VideoTrack::SetColour(const Colour& colour) { return true; } -uint64 VideoTrack::VideoPayloadSize() const { - uint64 size = EbmlElementSize(kMkvPixelWidth, width_); +uint64_t VideoTrack::VideoPayloadSize() const { + uint64_t size = EbmlElementSize(kMkvPixelWidth, width_); size += EbmlElementSize(kMkvPixelHeight, height_); if (display_width_ > 0) size += EbmlElementSize(kMkvDisplayWidth, display_width_); @@ -1316,10 +1315,10 @@ AudioTrack::AudioTrack(unsigned int* seed) AudioTrack::~AudioTrack() {} -uint64 AudioTrack::PayloadSize() const { - const uint64 parent_size = Track::PayloadSize(); +uint64_t AudioTrack::PayloadSize() const { + const uint64_t parent_size = Track::PayloadSize(); - uint64 size = + uint64_t size = EbmlElementSize(kMkvSamplingFrequency, static_cast(sample_rate_)); size += EbmlElementSize(kMkvChannels, channels_); if (bit_depth_ > 0) @@ -1334,7 +1333,7 @@ bool AudioTrack::Write(IMkvWriter* writer) const { return false; // Calculate AudioSettings size. - uint64 size = + uint64_t size = EbmlElementSize(kMkvSamplingFrequency, static_cast(sample_rate_)); size += EbmlElementSize(kMkvChannels, channels_); if (bit_depth_ > 0) @@ -1343,7 +1342,7 @@ bool AudioTrack::Write(IMkvWriter* writer) const { if (!WriteEbmlMasterElement(writer, kMkvAudio, size)) return false; - const int64 payload_position = writer->Position(); + const int64_t payload_position = writer->Position(); if (payload_position < 0) return false; @@ -1356,9 +1355,9 @@ bool AudioTrack::Write(IMkvWriter* writer) const { if (!WriteEbmlElement(writer, kMkvBitDepth, bit_depth_)) return false; - const int64 stop_position = writer->Position(); + const int64_t stop_position = writer->Position(); if (stop_position < 0 || - stop_position - payload_position != static_cast(size)) + stop_position - payload_position != static_cast(size)) return false; return true; @@ -1379,7 +1378,7 @@ Tracks::Tracks() Tracks::~Tracks() { if (track_entries_) { - for (uint32 i = 0; i < track_entries_size_; ++i) { + for (uint32_t i = 0; i < track_entries_size_; ++i) { Track* const track = track_entries_[i]; delete track; } @@ -1387,7 +1386,7 @@ Tracks::~Tracks() { } } -bool Tracks::AddTrack(Track* track, int32 number) { +bool Tracks::AddTrack(Track* track, int32_t number) { if (number < 0 || wrote_tracks_) return false; @@ -1399,23 +1398,23 @@ bool Tracks::AddTrack(Track* track, int32 number) { if (number > 0x7E) return false; - uint32 track_num = number; + uint32_t track_num = number; if (track_num > 0) { // Check to make sure a track does not already have |track_num|. - for (uint32 i = 0; i < track_entries_size_; ++i) { + for (uint32_t i = 0; i < track_entries_size_; ++i) { if (track_entries_[i]->number() == track_num) return false; } } - const uint32 count = track_entries_size_ + 1; + const uint32_t count = track_entries_size_ + 1; Track** const track_entries = new (std::nothrow) Track*[count]; // NOLINT if (!track_entries) return false; - for (uint32 i = 0; i < track_entries_size_; ++i) { + for (uint32_t i = 0; i < track_entries_size_; ++i) { track_entries[i] = track_entries_[i]; } @@ -1429,7 +1428,7 @@ bool Tracks::AddTrack(Track* track, int32 number) { bool exit = false; do { exit = true; - for (uint32 i = 0; i < track_entries_size_; ++i) { + for (uint32_t i = 0; i < track_entries_size_; ++i) { if (track_entries[i]->number() == track_num) { track_num++; exit = false; @@ -1446,7 +1445,7 @@ bool Tracks::AddTrack(Track* track, int32 number) { return true; } -const Track* Tracks::GetTrackByIndex(uint32 index) const { +const Track* Tracks::GetTrackByIndex(uint32_t index) const { if (track_entries_ == NULL) return NULL; @@ -1456,9 +1455,9 @@ const Track* Tracks::GetTrackByIndex(uint32 index) const { return track_entries_[index]; } -Track* Tracks::GetTrackByNumber(uint64 track_number) const { - const int32 count = track_entries_size(); - for (int32 i = 0; i < count; ++i) { +Track* Tracks::GetTrackByNumber(uint64_t track_number) const { + const int32_t count = track_entries_size(); + for (int32_t i = 0; i < count; ++i) { if (track_entries_[i]->number() == track_number) return track_entries_[i]; } @@ -1466,7 +1465,7 @@ Track* Tracks::GetTrackByNumber(uint64 track_number) const { return NULL; } -bool Tracks::TrackIsAudio(uint64 track_number) const { +bool Tracks::TrackIsAudio(uint64_t track_number) const { const Track* const track = GetTrackByNumber(track_number); if (track->type() == kAudio) @@ -1475,7 +1474,7 @@ bool Tracks::TrackIsAudio(uint64 track_number) const { return false; } -bool Tracks::TrackIsVideo(uint64 track_number) const { +bool Tracks::TrackIsVideo(uint64_t track_number) const { const Track* const track = GetTrackByNumber(track_number); if (track->type() == kVideo) @@ -1485,9 +1484,9 @@ bool Tracks::TrackIsVideo(uint64 track_number) const { } bool Tracks::Write(IMkvWriter* writer) const { - uint64 size = 0; - const int32 count = track_entries_size(); - for (int32 i = 0; i < count; ++i) { + uint64_t size = 0; + const int32_t count = track_entries_size(); + for (int32_t i = 0; i < count; ++i) { const Track* const track = GetTrackByIndex(i); if (!track) @@ -1499,19 +1498,19 @@ bool Tracks::Write(IMkvWriter* writer) const { if (!WriteEbmlMasterElement(writer, kMkvTracks, size)) return false; - const int64 payload_position = writer->Position(); + const int64_t payload_position = writer->Position(); if (payload_position < 0) return false; - for (int32 i = 0; i < count; ++i) { + for (int32_t i = 0; i < count; ++i) { const Track* const track = GetTrackByIndex(i); if (!track->Write(writer)) return false; } - const int64 stop_position = writer->Position(); + const int64_t stop_position = writer->Position(); if (stop_position < 0 || - stop_position - payload_position != static_cast(size)) + stop_position - payload_position != static_cast(size)) return false; wrote_tracks_ = true; @@ -1524,9 +1523,10 @@ bool Tracks::Write(IMkvWriter* writer) const { 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_t start_ns, + uint64_t end_ns) { const SegmentInfo* const info = segment.GetSegmentInfo(); - const uint64 timecode_scale = info->timecode_scale(); + const uint64_t timecode_scale = info->timecode_scale(); start_timecode_ = start_ns / timecode_scale; end_timecode_ = end_ns / timecode_scale; } @@ -1621,24 +1621,25 @@ bool Chapter::ExpandDisplaysArray() { return true; } -uint64 Chapter::WriteAtom(IMkvWriter* writer) const { - uint64 payload_size = EbmlElementSize(kMkvChapterStringUID, id_) + - EbmlElementSize(kMkvChapterUID, uid_) + - EbmlElementSize(kMkvChapterTimeStart, start_timecode_) + - EbmlElementSize(kMkvChapterTimeEnd, end_timecode_); +uint64_t Chapter::WriteAtom(IMkvWriter* writer) const { + uint64_t payload_size = + EbmlElementSize(kMkvChapterStringUID, id_) + + EbmlElementSize(kMkvChapterUID, uid_) + + EbmlElementSize(kMkvChapterTimeStart, start_timecode_) + + EbmlElementSize(kMkvChapterTimeEnd, end_timecode_); for (int idx = 0; idx < displays_count_; ++idx) { const Display& d = displays_[idx]; payload_size += d.WriteDisplay(NULL); } - const uint64 atom_size = + const uint64_t atom_size = EbmlMasterElementSize(kMkvChapterAtom, payload_size) + payload_size; if (writer == NULL) return atom_size; - const int64 start = writer->Position(); + const int64_t start = writer->Position(); if (!WriteEbmlMasterElement(writer, kMkvChapterAtom, payload_size)) return 0; @@ -1662,9 +1663,9 @@ uint64 Chapter::WriteAtom(IMkvWriter* writer) const { return 0; } - const int64 stop = writer->Position(); + const int64_t stop = writer->Position(); - if (stop >= start && uint64(stop - start) != atom_size) + if (stop >= start && uint64_t(stop - start) != atom_size) return 0; return atom_size; @@ -1694,8 +1695,8 @@ bool Chapter::Display::set_country(const char* country) { return StrCpy(country, &country_); } -uint64 Chapter::Display::WriteDisplay(IMkvWriter* writer) const { - uint64 payload_size = EbmlElementSize(kMkvChapString, title_); +uint64_t Chapter::Display::WriteDisplay(IMkvWriter* writer) const { + uint64_t payload_size = EbmlElementSize(kMkvChapString, title_); if (language_) payload_size += EbmlElementSize(kMkvChapLanguage, language_); @@ -1703,13 +1704,13 @@ uint64 Chapter::Display::WriteDisplay(IMkvWriter* writer) const { if (country_) payload_size += EbmlElementSize(kMkvChapCountry, country_); - const uint64 display_size = + const uint64_t display_size = EbmlMasterElementSize(kMkvChapterDisplay, payload_size) + payload_size; if (writer == NULL) return display_size; - const int64 start = writer->Position(); + const int64_t start = writer->Position(); if (!WriteEbmlMasterElement(writer, kMkvChapterDisplay, payload_size)) return 0; @@ -1727,9 +1728,9 @@ uint64 Chapter::Display::WriteDisplay(IMkvWriter* writer) const { return 0; } - const int64 stop = writer->Position(); + const int64_t stop = writer->Position(); - if (stop >= start && uint64(stop - start) != display_size) + if (stop >= start && uint64_t(stop - start) != display_size) return 0; return display_size; @@ -1767,19 +1768,19 @@ bool Chapters::Write(IMkvWriter* writer) const { if (writer == NULL) return false; - const uint64 payload_size = WriteEdition(NULL); // return size only + const uint64_t payload_size = WriteEdition(NULL); // return size only if (!WriteEbmlMasterElement(writer, kMkvChapters, payload_size)) return false; - const int64 start = writer->Position(); + const int64_t start = writer->Position(); if (WriteEdition(writer) == 0) // error return false; - const int64 stop = writer->Position(); + const int64_t stop = writer->Position(); - if (stop >= start && uint64(stop - start) != payload_size) + if (stop >= start && uint64_t(stop - start) != payload_size) return false; return true; @@ -1809,21 +1810,21 @@ bool Chapters::ExpandChaptersArray() { return true; } -uint64 Chapters::WriteEdition(IMkvWriter* writer) const { - uint64 payload_size = 0; +uint64_t Chapters::WriteEdition(IMkvWriter* writer) const { + uint64_t payload_size = 0; for (int idx = 0; idx < chapters_count_; ++idx) { const Chapter& chapter = chapters_[idx]; payload_size += chapter.WriteAtom(NULL); } - const uint64 edition_size = + const uint64_t edition_size = EbmlMasterElementSize(kMkvEditionEntry, payload_size) + payload_size; if (writer == NULL) // return size only return edition_size; - const int64 start = writer->Position(); + const int64_t start = writer->Position(); if (!WriteEbmlMasterElement(writer, kMkvEditionEntry, payload_size)) return 0; // error @@ -1831,14 +1832,14 @@ uint64 Chapters::WriteEdition(IMkvWriter* writer) const { for (int idx = 0; idx < chapters_count_; ++idx) { const Chapter& chapter = chapters_[idx]; - const uint64 chapter_size = chapter.WriteAtom(writer); + const uint64_t chapter_size = chapter.WriteAtom(writer); if (chapter_size == 0) // error return 0; } - const int64 stop = writer->Position(); + const int64_t stop = writer->Position(); - if (stop >= start && uint64(stop - start) != edition_size) + if (stop >= start && uint64_t(stop - start) != edition_size) return 0; return edition_size; @@ -1910,21 +1911,21 @@ bool Tag::ExpandSimpleTagsArray() { return true; } -uint64 Tag::Write(IMkvWriter* writer) const { - uint64 payload_size = 0; +uint64_t Tag::Write(IMkvWriter* writer) const { + uint64_t payload_size = 0; for (int idx = 0; idx < simple_tags_count_; ++idx) { const SimpleTag& st = simple_tags_[idx]; payload_size += st.Write(NULL); } - const uint64 tag_size = + const uint64_t tag_size = EbmlMasterElementSize(kMkvTag, payload_size) + payload_size; if (writer == NULL) return tag_size; - const int64 start = writer->Position(); + const int64_t start = writer->Position(); if (!WriteEbmlMasterElement(writer, kMkvTag, payload_size)) return 0; @@ -1936,9 +1937,9 @@ uint64 Tag::Write(IMkvWriter* writer) const { return 0; } - const int64 stop = writer->Position(); + const int64_t stop = writer->Position(); - if (stop >= start && uint64(stop - start) != tag_size) + if (stop >= start && uint64_t(stop - start) != tag_size) return 0; return tag_size; @@ -1964,18 +1965,18 @@ bool Tag::SimpleTag::set_tag_string(const char* tag_string) { return StrCpy(tag_string, &tag_string_); } -uint64 Tag::SimpleTag::Write(IMkvWriter* writer) const { - uint64 payload_size = EbmlElementSize(kMkvTagName, tag_name_); +uint64_t Tag::SimpleTag::Write(IMkvWriter* writer) const { + uint64_t payload_size = EbmlElementSize(kMkvTagName, tag_name_); payload_size += EbmlElementSize(kMkvTagString, tag_string_); - const uint64 simple_tag_size = + const uint64_t simple_tag_size = EbmlMasterElementSize(kMkvSimpleTag, payload_size) + payload_size; if (writer == NULL) return simple_tag_size; - const int64 start = writer->Position(); + const int64_t start = writer->Position(); if (!WriteEbmlMasterElement(writer, kMkvSimpleTag, payload_size)) return 0; @@ -1986,9 +1987,9 @@ uint64 Tag::SimpleTag::Write(IMkvWriter* writer) const { if (!WriteEbmlElement(writer, kMkvTagString, tag_string_)) return 0; - const int64 stop = writer->Position(); + const int64_t stop = writer->Position(); - if (stop >= start && uint64(stop - start) != simple_tag_size) + if (stop >= start && uint64_t(stop - start) != simple_tag_size) return 0; return simple_tag_size; @@ -2023,7 +2024,7 @@ bool Tags::Write(IMkvWriter* writer) const { if (writer == NULL) return false; - uint64 payload_size = 0; + uint64_t payload_size = 0; for (int idx = 0; idx < tags_count_; ++idx) { const Tag& tag = tags_[idx]; @@ -2033,19 +2034,19 @@ bool Tags::Write(IMkvWriter* writer) const { if (!WriteEbmlMasterElement(writer, kMkvTags, payload_size)) return false; - const int64 start = writer->Position(); + const int64_t start = writer->Position(); for (int idx = 0; idx < tags_count_; ++idx) { const Tag& tag = tags_[idx]; - const uint64 tag_size = tag.Write(writer); + const uint64_t tag_size = tag.Write(writer); if (tag_size == 0) // error return 0; } - const int64 stop = writer->Position(); + const int64_t stop = writer->Position(); - if (stop >= start && uint64(stop - start) != payload_size) + if (stop >= start && uint64_t(stop - start) != payload_size) return false; return true; @@ -2079,7 +2080,7 @@ bool Tags::ExpandTagsArray() { // // Cluster class -Cluster::Cluster(uint64 timecode, int64 cues_pos, uint64 timecode_scale, +Cluster::Cluster(uint64_t timecode, int64_t cues_pos, uint64_t timecode_scale, bool write_last_frame_with_duration) : blocks_added_(0), finalized_(false), @@ -2106,8 +2107,9 @@ bool Cluster::AddFrame(const Frame* const frame) { return QueueOrWriteFrame(frame); } -bool Cluster::AddFrame(const uint8* data, uint64 length, uint64 track_number, - uint64 abs_timecode, bool is_key) { +bool Cluster::AddFrame(const uint8_t* data, uint64_t length, + uint64_t track_number, uint64_t abs_timecode, + bool is_key) { Frame frame; if (!frame.Init(data, length)) return false; @@ -2117,11 +2119,11 @@ bool Cluster::AddFrame(const uint8* data, uint64 length, uint64 track_number, return QueueOrWriteFrame(&frame); } -bool Cluster::AddFrameWithAdditional(const uint8* data, uint64 length, - const uint8* additional, - uint64 additional_length, uint64 add_id, - uint64 track_number, uint64 abs_timecode, - bool is_key) { +bool Cluster::AddFrameWithAdditional(const uint8_t* data, uint64_t length, + const uint8_t* additional, + uint64_t additional_length, + uint64_t add_id, uint64_t track_number, + uint64_t abs_timecode, bool is_key) { if (!additional || additional_length == 0) { return false; } @@ -2136,10 +2138,10 @@ bool Cluster::AddFrameWithAdditional(const uint8* data, uint64 length, return QueueOrWriteFrame(&frame); } -bool Cluster::AddFrameWithDiscardPadding(const uint8* data, uint64 length, - int64 discard_padding, - uint64 track_number, - uint64 abs_timecode, bool is_key) { +bool Cluster::AddFrameWithDiscardPadding(const uint8_t* data, uint64_t length, + int64_t discard_padding, + uint64_t track_number, + uint64_t abs_timecode, bool is_key) { Frame frame; if (!frame.Init(data, length)) return false; @@ -2150,8 +2152,9 @@ bool Cluster::AddFrameWithDiscardPadding(const uint8* data, uint64 length, return QueueOrWriteFrame(&frame); } -bool Cluster::AddMetadata(const uint8* data, uint64 length, uint64 track_number, - uint64 abs_timecode, uint64 duration_timecode) { +bool Cluster::AddMetadata(const uint8_t* data, uint64_t length, + uint64_t track_number, uint64_t abs_timecode, + uint64_t duration_timecode) { Frame frame; if (!frame.Init(data, length)) return false; @@ -2162,13 +2165,13 @@ bool Cluster::AddMetadata(const uint8* data, uint64 length, uint64 track_number, return QueueOrWriteFrame(&frame); } -void Cluster::AddPayloadSize(uint64 size) { payload_size_ += size; } +void Cluster::AddPayloadSize(uint64_t size) { payload_size_ += size; } bool Cluster::Finalize() { return !write_last_frame_with_duration_ && Finalize(false, 0); } -bool Cluster::Finalize(bool set_last_frame_duration, uint64 duration) { +bool Cluster::Finalize(bool set_last_frame_duration, uint64_t duration) { if (!writer_ || finalized_) return false; @@ -2214,7 +2217,7 @@ bool Cluster::Finalize(bool set_last_frame_duration, uint64 duration) { return false; if (writer_->Seekable()) { - const int64 pos = writer_->Position(); + const int64_t pos = writer_->Position(); if (writer_->Position(size_position_)) return false; @@ -2231,8 +2234,8 @@ bool Cluster::Finalize(bool set_last_frame_duration, uint64 duration) { return true; } -uint64 Cluster::Size() const { - const uint64 element_size = +uint64_t Cluster::Size() const { + const uint64_t element_size = EbmlMasterElementSize(kMkvCluster, 0xFFFFFFFFFFFFFFFFULL) + payload_size_; return element_size; } @@ -2249,15 +2252,15 @@ bool Cluster::PreWriteBlock() { return true; } -void Cluster::PostWriteBlock(uint64 element_size) { +void Cluster::PostWriteBlock(uint64_t element_size) { AddPayloadSize(element_size); ++blocks_added_; } -int64 Cluster::GetRelativeTimecode(int64 abs_timecode) const { - const int64 cluster_timecode = this->Cluster::timecode(); - const int64 rel_timecode = - static_cast(abs_timecode) - cluster_timecode; +int64_t Cluster::GetRelativeTimecode(int64_t abs_timecode) const { + const int64_t cluster_timecode = this->Cluster::timecode(); + const int64_t rel_timecode = + static_cast(abs_timecode) - cluster_timecode; if (rel_timecode < 0 || rel_timecode > kMaxBlockTimecode) return -1; @@ -2272,7 +2275,7 @@ bool Cluster::DoWriteFrame(const Frame* const frame) { if (!PreWriteBlock()) return false; - const uint64 element_size = WriteFrame(writer_, frame, this); + const uint64_t element_size = WriteFrame(writer_, frame, this); if (element_size == 0) return false; @@ -2292,7 +2295,7 @@ bool Cluster::QueueOrWriteFrame(const Frame* const frame) { } // Queue the current frame. - uint64 track_number = frame->track_number(); + uint64_t track_number = frame->track_number(); Frame* const frame_to_store = new Frame(); frame_to_store->CopyFrom(*frame); stored_frames_[track_number].push_back(frame_to_store); @@ -2364,7 +2367,7 @@ bool Cluster::WriteClusterHeader() { // SeekHead Class SeekHead::SeekHead() : start_pos_(0ULL) { - for (int32 i = 0; i < kSeekEntryCount; ++i) { + for (int32_t i = 0; i < kSeekEntryCount; ++i) { seek_entry_id_[i] = 0; seek_entry_pos_[i] = 0; } @@ -2377,13 +2380,13 @@ bool SeekHead::Finalize(IMkvWriter* writer) const { if (start_pos_ == -1) return false; - uint64 payload_size = 0; - uint64 entry_size[kSeekEntryCount]; + uint64_t payload_size = 0; + uint64_t entry_size[kSeekEntryCount]; - for (int32 i = 0; i < kSeekEntryCount; ++i) { + for (int32_t i = 0; i < kSeekEntryCount; ++i) { if (seek_entry_id_[i] != 0) { - entry_size[i] = - EbmlElementSize(kMkvSeekID, static_cast(seek_entry_id_[i])); + entry_size[i] = EbmlElementSize( + kMkvSeekID, static_cast(seek_entry_id_[i])); entry_size[i] += EbmlElementSize(kMkvSeekPosition, seek_entry_pos_[i]); payload_size += @@ -2395,20 +2398,20 @@ bool SeekHead::Finalize(IMkvWriter* writer) const { if (payload_size == 0) return true; - const int64 pos = writer->Position(); + const int64_t pos = writer->Position(); if (writer->Position(start_pos_)) return false; if (!WriteEbmlMasterElement(writer, kMkvSeekHead, payload_size)) return false; - for (int32 i = 0; i < kSeekEntryCount; ++i) { + for (int32_t i = 0; i < kSeekEntryCount; ++i) { if (seek_entry_id_[i] != 0) { if (!WriteEbmlMasterElement(writer, kMkvSeek, entry_size[i])) return false; if (!WriteEbmlElement(writer, kMkvSeekID, - static_cast(seek_entry_id_[i]))) + static_cast(seek_entry_id_[i]))) return false; if (!WriteEbmlElement(writer, kMkvSeekPosition, seek_entry_pos_[i])) @@ -2416,13 +2419,13 @@ bool SeekHead::Finalize(IMkvWriter* writer) const { } } - const uint64 total_entry_size = kSeekEntryCount * MaxEntrySize(); - const uint64 total_size = + const uint64_t total_entry_size = kSeekEntryCount * MaxEntrySize(); + const uint64_t total_size = EbmlMasterElementSize(kMkvSeekHead, total_entry_size) + total_entry_size; - const int64 size_left = total_size - (writer->Position() - start_pos_); + const int64_t size_left = total_size - (writer->Position() - start_pos_); - const uint64 bytes_written = WriteVoidElement(writer, size_left); + const uint64_t bytes_written = WriteVoidElement(writer, size_left); if (!bytes_written) return false; @@ -2434,20 +2437,20 @@ bool SeekHead::Finalize(IMkvWriter* writer) const { } bool SeekHead::Write(IMkvWriter* writer) { - const uint64 entry_size = kSeekEntryCount * MaxEntrySize(); - const uint64 size = EbmlMasterElementSize(kMkvSeekHead, entry_size); + const uint64_t entry_size = kSeekEntryCount * MaxEntrySize(); + const uint64_t size = EbmlMasterElementSize(kMkvSeekHead, entry_size); start_pos_ = writer->Position(); - const uint64 bytes_written = WriteVoidElement(writer, size + entry_size); + const uint64_t bytes_written = WriteVoidElement(writer, size + entry_size); if (!bytes_written) return false; return true; } -bool SeekHead::AddSeekEntry(uint32 id, uint64 pos) { - for (int32 i = 0; i < kSeekEntryCount; ++i) { +bool SeekHead::AddSeekEntry(uint32_t id, uint64_t pos) { + for (int32_t i = 0; i < kSeekEntryCount; ++i) { if (seek_entry_id_[i] == 0) { seek_entry_id_[i] = id; seek_entry_pos_[i] = pos; @@ -2457,19 +2460,19 @@ bool SeekHead::AddSeekEntry(uint32 id, uint64 pos) { return false; } -uint32 SeekHead::GetId(int index) const { +uint32_t SeekHead::GetId(int index) const { if (index < 0 || index >= kSeekEntryCount) return UINT_MAX; return seek_entry_id_[index]; } -uint64 SeekHead::GetPosition(int index) const { +uint64_t SeekHead::GetPosition(int index) const { if (index < 0 || index >= kSeekEntryCount) return ULLONG_MAX; return seek_entry_pos_[index]; } -bool SeekHead::SetSeekEntry(int index, uint32 id, uint64 position) { +bool SeekHead::SetSeekEntry(int index, uint32_t id, uint64_t position) { if (index < 0 || index >= kSeekEntryCount) return false; seek_entry_id_[index] = id; @@ -2477,11 +2480,11 @@ bool SeekHead::SetSeekEntry(int index, uint32 id, uint64 position) { return true; } -uint64 SeekHead::MaxEntrySize() const { - const uint64 max_entry_payload_size = - EbmlElementSize(kMkvSeekID, 0xffffffffULL) + - EbmlElementSize(kMkvSeekPosition, 0xffffffffffffffffULL); - const uint64 max_entry_size = +uint64_t SeekHead::MaxEntrySize() const { + const uint64_t max_entry_payload_size = + EbmlElementSize(kMkvSeekID, UINT64_C(0xffffffff)) + + EbmlElementSize(kMkvSeekPosition, UINT64_C(0xffffffffffffffff)); + const uint64_t max_entry_size = EbmlMasterElementSize(kMkvSeek, max_entry_payload_size) + max_entry_payload_size; @@ -2506,10 +2509,10 @@ SegmentInfo::~SegmentInfo() { } bool SegmentInfo::Init() { - int32 major; - int32 minor; - int32 build; - int32 revision; + int32_t major; + int32_t minor; + int32_t build; + int32_t revision; GetVersion(&major, &minor, &build, &revision); char temp[256]; #ifdef _MSC_VER @@ -2549,7 +2552,7 @@ bool SegmentInfo::Finalize(IMkvWriter* writer) const { if (duration_pos_ == -1) return false; - const int64 pos = writer->Position(); + const int64_t pos = writer->Position(); if (writer->Position(duration_pos_)) return false; @@ -2570,7 +2573,7 @@ bool SegmentInfo::Write(IMkvWriter* writer) { if (!writer || !muxing_app_ || !writing_app_) return false; - uint64 size = EbmlElementSize(kMkvTimecodeScale, timecode_scale_); + uint64_t size = EbmlElementSize(kMkvTimecodeScale, timecode_scale_); if (duration_ > 0.0) size += EbmlElementSize(kMkvDuration, static_cast(duration_)); if (date_utc_ != LLONG_MIN) @@ -2581,7 +2584,7 @@ bool SegmentInfo::Write(IMkvWriter* writer) { if (!WriteEbmlMasterElement(writer, kMkvInfo, size)) return false; - const int64 payload_position = writer->Position(); + const int64_t payload_position = writer->Position(); if (payload_position < 0) return false; @@ -2604,9 +2607,9 @@ bool SegmentInfo::Write(IMkvWriter* writer) { if (!WriteEbmlElement(writer, kMkvWritingApp, writing_app_)) return false; - const int64 stop_position = writer->Position(); + const int64_t stop_position = writer->Position(); if (stop_position < 0 || - stop_position - payload_position != static_cast(size)) + stop_position - payload_position != static_cast(size)) return false; return true; @@ -2694,7 +2697,7 @@ Segment::Segment() Segment::~Segment() { if (cluster_list_) { - for (int32 i = 0; i < cluster_list_size_; ++i) { + for (int32_t i = 0; i < cluster_list_size_; ++i) { Cluster* const cluster = cluster_list_[i]; delete cluster; } @@ -2702,7 +2705,7 @@ Segment::~Segment() { } if (frames_) { - for (int32 i = 0; i < frames_size_; ++i) { + for (int32_t i = 0; i < frames_size_; ++i) { Frame* const frame = frames_[i]; delete frame; } @@ -2726,13 +2729,13 @@ Segment::~Segment() { } } -void Segment::MoveCuesBeforeClustersHelper(uint64 diff, int32 index, - uint64* cues_size) { +void Segment::MoveCuesBeforeClustersHelper(uint64_t diff, int32_t index, + uint64_t* cues_size) { CuePoint* const cue_point = cues_.GetCueByIndex(index); if (cue_point == NULL) return; - const uint64 old_cue_point_size = cue_point->Size(); - const uint64 cluster_pos = cue_point->cluster_pos() + diff; + const uint64_t old_cue_point_size = cue_point->Size(); + const uint64_t cluster_pos = cue_point->cluster_pos() + diff; cue_point->set_cluster_pos(cluster_pos); // update the new cluster position // New size of the cue is computed as follows // Let a = current sum of size of all CuePoints @@ -2742,32 +2745,32 @@ void Segment::MoveCuesBeforeClustersHelper(uint64 diff, int32 index, // Let d = b + c. Now d is the |diff| passed to the next recursive call. // Let e = a + b. Now e is the |cues_size| passed to the next recursive // call. - const uint64 cue_point_size_diff = cue_point->Size() - old_cue_point_size; - const uint64 cue_size_diff = + const uint64_t cue_point_size_diff = cue_point->Size() - old_cue_point_size; + const uint64_t cue_size_diff = GetCodedUIntSize(*cues_size + cue_point_size_diff) - GetCodedUIntSize(*cues_size); *cues_size += cue_point_size_diff; diff = cue_size_diff + cue_point_size_diff; if (diff > 0) { - for (int32 i = 0; i < cues_.cue_entries_size(); ++i) { + for (int32_t i = 0; i < cues_.cue_entries_size(); ++i) { MoveCuesBeforeClustersHelper(diff, i, cues_size); } } } void Segment::MoveCuesBeforeClusters() { - const uint64 current_cue_size = cues_.Size(); - uint64 cue_size = 0; - for (int32 i = 0; i < cues_.cue_entries_size(); ++i) + const uint64_t current_cue_size = cues_.Size(); + uint64_t cue_size = 0; + for (int32_t i = 0; i < cues_.cue_entries_size(); ++i) cue_size += cues_.GetCueByIndex(i)->Size(); - for (int32 i = 0; i < cues_.cue_entries_size(); ++i) + for (int32_t i = 0; i < cues_.cue_entries_size(); ++i) MoveCuesBeforeClustersHelper(current_cue_size, i, &cue_size); // Adjust the Seek Entry to reflect the change in position // of Cluster and Cues - int32 cluster_index = 0; - int32 cues_index = 0; - for (int32 i = 0; i < SeekHead::kSeekEntryCount; ++i) { + int32_t cluster_index = 0; + int32_t cues_index = 0; + for (int32_t i = 0; i < SeekHead::kSeekEntryCount; ++i) { if (seek_head_.GetId(i) == kMkvCluster) cluster_index = i; if (seek_head_.GetId(i) == kMkvCues) @@ -2793,7 +2796,7 @@ bool Segment::CopyAndMoveCuesBeforeClusters(mkvparser::IMkvReader* reader, IMkvWriter* writer) { if (!writer->Seekable() || chunking_) return false; - const int64 cluster_offset = + const int64_t cluster_offset = cluster_list_[0]->size_position() - GetUIntSize(kMkvCluster); // Copy the headers. @@ -2817,8 +2820,8 @@ bool Segment::CopyAndMoveCuesBeforeClusters(mkvparser::IMkvReader* reader, return false; // Update the Segment size in case the Cues size has changed. - const int64 pos = writer->Position(); - const int64 segment_size = writer->Position() - payload_pos_; + const int64_t pos = writer->Position(); + const int64_t segment_size = writer->Position() - payload_pos_; if (writer->Position(size_position_) || WriteUIntSize(writer, segment_size, 8) || writer->Position(pos)) return false; @@ -2884,11 +2887,11 @@ bool Segment::Finalize() { if (size_position_ == -1) return false; - const int64 segment_size = MaxOffset(); + const int64_t segment_size = MaxOffset(); if (segment_size < 1) return false; - const int64 pos = writer_header_->Position(); + const int64_t pos = writer_header_->Position(); UpdateDocTypeVersion(); if (doc_type_version_ != doc_type_version_written_) { if (writer_header_->Position(0)) @@ -2926,7 +2929,7 @@ bool Segment::Finalize() { return true; } -Track* Segment::AddTrack(int32 number) { +Track* Segment::AddTrack(int32_t number) { Track* const track = new (std::nothrow) Track(&seed_); // NOLINT if (!track) @@ -2944,7 +2947,7 @@ Chapter* Segment::AddChapter() { return chapters_.AddChapter(&seed_); } Tag* Segment::AddTag() { return tags_.AddTag(); } -uint64 Segment::AddVideoTrack(int32 width, int32 height, int32 number) { +uint64_t Segment::AddVideoTrack(int32_t width, int32_t height, int32_t number) { VideoTrack* const track = new (std::nothrow) VideoTrack(&seed_); // NOLINT if (!track) return 0; @@ -2960,7 +2963,7 @@ uint64 Segment::AddVideoTrack(int32 width, int32 height, int32 number) { return track->number(); } -bool Segment::AddCuePoint(uint64 timestamp, uint64 track) { +bool Segment::AddCuePoint(uint64_t timestamp, uint64_t track) { if (cluster_list_size_ < 1) return false; @@ -2983,7 +2986,8 @@ bool Segment::AddCuePoint(uint64 timestamp, uint64 track) { return true; } -uint64 Segment::AddAudioTrack(int32 sample_rate, int32 channels, int32 number) { +uint64_t Segment::AddAudioTrack(int32_t sample_rate, int32_t channels, + int32_t number) { AudioTrack* const track = new (std::nothrow) AudioTrack(&seed_); // NOLINT if (!track) return 0; @@ -2998,8 +3002,8 @@ uint64 Segment::AddAudioTrack(int32 sample_rate, int32 channels, int32 number) { return track->number(); } -bool Segment::AddFrame(const uint8* data, uint64 length, uint64 track_number, - uint64 timestamp, bool is_key) { +bool Segment::AddFrame(const uint8_t* data, uint64_t length, + uint64_t track_number, uint64_t timestamp, bool is_key) { if (!data) return false; @@ -3012,11 +3016,11 @@ bool Segment::AddFrame(const uint8* data, uint64 length, uint64 track_number, return AddGenericFrame(&frame); } -bool Segment::AddFrameWithAdditional(const uint8* data, uint64 length, - const uint8* additional, - uint64 additional_length, uint64 add_id, - uint64 track_number, uint64 timestamp, - bool is_key) { +bool Segment::AddFrameWithAdditional(const uint8_t* data, uint64_t length, + const uint8_t* additional, + uint64_t additional_length, + uint64_t add_id, uint64_t track_number, + uint64_t timestamp, bool is_key) { if (!data || !additional) return false; @@ -3031,10 +3035,10 @@ bool Segment::AddFrameWithAdditional(const uint8* data, uint64 length, return AddGenericFrame(&frame); } -bool Segment::AddFrameWithDiscardPadding(const uint8* data, uint64 length, - int64 discard_padding, - uint64 track_number, uint64 timestamp, - bool is_key) { +bool Segment::AddFrameWithDiscardPadding(const uint8_t* data, uint64_t length, + int64_t discard_padding, + uint64_t track_number, + uint64_t timestamp, bool is_key) { if (!data) return false; @@ -3048,8 +3052,9 @@ bool Segment::AddFrameWithDiscardPadding(const uint8* data, uint64 length, return AddGenericFrame(&frame); } -bool Segment::AddMetadata(const uint8* data, uint64 length, uint64 track_number, - uint64 timestamp_ns, uint64 duration_ns) { +bool Segment::AddMetadata(const uint8_t* data, uint64_t length, + uint64_t track_number, uint64_t timestamp_ns, + uint64_t duration_ns) { if (!data) return false; @@ -3221,7 +3226,7 @@ bool Segment::SetChunking(bool chunking, const char* filename) { return true; } -bool Segment::CuesTrack(uint64 track_number) { +bool Segment::CuesTrack(uint64_t track_number) { const Track* const track = GetTrackByNumber(track_number); if (!track) return false; @@ -3232,7 +3237,7 @@ bool Segment::CuesTrack(uint64 track_number) { void Segment::ForceNewClusterOnNextFrame() { force_new_cluster_ = true; } -Track* Segment::GetTrackByNumber(uint64 track_number) const { +Track* Segment::GetTrackByNumber(uint64_t track_number) const { return tracks_.GetTrackByNumber(track_number); } @@ -3243,7 +3248,7 @@ bool Segment::WriteSegmentHeader() { if (!WriteEbmlHeader(writer_header_, doc_type_version_)) return false; doc_type_version_written_ = doc_type_version_; - ebml_header_size_ = static_cast(writer_header_->Position()); + ebml_header_size_ = static_cast(writer_header_->Position()); // Write "unknown" (-1) as segment size value. If mode is kFile, Segment // will write over duration when the file is finalized. @@ -3310,7 +3315,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_t track_number, uint64_t frame_timestamp_ns, bool is_key) const { if (force_new_cluster_) return 1; @@ -3328,11 +3333,11 @@ int Segment::TestFrame(uint64 track_number, uint64 frame_timestamp_ns, // written to the existing cluster, or that a new cluster should be // created. - const uint64 timecode_scale = segment_info_.timecode_scale(); - const uint64 frame_timecode = frame_timestamp_ns / timecode_scale; + const uint64_t timecode_scale = segment_info_.timecode_scale(); + const uint64_t frame_timecode = frame_timestamp_ns / timecode_scale; const Cluster* const last_cluster = cluster_list_[cluster_list_size_ - 1]; - const uint64 last_cluster_timecode = last_cluster->timecode(); + const uint64_t last_cluster_timecode = last_cluster->timecode(); // For completeness we test for the case when the frame's timecode // is less than the cluster's timecode. Although in principle that @@ -3347,7 +3352,7 @@ int Segment::TestFrame(uint64 track_number, uint64 frame_timestamp_ns, // using a 16-bit signed integer), then we cannot write this frame // to that cluster, and so we must create a new cluster. - const int64 delta_timecode = frame_timecode - last_cluster_timecode; + const int64_t delta_timecode = frame_timecode - last_cluster_timecode; if (delta_timecode > kMaxBlockTimecode) return 2; @@ -3363,7 +3368,7 @@ int Segment::TestFrame(uint64 track_number, uint64 frame_timestamp_ns, // already, where "too many" is defined as "the total time of frames // in the cluster exceeds a threshold". - const uint64 delta_ns = delta_timecode * timecode_scale; + const uint64_t delta_ns = delta_timecode * timecode_scale; if (max_cluster_duration_ > 0 && delta_ns >= max_cluster_duration_) return 1; @@ -3372,7 +3377,7 @@ int Segment::TestFrame(uint64 track_number, uint64 frame_timestamp_ns, // cluster is created when the size of the current cluster exceeds a // threshold. - const uint64 cluster_size = last_cluster->payload_size(); + const uint64_t cluster_size = last_cluster->payload_size(); if (max_cluster_size_ > 0 && cluster_size >= max_cluster_size_) return 1; @@ -3382,19 +3387,19 @@ int Segment::TestFrame(uint64 track_number, uint64 frame_timestamp_ns, return 0; } -bool Segment::MakeNewCluster(uint64 frame_timestamp_ns) { - const int32 new_size = cluster_list_size_ + 1; +bool Segment::MakeNewCluster(uint64_t frame_timestamp_ns) { + const int32_t new_size = cluster_list_size_ + 1; if (new_size > cluster_list_capacity_) { // Add more clusters. - const int32 new_capacity = + const int32_t new_capacity = (cluster_list_capacity_ <= 0) ? 1 : cluster_list_capacity_ * 2; Cluster** const clusters = new (std::nothrow) Cluster*[new_capacity]; // NOLINT if (!clusters) return false; - for (int32 i = 0; i < cluster_list_size_; ++i) { + for (int32_t i = 0; i < cluster_list_size_; ++i) { clusters[i] = cluster_list_[i]; } @@ -3428,22 +3433,22 @@ bool Segment::MakeNewCluster(uint64 frame_timestamp_ns) { return false; } - const uint64 timecode_scale = segment_info_.timecode_scale(); - const uint64 frame_timecode = frame_timestamp_ns / timecode_scale; + const uint64_t timecode_scale = segment_info_.timecode_scale(); + const uint64_t frame_timecode = frame_timestamp_ns / timecode_scale; - uint64 cluster_timecode = frame_timecode; + uint64_t cluster_timecode = frame_timecode; if (frames_size_ > 0) { const Frame* const f = frames_[0]; // earliest queued frame - const uint64 ns = f->timestamp(); - const uint64 tc = ns / timecode_scale; + const uint64_t ns = f->timestamp(); + const uint64_t tc = ns / timecode_scale; if (tc < cluster_timecode) cluster_timecode = tc; } Cluster*& cluster = cluster_list_[cluster_list_size_]; - const int64 offset = MaxOffset(); + const int64_t offset = MaxOffset(); cluster = new (std::nothrow) Cluster(cluster_timecode, offset, segment_info_.timecode_scale(), accurate_cluster_duration_); @@ -3457,8 +3462,8 @@ bool Segment::MakeNewCluster(uint64 frame_timestamp_ns) { return true; } -bool Segment::DoNewClusterProcessing(uint64 track_number, - uint64 frame_timestamp_ns, bool is_key) { +bool Segment::DoNewClusterProcessing(uint64_t track_number, + uint64_t 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. @@ -3499,7 +3504,7 @@ bool Segment::CheckHeaderInfo() { if (output_cues_ && cues_track_ == 0) { // Check for a video track - for (uint32 i = 0; i < tracks_.track_entries_size(); ++i) { + for (uint32_t i = 0; i < tracks_.track_entries_size(); ++i) { const Track* const track = tracks_.GetTrackByIndex(i); if (!track) return false; @@ -3524,7 +3529,7 @@ bool Segment::CheckHeaderInfo() { } void Segment::UpdateDocTypeVersion() { - for (uint32 index = 0; index < tracks_.track_entries_size(); ++index) { + for (uint32_t index = 0; index < tracks_.track_entries_size(); ++index) { const Track* track = tracks_.GetTrackByIndex(index); if (track == NULL) break; @@ -3566,14 +3571,14 @@ bool Segment::UpdateChunkName(const char* ext, char** name) const { return true; } -int64 Segment::MaxOffset() { +int64_t Segment::MaxOffset() { if (!writer_header_) return -1; - int64 offset = writer_header_->Position() - payload_pos_; + int64_t offset = writer_header_->Position() - payload_pos_; if (chunking_) { - for (int32 i = 0; i < cluster_list_size_; ++i) { + for (int32_t i = 0; i < cluster_list_size_; ++i) { Cluster* const cluster = cluster_list_[i]; offset += cluster->Size(); } @@ -3586,11 +3591,11 @@ int64 Segment::MaxOffset() { } bool Segment::QueueFrame(Frame* frame) { - const int32 new_size = frames_size_ + 1; + const int32_t new_size = frames_size_ + 1; if (new_size > frames_capacity_) { // Add more frames. - const int32 new_capacity = (!frames_capacity_) ? 2 : frames_capacity_ * 2; + const int32_t new_capacity = (!frames_capacity_) ? 2 : frames_capacity_ * 2; if (new_capacity < 1) return false; @@ -3599,7 +3604,7 @@ bool Segment::QueueFrame(Frame* frame) { if (!frames) return false; - for (int32 i = 0; i < frames_size_; ++i) { + for (int32_t i = 0; i < frames_size_; ++i) { frames[i] = frames_[i]; } @@ -3625,7 +3630,7 @@ int Segment::WriteFramesAll() { if (!cluster) return -1; - for (int32 i = 0; i < frames_size_; ++i) { + for (int32_t i = 0; i < frames_size_; ++i) { Frame*& frame = frames_[i]; // TODO(jzern/vigneshv): using Segment::AddGenericFrame here would limit the // places where |doc_type_version_| needs to be updated. @@ -3654,7 +3659,7 @@ int Segment::WriteFramesAll() { return result; } -bool Segment::WriteFramesLessThan(uint64 timestamp) { +bool Segment::WriteFramesLessThan(uint64_t timestamp) { // Check |cluster_list_size_| to see if this is the first cluster. If it is // the first cluster the audio frames that are less than the first video // timesatmp will be written in a later step. @@ -3666,11 +3671,11 @@ bool Segment::WriteFramesLessThan(uint64 timestamp) { if (!cluster) return false; - int32 shift_left = 0; + int32_t shift_left = 0; // TODO(fgalligan): Change this to use the durations of frames instead of // the next frame's start time if the duration is accurate. - for (int32 i = 1; i < frames_size_; ++i) { + for (int32_t i = 1; i < frames_size_; ++i) { const Frame* const frame_curr = frames_[i]; if (frame_curr->timestamp() > timestamp) @@ -3701,8 +3706,8 @@ bool Segment::WriteFramesLessThan(uint64 timestamp) { if (shift_left >= frames_size_) return false; - const int32 new_frames_size = frames_size_ - shift_left; - for (int32 i = 0; i < new_frames_size; ++i) { + const int32_t new_frames_size = frames_size_ - shift_left; + for (int32_t i = 0; i < new_frames_size; ++i) { frames_[i] = frames_[i + shift_left]; } diff --git a/mkvmuxer.hpp b/mkvmuxer.hpp index d3198ef..5cb04d3 100644 --- a/mkvmuxer.hpp +++ b/mkvmuxer.hpp @@ -9,6 +9,8 @@ #ifndef MKVMUXER_HPP #define MKVMUXER_HPP +#include + #include #include #include @@ -30,21 +32,21 @@ namespace mkvmuxer { class MkvWriter; class Segment; -const uint64 kMaxTrackNumber = 126; +const uint64_t kMaxTrackNumber = 126; /////////////////////////////////////////////////////////////// // Interface used by the mkvmuxer to write out the Mkv data. class IMkvWriter { public: // Writes out |len| bytes of |buf|. Returns 0 on success. - virtual int32 Write(const void* buf, uint32 len) = 0; + virtual int32_t Write(const void* buf, uint32_t len) = 0; // Returns the offset of the output position from the beginning of the // output. - virtual int64 Position() const = 0; + virtual int64_t Position() const = 0; // Set the current File position. Returns 0 on success. - virtual int32 Position(int64 position) = 0; + virtual int32_t Position(int64_t position) = 0; // Returns true if the writer is seekable. virtual bool Seekable() const = 0; @@ -54,7 +56,7 @@ class IMkvWriter { // |position| is the location in the WebM stream where the first octet of the // element identifier will be written. // Note: the |MkvId| enumeration in webmids.hpp defines element values. - virtual void ElementStartNotify(uint64 element_id, int64 position) = 0; + virtual void ElementStartNotify(uint64_t element_id, int64_t position) = 0; protected: IMkvWriter(); @@ -66,15 +68,15 @@ class IMkvWriter { // Writes out the EBML header for a WebM file. This function must be called // before any other libwebm writing functions are called. -bool WriteEbmlHeader(IMkvWriter* writer, uint64 doc_type_version); +bool WriteEbmlHeader(IMkvWriter* writer, uint64_t doc_type_version); // Deprecated. Writes out EBML header with doc_type_version as // kDefaultDocTypeVersion. Exists for backward compatibility. 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_t start, + int64_t size); /////////////////////////////////////////////////////////////// // Class to hold data the will be written to a block. @@ -88,10 +90,11 @@ class Frame { bool CopyFrom(const Frame& frame); // Copies |frame| data into |frame_|. Returns true on success. - bool Init(const uint8* frame, uint64 length); + bool Init(const uint8_t* frame, uint64_t length); // Copies |additional| data into |additional_|. Returns true on success. - bool AddAdditionalData(const uint8* additional, uint64 length, uint64 add_id); + bool AddAdditionalData(const uint8_t* additional, uint64_t length, + uint64_t add_id); // Returns true if the frame has valid parameters. bool IsValid() const; @@ -100,42 +103,44 @@ class Frame { // parameters. bool CanBeSimpleBlock() const; - uint64 add_id() const { return add_id_; } - const uint8* additional() const { return additional_; } - uint64 additional_length() const { return additional_length_; } - void set_duration(uint64 duration); - uint64 duration() const { return duration_; } + uint64_t add_id() const { return add_id_; } + const uint8_t* additional() const { return additional_; } + uint64_t additional_length() const { return additional_length_; } + void set_duration(uint64_t duration); + uint64_t duration() const { return duration_; } bool duration_set() const { return duration_set_; } - const uint8* frame() const { return frame_; } + const uint8_t* frame() const { return frame_; } void set_is_key(bool key) { is_key_ = key; } bool is_key() const { return is_key_; } - uint64 length() const { return length_; } - void set_track_number(uint64 track_number) { track_number_ = track_number; } - uint64 track_number() const { return track_number_; } - void set_timestamp(uint64 timestamp) { timestamp_ = timestamp; } - uint64 timestamp() const { return timestamp_; } - void set_discard_padding(int64 discard_padding) { + uint64_t length() const { return length_; } + void set_track_number(uint64_t track_number) { track_number_ = track_number; } + uint64_t track_number() const { return track_number_; } + void set_timestamp(uint64_t timestamp) { timestamp_ = timestamp; } + uint64_t timestamp() const { return timestamp_; } + void set_discard_padding(int64_t discard_padding) { discard_padding_ = discard_padding; } - int64 discard_padding() const { return discard_padding_; } - void set_reference_block_timestamp(int64 reference_block_timestamp); - int64 reference_block_timestamp() const { return reference_block_timestamp_; } + int64_t discard_padding() const { return discard_padding_; } + void set_reference_block_timestamp(int64_t reference_block_timestamp); + int64_t reference_block_timestamp() const { + return reference_block_timestamp_; + } bool reference_block_timestamp_set() const { return reference_block_timestamp_set_; } private: // Id of the Additional data. - uint64 add_id_; + uint64_t add_id_; // Pointer to additional data. Owned by this class. - uint8* additional_; + uint8_t* additional_; // Length of the additional data. - uint64 additional_length_; + uint64_t additional_length_; // Duration of the frame in nanoseconds. - uint64 duration_; + uint64_t duration_; // Flag indicating that |duration_| has been set. Setting duration causes the // frame to be written out as a Block with BlockDuration instead of as a @@ -143,25 +148,25 @@ class Frame { bool duration_set_; // Pointer to the data. Owned by this class. - uint8* frame_; + uint8_t* frame_; // Flag telling if the data should set the key flag of a block. bool is_key_; // Length of the data. - uint64 length_; + uint64_t length_; // Mkv track number the data is associated with. - uint64 track_number_; + uint64_t track_number_; // Timestamp of the data in nanoseconds. - uint64 timestamp_; + uint64_t timestamp_; // Discard padding for the frame. - int64 discard_padding_; + int64_t discard_padding_; // Reference block timestamp. - int64 reference_block_timestamp_; + int64_t reference_block_timestamp_; // Flag indicating if |reference_block_timestamp_| has been set. bool reference_block_timestamp_set_; @@ -177,19 +182,19 @@ class CuePoint { ~CuePoint(); // Returns the size in bytes for the entire CuePoint element. - uint64 Size() const; + uint64_t Size() const; // Output the CuePoint element to the writer. Returns true on success. bool Write(IMkvWriter* writer) const; - void set_time(uint64 time) { time_ = time; } - uint64 time() const { return time_; } - void set_track(uint64 track) { track_ = track; } - uint64 track() const { return track_; } - void set_cluster_pos(uint64 cluster_pos) { cluster_pos_ = cluster_pos; } - uint64 cluster_pos() const { return cluster_pos_; } - void set_block_number(uint64 block_number) { block_number_ = block_number; } - uint64 block_number() const { return block_number_; } + void set_time(uint64_t time) { time_ = time; } + uint64_t time() const { return time_; } + void set_track(uint64_t track) { track_ = track; } + uint64_t track() const { return track_; } + void set_cluster_pos(uint64_t cluster_pos) { cluster_pos_ = cluster_pos; } + uint64_t cluster_pos() const { return cluster_pos_; } + void set_block_number(uint64_t block_number) { block_number_ = block_number; } + uint64_t block_number() const { return block_number_; } void set_output_block_number(bool output_block_number) { output_block_number_ = output_block_number; } @@ -197,19 +202,19 @@ class CuePoint { private: // Returns the size in bytes for the payload of the CuePoint element. - uint64 PayloadSize() const; + uint64_t PayloadSize() const; // Absolute timecode according to the segment time base. - uint64 time_; + uint64_t time_; // The Track element associated with the CuePoint. - uint64 track_; + uint64_t track_; // The position of the Cluster containing the Block. - uint64 cluster_pos_; + uint64_t cluster_pos_; // Number of the Block within the Cluster, starting from 1. - uint64 block_number_; + uint64_t block_number_; // If true the muxer will write out the block number for the cue if the // block number is different than the default of 1. Default is set to true. @@ -230,15 +235,15 @@ class Cues { // Returns the cue point by index. Returns NULL if there is no cue point // match. - CuePoint* GetCueByIndex(int32 index) const; + CuePoint* GetCueByIndex(int32_t index) const; // Returns the total size of the Cues element - uint64 Size(); + uint64_t Size(); // Output the Cues element to the writer. Returns true on success. bool Write(IMkvWriter* writer) const; - int32 cue_entries_size() const { return cue_entries_size_; } + int32_t cue_entries_size() const { return cue_entries_size_; } void set_output_block_number(bool output_block_number) { output_block_number_ = output_block_number; } @@ -246,10 +251,10 @@ class Cues { private: // Number of allocated elements in |cue_entries_|. - int32 cue_entries_capacity_; + int32_t cue_entries_capacity_; // Number of CuePoints in |cue_entries_|. - int32 cue_entries_size_; + int32_t cue_entries_size_; // CuePoint list. CuePoint** cue_entries_; @@ -271,21 +276,21 @@ class ContentEncAESSettings { ~ContentEncAESSettings() {} // Returns the size in bytes for the ContentEncAESSettings element. - uint64 Size() const; + uint64_t Size() const; // Writes out the ContentEncAESSettings element to |writer|. Returns true on // success. bool Write(IMkvWriter* writer) const; - uint64 cipher_mode() const { return cipher_mode_; } + uint64_t cipher_mode() const { return cipher_mode_; } private: // Returns the size in bytes for the payload of the ContentEncAESSettings // element. - uint64 PayloadSize() const; + uint64_t PayloadSize() const; // Sub elements - uint64 cipher_mode_; + uint64_t cipher_mode_; LIBWEBM_DISALLOW_COPY_AND_ASSIGN(ContentEncAESSettings); }; @@ -304,40 +309,41 @@ class ContentEncoding { // Sets the content encryption id. Copies |length| bytes from |id| to // |enc_key_id_|. Returns true on success. - bool SetEncryptionID(const uint8* id, uint64 length); + bool SetEncryptionID(const uint8_t* id, uint64_t length); // Returns the size in bytes for the ContentEncoding element. - uint64 Size() const; + uint64_t Size() const; // Writes out the ContentEncoding element to |writer|. Returns true on // success. bool Write(IMkvWriter* writer) const; - uint64 enc_algo() const { return enc_algo_; } - uint64 encoding_order() const { return encoding_order_; } - uint64 encoding_scope() const { return encoding_scope_; } - uint64 encoding_type() const { return encoding_type_; } + uint64_t enc_algo() const { return enc_algo_; } + uint64_t encoding_order() const { return encoding_order_; } + uint64_t encoding_scope() const { return encoding_scope_; } + uint64_t encoding_type() const { return encoding_type_; } ContentEncAESSettings* enc_aes_settings() { return &enc_aes_settings_; } private: // Returns the size in bytes for the encoding elements. - uint64 EncodingSize(uint64 compresion_size, uint64 encryption_size) const; + uint64_t EncodingSize(uint64_t compresion_size, + uint64_t encryption_size) const; // Returns the size in bytes for the encryption elements. - uint64 EncryptionSize() const; + uint64_t EncryptionSize() const; // Track element names - uint64 enc_algo_; - uint8* enc_key_id_; - uint64 encoding_order_; - uint64 encoding_scope_; - uint64 encoding_type_; + uint64_t enc_algo_; + uint8_t* enc_key_id_; + uint64_t encoding_order_; + uint64_t encoding_scope_; + uint64_t encoding_type_; // ContentEncAESSettings element. ContentEncAESSettings enc_aes_settings_; // Size of the ContentEncKeyID data in bytes. - uint64 enc_key_id_length_; + uint64_t enc_key_id_length_; LIBWEBM_DISALLOW_COPY_AND_ASSIGN(ContentEncoding); }; @@ -348,7 +354,7 @@ struct PrimaryChromaticity { PrimaryChromaticity(float x_val, float y_val) : x(x_val), y(y_val) {} PrimaryChromaticity() : x(0), y(0) {} ~PrimaryChromaticity() {} - uint64 PrimaryChromaticityPayloadSize(MkvId x_id, MkvId y_id) const; + uint64_t PrimaryChromaticityPayloadSize(MkvId x_id, MkvId y_id) const; bool Write(IMkvWriter* writer, MkvId x_id, MkvId y_id) const; float x; @@ -374,7 +380,7 @@ class MasteringMetadata { } // Returns total size of the MasteringMetadata element. - uint64 MasteringMetadataSize() const; + uint64_t MasteringMetadataSize() const; bool Write(IMkvWriter* writer) const; // Copies non-null chromaticity. @@ -392,7 +398,7 @@ class MasteringMetadata { private: // Returns size of MasteringMetadata child elements. - uint64 PayloadSize() const; + uint64_t PayloadSize() const; PrimaryChromaticity* r_; PrimaryChromaticity* g_; @@ -402,7 +408,7 @@ class MasteringMetadata { class Colour { public: - static const uint64 kValueNotPresent; + static const uint64_t kValueNotPresent; Colour() : matrix_coefficients(kValueNotPresent), bits_per_channel(kValueNotPresent), @@ -421,7 +427,7 @@ class Colour { ~Colour() { delete mastering_metadata_; } // Returns total size of the Colour element. - uint64 ColourSize() const; + uint64_t ColourSize() const; bool Write(IMkvWriter* writer) const; // Deep copies |mastering_metadata|. @@ -431,23 +437,23 @@ class Colour { return mastering_metadata_; } - uint64 matrix_coefficients; - uint64 bits_per_channel; - uint64 chroma_subsampling_horz; - uint64 chroma_subsampling_vert; - uint64 cb_subsampling_horz; - uint64 cb_subsampling_vert; - uint64 chroma_siting_horz; - uint64 chroma_siting_vert; - uint64 range; - uint64 transfer_characteristics; - uint64 primaries; - uint64 max_cll; - uint64 max_fall; + uint64_t matrix_coefficients; + uint64_t bits_per_channel; + uint64_t chroma_subsampling_horz; + uint64_t chroma_subsampling_vert; + uint64_t cb_subsampling_horz; + uint64_t cb_subsampling_vert; + uint64_t chroma_siting_horz; + uint64_t chroma_siting_vert; + uint64_t range; + uint64_t transfer_characteristics; + uint64_t primaries; + uint64_t max_cll; + uint64_t max_fall; private: // Returns size of Colour child elements. - uint64 PayloadSize() const; + uint64_t PayloadSize() const; MasteringMetadata* mastering_metadata_; }; @@ -465,76 +471,76 @@ class Track { // Returns the ContentEncoding by index. Returns NULL if there is no // ContentEncoding match. - ContentEncoding* GetContentEncodingByIndex(uint32 index) const; + ContentEncoding* GetContentEncodingByIndex(uint32_t index) const; // Returns the size in bytes for the payload of the Track element. - virtual uint64 PayloadSize() const; + virtual uint64_t PayloadSize() const; // Returns the size in bytes of the Track element. - virtual uint64 Size() const; + virtual uint64_t Size() const; // Output the Track element to the writer. Returns true on success. virtual bool Write(IMkvWriter* writer) const; // Sets the CodecPrivate element of the Track element. Copies |length| // bytes from |codec_private| to |codec_private_|. Returns true on success. - bool SetCodecPrivate(const uint8* codec_private, uint64 length); + bool SetCodecPrivate(const uint8_t* codec_private, uint64_t length); void set_codec_id(const char* codec_id); const char* codec_id() const { return codec_id_; } - const uint8* codec_private() const { return codec_private_; } + const uint8_t* codec_private() const { return codec_private_; } void set_language(const char* language); const char* language() const { return language_; } - void set_max_block_additional_id(uint64 max_block_additional_id) { + void set_max_block_additional_id(uint64_t max_block_additional_id) { max_block_additional_id_ = max_block_additional_id; } - uint64 max_block_additional_id() const { return max_block_additional_id_; } + uint64_t max_block_additional_id() const { return max_block_additional_id_; } void set_name(const char* name); const char* name() const { return name_; } - void set_number(uint64 number) { number_ = number; } - uint64 number() const { return number_; } - void set_type(uint64 type) { type_ = type; } - uint64 type() const { return type_; } - void set_uid(uint64 uid) { uid_ = uid; } - uint64 uid() const { return uid_; } - void set_codec_delay(uint64 codec_delay) { codec_delay_ = codec_delay; } - uint64 codec_delay() const { return codec_delay_; } - void set_seek_pre_roll(uint64 seek_pre_roll) { + void set_number(uint64_t number) { number_ = number; } + uint64_t number() const { return number_; } + void set_type(uint64_t type) { type_ = type; } + uint64_t type() const { return type_; } + void set_uid(uint64_t uid) { uid_ = uid; } + uint64_t uid() const { return uid_; } + void set_codec_delay(uint64_t codec_delay) { codec_delay_ = codec_delay; } + uint64_t codec_delay() const { return codec_delay_; } + void set_seek_pre_roll(uint64_t seek_pre_roll) { seek_pre_roll_ = seek_pre_roll; } - uint64 seek_pre_roll() const { return seek_pre_roll_; } - void set_default_duration(uint64 default_duration) { + uint64_t seek_pre_roll() const { return seek_pre_roll_; } + void set_default_duration(uint64_t default_duration) { default_duration_ = default_duration; } - uint64 default_duration() const { return default_duration_; } + uint64_t default_duration() const { return default_duration_; } - uint64 codec_private_length() const { return codec_private_length_; } - uint32 content_encoding_entries_size() const { + uint64_t codec_private_length() const { return codec_private_length_; } + uint32_t content_encoding_entries_size() const { return content_encoding_entries_size_; } private: // Track element names. char* codec_id_; - uint8* codec_private_; + uint8_t* codec_private_; char* language_; - uint64 max_block_additional_id_; + uint64_t max_block_additional_id_; char* name_; - uint64 number_; - uint64 type_; - uint64 uid_; - uint64 codec_delay_; - uint64 seek_pre_roll_; - uint64 default_duration_; + uint64_t number_; + uint64_t type_; + uint64_t uid_; + uint64_t codec_delay_; + uint64_t seek_pre_roll_; + uint64_t default_duration_; // Size of the CodecPrivate data in bytes. - uint64 codec_private_length_; + uint64_t codec_private_length_; // ContentEncoding element list. ContentEncoding** content_encoding_entries_; // Number of ContentEncoding elements added. - uint32 content_encoding_entries_size_; + uint32_t content_encoding_entries_size_; LIBWEBM_DISALLOW_COPY_AND_ASSIGN(Track); }; @@ -560,39 +566,39 @@ class VideoTrack : public Track { // Returns the size in bytes for the payload of the Track element plus the // video specific elements. - virtual uint64 PayloadSize() const; + virtual uint64_t PayloadSize() const; // Output the VideoTrack element to the writer. Returns true on success. virtual bool Write(IMkvWriter* writer) const; // Sets the video's stereo mode. Returns true on success. - bool SetStereoMode(uint64 stereo_mode); + bool SetStereoMode(uint64_t stereo_mode); // Sets the video's alpha mode. Returns true on success. - bool SetAlphaMode(uint64 alpha_mode); + bool SetAlphaMode(uint64_t alpha_mode); - void set_display_height(uint64 height) { display_height_ = height; } - uint64 display_height() const { return display_height_; } - void set_display_width(uint64 width) { display_width_ = width; } - uint64 display_width() const { return display_width_; } + void set_display_height(uint64_t height) { display_height_ = height; } + uint64_t display_height() const { return display_height_; } + void set_display_width(uint64_t width) { display_width_ = width; } + uint64_t display_width() const { return display_width_; } - void set_crop_left(uint64 crop_left) { crop_left_ = crop_left; } - uint64 crop_left() const { return crop_left_; } - void set_crop_right(uint64 crop_right) { crop_right_ = crop_right; } - uint64 crop_right() const { return crop_right_; } - void set_crop_top(uint64 crop_top) { crop_top_ = crop_top; } - uint64 crop_top() const { return crop_top_; } - void set_crop_bottom(uint64 crop_bottom) { crop_bottom_ = crop_bottom; } - uint64 crop_bottom() const { return crop_bottom_; } + void set_crop_left(uint64_t crop_left) { crop_left_ = crop_left; } + uint64_t crop_left() const { return crop_left_; } + void set_crop_right(uint64_t crop_right) { crop_right_ = crop_right; } + uint64_t crop_right() const { return crop_right_; } + void set_crop_top(uint64_t crop_top) { crop_top_ = crop_top; } + uint64_t crop_top() const { return crop_top_; } + void set_crop_bottom(uint64_t crop_bottom) { crop_bottom_ = crop_bottom; } + uint64_t crop_bottom() const { return crop_bottom_; } void set_frame_rate(double frame_rate) { frame_rate_ = frame_rate; } double frame_rate() const { return frame_rate_; } - void set_height(uint64 height) { height_ = height; } - uint64 height() const { return height_; } - uint64 stereo_mode() { return stereo_mode_; } - uint64 alpha_mode() { return alpha_mode_; } - void set_width(uint64 width) { width_ = width; } - uint64 width() const { return width_; } + void set_height(uint64_t height) { height_ = height; } + uint64_t height() const { return height_; } + uint64_t stereo_mode() { return stereo_mode_; } + uint64_t alpha_mode() { return alpha_mode_; } + void set_width(uint64_t width) { width_ = width; } + uint64_t width() const { return width_; } Colour* colour() { return colour_; } @@ -601,20 +607,20 @@ class VideoTrack : public Track { private: // Returns the size in bytes of the Video element. - uint64 VideoPayloadSize() const; + uint64_t VideoPayloadSize() const; // Video track element names. - uint64 display_height_; - uint64 display_width_; - uint64 crop_left_; - uint64 crop_right_; - uint64 crop_top_; - uint64 crop_bottom_; + uint64_t display_height_; + uint64_t display_width_; + uint64_t crop_left_; + uint64_t crop_right_; + uint64_t crop_top_; + uint64_t crop_bottom_; double frame_rate_; - uint64 height_; - uint64 stereo_mode_; - uint64 alpha_mode_; - uint64 width_; + uint64_t height_; + uint64_t stereo_mode_; + uint64_t alpha_mode_; + uint64_t width_; Colour* colour_; @@ -631,22 +637,22 @@ class AudioTrack : public Track { // Returns the size in bytes for the payload of the Track element plus the // audio specific elements. - virtual uint64 PayloadSize() const; + virtual uint64_t PayloadSize() const; // Output the AudioTrack element to the writer. Returns true on success. virtual bool Write(IMkvWriter* writer) const; - void set_bit_depth(uint64 bit_depth) { bit_depth_ = bit_depth; } - uint64 bit_depth() const { return bit_depth_; } - void set_channels(uint64 channels) { channels_ = channels; } - uint64 channels() const { return channels_; } + void set_bit_depth(uint64_t bit_depth) { bit_depth_ = bit_depth; } + uint64_t bit_depth() const { return bit_depth_; } + void set_channels(uint64_t channels) { channels_ = channels; } + uint64_t channels() const { return channels_; } void set_sample_rate(double sample_rate) { sample_rate_ = sample_rate; } double sample_rate() const { return sample_rate_; } private: // Audio track element names. - uint64 bit_depth_; - uint64 channels_; + uint64_t bit_depth_; + uint64_t channels_; double sample_rate_; LIBWEBM_DISALLOW_COPY_AND_ASSIGN(AudioTrack); @@ -672,32 +678,32 @@ class Tracks { // deleted by the Tracks object. Returns true on success. |number| is the // number to use for the track. |number| must be >= 0. If |number| == 0 // then the muxer will decide on the track number. - bool AddTrack(Track* track, int32 number); + bool AddTrack(Track* track, int32_t number); // Returns the track by index. Returns NULL if there is no track match. - const Track* GetTrackByIndex(uint32 idx) const; + const Track* GetTrackByIndex(uint32_t idx) const; // Search the Tracks and return the track that matches |tn|. Returns NULL // if there is no track match. - Track* GetTrackByNumber(uint64 track_number) const; + Track* GetTrackByNumber(uint64_t track_number) const; // Returns true if the track number is an audio track. - bool TrackIsAudio(uint64 track_number) const; + bool TrackIsAudio(uint64_t track_number) const; // Returns true if the track number is a video track. - bool TrackIsVideo(uint64 track_number) const; + bool TrackIsVideo(uint64_t track_number) const; // Output the Tracks element to the writer. Returns true on success. bool Write(IMkvWriter* writer) const; - uint32 track_entries_size() const { return track_entries_size_; } + uint32_t track_entries_size() const { return track_entries_size_; } private: // Track element list. Track** track_entries_; // Number of Track elements added. - uint32 track_entries_size_; + uint32_t track_entries_size_; // Whether or not Tracks element has already been written via IMkvWriter. mutable bool wrote_tracks_; @@ -718,12 +724,12 @@ 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, - uint64 end_time_ns); + void set_time(const Segment& segment, uint64_t start_time_ns, + uint64_t end_time_ns); // Sets the uid for this chapter. Primarily used to enable // deterministic output from the muxer. - void set_uid(const uint64 uid) { uid_ = uid; } + void set_uid(const uint64_t uid) { uid_ = uid; } // Add a title string to this chapter, per the semantics described // here: @@ -770,7 +776,7 @@ class Chapter { // If |writer| is non-NULL, serialize the Display sub-element of // the Atom into the stream. Returns the Display element size on // success, 0 if error. - uint64 WriteDisplay(IMkvWriter* writer) const; + uint64_t WriteDisplay(IMkvWriter* writer) const; private: char* title_; @@ -803,20 +809,20 @@ class Chapter { // If |writer| is non-NULL, serialize the Atom sub-element into the // stream. Returns the total size of the element on success, 0 if // error. - uint64 WriteAtom(IMkvWriter* writer) const; + uint64_t WriteAtom(IMkvWriter* writer) const; // The string identifier for this chapter (corresponds to WebVTT cue // identifier). char* id_; // Start timecode of the chapter. - uint64 start_timecode_; + uint64_t start_timecode_; // Stop timecode of the chapter. - uint64 end_timecode_; + uint64_t end_timecode_; // The binary identifier for this chapter. - uint64 uid_; + uint64_t uid_; // The Atom element can contain multiple Display sub-elements, as // the same logical title can be rendered in different languages. @@ -856,7 +862,7 @@ class Chapters { // If |writer| is non-NULL, serialize the Edition sub-element of the // Chapters element into the stream. Returns the Edition element // size on success, 0 if error. - uint64 WriteEdition(IMkvWriter* writer) const; + uint64_t WriteEdition(IMkvWriter* writer) const; // Total length of the chapters_ array. int chapters_size_; @@ -901,7 +907,7 @@ class Tag { // If |writer| is non-NULL, serialize the SimpleTag sub-element of // the Atom into the stream. Returns the SimpleTag element size on // success, 0 if error. - uint64 Write(IMkvWriter* writer) const; + uint64_t Write(IMkvWriter* writer) const; private: char* tag_name_; @@ -928,7 +934,7 @@ class Tag { // If |writer| is non-NULL, serialize the Tag sub-element into the // stream. Returns the total size of the element on success, 0 if // error. - uint64 Write(IMkvWriter* writer) const; + uint64_t Write(IMkvWriter* writer) const; // The Atom element can contain multiple SimpleTag sub-elements SimpleTag* simple_tags_; @@ -986,7 +992,8 @@ class Cluster { // |timecode| is the absolute timecode of the cluster. |cues_pos| is the // position for the cluster within the segment that should be written in // the cues element. |timecode_scale| is the timecode scale of the segment. - Cluster(uint64 timecode, int64 cues_pos, uint64 timecode_scale, + Cluster(uint64_t timecode, int64_t cues_pos, uint64_t timecode_scale); + Cluster(uint64_t timecode, int64_t cues_pos, uint64_t timecode_scale, bool write_last_frame_with_duration = false); ~Cluster(); @@ -1006,8 +1013,8 @@ 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* data, uint64 length, uint64 track_number, - uint64 timecode, // timecode units (absolute) + bool AddFrame(const uint8_t* data, uint64_t length, uint64_t track_number, + uint64_t timecode, // timecode units (absolute) bool is_key); // Adds a frame to be output in the file. The frame is written out through @@ -1023,10 +1030,11 @@ 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* data, uint64 length, - const uint8* additional, uint64 additional_length, - uint64 add_id, uint64 track_number, - uint64 abs_timecode, bool is_key); + bool AddFrameWithAdditional(const uint8_t* data, uint64_t length, + const uint8_t* additional, + uint64_t additional_length, uint64_t add_id, + uint64_t track_number, uint64_t 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. @@ -1039,9 +1047,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 AddFrameWithDiscardPadding(const uint8* data, uint64 length, - int64 discard_padding, uint64 track_number, - uint64 abs_timecode, bool is_key); + bool AddFrameWithDiscardPadding(const uint8_t* data, uint64_t length, + int64_t discard_padding, + uint64_t track_number, uint64_t abs_timecode, + bool is_key); // Writes a frame of metadata to the output medium; returns true on // success. @@ -1057,11 +1066,11 @@ 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* data, uint64 length, uint64 track_number, - uint64 timecode, uint64 duration); + bool AddMetadata(const uint8_t* data, uint64_t length, uint64_t track_number, + uint64_t timecode, uint64_t duration); // Increments the size of the cluster's data in bytes. - void AddPayloadSize(uint64 size); + void AddPayloadSize(uint64_t size); // Closes the cluster so no more data can be written to it. Will update the // cluster's size if |writer_| is seekable. Returns true on success. This @@ -1078,21 +1087,21 @@ class Cluster { // |write_last_frame_with_duration_| will not be // honored. // duration: Duration of the Cluster in timecode scale. - bool Finalize(bool set_last_frame_duration, uint64 duration); + bool Finalize(bool set_last_frame_duration, uint64_t duration); // Returns the size in bytes for the entire Cluster element. - uint64 Size() const; + uint64_t Size() const; // Given |abs_timecode|, calculates timecode relative to most recent timecode. // Returns -1 on failure, or a relative timecode. - int64 GetRelativeTimecode(int64 abs_timecode) const; + int64_t GetRelativeTimecode(int64_t abs_timecode) const; - int64 size_position() const { return size_position_; } - int32 blocks_added() const { return blocks_added_; } - uint64 payload_size() const { return payload_size_; } - int64 position_for_cues() const { return position_for_cues_; } - uint64 timecode() const { return timecode_; } - uint64 timecode_scale() const { return timecode_scale_; } + int64_t size_position() const { return size_position_; } + int32_t blocks_added() const { return blocks_added_; } + uint64_t payload_size() const { return payload_size_; } + int64_t position_for_cues() const { return position_for_cues_; } + uint64_t timecode() const { return timecode_; } + uint64_t timecode_scale() const { return timecode_scale_; } void set_write_last_frame_with_duration(bool write_last_frame_with_duration) { write_last_frame_with_duration_ = write_last_frame_with_duration; } @@ -1102,7 +1111,7 @@ class Cluster { private: // Iterator type for the |stored_frames_| map. - typedef std::map >::iterator FrameMapIterator; + typedef std::map >::iterator FrameMapIterator; // Utility method that confirms that blocks can still be added, and that the // cluster header has been written. Used by |DoWriteFrame*|. Returns true @@ -1111,7 +1120,7 @@ class Cluster { // Utility method used by the |DoWriteFrame*| methods that handles the book // keeping required after each block is written. - void PostWriteBlock(uint64 element_size); + void PostWriteBlock(uint64_t element_size); // Does some verification and calls WriteFrame. bool DoWriteFrame(const Frame* const frame); @@ -1124,7 +1133,7 @@ class Cluster { bool WriteClusterHeader(); // Number of blocks added to the cluster. - int32 blocks_added_; + int32_t blocks_added_; // Flag telling if the cluster has been closed. bool finalized_; @@ -1133,19 +1142,19 @@ class Cluster { bool header_written_; // The size of the cluster elements in bytes. - uint64 payload_size_; + uint64_t payload_size_; // The file position used for cue points. - const int64 position_for_cues_; + const int64_t position_for_cues_; // The file position of the cluster's size element. - int64 size_position_; + int64_t size_position_; // The absolute timecode of the cluster. - const uint64 timecode_; + const uint64_t timecode_; // The timecode scale of the Segment containing the cluster. - const uint64 timecode_scale_; + const uint64_t timecode_scale_; // Flag indicating whether the last frame of the cluster should be written as // a Block with Duration. If set to true, then it will result in holding back @@ -1154,11 +1163,11 @@ class Cluster { bool write_last_frame_with_duration_; // Map used to hold back frames, if required. Track number is the key. - std::map > stored_frames_; + std::map > stored_frames_; // Map from track number to the timestamp of the last block written for that // track. - std::map last_block_timestamp_; + std::map last_block_timestamp_; // Pointer to the writer object. Not owned by this class. IMkvWriter* writer_; @@ -1179,42 +1188,42 @@ class SeekHead { // Adds a seek entry to be written out when the element is finalized. |id| // must be the coded mkv element id. |pos| is the file position of the // element. Returns true on success. - bool AddSeekEntry(uint32 id, uint64 pos); + bool AddSeekEntry(uint32_t id, uint64_t pos); // Writes out SeekHead and SeekEntry elements. Returns true on success. bool Finalize(IMkvWriter* writer) const; // Returns the id of the Seek Entry at the given index. Returns -1 if index is // out of range. - uint32 GetId(int index) const; + uint32_t GetId(int index) const; // Returns the position of the Seek Entry at the given index. Returns -1 if // index is out of range. - uint64 GetPosition(int index) const; + uint64_t GetPosition(int index) const; // Sets the Seek Entry id and position at given index. // Returns true on success. - bool SetSeekEntry(int index, uint32 id, uint64 position); + bool SetSeekEntry(int index, uint32_t id, uint64_t position); // Reserves space by writing out a Void element which will be updated with // a SeekHead element later. Returns true on success. bool Write(IMkvWriter* writer); // We are going to put a cap on the number of Seek Entries. - const static int32 kSeekEntryCount = 5; + const static int32_t kSeekEntryCount = 5; private: // Returns the maximum size in bytes of one seek entry. - uint64 MaxEntrySize() const; + uint64_t MaxEntrySize() const; // Seek entry id element list. - uint32 seek_entry_id_[kSeekEntryCount]; + uint32_t seek_entry_id_[kSeekEntryCount]; // Seek entry pos element list. - uint64 seek_entry_pos_[kSeekEntryCount]; + uint64_t seek_entry_pos_[kSeekEntryCount]; // The file position of SeekHead element. - int64 start_pos_; + int64_t start_pos_; LIBWEBM_DISALLOW_COPY_AND_ASSIGN(SeekHead); }; @@ -1240,12 +1249,12 @@ class SegmentInfo { double duration() const { return duration_; } void set_muxing_app(const char* app); const char* muxing_app() const { return muxing_app_; } - void set_timecode_scale(uint64 scale) { timecode_scale_ = scale; } - uint64 timecode_scale() const { return timecode_scale_; } + void set_timecode_scale(uint64_t scale) { timecode_scale_ = scale; } + uint64_t timecode_scale() const { return timecode_scale_; } void set_writing_app(const char* app); const char* writing_app() const { return writing_app_; } - void set_date_utc(int64 date_utc) { date_utc_ = date_utc; } - int64 date_utc() const { return date_utc_; } + void set_date_utc(int64_t date_utc) { date_utc_ = date_utc; } + int64_t date_utc() const { return date_utc_; } private: // Segment Information element names. @@ -1254,14 +1263,14 @@ class SegmentInfo { double duration_; // Set to libwebm-%d.%d.%d.%d, major, minor, build, revision. char* muxing_app_; - uint64 timecode_scale_; + uint64_t timecode_scale_; // Initially set to libwebm-%d.%d.%d.%d, major, minor, build, revision. char* writing_app_; // LLONG_MIN when DateUTC is not set. - int64 date_utc_; + int64_t date_utc_; // The file position of the duration element. - int64 duration_pos_; + int64_t duration_pos_; LIBWEBM_DISALLOW_COPY_AND_ASSIGN(SegmentInfo); }; @@ -1281,8 +1290,8 @@ class Segment { kBeforeClusters = 0x1 // Position Cues before Clusters }; - const static uint32 kDefaultDocTypeVersion = 2; - const static uint64 kDefaultMaxClusterDuration = 30000000000ULL; + const static uint32_t kDefaultDocTypeVersion = 2; + const static uint64_t kDefaultMaxClusterDuration = 30000000000ULL; Segment(); ~Segment(); @@ -1296,13 +1305,13 @@ class Segment { // error. |number| is the number to use for the track. |number| // must be >= 0. If |number| == 0 then the muxer will decide on the // track number. - Track* AddTrack(int32 number); + Track* AddTrack(int32_t number); // Adds a Vorbis audio track to the segment. Returns the number of the track // on success, 0 on error. |number| is the number to use for the audio track. // |number| must be >= 0. If |number| == 0 then the muxer will decide on // the track number. - uint64 AddAudioTrack(int32 sample_rate, int32 channels, int32 number); + uint64_t AddAudioTrack(int32_t sample_rate, int32_t channels, int32_t number); // Adds an empty chapter to the chapters of this segment. Returns // non-NULL on success. After adding the chapter, the caller should @@ -1318,7 +1327,7 @@ class Segment { // nanoseconds of the cue's time. |track| is the Track of the Cue. This // function must be called after AddFrame to calculate the correct // BlockNumber for the CuePoint. Returns true on success. - bool AddCuePoint(uint64 timestamp, uint64 track); + bool AddCuePoint(uint64_t timestamp, uint64_t track); // Adds a frame to be output in the file. Returns true on success. // Inputs: @@ -1328,8 +1337,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* data, uint64 length, uint64 track_number, - uint64 timestamp_ns, bool is_key); + bool AddFrame(const uint8_t* data, uint64_t length, uint64_t track_number, + uint64_t timestamp_ns, bool is_key); // Writes a frame of metadata to the output medium; returns true on // success. @@ -1345,8 +1354,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* data, uint64 length, uint64 track_number, - uint64 timestamp_ns, uint64 duration_ns); + bool AddMetadata(const uint8_t* data, uint64_t length, uint64_t track_number, + uint64_t timestamp_ns, uint64_t duration_ns); // Writes a frame with additional data to the output medium; returns true on // success. @@ -1361,10 +1370,11 @@ 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* data, uint64 length, - const uint8* additional, uint64 additional_length, - uint64 add_id, uint64 track_number, - uint64 timestamp, bool is_key); + bool AddFrameWithAdditional(const uint8_t* data, uint64_t length, + const uint8_t* additional, + uint64_t additional_length, uint64_t add_id, + uint64_t track_number, uint64_t timestamp, + bool is_key); // Writes a frame with DiscardPadding to the output medium; returns true on // success. @@ -1377,9 +1387,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 AddFrameWithDiscardPadding(const uint8* data, uint64 length, - int64 discard_padding, uint64 track_number, - uint64 timestamp, bool is_key); + bool AddFrameWithDiscardPadding(const uint8_t* data, uint64_t length, + int64_t discard_padding, + uint64_t track_number, uint64_t 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. @@ -1391,7 +1402,7 @@ class Segment { // success, 0 on error. |number| is the number to use for the video track. // |number| must be >= 0. If |number| == 0 then the muxer will decide on // the track number. - uint64 AddVideoTrack(int32 width, int32 height, int32 number); + uint64_t AddVideoTrack(int32_t width, int32_t height, int32_t number); // This function must be called after Finalize() if you need a copy of the // output with Cues written before the Clusters. It will return false if the @@ -1410,7 +1421,7 @@ class Segment { // Sets which track to use for the Cues element. Must have added the track // before calling this function. Returns true on success. |track_number| is // returned by the Add track functions. - bool CuesTrack(uint64 track_number); + bool CuesTrack(uint64_t track_number); // This will force the muxer to create a new Cluster when the next frame is // added. @@ -1430,7 +1441,7 @@ class Segment { // Search the Tracks and return the track that matches |track_number|. // Returns NULL if there is no track match. - Track* GetTrackByNumber(uint64 track_number) const; + Track* GetTrackByNumber(uint64_t track_number) const; // Toggles whether to output a cues element. void OutputCues(bool output_cues); @@ -1450,15 +1461,15 @@ class Segment { bool SetChunking(bool chunking, const char* filename); bool chunking() const { return chunking_; } - uint64 cues_track() const { return cues_track_; } - void set_max_cluster_duration(uint64 max_cluster_duration) { + uint64_t cues_track() const { return cues_track_; } + void set_max_cluster_duration(uint64_t max_cluster_duration) { max_cluster_duration_ = max_cluster_duration; } - uint64 max_cluster_duration() const { return max_cluster_duration_; } - void set_max_cluster_size(uint64 max_cluster_size) { + uint64_t max_cluster_duration() const { return max_cluster_duration_; } + void set_max_cluster_size(uint64_t max_cluster_size) { max_cluster_size_ = max_cluster_size; } - uint64 max_cluster_size() const { return max_cluster_size_; } + uint64_t max_cluster_size() const { return max_cluster_size_; } void set_mode(Mode mode) { mode_ = mode; } Mode mode() const { return mode_; } CuesPosition cues_position() const { return cues_position_; } @@ -1482,7 +1493,7 @@ class Segment { // Returns the maximum offset within the segment's payload. When chunking // this function is needed to determine offsets of elements within the // chunked files. Returns -1 on error. - int64 MaxOffset(); + int64_t MaxOffset(); // Adds the frame to our frame array. bool QueueFrame(Frame* frame); @@ -1494,7 +1505,7 @@ class Segment { // Output all frames that are queued that have an end time that is less // then |timestamp|. Returns true on success and if there are no frames // queued. - bool WriteFramesLessThan(uint64 timestamp); + bool WriteFramesLessThan(uint64_t timestamp); // Outputs the segment header, Segment Information element, SeekHead element, // and Tracks element to |writer_|. @@ -1508,16 +1519,17 @@ class Segment { // 0 = do not create a new cluster, and write frame to the existing cluster // 1 = create a new cluster, and write frame to that new cluster // 2 = create a new cluster, and re-run test - int TestFrame(uint64 track_num, uint64 timestamp_ns, bool key) const; + int TestFrame(uint64_t track_num, uint64_t timestamp_ns, bool key) const; // Create a new cluster, using the earlier of the first enqueued // frame, or the indicated time. Returns true on success. - bool MakeNewCluster(uint64 timestamp_ns); + bool MakeNewCluster(uint64_t timestamp_ns); // Checks whether a new cluster needs to be created, and if so // creates a new cluster. Returns false if creation of a new cluster // was necessary but creation was not successful. - bool DoNewClusterProcessing(uint64 track_num, uint64 timestamp_ns, bool key); + bool DoNewClusterProcessing(uint64_t track_num, uint64_t timestamp_ns, + bool key); // Adjusts Cue Point values (to place Cues before Clusters) so that they // reflect the correct offsets. @@ -1531,7 +1543,8 @@ class Segment { // accounted for. // index - index in the list of Cues which is currently being adjusted. // cue_size - sum of size of all the CuePoint elements. - void MoveCuesBeforeClustersHelper(uint64 diff, int index, uint64* cue_size); + void MoveCuesBeforeClustersHelper(uint64_t diff, int index, + uint64_t* cue_size); // Seeds the random number generator used to make UIDs. unsigned int seed_; @@ -1570,22 +1583,22 @@ class Segment { char* chunking_base_name_; // File position offset where the Clusters end. - int64 cluster_end_offset_; + int64_t cluster_end_offset_; // List of clusters. Cluster** cluster_list_; // Number of cluster pointers allocated in the cluster list. - int32 cluster_list_capacity_; + int32_t cluster_list_capacity_; // Number of clusters in the cluster list. - int32 cluster_list_size_; + int32_t cluster_list_size_; // Indicates whether Cues should be written before or after Clusters CuesPosition cues_position_; // Track number that is associated with the cues element for this segment. - uint64 cues_track_; + uint64_t cues_track_; // Tells the muxer to force a new cluster on the next Block. bool force_new_cluster_; @@ -1597,10 +1610,10 @@ class Segment { Frame** frames_; // Number of frame pointers allocated in the frame list. - int32 frames_capacity_; + int32_t frames_capacity_; // Number of frames in the frame list. - int32 frames_size_; + int32_t frames_size_; // Flag telling if a video track has been added to the segment. bool has_video_; @@ -1609,23 +1622,23 @@ class Segment { bool header_written_; // Duration of the last block in nanoseconds. - uint64 last_block_duration_; + uint64_t last_block_duration_; // Last timestamp in nanoseconds added to a cluster. - uint64 last_timestamp_; + uint64_t last_timestamp_; // Last timestamp in nanoseconds by track number added to a cluster. - uint64 last_track_timestamp_[kMaxTrackNumber]; + uint64_t last_track_timestamp_[kMaxTrackNumber]; // Maximum time in nanoseconds for a cluster duration. This variable is a // guideline and some clusters may have a longer duration. Default is 30 // seconds. - uint64 max_cluster_duration_; + uint64_t max_cluster_duration_; // Maximum size in bytes for a cluster. This variable is a guideline and // some clusters may have a larger size. Default is 0 which signifies that // the muxer will decide the size. - uint64 max_cluster_size_; + uint64_t max_cluster_size_; // The mode that segment is in. If set to |kLive| the writer must not // seek backwards. @@ -1644,20 +1657,20 @@ class Segment { // The size of the EBML header, used to validate the header if // WriteEbmlHeader() is called more than once. - int32 ebml_header_size_; + int32_t ebml_header_size_; // The file position of the segment's payload. - int64 payload_pos_; + int64_t payload_pos_; // The file position of the element's size. - int64 size_position_; + int64_t size_position_; // Current DocTypeVersion (|doc_type_version_|) and that written in // WriteSegmentHeader(). // WriteEbmlHeader() will be called from Finalize() if |doc_type_version_| // differs from |doc_type_version_written_|. - uint32 doc_type_version_; - uint32 doc_type_version_written_; + uint32_t doc_type_version_; + uint32_t doc_type_version_written_; // Pointer to the writer objects. Not owned by this class. IMkvWriter* writer_cluster_; diff --git a/mkvmuxertypes.hpp b/mkvmuxertypes.hpp index d91dd06..55b4df9 100644 --- a/mkvmuxertypes.hpp +++ b/mkvmuxertypes.hpp @@ -16,17 +16,4 @@ TypeName(const TypeName&); \ void operator=(const TypeName&) -namespace libwebm { - -// TODO(tomfinegan): These types are no longer necessary: drop these, and use -// cstdint/stdint.h types. -typedef unsigned char uint8; -typedef short int16; -typedef int int32; -typedef unsigned int uint32; -typedef long long int64; -typedef unsigned long long uint64; - -} // namespace libwebm - #endif // MKVMUXERTYPES_HPP diff --git a/mkvmuxerutil.cpp b/mkvmuxerutil.cpp index b4fc282..dbb5d4a 100644 --- a/mkvmuxerutil.cpp +++ b/mkvmuxerutil.cpp @@ -12,6 +12,8 @@ #include #endif +#include + #include #include #include @@ -37,14 +39,14 @@ namespace { // Date elements are always 8 octets in size. const int kDateElementSize = 8; -uint64 WriteBlock(IMkvWriter* writer, const Frame* const frame, int64 timecode, - uint64 timecode_scale) { - uint64 block_additional_elem_size = 0; - uint64 block_addid_elem_size = 0; - uint64 block_more_payload_size = 0; - uint64 block_more_elem_size = 0; - uint64 block_additions_payload_size = 0; - uint64 block_additions_elem_size = 0; +uint64_t WriteBlock(IMkvWriter* writer, const Frame* const frame, + int64_t timecode, uint64_t timecode_scale) { + uint64_t block_additional_elem_size = 0; + uint64_t block_addid_elem_size = 0; + uint64_t block_more_payload_size = 0; + uint64_t block_more_elem_size = 0; + uint64_t block_additions_payload_size = 0; + uint64_t block_additions_elem_size = 0; if (frame->additional()) { block_additional_elem_size = EbmlElementSize( kMkvBlockAdditional, frame->additional(), frame->additional_length()); @@ -62,30 +64,30 @@ uint64 WriteBlock(IMkvWriter* writer, const Frame* const frame, int64 timecode, block_additions_payload_size; } - uint64 discard_padding_elem_size = 0; + uint64_t discard_padding_elem_size = 0; if (frame->discard_padding() != 0) { discard_padding_elem_size = EbmlElementSize(kMkvDiscardPadding, frame->discard_padding()); } - const uint64 reference_block_timestamp = + const uint64_t reference_block_timestamp = frame->reference_block_timestamp() / timecode_scale; - uint64 reference_block_elem_size = 0; + uint64_t reference_block_elem_size = 0; if (!frame->is_key()) { reference_block_elem_size = EbmlElementSize(kMkvReferenceBlock, reference_block_timestamp); } - const uint64 duration = frame->duration() / timecode_scale; - uint64 block_duration_elem_size = 0; + const uint64_t duration = frame->duration() / timecode_scale; + uint64_t block_duration_elem_size = 0; if (duration > 0) block_duration_elem_size = EbmlElementSize(kMkvBlockDuration, duration); - const uint64 block_payload_size = 4 + frame->length(); - const uint64 block_elem_size = + const uint64_t block_payload_size = 4 + frame->length(); + const uint64_t block_elem_size = EbmlMasterElementSize(kMkvBlock, block_payload_size) + block_payload_size; - const uint64 block_group_payload_size = + const uint64_t block_group_payload_size = block_elem_size + block_additions_elem_size + block_duration_elem_size + discard_padding_elem_size + reference_block_elem_size; @@ -107,7 +109,7 @@ uint64 WriteBlock(IMkvWriter* writer, const Frame* const frame, int64 timecode, if (SerializeInt(writer, 0, 1)) return 0; - if (writer->Write(frame->frame(), static_cast(frame->length()))) + if (writer->Write(frame->frame(), static_cast(frame->length()))) return 0; if (frame->additional()) { @@ -146,29 +148,29 @@ uint64 WriteBlock(IMkvWriter* writer, const Frame* const frame, int64 timecode, block_group_payload_size; } -uint64 WriteSimpleBlock(IMkvWriter* writer, const Frame* const frame, - int64 timecode) { +uint64_t WriteSimpleBlock(IMkvWriter* writer, const Frame* const frame, + int64_t timecode) { if (WriteID(writer, kMkvSimpleBlock)) return 0; - const int32 size = static_cast(frame->length()) + 4; + const int32_t size = static_cast(frame->length()) + 4; if (WriteUInt(writer, size)) return 0; - if (WriteUInt(writer, static_cast(frame->track_number()))) + if (WriteUInt(writer, static_cast(frame->track_number()))) return 0; if (SerializeInt(writer, timecode, 2)) return 0; - uint64 flags = 0; + uint64_t flags = 0; if (frame->is_key()) flags |= 0x80; if (SerializeInt(writer, flags, 1)) return 0; - if (writer->Write(frame->frame(), static_cast(frame->length()))) + if (writer->Write(frame->frame(), static_cast(frame->length()))) return 0; return GetUIntSize(kMkvSimpleBlock) + GetCodedUIntSize(size) + 4 + @@ -177,7 +179,7 @@ uint64 WriteSimpleBlock(IMkvWriter* writer, const Frame* const frame, } // namespace -int32 GetCodedUIntSize(uint64 value) { +int32_t GetCodedUIntSize(uint64_t value) { if (value < 0x000000000000007FULL) return 1; else if (value < 0x0000000000003FFFULL) @@ -195,7 +197,7 @@ int32 GetCodedUIntSize(uint64 value) { return 8; } -int32 GetUIntSize(uint64 value) { +int32_t GetUIntSize(uint64_t value) { if (value < 0x0000000000000100ULL) return 1; else if (value < 0x0000000000010000ULL) @@ -213,16 +215,16 @@ int32 GetUIntSize(uint64 value) { return 8; } -int32 GetIntSize(int64 value) { +int32_t GetIntSize(int64_t value) { // Doubling the requested value ensures positive values with their high bit // set are written with 0-padding to avoid flipping the signedness. - const uint64 v = (value < 0) ? value ^ -1LL : value; + const uint64_t v = (value < 0) ? value ^ -1LL : value; return GetUIntSize(2 * v); } -uint64 EbmlMasterElementSize(uint64 type, uint64 value) { +uint64_t EbmlMasterElementSize(uint64_t type, uint64_t value) { // Size of EBML ID - int32 ebml_size = GetUIntSize(type); + int32_t ebml_size = GetUIntSize(type); // Datasize ebml_size += GetCodedUIntSize(value); @@ -230,9 +232,9 @@ uint64 EbmlMasterElementSize(uint64 type, uint64 value) { return ebml_size; } -uint64 EbmlElementSize(uint64 type, int64 value) { +uint64_t EbmlElementSize(uint64_t type, int64_t value) { // Size of EBML ID - int32 ebml_size = GetUIntSize(type); + int32_t ebml_size = GetUIntSize(type); // Datasize ebml_size += GetIntSize(value); @@ -243,9 +245,9 @@ uint64 EbmlElementSize(uint64 type, int64 value) { return ebml_size; } -uint64 EbmlElementSize(uint64 type, uint64 value) { +uint64_t EbmlElementSize(uint64_t type, uint64_t value) { // Size of EBML ID - int32 ebml_size = GetUIntSize(type); + int32_t ebml_size = GetUIntSize(type); // Datasize ebml_size += GetUIntSize(value); @@ -256,9 +258,9 @@ uint64 EbmlElementSize(uint64 type, uint64 value) { return ebml_size; } -uint64 EbmlElementSize(uint64 type, float /* value */) { +uint64_t EbmlElementSize(uint64_t type, float /* value */) { // Size of EBML ID - uint64 ebml_size = GetUIntSize(type); + uint64_t ebml_size = GetUIntSize(type); // Datasize ebml_size += sizeof(float); @@ -269,12 +271,12 @@ uint64 EbmlElementSize(uint64 type, float /* value */) { return ebml_size; } -uint64 EbmlElementSize(uint64 type, const char* value) { +uint64_t EbmlElementSize(uint64_t type, const char* value) { if (!value) return 0; // Size of EBML ID - uint64 ebml_size = GetUIntSize(type); + uint64_t ebml_size = GetUIntSize(type); // Datasize ebml_size += strlen(value); @@ -285,12 +287,12 @@ uint64 EbmlElementSize(uint64 type, const char* value) { return ebml_size; } -uint64 EbmlElementSize(uint64 type, const uint8* value, uint64 size) { +uint64_t EbmlElementSize(uint64_t type, const uint8_t* value, uint64_t size) { if (!value) return 0; // Size of EBML ID - uint64 ebml_size = GetUIntSize(type); + uint64_t ebml_size = GetUIntSize(type); // Datasize ebml_size += size; @@ -301,9 +303,9 @@ uint64 EbmlElementSize(uint64 type, const uint8* value, uint64 size) { return ebml_size; } -uint64 EbmlDateElementSize(uint64 type) { +uint64_t EbmlDateElementSize(uint64_t type) { // Size of EBML ID - uint64 ebml_size = GetUIntSize(type); + uint64_t ebml_size = GetUIntSize(type); // Datasize ebml_size += kDateElementSize; @@ -314,18 +316,18 @@ uint64 EbmlDateElementSize(uint64 type) { return ebml_size; } -int32 SerializeInt(IMkvWriter* writer, int64 value, int32 size) { +int32_t SerializeInt(IMkvWriter* writer, int64_t value, int32_t size) { if (!writer || size < 1 || size > 8) return -1; - for (int32 i = 1; i <= size; ++i) { - const int32 byte_count = size - i; - const int32 bit_count = byte_count * 8; + for (int32_t i = 1; i <= size; ++i) { + const int32_t byte_count = size - i; + const int32_t bit_count = byte_count * 8; - const int64 bb = value >> bit_count; - const uint8 b = static_cast(bb); + const int64_t bb = value >> bit_count; + const uint8_t b = static_cast(bb); - const int32 status = writer->Write(&b, 1); + const int32_t status = writer->Write(&b, 1); if (status < 0) return status; @@ -334,26 +336,26 @@ int32 SerializeInt(IMkvWriter* writer, int64 value, int32 size) { return 0; } -int32 SerializeFloat(IMkvWriter* writer, float f) { +int32_t SerializeFloat(IMkvWriter* writer, float f) { if (!writer) return -1; - assert(sizeof(uint32) == sizeof(float)); + assert(sizeof(uint32_t) == sizeof(float)); // This union is merely used to avoid a reinterpret_cast from float& to // uint32& which will result in violation of strict aliasing. union U32 { - uint32 u32; + uint32_t u32; float f; } value; value.f = f; - for (int32 i = 1; i <= 4; ++i) { - const int32 byte_count = 4 - i; - const int32 bit_count = byte_count * 8; + for (int32_t i = 1; i <= 4; ++i) { + const int32_t byte_count = 4 - i; + const int32_t bit_count = byte_count * 8; - const uint8 byte = static_cast(value.u32 >> bit_count); + const uint8_t byte = static_cast(value.u32 >> bit_count); - const int32 status = writer->Write(&byte, 1); + const int32_t status = writer->Write(&byte, 1); if (status < 0) return status; @@ -362,21 +364,21 @@ int32 SerializeFloat(IMkvWriter* writer, float f) { return 0; } -int32 WriteUInt(IMkvWriter* writer, uint64 value) { +int32_t WriteUInt(IMkvWriter* writer, uint64_t value) { if (!writer) return -1; - int32 size = GetCodedUIntSize(value); + int32_t size = GetCodedUIntSize(value); return WriteUIntSize(writer, value, size); } -int32 WriteUIntSize(IMkvWriter* writer, uint64 value, int32 size) { +int32_t WriteUIntSize(IMkvWriter* writer, uint64_t value, int32_t size) { if (!writer || size < 0 || size > 8) return -1; if (size > 0) { - const uint64 bit = 1LL << (size * 7); + const uint64_t bit = 1LL << (size * 7); if (value > (bit - 2)) return -1; @@ -384,11 +386,11 @@ int32 WriteUIntSize(IMkvWriter* writer, uint64 value, int32 size) { value |= bit; } else { size = 1; - int64 bit; + int64_t bit; for (;;) { bit = 1LL << (size * 7); - const uint64 max = bit - 2; + const uint64_t max = bit - 2; if (value <= max) break; @@ -405,18 +407,18 @@ int32 WriteUIntSize(IMkvWriter* writer, uint64 value, int32 size) { return SerializeInt(writer, value, size); } -int32 WriteID(IMkvWriter* writer, uint64 type) { +int32_t WriteID(IMkvWriter* writer, uint64_t type) { if (!writer) return -1; writer->ElementStartNotify(type, writer->Position()); - const int32 size = GetUIntSize(type); + const int32_t size = GetUIntSize(type); return SerializeInt(writer, type, size); } -bool WriteEbmlMasterElement(IMkvWriter* writer, uint64 type, uint64 size) { +bool WriteEbmlMasterElement(IMkvWriter* writer, uint64_t type, uint64_t size) { if (!writer) return false; @@ -429,41 +431,41 @@ bool WriteEbmlMasterElement(IMkvWriter* writer, uint64 type, uint64 size) { return true; } -bool WriteEbmlElement(IMkvWriter* writer, uint64 type, uint64 value) { +bool WriteEbmlElement(IMkvWriter* writer, uint64_t type, uint64_t value) { if (!writer) return false; if (WriteID(writer, type)) return false; - const uint64 size = GetUIntSize(value); + const uint64_t size = GetUIntSize(value); if (WriteUInt(writer, size)) return false; - if (SerializeInt(writer, value, static_cast(size))) + if (SerializeInt(writer, value, static_cast(size))) return false; return true; } -bool WriteEbmlElement(IMkvWriter* writer, uint64 type, int64 value) { +bool WriteEbmlElement(IMkvWriter* writer, uint64_t type, int64_t value) { if (!writer) return false; if (WriteID(writer, type)) return 0; - const uint64 size = GetIntSize(value); + const uint64_t size = GetIntSize(value); if (WriteUInt(writer, size)) return false; - if (SerializeInt(writer, value, static_cast(size))) + if (SerializeInt(writer, value, static_cast(size))) return false; return true; } -bool WriteEbmlElement(IMkvWriter* writer, uint64 type, float value) { +bool WriteEbmlElement(IMkvWriter* writer, uint64_t type, float value) { if (!writer) return false; @@ -479,25 +481,25 @@ bool WriteEbmlElement(IMkvWriter* writer, uint64 type, float value) { return true; } -bool WriteEbmlElement(IMkvWriter* writer, uint64 type, const char* value) { +bool WriteEbmlElement(IMkvWriter* writer, uint64_t type, const char* value) { if (!writer || !value) return false; if (WriteID(writer, type)) return false; - const uint64 length = strlen(value); + const uint64_t length = strlen(value); if (WriteUInt(writer, length)) return false; - if (writer->Write(value, static_cast(length))) + if (writer->Write(value, static_cast(length))) return false; return true; } -bool WriteEbmlElement(IMkvWriter* writer, uint64 type, const uint8* value, - uint64 size) { +bool WriteEbmlElement(IMkvWriter* writer, uint64_t type, const uint8_t* value, + uint64_t size) { if (!writer || !value || size < 1) return false; @@ -507,13 +509,13 @@ bool WriteEbmlElement(IMkvWriter* writer, uint64 type, const uint8* value, if (WriteUInt(writer, size)) return false; - if (writer->Write(value, static_cast(size))) + if (writer->Write(value, static_cast(size))) return false; return true; } -bool WriteEbmlDateElement(IMkvWriter* writer, uint64 type, int64 value) { +bool WriteEbmlDateElement(IMkvWriter* writer, uint64_t type, int64_t value) { if (!writer) return false; @@ -529,8 +531,8 @@ bool WriteEbmlDateElement(IMkvWriter* writer, uint64 type, int64 value) { return true; } -uint64 WriteFrame(IMkvWriter* writer, const Frame* const frame, - Cluster* cluster) { +uint64_t WriteFrame(IMkvWriter* writer, const Frame* const frame, + Cluster* cluster) { if (!writer || !frame || !frame->IsValid() || !cluster || !cluster->timecode_scale()) return 0; @@ -539,7 +541,7 @@ uint64 WriteFrame(IMkvWriter* writer, const Frame* const frame, // timecode for the cluster itself (remember that block timecode // is a signed, 16-bit integer). However, as a simplification we // only permit non-negative cluster-relative timecodes for blocks. - const int64 relative_timecode = cluster->GetRelativeTimecode( + const int64_t relative_timecode = cluster->GetRelativeTimecode( frame->timestamp() / cluster->timecode_scale()); if (relative_timecode < 0 || relative_timecode > kMaxBlockTimecode) return 0; @@ -550,19 +552,19 @@ uint64 WriteFrame(IMkvWriter* writer, const Frame* const frame, cluster->timecode_scale()); } -uint64 WriteVoidElement(IMkvWriter* writer, uint64 size) { +uint64_t WriteVoidElement(IMkvWriter* writer, uint64_t size) { if (!writer) return false; // Subtract one for the void ID and the coded size. - uint64 void_entry_size = size - 1 - GetCodedUIntSize(size - 1); - uint64 void_size = + uint64_t void_entry_size = size - 1 - GetCodedUIntSize(size - 1); + uint64_t void_size = EbmlMasterElementSize(kMkvVoid, void_entry_size) + void_entry_size; if (void_size != size) return 0; - const int64 payload_position = writer->Position(); + const int64_t payload_position = writer->Position(); if (payload_position < 0) return 0; @@ -572,29 +574,30 @@ uint64 WriteVoidElement(IMkvWriter* writer, uint64 size) { if (WriteUInt(writer, void_entry_size)) return 0; - const uint8 value = 0; - for (int32 i = 0; i < static_cast(void_entry_size); ++i) { + const uint8_t value = 0; + for (int32_t i = 0; i < static_cast(void_entry_size); ++i) { if (writer->Write(&value, 1)) return 0; } - const int64 stop_position = writer->Position(); + const int64_t stop_position = writer->Position(); if (stop_position < 0 || - stop_position - payload_position != static_cast(void_size)) + stop_position - payload_position != static_cast(void_size)) return 0; return void_size; } -void GetVersion(int32* major, int32* minor, int32* build, int32* revision) { +void GetVersion(int32_t* major, int32_t* minor, int32_t* build, + int32_t* revision) { *major = 0; *minor = 2; *build = 1; *revision = 0; } -uint64 MakeUID(unsigned int* seed) { - uint64 uid = 0; +uint64_t MakeUID(unsigned int* seed) { + uint64_t uid = 0; #ifdef __MINGW32__ srand(*seed); @@ -606,21 +609,21 @@ uint64 MakeUID(unsigned int* seed) { // TODO(fgalligan): Move random number generation to platform specific code. #ifdef _MSC_VER (void)seed; - const int32 nn = rand(); + const int32_t nn = rand(); #elif __ANDROID__ - int32 temp_num = 1; + int32_t temp_num = 1; int fd = open("/dev/urandom", O_RDONLY); if (fd != -1) { read(fd, &temp_num, sizeof(int32)); close(fd); } - const int32 nn = temp_num; + const int32_t nn = temp_num; #elif defined __MINGW32__ - const int32 nn = rand(); + const int32_t nn = rand(); #else - const int32 nn = rand_r(seed); + const int32_t nn = rand_r(seed); #endif - const int32 n = 0xFF & (nn >> 4); // throw away low-order bits + const int32_t n = 0xFF & (nn >> 4); // throw away low-order bits uid |= n; } diff --git a/mkvmuxerutil.hpp b/mkvmuxerutil.hpp index cadc097..4db2df7 100644 --- a/mkvmuxerutil.hpp +++ b/mkvmuxerutil.hpp @@ -5,11 +5,10 @@ // tree. An additional intellectual property rights grant can be found // in the file PATENTS. All contributing project authors may // be found in the AUTHORS file in the root of the source tree. - #ifndef MKVMUXERUTIL_HPP #define MKVMUXERUTIL_HPP -#include "mkvmuxertypes.hpp" +#include namespace libwebm { namespace mkvmuxer { @@ -17,67 +16,68 @@ class Cluster; class Frame; class IMkvWriter; -const uint64 kEbmlUnknownValue = 0x01FFFFFFFFFFFFFFULL; -const int64 kMaxBlockTimecode = 0x07FFFLL; +const uint64_t kEbmlUnknownValue = 0x01FFFFFFFFFFFFFFULL; +const int64_t kMaxBlockTimecode = 0x07FFFLL; // Writes out |value| in Big Endian order. Returns 0 on success. -int32 SerializeInt(IMkvWriter* writer, int64 value, int32 size); +int32_t SerializeInt(IMkvWriter* writer, int64_t value, int32_t size); // Returns the size in bytes of the element. -int32 GetUIntSize(uint64 value); -int32 GetIntSize(int64 value); -int32 GetCodedUIntSize(uint64 value); -uint64 EbmlMasterElementSize(uint64 type, uint64 value); -uint64 EbmlElementSize(uint64 type, int64 value); -uint64 EbmlElementSize(uint64 type, uint64 value); -uint64 EbmlElementSize(uint64 type, float value); -uint64 EbmlElementSize(uint64 type, const char* value); -uint64 EbmlElementSize(uint64 type, const uint8* value, uint64 size); -uint64 EbmlDateElementSize(uint64 type); +int32_t GetUIntSize(uint64_t value); +int32_t GetIntSize(int64_t value); +int32_t GetCodedUIntSize(uint64_t value); +uint64_t EbmlMasterElementSize(uint64_t type, uint64_t value); +uint64_t EbmlElementSize(uint64_t type, int64_t value); +uint64_t EbmlElementSize(uint64_t type, uint64_t value); +uint64_t EbmlElementSize(uint64_t type, float value); +uint64_t EbmlElementSize(uint64_t type, const char* value); +uint64_t EbmlElementSize(uint64_t type, const uint8_t* value, uint64_t size); +uint64_t EbmlDateElementSize(uint64_t type); // Creates an EBML coded number from |value| and writes it out. The size of // the coded number is determined by the value of |value|. |value| must not // be in a coded form. Returns 0 on success. -int32 WriteUInt(IMkvWriter* writer, uint64 value); +int32_t WriteUInt(IMkvWriter* writer, uint64_t value); // Creates an EBML coded number from |value| and writes it out. The size of // the coded number is determined by the value of |size|. |value| must not // be in a coded form. Returns 0 on success. -int32 WriteUIntSize(IMkvWriter* writer, uint64 value, int32 size); +int32_t WriteUIntSize(IMkvWriter* writer, uint64_t value, int32_t size); // Output an Mkv master element. Returns true if the element was written. -bool WriteEbmlMasterElement(IMkvWriter* writer, uint64 value, uint64 size); +bool WriteEbmlMasterElement(IMkvWriter* writer, uint64_t value, uint64_t size); // Outputs an Mkv ID, calls |IMkvWriter::ElementStartNotify|, and passes the // ID to |SerializeInt|. Returns 0 on success. -int32 WriteID(IMkvWriter* writer, uint64 type); +int32_t WriteID(IMkvWriter* writer, uint64_t type); // Output an Mkv non-master element. Returns true if the element was written. -bool WriteEbmlElement(IMkvWriter* writer, uint64 type, uint64 value); -bool WriteEbmlElement(IMkvWriter* writer, uint64 type, int64 value); -bool WriteEbmlElement(IMkvWriter* writer, uint64 type, float value); -bool WriteEbmlElement(IMkvWriter* writer, uint64 type, const char* value); -bool WriteEbmlElement(IMkvWriter* writer, uint64 type, const uint8* value, - uint64 size); -bool WriteEbmlDateElement(IMkvWriter* writer, uint64 type, int64 value); +bool WriteEbmlElement(IMkvWriter* writer, uint64_t type, uint64_t value); +bool WriteEbmlElement(IMkvWriter* writer, uint64_t type, int64_t value); +bool WriteEbmlElement(IMkvWriter* writer, uint64_t type, float value); +bool WriteEbmlElement(IMkvWriter* writer, uint64_t type, const char* value); +bool WriteEbmlElement(IMkvWriter* writer, uint64_t type, const uint8_t* value, + uint64_t size); +bool WriteEbmlDateElement(IMkvWriter* writer, uint64_t type, int64_t value); // Output a Mkv Frame. It decides the correct element to write (Block vs // SimpleBlock) based on the parameters of the Frame. -uint64 WriteFrame(IMkvWriter* writer, const Frame* const frame, - Cluster* cluster); +uint64_t WriteFrame(IMkvWriter* writer, const Frame* const frame, + Cluster* cluster); // Output a void element. |size| must be the entire size in bytes that will be // void. The function will calculate the size of the void header and subtract // it from |size|. -uint64 WriteVoidElement(IMkvWriter* writer, uint64 size); +uint64_t WriteVoidElement(IMkvWriter* writer, uint64_t size); // Returns the version number of the muxer in |major|, |minor|, |build|, // and |revision|. -void GetVersion(int32* major, int32* minor, int32* build, int32* revision); +void GetVersion(int32_t* major, int32_t* minor, int32_t* build, + int32_t* revision); // Returns a random number to be used for UID, using |seed| to seed // the random-number generator (see POSIX rand_r() for semantics). -uint64 MakeUID(unsigned int* seed); +uint64_t MakeUID(unsigned int* seed); } // namespace mkvmuxer } // namespace libwebm diff --git a/mkvwriter.cpp b/mkvwriter.cpp index 47061da..597485c 100644 --- a/mkvwriter.cpp +++ b/mkvwriter.cpp @@ -21,7 +21,7 @@ MkvWriter::MkvWriter(FILE* fp) : file_(fp), writer_owns_file_(false) {} MkvWriter::~MkvWriter() { Close(); } -int32 MkvWriter::Write(const void* buffer, uint32 length) { +int32_t MkvWriter::Write(const void* buffer, uint32_t length) { if (!file_) return -1; @@ -60,7 +60,7 @@ void MkvWriter::Close() { file_ = NULL; } -int64 MkvWriter::Position() const { +int64_t MkvWriter::Position() const { if (!file_) return 0; @@ -71,7 +71,7 @@ int64 MkvWriter::Position() const { #endif } -int32 MkvWriter::Position(int64 position) { +int32_t MkvWriter::Position(int64_t position) { if (!file_) return -1; @@ -84,7 +84,7 @@ int32 MkvWriter::Position(int64 position) { bool MkvWriter::Seekable() const { return true; } -void MkvWriter::ElementStartNotify(uint64, int64) {} +void MkvWriter::ElementStartNotify(uint64_t, int64_t) {} } // namespace mkvmuxer } // namespace libwebm diff --git a/mkvwriter.hpp b/mkvwriter.hpp index 9ab68ae..13fcb6e 100644 --- a/mkvwriter.hpp +++ b/mkvwriter.hpp @@ -25,11 +25,11 @@ class MkvWriter : public IMkvWriter { virtual ~MkvWriter(); // IMkvWriter interface - virtual int64 Position() const; - virtual int32 Position(int64 position); + virtual int64_t Position() const; + virtual int32_t Position(int64_t position); virtual bool Seekable() const; - virtual int32 Write(const void* buffer, uint32 length); - virtual void ElementStartNotify(uint64 element_id, int64 position); + virtual int32_t Write(const void* buffer, uint32_t length); + virtual void ElementStartNotify(uint64_t element_id, int64_t position); // Creates and opens a file for writing. |filename| is the name of the file // to open. This function will overwrite the contents of |filename|. Returns diff --git a/sample_muxer.cpp b/sample_muxer.cpp index 37e04d0..c5845e4 100644 --- a/sample_muxer.cpp +++ b/sample_muxer.cpp @@ -5,6 +5,7 @@ // tree. An additional intellectual property rights grant can be found // in the file PATENTS. All contributing project authors may // be found in the AUTHORS file in the root of the source tree. +#include #include #include @@ -158,8 +159,8 @@ int main(int argc, char* argv[]) { bool cues_before_clusters = false; bool cues_on_video_track = true; bool cues_on_audio_track = false; - libwebm::uint64 max_cluster_duration = 0; - libwebm::uint64 max_cluster_size = 0; + uint64_t max_cluster_duration = 0; + uint64_t max_cluster_size = 0; bool switch_tracks = false; int audio_track_number = 0; // 0 tells muxer to decide. int video_track_number = 0; // 0 tells muxer to decide. @@ -170,9 +171,9 @@ int main(int argc, char* argv[]) { bool output_cues_block_number = true; - libwebm::uint64 display_width = 0; - libwebm::uint64 display_height = 0; - libwebm::uint64 stereo_mode = 0; + uint64_t display_width = 0; + uint64_t display_height = 0; + uint64_t stereo_mode = 0; metadata_files_t metadata_files; @@ -207,8 +208,7 @@ int main(int argc, char* argv[]) { cues_on_video_track = false; } else if (!strcmp("-max_cluster_duration", argv[i]) && i < argc_check) { const double seconds = strtod(argv[++i], &end); - max_cluster_duration = - static_cast(seconds * 1000000000.0); + max_cluster_duration = static_cast(seconds * 1000000000.0); } else if (!strcmp("-max_cluster_size", argv[i]) && i < argc_check) { max_cluster_size = strtol(argv[++i], &end, 10); } else if (!strcmp("-switch_tracks", argv[i]) && i < argc_check) { @@ -344,8 +344,8 @@ int main(int argc, char* argv[]) { const libwebm::mkvparser::Tracks* const parser_tracks = parser_segment->GetTracks(); unsigned long i = 0; - libwebm::uint64 vid_track = 0; // no track added - libwebm::uint64 aud_track = 0; // no track added + uint64_t vid_track = 0; // no track added + uint64_t aud_track = 0; // no track added using libwebm::mkvparser::Track; diff --git a/sample_muxer_metadata.cc b/sample_muxer_metadata.cc index 92fc3ff..cc871d4 100644 --- a/sample_muxer_metadata.cc +++ b/sample_muxer_metadata.cc @@ -33,7 +33,7 @@ bool SampleMuxerMetadata::Load(const char* file, Kind kind) { if (kind == kChapters) return LoadChapters(file); - uint64 track_num; + uint64_t track_num; if (!AddTrack(kind, &track_num)) { printf("Unable to add track for WebVTT file \"%s\"\n", file); @@ -58,7 +58,7 @@ bool SampleMuxerMetadata::AddChapters() { return true; } -bool SampleMuxerMetadata::Write(int64 time_ns) { +bool SampleMuxerMetadata::Write(int64_t time_ns) { typedef cues_set_t::iterator iter_t; iter_t i = cues_set_.begin(); @@ -174,8 +174,8 @@ bool SampleMuxerMetadata::AddChapter(const cue_t& cue) { const time_ms_t stop_time_ms = cue.stop_time.presentation(); enum { kNsPerMs = 1000000 }; - const uint64 start_time_ns = start_time_ms * kNsPerMs; - const uint64 stop_time_ns = stop_time_ms * kNsPerMs; + const uint64_t start_time_ns = start_time_ms * kNsPerMs; + const uint64_t stop_time_ns = stop_time_ms * kNsPerMs; chapter->set_time(*segment_, start_time_ns, stop_time_ns); @@ -203,7 +203,7 @@ bool SampleMuxerMetadata::AddChapter(const cue_t& cue) { return true; } -bool SampleMuxerMetadata::AddTrack(Kind kind, uint64* track_num) { +bool SampleMuxerMetadata::AddTrack(Kind kind, uint64_t* track_num) { *track_num = 0; // Track number value 0 means "let muxer choose track number" @@ -252,7 +252,7 @@ bool SampleMuxerMetadata::AddTrack(Kind kind, uint64* track_num) { } bool SampleMuxerMetadata::Parse(const char* file, Kind /* kind */, - uint64 track_num) { + uint64_t track_num) { libwebvtt::VttReader r; int e = r.Open(file); @@ -361,26 +361,26 @@ void SampleMuxerMetadata::WriteCuePayload(const cue_t::payload_t& payload, bool SampleMuxerMetadata::SortableCue::Write(mkvmuxer::Segment* segment) const { // Cue start time expressed in milliseconds - const int64 start_ms = cue.start_time.presentation(); + const int64_t start_ms = cue.start_time.presentation(); // Cue start time expressed in nanoseconds (MKV time) - const int64 start_ns = start_ms * 1000000; + const int64_t start_ns = start_ms * 1000000; // Cue stop time expressed in milliseconds - const int64 stop_ms = cue.stop_time.presentation(); + const int64_t stop_ms = cue.stop_time.presentation(); // Cue stop time expressed in nanonseconds - const int64 stop_ns = stop_ms * 1000000; + const int64_t stop_ns = stop_ms * 1000000; // Metadata blocks always specify the block duration. - const int64 duration_ns = stop_ns - start_ns; + const int64_t duration_ns = stop_ns - start_ns; std::string frame; MakeFrame(cue, &frame); - typedef const uint8* data_t; + typedef const uint8_t* data_t; const data_t buf = reinterpret_cast(frame.data()); - const uint64 len = frame.length(); + const uint64_t len = frame.length(); mkvmuxer::Frame muxer_frame; if (!muxer_frame.Init(buf, len)) diff --git a/sample_muxer_metadata.h b/sample_muxer_metadata.h index 379338a..3e20eec 100644 --- a/sample_muxer_metadata.h +++ b/sample_muxer_metadata.h @@ -9,6 +9,8 @@ #ifndef SAMPLE_MUXER_METADATA_H_ // NOLINT #define SAMPLE_MUXER_METADATA_H_ +#include + #include #include #include @@ -45,19 +47,19 @@ class SampleMuxerMetadata { // Write any WebVTT cues whose time is less or equal to |time_ns| as // a metadata block in its corresponding track. If |time_ns| is // negative, write all remaining cues. Returns false on error. - bool Write(int64 time_ns); + bool Write(int64_t time_ns); private: typedef libwebvtt::Cue cue_t; // Used to sort cues as they are loaded. struct SortableCue { - bool operator>(int64 time_ns) const { + bool operator>(int64_t time_ns) const { // Cue start time expressed in milliseconds - const int64 start_ms = cue.start_time.presentation(); + const int64_t start_ms = cue.start_time.presentation(); // Cue start time expressed in nanoseconds (MKV time) - const int64 start_ns = start_ms * 1000000; + const int64_t start_ns = start_ms * 1000000; return (start_ns > time_ns); } @@ -76,7 +78,7 @@ class SampleMuxerMetadata { // error. bool Write(mkvmuxer::Segment* segment) const; - uint64 track_num; + uint64_t track_num; cue_t cue; }; @@ -99,12 +101,12 @@ class SampleMuxerMetadata { // Add a metadata track to the segment having the indicated |kind|, // returning the |track_num| that has been chosen for this track. // Returns false on error. - bool AddTrack(Kind kind, uint64* track_num); + bool AddTrack(Kind kind, uint64_t* track_num); // Parse the WebVTT |file| having the indicated |kind| and // |track_num|, adding each parsed cue to cues set. Returns false // on error. - bool Parse(const char* file, Kind kind, uint64 track_num); + bool Parse(const char* file, Kind kind, uint64_t track_num); // Converts a WebVTT cue to a Matroska metadata block. static void MakeFrame(const cue_t& cue, std::string* frame); diff --git a/testing/muxer_tests.cc b/testing/muxer_tests.cc index 2e8143e..5d2cd7e 100644 --- a/testing/muxer_tests.cc +++ b/testing/muxer_tests.cc @@ -5,8 +5,9 @@ // tree. An additional intellectual property rights grant can be found // in the file PATENTS. All contributing project authors may // be found in the AUTHORS file in the root of the source tree. +#include + #include -#include #include #include #include @@ -20,7 +21,6 @@ #include "common/file_util.h" #include "common/libwebm_util.h" #include "mkvmuxer.hpp" -#include "mkvmuxertypes.hpp" #include "mkvparser/mkvreader.hpp" #include "mkvwriter.hpp" #include "testing/test_util.h" @@ -123,7 +123,7 @@ TEST_F(MuxerTest, SegmentInfo) { info->set_duration(2.345); EXPECT_STREQ(kAppString, info->muxing_app()); EXPECT_STREQ(kAppString, info->writing_app()); - EXPECT_EQ(static_cast(kTimeCodeScale), info->timecode_scale()); + EXPECT_EQ(static_cast(kTimeCodeScale), info->timecode_scale()); EXPECT_DOUBLE_EQ(2.345, info->duration()); AddVideoTrack(); @@ -141,19 +141,19 @@ TEST_F(MuxerTest, AddTracks) { VideoTrack* const video = dynamic_cast(segment_.GetTrackByNumber(kVideoTrackNumber)); ASSERT_TRUE(video != NULL); - EXPECT_EQ(static_cast(kWidth), video->width()); - EXPECT_EQ(static_cast(kHeight), video->height()); + EXPECT_EQ(static_cast(kWidth), video->width()); + EXPECT_EQ(static_cast(kHeight), video->height()); video->set_name(kTrackName); video->set_display_width(kWidth - 10); video->set_display_height(kHeight - 10); video->set_frame_rate(0.5); EXPECT_STREQ(kTrackName, video->name()); - const uint64 kDisplayWidth = kWidth - 10; + const uint64_t kDisplayWidth = kWidth - 10; EXPECT_EQ(kDisplayWidth, video->display_width()); - const uint64 kDisplayHeight = kHeight - 10; + const uint64_t kDisplayHeight = kHeight - 10; EXPECT_EQ(kDisplayHeight, video->display_height()); EXPECT_DOUBLE_EQ(0.5, video->frame_rate()); - EXPECT_EQ(static_cast(kVideoTrackNumber), video->uid()); + EXPECT_EQ(static_cast(kVideoTrackNumber), video->uid()); // Add an Audio Track const int aud_track = @@ -162,14 +162,14 @@ TEST_F(MuxerTest, AddTracks) { AudioTrack* const audio = dynamic_cast(segment_.GetTrackByNumber(aud_track)); EXPECT_EQ(kSampleRate, audio->sample_rate()); - EXPECT_EQ(static_cast(kChannels), audio->channels()); + EXPECT_EQ(static_cast(kChannels), audio->channels()); ASSERT_TRUE(audio != NULL); audio->set_name(kTrackName); audio->set_bit_depth(kBitDepth); audio->set_uid(kAudioTrackNumber); EXPECT_STREQ(kTrackName, audio->name()); - EXPECT_EQ(static_cast(kBitDepth), audio->bit_depth()); - EXPECT_EQ(static_cast(kAudioTrackNumber), audio->uid()); + EXPECT_EQ(static_cast(kBitDepth), audio->bit_depth()); + EXPECT_EQ(static_cast(kAudioTrackNumber), audio->uid()); AddDummyFrameAndFinalize(kVideoTrackNumber); CloseWriter(); @@ -487,7 +487,7 @@ TEST_F(MuxerTest, CuesBeforeClusters) { TEST_F(MuxerTest, MaxClusterSize) { EXPECT_TRUE(SegmentInit(false, false)); AddVideoTrack(); - const uint64 kMaxClusterSize = 20; + const uint64_t kMaxClusterSize = 20; segment_.set_max_cluster_size(kMaxClusterSize); EXPECT_EQ(kMaxClusterSize, segment_.max_cluster_size()); EXPECT_TRUE(segment_.AddFrame(dummy_data_, 1, kVideoTrackNumber, 0, false)); @@ -512,7 +512,7 @@ TEST_F(MuxerTest, MaxClusterSize) { TEST_F(MuxerTest, MaxClusterDuration) { EXPECT_TRUE(SegmentInit(false, false)); AddVideoTrack(); - const uint64 kMaxClusterDuration = 4000000; + const uint64_t kMaxClusterDuration = 4000000; segment_.set_max_cluster_duration(kMaxClusterDuration); EXPECT_EQ(kMaxClusterDuration, segment_.max_cluster_duration()); @@ -537,9 +537,9 @@ TEST_F(MuxerTest, MaxClusterDuration) { } TEST_F(MuxerTest, SetCuesTrackNumber) { - const uint64 kTrackNumber = 10; + const uint64_t kTrackNumber = 10; EXPECT_TRUE(SegmentInit(true, false)); - const uint64 vid_track = + const uint64_t vid_track = segment_.AddVideoTrack(kWidth, kHeight, kTrackNumber); EXPECT_EQ(kTrackNumber, vid_track); segment_.GetTrackByNumber(vid_track)->set_uid(kVideoTrackNumber); diff --git a/testing/test_util.h b/testing/test_util.h index ee5b52a..5abe670 100644 --- a/testing/test_util.h +++ b/testing/test_util.h @@ -8,8 +8,9 @@ #ifndef LIBWEBM_TESTING_TEST_UTIL_H_ #define LIBWEBM_TESTING_TEST_UTIL_H_ +#include + #include -#include #include namespace libwebm {