64 return FFMPEG_CONFIGURATION;
69 #define LICENSE_PREFIX "libavformat license: "
73 #define RELATIVE_TS_BASE (INT64_MAX - (1LL<<48))
91 timestamp < st->pts_wrap_reference)
103 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, subtitle_codec)
107 if (st->codec->codec)
108 return st->codec->codec;
110 switch(st->codec->codec_type){
112 if(s->video_codec)
return s->video_codec;
115 if(s->audio_codec)
return s->audio_codec;
118 if(s->subtitle_codec)
return s->subtitle_codec;
131 #define SANE_CHUNK_SIZE (50000000)
137 if(remaining < size){
140 s->
maxsize= newsize - !newsize;
142 remaining=
FFMAX(remaining, 0);
145 if(s->
maxsize>=0 && remaining+1 < size){
159 int64_t orig_pos = pkt->
pos;
160 int orig_size = pkt->
size;
164 int prev_size = pkt->
size;
184 if (ret != read_size) {
197 return pkt->
size > orig_size ? pkt->
size - orig_size :
ret;
228 int score, nodat = 0, score_max=0;
232 lpd.
buf = zerobuffer;
257 if (score > score_max) {
260 }
else if (score == score_max)
265 *score_ret= score_max;
274 if(score_ret > *score_max){
275 *score_max= score_ret;
288 static const struct {
309 for (i = 0; fmt_id_type[i].name; i++) {
310 if (!strcmp(fmt->
name, fmt_id_type[i].name)) {
340 const char *filename,
void *logctx,
341 unsigned int offset,
unsigned int max_probe_size)
343 AVProbeData pd = { filename ? filename :
"", NULL, -offset };
344 unsigned char *
buf = NULL;
346 int ret = 0, probe_size, buf_offset = 0;
349 if (!max_probe_size) {
355 "Specified probe size value %u cannot be < %u\n", max_probe_size,
PROBE_BUF_MIN);
359 if (offset >= max_probe_size) {
371 probe_size =
FFMIN(probe_size<<1,
FFMAX(max_probe_size, probe_size+1))) {
378 if ((ret =
avio_read(pb, buf + buf_offset, probe_size - buf_offset)) < 0) {
388 if (buf_offset < offset)
399 av_log(logctx,
AV_LOG_WARNING,
"Format %s detected only with low score of %d, misdetection possible!\n", (*fmt)->name, score);
401 av_log(logctx,
AV_LOG_DEBUG,
"Format %s probed with size=%d and score=%d\n", (*fmt)->name, probe_size, score);
413 return ret < 0 ? ret : score;
417 const char *filename,
void *logctx,
418 unsigned int offset,
unsigned int max_probe_size)
421 return ret < 0 ? ret : 0;
438 "will be ignored with AVFMT_NOFILE format.\n");
461 (*plast_pktl)->next = pktl;
463 *packet_buffer = pktl;
497 av_log(NULL,
AV_LOG_ERROR,
"Input context has not been properly allocated by avformat_alloc_context() and is not NULL either\n");
509 if ((ret =
init_input(s, filename, &tmp)) < 0)
547 if (id3v2_extra_meta) {
611 "Failed to reallocate probe buffer for stream %d\n",
677 if (!pktl || ret ==
AVERROR(EAGAIN))
693 "Dropped corrupted packet (stream = %d)\n",
728 #if FF_API_READ_PACKET
814 if (frame_size <= 0 || st->codec->sample_rate <= 0)
845 #if CONFIG_H264_DECODER
882 if (!first_program) {
907 program = first_program;
962 pts_buffer[0]= pktl->
pkt.
pts;
963 for(i=0; i<delay && pts_buffer[i] > pts_buffer[i+1]; i++)
964 FFSWAP(int64_t, pts_buffer[i], pts_buffer[i+1]);
966 pktl->
pkt.
dts= pts_buffer[0];
999 av_log(s,
AV_LOG_DEBUG,
"first_dts %s not matching first dts %s (pts %s, duration %d) in the queue\n",
1033 int num, den, presentation_delayed, delay, i;
1049 presentation_delayed = 0;
1055 presentation_delayed = 1;
1071 if(strcmp(s->
iformat->
name,
"mov,mp4,m4a,3gp,3g2,mj2"))
1118 presentation_delayed = 1;
1120 av_dlog(NULL,
"IN delayed:%d pts:%s, dts:%s cur_dts:%s st:%d pc:%p duration:%d\n",
1125 if (presentation_delayed) {
1175 av_dlog(NULL,
"OUTdelayed:%d/%d pts:%s, dts:%s cur_dts:%s\n",
1189 *pkt_buf = pktl->
next;
1193 *pkt_buf_end = NULL;
1207 int ret = 0, got_output = 0;
1218 while (size > 0 || (pkt == &
flush_pkt && got_output)) {
1223 &out_pkt.
data, &out_pkt.
size, data, size,
1232 got_output = !!out_pkt.
size;
1282 #if FF_API_DESTRUCT_PACKET
1284 out_pkt.destruct = pkt->destruct;
1285 pkt->destruct = NULL;
1319 *pkt_buffer = pktl->
next;
1321 *pkt_buffer_end = NULL;
1328 int ret = 0, i, got_packet = 0;
1356 cur_pkt.
pts < cur_pkt.
dts) {
1364 av_log(s,
AV_LOG_DEBUG,
"ff_read_packet stream=%d, pts=%s, dts=%s, size=%d, duration=%d, flags=%d\n",
1376 "%s, packets or times may be invalid.\n",
1421 av_log(s,
AV_LOG_DEBUG,
"read_frame_internal stream=%d, pts=%s, dts=%s, size=%d, duration=%d, flags=%d\n",
1458 int64_t last_dts = next_pkt->
dts;
1467 last_dts = pktl->
pkt.
dts;
1494 if (pktl && ret !=
AVERROR(EAGAIN)) {
1546 int first_audio_index = -1;
1559 first_audio_index = i;
1561 return first_audio_index >= 0 ? first_audio_index : 0;
1621 int *nb_index_entries,
1622 unsigned int *index_entries_allocated_size,
1628 if((
unsigned)*nb_index_entries + 1 >= UINT_MAX /
sizeof(
AVIndexEntry))
1634 if (size < 0 || size > 0x3FFFFFFF)
1641 index_entries_allocated_size,
1642 (*nb_index_entries + 1) *
1647 *index_entries= entries;
1652 index= (*nb_index_entries)++;
1653 ie= &entries[
index];
1654 av_assert0(index==0 || ie[-1].timestamp < timestamp);
1656 ie= &entries[
index];
1660 memmove(entries + index + 1, entries + index,
sizeof(
AVIndexEntry)*(*nb_index_entries - index));
1661 (*nb_index_entries)++;
1662 }
else if(ie->
pos == pos && distance < ie->min_distance)
1681 timestamp, size, distance, flags);
1685 int64_t wanted_timestamp,
int flags)
1694 if(b && entries[b-1].timestamp < wanted_timestamp)
1700 if(timestamp >= wanted_timestamp)
1702 if(timestamp <= wanted_timestamp)
1722 wanted_timestamp, flags);
1726 int64_t (*read_timestamp)(
struct AVFormatContext *,
int , int64_t *, int64_t ))
1728 int64_t ts = read_timestamp(s, stream_index, ppos, pos_limit);
1729 if (stream_index >= 0)
1738 int64_t ts_min, ts_max, ts;
1743 if (stream_index < 0)
1757 index=
FFMAX(index, 0);
1763 av_dlog(s,
"using cached pos_min=0x%"PRIx64
" dts_min=%s\n",
1777 av_dlog(s,
"using cached pos_max=0x%"PRIx64
" pos_limit=0x%"PRIx64
" dts_max=%s\n",
1782 pos=
ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->
read_timestamp);
1797 int64_t (*read_timestamp)(
struct AVFormatContext *,
int , int64_t *, int64_t ))
1800 int64_t limit, ts_max;
1802 int64_t pos_max = filesize - 1;
1805 pos_max =
FFMAX(0, (pos_max) - step);
1813 int64_t tmp_pos = pos_max + 1;
1814 int64_t tmp_ts =
ff_read_timestamp(s, stream_index, &tmp_pos, INT64_MAX, read_timestamp);
1820 if(tmp_pos >= filesize)
1833 int64_t pos_min, int64_t pos_max, int64_t pos_limit,
1834 int64_t ts_min, int64_t ts_max,
int flags, int64_t *ts_ret,
1835 int64_t (*read_timestamp)(
struct AVFormatContext *,
int , int64_t *, int64_t ))
1846 ts_min =
ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1851 if(ts_min >= target_ts){
1857 if ((ret =
ff_find_last_ts(s, stream_index, &ts_max, &pos_max, read_timestamp)) < 0)
1862 if(ts_max <= target_ts){
1867 if(ts_min > ts_max){
1869 }
else if(ts_min == ts_max){
1874 while (pos_min < pos_limit) {
1875 av_dlog(s,
"pos_min=0x%"PRIx64
" pos_max=0x%"PRIx64
" dts_min=%s dts_max=%s\n",
1877 assert(pos_limit <= pos_max);
1880 int64_t approximate_keyframe_distance= pos_max - pos_limit;
1882 pos =
av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1883 + pos_min - approximate_keyframe_distance;
1884 }
else if(no_change==1){
1886 pos = (pos_min + pos_limit)>>1;
1894 else if(pos > pos_limit)
1903 av_dlog(s,
"%"PRId64
" %"PRId64
" %"PRId64
" / %s %s %s target:%s limit:%"PRId64
" start:%"PRId64
" noc:%d\n",
1904 pos_min, pos, pos_max,
1906 pos_limit, start_pos, no_change);
1912 if (target_ts <= ts) {
1913 pos_limit = start_pos - 1;
1917 if (target_ts >= ts) {
1927 ts_min =
ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1929 ts_max =
ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1930 av_dlog(s,
"pos=0x%"PRIx64
" %s<=%s<=%s\n",
1938 int64_t pos_min, pos_max;
1943 if (pos < pos_min) pos= pos_min;
1944 else if(pos > pos_max) pos= pos_max;
1954 int stream_index, int64_t timestamp,
int flags)
1961 st = s->
streams[stream_index];
1965 if(index < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
1968 if(index < 0 || index==st->nb_index_entries-1){
1986 }
while (read_status ==
AVERROR(EAGAIN));
1987 if (read_status < 0)
1994 av_log(s,
AV_LOG_ERROR,
"seek_frame_generic failed as this stream seems to contain no keyframes after the target timestamp, %d non keyframes found\n", nonkey);
2018 int64_t timestamp,
int flags)
2030 if(stream_index < 0){
2032 if(stream_index < 0)
2066 int64_t min_ts = INT64_MIN, max_ts = INT64_MAX;
2072 flags & ~AVSEEK_FLAG_BACKWARD);
2085 if(min_ts > ts || max_ts < ts)
2087 if (stream_index < -1 || stream_index >= (
int)s->
nb_streams)
2098 if (stream_index == -1 && s->
nb_streams == 1) {
2105 time_base.
num * (int64_t)AV_TIME_BASE,
2125 if (ret<0 && ts != min_ts && max_ts != ts) {
2126 ret =
av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
2166 int64_t
start_time, start_time1, start_time_text, end_time, end_time1;
2167 int64_t
duration, duration1, filesize;
2172 start_time = INT64_MAX;
2173 start_time_text = INT64_MAX;
2174 end_time = INT64_MIN;
2175 duration = INT64_MIN;
2181 if (start_time1 < start_time_text)
2182 start_time_text = start_time1;
2184 start_time =
FFMIN(start_time, start_time1);
2187 end_time1 = start_time1
2189 end_time =
FFMAX(end_time, end_time1);
2200 duration =
FFMAX(duration, duration1);
2203 if (start_time == INT64_MAX || (start_time > start_time_text && start_time - start_time_text <
AV_TIME_BASE))
2204 start_time = start_time_text;
2205 else if(start_time > start_time_text)
2208 if (start_time != INT64_MAX) {
2210 if (end_time != INT64_MIN) {
2218 duration =
FFMAX(duration, end_time - start_time);
2226 double bitrate = (double)filesize * 8.0 * AV_TIME_BASE /
2228 if (bitrate >= 0 && bitrate <= INT_MAX)
2253 int i, show_warning = 0;
2292 #define DURATION_MAX_READ_SIZE 250000LL
2293 #define DURATION_MAX_RETRY 4
2300 int read_size, i,
ret;
2336 }
while(ret ==
AVERROR(EAGAIN));
2339 read_size += pkt->
size;
2344 duration = end_time = pkt->
pts;
2382 file_size =
FFMAX(0, file_size);
2408 av_dlog(ic,
"%d: start_time: %0.3f duration: %0.3f\n", i,
2412 av_dlog(ic,
"stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2423 #define FAIL(errmsg) do { \
2425 *errmsg_ptr = errmsg; \
2432 FAIL(
"unspecified frame size");
2434 FAIL(
"unspecified sample format");
2436 FAIL(
"unspecified sample rate");
2438 FAIL(
"unspecified number of channels");
2440 FAIL(
"no decodable DTS frames");
2444 FAIL(
"unspecified size");
2446 FAIL(
"unspecified pixel format");
2449 FAIL(
"no frame in rv30/40 and no sar");
2453 FAIL(
"unspecified size");
2460 FAIL(
"unknown codec");
2468 int got_picture = 1,
ret = 0;
2489 av_dict_set(options ? options : &thread_opt,
"threads",
"1", 0);
2506 while ((pkt.
size > 0 || (!pkt.
data && got_picture)) &&
2516 &got_picture, &pkt);
2523 &got_picture, &pkt);
2538 if(!pkt.
data && !got_picture)
2560 if(tag == tags[i].tag)
2581 if (sflags & (1 << (bps - 1))) {
2613 for(i=0; tags && tags[i]; i++){
2616 if (codec_tags->
id ==
id) {
2617 *tag = codec_tags->
tag;
2629 for(i=0; tags && tags[i]; i++){
2650 if (j != i && next_start > ch->
start && next_start < end)
2653 ch->
end = (end == INT64_MAX) ? ch->
start : end;
2658 if(i<60*12)
return (i+1)*1001;
2659 else return ((
const int[]){24,30,60,12,15,48})[i-60*12]*1000*12;
2683 #if FF_API_FORMAT_PARAMETERS
2746 "%s, packets or times may be invalid.\n",
2754 av_dict_set(options ? &options[i] : &thread_opt,
"threads",
"1", 0);
2773 #if FF_API_R_FRAME_RATE
2791 int fps_analyze_framecount = 20;
2800 fps_analyze_framecount *= 2;
2804 fps_analyze_framecount = 0;
2838 "Stream #%d: not enough frames to estimate rate; "
2839 "consider increasing probesize\n", i);
2861 goto find_stream_info_err;
2864 goto find_stream_info_err;
2869 read_size += pkt->
size;
2876 "packet %d with DTS %"PRId64
", packet %d with DTS "
2889 "packet %d with DTS %"PRId64
", packet %d with DTS "
2925 #if FF_API_R_FRAME_RATE
2930 && pkt->
dts - (uint64_t)last < INT64_MAX){
2943 double sdts= dts*framerate/(1001*12);
2945 int64_t ticks=
llrint(sdts+j*0.5);
2946 double error= sdts - ticks + j*0.5;
2978 try_decode_frame(ic, st, pkt, (options && i < orig_nb_streams ) ? &options[i] : NULL);
2997 (options && i < orig_nb_streams) ?
2998 &options[i] : NULL);
3003 "decoding for stream %d failed\n", st->
index);
3026 double best_error = 0.01;
3042 if (error < best_error) {
3044 best_fps = std_fps.
num;
3049 best_fps, 12*1001, INT_MAX);
3060 double best_error= 0.01;
3074 if(error < best_error && best_error> 0.000000001){
3128 "Could not find codec parameters for stream %d (%s): %s\n"
3129 "Consider increasing the value for the 'analyzeduration' and 'probesize' options\n",
3138 find_stream_info_err:
3171 int wanted_stream_nb,
3178 unsigned *program = NULL;
3181 if (related_stream >= 0 && wanted_stream_nb < 0) {
3188 for (i = 0; i < nb_streams; i++) {
3189 int real_stream_index = program ? program[i] : i;
3194 if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
3209 if ((best_multiframe > multiframe) ||
3210 (best_multiframe == multiframe && best_bitrate > bitrate) ||
3211 (best_multiframe == multiframe && best_bitrate == bitrate && best_count >=
count))
3214 best_bitrate = bitrate;
3215 best_multiframe = multiframe;
3216 ret = real_stream_index;
3218 if (program && i == nb_streams - 1 && ret < 0) {
3225 *decoder_ret = best_decoder;
3302 #if FF_API_CLOSE_INPUT_FILE
3338 #if FF_API_NEW_STREAM
3354 if (s->
nb_streams >= INT_MAX/
sizeof(*streams))
3397 #if FF_API_R_FRAME_RATE
3412 av_dlog(ac,
"new_program: id=0x%04x\n",
id);
3501 if(strcmp(
"language", tag->
key)){
3502 const char *p = tag->
value;
3506 size_t len = strcspn(p,
"\x8\xa\xb\xc\xd");
3547 display_aspect_ratio.
num, display_aspect_ratio.
den);
3552 #if FF_API_R_FRAME_RATE
3596 is_output ?
"Output" :
"Input",
3599 is_output ?
"to" :
"from", url);
3604 int hours, mins, secs, us;
3642 int j, k, total = 0;
3647 name ? name->
value :
"");
3655 if (total < ic->nb_streams)
3671 const char *path,
int number)
3674 char *q, buf1[20],
c;
3675 int nd,
len, percentd_found;
3688 nd = nd * 10 + *p++ -
'0';
3700 snprintf(buf1,
sizeof(buf1),
"%0*d", nd, number);
3702 if ((q - buf + len) > buf_size - 1)
3704 memcpy(q, buf1, len);
3712 if ((q - buf) < buf_size - 1)
3716 if (!percentd_found)
3729 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3731 for(i=0;i<
size;i+=16) {
3738 PRINT(
" %02x", buf[i+j]);
3743 for(j=0;j<
len;j++) {
3745 if (c < ' ' || c >
'~')
3766 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3801 char *authorization,
int authorization_size,
3802 char *hostname,
int hostname_size,
3804 char *path,
int path_size,
3807 const char *p, *ls, *ls2, *at, *at2, *col, *brk;
3809 if (port_ptr) *port_ptr = -1;
3810 if (proto_size > 0) proto[0] = 0;
3811 if (authorization_size > 0) authorization[0] = 0;
3812 if (hostname_size > 0) hostname[0] = 0;
3813 if (path_size > 0) path[0] = 0;
3816 if ((p = strchr(url,
':'))) {
3828 ls = strchr(p,
'/');
3829 ls2 = strchr(p,
'?');
3833 ls =
FFMIN(ls, ls2);
3843 while ((at = strchr(p,
'@')) && at < ls) {
3845 FFMIN(authorization_size, at + 1 - at2));
3849 if (*p ==
'[' && (brk = strchr(p,
']')) && brk < ls) {
3852 FFMIN(hostname_size, brk - p));
3853 if (brk[1] ==
':' && port_ptr)
3854 *port_ptr = atoi(brk + 2);
3855 }
else if ((col = strchr(p,
':')) && col < ls) {
3857 FFMIN(col + 1 - p, hostname_size));
3858 if (port_ptr) *port_ptr = atoi(col + 1);
3861 FFMIN(ls + 1 - p, hostname_size));
3868 static const char hex_table_uc[16] = {
'0',
'1',
'2',
'3',
3871 'C',
'D',
'E',
'F' };
3872 static const char hex_table_lc[16] = {
'0',
'1',
'2',
'3',
3875 'c',
'd',
'e',
'f' };
3876 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3878 for(i = 0; i <
s; i++) {
3879 buff[i * 2] = hex_table[src[i] >> 4];
3880 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3897 if (c >=
'0' && c <=
'9')
3899 else if (c >=
'A' && c <=
'F')
3914 #if FF_API_SET_PTS_INFO
3915 void av_set_pts_info(
AVStream *s,
int pts_wrap_bits,
3916 unsigned int pts_num,
unsigned int pts_den)
3923 unsigned int pts_num,
unsigned int pts_den)
3927 if(new_tb.
num != pts_num)
3932 if(new_tb.
num <= 0 || new_tb.
den <= 0) {
3944 const char *ptr = str;
3949 char *dest = NULL, *dest_end;
3950 int key_len, dest_len = 0;
3953 while (*ptr && (
av_isspace(*ptr) || *ptr ==
','))
3960 if (!(ptr = strchr(key,
'=')))
3963 key_len = ptr - key;
3965 callback_get_buf(context, key, key_len, &dest, &dest_len);
3966 dest_end = dest + dest_len - 1;
3970 while (*ptr && *ptr !=
'\"') {
3974 if (dest && dest < dest_end)
3978 if (dest && dest < dest_end)
3986 for (; *ptr && !(
av_isspace(*ptr) || *ptr ==
','); ptr++)
3987 if (dest && dest < dest_end)
4007 struct tm time1 = {0}, time2 = {0};
4021 return ofmt->
query_codec(codec_id, std_compliance);
4065 if (channel_layout) {
4073 if (width || height) {
4080 bytestream_put_le32(&data, flags);
4082 bytestream_put_le32(&data, channels);
4084 bytestream_put_le64(&data, channel_layout);
4086 bytestream_put_le32(&data, sample_rate);
4087 if (width || height) {
4088 bytestream_put_le32(&data, width);
4089 bytestream_put_le32(&data, height);