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);
89 unsigned len,
const char *key)
98 snprintf(buf,
sizeof(buf),
"%d",
avio_r8(pb));
105 unsigned len,
const char *key)
109 snprintf(buf,
sizeof(buf),
"%d",
avio_r8(pb));
116 unsigned len,
const char *key)
133 0x00C4,0x00C5,0x00C7,0x00C9,0x00D1,0x00D6,0x00DC,0x00E1,
134 0x00E0,0x00E2,0x00E4,0x00E3,0x00E5,0x00E7,0x00E9,0x00E8,
135 0x00EA,0x00EB,0x00ED,0x00EC,0x00EE,0x00EF,0x00F1,0x00F3,
136 0x00F2,0x00F4,0x00F6,0x00F5,0x00FA,0x00F9,0x00FB,0x00FC,
137 0x2020,0x00B0,0x00A2,0x00A3,0x00A7,0x2022,0x00B6,0x00DF,
138 0x00AE,0x00A9,0x2122,0x00B4,0x00A8,0x2260,0x00C6,0x00D8,
139 0x221E,0x00B1,0x2264,0x2265,0x00A5,0x00B5,0x2202,0x2211,
140 0x220F,0x03C0,0x222B,0x00AA,0x00BA,0x03A9,0x00E6,0x00F8,
141 0x00BF,0x00A1,0x00AC,0x221A,0x0192,0x2248,0x2206,0x00AB,
142 0x00BB,0x2026,0x00A0,0x00C0,0x00C3,0x00D5,0x0152,0x0153,
143 0x2013,0x2014,0x201C,0x201D,0x2018,0x2019,0x00F7,0x25CA,
144 0x00FF,0x0178,0x2044,0x20AC,0x2039,0x203A,0xFB01,0xFB02,
145 0x2021,0x00B7,0x201A,0x201E,0x2030,0x00C2,0x00CA,0x00C1,
146 0x00CB,0x00C8,0x00CD,0x00CE,0x00CF,0x00CC,0x00D3,0x00D4,
147 0xF8FF,0x00D2,0x00DA,0x00DB,0x00D9,0x0131,0x02C6,0x02DC,
148 0x00AF,0x02D8,0x02D9,0x02DA,0x00B8,0x02DD,0x02DB,0x02C7,
152 char *dst,
int dstlen)
155 char *end = dst+dstlen-1;
158 for (i = 0; i <
len; i++) {
160 if (c < 0x80 && p < end)
213 #ifdef MOV_EXPORT_ALL_METADATA
216 char str[1024], key2[16], language[4] = {0};
217 const char *key =
NULL;
218 uint16_t langcode = 0;
219 uint32_t data_type = 0, str_size;
223 case MKTAG(0xa9,
'n',
'a',
'm'): key =
"title";
break;
224 case MKTAG(0xa9,
'a',
'u',
't'):
225 case MKTAG(0xa9,
'A',
'R',
'T'): key =
"artist";
break;
226 case MKTAG(
'a',
'A',
'R',
'T'): key =
"album_artist";
break;
227 case MKTAG(0xa9,
'w',
'r',
't'): key =
"composer";
break;
228 case MKTAG(
'c',
'p',
'r',
't'):
229 case MKTAG(0xa9,
'c',
'p',
'y'): key =
"copyright";
break;
230 case MKTAG(0xa9,
'c',
'm',
't'):
231 case MKTAG(0xa9,
'i',
'n',
'f'): key =
"comment";
break;
232 case MKTAG(0xa9,
'a',
'l',
'b'): key =
"album";
break;
233 case MKTAG(0xa9,
'd',
'a',
'y'): key =
"date";
break;
234 case MKTAG(0xa9,
'g',
'e',
'n'): key =
"genre";
break;
235 case MKTAG(
'g',
'n',
'r',
'e'): key =
"genre";
237 case MKTAG(0xa9,
't',
'o',
'o'):
238 case MKTAG(0xa9,
's',
'w',
'r'): key =
"encoder";
break;
239 case MKTAG(0xa9,
'e',
'n',
'c'): key =
"encoder";
break;
240 case MKTAG(
'd',
'e',
's',
'c'): key =
"description";
break;
241 case MKTAG(
'l',
'd',
'e',
's'): key =
"synopsis";
break;
242 case MKTAG(
't',
'v',
's',
'h'): key =
"show";
break;
243 case MKTAG(
't',
'v',
'e',
'n'): key =
"episode_id";
break;
244 case MKTAG(
't',
'v',
'n',
'n'): key =
"network";
break;
245 case MKTAG(
't',
'r',
'k',
'n'): key =
"track";
247 case MKTAG(
'd',
'i',
's',
'k'): key =
"disc";
249 case MKTAG(
't',
'v',
'e',
's'): key =
"episode_sort";
251 case MKTAG(
't',
'v',
's',
'n'): key =
"season_number";
253 case MKTAG(
's',
't',
'i',
'k'): key =
"media_type";
255 case MKTAG(
'h',
'd',
'v',
'd'): key =
"hd_video";
257 case MKTAG(
'p',
'g',
'a',
'p'): key =
"gapless_playback";
264 if (tag ==
MKTAG(
'd',
'a',
't',
'a')) {
267 str_size = data_size - 16;
270 if (atom.
type ==
MKTAG(
'c',
'o',
'v',
'r')) {
284 str_size = atom.
size;
286 #ifdef MOV_EXPORT_ALL_METADATA
288 snprintf(tmp_key, 5,
"%.4s", (
char*)&atom.
type);
298 str_size =
FFMIN3(
sizeof(str)-1, str_size, atom.
size);
301 parse(c, pb, str_size, key);
303 if (data_type == 3 || (data_type == 0 && (langcode < 0x400 || langcode == 0x7fff))) {
310 if (*language && strcmp(language,
"und")) {
311 snprintf(key2,
sizeof(key2),
"%s-%s", key, language);
315 av_dlog(c->
fc,
"lang \"%3s\" ", language);
316 av_dlog(c->
fc,
"tag \"%s\" value \"%s\" atom \"%.4s\" %d %"PRId64
"\n",
317 key, str, (
char*)&atom.
type, str_size, atom.
size);
325 int i, nb_chapters, str_len,
version;
328 if ((atom.
size -= 5) < 0)
337 for (i = 0; i < nb_chapters; i++) {
344 if ((atom.
size -= 9+str_len) < 0)
354 #define MIN_DATA_ENTRY_BOX_SIZE 12
370 entries >= UINT_MAX /
sizeof(*sc->
drefs))
389 av_dlog(c->
fc,
"type %.4s size %d\n", (
char*)&dref->
type, size);
391 if (dref->
type ==
MKTAG(
'a',
'l',
'i',
's') && size > 150) {
393 uint16_t volume_len,
len;
399 volume_len =
FFMIN(volume_len, 27);
401 dref->
volume[volume_len] = 0;
407 len =
FFMIN(len, 63);
422 for (type = 0; type != -1 &&
avio_tell(pb) < next; ) {
436 if (len > volume_len && !strncmp(dref->
path, dref->
volume, volume_len)) {
438 memmove(dref->
path, dref->
path+volume_len, len);
441 for (j = 0; j <
len; j++)
442 if (dref->
path[j] ==
':')
445 }
else if (type == 0) {
452 for (j = 0; j <
len; j++)
453 if (dref->
dir[j] ==
':')
483 av_dlog(c->
fc,
"ctype= %.4s (0x%08x)\n", (
char*)&ctype, ctype);
484 av_dlog(c->
fc,
"stype= %.4s\n", (
char*)&type);
486 if (type ==
MKTAG(
'v',
'i',
'd',
'e'))
488 else if (type ==
MKTAG(
's',
'o',
'u',
'n'))
490 else if (type ==
MKTAG(
'm',
'1',
'a',
' '))
492 else if ((type ==
MKTAG(
's',
'u',
'b',
'p')) || (type ==
MKTAG(
'c',
'l',
'c',
'p')))
532 int ac3info, acmod, lfeon, bsmod;
539 bsmod = (ac3info >> 14) & 0x7;
540 acmod = (ac3info >> 11) & 0x7;
541 lfeon = (ac3info >> 10) & 0x1;
542 st->
codec->
channels = ((
int[]){2,1,2,3,3,4,4,5})[acmod] + lfeon;
556 int eac3info, acmod, lfeon, bsmod;
567 bsmod = (eac3info >> 12) & 0x1f;
568 acmod = (eac3info >> 9) & 0x7;
569 lfeon = (eac3info >> 8) & 0x1;
623 "sample aspect ratio already set to %d:%d, ignoring 'pasp' atom (%d:%d)\n",
626 }
else if (den != 0) {
647 char minor_ver_str[11];
648 char* comp_brands_str;
652 if (strcmp(type,
"qt "))
657 snprintf(minor_ver_str,
sizeof(minor_ver_str),
"%d", minor_ver);
660 comp_brand_size = atom.
size - 8;
661 if (comp_brand_size < 0)
663 comp_brands_str =
av_malloc(comp_brand_size + 1);
664 if (!comp_brands_str)
666 avio_read(pb, comp_brands_str, comp_brand_size);
667 comp_brands_str[comp_brand_size] = 0;
702 strftime(buffer,
sizeof(buffer),
"%Y-%m-%d %H:%M:%S", ptm);
712 char language[4] = {0};
714 time_t creation_time;
754 time_t creation_time;
798 if ((uint64_t)atom.
size > (1<<30))
824 av_dlog(c->
fc,
"enda %d\n", little_endian);
825 if (little_endian == 1) {
849 unsigned mov_field_order;
858 if ((mov_field_order & 0xFF00) == 0x0100)
860 else if ((mov_field_order & 0xFF00) == 0x0200) {
861 switch (mov_field_order & 0xFF) {
891 if (size > INT_MAX || (uint64_t)atom.
size > INT_MAX)
913 if ((uint64_t)atom.
size > (1<<30))
924 }
else if (atom.
size > 8) {
945 if ((uint64_t)atom.
size > (1<<30))
948 if (atom.
size >= 10) {
954 if (type ==
MKTAG(
'f',
'i',
'e',
'l') && size == atom.
size)
975 if (atom.
size >= (1<<28) || atom.
size < 7)
979 if ((profile_level & 0xf0) != 0xc0)
1003 if (atom.
size <= 40)
1007 if ((uint64_t)atom.
size > (1<<30))
1024 unsigned int i, entries;
1038 if (entries >= UINT_MAX/
sizeof(int64_t))
1046 if (atom.
type ==
MKTAG(
's',
't',
'c',
'o'))
1049 else if (atom.
type ==
MKTAG(
'c',
'o',
'6',
'4'))
1081 int j, pseudo_stream_id;
1088 for (pseudo_stream_id = 0;
1090 pseudo_stream_id++) {
1129 if (
id<=0 && ((format&0xFFFF) ==
'm'+(
's'<<8) || (format&0xFFFF) ==
'T'+(
'S'<<8)))
1135 format && format !=
MKTAG(
'm',
'p',
'4',
's')) {
1148 av_dlog(c->
fc,
"size=%d 4CC= %c%c%c%c codec_type=%d\n", size,
1149 (format >> 0) & 0xff, (format >> 8) & 0xff, (format >> 16) & 0xff,
1153 unsigned int color_depth,
len;
1154 int color_greyscale;
1182 if (format ==
MKTAG(
'H',
'2',
'6',
'3') &&
1188 av_dlog(c->
fc,
"depth %d, ctab id %d\n",
1195 if ((color_depth == 2) || (color_depth == 4) ||
1196 (color_depth == 8)) {
1198 unsigned int color_start, color_count, color_end;
1199 unsigned char r,
g,
b;
1201 if (color_greyscale) {
1202 int color_index, color_dec;
1205 color_count = 1 << color_depth;
1207 color_dec = 256 / (color_count - 1);
1208 for (j = 0; j < color_count; j++) {
1209 r = g = b = color_index;
1211 (r << 16) | (g << 8) | (
b);
1212 color_index -= color_dec;
1213 if (color_index < 0)
1216 }
else if (color_table_id) {
1219 color_count = 1 << color_depth;
1220 if (color_depth == 2)
1222 else if (color_depth == 4)
1227 for (j = 0; j < color_count; j++) {
1228 r = color_table[j * 3 + 0];
1229 g = color_table[j * 3 + 1];
1230 b = color_table[j * 3 + 2];
1232 (r << 16) | (g << 8) | (
b);
1239 if ((color_start <= 255) &&
1240 (color_end <= 255)) {
1241 for (j = color_start; j <= color_end; j++) {
1254 (r << 16) | (g << 8) | (
b);
1261 int bits_per_sample,
flags;
1285 }
else if (version==2) {
1294 if (format ==
MKTAG(
'l',
'p',
'c',
'm'))
1336 if (bits_per_sample) {
1344 if (format !=
AV_RL32(
"mp4s"))
1359 }
else if (a.
size > 0)
1371 #if CONFIG_DV_DEMUXER
1441 unsigned int i, entries;
1457 if (entries >= UINT_MAX /
sizeof(*sc->
stsc_data))
1463 for (i = 0; i < entries && !pb->
eof_reached; i++) {
1481 unsigned i, entries;
1491 if (entries >= UINT_MAX /
sizeof(*sc->
stps_data))
1497 for (i = 0; i < entries && !pb->
eof_reached; i++) {
1514 unsigned int i, entries;
1526 av_dlog(c->
fc,
"keyframe_count = %d\n", entries);
1533 if (entries >= UINT_MAX /
sizeof(
int))
1540 for (i = 0; i < entries && !pb->
eof_reached; i++) {
1557 unsigned int i, entries, sample_size, field_size, num_bytes;
1569 if (atom.
type ==
MKTAG(
's',
't',
's',
'z')) {
1587 if (field_size != 4 && field_size != 8 && field_size != 16 && field_size != 32) {
1594 if (entries >= UINT_MAX /
sizeof(
int) || entries >= (UINT_MAX - 4) / field_size)
1600 num_bytes = (entries*field_size+4)>>3;
1608 if (
avio_read(pb, buf, num_bytes) < num_bytes) {
1616 for (i = 0; i < entries && !pb->
eof_reached; i++) {
1634 unsigned int i, entries;
1636 int64_t total_sample_count=0;
1647 av_dlog(c->
fc,
"track[%i].stts.entries = %i\n",
1652 if (entries >= UINT_MAX /
sizeof(*sc->
stts_data))
1660 for (i = 0; i < entries && !pb->
eof_reached; i++) {
1661 int sample_duration;
1666 if (sample_count < 0) {
1673 av_dlog(c->
fc,
"sample_count=%d, sample_duration=%d\n",
1674 sample_count, sample_duration);
1676 duration+=(int64_t)sample_duration*sample_count;
1677 total_sample_count+=sample_count;
1696 unsigned int i, entries;
1711 if (entries >= UINT_MAX /
sizeof(*sc->
ctts_data))
1717 for (i = 0; i < entries && !pb->
eof_reached; i++) {
1741 unsigned int i, entries;
1743 uint32_t grouping_type;
1753 if (grouping_type !=
MKTAG(
'r',
'a',
'p',
' '))
1761 if (entries >= UINT_MAX /
sizeof(*sc->
rap_group))
1767 for (i = 0; i < entries && !pb->
eof_reached; i++) {
1780 int64_t current_offset;
1781 int64_t current_dts = 0;
1782 unsigned int stts_index = 0;
1783 unsigned int stsc_index = 0;
1784 unsigned int stss_index = 0;
1785 unsigned int stps_index = 0;
1787 uint64_t stream_size = 0;
1807 unsigned int current_sample = 0;
1808 unsigned int stts_sample = 0;
1809 unsigned int sample_size;
1811 unsigned int rap_group_index = 0;
1812 unsigned int rap_group_sample = 0;
1849 if (rap_group_present && rap_group_index < sc->rap_group_count) {
1852 if (++rap_group_sample == sc->
rap_group[rap_group_index].
count) {
1853 rap_group_sample = 0;
1863 e->
pos = current_offset;
1865 e->
size = sample_size;
1868 av_dlog(mov->
fc,
"AVIndex stream %d, sample %d, offset %"PRIx64
", dts %"PRId64
", "
1869 "size %d, distance %d, keyframe %d\n", st->
index, current_sample,
1870 current_offset, current_dts, sample_size, distance, keyframe);
1873 current_offset += sample_size;
1874 stream_size += sample_size;
1888 unsigned chunk_samples, total = 0;
1892 unsigned count, chunk_count;
1905 count = (chunk_samples+samples-1) /
samples;
1907 count = (chunk_samples+1023) / 1024;
1910 if (i < sc->stsc_count - 1)
1914 total += chunk_count * count;
1917 av_dlog(mov->
fc,
"chunk count %d\n", total);
1934 while (chunk_samples > 0) {
1947 samples =
FFMIN(1024, chunk_samples);
1957 e->
pos = current_offset;
1962 av_dlog(mov->
fc,
"AVIndex stream %d, chunk %d, offset %"PRIx64
", dts %"PRId64
", "
1963 "size %d, duration %d\n", st->
index, i, current_offset, current_dts,
1966 current_offset +=
size;
1980 char filename[1024];
1985 src_path = strrchr(src,
'/');
1992 for (i = 0, l = strlen(ref->
path) - 1; l >= 0; l--)
1993 if (ref->
path[l] ==
'/') {
2001 if (i == ref->
nlvl_to - 1 && src_path - src <
sizeof(filename)) {
2002 memcpy(filename, src, src_path - src);
2003 filename[src_path - src] = 0;
2025 if (!st)
return AVERROR(ENOMEM);
2028 if (!sc)
return AVERROR(ENOMEM);
2060 "stream %d, error opening alias: path='%s', dir='%s', "
2061 "filename='%s', volume='%s', nlvl_from=%d, nlvl_to=%d\n",
2078 #if FF_API_R_FRAME_RATE
2080 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den,
2086 #if CONFIG_H261_DECODER
2089 #if CONFIG_H263_DECODER
2092 #if CONFIG_MPEG4_DECODER
2123 while (atom.
size > 8) {
2126 if (tag ==
MKTAG(
'h',
'd',
'l',
'r')) {
2140 int64_t disp_transform[2];
2141 int display_matrix[3][2];
2183 for (i = 0; i < 3; i++) {
2191 sc->
width = width >> 16;
2192 sc->
height = height >> 16;
2198 if (width && height &&
2199 ((display_matrix[0][0] != 65536 ||
2200 display_matrix[1][1] != 65536) &&
2201 !display_matrix[0][1] &&
2202 !display_matrix[1][0] &&
2203 !display_matrix[2][0] && !display_matrix[2][1])) {
2204 for (i = 0; i < 2; i++)
2206 (int64_t) width * display_matrix[0][i] +
2207 (int64_t) height * display_matrix[1][i] +
2208 ((int64_t) display_matrix[2][i] << 16);
2212 ((
double) disp_transform[0] * height) /
2213 ((
double) disp_transform[1] * width), INT_MAX);
2222 int flags, track_id, i;
2290 int data_offset = 0;
2291 unsigned entries, first_sample_flags = frag->
flags;
2310 av_dlog(c->
fc,
"flags 0x%x entries %d\n", flags, entries);
2341 av_dlog(c->
fc,
"first sample flags 0x%x\n", first_sample_flags);
2342 for (i = 0; i < entries && !pb->
eof_reached; i++) {
2343 unsigned sample_size = frag->
size;
2344 int sample_flags = i ? frag->
flags : first_sample_flags;
2345 unsigned sample_duration = frag->
duration;
2357 else if (!found_keyframe)
2358 keyframe = found_keyframe =
2365 av_dlog(c->
fc,
"AVIndex stream %d, sample %d, offset %"PRIx64
", dts %"PRId64
", "
2367 offset, dts, sample_size, distance, keyframe);
2369 dts += sample_duration;
2370 offset += sample_size;
2397 if (atom.
type !=
MKTAG(
'm',
'd',
'a',
't')) {
2411 long cmov_len, moov_len;
2425 cmov_len = atom.
size - 6 * 4;
2436 if (uncompress (moov_data, (uLongf *) &moov_len, (
const Bytef *)cmov_data, cmov_len) != Z_OK)
2437 goto free_and_return;
2439 goto free_and_return;
2441 atom.
size = moov_len;
2467 if ((uint64_t)edit_count*12+8 > atom.
size)
2470 for (i=0; i<edit_count; i++){
2481 if (i == 0 && time >= -1) {
2488 "a/v desync might occur, patch welcome\n");
2557 int64_t total_size = 0;
2562 atom.
size = INT64_MAX;
2567 if (atom.
size >= 8) {
2571 av_dlog(c->
fc,
"type: %08x '%.4s' parent:'%.4s' sz: %"PRId64
" %"PRId64
" %"PRId64
"\n",
2588 for (i = 0; mov_default_parse_table[i].
type; i++)
2589 if (mov_default_parse_table[i].type == a.
type) {
2604 int err =
parse(c, pb, a);
2617 else if (left < 0) {
2619 "overread end of atom '%.4s' by %"PRId64
" bytes\n",
2620 (
char*)&a.
type, -left);
2625 total_size += a.
size;
2628 if (total_size < atom.
size && atom.
size < 0x7ffff)
2636 unsigned int offset;
2644 if ((offset + 8) > (
unsigned int)p->
buf_size)
2649 case MKTAG(
'j',
'P',
' ',
' '):
2650 case MKTAG(
'm',
'o',
'o',
'v'):
2651 case MKTAG(
'm',
'd',
'a',
't'):
2652 case MKTAG(
'p',
'n',
'o',
't'):
2653 case MKTAG(
'u',
'd',
't',
'a'):
2654 case MKTAG(
'f',
't',
'y',
'p'):
2657 case MKTAG(
'e',
'd',
'i',
'w'):
2658 case MKTAG(
'w',
'i',
'd',
'e'):
2659 case MKTAG(
'f',
'r',
'e',
'e'):
2660 case MKTAG(
'j',
'u',
'n',
'k'):
2661 case MKTAG(
'p',
'i',
'c',
't'):
2663 case MKTAG(0x82,0x82,0x7f,0x7d):
2664 case MKTAG(
's',
'k',
'i',
'p'):
2665 case MKTAG(
'u',
'u',
'i',
'd'):
2666 case MKTAG(
'p',
'r',
'f',
'l'):
2715 if (len > sample->
size-2)
2717 title_len = 2*len + 1;
2730 else if (ch == 0xfffe)
2734 if (len == 1 || len == 2)
2763 if (sc->
pb && sc->
pb != s->
pb)
2801 atom.
size = INT64_MAX;
2835 int64_t best_dts = INT64_MAX;
2846 ((msc->
pb != s->
pb && dts < best_dts) || (msc->
pb == s->
pb &&
2849 sample = current_sample;
2903 #if CONFIG_DV_DEMUXER
2938 av_dlog(s,
"stream %d, pts %"PRId64
", dts %"PRId64
", pos 0x%"PRIx64
", duration %d\n",
2950 av_dlog(s,
"stream %d, timestamp %"PRId64
", sample %d\n", st->
index, timestamp, sample);
2951 if (sample < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
2976 int64_t seek_timestamp, timestamp;
2982 if (sample_time < 0)
2985 st = s->
streams[stream_index];
2995 if (stream_index == i)
3005 .
name =
"mov,mp4,m4a,3gp,3g2,mj2",
int itunes_metadata
metadata are itunes style
static int mov_read_moof(MOVContext *c, AVIOContext *pb, MOVAtom atom)
void * av_malloc(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
static int mov_read_esds(MOVContext *c, AVIOContext *pb, MOVAtom atom)
static int mov_read_enda(MOVContext *c, AVIOContext *pb, MOVAtom atom)
int64_t avio_size(AVIOContext *s)
Get the filesize.
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[]
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)
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.
AVIndexEntry * index_entries
Only used if the format does not support seeking natively.
#define AV_DISPOSITION_ATTACHED_PIC
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
unsigned int avio_rb16(AVIOContext *s)
static int mov_read_udta_string(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 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)
int found_moov
'moov' atom has been found
static int mov_read_stps(MOVContext *c, AVIOContext *pb, MOVAtom atom)
Macro definitions for various function/variable attributes.
void av_freep(void *arg)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
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)
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)
static int mov_read_moov(MOVContext *c, AVIOContext *pb, MOVAtom atom)
static av_always_inline double av_int2double(uint64_t i)
Reinterpret a 64-bit integer as a double.
Opaque data information usually continuous.
unsigned int sample_count
const AVCodecTag ff_codec_movvideo_tags[]
unsigned int avio_rb32(AVIOContext *s)
int dts_shift
dts shift when ctts is negative
#define AVFMT_FLAG_IGNIDX
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)
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
#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)
AVFormatContext * avformat_alloc_context(void)
Allocate an AVFormatContext.
#define MOV_TRUN_SAMPLE_SIZE
bitstream reader API header.
static av_cold int read_close(AVFormatContext *ctx)
#define MKTAG(a, b, c, d)
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 bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
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
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
int64_t time_offset
time offset of the first edit list entry
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)
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.
int ff_mp4_read_dec_config_descr(AVFormatContext *fc, AVStream *st, AVIOContext *pb)
AVCodecID
Identify the syntax and semantics of the bitstream.
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 av_log_ask_for_sample(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message asking for a sample.
unsigned int avio_rl32(AVIOContext *s)
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. ...
int avio_close(AVIOContext *s)
Close the resource accessed by the AVIOContext s and free it.
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)
void av_log(void *avcl, int level, const char *fmt,...)
AVStream * avformat_new_stream(AVFormatContext *s, AVCodec *c)
Add a new stream to a media file.
AVRational avg_frame_rate
Average framerate.
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.
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)
int avio_r8(AVIOContext *s)
AVCodecContext * codec
Codec context associated with this stream.
static float distance(float x, float y, int band)
static int mov_read_tkhd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)
Reduce a fraction.
int buf_size
Size of buf except extra allocated bytes.
static int mov_read_default(MOVContext *c, AVIOContext *pb, MOVAtom atom)
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
unsigned int nb_streams
A list of all streams in the file.
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
audio channel layout utility functions
AVRational av_d2q(double d, int max)
Convert a double precision floating point number to a rational.
unsigned int avio_rb24(AVIOContext *s)
const AVIOInterruptCB int_cb
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.
const AVCodecTag ff_codec_bmp_tags[]
static int mov_read_ftyp(MOVContext *c, AVIOContext *pb, MOVAtom atom)
int width
picture width / height.
static int mov_open_dref(AVIOContext **pb, char *src, MOVDref *ref, AVIOInterruptCB *int_cb)
static av_always_inline int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
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)
#define MOV_TRUN_SAMPLE_DURATION
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.
struct MOVContext MOVContext
static int read_header(FFV1Context *f)
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)
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
AVIOContext * pb
I/O context.
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').
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]
#define FF_INPUT_BUFFER_PADDING_SIZE
static int mov_read_mac_string(MOVContext *c, AVIOContext *pb, int len, char *dst, int dstlen)
int avio_open2(AVIOContext **s, const char *url, int flags, const AVIOInterruptCB *int_cb, AVDictionary **options)
Create and initialize a AVIOContext for accessing the resource indicated by url.
#define MOV_TFHD_DEFAULT_FLAGS
#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 int mov_read_meta(MOVContext *c, AVIOContext *pb, MOVAtom atom)
#define PUT_UTF8(val, tmp, PUT_BYTE)
unsigned * stps_data
partial sync sample for mpeg-2 open gop
struct MOVParseTableEntry MOVParseTableEntry
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)
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)
#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))
void * av_realloc(void *ptr, size_t size)
Allocate or reallocate a block of memory.
int avio_get_str16be(AVIOContext *pb, int maxlen, char *buf, int buflen)
static const MOVParseTableEntry mov_default_parse_table[]
static int mov_read_chan(MOVContext *c, AVIOContext *pb, MOVAtom atom)
#define AVERROR_INVALIDDATA
int disposition
AV_DISPOSITION_* bit field.
#define AVPROBE_SCORE_MAX
static int mov_read_extradata(MOVContext *c, AVIOContext *pb, MOVAtom atom)
int64_t nb_frames
number of frames in this stream if known or 0
#define AVERROR_PATCHWELCOME
static int mov_read_stco(MOVContext *c, AVIOContext *pb, MOVAtom atom)
int ff_mov_read_esds(AVFormatContext *fc, AVIOContext *pb, MOVAtom atom)
unsigned int index_entries_allocated_size
int eof_reached
true if eof reached
as in Berlin toast format
int channels
number of audio channels
void * priv_data
Format private data.
#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)
int avio_get_str(AVIOContext *pb, int maxlen, char *buf, int buflen)
Read a string from pb into buf.
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...
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)
void * av_mallocz(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
AVPacket attached_pic
For streams with AV_DISPOSITION_ATTACHED_PIC disposition, this packet will contain the attached pictu...
#define MOV_FRAG_SAMPLE_FLAG_IS_NON_SYNC
if(!(ptr_align%ac->ptr_align)&&samples_align >=aligned_len)