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
23 #include "libavcodec/opt.h"
25 #include "libavutil/avstring.h"
35 * @file libavformat/utils.c
36 * various utility functions for use within FFmpeg
39 unsigned avformat_version(void)
41 return LIBAVFORMAT_VERSION_INT
;
44 /* fraction handling */
47 * f = val + (num / den) + 0.5.
49 * 'num' is normalized so that it is such as 0 <= num < den.
51 * @param f fractional number
52 * @param val integer value
53 * @param num must be >= 0
54 * @param den must be >= 1
56 static void av_frac_init(AVFrac
*f
, int64_t val
, int64_t num
, int64_t den
)
69 * Fractional addition to f: f = f + (incr / f->den).
71 * @param f fractional number
72 * @param incr increment, can be positive or negative
74 static void av_frac_add(AVFrac
*f
, int64_t incr
)
87 } else if (num
>= den
) {
94 /** head of registered input format linked list */
95 AVInputFormat
*first_iformat
= NULL
;
96 /** head of registered output format linked list */
97 AVOutputFormat
*first_oformat
= NULL
;
99 AVInputFormat
*av_iformat_next(AVInputFormat
*f
)
101 if(f
) return f
->next
;
102 else return first_iformat
;
105 AVOutputFormat
*av_oformat_next(AVOutputFormat
*f
)
107 if(f
) return f
->next
;
108 else return first_oformat
;
111 void av_register_input_format(AVInputFormat
*format
)
115 while (*p
!= NULL
) p
= &(*p
)->next
;
120 void av_register_output_format(AVOutputFormat
*format
)
124 while (*p
!= NULL
) p
= &(*p
)->next
;
129 int match_ext(const char *filename
, const char *extensions
)
137 ext
= strrchr(filename
, '.');
143 while (*p
!= '\0' && *p
!= ',' && q
-ext1
<sizeof(ext1
)-1)
146 if (!strcasecmp(ext1
, ext
))
156 static int match_format(const char *name
, const char *names
)
164 namelen
= strlen(name
);
165 while ((p
= strchr(names
, ','))) {
166 len
= FFMAX(p
- names
, namelen
);
167 if (!strncasecmp(name
, names
, len
))
171 return !strcasecmp(name
, names
);
174 AVOutputFormat
*guess_format(const char *short_name
, const char *filename
,
175 const char *mime_type
)
177 AVOutputFormat
*fmt
, *fmt_found
;
178 int score_max
, score
;
180 /* specific test for image sequences */
181 #if CONFIG_IMAGE2_MUXER
182 if (!short_name
&& filename
&&
183 av_filename_number_test(filename
) &&
184 av_guess_image2_codec(filename
) != CODEC_ID_NONE
) {
185 return guess_format("image2", NULL
, NULL
);
188 /* Find the proper file type. */
192 while (fmt
!= NULL
) {
194 if (fmt
->name
&& short_name
&& !strcmp(fmt
->name
, short_name
))
196 if (fmt
->mime_type
&& mime_type
&& !strcmp(fmt
->mime_type
, mime_type
))
198 if (filename
&& fmt
->extensions
&&
199 match_ext(filename
, fmt
->extensions
)) {
202 if (score
> score_max
) {
211 AVOutputFormat
*guess_stream_format(const char *short_name
, const char *filename
,
212 const char *mime_type
)
214 AVOutputFormat
*fmt
= guess_format(short_name
, filename
, mime_type
);
217 AVOutputFormat
*stream_fmt
;
218 char stream_format_name
[64];
220 snprintf(stream_format_name
, sizeof(stream_format_name
), "%s_stream", fmt
->name
);
221 stream_fmt
= guess_format(stream_format_name
, NULL
, NULL
);
230 enum CodecID
av_guess_codec(AVOutputFormat
*fmt
, const char *short_name
,
231 const char *filename
, const char *mime_type
, enum CodecType type
){
232 if(type
== CODEC_TYPE_VIDEO
){
233 enum CodecID codec_id
= CODEC_ID_NONE
;
235 #if CONFIG_IMAGE2_MUXER
236 if(!strcmp(fmt
->name
, "image2") || !strcmp(fmt
->name
, "image2pipe")){
237 codec_id
= av_guess_image2_codec(filename
);
240 if(codec_id
== CODEC_ID_NONE
)
241 codec_id
= fmt
->video_codec
;
243 }else if(type
== CODEC_TYPE_AUDIO
)
244 return fmt
->audio_codec
;
246 return CODEC_ID_NONE
;
249 AVInputFormat
*av_find_input_format(const char *short_name
)
252 for(fmt
= first_iformat
; fmt
!= NULL
; fmt
= fmt
->next
) {
253 if (match_format(short_name
, fmt
->name
))
259 /* memory handling */
262 int av_get_packet(ByteIOContext
*s
, AVPacket
*pkt
, int size
)
264 int ret
= av_new_packet(pkt
, size
);
269 pkt
->pos
= url_ftell(s
);
271 ret
= get_buffer(s
, pkt
->data
, size
);
275 av_shrink_packet(pkt
, ret
);
281 int av_filename_number_test(const char *filename
)
284 return filename
&& (av_get_frame_filename(buf
, sizeof(buf
), filename
, 1)>=0);
287 static AVInputFormat
*av_probe_input_format2(AVProbeData
*pd
, int is_opened
, int *score_max
)
289 AVInputFormat
*fmt1
, *fmt
;
293 for(fmt1
= first_iformat
; fmt1
!= NULL
; fmt1
= fmt1
->next
) {
294 if (!is_opened
== !(fmt1
->flags
& AVFMT_NOFILE
))
297 if (fmt1
->read_probe
) {
298 score
= fmt1
->read_probe(pd
);
299 } else if (fmt1
->extensions
) {
300 if (match_ext(pd
->filename
, fmt1
->extensions
)) {
304 if (score
> *score_max
) {
307 }else if (score
== *score_max
)
313 AVInputFormat
*av_probe_input_format(AVProbeData
*pd
, int is_opened
){
315 return av_probe_input_format2(pd
, is_opened
, &score
);
318 static int set_codec_from_probe_data(AVFormatContext
*s
, AVStream
*st
, AVProbeData
*pd
, int score
)
321 fmt
= av_probe_input_format2(pd
, 1, &score
);
324 av_log(s
, AV_LOG_DEBUG
, "Probe with size=%d, packets=%d detected %s with score=%d\n",
325 pd
->buf_size
, MAX_PROBE_PACKETS
- st
->probe_packets
, fmt
->name
, score
);
326 if (!strcmp(fmt
->name
, "mp3")) {
327 st
->codec
->codec_id
= CODEC_ID_MP3
;
328 st
->codec
->codec_type
= CODEC_TYPE_AUDIO
;
329 } else if (!strcmp(fmt
->name
, "ac3")) {
330 st
->codec
->codec_id
= CODEC_ID_AC3
;
331 st
->codec
->codec_type
= CODEC_TYPE_AUDIO
;
332 } else if (!strcmp(fmt
->name
, "mpegvideo")) {
333 st
->codec
->codec_id
= CODEC_ID_MPEG2VIDEO
;
334 st
->codec
->codec_type
= CODEC_TYPE_VIDEO
;
335 } else if (!strcmp(fmt
->name
, "m4v")) {
336 st
->codec
->codec_id
= CODEC_ID_MPEG4
;
337 st
->codec
->codec_type
= CODEC_TYPE_VIDEO
;
338 } else if (!strcmp(fmt
->name
, "h264")) {
339 st
->codec
->codec_id
= CODEC_ID_H264
;
340 st
->codec
->codec_type
= CODEC_TYPE_VIDEO
;
341 } else if (!strcmp(fmt
->name
, "dts")) {
342 st
->codec
->codec_id
= CODEC_ID_DTS
;
343 st
->codec
->codec_type
= CODEC_TYPE_AUDIO
;
349 /************************************************************/
350 /* input media file */
353 * Open a media file from an IO stream. 'fmt' must be specified.
355 int av_open_input_stream(AVFormatContext
**ic_ptr
,
356 ByteIOContext
*pb
, const char *filename
,
357 AVInputFormat
*fmt
, AVFormatParameters
*ap
)
361 AVFormatParameters default_ap
;
365 memset(ap
, 0, sizeof(default_ap
));
368 if(!ap
->prealloced_context
)
369 ic
= avformat_alloc_context();
373 err
= AVERROR(ENOMEM
);
378 ic
->duration
= AV_NOPTS_VALUE
;
379 ic
->start_time
= AV_NOPTS_VALUE
;
380 av_strlcpy(ic
->filename
, filename
, sizeof(ic
->filename
));
382 /* allocate private data */
383 if (fmt
->priv_data_size
> 0) {
384 ic
->priv_data
= av_mallocz(fmt
->priv_data_size
);
385 if (!ic
->priv_data
) {
386 err
= AVERROR(ENOMEM
);
390 ic
->priv_data
= NULL
;
393 if (ic
->iformat
->read_header
) {
394 err
= ic
->iformat
->read_header(ic
, ap
);
399 if (pb
&& !ic
->data_offset
)
400 ic
->data_offset
= url_ftell(ic
->pb
);
402 #if LIBAVFORMAT_VERSION_MAJOR < 53
403 ff_metadata_demux_compat(ic
);
406 ic
->raw_packet_buffer_remaining_size
= RAW_PACKET_BUFFER_SIZE
;
413 av_freep(&ic
->priv_data
);
414 for(i
=0;i
<ic
->nb_streams
;i
++) {
415 AVStream
*st
= ic
->streams
[i
];
417 av_free(st
->priv_data
);
418 av_free(st
->codec
->extradata
);
428 /** size of probe buffer, for guessing file type from file contents */
429 #define PROBE_BUF_MIN 2048
430 #define PROBE_BUF_MAX (1<<20)
432 int av_open_input_file(AVFormatContext
**ic_ptr
, const char *filename
,
435 AVFormatParameters
*ap
)
438 AVProbeData probe_data
, *pd
= &probe_data
;
439 ByteIOContext
*pb
= NULL
;
440 void *logctx
= ap
&& ap
->prealloced_context
? *ic_ptr
: NULL
;
444 pd
->filename
= filename
;
449 /* guess format if no file can be opened */
450 fmt
= av_probe_input_format(pd
, 0);
453 /* Do not open file if the format does not need it. XXX: specific
454 hack needed to handle RTSP/TCP */
455 if (!fmt
|| !(fmt
->flags
& AVFMT_NOFILE
)) {
456 /* if no file needed do not try to open one */
457 if ((err
=url_fopen(&pb
, filename
, URL_RDONLY
)) < 0) {
461 url_setbufsize(pb
, buf_size
);
464 for(probe_size
= PROBE_BUF_MIN
; probe_size
<=PROBE_BUF_MAX
&& !fmt
; probe_size
<<=1){
465 int score
= probe_size
< PROBE_BUF_MAX
? AVPROBE_SCORE_MAX
/4 : 0;
466 /* read probe data */
467 pd
->buf
= av_realloc(pd
->buf
, probe_size
+ AVPROBE_PADDING_SIZE
);
468 pd
->buf_size
= get_buffer(pb
, pd
->buf
, probe_size
);
469 memset(pd
->buf
+pd
->buf_size
, 0, AVPROBE_PADDING_SIZE
);
470 if (url_fseek(pb
, 0, SEEK_SET
) < 0) {
472 if (url_fopen(&pb
, filename
, URL_RDONLY
) < 0) {
478 /* guess file format */
479 fmt
= av_probe_input_format2(pd
, 1, &score
);
481 if(score
<= AVPROBE_SCORE_MAX
/4){ //this can only be true in the last iteration
482 av_log(logctx
, AV_LOG_WARNING
, "Format detected only with low score of %d, misdetection possible!\n", score
);
484 av_log(logctx
, AV_LOG_DEBUG
, "Probed with size=%d and score=%d\n", probe_size
, score
);
490 /* if still no format found, error */
496 /* check filename in case an image number is expected */
497 if (fmt
->flags
& AVFMT_NEEDNUMBER
) {
498 if (!av_filename_number_test(filename
)) {
499 err
= AVERROR_NUMEXPECTED
;
503 err
= av_open_input_stream(ic_ptr
, pb
, filename
, fmt
, ap
);
511 if (ap
&& ap
->prealloced_context
)
518 /*******************************************************/
520 static AVPacket
*add_to_pktbuf(AVPacketList
**packet_buffer
, AVPacket
*pkt
,
521 AVPacketList
**plast_pktl
){
522 AVPacketList
*pktl
= av_mallocz(sizeof(AVPacketList
));
527 (*plast_pktl
)->next
= pktl
;
529 *packet_buffer
= pktl
;
531 /* add the packet in the buffered packet list */
537 int av_read_packet(AVFormatContext
*s
, AVPacket
*pkt
)
543 AVPacketList
*pktl
= s
->raw_packet_buffer
;
547 if(s
->streams
[pkt
->stream_index
]->codec
->codec_id
!= CODEC_ID_PROBE
||
548 !s
->streams
[pkt
->stream_index
]->probe_packets
||
549 s
->raw_packet_buffer_remaining_size
< pkt
->size
){
550 AVProbeData
*pd
= &s
->streams
[pkt
->stream_index
]->probe_data
;
553 s
->raw_packet_buffer
= pktl
->next
;
554 s
->raw_packet_buffer_remaining_size
+= pkt
->size
;
561 ret
= s
->iformat
->read_packet(s
, pkt
);
563 if (!pktl
|| ret
== AVERROR(EAGAIN
))
565 for (i
= 0; i
< s
->nb_streams
; i
++)
566 s
->streams
[i
]->probe_packets
= 0;
569 st
= s
->streams
[pkt
->stream_index
];
571 switch(st
->codec
->codec_type
){
572 case CODEC_TYPE_VIDEO
:
573 if(s
->video_codec_id
) st
->codec
->codec_id
= s
->video_codec_id
;
575 case CODEC_TYPE_AUDIO
:
576 if(s
->audio_codec_id
) st
->codec
->codec_id
= s
->audio_codec_id
;
578 case CODEC_TYPE_SUBTITLE
:
579 if(s
->subtitle_codec_id
)st
->codec
->codec_id
= s
->subtitle_codec_id
;
583 if(!pktl
&& (st
->codec
->codec_id
!= CODEC_ID_PROBE
||
587 add_to_pktbuf(&s
->raw_packet_buffer
, pkt
, &s
->raw_packet_buffer_end
);
588 s
->raw_packet_buffer_remaining_size
-= pkt
->size
;
590 if(st
->codec
->codec_id
== CODEC_ID_PROBE
){
591 AVProbeData
*pd
= &st
->probe_data
;
595 pd
->buf
= av_realloc(pd
->buf
, pd
->buf_size
+pkt
->size
+AVPROBE_PADDING_SIZE
);
596 memcpy(pd
->buf
+pd
->buf_size
, pkt
->data
, pkt
->size
);
597 pd
->buf_size
+= pkt
->size
;
598 memset(pd
->buf
+pd
->buf_size
, 0, AVPROBE_PADDING_SIZE
);
600 if(av_log2(pd
->buf_size
) != av_log2(pd
->buf_size
- pkt
->size
)){
601 set_codec_from_probe_data(s
, st
, pd
, 1);
602 if(st
->codec
->codec_id
!= CODEC_ID_PROBE
){
611 /**********************************************************/
614 * Get the number of samples of an audio frame. Return -1 on error.
616 static int get_audio_frame_size(AVCodecContext
*enc
, int size
)
620 if(enc
->codec_id
== CODEC_ID_VORBIS
)
623 if (enc
->frame_size
<= 1) {
624 int bits_per_sample
= av_get_bits_per_sample(enc
->codec_id
);
626 if (bits_per_sample
) {
627 if (enc
->channels
== 0)
629 frame_size
= (size
<< 3) / (bits_per_sample
* enc
->channels
);
631 /* used for example by ADPCM codecs */
632 if (enc
->bit_rate
== 0)
634 frame_size
= ((int64_t)size
* 8 * enc
->sample_rate
) / enc
->bit_rate
;
637 frame_size
= enc
->frame_size
;
644 * Return the frame duration in seconds. Return 0 if not available.
646 static void compute_frame_duration(int *pnum
, int *pden
, AVStream
*st
,
647 AVCodecParserContext
*pc
, AVPacket
*pkt
)
653 switch(st
->codec
->codec_type
) {
654 case CODEC_TYPE_VIDEO
:
655 if(st
->time_base
.num
*1000LL > st
->time_base
.den
){
656 *pnum
= st
->time_base
.num
;
657 *pden
= st
->time_base
.den
;
658 }else if(st
->codec
->time_base
.num
*1000LL > st
->codec
->time_base
.den
){
659 *pnum
= st
->codec
->time_base
.num
;
660 *pden
= st
->codec
->time_base
.den
;
661 if (pc
&& pc
->repeat_pict
) {
662 *pnum
= (*pnum
) * (1 + pc
->repeat_pict
);
666 case CODEC_TYPE_AUDIO
:
667 frame_size
= get_audio_frame_size(st
->codec
, pkt
->size
);
671 *pden
= st
->codec
->sample_rate
;
678 static int is_intra_only(AVCodecContext
*enc
){
679 if(enc
->codec_type
== CODEC_TYPE_AUDIO
){
681 }else if(enc
->codec_type
== CODEC_TYPE_VIDEO
){
682 switch(enc
->codec_id
){
684 case CODEC_ID_MJPEGB
:
686 case CODEC_ID_RAWVIDEO
:
687 case CODEC_ID_DVVIDEO
:
688 case CODEC_ID_HUFFYUV
:
689 case CODEC_ID_FFVHUFF
:
694 case CODEC_ID_JPEG2000
:
702 static void update_initial_timestamps(AVFormatContext
*s
, int stream_index
,
703 int64_t dts
, int64_t pts
)
705 AVStream
*st
= s
->streams
[stream_index
];
706 AVPacketList
*pktl
= s
->packet_buffer
;
708 if(st
->first_dts
!= AV_NOPTS_VALUE
|| dts
== AV_NOPTS_VALUE
|| st
->cur_dts
== AV_NOPTS_VALUE
)
711 st
->first_dts
= dts
- st
->cur_dts
;
714 for(; pktl
; pktl
= pktl
->next
){
715 if(pktl
->pkt
.stream_index
!= stream_index
)
717 //FIXME think more about this check
718 if(pktl
->pkt
.pts
!= AV_NOPTS_VALUE
&& pktl
->pkt
.pts
== pktl
->pkt
.dts
)
719 pktl
->pkt
.pts
+= st
->first_dts
;
721 if(pktl
->pkt
.dts
!= AV_NOPTS_VALUE
)
722 pktl
->pkt
.dts
+= st
->first_dts
;
724 if(st
->start_time
== AV_NOPTS_VALUE
&& pktl
->pkt
.pts
!= AV_NOPTS_VALUE
)
725 st
->start_time
= pktl
->pkt
.pts
;
727 if (st
->start_time
== AV_NOPTS_VALUE
)
728 st
->start_time
= pts
;
731 static void update_initial_durations(AVFormatContext
*s
, AVStream
*st
, AVPacket
*pkt
)
733 AVPacketList
*pktl
= s
->packet_buffer
;
736 if(st
->first_dts
!= AV_NOPTS_VALUE
){
737 cur_dts
= st
->first_dts
;
738 for(; pktl
; pktl
= pktl
->next
){
739 if(pktl
->pkt
.stream_index
== pkt
->stream_index
){
740 if(pktl
->pkt
.pts
!= pktl
->pkt
.dts
|| pktl
->pkt
.dts
!= AV_NOPTS_VALUE
|| pktl
->pkt
.duration
)
742 cur_dts
-= pkt
->duration
;
745 pktl
= s
->packet_buffer
;
746 st
->first_dts
= cur_dts
;
747 }else if(st
->cur_dts
)
750 for(; pktl
; pktl
= pktl
->next
){
751 if(pktl
->pkt
.stream_index
!= pkt
->stream_index
)
753 if(pktl
->pkt
.pts
== pktl
->pkt
.dts
&& pktl
->pkt
.dts
== AV_NOPTS_VALUE
754 && !pktl
->pkt
.duration
){
755 pktl
->pkt
.dts
= cur_dts
;
756 if(!st
->codec
->has_b_frames
)
757 pktl
->pkt
.pts
= cur_dts
;
758 cur_dts
+= pkt
->duration
;
759 pktl
->pkt
.duration
= pkt
->duration
;
763 if(st
->first_dts
== AV_NOPTS_VALUE
)
764 st
->cur_dts
= cur_dts
;
767 static void compute_pkt_fields(AVFormatContext
*s
, AVStream
*st
,
768 AVCodecParserContext
*pc
, AVPacket
*pkt
)
770 int num
, den
, presentation_delayed
, delay
, i
;
773 if (pc
&& pc
->pict_type
== FF_B_TYPE
)
774 st
->codec
->has_b_frames
= 1;
776 /* do we have a video B-frame ? */
777 delay
= st
->codec
->has_b_frames
;
778 presentation_delayed
= 0;
779 /* XXX: need has_b_frame, but cannot get it if the codec is
782 pc
&& pc
->pict_type
!= FF_B_TYPE
)
783 presentation_delayed
= 1;
785 if(pkt
->pts
!= AV_NOPTS_VALUE
&& pkt
->dts
!= AV_NOPTS_VALUE
&& pkt
->dts
> pkt
->pts
&& st
->pts_wrap_bits
<63
786 /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
787 pkt
->dts
-= 1LL<<st
->pts_wrap_bits
;
790 // some mpeg2 in mpeg-ps lack dts (issue171 / input_file.mpg)
791 // we take the conservative approach and discard both
792 // Note, if this is misbehaving for a H.264 file then possibly presentation_delayed is not set correctly.
793 if(delay
==1 && pkt
->dts
== pkt
->pts
&& pkt
->dts
!= AV_NOPTS_VALUE
&& presentation_delayed
){
794 av_log(s
, AV_LOG_WARNING
, "invalid dts/pts combination\n");
795 pkt
->dts
= pkt
->pts
= AV_NOPTS_VALUE
;
798 if (pkt
->duration
== 0) {
799 compute_frame_duration(&num
, &den
, st
, pc
, pkt
);
801 pkt
->duration
= av_rescale(1, num
* (int64_t)st
->time_base
.den
, den
* (int64_t)st
->time_base
.num
);
803 if(pkt
->duration
!= 0 && s
->packet_buffer
)
804 update_initial_durations(s
, st
, pkt
);
808 /* correct timestamps with byte offset if demuxers only have timestamps
809 on packet boundaries */
810 if(pc
&& st
->need_parsing
== AVSTREAM_PARSE_TIMESTAMPS
&& pkt
->size
){
811 /* this will estimate bitrate based on this frame's duration and size */
812 offset
= av_rescale(pc
->offset
, pkt
->duration
, pkt
->size
);
813 if(pkt
->pts
!= AV_NOPTS_VALUE
)
815 if(pkt
->dts
!= AV_NOPTS_VALUE
)
819 if (pc
&& pc
->dts_sync_point
>= 0) {
820 // we have synchronization info from the parser
821 int64_t den
= st
->codec
->time_base
.den
* (int64_t) st
->time_base
.num
;
823 int64_t num
= st
->codec
->time_base
.num
* (int64_t) st
->time_base
.den
;
824 if (pkt
->dts
!= AV_NOPTS_VALUE
) {
825 // got DTS from the stream, update reference timestamp
826 st
->reference_dts
= pkt
->dts
- pc
->dts_ref_dts_delta
* num
/ den
;
827 pkt
->pts
= pkt
->dts
+ pc
->pts_dts_delta
* num
/ den
;
828 } else if (st
->reference_dts
!= AV_NOPTS_VALUE
) {
829 // compute DTS based on reference timestamp
830 pkt
->dts
= st
->reference_dts
+ pc
->dts_ref_dts_delta
* num
/ den
;
831 pkt
->pts
= pkt
->dts
+ pc
->pts_dts_delta
* num
/ den
;
833 if (pc
->dts_sync_point
> 0)
834 st
->reference_dts
= pkt
->dts
; // new reference
838 /* This may be redundant, but it should not hurt. */
839 if(pkt
->dts
!= AV_NOPTS_VALUE
&& pkt
->pts
!= AV_NOPTS_VALUE
&& pkt
->pts
> pkt
->dts
)
840 presentation_delayed
= 1;
842 // av_log(NULL, AV_LOG_DEBUG, "IN delayed:%d pts:%"PRId64", dts:%"PRId64" cur_dts:%"PRId64" st:%d pc:%p\n", presentation_delayed, pkt->pts, pkt->dts, st->cur_dts, pkt->stream_index, pc);
843 /* interpolate PTS and DTS if they are not present */
844 //We skip H264 currently because delay and has_b_frames are not reliably set
845 if((delay
==0 || (delay
==1 && pc
)) && st
->codec
->codec_id
!= CODEC_ID_H264
){
846 if (presentation_delayed
) {
847 /* DTS = decompression timestamp */
848 /* PTS = presentation timestamp */
849 if (pkt
->dts
== AV_NOPTS_VALUE
)
850 pkt
->dts
= st
->last_IP_pts
;
851 update_initial_timestamps(s
, pkt
->stream_index
, pkt
->dts
, pkt
->pts
);
852 if (pkt
->dts
== AV_NOPTS_VALUE
)
853 pkt
->dts
= st
->cur_dts
;
855 /* this is tricky: the dts must be incremented by the duration
856 of the frame we are displaying, i.e. the last I- or P-frame */
857 if (st
->last_IP_duration
== 0)
858 st
->last_IP_duration
= pkt
->duration
;
859 if(pkt
->dts
!= AV_NOPTS_VALUE
)
860 st
->cur_dts
= pkt
->dts
+ st
->last_IP_duration
;
861 st
->last_IP_duration
= pkt
->duration
;
862 st
->last_IP_pts
= pkt
->pts
;
863 /* cannot compute PTS if not present (we can compute it only
864 by knowing the future */
865 } else if(pkt
->pts
!= AV_NOPTS_VALUE
|| pkt
->dts
!= AV_NOPTS_VALUE
|| pkt
->duration
){
866 if(pkt
->pts
!= AV_NOPTS_VALUE
&& pkt
->duration
){
867 int64_t old_diff
= FFABS(st
->cur_dts
- pkt
->duration
- pkt
->pts
);
868 int64_t new_diff
= FFABS(st
->cur_dts
- pkt
->pts
);
869 if(old_diff
< new_diff
&& old_diff
< (pkt
->duration
>>3)){
870 pkt
->pts
+= pkt
->duration
;
871 // av_log(NULL, AV_LOG_DEBUG, "id:%d old:%"PRId64" new:%"PRId64" dur:%d cur:%"PRId64" size:%d\n", pkt->stream_index, old_diff, new_diff, pkt->duration, st->cur_dts, pkt->size);
875 /* presentation is not delayed : PTS and DTS are the same */
876 if(pkt
->pts
== AV_NOPTS_VALUE
)
878 update_initial_timestamps(s
, pkt
->stream_index
, pkt
->pts
, pkt
->pts
);
879 if(pkt
->pts
== AV_NOPTS_VALUE
)
880 pkt
->pts
= st
->cur_dts
;
882 if(pkt
->pts
!= AV_NOPTS_VALUE
)
883 st
->cur_dts
= pkt
->pts
+ pkt
->duration
;
887 if(pkt
->pts
!= AV_NOPTS_VALUE
&& delay
<= MAX_REORDER_DELAY
){
888 st
->pts_buffer
[0]= pkt
->pts
;
889 for(i
=0; i
<delay
&& st
->pts_buffer
[i
] > st
->pts_buffer
[i
+1]; i
++)
890 FFSWAP(int64_t, st
->pts_buffer
[i
], st
->pts_buffer
[i
+1]);
891 if(pkt
->dts
== AV_NOPTS_VALUE
)
892 pkt
->dts
= st
->pts_buffer
[0];
893 if(st
->codec
->codec_id
== CODEC_ID_H264
){ //we skiped it above so we try here
894 update_initial_timestamps(s
, pkt
->stream_index
, pkt
->dts
, pkt
->pts
); // this should happen on the first packet
896 if(pkt
->dts
> st
->cur_dts
)
897 st
->cur_dts
= pkt
->dts
;
900 // av_log(NULL, AV_LOG_ERROR, "OUTdelayed:%d/%d pts:%"PRId64", dts:%"PRId64" cur_dts:%"PRId64"\n", presentation_delayed, delay, pkt->pts, pkt->dts, st->cur_dts);
903 if(is_intra_only(st
->codec
))
904 pkt
->flags
|= PKT_FLAG_KEY
;
907 /* keyframe computation */
908 if (pc
->key_frame
== 1)
909 pkt
->flags
|= PKT_FLAG_KEY
;
910 else if (pc
->key_frame
== -1 && pc
->pict_type
== FF_I_TYPE
)
911 pkt
->flags
|= PKT_FLAG_KEY
;
914 pkt
->convergence_duration
= pc
->convergence_duration
;
918 static int av_read_frame_internal(AVFormatContext
*s
, AVPacket
*pkt
)
926 /* select current input stream component */
929 if (!st
->need_parsing
|| !st
->parser
) {
930 /* no parsing needed: we just output the packet as is */
931 /* raw data support */
932 *pkt
= st
->cur_pkt
; st
->cur_pkt
.data
= NULL
;
933 compute_pkt_fields(s
, st
, NULL
, pkt
);
935 if ((s
->iformat
->flags
& AVFMT_GENERIC_INDEX
) &&
936 (pkt
->flags
& PKT_FLAG_KEY
) && pkt
->dts
!= AV_NOPTS_VALUE
) {
937 ff_reduce_index(s
, st
->index
);
938 av_add_index_entry(st
, pkt
->pos
, pkt
->dts
, 0, 0, AVINDEX_KEYFRAME
);
941 } else if (st
->cur_len
> 0 && st
->discard
< AVDISCARD_ALL
) {
942 len
= av_parser_parse2(st
->parser
, st
->codec
, &pkt
->data
, &pkt
->size
,
943 st
->cur_ptr
, st
->cur_len
,
944 st
->cur_pkt
.pts
, st
->cur_pkt
.dts
,
946 st
->cur_pkt
.pts
= AV_NOPTS_VALUE
;
947 st
->cur_pkt
.dts
= AV_NOPTS_VALUE
;
948 /* increment read pointer */
952 /* return packet if any */
956 pkt
->stream_index
= st
->index
;
957 pkt
->pts
= st
->parser
->pts
;
958 pkt
->dts
= st
->parser
->dts
;
959 pkt
->pos
= st
->parser
->pos
;
960 pkt
->destruct
= NULL
;
961 compute_pkt_fields(s
, st
, st
->parser
, pkt
);
963 if((s
->iformat
->flags
& AVFMT_GENERIC_INDEX
) && pkt
->flags
& PKT_FLAG_KEY
){
964 ff_reduce_index(s
, st
->index
);
965 av_add_index_entry(st
, st
->parser
->frame_offset
, pkt
->dts
,
966 0, 0, AVINDEX_KEYFRAME
);
973 av_free_packet(&st
->cur_pkt
);
978 /* read next packet */
979 ret
= av_read_packet(s
, &cur_pkt
);
981 if (ret
== AVERROR(EAGAIN
))
983 /* return the last frames, if any */
984 for(i
= 0; i
< s
->nb_streams
; i
++) {
986 if (st
->parser
&& st
->need_parsing
) {
987 av_parser_parse2(st
->parser
, st
->codec
,
988 &pkt
->data
, &pkt
->size
,
990 AV_NOPTS_VALUE
, AV_NOPTS_VALUE
,
996 /* no more packets: really terminate parsing */
999 st
= s
->streams
[cur_pkt
.stream_index
];
1000 st
->cur_pkt
= cur_pkt
;
1002 if(st
->cur_pkt
.pts
!= AV_NOPTS_VALUE
&&
1003 st
->cur_pkt
.dts
!= AV_NOPTS_VALUE
&&
1004 st
->cur_pkt
.pts
< st
->cur_pkt
.dts
){
1005 av_log(s
, AV_LOG_WARNING
, "Invalid timestamps stream=%d, pts=%"PRId64
", dts=%"PRId64
", size=%d\n",
1006 st
->cur_pkt
.stream_index
,
1010 // av_free_packet(&st->cur_pkt);
1014 if(s
->debug
& FF_FDEBUG_TS
)
1015 av_log(s
, AV_LOG_DEBUG
, "av_read_packet stream=%d, pts=%"PRId64
", dts=%"PRId64
", size=%d, flags=%d\n",
1016 st
->cur_pkt
.stream_index
,
1023 st
->cur_ptr
= st
->cur_pkt
.data
;
1024 st
->cur_len
= st
->cur_pkt
.size
;
1025 if (st
->need_parsing
&& !st
->parser
) {
1026 st
->parser
= av_parser_init(st
->codec
->codec_id
);
1028 /* no parser available: just output the raw packets */
1029 st
->need_parsing
= AVSTREAM_PARSE_NONE
;
1030 }else if(st
->need_parsing
== AVSTREAM_PARSE_HEADERS
){
1031 st
->parser
->flags
|= PARSER_FLAG_COMPLETE_FRAMES
;
1033 if(st
->parser
&& (s
->iformat
->flags
& AVFMT_GENERIC_INDEX
)){
1034 st
->parser
->next_frame_offset
=
1035 st
->parser
->cur_offset
= st
->cur_pkt
.pos
;
1040 if(s
->debug
& FF_FDEBUG_TS
)
1041 av_log(s
, AV_LOG_DEBUG
, "av_read_frame_internal stream=%d, pts=%"PRId64
", dts=%"PRId64
", size=%d, flags=%d\n",
1051 int av_read_frame(AVFormatContext
*s
, AVPacket
*pkt
)
1055 const int genpts
= s
->flags
& AVFMT_FLAG_GENPTS
;
1058 pktl
= s
->packet_buffer
;
1060 AVPacket
*next_pkt
= &pktl
->pkt
;
1062 if(genpts
&& next_pkt
->dts
!= AV_NOPTS_VALUE
){
1063 while(pktl
&& next_pkt
->pts
== AV_NOPTS_VALUE
){
1064 if( pktl
->pkt
.stream_index
== next_pkt
->stream_index
1065 && next_pkt
->dts
< pktl
->pkt
.dts
1066 && pktl
->pkt
.pts
!= pktl
->pkt
.dts
//not b frame
1067 /*&& pktl->pkt.dts != AV_NOPTS_VALUE*/){
1068 next_pkt
->pts
= pktl
->pkt
.dts
;
1072 pktl
= s
->packet_buffer
;
1075 if( next_pkt
->pts
!= AV_NOPTS_VALUE
1076 || next_pkt
->dts
== AV_NOPTS_VALUE
1078 /* read packet from packet buffer, if there is data */
1080 s
->packet_buffer
= pktl
->next
;
1086 int ret
= av_read_frame_internal(s
, pkt
);
1088 if(pktl
&& ret
!= AVERROR(EAGAIN
)){
1095 if(av_dup_packet(add_to_pktbuf(&s
->packet_buffer
, pkt
,
1096 &s
->packet_buffer_end
)) < 0)
1097 return AVERROR(ENOMEM
);
1099 assert(!s
->packet_buffer
);
1100 return av_read_frame_internal(s
, pkt
);
1105 /* XXX: suppress the packet queue */
1106 static void flush_packet_queue(AVFormatContext
*s
)
1111 pktl
= s
->packet_buffer
;
1114 s
->packet_buffer
= pktl
->next
;
1115 av_free_packet(&pktl
->pkt
);
1118 while(s
->raw_packet_buffer
){
1119 pktl
= s
->raw_packet_buffer
;
1120 s
->raw_packet_buffer
= pktl
->next
;
1121 av_free_packet(&pktl
->pkt
);
1124 s
->packet_buffer_end
=
1125 s
->raw_packet_buffer_end
= NULL
;
1126 s
->raw_packet_buffer_remaining_size
= RAW_PACKET_BUFFER_SIZE
;
1129 /*******************************************************/
1132 int av_find_default_stream_index(AVFormatContext
*s
)
1134 int first_audio_index
= -1;
1138 if (s
->nb_streams
<= 0)
1140 for(i
= 0; i
< s
->nb_streams
; i
++) {
1142 if (st
->codec
->codec_type
== CODEC_TYPE_VIDEO
) {
1145 if (first_audio_index
< 0 && st
->codec
->codec_type
== CODEC_TYPE_AUDIO
)
1146 first_audio_index
= i
;
1148 return first_audio_index
>= 0 ? first_audio_index
: 0;
1152 * Flush the frame reader.
1154 void av_read_frame_flush(AVFormatContext
*s
)
1159 flush_packet_queue(s
);
1163 /* for each stream, reset read state */
1164 for(i
= 0; i
< s
->nb_streams
; i
++) {
1168 av_parser_close(st
->parser
);
1170 av_free_packet(&st
->cur_pkt
);
1172 st
->last_IP_pts
= AV_NOPTS_VALUE
;
1173 st
->cur_dts
= AV_NOPTS_VALUE
; /* we set the current DTS to an unspecified origin */
1174 st
->reference_dts
= AV_NOPTS_VALUE
;
1179 st
->probe_packets
= MAX_PROBE_PACKETS
;
1183 void av_update_cur_dts(AVFormatContext
*s
, AVStream
*ref_st
, int64_t timestamp
){
1186 for(i
= 0; i
< s
->nb_streams
; i
++) {
1187 AVStream
*st
= s
->streams
[i
];
1189 st
->cur_dts
= av_rescale(timestamp
,
1190 st
->time_base
.den
* (int64_t)ref_st
->time_base
.num
,
1191 st
->time_base
.num
* (int64_t)ref_st
->time_base
.den
);
1195 void ff_reduce_index(AVFormatContext
*s
, int stream_index
)
1197 AVStream
*st
= s
->streams
[stream_index
];
1198 unsigned int max_entries
= s
->max_index_size
/ sizeof(AVIndexEntry
);
1200 if((unsigned)st
->nb_index_entries
>= max_entries
){
1202 for(i
=0; 2*i
<st
->nb_index_entries
; i
++)
1203 st
->index_entries
[i
]= st
->index_entries
[2*i
];
1204 st
->nb_index_entries
= i
;
1208 int av_add_index_entry(AVStream
*st
,
1209 int64_t pos
, int64_t timestamp
, int size
, int distance
, int flags
)
1211 AVIndexEntry
*entries
, *ie
;
1214 if((unsigned)st
->nb_index_entries
+ 1 >= UINT_MAX
/ sizeof(AVIndexEntry
))
1217 entries
= av_fast_realloc(st
->index_entries
,
1218 &st
->index_entries_allocated_size
,
1219 (st
->nb_index_entries
+ 1) *
1220 sizeof(AVIndexEntry
));
1224 st
->index_entries
= entries
;
1226 index
= av_index_search_timestamp(st
, timestamp
, AVSEEK_FLAG_ANY
);
1229 index
= st
->nb_index_entries
++;
1230 ie
= &entries
[index
];
1231 assert(index
==0 || ie
[-1].timestamp
< timestamp
);
1233 ie
= &entries
[index
];
1234 if(ie
->timestamp
!= timestamp
){
1235 if(ie
->timestamp
<= timestamp
)
1237 memmove(entries
+ index
+ 1, entries
+ index
, sizeof(AVIndexEntry
)*(st
->nb_index_entries
- index
));
1238 st
->nb_index_entries
++;
1239 }else if(ie
->pos
== pos
&& distance
< ie
->min_distance
) //do not reduce the distance
1240 distance
= ie
->min_distance
;
1244 ie
->timestamp
= timestamp
;
1245 ie
->min_distance
= distance
;
1252 int av_index_search_timestamp(AVStream
*st
, int64_t wanted_timestamp
,
1255 AVIndexEntry
*entries
= st
->index_entries
;
1256 int nb_entries
= st
->nb_index_entries
;
1265 timestamp
= entries
[m
].timestamp
;
1266 if(timestamp
>= wanted_timestamp
)
1268 if(timestamp
<= wanted_timestamp
)
1271 m
= (flags
& AVSEEK_FLAG_BACKWARD
) ? a
: b
;
1273 if(!(flags
& AVSEEK_FLAG_ANY
)){
1274 while(m
>=0 && m
<nb_entries
&& !(entries
[m
].flags
& AVINDEX_KEYFRAME
)){
1275 m
+= (flags
& AVSEEK_FLAG_BACKWARD
) ? -1 : 1;
1286 int av_seek_frame_binary(AVFormatContext
*s
, int stream_index
, int64_t target_ts
, int flags
){
1287 AVInputFormat
*avif
= s
->iformat
;
1288 int64_t av_uninit(pos_min
), av_uninit(pos_max
), pos
, pos_limit
;
1289 int64_t ts_min
, ts_max
, ts
;
1293 if (stream_index
< 0)
1297 av_log(s
, AV_LOG_DEBUG
, "read_seek: %d %"PRId64
"\n", stream_index
, target_ts
);
1301 ts_min
= AV_NOPTS_VALUE
;
1302 pos_limit
= -1; //gcc falsely says it may be uninitialized
1304 st
= s
->streams
[stream_index
];
1305 if(st
->index_entries
){
1308 index
= av_index_search_timestamp(st
, target_ts
, flags
| AVSEEK_FLAG_BACKWARD
); //FIXME whole func must be checked for non-keyframe entries in index case, especially read_timestamp()
1309 index
= FFMAX(index
, 0);
1310 e
= &st
->index_entries
[index
];
1312 if(e
->timestamp
<= target_ts
|| e
->pos
== e
->min_distance
){
1314 ts_min
= e
->timestamp
;
1316 av_log(s
, AV_LOG_DEBUG
, "using cached pos_min=0x%"PRIx64
" dts_min=%"PRId64
"\n",
1323 index
= av_index_search_timestamp(st
, target_ts
, flags
& ~AVSEEK_FLAG_BACKWARD
);
1324 assert(index
< st
->nb_index_entries
);
1326 e
= &st
->index_entries
[index
];
1327 assert(e
->timestamp
>= target_ts
);
1329 ts_max
= e
->timestamp
;
1330 pos_limit
= pos_max
- e
->min_distance
;
1332 av_log(s
, AV_LOG_DEBUG
, "using cached pos_max=0x%"PRIx64
" pos_limit=0x%"PRIx64
" dts_max=%"PRId64
"\n",
1333 pos_max
,pos_limit
, ts_max
);
1338 pos
= av_gen_search(s
, stream_index
, target_ts
, pos_min
, pos_max
, pos_limit
, ts_min
, ts_max
, flags
, &ts
, avif
->read_timestamp
);
1343 url_fseek(s
->pb
, pos
, SEEK_SET
);
1345 av_update_cur_dts(s
, st
, ts
);
1350 int64_t av_gen_search(AVFormatContext
*s
, int stream_index
, int64_t target_ts
, int64_t pos_min
, int64_t pos_max
, int64_t pos_limit
, int64_t ts_min
, int64_t ts_max
, int flags
, int64_t *ts_ret
, int64_t (*read_timestamp
)(struct AVFormatContext
*, int , int64_t *, int64_t )){
1352 int64_t start_pos
, filesize
;
1356 av_log(s
, AV_LOG_DEBUG
, "gen_seek: %d %"PRId64
"\n", stream_index
, target_ts
);
1359 if(ts_min
== AV_NOPTS_VALUE
){
1360 pos_min
= s
->data_offset
;
1361 ts_min
= read_timestamp(s
, stream_index
, &pos_min
, INT64_MAX
);
1362 if (ts_min
== AV_NOPTS_VALUE
)
1366 if(ts_max
== AV_NOPTS_VALUE
){
1368 filesize
= url_fsize(s
->pb
);
1369 pos_max
= filesize
- 1;
1372 ts_max
= read_timestamp(s
, stream_index
, &pos_max
, pos_max
+ step
);
1374 }while(ts_max
== AV_NOPTS_VALUE
&& pos_max
>= step
);
1375 if (ts_max
== AV_NOPTS_VALUE
)
1379 int64_t tmp_pos
= pos_max
+ 1;
1380 int64_t tmp_ts
= read_timestamp(s
, stream_index
, &tmp_pos
, INT64_MAX
);
1381 if(tmp_ts
== AV_NOPTS_VALUE
)
1385 if(tmp_pos
>= filesize
)
1391 if(ts_min
> ts_max
){
1393 }else if(ts_min
== ts_max
){
1398 while (pos_min
< pos_limit
) {
1400 av_log(s
, AV_LOG_DEBUG
, "pos_min=0x%"PRIx64
" pos_max=0x%"PRIx64
" dts_min=%"PRId64
" dts_max=%"PRId64
"\n",
1404 assert(pos_limit
<= pos_max
);
1407 int64_t approximate_keyframe_distance
= pos_max
- pos_limit
;
1408 // interpolate position (better than dichotomy)
1409 pos
= av_rescale(target_ts
- ts_min
, pos_max
- pos_min
, ts_max
- ts_min
)
1410 + pos_min
- approximate_keyframe_distance
;
1411 }else if(no_change
==1){
1412 // bisection, if interpolation failed to change min or max pos last time
1413 pos
= (pos_min
+ pos_limit
)>>1;
1415 /* linear search if bisection failed, can only happen if there
1416 are very few or no keyframes between min/max */
1421 else if(pos
> pos_limit
)
1425 ts
= read_timestamp(s
, stream_index
, &pos
, INT64_MAX
); //may pass pos_limit instead of -1
1431 av_log(s
, AV_LOG_DEBUG
, "%"PRId64
" %"PRId64
" %"PRId64
" / %"PRId64
" %"PRId64
" %"PRId64
" target:%"PRId64
" limit:%"PRId64
" start:%"PRId64
" noc:%d\n",
1432 pos_min
, pos
, pos_max
, ts_min
, ts
, ts_max
, target_ts
, pos_limit
,
1433 start_pos
, no_change
);
1435 if(ts
== AV_NOPTS_VALUE
){
1436 av_log(s
, AV_LOG_ERROR
, "read_timestamp() failed in the middle\n");
1439 assert(ts
!= AV_NOPTS_VALUE
);
1440 if (target_ts
<= ts
) {
1441 pos_limit
= start_pos
- 1;
1445 if (target_ts
>= ts
) {
1451 pos
= (flags
& AVSEEK_FLAG_BACKWARD
) ? pos_min
: pos_max
;
1452 ts
= (flags
& AVSEEK_FLAG_BACKWARD
) ? ts_min
: ts_max
;
1455 ts_min
= read_timestamp(s
, stream_index
, &pos_min
, INT64_MAX
);
1457 ts_max
= read_timestamp(s
, stream_index
, &pos_min
, INT64_MAX
);
1458 av_log(s
, AV_LOG_DEBUG
, "pos=0x%"PRIx64
" %"PRId64
"<=%"PRId64
"<=%"PRId64
"\n",
1459 pos
, ts_min
, target_ts
, ts_max
);
1465 static int av_seek_frame_byte(AVFormatContext
*s
, int stream_index
, int64_t pos
, int flags
){
1466 int64_t pos_min
, pos_max
;
1470 if (stream_index
< 0)
1473 st
= s
->streams
[stream_index
];
1476 pos_min
= s
->data_offset
;
1477 pos_max
= url_fsize(s
->pb
) - 1;
1479 if (pos
< pos_min
) pos
= pos_min
;
1480 else if(pos
> pos_max
) pos
= pos_max
;
1482 url_fseek(s
->pb
, pos
, SEEK_SET
);
1485 av_update_cur_dts(s
, st
, ts
);
1490 static int av_seek_frame_generic(AVFormatContext
*s
,
1491 int stream_index
, int64_t timestamp
, int flags
)
1497 st
= s
->streams
[stream_index
];
1499 index
= av_index_search_timestamp(st
, timestamp
, flags
);
1501 if(index
< 0 || index
==st
->nb_index_entries
-1){
1505 if(st
->nb_index_entries
){
1506 assert(st
->index_entries
);
1507 ie
= &st
->index_entries
[st
->nb_index_entries
-1];
1508 if ((ret
= url_fseek(s
->pb
, ie
->pos
, SEEK_SET
)) < 0)
1510 av_update_cur_dts(s
, st
, ie
->timestamp
);
1512 if ((ret
= url_fseek(s
->pb
, s
->data_offset
, SEEK_SET
)) < 0)
1518 ret
= av_read_frame(s
, &pkt
);
1519 }while(ret
== AVERROR(EAGAIN
));
1522 av_free_packet(&pkt
);
1523 if(stream_index
== pkt
.stream_index
){
1524 if((pkt
.flags
& PKT_FLAG_KEY
) && pkt
.dts
> timestamp
)
1528 index
= av_index_search_timestamp(st
, timestamp
, flags
);
1533 av_read_frame_flush(s
);
1534 if (s
->iformat
->read_seek
){
1535 if(s
->iformat
->read_seek(s
, stream_index
, timestamp
, flags
) >= 0)
1538 ie
= &st
->index_entries
[index
];
1539 if ((ret
= url_fseek(s
->pb
, ie
->pos
, SEEK_SET
)) < 0)
1541 av_update_cur_dts(s
, st
, ie
->timestamp
);
1546 int av_seek_frame(AVFormatContext
*s
, int stream_index
, int64_t timestamp
, int flags
)
1551 av_read_frame_flush(s
);
1553 if(flags
& AVSEEK_FLAG_BYTE
)
1554 return av_seek_frame_byte(s
, stream_index
, timestamp
, flags
);
1556 if(stream_index
< 0){
1557 stream_index
= av_find_default_stream_index(s
);
1558 if(stream_index
< 0)
1561 st
= s
->streams
[stream_index
];
1562 /* timestamp for default must be expressed in AV_TIME_BASE units */
1563 timestamp
= av_rescale(timestamp
, st
->time_base
.den
, AV_TIME_BASE
* (int64_t)st
->time_base
.num
);
1566 /* first, we try the format specific seek */
1567 if (s
->iformat
->read_seek
)
1568 ret
= s
->iformat
->read_seek(s
, stream_index
, timestamp
, flags
);
1575 if(s
->iformat
->read_timestamp
)
1576 return av_seek_frame_binary(s
, stream_index
, timestamp
, flags
);
1578 return av_seek_frame_generic(s
, stream_index
, timestamp
, flags
);
1581 int avformat_seek_file(AVFormatContext
*s
, int stream_index
, int64_t min_ts
, int64_t ts
, int64_t max_ts
, int flags
)
1583 if(min_ts
> ts
|| max_ts
< ts
)
1586 av_read_frame_flush(s
);
1588 if (s
->iformat
->read_seek2
)
1589 return s
->iformat
->read_seek2(s
, stream_index
, min_ts
, ts
, max_ts
, flags
);
1591 if(s
->iformat
->read_timestamp
){
1592 //try to seek via read_timestamp()
1595 //Fallback to old API if new is not implemented but old is
1596 //Note the old has somewat different sematics
1597 if(s
->iformat
->read_seek
|| 1)
1598 return av_seek_frame(s
, stream_index
, ts
, flags
| (ts
- min_ts
> (uint64_t)(max_ts
- ts
) ? AVSEEK_FLAG_BACKWARD
: 0));
1600 // try some generic seek like av_seek_frame_generic() but with new ts semantics
1603 /*******************************************************/
1606 * Returns TRUE if the stream has accurate duration in any stream.
1608 * @return TRUE if the stream has accurate duration for at least one component.
1610 static int av_has_duration(AVFormatContext
*ic
)
1615 for(i
= 0;i
< ic
->nb_streams
; i
++) {
1616 st
= ic
->streams
[i
];
1617 if (st
->duration
!= AV_NOPTS_VALUE
)
1624 * Estimate the stream timings from the one of each components.
1626 * Also computes the global bitrate if possible.
1628 static void av_update_stream_timings(AVFormatContext
*ic
)
1630 int64_t start_time
, start_time1
, end_time
, end_time1
;
1631 int64_t duration
, duration1
;
1635 start_time
= INT64_MAX
;
1636 end_time
= INT64_MIN
;
1637 duration
= INT64_MIN
;
1638 for(i
= 0;i
< ic
->nb_streams
; i
++) {
1639 st
= ic
->streams
[i
];
1640 if (st
->start_time
!= AV_NOPTS_VALUE
&& st
->time_base
.den
) {
1641 start_time1
= av_rescale_q(st
->start_time
, st
->time_base
, AV_TIME_BASE_Q
);
1642 if (start_time1
< start_time
)
1643 start_time
= start_time1
;
1644 if (st
->duration
!= AV_NOPTS_VALUE
) {
1645 end_time1
= start_time1
1646 + av_rescale_q(st
->duration
, st
->time_base
, AV_TIME_BASE_Q
);
1647 if (end_time1
> end_time
)
1648 end_time
= end_time1
;
1651 if (st
->duration
!= AV_NOPTS_VALUE
) {
1652 duration1
= av_rescale_q(st
->duration
, st
->time_base
, AV_TIME_BASE_Q
);
1653 if (duration1
> duration
)
1654 duration
= duration1
;
1657 if (start_time
!= INT64_MAX
) {
1658 ic
->start_time
= start_time
;
1659 if (end_time
!= INT64_MIN
) {
1660 if (end_time
- start_time
> duration
)
1661 duration
= end_time
- start_time
;
1664 if (duration
!= INT64_MIN
) {
1665 ic
->duration
= duration
;
1666 if (ic
->file_size
> 0) {
1667 /* compute the bitrate */
1668 ic
->bit_rate
= (double)ic
->file_size
* 8.0 * AV_TIME_BASE
/
1669 (double)ic
->duration
;
1674 static void fill_all_stream_timings(AVFormatContext
*ic
)
1679 av_update_stream_timings(ic
);
1680 for(i
= 0;i
< ic
->nb_streams
; i
++) {
1681 st
= ic
->streams
[i
];
1682 if (st
->start_time
== AV_NOPTS_VALUE
) {
1683 if(ic
->start_time
!= AV_NOPTS_VALUE
)
1684 st
->start_time
= av_rescale_q(ic
->start_time
, AV_TIME_BASE_Q
, st
->time_base
);
1685 if(ic
->duration
!= AV_NOPTS_VALUE
)
1686 st
->duration
= av_rescale_q(ic
->duration
, AV_TIME_BASE_Q
, st
->time_base
);
1691 static void av_estimate_timings_from_bit_rate(AVFormatContext
*ic
)
1693 int64_t filesize
, duration
;
1697 /* if bit_rate is already set, we believe it */
1698 if (ic
->bit_rate
== 0) {
1700 for(i
=0;i
<ic
->nb_streams
;i
++) {
1701 st
= ic
->streams
[i
];
1702 bit_rate
+= st
->codec
->bit_rate
;
1704 ic
->bit_rate
= bit_rate
;
1707 /* if duration is already set, we believe it */
1708 if (ic
->duration
== AV_NOPTS_VALUE
&&
1709 ic
->bit_rate
!= 0 &&
1710 ic
->file_size
!= 0) {
1711 filesize
= ic
->file_size
;
1713 for(i
= 0; i
< ic
->nb_streams
; i
++) {
1714 st
= ic
->streams
[i
];
1715 duration
= av_rescale(8*filesize
, st
->time_base
.den
, ic
->bit_rate
*(int64_t)st
->time_base
.num
);
1716 if (st
->duration
== AV_NOPTS_VALUE
)
1717 st
->duration
= duration
;
1723 #define DURATION_MAX_READ_SIZE 250000
1725 /* only usable for MPEG-PS streams */
1726 static void av_estimate_timings_from_pts(AVFormatContext
*ic
, int64_t old_offset
)
1728 AVPacket pkt1
, *pkt
= &pkt1
;
1730 int read_size
, i
, ret
;
1732 int64_t filesize
, offset
, duration
;
1736 /* flush packet queue */
1737 flush_packet_queue(ic
);
1739 for(i
=0;i
<ic
->nb_streams
;i
++) {
1740 st
= ic
->streams
[i
];
1742 av_parser_close(st
->parser
);
1744 av_free_packet(&st
->cur_pkt
);
1748 /* we read the first packets to get the first PTS (not fully
1749 accurate, but it is enough now) */
1750 url_fseek(ic
->pb
, 0, SEEK_SET
);
1753 if (read_size
>= DURATION_MAX_READ_SIZE
)
1755 /* if all info is available, we can stop */
1756 for(i
= 0;i
< ic
->nb_streams
; i
++) {
1757 st
= ic
->streams
[i
];
1758 if (st
->start_time
== AV_NOPTS_VALUE
)
1761 if (i
== ic
->nb_streams
)
1765 ret
= av_read_packet(ic
, pkt
);
1766 }while(ret
== AVERROR(EAGAIN
));
1769 read_size
+= pkt
->size
;
1770 st
= ic
->streams
[pkt
->stream_index
];
1771 if (pkt
->pts
!= AV_NOPTS_VALUE
) {
1772 if (st
->start_time
== AV_NOPTS_VALUE
)
1773 st
->start_time
= pkt
->pts
;
1775 av_free_packet(pkt
);
1778 /* estimate the end time (duration) */
1779 /* XXX: may need to support wrapping */
1780 filesize
= ic
->file_size
;
1781 offset
= filesize
- DURATION_MAX_READ_SIZE
;
1785 url_fseek(ic
->pb
, offset
, SEEK_SET
);
1788 if (read_size
>= DURATION_MAX_READ_SIZE
)
1792 ret
= av_read_packet(ic
, pkt
);
1793 }while(ret
== AVERROR(EAGAIN
));
1796 read_size
+= pkt
->size
;
1797 st
= ic
->streams
[pkt
->stream_index
];
1798 if (pkt
->pts
!= AV_NOPTS_VALUE
&&
1799 st
->start_time
!= AV_NOPTS_VALUE
) {
1800 end_time
= pkt
->pts
;
1801 duration
= end_time
- st
->start_time
;
1803 if (st
->duration
== AV_NOPTS_VALUE
||
1804 st
->duration
< duration
)
1805 st
->duration
= duration
;
1808 av_free_packet(pkt
);
1811 fill_all_stream_timings(ic
);
1813 url_fseek(ic
->pb
, old_offset
, SEEK_SET
);
1814 for(i
=0; i
<ic
->nb_streams
; i
++){
1816 st
->cur_dts
= st
->first_dts
;
1817 st
->last_IP_pts
= AV_NOPTS_VALUE
;
1821 static void av_estimate_timings(AVFormatContext
*ic
, int64_t old_offset
)
1825 /* get the file size, if possible */
1826 if (ic
->iformat
->flags
& AVFMT_NOFILE
) {
1829 file_size
= url_fsize(ic
->pb
);
1833 ic
->file_size
= file_size
;
1835 if ((!strcmp(ic
->iformat
->name
, "mpeg") ||
1836 !strcmp(ic
->iformat
->name
, "mpegts")) &&
1837 file_size
&& !url_is_streamed(ic
->pb
)) {
1838 /* get accurate estimate from the PTSes */
1839 av_estimate_timings_from_pts(ic
, old_offset
);
1840 } else if (av_has_duration(ic
)) {
1841 /* at least one component has timings - we use them for all
1843 fill_all_stream_timings(ic
);
1845 /* less precise: use bitrate info */
1846 av_estimate_timings_from_bit_rate(ic
);
1848 av_update_stream_timings(ic
);
1854 for(i
= 0;i
< ic
->nb_streams
; i
++) {
1855 st
= ic
->streams
[i
];
1856 printf("%d: start_time: %0.3f duration: %0.3f\n",
1857 i
, (double)st
->start_time
/ AV_TIME_BASE
,
1858 (double)st
->duration
/ AV_TIME_BASE
);
1860 printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1861 (double)ic
->start_time
/ AV_TIME_BASE
,
1862 (double)ic
->duration
/ AV_TIME_BASE
,
1863 ic
->bit_rate
/ 1000);
1868 static int has_codec_parameters(AVCodecContext
*enc
)
1871 switch(enc
->codec_type
) {
1872 case CODEC_TYPE_AUDIO
:
1873 val
= enc
->sample_rate
&& enc
->channels
&& enc
->sample_fmt
!= SAMPLE_FMT_NONE
;
1874 if(!enc
->frame_size
&&
1875 (enc
->codec_id
== CODEC_ID_VORBIS
||
1876 enc
->codec_id
== CODEC_ID_AAC
||
1877 enc
->codec_id
== CODEC_ID_SPEEX
))
1880 case CODEC_TYPE_VIDEO
:
1881 val
= enc
->width
&& enc
->pix_fmt
!= PIX_FMT_NONE
;
1887 return enc
->codec_id
!= CODEC_ID_NONE
&& val
!= 0;
1890 static int try_decode_frame(AVStream
*st
, AVPacket
*avpkt
)
1894 int got_picture
, data_size
, ret
=0;
1897 if(!st
->codec
->codec
){
1898 codec
= avcodec_find_decoder(st
->codec
->codec_id
);
1901 ret
= avcodec_open(st
->codec
, codec
);
1906 if(!has_codec_parameters(st
->codec
)){
1907 switch(st
->codec
->codec_type
) {
1908 case CODEC_TYPE_VIDEO
:
1909 avcodec_get_frame_defaults(&picture
);
1910 ret
= avcodec_decode_video2(st
->codec
, &picture
,
1911 &got_picture
, avpkt
);
1913 case CODEC_TYPE_AUDIO
:
1914 data_size
= FFMAX(avpkt
->size
, AVCODEC_MAX_AUDIO_FRAME_SIZE
);
1915 samples
= av_malloc(data_size
);
1918 ret
= avcodec_decode_audio3(st
->codec
, samples
,
1930 unsigned int ff_codec_get_tag(const AVCodecTag
*tags
, int id
)
1932 while (tags
->id
!= CODEC_ID_NONE
) {
1940 enum CodecID
ff_codec_get_id(const AVCodecTag
*tags
, unsigned int tag
)
1943 for(i
=0; tags
[i
].id
!= CODEC_ID_NONE
;i
++) {
1944 if(tag
== tags
[i
].tag
)
1947 for(i
=0; tags
[i
].id
!= CODEC_ID_NONE
; i
++) {
1948 if( toupper((tag
>> 0)&0xFF) == toupper((tags
[i
].tag
>> 0)&0xFF)
1949 && toupper((tag
>> 8)&0xFF) == toupper((tags
[i
].tag
>> 8)&0xFF)
1950 && toupper((tag
>>16)&0xFF) == toupper((tags
[i
].tag
>>16)&0xFF)
1951 && toupper((tag
>>24)&0xFF) == toupper((tags
[i
].tag
>>24)&0xFF))
1954 return CODEC_ID_NONE
;
1957 unsigned int av_codec_get_tag(const AVCodecTag
* const *tags
, enum CodecID id
)
1960 for(i
=0; tags
&& tags
[i
]; i
++){
1961 int tag
= ff_codec_get_tag(tags
[i
], id
);
1967 enum CodecID
av_codec_get_id(const AVCodecTag
* const *tags
, unsigned int tag
)
1970 for(i
=0; tags
&& tags
[i
]; i
++){
1971 enum CodecID id
= ff_codec_get_id(tags
[i
], tag
);
1972 if(id
!=CODEC_ID_NONE
) return id
;
1974 return CODEC_ID_NONE
;
1977 static void compute_chapters_end(AVFormatContext
*s
)
1981 for (i
=0; i
+1<s
->nb_chapters
; i
++)
1982 if (s
->chapters
[i
]->end
== AV_NOPTS_VALUE
) {
1983 assert(s
->chapters
[i
]->start
<= s
->chapters
[i
+1]->start
);
1984 assert(!av_cmp_q(s
->chapters
[i
]->time_base
, s
->chapters
[i
+1]->time_base
));
1985 s
->chapters
[i
]->end
= s
->chapters
[i
+1]->start
;
1988 if (s
->nb_chapters
&& s
->chapters
[i
]->end
== AV_NOPTS_VALUE
) {
1989 assert(s
->start_time
!= AV_NOPTS_VALUE
);
1990 assert(s
->duration
> 0);
1991 s
->chapters
[i
]->end
= av_rescale_q(s
->start_time
+ s
->duration
,
1993 s
->chapters
[i
]->time_base
);
1997 #define MAX_STD_TIMEBASES (60*12+5)
1998 static int get_std_framerate(int i
){
1999 if(i
<60*12) return i
*1001;
2000 else return ((const int[]){24,30,60,12,15})[i
-60*12]*1000*12;
2004 * Is the time base unreliable.
2005 * This is a heuristic to balance between quick acceptance of the values in
2006 * the headers vs. some extra checks.
2007 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2008 * MPEG-2 commonly misuses field repeat flags to store different framerates.
2009 * And there are "variable" fps files this needs to detect as well.
2011 static int tb_unreliable(AVCodecContext
*c
){
2012 if( c
->time_base
.den
>= 101L*c
->time_base
.num
2013 || c
->time_base
.den
< 5L*c
->time_base
.num
2014 /* || c->codec_tag == AV_RL32("DIVX")
2015 || c->codec_tag == AV_RL32("XVID")*/
2016 || c
->codec_id
== CODEC_ID_MPEG2VIDEO
2017 || c
->codec_id
== CODEC_ID_H264
2023 int av_find_stream_info(AVFormatContext
*ic
)
2025 int i
, count
, ret
, read_size
, j
;
2027 AVPacket pkt1
, *pkt
;
2028 int64_t last_dts
[MAX_STREAMS
];
2029 int64_t duration_gcd
[MAX_STREAMS
]={0};
2030 int duration_count
[MAX_STREAMS
]={0};
2031 double (*duration_error
)[MAX_STD_TIMEBASES
];
2032 int64_t old_offset
= url_ftell(ic
->pb
);
2033 int64_t codec_info_duration
[MAX_STREAMS
]={0};
2034 int codec_info_nb_frames
[MAX_STREAMS
]={0};
2036 duration_error
= av_mallocz(MAX_STREAMS
* sizeof(*duration_error
));
2037 if (!duration_error
) return AVERROR(ENOMEM
);
2039 for(i
=0;i
<ic
->nb_streams
;i
++) {
2040 st
= ic
->streams
[i
];
2041 if(st
->codec
->codec_type
== CODEC_TYPE_VIDEO
){
2042 /* if(!st->time_base.num)
2044 if(!st
->codec
->time_base
.num
)
2045 st
->codec
->time_base
= st
->time_base
;
2047 //only for the split stuff
2049 st
->parser
= av_parser_init(st
->codec
->codec_id
);
2050 if(st
->need_parsing
== AVSTREAM_PARSE_HEADERS
&& st
->parser
){
2051 st
->parser
->flags
|= PARSER_FLAG_COMPLETE_FRAMES
;
2056 for(i
=0;i
<MAX_STREAMS
;i
++){
2057 last_dts
[i
]= AV_NOPTS_VALUE
;
2063 if(url_interrupt_cb()){
2064 ret
= AVERROR(EINTR
);
2065 av_log(ic
, AV_LOG_DEBUG
, "interrupted\n");
2069 /* check if one codec still needs to be handled */
2070 for(i
=0;i
<ic
->nb_streams
;i
++) {
2071 st
= ic
->streams
[i
];
2072 if (!has_codec_parameters(st
->codec
))
2074 /* variable fps and no guess at the real fps */
2075 if( tb_unreliable(st
->codec
)
2076 && duration_count
[i
]<20 && st
->codec
->codec_type
== CODEC_TYPE_VIDEO
)
2078 if(st
->parser
&& st
->parser
->parser
->split
&& !st
->codec
->extradata
)
2080 if(st
->first_dts
== AV_NOPTS_VALUE
)
2083 if (i
== ic
->nb_streams
) {
2084 /* NOTE: if the format has no header, then we need to read
2085 some packets to get most of the streams, so we cannot
2087 if (!(ic
->ctx_flags
& AVFMTCTX_NOHEADER
)) {
2088 /* if we found the info for all the codecs, we can stop */
2090 av_log(ic
, AV_LOG_DEBUG
, "All info found\n");
2094 /* we did not get all the codec info, but we read too much data */
2095 if (read_size
>= ic
->probesize
) {
2097 av_log(ic
, AV_LOG_WARNING
, "MAX_READ_SIZE:%d reached\n", ic
->probesize
);
2101 /* NOTE: a new stream can be added there if no header in file
2102 (AVFMTCTX_NOHEADER) */
2103 ret
= av_read_frame_internal(ic
, &pkt1
);
2104 if(ret
== AVERROR(EAGAIN
))
2108 ret
= -1; /* we could not have all the codec parameters before EOF */
2109 for(i
=0;i
<ic
->nb_streams
;i
++) {
2110 st
= ic
->streams
[i
];
2111 if (!has_codec_parameters(st
->codec
)){
2113 avcodec_string(buf
, sizeof(buf
), st
->codec
, 0);
2114 av_log(ic
, AV_LOG_WARNING
, "Could not find codec parameters (%s)\n", buf
);
2122 pkt
= add_to_pktbuf(&ic
->packet_buffer
, &pkt1
, &ic
->packet_buffer_end
);
2123 if(av_dup_packet(pkt
) < 0) {
2124 av_free(duration_error
);
2125 return AVERROR(ENOMEM
);
2128 read_size
+= pkt
->size
;
2130 st
= ic
->streams
[pkt
->stream_index
];
2131 if(codec_info_nb_frames
[st
->index
]>1) {
2132 if (st
->time_base
.den
> 0 && av_rescale_q(codec_info_duration
[st
->index
], st
->time_base
, AV_TIME_BASE_Q
) >= ic
->max_analyze_duration
){
2133 av_log(ic
, AV_LOG_WARNING
, "max_analyze_duration reached\n");
2136 codec_info_duration
[st
->index
] += pkt
->duration
;
2138 if (pkt
->duration
!= 0)
2139 codec_info_nb_frames
[st
->index
]++;
2142 int index
= pkt
->stream_index
;
2143 int64_t last
= last_dts
[index
];
2144 int64_t duration
= pkt
->dts
- last
;
2146 if(pkt
->dts
!= AV_NOPTS_VALUE
&& last
!= AV_NOPTS_VALUE
&& duration
>0){
2147 double dur
= duration
* av_q2d(st
->time_base
);
2149 // if(st->codec->codec_type == CODEC_TYPE_VIDEO)
2150 // av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
2151 if(duration_count
[index
] < 2)
2152 memset(duration_error
[index
], 0, sizeof(*duration_error
));
2153 for(i
=1; i
<MAX_STD_TIMEBASES
; i
++){
2154 int framerate
= get_std_framerate(i
);
2155 int ticks
= lrintf(dur
*framerate
/(1001*12));
2156 double error
= dur
- ticks
*1001*12/(double)framerate
;
2157 duration_error
[index
][i
] += error
*error
;
2159 duration_count
[index
]++;
2160 // ignore the first 4 values, they might have some random jitter
2161 if (duration_count
[index
] > 3)
2162 duration_gcd
[index
] = av_gcd(duration_gcd
[index
], duration
);
2164 if(last
== AV_NOPTS_VALUE
|| duration_count
[index
]<=1)
2165 last_dts
[pkt
->stream_index
]= pkt
->dts
;
2167 if(st
->parser
&& st
->parser
->parser
->split
&& !st
->codec
->extradata
){
2168 int i
= st
->parser
->parser
->split(st
->codec
, pkt
->data
, pkt
->size
);
2170 st
->codec
->extradata_size
= i
;
2171 st
->codec
->extradata
= av_malloc(st
->codec
->extradata_size
+ FF_INPUT_BUFFER_PADDING_SIZE
);
2172 memcpy(st
->codec
->extradata
, pkt
->data
, st
->codec
->extradata_size
);
2173 memset(st
->codec
->extradata
+ i
, 0, FF_INPUT_BUFFER_PADDING_SIZE
);
2177 /* if still no information, we try to open the codec and to
2178 decompress the frame. We try to avoid that in most cases as
2179 it takes longer and uses more memory. For MPEG-4, we need to
2180 decompress for QuickTime. */
2181 if (!has_codec_parameters(st
->codec
) /*&&
2182 (st->codec->codec_id == CODEC_ID_FLV1 ||
2183 st->codec->codec_id == CODEC_ID_H264 ||
2184 st->codec->codec_id == CODEC_ID_H263 ||
2185 st->codec->codec_id == CODEC_ID_H261 ||
2186 st->codec->codec_id == CODEC_ID_VORBIS ||
2187 st->codec->codec_id == CODEC_ID_MJPEG ||
2188 st->codec->codec_id == CODEC_ID_PNG ||
2189 st->codec->codec_id == CODEC_ID_PAM ||
2190 st->codec->codec_id == CODEC_ID_PGM ||
2191 st->codec->codec_id == CODEC_ID_PGMYUV ||
2192 st->codec->codec_id == CODEC_ID_PBM ||
2193 st->codec->codec_id == CODEC_ID_PPM ||
2194 st->codec->codec_id == CODEC_ID_SHORTEN ||
2195 (st->codec->codec_id == CODEC_ID_MPEG4 && !st->need_parsing))*/)
2196 try_decode_frame(st
, pkt
);
2201 // close codecs which were opened in try_decode_frame()
2202 for(i
=0;i
<ic
->nb_streams
;i
++) {
2203 st
= ic
->streams
[i
];
2204 if(st
->codec
->codec
)
2205 avcodec_close(st
->codec
);
2207 for(i
=0;i
<ic
->nb_streams
;i
++) {
2208 st
= ic
->streams
[i
];
2209 if (st
->codec
->codec_type
== CODEC_TYPE_VIDEO
) {
2210 if(st
->codec
->codec_id
== CODEC_ID_RAWVIDEO
&& !st
->codec
->codec_tag
&& !st
->codec
->bits_per_coded_sample
)
2211 st
->codec
->codec_tag
= avcodec_pix_fmt_to_codec_tag(st
->codec
->pix_fmt
);
2213 // the check for tb_unreliable() is not completely correct, since this is not about handling
2214 // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2215 // ipmovie.c produces.
2216 if (tb_unreliable(st
->codec
) && duration_count
[i
] > 15 && duration_gcd
[i
] > 1)
2217 av_reduce(&st
->r_frame_rate
.num
, &st
->r_frame_rate
.den
, st
->time_base
.den
, st
->time_base
.num
* duration_gcd
[i
], INT_MAX
);
2218 if(duration_count
[i
]
2219 && tb_unreliable(st
->codec
) /*&&
2220 //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2221 st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den*/){
2223 double best_error
= 2*av_q2d(st
->time_base
);
2224 best_error
= best_error
*best_error
*duration_count
[i
]*1000*12*30;
2226 for(j
=1; j
<MAX_STD_TIMEBASES
; j
++){
2227 double error
= duration_error
[i
][j
] * get_std_framerate(j
);
2228 // if(st->codec->codec_type == CODEC_TYPE_VIDEO)
2229 // av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
2230 if(error
< best_error
){
2232 num
= get_std_framerate(j
);
2235 // do not increase frame rate by more than 1 % in order to match a standard rate.
2236 if (num
&& (!st
->r_frame_rate
.num
|| (double)num
/(12*1001) < 1.01 * av_q2d(st
->r_frame_rate
)))
2237 av_reduce(&st
->r_frame_rate
.num
, &st
->r_frame_rate
.den
, num
, 12*1001, INT_MAX
);
2240 if (!st
->r_frame_rate
.num
){
2241 if( st
->codec
->time_base
.den
* (int64_t)st
->time_base
.num
2242 <= st
->codec
->time_base
.num
* st
->codec
->ticks_per_frame
* (int64_t)st
->time_base
.den
){
2243 st
->r_frame_rate
.num
= st
->codec
->time_base
.den
;
2244 st
->r_frame_rate
.den
= st
->codec
->time_base
.num
* st
->codec
->ticks_per_frame
;
2246 st
->r_frame_rate
.num
= st
->time_base
.den
;
2247 st
->r_frame_rate
.den
= st
->time_base
.num
;
2250 }else if(st
->codec
->codec_type
== CODEC_TYPE_AUDIO
) {
2251 if(!st
->codec
->bits_per_coded_sample
)
2252 st
->codec
->bits_per_coded_sample
= av_get_bits_per_sample(st
->codec
->codec_id
);
2256 av_estimate_timings(ic
, old_offset
);
2258 compute_chapters_end(ic
);
2261 /* correct DTS for B-frame streams with no timestamps */
2262 for(i
=0;i
<ic
->nb_streams
;i
++) {
2263 st
= ic
->streams
[i
];
2264 if (st
->codec
->codec_type
== CODEC_TYPE_VIDEO
) {
2266 ppktl
= &ic
->packet_buffer
;
2268 if(ppkt1
->stream_index
!= i
)
2270 if(ppkt1
->pkt
->dts
< 0)
2272 if(ppkt1
->pkt
->pts
!= AV_NOPTS_VALUE
)
2274 ppkt1
->pkt
->dts
-= delta
;
2279 st
->cur_dts
-= delta
;
2285 av_free(duration_error
);
2290 /*******************************************************/
2292 int av_read_play(AVFormatContext
*s
)
2294 if (s
->iformat
->read_play
)
2295 return s
->iformat
->read_play(s
);
2297 return av_url_read_fpause(s
->pb
, 0);
2298 return AVERROR(ENOSYS
);
2301 int av_read_pause(AVFormatContext
*s
)
2303 if (s
->iformat
->read_pause
)
2304 return s
->iformat
->read_pause(s
);
2306 return av_url_read_fpause(s
->pb
, 1);
2307 return AVERROR(ENOSYS
);
2310 void av_close_input_stream(AVFormatContext
*s
)
2315 if (s
->iformat
->read_close
)
2316 s
->iformat
->read_close(s
);
2317 for(i
=0;i
<s
->nb_streams
;i
++) {
2318 /* free all data in a stream component */
2321 av_parser_close(st
->parser
);
2322 av_free_packet(&st
->cur_pkt
);
2324 av_metadata_free(&st
->metadata
);
2325 av_free(st
->index_entries
);
2326 av_free(st
->codec
->extradata
);
2328 #if LIBAVFORMAT_VERSION_INT < (53<<16)
2329 av_free(st
->filename
);
2331 av_free(st
->priv_data
);
2334 for(i
=s
->nb_programs
-1; i
>=0; i
--) {
2335 #if LIBAVFORMAT_VERSION_INT < (53<<16)
2336 av_freep(&s
->programs
[i
]->provider_name
);
2337 av_freep(&s
->programs
[i
]->name
);
2339 av_metadata_free(&s
->programs
[i
]->metadata
);
2340 av_freep(&s
->programs
[i
]->stream_index
);
2341 av_freep(&s
->programs
[i
]);
2343 av_freep(&s
->programs
);
2344 flush_packet_queue(s
);
2345 av_freep(&s
->priv_data
);
2346 while(s
->nb_chapters
--) {
2347 #if LIBAVFORMAT_VERSION_INT < (53<<16)
2348 av_free(s
->chapters
[s
->nb_chapters
]->title
);
2350 av_metadata_free(&s
->chapters
[s
->nb_chapters
]->metadata
);
2351 av_free(s
->chapters
[s
->nb_chapters
]);
2353 av_freep(&s
->chapters
);
2354 av_metadata_free(&s
->metadata
);
2358 void av_close_input_file(AVFormatContext
*s
)
2360 ByteIOContext
*pb
= s
->iformat
->flags
& AVFMT_NOFILE
? NULL
: s
->pb
;
2361 av_close_input_stream(s
);
2366 AVStream
*av_new_stream(AVFormatContext
*s
, int id
)
2371 if (s
->nb_streams
>= MAX_STREAMS
)
2374 st
= av_mallocz(sizeof(AVStream
));
2378 st
->codec
= avcodec_alloc_context();
2380 /* no default bitrate if decoding */
2381 st
->codec
->bit_rate
= 0;
2383 st
->index
= s
->nb_streams
;
2385 st
->start_time
= AV_NOPTS_VALUE
;
2386 st
->duration
= AV_NOPTS_VALUE
;
2387 /* we set the current DTS to 0 so that formats without any timestamps
2388 but durations get some timestamps, formats with some unknown
2389 timestamps have their first few packets buffered and the
2390 timestamps corrected before they are returned to the user */
2392 st
->first_dts
= AV_NOPTS_VALUE
;
2393 st
->probe_packets
= MAX_PROBE_PACKETS
;
2395 /* default pts setting is MPEG-like */
2396 av_set_pts_info(st
, 33, 1, 90000);
2397 st
->last_IP_pts
= AV_NOPTS_VALUE
;
2398 for(i
=0; i
<MAX_REORDER_DELAY
+1; i
++)
2399 st
->pts_buffer
[i
]= AV_NOPTS_VALUE
;
2400 st
->reference_dts
= AV_NOPTS_VALUE
;
2402 st
->sample_aspect_ratio
= (AVRational
){0,1};
2404 s
->streams
[s
->nb_streams
++] = st
;
2408 AVProgram
*av_new_program(AVFormatContext
*ac
, int id
)
2410 AVProgram
*program
=NULL
;
2414 av_log(ac
, AV_LOG_DEBUG
, "new_program: id=0x%04x\n", id
);
2417 for(i
=0; i
<ac
->nb_programs
; i
++)
2418 if(ac
->programs
[i
]->id
== id
)
2419 program
= ac
->programs
[i
];
2422 program
= av_mallocz(sizeof(AVProgram
));
2425 dynarray_add(&ac
->programs
, &ac
->nb_programs
, program
);
2426 program
->discard
= AVDISCARD_NONE
;
2433 AVChapter
*ff_new_chapter(AVFormatContext
*s
, int id
, AVRational time_base
, int64_t start
, int64_t end
, const char *title
)
2435 AVChapter
*chapter
= NULL
;
2438 for(i
=0; i
<s
->nb_chapters
; i
++)
2439 if(s
->chapters
[i
]->id
== id
)
2440 chapter
= s
->chapters
[i
];
2443 chapter
= av_mallocz(sizeof(AVChapter
));
2446 dynarray_add(&s
->chapters
, &s
->nb_chapters
, chapter
);
2448 #if LIBAVFORMAT_VERSION_INT < (53<<16)
2449 av_free(chapter
->title
);
2451 av_metadata_set(&chapter
->metadata
, "title", title
);
2453 chapter
->time_base
= time_base
;
2454 chapter
->start
= start
;
2460 /************************************************************/
2461 /* output media file */
2463 int av_set_parameters(AVFormatContext
*s
, AVFormatParameters
*ap
)
2467 if (s
->oformat
->priv_data_size
> 0) {
2468 s
->priv_data
= av_mallocz(s
->oformat
->priv_data_size
);
2470 return AVERROR(ENOMEM
);
2472 s
->priv_data
= NULL
;
2474 if (s
->oformat
->set_parameters
) {
2475 ret
= s
->oformat
->set_parameters(s
, ap
);
2482 int av_write_header(AVFormatContext
*s
)
2487 // some sanity checks
2488 for(i
=0;i
<s
->nb_streams
;i
++) {
2491 switch (st
->codec
->codec_type
) {
2492 case CODEC_TYPE_AUDIO
:
2493 if(st
->codec
->sample_rate
<=0){
2494 av_log(s
, AV_LOG_ERROR
, "sample rate not set\n");
2497 if(!st
->codec
->block_align
)
2498 st
->codec
->block_align
= st
->codec
->channels
*
2499 av_get_bits_per_sample(st
->codec
->codec_id
) >> 3;
2501 case CODEC_TYPE_VIDEO
:
2502 if(st
->codec
->time_base
.num
<=0 || st
->codec
->time_base
.den
<=0){ //FIXME audio too?
2503 av_log(s
, AV_LOG_ERROR
, "time base not set\n");
2506 if(st
->codec
->width
<=0 || st
->codec
->height
<=0){
2507 av_log(s
, AV_LOG_ERROR
, "dimensions not set\n");
2510 if(av_cmp_q(st
->sample_aspect_ratio
, st
->codec
->sample_aspect_ratio
)){
2511 av_log(s
, AV_LOG_ERROR
, "Aspect ratio mismatch between encoder and muxer layer\n");
2517 if(s
->oformat
->codec_tag
){
2518 if(st
->codec
->codec_tag
){
2520 //check that tag + id is in the table
2521 //if neither is in the table -> OK
2522 //if tag is in the table with another id -> FAIL
2523 //if id is in the table with another tag -> FAIL unless strict < ?
2525 st
->codec
->codec_tag
= av_codec_get_tag(s
->oformat
->codec_tag
, st
->codec
->codec_id
);
2528 if(s
->oformat
->flags
& AVFMT_GLOBALHEADER
&&
2529 !(st
->codec
->flags
& CODEC_FLAG_GLOBAL_HEADER
))
2530 av_log(s
, AV_LOG_WARNING
, "Codec for stream %d does not use global headers but container format requires global headers\n", i
);
2533 if (!s
->priv_data
&& s
->oformat
->priv_data_size
> 0) {
2534 s
->priv_data
= av_mallocz(s
->oformat
->priv_data_size
);
2536 return AVERROR(ENOMEM
);
2539 #if LIBAVFORMAT_VERSION_MAJOR < 53
2540 ff_metadata_mux_compat(s
);
2543 if(s
->oformat
->write_header
){
2544 ret
= s
->oformat
->write_header(s
);
2549 /* init PTS generation */
2550 for(i
=0;i
<s
->nb_streams
;i
++) {
2551 int64_t den
= AV_NOPTS_VALUE
;
2554 switch (st
->codec
->codec_type
) {
2555 case CODEC_TYPE_AUDIO
:
2556 den
= (int64_t)st
->time_base
.num
* st
->codec
->sample_rate
;
2558 case CODEC_TYPE_VIDEO
:
2559 den
= (int64_t)st
->time_base
.num
* st
->codec
->time_base
.den
;
2564 if (den
!= AV_NOPTS_VALUE
) {
2566 return AVERROR_INVALIDDATA
;
2567 av_frac_init(&st
->pts
, 0, 0, den
);
2573 //FIXME merge with compute_pkt_fields
2574 static int compute_pkt_fields2(AVStream
*st
, AVPacket
*pkt
){
2575 int delay
= FFMAX(st
->codec
->has_b_frames
, !!st
->codec
->max_b_frames
);
2576 int num
, den
, frame_size
, i
;
2578 // av_log(st->codec, AV_LOG_DEBUG, "av_write_frame: pts:%"PRId64" dts:%"PRId64" cur_dts:%"PRId64" b:%d size:%d st:%d\n", pkt->pts, pkt->dts, st->cur_dts, delay, pkt->size, pkt->stream_index);
2580 /* if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2583 /* duration field */
2584 if (pkt
->duration
== 0) {
2585 compute_frame_duration(&num
, &den
, st
, NULL
, pkt
);
2587 pkt
->duration
= av_rescale(1, num
* (int64_t)st
->time_base
.den
* st
->codec
->ticks_per_frame
, den
* (int64_t)st
->time_base
.num
);
2591 if(pkt
->pts
== AV_NOPTS_VALUE
&& pkt
->dts
!= AV_NOPTS_VALUE
&& delay
==0)
2594 //XXX/FIXME this is a temporary hack until all encoders output pts
2595 if((pkt
->pts
== 0 || pkt
->pts
== AV_NOPTS_VALUE
) && pkt
->dts
== AV_NOPTS_VALUE
&& !delay
){
2597 // pkt->pts= st->cur_dts;
2598 pkt
->pts
= st
->pts
.val
;
2601 //calculate dts from pts
2602 if(pkt
->pts
!= AV_NOPTS_VALUE
&& pkt
->dts
== AV_NOPTS_VALUE
&& delay
<= MAX_REORDER_DELAY
){
2603 st
->pts_buffer
[0]= pkt
->pts
;
2604 for(i
=1; i
<delay
+1 && st
->pts_buffer
[i
] == AV_NOPTS_VALUE
; i
++)
2605 st
->pts_buffer
[i
]= (i
-delay
-1) * pkt
->duration
;
2606 for(i
=0; i
<delay
&& st
->pts_buffer
[i
] > st
->pts_buffer
[i
+1]; i
++)
2607 FFSWAP(int64_t, st
->pts_buffer
[i
], st
->pts_buffer
[i
+1]);
2609 pkt
->dts
= st
->pts_buffer
[0];
2612 if(st
->cur_dts
&& st
->cur_dts
!= AV_NOPTS_VALUE
&& st
->cur_dts
>= pkt
->dts
){
2613 av_log(st
->codec
, AV_LOG_ERROR
, "error, non monotone timestamps %"PRId64
" >= %"PRId64
"\n", st
->cur_dts
, pkt
->dts
);
2616 if(pkt
->dts
!= AV_NOPTS_VALUE
&& pkt
->pts
!= AV_NOPTS_VALUE
&& pkt
->pts
< pkt
->dts
){
2617 av_log(st
->codec
, AV_LOG_ERROR
, "error, pts < dts\n");
2621 // av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2622 st
->cur_dts
= pkt
->dts
;
2623 st
->pts
.val
= pkt
->dts
;
2626 switch (st
->codec
->codec_type
) {
2627 case CODEC_TYPE_AUDIO
:
2628 frame_size
= get_audio_frame_size(st
->codec
, pkt
->size
);
2630 /* HACK/FIXME, we skip the initial 0 size packets as they are most
2631 likely equal to the encoder delay, but it would be better if we
2632 had the real timestamps from the encoder */
2633 if (frame_size
>= 0 && (pkt
->size
|| st
->pts
.num
!=st
->pts
.den
>>1 || st
->pts
.val
)) {
2634 av_frac_add(&st
->pts
, (int64_t)st
->time_base
.den
* frame_size
);
2637 case CODEC_TYPE_VIDEO
:
2638 av_frac_add(&st
->pts
, (int64_t)st
->time_base
.den
* st
->codec
->time_base
.num
);
2646 int av_write_frame(AVFormatContext
*s
, AVPacket
*pkt
)
2648 int ret
= compute_pkt_fields2(s
->streams
[pkt
->stream_index
], pkt
);
2650 if(ret
<0 && !(s
->oformat
->flags
& AVFMT_NOTIMESTAMPS
))
2653 ret
= s
->oformat
->write_packet(s
, pkt
);
2655 ret
= url_ferror(s
->pb
);
2659 void ff_interleave_add_packet(AVFormatContext
*s
, AVPacket
*pkt
,
2660 int (*compare
)(AVFormatContext
*, AVPacket
*, AVPacket
*))
2662 AVPacketList
**next_point
, *this_pktl
;
2664 this_pktl
= av_mallocz(sizeof(AVPacketList
));
2665 this_pktl
->pkt
= *pkt
;
2666 pkt
->destruct
= NULL
; // do not free original but only the copy
2667 av_dup_packet(&this_pktl
->pkt
); // duplicate the packet if it uses non-alloced memory
2669 if(s
->streams
[pkt
->stream_index
]->last_in_packet_buffer
){
2670 next_point
= &(s
->streams
[pkt
->stream_index
]->last_in_packet_buffer
->next
);
2672 next_point
= &s
->packet_buffer
;
2675 if(compare(s
, &s
->packet_buffer_end
->pkt
, pkt
)){
2676 while(!compare(s
, &(*next_point
)->pkt
, pkt
)){
2677 next_point
= &(*next_point
)->next
;
2681 next_point
= &(s
->packet_buffer_end
->next
);
2684 assert(!*next_point
);
2686 s
->packet_buffer_end
= this_pktl
;
2689 this_pktl
->next
= *next_point
;
2691 s
->streams
[pkt
->stream_index
]->last_in_packet_buffer
=
2692 *next_point
= this_pktl
;
2695 int ff_interleave_compare_dts(AVFormatContext
*s
, AVPacket
*next
, AVPacket
*pkt
)
2697 AVStream
*st
= s
->streams
[ pkt
->stream_index
];
2698 AVStream
*st2
= s
->streams
[ next
->stream_index
];
2699 int64_t left
= st2
->time_base
.num
* (int64_t)st
->time_base
.den
;
2700 int64_t right
= st
->time_base
.num
* (int64_t)st2
->time_base
.den
;
2702 if (pkt
->dts
== AV_NOPTS_VALUE
)
2705 return next
->dts
* left
> pkt
->dts
* right
; //FIXME this can overflow
2708 int av_interleave_packet_per_dts(AVFormatContext
*s
, AVPacket
*out
, AVPacket
*pkt
, int flush
){
2714 ff_interleave_add_packet(s
, pkt
, ff_interleave_compare_dts
);
2717 for(i
=0; i
< s
->nb_streams
; i
++)
2718 stream_count
+= !!s
->streams
[i
]->last_in_packet_buffer
;
2720 if(stream_count
&& (s
->nb_streams
== stream_count
|| flush
)){
2721 pktl
= s
->packet_buffer
;
2724 s
->packet_buffer
= pktl
->next
;
2725 if(!s
->packet_buffer
)
2726 s
->packet_buffer_end
= NULL
;
2728 if(s
->streams
[out
->stream_index
]->last_in_packet_buffer
== pktl
)
2729 s
->streams
[out
->stream_index
]->last_in_packet_buffer
= NULL
;
2733 av_init_packet(out
);
2739 * Interleaves an AVPacket correctly so it can be muxed.
2740 * @param out the interleaved packet will be output here
2741 * @param in the input packet
2742 * @param flush 1 if no further packets are available as input and all
2743 * remaining packets should be output
2744 * @return 1 if a packet was output, 0 if no packet could be output,
2745 * < 0 if an error occurred
2747 static int av_interleave_packet(AVFormatContext
*s
, AVPacket
*out
, AVPacket
*in
, int flush
){
2748 if(s
->oformat
->interleave_packet
)
2749 return s
->oformat
->interleave_packet(s
, out
, in
, flush
);
2751 return av_interleave_packet_per_dts(s
, out
, in
, flush
);
2754 int av_interleaved_write_frame(AVFormatContext
*s
, AVPacket
*pkt
){
2755 AVStream
*st
= s
->streams
[ pkt
->stream_index
];
2757 //FIXME/XXX/HACK drop zero sized packets
2758 if(st
->codec
->codec_type
== CODEC_TYPE_AUDIO
&& pkt
->size
==0)
2761 //av_log(NULL, AV_LOG_DEBUG, "av_interleaved_write_frame %d %"PRId64" %"PRId64"\n", pkt->size, pkt->dts, pkt->pts);
2762 if(compute_pkt_fields2(st
, pkt
) < 0 && !(s
->oformat
->flags
& AVFMT_NOTIMESTAMPS
))
2765 if(pkt
->dts
== AV_NOPTS_VALUE
&& !(s
->oformat
->flags
& AVFMT_NOTIMESTAMPS
))
2770 int ret
= av_interleave_packet(s
, &opkt
, pkt
, 0);
2771 if(ret
<=0) //FIXME cleanup needed for ret<0 ?
2774 ret
= s
->oformat
->write_packet(s
, &opkt
);
2776 av_free_packet(&opkt
);
2781 if(url_ferror(s
->pb
))
2782 return url_ferror(s
->pb
);
2786 int av_write_trailer(AVFormatContext
*s
)
2792 ret
= av_interleave_packet(s
, &pkt
, NULL
, 1);
2793 if(ret
<0) //FIXME cleanup needed for ret<0 ?
2798 ret
= s
->oformat
->write_packet(s
, &pkt
);
2800 av_free_packet(&pkt
);
2804 if(url_ferror(s
->pb
))
2808 if(s
->oformat
->write_trailer
)
2809 ret
= s
->oformat
->write_trailer(s
);
2812 ret
=url_ferror(s
->pb
);
2813 for(i
=0;i
<s
->nb_streams
;i
++)
2814 av_freep(&s
->streams
[i
]->priv_data
);
2815 av_freep(&s
->priv_data
);
2819 void av_program_add_stream_index(AVFormatContext
*ac
, int progid
, unsigned int idx
)
2822 AVProgram
*program
=NULL
;
2825 for(i
=0; i
<ac
->nb_programs
; i
++){
2826 if(ac
->programs
[i
]->id
!= progid
)
2828 program
= ac
->programs
[i
];
2829 for(j
=0; j
<program
->nb_stream_indexes
; j
++)
2830 if(program
->stream_index
[j
] == idx
)
2833 tmp
= av_realloc(program
->stream_index
, sizeof(unsigned int)*(program
->nb_stream_indexes
+1));
2836 program
->stream_index
= tmp
;
2837 program
->stream_index
[program
->nb_stream_indexes
++] = idx
;
2842 static void print_fps(double d
, const char *postfix
){
2843 uint64_t v
= lrintf(d
*100);
2844 if (v
% 100 ) av_log(NULL
, AV_LOG_INFO
, ", %3.2f %s", d
, postfix
);
2845 else if(v
%(100*1000)) av_log(NULL
, AV_LOG_INFO
, ", %1.0f %s", d
, postfix
);
2846 else av_log(NULL
, AV_LOG_INFO
, ", %1.0fk %s", d
/1000, postfix
);
2849 /* "user interface" functions */
2850 static void dump_stream_format(AVFormatContext
*ic
, int i
, int index
, int is_output
)
2853 int flags
= (is_output
? ic
->oformat
->flags
: ic
->iformat
->flags
);
2854 AVStream
*st
= ic
->streams
[i
];
2855 int g
= av_gcd(st
->time_base
.num
, st
->time_base
.den
);
2856 AVMetadataTag
*lang
= av_metadata_get(st
->metadata
, "language", NULL
, 0);
2857 avcodec_string(buf
, sizeof(buf
), st
->codec
, is_output
);
2858 av_log(NULL
, AV_LOG_INFO
, " Stream #%d.%d", index
, i
);
2859 /* the pid is an important information, so we display it */
2860 /* XXX: add a generic system */
2861 if (flags
& AVFMT_SHOW_IDS
)
2862 av_log(NULL
, AV_LOG_INFO
, "[0x%x]", st
->id
);
2864 av_log(NULL
, AV_LOG_INFO
, "(%s)", lang
->value
);
2865 av_log(NULL
, AV_LOG_DEBUG
, ", %d/%d", st
->time_base
.num
/g
, st
->time_base
.den
/g
);
2866 av_log(NULL
, AV_LOG_INFO
, ": %s", buf
);
2867 if (st
->sample_aspect_ratio
.num
&& // default
2868 av_cmp_q(st
->sample_aspect_ratio
, st
->codec
->sample_aspect_ratio
)) {
2869 AVRational display_aspect_ratio
;
2870 av_reduce(&display_aspect_ratio
.num
, &display_aspect_ratio
.den
,
2871 st
->codec
->width
*st
->sample_aspect_ratio
.num
,
2872 st
->codec
->height
*st
->sample_aspect_ratio
.den
,
2874 av_log(NULL
, AV_LOG_INFO
, ", PAR %d:%d DAR %d:%d",
2875 st
->sample_aspect_ratio
.num
, st
->sample_aspect_ratio
.den
,
2876 display_aspect_ratio
.num
, display_aspect_ratio
.den
);
2878 if(st
->codec
->codec_type
== CODEC_TYPE_VIDEO
){
2879 if(st
->r_frame_rate
.den
&& st
->r_frame_rate
.num
)
2880 print_fps(av_q2d(st
->r_frame_rate
), "tbr");
2881 if(st
->time_base
.den
&& st
->time_base
.num
)
2882 print_fps(1/av_q2d(st
->time_base
), "tbn");
2883 if(st
->codec
->time_base
.den
&& st
->codec
->time_base
.num
)
2884 print_fps(1/av_q2d(st
->codec
->time_base
), "tbc");
2886 av_log(NULL
, AV_LOG_INFO
, "\n");
2889 void dump_format(AVFormatContext
*ic
,
2896 av_log(NULL
, AV_LOG_INFO
, "%s #%d, %s, %s '%s':\n",
2897 is_output
? "Output" : "Input",
2899 is_output
? ic
->oformat
->name
: ic
->iformat
->name
,
2900 is_output
? "to" : "from", url
);
2902 av_log(NULL
, AV_LOG_INFO
, " Duration: ");
2903 if (ic
->duration
!= AV_NOPTS_VALUE
) {
2904 int hours
, mins
, secs
, us
;
2905 secs
= ic
->duration
/ AV_TIME_BASE
;
2906 us
= ic
->duration
% AV_TIME_BASE
;
2911 av_log(NULL
, AV_LOG_INFO
, "%02d:%02d:%02d.%02d", hours
, mins
, secs
,
2912 (100 * us
) / AV_TIME_BASE
);
2914 av_log(NULL
, AV_LOG_INFO
, "N/A");
2916 if (ic
->start_time
!= AV_NOPTS_VALUE
) {
2918 av_log(NULL
, AV_LOG_INFO
, ", start: ");
2919 secs
= ic
->start_time
/ AV_TIME_BASE
;
2920 us
= ic
->start_time
% AV_TIME_BASE
;
2921 av_log(NULL
, AV_LOG_INFO
, "%d.%06d",
2922 secs
, (int)av_rescale(us
, 1000000, AV_TIME_BASE
));
2924 av_log(NULL
, AV_LOG_INFO
, ", bitrate: ");
2926 av_log(NULL
, AV_LOG_INFO
,"%d kb/s", ic
->bit_rate
/ 1000);
2928 av_log(NULL
, AV_LOG_INFO
, "N/A");
2930 av_log(NULL
, AV_LOG_INFO
, "\n");
2932 if(ic
->nb_programs
) {
2934 for(j
=0; j
<ic
->nb_programs
; j
++) {
2935 AVMetadataTag
*name
= av_metadata_get(ic
->programs
[j
]->metadata
,
2937 av_log(NULL
, AV_LOG_INFO
, " Program %d %s\n", ic
->programs
[j
]->id
,
2938 name
? name
->value
: "");
2939 for(k
=0; k
<ic
->programs
[j
]->nb_stream_indexes
; k
++)
2940 dump_stream_format(ic
, ic
->programs
[j
]->stream_index
[k
], index
, is_output
);
2943 for(i
=0;i
<ic
->nb_streams
;i
++)
2944 dump_stream_format(ic
, i
, index
, is_output
);
2946 AVMetadataTag
*tag
=NULL
;
2947 av_log(NULL
, AV_LOG_INFO
, " Metadata\n");
2948 while((tag
=av_metadata_get(ic
->metadata
, "", tag
, AV_METADATA_IGNORE_SUFFIX
))) {
2949 av_log(NULL
, AV_LOG_INFO
, " %-16s: %s\n", tag
->key
, tag
->value
);
2955 #if LIBAVFORMAT_VERSION_MAJOR < 53
2956 int parse_image_size(int *width_ptr
, int *height_ptr
, const char *str
)
2958 return av_parse_video_frame_size(width_ptr
, height_ptr
, str
);
2961 int parse_frame_rate(int *frame_rate_num
, int *frame_rate_den
, const char *arg
)
2963 AVRational frame_rate
;
2964 int ret
= av_parse_video_frame_rate(&frame_rate
, arg
);
2965 *frame_rate_num
= frame_rate
.num
;
2966 *frame_rate_den
= frame_rate
.den
;
2971 int64_t av_gettime(void)
2974 gettimeofday(&tv
,NULL
);
2975 return (int64_t)tv
.tv_sec
* 1000000 + tv
.tv_usec
;
2978 int64_t parse_date(const char *datestr
, int duration
)
2984 static const char * const date_fmt
[] = {
2988 static const char * const time_fmt
[] = {
2998 time_t now
= time(0);
3000 len
= strlen(datestr
);
3002 lastch
= datestr
[len
- 1];
3005 is_utc
= (lastch
== 'z' || lastch
== 'Z');
3007 memset(&dt
, 0, sizeof(dt
));
3012 if (!strncasecmp(datestr
, "now", len
))
3013 return (int64_t) now
* 1000000;
3015 /* parse the year-month-day part */
3016 for (i
= 0; i
< FF_ARRAY_ELEMS(date_fmt
); i
++) {
3017 q
= small_strptime(p
, date_fmt
[i
], &dt
);
3023 /* if the year-month-day part is missing, then take the
3024 * current year-month-day time */
3029 dt
= *localtime(&now
);
3031 dt
.tm_hour
= dt
.tm_min
= dt
.tm_sec
= 0;
3036 if (*p
== 'T' || *p
== 't' || *p
== ' ')
3039 /* parse the hour-minute-second part */
3040 for (i
= 0; i
< FF_ARRAY_ELEMS(time_fmt
); i
++) {
3041 q
= small_strptime(p
, time_fmt
[i
], &dt
);
3047 /* parse datestr as a duration */
3052 /* parse datestr as HH:MM:SS */
3053 q
= small_strptime(p
, time_fmt
[0], &dt
);
3055 /* parse datestr as S+ */
3056 dt
.tm_sec
= strtol(p
, (char **)&q
, 10);
3058 /* the parsing didn't succeed */
3065 /* Now we have all the fields that we can get */
3071 t
= dt
.tm_hour
* 3600 + dt
.tm_min
* 60 + dt
.tm_sec
;
3073 dt
.tm_isdst
= -1; /* unknown */
3083 /* parse the .m... part */
3087 for (val
= 0, n
= 100000; n
>= 1; n
/= 10, q
++) {
3090 val
+= n
* (*q
- '0');
3094 return negative
? -t
: t
;
3097 int find_info_tag(char *arg
, int arg_size
, const char *tag1
, const char *info
)
3107 while (*p
!= '\0' && *p
!= '=' && *p
!= '&') {
3108 if ((q
- tag
) < sizeof(tag
) - 1)
3116 while (*p
!= '&' && *p
!= '\0') {
3117 if ((q
- arg
) < arg_size
- 1) {
3127 if (!strcmp(tag
, tag1
))
3136 int av_get_frame_filename(char *buf
, int buf_size
,
3137 const char *path
, int number
)
3140 char *q
, buf1
[20], c
;
3141 int nd
, len
, percentd_found
;
3153 while (isdigit(*p
)) {
3154 nd
= nd
* 10 + *p
++ - '0';
3157 } while (isdigit(c
));
3166 snprintf(buf1
, sizeof(buf1
), "%0*d", nd
, number
);
3168 if ((q
- buf
+ len
) > buf_size
- 1)
3170 memcpy(q
, buf1
, len
);
3178 if ((q
- buf
) < buf_size
- 1)
3182 if (!percentd_found
)
3191 static void hex_dump_internal(void *avcl
, FILE *f
, int level
, uint8_t *buf
, int size
)
3194 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3196 for(i
=0;i
<size
;i
+=16) {
3203 PRINT(" %02x", buf
[i
+j
]);
3208 for(j
=0;j
<len
;j
++) {
3210 if (c
< ' ' || c
> '~')
3219 void av_hex_dump(FILE *f
, uint8_t *buf
, int size
)
3221 hex_dump_internal(NULL
, f
, 0, buf
, size
);
3224 void av_hex_dump_log(void *avcl
, int level
, uint8_t *buf
, int size
)
3226 hex_dump_internal(avcl
, NULL
, level
, buf
, size
);
3229 //FIXME needs to know the time_base
3230 static void pkt_dump_internal(void *avcl
, FILE *f
, int level
, AVPacket
*pkt
, int dump_payload
)
3232 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3233 PRINT("stream #%d:\n", pkt
->stream_index
);
3234 PRINT(" keyframe=%d\n", ((pkt
->flags
& PKT_FLAG_KEY
) != 0));
3235 PRINT(" duration=%0.3f\n", (double)pkt
->duration
/ AV_TIME_BASE
);
3236 /* DTS is _always_ valid after av_read_frame() */
3238 if (pkt
->dts
== AV_NOPTS_VALUE
)
3241 PRINT("%0.3f", (double)pkt
->dts
/ AV_TIME_BASE
);
3242 /* PTS may not be known if B-frames are present. */
3244 if (pkt
->pts
== AV_NOPTS_VALUE
)
3247 PRINT("%0.3f", (double)pkt
->pts
/ AV_TIME_BASE
);
3249 PRINT(" size=%d\n", pkt
->size
);
3252 av_hex_dump(f
, pkt
->data
, pkt
->size
);
3255 void av_pkt_dump(FILE *f
, AVPacket
*pkt
, int dump_payload
)
3257 pkt_dump_internal(NULL
, f
, 0, pkt
, dump_payload
);
3260 void av_pkt_dump_log(void *avcl
, int level
, AVPacket
*pkt
, int dump_payload
)
3262 pkt_dump_internal(avcl
, NULL
, level
, pkt
, dump_payload
);
3265 void url_split(char *proto
, int proto_size
,
3266 char *authorization
, int authorization_size
,
3267 char *hostname
, int hostname_size
,
3269 char *path
, int path_size
,
3272 const char *p
, *ls
, *at
, *col
, *brk
;
3274 if (port_ptr
) *port_ptr
= -1;
3275 if (proto_size
> 0) proto
[0] = 0;
3276 if (authorization_size
> 0) authorization
[0] = 0;
3277 if (hostname_size
> 0) hostname
[0] = 0;
3278 if (path_size
> 0) path
[0] = 0;
3280 /* parse protocol */
3281 if ((p
= strchr(url
, ':'))) {
3282 av_strlcpy(proto
, url
, FFMIN(proto_size
, p
+ 1 - url
));
3287 /* no protocol means plain filename */
3288 av_strlcpy(path
, url
, path_size
);
3292 /* separate path from hostname */
3293 ls
= strchr(p
, '/');
3295 ls
= strchr(p
, '?');
3297 av_strlcpy(path
, ls
, path_size
);
3299 ls
= &p
[strlen(p
)]; // XXX
3301 /* the rest is hostname, use that to parse auth/port */
3303 /* authorization (user[:pass]@hostname) */
3304 if ((at
= strchr(p
, '@')) && at
< ls
) {
3305 av_strlcpy(authorization
, p
,
3306 FFMIN(authorization_size
, at
+ 1 - p
));
3307 p
= at
+ 1; /* skip '@' */
3310 if (*p
== '[' && (brk
= strchr(p
, ']')) && brk
< ls
) {
3312 av_strlcpy(hostname
, p
+ 1,
3313 FFMIN(hostname_size
, brk
- p
));
3314 if (brk
[1] == ':' && port_ptr
)
3315 *port_ptr
= atoi(brk
+ 2);
3316 } else if ((col
= strchr(p
, ':')) && col
< ls
) {
3317 av_strlcpy(hostname
, p
,
3318 FFMIN(col
+ 1 - p
, hostname_size
));
3319 if (port_ptr
) *port_ptr
= atoi(col
+ 1);
3321 av_strlcpy(hostname
, p
,
3322 FFMIN(ls
+ 1 - p
, hostname_size
));
3326 char *ff_data_to_hex(char *buff
, const uint8_t *src
, int s
)
3329 static const char hex_table
[16] = { '0', '1', '2', '3',
3332 'C', 'D', 'E', 'F' };
3334 for(i
= 0; i
< s
; i
++) {
3335 buff
[i
* 2] = hex_table
[src
[i
] >> 4];
3336 buff
[i
* 2 + 1] = hex_table
[src
[i
] & 0xF];
3342 void av_set_pts_info(AVStream
*s
, int pts_wrap_bits
,
3343 unsigned int pts_num
, unsigned int pts_den
)
3345 s
->pts_wrap_bits
= pts_wrap_bits
;
3347 if(av_reduce(&s
->time_base
.num
, &s
->time_base
.den
, pts_num
, pts_den
, INT_MAX
)){
3348 if(s
->time_base
.num
!= pts_num
)
3349 av_log(NULL
, AV_LOG_DEBUG
, "st:%d removing common factor %d from timebase\n", s
->index
, pts_num
/s
->time_base
.num
);
3351 av_log(NULL
, AV_LOG_WARNING
, "st:%d has too large timebase, reducing\n", s
->index
);
3353 if(!s
->time_base
.num
|| !s
->time_base
.den
)
3354 s
->time_base
.num
= s
->time_base
.den
= 0;