67 #define LICENSE_PREFIX "libavformat license: "
114 ext = strrchr(filename,
'.');
120 while (*p !=
'\0' && *p !=
',' && q-ext1<
sizeof(ext1)-1)
141 namelen = strlen(name);
142 while ((p = strchr(names,
','))) {
143 len =
FFMAX(p - names, namelen);
152 const char *mime_type)
155 int score_max, score;
158 #if CONFIG_IMAGE2_MUXER
159 if (!short_name && filename &&
178 if (score > score_max) {
187 const char *filename,
const char *mime_type,
enum AVMediaType type){
191 #if CONFIG_IMAGE2_MUXER
192 if(!strcmp(fmt->
name,
"image2") || !strcmp(fmt->
name,
"image2pipe")){
242 old_size = pkt->
size;
285 if (score > *score_max) {
288 }
else if (score == *score_max)
303 if (fmt->extensions &&
av_match_ext(
"mp3", fmt->extensions)) {
319 static const struct {
338 for (i = 0; fmt_id_type[i].name; i++) {
339 if (!strcmp(fmt->
name, fmt_id_type[i].name)) {
353 #define PROBE_BUF_MIN 2048
354 #define PROBE_BUF_MAX (1<<20)
357 const char *filename,
void *logctx,
358 unsigned int offset,
unsigned int max_probe_size)
362 int ret = 0, probe_size;
364 if (!max_probe_size) {
372 if (offset >= max_probe_size) {
376 max_probe_size -= offset;
378 for(probe_size=
PROBE_BUF_MIN; probe_size<=max_probe_size && !*fmt;
379 probe_size =
FFMIN(probe_size<<1,
FFMAX(max_probe_size, probe_size+1))) {
402 av_log(logctx,
AV_LOG_WARNING,
"Format detected only with low score of %d, misdetection possible!\n", score);
404 av_log(logctx,
AV_LOG_DEBUG,
"Probed with size=%d and score=%d\n", probe_size, score);
454 (*plast_pktl)->next = pktl;
456 *packet_buffer = pktl;
494 if ((ret =
init_input(s, filename, &tmp)) < 0)
530 if (id3v2_extra_meta &&
626 if (!pktl || ret ==
AVERROR(EAGAIN))
640 "Dropped corrupted packet (stream = %d)\n",
671 #if FF_API_READ_PACKET
739 if (frame_size <= 0 || st->codec->sample_rate <= 0)
760 int64_t dts, int64_t pts)
771 for(; pktl; pktl= pktl->
next){
796 for(; pktl; pktl= pktl->
next){
808 for(; pktl; pktl= pktl->
next){
829 int num, den, presentation_delayed, delay, i;
840 presentation_delayed = 0;
846 presentation_delayed = 1;
903 presentation_delayed = 1;
906 "IN delayed:%d pts:%"PRId64
", dts:%"PRId64
" cur_dts:%"PRId64
" st:%d pc:%p\n",
912 if (presentation_delayed) {
979 "OUTdelayed:%d/%d pts:%"PRId64
", dts:%"PRId64
" cur_dts:%"PRId64
"\n",
980 presentation_delayed, delay, pkt->
pts, pkt->
dts, st->
cur_dts);
993 *pkt_buf = pktl->
next;
1011 int ret = 0, got_output = 0;
1019 while (size > 0 || (pkt == &
flush_pkt && got_output)) {
1024 &out_pkt.
data, &out_pkt.
size, data, size,
1032 got_output = !!out_pkt.
size;
1107 *pkt_buffer = pktl->
next;
1109 *pkt_buffer_end =
NULL;
1116 int ret = 0, i, got_packet = 0;
1144 cur_pkt.
pts < cur_pkt.
dts) {
1145 av_log(s,
AV_LOG_WARNING,
"Invalid timestamps stream=%d, pts=%"PRId64
", dts=%"PRId64
", size=%d\n",
1152 av_log(s,
AV_LOG_DEBUG,
"ff_read_packet stream=%d, pts=%"PRId64
", dts=%"PRId64
", size=%d, duration=%d, flags=%d\n",
1195 av_log(s,
AV_LOG_DEBUG,
"read_frame_internal stream=%d, pts=%"PRId64
", dts=%"PRId64
", size=%d, duration=%d, flags=%d\n",
1246 if (pktl && ret !=
AVERROR(EAGAIN)) {
1274 int first_audio_index = -1;
1287 first_audio_index = i;
1289 return first_audio_index >= 0 ? first_audio_index : 0;
1348 int *nb_index_entries,
1349 unsigned int *index_entries_allocated_size,
1355 if((
unsigned)*nb_index_entries + 1 >= UINT_MAX /
sizeof(
AVIndexEntry))
1359 index_entries_allocated_size,
1360 (*nb_index_entries + 1) *
1365 *index_entries= entries;
1370 index= (*nb_index_entries)++;
1371 ie= &entries[
index];
1372 assert(index==0 || ie[-1].timestamp < timestamp);
1374 ie= &entries[
index];
1378 memmove(entries + index + 1, entries + index,
sizeof(
AVIndexEntry)*(*nb_index_entries - index));
1379 (*nb_index_entries)++;
1380 }
else if(ie->
pos == pos && distance < ie->min_distance)
1398 timestamp, size, distance, flags);
1402 int64_t wanted_timestamp,
int flags)
1411 if(b && entries[b-1].timestamp < wanted_timestamp)
1417 if(timestamp >= wanted_timestamp)
1419 if(timestamp <= wanted_timestamp)
1439 wanted_timestamp, flags);
1446 int64_t ts_min, ts_max, ts;
1451 if (stream_index < 0)
1454 av_dlog(s,
"read_seek: %d %"PRId64
"\n", stream_index, target_ts);
1465 index=
FFMAX(index, 0);
1471 av_dlog(s,
"using cached pos_min=0x%"PRIx64
" dts_min=%"PRId64
"\n",
1478 assert(index < st->nb_index_entries);
1485 av_dlog(s,
"using cached pos_max=0x%"PRIx64
" pos_limit=0x%"PRIx64
" dts_max=%"PRId64
"\n",
1486 pos_max,pos_limit, ts_max);
1490 pos=
ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->
read_timestamp);
1504 int64_t pos_min, int64_t pos_max, int64_t pos_limit,
1505 int64_t ts_min, int64_t ts_max,
int flags, int64_t *ts_ret,
1506 int64_t (*read_timestamp)(
struct AVFormatContext *,
int , int64_t *, int64_t ))
1509 int64_t start_pos, filesize;
1512 av_dlog(s,
"gen_seek: %d %"PRId64
"\n", stream_index, target_ts);
1516 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1524 pos_max = filesize - 1;
1527 ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1534 int64_t tmp_pos= pos_max + 1;
1535 int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1540 if(tmp_pos >= filesize)
1546 if(ts_min > ts_max){
1548 }
else if(ts_min == ts_max){
1553 while (pos_min < pos_limit) {
1554 av_dlog(s,
"pos_min=0x%"PRIx64
" pos_max=0x%"PRIx64
" dts_min=%"PRId64
" dts_max=%"PRId64
"\n",
1555 pos_min, pos_max, ts_min, ts_max);
1556 assert(pos_limit <= pos_max);
1559 int64_t approximate_keyframe_distance= pos_max - pos_limit;
1561 pos =
av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1562 + pos_min - approximate_keyframe_distance;
1563 }
else if(no_change==1){
1565 pos = (pos_min + pos_limit)>>1;
1573 else if(pos > pos_limit)
1577 ts = read_timestamp(s, stream_index, &pos, INT64_MAX);
1582 av_dlog(s,
"%"PRId64
" %"PRId64
" %"PRId64
" / %"PRId64
" %"PRId64
" %"PRId64
" target:%"PRId64
" limit:%"PRId64
" start:%"PRId64
" noc:%d\n",
1583 pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts,
1584 pos_limit, start_pos, no_change);
1590 if (target_ts <= ts) {
1591 pos_limit = start_pos - 1;
1595 if (target_ts >= ts) {
1604 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1606 ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1607 av_dlog(s,
"pos=0x%"PRIx64
" %"PRId64
"<=%"PRId64
"<=%"PRId64
"\n",
1608 pos, ts_min, target_ts, ts_max);
1614 int64_t pos_min, pos_max;
1619 if (pos < pos_min) pos= pos_min;
1620 else if(pos > pos_max) pos= pos_max;
1628 int stream_index, int64_t timestamp,
int flags)
1635 st = s->
streams[stream_index];
1639 if(index < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
1642 if(index < 0 || index==st->nb_index_entries-1){
1659 }
while (read_status ==
AVERROR(EAGAIN));
1660 if (read_status < 0)
1687 int64_t timestamp,
int flags)
1699 if(stream_index < 0){
1701 if(stream_index < 0)
1742 if(min_ts > ts || max_ts < ts)
1796 int64_t
start_time, start_time1, end_time, end_time1;
1797 int64_t
duration, duration1, filesize;
1801 start_time = INT64_MAX;
1802 end_time = INT64_MIN;
1803 duration = INT64_MIN;
1808 start_time =
FFMIN(start_time, start_time1);
1810 end_time1 = start_time1
1812 end_time =
FFMAX(end_time, end_time1);
1817 duration =
FFMAX(duration, duration1);
1820 if (start_time != INT64_MAX) {
1822 if (end_time != INT64_MIN)
1823 duration =
FFMAX(duration, end_time - start_time);
1825 if (duration != INT64_MIN) {
1889 #define DURATION_MAX_READ_SIZE 250000
1890 #define DURATION_MAX_RETRY 3
1897 int read_size, i, ret;
1899 int64_t filesize, offset,
duration;
1933 }
while(ret ==
AVERROR(EAGAIN));
1936 read_size += pkt->
size;
1941 duration = end_time = pkt->
pts;
1979 file_size =
FFMAX(0, file_size);
2003 av_dlog(ic,
"%d: start_time: %0.3f duration: %0.3f\n", i,
2007 av_dlog(ic,
"stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2046 int got_picture = 1, ret = 0;
2067 av_dict_set(options ? options : &thread_opt,
"threads",
"1", 0);
2084 while ((pkt.
size > 0 || (!pkt.
data && got_picture)) &&
2094 &got_picture, &pkt);
2130 if(tag == tags[i].tag)
2150 if (sflags & (1 << (bps - 1))) {
2173 for(i=0; tags && tags[i]; i++){
2183 for(i=0; tags && tags[i]; i++){
2204 if (j != i && next_start > ch->
start && next_start < end)
2207 ch->
end = (end == INT64_MAX) ? ch->
start : end;
2212 if(i<60*12)
return i*1001;
2213 else return ((
const int[]){24,30,60,12,15})[i-60*12]*1000*12;
2238 int i, count, ret, read_size, j;
2261 av_dict_set(options ? &options[i] : &thread_opt,
"threads",
"1", 0);
2280 #if FF_API_R_FRAME_RATE
2298 int fps_analyze_framecount = 20;
2307 fps_analyze_framecount *= 2;
2360 (options && i < orig_nb_streams) ?
2361 &options[i] :
NULL);
2367 "decoding for stream %d failed\n", st->
index);
2372 "Could not find codec parameters (%s)\n", buf);
2386 goto find_stream_info_err;
2389 read_size += pkt->
size;
2397 "packet %d with DTS %"PRId64
", packet %d with DTS "
2410 "packet %d with DTS %"PRId64
", packet %d with DTS "
2431 #if FF_API_R_FRAME_RATE
2433 int64_t last = st->
info->last_dts;
2439 if (st->
info->duration_count < 2)
2440 memset(st->
info->duration_error, 0,
sizeof(st->
info->duration_error));
2443 int ticks=
lrintf(dur*framerate/(1001*12));
2444 double error = dur - (double)ticks*1001*12 / framerate;
2445 st->
info->duration_error[i] += error*error;
2447 st->
info->duration_count++;
2449 if (st->
info->duration_count > 3)
2450 st->
info->duration_gcd =
av_gcd(st->
info->duration_gcd, duration);
2453 st->
info->last_dts = pkt->
dts;
2496 double best_error = 0.01;
2512 if (error < best_error) {
2514 best_fps = std_fps.
num;
2519 best_fps, 12*1001, INT_MAX);
2522 #if FF_API_R_FRAME_RATE
2528 if (st->
info->duration_count && !st->r_frame_rate.num
2532 best_error = best_error*best_error*st->
info->duration_count*1000*12*30;
2536 if(error < best_error){
2542 if (num && (!st->r_frame_rate.num || (
double)num/(12*1001) < 1.01 *
av_q2d(st->r_frame_rate)))
2543 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2569 find_stream_info_err:
2591 int wanted_stream_nb,
2598 unsigned *program =
NULL;
2601 if (related_stream >= 0 && wanted_stream_nb < 0) {
2608 for (i = 0; i < nb_streams; i++) {
2609 int real_stream_index = program ? program[i] : i;
2614 if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
2629 ret = real_stream_index;
2631 if (program && i == nb_streams - 1 && ret < 0) {
2638 *decoder_ret = best_decoder;
2706 #if FF_API_CLOSE_INPUT_FILE
2742 if (s->
nb_streams >= INT_MAX/
sizeof(*streams))
2782 #if FF_API_R_FRAME_RATE
2797 av_dlog(ac,
"new_program: id=0x%04x\n",
id);
2833 chapter->
start = start;
2868 uint64_t v=
lrintf(d*100);
2881 if(strcmp(
"language", tag->
key))
2914 display_aspect_ratio.
num, display_aspect_ratio.
den);
2919 #if FF_API_R_FRAME_RATE
2920 if(st->r_frame_rate.den && st->r_frame_rate.num)
2963 is_output ?
"Output" :
"Input",
2966 is_output ?
"to" :
"from", url);
2971 int hours, mins, secs, us;
3008 int j, k, total = 0;
3013 name ? name->
value :
"");
3021 if (total < ic->nb_streams)
3031 #if FF_API_AV_GETTIME && CONFIG_SHARED && HAVE_SYMVER
3032 FF_SYMVER(int64_t,
av_gettime, (
void),
"LIBAVFORMAT_54")
3044 const char *path,
int number)
3047 char *q, buf1[20], c;
3048 int nd,
len, percentd_found;
3060 while (isdigit(*p)) {
3061 nd = nd * 10 + *p++ -
'0';
3064 }
while (isdigit(c));
3073 snprintf(buf1,
sizeof(buf1),
"%0*d", nd, number);
3075 if ((q - buf + len) > buf_size - 1)
3077 memcpy(q, buf1, len);
3085 if ((q - buf) < buf_size - 1)
3089 if (!percentd_found)
3102 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3104 for(i=0;i<
size;i+=16) {
3111 PRINT(
" %02x", buf[i+j]);
3116 for(j=0;j<
len;j++) {
3118 if (c < ' ' || c >
'~')
3139 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3174 char *authorization,
int authorization_size,
3175 char *hostname,
int hostname_size,
3177 char *path,
int path_size,
3180 const char *p, *ls, *at, *col, *brk;
3182 if (port_ptr) *port_ptr = -1;
3183 if (proto_size > 0) proto[0] = 0;
3184 if (authorization_size > 0) authorization[0] = 0;
3185 if (hostname_size > 0) hostname[0] = 0;
3186 if (path_size > 0) path[0] = 0;
3189 if ((p = strchr(url,
':'))) {
3201 ls = strchr(p,
'/');
3203 ls = strchr(p,
'?');
3212 if ((at = strchr(p,
'@')) && at < ls) {
3214 FFMIN(authorization_size, at + 1 - p));
3218 if (*p ==
'[' && (brk = strchr(p,
']')) && brk < ls) {
3221 FFMIN(hostname_size, brk - p));
3222 if (brk[1] ==
':' && port_ptr)
3223 *port_ptr = atoi(brk + 2);
3224 }
else if ((col = strchr(p,
':')) && col < ls) {
3226 FFMIN(col + 1 - p, hostname_size));
3227 if (port_ptr) *port_ptr = atoi(col + 1);
3230 FFMIN(ls + 1 - p, hostname_size));
3237 static const char hex_table_uc[16] = {
'0',
'1',
'2',
'3',
3240 'C',
'D',
'E',
'F' };
3241 static const char hex_table_lc[16] = {
'0',
'1',
'2',
'3',
3244 'c',
'd',
'e',
'f' };
3245 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3247 for(i = 0; i < s; i++) {
3248 buff[i * 2] = hex_table[src[i] >> 4];
3249 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3265 c = toupper((
unsigned char) *p++);
3266 if (c >=
'0' && c <=
'9')
3268 else if (c >=
'A' && c <=
'F')
3284 unsigned int pts_num,
unsigned int pts_den)
3288 if(new_tb.
num != pts_num)
3293 if(new_tb.
num <= 0 || new_tb.
den <= 0) {
3302 const char *authorization,
const char *hostname,
3303 int port,
const char *fmt, ...)
3306 struct addrinfo hints = { 0 }, *ai;
3312 if (authorization && authorization[0])
3314 #if CONFIG_NETWORK && defined(AF_INET6)
3319 if (ai->ai_family == AF_INET6) {
3336 int len = strlen(str);
3339 vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);
3366 const char *ptr = str;
3371 char *dest =
NULL, *dest_end;
3372 int key_len, dest_len = 0;
3375 while (*ptr && (isspace(*ptr) || *ptr ==
','))
3382 if (!(ptr = strchr(key,
'=')))
3385 key_len = ptr - key;
3387 callback_get_buf(context, key, key_len, &dest, &dest_len);
3388 dest_end = dest + dest_len - 1;
3392 while (*ptr && *ptr !=
'\"') {
3396 if (dest && dest < dest_end)
3400 if (dest && dest < dest_end)
3408 for (; *ptr && !(isspace(*ptr) || *ptr ==
','); ptr++)
3409 if (dest && dest < dest_end)
3430 char *sep, *path_query;
3432 if (base && strstr(base,
"://") && rel[0] ==
'/') {
3435 sep = strstr(buf,
"://");
3438 if (rel[1] ==
'/') {
3443 sep = strchr(sep,
'/');
3452 if (!base || strstr(rel,
"://") || rel[0] ==
'/') {
3460 path_query = strchr(buf,
'?');
3461 if (path_query !=
NULL)
3465 if (rel[0] ==
'?') {
3471 sep = strrchr(buf,
'/');
3479 sep = strrchr(buf,
'/');
3481 if (!strcmp(sep ? &sep[1] : buf,
"..")) {
3499 struct tm time1 = {0}, time2 = {0};
3501 ret1 = strptime(datestr,
"%Y - %m - %d %T", &time1);
3502 ret2 = strptime(datestr,
"%Y - %m - %dT%T", &time2);
3509 "the date string.\n");
3518 return ofmt->
query_codec(codec_id, std_compliance);
3550 uint64_t channel_layout,
int32_t sample_rate,
3562 if (channel_layout) {
3570 if (width || height) {
3577 bytestream_put_le32(&data, flags);
3579 bytestream_put_le32(&data, channels);
3581 bytestream_put_le64(&data, channel_layout);
3583 bytestream_put_le32(&data, sample_rate);
3584 if (width || height) {
3585 bytestream_put_le32(&data, width);
3586 bytestream_put_le32(&data, height);
time_t av_timegm(struct tm *tm)
Convert the decomposed UTC time in tm to a time_t value.
#define AVFMT_NO_BYTE_SEEK
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 ...
int64_t avio_size(AVIOContext *s)
Get the filesize.
void av_free_packet(AVPacket *pkt)
Free a packet.
#define AV_PKT_FLAG_CORRUPT
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.
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
Write a packet to an output media file.
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.
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.
AVIndexEntry * index_entries
Only used if the format does not support seeking natively.
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.
int av_strncasecmp(const char *a, const char *b, size_t n)
Locale-independent case-insensitive compare.
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
void ff_network_close(void)
static int av_cmp_q(AVRational a, AVRational b)
Compare two rationals.
#define AV_DISPOSITION_ATTACHED_PIC
#define AV_DISPOSITION_DUB
#define MAX_STD_TIMEBASES
#define AVFMT_NOGENSEARCH
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
#define AV_DISPOSITION_KARAOKE
int duration
Duration of the current frame.
struct AVStream::@75 * info
int ctx_flags
Format-specific flags, see AVFMTCTX_xx.
int dts_ref_dts_delta
Offset of the current timestamp against last timestamp sync point in units of AVCodecContext.time_base.
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.
#define AVERROR_DECODER_NOT_FOUND
#define FFSWAP(type, a, b)
enum AVSampleFormat sample_fmt
audio sample format
const struct AVCodecTag * avformat_get_riff_video_tags(void)
int ff_network_init(void)
unsigned avformat_version(void)
Return the LIBAVFORMAT_VERSION_INT constant.
const char * avformat_license(void)
Return the libavformat license.
#define RAW_PACKET_BUFFER_SIZE
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.
AVFormatContext * avformat_alloc_context(void)
Allocate an AVFormatContext.
const char * avformat_configuration(void)
Return the libavformat build-time configuration.
#define AV_DISPOSITION_CLEAN_EFFECTS
static double av_q2d(AVRational a)
Convert rational to double.
AVProgram * av_new_program(AVFormatContext *ac, int id)
int avformat_network_init(void)
Do global initialization of network components.
const struct AVCodecTag * avformat_get_riff_audio_tags(void)
int fps_probe_size
decoding: number of frames used to probe fps
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
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
void(* destruct)(struct AVPacket *)
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...
int av_new_packet(AVPacket *pkt, int size)
Allocate the payload of a packet and initialize its fields with default values.
static int64_t start_time
AVCodecID
Identify the syntax and semantics of the bitstream.
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.
#define AVFMT_FLAG_IGNDTS
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.
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.
struct AVCodecParser * parser
An AV_PKT_DATA_PARAM_CHANGE side data packet is laid out as follows:
unsigned int avpriv_toupper4(unsigned int x)
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.
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
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.
#define AV_DISPOSITION_LYRICS
AVRational avg_frame_rate
Average framerate.
const AVCodecTag ff_codec_wav_tags[]
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.
#define LIBAV_CONFIGURATION
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.
#define AVFMT_FLAG_CUSTOM_IO
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.
#define FF_MAX_EXTRADATA_SIZE
Maximum size in bytes of extradata.
AVFrame * avcodec_alloc_frame(void)
Allocate an AVFrame and set its fields to default values.
unsigned int nb_streams
A list of all streams in the file.
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.
AVInputFormat * av_find_input_format(const char *short_name)
Find AVInputFormat based on the short name of the input format.
#define AV_DISPOSITION_DEFAULT
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
#define MAX_REORDER_DELAY
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.
enum AVCodecID audio_codec_id
Forced audio codec_id.
const AVCodecTag ff_codec_bmp_tags[]
int av_strcasecmp(const char *a, const char *b)
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.
enum AVCodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name, const char *filename, const char *mime_type, enum AVMediaType type)
Guess the codec ID based upon muxer and filename.
static const chunk_decoder decoder[8]
int width
picture width / height.
#define AV_DISPOSITION_ORIGINAL
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.
#define MAX_PROBE_PACKETS
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)
AVOutputFormat * av_guess_format(const char *short_name, const char *filename, const char *mime_type)
Return the output format in the list of registered output formats which best matches the provided par...
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...
void av_register_input_format(AVInputFormat *format)
unsigned int probesize
decoding: size of data to probe; encoding: unused.
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.
AVOutputFormat * av_oformat_next(AVOutputFormat *f)
If f is NULL, returns the first registered output format, if f is non-NULL, returns the next register...
#define PARSER_FLAG_COMPLETE_FRAMES
#define AV_CODEC_PROP_INTRA_ONLY
int raw_packet_buffer_remaining_size
int64_t av_gettime(void)
Get the current time in microseconds.
int64_t end
chapter start/end time in time_base units
#define AVSEEK_FLAG_BACKWARD
void av_register_output_format(AVOutputFormat *format)
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.
int pts_dts_delta
Presentation delay of current frame in units of AVCodecContext.time_base.
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.
int av_opt_set_dict(void *obj, AVDictionary **options)
int sample_rate
samples per second
#define AV_DISPOSITION_COMMENT
AVIOContext * pb
I/O context.
int64_t reference_dts
Timestamp corresponding to the last dts sync point.
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.
#define AV_DICT_IGNORE_SUFFIX
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
#define AVFMT_FLAG_GENPTS
#define LIBAVFORMAT_VERSION_INT
void avcodec_get_frame_defaults(AVFrame *frame)
Set the fields of the given AVFrame to default values.
Describe the class of an AVClass context structure.
#define FF_ARRAY_ELEMS(a)
rational number numerator/denominator
struct AVPacketList * packet_buffer_end
#define AVFMT_NOBINSEARCH
#define FF_INPUT_BUFFER_PADDING_SIZE
size_t av_strlcatf(char *dst, size_t size, const char *fmt,...)
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 AVFMT_FLAG_NOFILLIN
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.
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...
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. ...
#define AVPROBE_PADDING_SIZE
struct AVPacketList * parse_queue_end
#define AVFMT_FLAG_NOBUFFER
struct AVPacketList * parse_queue
Packets split by the parser get queued here.
int64_t start_time
Decoding: 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.
const OptionDef options[]
int av_strstart(const char *str, const char *pfx, const char **ptr)
Return non-zero if pfx is a prefix of str.
#define AVFMT_FLAG_NOPARSE
#define AVERROR_STREAM_NOT_FOUND
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.
common internal api header.
struct AVPacketList * next
int ff_id3v2_match(const uint8_t *buf, const char *magic)
Detect ID3v2 Header.
void * av_realloc(void *ptr, size_t size)
Allocate or reallocate a block of memory.
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.
#define AVERROR_INVALIDDATA
int disposition
AV_DISPOSITION_* bit field.
#define AVPROBE_SCORE_MAX
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
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.
int max_analyze_duration
decoding: maximum time (in AV_TIME_BASE units) during which the input should be analyzed in avformat_...
struct AVInputFormat * iformat
Can only be iformat or oformat, not both at the same time.
void avformat_close_input(AVFormatContext **ps)
Close an opened input AVFormatContext.
#define AVERROR_PATCHWELCOME
enum AVCodecID ff_guess_image2_codec(const char *filename)
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 AV_DISPOSITION_FORCED
#define AVFMTCTX_NOHEADER
#define CODEC_CAP_CHANNEL_CONF
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()
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.
void avcodec_free_frame(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
int bit_rate
Decoding: total stream bitrate in bit/s, 0 if not available.
#define AV_DISPOSITION_HEARING_IMPAIRED
int repeat_pict
This field is used for proper frame duration computation in lavf.
int64_t duration
Decoding: duration of the stream, in AV_TIME_BASE fractional seconds.
unbuffered private I/O API
#define AVFMT_FLAG_DISCARD_CORRUPT
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.
#define AV_DISPOSITION_VISUAL_IMPAIRED
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 ...
int dts_sync_point
Synchronization point for start of timestamp generation.
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 AVFMT_GENERIC_INDEX
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.
if(!(ptr_align%ac->ptr_align)&&samples_align >=aligned_len)
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.