mkvmuxerutil: Revert to using mkvmuxertypes.
- The direct change to stdint.h types causes too much downstream churn. Need an intermediate step or a wrapper because quite a bit of user code explicitly casts args passed to mkvmuxerutil functions to types defined in mkvmuxertypes. - Update call sites in mkvmuxer to avoid ambiguity errors. Change-Id: I018445b3d8ab1da776ecdb19a290ac00af63c2cf
This commit is contained in:
Tom Finegan
parent
7d674468bd
commit
ec479287ff
@ -82,30 +82,46 @@ 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));
|
||||
uint64_t size =
|
||||
EbmlElementSize(libwebm::kMkvEBMLVersion, static_cast<uint64>(1));
|
||||
size += EbmlElementSize(libwebm::kMkvEBMLReadVersion, static_cast<uint64>(1));
|
||||
size += EbmlElementSize(libwebm::kMkvEBMLMaxIDLength, static_cast<uint64>(4));
|
||||
size +=
|
||||
EbmlElementSize(libwebm::kMkvEBMLMaxSizeLength, static_cast<uint64>(8));
|
||||
size += EbmlElementSize(libwebm::kMkvDocType, "webm");
|
||||
size += EbmlElementSize(libwebm::kMkvDocTypeVersion, doc_type_version);
|
||||
size += EbmlElementSize(libwebm::kMkvDocTypeReadVersion, UINT64_C(2));
|
||||
size += EbmlElementSize(libwebm::kMkvDocTypeVersion,
|
||||
static_cast<uint64>(doc_type_version));
|
||||
size +=
|
||||
EbmlElementSize(libwebm::kMkvDocTypeReadVersion, static_cast<uint64>(2));
|
||||
|
||||
if (!WriteEbmlMasterElement(writer, libwebm::kMkvEBML, size))
|
||||
return false;
|
||||
if (!WriteEbmlElement(writer, libwebm::kMkvEBMLVersion, UINT64_C(1)))
|
||||
if (!WriteEbmlElement(writer, libwebm::kMkvEBMLVersion,
|
||||
static_cast<uint64>(1))) {
|
||||
return false;
|
||||
if (!WriteEbmlElement(writer, libwebm::kMkvEBMLReadVersion, UINT64_C(1)))
|
||||
}
|
||||
if (!WriteEbmlElement(writer, libwebm::kMkvEBMLReadVersion,
|
||||
static_cast<uint64>(1))) {
|
||||
return false;
|
||||
if (!WriteEbmlElement(writer, libwebm::kMkvEBMLMaxIDLength, UINT64_C(4)))
|
||||
}
|
||||
if (!WriteEbmlElement(writer, libwebm::kMkvEBMLMaxIDLength,
|
||||
static_cast<uint64>(4))) {
|
||||
return false;
|
||||
if (!WriteEbmlElement(writer, libwebm::kMkvEBMLMaxSizeLength, UINT64_C(8)))
|
||||
}
|
||||
if (!WriteEbmlElement(writer, libwebm::kMkvEBMLMaxSizeLength,
|
||||
static_cast<uint64>(8))) {
|
||||
return false;
|
||||
}
|
||||
if (!WriteEbmlElement(writer, libwebm::kMkvDocType, "webm"))
|
||||
return false;
|
||||
if (!WriteEbmlElement(writer, libwebm::kMkvDocTypeVersion, doc_type_version))
|
||||
if (!WriteEbmlElement(writer, libwebm::kMkvDocTypeVersion,
|
||||
static_cast<uint64>(doc_type_version))) {
|
||||
return false;
|
||||
if (!WriteEbmlElement(writer, libwebm::kMkvDocTypeReadVersion, UINT64_C(2)))
|
||||
}
|
||||
if (!WriteEbmlElement(writer, libwebm::kMkvDocTypeReadVersion,
|
||||
static_cast<uint64>(2))) {
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
@ -262,15 +278,17 @@ 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_);
|
||||
uint64_t size = EbmlElementSize(libwebm::kMkvCueClusterPosition,
|
||||
static_cast<uint64>(cluster_pos_));
|
||||
size += EbmlElementSize(libwebm::kMkvCueTrack, static_cast<uint64>(track_));
|
||||
if (output_block_number_ && block_number_ > 1)
|
||||
size += EbmlElementSize(libwebm::kMkvCueBlockNumber, block_number_);
|
||||
size += EbmlElementSize(libwebm::kMkvCueBlockNumber,
|
||||
static_cast<uint64>(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;
|
||||
EbmlElementSize(libwebm::kMkvCueTime, static_cast<uint64>(time_)) +
|
||||
track_pos_size;
|
||||
|
||||
if (!WriteEbmlMasterElement(writer, libwebm::kMkvCuePoint, payload_size))
|
||||
return false;
|
||||
@ -279,18 +297,27 @@ bool CuePoint::Write(IMkvWriter* writer) const {
|
||||
if (payload_position < 0)
|
||||
return false;
|
||||
|
||||
if (!WriteEbmlElement(writer, libwebm::kMkvCueTime, time_))
|
||||
if (!WriteEbmlElement(writer, libwebm::kMkvCueTime,
|
||||
static_cast<uint64>(time_))) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!WriteEbmlMasterElement(writer, libwebm::kMkvCueTrackPositions, size))
|
||||
return false;
|
||||
if (!WriteEbmlElement(writer, libwebm::kMkvCueTrack, track_))
|
||||
if (!WriteEbmlElement(writer, libwebm::kMkvCueTrack,
|
||||
static_cast<uint64>(track_))) {
|
||||
return false;
|
||||
if (!WriteEbmlElement(writer, libwebm::kMkvCueClusterPosition, cluster_pos_))
|
||||
}
|
||||
if (!WriteEbmlElement(writer, libwebm::kMkvCueClusterPosition,
|
||||
static_cast<uint64>(cluster_pos_))) {
|
||||
return false;
|
||||
if (output_block_number_ && block_number_ > 1)
|
||||
if (!WriteEbmlElement(writer, libwebm::kMkvCueBlockNumber, block_number_))
|
||||
}
|
||||
if (output_block_number_ && block_number_ > 1) {
|
||||
if (!WriteEbmlElement(writer, libwebm::kMkvCueBlockNumber,
|
||||
static_cast<uint64>(block_number_))) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
const int64_t stop_position = writer->Position();
|
||||
if (stop_position < 0)
|
||||
@ -303,15 +330,17 @@ bool CuePoint::Write(IMkvWriter* writer) const {
|
||||
}
|
||||
|
||||
uint64_t CuePoint::PayloadSize() const {
|
||||
uint64_t size =
|
||||
EbmlElementSize(libwebm::kMkvCueClusterPosition, cluster_pos_);
|
||||
size += EbmlElementSize(libwebm::kMkvCueTrack, track_);
|
||||
uint64_t size = EbmlElementSize(libwebm::kMkvCueClusterPosition,
|
||||
static_cast<uint64>(cluster_pos_));
|
||||
size += EbmlElementSize(libwebm::kMkvCueTrack, static_cast<uint64>(track_));
|
||||
if (output_block_number_ && block_number_ > 1)
|
||||
size += EbmlElementSize(libwebm::kMkvCueBlockNumber, block_number_);
|
||||
size += EbmlElementSize(libwebm::kMkvCueBlockNumber,
|
||||
static_cast<uint64>(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;
|
||||
EbmlElementSize(libwebm::kMkvCueTime, static_cast<uint64>(time_)) +
|
||||
track_pos_size;
|
||||
|
||||
return payload_size;
|
||||
}
|
||||
@ -456,8 +485,9 @@ bool ContentEncAESSettings::Write(IMkvWriter* writer) const {
|
||||
return false;
|
||||
|
||||
if (!WriteEbmlElement(writer, libwebm::kMkvAESSettingsCipherMode,
|
||||
cipher_mode_))
|
||||
static_cast<uint64>(cipher_mode_))) {
|
||||
return false;
|
||||
}
|
||||
|
||||
const int64_t stop_position = writer->Position();
|
||||
if (stop_position < 0 ||
|
||||
@ -468,8 +498,8 @@ bool ContentEncAESSettings::Write(IMkvWriter* writer) const {
|
||||
}
|
||||
|
||||
uint64_t ContentEncAESSettings::PayloadSize() const {
|
||||
uint64_t size =
|
||||
EbmlElementSize(libwebm::kMkvAESSettingsCipherMode, cipher_mode_);
|
||||
uint64_t size = EbmlElementSize(libwebm::kMkvAESSettingsCipherMode,
|
||||
static_cast<uint64>(cipher_mode_));
|
||||
return size;
|
||||
}
|
||||
|
||||
@ -529,20 +559,22 @@ bool ContentEncoding::Write(IMkvWriter* writer) const {
|
||||
encoding_size))
|
||||
return false;
|
||||
if (!WriteEbmlElement(writer, libwebm::kMkvContentEncodingOrder,
|
||||
encoding_order_))
|
||||
static_cast<uint64>(encoding_order_)))
|
||||
return false;
|
||||
if (!WriteEbmlElement(writer, libwebm::kMkvContentEncodingScope,
|
||||
encoding_scope_))
|
||||
static_cast<uint64>(encoding_scope_)))
|
||||
return false;
|
||||
if (!WriteEbmlElement(writer, libwebm::kMkvContentEncodingType,
|
||||
encoding_type_))
|
||||
static_cast<uint64>(encoding_type_)))
|
||||
return false;
|
||||
|
||||
if (!WriteEbmlMasterElement(writer, libwebm::kMkvContentEncryption,
|
||||
encryption_size))
|
||||
return false;
|
||||
if (!WriteEbmlElement(writer, libwebm::kMkvContentEncAlgo, enc_algo_))
|
||||
if (!WriteEbmlElement(writer, libwebm::kMkvContentEncAlgo,
|
||||
static_cast<uint64>(enc_algo_))) {
|
||||
return false;
|
||||
}
|
||||
if (!WriteEbmlElement(writer, libwebm::kMkvContentEncKeyID, enc_key_id_,
|
||||
enc_key_id_length_))
|
||||
return false;
|
||||
@ -571,12 +603,12 @@ uint64_t ContentEncoding::EncodingSize(uint64_t compresion_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_);
|
||||
encoding_size += EbmlElementSize(libwebm::kMkvContentEncodingType,
|
||||
static_cast<uint64>(encoding_type_));
|
||||
encoding_size += EbmlElementSize(libwebm::kMkvContentEncodingScope,
|
||||
static_cast<uint64>(encoding_scope_));
|
||||
encoding_size += EbmlElementSize(libwebm::kMkvContentEncodingOrder,
|
||||
static_cast<uint64>(encoding_order_));
|
||||
|
||||
return encoding_size;
|
||||
}
|
||||
@ -586,7 +618,8 @@ uint64_t ContentEncoding::EncryptionSize() const {
|
||||
|
||||
uint64_t encryption_size = EbmlElementSize(libwebm::kMkvContentEncKeyID,
|
||||
enc_key_id_, enc_key_id_length_);
|
||||
encryption_size += EbmlElementSize(libwebm::kMkvContentEncAlgo, enc_algo_);
|
||||
encryption_size += EbmlElementSize(libwebm::kMkvContentEncAlgo,
|
||||
static_cast<uint64>(enc_algo_));
|
||||
|
||||
return encryption_size + aes_size;
|
||||
}
|
||||
@ -664,9 +697,10 @@ ContentEncoding* Track::GetContentEncodingByIndex(uint32_t index) const {
|
||||
}
|
||||
|
||||
uint64_t Track::PayloadSize() const {
|
||||
uint64_t size = EbmlElementSize(libwebm::kMkvTrackNumber, number_);
|
||||
size += EbmlElementSize(libwebm::kMkvTrackUID, uid_);
|
||||
size += EbmlElementSize(libwebm::kMkvTrackType, type_);
|
||||
uint64_t size =
|
||||
EbmlElementSize(libwebm::kMkvTrackNumber, static_cast<uint64>(number_));
|
||||
size += EbmlElementSize(libwebm::kMkvTrackUID, static_cast<uint64>(uid_));
|
||||
size += EbmlElementSize(libwebm::kMkvTrackType, static_cast<uint64>(type_));
|
||||
if (codec_id_)
|
||||
size += EbmlElementSize(libwebm::kMkvCodecID, codec_id_);
|
||||
if (codec_private_)
|
||||
@ -676,15 +710,22 @@ uint64_t Track::PayloadSize() const {
|
||||
size += EbmlElementSize(libwebm::kMkvLanguage, language_);
|
||||
if (name_)
|
||||
size += EbmlElementSize(libwebm::kMkvName, name_);
|
||||
if (max_block_additional_id_)
|
||||
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_);
|
||||
static_cast<uint64>(max_block_additional_id_));
|
||||
}
|
||||
if (codec_delay_) {
|
||||
size += EbmlElementSize(libwebm::kMkvCodecDelay,
|
||||
static_cast<uint64>(codec_delay_));
|
||||
}
|
||||
if (seek_pre_roll_) {
|
||||
size += EbmlElementSize(libwebm::kMkvSeekPreRoll,
|
||||
static_cast<uint64>(seek_pre_roll_));
|
||||
}
|
||||
if (default_duration_) {
|
||||
size += EbmlElementSize(libwebm::kMkvDefaultDuration,
|
||||
static_cast<uint64>(default_duration_));
|
||||
}
|
||||
|
||||
if (content_encoding_entries_size_ > 0) {
|
||||
uint64_t content_encodings_size = 0;
|
||||
@ -722,55 +763,64 @@ bool Track::Write(IMkvWriter* writer) const {
|
||||
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_);
|
||||
uint64_t size =
|
||||
EbmlElementSize(libwebm::kMkvTrackNumber, static_cast<uint64>(number_));
|
||||
size += EbmlElementSize(libwebm::kMkvTrackUID, static_cast<uint64>(uid_));
|
||||
size += EbmlElementSize(libwebm::kMkvTrackType, static_cast<uint64>(type_));
|
||||
if (codec_id_)
|
||||
size += EbmlElementSize(libwebm::kMkvCodecID, codec_id_);
|
||||
if (codec_private_)
|
||||
size += EbmlElementSize(libwebm::kMkvCodecPrivate, codec_private_,
|
||||
codec_private_length_);
|
||||
static_cast<uint64>(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_);
|
||||
static_cast<uint64>(max_block_additional_id_));
|
||||
if (codec_delay_)
|
||||
size += EbmlElementSize(libwebm::kMkvCodecDelay, codec_delay_);
|
||||
size += EbmlElementSize(libwebm::kMkvCodecDelay,
|
||||
static_cast<uint64>(codec_delay_));
|
||||
if (seek_pre_roll_)
|
||||
size += EbmlElementSize(libwebm::kMkvSeekPreRoll, seek_pre_roll_);
|
||||
size += EbmlElementSize(libwebm::kMkvSeekPreRoll,
|
||||
static_cast<uint64>(seek_pre_roll_));
|
||||
if (default_duration_)
|
||||
size += EbmlElementSize(libwebm::kMkvDefaultDuration, default_duration_);
|
||||
size += EbmlElementSize(libwebm::kMkvDefaultDuration,
|
||||
static_cast<uint64>(default_duration_));
|
||||
|
||||
const int64_t payload_position = writer->Position();
|
||||
if (payload_position < 0)
|
||||
return false;
|
||||
|
||||
if (!WriteEbmlElement(writer, libwebm::kMkvTrackNumber, number_))
|
||||
if (!WriteEbmlElement(writer, libwebm::kMkvTrackNumber,
|
||||
static_cast<uint64>(number_)))
|
||||
return false;
|
||||
if (!WriteEbmlElement(writer, libwebm::kMkvTrackUID, uid_))
|
||||
if (!WriteEbmlElement(writer, libwebm::kMkvTrackUID,
|
||||
static_cast<uint64>(uid_)))
|
||||
return false;
|
||||
if (!WriteEbmlElement(writer, libwebm::kMkvTrackType, type_))
|
||||
if (!WriteEbmlElement(writer, libwebm::kMkvTrackType,
|
||||
static_cast<uint64>(type_)))
|
||||
return false;
|
||||
if (max_block_additional_id_) {
|
||||
if (!WriteEbmlElement(writer, libwebm::kMkvMaxBlockAdditionID,
|
||||
max_block_additional_id_)) {
|
||||
static_cast<uint64>(max_block_additional_id_))) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
if (codec_delay_) {
|
||||
if (!WriteEbmlElement(writer, libwebm::kMkvCodecDelay, codec_delay_))
|
||||
if (!WriteEbmlElement(writer, libwebm::kMkvCodecDelay,
|
||||
static_cast<uint64>(codec_delay_)))
|
||||
return false;
|
||||
}
|
||||
if (seek_pre_roll_) {
|
||||
if (!WriteEbmlElement(writer, libwebm::kMkvSeekPreRoll, seek_pre_roll_))
|
||||
if (!WriteEbmlElement(writer, libwebm::kMkvSeekPreRoll,
|
||||
static_cast<uint64>(seek_pre_roll_)))
|
||||
return false;
|
||||
}
|
||||
if (default_duration_) {
|
||||
if (!WriteEbmlElement(writer, libwebm::kMkvDefaultDuration,
|
||||
default_duration_))
|
||||
static_cast<uint64>(default_duration_)))
|
||||
return false;
|
||||
}
|
||||
if (codec_id_) {
|
||||
@ -779,7 +829,7 @@ bool Track::Write(IMkvWriter* writer) const {
|
||||
}
|
||||
if (codec_private_) {
|
||||
if (!WriteEbmlElement(writer, libwebm::kMkvCodecPrivate, codec_private_,
|
||||
codec_private_length_))
|
||||
static_cast<uint64>(codec_private_length_)))
|
||||
return false;
|
||||
}
|
||||
if (language_) {
|
||||
@ -1031,64 +1081,68 @@ bool Colour::Write(IMkvWriter* writer) const {
|
||||
|
||||
if (matrix_coefficients != kValueNotPresent &&
|
||||
!WriteEbmlElement(writer, libwebm::kMkvMatrixCoefficients,
|
||||
matrix_coefficients)) {
|
||||
static_cast<uint64>(matrix_coefficients))) {
|
||||
return false;
|
||||
}
|
||||
if (bits_per_channel != kValueNotPresent &&
|
||||
!WriteEbmlElement(writer, libwebm::kMkvBitsPerChannel,
|
||||
bits_per_channel)) {
|
||||
static_cast<uint64>(bits_per_channel))) {
|
||||
return false;
|
||||
}
|
||||
if (chroma_subsampling_horz != kValueNotPresent &&
|
||||
!WriteEbmlElement(writer, libwebm::kMkvChromaSubsamplingHorz,
|
||||
chroma_subsampling_horz)) {
|
||||
static_cast<uint64>(chroma_subsampling_horz))) {
|
||||
return false;
|
||||
}
|
||||
if (chroma_subsampling_vert != kValueNotPresent &&
|
||||
!WriteEbmlElement(writer, libwebm::kMkvChromaSubsamplingVert,
|
||||
chroma_subsampling_vert)) {
|
||||
static_cast<uint64>(chroma_subsampling_vert))) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (cb_subsampling_horz != kValueNotPresent &&
|
||||
!WriteEbmlElement(writer, libwebm::kMkvCbSubsamplingHorz,
|
||||
cb_subsampling_horz)) {
|
||||
static_cast<uint64>(cb_subsampling_horz))) {
|
||||
return false;
|
||||
}
|
||||
if (cb_subsampling_vert != kValueNotPresent &&
|
||||
!WriteEbmlElement(writer, libwebm::kMkvCbSubsamplingVert,
|
||||
cb_subsampling_vert)) {
|
||||
static_cast<uint64>(cb_subsampling_vert))) {
|
||||
return false;
|
||||
}
|
||||
if (chroma_siting_horz != kValueNotPresent &&
|
||||
!WriteEbmlElement(writer, libwebm::kMkvChromaSitingHorz,
|
||||
chroma_siting_horz)) {
|
||||
static_cast<uint64>(chroma_siting_horz))) {
|
||||
return false;
|
||||
}
|
||||
if (chroma_siting_vert != kValueNotPresent &&
|
||||
!WriteEbmlElement(writer, libwebm::kMkvChromaSitingVert,
|
||||
chroma_siting_vert)) {
|
||||
static_cast<uint64>(chroma_siting_vert))) {
|
||||
return false;
|
||||
}
|
||||
if (range != kValueNotPresent &&
|
||||
!WriteEbmlElement(writer, libwebm::kMkvRange, range)) {
|
||||
!WriteEbmlElement(writer, libwebm::kMkvRange,
|
||||
static_cast<uint64>(range))) {
|
||||
return false;
|
||||
}
|
||||
if (transfer_characteristics != kValueNotPresent &&
|
||||
!WriteEbmlElement(writer, libwebm::kMkvTransferCharacteristics,
|
||||
transfer_characteristics)) {
|
||||
static_cast<uint64>(transfer_characteristics))) {
|
||||
return false;
|
||||
}
|
||||
if (primaries != kValueNotPresent &&
|
||||
!WriteEbmlElement(writer, libwebm::kMkvPrimaries, primaries)) {
|
||||
!WriteEbmlElement(writer, libwebm::kMkvPrimaries,
|
||||
static_cast<uint64>(primaries))) {
|
||||
return false;
|
||||
}
|
||||
if (max_cll != kValueNotPresent &&
|
||||
!WriteEbmlElement(writer, libwebm::kMkvMaxCLL, max_cll)) {
|
||||
!WriteEbmlElement(writer, libwebm::kMkvMaxCLL,
|
||||
static_cast<uint64>(max_cll))) {
|
||||
return false;
|
||||
}
|
||||
if (max_fall != kValueNotPresent &&
|
||||
!WriteEbmlElement(writer, libwebm::kMkvMaxFALL, max_fall)) {
|
||||
!WriteEbmlElement(writer, libwebm::kMkvMaxFALL,
|
||||
static_cast<uint64>(max_fall))) {
|
||||
return false;
|
||||
}
|
||||
|
||||
@ -1121,37 +1175,42 @@ uint64_t Colour::PayloadSize() const {
|
||||
uint64_t size = 0;
|
||||
|
||||
if (matrix_coefficients != kValueNotPresent)
|
||||
size +=
|
||||
EbmlElementSize(libwebm::kMkvMatrixCoefficients, matrix_coefficients);
|
||||
size += EbmlElementSize(libwebm::kMkvMatrixCoefficients,
|
||||
static_cast<uint64>(matrix_coefficients));
|
||||
if (bits_per_channel != kValueNotPresent)
|
||||
size += EbmlElementSize(libwebm::kMkvBitsPerChannel, bits_per_channel);
|
||||
size += EbmlElementSize(libwebm::kMkvBitsPerChannel,
|
||||
static_cast<uint64>(bits_per_channel));
|
||||
if (chroma_subsampling_horz != kValueNotPresent)
|
||||
size += EbmlElementSize(libwebm::kMkvChromaSubsamplingHorz,
|
||||
chroma_subsampling_horz);
|
||||
static_cast<uint64>(chroma_subsampling_horz));
|
||||
if (chroma_subsampling_vert != kValueNotPresent)
|
||||
size += EbmlElementSize(libwebm::kMkvChromaSubsamplingVert,
|
||||
chroma_subsampling_vert);
|
||||
static_cast<uint64>(chroma_subsampling_vert));
|
||||
if (cb_subsampling_horz != kValueNotPresent)
|
||||
size +=
|
||||
EbmlElementSize(libwebm::kMkvCbSubsamplingHorz, cb_subsampling_horz);
|
||||
size += EbmlElementSize(libwebm::kMkvCbSubsamplingHorz,
|
||||
static_cast<uint64>(cb_subsampling_horz));
|
||||
if (cb_subsampling_vert != kValueNotPresent)
|
||||
size +=
|
||||
EbmlElementSize(libwebm::kMkvCbSubsamplingVert, cb_subsampling_vert);
|
||||
size += EbmlElementSize(libwebm::kMkvCbSubsamplingVert,
|
||||
static_cast<uint64>(cb_subsampling_vert));
|
||||
if (chroma_siting_horz != kValueNotPresent)
|
||||
size += EbmlElementSize(libwebm::kMkvChromaSitingHorz, chroma_siting_horz);
|
||||
size += EbmlElementSize(libwebm::kMkvChromaSitingHorz,
|
||||
static_cast<uint64>(chroma_siting_horz));
|
||||
if (chroma_siting_vert != kValueNotPresent)
|
||||
size += EbmlElementSize(libwebm::kMkvChromaSitingVert, chroma_siting_vert);
|
||||
size += EbmlElementSize(libwebm::kMkvChromaSitingVert,
|
||||
static_cast<uint64>(chroma_siting_vert));
|
||||
if (range != kValueNotPresent)
|
||||
size += EbmlElementSize(libwebm::kMkvRange, range);
|
||||
size += EbmlElementSize(libwebm::kMkvRange, static_cast<uint64>(range));
|
||||
if (transfer_characteristics != kValueNotPresent)
|
||||
size += EbmlElementSize(libwebm::kMkvTransferCharacteristics,
|
||||
transfer_characteristics);
|
||||
static_cast<uint64>(transfer_characteristics));
|
||||
if (primaries != kValueNotPresent)
|
||||
size += EbmlElementSize(libwebm::kMkvPrimaries, primaries);
|
||||
size +=
|
||||
EbmlElementSize(libwebm::kMkvPrimaries, static_cast<uint64>(primaries));
|
||||
if (max_cll != kValueNotPresent)
|
||||
size += EbmlElementSize(libwebm::kMkvMaxCLL, max_cll);
|
||||
size += EbmlElementSize(libwebm::kMkvMaxCLL, static_cast<uint64>(max_cll));
|
||||
if (max_fall != kValueNotPresent)
|
||||
size += EbmlElementSize(libwebm::kMkvMaxFALL, max_fall);
|
||||
size +=
|
||||
EbmlElementSize(libwebm::kMkvMaxFALL, static_cast<uint64>(max_fall));
|
||||
|
||||
if (mastering_metadata_)
|
||||
size += mastering_metadata_->MasteringMetadataSize();
|
||||
@ -1221,40 +1280,50 @@ bool VideoTrack::Write(IMkvWriter* writer) const {
|
||||
if (payload_position < 0)
|
||||
return false;
|
||||
|
||||
if (!WriteEbmlElement(writer, libwebm::kMkvPixelWidth, width_))
|
||||
if (!WriteEbmlElement(writer, libwebm::kMkvPixelWidth,
|
||||
static_cast<uint64>(width_)))
|
||||
return false;
|
||||
if (!WriteEbmlElement(writer, libwebm::kMkvPixelHeight, height_))
|
||||
if (!WriteEbmlElement(writer, libwebm::kMkvPixelHeight,
|
||||
static_cast<uint64>(height_)))
|
||||
return false;
|
||||
if (display_width_ > 0) {
|
||||
if (!WriteEbmlElement(writer, libwebm::kMkvDisplayWidth, display_width_))
|
||||
if (!WriteEbmlElement(writer, libwebm::kMkvDisplayWidth,
|
||||
static_cast<uint64>(display_width_)))
|
||||
return false;
|
||||
}
|
||||
if (display_height_ > 0) {
|
||||
if (!WriteEbmlElement(writer, libwebm::kMkvDisplayHeight, display_height_))
|
||||
if (!WriteEbmlElement(writer, libwebm::kMkvDisplayHeight,
|
||||
static_cast<uint64>(display_height_)))
|
||||
return false;
|
||||
}
|
||||
if (crop_left_ > 0) {
|
||||
if (!WriteEbmlElement(writer, libwebm::kMkvPixelCropLeft, crop_left_))
|
||||
if (!WriteEbmlElement(writer, libwebm::kMkvPixelCropLeft,
|
||||
static_cast<uint64>(crop_left_)))
|
||||
return false;
|
||||
}
|
||||
if (crop_right_ > 0) {
|
||||
if (!WriteEbmlElement(writer, libwebm::kMkvPixelCropRight, crop_right_))
|
||||
if (!WriteEbmlElement(writer, libwebm::kMkvPixelCropRight,
|
||||
static_cast<uint64>(crop_right_)))
|
||||
return false;
|
||||
}
|
||||
if (crop_top_ > 0) {
|
||||
if (!WriteEbmlElement(writer, libwebm::kMkvPixelCropTop, crop_top_))
|
||||
if (!WriteEbmlElement(writer, libwebm::kMkvPixelCropTop,
|
||||
static_cast<uint64>(crop_top_)))
|
||||
return false;
|
||||
}
|
||||
if (crop_bottom_ > 0) {
|
||||
if (!WriteEbmlElement(writer, libwebm::kMkvPixelCropBottom, crop_bottom_))
|
||||
if (!WriteEbmlElement(writer, libwebm::kMkvPixelCropBottom,
|
||||
static_cast<uint64>(crop_bottom_)))
|
||||
return false;
|
||||
}
|
||||
if (stereo_mode_ > kMono) {
|
||||
if (!WriteEbmlElement(writer, libwebm::kMkvStereoMode, stereo_mode_))
|
||||
if (!WriteEbmlElement(writer, libwebm::kMkvStereoMode,
|
||||
static_cast<uint64>(stereo_mode_)))
|
||||
return false;
|
||||
}
|
||||
if (alpha_mode_ > kNoAlpha) {
|
||||
if (!WriteEbmlElement(writer, libwebm::kMkvAlphaMode, alpha_mode_))
|
||||
if (!WriteEbmlElement(writer, libwebm::kMkvAlphaMode,
|
||||
static_cast<uint64>(alpha_mode_)))
|
||||
return false;
|
||||
}
|
||||
if (frame_rate_ > 0.0) {
|
||||
@ -1305,24 +1374,34 @@ bool VideoTrack::SetColour(const Colour& colour) {
|
||||
}
|
||||
|
||||
uint64_t VideoTrack::VideoPayloadSize() const {
|
||||
uint64_t size = EbmlElementSize(libwebm::kMkvPixelWidth, width_);
|
||||
size += EbmlElementSize(libwebm::kMkvPixelHeight, height_);
|
||||
uint64_t size =
|
||||
EbmlElementSize(libwebm::kMkvPixelWidth, static_cast<uint64>(width_));
|
||||
size +=
|
||||
EbmlElementSize(libwebm::kMkvPixelHeight, static_cast<uint64>(height_));
|
||||
if (display_width_ > 0)
|
||||
size += EbmlElementSize(libwebm::kMkvDisplayWidth, display_width_);
|
||||
size += EbmlElementSize(libwebm::kMkvDisplayWidth,
|
||||
static_cast<uint64>(display_width_));
|
||||
if (display_height_ > 0)
|
||||
size += EbmlElementSize(libwebm::kMkvDisplayHeight, display_height_);
|
||||
size += EbmlElementSize(libwebm::kMkvDisplayHeight,
|
||||
static_cast<uint64>(display_height_));
|
||||
if (crop_left_ > 0)
|
||||
size += EbmlElementSize(libwebm::kMkvPixelCropLeft, crop_left_);
|
||||
size += EbmlElementSize(libwebm::kMkvPixelCropLeft,
|
||||
static_cast<uint64>(crop_left_));
|
||||
if (crop_right_ > 0)
|
||||
size += EbmlElementSize(libwebm::kMkvPixelCropRight, crop_right_);
|
||||
size += EbmlElementSize(libwebm::kMkvPixelCropRight,
|
||||
static_cast<uint64>(crop_right_));
|
||||
if (crop_top_ > 0)
|
||||
size += EbmlElementSize(libwebm::kMkvPixelCropTop, crop_top_);
|
||||
size += EbmlElementSize(libwebm::kMkvPixelCropTop,
|
||||
static_cast<uint64>(crop_top_));
|
||||
if (crop_bottom_ > 0)
|
||||
size += EbmlElementSize(libwebm::kMkvPixelCropBottom, crop_bottom_);
|
||||
size += EbmlElementSize(libwebm::kMkvPixelCropBottom,
|
||||
static_cast<uint64>(crop_bottom_));
|
||||
if (stereo_mode_ > kMono)
|
||||
size += EbmlElementSize(libwebm::kMkvStereoMode, stereo_mode_);
|
||||
size += EbmlElementSize(libwebm::kMkvStereoMode,
|
||||
static_cast<uint64>(stereo_mode_));
|
||||
if (alpha_mode_ > kNoAlpha)
|
||||
size += EbmlElementSize(libwebm::kMkvAlphaMode, alpha_mode_);
|
||||
size += EbmlElementSize(libwebm::kMkvAlphaMode,
|
||||
static_cast<uint64>(alpha_mode_));
|
||||
if (frame_rate_ > 0.0)
|
||||
size += EbmlElementSize(libwebm::kMkvFrameRate,
|
||||
static_cast<float>(frame_rate_));
|
||||
@ -1346,9 +1425,11 @@ uint64_t AudioTrack::PayloadSize() const {
|
||||
|
||||
uint64_t size = EbmlElementSize(libwebm::kMkvSamplingFrequency,
|
||||
static_cast<float>(sample_rate_));
|
||||
size += EbmlElementSize(libwebm::kMkvChannels, channels_);
|
||||
size +=
|
||||
EbmlElementSize(libwebm::kMkvChannels, static_cast<uint64>(channels_));
|
||||
if (bit_depth_ > 0)
|
||||
size += EbmlElementSize(libwebm::kMkvBitDepth, bit_depth_);
|
||||
size +=
|
||||
EbmlElementSize(libwebm::kMkvBitDepth, static_cast<uint64>(bit_depth_));
|
||||
size += EbmlMasterElementSize(libwebm::kMkvAudio, size);
|
||||
|
||||
return parent_size + size;
|
||||
@ -1361,9 +1442,11 @@ bool AudioTrack::Write(IMkvWriter* writer) const {
|
||||
// Calculate AudioSettings size.
|
||||
uint64_t size = EbmlElementSize(libwebm::kMkvSamplingFrequency,
|
||||
static_cast<float>(sample_rate_));
|
||||
size += EbmlElementSize(libwebm::kMkvChannels, channels_);
|
||||
size +=
|
||||
EbmlElementSize(libwebm::kMkvChannels, static_cast<uint64>(channels_));
|
||||
if (bit_depth_ > 0)
|
||||
size += EbmlElementSize(libwebm::kMkvBitDepth, bit_depth_);
|
||||
size +=
|
||||
EbmlElementSize(libwebm::kMkvBitDepth, static_cast<uint64>(bit_depth_));
|
||||
|
||||
if (!WriteEbmlMasterElement(writer, libwebm::kMkvAudio, size))
|
||||
return false;
|
||||
@ -1375,10 +1458,12 @@ bool AudioTrack::Write(IMkvWriter* writer) const {
|
||||
if (!WriteEbmlElement(writer, libwebm::kMkvSamplingFrequency,
|
||||
static_cast<float>(sample_rate_)))
|
||||
return false;
|
||||
if (!WriteEbmlElement(writer, libwebm::kMkvChannels, channels_))
|
||||
if (!WriteEbmlElement(writer, libwebm::kMkvChannels,
|
||||
static_cast<uint64>(channels_)))
|
||||
return false;
|
||||
if (bit_depth_ > 0)
|
||||
if (!WriteEbmlElement(writer, libwebm::kMkvBitDepth, bit_depth_))
|
||||
if (!WriteEbmlElement(writer, libwebm::kMkvBitDepth,
|
||||
static_cast<uint64>(bit_depth_)))
|
||||
return false;
|
||||
|
||||
const int64_t stop_position = writer->Position();
|
||||
@ -1650,9 +1735,11 @@ bool Chapter::ExpandDisplaysArray() {
|
||||
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_);
|
||||
EbmlElementSize(libwebm::kMkvChapterUID, static_cast<uint64>(uid_)) +
|
||||
EbmlElementSize(libwebm::kMkvChapterTimeStart,
|
||||
static_cast<uint64>(start_timecode_)) +
|
||||
EbmlElementSize(libwebm::kMkvChapterTimeEnd,
|
||||
static_cast<uint64>(end_timecode_));
|
||||
|
||||
for (int idx = 0; idx < displays_count_; ++idx) {
|
||||
const Display& d = displays_[idx];
|
||||
@ -1674,13 +1761,16 @@ uint64_t Chapter::WriteAtom(IMkvWriter* writer) const {
|
||||
if (!WriteEbmlElement(writer, libwebm::kMkvChapterStringUID, id_))
|
||||
return 0;
|
||||
|
||||
if (!WriteEbmlElement(writer, libwebm::kMkvChapterUID, uid_))
|
||||
if (!WriteEbmlElement(writer, libwebm::kMkvChapterUID,
|
||||
static_cast<uint64>(uid_)))
|
||||
return 0;
|
||||
|
||||
if (!WriteEbmlElement(writer, libwebm::kMkvChapterTimeStart, start_timecode_))
|
||||
if (!WriteEbmlElement(writer, libwebm::kMkvChapterTimeStart,
|
||||
static_cast<uint64>(start_timecode_)))
|
||||
return 0;
|
||||
|
||||
if (!WriteEbmlElement(writer, libwebm::kMkvChapterTimeEnd, end_timecode_))
|
||||
if (!WriteEbmlElement(writer, libwebm::kMkvChapterTimeEnd,
|
||||
static_cast<uint64>(end_timecode_)))
|
||||
return 0;
|
||||
|
||||
for (int idx = 0; idx < displays_count_; ++idx) {
|
||||
@ -2421,10 +2511,10 @@ bool SeekHead::Finalize(IMkvWriter* writer) const {
|
||||
|
||||
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]);
|
||||
entry_size[i] = EbmlElementSize(libwebm::kMkvSeekID,
|
||||
static_cast<uint64>(seek_entry_id_[i]));
|
||||
entry_size[i] += EbmlElementSize(
|
||||
libwebm::kMkvSeekPosition, static_cast<uint64>(seek_entry_pos_[i]));
|
||||
|
||||
payload_size +=
|
||||
EbmlMasterElementSize(libwebm::kMkvSeek, entry_size[i]) +
|
||||
@ -2449,11 +2539,11 @@ bool SeekHead::Finalize(IMkvWriter* writer) const {
|
||||
return false;
|
||||
|
||||
if (!WriteEbmlElement(writer, libwebm::kMkvSeekID,
|
||||
static_cast<uint64_t>(seek_entry_id_[i])))
|
||||
static_cast<uint64>(seek_entry_id_[i])))
|
||||
return false;
|
||||
|
||||
if (!WriteEbmlElement(writer, libwebm::kMkvSeekPosition,
|
||||
seek_entry_pos_[i]))
|
||||
static_cast<uint64>(seek_entry_pos_[i])))
|
||||
return false;
|
||||
}
|
||||
}
|
||||
@ -2522,8 +2612,10 @@ bool SeekHead::SetSeekEntry(int index, uint32_t id, uint64_t position) {
|
||||
|
||||
uint64_t SeekHead::MaxEntrySize() const {
|
||||
const uint64_t max_entry_payload_size =
|
||||
EbmlElementSize(libwebm::kMkvSeekID, UINT64_C(0xffffffff)) +
|
||||
EbmlElementSize(libwebm::kMkvSeekPosition, UINT64_C(0xffffffffffffffff));
|
||||
EbmlElementSize(libwebm::kMkvSeekID,
|
||||
static_cast<uint64>(UINT64_C(0xffffffff))) +
|
||||
EbmlElementSize(libwebm::kMkvSeekPosition,
|
||||
static_cast<uint64>(UINT64_C(0xffffffffffffffff)));
|
||||
const uint64_t max_entry_size =
|
||||
EbmlMasterElementSize(libwebm::kMkvSeek, max_entry_payload_size) +
|
||||
max_entry_payload_size;
|
||||
@ -2613,7 +2705,8 @@ bool SegmentInfo::Write(IMkvWriter* writer) {
|
||||
if (!writer || !muxing_app_ || !writing_app_)
|
||||
return false;
|
||||
|
||||
uint64_t size = EbmlElementSize(libwebm::kMkvTimecodeScale, timecode_scale_);
|
||||
uint64_t size = EbmlElementSize(libwebm::kMkvTimecodeScale,
|
||||
static_cast<uint64>(timecode_scale_));
|
||||
if (duration_ > 0.0)
|
||||
size +=
|
||||
EbmlElementSize(libwebm::kMkvDuration, static_cast<float>(duration_));
|
||||
@ -2629,7 +2722,8 @@ bool SegmentInfo::Write(IMkvWriter* writer) {
|
||||
if (payload_position < 0)
|
||||
return false;
|
||||
|
||||
if (!WriteEbmlElement(writer, libwebm::kMkvTimecodeScale, timecode_scale_))
|
||||
if (!WriteEbmlElement(writer, libwebm::kMkvTimecodeScale,
|
||||
static_cast<uint64>(timecode_scale_)))
|
||||
return false;
|
||||
|
||||
if (duration_ > 0.0) {
|
||||
|
||||
@ -31,20 +31,20 @@ namespace {
|
||||
// Date elements are always 8 octets in size.
|
||||
const int kDateElementSize = 8;
|
||||
|
||||
uint64_t WriteBlock(IMkvWriter* writer, const Frame* const frame,
|
||||
int64_t timecode, uint64_t timecode_scale) {
|
||||
uint64_t block_additional_elem_size = 0;
|
||||
uint64_t block_addid_elem_size = 0;
|
||||
uint64_t block_more_payload_size = 0;
|
||||
uint64_t block_more_elem_size = 0;
|
||||
uint64_t block_additions_payload_size = 0;
|
||||
uint64_t block_additions_elem_size = 0;
|
||||
uint64 WriteBlock(IMkvWriter* writer, const Frame* const frame, int64 timecode,
|
||||
uint64 timecode_scale) {
|
||||
uint64 block_additional_elem_size = 0;
|
||||
uint64 block_addid_elem_size = 0;
|
||||
uint64 block_more_payload_size = 0;
|
||||
uint64 block_more_elem_size = 0;
|
||||
uint64 block_additions_payload_size = 0;
|
||||
uint64 block_additions_elem_size = 0;
|
||||
if (frame->additional()) {
|
||||
block_additional_elem_size =
|
||||
EbmlElementSize(libwebm::kMkvBlockAdditional, frame->additional(),
|
||||
frame->additional_length());
|
||||
block_addid_elem_size =
|
||||
EbmlElementSize(libwebm::kMkvBlockAddID, frame->add_id());
|
||||
block_addid_elem_size = EbmlElementSize(
|
||||
libwebm::kMkvBlockAddID, static_cast<uint64>(frame->add_id()));
|
||||
|
||||
block_more_payload_size =
|
||||
block_addid_elem_size + block_additional_elem_size;
|
||||
@ -58,32 +58,33 @@ uint64_t WriteBlock(IMkvWriter* writer, const Frame* const frame,
|
||||
block_additions_payload_size;
|
||||
}
|
||||
|
||||
uint64_t discard_padding_elem_size = 0;
|
||||
uint64 discard_padding_elem_size = 0;
|
||||
if (frame->discard_padding() != 0) {
|
||||
discard_padding_elem_size =
|
||||
EbmlElementSize(libwebm::kMkvDiscardPadding, frame->discard_padding());
|
||||
EbmlElementSize(libwebm::kMkvDiscardPadding,
|
||||
static_cast<int64>(frame->discard_padding()));
|
||||
}
|
||||
|
||||
const uint64_t reference_block_timestamp =
|
||||
const uint64 reference_block_timestamp =
|
||||
frame->reference_block_timestamp() / timecode_scale;
|
||||
uint64_t reference_block_elem_size = 0;
|
||||
uint64 reference_block_elem_size = 0;
|
||||
if (!frame->is_key()) {
|
||||
reference_block_elem_size =
|
||||
EbmlElementSize(libwebm::kMkvReferenceBlock, reference_block_timestamp);
|
||||
}
|
||||
|
||||
const uint64_t duration = frame->duration() / timecode_scale;
|
||||
uint64_t block_duration_elem_size = 0;
|
||||
const uint64 duration = frame->duration() / timecode_scale;
|
||||
uint64 block_duration_elem_size = 0;
|
||||
if (duration > 0)
|
||||
block_duration_elem_size =
|
||||
EbmlElementSize(libwebm::kMkvBlockDuration, duration);
|
||||
|
||||
const uint64_t block_payload_size = 4 + frame->length();
|
||||
const uint64_t block_elem_size =
|
||||
const uint64 block_payload_size = 4 + frame->length();
|
||||
const uint64 block_elem_size =
|
||||
EbmlMasterElementSize(libwebm::kMkvBlock, block_payload_size) +
|
||||
block_payload_size;
|
||||
|
||||
const uint64_t block_group_payload_size =
|
||||
const uint64 block_group_payload_size =
|
||||
block_elem_size + block_additions_elem_size + block_duration_elem_size +
|
||||
discard_padding_elem_size + reference_block_elem_size;
|
||||
|
||||
@ -105,7 +106,7 @@ uint64_t WriteBlock(IMkvWriter* writer, const Frame* const frame,
|
||||
if (SerializeInt(writer, 0, 1))
|
||||
return 0;
|
||||
|
||||
if (writer->Write(frame->frame(), static_cast<uint32_t>(frame->length())))
|
||||
if (writer->Write(frame->frame(), static_cast<uint32>(frame->length())))
|
||||
return 0;
|
||||
|
||||
if (frame->additional()) {
|
||||
@ -118,7 +119,8 @@ uint64_t WriteBlock(IMkvWriter* writer, const Frame* const frame,
|
||||
block_more_payload_size))
|
||||
return 0;
|
||||
|
||||
if (!WriteEbmlElement(writer, libwebm::kMkvBlockAddID, frame->add_id()))
|
||||
if (!WriteEbmlElement(writer, libwebm::kMkvBlockAddID,
|
||||
static_cast<uint64>(frame->add_id())))
|
||||
return 0;
|
||||
|
||||
if (!WriteEbmlElement(writer, libwebm::kMkvBlockAdditional,
|
||||
@ -129,7 +131,7 @@ uint64_t WriteBlock(IMkvWriter* writer, const Frame* const frame,
|
||||
|
||||
if (frame->discard_padding() != 0 &&
|
||||
!WriteEbmlElement(writer, libwebm::kMkvDiscardPadding,
|
||||
frame->discard_padding())) {
|
||||
static_cast<int64>(frame->discard_padding()))) {
|
||||
return false;
|
||||
}
|
||||
|
||||
@ -148,38 +150,38 @@ uint64_t WriteBlock(IMkvWriter* writer, const Frame* const frame,
|
||||
block_group_payload_size;
|
||||
}
|
||||
|
||||
uint64_t WriteSimpleBlock(IMkvWriter* writer, const Frame* const frame,
|
||||
int64_t timecode) {
|
||||
uint64 WriteSimpleBlock(IMkvWriter* writer, const Frame* const frame,
|
||||
int64 timecode) {
|
||||
if (WriteID(writer, libwebm::kMkvSimpleBlock))
|
||||
return 0;
|
||||
|
||||
const int32_t size = static_cast<int32_t>(frame->length()) + 4;
|
||||
const int32 size = static_cast<int32>(frame->length()) + 4;
|
||||
if (WriteUInt(writer, size))
|
||||
return 0;
|
||||
|
||||
if (WriteUInt(writer, static_cast<uint64_t>(frame->track_number())))
|
||||
if (WriteUInt(writer, static_cast<uint64>(frame->track_number())))
|
||||
return 0;
|
||||
|
||||
if (SerializeInt(writer, timecode, 2))
|
||||
return 0;
|
||||
|
||||
uint64_t flags = 0;
|
||||
uint64 flags = 0;
|
||||
if (frame->is_key())
|
||||
flags |= 0x80;
|
||||
|
||||
if (SerializeInt(writer, flags, 1))
|
||||
return 0;
|
||||
|
||||
if (writer->Write(frame->frame(), static_cast<uint32_t>(frame->length())))
|
||||
if (writer->Write(frame->frame(), static_cast<uint32>(frame->length())))
|
||||
return 0;
|
||||
|
||||
return static_cast<uint64_t>(GetUIntSize(libwebm::kMkvSimpleBlock) +
|
||||
GetCodedUIntSize(size) + 4 + frame->length());
|
||||
return GetUIntSize(libwebm::kMkvSimpleBlock) + GetCodedUIntSize(size) + 4 +
|
||||
frame->length();
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
int32_t GetCodedUIntSize(uint64_t value) {
|
||||
int32 GetCodedUIntSize(uint64 value) {
|
||||
if (value < 0x000000000000007FULL)
|
||||
return 1;
|
||||
else if (value < 0x0000000000003FFFULL)
|
||||
@ -197,7 +199,7 @@ int32_t GetCodedUIntSize(uint64_t value) {
|
||||
return 8;
|
||||
}
|
||||
|
||||
int32_t GetUIntSize(uint64_t value) {
|
||||
int32 GetUIntSize(uint64 value) {
|
||||
if (value < 0x0000000000000100ULL)
|
||||
return 1;
|
||||
else if (value < 0x0000000000010000ULL)
|
||||
@ -215,26 +217,26 @@ int32_t GetUIntSize(uint64_t value) {
|
||||
return 8;
|
||||
}
|
||||
|
||||
int32_t GetIntSize(int64_t value) {
|
||||
int32 GetIntSize(int64 value) {
|
||||
// Doubling the requested value ensures positive values with their high bit
|
||||
// set are written with 0-padding to avoid flipping the signedness.
|
||||
const uint64_t v = (value < 0) ? value ^ -1LL : value;
|
||||
const uint64 v = (value < 0) ? value ^ -1LL : value;
|
||||
return GetUIntSize(2 * v);
|
||||
}
|
||||
|
||||
uint64_t EbmlMasterElementSize(uint64_t type, uint64_t value) {
|
||||
uint64 EbmlMasterElementSize(uint64 type, uint64 value) {
|
||||
// Size of EBML ID
|
||||
int32_t ebml_size = GetUIntSize(type);
|
||||
int32 ebml_size = GetUIntSize(type);
|
||||
|
||||
// Datasize
|
||||
ebml_size += GetCodedUIntSize(value);
|
||||
|
||||
return static_cast<uint64_t>(ebml_size);
|
||||
return ebml_size;
|
||||
}
|
||||
|
||||
uint64_t EbmlElementSize(uint64_t type, int64_t value) {
|
||||
uint64 EbmlElementSize(uint64 type, int64 value) {
|
||||
// Size of EBML ID
|
||||
int32_t ebml_size = GetUIntSize(type);
|
||||
int32 ebml_size = GetUIntSize(type);
|
||||
|
||||
// Datasize
|
||||
ebml_size += GetIntSize(value);
|
||||
@ -242,20 +244,19 @@ uint64_t EbmlElementSize(uint64_t type, int64_t value) {
|
||||
// Size of Datasize
|
||||
ebml_size++;
|
||||
|
||||
return static_cast<uint64_t>(ebml_size);
|
||||
return ebml_size;
|
||||
}
|
||||
|
||||
uint64_t EbmlElementSize(uint64_t type, uint64_t value) {
|
||||
uint64 EbmlElementSize(uint64 type, uint64 value) {
|
||||
return EbmlElementSize(type, value, 0);
|
||||
}
|
||||
|
||||
uint64_t EbmlElementSize(uint64_t type, uint64_t value, uint64_t fixed_size) {
|
||||
uint64 EbmlElementSize(uint64 type, uint64 value, uint64 fixed_size) {
|
||||
// Size of EBML ID
|
||||
uint64_t ebml_size = static_cast<uint64_t>(GetUIntSize(type));
|
||||
int32 ebml_size = GetUIntSize(type);
|
||||
|
||||
// Datasize
|
||||
ebml_size +=
|
||||
(fixed_size > 0) ? fixed_size : static_cast<uint64_t>(GetUIntSize(value));
|
||||
ebml_size += (fixed_size > 0) ? fixed_size : GetUIntSize(value);
|
||||
|
||||
// Size of Datasize
|
||||
ebml_size++;
|
||||
@ -263,9 +264,9 @@ uint64_t EbmlElementSize(uint64_t type, uint64_t value, uint64_t fixed_size) {
|
||||
return ebml_size;
|
||||
}
|
||||
|
||||
uint64_t EbmlElementSize(uint64_t type, float /* value */) {
|
||||
uint64 EbmlElementSize(uint64 type, float /* value */) {
|
||||
// Size of EBML ID
|
||||
uint64_t ebml_size = static_cast<uint64_t>(GetUIntSize(type));
|
||||
uint64 ebml_size = GetUIntSize(type);
|
||||
|
||||
// Datasize
|
||||
ebml_size += sizeof(float);
|
||||
@ -276,12 +277,12 @@ uint64_t EbmlElementSize(uint64_t type, float /* value */) {
|
||||
return ebml_size;
|
||||
}
|
||||
|
||||
uint64_t EbmlElementSize(uint64_t type, const char* value) {
|
||||
uint64 EbmlElementSize(uint64 type, const char* value) {
|
||||
if (!value)
|
||||
return 0;
|
||||
|
||||
// Size of EBML ID
|
||||
uint64_t ebml_size = static_cast<uint64_t>(GetUIntSize(type));
|
||||
uint64 ebml_size = GetUIntSize(type);
|
||||
|
||||
// Datasize
|
||||
ebml_size += strlen(value);
|
||||
@ -292,12 +293,12 @@ uint64_t EbmlElementSize(uint64_t type, const char* value) {
|
||||
return ebml_size;
|
||||
}
|
||||
|
||||
uint64_t EbmlElementSize(uint64_t type, const uint8_t* value, uint64_t size) {
|
||||
uint64 EbmlElementSize(uint64 type, const uint8* value, uint64 size) {
|
||||
if (!value)
|
||||
return 0;
|
||||
|
||||
// Size of EBML ID
|
||||
uint64_t ebml_size = static_cast<uint64_t>(GetUIntSize(type));
|
||||
uint64 ebml_size = GetUIntSize(type);
|
||||
|
||||
// Datasize
|
||||
ebml_size += size;
|
||||
@ -308,9 +309,9 @@ uint64_t EbmlElementSize(uint64_t type, const uint8_t* value, uint64_t size) {
|
||||
return ebml_size;
|
||||
}
|
||||
|
||||
uint64_t EbmlDateElementSize(uint64_t type) {
|
||||
uint64 EbmlDateElementSize(uint64 type) {
|
||||
// Size of EBML ID
|
||||
uint64_t ebml_size = static_cast<uint64_t>(GetUIntSize(type));
|
||||
uint64 ebml_size = GetUIntSize(type);
|
||||
|
||||
// Datasize
|
||||
ebml_size += kDateElementSize;
|
||||
@ -321,18 +322,18 @@ uint64_t EbmlDateElementSize(uint64_t type) {
|
||||
return ebml_size;
|
||||
}
|
||||
|
||||
int32_t SerializeInt(IMkvWriter* writer, int64_t value, int32_t size) {
|
||||
int32 SerializeInt(IMkvWriter* writer, int64 value, int32 size) {
|
||||
if (!writer || size < 1 || size > 8)
|
||||
return -1;
|
||||
|
||||
for (int32_t i = 1; i <= size; ++i) {
|
||||
const int32_t byte_count = size - i;
|
||||
const int32_t bit_count = byte_count * 8;
|
||||
for (int32 i = 1; i <= size; ++i) {
|
||||
const int32 byte_count = size - i;
|
||||
const int32 bit_count = byte_count * 8;
|
||||
|
||||
const int64_t bb = value >> bit_count;
|
||||
const uint8_t b = static_cast<uint8_t>(bb);
|
||||
const int64 bb = value >> bit_count;
|
||||
const uint8 b = static_cast<uint8>(bb);
|
||||
|
||||
const int32_t status = writer->Write(&b, 1);
|
||||
const int32 status = writer->Write(&b, 1);
|
||||
|
||||
if (status < 0)
|
||||
return status;
|
||||
@ -341,26 +342,26 @@ int32_t SerializeInt(IMkvWriter* writer, int64_t value, int32_t size) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
int32_t SerializeFloat(IMkvWriter* writer, float f) {
|
||||
int32 SerializeFloat(IMkvWriter* writer, float f) {
|
||||
if (!writer)
|
||||
return -1;
|
||||
|
||||
assert(sizeof(uint32_t) == sizeof(float));
|
||||
assert(sizeof(uint32) == sizeof(float));
|
||||
// This union is merely used to avoid a reinterpret_cast from float& to
|
||||
// uint32& which will result in violation of strict aliasing.
|
||||
union U32 {
|
||||
uint32_t u32;
|
||||
uint32 u32;
|
||||
float f;
|
||||
} value;
|
||||
value.f = f;
|
||||
|
||||
for (int32_t i = 1; i <= 4; ++i) {
|
||||
const int32_t byte_count = 4 - i;
|
||||
const int32_t bit_count = byte_count * 8;
|
||||
for (int32 i = 1; i <= 4; ++i) {
|
||||
const int32 byte_count = 4 - i;
|
||||
const int32 bit_count = byte_count * 8;
|
||||
|
||||
const uint8_t byte = static_cast<uint8_t>(value.u32 >> bit_count);
|
||||
const uint8 byte = static_cast<uint8>(value.u32 >> bit_count);
|
||||
|
||||
const int32_t status = writer->Write(&byte, 1);
|
||||
const int32 status = writer->Write(&byte, 1);
|
||||
|
||||
if (status < 0)
|
||||
return status;
|
||||
@ -369,21 +370,21 @@ int32_t SerializeFloat(IMkvWriter* writer, float f) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
int32_t WriteUInt(IMkvWriter* writer, uint64_t value) {
|
||||
int32 WriteUInt(IMkvWriter* writer, uint64 value) {
|
||||
if (!writer)
|
||||
return -1;
|
||||
|
||||
int32_t size = GetCodedUIntSize(value);
|
||||
int32 size = GetCodedUIntSize(value);
|
||||
|
||||
return WriteUIntSize(writer, value, size);
|
||||
}
|
||||
|
||||
int32_t WriteUIntSize(IMkvWriter* writer, uint64_t value, int32_t size) {
|
||||
int32 WriteUIntSize(IMkvWriter* writer, uint64 value, int32 size) {
|
||||
if (!writer || size < 0 || size > 8)
|
||||
return -1;
|
||||
|
||||
if (size > 0) {
|
||||
const uint64_t bit = 1LL << (size * 7);
|
||||
const uint64 bit = 1LL << (size * 7);
|
||||
|
||||
if (value > (bit - 2))
|
||||
return -1;
|
||||
@ -391,11 +392,11 @@ int32_t WriteUIntSize(IMkvWriter* writer, uint64_t value, int32_t size) {
|
||||
value |= bit;
|
||||
} else {
|
||||
size = 1;
|
||||
int64_t bit;
|
||||
int64 bit;
|
||||
|
||||
for (;;) {
|
||||
bit = 1LL << (size * 7);
|
||||
const uint64_t max = bit - 2;
|
||||
const uint64 max = bit - 2;
|
||||
|
||||
if (value <= max)
|
||||
break;
|
||||
@ -412,18 +413,18 @@ int32_t WriteUIntSize(IMkvWriter* writer, uint64_t value, int32_t size) {
|
||||
return SerializeInt(writer, value, size);
|
||||
}
|
||||
|
||||
int32_t WriteID(IMkvWriter* writer, uint64_t type) {
|
||||
int32 WriteID(IMkvWriter* writer, uint64 type) {
|
||||
if (!writer)
|
||||
return -1;
|
||||
|
||||
writer->ElementStartNotify(type, writer->Position());
|
||||
|
||||
const int32_t size = GetUIntSize(type);
|
||||
const int32 size = GetUIntSize(type);
|
||||
|
||||
return SerializeInt(writer, type, size);
|
||||
}
|
||||
|
||||
bool WriteEbmlMasterElement(IMkvWriter* writer, uint64_t type, uint64_t size) {
|
||||
bool WriteEbmlMasterElement(IMkvWriter* writer, uint64 type, uint64 size) {
|
||||
if (!writer)
|
||||
return false;
|
||||
|
||||
@ -436,19 +437,19 @@ bool WriteEbmlMasterElement(IMkvWriter* writer, uint64_t type, uint64_t size) {
|
||||
return true;
|
||||
}
|
||||
|
||||
bool WriteEbmlElement(IMkvWriter* writer, uint64_t type, uint64_t value) {
|
||||
bool WriteEbmlElement(IMkvWriter* writer, uint64 type, uint64 value) {
|
||||
return WriteEbmlElement(writer, type, value, 0);
|
||||
}
|
||||
|
||||
bool WriteEbmlElement(IMkvWriter* writer, uint64_t type, uint64_t value,
|
||||
uint64_t fixed_size) {
|
||||
bool WriteEbmlElement(IMkvWriter* writer, uint64 type, uint64 value,
|
||||
uint64 fixed_size) {
|
||||
if (!writer)
|
||||
return false;
|
||||
|
||||
if (WriteID(writer, type))
|
||||
return false;
|
||||
|
||||
uint64_t size = static_cast<uint64_t>(GetUIntSize(value));
|
||||
uint64 size = GetUIntSize(value);
|
||||
if (fixed_size > 0) {
|
||||
if (size > fixed_size)
|
||||
return false;
|
||||
@ -457,30 +458,30 @@ bool WriteEbmlElement(IMkvWriter* writer, uint64_t type, uint64_t value,
|
||||
if (WriteUInt(writer, size))
|
||||
return false;
|
||||
|
||||
if (SerializeInt(writer, value, static_cast<int32_t>(size)))
|
||||
if (SerializeInt(writer, value, static_cast<int32>(size)))
|
||||
return false;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool WriteEbmlElement(IMkvWriter* writer, uint64_t type, int64_t value) {
|
||||
bool WriteEbmlElement(IMkvWriter* writer, uint64 type, int64 value) {
|
||||
if (!writer)
|
||||
return false;
|
||||
|
||||
if (WriteID(writer, type))
|
||||
return 0;
|
||||
|
||||
const uint64_t size = GetIntSize(value);
|
||||
const uint64 size = GetIntSize(value);
|
||||
if (WriteUInt(writer, size))
|
||||
return false;
|
||||
|
||||
if (SerializeInt(writer, value, static_cast<int32_t>(size)))
|
||||
if (SerializeInt(writer, value, static_cast<int32>(size)))
|
||||
return false;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool WriteEbmlElement(IMkvWriter* writer, uint64_t type, float value) {
|
||||
bool WriteEbmlElement(IMkvWriter* writer, uint64 type, float value) {
|
||||
if (!writer)
|
||||
return false;
|
||||
|
||||
@ -496,25 +497,25 @@ bool WriteEbmlElement(IMkvWriter* writer, uint64_t type, float value) {
|
||||
return true;
|
||||
}
|
||||
|
||||
bool WriteEbmlElement(IMkvWriter* writer, uint64_t type, const char* value) {
|
||||
bool WriteEbmlElement(IMkvWriter* writer, uint64 type, const char* value) {
|
||||
if (!writer || !value)
|
||||
return false;
|
||||
|
||||
if (WriteID(writer, type))
|
||||
return false;
|
||||
|
||||
const uint64_t length = strlen(value);
|
||||
const uint64 length = strlen(value);
|
||||
if (WriteUInt(writer, length))
|
||||
return false;
|
||||
|
||||
if (writer->Write(value, static_cast<const uint32_t>(length)))
|
||||
if (writer->Write(value, static_cast<const uint32>(length)))
|
||||
return false;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool WriteEbmlElement(IMkvWriter* writer, uint64_t type, const uint8_t* value,
|
||||
uint64_t size) {
|
||||
bool WriteEbmlElement(IMkvWriter* writer, uint64 type, const uint8* value,
|
||||
uint64 size) {
|
||||
if (!writer || !value || size < 1)
|
||||
return false;
|
||||
|
||||
@ -524,13 +525,13 @@ bool WriteEbmlElement(IMkvWriter* writer, uint64_t type, const uint8_t* value,
|
||||
if (WriteUInt(writer, size))
|
||||
return false;
|
||||
|
||||
if (writer->Write(value, static_cast<uint32_t>(size)))
|
||||
if (writer->Write(value, static_cast<uint32>(size)))
|
||||
return false;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool WriteEbmlDateElement(IMkvWriter* writer, uint64_t type, int64_t value) {
|
||||
bool WriteEbmlDateElement(IMkvWriter* writer, uint64 type, int64 value) {
|
||||
if (!writer)
|
||||
return false;
|
||||
|
||||
@ -546,8 +547,8 @@ bool WriteEbmlDateElement(IMkvWriter* writer, uint64_t type, int64_t value) {
|
||||
return true;
|
||||
}
|
||||
|
||||
uint64_t WriteFrame(IMkvWriter* writer, const Frame* const frame,
|
||||
Cluster* cluster) {
|
||||
uint64 WriteFrame(IMkvWriter* writer, const Frame* const frame,
|
||||
Cluster* cluster) {
|
||||
if (!writer || !frame || !frame->IsValid() || !cluster ||
|
||||
!cluster->timecode_scale())
|
||||
return 0;
|
||||
@ -556,7 +557,7 @@ uint64_t WriteFrame(IMkvWriter* writer, const Frame* const frame,
|
||||
// timecode for the cluster itself (remember that block timecode
|
||||
// is a signed, 16-bit integer). However, as a simplification we
|
||||
// only permit non-negative cluster-relative timecodes for blocks.
|
||||
const int64_t relative_timecode = cluster->GetRelativeTimecode(
|
||||
const int64 relative_timecode = cluster->GetRelativeTimecode(
|
||||
frame->timestamp() / cluster->timecode_scale());
|
||||
if (relative_timecode < 0 || relative_timecode > kMaxBlockTimecode)
|
||||
return 0;
|
||||
@ -567,20 +568,19 @@ uint64_t WriteFrame(IMkvWriter* writer, const Frame* const frame,
|
||||
cluster->timecode_scale());
|
||||
}
|
||||
|
||||
uint64_t WriteVoidElement(IMkvWriter* writer, uint64_t size) {
|
||||
uint64 WriteVoidElement(IMkvWriter* writer, uint64 size) {
|
||||
if (!writer)
|
||||
return false;
|
||||
|
||||
// Subtract one for the void ID and the coded size.
|
||||
uint64_t void_entry_size = size - 1 - GetCodedUIntSize(size - 1);
|
||||
uint64_t void_size =
|
||||
EbmlMasterElementSize(libwebm::kMkvVoid, void_entry_size) +
|
||||
void_entry_size;
|
||||
uint64 void_entry_size = size - 1 - GetCodedUIntSize(size - 1);
|
||||
uint64 void_size = EbmlMasterElementSize(libwebm::kMkvVoid, void_entry_size) +
|
||||
void_entry_size;
|
||||
|
||||
if (void_size != size)
|
||||
return 0;
|
||||
|
||||
const int64_t payload_position = writer->Position();
|
||||
const int64 payload_position = writer->Position();
|
||||
if (payload_position < 0)
|
||||
return 0;
|
||||
|
||||
@ -590,30 +590,29 @@ uint64_t WriteVoidElement(IMkvWriter* writer, uint64_t size) {
|
||||
if (WriteUInt(writer, void_entry_size))
|
||||
return 0;
|
||||
|
||||
const uint8_t value = 0;
|
||||
for (int32_t i = 0; i < static_cast<int32_t>(void_entry_size); ++i) {
|
||||
const uint8 value = 0;
|
||||
for (int32 i = 0; i < static_cast<int32>(void_entry_size); ++i) {
|
||||
if (writer->Write(&value, 1))
|
||||
return 0;
|
||||
}
|
||||
|
||||
const int64_t stop_position = writer->Position();
|
||||
const int64 stop_position = writer->Position();
|
||||
if (stop_position < 0 ||
|
||||
stop_position - payload_position != static_cast<int64_t>(void_size))
|
||||
stop_position - payload_position != static_cast<int64>(void_size))
|
||||
return 0;
|
||||
|
||||
return void_size;
|
||||
}
|
||||
|
||||
void GetVersion(int32_t* major, int32_t* minor, int32_t* build,
|
||||
int32_t* revision) {
|
||||
void GetVersion(int32* major, int32* minor, int32* build, int32* revision) {
|
||||
*major = 0;
|
||||
*minor = 2;
|
||||
*build = 1;
|
||||
*revision = 0;
|
||||
}
|
||||
|
||||
uint64_t MakeUID(unsigned int* seed) {
|
||||
uint64_t uid = 0;
|
||||
uint64 MakeUID(unsigned int* seed) {
|
||||
uint64 uid = 0;
|
||||
|
||||
#ifdef __MINGW32__
|
||||
srand(*seed);
|
||||
@ -625,21 +624,21 @@ uint64_t MakeUID(unsigned int* seed) {
|
||||
// TODO(fgalligan): Move random number generation to platform specific code.
|
||||
#ifdef _MSC_VER
|
||||
(void)seed;
|
||||
const int32_t nn = rand();
|
||||
const int32 nn = rand();
|
||||
#elif __ANDROID__
|
||||
int32_t temp_num = 1;
|
||||
int32 temp_num = 1;
|
||||
int fd = open("/dev/urandom", O_RDONLY);
|
||||
if (fd != -1) {
|
||||
read(fd, &temp_num, sizeof(temp_num));
|
||||
close(fd);
|
||||
}
|
||||
const int32_t nn = temp_num;
|
||||
const int32 nn = temp_num;
|
||||
#elif defined __MINGW32__
|
||||
const int32_t nn = rand();
|
||||
const int32 nn = rand();
|
||||
#else
|
||||
const int32_t nn = rand_r(seed);
|
||||
const int32 nn = rand_r(seed);
|
||||
#endif
|
||||
const int32_t n = 0xFF & (nn >> 4); // throw away low-order bits
|
||||
const int32 n = 0xFF & (nn >> 4); // throw away low-order bits
|
||||
|
||||
uid |= n;
|
||||
}
|
||||
|
||||
@ -8,87 +8,94 @@
|
||||
#ifndef MKVMUXER_MKVMUXERUTIL_H_
|
||||
#define MKVMUXER_MKVMUXERUTIL_H_
|
||||
|
||||
#include <stdint.h>
|
||||
#include "mkvmuxertypes.h"
|
||||
|
||||
namespace mkvmuxer {
|
||||
class Cluster;
|
||||
class Frame;
|
||||
class IMkvWriter;
|
||||
|
||||
const uint64_t kEbmlUnknownValue = 0x01FFFFFFFFFFFFFFULL;
|
||||
const int64_t kMaxBlockTimecode = 0x07FFFLL;
|
||||
// TODO(tomfinegan): mkvmuxer:: integer types continue to be used here because
|
||||
// changing them causes pain for downstream projects. It would be nice if a
|
||||
// solution that allows removal of the mkvmuxer:: integer types while avoiding
|
||||
// pain for downstream users of libwebm. Considering that mkvmuxerutil.{cc,h}
|
||||
// are really, for the great majority of cases, EBML size calculation and writer
|
||||
// functions, perhaps a more EBML focused utility would be the way to go as a
|
||||
// first step.
|
||||
|
||||
const uint64 kEbmlUnknownValue = 0x01FFFFFFFFFFFFFFULL;
|
||||
const int64 kMaxBlockTimecode = 0x07FFFLL;
|
||||
|
||||
// Writes out |value| in Big Endian order. Returns 0 on success.
|
||||
int32_t SerializeInt(IMkvWriter* writer, int64_t value, int32_t size);
|
||||
int32 SerializeInt(IMkvWriter* writer, int64 value, int32 size);
|
||||
|
||||
// Returns the size in bytes of the element.
|
||||
int32_t GetUIntSize(uint64_t value);
|
||||
int32_t GetIntSize(int64_t value);
|
||||
int32_t GetCodedUIntSize(uint64_t value);
|
||||
uint64_t EbmlMasterElementSize(uint64_t type, uint64_t value);
|
||||
uint64_t EbmlElementSize(uint64_t type, int64_t value);
|
||||
uint64_t EbmlElementSize(uint64_t type, uint64_t value);
|
||||
uint64_t EbmlElementSize(uint64_t type, float value);
|
||||
uint64_t EbmlElementSize(uint64_t type, const char* value);
|
||||
uint64_t EbmlElementSize(uint64_t type, const uint8_t* value, uint64_t size);
|
||||
uint64_t EbmlDateElementSize(uint64_t type);
|
||||
int32 GetUIntSize(uint64 value);
|
||||
int32 GetIntSize(int64 value);
|
||||
int32 GetCodedUIntSize(uint64 value);
|
||||
uint64 EbmlMasterElementSize(uint64 type, uint64 value);
|
||||
uint64 EbmlElementSize(uint64 type, int64 value);
|
||||
uint64 EbmlElementSize(uint64 type, uint64 value);
|
||||
uint64 EbmlElementSize(uint64 type, float value);
|
||||
uint64 EbmlElementSize(uint64 type, const char* value);
|
||||
uint64 EbmlElementSize(uint64 type, const uint8* value, uint64 size);
|
||||
uint64 EbmlDateElementSize(uint64 type);
|
||||
|
||||
// Returns the size in bytes of the element assuming that the element was
|
||||
// written using |fixed_size| bytes. If |fixed_size| is set to zero, then it
|
||||
// computes the necessary number of bytes based on |value|.
|
||||
uint64_t EbmlElementSize(uint64_t type, uint64_t value, uint64_t fixed_size);
|
||||
uint64 EbmlElementSize(uint64 type, uint64 value, uint64 fixed_size);
|
||||
|
||||
// Creates an EBML coded number from |value| and writes it out. The size of
|
||||
// the coded number is determined by the value of |value|. |value| must not
|
||||
// be in a coded form. Returns 0 on success.
|
||||
int32_t WriteUInt(IMkvWriter* writer, uint64_t value);
|
||||
int32 WriteUInt(IMkvWriter* writer, uint64 value);
|
||||
|
||||
// Creates an EBML coded number from |value| and writes it out. The size of
|
||||
// the coded number is determined by the value of |size|. |value| must not
|
||||
// be in a coded form. Returns 0 on success.
|
||||
int32_t WriteUIntSize(IMkvWriter* writer, uint64_t value, int32_t size);
|
||||
int32 WriteUIntSize(IMkvWriter* writer, uint64 value, int32 size);
|
||||
|
||||
// Output an Mkv master element. Returns true if the element was written.
|
||||
bool WriteEbmlMasterElement(IMkvWriter* writer, uint64_t value, uint64_t size);
|
||||
bool WriteEbmlMasterElement(IMkvWriter* writer, uint64 value, uint64 size);
|
||||
|
||||
// Outputs an Mkv ID, calls |IMkvWriter::ElementStartNotify|, and passes the
|
||||
// ID to |SerializeInt|. Returns 0 on success.
|
||||
int32_t WriteID(IMkvWriter* writer, uint64_t type);
|
||||
int32 WriteID(IMkvWriter* writer, uint64 type);
|
||||
|
||||
// Output an Mkv non-master element. Returns true if the element was written.
|
||||
bool WriteEbmlElement(IMkvWriter* writer, uint64_t type, uint64_t value);
|
||||
bool WriteEbmlElement(IMkvWriter* writer, uint64_t type, int64_t value);
|
||||
bool WriteEbmlElement(IMkvWriter* writer, uint64_t type, float value);
|
||||
bool WriteEbmlElement(IMkvWriter* writer, uint64_t type, const char* value);
|
||||
bool WriteEbmlElement(IMkvWriter* writer, uint64_t type, const uint8_t* value,
|
||||
uint64_t size);
|
||||
bool WriteEbmlDateElement(IMkvWriter* writer, uint64_t type, int64_t value);
|
||||
bool WriteEbmlElement(IMkvWriter* writer, uint64 type, uint64 value);
|
||||
bool WriteEbmlElement(IMkvWriter* writer, uint64 type, int64 value);
|
||||
bool WriteEbmlElement(IMkvWriter* writer, uint64 type, float value);
|
||||
bool WriteEbmlElement(IMkvWriter* writer, uint64 type, const char* value);
|
||||
bool WriteEbmlElement(IMkvWriter* writer, uint64 type, const uint8* value,
|
||||
uint64 size);
|
||||
bool WriteEbmlDateElement(IMkvWriter* writer, uint64 type, int64 value);
|
||||
|
||||
// Output an Mkv non-master element using fixed size. The element will be
|
||||
// written out using exactly |fixed_size| bytes. If |fixed_size| is set to zero
|
||||
// then it computes the necessary number of bytes based on |value|. Returns true
|
||||
// if the element was written.
|
||||
bool WriteEbmlElement(IMkvWriter* writer, uint64_t type, uint64_t value,
|
||||
uint64_t fixed_size);
|
||||
bool WriteEbmlElement(IMkvWriter* writer, uint64 type, uint64 value,
|
||||
uint64 fixed_size);
|
||||
|
||||
// Output a Mkv Frame. It decides the correct element to write (Block vs
|
||||
// SimpleBlock) based on the parameters of the Frame.
|
||||
uint64_t WriteFrame(IMkvWriter* writer, const Frame* const frame,
|
||||
Cluster* cluster);
|
||||
uint64 WriteFrame(IMkvWriter* writer, const Frame* const frame,
|
||||
Cluster* cluster);
|
||||
|
||||
// Output a void element. |size| must be the entire size in bytes that will be
|
||||
// void. The function will calculate the size of the void header and subtract
|
||||
// it from |size|.
|
||||
uint64_t WriteVoidElement(IMkvWriter* writer, uint64_t size);
|
||||
uint64 WriteVoidElement(IMkvWriter* writer, uint64 size);
|
||||
|
||||
// Returns the version number of the muxer in |major|, |minor|, |build|,
|
||||
// and |revision|.
|
||||
void GetVersion(int32_t* major, int32_t* minor, int32_t* build,
|
||||
int32_t* revision);
|
||||
void GetVersion(int32* major, int32* minor, int32* build, int32* revision);
|
||||
|
||||
// Returns a random number to be used for UID, using |seed| to seed
|
||||
// the random-number generator (see POSIX rand_r() for semantics).
|
||||
uint64_t MakeUID(unsigned int* seed);
|
||||
uint64 MakeUID(unsigned int* seed);
|
||||
|
||||
} // namespace mkvmuxer
|
||||
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user