generic-library/webm
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Restore original namespaces for mkvmuxer and mkvparser.

Browse Source 
Wrapping mkvmuxer and mkvparser in the libwebm namespace is no
longer necessary now that the tree reorganization is complete.
Put mkvmuxer and mkvparser namespaces back in the global
namespace to avoid unnecessary churn in downstream code.

Change-Id: I13a4fe0143d20bb2bb6038078c68636ff2af0c29
This commit is contained in:
Tom Finegan 2016-03-21 12:16:30 -07:00
parent 504e0f2d5b
commit cbe5c40d12
21 changed files with 621 additions and 610 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
common/hdr_util.h
View File

@ -12,14 +12,13 @@
#include "mkvmuxer/mkvmuxer.h"
namespace libwebm {
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.

2
m2ts/tests/webm2pes_tests.cc
View File

@ -59,7 +59,7 @@ class Webm2PesTests : public ::testing::Test {
private:
const libwebm::TempFileDeleter temp_file_name_;
const std::string input_file_name_ =
libwebm::test::GetTestFilePath("bbb_480p_vp9_opus_1second.webm");
test::GetTestFilePath("bbb_480p_vp9_opus_1second.webm");
libwebm::VpxPesParser parser_;
};

575
mkvmuxer/mkvmuxer.cc
View File

File diff suppressed because it is too large Load Diff

11
mkvmuxer/mkvmuxer.h
View File

@ -21,8 +21,6 @@
// For a description of the WebM elements see
// http://www.webmproject.org/code/specs/container/.
namespace libwebm {
namespace mkvparser {
class IMkvReader;
} // namespace mkvparser
@ -354,8 +352,10 @@ struct PrimaryChromaticity {
PrimaryChromaticity(float x_val, float y_val) : x(x_val), y(y_val) {}
PrimaryChromaticity() : x(0), y(0) {}
~PrimaryChromaticity() {}
uint64_t PrimaryChromaticityPayloadSize(MkvId x_id, MkvId y_id) const;
bool Write(IMkvWriter* writer, MkvId x_id, MkvId y_id) const;
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;
@ -1681,6 +1681,5 @@ class Segment {
};
} // namespace mkvmuxer
} // namespace libwebm
#endif // MKVMUXER_MKVMUXER_H_
#endif // MKVMUXER_MKVMUXER_H_

61
mkvmuxer/mkvmuxerutil.cc
View File

@ -29,7 +29,6 @@
#pragma warning(disable : 4996)
#endif
namespace libwebm {
namespace mkvmuxer {
namespace {
@ -46,18 +45,20 @@ uint64_t WriteBlock(IMkvWriter* writer, const Frame* const frame,
uint64_t block_additions_payload_size = 0;
uint64_t block_additions_elem_size = 0;
if (frame->additional()) {
block_additional_elem_size = EbmlElementSize(
kMkvBlockAdditional, frame->additional(), frame->additional_length());
block_addid_elem_size = EbmlElementSize(kMkvBlockAddID, frame->add_id());
block_additional_elem_size =
EbmlElementSize(libwebm::kMkvBlockAdditional, frame->additional(),
frame->additional_length());
block_addid_elem_size =
EbmlElementSize(libwebm::kMkvBlockAddID, frame->add_id());
block_more_payload_size =
block_addid_elem_size + block_additional_elem_size;
block_more_elem_size =
EbmlMasterElementSize(kMkvBlockMore, block_more_payload_size) +
EbmlMasterElementSize(libwebm::kMkvBlockMore, block_more_payload_size) +
block_more_payload_size;
block_additions_payload_size = block_more_elem_size;
block_additions_elem_size =
EbmlMasterElementSize(kMkvBlockAdditions,
EbmlMasterElementSize(libwebm::kMkvBlockAdditions,
block_additions_payload_size) +
block_additions_payload_size;
}
@ -65,7 +66,7 @@ uint64_t WriteBlock(IMkvWriter* writer, const Frame* const frame,
uint64_t discard_padding_elem_size = 0;
if (frame->discard_padding() != 0) {
discard_padding_elem_size =
EbmlElementSize(kMkvDiscardPadding, frame->discard_padding());
EbmlElementSize(libwebm::kMkvDiscardPadding, frame->discard_padding());
}
const uint64_t reference_block_timestamp =
@ -73,28 +74,30 @@ uint64_t WriteBlock(IMkvWriter* writer, const Frame* const frame,
uint64_t reference_block_elem_size = 0;
if (!frame->is_key()) {
reference_block_elem_size =
EbmlElementSize(kMkvReferenceBlock, reference_block_timestamp);
EbmlElementSize(libwebm::kMkvReferenceBlock, reference_block_timestamp);
}
const uint64_t duration = frame->duration() / timecode_scale;
uint64_t block_duration_elem_size = 0;
if (duration > 0)
block_duration_elem_size = EbmlElementSize(kMkvBlockDuration, duration);
block_duration_elem_size =
EbmlElementSize(libwebm::kMkvBlockDuration, duration);
const uint64_t block_payload_size = 4 + frame->length();
const uint64_t block_elem_size =
EbmlMasterElementSize(kMkvBlock, block_payload_size) + block_payload_size;
EbmlMasterElementSize(libwebm::kMkvBlock, block_payload_size) +
block_payload_size;
const uint64_t block_group_payload_size =
block_elem_size + block_additions_elem_size + block_duration_elem_size +
discard_padding_elem_size + reference_block_elem_size;
if (!WriteEbmlMasterElement(writer, kMkvBlockGroup,
if (!WriteEbmlMasterElement(writer, libwebm::kMkvBlockGroup,
block_group_payload_size)) {
return 0;
}
if (!WriteEbmlMasterElement(writer, kMkvBlock, block_payload_size))
if (!WriteEbmlMasterElement(writer, libwebm::kMkvBlock, block_payload_size))
return 0;
if (WriteUInt(writer, frame->track_number()))
@ -111,44 +114,48 @@ uint64_t WriteBlock(IMkvWriter* writer, const Frame* const frame,
return 0;
if (frame->additional()) {
if (!WriteEbmlMasterElement(writer, kMkvBlockAdditions,
if (!WriteEbmlMasterElement(writer, libwebm::kMkvBlockAdditions,
block_additions_payload_size)) {
return 0;
}
if (!WriteEbmlMasterElement(writer, kMkvBlockMore, block_more_payload_size))
if (!WriteEbmlMasterElement(writer, libwebm::kMkvBlockMore,
block_more_payload_size))
return 0;
if (!WriteEbmlElement(writer, kMkvBlockAddID, frame->add_id()))
if (!WriteEbmlElement(writer, libwebm::kMkvBlockAddID, frame->add_id()))
return 0;
if (!WriteEbmlElement(writer, kMkvBlockAdditional, frame->additional(),
frame->additional_length())) {
if (!WriteEbmlElement(writer, libwebm::kMkvBlockAdditional,
frame->additional(), frame->additional_length())) {
return 0;
}
}
if (frame->discard_padding() != 0 &&
!WriteEbmlElement(writer, kMkvDiscardPadding, frame->discard_padding())) {
!WriteEbmlElement(writer, libwebm::kMkvDiscardPadding,
frame->discard_padding())) {
return false;
}
if (!frame->is_key() &&
!WriteEbmlElement(writer, kMkvReferenceBlock,
!WriteEbmlElement(writer, libwebm::kMkvReferenceBlock,
reference_block_timestamp)) {
return false;
}
if (duration > 0 && !WriteEbmlElement(writer, kMkvBlockDuration, duration)) {
if (duration > 0 &&
!WriteEbmlElement(writer, libwebm::kMkvBlockDuration, duration)) {
return false;
}
return EbmlMasterElementSize(kMkvBlockGroup, block_group_payload_size) +
return EbmlMasterElementSize(libwebm::kMkvBlockGroup,
block_group_payload_size) +
block_group_payload_size;
}
uint64_t WriteSimpleBlock(IMkvWriter* writer, const Frame* const frame,
int64_t timecode) {
if (WriteID(writer, kMkvSimpleBlock))
if (WriteID(writer, libwebm::kMkvSimpleBlock))
return 0;
const int32_t size = static_cast<int32_t>(frame->length()) + 4;
@ -171,7 +178,7 @@ uint64_t WriteSimpleBlock(IMkvWriter* writer, const Frame* const frame,
if (writer->Write(frame->frame(), static_cast<uint32_t>(frame->length())))
return 0;
return GetUIntSize(kMkvSimpleBlock) + GetCodedUIntSize(size) + 4 +
return GetUIntSize(libwebm::kMkvSimpleBlock) + GetCodedUIntSize(size) + 4 +
frame->length();
}
@ -557,7 +564,8 @@ uint64_t WriteVoidElement(IMkvWriter* writer, uint64_t size) {
// 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(kMkvVoid, void_entry_size) + void_entry_size;
EbmlMasterElementSize(libwebm::kMkvVoid, void_entry_size) +
void_entry_size;
if (void_size != size)
return 0;
@ -566,7 +574,7 @@ uint64_t WriteVoidElement(IMkvWriter* writer, uint64_t size) {
if (payload_position < 0)
return 0;
if (WriteID(writer, kMkvVoid))
if (WriteID(writer, libwebm::kMkvVoid))
return 0;
if (WriteUInt(writer, void_entry_size))
@ -629,5 +637,4 @@ uint64_t MakeUID(unsigned int* seed) {
return uid;
}
} // namespace mkvmuxer
} // namespace libwebm
} // namespace mkvmuxer

2
mkvmuxer/mkvmuxerutil.h
View File

@ -10,7 +10,6 @@
#include <stdint.h>
namespace libwebm {
namespace mkvmuxer {
class Cluster;
class Frame;
@ -80,6 +79,5 @@ void GetVersion(int32_t* major, int32_t* minor, int32_t* build,
uint64_t MakeUID(unsigned int* seed);
} // namespace mkvmuxer
} // namespace libwebm
#endif // MKVMUXER_MKVMUXERUTIL_H_

2
mkvmuxer/mkvwriter.cc
View File

@ -12,7 +12,6 @@
#include <share.h> // for _SH_DENYWR
#endif
namespace libwebm {
namespace mkvmuxer {
MkvWriter::MkvWriter() : file_(NULL), writer_owns_file_(true) {}
@ -87,4 +86,3 @@ bool MkvWriter::Seekable() const { return true; }
void MkvWriter::ElementStartNotify(uint64_t, int64_t) {}
} // namespace mkvmuxer
} // namespace libwebm

2
mkvmuxer/mkvwriter.h
View File

@ -14,7 +14,6 @@
#include "mkvmuxer/mkvmuxer.h"
#include "mkvmuxer/mkvmuxertypes.h"
namespace libwebm {
namespace mkvmuxer {
// Default implementation of the IMkvWriter interface on Windows.
@ -48,6 +47,5 @@ class MkvWriter : public IMkvWriter {
};
} // namespace mkvmuxer
} // namespace libwebm
#endif // MKVMUXER_MKVWRITER_H_

322
mkvparser/mkvparser.cc
View File

File diff suppressed because it is too large Load Diff

4
mkvparser/mkvparser.h
View File

@ -10,7 +10,6 @@
#include <cstddef>
namespace libwebm {
namespace mkvparser {
const int E_PARSE_FAILED = -1;
@ -1102,9 +1101,8 @@ class Segment {
};
} // namespace mkvparser
} // namespace libwebm
inline long libwebm::mkvparser::Segment::LoadCluster() {
inline long mkvparser::Segment::LoadCluster() {
long long pos;
long size;

4
mkvparser/mkvreader.cc
View File

@ -9,7 +9,6 @@
#include <cassert>
namespace libwebm {
namespace mkvparser {
MkvReader::MkvReader() : m_file(NULL), reader_owns_file_(true) {}
@ -129,5 +128,4 @@ int MkvReader::Read(long long offset, long len, unsigned char* buffer) {
return 0; // success
}
} // namespace mkvparser
} // namespace libwebm
} // namespace mkvparser

2
mkvparser/mkvreader.h
View File

@ -12,7 +12,6 @@
#include "mkvparser/mkvparser.h"
namespace libwebm {
namespace mkvparser {
class MkvReader : public IMkvReader {
@ -42,6 +41,5 @@ class MkvReader : public IMkvReader {
};
} // namespace mkvparser
} // namespace libwebm
#endif // MKVPARSER_MKVREADER_H_

72
sample.cc
View File

@ -44,15 +44,15 @@ const wchar_t* utf8towcs(const char* str) {
return val;
}
bool InputHasCues(const libwebm::mkvparser::Segment* const segment) {
const libwebm::mkvparser::Cues* const cues = segment->GetCues();
bool InputHasCues(const mkvparser::Segment* const segment) {
const mkvparser::Cues* const cues = segment->GetCues();
if (cues == NULL)
return false;
while (!cues->DoneParsing())
cues->LoadCuePoint();
const libwebm::mkvparser::CuePoint* const cue_point = cues->GetFirst();
const mkvparser::CuePoint* const cue_point = cues->GetFirst();
if (cue_point == NULL)
return false;
@ -60,11 +60,11 @@ bool InputHasCues(const libwebm::mkvparser::Segment* const segment) {
}
bool MasteringMetadataValuePresent(double value) {
return value != libwebm::mkvparser::MasteringMetadata::kValueNotPresent;
return value != mkvparser::MasteringMetadata::kValueNotPresent;
}
bool ColourValuePresent(long long value) {
return value != libwebm::mkvparser::Colour::kValueNotPresent;
return value != mkvparser::Colour::kValueNotPresent;
}
} // namespace
@ -77,7 +77,7 @@ int main(int argc, char* argv[]) {
return -1;
}
libwebm::mkvparser::MkvReader reader;
mkvparser::MkvReader reader;
if (reader.Open(argv[1])) {
printf("\n Filename is invalid or error while opening.\n");
@ -86,12 +86,12 @@ int main(int argc, char* argv[]) {
int maj, min, build, rev;
libwebm::mkvparser::GetVersion(maj, min, build, rev);
mkvparser::GetVersion(maj, min, build, rev);
printf("\t\t libmkv verison: %d.%d.%d.%d\n", maj, min, build, rev);
long long pos = 0;
libwebm::mkvparser::EBMLHeader ebmlHeader;
mkvparser::EBMLHeader ebmlHeader;
long long ret = ebmlHeader.Parse(&reader, pos);
if (ret < 0) {
@ -106,7 +106,7 @@ int main(int argc, char* argv[]) {
printf("\t\tDoc Type\t\t: %s\n", ebmlHeader.m_docType);
printf("\t\tPos\t\t\t: %lld\n", pos);
typedef libwebm::mkvparser::Segment seg_t;
typedef mkvparser::Segment seg_t;
seg_t* pSegment_;
ret = seg_t::CreateInstance(&reader, pos, pSegment_);
@ -123,8 +123,7 @@ int main(int argc, char* argv[]) {
return -1;
}
const libwebm::mkvparser::SegmentInfo* const pSegmentInfo =
pSegment->GetInfo();
const mkvparser::SegmentInfo* const pSegmentInfo = pSegment->GetInfo();
if (pSegmentInfo == NULL) {
printf("\n Segment::GetInfo() failed.");
return -1;
@ -177,7 +176,7 @@ int main(int argc, char* argv[]) {
// size of segment payload
printf("\t\tSize(Segment)\t\t: %lld\n", pSegment->m_size);
const libwebm::mkvparser::Tracks* pTracks = pSegment->GetTracks();
const mkvparser::Tracks* pTracks = pSegment->GetTracks();
unsigned long track_num = 0;
const unsigned long num_tracks = pTracks->GetTracksCount();
@ -185,7 +184,7 @@ int main(int argc, char* argv[]) {
printf("\n\t\t\t Track Info\n");
while (track_num != num_tracks) {
const libwebm::mkvparser::Track* const pTrack =
const mkvparser::Track* const pTrack =
pTracks->GetTrackByIndex(track_num++);
if (pTrack == NULL)
@ -224,9 +223,9 @@ int main(int argc, char* argv[]) {
delete[] pCodecName;
}
if (trackType == libwebm::mkvparser::Track::kVideo) {
const libwebm::mkvparser::VideoTrack* const pVideoTrack =
static_cast<const libwebm::mkvparser::VideoTrack*>(pTrack);
if (trackType == mkvparser::Track::kVideo) {
const mkvparser::VideoTrack* const pVideoTrack =
static_cast<const mkvparser::VideoTrack*>(pTrack);
const long long width = pVideoTrack->GetWidth();
printf("\t\tVideo Width\t\t: %lld\n", width);
@ -237,7 +236,7 @@ int main(int argc, char* argv[]) {
const double rate = pVideoTrack->GetFrameRate();
printf("\t\tVideo Rate\t\t: %f\n", rate);
const libwebm::mkvparser::Colour* const colour = pVideoTrack->GetColour();
const mkvparser::Colour* const colour = pVideoTrack->GetColour();
if (colour) {
printf("\t\tVideo Colour:\n");
if (ColourValuePresent(colour->matrix_coefficients))
@ -273,7 +272,7 @@ int main(int argc, char* argv[]) {
if (ColourValuePresent(colour->max_fall))
printf("\t\t\tMaxFALL: %lld\n", colour->max_fall);
if (colour->mastering_metadata) {
const libwebm::mkvparser::MasteringMetadata* const mm =
const mkvparser::MasteringMetadata* const mm =
colour->mastering_metadata;
printf("\t\t\tMastering Metadata:\n");
if (MasteringMetadataValuePresent(mm->luminance_max))
@ -302,9 +301,9 @@ int main(int argc, char* argv[]) {
}
}
if (trackType == libwebm::mkvparser::Track::kAudio) {
const libwebm::mkvparser::AudioTrack* const pAudioTrack =
static_cast<const libwebm::mkvparser::AudioTrack*>(pTrack);
if (trackType == mkvparser::Track::kAudio) {
const mkvparser::AudioTrack* const pAudioTrack =
static_cast<const mkvparser::AudioTrack*>(pTrack);
const long long channels = pAudioTrack->GetChannels();
printf("\t\tAudio Channels\t\t: %lld\n", channels);
@ -333,7 +332,7 @@ int main(int argc, char* argv[]) {
return -1;
}
const libwebm::mkvparser::Cluster* pCluster = pSegment->GetFirst();
const mkvparser::Cluster* pCluster = pSegment->GetFirst();
while ((pCluster != NULL) && !pCluster->EOS()) {
const long long timeCode = pCluster->GetTimeCode();
@ -342,7 +341,7 @@ int main(int argc, char* argv[]) {
const long long time_ns = pCluster->GetTime();
printf("\t\tCluster Time (ns)\t: %lld\n", time_ns);
const libwebm::mkvparser::BlockEntry* pBlockEntry;
const mkvparser::BlockEntry* pBlockEntry;
long status = pCluster->GetFirst(pBlockEntry);
@ -354,11 +353,10 @@ int main(int argc, char* argv[]) {
}
while ((pBlockEntry != NULL) && !pBlockEntry->EOS()) {
const libwebm::mkvparser::Block* const pBlock = pBlockEntry->GetBlock();
const mkvparser::Block* const pBlock = pBlockEntry->GetBlock();
const long long trackNum = pBlock->GetTrackNumber();
const unsigned long tn = static_cast<unsigned long>(trackNum);
const libwebm::mkvparser::Track* const pTrack =
pTracks->GetTrackByNumber(tn);
const mkvparser::Track* const pTrack = pTracks->GetTrackByNumber(tn);
if (pTrack == NULL)
printf("\t\t\tBlock\t\t:UNKNOWN TRACK TYPE\n");
@ -369,12 +367,11 @@ int main(int argc, char* argv[]) {
const long long discard_padding = pBlock->GetDiscardPadding();
printf("\t\t\tBlock\t\t:%s,%s,%15lld,%lld\n",
(trackType == libwebm::mkvparser::Track::kVideo) ? "V" : "A",
(trackType == mkvparser::Track::kVideo) ? "V" : "A",
pBlock->IsKey() ? "I" : "P", time_ns, discard_padding);
for (int i = 0; i < frameCount; ++i) {
const libwebm::mkvparser::Block::Frame& theFrame =
pBlock->GetFrame(i);
const mkvparser::Block::Frame& theFrame = pBlock->GetFrame(i);
const long size = theFrame.len;
const long long offset = theFrame.pos;
printf("\t\t\t %15ld,%15llx\n", size, offset);
@ -395,22 +392,21 @@ int main(int argc, char* argv[]) {
if (InputHasCues(pSegment.get())) {
// Walk them.
const libwebm::mkvparser::Cues* const cues = pSegment->GetCues();
const libwebm::mkvparser::CuePoint* cue = cues->GetFirst();
const mkvparser::Cues* const cues = pSegment->GetCues();
const mkvparser::CuePoint* cue = cues->GetFirst();
int cue_point_num = 1;
printf("\t\tCues\n");
do {
for (track_num = 0; track_num < num_tracks; ++track_num) {
const libwebm::mkvparser::Track* const track =
const mkvparser::Track* const track =
pTracks->GetTrackByIndex(track_num);
const libwebm::mkvparser::CuePoint::TrackPosition* const track_pos =
const mkvparser::CuePoint::TrackPosition* const track_pos =
cue->Find(track);
if (track_pos != NULL) {
const char track_type =
(track->GetType() == libwebm::mkvparser::Track::kVideo) ? 'V' :
'A';
(track->GetType() == mkvparser::Track::kVideo) ? 'V' : 'A';
printf(
"\t\t\tCue Point %4d Track %3lu(%c) Time %14lld "
"Block %4lld Pos %8llx\n",
@ -425,14 +421,14 @@ int main(int argc, char* argv[]) {
} while (cue != NULL);
}
const libwebm::mkvparser::Tags* const tags = pSegment->GetTags();
const mkvparser::Tags* const tags = pSegment->GetTags();
if (tags && tags->GetTagCount() > 0) {
printf("\t\tTags\n");
for (int i = 0; i < tags->GetTagCount(); ++i) {
const libwebm::mkvparser::Tags::Tag* const tag = tags->GetTag(i);
const mkvparser::Tags::Tag* const tag = tags->GetTag(i);
printf("\t\t\tTag\n");
for (int j = 0; j < tag->GetSimpleTagCount(); j++) {
const libwebm::mkvparser::Tags::SimpleTag* const simple_tag =
const mkvparser::Tags::SimpleTag* const simple_tag =
tag->GetSimpleTag(j);
printf("\t\t\t\tSimple Tag \"%s\" Value \"%s\"\n",
simple_tag->GetTagName(), simple_tag->GetTagString());

90
sample_muxer.cc
View File

@ -82,14 +82,14 @@ void Usage() {
struct MetadataFile {
const char* name;
libwebm::SampleMuxerMetadata::Kind kind;
SampleMuxerMetadata::Kind kind;
};
typedef std::list<MetadataFile> metadata_files_t;
// Cache the WebVTT filenames specified as command-line args.
bool LoadMetadataFiles(const metadata_files_t& files,
libwebm::SampleMuxerMetadata* metadata) {
SampleMuxerMetadata* metadata) {
typedef metadata_files_t::const_iterator iter_t;
iter_t i = files.begin();
@ -112,14 +112,14 @@ int ParseArgWebVTT(char* argv[], int* argv_index, int argc_check,
enum { kCount = 5 };
struct Arg {
const char* name;
libwebm::SampleMuxerMetadata::Kind kind;
SampleMuxerMetadata::Kind kind;
};
const Arg args[kCount] = {
{"-webvtt-subtitles", libwebm::SampleMuxerMetadata::kSubtitles},
{"-webvtt-captions", libwebm::SampleMuxerMetadata::kCaptions},
{"-webvtt-descriptions", libwebm::SampleMuxerMetadata::kDescriptions},
{"-webvtt-metadata", libwebm::SampleMuxerMetadata::kMetadata},
{"-webvtt-chapters", libwebm::SampleMuxerMetadata::kChapters}};
{"-webvtt-subtitles", SampleMuxerMetadata::kSubtitles},
{"-webvtt-captions", SampleMuxerMetadata::kCaptions},
{"-webvtt-descriptions", SampleMuxerMetadata::kDescriptions},
{"-webvtt-metadata", SampleMuxerMetadata::kMetadata},
{"-webvtt-chapters", SampleMuxerMetadata::kChapters}};
for (int idx = 0; idx < kCount; ++idx) {
const Arg& arg = args[idx];
@ -248,7 +248,7 @@ int main(int argc, char* argv[]) {
}
// Get parser header info
libwebm::mkvparser::MkvReader reader;
mkvparser::MkvReader reader;
if (reader.Open(input)) {
printf("\n Filename is invalid or error while opening.\n");
@ -256,31 +256,28 @@ int main(int argc, char* argv[]) {
}
long long pos = 0;
libwebm::mkvparser::EBMLHeader ebml_header;
mkvparser::EBMLHeader ebml_header;
long long ret = ebml_header.Parse(&reader, pos);
if (ret) {
printf("\n EBMLHeader::Parse() failed.");
return EXIT_FAILURE;
}
libwebm::mkvparser::Segment* parser_segment_;
ret = libwebm::mkvparser::Segment::CreateInstance(&reader, pos,
parser_segment_);
mkvparser::Segment* parser_segment_;
ret = mkvparser::Segment::CreateInstance(&reader, pos, parser_segment_);
if (ret) {
printf("\n Segment::CreateInstance() failed.");
return EXIT_FAILURE;
}
const std::auto_ptr<libwebm::mkvparser::Segment> parser_segment(
parser_segment_);
const std::auto_ptr<mkvparser::Segment> parser_segment(parser_segment_);
ret = parser_segment->Load();
if (ret < 0) {
printf("\n Segment::Load() failed.");
return EXIT_FAILURE;
}
const libwebm::mkvparser::SegmentInfo* const segment_info =
parser_segment->GetInfo();
const mkvparser::SegmentInfo* const segment_info = parser_segment->GetInfo();
if (segment_info == NULL) {
printf("\n Segment::GetInfo() failed.");
return EXIT_FAILURE;
@ -288,7 +285,7 @@ int main(int argc, char* argv[]) {
const long long timeCodeScale = segment_info->GetTimeCodeScale();
// Set muxer header info
libwebm::mkvmuxer::MkvWriter writer;
mkvmuxer::MkvWriter writer;
const std::string temp_file = libwebm::GetTempFileName();
if (!writer.Open(cues_before_clusters ? temp_file.c_str() : output)) {
@ -297,7 +294,7 @@ int main(int argc, char* argv[]) {
}
// Set Segment element attributes
libwebm::mkvmuxer::Segment muxer_segment;
mkvmuxer::Segment muxer_segment;
if (!muxer_segment.Init(&writer)) {
printf("\n Could not initialize muxer segment!\n");
@ -307,9 +304,9 @@ int main(int argc, char* argv[]) {
muxer_segment.AccurateClusterDuration(accurate_cluster_duration);
if (live_mode)
muxer_segment.set_mode(libwebm::mkvmuxer::Segment::kLive);
muxer_segment.set_mode(mkvmuxer::Segment::kLive);
else
muxer_segment.set_mode(libwebm::mkvmuxer::Segment::kFile);
muxer_segment.set_mode(mkvmuxer::Segment::kFile);
if (chunking)
muxer_segment.SetChunking(true, chunk_name);
@ -321,18 +318,18 @@ int main(int argc, char* argv[]) {
muxer_segment.OutputCues(output_cues);
// Set SegmentInfo element attributes
libwebm::mkvmuxer::SegmentInfo* const info = muxer_segment.GetSegmentInfo();
mkvmuxer::SegmentInfo* const info = muxer_segment.GetSegmentInfo();
info->set_timecode_scale(timeCodeScale);
info->set_writing_app("sample_muxer");
const libwebm::mkvparser::Tags* const tags = parser_segment->GetTags();
const mkvparser::Tags* const tags = parser_segment->GetTags();
if (copy_tags && tags) {
for (int i = 0; i < tags->GetTagCount(); i++) {
const libwebm::mkvparser::Tags::Tag* const tag = tags->GetTag(i);
libwebm::mkvmuxer::Tag* muxer_tag = muxer_segment.AddTag();
const mkvparser::Tags::Tag* const tag = tags->GetTag(i);
mkvmuxer::Tag* muxer_tag = muxer_segment.AddTag();
for (int j = 0; j < tag->GetSimpleTagCount(); j++) {
const libwebm::mkvparser::Tags::SimpleTag* const simple_tag =
const mkvparser::Tags::SimpleTag* const simple_tag =
tag->GetSimpleTag(j);
muxer_tag->add_simple_tag(simple_tag->GetTagName(),
simple_tag->GetTagString());
@ -341,13 +338,12 @@ int main(int argc, char* argv[]) {
}
// Set Tracks element attributes
const libwebm::mkvparser::Tracks* const parser_tracks =
parser_segment->GetTracks();
const mkvparser::Tracks* const parser_tracks = parser_segment->GetTracks();
unsigned long i = 0;
uint64_t vid_track = 0; // no track added
uint64_t aud_track = 0; // no track added
using libwebm::mkvparser::Track;
using mkvparser::Track;
while (i != parser_tracks->GetTracksCount()) {
int track_num = i++;
@ -366,8 +362,8 @@ int main(int argc, char* argv[]) {
if (track_type == Track::kVideo && output_video) {
// Get the video track from the parser
const libwebm::mkvparser::VideoTrack* const pVideoTrack =
static_cast<const libwebm::mkvparser::VideoTrack*>(parser_track);
const mkvparser::VideoTrack* const pVideoTrack =
static_cast<const mkvparser::VideoTrack*>(parser_track);
const long long width = pVideoTrack->GetWidth();
const long long height = pVideoTrack->GetHeight();
@ -380,16 +376,15 @@ int main(int argc, char* argv[]) {
return EXIT_FAILURE;
}
libwebm::mkvmuxer::VideoTrack* const video =
static_cast<libwebm::mkvmuxer::VideoTrack*>(
muxer_segment.GetTrackByNumber(vid_track));
mkvmuxer::VideoTrack* const video = static_cast<mkvmuxer::VideoTrack*>(
muxer_segment.GetTrackByNumber(vid_track));
if (!video) {
printf("\n Could not get video track.\n");
return EXIT_FAILURE;
}
if (pVideoTrack->GetColour()) {
libwebm::mkvmuxer::Colour muxer_colour;
mkvmuxer::Colour muxer_colour;
if (!libwebm::CopyColour(*pVideoTrack->GetColour(), &muxer_colour))
return EXIT_FAILURE;
if (!video->SetColour(muxer_colour))
@ -414,8 +409,8 @@ int main(int argc, char* argv[]) {
}
} else if (track_type == Track::kAudio && output_audio) {
// Get the audio track from the parser
const libwebm::mkvparser::AudioTrack* const pAudioTrack =
static_cast<const libwebm::mkvparser::AudioTrack*>(parser_track);
const mkvparser::AudioTrack* const pAudioTrack =
static_cast<const mkvparser::AudioTrack*>(parser_track);
const long long channels = pAudioTrack->GetChannels();
const double sample_rate = pAudioTrack->GetSamplingRate();
@ -428,9 +423,8 @@ int main(int argc, char* argv[]) {
return EXIT_FAILURE;
}
libwebm::mkvmuxer::AudioTrack* const audio =
static_cast<libwebm::mkvmuxer::AudioTrack*>(
muxer_segment.GetTrackByNumber(aud_track));
mkvmuxer::AudioTrack* const audio = static_cast<mkvmuxer::AudioTrack*>(
muxer_segment.GetTrackByNumber(aud_track));
if (!audio) {
printf("\n Could not get audio track.\n");
return EXIT_FAILURE;
@ -467,7 +461,7 @@ int main(int argc, char* argv[]) {
// add a track to the output file corresponding to each metadata
// input file.
libwebm::SampleMuxerMetadata metadata;
SampleMuxerMetadata metadata;
if (!metadata.Init(&muxer_segment)) {
printf("\n Could not initialize metadata cache.\n");
@ -481,7 +475,7 @@ int main(int argc, char* argv[]) {
return EXIT_FAILURE;
// Set Cues element attributes
libwebm::mkvmuxer::Cues* const cues = muxer_segment.GetCues();
mkvmuxer::Cues* const cues = muxer_segment.GetCues();
cues->set_output_block_number(output_cues_block_number);
if (cues_on_video_track && vid_track)
muxer_segment.CuesTrack(vid_track);
@ -492,10 +486,10 @@ int main(int argc, char* argv[]) {
unsigned char* data = NULL;
int data_len = 0;
const libwebm::mkvparser::Cluster* cluster = parser_segment->GetFirst();
const mkvparser::Cluster* cluster = parser_segment->GetFirst();
while ((cluster != NULL) && !cluster->EOS()) {
const libwebm::mkvparser::BlockEntry* block_entry;
const mkvparser::BlockEntry* block_entry;
long status = cluster->GetFirst(block_entry);
@ -505,9 +499,9 @@ int main(int argc, char* argv[]) {
}
while ((block_entry != NULL) && !block_entry->EOS()) {
const libwebm::mkvparser::Block* const block = block_entry->GetBlock();
const mkvparser::Block* const block = block_entry->GetBlock();
const long long trackNum = block->GetTrackNumber();
const libwebm::mkvparser::Track* const parser_track =
const mkvparser::Track* const parser_track =
parser_tracks->GetTrackByNumber(static_cast<unsigned long>(trackNum));
// When |parser_track| is NULL, it means that the track number in the
@ -530,7 +524,7 @@ int main(int argc, char* argv[]) {
const int frame_count = block->GetFrameCount();
for (int i = 0; i < frame_count; ++i) {
const libwebm::mkvparser::Block::Frame& frame = block->GetFrame(i);
const mkvparser::Block::Frame& frame = block->GetFrame(i);
if (frame.len > data_len) {
delete[] data;
@ -543,7 +537,7 @@ int main(int argc, char* argv[]) {
if (frame.Read(&reader, data))
return EXIT_FAILURE;
libwebm::mkvmuxer::Frame muxer_frame;
mkvmuxer::Frame muxer_frame;
if (!muxer_frame.Init(data, frame.len))
return EXIT_FAILURE;
muxer_frame.set_track_number(track_type == Track::kAudio ? aud_track :

6
sample_muxer_metadata.cc
View File

@ -17,8 +17,6 @@
#include "mkvmuxer/mkvmuxer.h"
#include "webvtt/vttreader.h"
namespace libwebm {
SampleMuxerMetadata::SampleMuxerMetadata() : segment_(NULL) {}
bool SampleMuxerMetadata::Init(mkvmuxer::Segment* segment) {
@ -390,6 +388,4 @@ bool SampleMuxerMetadata::SortableCue::Write(mkvmuxer::Segment* segment) const {
muxer_frame.set_duration(duration_ns);
muxer_frame.set_is_key(true); // All metadata frames are keyframes.
return segment->AddGenericFrame(&muxer_frame);
}
} // namespace libwebm
}

4
sample_muxer_metadata.h
View File

@ -17,8 +17,6 @@
#include "webvtt/webvttparser.h"
namespace libwebm {
namespace mkvmuxer {
class Chapter;
class Frame;
@ -136,6 +134,4 @@ class SampleMuxerMetadata {
SampleMuxerMetadata& operator=(const SampleMuxerMetadata&);
};
} // namespace libwebm
#endif // SAMPLE_MUXER_METADATA_H_ // NOLINT

27
testing/muxer_tests.cc
View File

@ -30,16 +30,15 @@
#pragma warning(disable : 4996)
#endif
using libwebm::mkvmuxer::AudioTrack;
using libwebm::mkvmuxer::Chapter;
using libwebm::mkvmuxer::Frame;
using libwebm::mkvmuxer::MkvWriter;
using libwebm::mkvmuxer::Segment;
using libwebm::mkvmuxer::SegmentInfo;
using libwebm::mkvmuxer::Track;
using libwebm::mkvmuxer::VideoTrack;
using mkvmuxer::AudioTrack;
using mkvmuxer::Chapter;
using mkvmuxer::Frame;
using mkvmuxer::MkvWriter;
using mkvmuxer::Segment;
using mkvmuxer::SegmentInfo;
using mkvmuxer::Track;
using mkvmuxer::VideoTrack;
namespace libwebm {
namespace test {
// Base class containing boiler plate stuff.
@ -54,9 +53,10 @@ class MuxerTest : public testing::Test {
// are fatal, but the ASSERT_* gtest macros cannot be used in a constructor.
void Init() {
ASSERT_TRUE(GetTestDataDir().length() > 0);
filename_ = GetTempFileName();
filename_ = libwebm::GetTempFileName();
ASSERT_GT(filename_.length(), 0u);
temp_file_ = FilePtr(std::fopen(filename_.c_str(), "wb"), FILEDeleter());
temp_file_ = libwebm::FilePtr(std::fopen(filename_.c_str(), "wb"),
libwebm::FILEDeleter());
ASSERT_TRUE(temp_file_.get() != nullptr);
writer_.reset(new MkvWriter(temp_file_.get()));
is_writer_open_ = true;
@ -112,7 +112,7 @@ class MuxerTest : public testing::Test {
bool is_writer_open_ = false;
Segment segment_;
std::string filename_;
FilePtr temp_file_;
libwebm::FilePtr temp_file_;
std::uint8_t dummy_data_[kFrameLength];
};
@ -473,7 +473,7 @@ TEST_F(MuxerTest, CuesBeforeClusters) {
mkvparser::MkvReader reader;
ASSERT_EQ(0, reader.Open(filename_.c_str()));
MkvWriter cues_writer;
std::string cues_filename = GetTempFileName();
std::string cues_filename = libwebm::GetTempFileName();
ASSERT_GT(cues_filename.length(), 0u);
cues_writer.Open(cues_filename.c_str());
EXPECT_TRUE(segment_.CopyAndMoveCuesBeforeClusters(&reader, &cues_writer));
@ -704,7 +704,6 @@ TEST_F(MuxerTest, AccurateClusterDurationTwoTracks) {
}
} // namespace test
} // namespace libwebm
int main(int argc, char* argv[]) {
::testing::InitGoogleTest(&argc, argv);

28
testing/parser_tests.cc
View File

@ -18,21 +18,20 @@
#include "mkvparser/mkvreader.h"
#include "testing/test_util.h"
using libwebm::mkvparser::AudioTrack;
using libwebm::mkvparser::Block;
using libwebm::mkvparser::BlockEntry;
using libwebm::mkvparser::BlockGroup;
using libwebm::mkvparser::Cluster;
using libwebm::mkvparser::CuePoint;
using libwebm::mkvparser::Cues;
using libwebm::mkvparser::MkvReader;
using libwebm::mkvparser::Segment;
using libwebm::mkvparser::SegmentInfo;
using libwebm::mkvparser::Track;
using libwebm::mkvparser::Tracks;
using libwebm::mkvparser::VideoTrack;
using mkvparser::AudioTrack;
using mkvparser::Block;
using mkvparser::BlockEntry;
using mkvparser::BlockGroup;
using mkvparser::Cluster;
using mkvparser::CuePoint;
using mkvparser::Cues;
using mkvparser::MkvReader;
using mkvparser::Segment;
using mkvparser::SegmentInfo;
using mkvparser::Track;
using mkvparser::Tracks;
using mkvparser::VideoTrack;
namespace libwebm {
namespace test {
// Base class containing boiler plate stuff.
@ -664,7 +663,6 @@ TEST_F(ParserTest, StereoModeParsedCorrectly) {
}
} // namespace test
} // namespace libwebm
int main(int argc, char* argv[]) {
::testing::InitGoogleTest(&argc, argv);

10
testing/test_util.cc
View File

@ -21,7 +21,6 @@
#include "common/libwebm_util.h"
namespace libwebm {
namespace test {
std::string GetTestDataDir() {
@ -39,8 +38,10 @@ bool CompareFiles(const std::string& file1, const std::string& file2) {
std::uint8_t buf1[kBlockSize] = {0};
std::uint8_t buf2[kBlockSize] = {0};
FilePtr f1 = FilePtr(std::fopen(file1.c_str(), "rb"), FILEDeleter());
FilePtr f2 = FilePtr(std::fopen(file2.c_str(), "rb"), FILEDeleter());
libwebm::FilePtr f1 =
libwebm::FilePtr(std::fopen(file1.c_str(), "rb"), libwebm::FILEDeleter());
libwebm::FilePtr f2 =
libwebm::FilePtr(std::fopen(file2.c_str(), "rb"), libwebm::FILEDeleter());
if (!f1.get() || !f2.get()) {
// Files cannot match if one or both couldn't be opened.
@ -59,5 +60,4 @@ bool CompareFiles(const std::string& file1, const std::string& file2) {
return std::feof(f1.get()) && std::feof(f2.get());
}
} // namespace test
} // namespace libwebm
} // namespace test

2
testing/test_util.h
View File

@ -13,7 +13,6 @@
#include <cstddef>
#include <string>
namespace libwebm {
namespace test {
// constants for muxer and parser tests
@ -54,6 +53,5 @@ std::string GetTestFilePath(const std::string& name);
bool CompareFiles(const std::string& file1, const std::string& file2);
} // namespace test
} // namespace libwebm
#endif // LIBWEBM_TESTING_TEST_UTIL_H_

2
vttdemux.cc
View File

@ -961,7 +961,7 @@ int main(int argc, const char* argv[]) {
}
const char* const filename = argv[1];
libwebm::mkvparser::MkvReader reader;
mkvparser::MkvReader reader;
int e = reader.Open(filename);