68 #define LICENSE_PREFIX "libavformat license: "
115 }
else if (num >= den) {
129 if(f)
return f->
next;
135 if(f)
return f->
next;
165 ext = strrchr(filename,
'.');
171 while (*p !=
'\0' && *p !=
',' && q-ext1<
sizeof(ext1)-1)
192 namelen = strlen(name);
193 while ((p = strchr(names,
','))) {
194 len =
FFMAX(p - names, namelen);
203 const char *mime_type)
206 int score_max, score;
209 #if CONFIG_IMAGE2_MUXER
210 if (!short_name && filename &&
221 if (fmt->
name && short_name && !strcmp(fmt->
name, short_name))
229 if (score > score_max) {
238 const char *filename,
const char *mime_type,
enum AVMediaType type){
242 #if CONFIG_IMAGE2_MUXER
243 if(!strcmp(fmt->
name,
"image2") || !strcmp(fmt->
name,
"image2pipe")){
293 old_size = pkt->
size;
336 if (score > *score_max) {
339 }
else if (score == *score_max)
354 if (fmt->extensions &&
av_match_ext(
"mp3", fmt->extensions)) {
370 static const struct {
389 for (i = 0; fmt_id_type[i].name; i++) {
390 if (!strcmp(fmt->
name, fmt_id_type[i].name)) {
403 #if FF_API_FORMAT_PARAMETERS
412 if (ap->time_base.num) {
413 snprintf(buf,
sizeof(buf),
"%d/%d", ap->time_base.den, ap->time_base.num);
416 if (ap->sample_rate) {
417 snprintf(buf,
sizeof(buf),
"%d", ap->sample_rate);
421 snprintf(buf,
sizeof(buf),
"%d", ap->channels);
424 if (ap->width || ap->height) {
425 snprintf(buf,
sizeof(buf),
"%dx%d", ap->width, ap->height);
432 snprintf(buf,
sizeof(buf),
"%d", ap->channel);
438 if (ap->mpeg2ts_compute_pcr) {
441 if (ap->initial_pause) {
461 memset(ap, 0,
sizeof(default_ap));
463 opts = convert_format_parameters(ap);
465 if(!ap->prealloced_context)
475 "will be ignored with AVFMT_NOFILE format.\n");
481 ic->
pb = ic->
pb ? ic->
pb : pb;
491 #define PROBE_BUF_MIN 2048
492 #define PROBE_BUF_MAX (1<<20)
495 const char *filename,
void *logctx,
496 unsigned int offset,
unsigned int max_probe_size)
499 unsigned char *buf =
NULL;
500 int ret = 0, probe_size;
502 if (!max_probe_size) {
510 if (offset >= max_probe_size) {
514 for(probe_size=
PROBE_BUF_MIN; probe_size<=max_probe_size && !*fmt;
515 probe_size =
FFMIN(probe_size<<1,
FFMAX(max_probe_size, probe_size+1))) {
518 if (probe_size < offset) {
534 pd.
buf = &buf[offset];
542 av_log(logctx,
AV_LOG_WARNING,
"Format detected only with low score of %d, misdetection possible!\n", score);
544 av_log(logctx,
AV_LOG_DEBUG,
"Probed with size=%d and score=%d\n", probe_size, score);
560 #if FF_API_FORMAT_PARAMETERS
569 if (!ap || !ap->prealloced_context)
624 if ((ret =
init_input(s, filename, &tmp)) < 0)
690 (*plast_pktl)->next = pktl;
692 *packet_buffer = pktl;
726 if (!pktl || ret ==
AVERROR(EAGAIN))
736 "Dropped corrupted packet (stream = %d)\n",
801 if (bits_per_sample) {
804 frame_size = (size << 3) / (bits_per_sample * enc->
channels);
854 if (frame_size <= 0 || st->codec->sample_rate <= 0)
890 int64_t dts, int64_t pts)
901 for(; pktl; pktl= pktl->
next){
925 for(; pktl; pktl= pktl->
next){
937 for(; pktl; pktl= pktl->
next){
957 int num, den, presentation_delayed, delay, i;
972 presentation_delayed = 0;
978 presentation_delayed = 1;
1035 presentation_delayed = 1;
1041 if (presentation_delayed) {
1064 if(old_diff < new_diff && old_diff < (pkt->
duration>>3)){
1208 av_log(s,
AV_LOG_WARNING,
"Invalid timestamps stream=%d, pts=%"PRId64
", dts=%"PRId64
", size=%d\n",
1218 av_log(s,
AV_LOG_DEBUG,
"av_read_packet stream=%d, pts=%"PRId64
", dts=%"PRId64
", size=%d, duration=%d, flags=%d\n",
1243 av_log(s,
AV_LOG_DEBUG,
"read_frame_internal stream=%d, pts=%"PRId64
", dts=%"PRId64
", size=%d, duration=%d, flags=%d\n",
1301 if (pktl && ret !=
AVERROR(EAGAIN)) {
1343 int first_audio_index = -1;
1355 first_audio_index = i;
1357 return first_audio_index >= 0 ? first_audio_index : 0;
1395 #if FF_API_SEEK_PUBLIC
1429 int *nb_index_entries,
1430 unsigned int *index_entries_allocated_size,
1436 if((
unsigned)*nb_index_entries + 1 >= UINT_MAX /
sizeof(
AVIndexEntry))
1440 index_entries_allocated_size,
1441 (*nb_index_entries + 1) *
1446 *index_entries= entries;
1451 index= (*nb_index_entries)++;
1452 ie= &entries[
index];
1453 assert(index==0 || ie[-1].timestamp < timestamp);
1455 ie= &entries[
index];
1459 memmove(entries + index + 1, entries + index,
sizeof(
AVIndexEntry)*(*nb_index_entries - index));
1460 (*nb_index_entries)++;
1461 }
else if(ie->
pos == pos && distance < ie->min_distance)
1479 timestamp, size, distance, flags);
1483 int64_t wanted_timestamp,
int flags)
1492 if(b && entries[b-1].timestamp < wanted_timestamp)
1498 if(timestamp >= wanted_timestamp)
1500 if(timestamp <= wanted_timestamp)
1520 wanted_timestamp, flags);
1523 #if FF_API_SEEK_PUBLIC
1533 int64_t ts_min, ts_max, ts;
1538 if (stream_index < 0)
1541 av_dlog(s,
"read_seek: %d %"PRId64
"\n", stream_index, target_ts);
1552 index=
FFMAX(index, 0);
1558 av_dlog(s,
"using cached pos_min=0x%"PRIx64
" dts_min=%"PRId64
"\n",
1565 assert(index < st->nb_index_entries);
1572 av_dlog(s,
"using cached pos_max=0x%"PRIx64
" pos_limit=0x%"PRIx64
" dts_max=%"PRId64
"\n",
1573 pos_max,pos_limit, ts_max);
1577 pos=
ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->
read_timestamp);
1590 #if FF_API_SEEK_PUBLIC
1591 int64_t av_gen_search(
AVFormatContext *s,
int stream_index, int64_t target_ts,
1592 int64_t pos_min, int64_t pos_max, int64_t pos_limit,
1593 int64_t ts_min, int64_t ts_max,
int flags, int64_t *ts_ret,
1594 int64_t (*read_timestamp)(
struct AVFormatContext *,
int , int64_t *, int64_t ))
1596 return ff_gen_search(s, stream_index, target_ts, pos_min, pos_max,
1597 pos_limit, ts_min, ts_max, flags, ts_ret,
1603 int64_t pos_min, int64_t pos_max, int64_t pos_limit,
1604 int64_t ts_min, int64_t ts_max,
int flags, int64_t *ts_ret,
1605 int64_t (*read_timestamp)(
struct AVFormatContext *,
int , int64_t *, int64_t ))
1608 int64_t start_pos, filesize;
1611 av_dlog(s,
"gen_seek: %d %"PRId64
"\n", stream_index, target_ts);
1615 ts_min = read_timestamp(s, stream_index, &pos_min,
INT64_MAX);
1623 pos_max = filesize - 1;
1626 ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1633 int64_t tmp_pos= pos_max + 1;
1634 int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos,
INT64_MAX);
1639 if(tmp_pos >= filesize)
1645 if(ts_min > ts_max){
1647 }
else if(ts_min == ts_max){
1652 while (pos_min < pos_limit) {
1653 av_dlog(s,
"pos_min=0x%"PRIx64
" pos_max=0x%"PRIx64
" dts_min=%"PRId64
" dts_max=%"PRId64
"\n",
1654 pos_min, pos_max, ts_min, ts_max);
1655 assert(pos_limit <= pos_max);
1658 int64_t approximate_keyframe_distance= pos_max - pos_limit;
1660 pos =
av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1661 + pos_min - approximate_keyframe_distance;
1662 }
else if(no_change==1){
1664 pos = (pos_min + pos_limit)>>1;
1672 else if(pos > pos_limit)
1676 ts = read_timestamp(s, stream_index, &pos,
INT64_MAX);
1681 av_dlog(s,
"%"PRId64
" %"PRId64
" %"PRId64
" / %"PRId64
" %"PRId64
" %"PRId64
" target:%"PRId64
" limit:%"PRId64
" start:%"PRId64
" noc:%d\n",
1682 pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts,
1683 pos_limit, start_pos, no_change);
1689 if (target_ts <= ts) {
1690 pos_limit = start_pos - 1;
1694 if (target_ts >= ts) {
1703 ts_min = read_timestamp(s, stream_index, &pos_min,
INT64_MAX);
1705 ts_max = read_timestamp(s, stream_index, &pos_min,
INT64_MAX);
1706 av_dlog(s,
"pos=0x%"PRIx64
" %"PRId64
"<=%"PRId64
"<=%"PRId64
"\n",
1707 pos, ts_min, target_ts, ts_max);
1713 int64_t pos_min, pos_max;
1717 if (stream_index < 0)
1726 if (pos < pos_min) pos= pos_min;
1727 else if(pos > pos_max) pos= pos_max;
1732 av_update_cur_dts(s, st, ts);
1738 int stream_index, int64_t timestamp,
int flags)
1745 st = s->
streams[stream_index];
1749 if(index < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
1752 if(index < 0 || index==st->nb_index_entries-1){
1769 }
while (read_status ==
AVERROR(EAGAIN));
1770 if (read_status < 0)
1808 if(stream_index < 0){
1810 if(stream_index < 0)
1841 if(min_ts > ts || max_ts < ts)
1888 int64_t
start_time, start_time1, end_time, end_time1;
1889 int64_t
duration, duration1, filesize;
1900 start_time =
FFMIN(start_time, start_time1);
1902 end_time1 = start_time1
1904 end_time =
FFMAX(end_time, end_time1);
1909 duration =
FFMAX(duration, duration1);
1915 duration =
FFMAX(duration, end_time - start_time);
1981 #define DURATION_MAX_READ_SIZE 250000
1982 #define DURATION_MAX_RETRY 3
1989 int read_size, i, ret;
1991 int64_t filesize, offset,
duration;
2028 }
while(ret ==
AVERROR(EAGAIN));
2031 read_size += pkt->
size;
2036 duration = end_time = pkt->
pts;
2074 file_size =
FFMAX(0, file_size);
2098 av_dlog(ic,
"%d: start_time: %0.3f duration: %0.3f\n", i,
2102 av_dlog(ic,
"stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2144 int got_picture = 1, ret = 0;
2159 av_dict_set(options ? options : &thread_opt,
"threads",
"1", 0);
2167 while ((pkt.
size > 0 || (!pkt.
data && got_picture)) &&
2177 &got_picture, &pkt);
2210 if(tag == tags[i].tag)
2223 for(i=0; tags && tags[i]; i++){
2233 for(i=0; tags && tags[i]; i++){
2254 if (j != i && next_start > ch->
start && next_start < end)
2262 if(i<60*12)
return i*1001;
2263 else return ((
const int[]){24,30,60,12,15})[i-60*12]*1000*12;
2286 #if FF_API_FORMAT_PARAMETERS
2295 int i, count, ret, read_size, j;
2325 av_dict_set(options ? &options[i] : &thread_opt,
"threads",
"1", 0);
2358 int fps_analyze_framecount = 20;
2367 fps_analyze_framecount *= 2;
2417 (options && i < orig_nb_streams) ?
2418 &options[i] :
NULL);
2423 "decoding for stream %d failed\n", st->
index);
2428 "Could not find codec parameters (%s)\n", buf);
2438 goto find_stream_info_err;
2440 read_size += pkt->
size;
2463 int ticks=
lrintf(dur*framerate/(1001*12));
2464 double error = dur - (double)ticks*1001*12 / framerate;
2531 if(error < best_error){
2582 if(ppkt1->stream_index != i)
2584 if(ppkt1->pkt->dts < 0)
2599 find_stream_info_err:
2621 int wanted_stream_nb,
2628 unsigned *program =
NULL;
2631 if (related_stream >= 0 && wanted_stream_nb < 0) {
2638 for (i = 0; i < nb_streams; i++) {
2639 int real_stream_index = program ? program[i] : i;
2644 if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
2659 ret = real_stream_index;
2661 if (program && i == nb_streams - 1 && ret < 0) {
2668 *decoder_ret = best_decoder;
2692 #if FF_API_FORMAT_PARAMETERS
2745 #if FF_API_CLOSE_INPUT_FILE
2766 #if FF_API_NEW_STREAM
2782 if (s->
nb_streams >= INT_MAX/
sizeof(*streams))
2831 av_dlog(ac,
"new_program: id=0x%04x\n",
id);
2867 chapter->
start = start;
2876 #if FF_API_FORMAT_PARAMETERS
2906 unsigned int tag = 0;
2934 #if FF_API_FORMAT_PARAMETERS
3002 "Tag %s/0x%08x incompatible with output codec id '%d'\n",
3013 av_log(s,
AV_LOG_WARNING,
"Codec for stream %d does not use global headers but container format requires global headers\n", i);
3078 int num, den, frame_size, i;
3080 av_dlog(s,
"compute_pkt_fields2: pts:%"PRId64
" dts:%"PRId64
" cur_dts:%"PRId64
" b:%d size:%d st:%d\n",
3117 "Application provided invalid, non monotonically increasing dts to muxer in stream %d: %"PRId64
" >= %"PRId64
"\n",
3171 this_pktl->
pkt= *pkt;
3182 while(!compare(s, &(*next_point)->pkt, pkt)){
3183 next_point= &(*next_point)->
next;
3190 assert(!*next_point);
3195 this_pktl->
next= *next_point;
3198 *next_point= this_pktl;
3225 if(stream_count && (s->
nb_streams == stream_count || flush)){
3270 av_dlog(s,
"av_interleaved_write_frame size:%d dts:%"PRId64
" pts:%"PRId64
"\n",
3373 if(strcmp(
"language", tag->
key))
3406 display_aspect_ratio.
num, display_aspect_ratio.
den);
3442 #if FF_API_DUMP_FORMAT
3463 is_output ?
"Output" :
"Input",
3466 is_output ?
"to" :
"from", url);
3471 int hours, mins, secs, us;
3508 int j, k, total = 0;
3513 name ? name->
value :
"");
3521 if (total < ic->nb_streams)
3534 gettimeofday(&tv,
NULL);
3535 return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
3543 #if FF_API_PARSE_DATE
3546 int64_t parse_date(
const char *timestr,
int duration)
3554 #if FF_API_FIND_INFO_TAG
3557 int find_info_tag(
char *arg,
int arg_size,
const char *tag1,
const char *info)
3564 const char *path,
int number)
3567 char *q, buf1[20], c;
3568 int nd,
len, percentd_found;
3580 while (isdigit(*p)) {
3581 nd = nd * 10 + *p++ -
'0';
3584 }
while (isdigit(c));
3593 snprintf(buf1,
sizeof(buf1),
"%0*d", nd, number);
3595 if ((q - buf + len) > buf_size - 1)
3597 memcpy(q, buf1, len);
3605 if ((q - buf) < buf_size - 1)
3609 if (!percentd_found)
3622 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3624 for(i=0;i<
size;i+=16) {
3631 PRINT(
" %02x", buf[i+j]);
3636 for(j=0;j<
len;j++) {
3638 if (c < ' ' || c >
'~')
3660 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3684 void av_pkt_dump(FILE *
f,
AVPacket *pkt,
int dump_payload)
3697 void av_pkt_dump_log(
void *avcl,
int level,
AVPacket *pkt,
int dump_payload)
3711 char *authorization,
int authorization_size,
3712 char *hostname,
int hostname_size,
3714 char *path,
int path_size,
3717 const char *p, *ls, *at, *col, *brk;
3719 if (port_ptr) *port_ptr = -1;
3720 if (proto_size > 0) proto[0] = 0;
3721 if (authorization_size > 0) authorization[0] = 0;
3722 if (hostname_size > 0) hostname[0] = 0;
3723 if (path_size > 0) path[0] = 0;
3726 if ((p = strchr(url,
':'))) {
3738 ls = strchr(p,
'/');
3740 ls = strchr(p,
'?');
3749 if ((at = strchr(p,
'@')) && at < ls) {
3751 FFMIN(authorization_size, at + 1 - p));
3755 if (*p ==
'[' && (brk = strchr(p,
']')) && brk < ls) {
3758 FFMIN(hostname_size, brk - p));
3759 if (brk[1] ==
':' && port_ptr)
3760 *port_ptr = atoi(brk + 2);
3761 }
else if ((col = strchr(p,
':')) && col < ls) {
3763 FFMIN(col + 1 - p, hostname_size));
3764 if (port_ptr) *port_ptr = atoi(col + 1);
3767 FFMIN(ls + 1 - p, hostname_size));
3774 static const char hex_table_uc[16] = {
'0',
'1',
'2',
'3',
3777 'C',
'D',
'E',
'F' };
3778 static const char hex_table_lc[16] = {
'0',
'1',
'2',
'3',
3781 'c',
'd',
'e',
'f' };
3782 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3784 for(i = 0; i < s; i++) {
3785 buff[i * 2] = hex_table[src[i] >> 4];
3786 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3802 c = toupper((
unsigned char) *p++);
3803 if (c >=
'0' && c <=
'9')
3805 else if (c >=
'A' && c <=
'F')
3820 #if FF_API_SET_PTS_INFO
3821 void av_set_pts_info(
AVStream *s,
int pts_wrap_bits,
3822 unsigned int pts_num,
unsigned int pts_den)
3829 unsigned int pts_num,
unsigned int pts_den)
3833 if(new_tb.
num != pts_num)
3838 if(new_tb.
num <= 0 || new_tb.
den <= 0) {
3847 const char *authorization,
const char *hostname,
3848 int port,
const char *fmt, ...)
3857 if (authorization && authorization[0])
3859 #if CONFIG_NETWORK && defined(AF_INET6)
3862 memset(&hints, 0,
sizeof(hints));
3882 int len = strlen(str);
3885 vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);
3912 const char *ptr = str;
3917 char *dest =
NULL, *dest_end;
3918 int key_len, dest_len = 0;
3921 while (*ptr && (isspace(*ptr) || *ptr ==
','))
3928 if (!(ptr = strchr(key,
'=')))
3931 key_len = ptr - key;
3933 callback_get_buf(context, key, key_len, &dest, &dest_len);
3934 dest_end = dest + dest_len - 1;
3938 while (*ptr && *ptr !=
'\"') {
3942 if (dest && dest < dest_end)
3946 if (dest && dest < dest_end)
3954 for (; *ptr && !(isspace(*ptr) || *ptr ==
','); ptr++)
3955 if (dest && dest < dest_end)
3978 if (base && strstr(base,
"://") && rel[0] ==
'/') {
3981 sep = strstr(buf,
"://");
3984 sep = strchr(sep,
'/');
3992 if (!base || strstr(rel,
"://") || rel[0] ==
'/') {
3999 sep = strrchr(buf,
'/');
4007 sep = strrchr(buf,
'/');
4009 if (!strcmp(sep ? &sep[1] : buf,
"..")) {
4027 struct tm time1 = {0}, time2 = {0};
4029 ret1 = strptime(datestr,
"%Y - %m - %d %T", &time1);
4030 ret2 = strptime(datestr,
"%Y - %m - %dT%T", &time2);
4037 "the date string.\n");
4046 return ofmt->
query_codec(codec_id, std_compliance);
4078 uint64_t channel_layout, int32_t sample_rate,
4090 if (channel_layout) {
4098 if (width || height) {
4105 bytestream_put_le32(&data, flags);
4107 bytestream_put_le32(&data, channels);
4109 bytestream_put_le64(&data, channel_layout);
4111 bytestream_put_le32(&data, sample_rate);
4112 if (width || height) {
4113 bytestream_put_le32(&data, width);
4114 bytestream_put_le32(&data, height);