Go to the documentation of this file.
62 {
"movflags",
"MOV muxer flags", offsetof(
MOVMuxContext,
flags),
AV_OPT_TYPE_FLAGS, {.i64 = 0}, INT_MIN, INT_MAX,
AV_OPT_FLAG_ENCODING_PARAM,
"movflags" },
64 {
"moov_size",
"maximum moov size so it can be placed at the begin", offsetof(
MOVMuxContext, reserved_moov_size),
AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX,
AV_OPT_FLAG_ENCODING_PARAM, 0 },
78 {
"delay_moov",
"Delay writing the initial moov until the first fragment is cut, or until the first fragment flush", 0,
AV_OPT_TYPE_CONST, {.i64 =
FF_MOV_FLAG_DELAY_MOOV}, INT_MIN, INT_MAX,
AV_OPT_FLAG_ENCODING_PARAM,
"movflags" },
81 {
"write_colr",
"Write colr atom (Experimental, may be renamed or changed, do not use from scripts)", 0,
AV_OPT_TYPE_CONST, {.i64 =
FF_MOV_FLAG_WRITE_COLR}, INT_MIN, INT_MAX,
AV_OPT_FLAG_ENCODING_PARAM,
"movflags" },
100 {
"frag_interleave",
"Interleave samples within fragments (max number of consecutive samples, lower is tighter interleaving, but with more overhead)", offsetof(
MOVMuxContext, frag_interleave),
AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX,
AV_OPT_FLAG_ENCODING_PARAM },
106 {
"write_prft",
"Write producer reference time box with specified time source", offsetof(
MOVMuxContext, write_prft),
AV_OPT_TYPE_INT, {.i64 =
MOV_PRFT_NONE}, 0,
MOV_PRFT_NB-1,
AV_OPT_FLAG_ENCODING_PARAM,
"prft"},
113 #define MOV_CLASS(flavor)\
114 static const AVClass flavor ## _muxer_class = {\
115 .class_name = #flavor " muxer",\
116 .item_name = av_default_item_name,\
118 .version = LIBAVUTIL_VERSION_INT,\
181 for (
i = 0;
i < track->
entry;
i++) {
196 int i, j, entries = 0, tst = -1, oldtst = -1;
203 for (
i = 0;
i < track->
entry;
i++) {
205 if (oldtst != -1 && tst != oldtst)
210 if (equalChunks && track->
entry) {
212 sSize =
FFMAX(1, sSize);
218 for (
i = 0;
i < track->
entry;
i++) {
231 int index = 0, oldval = -1,
i;
232 int64_t entryPos, curpos;
240 for (
i = 0;
i < track->
entry;
i++) {
260 int64_t curpos, entryPos;
268 for (
i = 0;
i < track->
entry;
i++) {
285 uint8_t leading, dependent, reference, redundancy;
290 for (
i = 0;
i < track->
entry;
i++) {
299 avio_w8(pb, (leading << 6) | (dependent << 4) |
300 (reference << 2) | redundancy);
324 int fscod, bsid, bsmod, acmod, lfeon, frmsizecod;
328 "Cannot write moov atom before AC3 packets."
329 " Set the delay_moov flag to fix this.\n");
345 if ((acmod & 1) && acmod != 1)
399 #if CONFIG_AC3_PARSER
423 if (!
info->ec3_done) {
469 while (cumul_size !=
pkt->
size) {
479 info->substream[parent].num_dep_sub++;
495 info->substream[parent].chan_loc |= (
get_bits(&gbc, 16) >> 5) & 0x1f;
513 if (!
info->num_blocks) {
524 if (
info->num_blocks != 6)
528 info->num_blocks = 0;
548 "Cannot write moov atom before EAC3 packets parsed.\n");
553 size = 2 + ((34 * (
info->num_ind_sub + 1) + 7) >> 3);
562 for (
i = 0;
i <=
info->num_ind_sub;
i++) {
572 if (!
info->substream[
i].num_dep_sub) {
640 int decoder_specific_info_len = track->
vos_len ? 5 + track->
vos_len : 0;
641 unsigned avg_bitrate;
648 put_descr(pb, 0x03, 3 + 5+13 + decoder_specific_info_len + 5+1);
653 put_descr(pb, 0x04, 13 + decoder_specific_info_len);
784 "Cannot write moov atom before TrueHD packets."
785 " Set the delay_moov flag to fix this.\n");
790 if (length < 20 || length > track->
vos_len)
806 uint32_t layout_tag, bitmap;
814 "lack of channel information\n");
879 int unescaped_size, seq_found = 0;
880 int level = 0, interlace = 0;
889 packet_seq = packet_entry = 1;
891 "moov atom written before any packets, unable to write correct "
892 "dvc1 atom. Set the delay_moov flag to fix this.\n");
899 for (next = start; next <
end; start = next) {
903 size = next - start - 4;
1015 if (cluster_idx >= track->
entry)
1018 if (cluster_idx + 1 == track->
entry)
1021 next_dts = track->
cluster[cluster_idx + 1].
dts;
1033 int i, first_duration;
1045 for (
i = 1;
i < track->
entry;
i++) {
1049 return first_duration;
1056 uint32_t
tag = track->
tag;
1166 else if (track->
tag ==
MKTAG(
'm',
'p',
'4',
'a'))
1254 if (track->
tag ==
MKTAG(
'h',
'v',
'c',
'1'))
1267 int display_width = track->
par->
width;
1295 if (track->
tag ==
MKTAG(
'A',
'V',
'd',
'h')) {
1339 for (
i = 0;
i < 10;
i++)
1372 }
else if (track->
par->
height == 1080) {
1387 #if FF_API_LAVF_AVCTX
1405 if (rational_framerate.
den != 0)
1406 rate =
av_q2d(rational_framerate);
1423 if (rate == 24)
tag =
MKTAG(
'x',
'd',
'v',
'4');
1424 else if (rate == 25)
tag =
MKTAG(
'x',
'd',
'v',
'5');
1425 else if (rate == 30)
tag =
MKTAG(
'x',
'd',
'v',
'1');
1426 else if (rate == 50)
tag =
MKTAG(
'x',
'd',
'v',
'a');
1427 else if (rate == 60)
tag =
MKTAG(
'x',
'd',
'v',
'9');
1431 if (rate == 24)
tag =
MKTAG(
'x',
'd',
'v',
'6');
1432 else if (rate == 25)
tag =
MKTAG(
'x',
'd',
'v',
'7');
1433 else if (rate == 30)
tag =
MKTAG(
'x',
'd',
'v',
'8');
1435 if (rate == 25)
tag =
MKTAG(
'x',
'd',
'v',
'3');
1436 else if (rate == 30)
tag =
MKTAG(
'x',
'd',
'v',
'2');
1440 if (rate == 24)
tag =
MKTAG(
'x',
'd',
'v',
'd');
1441 else if (rate == 25)
tag =
MKTAG(
'x',
'd',
'v',
'e');
1442 else if (rate == 30)
tag =
MKTAG(
'x',
'd',
'v',
'f');
1444 if (rate == 25)
tag =
MKTAG(
'x',
'd',
'v',
'c');
1445 else if (rate == 30)
tag =
MKTAG(
'x',
'd',
'v',
'b');
1451 if (rate == 24)
tag =
MKTAG(
'x',
'd',
'5',
'4');
1452 else if (rate == 25)
tag =
MKTAG(
'x',
'd',
'5',
'5');
1453 else if (rate == 30)
tag =
MKTAG(
'x',
'd',
'5',
'1');
1454 else if (rate == 50)
tag =
MKTAG(
'x',
'd',
'5',
'a');
1455 else if (rate == 60)
tag =
MKTAG(
'x',
'd',
'5',
'9');
1459 if (rate == 24)
tag =
MKTAG(
'x',
'd',
'5',
'd');
1460 else if (rate == 25)
tag =
MKTAG(
'x',
'd',
'5',
'e');
1461 else if (rate == 30)
tag =
MKTAG(
'x',
'd',
'5',
'f');
1463 if (rate == 25)
tag =
MKTAG(
'x',
'd',
'5',
'c');
1464 else if (rate == 30)
tag =
MKTAG(
'x',
'd',
'5',
'b');
1485 if (rate == 24)
tag =
MKTAG(
'a',
'i',
'5',
'p');
1486 else if (rate == 25)
tag =
MKTAG(
'a',
'i',
'5',
'q');
1487 else if (rate == 30)
tag =
MKTAG(
'a',
'i',
'5',
'p');
1488 else if (rate == 50)
tag =
MKTAG(
'a',
'i',
'5',
'q');
1489 else if (rate == 60)
tag =
MKTAG(
'a',
'i',
'5',
'p');
1493 if (rate == 24)
tag =
MKTAG(
'a',
'i',
'5',
'3');
1494 else if (rate == 25)
tag =
MKTAG(
'a',
'i',
'5',
'2');
1495 else if (rate == 30)
tag =
MKTAG(
'a',
'i',
'5',
'3');
1497 if (rate == 50)
tag =
MKTAG(
'a',
'i',
'5',
'5');
1498 else if (rate == 60)
tag =
MKTAG(
'a',
'i',
'5',
'6');
1504 if (rate == 24)
tag =
MKTAG(
'a',
'i',
'1',
'p');
1505 else if (rate == 25)
tag =
MKTAG(
'a',
'i',
'1',
'q');
1506 else if (rate == 30)
tag =
MKTAG(
'a',
'i',
'1',
'p');
1507 else if (rate == 50)
tag =
MKTAG(
'a',
'i',
'1',
'q');
1508 else if (rate == 60)
tag =
MKTAG(
'a',
'i',
'1',
'p');
1512 if (rate == 24)
tag =
MKTAG(
'a',
'i',
'1',
'3');
1513 else if (rate == 25)
tag =
MKTAG(
'a',
'i',
'1',
'2');
1514 else if (rate == 30)
tag =
MKTAG(
'a',
'i',
'1',
'3');
1516 if (rate == 25)
tag =
MKTAG(
'a',
'i',
'1',
'5');
1517 else if (rate == 50)
tag =
MKTAG(
'a',
'i',
'1',
'5');
1518 else if (rate == 60)
tag =
MKTAG(
'a',
'i',
'1',
'6');
1530 static const struct {
1578 if (
tag ==
MKTAG(
'r',
'a',
'w',
' ') &&
1582 av_log(
s,
AV_LOG_ERROR,
"%s rawvideo cannot be written to mov, output file will be unreadable\n",
1619 "the file may be unplayable!\n");
1626 tag =
MKTAG(
'm',
's', ((ms_tag >> 8) & 0xff), (ms_tag & 0xff));
1628 "the file may be unplayable!\n");
1653 for (
i = 0; tags && tags[
i];
i++) {
1658 return codec_tags->
tag;
1675 "Quicktime/Ipod might not play the file\n");
1701 0x0000, 0x0100, 0x0201, 0x0206, 0x0209, 0x020e
1706 unsigned mov_field_order = 0;
1708 mov_field_order =
fiel_data[field_order];
1738 if (stereo_3d->
flags != 0) {
1743 switch (stereo_3d->
type) {
1766 int64_t sv3d_pos, svhd_pos, proj_pos;
1841 "rpu flag: %d, el flag: %d, bl flag: %d, compatibility id: %d\n",
1889 gama = (uint32_t)
lrint((
double)(1<<16) * gamma);
1911 int icc_profile_size;
1920 avio_write(pb, icc_profile, icc_profile_size);
1921 return 12 + icc_profile_size;
1977 const int chroma_den = 50000;
1978 const int luma_den = 10000;
2021 }
else if(track->
par->
width == 1440) {
2035 char compressor_name[32] = { 0 };
2055 if (uncompressed_ycbcr) {
2084 avio_w8(pb, strlen(compressor_name));
2105 for (
i = 0;
i < pal_size;
i++) {
2107 uint16_t
r = (rgb >> 16) & 0xff;
2108 uint16_t
g = (rgb >> 8) & 0xff;
2109 uint16_t
b = rgb & 0xff;
2118 if (track->
tag ==
MKTAG(
'm',
'p',
'4',
'v'))
2148 }
else if (track->
vos_len > 0)
2156 #if FF_API_LAVF_AVCTX
2158 if (field_order != track->
st->codec->field_order && track->
st->codec->field_order !=
AV_FIELD_UNKNOWN)
2159 field_order = track->
st->codec->field_order;
2192 if (spherical_mapping)
2202 if (uncompressed_ycbcr){
2240 uint64_t str_size =strlen(reel_name);
2243 if (str_size >= UINT16_MAX){
2266 #if FF_API_LAVF_AVCTX
2280 if (nb_frames > 255) {
2356 uint32_t entries = 0;
2363 ctts_entries[0].
count = 1;
2365 for (
i = 1;
i < track->
entry;
i++) {
2367 ctts_entries[entries].
count++;
2371 ctts_entries[entries].
count = 1;
2375 atom_size = 16 + (entries * 8);
2384 for (
i = 0;
i < entries;
i++) {
2396 uint32_t entries = -1;
2401 stts_entries =
av_malloc(
sizeof(*stts_entries));
2413 for (
i = 0;
i < track->
entry;
i++) {
2416 stts_entries[entries].
count++;
2420 stts_entries[entries].
count = 1;
2425 atom_size = 16 + (entries * 8);
2430 for (
i = 0;
i < entries;
i++) {
2457 int16_t roll_distance;
2458 int group_description_index;
2461 struct sgpd_entry *sgpd_entries =
NULL;
2481 for (
i = 0;
i < track->
entry;
i++) {
2482 int roll_samples_remaining = roll_samples;
2484 for (j =
i - 1; j >= 0; j--) {
2487 if (roll_samples_remaining <= 0)
2493 if (roll_samples_remaining > 0)
2498 if (
i &&
distance == sgpd_entries[entries].roll_distance) {
2499 sgpd_entries[entries].count++;
2502 sgpd_entries[entries].count = 1;
2503 sgpd_entries[entries].roll_distance =
distance;
2504 sgpd_entries[entries].group_description_index =
distance ? ++group : 0;
2510 sgpd_entries[entries].roll_distance = 1;
2511 sgpd_entries[entries].group_description_index = ++group;
2527 for (
i = 0;
i < entries;
i++) {
2528 if (sgpd_entries[
i].group_description_index) {
2529 avio_wb16(pb, -sgpd_entries[
i].roll_distance);
2539 for (
i = 0;
i < entries;
i++) {
2541 avio_wb32(pb, sgpd_entries[
i].group_description_index);
2606 const char *font =
"Lucida Grande";
2646 if (track->
tag !=
MKTAG(
'c',
'6',
'0',
'8')) {
2698 return track->
tag ==
MKTAG(
'c',
'7',
'0',
'8') ||
2699 track->
tag ==
MKTAG(
'c',
'6',
'0',
'8');
2705 const char *hdlr, *descr =
NULL, *hdlr_type =
NULL;
2710 descr =
"DataHandler";
2713 hdlr = (track->
mode ==
MODE_MOV) ?
"mhlr" :
"\0\0\0\0";
2716 descr =
"VideoHandler";
2719 descr =
"SoundHandler";
2723 descr =
"ClosedCaptionHandler";
2725 if (track->
tag ==
MKTAG(
't',
'x',
'3',
'g')) {
2727 }
else if (track->
tag ==
MKTAG(
'm',
'p',
'4',
's')) {
2732 descr =
"SubtitleHandler";
2736 descr =
"HintHandler";
2739 descr =
"TimeCodeHandler";
2742 descr =
"GoPro MET";
2745 "Unknown hldr_type for %s, writing dummy values\n",
2810 }
else if (track->
tag ==
MKTAG(
'r',
't',
'p',
' ')) {
2812 }
else if (track->
tag ==
MKTAG(
't',
'm',
'c',
'd')) {
2817 }
else if (track->
tag ==
MKTAG(
'g',
'p',
'm',
'd')) {
2868 else if (!track->
entry)
2877 "FATAL error, file duration too long for timebase, this file will not be\n"
2878 "playable with QuickTime. Choose a different timebase with "
2879 "-video_track_timescale or a different container format\n");
2905 int16_t d, int16_t tx, int16_t ty)
2929 uint32_t *display_matrix =
NULL;
2930 int display_matrix_size,
i;
2939 &display_matrix_size);
2940 if (display_matrix && display_matrix_size < 9 *
sizeof(*display_matrix))
2941 display_matrix =
NULL;
2965 else if (!track->
entry)
2982 #if FF_API_OLD_ROTATE_API
2985 rotation = (rot && rot->
value) ? atoi(rot->
value) : 0;
2988 if (display_matrix) {
2989 for (
i = 0;
i < 9;
i++)
2991 #if FF_API_OLD_ROTATE_API
2992 }
else if (rotation == 90) {
2994 }
else if (rotation == 180) {
2996 }
else if (rotation == 270) {
3005 int64_t track_width_1616;
3007 track_width_1616 = track->
par->
width * 0x10000ULL;
3012 if (!track_width_1616 ||
3014 track_width_1616 > UINT32_MAX)
3015 track_width_1616 = track->
par->
width * 0x10000ULL;
3017 if (track_width_1616 > UINT32_MAX) {
3019 track_width_1616 = 0;
3022 if (track->
height > 0xFFFF) {
3073 int entry_size, entry_count,
size;
3074 int64_t delay, start_ct = track->
start_cts;
3081 "EDTS using dts:%"PRId64
" cts:%d instead of dts:%"PRId64
" cts:%"PRId64
" tid:%d\n",
3083 start_dts, start_ct, track->
track_id);
3091 version |= delay < INT32_MAX ? 0 : 1;
3093 entry_size = (
version == 1) ? 20 : 12;
3094 entry_count = 1 + (delay > 0);
3095 size = 24 + entry_count * entry_size;
3126 start_ct = -
FFMIN(start_dts, 0);
3184 char buf[1000] =
"";
3203 const char *
tag,
const char *
str)
3247 int entry_backup = track->
entry;
3267 "Not writing any edit list even though one would have been required\n");
3277 if (track->
tag ==
MKTAG(
'r',
't',
'p',
' '))
3291 track->
entry = entry_backup;
3298 int i, has_audio = 0, has_video = 0;
3308 if (audio_profile < 0)
3309 audio_profile = 0xFF - has_audio;
3310 if (video_profile < 0)
3311 video_profile = 0xFF - has_video;
3351 int max_track_id = 1,
i;
3352 int64_t max_track_len = 0;
3362 if (max_track_len < max_track_len_temp)
3363 max_track_len = max_track_len_temp;
3364 if (max_track_id < mov->tracks[
i].track_id)
3375 version = max_track_len < UINT32_MAX ? 0 : 1;
3442 return strlen(
data) + 4;
3447 const char *
value,
int lang,
int long_style)
3461 const char *
tag,
int *lang)
3475 len2 = strlen(
t2->key);
3476 if (len2 ==
len + 4 && !strcmp(t->
value,
t2->value)
3486 const char *
name,
const char *
tag,
3500 int size = 0, tmpo = t ? atoi(t->
value) : 0;
3519 double latitude, longitude, altitude;
3520 int32_t latitude_fix, longitude_fix, altitude_fix;
3522 const char *ptr, *place =
"";
3524 static const char *astronomical_body =
"earth";
3546 latitude_fix = (
int32_t) ((1 << 16) * latitude);
3547 longitude_fix = (
int32_t) ((1 << 16) * longitude);
3548 altitude_fix = (
int32_t) ((1 << 16) * altitude);
3559 avio_write(pb, astronomical_body, strlen(astronomical_body) + 1);
3570 disc ?
"disc" :
"track",
3572 int size = 0, track = t ? atoi(t->
value) : 0;
3575 char *slash = strchr(t->
value,
'/');
3577 tracks = atoi(slash + 1);
3594 const char *
name,
const char *
tag,
3601 if (
len != 1 &&
len != 4)
3606 num = atoi(t->
value);
3626 for (
i = 0;
i <
s->nb_streams;
i++) {
3708 int64_t curpos, entry_pos;
3776 const char *
name,
const char *
key)
3808 return (((
str[0] - 0x60) & 0x1F) << 10) +
3809 (((
str[1] - 0x60) & 0x1F) << 5) +
3810 ((
str[2] - 0x60) & 0x1F);
3814 const char *
tag,
const char *
str)
3823 if (!strcmp(
tag,
"yrrc"))
3828 if (!strcmp(
tag,
"albm") &&
3838 int i, nb_chapters =
FFMIN(
s->nb_chapters, 255);
3846 for (
i = 0;
i < nb_chapters;
i++) {
3920 const char *
str,
const char *lang,
int type)
3974 uint64_t chunkSize = chunk->
size;
3987 chunkSize = chunk->
size;
4013 int next_generated_track_id = 0;
4014 for (
i = 0;
i <
s->nb_streams;
i++) {
4015 if (
s->streams[
i]->id > next_generated_track_id)
4016 next_generated_track_id =
s->streams[
i]->id;
4023 mov->
tracks[
i].
track_id =
i >=
s->nb_streams ? ++next_generated_track_id :
s->streams[
i]->id;
4060 for (
i = 0;
i <
s->nb_streams;
i++) {
4066 if (track->
tag ==
MKTAG(
'r',
't',
'p',
' ')) {
4070 int * fallback,
size;
4074 if (fallback !=
NULL &&
size ==
sizeof(
int)) {
4075 if (*fallback >= 0 && *fallback < mov->
nb_streams) {
4130 buf[2 *
len] =
'\0';
4131 avio_printf(pb,
"<param name=\"%s\" value=\"%s\" valuetype=\"data\"/>\n",
name, buf);
4138 int64_t manifest_bit_rate = 0;
4141 static const uint8_t uuid[] = {
4142 0xa5, 0xd4, 0x0b, 0x30, 0xe8, 0x14, 0x11, 0xdd,
4143 0xba, 0x2f, 0x08, 0x00, 0x20, 0x0c, 0x9a, 0x66
4151 avio_printf(pb,
"<?xml version=\"1.0\" encoding=\"utf-8\"?>\n");
4152 avio_printf(pb,
"<smil xmlns=\"http://www.w3.org/2001/SMIL20/Language\">\n");
4155 avio_printf(pb,
"<meta name=\"creator\" content=\"%s\" />\n",
4167 char track_name_buf[32] = { 0 };
4199 av_strlcatf(track_name_buf,
sizeof(track_name_buf),
4200 "_%s", lang->
value);
4204 av_strlcat(track_name_buf,
"_cc",
sizeof(track_name_buf));
4206 av_strlcat(track_name_buf,
"_ad",
sizeof(track_name_buf));
4282 MOVTrack *track, int64_t moof_offset)
4287 if (!track->
entry) {
4334 if (track->
entry > 1)
4406 static const uint8_t uuid[] = {
4407 0x6d, 0x1d, 0x9b, 0x05, 0x42, 0xd5, 0x44, 0xe6,
4408 0x80, 0xe2, 0x14, 0x1d, 0xaf, 0xf7, 0x57, 0xb2
4428 int size = 8 + 16 + 4 + 1 + 16*n;
4429 static const uint8_t uuid[] = {
4430 0xd4, 0x80, 0x7e, 0xf2, 0xca, 0x39, 0x46, 0x95,
4431 0x8e, 0x54, 0x26, 0xcb, 0x9e, 0x46, 0xa7, 0x9f
4444 for (
i = 0;
i < n;
i++) {
4445 int index = entry + 1 +
i;
4449 if (n < mov->ism_lookahead) {
4480 if ((tracks >= 0 &&
i != tracks) || !track->
entry)
4503 if (
info->time < 0) {
4507 info->tfrf_offset = 0;
4518 if ((tracks >= 0 &&
i != tracks) || !track->
entry)
4540 MOVTrack *track, int64_t moof_offset,
4551 for (
i = 1;
i < track->
entry;
i++) {
4566 if (!
info->tfrf_offset)
4580 int tracks,
int moof_size)
4592 if (tracks >= 0 &&
i != tracks)
4603 MOVTrack *track,
int ref_size,
int total_sidx_size)
4607 unsigned starts_with_SAP;
4619 if (presentation_time < 0) {
4621 presentation_time = 0;
4642 for (
i = 0;
i < entries;
i++) {
4643 if (!track->
entry) {
4649 starts_with_SAP = 1;
4651 avio_wb32(pb, (0 << 31) | (ref_size & 0x7fffffff));
4653 avio_wb32(pb, (starts_with_SAP << 31) | (0 << 28) | 0);
4657 offset =
pos + total_sidx_size - end_pos;
4665 int tracks,
int ref_size)
4683 if (tracks >= 0 &&
i != tracks)
4688 if (!track->
entry && ref_size > 0)
4709 first_track = &(mov->
tracks[0]);
4711 if (!first_track->
entry) {
4843 int has_h264,
int has_video,
int write_minor)
4852 minor = has_h264 ? 0x100 : 0x200;
4855 minor = has_h264 ? 0x20000 : 0x10000;
4884 int has_h264 = 0, has_video = 0;
4887 for (
i = 0;
i <
s->nb_streams;
i++) {
4955 int audio_kbitrate = audio_par->
bit_rate / 1000;
4956 int video_kbitrate =
FFMIN(video_par->
bit_rate / 1000, 800 - audio_kbitrate);
4958 if (frame_rate < 0 || frame_rate > INT32_MAX) {
4959 av_log(
s,
AV_LOG_ERROR,
"Frame rate %f outside supported range\n", frame_rate / (
double)0x10000);
5024 int video_streams_nb = 0, audio_streams_nb = 0, other_streams_nb = 0;
5025 for (
i = 0;
i <
s->nb_streams;
i++) {
5037 if (video_streams_nb != 1 || audio_streams_nb != 1 || other_streams_nb) {
5049 int i, closed_gop = 0;
5054 closed_gop =
pkt->
data[
i + 4] >> 6 & 0x01;
5055 }
else if (
c == 0x100) {
5057 if (!temp_ref || closed_gop)
5070 int seq = 0, entry = 0;
5073 for (next = start; next <
end; start = next) {
5135 if (length < 8 || length >
pkt->
size)
5174 int i, first_track = -1;
5175 int64_t mdat_size = 0;
5177 int has_video = 0, starts_with_key = 0, first_video_track = 1;
5187 for (
i = 0;
i <
s->nb_streams;
i++) {
5205 if (track->
entry <= 1)
5223 "Estimating the duration of the last packet in a "
5224 "fragment, consider setting the duration field in "
5225 "AVPacket instead.\n");
5233 int buf_size, moov_size;
5304 if (first_video_track) {
5307 first_video_track = 0;
5314 if (first_track < 0)
5327 int buf_size, write_moof = 1, moof_tracks = -1;
5340 write_moof =
i == first_track;
5417 av_log(
s,
AV_LOG_ERROR,
"Application provided duration: %"PRId64
" / timestamp: %"PRId64
" is out of range for mov/mp4 format\n",
5439 unsigned int samples_in_chunk = 0;
5474 static const uint16_t packed_size[16] =
5475 {13, 14, 16, 18, 20, 21, 27, 32, 6, 0, 0, 0, 0, 0, 0, 1};
5478 while (
len <
size && samples_in_chunk < 100) {
5482 if (samples_in_chunk > 1) {
5483 av_log(
s,
AV_LOG_ERROR,
"fatal error, input is not a single packet, implement a AVParser for it\n");
5492 samples_in_chunk = 1;
5494 if (samples_in_chunk < 1) {
5534 "use the audio bitstream filter 'aac_adtstoasc' to fix it "
5535 "('-bsf:a aac_adtstoasc' option with ffmpeg)\n");
5582 #if CONFIG_AC3_PARSER
5584 size = handle_eac3(mov,
pkt, trk);
5594 int nal_size_length = (par->
extradata[4] & 0x3) + 1;
5679 "Track %d starts with a nonzero dts %"PRId64
", while the moov "
5680 "already has been written. Set the delay_moov flag to handle "
5738 reformatted_data ? reformatted_data +
offset
5744 if (
pkt->
data != reformatted_data)
5754 int64_t frag_duration = 0;
5763 for (
i = 0;
i <
s->nb_streams;
i++)
5786 memcpy(par->
extradata, side, side_size);
5847 end.stream_index = stream_index;
5921 int reshuffle_ret,
ret;
5924 int expected_stride = ((trk->
par->
width * bpc + 15) >> 4)*2;
5926 if (reshuffle_ret < 0)
5927 return reshuffle_ret;
5942 if (reshuffle_ret) {
5967 track->
tag =
MKTAG(
't',
'e',
'x',
't');
5975 uint8_t chapter_properties[43] = { 0, 0, 0, 0, 0, 0, 0, 1, };
5978 memcpy(track->
par->
extradata, chapter_properties,
sizeof(chapter_properties));
6025 for (
i = 0;
i <
s->nb_chapters;
i++) {
6034 static const char encd[12] = {
6035 0x00, 0x00, 0x00, 0x0C,
6037 0x00, 0x00, 0x01, 0x00 };
6045 memcpy(
pkt.
data +
len + 2, encd,
sizeof(encd));
6069 AVStream *src_st =
s->streams[src_index];
6075 track->
tag =
MKTAG(
't',
'm',
'c',
'd');
6125 for (
i = 0;
i <
s->nb_streams;
i++) {
6148 if (!enabled[
i] &&
first[
i] >= 0)
6199 r = (rgb >> 16) & 0xFF;
6200 g = (rgb >> 8) & 0xFF;
6203 y = av_clip_uint8(( 16000 + 257 *
r + 504 *
g + 98 *
b)/1000);
6204 cb = av_clip_uint8((128000 - 148 *
r - 291 *
g + 439 *
b)/1000);
6205 cr = av_clip_uint8((128000 + 439 *
r - 368 *
g - 71 *
b)/1000);
6207 return (y << 16) | (
cr << 8) |
cb;
6214 int have_palette = 0, have_size = 0;
6215 uint32_t palette[16];
6218 while (cur && *cur) {
6219 if (strncmp(
"palette:", cur, 8) == 0) {
6221 count = sscanf(cur + 8,
6222 "%06"PRIx32
", %06"PRIx32
", %06"PRIx32
", %06"PRIx32
", "
6223 "%06"PRIx32
", %06"PRIx32
", %06"PRIx32
", %06"PRIx32
", "
6224 "%06"PRIx32
", %06"PRIx32
", %06"PRIx32
", %06"PRIx32
", "
6225 "%06"PRIx32
", %06"PRIx32
", %06"PRIx32
", %06"PRIx32
"",
6226 &palette[ 0], &palette[ 1], &palette[ 2], &palette[ 3],
6227 &palette[ 4], &palette[ 5], &palette[ 6], &palette[ 7],
6228 &palette[ 8], &palette[ 9], &palette[10], &palette[11],
6229 &palette[12], &palette[13], &palette[14], &palette[15]);
6231 for (
i = 0;
i < count;
i++) {
6235 }
else if (!strncmp(
"size:", cur, 5)) {
6239 if (have_palette && have_size)
6241 cur += strcspn(cur,
"\n\r");
6242 cur += strspn(cur,
"\n\r");
6248 for (
i = 0;
i < 16;
i++) {
6274 else if (!strcmp(
"mov",
s->oformat->name)) mov->
mode =
MODE_MOV;
6275 else if (!strcmp(
"psp",
s->oformat->name)) mov->
mode =
MODE_PSP;
6276 else if (!strcmp(
"ipod",
s->oformat->name)) mov->
mode =
MODE_IPOD;
6277 else if (!strcmp(
"ismv",
s->oformat->name)) mov->
mode =
MODE_ISM;
6278 else if (!strcmp(
"f4v",
s->oformat->name)) mov->
mode =
MODE_F4V;
6336 av_log(
s,
AV_LOG_WARNING,
"No meaningful edit list will be written when using empty_moov without delay_moov\n");
6356 "Sample interleaving in fragments is mutually exclusive with "
6357 "omit_tfhd_offset and separate_moof\n");
6374 for (
i = 0;
i <
s->nb_streams;
i++)
6382 for (
i = 0;
i <
s->nb_streams;
i++) {
6396 for (
i = 0;
i <
s->nb_streams;
i++) {
6400 "so timecode metadata are now ignored\n");
6437 for (
i = 0;
i <
s->nb_streams;
i++) {
6451 "codec not currently supported in container\n",
6463 if (track->
tag ==
MKTAG(
'm',
'x',
'3',
'p') || track->
tag ==
MKTAG(
'm',
'x',
'3',
'n') ||
6464 track->
tag ==
MKTAG(
'm',
'x',
'4',
'p') || track->
tag ==
MKTAG(
'm',
'x',
'4',
'n') ||
6465 track->
tag ==
MKTAG(
'm',
'x',
'5',
'p') || track->
tag ==
MKTAG(
'm',
'x',
'5',
'n')) {
6470 track->
height = track->
tag >> 24 ==
'n' ? 486 : 576;
6475 av_log(
s,
AV_LOG_WARNING,
"Warning: some tools, like mp4split, assume a timescale of 10000000 for ISMV.\n");
6487 "WARNING codec timebase is very high. If duration is too long,\n"
6488 "file may not be playable by quicktime. Specify a shorter timebase\n"
6489 "or choose different container.\n");
6492 track->
tag ==
MKTAG(
'r',
'a',
'w',
' ')) {
6541 av_log(
s,
AV_LOG_ERROR,
"track %d: muxing mp3 at %dhz is not standard, to mux anyway set strict to -1\n",
6559 "%s in MP4 support is experimental, add "
6560 "'-strict %d' if you want to use it.\n",
6602 int i,
ret, hint_track = 0, tmcd_track = 0, nb_tracks =
s->nb_streams;
6608 hint_track = nb_tracks;
6609 for (
i = 0;
i <
s->nb_streams;
i++)
6615 tmcd_track = nb_tracks;
6617 for (
i = 0;
i <
s->nb_streams;
i++) {
6641 for (j = 0; j <
s->nb_streams; j++) {
6650 trackj->
tag != track->
tag
6683 mov->
time += 0x7C25B080;
6690 for (
i = 0;
i <
s->nb_streams;
i++) {
6701 for (
i = 0;
i <
s->nb_streams;
i++) {
6770 int i, moov_size, moov_size2;
6786 if (moov_size2 != moov_size)
6810 int ret = 0, moov_size;
6812 int64_t
pos, pos_end;
6814 int read_buf_id = 0;
6829 read_buf[1] = buf + moov_size;
6838 "the second pass (faststart)\n",
s->url);
6851 #define READ_BLOCK do { \
6852 read_size[read_buf_id] = avio_read(read_pb, read_buf[read_buf_id], moov_size); \
6861 n = read_size[read_buf_id];
6866 }
while (
pos < pos_end);
6883 for (
i = 0;
i <
s->nb_streams;
i++) {
6941 av_log(
s,
AV_LOG_INFO,
"Starting second pass: moving the moov atom to the beginning of the file\n");
7077 #if CONFIG_MOV_MUXER
7082 .extensions =
"mov",
7085 .video_codec = CONFIG_LIBX264_ENCODER ?
7097 .priv_class = &mov_muxer_class,
7100 #if CONFIG_TGP_MUXER
7105 .extensions =
"3gp",
7117 .priv_class = &tgp_muxer_class,
7120 #if CONFIG_MP4_MUXER
7125 .mime_type =
"video/mp4",
7126 .extensions =
"mp4",
7129 .video_codec = CONFIG_LIBX264_ENCODER ?
7139 .priv_class = &mp4_muxer_class,
7142 #if CONFIG_PSP_MUXER
7147 .extensions =
"mp4,psp",
7150 .video_codec = CONFIG_LIBX264_ENCODER ?
7160 .priv_class = &psp_muxer_class,
7163 #if CONFIG_TG2_MUXER
7168 .extensions =
"3g2",
7180 .priv_class = &tg2_muxer_class,
7183 #if CONFIG_IPOD_MUXER
7188 .mime_type =
"video/mp4",
7189 .extensions =
"m4v,m4a,m4b",
7201 .priv_class = &ipod_muxer_class,
7204 #if CONFIG_ISMV_MUXER
7209 .mime_type =
"video/mp4",
7210 .extensions =
"ismv,isma",
7223 .priv_class = &ismv_muxer_class,
7226 #if CONFIG_F4V_MUXER
7231 .mime_type =
"application/f4v",
7232 .extensions =
"f4v",
7244 .priv_class = &f4v_muxer_class,
const AVCodecTag codec_ism_tags[]
int height
active picture (w/o VBI) height for D-10/IMX
static int mov_write_traf_tag(AVIOContext *pb, MOVMuxContext *mov, MOVTrack *track, int64_t moof_offset, int moof_size)
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
#define FF_ENABLE_DEPRECATION_WARNINGS
static int mov_write_udta_sdp(AVIOContext *pb, MOVTrack *track)
#define FF_MOV_FLAG_GLOBAL_SIDX
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
#define AV_LOG_WARNING
Something somehow does not look correct.
#define MOV_TFHD_DEFAULT_FLAGS
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
AVPixelFormat
Pixel format.
static int mov_get_dnxhd_codec_tag(AVFormatContext *s, MOVTrack *track)
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option name
@ AV_CODEC_ID_ADPCM_IMA_QT
#define AVERROR_EXPERIMENTAL
Requested feature is flagged experimental. Set strict_std_compliance if you really want to use it.
@ AVIO_DATA_MARKER_BOUNDARY_POINT
A point in the output bytestream where a demuxer can start parsing (for non self synchronizing bytest...
static int mov_write_moov_tag(AVIOContext *pb, MOVMuxContext *mov, AVFormatContext *s)
#define MOV_TRUN_SAMPLE_FLAGS
static int mov_write_vmhd_tag(AVIOContext *pb)
int av_timecode_check_frame_rate(AVRational rate)
Check if the timecode feature is available for the given frame rate.
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
static void av_unused put_bits32(PutBitContext *s, uint32_t value)
Write exactly 32 bits into a bitstream.
#define FF_MOV_FLAG_FRAG_KEYFRAME
static int mov_write_wfex_tag(AVFormatContext *s, AVIOContext *pb, MOVTrack *track)
#define MOV_TKHD_FLAG_ENABLED
static int mov_write_mfra_tag(AVIOContext *pb, MOVMuxContext *mov)
enum AVMediaType codec_type
General type of the encoded data.
enum AVSphericalProjection projection
Projection type.
static int mov_write_udta_tag(AVIOContext *pb, MOVMuxContext *mov, AVFormatContext *s)
static int mov_write_clap_tag(AVIOContext *pb, MOVTrack *track)
static int mov_add_tfra_entries(AVIOContext *pb, MOVMuxContext *mov, int tracks, int size)
uint32_t bound_bottom
Distance from the bottom edge.
static int mov_write_3gp_udta_tag(AVIOContext *pb, AVFormatContext *s, const char *tag, const char *str)
static av_always_inline void ffio_wfourcc(AVIOContext *pb, const uint8_t *s)
@ EAC3_FRAME_TYPE_INDEPENDENT
#define FF_COMPLIANCE_EXPERIMENTAL
Allow nonstandardized experimental things.
static double cb(void *priv, double x, double y)
const AVCodecTag ff_mp4_obj_type[]
MOVEncryptionScheme encryption_scheme
#define FF_MOV_FLAG_WRITE_COLR
static int mov_write_single_packet(AVFormatContext *s, AVPacket *pkt)
This struct describes the properties of an encoded stream.
static int mov_write_trun_tag(AVIOContext *pb, MOVMuxContext *mov, MOVTrack *track, int moof_size, int first, int end)
static int mov_write_mvhd_tag(AVIOContext *pb, MOVMuxContext *mov)
static uint32_t get_sample_flags(MOVTrack *track, MOVIentry *entry)
enum AVColorSpace color_space
double strtod(const char *, char **)
static int mov_write_track_udta_tag(AVIOContext *pb, MOVMuxContext *mov, AVStream *st)
#define FF_MOV_FLAG_SKIP_TRAILER
#define MKTAG(a, b, c, d)
static int mov_write_gama_tag(AVFormatContext *s, AVIOContext *pb, MOVTrack *track, double gamma)
#define AV_CH_LAYOUT_MONO
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
int av_grow_packet(AVPacket *pkt, int grow_by)
Increase packet size, correctly zeroing padding.
static int mov_write_ms_tag(AVFormatContext *s, AVIOContext *pb, MOVTrack *track)
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
static int mov_auto_flush_fragment(AVFormatContext *s, int force)
static int mov_pcm_le_gt16(enum AVCodecID codec_id)
int min_fragment_duration
unsigned MaxCLL
Max content light level (cd/m^2).
static av_cold int end(AVCodecContext *avctx)
char * encryption_scheme_str
#define FF_MOV_FLAG_FRAG_CUSTOM
static int mov_write_enda_tag(AVIOContext *pb)
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
AVStream ** streams
A list of all streams in the file.
unsigned int avpriv_toupper4(unsigned int x)
@ AVCOL_RANGE_JPEG
the normal 2^n-1 "JPEG" YUV ranges
int strict_std_compliance
Allow non-standard and experimental extension.
static int mov_write_iods_tag(AVIOContext *pb, MOVMuxContext *mov)
int64_t wallclock
A UTC timestamp, in microseconds, since Unix epoch (e.g, av_gettime()).
static int mov_write_tkhd_tag(AVIOContext *pb, MOVMuxContext *mov, MOVTrack *track, AVStream *st)
static int mov_init(AVFormatContext *s)
#define MOV_FRAG_INFO_ALLOC_INCREMENT
static void enable_tracks(AVFormatContext *s)
static int mov_write_mdta_hdlr_tag(AVIOContext *pb, MOVMuxContext *mov, AVFormatContext *s)
static int mov_write_raw_metadata_tag(AVFormatContext *s, AVIOContext *pb, const char *name, const char *key)
AVRational avg_frame_rate
Average framerate.
@ AV_PIX_FMT_MONOWHITE
Y , 1bpp, 0 is white, 1 is black, in each byte pixels are ordered from the msb to the lsb.
#define AV_PIX_FMT_YUV420P10
#define AV_DICT_IGNORE_SUFFIX
Return first entry in a dictionary whose first part corresponds to the search key,...
static int co64_required(const MOVTrack *track)
void * av_mallocz_array(size_t nmemb, size_t size)
#define AV_LOG_VERBOSE
Detailed information.
const AVCodecTag ff_codec_wav_tags[]
static int mov_write_itunes_hdlr_tag(AVIOContext *pb, MOVMuxContext *mov, AVFormatContext *s)
static int mov_write_header(AVFormatContext *s)
static int mov_write_sv3d_tag(AVFormatContext *s, AVIOContext *pb, AVSphericalMapping *spherical_mapping)
@ AV_PIX_FMT_BGR24
packed RGB 8:8:8, 24bpp, BGRBGR...
@ AV_PIX_FMT_BGRA
packed BGRA 8:8:8:8, 32bpp, BGRABGRA...
static int mov_write_loci_tag(AVFormatContext *s, AVIOContext *pb)
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
static int get_sidx_size(AVFormatContext *s)
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
int ff_isom_write_av1c(AVIOContext *pb, const uint8_t *buf, int size)
Writes AV1 extradata (Sequence Header and Metadata OBUs) to the provided AVIOContext.
@ AV_SPHERICAL_EQUIRECTANGULAR_TILE
Video represents a portion of a sphere mapped on a flat surface using equirectangular projection.
#define FF_MOV_FLAG_WRITE_GAMA
static int mov_write_d263_tag(AVIOContext *pb)
#define AV_PKT_FLAG_DISPOSABLE
Flag is used to indicate packets that contain frames that can be discarded by the decoder.
@ FLAC_METADATA_TYPE_STREAMINFO
static const uint16_t fiel_data[]
@ AV_PKT_DATA_SPHERICAL
This side data should be associated with a video stream and corresponds to the AVSphericalMapping str...
int ff_mov_init_hinting(AVFormatContext *s, int index, int src_index)
@ AV_SPHERICAL_EQUIRECTANGULAR
Video represents a sphere mapped on a flat surface using equirectangular projection.
static int mov_write_rtp_tag(AVIOContext *pb, MOVTrack *track)
#define MOV_SAMPLE_DEPENDENCY_UNKNOWN
static int is_clcp_track(MOVTrack *track)
static const AVCodecTag codec_cover_image_tags[]
size_t av_strlcatf(char *dst, size_t size, const char *fmt,...)
int avio_get_dyn_buf(AVIOContext *s, uint8_t **pbuffer)
Return the written size and a pointer to the buffer.
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
void av_packet_free(AVPacket **pkt)
Free the packet, if the packet is reference counted, it will be unreferenced first.
#define FF_COMPLIANCE_UNOFFICIAL
Allow unofficial extensions.
@ AV_PIX_FMT_RGB555BE
packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), big-endian , X=unused/undefined
static int ascii_to_wc(AVIOContext *pb, const uint8_t *b)
#define FF_RTP_FLAG_OPTS(ctx, fieldname)
#define OPUS_SEEK_PREROLL_MS
static int mov_write_tfdt_tag(AVIOContext *pb, MOVTrack *track)
MOVFragmentInfo * frag_info
static int mov_write_wave_tag(AVFormatContext *s, AVIOContext *pb, MOVTrack *track)
static const av_always_inline uint8_t * find_next_marker(const uint8_t *src, const uint8_t *end)
Find VC-1 marker in buffer.
static const struct @262 mov_pix_fmt_tags[]
@ EAC3_FRAME_TYPE_DEPENDENT
@ AV_CODEC_ID_MPEGH_3D_AUDIO
Content light level needed by to transmit HDR over HDMI (CTA-861.3).
static void skip_bits(GetBitContext *s, int n)
enum AVColorPrimaries color_primaries
void avio_write_marker(AVIOContext *s, int64_t time, enum AVIODataMarkerType type)
Mark the written bytestream as a specific type.
@ AV_PIX_FMT_GRAY16BE
Y , 16bpp, big-endian.
@ AV_STEREO3D_SIDEBYSIDE
Views are next to each other.
static int mov_write_trex_tag(AVIOContext *pb, MOVTrack *track)
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
#define FF_MOV_FLAG_FRAG_EVERY_FRAME
static int mov_write_dvc1_tag(AVIOContext *pb, MOVTrack *track)
static void put_descr(AVIOContext *pb, int tag, unsigned int size)
@ AV_OPT_TYPE_BINARY
offset must point to a pointer immediately followed by an int for the length
#define FF_MOV_FLAG_DEFAULT_BASE_MOOF
static int mov_write_audio_tag(AVFormatContext *s, AVIOContext *pb, MOVMuxContext *mov, MOVTrack *track)
static int defined_frame_rate(AVFormatContext *s, AVStream *st)
#define MOV_FRAG_SAMPLE_FLAG_IS_NON_SYNC
static int mov_write_gpmd_tag(AVIOContext *pb, const MOVTrack *track)
int bits_per_raw_sample
This is the number of valid bits in each output sample.
static int mov_write_string_metadata(AVFormatContext *s, AVIOContext *pb, const char *name, const char *tag, int long_style)
int ffio_open_null_buf(AVIOContext **s)
Open a write-only fake memory stream.
@ AV_STEREO3D_2D
Video is not stereoscopic (and metadata has to be there).
static int mov_write_mvex_tag(AVIOContext *pb, MOVMuxContext *mov)
static int mov_write_dref_tag(AVIOContext *pb)
static int mov_write_mdhd_tag(AVIOContext *pb, MOVMuxContext *mov, MOVTrack *track)
static int mov_write_video_tag(AVFormatContext *s, AVIOContext *pb, MOVMuxContext *mov, MOVTrack *track)
static int mov_get_rawvideo_codec_tag(AVFormatContext *s, MOVTrack *track)
double avpriv_get_gamma_from_trc(enum AVColorTransferCharacteristic trc)
Determine a suitable 'gamma' value to match the supplied AVColorTransferCharacteristic.
static int mov_write_esds_tag(AVIOContext *pb, MOVTrack *track)
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
static int mov_write_ftyp_tag(AVIOContext *pb, AVFormatContext *s)
#define MOV_TRUN_SAMPLE_DURATION
static double val(void *priv, double ch)
static unsigned compute_avg_bitrate(MOVTrack *track)
static unsigned int validate_codec_tag(const AVCodecTag *const *tags, unsigned int tag, int codec_id)
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type
static int mov_setup_track_ids(MOVMuxContext *mov, AVFormatContext *s)
Assign track ids.
@ AV_ROUND_UP
Round toward +infinity.
@ AV_PKT_DATA_DISPLAYMATRIX
This side data contains a 3x3 transformation matrix describing an affine transformation that needs to...
#define FF_MOV_FLAG_USE_MDTA
@ AV_CODEC_ID_MP3
preferred ID for decoding MPEG audio layer 1, 2 or 3
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)
Reduce a fraction.
static int mov_get_dv_codec_tag(AVFormatContext *s, MOVTrack *track)
AVProducerReferenceTime prft
#define MOV_FRAG_SAMPLE_FLAG_DEPENDS_YES
#define MOV_TRUN_DATA_OFFSET
void ff_mov_cenc_free(MOVMuxCencContext *ctx)
Free a CENC context.
static void mov_prune_frag_info(MOVMuxContext *mov, int tracks, int max)
#define GET_UTF8(val, GET_BYTE, ERROR)
Convert a UTF-8 character (up to 4 bytes) to its 32-bit UCS-4 encoded form.
enum AVColorTransferCharacteristic color_trc
int avio_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer)
Return the written size and a pointer to the buffer.
static int mov_write_tmpo_tag(AVIOContext *pb, AVFormatContext *s)
static int mov_write_trak_tag(AVFormatContext *s, AVIOContext *pb, MOVMuxContext *mov, MOVTrack *track, AVStream *st)
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But first
enum AVPixelFormat pix_fmt
uint32_t palette[AVPALETTE_COUNT]
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
#define FF_MOV_FLAG_FRAG_DISCONT
static int mov_write_trailer(AVFormatContext *s)
#define FF_PROFILE_AAC_HE_V2
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
int frame_size
Audio only.
int avio_open_dyn_buf(AVIOContext **s)
Open a write only memory stream.
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
int chapter_track
qt chapter track number
#define FF_MOV_FLAG_FRAGMENT
#define MOV_TFHD_DEFAULT_BASE_IS_MOOF
#define AV_OPT_FLAG_ENCODING_PARAM
a generic parameter which can be set by the user for muxing or encoding
@ AV_PKT_DATA_STEREO3D
This side data should be associated with a video stream and contains Stereoscopic 3D information in f...
static int mov_write_chpl_tag(AVIOContext *pb, AVFormatContext *s)
#define MOV_TFHD_DEFAULT_DURATION
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
@ AV_PKT_DATA_MASTERING_DISPLAY_METADATA
Mastering display metadata (based on SMPTE-2086:2014).
int flags
Flags modifying the (de)muxer behaviour.
AVRational sample_aspect_ratio
Video only.
#define FF_MOV_FLAG_DELAY_MOOV
static int mov_check_timecode_track(AVFormatContext *s, AVTimecode *tc, int src_index, const char *tcstr)
static int mov_write_ac3_tag(AVFormatContext *s, AVIOContext *pb, MOVTrack *track)
uint32_t bound_top
Distance from the top edge.
static int check_pkt(AVFormatContext *s, AVPacket *pkt)
int ff_av1_filter_obus_buf(const uint8_t *in, uint8_t **out, int *size, int *offset)
Filter out AV1 OBUs not meant to be present in ISOBMFF sample data and return the result in a data bu...
#define MOV_TRUN_FIRST_SAMPLE_FLAGS
static double av_q2d(AVRational a)
Convert an AVRational to a double.
int nb_meta_tmcd
number of new created tmcd track based on metadata (aka not data copy)
static int utf8len(const uint8_t *b)
static int mov_write_tfra_tag(AVIOContext *pb, MOVTrack *track)
int av_match_ext(const char *filename, const char *extensions)
Return a positive value if the given filename has one of the given extensions, 0 otherwise.
#define FF_MOV_FLAG_NEGATIVE_CTS_OFFSETS
#define FF_PROFILE_UNKNOWN
#define av_assert0(cond)
assert() equivalent, that is always enabled.
static int mov_write_trkn_tag(AVIOContext *pb, MOVMuxContext *mov, AVFormatContext *s, int disc)
@ AV_PKT_DATA_ICC_PROFILE
ICC profile data consisting of an opaque octet buffer following the format described by ISO 15076-1.
#define FF_MOV_FLAG_PREFER_ICC
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
static int mov_write_stco_tag(AVIOContext *pb, MOVTrack *track)
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_RL16
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
@ AVMEDIA_TYPE_DATA
Opaque data information usually continuous.
static int mov_parse_mpeg2_frame(AVPacket *pkt, uint32_t *flags)
static int mov_write_tcmi_tag(AVIOContext *pb, MOVTrack *track)
static void build_chunks(MOVTrack *trk)
@ AV_PKT_DATA_PRFT
Producer Reference Time data corresponding to the AVProducerReferenceTime struct, usually exported by...
static int mov_write_edts_tag(AVIOContext *pb, MOVMuxContext *mov, MOVTrack *track)
This structure describes the bitrate properties of an encoded bitstream.
static int mov_write_colr_tag(AVIOContext *pb, MOVTrack *track, int prefer_icc)
static int mov_write_hdlr_tag(AVFormatContext *s, AVIOContext *pb, MOVTrack *track)
@ AV_PIX_FMT_RGBA
packed RGBA 8:8:8:8, 32bpp, RGBARGBA...
enum AVPixelFormat avpriv_find_pix_fmt(const PixelFormatTag *tags, unsigned int fourcc)
uint8_t * av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type, int *size)
Get side information from packet.
int flags
Additional information about the frame packing.
#define FF_MOV_FLAG_RTP_HINT
static int mov_write_mfhd_tag(AVIOContext *pb, MOVMuxContext *mov)
static void mov_write_psp_udta_tag(AVIOContext *pb, const char *str, const char *lang, int type)
static int mov_write_vpcc_tag(AVFormatContext *s, AVIOContext *pb, MOVTrack *track)
void avio_flush(AVIOContext *s)
Force flushing of buffered data.
int use_stream_ids_as_track_ids
int avg_bitrate
Average bitrate of the stream, in bits per second.
static const AVOption options[]
AVCodecParameters * codecpar
Codec parameters associated with this stream.
static int compute_moov_size(AVFormatContext *s)
@ AV_PIX_FMT_RGB565LE
packed RGB 5:6:5, 16bpp, (msb) 5R 6G 5B(lsb), little-endian
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
int ff_put_wav_header(AVFormatContext *s, AVIOContext *pb, AVCodecParameters *par, int flags)
Write WAVEFORMAT header structure.
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
int src_track
the track that this hint (or tmcd) track describes
uint8_t dv_bl_signal_compatibility_id
static int mov_pcm_be_gt16(enum AVCodecID codec_id)
static const AVCodecTag codec_f4v_tags[]
static int mov_create_timecode_track(AVFormatContext *s, int index, int src_index, AVTimecode tc)
static int mov_write_extradata_tag(AVIOContext *pb, MOVTrack *track)
This function writes extradata "as is".
static int mov_write_packet(AVFormatContext *s, AVPacket *pkt)
static int mov_write_stsc_tag(AVIOContext *pb, MOVTrack *track)
static int write_trailer(AVFormatContext *s1)
@ AVIO_DATA_MARKER_TRAILER
Trailer data, which doesn't contain actual content, but only for finalizing the output file.
@ AV_PIX_FMT_YUYV422
packed YUV 4:2:2, 16bpp, Y0 Cb Y1 Cr
static int get_moov_size(AVFormatContext *s)
static av_always_inline int vc1_unescape_buffer(const uint8_t *src, int size, uint8_t *dst)
int ff_mov_cenc_avc_write_nal_units(AVFormatContext *s, MOVMuxCencContext *ctx, int nal_length_size, AVIOContext *pb, const uint8_t *buf_in, int size)
Write AVC NAL units that are in MP4 format, the nal size and type are written in the clear while the ...
Rational number (pair of numerator and denominator).
int ff_hevc_annexb2mp4_buf(const uint8_t *buf_in, uint8_t **buf_out, int *size, int filter_ps, int *ps_count)
Writes Annex B formatted HEVC NAL units to a data buffer.
static int rtp_hinting_needed(const AVStream *st)
int ffio_close_null_buf(AVIOContext *s)
Close a null buffer.
@ AV_PIX_FMT_MONOBLACK
Y , 1bpp, 0 is black, 1 is white, in each byte pixels are ordered from the msb to the lsb.
#define ROUNDED_DIV(a, b)
@ AV_CODEC_ID_DVD_SUBTITLE
static unsigned int get_bits1(GetBitContext *s)
static int mov_write_moof_tag_internal(AVIOContext *pb, MOVMuxContext *mov, int tracks, int moof_size)
int last_sample_is_subtitle_end
int ff_avc_parse_nal_units_buf(const uint8_t *buf_in, uint8_t **buf, int *size)
static int get_cluster_duration(MOVTrack *track, int cluster_idx)
#define FLAC_STREAMINFO_SIZE
static int mov_write_pasp_tag(AVIOContext *pb, MOVTrack *track)
#define MOV_SAMPLE_DEPENDENCY_NO
int missing_duration_warned
static int mov_write_track_metadata(AVIOContext *pb, AVStream *st, const char *tag, const char *str)
void ff_mov_close_hinting(MOVTrack *track)
void avio_w8(AVIOContext *s, int b)
#define AV_PIX_FMT_YUV422P10
static int mov_get_lpcm_flags(enum AVCodecID codec_id)
Compute flags for 'lpcm' tag.
int ff_mov_cenc_init(MOVMuxCencContext *ctx, uint8_t *encryption_key, int use_subsamples, int bitexact)
Initialize a CENC context.
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
static int mov_write_nmhd_tag(AVIOContext *pb)
This structure supplies correlation between a packet timestamp and a wall clock production time.
int av_packet_ref(AVPacket *dst, const AVPacket *src)
Setup a new reference to the data described by a given packet.
static unsigned int mov_get_codec_tag(AVFormatContext *s, MOVTrack *track)
void av_packet_move_ref(AVPacket *dst, AVPacket *src)
Move every field in src to dst and reset src.
static int mov_write_minf_tag(AVFormatContext *s, AVIOContext *pb, MOVMuxContext *mov, MOVTrack *track)
static void param_write_int(AVIOContext *pb, const char *name, int value)
#define FF_MOV_FLAG_DISABLE_CHPL
static int mov_write_ctts_tag(AVFormatContext *s, AVIOContext *pb, MOVTrack *track)
static int mov_write_string_data_tag(AVIOContext *pb, const char *data, int lang, int long_style)
#define MOV_TFHD_BASE_DATA_OFFSET
@ AV_PIX_FMT_ABGR
packed ABGR 8:8:8:8, 32bpp, ABGRABGR...
@ AVCOL_RANGE_UNSPECIFIED
static int mov_write_isml_manifest(AVIOContext *pb, MOVMuxContext *mov, AVFormatContext *s)
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
static int mov_write_subtitle_end_packet(AVFormatContext *s, int stream_index, int64_t dts)
int sample_rate
Audio only.
static int mov_write_stbl_tag(AVFormatContext *s, AVIOContext *pb, MOVMuxContext *mov, MOVTrack *track)
static int compute_sidx_size(AVFormatContext *s)
static void find_compressor(char *compressor_name, int len, MOVTrack *track)
int64_t nb_frames
number of frames in this stream if known or 0
AVCodecID
Identify the syntax and semantics of the bitstream.
struct eac3_info::@263 substream[1]
int extradata_size
Size of the extradata content in bytes.
#define MOV_FRAG_SAMPLE_FLAG_DEPENDS_NO
int64_t av_rescale_rnd(int64_t a, int64_t b, int64_t c, enum AVRounding rnd)
Rescale a 64-bit integer with specified rounding.
const AVCodecTag ff_codec_movvideo_tags[]
int av_get_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
int ff_isom_write_vpcc(AVFormatContext *s, AVIOContext *pb, AVCodecParameters *par)
Writes VP codec configuration to the provided AVIOContext.
@ AV_PIX_FMT_RGB24
packed RGB 8:8:8, 24bpp, RGBRGB...
@ AV_SPHERICAL_CUBEMAP
Video frame is split into 6 faces of a cube, and arranged on a 3x2 layout.
int ff_avc_parse_nal_units(AVIOContext *pb, const uint8_t *buf_in, int size)
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
static const AVCodecTag codec_ipod_tags[]
int ff_isom_write_avcc(AVIOContext *pb, const uint8_t *data, int len)
uint8_t * av_stream_get_side_data(const AVStream *stream, enum AVPacketSideDataType type, int *size)
Get side information from stream.
uint32_t bound_right
Distance from the right edge.
static int mov_write_dpxe_tag(AVIOContext *pb, MOVTrack *track)
#define FF_MOV_FLAG_FASTSTART
static int mov_write_eac3_tag(AVFormatContext *s, AVIOContext *pb, MOVTrack *track)
uint32_t default_sample_flags
int ff_mov_cenc_write_packet(MOVMuxCencContext *ctx, AVIOContext *pb, const uint8_t *buf_in, int size)
Write a fully encrypted packet.
static AVRational find_fps(AVFormatContext *s, AVStream *st)
const PixelFormatTag avpriv_pix_fmt_bps_mov[]
static int mov_write_mdta_keys_tag(AVIOContext *pb, MOVMuxContext *mov, AVFormatContext *s)
int need_rewrite_extradata
static int mov_write_uuid_tag_psp(AVIOContext *pb, MOVTrack *mov)
#define AV_NOPTS_VALUE
Undefined timestamp value.
const AVCodecTag codec_mp4_tags[]
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32
static AVDictionaryEntry * get_metadata_lang(AVFormatContext *s, const char *tag, int *lang)
static const AVCodecTag codec_3gp_tags[]
#define FF_PUT_WAV_HEADER_FORCE_WAVEFORMATEX
Tell ff_put_wav_header() to use WAVEFORMATEX even for PCM codecs.
int profile
Codec-specific bitstream restrictions that the stream conforms to.
static void write_matrix(AVIOContext *pb, int16_t a, int16_t b, int16_t c, int16_t d, int16_t tx, int16_t ty)
static int mov_create_dvd_sub_decoder_specific_info(MOVTrack *track, AVStream *st)
int64_t reserved_header_pos
static int mov_write_gmhd_tag(AVIOContext *pb, MOVTrack *track)
static int mov_write_stsd_tag(AVFormatContext *s, AVIOContext *pb, MOVMuxContext *mov, MOVTrack *track)
@ AVMEDIA_TYPE_UNKNOWN
Usually treated as AVMEDIA_TYPE_DATA.
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
static int mov_write_tmcd_tag(AVIOContext *pb, MOVTrack *track)
static int mov_write_dmlp_tag(AVFormatContext *s, AVIOContext *pb, MOVTrack *track)
@ AVIO_DATA_MARKER_SYNC_POINT
A point in the output bytestream where a decoder can start decoding (i.e.
int ff_mov_iso639_to_lang(const char lang[4], int mp4)
static int64_t calc_pts_duration(MOVMuxContext *mov, MOVTrack *track)
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
void avio_wb32(AVIOContext *s, unsigned int val)
uint32_t padding
Number of pixels to pad from the edge of each cube face.
uint32_t ff_mov_get_channel_layout_tag(enum AVCodecID codec_id, uint64_t channel_layout, uint32_t *bitmap)
Get the channel layout tag for the specified codec id and channel layout.
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
int av_reallocp_array(void *ptr, size_t nmemb, size_t size)
Allocate, reallocate, or free an array through a pointer to a pointer.
void avio_wl32(AVIOContext *s, unsigned int val)
int max_bitrate
Maximum bitrate of the stream, in bits per second.
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
@ AV_PKT_DATA_CONTENT_LIGHT_LEVEL
Content light level (based on CTA-861.3).
int flags
A combination of AV_PKT_FLAG values.
void ff_mov_cenc_write_stbl_atoms(MOVMuxCencContext *ctx, AVIOContext *pb)
Write the cenc atoms that should reside inside stbl.
static int mov_write_avid_tag(AVIOContext *pb, MOVTrack *track)
static int mov_write_mdta_ilst_tag(AVIOContext *pb, MOVMuxContext *mov, AVFormatContext *s)
unsigned int chunkNum
Chunk number if the current entry is a chunk start otherwise 0.
static int mov_write_meta_tag(AVIOContext *pb, MOVMuxContext *mov, AVFormatContext *s)
#define FF_COMPLIANCE_NORMAL
#define FF_MOV_FLAG_OMIT_TFHD_OFFSET
#define MOV_DISPOSABLE_SAMPLE
static int shift_data(AVFormatContext *s)
static int mov_write_dvc1_structs(MOVTrack *track, uint8_t *buf)
#define AV_LOG_INFO
Standard information.
static void mov_free(AVFormatContext *s)
#define FF_MOV_FLAG_SKIP_SIDX
@ AV_PIX_FMT_ARGB
packed ARGB 8:8:8:8, 32bpp, ARGBARGB...
int ff_mov_add_hinted_packet(AVFormatContext *s, AVPacket *pkt, int track_index, int sample, uint8_t *sample_data, int sample_size)
static void write_packet(OutputFile *of, AVPacket *pkt, OutputStream *ost, int unqueue)
static int mov_write_covr(AVIOContext *pb, AVFormatContext *s)
const char * avcodec_get_name(enum AVCodecID id)
Get the name of a codec.
int ff_isom_write_hvcc(AVIOContext *pb, const uint8_t *data, int size, int ps_array_completeness)
Writes HEVC extradata (parameter sets, declarative SEI NAL units) to the provided AVIOContext.
int hint_track
the track that hints this track, -1 if no hint track is set
static void init(int bf, int audio_preroll)
static av_always_inline uint64_t av_double2int(double f)
Reinterpret a double as a 64-bit integer.
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
static int mov_write_uuidprof_tag(AVIOContext *pb, AVFormatContext *s)
static int mov_write_dinf_tag(AVIOContext *pb)
@ AV_PIX_FMT_RGB555LE
packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), little-endian, X=unused/undefined
int32_t roll
Rotation around the forward vector [-180, 180].
@ AV_PIX_FMT_RGB48BE
packed RGB 16:16:16, 48bpp, 16R, 16G, 16B, the 2-byte value for each R/G/B component is stored as big...
#define FF_MOV_FLAG_EMPTY_MOOV
#define i(width, name, range_min, range_max)
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
static int put_bits_count(PutBitContext *s)
int ff_mov_write_packet(AVFormatContext *s, AVPacket *pkt)
static av_always_inline av_const double round(double x)
#define MOV_CLASS(flavor)
static int mov_write_avcc_tag(AVIOContext *pb, MOVTrack *track)
#define AV_TIME_BASE
Internal time base represented as integer.
int block_align
Audio only.
#define av_malloc_array(a, b)
static int mov_get_mpeg2_xdcam_codec_tag(AVFormatContext *s, MOVTrack *track)
@ AV_STEREO3D_TOPBOTTOM
Views are on top of each other.
static int mov_write_string_tag(AVIOContext *pb, const char *name, const char *value, int lang, int long_style)
int avpriv_ac3_parse_header(AC3HeaderInfo **phdr, const uint8_t *buf, size_t size)
@ AV_ROUND_DOWN
Round toward -infinity.
#define xf(width, name, var, range_min, range_max, subs,...)
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default value
int video_track_timescale
static int mov_write_stss_tag(AVIOContext *pb, MOVTrack *track, uint32_t flag)
#define MOV_TIMECODE_FLAG_DROPFRAME
static void mov_parse_truehd_frame(AVPacket *pkt, MOVTrack *trk)
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
int max_fragment_duration
AVFormatContext * rtp_ctx
the format context for the hinting rtp muxer
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
@ AV_PKT_DATA_CPB_PROPERTIES
This side data corresponds to the AVCPBProperties struct.
enum AVColorRange color_range
Video only.
#define MOV_TFHD_DEFAULT_SIZE
static int mov_write_tapt_tag(AVIOContext *pb, MOVTrack *track)
static int mov_write_stsz_tag(AVIOContext *pb, MOVTrack *track)
#define MOV_SAMPLE_DEPENDENCY_YES
int64_t av_rescale(int64_t a, int64_t b, int64_t c)
Rescale a 64-bit integer with rounding to nearest.
@ AVCOL_RANGE_MPEG
the normal 219*2^(n-8) "MPEG" YUV ranges
enum AVFieldOrder field_order
Video only.
static int64_t update_size(AVIOContext *pb, int64_t pos)
#define FF_PROFILE_AAC_HE
static int mov_write_subtitle_tag(AVIOContext *pb, MOVTrack *track)
@ AV_TIMECODE_FLAG_DROPFRAME
timecode is drop frame
static int mov_write_tfhd_tag(AVIOContext *pb, MOVMuxContext *mov, MOVTrack *track, int64_t moof_offset)
static int mov_write_stts_tag(AVIOContext *pb, MOVTrack *track)
@ AV_PIX_FMT_PAL8
8 bits with AV_PIX_FMT_RGB32 palette
int disposition
AV_DISPOSITION_* bit field.
static int mov_write_moof_tag(AVIOContext *pb, MOVMuxContext *mov, int tracks, int64_t mdat_size)
void ffio_free_dyn_buf(AVIOContext **s)
Free a dynamic buffer.
@ AV_PKT_DATA_DOVI_CONF
DOVI configuration ref: dolby-vision-bitstreams-within-the-iso-base-media-file-format-v2....
static int mov_get_h264_codec_tag(AVFormatContext *s, MOVTrack *track)
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
static int mov_write_int8_metadata(AVFormatContext *s, AVIOContext *pb, const char *name, const char *tag, int len)
static av_always_inline uint64_t ff_dnxhd_parse_header_prefix(const uint8_t *buf)
int ff_mov_cenc_write_sinf_tag(MOVTrack *track, AVIOContext *pb, uint8_t *kid)
Write the sinf atom, contained inside stsd.
size_t av_strlcat(char *dst, const char *src, size_t size)
Append the string src to the string dst, but to a total length of no more than size - 1 bytes,...
int32_t pitch
Rotation around the right vector [-90, 90].
int ff_av1_filter_obus(AVIOContext *pb, const uint8_t *buf, int size)
Filter out AV1 OBUs not meant to be present in ISOBMFF sample data and write the resulting bitstream ...
int buffer_size
The size of the buffer to which the ratecontrol is applied, in bits.
AVCodecParameters * avcodec_parameters_alloc(void)
Allocate a new AVCodecParameters and set its fields to default values (unknown/invalid/0).
#define MOV_TKHD_FLAG_IN_MOVIE
enum AVStereo3DType type
How views are packed within the video.
static int mov_write_tref_tag(AVIOContext *pb, MOVTrack *track)
static int mov_write_uuid_tag_ipod(AVIOContext *pb)
Write uuid atom.
struct AVAESCTR * aes_ctr
#define AV_INPUT_BUFFER_PADDING_SIZE
@ AV_PIX_FMT_UYVY422
packed YUV 4:2:2, 16bpp, Cb Y0 Cr Y1
#define FF_ARRAY_ELEMS(a)
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
static int mov_flush_fragment(AVFormatContext *s, int force)
int avio_printf(AVIOContext *s, const char *fmt,...) av_printf_format(2
Writes a formatted string to the context.
int index
stream index in AVFormatContext
#define MOV_INDEX_CLUSTER_SIZE
const AVCodecTag ff_codec_bmp_tags[]
#define FF_MOV_FLAG_SEPARATE_MOOF
int ff_avc_write_annexb_extradata(const uint8_t *in, uint8_t **buf, int *size)
int reserved_moov_size
0 for disabled, -1 for automatic, size otherwise
#define AVIO_SEEKABLE_NORMAL
Seeking works like for a local file.
static int is_cover_image(const AVStream *st)
@ AV_PKT_DATA_NEW_EXTRADATA
The AV_PKT_DATA_NEW_EXTRADATA is used to notify the codec or the format that the extradata buffer was...
static uint32_t rgb_to_yuv(uint32_t rgb)
static int64_t rescale_mdcv(AVRational q, int b)
static int mov_create_chapter_track(AVFormatContext *s, int tracknum)
static void mov_write_ftyp_tag_internal(AVIOContext *pb, AVFormatContext *s, int has_h264, int has_video, int write_minor)
static int mov_write_prft_tag(AVIOContext *pb, MOVMuxContext *mov, int tracks)
static int mov_write_fiel_tag(AVIOContext *pb, MOVTrack *track, int field_order)
@ AVIO_DATA_MARKER_HEADER
Header data; this needs to be present for the stream to be decodeable.
static int mov_write_identification(AVIOContext *pb, AVFormatContext *s)
static int mov_write_sidx_tags(AVIOContext *pb, MOVMuxContext *mov, int tracks, int ref_size)
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_WB16 unsigned int_TMPL AV_RB8
static int ref[MAX_W *MAX_W]
static int mov_write_hvcc_tag(AVIOContext *pb, MOVTrack *track)
static int mov_write_ilst_tag(AVIOContext *pb, MOVMuxContext *mov, AVFormatContext *s)
static int mov_flush_fragment_interleaving(AVFormatContext *s, MOVTrack *track)
static int mov_write_glbl_tag(AVIOContext *pb, MOVTrack *track)
const AVCodecTag ff_codec_movsubtitle_tags[]
static int mov_write_mdia_tag(AVFormatContext *s, AVIOContext *pb, MOVMuxContext *mov, MOVTrack *track)
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
@ AV_PIX_FMT_RGB565BE
packed RGB 5:6:5, 16bpp, (msb) 5R 6G 5B(lsb), big-endian
void avio_wb64(AVIOContext *s, uint64_t val)
#define MOV_TRACK_ENABLED
#define FF_DISABLE_DEPRECATION_WARNINGS
static int mov_check_bitstream(struct AVFormatContext *s, const AVPacket *pkt)
#define AVIO_FLAG_READ
read-only
int bits_per_coded_sample
The number of bits per sample in the codedwords.
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
static int mov_write_sdtp_tag(AVIOContext *pb, MOVTrack *track)
static void param_write_hex(AVIOContext *pb, const char *name, const uint8_t *value, int len)
static int mov_write_av1c_tag(AVIOContext *pb, MOVTrack *track)
uint32_t bound_left
Distance from the left edge.
#define avpriv_request_sample(...)
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
static int mov_write_uuidusmt_tag(AVIOContext *pb, AVFormatContext *s)
void avio_wb24(AVIOContext *s, unsigned int val)
static int mov_write_dvcc_dvvc_tag(AVFormatContext *s, AVIOContext *pb, AVDOVIDecoderConfigurationRecord *dovi)
static int mov_preroll_write_stbl_atoms(AVIOContext *pb, MOVTrack *track)
static int mov_write_chan_tag(AVFormatContext *s, AVIOContext *pb, MOVTrack *track)
static int mov_write_st3d_tag(AVFormatContext *s, AVIOContext *pb, AVStereo3D *stereo_3d)
unsigned cluster_capacity
static uint16_t language_code(const char *str)
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
static int get_samples_per_packet(MOVTrack *track)
static int mov_write_smhd_tag(AVIOContext *pb)
unsigned MaxFALL
Max average light level per frame (cd/m^2).
This structure stores compressed data.
static double cr(void *priv, double x, double y)
@ AV_CODEC_ID_ADPCM_IMA_WAV
static int mov_write_source_reference_tag(AVIOContext *pb, MOVTrack *track, const char *reel_name)
static void mov_parse_vc1_frame(AVPacket *pkt, MOVTrack *trk)
@ AV_PKT_DATA_FALLBACK_TRACK
This side data contains an integer value representing the stream index of a "fallback" track.
#define MOV_TFHD_DURATION_IS_EMPTY
uint64_t channel_layout
Audio only.
#define MOV_TRUN_SAMPLE_SIZE
struct MOVTrack::@264 vc1_info
static float distance(float x, float y, int band)
static int mov_write_dops_tag(AVFormatContext *s, AVIOContext *pb, MOVTrack *track)
void ffio_fill(AVIOContext *s, int b, int count)
void avio_wb16(AVIOContext *s, unsigned int val)
#define flags(name, subs,...)
static int mov_write_hmhd_tag(AVIOContext *pb)
size_t av_strlcpy(char *dst, const char *src, size_t size)
Copy the string src to dst, but no more than size - 1 bytes, and null-terminate dst.
static void param_write_string(AVIOContext *pb, const char *name, const char *value)
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
static int mov_write_mdcv_tag(AVIOContext *pb, MOVTrack *track)
static int mov_write_enda_tag_be(AVIOContext *pb)
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
const AVCodecTag ff_codec_movaudio_tags[]
const char * av_stereo3d_type_name(unsigned int type)
Provide a human-readable name of a given stereo3d type.
static int mov_write_amr_tag(AVIOContext *pb, MOVTrack *track)
static int mov_write_mdat_tag(AVIOContext *pb, MOVMuxContext *mov)
static int mov_write_tfrf_tag(AVIOContext *pb, MOVMuxContext *mov, MOVTrack *track, int entry)
int av_timecode_init_from_string(AVTimecode *tc, AVRational rate, const char *str, void *log_ctx)
Parse timecode representation (hh:mm:ss[:;.
Stereo 3D type: this structure describes how two videos are packed within a single video surface,...
int ff_mov_cenc_avc_parse_nal_units(MOVMuxCencContext *ctx, AVIOContext *pb, const uint8_t *buf_in, int size)
Parse AVC NAL units from annex B format, the nal size and type are written in the clear while the bod...
static void write_header(FFV1Context *f)
unsigned frag_info_capacity
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_RB24
int avio_put_str(AVIOContext *s, const char *str)
Write a NULL-terminated string.
int tref_id
trackID of the referenced track
@ AV_CODEC_ID_MPEG2VIDEO
preferred ID for MPEG-1/2 video decoding
#define MOV_TRUN_SAMPLE_CTS
static int mov_write_tfrf_tags(AVIOContext *pb, MOVMuxContext *mov, MOVTrack *track)
static unsigned int mov_find_codec_tag(AVFormatContext *s, MOVTrack *track)
This structure describes how to handle spherical videos, outlining information about projection,...
static int mov_write_tfxd_tag(AVIOContext *pb, MOVTrack *track)
#define MOV_PARTIAL_SYNC_SAMPLE
int32_t yaw
Rotation around the up vector [-180, 180].
static int mov_write_clli_tag(AVIOContext *pb, MOVTrack *track)
const char * av_get_pix_fmt_name(enum AVPixelFormat pix_fmt)
Return the short name for a pixel format, NULL in case pix_fmt is unknown.
int ff_hevc_annexb2mp4(AVIOContext *pb, const uint8_t *buf_in, int size, int filter_ps, int *ps_count)
Writes Annex B formatted HEVC NAL units to the provided AVIOContext.
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_RB16
#define av_fourcc2str(fourcc)
void av_init_packet(AVPacket *pkt)
Initialize optional fields of a packet with default values.
static int mov_write_dfla_tag(AVIOContext *pb, MOVTrack *track)
static int mov_write_sidx_tag(AVIOContext *pb, MOVTrack *track, int ref_size, int total_sidx_size)
@ AVIO_DATA_MARKER_FLUSH_POINT
A point in the output bytestream where the underlying AVIOContext might flush the buffer depending on...
unsigned int samples_in_chunk