Go to the documentation of this file.
24 #include "config_components.h"
82 {
"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 },
88 {
"movflags",
"MOV muxer flags", offsetof(
MOVMuxContext,
flags),
AV_OPT_TYPE_FLAGS, {.i64 = 0}, INT_MIN, INT_MAX,
AV_OPT_FLAG_ENCODING_PARAM, .unit =
"movflags" },
92 {
"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" },
102 {
"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 },
111 {
"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" },
122 {
"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"},
130 .
class_name =
"mov/mp4/tgp/psp/tg2/ipod/ismv/f4v muxer",
197 for (
i = 0;
i < track->
entry;
i++) {
212 int i, j, entries = 0, tst = -1, oldtst = -1;
219 for (
i = 0;
i < track->
entry;
i++) {
221 if (oldtst != -1 && tst != oldtst)
226 if (equalChunks && track->
entry) {
228 sSize =
FFMAX(1, sSize);
234 for (
i = 0;
i < track->
entry;
i++) {
247 int index = 0, oldval = -1,
i;
248 int64_t entryPos, curpos;
256 for (
i = 0;
i < track->
entry;
i++) {
276 int64_t curpos, entryPos;
284 for (
i = 0;
i < track->
entry;
i++) {
301 uint8_t leading, dependent, reference, redundancy;
306 for (
i = 0;
i < track->
entry;
i++) {
315 avio_w8(pb, (leading << 6) | (dependent << 4) |
316 (reference << 2) | redundancy);
326 uint8_t *dyn_buf =
NULL;
404 "Cannot write moov atom before AC3 packets."
405 " Set the delay_moov flag to fix this.\n");
409 if (
info->substream[0].bsid > 8) {
411 "RealAudio AC-3/DolbyNet with bsid %d is not defined by the "
412 "ISOBMFF specification in ETSI TS 102 366!\n",
413 info->substream[0].bsid);
417 if (
info->ac3_bit_rate_code < 0) {
419 "No valid AC3 bit rate code for data rate of %d!\n",
477 if (!
info->ec3_done) {
532 while (cumul_size !=
pkt->
size) {
542 info->substream[parent].num_dep_sub++;
558 info->substream[parent].chan_loc |= (
get_bits(&gbc, 16) >> 5) & 0x1f;
576 if (!
info->num_blocks) {
587 if (
info->num_blocks != 6)
591 info->num_blocks = 0;
610 "Cannot write moov atom before EAC3 packets parsed.\n");
615 size = 2 + ((34 * (
info->num_ind_sub + 1) + 7) >> 3);
624 for (
i = 0;
i <=
info->num_ind_sub;
i++) {
634 if (!
info->substream[
i].num_dep_sub) {
714 if (!bit_rates.avg_bit_rate) {
723 if (props && props->avg_bitrate) {
724 bit_rates.avg_bit_rate = props->avg_bitrate;
727 }
else if (props && props->max_bitrate) {
728 bit_rates.avg_bit_rate = props->max_bitrate;
734 bit_rates.avg_bit_rate);
738 bit_rates.max_bit_rate =
FFMAX(bit_rates.max_bit_rate,
740 bit_rates.buffer_size = props->buffer_size / 8;
750 int decoder_specific_info_len = track->
vos_len ? 5 + track->
vos_len : 0;
757 put_descr(pb, 0x03, 3 + 5+13 + decoder_specific_info_len + 5+1);
762 put_descr(pb, 0x04, 13 + decoder_specific_info_len);
899 "Cannot write moov atom before TrueHD packets."
900 " Set the delay_moov flag to fix this.\n");
905 if (length < 20 || length > track->
vos_len)
921 uint32_t layout_tag, bitmap, *channel_desc;
929 &bitmap, &channel_desc);
934 "lack of channel information\n");
943 channel_desc =
av_malloc(
sizeof(*channel_desc));
962 for (
int i = 0;
i < num_desc;
i++) {
1022 int unescaped_size, seq_found = 0;
1023 int level = 0, interlace = 0;
1032 packet_seq = packet_entry = 1;
1034 "moov atom written before any packets, unable to write correct "
1035 "dvc1 atom. Set the delay_moov flag to fix this.\n");
1042 for (next = start; next < end; start = next) {
1046 size = next - start - 4;
1103 uint8_t buf[7] = { 0 };
1158 if (cluster_idx >= track->
entry)
1161 if (cluster_idx + 1 == track->
entry)
1164 next_dts = track->
cluster[cluster_idx + 1].
dts;
1176 int i, first_duration;
1186 for (
i = 1;
i < track->
entry;
i++) {
1190 return first_duration;
1217 uint8_t *speaker_pos =
NULL;
1225 speaker_pos,
layout->nb_channels);
1227 char buf[128] = {0};
1245 for (
int i = 0;
i <
layout->nb_channels;
i++)
1283 uint32_t
tag = track->
tag;
1387 else if (track->
tag ==
MKTAG(
'm',
'p',
'4',
'a'))
1390 else if (track->
tag ==
MKTAG(
'i',
'a',
'm',
'f'))
1391 ret = mov_write_iacb_tag(mov->
fc, pb, track);
1415 }
else if (track->
vos_len > 0)
1487 if (track->
tag ==
MKTAG(
'h',
'v',
'c',
'1'))
1501 if (track->
tag ==
MKTAG(
'e',
'v',
'c',
'1'))
1519 if (track->
tag ==
MKTAG(
'v',
'v',
'c',
'1'))
1531 int display_width = track->
par->
width;
1559 if (track->
tag ==
MKTAG(
'A',
'V',
'd',
'h')) {
1635 }
else if (track->
par->
height == 1080) {
1650 if (rational_framerate.
den != 0)
1651 rate =
av_q2d(rational_framerate);
1668 if (rate == 24)
tag =
MKTAG(
'x',
'd',
'v',
'4');
1669 else if (rate == 25)
tag =
MKTAG(
'x',
'd',
'v',
'5');
1670 else if (rate == 30)
tag =
MKTAG(
'x',
'd',
'v',
'1');
1671 else if (rate == 50)
tag =
MKTAG(
'x',
'd',
'v',
'a');
1672 else if (rate == 60)
tag =
MKTAG(
'x',
'd',
'v',
'9');
1676 if (rate == 24)
tag =
MKTAG(
'x',
'd',
'v',
'6');
1677 else if (rate == 25)
tag =
MKTAG(
'x',
'd',
'v',
'7');
1678 else if (rate == 30)
tag =
MKTAG(
'x',
'd',
'v',
'8');
1680 if (rate == 25)
tag =
MKTAG(
'x',
'd',
'v',
'3');
1681 else if (rate == 30)
tag =
MKTAG(
'x',
'd',
'v',
'2');
1685 if (rate == 24)
tag =
MKTAG(
'x',
'd',
'v',
'd');
1686 else if (rate == 25)
tag =
MKTAG(
'x',
'd',
'v',
'e');
1687 else if (rate == 30)
tag =
MKTAG(
'x',
'd',
'v',
'f');
1689 if (rate == 25)
tag =
MKTAG(
'x',
'd',
'v',
'c');
1690 else if (rate == 30)
tag =
MKTAG(
'x',
'd',
'v',
'b');
1696 if (rate == 24)
tag =
MKTAG(
'x',
'd',
'5',
'4');
1697 else if (rate == 25)
tag =
MKTAG(
'x',
'd',
'5',
'5');
1698 else if (rate == 30)
tag =
MKTAG(
'x',
'd',
'5',
'1');
1699 else if (rate == 50)
tag =
MKTAG(
'x',
'd',
'5',
'a');
1700 else if (rate == 60)
tag =
MKTAG(
'x',
'd',
'5',
'9');
1704 if (rate == 24)
tag =
MKTAG(
'x',
'd',
'5',
'd');
1705 else if (rate == 25)
tag =
MKTAG(
'x',
'd',
'5',
'e');
1706 else if (rate == 30)
tag =
MKTAG(
'x',
'd',
'5',
'f');
1708 if (rate == 25)
tag =
MKTAG(
'x',
'd',
'5',
'c');
1709 else if (rate == 30)
tag =
MKTAG(
'x',
'd',
'5',
'b');
1730 if (rate == 24)
tag =
MKTAG(
'a',
'i',
'5',
'p');
1731 else if (rate == 25)
tag =
MKTAG(
'a',
'i',
'5',
'q');
1732 else if (rate == 30)
tag =
MKTAG(
'a',
'i',
'5',
'p');
1733 else if (rate == 50)
tag =
MKTAG(
'a',
'i',
'5',
'q');
1734 else if (rate == 60)
tag =
MKTAG(
'a',
'i',
'5',
'p');
1738 if (rate == 24)
tag =
MKTAG(
'a',
'i',
'5',
'3');
1739 else if (rate == 25)
tag =
MKTAG(
'a',
'i',
'5',
'2');
1740 else if (rate == 30)
tag =
MKTAG(
'a',
'i',
'5',
'3');
1742 if (rate == 50)
tag =
MKTAG(
'a',
'i',
'5',
'5');
1743 else if (rate == 60)
tag =
MKTAG(
'a',
'i',
'5',
'6');
1749 if (rate == 24)
tag =
MKTAG(
'a',
'i',
'1',
'p');
1750 else if (rate == 25)
tag =
MKTAG(
'a',
'i',
'1',
'q');
1751 else if (rate == 30)
tag =
MKTAG(
'a',
'i',
'1',
'p');
1752 else if (rate == 50)
tag =
MKTAG(
'a',
'i',
'1',
'q');
1753 else if (rate == 60)
tag =
MKTAG(
'a',
'i',
'1',
'p');
1757 if (rate == 24)
tag =
MKTAG(
'a',
'i',
'1',
'3');
1758 else if (rate == 25)
tag =
MKTAG(
'a',
'i',
'1',
'2');
1759 else if (rate == 30)
tag =
MKTAG(
'a',
'i',
'1',
'3');
1761 if (rate == 25)
tag =
MKTAG(
'a',
'i',
'1',
'5');
1762 else if (rate == 50)
tag =
MKTAG(
'a',
'i',
'1',
'5');
1763 else if (rate == 60)
tag =
MKTAG(
'a',
'i',
'1',
'6');
1785 static const struct {
1833 if (
tag ==
MKTAG(
'r',
'a',
'w',
' ') &&
1837 av_log(
s,
AV_LOG_ERROR,
"%s rawvideo cannot be written to mov, output file will be unreadable\n",
1876 "the file may be unplayable!\n");
1883 tag =
MKTAG(
'm',
's', ((ms_tag >> 8) & 0xff), (ms_tag & 0xff));
1885 "the file may be unplayable!\n");
1910 for (
i = 0; tags && tags[
i];
i++) {
1915 return codec_tags->
tag;
1932 "Quicktime/Ipod might not play the file\n");
1958 0x0000, 0x0100, 0x0201, 0x0206, 0x0209, 0x020e
1963 unsigned mov_field_order = 0;
1965 mov_field_order =
fiel_data[field_order];
2003 "Unknown codec tag '%s' utilized for TTML stream with "
2004 "index %d (track id %d)!\n",
2023 if (stereo_3d->
flags != 0) {
2028 switch (stereo_3d->
type) {
2051 int64_t sv3d_pos, svhd_pos, proj_pos;
2161 gama = (uint32_t)
lrint((
double)(1<<16) * gamma);
2192 return 12 + sd->
size;
2250 const int chroma_den = 50000;
2251 const int luma_den = 10000;
2281 const int illuminance_den = 10000;
2282 const int ambient_den = 50000;
2325 }
else if(track->
par->
width == 1440) {
2344 uint8_t ccstValue = (0 << 7) |
2361 avio_write(pb,
"urn:mpeg:mpegB:cicp:systems:auxiliary:alpha\0", 44);
2369 char compressor_name[32] = { 0 };
2389 if (uncompressed_ycbcr) {
2415 avio_w8(pb, strlen(compressor_name));
2436 for (
i = 0;
i < pal_size;
i++) {
2438 uint16_t
r = (
rgb >> 16) & 0xff;
2439 uint16_t
g = (
rgb >> 8) & 0xff;
2440 uint16_t
b =
rgb & 0xff;
2449 if (track->
tag ==
MKTAG(
'm',
'p',
'4',
'v'))
2484 }
else if (track->
vos_len > 0)
2531 if (spherical_mapping)
2550 if (uncompressed_ycbcr){
2598 uint64_t str_size =strlen(reel_name);
2601 if (str_size >= UINT16_MAX){
2631 if (nb_frames > 255) {
2707 uint32_t entries = 0;
2714 ctts_entries[0].
count = 1;
2716 for (
i = 1;
i < track->
entry;
i++) {
2718 ctts_entries[entries].
count++;
2722 ctts_entries[entries].
count = 1;
2726 atom_size = 16 + (entries * 8);
2735 for (
i = 0;
i < entries;
i++) {
2747 uint32_t entries = -1;
2752 stts_entries =
av_malloc(
sizeof(*stts_entries));
2764 for (
i = 0;
i < track->
entry;
i++) {
2767 stts_entries[entries].
count++;
2771 stts_entries[entries].
count = 1;
2776 atom_size = 16 + (entries * 8);
2781 for (
i = 0;
i < entries;
i++) {
2808 int16_t roll_distance;
2809 int group_description_index;
2812 struct sgpd_entry *sgpd_entries =
NULL;
2832 for (
i = 0;
i < track->
entry;
i++) {
2833 int roll_samples_remaining = roll_samples;
2835 for (j =
i - 1; j >= 0; j--) {
2838 if (roll_samples_remaining <= 0)
2844 if (roll_samples_remaining > 0)
2849 if (
i &&
distance == sgpd_entries[entries].roll_distance) {
2850 sgpd_entries[entries].count++;
2853 sgpd_entries[entries].count = 1;
2854 sgpd_entries[entries].roll_distance =
distance;
2855 sgpd_entries[entries].group_description_index =
distance ? ++group : 0;
2861 sgpd_entries[entries].roll_distance = 1;
2862 sgpd_entries[entries].group_description_index = ++group;
2878 for (
i = 0;
i < entries;
i++) {
2879 if (sgpd_entries[
i].group_description_index) {
2880 avio_wb16(pb, -sgpd_entries[
i].roll_distance);
2890 for (
i = 0;
i < entries;
i++) {
2892 avio_wb32(pb, sgpd_entries[
i].group_description_index);
2965 const char *font =
"Lucida Grande";
3005 if (track->
tag !=
MKTAG(
'c',
'6',
'0',
'8')) {
3057 return track->
tag ==
MKTAG(
'c',
'7',
'0',
'8') ||
3058 track->
tag ==
MKTAG(
'c',
'6',
'0',
'8');
3064 const char *hdlr, *descr =
NULL, *hdlr_type =
NULL;
3070 descr =
"DataHandler";
3073 hdlr = (track->
mode ==
MODE_MOV) ?
"mhlr" :
"\0\0\0\0";
3076 hdlr_type = (track == &mov->
tracks[0]) ?
"pict" :
"auxv";
3077 descr =
"PictureHandler";
3080 descr =
"VideoHandler";
3084 descr =
"SoundHandler";
3088 descr =
"ClosedCaptionHandler";
3090 if (track->
tag ==
MKTAG(
't',
'x',
'3',
'g')) {
3092 }
else if (track->
tag ==
MKTAG(
'm',
'p',
'4',
's')) {
3099 descr =
"SubtitleHandler";
3103 descr =
"HintHandler";
3106 descr =
"TimeCodeHandler";
3109 descr =
"GoPro MET";
3112 "Unknown hdlr_type for %s, writing dummy values\n",
3137 descr_len = strlen(descr);
3230 avio_wb32(pb,
s->streams[stream_index]->codecpar->width);
3231 avio_wb32(pb,
s->streams[stream_index]->codecpar->height);
3336 }
else if (track->
tag ==
MKTAG(
'r',
't',
'p',
' ')) {
3338 }
else if (track->
tag ==
MKTAG(
't',
'm',
'c',
'd')) {
3343 }
else if (track->
tag ==
MKTAG(
'g',
'p',
'm',
'd')) {
3355 int64_t *start, int64_t *end)
3429 else if (!track->
entry)
3438 "FATAL error, file duration too long for timebase, this file will not be\n"
3439 "playable with QuickTime. Choose a different timebase with "
3440 "-video_track_timescale or a different container format\n");
3466 int16_t
d, int16_t tx, int16_t ty)
3489 uint32_t *display_matrix =
NULL;
3508 if (sd && sd->
size == 9 *
sizeof(*display_matrix))
3509 display_matrix = (uint32_t *)sd->
data;
3532 else if (!track->
entry)
3549 if (display_matrix) {
3550 for (
i = 0;
i < 9;
i++)
3558 int64_t track_width_1616;
3560 track_width_1616 = track->
par->
width * 0x10000ULL;
3565 if (!track_width_1616 ||
3567 track_width_1616 > UINT32_MAX)
3568 track_width_1616 = track->
par->
width * 0x10000ULL;
3570 if (track_width_1616 > UINT32_MAX) {
3572 track_width_1616 = 0;
3575 if (track->
height > 0xFFFF) {
3629 int entry_size, entry_count,
size;
3630 int64_t delay, start_ct = track->
start_cts;
3638 "EDTS using dts:%"PRId64
" cts:%d instead of dts:%"PRId64
" cts:%"PRId64
" tid:%d\n",
3640 start_dts, start_ct, track->
track_id);
3659 version |= delay < INT32_MAX ? 0 : 1;
3661 entry_size = (
version == 1) ? 20 : 12;
3662 entry_count = 1 + (delay > 0);
3663 size = 24 + entry_count * entry_size;
3694 start_ct = -
FFMIN(start_dts, 0);
3752 char buf[1000] =
"";
3771 const char *
tag,
const char *str)
3796 avio_write(pb, (
const unsigned char *)scheme_uri,
3797 strlen(scheme_uri));
3817 for (
int j = 0;
map.value_maps[j].disposition; j++) {
3866 int entry_backup = track->
entry;
3886 "Not writing any edit list even though one would have been required\n");
3899 if (track->
tag ==
MKTAG(
'r',
't',
'p',
' '))
3913 track->
entry = entry_backup;
3920 int i, has_audio = 0, has_video = 0;
3930 if (audio_profile < 0)
3931 audio_profile = 0xFF - has_audio;
3932 if (video_profile < 0)
3933 video_profile = 0xFF - has_video;
3973 int max_track_id = 1,
i;
3974 int64_t max_track_len = 0;
3985 if (max_track_len < max_track_len_temp)
3986 max_track_len = max_track_len_temp;
3987 if (max_track_id < mov->tracks[
i].track_id)
4054 size_t data_len = strlen(
data);
4056 int size = 16 + data_len;
4069 return data_len + 4;
4074 const char *
value,
int lang,
int long_style)
4088 const char *
tag,
int *lang)
4102 len2 = strlen(
t2->key);
4103 if (len2 ==
len + 4 && !strcmp(t->
value,
t2->value)
4113 const char *
name,
const char *
tag,
4127 int size = 0, tmpo = t ? atoi(t->
value) : 0;
4146 double latitude, longitude, altitude;
4147 int32_t latitude_fix, longitude_fix, altitude_fix;
4149 const char *ptr, *place =
"";
4151 static const char *astronomical_body =
"earth";
4156 latitude =
strtod(ptr, &end);
4162 longitude =
strtod(ptr, &end);
4168 altitude =
strtod(ptr, &end);
4173 latitude_fix = (
int32_t) ((1 << 16) * latitude);
4174 longitude_fix = (
int32_t) ((1 << 16) * longitude);
4175 altitude_fix = (
int32_t) ((1 << 16) * altitude);
4186 avio_write(pb, astronomical_body, strlen(astronomical_body) + 1);
4197 disc ?
"disc" :
"track",
4199 int size = 0, track = t ? atoi(t->
value) : 0;
4202 char *slash = strchr(t->
value,
'/');
4204 tracks = atoi(slash + 1);
4221 const char *
name,
const char *
tag,
4228 if (
len != 1 &&
len != 4)
4233 num = atoi(t->
value);
4334 int64_t curpos, entry_pos;
4344 size_t key_len = strlen(t->
key);
4412 const char *
name,
const char *
key)
4444 return (((str[0] - 0x60) & 0x1F) << 10) +
4445 (((str[1] - 0x60) & 0x1F) << 5) +
4446 (( str[2] - 0x60) & 0x1F);
4450 const char *
tag,
const char *str)
4459 if (!strcmp(
tag,
"yrrc"))
4464 if (!strcmp(
tag,
"albm") &&
4474 int i, nb_chapters =
FFMIN(
s->nb_chapters, 255);
4482 for (
i = 0;
i < nb_chapters;
i++) {
4556 const char *str,
const char *lang,
int type)
4610 uint64_t chunkSize = chunk->
size;
4623 chunkSize = chunk->
size;
4649 int next_generated_track_id = 0;
4652 if (st->
id > next_generated_track_id)
4653 next_generated_track_id = st->
id;
4703 if (track->
tag ==
MKTAG(
'r',
't',
'p',
' ')) {
4710 if (sd && sd->
size ==
sizeof(
int)) {
4711 int *fallback = (
int *)sd->
data;
4712 if (*fallback >= 0 && *fallback < mov->nb_tracks) {
4768 avio_printf(pb,
"<param name=\"%s\" value=\"%s\" valuetype=\"data\"/>\n",
name, buf);
4776 static const AVUUID uuid = {
4777 0xa5, 0xd4, 0x0b, 0x30, 0xe8, 0x14, 0x11, 0xdd,
4778 0xba, 0x2f, 0x08, 0x00, 0x20, 0x0c, 0x9a, 0x66
4786 avio_printf(pb,
"<?xml version=\"1.0\" encoding=\"utf-8\"?>\n");
4787 avio_printf(pb,
"<smil xmlns=\"http://www.w3.org/2001/SMIL20/Language\">\n");
4790 avio_printf(pb,
"<meta name=\"creator\" content=\"%s\" />\n",
4804 char track_name_buf[32] = { 0 };
4828 av_strlcatf(track_name_buf,
sizeof(track_name_buf),
4829 "_%s", lang->
value);
4833 av_strlcat(track_name_buf,
"_cc",
sizeof(track_name_buf));
4835 av_strlcat(track_name_buf,
"_ad",
sizeof(track_name_buf));
4910 MOVTrack *track, int64_t moof_offset)
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)
5166 MOVTrack *track, int64_t moof_offset,
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, has_id3 = 0;
5531 for (
int i = 0;
i <
s->nb_stream_groups;
i++) {
5577 const int depth = pix_fmt_desc->
comp[0].
depth;
5587 if (depth == 8 || depth == 10) {
5654 int audio_kbitrate = audio_par->
bit_rate / 1000;
5655 int video_kbitrate =
FFMIN(video_par->
bit_rate / 1000, 800 - audio_kbitrate);
5657 if (frame_rate < 0 || frame_rate > INT32_MAX) {
5658 av_log(
s,
AV_LOG_ERROR,
"Frame rate %f outside supported range\n", frame_rate / (
double)0x10000);
5723 int video_streams_nb = 0, audio_streams_nb = 0, other_streams_nb = 0;
5736 if (video_streams_nb != 1 || audio_streams_nb != 1 || other_streams_nb) {
5748 int i, closed_gop = 0;
5753 closed_gop =
pkt->
data[
i + 4] >> 6 & 0x01;
5754 }
else if (
c == 0x100) {
5756 if (!temp_ref || closed_gop)
5769 int seq = 0,
entry = 0;
5772 for (next = start; next < end; start = next) {
5834 if (length < 8 || length >
pkt->
size)
5886 if (!had_packets && squashed_packet->
duration == 0) {
5919 "Failed to write squashed packet for %s stream with "
5920 "index %d and track id %d. Error: %s\n",
5935 int i, first_track = -1;
5936 int64_t mdat_size = 0;
5938 int has_video = 0, starts_with_key = 0, first_video_track = 1;
5975 if (track->
entry <= 1)
5993 "Estimating the duration of the last packet in a "
5994 "fragment, consider setting the duration field in "
5995 "AVPacket instead.\n");
6003 int buf_size, moov_size;
6009 if (i < mov->nb_tracks && !force)
6070 if (first_video_track) {
6073 first_video_track = 0;
6080 if (first_track < 0)
6093 int buf_size, write_moof = 1, moof_tracks = -1;
6102 write_moof =
i == first_track;
6196 unsigned int samples_in_chunk = 0;
6199 uint8_t *reformatted_data =
NULL;
6243 static const uint16_t packed_size[16] =
6244 {13, 14, 16, 18, 20, 21, 27, 32, 6, 0, 0, 0, 0, 0, 0, 1};
6247 while (
len <
size && samples_in_chunk < 100) {
6251 if (samples_in_chunk > 1) {
6252 av_log(
s,
AV_LOG_ERROR,
"fatal error, input is not a single packet, implement a AVParser for it\n");
6261 samples_in_chunk = 1;
6263 if (samples_in_chunk < 1) {
6305 "use the audio bitstream filter 'aac_adtstoasc' to fix it "
6306 "('-bsf:a aac_adtstoasc' option with ffmpeg)\n");
6404 int nal_size_length = (par->
extradata[4] & 0x3) + 1;
6407 int nal_size_length = (par->
extradata[21] & 0x3) + 1;
6492 "Track %d starts with a nonzero dts %"PRId64
", while the moov "
6493 "already has been written. Set the delay_moov flag to handle "
6551 reformatted_data ? reformatted_data +
offset
6557 if (
pkt->
data != reformatted_data)
6567 int64_t frag_duration = 0;
6598 memcpy(par->
extradata, side, side_size);
6656 uint8_t
data[2] = {0};
6723 const char *scheme_id_uri =
"https://aomedia.org/emsg/ID3";
6724 const char *
value =
"";
6741 avio_write(pb, scheme_id_uri, strlen(scheme_id_uri) + 1);
6767 int ret = mov_build_iamf_packet(
s, trk,
pkt);
6772 "for stream #%d\n", trk->
st->
index);
6842 "Packets without a valid presentation timestamp are "
6843 "not supported with packet squashing!\n");
6860 int reshuffle_ret,
ret;
6863 int expected_stride = ((trk->
par->
width * bpc + 15) >> 4)*2;
6865 if (reshuffle_ret < 0)
6866 return reshuffle_ret;
6884 if (reshuffle_ret) {
6901 static const uint8_t stub_header[] = {
6903 0x00, 0x00, 0x00, 0x01,
6905 0x00, 0x00, 0x00, 0x00,
6907 0x00, 0x00, 0x00, 0x00,
6908 0x00, 0x00, 0x00, 0x00,
6910 0x00, 0x00, 0x00, 0x00,
6913 0x00, 0x00, 0x00, 0x00,
6915 0x00, 0x00, 0x00, 0x0D,
6929 track->
tag =
MKTAG(
't',
'e',
'x',
't');
6938 memcpy(track->
par->
extradata, stub_header,
sizeof(stub_header));
6943 for (
i = 0;
i <
s->nb_chapters;
i++) {
6952 static const char encd[12] = {
6953 0x00, 0x00, 0x00, 0x0C,
6955 0x00, 0x00, 0x01, 0x00 };
6965 memcpy(
pkt->
data +
len + 2, encd,
sizeof(encd));
6998 track->
tag =
MKTAG(
't',
'm',
'c',
'd');
7073 if (!enabled[
i] &&
first[
i] >= 0)
7084 for (
int i = 0;
i <
s->nb_streams;
i++)
7085 s->streams[
i]->priv_data =
NULL;
7097 if (track->
tag ==
MKTAG(
'r',
't',
'p',
' '))
7135 r = (
rgb >> 16) & 0xFF;
7136 g = (
rgb >> 8) & 0xFF;
7143 return (y << 16) | (
cr << 8) |
cb;
7150 int have_palette = 0, have_size = 0;
7151 uint32_t palette[16];
7154 while (cur && *cur) {
7155 if (strncmp(
"palette:", cur, 8) == 0) {
7157 count = sscanf(cur + 8,
7158 "%06"PRIx32
", %06"PRIx32
", %06"PRIx32
", %06"PRIx32
", "
7159 "%06"PRIx32
", %06"PRIx32
", %06"PRIx32
", %06"PRIx32
", "
7160 "%06"PRIx32
", %06"PRIx32
", %06"PRIx32
", %06"PRIx32
", "
7161 "%06"PRIx32
", %06"PRIx32
", %06"PRIx32
", %06"PRIx32
"",
7162 &palette[ 0], &palette[ 1], &palette[ 2], &palette[ 3],
7163 &palette[ 4], &palette[ 5], &palette[ 6], &palette[ 7],
7164 &palette[ 8], &palette[ 9], &palette[10], &palette[11],
7165 &palette[12], &palette[13], &palette[14], &palette[15]);
7167 for (
i = 0;
i < count;
i++) {
7171 }
else if (!strncmp(
"size:", cur, 5)) {
7175 if (have_palette && have_size)
7177 cur += strcspn(cur,
"\n\r");
7178 cur += strspn(cur,
"\n\r");
7184 for (
i = 0;
i < 16;
i++) {
7201 int nb_audio_elements = 0, nb_mix_presentations = 0;
7204 for (
int i = 0;
i <
s->nb_stream_groups;
i++) {
7208 nb_audio_elements++;
7210 nb_mix_presentations++;
7213 if (!nb_audio_elements && !nb_mix_presentations)
7216 if (nb_audio_elements < 1 || nb_audio_elements > 2 || nb_mix_presentations < 1) {
7218 "one IAMF_MIX_PRESENTATION stream groups to write a IMAF track\n");
7226 for (
int i = 0;
i <
s->nb_stream_groups;
i++) {
7248 track->
tag =
MKTAG(
'i',
'a',
'm',
'f');
7269 #define IS_MODE(muxer, config) (CONFIG_ ## config ## _MUXER && !strcmp(#muxer, s->oformat->name))
7338 av_log(
s,
AV_LOG_WARNING,
"No meaningful edit list will be written when using empty_moov without delay_moov\n");
7358 "Sample interleaving in fragments is mutually exclusive with "
7359 "omit_tfhd_offset and separate_moof\n");
7375 if (
s->nb_streams > 2) {
7384 if (
s->nb_streams > 1) {
7388 av_log(
s,
AV_LOG_ERROR,
"Second stream for AVIF (alpha) output must have exactly one plane\n");
7396 for (
i = 0;
i <
s->nb_stream_groups;
i++) {
7407 "IAMF Audio Element\n", j);
7418 for (
i = 0;
i <
s->nb_streams;
i++) {
7438 for (
i = 0;
i <
s->nb_streams;
i++)
7453 for (
i = 0;
i <
s->nb_streams;
i++) {
7467 for (
i = 0;
i <
s->nb_streams;
i++) {
7471 "so timecode metadata are now ignored\n");
7509 ret = mov_init_iamf_track(
s);
7514 for (
int j = 0,
i = 0; j <
s->nb_streams; j++) {
7522 for (
i = 0;
i <
s->nb_streams;
i++) {
7542 "codec not currently supported in container\n",
7554 if (track->
tag ==
MKTAG(
'm',
'x',
'3',
'p') || track->
tag ==
MKTAG(
'm',
'x',
'3',
'n') ||
7555 track->
tag ==
MKTAG(
'm',
'x',
'4',
'p') || track->
tag ==
MKTAG(
'm',
'x',
'4',
'n') ||
7556 track->
tag ==
MKTAG(
'm',
'x',
'5',
'p') || track->
tag ==
MKTAG(
'm',
'x',
'5',
'n')) {
7561 track->
height = track->
tag >> 24 ==
'n' ? 486 : 576;
7566 av_log(
s,
AV_LOG_WARNING,
"Warning: some tools, like mp4split, assume a timescale of 10000000 for ISMV.\n");
7578 "WARNING codec timebase is very high. If duration is too long,\n"
7579 "file may not be playable by quicktime. Specify a shorter timebase\n"
7580 "or choose different container.\n");
7583 track->
tag ==
MKTAG(
'r',
'a',
'w',
' ')) {
7639 av_log(
s,
AV_LOG_ERROR,
"track %d: muxing mp3 at %dhz is not standard, to mux anyway set strict to -1\n",
7657 "%s in MP4 support is experimental, add "
7658 "'-strict %d' if you want to use it.\n",
7679 "Fragmentation is not currently supported for "
7680 "TTML in MP4/ISMV (track synchronization between "
7681 "subtitles and other media is not yet implemented)!\n");
7689 "ISMV style TTML support with the 'dfxp' tag in "
7690 "non-ISMV formats is not officially supported. Add "
7691 "'-strict unofficial' if you want to use it.\n");
7731 int ret, hint_track = 0, tmcd_track = 0, nb_tracks = mov->
nb_streams;
7737 hint_track = nb_tracks;
7745 tmcd_track = nb_tracks;
7795 trackj->
tag != track->
tag
7828 mov->
time += 0x7C25B080;
7846 "timecode",
NULL, 0);
7917 int i, moov_size, moov_size2;
7933 if (moov_size2 != moov_size)
8042 av_log(
s,
AV_LOG_INFO,
"Starting second pass: moving the moov atom to the beginning of the file\n");
8108 #if CONFIG_AVIF_MUXER
8113 int64_t pos_backup, extent_offsets[2];
8115 int buf_size, moov_size;
8153 if (extent_offsets[
i] != (uint32_t)extent_offsets[
i]) {
8166 #if CONFIG_TGP_MUXER || CONFIG_TG2_MUXER
8177 static const AVCodecTag *
const codec_3gp_tags_list[] = { codec_3gp_tags,
NULL };
8236 #if CONFIG_MP4_MUXER || CONFIG_PSP_MUXER
8266 #if CONFIG_AVIF_MUXER
8268 static const AVOption avif_options[] = {
8270 {
"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 },
8273 static const AVCodecTag codec_avif_tags[] = {
8277 static const AVCodecTag *
const codec_avif_tags_list[] = { codec_avif_tags,
NULL };
8279 static const AVClass mov_avif_muxer_class = {
8282 .option = avif_options,
8287 #if CONFIG_MOV_MUXER
8291 .p.extensions =
"mov",
8294 .p.video_codec = CONFIG_LIBX264_ENCODER ?
8314 #if CONFIG_TGP_MUXER
8318 .p.extensions =
"3gp",
8332 .p.codec_tag = codec_3gp_tags_list,
8338 #if CONFIG_MP4_MUXER
8342 .p.mime_type =
"video/mp4",
8343 .p.extensions =
"mp4",
8346 .p.video_codec = CONFIG_LIBX264_ENCODER ?
8358 .p.codec_tag = mp4_codec_tags_list,
8364 #if CONFIG_PSP_MUXER
8368 .p.extensions =
"mp4,psp",
8371 .p.video_codec = CONFIG_LIBX264_ENCODER ?
8383 .p.codec_tag = mp4_codec_tags_list,
8389 #if CONFIG_TG2_MUXER
8393 .p.extensions =
"3g2",
8407 .p.codec_tag = codec_3gp_tags_list,
8413 #if CONFIG_IPOD_MUXER
8417 .p.mime_type =
"video/mp4",
8418 .p.extensions =
"m4v,m4a,m4b",
8438 #if CONFIG_ISMV_MUXER
8442 .p.mime_type =
"video/mp4",
8443 .p.extensions =
"ismv,isma",
8464 #if CONFIG_F4V_MUXER
8468 .p.mime_type =
"application/f4v",
8469 .p.extensions =
"f4v",
8489 #if CONFIG_AVIF_MUXER
8493 .p.mime_type =
"image/avif",
8494 .p.extensions =
"avif",
8500 .write_trailer = avif_write_trailer,
8507 .p.codec_tag = codec_avif_tags_list,
8508 .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
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.
@ 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.
static int mov_write_emsg_tag(AVIOContext *pb, AVStream *st, AVPacket *pkt)
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)
struct MOVTrack::@359 vc1_info
#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
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
void avpriv_packet_list_free(PacketList *pkt_buf)
Wipe the list and unref all the packets in it.
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)
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.
@ 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[]
#define FF_OFMT_FLAG_ALLOW_FLUSH
This flag indicates that the muxer stores data internally and supports flushing 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 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)
#define AV_TIME_BASE
Internal time base represented as integer.
int block_align
Audio only.
struct eac3_info::@358 substream[1]
#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.
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 const struct @357 mov_pix_fmt_tags[]
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)
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).
@ FLAC_METADATA_TYPE_STREAMINFO
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