blob: c79ce24ed35d5d15497343d252ba2f4e6e185ef6 [file] [log] [blame]
// 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/mkvmuxer.h"
#include <cfloat>
#include <climits>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <memory>
#include <new>
#include <vector>
#include "common/webmids.h"
#include "mkvmuxer/mkvmuxerutil.h"
#include "mkvmuxer/mkvwriter.h"
#include "mkvparser/mkvparser.h"
namespace mkvmuxer {
const float MasteringMetadata::kValueNotPresent = FLT_MAX;
const uint64_t Colour::kValueNotPresent = UINT64_MAX;
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;
}
typedef std::auto_ptr<PrimaryChromaticity> PrimaryChromaticityPtr;
bool CopyChromaticity(const PrimaryChromaticity* src,
PrimaryChromaticityPtr* dst) {
if (!dst)
return false;
dst->reset(new (std::nothrow) PrimaryChromaticity(src->x, src->y));
if (!dst->get())
return false;
return true;
}
} // namespace
///////////////////////////////////////////////////////////////
//
// IMkvWriter Class
IMkvWriter::IMkvWriter() {}
IMkvWriter::~IMkvWriter() {}
bool WriteEbmlHeader(IMkvWriter* writer, uint64_t doc_type_version) {
// Level 0
uint64_t size = EbmlElementSize(libwebm::kMkvEBMLVersion, UINT64_C(1));
size += EbmlElementSize(libwebm::kMkvEBMLReadVersion, UINT64_C(1));
size += EbmlElementSize(libwebm::kMkvEBMLMaxIDLength, UINT64_C(4));
size += EbmlElementSize(libwebm::kMkvEBMLMaxSizeLength, UINT64_C(8));
size += EbmlElementSize(libwebm::kMkvDocType, "webm");
size += EbmlElementSize(libwebm::kMkvDocTypeVersion, doc_type_version);
size += EbmlElementSize(libwebm::kMkvDocTypeReadVersion, UINT64_C(2));
if (!WriteEbmlMasterElement(writer, libwebm::kMkvEBML, size))
return false;
if (!WriteEbmlElement(writer, libwebm::kMkvEBMLVersion, UINT64_C(1)))
return false;
if (!WriteEbmlElement(writer, libwebm::kMkvEBMLReadVersion, UINT64_C(1)))
return false;
if (!WriteEbmlElement(writer, libwebm::kMkvEBMLMaxIDLength, UINT64_C(4)))
return false;
if (!WriteEbmlElement(writer, libwebm::kMkvEBMLMaxSizeLength, UINT64_C(8)))
return false;
if (!WriteEbmlElement(writer, libwebm::kMkvDocType, "webm"))
return false;
if (!WriteEbmlElement(writer, libwebm::kMkvDocTypeVersion, doc_type_version))
return false;
if (!WriteEbmlElement(writer, libwebm::kMkvDocTypeReadVersion, UINT64_C(2)))
return false;
return true;
}
bool WriteEbmlHeader(IMkvWriter* writer) {
return WriteEbmlHeader(writer, mkvmuxer::Segment::kDefaultDocTypeVersion);
}
bool ChunkedCopy(mkvparser::IMkvReader* source, mkvmuxer::IMkvWriter* dst,
int64_t start, int64_t size) {
// TODO(vigneshv): Check if this is a reasonable value.
const uint32_t kBufSize = 2048;
uint8_t* buf = new uint8_t[kBufSize];
int64_t offset = start;
while (size > 0) {
const int64_t read_len = (size > kBufSize) ? kBufSize : size;
if (source->Read(offset, static_cast<long>(read_len), buf))
return false;
dst->Write(buf, static_cast<uint32_t>(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),
duration_set_(false),
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();
duration_set_ = frame.duration_set();
is_key_ = frame.is_key();
track_number_ = frame.track_number();
timestamp_ = frame.timestamp();
discard_padding_ = frame.discard_padding();
reference_block_timestamp_ = frame.reference_block_timestamp();
reference_block_timestamp_set_ = frame.reference_block_timestamp_set();
return true;
}
bool Frame::Init(const uint8_t* frame, uint64_t length) {
uint8_t* const data =
new (std::nothrow) uint8_t[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_t* additional, uint64_t length,
uint64_t add_id) {
uint8_t* const data =
new (std::nothrow) uint8_t[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_duration(uint64_t duration) {
duration_ = duration;
duration_set_ = true;
}
void Frame::set_reference_block_timestamp(int64_t 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_t size =
EbmlElementSize(libwebm::kMkvCueClusterPosition, cluster_pos_);
size += EbmlElementSize(libwebm::kMkvCueTrack, track_);
if (output_block_number_ && block_number_ > 1)
size += EbmlElementSize(libwebm::kMkvCueBlockNumber, block_number_);
const uint64_t track_pos_size =
EbmlMasterElementSize(libwebm::kMkvCueTrackPositions, size) + size;
const uint64_t payload_size =
EbmlElementSize(libwebm::kMkvCueTime, time_) + track_pos_size;
if (!WriteEbmlMasterElement(writer, libwebm::kMkvCuePoint, payload_size))
return false;
const int64_t payload_position = writer->Position();
if (payload_position < 0)
return false;
if (!WriteEbmlElement(writer, libwebm::kMkvCueTime, time_))
return false;
if (!WriteEbmlMasterElement(writer, libwebm::kMkvCueTrackPositions, size))
return false;
if (!WriteEbmlElement(writer, libwebm::kMkvCueTrack, track_))
return false;
if (!WriteEbmlElement(writer, libwebm::kMkvCueClusterPosition, cluster_pos_))
return false;
if (output_block_number_ && block_number_ > 1)
if (!WriteEbmlElement(writer, libwebm::kMkvCueBlockNumber, block_number_))
return false;
const int64_t stop_position = writer->Position();
if (stop_position < 0)
return false;
if (stop_position - payload_position != static_cast<int64_t>(payload_size))
return false;
return true;
}
uint64_t CuePoint::PayloadSize() const {
uint64_t size =
EbmlElementSize(libwebm::kMkvCueClusterPosition, cluster_pos_);
size += EbmlElementSize(libwebm::kMkvCueTrack, track_);
if (output_block_number_ && block_number_ > 1)
size += EbmlElementSize(libwebm::kMkvCueBlockNumber, block_number_);
const uint64_t track_pos_size =
EbmlMasterElementSize(libwebm::kMkvCueTrackPositions, size) + size;
const uint64_t payload_size =
EbmlElementSize(libwebm::kMkvCueTime, time_) + track_pos_size;
return payload_size;
}
uint64_t CuePoint::Size() const {
const uint64_t payload_size = PayloadSize();
return EbmlMasterElementSize(libwebm::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_t 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_t 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_t 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_t index) const {
if (cue_entries_ == NULL)
return NULL;
if (index >= cue_entries_size_)
return NULL;
return cue_entries_[index];
}
uint64_t Cues::Size() {
uint64_t size = 0;
for (int32_t i = 0; i < cue_entries_size_; ++i)
size += GetCueByIndex(i)->Size();
size += EbmlMasterElementSize(libwebm::kMkvCues, size);
return size;
}
bool Cues::Write(IMkvWriter* writer) const {
if (!writer)
return false;
uint64_t size = 0;
for (int32_t i = 0; i < cue_entries_size_; ++i) {
const CuePoint* const cue = GetCueByIndex(i);
if (!cue)
return false;
size += cue->Size();
}
if (!WriteEbmlMasterElement(writer, libwebm::kMkvCues, size))
return false;
const int64_t payload_position = writer->Position();
if (payload_position < 0)
return false;
for (int32_t i = 0; i < cue_entries_size_; ++i) {
const CuePoint* const cue = GetCueByIndex(i);
if (!cue->Write(writer))
return false;
}
const int64_t stop_position = writer->Position();
if (stop_position < 0)
return false;
if (stop_position - payload_position != static_cast<int64_t>(size))
return false;
return true;
}
///////////////////////////////////////////////////////////////
//
// ContentEncAESSettings Class
ContentEncAESSettings::ContentEncAESSettings() : cipher_mode_(kCTR) {}
uint64_t ContentEncAESSettings::Size() const {
const uint64_t payload = PayloadSize();
const uint64_t size =
EbmlMasterElementSize(libwebm::kMkvContentEncAESSettings, payload) +
payload;
return size;
}
bool ContentEncAESSettings::Write(IMkvWriter* writer) const {
const uint64_t payload = PayloadSize();
if (!WriteEbmlMasterElement(writer, libwebm::kMkvContentEncAESSettings,
payload))
return false;
const int64_t payload_position = writer->Position();
if (payload_position < 0)
return false;
if (!WriteEbmlElement(writer, libwebm::kMkvAESSettingsCipherMode,
cipher_mode_))
return false;
const int64_t stop_position = writer->Position();
if (stop_position < 0 ||
stop_position - payload_position != static_cast<int64_t>(payload))
return false;
return true;
}
uint64_t ContentEncAESSettings::PayloadSize() const {
uint64_t size =
EbmlElementSize(libwebm::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_t* id, uint64_t length) {
if (!id || length < 1)
return false;
delete[] enc_key_id_;
enc_key_id_ =
new (std::nothrow) uint8_t[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_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(libwebm::kMkvContentEncoding, encoding_size) +
encoding_size;
return encodings_size;
}
bool ContentEncoding::Write(IMkvWriter* writer) const {
const uint64_t encryption_size = EncryptionSize();
const uint64_t encoding_size = EncodingSize(0, encryption_size);
const uint64_t size =
EbmlMasterElementSize(libwebm::kMkvContentEncoding, encoding_size) +
encoding_size;
const int64_t payload_position = writer->Position();
if (payload_position < 0)
return false;
if (!WriteEbmlMasterElement(writer, libwebm::kMkvContentEncoding,
encoding_size))
return false;
if (!WriteEbmlElement(writer, libwebm::kMkvContentEncodingOrder,
encoding_order_))
return false;
if (!WriteEbmlElement(writer, libwebm::kMkvContentEncodingScope,
encoding_scope_))
return false;
if (!WriteEbmlElement(writer, libwebm::kMkvContentEncodingType,
encoding_type_))
return false;
if (!WriteEbmlMasterElement(writer, libwebm::kMkvContentEncryption,
encryption_size))
return false;
if (!WriteEbmlElement(writer, libwebm::kMkvContentEncAlgo, enc_algo_))
return false;
if (!WriteEbmlElement(writer, libwebm::kMkvContentEncKeyID, enc_key_id_,
enc_key_id_length_))
return false;
if (!enc_aes_settings_.Write(writer))
return false;
const int64_t stop_position = writer->Position();
if (stop_position < 0 ||
stop_position - payload_position != static_cast<int64_t>(size))
return false;
return true;
}
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_t encoding_size = 0;
if (encryption_size > 0) {
encoding_size +=
EbmlMasterElementSize(libwebm::kMkvContentEncryption, encryption_size) +
encryption_size;
}
encoding_size +=
EbmlElementSize(libwebm::kMkvContentEncodingType, encoding_type_);
encoding_size +=
EbmlElementSize(libwebm::kMkvContentEncodingScope, encoding_scope_);
encoding_size +=
EbmlElementSize(libwebm::kMkvContentEncodingOrder, encoding_order_);
return encoding_size;
}
uint64_t ContentEncoding::EncryptionSize() const {
const uint64_t aes_size = enc_aes_settings_.Size();
uint64_t encryption_size = EbmlElementSize(libwebm::kMkvContentEncKeyID,
enc_key_id_, enc_key_id_length_);
encryption_size += EbmlElementSize(libwebm::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_t 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_t 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_t 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_t index) const {
if (content_encoding_entries_ == NULL)
return NULL;
if (index >= content_encoding_entries_size_)
return NULL;
return content_encoding_entries_[index];
}
uint64_t Track::PayloadSize() const {
uint64_t size = EbmlElementSize(libwebm::kMkvTrackNumber, number_);
size += EbmlElementSize(libwebm::kMkvTrackUID, uid_);
size += EbmlElementSize(libwebm::kMkvTrackType, type_);
if (codec_id_)
size += EbmlElementSize(libwebm::kMkvCodecID, codec_id_);
if (codec_private_)
size += EbmlElementSize(libwebm::kMkvCodecPrivate, codec_private_,
codec_private_length_);
if (language_)
size += EbmlElementSize(libwebm::kMkvLanguage, language_);
if (name_)
size += EbmlElementSize(libwebm::kMkvName, name_);
if (max_block_additional_id_)
size += EbmlElementSize(libwebm::kMkvMaxBlockAdditionID,
max_block_additional_id_);
if (codec_delay_)
size += EbmlElementSize(libwebm::kMkvCodecDelay, codec_delay_);
if (seek_pre_roll_)
size += EbmlElementSize(libwebm::kMkvSeekPreRoll, seek_pre_roll_);
if (default_duration_)
size += EbmlElementSize(libwebm::kMkvDefaultDuration, default_duration_);
if (content_encoding_entries_size_ > 0) {
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();
}
size += EbmlMasterElementSize(libwebm::kMkvContentEncodings,
content_encodings_size) +
content_encodings_size;
}
return size;
}
uint64_t Track::Size() const {
uint64_t size = PayloadSize();
size += EbmlMasterElementSize(libwebm::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_t payload_size = PayloadSize();
if (!WriteEbmlMasterElement(writer, libwebm::kMkvTrackEntry, payload_size))
return false;
uint64_t size = EbmlElementSize(libwebm::kMkvTrackNumber, number_);
size += EbmlElementSize(libwebm::kMkvTrackUID, uid_);
size += EbmlElementSize(libwebm::kMkvTrackType, type_);
if (codec_id_)
size += EbmlElementSize(libwebm::kMkvCodecID, codec_id_);
if (codec_private_)
size += EbmlElementSize(libwebm::kMkvCodecPrivate, codec_private_,
codec_private_length_);
if (language_)
size += EbmlElementSize(libwebm::kMkvLanguage, language_);
if (name_)
size += EbmlElementSize(libwebm::kMkvName, name_);
if (max_block_additional_id_)
size += EbmlElementSize(libwebm::kMkvMaxBlockAdditionID,
max_block_additional_id_);
if (codec_delay_)
size += EbmlElementSize(libwebm::kMkvCodecDelay, codec_delay_);
if (seek_pre_roll_)
size += EbmlElementSize(libwebm::kMkvSeekPreRoll, seek_pre_roll_);
if (default_duration_)
size += EbmlElementSize(libwebm::kMkvDefaultDuration, default_duration_);
const int64_t payload_position = writer->Position();
if (payload_position < 0)
return false;
if (!WriteEbmlElement(writer, libwebm::kMkvTrackNumber, number_))
return false;
if (!WriteEbmlElement(writer, libwebm::kMkvTrackUID, uid_))
return false;
if (!WriteEbmlElement(writer, libwebm::kMkvTrackType, type_))
return false;
if (max_block_additional_id_) {
if (!WriteEbmlElement(writer, libwebm::kMkvMaxBlockAdditionID,
max_block_additional_id_)) {
return false;
}
}
if (codec_delay_) {
if (!WriteEbmlElement(writer, libwebm::kMkvCodecDelay, codec_delay_))
return false;
}
if (seek_pre_roll_) {
if (!WriteEbmlElement(writer, libwebm::kMkvSeekPreRoll, seek_pre_roll_))
return false;
}
if (default_duration_) {
if (!WriteEbmlElement(writer, libwebm::kMkvDefaultDuration,
default_duration_))
return false;
}
if (codec_id_) {
if (!WriteEbmlElement(writer, libwebm::kMkvCodecID, codec_id_))
return false;
}
if (codec_private_) {
if (!WriteEbmlElement(writer, libwebm::kMkvCodecPrivate, codec_private_,
codec_private_length_))
return false;
}
if (language_) {
if (!WriteEbmlElement(writer, libwebm::kMkvLanguage, language_))
return false;
}
if (name_) {
if (!WriteEbmlElement(writer, libwebm::kMkvName, name_))
return false;
}
int64_t stop_position = writer->Position();
if (stop_position < 0 ||
stop_position - payload_position != static_cast<int64_t>(size))
return false;
if (content_encoding_entries_size_ > 0) {
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();
}
if (!WriteEbmlMasterElement(writer, libwebm::kMkvContentEncodings,
content_encodings_size))
return false;
for (uint32_t 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_t* codec_private, uint64_t length) {
if (!codec_private || length < 1)
return false;
delete[] codec_private_;
codec_private_ =
new (std::nothrow) uint8_t[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
}
}
}
///////////////////////////////////////////////////////////////
//
// Colour and its child elements
uint64_t PrimaryChromaticity::PrimaryChromaticityPayloadSize(
libwebm::MkvId x_id, libwebm::MkvId y_id) const {
return EbmlElementSize(x_id, x) + EbmlElementSize(y_id, y);
}
bool PrimaryChromaticity::Write(IMkvWriter* writer, libwebm::MkvId x_id,
libwebm::MkvId y_id) const {
return WriteEbmlElement(writer, x_id, x) && WriteEbmlElement(writer, y_id, y);
}
uint64_t MasteringMetadata::MasteringMetadataSize() const {
uint64_t size = PayloadSize();
if (size > 0)
size += EbmlMasterElementSize(libwebm::kMkvMasteringMetadata, size);
return size;
}
bool MasteringMetadata::Write(IMkvWriter* writer) const {
const uint64_t size = PayloadSize();
// Don't write an empty element.
if (size == 0)
return true;
if (!WriteEbmlMasterElement(writer, libwebm::kMkvMasteringMetadata, size))
return false;
if (luminance_max != kValueNotPresent &&
!WriteEbmlElement(writer, libwebm::kMkvLuminanceMax, luminance_max)) {
return false;
}
if (luminance_min != kValueNotPresent &&
!WriteEbmlElement(writer, libwebm::kMkvLuminanceMin, luminance_min)) {
return false;
}
if (r_ &&
!r_->Write(writer, libwebm::kMkvPrimaryRChromaticityX,
libwebm::kMkvPrimaryRChromaticityY)) {
return false;
}
if (g_ &&
!g_->Write(writer, libwebm::kMkvPrimaryGChromaticityX,
libwebm::kMkvPrimaryGChromaticityY)) {
return false;
}
if (b_ &&
!b_->Write(writer, libwebm::kMkvPrimaryBChromaticityX,
libwebm::kMkvPrimaryBChromaticityY)) {
return false;
}
if (white_point_ &&
!white_point_->Write(writer, libwebm::kMkvWhitePointChromaticityX,
libwebm::kMkvWhitePointChromaticityY)) {
return false;
}
return true;
}
bool MasteringMetadata::SetChromaticity(
const PrimaryChromaticity* r, const PrimaryChromaticity* g,
const PrimaryChromaticity* b, const PrimaryChromaticity* white_point) {
PrimaryChromaticityPtr r_ptr(NULL);
if (r) {
if (!CopyChromaticity(r, &r_ptr))
return false;
}
PrimaryChromaticityPtr g_ptr(NULL);
if (g) {
if (!CopyChromaticity(g, &g_ptr))
return false;
}
PrimaryChromaticityPtr b_ptr(NULL);
if (b) {
if (!CopyChromaticity(b, &b_ptr))
return false;
}
PrimaryChromaticityPtr wp_ptr(NULL);
if (white_point) {
if (!CopyChromaticity(white_point, &wp_ptr))
return false;
}
r_ = r_ptr.release();
g_ = g_ptr.release();
b_ = b_ptr.release();
white_point_ = wp_ptr.release();
return true;
}
uint64_t MasteringMetadata::PayloadSize() const {
uint64_t size = 0;
if (luminance_max != kValueNotPresent)
size += EbmlElementSize(libwebm::kMkvLuminanceMax, luminance_max);
if (luminance_min != kValueNotPresent)
size += EbmlElementSize(libwebm::kMkvLuminanceMin, luminance_min);
if (r_) {
size += r_->PrimaryChromaticityPayloadSize(
libwebm::kMkvPrimaryRChromaticityX, libwebm::kMkvPrimaryRChromaticityY);
}
if (g_) {
size += g_->PrimaryChromaticityPayloadSize(
libwebm::kMkvPrimaryGChromaticityX, libwebm::kMkvPrimaryGChromaticityY);
}
if (b_) {
size += b_->PrimaryChromaticityPayloadSize(
libwebm::kMkvPrimaryBChromaticityX, libwebm::kMkvPrimaryBChromaticityY);
}
if (white_point_) {
size += white_point_->PrimaryChromaticityPayloadSize(
libwebm::kMkvWhitePointChromaticityX,
libwebm::kMkvWhitePointChromaticityY);
}
return size;
}
uint64_t Colour::ColourSize() const {
uint64_t size = PayloadSize();
if (size > 0)
size += EbmlMasterElementSize(libwebm::kMkvColour, size);
return size;
}
bool Colour::Write(IMkvWriter* writer) const {
const uint64_t size = PayloadSize();
// Don't write an empty element.
if (size == 0)
return true;
if (!WriteEbmlMasterElement(writer, libwebm::kMkvColour, size))
return false;
if (matrix_coefficients != kValueNotPresent &&
!WriteEbmlElement(writer, libwebm::kMkvMatrixCoefficients,
matrix_coefficients)) {
return false;
}
if (bits_per_channel != kValueNotPresent &&
!WriteEbmlElement(writer, libwebm::kMkvBitsPerChannel,
bits_per_channel)) {
return false;
}
if (chroma_subsampling_horz != kValueNotPresent &&
!WriteEbmlElement(writer, libwebm::kMkvChromaSubsamplingHorz,
chroma_subsampling_horz)) {
return false;
}
if (chroma_subsampling_vert != kValueNotPresent &&
!WriteEbmlElement(writer, libwebm::kMkvChromaSubsamplingVert,
chroma_subsampling_vert)) {
return false;
}
if (cb_subsampling_horz != kValueNotPresent &&
!WriteEbmlElement(writer, libwebm::kMkvCbSubsamplingHorz,
cb_subsampling_horz)) {
return false;
}
if (cb_subsampling_vert != kValueNotPresent &&
!WriteEbmlElement(writer, libwebm::kMkvCbSubsamplingVert,
cb_subsampling_vert)) {
return false;
}
if (chroma_siting_horz != kValueNotPresent &&
!WriteEbmlElement(writer, libwebm::kMkvChromaSitingHorz,
chroma_siting_horz)) {
return false;
}
if (chroma_siting_vert != kValueNotPresent &&
!WriteEbmlElement(writer, libwebm::kMkvChromaSitingVert,
chroma_siting_vert)) {
return false;
}
if (range != kValueNotPresent &&
!WriteEbmlElement(writer, libwebm::kMkvRange, range)) {
return false;
}
if (transfer_characteristics != kValueNotPresent &&
!WriteEbmlElement(writer, libwebm::kMkvTransferCharacteristics,
transfer_characteristics)) {
return false;
}
if (primaries != kValueNotPresent &&
!WriteEbmlElement(writer, libwebm::kMkvPrimaries, primaries)) {
return false;
}
if (max_cll != kValueNotPresent &&
!WriteEbmlElement(writer, libwebm::kMkvMaxCLL, max_cll)) {
return false;
}
if (max_fall != kValueNotPresent &&
!WriteEbmlElement(writer, libwebm::kMkvMaxFALL, max_fall)) {
return false;
}
if (mastering_metadata_ && !mastering_metadata_->Write(writer))
return false;
return true;
}
bool Colour::SetMasteringMetadata(const MasteringMetadata& mastering_metadata) {
std::auto_ptr<MasteringMetadata> mm_ptr(new MasteringMetadata());
if (!mm_ptr.get())
return false;
mm_ptr->luminance_max = mastering_metadata.luminance_max;
mm_ptr->luminance_min = mastering_metadata.luminance_min;
if (!mm_ptr->SetChromaticity(mastering_metadata.r(), mastering_metadata.g(),
mastering_metadata.b(),
mastering_metadata.white_point())) {
return false;
}
delete mastering_metadata_;
mastering_metadata_ = mm_ptr.release();
return true;
}
uint64_t Colour::PayloadSize() const {
uint64_t size = 0;
if (matrix_coefficients != kValueNotPresent)
size +=
EbmlElementSize(libwebm::kMkvMatrixCoefficients, matrix_coefficients);
if (bits_per_channel != kValueNotPresent)
size += EbmlElementSize(libwebm::kMkvBitsPerChannel, bits_per_channel);
if (chroma_subsampling_horz != kValueNotPresent)
size += EbmlElementSize(libwebm::kMkvChromaSubsamplingHorz,
chroma_subsampling_horz);
if (chroma_subsampling_vert != kValueNotPresent)
size += EbmlElementSize(libwebm::kMkvChromaSubsamplingVert,
chroma_subsampling_vert);
if (cb_subsampling_horz != kValueNotPresent)
size +=
EbmlElementSize(libwebm::kMkvCbSubsamplingHorz, cb_subsampling_horz);
if (cb_subsampling_vert != kValueNotPresent)
size +=
EbmlElementSize(libwebm::kMkvCbSubsamplingVert, cb_subsampling_vert);
if (chroma_siting_horz != kValueNotPresent)
size += EbmlElementSize(libwebm::kMkvChromaSitingHorz, chroma_siting_horz);
if (chroma_siting_vert != kValueNotPresent)
size += EbmlElementSize(libwebm::kMkvChromaSitingVert, chroma_siting_vert);
if (range != kValueNotPresent)
size += EbmlElementSize(libwebm::kMkvRange, range);
if (transfer_characteristics != kValueNotPresent)
size += EbmlElementSize(libwebm::kMkvTransferCharacteristics,
transfer_characteristics);
if (primaries != kValueNotPresent)
size += EbmlElementSize(libwebm::kMkvPrimaries, primaries);
if (max_cll != kValueNotPresent)
size += EbmlElementSize(libwebm::kMkvMaxCLL, max_cll);
if (max_fall != kValueNotPresent)
size += EbmlElementSize(libwebm::kMkvMaxFALL, max_fall);
if (mastering_metadata_)
size += mastering_metadata_->MasteringMetadataSize();
return size;
}
///////////////////////////////////////////////////////////////
//
// 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),
colour_(NULL) {}
VideoTrack::~VideoTrack() { delete colour_; }
bool VideoTrack::SetStereoMode(uint64_t 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_t alpha_mode) {
if (alpha_mode != kNoAlpha && alpha_mode != kAlpha)
return false;
alpha_mode_ = alpha_mode;
return true;
}
uint64_t VideoTrack::PayloadSize() const {
const uint64_t parent_size = Track::PayloadSize();
uint64_t size = VideoPayloadSize();
size += EbmlMasterElementSize(libwebm::kMkvVideo, size);
return parent_size + size;
}
bool VideoTrack::Write(IMkvWriter* writer) const {
if (!Track::Write(writer))
return false;
const uint64_t size = VideoPayloadSize();
if (!WriteEbmlMasterElement(writer, libwebm::kMkvVideo, size))
return false;
const int64_t payload_position = writer->Position();
if (payload_position < 0)
return false;
if (!WriteEbmlElement(writer, libwebm::kMkvPixelWidth, width_))
return false;
if (!WriteEbmlElement(writer, libwebm::kMkvPixelHeight, height_))
return false;
if (display_width_ > 0) {
if (!WriteEbmlElement(writer, libwebm::kMkvDisplayWidth, display_width_))
return false;
}
if (display_height_ > 0) {
if (!WriteEbmlElement(writer, libwebm::kMkvDisplayHeight, display_height_))
return false;
}
if (crop_left_ > 0) {
if (!WriteEbmlElement(writer, libwebm::kMkvPixelCropLeft, crop_left_))
return false;
}
if (crop_right_ > 0) {
if (!WriteEbmlElement(writer, libwebm::kMkvPixelCropRight, crop_right_))
return false;
}
if (crop_top_ > 0) {
if (!WriteEbmlElement(writer, libwebm::kMkvPixelCropTop, crop_top_))
return false;
}
if (crop_bottom_ > 0) {
if (!WriteEbmlElement(writer, libwebm::kMkvPixelCropBottom, crop_bottom_))
return false;
}
if (stereo_mode_ > kMono) {
if (!WriteEbmlElement(writer, libwebm::kMkvStereoMode, stereo_mode_))
return false;
}
if (alpha_mode_ > kNoAlpha) {
if (!WriteEbmlElement(writer, libwebm::kMkvAlphaMode, alpha_mode_))
return false;
}
if (frame_rate_ > 0.0) {
if (!WriteEbmlElement(writer, libwebm::kMkvFrameRate,
static_cast<float>(frame_rate_))) {
return false;
}
}
if (colour_) {
if (!colour_->Write(writer))
return false;
}
const int64_t stop_position = writer->Position();
if (stop_position < 0 ||
stop_position - payload_position != static_cast<int64_t>(size)) {
return false;
}
return true;
}
bool VideoTrack::SetColour(const Colour& colour) {
std::auto_ptr<Colour> colour_ptr(new Colour());
if (!colour_ptr.get())
return false;
if (colour.mastering_metadata()) {
if (!colour_ptr->SetMasteringMetadata(*colour.mastering_metadata()))
return false;
}
colour_ptr->matrix_coefficients = colour.matrix_coefficients;
colour_ptr->bits_per_channel = colour.bits_per_channel;
colour_ptr->chroma_subsampling_horz = colour.chroma_subsampling_horz;
colour_ptr->chroma_subsampling_vert = colour.chroma_subsampling_vert;
colour_ptr->cb_subsampling_horz = colour.cb_subsampling_horz;
colour_ptr->cb_subsampling_vert = colour.cb_subsampling_vert;
colour_ptr->chroma_siting_horz = colour.chroma_siting_horz;
colour_ptr->chroma_siting_vert = colour.chroma_siting_vert;
colour_ptr->range = colour.range;
colour_ptr->transfer_characteristics = colour.transfer_characteristics;
colour_ptr->primaries = colour.primaries;
colour_ptr->max_cll = colour.max_cll;
colour_ptr->max_fall = colour.max_fall;
colour_ = colour_ptr.release();
return true;
}
uint64_t VideoTrack::VideoPayloadSize() const {
uint64_t size = EbmlElementSize(libwebm::kMkvPixelWidth, width_);
size += EbmlElementSize(libwebm::kMkvPixelHeight, height_);
if (display_width_ > 0)
size += EbmlElementSize(libwebm::kMkvDisplayWidth, display_width_);
if (display_height_ > 0)
size += EbmlElementSize(libwebm::kMkvDisplayHeight, display_height_);
if (crop_left_ > 0)
size += EbmlElementSize(libwebm::kMkvPixelCropLeft, crop_left_);
if (crop_right_ > 0)
size += EbmlElementSize(libwebm::kMkvPixelCropRight, crop_right_);
if (crop_top_ > 0)
size += EbmlElementSize(libwebm::kMkvPixelCropTop, crop_top_);
if (crop_bottom_ > 0)
size += EbmlElementSize(libwebm::kMkvPixelCropBottom, crop_bottom_);
if (stereo_mode_ > kMono)
size += EbmlElementSize(libwebm::kMkvStereoMode, stereo_mode_);
if (alpha_mode_ > kNoAlpha)
size += EbmlElementSize(libwebm::kMkvAlphaMode, alpha_mode_);
if (frame_rate_ > 0.0)
size += EbmlElementSize(libwebm::kMkvFrameRate,
static_cast<float>(frame_rate_));
if (colour_)
size += colour_->ColourSize();
return size;
}
///////////////////////////////////////////////////////////////
//
// AudioTrack Class
AudioTrack::AudioTrack(unsigned int* seed)
: Track(seed), bit_depth_(0), channels_(1), sample_rate_(0.0) {}
AudioTrack::~AudioTrack() {}
uint64_t AudioTrack::PayloadSize() const {
const uint64_t parent_size = Track::PayloadSize();
uint64_t size = EbmlElementSize(libwebm::kMkvSamplingFrequency,
static_cast<float>(sample_rate_));
size += EbmlElementSize(libwebm::kMkvChannels, channels_);
if (bit_depth_ > 0)
size += EbmlElementSize(libwebm::kMkvBitDepth, bit_depth_);
size += EbmlMasterElementSize(libwebm::kMkvAudio, size);
return parent_size + size;
}
bool AudioTrack::Write(IMkvWriter* writer) const {
if (!Track::Write(writer))
return false;
// Calculate AudioSettings size.
uint64_t size = EbmlElementSize(libwebm::kMkvSamplingFrequency,
static_cast<float>(sample_rate_));
size += EbmlElementSize(libwebm::kMkvChannels, channels_);
if (bit_depth_ > 0)
size += EbmlElementSize(libwebm::kMkvBitDepth, bit_depth_);
if (!WriteEbmlMasterElement(writer, libwebm::kMkvAudio, size))
return false;
const int64_t payload_position = writer->Position();
if (payload_position < 0)
return false;
if (!WriteEbmlElement(writer, libwebm::kMkvSamplingFrequency,
static_cast<float>(sample_rate_)))
return false;
if (!WriteEbmlElement(writer, libwebm::kMkvChannels, channels_))
return false;
if (bit_depth_ > 0)
if (!WriteEbmlElement(writer, libwebm::kMkvBitDepth, bit_depth_))
return false;
const int64_t stop_position = writer->Position();
if (stop_position < 0 ||
stop_position - payload_position != static_cast<int64_t>(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), wrote_tracks_(false) {}
Tracks::~Tracks() {
if (track_entries_) {
for (uint32_t i = 0; i < track_entries_size_; ++i) {
Track* const track = track_entries_[i];
delete track;
}
delete[] track_entries_;
}
}
bool Tracks::AddTrack(Track* track, int32_t number) {
if (number < 0 || wrote_tracks_)
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_t track_num = number;
if (track_num > 0) {
// Check to make sure a track does not already have |track_num|.
for (uint32_t i = 0; i < track_entries_size_; ++i) {
if (track_entries_[i]->number() == track_num)
return false;
}
}
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_t 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_t 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_t index) const {
if (track_entries_ == NULL)
return NULL;
if (index >= track_entries_size_)
return NULL;
return track_entries_[index];
}
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];
}
return NULL;
}
bool Tracks::TrackIsAudio(uint64_t track_number) const {
const Track* const track = GetTrackByNumber(track_number);
if (track->type() == kAudio)
return true;
return false;
}
bool Tracks::TrackIsVideo(uint64_t 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_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)
return false;
size += track->Size();
}
if (!WriteEbmlMasterElement(writer, libwebm::kMkvTracks, size))
return false;
const int64_t payload_position = writer->Position();
if (payload_position < 0)
return false;
for (int32_t i = 0; i < count; ++i) {
const Track* const track = GetTrackByIndex(i);
if (!track->Write(writer))
return false;
}
const int64_t stop_position = writer->Position();
if (stop_position < 0 ||
stop_position - payload_position != static_cast<int64_t>(size))
return false;
wrote_tracks_ = true;
return true;
}
///////////////////////////////////////////////////////////////
//
// Chapter Class
bool Chapter::set_id(const char* id) { return StrCpy(id, &id_); }
void Chapter::set_time(const Segment& segment, uint64_t start_ns,
uint64_t end_ns) {
const SegmentInfo* const info = segment.GetSegmentInfo();
const uint64_t 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_t Chapter::WriteAtom(IMkvWriter* writer) const {
uint64_t payload_size =
EbmlElementSize(libwebm::kMkvChapterStringUID, id_) +
EbmlElementSize(libwebm::kMkvChapterUID, uid_) +
EbmlElementSize(libwebm::kMkvChapterTimeStart, start_timecode_) +
EbmlElementSize(libwebm::kMkvChapterTimeEnd, end_timecode_);
for (int idx = 0; idx < displays_count_; ++idx) {
const Display& d = displays_[idx];
payload_size += d.WriteDisplay(NULL);
}
const uint64_t atom_size =
EbmlMasterElementSize(libwebm::kMkvChapterAtom, payload_size) +
payload_size;
if (writer == NULL)
return atom_size;
const int64_t start = writer->Position();
if (!WriteEbmlMasterElement(writer, libwebm::kMkvChapterAtom, payload_size))
return 0;
if (!WriteEbmlElement(writer, libwebm::kMkvChapterStringUID, id_))
return 0;
if (!WriteEbmlElement(writer, libwebm::kMkvChapterUID, uid_))
return 0;
if (!WriteEbmlElement(writer, libwebm::kMkvChapterTimeStart, start_timecode_))
return 0;
if (!WriteEbmlElement(writer, libwebm::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_t stop = writer->Position();
if (stop >= start && uint64_t(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_t Chapter::Display::WriteDisplay(IMkvWriter* writer) const {
uint64_t payload_size = EbmlElementSize(libwebm::kMkvChapString, title_);
if (language_)
payload_size += EbmlElementSize(libwebm::kMkvChapLanguage, language_);
if (country_)
payload_size += EbmlElementSize(libwebm::kMkvChapCountry, country_);
const uint64_t display_size =
EbmlMasterElementSize(libwebm::kMkvChapterDisplay, payload_size) +
payload_size;
if (writer == NULL)
return display_size;
const int64_t start = writer->Position();
if (!WriteEbmlMasterElement(writer, libwebm::kMkvChapterDisplay,
payload_size))
return 0;
if (!WriteEbmlElement(writer, libwebm::kMkvChapString, title_))
return 0;
if (language_) {
if (!WriteEbmlElement(writer, libwebm::kMkvChapLanguage, language_))
return 0;
}
if (country_) {
if (!WriteEbmlElement(writer, libwebm::kMkvChapCountry, country_))
return 0;
}
const int64_t stop = writer->Position();
if (stop >= start && uint64_t(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_t payload_size = WriteEdition(NULL); // return size only
if (!WriteEbmlMasterElement(writer, libwebm::kMkvChapters, payload_size))
return false;
const int64_t start = writer->Position();
if (WriteEdition(writer) == 0) // error
return false;
const int64_t stop = writer->Position();
if (stop >= start && uint64_t(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_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_t edition_size =
EbmlMasterElementSize(libwebm::kMkvEditionEntry, payload_size) +
payload_size;
if (writer == NULL) // return size only
return edition_size;
const int64_t start = writer->Position();
if (!WriteEbmlMasterElement(writer, libwebm::kMkvEditionEntry, payload_size))
return 0; // error
for (int idx = 0; idx < chapters_count_; ++idx) {
const Chapter& chapter = chapters_[idx];
const uint64_t chapter_size = chapter.WriteAtom(writer);
if (chapter_size == 0) // error
return 0;
}
const int64_t stop = writer->Position();
if (stop >= start && uint64_t(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_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_t tag_size =
EbmlMasterElementSize(libwebm::kMkvTag, payload_size) + payload_size;
if (writer == NULL)
return tag_size;
const int64_t start = writer->Position();
if (!WriteEbmlMasterElement(writer, libwebm::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_t stop = writer->Position();
if (stop >= start && uint64_t(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_t Tag::SimpleTag::Write(IMkvWriter* writer) const {
uint64_t payload_size = EbmlElementSize(libwebm::kMkvTagName, tag_name_);
payload_size += EbmlElementSize(libwebm::kMkvTagString, tag_string_);
const uint64_t simple_tag_size =
EbmlMasterElementSize(libwebm::kMkvSimpleTag, payload_size) +
payload_size;
if (writer == NULL)
return simple_tag_size;
const int64_t start = writer->Position();
if (!WriteEbmlMasterElement(writer, libwebm::kMkvSimpleTag, payload_size))
return 0;
if (!WriteEbmlElement(writer, libwebm::kMkvTagName, tag_name_))
return 0;
if (!WriteEbmlElement(writer, libwebm::kMkvTagString, tag_string_))
return 0;
const int64_t stop = writer->Position();
if (stop >= start && uint64_t(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_t payload_size = 0;
for (int idx = 0; idx < tags_count_; ++idx) {
const Tag& tag = tags_[idx];
payload_size += tag.Write(NULL);
}
if (!WriteEbmlMasterElement(writer, libwebm::kMkvTags, payload_size))
return false;
const int64_t start = writer->Position();
for (int idx = 0; idx < tags_count_; ++idx) {
const Tag& tag = tags_[idx];
const uint64_t tag_size = tag.Write(writer);
if (tag_size == 0) // error
return 0;
}
const int64_t stop = writer->Position();
if (stop >= start && uint64_t(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_t timecode, int64_t cues_pos, uint64_t timecode_scale,
bool write_last_frame_with_duration, bool fixed_size_timecode)
: blocks_added_(0),
finalized_(false),
fixed_size_timecode_(fixed_size_timecode),
header_written_(false),
payload_size_(0),
position_for_cues_(cues_pos),
size_position_(-1),
timecode_(timecode),
timecode_scale_(timecode_scale),
write_last_frame_with_duration_(write_last_frame_with_duration),
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 QueueOrWriteFrame(frame);
}
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;
frame.set_track_number(track_number);
frame.set_timestamp(abs_timecode);
frame.set_is_key(is_key);
return QueueOrWriteFrame(&frame);
}
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;
}
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 QueueOrWriteFrame(&frame);
}
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;
frame.set_discard_padding(discard_padding);
frame.set_track_number(track_number);
frame.set_timestamp(abs_timecode);
frame.set_is_key(is_key);
return QueueOrWriteFrame(&frame);
}
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;
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 QueueOrWriteFrame(&frame);
}
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_t duration) {
if (!writer_ || finalized_)
return false;
if (write_last_frame_with_duration_) {
// Write out held back Frames. This essentially performs a k-way merge
// across all tracks in the increasing order of timestamps.
while (!stored_frames_.empty()) {
Frame* frame = stored_frames_.begin()->second.front();
// Get the next frame to write (frame with least timestamp across all
// tracks).
for (FrameMapIterator frames_iterator = ++stored_frames_.begin();
frames_iterator != stored_frames_.end(); ++frames_iterator) {
if (frames_iterator->second.front()->timestamp() < frame->timestamp()) {
frame = frames_iterator->second.front();
}
}
// Set the duration if it's the last frame for the track.
if (set_last_frame_duration &&
stored_frames_[frame->track_number()].size() == 1 &&
!frame->duration_set()) {
frame->set_duration(duration - frame->timestamp());
if (!frame->is_key() && !frame->reference_block_timestamp_set()) {
frame->set_reference_block_timestamp(
last_block_timestamp_[frame->track_number()]);
}
}
// Write the frame and remove it from |stored_frames_|.
const bool wrote_frame = DoWriteFrame(frame);
stored_frames_[frame->track_number()].pop_front();
if (stored_frames_[frame->track_number()].empty()) {
stored_frames_.erase(frame->track_number());
}
delete frame;
if (!wrote_frame)
return false;
}
}
if (size_position_ == -1)
return false;
if (writer_->Seekable()) {
const int64_t 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_t Cluster::Size() const {
const uint64_t element_size =
EbmlMasterElementSize(libwebm::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_t element_size) {
AddPayloadSize(element_size);
++blocks_added_;
}
int64_t Cluster::GetRelativeTimecode(int64_t abs_timecode) const {
const int64_t cluster_timecode = this->Cluster::timecode();
const int64_t rel_timecode =
static_cast<int64_t>(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_t element_size = WriteFrame(writer_, frame, this);
if (element_size == 0)
return false;
PostWriteBlock(element_size);
last_block_timestamp_[frame->track_number()] = frame->timestamp();
return true;
}
bool Cluster::QueueOrWriteFrame(const Frame* const frame) {
if (!frame || !frame->IsValid())
return false;
// If |write_last_frame_with_duration_| is not set, then write the frame right
// away.
if (!write_last_frame_with_duration_) {
return DoWriteFrame(frame);
}
// Queue the current frame.
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);
// Iterate through all queued frames in the current track except the last one
// and write it if it is okay to do so (i.e.) no other track has an held back
// frame with timestamp <= the timestamp of the frame in question.
std::vector<std::list<Frame*>::iterator> frames_to_erase;
for (std::list<Frame *>::iterator
current_track_iterator = stored_frames_[track_number].begin(),
end = --stored_frames_[track_number].end();
current_track_iterator != end; ++current_track_iterator) {
const Frame* const frame_to_write = *current_track_iterator;
bool okay_to_write = true;
for (FrameMapIterator track_iterator = stored_frames_.begin();
track_iterator != stored_frames_.end(); ++track_iterator) {
if (track_iterator->first == track_number) {
continue;
}
if (track_iterator->second.front()->timestamp() <
frame_to_write->timestamp()) {
okay_to_write = false;
break;
}
}
if (okay_to_write) {
const bool wrote_frame = DoWriteFrame(frame_to_write);
delete frame_to_write;
if (!wrote_frame)
return false;
frames_to_erase.push_back(current_track_iterator);
} else {
break;
}
}
for (std::vector<std::list<Frame*>::iterator>::iterator iterator =
frames_to_erase.begin();
iterator != frames_to_erase.end(); ++iterator) {
stored_frames_[track_number].erase(*iterator);
}
return true;
}
bool Cluster::WriteClusterHeader() {
if (finalized_)
return false;
if (WriteID(writer_, libwebm::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_, libwebm::kMkvTimecode, timecode(),
fixed_size_timecode_ ? 8 : 0)) {
return false;
}
AddPayloadSize(EbmlElementSize(libwebm::kMkvTimecode, timecode(),
fixed_size_timecode_ ? 8 : 0));
header_written_ = true;
return true;
}
///////////////////////////////////////////////////////////////
//
// SeekHead Class
SeekHead::SeekHead() : start_pos_(0ULL) {
for (int32_t 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_t payload_size = 0;
uint64_t entry_size[kSeekEntryCount];
for (int32_t i = 0; i < kSeekEntryCount; ++i) {
if (seek_entry_id_[i] != 0) {
entry_size[i] = EbmlElementSize(
libwebm::kMkvSeekID, static_cast<uint64_t>(seek_entry_id_[i]));
entry_size[i] +=
EbmlElementSize(libwebm::kMkvSeekPosition, seek_entry_pos_[i]);
payload_size +=
EbmlMasterElementSize(libwebm::kMkvSeek, entry_size[i]) +
entry_size[i];
}
}
// No SeekHead elements
if (payload_size == 0)
return true;
const int64_t pos = writer->Position();
if (writer->Position(start_pos_))
return false;
if (!WriteEbmlMasterElement(writer, libwebm::kMkvSeekHead, payload_size))
return false;
for (int32_t i = 0; i < kSeekEntryCount; ++i) {
if (seek_entry_id_[i] != 0) {
if (!WriteEbmlMasterElement(writer, libwebm::kMkvSeek, entry_size[i]))
return false;
if (!WriteEbmlElement(writer, libwebm::kMkvSeekID,
static_cast<uint64_t>(seek_entry_id_[i])))
return false;
if (!WriteEbmlElement(writer, libwebm::kMkvSeekPosition,
seek_entry_pos_[i]))
return false;
}
}
const uint64_t total_entry_size = kSeekEntryCount * MaxEntrySize();
const uint64_t total_size =
EbmlMasterElementSize(libwebm::kMkvSeekHead, total_entry_size) +
total_entry_size;
const int64_t size_left = total_size - (writer->Position() - start_pos_);
const uint64_t 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_t entry_size = kSeekEntryCount * MaxEntrySize();
const uint64_t size =
EbmlMasterElementSize(libwebm::kMkvSeekHead, entry_size);
start_pos_ = writer->Position();
const uint64_t bytes_written = WriteVoidElement(writer, size + entry_size);
if (!bytes_written)
return false;
return true;
}
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;
return true;
}
}
return false;
}
uint32_t SeekHead::GetId(int index) const {
if (index < 0 || index >= kSeekEntryCount)
return UINT_MAX;
return seek_entry_id_[index];
}
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_t id, uint64_t position) {
if (index < 0 || index >= kSeekEntryCount)
return false;
seek_entry_id_[index] = id;
seek_entry_pos_[index] = position;
return true;
}
uint64_t SeekHead::MaxEntrySize() const {
const uint64_t max_entry_payload_size =
EbmlElementSize(libwebm::kMkvSeekID, UINT64_C(0xffffffff)) +
EbmlElementSize(libwebm::kMkvSeekPosition, UINT64_C(0xffffffffffffffff));
const uint64_t max_entry_size =
EbmlMasterElementSize(libwebm::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_t major;
int32_t minor;
int32_t build;
int32_t 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_t pos = writer->Position();
if (writer->Position(duration_pos_))
return false;
if (!WriteEbmlElement(writer, libwebm::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_t size = EbmlElementSize(libwebm::kMkvTimecodeScale, timecode_scale_);
if (duration_ > 0.0)
size +=
EbmlElementSize(libwebm::kMkvDuration, static_cast<float>(duration_));
if (date_utc_ != LLONG_MIN)
size +=