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);