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

Namespace reorg: Make everything a child of libwebm.

Browse Source 
(that is not already)
Some details:
- mkvmuxer and mkvparser wrapped by libwebm
- Matroska element constants moved from mkvmuxer to libwebm
- integer types moved from mkvmuxer to libwebm

Change-Id: Ic91e887e50adbc2d735bf6264534a5d01135df31
This commit is contained in:
Tom Finegan
2016-03-18 09:32:52 -07:00
parent 5fdb386183
commit e64bf75688
20 changed files with 415 additions and 377 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
common/hdr_util.h
View File

@@ -12,14 +12,14 @@
#include "../mkvmuxer.hpp" #include "../mkvmuxer.hpp"
namespace libwebm {
namespace mkvparser { namespace mkvparser {
struct Colour; struct Colour;
struct MasteringMetadata; struct MasteringMetadata;
struct PrimaryChromaticity; struct PrimaryChromaticity;
} // namespace mkvparser } // namespace mkvparser
namespace libwebm {
// Utility types and functions for working with the Colour element and its // Utility types and functions for working with the Colour element and its
// children. Copiers return true upon success. Presence functions return true // children. Copiers return true upon success. Presence functions return true
// when the specified element is present. // when the specified element is present.

4
mkvmuxer.cpp
View File

@@ -29,6 +29,7 @@
#pragma warning(disable : 4996) #pragma warning(disable : 4996)
#endif #endif
namespace libwebm {
namespace mkvmuxer { namespace mkvmuxer {
const float MasteringMetadata::kValueNotPresent = FLT_MAX; const float MasteringMetadata::kValueNotPresent = FLT_MAX;
@@ -121,7 +122,7 @@ bool WriteEbmlHeader(IMkvWriter* writer) {
} }
bool ChunkedCopy(mkvparser::IMkvReader* source, mkvmuxer::IMkvWriter* dst, bool ChunkedCopy(mkvparser::IMkvReader* source, mkvmuxer::IMkvWriter* dst,
mkvmuxer::int64 start, int64 size) { int64 start, int64 size) {
// TODO(vigneshv): Check if this is a reasonable value. // TODO(vigneshv): Check if this is a reasonable value.
const uint32 kBufSize = 2048; const uint32 kBufSize = 2048;
uint8* buf = new uint8[kBufSize]; uint8* buf = new uint8[kBufSize];
@@ -3595,3 +3596,4 @@ bool Segment::WriteFramesLessThan(uint64 timestamp) {
} }
} // namespace mkvmuxer } // namespace mkvmuxer
} // namespace libwebm

7
mkvmuxer.hpp
View File

@@ -17,9 +17,11 @@
// For a description of the WebM elements see // For a description of the WebM elements see
// http://www.webmproject.org/code/specs/container/. // http://www.webmproject.org/code/specs/container/.
namespace libwebm {
namespace mkvparser { namespace mkvparser {
class IMkvReader; class IMkvReader;
} // end namespace } // namespace mkvparser
namespace mkvmuxer { namespace mkvmuxer {
@@ -1610,6 +1612,7 @@ class Segment {
LIBWEBM_DISALLOW_COPY_AND_ASSIGN(Segment); LIBWEBM_DISALLOW_COPY_AND_ASSIGN(Segment);
}; };
} // end namespace mkvmuxer } // namespace mkvmuxer
} // namespace libwebm
#endif // MKVMUXER_HPP #endif // MKVMUXER_HPP

6
mkvmuxertypes.hpp
View File

@@ -16,8 +16,10 @@
TypeName(const TypeName&); \ TypeName(const TypeName&); \
void operator=(const TypeName&) void operator=(const TypeName&)
namespace mkvmuxer { namespace libwebm {
// TODO(tomfinegan): These types are no longer necessary: drop these, and use
// cstdint/stdint.h types.
typedef unsigned char uint8; typedef unsigned char uint8;
typedef short int16; typedef short int16;
typedef int int32; typedef int int32;
@@ -25,6 +27,6 @@ typedef unsigned int uint32;
typedef long long int64; typedef long long int64;
typedef unsigned long long uint64; typedef unsigned long long uint64;
} // end namespace mkvmuxer } // namespace libwebm
#endif // MKVMUXERTYPES_HPP #endif // MKVMUXERTYPES_HPP

8
mkvmuxerutil.cpp
View File

@@ -29,6 +29,7 @@
#pragma warning(disable : 4996) #pragma warning(disable : 4996)
#endif #endif
namespace libwebm {
namespace mkvmuxer { namespace mkvmuxer {
namespace { namespace {
@@ -592,9 +593,7 @@ void GetVersion(int32* major, int32* minor, int32* build, int32* revision) {
*revision = 0; *revision = 0;
} }
} // namespace mkvmuxer uint64 MakeUID(unsigned int* seed) {
mkvmuxer::uint64 mkvmuxer::MakeUID(unsigned int* seed) {
uint64 uid = 0; uint64 uid = 0;
#ifdef __MINGW32__ #ifdef __MINGW32__
@@ -628,3 +627,6 @@ mkvmuxer::uint64 mkvmuxer::MakeUID(unsigned int* seed) {
return uid; return uid;
} }
} // namespace mkvmuxer
} // namespace libwebm

4
mkvmuxerutil.hpp
View File

@@ -11,6 +11,7 @@
#include "mkvmuxertypes.hpp" #include "mkvmuxertypes.hpp"
namespace libwebm {
namespace mkvmuxer { namespace mkvmuxer {
class Cluster; class Cluster;
class Frame; class Frame;
@@ -78,6 +79,7 @@ void GetVersion(int32* major, int32* minor, int32* build, int32* revision);
// the random-number generator (see POSIX rand_r() for semantics). // the random-number generator (see POSIX rand_r() for semantics).
uint64 MakeUID(unsigned int* seed); uint64 MakeUID(unsigned int* seed);
} // end namespace mkvmuxer } // namespace mkvmuxer
} // namespace libwebm
#endif // MKVMUXERUTIL_HPP #endif // MKVMUXERUTIL_HPP

323
mkvparser.cpp
View File

File diff suppressed because it is too large Load Diff

6
mkvparser.hpp
View File

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

4
mkvreader.cpp
View File

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

4
mkvreader.hpp
View File

@@ -12,6 +12,7 @@
#include "mkvparser.hpp" #include "mkvparser.hpp"
#include <cstdio> #include <cstdio>
namespace libwebm {
namespace mkvparser { namespace mkvparser {
class MkvReader : public IMkvReader { class MkvReader : public IMkvReader {
@@ -40,6 +41,7 @@ class MkvReader : public IMkvReader {
bool reader_owns_file_; bool reader_owns_file_;
}; };
} // end namespace mkvparser } // namespace mkvparser
} // namespace libwebm
#endif // MKVREADER_HPP #endif // MKVREADER_HPP

2
mkvwriter.cpp
View File

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

4
mkvwriter.hpp
View File

@@ -14,6 +14,7 @@
#include "mkvmuxer.hpp" #include "mkvmuxer.hpp"
#include "mkvmuxertypes.hpp" #include "mkvmuxertypes.hpp"
namespace libwebm {
namespace mkvmuxer { namespace mkvmuxer {
// Default implementation of the IMkvWriter interface on Windows. // Default implementation of the IMkvWriter interface on Windows.
@@ -46,6 +47,7 @@ class MkvWriter : public IMkvWriter {
LIBWEBM_DISALLOW_COPY_AND_ASSIGN(MkvWriter); LIBWEBM_DISALLOW_COPY_AND_ASSIGN(MkvWriter);
}; };
} // end namespace mkvmuxer } // namespace mkvmuxer
} // namespace libwebm
#endif // MKVWRITER_HPP #endif // MKVWRITER_HPP

75
sample.cpp
View File

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

109
sample_muxer.cpp
View File

@@ -28,9 +28,6 @@
#include "sample_muxer_metadata.h" #include "sample_muxer_metadata.h"
using mkvmuxer::int64;
using mkvmuxer::uint64;
#ifdef _MSC_VER #ifdef _MSC_VER
// Disable MSVC warnings that suggest making code non-portable. // Disable MSVC warnings that suggest making code non-portable.
#pragma warning(disable : 4996) #pragma warning(disable : 4996)
@@ -82,14 +79,14 @@ void Usage() {
struct MetadataFile { struct MetadataFile {
const char* name; const char* name;
SampleMuxerMetadata::Kind kind; libwebm::SampleMuxerMetadata::Kind kind;
}; };
typedef std::list<MetadataFile> metadata_files_t; typedef std::list<MetadataFile> metadata_files_t;
// Cache the WebVTT filenames specified as command-line args. // Cache the WebVTT filenames specified as command-line args.
bool LoadMetadataFiles(const metadata_files_t& files, bool LoadMetadataFiles(const metadata_files_t& files,
SampleMuxerMetadata* metadata) { libwebm::SampleMuxerMetadata* metadata) {
typedef metadata_files_t::const_iterator iter_t; typedef metadata_files_t::const_iterator iter_t;
iter_t i = files.begin(); iter_t i = files.begin();
@@ -112,14 +109,14 @@ int ParseArgWebVTT(char* argv[], int* argv_index, int argc_check,
enum { kCount = 5 }; enum { kCount = 5 };
struct Arg { struct Arg {
const char* name; const char* name;
SampleMuxerMetadata::Kind kind; libwebm::SampleMuxerMetadata::Kind kind;
}; };
const Arg args[kCount] = { const Arg args[kCount] = {
{"-webvtt-subtitles", SampleMuxerMetadata::kSubtitles}, {"-webvtt-subtitles", libwebm::SampleMuxerMetadata::kSubtitles},
{"-webvtt-captions", SampleMuxerMetadata::kCaptions}, {"-webvtt-captions", libwebm::SampleMuxerMetadata::kCaptions},
{"-webvtt-descriptions", SampleMuxerMetadata::kDescriptions}, {"-webvtt-descriptions", libwebm::SampleMuxerMetadata::kDescriptions},
{"-webvtt-metadata", SampleMuxerMetadata::kMetadata}, {"-webvtt-metadata", libwebm::SampleMuxerMetadata::kMetadata},
{"-webvtt-chapters", SampleMuxerMetadata::kChapters}}; {"-webvtt-chapters", libwebm::SampleMuxerMetadata::kChapters}};
for (int idx = 0; idx < kCount; ++idx) { for (int idx = 0; idx < kCount; ++idx) {
const Arg& arg = args[idx]; const Arg& arg = args[idx];
@@ -159,8 +156,8 @@ int main(int argc, char* argv[]) {
bool cues_before_clusters = false; bool cues_before_clusters = false;
bool cues_on_video_track = true; bool cues_on_video_track = true;
bool cues_on_audio_track = false; bool cues_on_audio_track = false;
uint64 max_cluster_duration = 0; libwebm::uint64 max_cluster_duration = 0;
uint64 max_cluster_size = 0; libwebm::uint64 max_cluster_size = 0;
bool switch_tracks = false; bool switch_tracks = false;
int audio_track_number = 0; // 0 tells muxer to decide. int audio_track_number = 0; // 0 tells muxer to decide.
int video_track_number = 0; // 0 tells muxer to decide. int video_track_number = 0; // 0 tells muxer to decide.
@@ -170,9 +167,9 @@ int main(int argc, char* argv[]) {
bool output_cues_block_number = true; bool output_cues_block_number = true;
uint64 display_width = 0; libwebm::uint64 display_width = 0;
uint64 display_height = 0; libwebm::uint64 display_height = 0;
uint64 stereo_mode = 0; libwebm::uint64 stereo_mode = 0;
metadata_files_t metadata_files; metadata_files_t metadata_files;
@@ -207,7 +204,8 @@ int main(int argc, char* argv[]) {
cues_on_video_track = false; cues_on_video_track = false;
} else if (!strcmp("-max_cluster_duration", argv[i]) && i < argc_check) { } else if (!strcmp("-max_cluster_duration", argv[i]) && i < argc_check) {
const double seconds = strtod(argv[++i], &end); const double seconds = strtod(argv[++i], &end);
max_cluster_duration = static_cast<uint64>(seconds * 1000000000.0); max_cluster_duration =
static_cast<libwebm::uint64>(seconds * 1000000000.0);
} else if (!strcmp("-max_cluster_size", argv[i]) && i < argc_check) { } else if (!strcmp("-max_cluster_size", argv[i]) && i < argc_check) {
max_cluster_size = strtol(argv[++i], &end, 10); max_cluster_size = strtol(argv[++i], &end, 10);
} else if (!strcmp("-switch_tracks", argv[i]) && i < argc_check) { } else if (!strcmp("-switch_tracks", argv[i]) && i < argc_check) {
@@ -243,7 +241,7 @@ int main(int argc, char* argv[]) {
} }
// Get parser header info // Get parser header info
mkvparser::MkvReader reader; libwebm::mkvparser::MkvReader reader;
if (reader.Open(input)) { if (reader.Open(input)) {
printf("\n Filename is invalid or error while opening.\n"); printf("\n Filename is invalid or error while opening.\n");
@@ -251,28 +249,31 @@ int main(int argc, char* argv[]) {
} }
long long pos = 0; long long pos = 0;
mkvparser::EBMLHeader ebml_header; libwebm::mkvparser::EBMLHeader ebml_header;
long long ret = ebml_header.Parse(&reader, pos); long long ret = ebml_header.Parse(&reader, pos);
if (ret) { if (ret) {
printf("\n EBMLHeader::Parse() failed."); printf("\n EBMLHeader::Parse() failed.");
return EXIT_FAILURE; return EXIT_FAILURE;
} }
mkvparser::Segment* parser_segment_; libwebm::mkvparser::Segment* parser_segment_;
ret = mkvparser::Segment::CreateInstance(&reader, pos, parser_segment_); ret = libwebm::mkvparser::Segment::CreateInstance(&reader, pos,
parser_segment_);
if (ret) { if (ret) {
printf("\n Segment::CreateInstance() failed."); printf("\n Segment::CreateInstance() failed.");
return EXIT_FAILURE; return EXIT_FAILURE;
} }
const std::auto_ptr<mkvparser::Segment> parser_segment(parser_segment_); const std::auto_ptr<libwebm::mkvparser::Segment> parser_segment(
parser_segment_);
ret = parser_segment->Load(); ret = parser_segment->Load();
if (ret < 0) { if (ret < 0) {
printf("\n Segment::Load() failed."); printf("\n Segment::Load() failed.");
return EXIT_FAILURE; return EXIT_FAILURE;
} }
const mkvparser::SegmentInfo* const segment_info = parser_segment->GetInfo(); const libwebm::mkvparser::SegmentInfo* const segment_info =
parser_segment->GetInfo();
if (segment_info == NULL) { if (segment_info == NULL) {
printf("\n Segment::GetInfo() failed."); printf("\n Segment::GetInfo() failed.");
return EXIT_FAILURE; return EXIT_FAILURE;
@@ -280,7 +281,7 @@ int main(int argc, char* argv[]) {
const long long timeCodeScale = segment_info->GetTimeCodeScale(); const long long timeCodeScale = segment_info->GetTimeCodeScale();
// Set muxer header info // Set muxer header info
mkvmuxer::MkvWriter writer; libwebm::mkvmuxer::MkvWriter writer;
const std::string temp_file = libwebm::GetTempFileName(); const std::string temp_file = libwebm::GetTempFileName();
if (!writer.Open(cues_before_clusters ? temp_file.c_str() : output)) { if (!writer.Open(cues_before_clusters ? temp_file.c_str() : output)) {
@@ -289,7 +290,7 @@ int main(int argc, char* argv[]) {
} }
// Set Segment element attributes // Set Segment element attributes
mkvmuxer::Segment muxer_segment; libwebm::mkvmuxer::Segment muxer_segment;
if (!muxer_segment.Init(&writer)) { if (!muxer_segment.Init(&writer)) {
printf("\n Could not initialize muxer segment!\n"); printf("\n Could not initialize muxer segment!\n");
@@ -297,9 +298,9 @@ int main(int argc, char* argv[]) {
} }
if (live_mode) if (live_mode)
muxer_segment.set_mode(mkvmuxer::Segment::kLive); muxer_segment.set_mode(libwebm::mkvmuxer::Segment::kLive);
else else
muxer_segment.set_mode(mkvmuxer::Segment::kFile); muxer_segment.set_mode(libwebm::mkvmuxer::Segment::kFile);
if (chunking) if (chunking)
muxer_segment.SetChunking(true, chunk_name); muxer_segment.SetChunking(true, chunk_name);
@@ -311,18 +312,18 @@ int main(int argc, char* argv[]) {
muxer_segment.OutputCues(output_cues); muxer_segment.OutputCues(output_cues);
// Set SegmentInfo element attributes // Set SegmentInfo element attributes
mkvmuxer::SegmentInfo* const info = muxer_segment.GetSegmentInfo(); libwebm::mkvmuxer::SegmentInfo* const info = muxer_segment.GetSegmentInfo();
info->set_timecode_scale(timeCodeScale); info->set_timecode_scale(timeCodeScale);
info->set_writing_app("sample_muxer"); info->set_writing_app("sample_muxer");
const mkvparser::Tags* const tags = parser_segment->GetTags(); const libwebm::mkvparser::Tags* const tags = parser_segment->GetTags();
if (copy_tags && tags) { if (copy_tags && tags) {
for (int i = 0; i < tags->GetTagCount(); i++) { for (int i = 0; i < tags->GetTagCount(); i++) {
const mkvparser::Tags::Tag* const tag = tags->GetTag(i); const libwebm::mkvparser::Tags::Tag* const tag = tags->GetTag(i);
mkvmuxer::Tag* muxer_tag = muxer_segment.AddTag(); libwebm::mkvmuxer::Tag* muxer_tag = muxer_segment.AddTag();
for (int j = 0; j < tag->GetSimpleTagCount(); j++) { for (int j = 0; j < tag->GetSimpleTagCount(); j++) {
const mkvparser::Tags::SimpleTag* const simple_tag = const libwebm::mkvparser::Tags::SimpleTag* const simple_tag =
tag->GetSimpleTag(j); tag->GetSimpleTag(j);
muxer_tag->add_simple_tag(simple_tag->GetTagName(), muxer_tag->add_simple_tag(simple_tag->GetTagName(),
simple_tag->GetTagString()); simple_tag->GetTagString());
@@ -331,20 +332,20 @@ int main(int argc, char* argv[]) {
} }
// Set Tracks element attributes // Set Tracks element attributes
const mkvparser::Tracks* const parser_tracks = parser_segment->GetTracks(); const libwebm::mkvparser::Tracks* const parser_tracks =
parser_segment->GetTracks();
unsigned long i = 0; unsigned long i = 0;
uint64 vid_track = 0; // no track added libwebm::uint64 vid_track = 0; // no track added
uint64 aud_track = 0; // no track added libwebm::uint64 aud_track = 0; // no track added
using mkvparser::Track; using libwebm::mkvparser::Track;
while (i != parser_tracks->GetTracksCount()) { while (i != parser_tracks->GetTracksCount()) {
int track_num = i++; int track_num = i++;
if (switch_tracks) if (switch_tracks)
track_num = i % parser_tracks->GetTracksCount(); track_num = i % parser_tracks->GetTracksCount();
const mkvparser::Track* const parser_track = const Track* const parser_track = parser_tracks->GetTrackByIndex(track_num);
parser_tracks->GetTrackByIndex(track_num);
if (parser_track == NULL) if (parser_track == NULL)
continue; continue;
@@ -356,8 +357,8 @@ int main(int argc, char* argv[]) {
if (track_type == Track::kVideo && output_video) { if (track_type == Track::kVideo && output_video) {
// Get the video track from the parser // Get the video track from the parser
const mkvparser::VideoTrack* const pVideoTrack = const libwebm::mkvparser::VideoTrack* const pVideoTrack =
static_cast<const mkvparser::VideoTrack*>(parser_track); static_cast<const libwebm::mkvparser::VideoTrack*>(parser_track);
const long long width = pVideoTrack->GetWidth(); const long long width = pVideoTrack->GetWidth();
const long long height = pVideoTrack->GetHeight(); const long long height = pVideoTrack->GetHeight();
@@ -370,7 +371,8 @@ int main(int argc, char* argv[]) {
return EXIT_FAILURE; return EXIT_FAILURE;
} }
mkvmuxer::VideoTrack* const video = static_cast<mkvmuxer::VideoTrack*>( libwebm::mkvmuxer::VideoTrack* const video =
static_cast<libwebm::mkvmuxer::VideoTrack*>(
muxer_segment.GetTrackByNumber(vid_track)); muxer_segment.GetTrackByNumber(vid_track));
if (!video) { if (!video) {
printf("\n Could not get video track.\n"); printf("\n Could not get video track.\n");
@@ -378,7 +380,7 @@ int main(int argc, char* argv[]) {
} }
if (pVideoTrack->GetColour()) { if (pVideoTrack->GetColour()) {
mkvmuxer::Colour muxer_colour; libwebm::mkvmuxer::Colour muxer_colour;
if (!libwebm::CopyColour(*pVideoTrack->GetColour(), &muxer_colour)) if (!libwebm::CopyColour(*pVideoTrack->GetColour(), &muxer_colour))
return EXIT_FAILURE; return EXIT_FAILURE;
if (!video->SetColour(muxer_colour)) if (!video->SetColour(muxer_colour))
@@ -403,8 +405,8 @@ int main(int argc, char* argv[]) {
} }
} else if (track_type == Track::kAudio && output_audio) { } else if (track_type == Track::kAudio && output_audio) {
// Get the audio track from the parser // Get the audio track from the parser
const mkvparser::AudioTrack* const pAudioTrack = const libwebm::mkvparser::AudioTrack* const pAudioTrack =
static_cast<const mkvparser::AudioTrack*>(parser_track); static_cast<const libwebm::mkvparser::AudioTrack*>(parser_track);
const long long channels = pAudioTrack->GetChannels(); const long long channels = pAudioTrack->GetChannels();
const double sample_rate = pAudioTrack->GetSamplingRate(); const double sample_rate = pAudioTrack->GetSamplingRate();
@@ -417,7 +419,8 @@ int main(int argc, char* argv[]) {
return EXIT_FAILURE; return EXIT_FAILURE;
} }
mkvmuxer::AudioTrack* const audio = static_cast<mkvmuxer::AudioTrack*>( libwebm::mkvmuxer::AudioTrack* const audio =
static_cast<libwebm::mkvmuxer::AudioTrack*>(
muxer_segment.GetTrackByNumber(aud_track)); muxer_segment.GetTrackByNumber(aud_track));
if (!audio) { if (!audio) {
printf("\n Could not get audio track.\n"); printf("\n Could not get audio track.\n");
@@ -455,7 +458,7 @@ int main(int argc, char* argv[]) {
// add a track to the output file corresponding to each metadata // add a track to the output file corresponding to each metadata
// input file. // input file.
SampleMuxerMetadata metadata; libwebm::SampleMuxerMetadata metadata;
if (!metadata.Init(&muxer_segment)) { if (!metadata.Init(&muxer_segment)) {
printf("\n Could not initialize metadata cache.\n"); printf("\n Could not initialize metadata cache.\n");
@@ -469,7 +472,7 @@ int main(int argc, char* argv[]) {
return EXIT_FAILURE; return EXIT_FAILURE;
// Set Cues element attributes // Set Cues element attributes
mkvmuxer::Cues* const cues = muxer_segment.GetCues(); libwebm::mkvmuxer::Cues* const cues = muxer_segment.GetCues();
cues->set_output_block_number(output_cues_block_number); cues->set_output_block_number(output_cues_block_number);
if (cues_on_video_track && vid_track) if (cues_on_video_track && vid_track)
muxer_segment.CuesTrack(vid_track); muxer_segment.CuesTrack(vid_track);
@@ -480,10 +483,10 @@ int main(int argc, char* argv[]) {
unsigned char* data = NULL; unsigned char* data = NULL;
int data_len = 0; int data_len = 0;
const mkvparser::Cluster* cluster = parser_segment->GetFirst(); const libwebm::mkvparser::Cluster* cluster = parser_segment->GetFirst();
while ((cluster != NULL) && !cluster->EOS()) { while ((cluster != NULL) && !cluster->EOS()) {
const mkvparser::BlockEntry* block_entry; const libwebm::mkvparser::BlockEntry* block_entry;
long status = cluster->GetFirst(block_entry); long status = cluster->GetFirst(block_entry);
@@ -493,9 +496,9 @@ int main(int argc, char* argv[]) {
} }
while ((block_entry != NULL) && !block_entry->EOS()) { while ((block_entry != NULL) && !block_entry->EOS()) {
const mkvparser::Block* const block = block_entry->GetBlock(); const libwebm::mkvparser::Block* const block = block_entry->GetBlock();
const long long trackNum = block->GetTrackNumber(); const long long trackNum = block->GetTrackNumber();
const mkvparser::Track* const parser_track = const libwebm::mkvparser::Track* const parser_track =
parser_tracks->GetTrackByNumber(static_cast<unsigned long>(trackNum)); parser_tracks->GetTrackByNumber(static_cast<unsigned long>(trackNum));
// When |parser_track| is NULL, it means that the track number in the // When |parser_track| is NULL, it means that the track number in the
@@ -518,7 +521,7 @@ int main(int argc, char* argv[]) {
const int frame_count = block->GetFrameCount(); const int frame_count = block->GetFrameCount();
for (int i = 0; i < frame_count; ++i) { for (int i = 0; i < frame_count; ++i) {
const mkvparser::Block::Frame& frame = block->GetFrame(i); const libwebm::mkvparser::Block::Frame& frame = block->GetFrame(i);
if (frame.len > data_len) { if (frame.len > data_len) {
delete[] data; delete[] data;
@@ -531,7 +534,7 @@ int main(int argc, char* argv[]) {
if (frame.Read(&reader, data)) if (frame.Read(&reader, data))
return EXIT_FAILURE; return EXIT_FAILURE;
mkvmuxer::Frame muxer_frame; libwebm::mkvmuxer::Frame muxer_frame;
if (!muxer_frame.Init(data, frame.len)) if (!muxer_frame.Init(data, frame.len))
return EXIT_FAILURE; return EXIT_FAILURE;
muxer_frame.set_track_number(track_type == Track::kAudio ? aud_track : muxer_frame.set_track_number(track_type == Track::kAudio ? aud_track :

30
sample_muxer_metadata.cc
View File

@@ -17,6 +17,8 @@
#include "mkvmuxer.hpp" #include "mkvmuxer.hpp"
#include "vttreader.h" #include "vttreader.h"
namespace libwebm {
SampleMuxerMetadata::SampleMuxerMetadata() : segment_(NULL) {} SampleMuxerMetadata::SampleMuxerMetadata() : segment_(NULL) {}
bool SampleMuxerMetadata::Init(mkvmuxer::Segment* segment) { bool SampleMuxerMetadata::Init(mkvmuxer::Segment* segment) {
@@ -31,7 +33,7 @@ bool SampleMuxerMetadata::Load(const char* file, Kind kind) {
if (kind == kChapters) if (kind == kChapters)
return LoadChapters(file); return LoadChapters(file);
mkvmuxer::uint64 track_num; uint64 track_num;
if (!AddTrack(kind, &track_num)) { if (!AddTrack(kind, &track_num)) {
printf("Unable to add track for WebVTT file \"%s\"\n", file); printf("Unable to add track for WebVTT file \"%s\"\n", file);
@@ -56,7 +58,7 @@ bool SampleMuxerMetadata::AddChapters() {
return true; return true;
} }
bool SampleMuxerMetadata::Write(mkvmuxer::int64 time_ns) { bool SampleMuxerMetadata::Write(int64 time_ns) {
typedef cues_set_t::iterator iter_t; typedef cues_set_t::iterator iter_t;
iter_t i = cues_set_.begin(); iter_t i = cues_set_.begin();
@@ -172,8 +174,8 @@ bool SampleMuxerMetadata::AddChapter(const cue_t& cue) {
const time_ms_t stop_time_ms = cue.stop_time.presentation(); const time_ms_t stop_time_ms = cue.stop_time.presentation();
enum { kNsPerMs = 1000000 }; enum { kNsPerMs = 1000000 };
const mkvmuxer::uint64 start_time_ns = start_time_ms * kNsPerMs; const uint64 start_time_ns = start_time_ms * kNsPerMs;
const mkvmuxer::uint64 stop_time_ns = stop_time_ms * kNsPerMs; const uint64 stop_time_ns = stop_time_ms * kNsPerMs;
chapter->set_time(*segment_, start_time_ns, stop_time_ns); chapter->set_time(*segment_, start_time_ns, stop_time_ns);
@@ -201,7 +203,7 @@ bool SampleMuxerMetadata::AddChapter(const cue_t& cue) {
return true; return true;
} }
bool SampleMuxerMetadata::AddTrack(Kind kind, mkvmuxer::uint64* track_num) { bool SampleMuxerMetadata::AddTrack(Kind kind, uint64* track_num) {
*track_num = 0; *track_num = 0;
// Track number value 0 means "let muxer choose track number" // Track number value 0 means "let muxer choose track number"
@@ -250,7 +252,7 @@ bool SampleMuxerMetadata::AddTrack(Kind kind, mkvmuxer::uint64* track_num) {
} }
bool SampleMuxerMetadata::Parse(const char* file, Kind /* kind */, bool SampleMuxerMetadata::Parse(const char* file, Kind /* kind */,
mkvmuxer::uint64 track_num) { uint64 track_num) {
libwebvtt::VttReader r; libwebvtt::VttReader r;
int e = r.Open(file); int e = r.Open(file);
@@ -359,26 +361,26 @@ void SampleMuxerMetadata::WriteCuePayload(const cue_t::payload_t& payload,
bool SampleMuxerMetadata::SortableCue::Write(mkvmuxer::Segment* segment) const { bool SampleMuxerMetadata::SortableCue::Write(mkvmuxer::Segment* segment) const {
// Cue start time expressed in milliseconds // Cue start time expressed in milliseconds
const mkvmuxer::int64 start_ms = cue.start_time.presentation(); const int64 start_ms = cue.start_time.presentation();
// Cue start time expressed in nanoseconds (MKV time) // Cue start time expressed in nanoseconds (MKV time)
const mkvmuxer::int64 start_ns = start_ms * 1000000; const int64 start_ns = start_ms * 1000000;
// Cue stop time expressed in milliseconds // Cue stop time expressed in milliseconds
const mkvmuxer::int64 stop_ms = cue.stop_time.presentation(); const int64 stop_ms = cue.stop_time.presentation();
// Cue stop time expressed in nanonseconds // Cue stop time expressed in nanonseconds
const mkvmuxer::int64 stop_ns = stop_ms * 1000000; const int64 stop_ns = stop_ms * 1000000;
// Metadata blocks always specify the block duration. // Metadata blocks always specify the block duration.
const mkvmuxer::int64 duration_ns = stop_ns - start_ns; const int64 duration_ns = stop_ns - start_ns;
std::string frame; std::string frame;
MakeFrame(cue, &frame); MakeFrame(cue, &frame);
typedef const mkvmuxer::uint8* data_t; typedef const uint8* data_t;
const data_t buf = reinterpret_cast<data_t>(frame.data()); const data_t buf = reinterpret_cast<data_t>(frame.data());
const mkvmuxer::uint64 len = frame.length(); const uint64 len = frame.length();
mkvmuxer::Frame muxer_frame; mkvmuxer::Frame muxer_frame;
if (!muxer_frame.Init(buf, len)) if (!muxer_frame.Init(buf, len))
@@ -389,3 +391,5 @@ bool SampleMuxerMetadata::SortableCue::Write(mkvmuxer::Segment* segment) const {
muxer_frame.set_is_key(true); // All metadata frames are keyframes. muxer_frame.set_is_key(true); // All metadata frames are keyframes.
return segment->AddGenericFrame(&muxer_frame); return segment->AddGenericFrame(&muxer_frame);
} }
} // namespace libwebm

18
sample_muxer_metadata.h
View File

@@ -16,6 +16,8 @@
#include "mkvmuxertypes.hpp" #include "mkvmuxertypes.hpp"
#include "webvttparser.h" #include "webvttparser.h"
namespace libwebm {
namespace mkvmuxer { namespace mkvmuxer {
class Chapter; class Chapter;
class Frame; class Frame;
@@ -43,19 +45,19 @@ class SampleMuxerMetadata {
// Write any WebVTT cues whose time is less or equal to |time_ns| as // Write any WebVTT cues whose time is less or equal to |time_ns| as
// a metadata block in its corresponding track. If |time_ns| is // a metadata block in its corresponding track. If |time_ns| is
// negative, write all remaining cues. Returns false on error. // negative, write all remaining cues. Returns false on error.
bool Write(mkvmuxer::int64 time_ns); bool Write(int64 time_ns);
private: private:
typedef libwebvtt::Cue cue_t; typedef libwebvtt::Cue cue_t;
// Used to sort cues as they are loaded. // Used to sort cues as they are loaded.
struct SortableCue { struct SortableCue {
bool operator>(mkvmuxer::int64 time_ns) const { bool operator>(int64 time_ns) const {
// Cue start time expressed in milliseconds // Cue start time expressed in milliseconds
const mkvmuxer::int64 start_ms = cue.start_time.presentation(); const int64 start_ms = cue.start_time.presentation();
// Cue start time expressed in nanoseconds (MKV time) // Cue start time expressed in nanoseconds (MKV time)
const mkvmuxer::int64 start_ns = start_ms * 1000000; const int64 start_ns = start_ms * 1000000;
return (start_ns > time_ns); return (start_ns > time_ns);
} }
@@ -74,7 +76,7 @@ class SampleMuxerMetadata {
// error. // error.
bool Write(mkvmuxer::Segment* segment) const; bool Write(mkvmuxer::Segment* segment) const;
mkvmuxer::uint64 track_num; uint64 track_num;
cue_t cue; cue_t cue;
}; };
@@ -97,12 +99,12 @@ class SampleMuxerMetadata {
// Add a metadata track to the segment having the indicated |kind|, // Add a metadata track to the segment having the indicated |kind|,
// returning the |track_num| that has been chosen for this track. // returning the |track_num| that has been chosen for this track.
// Returns false on error. // Returns false on error.
bool AddTrack(Kind kind, mkvmuxer::uint64* track_num); bool AddTrack(Kind kind, uint64* track_num);
// Parse the WebVTT |file| having the indicated |kind| and // Parse the WebVTT |file| having the indicated |kind| and
// |track_num|, adding each parsed cue to cues set. Returns false // |track_num|, adding each parsed cue to cues set. Returns false
// on error. // on error.
bool Parse(const char* file, Kind kind, mkvmuxer::uint64 track_num); bool Parse(const char* file, Kind kind, uint64 track_num);
// Converts a WebVTT cue to a Matroska metadata block. // Converts a WebVTT cue to a Matroska metadata block.
static void MakeFrame(const cue_t& cue, std::string* frame); static void MakeFrame(const cue_t& cue, std::string* frame);
@@ -133,4 +135,6 @@ class SampleMuxerMetadata {
SampleMuxerMetadata& operator=(const SampleMuxerMetadata&); SampleMuxerMetadata& operator=(const SampleMuxerMetadata&);
}; };
} // namespace libwebm
#endif // SAMPLE_MUXER_METADATA_H_ // NOLINT #endif // SAMPLE_MUXER_METADATA_H_ // NOLINT

45
testing/muxer_tests.cc
View File

@@ -14,8 +14,8 @@
#include <ostream> #include <ostream>
#include <string> #include <string>
#include "gtest/gtest.h"
#include "gtest/gtest-message.h" #include "gtest/gtest-message.h"
#include "gtest/gtest.h"
#include "mkvmuxer.hpp" #include "mkvmuxer.hpp"
#include "mkvmuxertypes.hpp" #include "mkvmuxertypes.hpp"
@@ -31,14 +31,14 @@
#pragma warning(disable : 4996) #pragma warning(disable : 4996)
#endif #endif
using ::mkvmuxer::AudioTrack; using libwebm::mkvmuxer::AudioTrack;
using ::mkvmuxer::Chapter; using libwebm::mkvmuxer::Chapter;
using ::mkvmuxer::Frame; using libwebm::mkvmuxer::Frame;
using ::mkvmuxer::MkvWriter; using libwebm::mkvmuxer::MkvWriter;
using ::mkvmuxer::Segment; using libwebm::mkvmuxer::Segment;
using ::mkvmuxer::SegmentInfo; using libwebm::mkvmuxer::SegmentInfo;
using ::mkvmuxer::Track; using libwebm::mkvmuxer::Track;
using ::mkvmuxer::VideoTrack; using libwebm::mkvmuxer::VideoTrack;
namespace libwebm { namespace libwebm {
namespace test { namespace test {
@@ -123,8 +123,7 @@ TEST_F(MuxerTest, SegmentInfo) {
info->set_duration(2.345); info->set_duration(2.345);
EXPECT_STREQ(kAppString, info->muxing_app()); EXPECT_STREQ(kAppString, info->muxing_app());
EXPECT_STREQ(kAppString, info->writing_app()); EXPECT_STREQ(kAppString, info->writing_app());
EXPECT_EQ(static_cast<mkvmuxer::uint64>(kTimeCodeScale), EXPECT_EQ(static_cast<uint64>(kTimeCodeScale), info->timecode_scale());
info->timecode_scale());
EXPECT_DOUBLE_EQ(2.345, info->duration()); EXPECT_DOUBLE_EQ(2.345, info->duration());
AddVideoTrack(); AddVideoTrack();
@@ -142,19 +141,19 @@ TEST_F(MuxerTest, AddTracks) {
VideoTrack* const video = VideoTrack* const video =
dynamic_cast<VideoTrack*>(segment_.GetTrackByNumber(kVideoTrackNumber)); dynamic_cast<VideoTrack*>(segment_.GetTrackByNumber(kVideoTrackNumber));
ASSERT_TRUE(video != NULL); ASSERT_TRUE(video != NULL);
EXPECT_EQ(static_cast<mkvmuxer::uint64>(kWidth), video->width()); EXPECT_EQ(static_cast<uint64>(kWidth), video->width());
EXPECT_EQ(static_cast<mkvmuxer::uint64>(kHeight), video->height()); EXPECT_EQ(static_cast<uint64>(kHeight), video->height());
video->set_name(kTrackName); video->set_name(kTrackName);
video->set_display_width(kWidth - 10); video->set_display_width(kWidth - 10);
video->set_display_height(kHeight - 10); video->set_display_height(kHeight - 10);
video->set_frame_rate(0.5); video->set_frame_rate(0.5);
EXPECT_STREQ(kTrackName, video->name()); EXPECT_STREQ(kTrackName, video->name());
const mkvmuxer::uint64 kDisplayWidth = kWidth - 10; const uint64 kDisplayWidth = kWidth - 10;
EXPECT_EQ(kDisplayWidth, video->display_width()); EXPECT_EQ(kDisplayWidth, video->display_width());
const mkvmuxer::uint64 kDisplayHeight = kHeight - 10; const uint64 kDisplayHeight = kHeight - 10;
EXPECT_EQ(kDisplayHeight, video->display_height()); EXPECT_EQ(kDisplayHeight, video->display_height());
EXPECT_DOUBLE_EQ(0.5, video->frame_rate()); EXPECT_DOUBLE_EQ(0.5, video->frame_rate());
EXPECT_EQ(static_cast<mkvmuxer::uint64>(kVideoTrackNumber), video->uid()); EXPECT_EQ(static_cast<uint64>(kVideoTrackNumber), video->uid());
// Add an Audio Track // Add an Audio Track
const int aud_track = const int aud_track =
@@ -163,14 +162,14 @@ TEST_F(MuxerTest, AddTracks) {
AudioTrack* const audio = AudioTrack* const audio =
dynamic_cast<AudioTrack*>(segment_.GetTrackByNumber(aud_track)); dynamic_cast<AudioTrack*>(segment_.GetTrackByNumber(aud_track));
EXPECT_EQ(kSampleRate, audio->sample_rate()); EXPECT_EQ(kSampleRate, audio->sample_rate());
EXPECT_EQ(static_cast<mkvmuxer::uint64>(kChannels), audio->channels()); EXPECT_EQ(static_cast<uint64>(kChannels), audio->channels());
ASSERT_TRUE(audio != NULL); ASSERT_TRUE(audio != NULL);
audio->set_name(kTrackName); audio->set_name(kTrackName);
audio->set_bit_depth(kBitDepth); audio->set_bit_depth(kBitDepth);
audio->set_uid(kAudioTrackNumber); audio->set_uid(kAudioTrackNumber);
EXPECT_STREQ(kTrackName, audio->name()); EXPECT_STREQ(kTrackName, audio->name());
EXPECT_EQ(static_cast<mkvmuxer::uint64>(kBitDepth), audio->bit_depth()); EXPECT_EQ(static_cast<uint64>(kBitDepth), audio->bit_depth());
EXPECT_EQ(static_cast<mkvmuxer::uint64>(kAudioTrackNumber), audio->uid()); EXPECT_EQ(static_cast<uint64>(kAudioTrackNumber), audio->uid());
AddDummyFrameAndFinalize(kVideoTrackNumber); AddDummyFrameAndFinalize(kVideoTrackNumber);
CloseWriter(); CloseWriter();
@@ -488,7 +487,7 @@ TEST_F(MuxerTest, CuesBeforeClusters) {
TEST_F(MuxerTest, MaxClusterSize) { TEST_F(MuxerTest, MaxClusterSize) {
EXPECT_TRUE(SegmentInit(false)); EXPECT_TRUE(SegmentInit(false));
AddVideoTrack(); AddVideoTrack();
const mkvmuxer::uint64 kMaxClusterSize = 20; const uint64 kMaxClusterSize = 20;
segment_.set_max_cluster_size(kMaxClusterSize); segment_.set_max_cluster_size(kMaxClusterSize);
EXPECT_EQ(kMaxClusterSize, segment_.max_cluster_size()); EXPECT_EQ(kMaxClusterSize, segment_.max_cluster_size());
EXPECT_TRUE(segment_.AddFrame(dummy_data_, 1, kVideoTrackNumber, 0, false)); EXPECT_TRUE(segment_.AddFrame(dummy_data_, 1, kVideoTrackNumber, 0, false));
@@ -513,7 +512,7 @@ TEST_F(MuxerTest, MaxClusterSize) {
TEST_F(MuxerTest, MaxClusterDuration) { TEST_F(MuxerTest, MaxClusterDuration) {
EXPECT_TRUE(SegmentInit(false)); EXPECT_TRUE(SegmentInit(false));
AddVideoTrack(); AddVideoTrack();
const mkvmuxer::uint64 kMaxClusterDuration = 4000000; const uint64 kMaxClusterDuration = 4000000;
segment_.set_max_cluster_duration(kMaxClusterDuration); segment_.set_max_cluster_duration(kMaxClusterDuration);
EXPECT_EQ(kMaxClusterDuration, segment_.max_cluster_duration()); EXPECT_EQ(kMaxClusterDuration, segment_.max_cluster_duration());
@@ -538,9 +537,9 @@ TEST_F(MuxerTest, MaxClusterDuration) {
} }
TEST_F(MuxerTest, SetCuesTrackNumber) { TEST_F(MuxerTest, SetCuesTrackNumber) {
const mkvmuxer::uint64 kTrackNumber = 10; const uint64 kTrackNumber = 10;
EXPECT_TRUE(SegmentInit(true)); EXPECT_TRUE(SegmentInit(true));
const mkvmuxer::uint64 vid_track = const uint64 vid_track =
segment_.AddVideoTrack(kWidth, kHeight, kTrackNumber); segment_.AddVideoTrack(kWidth, kHeight, kTrackNumber);
EXPECT_EQ(kTrackNumber, vid_track); EXPECT_EQ(kTrackNumber, vid_track);
segment_.GetTrackByNumber(vid_track)->set_uid(kVideoTrackNumber); segment_.GetTrackByNumber(vid_track)->set_uid(kVideoTrackNumber);

26
testing/parser_tests.cc
View File

@@ -19,19 +19,19 @@
#include "testing/test_util.h" #include "testing/test_util.h"
using ::mkvparser::AudioTrack; using libwebm::mkvparser::AudioTrack;
using ::mkvparser::Block; using libwebm::mkvparser::Block;
using ::mkvparser::BlockEntry; using libwebm::mkvparser::BlockEntry;
using ::mkvparser::BlockGroup; using libwebm::mkvparser::BlockGroup;
using ::mkvparser::Cluster; using libwebm::mkvparser::Cluster;
using ::mkvparser::CuePoint; using libwebm::mkvparser::CuePoint;
using ::mkvparser::Cues; using libwebm::mkvparser::Cues;
using ::mkvparser::MkvReader; using libwebm::mkvparser::MkvReader;
using ::mkvparser::Segment; using libwebm::mkvparser::Segment;
using ::mkvparser::SegmentInfo; using libwebm::mkvparser::SegmentInfo;
using ::mkvparser::Track; using libwebm::mkvparser::Track;
using ::mkvparser::Tracks; using libwebm::mkvparser::Tracks;
using ::mkvparser::VideoTrack; using libwebm::mkvparser::VideoTrack;
namespace libwebm { namespace libwebm {
namespace test { namespace test {

105
vttdemux.cc
View File

@@ -6,8 +6,8 @@
// in the file PATENTS. All contributing project authors may // in the file PATENTS. All contributing project authors may
// be found in the AUTHORS file in the root of the source tree. // be found in the AUTHORS file in the root of the source tree.
#include <cstdlib>
#include <cstdio> #include <cstdio>
#include <cstdlib>
#include <cstring> #include <cstring>
#include <map> #include <map>
#include <memory> #include <memory>
@@ -25,6 +25,7 @@
using std::string; using std::string;
namespace libwebm {
namespace vttdemux { namespace vttdemux {
typedef long long mkvtime_t; // NOLINT typedef long long mkvtime_t; // NOLINT
@@ -221,56 +222,6 @@ bool WriteCueTime(FILE* f, mkvtime_t time_ns);
bool WriteCuePayload(FILE* f, FrameParser* parser); bool WriteCuePayload(FILE* f, FrameParser* parser);
} // namespace vttdemux } // namespace vttdemux
int main(int argc, const char* argv[]) {
if (argc != 2) {
printf("usage: vttdemux <webmfile>\n");
return EXIT_SUCCESS;
}
const char* const filename = argv[1];
mkvparser::MkvReader reader;
int e = reader.Open(filename);
if (e) { // error
printf("unable to open file\n");
return EXIT_FAILURE;
}
vttdemux::mkvpos_t pos;
if (!vttdemux::ParseHeader(&reader, &pos))
return EXIT_FAILURE;
vttdemux::segment_ptr_t segment_ptr;
if (!vttdemux::ParseSegment(&reader, pos, &segment_ptr))
return EXIT_FAILURE;
vttdemux::metadata_map_t metadata_map;
BuildMap(segment_ptr.get(), &metadata_map);
if (metadata_map.empty()) {
printf("no WebVTT metadata found\n");
return EXIT_FAILURE;
}
if (!OpenFiles(&metadata_map, filename)) {
CloseFiles(&metadata_map); // nothing to flush, so not strictly necessary
return EXIT_FAILURE;
}
if (!WriteFiles(metadata_map, segment_ptr.get())) {
CloseFiles(&metadata_map); // might as well flush what we do have
return EXIT_FAILURE;
}
CloseFiles(&metadata_map);
return EXIT_SUCCESS;
}
namespace vttdemux { namespace vttdemux {
FrameParser::FrameParser(const mkvparser::BlockGroup* block_group) FrameParser::FrameParser(const mkvparser::BlockGroup* block_group)
@@ -1000,3 +951,55 @@ bool vttdemux::WriteCuePayload(FILE* f, FrameParser* parser) {
return true; return true;
} }
} // namespace libwebm
int main(int argc, const char* argv[]) {
if (argc != 2) {
printf("usage: vttdemux <webmfile>\n");
return EXIT_SUCCESS;
}
const char* const filename = argv[1];
libwebm::mkvparser::MkvReader reader;
int e = reader.Open(filename);
if (e) { // error
printf("unable to open file\n");
return EXIT_FAILURE;
}
libwebm::vttdemux::mkvpos_t pos;
if (!libwebm::vttdemux::ParseHeader(&reader, &pos))
return EXIT_FAILURE;
libwebm::vttdemux::segment_ptr_t segment_ptr;
if (!libwebm::vttdemux::ParseSegment(&reader, pos, &segment_ptr))
return EXIT_FAILURE;
libwebm::vttdemux::metadata_map_t metadata_map;
BuildMap(segment_ptr.get(), &metadata_map);
if (metadata_map.empty()) {
printf("no WebVTT metadata found\n");
return EXIT_FAILURE;
}
if (!OpenFiles(&metadata_map, filename)) {
CloseFiles(&metadata_map); // nothing to flush, so not strictly necessary
return EXIT_FAILURE;
}
if (!WriteFiles(metadata_map, segment_ptr.get())) {
CloseFiles(&metadata_map); // might as well flush what we do have
return EXIT_FAILURE;
}
CloseFiles(&metadata_map);
return EXIT_SUCCESS;
}

4
webmids.hpp
View File

@@ -9,7 +9,7 @@
#ifndef WEBMIDS_HPP #ifndef WEBMIDS_HPP
#define WEBMIDS_HPP #define WEBMIDS_HPP
namespace mkvmuxer { namespace libwebm {
enum MkvId { enum MkvId {
kMkvEBML = 0x1A45DFA3, kMkvEBML = 0x1A45DFA3,
@@ -179,6 +179,6 @@ enum MkvId {
kMkvTagString = 0x4487 kMkvTagString = 0x4487
}; };
} // end namespace mkvmuxer } // namespace libwebm
#endif // WEBMIDS_HPP #endif // WEBMIDS_HPP