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
369 entries >= UINT_MAX /
sizeof(*sc->
drefs))
387 av_dlog(c->
fc,
"type %.4s size %d\n", (
char*)&dref->
type, size);
389 if (dref->
type ==
MKTAG(
'a',
'l',
'i',
's') && size > 150) {
391 uint16_t volume_len,
len;
397 volume_len =
FFMIN(volume_len, 27);
399 dref->
volume[volume_len] = 0;
405 len =
FFMIN(len, 63);
420 for (type = 0; type != -1 &&
avio_tell(pb) < next; ) {
434 if (len > volume_len && !strncmp(dref->
path, dref->
volume, volume_len)) {
436 memmove(dref->
path, dref->
path+volume_len, len);
439 for (j = 0; j <
len; j++)
440 if (dref->
path[j] ==
':')
443 }
else if (type == 0) {
450 for (j = 0; j <
len; j++)
451 if (dref->
dir[j] ==
':')
481 av_dlog(c->
fc,
"ctype= %.4s (0x%08x)\n", (
char*)&ctype, ctype);
482 av_dlog(c->
fc,
"stype= %.4s\n", (
char*)&type);
484 if (type ==
MKTAG(
'v',
'i',
'd',
'e'))
486 else if (type ==
MKTAG(
's',
'o',
'u',
'n'))
488 else if (type ==
MKTAG(
'm',
'1',
'a',
' '))
490 else if ((type ==
MKTAG(
's',
'u',
'b',
'p')) || (type ==
MKTAG(
'c',
'l',
'c',
'p')))
530 int ac3info, acmod, lfeon, bsmod;
537 bsmod = (ac3info >> 14) & 0x7;
538 acmod = (ac3info >> 11) & 0x7;
539 lfeon = (ac3info >> 10) & 0x1;
540 st->
codec->
channels = ((
int[]){2,1,2,3,3,4,4,5})[acmod] + lfeon;
554 int eac3info, acmod, lfeon, bsmod;
565 bsmod = (eac3info >> 12) & 0x1f;
566 acmod = (eac3info >> 9) & 0x7;
567 lfeon = (eac3info >> 8) & 0x1;
621 "sample aspect ratio already set to %d:%d, ignoring 'pasp' atom (%d:%d)\n",
624 }
else if (den != 0) {
645 char minor_ver_str[11];
646 char* comp_brands_str;
650 if (strcmp(type,
"qt "))
655 snprintf(minor_ver_str,
sizeof(minor_ver_str),
"%d", minor_ver);
658 comp_brand_size = atom.
size - 8;
659 if (comp_brand_size < 0)
661 comp_brands_str =
av_malloc(comp_brand_size + 1);
662 if (!comp_brands_str)
664 avio_read(pb, comp_brands_str, comp_brand_size);
665 comp_brands_str[comp_brand_size] = 0;
700 strftime(buffer,
sizeof(buffer),
"%Y-%m-%d %H:%M:%S", ptm);
710 char language[4] = {0};
712 time_t creation_time;
752 time_t creation_time;
796 if ((uint64_t)atom.
size > (1<<30))
822 av_dlog(c->
fc,
"enda %d\n", little_endian);
823 if (little_endian == 1) {
847 unsigned mov_field_order;
856 if ((mov_field_order & 0xFF00) == 0x0100)
858 else if ((mov_field_order & 0xFF00) == 0x0200) {
859 switch (mov_field_order & 0xFF) {
889 if (size > INT_MAX || (uint64_t)atom.
size > INT_MAX)
911 if ((uint64_t)atom.
size > (1<<30))
922 }
else if (atom.
size > 8) {
943 if ((uint64_t)atom.
size > (1<<30))
946 if (atom.
size >= 10) {
952 if (type ==
MKTAG(
'f',
'i',
'e',
'l') && size == atom.
size)
973 if (atom.
size >= (1<<28) || atom.
size < 7)
977 if ((profile_level & 0xf0) != 0xc0)
1001 if (atom.
size <= 40)
1005 if ((uint64_t)atom.
size > (1<<30))
1022 unsigned int i, entries;
1036 if (entries >= UINT_MAX/
sizeof(int64_t))
1044 if (atom.
type ==
MKTAG(
's',
't',
'c',
'o'))
1047 else if (atom.
type ==
MKTAG(
'c',
'o',
'6',
'4'))
1079 int j, pseudo_stream_id;
1086 for (pseudo_stream_id = 0;
1088 pseudo_stream_id++) {
1127 if (
id<=0 && ((format&0xFFFF) ==
'm'+(
's'<<8) || (format&0xFFFF) ==
'T'+(
'S'<<8)))
1133 format && format !=
MKTAG(
'm',
'p',
'4',
's')) {
1146 av_dlog(c->
fc,
"size=%d 4CC= %c%c%c%c codec_type=%d\n", size,
1147 (format >> 0) & 0xff, (format >> 8) & 0xff, (format >> 16) & 0xff,
1151 unsigned int color_depth,
len;
1152 int color_greyscale;
1180 if (format ==
MKTAG(
'H',
'2',
'6',
'3') &&
1186 av_dlog(c->
fc,
"depth %d, ctab id %d\n",
1193 if ((color_depth == 2) || (color_depth == 4) ||
1194 (color_depth == 8)) {
1196 unsigned int color_start, color_count, color_end;
1197 unsigned char r,
g,
b;
1199 if (color_greyscale) {
1200 int color_index, color_dec;
1203 color_count = 1 << color_depth;
1205 color_dec = 256 / (color_count - 1);
1206 for (j = 0; j < color_count; j++) {
1207 r = g = b = color_index;
1209 (r << 16) | (g << 8) | (
b);
1210 color_index -= color_dec;
1211 if (color_index < 0)
1214 }
else if (color_table_id) {
1217 color_count = 1 << color_depth;
1218 if (color_depth == 2)
1220 else if (color_depth == 4)
1225 for (j = 0; j < color_count; j++) {
1226 r = color_table[j * 3 + 0];
1227 g = color_table[j * 3 + 1];
1228 b = color_table[j * 3 + 2];
1230 (r << 16) | (g << 8) | (
b);
1237 if ((color_start <= 255) &&
1238 (color_end <= 255)) {
1239 for (j = color_start; j <= color_end; j++) {
1252 (r << 16) | (g << 8) | (
b);
1259 int bits_per_sample,
flags;
1283 }
else if (version==2) {
1292 if (format ==
MKTAG(
'l',
'p',
'c',
'm'))
1334 if (bits_per_sample) {
1342 if (format !=
AV_RL32(
"mp4s"))
1357 }
else if (a.
size > 0)
1369 #if CONFIG_DV_DEMUXER
1439 unsigned int i, entries;
1455 if (entries >= UINT_MAX /
sizeof(*sc->
stsc_data))
1461 for (i = 0; i < entries && !pb->
eof_reached; i++) {
1479 unsigned i, entries;
1489 if (entries >= UINT_MAX /
sizeof(*sc->
stps_data))
1495 for (i = 0; i < entries && !pb->
eof_reached; i++) {
1512 unsigned int i, entries;
1524 av_dlog(c->
fc,
"keyframe_count = %d\n", entries);
1531 if (entries >= UINT_MAX /
sizeof(
int))
1538 for (i = 0; i < entries && !pb->
eof_reached; i++) {
1555 unsigned int i, entries, sample_size, field_size, num_bytes;
1567 if (atom.
type ==
MKTAG(
's',
't',
's',
'z')) {
1585 if (field_size != 4 && field_size != 8 && field_size != 16 && field_size != 32) {
1592 if (entries >= UINT_MAX /
sizeof(
int) || entries >= (UINT_MAX - 4) / field_size)
1598 num_bytes = (entries*field_size+4)>>3;
1606 if (
avio_read(pb, buf, num_bytes) < num_bytes) {
1614 for (i = 0; i < entries && !pb->
eof_reached; i++) {
1632 unsigned int i, entries;
1634 int64_t total_sample_count=0;
1645 av_dlog(c->
fc,
"track[%i].stts.entries = %i\n",
1650 if (entries >= UINT_MAX /
sizeof(*sc->
stts_data))
1658 for (i = 0; i < entries && !pb->
eof_reached; i++) {
1659 int sample_duration;
1664 if (sample_count < 0) {
1671 av_dlog(c->
fc,
"sample_count=%d, sample_duration=%d\n",
1672 sample_count, sample_duration);
1674 duration+=(int64_t)sample_duration*sample_count;
1675 total_sample_count+=sample_count;
1694 unsigned int i, entries;
1709 if (entries >= UINT_MAX /
sizeof(*sc->
ctts_data))
1715 for (i = 0; i < entries && !pb->
eof_reached; i++) {
1739 unsigned int i, entries;
1741 uint32_t grouping_type;
1751 if (grouping_type !=
MKTAG(
'r',
'a',
'p',
' '))
1759 if (entries >= UINT_MAX /
sizeof(*sc->
rap_group))
1765 for (i = 0; i < entries && !pb->
eof_reached; i++) {
1778 int64_t current_offset;
1779 int64_t current_dts = 0;
1780 unsigned int stts_index = 0;
1781 unsigned int stsc_index = 0;
1782 unsigned int stss_index = 0;
1783 unsigned int stps_index = 0;
1785 uint64_t stream_size = 0;
1805 unsigned int current_sample = 0;
1806 unsigned int stts_sample = 0;
1807 unsigned int sample_size;
1809 unsigned int rap_group_index = 0;
1810 unsigned int rap_group_sample = 0;
1847 if (rap_group_present && rap_group_index < sc->rap_group_count) {
1850 if (++rap_group_sample == sc->
rap_group[rap_group_index].
count) {
1851 rap_group_sample = 0;
1861 e->
pos = current_offset;
1863 e->
size = sample_size;
1866 av_dlog(mov->
fc,
"AVIndex stream %d, sample %d, offset %"PRIx64
", dts %"PRId64
", "
1867 "size %d, distance %d, keyframe %d\n", st->
index, current_sample,
1868 current_offset, current_dts, sample_size, distance, keyframe);
1871 current_offset += sample_size;
1872 stream_size += sample_size;
1886 unsigned chunk_samples, total = 0;
1890 unsigned count, chunk_count;
1903 count = (chunk_samples+samples-1) /
samples;
1905 count = (chunk_samples+1023) / 1024;
1908 if (i < sc->stsc_count - 1)
1912 total += chunk_count * count;
1915 av_dlog(mov->
fc,
"chunk count %d\n", total);
1932 while (chunk_samples > 0) {
1945 samples =
FFMIN(1024, chunk_samples);
1955 e->
pos = current_offset;
1960 av_dlog(mov->
fc,
"AVIndex stream %d, chunk %d, offset %"PRIx64
", dts %"PRId64
", "
1961 "size %d, duration %d\n", st->
index, i, current_offset, current_dts,
1964 current_offset +=
size;
1978 char filename[1024];
1983 src_path = strrchr(src,
'/');
1990 for (i = 0, l = strlen(ref->
path) - 1; l >= 0; l--)
1991 if (ref->
path[l] ==
'/') {
1999 if (i == ref->
nlvl_to - 1 && src_path - src <
sizeof(filename)) {
2000 memcpy(filename, src, src_path - src);
2001 filename[src_path - src] = 0;
2023 if (!st)
return AVERROR(ENOMEM);
2026 if (!sc)
return AVERROR(ENOMEM);
2058 "stream %d, error opening alias: path='%s', dir='%s', "
2059 "filename='%s', volume='%s', nlvl_from=%d, nlvl_to=%d\n",
2076 #if FF_API_R_FRAME_RATE
2078 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den,
2084 #if CONFIG_H261_DECODER
2087 #if CONFIG_H263_DECODER
2090 #if CONFIG_MPEG4_DECODER
2121 while (atom.
size > 8) {
2124 if (tag ==
MKTAG(
'h',
'd',
'l',
'r')) {
2138 int64_t disp_transform[2];
2139 int display_matrix[3][2];
2181 for (i = 0; i < 3; i++) {
2189 sc->
width = width >> 16;
2190 sc->
height = height >> 16;
2196 if (width && height &&
2197 ((display_matrix[0][0] != 65536 ||
2198 display_matrix[1][1] != 65536) &&
2199 !display_matrix[0][1] &&
2200 !display_matrix[1][0] &&
2201 !display_matrix[2][0] && !display_matrix[2][1])) {
2202 for (i = 0; i < 2; i++)
2204 (int64_t) width * display_matrix[0][i] +
2205 (int64_t) height * display_matrix[1][i] +
2206 ((int64_t) display_matrix[2][i] << 16);
2210 ((
double) disp_transform[0] * height) /
2211 ((
double) disp_transform[1] * width), INT_MAX);
2220 int flags, track_id, i;
2288 int data_offset = 0;
2289 unsigned entries, first_sample_flags = frag->
flags;
2308 av_dlog(c->
fc,
"flags 0x%x entries %d\n", flags, entries);
2339 av_dlog(c->
fc,
"first sample flags 0x%x\n", first_sample_flags);
2340 for (i = 0; i < entries && !pb->
eof_reached; i++) {
2341 unsigned sample_size = frag->
size;
2342 int sample_flags = i ? frag->
flags : first_sample_flags;
2343 unsigned sample_duration = frag->
duration;
2355 else if (!found_keyframe)
2356 keyframe = found_keyframe =
2363 av_dlog(c->
fc,
"AVIndex stream %d, sample %d, offset %"PRIx64
", dts %"PRId64
", "
2365 offset, dts, sample_size, distance, keyframe);
2367 dts += sample_duration;
2368 offset += sample_size;
2395 if (atom.
type !=
MKTAG(
'm',
'd',
'a',
't')) {
2409 long cmov_len, moov_len;
2423 cmov_len = atom.
size - 6 * 4;
2434 if (uncompress (moov_data, (uLongf *) &moov_len, (
const Bytef *)cmov_data, cmov_len) != Z_OK)
2435 goto free_and_return;
2437 goto free_and_return;
2439 atom.
size = moov_len;
2465 if ((uint64_t)edit_count*12+8 > atom.
size)
2468 for (i=0; i<edit_count; i++){
2479 if (i == 0 && time >= -1) {
2486 "a/v desync might occur, patch welcome\n");
2555 int64_t total_size = 0;
2560 atom.
size = INT64_MAX;
2565 if (atom.
size >= 8) {
2569 av_dlog(c->
fc,
"type: %08x '%.4s' parent:'%.4s' sz: %"PRId64
" %"PRId64
" %"PRId64
"\n",
2586 for (i = 0; mov_default_parse_table[i].
type; i++)
2587 if (mov_default_parse_table[i].type == a.
type) {
2602 int err =
parse(c, pb, a);
2615 else if (left < 0) {
2617 "overread end of atom '%.4s' by %"PRId64
" bytes\n",
2618 (
char*)&a.
type, -left);
2623 total_size += a.
size;
2626 if (total_size < atom.
size && atom.
size < 0x7ffff)
2634 unsigned int offset;
2642 if ((offset + 8) > (
unsigned int)p->
buf_size)
2647 case MKTAG(
'j',
'P',
' ',
' '):
2648 case MKTAG(
'm',
'o',
'o',
'v'):
2649 case MKTAG(
'm',
'd',
'a',
't'):
2650 case MKTAG(
'p',
'n',
'o',
't'):
2651 case MKTAG(
'u',
'd',
't',
'a'):
2652 case MKTAG(
'f',
't',
'y',
'p'):
2655 case MKTAG(
'e',
'd',
'i',
'w'):
2656 case MKTAG(
'w',
'i',
'd',
'e'):
2657 case MKTAG(
'f',
'r',
'e',
'e'):
2658 case MKTAG(
'j',
'u',
'n',
'k'):
2659 case MKTAG(
'p',
'i',
'c',
't'):
2661 case MKTAG(0x82,0x82,0x7f,0x7d):
2662 case MKTAG(
's',
'k',
'i',
'p'):
2663 case MKTAG(
'u',
'u',
'i',
'd'):
2664 case MKTAG(
'p',
'r',
'f',
'l'):
2713 if (len > sample->
size-2)
2715 title_len = 2*len + 1;
2728 else if (ch == 0xfffe)
2732 if (len == 1 || len == 2)
2761 if (sc->
pb && sc->
pb != s->
pb)
2799 atom.
size = INT64_MAX;
2833 int64_t best_dts = INT64_MAX;
2844 ((msc->
pb != s->
pb && dts < best_dts) || (msc->
pb == s->
pb &&
2847 sample = current_sample;
2901 #if CONFIG_DV_DEMUXER
2936 av_dlog(s,
"stream %d, pts %"PRId64
", dts %"PRId64
", pos 0x%"PRIx64
", duration %d\n",
2948 av_dlog(s,
"stream %d, timestamp %"PRId64
", sample %d\n", st->
index, timestamp, sample);
2949 if (sample < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
2974 int64_t seek_timestamp, timestamp;
2980 if (sample_time < 0)
2983 st = s->
streams[stream_index];
2993 if (stream_index == i)
3003 .
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)