#include "libavcodec/mpeg4audio.h"
/* Level 1 elements we create a SeekHead entry for:
- * Info, Tracks, Chapters, Attachments, Tags and Cues */
-#define MAX_SEEKHEAD_ENTRIES 6
+ * Info, Tracks, Chapters, Attachments, Tags (potentially twice) and Cues */
+#define MAX_SEEKHEAD_ENTRIES 7
#define IS_SEEKABLE(pb, mkv) (((pb)->seekable & AVIO_SEEKABLE_NORMAL) && \
!(mkv)->is_live)
mkv_cues cues;
int64_t cues_pos;
- AVPacket cur_audio_pkt;
+ AVPacket *cur_audio_pkt;
unsigned nb_attachments;
int have_video;
- uint32_t chapter_id_offset;
int wrote_chapters;
+ int wrote_tags;
int reserve_cues_space;
int cluster_size_limit;
int is_dash;
int dash_track_number;
int allow_raw_vfw;
+ int flipped_raw_rgb;
int default_mode;
uint32_t segment_uid[4];
{
MatroskaMuxContext *mkv = s->priv_data;
- av_packet_unref(&mkv->cur_audio_pkt);
+ av_packet_free(&mkv->cur_audio_pkt);
ffio_free_dyn_buf(&mkv->cluster_bc);
ffio_free_dyn_buf(&mkv->info.bc);
const uint8_t *header_start[3];
int header_len[3];
int first_header_size;
- int j;
+ int err, j;
if (par->codec_id == AV_CODEC_ID_VORBIS)
first_header_size = 30;
else
first_header_size = 42;
- if (avpriv_split_xiph_headers(par->extradata, par->extradata_size,
- first_header_size, header_start, header_len) < 0) {
+ err = avpriv_split_xiph_headers(par->extradata, par->extradata_size,
+ first_header_size, header_start, header_len);
+ if (err < 0) {
av_log(s, AV_LOG_ERROR, "Extradata corrupt.\n");
- return -1;
+ return err;
}
avio_w8(pb, 2); // number packets - 1
int native_id, int qt_id)
{
AVIOContext *dyn_cp;
+ MatroskaMuxContext *mkv = s->priv_data;
uint8_t *codecpriv;
int ret, codecpriv_size;
ret = AVERROR(EINVAL);
}
- ff_put_bmp_header(dyn_cp, par, 0, 0);
+ ff_put_bmp_header(dyn_cp, par, 0, 0, mkv->flipped_raw_rgb);
}
} else if (par->codec_type == AVMEDIA_TYPE_AUDIO) {
unsigned int tag;
* plus another byte to stay clear of the end. */
uint8_t colour[(2 + 1 + 8) * 18 + (2 + 1) + 1];
AVIOContext buf, *dyn_cp = &buf;
- int side_data_size = 0;
int colorinfo_size;
- const uint8_t *side_data;
+ const void *side_data;
ffio_init_context(dyn_cp, colour, sizeof(colour), 1, NULL, NULL, NULL, NULL);
}
side_data = av_stream_get_side_data(st, AV_PKT_DATA_CONTENT_LIGHT_LEVEL,
- &side_data_size);
- if (side_data_size) {
- const AVContentLightMetadata *metadata =
- (const AVContentLightMetadata*)side_data;
+ NULL);
+ if (side_data) {
+ const AVContentLightMetadata *metadata = side_data;
put_ebml_uint(dyn_cp, MATROSKA_ID_VIDEOCOLORMAXCLL, metadata->MaxCLL);
put_ebml_uint(dyn_cp, MATROSKA_ID_VIDEOCOLORMAXFALL, metadata->MaxFALL);
}
side_data = av_stream_get_side_data(st, AV_PKT_DATA_MASTERING_DISPLAY_METADATA,
- &side_data_size);
- if (side_data_size == sizeof(AVMasteringDisplayMetadata)) {
+ NULL);
+ if (side_data) {
ebml_master meta_element = start_ebml_master(
dyn_cp, MATROSKA_ID_VIDEOCOLORMASTERINGMETA, 10 * (2 + 1 + 8));
- const AVMasteringDisplayMetadata *metadata =
- (const AVMasteringDisplayMetadata*)side_data;
+ const AVMasteringDisplayMetadata *metadata = side_data;
if (metadata->has_primaries) {
put_ebml_float(dyn_cp, MATROSKA_ID_VIDEOCOLOR_RX,
av_q2d(metadata->display_primaries[0][0]));
const AVStream *st)
{
ebml_master projection;
- int side_data_size = 0;
uint8_t private[20];
const AVSphericalMapping *spherical =
(const AVSphericalMapping *)av_stream_get_side_data(st, AV_PKT_DATA_SPHERICAL,
- &side_data_size);
+ NULL);
- if (!side_data_size)
+ if (!spherical)
return;
if (spherical->projection != AV_SPHERICAL_EQUIRECTANGULAR &&
const AVDictionaryEntry *tag;
MatroskaVideoStereoModeType format = MATROSKA_VIDEO_STEREOMODE_TYPE_NB;
const AVStereo3D *stereo;
- int side_data_size = 0;
*h_width = 1;
*h_height = 1;
}
stereo = (const AVStereo3D*)av_stream_get_side_data(st, AV_PKT_DATA_STEREO3D,
- &side_data_size);
- if (side_data_size >= sizeof(AVStereo3D)) {
+ NULL);
+ if (stereo) {
switch (stereo->type) {
case AV_STEREO3D_2D:
format = MATROSKA_VIDEO_STEREOMODE_TYPE_MONO;
put_ebml_string(pb, MATROSKA_ID_TRACKNAME, tag->value);
tag = av_dict_get(st->metadata, "language", NULL, 0);
put_ebml_string(pb, MATROSKA_ID_TRACKLANGUAGE,
- tag && tag->value ? tag->value : "und");
+ tag && tag->value[0] ? tag->value : "und");
// The default value for TRACKFLAGDEFAULT is 1, so add element
// if we need to clear it.
put_ebml_string(pb, MATROSKA_ID_CODECID, codec_id);
} else {
+ if (st->disposition & AV_DISPOSITION_COMMENT)
+ put_ebml_uint(pb, MATROSKA_ID_TRACKFLAGCOMMENTARY, 1);
+ if (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED)
+ put_ebml_uint(pb, MATROSKA_ID_TRACKFLAGHEARINGIMPAIRED, 1);
+ if (st->disposition & AV_DISPOSITION_VISUAL_IMPAIRED)
+ put_ebml_uint(pb, MATROSKA_ID_TRACKFLAGVISUALIMPAIRED, 1);
+ if (st->disposition & (AV_DISPOSITION_ORIGINAL | AV_DISPOSITION_DUB) &&
+ (st->disposition & (AV_DISPOSITION_ORIGINAL | AV_DISPOSITION_DUB))
+ != (AV_DISPOSITION_ORIGINAL | AV_DISPOSITION_DUB))
+ put_ebml_uint(pb, MATROSKA_ID_TRACKFLAGORIGINAL,
+ !!(st->disposition & AV_DISPOSITION_ORIGINAL));
+
// look for a codec ID string specific to mkv to use,
// if none are found, use AVI codes
if (par->codec_id != AV_CODEC_ID_RAWVIDEO || par->codec_tag) {
av_log(s, AV_LOG_ERROR, "Subtitle codec %d is not supported.\n", par->codec_id);
return AVERROR(ENOSYS);
}
+ if (mkv->mode != MODE_WEBM && st->disposition & AV_DISPOSITION_DESCRIPTIONS)
+ put_ebml_uint(pb, MATROSKA_ID_TRACKFLAGTEXTDESCRIPTIONS, 1);
if (mkv->mode != MODE_WEBM || par->codec_id != AV_CODEC_ID_WEBVTT)
native_id = MATROSKA_TRACK_TYPE_SUBTITLE;
MATROSKA_ID_TRACKS);
}
-static int mkv_write_chapters(AVFormatContext *s)
-{
- MatroskaMuxContext *mkv = s->priv_data;
- AVIOContext *dyn_cp = NULL, *pb = s->pb;
- ebml_master editionentry;
- AVRational scale = {1, 1E9};
- int i, ret;
-
- if (!s->nb_chapters || mkv->wrote_chapters)
- return 0;
-
- for (i = 0; i < s->nb_chapters; i++)
- if (!s->chapters[i]->id) {
- mkv->chapter_id_offset = 1;
- break;
- }
-
- ret = start_ebml_master_crc32(&dyn_cp, mkv);
- if (ret < 0)
- return ret;
-
- editionentry = start_ebml_master(dyn_cp, MATROSKA_ID_EDITIONENTRY, 0);
- if (mkv->mode != MODE_WEBM)
- put_ebml_uint(dyn_cp, MATROSKA_ID_EDITIONFLAGDEFAULT, 1);
-
- for (i = 0; i < s->nb_chapters; i++) {
- ebml_master chapteratom, chapterdisplay;
- const AVChapter *c = s->chapters[i];
- int64_t chapterstart = av_rescale_q(c->start, c->time_base, scale);
- int64_t chapterend = av_rescale_q(c->end, c->time_base, scale);
- const AVDictionaryEntry *t;
- if (chapterstart < 0 || chapterstart > chapterend || chapterend < 0) {
- av_log(s, AV_LOG_ERROR,
- "Invalid chapter start (%"PRId64") or end (%"PRId64").\n",
- chapterstart, chapterend);
- ffio_free_dyn_buf(&dyn_cp);
- return AVERROR_INVALIDDATA;
- }
-
- chapteratom = start_ebml_master(dyn_cp, MATROSKA_ID_CHAPTERATOM, 0);
- put_ebml_uint(dyn_cp, MATROSKA_ID_CHAPTERUID,
- (uint32_t)c->id + (uint64_t)mkv->chapter_id_offset);
- put_ebml_uint(dyn_cp, MATROSKA_ID_CHAPTERTIMESTART, chapterstart);
- put_ebml_uint(dyn_cp, MATROSKA_ID_CHAPTERTIMEEND, chapterend);
- if ((t = av_dict_get(c->metadata, "title", NULL, 0))) {
- chapterdisplay = start_ebml_master(dyn_cp, MATROSKA_ID_CHAPTERDISPLAY, 0);
- put_ebml_string(dyn_cp, MATROSKA_ID_CHAPSTRING, t->value);
- put_ebml_string(dyn_cp, MATROSKA_ID_CHAPLANG , "und");
- end_ebml_master(dyn_cp, chapterdisplay);
- }
- end_ebml_master(dyn_cp, chapteratom);
- }
- end_ebml_master(dyn_cp, editionentry);
- mkv->wrote_chapters = 1;
-
- return end_ebml_master_crc32(pb, &dyn_cp, mkv,
- MATROSKA_ID_CHAPTERS, 0, 0, 1);
-}
-
static int mkv_write_simpletag(AVIOContext *pb, const AVDictionaryEntry *t)
{
uint8_t *key = av_strdup(t->key);
ebml_master tag, *tagp = IS_SEEKABLE(s->pb, mkv) ? &tag : NULL;
int i, ret;
+ mkv->wrote_tags = 1;
+
ff_metadata_conv_ctx(s, ff_mkv_metadata_conv, NULL);
if (mkv_check_tag(s->metadata, 0)) {
}
}
- if (mkv->mode != MODE_WEBM) {
- for (i = 0; i < s->nb_chapters; i++) {
- AVChapter *ch = s->chapters[i];
-
- if (!mkv_check_tag(ch->metadata, MATROSKA_ID_TAGTARGETS_CHAPTERUID))
- continue;
-
- ret = mkv_write_tag(mkv, ch->metadata, &mkv->tags.bc, NULL,
- MATROSKA_ID_TAGTARGETS_CHAPTERUID,
- (uint32_t)ch->id + (uint64_t)mkv->chapter_id_offset);
- if (ret < 0)
- return ret;
- }
- }
-
if (mkv->nb_attachments && mkv->mode != MODE_WEBM) {
for (i = 0; i < s->nb_streams; i++) {
const mkv_track *track = &mkv->tracks[i];
return 0;
}
+static int mkv_write_chapters(AVFormatContext *s)
+{
+ MatroskaMuxContext *mkv = s->priv_data;
+ AVIOContext *dyn_cp = NULL, *dyn_tags = NULL, **tags, *pb = s->pb;
+ ebml_master editionentry;
+ uint64_t chapter_id_offset = 0;
+ AVRational scale = {1, 1E9};
+ int i, ret;
+
+ if (!s->nb_chapters || mkv->wrote_chapters)
+ return 0;
+
+ for (i = 0; i < s->nb_chapters; i++)
+ if (!s->chapters[i]->id) {
+ chapter_id_offset = 1;
+ break;
+ }
+
+ ret = start_ebml_master_crc32(&dyn_cp, mkv);
+ if (ret < 0)
+ return ret;
+
+ editionentry = start_ebml_master(dyn_cp, MATROSKA_ID_EDITIONENTRY, 0);
+ if (mkv->mode != MODE_WEBM) {
+ put_ebml_uint(dyn_cp, MATROSKA_ID_EDITIONFLAGDEFAULT, 1);
+ /* If mkv_write_tags() has already been called, then any tags
+ * corresponding to chapters will be put into a new Tags element. */
+ tags = mkv->wrote_tags ? &dyn_tags : &mkv->tags.bc;
+ } else
+ tags = NULL;
+
+ for (i = 0; i < s->nb_chapters; i++) {
+ ebml_master chapteratom, chapterdisplay;
+ const AVChapter *c = s->chapters[i];
+ int64_t chapterstart = av_rescale_q(c->start, c->time_base, scale);
+ int64_t chapterend = av_rescale_q(c->end, c->time_base, scale);
+ const AVDictionaryEntry *t;
+ if (chapterstart < 0 || chapterstart > chapterend || chapterend < 0) {
+ av_log(s, AV_LOG_ERROR,
+ "Invalid chapter start (%"PRId64") or end (%"PRId64").\n",
+ chapterstart, chapterend);
+ ret = AVERROR_INVALIDDATA;
+ goto fail;
+ }
+
+ chapteratom = start_ebml_master(dyn_cp, MATROSKA_ID_CHAPTERATOM, 0);
+ put_ebml_uint(dyn_cp, MATROSKA_ID_CHAPTERUID,
+ (uint32_t)c->id + chapter_id_offset);
+ put_ebml_uint(dyn_cp, MATROSKA_ID_CHAPTERTIMESTART, chapterstart);
+ put_ebml_uint(dyn_cp, MATROSKA_ID_CHAPTERTIMEEND, chapterend);
+ if ((t = av_dict_get(c->metadata, "title", NULL, 0))) {
+ chapterdisplay = start_ebml_master(dyn_cp, MATROSKA_ID_CHAPTERDISPLAY, 0);
+ put_ebml_string(dyn_cp, MATROSKA_ID_CHAPSTRING, t->value);
+ put_ebml_string(dyn_cp, MATROSKA_ID_CHAPLANG , "und");
+ end_ebml_master(dyn_cp, chapterdisplay);
+ }
+ end_ebml_master(dyn_cp, chapteratom);
+
+ if (tags && mkv_check_tag(c->metadata, MATROSKA_ID_TAGTARGETS_CHAPTERUID)) {
+ ret = mkv_write_tag(mkv, c->metadata, tags, NULL,
+ MATROSKA_ID_TAGTARGETS_CHAPTERUID,
+ (uint32_t)c->id + chapter_id_offset);
+ if (ret < 0)
+ goto fail;
+ }
+ }
+ end_ebml_master(dyn_cp, editionentry);
+ mkv->wrote_chapters = 1;
+
+ ret = end_ebml_master_crc32(pb, &dyn_cp, mkv, MATROSKA_ID_CHAPTERS, 0, 0, 1);
+ if (ret < 0)
+ goto fail;
+ if (dyn_tags)
+ return end_ebml_master_crc32(pb, &dyn_tags, mkv,
+ MATROSKA_ID_TAGS, 0, 0, 1);
+ return 0;
+
+fail:
+ if (tags) {
+ /* tags == &mkv->tags.bc can only happen if mkv->tags.bc was
+ * initially NULL, so we never free older tags. */
+ ffio_free_dyn_buf(tags);
+ }
+ ffio_free_dyn_buf(&dyn_cp);
+ return ret;
+}
+
static const char *get_mimetype(const AVStream *st)
{
const AVDictionaryEntry *t;
return ret;
}
- /* Must come after mkv_write_chapters() because of chapter_id_offset */
+ /* Must come after mkv_write_chapters() to write chapter tags
+ * into the same Tags element as the other tags. */
ret = mkv_write_tags(s);
if (ret < 0)
return ret;
mkv->reserve_cues_space = -1;
}
- av_init_packet(&mkv->cur_audio_pkt);
- mkv->cur_audio_pkt.size = 0;
mkv->cluster_pos = -1;
// start a new cluster every 5 MB or 5 sec, or 32k / 1 sec for streaming or
AVCodecParameters *par = s->streams[pkt->stream_index]->codecpar;
mkv_track *track = &mkv->tracks[pkt->stream_index];
uint8_t *data = NULL, *side_data = NULL;
- int err = 0, offset = 0, size = pkt->size, side_data_size = 0;
+ buffer_size_t side_data_size;
+ int err = 0, offset = 0, size = pkt->size;
int64_t ts = track->write_dts ? pkt->dts : pkt->pts;
uint64_t additional_id;
int64_t discard_padding = 0;
MatroskaMuxContext *mkv = s->priv_data;
mkv_track *track = &mkv->tracks[pkt->stream_index];
ebml_master blockgroup;
- int id_size, settings_size, size;
- uint8_t *id, *settings;
+ buffer_size_t id_size, settings_size;
+ int size;
+ const char *id, *settings;
int64_t ts = track->write_dts ? pkt->dts : pkt->pts;
const int flags = 0;
- id_size = 0;
id = av_packet_get_side_data(pkt, AV_PKT_DATA_WEBVTT_IDENTIFIER,
&id_size);
+ id = id ? id : "";
- settings_size = 0;
settings = av_packet_get_side_data(pkt, AV_PKT_DATA_WEBVTT_SETTINGS,
&settings_size);
+ settings = settings ? settings : "";
size = id_size + 1 + settings_size + 1 + pkt->size;
mkv_track *track = &mkv->tracks[pkt->stream_index];
AVCodecParameters *par = s->streams[pkt->stream_index]->codecpar;
uint8_t *side_data;
- int side_data_size = 0, ret;
+ buffer_size_t side_data_size;
+ int ret;
side_data = av_packet_get_side_data(pkt, AV_PKT_DATA_NEW_EXTRADATA,
&side_data_size);
keyframe && (mkv->have_video ? codec_type == AVMEDIA_TYPE_VIDEO : 1) ? AVIO_DATA_MARKER_SYNC_POINT : AVIO_DATA_MARKER_BOUNDARY_POINT);
// check if we have an audio packet cached
- if (mkv->cur_audio_pkt.size > 0) {
- ret = mkv_write_packet_internal(s, &mkv->cur_audio_pkt);
- av_packet_unref(&mkv->cur_audio_pkt);
+ if (mkv->cur_audio_pkt->size > 0) {
+ ret = mkv_write_packet_internal(s, mkv->cur_audio_pkt);
+ av_packet_unref(mkv->cur_audio_pkt);
if (ret < 0) {
av_log(s, AV_LOG_ERROR,
"Could not write cached audio packet ret:%d\n", ret);
// keyframe's timecode is contained in the same cluster for WebM
if (codec_type == AVMEDIA_TYPE_AUDIO) {
if (pkt->size > 0)
- ret = av_packet_ref(&mkv->cur_audio_pkt, pkt);
+ ret = av_packet_ref(mkv->cur_audio_pkt, pkt);
} else
ret = mkv_write_packet_internal(s, pkt);
return ret;
int ret, ret2 = 0;
// check if we have an audio packet cached
- if (mkv->cur_audio_pkt.size > 0) {
- ret = mkv_write_packet_internal(s, &mkv->cur_audio_pkt);
+ if (mkv->cur_audio_pkt->size > 0) {
+ ret = mkv_write_packet_internal(s, mkv->cur_audio_pkt);
if (ret < 0) {
av_log(s, AV_LOG_ERROR,
"Could not write cached audio packet ret:%d\n", ret);
} else
mkv->mode = MODE_MATROSKAv2;
+ mkv->cur_audio_pkt = av_packet_alloc();
+ if (!mkv->cur_audio_pkt)
+ return AVERROR(ENOMEM);
mkv->tracks = av_mallocz_array(s->nb_streams, sizeof(*mkv->tracks));
if (!mkv->tracks)
return AVERROR(ENOMEM);
{ "dash_track_number", "Track number for the DASH stream", OFFSET(dash_track_number), AV_OPT_TYPE_INT, { .i64 = 1 }, 1, INT_MAX, FLAGS },
{ "live", "Write files assuming it is a live stream.", OFFSET(is_live), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, FLAGS },
{ "allow_raw_vfw", "allow RAW VFW mode", OFFSET(allow_raw_vfw), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, FLAGS },
+ { "flipped_raw_rgb", "Raw RGB bitmaps in VFW mode are stored bottom-up", OFFSET(flipped_raw_rgb), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, FLAGS },
{ "write_crc32", "write a CRC32 element inside every Level 1 element", OFFSET(write_crc), AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, FLAGS },
{ "default_mode", "Controls how a track's FlagDefault is inferred", OFFSET(default_mode), AV_OPT_TYPE_INT, { .i64 = DEFAULT_MODE_INFER }, DEFAULT_MODE_INFER, DEFAULT_MODE_PASSTHROUGH, FLAGS, "default_mode" },
{ "infer", "For each track type, mark the first track of disposition default as default; if none exists, mark the first track as default.", 0, AV_OPT_TYPE_CONST, { .i64 = DEFAULT_MODE_INFER }, 0, 0, FLAGS, "default_mode" },