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))) {
517 int buf_offset = (probe_size ==
PROBE_BUF_MIN) ? 0 : probe_size>>1;
519 if (probe_size < offset) {
525 if ((ret =
avio_read(pb, buf + buf_offset, probe_size - buf_offset)) < 0) {
535 pd.
buf = &buf[offset];
543 av_log(logctx,
AV_LOG_WARNING,
"Format detected only with low score of %d, misdetection possible!\n", score);
545 av_log(logctx,
AV_LOG_DEBUG,
"Probed with size=%d and score=%d\n", probe_size, score);
561 #if FF_API_FORMAT_PARAMETERS
570 if (!ap || !ap->prealloced_context)
625 if ((ret =
init_input(s, filename, &tmp)) < 0)
691 (*plast_pktl)->next = pktl;
693 *packet_buffer = pktl;
727 if (!pktl || ret ==
AVERROR(EAGAIN))
737 "Dropped corrupted packet (stream = %d)\n",
802 if (bits_per_sample) {
805 frame_size = (size << 3) / (bits_per_sample * enc->
channels);
855 if (frame_size <= 0 || st->codec->sample_rate <= 0)
891 int64_t dts, int64_t pts)
902 for(; pktl; pktl= pktl->
next){
926 for(; pktl; pktl= pktl->
next){
938 for(; pktl; pktl= pktl->
next){
958 int num, den, presentation_delayed, delay, i;
973 presentation_delayed = 0;
979 presentation_delayed = 1;
1036 presentation_delayed = 1;
1042 if (presentation_delayed) {
1065 if(old_diff < new_diff && old_diff < (pkt->
duration>>3)){
1209 av_log(s,
AV_LOG_WARNING,
"Invalid timestamps stream=%d, pts=%"PRId64
", dts=%"PRId64
", size=%d\n",
1219 av_log(s,
AV_LOG_DEBUG,
"av_read_packet stream=%d, pts=%"PRId64
", dts=%"PRId64
", size=%d, duration=%d, flags=%d\n",
1244 av_log(s,
AV_LOG_DEBUG,
"read_frame_internal stream=%d, pts=%"PRId64
", dts=%"PRId64
", size=%d, duration=%d, flags=%d\n",
1302 if (pktl && ret !=
AVERROR(EAGAIN)) {
1344 int first_audio_index = -1;
1356 first_audio_index = i;
1358 return first_audio_index >= 0 ? first_audio_index : 0;
1396 #if FF_API_SEEK_PUBLIC
1430 int *nb_index_entries,
1431 unsigned int *index_entries_allocated_size,
1437 if((
unsigned)*nb_index_entries + 1 >= UINT_MAX /
sizeof(
AVIndexEntry))
1441 index_entries_allocated_size,
1442 (*nb_index_entries + 1) *
1447 *index_entries= entries;
1452 index= (*nb_index_entries)++;
1453 ie= &entries[
index];
1454 assert(index==0 || ie[-1].timestamp < timestamp);
1456 ie= &entries[
index];
1460 memmove(entries + index + 1, entries + index,
sizeof(
AVIndexEntry)*(*nb_index_entries - index));
1461 (*nb_index_entries)++;
1462 }
else if(ie->
pos == pos && distance < ie->min_distance)
1480 timestamp, size, distance, flags);
1484 int64_t wanted_timestamp,
int flags)
1493 if(b && entries[b-1].timestamp < wanted_timestamp)
1499 if(timestamp >= wanted_timestamp)
1501 if(timestamp <= wanted_timestamp)
1521 wanted_timestamp, flags);
1524 #if FF_API_SEEK_PUBLIC
1534 int64_t ts_min, ts_max, ts;
1539 if (stream_index < 0)
1542 av_dlog(s,
"read_seek: %d %"PRId64
"\n", stream_index, target_ts);
1553 index=
FFMAX(index, 0);
1559 av_dlog(s,
"using cached pos_min=0x%"PRIx64
" dts_min=%"PRId64
"\n",
1566 assert(index < st->nb_index_entries);
1573 av_dlog(s,
"using cached pos_max=0x%"PRIx64
" pos_limit=0x%"PRIx64
" dts_max=%"PRId64
"\n",
1574 pos_max,pos_limit, ts_max);
1578 pos=
ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->
read_timestamp);
1591 #if FF_API_SEEK_PUBLIC
1592 int64_t av_gen_search(
AVFormatContext *s,
int stream_index, int64_t target_ts,
1593 int64_t pos_min, int64_t pos_max, int64_t pos_limit,
1594 int64_t ts_min, int64_t ts_max,
int flags, int64_t *ts_ret,
1595 int64_t (*read_timestamp)(
struct AVFormatContext *,
int , int64_t *, int64_t ))
1597 return ff_gen_search(s, stream_index, target_ts, pos_min, pos_max,
1598 pos_limit, ts_min, ts_max, flags, ts_ret,
1604 int64_t pos_min, int64_t pos_max, int64_t pos_limit,
1605 int64_t ts_min, int64_t ts_max,
int flags, int64_t *ts_ret,
1606 int64_t (*read_timestamp)(
struct AVFormatContext *,
int , int64_t *, int64_t ))
1609 int64_t start_pos, filesize;
1612 av_dlog(s,
"gen_seek: %d %"PRId64
"\n", stream_index, target_ts);
1616 ts_min = read_timestamp(s, stream_index, &pos_min,
INT64_MAX);
1624 pos_max = filesize - 1;
1627 ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1634 int64_t tmp_pos= pos_max + 1;
1635 int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos,
INT64_MAX);
1640 if(tmp_pos >= filesize)
1646 if(ts_min > ts_max){
1648 }
else if(ts_min == ts_max){
1653 while (pos_min < pos_limit) {
1654 av_dlog(s,
"pos_min=0x%"PRIx64
" pos_max=0x%"PRIx64
" dts_min=%"PRId64
" dts_max=%"PRId64
"\n",
1655 pos_min, pos_max, ts_min, ts_max);
1656 assert(pos_limit <= pos_max);
1659 int64_t approximate_keyframe_distance= pos_max - pos_limit;
1661 pos =
av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1662 + pos_min - approximate_keyframe_distance;
1663 }
else if(no_change==1){
1665 pos = (pos_min + pos_limit)>>1;
1673 else if(pos > pos_limit)
1677 ts = read_timestamp(s, stream_index, &pos,
INT64_MAX);
1682 av_dlog(s,
"%"PRId64
" %"PRId64
" %"PRId64
" / %"PRId64
" %"PRId64
" %"PRId64
" target:%"PRId64
" limit:%"PRId64
" start:%"PRId64
" noc:%d\n",
1683 pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts,
1684 pos_limit, start_pos, no_change);
1690 if (target_ts <= ts) {
1691 pos_limit = start_pos - 1;
1695 if (target_ts >= ts) {
1704 ts_min = read_timestamp(s, stream_index, &pos_min,
INT64_MAX);
1706 ts_max = read_timestamp(s, stream_index, &pos_min,
INT64_MAX);
1707 av_dlog(s,
"pos=0x%"PRIx64
" %"PRId64
"<=%"PRId64
"<=%"PRId64
"\n",
1708 pos, ts_min, target_ts, ts_max);
1714 int64_t pos_min, pos_max;
1718 if (stream_index < 0)
1727 if (pos < pos_min) pos= pos_min;
1728 else if(pos > pos_max) pos= pos_max;
1733 av_update_cur_dts(s, st, ts);
1739 int stream_index, int64_t timestamp,
int flags)
1746 st = s->
streams[stream_index];
1750 if(index < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
1753 if(index < 0 || index==st->nb_index_entries-1){
1770 }
while (read_status ==
AVERROR(EAGAIN));
1771 if (read_status < 0)
1809 if(stream_index < 0){
1811 if(stream_index < 0)
1842 if(min_ts > ts || max_ts < ts)
1889 int64_t
start_time, start_time1, end_time, end_time1;
1890 int64_t
duration, duration1, filesize;
1901 start_time =
FFMIN(start_time, start_time1);
1903 end_time1 = start_time1
1905 end_time =
FFMAX(end_time, end_time1);
1910 duration =
FFMAX(duration, duration1);
1916 duration =
FFMAX(duration, end_time - start_time);
1982 #define DURATION_MAX_READ_SIZE 250000
1983 #define DURATION_MAX_RETRY 3
1990 int read_size, i, ret;
1992 int64_t filesize, offset,
duration;
2029 }
while(ret ==
AVERROR(EAGAIN));
2032 read_size += pkt->
size;
2037 duration = end_time = pkt->
pts;
2075 file_size =
FFMAX(0, file_size);
2099 av_dlog(ic,
"%d: start_time: %0.3f duration: %0.3f\n", i,
2103 av_dlog(ic,
"stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2145 int got_picture = 1, ret = 0;
2160 av_dict_set(options ? options : &thread_opt,
"threads",
"1", 0);
2168 while ((pkt.
size > 0 || (!pkt.
data && got_picture)) &&
2178 &got_picture, &pkt);
2211 if(tag == tags[i].tag)
2224 for(i=0; tags && tags[i]; i++){
2234 for(i=0; tags && tags[i]; i++){
2255 if (j != i && next_start > ch->
start && next_start < end)
2263 if(i<60*12)
return i*1001;
2264 else return ((
const int[]){24,30,60,12,15})[i-60*12]*1000*12;
2287 #if FF_API_FORMAT_PARAMETERS
2296 int i, count, ret, read_size, j;
2326 av_dict_set(options ? &options[i] : &thread_opt,
"threads",
"1", 0);
2359 int fps_analyze_framecount = 20;
2368 fps_analyze_framecount *= 2;
2418 (options && i < orig_nb_streams) ?
2419 &options[i] :
NULL);
2424 "decoding for stream %d failed\n", st->
index);
2429 "Could not find codec parameters (%s)\n", buf);
2439 goto find_stream_info_err;
2441 read_size += pkt->
size;
2464 int ticks=
lrintf(dur*framerate/(1001*12));
2465 double error = dur - (double)ticks*1001*12 / framerate;
2532 if(error < best_error){
2583 if(ppkt1->stream_index != i)
2585 if(ppkt1->pkt->dts < 0)
2600 find_stream_info_err:
2622 int wanted_stream_nb,
2629 unsigned *program =
NULL;
2632 if (related_stream >= 0 && wanted_stream_nb < 0) {
2639 for (i = 0; i < nb_streams; i++) {
2640 int real_stream_index = program ? program[i] : i;
2645 if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
2660 ret = real_stream_index;
2662 if (program && i == nb_streams - 1 && ret < 0) {
2669 *decoder_ret = best_decoder;
2693 #if FF_API_FORMAT_PARAMETERS
2746 #if FF_API_CLOSE_INPUT_FILE
2767 #if FF_API_NEW_STREAM
2783 if (s->
nb_streams >= INT_MAX/
sizeof(*streams))
2832 av_dlog(ac,
"new_program: id=0x%04x\n",
id);
2868 chapter->
start = start;
2877 #if FF_API_FORMAT_PARAMETERS
2907 unsigned int tag = 0;
2935 #if FF_API_FORMAT_PARAMETERS
3003 "Tag %s/0x%08x incompatible with output codec id '%d'\n",
3014 av_log(s,
AV_LOG_WARNING,
"Codec for stream %d does not use global headers but container format requires global headers\n", i);
3079 int num, den, frame_size, i;
3081 av_dlog(s,
"compute_pkt_fields2: pts:%"PRId64
" dts:%"PRId64
" cur_dts:%"PRId64
" b:%d size:%d st:%d\n",
3118 "Application provided invalid, non monotonically increasing dts to muxer in stream %d: %"PRId64
" >= %"PRId64
"\n",
3172 this_pktl->
pkt= *pkt;
3183 while(!compare(s, &(*next_point)->pkt, pkt)){
3184 next_point= &(*next_point)->
next;
3191 assert(!*next_point);
3196 this_pktl->
next= *next_point;
3199 *next_point= this_pktl;
3226 if(stream_count && (s->
nb_streams == stream_count || flush)){
3271 av_dlog(s,
"av_interleaved_write_frame size:%d dts:%"PRId64
" pts:%"PRId64
"\n",
3374 if(strcmp(
"language", tag->
key))
3407 display_aspect_ratio.
num, display_aspect_ratio.
den);
3443 #if FF_API_DUMP_FORMAT
3464 is_output ?
"Output" :
"Input",
3467 is_output ?
"to" :
"from", url);
3472 int hours, mins, secs, us;
3509 int j, k, total = 0;
3514 name ? name->
value :
"");
3522 if (total < ic->nb_streams)
3535 gettimeofday(&tv,
NULL);
3536 return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
3544 #if FF_API_PARSE_DATE
3547 int64_t parse_date(
const char *timestr,
int duration)
3555 #if FF_API_FIND_INFO_TAG
3558 int find_info_tag(
char *arg,
int arg_size,
const char *tag1,
const char *info)
3565 const char *path,
int number)
3568 char *q, buf1[20], c;
3569 int nd,
len, percentd_found;
3581 while (isdigit(*p)) {
3582 nd = nd * 10 + *p++ -
'0';
3585 }
while (isdigit(c));
3594 snprintf(buf1,
sizeof(buf1),
"%0*d", nd, number);
3596 if ((q - buf + len) > buf_size - 1)
3598 memcpy(q, buf1, len);
3606 if ((q - buf) < buf_size - 1)
3610 if (!percentd_found)
3623 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3625 for(i=0;i<
size;i+=16) {
3632 PRINT(
" %02x", buf[i+j]);
3637 for(j=0;j<
len;j++) {
3639 if (c < ' ' || c >
'~')
3661 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3685 void av_pkt_dump(FILE *
f,
AVPacket *pkt,
int dump_payload)
3698 void av_pkt_dump_log(
void *avcl,
int level,
AVPacket *pkt,
int dump_payload)
3712 char *authorization,
int authorization_size,
3713 char *hostname,
int hostname_size,
3715 char *path,
int path_size,
3718 const char *p, *ls, *at, *col, *brk;
3720 if (port_ptr) *port_ptr = -1;
3721 if (proto_size > 0) proto[0] = 0;
3722 if (authorization_size > 0) authorization[0] = 0;
3723 if (hostname_size > 0) hostname[0] = 0;
3724 if (path_size > 0) path[0] = 0;
3727 if ((p = strchr(url,
':'))) {
3739 ls = strchr(p,
'/');
3741 ls = strchr(p,
'?');
3750 if ((at = strchr(p,
'@')) && at < ls) {
3752 FFMIN(authorization_size, at + 1 - p));
3756 if (*p ==
'[' && (brk = strchr(p,
']')) && brk < ls) {
3759 FFMIN(hostname_size, brk - p));
3760 if (brk[1] ==
':' && port_ptr)
3761 *port_ptr = atoi(brk + 2);
3762 }
else if ((col = strchr(p,
':')) && col < ls) {
3764 FFMIN(col + 1 - p, hostname_size));
3765 if (port_ptr) *port_ptr = atoi(col + 1);
3768 FFMIN(ls + 1 - p, hostname_size));
3775 static const char hex_table_uc[16] = {
'0',
'1',
'2',
'3',
3778 'C',
'D',
'E',
'F' };
3779 static const char hex_table_lc[16] = {
'0',
'1',
'2',
'3',
3782 'c',
'd',
'e',
'f' };
3783 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3785 for(i = 0; i < s; i++) {
3786 buff[i * 2] = hex_table[src[i] >> 4];
3787 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3803 c = toupper((
unsigned char) *p++);
3804 if (c >=
'0' && c <=
'9')
3806 else if (c >=
'A' && c <=
'F')
3821 #if FF_API_SET_PTS_INFO
3822 void av_set_pts_info(
AVStream *s,
int pts_wrap_bits,
3823 unsigned int pts_num,
unsigned int pts_den)
3830 unsigned int pts_num,
unsigned int pts_den)
3834 if(new_tb.
num != pts_num)
3839 if(new_tb.
num <= 0 || new_tb.
den <= 0) {
3848 const char *authorization,
const char *hostname,
3849 int port,
const char *fmt, ...)
3858 if (authorization && authorization[0])
3860 #if CONFIG_NETWORK && defined(AF_INET6)
3863 memset(&hints, 0,
sizeof(hints));
3883 int len = strlen(str);
3886 vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);
3913 const char *ptr = str;
3918 char *dest =
NULL, *dest_end;
3919 int key_len, dest_len = 0;
3922 while (*ptr && (isspace(*ptr) || *ptr ==
','))
3929 if (!(ptr = strchr(key,
'=')))
3932 key_len = ptr - key;
3934 callback_get_buf(context, key, key_len, &dest, &dest_len);
3935 dest_end = dest + dest_len - 1;
3939 while (*ptr && *ptr !=
'\"') {
3943 if (dest && dest < dest_end)
3947 if (dest && dest < dest_end)
3955 for (; *ptr && !(isspace(*ptr) || *ptr ==
','); ptr++)
3956 if (dest && dest < dest_end)
3979 if (base && strstr(base,
"://") && rel[0] ==
'/') {
3982 sep = strstr(buf,
"://");
3985 sep = strchr(sep,
'/');
3993 if (!base || strstr(rel,
"://") || rel[0] ==
'/') {
4000 sep = strrchr(buf,
'/');
4008 sep = strrchr(buf,
'/');
4010 if (!strcmp(sep ? &sep[1] : buf,
"..")) {
4028 struct tm time1 = {0}, time2 = {0};
4030 ret1 = strptime(datestr,
"%Y - %m - %d %T", &time1);
4031 ret2 = strptime(datestr,
"%Y - %m - %dT%T", &time2);
4038 "the date string.\n");
4047 return ofmt->
query_codec(codec_id, std_compliance);
4079 uint64_t channel_layout, int32_t sample_rate,
4091 if (channel_layout) {
4099 if (width || height) {
4106 bytestream_put_le32(&data, flags);
4108 bytestream_put_le32(&data, channels);
4110 bytestream_put_le64(&data, channel_layout);
4112 bytestream_put_le32(&data, sample_rate);
4113 if (width || height) {
4114 bytestream_put_le32(&data, width);
4115 bytestream_put_le32(&data, height);