2 * various utility functions for use within FFmpeg
3 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
29 #include "libavutil/avassert.h"
30 #include "libavutil/avstring.h"
31 #include "libavutil/dict.h"
32 #include "libavutil/internal.h"
33 #include "libavutil/mathematics.h"
34 #include "libavutil/opt.h"
35 #include "libavutil/parseutils.h"
36 #include "libavutil/pixdesc.h"
37 #include "libavutil/time.h"
38 #include "libavutil/timestamp.h"
40 #include "libavcodec/bytestream.h"
41 #include "libavcodec/internal.h"
42 #include "libavcodec/raw.h"
44 #include "audiointerleave.h"
46 #include "avio_internal.h"
58 * various utility functions for use within FFmpeg
61 unsigned avformat_version(void)
63 av_assert0(LIBAVFORMAT_VERSION_MICRO
>= 100);
64 return LIBAVFORMAT_VERSION_INT
;
67 const char *avformat_configuration(void)
69 return FFMPEG_CONFIGURATION
;
72 const char *avformat_license(void)
74 #define LICENSE_PREFIX "libavformat license: "
75 return LICENSE_PREFIX FFMPEG_LICENSE
+ sizeof(LICENSE_PREFIX
) - 1;
78 #define RELATIVE_TS_BASE (INT64_MAX - (1LL<<48))
80 static int is_relative(int64_t ts
) {
81 return ts
> (RELATIVE_TS_BASE
- (1LL<<48));
85 * Wrap a given time stamp, if there is an indication for an overflow
88 * @param timestamp the time stamp to wrap
89 * @return resulting time stamp
91 static int64_t wrap_timestamp(AVStream
*st
, int64_t timestamp
)
93 if (st
->pts_wrap_behavior
!= AV_PTS_WRAP_IGNORE
&&
94 st
->pts_wrap_reference
!= AV_NOPTS_VALUE
&& timestamp
!= AV_NOPTS_VALUE
) {
95 if (st
->pts_wrap_behavior
== AV_PTS_WRAP_ADD_OFFSET
&&
96 timestamp
< st
->pts_wrap_reference
)
97 return timestamp
+ (1ULL << st
->pts_wrap_bits
);
98 else if (st
->pts_wrap_behavior
== AV_PTS_WRAP_SUB_OFFSET
&&
99 timestamp
>= st
->pts_wrap_reference
)
100 return timestamp
- (1ULL << st
->pts_wrap_bits
);
105 MAKE_ACCESSORS(AVStream
, stream
, AVRational
, r_frame_rate
)
106 MAKE_ACCESSORS(AVStream
, stream
, char *, recommended_encoder_configuration
)
107 MAKE_ACCESSORS(AVFormatContext
, format
, AVCodec
*, video_codec
)
108 MAKE_ACCESSORS(AVFormatContext
, format
, AVCodec
*, audio_codec
)
109 MAKE_ACCESSORS(AVFormatContext
, format
, AVCodec
*, subtitle_codec
)
110 MAKE_ACCESSORS(AVFormatContext
, format
, int, metadata_header_padding
)
111 MAKE_ACCESSORS(AVFormatContext
, format
, void *, opaque
)
112 MAKE_ACCESSORS(AVFormatContext
, format
, av_format_control_message
, control_message_cb
)
114 int64_t av_stream_get_end_pts(const AVStream
*st
)
119 struct AVCodecParserContext
*av_stream_get_parser(const AVStream
*st
)
124 void av_format_inject_global_side_data(AVFormatContext
*s
)
127 s
->internal
->inject_global_side_data
= 1;
128 for (i
= 0; i
< s
->nb_streams
; i
++) {
129 AVStream
*st
= s
->streams
[i
];
130 st
->inject_global_side_data
= 1;
134 int ff_copy_whitelists(AVFormatContext
*dst
, AVFormatContext
*src
)
136 av_assert0(!dst
->codec_whitelist
&& !dst
->format_whitelist
);
137 dst
-> codec_whitelist
= av_strdup(src
->codec_whitelist
);
138 dst
->format_whitelist
= av_strdup(src
->format_whitelist
);
139 if ( (src
-> codec_whitelist
&& !dst
-> codec_whitelist
)
140 || (src
->format_whitelist
&& !dst
->format_whitelist
)) {
141 av_log(dst
, AV_LOG_ERROR
, "Failed to duplicate whitelist\n");
142 return AVERROR(ENOMEM
);
147 static const AVCodec
*find_decoder(AVFormatContext
*s
, AVStream
*st
, enum AVCodecID codec_id
)
149 if (st
->codec
->codec
)
150 return st
->codec
->codec
;
152 switch (st
->codec
->codec_type
) {
153 case AVMEDIA_TYPE_VIDEO
:
154 if (s
->video_codec
) return s
->video_codec
;
156 case AVMEDIA_TYPE_AUDIO
:
157 if (s
->audio_codec
) return s
->audio_codec
;
159 case AVMEDIA_TYPE_SUBTITLE
:
160 if (s
->subtitle_codec
) return s
->subtitle_codec
;
164 return avcodec_find_decoder(codec_id
);
167 int av_format_get_probe_score(const AVFormatContext
*s
)
169 return s
->probe_score
;
172 /* an arbitrarily chosen "sane" max packet size -- 50M */
173 #define SANE_CHUNK_SIZE (50000000)
175 int ffio_limit(AVIOContext
*s
, int size
)
177 if (s
->maxsize
>= 0) {
178 int64_t remaining
= s
->maxsize
- avio_tell(s
);
179 if (remaining
< size
) {
180 int64_t newsize
= avio_size(s
);
181 if (!s
->maxsize
|| s
->maxsize
<newsize
)
182 s
->maxsize
= newsize
- !newsize
;
183 remaining
= s
->maxsize
- avio_tell(s
);
184 remaining
= FFMAX(remaining
, 0);
187 if (s
->maxsize
>= 0 && remaining
+1 < size
) {
188 av_log(NULL
, remaining
? AV_LOG_ERROR
: AV_LOG_DEBUG
, "Truncating packet of size %d to %"PRId64
"\n", size
, remaining
+1);
195 /* Read the data in sane-sized chunks and append to pkt.
196 * Return the number of bytes read or an error. */
197 static int append_packet_chunked(AVIOContext
*s
, AVPacket
*pkt
, int size
)
199 int64_t orig_pos
= pkt
->pos
; // av_grow_packet might reset pos
200 int orig_size
= pkt
->size
;
204 int prev_size
= pkt
->size
;
207 /* When the caller requests a lot of data, limit it to the amount
208 * left in file or SANE_CHUNK_SIZE when it is not known. */
210 if (read_size
> SANE_CHUNK_SIZE
/10) {
211 read_size
= ffio_limit(s
, read_size
);
212 // If filesize/maxsize is unknown, limit to SANE_CHUNK_SIZE
214 read_size
= FFMIN(read_size
, SANE_CHUNK_SIZE
);
217 ret
= av_grow_packet(pkt
, read_size
);
221 ret
= avio_read(s
, pkt
->data
+ prev_size
, read_size
);
222 if (ret
!= read_size
) {
223 av_shrink_packet(pkt
, prev_size
+ FFMAX(ret
, 0));
230 pkt
->flags
|= AV_PKT_FLAG_CORRUPT
;
235 return pkt
->size
> orig_size
? pkt
->size
- orig_size
: ret
;
238 int av_get_packet(AVIOContext
*s
, AVPacket
*pkt
, int size
)
243 pkt
->pos
= avio_tell(s
);
245 return append_packet_chunked(s
, pkt
, size
);
248 int av_append_packet(AVIOContext
*s
, AVPacket
*pkt
, int size
)
251 return av_get_packet(s
, pkt
, size
);
252 return append_packet_chunked(s
, pkt
, size
);
255 int av_filename_number_test(const char *filename
)
259 (av_get_frame_filename(buf
, sizeof(buf
), filename
, 1) >= 0);
262 static int set_codec_from_probe_data(AVFormatContext
*s
, AVStream
*st
,
265 static const struct {
268 enum AVMediaType type
;
270 { "aac", AV_CODEC_ID_AAC
, AVMEDIA_TYPE_AUDIO
},
271 { "ac3", AV_CODEC_ID_AC3
, AVMEDIA_TYPE_AUDIO
},
272 { "dts", AV_CODEC_ID_DTS
, AVMEDIA_TYPE_AUDIO
},
273 { "eac3", AV_CODEC_ID_EAC3
, AVMEDIA_TYPE_AUDIO
},
274 { "h264", AV_CODEC_ID_H264
, AVMEDIA_TYPE_VIDEO
},
275 { "hevc", AV_CODEC_ID_HEVC
, AVMEDIA_TYPE_VIDEO
},
276 { "loas", AV_CODEC_ID_AAC_LATM
, AVMEDIA_TYPE_AUDIO
},
277 { "m4v", AV_CODEC_ID_MPEG4
, AVMEDIA_TYPE_VIDEO
},
278 { "mp3", AV_CODEC_ID_MP3
, AVMEDIA_TYPE_AUDIO
},
279 { "mpegvideo", AV_CODEC_ID_MPEG2VIDEO
, AVMEDIA_TYPE_VIDEO
},
283 AVInputFormat
*fmt
= av_probe_input_format3(pd
, 1, &score
);
285 if (fmt
&& st
->request_probe
<= score
) {
287 av_log(s
, AV_LOG_DEBUG
,
288 "Probe with size=%d, packets=%d detected %s with score=%d\n",
289 pd
->buf_size
, MAX_PROBE_PACKETS
- st
->probe_packets
,
291 for (i
= 0; fmt_id_type
[i
].name
; i
++) {
292 if (!strcmp(fmt
->name
, fmt_id_type
[i
].name
)) {
293 st
->codec
->codec_id
= fmt_id_type
[i
].id
;
294 st
->codec
->codec_type
= fmt_id_type
[i
].type
;
302 /************************************************************/
303 /* input media file */
305 int av_demuxer_open(AVFormatContext
*ic
) {
308 if (ic
->format_whitelist
&& av_match_list(ic
->iformat
->name
, ic
->format_whitelist
, ',') <= 0) {
309 av_log(ic
, AV_LOG_ERROR
, "Format not on whitelist\n");
310 return AVERROR(EINVAL
);
313 if (ic
->iformat
->read_header
) {
314 err
= ic
->iformat
->read_header(ic
);
319 if (ic
->pb
&& !ic
->data_offset
)
320 ic
->data_offset
= avio_tell(ic
->pb
);
325 /* Open input file and probe the format if necessary. */
326 static int init_input(AVFormatContext
*s
, const char *filename
,
327 AVDictionary
**options
)
330 AVProbeData pd
= { filename
, NULL
, 0 };
331 int score
= AVPROBE_SCORE_RETRY
;
334 s
->flags
|= AVFMT_FLAG_CUSTOM_IO
;
336 return av_probe_input_buffer2(s
->pb
, &s
->iformat
, filename
,
337 s
, 0, s
->format_probesize
);
338 else if (s
->iformat
->flags
& AVFMT_NOFILE
)
339 av_log(s
, AV_LOG_WARNING
, "Custom AVIOContext makes no sense and "
340 "will be ignored with AVFMT_NOFILE format.\n");
344 if ((s
->iformat
&& s
->iformat
->flags
& AVFMT_NOFILE
) ||
345 (!s
->iformat
&& (s
->iformat
= av_probe_input_format2(&pd
, 0, &score
))))
348 if ((ret
= avio_open2(&s
->pb
, filename
, AVIO_FLAG_READ
| s
->avio_flags
,
349 &s
->interrupt_callback
, options
)) < 0)
353 return av_probe_input_buffer2(s
->pb
, &s
->iformat
, filename
,
354 s
, 0, s
->format_probesize
);
357 static AVPacket
*add_to_pktbuf(AVPacketList
**packet_buffer
, AVPacket
*pkt
,
358 AVPacketList
**plast_pktl
)
360 AVPacketList
*pktl
= av_mallocz(sizeof(AVPacketList
));
365 (*plast_pktl
)->next
= pktl
;
367 *packet_buffer
= pktl
;
369 /* Add the packet in the buffered packet list. */
375 int avformat_queue_attached_pictures(AVFormatContext
*s
)
378 for (i
= 0; i
< s
->nb_streams
; i
++)
379 if (s
->streams
[i
]->disposition
& AV_DISPOSITION_ATTACHED_PIC
&&
380 s
->streams
[i
]->discard
< AVDISCARD_ALL
) {
381 AVPacket copy
= s
->streams
[i
]->attached_pic
;
382 if (copy
.size
<= 0) {
383 av_log(s
, AV_LOG_WARNING
,
384 "Attached picture on stream %d has invalid size, "
388 copy
.buf
= av_buffer_ref(copy
.buf
);
390 return AVERROR(ENOMEM
);
392 add_to_pktbuf(&s
->raw_packet_buffer
, ©
,
393 &s
->raw_packet_buffer_end
);
398 int avformat_open_input(AVFormatContext
**ps
, const char *filename
,
399 AVInputFormat
*fmt
, AVDictionary
**options
)
401 AVFormatContext
*s
= *ps
;
403 AVDictionary
*tmp
= NULL
;
404 ID3v2ExtraMeta
*id3v2_extra_meta
= NULL
;
406 if (!s
&& !(s
= avformat_alloc_context()))
407 return AVERROR(ENOMEM
);
409 av_log(NULL
, AV_LOG_ERROR
, "Input context has not been properly allocated by avformat_alloc_context() and is not NULL either\n");
410 return AVERROR(EINVAL
);
416 av_dict_copy(&tmp
, *options
, 0);
418 if ((ret
= av_opt_set_dict(s
, &tmp
)) < 0)
421 if ((ret
= init_input(s
, filename
, &tmp
)) < 0)
423 s
->probe_score
= ret
;
425 if (s
->format_whitelist
&& av_match_list(s
->iformat
->name
, s
->format_whitelist
, ',') <= 0) {
426 av_log(s
, AV_LOG_ERROR
, "Format not on whitelist\n");
427 ret
= AVERROR(EINVAL
);
431 avio_skip(s
->pb
, s
->skip_initial_bytes
);
433 /* Check filename in case an image number is expected. */
434 if (s
->iformat
->flags
& AVFMT_NEEDNUMBER
) {
435 if (!av_filename_number_test(filename
)) {
436 ret
= AVERROR(EINVAL
);
441 s
->duration
= s
->start_time
= AV_NOPTS_VALUE
;
442 av_strlcpy(s
->filename
, filename
? filename
: "", sizeof(s
->filename
));
444 /* Allocate private data. */
445 if (s
->iformat
->priv_data_size
> 0) {
446 if (!(s
->priv_data
= av_mallocz(s
->iformat
->priv_data_size
))) {
447 ret
= AVERROR(ENOMEM
);
450 if (s
->iformat
->priv_class
) {
451 *(const AVClass
**) s
->priv_data
= s
->iformat
->priv_class
;
452 av_opt_set_defaults(s
->priv_data
);
453 if ((ret
= av_opt_set_dict(s
->priv_data
, &tmp
)) < 0)
458 /* e.g. AVFMT_NOFILE formats will not have a AVIOContext */
460 ff_id3v2_read(s
, ID3v2_DEFAULT_MAGIC
, &id3v2_extra_meta
, 0);
462 if (!(s
->flags
&AVFMT_FLAG_PRIV_OPT
) && s
->iformat
->read_header
)
463 if ((ret
= s
->iformat
->read_header(s
)) < 0)
466 if (id3v2_extra_meta
) {
467 if (!strcmp(s
->iformat
->name
, "mp3") || !strcmp(s
->iformat
->name
, "aac") ||
468 !strcmp(s
->iformat
->name
, "tta")) {
469 if ((ret
= ff_id3v2_parse_apic(s
, &id3v2_extra_meta
)) < 0)
472 av_log(s
, AV_LOG_DEBUG
, "demuxer does not support additional id3 data, skipping\n");
474 ff_id3v2_free_extra_meta(&id3v2_extra_meta
);
476 if ((ret
= avformat_queue_attached_pictures(s
)) < 0)
479 if (!(s
->flags
&AVFMT_FLAG_PRIV_OPT
) && s
->pb
&& !s
->data_offset
)
480 s
->data_offset
= avio_tell(s
->pb
);
482 s
->raw_packet_buffer_remaining_size
= RAW_PACKET_BUFFER_SIZE
;
485 av_dict_free(options
);
492 ff_id3v2_free_extra_meta(&id3v2_extra_meta
);
494 if (s
->pb
&& !(s
->flags
& AVFMT_FLAG_CUSTOM_IO
))
496 avformat_free_context(s
);
501 /*******************************************************/
503 static void force_codec_ids(AVFormatContext
*s
, AVStream
*st
)
505 switch (st
->codec
->codec_type
) {
506 case AVMEDIA_TYPE_VIDEO
:
507 if (s
->video_codec_id
)
508 st
->codec
->codec_id
= s
->video_codec_id
;
510 case AVMEDIA_TYPE_AUDIO
:
511 if (s
->audio_codec_id
)
512 st
->codec
->codec_id
= s
->audio_codec_id
;
514 case AVMEDIA_TYPE_SUBTITLE
:
515 if (s
->subtitle_codec_id
)
516 st
->codec
->codec_id
= s
->subtitle_codec_id
;
521 static int probe_codec(AVFormatContext
*s
, AVStream
*st
, const AVPacket
*pkt
)
523 if (st
->request_probe
>0) {
524 AVProbeData
*pd
= &st
->probe_data
;
526 av_log(s
, AV_LOG_DEBUG
, "probing stream %d pp:%d\n", st
->index
, st
->probe_packets
);
530 uint8_t *new_buf
= av_realloc(pd
->buf
, pd
->buf_size
+pkt
->size
+AVPROBE_PADDING_SIZE
);
532 av_log(s
, AV_LOG_WARNING
,
533 "Failed to reallocate probe buffer for stream %d\n",
538 memcpy(pd
->buf
+ pd
->buf_size
, pkt
->data
, pkt
->size
);
539 pd
->buf_size
+= pkt
->size
;
540 memset(pd
->buf
+ pd
->buf_size
, 0, AVPROBE_PADDING_SIZE
);
543 st
->probe_packets
= 0;
545 av_log(s
, AV_LOG_WARNING
,
546 "nothing to probe for stream %d\n", st
->index
);
550 end
= s
->raw_packet_buffer_remaining_size
<= 0
551 || st
->probe_packets
<= 0;
553 if (end
|| av_log2(pd
->buf_size
) != av_log2(pd
->buf_size
- pkt
->size
)) {
554 int score
= set_codec_from_probe_data(s
, st
, pd
);
555 if ( (st
->codec
->codec_id
!= AV_CODEC_ID_NONE
&& score
> AVPROBE_SCORE_STREAM_RETRY
)
559 st
->request_probe
= -1;
560 if (st
->codec
->codec_id
!= AV_CODEC_ID_NONE
) {
561 av_log(s
, AV_LOG_DEBUG
, "probed stream %d\n", st
->index
);
563 av_log(s
, AV_LOG_WARNING
, "probed stream %d failed\n", st
->index
);
565 force_codec_ids(s
, st
);
571 static int update_wrap_reference(AVFormatContext
*s
, AVStream
*st
, int stream_index
, AVPacket
*pkt
)
573 int64_t ref
= pkt
->dts
;
574 int i
, pts_wrap_behavior
;
575 int64_t pts_wrap_reference
;
576 AVProgram
*first_program
;
578 if (ref
== AV_NOPTS_VALUE
)
580 if (st
->pts_wrap_reference
!= AV_NOPTS_VALUE
|| st
->pts_wrap_bits
>= 63 || ref
== AV_NOPTS_VALUE
|| !s
->correct_ts_overflow
)
582 ref
&= (1LL << st
->pts_wrap_bits
)-1;
584 // reference time stamp should be 60 s before first time stamp
585 pts_wrap_reference
= ref
- av_rescale(60, st
->time_base
.den
, st
->time_base
.num
);
586 // if first time stamp is not more than 1/8 and 60s before the wrap point, subtract rather than add wrap offset
587 pts_wrap_behavior
= (ref
< (1LL << st
->pts_wrap_bits
) - (1LL << st
->pts_wrap_bits
-3)) ||
588 (ref
< (1LL << st
->pts_wrap_bits
) - av_rescale(60, st
->time_base
.den
, st
->time_base
.num
)) ?
589 AV_PTS_WRAP_ADD_OFFSET
: AV_PTS_WRAP_SUB_OFFSET
;
591 first_program
= av_find_program_from_stream(s
, NULL
, stream_index
);
593 if (!first_program
) {
594 int default_stream_index
= av_find_default_stream_index(s
);
595 if (s
->streams
[default_stream_index
]->pts_wrap_reference
== AV_NOPTS_VALUE
) {
596 for (i
= 0; i
< s
->nb_streams
; i
++) {
597 if (av_find_program_from_stream(s
, NULL
, i
))
599 s
->streams
[i
]->pts_wrap_reference
= pts_wrap_reference
;
600 s
->streams
[i
]->pts_wrap_behavior
= pts_wrap_behavior
;
604 st
->pts_wrap_reference
= s
->streams
[default_stream_index
]->pts_wrap_reference
;
605 st
->pts_wrap_behavior
= s
->streams
[default_stream_index
]->pts_wrap_behavior
;
609 AVProgram
*program
= first_program
;
611 if (program
->pts_wrap_reference
!= AV_NOPTS_VALUE
) {
612 pts_wrap_reference
= program
->pts_wrap_reference
;
613 pts_wrap_behavior
= program
->pts_wrap_behavior
;
616 program
= av_find_program_from_stream(s
, program
, stream_index
);
619 // update every program with differing pts_wrap_reference
620 program
= first_program
;
622 if (program
->pts_wrap_reference
!= pts_wrap_reference
) {
623 for (i
= 0; i
<program
->nb_stream_indexes
; i
++) {
624 s
->streams
[program
->stream_index
[i
]]->pts_wrap_reference
= pts_wrap_reference
;
625 s
->streams
[program
->stream_index
[i
]]->pts_wrap_behavior
= pts_wrap_behavior
;
628 program
->pts_wrap_reference
= pts_wrap_reference
;
629 program
->pts_wrap_behavior
= pts_wrap_behavior
;
631 program
= av_find_program_from_stream(s
, program
, stream_index
);
637 int ff_read_packet(AVFormatContext
*s
, AVPacket
*pkt
)
643 AVPacketList
*pktl
= s
->raw_packet_buffer
;
647 st
= s
->streams
[pkt
->stream_index
];
648 if (s
->raw_packet_buffer_remaining_size
<= 0)
649 if ((err
= probe_codec(s
, st
, NULL
)) < 0)
651 if (st
->request_probe
<= 0) {
652 s
->raw_packet_buffer
= pktl
->next
;
653 s
->raw_packet_buffer_remaining_size
+= pkt
->size
;
662 ret
= s
->iformat
->read_packet(s
, pkt
);
664 if (!pktl
|| ret
== AVERROR(EAGAIN
))
666 for (i
= 0; i
< s
->nb_streams
; i
++) {
668 if (st
->probe_packets
)
669 if ((err
= probe_codec(s
, st
, NULL
)) < 0)
671 av_assert0(st
->request_probe
<= 0);
676 if ((s
->flags
& AVFMT_FLAG_DISCARD_CORRUPT
) &&
677 (pkt
->flags
& AV_PKT_FLAG_CORRUPT
)) {
678 av_log(s
, AV_LOG_WARNING
,
679 "Dropped corrupted packet (stream = %d)\n",
685 if (pkt
->stream_index
>= (unsigned)s
->nb_streams
) {
686 av_log(s
, AV_LOG_ERROR
, "Invalid stream index %d\n", pkt
->stream_index
);
690 st
= s
->streams
[pkt
->stream_index
];
692 if (update_wrap_reference(s
, st
, pkt
->stream_index
, pkt
) && st
->pts_wrap_behavior
== AV_PTS_WRAP_SUB_OFFSET
) {
693 // correct first time stamps to negative values
694 if (!is_relative(st
->first_dts
))
695 st
->first_dts
= wrap_timestamp(st
, st
->first_dts
);
696 if (!is_relative(st
->start_time
))
697 st
->start_time
= wrap_timestamp(st
, st
->start_time
);
698 if (!is_relative(st
->cur_dts
))
699 st
->cur_dts
= wrap_timestamp(st
, st
->cur_dts
);
702 pkt
->dts
= wrap_timestamp(st
, pkt
->dts
);
703 pkt
->pts
= wrap_timestamp(st
, pkt
->pts
);
705 force_codec_ids(s
, st
);
707 /* TODO: audio: time filter; video: frame reordering (pts != dts) */
708 if (s
->use_wallclock_as_timestamps
)
709 pkt
->dts
= pkt
->pts
= av_rescale_q(av_gettime(), AV_TIME_BASE_Q
, st
->time_base
);
711 if (!pktl
&& st
->request_probe
<= 0)
714 add_to_pktbuf(&s
->raw_packet_buffer
, pkt
, &s
->raw_packet_buffer_end
);
715 s
->raw_packet_buffer_remaining_size
-= pkt
->size
;
717 if ((err
= probe_codec(s
, st
, pkt
)) < 0)
723 /**********************************************************/
725 static int determinable_frame_size(AVCodecContext
*avctx
)
727 if (/*avctx->codec_id == AV_CODEC_ID_AAC ||*/
728 avctx
->codec_id
== AV_CODEC_ID_MP1
||
729 avctx
->codec_id
== AV_CODEC_ID_MP2
||
730 avctx
->codec_id
== AV_CODEC_ID_MP3
/* ||
731 avctx->codec_id == AV_CODEC_ID_CELT*/)
737 * Return the frame duration in seconds. Return 0 if not available.
739 void ff_compute_frame_duration(AVFormatContext
*s
, int *pnum
, int *pden
, AVStream
*st
,
740 AVCodecParserContext
*pc
, AVPacket
*pkt
)
742 AVRational codec_framerate
= s
->iformat
? st
->codec
->framerate
:
743 av_mul_q(av_inv_q(st
->codec
->time_base
), (AVRational
){1, st
->codec
->ticks_per_frame
});
748 switch (st
->codec
->codec_type
) {
749 case AVMEDIA_TYPE_VIDEO
:
750 if (st
->r_frame_rate
.num
&& !pc
) {
751 *pnum
= st
->r_frame_rate
.den
;
752 *pden
= st
->r_frame_rate
.num
;
753 } else if (st
->time_base
.num
* 1000LL > st
->time_base
.den
) {
754 *pnum
= st
->time_base
.num
;
755 *pden
= st
->time_base
.den
;
756 } else if (codec_framerate
.den
* 1000LL > codec_framerate
.num
) {
757 av_assert0(st
->codec
->ticks_per_frame
);
758 av_reduce(pnum
, pden
,
760 codec_framerate
.num
* (int64_t)st
->codec
->ticks_per_frame
,
763 if (pc
&& pc
->repeat_pict
) {
764 av_assert0(s
->iformat
); // this may be wrong for interlaced encoding but its not used for that case
765 av_reduce(pnum
, pden
,
766 (*pnum
) * (1LL + pc
->repeat_pict
),
770 /* If this codec can be interlaced or progressive then we need
771 * a parser to compute duration of a packet. Thus if we have
772 * no parser in such case leave duration undefined. */
773 if (st
->codec
->ticks_per_frame
> 1 && !pc
)
777 case AVMEDIA_TYPE_AUDIO
:
778 frame_size
= av_get_audio_frame_duration(st
->codec
, pkt
->size
);
779 if (frame_size
<= 0 || st
->codec
->sample_rate
<= 0)
782 *pden
= st
->codec
->sample_rate
;
789 static int is_intra_only(AVCodecContext
*enc
) {
790 const AVCodecDescriptor
*desc
;
792 if (enc
->codec_type
!= AVMEDIA_TYPE_VIDEO
)
795 desc
= av_codec_get_codec_descriptor(enc
);
797 desc
= avcodec_descriptor_get(enc
->codec_id
);
798 av_codec_set_codec_descriptor(enc
, desc
);
801 return !!(desc
->props
& AV_CODEC_PROP_INTRA_ONLY
);
805 static int has_decode_delay_been_guessed(AVStream
*st
)
807 if (st
->codec
->codec_id
!= AV_CODEC_ID_H264
) return 1;
808 if (!st
->info
) // if we have left find_stream_info then nb_decoded_frames won't increase anymore for stream copy
810 #if CONFIG_H264_DECODER
811 if (st
->codec
->has_b_frames
&&
812 avpriv_h264_has_num_reorder_frames(st
->codec
) == st
->codec
->has_b_frames
)
815 if (st
->codec
->has_b_frames
<3)
816 return st
->nb_decoded_frames
>= 7;
817 else if (st
->codec
->has_b_frames
<4)
818 return st
->nb_decoded_frames
>= 18;
820 return st
->nb_decoded_frames
>= 20;
823 static AVPacketList
*get_next_pkt(AVFormatContext
*s
, AVStream
*st
, AVPacketList
*pktl
)
827 if (pktl
== s
->packet_buffer_end
)
828 return s
->parse_queue
;
832 static int64_t select_from_pts_buffer(AVStream
*st
, int64_t *pts_buffer
, int64_t dts
) {
833 int onein_oneout
= st
->codec
->codec_id
!= AV_CODEC_ID_H264
&&
834 st
->codec
->codec_id
!= AV_CODEC_ID_HEVC
;
837 int delay
= st
->codec
->has_b_frames
;
840 if (dts
== AV_NOPTS_VALUE
) {
841 int64_t best_score
= INT64_MAX
;
842 for (i
= 0; i
<delay
; i
++) {
843 if (st
->pts_reorder_error_count
[i
]) {
844 int64_t score
= st
->pts_reorder_error
[i
] / st
->pts_reorder_error_count
[i
];
845 if (score
< best_score
) {
852 for (i
= 0; i
<delay
; i
++) {
853 if (pts_buffer
[i
] != AV_NOPTS_VALUE
) {
854 int64_t diff
= FFABS(pts_buffer
[i
] - dts
)
855 + (uint64_t)st
->pts_reorder_error
[i
];
856 diff
= FFMAX(diff
, st
->pts_reorder_error
[i
]);
857 st
->pts_reorder_error
[i
] = diff
;
858 st
->pts_reorder_error_count
[i
]++;
859 if (st
->pts_reorder_error_count
[i
] > 250) {
860 st
->pts_reorder_error
[i
] >>= 1;
861 st
->pts_reorder_error_count
[i
] >>= 1;
868 if (dts
== AV_NOPTS_VALUE
)
874 static void update_initial_timestamps(AVFormatContext
*s
, int stream_index
,
875 int64_t dts
, int64_t pts
, AVPacket
*pkt
)
877 AVStream
*st
= s
->streams
[stream_index
];
878 AVPacketList
*pktl
= s
->packet_buffer
? s
->packet_buffer
: s
->parse_queue
;
879 int64_t pts_buffer
[MAX_REORDER_DELAY
+1];
883 if (st
->first_dts
!= AV_NOPTS_VALUE
||
884 dts
== AV_NOPTS_VALUE
||
885 st
->cur_dts
== AV_NOPTS_VALUE
||
889 delay
= st
->codec
->has_b_frames
;
890 st
->first_dts
= dts
- (st
->cur_dts
- RELATIVE_TS_BASE
);
892 shift
= st
->first_dts
- RELATIVE_TS_BASE
;
894 for (i
= 0; i
<MAX_REORDER_DELAY
+1; i
++)
895 pts_buffer
[i
] = AV_NOPTS_VALUE
;
897 if (is_relative(pts
))
900 for (; pktl
; pktl
= get_next_pkt(s
, st
, pktl
)) {
901 if (pktl
->pkt
.stream_index
!= stream_index
)
903 if (is_relative(pktl
->pkt
.pts
))
904 pktl
->pkt
.pts
+= shift
;
906 if (is_relative(pktl
->pkt
.dts
))
907 pktl
->pkt
.dts
+= shift
;
909 if (st
->start_time
== AV_NOPTS_VALUE
&& pktl
->pkt
.pts
!= AV_NOPTS_VALUE
)
910 st
->start_time
= pktl
->pkt
.pts
;
912 if (pktl
->pkt
.pts
!= AV_NOPTS_VALUE
&& delay
<= MAX_REORDER_DELAY
&& has_decode_delay_been_guessed(st
)) {
913 pts_buffer
[0] = pktl
->pkt
.pts
;
914 for (i
= 0; i
<delay
&& pts_buffer
[i
] > pts_buffer
[i
+ 1]; i
++)
915 FFSWAP(int64_t, pts_buffer
[i
], pts_buffer
[i
+ 1]);
917 pktl
->pkt
.dts
= select_from_pts_buffer(st
, pts_buffer
, pktl
->pkt
.dts
);
921 if (st
->start_time
== AV_NOPTS_VALUE
)
922 st
->start_time
= pts
;
925 static void update_initial_durations(AVFormatContext
*s
, AVStream
*st
,
926 int stream_index
, int duration
)
928 AVPacketList
*pktl
= s
->packet_buffer
? s
->packet_buffer
: s
->parse_queue
;
929 int64_t cur_dts
= RELATIVE_TS_BASE
;
931 if (st
->first_dts
!= AV_NOPTS_VALUE
) {
932 if (st
->update_initial_durations_done
)
934 st
->update_initial_durations_done
= 1;
935 cur_dts
= st
->first_dts
;
936 for (; pktl
; pktl
= get_next_pkt(s
, st
, pktl
)) {
937 if (pktl
->pkt
.stream_index
== stream_index
) {
938 if (pktl
->pkt
.pts
!= pktl
->pkt
.dts
||
939 pktl
->pkt
.dts
!= AV_NOPTS_VALUE
||
945 if (pktl
&& pktl
->pkt
.dts
!= st
->first_dts
) {
946 av_log(s
, AV_LOG_DEBUG
, "first_dts %s not matching first dts %s (pts %s, duration %d) in the queue\n",
947 av_ts2str(st
->first_dts
), av_ts2str(pktl
->pkt
.dts
), av_ts2str(pktl
->pkt
.pts
), pktl
->pkt
.duration
);
951 av_log(s
, AV_LOG_DEBUG
, "first_dts %s but no packet with dts in the queue\n", av_ts2str(st
->first_dts
));
954 pktl
= s
->packet_buffer
? s
->packet_buffer
: s
->parse_queue
;
955 st
->first_dts
= cur_dts
;
956 } else if (st
->cur_dts
!= RELATIVE_TS_BASE
)
959 for (; pktl
; pktl
= get_next_pkt(s
, st
, pktl
)) {
960 if (pktl
->pkt
.stream_index
!= stream_index
)
962 if (pktl
->pkt
.pts
== pktl
->pkt
.dts
&&
963 (pktl
->pkt
.dts
== AV_NOPTS_VALUE
|| pktl
->pkt
.dts
== st
->first_dts
) &&
964 !pktl
->pkt
.duration
) {
965 pktl
->pkt
.dts
= cur_dts
;
966 if (!st
->codec
->has_b_frames
)
967 pktl
->pkt
.pts
= cur_dts
;
968 // if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO)
969 pktl
->pkt
.duration
= duration
;
972 cur_dts
= pktl
->pkt
.dts
+ pktl
->pkt
.duration
;
975 st
->cur_dts
= cur_dts
;
978 static void compute_pkt_fields(AVFormatContext
*s
, AVStream
*st
,
979 AVCodecParserContext
*pc
, AVPacket
*pkt
)
981 int num
, den
, presentation_delayed
, delay
, i
;
984 int onein_oneout
= st
->codec
->codec_id
!= AV_CODEC_ID_H264
&&
985 st
->codec
->codec_id
!= AV_CODEC_ID_HEVC
;
987 if (s
->flags
& AVFMT_FLAG_NOFILLIN
)
990 if (st
->codec
->codec_type
== AVMEDIA_TYPE_VIDEO
&& pkt
->dts
!= AV_NOPTS_VALUE
) {
991 if (pkt
->dts
== pkt
->pts
&& st
->last_dts_for_order_check
!= AV_NOPTS_VALUE
) {
992 if (st
->last_dts_for_order_check
<= pkt
->dts
) {
995 av_log(s
, st
->dts_misordered
? AV_LOG_DEBUG
: AV_LOG_WARNING
,
996 "DTS %"PRIi64
" < %"PRIi64
" out of order\n",
998 st
->last_dts_for_order_check
);
999 st
->dts_misordered
++;
1001 if (st
->dts_ordered
+ st
->dts_misordered
> 250) {
1002 st
->dts_ordered
>>= 1;
1003 st
->dts_misordered
>>= 1;
1007 st
->last_dts_for_order_check
= pkt
->dts
;
1008 if (st
->dts_ordered
< 8*st
->dts_misordered
&& pkt
->dts
== pkt
->pts
)
1009 pkt
->dts
= AV_NOPTS_VALUE
;
1012 if ((s
->flags
& AVFMT_FLAG_IGNDTS
) && pkt
->pts
!= AV_NOPTS_VALUE
)
1013 pkt
->dts
= AV_NOPTS_VALUE
;
1015 if (pc
&& pc
->pict_type
== AV_PICTURE_TYPE_B
1016 && !st
->codec
->has_b_frames
)
1017 //FIXME Set low_delay = 0 when has_b_frames = 1
1018 st
->codec
->has_b_frames
= 1;
1020 /* do we have a video B-frame ? */
1021 delay
= st
->codec
->has_b_frames
;
1022 presentation_delayed
= 0;
1024 /* XXX: need has_b_frame, but cannot get it if the codec is
1025 * not initialized */
1027 pc
&& pc
->pict_type
!= AV_PICTURE_TYPE_B
)
1028 presentation_delayed
= 1;
1030 if (pkt
->pts
!= AV_NOPTS_VALUE
&& pkt
->dts
!= AV_NOPTS_VALUE
&&
1031 st
->pts_wrap_bits
< 63 &&
1032 pkt
->dts
- (1LL << (st
->pts_wrap_bits
- 1)) > pkt
->pts
) {
1033 if (is_relative(st
->cur_dts
) || pkt
->dts
- (1LL<<(st
->pts_wrap_bits
- 1)) > st
->cur_dts
) {
1034 pkt
->dts
-= 1LL << st
->pts_wrap_bits
;
1036 pkt
->pts
+= 1LL << st
->pts_wrap_bits
;
1039 /* Some MPEG-2 in MPEG-PS lack dts (issue #171 / input_file.mpg).
1040 * We take the conservative approach and discard both.
1041 * Note: If this is misbehaving for an H.264 file, then possibly
1042 * presentation_delayed is not set correctly. */
1043 if (delay
== 1 && pkt
->dts
== pkt
->pts
&&
1044 pkt
->dts
!= AV_NOPTS_VALUE
&& presentation_delayed
) {
1045 av_log(s
, AV_LOG_DEBUG
, "invalid dts/pts combination %"PRIi64
"\n", pkt
->dts
);
1046 if ( strcmp(s
->iformat
->name
, "mov,mp4,m4a,3gp,3g2,mj2")
1047 && strcmp(s
->iformat
->name
, "flv")) // otherwise we discard correct timestamps for vc1-wmapro.ism
1048 pkt
->dts
= AV_NOPTS_VALUE
;
1051 duration
= av_mul_q((AVRational
) {pkt
->duration
, 1}, st
->time_base
);
1052 if (pkt
->duration
== 0) {
1053 ff_compute_frame_duration(s
, &num
, &den
, st
, pc
, pkt
);
1055 duration
= (AVRational
) {num
, den
};
1056 pkt
->duration
= av_rescale_rnd(1,
1057 num
* (int64_t) st
->time_base
.den
,
1058 den
* (int64_t) st
->time_base
.num
,
1063 if (pkt
->duration
!= 0 && (s
->packet_buffer
|| s
->parse_queue
))
1064 update_initial_durations(s
, st
, pkt
->stream_index
, pkt
->duration
);
1066 /* Correct timestamps with byte offset if demuxers only have timestamps
1067 * on packet boundaries */
1068 if (pc
&& st
->need_parsing
== AVSTREAM_PARSE_TIMESTAMPS
&& pkt
->size
) {
1069 /* this will estimate bitrate based on this frame's duration and size */
1070 offset
= av_rescale(pc
->offset
, pkt
->duration
, pkt
->size
);
1071 if (pkt
->pts
!= AV_NOPTS_VALUE
)
1073 if (pkt
->dts
!= AV_NOPTS_VALUE
)
1077 /* This may be redundant, but it should not hurt. */
1078 if (pkt
->dts
!= AV_NOPTS_VALUE
&&
1079 pkt
->pts
!= AV_NOPTS_VALUE
&&
1080 pkt
->pts
> pkt
->dts
)
1081 presentation_delayed
= 1;
1084 "IN delayed:%d pts:%s, dts:%s cur_dts:%s st:%d pc:%p duration:%d delay:%d onein_oneout:%d\n",
1085 presentation_delayed
, av_ts2str(pkt
->pts
), av_ts2str(pkt
->dts
), av_ts2str(st
->cur_dts
),
1086 pkt
->stream_index
, pc
, pkt
->duration
, delay
, onein_oneout
);
1087 /* Interpolate PTS and DTS if they are not present. We skip H264
1088 * currently because delay and has_b_frames are not reliably set. */
1089 if ((delay
== 0 || (delay
== 1 && pc
)) &&
1091 if (presentation_delayed
) {
1092 /* DTS = decompression timestamp */
1093 /* PTS = presentation timestamp */
1094 if (pkt
->dts
== AV_NOPTS_VALUE
)
1095 pkt
->dts
= st
->last_IP_pts
;
1096 update_initial_timestamps(s
, pkt
->stream_index
, pkt
->dts
, pkt
->pts
, pkt
);
1097 if (pkt
->dts
== AV_NOPTS_VALUE
)
1098 pkt
->dts
= st
->cur_dts
;
1100 /* This is tricky: the dts must be incremented by the duration
1101 * of the frame we are displaying, i.e. the last I- or P-frame. */
1102 if (st
->last_IP_duration
== 0)
1103 st
->last_IP_duration
= pkt
->duration
;
1104 if (pkt
->dts
!= AV_NOPTS_VALUE
)
1105 st
->cur_dts
= pkt
->dts
+ st
->last_IP_duration
;
1106 st
->last_IP_duration
= pkt
->duration
;
1107 st
->last_IP_pts
= pkt
->pts
;
1108 /* Cannot compute PTS if not present (we can compute it only
1109 * by knowing the future. */
1110 } else if (pkt
->pts
!= AV_NOPTS_VALUE
||
1111 pkt
->dts
!= AV_NOPTS_VALUE
||
1114 /* presentation is not delayed : PTS and DTS are the same */
1115 if (pkt
->pts
== AV_NOPTS_VALUE
)
1116 pkt
->pts
= pkt
->dts
;
1117 update_initial_timestamps(s
, pkt
->stream_index
, pkt
->pts
,
1119 if (pkt
->pts
== AV_NOPTS_VALUE
)
1120 pkt
->pts
= st
->cur_dts
;
1121 pkt
->dts
= pkt
->pts
;
1122 if (pkt
->pts
!= AV_NOPTS_VALUE
)
1123 st
->cur_dts
= av_add_stable(st
->time_base
, pkt
->pts
, duration
, 1);
1127 if (pkt
->pts
!= AV_NOPTS_VALUE
&& delay
<= MAX_REORDER_DELAY
&& has_decode_delay_been_guessed(st
)) {
1128 st
->pts_buffer
[0] = pkt
->pts
;
1129 for (i
= 0; i
<delay
&& st
->pts_buffer
[i
] > st
->pts_buffer
[i
+ 1]; i
++)
1130 FFSWAP(int64_t, st
->pts_buffer
[i
], st
->pts_buffer
[i
+ 1]);
1132 pkt
->dts
= select_from_pts_buffer(st
, st
->pts_buffer
, pkt
->dts
);
1134 // We skipped it above so we try here.
1136 // This should happen on the first packet
1137 update_initial_timestamps(s
, pkt
->stream_index
, pkt
->dts
, pkt
->pts
, pkt
);
1138 if (pkt
->dts
> st
->cur_dts
)
1139 st
->cur_dts
= pkt
->dts
;
1141 av_dlog(NULL
, "OUTdelayed:%d/%d pts:%s, dts:%s cur_dts:%s\n",
1142 presentation_delayed
, delay
, av_ts2str(pkt
->pts
), av_ts2str(pkt
->dts
), av_ts2str(st
->cur_dts
));
1145 if (is_intra_only(st
->codec
))
1146 pkt
->flags
|= AV_PKT_FLAG_KEY
;
1148 pkt
->convergence_duration
= pc
->convergence_duration
;
1151 static void free_packet_buffer(AVPacketList
**pkt_buf
, AVPacketList
**pkt_buf_end
)
1154 AVPacketList
*pktl
= *pkt_buf
;
1155 *pkt_buf
= pktl
->next
;
1156 av_free_packet(&pktl
->pkt
);
1159 *pkt_buf_end
= NULL
;
1163 * Parse a packet, add all split parts to parse_queue.
1165 * @param pkt Packet to parse, NULL when flushing the parser at end of stream.
1167 static int parse_packet(AVFormatContext
*s
, AVPacket
*pkt
, int stream_index
)
1169 AVPacket out_pkt
= { 0 }, flush_pkt
= { 0 };
1170 AVStream
*st
= s
->streams
[stream_index
];
1171 uint8_t *data
= pkt
? pkt
->data
: NULL
;
1172 int size
= pkt
? pkt
->size
: 0;
1173 int ret
= 0, got_output
= 0;
1176 av_init_packet(&flush_pkt
);
1179 } else if (!size
&& st
->parser
->flags
& PARSER_FLAG_COMPLETE_FRAMES
) {
1180 // preserve 0-size sync packets
1181 compute_pkt_fields(s
, st
, st
->parser
, pkt
);
1184 while (size
> 0 || (pkt
== &flush_pkt
&& got_output
)) {
1187 av_init_packet(&out_pkt
);
1188 len
= av_parser_parse2(st
->parser
, st
->codec
,
1189 &out_pkt
.data
, &out_pkt
.size
, data
, size
,
1190 pkt
->pts
, pkt
->dts
, pkt
->pos
);
1192 pkt
->pts
= pkt
->dts
= AV_NOPTS_VALUE
;
1194 /* increment read pointer */
1198 got_output
= !!out_pkt
.size
;
1203 if (pkt
->side_data
) {
1204 out_pkt
.side_data
= pkt
->side_data
;
1205 out_pkt
.side_data_elems
= pkt
->side_data_elems
;
1206 pkt
->side_data
= NULL
;
1207 pkt
->side_data_elems
= 0;
1210 /* set the duration */
1211 out_pkt
.duration
= 0;
1212 if (st
->codec
->codec_type
== AVMEDIA_TYPE_AUDIO
) {
1213 if (st
->codec
->sample_rate
> 0) {
1215 av_rescale_q_rnd(st
->parser
->duration
,
1216 (AVRational
) { 1, st
->codec
->sample_rate
},
1222 out_pkt
.stream_index
= st
->index
;
1223 out_pkt
.pts
= st
->parser
->pts
;
1224 out_pkt
.dts
= st
->parser
->dts
;
1225 out_pkt
.pos
= st
->parser
->pos
;
1227 if (st
->need_parsing
== AVSTREAM_PARSE_FULL_RAW
)
1228 out_pkt
.pos
= st
->parser
->frame_offset
;
1230 if (st
->parser
->key_frame
== 1 ||
1231 (st
->parser
->key_frame
== -1 &&
1232 st
->parser
->pict_type
== AV_PICTURE_TYPE_I
))
1233 out_pkt
.flags
|= AV_PKT_FLAG_KEY
;
1235 if (st
->parser
->key_frame
== -1 && st
->parser
->pict_type
==AV_PICTURE_TYPE_NONE
&& (pkt
->flags
&AV_PKT_FLAG_KEY
))
1236 out_pkt
.flags
|= AV_PKT_FLAG_KEY
;
1238 compute_pkt_fields(s
, st
, st
->parser
, &out_pkt
);
1240 if (out_pkt
.data
== pkt
->data
&& out_pkt
.size
== pkt
->size
) {
1241 out_pkt
.buf
= pkt
->buf
;
1243 #if FF_API_DESTRUCT_PACKET
1244 FF_DISABLE_DEPRECATION_WARNINGS
1245 out_pkt
.destruct
= pkt
->destruct
;
1246 pkt
->destruct
= NULL
;
1247 FF_ENABLE_DEPRECATION_WARNINGS
1250 if ((ret
= av_dup_packet(&out_pkt
)) < 0)
1253 if (!add_to_pktbuf(&s
->parse_queue
, &out_pkt
, &s
->parse_queue_end
)) {
1254 av_free_packet(&out_pkt
);
1255 ret
= AVERROR(ENOMEM
);
1260 /* end of the stream => close and free the parser */
1261 if (pkt
== &flush_pkt
) {
1262 av_parser_close(st
->parser
);
1267 av_free_packet(pkt
);
1271 static int read_from_packet_buffer(AVPacketList
**pkt_buffer
,
1272 AVPacketList
**pkt_buffer_end
,
1276 av_assert0(*pkt_buffer
);
1279 *pkt_buffer
= pktl
->next
;
1281 *pkt_buffer_end
= NULL
;
1286 static int64_t ts_to_samples(AVStream
*st
, int64_t ts
)
1288 return av_rescale(ts
, st
->time_base
.num
* st
->codec
->sample_rate
, st
->time_base
.den
);
1291 static int read_frame_internal(AVFormatContext
*s
, AVPacket
*pkt
)
1293 int ret
= 0, i
, got_packet
= 0;
1294 AVDictionary
*metadata
= NULL
;
1296 av_init_packet(pkt
);
1298 while (!got_packet
&& !s
->parse_queue
) {
1302 /* read next packet */
1303 ret
= ff_read_packet(s
, &cur_pkt
);
1305 if (ret
== AVERROR(EAGAIN
))
1307 /* flush the parsers */
1308 for (i
= 0; i
< s
->nb_streams
; i
++) {
1310 if (st
->parser
&& st
->need_parsing
)
1311 parse_packet(s
, NULL
, st
->index
);
1313 /* all remaining packets are now in parse_queue =>
1314 * really terminate parsing */
1318 st
= s
->streams
[cur_pkt
.stream_index
];
1320 if (cur_pkt
.pts
!= AV_NOPTS_VALUE
&&
1321 cur_pkt
.dts
!= AV_NOPTS_VALUE
&&
1322 cur_pkt
.pts
< cur_pkt
.dts
) {
1323 av_log(s
, AV_LOG_WARNING
,
1324 "Invalid timestamps stream=%d, pts=%s, dts=%s, size=%d\n",
1325 cur_pkt
.stream_index
,
1326 av_ts2str(cur_pkt
.pts
),
1327 av_ts2str(cur_pkt
.dts
),
1330 if (s
->debug
& FF_FDEBUG_TS
)
1331 av_log(s
, AV_LOG_DEBUG
,
1332 "ff_read_packet stream=%d, pts=%s, dts=%s, size=%d, duration=%d, flags=%d\n",
1333 cur_pkt
.stream_index
,
1334 av_ts2str(cur_pkt
.pts
),
1335 av_ts2str(cur_pkt
.dts
),
1336 cur_pkt
.size
, cur_pkt
.duration
, cur_pkt
.flags
);
1338 if (st
->need_parsing
&& !st
->parser
&& !(s
->flags
& AVFMT_FLAG_NOPARSE
)) {
1339 st
->parser
= av_parser_init(st
->codec
->codec_id
);
1341 av_log(s
, AV_LOG_VERBOSE
, "parser not found for codec "
1342 "%s, packets or times may be invalid.\n",
1343 avcodec_get_name(st
->codec
->codec_id
));
1344 /* no parser available: just output the raw packets */
1345 st
->need_parsing
= AVSTREAM_PARSE_NONE
;
1346 } else if (st
->need_parsing
== AVSTREAM_PARSE_HEADERS
)
1347 st
->parser
->flags
|= PARSER_FLAG_COMPLETE_FRAMES
;
1348 else if (st
->need_parsing
== AVSTREAM_PARSE_FULL_ONCE
)
1349 st
->parser
->flags
|= PARSER_FLAG_ONCE
;
1350 else if (st
->need_parsing
== AVSTREAM_PARSE_FULL_RAW
)
1351 st
->parser
->flags
|= PARSER_FLAG_USE_CODEC_TS
;
1354 if (!st
->need_parsing
|| !st
->parser
) {
1355 /* no parsing needed: we just output the packet as is */
1357 compute_pkt_fields(s
, st
, NULL
, pkt
);
1358 if ((s
->iformat
->flags
& AVFMT_GENERIC_INDEX
) &&
1359 (pkt
->flags
& AV_PKT_FLAG_KEY
) && pkt
->dts
!= AV_NOPTS_VALUE
) {
1360 ff_reduce_index(s
, st
->index
);
1361 av_add_index_entry(st
, pkt
->pos
, pkt
->dts
,
1362 0, 0, AVINDEX_KEYFRAME
);
1365 } else if (st
->discard
< AVDISCARD_ALL
) {
1366 if ((ret
= parse_packet(s
, &cur_pkt
, cur_pkt
.stream_index
)) < 0)
1370 av_free_packet(&cur_pkt
);
1372 if (pkt
->flags
& AV_PKT_FLAG_KEY
)
1373 st
->skip_to_keyframe
= 0;
1374 if (st
->skip_to_keyframe
) {
1375 av_free_packet(&cur_pkt
);
1383 if (!got_packet
&& s
->parse_queue
)
1384 ret
= read_from_packet_buffer(&s
->parse_queue
, &s
->parse_queue_end
, pkt
);
1387 AVStream
*st
= s
->streams
[pkt
->stream_index
];
1388 int discard_padding
= 0;
1389 if (st
->first_discard_sample
&& pkt
->pts
!= AV_NOPTS_VALUE
) {
1390 int64_t pts
= pkt
->pts
- (is_relative(pkt
->pts
) ? RELATIVE_TS_BASE
: 0);
1391 int64_t sample
= ts_to_samples(st
, pts
);
1392 int duration
= ts_to_samples(st
, pkt
->duration
);
1393 int64_t end_sample
= sample
+ duration
;
1394 if (duration
> 0 && end_sample
>= st
->first_discard_sample
&&
1395 sample
< st
->last_discard_sample
)
1396 discard_padding
= FFMIN(end_sample
- st
->first_discard_sample
, duration
);
1398 if (st
->skip_samples
|| discard_padding
) {
1399 uint8_t *p
= av_packet_new_side_data(pkt
, AV_PKT_DATA_SKIP_SAMPLES
, 10);
1401 AV_WL32(p
, st
->skip_samples
);
1402 AV_WL32(p
+ 4, discard_padding
);
1403 av_log(s
, AV_LOG_DEBUG
, "demuxer injecting skip %d\n", st
->skip_samples
);
1405 st
->skip_samples
= 0;
1408 if (st
->inject_global_side_data
) {
1409 for (i
= 0; i
< st
->nb_side_data
; i
++) {
1410 AVPacketSideData
*src_sd
= &st
->side_data
[i
];
1413 if (av_packet_get_side_data(pkt
, src_sd
->type
, NULL
))
1416 dst_data
= av_packet_new_side_data(pkt
, src_sd
->type
, src_sd
->size
);
1418 av_log(s
, AV_LOG_WARNING
, "Could not inject global side data\n");
1422 memcpy(dst_data
, src_sd
->data
, src_sd
->size
);
1424 st
->inject_global_side_data
= 0;
1427 if (!(s
->flags
& AVFMT_FLAG_KEEP_SIDE_DATA
))
1428 av_packet_merge_side_data(pkt
);
1431 av_opt_get_dict_val(s
, "metadata", AV_OPT_SEARCH_CHILDREN
, &metadata
);
1433 s
->event_flags
|= AVFMT_EVENT_FLAG_METADATA_UPDATED
;
1434 av_dict_copy(&s
->metadata
, metadata
, 0);
1435 av_dict_free(&metadata
);
1436 av_opt_set_dict_val(s
, "metadata", NULL
, AV_OPT_SEARCH_CHILDREN
);
1439 if (s
->debug
& FF_FDEBUG_TS
)
1440 av_log(s
, AV_LOG_DEBUG
,
1441 "read_frame_internal stream=%d, pts=%s, dts=%s, "
1442 "size=%d, duration=%d, flags=%d\n",
1444 av_ts2str(pkt
->pts
),
1445 av_ts2str(pkt
->dts
),
1446 pkt
->size
, pkt
->duration
, pkt
->flags
);
1451 int av_read_frame(AVFormatContext
*s
, AVPacket
*pkt
)
1453 const int genpts
= s
->flags
& AVFMT_FLAG_GENPTS
;
1459 ret
= s
->packet_buffer
1460 ? read_from_packet_buffer(&s
->packet_buffer
,
1461 &s
->packet_buffer_end
, pkt
)
1462 : read_frame_internal(s
, pkt
);
1469 AVPacketList
*pktl
= s
->packet_buffer
;
1472 AVPacket
*next_pkt
= &pktl
->pkt
;
1474 if (next_pkt
->dts
!= AV_NOPTS_VALUE
) {
1475 int wrap_bits
= s
->streams
[next_pkt
->stream_index
]->pts_wrap_bits
;
1476 // last dts seen for this stream. if any of packets following
1477 // current one had no dts, we will set this to AV_NOPTS_VALUE.
1478 int64_t last_dts
= next_pkt
->dts
;
1479 while (pktl
&& next_pkt
->pts
== AV_NOPTS_VALUE
) {
1480 if (pktl
->pkt
.stream_index
== next_pkt
->stream_index
&&
1481 (av_compare_mod(next_pkt
->dts
, pktl
->pkt
.dts
, 2LL << (wrap_bits
- 1)) < 0)) {
1482 if (av_compare_mod(pktl
->pkt
.pts
, pktl
->pkt
.dts
, 2LL << (wrap_bits
- 1))) {
1484 next_pkt
->pts
= pktl
->pkt
.dts
;
1486 if (last_dts
!= AV_NOPTS_VALUE
) {
1487 // Once last dts was set to AV_NOPTS_VALUE, we don't change it.
1488 last_dts
= pktl
->pkt
.dts
;
1493 if (eof
&& next_pkt
->pts
== AV_NOPTS_VALUE
&& last_dts
!= AV_NOPTS_VALUE
) {
1494 // Fixing the last reference frame had none pts issue (For MXF etc).
1495 // We only do this when
1497 // 2. we are not able to resolve a pts value for current packet.
1498 // 3. the packets for this stream at the end of the files had valid dts.
1499 next_pkt
->pts
= last_dts
+ next_pkt
->duration
;
1501 pktl
= s
->packet_buffer
;
1504 /* read packet from packet buffer, if there is data */
1505 st
= s
->streams
[next_pkt
->stream_index
];
1506 if (!(next_pkt
->pts
== AV_NOPTS_VALUE
&& st
->discard
< AVDISCARD_ALL
&&
1507 next_pkt
->dts
!= AV_NOPTS_VALUE
&& !eof
)) {
1508 ret
= read_from_packet_buffer(&s
->packet_buffer
,
1509 &s
->packet_buffer_end
, pkt
);
1514 ret
= read_frame_internal(s
, pkt
);
1516 if (pktl
&& ret
!= AVERROR(EAGAIN
)) {
1523 if (av_dup_packet(add_to_pktbuf(&s
->packet_buffer
, pkt
,
1524 &s
->packet_buffer_end
)) < 0)
1525 return AVERROR(ENOMEM
);
1530 st
= s
->streams
[pkt
->stream_index
];
1531 if ((s
->iformat
->flags
& AVFMT_GENERIC_INDEX
) && pkt
->flags
& AV_PKT_FLAG_KEY
) {
1532 ff_reduce_index(s
, st
->index
);
1533 av_add_index_entry(st
, pkt
->pos
, pkt
->dts
, 0, 0, AVINDEX_KEYFRAME
);
1536 if (is_relative(pkt
->dts
))
1537 pkt
->dts
-= RELATIVE_TS_BASE
;
1538 if (is_relative(pkt
->pts
))
1539 pkt
->pts
-= RELATIVE_TS_BASE
;
1544 /* XXX: suppress the packet queue */
1545 static void flush_packet_queue(AVFormatContext
*s
)
1547 free_packet_buffer(&s
->parse_queue
, &s
->parse_queue_end
);
1548 free_packet_buffer(&s
->packet_buffer
, &s
->packet_buffer_end
);
1549 free_packet_buffer(&s
->raw_packet_buffer
, &s
->raw_packet_buffer_end
);
1551 s
->raw_packet_buffer_remaining_size
= RAW_PACKET_BUFFER_SIZE
;
1554 /*******************************************************/
1557 int av_find_default_stream_index(AVFormatContext
*s
)
1561 int best_stream
= 0;
1562 int best_score
= -1;
1564 if (s
->nb_streams
<= 0)
1566 for (i
= 0; i
< s
->nb_streams
; i
++) {
1569 if (st
->codec
->codec_type
== AVMEDIA_TYPE_VIDEO
&&
1570 !(st
->disposition
& AV_DISPOSITION_ATTACHED_PIC
)) {
1571 if (!st
->codec
->width
&& !st
->codec
->height
&& !st
->codec_info_nb_frames
)
1576 if (st
->codec
->codec_type
== AVMEDIA_TYPE_AUDIO
) {
1577 if (!st
->codec
->sample_rate
&& !st
->codec_info_nb_frames
)
1583 if (score
> best_score
) {
1591 /** Flush the frame reader. */
1592 void ff_read_frame_flush(AVFormatContext
*s
)
1597 flush_packet_queue(s
);
1599 /* Reset read state for each stream. */
1600 for (i
= 0; i
< s
->nb_streams
; i
++) {
1604 av_parser_close(st
->parser
);
1607 st
->last_IP_pts
= AV_NOPTS_VALUE
;
1608 st
->last_dts_for_order_check
= AV_NOPTS_VALUE
;
1609 if (st
->first_dts
== AV_NOPTS_VALUE
)
1610 st
->cur_dts
= RELATIVE_TS_BASE
;
1612 /* We set the current DTS to an unspecified origin. */
1613 st
->cur_dts
= AV_NOPTS_VALUE
;
1615 st
->probe_packets
= MAX_PROBE_PACKETS
;
1617 for (j
= 0; j
< MAX_REORDER_DELAY
+ 1; j
++)
1618 st
->pts_buffer
[j
] = AV_NOPTS_VALUE
;
1620 if (s
->internal
->inject_global_side_data
)
1621 st
->inject_global_side_data
= 1;
1625 void ff_update_cur_dts(AVFormatContext
*s
, AVStream
*ref_st
, int64_t timestamp
)
1629 for (i
= 0; i
< s
->nb_streams
; i
++) {
1630 AVStream
*st
= s
->streams
[i
];
1633 av_rescale(timestamp
,
1634 st
->time_base
.den
* (int64_t) ref_st
->time_base
.num
,
1635 st
->time_base
.num
* (int64_t) ref_st
->time_base
.den
);
1639 void ff_reduce_index(AVFormatContext
*s
, int stream_index
)
1641 AVStream
*st
= s
->streams
[stream_index
];
1642 unsigned int max_entries
= s
->max_index_size
/ sizeof(AVIndexEntry
);
1644 if ((unsigned) st
->nb_index_entries
>= max_entries
) {
1646 for (i
= 0; 2 * i
< st
->nb_index_entries
; i
++)
1647 st
->index_entries
[i
] = st
->index_entries
[2 * i
];
1648 st
->nb_index_entries
= i
;
1652 int ff_add_index_entry(AVIndexEntry
**index_entries
,
1653 int *nb_index_entries
,
1654 unsigned int *index_entries_allocated_size
,
1655 int64_t pos
, int64_t timestamp
,
1656 int size
, int distance
, int flags
)
1658 AVIndexEntry
*entries
, *ie
;
1661 if ((unsigned) *nb_index_entries
+ 1 >= UINT_MAX
/ sizeof(AVIndexEntry
))
1664 if (timestamp
== AV_NOPTS_VALUE
)
1665 return AVERROR(EINVAL
);
1667 if (size
< 0 || size
> 0x3FFFFFFF)
1668 return AVERROR(EINVAL
);
1670 if (is_relative(timestamp
)) //FIXME this maintains previous behavior but we should shift by the correct offset once known
1671 timestamp
-= RELATIVE_TS_BASE
;
1673 entries
= av_fast_realloc(*index_entries
,
1674 index_entries_allocated_size
,
1675 (*nb_index_entries
+ 1) *
1676 sizeof(AVIndexEntry
));
1680 *index_entries
= entries
;
1682 index
= ff_index_search_timestamp(*index_entries
, *nb_index_entries
,
1683 timestamp
, AVSEEK_FLAG_ANY
);
1686 index
= (*nb_index_entries
)++;
1687 ie
= &entries
[index
];
1688 av_assert0(index
== 0 || ie
[-1].timestamp
< timestamp
);
1690 ie
= &entries
[index
];
1691 if (ie
->timestamp
!= timestamp
) {
1692 if (ie
->timestamp
<= timestamp
)
1694 memmove(entries
+ index
+ 1, entries
+ index
,
1695 sizeof(AVIndexEntry
) * (*nb_index_entries
- index
));
1696 (*nb_index_entries
)++;
1697 } else if (ie
->pos
== pos
&& distance
< ie
->min_distance
)
1698 // do not reduce the distance
1699 distance
= ie
->min_distance
;
1703 ie
->timestamp
= timestamp
;
1704 ie
->min_distance
= distance
;
1711 int av_add_index_entry(AVStream
*st
, int64_t pos
, int64_t timestamp
,
1712 int size
, int distance
, int flags
)
1714 timestamp
= wrap_timestamp(st
, timestamp
);
1715 return ff_add_index_entry(&st
->index_entries
, &st
->nb_index_entries
,
1716 &st
->index_entries_allocated_size
, pos
,
1717 timestamp
, size
, distance
, flags
);
1720 int ff_index_search_timestamp(const AVIndexEntry
*entries
, int nb_entries
,
1721 int64_t wanted_timestamp
, int flags
)
1729 // Optimize appending index entries at the end.
1730 if (b
&& entries
[b
- 1].timestamp
< wanted_timestamp
)
1735 timestamp
= entries
[m
].timestamp
;
1736 if (timestamp
>= wanted_timestamp
)
1738 if (timestamp
<= wanted_timestamp
)
1741 m
= (flags
& AVSEEK_FLAG_BACKWARD
) ? a
: b
;
1743 if (!(flags
& AVSEEK_FLAG_ANY
))
1744 while (m
>= 0 && m
< nb_entries
&&
1745 !(entries
[m
].flags
& AVINDEX_KEYFRAME
))
1746 m
+= (flags
& AVSEEK_FLAG_BACKWARD
) ? -1 : 1;
1748 if (m
== nb_entries
)
1753 int av_index_search_timestamp(AVStream
*st
, int64_t wanted_timestamp
, int flags
)
1755 return ff_index_search_timestamp(st
->index_entries
, st
->nb_index_entries
,
1756 wanted_timestamp
, flags
);
1759 static int64_t ff_read_timestamp(AVFormatContext
*s
, int stream_index
, int64_t *ppos
, int64_t pos_limit
,
1760 int64_t (*read_timestamp
)(struct AVFormatContext
*, int , int64_t *, int64_t ))
1762 int64_t ts
= read_timestamp(s
, stream_index
, ppos
, pos_limit
);
1763 if (stream_index
>= 0)
1764 ts
= wrap_timestamp(s
->streams
[stream_index
], ts
);
1768 int ff_seek_frame_binary(AVFormatContext
*s
, int stream_index
,
1769 int64_t target_ts
, int flags
)
1771 AVInputFormat
*avif
= s
->iformat
;
1772 int64_t av_uninit(pos_min
), av_uninit(pos_max
), pos
, pos_limit
;
1773 int64_t ts_min
, ts_max
, ts
;
1778 if (stream_index
< 0)
1781 av_dlog(s
, "read_seek: %d %s\n", stream_index
, av_ts2str(target_ts
));
1784 ts_min
= AV_NOPTS_VALUE
;
1785 pos_limit
= -1; // GCC falsely says it may be uninitialized.
1787 st
= s
->streams
[stream_index
];
1788 if (st
->index_entries
) {
1791 /* FIXME: Whole function must be checked for non-keyframe entries in
1792 * index case, especially read_timestamp(). */
1793 index
= av_index_search_timestamp(st
, target_ts
,
1794 flags
| AVSEEK_FLAG_BACKWARD
);
1795 index
= FFMAX(index
, 0);
1796 e
= &st
->index_entries
[index
];
1798 if (e
->timestamp
<= target_ts
|| e
->pos
== e
->min_distance
) {
1800 ts_min
= e
->timestamp
;
1801 av_dlog(s
, "using cached pos_min=0x%"PRIx64
" dts_min=%s\n",
1802 pos_min
, av_ts2str(ts_min
));
1804 av_assert1(index
== 0);
1807 index
= av_index_search_timestamp(st
, target_ts
,
1808 flags
& ~AVSEEK_FLAG_BACKWARD
);
1809 av_assert0(index
< st
->nb_index_entries
);
1811 e
= &st
->index_entries
[index
];
1812 av_assert1(e
->timestamp
>= target_ts
);
1814 ts_max
= e
->timestamp
;
1815 pos_limit
= pos_max
- e
->min_distance
;
1816 av_dlog(s
, "using cached pos_max=0x%"PRIx64
" pos_limit=0x%"PRIx64
1817 " dts_max=%s\n", pos_max
, pos_limit
, av_ts2str(ts_max
));
1821 pos
= ff_gen_search(s
, stream_index
, target_ts
, pos_min
, pos_max
, pos_limit
,
1822 ts_min
, ts_max
, flags
, &ts
, avif
->read_timestamp
);
1827 if ((ret
= avio_seek(s
->pb
, pos
, SEEK_SET
)) < 0)
1830 ff_read_frame_flush(s
);
1831 ff_update_cur_dts(s
, st
, ts
);
1836 int ff_find_last_ts(AVFormatContext
*s
, int stream_index
, int64_t *ts
, int64_t *pos
,
1837 int64_t (*read_timestamp
)(struct AVFormatContext
*, int , int64_t *, int64_t ))
1839 int64_t step
= 1024;
1840 int64_t limit
, ts_max
;
1841 int64_t filesize
= avio_size(s
->pb
);
1842 int64_t pos_max
= filesize
- 1;
1845 pos_max
= FFMAX(0, (pos_max
) - step
);
1846 ts_max
= ff_read_timestamp(s
, stream_index
,
1847 &pos_max
, limit
, read_timestamp
);
1849 } while (ts_max
== AV_NOPTS_VALUE
&& 2*limit
> step
);
1850 if (ts_max
== AV_NOPTS_VALUE
)
1854 int64_t tmp_pos
= pos_max
+ 1;
1855 int64_t tmp_ts
= ff_read_timestamp(s
, stream_index
,
1856 &tmp_pos
, INT64_MAX
, read_timestamp
);
1857 if (tmp_ts
== AV_NOPTS_VALUE
)
1859 av_assert0(tmp_pos
> pos_max
);
1862 if (tmp_pos
>= filesize
)
1874 int64_t ff_gen_search(AVFormatContext
*s
, int stream_index
, int64_t target_ts
,
1875 int64_t pos_min
, int64_t pos_max
, int64_t pos_limit
,
1876 int64_t ts_min
, int64_t ts_max
,
1877 int flags
, int64_t *ts_ret
,
1878 int64_t (*read_timestamp
)(struct AVFormatContext
*, int,
1879 int64_t *, int64_t))
1886 av_dlog(s
, "gen_seek: %d %s\n", stream_index
, av_ts2str(target_ts
));
1888 if (ts_min
== AV_NOPTS_VALUE
) {
1889 pos_min
= s
->data_offset
;
1890 ts_min
= ff_read_timestamp(s
, stream_index
, &pos_min
, INT64_MAX
, read_timestamp
);
1891 if (ts_min
== AV_NOPTS_VALUE
)
1895 if (ts_min
>= target_ts
) {
1900 if (ts_max
== AV_NOPTS_VALUE
) {
1901 if ((ret
= ff_find_last_ts(s
, stream_index
, &ts_max
, &pos_max
, read_timestamp
)) < 0)
1903 pos_limit
= pos_max
;
1906 if (ts_max
<= target_ts
) {
1911 if (ts_min
> ts_max
)
1913 else if (ts_min
== ts_max
)
1914 pos_limit
= pos_min
;
1917 while (pos_min
< pos_limit
) {
1919 "pos_min=0x%"PRIx64
" pos_max=0x%"PRIx64
" dts_min=%s dts_max=%s\n",
1920 pos_min
, pos_max
, av_ts2str(ts_min
), av_ts2str(ts_max
));
1921 assert(pos_limit
<= pos_max
);
1923 if (no_change
== 0) {
1924 int64_t approximate_keyframe_distance
= pos_max
- pos_limit
;
1925 // interpolate position (better than dichotomy)
1926 pos
= av_rescale(target_ts
- ts_min
, pos_max
- pos_min
,
1928 pos_min
- approximate_keyframe_distance
;
1929 } else if (no_change
== 1) {
1930 // bisection if interpolation did not change min / max pos last time
1931 pos
= (pos_min
+ pos_limit
) >> 1;
1933 /* linear search if bisection failed, can only happen if there
1934 * are very few or no keyframes between min/max */
1939 else if (pos
> pos_limit
)
1943 // May pass pos_limit instead of -1.
1944 ts
= ff_read_timestamp(s
, stream_index
, &pos
, INT64_MAX
, read_timestamp
);
1949 av_dlog(s
, "%"PRId64
" %"PRId64
" %"PRId64
" / %s %s %s"
1950 " target:%s limit:%"PRId64
" start:%"PRId64
" noc:%d\n",
1951 pos_min
, pos
, pos_max
,
1952 av_ts2str(ts_min
), av_ts2str(ts
), av_ts2str(ts_max
), av_ts2str(target_ts
),
1953 pos_limit
, start_pos
, no_change
);
1954 if (ts
== AV_NOPTS_VALUE
) {
1955 av_log(s
, AV_LOG_ERROR
, "read_timestamp() failed in the middle\n");
1958 if (target_ts
<= ts
) {
1959 pos_limit
= start_pos
- 1;
1963 if (target_ts
>= ts
) {
1969 pos
= (flags
& AVSEEK_FLAG_BACKWARD
) ? pos_min
: pos_max
;
1970 ts
= (flags
& AVSEEK_FLAG_BACKWARD
) ? ts_min
: ts_max
;
1973 ts_min
= ff_read_timestamp(s
, stream_index
, &pos_min
, INT64_MAX
, read_timestamp
);
1975 ts_max
= ff_read_timestamp(s
, stream_index
, &pos_min
, INT64_MAX
, read_timestamp
);
1976 av_dlog(s
, "pos=0x%"PRIx64
" %s<=%s<=%s\n",
1977 pos
, av_ts2str(ts_min
), av_ts2str(target_ts
), av_ts2str(ts_max
));
1983 static int seek_frame_byte(AVFormatContext
*s
, int stream_index
,
1984 int64_t pos
, int flags
)
1986 int64_t pos_min
, pos_max
;
1988 pos_min
= s
->data_offset
;
1989 pos_max
= avio_size(s
->pb
) - 1;
1993 else if (pos
> pos_max
)
1996 avio_seek(s
->pb
, pos
, SEEK_SET
);
1998 s
->io_repositioned
= 1;
2003 static int seek_frame_generic(AVFormatContext
*s
, int stream_index
,
2004 int64_t timestamp
, int flags
)
2011 st
= s
->streams
[stream_index
];
2013 index
= av_index_search_timestamp(st
, timestamp
, flags
);
2015 if (index
< 0 && st
->nb_index_entries
&&
2016 timestamp
< st
->index_entries
[0].timestamp
)
2019 if (index
< 0 || index
== st
->nb_index_entries
- 1) {
2023 if (st
->nb_index_entries
) {
2024 av_assert0(st
->index_entries
);
2025 ie
= &st
->index_entries
[st
->nb_index_entries
- 1];
2026 if ((ret
= avio_seek(s
->pb
, ie
->pos
, SEEK_SET
)) < 0)
2028 ff_update_cur_dts(s
, st
, ie
->timestamp
);
2030 if ((ret
= avio_seek(s
->pb
, s
->data_offset
, SEEK_SET
)) < 0)
2036 read_status
= av_read_frame(s
, &pkt
);
2037 } while (read_status
== AVERROR(EAGAIN
));
2038 if (read_status
< 0)
2040 av_free_packet(&pkt
);
2041 if (stream_index
== pkt
.stream_index
&& pkt
.dts
> timestamp
) {
2042 if (pkt
.flags
& AV_PKT_FLAG_KEY
)
2044 if (nonkey
++ > 1000 && st
->codec
->codec_id
!= AV_CODEC_ID_CDGRAPHICS
) {
2045 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
);
2050 index
= av_index_search_timestamp(st
, timestamp
, flags
);
2055 ff_read_frame_flush(s
);
2056 if (s
->iformat
->read_seek
)
2057 if (s
->iformat
->read_seek(s
, stream_index
, timestamp
, flags
) >= 0)
2059 ie
= &st
->index_entries
[index
];
2060 if ((ret
= avio_seek(s
->pb
, ie
->pos
, SEEK_SET
)) < 0)
2062 ff_update_cur_dts(s
, st
, ie
->timestamp
);
2067 static int seek_frame_internal(AVFormatContext
*s
, int stream_index
,
2068 int64_t timestamp
, int flags
)
2073 if (flags
& AVSEEK_FLAG_BYTE
) {
2074 if (s
->iformat
->flags
& AVFMT_NO_BYTE_SEEK
)
2076 ff_read_frame_flush(s
);
2077 return seek_frame_byte(s
, stream_index
, timestamp
, flags
);
2080 if (stream_index
< 0) {
2081 stream_index
= av_find_default_stream_index(s
);
2082 if (stream_index
< 0)
2085 st
= s
->streams
[stream_index
];
2086 /* timestamp for default must be expressed in AV_TIME_BASE units */
2087 timestamp
= av_rescale(timestamp
, st
->time_base
.den
,
2088 AV_TIME_BASE
* (int64_t) st
->time_base
.num
);
2091 /* first, we try the format specific seek */
2092 if (s
->iformat
->read_seek
) {
2093 ff_read_frame_flush(s
);
2094 ret
= s
->iformat
->read_seek(s
, stream_index
, timestamp
, flags
);
2100 if (s
->iformat
->read_timestamp
&&
2101 !(s
->iformat
->flags
& AVFMT_NOBINSEARCH
)) {
2102 ff_read_frame_flush(s
);
2103 return ff_seek_frame_binary(s
, stream_index
, timestamp
, flags
);
2104 } else if (!(s
->iformat
->flags
& AVFMT_NOGENSEARCH
)) {
2105 ff_read_frame_flush(s
);
2106 return seek_frame_generic(s
, stream_index
, timestamp
, flags
);
2111 int av_seek_frame(AVFormatContext
*s
, int stream_index
,
2112 int64_t timestamp
, int flags
)
2116 if (s
->iformat
->read_seek2
&& !s
->iformat
->read_seek
) {
2117 int64_t min_ts
= INT64_MIN
, max_ts
= INT64_MAX
;
2118 if ((flags
& AVSEEK_FLAG_BACKWARD
))
2122 return avformat_seek_file(s
, stream_index
, min_ts
, timestamp
, max_ts
,
2123 flags
& ~AVSEEK_FLAG_BACKWARD
);
2126 ret
= seek_frame_internal(s
, stream_index
, timestamp
, flags
);
2129 ret
= avformat_queue_attached_pictures(s
);
2134 int avformat_seek_file(AVFormatContext
*s
, int stream_index
, int64_t min_ts
,
2135 int64_t ts
, int64_t max_ts
, int flags
)
2137 if (min_ts
> ts
|| max_ts
< ts
)
2139 if (stream_index
< -1 || stream_index
>= (int)s
->nb_streams
)
2140 return AVERROR(EINVAL
);
2143 flags
|= AVSEEK_FLAG_ANY
;
2144 flags
&= ~AVSEEK_FLAG_BACKWARD
;
2146 if (s
->iformat
->read_seek2
) {
2148 ff_read_frame_flush(s
);
2150 if (stream_index
== -1 && s
->nb_streams
== 1) {
2151 AVRational time_base
= s
->streams
[0]->time_base
;
2152 ts
= av_rescale_q(ts
, AV_TIME_BASE_Q
, time_base
);
2153 min_ts
= av_rescale_rnd(min_ts
, time_base
.den
,
2154 time_base
.num
* (int64_t)AV_TIME_BASE
,
2155 AV_ROUND_UP
| AV_ROUND_PASS_MINMAX
);
2156 max_ts
= av_rescale_rnd(max_ts
, time_base
.den
,
2157 time_base
.num
* (int64_t)AV_TIME_BASE
,
2158 AV_ROUND_DOWN
| AV_ROUND_PASS_MINMAX
);
2161 ret
= s
->iformat
->read_seek2(s
, stream_index
, min_ts
,
2165 ret
= avformat_queue_attached_pictures(s
);
2169 if (s
->iformat
->read_timestamp
) {
2170 // try to seek via read_timestamp()
2173 // Fall back on old API if new is not implemented but old is.
2174 // Note the old API has somewhat different semantics.
2175 if (s
->iformat
->read_seek
|| 1) {
2176 int dir
= (ts
- (uint64_t)min_ts
> (uint64_t)max_ts
- ts
? AVSEEK_FLAG_BACKWARD
: 0);
2177 int ret
= av_seek_frame(s
, stream_index
, ts
, flags
| dir
);
2178 if (ret
<0 && ts
!= min_ts
&& max_ts
!= ts
) {
2179 ret
= av_seek_frame(s
, stream_index
, dir
? max_ts
: min_ts
, flags
| dir
);
2181 ret
= av_seek_frame(s
, stream_index
, ts
, flags
| (dir
^AVSEEK_FLAG_BACKWARD
));
2186 // try some generic seek like seek_frame_generic() but with new ts semantics
2187 return -1; //unreachable
2190 /*******************************************************/
2193 * Return TRUE if the stream has accurate duration in any stream.
2195 * @return TRUE if the stream has accurate duration for at least one component.
2197 static int has_duration(AVFormatContext
*ic
)
2202 for (i
= 0; i
< ic
->nb_streams
; i
++) {
2203 st
= ic
->streams
[i
];
2204 if (st
->duration
!= AV_NOPTS_VALUE
)
2207 if (ic
->duration
!= AV_NOPTS_VALUE
)
2213 * Estimate the stream timings from the one of each components.
2215 * Also computes the global bitrate if possible.
2217 static void update_stream_timings(AVFormatContext
*ic
)
2219 int64_t start_time
, start_time1
, start_time_text
, end_time
, end_time1
;
2220 int64_t duration
, duration1
, filesize
;
2225 start_time
= INT64_MAX
;
2226 start_time_text
= INT64_MAX
;
2227 end_time
= INT64_MIN
;
2228 duration
= INT64_MIN
;
2229 for (i
= 0; i
< ic
->nb_streams
; i
++) {
2230 st
= ic
->streams
[i
];
2231 if (st
->start_time
!= AV_NOPTS_VALUE
&& st
->time_base
.den
) {
2232 start_time1
= av_rescale_q(st
->start_time
, st
->time_base
,
2234 if (st
->codec
->codec_type
== AVMEDIA_TYPE_SUBTITLE
|| st
->codec
->codec_type
== AVMEDIA_TYPE_DATA
) {
2235 if (start_time1
< start_time_text
)
2236 start_time_text
= start_time1
;
2238 start_time
= FFMIN(start_time
, start_time1
);
2239 end_time1
= AV_NOPTS_VALUE
;
2240 if (st
->duration
!= AV_NOPTS_VALUE
) {
2241 end_time1
= start_time1
+
2242 av_rescale_q(st
->duration
, st
->time_base
,
2244 end_time
= FFMAX(end_time
, end_time1
);
2246 for (p
= NULL
; (p
= av_find_program_from_stream(ic
, p
, i
)); ) {
2247 if (p
->start_time
== AV_NOPTS_VALUE
|| p
->start_time
> start_time1
)
2248 p
->start_time
= start_time1
;
2249 if (p
->end_time
< end_time1
)
2250 p
->end_time
= end_time1
;
2253 if (st
->duration
!= AV_NOPTS_VALUE
) {
2254 duration1
= av_rescale_q(st
->duration
, st
->time_base
,
2256 duration
= FFMAX(duration
, duration1
);
2259 if (start_time
== INT64_MAX
|| (start_time
> start_time_text
&& start_time
- start_time_text
< AV_TIME_BASE
))
2260 start_time
= start_time_text
;
2261 else if (start_time
> start_time_text
)
2262 av_log(ic
, AV_LOG_VERBOSE
, "Ignoring outlier non primary stream starttime %f\n", start_time_text
/ (float)AV_TIME_BASE
);
2264 if (start_time
!= INT64_MAX
) {
2265 ic
->start_time
= start_time
;
2266 if (end_time
!= INT64_MIN
) {
2267 if (ic
->nb_programs
) {
2268 for (i
= 0; i
< ic
->nb_programs
; i
++) {
2269 p
= ic
->programs
[i
];
2270 if (p
->start_time
!= AV_NOPTS_VALUE
&& p
->end_time
> p
->start_time
)
2271 duration
= FFMAX(duration
, p
->end_time
- p
->start_time
);
2274 duration
= FFMAX(duration
, end_time
- start_time
);
2277 if (duration
!= INT64_MIN
&& duration
> 0 && ic
->duration
== AV_NOPTS_VALUE
) {
2278 ic
->duration
= duration
;
2280 if (ic
->pb
&& (filesize
= avio_size(ic
->pb
)) > 0 && ic
->duration
!= AV_NOPTS_VALUE
) {
2281 /* compute the bitrate */
2282 double bitrate
= (double) filesize
* 8.0 * AV_TIME_BASE
/
2283 (double) ic
->duration
;
2284 if (bitrate
>= 0 && bitrate
<= INT_MAX
)
2285 ic
->bit_rate
= bitrate
;
2289 static void fill_all_stream_timings(AVFormatContext
*ic
)
2294 update_stream_timings(ic
);
2295 for (i
= 0; i
< ic
->nb_streams
; i
++) {
2296 st
= ic
->streams
[i
];
2297 if (st
->start_time
== AV_NOPTS_VALUE
) {
2298 if (ic
->start_time
!= AV_NOPTS_VALUE
)
2299 st
->start_time
= av_rescale_q(ic
->start_time
, AV_TIME_BASE_Q
,
2301 if (ic
->duration
!= AV_NOPTS_VALUE
)
2302 st
->duration
= av_rescale_q(ic
->duration
, AV_TIME_BASE_Q
,
2308 static void estimate_timings_from_bit_rate(AVFormatContext
*ic
)
2310 int64_t filesize
, duration
;
2311 int i
, show_warning
= 0;
2314 /* if bit_rate is already set, we believe it */
2315 if (ic
->bit_rate
<= 0) {
2317 for (i
= 0; i
< ic
->nb_streams
; i
++) {
2318 st
= ic
->streams
[i
];
2319 if (st
->codec
->bit_rate
> 0) {
2320 if (INT_MAX
- st
->codec
->bit_rate
< bit_rate
) {
2324 bit_rate
+= st
->codec
->bit_rate
;
2327 ic
->bit_rate
= bit_rate
;
2330 /* if duration is already set, we believe it */
2331 if (ic
->duration
== AV_NOPTS_VALUE
&&
2332 ic
->bit_rate
!= 0) {
2333 filesize
= ic
->pb
? avio_size(ic
->pb
) : 0;
2334 if (filesize
> ic
->data_offset
) {
2335 filesize
-= ic
->data_offset
;
2336 for (i
= 0; i
< ic
->nb_streams
; i
++) {
2337 st
= ic
->streams
[i
];
2338 if ( st
->time_base
.num
<= INT64_MAX
/ ic
->bit_rate
2339 && st
->duration
== AV_NOPTS_VALUE
) {
2340 duration
= av_rescale(8 * filesize
, st
->time_base
.den
,
2342 (int64_t) st
->time_base
.num
);
2343 st
->duration
= duration
;
2350 av_log(ic
, AV_LOG_WARNING
,
2351 "Estimating duration from bitrate, this may be inaccurate\n");
2354 #define DURATION_MAX_READ_SIZE 250000LL
2355 #define DURATION_MAX_RETRY 4
2357 /* only usable for MPEG-PS streams */
2358 static void estimate_timings_from_pts(AVFormatContext
*ic
, int64_t old_offset
)
2360 AVPacket pkt1
, *pkt
= &pkt1
;
2362 int num
, den
, read_size
, i
, ret
;
2363 int found_duration
= 0;
2365 int64_t filesize
, offset
, duration
;
2368 /* flush packet queue */
2369 flush_packet_queue(ic
);
2371 for (i
= 0; i
< ic
->nb_streams
; i
++) {
2372 st
= ic
->streams
[i
];
2373 if (st
->start_time
== AV_NOPTS_VALUE
&&
2374 st
->first_dts
== AV_NOPTS_VALUE
&&
2375 st
->codec
->codec_type
!= AVMEDIA_TYPE_UNKNOWN
)
2376 av_log(st
->codec
, AV_LOG_WARNING
,
2377 "start time for stream %d is not set in estimate_timings_from_pts\n", i
);
2380 av_parser_close(st
->parser
);
2385 av_opt_set(ic
, "skip_changes", "1", AV_OPT_SEARCH_CHILDREN
);
2386 /* estimate the end time (duration) */
2387 /* XXX: may need to support wrapping */
2388 filesize
= ic
->pb
? avio_size(ic
->pb
) : 0;
2390 is_end
= found_duration
;
2391 offset
= filesize
- (DURATION_MAX_READ_SIZE
<< retry
);
2395 avio_seek(ic
->pb
, offset
, SEEK_SET
);
2398 if (read_size
>= DURATION_MAX_READ_SIZE
<< (FFMAX(retry
- 1, 0)))
2402 ret
= ff_read_packet(ic
, pkt
);
2403 } while (ret
== AVERROR(EAGAIN
));
2406 read_size
+= pkt
->size
;
2407 st
= ic
->streams
[pkt
->stream_index
];
2408 if (pkt
->pts
!= AV_NOPTS_VALUE
&&
2409 (st
->start_time
!= AV_NOPTS_VALUE
||
2410 st
->first_dts
!= AV_NOPTS_VALUE
)) {
2411 if (pkt
->duration
== 0) {
2412 ff_compute_frame_duration(ic
, &num
, &den
, st
, st
->parser
, pkt
);
2414 pkt
->duration
= av_rescale_rnd(1,
2415 num
* (int64_t) st
->time_base
.den
,
2416 den
* (int64_t) st
->time_base
.num
,
2420 duration
= pkt
->pts
+ pkt
->duration
;
2422 if (st
->start_time
!= AV_NOPTS_VALUE
)
2423 duration
-= st
->start_time
;
2425 duration
-= st
->first_dts
;
2427 if (st
->duration
== AV_NOPTS_VALUE
|| st
->info
->last_duration
<= 0 ||
2428 (st
->duration
< duration
&& FFABS(duration
- st
->info
->last_duration
) < 60LL*st
->time_base
.den
/ st
->time_base
.num
))
2429 st
->duration
= duration
;
2430 st
->info
->last_duration
= duration
;
2433 av_free_packet(pkt
);
2436 /* check if all audio/video streams have valid duration */
2439 for (i
= 0; i
< ic
->nb_streams
; i
++) {
2440 st
= ic
->streams
[i
];
2441 switch (st
->codec
->codec_type
) {
2442 case AVMEDIA_TYPE_VIDEO
:
2443 case AVMEDIA_TYPE_AUDIO
:
2444 if (st
->duration
== AV_NOPTS_VALUE
)
2451 ++retry
<= DURATION_MAX_RETRY
);
2453 av_opt_set(ic
, "skip_changes", "0", AV_OPT_SEARCH_CHILDREN
);
2455 /* warn about audio/video streams which duration could not be estimated */
2456 for (i
= 0; i
< ic
->nb_streams
; i
++) {
2457 st
= ic
->streams
[i
];
2458 if (st
->duration
== AV_NOPTS_VALUE
) {
2459 switch (st
->codec
->codec_type
) {
2460 case AVMEDIA_TYPE_VIDEO
:
2461 case AVMEDIA_TYPE_AUDIO
:
2462 if (st
->start_time
!= AV_NOPTS_VALUE
|| st
->first_dts
!= AV_NOPTS_VALUE
) {
2463 av_log(ic
, AV_LOG_DEBUG
, "stream %d : no PTS found at end of file, duration not set\n", i
);
2465 av_log(ic
, AV_LOG_DEBUG
, "stream %d : no TS found at start of file, duration not set\n", i
);
2469 fill_all_stream_timings(ic
);
2471 avio_seek(ic
->pb
, old_offset
, SEEK_SET
);
2472 for (i
= 0; i
< ic
->nb_streams
; i
++) {
2475 st
= ic
->streams
[i
];
2476 st
->cur_dts
= st
->first_dts
;
2477 st
->last_IP_pts
= AV_NOPTS_VALUE
;
2478 st
->last_dts_for_order_check
= AV_NOPTS_VALUE
;
2479 for (j
= 0; j
< MAX_REORDER_DELAY
+ 1; j
++)
2480 st
->pts_buffer
[j
] = AV_NOPTS_VALUE
;
2484 static void estimate_timings(AVFormatContext
*ic
, int64_t old_offset
)
2488 /* get the file size, if possible */
2489 if (ic
->iformat
->flags
& AVFMT_NOFILE
) {
2492 file_size
= avio_size(ic
->pb
);
2493 file_size
= FFMAX(0, file_size
);
2496 if ((!strcmp(ic
->iformat
->name
, "mpeg") ||
2497 !strcmp(ic
->iformat
->name
, "mpegts")) &&
2498 file_size
&& ic
->pb
->seekable
) {
2499 /* get accurate estimate from the PTSes */
2500 estimate_timings_from_pts(ic
, old_offset
);
2501 ic
->duration_estimation_method
= AVFMT_DURATION_FROM_PTS
;
2502 } else if (has_duration(ic
)) {
2503 /* at least one component has timings - we use them for all
2505 fill_all_stream_timings(ic
);
2506 ic
->duration_estimation_method
= AVFMT_DURATION_FROM_STREAM
;
2508 /* less precise: use bitrate info */
2509 estimate_timings_from_bit_rate(ic
);
2510 ic
->duration_estimation_method
= AVFMT_DURATION_FROM_BITRATE
;
2512 update_stream_timings(ic
);
2516 AVStream av_unused
*st
;
2517 for (i
= 0; i
< ic
->nb_streams
; i
++) {
2518 st
= ic
->streams
[i
];
2519 av_dlog(ic
, "%d: start_time: %0.3f duration: %0.3f\n", i
,
2520 (double) st
->start_time
/ AV_TIME_BASE
,
2521 (double) st
->duration
/ AV_TIME_BASE
);
2524 "stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2525 (double) ic
->start_time
/ AV_TIME_BASE
,
2526 (double) ic
->duration
/ AV_TIME_BASE
,
2527 ic
->bit_rate
/ 1000);
2531 static int has_codec_parameters(AVStream
*st
, const char **errmsg_ptr
)
2533 AVCodecContext
*avctx
= st
->codec
;
2535 #define FAIL(errmsg) do { \
2537 *errmsg_ptr = errmsg; \
2541 if ( avctx
->codec_id
== AV_CODEC_ID_NONE
2542 && avctx
->codec_type
!= AVMEDIA_TYPE_DATA
)
2543 FAIL("unknown codec");
2544 switch (avctx
->codec_type
) {
2545 case AVMEDIA_TYPE_AUDIO
:
2546 if (!avctx
->frame_size
&& determinable_frame_size(avctx
))
2547 FAIL("unspecified frame size");
2548 if (st
->info
->found_decoder
>= 0 &&
2549 avctx
->sample_fmt
== AV_SAMPLE_FMT_NONE
)
2550 FAIL("unspecified sample format");
2551 if (!avctx
->sample_rate
)
2552 FAIL("unspecified sample rate");
2553 if (!avctx
->channels
)
2554 FAIL("unspecified number of channels");
2555 if (st
->info
->found_decoder
>= 0 && !st
->nb_decoded_frames
&& avctx
->codec_id
== AV_CODEC_ID_DTS
)
2556 FAIL("no decodable DTS frames");
2558 case AVMEDIA_TYPE_VIDEO
:
2560 FAIL("unspecified size");
2561 if (st
->info
->found_decoder
>= 0 && avctx
->pix_fmt
== AV_PIX_FMT_NONE
)
2562 FAIL("unspecified pixel format");
2563 if (st
->codec
->codec_id
== AV_CODEC_ID_RV30
|| st
->codec
->codec_id
== AV_CODEC_ID_RV40
)
2564 if (!st
->sample_aspect_ratio
.num
&& !st
->codec
->sample_aspect_ratio
.num
&& !st
->codec_info_nb_frames
)
2565 FAIL("no frame in rv30/40 and no sar");
2567 case AVMEDIA_TYPE_SUBTITLE
:
2568 if (avctx
->codec_id
== AV_CODEC_ID_HDMV_PGS_SUBTITLE
&& !avctx
->width
)
2569 FAIL("unspecified size");
2571 case AVMEDIA_TYPE_DATA
:
2572 if (avctx
->codec_id
== AV_CODEC_ID_NONE
) return 1;
2578 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
2579 static int try_decode_frame(AVFormatContext
*s
, AVStream
*st
, AVPacket
*avpkt
,
2580 AVDictionary
**options
)
2582 const AVCodec
*codec
;
2583 int got_picture
= 1, ret
= 0;
2584 AVFrame
*frame
= av_frame_alloc();
2585 AVSubtitle subtitle
;
2586 AVPacket pkt
= *avpkt
;
2589 return AVERROR(ENOMEM
);
2591 if (!avcodec_is_open(st
->codec
) &&
2592 st
->info
->found_decoder
<= 0 &&
2593 (st
->codec
->codec_id
!= -st
->info
->found_decoder
|| !st
->codec
->codec_id
)) {
2594 AVDictionary
*thread_opt
= NULL
;
2596 codec
= find_decoder(s
, st
, st
->codec
->codec_id
);
2599 st
->info
->found_decoder
= -st
->codec
->codec_id
;
2604 /* Force thread count to 1 since the H.264 decoder will not extract
2605 * SPS and PPS to extradata during multi-threaded decoding. */
2606 av_dict_set(options
? options
: &thread_opt
, "threads", "1", 0);
2607 if (s
->codec_whitelist
)
2608 av_dict_set(options
? options
: &thread_opt
, "codec_whitelist", s
->codec_whitelist
, 0);
2609 ret
= avcodec_open2(st
->codec
, codec
, options
? options
: &thread_opt
);
2611 av_dict_free(&thread_opt
);
2613 st
->info
->found_decoder
= -st
->codec
->codec_id
;
2616 st
->info
->found_decoder
= 1;
2617 } else if (!st
->info
->found_decoder
)
2618 st
->info
->found_decoder
= 1;
2620 if (st
->info
->found_decoder
< 0) {
2625 while ((pkt
.size
> 0 || (!pkt
.data
&& got_picture
)) &&
2627 (!has_codec_parameters(st
, NULL
) || !has_decode_delay_been_guessed(st
) ||
2628 (!st
->codec_info_nb_frames
&&
2629 st
->codec
->codec
->capabilities
& CODEC_CAP_CHANNEL_CONF
))) {
2631 switch (st
->codec
->codec_type
) {
2632 case AVMEDIA_TYPE_VIDEO
:
2633 ret
= avcodec_decode_video2(st
->codec
, frame
,
2634 &got_picture
, &pkt
);
2636 case AVMEDIA_TYPE_AUDIO
:
2637 ret
= avcodec_decode_audio4(st
->codec
, frame
, &got_picture
, &pkt
);
2639 case AVMEDIA_TYPE_SUBTITLE
:
2640 ret
= avcodec_decode_subtitle2(st
->codec
, &subtitle
,
2641 &got_picture
, &pkt
);
2649 st
->nb_decoded_frames
++;
2656 if (!pkt
.data
&& !got_picture
)
2660 av_frame_free(&frame
);
2664 unsigned int ff_codec_get_tag(const AVCodecTag
*tags
, enum AVCodecID id
)
2666 while (tags
->id
!= AV_CODEC_ID_NONE
) {
2674 enum AVCodecID
ff_codec_get_id(const AVCodecTag
*tags
, unsigned int tag
)
2677 for (i
= 0; tags
[i
].id
!= AV_CODEC_ID_NONE
; i
++)
2678 if (tag
== tags
[i
].tag
)
2680 for (i
= 0; tags
[i
].id
!= AV_CODEC_ID_NONE
; i
++)
2681 if (avpriv_toupper4(tag
) == avpriv_toupper4(tags
[i
].tag
))
2683 return AV_CODEC_ID_NONE
;
2686 enum AVCodecID
ff_get_pcm_codec_id(int bps
, int flt
, int be
, int sflags
)
2691 return be
? AV_CODEC_ID_PCM_F32BE
: AV_CODEC_ID_PCM_F32LE
;
2693 return be
? AV_CODEC_ID_PCM_F64BE
: AV_CODEC_ID_PCM_F64LE
;
2695 return AV_CODEC_ID_NONE
;
2700 if (sflags
& (1 << (bps
- 1))) {
2703 return AV_CODEC_ID_PCM_S8
;
2705 return be
? AV_CODEC_ID_PCM_S16BE
: AV_CODEC_ID_PCM_S16LE
;
2707 return be
? AV_CODEC_ID_PCM_S24BE
: AV_CODEC_ID_PCM_S24LE
;
2709 return be
? AV_CODEC_ID_PCM_S32BE
: AV_CODEC_ID_PCM_S32LE
;
2711 return AV_CODEC_ID_NONE
;
2716 return AV_CODEC_ID_PCM_U8
;
2718 return be
? AV_CODEC_ID_PCM_U16BE
: AV_CODEC_ID_PCM_U16LE
;
2720 return be
? AV_CODEC_ID_PCM_U24BE
: AV_CODEC_ID_PCM_U24LE
;
2722 return be
? AV_CODEC_ID_PCM_U32BE
: AV_CODEC_ID_PCM_U32LE
;
2724 return AV_CODEC_ID_NONE
;
2730 unsigned int av_codec_get_tag(const AVCodecTag
*const *tags
, enum AVCodecID id
)
2733 if (!av_codec_get_tag2(tags
, id
, &tag
))
2738 int av_codec_get_tag2(const AVCodecTag
* const *tags
, enum AVCodecID id
,
2742 for (i
= 0; tags
&& tags
[i
]; i
++) {
2743 const AVCodecTag
*codec_tags
= tags
[i
];
2744 while (codec_tags
->id
!= AV_CODEC_ID_NONE
) {
2745 if (codec_tags
->id
== id
) {
2746 *tag
= codec_tags
->tag
;
2755 enum AVCodecID
av_codec_get_id(const AVCodecTag
*const *tags
, unsigned int tag
)
2758 for (i
= 0; tags
&& tags
[i
]; i
++) {
2759 enum AVCodecID id
= ff_codec_get_id(tags
[i
], tag
);
2760 if (id
!= AV_CODEC_ID_NONE
)
2763 return AV_CODEC_ID_NONE
;
2766 static void compute_chapters_end(AVFormatContext
*s
)
2769 int64_t max_time
= s
->duration
+
2770 ((s
->start_time
== AV_NOPTS_VALUE
) ? 0 : s
->start_time
);
2772 for (i
= 0; i
< s
->nb_chapters
; i
++)
2773 if (s
->chapters
[i
]->end
== AV_NOPTS_VALUE
) {
2774 AVChapter
*ch
= s
->chapters
[i
];
2775 int64_t end
= max_time
? av_rescale_q(max_time
, AV_TIME_BASE_Q
,
2779 for (j
= 0; j
< s
->nb_chapters
; j
++) {
2780 AVChapter
*ch1
= s
->chapters
[j
];
2781 int64_t next_start
= av_rescale_q(ch1
->start
, ch1
->time_base
,
2783 if (j
!= i
&& next_start
> ch
->start
&& next_start
< end
)
2786 ch
->end
= (end
== INT64_MAX
) ? ch
->start
: end
;
2790 static int get_std_framerate(int i
)
2793 return (i
+ 1) * 1001;
2797 return ((const int[]) { 40, 48, 50, 60, 80, 120, 240})[i
] * 1001 * 12;
2801 return ((const int[]) { 24, 30, 60, 12, 15, 48 })[i
] * 1000 * 12;
2804 /* Is the time base unreliable?
2805 * This is a heuristic to balance between quick acceptance of the values in
2806 * the headers vs. some extra checks.
2807 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2808 * MPEG-2 commonly misuses field repeat flags to store different framerates.
2809 * And there are "variable" fps files this needs to detect as well. */
2810 static int tb_unreliable(AVCodecContext
*c
)
2812 if (c
->time_base
.den
>= 101L * c
->time_base
.num
||
2813 c
->time_base
.den
< 5L * c
->time_base
.num
||
2814 // c->codec_tag == AV_RL32("DIVX") ||
2815 // c->codec_tag == AV_RL32("XVID") ||
2816 c
->codec_tag
== AV_RL32("mp4v") ||
2817 c
->codec_id
== AV_CODEC_ID_MPEG2VIDEO
||
2818 c
->codec_id
== AV_CODEC_ID_GIF
||
2819 c
->codec_id
== AV_CODEC_ID_H264
)
2824 int ff_alloc_extradata(AVCodecContext
*avctx
, int size
)
2828 if (size
< 0 || size
>= INT32_MAX
- FF_INPUT_BUFFER_PADDING_SIZE
) {
2829 avctx
->extradata_size
= 0;
2830 return AVERROR(EINVAL
);
2832 avctx
->extradata
= av_malloc(size
+ FF_INPUT_BUFFER_PADDING_SIZE
);
2833 if (avctx
->extradata
) {
2834 memset(avctx
->extradata
+ size
, 0, FF_INPUT_BUFFER_PADDING_SIZE
);
2835 avctx
->extradata_size
= size
;
2838 avctx
->extradata_size
= 0;
2839 ret
= AVERROR(ENOMEM
);
2844 int ff_get_extradata(AVCodecContext
*avctx
, AVIOContext
*pb
, int size
)
2846 int ret
= ff_alloc_extradata(avctx
, size
);
2849 ret
= avio_read(pb
, avctx
->extradata
, size
);
2851 av_freep(&avctx
->extradata
);
2852 avctx
->extradata_size
= 0;
2853 av_log(avctx
, AV_LOG_ERROR
, "Failed to read extradata of size %d\n", size
);
2854 return ret
< 0 ? ret
: AVERROR_INVALIDDATA
;
2860 int ff_rfps_add_frame(AVFormatContext
*ic
, AVStream
*st
, int64_t ts
)
2863 int64_t last
= st
->info
->last_dts
;
2865 if ( ts
!= AV_NOPTS_VALUE
&& last
!= AV_NOPTS_VALUE
&& ts
> last
2866 && ts
- (uint64_t)last
< INT64_MAX
) {
2867 double dts
= (is_relative(ts
) ? ts
- RELATIVE_TS_BASE
: ts
) * av_q2d(st
->time_base
);
2868 int64_t duration
= ts
- last
;
2870 if (!st
->info
->duration_error
)
2871 st
->info
->duration_error
= av_mallocz(sizeof(st
->info
->duration_error
[0])*2);
2872 if (!st
->info
->duration_error
)
2873 return AVERROR(ENOMEM
);
2875 // if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2876 // av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
2877 for (i
= 0; i
<MAX_STD_TIMEBASES
; i
++) {
2878 if (st
->info
->duration_error
[0][1][i
] < 1e10
) {
2879 int framerate
= get_std_framerate(i
);
2880 double sdts
= dts
*framerate
/(1001*12);
2881 for (j
= 0; j
<2; j
++) {
2882 int64_t ticks
= llrint(sdts
+j
*0.5);
2883 double error
= sdts
- ticks
+ j
*0.5;
2884 st
->info
->duration_error
[j
][0][i
] += error
;
2885 st
->info
->duration_error
[j
][1][i
] += error
*error
;
2889 st
->info
->duration_count
++;
2890 st
->info
->rfps_duration_sum
+= duration
;
2892 if (st
->info
->duration_count
% 10 == 0) {
2893 int n
= st
->info
->duration_count
;
2894 for (i
= 0; i
<MAX_STD_TIMEBASES
; i
++) {
2895 if (st
->info
->duration_error
[0][1][i
] < 1e10
) {
2896 double a0
= st
->info
->duration_error
[0][0][i
] / n
;
2897 double error0
= st
->info
->duration_error
[0][1][i
] / n
- a0
*a0
;
2898 double a1
= st
->info
->duration_error
[1][0][i
] / n
;
2899 double error1
= st
->info
->duration_error
[1][1][i
] / n
- a1
*a1
;
2900 if (error0
> 0.04 && error1
> 0.04) {
2901 st
->info
->duration_error
[0][1][i
] = 2e10
;
2902 st
->info
->duration_error
[1][1][i
] = 2e10
;
2908 // ignore the first 4 values, they might have some random jitter
2909 if (st
->info
->duration_count
> 3 && is_relative(ts
) == is_relative(last
))
2910 st
->info
->duration_gcd
= av_gcd(st
->info
->duration_gcd
, duration
);
2912 if (ts
!= AV_NOPTS_VALUE
)
2913 st
->info
->last_dts
= ts
;
2918 void ff_rfps_calculate(AVFormatContext
*ic
)
2922 for (i
= 0; i
< ic
->nb_streams
; i
++) {
2923 AVStream
*st
= ic
->streams
[i
];
2925 if (st
->codec
->codec_type
!= AVMEDIA_TYPE_VIDEO
)
2927 // the check for tb_unreliable() is not completely correct, since this is not about handling
2928 // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2929 // ipmovie.c produces.
2930 if (tb_unreliable(st
->codec
) && st
->info
->duration_count
> 15 && st
->info
->duration_gcd
> FFMAX(1, st
->time_base
.den
/(500LL*st
->time_base
.num
)) && !st
->r_frame_rate
.num
)
2931 av_reduce(&st
->r_frame_rate
.num
, &st
->r_frame_rate
.den
, st
->time_base
.den
, st
->time_base
.num
* st
->info
->duration_gcd
, INT_MAX
);
2932 if (st
->info
->duration_count
>1 && !st
->r_frame_rate
.num
2933 && tb_unreliable(st
->codec
)) {
2935 double best_error
= 0.01;
2936 AVRational ref_rate
= st
->r_frame_rate
.num
? st
->r_frame_rate
: av_inv_q(st
->time_base
);
2938 for (j
= 0; j
<MAX_STD_TIMEBASES
; j
++) {
2941 if (st
->info
->codec_info_duration
&& st
->info
->codec_info_duration
*av_q2d(st
->time_base
) < (1001*12.0)/get_std_framerate(j
))
2943 if (!st
->info
->codec_info_duration
&& 1.0 < (1001*12.0)/get_std_framerate(j
))
2946 if (av_q2d(st
->time_base
) * st
->info
->rfps_duration_sum
/ st
->info
->duration_count
< (1001*12.0 * 0.8)/get_std_framerate(j
))
2949 for (k
= 0; k
<2; k
++) {
2950 int n
= st
->info
->duration_count
;
2951 double a
= st
->info
->duration_error
[k
][0][j
] / n
;
2952 double error
= st
->info
->duration_error
[k
][1][j
]/n
- a
*a
;
2954 if (error
< best_error
&& best_error
> 0.000000001) {
2956 num
= get_std_framerate(j
);
2959 av_log(NULL
, AV_LOG_DEBUG
, "rfps: %f %f\n", get_std_framerate(j
) / 12.0/1001, error
);
2962 // do not increase frame rate by more than 1 % in order to match a standard rate.
2963 if (num
&& (!ref_rate
.num
|| (double)num
/(12*1001) < 1.01 * av_q2d(ref_rate
)))
2964 av_reduce(&st
->r_frame_rate
.num
, &st
->r_frame_rate
.den
, num
, 12*1001, INT_MAX
);
2966 if ( !st
->avg_frame_rate
.num
2967 && st
->r_frame_rate
.num
&& st
->info
->rfps_duration_sum
2968 && st
->info
->codec_info_duration
<= 0
2969 && st
->info
->duration_count
> 2
2970 && fabs(1.0 / (av_q2d(st
->r_frame_rate
) * av_q2d(st
->time_base
)) - st
->info
->rfps_duration_sum
/ (double)st
->info
->duration_count
) <= 1.0
2972 av_log(ic
, AV_LOG_DEBUG
, "Setting avg frame rate based on r frame rate\n");
2973 st
->avg_frame_rate
= st
->r_frame_rate
;
2976 av_freep(&st
->info
->duration_error
);
2977 st
->info
->last_dts
= AV_NOPTS_VALUE
;
2978 st
->info
->duration_count
= 0;
2979 st
->info
->rfps_duration_sum
= 0;
2983 int avformat_find_stream_info(AVFormatContext
*ic
, AVDictionary
**options
)
2985 int i
, count
, ret
= 0, j
;
2988 AVPacket pkt1
, *pkt
;
2989 int64_t old_offset
= avio_tell(ic
->pb
);
2990 // new streams might appear, no options for those
2991 int orig_nb_streams
= ic
->nb_streams
;
2993 int64_t max_analyze_duration
= ic
->max_analyze_duration2
;
2994 int64_t max_stream_analyze_duration
;
2995 int64_t probesize
= ic
->probesize2
;
2997 if (!max_analyze_duration
)
2998 max_analyze_duration
= ic
->max_analyze_duration
;
3000 probesize
= ic
->probesize
;
3001 flush_codecs
= probesize
> 0;
3003 av_opt_set(ic
, "skip_clear", "1", AV_OPT_SEARCH_CHILDREN
);
3005 max_stream_analyze_duration
= max_analyze_duration
;
3006 if (!max_analyze_duration
) {
3007 max_stream_analyze_duration
=
3008 max_analyze_duration
= 5*AV_TIME_BASE
;
3009 if (!strcmp(ic
->iformat
->name
, "flv"))
3010 max_stream_analyze_duration
= 30*AV_TIME_BASE
;
3014 av_log(ic
, AV_LOG_DEBUG
, "Before avformat_find_stream_info() pos: %"PRId64
" bytes read:%"PRId64
" seeks:%d\n",
3015 avio_tell(ic
->pb
), ic
->pb
->bytes_read
, ic
->pb
->seek_count
);
3017 for (i
= 0; i
< ic
->nb_streams
; i
++) {
3018 const AVCodec
*codec
;
3019 AVDictionary
*thread_opt
= NULL
;
3020 st
= ic
->streams
[i
];
3022 if (st
->codec
->codec_type
== AVMEDIA_TYPE_VIDEO
||
3023 st
->codec
->codec_type
== AVMEDIA_TYPE_SUBTITLE
) {
3024 /* if (!st->time_base.num)
3026 if (!st
->codec
->time_base
.num
)
3027 st
->codec
->time_base
= st
->time_base
;
3029 // only for the split stuff
3030 if (!st
->parser
&& !(ic
->flags
& AVFMT_FLAG_NOPARSE
)) {
3031 st
->parser
= av_parser_init(st
->codec
->codec_id
);
3033 if (st
->need_parsing
== AVSTREAM_PARSE_HEADERS
) {
3034 st
->parser
->flags
|= PARSER_FLAG_COMPLETE_FRAMES
;
3035 } else if (st
->need_parsing
== AVSTREAM_PARSE_FULL_RAW
) {
3036 st
->parser
->flags
|= PARSER_FLAG_USE_CODEC_TS
;
3038 } else if (st
->need_parsing
) {
3039 av_log(ic
, AV_LOG_VERBOSE
, "parser not found for codec "
3040 "%s, packets or times may be invalid.\n",
3041 avcodec_get_name(st
->codec
->codec_id
));
3044 codec
= find_decoder(ic
, st
, st
->codec
->codec_id
);
3046 /* Force thread count to 1 since the H.264 decoder will not extract
3047 * SPS and PPS to extradata during multi-threaded decoding. */
3048 av_dict_set(options
? &options
[i
] : &thread_opt
, "threads", "1", 0);
3050 if (ic
->codec_whitelist
)
3051 av_dict_set(options
? &options
[i
] : &thread_opt
, "codec_whitelist", ic
->codec_whitelist
, 0);
3053 /* Ensure that subtitle_header is properly set. */
3054 if (st
->codec
->codec_type
== AVMEDIA_TYPE_SUBTITLE
3055 && codec
&& !st
->codec
->codec
) {
3056 if (avcodec_open2(st
->codec
, codec
, options
? &options
[i
] : &thread_opt
) < 0)
3057 av_log(ic
, AV_LOG_WARNING
,
3058 "Failed to open codec in av_find_stream_info\n");
3061 // Try to just open decoders, in case this is enough to get parameters.
3062 if (!has_codec_parameters(st
, NULL
) && st
->request_probe
<= 0) {
3063 if (codec
&& !st
->codec
->codec
)
3064 if (avcodec_open2(st
->codec
, codec
, options
? &options
[i
] : &thread_opt
) < 0)
3065 av_log(ic
, AV_LOG_WARNING
,
3066 "Failed to open codec in av_find_stream_info\n");
3069 av_dict_free(&thread_opt
);
3072 for (i
= 0; i
< ic
->nb_streams
; i
++) {
3073 #if FF_API_R_FRAME_RATE
3074 ic
->streams
[i
]->info
->last_dts
= AV_NOPTS_VALUE
;
3076 ic
->streams
[i
]->info
->fps_first_dts
= AV_NOPTS_VALUE
;
3077 ic
->streams
[i
]->info
->fps_last_dts
= AV_NOPTS_VALUE
;
3083 int analyzed_all_streams
;
3084 if (ff_check_interrupt(&ic
->interrupt_callback
)) {
3086 av_log(ic
, AV_LOG_DEBUG
, "interrupted\n");
3090 /* check if one codec still needs to be handled */
3091 for (i
= 0; i
< ic
->nb_streams
; i
++) {
3092 int fps_analyze_framecount
= 20;
3094 st
= ic
->streams
[i
];
3095 if (!has_codec_parameters(st
, NULL
))
3097 /* If the timebase is coarse (like the usual millisecond precision
3098 * of mkv), we need to analyze more frames to reliably arrive at
3099 * the correct fps. */
3100 if (av_q2d(st
->time_base
) > 0.0005)
3101 fps_analyze_framecount
*= 2;
3102 if (!tb_unreliable(st
->codec
))
3103 fps_analyze_framecount
= 0;
3104 if (ic
->fps_probe_size
>= 0)
3105 fps_analyze_framecount
= ic
->fps_probe_size
;
3106 if (st
->disposition
& AV_DISPOSITION_ATTACHED_PIC
)
3107 fps_analyze_framecount
= 0;
3108 /* variable fps and no guess at the real fps */
3109 if (!(st
->r_frame_rate
.num
&& st
->avg_frame_rate
.num
) &&
3110 st
->info
->duration_count
< fps_analyze_framecount
&&
3111 st
->codec
->codec_type
== AVMEDIA_TYPE_VIDEO
)
3113 if (st
->parser
&& st
->parser
->parser
->split
&&
3114 !st
->codec
->extradata
)
3116 if (st
->first_dts
== AV_NOPTS_VALUE
&&
3117 !(ic
->iformat
->flags
& AVFMT_NOTIMESTAMPS
) &&
3118 st
->codec_info_nb_frames
< ic
->max_ts_probe
&&
3119 (st
->codec
->codec_type
== AVMEDIA_TYPE_VIDEO
||
3120 st
->codec
->codec_type
== AVMEDIA_TYPE_AUDIO
))
3123 analyzed_all_streams
= 0;
3124 if (i
== ic
->nb_streams
) {
3125 analyzed_all_streams
= 1;
3126 /* NOTE: If the format has no header, then we need to read some
3127 * packets to get most of the streams, so we cannot stop here. */
3128 if (!(ic
->ctx_flags
& AVFMTCTX_NOHEADER
)) {
3129 /* If we found the info for all the codecs, we can stop. */
3131 av_log(ic
, AV_LOG_DEBUG
, "All info found\n");
3136 /* We did not get all the codec info, but we read too much data. */
3137 if (read_size
>= probesize
) {
3139 av_log(ic
, AV_LOG_DEBUG
,
3140 "Probe buffer size limit of %"PRId64
" bytes reached\n", probesize
);
3141 for (i
= 0; i
< ic
->nb_streams
; i
++)
3142 if (!ic
->streams
[i
]->r_frame_rate
.num
&&
3143 ic
->streams
[i
]->info
->duration_count
<= 1 &&
3144 ic
->streams
[i
]->codec
->codec_type
== AVMEDIA_TYPE_VIDEO
&&
3145 strcmp(ic
->iformat
->name
, "image2"))
3146 av_log(ic
, AV_LOG_WARNING
,
3147 "Stream #%d: not enough frames to estimate rate; "
3148 "consider increasing probesize\n", i
);
3152 /* NOTE: A new stream can be added there if no header in file
3153 * (AVFMTCTX_NOHEADER). */
3154 ret
= read_frame_internal(ic
, &pkt1
);
3155 if (ret
== AVERROR(EAGAIN
))
3163 if (ic
->flags
& AVFMT_FLAG_NOBUFFER
)
3164 free_packet_buffer(&ic
->packet_buffer
, &ic
->packet_buffer_end
);
3166 pkt
= add_to_pktbuf(&ic
->packet_buffer
, &pkt1
,
3167 &ic
->packet_buffer_end
);
3169 ret
= AVERROR(ENOMEM
);
3170 goto find_stream_info_err
;
3172 if ((ret
= av_dup_packet(pkt
)) < 0)
3173 goto find_stream_info_err
;
3176 st
= ic
->streams
[pkt
->stream_index
];
3177 if (!(st
->disposition
& AV_DISPOSITION_ATTACHED_PIC
))
3178 read_size
+= pkt
->size
;
3180 if (pkt
->dts
!= AV_NOPTS_VALUE
&& st
->codec_info_nb_frames
> 1) {
3181 /* check for non-increasing dts */
3182 if (st
->info
->fps_last_dts
!= AV_NOPTS_VALUE
&&
3183 st
->info
->fps_last_dts
>= pkt
->dts
) {
3184 av_log(ic
, AV_LOG_DEBUG
,
3185 "Non-increasing DTS in stream %d: packet %d with DTS "
3186 "%"PRId64
", packet %d with DTS %"PRId64
"\n",
3187 st
->index
, st
->info
->fps_last_dts_idx
,
3188 st
->info
->fps_last_dts
, st
->codec_info_nb_frames
,
3190 st
->info
->fps_first_dts
=
3191 st
->info
->fps_last_dts
= AV_NOPTS_VALUE
;
3193 /* Check for a discontinuity in dts. If the difference in dts
3194 * is more than 1000 times the average packet duration in the
3195 * sequence, we treat it as a discontinuity. */
3196 if (st
->info
->fps_last_dts
!= AV_NOPTS_VALUE
&&
3197 st
->info
->fps_last_dts_idx
> st
->info
->fps_first_dts_idx
&&
3198 (pkt
->dts
- st
->info
->fps_last_dts
) / 1000 >
3199 (st
->info
->fps_last_dts
- st
->info
->fps_first_dts
) /
3200 (st
->info
->fps_last_dts_idx
- st
->info
->fps_first_dts_idx
)) {
3201 av_log(ic
, AV_LOG_WARNING
,
3202 "DTS discontinuity in stream %d: packet %d with DTS "
3203 "%"PRId64
", packet %d with DTS %"PRId64
"\n",
3204 st
->index
, st
->info
->fps_last_dts_idx
,
3205 st
->info
->fps_last_dts
, st
->codec_info_nb_frames
,
3207 st
->info
->fps_first_dts
=
3208 st
->info
->fps_last_dts
= AV_NOPTS_VALUE
;
3211 /* update stored dts values */
3212 if (st
->info
->fps_first_dts
== AV_NOPTS_VALUE
) {
3213 st
->info
->fps_first_dts
= pkt
->dts
;
3214 st
->info
->fps_first_dts_idx
= st
->codec_info_nb_frames
;
3216 st
->info
->fps_last_dts
= pkt
->dts
;
3217 st
->info
->fps_last_dts_idx
= st
->codec_info_nb_frames
;
3219 if (st
->codec_info_nb_frames
>1) {
3222 if (st
->time_base
.den
> 0)
3223 t
= av_rescale_q(st
->info
->codec_info_duration
, st
->time_base
, AV_TIME_BASE_Q
);
3224 if (st
->avg_frame_rate
.num
> 0)
3225 t
= FFMAX(t
, av_rescale_q(st
->codec_info_nb_frames
, av_inv_q(st
->avg_frame_rate
), AV_TIME_BASE_Q
));
3228 && st
->codec_info_nb_frames
>30
3229 && st
->info
->fps_first_dts
!= AV_NOPTS_VALUE
3230 && st
->info
->fps_last_dts
!= AV_NOPTS_VALUE
)
3231 t
= FFMAX(t
, av_rescale_q(st
->info
->fps_last_dts
- st
->info
->fps_first_dts
, st
->time_base
, AV_TIME_BASE_Q
));
3233 if (t
>= (analyzed_all_streams
? max_analyze_duration
: max_stream_analyze_duration
)) {
3234 av_log(ic
, AV_LOG_VERBOSE
, "max_analyze_duration %"PRId64
" reached at %"PRId64
" microseconds\n",
3235 max_analyze_duration
,
3237 if (ic
->flags
& AVFMT_FLAG_NOBUFFER
)
3238 av_packet_unref(pkt
);
3241 if (pkt
->duration
) {
3242 st
->info
->codec_info_duration
+= pkt
->duration
;
3243 st
->info
->codec_info_duration_fields
+= st
->parser
&& st
->need_parsing
&& st
->codec
->ticks_per_frame
==2 ? st
->parser
->repeat_pict
+ 1 : 2;
3246 #if FF_API_R_FRAME_RATE
3247 if (st
->codec
->codec_type
== AVMEDIA_TYPE_VIDEO
)
3248 ff_rfps_add_frame(ic
, st
, pkt
->dts
);
3250 if (st
->parser
&& st
->parser
->parser
->split
&& !st
->codec
->extradata
) {
3251 int i
= st
->parser
->parser
->split(st
->codec
, pkt
->data
, pkt
->size
);
3252 if (i
> 0 && i
< FF_MAX_EXTRADATA_SIZE
) {
3253 if (ff_alloc_extradata(st
->codec
, i
))
3254 return AVERROR(ENOMEM
);
3255 memcpy(st
->codec
->extradata
, pkt
->data
,
3256 st
->codec
->extradata_size
);
3260 /* If still no information, we try to open the codec and to
3261 * decompress the frame. We try to avoid that in most cases as
3262 * it takes longer and uses more memory. For MPEG-4, we need to
3263 * decompress for QuickTime.
3265 * If CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
3266 * least one frame of codec data, this makes sure the codec initializes
3267 * the channel configuration and does not only trust the values from
3269 try_decode_frame(ic
, st
, pkt
,
3270 (options
&& i
< orig_nb_streams
) ? &options
[i
] : NULL
);
3272 if (ic
->flags
& AVFMT_FLAG_NOBUFFER
)
3273 av_packet_unref(pkt
);
3275 st
->codec_info_nb_frames
++;
3280 AVPacket empty_pkt
= { 0 };
3282 av_init_packet(&empty_pkt
);
3284 for (i
= 0; i
< ic
->nb_streams
; i
++) {
3286 st
= ic
->streams
[i
];
3288 /* flush the decoders */
3289 if (st
->info
->found_decoder
== 1) {
3291 err
= try_decode_frame(ic
, st
, &empty_pkt
,
3292 (options
&& i
< orig_nb_streams
)
3293 ? &options
[i
] : NULL
);
3294 } while (err
> 0 && !has_codec_parameters(st
, NULL
));
3297 av_log(ic
, AV_LOG_INFO
,
3298 "decoding for stream %d failed\n", st
->index
);
3304 // close codecs which were opened in try_decode_frame()
3305 for (i
= 0; i
< ic
->nb_streams
; i
++) {
3306 st
= ic
->streams
[i
];
3307 avcodec_close(st
->codec
);
3310 ff_rfps_calculate(ic
);
3312 for (i
= 0; i
< ic
->nb_streams
; i
++) {
3313 st
= ic
->streams
[i
];
3314 if (st
->codec
->codec_type
== AVMEDIA_TYPE_VIDEO
) {
3315 if (st
->codec
->codec_id
== AV_CODEC_ID_RAWVIDEO
&& !st
->codec
->codec_tag
&& !st
->codec
->bits_per_coded_sample
) {
3316 uint32_t tag
= avcodec_pix_fmt_to_codec_tag(st
->codec
->pix_fmt
);
3317 if (avpriv_find_pix_fmt(avpriv_get_raw_pix_fmt_tags(), tag
) == st
->codec
->pix_fmt
)
3318 st
->codec
->codec_tag
= tag
;
3321 /* estimate average framerate if not set by demuxer */
3322 if (st
->info
->codec_info_duration_fields
&&
3323 !st
->avg_frame_rate
.num
&&
3324 st
->info
->codec_info_duration
) {
3326 double best_error
= 0.01;
3328 if (st
->info
->codec_info_duration
>= INT64_MAX
/ st
->time_base
.num
/ 2||
3329 st
->info
->codec_info_duration_fields
>= INT64_MAX
/ st
->time_base
.den
||
3330 st
->info
->codec_info_duration
< 0)
3332 av_reduce(&st
->avg_frame_rate
.num
, &st
->avg_frame_rate
.den
,
3333 st
->info
->codec_info_duration_fields
* (int64_t) st
->time_base
.den
,
3334 st
->info
->codec_info_duration
* 2 * (int64_t) st
->time_base
.num
, 60000);
3336 /* Round guessed framerate to a "standard" framerate if it's
3337 * within 1% of the original estimate. */
3338 for (j
= 0; j
< MAX_STD_TIMEBASES
; j
++) {
3339 AVRational std_fps
= { get_std_framerate(j
), 12 * 1001 };
3340 double error
= fabs(av_q2d(st
->avg_frame_rate
) /
3341 av_q2d(std_fps
) - 1);
3343 if (error
< best_error
) {
3345 best_fps
= std_fps
.num
;
3349 av_reduce(&st
->avg_frame_rate
.num
, &st
->avg_frame_rate
.den
,
3350 best_fps
, 12 * 1001, INT_MAX
);
3353 if (!st
->r_frame_rate
.num
) {
3354 if ( st
->codec
->time_base
.den
* (int64_t) st
->time_base
.num
3355 <= st
->codec
->time_base
.num
* st
->codec
->ticks_per_frame
* (int64_t) st
->time_base
.den
) {
3356 st
->r_frame_rate
.num
= st
->codec
->time_base
.den
;
3357 st
->r_frame_rate
.den
= st
->codec
->time_base
.num
* st
->codec
->ticks_per_frame
;
3359 st
->r_frame_rate
.num
= st
->time_base
.den
;
3360 st
->r_frame_rate
.den
= st
->time_base
.num
;
3363 if (st
->display_aspect_ratio
.num
&& st
->display_aspect_ratio
.den
) {
3364 AVRational hw_ratio
= { st
->codec
->height
, st
->codec
->width
};
3365 st
->sample_aspect_ratio
= av_mul_q(st
->display_aspect_ratio
,
3368 } else if (st
->codec
->codec_type
== AVMEDIA_TYPE_AUDIO
) {
3369 if (!st
->codec
->bits_per_coded_sample
)
3370 st
->codec
->bits_per_coded_sample
=
3371 av_get_bits_per_sample(st
->codec
->codec_id
);
3372 // set stream disposition based on audio service type
3373 switch (st
->codec
->audio_service_type
) {
3374 case AV_AUDIO_SERVICE_TYPE_EFFECTS
:
3375 st
->disposition
= AV_DISPOSITION_CLEAN_EFFECTS
;
3377 case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED
:
3378 st
->disposition
= AV_DISPOSITION_VISUAL_IMPAIRED
;
3380 case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED
:
3381 st
->disposition
= AV_DISPOSITION_HEARING_IMPAIRED
;
3383 case AV_AUDIO_SERVICE_TYPE_COMMENTARY
:
3384 st
->disposition
= AV_DISPOSITION_COMMENT
;
3386 case AV_AUDIO_SERVICE_TYPE_KARAOKE
:
3387 st
->disposition
= AV_DISPOSITION_KARAOKE
;
3394 estimate_timings(ic
, old_offset
);
3396 av_opt_set(ic
, "skip_clear", "0", AV_OPT_SEARCH_CHILDREN
);
3398 if (ret
>= 0 && ic
->nb_streams
)
3399 /* We could not have all the codec parameters before EOF. */
3401 for (i
= 0; i
< ic
->nb_streams
; i
++) {
3403 st
= ic
->streams
[i
];
3404 if (!has_codec_parameters(st
, &errmsg
)) {
3406 avcodec_string(buf
, sizeof(buf
), st
->codec
, 0);
3407 av_log(ic
, AV_LOG_WARNING
,
3408 "Could not find codec parameters for stream %d (%s): %s\n"
3409 "Consider increasing the value for the 'analyzeduration' and 'probesize' options\n",
3416 compute_chapters_end(ic
);
3418 find_stream_info_err
:
3419 for (i
= 0; i
< ic
->nb_streams
; i
++) {
3420 st
= ic
->streams
[i
];
3421 if (ic
->streams
[i
]->codec
->codec_type
!= AVMEDIA_TYPE_AUDIO
)
3422 ic
->streams
[i
]->codec
->thread_count
= 0;
3424 av_freep(&st
->info
->duration_error
);
3425 av_freep(&ic
->streams
[i
]->info
);
3428 av_log(ic
, AV_LOG_DEBUG
, "After avformat_find_stream_info() pos: %"PRId64
" bytes read:%"PRId64
" seeks:%d frames:%d\n",
3429 avio_tell(ic
->pb
), ic
->pb
->bytes_read
, ic
->pb
->seek_count
, count
);
3433 AVProgram
*av_find_program_from_stream(AVFormatContext
*ic
, AVProgram
*last
, int s
)
3437 for (i
= 0; i
< ic
->nb_programs
; i
++) {
3438 if (ic
->programs
[i
] == last
) {
3442 for (j
= 0; j
< ic
->programs
[i
]->nb_stream_indexes
; j
++)
3443 if (ic
->programs
[i
]->stream_index
[j
] == s
)
3444 return ic
->programs
[i
];
3450 int av_find_best_stream(AVFormatContext
*ic
, enum AVMediaType type
,
3451 int wanted_stream_nb
, int related_stream
,
3452 AVCodec
**decoder_ret
, int flags
)
3454 int i
, nb_streams
= ic
->nb_streams
;
3455 int ret
= AVERROR_STREAM_NOT_FOUND
, best_count
= -1, best_bitrate
= -1, best_multiframe
= -1, count
, bitrate
, multiframe
;
3456 unsigned *program
= NULL
;
3457 const AVCodec
*decoder
= NULL
, *best_decoder
= NULL
;
3459 if (related_stream
>= 0 && wanted_stream_nb
< 0) {
3460 AVProgram
*p
= av_find_program_from_stream(ic
, NULL
, related_stream
);
3462 program
= p
->stream_index
;
3463 nb_streams
= p
->nb_stream_indexes
;
3466 for (i
= 0; i
< nb_streams
; i
++) {
3467 int real_stream_index
= program
? program
[i
] : i
;
3468 AVStream
*st
= ic
->streams
[real_stream_index
];
3469 AVCodecContext
*avctx
= st
->codec
;
3470 if (avctx
->codec_type
!= type
)
3472 if (wanted_stream_nb
>= 0 && real_stream_index
!= wanted_stream_nb
)
3474 if (wanted_stream_nb
!= real_stream_index
&&
3475 st
->disposition
& (AV_DISPOSITION_HEARING_IMPAIRED
|
3476 AV_DISPOSITION_VISUAL_IMPAIRED
))
3478 if (type
== AVMEDIA_TYPE_AUDIO
&& !avctx
->channels
)
3481 decoder
= find_decoder(ic
, st
, st
->codec
->codec_id
);
3484 ret
= AVERROR_DECODER_NOT_FOUND
;
3488 count
= st
->codec_info_nb_frames
;
3489 bitrate
= avctx
->bit_rate
;
3491 bitrate
= avctx
->rc_max_rate
;
3492 multiframe
= FFMIN(5, count
);
3493 if ((best_multiframe
> multiframe
) ||
3494 (best_multiframe
== multiframe
&& best_bitrate
> bitrate
) ||
3495 (best_multiframe
== multiframe
&& best_bitrate
== bitrate
&& best_count
>= count
))
3498 best_bitrate
= bitrate
;
3499 best_multiframe
= multiframe
;
3500 ret
= real_stream_index
;
3501 best_decoder
= decoder
;
3502 if (program
&& i
== nb_streams
- 1 && ret
< 0) {
3504 nb_streams
= ic
->nb_streams
;
3505 /* no related stream found, try again with everything */
3510 *decoder_ret
= (AVCodec
*)best_decoder
;
3514 /*******************************************************/
3516 int av_read_play(AVFormatContext
*s
)
3518 if (s
->iformat
->read_play
)
3519 return s
->iformat
->read_play(s
);
3521 return avio_pause(s
->pb
, 0);
3522 return AVERROR(ENOSYS
);
3525 int av_read_pause(AVFormatContext
*s
)
3527 if (s
->iformat
->read_pause
)
3528 return s
->iformat
->read_pause(s
);
3530 return avio_pause(s
->pb
, 1);
3531 return AVERROR(ENOSYS
);
3534 void ff_free_stream(AVFormatContext
*s
, AVStream
*st
) {
3536 av_assert0(s
->nb_streams
>0);
3537 av_assert0(s
->streams
[ s
->nb_streams
- 1 ] == st
);
3539 for (j
= 0; j
< st
->nb_side_data
; j
++)
3540 av_freep(&st
->side_data
[j
].data
);
3541 av_freep(&st
->side_data
);
3542 st
->nb_side_data
= 0;
3545 av_parser_close(st
->parser
);
3547 if (st
->attached_pic
.data
)
3548 av_free_packet(&st
->attached_pic
);
3549 av_dict_free(&st
->metadata
);
3550 av_freep(&st
->probe_data
.buf
);
3551 av_freep(&st
->index_entries
);
3552 av_freep(&st
->codec
->extradata
);
3553 av_freep(&st
->codec
->subtitle_header
);
3554 av_freep(&st
->codec
);
3555 av_freep(&st
->priv_data
);
3557 av_freep(&st
->info
->duration_error
);
3558 av_freep(&st
->info
);
3559 av_freep(&st
->recommended_encoder_configuration
);
3560 av_freep(&s
->streams
[ --s
->nb_streams
]);
3563 void avformat_free_context(AVFormatContext
*s
)
3571 if (s
->iformat
&& s
->iformat
->priv_class
&& s
->priv_data
)
3572 av_opt_free(s
->priv_data
);
3573 if (s
->oformat
&& s
->oformat
->priv_class
&& s
->priv_data
)
3574 av_opt_free(s
->priv_data
);
3576 for (i
= s
->nb_streams
- 1; i
>= 0; i
--) {
3577 ff_free_stream(s
, s
->streams
[i
]);
3579 for (i
= s
->nb_programs
- 1; i
>= 0; i
--) {
3580 av_dict_free(&s
->programs
[i
]->metadata
);
3581 av_freep(&s
->programs
[i
]->stream_index
);
3582 av_freep(&s
->programs
[i
]);
3584 av_freep(&s
->programs
);
3585 av_freep(&s
->priv_data
);
3586 while (s
->nb_chapters
--) {
3587 av_dict_free(&s
->chapters
[s
->nb_chapters
]->metadata
);
3588 av_freep(&s
->chapters
[s
->nb_chapters
]);
3590 av_freep(&s
->chapters
);
3591 av_dict_free(&s
->metadata
);
3592 av_freep(&s
->streams
);
3593 av_freep(&s
->internal
);
3594 flush_packet_queue(s
);
3598 void avformat_close_input(AVFormatContext
**ps
)
3609 if ((s
->iformat
&& strcmp(s
->iformat
->name
, "image2") && s
->iformat
->flags
& AVFMT_NOFILE
) ||
3610 (s
->flags
& AVFMT_FLAG_CUSTOM_IO
))
3613 flush_packet_queue(s
);
3616 if (s
->iformat
->read_close
)
3617 s
->iformat
->read_close(s
);
3619 avformat_free_context(s
);
3626 AVStream
*avformat_new_stream(AVFormatContext
*s
, const AVCodec
*c
)
3632 if (s
->nb_streams
>= INT_MAX
/sizeof(*streams
))
3634 streams
= av_realloc_array(s
->streams
, s
->nb_streams
+ 1, sizeof(*streams
));
3637 s
->streams
= streams
;
3639 st
= av_mallocz(sizeof(AVStream
));
3642 if (!(st
->info
= av_mallocz(sizeof(*st
->info
)))) {
3646 st
->info
->last_dts
= AV_NOPTS_VALUE
;
3648 st
->codec
= avcodec_alloc_context3(c
);
3650 /* no default bitrate if decoding */
3651 st
->codec
->bit_rate
= 0;
3653 /* default pts setting is MPEG-like */
3654 avpriv_set_pts_info(st
, 33, 1, 90000);
3657 st
->index
= s
->nb_streams
;
3658 st
->start_time
= AV_NOPTS_VALUE
;
3659 st
->duration
= AV_NOPTS_VALUE
;
3660 /* we set the current DTS to 0 so that formats without any timestamps
3661 * but durations get some timestamps, formats with some unknown
3662 * timestamps have their first few packets buffered and the
3663 * timestamps corrected before they are returned to the user */
3664 st
->cur_dts
= s
->iformat
? RELATIVE_TS_BASE
: 0;
3665 st
->first_dts
= AV_NOPTS_VALUE
;
3666 st
->probe_packets
= MAX_PROBE_PACKETS
;
3667 st
->pts_wrap_reference
= AV_NOPTS_VALUE
;
3668 st
->pts_wrap_behavior
= AV_PTS_WRAP_IGNORE
;
3670 st
->last_IP_pts
= AV_NOPTS_VALUE
;
3671 st
->last_dts_for_order_check
= AV_NOPTS_VALUE
;
3672 for (i
= 0; i
< MAX_REORDER_DELAY
+ 1; i
++)
3673 st
->pts_buffer
[i
] = AV_NOPTS_VALUE
;
3675 st
->sample_aspect_ratio
= (AVRational
) { 0, 1 };
3677 #if FF_API_R_FRAME_RATE
3678 st
->info
->last_dts
= AV_NOPTS_VALUE
;
3680 st
->info
->fps_first_dts
= AV_NOPTS_VALUE
;
3681 st
->info
->fps_last_dts
= AV_NOPTS_VALUE
;
3683 st
->inject_global_side_data
= s
->internal
->inject_global_side_data
;
3685 s
->streams
[s
->nb_streams
++] = st
;
3689 AVProgram
*av_new_program(AVFormatContext
*ac
, int id
)
3691 AVProgram
*program
= NULL
;
3694 av_dlog(ac
, "new_program: id=0x%04x\n", id
);
3696 for (i
= 0; i
< ac
->nb_programs
; i
++)
3697 if (ac
->programs
[i
]->id
== id
)
3698 program
= ac
->programs
[i
];
3701 program
= av_mallocz(sizeof(AVProgram
));
3704 dynarray_add(&ac
->programs
, &ac
->nb_programs
, program
);
3705 program
->discard
= AVDISCARD_NONE
;
3708 program
->pts_wrap_reference
= AV_NOPTS_VALUE
;
3709 program
->pts_wrap_behavior
= AV_PTS_WRAP_IGNORE
;
3711 program
->start_time
=
3712 program
->end_time
= AV_NOPTS_VALUE
;
3717 AVChapter
*avpriv_new_chapter(AVFormatContext
*s
, int id
, AVRational time_base
,
3718 int64_t start
, int64_t end
, const char *title
)
3720 AVChapter
*chapter
= NULL
;
3723 if (end
!= AV_NOPTS_VALUE
&& start
> end
) {
3724 av_log(s
, AV_LOG_ERROR
, "Chapter end time %"PRId64
" before start %"PRId64
"\n", end
, start
);
3728 for (i
= 0; i
< s
->nb_chapters
; i
++)
3729 if (s
->chapters
[i
]->id
== id
)
3730 chapter
= s
->chapters
[i
];
3733 chapter
= av_mallocz(sizeof(AVChapter
));
3736 dynarray_add(&s
->chapters
, &s
->nb_chapters
, chapter
);
3738 av_dict_set(&chapter
->metadata
, "title", title
, 0);
3740 chapter
->time_base
= time_base
;
3741 chapter
->start
= start
;
3747 void ff_program_add_stream_index(AVFormatContext
*ac
, int progid
, unsigned idx
)
3750 AVProgram
*program
= NULL
;
3753 if (idx
>= ac
->nb_streams
) {
3754 av_log(ac
, AV_LOG_ERROR
, "stream index %d is not valid\n", idx
);
3758 for (i
= 0; i
< ac
->nb_programs
; i
++) {
3759 if (ac
->programs
[i
]->id
!= progid
)
3761 program
= ac
->programs
[i
];
3762 for (j
= 0; j
< program
->nb_stream_indexes
; j
++)
3763 if (program
->stream_index
[j
] == idx
)
3766 tmp
= av_realloc_array(program
->stream_index
, program
->nb_stream_indexes
+1, sizeof(unsigned int));
3769 program
->stream_index
= tmp
;
3770 program
->stream_index
[program
->nb_stream_indexes
++] = idx
;
3775 uint64_t ff_ntp_time(void)
3777 return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US
;
3780 int av_get_frame_filename(char *buf
, int buf_size
, const char *path
, int number
)
3783 char *q
, buf1
[20], c
;
3784 int nd
, len
, percentd_found
;
3796 while (av_isdigit(*p
))
3797 nd
= nd
* 10 + *p
++ - '0';
3799 } while (av_isdigit(c
));
3808 snprintf(buf1
, sizeof(buf1
), "%0*d", nd
, number
);
3810 if ((q
- buf
+ len
) > buf_size
- 1)
3812 memcpy(q
, buf1
, len
);
3820 if ((q
- buf
) < buf_size
- 1)
3824 if (!percentd_found
)
3833 void av_url_split(char *proto
, int proto_size
,
3834 char *authorization
, int authorization_size
,
3835 char *hostname
, int hostname_size
,
3836 int *port_ptr
, char *path
, int path_size
, const char *url
)
3838 const char *p
, *ls
, *ls2
, *at
, *at2
, *col
, *brk
;
3844 if (authorization_size
> 0)
3845 authorization
[0] = 0;
3846 if (hostname_size
> 0)
3851 /* parse protocol */
3852 if ((p
= strchr(url
, ':'))) {
3853 av_strlcpy(proto
, url
, FFMIN(proto_size
, p
+ 1 - url
));
3860 /* no protocol means plain filename */
3861 av_strlcpy(path
, url
, path_size
);
3865 /* separate path from hostname */
3866 ls
= strchr(p
, '/');
3867 ls2
= strchr(p
, '?');
3871 ls
= FFMIN(ls
, ls2
);
3873 av_strlcpy(path
, ls
, path_size
);
3875 ls
= &p
[strlen(p
)]; // XXX
3877 /* the rest is hostname, use that to parse auth/port */
3879 /* authorization (user[:pass]@hostname) */
3881 while ((at
= strchr(p
, '@')) && at
< ls
) {
3882 av_strlcpy(authorization
, at2
,
3883 FFMIN(authorization_size
, at
+ 1 - at2
));
3884 p
= at
+ 1; /* skip '@' */
3887 if (*p
== '[' && (brk
= strchr(p
, ']')) && brk
< ls
) {
3889 av_strlcpy(hostname
, p
+ 1,
3890 FFMIN(hostname_size
, brk
- p
));
3891 if (brk
[1] == ':' && port_ptr
)
3892 *port_ptr
= atoi(brk
+ 2);
3893 } else if ((col
= strchr(p
, ':')) && col
< ls
) {
3894 av_strlcpy(hostname
, p
,
3895 FFMIN(col
+ 1 - p
, hostname_size
));
3897 *port_ptr
= atoi(col
+ 1);
3899 av_strlcpy(hostname
, p
,
3900 FFMIN(ls
+ 1 - p
, hostname_size
));
3904 char *ff_data_to_hex(char *buff
, const uint8_t *src
, int s
, int lowercase
)
3907 static const char hex_table_uc
[16] = { '0', '1', '2', '3',
3910 'C', 'D', 'E', 'F' };
3911 static const char hex_table_lc
[16] = { '0', '1', '2', '3',
3914 'c', 'd', 'e', 'f' };
3915 const char *hex_table
= lowercase
? hex_table_lc
: hex_table_uc
;
3917 for (i
= 0; i
< s
; i
++) {
3918 buff
[i
* 2] = hex_table
[src
[i
] >> 4];
3919 buff
[i
* 2 + 1] = hex_table
[src
[i
] & 0xF];
3925 int ff_hex_to_data(uint8_t *data
, const char *p
)
3932 p
+= strspn(p
, SPACE_CHARS
);
3935 c
= av_toupper((unsigned char) *p
++);
3936 if (c
>= '0' && c
<= '9')
3938 else if (c
>= 'A' && c
<= 'F')
3953 void avpriv_set_pts_info(AVStream
*s
, int pts_wrap_bits
,
3954 unsigned int pts_num
, unsigned int pts_den
)
3957 if (av_reduce(&new_tb
.num
, &new_tb
.den
, pts_num
, pts_den
, INT_MAX
)) {
3958 if (new_tb
.num
!= pts_num
)
3959 av_log(NULL
, AV_LOG_DEBUG
,
3960 "st:%d removing common factor %d from timebase\n",
3961 s
->index
, pts_num
/ new_tb
.num
);
3963 av_log(NULL
, AV_LOG_WARNING
,
3964 "st:%d has too large timebase, reducing\n", s
->index
);
3966 if (new_tb
.num
<= 0 || new_tb
.den
<= 0) {
3967 av_log(NULL
, AV_LOG_ERROR
,
3968 "Ignoring attempt to set invalid timebase %d/%d for st:%d\n",
3969 new_tb
.num
, new_tb
.den
,
3973 s
->time_base
= new_tb
;
3974 av_codec_set_pkt_timebase(s
->codec
, new_tb
);
3975 s
->pts_wrap_bits
= pts_wrap_bits
;
3978 void ff_parse_key_value(const char *str
, ff_parse_key_val_cb callback_get_buf
,
3981 const char *ptr
= str
;
3983 /* Parse key=value pairs. */
3986 char *dest
= NULL
, *dest_end
;
3987 int key_len
, dest_len
= 0;
3989 /* Skip whitespace and potential commas. */
3990 while (*ptr
&& (av_isspace(*ptr
) || *ptr
== ','))
3997 if (!(ptr
= strchr(key
, '=')))
4000 key_len
= ptr
- key
;
4002 callback_get_buf(context
, key
, key_len
, &dest
, &dest_len
);
4003 dest_end
= dest
+ dest_len
- 1;
4007 while (*ptr
&& *ptr
!= '\"') {
4011 if (dest
&& dest
< dest_end
)
4015 if (dest
&& dest
< dest_end
)
4023 for (; *ptr
&& !(av_isspace(*ptr
) || *ptr
== ','); ptr
++)
4024 if (dest
&& dest
< dest_end
)
4032 int ff_find_stream_index(AVFormatContext
*s
, int id
)
4035 for (i
= 0; i
< s
->nb_streams
; i
++)
4036 if (s
->streams
[i
]->id
== id
)
4041 int64_t ff_iso8601_to_unix_time(const char *datestr
)
4043 struct tm time1
= { 0 }, time2
= { 0 };
4045 ret1
= av_small_strptime(datestr
, "%Y - %m - %d %H:%M:%S", &time1
);
4046 ret2
= av_small_strptime(datestr
, "%Y - %m - %dT%H:%M:%S", &time2
);
4048 return av_timegm(&time2
);
4050 return av_timegm(&time1
);
4053 int avformat_query_codec(const AVOutputFormat
*ofmt
, enum AVCodecID codec_id
,
4057 if (ofmt
->query_codec
)
4058 return ofmt
->query_codec(codec_id
, std_compliance
);
4059 else if (ofmt
->codec_tag
)
4060 return !!av_codec_get_tag(ofmt
->codec_tag
, codec_id
);
4061 else if (codec_id
== ofmt
->video_codec
||
4062 codec_id
== ofmt
->audio_codec
||
4063 codec_id
== ofmt
->subtitle_codec
)
4066 return AVERROR_PATCHWELCOME
;
4069 int avformat_network_init(void)
4073 ff_network_inited_globally
= 1;
4074 if ((ret
= ff_network_init()) < 0)
4081 int avformat_network_deinit(void)
4090 int ff_add_param_change(AVPacket
*pkt
, int32_t channels
,
4091 uint64_t channel_layout
, int32_t sample_rate
,
4092 int32_t width
, int32_t height
)
4098 return AVERROR(EINVAL
);
4101 flags
|= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT
;
4103 if (channel_layout
) {
4105 flags
|= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT
;
4109 flags
|= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE
;
4111 if (width
|| height
) {
4113 flags
|= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS
;
4115 data
= av_packet_new_side_data(pkt
, AV_PKT_DATA_PARAM_CHANGE
, size
);
4117 return AVERROR(ENOMEM
);
4118 bytestream_put_le32(&data
, flags
);
4120 bytestream_put_le32(&data
, channels
);
4122 bytestream_put_le64(&data
, channel_layout
);
4124 bytestream_put_le32(&data
, sample_rate
);
4125 if (width
|| height
) {
4126 bytestream_put_le32(&data
, width
);
4127 bytestream_put_le32(&data
, height
);
4132 AVRational
av_guess_sample_aspect_ratio(AVFormatContext
*format
, AVStream
*stream
, AVFrame
*frame
)
4134 AVRational undef
= {0, 1};
4135 AVRational stream_sample_aspect_ratio
= stream
? stream
->sample_aspect_ratio
: undef
;
4136 AVRational codec_sample_aspect_ratio
= stream
&& stream
->codec
? stream
->codec
->sample_aspect_ratio
: undef
;
4137 AVRational frame_sample_aspect_ratio
= frame
? frame
->sample_aspect_ratio
: codec_sample_aspect_ratio
;
4139 av_reduce(&stream_sample_aspect_ratio
.num
, &stream_sample_aspect_ratio
.den
,
4140 stream_sample_aspect_ratio
.num
, stream_sample_aspect_ratio
.den
, INT_MAX
);
4141 if (stream_sample_aspect_ratio
.num
<= 0 || stream_sample_aspect_ratio
.den
<= 0)
4142 stream_sample_aspect_ratio
= undef
;
4144 av_reduce(&frame_sample_aspect_ratio
.num
, &frame_sample_aspect_ratio
.den
,
4145 frame_sample_aspect_ratio
.num
, frame_sample_aspect_ratio
.den
, INT_MAX
);
4146 if (frame_sample_aspect_ratio
.num
<= 0 || frame_sample_aspect_ratio
.den
<= 0)
4147 frame_sample_aspect_ratio
= undef
;
4149 if (stream_sample_aspect_ratio
.num
)
4150 return stream_sample_aspect_ratio
;
4152 return frame_sample_aspect_ratio
;
4155 AVRational
av_guess_frame_rate(AVFormatContext
*format
, AVStream
*st
, AVFrame
*frame
)
4157 AVRational fr
= st
->r_frame_rate
;
4158 AVRational codec_fr
= st
->codec
->framerate
;
4159 AVRational avg_fr
= st
->avg_frame_rate
;
4161 if (avg_fr
.num
> 0 && avg_fr
.den
> 0 && fr
.num
> 0 && fr
.den
> 0 &&
4162 av_q2d(avg_fr
) < 70 && av_q2d(fr
) > 210) {
4167 if (st
->codec
->ticks_per_frame
> 1) {
4168 if ( codec_fr
.num
> 0 && codec_fr
.den
> 0 && av_q2d(codec_fr
) < av_q2d(fr
)*0.7
4169 && fabs(1.0 - av_q2d(av_div_q(avg_fr
, fr
))) > 0.1)
4176 int avformat_match_stream_specifier(AVFormatContext
*s
, AVStream
*st
,
4179 if (*spec
<= '9' && *spec
>= '0') /* opt:index */
4180 return strtol(spec
, NULL
, 0) == st
->index
;
4181 else if (*spec
== 'v' || *spec
== 'a' || *spec
== 's' || *spec
== 'd' ||
4182 *spec
== 't') { /* opt:[vasdt] */
4183 enum AVMediaType type
;
4186 case 'v': type
= AVMEDIA_TYPE_VIDEO
; break;
4187 case 'a': type
= AVMEDIA_TYPE_AUDIO
; break;
4188 case 's': type
= AVMEDIA_TYPE_SUBTITLE
; break;
4189 case 'd': type
= AVMEDIA_TYPE_DATA
; break;
4190 case 't': type
= AVMEDIA_TYPE_ATTACHMENT
; break;
4191 default: av_assert0(0);
4193 if (type
!= st
->codec
->codec_type
)
4195 if (*spec
++ == ':') { /* possibly followed by :index */
4196 int i
, index
= strtol(spec
, NULL
, 0);
4197 for (i
= 0; i
< s
->nb_streams
; i
++)
4198 if (s
->streams
[i
]->codec
->codec_type
== type
&& index
-- == 0)
4199 return i
== st
->index
;
4203 } else if (*spec
== 'p' && *(spec
+ 1) == ':') {
4207 prog_id
= strtol(spec
, &endptr
, 0);
4208 for (i
= 0; i
< s
->nb_programs
; i
++) {
4209 if (s
->programs
[i
]->id
!= prog_id
)
4212 if (*endptr
++ == ':') {
4213 int stream_idx
= strtol(endptr
, NULL
, 0);
4214 return stream_idx
>= 0 &&
4215 stream_idx
< s
->programs
[i
]->nb_stream_indexes
&&
4216 st
->index
== s
->programs
[i
]->stream_index
[stream_idx
];
4219 for (j
= 0; j
< s
->programs
[i
]->nb_stream_indexes
; j
++)
4220 if (st
->index
== s
->programs
[i
]->stream_index
[j
])
4224 } else if (*spec
== '#' ||
4225 (*spec
== 'i' && *(spec
+ 1) == ':')) {
4228 spec
+= 1 + (*spec
== 'i');
4229 stream_id
= strtol(spec
, &endptr
, 0);
4231 return stream_id
== st
->id
;
4232 } else if (*spec
== 'm' && *(spec
+ 1) == ':') {
4233 AVDictionaryEntry
*tag
;
4238 val
= strchr(spec
, ':');
4240 key
= val
? av_strndup(spec
, val
- spec
) : av_strdup(spec
);
4242 return AVERROR(ENOMEM
);
4244 tag
= av_dict_get(st
->metadata
, key
, NULL
, 0);
4246 if (!val
|| !strcmp(tag
->value
, val
+ 1))
4255 } else if (!*spec
) /* empty specifier, matches everything */
4258 av_log(s
, AV_LOG_ERROR
, "Invalid stream specifier: %s.\n", spec
);
4259 return AVERROR(EINVAL
);
4262 int ff_generate_avci_extradata(AVStream
*st
)
4264 static const uint8_t avci100_1080p_extradata
[] = {
4266 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4267 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4268 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4269 0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
4270 0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
4271 0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
4272 0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
4273 0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
4274 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4276 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4279 static const uint8_t avci100_1080i_extradata
[] = {
4281 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4282 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4283 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4284 0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
4285 0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
4286 0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
4287 0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
4288 0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
4289 0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
4290 0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
4291 0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x00,
4293 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4296 static const uint8_t avci50_1080p_extradata
[] = {
4298 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
4299 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4300 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4301 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
4302 0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
4303 0x6e, 0x6c, 0xd3, 0x3c, 0x05, 0xa0, 0x22, 0x7e,
4304 0x5f, 0xfc, 0x00, 0x0c, 0x00, 0x13, 0x8c, 0x04,
4305 0x04, 0x05, 0x00, 0x00, 0x03, 0x00, 0x01, 0x00,
4306 0x00, 0x03, 0x00, 0x32, 0x84, 0x00, 0x00, 0x00,
4308 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4311 static const uint8_t avci50_1080i_extradata
[] = {
4313 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
4314 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4315 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4316 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
4317 0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
4318 0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
4319 0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
4320 0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
4321 0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
4322 0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
4323 0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
4325 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4328 static const uint8_t avci100_720p_extradata
[] = {
4330 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4331 0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
4332 0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
4333 0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
4334 0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
4335 0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
4336 0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
4337 0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
4338 0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
4339 0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
4341 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
4344 static const uint8_t avci50_720p_extradata
[] = {
4346 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x20,
4347 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4348 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4349 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
4350 0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
4351 0x6e, 0x6c, 0xd3, 0x3c, 0x0f, 0x01, 0x6e, 0xff,
4352 0xc0, 0x00, 0xc0, 0x01, 0x38, 0xc0, 0x40, 0x40,
4353 0x50, 0x00, 0x00, 0x03, 0x00, 0x10, 0x00, 0x00,
4354 0x06, 0x48, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
4356 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4360 const uint8_t *data
= NULL
;
4363 if (st
->codec
->width
== 1920) {
4364 if (st
->codec
->field_order
== AV_FIELD_PROGRESSIVE
) {
4365 data
= avci100_1080p_extradata
;
4366 size
= sizeof(avci100_1080p_extradata
);
4368 data
= avci100_1080i_extradata
;
4369 size
= sizeof(avci100_1080i_extradata
);
4371 } else if (st
->codec
->width
== 1440) {
4372 if (st
->codec
->field_order
== AV_FIELD_PROGRESSIVE
) {
4373 data
= avci50_1080p_extradata
;
4374 size
= sizeof(avci50_1080p_extradata
);
4376 data
= avci50_1080i_extradata
;
4377 size
= sizeof(avci50_1080i_extradata
);
4379 } else if (st
->codec
->width
== 1280) {
4380 data
= avci100_720p_extradata
;
4381 size
= sizeof(avci100_720p_extradata
);
4382 } else if (st
->codec
->width
== 960) {
4383 data
= avci50_720p_extradata
;
4384 size
= sizeof(avci50_720p_extradata
);
4390 av_freep(&st
->codec
->extradata
);
4391 if (ff_alloc_extradata(st
->codec
, size
))
4392 return AVERROR(ENOMEM
);
4393 memcpy(st
->codec
->extradata
, data
, size
);
4398 uint8_t *av_stream_get_side_data(AVStream
*st
, enum AVPacketSideDataType type
,
4403 for (i
= 0; i
< st
->nb_side_data
; i
++) {
4404 if (st
->side_data
[i
].type
== type
) {
4406 *size
= st
->side_data
[i
].size
;
4407 return st
->side_data
[i
].data
;