Go to the documentation of this file.
24 #include "config_components.h"
83 {
"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 },
89 {
"movflags",
"MOV muxer flags", offsetof(
MOVMuxContext,
flags),
AV_OPT_TYPE_FLAGS, {.i64 = 0}, INT_MIN, INT_MAX,
AV_OPT_FLAG_ENCODING_PARAM, .unit =
"movflags" },
93 {
"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, .unit =
"movflags" },
103 {
"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, .unit = 0 },
112 {
"write_colr",
"Write colr atom even if the color info is unspecified (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, .unit =
"movflags" },
123 {
"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, .unit =
"prft"},
131 .
class_name =
"mov/mp4/tgp/psp/tg2/ipod/ismv/f4v muxer",
198 for (
i = 0;
i < track->
entry;
i++) {
213 int i, j, entries = 0, tst = -1, oldtst = -1;
220 for (
i = 0;
i < track->
entry;
i++) {
222 if (oldtst != -1 && tst != oldtst)
227 if (equalChunks && track->
entry) {
229 sSize =
FFMAX(1, sSize);
235 for (
i = 0;
i < track->
entry;
i++) {
248 int index = 0, oldval = -1,
i;
257 for (
i = 0;
i < track->
entry;
i++) {
285 for (
i = 0;
i < track->
entry;
i++) {
302 uint8_t leading, dependent, reference, redundancy;
307 for (
i = 0;
i < track->
entry;
i++) {
316 avio_w8(pb, (leading << 6) | (dependent << 4) |
317 (reference << 2) | redundancy);
326 uint8_t *dyn_buf =
NULL;
403 "Cannot write moov atom before AC3 packets."
404 " Set the delay_moov flag to fix this.\n");
408 if (
info->substream[0].bsid > 8) {
410 "RealAudio AC-3/DolbyNet with bsid %d is not defined by the "
411 "ISOBMFF specification in ETSI TS 102 366!\n",
412 info->substream[0].bsid);
416 if (
info->ac3_bit_rate_code < 0) {
418 "No valid AC3 bit rate code for data rate of %d!\n",
476 if (!
info->ec3_done) {
531 while (cumul_size !=
pkt->
size) {
541 info->substream[parent].num_dep_sub++;
557 info->substream[parent].chan_loc |= (
get_bits(&gbc, 16) >> 5) & 0x1f;
575 if (!
info->num_blocks) {
586 if (
info->num_blocks != 6)
590 info->num_blocks = 0;
609 "Cannot write moov atom before EAC3 packets parsed.\n");
614 size = 2 + ((34 * (
info->num_ind_sub + 1) + 7) >> 3);
623 for (
i = 0;
i <=
info->num_ind_sub;
i++) {
633 if (!
info->substream[
i].num_dep_sub) {
707 track->st->codecpar->nb_coded_side_data,
713 if (!bit_rates.avg_bit_rate) {
722 if (props && props->avg_bitrate) {
723 bit_rates.avg_bit_rate = props->avg_bitrate;
724 }
else if (track->par->bit_rate) {
725 bit_rates.avg_bit_rate = track->par->bit_rate;
726 }
else if (props && props->max_bitrate) {
727 bit_rates.avg_bit_rate = props->max_bitrate;
732 bit_rates.max_bit_rate =
FFMAX(track->par->bit_rate,
733 bit_rates.avg_bit_rate);
737 bit_rates.max_bit_rate =
FFMAX(bit_rates.max_bit_rate,
739 bit_rates.buffer_size = props->buffer_size / 8;
749 int decoder_specific_info_len = track->
vos_len ? 5 + track->
vos_len : 0;
756 put_descr(pb, 0x03, 3 + 5+13 + decoder_specific_info_len + 5+1);
761 put_descr(pb, 0x04, 13 + decoder_specific_info_len);
898 "Cannot write moov atom before TrueHD packets."
899 " Set the delay_moov flag to fix this.\n");
904 if (length < 20 || length > track->
vos_len)
920 uint32_t layout_tag, bitmap, *channel_desc;
928 &bitmap, &channel_desc);
933 "lack of channel information\n");
942 channel_desc =
av_malloc(
sizeof(*channel_desc));
961 for (
int i = 0;
i < num_desc;
i++) {
1021 int unescaped_size, seq_found = 0;
1022 int level = 0, interlace = 0;
1031 packet_seq = packet_entry = 1;
1033 "moov atom written before any packets, unable to write correct "
1034 "dvc1 atom. Set the delay_moov flag to fix this.\n");
1041 for (next = start; next < end; start = next) {
1045 size = next - start - 4;
1102 uint8_t buf[7] = { 0 };
1157 if (cluster_idx >= track->
entry)
1160 if (cluster_idx + 1 == track->
entry)
1163 next_dts = track->
cluster[cluster_idx + 1].
dts;
1175 int i, first_duration;
1187 for (
i = 1;
i < track->
entry;
i++) {
1191 return first_duration;
1218 uint8_t *speaker_pos =
NULL;
1228 speaker_pos,
layout->nb_channels);
1230 char buf[128] = {0};
1248 for (
int i = 0;
i <
layout->nb_channels;
i++)
1286 uint32_t
tag = track->
tag;
1356 if (track->
tag ==
MKTAG(
'i',
'a',
'm',
'f'))
1393 else if (track->
tag ==
MKTAG(
'm',
'p',
'4',
'a'))
1395 else if (track->
tag ==
MKTAG(
'i',
'a',
'm',
'f'))
1419 }
else if (track->
vos_len > 0)
1491 if (track->
tag ==
MKTAG(
'h',
'v',
'c',
'1'))
1505 if (track->
tag ==
MKTAG(
'e',
'v',
'c',
'1'))
1523 if (track->
tag ==
MKTAG(
'v',
'v',
'c',
'1'))
1535 int display_width = track->
par->
width;
1563 if (track->
tag ==
MKTAG(
'A',
'V',
'd',
'h')) {
1639 }
else if (track->
par->
height == 1080) {
1654 if (rational_framerate.
den != 0)
1655 rate =
av_q2d(rational_framerate);
1672 if (rate == 24)
tag =
MKTAG(
'x',
'd',
'v',
'4');
1673 else if (rate == 25)
tag =
MKTAG(
'x',
'd',
'v',
'5');
1674 else if (rate == 30)
tag =
MKTAG(
'x',
'd',
'v',
'1');
1675 else if (rate == 50)
tag =
MKTAG(
'x',
'd',
'v',
'a');
1676 else if (rate == 60)
tag =
MKTAG(
'x',
'd',
'v',
'9');
1680 if (rate == 24)
tag =
MKTAG(
'x',
'd',
'v',
'6');
1681 else if (rate == 25)
tag =
MKTAG(
'x',
'd',
'v',
'7');
1682 else if (rate == 30)
tag =
MKTAG(
'x',
'd',
'v',
'8');
1684 if (rate == 25)
tag =
MKTAG(
'x',
'd',
'v',
'3');
1685 else if (rate == 30)
tag =
MKTAG(
'x',
'd',
'v',
'2');
1689 if (rate == 24)
tag =
MKTAG(
'x',
'd',
'v',
'd');
1690 else if (rate == 25)
tag =
MKTAG(
'x',
'd',
'v',
'e');
1691 else if (rate == 30)
tag =
MKTAG(
'x',
'd',
'v',
'f');
1693 if (rate == 25)
tag =
MKTAG(
'x',
'd',
'v',
'c');
1694 else if (rate == 30)
tag =
MKTAG(
'x',
'd',
'v',
'b');
1700 if (rate == 24)
tag =
MKTAG(
'x',
'd',
'5',
'4');
1701 else if (rate == 25)
tag =
MKTAG(
'x',
'd',
'5',
'5');
1702 else if (rate == 30)
tag =
MKTAG(
'x',
'd',
'5',
'1');
1703 else if (rate == 50)
tag =
MKTAG(
'x',
'd',
'5',
'a');
1704 else if (rate == 60)
tag =
MKTAG(
'x',
'd',
'5',
'9');
1708 if (rate == 24)
tag =
MKTAG(
'x',
'd',
'5',
'd');
1709 else if (rate == 25)
tag =
MKTAG(
'x',
'd',
'5',
'e');
1710 else if (rate == 30)
tag =
MKTAG(
'x',
'd',
'5',
'f');
1712 if (rate == 25)
tag =
MKTAG(
'x',
'd',
'5',
'c');
1713 else if (rate == 30)
tag =
MKTAG(
'x',
'd',
'5',
'b');
1734 if (rate == 24)
tag =
MKTAG(
'a',
'i',
'5',
'p');
1735 else if (rate == 25)
tag =
MKTAG(
'a',
'i',
'5',
'q');
1736 else if (rate == 30)
tag =
MKTAG(
'a',
'i',
'5',
'p');
1737 else if (rate == 50)
tag =
MKTAG(
'a',
'i',
'5',
'q');
1738 else if (rate == 60)
tag =
MKTAG(
'a',
'i',
'5',
'p');
1742 if (rate == 24)
tag =
MKTAG(
'a',
'i',
'5',
'3');
1743 else if (rate == 25)
tag =
MKTAG(
'a',
'i',
'5',
'2');
1744 else if (rate == 30)
tag =
MKTAG(
'a',
'i',
'5',
'3');
1746 if (rate == 50)
tag =
MKTAG(
'a',
'i',
'5',
'5');
1747 else if (rate == 60)
tag =
MKTAG(
'a',
'i',
'5',
'6');
1753 if (rate == 24)
tag =
MKTAG(
'a',
'i',
'1',
'p');
1754 else if (rate == 25)
tag =
MKTAG(
'a',
'i',
'1',
'q');
1755 else if (rate == 30)
tag =
MKTAG(
'a',
'i',
'1',
'p');
1756 else if (rate == 50)
tag =
MKTAG(
'a',
'i',
'1',
'q');
1757 else if (rate == 60)
tag =
MKTAG(
'a',
'i',
'1',
'p');
1761 if (rate == 24)
tag =
MKTAG(
'a',
'i',
'1',
'3');
1762 else if (rate == 25)
tag =
MKTAG(
'a',
'i',
'1',
'2');
1763 else if (rate == 30)
tag =
MKTAG(
'a',
'i',
'1',
'3');
1765 if (rate == 25)
tag =
MKTAG(
'a',
'i',
'1',
'5');
1766 else if (rate == 50)
tag =
MKTAG(
'a',
'i',
'1',
'5');
1767 else if (rate == 60)
tag =
MKTAG(
'a',
'i',
'1',
'6');
1789 static const struct {
1837 if (
tag ==
MKTAG(
'r',
'a',
'w',
' ') &&
1841 av_log(
s,
AV_LOG_ERROR,
"%s rawvideo cannot be written to mov, output file will be unreadable\n",
1880 "the file may be unplayable!\n");
1887 tag =
MKTAG(
'm',
's', ((ms_tag >> 8) & 0xff), (ms_tag & 0xff));
1889 "the file may be unplayable!\n");
1914 for (
i = 0; tags && tags[
i];
i++) {
1919 return codec_tags->
tag;
1936 "Quicktime/Ipod might not play the file\n");
1962 0x0000, 0x0100, 0x0201, 0x0206, 0x0209, 0x020e
1967 unsigned mov_field_order = 0;
1969 mov_field_order =
fiel_data[field_order];
2007 "Unknown codec tag '%s' utilized for TTML stream with "
2008 "index %d (track id %d)!\n",
2027 if (stereo_3d->
flags != 0) {
2032 switch (stereo_3d->
type) {
2055 int64_t sv3d_pos, svhd_pos, proj_pos;
2165 gama = (uint32_t)
lrint((
double)(1<<16) * gamma);
2196 return 12 + sd->
size;
2254 const int chroma_den = 50000;
2255 const int luma_den = 10000;
2285 const int illuminance_den = 10000;
2286 const int ambient_den = 50000;
2329 }
else if(track->
par->
width == 1440) {
2348 uint8_t ccstValue = (0 << 7) |
2365 avio_write(pb,
"urn:mpeg:mpegB:cicp:systems:auxiliary:alpha\0", 44);
2373 char compressor_name[32] = { 0 };
2393 if (uncompressed_ycbcr) {
2419 avio_w8(pb, strlen(compressor_name));
2440 for (
i = 0;
i < pal_size;
i++) {
2442 uint16_t
r = (
rgb >> 16) & 0xff;
2443 uint16_t
g = (
rgb >> 8) & 0xff;
2444 uint16_t
b =
rgb & 0xff;
2453 if (track->
tag ==
MKTAG(
'm',
'p',
'4',
'v'))
2488 }
else if (track->
vos_len > 0)
2539 if (spherical_mapping)
2549 if (uncompressed_ycbcr){
2597 uint64_t str_size =strlen(reel_name);
2600 if (str_size >= UINT16_MAX){
2630 if (nb_frames > 255) {
2706 uint32_t entries = 0;
2713 ctts_entries[0].
count = 1;
2715 for (
i = 1;
i < track->
entry;
i++) {
2717 ctts_entries[entries].
count++;
2721 ctts_entries[entries].
count = 1;
2725 atom_size = 16 + (entries * 8);
2734 for (
i = 0;
i < entries;
i++) {
2746 uint32_t entries = -1;
2751 stts_entries =
av_malloc(
sizeof(*stts_entries));
2763 for (
i = 0;
i < track->
entry;
i++) {
2766 stts_entries[entries].
count++;
2770 stts_entries[entries].
count = 1;
2775 atom_size = 16 + (entries * 8);
2780 for (
i = 0;
i < entries;
i++) {
2807 int16_t roll_distance;
2808 int group_description_index;
2811 struct sgpd_entry *sgpd_entries =
NULL;
2831 for (
i = 0;
i < track->
entry;
i++) {
2832 int roll_samples_remaining = roll_samples;
2834 for (j =
i - 1; j >= 0; j--) {
2837 if (roll_samples_remaining <= 0)
2843 if (roll_samples_remaining > 0)
2848 if (
i &&
distance == sgpd_entries[entries].roll_distance) {
2849 sgpd_entries[entries].count++;
2852 sgpd_entries[entries].count = 1;
2853 sgpd_entries[entries].roll_distance =
distance;
2854 sgpd_entries[entries].group_description_index =
distance ? ++group : 0;
2860 sgpd_entries[entries].roll_distance = 1;
2861 sgpd_entries[entries].group_description_index = ++group;
2877 for (
i = 0;
i < entries;
i++) {
2878 if (sgpd_entries[
i].group_description_index) {
2879 avio_wb16(pb, -sgpd_entries[
i].roll_distance);
2889 for (
i = 0;
i < entries;
i++) {
2891 avio_wb32(pb, sgpd_entries[
i].group_description_index);
2964 const char *font =
"Lucida Grande";
3004 if (track->
tag !=
MKTAG(
'c',
'6',
'0',
'8')) {
3056 return track->
tag ==
MKTAG(
'c',
'7',
'0',
'8') ||
3057 track->
tag ==
MKTAG(
'c',
'6',
'0',
'8');
3063 const char *hdlr, *descr =
NULL, *hdlr_type =
NULL;
3069 descr =
"DataHandler";
3072 hdlr = (track->
mode ==
MODE_MOV) ?
"mhlr" :
"\0\0\0\0";
3075 hdlr_type = (track == &mov->
tracks[0]) ?
"pict" :
"auxv";
3076 descr =
"PictureHandler";
3079 descr =
"VideoHandler";
3083 descr =
"SoundHandler";
3087 descr =
"ClosedCaptionHandler";
3089 if (track->
tag ==
MKTAG(
't',
'x',
'3',
'g')) {
3091 }
else if (track->
tag ==
MKTAG(
'm',
'p',
'4',
's')) {
3098 descr =
"SubtitleHandler";
3102 descr =
"HintHandler";
3105 descr =
"TimeCodeHandler";
3108 descr =
"GoPro MET";
3111 "Unknown hdlr_type for %s, writing dummy values\n",
3136 descr_len = strlen(descr);
3229 avio_wb32(pb,
s->streams[stream_index]->codecpar->width);
3230 avio_wb32(pb,
s->streams[stream_index]->codecpar->height);
3335 }
else if (track->
tag ==
MKTAG(
'r',
't',
'p',
' ')) {
3337 }
else if (track->
tag ==
MKTAG(
't',
'm',
'c',
'd')) {
3342 }
else if (track->
tag ==
MKTAG(
'g',
'p',
'm',
'd')) {
3428 else if (!track->
entry)
3437 "FATAL error, file duration too long for timebase, this file will not be\n"
3438 "playable with QuickTime. Choose a different timebase with "
3439 "-video_track_timescale or a different container format\n");
3465 int16_t
d, int16_t tx, int16_t ty)
3488 uint32_t *display_matrix =
NULL;
3507 if (sd && sd->
size == 9 *
sizeof(*display_matrix))
3508 display_matrix = (uint32_t *)sd->
data;
3531 else if (!track->
entry)
3548 if (display_matrix) {
3549 for (
i = 0;
i < 9;
i++)
3559 track_width_1616 = track->
par->
width * 0x10000ULL;
3564 if (!track_width_1616 ||
3566 track_width_1616 > UINT32_MAX)
3567 track_width_1616 = track->
par->
width * 0x10000ULL;
3569 if (track_width_1616 > UINT32_MAX) {
3571 track_width_1616 = 0;
3574 if (track->
height > 0xFFFF) {
3628 int entry_size, entry_count,
size;
3637 "EDTS using dts:%"PRId64
" cts:%d instead of dts:%"PRId64
" cts:%"PRId64
" tid:%d\n",
3639 start_dts, start_ct, track->
track_id);
3658 version |= delay < INT32_MAX ? 0 : 1;
3660 entry_size = (
version == 1) ? 20 : 12;
3661 entry_count = 1 + (delay > 0);
3662 size = 24 + entry_count * entry_size;
3693 start_ct = -
FFMIN(start_dts, 0);
3751 char buf[1000] =
"";
3770 const char *
tag,
const char *str)
3795 avio_write(pb, (
const unsigned char *)scheme_uri,
3796 strlen(scheme_uri));
3816 for (
int j = 0;
map.value_maps[j].disposition; j++) {
3865 int entry_backup = track->
entry;
3885 "Not writing any edit list even though one would have been required\n");
3898 if (track->
tag ==
MKTAG(
'r',
't',
'p',
' '))
3912 track->
entry = entry_backup;
3919 int i, has_audio = 0, has_video = 0;
3929 if (audio_profile < 0)
3930 audio_profile = 0xFF - has_audio;
3931 if (video_profile < 0)
3932 video_profile = 0xFF - has_video;
3972 int max_track_id = 1,
i;
3984 if (max_track_len < max_track_len_temp)
3985 max_track_len = max_track_len_temp;
3986 if (max_track_id < mov->tracks[
i].track_id)
4053 size_t data_len = strlen(
data);
4055 int size = 16 + data_len;
4068 return data_len + 4;
4073 const char *
value,
int lang,
int long_style)
4087 const char *
tag,
int *lang)
4101 len2 = strlen(
t2->key);
4102 if (len2 ==
len + 4 && !strcmp(t->
value,
t2->value)
4112 const char *
name,
const char *
tag,
4126 int size = 0, tmpo = t ? atoi(t->
value) : 0;
4145 double latitude, longitude, altitude;
4146 int32_t latitude_fix, longitude_fix, altitude_fix;
4148 const char *ptr, *place =
"";
4150 static const char *astronomical_body =
"earth";
4155 latitude =
strtod(ptr, &end);
4161 longitude =
strtod(ptr, &end);
4167 altitude =
strtod(ptr, &end);
4172 latitude_fix = (
int32_t) ((1 << 16) * latitude);
4173 longitude_fix = (
int32_t) ((1 << 16) * longitude);
4174 altitude_fix = (
int32_t) ((1 << 16) * altitude);
4185 avio_write(pb, astronomical_body, strlen(astronomical_body) + 1);
4196 disc ?
"disc" :
"track",
4198 int size = 0, track = t ? atoi(t->
value) : 0;
4201 char *slash = strchr(t->
value,
'/');
4203 tracks = atoi(slash + 1);
4220 const char *
name,
const char *
tag,
4227 if (
len != 1 &&
len != 4)
4232 num = atoi(t->
value);
4343 size_t key_len = strlen(t->
key);
4411 const char *
name,
const char *
key)
4443 return (((str[0] - 0x60) & 0x1F) << 10) +
4444 (((str[1] - 0x60) & 0x1F) << 5) +
4445 (( str[2] - 0x60) & 0x1F);
4449 const char *
tag,
const char *str)
4458 if (!strcmp(
tag,
"yrrc"))
4463 if (!strcmp(
tag,
"albm") &&
4473 int i, nb_chapters =
FFMIN(
s->nb_chapters, 255);
4481 for (
i = 0;
i < nb_chapters;
i++) {
4555 const char *str,
const char *lang,
int type)
4609 uint64_t chunkSize = chunk->
size;
4622 chunkSize = chunk->
size;
4648 int next_generated_track_id = 0;
4651 if (st->
id > next_generated_track_id)
4652 next_generated_track_id = st->
id;
4702 if (track->
tag ==
MKTAG(
'r',
't',
'p',
' ')) {
4709 if (sd && sd->
size ==
sizeof(
int)) {
4710 int *fallback = (
int *)sd->
data;
4711 if (*fallback >= 0 && *fallback < mov->nb_tracks) {
4767 avio_printf(pb,
"<param name=\"%s\" value=\"%s\" valuetype=\"data\"/>\n",
name, buf);
4775 static const AVUUID uuid = {
4776 0xa5, 0xd4, 0x0b, 0x30, 0xe8, 0x14, 0x11, 0xdd,
4777 0xba, 0x2f, 0x08, 0x00, 0x20, 0x0c, 0x9a, 0x66
4785 avio_printf(pb,
"<?xml version=\"1.0\" encoding=\"utf-8\"?>\n");
4786 avio_printf(pb,
"<smil xmlns=\"http://www.w3.org/2001/SMIL20/Language\">\n");
4789 avio_printf(pb,
"<meta name=\"creator\" content=\"%s\" />\n",
4803 char track_name_buf[32] = { 0 };
4827 av_strlcatf(track_name_buf,
sizeof(track_name_buf),
4828 "_%s", lang->
value);
4832 av_strlcat(track_name_buf,
"_cc",
sizeof(track_name_buf));
4834 av_strlcat(track_name_buf,
"_ad",
sizeof(track_name_buf));
4915 if (!track->
entry) {
4962 if (track->
entry > 1)
5034 static const uint8_t uuid[] = {
5035 0x6d, 0x1d, 0x9b, 0x05, 0x42, 0xd5, 0x44, 0xe6,
5036 0x80, 0xe2, 0x14, 0x1d, 0xaf, 0xf7, 0x57, 0xb2
5055 int size = 8 + 16 + 4 + 1 + 16*n;
5056 static const uint8_t uuid[] = {
5057 0xd4, 0x80, 0x7e, 0xf2, 0xca, 0x39, 0x46, 0x95,
5058 0x8e, 0x54, 0x26, 0xcb, 0x9e, 0x46, 0xa7, 0x9f
5071 for (
i = 0;
i < n;
i++) {
5076 if (n < mov->ism_lookahead) {
5107 if ((tracks >= 0 &&
i != tracks) || !track->
entry)
5129 if (
info->time < 0) {
5133 info->tfrf_offset = 0;
5144 if ((tracks >= 0 &&
i != tracks) || !track->
entry)
5177 for (
i = 1;
i < track->
entry;
i++) {
5192 if (!
info->tfrf_offset)
5205 int tracks,
int moof_size)
5217 if (tracks >= 0 &&
i != tracks)
5228 MOVTrack *track,
int ref_size,
int total_sidx_size)
5232 unsigned starts_with_SAP;
5244 if (presentation_time < 0) {
5246 presentation_time = 0;
5254 if (presentation_time > 0)
5270 for (
i = 0;
i < entries;
i++) {
5271 if (!track->
entry) {
5277 starts_with_SAP = 1;
5279 avio_wb32(pb, (0 << 31) | (ref_size & 0x7fffffff));
5281 avio_wb32(pb, (starts_with_SAP << 31) | (0 << 28) | 0);
5285 offset =
pos + total_sidx_size - end_pos;
5293 int tracks,
int ref_size)
5311 if (tracks >= 0 &&
i != tracks)
5316 if (!track->
entry && ref_size > 0)
5337 first_track = &(mov->
tracks[0]);
5339 if (!first_track->
entry) {
5483 int has_h264,
int has_video,
int write_minor)
5492 minor = has_h264 ? 0x100 : 0x200;
5498 minor = has_h264 ? 0x20000 : 0x10000;
5527 int has_h264 = 0, has_av1 = 0, has_video = 0, has_dolby = 0;
5530 for (
int i = 0;
i <
s->nb_stream_groups;
i++) {
5573 const int depth = pix_fmt_desc->
comp[0].
depth;
5583 if (depth == 8 || depth == 10) {
5647 int audio_kbitrate = audio_par->
bit_rate / 1000;
5648 int video_kbitrate =
FFMIN(video_par->
bit_rate / 1000, 800 - audio_kbitrate);
5650 if (frame_rate < 0 || frame_rate > INT32_MAX) {
5651 av_log(
s,
AV_LOG_ERROR,
"Frame rate %f outside supported range\n", frame_rate / (
double)0x10000);
5716 int video_streams_nb = 0, audio_streams_nb = 0, other_streams_nb = 0;
5729 if (video_streams_nb != 1 || audio_streams_nb != 1 || other_streams_nb) {
5741 int i, closed_gop = 0;
5746 closed_gop =
pkt->
data[
i + 4] >> 6 & 0x01;
5747 }
else if (
c == 0x100) {
5749 if (!temp_ref || closed_gop)
5762 int seq = 0,
entry = 0;
5765 for (next = start; next < end; start = next) {
5827 if (length < 8 || length >
pkt->
size)
5879 if (!had_packets && squashed_packet->
duration == 0) {
5912 "Failed to write squashed packet for %s stream with "
5913 "index %d and track id %d. Error: %s\n",
5928 int i, first_track = -1;
5931 int has_video = 0, starts_with_key = 0, first_video_track = 1;
5968 if (track->
entry <= 1)
5986 "Estimating the duration of the last packet in a "
5987 "fragment, consider setting the duration field in "
5988 "AVPacket instead.\n");
5996 int buf_size, moov_size;
6002 if (i < mov->nb_tracks && !force)
6063 if (first_video_track) {
6066 first_video_track = 0;
6073 if (first_track < 0)
6086 int buf_size, write_moof = 1, moof_tracks = -1;
6095 write_moof =
i == first_track;
6189 unsigned int samples_in_chunk = 0;
6192 uint8_t *reformatted_data =
NULL;
6236 static const uint16_t packed_size[16] =
6237 {13, 14, 16, 18, 20, 21, 27, 32, 6, 0, 0, 0, 0, 0, 0, 1};
6240 while (
len <
size && samples_in_chunk < 100) {
6244 if (samples_in_chunk > 1) {
6245 av_log(
s,
AV_LOG_ERROR,
"fatal error, input is not a single packet, implement a AVParser for it\n");
6254 samples_in_chunk = 1;
6256 if (samples_in_chunk < 1) {
6298 "use the audio bitstream filter 'aac_adtstoasc' to fix it "
6299 "('-bsf:a aac_adtstoasc' option with ffmpeg)\n");
6397 int nal_size_length = (par->
extradata[4] & 0x3) + 1;
6400 int nal_size_length = (par->
extradata[21] & 0x3) + 1;
6485 "Track %d starts with a nonzero dts %"PRId64
", while the moov "
6486 "already has been written. Set the delay_moov flag to handle "
6544 reformatted_data ? reformatted_data +
offset
6550 if (
pkt->
data != reformatted_data)
6591 memcpy(par->
extradata, side, side_size);
6649 uint8_t
data[2] = {0};
6734 "for stream #%d\n", trk->
st->
index);
6803 "Packets without a valid presentation timestamp are "
6804 "not supported with packet squashing!\n");
6821 int reshuffle_ret,
ret;
6824 int expected_stride = ((trk->
par->
width * bpc + 15) >> 4)*2;
6826 if (reshuffle_ret < 0)
6827 return reshuffle_ret;
6845 if (reshuffle_ret) {
6862 static const uint8_t stub_header[] = {
6864 0x00, 0x00, 0x00, 0x01,
6866 0x00, 0x00, 0x00, 0x00,
6868 0x00, 0x00, 0x00, 0x00,
6869 0x00, 0x00, 0x00, 0x00,
6871 0x00, 0x00, 0x00, 0x00,
6874 0x00, 0x00, 0x00, 0x00,
6876 0x00, 0x00, 0x00, 0x0D,
6890 track->
tag =
MKTAG(
't',
'e',
'x',
't');
6899 memcpy(track->
par->
extradata, stub_header,
sizeof(stub_header));
6904 for (
i = 0;
i <
s->nb_chapters;
i++) {
6913 static const char encd[12] = {
6914 0x00, 0x00, 0x00, 0x0C,
6916 0x00, 0x00, 0x01, 0x00 };
6926 memcpy(
pkt->
data +
len + 2, encd,
sizeof(encd));
6959 track->
tag =
MKTAG(
't',
'm',
'c',
'd');
7034 if (!enabled[
i] &&
first[
i] >= 0)
7045 for (
int i = 0;
i <
s->nb_streams;
i++)
7046 s->streams[
i]->priv_data =
NULL;
7058 if (track->
tag ==
MKTAG(
'r',
't',
'p',
' '))
7094 r = (
rgb >> 16) & 0xFF;
7095 g = (
rgb >> 8) & 0xFF;
7102 return (y << 16) | (
cr << 8) |
cb;
7109 int have_palette = 0, have_size = 0;
7110 uint32_t palette[16];
7113 while (cur && *cur) {
7114 if (strncmp(
"palette:", cur, 8) == 0) {
7116 count = sscanf(cur + 8,
7117 "%06"PRIx32
", %06"PRIx32
", %06"PRIx32
", %06"PRIx32
", "
7118 "%06"PRIx32
", %06"PRIx32
", %06"PRIx32
", %06"PRIx32
", "
7119 "%06"PRIx32
", %06"PRIx32
", %06"PRIx32
", %06"PRIx32
", "
7120 "%06"PRIx32
", %06"PRIx32
", %06"PRIx32
", %06"PRIx32
"",
7121 &palette[ 0], &palette[ 1], &palette[ 2], &palette[ 3],
7122 &palette[ 4], &palette[ 5], &palette[ 6], &palette[ 7],
7123 &palette[ 8], &palette[ 9], &palette[10], &palette[11],
7124 &palette[12], &palette[13], &palette[14], &palette[15]);
7126 for (
i = 0;
i < count;
i++) {
7130 }
else if (!strncmp(
"size:", cur, 5)) {
7134 if (have_palette && have_size)
7136 cur += strcspn(cur,
"\n\r");
7137 cur += strspn(cur,
"\n\r");
7143 for (
i = 0;
i < 16;
i++) {
7160 int first_iamf_idx = INT_MAX, last_iamf_idx = 0;
7161 int nb_audio_elements = 0, nb_mix_presentations = 0;
7164 for (
int i = 0;
i <
s->nb_stream_groups;
i++) {
7168 nb_audio_elements++;
7170 nb_mix_presentations++;
7173 if (!nb_audio_elements && !nb_mix_presentations)
7176 if (nb_audio_elements < 1 || nb_audio_elements > 2 || nb_mix_presentations < 1) {
7178 "one IAMF_MIX_PRESENTATION stream groups to write a IMAF track\n");
7187 for (
int i = 0;
i <
s->nb_stream_groups;
i++) {
7208 track = &mov->
tracks[first_iamf_idx];
7212 track->
tag =
MKTAG(
'i',
'a',
'm',
'f');
7214 for (
int i = 0;
i <
s->nb_stream_groups;
i++) {
7241 #define IS_MODE(muxer, config) (CONFIG_ ## config ## _MUXER && !strcmp(#muxer, s->oformat->name))
7310 av_log(
s,
AV_LOG_WARNING,
"No meaningful edit list will be written when using empty_moov without delay_moov\n");
7330 "Sample interleaving in fragments is mutually exclusive with "
7331 "omit_tfhd_offset and separate_moof\n");
7347 if (
s->nb_streams > 2) {
7356 if (
s->nb_streams > 1) {
7360 av_log(
s,
AV_LOG_ERROR,
"Second stream for AVIF (alpha) output must have exactly one plane\n");
7367 for (
i = 0;
i <
s->nb_stream_groups;
i++) {
7378 "IAMF Audio Element\n", j);
7389 for (
i = 0;
i <
s->nb_streams;
i++) {
7403 for (
i = 0;
i <
s->nb_streams;
i++)
7418 for (
i = 0;
i <
s->nb_streams;
i++) {
7432 for (
i = 0;
i <
s->nb_streams;
i++) {
7436 "so timecode metadata are now ignored\n");
7477 for (
int j = 0,
i = 0; j <
s->nb_streams; j++) {
7488 for (
i = 0;
i <
s->nb_streams;
i++) {
7505 "codec not currently supported in container\n",
7517 if (track->
tag ==
MKTAG(
'm',
'x',
'3',
'p') || track->
tag ==
MKTAG(
'm',
'x',
'3',
'n') ||
7518 track->
tag ==
MKTAG(
'm',
'x',
'4',
'p') || track->
tag ==
MKTAG(
'm',
'x',
'4',
'n') ||
7519 track->
tag ==
MKTAG(
'm',
'x',
'5',
'p') || track->
tag ==
MKTAG(
'm',
'x',
'5',
'n')) {
7524 track->
height = track->
tag >> 24 ==
'n' ? 486 : 576;
7529 av_log(
s,
AV_LOG_WARNING,
"Warning: some tools, like mp4split, assume a timescale of 10000000 for ISMV.\n");
7541 "WARNING codec timebase is very high. If duration is too long,\n"
7542 "file may not be playable by quicktime. Specify a shorter timebase\n"
7543 "or choose different container.\n");
7546 track->
tag ==
MKTAG(
'r',
'a',
'w',
' ')) {
7602 av_log(
s,
AV_LOG_ERROR,
"track %d: muxing mp3 at %dhz is not standard, to mux anyway set strict to -1\n",
7620 "%s in MP4 support is experimental, add "
7621 "'-strict %d' if you want to use it.\n",
7642 "Fragmentation is not currently supported for "
7643 "TTML in MP4/ISMV (track synchronization between "
7644 "subtitles and other media is not yet implemented)!\n");
7652 "ISMV style TTML support with the 'dfxp' tag in "
7653 "non-ISMV formats is not officially supported. Add "
7654 "'-strict unofficial' if you want to use it.\n");
7694 int ret, hint_track = 0, tmcd_track = 0, nb_tracks = mov->
nb_streams;
7700 hint_track = nb_tracks;
7708 tmcd_track = nb_tracks;
7758 trackj->
tag != track->
tag
7791 mov->
time += 0x7C25B080;
7809 "timecode",
NULL, 0);
7880 int i, moov_size, moov_size2;
7896 if (moov_size2 != moov_size)
8005 av_log(
s,
AV_LOG_INFO,
"Starting second pass: moving the moov atom to the beginning of the file\n");
8071 #if CONFIG_AVIF_MUXER
8076 int64_t pos_backup, extent_offsets[2];
8078 int buf_size, moov_size;
8116 if (extent_offsets[
i] != (uint32_t)extent_offsets[
i]) {
8129 #if CONFIG_TGP_MUXER || CONFIG_TG2_MUXER
8140 static const AVCodecTag *
const codec_3gp_tags_list[] = { codec_3gp_tags,
NULL };
8199 #if CONFIG_MP4_MUXER || CONFIG_PSP_MUXER
8229 #if CONFIG_AVIF_MUXER
8231 static const AVOption avif_options[] = {
8233 {
"loop",
"Number of times to loop animated AVIF: 0 - infinite loop", offsetof(
MOVMuxContext, avif_loop_count),
AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX,
AV_OPT_FLAG_ENCODING_PARAM, .unit = 0 },
8236 static const AVCodecTag codec_avif_tags[] = {
8240 static const AVCodecTag *
const codec_avif_tags_list[] = { codec_avif_tags,
NULL };
8242 static const AVClass mov_avif_muxer_class = {
8245 .option = avif_options,
8250 #if CONFIG_MOV_MUXER
8254 .p.extensions =
"mov",
8257 .p.video_codec = CONFIG_LIBX264_ENCODER ?
8277 #if CONFIG_TGP_MUXER
8281 .p.extensions =
"3gp",
8295 .p.codec_tag = codec_3gp_tags_list,
8301 #if CONFIG_MP4_MUXER
8305 .p.mime_type =
"video/mp4",
8306 .p.extensions =
"mp4",
8309 .p.video_codec = CONFIG_LIBX264_ENCODER ?
8321 .p.codec_tag = mp4_codec_tags_list,
8327 #if CONFIG_PSP_MUXER
8331 .p.extensions =
"mp4,psp",
8334 .p.video_codec = CONFIG_LIBX264_ENCODER ?
8346 .p.codec_tag = mp4_codec_tags_list,
8352 #if CONFIG_TG2_MUXER
8356 .p.extensions =
"3g2",
8370 .p.codec_tag = codec_3gp_tags_list,
8376 #if CONFIG_IPOD_MUXER
8380 .p.mime_type =
"video/mp4",
8381 .p.extensions =
"m4v,m4a,m4b",
8401 #if CONFIG_ISMV_MUXER
8405 .p.mime_type =
"video/mp4",
8406 .p.extensions =
"ismv,isma",
8427 #if CONFIG_F4V_MUXER
8431 .p.mime_type =
"application/f4v",
8432 .p.extensions =
"f4v",
8452 #if CONFIG_AVIF_MUXER
8456 .p.mime_type =
"image/avif",
8457 .p.extensions =
"avif",
8463 .write_trailer = avif_write_trailer,
8470 .p.codec_tag = codec_avif_tags_list,
8471 .p.priv_class = &mov_avif_muxer_class,
static void get_pts_range(MOVMuxContext *mov, MOVTrack *track, int64_t *start, int64_t *end)
static 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)
@ AV_PKT_DATA_DISPLAYMATRIX
This side data contains a 3x3 transformation matrix describing an affine transformation that needs to...
@ AV_ROUND_UP
Round toward +infinity.
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
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
int avpriv_packet_list_put(PacketList *packet_buffer, AVPacket *pkt, int(*copy)(AVPacket *dst, const AVPacket *src), int flags)
Append an AVPacket to the list.
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)
@ AV_PKT_DATA_AMBIENT_VIEWING_ENVIRONMENT
Ambient viewing environment metadata, as defined by H.274.
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 int mov_write_track_kinds(AVIOContext *pb, AVStream *st)
unsigned int squash_fragment_samples_to_one
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)
uint8_t AVUUID[AV_UUID_LEN]
static int put_bytes_output(const PutBitContext *s)
static double cb(void *priv, double x, double y)
uint32_t buffer_size
Size of the decoding buffer for the elementary stream in bytes.
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)
Ambient viewing environment metadata as defined by H.274.
static uint32_t get_sample_flags(MOVTrack *track, MOVIentry *entry)
enum AVColorSpace color_space
double strtod(const char *, char **)
@ 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 int mov_write_track_udta_tag(AVIOContext *pb, MOVMuxContext *mov, AVStream *st)
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
#define FF_MOV_FLAG_SKIP_TRAILER
static int mov_write_gama_tag(AVFormatContext *s, AVIOContext *pb, MOVTrack *track, double gamma)
@ AV_PKT_DATA_MASTERING_DISPLAY_METADATA
Mastering display metadata (based on SMPTE-2086:2014).
#define IS_MODE(muxer, config)
#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 ff_vvc_annexb2mp4(AVIOContext *pb, const uint8_t *buf_in, int size, int filter_ps, int *ps_count)
Writes Annex B formatted H.266/VVC NAL units to the provided AVIOContext.
int min_fragment_duration
int avif_extent_length[2]
unsigned MaxCLL
Max content light level (cd/m^2).
int ff_isom_write_vvcc(AVIOContext *pb, const uint8_t *data, int size, int ps_array_completeness)
Writes H.266/VVC extradata (parameter sets, declarative SEI NAL units) to the provided AVIOContext.
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.
This structure stores auxiliary information for decoding, presenting, or otherwise processing the cod...
@ AVCOL_RANGE_JPEG
Full range content.
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)
int depth
Number of bits in the component.
static int mov_init(AVFormatContext *s)
AVRational ambient_light_x
Normalized x chromaticity coordinate of the environmental ambient light in the nominal viewing enviro...
#define MOV_FRAG_INFO_ALLOC_INCREMENT
@ AV_PKT_DATA_FALLBACK_TRACK
This side data contains an integer value representing the stream index of a "fallback" track.
static void enable_tracks(AVFormatContext *s)
static int mov_write_ccst_tag(AVIOContext *pb)
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)
static int mov_write_aux_tag(AVIOContext *pb, const char *aux_type)
unsigned int ff_toupper4(unsigned int x)
int ff_parse_creation_time_metadata(AVFormatContext *s, int64_t *timestamp, int return_seconds)
Parse creation_time in AVFormatContext metadata if exists and warn if the parsing fails.
#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).
@ 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
#define FF_COMPLIANCE_EXPERIMENTAL
Allow nonstandardized experimental things.
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.
static const uint16_t fiel_data[]
int ff_mov_init_hinting(AVFormatContext *s, int index, int src_index)
int nb_channels
Number of channels in this layout.
int ff_mov_get_channel_layout_tag(const AVCodecParameters *par, uint32_t *layout, uint32_t *bitmap, uint32_t **pchannel_desc)
Get the channel layout tag for the specified codec id and channel layout.
@ 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.
@ 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)
static int mov_write_chnl_tag(AVFormatContext *s, AVIOContext *pb, MOVTrack *track)
#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.
@ AV_CODEC_ID_MPEGH_3D_AUDIO
Content light level needed by to transmit HDR over HDMI (CTA-861.3).
@ AV_PKT_DATA_DOVI_CONF
DOVI configuration ref: dolby-vision-bitstreams-within-the-iso-base-media-file-format-v2....
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)
static int mov_write_pcmc_tag(AVFormatContext *s, AVIOContext *pb, MOVTrack *track)
@ AV_OPT_TYPE_BINARY
offset must point to a pointer immediately followed by an int for the length
static int64_t calc_samples_pts_duration(MOVMuxContext *mov, MOVTrack *track)
#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_write_evcc_tag(AVIOContext *pb, MOVTrack *track)
static int mov_get_rawvideo_codec_tag(AVFormatContext *s, MOVTrack *track)
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)
@ EAC3_FRAME_TYPE_DEPENDENT
#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.
#define FF_MOV_FLAG_USE_MDTA
@ AV_CODEC_ID_MP3
preferred ID for decoding MPEG audio layer 1, 2 or 3
static int mov_write_iref_tag(AVIOContext *pb, MOVMuxContext *mov, AVFormatContext *s)
AVRational ambient_illuminance
Environmental illuminance of the ambient viewing environment in lux.
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
static int handle_eac3(MOVMuxContext *mov, AVPacket *pkt, MOVTrack *track)
void ff_mov_cenc_free(MOVMuxCencContext *ctx)
Free a CENC context.
int ff_isom_write_evcc(AVIOContext *pb, const uint8_t *data, int size, int ps_array_completeness)
Writes EVC sample metadata to the provided AVIOContext.
static void mov_prune_frag_info(MOVMuxContext *mov, int tracks, int max)
int av_get_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
#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_ARRAY_ELEMS(a)
struct eac3_info::@331 substream[1]
#define AV_PROFILE_UNKNOWN
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
PacketList squashed_packet_queue
int frame_size
Audio only.
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
int avio_open_dyn_buf(AVIOContext **s)
Open a write only memory stream.
int av_channel_layout_describe(const AVChannelLayout *channel_layout, char *buf, size_t buf_size)
Get a human-readable string describing the channel layout properties.
int chapter_track
qt chapter track number
#define FF_MOV_FLAG_FRAGMENT
int ff_iamf_add_audio_element(IAMFContext *iamf, const AVStreamGroup *stg, void *log_ctx)
#define MOV_TFHD_DEFAULT_BASE_IS_MOOF
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)
int flags
Flags modifying the (de)muxer behaviour.
AVRational sample_aspect_ratio
Video only.
#define FF_MOV_FLAG_DELAY_MOOV
static int mov_write_ac3_tag(AVFormatContext *s, AVIOContext *pb, MOVTrack *track)
uint32_t bound_top
Distance from the top edge.
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 av_assert0(cond)
assert() equivalent, that is always enabled.
@ EAC3_FRAME_TYPE_INDEPENDENT
static int mov_write_trkn_tag(AVIOContext *pb, MOVMuxContext *mov, AVFormatContext *s, int disc)
void ff_isom_put_dvcc_dvvc(void *logctx, uint8_t out[ISOM_DVCC_DVVC_SIZE], const AVDOVIDecoderConfigurationRecord *dovi)
#define FF_MOV_FLAG_PREFER_ICC
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
static int mov_write_ipco_tag(AVIOContext *pb, MOVMuxContext *mov, AVFormatContext *s)
static int mov_write_stco_tag(AVIOContext *pb, MOVTrack *track)
static int mov_write_iloc_tag(AVIOContext *pb, MOVMuxContext *mov, AVFormatContext *s)
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_RL16
@ AV_PKT_DATA_STEREO3D
This side data should be associated with a video stream and contains Stereoscopic 3D information in f...
void ffio_write_leb(AVIOContext *s, unsigned val)
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
static const uint8_t channel_map[8][8]
uint8_t log2_chroma_w
Amount to shift the luma width right to find the chroma width.
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
int nb_coded_side_data
Amount of entries in coded_side_data.
@ 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)
static int mov_write_edts_tag(AVIOContext *pb, MOVMuxContext *mov, MOVTrack *track)
This structure describes the bitrate properties of an encoded bitstream.
int ff_format_shift_data(AVFormatContext *s, int64_t read_start, int shift_size)
Make shift_size amount of space at read_start by shifting data in the output at read_start until the ...
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...
int flags
Additional information about the frame packing.
#define FF_MOV_FLAG_RTP_HINT
@ FLAC_METADATA_TYPE_STREAMINFO
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)
int ff_isom_write_vpcc(AVFormatContext *s, AVIOContext *pb, const uint8_t *data, int len, AVCodecParameters *par)
Writes VP codec configuration to the provided AVIOContext.
void avio_flush(AVIOContext *s)
Force flushing of buffered data.
int use_stream_ids_as_track_ids
static const AVClass mov_isobmff_muxer_class
static struct mpeg4_bit_rate_values calculate_mpeg4_bit_rates(MOVTrack *track)
static const AVOption options[]
AVBufferRef * buf
A reference to the reference-counted buffer where the packet data is stored.
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
#define LIBAVUTIL_VERSION_INT
Describe the class of an AVClass context structure.
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
static int mov_write_pitm_tag(AVIOContext *pb, int item_id)
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it.
static int mov_pcm_be_gt16(enum AVCodecID codec_id)
void avcodec_parameters_free(AVCodecParameters **ppar)
Free an AVCodecParameters instance and everything associated with it and write NULL to the supplied p...
uint8_t nb_components
The number of components each pixel has, (1-4)
static int mov_check_timecode_track(AVFormatContext *s, AVTimecode *tc, AVStream *src_st, const char *tcstr)
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)
@ 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)
static int check_pkt(AVFormatContext *s, MOVTrack *trk, AVPacket *pkt)
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.
static int mov_write_squashed_packets(AVFormatContext *s)
#define ROUNDED_DIV(a, b)
@ AV_CODEC_ID_DVD_SUBTITLE
const char * av_default_item_name(void *ptr)
Return the context name.
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 ff_iamf_add_mix_presentation(IAMFContext *iamf, const AVStreamGroup *stg, void *log_ctx)
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)
static int mov_write_amve_tag(AVIOContext *pb, MOVTrack *track)
int ff_mov_get_channel_positions_from_layout(const AVChannelLayout *layout, uint8_t *position, int position_num)
Get ISO/IEC 23001-8 OutputChannelPosition from AVChannelLayout.
const AVCodecTag ff_codec_movvideo_tags[]
#define AV_PIX_FMT_YUV422P10
static int mov_get_lpcm_flags(enum AVCodecID codec_id)
Compute flags for 'lpcm' tag.
void ffio_fill(AVIOContext *s, int b, int64_t count)
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.
AVChannelLayout ch_layout
Audio only.
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)
@ AV_PKT_DATA_CONTENT_LIGHT_LEVEL
Content light level (based on CTA-861.3).
#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)
const AVCodecTag ff_codec_movaudio_tags[]
#define AV_OPT_FLAG_ENCODING_PARAM
A generic parameter which can be set by the user for muxing or encoding.
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)
AVBufferRef * av_buffer_create(uint8_t *data, size_t size, void(*free)(void *opaque, uint8_t *data), void *opaque, int flags)
Create an AVBuffer from an existing array.
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.
const AVPacketSideData * av_packet_side_data_get(const AVPacketSideData *sd, int nb_sd, enum AVPacketSideDataType type)
Get side information from a side data array.
@ AV_PKT_DATA_SPHERICAL
This side data should be associated with a video stream and corresponds to the AVSphericalMapping str...
int extradata_size
Size of the extradata content in bytes.
#define MOV_FRAG_SAMPLE_FLAG_DEPENDS_NO
@ EAC3_FRAME_TYPE_AC3_CONVERT
int ff_mov_get_channel_config_from_layout(const AVChannelLayout *layout, int *config)
Get ISO/IEC 23001-8 ChannelConfiguration from AVChannelLayout.
@ AV_ROUND_DOWN
Round toward -infinity.
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.
int av_get_exact_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
int ff_mov_generate_squashed_ttml_packet(AVFormatContext *s, MOVTrack *track, AVPacket *pkt)
@ 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.
enum AVPixelFormat avpriv_pix_fmt_find(enum PixelFormatTagLists list, unsigned fourcc)
static const AVCodecTag codec_ipod_tags[]
#define FF_OFMT_FLAG_ALLOW_FLUSH
This flag indicates that the muxer stores data internally and supports flushing it.
void avpriv_packet_list_free(PacketList *pkt_buf)
Wipe the list and unref all the packets in it.
int ff_isom_write_avcc(AVIOContext *pb, const uint8_t *data, int len)
An AVChannelLayout holds information about the channel layout of audio data.
uint32_t bound_right
Distance from the right edge.
static int mov_write_dpxe_tag(AVIOContext *pb, MOVTrack *track)
static int mov_write_vvcc_tag(AVIOContext *pb, MOVTrack *track)
#define FF_MOV_FLAG_FASTSTART
uint32_t avg_bit_rate
Average rate in bits/second over the entire presentation.
#define av_err2str(errnum)
Convenience macro, the return value should be used only directly in function arguments but never stan...
int ff_vvc_annexb2mp4_buf(const uint8_t *buf_in, uint8_t **buf_out, int *size, int filter_ps, int *ps_count)
Writes Annex B formatted H.266/VVC NAL units to a data buffer.
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.
int64_t avif_extent_pos[2]
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)
double av_csp_approximate_trc_gamma(enum AVColorTransferCharacteristic trc)
Determine a suitable 'gamma' value to match the supplied AVColorTransferCharacteristic.
#define AV_NOPTS_VALUE
Undefined timestamp value.
static const AVCodecTag codec_mp4_tags[]
int ff_iamf_write_parameter_blocks(const IAMFContext *iamf, AVIOContext *pb, const AVPacket *pkt, void *log_ctx)
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)
#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)
int ff_isom_write_av1c(AVIOContext *pb, const uint8_t *buf, int size, int write_seq_header)
Writes AV1 extradata (Sequence Header and Metadata OBUs) to the provided AVIOContext.
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)
#define FF_COMPLIANCE_NORMAL
uint32_t padding
Number of pixels to pad from the edge of each cube face.
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 an array through a pointer to a pointer.
static int mov_get_evc_codec_tag(AVFormatContext *s, MOVTrack *track)
void avio_wl32(AVIOContext *s, unsigned int val)
static int mov_write_subtitle_tag(AVFormatContext *s, AVIOContext *pb, MOVTrack *track)
@ AV_PKT_DATA_PRFT
Producer Reference Time data corresponding to the AVProducerReferenceTime struct, usually exported by...
static int mov_write_track_kind(AVIOContext *pb, const char *scheme_uri, const char *value)
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
int flags
A combination of AV_PKT_FLAG values.
AVPacket * av_packet_alloc(void)
Allocate an AVPacket and set its fields to default values.
#define FF_COMPLIANCE_UNOFFICIAL
Allow unofficial extensions.
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.
AVStream ** streams
A list of streams in the group.
static int mov_write_meta_tag(AVIOContext *pb, MOVMuxContext *mov, AVFormatContext *s)
#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)
int av_channel_layout_compare(const AVChannelLayout *chl, const AVChannelLayout *chl1)
Check whether two channel layouts are semantically the same, i.e.
static int mov_write_iinf_tag(AVIOContext *pb, MOVMuxContext *mov, AVFormatContext *s)
#define AV_LOG_INFO
Standard information.
static int mov_init_iamf_track(AVFormatContext *s)
static void mov_free(AVFormatContext *s)
#define FF_MOV_FLAG_SKIP_SIDX
struct MOVTrack::@332 vc1_info
@ 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)
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 layout
static int mov_write_covr(AVIOContext *pb, AVFormatContext *s)
AVCodecParameters * avcodec_parameters_alloc(void)
Allocate a new AVCodecParameters and set its fields to default values (unknown/invalid/0).
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 av_always_inline uint64_t av_double2int(double f)
Reinterpret a double as a 64-bit integer.
static int mov_write_iprp_tag(AVIOContext *pb, MOVMuxContext *mov, AVFormatContext *s)
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
static int mov_write_uuidprof_tag(AVIOContext *pb, AVFormatContext *s)
@ AV_PKT_DATA_CPB_PROPERTIES
This side data corresponds to the AVCPBProperties struct.
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...
int ff_mov_write_packet(AVFormatContext *s, AVPacket *pkt)
static av_always_inline av_const double round(double x)
uint8_t * av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type, size_t *size)
Get side information from packet.
static int mov_write_avcc_tag(AVIOContext *pb, MOVTrack *track)
static int mov_write_iacb_tag(AVFormatContext *s, 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_PKT_DATA_ICC_PROFILE
ICC profile data consisting of an opaque octet buffer following the format described by ISO 15076-1.
@ 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 ff_get_packet_palette(AVFormatContext *s, AVPacket *pkt, int ret, uint32_t *palette)
Retrieves the palette from a packet, either from side data, or appended to the video data in the pack...
int avpriv_ac3_parse_header(AC3HeaderInfo **phdr, const uint8_t *buf, size_t size)
#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.
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)
static int mov_check_bitstream(AVFormatContext *s, AVStream *st, const AVPacket *pkt)
#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.
AVPacketSideData * coded_side_data
Additional data associated with the entire stream.
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
void * av_calloc(size_t nmemb, size_t size)
struct IAMFContext * iamf
enum AVFieldOrder field_order
Video only.
static int64_t update_size(AVIOContext *pb, int64_t pos)
int ff_iamf_write_audio_frame(const IAMFContext *iamf, AVIOContext *pb, unsigned audio_substream_id, const AVPacket *pkt)
int ff_iamf_write_descriptors(const IAMFContext *iamf, AVIOContext *pb, void *log_ctx)
@ 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
Stream disposition - a combination of AV_DISPOSITION_* flags.
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.
int id
Format-specific stream ID.
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)
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
static int mov_write_pixi_tag(AVIOContext *pb, MOVMuxContext *mov, AVFormatContext *s, int stream_index)
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 ...
#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.
static const struct @330 mov_pix_fmt_tags[]
struct AVAESCTR * aes_ctr
#define AV_INPUT_BUFFER_PADDING_SIZE
@ AV_PIX_FMT_UYVY422
packed YUV 4:2:2, 16bpp, Cb Y0 Cr Y1
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.
static int mov_write_sthd_tag(AVIOContext *pb)
int index
stream index in AVFormatContext
#define MOV_INDEX_CLUSTER_SIZE
const AVCodecTag ff_codec_bmp_tags[]
#define FF_MOV_FLAG_SEPARATE_MOOF
unsigned int nb_streams
Number of elements in AVStreamGroup.streams.
int ff_avc_write_annexb_extradata(const uint8_t *in, uint8_t **buf, int *size)
#define AV_PROFILE_AAC_HE_V2
int reserved_moov_size
0 for disabled, -1 for automatic, size otherwise
#define ISOM_DVCC_DVVC_SIZE
#define AVIO_SEEKABLE_NORMAL
Seeking works like for a local file.
static int is_cover_image(const AVStream *st)
static uint32_t rgb_to_yuv(uint32_t rgb)
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.
int av_packet_make_writable(AVPacket *pkt)
Create a writable reference for the data described by a given packet, avoiding data copy if possible.
static int mov_write_identification(AVIOContext *pb, AVFormatContext *s)
static int mov_write_sidx_tags(AVIOContext *pb, MOVMuxContext *mov, int tracks, int ref_size)
static int mov_build_iamf_packet(AVFormatContext *s, MOVTrack *trk, AVPacket *pkt)
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)
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
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_btrt_tag(AVIOContext *pb, MOVTrack *track)
static int mov_write_glbl_tag(AVIOContext *pb, MOVTrack *track)
static int mov_mdhd_mvhd_tkhd_version(MOVMuxContext *mov, MOVTrack *track, int64_t duration)
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
static int mov_write_ispe_tag(AVIOContext *pb, MOVMuxContext *mov, AVFormatContext *s, int stream_index)
int ff_reshuffle_raw_rgb(AVFormatContext *s, AVPacket **ppkt, AVCodecParameters *par, int expected_stride)
Reshuffles the lines to use the user specified stride.
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)
enum AVStreamGroupParamsType type
Group type.
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.
AVPacket * pkt
Used to hold temporary packets for the generic demuxing code.
#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)
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
void avio_wb24(AVIOContext *s, unsigned int val)
const VDPAUPixFmtMap * map
#define AV_CHANNEL_LAYOUT_MONO
uint32_t max_bit_rate
Maximum rate in bits/second over any window of one second.
static int mov_write_dvcc_dvvc_tag(AVFormatContext *s, AVIOContext *pb, AVDOVIDecoderConfigurationRecord *dovi)
static int mov_preroll_write_stbl_atoms(AVIOContext *pb, MOVTrack *track)
#define AV_PROFILE_AAC_HE
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 mov_write_ipma_tag(AVIOContext *pb, MOVMuxContext *mov, AVFormatContext *s)
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)
#define MOV_TFHD_DURATION_IS_EMPTY
#define MOV_TRUN_SAMPLE_SIZE
static float distance(float x, float y, int band)
static int mov_write_dops_tag(AVFormatContext *s, AVIOContext *pb, MOVTrack *track)
static int mov_write_squashed_packet(AVFormatContext *s, MOVTrack *track)
void avio_wb16(AVIOContext *s, unsigned int val)
#define flags(name, subs,...)
static int mov_write_hmhd_tag(AVIOContext *pb)
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
static const SheerTable rgb[2]
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)
static int64_t rescale_rational(AVRational q, int b)
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
const struct MP4TrackKindMapping ff_mov_track_kind_table[]
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)
#define MKTAG(a, b, c, d)
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...
AVRational ambient_light_y
Normalized y chromaticity coordinate of the environmental ambient light in the nominal viewing enviro...
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
#define MOV_ISMV_TTML_TAG
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,...
const AVDictionaryEntry * av_dict_iterate(const AVDictionary *m, const AVDictionaryEntry *prev)
Iterate over a dictionary.
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
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)
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