diff --git a/examples.mk b/examples.mk index c891a5496..f10bec68c 100644 --- a/examples.mk +++ b/examples.mk @@ -36,30 +36,21 @@ LIBYUV_SRCS += third_party/libyuv/include/libyuv/basic_types.h \ third_party/libyuv/source/scale_neon64.cc \ third_party/libyuv/source/scale_win.cc \ -LIBWEBM_COMMON_SRCS += third_party/libwebm/common/hdr_util.cc \ - third_party/libwebm/common/hdr_util.h \ - third_party/libwebm/common/webmids.h +LIBWEBM_COMMON_SRCS += third_party/libwebm/webmids.hpp -LIBWEBM_MUXER_SRCS += third_party/libwebm/mkvmuxer/mkvmuxer.cc \ - third_party/libwebm/mkvmuxer/mkvmuxerutil.cc \ - third_party/libwebm/mkvmuxer/mkvwriter.cc \ - third_party/libwebm/mkvmuxer/mkvmuxer.h \ - third_party/libwebm/mkvmuxer/mkvmuxertypes.h \ - third_party/libwebm/mkvmuxer/mkvmuxerutil.h \ - third_party/libwebm/mkvparser/mkvparser.h \ - third_party/libwebm/mkvmuxer/mkvwriter.h - -LIBWEBM_PARSER_SRCS = third_party/libwebm/mkvparser/mkvparser.cc \ - third_party/libwebm/mkvparser/mkvreader.cc \ - third_party/libwebm/mkvparser/mkvparser.h \ - third_party/libwebm/mkvparser/mkvreader.h - -# Add compile flags and include path for libwebm sources. -ifeq ($(CONFIG_WEBM_IO),yes) - CXXFLAGS += -D__STDC_CONSTANT_MACROS -D__STDC_LIMIT_MACROS - INC_PATH-yes += $(SRC_PATH_BARE)/third_party/libwebm -endif +LIBWEBM_MUXER_SRCS += third_party/libwebm/mkvmuxer.cpp \ + third_party/libwebm/mkvmuxerutil.cpp \ + third_party/libwebm/mkvwriter.cpp \ + third_party/libwebm/mkvmuxer.hpp \ + third_party/libwebm/mkvmuxertypes.hpp \ + third_party/libwebm/mkvmuxerutil.hpp \ + third_party/libwebm/mkvparser.hpp \ + third_party/libwebm/mkvwriter.hpp +LIBWEBM_PARSER_SRCS = third_party/libwebm/mkvparser.cpp \ + third_party/libwebm/mkvreader.cpp \ + third_party/libwebm/mkvparser.hpp \ + third_party/libwebm/mkvreader.hpp # List of examples to build. UTILS are tools meant for distribution # while EXAMPLES demonstrate specific portions of the API. @@ -79,7 +70,6 @@ ifeq ($(CONFIG_LIBYUV),yes) endif ifeq ($(CONFIG_WEBM_IO),yes) vpxdec.SRCS += $(LIBWEBM_COMMON_SRCS) - vpxdec.SRCS += $(LIBWEBM_MUXER_SRCS) vpxdec.SRCS += $(LIBWEBM_PARSER_SRCS) vpxdec.SRCS += webmdec.cc webmdec.h endif @@ -103,7 +93,6 @@ endif ifeq ($(CONFIG_WEBM_IO),yes) vpxenc.SRCS += $(LIBWEBM_COMMON_SRCS) vpxenc.SRCS += $(LIBWEBM_MUXER_SRCS) - vpxenc.SRCS += $(LIBWEBM_PARSER_SRCS) vpxenc.SRCS += webmenc.cc webmenc.h endif vpxenc.GUID = 548DEC74-7A15-4B2B-AFC3-AA102E7C25C1 diff --git a/libs.mk b/libs.mk index c2a4725b0..e6fb068bf 100644 --- a/libs.mk +++ b/libs.mk @@ -394,12 +394,6 @@ $(filter %$(ASM).o,$(OBJS-yes)): $(BUILD_PFX)vpx_config.asm $(shell $(SRC_PATH_BARE)/build/make/version.sh "$(SRC_PATH_BARE)" $(BUILD_PFX)vpx_version.h) CLEAN-OBJS += $(BUILD_PFX)vpx_version.h -# -# Add include path for libwebm sources. -# -ifeq ($(CONFIG_WEBM_IO),yes) - CXXFLAGS += -I$(SRC_PATH_BARE)/third_party/libwebm -endif ## ## libvpx test directives @@ -475,7 +469,6 @@ test_libvpx.$(VCPROJ_SFX): $(LIBVPX_TEST_SRCS) vpx.$(VCPROJ_SFX) gtest.$(VCPROJ_ $(if $(CONFIG_STATIC_MSVCRT),--static-crt) \ --out=$@ $(INTERNAL_CFLAGS) $(CFLAGS) \ -I. -I"$(SRC_PATH_BARE)/third_party/googletest/src/include" \ - $(if $(CONFIG_WEBM_IO),-I"$(SRC_PATH_BARE)/third_party/libwebm") \ -L. -l$(CODEC_LIB) -l$(GTEST_LIB) $^ PROJECTS-$(CONFIG_MSVS) += test_libvpx.$(VCPROJ_SFX) diff --git a/test/test.mk b/test/test.mk index 693185362..0a4b69ce0 100644 --- a/test/test.mk +++ b/test/test.mk @@ -59,10 +59,10 @@ LIBVPX_TEST_SRCS-$(CONFIG_ENCODERS) += y4m_test.cc ../y4menc.c ../y4menc.h ## WebM Parsing ifeq ($(CONFIG_WEBM_IO), yes) -LIBWEBM_PARSER_SRCS += ../third_party/libwebm/mkvparser/mkvparser.cc -LIBWEBM_PARSER_SRCS += ../third_party/libwebm/mkvparser/mkvreader.cc -LIBWEBM_PARSER_SRCS += ../third_party/libwebm/mkvparser/mkvparser.h -LIBWEBM_PARSER_SRCS += ../third_party/libwebm/mkvparser/mkvreader.h +LIBWEBM_PARSER_SRCS += ../third_party/libwebm/mkvparser.cpp +LIBWEBM_PARSER_SRCS += ../third_party/libwebm/mkvreader.cpp +LIBWEBM_PARSER_SRCS += ../third_party/libwebm/mkvparser.hpp +LIBWEBM_PARSER_SRCS += ../third_party/libwebm/mkvreader.hpp LIBVPX_TEST_SRCS-$(CONFIG_DECODERS) += $(LIBWEBM_PARSER_SRCS) LIBVPX_TEST_SRCS-$(CONFIG_DECODERS) += ../tools_common.h LIBVPX_TEST_SRCS-$(CONFIG_DECODERS) += ../webmdec.cc diff --git a/third_party/libwebm/Android.mk b/third_party/libwebm/Android.mk index 8149a083f..be9d77dee 100644 --- a/third_party/libwebm/Android.mk +++ b/third_party/libwebm/Android.mk @@ -2,16 +2,9 @@ LOCAL_PATH:= $(call my-dir) include $(CLEAR_VARS) LOCAL_MODULE:= libwebm -LOCAL_CPPFLAGS:=-D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -LOCAL_CPPFLAGS+=-D__STDC_LIMIT_MACROS -Wno-extern-c-compat -LOCAL_C_INCLUDES:= $(LOCAL_PATH) -LOCAL_EXPORT_C_INCLUDES:= $(LOCAL_PATH) - -LOCAL_SRC_FILES:= common/file_util.cc \ - common/hdr_util.cc \ - mkvparser/mkvparser.cc \ - mkvparser/mkvreader.cc \ - mkvmuxer/mkvmuxer.cc \ - mkvmuxer/mkvmuxerutil.cc \ - mkvmuxer/mkvwriter.cc +LOCAL_SRC_FILES:= mkvparser.cpp \ + mkvreader.cpp \ + mkvmuxer.cpp \ + mkvmuxerutil.cpp \ + mkvwriter.cpp include $(BUILD_STATIC_LIBRARY) diff --git a/third_party/libwebm/README.libvpx b/third_party/libwebm/README.libvpx index 99cae2a23..2989d3d89 100644 --- a/third_party/libwebm/README.libvpx +++ b/third_party/libwebm/README.libvpx @@ -1,5 +1,5 @@ URL: https://chromium.googlesource.com/webm/libwebm -Version: eb50da8e38633d987aabcc2fe60c9a72bad753ae +Version: 476366249e1fda7710a389cd41c57db42305e0d4 License: BSD License File: LICENSE.txt diff --git a/third_party/libwebm/RELEASE.TXT b/third_party/libwebm/RELEASE.TXT new file mode 100644 index 000000000..a7e9f032c --- /dev/null +++ b/third_party/libwebm/RELEASE.TXT @@ -0,0 +1,34 @@ +1.0.0.5 + * Handled case when no duration + * Handled empty clusters + * Handled empty clusters when seeking + * Implemented check lacing bits + +1.0.0.4 + * Made Cues member variables mutables + * Defined against badly-formatted cue points + * Segment::GetCluster returns CuePoint too + * Separated cue-based searches + +1.0.0.3 + * Added Block::GetOffset() to get a frame's offset in a block + * Changed cluster count type from size_t to long + * Parsed SeekHead to find cues + * Allowed seeking beyond end of cluster cache + * Added not to attempt to reparse cues element + * Restructured Segment::LoadCluster + * Marked position of cues without parsing cues element + * Allowed cue points to be loaded incrementally + * Implemented to load lazily cue points as they're searched + * Merged Cues::LoadCuePoint into Cues::Find + * Lazy init cues + * Loaded cue point during find + +1.0.0.2 + * added support for Cues element + * seeking was improved + +1.0.0.1 + * fixed item 141 + * added item 142 + * added this file, RELEASE.TXT, to repository diff --git a/third_party/libwebm/common/file_util.cc b/third_party/libwebm/common/file_util.cc deleted file mode 100644 index 4f91318f3..000000000 --- a/third_party/libwebm/common/file_util.cc +++ /dev/null @@ -1,67 +0,0 @@ -// Copyright (c) 2016 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 "common/file_util.h" - -#include -#ifndef _MSC_VER -#include // close() -#endif - -#include -#include -#include -#include - -namespace libwebm { - -std::string GetTempFileName() { -#if !defined _MSC_VER && !defined __MINGW32__ - char temp_file_name_template[] = "libwebm_temp.XXXXXX"; - int fd = mkstemp(temp_file_name_template); - if (fd != -1) { - close(fd); - return std::string(temp_file_name_template); - } - return std::string(); -#else - char tmp_file_name[_MAX_PATH]; - errno_t err = tmpnam_s(tmp_file_name); - if (err == 0) { - return std::string(tmp_file_name); - } - return std::string(); -#endif -} - -uint64_t GetFileSize(const std::string& file_name) { - uint64_t file_size = 0; -#ifndef _MSC_VER - struct stat st; - st.st_size = 0; - if (stat(file_name.c_str(), &st) == 0) { -#else - struct _stat st; - st.st_size = 0; - if (_stat(file_name.c_str(), &st) == 0) { -#endif - file_size = st.st_size; - } - return file_size; -} - -TempFileDeleter::TempFileDeleter() { file_name_ = GetTempFileName(); } - -TempFileDeleter::~TempFileDeleter() { - std::ifstream file(file_name_.c_str()); - if (file.good()) { - file.close(); - std::remove(file_name_.c_str()); - } -} - -} // namespace libwebm diff --git a/third_party/libwebm/common/file_util.h b/third_party/libwebm/common/file_util.h deleted file mode 100644 index 0e71eac11..000000000 --- a/third_party/libwebm/common/file_util.h +++ /dev/null @@ -1,41 +0,0 @@ -// Copyright (c) 2016 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. -#ifndef LIBWEBM_COMMON_FILE_UTIL_H_ -#define LIBWEBM_COMMON_FILE_UTIL_H_ - -#include - -#include - -#include "mkvmuxer/mkvmuxertypes.h" // LIBWEBM_DISALLOW_COPY_AND_ASSIGN() - -namespace libwebm { - -// Returns a temporary file name. -std::string GetTempFileName(); - -// Returns size of file specified by |file_name|, or 0 upon failure. -uint64_t GetFileSize(const std::string& file_name); - -// Manages life of temporary file specified at time of construction. Deletes -// file upon destruction. -class TempFileDeleter { - public: - TempFileDeleter(); - explicit TempFileDeleter(std::string file_name) : file_name_(file_name) {} - ~TempFileDeleter(); - const std::string& name() const { return file_name_; } - - private: - std::string file_name_; - LIBWEBM_DISALLOW_COPY_AND_ASSIGN(TempFileDeleter); -}; - -} // namespace libwebm - -#endif // LIBWEBM_COMMON_FILE_UTIL_H_ \ No newline at end of file diff --git a/third_party/libwebm/common/hdr_util.cc b/third_party/libwebm/common/hdr_util.cc deleted file mode 100644 index e1a9842fb..000000000 --- a/third_party/libwebm/common/hdr_util.cc +++ /dev/null @@ -1,182 +0,0 @@ -// Copyright (c) 2016 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 "hdr_util.h" - -#include -#include - -#include "mkvparser/mkvparser.h" - -namespace libwebm { -bool CopyPrimaryChromaticity(const mkvparser::PrimaryChromaticity& parser_pc, - PrimaryChromaticityPtr* muxer_pc) { - muxer_pc->reset(new (std::nothrow) - mkvmuxer::PrimaryChromaticity(parser_pc.x, parser_pc.y)); - if (!muxer_pc->get()) - return false; - return true; -} - -bool MasteringMetadataValuePresent(double value) { - return value != mkvparser::MasteringMetadata::kValueNotPresent; -} - -bool CopyMasteringMetadata(const mkvparser::MasteringMetadata& parser_mm, - mkvmuxer::MasteringMetadata* muxer_mm) { - if (MasteringMetadataValuePresent(parser_mm.luminance_max)) - muxer_mm->luminance_max = parser_mm.luminance_max; - if (MasteringMetadataValuePresent(parser_mm.luminance_min)) - muxer_mm->luminance_min = parser_mm.luminance_min; - - PrimaryChromaticityPtr r_ptr(NULL); - PrimaryChromaticityPtr g_ptr(NULL); - PrimaryChromaticityPtr b_ptr(NULL); - PrimaryChromaticityPtr wp_ptr(NULL); - - if (parser_mm.r) { - if (!CopyPrimaryChromaticity(*parser_mm.r, &r_ptr)) - return false; - } - if (parser_mm.g) { - if (!CopyPrimaryChromaticity(*parser_mm.g, &g_ptr)) - return false; - } - if (parser_mm.b) { - if (!CopyPrimaryChromaticity(*parser_mm.b, &b_ptr)) - return false; - } - if (parser_mm.white_point) { - if (!CopyPrimaryChromaticity(*parser_mm.white_point, &wp_ptr)) - return false; - } - - if (!muxer_mm->SetChromaticity(r_ptr.get(), g_ptr.get(), b_ptr.get(), - wp_ptr.get())) { - return false; - } - - return true; -} - -bool ColourValuePresent(long long value) { - return value != mkvparser::Colour::kValueNotPresent; -} - -bool CopyColour(const mkvparser::Colour& parser_colour, - mkvmuxer::Colour* muxer_colour) { - if (!muxer_colour) - return false; - - if (ColourValuePresent(parser_colour.matrix_coefficients)) - muxer_colour->matrix_coefficients = parser_colour.matrix_coefficients; - if (ColourValuePresent(parser_colour.bits_per_channel)) - muxer_colour->bits_per_channel = parser_colour.bits_per_channel; - if (ColourValuePresent(parser_colour.chroma_subsampling_horz)) - muxer_colour->chroma_subsampling_horz = - parser_colour.chroma_subsampling_horz; - if (ColourValuePresent(parser_colour.chroma_subsampling_vert)) - muxer_colour->chroma_subsampling_vert = - parser_colour.chroma_subsampling_vert; - if (ColourValuePresent(parser_colour.cb_subsampling_horz)) - muxer_colour->cb_subsampling_horz = parser_colour.cb_subsampling_horz; - if (ColourValuePresent(parser_colour.cb_subsampling_vert)) - muxer_colour->cb_subsampling_vert = parser_colour.cb_subsampling_vert; - if (ColourValuePresent(parser_colour.chroma_siting_horz)) - muxer_colour->chroma_siting_horz = parser_colour.chroma_siting_horz; - if (ColourValuePresent(parser_colour.chroma_siting_vert)) - muxer_colour->chroma_siting_vert = parser_colour.chroma_siting_vert; - if (ColourValuePresent(parser_colour.range)) - muxer_colour->range = parser_colour.range; - if (ColourValuePresent(parser_colour.transfer_characteristics)) - muxer_colour->transfer_characteristics = - parser_colour.transfer_characteristics; - if (ColourValuePresent(parser_colour.primaries)) - muxer_colour->primaries = parser_colour.primaries; - if (ColourValuePresent(parser_colour.max_cll)) - muxer_colour->max_cll = parser_colour.max_cll; - if (ColourValuePresent(parser_colour.max_fall)) - muxer_colour->max_fall = parser_colour.max_fall; - - if (parser_colour.mastering_metadata) { - mkvmuxer::MasteringMetadata muxer_mm; - if (!CopyMasteringMetadata(*parser_colour.mastering_metadata, &muxer_mm)) - return false; - if (!muxer_colour->SetMasteringMetadata(muxer_mm)) - return false; - } - return true; -} - -// Format of VPx private data: -// -// 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 -// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ -// | ID Byte | Length | | -// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | -// | | -// : Bytes 1..Length of Codec Feature : -// | | -// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ -// -// ID Byte Format -// ID byte is an unsigned byte. -// 0 1 2 3 4 5 6 7 -// +-+-+-+-+-+-+-+-+ -// |X| ID | -// +-+-+-+-+-+-+-+-+ -// -// The X bit is reserved. -// -// Currently only profile level is supported. ID byte must be set to 1, and -// length must be 1. Supported values are: -// -// 10: Level 1 -// 11: Level 1.1 -// 20: Level 2 -// 21: Level 2.1 -// 30: Level 3 -// 31: Level 3.1 -// 40: Level 4 -// 41: Level 4.1 -// 50: Level 5 -// 51: Level 5.1 -// 52: Level 5.2 -// 60: Level 6 -// 61: Level 6.1 -// 62: Level 6.2 -// -// See the following link for more information: -// http://www.webmproject.org/vp9/profiles/ -int ParseVpxCodecPrivate(const uint8_t* private_data, int32_t length) { - const int kVpxCodecPrivateLength = 3; - if (!private_data || length != kVpxCodecPrivateLength) - return 0; - - const uint8_t id_byte = *private_data; - if (id_byte != 1) - return 0; - - const int kVpxProfileLength = 1; - const uint8_t length_byte = private_data[1]; - if (length_byte != kVpxProfileLength) - return 0; - - const int level = static_cast(private_data[2]); - - const int kNumLevels = 14; - const int levels[kNumLevels] = {10, 11, 20, 21, 30, 31, 40, - 41, 50, 51, 52, 60, 61, 62}; - - for (int i = 0; i < kNumLevels; ++i) { - if (level == levels[i]) - return level; - } - - return 0; -} -} // namespace libwebm diff --git a/third_party/libwebm/common/hdr_util.h b/third_party/libwebm/common/hdr_util.h deleted file mode 100644 index d30c2b9f2..000000000 --- a/third_party/libwebm/common/hdr_util.h +++ /dev/null @@ -1,51 +0,0 @@ -// Copyright (c) 2016 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. -#ifndef LIBWEBM_COMMON_HDR_UTIL_H_ -#define LIBWEBM_COMMON_HDR_UTIL_H_ - -#include - -#include - -#include "mkvmuxer/mkvmuxer.h" - -namespace mkvparser { -struct Colour; -struct MasteringMetadata; -struct PrimaryChromaticity; -} // namespace mkvparser - -namespace libwebm { -// Utility types and functions for working with the Colour element and its -// children. Copiers return true upon success. Presence functions return true -// when the specified element is present. - -// TODO(tomfinegan): These should be moved to libwebm_utils once c++11 is -// required by libwebm. - -typedef std::auto_ptr PrimaryChromaticityPtr; - -bool CopyPrimaryChromaticity(const mkvparser::PrimaryChromaticity& parser_pc, - PrimaryChromaticityPtr* muxer_pc); - -bool MasteringMetadataValuePresent(double value); - -bool CopyMasteringMetadata(const mkvparser::MasteringMetadata& parser_mm, - mkvmuxer::MasteringMetadata* muxer_mm); - -bool ColourValuePresent(long long value); - -bool CopyColour(const mkvparser::Colour& parser_colour, - mkvmuxer::Colour* muxer_colour); - -// Returns VP9 profile upon success or 0 upon failure. -int ParseVpxCodecPrivate(const uint8_t* private_data, int32_t length); - -} // namespace libwebm - -#endif // LIBWEBM_COMMON_HDR_UTIL_H_ diff --git a/third_party/libwebm/mkvmuxer/mkvmuxer.cc b/third_party/libwebm/mkvmuxer.cpp similarity index 56% rename from third_party/libwebm/mkvmuxer/mkvmuxer.cc rename to third_party/libwebm/mkvmuxer.cpp index c79ce24ed..9be3119a4 100644 --- a/third_party/libwebm/mkvmuxer/mkvmuxer.cc +++ b/third_party/libwebm/mkvmuxer.cpp @@ -6,28 +6,27 @@ // 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 "mkvmuxer.hpp" -#include #include #include #include #include #include -#include #include -#include -#include "common/webmids.h" -#include "mkvmuxer/mkvmuxerutil.h" -#include "mkvmuxer/mkvwriter.h" -#include "mkvparser/mkvparser.h" +#include "mkvmuxerutil.hpp" +#include "mkvparser.hpp" +#include "mkvwriter.hpp" +#include "webmids.hpp" + +#ifdef _MSC_VER +// Disable MSVC warnings that suggest making code non-portable. +#pragma warning(disable : 4996) +#endif namespace mkvmuxer { -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 @@ -56,20 +55,6 @@ bool StrCpy(const char* src, char** dst_ptr) { strcpy(dst, src); // NOLINT return true; } - -typedef std::auto_ptr 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 /////////////////////////////////////////////////////////////// @@ -80,31 +65,31 @@ IMkvWriter::IMkvWriter() {} IMkvWriter::~IMkvWriter() {} -bool WriteEbmlHeader(IMkvWriter* writer, uint64_t doc_type_version) { +bool WriteEbmlHeader(IMkvWriter* writer, uint64 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)); + uint64 size = EbmlElementSize(kMkvEBMLVersion, 1ULL); + size += EbmlElementSize(kMkvEBMLReadVersion, 1ULL); + size += EbmlElementSize(kMkvEBMLMaxIDLength, 4ULL); + size += EbmlElementSize(kMkvEBMLMaxSizeLength, 8ULL); + size += EbmlElementSize(kMkvDocType, "webm"); + size += EbmlElementSize(kMkvDocTypeVersion, doc_type_version); + size += EbmlElementSize(kMkvDocTypeReadVersion, 2ULL); - if (!WriteEbmlMasterElement(writer, libwebm::kMkvEBML, size)) + if (!WriteEbmlMasterElement(writer, kMkvEBML, size)) return false; - if (!WriteEbmlElement(writer, libwebm::kMkvEBMLVersion, UINT64_C(1))) + if (!WriteEbmlElement(writer, kMkvEBMLVersion, 1ULL)) return false; - if (!WriteEbmlElement(writer, libwebm::kMkvEBMLReadVersion, UINT64_C(1))) + if (!WriteEbmlElement(writer, kMkvEBMLReadVersion, 1ULL)) return false; - if (!WriteEbmlElement(writer, libwebm::kMkvEBMLMaxIDLength, UINT64_C(4))) + if (!WriteEbmlElement(writer, kMkvEBMLMaxIDLength, 4ULL)) return false; - if (!WriteEbmlElement(writer, libwebm::kMkvEBMLMaxSizeLength, UINT64_C(8))) + if (!WriteEbmlElement(writer, kMkvEBMLMaxSizeLength, 8ULL)) return false; - if (!WriteEbmlElement(writer, libwebm::kMkvDocType, "webm")) + if (!WriteEbmlElement(writer, kMkvDocType, "webm")) return false; - if (!WriteEbmlElement(writer, libwebm::kMkvDocTypeVersion, doc_type_version)) + if (!WriteEbmlElement(writer, kMkvDocTypeVersion, doc_type_version)) return false; - if (!WriteEbmlElement(writer, libwebm::kMkvDocTypeReadVersion, UINT64_C(2))) + if (!WriteEbmlElement(writer, kMkvDocTypeReadVersion, 2ULL)) return false; return true; @@ -115,16 +100,16 @@ bool WriteEbmlHeader(IMkvWriter* writer) { } bool ChunkedCopy(mkvparser::IMkvReader* source, mkvmuxer::IMkvWriter* dst, - int64_t start, int64_t size) { + mkvmuxer::int64 start, int64 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; + const uint32 kBufSize = 2048; + uint8* buf = new uint8[kBufSize]; + int64 offset = start; while (size > 0) { - const int64_t read_len = (size > kBufSize) ? kBufSize : size; + const int64 read_len = (size > kBufSize) ? kBufSize : size; if (source->Read(offset, static_cast(read_len), buf)) return false; - dst->Write(buf, static_cast(read_len)); + dst->Write(buf, static_cast(read_len)); offset += read_len; size -= read_len; } @@ -141,7 +126,6 @@ Frame::Frame() additional_(NULL), additional_length_(0), duration_(0), - duration_set_(false), frame_(NULL), is_key_(false), length_(0), @@ -174,19 +158,16 @@ bool Frame::CopyFrom(const Frame& frame) { 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(length)]; // NOLINT +bool Frame::Init(const uint8* frame, uint64 length) { + uint8* const data = + new (std::nothrow) uint8[static_cast(length)]; // NOLINT if (!data) return false; @@ -198,10 +179,10 @@ bool Frame::Init(const uint8_t* frame, uint64_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(length)]; // NOLINT +bool Frame::AddAdditionalData(const uint8* additional, uint64 length, + uint64 add_id) { + uint8* const data = + new (std::nothrow) uint8[static_cast(length)]; // NOLINT if (!data) return false; @@ -235,12 +216,7 @@ 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) { +void Frame::set_reference_block_timestamp(int64 reference_block_timestamp) { reference_block_timestamp_ = reference_block_timestamp; reference_block_timestamp_set_ = true; } @@ -262,64 +238,61 @@ 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 size = EbmlElementSize(kMkvCueClusterPosition, cluster_pos_); + size += EbmlElementSize(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; + size += EbmlElementSize(kMkvCueBlockNumber, block_number_); + const uint64 track_pos_size = + EbmlMasterElementSize(kMkvCueTrackPositions, size) + size; + const uint64 payload_size = + EbmlElementSize(kMkvCueTime, time_) + track_pos_size; - if (!WriteEbmlMasterElement(writer, libwebm::kMkvCuePoint, payload_size)) + if (!WriteEbmlMasterElement(writer, kMkvCuePoint, payload_size)) return false; - const int64_t payload_position = writer->Position(); + const int64 payload_position = writer->Position(); if (payload_position < 0) return false; - if (!WriteEbmlElement(writer, libwebm::kMkvCueTime, time_)) + if (!WriteEbmlElement(writer, kMkvCueTime, time_)) return false; - if (!WriteEbmlMasterElement(writer, libwebm::kMkvCueTrackPositions, size)) + if (!WriteEbmlMasterElement(writer, kMkvCueTrackPositions, size)) return false; - if (!WriteEbmlElement(writer, libwebm::kMkvCueTrack, track_)) + if (!WriteEbmlElement(writer, kMkvCueTrack, track_)) return false; - if (!WriteEbmlElement(writer, libwebm::kMkvCueClusterPosition, cluster_pos_)) + if (!WriteEbmlElement(writer, kMkvCueClusterPosition, cluster_pos_)) return false; if (output_block_number_ && block_number_ > 1) - if (!WriteEbmlElement(writer, libwebm::kMkvCueBlockNumber, block_number_)) + if (!WriteEbmlElement(writer, kMkvCueBlockNumber, block_number_)) return false; - const int64_t stop_position = writer->Position(); + const int64 stop_position = writer->Position(); if (stop_position < 0) return false; - if (stop_position - payload_position != static_cast(payload_size)) + if (stop_position - payload_position != static_cast(payload_size)) return false; return true; } -uint64_t CuePoint::PayloadSize() const { - uint64_t size = - EbmlElementSize(libwebm::kMkvCueClusterPosition, cluster_pos_); - size += EbmlElementSize(libwebm::kMkvCueTrack, track_); +uint64 CuePoint::PayloadSize() const { + uint64 size = EbmlElementSize(kMkvCueClusterPosition, cluster_pos_); + size += EbmlElementSize(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; + size += EbmlElementSize(kMkvCueBlockNumber, block_number_); + const uint64 track_pos_size = + EbmlMasterElementSize(kMkvCueTrackPositions, size) + size; + const uint64 payload_size = + EbmlElementSize(kMkvCueTime, time_) + track_pos_size; return payload_size; } -uint64_t CuePoint::Size() const { - const uint64_t payload_size = PayloadSize(); - return EbmlMasterElementSize(libwebm::kMkvCuePoint, payload_size) + - payload_size; +uint64 CuePoint::Size() const { + const uint64 payload_size = PayloadSize(); + return EbmlMasterElementSize(kMkvCuePoint, payload_size) + payload_size; } /////////////////////////////////////////////////////////////// @@ -334,7 +307,7 @@ Cues::Cues() Cues::~Cues() { if (cue_entries_) { - for (int32_t i = 0; i < cue_entries_size_; ++i) { + for (int32 i = 0; i < cue_entries_size_; ++i) { CuePoint* const cue = cue_entries_[i]; delete cue; } @@ -348,7 +321,7 @@ bool Cues::AddCue(CuePoint* cue) { if ((cue_entries_size_ + 1) > cue_entries_capacity_) { // Add more CuePoints. - const int32_t new_capacity = + const int32 new_capacity = (!cue_entries_capacity_) ? 2 : cue_entries_capacity_ * 2; if (new_capacity < 1) @@ -359,7 +332,7 @@ bool Cues::AddCue(CuePoint* cue) { if (!cues) return false; - for (int32_t i = 0; i < cue_entries_size_; ++i) { + for (int32 i = 0; i < cue_entries_size_; ++i) { cues[i] = cue_entries_[i]; } @@ -374,7 +347,7 @@ bool Cues::AddCue(CuePoint* cue) { return true; } -CuePoint* Cues::GetCueByIndex(int32_t index) const { +CuePoint* Cues::GetCueByIndex(int32 index) const { if (cue_entries_ == NULL) return NULL; @@ -384,11 +357,11 @@ CuePoint* Cues::GetCueByIndex(int32_t index) const { return cue_entries_[index]; } -uint64_t Cues::Size() { - uint64_t size = 0; - for (int32_t i = 0; i < cue_entries_size_; ++i) +uint64 Cues::Size() { + uint64 size = 0; + for (int32 i = 0; i < cue_entries_size_; ++i) size += GetCueByIndex(i)->Size(); - size += EbmlMasterElementSize(libwebm::kMkvCues, size); + size += EbmlMasterElementSize(kMkvCues, size); return size; } @@ -396,8 +369,8 @@ bool Cues::Write(IMkvWriter* writer) const { if (!writer) return false; - uint64_t size = 0; - for (int32_t i = 0; i < cue_entries_size_; ++i) { + uint64 size = 0; + for (int32 i = 0; i < cue_entries_size_; ++i) { const CuePoint* const cue = GetCueByIndex(i); if (!cue) @@ -406,25 +379,25 @@ bool Cues::Write(IMkvWriter* writer) const { size += cue->Size(); } - if (!WriteEbmlMasterElement(writer, libwebm::kMkvCues, size)) + if (!WriteEbmlMasterElement(writer, kMkvCues, size)) return false; - const int64_t payload_position = writer->Position(); + const int64 payload_position = writer->Position(); if (payload_position < 0) return false; - for (int32_t i = 0; i < cue_entries_size_; ++i) { + for (int32 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(); + const int64 stop_position = writer->Position(); if (stop_position < 0) return false; - if (stop_position - payload_position != static_cast(size)) + if (stop_position - payload_position != static_cast(size)) return false; return true; @@ -436,40 +409,36 @@ bool Cues::Write(IMkvWriter* writer) const { ContentEncAESSettings::ContentEncAESSettings() : cipher_mode_(kCTR) {} -uint64_t ContentEncAESSettings::Size() const { - const uint64_t payload = PayloadSize(); - const uint64_t size = - EbmlMasterElementSize(libwebm::kMkvContentEncAESSettings, payload) + - payload; +uint64 ContentEncAESSettings::Size() const { + const uint64 payload = PayloadSize(); + const uint64 size = + EbmlMasterElementSize(kMkvContentEncAESSettings, payload) + payload; return size; } bool ContentEncAESSettings::Write(IMkvWriter* writer) const { - const uint64_t payload = PayloadSize(); + const uint64 payload = PayloadSize(); - if (!WriteEbmlMasterElement(writer, libwebm::kMkvContentEncAESSettings, - payload)) + if (!WriteEbmlMasterElement(writer, kMkvContentEncAESSettings, payload)) return false; - const int64_t payload_position = writer->Position(); + const int64 payload_position = writer->Position(); if (payload_position < 0) return false; - if (!WriteEbmlElement(writer, libwebm::kMkvAESSettingsCipherMode, - cipher_mode_)) + if (!WriteEbmlElement(writer, kMkvAESSettingsCipherMode, cipher_mode_)) return false; - const int64_t stop_position = writer->Position(); + const int64 stop_position = writer->Position(); if (stop_position < 0 || - stop_position - payload_position != static_cast(payload)) + stop_position - payload_position != static_cast(payload)) return false; return true; } -uint64_t ContentEncAESSettings::PayloadSize() const { - uint64_t size = - EbmlElementSize(libwebm::kMkvAESSettingsCipherMode, cipher_mode_); +uint64 ContentEncAESSettings::PayloadSize() const { + uint64 size = EbmlElementSize(kMkvAESSettingsCipherMode, cipher_mode_); return size; } @@ -487,14 +456,14 @@ ContentEncoding::ContentEncoding() ContentEncoding::~ContentEncoding() { delete[] enc_key_id_; } -bool ContentEncoding::SetEncryptionID(const uint8_t* id, uint64_t length) { +bool ContentEncoding::SetEncryptionID(const uint8* id, uint64 length) { if (!id || length < 1) return false; delete[] enc_key_id_; enc_key_id_ = - new (std::nothrow) uint8_t[static_cast(length)]; // NOLINT + new (std::nothrow) uint8[static_cast(length)]; // NOLINT if (!enc_key_id_) return false; @@ -504,89 +473,79 @@ bool ContentEncoding::SetEncryptionID(const uint8_t* id, uint64_t 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; +uint64 ContentEncoding::Size() const { + const uint64 encryption_size = EncryptionSize(); + const uint64 encoding_size = EncodingSize(0, encryption_size); + const uint64 encodings_size = + EbmlMasterElementSize(kMkvContentEncoding, encoding_size) + encoding_size; return encodings_size; } bool ContentEncoding::Write(IMkvWriter* writer) const { - const uint64_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 uint64 encryption_size = EncryptionSize(); + const uint64 encoding_size = EncodingSize(0, encryption_size); + const uint64 size = + EbmlMasterElementSize(kMkvContentEncoding, encoding_size) + encoding_size; - const int64_t payload_position = writer->Position(); + const int64 payload_position = writer->Position(); if (payload_position < 0) return false; - if (!WriteEbmlMasterElement(writer, libwebm::kMkvContentEncoding, - encoding_size)) + if (!WriteEbmlMasterElement(writer, kMkvContentEncoding, encoding_size)) return false; - if (!WriteEbmlElement(writer, libwebm::kMkvContentEncodingOrder, - encoding_order_)) + if (!WriteEbmlElement(writer, kMkvContentEncodingOrder, encoding_order_)) return false; - if (!WriteEbmlElement(writer, libwebm::kMkvContentEncodingScope, - encoding_scope_)) + if (!WriteEbmlElement(writer, kMkvContentEncodingScope, encoding_scope_)) return false; - if (!WriteEbmlElement(writer, libwebm::kMkvContentEncodingType, - encoding_type_)) + if (!WriteEbmlElement(writer, kMkvContentEncodingType, encoding_type_)) return false; - if (!WriteEbmlMasterElement(writer, libwebm::kMkvContentEncryption, - encryption_size)) + if (!WriteEbmlMasterElement(writer, kMkvContentEncryption, encryption_size)) return false; - if (!WriteEbmlElement(writer, libwebm::kMkvContentEncAlgo, enc_algo_)) + if (!WriteEbmlElement(writer, kMkvContentEncAlgo, enc_algo_)) return false; - if (!WriteEbmlElement(writer, libwebm::kMkvContentEncKeyID, enc_key_id_, + if (!WriteEbmlElement(writer, 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(); + const int64 stop_position = writer->Position(); if (stop_position < 0 || - stop_position - payload_position != static_cast(size)) + stop_position - payload_position != static_cast(size)) return false; return true; } -uint64_t ContentEncoding::EncodingSize(uint64_t compresion_size, - uint64_t encryption_size) const { +uint64 ContentEncoding::EncodingSize(uint64 compresion_size, + uint64 encryption_size) const { // TODO(fgalligan): Add support for compression settings. if (compresion_size != 0) return 0; - uint64_t encoding_size = 0; + uint64 encoding_size = 0; if (encryption_size > 0) { encoding_size += - EbmlMasterElementSize(libwebm::kMkvContentEncryption, encryption_size) + + EbmlMasterElementSize(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(kMkvContentEncodingType, encoding_type_); + encoding_size += EbmlElementSize(kMkvContentEncodingScope, encoding_scope_); + encoding_size += EbmlElementSize(kMkvContentEncodingOrder, encoding_order_); return encoding_size; } -uint64_t ContentEncoding::EncryptionSize() const { - const uint64_t aes_size = enc_aes_settings_.Size(); +uint64 ContentEncoding::EncryptionSize() const { + const uint64 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_); + uint64 encryption_size = + EbmlElementSize(kMkvContentEncKeyID, enc_key_id_, enc_key_id_length_); + encryption_size += EbmlElementSize(kMkvContentEncAlgo, enc_algo_); return encryption_size + aes_size; } @@ -618,7 +577,7 @@ Track::~Track() { delete[] name_; if (content_encoding_entries_) { - for (uint32_t i = 0; i < content_encoding_entries_size_; ++i) { + for (uint32 i = 0; i < content_encoding_entries_size_; ++i) { ContentEncoding* const encoding = content_encoding_entries_[i]; delete encoding; } @@ -627,7 +586,7 @@ Track::~Track() { } bool Track::AddContentEncoding() { - const uint32_t count = content_encoding_entries_size_ + 1; + const uint32 count = content_encoding_entries_size_ + 1; ContentEncoding** const content_encoding_entries = new (std::nothrow) ContentEncoding*[count]; // NOLINT @@ -641,7 +600,7 @@ bool Track::AddContentEncoding() { return false; } - for (uint32_t i = 0; i < content_encoding_entries_size_; ++i) { + for (uint32 i = 0; i < content_encoding_entries_size_; ++i) { content_encoding_entries[i] = content_encoding_entries_[i]; } @@ -653,7 +612,7 @@ bool Track::AddContentEncoding() { return true; } -ContentEncoding* Track::GetContentEncodingByIndex(uint32_t index) const { +ContentEncoding* Track::GetContentEncodingByIndex(uint32 index) const { if (content_encoding_entries_ == NULL) return NULL; @@ -663,47 +622,46 @@ ContentEncoding* Track::GetContentEncodingByIndex(uint32_t index) const { 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_); +uint64 Track::PayloadSize() const { + uint64 size = EbmlElementSize(kMkvTrackNumber, number_); + size += EbmlElementSize(kMkvTrackUID, uid_); + size += EbmlElementSize(kMkvTrackType, type_); if (codec_id_) - size += EbmlElementSize(libwebm::kMkvCodecID, codec_id_); + size += EbmlElementSize(kMkvCodecID, codec_id_); if (codec_private_) - size += EbmlElementSize(libwebm::kMkvCodecPrivate, codec_private_, + size += EbmlElementSize(kMkvCodecPrivate, codec_private_, codec_private_length_); if (language_) - size += EbmlElementSize(libwebm::kMkvLanguage, language_); + size += EbmlElementSize(kMkvLanguage, language_); if (name_) - size += EbmlElementSize(libwebm::kMkvName, name_); + size += EbmlElementSize(kMkvName, name_); if (max_block_additional_id_) - size += EbmlElementSize(libwebm::kMkvMaxBlockAdditionID, - max_block_additional_id_); + size += EbmlElementSize(kMkvMaxBlockAdditionID, max_block_additional_id_); if (codec_delay_) - size += EbmlElementSize(libwebm::kMkvCodecDelay, codec_delay_); + size += EbmlElementSize(kMkvCodecDelay, codec_delay_); if (seek_pre_roll_) - size += EbmlElementSize(libwebm::kMkvSeekPreRoll, seek_pre_roll_); + size += EbmlElementSize(kMkvSeekPreRoll, seek_pre_roll_); if (default_duration_) - size += EbmlElementSize(libwebm::kMkvDefaultDuration, default_duration_); + size += EbmlElementSize(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) { + uint64 content_encodings_size = 0; + for (uint32 i = 0; i < content_encoding_entries_size_; ++i) { ContentEncoding* const encoding = content_encoding_entries_[i]; content_encodings_size += encoding->Size(); } - size += EbmlMasterElementSize(libwebm::kMkvContentEncodings, - content_encodings_size) + - content_encodings_size; + size += + EbmlMasterElementSize(kMkvContentEncodings, content_encodings_size) + + content_encodings_size; } return size; } -uint64_t Track::Size() const { - uint64_t size = PayloadSize(); - size += EbmlMasterElementSize(libwebm::kMkvTrackEntry, size); +uint64 Track::Size() const { + uint64 size = PayloadSize(); + size += EbmlMasterElementSize(kMkvTrackEntry, size); return size; } @@ -717,97 +675,95 @@ bool Track::Write(IMkvWriter* writer) const { // |size| may be bigger than what is written out in this function because // derived classes may write out more data in the Track element. - const uint64_t payload_size = PayloadSize(); + const uint64 payload_size = PayloadSize(); - if (!WriteEbmlMasterElement(writer, libwebm::kMkvTrackEntry, payload_size)) + if (!WriteEbmlMasterElement(writer, kMkvTrackEntry, payload_size)) return false; - uint64_t size = EbmlElementSize(libwebm::kMkvTrackNumber, number_); - size += EbmlElementSize(libwebm::kMkvTrackUID, uid_); - size += EbmlElementSize(libwebm::kMkvTrackType, type_); + uint64 size = EbmlElementSize(kMkvTrackNumber, number_); + size += EbmlElementSize(kMkvTrackUID, uid_); + size += EbmlElementSize(kMkvTrackType, type_); if (codec_id_) - size += EbmlElementSize(libwebm::kMkvCodecID, codec_id_); + size += EbmlElementSize(kMkvCodecID, codec_id_); if (codec_private_) - size += EbmlElementSize(libwebm::kMkvCodecPrivate, codec_private_, + size += EbmlElementSize(kMkvCodecPrivate, codec_private_, codec_private_length_); if (language_) - size += EbmlElementSize(libwebm::kMkvLanguage, language_); + size += EbmlElementSize(kMkvLanguage, language_); if (name_) - size += EbmlElementSize(libwebm::kMkvName, name_); + size += EbmlElementSize(kMkvName, name_); if (max_block_additional_id_) - size += EbmlElementSize(libwebm::kMkvMaxBlockAdditionID, - max_block_additional_id_); + size += EbmlElementSize(kMkvMaxBlockAdditionID, max_block_additional_id_); if (codec_delay_) - size += EbmlElementSize(libwebm::kMkvCodecDelay, codec_delay_); + size += EbmlElementSize(kMkvCodecDelay, codec_delay_); if (seek_pre_roll_) - size += EbmlElementSize(libwebm::kMkvSeekPreRoll, seek_pre_roll_); + size += EbmlElementSize(kMkvSeekPreRoll, seek_pre_roll_); if (default_duration_) - size += EbmlElementSize(libwebm::kMkvDefaultDuration, default_duration_); + size += EbmlElementSize(kMkvDefaultDuration, default_duration_); - const int64_t payload_position = writer->Position(); + const int64 payload_position = writer->Position(); if (payload_position < 0) return false; - if (!WriteEbmlElement(writer, libwebm::kMkvTrackNumber, number_)) + if (!WriteEbmlElement(writer, kMkvTrackNumber, number_)) return false; - if (!WriteEbmlElement(writer, libwebm::kMkvTrackUID, uid_)) + if (!WriteEbmlElement(writer, kMkvTrackUID, uid_)) return false; - if (!WriteEbmlElement(writer, libwebm::kMkvTrackType, type_)) + if (!WriteEbmlElement(writer, kMkvTrackType, type_)) return false; if (max_block_additional_id_) { - if (!WriteEbmlElement(writer, libwebm::kMkvMaxBlockAdditionID, + if (!WriteEbmlElement(writer, kMkvMaxBlockAdditionID, max_block_additional_id_)) { return false; } } if (codec_delay_) { - if (!WriteEbmlElement(writer, libwebm::kMkvCodecDelay, codec_delay_)) + if (!WriteEbmlElement(writer, kMkvCodecDelay, codec_delay_)) return false; } if (seek_pre_roll_) { - if (!WriteEbmlElement(writer, libwebm::kMkvSeekPreRoll, seek_pre_roll_)) + if (!WriteEbmlElement(writer, kMkvSeekPreRoll, seek_pre_roll_)) return false; } if (default_duration_) { - if (!WriteEbmlElement(writer, libwebm::kMkvDefaultDuration, - default_duration_)) + if (!WriteEbmlElement(writer, kMkvDefaultDuration, default_duration_)) return false; } if (codec_id_) { - if (!WriteEbmlElement(writer, libwebm::kMkvCodecID, codec_id_)) + if (!WriteEbmlElement(writer, kMkvCodecID, codec_id_)) return false; } if (codec_private_) { - if (!WriteEbmlElement(writer, libwebm::kMkvCodecPrivate, codec_private_, + if (!WriteEbmlElement(writer, kMkvCodecPrivate, codec_private_, codec_private_length_)) return false; } if (language_) { - if (!WriteEbmlElement(writer, libwebm::kMkvLanguage, language_)) + if (!WriteEbmlElement(writer, kMkvLanguage, language_)) return false; } if (name_) { - if (!WriteEbmlElement(writer, libwebm::kMkvName, name_)) + if (!WriteEbmlElement(writer, kMkvName, name_)) return false; } - int64_t stop_position = writer->Position(); + int64 stop_position = writer->Position(); if (stop_position < 0 || - stop_position - payload_position != static_cast(size)) + stop_position - payload_position != static_cast(size)) return false; if (content_encoding_entries_size_ > 0) { - uint64_t content_encodings_size = 0; - for (uint32_t i = 0; i < content_encoding_entries_size_; ++i) { + uint64 content_encodings_size = 0; + for (uint32 i = 0; i < content_encoding_entries_size_; ++i) { ContentEncoding* const encoding = content_encoding_entries_[i]; content_encodings_size += encoding->Size(); } - if (!WriteEbmlMasterElement(writer, libwebm::kMkvContentEncodings, + if (!WriteEbmlMasterElement(writer, kMkvContentEncodings, content_encodings_size)) return false; - for (uint32_t i = 0; i < content_encoding_entries_size_; ++i) { + for (uint32 i = 0; i < content_encoding_entries_size_; ++i) { ContentEncoding* const encoding = content_encoding_entries_[i]; if (!encoding->Write(writer)) return false; @@ -820,14 +776,14 @@ bool Track::Write(IMkvWriter* writer) const { return true; } -bool Track::SetCodecPrivate(const uint8_t* codec_private, uint64_t length) { +bool Track::SetCodecPrivate(const uint8* codec_private, uint64 length) { if (!codec_private || length < 1) return false; delete[] codec_private_; codec_private_ = - new (std::nothrow) uint8_t[static_cast(length)]; // NOLINT + new (std::nothrow) uint8[static_cast(length)]; // NOLINT if (!codec_private_) return false; @@ -886,279 +842,6 @@ void Track::set_name(const char* name) { } } -/////////////////////////////////////////////////////////////// -// -// 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 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 @@ -1175,12 +858,11 @@ VideoTrack::VideoTrack(unsigned int* seed) height_(0), stereo_mode_(0), alpha_mode_(0), - width_(0), - colour_(NULL) {} + width_(0) {} -VideoTrack::~VideoTrack() { delete colour_; } +VideoTrack::~VideoTrack() {} -bool VideoTrack::SetStereoMode(uint64_t stereo_mode) { +bool VideoTrack::SetStereoMode(uint64 stereo_mode) { if (stereo_mode != kMono && stereo_mode != kSideBySideLeftIsFirst && stereo_mode != kTopBottomRightIsFirst && stereo_mode != kTopBottomLeftIsFirst && @@ -1191,7 +873,7 @@ bool VideoTrack::SetStereoMode(uint64_t stereo_mode) { return true; } -bool VideoTrack::SetAlphaMode(uint64_t alpha_mode) { +bool VideoTrack::SetAlphaMode(uint64 alpha_mode) { if (alpha_mode != kNoAlpha && alpha_mode != kAlpha) return false; @@ -1199,11 +881,11 @@ bool VideoTrack::SetAlphaMode(uint64_t alpha_mode) { return true; } -uint64_t VideoTrack::PayloadSize() const { - const uint64_t parent_size = Track::PayloadSize(); +uint64 VideoTrack::PayloadSize() const { + const uint64 parent_size = Track::PayloadSize(); - uint64_t size = VideoPayloadSize(); - size += EbmlMasterElementSize(libwebm::kMkvVideo, size); + uint64 size = VideoPayloadSize(); + size += EbmlMasterElementSize(kMkvVideo, size); return parent_size + size; } @@ -1212,122 +894,88 @@ bool VideoTrack::Write(IMkvWriter* writer) const { if (!Track::Write(writer)) return false; - const uint64_t size = VideoPayloadSize(); + const uint64 size = VideoPayloadSize(); - if (!WriteEbmlMasterElement(writer, libwebm::kMkvVideo, size)) + if (!WriteEbmlMasterElement(writer, kMkvVideo, size)) return false; - const int64_t payload_position = writer->Position(); + const int64 payload_position = writer->Position(); if (payload_position < 0) return false; - if (!WriteEbmlElement(writer, libwebm::kMkvPixelWidth, width_)) + if (!WriteEbmlElement(writer, kMkvPixelWidth, width_)) return false; - if (!WriteEbmlElement(writer, libwebm::kMkvPixelHeight, height_)) + if (!WriteEbmlElement(writer, kMkvPixelHeight, height_)) return false; if (display_width_ > 0) { - if (!WriteEbmlElement(writer, libwebm::kMkvDisplayWidth, display_width_)) + if (!WriteEbmlElement(writer, kMkvDisplayWidth, display_width_)) return false; } if (display_height_ > 0) { - if (!WriteEbmlElement(writer, libwebm::kMkvDisplayHeight, display_height_)) + if (!WriteEbmlElement(writer, kMkvDisplayHeight, display_height_)) return false; } if (crop_left_ > 0) { - if (!WriteEbmlElement(writer, libwebm::kMkvPixelCropLeft, crop_left_)) + if (!WriteEbmlElement(writer, kMkvPixelCropLeft, crop_left_)) return false; } if (crop_right_ > 0) { - if (!WriteEbmlElement(writer, libwebm::kMkvPixelCropRight, crop_right_)) + if (!WriteEbmlElement(writer, kMkvPixelCropRight, crop_right_)) return false; } if (crop_top_ > 0) { - if (!WriteEbmlElement(writer, libwebm::kMkvPixelCropTop, crop_top_)) + if (!WriteEbmlElement(writer, kMkvPixelCropTop, crop_top_)) return false; } if (crop_bottom_ > 0) { - if (!WriteEbmlElement(writer, libwebm::kMkvPixelCropBottom, crop_bottom_)) + if (!WriteEbmlElement(writer, kMkvPixelCropBottom, crop_bottom_)) return false; } if (stereo_mode_ > kMono) { - if (!WriteEbmlElement(writer, libwebm::kMkvStereoMode, stereo_mode_)) + if (!WriteEbmlElement(writer, kMkvStereoMode, stereo_mode_)) return false; } if (alpha_mode_ > kNoAlpha) { - if (!WriteEbmlElement(writer, libwebm::kMkvAlphaMode, alpha_mode_)) + if (!WriteEbmlElement(writer, kMkvAlphaMode, alpha_mode_)) return false; } if (frame_rate_ > 0.0) { - if (!WriteEbmlElement(writer, libwebm::kMkvFrameRate, + if (!WriteEbmlElement(writer, kMkvFrameRate, static_cast(frame_rate_))) { return false; } } - if (colour_) { - if (!colour_->Write(writer)) - return false; - } - const int64_t stop_position = writer->Position(); + const int64 stop_position = writer->Position(); if (stop_position < 0 || - stop_position - payload_position != static_cast(size)) { + stop_position - payload_position != static_cast(size)) { return false; } return true; } -bool VideoTrack::SetColour(const Colour& colour) { - std::auto_ptr 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_); +uint64 VideoTrack::VideoPayloadSize() const { + uint64 size = EbmlElementSize(kMkvPixelWidth, width_); + size += EbmlElementSize(kMkvPixelHeight, height_); if (display_width_ > 0) - size += EbmlElementSize(libwebm::kMkvDisplayWidth, display_width_); + size += EbmlElementSize(kMkvDisplayWidth, display_width_); if (display_height_ > 0) - size += EbmlElementSize(libwebm::kMkvDisplayHeight, display_height_); + size += EbmlElementSize(kMkvDisplayHeight, display_height_); if (crop_left_ > 0) - size += EbmlElementSize(libwebm::kMkvPixelCropLeft, crop_left_); + size += EbmlElementSize(kMkvPixelCropLeft, crop_left_); if (crop_right_ > 0) - size += EbmlElementSize(libwebm::kMkvPixelCropRight, crop_right_); + size += EbmlElementSize(kMkvPixelCropRight, crop_right_); if (crop_top_ > 0) - size += EbmlElementSize(libwebm::kMkvPixelCropTop, crop_top_); + size += EbmlElementSize(kMkvPixelCropTop, crop_top_); if (crop_bottom_ > 0) - size += EbmlElementSize(libwebm::kMkvPixelCropBottom, crop_bottom_); + size += EbmlElementSize(kMkvPixelCropBottom, crop_bottom_); if (stereo_mode_ > kMono) - size += EbmlElementSize(libwebm::kMkvStereoMode, stereo_mode_); + size += EbmlElementSize(kMkvStereoMode, stereo_mode_); if (alpha_mode_ > kNoAlpha) - size += EbmlElementSize(libwebm::kMkvAlphaMode, alpha_mode_); + size += EbmlElementSize(kMkvAlphaMode, alpha_mode_); if (frame_rate_ > 0.0) - size += EbmlElementSize(libwebm::kMkvFrameRate, - static_cast(frame_rate_)); - if (colour_) - size += colour_->ColourSize(); + size += EbmlElementSize(kMkvFrameRate, static_cast(frame_rate_)); return size; } @@ -1341,15 +989,15 @@ AudioTrack::AudioTrack(unsigned int* seed) AudioTrack::~AudioTrack() {} -uint64_t AudioTrack::PayloadSize() const { - const uint64_t parent_size = Track::PayloadSize(); +uint64 AudioTrack::PayloadSize() const { + const uint64 parent_size = Track::PayloadSize(); - uint64_t size = EbmlElementSize(libwebm::kMkvSamplingFrequency, - static_cast(sample_rate_)); - size += EbmlElementSize(libwebm::kMkvChannels, channels_); + uint64 size = + EbmlElementSize(kMkvSamplingFrequency, static_cast(sample_rate_)); + size += EbmlElementSize(kMkvChannels, channels_); if (bit_depth_ > 0) - size += EbmlElementSize(libwebm::kMkvBitDepth, bit_depth_); - size += EbmlMasterElementSize(libwebm::kMkvAudio, size); + size += EbmlElementSize(kMkvBitDepth, bit_depth_); + size += EbmlMasterElementSize(kMkvAudio, size); return parent_size + size; } @@ -1359,31 +1007,31 @@ bool AudioTrack::Write(IMkvWriter* writer) const { return false; // Calculate AudioSettings size. - uint64_t size = EbmlElementSize(libwebm::kMkvSamplingFrequency, - static_cast(sample_rate_)); - size += EbmlElementSize(libwebm::kMkvChannels, channels_); + uint64 size = + EbmlElementSize(kMkvSamplingFrequency, static_cast(sample_rate_)); + size += EbmlElementSize(kMkvChannels, channels_); if (bit_depth_ > 0) - size += EbmlElementSize(libwebm::kMkvBitDepth, bit_depth_); + size += EbmlElementSize(kMkvBitDepth, bit_depth_); - if (!WriteEbmlMasterElement(writer, libwebm::kMkvAudio, size)) + if (!WriteEbmlMasterElement(writer, kMkvAudio, size)) return false; - const int64_t payload_position = writer->Position(); + const int64 payload_position = writer->Position(); if (payload_position < 0) return false; - if (!WriteEbmlElement(writer, libwebm::kMkvSamplingFrequency, + if (!WriteEbmlElement(writer, kMkvSamplingFrequency, static_cast(sample_rate_))) return false; - if (!WriteEbmlElement(writer, libwebm::kMkvChannels, channels_)) + if (!WriteEbmlElement(writer, kMkvChannels, channels_)) return false; if (bit_depth_ > 0) - if (!WriteEbmlElement(writer, libwebm::kMkvBitDepth, bit_depth_)) + if (!WriteEbmlElement(writer, kMkvBitDepth, bit_depth_)) return false; - const int64_t stop_position = writer->Position(); + const int64 stop_position = writer->Position(); if (stop_position < 0 || - stop_position - payload_position != static_cast(size)) + stop_position - payload_position != static_cast(size)) return false; return true; @@ -1399,12 +1047,11 @@ 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() : track_entries_(NULL), track_entries_size_(0) {} Tracks::~Tracks() { if (track_entries_) { - for (uint32_t i = 0; i < track_entries_size_; ++i) { + for (uint32 i = 0; i < track_entries_size_; ++i) { Track* const track = track_entries_[i]; delete track; } @@ -1412,8 +1059,8 @@ Tracks::~Tracks() { } } -bool Tracks::AddTrack(Track* track, int32_t number) { - if (number < 0 || wrote_tracks_) +bool Tracks::AddTrack(Track* track, int32 number) { + if (number < 0) return false; // This muxer only supports track numbers in the range [1, 126], in @@ -1424,23 +1071,23 @@ bool Tracks::AddTrack(Track* track, int32_t number) { if (number > 0x7E) return false; - uint32_t track_num = number; + uint32 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) { + for (uint32 i = 0; i < track_entries_size_; ++i) { if (track_entries_[i]->number() == track_num) return false; } } - const uint32_t count = track_entries_size_ + 1; + const uint32 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) { + for (uint32 i = 0; i < track_entries_size_; ++i) { track_entries[i] = track_entries_[i]; } @@ -1454,7 +1101,7 @@ bool Tracks::AddTrack(Track* track, int32_t number) { bool exit = false; do { exit = true; - for (uint32_t i = 0; i < track_entries_size_; ++i) { + for (uint32 i = 0; i < track_entries_size_; ++i) { if (track_entries[i]->number() == track_num) { track_num++; exit = false; @@ -1471,7 +1118,7 @@ bool Tracks::AddTrack(Track* track, int32_t number) { return true; } -const Track* Tracks::GetTrackByIndex(uint32_t index) const { +const Track* Tracks::GetTrackByIndex(uint32 index) const { if (track_entries_ == NULL) return NULL; @@ -1481,9 +1128,9 @@ const Track* Tracks::GetTrackByIndex(uint32_t index) const { 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) { +Track* Tracks::GetTrackByNumber(uint64 track_number) const { + const int32 count = track_entries_size(); + for (int32 i = 0; i < count; ++i) { if (track_entries_[i]->number() == track_number) return track_entries_[i]; } @@ -1491,7 +1138,7 @@ Track* Tracks::GetTrackByNumber(uint64_t track_number) const { return NULL; } -bool Tracks::TrackIsAudio(uint64_t track_number) const { +bool Tracks::TrackIsAudio(uint64 track_number) const { const Track* const track = GetTrackByNumber(track_number); if (track->type() == kAudio) @@ -1500,7 +1147,7 @@ bool Tracks::TrackIsAudio(uint64_t track_number) const { return false; } -bool Tracks::TrackIsVideo(uint64_t track_number) const { +bool Tracks::TrackIsVideo(uint64 track_number) const { const Track* const track = GetTrackByNumber(track_number); if (track->type() == kVideo) @@ -1510,9 +1157,9 @@ bool Tracks::TrackIsVideo(uint64_t track_number) const { } 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) { + uint64 size = 0; + const int32 count = track_entries_size(); + for (int32 i = 0; i < count; ++i) { const Track* const track = GetTrackByIndex(i); if (!track) @@ -1521,25 +1168,24 @@ bool Tracks::Write(IMkvWriter* writer) const { size += track->Size(); } - if (!WriteEbmlMasterElement(writer, libwebm::kMkvTracks, size)) + if (!WriteEbmlMasterElement(writer, kMkvTracks, size)) return false; - const int64_t payload_position = writer->Position(); + const int64 payload_position = writer->Position(); if (payload_position < 0) return false; - for (int32_t i = 0; i < count; ++i) { + for (int32 i = 0; i < count; ++i) { const Track* const track = GetTrackByIndex(i); if (!track->Write(writer)) return false; } - const int64_t stop_position = writer->Position(); + const int64 stop_position = writer->Position(); if (stop_position < 0 || - stop_position - payload_position != static_cast(size)) + stop_position - payload_position != static_cast(size)) return false; - wrote_tracks_ = true; return true; } @@ -1549,10 +1195,9 @@ bool Tracks::Write(IMkvWriter* writer) const { bool Chapter::set_id(const char* id) { return StrCpy(id, &id_); } -void Chapter::set_time(const Segment& segment, uint64_t start_ns, - uint64_t end_ns) { +void Chapter::set_time(const Segment& segment, uint64 start_ns, uint64 end_ns) { const SegmentInfo* const info = segment.GetSegmentInfo(); - const uint64_t timecode_scale = info->timecode_scale(); + const uint64 timecode_scale = info->timecode_scale(); start_timecode_ = start_ns / timecode_scale; end_timecode_ = end_ns / timecode_scale; } @@ -1647,40 +1292,38 @@ bool Chapter::ExpandDisplaysArray() { 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_); +uint64 Chapter::WriteAtom(IMkvWriter* writer) const { + uint64 payload_size = EbmlElementSize(kMkvChapterStringUID, id_) + + EbmlElementSize(kMkvChapterUID, uid_) + + EbmlElementSize(kMkvChapterTimeStart, start_timecode_) + + EbmlElementSize(kMkvChapterTimeEnd, end_timecode_); for (int idx = 0; idx < displays_count_; ++idx) { const Display& d = displays_[idx]; payload_size += d.WriteDisplay(NULL); } - const uint64_t atom_size = - EbmlMasterElementSize(libwebm::kMkvChapterAtom, payload_size) + - payload_size; + const uint64 atom_size = + EbmlMasterElementSize(kMkvChapterAtom, payload_size) + payload_size; if (writer == NULL) return atom_size; - const int64_t start = writer->Position(); + const int64 start = writer->Position(); - if (!WriteEbmlMasterElement(writer, libwebm::kMkvChapterAtom, payload_size)) + if (!WriteEbmlMasterElement(writer, kMkvChapterAtom, payload_size)) return 0; - if (!WriteEbmlElement(writer, libwebm::kMkvChapterStringUID, id_)) + if (!WriteEbmlElement(writer, kMkvChapterStringUID, id_)) return 0; - if (!WriteEbmlElement(writer, libwebm::kMkvChapterUID, uid_)) + if (!WriteEbmlElement(writer, kMkvChapterUID, uid_)) return 0; - if (!WriteEbmlElement(writer, libwebm::kMkvChapterTimeStart, start_timecode_)) + if (!WriteEbmlElement(writer, kMkvChapterTimeStart, start_timecode_)) return 0; - if (!WriteEbmlElement(writer, libwebm::kMkvChapterTimeEnd, end_timecode_)) + if (!WriteEbmlElement(writer, kMkvChapterTimeEnd, end_timecode_)) return 0; for (int idx = 0; idx < displays_count_; ++idx) { @@ -1690,9 +1333,9 @@ uint64_t Chapter::WriteAtom(IMkvWriter* writer) const { return 0; } - const int64_t stop = writer->Position(); + const int64 stop = writer->Position(); - if (stop >= start && uint64_t(stop - start) != atom_size) + if (stop >= start && uint64(stop - start) != atom_size) return 0; return atom_size; @@ -1722,44 +1365,42 @@ 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_); +uint64 Chapter::Display::WriteDisplay(IMkvWriter* writer) const { + uint64 payload_size = EbmlElementSize(kMkvChapString, title_); if (language_) - payload_size += EbmlElementSize(libwebm::kMkvChapLanguage, language_); + payload_size += EbmlElementSize(kMkvChapLanguage, language_); if (country_) - payload_size += EbmlElementSize(libwebm::kMkvChapCountry, country_); + payload_size += EbmlElementSize(kMkvChapCountry, country_); - const uint64_t display_size = - EbmlMasterElementSize(libwebm::kMkvChapterDisplay, payload_size) + - payload_size; + const uint64 display_size = + EbmlMasterElementSize(kMkvChapterDisplay, payload_size) + payload_size; if (writer == NULL) return display_size; - const int64_t start = writer->Position(); + const int64 start = writer->Position(); - if (!WriteEbmlMasterElement(writer, libwebm::kMkvChapterDisplay, - payload_size)) + if (!WriteEbmlMasterElement(writer, kMkvChapterDisplay, payload_size)) return 0; - if (!WriteEbmlElement(writer, libwebm::kMkvChapString, title_)) + if (!WriteEbmlElement(writer, kMkvChapString, title_)) return 0; if (language_) { - if (!WriteEbmlElement(writer, libwebm::kMkvChapLanguage, language_)) + if (!WriteEbmlElement(writer, kMkvChapLanguage, language_)) return 0; } if (country_) { - if (!WriteEbmlElement(writer, libwebm::kMkvChapCountry, country_)) + if (!WriteEbmlElement(writer, kMkvChapCountry, country_)) return 0; } - const int64_t stop = writer->Position(); + const int64 stop = writer->Position(); - if (stop >= start && uint64_t(stop - start) != display_size) + if (stop >= start && uint64(stop - start) != display_size) return 0; return display_size; @@ -1797,19 +1438,19 @@ bool Chapters::Write(IMkvWriter* writer) const { if (writer == NULL) return false; - const uint64_t payload_size = WriteEdition(NULL); // return size only + const uint64 payload_size = WriteEdition(NULL); // return size only - if (!WriteEbmlMasterElement(writer, libwebm::kMkvChapters, payload_size)) + if (!WriteEbmlMasterElement(writer, kMkvChapters, payload_size)) return false; - const int64_t start = writer->Position(); + const int64 start = writer->Position(); if (WriteEdition(writer) == 0) // error return false; - const int64_t stop = writer->Position(); + const int64 stop = writer->Position(); - if (stop >= start && uint64_t(stop - start) != payload_size) + if (stop >= start && uint64(stop - start) != payload_size) return false; return true; @@ -1839,37 +1480,36 @@ bool Chapters::ExpandChaptersArray() { return true; } -uint64_t Chapters::WriteEdition(IMkvWriter* writer) const { - uint64_t payload_size = 0; +uint64 Chapters::WriteEdition(IMkvWriter* writer) const { + uint64 payload_size = 0; for (int idx = 0; idx < chapters_count_; ++idx) { const Chapter& chapter = chapters_[idx]; payload_size += chapter.WriteAtom(NULL); } - const uint64_t edition_size = - EbmlMasterElementSize(libwebm::kMkvEditionEntry, payload_size) + - payload_size; + const uint64 edition_size = + EbmlMasterElementSize(kMkvEditionEntry, payload_size) + payload_size; if (writer == NULL) // return size only return edition_size; - const int64_t start = writer->Position(); + const int64 start = writer->Position(); - if (!WriteEbmlMasterElement(writer, libwebm::kMkvEditionEntry, payload_size)) + if (!WriteEbmlMasterElement(writer, 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); + const uint64 chapter_size = chapter.WriteAtom(writer); if (chapter_size == 0) // error return 0; } - const int64_t stop = writer->Position(); + const int64 stop = writer->Position(); - if (stop >= start && uint64_t(stop - start) != edition_size) + if (stop >= start && uint64(stop - start) != edition_size) return 0; return edition_size; @@ -1941,23 +1581,23 @@ bool Tag::ExpandSimpleTagsArray() { return true; } -uint64_t Tag::Write(IMkvWriter* writer) const { - uint64_t payload_size = 0; +uint64 Tag::Write(IMkvWriter* writer) const { + uint64 payload_size = 0; for (int idx = 0; idx < simple_tags_count_; ++idx) { const SimpleTag& st = simple_tags_[idx]; payload_size += st.Write(NULL); } - const uint64_t tag_size = - EbmlMasterElementSize(libwebm::kMkvTag, payload_size) + payload_size; + const uint64 tag_size = + EbmlMasterElementSize(kMkvTag, payload_size) + payload_size; if (writer == NULL) return tag_size; - const int64_t start = writer->Position(); + const int64 start = writer->Position(); - if (!WriteEbmlMasterElement(writer, libwebm::kMkvTag, payload_size)) + if (!WriteEbmlMasterElement(writer, kMkvTag, payload_size)) return 0; for (int idx = 0; idx < simple_tags_count_; ++idx) { @@ -1967,9 +1607,9 @@ uint64_t Tag::Write(IMkvWriter* writer) const { return 0; } - const int64_t stop = writer->Position(); + const int64 stop = writer->Position(); - if (stop >= start && uint64_t(stop - start) != tag_size) + if (stop >= start && uint64(stop - start) != tag_size) return 0; return tag_size; @@ -1995,32 +1635,31 @@ 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_); +uint64 Tag::SimpleTag::Write(IMkvWriter* writer) const { + uint64 payload_size = EbmlElementSize(kMkvTagName, tag_name_); - payload_size += EbmlElementSize(libwebm::kMkvTagString, tag_string_); + payload_size += EbmlElementSize(kMkvTagString, tag_string_); - const uint64_t simple_tag_size = - EbmlMasterElementSize(libwebm::kMkvSimpleTag, payload_size) + - payload_size; + const uint64 simple_tag_size = + EbmlMasterElementSize(kMkvSimpleTag, payload_size) + payload_size; if (writer == NULL) return simple_tag_size; - const int64_t start = writer->Position(); + const int64 start = writer->Position(); - if (!WriteEbmlMasterElement(writer, libwebm::kMkvSimpleTag, payload_size)) + if (!WriteEbmlMasterElement(writer, kMkvSimpleTag, payload_size)) return 0; - if (!WriteEbmlElement(writer, libwebm::kMkvTagName, tag_name_)) + if (!WriteEbmlElement(writer, kMkvTagName, tag_name_)) return 0; - if (!WriteEbmlElement(writer, libwebm::kMkvTagString, tag_string_)) + if (!WriteEbmlElement(writer, kMkvTagString, tag_string_)) return 0; - const int64_t stop = writer->Position(); + const int64 stop = writer->Position(); - if (stop >= start && uint64_t(stop - start) != simple_tag_size) + if (stop >= start && uint64(stop - start) != simple_tag_size) return 0; return simple_tag_size; @@ -2055,29 +1694,29 @@ bool Tags::Write(IMkvWriter* writer) const { if (writer == NULL) return false; - uint64_t payload_size = 0; + uint64 payload_size = 0; for (int idx = 0; idx < tags_count_; ++idx) { const Tag& tag = tags_[idx]; payload_size += tag.Write(NULL); } - if (!WriteEbmlMasterElement(writer, libwebm::kMkvTags, payload_size)) + if (!WriteEbmlMasterElement(writer, kMkvTags, payload_size)) return false; - const int64_t start = writer->Position(); + const int64 start = writer->Position(); for (int idx = 0; idx < tags_count_; ++idx) { const Tag& tag = tags_[idx]; - const uint64_t tag_size = tag.Write(writer); + const uint64 tag_size = tag.Write(writer); if (tag_size == 0) // error return 0; } - const int64_t stop = writer->Position(); + const int64 stop = writer->Position(); - if (stop >= start && uint64_t(stop - start) != payload_size) + if (stop >= start && uint64(stop - start) != payload_size) return false; return true; @@ -2111,18 +1750,15 @@ bool Tags::ExpandTagsArray() { // // 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) +Cluster::Cluster(uint64 timecode, int64 cues_pos, uint64 timecode_scale) : 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() {} @@ -2135,27 +1771,24 @@ bool Cluster::Init(IMkvWriter* ptr_writer) { return true; } -bool Cluster::AddFrame(const Frame* const frame) { - return QueueOrWriteFrame(frame); -} +bool Cluster::AddFrame(const Frame* const frame) { return DoWriteFrame(frame); } -bool Cluster::AddFrame(const uint8_t* data, uint64_t length, - uint64_t track_number, uint64_t abs_timecode, - bool is_key) { +bool Cluster::AddFrame(const uint8* data, uint64 length, uint64 track_number, + uint64 abs_timecode, bool is_key) { Frame frame; if (!frame.Init(data, length)) return false; frame.set_track_number(track_number); frame.set_timestamp(abs_timecode); frame.set_is_key(is_key); - return QueueOrWriteFrame(&frame); + return DoWriteFrame(&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) { +bool Cluster::AddFrameWithAdditional(const uint8* data, uint64 length, + const uint8* additional, + uint64 additional_length, uint64 add_id, + uint64 track_number, uint64 abs_timecode, + bool is_key) { if (!additional || additional_length == 0) { return false; } @@ -2167,13 +1800,13 @@ bool Cluster::AddFrameWithAdditional(const uint8_t* data, uint64_t length, frame.set_track_number(track_number); frame.set_timestamp(abs_timecode); frame.set_is_key(is_key); - return QueueOrWriteFrame(&frame); + return DoWriteFrame(&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) { +bool Cluster::AddFrameWithDiscardPadding(const uint8* data, uint64 length, + int64 discard_padding, + uint64 track_number, + uint64 abs_timecode, bool is_key) { Frame frame; if (!frame.Init(data, length)) return false; @@ -2181,12 +1814,11 @@ bool Cluster::AddFrameWithDiscardPadding(const uint8_t* data, uint64_t length, frame.set_track_number(track_number); frame.set_timestamp(abs_timecode); frame.set_is_key(is_key); - return QueueOrWriteFrame(&frame); + return DoWriteFrame(&frame); } -bool Cluster::AddMetadata(const uint8_t* data, uint64_t length, - uint64_t track_number, uint64_t abs_timecode, - uint64_t duration_timecode) { +bool Cluster::AddMetadata(const uint8* data, uint64 length, uint64 track_number, + uint64 abs_timecode, uint64 duration_timecode) { Frame frame; if (!frame.Init(data, length)) return false; @@ -2194,62 +1826,17 @@ bool Cluster::AddMetadata(const uint8_t* data, uint64_t length, frame.set_timestamp(abs_timecode); frame.set_duration(duration_timecode); frame.set_is_key(true); // All metadata blocks are keyframes. - return QueueOrWriteFrame(&frame); + return DoWriteFrame(&frame); } -void Cluster::AddPayloadSize(uint64_t size) { payload_size_ += size; } +void Cluster::AddPayloadSize(uint64 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) + if (!writer_ || finalized_ || size_position_ == -1) return false; if (writer_->Seekable()) { - const int64_t pos = writer_->Position(); + const int64 pos = writer_->Position(); if (writer_->Position(size_position_)) return false; @@ -2266,10 +1853,9 @@ bool Cluster::Finalize(bool set_last_frame_duration, uint64_t duration) { return true; } -uint64_t Cluster::Size() const { - const uint64_t element_size = - EbmlMasterElementSize(libwebm::kMkvCluster, 0xFFFFFFFFFFFFFFFFULL) + - payload_size_; +uint64 Cluster::Size() const { + const uint64 element_size = + EbmlMasterElementSize(kMkvCluster, 0xFFFFFFFFFFFFFFFFULL) + payload_size_; return element_size; } @@ -2285,15 +1871,15 @@ bool Cluster::PreWriteBlock() { return true; } -void Cluster::PostWriteBlock(uint64_t element_size) { +void Cluster::PostWriteBlock(uint64 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(abs_timecode) - cluster_timecode; +int64 Cluster::GetRelativeTimecode(int64 abs_timecode) const { + const int64 cluster_timecode = this->Cluster::timecode(); + const int64 rel_timecode = + static_cast(abs_timecode) - cluster_timecode; if (rel_timecode < 0 || rel_timecode > kMaxBlockTimecode) return -1; @@ -2308,67 +1894,11 @@ bool Cluster::DoWriteFrame(const Frame* const frame) { if (!PreWriteBlock()) return false; - const uint64_t element_size = WriteFrame(writer_, frame, this); + const uint64 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::iterator> frames_to_erase; - for (std::list::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::iterator>::iterator iterator = - frames_to_erase.begin(); - iterator != frames_to_erase.end(); ++iterator) { - stored_frames_[track_number].erase(*iterator); - } return true; } @@ -2376,7 +1906,7 @@ bool Cluster::WriteClusterHeader() { if (finalized_) return false; - if (WriteID(writer_, libwebm::kMkvCluster)) + if (WriteID(writer_, kMkvCluster)) return false; // Save for later. @@ -2387,12 +1917,9 @@ bool Cluster::WriteClusterHeader() { if (SerializeInt(writer_, kEbmlUnknownValue, 8)) return false; - if (!WriteEbmlElement(writer_, libwebm::kMkvTimecode, timecode(), - fixed_size_timecode_ ? 8 : 0)) { + if (!WriteEbmlElement(writer_, kMkvTimecode, timecode())) return false; - } - AddPayloadSize(EbmlElementSize(libwebm::kMkvTimecode, timecode(), - fixed_size_timecode_ ? 8 : 0)); + AddPayloadSize(EbmlElementSize(kMkvTimecode, timecode())); header_written_ = true; return true; @@ -2403,7 +1930,7 @@ bool Cluster::WriteClusterHeader() { // SeekHead Class SeekHead::SeekHead() : start_pos_(0ULL) { - for (int32_t i = 0; i < kSeekEntryCount; ++i) { + for (int32 i = 0; i < kSeekEntryCount; ++i) { seek_entry_id_[i] = 0; seek_entry_pos_[i] = 0; } @@ -2416,19 +1943,17 @@ bool SeekHead::Finalize(IMkvWriter* writer) const { if (start_pos_ == -1) return false; - uint64_t payload_size = 0; - uint64_t entry_size[kSeekEntryCount]; + uint64 payload_size = 0; + uint64 entry_size[kSeekEntryCount]; - for (int32_t i = 0; i < kSeekEntryCount; ++i) { + for (int32 i = 0; i < kSeekEntryCount; ++i) { if (seek_entry_id_[i] != 0) { - entry_size[i] = EbmlElementSize( - libwebm::kMkvSeekID, static_cast(seek_entry_id_[i])); - entry_size[i] += - EbmlElementSize(libwebm::kMkvSeekPosition, seek_entry_pos_[i]); + entry_size[i] = + EbmlElementSize(kMkvSeekID, static_cast(seek_entry_id_[i])); + entry_size[i] += EbmlElementSize(kMkvSeekPosition, seek_entry_pos_[i]); payload_size += - EbmlMasterElementSize(libwebm::kMkvSeek, entry_size[i]) + - entry_size[i]; + EbmlMasterElementSize(kMkvSeek, entry_size[i]) + entry_size[i]; } } @@ -2436,35 +1961,34 @@ bool SeekHead::Finalize(IMkvWriter* writer) const { if (payload_size == 0) return true; - const int64_t pos = writer->Position(); + const int64 pos = writer->Position(); if (writer->Position(start_pos_)) return false; - if (!WriteEbmlMasterElement(writer, libwebm::kMkvSeekHead, payload_size)) + if (!WriteEbmlMasterElement(writer, kMkvSeekHead, payload_size)) return false; - for (int32_t i = 0; i < kSeekEntryCount; ++i) { + for (int32 i = 0; i < kSeekEntryCount; ++i) { if (seek_entry_id_[i] != 0) { - if (!WriteEbmlMasterElement(writer, libwebm::kMkvSeek, entry_size[i])) + if (!WriteEbmlMasterElement(writer, kMkvSeek, entry_size[i])) return false; - if (!WriteEbmlElement(writer, libwebm::kMkvSeekID, - static_cast(seek_entry_id_[i]))) + if (!WriteEbmlElement(writer, kMkvSeekID, + static_cast(seek_entry_id_[i]))) return false; - if (!WriteEbmlElement(writer, libwebm::kMkvSeekPosition, - seek_entry_pos_[i])) + if (!WriteEbmlElement(writer, 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) + + const uint64 total_entry_size = kSeekEntryCount * MaxEntrySize(); + const uint64 total_size = + EbmlMasterElementSize(kMkvSeekHead, total_entry_size) + total_entry_size; - const int64_t size_left = total_size - (writer->Position() - start_pos_); + const int64 size_left = total_size - (writer->Position() - start_pos_); - const uint64_t bytes_written = WriteVoidElement(writer, size_left); + const uint64 bytes_written = WriteVoidElement(writer, size_left); if (!bytes_written) return false; @@ -2476,21 +2000,20 @@ bool SeekHead::Finalize(IMkvWriter* writer) const { } bool SeekHead::Write(IMkvWriter* writer) { - const uint64_t entry_size = kSeekEntryCount * MaxEntrySize(); - const uint64_t size = - EbmlMasterElementSize(libwebm::kMkvSeekHead, entry_size); + const uint64 entry_size = kSeekEntryCount * MaxEntrySize(); + const uint64 size = EbmlMasterElementSize(kMkvSeekHead, entry_size); start_pos_ = writer->Position(); - const uint64_t bytes_written = WriteVoidElement(writer, size + entry_size); + const uint64 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) { +bool SeekHead::AddSeekEntry(uint32 id, uint64 pos) { + for (int32 i = 0; i < kSeekEntryCount; ++i) { if (seek_entry_id_[i] == 0) { seek_entry_id_[i] = id; seek_entry_pos_[i] = pos; @@ -2500,19 +2023,19 @@ bool SeekHead::AddSeekEntry(uint32_t id, uint64_t pos) { return false; } -uint32_t SeekHead::GetId(int index) const { +uint32 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 { +uint64 SeekHead::GetPosition(int index) const { if (index < 0 || index >= kSeekEntryCount) return ULLONG_MAX; return seek_entry_pos_[index]; } -bool SeekHead::SetSeekEntry(int index, uint32_t id, uint64_t position) { +bool SeekHead::SetSeekEntry(int index, uint32 id, uint64 position) { if (index < 0 || index >= kSeekEntryCount) return false; seek_entry_id_[index] = id; @@ -2520,12 +2043,12 @@ bool SeekHead::SetSeekEntry(int index, uint32_t id, uint64_t 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) + +uint64 SeekHead::MaxEntrySize() const { + const uint64 max_entry_payload_size = + EbmlElementSize(kMkvSeekID, 0xffffffffULL) + + EbmlElementSize(kMkvSeekPosition, 0xffffffffffffffffULL); + const uint64 max_entry_size = + EbmlMasterElementSize(kMkvSeek, max_entry_payload_size) + max_entry_payload_size; return max_entry_size; @@ -2549,10 +2072,10 @@ SegmentInfo::~SegmentInfo() { } bool SegmentInfo::Init() { - int32_t major; - int32_t minor; - int32_t build; - int32_t revision; + int32 major; + int32 minor; + int32 build; + int32 revision; GetVersion(&major, &minor, &build, &revision); char temp[256]; #ifdef _MSC_VER @@ -2592,12 +2115,12 @@ bool SegmentInfo::Finalize(IMkvWriter* writer) const { if (duration_pos_ == -1) return false; - const int64_t pos = writer->Position(); + const int64 pos = writer->Position(); if (writer->Position(duration_pos_)) return false; - if (!WriteEbmlElement(writer, libwebm::kMkvDuration, + if (!WriteEbmlElement(writer, kMkvDuration, static_cast(duration_))) return false; @@ -2613,45 +2136,43 @@ bool SegmentInfo::Write(IMkvWriter* writer) { if (!writer || !muxing_app_ || !writing_app_) return false; - uint64_t size = EbmlElementSize(libwebm::kMkvTimecodeScale, timecode_scale_); + uint64 size = EbmlElementSize(kMkvTimecodeScale, timecode_scale_); if (duration_ > 0.0) - size += - EbmlElementSize(libwebm::kMkvDuration, static_cast(duration_)); + size += EbmlElementSize(kMkvDuration, static_cast(duration_)); if (date_utc_ != LLONG_MIN) - size += EbmlDateElementSize(libwebm::kMkvDateUTC); - size += EbmlElementSize(libwebm::kMkvMuxingApp, muxing_app_); - size += EbmlElementSize(libwebm::kMkvWritingApp, writing_app_); + size += EbmlDateElementSize(kMkvDateUTC); + size += EbmlElementSize(kMkvMuxingApp, muxing_app_); + size += EbmlElementSize(kMkvWritingApp, writing_app_); - if (!WriteEbmlMasterElement(writer, libwebm::kMkvInfo, size)) + if (!WriteEbmlMasterElement(writer, kMkvInfo, size)) return false; - const int64_t payload_position = writer->Position(); + const int64 payload_position = writer->Position(); if (payload_position < 0) return false; - if (!WriteEbmlElement(writer, libwebm::kMkvTimecodeScale, timecode_scale_)) + if (!WriteEbmlElement(writer, kMkvTimecodeScale, timecode_scale_)) return false; if (duration_ > 0.0) { // Save for later duration_pos_ = writer->Position(); - if (!WriteEbmlElement(writer, libwebm::kMkvDuration, - static_cast(duration_))) + if (!WriteEbmlElement(writer, kMkvDuration, static_cast(duration_))) return false; } if (date_utc_ != LLONG_MIN) - WriteEbmlDateElement(writer, libwebm::kMkvDateUTC, date_utc_); + WriteEbmlDateElement(writer, kMkvDateUTC, date_utc_); - if (!WriteEbmlElement(writer, libwebm::kMkvMuxingApp, muxing_app_)) + if (!WriteEbmlElement(writer, kMkvMuxingApp, muxing_app_)) return false; - if (!WriteEbmlElement(writer, libwebm::kMkvWritingApp, writing_app_)) + if (!WriteEbmlElement(writer, kMkvWritingApp, writing_app_)) return false; - const int64_t stop_position = writer->Position(); + const int64 stop_position = writer->Position(); if (stop_position < 0 || - stop_position - payload_position != static_cast(size)) + stop_position - payload_position != static_cast(size)) return false; return true; @@ -2723,8 +2244,6 @@ Segment::Segment() mode_(kFile), new_cuepoint_(false), output_cues_(true), - accurate_cluster_duration_(false), - fixed_size_cluster_timecode_(false), payload_pos_(0), size_position_(0), doc_type_version_(kDefaultDocTypeVersion), @@ -2741,7 +2260,7 @@ Segment::Segment() Segment::~Segment() { if (cluster_list_) { - for (int32_t i = 0; i < cluster_list_size_; ++i) { + for (int32 i = 0; i < cluster_list_size_; ++i) { Cluster* const cluster = cluster_list_[i]; delete cluster; } @@ -2749,7 +2268,7 @@ Segment::~Segment() { } if (frames_) { - for (int32_t i = 0; i < frames_size_; ++i) { + for (int32 i = 0; i < frames_size_; ++i) { Frame* const frame = frames_[i]; delete frame; } @@ -2773,13 +2292,13 @@ Segment::~Segment() { } } -void Segment::MoveCuesBeforeClustersHelper(uint64_t diff, int32_t index, - uint64_t* cues_size) { +void Segment::MoveCuesBeforeClustersHelper(uint64 diff, int32 index, + uint64* cues_size) { CuePoint* const cue_point = cues_.GetCueByIndex(index); if (cue_point == NULL) return; - const uint64_t old_cue_point_size = cue_point->Size(); - const uint64_t cluster_pos = cue_point->cluster_pos() + diff; + const uint64 old_cue_point_size = cue_point->Size(); + const uint64 cluster_pos = cue_point->cluster_pos() + diff; cue_point->set_cluster_pos(cluster_pos); // update the new cluster position // New size of the cue is computed as follows // Let a = current sum of size of all CuePoints @@ -2789,40 +2308,40 @@ void Segment::MoveCuesBeforeClustersHelper(uint64_t diff, int32_t index, // Let d = b + c. Now d is the |diff| passed to the next recursive call. // Let e = a + b. Now e is the |cues_size| passed to the next recursive // call. - const uint64_t cue_point_size_diff = cue_point->Size() - old_cue_point_size; - const uint64_t cue_size_diff = + const uint64 cue_point_size_diff = cue_point->Size() - old_cue_point_size; + const uint64 cue_size_diff = GetCodedUIntSize(*cues_size + cue_point_size_diff) - GetCodedUIntSize(*cues_size); *cues_size += cue_point_size_diff; diff = cue_size_diff + cue_point_size_diff; if (diff > 0) { - for (int32_t i = 0; i < cues_.cue_entries_size(); ++i) { + for (int32 i = 0; i < cues_.cue_entries_size(); ++i) { MoveCuesBeforeClustersHelper(diff, i, cues_size); } } } void Segment::MoveCuesBeforeClusters() { - const uint64_t current_cue_size = cues_.Size(); - uint64_t cue_size = 0; - for (int32_t i = 0; i < cues_.cue_entries_size(); ++i) + const uint64 current_cue_size = cues_.Size(); + uint64 cue_size = 0; + for (int32 i = 0; i < cues_.cue_entries_size(); ++i) cue_size += cues_.GetCueByIndex(i)->Size(); - for (int32_t i = 0; i < cues_.cue_entries_size(); ++i) + for (int32 i = 0; i < cues_.cue_entries_size(); ++i) MoveCuesBeforeClustersHelper(current_cue_size, i, &cue_size); // Adjust the Seek Entry to reflect the change in position // of Cluster and Cues - int32_t cluster_index = 0; - int32_t cues_index = 0; - for (int32_t i = 0; i < SeekHead::kSeekEntryCount; ++i) { - if (seek_head_.GetId(i) == libwebm::kMkvCluster) + int32 cluster_index = 0; + int32 cues_index = 0; + for (int32 i = 0; i < SeekHead::kSeekEntryCount; ++i) { + if (seek_head_.GetId(i) == kMkvCluster) cluster_index = i; - if (seek_head_.GetId(i) == libwebm::kMkvCues) + if (seek_head_.GetId(i) == kMkvCues) cues_index = i; } - seek_head_.SetSeekEntry(cues_index, libwebm::kMkvCues, + seek_head_.SetSeekEntry(cues_index, kMkvCues, seek_head_.GetPosition(cluster_index)); - seek_head_.SetSeekEntry(cluster_index, libwebm::kMkvCluster, + seek_head_.SetSeekEntry(cluster_index, kMkvCluster, cues_.Size() + seek_head_.GetPosition(cues_index)); } @@ -2840,8 +2359,8 @@ bool Segment::CopyAndMoveCuesBeforeClusters(mkvparser::IMkvReader* reader, IMkvWriter* writer) { if (!writer->Seekable() || chunking_) return false; - const int64_t cluster_offset = - cluster_list_[0]->size_position() - GetUIntSize(libwebm::kMkvCluster); + const int64 cluster_offset = + cluster_list_[0]->size_position() - GetUIntSize(kMkvCluster); // Copy the headers. if (!ChunkedCopy(reader, writer, 0, cluster_offset)) @@ -2864,8 +2383,8 @@ bool Segment::CopyAndMoveCuesBeforeClusters(mkvparser::IMkvReader* reader, return false; // Update the Segment size in case the Cues size has changed. - const int64_t pos = writer->Position(); - const int64_t segment_size = writer->Position() - payload_pos_; + const int64 pos = writer->Position(); + const int64 segment_size = writer->Position() - payload_pos_; if (writer->Position(size_position_) || WriteUIntSize(writer, segment_size, 8) || writer->Position(pos)) return false; @@ -2876,17 +2395,15 @@ bool Segment::Finalize() { if (WriteFramesAll() < 0) return false; - if (cluster_list_size_ > 0) { - // Update last cluster's size - Cluster* const old_cluster = cluster_list_[cluster_list_size_ - 1]; - - // For the last frame of the last Cluster, we don't write it as a BlockGroup - // with Duration unless the frame itself has duration set explicitly. - if (!old_cluster || !old_cluster->Finalize(false, 0)) - return false; - } - if (mode_ == kFile) { + if (cluster_list_size_ > 0) { + // Update last cluster's size + Cluster* const old_cluster = cluster_list_[cluster_list_size_ - 1]; + + if (!old_cluster || !old_cluster->Finalize()) + return false; + } + if (chunking_ && chunk_writer_cluster_) { chunk_writer_cluster_->Close(); chunk_count_++; @@ -2900,7 +2417,7 @@ bool Segment::Finalize() { return false; if (output_cues_) - if (!seek_head_.AddSeekEntry(libwebm::kMkvCues, MaxOffset())) + if (!seek_head_.AddSeekEntry(kMkvCues, MaxOffset())) return false; if (chunking_) { @@ -2931,11 +2448,11 @@ bool Segment::Finalize() { if (size_position_ == -1) return false; - const int64_t segment_size = MaxOffset(); + const int64 segment_size = MaxOffset(); if (segment_size < 1) return false; - const int64_t pos = writer_header_->Position(); + const int64 pos = writer_header_->Position(); UpdateDocTypeVersion(); if (doc_type_version_ != doc_type_version_written_) { if (writer_header_->Position(0)) @@ -2973,7 +2490,7 @@ bool Segment::Finalize() { return true; } -Track* Segment::AddTrack(int32_t number) { +Track* Segment::AddTrack(int32 number) { Track* const track = new (std::nothrow) Track(&seed_); // NOLINT if (!track) @@ -2991,7 +2508,7 @@ Chapter* Segment::AddChapter() { return chapters_.AddChapter(&seed_); } Tag* Segment::AddTag() { return tags_.AddTag(); } -uint64_t Segment::AddVideoTrack(int32_t width, int32_t height, int32_t number) { +uint64 Segment::AddVideoTrack(int32 width, int32 height, int32 number) { VideoTrack* const track = new (std::nothrow) VideoTrack(&seed_); // NOLINT if (!track) return 0; @@ -3007,7 +2524,7 @@ uint64_t Segment::AddVideoTrack(int32_t width, int32_t height, int32_t number) { return track->number(); } -bool Segment::AddCuePoint(uint64_t timestamp, uint64_t track) { +bool Segment::AddCuePoint(uint64 timestamp, uint64 track) { if (cluster_list_size_ < 1) return false; @@ -3030,8 +2547,7 @@ bool Segment::AddCuePoint(uint64_t timestamp, uint64_t track) { return true; } -uint64_t Segment::AddAudioTrack(int32_t sample_rate, int32_t channels, - int32_t number) { +uint64 Segment::AddAudioTrack(int32 sample_rate, int32 channels, int32 number) { AudioTrack* const track = new (std::nothrow) AudioTrack(&seed_); // NOLINT if (!track) return 0; @@ -3046,8 +2562,8 @@ uint64_t Segment::AddAudioTrack(int32_t sample_rate, int32_t channels, return track->number(); } -bool Segment::AddFrame(const uint8_t* data, uint64_t length, - uint64_t track_number, uint64_t timestamp, bool is_key) { +bool Segment::AddFrame(const uint8* data, uint64 length, uint64 track_number, + uint64 timestamp, bool is_key) { if (!data) return false; @@ -3060,11 +2576,11 @@ bool Segment::AddFrame(const uint8_t* data, uint64_t length, return AddGenericFrame(&frame); } -bool Segment::AddFrameWithAdditional(const uint8_t* data, uint64_t length, - const uint8_t* additional, - uint64_t additional_length, - uint64_t add_id, uint64_t track_number, - uint64_t timestamp, bool is_key) { +bool Segment::AddFrameWithAdditional(const uint8* data, uint64 length, + const uint8* additional, + uint64 additional_length, uint64 add_id, + uint64 track_number, uint64 timestamp, + bool is_key) { if (!data || !additional) return false; @@ -3079,10 +2595,10 @@ bool Segment::AddFrameWithAdditional(const uint8_t* data, uint64_t length, return AddGenericFrame(&frame); } -bool Segment::AddFrameWithDiscardPadding(const uint8_t* data, uint64_t length, - int64_t discard_padding, - uint64_t track_number, - uint64_t timestamp, bool is_key) { +bool Segment::AddFrameWithDiscardPadding(const uint8* data, uint64 length, + int64 discard_padding, + uint64 track_number, uint64 timestamp, + bool is_key) { if (!data) return false; @@ -3096,9 +2612,8 @@ bool Segment::AddFrameWithDiscardPadding(const uint8_t* data, uint64_t length, return AddGenericFrame(&frame); } -bool Segment::AddMetadata(const uint8_t* data, uint64_t length, - uint64_t track_number, uint64_t timestamp_ns, - uint64_t duration_ns) { +bool Segment::AddMetadata(const uint8* data, uint64 length, uint64 track_number, + uint64 timestamp_ns, uint64 duration_ns) { if (!data) return false; @@ -3187,14 +2702,6 @@ bool Segment::AddGenericFrame(const Frame* frame) { void Segment::OutputCues(bool output_cues) { output_cues_ = output_cues; } -void Segment::AccurateClusterDuration(bool accurate_cluster_duration) { - accurate_cluster_duration_ = accurate_cluster_duration; -} - -void Segment::UseFixedSizeClusterTimecode(bool fixed_size_cluster_timecode) { - fixed_size_cluster_timecode_ = fixed_size_cluster_timecode; -} - bool Segment::SetChunking(bool chunking, const char* filename) { if (chunk_count_ > 0) return false; @@ -3274,7 +2781,7 @@ bool Segment::SetChunking(bool chunking, const char* filename) { return true; } -bool Segment::CuesTrack(uint64_t track_number) { +bool Segment::CuesTrack(uint64 track_number) { const Track* const track = GetTrackByNumber(track_number); if (!track) return false; @@ -3285,7 +2792,7 @@ bool Segment::CuesTrack(uint64_t track_number) { void Segment::ForceNewClusterOnNextFrame() { force_new_cluster_ = true; } -Track* Segment::GetTrackByNumber(uint64_t track_number) const { +Track* Segment::GetTrackByNumber(uint64 track_number) const { return tracks_.GetTrackByNumber(track_number); } @@ -3296,11 +2803,11 @@ bool Segment::WriteSegmentHeader() { if (!WriteEbmlHeader(writer_header_, doc_type_version_)) return false; doc_type_version_written_ = doc_type_version_; - ebml_header_size_ = static_cast(writer_header_->Position()); + ebml_header_size_ = static_cast(writer_header_->Position()); // Write "unknown" (-1) as segment size value. If mode is kFile, Segment // will write over duration when the file is finalized. - if (WriteID(writer_header_, libwebm::kMkvSegment)) + if (WriteID(writer_header_, kMkvSegment)) return false; // Save for later. @@ -3324,25 +2831,25 @@ bool Segment::WriteSegmentHeader() { return false; } - if (!seek_head_.AddSeekEntry(libwebm::kMkvInfo, MaxOffset())) + if (!seek_head_.AddSeekEntry(kMkvInfo, MaxOffset())) return false; if (!segment_info_.Write(writer_header_)) return false; - if (!seek_head_.AddSeekEntry(libwebm::kMkvTracks, MaxOffset())) + if (!seek_head_.AddSeekEntry(kMkvTracks, MaxOffset())) return false; if (!tracks_.Write(writer_header_)) return false; if (chapters_.Count() > 0) { - if (!seek_head_.AddSeekEntry(libwebm::kMkvChapters, MaxOffset())) + if (!seek_head_.AddSeekEntry(kMkvChapters, MaxOffset())) return false; if (!chapters_.Write(writer_header_)) return false; } if (tags_.Count() > 0) { - if (!seek_head_.AddSeekEntry(libwebm::kMkvTags, MaxOffset())) + if (!seek_head_.AddSeekEntry(kMkvTags, MaxOffset())) return false; if (!tags_.Write(writer_header_)) return false; @@ -3363,7 +2870,7 @@ bool Segment::WriteSegmentHeader() { // Here we are testing whether to create a new cluster, given a frame // having time frame_timestamp_ns. // -int Segment::TestFrame(uint64_t track_number, uint64_t frame_timestamp_ns, +int Segment::TestFrame(uint64 track_number, uint64 frame_timestamp_ns, bool is_key) const { if (force_new_cluster_) return 1; @@ -3381,11 +2888,11 @@ int Segment::TestFrame(uint64_t track_number, uint64_t frame_timestamp_ns, // written to the existing cluster, or that a new cluster should be // created. - const uint64_t timecode_scale = segment_info_.timecode_scale(); - const uint64_t frame_timecode = frame_timestamp_ns / timecode_scale; + const uint64 timecode_scale = segment_info_.timecode_scale(); + const uint64 frame_timecode = frame_timestamp_ns / timecode_scale; const Cluster* const last_cluster = cluster_list_[cluster_list_size_ - 1]; - const uint64_t last_cluster_timecode = last_cluster->timecode(); + const uint64 last_cluster_timecode = last_cluster->timecode(); // For completeness we test for the case when the frame's timecode // is less than the cluster's timecode. Although in principle that @@ -3400,7 +2907,7 @@ int Segment::TestFrame(uint64_t track_number, uint64_t frame_timestamp_ns, // using a 16-bit signed integer), then we cannot write this frame // to that cluster, and so we must create a new cluster. - const int64_t delta_timecode = frame_timecode - last_cluster_timecode; + const int64 delta_timecode = frame_timecode - last_cluster_timecode; if (delta_timecode > kMaxBlockTimecode) return 2; @@ -3416,7 +2923,7 @@ int Segment::TestFrame(uint64_t track_number, uint64_t frame_timestamp_ns, // already, where "too many" is defined as "the total time of frames // in the cluster exceeds a threshold". - const uint64_t delta_ns = delta_timecode * timecode_scale; + const uint64 delta_ns = delta_timecode * timecode_scale; if (max_cluster_duration_ > 0 && delta_ns >= max_cluster_duration_) return 1; @@ -3425,7 +2932,7 @@ int Segment::TestFrame(uint64_t track_number, uint64_t frame_timestamp_ns, // cluster is created when the size of the current cluster exceeds a // threshold. - const uint64_t cluster_size = last_cluster->payload_size(); + const uint64 cluster_size = last_cluster->payload_size(); if (max_cluster_size_ > 0 && cluster_size >= max_cluster_size_) return 1; @@ -3435,19 +2942,19 @@ int Segment::TestFrame(uint64_t track_number, uint64_t frame_timestamp_ns, return 0; } -bool Segment::MakeNewCluster(uint64_t frame_timestamp_ns) { - const int32_t new_size = cluster_list_size_ + 1; +bool Segment::MakeNewCluster(uint64 frame_timestamp_ns) { + const int32 new_size = cluster_list_size_ + 1; if (new_size > cluster_list_capacity_) { // Add more clusters. - const int32_t new_capacity = + const int32 new_capacity = (cluster_list_capacity_ <= 0) ? 1 : cluster_list_capacity_ * 2; Cluster** const clusters = new (std::nothrow) Cluster*[new_capacity]; // NOLINT if (!clusters) return false; - for (int32_t i = 0; i < cluster_list_size_; ++i) { + for (int32 i = 0; i < cluster_list_size_; ++i) { clusters[i] = cluster_list_[i]; } @@ -3460,17 +2967,19 @@ bool Segment::MakeNewCluster(uint64_t frame_timestamp_ns) { if (!WriteFramesLessThan(frame_timestamp_ns)) return false; - if (cluster_list_size_ > 0) { - // Update old cluster's size - Cluster* const old_cluster = cluster_list_[cluster_list_size_ - 1]; + if (mode_ == kFile) { + if (cluster_list_size_ > 0) { + // Update old cluster's size + Cluster* const old_cluster = cluster_list_[cluster_list_size_ - 1]; - if (!old_cluster || !old_cluster->Finalize(true, frame_timestamp_ns)) - return false; + if (!old_cluster || !old_cluster->Finalize()) + return false; + } + + if (output_cues_) + new_cuepoint_ = true; } - if (output_cues_) - new_cuepoint_ = true; - if (chunking_ && cluster_list_size_ > 0) { chunk_writer_cluster_->Close(); chunk_count_++; @@ -3481,25 +2990,24 @@ bool Segment::MakeNewCluster(uint64_t frame_timestamp_ns) { return false; } - const uint64_t timecode_scale = segment_info_.timecode_scale(); - const uint64_t frame_timecode = frame_timestamp_ns / timecode_scale; + const uint64 timecode_scale = segment_info_.timecode_scale(); + const uint64 frame_timecode = frame_timestamp_ns / timecode_scale; - uint64_t cluster_timecode = frame_timecode; + uint64 cluster_timecode = frame_timecode; if (frames_size_ > 0) { const Frame* const f = frames_[0]; // earliest queued frame - const uint64_t ns = f->timestamp(); - const uint64_t tc = ns / timecode_scale; + const uint64 ns = f->timestamp(); + const uint64 tc = ns / timecode_scale; if (tc < cluster_timecode) cluster_timecode = tc; } Cluster*& cluster = cluster_list_[cluster_list_size_]; - const int64_t offset = MaxOffset(); - cluster = new (std::nothrow) - Cluster(cluster_timecode, offset, segment_info_.timecode_scale(), - accurate_cluster_duration_, fixed_size_cluster_timecode_); + const int64 offset = MaxOffset(); + cluster = new (std::nothrow) Cluster(cluster_timecode, // NOLINT + offset, segment_info_.timecode_scale()); if (!cluster) return false; @@ -3510,8 +3018,8 @@ bool Segment::MakeNewCluster(uint64_t frame_timestamp_ns) { return true; } -bool Segment::DoNewClusterProcessing(uint64_t track_number, - uint64_t frame_timestamp_ns, bool is_key) { +bool Segment::DoNewClusterProcessing(uint64 track_number, + uint64 frame_timestamp_ns, bool is_key) { for (;;) { // Based on the characteristics of the current frame and current // cluster, decide whether to create a new cluster. @@ -3547,12 +3055,12 @@ bool Segment::CheckHeaderInfo() { if (!WriteSegmentHeader()) return false; - if (!seek_head_.AddSeekEntry(libwebm::kMkvCluster, MaxOffset())) + if (!seek_head_.AddSeekEntry(kMkvCluster, MaxOffset())) return false; if (output_cues_ && cues_track_ == 0) { // Check for a video track - for (uint32_t i = 0; i < tracks_.track_entries_size(); ++i) { + for (uint32 i = 0; i < tracks_.track_entries_size(); ++i) { const Track* const track = tracks_.GetTrackByIndex(i); if (!track) return false; @@ -3577,7 +3085,7 @@ bool Segment::CheckHeaderInfo() { } void Segment::UpdateDocTypeVersion() { - for (uint32_t index = 0; index < tracks_.track_entries_size(); ++index) { + for (uint32 index = 0; index < tracks_.track_entries_size(); ++index) { const Track* track = tracks_.GetTrackByIndex(index); if (track == NULL) break; @@ -3619,14 +3127,14 @@ bool Segment::UpdateChunkName(const char* ext, char** name) const { return true; } -int64_t Segment::MaxOffset() { +int64 Segment::MaxOffset() { if (!writer_header_) return -1; - int64_t offset = writer_header_->Position() - payload_pos_; + int64 offset = writer_header_->Position() - payload_pos_; if (chunking_) { - for (int32_t i = 0; i < cluster_list_size_; ++i) { + for (int32 i = 0; i < cluster_list_size_; ++i) { Cluster* const cluster = cluster_list_[i]; offset += cluster->Size(); } @@ -3639,11 +3147,11 @@ int64_t Segment::MaxOffset() { } bool Segment::QueueFrame(Frame* frame) { - const int32_t new_size = frames_size_ + 1; + const int32 new_size = frames_size_ + 1; if (new_size > frames_capacity_) { // Add more frames. - const int32_t new_capacity = (!frames_capacity_) ? 2 : frames_capacity_ * 2; + const int32 new_capacity = (!frames_capacity_) ? 2 : frames_capacity_ * 2; if (new_capacity < 1) return false; @@ -3652,7 +3160,7 @@ bool Segment::QueueFrame(Frame* frame) { if (!frames) return false; - for (int32_t i = 0; i < frames_size_; ++i) { + for (int32 i = 0; i < frames_size_; ++i) { frames[i] = frames_[i]; } @@ -3678,7 +3186,7 @@ int Segment::WriteFramesAll() { if (!cluster) return -1; - for (int32_t i = 0; i < frames_size_; ++i) { + for (int32 i = 0; i < frames_size_; ++i) { Frame*& frame = frames_[i]; // TODO(jzern/vigneshv): using Segment::AddGenericFrame here would limit the // places where |doc_type_version_| needs to be updated. @@ -3707,7 +3215,7 @@ int Segment::WriteFramesAll() { return result; } -bool Segment::WriteFramesLessThan(uint64_t timestamp) { +bool Segment::WriteFramesLessThan(uint64 timestamp) { // Check |cluster_list_size_| to see if this is the first cluster. If it is // the first cluster the audio frames that are less than the first video // timesatmp will be written in a later step. @@ -3719,11 +3227,11 @@ bool Segment::WriteFramesLessThan(uint64_t timestamp) { if (!cluster) return false; - int32_t shift_left = 0; + int32 shift_left = 0; // TODO(fgalligan): Change this to use the durations of frames instead of // the next frame's start time if the duration is accurate. - for (int32_t i = 1; i < frames_size_; ++i) { + for (int32 i = 1; i < frames_size_; ++i) { const Frame* const frame_curr = frames_[i]; if (frame_curr->timestamp() > timestamp) @@ -3754,8 +3262,8 @@ bool Segment::WriteFramesLessThan(uint64_t timestamp) { if (shift_left >= frames_size_) return false; - const int32_t new_frames_size = frames_size_ - shift_left; - for (int32_t i = 0; i < new_frames_size; ++i) { + const int32 new_frames_size = frames_size_ - shift_left; + for (int32 i = 0; i < new_frames_size; ++i) { frames_[i] = frames_[i + shift_left]; } diff --git a/third_party/libwebm/mkvmuxer/mkvmuxer.h b/third_party/libwebm/mkvmuxer.hpp similarity index 68% rename from third_party/libwebm/mkvmuxer/mkvmuxer.h rename to third_party/libwebm/mkvmuxer.hpp index 1559d56a3..03a002c93 100644 --- a/third_party/libwebm/mkvmuxer/mkvmuxer.h +++ b/third_party/libwebm/mkvmuxer.hpp @@ -6,45 +6,38 @@ // in the file PATENTS. All contributing project authors may // be found in the AUTHORS file in the root of the source tree. -#ifndef MKVMUXER_MKVMUXER_H_ -#define MKVMUXER_MKVMUXER_H_ +#ifndef MKVMUXER_HPP +#define MKVMUXER_HPP -#include - -#include -#include -#include - -#include "common/webmids.h" -#include "mkvmuxer/mkvmuxertypes.h" +#include "mkvmuxertypes.hpp" // For a description of the WebM elements see // http://www.webmproject.org/code/specs/container/. namespace mkvparser { class IMkvReader; -} // namespace mkvparser +} // end namespace namespace mkvmuxer { class MkvWriter; class Segment; -const uint64_t kMaxTrackNumber = 126; +const uint64 kMaxTrackNumber = 126; /////////////////////////////////////////////////////////////// // Interface used by the mkvmuxer to write out the Mkv data. class IMkvWriter { public: // Writes out |len| bytes of |buf|. Returns 0 on success. - virtual int32_t Write(const void* buf, uint32_t len) = 0; + virtual int32 Write(const void* buf, uint32 len) = 0; // Returns the offset of the output position from the beginning of the // output. - virtual int64_t Position() const = 0; + virtual int64 Position() const = 0; // Set the current File position. Returns 0 on success. - virtual int32_t Position(int64_t position) = 0; + virtual int32 Position(int64 position) = 0; // Returns true if the writer is seekable. virtual bool Seekable() const = 0; @@ -54,7 +47,7 @@ class IMkvWriter { // |position| is the location in the WebM stream where the first octet of the // element identifier will be written. // Note: the |MkvId| enumeration in webmids.hpp defines element values. - virtual void ElementStartNotify(uint64_t element_id, int64_t position) = 0; + virtual void ElementStartNotify(uint64 element_id, int64 position) = 0; protected: IMkvWriter(); @@ -66,15 +59,15 @@ class IMkvWriter { // Writes out the EBML header for a WebM file. This function must be called // before any other libwebm writing functions are called. -bool WriteEbmlHeader(IMkvWriter* writer, uint64_t doc_type_version); +bool WriteEbmlHeader(IMkvWriter* writer, uint64 doc_type_version); // Deprecated. Writes out EBML header with doc_type_version as // kDefaultDocTypeVersion. Exists for backward compatibility. bool WriteEbmlHeader(IMkvWriter* writer); // Copies in Chunk from source to destination between the given byte positions -bool ChunkedCopy(mkvparser::IMkvReader* source, IMkvWriter* dst, int64_t start, - int64_t size); +bool ChunkedCopy(mkvparser::IMkvReader* source, IMkvWriter* dst, int64 start, + int64 size); /////////////////////////////////////////////////////////////// // Class to hold data the will be written to a block. @@ -88,11 +81,10 @@ class Frame { bool CopyFrom(const Frame& frame); // Copies |frame| data into |frame_|. Returns true on success. - bool Init(const uint8_t* frame, uint64_t length); + bool Init(const uint8* frame, uint64 length); // Copies |additional| data into |additional_|. Returns true on success. - bool AddAdditionalData(const uint8_t* additional, uint64_t length, - uint64_t add_id); + bool AddAdditionalData(const uint8* additional, uint64 length, uint64 add_id); // Returns true if the frame has valid parameters. bool IsValid() const; @@ -101,70 +93,62 @@ class Frame { // parameters. bool CanBeSimpleBlock() const; - uint64_t add_id() const { return add_id_; } - const uint8_t* additional() const { return additional_; } - uint64_t additional_length() const { return additional_length_; } - void set_duration(uint64_t duration); - uint64_t duration() const { return duration_; } - bool duration_set() const { return duration_set_; } - const uint8_t* frame() const { return frame_; } + uint64 add_id() const { return add_id_; } + const uint8* additional() const { return additional_; } + uint64 additional_length() const { return additional_length_; } + void set_duration(uint64 duration) { duration_ = duration; } + uint64 duration() const { return duration_; } + const uint8* frame() const { return frame_; } void set_is_key(bool key) { is_key_ = key; } bool is_key() const { return is_key_; } - uint64_t length() const { return length_; } - void set_track_number(uint64_t track_number) { track_number_ = track_number; } - uint64_t track_number() const { return track_number_; } - void set_timestamp(uint64_t timestamp) { timestamp_ = timestamp; } - uint64_t timestamp() const { return timestamp_; } - void set_discard_padding(int64_t discard_padding) { + uint64 length() const { return length_; } + void set_track_number(uint64 track_number) { track_number_ = track_number; } + uint64 track_number() const { return track_number_; } + void set_timestamp(uint64 timestamp) { timestamp_ = timestamp; } + uint64 timestamp() const { return timestamp_; } + void set_discard_padding(int64 discard_padding) { discard_padding_ = discard_padding; } - int64_t discard_padding() const { return discard_padding_; } - void set_reference_block_timestamp(int64_t reference_block_timestamp); - int64_t reference_block_timestamp() const { - return reference_block_timestamp_; - } + int64 discard_padding() const { return discard_padding_; } + void set_reference_block_timestamp(int64 reference_block_timestamp); + int64 reference_block_timestamp() const { return reference_block_timestamp_; } bool reference_block_timestamp_set() const { return reference_block_timestamp_set_; } private: // Id of the Additional data. - uint64_t add_id_; + uint64 add_id_; // Pointer to additional data. Owned by this class. - uint8_t* additional_; + uint8* additional_; // Length of the additional data. - uint64_t additional_length_; + uint64 additional_length_; // Duration of the frame in nanoseconds. - uint64_t duration_; - - // Flag indicating that |duration_| has been set. Setting duration causes the - // frame to be written out as a Block with BlockDuration instead of as a - // SimpleBlock. - bool duration_set_; + uint64 duration_; // Pointer to the data. Owned by this class. - uint8_t* frame_; + uint8* frame_; // Flag telling if the data should set the key flag of a block. bool is_key_; // Length of the data. - uint64_t length_; + uint64 length_; // Mkv track number the data is associated with. - uint64_t track_number_; + uint64 track_number_; // Timestamp of the data in nanoseconds. - uint64_t timestamp_; + uint64 timestamp_; // Discard padding for the frame. - int64_t discard_padding_; + int64 discard_padding_; // Reference block timestamp. - int64_t reference_block_timestamp_; + int64 reference_block_timestamp_; // Flag indicating if |reference_block_timestamp_| has been set. bool reference_block_timestamp_set_; @@ -180,19 +164,19 @@ class CuePoint { ~CuePoint(); // Returns the size in bytes for the entire CuePoint element. - uint64_t Size() const; + uint64 Size() const; // Output the CuePoint element to the writer. Returns true on success. bool Write(IMkvWriter* writer) const; - void set_time(uint64_t time) { time_ = time; } - uint64_t time() const { return time_; } - void set_track(uint64_t track) { track_ = track; } - uint64_t track() const { return track_; } - void set_cluster_pos(uint64_t cluster_pos) { cluster_pos_ = cluster_pos; } - uint64_t cluster_pos() const { return cluster_pos_; } - void set_block_number(uint64_t block_number) { block_number_ = block_number; } - uint64_t block_number() const { return block_number_; } + void set_time(uint64 time) { time_ = time; } + uint64 time() const { return time_; } + void set_track(uint64 track) { track_ = track; } + uint64 track() const { return track_; } + void set_cluster_pos(uint64 cluster_pos) { cluster_pos_ = cluster_pos; } + uint64 cluster_pos() const { return cluster_pos_; } + void set_block_number(uint64 block_number) { block_number_ = block_number; } + uint64 block_number() const { return block_number_; } void set_output_block_number(bool output_block_number) { output_block_number_ = output_block_number; } @@ -200,19 +184,19 @@ class CuePoint { private: // Returns the size in bytes for the payload of the CuePoint element. - uint64_t PayloadSize() const; + uint64 PayloadSize() const; // Absolute timecode according to the segment time base. - uint64_t time_; + uint64 time_; // The Track element associated with the CuePoint. - uint64_t track_; + uint64 track_; // The position of the Cluster containing the Block. - uint64_t cluster_pos_; + uint64 cluster_pos_; // Number of the Block within the Cluster, starting from 1. - uint64_t block_number_; + uint64 block_number_; // If true the muxer will write out the block number for the cue if the // block number is different than the default of 1. Default is set to true. @@ -233,15 +217,15 @@ class Cues { // Returns the cue point by index. Returns NULL if there is no cue point // match. - CuePoint* GetCueByIndex(int32_t index) const; + CuePoint* GetCueByIndex(int32 index) const; // Returns the total size of the Cues element - uint64_t Size(); + uint64 Size(); // Output the Cues element to the writer. Returns true on success. bool Write(IMkvWriter* writer) const; - int32_t cue_entries_size() const { return cue_entries_size_; } + int32 cue_entries_size() const { return cue_entries_size_; } void set_output_block_number(bool output_block_number) { output_block_number_ = output_block_number; } @@ -249,10 +233,10 @@ class Cues { private: // Number of allocated elements in |cue_entries_|. - int32_t cue_entries_capacity_; + int32 cue_entries_capacity_; // Number of CuePoints in |cue_entries_|. - int32_t cue_entries_size_; + int32 cue_entries_size_; // CuePoint list. CuePoint** cue_entries_; @@ -274,21 +258,21 @@ class ContentEncAESSettings { ~ContentEncAESSettings() {} // Returns the size in bytes for the ContentEncAESSettings element. - uint64_t Size() const; + uint64 Size() const; // Writes out the ContentEncAESSettings element to |writer|. Returns true on // success. bool Write(IMkvWriter* writer) const; - uint64_t cipher_mode() const { return cipher_mode_; } + uint64 cipher_mode() const { return cipher_mode_; } private: // Returns the size in bytes for the payload of the ContentEncAESSettings // element. - uint64_t PayloadSize() const; + uint64 PayloadSize() const; // Sub elements - uint64_t cipher_mode_; + uint64 cipher_mode_; LIBWEBM_DISALLOW_COPY_AND_ASSIGN(ContentEncAESSettings); }; @@ -307,157 +291,44 @@ class ContentEncoding { // Sets the content encryption id. Copies |length| bytes from |id| to // |enc_key_id_|. Returns true on success. - bool SetEncryptionID(const uint8_t* id, uint64_t length); + bool SetEncryptionID(const uint8* id, uint64 length); // Returns the size in bytes for the ContentEncoding element. - uint64_t Size() const; + uint64 Size() const; // Writes out the ContentEncoding element to |writer|. Returns true on // success. bool Write(IMkvWriter* writer) const; - uint64_t enc_algo() const { return enc_algo_; } - uint64_t encoding_order() const { return encoding_order_; } - uint64_t encoding_scope() const { return encoding_scope_; } - uint64_t encoding_type() const { return encoding_type_; } + uint64 enc_algo() const { return enc_algo_; } + uint64 encoding_order() const { return encoding_order_; } + uint64 encoding_scope() const { return encoding_scope_; } + uint64 encoding_type() const { return encoding_type_; } ContentEncAESSettings* enc_aes_settings() { return &enc_aes_settings_; } private: // Returns the size in bytes for the encoding elements. - uint64_t EncodingSize(uint64_t compresion_size, - uint64_t encryption_size) const; + uint64 EncodingSize(uint64 compresion_size, uint64 encryption_size) const; // Returns the size in bytes for the encryption elements. - uint64_t EncryptionSize() const; + uint64 EncryptionSize() const; // Track element names - uint64_t enc_algo_; - uint8_t* enc_key_id_; - uint64_t encoding_order_; - uint64_t encoding_scope_; - uint64_t encoding_type_; + uint64 enc_algo_; + uint8* enc_key_id_; + uint64 encoding_order_; + uint64 encoding_scope_; + uint64 encoding_type_; // ContentEncAESSettings element. ContentEncAESSettings enc_aes_settings_; // Size of the ContentEncKeyID data in bytes. - uint64_t enc_key_id_length_; + uint64 enc_key_id_length_; LIBWEBM_DISALLOW_COPY_AND_ASSIGN(ContentEncoding); }; -/////////////////////////////////////////////////////////////// -// Colour element. -struct PrimaryChromaticity { - PrimaryChromaticity(float x_val, float y_val) : x(x_val), y(y_val) {} - PrimaryChromaticity() : x(0), y(0) {} - ~PrimaryChromaticity() {} - uint64_t PrimaryChromaticityPayloadSize(libwebm::MkvId x_id, - libwebm::MkvId y_id) const; - bool Write(IMkvWriter* writer, libwebm::MkvId x_id, - libwebm::MkvId y_id) const; - - float x; - float y; -}; - -class MasteringMetadata { - public: - static const float kValueNotPresent; - - MasteringMetadata() - : luminance_max(kValueNotPresent), - luminance_min(kValueNotPresent), - r_(NULL), - g_(NULL), - b_(NULL), - white_point_(NULL) {} - ~MasteringMetadata() { - delete r_; - delete g_; - delete b_; - delete white_point_; - } - - // Returns total size of the MasteringMetadata element. - uint64_t MasteringMetadataSize() const; - bool Write(IMkvWriter* writer) const; - - // Copies non-null chromaticity. - bool SetChromaticity(const PrimaryChromaticity* r, - const PrimaryChromaticity* g, - const PrimaryChromaticity* b, - const PrimaryChromaticity* white_point); - const PrimaryChromaticity* r() const { return r_; } - const PrimaryChromaticity* g() const { return g_; } - const PrimaryChromaticity* b() const { return b_; } - const PrimaryChromaticity* white_point() const { return white_point_; } - - float luminance_max; - float luminance_min; - - private: - // Returns size of MasteringMetadata child elements. - uint64_t PayloadSize() const; - - PrimaryChromaticity* r_; - PrimaryChromaticity* g_; - PrimaryChromaticity* b_; - PrimaryChromaticity* white_point_; -}; - -class Colour { - public: - static const uint64_t kValueNotPresent; - Colour() - : matrix_coefficients(kValueNotPresent), - bits_per_channel(kValueNotPresent), - chroma_subsampling_horz(kValueNotPresent), - chroma_subsampling_vert(kValueNotPresent), - cb_subsampling_horz(kValueNotPresent), - cb_subsampling_vert(kValueNotPresent), - chroma_siting_horz(kValueNotPresent), - chroma_siting_vert(kValueNotPresent), - range(kValueNotPresent), - transfer_characteristics(kValueNotPresent), - primaries(kValueNotPresent), - max_cll(kValueNotPresent), - max_fall(kValueNotPresent), - mastering_metadata_(NULL) {} - ~Colour() { delete mastering_metadata_; } - - // Returns total size of the Colour element. - uint64_t ColourSize() const; - bool Write(IMkvWriter* writer) const; - - // Deep copies |mastering_metadata|. - bool SetMasteringMetadata(const MasteringMetadata& mastering_metadata); - - const MasteringMetadata* mastering_metadata() const { - return mastering_metadata_; - } - - uint64_t matrix_coefficients; - uint64_t bits_per_channel; - uint64_t chroma_subsampling_horz; - uint64_t chroma_subsampling_vert; - uint64_t cb_subsampling_horz; - uint64_t cb_subsampling_vert; - uint64_t chroma_siting_horz; - uint64_t chroma_siting_vert; - uint64_t range; - uint64_t transfer_characteristics; - uint64_t primaries; - uint64_t max_cll; - uint64_t max_fall; - - private: - // Returns size of Colour child elements. - uint64_t PayloadSize() const; - - MasteringMetadata* mastering_metadata_; -}; - /////////////////////////////////////////////////////////////// // Track element. class Track { @@ -471,76 +342,76 @@ class Track { // Returns the ContentEncoding by index. Returns NULL if there is no // ContentEncoding match. - ContentEncoding* GetContentEncodingByIndex(uint32_t index) const; + ContentEncoding* GetContentEncodingByIndex(uint32 index) const; // Returns the size in bytes for the payload of the Track element. - virtual uint64_t PayloadSize() const; + virtual uint64 PayloadSize() const; // Returns the size in bytes of the Track element. - virtual uint64_t Size() const; + virtual uint64 Size() const; // Output the Track element to the writer. Returns true on success. virtual bool Write(IMkvWriter* writer) const; // Sets the CodecPrivate element of the Track element. Copies |length| // bytes from |codec_private| to |codec_private_|. Returns true on success. - bool SetCodecPrivate(const uint8_t* codec_private, uint64_t length); + bool SetCodecPrivate(const uint8* codec_private, uint64 length); void set_codec_id(const char* codec_id); const char* codec_id() const { return codec_id_; } - const uint8_t* codec_private() const { return codec_private_; } + const uint8* codec_private() const { return codec_private_; } void set_language(const char* language); const char* language() const { return language_; } - void set_max_block_additional_id(uint64_t max_block_additional_id) { + void set_max_block_additional_id(uint64 max_block_additional_id) { max_block_additional_id_ = max_block_additional_id; } - uint64_t max_block_additional_id() const { return max_block_additional_id_; } + uint64 max_block_additional_id() const { return max_block_additional_id_; } void set_name(const char* name); const char* name() const { return name_; } - void set_number(uint64_t number) { number_ = number; } - uint64_t number() const { return number_; } - void set_type(uint64_t type) { type_ = type; } - uint64_t type() const { return type_; } - void set_uid(uint64_t uid) { uid_ = uid; } - uint64_t uid() const { return uid_; } - void set_codec_delay(uint64_t codec_delay) { codec_delay_ = codec_delay; } - uint64_t codec_delay() const { return codec_delay_; } - void set_seek_pre_roll(uint64_t seek_pre_roll) { + void set_number(uint64 number) { number_ = number; } + uint64 number() const { return number_; } + void set_type(uint64 type) { type_ = type; } + uint64 type() const { return type_; } + void set_uid(uint64 uid) { uid_ = uid; } + uint64 uid() const { return uid_; } + void set_codec_delay(uint64 codec_delay) { codec_delay_ = codec_delay; } + uint64 codec_delay() const { return codec_delay_; } + void set_seek_pre_roll(uint64 seek_pre_roll) { seek_pre_roll_ = seek_pre_roll; } - uint64_t seek_pre_roll() const { return seek_pre_roll_; } - void set_default_duration(uint64_t default_duration) { + uint64 seek_pre_roll() const { return seek_pre_roll_; } + void set_default_duration(uint64 default_duration) { default_duration_ = default_duration; } - uint64_t default_duration() const { return default_duration_; } + uint64 default_duration() const { return default_duration_; } - uint64_t codec_private_length() const { return codec_private_length_; } - uint32_t content_encoding_entries_size() const { + uint64 codec_private_length() const { return codec_private_length_; } + uint32 content_encoding_entries_size() const { return content_encoding_entries_size_; } private: // Track element names. char* codec_id_; - uint8_t* codec_private_; + uint8* codec_private_; char* language_; - uint64_t max_block_additional_id_; + uint64 max_block_additional_id_; char* name_; - uint64_t number_; - uint64_t type_; - uint64_t uid_; - uint64_t codec_delay_; - uint64_t seek_pre_roll_; - uint64_t default_duration_; + uint64 number_; + uint64 type_; + uint64 uid_; + uint64 codec_delay_; + uint64 seek_pre_roll_; + uint64 default_duration_; // Size of the CodecPrivate data in bytes. - uint64_t codec_private_length_; + uint64 codec_private_length_; // ContentEncoding element list. ContentEncoding** content_encoding_entries_; // Number of ContentEncoding elements added. - uint32_t content_encoding_entries_size_; + uint32 content_encoding_entries_size_; LIBWEBM_DISALLOW_COPY_AND_ASSIGN(Track); }; @@ -566,63 +437,56 @@ class VideoTrack : public Track { // Returns the size in bytes for the payload of the Track element plus the // video specific elements. - virtual uint64_t PayloadSize() const; + virtual uint64 PayloadSize() const; // Output the VideoTrack element to the writer. Returns true on success. virtual bool Write(IMkvWriter* writer) const; // Sets the video's stereo mode. Returns true on success. - bool SetStereoMode(uint64_t stereo_mode); + bool SetStereoMode(uint64 stereo_mode); // Sets the video's alpha mode. Returns true on success. - bool SetAlphaMode(uint64_t alpha_mode); + bool SetAlphaMode(uint64 alpha_mode); - void set_display_height(uint64_t height) { display_height_ = height; } - uint64_t display_height() const { return display_height_; } - void set_display_width(uint64_t width) { display_width_ = width; } - uint64_t display_width() const { return display_width_; } + void set_display_height(uint64 height) { display_height_ = height; } + uint64 display_height() const { return display_height_; } + void set_display_width(uint64 width) { display_width_ = width; } + uint64 display_width() const { return display_width_; } - void set_crop_left(uint64_t crop_left) { crop_left_ = crop_left; } - uint64_t crop_left() const { return crop_left_; } - void set_crop_right(uint64_t crop_right) { crop_right_ = crop_right; } - uint64_t crop_right() const { return crop_right_; } - void set_crop_top(uint64_t crop_top) { crop_top_ = crop_top; } - uint64_t crop_top() const { return crop_top_; } - void set_crop_bottom(uint64_t crop_bottom) { crop_bottom_ = crop_bottom; } - uint64_t crop_bottom() const { return crop_bottom_; } + void set_crop_left(uint64 crop_left) { crop_left_ = crop_left; } + uint64 crop_left() const { return crop_left_; } + void set_crop_right(uint64 crop_right) { crop_right_ = crop_right; } + uint64 crop_right() const { return crop_right_; } + void set_crop_top(uint64 crop_top) { crop_top_ = crop_top; } + uint64 crop_top() const { return crop_top_; } + void set_crop_bottom(uint64 crop_bottom) { crop_bottom_ = crop_bottom; } + uint64 crop_bottom() const { return crop_bottom_; } void set_frame_rate(double frame_rate) { frame_rate_ = frame_rate; } double frame_rate() const { return frame_rate_; } - void set_height(uint64_t height) { height_ = height; } - uint64_t height() const { return height_; } - uint64_t stereo_mode() { return stereo_mode_; } - uint64_t alpha_mode() { return alpha_mode_; } - void set_width(uint64_t width) { width_ = width; } - uint64_t width() const { return width_; } - - Colour* colour() { return colour_; } - - // Deep copies |colour|. - bool SetColour(const Colour& colour); + void set_height(uint64 height) { height_ = height; } + uint64 height() const { return height_; } + uint64 stereo_mode() { return stereo_mode_; } + uint64 alpha_mode() { return alpha_mode_; } + void set_width(uint64 width) { width_ = width; } + uint64 width() const { return width_; } private: // Returns the size in bytes of the Video element. - uint64_t VideoPayloadSize() const; + uint64 VideoPayloadSize() const; // Video track element names. - uint64_t display_height_; - uint64_t display_width_; - uint64_t crop_left_; - uint64_t crop_right_; - uint64_t crop_top_; - uint64_t crop_bottom_; + uint64 display_height_; + uint64 display_width_; + uint64 crop_left_; + uint64 crop_right_; + uint64 crop_top_; + uint64 crop_bottom_; double frame_rate_; - uint64_t height_; - uint64_t stereo_mode_; - uint64_t alpha_mode_; - uint64_t width_; - - Colour* colour_; + uint64 height_; + uint64 stereo_mode_; + uint64 alpha_mode_; + uint64 width_; LIBWEBM_DISALLOW_COPY_AND_ASSIGN(VideoTrack); }; @@ -637,22 +501,22 @@ class AudioTrack : public Track { // Returns the size in bytes for the payload of the Track element plus the // audio specific elements. - virtual uint64_t PayloadSize() const; + virtual uint64 PayloadSize() const; // Output the AudioTrack element to the writer. Returns true on success. virtual bool Write(IMkvWriter* writer) const; - void set_bit_depth(uint64_t bit_depth) { bit_depth_ = bit_depth; } - uint64_t bit_depth() const { return bit_depth_; } - void set_channels(uint64_t channels) { channels_ = channels; } - uint64_t channels() const { return channels_; } + void set_bit_depth(uint64 bit_depth) { bit_depth_ = bit_depth; } + uint64 bit_depth() const { return bit_depth_; } + void set_channels(uint64 channels) { channels_ = channels; } + uint64 channels() const { return channels_; } void set_sample_rate(double sample_rate) { sample_rate_ = sample_rate; } double sample_rate() const { return sample_rate_; } private: // Audio track element names. - uint64_t bit_depth_; - uint64_t channels_; + uint64 bit_depth_; + uint64 channels_; double sample_rate_; LIBWEBM_DISALLOW_COPY_AND_ASSIGN(AudioTrack); @@ -678,35 +542,32 @@ class Tracks { // deleted by the Tracks object. Returns true on success. |number| is the // number to use for the track. |number| must be >= 0. If |number| == 0 // then the muxer will decide on the track number. - bool AddTrack(Track* track, int32_t number); + bool AddTrack(Track* track, int32 number); // Returns the track by index. Returns NULL if there is no track match. - const Track* GetTrackByIndex(uint32_t idx) const; + const Track* GetTrackByIndex(uint32 idx) const; // Search the Tracks and return the track that matches |tn|. Returns NULL // if there is no track match. - Track* GetTrackByNumber(uint64_t track_number) const; + Track* GetTrackByNumber(uint64 track_number) const; // Returns true if the track number is an audio track. - bool TrackIsAudio(uint64_t track_number) const; + bool TrackIsAudio(uint64 track_number) const; // Returns true if the track number is a video track. - bool TrackIsVideo(uint64_t track_number) const; + bool TrackIsVideo(uint64 track_number) const; // Output the Tracks element to the writer. Returns true on success. bool Write(IMkvWriter* writer) const; - uint32_t track_entries_size() const { return track_entries_size_; } + uint32 track_entries_size() const { return track_entries_size_; } private: // Track element list. Track** track_entries_; // Number of Track elements added. - uint32_t track_entries_size_; - - // Whether or not Tracks element has already been written via IMkvWriter. - mutable bool wrote_tracks_; + uint32 track_entries_size_; LIBWEBM_DISALLOW_COPY_AND_ASSIGN(Tracks); }; @@ -724,12 +585,12 @@ class Chapter { // Converts the nanosecond start and stop times of this chapter to // their corresponding timecode values, and stores them that way. - void set_time(const Segment& segment, uint64_t start_time_ns, - uint64_t end_time_ns); + void set_time(const Segment& segment, uint64 start_time_ns, + uint64 end_time_ns); // Sets the uid for this chapter. Primarily used to enable // deterministic output from the muxer. - void set_uid(const uint64_t uid) { uid_ = uid; } + void set_uid(const uint64 uid) { uid_ = uid; } // Add a title string to this chapter, per the semantics described // here: @@ -776,7 +637,7 @@ class Chapter { // If |writer| is non-NULL, serialize the Display sub-element of // the Atom into the stream. Returns the Display element size on // success, 0 if error. - uint64_t WriteDisplay(IMkvWriter* writer) const; + uint64 WriteDisplay(IMkvWriter* writer) const; private: char* title_; @@ -809,20 +670,20 @@ class Chapter { // If |writer| is non-NULL, serialize the Atom sub-element into the // stream. Returns the total size of the element on success, 0 if // error. - uint64_t WriteAtom(IMkvWriter* writer) const; + uint64 WriteAtom(IMkvWriter* writer) const; // The string identifier for this chapter (corresponds to WebVTT cue // identifier). char* id_; // Start timecode of the chapter. - uint64_t start_timecode_; + uint64 start_timecode_; // Stop timecode of the chapter. - uint64_t end_timecode_; + uint64 end_timecode_; // The binary identifier for this chapter. - uint64_t uid_; + uint64 uid_; // The Atom element can contain multiple Display sub-elements, as // the same logical title can be rendered in different languages. @@ -862,7 +723,7 @@ class Chapters { // If |writer| is non-NULL, serialize the Edition sub-element of the // Chapters element into the stream. Returns the Edition element // size on success, 0 if error. - uint64_t WriteEdition(IMkvWriter* writer) const; + uint64 WriteEdition(IMkvWriter* writer) const; // Total length of the chapters_ array. int chapters_size_; @@ -907,7 +768,7 @@ class Tag { // If |writer| is non-NULL, serialize the SimpleTag sub-element of // the Atom into the stream. Returns the SimpleTag element size on // success, 0 if error. - uint64_t Write(IMkvWriter* writer) const; + uint64 Write(IMkvWriter* writer) const; private: char* tag_name_; @@ -934,7 +795,7 @@ class Tag { // If |writer| is non-NULL, serialize the Tag sub-element into the // stream. Returns the total size of the element on success, 0 if // error. - uint64_t Write(IMkvWriter* writer) const; + uint64 Write(IMkvWriter* writer) const; // The Atom element can contain multiple SimpleTag sub-elements SimpleTag* simple_tags_; @@ -992,9 +853,7 @@ class Cluster { // |timecode| is the absolute timecode of the cluster. |cues_pos| is the // position for the cluster within the segment that should be written in // the cues element. |timecode_scale| is the timecode scale of the segment. - Cluster(uint64_t timecode, int64_t cues_pos, uint64_t timecode_scale, - bool write_last_frame_with_duration = false, - bool fixed_size_timecode = false); + Cluster(uint64 timecode, int64 cues_pos, uint64 timecode_scale); ~Cluster(); bool Init(IMkvWriter* ptr_writer); @@ -1013,8 +872,8 @@ class Cluster { // timecode: Absolute (not relative to cluster) timestamp of the // frame, expressed in timecode units. // is_key: Flag telling whether or not this frame is a key frame. - bool AddFrame(const uint8_t* data, uint64_t length, uint64_t track_number, - uint64_t timecode, // timecode units (absolute) + bool AddFrame(const uint8* data, uint64 length, uint64 track_number, + uint64 timecode, // timecode units (absolute) bool is_key); // Adds a frame to be output in the file. The frame is written out through @@ -1030,11 +889,10 @@ class Cluster { // abs_timecode: Absolute (not relative to cluster) timestamp of the // frame, expressed in timecode units. // is_key: Flag telling whether or not this frame is a key frame. - bool AddFrameWithAdditional(const uint8_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); + bool AddFrameWithAdditional(const uint8* data, uint64 length, + const uint8* additional, uint64 additional_length, + uint64 add_id, uint64 track_number, + uint64 abs_timecode, bool is_key); // Adds a frame to be output in the file. The frame is written out through // |writer_| if successful. Returns true on success. @@ -1047,10 +905,9 @@ class Cluster { // abs_timecode: Absolute (not relative to cluster) timestamp of the // frame, expressed in timecode units. // is_key: Flag telling whether or not this frame is a key frame. - bool AddFrameWithDiscardPadding(const uint8_t* data, uint64_t length, - int64_t discard_padding, - uint64_t track_number, uint64_t abs_timecode, - bool is_key); + bool AddFrameWithDiscardPadding(const uint8* data, uint64 length, + int64 discard_padding, uint64 track_number, + uint64 abs_timecode, bool is_key); // Writes a frame of metadata to the output medium; returns true on // success. @@ -1066,53 +923,31 @@ class Cluster { // The metadata frame is written as a block group, with a duration // sub-element but no reference time sub-elements (indicating that // it is considered a keyframe, per Matroska semantics). - bool AddMetadata(const uint8_t* data, uint64_t length, uint64_t track_number, - uint64_t timecode, uint64_t duration); + bool AddMetadata(const uint8* data, uint64 length, uint64 track_number, + uint64 timecode, uint64 duration); // Increments the size of the cluster's data in bytes. - void AddPayloadSize(uint64_t size); - - // Closes the cluster so no more data can be written to it. Will update the - // cluster's size if |writer_| is seekable. Returns true on success. This - // variant of Finalize() fails when |write_last_frame_with_duration_| is set - // to true. - bool Finalize(); + void AddPayloadSize(uint64 size); // Closes the cluster so no more data can be written to it. Will update the // cluster's size if |writer_| is seekable. Returns true on success. - // Inputs: - // set_last_frame_duration: Boolean indicating whether or not the duration - // of the last frame should be set. If set to - // false, the |duration| value is ignored and - // |write_last_frame_with_duration_| will not be - // honored. - // duration: Duration of the Cluster in timecode scale. - bool Finalize(bool set_last_frame_duration, uint64_t duration); + bool Finalize(); // Returns the size in bytes for the entire Cluster element. - uint64_t Size() const; + uint64 Size() const; // Given |abs_timecode|, calculates timecode relative to most recent timecode. // Returns -1 on failure, or a relative timecode. - int64_t GetRelativeTimecode(int64_t abs_timecode) const; + int64 GetRelativeTimecode(int64 abs_timecode) const; - int64_t size_position() const { return size_position_; } - int32_t blocks_added() const { return blocks_added_; } - uint64_t payload_size() const { return payload_size_; } - int64_t position_for_cues() const { return position_for_cues_; } - uint64_t timecode() const { return timecode_; } - uint64_t timecode_scale() const { return timecode_scale_; } - void set_write_last_frame_with_duration(bool write_last_frame_with_duration) { - write_last_frame_with_duration_ = write_last_frame_with_duration; - } - bool write_last_frame_with_duration() const { - return write_last_frame_with_duration_; - } + int64 size_position() const { return size_position_; } + int32 blocks_added() const { return blocks_added_; } + uint64 payload_size() const { return payload_size_; } + int64 position_for_cues() const { return position_for_cues_; } + uint64 timecode() const { return timecode_; } + uint64 timecode_scale() const { return timecode_scale_; } private: - // Iterator type for the |stored_frames_| map. - typedef std::map >::iterator FrameMapIterator; - // Utility method that confirms that blocks can still be added, and that the // cluster header has been written. Used by |DoWriteFrame*|. Returns true // when successful. @@ -1120,58 +955,37 @@ class Cluster { // Utility method used by the |DoWriteFrame*| methods that handles the book // keeping required after each block is written. - void PostWriteBlock(uint64_t element_size); + void PostWriteBlock(uint64 element_size); // Does some verification and calls WriteFrame. bool DoWriteFrame(const Frame* const frame); - // Either holds back the given frame, or writes it out depending on whether or - // not |write_last_frame_with_duration_| is set. - bool QueueOrWriteFrame(const Frame* const frame); - // Outputs the Cluster header to |writer_|. Returns true on success. bool WriteClusterHeader(); // Number of blocks added to the cluster. - int32_t blocks_added_; + int32 blocks_added_; // Flag telling if the cluster has been closed. bool finalized_; - // Flag indicating whether the cluster's timecode will always be written out - // using 8 bytes. - bool fixed_size_timecode_; - // Flag telling if the cluster's header has been written. bool header_written_; // The size of the cluster elements in bytes. - uint64_t payload_size_; + uint64 payload_size_; // The file position used for cue points. - const int64_t position_for_cues_; + const int64 position_for_cues_; // The file position of the cluster's size element. - int64_t size_position_; + int64 size_position_; // The absolute timecode of the cluster. - const uint64_t timecode_; + const uint64 timecode_; // The timecode scale of the Segment containing the cluster. - const uint64_t timecode_scale_; - - // Flag indicating whether the last frame of the cluster should be written as - // a Block with Duration. If set to true, then it will result in holding back - // of frames and the parameterized version of Finalize() must be called to - // finish writing the Cluster. - bool write_last_frame_with_duration_; - - // Map used to hold back frames, if required. Track number is the key. - std::map > stored_frames_; - - // Map from track number to the timestamp of the last block written for that - // track. - std::map last_block_timestamp_; + const uint64 timecode_scale_; // Pointer to the writer object. Not owned by this class. IMkvWriter* writer_; @@ -1192,42 +1006,42 @@ class SeekHead { // Adds a seek entry to be written out when the element is finalized. |id| // must be the coded mkv element id. |pos| is the file position of the // element. Returns true on success. - bool AddSeekEntry(uint32_t id, uint64_t pos); + bool AddSeekEntry(uint32 id, uint64 pos); // Writes out SeekHead and SeekEntry elements. Returns true on success. bool Finalize(IMkvWriter* writer) const; // Returns the id of the Seek Entry at the given index. Returns -1 if index is // out of range. - uint32_t GetId(int index) const; + uint32 GetId(int index) const; // Returns the position of the Seek Entry at the given index. Returns -1 if // index is out of range. - uint64_t GetPosition(int index) const; + uint64 GetPosition(int index) const; // Sets the Seek Entry id and position at given index. // Returns true on success. - bool SetSeekEntry(int index, uint32_t id, uint64_t position); + bool SetSeekEntry(int index, uint32 id, uint64 position); // Reserves space by writing out a Void element which will be updated with // a SeekHead element later. Returns true on success. bool Write(IMkvWriter* writer); // We are going to put a cap on the number of Seek Entries. - const static int32_t kSeekEntryCount = 5; + const static int32 kSeekEntryCount = 5; private: // Returns the maximum size in bytes of one seek entry. - uint64_t MaxEntrySize() const; + uint64 MaxEntrySize() const; // Seek entry id element list. - uint32_t seek_entry_id_[kSeekEntryCount]; + uint32 seek_entry_id_[kSeekEntryCount]; // Seek entry pos element list. - uint64_t seek_entry_pos_[kSeekEntryCount]; + uint64 seek_entry_pos_[kSeekEntryCount]; // The file position of SeekHead element. - int64_t start_pos_; + int64 start_pos_; LIBWEBM_DISALLOW_COPY_AND_ASSIGN(SeekHead); }; @@ -1253,12 +1067,12 @@ class SegmentInfo { double duration() const { return duration_; } void set_muxing_app(const char* app); const char* muxing_app() const { return muxing_app_; } - void set_timecode_scale(uint64_t scale) { timecode_scale_ = scale; } - uint64_t timecode_scale() const { return timecode_scale_; } + void set_timecode_scale(uint64 scale) { timecode_scale_ = scale; } + uint64 timecode_scale() const { return timecode_scale_; } void set_writing_app(const char* app); const char* writing_app() const { return writing_app_; } - void set_date_utc(int64_t date_utc) { date_utc_ = date_utc; } - int64_t date_utc() const { return date_utc_; } + void set_date_utc(int64 date_utc) { date_utc_ = date_utc; } + int64 date_utc() const { return date_utc_; } private: // Segment Information element names. @@ -1267,14 +1081,14 @@ class SegmentInfo { double duration_; // Set to libwebm-%d.%d.%d.%d, major, minor, build, revision. char* muxing_app_; - uint64_t timecode_scale_; + uint64 timecode_scale_; // Initially set to libwebm-%d.%d.%d.%d, major, minor, build, revision. char* writing_app_; // LLONG_MIN when DateUTC is not set. - int64_t date_utc_; + int64 date_utc_; // The file position of the duration element. - int64_t duration_pos_; + int64 duration_pos_; LIBWEBM_DISALLOW_COPY_AND_ASSIGN(SegmentInfo); }; @@ -1294,8 +1108,8 @@ class Segment { kBeforeClusters = 0x1 // Position Cues before Clusters }; - const static uint32_t kDefaultDocTypeVersion = 2; - const static uint64_t kDefaultMaxClusterDuration = 30000000000ULL; + const static uint32 kDefaultDocTypeVersion = 2; + const static uint64 kDefaultMaxClusterDuration = 30000000000ULL; Segment(); ~Segment(); @@ -1309,13 +1123,13 @@ class Segment { // error. |number| is the number to use for the track. |number| // must be >= 0. If |number| == 0 then the muxer will decide on the // track number. - Track* AddTrack(int32_t number); + Track* AddTrack(int32 number); // Adds a Vorbis audio track to the segment. Returns the number of the track // on success, 0 on error. |number| is the number to use for the audio track. // |number| must be >= 0. If |number| == 0 then the muxer will decide on // the track number. - uint64_t AddAudioTrack(int32_t sample_rate, int32_t channels, int32_t number); + uint64 AddAudioTrack(int32 sample_rate, int32 channels, int32 number); // Adds an empty chapter to the chapters of this segment. Returns // non-NULL on success. After adding the chapter, the caller should @@ -1331,7 +1145,7 @@ class Segment { // nanoseconds of the cue's time. |track| is the Track of the Cue. This // function must be called after AddFrame to calculate the correct // BlockNumber for the CuePoint. Returns true on success. - bool AddCuePoint(uint64_t timestamp, uint64_t track); + bool AddCuePoint(uint64 timestamp, uint64 track); // Adds a frame to be output in the file. Returns true on success. // Inputs: @@ -1341,8 +1155,8 @@ class Segment { // functions. // timestamp: Timestamp of the frame in nanoseconds from 0. // is_key: Flag telling whether or not this frame is a key frame. - bool AddFrame(const uint8_t* data, uint64_t length, uint64_t track_number, - uint64_t timestamp_ns, bool is_key); + bool AddFrame(const uint8* data, uint64 length, uint64 track_number, + uint64 timestamp_ns, bool is_key); // Writes a frame of metadata to the output medium; returns true on // success. @@ -1358,8 +1172,8 @@ class Segment { // The metadata frame is written as a block group, with a duration // sub-element but no reference time sub-elements (indicating that // it is considered a keyframe, per Matroska semantics). - bool AddMetadata(const uint8_t* data, uint64_t length, uint64_t track_number, - uint64_t timestamp_ns, uint64_t duration_ns); + bool AddMetadata(const uint8* data, uint64 length, uint64 track_number, + uint64 timestamp_ns, uint64 duration_ns); // Writes a frame with additional data to the output medium; returns true on // success. @@ -1374,11 +1188,10 @@ class Segment { // timestamp: Absolute timestamp of the frame, expressed in nanosecond // units. // is_key: Flag telling whether or not this frame is a key frame. - bool AddFrameWithAdditional(const uint8_t* data, uint64_t length, - const uint8_t* additional, - uint64_t additional_length, uint64_t add_id, - uint64_t track_number, uint64_t timestamp, - bool is_key); + bool AddFrameWithAdditional(const uint8* data, uint64 length, + const uint8* additional, uint64 additional_length, + uint64 add_id, uint64 track_number, + uint64 timestamp, bool is_key); // Writes a frame with DiscardPadding to the output medium; returns true on // success. @@ -1391,10 +1204,9 @@ class Segment { // timestamp: Absolute timestamp of the frame, expressed in nanosecond // units. // is_key: Flag telling whether or not this frame is a key frame. - bool AddFrameWithDiscardPadding(const uint8_t* data, uint64_t length, - int64_t discard_padding, - uint64_t track_number, uint64_t timestamp, - bool is_key); + bool AddFrameWithDiscardPadding(const uint8* data, uint64 length, + int64 discard_padding, uint64 track_number, + uint64 timestamp, bool is_key); // Writes a Frame to the output medium. Chooses the correct way of writing // the frame (Block vs SimpleBlock) based on the parameters passed. @@ -1406,7 +1218,7 @@ class Segment { // success, 0 on error. |number| is the number to use for the video track. // |number| must be >= 0. If |number| == 0 then the muxer will decide on // the track number. - uint64_t AddVideoTrack(int32_t width, int32_t height, int32_t number); + uint64 AddVideoTrack(int32 width, int32 height, int32 number); // This function must be called after Finalize() if you need a copy of the // output with Cues written before the Clusters. It will return false if the @@ -1425,7 +1237,7 @@ class Segment { // Sets which track to use for the Cues element. Must have added the track // before calling this function. Returns true on success. |track_number| is // returned by the Add track functions. - bool CuesTrack(uint64_t track_number); + bool CuesTrack(uint64 track_number); // This will force the muxer to create a new Cluster when the next frame is // added. @@ -1445,17 +1257,11 @@ class Segment { // Search the Tracks and return the track that matches |track_number|. // Returns NULL if there is no track match. - Track* GetTrackByNumber(uint64_t track_number) const; + Track* GetTrackByNumber(uint64 track_number) const; // Toggles whether to output a cues element. void OutputCues(bool output_cues); - // Toggles whether to write the last frame in each Cluster with Duration. - void AccurateClusterDuration(bool accurate_cluster_duration); - - // Toggles whether to write the Cluster Timecode using exactly 8 bytes. - void UseFixedSizeClusterTimecode(bool fixed_size_cluster_timecode); - // Sets if the muxer will output files in chunks or not. |chunking| is a // flag telling whether or not to turn on chunking. |filename| is the base // filename for the chunk files. The header chunk file will be named @@ -1468,15 +1274,15 @@ class Segment { bool SetChunking(bool chunking, const char* filename); bool chunking() const { return chunking_; } - uint64_t cues_track() const { return cues_track_; } - void set_max_cluster_duration(uint64_t max_cluster_duration) { + uint64 cues_track() const { return cues_track_; } + void set_max_cluster_duration(uint64 max_cluster_duration) { max_cluster_duration_ = max_cluster_duration; } - uint64_t max_cluster_duration() const { return max_cluster_duration_; } - void set_max_cluster_size(uint64_t max_cluster_size) { + uint64 max_cluster_duration() const { return max_cluster_duration_; } + void set_max_cluster_size(uint64 max_cluster_size) { max_cluster_size_ = max_cluster_size; } - uint64_t max_cluster_size() const { return max_cluster_size_; } + uint64 max_cluster_size() const { return max_cluster_size_; } void set_mode(Mode mode) { mode_ = mode; } Mode mode() const { return mode_; } CuesPosition cues_position() const { return cues_position_; } @@ -1500,7 +1306,7 @@ class Segment { // Returns the maximum offset within the segment's payload. When chunking // this function is needed to determine offsets of elements within the // chunked files. Returns -1 on error. - int64_t MaxOffset(); + int64 MaxOffset(); // Adds the frame to our frame array. bool QueueFrame(Frame* frame); @@ -1512,7 +1318,7 @@ class Segment { // Output all frames that are queued that have an end time that is less // then |timestamp|. Returns true on success and if there are no frames // queued. - bool WriteFramesLessThan(uint64_t timestamp); + bool WriteFramesLessThan(uint64 timestamp); // Outputs the segment header, Segment Information element, SeekHead element, // and Tracks element to |writer_|. @@ -1526,17 +1332,16 @@ class Segment { // 0 = do not create a new cluster, and write frame to the existing cluster // 1 = create a new cluster, and write frame to that new cluster // 2 = create a new cluster, and re-run test - int TestFrame(uint64_t track_num, uint64_t timestamp_ns, bool key) const; + int TestFrame(uint64 track_num, uint64 timestamp_ns, bool key) const; // Create a new cluster, using the earlier of the first enqueued // frame, or the indicated time. Returns true on success. - bool MakeNewCluster(uint64_t timestamp_ns); + bool MakeNewCluster(uint64 timestamp_ns); // Checks whether a new cluster needs to be created, and if so // creates a new cluster. Returns false if creation of a new cluster // was necessary but creation was not successful. - bool DoNewClusterProcessing(uint64_t track_num, uint64_t timestamp_ns, - bool key); + bool DoNewClusterProcessing(uint64 track_num, uint64 timestamp_ns, bool key); // Adjusts Cue Point values (to place Cues before Clusters) so that they // reflect the correct offsets. @@ -1550,8 +1355,7 @@ class Segment { // accounted for. // index - index in the list of Cues which is currently being adjusted. // cue_size - sum of size of all the CuePoint elements. - void MoveCuesBeforeClustersHelper(uint64_t diff, int index, - uint64_t* cue_size); + void MoveCuesBeforeClustersHelper(uint64 diff, int index, uint64* cue_size); // Seeds the random number generator used to make UIDs. unsigned int seed_; @@ -1590,22 +1394,22 @@ class Segment { char* chunking_base_name_; // File position offset where the Clusters end. - int64_t cluster_end_offset_; + int64 cluster_end_offset_; // List of clusters. Cluster** cluster_list_; // Number of cluster pointers allocated in the cluster list. - int32_t cluster_list_capacity_; + int32 cluster_list_capacity_; // Number of clusters in the cluster list. - int32_t cluster_list_size_; + int32 cluster_list_size_; // Indicates whether Cues should be written before or after Clusters CuesPosition cues_position_; // Track number that is associated with the cues element for this segment. - uint64_t cues_track_; + uint64 cues_track_; // Tells the muxer to force a new cluster on the next Block. bool force_new_cluster_; @@ -1617,10 +1421,10 @@ class Segment { Frame** frames_; // Number of frame pointers allocated in the frame list. - int32_t frames_capacity_; + int32 frames_capacity_; // Number of frames in the frame list. - int32_t frames_size_; + int32 frames_size_; // Flag telling if a video track has been added to the segment. bool has_video_; @@ -1629,23 +1433,23 @@ class Segment { bool header_written_; // Duration of the last block in nanoseconds. - uint64_t last_block_duration_; + uint64 last_block_duration_; // Last timestamp in nanoseconds added to a cluster. - uint64_t last_timestamp_; + uint64 last_timestamp_; // Last timestamp in nanoseconds by track number added to a cluster. - uint64_t last_track_timestamp_[kMaxTrackNumber]; + uint64 last_track_timestamp_[kMaxTrackNumber]; // Maximum time in nanoseconds for a cluster duration. This variable is a // guideline and some clusters may have a longer duration. Default is 30 // seconds. - uint64_t max_cluster_duration_; + uint64 max_cluster_duration_; // Maximum size in bytes for a cluster. This variable is a guideline and // some clusters may have a larger size. Default is 0 which signifies that // the muxer will decide the size. - uint64_t max_cluster_size_; + uint64 max_cluster_size_; // The mode that segment is in. If set to |kLive| the writer must not // seek backwards. @@ -1658,29 +1462,22 @@ class Segment { // Flag whether or not the muxer should output a Cues element. bool output_cues_; - // Flag whether or not the last frame in each Cluster will have a Duration - // element in it. - bool accurate_cluster_duration_; - - // Flag whether or not to write the Cluster Timecode using exactly 8 bytes. - bool fixed_size_cluster_timecode_; - // The size of the EBML header, used to validate the header if // WriteEbmlHeader() is called more than once. - int32_t ebml_header_size_; + int32 ebml_header_size_; // The file position of the segment's payload. - int64_t payload_pos_; + int64 payload_pos_; // The file position of the element's size. - int64_t size_position_; + int64 size_position_; // Current DocTypeVersion (|doc_type_version_|) and that written in // WriteSegmentHeader(). // WriteEbmlHeader() will be called from Finalize() if |doc_type_version_| // differs from |doc_type_version_written_|. - uint32_t doc_type_version_; - uint32_t doc_type_version_written_; + uint32 doc_type_version_; + uint32 doc_type_version_written_; // Pointer to the writer objects. Not owned by this class. IMkvWriter* writer_cluster_; @@ -1690,6 +1487,6 @@ class Segment { LIBWEBM_DISALLOW_COPY_AND_ASSIGN(Segment); }; -} // namespace mkvmuxer +} // end namespace mkvmuxer -#endif // MKVMUXER_MKVMUXER_H_ +#endif // MKVMUXER_HPP diff --git a/third_party/libwebm/mkvmuxer/mkvmuxerutil.h b/third_party/libwebm/mkvmuxer/mkvmuxerutil.h deleted file mode 100644 index 0e21a2dcb..000000000 --- a/third_party/libwebm/mkvmuxer/mkvmuxerutil.h +++ /dev/null @@ -1,95 +0,0 @@ -// 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. -#ifndef MKVMUXER_MKVMUXERUTIL_H_ -#define MKVMUXER_MKVMUXERUTIL_H_ - -#include - -namespace mkvmuxer { -class Cluster; -class Frame; -class IMkvWriter; - -const uint64_t kEbmlUnknownValue = 0x01FFFFFFFFFFFFFFULL; -const int64_t kMaxBlockTimecode = 0x07FFFLL; - -// Writes out |value| in Big Endian order. Returns 0 on success. -int32_t SerializeInt(IMkvWriter* writer, int64_t value, int32_t 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); - -// 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); - -// 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); - -// 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); - -// Output an Mkv master element. Returns true if the element was written. -bool WriteEbmlMasterElement(IMkvWriter* writer, uint64_t value, uint64_t size); - -// Outputs an Mkv ID, calls |IMkvWriter::ElementStartNotify|, and passes the -// ID to |SerializeInt|. Returns 0 on success. -int32_t WriteID(IMkvWriter* writer, uint64_t type); - -// Output an Mkv non-master element. Returns true if the element was written. -bool WriteEbmlElement(IMkvWriter* writer, uint64_t type, uint64_t value); -bool WriteEbmlElement(IMkvWriter* writer, uint64_t type, int64_t value); -bool WriteEbmlElement(IMkvWriter* writer, uint64_t type, float value); -bool WriteEbmlElement(IMkvWriter* writer, uint64_t type, const char* value); -bool WriteEbmlElement(IMkvWriter* writer, uint64_t type, const uint8_t* value, - uint64_t size); -bool WriteEbmlDateElement(IMkvWriter* writer, uint64_t type, int64_t value); - -// Output 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); - -// 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); - -// 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); - -// 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); - -// 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); - -} // namespace mkvmuxer - -#endif // MKVMUXER_MKVMUXERUTIL_H_ diff --git a/third_party/libwebm/mkvmuxer/mkvmuxertypes.h b/third_party/libwebm/mkvmuxertypes.hpp similarity index 70% rename from third_party/libwebm/mkvmuxer/mkvmuxertypes.h rename to third_party/libwebm/mkvmuxertypes.hpp index f5c80f619..d0fc9fec8 100644 --- a/third_party/libwebm/mkvmuxer/mkvmuxertypes.h +++ b/third_party/libwebm/mkvmuxertypes.hpp @@ -6,8 +6,8 @@ // in the file PATENTS. All contributing project authors may // be found in the AUTHORS file in the root of the source tree. -#ifndef MKVMUXER_MKVMUXERTYPES_H_ -#define MKVMUXER_MKVMUXERTYPES_H_ +#ifndef MKVMUXERTYPES_HPP +#define MKVMUXERTYPES_HPP // Copied from Chromium basictypes.h // A macro to disallow the copy constructor and operator= functions @@ -16,4 +16,15 @@ TypeName(const TypeName&); \ void operator=(const TypeName&) -#endif // MKVMUXER_MKVMUXERTYPES_HPP_ +namespace mkvmuxer { + +typedef unsigned char uint8; +typedef short int16; +typedef int int32; +typedef unsigned int uint32; +typedef long long int64; +typedef unsigned long long uint64; + +} // end namespace mkvmuxer + +#endif // MKVMUXERTYPES_HPP diff --git a/third_party/libwebm/mkvmuxer/mkvmuxerutil.cc b/third_party/libwebm/mkvmuxerutil.cpp similarity index 52% rename from third_party/libwebm/mkvmuxer/mkvmuxerutil.cc rename to third_party/libwebm/mkvmuxerutil.cpp index f8e517c06..27ab15d51 100644 --- a/third_party/libwebm/mkvmuxer/mkvmuxerutil.cc +++ b/third_party/libwebm/mkvmuxerutil.cpp @@ -6,7 +6,7 @@ // in the file PATENTS. All contributing project authors may // be found in the AUTHORS file in the root of the source tree. -#include "mkvmuxer/mkvmuxerutil.h" +#include "mkvmuxerutil.hpp" #ifdef __ANDROID__ #include @@ -20,9 +20,13 @@ #include #include -#include "common/webmids.h" -#include "mkvmuxer/mkvmuxer.h" -#include "mkvmuxer/mkvwriter.h" +#include "mkvwriter.hpp" +#include "webmids.hpp" + +#ifdef _MSC_VER +// Disable MSVC warnings that suggest making code non-portable. +#pragma warning(disable : 4996) +#endif namespace mkvmuxer { @@ -31,68 +35,64 @@ 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_additional_elem_size = EbmlElementSize( + kMkvBlockAdditional, frame->additional(), frame->additional_length()); + block_addid_elem_size = EbmlElementSize(kMkvBlockAddID, frame->add_id()); block_more_payload_size = block_addid_elem_size + block_additional_elem_size; block_more_elem_size = - EbmlMasterElementSize(libwebm::kMkvBlockMore, block_more_payload_size) + + EbmlMasterElementSize(kMkvBlockMore, block_more_payload_size) + block_more_payload_size; block_additions_payload_size = block_more_elem_size; block_additions_elem_size = - EbmlMasterElementSize(libwebm::kMkvBlockAdditions, + EbmlMasterElementSize(kMkvBlockAdditions, block_additions_payload_size) + 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(kMkvDiscardPadding, 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); + EbmlElementSize(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); + block_duration_elem_size = EbmlElementSize(kMkvBlockDuration, duration); - const uint64_t block_payload_size = 4 + frame->length(); - const uint64_t block_elem_size = - EbmlMasterElementSize(libwebm::kMkvBlock, block_payload_size) + - block_payload_size; + const uint64 block_payload_size = 4 + frame->length(); + const uint64 block_elem_size = + EbmlMasterElementSize(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; - if (!WriteEbmlMasterElement(writer, libwebm::kMkvBlockGroup, + if (!WriteEbmlMasterElement(writer, kMkvBlockGroup, block_group_payload_size)) { return 0; } - if (!WriteEbmlMasterElement(writer, libwebm::kMkvBlock, block_payload_size)) + if (!WriteEbmlMasterElement(writer, kMkvBlock, block_payload_size)) return 0; if (WriteUInt(writer, frame->track_number())) @@ -105,81 +105,77 @@ uint64_t WriteBlock(IMkvWriter* writer, const Frame* const frame, if (SerializeInt(writer, 0, 1)) return 0; - if (writer->Write(frame->frame(), static_cast(frame->length()))) + if (writer->Write(frame->frame(), static_cast(frame->length()))) return 0; if (frame->additional()) { - if (!WriteEbmlMasterElement(writer, libwebm::kMkvBlockAdditions, + if (!WriteEbmlMasterElement(writer, kMkvBlockAdditions, block_additions_payload_size)) { return 0; } - if (!WriteEbmlMasterElement(writer, libwebm::kMkvBlockMore, - block_more_payload_size)) + if (!WriteEbmlMasterElement(writer, kMkvBlockMore, block_more_payload_size)) return 0; - if (!WriteEbmlElement(writer, libwebm::kMkvBlockAddID, frame->add_id())) + if (!WriteEbmlElement(writer, kMkvBlockAddID, frame->add_id())) return 0; - if (!WriteEbmlElement(writer, libwebm::kMkvBlockAdditional, - frame->additional(), frame->additional_length())) { + if (!WriteEbmlElement(writer, kMkvBlockAdditional, frame->additional(), + frame->additional_length())) { return 0; } } if (frame->discard_padding() != 0 && - !WriteEbmlElement(writer, libwebm::kMkvDiscardPadding, - frame->discard_padding())) { + !WriteEbmlElement(writer, kMkvDiscardPadding, frame->discard_padding())) { return false; } if (!frame->is_key() && - !WriteEbmlElement(writer, libwebm::kMkvReferenceBlock, + !WriteEbmlElement(writer, kMkvReferenceBlock, reference_block_timestamp)) { return false; } - if (duration > 0 && - !WriteEbmlElement(writer, libwebm::kMkvBlockDuration, duration)) { + if (duration > 0 && !WriteEbmlElement(writer, kMkvBlockDuration, duration)) { return false; } - return EbmlMasterElementSize(libwebm::kMkvBlockGroup, - block_group_payload_size) + + return EbmlMasterElementSize(kMkvBlockGroup, block_group_payload_size) + block_group_payload_size; } -uint64_t WriteSimpleBlock(IMkvWriter* writer, const Frame* const frame, - int64_t timecode) { - if (WriteID(writer, libwebm::kMkvSimpleBlock)) +uint64 WriteSimpleBlock(IMkvWriter* writer, const Frame* const frame, + int64 timecode) { + if (WriteID(writer, kMkvSimpleBlock)) return 0; - const int32_t size = static_cast(frame->length()) + 4; + const int32 size = static_cast(frame->length()) + 4; if (WriteUInt(writer, size)) return 0; - if (WriteUInt(writer, static_cast(frame->track_number()))) + if (WriteUInt(writer, static_cast(frame->track_number()))) return 0; if (SerializeInt(writer, timecode, 2)) return 0; - uint64_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(frame->length()))) + if (writer->Write(frame->frame(), static_cast(frame->length()))) return 0; - return GetUIntSize(libwebm::kMkvSimpleBlock) + GetCodedUIntSize(size) + 4 + + return GetUIntSize(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 +193,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,16 +211,16 @@ 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); @@ -232,9 +228,9 @@ uint64_t EbmlMasterElementSize(uint64_t type, uint64_t value) { 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); @@ -245,16 +241,12 @@ uint64_t EbmlElementSize(uint64_t type, int64_t value) { return ebml_size; } -uint64_t EbmlElementSize(uint64_t type, uint64_t 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) { // Size of EBML ID - int32_t ebml_size = GetUIntSize(type); + int32 ebml_size = GetUIntSize(type); // Datasize - ebml_size += (fixed_size > 0) ? fixed_size : GetUIntSize(value); + ebml_size += GetUIntSize(value); // Size of Datasize ebml_size++; @@ -262,9 +254,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 = GetUIntSize(type); + uint64 ebml_size = GetUIntSize(type); // Datasize ebml_size += sizeof(float); @@ -275,12 +267,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 = GetUIntSize(type); + uint64 ebml_size = GetUIntSize(type); // Datasize ebml_size += strlen(value); @@ -291,12 +283,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 = GetUIntSize(type); + uint64 ebml_size = GetUIntSize(type); // Datasize ebml_size += size; @@ -307,9 +299,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 = GetUIntSize(type); + uint64 ebml_size = GetUIntSize(type); // Datasize ebml_size += kDateElementSize; @@ -320,18 +312,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(bb); + const int64 bb = value >> bit_count; + const uint8 b = static_cast(bb); - const int32_t status = writer->Write(&b, 1); + const int32 status = writer->Write(&b, 1); if (status < 0) return status; @@ -340,26 +332,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(value.u32 >> bit_count); + const uint8 byte = static_cast(value.u32 >> bit_count); - const int32_t status = writer->Write(&byte, 1); + const int32 status = writer->Write(&byte, 1); if (status < 0) return status; @@ -368,21 +360,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; @@ -390,11 +382,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; @@ -411,18 +403,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; @@ -435,51 +427,41 @@ bool WriteEbmlMasterElement(IMkvWriter* writer, uint64_t type, uint64_t size) { return true; } -bool WriteEbmlElement(IMkvWriter* writer, uint64_t type, uint64_t 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) { if (!writer) return false; if (WriteID(writer, type)) return false; - uint64_t size = GetUIntSize(value); - if (fixed_size > 0) { - if (size > fixed_size) - return false; - size = fixed_size; - } + const uint64 size = GetUIntSize(value); if (WriteUInt(writer, size)) return false; - if (SerializeInt(writer, value, static_cast(size))) + if (SerializeInt(writer, value, static_cast(size))) return false; return true; } -bool WriteEbmlElement(IMkvWriter* writer, uint64_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(size))) + if (SerializeInt(writer, value, static_cast(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; @@ -495,25 +477,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(length))) + if (writer->Write(value, static_cast(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; @@ -523,13 +505,13 @@ bool WriteEbmlElement(IMkvWriter* writer, uint64_t type, const uint8_t* value, if (WriteUInt(writer, size)) return false; - if (writer->Write(value, static_cast(size))) + if (writer->Write(value, static_cast(size))) return false; return true; } -bool WriteEbmlDateElement(IMkvWriter* writer, uint64_t type, int64_t value) { +bool WriteEbmlDateElement(IMkvWriter* writer, uint64 type, int64 value) { if (!writer) return false; @@ -545,8 +527,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; @@ -555,7 +537,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; @@ -566,53 +548,53 @@ 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(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; - if (WriteID(writer, libwebm::kMkvVoid)) + if (WriteID(writer, kMkvVoid)) return 0; if (WriteUInt(writer, void_entry_size)) return 0; - const uint8_t value = 0; - for (int32_t i = 0; i < static_cast(void_entry_size); ++i) { + const uint8 value = 0; + for (int32 i = 0; i < static_cast(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(void_size)) + stop_position - payload_position != static_cast(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; +} // namespace mkvmuxer + +mkvmuxer::uint64 mkvmuxer::MakeUID(unsigned int* seed) { + uint64 uid = 0; #ifdef __MINGW32__ srand(*seed); @@ -624,26 +606,24 @@ 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)); + read(fd, &temp_num, sizeof(int32)); 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; } return uid; } - -} // namespace mkvmuxer diff --git a/third_party/libwebm/mkvmuxerutil.hpp b/third_party/libwebm/mkvmuxerutil.hpp new file mode 100644 index 000000000..e31857694 --- /dev/null +++ b/third_party/libwebm/mkvmuxerutil.hpp @@ -0,0 +1,83 @@ +// 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. + +#ifndef MKVMUXERUTIL_HPP +#define MKVMUXERUTIL_HPP + +#include "mkvmuxer.hpp" +#include "mkvmuxertypes.hpp" + +namespace mkvmuxer { + +class IMkvWriter; + +const uint64 kEbmlUnknownValue = 0x01FFFFFFFFFFFFFFULL; +const int64 kMaxBlockTimecode = 0x07FFFLL; + +// Writes out |value| in Big Endian order. Returns 0 on success. +int32 SerializeInt(IMkvWriter* writer, int64 value, int32 size); + +// Returns the size in bytes of the element. +int32 GetUIntSize(uint64 value); +int32 GetIntSize(int64 value); +int32 GetCodedUIntSize(uint64 value); +uint64 EbmlMasterElementSize(uint64 type, uint64 value); +uint64 EbmlElementSize(uint64 type, int64 value); +uint64 EbmlElementSize(uint64 type, uint64 value); +uint64 EbmlElementSize(uint64 type, float value); +uint64 EbmlElementSize(uint64 type, const char* value); +uint64 EbmlElementSize(uint64 type, const uint8* value, uint64 size); +uint64 EbmlDateElementSize(uint64 type); + +// Creates an EBML coded number from |value| and writes it out. The size of +// the coded number is determined by the value of |value|. |value| must not +// be in a coded form. Returns 0 on success. +int32 WriteUInt(IMkvWriter* writer, uint64 value); + +// Creates an EBML coded number from |value| and writes it out. The size of +// the coded number is determined by the value of |size|. |value| must not +// be in a coded form. Returns 0 on success. +int32 WriteUIntSize(IMkvWriter* writer, uint64 value, int32 size); + +// Output an Mkv master element. Returns true if the element was written. +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 WriteID(IMkvWriter* writer, uint64 type); + +// Output an Mkv non-master element. Returns true if the element was written. +bool WriteEbmlElement(IMkvWriter* writer, uint64 type, uint64 value); +bool WriteEbmlElement(IMkvWriter* writer, uint64 type, int64 value); +bool WriteEbmlElement(IMkvWriter* writer, uint64 type, float value); +bool WriteEbmlElement(IMkvWriter* writer, uint64 type, const char* value); +bool WriteEbmlElement(IMkvWriter* writer, uint64 type, const uint8* value, + uint64 size); +bool WriteEbmlDateElement(IMkvWriter* writer, uint64 type, int64 value); + +// Output a Mkv Frame. It decides the correct element to write (Block vs +// SimpleBlock) based on the parameters of the Frame. +uint64 WriteFrame(IMkvWriter* writer, const Frame* const frame, + Cluster* cluster); + +// Output a void element. |size| must be the entire size in bytes that will be +// void. The function will calculate the size of the void header and subtract +// it from |size|. +uint64 WriteVoidElement(IMkvWriter* writer, uint64 size); + +// Returns the version number of the muxer in |major|, |minor|, |build|, +// and |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 MakeUID(unsigned int* seed); + +} // end namespace mkvmuxer + +#endif // MKVMUXERUTIL_HPP diff --git a/third_party/libwebm/mkvparser/mkvparser.cc b/third_party/libwebm/mkvparser.cpp similarity index 92% rename from third_party/libwebm/mkvparser/mkvparser.cc rename to third_party/libwebm/mkvparser.cpp index ff1332726..f2855d506 100644 --- a/third_party/libwebm/mkvparser/mkvparser.cc +++ b/third_party/libwebm/mkvparser.cpp @@ -5,7 +5,8 @@ // 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 "mkvparser/mkvparser.h" + +#include "mkvparser.hpp" #if defined(_MSC_VER) && _MSC_VER < 1800 #include // _isnan() / _finite() @@ -13,18 +14,19 @@ #endif #include -#include #include #include #include -#include #include -#include "common/webmids.h" +#include "webmids.hpp" + +#ifdef _MSC_VER +// Disable MSVC warnings that suggest making code non-portable. +#pragma warning(disable : 4996) +#endif namespace mkvparser { -const float MasteringMetadata::kValueNotPresent = FLT_MAX; -const long long Colour::kValueNotPresent = LLONG_MAX; #ifdef MSC_COMPAT inline bool isnan(double val) { return !!_isnan(val); } @@ -36,9 +38,8 @@ inline bool isinf(double val) { return std::isinf(val); } IMkvReader::~IMkvReader() {} -template -Type* SafeArrayAlloc(unsigned long long num_elements, - unsigned long long element_size) { +template Type* SafeArrayAlloc(unsigned long long num_elements, + unsigned long long element_size) { if (num_elements == 0 || element_size == 0) return NULL; @@ -349,8 +350,9 @@ long UnserializeString(IMkvReader* pReader, long long pos, long long size, return 0; } -long ParseElementHeader(IMkvReader* pReader, long long& pos, long long stop, - long long& id, long long& size) { +long ParseElementHeader(IMkvReader* pReader, long long& pos, + long long stop, long long& id, + long long& size) { if (stop >= 0 && pos >= stop) return E_FILE_FORMAT_INVALID; @@ -384,7 +386,7 @@ long ParseElementHeader(IMkvReader* pReader, long long& pos, long long stop, // pos now designates payload - if (stop >= 0 && pos > stop) + if (stop >= 0 && pos >= stop) return E_FILE_FORMAT_INVALID; return 0; // success @@ -518,6 +520,7 @@ long long EBMLHeader::Parse(IMkvReader* pReader, long long& pos) { return status; pos = 0; + long long end = (available >= 1024) ? 1024 : available; // Scan until we find what looks like the first byte of the EBML header. const long long kMaxScanBytes = (available >= 1024) ? 1024 : available; @@ -541,10 +544,8 @@ long long EBMLHeader::Parse(IMkvReader* pReader, long long& pos) { long len = 0; const long long ebml_id = ReadID(pReader, pos, len); - if (ebml_id == E_BUFFER_NOT_FULL) - return E_BUFFER_NOT_FULL; - - if (len != 4 || ebml_id != libwebm::kMkvEBML) + // TODO(tomfinegan): Move Matroska ID constants into a common namespace. + if (len != 4 || ebml_id != mkvmuxer::kMkvEBML) return E_FILE_FORMAT_INVALID; // Move read pos forward to the EBML header size field. @@ -583,7 +584,7 @@ long long EBMLHeader::Parse(IMkvReader* pReader, long long& pos) { if ((available - pos) < result) return pos + result; - const long long end = pos + result; + end = pos + result; Init(); @@ -598,27 +599,27 @@ long long EBMLHeader::Parse(IMkvReader* pReader, long long& pos) { if (size == 0) return E_FILE_FORMAT_INVALID; - if (id == libwebm::kMkvEBMLVersion) { + if (id == mkvmuxer::kMkvEBMLVersion) { m_version = UnserializeUInt(pReader, pos, size); if (m_version <= 0) return E_FILE_FORMAT_INVALID; - } else if (id == libwebm::kMkvEBMLReadVersion) { + } else if (id == mkvmuxer::kMkvEBMLReadVersion) { m_readVersion = UnserializeUInt(pReader, pos, size); if (m_readVersion <= 0) return E_FILE_FORMAT_INVALID; - } else if (id == libwebm::kMkvEBMLMaxIDLength) { + } else if (id == mkvmuxer::kMkvEBMLMaxIDLength) { m_maxIdLength = UnserializeUInt(pReader, pos, size); if (m_maxIdLength <= 0) return E_FILE_FORMAT_INVALID; - } else if (id == libwebm::kMkvEBMLMaxSizeLength) { + } else if (id == mkvmuxer::kMkvEBMLMaxSizeLength) { m_maxSizeLength = UnserializeUInt(pReader, pos, size); if (m_maxSizeLength <= 0) return E_FILE_FORMAT_INVALID; - } else if (id == libwebm::kMkvDocType) { + } else if (id == mkvmuxer::kMkvDocType) { if (m_docType) return E_FILE_FORMAT_INVALID; @@ -626,12 +627,12 @@ long long EBMLHeader::Parse(IMkvReader* pReader, long long& pos) { if (status) // error return status; - } else if (id == libwebm::kMkvDocTypeVersion) { + } else if (id == mkvmuxer::kMkvDocTypeVersion) { m_docTypeVersion = UnserializeUInt(pReader, pos, size); if (m_docTypeVersion <= 0) return E_FILE_FORMAT_INVALID; - } else if (id == libwebm::kMkvDocTypeReadVersion) { + } else if (id == mkvmuxer::kMkvDocTypeReadVersion) { m_docTypeReadVersion = UnserializeUInt(pReader, pos, size); if (m_docTypeReadVersion <= 0) @@ -649,8 +650,8 @@ long long EBMLHeader::Parse(IMkvReader* pReader, long long& pos) { return E_FILE_FORMAT_INVALID; // Make sure EBMLMaxIDLength and EBMLMaxSizeLength are valid. - if (m_maxIdLength <= 0 || m_maxIdLength > 4 || m_maxSizeLength <= 0 || - m_maxSizeLength > 8) + if (m_maxIdLength <= 0 || m_maxIdLength > 4 || + m_maxSizeLength <= 0 || m_maxSizeLength > 8) return E_FILE_FORMAT_INVALID; return 0; @@ -785,7 +786,7 @@ long long Segment::CreateInstance(IMkvReader* pReader, long long pos, // Handle "unknown size" for live streaming of webm files. const long long unknown_size = (1LL << (7 * len)) - 1; - if (id == libwebm::kMkvSegment) { + if (id == mkvmuxer::kMkvSegment) { if (size == unknown_size) size = -1; @@ -877,7 +878,7 @@ long long Segment::ParseHeaders() { if (id < 0) return E_FILE_FORMAT_INVALID; - if (id == libwebm::kMkvCluster) + if (id == mkvmuxer::kMkvCluster) break; pos += len; // consume ID @@ -929,7 +930,7 @@ long long Segment::ParseHeaders() { if ((pos + size) > available) return pos + size; - if (id == libwebm::kMkvInfo) { + if (id == mkvmuxer::kMkvInfo) { if (m_pInfo) return E_FILE_FORMAT_INVALID; @@ -943,7 +944,7 @@ long long Segment::ParseHeaders() { if (status) return status; - } else if (id == libwebm::kMkvTracks) { + } else if (id == mkvmuxer::kMkvTracks) { if (m_pTracks) return E_FILE_FORMAT_INVALID; @@ -957,7 +958,7 @@ long long Segment::ParseHeaders() { if (status) return status; - } else if (id == libwebm::kMkvCues) { + } else if (id == mkvmuxer::kMkvCues) { if (m_pCues == NULL) { m_pCues = new (std::nothrow) Cues(this, pos, size, element_start, element_size); @@ -965,7 +966,7 @@ long long Segment::ParseHeaders() { if (m_pCues == NULL) return -1; } - } else if (id == libwebm::kMkvSeekHead) { + } else if (id == mkvmuxer::kMkvSeekHead) { if (m_pSeekHead == NULL) { m_pSeekHead = new (std::nothrow) SeekHead(this, pos, size, element_start, element_size); @@ -978,7 +979,7 @@ long long Segment::ParseHeaders() { if (status) return status; } - } else if (id == libwebm::kMkvChapters) { + } else if (id == mkvmuxer::kMkvChapters) { if (m_pChapters == NULL) { m_pChapters = new (std::nothrow) Chapters(this, pos, size, element_start, element_size); @@ -991,7 +992,7 @@ long long Segment::ParseHeaders() { if (status) return status; } - } else if (id == libwebm::kMkvTags) { + } else if (id == mkvmuxer::kMkvTags) { if (m_pTags == NULL) { m_pTags = new (std::nothrow) Tags(this, pos, size, element_start, element_size); @@ -1130,7 +1131,7 @@ long Segment::DoLoadCluster(long long& pos, long& len) { return E_FILE_FORMAT_INVALID; } - if (id == libwebm::kMkvCues) { + if (id == mkvmuxer::kMkvCues) { if (size == unknown_size) { // Cues element of unknown size: Not supported. return E_FILE_FORMAT_INVALID; @@ -1148,7 +1149,7 @@ long Segment::DoLoadCluster(long long& pos, long& len) { continue; } - if (id != libwebm::kMkvCluster) { + if (id != mkvmuxer::kMkvCluster) { // Besides the Segment, Libwebm allows only cluster elements of unknown // size. Fail the parse upon encountering a non-cluster element reporting // unknown size. @@ -1511,9 +1512,9 @@ long SeekHead::Parse() { if (status < 0) // error return status; - if (id == libwebm::kMkvSeek) + if (id == mkvmuxer::kMkvSeek) ++entry_count; - else if (id == libwebm::kMkvVoid) + else if (id == mkvmuxer::kMkvVoid) ++void_element_count; pos += size; // consume payload @@ -1552,14 +1553,14 @@ long SeekHead::Parse() { if (status < 0) // error return status; - if (id == libwebm::kMkvSeek) { + if (id == mkvmuxer::kMkvSeek) { if (ParseEntry(pReader, pos, size, pEntry)) { Entry& e = *pEntry++; e.element_start = idpos; e.element_size = (pos + size) - idpos; } - } else if (id == libwebm::kMkvVoid) { + } else if (id == mkvmuxer::kMkvVoid) { VoidElement& e = *pVoidElement++; e.element_start = idpos; @@ -1663,7 +1664,7 @@ long Segment::ParseCues(long long off, long long& pos, long& len) { const long long id = ReadID(m_pReader, idpos, len); - if (id != libwebm::kMkvCues) + if (id != mkvmuxer::kMkvCues) return E_FILE_FORMAT_INVALID; pos += len; // consume ID @@ -1745,7 +1746,7 @@ bool SeekHead::ParseEntry(IMkvReader* pReader, long long start, long long size_, if (seekIdId < 0) return false; - if (seekIdId != libwebm::kMkvSeekID) + if (seekIdId != mkvmuxer::kMkvSeekID) return false; if ((pos + len) > stop) @@ -1789,7 +1790,7 @@ bool SeekHead::ParseEntry(IMkvReader* pReader, long long start, long long size_, const long long seekPosId = ReadID(pReader, pos, len); - if (seekPosId != libwebm::kMkvSeekPosition) + if (seekPosId != mkvmuxer::kMkvSeekPosition) return false; if ((pos + len) > stop) @@ -1899,7 +1900,7 @@ bool Cues::Init() const { return false; } - if (id == libwebm::kMkvCuePoint) { + if (id == mkvmuxer::kMkvCuePoint) { if (!PreloadCuePoint(cue_points_size, idpos)) return false; } @@ -1974,7 +1975,7 @@ bool Cues::LoadCuePoint() const { if ((m_pos + size) > stop) return false; - if (id != libwebm::kMkvCuePoint) { + if (id != mkvmuxer::kMkvCuePoint) { m_pos += size; // consume payload if (m_pos > stop) return false; @@ -2104,8 +2105,8 @@ const CuePoint* Cues::GetLast() const { } const CuePoint* Cues::GetNext(const CuePoint* pCurr) const { - if (pCurr == NULL || pCurr->GetTimeCode() < 0 || m_cue_points == NULL || - m_count < 1) { + if (pCurr == NULL || pCurr->GetTimeCode() < 0 || + m_cue_points == NULL || m_count < 1) { return NULL; } @@ -2285,7 +2286,7 @@ bool CuePoint::Load(IMkvReader* pReader) { long len; const long long id = ReadID(pReader, pos_, len); - if (id != libwebm::kMkvCuePoint) + if (id != mkvmuxer::kMkvCuePoint) return false; pos_ += len; // consume ID @@ -2325,10 +2326,10 @@ bool CuePoint::Load(IMkvReader* pReader) { return false; } - if (id == libwebm::kMkvCueTime) + if (id == mkvmuxer::kMkvCueTime) m_timecode = UnserializeUInt(pReader, pos, size); - else if (id == libwebm::kMkvCueTrackPositions) + else if (id == mkvmuxer::kMkvCueTrackPositions) ++m_track_positions_count; pos += size; // consume payload @@ -2367,7 +2368,7 @@ bool CuePoint::Load(IMkvReader* pReader) { pos += len; // consume Size field assert((pos + size) <= stop); - if (id == libwebm::kMkvCueTrackPositions) { + if (id == mkvmuxer::kMkvCueTrackPositions) { TrackPosition& tp = *p++; if (!tp.Parse(pReader, pos, size)) { return false; @@ -2416,11 +2417,11 @@ bool CuePoint::TrackPosition::Parse(IMkvReader* pReader, long long start_, return false; } - if (id == libwebm::kMkvCueTrack) + if (id == mkvmuxer::kMkvCueTrack) m_track = UnserializeUInt(pReader, pos, size); - else if (id == libwebm::kMkvCueClusterPosition) + else if (id == mkvmuxer::kMkvCueClusterPosition) m_pos = UnserializeUInt(pReader, pos, size); - else if (id == libwebm::kMkvCueBlockNumber) + else if (id == mkvmuxer::kMkvCueBlockNumber) m_block = UnserializeUInt(pReader, pos, size); pos += size; // consume payload @@ -2554,7 +2555,7 @@ const Cluster* Segment::GetNext(const Cluster* pCurr) { return NULL; const long long id = ReadID(m_pReader, pos, len); - if (id != libwebm::kMkvCluster) + if (id != mkvmuxer::kMkvCluster) return NULL; pos += len; // consume ID @@ -2611,7 +2612,7 @@ const Cluster* Segment::GetNext(const Cluster* pCurr) { if (size == 0) // weird continue; - if (id == libwebm::kMkvCluster) { + if (id == mkvmuxer::kMkvCluster) { const long long off_next_ = idpos - m_start; long long pos_; @@ -2761,7 +2762,7 @@ long Segment::ParseNext(const Cluster* pCurr, const Cluster*& pResult, const long long id = ReadUInt(m_pReader, pos, len); - if (id != libwebm::kMkvCluster) + if (id != mkvmuxer::kMkvCluster) return -1; pos += len; // consume ID @@ -2926,7 +2927,7 @@ long Segment::DoParseNext(const Cluster*& pResult, long long& pos, long& len) { return E_FILE_FORMAT_INVALID; } - if (id == libwebm::kMkvCues) { + if (id == mkvmuxer::kMkvCues) { if (size == unknown_size) return E_FILE_FORMAT_INVALID; @@ -2952,7 +2953,7 @@ long Segment::DoParseNext(const Cluster*& pResult, long long& pos, long& len) { continue; } - if (id != libwebm::kMkvCluster) { // not a Cluster ID + if (id != mkvmuxer::kMkvCluster) { // not a Cluster ID if (size == unknown_size) return E_FILE_FORMAT_INVALID; @@ -3090,7 +3091,7 @@ long Segment::DoParseNext(const Cluster*& pResult, long long& pos, long& len) { // that we have exhausted the sub-element's inside the cluster // whose ID we parsed earlier. - if (id == libwebm::kMkvCluster || id == libwebm::kMkvCues) + if (id == mkvmuxer::kMkvCluster || id == mkvmuxer::kMkvCues) break; pos += len; // consume ID (of sub-element) @@ -3258,7 +3259,7 @@ long Chapters::Parse() { if (size == 0) // weird continue; - if (id == libwebm::kMkvEditionEntry) { + if (id == mkvmuxer::kMkvEditionEntry) { status = ParseEdition(pos, size); if (status < 0) // error @@ -3374,7 +3375,7 @@ long Chapters::Edition::Parse(IMkvReader* pReader, long long pos, if (size == 0) continue; - if (id == libwebm::kMkvChapterAtom) { + if (id == mkvmuxer::kMkvChapterAtom) { status = ParseAtom(pReader, pos, size); if (status < 0) // error @@ -3507,17 +3508,17 @@ long Chapters::Atom::Parse(IMkvReader* pReader, long long pos, long long size) { if (size == 0) // 0 length payload, skip. continue; - if (id == libwebm::kMkvChapterDisplay) { + if (id == mkvmuxer::kMkvChapterDisplay) { status = ParseDisplay(pReader, pos, size); if (status < 0) // error return status; - } else if (id == libwebm::kMkvChapterStringUID) { + } else if (id == mkvmuxer::kMkvChapterStringUID) { status = UnserializeString(pReader, pos, size, m_string_uid); if (status < 0) // error return status; - } else if (id == libwebm::kMkvChapterUID) { + } else if (id == mkvmuxer::kMkvChapterUID) { long long val; status = UnserializeInt(pReader, pos, size, val); @@ -3525,14 +3526,14 @@ long Chapters::Atom::Parse(IMkvReader* pReader, long long pos, long long size) { return status; m_uid = static_cast(val); - } else if (id == libwebm::kMkvChapterTimeStart) { + } else if (id == mkvmuxer::kMkvChapterTimeStart) { const long long val = UnserializeUInt(pReader, pos, size); if (val < 0) // error return static_cast(val); m_start_timecode = val; - } else if (id == libwebm::kMkvChapterTimeEnd) { + } else if (id == mkvmuxer::kMkvChapterTimeEnd) { const long long val = UnserializeUInt(pReader, pos, size); if (val < 0) // error @@ -3660,17 +3661,17 @@ long Chapters::Display::Parse(IMkvReader* pReader, long long pos, if (size == 0) // No payload. continue; - if (id == libwebm::kMkvChapString) { + if (id == mkvmuxer::kMkvChapString) { status = UnserializeString(pReader, pos, size, m_string); if (status) return status; - } else if (id == libwebm::kMkvChapLanguage) { + } else if (id == mkvmuxer::kMkvChapLanguage) { status = UnserializeString(pReader, pos, size, m_language); if (status) return status; - } else if (id == libwebm::kMkvChapCountry) { + } else if (id == mkvmuxer::kMkvChapCountry) { status = UnserializeString(pReader, pos, size, m_country); if (status) @@ -3723,7 +3724,7 @@ long Tags::Parse() { if (size == 0) // 0 length tag, read another continue; - if (id == libwebm::kMkvTag) { + if (id == mkvmuxer::kMkvTag) { status = ParseTag(pos, size); if (status < 0) @@ -3839,7 +3840,7 @@ long Tags::Tag::Parse(IMkvReader* pReader, long long pos, long long size) { if (size == 0) // 0 length tag, read another continue; - if (id == libwebm::kMkvSimpleTag) { + if (id == mkvmuxer::kMkvSimpleTag) { status = ParseSimpleTag(pReader, pos, size); if (status < 0) @@ -3930,12 +3931,12 @@ long Tags::SimpleTag::Parse(IMkvReader* pReader, long long pos, if (size == 0) // weird continue; - if (id == libwebm::kMkvTagName) { + if (id == mkvmuxer::kMkvTagName) { status = UnserializeString(pReader, pos, size, m_tag_name); if (status) return status; - } else if (id == libwebm::kMkvTagString) { + } else if (id == mkvmuxer::kMkvTagString) { status = UnserializeString(pReader, pos, size, m_tag_string); if (status) @@ -3995,12 +3996,12 @@ long SegmentInfo::Parse() { if (status < 0) // error return status; - if (id == libwebm::kMkvTimecodeScale) { + if (id == mkvmuxer::kMkvTimecodeScale) { m_timecodeScale = UnserializeUInt(pReader, pos, size); if (m_timecodeScale <= 0) return E_FILE_FORMAT_INVALID; - } else if (id == libwebm::kMkvDuration) { + } else if (id == mkvmuxer::kMkvDuration) { const long status = UnserializeFloat(pReader, pos, size, m_duration); if (status < 0) @@ -4008,19 +4009,19 @@ long SegmentInfo::Parse() { if (m_duration < 0) return E_FILE_FORMAT_INVALID; - } else if (id == libwebm::kMkvMuxingApp) { + } else if (id == mkvmuxer::kMkvMuxingApp) { const long status = UnserializeString(pReader, pos, size, m_pMuxingAppAsUTF8); if (status) return status; - } else if (id == libwebm::kMkvWritingApp) { + } else if (id == mkvmuxer::kMkvWritingApp) { const long status = UnserializeString(pReader, pos, size, m_pWritingAppAsUTF8); if (status) return status; - } else if (id == libwebm::kMkvTitle) { + } else if (id == mkvmuxer::kMkvTitle) { const long status = UnserializeString(pReader, pos, size, m_pTitleAsUTF8); if (status) @@ -4175,7 +4176,7 @@ long ContentEncoding::ParseContentEncAESSettingsEntry( if (status < 0) // error return status; - if (id == libwebm::kMkvAESSettingsCipherMode) { + if (id == mkvmuxer::kMkvAESSettingsCipherMode) { aes->cipher_mode = UnserializeUInt(pReader, pos, size); if (aes->cipher_mode != 1) return E_FILE_FORMAT_INVALID; @@ -4206,10 +4207,10 @@ long ContentEncoding::ParseContentEncodingEntry(long long start, long long size, if (status < 0) // error return status; - if (id == libwebm::kMkvContentCompression) + if (id == mkvmuxer::kMkvContentCompression) ++compression_count; - if (id == libwebm::kMkvContentEncryption) + if (id == mkvmuxer::kMkvContentEncryption) ++encryption_count; pos += size; // consume payload @@ -4245,15 +4246,15 @@ long ContentEncoding::ParseContentEncodingEntry(long long start, long long size, if (status < 0) // error return status; - if (id == libwebm::kMkvContentEncodingOrder) { + if (id == mkvmuxer::kMkvContentEncodingOrder) { encoding_order_ = UnserializeUInt(pReader, pos, size); - } else if (id == libwebm::kMkvContentEncodingScope) { + } else if (id == mkvmuxer::kMkvContentEncodingScope) { encoding_scope_ = UnserializeUInt(pReader, pos, size); if (encoding_scope_ < 1) return -1; - } else if (id == libwebm::kMkvContentEncodingType) { + } else if (id == mkvmuxer::kMkvContentEncodingType) { encoding_type_ = UnserializeUInt(pReader, pos, size); - } else if (id == libwebm::kMkvContentCompression) { + } else if (id == mkvmuxer::kMkvContentCompression) { ContentCompression* const compression = new (std::nothrow) ContentCompression(); if (!compression) @@ -4265,7 +4266,7 @@ long ContentEncoding::ParseContentEncodingEntry(long long start, long long size, return status; } *compression_entries_end_++ = compression; - } else if (id == libwebm::kMkvContentEncryption) { + } else if (id == mkvmuxer::kMkvContentEncryption) { ContentEncryption* const encryption = new (std::nothrow) ContentEncryption(); if (!encryption) @@ -4306,13 +4307,13 @@ long ContentEncoding::ParseCompressionEntry(long long start, long long size, if (status < 0) // error return status; - if (id == libwebm::kMkvContentCompAlgo) { + if (id == mkvmuxer::kMkvContentCompAlgo) { long long algo = UnserializeUInt(pReader, pos, size); if (algo < 0) return E_FILE_FORMAT_INVALID; compression->algo = algo; valid = true; - } else if (id == libwebm::kMkvContentCompSettings) { + } else if (id == mkvmuxer::kMkvContentCompSettings) { if (size <= 0) return E_FILE_FORMAT_INVALID; @@ -4359,11 +4360,11 @@ long ContentEncoding::ParseEncryptionEntry(long long start, long long size, if (status < 0) // error return status; - if (id == libwebm::kMkvContentEncAlgo) { + if (id == mkvmuxer::kMkvContentEncAlgo) { encryption->algo = UnserializeUInt(pReader, pos, size); if (encryption->algo != 5) return E_FILE_FORMAT_INVALID; - } else if (id == libwebm::kMkvContentEncKeyID) { + } else if (id == mkvmuxer::kMkvContentEncKeyID) { delete[] encryption->key_id; encryption->key_id = NULL; encryption->key_id_len = 0; @@ -4385,7 +4386,7 @@ long ContentEncoding::ParseEncryptionEntry(long long start, long long size, encryption->key_id = buf; encryption->key_id_len = buflen; - } else if (id == libwebm::kMkvContentSignature) { + } else if (id == mkvmuxer::kMkvContentSignature) { delete[] encryption->signature; encryption->signature = NULL; encryption->signature_len = 0; @@ -4407,7 +4408,7 @@ long ContentEncoding::ParseEncryptionEntry(long long start, long long size, encryption->signature = buf; encryption->signature_len = buflen; - } else if (id == libwebm::kMkvContentSigKeyID) { + } else if (id == mkvmuxer::kMkvContentSigKeyID) { delete[] encryption->sig_key_id; encryption->sig_key_id = NULL; encryption->sig_key_id_len = 0; @@ -4429,11 +4430,11 @@ long ContentEncoding::ParseEncryptionEntry(long long start, long long size, encryption->sig_key_id = buf; encryption->sig_key_id_len = buflen; - } else if (id == libwebm::kMkvContentSigAlgo) { + } else if (id == mkvmuxer::kMkvContentSigAlgo) { encryption->sig_algo = UnserializeUInt(pReader, pos, size); - } else if (id == libwebm::kMkvContentSigHashAlgo) { + } else if (id == mkvmuxer::kMkvContentSigHashAlgo) { encryption->sig_hash_algo = UnserializeUInt(pReader, pos, size); - } else if (id == libwebm::kMkvContentEncAESSettings) { + } else if (id == mkvmuxer::kMkvContentEncAESSettings) { const long status = ParseContentEncAESSettingsEntry( pos, size, pReader, &encryption->aes_settings); if (status) @@ -4920,7 +4921,7 @@ long Track::ParseContentEncodingsEntry(long long start, long long size) { return status; // pos now designates start of element - if (id == libwebm::kMkvContentEncoding) + if (id == mkvmuxer::kMkvContentEncoding) ++count; pos += size; // consume payload @@ -4945,7 +4946,7 @@ long Track::ParseContentEncodingsEntry(long long start, long long size) { return status; // pos now designates start of element - if (id == libwebm::kMkvContentEncoding) { + if (id == mkvmuxer::kMkvContentEncoding) { ContentEncoding* const content_encoding = new (std::nothrow) ContentEncoding(); if (!content_encoding) @@ -4977,222 +4978,9 @@ BlockEntry::Kind Track::EOSBlock::GetKind() const { return kBlockEOS; } const Block* Track::EOSBlock::GetBlock() const { return NULL; } -bool PrimaryChromaticity::Parse(IMkvReader* reader, long long read_pos, - long long value_size, bool is_x, - PrimaryChromaticity** chromaticity) { - if (!reader) - return false; - - std::auto_ptr chromaticity_ptr; - - if (!*chromaticity) { - chromaticity_ptr.reset(new PrimaryChromaticity()); - } else { - chromaticity_ptr.reset(*chromaticity); - } - - if (!chromaticity_ptr.get()) - return false; - - float* value = is_x ? &chromaticity_ptr->x : &chromaticity_ptr->y; - - double parser_value = 0; - const long long value_parse_status = - UnserializeFloat(reader, read_pos, value_size, parser_value); - - *value = static_cast(parser_value); - - if (value_parse_status < 0 || *value < 0.0 || *value > 1.0) - return false; - - *chromaticity = chromaticity_ptr.release(); - return true; -} - -bool MasteringMetadata::Parse(IMkvReader* reader, long long mm_start, - long long mm_size, MasteringMetadata** mm) { - if (!reader || *mm) - return false; - - std::auto_ptr mm_ptr(new MasteringMetadata()); - if (!mm_ptr.get()) - return false; - - const long long mm_end = mm_start + mm_size; - long long read_pos = mm_start; - - while (read_pos < mm_end) { - long long child_id = 0; - long long child_size = 0; - - const long long status = - ParseElementHeader(reader, read_pos, mm_end, child_id, child_size); - if (status < 0) - return false; - - if (child_id == libwebm::kMkvLuminanceMax) { - double value = 0; - const long long value_parse_status = - UnserializeFloat(reader, read_pos, child_size, value); - mm_ptr->luminance_max = static_cast(value); - if (value_parse_status < 0 || mm_ptr->luminance_max < 0.0 || - mm_ptr->luminance_max > 9999.99) { - return false; - } - } else if (child_id == libwebm::kMkvLuminanceMin) { - double value = 0; - const long long value_parse_status = - UnserializeFloat(reader, read_pos, child_size, value); - mm_ptr->luminance_min = static_cast(value); - if (value_parse_status < 0 || mm_ptr->luminance_min < 0.0 || - mm_ptr->luminance_min > 999.9999) { - return false; - } - } else { - bool is_x = false; - PrimaryChromaticity** chromaticity; - switch (child_id) { - case libwebm::kMkvPrimaryRChromaticityX: - case libwebm::kMkvPrimaryRChromaticityY: - is_x = child_id == libwebm::kMkvPrimaryRChromaticityX; - chromaticity = &mm_ptr->r; - break; - case libwebm::kMkvPrimaryGChromaticityX: - case libwebm::kMkvPrimaryGChromaticityY: - is_x = child_id == libwebm::kMkvPrimaryGChromaticityX; - chromaticity = &mm_ptr->g; - break; - case libwebm::kMkvPrimaryBChromaticityX: - case libwebm::kMkvPrimaryBChromaticityY: - is_x = child_id == libwebm::kMkvPrimaryBChromaticityX; - chromaticity = &mm_ptr->b; - break; - case libwebm::kMkvWhitePointChromaticityX: - case libwebm::kMkvWhitePointChromaticityY: - is_x = child_id == libwebm::kMkvWhitePointChromaticityX; - chromaticity = &mm_ptr->white_point; - break; - default: - return false; - } - const bool value_parse_status = PrimaryChromaticity::Parse( - reader, read_pos, child_size, is_x, chromaticity); - if (!value_parse_status) - return false; - } - - read_pos += child_size; - if (read_pos > mm_end) - return false; - } - - *mm = mm_ptr.release(); - return true; -} - -bool Colour::Parse(IMkvReader* reader, long long colour_start, - long long colour_size, Colour** colour) { - if (!reader || *colour) - return false; - - std::auto_ptr colour_ptr(new Colour()); - if (!colour_ptr.get()) - return false; - - const long long colour_end = colour_start + colour_size; - long long read_pos = colour_start; - - while (read_pos < colour_end) { - long long child_id = 0; - long long child_size = 0; - - const long status = - ParseElementHeader(reader, read_pos, colour_end, child_id, child_size); - if (status < 0) - return false; - - if (child_id == libwebm::kMkvMatrixCoefficients) { - colour_ptr->matrix_coefficients = - UnserializeUInt(reader, read_pos, child_size); - if (colour_ptr->matrix_coefficients < 0) - return false; - } else if (child_id == libwebm::kMkvBitsPerChannel) { - colour_ptr->bits_per_channel = - UnserializeUInt(reader, read_pos, child_size); - if (colour_ptr->bits_per_channel < 0) - return false; - } else if (child_id == libwebm::kMkvChromaSubsamplingHorz) { - colour_ptr->chroma_subsampling_horz = - UnserializeUInt(reader, read_pos, child_size); - if (colour_ptr->chroma_subsampling_horz < 0) - return false; - } else if (child_id == libwebm::kMkvChromaSubsamplingVert) { - colour_ptr->chroma_subsampling_vert = - UnserializeUInt(reader, read_pos, child_size); - if (colour_ptr->chroma_subsampling_vert < 0) - return false; - } else if (child_id == libwebm::kMkvCbSubsamplingHorz) { - colour_ptr->cb_subsampling_horz = - UnserializeUInt(reader, read_pos, child_size); - if (colour_ptr->cb_subsampling_horz < 0) - return false; - } else if (child_id == libwebm::kMkvCbSubsamplingVert) { - colour_ptr->cb_subsampling_vert = - UnserializeUInt(reader, read_pos, child_size); - if (colour_ptr->cb_subsampling_vert < 0) - return false; - } else if (child_id == libwebm::kMkvChromaSitingHorz) { - colour_ptr->chroma_siting_horz = - UnserializeUInt(reader, read_pos, child_size); - if (colour_ptr->chroma_siting_horz < 0) - return false; - } else if (child_id == libwebm::kMkvChromaSitingVert) { - colour_ptr->chroma_siting_vert = - UnserializeUInt(reader, read_pos, child_size); - if (colour_ptr->chroma_siting_vert < 0) - return false; - } else if (child_id == libwebm::kMkvRange) { - colour_ptr->range = UnserializeUInt(reader, read_pos, child_size); - if (colour_ptr->range < 0) - return false; - } else if (child_id == libwebm::kMkvTransferCharacteristics) { - colour_ptr->transfer_characteristics = - UnserializeUInt(reader, read_pos, child_size); - if (colour_ptr->transfer_characteristics < 0) - return false; - } else if (child_id == libwebm::kMkvPrimaries) { - colour_ptr->primaries = UnserializeUInt(reader, read_pos, child_size); - if (colour_ptr->primaries < 0) - return false; - } else if (child_id == libwebm::kMkvMaxCLL) { - colour_ptr->max_cll = UnserializeUInt(reader, read_pos, child_size); - if (colour_ptr->max_cll < 0) - return false; - } else if (child_id == libwebm::kMkvMaxFALL) { - colour_ptr->max_fall = UnserializeUInt(reader, read_pos, child_size); - if (colour_ptr->max_fall < 0) - return false; - } else if (child_id == libwebm::kMkvMasteringMetadata) { - if (!MasteringMetadata::Parse(reader, read_pos, child_size, - &colour_ptr->mastering_metadata)) - return false; - } else { - return false; - } - - read_pos += child_size; - if (read_pos > colour_end) - return false; - } - *colour = colour_ptr.release(); - return true; -} - VideoTrack::VideoTrack(Segment* pSegment, long long element_start, long long element_size) - : Track(pSegment, element_start, element_size), m_colour(NULL) {} - -VideoTrack::~VideoTrack() { delete m_colour; } + : Track(pSegment, element_start, element_size) {} long VideoTrack::Parse(Segment* pSegment, const Info& info, long long element_start, long long element_size, @@ -5223,8 +5011,6 @@ long VideoTrack::Parse(Segment* pSegment, const Info& info, const long long stop = pos + s.size; - Colour* colour = NULL; - while (pos < stop) { long long id, size; @@ -5233,37 +5019,37 @@ long VideoTrack::Parse(Segment* pSegment, const Info& info, if (status < 0) // error return status; - if (id == libwebm::kMkvPixelWidth) { + if (id == mkvmuxer::kMkvPixelWidth) { width = UnserializeUInt(pReader, pos, size); if (width <= 0) return E_FILE_FORMAT_INVALID; - } else if (id == libwebm::kMkvPixelHeight) { + } else if (id == mkvmuxer::kMkvPixelHeight) { height = UnserializeUInt(pReader, pos, size); if (height <= 0) return E_FILE_FORMAT_INVALID; - } else if (id == libwebm::kMkvDisplayWidth) { + } else if (id == mkvmuxer::kMkvDisplayWidth) { display_width = UnserializeUInt(pReader, pos, size); if (display_width <= 0) return E_FILE_FORMAT_INVALID; - } else if (id == libwebm::kMkvDisplayHeight) { + } else if (id == mkvmuxer::kMkvDisplayHeight) { display_height = UnserializeUInt(pReader, pos, size); if (display_height <= 0) return E_FILE_FORMAT_INVALID; - } else if (id == libwebm::kMkvDisplayUnit) { + } else if (id == mkvmuxer::kMkvDisplayUnit) { display_unit = UnserializeUInt(pReader, pos, size); if (display_unit < 0) return E_FILE_FORMAT_INVALID; - } else if (id == libwebm::kMkvStereoMode) { + } else if (id == mkvmuxer::kMkvStereoMode) { stereo_mode = UnserializeUInt(pReader, pos, size); if (stereo_mode < 0) return E_FILE_FORMAT_INVALID; - } else if (id == libwebm::kMkvFrameRate) { + } else if (id == mkvmuxer::kMkvFrameRate) { const long status = UnserializeFloat(pReader, pos, size, rate); if (status < 0) @@ -5271,9 +5057,6 @@ long VideoTrack::Parse(Segment* pSegment, const Info& info, if (rate <= 0) return E_FILE_FORMAT_INVALID; - } else if (id == libwebm::kMkvColour) { - if (!Colour::Parse(pReader, pos, size, &colour)) - return E_FILE_FORMAT_INVALID; } pos += size; // consume payload @@ -5304,7 +5087,6 @@ long VideoTrack::Parse(Segment* pSegment, const Info& info, pTrack->m_display_unit = display_unit; pTrack->m_stereo_mode = stereo_mode; pTrack->m_rate = rate; - pTrack->m_colour = colour; pResult = pTrack; return 0; // success @@ -5403,8 +5185,6 @@ long VideoTrack::Seek(long long time_ns, const BlockEntry*& pResult) const { return 0; } -Colour* VideoTrack::GetColour() const { return m_colour; } - long long VideoTrack::GetWidth() const { return m_width; } long long VideoTrack::GetHeight() const { return m_height; } @@ -5459,7 +5239,7 @@ long AudioTrack::Parse(Segment* pSegment, const Info& info, if (status < 0) // error return status; - if (id == libwebm::kMkvSamplingFrequency) { + if (id == mkvmuxer::kMkvSamplingFrequency) { status = UnserializeFloat(pReader, pos, size, rate); if (status < 0) @@ -5467,12 +5247,12 @@ long AudioTrack::Parse(Segment* pSegment, const Info& info, if (rate <= 0) return E_FILE_FORMAT_INVALID; - } else if (id == libwebm::kMkvChannels) { + } else if (id == mkvmuxer::kMkvChannels) { channels = UnserializeUInt(pReader, pos, size); if (channels <= 0) return E_FILE_FORMAT_INVALID; - } else if (id == libwebm::kMkvBitDepth) { + } else if (id == mkvmuxer::kMkvBitDepth) { bit_depth = UnserializeUInt(pReader, pos, size); if (bit_depth <= 0) @@ -5545,7 +5325,7 @@ long Tracks::Parse() { if (size == 0) // weird continue; - if (id == libwebm::kMkvTrackEntry) + if (id == mkvmuxer::kMkvTrackEntry) ++count; pos += size; // consume payload @@ -5587,7 +5367,7 @@ long Tracks::Parse() { const long long element_size = payload_stop - element_start; - if (id == libwebm::kMkvTrackEntry) { + if (id == mkvmuxer::kMkvTrackEntry) { Track*& pTrack = *m_trackEntriesEnd; pTrack = NULL; @@ -5663,16 +5443,16 @@ long Tracks::ParseTrackEntry(long long track_start, long long track_size, const long long start = pos; - if (id == libwebm::kMkvVideo) { + if (id == mkvmuxer::kMkvVideo) { v.start = start; v.size = size; - } else if (id == libwebm::kMkvAudio) { + } else if (id == mkvmuxer::kMkvAudio) { a.start = start; a.size = size; - } else if (id == libwebm::kMkvContentEncodings) { + } else if (id == mkvmuxer::kMkvContentEncodings) { e.start = start; e.size = size; - } else if (id == libwebm::kMkvTrackUID) { + } else if (id == mkvmuxer::kMkvTrackUID) { if (size > 8) return E_FILE_FORMAT_INVALID; @@ -5694,49 +5474,49 @@ long Tracks::ParseTrackEntry(long long track_start, long long track_size, ++pos_; } - } else if (id == libwebm::kMkvTrackNumber) { + } else if (id == mkvmuxer::kMkvTrackNumber) { const long long num = UnserializeUInt(pReader, pos, size); if ((num <= 0) || (num > 127)) return E_FILE_FORMAT_INVALID; info.number = static_cast(num); - } else if (id == libwebm::kMkvTrackType) { + } else if (id == mkvmuxer::kMkvTrackType) { const long long type = UnserializeUInt(pReader, pos, size); if ((type <= 0) || (type > 254)) return E_FILE_FORMAT_INVALID; info.type = static_cast(type); - } else if (id == libwebm::kMkvName) { + } else if (id == mkvmuxer::kMkvName) { const long status = UnserializeString(pReader, pos, size, info.nameAsUTF8); if (status) return status; - } else if (id == libwebm::kMkvLanguage) { + } else if (id == mkvmuxer::kMkvLanguage) { const long status = UnserializeString(pReader, pos, size, info.language); if (status) return status; - } else if (id == libwebm::kMkvDefaultDuration) { + } else if (id == mkvmuxer::kMkvDefaultDuration) { const long long duration = UnserializeUInt(pReader, pos, size); if (duration < 0) return E_FILE_FORMAT_INVALID; info.defaultDuration = static_cast(duration); - } else if (id == libwebm::kMkvCodecID) { + } else if (id == mkvmuxer::kMkvCodecID) { const long status = UnserializeString(pReader, pos, size, info.codecId); if (status) return status; - } else if (id == libwebm::kMkvFlagLacing) { + } else if (id == mkvmuxer::kMkvFlagLacing) { lacing = UnserializeUInt(pReader, pos, size); if ((lacing < 0) || (lacing > 1)) return E_FILE_FORMAT_INVALID; - } else if (id == libwebm::kMkvCodecPrivate) { + } else if (id == mkvmuxer::kMkvCodecPrivate) { delete[] info.codecPrivate; info.codecPrivate = NULL; info.codecPrivateSize = 0; @@ -5759,15 +5539,15 @@ long Tracks::ParseTrackEntry(long long track_start, long long track_size, info.codecPrivate = buf; info.codecPrivateSize = buflen; } - } else if (id == libwebm::kMkvCodecName) { + } else if (id == mkvmuxer::kMkvCodecName) { const long status = UnserializeString(pReader, pos, size, info.codecNameAsUTF8); if (status) return status; - } else if (id == libwebm::kMkvCodecDelay) { + } else if (id == mkvmuxer::kMkvCodecDelay) { info.codecDelay = UnserializeUInt(pReader, pos, size); - } else if (id == libwebm::kMkvSeekPreRoll) { + } else if (id == mkvmuxer::kMkvSeekPreRoll) { info.seekPreRoll = UnserializeUInt(pReader, pos, size); } @@ -5950,7 +5730,7 @@ long Cluster::Load(long long& pos, long& len) const { if (id_ < 0) // error return static_cast(id_); - if (id_ != libwebm::kMkvCluster) + if (id_ != mkvmuxer::kMkvCluster) return E_FILE_FORMAT_INVALID; pos += len; // consume id @@ -6032,10 +5812,10 @@ long Cluster::Load(long long& pos, long& len) const { // that we have exhausted the sub-element's inside the cluster // whose ID we parsed earlier. - if (id == libwebm::kMkvCluster) + if (id == mkvmuxer::kMkvCluster) break; - if (id == libwebm::kMkvCues) + if (id == mkvmuxer::kMkvCues) break; pos += len; // consume ID field @@ -6084,7 +5864,7 @@ long Cluster::Load(long long& pos, long& len) const { if ((cluster_stop >= 0) && ((pos + size) > cluster_stop)) return E_FILE_FORMAT_INVALID; - if (id == libwebm::kMkvTimecode) { + if (id == mkvmuxer::kMkvTimecode) { len = static_cast(size); if ((pos + size) > avail) @@ -6099,10 +5879,10 @@ long Cluster::Load(long long& pos, long& len) const { if (bBlock) break; - } else if (id == libwebm::kMkvBlockGroup) { + } else if (id == mkvmuxer::kMkvBlockGroup) { bBlock = true; break; - } else if (id == libwebm::kMkvSimpleBlock) { + } else if (id == mkvmuxer::kMkvSimpleBlock) { bBlock = true; break; } @@ -6200,7 +5980,7 @@ long Cluster::Parse(long long& pos, long& len) const { // that we have exhausted the sub-element's inside the cluster // whose ID we parsed earlier. - if ((id == libwebm::kMkvCluster) || (id == libwebm::kMkvCues)) { + if ((id == mkvmuxer::kMkvCluster) || (id == mkvmuxer::kMkvCues)) { if (m_element_size < 0) m_element_size = pos - m_element_start; @@ -6255,7 +6035,8 @@ long Cluster::Parse(long long& pos, long& len) const { if (cluster_stop >= 0) { if (block_stop > cluster_stop) { - if (id == libwebm::kMkvBlockGroup || id == libwebm::kMkvSimpleBlock) { + if (id == mkvmuxer::kMkvBlockGroup || + id == mkvmuxer::kMkvSimpleBlock) { return E_FILE_FORMAT_INVALID; } @@ -6273,10 +6054,10 @@ long Cluster::Parse(long long& pos, long& len) const { Cluster* const this_ = const_cast(this); - if (id == libwebm::kMkvBlockGroup) + if (id == mkvmuxer::kMkvBlockGroup) return this_->ParseBlockGroup(size, pos, len); - if (id == libwebm::kMkvSimpleBlock) + if (id == mkvmuxer::kMkvSimpleBlock) return this_->ParseSimpleBlock(size, pos, len); pos += size; // consume payload @@ -6407,7 +6188,8 @@ long Cluster::ParseSimpleBlock(long long block_size, long long& pos, return E_BUFFER_NOT_FULL; } - status = CreateBlock(libwebm::kMkvSimpleBlock, block_start, block_size, + status = CreateBlock(mkvmuxer::kMkvSimpleBlock, + block_start, block_size, 0); // DiscardPadding if (status != 0) @@ -6517,14 +6299,14 @@ long Cluster::ParseBlockGroup(long long payload_size, long long& pos, if (size == unknown_size) return E_FILE_FORMAT_INVALID; - if (id == libwebm::kMkvDiscardPadding) { + if (id == mkvmuxer::kMkvDiscardPadding) { status = UnserializeInt(pReader, pos, size, discard_padding); if (status < 0) // error return status; } - if (id != libwebm::kMkvBlock) { + if (id != mkvmuxer::kMkvBlock) { pos += size; // consume sub-part of block group if (pos > payload_stop) @@ -6617,8 +6399,8 @@ long Cluster::ParseBlockGroup(long long payload_size, long long& pos, if (pos != payload_stop) return E_FILE_FORMAT_INVALID; - status = CreateBlock(libwebm::kMkvBlockGroup, payload_start, payload_size, - discard_padding); + status = CreateBlock(mkvmuxer::kMkvBlockGroup, + payload_start, payload_size, discard_padding); if (status != 0) return status; @@ -6783,7 +6565,7 @@ long Cluster::HasBlockEntries( if (id < 0) // error return static_cast(id); - if (id != libwebm::kMkvCluster) + if (id != mkvmuxer::kMkvCluster) return E_PARSE_FAILED; pos += len; // consume Cluster ID field @@ -6871,10 +6653,10 @@ long Cluster::HasBlockEntries( // that we have exhausted the sub-element's inside the cluster // whose ID we parsed earlier. - if (id == libwebm::kMkvCluster) + if (id == mkvmuxer::kMkvCluster) return 0; // no entries found - if (id == libwebm::kMkvCues) + if (id == mkvmuxer::kMkvCues) return 0; // no entries found pos += len; // consume id field @@ -6926,10 +6708,10 @@ long Cluster::HasBlockEntries( if ((cluster_stop >= 0) && ((pos + size) > cluster_stop)) return E_FILE_FORMAT_INVALID; - if (id == libwebm::kMkvBlockGroup) + if (id == mkvmuxer::kMkvBlockGroup) return 1; // have at least one entry - if (id == libwebm::kMkvSimpleBlock) + if (id == mkvmuxer::kMkvSimpleBlock) return 1; // have at least one entry pos += size; // consume payload @@ -7004,7 +6786,7 @@ long long Cluster::GetLastTime() const { long Cluster::CreateBlock(long long id, long long pos, // absolute pos of payload long long size, long long discard_padding) { - if (id != libwebm::kMkvBlockGroup && id != libwebm::kMkvSimpleBlock) + if (id != mkvmuxer::kMkvBlockGroup && id != mkvmuxer::kMkvSimpleBlock) return E_PARSE_FAILED; if (m_entries_count < 0) { // haven't parsed anything yet @@ -7044,7 +6826,7 @@ long Cluster::CreateBlock(long long id, } } - if (id == libwebm::kMkvBlockGroup) + if (id == mkvmuxer::kMkvBlockGroup) return CreateBlockGroup(pos, size, discard_padding); else return CreateSimpleBlock(pos, size); @@ -7089,12 +6871,12 @@ long Cluster::CreateBlockGroup(long long start_offset, long long size, pos += len; // consume size - if (id == libwebm::kMkvBlock) { + if (id == mkvmuxer::kMkvBlock) { if (bpos < 0) { // Block ID bpos = pos; bsize = size; } - } else if (id == libwebm::kMkvBlockDuration) { + } else if (id == mkvmuxer::kMkvBlockDuration) { if (size > 8) return E_FILE_FORMAT_INVALID; @@ -7102,7 +6884,7 @@ long Cluster::CreateBlockGroup(long long start_offset, long long size, if (duration < 0) return E_FILE_FORMAT_INVALID; - } else if (id == libwebm::kMkvReferenceBlock) { + } else if (id == mkvmuxer::kMkvReferenceBlock) { if (size > 8 || size <= 0) return E_FILE_FORMAT_INVALID; const long size_ = static_cast(size); @@ -7449,6 +7231,7 @@ const BlockEntry* Cluster::GetEntry(const CuePoint& cp, BlockEntry::BlockEntry(Cluster* p, long idx) : m_pCluster(p), m_index(idx) {} BlockEntry::~BlockEntry() {} +bool BlockEntry::EOS() const { return (GetKind() == kBlockEOS); } const Cluster* BlockEntry::GetCluster() const { return m_pCluster; } long BlockEntry::GetIndex() const { return m_index; } @@ -7772,6 +7555,7 @@ long Block::Parse(const Cluster* pCluster) { if (pf >= pf_end) return E_FILE_FORMAT_INVALID; + const Frame& prev = *pf++; assert(prev.len == frame_size); if (prev.len != frame_size) @@ -7937,4 +7721,4 @@ long Block::Frame::Read(IMkvReader* pReader, unsigned char* buf) const { long long Block::GetDiscardPadding() const { return m_discard_padding; } -} // namespace mkvparser +} // end namespace mkvparser diff --git a/third_party/libwebm/mkvparser/mkvparser.h b/third_party/libwebm/mkvparser.hpp similarity index 90% rename from third_party/libwebm/mkvparser/mkvparser.h rename to third_party/libwebm/mkvparser.hpp index 42e6e88ab..75ef69d76 100644 --- a/third_party/libwebm/mkvparser/mkvparser.h +++ b/third_party/libwebm/mkvparser.hpp @@ -5,10 +5,13 @@ // tree. An additional intellectual property rights grant can be found // in the file PATENTS. All contributing project authors may // be found in the AUTHORS file in the root of the source tree. -#ifndef MKVPARSER_MKVPARSER_H_ -#define MKVPARSER_MKVPARSER_H_ + +#ifndef MKVPARSER_HPP +#define MKVPARSER_HPP #include +#include +#include namespace mkvparser { @@ -25,9 +28,8 @@ class IMkvReader { virtual ~IMkvReader(); }; -template -Type* SafeArrayAlloc(unsigned long long num_elements, - unsigned long long element_size); +template Type* SafeArrayAlloc(unsigned long long num_elements, + unsigned long long element_size); long long GetUIntLength(IMkvReader*, long long, long&); long long ReadUInt(IMkvReader*, long long, long&); long long ReadID(IMkvReader* pReader, long long pos, long& len); @@ -126,7 +128,7 @@ class BlockEntry { public: virtual ~BlockEntry(); - bool EOS() const { return (GetKind() == kBlockEOS); } + bool EOS() const; const Cluster* GetCluster() const; long GetIndex() const; virtual const Block* GetBlock() const = 0; @@ -389,90 +391,6 @@ class Track { ContentEncoding** content_encoding_entries_end_; }; -struct PrimaryChromaticity { - PrimaryChromaticity() : x(0), y(0) {} - ~PrimaryChromaticity() {} - static bool Parse(IMkvReader* reader, long long read_pos, - long long value_size, bool is_x, - PrimaryChromaticity** chromaticity); - float x; - float y; -}; - -struct MasteringMetadata { - static const float kValueNotPresent; - - MasteringMetadata() - : r(NULL), - g(NULL), - b(NULL), - white_point(NULL), - luminance_max(kValueNotPresent), - luminance_min(kValueNotPresent) {} - ~MasteringMetadata() { - delete r; - delete g; - delete b; - delete white_point; - } - - static bool Parse(IMkvReader* reader, long long element_start, - long long element_size, - MasteringMetadata** mastering_metadata); - - PrimaryChromaticity* r; - PrimaryChromaticity* g; - PrimaryChromaticity* b; - PrimaryChromaticity* white_point; - float luminance_max; - float luminance_min; -}; - -struct Colour { - static const long long kValueNotPresent; - - // Unless otherwise noted all values assigned upon construction are the - // equivalent of unspecified/default. - Colour() - : matrix_coefficients(kValueNotPresent), - bits_per_channel(kValueNotPresent), - chroma_subsampling_horz(kValueNotPresent), - chroma_subsampling_vert(kValueNotPresent), - cb_subsampling_horz(kValueNotPresent), - cb_subsampling_vert(kValueNotPresent), - chroma_siting_horz(kValueNotPresent), - chroma_siting_vert(kValueNotPresent), - range(kValueNotPresent), - transfer_characteristics(kValueNotPresent), - primaries(kValueNotPresent), - max_cll(kValueNotPresent), - max_fall(kValueNotPresent), - mastering_metadata(NULL) {} - ~Colour() { - delete mastering_metadata; - mastering_metadata = NULL; - } - - static bool Parse(IMkvReader* reader, long long element_start, - long long element_size, Colour** colour); - - long long matrix_coefficients; - long long bits_per_channel; - long long chroma_subsampling_horz; - long long chroma_subsampling_vert; - long long cb_subsampling_horz; - long long cb_subsampling_vert; - long long chroma_siting_horz; - long long chroma_siting_vert; - long long range; - long long transfer_characteristics; - long long primaries; - long long max_cll; - long long max_fall; - - MasteringMetadata* mastering_metadata; -}; - class VideoTrack : public Track { VideoTrack(const VideoTrack&); VideoTrack& operator=(const VideoTrack&); @@ -480,7 +398,6 @@ class VideoTrack : public Track { VideoTrack(Segment*, long long element_start, long long element_size); public: - virtual ~VideoTrack(); static long Parse(Segment*, const Info&, long long element_start, long long element_size, VideoTrack*&); @@ -495,8 +412,6 @@ class VideoTrack : public Track { bool VetEntry(const BlockEntry*) const; long Seek(long long time_ns, const BlockEntry*&) const; - Colour* GetColour() const; - private: long long m_width; long long m_height; @@ -506,8 +421,6 @@ class VideoTrack : public Track { long long m_stereo_mode; double m_rate; - - Colour* m_colour; }; class AudioTrack : public Track { @@ -1100,7 +1013,7 @@ class Segment { const BlockEntry* GetBlock(const CuePoint&, const CuePoint::TrackPosition&); }; -} // namespace mkvparser +} // end namespace mkvparser inline long mkvparser::Segment::LoadCluster() { long long pos; @@ -1109,4 +1022,4 @@ inline long mkvparser::Segment::LoadCluster() { return LoadCluster(pos, size); } -#endif // MKVPARSER_MKVPARSER_H_ +#endif // MKVPARSER_HPP diff --git a/third_party/libwebm/mkvparser/mkvreader.cc b/third_party/libwebm/mkvreader.cpp similarity index 97% rename from third_party/libwebm/mkvparser/mkvreader.cc rename to third_party/libwebm/mkvreader.cpp index 9f90d8c4f..eaf9e0a79 100644 --- a/third_party/libwebm/mkvparser/mkvreader.cc +++ b/third_party/libwebm/mkvreader.cpp @@ -5,7 +5,8 @@ // 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 "mkvparser/mkvreader.h" + +#include "mkvreader.hpp" #include @@ -128,4 +129,4 @@ int MkvReader::Read(long long offset, long len, unsigned char* buffer) { return 0; // success } -} // namespace mkvparser \ No newline at end of file +} // end namespace mkvparser diff --git a/third_party/libwebm/mkvparser/mkvreader.h b/third_party/libwebm/mkvreader.hpp similarity index 87% rename from third_party/libwebm/mkvparser/mkvreader.h rename to third_party/libwebm/mkvreader.hpp index 9831ecf64..82ebad544 100644 --- a/third_party/libwebm/mkvparser/mkvreader.h +++ b/third_party/libwebm/mkvreader.hpp @@ -5,13 +5,13 @@ // tree. An additional intellectual property rights grant can be found // in the file PATENTS. All contributing project authors may // be found in the AUTHORS file in the root of the source tree. -#ifndef MKVPARSER_MKVREADER_H_ -#define MKVPARSER_MKVREADER_H_ +#ifndef MKVREADER_HPP +#define MKVREADER_HPP + +#include "mkvparser.hpp" #include -#include "mkvparser/mkvparser.h" - namespace mkvparser { class MkvReader : public IMkvReader { @@ -40,6 +40,6 @@ class MkvReader : public IMkvReader { bool reader_owns_file_; }; -} // namespace mkvparser +} // end namespace mkvparser -#endif // MKVPARSER_MKVREADER_H_ +#endif // MKVREADER_HPP diff --git a/third_party/libwebm/mkvmuxer/mkvwriter.cc b/third_party/libwebm/mkvwriter.cpp similarity index 87% rename from third_party/libwebm/mkvmuxer/mkvwriter.cc rename to third_party/libwebm/mkvwriter.cpp index d7d6de9b6..75d4350c7 100644 --- a/third_party/libwebm/mkvmuxer/mkvwriter.cc +++ b/third_party/libwebm/mkvwriter.cpp @@ -6,12 +6,14 @@ // in the file PATENTS. All contributing project authors may // be found in the AUTHORS file in the root of the source tree. -#include "mkvmuxer/mkvwriter.h" +#include "mkvwriter.hpp" #ifdef _MSC_VER #include // for _SH_DENYWR #endif +#include + namespace mkvmuxer { MkvWriter::MkvWriter() : file_(NULL), writer_owns_file_(true) {} @@ -20,7 +22,7 @@ MkvWriter::MkvWriter(FILE* fp) : file_(fp), writer_owns_file_(false) {} MkvWriter::~MkvWriter() { Close(); } -int32_t MkvWriter::Write(const void* buffer, uint32_t length) { +int32 MkvWriter::Write(const void* buffer, uint32 length) { if (!file_) return -1; @@ -59,7 +61,7 @@ void MkvWriter::Close() { file_ = NULL; } -int64_t MkvWriter::Position() const { +int64 MkvWriter::Position() const { if (!file_) return 0; @@ -70,7 +72,7 @@ int64_t MkvWriter::Position() const { #endif } -int32_t MkvWriter::Position(int64_t position) { +int32 MkvWriter::Position(int64 position) { if (!file_) return -1; @@ -83,6 +85,6 @@ int32_t MkvWriter::Position(int64_t position) { bool MkvWriter::Seekable() const { return true; } -void MkvWriter::ElementStartNotify(uint64_t, int64_t) {} +void MkvWriter::ElementStartNotify(uint64, int64) {} } // namespace mkvmuxer diff --git a/third_party/libwebm/mkvmuxer/mkvwriter.h b/third_party/libwebm/mkvwriter.hpp similarity index 72% rename from third_party/libwebm/mkvmuxer/mkvwriter.h rename to third_party/libwebm/mkvwriter.hpp index ea6656e6f..684560c92 100644 --- a/third_party/libwebm/mkvmuxer/mkvwriter.h +++ b/third_party/libwebm/mkvwriter.hpp @@ -6,13 +6,13 @@ // in the file PATENTS. All contributing project authors may // be found in the AUTHORS file in the root of the source tree. -#ifndef MKVMUXER_MKVWRITER_H_ -#define MKVMUXER_MKVWRITER_H_ +#ifndef MKVWRITER_HPP +#define MKVWRITER_HPP #include -#include "mkvmuxer/mkvmuxer.h" -#include "mkvmuxer/mkvmuxertypes.h" +#include "mkvmuxer.hpp" +#include "mkvmuxertypes.hpp" namespace mkvmuxer { @@ -24,11 +24,11 @@ class MkvWriter : public IMkvWriter { virtual ~MkvWriter(); // IMkvWriter interface - virtual int64_t Position() const; - virtual int32_t Position(int64_t position); + virtual int64 Position() const; + virtual int32 Position(int64 position); virtual bool Seekable() const; - virtual int32_t Write(const void* buffer, uint32_t length); - virtual void ElementStartNotify(uint64_t element_id, int64_t position); + virtual int32 Write(const void* buffer, uint32 length); + virtual void ElementStartNotify(uint64 element_id, int64 position); // Creates and opens a file for writing. |filename| is the name of the file // to open. This function will overwrite the contents of |filename|. Returns @@ -46,6 +46,6 @@ class MkvWriter : public IMkvWriter { LIBWEBM_DISALLOW_COPY_AND_ASSIGN(MkvWriter); }; -} // namespace mkvmuxer +} // end namespace mkvmuxer -#endif // MKVMUXER_MKVWRITER_H_ +#endif // MKVWRITER_HPP diff --git a/third_party/libwebm/common/webmids.h b/third_party/libwebm/webmids.hpp similarity index 79% rename from third_party/libwebm/common/webmids.h rename to third_party/libwebm/webmids.hpp index 32a0c5fb9..ad4ab5738 100644 --- a/third_party/libwebm/common/webmids.h +++ b/third_party/libwebm/webmids.hpp @@ -6,10 +6,10 @@ // in the file PATENTS. All contributing project authors may // be found in the AUTHORS file in the root of the source tree. -#ifndef COMMON_WEBMIDS_H_ -#define COMMON_WEBMIDS_H_ +#ifndef WEBMIDS_HPP +#define WEBMIDS_HPP -namespace libwebm { +namespace mkvmuxer { enum MkvId { kMkvEBML = 0x1A45DFA3, @@ -95,35 +95,6 @@ enum MkvId { kMkvAspectRatioType = 0x54B3, kMkvFrameRate = 0x2383E3, // end video - // colour - kMkvColour = 0x55B0, - kMkvMatrixCoefficients = 0x55B1, - kMkvBitsPerChannel = 0x55B2, - kMkvChromaSubsamplingHorz = 0x55B3, - kMkvChromaSubsamplingVert = 0x55B4, - kMkvCbSubsamplingHorz = 0x55B5, - kMkvCbSubsamplingVert = 0x55B6, - kMkvChromaSitingHorz = 0x55B7, - kMkvChromaSitingVert = 0x55B8, - kMkvRange = 0x55B9, - kMkvTransferCharacteristics = 0x55BA, - kMkvPrimaries = 0x55BB, - kMkvMaxCLL = 0x55BC, - kMkvMaxFALL = 0x55BD, - // mastering metadata - kMkvMasteringMetadata = 0x55D0, - kMkvPrimaryRChromaticityX = 0x55D1, - kMkvPrimaryRChromaticityY = 0x55D2, - kMkvPrimaryGChromaticityX = 0x55D3, - kMkvPrimaryGChromaticityY = 0x55D4, - kMkvPrimaryBChromaticityX = 0x55D5, - kMkvPrimaryBChromaticityY = 0x55D6, - kMkvWhitePointChromaticityX = 0x55D7, - kMkvWhitePointChromaticityY = 0x55D8, - kMkvLuminanceMax = 0x55D9, - kMkvLuminanceMin = 0x55DA, - // end mastering metadata - // end colour // audio kMkvAudio = 0xE1, kMkvSamplingFrequency = 0xB5, @@ -179,6 +150,6 @@ enum MkvId { kMkvTagString = 0x4487 }; -} // namespace libwebm +} // end namespace mkvmuxer -#endif // COMMON_WEBMIDS_H_ +#endif // WEBMIDS_HPP diff --git a/webmdec.cc b/webmdec.cc index 81150aa66..c4539a0b9 100644 --- a/webmdec.cc +++ b/webmdec.cc @@ -13,8 +13,8 @@ #include #include -#include "third_party/libwebm/mkvparser/mkvparser.h" -#include "third_party/libwebm/mkvparser/mkvreader.h" +#include "third_party/libwebm/mkvparser.hpp" +#include "third_party/libwebm/mkvreader.hpp" namespace { diff --git a/webmenc.cc b/webmenc.cc index caf439157..d41e70044 100644 --- a/webmenc.cc +++ b/webmenc.cc @@ -11,9 +11,9 @@ #include -#include "third_party/libwebm/mkvmuxer/mkvmuxer.h" -#include "third_party/libwebm/mkvmuxer/mkvmuxerutil.h" -#include "third_party/libwebm/mkvmuxer/mkvwriter.h" +#include "third_party/libwebm/mkvmuxer.hpp" +#include "third_party/libwebm/mkvmuxerutil.hpp" +#include "third_party/libwebm/mkvwriter.hpp" namespace { const uint64_t kDebugTrackUid = 0xDEADBEEF;