*/
#include "avformat.h"
+#include "random.h"
#include "riff.h"
#include "xiph.h"
#include "matroska.h"
mkv_seekhead *main_seekhead;
mkv_seekhead *cluster_seekhead;
mkv_cues *cues;
+
+ AVRandomState rand_state;
} MatroskaMuxContext;
static void put_ebml_id(ByteIOContext *pb, unsigned int id)
static int ebml_id_size(unsigned int id)
{
- if (id >= 0x3fffff)
- return 4;
- if (id >= 0x7fff)
- return 3;
- if (id >= 0xff)
- return 2;
- return 1;
+ return (av_log2(id+1)-1)/7+1;
}
// XXX: test this thoroughly and get rid of minbytes hack (currently needed to
static void put_ebml_float(ByteIOContext *pb, unsigned int elementid, double val)
{
- // XXX: single-precision floats?
put_ebml_id(pb, elementid);
put_ebml_size(pb, 8, 0);
put_be64(pb, av_dbl2int(val));
url_fseek(pb, pos, SEEK_SET);
}
+static void put_xiph_size(ByteIOContext *pb, int size)
+{
+ int i;
+ for (i = 0; i < size / 255; i++)
+ put_byte(pb, 255);
+ put_byte(pb, size % 255);
+}
+
// initializes a mkv_seekhead element to be ready to index level 1 matroska elements
// if numelements is greater than 0, it reserves enough space for that many elements
// at the current file position and writes the seekhead there, otherwise the seekhead
uint8_t *header_start[3];
int header_len[3];
int first_header_size;
- int j, k;
+ int j;
if (codec->codec_id == CODEC_ID_VORBIS)
first_header_size = 30;
codecprivate = start_ebml_master(pb, MATROSKA_ID_CODECPRIVATE);
put_byte(pb, 2); // number packets - 1
for (j = 0; j < 2; j++) {
- for (k = 0; k < header_len[j] / 255; k++)
- put_byte(pb, 255);
- put_byte(pb, header_len[j] % 255);
+ put_xiph_size(pb, header_len[j]);
}
for (j = 0; j < 3; j++)
put_buffer(pb, header_start[j], header_len[j]);
return 0;
}
+#define FLAC_STREAMINFO_SIZE 34
+
+static int put_flac_codecpriv(ByteIOContext *pb, AVCodecContext *codec)
+{
+ offset_t codecpriv = start_ebml_master(pb, MATROSKA_ID_CODECPRIVATE);
+
+ // if the extradata_size is greater than FLAC_STREAMINFO_SIZE,
+ // assume that it's in Matroska's format already
+ if (codec->extradata_size < FLAC_STREAMINFO_SIZE) {
+ av_log(codec, AV_LOG_ERROR, "Invalid FLAC extradata\n");
+ return -1;
+ } else if (codec->extradata_size == FLAC_STREAMINFO_SIZE) {
+ // only the streaminfo packet
+ put_byte(pb, 0);
+ put_xiph_size(pb, codec->extradata_size);
+ av_log(codec, AV_LOG_ERROR, "Only one packet\n");
+ }
+ put_buffer(pb, codec->extradata, codec->extradata_size);
+ end_ebml_master(pb, codecpriv);
+ return 0;
+}
+
+static void get_aac_sample_rates(AVCodecContext *codec, int *sample_rate, int *output_sample_rate)
+{
+ static const int aac_sample_rates[] = {
+ 96000, 88200, 64000, 48000, 44100, 32000,
+ 24000, 22050, 16000, 12000, 11025, 8000,
+ };
+ int sri;
+
+ if (codec->extradata_size < 2) {
+ av_log(codec, AV_LOG_WARNING, "no aac extradata, unable to determine sample rate\n");
+ return;
+ }
+
+ sri = ((codec->extradata[0] << 1) & 0xE) | (codec->extradata[1] >> 7);
+ if (sri > 12) {
+ av_log(codec, AV_LOG_WARNING, "aac samplerate index out of bounds\n");
+ return;
+ }
+ *sample_rate = aac_sample_rates[sri];
+
+ // if sbr, get output sample rate as well
+ if (codec->extradata_size == 5) {
+ sri = (codec->extradata[4] >> 3) & 0xF;
+ if (sri > 12) {
+ av_log(codec, AV_LOG_WARNING, "aac output samplerate index out of bounds\n");
+ return;
+ }
+ *output_sample_rate = aac_sample_rates[sri];
+ }
+}
+
static int mkv_write_tracks(AVFormatContext *s)
{
MatroskaMuxContext *mkv = s->priv_data;
AVCodecContext *codec = st->codec;
offset_t subinfo, track;
int native_id = 0;
+ int bit_depth = av_get_bits_per_sample(codec->codec_id);
+ int sample_rate = codec->sample_rate;
+ int output_sample_rate = 0;
+
+ if (codec->codec_id == CODEC_ID_AAC)
+ get_aac_sample_rates(codec, &sample_rate, &output_sample_rate);
track = start_ebml_master(pb, MATROSKA_ID_TRACKENTRY);
put_ebml_uint (pb, MATROSKA_ID_TRACKNUMBER , i + 1);
}
}
- // XXX: CodecPrivate for vorbis, theora, aac, native mpeg4, ...
if (native_id) {
if (codec->codec_id == CODEC_ID_VORBIS || codec->codec_id == CODEC_ID_THEORA) {
if (put_xiph_codecpriv(pb, codec) < 0)
return -1;
- } else {
+ } else if (codec->codec_id == CODEC_ID_FLAC) {
+ if (put_flac_codecpriv(pb, codec) < 0)
+ return -1;
+ } else if (codec->extradata_size) {
put_ebml_binary(pb, MATROSKA_ID_CODECPRIVATE, codec->extradata, codec->extradata_size);
}
}
codec->codec_tag = codec_get_tag(codec_bmp_tags, codec->codec_id);
put_ebml_string(pb, MATROSKA_ID_CODECID, MATROSKA_CODEC_ID_VIDEO_VFW_FOURCC);
- // XXX: codec private isn't a master; is there a better way to re-use put_bmp_header?
bmp_header = start_ebml_master(pb, MATROSKA_ID_CODECPRIVATE);
put_bmp_header(pb, codec, codec_bmp_tags, 0);
end_ebml_master(pb, bmp_header);
// XXX: interlace flag?
put_ebml_uint (pb, MATROSKA_ID_VIDEOPIXELWIDTH , codec->width);
put_ebml_uint (pb, MATROSKA_ID_VIDEOPIXELHEIGHT, codec->height);
- // XXX: display width/height
+ if (codec->sample_aspect_ratio.num) {
+ put_ebml_uint(pb, MATROSKA_ID_VIDEODISPLAYWIDTH , codec->sample_aspect_ratio.num);
+ put_ebml_uint(pb, MATROSKA_ID_VIDEODISPLAYHEIGHT, codec->sample_aspect_ratio.den);
+ }
end_ebml_master(pb, subinfo);
break;
}
subinfo = start_ebml_master(pb, MATROSKA_ID_TRACKAUDIO);
put_ebml_uint (pb, MATROSKA_ID_AUDIOCHANNELS , codec->channels);
- put_ebml_float (pb, MATROSKA_ID_AUDIOSAMPLINGFREQ, codec->sample_rate);
- // XXX: output sample freq (for sbr) and bitdepth (for pcm)
+ put_ebml_float (pb, MATROSKA_ID_AUDIOSAMPLINGFREQ, sample_rate);
+ if (output_sample_rate)
+ put_ebml_float(pb, MATROSKA_ID_AUDIOOUTSAMPLINGFREQ, output_sample_rate);
+ if (bit_depth)
+ put_ebml_uint(pb, MATROSKA_ID_AUDIOBITDEPTH, bit_depth);
end_ebml_master(pb, subinfo);
break;
+ case CODEC_TYPE_SUBTITLE:
+ put_ebml_uint(pb, MATROSKA_ID_TRACKTYPE, MATROSKA_TRACK_TYPE_SUBTITLE);
+ break;
default:
av_log(s, AV_LOG_ERROR, "Only audio and video are supported for Matroska.");
break;
MatroskaMuxContext *mkv = s->priv_data;
ByteIOContext *pb = &s->pb;
offset_t ebml_header, segment_info;
+ int i;
+
+ av_init_random(av_gettime(), &mkv->rand_state);
ebml_header = start_ebml_master(pb, EBML_ID_HEADER);
put_ebml_uint (pb, EBML_ID_EBMLVERSION , 1);
if (strlen(s->title))
put_ebml_string(pb, MATROSKA_ID_TITLE, s->title);
if (!(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
- put_ebml_string(pb, MATROSKA_ID_MUXINGAPP, LIBAVFORMAT_IDENT);
- // XXX: both are required; something better for writing app?
+ uint8_t segmentuid[16];
+ for (i = 0; i < 16; i++)
+ segmentuid[i] = av_random(&mkv->rand_state);
+
+ put_ebml_string(pb, MATROSKA_ID_MUXINGAPP , LIBAVFORMAT_IDENT);
put_ebml_string(pb, MATROSKA_ID_WRITINGAPP, LIBAVFORMAT_IDENT);
+ put_ebml_binary(pb, MATROSKA_ID_SEGMENTUID, segmentuid, 16);
}
- // XXX: segment UID
+
// reserve space for the duration
mkv->duration = 0;
mkv->duration_offset = url_ftell(pb);
return 0;
}
+static void mkv_write_block(AVFormatContext *s, unsigned int blockid, AVPacket *pkt, int flags)
+{
+ MatroskaMuxContext *mkv = s->priv_data;
+ ByteIOContext *pb = &s->pb;
+
+ put_ebml_id(pb, blockid);
+ put_ebml_size(pb, pkt->size + 4, 0);
+ put_byte(pb, 0x80 | (pkt->stream_index + 1)); // this assumes stream_index is less than 126
+ put_be16(pb, pkt->pts - mkv->cluster_pts);
+ put_byte(pb, flags);
+ put_buffer(pb, pkt->data, pkt->size);
+}
+
static int mkv_write_packet(AVFormatContext *s, AVPacket *pkt)
{
MatroskaMuxContext *mkv = s->priv_data;
ByteIOContext *pb = &s->pb;
+ AVCodecContext *codec = s->streams[pkt->stream_index]->codec;
+ int keyframe = !!(pkt->flags & PKT_FLAG_KEY);
// start a new cluster every 5 MB or 5 sec
if (url_ftell(pb) > mkv->cluster + 5*1024*1024 || pkt->pts > mkv->cluster_pts + 5000) {
mkv->cluster_pts = pkt->pts;
}
- put_ebml_id(pb, MATROSKA_ID_SIMPLEBLOCK);
- put_ebml_size(pb, pkt->size + 4, 0);
- put_byte(pb, 0x80 | (pkt->stream_index + 1)); // this assumes stream_index is less than 126
- put_be16(pb, pkt->pts - mkv->cluster_pts);
- put_byte(pb, !!(pkt->flags & PKT_FLAG_KEY));
- put_buffer(pb, pkt->data, pkt->size);
+ if (codec->codec_type != CODEC_TYPE_SUBTITLE) {
+ mkv_write_block(s, MATROSKA_ID_SIMPLEBLOCK, pkt, keyframe << 7);
+ } else {
+ offset_t blockgroup = start_ebml_master(pb, MATROSKA_ID_BLOCKGROUP);
+ mkv_write_block(s, MATROSKA_ID_BLOCK, pkt, 0);
+ put_ebml_uint(pb, MATROSKA_ID_DURATION, pkt->duration);
+ end_ebml_master(pb, blockgroup);
+ }
- if (s->streams[pkt->stream_index]->codec->codec_type == CODEC_TYPE_VIDEO && pkt->flags & PKT_FLAG_KEY) {
+ if (codec->codec_type == CODEC_TYPE_VIDEO && keyframe) {
if (mkv_add_cuepoint(mkv->cues, pkt, mkv->cluster_pos) < 0)
return -1;
}
projects / ffmpeg / blobdiff