71 #define LICENSE_PREFIX "libavformat license: "
76 #define SANE_CHUNK_SIZE (50000000)
82 int64_t chunk_size =
size;
83 int64_t orig_pos = pkt->
pos;
84 int orig_size = pkt->
size;
88 int prev_size = pkt->
size;
97 read_size =
FFMIN(size, chunk_size);
104 if (ret != read_size) {
115 return pkt->
size > orig_size ? pkt->
size - orig_size : ret;
169 if (score > *score_max) {
172 }
else if (score == *score_max)
179 if (fmt->extensions &&
188 if (fmt->extensions &&
av_match_ext(
"mp3", fmt->extensions)) {
206 static const struct {
226 "Probe with size=%d, packets=%d detected %s with score=%d\n",
229 for (i = 0; fmt_id_type[i].name; i++) {
230 if (!strcmp(fmt->
name, fmt_id_type[i].name)) {
244 #define PROBE_BUF_MIN 2048
245 #define PROBE_BUF_MAX (1 << 20)
248 const char *filename,
void *logctx,
249 unsigned int offset,
unsigned int max_probe_size)
253 int ret = 0, probe_size;
262 if (offset >= max_probe_size)
265 max_probe_size -= offset;
267 for (probe_size =
PROBE_BUF_MIN; probe_size <= max_probe_size && !*fmt;
268 probe_size =
FFMIN(probe_size << 1,
269 FFMAX(max_probe_size, probe_size + 1))) {
296 "Format detected only with low score of %d, "
297 "misdetection possible!\n", score);
300 "Probed with size=%d and score=%d\n", probe_size, score);
354 (*plast_pktl)->next = pktl;
356 *packet_buffer = pktl;
400 if ((ret =
init_input(s, filename, &tmp)) < 0)
436 if (id3v2_extra_meta &&
487 "nothing to probe for stream %d\n", st->
index);
539 if (!pktl || ret ==
AVERROR(EAGAIN))
553 "Dropped corrupted packet (stream = %d)\n",
647 if (frame_size <= 0 || st->codec->sample_rate <= 0)
668 int64_t dts, int64_t pts)
681 for (; pktl; pktl = pktl->
next) {
706 for (; pktl; pktl = pktl->
next) {
720 for (; pktl; pktl = pktl->
next) {
742 int num, den, presentation_delayed, delay, i;
753 presentation_delayed = 0;
759 presentation_delayed = 1;
771 if (delay == 1 && pkt->
dts == pkt->
pts &&
805 presentation_delayed = 1;
808 "IN delayed:%d pts:%"PRId64
", dts:%"PRId64
" "
809 "cur_dts:%"PRId64
" st:%d pc:%p\n",
814 if ((delay == 0 || (delay == 1 && pc)) &&
816 if (presentation_delayed) {
884 "OUTdelayed:%d/%d pts:%"PRId64
", dts:%"PRId64
" cur_dts:%"PRId64
"\n",
885 presentation_delayed, delay, pkt->
pts, pkt->
dts, st->
cur_dts);
898 *pkt_buf = pktl->
next;
916 int ret = 0, got_output = 0;
924 while (size > 0 || (pkt == &
flush_pkt && got_output)) {
929 &out_pkt.
data, &out_pkt.
size, data, size,
937 got_output = !!out_pkt.
size;
989 #if FF_API_DESTRUCT_PACKET
1025 *pkt_buffer = pktl->
next;
1027 *pkt_buffer_end =
NULL;
1034 int ret = 0, i, got_packet = 0;
1062 cur_pkt.
pts < cur_pkt.
dts) {
1064 "Invalid timestamps stream=%d, pts=%"PRId64
", "
1065 "dts=%"PRId64
", size=%d\n",
1071 "ff_read_packet stream=%d, pts=%"PRId64
", dts=%"PRId64
", "
1072 "size=%d, duration=%d, flags=%d\n",
1112 "read_frame_internal stream=%d, pts=%"PRId64
", dts=%"PRId64
", "
1113 "size=%d, duration=%d, flags=%d\n",
1161 if (pktl && ret !=
AVERROR(EAGAIN)) {
1189 int first_audio_index = -1;
1201 if (first_audio_index < 0 &&
1203 first_audio_index = i;
1205 return first_audio_index >= 0 ? first_audio_index : 0;
1263 int *nb_index_entries,
1264 unsigned int *index_entries_allocated_size,
1265 int64_t pos, int64_t timestamp,
1271 if ((
unsigned) *nb_index_entries + 1 >= UINT_MAX /
sizeof(
AVIndexEntry))
1275 index_entries_allocated_size,
1276 (*nb_index_entries + 1) *
1281 *index_entries = entries;
1287 index = (*nb_index_entries)++;
1288 ie = &entries[
index];
1289 assert(index == 0 || ie[-1].timestamp < timestamp);
1291 ie = &entries[
index];
1295 memmove(entries + index + 1, entries + index,
1297 (*nb_index_entries)++;
1298 }
else if (ie->
pos == pos && distance < ie->min_distance)
1317 timestamp, size, distance, flags);
1321 int64_t wanted_timestamp,
int flags)
1330 if (b && entries[b - 1].timestamp < wanted_timestamp)
1336 if (timestamp >= wanted_timestamp)
1338 if (timestamp <= wanted_timestamp)
1344 while (m >= 0 && m < nb_entries &&
1348 if (m == nb_entries)
1356 wanted_timestamp, flags);
1360 int64_t target_ts,
int flags)
1364 int64_t ts_min, ts_max, ts;
1369 if (stream_index < 0)
1372 av_dlog(s,
"read_seek: %d %"PRId64
"\n", stream_index, target_ts);
1378 st = s->
streams[stream_index];
1386 index =
FFMAX(index, 0);
1392 av_dlog(s,
"using cached pos_min=0x%"PRIx64
" dts_min=%"PRId64
"\n",
1400 assert(index < st->nb_index_entries);
1407 av_dlog(s,
"using cached pos_max=0x%"PRIx64
" pos_limit=0x%"PRIx64
1408 " dts_max=%"PRId64
"\n", pos_max, pos_limit, ts_max);
1412 pos =
ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit,
1427 int64_t pos_min, int64_t pos_max, int64_t pos_limit,
1428 int64_t ts_min, int64_t ts_max,
1429 int flags, int64_t *ts_ret,
1431 int64_t *, int64_t))
1434 int64_t start_pos, filesize;
1437 av_dlog(s,
"gen_seek: %d %"PRId64
"\n", stream_index, target_ts);
1441 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1449 pos_max = filesize - 1;
1452 ts_max = read_timestamp(s, stream_index, &pos_max,
1460 int64_t tmp_pos = pos_max + 1;
1461 int64_t tmp_ts = read_timestamp(s, stream_index,
1462 &tmp_pos, INT64_MAX);
1467 if (tmp_pos >= filesize)
1470 pos_limit = pos_max;
1473 if (ts_min > ts_max)
1475 else if (ts_min == ts_max)
1476 pos_limit = pos_min;
1479 while (pos_min < pos_limit) {
1480 av_dlog(s,
"pos_min=0x%"PRIx64
" pos_max=0x%"PRIx64
" dts_min=%"PRId64
1481 " dts_max=%"PRId64
"\n", pos_min, pos_max, ts_min, ts_max);
1482 assert(pos_limit <= pos_max);
1484 if (no_change == 0) {
1485 int64_t approximate_keyframe_distance = pos_max - pos_limit;
1487 pos =
av_rescale(target_ts - ts_min, pos_max - pos_min,
1489 pos_min - approximate_keyframe_distance;
1490 }
else if (no_change == 1) {
1492 pos = (pos_min + pos_limit) >> 1;
1500 else if (pos > pos_limit)
1505 ts = read_timestamp(s, stream_index, &pos, INT64_MAX);
1510 av_dlog(s,
"%"PRId64
" %"PRId64
" %"PRId64
" / %"PRId64
" %"PRId64
" %"PRId64
1511 " target:%"PRId64
" limit:%"PRId64
" start:%"PRId64
" noc:%d\n",
1512 pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts,
1513 pos_limit, start_pos, no_change);
1519 if (target_ts <= ts) {
1520 pos_limit = start_pos - 1;
1524 if (target_ts >= ts) {
1533 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1535 ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1536 av_dlog(s,
"pos=0x%"PRIx64
" %"PRId64
"<=%"PRId64
"<=%"PRId64
"\n",
1537 pos, ts_min, target_ts, ts_max);
1543 int64_t pos,
int flags)
1545 int64_t pos_min, pos_max;
1552 else if (pos > pos_max)
1561 int64_t timestamp,
int flags)
1568 st = s->
streams[stream_index];
1572 if (index < 0 && st->nb_index_entries &&
1573 timestamp < st->index_entries[0].timestamp)
1576 if (index < 0 || index == st->nb_index_entries - 1) {
1593 }
while (read_status ==
AVERROR(EAGAIN));
1594 if (read_status < 0)
1619 int64_t timestamp,
int flags)
1631 if (stream_index < 0) {
1633 if (stream_index < 0)
1636 st = s->
streams[stream_index];
1663 int64_t timestamp,
int flags)
1674 int64_t ts, int64_t max_ts,
int flags)
1676 if (min_ts > ts || max_ts < ts)
1698 flags | ((uint64_t) ts - min_ts >
1699 (uint64_t) max_ts - ts
1734 int64_t
start_time, start_time1, end_time, end_time1;
1735 int64_t
duration, duration1, filesize;
1739 start_time = INT64_MAX;
1740 end_time = INT64_MIN;
1741 duration = INT64_MIN;
1747 start_time =
FFMIN(start_time, start_time1);
1749 end_time1 = start_time1 +
1752 end_time =
FFMAX(end_time, end_time1);
1758 duration =
FFMAX(duration, duration1);
1761 if (start_time != INT64_MAX) {
1763 if (end_time != INT64_MIN)
1764 duration =
FFMAX(duration, end_time - start_time);
1766 if (duration != INT64_MIN) {
1833 #define DURATION_MAX_READ_SIZE 250000
1834 #define DURATION_MAX_RETRY 3
1841 int read_size, i, ret;
1843 int64_t filesize, offset,
duration;
1853 "start time is not set in estimate_timings_from_pts\n");
1878 }
while (ret ==
AVERROR(EAGAIN));
1881 read_size += pkt->
size;
1886 duration = end_time = pkt->
pts;
1923 file_size =
FFMAX(0, file_size);
1937 "Estimating duration from bitrate, this may be inaccurate\n");
1948 av_dlog(ic,
"%d: start_time: %0.3f duration: %0.3f\n", i,
1953 "stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1995 int got_picture = 1, ret = 0;
2016 av_dict_set(options ? options : &thread_opt,
"threads",
"1", 0);
2033 while ((pkt.
size > 0 || (!pkt.
data && got_picture)) &&
2042 &got_picture, &pkt);
2078 if (tag == tags[i].tag)
2099 if (sflags & (1 << (bps - 1))) {
2132 for (i = 0; tags && tags[i]; i++) {
2143 for (i = 0; tags && tags[i]; i++) {
2168 if (j != i && next_start > ch->
start && next_start < end)
2171 ch->
end = (end == INT64_MAX) ? ch->
start : end;
2178 return (i + 1) * 1001;
2180 return ((
const int[]) { 24, 30, 60, 12, 15 })[i - 60 * 12] * 1000 * 12;
2203 int i, count, ret, read_size, j;
2226 av_dict_set(options ? &options[i] : &thread_opt,
"threads",
"1", 0);
2232 options ? &options[i] : &thread_opt);
2238 options ? &options[i] : &thread_opt);
2260 int fps_analyze_framecount = 20;
2269 fps_analyze_framecount *= 2;
2299 "Probe buffer size limit %d reached\n", ic->
probesize);
2324 (options && i < orig_nb_streams)
2325 ? &options[i] :
NULL);
2331 "decoding for stream %d failed\n", st->
index);
2336 "Could not find codec parameters (%s)\n", buf);
2350 goto find_stream_info_err;
2353 read_size += pkt->
size;
2361 "Non-increasing DTS in stream %d: packet %d with DTS "
2362 "%"PRId64
", packet %d with DTS %"PRId64
"\n",
2378 "DTS discontinuity in stream %d: packet %d with DTS "
2379 "%"PRId64
", packet %d with DTS %"PRId64
"\n",
2427 (options && i < orig_nb_streams) ? &options[i] :
NULL);
2449 double best_error = 0.01;
2466 if (error < best_error) {
2468 best_fps = std_fps.
num;
2473 best_fps, 12 * 1001, INT_MAX);
2504 find_stream_info_err:
2524 int wanted_stream_nb,
int related_stream,
2525 AVCodec **decoder_ret,
int flags)
2529 unsigned *program =
NULL;
2532 if (related_stream >= 0 && wanted_stream_nb < 0) {
2539 for (i = 0; i < nb_streams; i++) {
2540 int real_stream_index = program ? program[i] : i;
2545 if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
2561 ret = real_stream_index;
2563 if (program && i == nb_streams - 1 && ret < 0) {
2571 *decoder_ret = best_decoder;
2716 av_dlog(ac,
"new_program: id=0x%04x\n",
id);
2735 int64_t start, int64_t end,
const char *title)
2753 chapter->
start = start;
2790 uint64_t v =
lrintf(d * 100);
2793 else if (v % (100 * 1000))
2806 if (strcmp(
"language", tag->
key))
2808 "%s %-16s: %s\n", indent, tag->
key, tag->
value);
2814 int index,
int is_output)
2841 display_aspect_ratio.
num, display_aspect_ratio.
den);
2876 const char *url,
int is_output)
2884 is_output ?
"Output" :
"Input",
2887 is_output ?
"to" :
"from", url);
2892 int hours, mins, secs, us;
2930 int j, k, total = 0;
2935 name ? name->
value :
"");
2944 if (total < ic->nb_streams)
2962 char *q, buf1[20], c;
2963 int nd,
len, percentd_found;
2976 nd = nd * 10 + *p++ -
'0';
2987 snprintf(buf1,
sizeof(buf1),
"%0*d", nd, number);
2989 if ((q - buf + len) > buf_size - 1)
2991 memcpy(q, buf1, len);
2999 if ((q - buf) < buf_size - 1)
3003 if (!percentd_found)
3012 #define HEXDUMP_PRINT(...) \
3015 av_log(avcl, level, __VA_ARGS__); \
3017 fprintf(f, __VA_ARGS__); \
3025 for (i = 0; i <
size; i += 16) {
3030 for (j = 0; j < 16; j++) {
3037 for (j = 0; j <
len; j++) {
3039 if (c < ' ' || c >
'~')
3093 char *authorization,
int authorization_size,
3094 char *hostname,
int hostname_size,
3095 int *port_ptr,
char *path,
int path_size,
const char *url)
3097 const char *p, *ls, *at, *col, *brk;
3103 if (authorization_size > 0)
3104 authorization[0] = 0;
3105 if (hostname_size > 0)
3111 if ((p = strchr(url,
':'))) {
3125 ls = strchr(p,
'/');
3127 ls = strchr(p,
'?');
3136 if ((at = strchr(p,
'@')) && at < ls) {
3138 FFMIN(authorization_size, at + 1 - p));
3142 if (*p ==
'[' && (brk = strchr(p,
']')) && brk < ls) {
3145 FFMIN(hostname_size, brk - p));
3146 if (brk[1] ==
':' && port_ptr)
3147 *port_ptr = atoi(brk + 2);
3148 }
else if ((col = strchr(p,
':')) && col < ls) {
3150 FFMIN(col + 1 - p, hostname_size));
3152 *port_ptr = atoi(col + 1);
3155 FFMIN(ls + 1 - p, hostname_size));
3162 static const char hex_table_uc[16] = {
'0',
'1',
'2',
'3',
3165 'C',
'D',
'E',
'F' };
3166 static const char hex_table_lc[16] = {
'0',
'1',
'2',
'3',
3169 'c',
'd',
'e',
'f' };
3170 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3172 for (i = 0; i < s; i++) {
3173 buff[i * 2] = hex_table[src[i] >> 4];
3174 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3191 if (c >=
'0' && c <=
'9')
3193 else if (c >=
'A' && c <=
'F')
3209 unsigned int pts_num,
unsigned int pts_den)
3213 if (new_tb.
num != pts_num)
3215 "st:%d removing common factor %d from timebase\n",
3219 "st:%d has too large timebase, reducing\n", s->
index);
3221 if (new_tb.
num <= 0 || new_tb.
den <= 0) {
3223 "Ignoring attempt to set invalid timebase for st:%d\n",
3234 const char *ptr = str;
3239 char *dest =
NULL, *dest_end;
3240 int key_len, dest_len = 0;
3243 while (*ptr && (
av_isspace(*ptr) || *ptr ==
','))
3250 if (!(ptr = strchr(key,
'=')))
3253 key_len = ptr - key;
3255 callback_get_buf(context, key, key_len, &dest, &dest_len);
3256 dest_end = dest + dest_len - 1;
3260 while (*ptr && *ptr !=
'\"') {
3264 if (dest && dest < dest_end)
3268 if (dest && dest < dest_end)
3276 for (; *ptr && !(
av_isspace(*ptr) || *ptr ==
','); ptr++)
3277 if (dest && dest < dest_end)
3297 struct tm time1 = { 0 }, time2 = { 0 };
3299 ret1 = strptime(datestr,
"%Y - %m - %d %T", &time1);
3300 ret2 = strptime(datestr,
"%Y - %m - %dT%T", &time2);
3307 "strptime() unavailable on this system, cannot convert "
3308 "the date string.\n");
3318 return ofmt->
query_codec(codec_id, std_compliance);
3351 uint64_t channel_layout,
int32_t sample_rate,
3363 if (channel_layout) {
3371 if (width || height) {
3378 bytestream_put_le32(&data, flags);
3380 bytestream_put_le32(&data, channels);
3382 bytestream_put_le64(&data, channel_layout);
3384 bytestream_put_le32(&data, sample_rate);
3385 if (width || height) {
3386 bytestream_put_le32(&data, width);
3387 bytestream_put_le32(&data, height);
3394 static const uint8_t avci100_1080p_extradata[] = {
3396 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
3397 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
3398 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
3399 0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
3400 0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
3401 0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
3402 0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
3403 0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
3404 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3406 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
3409 static const uint8_t avci100_1080i_extradata[] = {
3411 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
3412 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
3413 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
3414 0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
3415 0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
3416 0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
3417 0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
3418 0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
3419 0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
3420 0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
3421 0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x00,
3423 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
3426 static const uint8_t avci50_1080i_extradata[] = {
3428 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
3429 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
3430 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
3431 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
3432 0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
3433 0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
3434 0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
3435 0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
3436 0x81, 0x13, 0xf7, 0xff, 0x80, 0x01, 0x80, 0x02,
3437 0x71, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
3438 0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
3440 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
3443 static const uint8_t avci100_720p_extradata[] = {
3445 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
3446 0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
3447 0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
3448 0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
3449 0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
3450 0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
3451 0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
3452 0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
3453 0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
3454 0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
3456 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
3465 data = avci100_1080p_extradata;
3466 size =
sizeof(avci100_1080p_extradata);
3468 data = avci100_1080i_extradata;
3469 size =
sizeof(avci100_1080i_extradata);
3472 data = avci50_1080i_extradata;
3473 size =
sizeof(avci50_1080i_extradata);
3475 data = avci100_720p_extradata;
3476 size =
sizeof(avci100_720p_extradata);
unsigned int nb_chapters
Number of chapters in AVChapter array.
time_t av_timegm(struct tm *tm)
Convert the decomposed UTC time in tm to a time_t value.
unsigned int max_index_size
Maximum amount of memory in bytes to use for the index of each stream.
void av_url_split(char *proto, int proto_size, char *authorization, int authorization_size, char *hostname, int hostname_size, int *port_ptr, char *path, int path_size, const char *url)
Split a URL string into components.
codec_id is not known (like AV_CODEC_ID_NONE) but lavf should attempt to identify it ...
const struct AVCodec * codec
void * av_malloc(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
#define AV_CODEC_PROP_INTRA_ONLY
Codec uses only intra compression.
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
int64_t avio_size(AVIOContext *s)
Get the filesize.
void av_free_packet(AVPacket *pkt)
Free a packet.
This structure describes decoded (raw) audio or video data.
AVIOInterruptCB interrupt_callback
Custom interrupt callbacks for the I/O layer.
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.
int64_t av_rescale_rnd(int64_t a, int64_t b, int64_t c, enum AVRounding rnd)
Rescale a 64-bit integer with specified rounding.
#define AV_LOG_WARNING
Something somehow does not look correct.
int64_t pos
byte position in stream, -1 if unknown
int avformat_open_input(AVFormatContext **ps, const char *filename, AVInputFormat *fmt, AVDictionary **options)
Open an input stream and read the header.
void av_shrink_packet(AVPacket *pkt, int size)
Reduce packet size, correctly zeroing padding.
int avformat_query_codec(AVOutputFormat *ofmt, enum AVCodecID codec_id, int std_compliance)
Test if the given container can store a codec.
int64_t pts_buffer[MAX_REORDER_DELAY+1]
void av_opt_set_defaults(void *s)
Set the values of all AVOption fields to their default values.
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
int index
stream index in AVFormatContext
int av_dict_count(const AVDictionary *m)
Get number of entries in dictionary.
#define ID3v2_DEFAULT_MAGIC
Default magic bytes for ID3v2 header: "ID3".
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
#define AVIO_FLAG_READ
read-only
AVIndexEntry * index_entries
Only used if the format does not support seeking natively.
AVFormatInternal * internal
An opaque field for libavformat internal usage.
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel...
void av_pkt_dump2(FILE *f, AVPacket *pkt, int dump_payload, AVStream *st)
Send a nice dump of a packet to the specified file stream.
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
void ff_network_close(void)
int av_isdigit(int c)
Locale-independent conversion of ASCII isdigit.
static int av_cmp_q(AVRational a, AVRational b)
Compare two rationals.
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)
int64_t data_offset
offset of the first packet
int duration
Duration of the current frame.
int ctx_flags
Format-specific flags, see AVFMTCTX_xx.
AVDictionaryEntry * av_dict_get(AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
int av_dup_packet(AVPacket *pkt)
int ff_id3v2_parse_apic(AVFormatContext *s, ID3v2ExtraMeta **extra_meta)
Create a stream for each APIC (attached picture) extracted from the ID3v2 header. ...
enum AVCodecID subtitle_codec_id
Forced subtitle codec_id.
struct AVPacketList * packet_buffer
This buffer is only needed when packets were already buffered but not decoded, for example to get the...
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
void av_freep(void *arg)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
enum AVAudioServiceType audio_service_type
Type of service that the audio stream conveys.
unsigned int nb_stream_indexes
int ff_network_inited_globally
#define av_assert0(cond)
assert() equivalent, that is always enabled.
enum AVSampleFormat sample_fmt
audio sample format
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
int ff_network_init(void)
unsigned avformat_version(void)
Return the LIBAVFORMAT_VERSION_INT constant.
const char * avformat_license(void)
Return the libavformat license.
attribute_deprecated void(* destruct)(struct AVPacket *)
int id
unique ID to identify the chapter
int id
Format-specific stream ID.
enum AVStreamParseType need_parsing
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
AVStream ** streams
A list of all streams in the file.
AVFormatContext * avformat_alloc_context(void)
Allocate an AVFormatContext.
const char * avformat_configuration(void)
Return the libavformat build-time configuration.
static double av_q2d(AVRational a)
Convert rational to double.
int av_reallocp(void *ptr, size_t size)
Allocate or reallocate a block of memory.
AVProgram * av_new_program(AVFormatContext *ac, int id)
int avformat_network_init(void)
Do global initialization of network components.
int fps_probe_size
The number of frames used for determining the framerate in avformat_find_stream_info().
#define AVERROR_EOF
End of file.
int av_match_ext(const char *filename, const char *extensions)
Return a positive value if the given filename has one of the given extensions, 0 otherwise.
static void copy(LZOContext *c, int cnt)
Copies bytes from input to output buffer with checking.
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).
enum AVDiscard discard
selects which program to discard and which to feed to the caller
static AVPacket flush_pkt
struct AVStream::@91 * info
int duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
unsigned int * stream_index
enum AVCodecID video_codec_id
Forced video codec_id.
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
struct AVOutputFormat * oformat
The output container format.
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
struct AVPacketList * raw_packet_buffer
Raw packets from the demuxer, prior to parsing and decoding.
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
static const uint8_t frame_size[4]
void av_dump_format(AVFormatContext *ic, int index, const char *url, int is_output)
void av_dict_copy(AVDictionary **dst, AVDictionary *src, int flags)
Copy entries from one AVDictionary struct into another.
int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type, int wanted_stream_nb, int related_stream, AVCodec **decoder_ret, int flags)
Find the "best" stream in the file.
av_cold int avcodec_close(AVCodecContext *avctx)
Close a given AVCodecContext and free all the data associated with it (but not the AVCodecContext its...
static int64_t start_time
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.
AVDictionary * metadata
Metadata that applies to the whole file.
int av_get_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
int has_b_frames
Size of the frame reordering buffer in the decoder.
void av_free(void *ptr)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc(). ...
int64_t pos
Byte position of currently parsed frame in stream.
int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp, int flags)
Get the index for a specific timestamp.
void * av_fast_realloc(void *ptr, unsigned int *size, size_t min_size)
Reallocate the given block if it is not large enough, otherwise do nothing.
void av_hex_dump(FILE *f, const uint8_t *buf, int size)
Send a nice hexadecimal dump of a buffer to the specified file stream.
struct AVCodecParser * parser
An AV_PKT_DATA_PARAM_CHANGE side data packet is laid out as follows:
unsigned int avpriv_toupper4(unsigned int x)
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
int avio_close(AVIOContext *s)
Close the resource accessed by the AVIOContext s and free it.
int avcodec_is_open(AVCodecContext *s)
int64_t convergence_duration
Time difference in AVStream->time_base units from the pts of this packet to the point at which the ou...
int capabilities
Codec capabilities.
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
int av_read_play(AVFormatContext *s)
Start playing a network-based stream (e.g.
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values. ...
preferred ID for decoding MPEG audio layer 1, 2 or 3
AVBufferRef * buf
A reference to the reference-counted buffer where the packet data is stored.
void ff_id3v2_free_extra_meta(ID3v2ExtraMeta **extra_meta)
Free memory allocated parsing special (non-text) metadata.
simple assert() macros that are a bit more flexible than ISO C assert().
int64_t av_gcd(int64_t a, int64_t b)
Return the greatest common divisor of a and b.
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.
int av_isspace(int c)
Locale-independent conversion of ASCII isspace.
AVRational avg_frame_rate
Average framerate.
New fields can be added to the end with minor version bumps.
AVInputFormat * av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
Guess the file format.
int min_distance
Minimum distance between this and the previous keyframe, used to avoid unneeded searching.
size_t av_strlcpy(char *dst, const char *src, size_t size)
Copy the string src to dst, but no more than size - 1 bytes, and null-terminate dst.
int flags
A combination of AV_PKT_FLAG values.
const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)
AVCodecContext * codec
Codec context associated with this stream.
static float distance(float x, float y, int band)
int props
Codec properties, a combination of AV_CODEC_PROP_* flags.
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.
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
common internal API header
#define FF_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
#define FF_MAX_EXTRADATA_SIZE
Maximum size in bytes of extradata.
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
int64_t fps_first_dts
Those are used for average framerate estimation.
int av_read_pause(AVFormatContext *s)
Pause a network-based stream (e.g.
int64_t av_rescale_q_rnd(int64_t a, AVRational bq, AVRational cq, enum AVRounding rnd)
Rescale a 64-bit integer by 2 rational numbers with specified rounding.
int seekable
A combination of AVIO_SEEKABLE_ flags or 0 when the stream is not seekable.
int bit_rate
the average bitrate
char filename[1024]
input or output filename
int64_t av_rescale(int64_t a, int64_t b, int64_t c)
Rescale a 64-bit integer with rounding to nearest.
#define AV_TIME_BASE
Internal time base represented as integer.
enum AVCodecID audio_codec_id
Forced audio codec_id.
AVCodecContext * avcodec_alloc_context3(const AVCodec *codec)
Allocate an AVCodecContext and set its fields to default values.
int av_parser_parse2(AVCodecParserContext *s, AVCodecContext *avctx, uint8_t **poutbuf, int *poutbuf_size, const uint8_t *buf, int buf_size, int64_t pts, int64_t dts, int64_t pos)
Parse a packet.
static const chunk_decoder decoder[8]
int width
picture width / height.
int64_t offset
byte offset from starting packet start
int av_find_default_stream_index(AVFormatContext *s)
int av_probe_input_buffer(AVIOContext *pb, AVInputFormat **fmt, const char *filename, void *logctx, unsigned int offset, unsigned int max_probe_size)
Probe a bytestream to determine the input format.
static av_always_inline int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
int64_t convergence_duration
Time difference in stream time base units from the pts of this packet to the point at which the outpu...
internal header for RIFF based (de)muxers do NOT include this in end user applications ...
void av_parser_close(AVCodecParserContext *s)
static av_always_inline av_const long int lrintf(float x)
int ticks_per_frame
For some codecs, the time base is closer to the field rate than the frame rate.
int ffio_rewind_with_probe_data(AVIOContext *s, unsigned char *buf, int buf_size)
Rewind the AVIOContext using the specified buffer containing the first buf_size bytes of the file...
#define AVERROR_EXIT
Immediate exit was requested; the called function should not be restarted.
unsigned int probesize
Maximum size of the data read from input for determining the input container format.
preferred ID for MPEG-1/2 video decoding
int thread_count
thread count is used to decide how many independent tasks should be passed to execute() ...
int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
Return in 'buf' the path with 'd' replaced by a number.
void ff_id3v2_read(AVFormatContext *s, const char *magic, ID3v2ExtraMeta **extra_meta)
Read an ID3v2 tag, including supported extra metadata.
int raw_packet_buffer_remaining_size
int64_t av_gettime(void)
Get the current time in microseconds.
#define AVERROR_PATCHWELCOME
Not yet implemented in Libav, patches welcome.
int64_t end
chapter start/end time in time_base units
int avformat_network_deinit(void)
Undo the initialization done by avformat_network_init.
int frame_size
Number of samples per channel in an audio frame.
#define AV_LOG_INFO
Standard information.
AVCodecParserContext * av_parser_init(int codec_id)
enum AVMediaType codec_type
int ff_check_interrupt(AVIOInterruptCB *cb)
Check if the user has requested to interrup a blocking function associated with cb.
int debug
Flags to enable debugging.
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
int av_opt_set_dict(void *obj, AVDictionary **options)
int sample_rate
samples per second
AVIOContext * pb
I/O context.
main external API structure.
AVCodec * avcodec_find_decoder(enum AVCodecID id)
Find a registered decoder with a matching codec ID.
int av_filename_number_test(const char *filename)
Check whether filename actually is a numbered sequence generator.
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Describe the class of an AVClass context structure.
rational number numerator/denominator
struct AVPacketList * packet_buffer_end
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.
int attribute_align_arg avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
Initialize the AVCodecContext to use the given AVCodec.
void avformat_free_context(AVFormatContext *s)
Free an AVFormatContext and all its streams.
This structure contains the data a format has to probe a file.
int av_get_audio_frame_duration(AVCodecContext *avctx, int frame_bytes)
Return audio frame duration.
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
Return the next frame of a stream.
int avio_pause(AVIOContext *h, int pause)
Pause and resume playing - only meaningful if using a network streaming protocol (e.g.
int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
Seek to timestamp ts.
This struct describes the properties of a single codec described by an AVCodecID. ...
struct AVPacketList * parse_queue_end
struct AVPacketList * parse_queue
Packets split by the parser get queued here.
int64_t start_time
Position of the first frame of the component, in AV_TIME_BASE fractional seconds. ...
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
Seek to the keyframe at timestamp.
int64_t duration
Decoding: duration of the stream, in stream time base.
static int av_toupper(int c)
Locale-independent conversion of ASCII characters to uppercase.
const OptionDef options[]
int(* split)(AVCodecContext *avctx, const uint8_t *buf, int buf_size)
void av_opt_free(void *obj)
Free all string and binary options in obj.
#define FF_DISABLE_DEPRECATION_WARNINGS
common internal api header.
struct AVPacketList * next
int ff_id3v2_match(const uint8_t *buf, const char *magic)
Detect ID3v2 Header.
#define CODEC_CAP_CHANNEL_CONF
Codec should fill in channel configuration and samplerate instead of container.
int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
Read packets of a media file to get stream information.
int64_t start_time
Decoding: pts of the first frame of the stream, in stream time base.
int disposition
AV_DISPOSITION_* bit field.
AVBufferRef * av_buffer_ref(AVBufferRef *buf)
Create a new reference to an AVBuffer.
int pts_wrap_bits
number of bits in pts (used for wrapping control)
AVRational time_base
time base in which the start/end timestamps are specified
#define PARSER_FLAG_COMPLETE_FRAMES
int av_grow_packet(AVPacket *pkt, int grow_by)
Increase packet size, correctly zeroing padding.
void av_init_packet(AVPacket *pkt)
Initialize optional fields of a packet with default values.
#define AV_PKT_FLAG_CORRUPT
The packet content is corrupted.
int max_analyze_duration
Maximum duration (in AV_TIME_BASE units) of the data read from input in avformat_find_stream_info().
struct AVInputFormat * iformat
The input container format.
void avformat_close_input(AVFormatContext **ps)
Close an opened input AVFormatContext.
AVInputFormat * av_iformat_next(AVInputFormat *f)
If f is NULL, returns the first registered input format, if f is non-NULL, returns the next registere...
void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode)
unsigned int index_entries_allocated_size
#define AVERROR_DECODER_NOT_FOUND
Decoder not found.
#define FF_ENABLE_DEPRECATION_WARNINGS
int channels
number of audio channels
int ff_id3v2_tag_len(const uint8_t *buf)
Get the length of an ID3v2 tag.
struct AVCodecParserContext * parser
void * priv_data
Format private data.
int codec_info_nb_frames
Number of frames that have been demuxed during av_find_stream_info()
struct AVPacket::@11 * side_data
Additional packet data that can be provided by the container.
#define AVERROR_STREAM_NOT_FOUND
Stream not found.
int attribute_align_arg avcodec_decode_video2(AVCodecContext *avctx, AVFrame *picture, int *got_picture_ptr, AVPacket *avpkt)
Decode the video frame of size avpkt->size from avpkt->data into picture.
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
int bit_rate
Total stream bitrate in bit/s, 0 if not available.
int repeat_pict
This field is used for proper frame duration computation in lavf.
int64_t duration
Duration of the stream, in AV_TIME_BASE fractional seconds.
enum AVFieldOrder field_order
Field order.
#define AV_DICT_IGNORE_SUFFIX
unbuffered private I/O API
#define FFSWAP(type, a, b)
void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload, AVStream *st)
Send a nice dump of a packet to the log.
void av_hex_dump_log(void *avcl, int level, const uint8_t *buf, int size)
Send a nice hexadecimal dump of a buffer to the log.
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.
AVInputFormat * av_probe_input_format(AVProbeData *pd, int is_opened)
Guess the file format.
struct AVPacketList * raw_packet_buffer_end
This structure stores compressed data.
int key_frame
Set by parser to 1 for key frames and 0 for non-key frames.
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 AV_NOPTS_VALUE
Undefined timestamp value.
int64_t av_compare_mod(uint64_t a, uint64_t b, uint64_t mod)
Compare 2 integers modulo mod.
uint8_t * subtitle_header
Header containing style information for text subtitles.
int attribute_align_arg avcodec_decode_audio4(AVCodecContext *avctx, AVFrame *frame, int *got_frame_ptr, AVPacket *avpkt)
Decode the audio frame of size avpkt->size from avpkt->data into frame.