ref: 5404978825e174835932d9bf740e7538beb10898
dir: /third_party/libwebm/mkvmuxer.cpp/
// Copyright (c) 2012 The WebM project authors. All Rights Reserved. // // Use of this source code is governed by a BSD-style license // that can be found in the LICENSE file in the root of the source // 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 "mkvmuxer.hpp" #include <climits> #include <cstdio> #include <cstdlib> #include <cstring> #include <ctime> #include <new> #include "mkvmuxerutil.hpp" #include "mkvparser.hpp" #include "mkvwriter.hpp" #include "webmids.hpp" #ifdef _MSC_VER // Disable MSVC warnings that suggest making code non-portable. #pragma warning(disable : 4996) #endif namespace mkvmuxer { namespace { // Deallocate the string designated by |dst|, and then copy the |src| // string to |dst|. The caller owns both the |src| string and the // |dst| copy (hence the caller is responsible for eventually // deallocating the strings, either directly, or indirectly via // StrCpy). Returns true if the source string was successfully copied // to the destination. bool StrCpy(const char* src, char** dst_ptr) { if (dst_ptr == NULL) return false; char*& dst = *dst_ptr; delete[] dst; dst = NULL; if (src == NULL) return true; const size_t size = strlen(src) + 1; dst = new (std::nothrow) char[size]; // NOLINT if (dst == NULL) return false; strcpy(dst, src); // NOLINT return true; } } // namespace /////////////////////////////////////////////////////////////// // // IMkvWriter Class IMkvWriter::IMkvWriter() {} IMkvWriter::~IMkvWriter() {} bool WriteEbmlHeader(IMkvWriter* writer, uint64 doc_type_version) { // Level 0 uint64 size = EbmlElementSize(kMkvEBMLVersion, 1ULL); size += EbmlElementSize(kMkvEBMLReadVersion, 1ULL); size += EbmlElementSize(kMkvEBMLMaxIDLength, 4ULL); size += EbmlElementSize(kMkvEBMLMaxSizeLength, 8ULL); size += EbmlElementSize(kMkvDocType, "webm"); size += EbmlElementSize(kMkvDocTypeVersion, doc_type_version); size += EbmlElementSize(kMkvDocTypeReadVersion, 2ULL); if (!WriteEbmlMasterElement(writer, kMkvEBML, size)) return false; if (!WriteEbmlElement(writer, kMkvEBMLVersion, 1ULL)) return false; if (!WriteEbmlElement(writer, kMkvEBMLReadVersion, 1ULL)) return false; if (!WriteEbmlElement(writer, kMkvEBMLMaxIDLength, 4ULL)) return false; if (!WriteEbmlElement(writer, kMkvEBMLMaxSizeLength, 8ULL)) return false; if (!WriteEbmlElement(writer, kMkvDocType, "webm")) return false; if (!WriteEbmlElement(writer, kMkvDocTypeVersion, doc_type_version)) return false; if (!WriteEbmlElement(writer, kMkvDocTypeReadVersion, 2ULL)) return false; return true; } bool WriteEbmlHeader(IMkvWriter* writer) { return WriteEbmlHeader(writer, mkvmuxer::Segment::kDefaultDocTypeVersion); } bool ChunkedCopy(mkvparser::IMkvReader* source, mkvmuxer::IMkvWriter* dst, mkvmuxer::int64 start, int64 size) { // TODO(vigneshv): Check if this is a reasonable value. const uint32 kBufSize = 2048; uint8* buf = new uint8[kBufSize]; int64 offset = start; while (size > 0) { const int64 read_len = (size > kBufSize) ? kBufSize : size; if (source->Read(offset, static_cast<long>(read_len), buf)) return false; dst->Write(buf, static_cast<uint32>(read_len)); offset += read_len; size -= read_len; } delete[] buf; return true; } /////////////////////////////////////////////////////////////// // // Frame Class Frame::Frame() : add_id_(0), additional_(NULL), additional_length_(0), duration_(0), frame_(NULL), is_key_(false), length_(0), track_number_(0), timestamp_(0), discard_padding_(0), reference_block_timestamp_(0), reference_block_timestamp_set_(false) {} Frame::~Frame() { delete[] frame_; delete[] additional_; } bool Frame::CopyFrom(const Frame& frame) { delete[] frame_; frame_ = NULL; length_ = 0; if (frame.length() > 0 && frame.frame() != NULL && !Init(frame.frame(), frame.length())) { return false; } add_id_ = 0; delete[] additional_; additional_ = NULL; additional_length_ = 0; if (frame.additional_length() > 0 && frame.additional() != NULL && !AddAdditionalData(frame.additional(), frame.additional_length(), frame.add_id())) { return false; } duration_ = frame.duration(); is_key_ = frame.is_key(); track_number_ = frame.track_number(); timestamp_ = frame.timestamp(); discard_padding_ = frame.discard_padding(); return true; } bool Frame::Init(const uint8* frame, uint64 length) { uint8* const data = new (std::nothrow) uint8[static_cast<size_t>(length)]; // NOLINT if (!data) return false; delete[] frame_; frame_ = data; length_ = length; memcpy(frame_, frame, static_cast<size_t>(length_)); return true; } bool Frame::AddAdditionalData(const uint8* additional, uint64 length, uint64 add_id) { uint8* const data = new (std::nothrow) uint8[static_cast<size_t>(length)]; // NOLINT if (!data) return false; delete[] additional_; additional_ = data; additional_length_ = length; add_id_ = add_id; memcpy(additional_, additional, static_cast<size_t>(additional_length_)); return true; } bool Frame::IsValid() const { if (length_ == 0 || !frame_) { return false; } if ((additional_length_ != 0 && !additional_) || (additional_ != NULL && additional_length_ == 0)) { return false; } if (track_number_ == 0 || track_number_ > kMaxTrackNumber) { return false; } if (!CanBeSimpleBlock() && !is_key_ && !reference_block_timestamp_set_) { return false; } return true; } bool Frame::CanBeSimpleBlock() const { return additional_ == NULL && discard_padding_ == 0 && duration_ == 0; } void Frame::set_reference_block_timestamp(int64 reference_block_timestamp) { reference_block_timestamp_ = reference_block_timestamp; reference_block_timestamp_set_ = true; } /////////////////////////////////////////////////////////////// // // CuePoint Class CuePoint::CuePoint() : time_(0), track_(0), cluster_pos_(0), block_number_(1), output_block_number_(true) {} CuePoint::~CuePoint() {} bool CuePoint::Write(IMkvWriter* writer) const { if (!writer || track_ < 1 || cluster_pos_ < 1) return false; uint64 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 = EbmlMasterElementSize(kMkvCueTrackPositions, size) + size; const uint64 payload_size = EbmlElementSize(kMkvCueTime, time_) + track_pos_size; if (!WriteEbmlMasterElement(writer, kMkvCuePoint, payload_size)) return false; const int64 payload_position = writer->Position(); if (payload_position < 0) return false; if (!WriteEbmlElement(writer, kMkvCueTime, time_)) return false; if (!WriteEbmlMasterElement(writer, kMkvCueTrackPositions, size)) return false; if (!WriteEbmlElement(writer, kMkvCueTrack, track_)) return false; if (!WriteEbmlElement(writer, kMkvCueClusterPosition, cluster_pos_)) return false; if (output_block_number_ && block_number_ > 1) if (!WriteEbmlElement(writer, kMkvCueBlockNumber, block_number_)) return false; const int64 stop_position = writer->Position(); if (stop_position < 0) return false; if (stop_position - payload_position != static_cast<int64>(payload_size)) return false; return true; } uint64 CuePoint::PayloadSize() const { uint64 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 = EbmlMasterElementSize(kMkvCueTrackPositions, size) + size; const uint64 payload_size = EbmlElementSize(kMkvCueTime, time_) + track_pos_size; return payload_size; } uint64 CuePoint::Size() const { const uint64 payload_size = PayloadSize(); return EbmlMasterElementSize(kMkvCuePoint, payload_size) + payload_size; } /////////////////////////////////////////////////////////////// // // Cues Class Cues::Cues() : cue_entries_capacity_(0), cue_entries_size_(0), cue_entries_(NULL), output_block_number_(true) {} Cues::~Cues() { if (cue_entries_) { for (int32 i = 0; i < cue_entries_size_; ++i) { CuePoint* const cue = cue_entries_[i]; delete cue; } delete[] cue_entries_; } } bool Cues::AddCue(CuePoint* cue) { if (!cue) return false; if ((cue_entries_size_ + 1) > cue_entries_capacity_) { // Add more CuePoints. const int32 new_capacity = (!cue_entries_capacity_) ? 2 : cue_entries_capacity_ * 2; if (new_capacity < 1) return false; CuePoint** const cues = new (std::nothrow) CuePoint*[new_capacity]; // NOLINT if (!cues) return false; for (int32 i = 0; i < cue_entries_size_; ++i) { cues[i] = cue_entries_[i]; } delete[] cue_entries_; cue_entries_ = cues; cue_entries_capacity_ = new_capacity; } cue->set_output_block_number(output_block_number_); cue_entries_[cue_entries_size_++] = cue; return true; } CuePoint* Cues::GetCueByIndex(int32 index) const { if (cue_entries_ == NULL) return NULL; if (index >= cue_entries_size_) return NULL; return cue_entries_[index]; } uint64 Cues::Size() { uint64 size = 0; for (int32 i = 0; i < cue_entries_size_; ++i) size += GetCueByIndex(i)->Size(); size += EbmlMasterElementSize(kMkvCues, size); return size; } bool Cues::Write(IMkvWriter* writer) const { if (!writer) return false; uint64 size = 0; for (int32 i = 0; i < cue_entries_size_; ++i) { const CuePoint* const cue = GetCueByIndex(i); if (!cue) return false; size += cue->Size(); } if (!WriteEbmlMasterElement(writer, kMkvCues, size)) return false; const int64 payload_position = writer->Position(); if (payload_position < 0) return false; for (int32 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(); if (stop_position < 0) return false; if (stop_position - payload_position != static_cast<int64>(size)) return false; return true; } /////////////////////////////////////////////////////////////// // // ContentEncAESSettings Class ContentEncAESSettings::ContentEncAESSettings() : cipher_mode_(kCTR) {} uint64 ContentEncAESSettings::Size() const { const uint64 payload = PayloadSize(); const uint64 size = EbmlMasterElementSize(kMkvContentEncAESSettings, payload) + payload; return size; } bool ContentEncAESSettings::Write(IMkvWriter* writer) const { const uint64 payload = PayloadSize(); if (!WriteEbmlMasterElement(writer, kMkvContentEncAESSettings, payload)) return false; const int64 payload_position = writer->Position(); if (payload_position < 0) return false; if (!WriteEbmlElement(writer, kMkvAESSettingsCipherMode, cipher_mode_)) return false; const int64 stop_position = writer->Position(); if (stop_position < 0 || stop_position - payload_position != static_cast<int64>(payload)) return false; return true; } uint64 ContentEncAESSettings::PayloadSize() const { uint64 size = EbmlElementSize(kMkvAESSettingsCipherMode, cipher_mode_); return size; } /////////////////////////////////////////////////////////////// // // ContentEncoding Class ContentEncoding::ContentEncoding() : enc_algo_(5), enc_key_id_(NULL), encoding_order_(0), encoding_scope_(1), encoding_type_(1), enc_key_id_length_(0) {} ContentEncoding::~ContentEncoding() { delete[] enc_key_id_; } bool ContentEncoding::SetEncryptionID(const uint8* id, uint64 length) { if (!id || length < 1) return false; delete[] enc_key_id_; enc_key_id_ = new (std::nothrow) uint8[static_cast<size_t>(length)]; // NOLINT if (!enc_key_id_) return false; memcpy(enc_key_id_, id, static_cast<size_t>(length)); enc_key_id_length_ = length; return true; } uint64 ContentEncoding::Size() const { const uint64 encryption_size = EncryptionSize(); const uint64 encoding_size = EncodingSize(0, encryption_size); const uint64 encodings_size = EbmlMasterElementSize(kMkvContentEncoding, encoding_size) + encoding_size; 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 = EbmlMasterElementSize(kMkvContentEncoding, encoding_size) + encoding_size; const int64 payload_position = writer->Position(); if (payload_position < 0) return false; if (!WriteEbmlMasterElement(writer, kMkvContentEncoding, encoding_size)) return false; if (!WriteEbmlElement(writer, kMkvContentEncodingOrder, encoding_order_)) return false; if (!WriteEbmlElement(writer, kMkvContentEncodingScope, encoding_scope_)) return false; if (!WriteEbmlElement(writer, kMkvContentEncodingType, encoding_type_)) return false; if (!WriteEbmlMasterElement(writer, kMkvContentEncryption, encryption_size)) return false; if (!WriteEbmlElement(writer, kMkvContentEncAlgo, enc_algo_)) return false; if (!WriteEbmlElement(writer, kMkvContentEncKeyID, enc_key_id_, enc_key_id_length_)) return false; if (!enc_aes_settings_.Write(writer)) return false; const int64 stop_position = writer->Position(); if (stop_position < 0 || stop_position - payload_position != static_cast<int64>(size)) return false; return true; } uint64 ContentEncoding::EncodingSize(uint64 compresion_size, uint64 encryption_size) const { // TODO(fgalligan): Add support for compression settings. if (compresion_size != 0) return 0; uint64 encoding_size = 0; if (encryption_size > 0) { encoding_size += EbmlMasterElementSize(kMkvContentEncryption, encryption_size) + encryption_size; } encoding_size += EbmlElementSize(kMkvContentEncodingType, encoding_type_); encoding_size += EbmlElementSize(kMkvContentEncodingScope, encoding_scope_); encoding_size += EbmlElementSize(kMkvContentEncodingOrder, encoding_order_); return encoding_size; } uint64 ContentEncoding::EncryptionSize() const { const uint64 aes_size = enc_aes_settings_.Size(); uint64 encryption_size = EbmlElementSize(kMkvContentEncKeyID, enc_key_id_, enc_key_id_length_); encryption_size += EbmlElementSize(kMkvContentEncAlgo, enc_algo_); return encryption_size + aes_size; } /////////////////////////////////////////////////////////////// // // Track Class Track::Track(unsigned int* seed) : codec_id_(NULL), codec_private_(NULL), language_(NULL), max_block_additional_id_(0), name_(NULL), number_(0), type_(0), uid_(MakeUID(seed)), codec_delay_(0), seek_pre_roll_(0), default_duration_(0), codec_private_length_(0), content_encoding_entries_(NULL), content_encoding_entries_size_(0) {} Track::~Track() { delete[] codec_id_; delete[] codec_private_; delete[] language_; delete[] name_; if (content_encoding_entries_) { for (uint32 i = 0; i < content_encoding_entries_size_; ++i) { ContentEncoding* const encoding = content_encoding_entries_[i]; delete encoding; } delete[] content_encoding_entries_; } } bool Track::AddContentEncoding() { const uint32 count = content_encoding_entries_size_ + 1; ContentEncoding** const content_encoding_entries = new (std::nothrow) ContentEncoding*[count]; // NOLINT if (!content_encoding_entries) return false; ContentEncoding* const content_encoding = new (std::nothrow) ContentEncoding(); // NOLINT if (!content_encoding) { delete[] content_encoding_entries; return false; } for (uint32 i = 0; i < content_encoding_entries_size_; ++i) { content_encoding_entries[i] = content_encoding_entries_[i]; } delete[] content_encoding_entries_; content_encoding_entries_ = content_encoding_entries; content_encoding_entries_[content_encoding_entries_size_] = content_encoding; content_encoding_entries_size_ = count; return true; } ContentEncoding* Track::GetContentEncodingByIndex(uint32 index) const { if (content_encoding_entries_ == NULL) return NULL; if (index >= content_encoding_entries_size_) return NULL; return content_encoding_entries_[index]; } uint64 Track::PayloadSize() const { uint64 size = EbmlElementSize(kMkvTrackNumber, number_); size += EbmlElementSize(kMkvTrackUID, uid_); size += EbmlElementSize(kMkvTrackType, type_); if (codec_id_) size += EbmlElementSize(kMkvCodecID, codec_id_); if (codec_private_) size += EbmlElementSize(kMkvCodecPrivate, codec_private_, codec_private_length_); if (language_) size += EbmlElementSize(kMkvLanguage, language_); if (name_) size += EbmlElementSize(kMkvName, name_); if (max_block_additional_id_) size += EbmlElementSize(kMkvMaxBlockAdditionID, max_block_additional_id_); if (codec_delay_) size += EbmlElementSize(kMkvCodecDelay, codec_delay_); if (seek_pre_roll_) size += EbmlElementSize(kMkvSeekPreRoll, seek_pre_roll_); if (default_duration_) 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) { ContentEncoding* const encoding = content_encoding_entries_[i]; content_encodings_size += encoding->Size(); } size += EbmlMasterElementSize(kMkvContentEncodings, content_encodings_size) + content_encodings_size; } return size; } uint64 Track::Size() const { uint64 size = PayloadSize(); size += EbmlMasterElementSize(kMkvTrackEntry, size); return size; } bool Track::Write(IMkvWriter* writer) const { if (!writer) return false; // mandatory elements without a default value. if (!type_ || !codec_id_) return false; // |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(); if (!WriteEbmlMasterElement(writer, kMkvTrackEntry, payload_size)) return false; uint64 size = EbmlElementSize(kMkvTrackNumber, number_); size += EbmlElementSize(kMkvTrackUID, uid_); size += EbmlElementSize(kMkvTrackType, type_); if (codec_id_) size += EbmlElementSize(kMkvCodecID, codec_id_); if (codec_private_) size += EbmlElementSize(kMkvCodecPrivate, codec_private_, codec_private_length_); if (language_) size += EbmlElementSize(kMkvLanguage, language_); if (name_) size += EbmlElementSize(kMkvName, name_); if (max_block_additional_id_) size += EbmlElementSize(kMkvMaxBlockAdditionID, max_block_additional_id_); if (codec_delay_) size += EbmlElementSize(kMkvCodecDelay, codec_delay_); if (seek_pre_roll_) size += EbmlElementSize(kMkvSeekPreRoll, seek_pre_roll_); if (default_duration_) size += EbmlElementSize(kMkvDefaultDuration, default_duration_); const int64 payload_position = writer->Position(); if (payload_position < 0) return false; if (!WriteEbmlElement(writer, kMkvTrackNumber, number_)) return false; if (!WriteEbmlElement(writer, kMkvTrackUID, uid_)) return false; if (!WriteEbmlElement(writer, kMkvTrackType, type_)) return false; if (max_block_additional_id_) { if (!WriteEbmlElement(writer, kMkvMaxBlockAdditionID, max_block_additional_id_)) { return false; } } if (codec_delay_) { if (!WriteEbmlElement(writer, kMkvCodecDelay, codec_delay_)) return false; } if (seek_pre_roll_) { if (!WriteEbmlElement(writer, kMkvSeekPreRoll, seek_pre_roll_)) return false; } if (default_duration_) { if (!WriteEbmlElement(writer, kMkvDefaultDuration, default_duration_)) return false; } if (codec_id_) { if (!WriteEbmlElement(writer, kMkvCodecID, codec_id_)) return false; } if (codec_private_) { if (!WriteEbmlElement(writer, kMkvCodecPrivate, codec_private_, codec_private_length_)) return false; } if (language_) { if (!WriteEbmlElement(writer, kMkvLanguage, language_)) return false; } if (name_) { if (!WriteEbmlElement(writer, kMkvName, name_)) return false; } int64 stop_position = writer->Position(); if (stop_position < 0 || stop_position - payload_position != static_cast<int64>(size)) return false; if (content_encoding_entries_size_ > 0) { uint64 content_encodings_size = 0; for (uint32 i = 0; i < content_encoding_entries_size_; ++i) { ContentEncoding* const encoding = content_encoding_entries_[i]; content_encodings_size += encoding->Size(); } if (!WriteEbmlMasterElement(writer, kMkvContentEncodings, content_encodings_size)) return false; for (uint32 i = 0; i < content_encoding_entries_size_; ++i) { ContentEncoding* const encoding = content_encoding_entries_[i]; if (!encoding->Write(writer)) return false; } } stop_position = writer->Position(); if (stop_position < 0) return false; return true; } bool Track::SetCodecPrivate(const uint8* codec_private, uint64 length) { if (!codec_private || length < 1) return false; delete[] codec_private_; codec_private_ = new (std::nothrow) uint8[static_cast<size_t>(length)]; // NOLINT if (!codec_private_) return false; memcpy(codec_private_, codec_private, static_cast<size_t>(length)); codec_private_length_ = length; return true; } void Track::set_codec_id(const char* codec_id) { if (codec_id) { delete[] codec_id_; const size_t length = strlen(codec_id) + 1; codec_id_ = new (std::nothrow) char[length]; // NOLINT if (codec_id_) { #ifdef _MSC_VER strcpy_s(codec_id_, length, codec_id); #else strcpy(codec_id_, codec_id); #endif } } } // TODO(fgalligan): Vet the language parameter. void Track::set_language(const char* language) { if (language) { delete[] language_; const size_t length = strlen(language) + 1; language_ = new (std::nothrow) char[length]; // NOLINT if (language_) { #ifdef _MSC_VER strcpy_s(language_, length, language); #else strcpy(language_, language); #endif } } } void Track::set_name(const char* name) { if (name) { delete[] name_; const size_t length = strlen(name) + 1; name_ = new (std::nothrow) char[length]; // NOLINT if (name_) { #ifdef _MSC_VER strcpy_s(name_, length, name); #else strcpy(name_, name); #endif } } } /////////////////////////////////////////////////////////////// // // VideoTrack Class VideoTrack::VideoTrack(unsigned int* seed) : Track(seed), display_height_(0), display_width_(0), crop_left_(0), crop_right_(0), crop_top_(0), crop_bottom_(0), frame_rate_(0.0), height_(0), stereo_mode_(0), alpha_mode_(0), width_(0) {} VideoTrack::~VideoTrack() {} bool VideoTrack::SetStereoMode(uint64 stereo_mode) { if (stereo_mode != kMono && stereo_mode != kSideBySideLeftIsFirst && stereo_mode != kTopBottomRightIsFirst && stereo_mode != kTopBottomLeftIsFirst && stereo_mode != kSideBySideRightIsFirst) return false; stereo_mode_ = stereo_mode; return true; } bool VideoTrack::SetAlphaMode(uint64 alpha_mode) { if (alpha_mode != kNoAlpha && alpha_mode != kAlpha) return false; alpha_mode_ = alpha_mode; return true; } uint64 VideoTrack::PayloadSize() const { const uint64 parent_size = Track::PayloadSize(); uint64 size = VideoPayloadSize(); size += EbmlMasterElementSize(kMkvVideo, size); return parent_size + size; } bool VideoTrack::Write(IMkvWriter* writer) const { if (!Track::Write(writer)) return false; const uint64 size = VideoPayloadSize(); if (!WriteEbmlMasterElement(writer, kMkvVideo, size)) return false; const int64 payload_position = writer->Position(); if (payload_position < 0) return false; if (!WriteEbmlElement(writer, kMkvPixelWidth, width_)) return false; if (!WriteEbmlElement(writer, kMkvPixelHeight, height_)) return false; if (display_width_ > 0) { if (!WriteEbmlElement(writer, kMkvDisplayWidth, display_width_)) return false; } if (display_height_ > 0) { if (!WriteEbmlElement(writer, kMkvDisplayHeight, display_height_)) return false; } if (crop_left_ > 0) { if (!WriteEbmlElement(writer, kMkvPixelCropLeft, crop_left_)) return false; } if (crop_right_ > 0) { if (!WriteEbmlElement(writer, kMkvPixelCropRight, crop_right_)) return false; } if (crop_top_ > 0) { if (!WriteEbmlElement(writer, kMkvPixelCropTop, crop_top_)) return false; } if (crop_bottom_ > 0) { if (!WriteEbmlElement(writer, kMkvPixelCropBottom, crop_bottom_)) return false; } if (stereo_mode_ > kMono) { if (!WriteEbmlElement(writer, kMkvStereoMode, stereo_mode_)) return false; } if (alpha_mode_ > kNoAlpha) { if (!WriteEbmlElement(writer, kMkvAlphaMode, alpha_mode_)) return false; } if (frame_rate_ > 0.0) { if (!WriteEbmlElement(writer, kMkvFrameRate, static_cast<float>(frame_rate_))) { return false; } } const int64 stop_position = writer->Position(); if (stop_position < 0 || stop_position - payload_position != static_cast<int64>(size)) { return false; } return true; } uint64 VideoTrack::VideoPayloadSize() const { uint64 size = EbmlElementSize(kMkvPixelWidth, width_); size += EbmlElementSize(kMkvPixelHeight, height_); if (display_width_ > 0) size += EbmlElementSize(kMkvDisplayWidth, display_width_); if (display_height_ > 0) size += EbmlElementSize(kMkvDisplayHeight, display_height_); if (crop_left_ > 0) size += EbmlElementSize(kMkvPixelCropLeft, crop_left_); if (crop_right_ > 0) size += EbmlElementSize(kMkvPixelCropRight, crop_right_); if (crop_top_ > 0) size += EbmlElementSize(kMkvPixelCropTop, crop_top_); if (crop_bottom_ > 0) size += EbmlElementSize(kMkvPixelCropBottom, crop_bottom_); if (stereo_mode_ > kMono) size += EbmlElementSize(kMkvStereoMode, stereo_mode_); if (alpha_mode_ > kNoAlpha) size += EbmlElementSize(kMkvAlphaMode, alpha_mode_); if (frame_rate_ > 0.0) size += EbmlElementSize(kMkvFrameRate, static_cast<float>(frame_rate_)); return size; } /////////////////////////////////////////////////////////////// // // AudioTrack Class AudioTrack::AudioTrack(unsigned int* seed) : Track(seed), bit_depth_(0), channels_(1), sample_rate_(0.0) {} AudioTrack::~AudioTrack() {} uint64 AudioTrack::PayloadSize() const { const uint64 parent_size = Track::PayloadSize(); uint64 size = EbmlElementSize(kMkvSamplingFrequency, static_cast<float>(sample_rate_)); size += EbmlElementSize(kMkvChannels, channels_); if (bit_depth_ > 0) size += EbmlElementSize(kMkvBitDepth, bit_depth_); size += EbmlMasterElementSize(kMkvAudio, size); return parent_size + size; } bool AudioTrack::Write(IMkvWriter* writer) const { if (!Track::Write(writer)) return false; // Calculate AudioSettings size. uint64 size = EbmlElementSize(kMkvSamplingFrequency, static_cast<float>(sample_rate_)); size += EbmlElementSize(kMkvChannels, channels_); if (bit_depth_ > 0) size += EbmlElementSize(kMkvBitDepth, bit_depth_); if (!WriteEbmlMasterElement(writer, kMkvAudio, size)) return false; const int64 payload_position = writer->Position(); if (payload_position < 0) return false; if (!WriteEbmlElement(writer, kMkvSamplingFrequency, static_cast<float>(sample_rate_))) return false; if (!WriteEbmlElement(writer, kMkvChannels, channels_)) return false; if (bit_depth_ > 0) if (!WriteEbmlElement(writer, kMkvBitDepth, bit_depth_)) return false; const int64 stop_position = writer->Position(); if (stop_position < 0 || stop_position - payload_position != static_cast<int64>(size)) return false; return true; } /////////////////////////////////////////////////////////////// // // Tracks Class const char Tracks::kOpusCodecId[] = "A_OPUS"; const char Tracks::kVorbisCodecId[] = "A_VORBIS"; const char Tracks::kVp8CodecId[] = "V_VP8"; const char Tracks::kVp9CodecId[] = "V_VP9"; const char Tracks::kVp10CodecId[] = "V_VP10"; Tracks::Tracks() : track_entries_(NULL), track_entries_size_(0) {} Tracks::~Tracks() { if (track_entries_) { for (uint32 i = 0; i < track_entries_size_; ++i) { Track* const track = track_entries_[i]; delete track; } delete[] track_entries_; } } bool Tracks::AddTrack(Track* track, int32 number) { if (number < 0) return false; // This muxer only supports track numbers in the range [1, 126], in // order to be able (to use Matroska integer representation) to // serialize the block header (of which the track number is a part) // for a frame using exactly 4 bytes. if (number > 0x7E) return false; uint32 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) { if (track_entries_[i]->number() == track_num) return false; } } const uint32 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) { track_entries[i] = track_entries_[i]; } delete[] track_entries_; // Find the lowest availible track number > 0. if (track_num == 0) { track_num = count; // Check to make sure a track does not already have |track_num|. bool exit = false; do { exit = true; for (uint32 i = 0; i < track_entries_size_; ++i) { if (track_entries[i]->number() == track_num) { track_num++; exit = false; break; } } } while (!exit); } track->set_number(track_num); track_entries_ = track_entries; track_entries_[track_entries_size_] = track; track_entries_size_ = count; return true; } const Track* Tracks::GetTrackByIndex(uint32 index) const { if (track_entries_ == NULL) return NULL; if (index >= track_entries_size_) return NULL; return track_entries_[index]; } Track* Tracks::GetTrackByNumber(uint64 track_number) const { const int32 count = track_entries_size(); for (int32 i = 0; i < count; ++i) { if (track_entries_[i]->number() == track_number) return track_entries_[i]; } return NULL; } bool Tracks::TrackIsAudio(uint64 track_number) const { const Track* const track = GetTrackByNumber(track_number); if (track->type() == kAudio) return true; return false; } bool Tracks::TrackIsVideo(uint64 track_number) const { const Track* const track = GetTrackByNumber(track_number); if (track->type() == kVideo) return true; return false; } bool Tracks::Write(IMkvWriter* writer) const { uint64 size = 0; const int32 count = track_entries_size(); for (int32 i = 0; i < count; ++i) { const Track* const track = GetTrackByIndex(i); if (!track) return false; size += track->Size(); } if (!WriteEbmlMasterElement(writer, kMkvTracks, size)) return false; const int64 payload_position = writer->Position(); if (payload_position < 0) return false; for (int32 i = 0; i < count; ++i) { const Track* const track = GetTrackByIndex(i); if (!track->Write(writer)) return false; } const int64 stop_position = writer->Position(); if (stop_position < 0 || stop_position - payload_position != static_cast<int64>(size)) return false; return true; } /////////////////////////////////////////////////////////////// // // Chapter Class bool Chapter::set_id(const char* id) { return StrCpy(id, &id_); } void Chapter::set_time(const Segment& segment, uint64 start_ns, uint64 end_ns) { const SegmentInfo* const info = segment.GetSegmentInfo(); const uint64 timecode_scale = info->timecode_scale(); start_timecode_ = start_ns / timecode_scale; end_timecode_ = end_ns / timecode_scale; } bool Chapter::add_string(const char* title, const char* language, const char* country) { if (!ExpandDisplaysArray()) return false; Display& d = displays_[displays_count_++]; d.Init(); if (!d.set_title(title)) return false; if (!d.set_language(language)) return false; if (!d.set_country(country)) return false; return true; } Chapter::Chapter() { // This ctor only constructs the object. Proper initialization is // done in Init() (called in Chapters::AddChapter()). The only // reason we bother implementing this ctor is because we had to // declare it as private (along with the dtor), in order to prevent // clients from creating Chapter instances (a privelege we grant // only to the Chapters class). Doing no initialization here also // means that creating arrays of chapter objects is more efficient, // because we only initialize each new chapter object as it becomes // active on the array. } Chapter::~Chapter() {} void Chapter::Init(unsigned int* seed) { id_ = NULL; start_timecode_ = 0; end_timecode_ = 0; displays_ = NULL; displays_size_ = 0; displays_count_ = 0; uid_ = MakeUID(seed); } void Chapter::ShallowCopy(Chapter* dst) const { dst->id_ = id_; dst->start_timecode_ = start_timecode_; dst->end_timecode_ = end_timecode_; dst->uid_ = uid_; dst->displays_ = displays_; dst->displays_size_ = displays_size_; dst->displays_count_ = displays_count_; } void Chapter::Clear() { StrCpy(NULL, &id_); while (displays_count_ > 0) { Display& d = displays_[--displays_count_]; d.Clear(); } delete[] displays_; displays_ = NULL; displays_size_ = 0; } bool Chapter::ExpandDisplaysArray() { if (displays_size_ > displays_count_) return true; // nothing to do yet const int size = (displays_size_ == 0) ? 1 : 2 * displays_size_; Display* const displays = new (std::nothrow) Display[size]; // NOLINT if (displays == NULL) return false; for (int idx = 0; idx < displays_count_; ++idx) { displays[idx] = displays_[idx]; // shallow copy } delete[] displays_; displays_ = displays; displays_size_ = size; 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_); for (int idx = 0; idx < displays_count_; ++idx) { const Display& d = displays_[idx]; payload_size += d.WriteDisplay(NULL); } const uint64 atom_size = EbmlMasterElementSize(kMkvChapterAtom, payload_size) + payload_size; if (writer == NULL) return atom_size; const int64 start = writer->Position(); if (!WriteEbmlMasterElement(writer, kMkvChapterAtom, payload_size)) return 0; if (!WriteEbmlElement(writer, kMkvChapterStringUID, id_)) return 0; if (!WriteEbmlElement(writer, kMkvChapterUID, uid_)) return 0; if (!WriteEbmlElement(writer, kMkvChapterTimeStart, start_timecode_)) return 0; if (!WriteEbmlElement(writer, kMkvChapterTimeEnd, end_timecode_)) return 0; for (int idx = 0; idx < displays_count_; ++idx) { const Display& d = displays_[idx]; if (!d.WriteDisplay(writer)) return 0; } const int64 stop = writer->Position(); if (stop >= start && uint64(stop - start) != atom_size) return 0; return atom_size; } void Chapter::Display::Init() { title_ = NULL; language_ = NULL; country_ = NULL; } void Chapter::Display::Clear() { StrCpy(NULL, &title_); StrCpy(NULL, &language_); StrCpy(NULL, &country_); } bool Chapter::Display::set_title(const char* title) { return StrCpy(title, &title_); } bool Chapter::Display::set_language(const char* language) { return StrCpy(language, &language_); } 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_); if (language_) payload_size += EbmlElementSize(kMkvChapLanguage, language_); if (country_) payload_size += EbmlElementSize(kMkvChapCountry, country_); const uint64 display_size = EbmlMasterElementSize(kMkvChapterDisplay, payload_size) + payload_size; if (writer == NULL) return display_size; const int64 start = writer->Position(); if (!WriteEbmlMasterElement(writer, kMkvChapterDisplay, payload_size)) return 0; if (!WriteEbmlElement(writer, kMkvChapString, title_)) return 0; if (language_) { if (!WriteEbmlElement(writer, kMkvChapLanguage, language_)) return 0; } if (country_) { if (!WriteEbmlElement(writer, kMkvChapCountry, country_)) return 0; } const int64 stop = writer->Position(); if (stop >= start && uint64(stop - start) != display_size) return 0; return display_size; } /////////////////////////////////////////////////////////////// // // Chapters Class Chapters::Chapters() : chapters_size_(0), chapters_count_(0), chapters_(NULL) {} Chapters::~Chapters() { while (chapters_count_ > 0) { Chapter& chapter = chapters_[--chapters_count_]; chapter.Clear(); } delete[] chapters_; chapters_ = NULL; } int Chapters::Count() const { return chapters_count_; } Chapter* Chapters::AddChapter(unsigned int* seed) { if (!ExpandChaptersArray()) return NULL; Chapter& chapter = chapters_[chapters_count_++]; chapter.Init(seed); return &chapter; } bool Chapters::Write(IMkvWriter* writer) const { if (writer == NULL) return false; const uint64 payload_size = WriteEdition(NULL); // return size only if (!WriteEbmlMasterElement(writer, kMkvChapters, payload_size)) return false; const int64 start = writer->Position(); if (WriteEdition(writer) == 0) // error return false; const int64 stop = writer->Position(); if (stop >= start && uint64(stop - start) != payload_size) return false; return true; } bool Chapters::ExpandChaptersArray() { if (chapters_size_ > chapters_count_) return true; // nothing to do yet const int size = (chapters_size_ == 0) ? 1 : 2 * chapters_size_; Chapter* const chapters = new (std::nothrow) Chapter[size]; // NOLINT if (chapters == NULL) return false; for (int idx = 0; idx < chapters_count_; ++idx) { const Chapter& src = chapters_[idx]; Chapter* const dst = chapters + idx; src.ShallowCopy(dst); } delete[] chapters_; chapters_ = chapters; chapters_size_ = size; return true; } uint64 Chapters::WriteEdition(IMkvWriter* writer) const { uint64 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 = EbmlMasterElementSize(kMkvEditionEntry, payload_size) + payload_size; if (writer == NULL) // return size only return edition_size; const int64 start = writer->Position(); if (!WriteEbmlMasterElement(writer, kMkvEditionEntry, payload_size)) return 0; // error for (int idx = 0; idx < chapters_count_; ++idx) { const Chapter& chapter = chapters_[idx]; const uint64 chapter_size = chapter.WriteAtom(writer); if (chapter_size == 0) // error return 0; } const int64 stop = writer->Position(); if (stop >= start && uint64(stop - start) != edition_size) return 0; return edition_size; } // Tag Class bool Tag::add_simple_tag(const char* tag_name, const char* tag_string) { if (!ExpandSimpleTagsArray()) return false; SimpleTag& st = simple_tags_[simple_tags_count_++]; st.Init(); if (!st.set_tag_name(tag_name)) return false; if (!st.set_tag_string(tag_string)) return false; return true; } Tag::Tag() { simple_tags_ = NULL; simple_tags_size_ = 0; simple_tags_count_ = 0; } Tag::~Tag() {} void Tag::ShallowCopy(Tag* dst) const { dst->simple_tags_ = simple_tags_; dst->simple_tags_size_ = simple_tags_size_; dst->simple_tags_count_ = simple_tags_count_; } void Tag::Clear() { while (simple_tags_count_ > 0) { SimpleTag& st = simple_tags_[--simple_tags_count_]; st.Clear(); } delete[] simple_tags_; simple_tags_ = NULL; simple_tags_size_ = 0; } bool Tag::ExpandSimpleTagsArray() { if (simple_tags_size_ > simple_tags_count_) return true; // nothing to do yet const int size = (simple_tags_size_ == 0) ? 1 : 2 * simple_tags_size_; SimpleTag* const simple_tags = new (std::nothrow) SimpleTag[size]; // NOLINT if (simple_tags == NULL) return false; for (int idx = 0; idx < simple_tags_count_; ++idx) { simple_tags[idx] = simple_tags_[idx]; // shallow copy } delete[] simple_tags_; simple_tags_ = simple_tags; simple_tags_size_ = size; return true; } uint64 Tag::Write(IMkvWriter* writer) const { uint64 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 = EbmlMasterElementSize(kMkvTag, payload_size) + payload_size; if (writer == NULL) return tag_size; const int64 start = writer->Position(); if (!WriteEbmlMasterElement(writer, kMkvTag, payload_size)) return 0; for (int idx = 0; idx < simple_tags_count_; ++idx) { const SimpleTag& st = simple_tags_[idx]; if (!st.Write(writer)) return 0; } const int64 stop = writer->Position(); if (stop >= start && uint64(stop - start) != tag_size) return 0; return tag_size; } // Tag::SimpleTag void Tag::SimpleTag::Init() { tag_name_ = NULL; tag_string_ = NULL; } void Tag::SimpleTag::Clear() { StrCpy(NULL, &tag_name_); StrCpy(NULL, &tag_string_); } bool Tag::SimpleTag::set_tag_name(const char* tag_name) { return StrCpy(tag_name, &tag_name_); } 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_); payload_size += EbmlElementSize(kMkvTagString, tag_string_); const uint64 simple_tag_size = EbmlMasterElementSize(kMkvSimpleTag, payload_size) + payload_size; if (writer == NULL) return simple_tag_size; const int64 start = writer->Position(); if (!WriteEbmlMasterElement(writer, kMkvSimpleTag, payload_size)) return 0; if (!WriteEbmlElement(writer, kMkvTagName, tag_name_)) return 0; if (!WriteEbmlElement(writer, kMkvTagString, tag_string_)) return 0; const int64 stop = writer->Position(); if (stop >= start && uint64(stop - start) != simple_tag_size) return 0; return simple_tag_size; } // Tags Class Tags::Tags() : tags_size_(0), tags_count_(0), tags_(NULL) {} Tags::~Tags() { while (tags_count_ > 0) { Tag& tag = tags_[--tags_count_]; tag.Clear(); } delete[] tags_; tags_ = NULL; } int Tags::Count() const { return tags_count_; } Tag* Tags::AddTag() { if (!ExpandTagsArray()) return NULL; Tag& tag = tags_[tags_count_++]; return &tag; } bool Tags::Write(IMkvWriter* writer) const { if (writer == NULL) return false; uint64 payload_size = 0; for (int idx = 0; idx < tags_count_; ++idx) { const Tag& tag = tags_[idx]; payload_size += tag.Write(NULL); } if (!WriteEbmlMasterElement(writer, kMkvTags, payload_size)) return false; const int64 start = writer->Position(); for (int idx = 0; idx < tags_count_; ++idx) { const Tag& tag = tags_[idx]; const uint64 tag_size = tag.Write(writer); if (tag_size == 0) // error return 0; } const int64 stop = writer->Position(); if (stop >= start && uint64(stop - start) != payload_size) return false; return true; } bool Tags::ExpandTagsArray() { if (tags_size_ > tags_count_) return true; // nothing to do yet const int size = (tags_size_ == 0) ? 1 : 2 * tags_size_; Tag* const tags = new (std::nothrow) Tag[size]; // NOLINT if (tags == NULL) return false; for (int idx = 0; idx < tags_count_; ++idx) { const Tag& src = tags_[idx]; Tag* const dst = tags + idx; src.ShallowCopy(dst); } delete[] tags_; tags_ = tags; tags_size_ = size; return true; } /////////////////////////////////////////////////////////////// // // Cluster class Cluster::Cluster(uint64 timecode, int64 cues_pos, uint64 timecode_scale) : blocks_added_(0), finalized_(false), header_written_(false), payload_size_(0), position_for_cues_(cues_pos), size_position_(-1), timecode_(timecode), timecode_scale_(timecode_scale), writer_(NULL) {} Cluster::~Cluster() {} bool Cluster::Init(IMkvWriter* ptr_writer) { if (!ptr_writer) { return false; } writer_ = ptr_writer; return true; } bool Cluster::AddFrame(const Frame* const frame) { return DoWriteFrame(frame); } bool Cluster::AddFrame(const uint8* data, uint64 length, uint64 track_number, uint64 abs_timecode, bool is_key) { Frame frame; if (!frame.Init(data, length)) return false; frame.set_track_number(track_number); frame.set_timestamp(abs_timecode); frame.set_is_key(is_key); return DoWriteFrame(&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) { if (!additional || additional_length == 0) { return false; } Frame frame; if (!frame.Init(data, length) || !frame.AddAdditionalData(additional, additional_length, add_id)) { return false; } frame.set_track_number(track_number); frame.set_timestamp(abs_timecode); frame.set_is_key(is_key); return DoWriteFrame(&frame); } bool Cluster::AddFrameWithDiscardPadding(const uint8* data, uint64 length, int64 discard_padding, uint64 track_number, uint64 abs_timecode, bool is_key) { Frame frame; if (!frame.Init(data, length)) return false; frame.set_discard_padding(discard_padding); frame.set_track_number(track_number); frame.set_timestamp(abs_timecode); frame.set_is_key(is_key); return DoWriteFrame(&frame); } bool Cluster::AddMetadata(const uint8* data, uint64 length, uint64 track_number, uint64 abs_timecode, uint64 duration_timecode) { Frame frame; if (!frame.Init(data, length)) return false; frame.set_track_number(track_number); frame.set_timestamp(abs_timecode); frame.set_duration(duration_timecode); frame.set_is_key(true); // All metadata blocks are keyframes. return DoWriteFrame(&frame); } void Cluster::AddPayloadSize(uint64 size) { payload_size_ += size; } bool Cluster::Finalize() { if (!writer_ || finalized_ || size_position_ == -1) return false; if (writer_->Seekable()) { const int64 pos = writer_->Position(); if (writer_->Position(size_position_)) return false; if (WriteUIntSize(writer_, payload_size(), 8)) return false; if (writer_->Position(pos)) return false; } finalized_ = true; return true; } uint64 Cluster::Size() const { const uint64 element_size = EbmlMasterElementSize(kMkvCluster, 0xFFFFFFFFFFFFFFFFULL) + payload_size_; return element_size; } bool Cluster::PreWriteBlock() { if (finalized_) return false; if (!header_written_) { if (!WriteClusterHeader()) return false; } return true; } void Cluster::PostWriteBlock(uint64 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<int64>(abs_timecode) - cluster_timecode; if (rel_timecode < 0 || rel_timecode > kMaxBlockTimecode) return -1; return rel_timecode; } bool Cluster::DoWriteFrame(const Frame* const frame) { if (!frame || !frame->IsValid()) return false; if (!PreWriteBlock()) return false; const uint64 element_size = WriteFrame(writer_, frame, this); if (element_size == 0) return false; PostWriteBlock(element_size); return true; } bool Cluster::WriteClusterHeader() { if (finalized_) return false; if (WriteID(writer_, kMkvCluster)) return false; // Save for later. size_position_ = writer_->Position(); // Write "unknown" (EBML coded -1) as cluster size value. We need to write 8 // bytes because we do not know how big our cluster will be. if (SerializeInt(writer_, kEbmlUnknownValue, 8)) return false; if (!WriteEbmlElement(writer_, kMkvTimecode, timecode())) return false; AddPayloadSize(EbmlElementSize(kMkvTimecode, timecode())); header_written_ = true; return true; } /////////////////////////////////////////////////////////////// // // SeekHead Class SeekHead::SeekHead() : start_pos_(0ULL) { for (int32 i = 0; i < kSeekEntryCount; ++i) { seek_entry_id_[i] = 0; seek_entry_pos_[i] = 0; } } SeekHead::~SeekHead() {} bool SeekHead::Finalize(IMkvWriter* writer) const { if (writer->Seekable()) { if (start_pos_ == -1) return false; uint64 payload_size = 0; uint64 entry_size[kSeekEntryCount]; for (int32 i = 0; i < kSeekEntryCount; ++i) { if (seek_entry_id_[i] != 0) { entry_size[i] = EbmlElementSize(kMkvSeekID, static_cast<uint64>(seek_entry_id_[i])); entry_size[i] += EbmlElementSize(kMkvSeekPosition, seek_entry_pos_[i]); payload_size += EbmlMasterElementSize(kMkvSeek, entry_size[i]) + entry_size[i]; } } // No SeekHead elements if (payload_size == 0) return true; const int64 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) { if (seek_entry_id_[i] != 0) { if (!WriteEbmlMasterElement(writer, kMkvSeek, entry_size[i])) return false; if (!WriteEbmlElement(writer, kMkvSeekID, static_cast<uint64>(seek_entry_id_[i]))) return false; if (!WriteEbmlElement(writer, kMkvSeekPosition, seek_entry_pos_[i])) return false; } } const uint64 total_entry_size = kSeekEntryCount * MaxEntrySize(); const uint64 total_size = EbmlMasterElementSize(kMkvSeekHead, total_entry_size) + total_entry_size; const int64 size_left = total_size - (writer->Position() - start_pos_); const uint64 bytes_written = WriteVoidElement(writer, size_left); if (!bytes_written) return false; if (writer->Position(pos)) return false; } return true; } bool SeekHead::Write(IMkvWriter* writer) { const uint64 entry_size = kSeekEntryCount * MaxEntrySize(); const uint64 size = EbmlMasterElementSize(kMkvSeekHead, entry_size); start_pos_ = writer->Position(); const uint64 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) { if (seek_entry_id_[i] == 0) { seek_entry_id_[i] = id; seek_entry_pos_[i] = pos; return true; } } return false; } uint32 SeekHead::GetId(int index) const { if (index < 0 || index >= kSeekEntryCount) return UINT_MAX; return seek_entry_id_[index]; } uint64 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) { if (index < 0 || index >= kSeekEntryCount) return false; seek_entry_id_[index] = id; seek_entry_pos_[index] = position; return true; } uint64 SeekHead::MaxEntrySize() const { const uint64 max_entry_payload_size = EbmlElementSize(kMkvSeekID, 0xffffffffULL) + EbmlElementSize(kMkvSeekPosition, 0xffffffffffffffffULL); const uint64 max_entry_size = EbmlMasterElementSize(kMkvSeek, max_entry_payload_size) + max_entry_payload_size; return max_entry_size; } /////////////////////////////////////////////////////////////// // // SegmentInfo Class SegmentInfo::SegmentInfo() : duration_(-1.0), muxing_app_(NULL), timecode_scale_(1000000ULL), writing_app_(NULL), date_utc_(LLONG_MIN), duration_pos_(-1) {} SegmentInfo::~SegmentInfo() { delete[] muxing_app_; delete[] writing_app_; } bool SegmentInfo::Init() { int32 major; int32 minor; int32 build; int32 revision; GetVersion(&major, &minor, &build, &revision); char temp[256]; #ifdef _MSC_VER sprintf_s(temp, sizeof(temp) / sizeof(temp[0]), "libwebm-%d.%d.%d.%d", major, minor, build, revision); #else snprintf(temp, sizeof(temp) / sizeof(temp[0]), "libwebm-%d.%d.%d.%d", major, minor, build, revision); #endif const size_t app_len = strlen(temp) + 1; delete[] muxing_app_; muxing_app_ = new (std::nothrow) char[app_len]; // NOLINT if (!muxing_app_) return false; #ifdef _MSC_VER strcpy_s(muxing_app_, app_len, temp); #else strcpy(muxing_app_, temp); #endif set_writing_app(temp); if (!writing_app_) return false; return true; } bool SegmentInfo::Finalize(IMkvWriter* writer) const { if (!writer) return false; if (duration_ > 0.0) { if (writer->Seekable()) { if (duration_pos_ == -1) return false; const int64 pos = writer->Position(); if (writer->Position(duration_pos_)) return false; if (!WriteEbmlElement(writer, kMkvDuration, static_cast<float>(duration_))) return false; if (writer->Position(pos)) return false; } } return true; } bool SegmentInfo::Write(IMkvWriter* writer) { if (!writer || !muxing_app_ || !writing_app_) return false; uint64 size = EbmlElementSize(kMkvTimecodeScale, timecode_scale_); if (duration_ > 0.0) size += EbmlElementSize(kMkvDuration, static_cast<float>(duration_)); if (date_utc_ != LLONG_MIN) size += EbmlDateElementSize(kMkvDateUTC); size += EbmlElementSize(kMkvMuxingApp, muxing_app_); size += EbmlElementSize(kMkvWritingApp, writing_app_); if (!WriteEbmlMasterElement(writer, kMkvInfo, size)) return false; const int64 payload_position = writer->Position(); if (payload_position < 0) return false; if (!WriteEbmlElement(writer, kMkvTimecodeScale, timecode_scale_)) return false; if (duration_ > 0.0) { // Save for later duration_pos_ = writer->Position(); if (!WriteEbmlElement(writer, kMkvDuration, static_cast<float>(duration_))) return false; } if (date_utc_ != LLONG_MIN) WriteEbmlDateElement(writer, kMkvDateUTC, date_utc_); if (!WriteEbmlElement(writer, kMkvMuxingApp, muxing_app_)) return false; if (!WriteEbmlElement(writer, kMkvWritingApp, writing_app_)) return false; const int64 stop_position = writer->Position(); if (stop_position < 0 || stop_position - payload_position != static_cast<int64>(size)) return false; return true; } void SegmentInfo::set_muxing_app(const char* app) { if (app) { const size_t length = strlen(app) + 1; char* temp_str = new (std::nothrow) char[length]; // NOLINT if (!temp_str) return; #ifdef _MSC_VER strcpy_s(temp_str, length, app); #else strcpy(temp_str, app); #endif delete[] muxing_app_; muxing_app_ = temp_str; } } void SegmentInfo::set_writing_app(const char* app) { if (app) { const size_t length = strlen(app) + 1; char* temp_str = new (std::nothrow) char[length]; // NOLINT if (!temp_str) return; #ifdef _MSC_VER strcpy_s(temp_str, length, app); #else strcpy(temp_str, app); #endif delete[] writing_app_; writing_app_ = temp_str; } } /////////////////////////////////////////////////////////////// // // Segment Class Segment::Segment() : chunk_count_(0), chunk_name_(NULL), chunk_writer_cluster_(NULL), chunk_writer_cues_(NULL), chunk_writer_header_(NULL), chunking_(false), chunking_base_name_(NULL), cluster_list_(NULL), cluster_list_capacity_(0), cluster_list_size_(0), cues_position_(kAfterClusters), cues_track_(0), force_new_cluster_(false), frames_(NULL), frames_capacity_(0), frames_size_(0), has_video_(false), header_written_(false), last_block_duration_(0), last_timestamp_(0), max_cluster_duration_(kDefaultMaxClusterDuration), max_cluster_size_(0), mode_(kFile), new_cuepoint_(false), output_cues_(true), payload_pos_(0), size_position_(0), doc_type_version_(kDefaultDocTypeVersion), doc_type_version_written_(0), writer_cluster_(NULL), writer_cues_(NULL), writer_header_(NULL) { const time_t curr_time = time(NULL); seed_ = static_cast<unsigned int>(curr_time); #ifdef _WIN32 srand(seed_); #endif } Segment::~Segment() { if (cluster_list_) { for (int32 i = 0; i < cluster_list_size_; ++i) { Cluster* const cluster = cluster_list_[i]; delete cluster; } delete[] cluster_list_; } if (frames_) { for (int32 i = 0; i < frames_size_; ++i) { Frame* const frame = frames_[i]; delete frame; } delete[] frames_; } delete[] chunk_name_; delete[] chunking_base_name_; if (chunk_writer_cluster_) { chunk_writer_cluster_->Close(); delete chunk_writer_cluster_; } if (chunk_writer_cues_) { chunk_writer_cues_->Close(); delete chunk_writer_cues_; } if (chunk_writer_header_) { chunk_writer_header_->Close(); delete chunk_writer_header_; } } void Segment::MoveCuesBeforeClustersHelper(uint64 diff, int32 index, uint64* 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; 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 // Let b = Increase in Cue Point's size due to this iteration // Let c = Increase in size of Cues Element's length due to this iteration // (This is computed as CodedSize(a + b) - CodedSize(a)) // 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 = 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) { 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) cue_size += cues_.GetCueByIndex(i)->Size(); for (int32 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) { if (seek_head_.GetId(i) == kMkvCluster) cluster_index = i; if (seek_head_.GetId(i) == kMkvCues) cues_index = i; } seek_head_.SetSeekEntry(cues_index, kMkvCues, seek_head_.GetPosition(cluster_index)); seek_head_.SetSeekEntry(cluster_index, kMkvCluster, cues_.Size() + seek_head_.GetPosition(cues_index)); } bool Segment::Init(IMkvWriter* ptr_writer) { if (!ptr_writer) { return false; } writer_cluster_ = ptr_writer; writer_cues_ = ptr_writer; writer_header_ = ptr_writer; return segment_info_.Init(); } bool Segment::CopyAndMoveCuesBeforeClusters(mkvparser::IMkvReader* reader, IMkvWriter* writer) { if (!writer->Seekable() || chunking_) return false; const int64 cluster_offset = cluster_list_[0]->size_position() - GetUIntSize(kMkvCluster); // Copy the headers. if (!ChunkedCopy(reader, writer, 0, cluster_offset)) return false; // Recompute cue positions and seek entries. MoveCuesBeforeClusters(); // Write cues and seek entries. // TODO(vigneshv): As of now, it's safe to call seek_head_.Finalize() for the // second time with a different writer object. But the name Finalize() doesn't // indicate something we want to call more than once. So consider renaming it // to write() or some such. if (!cues_.Write(writer) || !seek_head_.Finalize(writer)) return false; // Copy the Clusters. if (!ChunkedCopy(reader, writer, cluster_offset, cluster_end_offset_ - cluster_offset)) 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_; if (writer->Position(size_position_) || WriteUIntSize(writer, segment_size, 8) || writer->Position(pos)) return false; return true; } bool Segment::Finalize() { if (WriteFramesAll() < 0) return false; if (mode_ == kFile) { if (cluster_list_size_ > 0) { // Update last cluster's size Cluster* const old_cluster = cluster_list_[cluster_list_size_ - 1]; if (!old_cluster || !old_cluster->Finalize()) return false; } if (chunking_ && chunk_writer_cluster_) { chunk_writer_cluster_->Close(); chunk_count_++; } const double duration = (static_cast<double>(last_timestamp_) + last_block_duration_) / segment_info_.timecode_scale(); segment_info_.set_duration(duration); if (!segment_info_.Finalize(writer_header_)) return false; if (output_cues_) if (!seek_head_.AddSeekEntry(kMkvCues, MaxOffset())) return false; if (chunking_) { if (!chunk_writer_cues_) return false; char* name = NULL; if (!UpdateChunkName("cues", &name)) return false; const bool cues_open = chunk_writer_cues_->Open(name); delete[] name; if (!cues_open) return false; } cluster_end_offset_ = writer_cluster_->Position(); // Write the seek headers and cues if (output_cues_) if (!cues_.Write(writer_cues_)) return false; if (!seek_head_.Finalize(writer_header_)) return false; if (writer_header_->Seekable()) { if (size_position_ == -1) return false; const int64 segment_size = MaxOffset(); if (segment_size < 1) return false; const int64 pos = writer_header_->Position(); UpdateDocTypeVersion(); if (doc_type_version_ != doc_type_version_written_) { if (writer_header_->Position(0)) return false; if (!WriteEbmlHeader(writer_header_, doc_type_version_)) return false; if (writer_header_->Position() != ebml_header_size_) return false; doc_type_version_written_ = doc_type_version_; } if (writer_header_->Position(size_position_)) return false; if (WriteUIntSize(writer_header_, segment_size, 8)) return false; if (writer_header_->Position(pos)) return false; } if (chunking_) { // Do not close any writers until the segment size has been written, // otherwise the size may be off. if (!chunk_writer_cues_ || !chunk_writer_header_) return false; chunk_writer_cues_->Close(); chunk_writer_header_->Close(); } } return true; } Track* Segment::AddTrack(int32 number) { Track* const track = new (std::nothrow) Track(&seed_); // NOLINT if (!track) return NULL; if (!tracks_.AddTrack(track, number)) { delete track; return NULL; } return track; } Chapter* Segment::AddChapter() { return chapters_.AddChapter(&seed_); } Tag* Segment::AddTag() { return tags_.AddTag(); } uint64 Segment::AddVideoTrack(int32 width, int32 height, int32 number) { VideoTrack* const track = new (std::nothrow) VideoTrack(&seed_); // NOLINT if (!track) return 0; track->set_type(Tracks::kVideo); track->set_codec_id(Tracks::kVp8CodecId); track->set_width(width); track->set_height(height); tracks_.AddTrack(track, number); has_video_ = true; return track->number(); } bool Segment::AddCuePoint(uint64 timestamp, uint64 track) { if (cluster_list_size_ < 1) return false; const Cluster* const cluster = cluster_list_[cluster_list_size_ - 1]; if (!cluster) return false; CuePoint* const cue = new (std::nothrow) CuePoint(); // NOLINT if (!cue) return false; cue->set_time(timestamp / segment_info_.timecode_scale()); cue->set_block_number(cluster->blocks_added()); cue->set_cluster_pos(cluster->position_for_cues()); cue->set_track(track); if (!cues_.AddCue(cue)) return false; new_cuepoint_ = false; return true; } uint64 Segment::AddAudioTrack(int32 sample_rate, int32 channels, int32 number) { AudioTrack* const track = new (std::nothrow) AudioTrack(&seed_); // NOLINT if (!track) return 0; track->set_type(Tracks::kAudio); track->set_codec_id(Tracks::kVorbisCodecId); track->set_sample_rate(sample_rate); track->set_channels(channels); tracks_.AddTrack(track, number); return track->number(); } bool Segment::AddFrame(const uint8* data, uint64 length, uint64 track_number, uint64 timestamp, bool is_key) { if (!data) return false; Frame frame; if (!frame.Init(data, length)) return false; frame.set_track_number(track_number); frame.set_timestamp(timestamp); frame.set_is_key(is_key); 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) { if (!data || !additional) return false; Frame frame; if (!frame.Init(data, length) || !frame.AddAdditionalData(additional, additional_length, add_id)) { return false; } frame.set_track_number(track_number); frame.set_timestamp(timestamp); frame.set_is_key(is_key); return AddGenericFrame(&frame); } bool Segment::AddFrameWithDiscardPadding(const uint8* data, uint64 length, int64 discard_padding, uint64 track_number, uint64 timestamp, bool is_key) { if (!data) return false; Frame frame; if (!frame.Init(data, length)) return false; frame.set_discard_padding(discard_padding); frame.set_track_number(track_number); frame.set_timestamp(timestamp); frame.set_is_key(is_key); return AddGenericFrame(&frame); } bool Segment::AddMetadata(const uint8* data, uint64 length, uint64 track_number, uint64 timestamp_ns, uint64 duration_ns) { if (!data) return false; Frame frame; if (!frame.Init(data, length)) return false; frame.set_track_number(track_number); frame.set_timestamp(timestamp_ns); frame.set_duration(duration_ns); frame.set_is_key(true); // All metadata blocks are keyframes. return AddGenericFrame(&frame); } bool Segment::AddGenericFrame(const Frame* frame) { if (!frame) return false; if (!CheckHeaderInfo()) return false; // Check for non-monotonically increasing timestamps. if (frame->timestamp() < last_timestamp_) return false; // Check if the track number is valid. if (!tracks_.GetTrackByNumber(frame->track_number())) return false; if (frame->discard_padding() != 0) doc_type_version_ = 4; // If the segment has a video track hold onto audio frames to make sure the // audio that is associated with the start time of a video key-frame is // muxed into the same cluster. if (has_video_ && tracks_.TrackIsAudio(frame->track_number()) && !force_new_cluster_) { Frame* const new_frame = new (std::nothrow) Frame(); if (!new_frame || !new_frame->CopyFrom(*frame)) return false; return QueueFrame(new_frame); } if (!DoNewClusterProcessing(frame->track_number(), frame->timestamp(), frame->is_key())) { return false; } if (cluster_list_size_ < 1) return false; Cluster* const cluster = cluster_list_[cluster_list_size_ - 1]; if (!cluster) return false; // If the Frame is not a SimpleBlock, then set the reference_block_timestamp // if it is not set already. bool frame_created = false; if (!frame->CanBeSimpleBlock() && !frame->is_key() && !frame->reference_block_timestamp_set()) { Frame* const new_frame = new (std::nothrow) Frame(); if (!new_frame->CopyFrom(*frame)) return false; new_frame->set_reference_block_timestamp( last_track_timestamp_[frame->track_number() - 1]); frame = new_frame; frame_created = true; } if (!cluster->AddFrame(frame)) return false; if (new_cuepoint_ && cues_track_ == frame->track_number()) { if (!AddCuePoint(frame->timestamp(), cues_track_)) return false; } last_timestamp_ = frame->timestamp(); last_track_timestamp_[frame->track_number() - 1] = frame->timestamp(); last_block_duration_ = frame->duration(); if (frame_created) delete frame; return true; } void Segment::OutputCues(bool output_cues) { output_cues_ = output_cues; } bool Segment::SetChunking(bool chunking, const char* filename) { if (chunk_count_ > 0) return false; if (chunking) { if (!filename) return false; // Check if we are being set to what is already set. if (chunking_ && !strcmp(filename, chunking_base_name_)) return true; const size_t name_length = strlen(filename) + 1; char* const temp = new (std::nothrow) char[name_length]; // NOLINT if (!temp) return false; #ifdef _MSC_VER strcpy_s(temp, name_length, filename); #else strcpy(temp, filename); #endif delete[] chunking_base_name_; chunking_base_name_ = temp; if (!UpdateChunkName("chk", &chunk_name_)) return false; if (!chunk_writer_cluster_) { chunk_writer_cluster_ = new (std::nothrow) MkvWriter(); // NOLINT if (!chunk_writer_cluster_) return false; } if (!chunk_writer_cues_) { chunk_writer_cues_ = new (std::nothrow) MkvWriter(); // NOLINT if (!chunk_writer_cues_) return false; } if (!chunk_writer_header_) { chunk_writer_header_ = new (std::nothrow) MkvWriter(); // NOLINT if (!chunk_writer_header_) return false; } if (!chunk_writer_cluster_->Open(chunk_name_)) return false; const size_t header_length = strlen(filename) + strlen(".hdr") + 1; char* const header = new (std::nothrow) char[header_length]; // NOLINT if (!header) return false; #ifdef _MSC_VER strcpy_s(header, header_length - strlen(".hdr"), chunking_base_name_); strcat_s(header, header_length, ".hdr"); #else strcpy(header, chunking_base_name_); strcat(header, ".hdr"); #endif if (!chunk_writer_header_->Open(header)) { delete[] header; return false; } writer_cluster_ = chunk_writer_cluster_; writer_cues_ = chunk_writer_cues_; writer_header_ = chunk_writer_header_; delete[] header; } chunking_ = chunking; return true; } bool Segment::CuesTrack(uint64 track_number) { const Track* const track = GetTrackByNumber(track_number); if (!track) return false; cues_track_ = track_number; return true; } void Segment::ForceNewClusterOnNextFrame() { force_new_cluster_ = true; } Track* Segment::GetTrackByNumber(uint64 track_number) const { return tracks_.GetTrackByNumber(track_number); } bool Segment::WriteSegmentHeader() { UpdateDocTypeVersion(); // TODO(fgalligan): Support more than one segment. if (!WriteEbmlHeader(writer_header_, doc_type_version_)) return false; doc_type_version_written_ = doc_type_version_; ebml_header_size_ = static_cast<int32>(writer_header_->Position()); // Write "unknown" (-1) as segment size value. If mode is kFile, Segment // will write over duration when the file is finalized. if (WriteID(writer_header_, kMkvSegment)) return false; // Save for later. size_position_ = writer_header_->Position(); // Write "unknown" (EBML coded -1) as segment size value. We need to write 8 // bytes because if we are going to overwrite the segment size later we do // not know how big our segment will be. if (SerializeInt(writer_header_, kEbmlUnknownValue, 8)) return false; payload_pos_ = writer_header_->Position(); if (mode_ == kFile && writer_header_->Seekable()) { // Set the duration > 0.0 so SegmentInfo will write out the duration. When // the muxer is done writing we will set the correct duration and have // SegmentInfo upadte it. segment_info_.set_duration(1.0); if (!seek_head_.Write(writer_header_)) return false; } if (!seek_head_.AddSeekEntry(kMkvInfo, MaxOffset())) return false; if (!segment_info_.Write(writer_header_)) return false; if (!seek_head_.AddSeekEntry(kMkvTracks, MaxOffset())) return false; if (!tracks_.Write(writer_header_)) return false; if (chapters_.Count() > 0) { if (!seek_head_.AddSeekEntry(kMkvChapters, MaxOffset())) return false; if (!chapters_.Write(writer_header_)) return false; } if (tags_.Count() > 0) { if (!seek_head_.AddSeekEntry(kMkvTags, MaxOffset())) return false; if (!tags_.Write(writer_header_)) return false; } if (chunking_ && (mode_ == kLive || !writer_header_->Seekable())) { if (!chunk_writer_header_) return false; chunk_writer_header_->Close(); } header_written_ = true; return true; } // 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, bool is_key) const { if (force_new_cluster_) return 1; // If no clusters have been created yet, then create a new cluster // and write this frame immediately, in the new cluster. This path // should only be followed once, the first time we attempt to write // a frame. if (cluster_list_size_ <= 0) return 1; // There exists at least one cluster. We must compare the frame to // the last cluster, in order to determine whether the frame is // 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 Cluster* const last_cluster = cluster_list_[cluster_list_size_ - 1]; const uint64 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 // is allowed, this muxer doesn't actually write clusters like that, // so this indicates a bug somewhere in our algorithm. if (frame_timecode < last_cluster_timecode) // should never happen return -1; // If the frame has a timestamp significantly larger than the last // cluster (in Matroska, cluster-relative timestamps are serialized // 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; if (delta_timecode > kMaxBlockTimecode) return 2; // We decide to create a new cluster when we have a video keyframe. // This will flush queued (audio) frames, and write the keyframe // immediately, in the newly-created cluster. if (is_key && tracks_.TrackIsVideo(track_number)) return 1; // Create a new cluster if we have accumulated too many frames // 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; if (max_cluster_duration_ > 0 && delta_ns >= max_cluster_duration_) return 1; // This is similar to the case above, with the difference that a new // cluster is created when the size of the current cluster exceeds a // threshold. const uint64 cluster_size = last_cluster->payload_size(); if (max_cluster_size_ > 0 && cluster_size >= max_cluster_size_) return 1; // There's no need to create a new cluster, so emit this frame now. return 0; } bool Segment::MakeNewCluster(uint64 frame_timestamp_ns) { const int32 new_size = cluster_list_size_ + 1; if (new_size > cluster_list_capacity_) { // Add more clusters. const int32 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) { clusters[i] = cluster_list_[i]; } delete[] cluster_list_; cluster_list_ = clusters; cluster_list_capacity_ = new_capacity; } if (!WriteFramesLessThan(frame_timestamp_ns)) return false; if (mode_ == kFile) { if (cluster_list_size_ > 0) { // Update old cluster's size Cluster* const old_cluster = cluster_list_[cluster_list_size_ - 1]; if (!old_cluster || !old_cluster->Finalize()) return false; } if (output_cues_) new_cuepoint_ = true; } if (chunking_ && cluster_list_size_ > 0) { chunk_writer_cluster_->Close(); chunk_count_++; if (!UpdateChunkName("chk", &chunk_name_)) return false; if (!chunk_writer_cluster_->Open(chunk_name_)) return false; } const uint64 timecode_scale = segment_info_.timecode_scale(); const uint64 frame_timecode = frame_timestamp_ns / timecode_scale; uint64 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; if (tc < cluster_timecode) cluster_timecode = tc; } Cluster*& cluster = cluster_list_[cluster_list_size_]; const int64 offset = MaxOffset(); cluster = new (std::nothrow) Cluster(cluster_timecode, // NOLINT offset, segment_info_.timecode_scale()); if (!cluster) return false; if (!cluster->Init(writer_cluster_)) return false; cluster_list_size_ = new_size; return true; } bool Segment::DoNewClusterProcessing(uint64 track_number, uint64 frame_timestamp_ns, bool is_key) { for (;;) { // Based on the characteristics of the current frame and current // cluster, decide whether to create a new cluster. const int result = TestFrame(track_number, frame_timestamp_ns, is_key); if (result < 0) // error return false; // Always set force_new_cluster_ to false after TestFrame. force_new_cluster_ = false; // A non-zero result means create a new cluster. if (result > 0 && !MakeNewCluster(frame_timestamp_ns)) return false; // Write queued (audio) frames. const int frame_count = WriteFramesAll(); if (frame_count < 0) // error return false; // Write the current frame to the current cluster (if TestFrame // returns 0) or to a newly created cluster (TestFrame returns 1). if (result <= 1) return true; // TestFrame returned 2, which means there was a large time // difference between the cluster and the frame itself. Do the // test again, comparing the frame to the new cluster. } } bool Segment::CheckHeaderInfo() { if (!header_written_) { if (!WriteSegmentHeader()) return false; if (!seek_head_.AddSeekEntry(kMkvCluster, MaxOffset())) return false; if (output_cues_ && cues_track_ == 0) { // Check for a video track for (uint32 i = 0; i < tracks_.track_entries_size(); ++i) { const Track* const track = tracks_.GetTrackByIndex(i); if (!track) return false; if (tracks_.TrackIsVideo(track->number())) { cues_track_ = track->number(); break; } } // Set first track found if (cues_track_ == 0) { const Track* const track = tracks_.GetTrackByIndex(0); if (!track) return false; cues_track_ = track->number(); } } } return true; } void Segment::UpdateDocTypeVersion() { for (uint32 index = 0; index < tracks_.track_entries_size(); ++index) { const Track* track = tracks_.GetTrackByIndex(index); if (track == NULL) break; if ((track->codec_delay() || track->seek_pre_roll()) && doc_type_version_ < 4) { doc_type_version_ = 4; break; } } } bool Segment::UpdateChunkName(const char* ext, char** name) const { if (!name || !ext) return false; char ext_chk[64]; #ifdef _MSC_VER sprintf_s(ext_chk, sizeof(ext_chk), "_%06d.%s", chunk_count_, ext); #else snprintf(ext_chk, sizeof(ext_chk), "_%06d.%s", chunk_count_, ext); #endif const size_t length = strlen(chunking_base_name_) + strlen(ext_chk) + 1; char* const str = new (std::nothrow) char[length]; // NOLINT if (!str) return false; #ifdef _MSC_VER strcpy_s(str, length - strlen(ext_chk), chunking_base_name_); strcat_s(str, length, ext_chk); #else strcpy(str, chunking_base_name_); strcat(str, ext_chk); #endif delete[] * name; *name = str; return true; } int64 Segment::MaxOffset() { if (!writer_header_) return -1; int64 offset = writer_header_->Position() - payload_pos_; if (chunking_) { for (int32 i = 0; i < cluster_list_size_; ++i) { Cluster* const cluster = cluster_list_[i]; offset += cluster->Size(); } if (writer_cues_) offset += writer_cues_->Position(); } return offset; } bool Segment::QueueFrame(Frame* frame) { const int32 new_size = frames_size_ + 1; if (new_size > frames_capacity_) { // Add more frames. const int32 new_capacity = (!frames_capacity_) ? 2 : frames_capacity_ * 2; if (new_capacity < 1) return false; Frame** const frames = new (std::nothrow) Frame*[new_capacity]; // NOLINT if (!frames) return false; for (int32 i = 0; i < frames_size_; ++i) { frames[i] = frames_[i]; } delete[] frames_; frames_ = frames; frames_capacity_ = new_capacity; } frames_[frames_size_++] = frame; return true; } int Segment::WriteFramesAll() { if (frames_ == NULL) return 0; if (cluster_list_size_ < 1) return -1; Cluster* const cluster = cluster_list_[cluster_list_size_ - 1]; if (!cluster) return -1; for (int32 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. if (frame->discard_padding() != 0) doc_type_version_ = 4; if (!cluster->AddFrame(frame)) return -1; if (new_cuepoint_ && cues_track_ == frame->track_number()) { if (!AddCuePoint(frame->timestamp(), cues_track_)) return -1; } if (frame->timestamp() > last_timestamp_) { last_timestamp_ = frame->timestamp(); last_track_timestamp_[frame->track_number() - 1] = frame->timestamp(); } delete frame; frame = NULL; } const int result = frames_size_; frames_size_ = 0; return result; } bool Segment::WriteFramesLessThan(uint64 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. if (frames_size_ > 0 && cluster_list_size_ > 0) { if (!frames_) return false; Cluster* const cluster = cluster_list_[cluster_list_size_ - 1]; if (!cluster) return false; int32 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) { const Frame* const frame_curr = frames_[i]; if (frame_curr->timestamp() > timestamp) break; const Frame* const frame_prev = frames_[i - 1]; if (frame_prev->discard_padding() != 0) doc_type_version_ = 4; if (!cluster->AddFrame(frame_prev)) return false; if (new_cuepoint_ && cues_track_ == frame_prev->track_number()) { if (!AddCuePoint(frame_prev->timestamp(), cues_track_)) return false; } ++shift_left; if (frame_prev->timestamp() > last_timestamp_) { last_timestamp_ = frame_prev->timestamp(); last_track_timestamp_[frame_prev->track_number() - 1] = frame_prev->timestamp(); } delete frame_prev; } if (shift_left > 0) { 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) { frames_[i] = frames_[i + shift_left]; } frames_size_ = new_frames_size; } } return true; } } // namespace mkvmuxer