a3dd40877d
Squashed commit of the following:
9f73b86 Updated code to Google C++ style guide.
8580901 Added support for linux.
fd0b59c Fixed segment size issue.
d51d5ef Added more Track and Video options.
0fc73fd Fixed issue where cue point was being written out on wrong
track.
fcfdd07 Updated sample_muxer to read in a webm and output a webm file.
Added some options to sample_muxer. Fixed writing out unknown
size.
285c558 Added support for muxer guideline "Audio that matches video key
frame should be in the same cluster." Added support for
block_number in cue points. Added support for setting max
cluster size.
f956dec Add support for setting the max duration for all clusters.
92ca53e Add support for Cues element.
d6b4cba Added typedefs for unsigned long long, long long, and unsigned
char. Reformated some code.
1b1f8b2 Added support for SeekHead element. Added WriteVoidElement
function.
8faa187 Add support for CodecPrivate. Add support for updating
SegmentInfo duration. Add support for updating Segment size.
Added new sample that swicthes the tracks.
1dd3555 Refactored some code. Check to see if track is a video track if
starting a new cluster on a key-frame.
1bc8374 Refacotrs code so Cluster is in charge of wirting out its own
data.
836cd74 Added basic cluster and simple_block support for writing frames.
cc48cc2 Add simple support for Audio tracks.
4efd614 Added support for using the encoded ID value for the elements.
fb8b5a6 Initial commit of libwebm muxer.
Removed switch_sample project. Fixed initialization order warnings on
Linux. Reformatted code to follow Google C++ style guide. Fixed Makefile.
Removed tester.cpp.
Change-Id: I4857042f804edb834be52787a7d5ccdd578b7275
376 lines
7.7 KiB
C++
376 lines
7.7 KiB
C++
// Copyright (c) 2011 The WebM project authors. All Rights Reserved.
|
|
//
|
|
// Use of this source code is governed by a BSD-style license
|
|
// that can be found in the LICENSE file in the root of the source
|
|
// tree. An additional intellectual property rights grant can be found
|
|
// in the file PATENTS. All contributing project authors may
|
|
// be found in the AUTHORS file in the root of the source tree.
|
|
|
|
#include "mkvmuxerutil.hpp"
|
|
|
|
#include <math.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <time.h>
|
|
|
|
#include <cassert>
|
|
#include <new>
|
|
|
|
#include "mkvwriter.hpp"
|
|
#include "webmids.hpp"
|
|
|
|
namespace mkvmuxer {
|
|
|
|
int32 GetCodedUIntSize(uint64 value) {
|
|
|
|
if (value < 0x000000000000007FULL)
|
|
return 1;
|
|
else if (value < 0x0000000000003FFFULL)
|
|
return 2;
|
|
else if (value < 0x00000000001FFFFFULL)
|
|
return 3;
|
|
else if (value < 0x000000000FFFFFFFULL)
|
|
return 4;
|
|
else if (value < 0x00000007FFFFFFFFULL)
|
|
return 5;
|
|
else if (value < 0x000003FFFFFFFFFFULL)
|
|
return 6;
|
|
else if (value < 0x0001FFFFFFFFFFFFULL)
|
|
return 7;
|
|
return 8;
|
|
}
|
|
|
|
int32 GetUIntSize(uint64 value) {
|
|
|
|
if (value < 0x0000000000000100ULL)
|
|
return 1;
|
|
else if (value < 0x0000000000010000ULL)
|
|
return 2;
|
|
else if (value < 0x0000000001000000ULL)
|
|
return 3;
|
|
else if (value < 0x0000000100000000ULL)
|
|
return 4;
|
|
else if (value < 0x0000010000000000ULL)
|
|
return 5;
|
|
else if (value < 0x0001000000000000ULL)
|
|
return 6;
|
|
else if (value < 0x0100000000000000ULL)
|
|
return 7;
|
|
return 8;
|
|
}
|
|
|
|
uint64 EbmlElementSize(uint64 type, uint64 value, bool master) {
|
|
// Size of EBML ID
|
|
int32 ebml_size = GetUIntSize(type);
|
|
|
|
// Datasize
|
|
ebml_size += GetUIntSize(value);
|
|
|
|
// Size of Datasize
|
|
if (!master)
|
|
ebml_size++;
|
|
|
|
return ebml_size;
|
|
}
|
|
|
|
uint64 EbmlElementSize(uint64 type, float value, bool master) {
|
|
// Size of EBML ID
|
|
uint64 ebml_size = GetUIntSize(type);
|
|
|
|
// Datasize
|
|
ebml_size += sizeof(value);
|
|
|
|
// Size of Datasize
|
|
if (!master)
|
|
ebml_size++;
|
|
|
|
return ebml_size;
|
|
}
|
|
|
|
uint64 EbmlElementSize(uint64 type, const char* value, bool master) {
|
|
assert(value != NULL);
|
|
|
|
// Size of EBML ID
|
|
uint64 ebml_size = GetUIntSize(type);
|
|
|
|
// Datasize
|
|
ebml_size += strlen(value);
|
|
|
|
// Size of Datasize
|
|
if (!master)
|
|
ebml_size++;
|
|
|
|
return ebml_size;
|
|
}
|
|
|
|
uint64 EbmlElementSize(uint64 type,
|
|
const uint8* value,
|
|
uint64 size,
|
|
bool master) {
|
|
assert(value != NULL);
|
|
|
|
// Size of EBML ID
|
|
uint64 ebml_size = GetUIntSize(type);
|
|
|
|
// Datasize
|
|
ebml_size += size;
|
|
|
|
// Size of Datasize
|
|
if (!master)
|
|
ebml_size += GetCodedUIntSize(size);
|
|
|
|
return ebml_size;
|
|
}
|
|
|
|
int32 SerializeInt(
|
|
IMkvWriter* writer,
|
|
int64 value,
|
|
int32 size) {
|
|
assert(writer);
|
|
assert(size >= 0);
|
|
assert(size <= 8);
|
|
|
|
for (int32 i = 1; i <= size; ++i) {
|
|
const int32 byte_count = size - i;
|
|
const int32 bit_count = byte_count * 8;
|
|
|
|
const int64 bb = value >> bit_count;
|
|
const uint8 b = static_cast<uint8>(bb);
|
|
|
|
const int32 status = writer->Write(&b, 1);
|
|
|
|
if (status < 0)
|
|
return status;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int32 SerializeFloat(IMkvWriter* writer, float f) {
|
|
assert(writer);
|
|
const uint32& val = reinterpret_cast<const uint32&>(f);
|
|
|
|
for (int32 i = 1; i <= 4; ++i) {
|
|
const int32 byte_count = 4 - i;
|
|
const int32 bit_count = byte_count * 8;
|
|
|
|
const uint32 bb = val >> bit_count;
|
|
const uint8 b = static_cast<uint8>(bb);
|
|
|
|
const int32 status = writer->Write(&b, 1);
|
|
|
|
if (status < 0)
|
|
return status;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int32 WriteUInt(IMkvWriter* writer, uint64 value) {
|
|
assert(writer);
|
|
int32 size = GetCodedUIntSize(value);
|
|
|
|
return WriteUIntSize(writer, value, size);
|
|
}
|
|
|
|
int32 WriteUIntSize(IMkvWriter* writer, uint64 value, int32 size) {
|
|
assert(writer);
|
|
assert(size >= 0);
|
|
|
|
if (size > 0) {
|
|
assert(size <= 8);
|
|
|
|
const uint64 bit = 1LL << (size * 7);
|
|
assert(value <= (bit - 2));
|
|
|
|
value |= bit;
|
|
} else {
|
|
size = 1;
|
|
int64 bit;
|
|
|
|
for (;;) {
|
|
bit = 1LL << (size * 7);
|
|
const uint64 max = bit - 2;
|
|
|
|
if (value <= max)
|
|
break;
|
|
|
|
++size;
|
|
}
|
|
|
|
assert(size <= 8);
|
|
value |= bit;
|
|
}
|
|
|
|
return SerializeInt(writer, value, size);
|
|
}
|
|
|
|
int32 WriteID(IMkvWriter* writer, uint64 type) {
|
|
assert(writer);
|
|
const int32 size = GetUIntSize(type);
|
|
|
|
return SerializeInt(writer, type, size);
|
|
}
|
|
|
|
bool WriteEbmlMasterElement(IMkvWriter* writer, uint64 type, uint64 size) {
|
|
assert(writer);
|
|
|
|
if (WriteID(writer, type))
|
|
return false;
|
|
|
|
if (WriteUInt(writer, size))
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool WriteEbmlElement(IMkvWriter* writer, uint64 type, uint64 value) {
|
|
assert(writer);
|
|
|
|
if (WriteID(writer, type))
|
|
return false;
|
|
|
|
const uint64 size = GetUIntSize(value);
|
|
if (WriteUInt(writer, size))
|
|
return false;
|
|
|
|
if (SerializeInt(writer, value, static_cast<int32>(size)))
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool WriteEbmlElement(IMkvWriter* writer, uint64 type, float value) {
|
|
assert(writer);
|
|
|
|
if (WriteID(writer, type))
|
|
return false;
|
|
|
|
if (WriteUInt(writer, 4))
|
|
return false;
|
|
|
|
if (SerializeFloat(writer, value))
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool WriteEbmlElement(IMkvWriter* writer, uint64 type, const char* value) {
|
|
assert(writer);
|
|
assert(value != NULL);
|
|
|
|
if (WriteID(writer, type))
|
|
return false;
|
|
|
|
const int32 length = strlen(value);
|
|
if (WriteUInt(writer, length))
|
|
return false;
|
|
|
|
if (writer->Write(value, length))
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool WriteEbmlElement(IMkvWriter* writer,
|
|
uint64 type,
|
|
const uint8* value,
|
|
uint64 size) {
|
|
assert(writer);
|
|
assert(value != NULL);
|
|
assert(size > 0);
|
|
|
|
if (WriteID(writer, type))
|
|
return false;
|
|
|
|
if (WriteUInt(writer, size))
|
|
return false;
|
|
|
|
if (writer->Write(value, static_cast<uint32>(size)))
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
uint64 WriteSimpleBlock(IMkvWriter* writer,
|
|
const uint8* data,
|
|
uint64 length,
|
|
char track_number,
|
|
short timecode,
|
|
bool is_key) {
|
|
assert(writer);
|
|
assert(data != NULL);
|
|
assert(length > 0);
|
|
assert(track_number > 0);
|
|
assert(timecode >= 0);
|
|
|
|
if (WriteID(writer, kMkvSimpleBlock))
|
|
return 0;
|
|
|
|
const int32 size = static_cast<int32>(length) + 4;
|
|
if (WriteUInt(writer, size))
|
|
return 0;
|
|
|
|
if (WriteUInt(writer, static_cast<uint64>(track_number)))
|
|
return 0;
|
|
|
|
if (SerializeInt(writer, static_cast<uint64>(timecode), 2))
|
|
return 0;
|
|
|
|
uint64 flags = 0;
|
|
if(is_key)
|
|
flags |= 0x80;
|
|
|
|
if (SerializeInt(writer, flags, 1))
|
|
return 0;
|
|
|
|
if (writer->Write(data, static_cast<uint32>(length)))
|
|
return 0;
|
|
|
|
const uint64 element_size =
|
|
GetUIntSize(kMkvSimpleBlock) + GetCodedUIntSize(size) + 4 + length;
|
|
|
|
return element_size;
|
|
}
|
|
|
|
uint64 WriteVoidElement(IMkvWriter* writer, uint64 size) {
|
|
// Subtract one for the void ID and the coded size.
|
|
uint64 void_entry_size = size - 1 - GetCodedUIntSize(size-1);
|
|
uint64 void_size = EbmlElementSize(kMkvVoid, void_entry_size, true) +
|
|
void_entry_size;
|
|
assert(void_size == size);
|
|
|
|
const int64 payload_position = writer->Position();
|
|
if (payload_position < 0)
|
|
return 0;
|
|
|
|
if (WriteID(writer, kMkvVoid))
|
|
return 0;
|
|
|
|
if (WriteUInt(writer, void_entry_size))
|
|
return 0;
|
|
|
|
const uint8 value = 0;
|
|
for (int32 i = 0; i < static_cast<int32>(void_entry_size); ++i) {
|
|
if (writer->Write(&value, 1))
|
|
return 0;
|
|
}
|
|
|
|
const int64 stop_position = writer->Position();
|
|
if (stop_position < 0)
|
|
return 0;
|
|
assert(stop_position - payload_position == static_cast<int64>(void_size));
|
|
|
|
return void_size;
|
|
}
|
|
|
|
void GetVersion(int32& major, int32& minor, int32& build, int32& revision) {
|
|
major = 0;
|
|
minor = 0;
|
|
build = 0;
|
|
revision = 1;
|
|
}
|
|
|
|
} // namespace mkvmuxer
|