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;
249 int64_t entryPos, curpos;
257 for (
i = 0;
i < track->
entry;
i++) {
277 int64_t curpos, entryPos;
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;
1226 speaker_pos,
layout->nb_channels);
1228 char buf[128] = {0};
1246 for (
int i = 0;
i <
layout->nb_channels;
i++)
1284 uint32_t
tag = track->
tag;
1388 else if (track->
tag ==
MKTAG(
'm',
'p',
'4',
'a'))
1390 else if (track->
tag ==
MKTAG(
'i',
'a',
'm',
'f'))
1414 }
else if (track->
vos_len > 0)
1486 if (track->
tag ==
MKTAG(
'h',
'v',
'c',
'1'))
1500 if (track->
tag ==
MKTAG(
'e',
'v',
'c',
'1'))
1518 if (track->
tag ==
MKTAG(
'v',
'v',
'c',
'1'))
1530 int display_width = track->
par->
width;
1558 if (track->
tag ==
MKTAG(
'A',
'V',
'd',
'h')) {
1634 }
else if (track->
par->
height == 1080) {
1649 if (rational_framerate.
den != 0)
1650 rate =
av_q2d(rational_framerate);
1667 if (rate == 24)
tag =
MKTAG(
'x',
'd',
'v',
'4');
1668 else if (rate == 25)
tag =
MKTAG(
'x',
'd',
'v',
'5');
1669 else if (rate == 30)
tag =
MKTAG(
'x',
'd',
'v',
'1');
1670 else if (rate == 50)
tag =
MKTAG(
'x',
'd',
'v',
'a');
1671 else if (rate == 60)
tag =
MKTAG(
'x',
'd',
'v',
'9');
1675 if (rate == 24)
tag =
MKTAG(
'x',
'd',
'v',
'6');
1676 else if (rate == 25)
tag =
MKTAG(
'x',
'd',
'v',
'7');
1677 else if (rate == 30)
tag =
MKTAG(
'x',
'd',
'v',
'8');
1679 if (rate == 25)
tag =
MKTAG(
'x',
'd',
'v',
'3');
1680 else if (rate == 30)
tag =
MKTAG(
'x',
'd',
'v',
'2');
1684 if (rate == 24)
tag =
MKTAG(
'x',
'd',
'v',
'd');
1685 else if (rate == 25)
tag =
MKTAG(
'x',
'd',
'v',
'e');
1686 else if (rate == 30)
tag =
MKTAG(
'x',
'd',
'v',
'f');
1688 if (rate == 25)
tag =
MKTAG(
'x',
'd',
'v',
'c');
1689 else if (rate == 30)
tag =
MKTAG(
'x',
'd',
'v',
'b');
1695 if (rate == 24)
tag =
MKTAG(
'x',
'd',
'5',
'4');
1696 else if (rate == 25)
tag =
MKTAG(
'x',
'd',
'5',
'5');
1697 else if (rate == 30)
tag =
MKTAG(
'x',
'd',
'5',
'1');
1698 else if (rate == 50)
tag =
MKTAG(
'x',
'd',
'5',
'a');
1699 else if (rate == 60)
tag =
MKTAG(
'x',
'd',
'5',
'9');
1703 if (rate == 24)
tag =
MKTAG(
'x',
'd',
'5',
'd');
1704 else if (rate == 25)
tag =
MKTAG(
'x',
'd',
'5',
'e');
1705 else if (rate == 30)
tag =
MKTAG(
'x',
'd',
'5',
'f');
1707 if (rate == 25)
tag =
MKTAG(
'x',
'd',
'5',
'c');
1708 else if (rate == 30)
tag =
MKTAG(
'x',
'd',
'5',
'b');
1729 if (rate == 24)
tag =
MKTAG(
'a',
'i',
'5',
'p');
1730 else if (rate == 25)
tag =
MKTAG(
'a',
'i',
'5',
'q');
1731 else if (rate == 30)
tag =
MKTAG(
'a',
'i',
'5',
'p');
1732 else if (rate == 50)
tag =
MKTAG(
'a',
'i',
'5',
'q');
1733 else if (rate == 60)
tag =
MKTAG(
'a',
'i',
'5',
'p');
1737 if (rate == 24)
tag =
MKTAG(
'a',
'i',
'5',
'3');
1738 else if (rate == 25)
tag =
MKTAG(
'a',
'i',
'5',
'2');
1739 else if (rate == 30)
tag =
MKTAG(
'a',
'i',
'5',
'3');
1741 if (rate == 50)
tag =
MKTAG(
'a',
'i',
'5',
'5');
1742 else if (rate == 60)
tag =
MKTAG(
'a',
'i',
'5',
'6');
1748 if (rate == 24)
tag =
MKTAG(
'a',
'i',
'1',
'p');
1749 else if (rate == 25)
tag =
MKTAG(
'a',
'i',
'1',
'q');
1750 else if (rate == 30)
tag =
MKTAG(
'a',
'i',
'1',
'p');
1751 else if (rate == 50)
tag =
MKTAG(
'a',
'i',
'1',
'q');
1752 else if (rate == 60)
tag =
MKTAG(
'a',
'i',
'1',
'p');
1756 if (rate == 24)
tag =
MKTAG(
'a',
'i',
'1',
'3');
1757 else if (rate == 25)
tag =
MKTAG(
'a',
'i',
'1',
'2');
1758 else if (rate == 30)
tag =
MKTAG(
'a',
'i',
'1',
'3');
1760 if (rate == 25)
tag =
MKTAG(
'a',
'i',
'1',
'5');
1761 else if (rate == 50)
tag =
MKTAG(
'a',
'i',
'1',
'5');
1762 else if (rate == 60)
tag =
MKTAG(
'a',
'i',
'1',
'6');
1784 static const struct {
1832 if (
tag ==
MKTAG(
'r',
'a',
'w',
' ') &&
1836 av_log(
s,
AV_LOG_ERROR,
"%s rawvideo cannot be written to mov, output file will be unreadable\n",
1875 "the file may be unplayable!\n");
1882 tag =
MKTAG(
'm',
's', ((ms_tag >> 8) & 0xff), (ms_tag & 0xff));
1884 "the file may be unplayable!\n");
1909 for (
i = 0; tags && tags[
i];
i++) {
1914 return codec_tags->
tag;
1931 "Quicktime/Ipod might not play the file\n");
1957 0x0000, 0x0100, 0x0201, 0x0206, 0x0209, 0x020e
1962 unsigned mov_field_order = 0;
1964 mov_field_order =
fiel_data[field_order];
2002 "Unknown codec tag '%s' utilized for TTML stream with "
2003 "index %d (track id %d)!\n",
2022 if (stereo_3d->
flags != 0) {
2027 switch (stereo_3d->
type) {
2050 int64_t sv3d_pos, svhd_pos, proj_pos;
2160 gama = (uint32_t)
lrint((
double)(1<<16) * gamma);
2191 return 12 + sd->
size;
2249 const int chroma_den = 50000;
2250 const int luma_den = 10000;
2280 const int illuminance_den = 10000;
2281 const int ambient_den = 50000;
2324 }
else if(track->
par->
width == 1440) {
2343 uint8_t ccstValue = (0 << 7) |
2360 avio_write(pb,
"urn:mpeg:mpegB:cicp:systems:auxiliary:alpha\0", 44);
2368 char compressor_name[32] = { 0 };
2388 if (uncompressed_ycbcr) {
2414 avio_w8(pb, strlen(compressor_name));
2435 for (
i = 0;
i < pal_size;
i++) {
2437 uint16_t
r = (
rgb >> 16) & 0xff;
2438 uint16_t
g = (
rgb >> 8) & 0xff;
2439 uint16_t
b =
rgb & 0xff;
2448 if (track->
tag ==
MKTAG(
'm',
'p',
'4',
'v'))
2483 }
else if (track->
vos_len > 0)
2534 if (spherical_mapping)
2544 if (uncompressed_ycbcr){
2592 uint64_t str_size =strlen(reel_name);
2595 if (str_size >= UINT16_MAX){
2625 if (nb_frames > 255) {
2701 uint32_t entries = 0;
2708 ctts_entries[0].
count = 1;
2710 for (
i = 1;
i < track->
entry;
i++) {
2712 ctts_entries[entries].
count++;
2716 ctts_entries[entries].
count = 1;
2720 atom_size = 16 + (entries * 8);
2729 for (
i = 0;
i < entries;
i++) {
2741 uint32_t entries = -1;
2746 stts_entries =
av_malloc(
sizeof(*stts_entries));
2758 for (
i = 0;
i < track->
entry;
i++) {
2761 stts_entries[entries].
count++;
2765 stts_entries[entries].
count = 1;
2770 atom_size = 16 + (entries * 8);
2775 for (
i = 0;
i < entries;
i++) {
2802 int16_t roll_distance;
2803 int group_description_index;
2806 struct sgpd_entry *sgpd_entries =
NULL;
2826 for (
i = 0;
i < track->
entry;
i++) {
2827 int roll_samples_remaining = roll_samples;
2829 for (j =
i - 1; j >= 0; j--) {
2832 if (roll_samples_remaining <= 0)
2838 if (roll_samples_remaining > 0)
2843 if (
i &&
distance == sgpd_entries[entries].roll_distance) {
2844 sgpd_entries[entries].count++;
2847 sgpd_entries[entries].count = 1;
2848 sgpd_entries[entries].roll_distance =
distance;
2849 sgpd_entries[entries].group_description_index =
distance ? ++group : 0;
2855 sgpd_entries[entries].roll_distance = 1;
2856 sgpd_entries[entries].group_description_index = ++group;
2872 for (
i = 0;
i < entries;
i++) {
2873 if (sgpd_entries[
i].group_description_index) {
2874 avio_wb16(pb, -sgpd_entries[
i].roll_distance);
2884 for (
i = 0;
i < entries;
i++) {
2886 avio_wb32(pb, sgpd_entries[
i].group_description_index);
2959 const char *font =
"Lucida Grande";
2999 if (track->
tag !=
MKTAG(
'c',
'6',
'0',
'8')) {
3051 return track->
tag ==
MKTAG(
'c',
'7',
'0',
'8') ||
3052 track->
tag ==
MKTAG(
'c',
'6',
'0',
'8');
3058 const char *hdlr, *descr =
NULL, *hdlr_type =
NULL;
3064 descr =
"DataHandler";
3067 hdlr = (track->
mode ==
MODE_MOV) ?
"mhlr" :
"\0\0\0\0";
3070 hdlr_type = (track == &mov->
tracks[0]) ?
"pict" :
"auxv";
3071 descr =
"PictureHandler";
3074 descr =
"VideoHandler";
3078 descr =
"SoundHandler";
3082 descr =
"ClosedCaptionHandler";
3084 if (track->
tag ==
MKTAG(
't',
'x',
'3',
'g')) {
3086 }
else if (track->
tag ==
MKTAG(
'm',
'p',
'4',
's')) {
3093 descr =
"SubtitleHandler";
3097 descr =
"HintHandler";
3100 descr =
"TimeCodeHandler";
3103 descr =
"GoPro MET";
3106 "Unknown hdlr_type for %s, writing dummy values\n",
3131 descr_len = strlen(descr);
3224 avio_wb32(pb,
s->streams[stream_index]->codecpar->width);
3225 avio_wb32(pb,
s->streams[stream_index]->codecpar->height);
3330 }
else if (track->
tag ==
MKTAG(
'r',
't',
'p',
' ')) {
3332 }
else if (track->
tag ==
MKTAG(
't',
'm',
'c',
'd')) {
3337 }
else if (track->
tag ==
MKTAG(
'g',
'p',
'm',
'd')) {
3349 int64_t *start, int64_t *end)
3423 else if (!track->
entry)
3432 "FATAL error, file duration too long for timebase, this file will not be\n"
3433 "playable with QuickTime. Choose a different timebase with "
3434 "-video_track_timescale or a different container format\n");
3460 int16_t
d, int16_t tx, int16_t ty)
3483 uint32_t *display_matrix =
NULL;
3502 if (sd && sd->
size == 9 *
sizeof(*display_matrix))
3503 display_matrix = (uint32_t *)sd->
data;
3526 else if (!track->
entry)
3543 if (display_matrix) {
3544 for (
i = 0;
i < 9;
i++)
3552 int64_t track_width_1616;
3554 track_width_1616 = track->
par->
width * 0x10000ULL;
3559 if (!track_width_1616 ||
3561 track_width_1616 > UINT32_MAX)
3562 track_width_1616 = track->
par->
width * 0x10000ULL;
3564 if (track_width_1616 > UINT32_MAX) {
3566 track_width_1616 = 0;
3569 if (track->
height > 0xFFFF) {
3623 int entry_size, entry_count,
size;
3624 int64_t delay, start_ct = track->
start_cts;
3632 "EDTS using dts:%"PRId64
" cts:%d instead of dts:%"PRId64
" cts:%"PRId64
" tid:%d\n",
3634 start_dts, start_ct, track->
track_id);
3653 version |= delay < INT32_MAX ? 0 : 1;
3655 entry_size = (
version == 1) ? 20 : 12;
3656 entry_count = 1 + (delay > 0);
3657 size = 24 + entry_count * entry_size;
3688 start_ct = -
FFMIN(start_dts, 0);
3746 char buf[1000] =
"";
3765 const char *
tag,
const char *str)
3790 avio_write(pb, (
const unsigned char *)scheme_uri,
3791 strlen(scheme_uri));
3811 for (
int j = 0;
map.value_maps[j].disposition; j++) {
3860 int entry_backup = track->
entry;
3880 "Not writing any edit list even though one would have been required\n");
3893 if (track->
tag ==
MKTAG(
'r',
't',
'p',
' '))
3907 track->
entry = entry_backup;
3914 int i, has_audio = 0, has_video = 0;
3924 if (audio_profile < 0)
3925 audio_profile = 0xFF - has_audio;
3926 if (video_profile < 0)
3927 video_profile = 0xFF - has_video;
3967 int max_track_id = 1,
i;
3968 int64_t max_track_len = 0;
3979 if (max_track_len < max_track_len_temp)
3980 max_track_len = max_track_len_temp;
3981 if (max_track_id < mov->tracks[
i].track_id)
4048 size_t data_len = strlen(
data);
4050 int size = 16 + data_len;
4063 return data_len + 4;
4068 const char *
value,
int lang,
int long_style)
4082 const char *
tag,
int *lang)
4096 len2 = strlen(
t2->key);
4097 if (len2 ==
len + 4 && !strcmp(t->
value,
t2->value)
4107 const char *
name,
const char *
tag,
4121 int size = 0, tmpo = t ? atoi(t->
value) : 0;
4140 double latitude, longitude, altitude;
4141 int32_t latitude_fix, longitude_fix, altitude_fix;
4143 const char *ptr, *place =
"";
4145 static const char *astronomical_body =
"earth";
4150 latitude =
strtod(ptr, &end);
4156 longitude =
strtod(ptr, &end);
4162 altitude =
strtod(ptr, &end);
4167 latitude_fix = (
int32_t) ((1 << 16) * latitude);
4168 longitude_fix = (
int32_t) ((1 << 16) * longitude);
4169 altitude_fix = (
int32_t) ((1 << 16) * altitude);
4180 avio_write(pb, astronomical_body, strlen(astronomical_body) + 1);
4191 disc ?
"disc" :
"track",
4193 int size = 0, track = t ? atoi(t->
value) : 0;
4196 char *slash = strchr(t->
value,
'/');
4198 tracks = atoi(slash + 1);
4215 const char *
name,
const char *
tag,
4222 if (
len != 1 &&
len != 4)
4227 num = atoi(t->
value);
4328 int64_t curpos, entry_pos;
4338 size_t key_len = strlen(t->
key);
4406 const char *
name,
const char *
key)
4438 return (((str[0] - 0x60) & 0x1F) << 10) +
4439 (((str[1] - 0x60) & 0x1F) << 5) +
4440 (( str[2] - 0x60) & 0x1F);
4444 const char *
tag,
const char *str)
4453 if (!strcmp(
tag,
"yrrc"))
4458 if (!strcmp(
tag,
"albm") &&
4468 int i, nb_chapters =
FFMIN(
s->nb_chapters, 255);
4476 for (
i = 0;
i < nb_chapters;
i++) {
4550 const char *str,
const char *lang,
int type)
4604 uint64_t chunkSize = chunk->
size;
4617 chunkSize = chunk->
size;
4643 int next_generated_track_id = 0;
4646 if (st->
id > next_generated_track_id)
4647 next_generated_track_id = st->
id;
4697 if (track->
tag ==
MKTAG(
'r',
't',
'p',
' ')) {
4704 if (sd && sd->
size ==
sizeof(
int)) {
4705 int *fallback = (
int *)sd->
data;
4706 if (*fallback >= 0 && *fallback < mov->nb_tracks) {
4762 avio_printf(pb,
"<param name=\"%s\" value=\"%s\" valuetype=\"data\"/>\n",
name, buf);
4770 static const AVUUID uuid = {
4771 0xa5, 0xd4, 0x0b, 0x30, 0xe8, 0x14, 0x11, 0xdd,
4772 0xba, 0x2f, 0x08, 0x00, 0x20, 0x0c, 0x9a, 0x66
4780 avio_printf(pb,
"<?xml version=\"1.0\" encoding=\"utf-8\"?>\n");
4781 avio_printf(pb,
"<smil xmlns=\"http://www.w3.org/2001/SMIL20/Language\">\n");
4784 avio_printf(pb,
"<meta name=\"creator\" content=\"%s\" />\n",
4798 char track_name_buf[32] = { 0 };
4822 av_strlcatf(track_name_buf,
sizeof(track_name_buf),
4823 "_%s", lang->
value);
4827 av_strlcat(track_name_buf,
"_cc",
sizeof(track_name_buf));
4829 av_strlcat(track_name_buf,
"_ad",
sizeof(track_name_buf));
4905 MOVTrack *track, int64_t moof_offset)
4910 if (!track->
entry) {
4957 if (track->
entry > 1)
5029 static const uint8_t uuid[] = {
5030 0x6d, 0x1d, 0x9b, 0x05, 0x42, 0xd5, 0x44, 0xe6,
5031 0x80, 0xe2, 0x14, 0x1d, 0xaf, 0xf7, 0x57, 0xb2
5050 int size = 8 + 16 + 4 + 1 + 16*n;
5051 static const uint8_t uuid[] = {
5052 0xd4, 0x80, 0x7e, 0xf2, 0xca, 0x39, 0x46, 0x95,
5053 0x8e, 0x54, 0x26, 0xcb, 0x9e, 0x46, 0xa7, 0x9f
5066 for (
i = 0;
i < n;
i++) {
5067 int index = entry + 1 +
i;
5071 if (n < mov->ism_lookahead) {
5102 if ((tracks >= 0 &&
i != tracks) || !track->
entry)
5124 if (
info->time < 0) {
5128 info->tfrf_offset = 0;
5139 if ((tracks >= 0 &&
i != tracks) || !track->
entry)
5161 MOVTrack *track, int64_t moof_offset,
5172 for (
i = 1;
i < track->
entry;
i++) {
5187 if (!
info->tfrf_offset)
5200 int tracks,
int moof_size)
5212 if (tracks >= 0 &&
i != tracks)
5223 MOVTrack *track,
int ref_size,
int total_sidx_size)
5227 unsigned starts_with_SAP;
5239 if (presentation_time < 0) {
5241 presentation_time = 0;
5249 if (presentation_time > 0)
5265 for (
i = 0;
i < entries;
i++) {
5266 if (!track->
entry) {
5272 starts_with_SAP = 1;
5274 avio_wb32(pb, (0 << 31) | (ref_size & 0x7fffffff));
5276 avio_wb32(pb, (starts_with_SAP << 31) | (0 << 28) | 0);
5280 offset =
pos + total_sidx_size - end_pos;
5288 int tracks,
int ref_size)
5306 if (tracks >= 0 &&
i != tracks)
5311 if (!track->
entry && ref_size > 0)
5332 first_track = &(mov->
tracks[0]);
5334 if (!first_track->
entry) {
5478 int has_h264,
int has_video,
int write_minor)
5487 minor = has_h264 ? 0x100 : 0x200;
5493 minor = has_h264 ? 0x20000 : 0x10000;
5522 int has_h264 = 0, has_av1 = 0, has_video = 0, has_dolby = 0;
5525 for (
int i = 0;
i <
s->nb_stream_groups;
i++) {
5568 const int depth = pix_fmt_desc->
comp[0].
depth;
5578 if (depth == 8 || depth == 10) {
5642 int audio_kbitrate = audio_par->
bit_rate / 1000;
5643 int video_kbitrate =
FFMIN(video_par->
bit_rate / 1000, 800 - audio_kbitrate);
5645 if (frame_rate < 0 || frame_rate > INT32_MAX) {
5646 av_log(
s,
AV_LOG_ERROR,
"Frame rate %f outside supported range\n", frame_rate / (
double)0x10000);
5711 int video_streams_nb = 0, audio_streams_nb = 0, other_streams_nb = 0;
5724 if (video_streams_nb != 1 || audio_streams_nb != 1 || other_streams_nb) {
5736 int i, closed_gop = 0;
5741 closed_gop =
pkt->
data[
i + 4] >> 6 & 0x01;
5742 }
else if (
c == 0x100) {
5744 if (!temp_ref || closed_gop)
5757 int seq = 0, entry = 0;
5760 for (next = start; next < end; start = next) {
5822 if (length < 8 || length >
pkt->
size)
5874 if (!had_packets && squashed_packet->
duration == 0) {
5907 "Failed to write squashed packet for %s stream with "
5908 "index %d and track id %d. Error: %s\n",
5923 int i, first_track = -1;
5924 int64_t mdat_size = 0;
5926 int has_video = 0, starts_with_key = 0, first_video_track = 1;
5963 if (track->
entry <= 1)
5981 "Estimating the duration of the last packet in a "
5982 "fragment, consider setting the duration field in "
5983 "AVPacket instead.\n");
5991 int buf_size, moov_size;
5997 if (i < mov->nb_tracks && !force)
6058 if (first_video_track) {
6061 first_video_track = 0;
6068 if (first_track < 0)
6081 int buf_size, write_moof = 1, moof_tracks = -1;
6090 write_moof =
i == first_track;
6184 unsigned int samples_in_chunk = 0;
6187 uint8_t *reformatted_data =
NULL;
6225 static const uint16_t packed_size[16] =
6226 {13, 14, 16, 18, 20, 21, 27, 32, 6, 0, 0, 0, 0, 0, 0, 1};
6229 while (
len <
size && samples_in_chunk < 100) {
6233 if (samples_in_chunk > 1) {
6234 av_log(
s,
AV_LOG_ERROR,
"fatal error, input is not a single packet, implement a AVParser for it\n");
6243 samples_in_chunk = 1;
6245 if (samples_in_chunk < 1) {
6287 "use the audio bitstream filter 'aac_adtstoasc' to fix it "
6288 "('-bsf:a aac_adtstoasc' option with ffmpeg)\n");
6386 int nal_size_length = (par->
extradata[4] & 0x3) + 1;
6389 int nal_size_length = (par->
extradata[21] & 0x3) + 1;
6474 "Track %d starts with a nonzero dts %"PRId64
", while the moov "
6475 "already has been written. Set the delay_moov flag to handle "
6533 reformatted_data ? reformatted_data +
offset
6539 if (
pkt->
data != reformatted_data)
6549 int64_t frag_duration = 0;
6580 memcpy(par->
extradata, side, side_size);
6638 uint8_t
data[2] = {0};
6723 "for stream #%d\n", trk->
st->
index);
6792 "Packets without a valid presentation timestamp are "
6793 "not supported with packet squashing!\n");
6810 int reshuffle_ret,
ret;
6813 int expected_stride = ((trk->
par->
width * bpc + 15) >> 4)*2;
6815 if (reshuffle_ret < 0)
6816 return reshuffle_ret;
6834 if (reshuffle_ret) {
6851 static const uint8_t stub_header[] = {
6853 0x00, 0x00, 0x00, 0x01,
6855 0x00, 0x00, 0x00, 0x00,
6857 0x00, 0x00, 0x00, 0x00,
6858 0x00, 0x00, 0x00, 0x00,
6860 0x00, 0x00, 0x00, 0x00,
6863 0x00, 0x00, 0x00, 0x00,
6865 0x00, 0x00, 0x00, 0x0D,
6879 track->
tag =
MKTAG(
't',
'e',
'x',
't');
6888 memcpy(track->
par->
extradata, stub_header,
sizeof(stub_header));
6893 for (
i = 0;
i <
s->nb_chapters;
i++) {
6902 static const char encd[12] = {
6903 0x00, 0x00, 0x00, 0x0C,
6905 0x00, 0x00, 0x01, 0x00 };
6915 memcpy(
pkt->
data +
len + 2, encd,
sizeof(encd));
6948 track->
tag =
MKTAG(
't',
'm',
'c',
'd');
7023 if (!enabled[
i] &&
first[
i] >= 0)
7034 for (
int i = 0;
i <
s->nb_streams;
i++)
7035 s->streams[
i]->priv_data =
NULL;
7047 if (track->
tag ==
MKTAG(
'r',
't',
'p',
' '))
7083 r = (
rgb >> 16) & 0xFF;
7084 g = (
rgb >> 8) & 0xFF;
7091 return (y << 16) | (
cr << 8) |
cb;
7098 int have_palette = 0, have_size = 0;
7099 uint32_t palette[16];
7102 while (cur && *cur) {
7103 if (strncmp(
"palette:", cur, 8) == 0) {
7105 count = sscanf(cur + 8,
7106 "%06"PRIx32
", %06"PRIx32
", %06"PRIx32
", %06"PRIx32
", "
7107 "%06"PRIx32
", %06"PRIx32
", %06"PRIx32
", %06"PRIx32
", "
7108 "%06"PRIx32
", %06"PRIx32
", %06"PRIx32
", %06"PRIx32
", "
7109 "%06"PRIx32
", %06"PRIx32
", %06"PRIx32
", %06"PRIx32
"",
7110 &palette[ 0], &palette[ 1], &palette[ 2], &palette[ 3],
7111 &palette[ 4], &palette[ 5], &palette[ 6], &palette[ 7],
7112 &palette[ 8], &palette[ 9], &palette[10], &palette[11],
7113 &palette[12], &palette[13], &palette[14], &palette[15]);
7115 for (
i = 0;
i < count;
i++) {
7119 }
else if (!strncmp(
"size:", cur, 5)) {
7123 if (have_palette && have_size)
7125 cur += strcspn(cur,
"\n\r");
7126 cur += strspn(cur,
"\n\r");
7132 for (
i = 0;
i < 16;
i++) {
7148 int nb_audio_elements = 0, nb_mix_presentations = 0;
7151 for (
int i = 0;
i <
s->nb_stream_groups;
i++) {
7155 nb_audio_elements++;
7157 nb_mix_presentations++;
7160 if (!nb_audio_elements && !nb_mix_presentations)
7163 if (nb_audio_elements < 1 || nb_audio_elements > 2 || nb_mix_presentations < 1) {
7165 "one IAMF_MIX_PRESENTATION stream groups to write a IMAF track\n");
7173 for (
int i = 0;
i <
s->nb_stream_groups;
i++) {
7195 track->
tag =
MKTAG(
'i',
'a',
'm',
'f');
7215 #define IS_MODE(muxer, config) (CONFIG_ ## config ## _MUXER && !strcmp(#muxer, s->oformat->name))
7284 av_log(
s,
AV_LOG_WARNING,
"No meaningful edit list will be written when using empty_moov without delay_moov\n");
7304 "Sample interleaving in fragments is mutually exclusive with "
7305 "omit_tfhd_offset and separate_moof\n");
7321 if (
s->nb_streams > 2) {
7330 if (
s->nb_streams > 1) {
7334 av_log(
s,
AV_LOG_ERROR,
"Second stream for AVIF (alpha) output must have exactly one plane\n");
7341 for (
i = 0;
i <
s->nb_stream_groups;
i++) {
7352 "IAMF Audio Element\n", j);
7362 for (
i = 0;
i <
s->nb_streams;
i++) {
7376 for (
i = 0;
i <
s->nb_streams;
i++)
7391 for (
i = 0;
i <
s->nb_streams;
i++) {
7405 for (
i = 0;
i <
s->nb_streams;
i++) {
7409 "so timecode metadata are now ignored\n");
7450 for (
int j = 0,
i = 0; j <
s->nb_streams; j++) {
7458 for (
i = 0;
i <
s->nb_streams;
i++) {
7475 "codec not currently supported in container\n",
7487 if (track->
tag ==
MKTAG(
'm',
'x',
'3',
'p') || track->
tag ==
MKTAG(
'm',
'x',
'3',
'n') ||
7488 track->
tag ==
MKTAG(
'm',
'x',
'4',
'p') || track->
tag ==
MKTAG(
'm',
'x',
'4',
'n') ||
7489 track->
tag ==
MKTAG(
'm',
'x',
'5',
'p') || track->
tag ==
MKTAG(
'm',
'x',
'5',
'n')) {
7494 track->
height = track->
tag >> 24 ==
'n' ? 486 : 576;
7499 av_log(
s,
AV_LOG_WARNING,
"Warning: some tools, like mp4split, assume a timescale of 10000000 for ISMV.\n");
7511 "WARNING codec timebase is very high. If duration is too long,\n"
7512 "file may not be playable by quicktime. Specify a shorter timebase\n"
7513 "or choose different container.\n");
7516 track->
tag ==
MKTAG(
'r',
'a',
'w',
' ')) {
7572 av_log(
s,
AV_LOG_ERROR,
"track %d: muxing mp3 at %dhz is not standard, to mux anyway set strict to -1\n",
7590 "%s in MP4 support is experimental, add "
7591 "'-strict %d' if you want to use it.\n",
7612 "Fragmentation is not currently supported for "
7613 "TTML in MP4/ISMV (track synchronization between "
7614 "subtitles and other media is not yet implemented)!\n");
7622 "ISMV style TTML support with the 'dfxp' tag in "
7623 "non-ISMV formats is not officially supported. Add "
7624 "'-strict unofficial' if you want to use it.\n");
7664 int ret, hint_track = 0, tmcd_track = 0, nb_tracks = mov->
nb_streams;
7670 hint_track = nb_tracks;
7678 tmcd_track = nb_tracks;
7728 trackj->
tag != track->
tag
7761 mov->
time += 0x7C25B080;
7779 "timecode",
NULL, 0);
7850 int i, moov_size, moov_size2;
7866 if (moov_size2 != moov_size)
7975 av_log(
s,
AV_LOG_INFO,
"Starting second pass: moving the moov atom to the beginning of the file\n");
8045 int64_t pos_backup, extent_offsets[2];
8047 int buf_size, moov_size;
8085 if (extent_offsets[
i] != (uint32_t)extent_offsets[
i]) {
8097 #if CONFIG_TGP_MUXER || CONFIG_TG2_MUXER
8108 static const AVCodecTag *
const codec_3gp_tags_list[] = { codec_3gp_tags,
NULL };
8167 #if CONFIG_MP4_MUXER || CONFIG_PSP_MUXER
8197 #if CONFIG_AVIF_MUXER
8199 static const AVOption avif_options[] = {
8201 {
"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 },
8204 static const AVCodecTag codec_avif_tags[] = {
8208 static const AVCodecTag *
const codec_avif_tags_list[] = { codec_avif_tags,
NULL };
8210 static const AVClass mov_avif_muxer_class = {
8213 .option = avif_options,
8218 #if CONFIG_MOV_MUXER
8222 .p.extensions =
"mov",
8225 .p.video_codec = CONFIG_LIBX264_ENCODER ?
8245 #if CONFIG_TGP_MUXER
8249 .p.extensions =
"3gp",
8263 .p.codec_tag = codec_3gp_tags_list,
8269 #if CONFIG_MP4_MUXER
8273 .p.mime_type =
"video/mp4",
8274 .p.extensions =
"mp4",
8277 .p.video_codec = CONFIG_LIBX264_ENCODER ?
8289 .p.codec_tag = mp4_codec_tags_list,
8295 #if CONFIG_PSP_MUXER
8299 .p.extensions =
"mp4,psp",
8302 .p.video_codec = CONFIG_LIBX264_ENCODER ?
8314 .p.codec_tag = mp4_codec_tags_list,
8320 #if CONFIG_TG2_MUXER
8324 .p.extensions =
"3g2",
8338 .p.codec_tag = codec_3gp_tags_list,
8344 #if CONFIG_IPOD_MUXER
8348 .p.mime_type =
"video/mp4",
8349 .p.extensions =
"m4v,m4a,m4b",
8369 #if CONFIG_ISMV_MUXER
8373 .p.mime_type =
"video/mp4",
8374 .p.extensions =
"ismv,isma",
8395 #if CONFIG_F4V_MUXER
8399 .p.mime_type =
"application/f4v",
8400 .p.extensions =
"f4v",
8420 #if CONFIG_AVIF_MUXER
8424 .p.mime_type =
"image/avif",
8425 .p.extensions =
"avif",
8438 .p.codec_tag = codec_avif_tags_list,
8439 .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...
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
static const struct @327 mov_pix_fmt_tags[]
#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)
struct MOVTrack::@329 vc1_info
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)
#define FF_FMT_ALLOW_FLUSH
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.
@ AV_ROUND_UP
Round toward +infinity.
#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)
#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 avif_write_trailer(AVFormatContext *s)
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.
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[]
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
@ 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)
@ 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.
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.
struct eac3_info::@328 substream[1]
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.
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