#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];
{
av_assert0(bytes <= 8);
avio_w8(pb, 0x1ff >> bytes);
+ if (av_builtin_constant_p(bytes) && bytes == 1)
+ return;
ffio_fill(pb, 0xff, bytes - 1);
}
{
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);
put_ebml_uint(cuepoint, MATROSKA_ID_CUETRACK , tracks[idx].track_num);
put_ebml_uint(cuepoint, MATROSKA_ID_CUECLUSTERPOSITION , entry->cluster_pos);
put_ebml_uint(cuepoint, MATROSKA_ID_CUERELATIVEPOSITION, entry->relative_pos);
- if (entry->duration != -1)
+ if (entry->duration > 0)
put_ebml_uint(cuepoint, MATROSKA_ID_CUEDURATION , entry->duration);
end_ebml_master(cuepoint, track_positions);
} while (++entry < end && entry->pts == pts);
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 &&
static int mkv_write_stereo_mode(AVFormatContext *s, AVIOContext *pb,
AVStream *st, int mode, int *h_width, int *h_height)
{
- int i;
- int ret = 0;
const AVDictionaryEntry *tag;
MatroskaVideoStereoModeType format = MATROSKA_VIDEO_STEREOMODE_TYPE_NB;
+ const AVStereo3D *stereo;
*h_width = 1;
*h_height = 1;
(tag = av_dict_get( s->metadata, "stereo_mode", NULL, 0))) {
int stereo_mode = atoi(tag->value);
- for (i=0; i<MATROSKA_VIDEO_STEREOMODE_TYPE_NB; i++)
+ for (int i = 0; i < MATROSKA_VIDEO_STEREOMODE_TYPE_NB; i++)
if (!strcmp(tag->value, ff_matroska_video_stereo_mode[i])){
stereo_mode = i;
break;
}
}
- // iterate to find the stereo3d side data
- for (i = 0; i < st->nb_side_data; i++) {
- AVPacketSideData sd = st->side_data[i];
- if (sd.type == AV_PKT_DATA_STEREO3D) {
- AVStereo3D *stereo = (AVStereo3D *)sd.data;
-
- switch (stereo->type) {
- case AV_STEREO3D_2D:
- format = MATROSKA_VIDEO_STEREOMODE_TYPE_MONO;
- break;
- case AV_STEREO3D_SIDEBYSIDE:
- format = (stereo->flags & AV_STEREO3D_FLAG_INVERT)
- ? MATROSKA_VIDEO_STEREOMODE_TYPE_RIGHT_LEFT
- : MATROSKA_VIDEO_STEREOMODE_TYPE_LEFT_RIGHT;
- *h_width = 2;
- break;
- case AV_STEREO3D_TOPBOTTOM:
- format = MATROSKA_VIDEO_STEREOMODE_TYPE_TOP_BOTTOM;
- if (stereo->flags & AV_STEREO3D_FLAG_INVERT)
- format--;
- *h_height = 2;
- break;
- case AV_STEREO3D_CHECKERBOARD:
- format = MATROSKA_VIDEO_STEREOMODE_TYPE_CHECKERBOARD_LR;
- if (stereo->flags & AV_STEREO3D_FLAG_INVERT)
- format--;
- break;
- case AV_STEREO3D_LINES:
- format = MATROSKA_VIDEO_STEREOMODE_TYPE_ROW_INTERLEAVED_LR;
- if (stereo->flags & AV_STEREO3D_FLAG_INVERT)
- format--;
- *h_height = 2;
- break;
- case AV_STEREO3D_COLUMNS:
- format = MATROSKA_VIDEO_STEREOMODE_TYPE_COL_INTERLEAVED_LR;
- if (stereo->flags & AV_STEREO3D_FLAG_INVERT)
- format--;
- *h_width = 2;
- break;
- case AV_STEREO3D_FRAMESEQUENCE:
- format = MATROSKA_VIDEO_STEREOMODE_TYPE_BOTH_EYES_BLOCK_LR;
- if (stereo->flags & AV_STEREO3D_FLAG_INVERT)
- format++;
- break;
- }
+ stereo = (const AVStereo3D*)av_stream_get_side_data(st, AV_PKT_DATA_STEREO3D,
+ NULL);
+ if (stereo) {
+ switch (stereo->type) {
+ case AV_STEREO3D_2D:
+ format = MATROSKA_VIDEO_STEREOMODE_TYPE_MONO;
+ break;
+ case AV_STEREO3D_SIDEBYSIDE:
+ format = (stereo->flags & AV_STEREO3D_FLAG_INVERT)
+ ? MATROSKA_VIDEO_STEREOMODE_TYPE_RIGHT_LEFT
+ : MATROSKA_VIDEO_STEREOMODE_TYPE_LEFT_RIGHT;
+ *h_width = 2;
+ break;
+ case AV_STEREO3D_TOPBOTTOM:
+ format = MATROSKA_VIDEO_STEREOMODE_TYPE_TOP_BOTTOM;
+ if (stereo->flags & AV_STEREO3D_FLAG_INVERT)
+ format--;
+ *h_height = 2;
+ break;
+ case AV_STEREO3D_CHECKERBOARD:
+ format = MATROSKA_VIDEO_STEREOMODE_TYPE_CHECKERBOARD_LR;
+ if (stereo->flags & AV_STEREO3D_FLAG_INVERT)
+ format--;
+ break;
+ case AV_STEREO3D_LINES:
+ format = MATROSKA_VIDEO_STEREOMODE_TYPE_ROW_INTERLEAVED_LR;
+ if (stereo->flags & AV_STEREO3D_FLAG_INVERT)
+ format--;
+ *h_height = 2;
+ break;
+ case AV_STEREO3D_COLUMNS:
+ format = MATROSKA_VIDEO_STEREOMODE_TYPE_COL_INTERLEAVED_LR;
+ if (stereo->flags & AV_STEREO3D_FLAG_INVERT)
+ format--;
+ *h_width = 2;
+ break;
+ case AV_STEREO3D_FRAMESEQUENCE:
+ format = MATROSKA_VIDEO_STEREOMODE_TYPE_BOTH_EYES_BLOCK_LR;
+ if (stereo->flags & AV_STEREO3D_FLAG_INVERT)
+ format++;
break;
}
}
if (format == MATROSKA_VIDEO_STEREOMODE_TYPE_NB)
- return ret;
+ return 0;
// if webm, do not write unsupported modes
if ((mode == MODE_WEBM &&
|| format >= MATROSKA_VIDEO_STEREOMODE_TYPE_NB) {
av_log(s, AV_LOG_ERROR,
"The specified stereo mode is not valid.\n");
- format = MATROSKA_VIDEO_STEREOMODE_TYPE_NB;
return AVERROR(EINVAL);
}
// write StereoMode if format is valid
put_ebml_uint(pb, MATROSKA_ID_VIDEOSTEREOMODE, format);
- return ret;
+ return 0;
}
static int mkv_write_track(AVFormatContext *s, MatroskaMuxContext *mkv,
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);
return 0;
}
-static int mkv_write_tag_targets(AVFormatContext *s, uint32_t elementid,
- uint64_t uid, ebml_master *tag)
+static int mkv_write_tag_targets(MatroskaMuxContext *mkv, AVIOContext **pb,
+ ebml_master *tag, uint32_t elementid, uint64_t uid)
{
- AVIOContext *pb;
- MatroskaMuxContext *mkv = s->priv_data;
ebml_master targets;
int ret;
- if (!mkv->tags.bc) {
- ret = start_ebml_master_crc32(&mkv->tags.bc, mkv);
+ if (!*pb) {
+ ret = start_ebml_master_crc32(pb, mkv);
if (ret < 0)
return ret;
}
- pb = mkv->tags.bc;
- *tag = start_ebml_master(pb, MATROSKA_ID_TAG, 0);
- targets = start_ebml_master(pb, MATROSKA_ID_TAGTARGETS, 4 + 1 + 8);
+ *tag = start_ebml_master(*pb, MATROSKA_ID_TAG, 0);
+ targets = start_ebml_master(*pb, MATROSKA_ID_TAGTARGETS, 4 + 1 + 8);
if (elementid)
- put_ebml_uid(pb, elementid, uid);
- end_ebml_master(pb, targets);
+ put_ebml_uid(*pb, elementid, uid);
+ end_ebml_master(*pb, targets);
return 0;
}
av_strcasecmp(name, "mimetype")));
}
-static int mkv_write_tag(AVFormatContext *s, const AVDictionary *m,
- uint32_t elementid, uint64_t uid, ebml_master *tag)
+static int mkv_write_tag(MatroskaMuxContext *mkv, const AVDictionary *m,
+ AVIOContext **pb, ebml_master *tag,
+ uint32_t elementid, uint64_t uid)
{
- MatroskaMuxContext *mkv = s->priv_data;
const AVDictionaryEntry *t = NULL;
ebml_master tag2;
int ret;
- ret = mkv_write_tag_targets(s, elementid, uid, tag ? tag : &tag2);
+ ret = mkv_write_tag_targets(mkv, pb, tag ? tag : &tag2, elementid, uid);
if (ret < 0)
return ret;
while ((t = av_dict_get(m, "", t, AV_DICT_IGNORE_SUFFIX))) {
if (mkv_check_tag_name(t->key, elementid)) {
- ret = mkv_write_simpletag(mkv->tags.bc, t);
+ ret = mkv_write_simpletag(*pb, t);
if (ret < 0)
return ret;
}
}
if (!tag)
- end_ebml_master(mkv->tags.bc, tag2);
+ end_ebml_master(*pb, tag2);
return 0;
}
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)) {
- ret = mkv_write_tag(s, s->metadata, 0, 0, NULL);
+ ret = mkv_write_tag(mkv, s->metadata, &mkv->tags.bc, NULL, 0, 0);
if (ret < 0)
return ret;
}
if (!tagp && !mkv_check_tag(st->metadata, MATROSKA_ID_TAGTARGETS_TRACKUID))
continue;
- ret = mkv_write_tag(s, st->metadata, MATROSKA_ID_TAGTARGETS_TRACKUID,
- track->uid, tagp);
+ ret = mkv_write_tag(mkv, st->metadata, &mkv->tags.bc, tagp,
+ MATROSKA_ID_TAGTARGETS_TRACKUID, track->uid);
if (ret < 0)
return ret;
}
}
- 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(s, ch->metadata, MATROSKA_ID_TAGTARGETS_CHAPTERUID,
- (uint32_t)ch->id + (uint64_t)mkv->chapter_id_offset,
- NULL);
- 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];
if (!mkv_check_tag(st->metadata, MATROSKA_ID_TAGTARGETS_ATTACHUID))
continue;
- ret = mkv_write_tag(s, st->metadata, MATROSKA_ID_TAGTARGETS_ATTACHUID,
- track->uid, NULL);
+ ret = mkv_write_tag(mkv, st->metadata, &mkv->tags.bc, NULL,
+ MATROSKA_ID_TAGTARGETS_ATTACHUID, track->uid);
if (ret < 0)
return ret;
}
return 0;
}
+static int mkv_new_chapter_ids_needed(const AVFormatContext *s)
+{
+ for (unsigned i = 0; i < s->nb_chapters; i++) {
+ if (!s->chapters[i]->id)
+ return 1;
+ for (unsigned j = 0; j < i; j++)
+ if (s->chapters[j]->id == s->chapters[i]->id)
+ return 1;
+ }
+ 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;
+ AVRational scale = {1, 1E9};
+ int ret, create_new_ids;
+
+ if (!s->nb_chapters || mkv->wrote_chapters)
+ return 0;
+
+ 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;
+
+ create_new_ids = mkv_new_chapter_ids_needed(s);
+
+ for (unsigned 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;
+ uint64_t uid = create_new_ids ? i + 1ULL : c->id;
+ 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, uid);
+ 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, uid);
+ 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;
put_ebml_string(dyn_cp, MATROSKA_ID_FILEDESC, t->value);
if (!(t = av_dict_get(st->metadata, "filename", NULL, 0))) {
av_log(s, AV_LOG_ERROR, "Attachment stream %d has no filename tag.\n", i);
+ ffio_free_dyn_buf(&dyn_cp);
return AVERROR(EINVAL);
}
put_ebml_string(dyn_cp, MATROSKA_ID_FILENAME, t->value);
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;
+ 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;
+ size_t id_size, settings_size;
+ int size, id_size_int, settings_size_int;
+ 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 : "";
+
+ if (id_size > INT_MAX - 2 || settings_size > INT_MAX - id_size - 2 ||
+ pkt->size > INT_MAX - settings_size - id_size - 2)
+ return AVERROR(EINVAL);
size = id_size + 1 + settings_size + 1 + pkt->size;
put_ebml_num(pb, track->track_num, track->track_num_size);
avio_wb16(pb, ts - mkv->cluster_pts);
avio_w8(pb, flags);
- avio_printf(pb, "%.*s\n%.*s\n%.*s", id_size, id, settings_size, settings, pkt->size, pkt->data);
+
+ id_size_int = id_size;
+ settings_size_int = settings_size;
+ avio_printf(pb, "%.*s\n%.*s\n%.*s", id_size_int, id, settings_size_int, settings, pkt->size, pkt->data);
put_ebml_uint(pb, MATROSKA_ID_BLOCKDURATION, pkt->duration);
end_ebml_master(pb, blockgroup);
- return pkt->duration;
+ return 0;
}
static int mkv_end_cluster(AVFormatContext *s)
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;
+ size_t side_data_size;
+ int ret;
side_data = av_packet_get_side_data(pkt, AV_PKT_DATA_NEW_EXTRADATA,
&side_data_size);
AVCodecParameters *par = s->streams[pkt->stream_index]->codecpar;
mkv_track *track = &mkv->tracks[pkt->stream_index];
int keyframe = !!(pkt->flags & AV_PKT_FLAG_KEY);
- int duration = pkt->duration;
+ int64_t duration = pkt->duration;
int ret;
int64_t ts = track->write_dts ? pkt->dts : pkt->pts;
int64_t relative_packet_pos;
relative_packet_pos = avio_tell(pb);
- if (par->codec_type != AVMEDIA_TYPE_SUBTITLE) {
+ if (par->codec_type != AVMEDIA_TYPE_SUBTITLE ||
+ (par->codec_id != AV_CODEC_ID_WEBVTT && duration <= 0)) {
ret = mkv_write_block(s, pb, MATROSKA_ID_SIMPLEBLOCK, pkt, keyframe);
if (ret < 0)
return ret;
if (keyframe && IS_SEEKABLE(s->pb, mkv) &&
- (par->codec_type == AVMEDIA_TYPE_VIDEO || !mkv->have_video && !track->has_cue)) {
+ (par->codec_type == AVMEDIA_TYPE_VIDEO ||
+ par->codec_type == AVMEDIA_TYPE_SUBTITLE ||
+ !mkv->have_video && !track->has_cue)) {
ret = mkv_add_cuepoint(mkv, pkt->stream_index, ts,
- mkv->cluster_pos, relative_packet_pos, -1);
+ mkv->cluster_pos, relative_packet_pos, 0);
if (ret < 0)
return ret;
track->has_cue = 1;
}
} else {
if (par->codec_id == AV_CODEC_ID_WEBVTT) {
- duration = mkv_write_vtt_blocks(s, pb, pkt);
+ ret = mkv_write_vtt_blocks(s, pb, pkt);
+ if (ret < 0)
+ return ret;
} else {
ebml_master blockgroup = start_ebml_master(pb, MATROSKA_ID_BLOCKGROUP,
mkv_blockgroup_size(pkt->size,
track->track_num_size));
-#if FF_API_CONVERGENCE_DURATION
-FF_DISABLE_DEPRECATION_WARNINGS
- /* For backward compatibility, prefer convergence_duration. */
- if (pkt->convergence_duration > 0) {
- duration = pkt->convergence_duration;
- }
-FF_ENABLE_DEPRECATION_WARNINGS
-#endif
/* All subtitle blocks are considered to be keyframes. */
mkv_write_block(s, pb, MATROSKA_ID_BLOCK, pkt, 1);
put_ebml_uint(pb, MATROSKA_ID_BLOCKDURATION, duration);
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" },
projects / ffmpeg / blobdiff