32 #include "libavutil/attributes.h"
33 #include "libavutil/channel_layout.h"
34 #include "libavutil/intreadwrite.h"
35 #include "libavutil/intfloat.h"
36 #include "libavutil/mathematics.h"
37 #include "libavutil/avstring.h"
38 #include "libavutil/dict.h"
70 unsigned len,
const char *key)
74 short current, total = 0;
80 snprintf(buf,
sizeof(buf),
"%d", current);
82 snprintf(buf,
sizeof(buf),
"%d/%d", current, total);
90 unsigned len,
const char *key)
99 snprintf(buf,
sizeof(buf),
"%d",
avio_r8(pb));
107 unsigned len,
const char *key)
111 snprintf(buf,
sizeof(buf),
"%d",
avio_r8(pb));
119 unsigned len,
const char *key)
137 0x00C4,0x00C5,0x00C7,0x00C9,0x00D1,0x00D6,0x00DC,0x00E1,
138 0x00E0,0x00E2,0x00E4,0x00E3,0x00E5,0x00E7,0x00E9,0x00E8,
139 0x00EA,0x00EB,0x00ED,0x00EC,0x00EE,0x00EF,0x00F1,0x00F3,
140 0x00F2,0x00F4,0x00F6,0x00F5,0x00FA,0x00F9,0x00FB,0x00FC,
141 0x2020,0x00B0,0x00A2,0x00A3,0x00A7,0x2022,0x00B6,0x00DF,
142 0x00AE,0x00A9,0x2122,0x00B4,0x00A8,0x2260,0x00C6,0x00D8,
143 0x221E,0x00B1,0x2264,0x2265,0x00A5,0x00B5,0x2202,0x2211,
144 0x220F,0x03C0,0x222B,0x00AA,0x00BA,0x03A9,0x00E6,0x00F8,
145 0x00BF,0x00A1,0x00AC,0x221A,0x0192,0x2248,0x2206,0x00AB,
146 0x00BB,0x2026,0x00A0,0x00C0,0x00C3,0x00D5,0x0152,0x0153,
147 0x2013,0x2014,0x201C,0x201D,0x2018,0x2019,0x00F7,0x25CA,
148 0x00FF,0x0178,0x2044,0x20AC,0x2039,0x203A,0xFB01,0xFB02,
149 0x2021,0x00B7,0x201A,0x201E,0x2030,0x00C2,0x00CA,0x00C1,
150 0x00CB,0x00C8,0x00CD,0x00CE,0x00CF,0x00CC,0x00D3,0x00D4,
151 0xF8FF,0x00D2,0x00DA,0x00DB,0x00D9,0x0131,0x02C6,0x02DC,
152 0x00AF,0x02D8,0x02D9,0x02DA,0x00B8,0x02DD,0x02DB,0x02C7,
156 char *dst,
int dstlen)
159 char *end = dst+dstlen-1;
162 for (i = 0; i <
len; i++) {
164 if (c < 0x80 && p < end)
217 char language[4] = { 0 };
219 uint16_t langcode = 0;
220 double longitude, latitude;
221 const char *key =
"location";
223 if (len < 4 + 2 + 1 + 1 + 4 + 4 + 4)
243 snprintf(buf,
sizeof(buf),
"%+08.4f%+09.4f/", latitude, longitude);
244 if (*language && strcmp(language,
"und")) {
246 snprintf(key2,
sizeof(key2),
"%s-%s", key, language);
255 #ifdef MOV_EXPORT_ALL_METADATA
258 char str[1024], key2[16], language[4] = {0};
259 const char *key =
NULL;
260 uint16_t langcode = 0;
261 uint32_t data_type = 0, str_size;
265 case MKTAG(0xa9,
'n',
'a',
'm'): key =
"title";
break;
266 case MKTAG(0xa9,
'a',
'u',
't'):
267 case MKTAG(0xa9,
'A',
'R',
'T'): key =
"artist";
break;
268 case MKTAG(
'a',
'A',
'R',
'T'): key =
"album_artist";
break;
269 case MKTAG(0xa9,
'w',
'r',
't'): key =
"composer";
break;
270 case MKTAG(
'c',
'p',
'r',
't'):
271 case MKTAG(0xa9,
'c',
'p',
'y'): key =
"copyright";
break;
272 case MKTAG(0xa9,
'c',
'm',
't'):
273 case MKTAG(0xa9,
'i',
'n',
'f'): key =
"comment";
break;
274 case MKTAG(0xa9,
'a',
'l',
'b'): key =
"album";
break;
275 case MKTAG(0xa9,
'd',
'a',
'y'): key =
"date";
break;
276 case MKTAG(0xa9,
'g',
'e',
'n'): key =
"genre";
break;
277 case MKTAG(
'g',
'n',
'r',
'e'): key =
"genre";
279 case MKTAG(0xa9,
't',
'o',
'o'):
280 case MKTAG(0xa9,
's',
'w',
'r'): key =
"encoder";
break;
281 case MKTAG(0xa9,
'e',
'n',
'c'): key =
"encoder";
break;
282 case MKTAG(0xa9,
'x',
'y',
'z'): key =
"location";
break;
283 case MKTAG(
'd',
'e',
's',
'c'): key =
"description";
break;
284 case MKTAG(
'l',
'd',
'e',
's'): key =
"synopsis";
break;
285 case MKTAG(
't',
'v',
's',
'h'): key =
"show";
break;
286 case MKTAG(
't',
'v',
'e',
'n'): key =
"episode_id";
break;
287 case MKTAG(
't',
'v',
'n',
'n'): key =
"network";
break;
288 case MKTAG(
't',
'r',
'k',
'n'): key =
"track";
290 case MKTAG(
'd',
'i',
's',
'k'): key =
"disc";
292 case MKTAG(
't',
'v',
'e',
's'): key =
"episode_sort";
294 case MKTAG(
't',
'v',
's',
'n'): key =
"season_number";
296 case MKTAG(
's',
't',
'i',
'k'): key =
"media_type";
298 case MKTAG(
'h',
'd',
'v',
'd'): key =
"hd_video";
300 case MKTAG(
'p',
'g',
'a',
'p'): key =
"gapless_playback";
302 case MKTAG(
'l',
'o',
'c',
'i'):
309 if (tag ==
MKTAG(
'd',
'a',
't',
'a')) {
312 str_size = data_size - 16;
315 if (atom.
type ==
MKTAG(
'c',
'o',
'v',
'r')) {
329 str_size = atom.
size;
331 #ifdef MOV_EXPORT_ALL_METADATA
333 snprintf(tmp_key, 5,
"%.4s", (
char*)&atom.
type);
343 str_size =
FFMIN3(
sizeof(str)-1, str_size, atom.
size);
346 parse(c, pb, str_size, key);
348 if (data_type == 3 || (data_type == 0 && (langcode < 0x400 || langcode == 0x7fff))) {
356 if (*language && strcmp(language,
"und")) {
357 snprintf(key2,
sizeof(key2),
"%s-%s", key, language);
361 av_dlog(c->
fc,
"lang \"%3s\" ", language);
362 av_dlog(c->
fc,
"tag \"%s\" value \"%s\" atom \"%.4s\" %d %"PRId64
"\n",
363 key, str, (
char*)&atom.
type, str_size, atom.
size);
371 int i, nb_chapters, str_len,
version;
374 if ((atom.
size -= 5) < 0)
383 for (i = 0; i < nb_chapters; i++) {
390 if ((atom.
size -= 9+str_len) < 0)
400 #define MIN_DATA_ENTRY_BOX_SIZE 12
415 entries >= UINT_MAX /
sizeof(*sc->
drefs))
433 av_dlog(c->
fc,
"type %.4s size %d\n", (
char*)&dref->
type, size);
435 if (dref->
type ==
MKTAG(
'a',
'l',
'i',
's') && size > 150) {
437 uint16_t volume_len,
len;
443 volume_len =
FFMIN(volume_len, 27);
445 dref->
volume[volume_len] = 0;
451 len =
FFMIN(len, 63);
466 for (type = 0; type != -1 &&
avio_tell(pb) < next; ) {
480 if (len > volume_len && !strncmp(dref->
path, dref->
volume, volume_len)) {
482 memmove(dref->
path, dref->
path+volume_len, len);
485 for (j = 0; j <
len; j++)
486 if (dref->
path[j] ==
':')
489 }
else if (type == 0) {
496 for (j = 0; j <
len; j++)
497 if (dref->
dir[j] ==
':')
527 av_dlog(c->
fc,
"ctype= %.4s (0x%08x)\n", (
char*)&ctype, ctype);
528 av_dlog(c->
fc,
"stype= %.4s\n", (
char*)&type);
530 if (type ==
MKTAG(
'v',
'i',
'd',
'e'))
532 else if (type ==
MKTAG(
's',
'o',
'u',
'n'))
534 else if (type ==
MKTAG(
'm',
'1',
'a',
' '))
536 else if ((type ==
MKTAG(
's',
'u',
'b',
'p')) || (type ==
MKTAG(
'c',
'l',
'c',
'p')))
576 int ac3info, acmod, lfeon, bsmod;
583 bsmod = (ac3info >> 14) & 0x7;
584 acmod = (ac3info >> 11) & 0x7;
585 lfeon = (ac3info >> 10) & 0x1;
586 st->
codec->
channels = ((
int[]){2,1,2,3,3,4,4,5})[acmod] + lfeon;
600 int eac3info, acmod, lfeon, bsmod;
611 bsmod = (eac3info >> 12) & 0x1f;
612 acmod = (eac3info >> 9) & 0x7;
613 lfeon = (eac3info >> 8) & 0x1;
667 "sample aspect ratio already set to %d:%d, ignoring 'pasp' atom (%d:%d)\n",
670 }
else if (den != 0) {
691 char minor_ver_str[11];
692 char* comp_brands_str;
696 if (strcmp(type,
"qt "))
701 snprintf(minor_ver_str,
sizeof(minor_ver_str),
"%"PRIu32
"", minor_ver);
704 comp_brand_size = atom.
size - 8;
705 if (comp_brand_size < 0)
707 comp_brands_str =
av_malloc(comp_brand_size + 1);
708 if (!comp_brands_str)
710 avio_read(pb, comp_brands_str, comp_brand_size);
711 comp_brands_str[comp_brand_size] = 0;
746 strftime(buffer,
sizeof(buffer),
"%Y-%m-%d %H:%M:%S", ptm);
756 char language[4] = {0};
758 time_t creation_time;
798 time_t creation_time;
842 if ((uint64_t)atom.
size > (1<<30))
868 av_dlog(c->
fc,
"enda %d\n", little_endian);
869 if (little_endian == 1) {
893 unsigned mov_field_order;
902 if ((mov_field_order & 0xFF00) == 0x0100)
904 else if ((mov_field_order & 0xFF00) == 0x0200) {
905 switch (mov_field_order & 0xFF) {
936 if (size > INT_MAX || (uint64_t)atom.
size > INT_MAX)
958 if ((uint64_t)atom.
size > (1<<30))
969 }
else if (atom.
size > 8) {
990 if ((uint64_t)atom.
size > (1<<30))
993 if (atom.
size >= 10) {
999 if (type ==
MKTAG(
'f',
'i',
'e',
'l') && size == atom.
size)
1020 if (atom.
size >= (1<<28) || atom.
size < 7)
1024 if ((profile_level & 0xf0) != 0xc0)
1048 if (atom.
size <= 40)
1052 if ((uint64_t)atom.
size > (1<<30))
1069 unsigned int i, entries;
1083 if (entries >= UINT_MAX/
sizeof(int64_t))
1091 if (atom.
type ==
MKTAG(
's',
't',
'c',
'o'))
1094 else if (atom.
type ==
MKTAG(
'c',
'o',
'6',
'4'))
1127 ((format & 0xFFFF) ==
'm' + (
's' << 8) ||
1128 (format & 0xFFFF) ==
'T' + (
'S' << 8)))
1135 format && format !=
MKTAG(
'm',
'p',
'4',
's')) {
1157 unsigned int color_depth,
len, j;
1158 int color_greyscale;
1186 if (!memcmp(codec_name,
"Planar Y'CbCr 8-bit 4:2:0", 25))
1190 !memcmp(codec_name,
"Sorenson H263", 13))
1195 av_dlog(c->
fc,
"depth %d, ctab id %d\n",
1202 if ((color_depth == 2) || (color_depth == 4) || (color_depth == 8)) {
1204 unsigned int color_start, color_count, color_end;
1205 unsigned char r,
g,
b;
1207 if (color_greyscale) {
1208 int color_index, color_dec;
1211 color_count = 1 << color_depth;
1213 color_dec = 256 / (color_count - 1);
1214 for (j = 0; j < color_count; j++) {
1215 r = g = b = color_index;
1216 sc->
palette[j] = (r << 16) | (g << 8) | (
b);
1217 color_index -= color_dec;
1218 if (color_index < 0)
1221 }
else if (color_table_id) {
1224 color_count = 1 << color_depth;
1225 if (color_depth == 2)
1227 else if (color_depth == 4)
1232 for (j = 0; j < color_count; j++) {
1233 r = color_table[j * 3 + 0];
1234 g = color_table[j * 3 + 1];
1235 b = color_table[j * 3 + 2];
1236 sc->
palette[j] = (r << 16) | (g << 8) | (
b);
1243 if ((color_start <= 255) && (color_end <= 255)) {
1244 for (j = color_start; j <= color_end; j++) {
1256 sc->
palette[j] = (r << 16) | (g << 8) | (
b);
1267 int bits_per_sample,
flags;
1283 av_dlog(c->
fc,
"version =%d, isom =%d\n", version, c->
isom);
1290 }
else if (version == 2) {
1344 if (bits_per_sample) {
1369 y = (ycbcr >> 16) & 0xFF;
1370 cr = (ycbcr >> 8) & 0xFF;
1373 b = av_clip_uint8(1.164 * (y - 16) + 2.018 * (cb - 128));
1374 g = av_clip_uint8(1.164 * (y - 16) - 0.813 * (cr - 128) - 0.391 * (cb - 128));
1375 r = av_clip_uint8(1.164 * (y - 16) + 1.596 * (cr - 128));
1377 return (r << 16) | (g << 8) | b;
1382 char buf[256] = {0};
1390 snprintf(buf,
sizeof(buf),
"size: %dx%d\n",
1394 for (i = 0; i < 16; i++) {
1395 uint32_t yuv =
AV_RB32(src + i * 4);
1398 av_strlcatf(buf,
sizeof(buf),
"%06"PRIx32
"%s", rgba, i != 15 ?
", " :
"");
1401 if (
av_strlcat(buf,
"\n",
sizeof(buf)) >=
sizeof(buf))
1441 #if CONFIG_DV_DEMUXER
1497 int codec_tag,
int format,
1503 (codec_tag ==
AV_RL32(
"avc1") ||
1504 codec_tag ==
AV_RL32(
"hvc1") ||
1505 codec_tag ==
AV_RL32(
"hev1") ||
1506 (codec_tag != format &&
1508 : codec_tag !=
MKTAG(
'j',
'p',
'e',
'g'))))) {
1525 int pseudo_stream_id;
1532 for (pseudo_stream_id = 0;
1534 pseudo_stream_id++) {
1537 int ret, dref_id = 1;
1561 av_dlog(c->
fc,
"size=%"PRIu32
" 4CC= %"PRIu8
"%"PRIu8
"%"PRIu8
"%"PRIu8
" codec_type=%d\n", size,
1562 (format >> 0) & 0xff, (format >> 8) & 0xff, (format >> 16) & 0xff,
1586 }
else if (a.
size > 0)
1611 unsigned int i, entries;
1627 if (entries >= UINT_MAX /
sizeof(*sc->
stsc_data))
1633 for (i = 0; i < entries && !pb->
eof_reached; i++) {
1651 unsigned i, entries;
1661 if (entries >= UINT_MAX /
sizeof(*sc->
stps_data))
1667 for (i = 0; i < entries && !pb->
eof_reached; i++) {
1684 unsigned int i, entries;
1696 av_dlog(c->
fc,
"keyframe_count = %d\n", entries);
1703 if (entries >= UINT_MAX /
sizeof(
int))
1709 for (i = 0; i < entries && !pb->
eof_reached; i++) {
1726 unsigned int i, entries, sample_size, field_size, num_bytes;
1738 if (atom.
type ==
MKTAG(
's',
't',
's',
'z')) {
1756 if (field_size != 4 && field_size != 8 && field_size != 16 && field_size != 32) {
1763 if (entries >= UINT_MAX /
sizeof(
int) || entries >= (UINT_MAX - 4) / field_size)
1769 num_bytes = (entries*field_size+4)>>3;
1777 if (
avio_read(pb, buf, num_bytes) < num_bytes) {
1785 for (i = 0; i < entries && !pb->
eof_reached; i++) {
1803 unsigned int i, entries;
1805 int64_t total_sample_count=0;
1816 av_dlog(c->
fc,
"track[%i].stts.entries = %i\n",
1821 if (entries >= UINT_MAX /
sizeof(*sc->
stts_data))
1829 for (i = 0; i < entries && !pb->
eof_reached; i++) {
1830 int sample_duration;
1835 if (sample_count < 0) {
1842 av_dlog(c->
fc,
"sample_count=%d, sample_duration=%d\n",
1843 sample_count, sample_duration);
1845 duration+=(int64_t)sample_duration*sample_count;
1846 total_sample_count+=sample_count;
1865 unsigned int i, entries;
1880 if (entries >= UINT_MAX /
sizeof(*sc->
ctts_data))
1886 for (i = 0; i < entries && !pb->
eof_reached; i++) {
1910 unsigned int i, entries;
1912 uint32_t grouping_type;
1922 if (grouping_type !=
MKTAG(
'r',
'a',
'p',
' '))
1930 if (entries >= UINT_MAX /
sizeof(*sc->
rap_group))
1936 for (i = 0; i < entries && !pb->
eof_reached; i++) {
1949 int64_t current_offset;
1950 int64_t current_dts = 0;
1951 unsigned int stts_index = 0;
1952 unsigned int stsc_index = 0;
1953 unsigned int stss_index = 0;
1954 unsigned int stps_index = 0;
1956 uint64_t stream_size = 0;
1975 unsigned int current_sample = 0;
1976 unsigned int stts_sample = 0;
1977 unsigned int sample_size;
1979 unsigned int rap_group_index = 0;
1980 unsigned int rap_group_sample = 0;
2019 if (rap_group_present && rap_group_index < sc->rap_group_count) {
2022 if (++rap_group_sample == sc->
rap_group[rap_group_index].
count) {
2023 rap_group_sample = 0;
2033 e->
pos = current_offset;
2035 e->
size = sample_size;
2038 av_dlog(mov->
fc,
"AVIndex stream %d, sample %d, offset %"PRIx64
", dts %"PRId64
", "
2039 "size %d, distance %d, keyframe %d\n", st->
index, current_sample,
2040 current_offset, current_dts, sample_size, distance, keyframe);
2043 current_offset += sample_size;
2044 stream_size += sample_size;
2058 unsigned chunk_samples, total = 0;
2062 unsigned count, chunk_count;
2075 count = (chunk_samples+samples-1) / samples;
2077 count = (chunk_samples+1023) / 1024;
2080 if (i < sc->stsc_count - 1)
2084 total += chunk_count * count;
2087 av_dlog(mov->
fc,
"chunk count %d\n", total);
2106 while (chunk_samples > 0) {
2108 unsigned size, samples;
2119 samples =
FFMIN(1024, chunk_samples);
2129 e->
pos = current_offset;
2134 av_dlog(mov->
fc,
"AVIndex stream %d, chunk %d, offset %"PRIx64
", dts %"PRId64
", "
2135 "size %d, duration %d\n", st->
index, i, current_offset, current_dts,
2138 current_offset +=
size;
2139 current_dts += samples;
2140 chunk_samples -= samples;
2152 char filename[1024];
2157 src_path = strrchr(src,
'/');
2164 for (i = 0, l = strlen(ref->
path) - 1; l >= 0; l--)
2165 if (ref->
path[l] ==
'/') {
2173 if (i == ref->
nlvl_to - 1 && src_path - src <
sizeof(filename)) {
2174 memcpy(filename, src, src_path - src);
2175 filename[src_path - src] = 0;
2197 if (!st)
return AVERROR(ENOMEM);
2200 if (!sc)
return AVERROR(ENOMEM);
2232 "stream %d, error opening alias: path='%s', dir='%s', "
2233 "filename='%s', volume='%s', nlvl_from=%d, nlvl_to=%d\n",
2256 #if CONFIG_H261_DECODER
2259 #if CONFIG_H263_DECODER
2262 #if CONFIG_MPEG4_DECODER
2297 for (i = 0; i < 2; i++) {
2308 if (len < 12 || len - 12 > end -
avio_tell(pb))
2312 if (tag ==
MKTAG(
'n',
'a',
'm',
'e'))
2314 else if (tag ==
MKTAG(
'd',
'a',
't',
'a') && len > 4) {
2351 if (len > atom.
size)
2354 if (tag ==
MKTAG(
'm',
'e',
'a',
'n') && len > 12) {
2361 domain_len =
avio_get_str(pb, len, domain,
sizeof(domain));
2363 if (!strcmp(domain,
"org.hydrogenaudio.replaygain"))
2369 "Unhandled or malformed custom metadata of size %"PRId64
"\n", atom.
size);
2375 while (atom.
size > 8) {
2378 if (tag ==
MKTAG(
'h',
'd',
'l',
'r')) {
2392 int64_t disp_transform[2];
2393 int display_matrix[3][3];
2432 for (i = 0; i < 3; i++) {
2440 sc->
width = width >> 16;
2441 sc->
height = height >> 16;
2444 if (display_matrix[0][0] != (1 << 16) ||
2445 display_matrix[1][1] != (1 << 16) ||
2446 display_matrix[2][2] != (1 << 30) ||
2447 display_matrix[0][1] || display_matrix[0][2] ||
2448 display_matrix[1][0] || display_matrix[1][2] ||
2449 display_matrix[2][0] || display_matrix[2][1]) {
2457 for (i = 0; i < 3; i++)
2458 for (j = 0; j < 3; j++)
2466 if (width && height &&
2467 ((display_matrix[0][0] != 65536 ||
2468 display_matrix[1][1] != 65536) &&
2469 !display_matrix[0][1] &&
2470 !display_matrix[1][0] &&
2471 !display_matrix[2][0] && !display_matrix[2][1])) {
2472 for (i = 0; i < 2; i++)
2474 (int64_t) width * display_matrix[0][i] +
2475 (int64_t) height * display_matrix[1][i] +
2476 ((int64_t) display_matrix[2][i] << 16);
2480 ((
double) disp_transform[0] * height) /
2481 ((
double) disp_transform[1] * width), INT_MAX);
2490 int flags, track_id, i;
2561 int data_offset = 0;
2562 unsigned entries, first_sample_flags = frag->
flags;
2581 av_dlog(c->
fc,
"flags 0x%x entries %d\n", flags, entries);
2611 av_dlog(c->
fc,
"first sample flags 0x%x\n", first_sample_flags);
2612 for (i = 0; i < entries && !pb->
eof_reached; i++) {
2613 unsigned sample_size = frag->
size;
2614 int sample_flags = i ? frag->
flags : first_sample_flags;
2615 unsigned sample_duration = frag->
duration;
2627 else if (!found_keyframe)
2628 keyframe = found_keyframe =
2635 av_dlog(c->
fc,
"AVIndex stream %d, sample %d, offset %"PRIx64
", dts %"PRId64
", "
2637 offset, dts, sample_size, distance, keyframe);
2639 dts += sample_duration;
2640 offset += sample_size;
2667 if (atom.
type !=
MKTAG(
'm',
'd',
'a',
't')) {
2681 long cmov_len, moov_len;
2695 cmov_len = atom.
size - 6 * 4;
2706 if (uncompress (moov_data, (uLongf *) &moov_len, (
const Bytef *)cmov_data, cmov_len) != Z_OK)
2707 goto free_and_return;
2709 goto free_and_return;
2711 atom.
size = moov_len;
2737 if ((uint64_t)edit_count*12+8 > atom.
size)
2740 for (i=0; i<edit_count; i++){
2751 if (i == 0 && time >= -1) {
2758 "a/v desync might occur, patch welcome\n");
2829 int64_t total_size = 0;
2834 atom.
size = INT64_MAX;
2839 if (atom.
size >= 8) {
2843 av_dlog(c->
fc,
"type: %08x '%.4s' parent:'%.4s' sz: %"PRId64
" %"PRId64
" %"PRId64
"\n",
2860 for (i = 0; mov_default_parse_table[i].
type; i++)
2861 if (mov_default_parse_table[i].type == a.
type) {
2876 int err =
parse(c, pb, a);
2889 else if (left < 0) {
2891 "overread end of atom '%.4s' by %"PRId64
" bytes\n",
2892 (
char*)&a.
type, -left);
2897 total_size += a.
size;
2900 if (total_size < atom.
size && atom.
size < 0x7ffff)
2908 unsigned int offset;
2916 if ((offset + 8) > (
unsigned int)p->
buf_size)
2921 case MKTAG(
'j',
'P',
' ',
' '):
2922 case MKTAG(
'm',
'o',
'o',
'v'):
2923 case MKTAG(
'm',
'd',
'a',
't'):
2924 case MKTAG(
'p',
'n',
'o',
't'):
2925 case MKTAG(
'u',
'd',
't',
'a'):
2926 case MKTAG(
'f',
't',
'y',
'p'):
2929 case MKTAG(
'e',
'd',
'i',
'w'):
2930 case MKTAG(
'w',
'i',
'd',
'e'):
2931 case MKTAG(
'f',
'r',
'e',
'e'):
2932 case MKTAG(
'j',
'u',
'n',
'k'):
2933 case MKTAG(
'p',
'i',
'c',
't'):
2935 case MKTAG(0x82,0x82,0x7f,0x7d):
2936 case MKTAG(
's',
'k',
'i',
'p'):
2937 case MKTAG(
'u',
'u',
'i',
'd'):
2938 case MKTAG(
'p',
'r',
'f',
'l'):
2987 if (len > sample->
size-2)
2989 title_len = 2*len + 1;
3002 else if (ch == 0xfffe)
3006 if (len == 1 || len == 2)
3035 if (sc->
pb && sc->
pb != s->
pb)
3071 atom.
size = INT64_MAX;
3154 int64_t best_dts = INT64_MAX;
3165 ((msc->
pb != s->
pb && dts < best_dts) || (msc->
pb == s->
pb &&
3168 sample = current_sample;
3222 #if CONFIG_DV_DEMUXER
3257 av_dlog(s,
"stream %d, pts %"PRId64
", dts %"PRId64
", pos 0x%"PRIx64
", duration %d\n",
3269 av_dlog(s,
"stream %d, timestamp %"PRId64
", sample %d\n", st->
index, timestamp, sample);
3270 if (sample < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
3295 int64_t seek_timestamp, timestamp;
3301 if (sample_time < 0)
3304 st = s->
streams[stream_index];
3314 if (stream_index == i)
3324 .
name =
"mov,mp4,m4a,3gp,3g2,mj2",
3327 .extensions =
"mov,mp4,m4a,3gp,3g2,mj2",
int itunes_metadata
metadata are itunes style
static int mov_read_moof(MOVContext *c, AVIOContext *pb, MOVAtom atom)
static int mov_read_esds(MOVContext *c, AVIOContext *pb, MOVAtom atom)
static int mov_read_enda(MOVContext *c, AVIOContext *pb, MOVAtom atom)
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
static int mov_read_dec3(MOVContext *c, AVIOContext *pb, MOVAtom atom)
unsigned int rap_group_count
void ff_mp4_parse_es_descr(AVIOContext *pb, int *es_id)
AVIOInterruptCB interrupt_callback
Custom interrupt callbacks for the I/O layer.
static int mov_read_wide(MOVContext *c, AVIOContext *pb, MOVAtom atom)
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)
unsigned int samples_per_frame
static void mov_build_index(MOVContext *mov, AVStream *st)
static ColorEntry color_table[]
#define AV_LOG_WARNING
Something somehow does not look correct.
uint64_t base_data_offset
int64_t pos
byte position in stream, -1 if unknown
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)
AVCodecContext * codec
Codec context associated with this stream.
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
void av_log(void *avcl, int level, const char *fmt,...) av_printf_format(3
Send the specified message to the log if the level is less than or equal to the current av_log_level...
int event_flags
Flags for the user to detect events happening on the file.
AVPacketSideData * side_data
An array of side data that applies to the whole stream (i.e.
static const uint8_t ff_qt_default_palette_256[256 *3]
av_dlog(ac->avr,"%d samples - audio_convert: %s to %s (%s)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt), use_generic?ac->func_descr_generic:ac->func_descr)
int16_t audio_cid
stsd audio compression id
int(* parse)(MOVContext *ctx, AVIOContext *pb, MOVAtom atom)
static int mov_read_udta_string(MOVContext *c, AVIOContext *pb, MOVAtom atom)
int block_align
number of bytes per packet if constant and known or 0 Used by some WAV based audio codecs...
enum AVCodecID ff_mov_get_lpcm_codec_id(int bps, int flags)
Compute codec id for 'lpcm' tag.
static int mov_read_mvhd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
int found_moov
'moov' atom has been found
static int mov_read_stps(MOVContext *c, AVIOContext *pb, MOVAtom atom)
#define MOV_TFHD_DEFAULT_BASE_IS_MOOF
#define AV_DICT_DONT_STRDUP_KEY
Take ownership of a key that's been allocated with av_malloc() and children.
void av_freep(void *ptr)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
#define MOV_TKHD_FLAG_ENABLED
int isom
1 if file is ISO Media (mp4/3gp)
enum AVAudioServiceType audio_service_type
Type of service that the audio stream conveys.
int found_mdat
'mdat' atom has been found
static int mov_read_smi(MOVContext *c, AVIOContext *pb, MOVAtom atom)
#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_probe(AVProbeData *p)
static int mov_read_header(AVFormatContext *s)
static int parse(AVCodecParserContext *s, AVCodecContext *avctx, const uint8_t **poutbuf, int *poutbuf_size, const uint8_t *buf, int buf_size)
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)
Opaque data information usually continuous.
unsigned int sample_count
const AVCodecTag ff_codec_movvideo_tags[]
int dts_shift
dts shift when ctts is negative
This side data contains a 3x3 transformation matrix describing an affine transformation that needs to...
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
int id
Format-specific stream ID.
enum AVStreamParseType need_parsing
static int mov_read_replaygain(MOVContext *c, AVIOContext *pb, int size)
AVInputFormat ff_mov_demuxer
static int mov_read_cmov(MOVContext *c, AVIOContext *pb, MOVAtom atom)
int ff_mov_read_esds(AVFormatContext *fc, AVIOContext *pb)
int nb_side_data
The number of elements in the AVStream.side_data array.
#define AV_CH_LOW_FREQUENCY
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)
int flags
Flags modifying the (de)muxer behaviour.
int av_reallocp(void *ptr, size_t size)
Allocate or reallocate a block of memory.
#define MOV_TRUN_SAMPLE_SIZE
AVIndexEntry * index_entries
Only used if the format does not support seeking natively.
#define AVERROR_EOF
End of file.
bitstream reader API header.
static av_cold int read_close(AVFormatContext *ctx)
#define AV_LOG_VERBOSE
Detailed information.
static int mov_read_hdlr(MOVContext *c, AVIOContext *pb, MOVAtom atom)
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
int ff_replaygain_export(AVStream *st, AVDictionary *metadata)
Parse replaygain tags and export them as per-stream side data.
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
int duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
enum AVCodecID video_codec_id
Forced video codec_id.
#define MOV_TFHD_DEFAULT_SIZE
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
int64_t time_offset
time offset of the first edit list entry
static int mov_read_custom(MOVContext *c, AVIOContext *pb, MOVAtom atom)
unsigned int keyframe_count
static const uint8_t ff_qt_default_palette_4[4 *3]
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq) av_const
Rescale a 64-bit integer by 2 rational numbers.
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)
Callback for checking whether to abort blocking functions.
static int mov_rewrite_dvd_sub_extradata(AVStream *st)
int ff_mp4_read_dec_config_descr(AVFormatContext *fc, AVStream *st, AVIOContext *pb)
int av_reallocp_array(void *ptr, size_t nmemb, size_t size)
AVCodecID
Identify the syntax and semantics of the bitstream.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
int has_b_frames
Size of the frame reordering buffer in the decoder.
int av_get_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
void av_free(void *ptr)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc(). ...
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)
void * priv_data
Format private data.
char filename[1024]
input or output filename
static int mov_read_ctts(MOVContext *c, AVIOContext *pb, MOVAtom atom)
int ff_get_wav_header(AVIOContext *pb, AVCodecContext *codec, int size)
static int mov_read_wave(MOVContext *c, AVIOContext *pb, MOVAtom atom)
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
preferred ID for decoding MPEG audio layer 1, 2 or 3
int av_get_channel_layout_nb_channels(uint64_t channel_layout)
Return the number of channels in the channel layout.
static void mov_metadata_creation_time(AVDictionary **metadata, time_t time)
static int mov_read_trun(MOVContext *c, AVIOContext *pb, MOVAtom atom)
enum AVPacketSideDataType type
const AVCodecTag ff_codec_wav_tags[]
#define MOV_FRAG_SAMPLE_FLAG_DEPENDS_YES
int min_distance
Minimum distance between this and the previous keyframe, used to avoid unneeded searching.
uint8_t * av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type, int size)
Allocate new information of a packet.
const AVCodecTag ff_codec_movsubtitle_tags[]
#define MIN_DATA_ENTRY_BOX_SIZE
int flags
A combination of AV_PKT_FLAG values.
uint64_t channel_layout
Audio channel layout.
int ff_mov_read_stsd_entries(MOVContext *c, AVIOContext *pb, int entries)
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)
#define FF_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
static int mov_read_mdhd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
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)
static int mov_read_stts(MOVContext *c, AVIOContext *pb, MOVAtom atom)
int seekable
A combination of AVIO_SEEKABLE_ flags or 0 when the stream is not seekable.
int bit_rate
the average bitrate
AVRational av_d2q(double d, int max) av_const
Convert a double precision floating point number to a rational.
const AVIOInterruptCB int_cb
static int mov_read_chap(MOVContext *c, AVIOContext *pb, MOVAtom atom)
int64_t av_rescale(int64_t a, int64_t b, int64_t c) av_const
Rescale a 64-bit integer with rounding to nearest.
#define AV_TIME_BASE
Internal time base represented as integer.
void * av_realloc(void *ptr, size_t size) 1(2)
Allocate or reallocate a block of memory.
const AVCodecTag ff_codec_bmp_tags[]
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() and chilren.
int width
picture width / height.
AVStream ** streams
A list of all streams in the file.
static int mov_open_dref(AVIOContext **pb, char *src, MOVDref *ref, AVIOInterruptCB *int_cb)
void * av_malloc(size_t size) av_malloc_attrib 1(1)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
internal header for RIFF based (de)muxers do NOT include this in end user applications ...
static int mov_read_tfhd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
static int mov_parse_stsd_data(MOVContext *c, AVIOContext *pb, AVStream *st, MOVStreamContext *sc, int size)
#define MOV_TRUN_SAMPLE_DURATION
static int mov_read_packet(AVFormatContext *s, AVPacket *pkt)
static int mov_read_close(AVFormatContext *s)
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
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.
static int read_header(FFV1Context *f)
if(ac->has_optimized_func)
int64_t duration
duration of the longest track
int ff_mov_lang_to_iso639(unsigned code, char to[4])
static int mov_read_covr(MOVContext *c, AVIOContext *pb, int type, int len)
#define AVERROR_PATCHWELCOME
Not yet implemented in Libav, patches welcome.
DVDemuxContext * dv_demux
static int mov_read_seek(AVFormatContext *s, int stream_index, int64_t sample_time, int flags)
static const uint32_t mac_to_unicode[128]
static int mov_read_dref(MOVContext *c, AVIOContext *pb, MOVAtom atom)
enum AVMediaType codec_type
#define MP4DecConfigDescrTag
const AVCodecTag ff_codec_movaudio_tags[]
static void mov_read_chapters(AVFormatContext *s)
int sample_rate
samples per second
static void mov_parse_stsd_video(MOVContext *c, AVIOContext *pb, AVStream *st, MOVStreamContext *sc)
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)
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
AVIOContext * pb
I/O context.
static int read_packet(AVFormatContext *ctx, AVPacket *pkt)
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
rational number numerator/denominator
MOVFragment fragment
current fragment in moof atom
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
int64_t track_end
used for dts generation in fragmented movie files
static const uint8_t ff_qt_default_palette_16[16 *3]
AVDictionary * metadata
Metadata that applies to the whole file.
static void mov_parse_stsd_audio(MOVContext *c, AVIOContext *pb, AVStream *st, MOVStreamContext *sc)
static int mov_read_mac_string(MOVContext *c, AVIOContext *pb, int len, char *dst, int dstlen)
#define MOV_TFHD_DEFAULT_FLAGS
void avformat_free_context(AVFormatContext *s)
Free an AVFormatContext and all its streams.
#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...
#define MKTAG(a, b, c, d)
static int mov_read_meta(MOVContext *c, AVIOContext *pb, MOVAtom atom)
unsigned * stps_data
partial sync sample for mpeg-2 open gop
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)
int64_t duration
Decoding: duration of the stream, in stream time base.
int ff_mp4_read_descr(AVFormatContext *fc, AVIOContext *pb, int *tag)
static int mov_read_strf(MOVContext *c, AVIOContext *pb, MOVAtom atom)
An strf atom is a BITMAPINFOHEADER struct.
unsigned int bytes_per_frame
int wrong_dts
dts are wrong due to huge ctts offset (iMovie files)
static av_always_inline double av_int2double(uint64_t i)
Reinterpret a 64-bit integer as a double.
#define MOV_TFHD_BASE_DATA_OFFSET
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))
static const MOVParseTableEntry mov_default_parse_table[]
static int mov_read_chan(MOVContext *c, AVIOContext *pb, MOVAtom atom)
int disposition
AV_DISPOSITION_* bit field.
AVFormatContext * avformat_alloc_context(void)
Allocate an AVFormatContext.
static int mov_read_extradata(MOVContext *c, AVIOContext *pb, MOVAtom atom)
static int mov_codec_id(AVStream *st, uint32_t format)
int64_t nb_frames
number of frames in this stream if known or 0
static int mov_metadata_loci(MOVContext *c, AVIOContext *pb, unsigned len)
static int mov_read_stco(MOVContext *c, AVIOContext *pb, MOVAtom atom)
static int mov_skip_multiple_stsd(MOVContext *c, AVIOContext *pb, int codec_tag, int format, int size)
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
as in Berlin toast format
int channels
number of audio channels
#define MOV_TRUN_DATA_OFFSET
int64_t next_root_atom
offset of the next root atom
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
int ffindex
AVStream index.
enum AVFieldOrder field_order
Field order.
static int mov_read_trex(MOVContext *c, AVIOContext *pb, MOVAtom atom)
static int mov_read_stsc(MOVContext *c, AVIOContext *pb, MOVAtom atom)
static int mov_read_stsz(MOVContext *c, AVIOContext *pb, MOVAtom atom)
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
enum AVDiscard discard
Selects which packets can be discarded at will and do not need to be demuxed.
const char *const ff_id3v1_genre_str[ID3v1_GENRE_MAX+1]
ID3v1 genres.
This structure stores compressed data.
static int mov_read_sbgp(MOVContext *c, AVIOContext *pb, MOVAtom atom)
static void mov_parse_stsd_subtitle(MOVContext *c, AVIOContext *pb, AVStream *st, MOVStreamContext *sc, int size)
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
size_t av_strlcatf(char *dst, size_t size, const char *fmt,...) av_printf_format(3
Append output to a string, according to a format.
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.
void * av_mallocz(size_t size) av_malloc_attrib 1(1)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
static uint32_t yuv_to_rgba(uint32_t ycbcr)
#define MOV_FRAG_SAMPLE_FLAG_IS_NON_SYNC