79 unsigned len,
const char *key)
83 short current, total = 0;
89 snprintf(buf,
sizeof(buf),
"%d", current);
91 snprintf(buf,
sizeof(buf),
"%d/%d", current, total);
99 unsigned len,
const char *key)
113 unsigned len,
const char *key)
122 unsigned len,
const char *key)
138 0x00C4,0x00C5,0x00C7,0x00C9,0x00D1,0x00D6,0x00DC,0x00E1,
139 0x00E0,0x00E2,0x00E4,0x00E3,0x00E5,0x00E7,0x00E9,0x00E8,
140 0x00EA,0x00EB,0x00ED,0x00EC,0x00EE,0x00EF,0x00F1,0x00F3,
141 0x00F2,0x00F4,0x00F6,0x00F5,0x00FA,0x00F9,0x00FB,0x00FC,
142 0x2020,0x00B0,0x00A2,0x00A3,0x00A7,0x2022,0x00B6,0x00DF,
143 0x00AE,0x00A9,0x2122,0x00B4,0x00A8,0x2260,0x00C6,0x00D8,
144 0x221E,0x00B1,0x2264,0x2265,0x00A5,0x00B5,0x2202,0x2211,
145 0x220F,0x03C0,0x222B,0x00AA,0x00BA,0x03A9,0x00E6,0x00F8,
146 0x00BF,0x00A1,0x00AC,0x221A,0x0192,0x2248,0x2206,0x00AB,
147 0x00BB,0x2026,0x00A0,0x00C0,0x00C3,0x00D5,0x0152,0x0153,
148 0x2013,0x2014,0x201C,0x201D,0x2018,0x2019,0x00F7,0x25CA,
149 0x00FF,0x0178,0x2044,0x20AC,0x2039,0x203A,0xFB01,0xFB02,
150 0x2021,0x00B7,0x201A,0x201E,0x2030,0x00C2,0x00CA,0x00C1,
151 0x00CB,0x00C8,0x00CD,0x00CE,0x00CF,0x00CC,0x00D3,0x00D4,
152 0xF8FF,0x00D2,0x00DA,0x00DB,0x00D9,0x0131,0x02C6,0x02DC,
153 0x00AF,0x02D8,0x02D9,0x02DA,0x00B8,0x02DD,0x02DB,0x02C7,
157 char *dst,
int dstlen)
160 char *
end = dst+dstlen-1;
163 for (i = 0; i <
len; i++) {
165 if (c < 0x80 && p < end)
227 char language[4] = { 0 };
228 char buf[200], place[100];
229 uint16_t langcode = 0;
230 double longitude, latitude, altitude;
231 const char *key =
"location";
233 if (len < 4 + 2 + 1 + 1 + 4 + 4 + 4) {
253 "loci too short (%u bytes left, need at least %d)\n", len, 12);
261 snprintf(buf,
sizeof(buf),
"%+08.4f%+09.4f", latitude, longitude);
266 if (*language && strcmp(language,
"und")) {
268 snprintf(key2,
sizeof(key2),
"%s-%s", key, language);
295 char key2[32], language[4] = {0};
297 const char *key =
NULL;
298 uint16_t langcode = 0;
299 uint32_t data_type = 0, str_size, str_size_alloc;
305 case MKTAG(
'@',
'P',
'R',
'M'): key =
"premiere_version"; raw = 1;
break;
306 case MKTAG(
'@',
'P',
'R',
'Q'): key =
"quicktime_version"; raw = 1;
break;
307 case MKTAG(
'X',
'M',
'P',
'_'):
308 if (c->
export_xmp) { key =
"xmp"; raw = 1; }
break;
309 case MKTAG(
'a',
'A',
'R',
'T'): key =
"album_artist";
break;
310 case MKTAG(
'a',
'k',
'I',
'D'): key =
"account_type";
312 case MKTAG(
'a',
'p',
'I',
'D'): key =
"account_id";
break;
313 case MKTAG(
'c',
'a',
't',
'g'): key =
"category";
break;
314 case MKTAG(
'c',
'p',
'i',
'l'): key =
"compilation";
316 case MKTAG(
'c',
'p',
'r',
't'): key =
"copyright";
break;
317 case MKTAG(
'd',
'e',
's',
'c'): key =
"description";
break;
318 case MKTAG(
'd',
'i',
's',
'k'): key =
"disc";
320 case MKTAG(
'e',
'g',
'i',
'd'): key =
"episode_uid";
322 case MKTAG(
'F',
'I',
'R',
'M'): key =
"firmware"; raw = 1;
break;
323 case MKTAG(
'g',
'n',
'r',
'e'): key =
"genre";
325 case MKTAG(
'h',
'd',
'v',
'd'): key =
"hd_video";
327 case MKTAG(
'H',
'M',
'M',
'T'):
329 case MKTAG(
'k',
'e',
'y',
'w'): key =
"keywords";
break;
330 case MKTAG(
'l',
'd',
'e',
's'): key =
"synopsis";
break;
331 case MKTAG(
'l',
'o',
'c',
'i'):
333 case MKTAG(
'p',
'c',
's',
't'): key =
"podcast";
335 case MKTAG(
'p',
'g',
'a',
'p'): key =
"gapless_playback";
337 case MKTAG(
'p',
'u',
'r',
'd'): key =
"purchase_date";
break;
338 case MKTAG(
'r',
't',
'n',
'g'): key =
"rating";
340 case MKTAG(
's',
'o',
'a',
'a'): key =
"sort_album_artist";
break;
341 case MKTAG(
's',
'o',
'a',
'l'): key =
"sort_album";
break;
342 case MKTAG(
's',
'o',
'a',
'r'): key =
"sort_artist";
break;
343 case MKTAG(
's',
'o',
'c',
'o'): key =
"sort_composer";
break;
344 case MKTAG(
's',
'o',
'n',
'm'): key =
"sort_name";
break;
345 case MKTAG(
's',
'o',
's',
'n'): key =
"sort_show";
break;
346 case MKTAG(
's',
't',
'i',
'k'): key =
"media_type";
348 case MKTAG(
't',
'r',
'k',
'n'): key =
"track";
350 case MKTAG(
't',
'v',
'e',
'n'): key =
"episode_id";
break;
351 case MKTAG(
't',
'v',
'e',
's'): key =
"episode_sort";
353 case MKTAG(
't',
'v',
'n',
'n'): key =
"network";
break;
354 case MKTAG(
't',
'v',
's',
'h'): key =
"show";
break;
355 case MKTAG(
't',
'v',
's',
'n'): key =
"season_number";
357 case MKTAG(0xa9,
'A',
'R',
'T'): key =
"artist";
break;
358 case MKTAG(0xa9,
'P',
'R',
'D'): key =
"producer";
break;
359 case MKTAG(0xa9,
'a',
'l',
'b'): key =
"album";
break;
360 case MKTAG(0xa9,
'a',
'u',
't'): key =
"artist";
break;
361 case MKTAG(0xa9,
'c',
'h',
'p'): key =
"chapter";
break;
362 case MKTAG(0xa9,
'c',
'm',
't'): key =
"comment";
break;
363 case MKTAG(0xa9,
'c',
'o',
'm'): key =
"composer";
break;
364 case MKTAG(0xa9,
'c',
'p',
'y'): key =
"copyright";
break;
365 case MKTAG(0xa9,
'd',
'a',
'y'): key =
"date";
break;
366 case MKTAG(0xa9,
'd',
'i',
'r'): key =
"director";
break;
367 case MKTAG(0xa9,
'd',
'i',
's'): key =
"disclaimer";
break;
368 case MKTAG(0xa9,
'e',
'd',
'1'): key =
"edit_date";
break;
369 case MKTAG(0xa9,
'e',
'n',
'c'): key =
"encoder";
break;
370 case MKTAG(0xa9,
'f',
'm',
't'): key =
"original_format";
break;
371 case MKTAG(0xa9,
'g',
'e',
'n'): key =
"genre";
break;
372 case MKTAG(0xa9,
'g',
'r',
'p'): key =
"grouping";
break;
373 case MKTAG(0xa9,
'h',
's',
't'): key =
"host_computer";
break;
374 case MKTAG(0xa9,
'i',
'n',
'f'): key =
"comment";
break;
375 case MKTAG(0xa9,
'l',
'y',
'r'): key =
"lyrics";
break;
376 case MKTAG(0xa9,
'm',
'a',
'k'): key =
"make";
break;
377 case MKTAG(0xa9,
'm',
'o',
'd'): key =
"model";
break;
378 case MKTAG(0xa9,
'n',
'a',
'm'): key =
"title";
break;
379 case MKTAG(0xa9,
'o',
'p',
'e'): key =
"original_artist";
break;
380 case MKTAG(0xa9,
'p',
'r',
'd'): key =
"producer";
break;
381 case MKTAG(0xa9,
'p',
'r',
'f'): key =
"performers";
break;
382 case MKTAG(0xa9,
'r',
'e',
'q'): key =
"playback_requirements";
break;
383 case MKTAG(0xa9,
's',
'r',
'c'): key =
"original_source";
break;
384 case MKTAG(0xa9,
's',
't',
'3'): key =
"subtitle";
break;
385 case MKTAG(0xa9,
's',
'w',
'r'): key =
"encoder";
break;
386 case MKTAG(0xa9,
't',
'o',
'o'): key =
"encoder";
break;
387 case MKTAG(0xa9,
't',
'r',
'k'): key =
"track";
break;
388 case MKTAG(0xa9,
'u',
'r',
'l'): key =
"URL";
break;
389 case MKTAG(0xa9,
'w',
'r',
'n'): key =
"warning";
break;
390 case MKTAG(0xa9,
'w',
'r',
't'): key =
"composer";
break;
391 case MKTAG(0xa9,
'x',
'y',
'z'): key =
"location";
break;
397 if (tag ==
MKTAG(
'd',
'a',
't',
'a') && data_size <= atom.
size) {
400 str_size = data_size - 16;
403 if (atom.
type ==
MKTAG(
'c',
'o',
'v',
'r')) {
411 if (index < c->meta_keys_count && index > 0) {
415 "The index of 'data' is out of range: %"PRId32
" < 1 or >= %d.\n",
422 if (str_size > atom.
size) {
432 str_size = atom.
size;
441 if (atom.
size < 0 || str_size >= INT_MAX/2)
446 num = (data_type >= 21 && data_type <= 23);
447 str_size_alloc = (num ? 512 : (raw ? str_size : str_size * 2)) + 1;
453 parse(c, pb, str_size, key);
455 if (!raw && (data_type == 3 || (data_type == 0 && (langcode < 0x400 || langcode == 0x7fff)))) {
457 }
else if (data_type == 21) {
461 else if (str_size == 2)
463 else if (str_size == 3)
465 else if (str_size == 4)
467 if (
snprintf(str, str_size_alloc,
"%d", val) >= str_size_alloc) {
469 "Failed to store the number (%d) in string.\n", val);
473 }
else if (data_type == 22) {
474 unsigned int val = 0;
477 else if (str_size == 2)
479 else if (str_size == 3)
481 else if (str_size == 4)
483 if (
snprintf(str, str_size_alloc,
"%u", val) >= str_size_alloc) {
485 "Failed to store the number (%u) in string.\n", val);
489 }
else if (data_type == 23 && str_size >= 4) {
491 if (
snprintf(str, str_size_alloc,
"%f", val) >= str_size_alloc) {
493 "Failed to store the float32 number (%f) in string.\n", val);
507 if (*language && strcmp(language,
"und")) {
508 snprintf(key2,
sizeof(key2),
"%s-%s", key, language);
511 if (!strcmp(key,
"encoder")) {
512 int major, minor, micro;
513 if (sscanf(str,
"HandBrake %d.%d.%d", &major, &minor, µ) == 3) {
526 int i, nb_chapters, str_len,
version;
533 if ((atom.
size -= 5) < 0)
542 for (i = 0; i < nb_chapters; i++) {
549 if ((atom.
size -= 9+str_len) < 0)
561 #define MIN_DATA_ENTRY_BOX_SIZE 12
577 entries >= UINT_MAX /
sizeof(*sc->
drefs))
587 for (i = 0; i < entries; i++) {
598 if (dref->
type ==
MKTAG(
'a',
'l',
'i',
's') && size > 150) {
600 uint16_t volume_len,
len;
607 volume_len =
FFMIN(volume_len, 27);
611 dref->
volume[volume_len] = 0;
617 len =
FFMIN(len, 63);
634 for (type = 0; type != -1 &&
avio_tell(pb) < next; ) {
653 if (len > volume_len && !strncmp(dref->
path, dref->
volume, volume_len)) {
655 memmove(dref->
path, dref->
path+volume_len, len);
659 for (j = len - 1; j >= 0; j--) {
660 if (dref->
path[j] == 0)
665 for (j = 0; j <
len; j++)
666 if (dref->
path[j] ==
':' || dref->
path[j] == 0)
669 }
else if (type == 0) {
681 for (j = 0; j <
len; j++)
682 if (dref->
dir[j] ==
':')
719 if (type ==
MKTAG(
'm',
'd',
't',
'a')) {
727 if (type ==
MKTAG(
'v',
'i',
'd',
'e'))
729 else if (type ==
MKTAG(
's',
'o',
'u',
'n'))
731 else if (type ==
MKTAG(
'm',
'1',
'a',
' '))
733 else if ((type ==
MKTAG(
's',
'u',
'b',
'p')) || (type ==
MKTAG(
'c',
'l',
'c',
'p')))
740 title_size = atom.
size - 24;
741 if (title_size > 0) {
742 if (title_size >
FFMIN(INT_MAX, SIZE_MAX-1))
753 title_str[title_size] = 0;
755 int off = (!c->
isom && title_str[0] == title_size - 1);
795 int ac3info, acmod, lfeon, bsmod;
807 bsmod = (ac3info >> 14) & 0x7;
808 acmod = (ac3info >> 11) & 0x7;
809 lfeon = (ac3info >> 10) & 0x1;
818 #if FF_API_LAVF_AVCTX
820 st->codec->audio_service_type = *ast;
831 int eac3info, acmod, lfeon, bsmod;
847 bsmod = (eac3info >> 12) & 0x1f;
848 acmod = (eac3info >> 9) & 0x7;
849 lfeon = (eac3info >> 8) & 0x1;
858 #if FF_API_LAVF_AVCTX
860 st->codec->audio_service_type = *ast;
869 const uint32_t ddts_size = 20;
872 uint32_t frame_duration_code = 0;
873 uint32_t channel_layout_code = 0;
880 if (
avio_read(pb, buf, ddts_size) < ddts_size) {
900 frame_duration_code =
get_bits(&gb, 2);
902 channel_layout_code =
get_bits(&gb, 16);
905 (frame_duration_code == 0) ? 512 :
906 (frame_duration_code == 1) ? 1024 :
907 (frame_duration_code == 2) ? 2048 :
908 (frame_duration_code == 3) ? 4096 : 0;
910 if (channel_layout_code > 0xff) {
973 "sample aspect ratio already set to %d:%d, ignoring 'pasp' atom (%d:%d)\n",
976 }
else if (den != 0) {
992 #define DRM_BLOB_SIZE 56
1001 uint8_t calculated_checksum[20];
1026 for (i = 0; i < 20; i++)
1031 if (!activation_bytes) {
1063 if (memcmp(calculated_checksum, file_checksum, 20)) {
1070 for (i = 0; i < 4; i++) {
1072 if (activation_bytes[i] != output[3 - i]) {
1078 memcpy(c->
file_key, output + 8, 16);
1079 memcpy(input, output + 26, 16);
1096 unsigned char iv[16];
1110 int comp_brand_size;
1111 char* comp_brands_str;
1117 if (strcmp(type,
"qt "))
1124 comp_brand_size = atom.
size - 8;
1125 if (comp_brand_size < 0)
1127 comp_brands_str =
av_malloc(comp_brand_size + 1);
1128 if (!comp_brands_str)
1136 comp_brands_str[comp_brand_size] = 0;
1172 "read the mfra (may be a live ismv)\n");
1176 "seekable, can not look for mfra\n");
1187 if(time >= 2082844800)
1190 if ((int64_t)(time * 1000000ULL) / 1000000 != time) {
1204 char language[4] = {0};
1206 int64_t creation_time;
1251 int64_t creation_time;
1282 for (i = 0; i < 3; i++) {
1310 if (little_endian == 1) {
1334 char color_parameter_type[5] = { 0 };
1345 if (strncmp(color_parameter_type,
"nclx", 4) &&
1346 strncmp(color_parameter_type,
"nclc", 4)) {
1348 color_parameter_type);
1357 "%s: pri %d trc %d matrix %d",
1358 color_parameter_type, color_primaries, color_trc, color_matrix);
1360 if (!strncmp(color_parameter_type,
"nclx", 4)) {
1387 unsigned mov_field_order;
1396 if ((mov_field_order & 0xFF00) == 0x0100)
1398 else if ((mov_field_order & 0xFF00) == 0x0200) {
1399 switch (mov_field_order & 0xFF) {
1422 if (size > INT_MAX || (uint64_t)atom.
size > INT_MAX)
1436 int64_t result = atom.
size;
1445 }
else if (err < atom.
size) {
1459 uint64_t original_size;
1534 if (cid == 0xd4d || cid == 0xd4e)
1544 if (num <= 0 || den <= 0)
1548 if (den >= INT_MAX / 2)
1567 uint64_t original_size;
1572 if (atom.
size == 16) {
1577 if (length == atom.
size) {
1579 switch (range_value) {
1620 if ((uint64_t)atom.
size > (1<<30))
1631 }
else if (atom.
size > 8) {
1639 if ( (buffer & 0xFFFFFFFF) ==
MKBETAG(
'f',
'r',
'm',
'a')
1640 && buffer >> 32 <= atom.
size
1641 && buffer >> 32 >= 8) {
1645 #define ALAC_EXTRADATA_SIZE 36
1678 if ((uint64_t)atom.
size > (1<<30))
1681 if (atom.
size >= 10) {
1687 if (type ==
MKTAG(
'f',
'i',
'e',
'l') && size == atom.
size)
1712 if (atom.
size >= (1<<28) || atom.
size < 7)
1716 if ((profile_level & 0xf0) != 0xc0)
1740 if (atom.
size <= 40)
1744 if ((uint64_t)atom.
size > (1<<30))
1760 unsigned int i, entries;
1784 if (atom.
type ==
MKTAG(
's',
't',
'c',
'o'))
1787 else if (atom.
type ==
MKTAG(
'c',
'o',
'6',
'4'))
1820 ((format & 0xFFFF) ==
'm' + (
's' << 8) ||
1821 (format & 0xFFFF) ==
'T' + (
'S' << 8)))
1828 format && format !=
MKTAG(
'm',
'p',
'4',
's')) {
1851 uint8_t codec_name[32] = { 0 };
1884 if (!memcmp(codec_name,
"Planar Y'CbCr 8-bit 4:2:0", 25)) {
1891 !memcmp(codec_name,
"Sorenson H263", 13))
1907 int bits_per_sample,
flags;
1926 (compatible_brands && strstr(compatible_brands->
value,
"qt "))) {
1933 }
else if (version == 2) {
1948 if (version == 0 || (version == 1 && sc->
audio_cid != -2)) {
2007 if (bits_per_sample) {
2032 y = (ycbcr >> 16) & 0xFF;
2033 cr = (ycbcr >> 8) & 0xFF;
2036 b = av_clip_uint8((1164 * (y - 16) + 2018 * (cb - 128)) / 1000);
2037 g = av_clip_uint8((1164 * (y - 16) - 813 * (cr - 128) - 391 * (cb - 128)) / 1000);
2038 r = av_clip_uint8((1164 * (y - 16) + 1596 * (cr - 128) ) / 1000);
2040 return (r << 16) | (g << 8) | b;
2045 char buf[256] = {0};
2053 snprintf(buf,
sizeof(buf),
"size: %dx%d\n",
2057 for (i = 0; i < 16; i++) {
2058 uint32_t yuv =
AV_RB32(src + i * 4);
2061 av_strlcatf(buf,
sizeof(buf),
"%06"PRIx32
"%s", rgba, i != 15 ?
", " :
"");
2064 if (
av_strlcat(buf,
"\n",
sizeof(buf)) >=
sizeof(buf))
2085 if ((
int)size != size)
2098 #if FF_API_LAVF_AVCTX
2109 #if FF_API_LAVF_AVCTX
2119 if (format ==
AV_RB32(
"name") && (int64_t)size >= (int64_t)len + 18) {
2121 if (str_size > 0 && size >= (
int)str_size + 26) {
2122 char *reel_name =
av_malloc(str_size + 1);
2126 reel_name[str_size] = 0;
2128 if (*reel_name == 0) {
2153 #if CONFIG_DV_DEMUXER
2223 int codec_tag,
int format,
2229 (codec_tag != format &&
2237 : codec_tag !=
MKTAG(
'j',
'p',
'e',
'g')))) {
2254 int pseudo_stream_id;
2261 for (pseudo_stream_id = 0;
2263 pseudo_stream_id++) {
2266 int ret, dref_id = 1;
2276 }
else if (size <= 7) {
2278 "invalid size %"PRId64
" in stsd\n", size);
2293 "size=%"PRId64
" 4CC=%s codec_type=%d\n", size,
2321 }
else if (a.
size > 0)
2403 unsigned int i, entries;
2414 if ((uint64_t)entries * 12 + 4 > atom.
size)
2429 for (i = 0; i < entries && !pb->
eof_reached; i++) {
2443 #define mov_stsc_index_valid(index, count) ((index) < (count) - 1)
2462 unsigned i, entries;
2480 for (i = 0; i < entries && !pb->
eof_reached; i++) {
2496 unsigned int i, entries;
2519 if (entries >= UINT_MAX /
sizeof(
int))
2527 for (i = 0; i < entries && !pb->
eof_reached; i++) {
2543 unsigned int i, entries, sample_size, field_size, num_bytes;
2556 if (atom.
type ==
MKTAG(
's',
't',
's',
'z')) {
2575 if (field_size != 4 && field_size != 8 && field_size != 16 && field_size != 32) {
2582 if (entries >= (UINT_MAX - 4) / field_size)
2592 num_bytes = (entries*field_size+4)>>3;
2609 for (i = 0; i < entries && !pb->
eof_reached; i++) {
2628 unsigned int i, entries;
2630 int64_t total_sample_count=0;
2652 for (i = 0; i < entries && !pb->
eof_reached; i++) {
2653 int sample_duration;
2659 if (sample_count < 0) {
2667 sample_count, sample_duration);
2671 && sample_count == 1
2672 && total_sample_count > 100
2673 && sample_duration/10 > duration / total_sample_count)
2674 sample_duration = duration / total_sample_count;
2675 duration+=(int64_t)sample_duration*sample_count;
2676 total_sample_count+=sample_count;
2697 if (duration == INT_MIN) {
2709 unsigned int i, entries, ctts_count = 0;
2724 if (entries >= UINT_MAX /
sizeof(*sc->
ctts_data))
2731 for (i = 0; i < entries && !pb->
eof_reached; i++) {
2737 "ignoring CTTS entry with count=%d duration=%d\n",
2749 if (
FFNABS(duration) < -(1<<28) && i+2<entries) {
2774 unsigned int i, entries;
2776 uint32_t grouping_type;
2786 if (grouping_type !=
MKTAG(
'r',
'a',
'p',
' '))
2802 for (i = 0; i < entries && !pb->
eof_reached; i++) {
2817 unsigned int edit_list_index,
2818 int64_t *edit_list_media_time,
2819 int64_t *edit_list_duration,
2820 int64_t global_timescale)
2825 *edit_list_media_time = msc->
elst_data[edit_list_index].
time;
2829 if (global_timescale == 0) {
2897 const size_t requested_size =
2914 ie= &entries[
index];
2929 int64_t* frame_duration_buffer,
2930 int frame_duration_buffer_size) {
2932 av_assert0(end_index >= 0 && end_index <= st->nb_index_entries);
2933 for (i = 0; i < frame_duration_buffer_size; i++) {
2934 end_ts -= frame_duration_buffer[frame_duration_buffer_size - 1 - i];
2947 const size_t min_size_needed = (*ctts_count + 1) *
sizeof(
MOVStts);
2948 const size_t requested_size =
2949 min_size_needed > *allocated_size ?
2950 FFMAX(min_size_needed, 2 * (*allocated_size)) :
2953 if((
unsigned)(*ctts_count) + 1 >= UINT_MAX /
sizeof(
MOVStts))
2956 ctts_buf_new =
av_fast_realloc(*ctts_data, allocated_size, requested_size);
2961 *ctts_data = ctts_buf_new;
2966 *ctts_count = (*ctts_count) + 1;
3008 if (range_size > current_sample) {
3012 current_sample -= range_size;
3030 int64_t ctts_index_old = 0;
3031 int64_t ctts_sample_old = 0;
3033 int64_t edit_list_media_time = 0;
3034 int64_t edit_list_duration = 0;
3035 int64_t frame_duration = 0;
3036 int64_t edit_list_dts_counter = 0;
3037 int64_t edit_list_dts_entry_end = 0;
3038 int64_t edit_list_start_ctts_sample = 0;
3040 int64_t edit_list_index = 0;
3042 int64_t index_ctts_count;
3044 unsigned int ctts_allocated_size = 0;
3045 int64_t start_dts = 0;
3046 int64_t edit_list_media_time_dts = 0;
3047 int64_t edit_list_start_encountered = 0;
3048 int64_t search_timestamp = 0;
3049 int64_t* frame_duration_buffer =
NULL;
3050 int num_discarded_begin = 0;
3051 int first_non_zero_audio_edit = -1;
3052 int packet_skip_samples = 0;
3082 edit_list_dts_entry_end -= msc->
dts_shift;
3085 if (ctts_data_old && ctts_count_old > 0) {
3086 edit_list_dts_entry_end -= ctts_data_old[0].
duration;
3090 start_dts = edit_list_dts_entry_end;
3094 av_log(mov->
fc,
AV_LOG_DEBUG,
"Processing st: %d, edit list %"PRId64
" - media time: %"PRId64
", duration: %"PRId64
"\n",
3095 st->
index, edit_list_index, edit_list_media_time, edit_list_duration);
3097 edit_list_dts_counter = edit_list_dts_entry_end;
3098 edit_list_dts_entry_end += edit_list_duration;
3099 num_discarded_begin = 0;
3100 if (edit_list_media_time == -1) {
3107 if (first_non_zero_audio_edit < 0) {
3108 first_non_zero_audio_edit = 1;
3110 first_non_zero_audio_edit = 0;
3113 if (first_non_zero_audio_edit > 0)
3118 edit_list_media_time_dts = edit_list_media_time;
3120 edit_list_media_time_dts -= msc->
dts_shift;
3127 search_timestamp = edit_list_media_time_dts;
3138 "st: %d edit list: %"PRId64
" Missing key frame while searching for timestamp: %"PRId64
"\n",
3139 st->
index, edit_list_index, search_timestamp);
3144 "st: %d edit list %"PRId64
" Cannot find an index entry before timestamp: %"PRId64
".\n"
3145 "Rounding edit list media time to zero.\n",
3146 st->
index, edit_list_index, search_timestamp);
3148 edit_list_media_time = 0;
3151 current = e_old +
index;
3154 ctts_sample_old = 0;
3157 for (index_ctts_count = 0; index_ctts_count <
index; index_ctts_count++) {
3158 if (ctts_data_old && ctts_index_old < ctts_count_old) {
3160 if (ctts_data_old[ctts_index_old].
count == ctts_sample_old) {
3162 ctts_sample_old = 0;
3167 edit_list_start_ctts_sample = ctts_sample_old;
3170 edit_list_start_encountered = 0;
3171 for (; current < e_old_end; current++, index++) {
3173 frame_duration = (current + 1 < e_old_end) ?
3174 ((current + 1)->timestamp - current->
timestamp) : edit_list_duration;
3176 flags = current->
flags;
3181 if (ctts_data_old && ctts_index_old < ctts_count_old) {
3182 av_log(mov->
fc,
AV_LOG_DEBUG,
"shifted frame pts, curr_cts: %"PRId64
" @ %"PRId64
", ctts: %d, ctts_count: %"PRId64
"\n",
3183 curr_cts, ctts_index_old, ctts_data_old[ctts_index_old].
duration, ctts_count_old);
3184 curr_cts += ctts_data_old[ctts_index_old].
duration;
3186 if (ctts_sample_old == ctts_data_old[ctts_index_old].
count) {
3188 &ctts_allocated_size,
3189 ctts_data_old[ctts_index_old].
count - edit_list_start_ctts_sample,
3190 ctts_data_old[ctts_index_old].
duration) == -1) {
3193 ctts_data_old[ctts_index_old].
count - edit_list_start_ctts_sample,
3194 ctts_data_old[ctts_index_old].
duration);
3198 ctts_sample_old = 0;
3199 edit_list_start_ctts_sample = 0;
3203 if (curr_cts < edit_list_media_time || curr_cts >= (edit_list_duration + edit_list_media_time)) {
3205 curr_cts < edit_list_media_time && curr_cts + frame_duration > edit_list_media_time &&
3206 first_non_zero_audio_edit > 0) {
3207 packet_skip_samples = edit_list_media_time - curr_cts;
3211 edit_list_dts_counter -= packet_skip_samples;
3212 if (edit_list_start_encountered == 0) {
3213 edit_list_start_encountered = 1;
3216 if (frame_duration_buffer) {
3218 frame_duration_buffer, num_discarded_begin);
3223 av_log(mov->
fc,
AV_LOG_DEBUG,
"skip %d audio samples from curr_cts: %"PRId64
"\n", packet_skip_samples, curr_cts);
3226 av_log(mov->
fc,
AV_LOG_DEBUG,
"drop a frame at curr_cts: %"PRId64
" @ %"PRId64
"\n", curr_cts, index);
3229 num_discarded_begin++;
3230 frame_duration_buffer =
av_realloc(frame_duration_buffer,
3231 num_discarded_begin *
sizeof(int64_t));
3232 if (!frame_duration_buffer) {
3236 frame_duration_buffer[num_discarded_begin - 1] = frame_duration;
3245 }
else if (edit_list_start_encountered == 0) {
3246 edit_list_start_encountered = 1;
3251 frame_duration_buffer, num_discarded_begin);
3263 if (current_index_range < msc->index_ranges || index != current_index_range->
end) {
3264 current_index_range++;
3267 current_index_range->
end = index + 1;
3270 if (edit_list_start_encountered > 0) {
3271 edit_list_dts_counter = edit_list_dts_counter + frame_duration;
3275 if (((curr_cts + frame_duration) >= (edit_list_duration + edit_list_media_time)) &&
3278 if (ctts_data_old && ctts_sample_old != 0) {
3280 &ctts_allocated_size,
3281 ctts_sample_old - edit_list_start_ctts_sample,
3282 ctts_data_old[ctts_index_old].
duration) == -1) {
3284 ctts_index_old, ctts_sample_old - edit_list_start_ctts_sample,
3285 ctts_data_old[ctts_index_old].
duration);
3294 st->
duration = edit_list_dts_entry_end - start_dts;
3302 current_index_range++;
3303 current_index_range->
start = 0;
3304 current_index_range->
end = 0;
3311 int64_t current_offset;
3312 int64_t current_dts = 0;
3313 unsigned int stts_index = 0;
3314 unsigned int stsc_index = 0;
3315 unsigned int stss_index = 0;
3316 unsigned int stps_index = 0;
3318 uint64_t stream_size = 0;
3321 int i, edit_start_index = 0, multiple_edits = 0;
3322 int64_t empty_duration = 0;
3327 if (i == 0 && e->
time == -1) {
3331 edit_start_index = 1;
3332 }
else if (i == edit_start_index && e->
time >= 0) {
3333 start_time = e->
time;
3341 "Use -advanced_editlist to correctly decode otherwise "
3342 "a/v desync might occur\n");
3345 if ((empty_duration || start_time) && mov->
time_scale > 0) {
3361 unsigned int current_sample = 0;
3362 unsigned int stts_sample = 0;
3363 unsigned int sample_size;
3365 unsigned int rap_group_index = 0;
3366 unsigned int rap_group_sample = 0;
3367 int64_t last_dts = 0;
3368 int64_t dts_correction = 0;
3373 last_dts = current_dts;
3420 if (rap_group_present && rap_group_index < sc->rap_group_count) {
3423 if (++rap_group_sample == sc->
rap_group[rap_group_index].
count) {
3424 rap_group_sample = 0;
3430 && !rap_group_present
3439 if (sample_size > 0x3FFFFFFF) {
3444 e->
pos = current_offset;
3446 e->
size = sample_size;
3449 av_log(mov->
fc,
AV_LOG_TRACE,
"AVIndex stream %d, sample %u, offset %"PRIx64
", dts %"PRId64
", "
3450 "size %u, distance %u, keyframe %d\n", st->
index, current_sample,
3451 current_offset, current_dts, sample_size, distance, keyframe);
3456 current_offset += sample_size;
3457 stream_size += sample_size;
3463 "Invalid SampleDelta %d in STTS, at %d st:%d\n",
3470 if (!dts_correction || current_dts + dts_correction > last_dts) {
3471 current_dts += dts_correction;
3475 dts_correction += current_dts - last_dts - 1;
3476 current_dts = last_dts + 1;
3478 last_dts = current_dts;
3491 unsigned chunk_samples, total = 0;
3495 unsigned count, chunk_count;
3508 count = (chunk_samples+samples-1) / samples;
3510 count = (chunk_samples+1023) / 1024;
3517 total += chunk_count *
count;
3539 while (chunk_samples > 0) {
3541 unsigned size, samples;
3545 "Zero bytes per frame, but %d samples per frame",
3559 samples =
FFMIN(1024, chunk_samples);
3568 if (size > 0x3FFFFFFF) {
3573 e->
pos = current_offset;
3579 "size %u, duration %u\n", st->
index, i, current_offset, current_dts,
3582 current_offset +=
size;
3583 current_dts += samples;
3584 chunk_samples -= samples;
3605 av_url_split(src_proto,
sizeof(src_proto), src_auth,
sizeof(src_auth), src_host,
sizeof(src_host), &src_port,
NULL, 0, src);
3606 av_url_split(ref_proto,
sizeof(ref_proto), ref_auth,
sizeof(ref_auth), ref_host,
sizeof(ref_host), &ref_port,
NULL, 0, ref);
3608 if (strlen(src) == 0) {
3610 }
else if (strlen(src_auth) + 1 >=
sizeof(src_auth) ||
3611 strlen(ref_auth) + 1 >=
sizeof(ref_auth) ||
3612 strlen(src_host) + 1 >=
sizeof(src_host) ||
3613 strlen(ref_host) + 1 >=
sizeof(ref_host)) {
3615 }
else if (strcmp(src_proto, ref_proto) ||
3616 strcmp(src_auth, ref_auth) ||
3617 strcmp(src_host, ref_host) ||
3618 src_port != ref_port) {
3629 char filename[1025];
3630 const char *src_path;
3634 src_path = strrchr(src,
'/');
3641 for (i = 0, l = strlen(ref->
path) - 1; l >= 0; l--)
3642 if (ref->
path[l] ==
'/') {
3650 if (i == ref->
nlvl_to - 1 && src_path - src <
sizeof(filename)) {
3651 memcpy(filename, src, src_path - src);
3652 filename[src_path -
src] = 0;
3655 av_strlcat(filename,
"../",
sizeof(filename));
3663 "Reference with mismatching origin, %s not tried for security reasons, "
3664 "set demuxer option use_absolute_path to allow it anyway\n",
3669 if(strstr(ref->
path + l + 1,
"..") ||
3670 strstr(ref->
path + l + 1,
":") ||
3671 (ref->
nlvl_from > 1 && same_origin < 0) ||
3672 (filename[0] ==
'/' && src_path == src))
3676 if (strlen(filename) + 1 ==
sizeof(filename))
3683 "this is a possible security issue\n");
3688 "Absolute path %s not tried for security reasons, "
3689 "set demuxer option use_absolute_path to allow absolute paths\n",
3713 if (!st)
return AVERROR(ENOMEM);
3716 if (!sc)
return AVERROR(ENOMEM);
3747 "stream %d, error opening alias: path='%s', dir='%s', "
3748 "filename='%s', volume='%s', nlvl_from=%d, nlvl_to=%d\n",
3753 "Skipped opening external track: "
3754 "stream %d, alias: path='%s', dir='%s', "
3755 "filename='%s', volume='%s', nlvl_from=%d, nlvl_to=%d."
3756 "Set enable_drefs to allow this.\n",
3773 #if FF_API_R_FRAME_RATE
3789 #if CONFIG_H261_DECODER
3792 #if CONFIG_H263_DECODER
3795 #if CONFIG_MPEG4_DECODER
3841 if (count > UINT_MAX /
sizeof(*c->
meta_keys) - 1) {
3843 "The 'keys' atom with the invalid key count: %"PRIu32
"\n", count);
3852 for (i = 1; i <=
count; ++i) {
3857 "The key# %"PRIu32
" in meta has invalid size:"
3858 "%"PRIu32
"\n", i, key_size);
3862 if (type !=
MKTAG(
'm',
'd',
't',
'a')) {
3888 for (i = 0; i < 3; i++) {
3899 if (len < 12 || len - 12 > end -
avio_tell(pb))
3903 if (tag ==
MKTAG(
'm',
'e',
'a',
'n'))
3905 else if (tag ==
MKTAG(
'n',
'a',
'm',
'e'))
3907 else if (tag ==
MKTAG(
'd',
'a',
't',
'a') && len > 4) {
3925 if (mean && key && val) {
3926 if (strcmp(key,
"iTunSMPB") == 0) {
3927 int priming, remainder, samples;
3928 if(sscanf(val,
"%*X %X %X %X", &priming, &remainder, &samples) == 3){
3929 if(priming>0 && priming<16384)
3933 if (strcmp(key,
"cdec") != 0) {
3940 "Unhandled or malformed custom metadata of size %"PRId64
"\n", atom.
size);
3952 while (atom.
size > 8) {
3955 if (tag ==
MKTAG(
'h',
'd',
'l',
'r')) {
3965 #define IS_MATRIX_IDENT(matrix) \
3966 ( (matrix)[0][0] == (1 << 16) && \
3967 (matrix)[1][1] == (1 << 16) && \
3968 (matrix)[2][2] == (1 << 30) && \
3969 !(matrix)[0][1] && !(matrix)[0][2] && \
3970 !(matrix)[1][0] && !(matrix)[1][2] && \
3971 !(matrix)[2][0] && !(matrix)[2][1])
3978 int display_matrix[3][3];
3979 int res_display_matrix[3][3] = { { 0 } };
4018 for (i = 0; i < 3; i++) {
4026 sc->
width = width >> 16;
4027 sc->
height = height >> 16;
4030 for (i = 0; i < 3; i++) {
4031 const int sh[3] = { 16, 16, 30 };
4032 for (j = 0; j < 3; j++) {
4033 for (e = 0; e < 3; e++) {
4034 res_display_matrix[i][j] +=
4035 ((int64_t) display_matrix[i][e] *
4050 for (i = 0; i < 3; i++)
4051 for (j = 0; j < 3; j++)
4056 if (!
isnan(rotate)) {
4057 char rotate_buf[64];
4061 snprintf(rotate_buf,
sizeof(rotate_buf),
"%g", rotate);
4070 double disp_transform[2];
4072 for (i = 0; i < 2; i++)
4076 if (disp_transform[0] > 0 && disp_transform[1] > 0 &&
4077 disp_transform[0] < (1<<24) && disp_transform[1] < (1<<24) &&
4078 fabs((disp_transform[0] / disp_transform[1]) - 1.0) > 0.01)
4080 disp_transform[0] / disp_transform[1],
4091 int flags, track_id, i, found = 0;
4127 "found fragment index for track %u\n", frag->
track_id);
4129 for (j = index->
current_item; j < index->item_count; j++) {
4132 "for track %u and moof_offset %"PRId64
"\n",
4144 if (index && !found) {
4146 "it doesn't have an (in-order) entry for moof_offset "
4158 num = atom.
size / 4;
4236 int data_offset = 0;
4237 unsigned entries, first_sample_flags = frag->
flags;
4287 for (i = 0; i < entries && !pb->
eof_reached; i++) {
4288 unsigned sample_size = frag->
size;
4289 int sample_flags = i ? frag->
flags : first_sample_flags;
4290 unsigned sample_duration = frag->
duration;
4304 " sc->dts_shift %d ctts.duration %d"
4305 " sc->time_offset %"PRId64
" flags & MOV_TRUN_SAMPLE_CTS %d\n", pts,
4309 if (flags & MOV_TRUN_SAMPLE_CTS) {
4318 ", using it for dts\n", dts);
4338 offset, dts, sample_size, distance, keyframe);
4340 dts += sample_duration;
4341 offset += sample_size;
4363 unsigned i, track_id;
4395 if (timescale.
den <= 0) {
4419 if (!index->
items) {
4427 if (size & 0x80000000) {
4492 if (atom.
type !=
MKTAG(
'm',
'd',
'a',
't')) {
4506 long cmov_len, moov_len;
4520 cmov_len = atom.
size - 6 * 4;
4532 goto free_and_return;
4534 if (uncompress (moov_data, (uLongf *) &moov_len, (
const Bytef *)cmov_data, cmov_len) != Z_OK)
4535 goto free_and_return;
4537 goto free_and_return;
4540 atom.
size = moov_len;
4577 for (i = 0; i < edit_count && !pb->
eof_reached; i++) {
4591 if (e->
time < 0 && e->
time != -1 &&
4627 if (atom.
size < 5) {
4663 uint32_t l = 0, t = 0,
r = 0,
b = 0;
4664 uint32_t
tag, padding = 0;
4673 if (atom.
size < 8) {
4683 if (tag !=
MKTAG(
's',
'v',
'h',
'd')) {
4691 if (size > atom.
size)
4695 if (tag !=
MKTAG(
'p',
'r',
'o',
'j')) {
4701 if (size > atom.
size)
4705 if (tag !=
MKTAG(
'p',
'r',
'h',
'd')) {
4717 if (size > atom.
size)
4723 case MKTAG(
'c',
'b',
'm',
'p'):
4727 "Unsupported cubemap layout %d\n", layout);
4733 case MKTAG(
'e',
'q',
'u',
'i'):
4739 if (
b >= UINT_MAX - t ||
r >= UINT_MAX - l) {
4741 "Invalid bounding rectangle coordinates "
4742 "%"PRIu32
",%"PRIu32
",%"PRIu32
",%"PRIu32
"\n", l, t,
r,
b);
4746 if (l || t ||
r ||
b)
4791 if (
av_stristr(buffer,
"<GSpherical:StitchingSoftware>") &&
4792 (val =
av_stristr(buffer,
"<GSpherical:Spherical>")) &&
4794 (val =
av_stristr(buffer,
"<GSpherical:Stitched>")) &&
4796 (val =
av_stristr(buffer,
"<GSpherical:ProjectionType>")) &&
4804 if (
av_stristr(buffer,
"<GSpherical:StereoMode>")) {
4822 val =
av_stristr(buffer,
"<GSpherical:InitialViewHeadingDegrees>");
4825 val =
av_stristr(buffer,
"<GSpherical:InitialViewPitchDegrees>");
4828 val =
av_stristr(buffer,
"<GSpherical:InitialViewRollDegrees>");
4844 static const uint8_t uuid_isml_manifest[] = {
4845 0xa5, 0xd4, 0x0b, 0x30, 0xe8, 0x14, 0x11, 0xdd,
4846 0xba, 0x2f, 0x08, 0x00, 0x20, 0x0c, 0x9a, 0x66
4848 static const uint8_t uuid_xmp[] = {
4849 0xbe, 0x7a, 0xcf, 0xcb, 0x97, 0xa9, 0x42, 0xe8,
4850 0x9c, 0x71, 0x99, 0x94, 0x91, 0xe3, 0xaf, 0xac
4852 static const uint8_t uuid_spherical[] = {
4853 0xff, 0xcc, 0x82, 0x63, 0xf8, 0x55, 0x4a, 0x93,
4854 0x88, 0x14, 0x58, 0x7a, 0x02, 0x52, 0x1f, 0xdd,
4857 if (atom.
size <
sizeof(uuid) || atom.
size >=
FFMIN(INT_MAX, SIZE_MAX))
4865 ret =
avio_read(pb, uuid,
sizeof(uuid));
4868 }
else if (ret !=
sizeof(uuid)) {
4871 if (!memcmp(uuid, uuid_isml_manifest,
sizeof(uuid))) {
4874 size_t len = atom.
size -
sizeof(uuid);
4890 }
else if (ret != len) {
4896 while ((ptr =
av_stristr(ptr,
"systemBitrate=\""))) {
4897 ptr +=
sizeof(
"systemBitrate=\"") - 1;
4906 ret = strtol(ptr, &endptr, 10);
4907 if (ret < 0 || errno || *endptr !=
'"') {
4915 }
else if (!memcmp(uuid, uuid_xmp,
sizeof(uuid))) {
4917 size_t len = atom.
size -
sizeof(uuid);
4927 }
else if (ret != len) {
4940 }
else if (!memcmp(uuid, uuid_spherical,
sizeof(uuid))) {
4941 size_t len = atom.
size -
sizeof(uuid);
4965 && !memcmp(content,
"Anevia\x1A\x1A", 8)
4987 case MKTAG(
'e',
'n',
'c',
'v'):
4988 case MKTAG(
'e',
'n',
'c',
'a'):
4993 "ignoring 'frma' atom of '%.4s', stream has codec id %d\n",
5003 if (format != sc->
format) {
5005 "ignoring 'frma' atom of '%.4s', stream format is '%.4s'\n",
5006 (
char*)&format, (
char*)&sc->
format);
5018 size_t auxiliary_info_size;
5036 if (atom.
size < 8 || atom.
size >
FFMIN(INT_MAX, SIZE_MAX)) {
5042 auxiliary_info_size = atom.
size - 8;
5072 int atom_header_size;
5086 atom_header_size = 9;
5091 if ((flags & 0x01) != 0) {
5092 atom_header_size += 8;
5101 if (atom.
size <= atom_header_size) {
5105 if (atom.
size >
FFMIN(INT_MAX, SIZE_MAX)) {
5111 data_size = atom.
size - atom_header_size;
5138 if ((uint64_t)atom.
size > (1<<30) || atom.
size < 42)
5167 size_t auxiliary_info_seek_offset = 0;
5179 for (i = 0; i <
index; i++) {
5197 uint32_t encrypted_bytes;
5198 uint16_t subsample_count;
5199 uint16_t clear_bytes;
5235 for (; subsample_count > 0; subsample_count--)
5248 if ((uint64_t)clear_bytes + encrypted_bytes > input_end - input) {
5254 input += clear_bytes;
5258 input += encrypted_bytes;
5261 if (input < input_end) {
5356 int64_t total_size = 0;
5367 atom.
size = INT64_MAX;
5372 if (atom.
size >= 8) {
5380 uint32_t *
type = (uint32_t *)buf + 1;
5384 if (*type ==
MKTAG(
'm',
'v',
'h',
'd') ||
5385 *type ==
MKTAG(
'c',
'm',
'o',
'v')) {
5390 if (atom.
type !=
MKTAG(
'r',
'o',
'o',
't') &&
5402 if (a.
size == 1 && total_size + 8 <= atom.
size) {
5410 a.
size = atom.
size - total_size + 8;
5417 for (i = 0; mov_default_parse_table[i].
type; i++)
5418 if (mov_default_parse_table[i].
type == a.
type) {
5441 int err =
parse(c, pb, a);
5457 else if (left < 0) {
5459 "overread end of atom '%.4s' by %"PRId64
" bytes\n",
5460 (
char*)&a.
type, -left);
5465 total_size += a.
size;
5468 if (total_size < atom.
size && atom.
size < 0x7ffff)
5480 int moov_offset = -1;
5486 if ((offset + 8) > (
unsigned int)p->
buf_size)
5491 case MKTAG(
'm',
'o',
'o',
'v'):
5492 moov_offset = offset + 4;
5493 case MKTAG(
'm',
'd',
'a',
't'):
5494 case MKTAG(
'p',
'n',
'o',
't'):
5495 case MKTAG(
'u',
'd',
't',
'a'):
5496 case MKTAG(
'f',
't',
'y',
'p'):
5499 offset + 12 > (
unsigned int)p->
buf_size ||
5502 }
else if (tag ==
MKTAG(
'f',
't',
'y',
'p') &&
5506 score =
FFMAX(score, 5);
5513 case MKTAG(
'e',
'd',
'i',
'w'):
5514 case MKTAG(
'w',
'i',
'd',
'e'):
5515 case MKTAG(
'f',
'r',
'e',
'e'):
5516 case MKTAG(
'j',
'u',
'n',
'k'):
5517 case MKTAG(
'p',
'i',
'c',
't'):
5521 case MKTAG(0x82,0x82,0x7f,0x7d):
5522 case MKTAG(
's',
'k',
'i',
'p'):
5523 case MKTAG(
'u',
'u',
'i',
'd'):
5524 case MKTAG(
'p',
'r',
'f',
'l'):
5536 offset = moov_offset;
5538 while(offset < (p->
buf_size - 16)){
5572 if (s->
streams[i]->
id == chapter_track) {
5613 if (end < sample->timestamp) {
5625 if (len > sample->
size-2)
5627 title_len = 2*len + 1;
5640 else if (ch == 0xfffe)
5644 if (len == 1 || len == 2)
5679 int hh, mm,
ss, ff, drop;
5692 hh, mm, ss, drop ?
';' :
':', ff);
5842 int version, fieldlength, i, j;
5873 if (!index->
items) {
5895 for (j = 0; j < ((fieldlength >> 4) & 3) + 1; j++)
5897 for (j = 0; j < ((fieldlength >> 2) & 3) + 1; j++)
5899 for (j = 0; j < ((fieldlength >> 0) & 3) + 1; j++)
5914 if ((seek_ret =
avio_seek(f, stream_size - 4, SEEK_SET)) < 0) {
5919 if (mfra_size < 0 || mfra_size > stream_size) {
5923 if ((seek_ret =
avio_seek(f, -mfra_size, SEEK_CUR)) < 0) {
5943 seek_ret =
avio_seek(f, original_pos, SEEK_SET);
5946 "failed to seek back after looking for mfra\n");
5972 atom.
size = INT64_MAX;
6008 int tmcd_st_id = -1;
6014 if (tmcd_st_id < 0 || tmcd_st_id == i)
6143 int64_t best_dts = INT64_MAX;
6154 ((msc->
pb != s->
pb && dts < best_dts) || (msc->
pb == s->
pb &&
6157 sample = current_sample;
6178 int already_read = 0;
6180 if (
avio_seek(s->
pb, target, SEEK_SET) != target) {
6233 if (extradata_size > 0 && extradata) {
6239 memcpy(side, extradata, extradata_size);
6251 int64_t current_index;
6275 if (ret64 != sample->
pos) {
6307 #if CONFIG_DV_DEMUXER
6392 for (j = index->
item_count - 1; j >= 0; j--) {
6393 if (index->
items[j].
time <= timestamp) {
6418 if (sample < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
6463 st = s->
streams[stream_index];
6478 if (stream_index == i)
6505 #define OFFSET(x) offsetof(MOVContext, x)
6506 #define FLAGS AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
6508 {
"use_absolute_path",
6509 "allow using absolute path when opening alias, this is a possible security issue",
6512 {
"seek_streams_individually",
6513 "Seek each stream individually to the to the closest point",
6518 {
"advanced_editlist",
6519 "Modify the AVIndex according to the editlists. Use this option to decode in the order specified by the edits.",
6525 "use mfra for fragment timestamps",
6530 FLAGS,
"use_mfra_for" },
6532 FLAGS,
"use_mfra_for" },
6534 FLAGS,
"use_mfra_for" },
6535 {
"export_all",
"Export unrecognized metadata entries",
OFFSET(export_all),
6537 {
"export_xmp",
"Export full XMP metadata",
OFFSET(export_xmp),
6539 {
"activation_bytes",
"Secret bytes for Audible AAX files",
OFFSET(activation_bytes),
6541 {
"audible_fixed_key",
6542 "Fixed key used for handling Audible AAX files",
OFFSET(audible_fixed_key),
6547 {.i64 = 0}, 0, 1,
FLAGS },
6560 .
name =
"mov,mp4,m4a,3gp,3g2,mj2",
6564 .extensions =
"mov,mp4,m4a,3gp,3g2,mj2",
int32_t pitch
Rotation around the right vector [-90, 90].
static int mov_read_targa_y216(MOVContext *c, AVIOContext *pb, MOVAtom atom)
int itunes_metadata
metadata are itunes style
int * bitrates
bitrates read before streams creation
static int mov_read_moof(MOVContext *c, AVIOContext *pb, MOVAtom atom)
void av_sha_final(AVSHA *ctx, uint8_t *digest)
Finish hashing and output digest value.
void av_url_split(char *proto, int proto_size, char *authorization, int authorization_size, char *hostname, int hostname_size, int *port_ptr, char *path, int path_size, const char *url)
Split a URL string into components.
AVSphericalMapping * av_spherical_alloc(size_t *size)
Allocate a AVSphericalVideo structure and initialize its fields to default values.
const char const char void * val
enum AVFieldOrder field_order
Video only.
discard all frames except keyframes
static int mov_read_esds(MOVContext *c, AVIOContext *pb, MOVAtom atom)
static int mov_read_enda(MOVContext *c, AVIOContext *pb, MOVAtom atom)
enum AVColorTransferCharacteristic color_trc
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
int64_t avio_size(AVIOContext *s)
Get the filesize.
static int64_t find_prev_closest_index(AVStream *st, AVIndexEntry *e_old, int nb_old, int64_t timestamp, int flag)
Find the closest previous frame to the timestamp, in e_old index entries.
static int mov_read_dec3(MOVContext *c, AVIOContext *pb, MOVAtom atom)
#define av_realloc_f(p, o, n)
uint32_t tmcd_flags
tmcd track flags
uint8_t * auxiliary_info_end
void av_sha_update(AVSHA *ctx, const uint8_t *data, unsigned int len)
Update hash value.
unsigned int rap_group_count
void ff_mp4_parse_es_descr(AVIOContext *pb, int *es_id)
static int mov_read_wide(MOVContext *c, AVIOContext *pb, MOVAtom atom)
void * av_realloc(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory.
static int mov_change_extradata(MOVStreamContext *sc, AVPacket *pkt)
int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp, int size, int distance, int flags)
Add an index entry into a sorted list.
#define MOV_TFHD_DEFAULT_DURATION
static AVIndexEntry * mov_find_next_sample(AVFormatContext *s, AVStream **st)
static int mov_read_chpl(MOVContext *c, AVIOContext *pb, MOVAtom atom)
static int mov_read_keys(MOVContext *c, AVIOContext *pb, MOVAtom atom)
unsigned int samples_per_frame
static int mov_seek_auxiliary_info(MOVContext *c, MOVStreamContext *sc, int64_t index)
static void mov_build_index(MOVContext *mov, AVStream *st)
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
av_cold int av_sha_init(AVSHA *ctx, int bits)
Initialize SHA-1 or SHA-2 hashing.
#define AV_LOG_WARNING
Something somehow does not look correct.
uint64_t base_data_offset
#define LIBAVUTIL_VERSION_INT
int64_t pos
byte position in stream, -1 if unknown
static void skip_bits_long(GetBitContext *s, int n)
int ffio_read_size(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
char * av_stristr(const char *s1, const char *s2)
Locate the first case-independent occurrence in the string haystack of the string needle...
static av_always_inline float av_int2float(uint32_t i)
Reinterpret a 32-bit integer as a float.
static int mov_metadata_gnre(MOVContext *c, AVIOContext *pb, unsigned len, const char *key)
static int read_seek(AVFormatContext *ctx, int stream_index, int64_t timestamp, int flags)
This side data should be associated with a video stream and contains Stereoscopic 3D information in f...
Video represents a portion of a sphere mapped on a flat surface using equirectangular projection...
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
static int mov_read_trak(MOVContext *c, AVIOContext *pb, MOVAtom atom)
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
int index
stream index in AVFormatContext
#define MOV_TRUN_SAMPLE_CTS
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
#define AVIO_FLAG_READ
read-only
void av_aes_crypt(AVAES *a, uint8_t *dst, const uint8_t *src, int count, uint8_t *iv, int decrypt)
Encrypt or decrypt a buffer using a previously initialized context.
AVIndexEntry * index_entries
Only used if the format does not support seeking natively.
static int tmcd_is_referenced(AVFormatContext *s, int tmcd_id)
int event_flags
Flags for the user to detect events happening on the file.
static int mov_read_saiz(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Video represents a sphere mapped on a flat surface using equirectangular projection.
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
int16_t audio_cid
stsd audio compression id
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
#define PUT_UTF8(val, tmp, PUT_BYTE)
Convert a 32-bit Unicode character to its UTF-8 encoded form (up to 4 bytes long).
static int mov_parse_uuid_spherical(MOVStreamContext *sc, AVIOContext *pb, size_t len)
#define IS_MATRIX_IDENT(matrix)
unsigned int avio_rb16(AVIOContext *s)
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
static int mov_get_stsc_samples(MOVStreamContext *sc, int index)
static int mov_read_udta_string(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Views are next to each other.
static int mov_read_uuid(MOVContext *c, AVIOContext *pb, MOVAtom atom)
int avio_get_str16le(AVIOContext *pb, int maxlen, char *buf, int buflen)
Read a UTF-16 string from pb and convert it to UTF-8.
int strict_std_compliance
Allow non-standard and experimental extension.
enum AVCodecID ff_mov_get_lpcm_codec_id(int bps, int flags)
Compute codec id for 'lpcm' tag.
unsigned fragment_index_count
static int mov_read_mvhd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
AVSphericalMapping * spherical
This struct describes the properties of an encoded stream.
int found_moov
'moov' atom has been found
static int mov_read_stps(MOVContext *c, AVIOContext *pb, MOVAtom atom)
static void export_orphan_timecode(AVFormatContext *s)
enum AVColorSpace color_space
static int mov_read_aclr(MOVContext *c, AVIOContext *pb, MOVAtom atom)
#define MOV_TFHD_DEFAULT_BASE_IS_MOOF
const char * av_color_space_name(enum AVColorSpace space)
Macro definitions for various function/variable attributes.
int frame_size
Audio only.
static int should_retry(AVIOContext *pb, int error_code)
#define AV_DICT_DONT_STRDUP_KEY
Take ownership of a key that's been allocated with av_malloc() or another memory allocation function...
static int mov_realloc_extradata(AVCodecParameters *par, MOVAtom atom)
int av_get_channel_layout_nb_channels(uint64_t channel_layout)
Return the number of channels in the channel layout.
#define MOV_TKHD_FLAG_ENABLED
int isom
1 if file is ISO Media (mp4/3gp)
int found_mdat
'mdat' atom has been found
static int mov_read_st3d(MOVContext *c, AVIOContext *pb, MOVAtom atom)
static int mov_probe(AVProbeData *p)
static int mov_read_header(AVFormatContext *s)
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
#define av_assert0(cond)
assert() equivalent, that is always enabled.
void av_aes_ctr_crypt(struct AVAESCTR *a, uint8_t *dst, const uint8_t *src, int count)
Process a buffer using a previously initialized context.
static int parse(AVCodecParserContext *s, AVCodecContext *avctx, const uint8_t **poutbuf, int *poutbuf_size, const uint8_t *buf, int buf_size)
static int mov_parse_stsd_data(MOVContext *c, AVIOContext *pb, AVStream *st, MOVStreamContext *sc, int64_t size)
int avpriv_dict_set_timestamp(AVDictionary **dict, const char *key, int64_t timestamp)
Set a dictionary value to an ISO-8601 compliant timestamp string.
static double cb(void *priv, double x, double y)
int fragment_index_complete
void void avpriv_request_sample(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
static int mov_read_moov(MOVContext *c, AVIOContext *pb, MOVAtom atom)
static const AVOption mov_options[]
static void mov_current_sample_dec(MOVStreamContext *sc)
static int64_t start_time
static av_always_inline double av_int2double(uint64_t i)
Reinterpret a 64-bit integer as a double.
#define FF_MOV_FLAG_MFRA_DTS
static int64_t add_ctts_entry(MOVStts **ctts_data, unsigned int *ctts_count, unsigned int *allocated_size, int count, int duration)
Append a new ctts entry to ctts_data.
Opaque data information usually continuous.
unsigned int sample_count
const AVCodecTag ff_codec_movvideo_tags[]
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
unsigned int avio_rb32(AVIOContext *s)
int dts_shift
dts shift when ctts is negative
static int mov_read_ddts(MOVContext *c, AVIOContext *pb, MOVAtom atom)
static av_cold int end(AVCodecContext *avctx)
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
This side data contains a 3x3 transformation matrix describing an affine transformation that needs to...
uint8_t * auxiliary_info_pos
int id
Format-specific stream ID.
enum AVStreamParseType need_parsing
AVInputFormat ff_mov_demuxer
static int mov_read_cmov(MOVContext *c, AVIOContext *pb, MOVAtom atom)
int ff_mov_read_esds(AVFormatContext *fc, AVIOContext *pb)
static int64_t add_index_entry(AVStream *st, int64_t pos, int64_t timestamp, int size, int distance, int flags)
Add index entry with the given values, to the end of st->index_entries.
static void mov_current_sample_inc(MOVStreamContext *sc)
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
#define AV_CH_LOW_FREQUENCY
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
AVStream ** streams
A list of all streams in the file.
static int mov_metadata_int8_no_padding(MOVContext *c, AVIOContext *pb, unsigned len, const char *key)
static int mov_read_wfex(MOVContext *c, AVIOContext *pb, MOVAtom atom)
AVFormatContext * avformat_alloc_context(void)
Allocate an AVFormatContext.
static int mov_skip_multiple_stsd(MOVContext *c, AVIOContext *pb, int codec_tag, int format, int64_t size)
int activation_bytes_size
MOVFragmentIndex ** fragment_index_data
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
#define ALAC_EXTRADATA_SIZE
int flags
Flags modifying the (de)muxer behaviour.
#define MOV_TRUN_SAMPLE_SIZE
#define AVERROR_EOF
End of file.
bitstream reader API header.
static av_cold int read_close(AVFormatContext *ctx)
#define AV_LOG_VERBOSE
Detailed information.
struct AVAESCTR * aes_ctr
static int mov_read_hdlr(MOVContext *c, AVIOContext *pb, MOVAtom atom)
uint64_t avio_rb64(AVIOContext *s)
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)
Reduce a fraction.
int ff_replaygain_export(AVStream *st, AVDictionary *metadata)
Parse replaygain tags and export them as per-stream side data.
static int test_same_origin(const char *src, const char *ref)
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
void av_aes_ctr_free(struct AVAESCTR *a)
Release an AVAESCTR context.
enum AVCodecID video_codec_id
Forced video codec_id.
uint64_t channel_layout
Audio only.
#define MOV_TFHD_DEFAULT_SIZE
int32_t movie_display_matrix[3][3]
display matrix from mvhd
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
int ff_get_wav_header(AVFormatContext *s, AVIOContext *pb, AVCodecParameters *par, int size, int big_endian)
static int mov_read_frma(MOVContext *c, AVIOContext *pb, MOVAtom atom)
static int cenc_filter(MOVContext *c, MOVStreamContext *sc, int64_t index, uint8_t *input, int size)
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
int64_t time_offset
time offset of the edit list entries
static int mov_read_custom(MOVContext *c, AVIOContext *pb, MOVAtom atom)
unsigned int keyframe_count
MOVIndexRange * index_ranges
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
int av_timecode_init(AVTimecode *tc, AVRational rate, int flags, int frame_start, void *log_ctx)
Init a timecode struct with the passed parameters.
const uint16_t avpriv_ac3_channel_layout_tab[8]
Map audio coding mode (acmod) to channel layout mask.
static int mov_read_fiel(MOVContext *c, AVIOContext *pb, MOVAtom atom)
static int mov_read_stsd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
static int mov_rewrite_dvd_sub_extradata(AVStream *st)
int ff_mp4_read_dec_config_descr(AVFormatContext *fc, AVStream *st, AVIOContext *pb)
static void mov_parse_stsd_subtitle(MOVContext *c, AVIOContext *pb, AVStream *st, MOVStreamContext *sc, int64_t size)
AVCodecID
Identify the syntax and semantics of the bitstream.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
#define AV_DICT_MATCH_CASE
Only get an entry with exact-case key match.
int av_get_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
AVDictionary * metadata
Metadata that applies to the whole file.
An AV_PKT_DATA_PALETTE side data packet contains exactly AVPALETTE_SIZE bytes worth of palette...
int av_index_search_timestamp(AVStream *st, int64_t timestamp, int flags)
Get the index for a specific timestamp.
static int mov_read_pasp(MOVContext *c, AVIOContext *pb, MOVAtom atom)
static int mov_read_elst(MOVContext *c, AVIOContext *pb, MOVAtom atom)
FLAC (Free Lossless Audio Codec) decoder/demuxer common functions.
unsigned int avio_rl32(AVIOContext *s)
static int mov_read_ctts(MOVContext *c, AVIOContext *pb, MOVAtom atom)
static int mov_read_svq3(MOVContext *c, AVIOContext *pb, MOVAtom atom)
static int mov_read_wave(MOVContext *c, AVIOContext *pb, MOVAtom atom)
int64_t timestamp
Timestamp in AVStream.time_base units, preferably the time from which on correctly decoded frames are...
MOVIndexRange * current_index_range
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
enum AVColorPrimaries color_primaries
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
preferred ID for decoding MPEG audio layer 1, 2 or 3
#define av_fourcc2str(fourcc)
enum AVMediaType codec_type
General type of the encoded data.
static int mov_open_dref(MOVContext *c, AVIOContext **pb, const char *src, MOVDref *ref)
simple assert() macros that are a bit more flexible than ISO C assert().
static int mov_read_trun(MOVContext *c, AVIOContext *pb, MOVAtom atom)
#define FFNABS(a)
Negative Absolute value.
struct AVAES * av_aes_alloc(void)
Allocate an AVAES context.
int skip_samples
Number of samples to skip at the start of the frame decoded from the next packet. ...
static const uint8_t offset[127][2]
static int mov_read_sidx(MOVContext *c, AVIOContext *pb, MOVAtom atom)
AVRational avg_frame_rate
Average framerate.
const AVCodecTag ff_codec_wav_tags[]
static void * av_mallocz_array(size_t nmemb, size_t size)
#define MOV_FRAG_SAMPLE_FLAG_DEPENDS_YES
int min_distance
Minimum distance between this and the previous keyframe, used to avoid unneeded searching.
static void mov_metadata_creation_time(AVDictionary **metadata, int64_t time)
const AVCodecTag ff_codec_movsubtitle_tags[]
static int mov_read_adrm(MOVContext *c, AVIOContext *pb, MOVAtom atom)
#define mov_stsc_index_valid(index, count)
#define MIN_DATA_ENTRY_BOX_SIZE
int flags
A combination of AV_PKT_FLAG values.
const char * av_color_primaries_name(enum AVColorPrimaries primaries)
int extradata_size
Size of the extradata content in bytes.
int ff_mov_read_stsd_entries(MOVContext *c, AVIOContext *pb, int entries)
int avio_r8(AVIOContext *s)
int av_reallocp_array(void *ptr, size_t nmemb, size_t size)
struct AVAESCTR * av_aes_ctr_alloc(void)
Allocate an AVAESCTR context.
static float distance(float x, float y, int band)
static int mov_read_tkhd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
int buf_size
Size of buf except extra allocated bytes.
static int mov_read_default(MOVContext *c, AVIOContext *pb, MOVAtom atom)
static int aax_filter(uint8_t *input, int size, MOVContext *c)
static int mov_read_colr(MOVContext *c, AVIOContext *pb, MOVAtom atom)
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
common internal API header
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
static int mov_read_mdhd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
uint32_t bound_bottom
Distance from the bottom edge.
static int mov_seek_stream(AVFormatContext *s, AVStream *st, int64_t timestamp, int flags)
static int mov_metadata_track_or_disc_number(MOVContext *c, AVIOContext *pb, unsigned len, const char *key)
int block_align
Audio only.
static av_const double hypot(double x, double y)
struct AVAES * aes_decrypt
static int mov_read_stts(MOVContext *c, AVIOContext *pb, MOVAtom atom)
static const uint16_t fc[]
uint8_t auxiliary_info_default_size
int seekable
A combination of AVIO_SEEKABLE_ flags or 0 when the stream is not seekable.
Video frame is split into 6 faces of a cube, and arranged on a 3x2 layout.
audio channel layout utility functions
unsigned int avio_rb24(AVIOContext *s)
char filename[1024]
input or output filename
static int mov_read_chap(MOVContext *c, AVIOContext *pb, MOVAtom atom)
int64_t av_rescale(int64_t a, int64_t b, int64_t c)
Rescale a 64-bit integer with rounding to nearest.
#define AV_TIME_BASE
Internal time base represented as integer.
const AVCodecTag ff_codec_bmp_tags[]
int av_stream_add_side_data(AVStream *st, enum AVPacketSideDataType type, uint8_t *data, size_t size)
Wrap an existing array as stream side data.
static int mov_read_ftyp(MOVContext *c, AVIOContext *pb, MOVAtom atom)
#define AV_DICT_DONT_STRDUP_VAL
Take ownership of a value that's been allocated with av_malloc() or another memory allocation functio...
static int mov_read_tmcd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
GLsizei GLboolean const GLfloat * value
static int mov_read_senc(MOVContext *c, AVIOContext *pb, MOVAtom atom)
This side data should be associated with a video stream and corresponds to the AVSphericalMapping str...
static int mov_read_jp2h(MOVContext *c, AVIOContext *pb, MOVAtom atom)
uint32_t bound_right
Distance from the right edge.
static const struct ColorPrimaries color_primaries[AVCOL_PRI_NB]
internal header for RIFF based (de)muxers do NOT include this in end user applications ...
static int mov_read_timecode_track(AVFormatContext *s, AVStream *st)
int audible_fixed_key_size
static int mov_read_tfhd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
static void mov_fix_index(MOVContext *mov, AVStream *st)
Fix st->index_entries, so that it contains only the entries (and the entries which are needed to deco...
static int mov_read_ares(MOVContext *c, AVIOContext *pb, MOVAtom atom)
static int mov_read_tfdt(MOVContext *c, AVIOContext *pb, MOVAtom atom)
#define FLAC_STREAMINFO_SIZE
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
MOVFragmentIndexItem * items
void * av_fast_realloc(void *ptr, unsigned int *size, size_t min_size)
Reallocate the given buffer if it is not large enough, otherwise do nothing.
int32_t yaw
Rotation around the up vector [-180, 180].
#define MOV_TRUN_SAMPLE_DURATION
uint8_t * av_stream_new_side_data(AVStream *stream, enum AVPacketSideDataType type, int size)
Allocate new information from stream.
#define AV_CH_FRONT_CENTER
enum AVColorRange color_range
Video only.
static int mov_read_packet(AVFormatContext *s, AVPacket *pkt)
static int mov_read_close(AVFormatContext *s)
static int mov_read_glbl(MOVContext *c, AVIOContext *pb, MOVAtom atom)
This function reads atom content and puts data in extradata without tag nor size unlike mov_read_extr...
int ff_mov_read_chan(AVFormatContext *s, AVIOContext *pb, AVStream *st, int64_t size)
Read 'chan' tag from the input stream.
offset must point to a pointer immediately followed by an int for the length
#define FF_MOV_FLAG_MFRA_PTS
the normal 2^n-1 "JPEG" YUV ranges
static int read_header(FFV1Context *f)
uint32_t padding
Number of pixels to pad from the edge of each cube face.
size_t auxiliary_info_sizes_count
int64_t duration
duration of the longest track
int ff_mov_lang_to_iso639(unsigned code, char to[4])
static int mov_read_dfla(MOVContext *c, AVIOContext *pb, MOVAtom atom)
static int mov_read_covr(MOVContext *c, AVIOContext *pb, int type, int len)
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
static int read_packet(void *opaque, uint8_t *buf, int buf_size)
AVSphericalProjection
Projection of the video surface(s) on a sphere.
int av_aes_init(AVAES *a, const uint8_t *key, int key_bits, int decrypt)
Initialize an AVAES context.
static int mov_metadata_hmmt(MOVContext *c, AVIOContext *pb, unsigned len)
DVDemuxContext * dv_demux
#define AVIO_SEEKABLE_NORMAL
Seeking works like for a local file.
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
The AV_PKT_DATA_NEW_EXTRADATA is used to notify the codec or the format that the extradata buffer was...
static int mov_read_seek(AVFormatContext *s, int stream_index, int64_t sample_time, int flags)
static const uint32_t mac_to_unicode[128]
enum AVStereo3DType type
How views are packed within the video.
#define AV_LOG_INFO
Standard information.
static int mov_read_dref(MOVContext *c, AVIOContext *pb, MOVAtom atom)
int av_reallocp(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory through a pointer to a pointer.
int ff_get_qtpalette(int codec_id, AVIOContext *pb, uint32_t *palette)
Retrieve the palette (or "color table" in QuickTime terms), either from the video sample description...
#define MP4DecConfigDescrTag
const AVCodecTag ff_codec_movaudio_tags[]
int64_t auxiliary_info_index
static void mov_read_chapters(AVFormatContext *s)
AVIOContext * pb
I/O context.
static void mov_parse_stsd_video(MOVContext *c, AVIOContext *pb, AVStream *st, MOVStreamContext *sc)
unsigned int stsz_sample_size
always contains sample size from stsz atom
static int read_tfra(MOVContext *mov, AVIOContext *f)
static AVRational av_make_q(int num, int den)
Create an AVRational.
Public header for SHA-1 & SHA-256 hash function implementations.
static int mov_read_dac3(MOVContext *c, AVIOContext *pb, MOVAtom atom)
#define MOV_TRUN_FIRST_SAMPLE_FLAGS
static int mov_read_ilst(MOVContext *c, AVIOContext *pb, MOVAtom atom)
timecode wraps after 24 hours
struct AVSHA * av_sha_alloc(void)
Allocate an AVSHA context.
static int mov_read_free(MOVContext *c, AVIOContext *pb, MOVAtom atom)
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
static const char * format
Describe the class of an AVClass context structure.
static void skip_bits(GetBitContext *s, int n)
int32_t roll
Rotation around the forward vector [-180, 180].
Rational number (pair of numerator and denominator).
unsigned int aax_mode
'aax' file has been detected
static int mov_read_dpxe(MOVContext *c, AVIOContext *pb, MOVAtom atom)
#define AV_OPT_FLAG_DECODING_PARAM
a generic parameter which can be set by the user for demuxing or decoding
MOVFragment fragment
current fragment in moof atom
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
AVRational display_aspect_ratio
display aspect ratio (0 if unknown)
int64_t track_end
used for dts generation in fragmented movie files
static av_always_inline void flac_parse_block_header(const uint8_t *block_header, int *last, int *type, int *size)
Parse the metadata block parameters from the header.
static void mov_parse_stsd_audio(MOVContext *c, AVIOContext *pb, AVStream *st, MOVStreamContext *sc)
size_t av_strlcatf(char *dst, size_t size, const char *fmt,...)
static int mov_read_mac_string(MOVContext *c, AVIOContext *pb, int len, char *dst, int dstlen)
#define MOV_TFHD_DEFAULT_FLAGS
#define FF_COMPLIANCE_STRICT
Strictly conform to all the things in the spec no matter what consequences.
void avformat_free_context(AVFormatContext *s)
Free an AVFormatContext and all its streams.
#define FF_MOV_FLAG_MFRA_AUTO
AVStereo3DType
List of possible 3D Types.
#define MOV_TRUN_SAMPLE_FLAGS
This structure contains the data a format has to probe a file.
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
static int mov_read_stss(MOVContext *c, AVIOContext *pb, MOVAtom atom)
AVFormatContext * dv_fctx
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...
static int64_t pts
Global timestamp for the audio frames.
static void mov_update_dts_shift(MOVStreamContext *sc, int duration)
static int mov_read_meta(MOVContext *c, AVIOContext *pb, MOVAtom atom)
void av_aes_ctr_set_iv(struct AVAESCTR *a, const uint8_t *iv)
Forcefully change the iv.
char * av_timecode_make_string(const AVTimecode *tc, char *buf, int framenum)
Load timecode string in buf.
unsigned * stps_data
partial sync sample for mpeg-2 open gop
AVRational av_d2q(double d, int max)
Convert a double precision floating point number to a rational.
uint32_t bound_top
Distance from the top edge.
uint8_t * auxiliary_info_sizes
the normal 219*2^(n-8) "MPEG" YUV ranges
int(* parse)(MOVContext *ctx, AVIOContext *pb, MOVAtom atom)
static int mov_read_mdat(MOVContext *c, AVIOContext *pb, MOVAtom atom)
static int mov_metadata_int8_bypass_padding(MOVContext *c, AVIOContext *pb, unsigned len, const char *key)
int ffio_ensure_seekback(AVIOContext *s, int64_t buf_size)
Ensures that the requested seekback buffer size will be available.
int64_t duration
Decoding: duration of the stream, in stream time base.
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
int sample_rate
Audio only.
static int mov_read_avid(MOVContext *c, AVIOContext *pb, MOVAtom atom)
int start_pad
amount of samples to skip due to enc-dec delay
int trak_index
Index of the current 'trak'.
negative time values are allowed
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_RB64
int ff_mp4_read_descr(AVFormatContext *fc, AVIOContext *pb, int *tag)
struct MOVStreamContext::@210 cenc
static void fix_index_entry_timestamps(AVStream *st, int end_index, int64_t end_ts, int64_t *frame_duration_buffer, int frame_duration_buffer_size)
Rewrite timestamps of index entries in the range [end_index - frame_duration_buffer_size, end_index) by subtracting end_ts successively by the amounts given in frame_duration_buffer.
static int mov_read_strf(MOVContext *c, AVIOContext *pb, MOVAtom atom)
An strf atom is a BITMAPINFOHEADER struct.
#define AV_PKT_FLAG_DISCARD
Flag is used to discard packets which are required to maintain valid decoder state but are not requir...
unsigned int bytes_per_frame
#define FF_DISABLE_DEPRECATION_WARNINGS
static int mov_read_rtmd_track(AVFormatContext *s, AVStream *st)
#define MOV_TFHD_BASE_DATA_OFFSET
static int ref[MAX_W *MAX_W]
enum AVSphericalProjection projection
Projection type.
int ffio_init_context(AVIOContext *s, unsigned char *buffer, int buffer_size, int write_flag, void *opaque, int(*read_packet)(void *opaque, uint8_t *buf, int buf_size), int(*write_packet)(void *opaque, uint8_t *buf, int buf_size), int64_t(*seek)(void *opaque, int64_t offset, int whence))
int avio_get_str16be(AVIOContext *pb, int maxlen, char *buf, int buflen)
static const MOVParseTableEntry mov_default_parse_table[]
static int get_edit_list_entry(MOVContext *mov, const MOVStreamContext *msc, unsigned int edit_list_index, int64_t *edit_list_media_time, int64_t *edit_list_duration, int64_t global_timescale)
Get ith edit list entry (media time, duration).
Video is not stereoscopic (and metadata has to be there).
static int parse_timecode_in_framenum_format(AVFormatContext *s, AVStream *st, uint32_t value, int flags)
const char * av_color_transfer_name(enum AVColorTransferCharacteristic transfer)
int av_dict_set_int(AVDictionary **pm, const char *key, int64_t value, int flags)
Convenience wrapper for av_dict_set that converts the value to a string and stores it...
static int mov_read_chan(MOVContext *c, AVIOContext *pb, MOVAtom atom)
int disposition
AV_DISPOSITION_* bit field.
static int mov_codec_id(AVStream *st, uint32_t format)
int64_t nb_frames
number of frames in this stream if known or 0
uint8_t pi<< 24) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_U8,(uint64_t)((*(constuint8_t *) pi-0x80U))<< 56) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8,(*(constuint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8,(*(constuint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16,(*(constint16_t *) pi >>8)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S16,(uint64_t)(*(constint16_t *) pi)<< 48) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16,*(constint16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16,*(constint16_t *) pi *(1.0/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32,(*(constint32_t *) pi >>24)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S32,(uint64_t)(*(constint32_t *) pi)<< 32) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32,*(constint32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32,*(constint32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S64,(*(constint64_t *) pi >>56)+0x80) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S64,*(constint64_t *) pi *(1.0f/(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S64,*(constint64_t *) pi *(1.0/(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, av_clip_uint8(lrintf(*(constfloat *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, av_clip_int16(lrintf(*(constfloat *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, av_clipl_int32(llrintf(*(constfloat *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_FLT, llrintf(*(constfloat *) pi *(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, av_clip_uint8(lrint(*(constdouble *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, av_clip_int16(lrint(*(constdouble *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, av_clipl_int32(llrint(*(constdouble *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_DBL, llrint(*(constdouble *) pi *(INT64_C(1)<< 63)))#defineFMT_PAIR_FUNC(out, in) staticconv_func_type *constfmt_pair_to_conv_functions[AV_SAMPLE_FMT_NB *AV_SAMPLE_FMT_NB]={FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S64),};staticvoidcpy1(uint8_t **dst, constuint8_t **src, intlen){memcpy(*dst,*src, len);}staticvoidcpy2(uint8_t **dst, constuint8_t **src, intlen){memcpy(*dst,*src, 2 *len);}staticvoidcpy4(uint8_t **dst, constuint8_t **src, intlen){memcpy(*dst,*src, 4 *len);}staticvoidcpy8(uint8_t **dst, constuint8_t **src, intlen){memcpy(*dst,*src, 8 *len);}AudioConvert *swri_audio_convert_alloc(enumAVSampleFormatout_fmt, enumAVSampleFormatin_fmt, intchannels, constint *ch_map, intflags){AudioConvert *ctx;conv_func_type *f=fmt_pair_to_conv_functions[av_get_packed_sample_fmt(out_fmt)+AV_SAMPLE_FMT_NB *av_get_packed_sample_fmt(in_fmt)];if(!f) returnNULL;ctx=av_mallocz(sizeof(*ctx));if(!ctx) returnNULL;if(channels==1){in_fmt=av_get_planar_sample_fmt(in_fmt);out_fmt=av_get_planar_sample_fmt(out_fmt);}ctx->channels=channels;ctx->conv_f=f;ctx->ch_map=ch_map;if(in_fmt==AV_SAMPLE_FMT_U8||in_fmt==AV_SAMPLE_FMT_U8P) memset(ctx->silence, 0x80, sizeof(ctx->silence));if(out_fmt==in_fmt &&!ch_map){switch(av_get_bytes_per_sample(in_fmt)){case1:ctx->simd_f=cpy1;break;case2:ctx->simd_f=cpy2;break;case4:ctx->simd_f=cpy4;break;case8:ctx->simd_f=cpy8;break;}}if(HAVE_YASM &&1) swri_audio_convert_init_x86(ctx, out_fmt, in_fmt, channels);if(ARCH_ARM) swri_audio_convert_init_arm(ctx, out_fmt, in_fmt, channels);if(ARCH_AARCH64) swri_audio_convert_init_aarch64(ctx, out_fmt, in_fmt, channels);returnctx;}voidswri_audio_convert_free(AudioConvert **ctx){av_freep(ctx);}intswri_audio_convert(AudioConvert *ctx, AudioData *out, AudioData *in, intlen){intch;intoff=0;constintos=(out->planar?1:out->ch_count)*out->bps;unsignedmisaligned=0;av_assert0(ctx->channels==out->ch_count);if(ctx->in_simd_align_mask){intplanes=in->planar?in->ch_count:1;unsignedm=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) in->ch[ch];misaligned|=m &ctx->in_simd_align_mask;}if(ctx->out_simd_align_mask){intplanes=out->planar?out->ch_count:1;unsignedm=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) out->ch[ch];misaligned|=m &ctx->out_simd_align_mask;}if(ctx->simd_f &&!ctx->ch_map &&!misaligned){off=len &~15;av_assert1(off >=0);av_assert1(off<=len);av_assert2(ctx->channels==SWR_CH_MAX||!in->ch[ctx->channels]);if(off >0){if(out->planar==in->planar){intplanes=out->planar?out->ch_count:1;for(ch=0;ch< planes;ch++){ctx->simd_f(out-> ch ch
double av_display_rotation_get(const int32_t matrix[9])
The display transformation matrix specifies an affine transformation that should be applied to video ...
static int mov_metadata_loci(MOVContext *c, AVIOContext *pb, unsigned len)
#define MKBETAG(a, b, c, d)
static int mov_read_stco(MOVContext *c, AVIOContext *pb, MOVAtom atom)
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
static int mov_seek_fragment(AVFormatContext *s, AVStream *st, int64_t timestamp)
unsigned int index_entries_allocated_size
static int mov_finalize_stsd_codec(MOVContext *c, AVIOContext *pb, AVStream *st, MOVStreamContext *sc)
int eof_reached
true if eof reached
static int mov_read_avss(MOVContext *c, AVIOContext *pb, MOVAtom atom)
#define FF_ENABLE_DEPRECATION_WARNINGS
as in Berlin toast format
static int mov_read_extradata(MOVContext *c, AVIOContext *pb, MOVAtom atom, enum AVCodecID codec_id)
int av_aes_ctr_init(struct AVAESCTR *a, const uint8_t *key)
Initialize an AVAESCTR context.
unsigned int sample_size
may contain value calculated from stsd or value from stsz atom
static int mov_read_sv3d(MOVContext *c, AVIOContext *pb, MOVAtom atom)
void * priv_data
Format private data.
static int mov_read_mfra(MOVContext *c, AVIOContext *f)
Views are on top of each other.
static const AVClass mov_class
uint32_t bound_left
Distance from the left edge.
int bits_per_coded_sample
The number of bits per sample in the codedwords.
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
#define MOV_TRUN_DATA_OFFSET
int64_t next_root_atom
offset of the next root atom
unsigned int nb_chapter_tracks
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
static int mov_read_dvc1(MOVContext *c, AVIOContext *pb, MOVAtom atom)
int pseudo_stream_id
-1 means demux all ids
#define AV_CH_FRONT_RIGHT
static int64_t mov_read_atom_into_extradata(MOVContext *c, AVIOContext *pb, MOVAtom atom, AVCodecParameters *par, uint8_t *buf)
int64_t duration
Duration of the stream, in AV_TIME_BASE fractional seconds.
int ffindex
AVStream index.
uint8_t ** extradata
extradata array (and size) for multiple stsd
static int mov_read_trex(MOVContext *c, AVIOContext *pb, MOVAtom atom)
static int mov_read_stsc(MOVContext *c, AVIOContext *pb, MOVAtom atom)
static void mov_current_sample_set(MOVStreamContext *sc, int current_sample)
#define AV_LOG_FATAL
Something went wrong and recovery is not possible.
AVCodecParameters * codecpar
#define av_malloc_array(a, b)
int avio_get_str(AVIOContext *pb, int maxlen, char *buf, int buflen)
Read a string from pb into buf.
int avio_feof(AVIOContext *s)
feof() equivalent for AVIOContext.
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
static int mov_read_alac(MOVContext *c, AVIOContext *pb, MOVAtom atom)
static int mov_read_stsz(MOVContext *c, AVIOContext *pb, MOVAtom atom)
uint8_t * av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type, int size)
Allocate new information of a packet.
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
static double cr(void *priv, double x, double y)
AVStereo3D * av_stereo3d_alloc(void)
Allocate an AVStereo3D structure and set its fields to default values.
#define MKTAG(a, b, c, d)
enum AVDiscard discard
Selects which packets can be discarded at will and do not need to be demuxed.
static void fix_timescale(MOVContext *c, MOVStreamContext *sc)
AVRational r_frame_rate
Real base framerate of the stream.
int(* io_open)(struct AVFormatContext *s, AVIOContext **pb, const char *url, int flags, AVDictionary **options)
static int mov_switch_root(AVFormatContext *s, int64_t target)
const char *const ff_id3v1_genre_str[ID3v1_GENRE_MAX+1]
ID3v1 genres.
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
This structure stores compressed data.
static int mov_read_sbgp(MOVContext *c, AVIOContext *pb, MOVAtom atom)
mode
Use these values in ebur128_init (or'ed).
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
int found_hdlr_mdta
'hdlr' atom with type 'mdta' has been found
AVPacket attached_pic
For streams with AV_DISPOSITION_ATTACHED_PIC disposition, this packet will contain the attached pictu...
#define AV_NOPTS_VALUE
Undefined timestamp value.
static uint32_t yuv_to_rgba(uint32_t ycbcr)
#define AV_TIMECODE_STR_SIZE
#define MOV_FRAG_SAMPLE_FLAG_IS_NON_SYNC
This side data should be associated with an audio stream and corresponds to enum AVAudioServiceType.