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"
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.

4
mkvmuxer.cpp
View File

@@ -29,6 +29,7 @@
#pragma warning(disable : 4996)
#endif
namespace libwebm {
namespace mkvmuxer {
const float MasteringMetadata::kValueNotPresent = FLT_MAX;
@@ -121,7 +122,7 @@ bool WriteEbmlHeader(IMkvWriter* writer) {
}
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.
const uint32 kBufSize = 2048;
uint8* buf = new uint8[kBufSize];
@@ -3595,3 +3596,4 @@ bool Segment::WriteFramesLessThan(uint64 timestamp) {
}
} // namespace mkvmuxer
} // namespace libwebm

7
mkvmuxer.hpp
View File

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

6
mkvmuxertypes.hpp
View File

@@ -16,8 +16,10 @@
TypeName(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 short int16;
typedef int int32;
@@ -25,6 +27,6 @@ typedef unsigned int uint32;
typedef long long int64;
typedef unsigned long long uint64;
} // end namespace mkvmuxer
} // namespace libwebm
#endif // MKVMUXERTYPES_HPP

8
mkvmuxerutil.cpp
View File

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

4
mkvmuxerutil.hpp
View File

@@ -11,6 +11,7 @@
#include "mkvmuxertypes.hpp"
namespace libwebm {
namespace mkvmuxer {
class Cluster;
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).
uint64 MakeUID(unsigned int* seed);
} // end namespace mkvmuxer
} // namespace mkvmuxer
} // namespace libwebm
#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>
namespace libwebm {
namespace mkvparser {
const int E_PARSE_FAILED = -1;
@@ -1101,9 +1102,10 @@ class Segment {
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 size;

4
mkvreader.cpp
View File

@@ -10,6 +10,7 @@
#include <cassert>
namespace libwebm {
namespace mkvparser {
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
}
} // end namespace mkvparser
} // namespace mkvparser
} // namespace libwebm

4
mkvreader.hpp
View File

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

2
mkvwriter.cpp
View File

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

4
mkvwriter.hpp
View File

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

75
sample.cpp
View File

@@ -44,15 +44,15 @@ const wchar_t* utf8towcs(const char* str) {
return val;
}
bool InputHasCues(const mkvparser::Segment* const segment) {
const mkvparser::Cues* const cues = segment->GetCues();
bool InputHasCues(const libwebm::mkvparser::Segment* const segment) {
const libwebm::mkvparser::Cues* const cues = segment->GetCues();
if (cues == NULL)
return false;
while (!cues->DoneParsing())
cues->LoadCuePoint();
const mkvparser::CuePoint* const cue_point = cues->GetFirst();
const libwebm::mkvparser::CuePoint* const cue_point = cues->GetFirst();
if (cue_point == NULL)
return false;
@@ -60,11 +60,11 @@ bool InputHasCues(const mkvparser::Segment* const segment) {
}
bool MasteringMetadataValuePresent(double value) {
return value != mkvparser::MasteringMetadata::kValueNotPresent;
return value != libwebm::mkvparser::MasteringMetadata::kValueNotPresent;
}
bool ColourValuePresent(long long value) {
return value != mkvparser::Colour::kValueNotPresent;
return value != libwebm::mkvparser::Colour::kValueNotPresent;
}
} // namespace
@@ -77,9 +77,7 @@ int main(int argc, char* argv[]) {
return -1;
}
using namespace mkvparser;
MkvReader reader;
libwebm::mkvparser::MkvReader reader;
if (reader.Open(argv[1])) {
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;
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);
long long pos = 0;
EBMLHeader ebmlHeader;
libwebm::mkvparser::EBMLHeader ebmlHeader;
long long ret = ebmlHeader.Parse(&reader, pos);
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\tPos\t\t\t: %lld\n", pos);
typedef mkvparser::Segment seg_t;
typedef libwebm::mkvparser::Segment seg_t;
seg_t* pSegment_;
ret = seg_t::CreateInstance(&reader, pos, pSegment_);
@@ -125,7 +123,8 @@ int main(int argc, char* argv[]) {
return -1;
}
const SegmentInfo* const pSegmentInfo = pSegment->GetInfo();
const libwebm::mkvparser::SegmentInfo* const pSegmentInfo =
pSegment->GetInfo();
if (pSegmentInfo == NULL) {
printf("\n Segment::GetInfo() failed.");
return -1;
@@ -178,7 +177,7 @@ int main(int argc, char* argv[]) {
// size of segment payload
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;
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");
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)
continue;
@@ -224,9 +224,9 @@ int main(int argc, char* argv[]) {
delete[] pCodecName;
}
if (trackType == mkvparser::Track::kVideo) {
const VideoTrack* const pVideoTrack =
static_cast<const VideoTrack*>(pTrack);
if (trackType == libwebm::mkvparser::Track::kVideo) {
const libwebm::mkvparser::VideoTrack* const pVideoTrack =
static_cast<const libwebm::mkvparser::VideoTrack*>(pTrack);
const long long width = pVideoTrack->GetWidth();
printf("\t\tVideo Width\t\t: %lld\n", width);
@@ -237,7 +237,7 @@ int main(int argc, char* argv[]) {
const double rate = pVideoTrack->GetFrameRate();
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) {
printf("\t\tVideo Colour:\n");
if (ColourValuePresent(colour->matrix_coefficients))
@@ -273,7 +273,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 mkvparser::MasteringMetadata* const mm =
const libwebm::mkvparser::MasteringMetadata* const mm =
colour->mastering_metadata;
printf("\t\t\tMastering Metadata:\n");
if (MasteringMetadataValuePresent(mm->luminance_max))
@@ -302,9 +302,9 @@ int main(int argc, char* argv[]) {
}
}
if (trackType == mkvparser::Track::kAudio) {
const AudioTrack* const pAudioTrack =
static_cast<const AudioTrack*>(pTrack);
if (trackType == libwebm::mkvparser::Track::kAudio) {
const libwebm::mkvparser::AudioTrack* const pAudioTrack =
static_cast<const libwebm::mkvparser::AudioTrack*>(pTrack);
const long long channels = pAudioTrack->GetChannels();
printf("\t\tAudio Channels\t\t: %lld\n", channels);
@@ -333,7 +333,7 @@ int main(int argc, char* argv[]) {
return -1;
}
const mkvparser::Cluster* pCluster = pSegment->GetFirst();
const libwebm::mkvparser::Cluster* pCluster = pSegment->GetFirst();
while ((pCluster != NULL) && !pCluster->EOS()) {
const long long timeCode = pCluster->GetTimeCode();
@@ -342,7 +342,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 BlockEntry* pBlockEntry;
const libwebm::mkvparser::BlockEntry* pBlockEntry;
long status = pCluster->GetFirst(pBlockEntry);
@@ -354,10 +354,11 @@ int main(int argc, char* argv[]) {
}
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 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)
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();
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);
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 long offset = theFrame.pos;
printf("\t\t\t %15ld,%15llx\n", size, offset);
@@ -393,21 +395,22 @@ int main(int argc, char* argv[]) {
if (InputHasCues(pSegment.get())) {
// Walk them.
const mkvparser::Cues* const cues = pSegment->GetCues();
const mkvparser::CuePoint* cue = cues->GetFirst();
const libwebm::mkvparser::Cues* const cues = pSegment->GetCues();
const libwebm::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 mkvparser::Track* const track =
const libwebm::mkvparser::Track* const track =
pTracks->GetTrackByIndex(track_num);
const mkvparser::CuePoint::TrackPosition* const track_pos =
const libwebm::mkvparser::CuePoint::TrackPosition* const track_pos =
cue->Find(track);
if (track_pos != NULL) {
const char track_type =
(track->GetType() == mkvparser::Track::kVideo) ? 'V' : 'A';
(track->GetType() == libwebm::mkvparser::Track::kVideo) ? 'V' :
'A';
printf(
"\t\t\tCue Point %4d Track %3lu(%c) Time %14lld "
"Block %4lld Pos %8llx\n",
@@ -422,14 +425,14 @@ int main(int argc, char* argv[]) {
} while (cue != NULL);
}
const mkvparser::Tags* const tags = pSegment->GetTags();
const libwebm::mkvparser::Tags* const tags = pSegment->GetTags();
if (tags && tags->GetTagCount() > 0) {
printf("\t\tTags\n");
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");
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);
printf("\t\t\t\tSimple Tag \"%s\" Value \"%s\"\n",
simple_tag->GetTagName(), simple_tag->GetTagString());

113
sample_muxer.cpp
View File

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

30
sample_muxer_metadata.cc
View File

@@ -17,6 +17,8 @@
#include "mkvmuxer.hpp"
#include "vttreader.h"
namespace libwebm {
SampleMuxerMetadata::SampleMuxerMetadata() : segment_(NULL) {}
bool SampleMuxerMetadata::Init(mkvmuxer::Segment* segment) {
@@ -31,7 +33,7 @@ bool SampleMuxerMetadata::Load(const char* file, Kind kind) {
if (kind == kChapters)
return LoadChapters(file);
mkvmuxer::uint64 track_num;
uint64 track_num;
if (!AddTrack(kind, &track_num)) {
printf("Unable to add track for WebVTT file \"%s\"\n", file);
@@ -56,7 +58,7 @@ bool SampleMuxerMetadata::AddChapters() {
return true;
}
bool SampleMuxerMetadata::Write(mkvmuxer::int64 time_ns) {
bool SampleMuxerMetadata::Write(int64 time_ns) {
typedef cues_set_t::iterator iter_t;
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();
enum { kNsPerMs = 1000000 };
const mkvmuxer::uint64 start_time_ns = start_time_ms * kNsPerMs;
const mkvmuxer::uint64 stop_time_ns = stop_time_ms * kNsPerMs;
const uint64 start_time_ns = start_time_ms * kNsPerMs;
const uint64 stop_time_ns = stop_time_ms * kNsPerMs;
chapter->set_time(*segment_, start_time_ns, stop_time_ns);
@@ -201,7 +203,7 @@ bool SampleMuxerMetadata::AddChapter(const cue_t& cue) {
return true;
}
bool SampleMuxerMetadata::AddTrack(Kind kind, mkvmuxer::uint64* track_num) {
bool SampleMuxerMetadata::AddTrack(Kind kind, uint64* track_num) {
*track_num = 0;
// 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 */,
mkvmuxer::uint64 track_num) {
uint64 track_num) {
libwebvtt::VttReader r;
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 {
// 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)
const mkvmuxer::int64 start_ns = start_ms * 1000000;
const int64 start_ns = start_ms * 1000000;
// 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
const mkvmuxer::int64 stop_ns = stop_ms * 1000000;
const int64 stop_ns = stop_ms * 1000000;
// 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;
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 mkvmuxer::uint64 len = frame.length();
const uint64 len = frame.length();
mkvmuxer::Frame muxer_frame;
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.
return segment->AddGenericFrame(&muxer_frame);
}
} // namespace libwebm

18
sample_muxer_metadata.h
View File

@@ -16,6 +16,8 @@
#include "mkvmuxertypes.hpp"
#include "webvttparser.h"
namespace libwebm {
namespace mkvmuxer {
class Chapter;
class Frame;
@@ -43,19 +45,19 @@ class SampleMuxerMetadata {
// 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
// negative, write all remaining cues. Returns false on error.
bool Write(mkvmuxer::int64 time_ns);
bool Write(int64 time_ns);
private:
typedef libwebvtt::Cue cue_t;
// Used to sort cues as they are loaded.
struct SortableCue {
bool operator>(mkvmuxer::int64 time_ns) const {
bool operator>(int64 time_ns) const {
// 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)
const mkvmuxer::int64 start_ns = start_ms * 1000000;
const int64 start_ns = start_ms * 1000000;
return (start_ns > time_ns);
}
@@ -74,7 +76,7 @@ class SampleMuxerMetadata {
// error.
bool Write(mkvmuxer::Segment* segment) const;
mkvmuxer::uint64 track_num;
uint64 track_num;
cue_t cue;
};
@@ -97,12 +99,12 @@ class SampleMuxerMetadata {
// Add a metadata track to the segment having the indicated |kind|,
// returning the |track_num| that has been chosen for this track.
// 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
// |track_num|, adding each parsed cue to cues set. Returns false
// 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.
static void MakeFrame(const cue_t& cue, std::string* frame);
@@ -133,4 +135,6 @@ class SampleMuxerMetadata {
SampleMuxerMetadata& operator=(const SampleMuxerMetadata&);
};
} // namespace libwebm
#endif // SAMPLE_MUXER_METADATA_H_ // NOLINT

45
testing/muxer_tests.cc
View File

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

26
testing/parser_tests.cc
View File

@@ -19,19 +19,19 @@
#include "testing/test_util.h"
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;
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;
namespace libwebm {
namespace test {

105
vttdemux.cc
View File

@@ -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.
#include <cstdlib>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <map>
#include <memory>
@@ -25,6 +25,7 @@
using std::string;
namespace libwebm {
namespace vttdemux {
typedef long long mkvtime_t; // NOLINT
@@ -221,56 +222,6 @@ bool WriteCueTime(FILE* f, mkvtime_t time_ns);
bool WriteCuePayload(FILE* f, FrameParser* parser);
} // 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 {
FrameParser::FrameParser(const mkvparser::BlockGroup* block_group)
@@ -1000,3 +951,55 @@ bool vttdemux::WriteCuePayload(FILE* f, FrameParser* parser) {
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
#define WEBMIDS_HPP
namespace mkvmuxer {
namespace libwebm {
enum MkvId {
kMkvEBML = 0x1A45DFA3,
@@ -179,6 +179,6 @@ enum MkvId {
kMkvTagString = 0x4487
};
} // end namespace mkvmuxer
} // namespace libwebm
#endif // WEBMIDS_HPP