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(AVStream
*st
, AVProbeData
*pd
, int score
)
321 fmt
= av_probe_input_format2(pd
, 1, &score
);
324 if (!strcmp(fmt
->name
, "mp3")) {
325 st
->codec
->codec_id
= CODEC_ID_MP3
;
326 st
->codec
->codec_type
= CODEC_TYPE_AUDIO
;
327 } else if (!strcmp(fmt
->name
, "ac3")) {
328 st
->codec
->codec_id
= CODEC_ID_AC3
;
329 st
->codec
->codec_type
= CODEC_TYPE_AUDIO
;
330 } else if (!strcmp(fmt
->name
, "mpegvideo")) {
331 st
->codec
->codec_id
= CODEC_ID_MPEG2VIDEO
;
332 st
->codec
->codec_type
= CODEC_TYPE_VIDEO
;
333 } else if (!strcmp(fmt
->name
, "m4v")) {
334 st
->codec
->codec_id
= CODEC_ID_MPEG4
;
335 st
->codec
->codec_type
= CODEC_TYPE_VIDEO
;
336 } else if (!strcmp(fmt
->name
, "h264")) {
337 st
->codec
->codec_id
= CODEC_ID_H264
;
338 st
->codec
->codec_type
= CODEC_TYPE_VIDEO
;
339 } else if (!strcmp(fmt
->name
, "dts")) {
340 st
->codec
->codec_id
= CODEC_ID_DTS
;
341 st
->codec
->codec_type
= CODEC_TYPE_AUDIO
;
347 /************************************************************/
348 /* input media file */
351 * Open a media file from an IO stream. 'fmt' must be specified.
353 int av_open_input_stream(AVFormatContext
**ic_ptr
,
354 ByteIOContext
*pb
, const char *filename
,
355 AVInputFormat
*fmt
, AVFormatParameters
*ap
)
359 AVFormatParameters default_ap
;
363 memset(ap
, 0, sizeof(default_ap
));
366 if(!ap
->prealloced_context
)
367 ic
= avformat_alloc_context();
371 err
= AVERROR(ENOMEM
);
376 ic
->duration
= AV_NOPTS_VALUE
;
377 ic
->start_time
= AV_NOPTS_VALUE
;
378 av_strlcpy(ic
->filename
, filename
, sizeof(ic
->filename
));
380 /* allocate private data */
381 if (fmt
->priv_data_size
> 0) {
382 ic
->priv_data
= av_mallocz(fmt
->priv_data_size
);
383 if (!ic
->priv_data
) {
384 err
= AVERROR(ENOMEM
);
388 ic
->priv_data
= NULL
;
391 if (ic
->iformat
->read_header
) {
392 err
= ic
->iformat
->read_header(ic
, ap
);
397 if (pb
&& !ic
->data_offset
)
398 ic
->data_offset
= url_ftell(ic
->pb
);
400 #if LIBAVFORMAT_VERSION_MAJOR < 53
401 ff_metadata_demux_compat(ic
);
404 ic
->raw_packet_buffer_remaining_size
= RAW_PACKET_BUFFER_SIZE
;
411 av_freep(&ic
->priv_data
);
412 for(i
=0;i
<ic
->nb_streams
;i
++) {
413 AVStream
*st
= ic
->streams
[i
];
415 av_free(st
->priv_data
);
416 av_free(st
->codec
->extradata
);
426 /** size of probe buffer, for guessing file type from file contents */
427 #define PROBE_BUF_MIN 2048
428 #define PROBE_BUF_MAX (1<<20)
430 int av_open_input_file(AVFormatContext
**ic_ptr
, const char *filename
,
433 AVFormatParameters
*ap
)
436 AVProbeData probe_data
, *pd
= &probe_data
;
437 ByteIOContext
*pb
= NULL
;
441 pd
->filename
= filename
;
446 /* guess format if no file can be opened */
447 fmt
= av_probe_input_format(pd
, 0);
450 /* Do not open file if the format does not need it. XXX: specific
451 hack needed to handle RTSP/TCP */
452 if (!fmt
|| !(fmt
->flags
& AVFMT_NOFILE
)) {
453 /* if no file needed do not try to open one */
454 if ((err
=url_fopen(&pb
, filename
, URL_RDONLY
)) < 0) {
458 url_setbufsize(pb
, buf_size
);
461 for(probe_size
= PROBE_BUF_MIN
; probe_size
<=PROBE_BUF_MAX
&& !fmt
; probe_size
<<=1){
462 int score
= probe_size
< PROBE_BUF_MAX
? AVPROBE_SCORE_MAX
/4 : 0;
463 /* read probe data */
464 pd
->buf
= av_realloc(pd
->buf
, probe_size
+ AVPROBE_PADDING_SIZE
);
465 pd
->buf_size
= get_buffer(pb
, pd
->buf
, probe_size
);
466 memset(pd
->buf
+pd
->buf_size
, 0, AVPROBE_PADDING_SIZE
);
467 if (url_fseek(pb
, 0, SEEK_SET
) < 0) {
469 if (url_fopen(&pb
, filename
, URL_RDONLY
) < 0) {
475 /* guess file format */
476 fmt
= av_probe_input_format2(pd
, 1, &score
);
481 /* if still no format found, error */
487 /* check filename in case an image number is expected */
488 if (fmt
->flags
& AVFMT_NEEDNUMBER
) {
489 if (!av_filename_number_test(filename
)) {
490 err
= AVERROR_NUMEXPECTED
;
494 err
= av_open_input_stream(ic_ptr
, pb
, filename
, fmt
, ap
);
502 if (ap
&& ap
->prealloced_context
)
509 /*******************************************************/
511 static AVPacket
*add_to_pktbuf(AVPacketList
**packet_buffer
, AVPacket
*pkt
,
512 AVPacketList
**plast_pktl
){
513 AVPacketList
*pktl
= av_mallocz(sizeof(AVPacketList
));
518 (*plast_pktl
)->next
= pktl
;
520 *packet_buffer
= pktl
;
522 /* add the packet in the buffered packet list */
528 int av_read_packet(AVFormatContext
*s
, AVPacket
*pkt
)
534 AVPacketList
*pktl
= s
->raw_packet_buffer
;
538 if(s
->streams
[pkt
->stream_index
]->codec
->codec_id
!= CODEC_ID_PROBE
||
539 !s
->streams
[pkt
->stream_index
]->probe_packets
||
540 s
->raw_packet_buffer_remaining_size
< pkt
->size
){
541 AVProbeData
*pd
= &s
->streams
[pkt
->stream_index
]->probe_data
;
544 s
->raw_packet_buffer
= pktl
->next
;
545 s
->raw_packet_buffer_remaining_size
+= pkt
->size
;
552 ret
= s
->iformat
->read_packet(s
, pkt
);
554 if (!pktl
|| ret
== AVERROR(EAGAIN
))
556 for (i
= 0; i
< s
->nb_streams
; i
++)
557 s
->streams
[i
]->probe_packets
= 0;
560 st
= s
->streams
[pkt
->stream_index
];
562 switch(st
->codec
->codec_type
){
563 case CODEC_TYPE_VIDEO
:
564 if(s
->video_codec_id
) st
->codec
->codec_id
= s
->video_codec_id
;
566 case CODEC_TYPE_AUDIO
:
567 if(s
->audio_codec_id
) st
->codec
->codec_id
= s
->audio_codec_id
;
569 case CODEC_TYPE_SUBTITLE
:
570 if(s
->subtitle_codec_id
)st
->codec
->codec_id
= s
->subtitle_codec_id
;
574 if(!pktl
&& (st
->codec
->codec_id
!= CODEC_ID_PROBE
||
578 add_to_pktbuf(&s
->raw_packet_buffer
, pkt
, &s
->raw_packet_buffer_end
);
579 s
->raw_packet_buffer_remaining_size
-= pkt
->size
;
581 if(st
->codec
->codec_id
== CODEC_ID_PROBE
){
582 AVProbeData
*pd
= &st
->probe_data
;
586 pd
->buf
= av_realloc(pd
->buf
, pd
->buf_size
+pkt
->size
+AVPROBE_PADDING_SIZE
);
587 memcpy(pd
->buf
+pd
->buf_size
, pkt
->data
, pkt
->size
);
588 pd
->buf_size
+= pkt
->size
;
589 memset(pd
->buf
+pd
->buf_size
, 0, AVPROBE_PADDING_SIZE
);
591 if(av_log2(pd
->buf_size
) != av_log2(pd
->buf_size
- pkt
->size
)){
592 set_codec_from_probe_data(st
, pd
, 1);
593 if(st
->codec
->codec_id
!= CODEC_ID_PROBE
){
602 /**********************************************************/
605 * Get the number of samples of an audio frame. Return -1 on error.
607 static int get_audio_frame_size(AVCodecContext
*enc
, int size
)
611 if(enc
->codec_id
== CODEC_ID_VORBIS
)
614 if (enc
->frame_size
<= 1) {
615 int bits_per_sample
= av_get_bits_per_sample(enc
->codec_id
);
617 if (bits_per_sample
) {
618 if (enc
->channels
== 0)
620 frame_size
= (size
<< 3) / (bits_per_sample
* enc
->channels
);
622 /* used for example by ADPCM codecs */
623 if (enc
->bit_rate
== 0)
625 frame_size
= ((int64_t)size
* 8 * enc
->sample_rate
) / enc
->bit_rate
;
628 frame_size
= enc
->frame_size
;
635 * Return the frame duration in seconds. Return 0 if not available.
637 static void compute_frame_duration(int *pnum
, int *pden
, AVStream
*st
,
638 AVCodecParserContext
*pc
, AVPacket
*pkt
)
644 switch(st
->codec
->codec_type
) {
645 case CODEC_TYPE_VIDEO
:
646 if(st
->time_base
.num
*1000LL > st
->time_base
.den
){
647 *pnum
= st
->time_base
.num
;
648 *pden
= st
->time_base
.den
;
649 }else if(st
->codec
->time_base
.num
*1000LL > st
->codec
->time_base
.den
){
650 *pnum
= st
->codec
->time_base
.num
;
651 *pden
= st
->codec
->time_base
.den
;
652 if (pc
&& pc
->repeat_pict
) {
653 *pnum
= (*pnum
) * (1 + pc
->repeat_pict
);
657 case CODEC_TYPE_AUDIO
:
658 frame_size
= get_audio_frame_size(st
->codec
, pkt
->size
);
662 *pden
= st
->codec
->sample_rate
;
669 static int is_intra_only(AVCodecContext
*enc
){
670 if(enc
->codec_type
== CODEC_TYPE_AUDIO
){
672 }else if(enc
->codec_type
== CODEC_TYPE_VIDEO
){
673 switch(enc
->codec_id
){
675 case CODEC_ID_MJPEGB
:
677 case CODEC_ID_RAWVIDEO
:
678 case CODEC_ID_DVVIDEO
:
679 case CODEC_ID_HUFFYUV
:
680 case CODEC_ID_FFVHUFF
:
685 case CODEC_ID_JPEG2000
:
693 static void update_initial_timestamps(AVFormatContext
*s
, int stream_index
,
694 int64_t dts
, int64_t pts
)
696 AVStream
*st
= s
->streams
[stream_index
];
697 AVPacketList
*pktl
= s
->packet_buffer
;
699 if(st
->first_dts
!= AV_NOPTS_VALUE
|| dts
== AV_NOPTS_VALUE
|| st
->cur_dts
== AV_NOPTS_VALUE
)
702 st
->first_dts
= dts
- st
->cur_dts
;
705 for(; pktl
; pktl
= pktl
->next
){
706 if(pktl
->pkt
.stream_index
!= stream_index
)
708 //FIXME think more about this check
709 if(pktl
->pkt
.pts
!= AV_NOPTS_VALUE
&& pktl
->pkt
.pts
== pktl
->pkt
.dts
)
710 pktl
->pkt
.pts
+= st
->first_dts
;
712 if(pktl
->pkt
.dts
!= AV_NOPTS_VALUE
)
713 pktl
->pkt
.dts
+= st
->first_dts
;
715 if(st
->start_time
== AV_NOPTS_VALUE
&& pktl
->pkt
.pts
!= AV_NOPTS_VALUE
)
716 st
->start_time
= pktl
->pkt
.pts
;
718 if (st
->start_time
== AV_NOPTS_VALUE
)
719 st
->start_time
= pts
;
722 static void update_initial_durations(AVFormatContext
*s
, AVStream
*st
, AVPacket
*pkt
)
724 AVPacketList
*pktl
= s
->packet_buffer
;
727 if(st
->first_dts
!= AV_NOPTS_VALUE
){
728 cur_dts
= st
->first_dts
;
729 for(; pktl
; pktl
= pktl
->next
){
730 if(pktl
->pkt
.stream_index
== pkt
->stream_index
){
731 if(pktl
->pkt
.pts
!= pktl
->pkt
.dts
|| pktl
->pkt
.dts
!= AV_NOPTS_VALUE
|| pktl
->pkt
.duration
)
733 cur_dts
-= pkt
->duration
;
736 pktl
= s
->packet_buffer
;
737 st
->first_dts
= cur_dts
;
738 }else if(st
->cur_dts
)
741 for(; pktl
; pktl
= pktl
->next
){
742 if(pktl
->pkt
.stream_index
!= pkt
->stream_index
)
744 if(pktl
->pkt
.pts
== pktl
->pkt
.dts
&& pktl
->pkt
.dts
== AV_NOPTS_VALUE
745 && !pktl
->pkt
.duration
){
746 pktl
->pkt
.dts
= cur_dts
;
747 if(!st
->codec
->has_b_frames
)
748 pktl
->pkt
.pts
= cur_dts
;
749 cur_dts
+= pkt
->duration
;
750 pktl
->pkt
.duration
= pkt
->duration
;
754 if(st
->first_dts
== AV_NOPTS_VALUE
)
755 st
->cur_dts
= cur_dts
;
758 static void compute_pkt_fields(AVFormatContext
*s
, AVStream
*st
,
759 AVCodecParserContext
*pc
, AVPacket
*pkt
)
761 int num
, den
, presentation_delayed
, delay
, i
;
764 if (pc
&& pc
->pict_type
== FF_B_TYPE
)
765 st
->codec
->has_b_frames
= 1;
767 /* do we have a video B-frame ? */
768 delay
= st
->codec
->has_b_frames
;
769 presentation_delayed
= 0;
770 /* XXX: need has_b_frame, but cannot get it if the codec is
773 pc
&& pc
->pict_type
!= FF_B_TYPE
)
774 presentation_delayed
= 1;
776 if(pkt
->pts
!= AV_NOPTS_VALUE
&& pkt
->dts
!= AV_NOPTS_VALUE
&& pkt
->dts
> pkt
->pts
&& st
->pts_wrap_bits
<63
777 /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
778 pkt
->dts
-= 1LL<<st
->pts_wrap_bits
;
781 // some mpeg2 in mpeg-ps lack dts (issue171 / input_file.mpg)
782 // we take the conservative approach and discard both
783 // Note, if this is misbehaving for a H.264 file then possibly presentation_delayed is not set correctly.
784 if(delay
==1 && pkt
->dts
== pkt
->pts
&& pkt
->dts
!= AV_NOPTS_VALUE
&& presentation_delayed
){
785 av_log(s
, AV_LOG_WARNING
, "invalid dts/pts combination\n");
786 pkt
->dts
= pkt
->pts
= AV_NOPTS_VALUE
;
789 if (pkt
->duration
== 0) {
790 compute_frame_duration(&num
, &den
, st
, pc
, pkt
);
792 pkt
->duration
= av_rescale(1, num
* (int64_t)st
->time_base
.den
, den
* (int64_t)st
->time_base
.num
);
794 if(pkt
->duration
!= 0 && s
->packet_buffer
)
795 update_initial_durations(s
, st
, pkt
);
799 /* correct timestamps with byte offset if demuxers only have timestamps
800 on packet boundaries */
801 if(pc
&& st
->need_parsing
== AVSTREAM_PARSE_TIMESTAMPS
&& pkt
->size
){
802 /* this will estimate bitrate based on this frame's duration and size */
803 offset
= av_rescale(pc
->offset
, pkt
->duration
, pkt
->size
);
804 if(pkt
->pts
!= AV_NOPTS_VALUE
)
806 if(pkt
->dts
!= AV_NOPTS_VALUE
)
810 if (pc
&& pc
->dts_sync_point
>= 0) {
811 // we have synchronization info from the parser
812 int64_t den
= st
->codec
->time_base
.den
* (int64_t) st
->time_base
.num
;
814 int64_t num
= st
->codec
->time_base
.num
* (int64_t) st
->time_base
.den
;
815 if (pkt
->dts
!= AV_NOPTS_VALUE
) {
816 // got DTS from the stream, update reference timestamp
817 st
->reference_dts
= pkt
->dts
- pc
->dts_ref_dts_delta
* num
/ den
;
818 pkt
->pts
= pkt
->dts
+ pc
->pts_dts_delta
* num
/ den
;
819 } else if (st
->reference_dts
!= AV_NOPTS_VALUE
) {
820 // compute DTS based on reference timestamp
821 pkt
->dts
= st
->reference_dts
+ pc
->dts_ref_dts_delta
* num
/ den
;
822 pkt
->pts
= pkt
->dts
+ pc
->pts_dts_delta
* num
/ den
;
824 if (pc
->dts_sync_point
> 0)
825 st
->reference_dts
= pkt
->dts
; // new reference
829 /* This may be redundant, but it should not hurt. */
830 if(pkt
->dts
!= AV_NOPTS_VALUE
&& pkt
->pts
!= AV_NOPTS_VALUE
&& pkt
->pts
> pkt
->dts
)
831 presentation_delayed
= 1;
833 // 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);
834 /* interpolate PTS and DTS if they are not present */
835 //We skip H264 currently because delay and has_b_frames are not reliably set
836 if((delay
==0 || (delay
==1 && pc
)) && st
->codec
->codec_id
!= CODEC_ID_H264
){
837 if (presentation_delayed
) {
838 /* DTS = decompression timestamp */
839 /* PTS = presentation timestamp */
840 if (pkt
->dts
== AV_NOPTS_VALUE
)
841 pkt
->dts
= st
->last_IP_pts
;
842 update_initial_timestamps(s
, pkt
->stream_index
, pkt
->dts
, pkt
->pts
);
843 if (pkt
->dts
== AV_NOPTS_VALUE
)
844 pkt
->dts
= st
->cur_dts
;
846 /* this is tricky: the dts must be incremented by the duration
847 of the frame we are displaying, i.e. the last I- or P-frame */
848 if (st
->last_IP_duration
== 0)
849 st
->last_IP_duration
= pkt
->duration
;
850 if(pkt
->dts
!= AV_NOPTS_VALUE
)
851 st
->cur_dts
= pkt
->dts
+ st
->last_IP_duration
;
852 st
->last_IP_duration
= pkt
->duration
;
853 st
->last_IP_pts
= pkt
->pts
;
854 /* cannot compute PTS if not present (we can compute it only
855 by knowing the future */
856 } else if(pkt
->pts
!= AV_NOPTS_VALUE
|| pkt
->dts
!= AV_NOPTS_VALUE
|| pkt
->duration
){
857 if(pkt
->pts
!= AV_NOPTS_VALUE
&& pkt
->duration
){
858 int64_t old_diff
= FFABS(st
->cur_dts
- pkt
->duration
- pkt
->pts
);
859 int64_t new_diff
= FFABS(st
->cur_dts
- pkt
->pts
);
860 if(old_diff
< new_diff
&& old_diff
< (pkt
->duration
>>3)){
861 pkt
->pts
+= pkt
->duration
;
862 // 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);
866 /* presentation is not delayed : PTS and DTS are the same */
867 if(pkt
->pts
== AV_NOPTS_VALUE
)
869 update_initial_timestamps(s
, pkt
->stream_index
, pkt
->pts
, pkt
->pts
);
870 if(pkt
->pts
== AV_NOPTS_VALUE
)
871 pkt
->pts
= st
->cur_dts
;
873 if(pkt
->pts
!= AV_NOPTS_VALUE
)
874 st
->cur_dts
= pkt
->pts
+ pkt
->duration
;
878 if(pkt
->pts
!= AV_NOPTS_VALUE
&& delay
<= MAX_REORDER_DELAY
){
879 st
->pts_buffer
[0]= pkt
->pts
;
880 for(i
=0; i
<delay
&& st
->pts_buffer
[i
] > st
->pts_buffer
[i
+1]; i
++)
881 FFSWAP(int64_t, st
->pts_buffer
[i
], st
->pts_buffer
[i
+1]);
882 if(pkt
->dts
== AV_NOPTS_VALUE
)
883 pkt
->dts
= st
->pts_buffer
[0];
884 if(st
->codec
->codec_id
== CODEC_ID_H264
){ //we skiped it above so we try here
885 update_initial_timestamps(s
, pkt
->stream_index
, pkt
->dts
, pkt
->pts
); // this should happen on the first packet
887 if(pkt
->dts
> st
->cur_dts
)
888 st
->cur_dts
= pkt
->dts
;
891 // 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);
894 if(is_intra_only(st
->codec
))
895 pkt
->flags
|= PKT_FLAG_KEY
;
898 /* keyframe computation */
899 if (pc
->key_frame
== 1)
900 pkt
->flags
|= PKT_FLAG_KEY
;
901 else if (pc
->key_frame
== -1 && pc
->pict_type
== FF_I_TYPE
)
902 pkt
->flags
|= PKT_FLAG_KEY
;
905 pkt
->convergence_duration
= pc
->convergence_duration
;
909 static int av_read_frame_internal(AVFormatContext
*s
, AVPacket
*pkt
)
917 /* select current input stream component */
920 if (!st
->need_parsing
|| !st
->parser
) {
921 /* no parsing needed: we just output the packet as is */
922 /* raw data support */
923 *pkt
= st
->cur_pkt
; st
->cur_pkt
.data
= NULL
;
924 compute_pkt_fields(s
, st
, NULL
, pkt
);
926 if ((s
->iformat
->flags
& AVFMT_GENERIC_INDEX
) &&
927 (pkt
->flags
& PKT_FLAG_KEY
) && pkt
->dts
!= AV_NOPTS_VALUE
) {
928 ff_reduce_index(s
, st
->index
);
929 av_add_index_entry(st
, pkt
->pos
, pkt
->dts
, 0, 0, AVINDEX_KEYFRAME
);
932 } else if (st
->cur_len
> 0 && st
->discard
< AVDISCARD_ALL
) {
933 len
= av_parser_parse2(st
->parser
, st
->codec
, &pkt
->data
, &pkt
->size
,
934 st
->cur_ptr
, st
->cur_len
,
935 st
->cur_pkt
.pts
, st
->cur_pkt
.dts
,
937 st
->cur_pkt
.pts
= AV_NOPTS_VALUE
;
938 st
->cur_pkt
.dts
= AV_NOPTS_VALUE
;
939 /* increment read pointer */
943 /* return packet if any */
947 pkt
->stream_index
= st
->index
;
948 pkt
->pts
= st
->parser
->pts
;
949 pkt
->dts
= st
->parser
->dts
;
950 pkt
->pos
= st
->parser
->pos
;
951 pkt
->destruct
= NULL
;
952 compute_pkt_fields(s
, st
, st
->parser
, pkt
);
954 if((s
->iformat
->flags
& AVFMT_GENERIC_INDEX
) && pkt
->flags
& PKT_FLAG_KEY
){
955 ff_reduce_index(s
, st
->index
);
956 av_add_index_entry(st
, st
->parser
->frame_offset
, pkt
->dts
,
957 0, 0, AVINDEX_KEYFRAME
);
964 av_free_packet(&st
->cur_pkt
);
969 /* read next packet */
970 ret
= av_read_packet(s
, &cur_pkt
);
972 if (ret
== AVERROR(EAGAIN
))
974 /* return the last frames, if any */
975 for(i
= 0; i
< s
->nb_streams
; i
++) {
977 if (st
->parser
&& st
->need_parsing
) {
978 av_parser_parse2(st
->parser
, st
->codec
,
979 &pkt
->data
, &pkt
->size
,
981 AV_NOPTS_VALUE
, AV_NOPTS_VALUE
,
987 /* no more packets: really terminate parsing */
990 st
= s
->streams
[cur_pkt
.stream_index
];
991 st
->cur_pkt
= cur_pkt
;
993 if(st
->cur_pkt
.pts
!= AV_NOPTS_VALUE
&&
994 st
->cur_pkt
.dts
!= AV_NOPTS_VALUE
&&
995 st
->cur_pkt
.pts
< st
->cur_pkt
.dts
){
996 av_log(s
, AV_LOG_WARNING
, "Invalid timestamps stream=%d, pts=%"PRId64
", dts=%"PRId64
", size=%d\n",
997 st
->cur_pkt
.stream_index
,
1001 // av_free_packet(&st->cur_pkt);
1005 if(s
->debug
& FF_FDEBUG_TS
)
1006 av_log(s
, AV_LOG_DEBUG
, "av_read_packet stream=%d, pts=%"PRId64
", dts=%"PRId64
", size=%d, flags=%d\n",
1007 st
->cur_pkt
.stream_index
,
1014 st
->cur_ptr
= st
->cur_pkt
.data
;
1015 st
->cur_len
= st
->cur_pkt
.size
;
1016 if (st
->need_parsing
&& !st
->parser
) {
1017 st
->parser
= av_parser_init(st
->codec
->codec_id
);
1019 /* no parser available: just output the raw packets */
1020 st
->need_parsing
= AVSTREAM_PARSE_NONE
;
1021 }else if(st
->need_parsing
== AVSTREAM_PARSE_HEADERS
){
1022 st
->parser
->flags
|= PARSER_FLAG_COMPLETE_FRAMES
;
1024 if(st
->parser
&& (s
->iformat
->flags
& AVFMT_GENERIC_INDEX
)){
1025 st
->parser
->next_frame_offset
=
1026 st
->parser
->cur_offset
= st
->cur_pkt
.pos
;
1031 if(s
->debug
& FF_FDEBUG_TS
)
1032 av_log(s
, AV_LOG_DEBUG
, "av_read_frame_internal stream=%d, pts=%"PRId64
", dts=%"PRId64
", size=%d, flags=%d\n",
1042 int av_read_frame(AVFormatContext
*s
, AVPacket
*pkt
)
1046 const int genpts
= s
->flags
& AVFMT_FLAG_GENPTS
;
1049 pktl
= s
->packet_buffer
;
1051 AVPacket
*next_pkt
= &pktl
->pkt
;
1053 if(genpts
&& next_pkt
->dts
!= AV_NOPTS_VALUE
){
1054 while(pktl
&& next_pkt
->pts
== AV_NOPTS_VALUE
){
1055 if( pktl
->pkt
.stream_index
== next_pkt
->stream_index
1056 && next_pkt
->dts
< pktl
->pkt
.dts
1057 && pktl
->pkt
.pts
!= pktl
->pkt
.dts
//not b frame
1058 /*&& pktl->pkt.dts != AV_NOPTS_VALUE*/){
1059 next_pkt
->pts
= pktl
->pkt
.dts
;
1063 pktl
= s
->packet_buffer
;
1066 if( next_pkt
->pts
!= AV_NOPTS_VALUE
1067 || next_pkt
->dts
== AV_NOPTS_VALUE
1069 /* read packet from packet buffer, if there is data */
1071 s
->packet_buffer
= pktl
->next
;
1077 int ret
= av_read_frame_internal(s
, pkt
);
1079 if(pktl
&& ret
!= AVERROR(EAGAIN
)){
1086 if(av_dup_packet(add_to_pktbuf(&s
->packet_buffer
, pkt
,
1087 &s
->packet_buffer_end
)) < 0)
1088 return AVERROR(ENOMEM
);
1090 assert(!s
->packet_buffer
);
1091 return av_read_frame_internal(s
, pkt
);
1096 /* XXX: suppress the packet queue */
1097 static void flush_packet_queue(AVFormatContext
*s
)
1102 pktl
= s
->packet_buffer
;
1105 s
->packet_buffer
= pktl
->next
;
1106 av_free_packet(&pktl
->pkt
);
1109 while(s
->raw_packet_buffer
){
1110 pktl
= s
->raw_packet_buffer
;
1111 s
->raw_packet_buffer
= pktl
->next
;
1112 av_free_packet(&pktl
->pkt
);
1115 s
->raw_packet_buffer_remaining_size
= RAW_PACKET_BUFFER_SIZE
;
1118 /*******************************************************/
1121 int av_find_default_stream_index(AVFormatContext
*s
)
1123 int first_audio_index
= -1;
1127 if (s
->nb_streams
<= 0)
1129 for(i
= 0; i
< s
->nb_streams
; i
++) {
1131 if (st
->codec
->codec_type
== CODEC_TYPE_VIDEO
) {
1134 if (first_audio_index
< 0 && st
->codec
->codec_type
== CODEC_TYPE_AUDIO
)
1135 first_audio_index
= i
;
1137 return first_audio_index
>= 0 ? first_audio_index
: 0;
1141 * Flush the frame reader.
1143 void av_read_frame_flush(AVFormatContext
*s
)
1148 flush_packet_queue(s
);
1152 /* for each stream, reset read state */
1153 for(i
= 0; i
< s
->nb_streams
; i
++) {
1157 av_parser_close(st
->parser
);
1159 av_free_packet(&st
->cur_pkt
);
1161 st
->last_IP_pts
= AV_NOPTS_VALUE
;
1162 st
->cur_dts
= AV_NOPTS_VALUE
; /* we set the current DTS to an unspecified origin */
1163 st
->reference_dts
= AV_NOPTS_VALUE
;
1168 st
->probe_packets
= MAX_PROBE_PACKETS
;
1172 void av_update_cur_dts(AVFormatContext
*s
, AVStream
*ref_st
, int64_t timestamp
){
1175 for(i
= 0; i
< s
->nb_streams
; i
++) {
1176 AVStream
*st
= s
->streams
[i
];
1178 st
->cur_dts
= av_rescale(timestamp
,
1179 st
->time_base
.den
* (int64_t)ref_st
->time_base
.num
,
1180 st
->time_base
.num
* (int64_t)ref_st
->time_base
.den
);
1184 void ff_reduce_index(AVFormatContext
*s
, int stream_index
)
1186 AVStream
*st
= s
->streams
[stream_index
];
1187 unsigned int max_entries
= s
->max_index_size
/ sizeof(AVIndexEntry
);
1189 if((unsigned)st
->nb_index_entries
>= max_entries
){
1191 for(i
=0; 2*i
<st
->nb_index_entries
; i
++)
1192 st
->index_entries
[i
]= st
->index_entries
[2*i
];
1193 st
->nb_index_entries
= i
;
1197 int av_add_index_entry(AVStream
*st
,
1198 int64_t pos
, int64_t timestamp
, int size
, int distance
, int flags
)
1200 AVIndexEntry
*entries
, *ie
;
1203 if((unsigned)st
->nb_index_entries
+ 1 >= UINT_MAX
/ sizeof(AVIndexEntry
))
1206 entries
= av_fast_realloc(st
->index_entries
,
1207 &st
->index_entries_allocated_size
,
1208 (st
->nb_index_entries
+ 1) *
1209 sizeof(AVIndexEntry
));
1213 st
->index_entries
= entries
;
1215 index
= av_index_search_timestamp(st
, timestamp
, AVSEEK_FLAG_ANY
);
1218 index
= st
->nb_index_entries
++;
1219 ie
= &entries
[index
];
1220 assert(index
==0 || ie
[-1].timestamp
< timestamp
);
1222 ie
= &entries
[index
];
1223 if(ie
->timestamp
!= timestamp
){
1224 if(ie
->timestamp
<= timestamp
)
1226 memmove(entries
+ index
+ 1, entries
+ index
, sizeof(AVIndexEntry
)*(st
->nb_index_entries
- index
));
1227 st
->nb_index_entries
++;
1228 }else if(ie
->pos
== pos
&& distance
< ie
->min_distance
) //do not reduce the distance
1229 distance
= ie
->min_distance
;
1233 ie
->timestamp
= timestamp
;
1234 ie
->min_distance
= distance
;
1241 int av_index_search_timestamp(AVStream
*st
, int64_t wanted_timestamp
,
1244 AVIndexEntry
*entries
= st
->index_entries
;
1245 int nb_entries
= st
->nb_index_entries
;
1254 timestamp
= entries
[m
].timestamp
;
1255 if(timestamp
>= wanted_timestamp
)
1257 if(timestamp
<= wanted_timestamp
)
1260 m
= (flags
& AVSEEK_FLAG_BACKWARD
) ? a
: b
;
1262 if(!(flags
& AVSEEK_FLAG_ANY
)){
1263 while(m
>=0 && m
<nb_entries
&& !(entries
[m
].flags
& AVINDEX_KEYFRAME
)){
1264 m
+= (flags
& AVSEEK_FLAG_BACKWARD
) ? -1 : 1;
1275 int av_seek_frame_binary(AVFormatContext
*s
, int stream_index
, int64_t target_ts
, int flags
){
1276 AVInputFormat
*avif
= s
->iformat
;
1277 int64_t av_uninit(pos_min
), av_uninit(pos_max
), pos
, pos_limit
;
1278 int64_t ts_min
, ts_max
, ts
;
1282 if (stream_index
< 0)
1286 av_log(s
, AV_LOG_DEBUG
, "read_seek: %d %"PRId64
"\n", stream_index
, target_ts
);
1290 ts_min
= AV_NOPTS_VALUE
;
1291 pos_limit
= -1; //gcc falsely says it may be uninitialized
1293 st
= s
->streams
[stream_index
];
1294 if(st
->index_entries
){
1297 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()
1298 index
= FFMAX(index
, 0);
1299 e
= &st
->index_entries
[index
];
1301 if(e
->timestamp
<= target_ts
|| e
->pos
== e
->min_distance
){
1303 ts_min
= e
->timestamp
;
1305 av_log(s
, AV_LOG_DEBUG
, "using cached pos_min=0x%"PRIx64
" dts_min=%"PRId64
"\n",
1312 index
= av_index_search_timestamp(st
, target_ts
, flags
& ~AVSEEK_FLAG_BACKWARD
);
1313 assert(index
< st
->nb_index_entries
);
1315 e
= &st
->index_entries
[index
];
1316 assert(e
->timestamp
>= target_ts
);
1318 ts_max
= e
->timestamp
;
1319 pos_limit
= pos_max
- e
->min_distance
;
1321 av_log(s
, AV_LOG_DEBUG
, "using cached pos_max=0x%"PRIx64
" pos_limit=0x%"PRIx64
" dts_max=%"PRId64
"\n",
1322 pos_max
,pos_limit
, ts_max
);
1327 pos
= av_gen_search(s
, stream_index
, target_ts
, pos_min
, pos_max
, pos_limit
, ts_min
, ts_max
, flags
, &ts
, avif
->read_timestamp
);
1332 url_fseek(s
->pb
, pos
, SEEK_SET
);
1334 av_update_cur_dts(s
, st
, ts
);
1339 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 )){
1341 int64_t start_pos
, filesize
;
1345 av_log(s
, AV_LOG_DEBUG
, "gen_seek: %d %"PRId64
"\n", stream_index
, target_ts
);
1348 if(ts_min
== AV_NOPTS_VALUE
){
1349 pos_min
= s
->data_offset
;
1350 ts_min
= read_timestamp(s
, stream_index
, &pos_min
, INT64_MAX
);
1351 if (ts_min
== AV_NOPTS_VALUE
)
1355 if(ts_max
== AV_NOPTS_VALUE
){
1357 filesize
= url_fsize(s
->pb
);
1358 pos_max
= filesize
- 1;
1361 ts_max
= read_timestamp(s
, stream_index
, &pos_max
, pos_max
+ step
);
1363 }while(ts_max
== AV_NOPTS_VALUE
&& pos_max
>= step
);
1364 if (ts_max
== AV_NOPTS_VALUE
)
1368 int64_t tmp_pos
= pos_max
+ 1;
1369 int64_t tmp_ts
= read_timestamp(s
, stream_index
, &tmp_pos
, INT64_MAX
);
1370 if(tmp_ts
== AV_NOPTS_VALUE
)
1374 if(tmp_pos
>= filesize
)
1380 if(ts_min
> ts_max
){
1382 }else if(ts_min
== ts_max
){
1387 while (pos_min
< pos_limit
) {
1389 av_log(s
, AV_LOG_DEBUG
, "pos_min=0x%"PRIx64
" pos_max=0x%"PRIx64
" dts_min=%"PRId64
" dts_max=%"PRId64
"\n",
1393 assert(pos_limit
<= pos_max
);
1396 int64_t approximate_keyframe_distance
= pos_max
- pos_limit
;
1397 // interpolate position (better than dichotomy)
1398 pos
= av_rescale(target_ts
- ts_min
, pos_max
- pos_min
, ts_max
- ts_min
)
1399 + pos_min
- approximate_keyframe_distance
;
1400 }else if(no_change
==1){
1401 // bisection, if interpolation failed to change min or max pos last time
1402 pos
= (pos_min
+ pos_limit
)>>1;
1404 /* linear search if bisection failed, can only happen if there
1405 are very few or no keyframes between min/max */
1410 else if(pos
> pos_limit
)
1414 ts
= read_timestamp(s
, stream_index
, &pos
, INT64_MAX
); //may pass pos_limit instead of -1
1420 av_log(s
, AV_LOG_DEBUG
, "%"PRId64
" %"PRId64
" %"PRId64
" / %"PRId64
" %"PRId64
" %"PRId64
" target:%"PRId64
" limit:%"PRId64
" start:%"PRId64
" noc:%d\n",
1421 pos_min
, pos
, pos_max
, ts_min
, ts
, ts_max
, target_ts
, pos_limit
,
1422 start_pos
, no_change
);
1424 if(ts
== AV_NOPTS_VALUE
){
1425 av_log(s
, AV_LOG_ERROR
, "read_timestamp() failed in the middle\n");
1428 assert(ts
!= AV_NOPTS_VALUE
);
1429 if (target_ts
<= ts
) {
1430 pos_limit
= start_pos
- 1;
1434 if (target_ts
>= ts
) {
1440 pos
= (flags
& AVSEEK_FLAG_BACKWARD
) ? pos_min
: pos_max
;
1441 ts
= (flags
& AVSEEK_FLAG_BACKWARD
) ? ts_min
: ts_max
;
1444 ts_min
= read_timestamp(s
, stream_index
, &pos_min
, INT64_MAX
);
1446 ts_max
= read_timestamp(s
, stream_index
, &pos_min
, INT64_MAX
);
1447 av_log(s
, AV_LOG_DEBUG
, "pos=0x%"PRIx64
" %"PRId64
"<=%"PRId64
"<=%"PRId64
"\n",
1448 pos
, ts_min
, target_ts
, ts_max
);
1454 static int av_seek_frame_byte(AVFormatContext
*s
, int stream_index
, int64_t pos
, int flags
){
1455 int64_t pos_min
, pos_max
;
1459 if (stream_index
< 0)
1462 st
= s
->streams
[stream_index
];
1465 pos_min
= s
->data_offset
;
1466 pos_max
= url_fsize(s
->pb
) - 1;
1468 if (pos
< pos_min
) pos
= pos_min
;
1469 else if(pos
> pos_max
) pos
= pos_max
;
1471 url_fseek(s
->pb
, pos
, SEEK_SET
);
1474 av_update_cur_dts(s
, st
, ts
);
1479 static int av_seek_frame_generic(AVFormatContext
*s
,
1480 int stream_index
, int64_t timestamp
, int flags
)
1486 st
= s
->streams
[stream_index
];
1488 index
= av_index_search_timestamp(st
, timestamp
, flags
);
1490 if(index
< 0 || index
==st
->nb_index_entries
-1){
1494 if(st
->nb_index_entries
){
1495 assert(st
->index_entries
);
1496 ie
= &st
->index_entries
[st
->nb_index_entries
-1];
1497 if ((ret
= url_fseek(s
->pb
, ie
->pos
, SEEK_SET
)) < 0)
1499 av_update_cur_dts(s
, st
, ie
->timestamp
);
1501 if ((ret
= url_fseek(s
->pb
, s
->data_offset
, SEEK_SET
)) < 0)
1507 ret
= av_read_frame(s
, &pkt
);
1508 }while(ret
== AVERROR(EAGAIN
));
1511 av_free_packet(&pkt
);
1512 if(stream_index
== pkt
.stream_index
){
1513 if((pkt
.flags
& PKT_FLAG_KEY
) && pkt
.dts
> timestamp
)
1517 index
= av_index_search_timestamp(st
, timestamp
, flags
);
1522 av_read_frame_flush(s
);
1523 if (s
->iformat
->read_seek
){
1524 if(s
->iformat
->read_seek(s
, stream_index
, timestamp
, flags
) >= 0)
1527 ie
= &st
->index_entries
[index
];
1528 if ((ret
= url_fseek(s
->pb
, ie
->pos
, SEEK_SET
)) < 0)
1530 av_update_cur_dts(s
, st
, ie
->timestamp
);
1535 int av_seek_frame(AVFormatContext
*s
, int stream_index
, int64_t timestamp
, int flags
)
1540 av_read_frame_flush(s
);
1542 if(flags
& AVSEEK_FLAG_BYTE
)
1543 return av_seek_frame_byte(s
, stream_index
, timestamp
, flags
);
1545 if(stream_index
< 0){
1546 stream_index
= av_find_default_stream_index(s
);
1547 if(stream_index
< 0)
1550 st
= s
->streams
[stream_index
];
1551 /* timestamp for default must be expressed in AV_TIME_BASE units */
1552 timestamp
= av_rescale(timestamp
, st
->time_base
.den
, AV_TIME_BASE
* (int64_t)st
->time_base
.num
);
1555 /* first, we try the format specific seek */
1556 if (s
->iformat
->read_seek
)
1557 ret
= s
->iformat
->read_seek(s
, stream_index
, timestamp
, flags
);
1564 if(s
->iformat
->read_timestamp
)
1565 return av_seek_frame_binary(s
, stream_index
, timestamp
, flags
);
1567 return av_seek_frame_generic(s
, stream_index
, timestamp
, flags
);
1570 int avformat_seek_file(AVFormatContext
*s
, int stream_index
, int64_t min_ts
, int64_t ts
, int64_t max_ts
, int flags
)
1572 if(min_ts
> ts
|| max_ts
< ts
)
1575 av_read_frame_flush(s
);
1577 if (s
->iformat
->read_seek2
)
1578 return s
->iformat
->read_seek2(s
, stream_index
, min_ts
, ts
, max_ts
, flags
);
1580 if(s
->iformat
->read_timestamp
){
1581 //try to seek via read_timestamp()
1584 //Fallback to old API if new is not implemented but old is
1585 //Note the old has somewat different sematics
1586 if(s
->iformat
->read_seek
|| 1)
1587 return av_seek_frame(s
, stream_index
, ts
, flags
| (ts
- min_ts
> (uint64_t)(max_ts
- ts
) ? AVSEEK_FLAG_BACKWARD
: 0));
1589 // try some generic seek like av_seek_frame_generic() but with new ts semantics
1592 /*******************************************************/
1595 * Returns TRUE if the stream has accurate duration in any stream.
1597 * @return TRUE if the stream has accurate duration for at least one component.
1599 static int av_has_duration(AVFormatContext
*ic
)
1604 for(i
= 0;i
< ic
->nb_streams
; i
++) {
1605 st
= ic
->streams
[i
];
1606 if (st
->duration
!= AV_NOPTS_VALUE
)
1613 * Estimate the stream timings from the one of each components.
1615 * Also computes the global bitrate if possible.
1617 static void av_update_stream_timings(AVFormatContext
*ic
)
1619 int64_t start_time
, start_time1
, end_time
, end_time1
;
1620 int64_t duration
, duration1
;
1624 start_time
= INT64_MAX
;
1625 end_time
= INT64_MIN
;
1626 duration
= INT64_MIN
;
1627 for(i
= 0;i
< ic
->nb_streams
; i
++) {
1628 st
= ic
->streams
[i
];
1629 if (st
->start_time
!= AV_NOPTS_VALUE
&& st
->time_base
.den
) {
1630 start_time1
= av_rescale_q(st
->start_time
, st
->time_base
, AV_TIME_BASE_Q
);
1631 if (start_time1
< start_time
)
1632 start_time
= start_time1
;
1633 if (st
->duration
!= AV_NOPTS_VALUE
) {
1634 end_time1
= start_time1
1635 + av_rescale_q(st
->duration
, st
->time_base
, AV_TIME_BASE_Q
);
1636 if (end_time1
> end_time
)
1637 end_time
= end_time1
;
1640 if (st
->duration
!= AV_NOPTS_VALUE
) {
1641 duration1
= av_rescale_q(st
->duration
, st
->time_base
, AV_TIME_BASE_Q
);
1642 if (duration1
> duration
)
1643 duration
= duration1
;
1646 if (start_time
!= INT64_MAX
) {
1647 ic
->start_time
= start_time
;
1648 if (end_time
!= INT64_MIN
) {
1649 if (end_time
- start_time
> duration
)
1650 duration
= end_time
- start_time
;
1653 if (duration
!= INT64_MIN
) {
1654 ic
->duration
= duration
;
1655 if (ic
->file_size
> 0) {
1656 /* compute the bitrate */
1657 ic
->bit_rate
= (double)ic
->file_size
* 8.0 * AV_TIME_BASE
/
1658 (double)ic
->duration
;
1663 static void fill_all_stream_timings(AVFormatContext
*ic
)
1668 av_update_stream_timings(ic
);
1669 for(i
= 0;i
< ic
->nb_streams
; i
++) {
1670 st
= ic
->streams
[i
];
1671 if (st
->start_time
== AV_NOPTS_VALUE
) {
1672 if(ic
->start_time
!= AV_NOPTS_VALUE
)
1673 st
->start_time
= av_rescale_q(ic
->start_time
, AV_TIME_BASE_Q
, st
->time_base
);
1674 if(ic
->duration
!= AV_NOPTS_VALUE
)
1675 st
->duration
= av_rescale_q(ic
->duration
, AV_TIME_BASE_Q
, st
->time_base
);
1680 static void av_estimate_timings_from_bit_rate(AVFormatContext
*ic
)
1682 int64_t filesize
, duration
;
1686 /* if bit_rate is already set, we believe it */
1687 if (ic
->bit_rate
== 0) {
1689 for(i
=0;i
<ic
->nb_streams
;i
++) {
1690 st
= ic
->streams
[i
];
1691 bit_rate
+= st
->codec
->bit_rate
;
1693 ic
->bit_rate
= bit_rate
;
1696 /* if duration is already set, we believe it */
1697 if (ic
->duration
== AV_NOPTS_VALUE
&&
1698 ic
->bit_rate
!= 0 &&
1699 ic
->file_size
!= 0) {
1700 filesize
= ic
->file_size
;
1702 for(i
= 0; i
< ic
->nb_streams
; i
++) {
1703 st
= ic
->streams
[i
];
1704 duration
= av_rescale(8*filesize
, st
->time_base
.den
, ic
->bit_rate
*(int64_t)st
->time_base
.num
);
1705 if (st
->duration
== AV_NOPTS_VALUE
)
1706 st
->duration
= duration
;
1712 #define DURATION_MAX_READ_SIZE 250000
1714 /* only usable for MPEG-PS streams */
1715 static void av_estimate_timings_from_pts(AVFormatContext
*ic
, int64_t old_offset
)
1717 AVPacket pkt1
, *pkt
= &pkt1
;
1719 int read_size
, i
, ret
;
1721 int64_t filesize
, offset
, duration
;
1725 /* flush packet queue */
1726 flush_packet_queue(ic
);
1728 for(i
=0;i
<ic
->nb_streams
;i
++) {
1729 st
= ic
->streams
[i
];
1731 av_parser_close(st
->parser
);
1733 av_free_packet(&st
->cur_pkt
);
1737 /* we read the first packets to get the first PTS (not fully
1738 accurate, but it is enough now) */
1739 url_fseek(ic
->pb
, 0, SEEK_SET
);
1742 if (read_size
>= DURATION_MAX_READ_SIZE
)
1744 /* if all info is available, we can stop */
1745 for(i
= 0;i
< ic
->nb_streams
; i
++) {
1746 st
= ic
->streams
[i
];
1747 if (st
->start_time
== AV_NOPTS_VALUE
)
1750 if (i
== ic
->nb_streams
)
1754 ret
= av_read_packet(ic
, pkt
);
1755 }while(ret
== AVERROR(EAGAIN
));
1758 read_size
+= pkt
->size
;
1759 st
= ic
->streams
[pkt
->stream_index
];
1760 if (pkt
->pts
!= AV_NOPTS_VALUE
) {
1761 if (st
->start_time
== AV_NOPTS_VALUE
)
1762 st
->start_time
= pkt
->pts
;
1764 av_free_packet(pkt
);
1767 /* estimate the end time (duration) */
1768 /* XXX: may need to support wrapping */
1769 filesize
= ic
->file_size
;
1770 offset
= filesize
- DURATION_MAX_READ_SIZE
;
1774 url_fseek(ic
->pb
, offset
, SEEK_SET
);
1777 if (read_size
>= DURATION_MAX_READ_SIZE
)
1781 ret
= av_read_packet(ic
, pkt
);
1782 }while(ret
== AVERROR(EAGAIN
));
1785 read_size
+= pkt
->size
;
1786 st
= ic
->streams
[pkt
->stream_index
];
1787 if (pkt
->pts
!= AV_NOPTS_VALUE
&&
1788 st
->start_time
!= AV_NOPTS_VALUE
) {
1789 end_time
= pkt
->pts
;
1790 duration
= end_time
- st
->start_time
;
1792 if (st
->duration
== AV_NOPTS_VALUE
||
1793 st
->duration
< duration
)
1794 st
->duration
= duration
;
1797 av_free_packet(pkt
);
1800 fill_all_stream_timings(ic
);
1802 url_fseek(ic
->pb
, old_offset
, SEEK_SET
);
1803 for(i
=0; i
<ic
->nb_streams
; i
++){
1805 st
->cur_dts
= st
->first_dts
;
1806 st
->last_IP_pts
= AV_NOPTS_VALUE
;
1810 static void av_estimate_timings(AVFormatContext
*ic
, int64_t old_offset
)
1814 /* get the file size, if possible */
1815 if (ic
->iformat
->flags
& AVFMT_NOFILE
) {
1818 file_size
= url_fsize(ic
->pb
);
1822 ic
->file_size
= file_size
;
1824 if ((!strcmp(ic
->iformat
->name
, "mpeg") ||
1825 !strcmp(ic
->iformat
->name
, "mpegts")) &&
1826 file_size
&& !url_is_streamed(ic
->pb
)) {
1827 /* get accurate estimate from the PTSes */
1828 av_estimate_timings_from_pts(ic
, old_offset
);
1829 } else if (av_has_duration(ic
)) {
1830 /* at least one component has timings - we use them for all
1832 fill_all_stream_timings(ic
);
1834 /* less precise: use bitrate info */
1835 av_estimate_timings_from_bit_rate(ic
);
1837 av_update_stream_timings(ic
);
1843 for(i
= 0;i
< ic
->nb_streams
; i
++) {
1844 st
= ic
->streams
[i
];
1845 printf("%d: start_time: %0.3f duration: %0.3f\n",
1846 i
, (double)st
->start_time
/ AV_TIME_BASE
,
1847 (double)st
->duration
/ AV_TIME_BASE
);
1849 printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1850 (double)ic
->start_time
/ AV_TIME_BASE
,
1851 (double)ic
->duration
/ AV_TIME_BASE
,
1852 ic
->bit_rate
/ 1000);
1857 static int has_codec_parameters(AVCodecContext
*enc
)
1860 switch(enc
->codec_type
) {
1861 case CODEC_TYPE_AUDIO
:
1862 val
= enc
->sample_rate
&& enc
->channels
&& enc
->sample_fmt
!= SAMPLE_FMT_NONE
;
1863 if(!enc
->frame_size
&&
1864 (enc
->codec_id
== CODEC_ID_VORBIS
||
1865 enc
->codec_id
== CODEC_ID_AAC
))
1868 case CODEC_TYPE_VIDEO
:
1869 val
= enc
->width
&& enc
->pix_fmt
!= PIX_FMT_NONE
;
1875 return enc
->codec_id
!= CODEC_ID_NONE
&& val
!= 0;
1878 static int try_decode_frame(AVStream
*st
, AVPacket
*avpkt
)
1882 int got_picture
, data_size
, ret
=0;
1885 if(!st
->codec
->codec
){
1886 codec
= avcodec_find_decoder(st
->codec
->codec_id
);
1889 ret
= avcodec_open(st
->codec
, codec
);
1894 if(!has_codec_parameters(st
->codec
)){
1895 switch(st
->codec
->codec_type
) {
1896 case CODEC_TYPE_VIDEO
:
1897 avcodec_get_frame_defaults(&picture
);
1898 ret
= avcodec_decode_video2(st
->codec
, &picture
,
1899 &got_picture
, avpkt
);
1901 case CODEC_TYPE_AUDIO
:
1902 data_size
= FFMAX(avpkt
->size
, AVCODEC_MAX_AUDIO_FRAME_SIZE
);
1903 samples
= av_malloc(data_size
);
1906 ret
= avcodec_decode_audio3(st
->codec
, samples
,
1918 unsigned int ff_codec_get_tag(const AVCodecTag
*tags
, int id
)
1920 while (tags
->id
!= CODEC_ID_NONE
) {
1928 enum CodecID
ff_codec_get_id(const AVCodecTag
*tags
, unsigned int tag
)
1931 for(i
=0; tags
[i
].id
!= CODEC_ID_NONE
;i
++) {
1932 if(tag
== tags
[i
].tag
)
1935 for(i
=0; tags
[i
].id
!= CODEC_ID_NONE
; i
++) {
1936 if( toupper((tag
>> 0)&0xFF) == toupper((tags
[i
].tag
>> 0)&0xFF)
1937 && toupper((tag
>> 8)&0xFF) == toupper((tags
[i
].tag
>> 8)&0xFF)
1938 && toupper((tag
>>16)&0xFF) == toupper((tags
[i
].tag
>>16)&0xFF)
1939 && toupper((tag
>>24)&0xFF) == toupper((tags
[i
].tag
>>24)&0xFF))
1942 return CODEC_ID_NONE
;
1945 unsigned int av_codec_get_tag(const AVCodecTag
* const *tags
, enum CodecID id
)
1948 for(i
=0; tags
&& tags
[i
]; i
++){
1949 int tag
= ff_codec_get_tag(tags
[i
], id
);
1955 enum CodecID
av_codec_get_id(const AVCodecTag
* const *tags
, unsigned int tag
)
1958 for(i
=0; tags
&& tags
[i
]; i
++){
1959 enum CodecID id
= ff_codec_get_id(tags
[i
], tag
);
1960 if(id
!=CODEC_ID_NONE
) return id
;
1962 return CODEC_ID_NONE
;
1965 static void compute_chapters_end(AVFormatContext
*s
)
1969 for (i
=0; i
+1<s
->nb_chapters
; i
++)
1970 if (s
->chapters
[i
]->end
== AV_NOPTS_VALUE
) {
1971 assert(s
->chapters
[i
]->start
<= s
->chapters
[i
+1]->start
);
1972 assert(!av_cmp_q(s
->chapters
[i
]->time_base
, s
->chapters
[i
+1]->time_base
));
1973 s
->chapters
[i
]->end
= s
->chapters
[i
+1]->start
;
1976 if (s
->nb_chapters
&& s
->chapters
[i
]->end
== AV_NOPTS_VALUE
) {
1977 assert(s
->start_time
!= AV_NOPTS_VALUE
);
1978 assert(s
->duration
> 0);
1979 s
->chapters
[i
]->end
= av_rescale_q(s
->start_time
+ s
->duration
,
1981 s
->chapters
[i
]->time_base
);
1985 #define MAX_STD_TIMEBASES (60*12+5)
1986 static int get_std_framerate(int i
){
1987 if(i
<60*12) return i
*1001;
1988 else return ((const int[]){24,30,60,12,15})[i
-60*12]*1000*12;
1992 * Is the time base unreliable.
1993 * This is a heuristic to balance between quick acceptance of the values in
1994 * the headers vs. some extra checks.
1995 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
1996 * MPEG-2 commonly misuses field repeat flags to store different framerates.
1997 * And there are "variable" fps files this needs to detect as well.
1999 static int tb_unreliable(AVCodecContext
*c
){
2000 if( c
->time_base
.den
>= 101L*c
->time_base
.num
2001 || c
->time_base
.den
< 5L*c
->time_base
.num
2002 /* || c->codec_tag == AV_RL32("DIVX")
2003 || c->codec_tag == AV_RL32("XVID")*/
2004 || c
->codec_id
== CODEC_ID_MPEG2VIDEO
2005 || c
->codec_id
== CODEC_ID_H264
2011 int av_find_stream_info(AVFormatContext
*ic
)
2013 int i
, count
, ret
, read_size
, j
;
2015 AVPacket pkt1
, *pkt
;
2016 int64_t last_dts
[MAX_STREAMS
];
2017 int64_t duration_gcd
[MAX_STREAMS
]={0};
2018 int duration_count
[MAX_STREAMS
]={0};
2019 double (*duration_error
)[MAX_STD_TIMEBASES
];
2020 int64_t old_offset
= url_ftell(ic
->pb
);
2021 int64_t codec_info_duration
[MAX_STREAMS
]={0};
2022 int codec_info_nb_frames
[MAX_STREAMS
]={0};
2024 duration_error
= av_mallocz(MAX_STREAMS
* sizeof(*duration_error
));
2025 if (!duration_error
) return AVERROR(ENOMEM
);
2027 for(i
=0;i
<ic
->nb_streams
;i
++) {
2028 st
= ic
->streams
[i
];
2029 if(st
->codec
->codec_type
== CODEC_TYPE_VIDEO
){
2030 /* if(!st->time_base.num)
2032 if(!st
->codec
->time_base
.num
)
2033 st
->codec
->time_base
= st
->time_base
;
2035 //only for the split stuff
2037 st
->parser
= av_parser_init(st
->codec
->codec_id
);
2038 if(st
->need_parsing
== AVSTREAM_PARSE_HEADERS
&& st
->parser
){
2039 st
->parser
->flags
|= PARSER_FLAG_COMPLETE_FRAMES
;
2044 for(i
=0;i
<MAX_STREAMS
;i
++){
2045 last_dts
[i
]= AV_NOPTS_VALUE
;
2051 if(url_interrupt_cb()){
2052 ret
= AVERROR(EINTR
);
2053 av_log(ic
, AV_LOG_DEBUG
, "interrupted\n");
2057 /* check if one codec still needs to be handled */
2058 for(i
=0;i
<ic
->nb_streams
;i
++) {
2059 st
= ic
->streams
[i
];
2060 if (!has_codec_parameters(st
->codec
))
2062 /* variable fps and no guess at the real fps */
2063 if( tb_unreliable(st
->codec
)
2064 && duration_count
[i
]<20 && st
->codec
->codec_type
== CODEC_TYPE_VIDEO
)
2066 if(st
->parser
&& st
->parser
->parser
->split
&& !st
->codec
->extradata
)
2068 if(st
->first_dts
== AV_NOPTS_VALUE
)
2071 if (i
== ic
->nb_streams
) {
2072 /* NOTE: if the format has no header, then we need to read
2073 some packets to get most of the streams, so we cannot
2075 if (!(ic
->ctx_flags
& AVFMTCTX_NOHEADER
)) {
2076 /* if we found the info for all the codecs, we can stop */
2078 av_log(ic
, AV_LOG_DEBUG
, "All info found\n");
2082 /* we did not get all the codec info, but we read too much data */
2083 if (read_size
>= ic
->probesize
) {
2085 av_log(ic
, AV_LOG_DEBUG
, "MAX_READ_SIZE:%d reached\n", ic
->probesize
);
2089 /* NOTE: a new stream can be added there if no header in file
2090 (AVFMTCTX_NOHEADER) */
2091 ret
= av_read_frame_internal(ic
, &pkt1
);
2092 if(ret
== AVERROR(EAGAIN
))
2096 ret
= -1; /* we could not have all the codec parameters before EOF */
2097 for(i
=0;i
<ic
->nb_streams
;i
++) {
2098 st
= ic
->streams
[i
];
2099 if (!has_codec_parameters(st
->codec
)){
2101 avcodec_string(buf
, sizeof(buf
), st
->codec
, 0);
2102 av_log(ic
, AV_LOG_INFO
, "Could not find codec parameters (%s)\n", buf
);
2110 pkt
= add_to_pktbuf(&ic
->packet_buffer
, &pkt1
, &ic
->packet_buffer_end
);
2111 if(av_dup_packet(pkt
) < 0) {
2112 av_free(duration_error
);
2113 return AVERROR(ENOMEM
);
2116 read_size
+= pkt
->size
;
2118 st
= ic
->streams
[pkt
->stream_index
];
2119 if(codec_info_nb_frames
[st
->index
]>1) {
2120 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
){
2121 av_log(ic
, AV_LOG_DEBUG
, "max_analyze_duration reached\n");
2124 codec_info_duration
[st
->index
] += pkt
->duration
;
2126 if (pkt
->duration
!= 0)
2127 codec_info_nb_frames
[st
->index
]++;
2130 int index
= pkt
->stream_index
;
2131 int64_t last
= last_dts
[index
];
2132 int64_t duration
= pkt
->dts
- last
;
2134 if(pkt
->dts
!= AV_NOPTS_VALUE
&& last
!= AV_NOPTS_VALUE
&& duration
>0){
2135 double dur
= duration
* av_q2d(st
->time_base
);
2137 // if(st->codec->codec_type == CODEC_TYPE_VIDEO)
2138 // av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
2139 if(duration_count
[index
] < 2)
2140 memset(duration_error
[index
], 0, sizeof(*duration_error
));
2141 for(i
=1; i
<MAX_STD_TIMEBASES
; i
++){
2142 int framerate
= get_std_framerate(i
);
2143 int ticks
= lrintf(dur
*framerate
/(1001*12));
2144 double error
= dur
- ticks
*1001*12/(double)framerate
;
2145 duration_error
[index
][i
] += error
*error
;
2147 duration_count
[index
]++;
2148 // ignore the first 4 values, they might have some random jitter
2149 if (duration_count
[index
] > 3)
2150 duration_gcd
[index
] = av_gcd(duration_gcd
[index
], duration
);
2152 if(last
== AV_NOPTS_VALUE
|| duration_count
[index
]<=1)
2153 last_dts
[pkt
->stream_index
]= pkt
->dts
;
2155 if(st
->parser
&& st
->parser
->parser
->split
&& !st
->codec
->extradata
){
2156 int i
= st
->parser
->parser
->split(st
->codec
, pkt
->data
, pkt
->size
);
2158 st
->codec
->extradata_size
= i
;
2159 st
->codec
->extradata
= av_malloc(st
->codec
->extradata_size
+ FF_INPUT_BUFFER_PADDING_SIZE
);
2160 memcpy(st
->codec
->extradata
, pkt
->data
, st
->codec
->extradata_size
);
2161 memset(st
->codec
->extradata
+ i
, 0, FF_INPUT_BUFFER_PADDING_SIZE
);
2165 /* if still no information, we try to open the codec and to
2166 decompress the frame. We try to avoid that in most cases as
2167 it takes longer and uses more memory. For MPEG-4, we need to
2168 decompress for QuickTime. */
2169 if (!has_codec_parameters(st
->codec
) /*&&
2170 (st->codec->codec_id == CODEC_ID_FLV1 ||
2171 st->codec->codec_id == CODEC_ID_H264 ||
2172 st->codec->codec_id == CODEC_ID_H263 ||
2173 st->codec->codec_id == CODEC_ID_H261 ||
2174 st->codec->codec_id == CODEC_ID_VORBIS ||
2175 st->codec->codec_id == CODEC_ID_MJPEG ||
2176 st->codec->codec_id == CODEC_ID_PNG ||
2177 st->codec->codec_id == CODEC_ID_PAM ||
2178 st->codec->codec_id == CODEC_ID_PGM ||
2179 st->codec->codec_id == CODEC_ID_PGMYUV ||
2180 st->codec->codec_id == CODEC_ID_PBM ||
2181 st->codec->codec_id == CODEC_ID_PPM ||
2182 st->codec->codec_id == CODEC_ID_SHORTEN ||
2183 (st->codec->codec_id == CODEC_ID_MPEG4 && !st->need_parsing))*/)
2184 try_decode_frame(st
, pkt
);
2189 // close codecs which were opened in try_decode_frame()
2190 for(i
=0;i
<ic
->nb_streams
;i
++) {
2191 st
= ic
->streams
[i
];
2192 if(st
->codec
->codec
)
2193 avcodec_close(st
->codec
);
2195 for(i
=0;i
<ic
->nb_streams
;i
++) {
2196 st
= ic
->streams
[i
];
2197 if (st
->codec
->codec_type
== CODEC_TYPE_VIDEO
) {
2198 if(st
->codec
->codec_id
== CODEC_ID_RAWVIDEO
&& !st
->codec
->codec_tag
&& !st
->codec
->bits_per_coded_sample
)
2199 st
->codec
->codec_tag
= avcodec_pix_fmt_to_codec_tag(st
->codec
->pix_fmt
);
2201 // the check for tb_unreliable() is not completely correct, since this is not about handling
2202 // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2203 // ipmovie.c produces.
2204 if (tb_unreliable(st
->codec
) && duration_count
[i
] > 15 && duration_gcd
[i
] > 1)
2205 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
);
2206 if(duration_count
[i
]
2207 && tb_unreliable(st
->codec
) /*&&
2208 //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2209 st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den*/){
2211 double best_error
= 2*av_q2d(st
->time_base
);
2212 best_error
= best_error
*best_error
*duration_count
[i
]*1000*12*30;
2214 for(j
=1; j
<MAX_STD_TIMEBASES
; j
++){
2215 double error
= duration_error
[i
][j
] * get_std_framerate(j
);
2216 // if(st->codec->codec_type == CODEC_TYPE_VIDEO)
2217 // av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
2218 if(error
< best_error
){
2220 num
= get_std_framerate(j
);
2223 // do not increase frame rate by more than 1 % in order to match a standard rate.
2224 if (num
&& (!st
->r_frame_rate
.num
|| (double)num
/(12*1001) < 1.01 * av_q2d(st
->r_frame_rate
)))
2225 av_reduce(&st
->r_frame_rate
.num
, &st
->r_frame_rate
.den
, num
, 12*1001, INT_MAX
);
2228 if (!st
->r_frame_rate
.num
){
2229 if( st
->codec
->time_base
.den
* (int64_t)st
->time_base
.num
2230 <= st
->codec
->time_base
.num
* st
->codec
->ticks_per_frame
* (int64_t)st
->time_base
.den
){
2231 st
->r_frame_rate
.num
= st
->codec
->time_base
.den
;
2232 st
->r_frame_rate
.den
= st
->codec
->time_base
.num
* st
->codec
->ticks_per_frame
;
2234 st
->r_frame_rate
.num
= st
->time_base
.den
;
2235 st
->r_frame_rate
.den
= st
->time_base
.num
;
2238 }else if(st
->codec
->codec_type
== CODEC_TYPE_AUDIO
) {
2239 if(!st
->codec
->bits_per_coded_sample
)
2240 st
->codec
->bits_per_coded_sample
= av_get_bits_per_sample(st
->codec
->codec_id
);
2244 av_estimate_timings(ic
, old_offset
);
2246 compute_chapters_end(ic
);
2249 /* correct DTS for B-frame streams with no timestamps */
2250 for(i
=0;i
<ic
->nb_streams
;i
++) {
2251 st
= ic
->streams
[i
];
2252 if (st
->codec
->codec_type
== CODEC_TYPE_VIDEO
) {
2254 ppktl
= &ic
->packet_buffer
;
2256 if(ppkt1
->stream_index
!= i
)
2258 if(ppkt1
->pkt
->dts
< 0)
2260 if(ppkt1
->pkt
->pts
!= AV_NOPTS_VALUE
)
2262 ppkt1
->pkt
->dts
-= delta
;
2267 st
->cur_dts
-= delta
;
2273 av_free(duration_error
);
2278 /*******************************************************/
2280 int av_read_play(AVFormatContext
*s
)
2282 if (s
->iformat
->read_play
)
2283 return s
->iformat
->read_play(s
);
2285 return av_url_read_fpause(s
->pb
, 0);
2286 return AVERROR(ENOSYS
);
2289 int av_read_pause(AVFormatContext
*s
)
2291 if (s
->iformat
->read_pause
)
2292 return s
->iformat
->read_pause(s
);
2294 return av_url_read_fpause(s
->pb
, 1);
2295 return AVERROR(ENOSYS
);
2298 void av_close_input_stream(AVFormatContext
*s
)
2303 if (s
->iformat
->read_close
)
2304 s
->iformat
->read_close(s
);
2305 for(i
=0;i
<s
->nb_streams
;i
++) {
2306 /* free all data in a stream component */
2309 av_parser_close(st
->parser
);
2310 av_free_packet(&st
->cur_pkt
);
2312 av_metadata_free(&st
->metadata
);
2313 av_free(st
->index_entries
);
2314 av_free(st
->codec
->extradata
);
2316 #if LIBAVFORMAT_VERSION_INT < (53<<16)
2317 av_free(st
->filename
);
2319 av_free(st
->priv_data
);
2322 for(i
=s
->nb_programs
-1; i
>=0; i
--) {
2323 #if LIBAVFORMAT_VERSION_INT < (53<<16)
2324 av_freep(&s
->programs
[i
]->provider_name
);
2325 av_freep(&s
->programs
[i
]->name
);
2327 av_metadata_free(&s
->programs
[i
]->metadata
);
2328 av_freep(&s
->programs
[i
]->stream_index
);
2329 av_freep(&s
->programs
[i
]);
2331 av_freep(&s
->programs
);
2332 flush_packet_queue(s
);
2333 av_freep(&s
->priv_data
);
2334 while(s
->nb_chapters
--) {
2335 #if LIBAVFORMAT_VERSION_INT < (53<<16)
2336 av_free(s
->chapters
[s
->nb_chapters
]->title
);
2338 av_metadata_free(&s
->chapters
[s
->nb_chapters
]->metadata
);
2339 av_free(s
->chapters
[s
->nb_chapters
]);
2341 av_freep(&s
->chapters
);
2342 av_metadata_free(&s
->metadata
);
2346 void av_close_input_file(AVFormatContext
*s
)
2348 ByteIOContext
*pb
= s
->iformat
->flags
& AVFMT_NOFILE
? NULL
: s
->pb
;
2349 av_close_input_stream(s
);
2354 AVStream
*av_new_stream(AVFormatContext
*s
, int id
)
2359 if (s
->nb_streams
>= MAX_STREAMS
)
2362 st
= av_mallocz(sizeof(AVStream
));
2366 st
->codec
= avcodec_alloc_context();
2368 /* no default bitrate if decoding */
2369 st
->codec
->bit_rate
= 0;
2371 st
->index
= s
->nb_streams
;
2373 st
->start_time
= AV_NOPTS_VALUE
;
2374 st
->duration
= AV_NOPTS_VALUE
;
2375 /* we set the current DTS to 0 so that formats without any timestamps
2376 but durations get some timestamps, formats with some unknown
2377 timestamps have their first few packets buffered and the
2378 timestamps corrected before they are returned to the user */
2380 st
->first_dts
= AV_NOPTS_VALUE
;
2381 st
->probe_packets
= MAX_PROBE_PACKETS
;
2383 /* default pts setting is MPEG-like */
2384 av_set_pts_info(st
, 33, 1, 90000);
2385 st
->last_IP_pts
= AV_NOPTS_VALUE
;
2386 for(i
=0; i
<MAX_REORDER_DELAY
+1; i
++)
2387 st
->pts_buffer
[i
]= AV_NOPTS_VALUE
;
2388 st
->reference_dts
= AV_NOPTS_VALUE
;
2390 st
->sample_aspect_ratio
= (AVRational
){0,1};
2392 s
->streams
[s
->nb_streams
++] = st
;
2396 AVProgram
*av_new_program(AVFormatContext
*ac
, int id
)
2398 AVProgram
*program
=NULL
;
2402 av_log(ac
, AV_LOG_DEBUG
, "new_program: id=0x%04x\n", id
);
2405 for(i
=0; i
<ac
->nb_programs
; i
++)
2406 if(ac
->programs
[i
]->id
== id
)
2407 program
= ac
->programs
[i
];
2410 program
= av_mallocz(sizeof(AVProgram
));
2413 dynarray_add(&ac
->programs
, &ac
->nb_programs
, program
);
2414 program
->discard
= AVDISCARD_NONE
;
2421 AVChapter
*ff_new_chapter(AVFormatContext
*s
, int id
, AVRational time_base
, int64_t start
, int64_t end
, const char *title
)
2423 AVChapter
*chapter
= NULL
;
2426 for(i
=0; i
<s
->nb_chapters
; i
++)
2427 if(s
->chapters
[i
]->id
== id
)
2428 chapter
= s
->chapters
[i
];
2431 chapter
= av_mallocz(sizeof(AVChapter
));
2434 dynarray_add(&s
->chapters
, &s
->nb_chapters
, chapter
);
2436 #if LIBAVFORMAT_VERSION_INT < (53<<16)
2437 av_free(chapter
->title
);
2439 av_metadata_set(&chapter
->metadata
, "title", title
);
2441 chapter
->time_base
= time_base
;
2442 chapter
->start
= start
;
2448 /************************************************************/
2449 /* output media file */
2451 int av_set_parameters(AVFormatContext
*s
, AVFormatParameters
*ap
)
2455 if (s
->oformat
->priv_data_size
> 0) {
2456 s
->priv_data
= av_mallocz(s
->oformat
->priv_data_size
);
2458 return AVERROR(ENOMEM
);
2460 s
->priv_data
= NULL
;
2462 if (s
->oformat
->set_parameters
) {
2463 ret
= s
->oformat
->set_parameters(s
, ap
);
2470 int av_write_header(AVFormatContext
*s
)
2475 // some sanity checks
2476 for(i
=0;i
<s
->nb_streams
;i
++) {
2479 switch (st
->codec
->codec_type
) {
2480 case CODEC_TYPE_AUDIO
:
2481 if(st
->codec
->sample_rate
<=0){
2482 av_log(s
, AV_LOG_ERROR
, "sample rate not set\n");
2485 if(!st
->codec
->block_align
)
2486 st
->codec
->block_align
= st
->codec
->channels
*
2487 av_get_bits_per_sample(st
->codec
->codec_id
) >> 3;
2489 case CODEC_TYPE_VIDEO
:
2490 if(st
->codec
->time_base
.num
<=0 || st
->codec
->time_base
.den
<=0){ //FIXME audio too?
2491 av_log(s
, AV_LOG_ERROR
, "time base not set\n");
2494 if(st
->codec
->width
<=0 || st
->codec
->height
<=0){
2495 av_log(s
, AV_LOG_ERROR
, "dimensions not set\n");
2498 if(av_cmp_q(st
->sample_aspect_ratio
, st
->codec
->sample_aspect_ratio
)){
2499 av_log(s
, AV_LOG_ERROR
, "Aspect ratio mismatch between encoder and muxer layer\n");
2505 if(s
->oformat
->codec_tag
){
2506 if(st
->codec
->codec_tag
){
2508 //check that tag + id is in the table
2509 //if neither is in the table -> OK
2510 //if tag is in the table with another id -> FAIL
2511 //if id is in the table with another tag -> FAIL unless strict < ?
2513 st
->codec
->codec_tag
= av_codec_get_tag(s
->oformat
->codec_tag
, st
->codec
->codec_id
);
2516 if(s
->oformat
->flags
& AVFMT_GLOBALHEADER
&&
2517 !(st
->codec
->flags
& CODEC_FLAG_GLOBAL_HEADER
))
2518 av_log(s
, AV_LOG_WARNING
, "Codec for stream %d does not use global headers but container format requires global headers\n", i
);
2521 if (!s
->priv_data
&& s
->oformat
->priv_data_size
> 0) {
2522 s
->priv_data
= av_mallocz(s
->oformat
->priv_data_size
);
2524 return AVERROR(ENOMEM
);
2527 #if LIBAVFORMAT_VERSION_MAJOR < 53
2528 ff_metadata_mux_compat(s
);
2531 if(s
->oformat
->write_header
){
2532 ret
= s
->oformat
->write_header(s
);
2537 /* init PTS generation */
2538 for(i
=0;i
<s
->nb_streams
;i
++) {
2539 int64_t den
= AV_NOPTS_VALUE
;
2542 switch (st
->codec
->codec_type
) {
2543 case CODEC_TYPE_AUDIO
:
2544 den
= (int64_t)st
->time_base
.num
* st
->codec
->sample_rate
;
2546 case CODEC_TYPE_VIDEO
:
2547 den
= (int64_t)st
->time_base
.num
* st
->codec
->time_base
.den
;
2552 if (den
!= AV_NOPTS_VALUE
) {
2554 return AVERROR_INVALIDDATA
;
2555 av_frac_init(&st
->pts
, 0, 0, den
);
2561 //FIXME merge with compute_pkt_fields
2562 static int compute_pkt_fields2(AVStream
*st
, AVPacket
*pkt
){
2563 int delay
= FFMAX(st
->codec
->has_b_frames
, !!st
->codec
->max_b_frames
);
2564 int num
, den
, frame_size
, i
;
2566 // 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);
2568 /* if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2571 /* duration field */
2572 if (pkt
->duration
== 0) {
2573 compute_frame_duration(&num
, &den
, st
, NULL
, pkt
);
2575 pkt
->duration
= av_rescale(1, num
* (int64_t)st
->time_base
.den
* st
->codec
->ticks_per_frame
, den
* (int64_t)st
->time_base
.num
);
2579 if(pkt
->pts
== AV_NOPTS_VALUE
&& pkt
->dts
!= AV_NOPTS_VALUE
&& delay
==0)
2582 //XXX/FIXME this is a temporary hack until all encoders output pts
2583 if((pkt
->pts
== 0 || pkt
->pts
== AV_NOPTS_VALUE
) && pkt
->dts
== AV_NOPTS_VALUE
&& !delay
){
2585 // pkt->pts= st->cur_dts;
2586 pkt
->pts
= st
->pts
.val
;
2589 //calculate dts from pts
2590 if(pkt
->pts
!= AV_NOPTS_VALUE
&& pkt
->dts
== AV_NOPTS_VALUE
&& delay
<= MAX_REORDER_DELAY
){
2591 st
->pts_buffer
[0]= pkt
->pts
;
2592 for(i
=1; i
<delay
+1 && st
->pts_buffer
[i
] == AV_NOPTS_VALUE
; i
++)
2593 st
->pts_buffer
[i
]= (i
-delay
-1) * pkt
->duration
;
2594 for(i
=0; i
<delay
&& st
->pts_buffer
[i
] > st
->pts_buffer
[i
+1]; i
++)
2595 FFSWAP(int64_t, st
->pts_buffer
[i
], st
->pts_buffer
[i
+1]);
2597 pkt
->dts
= st
->pts_buffer
[0];
2600 if(st
->cur_dts
&& st
->cur_dts
!= AV_NOPTS_VALUE
&& st
->cur_dts
>= pkt
->dts
){
2601 av_log(st
->codec
, AV_LOG_ERROR
, "error, non monotone timestamps %"PRId64
" >= %"PRId64
"\n", st
->cur_dts
, pkt
->dts
);
2604 if(pkt
->dts
!= AV_NOPTS_VALUE
&& pkt
->pts
!= AV_NOPTS_VALUE
&& pkt
->pts
< pkt
->dts
){
2605 av_log(st
->codec
, AV_LOG_ERROR
, "error, pts < dts\n");
2609 // av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2610 st
->cur_dts
= pkt
->dts
;
2611 st
->pts
.val
= pkt
->dts
;
2614 switch (st
->codec
->codec_type
) {
2615 case CODEC_TYPE_AUDIO
:
2616 frame_size
= get_audio_frame_size(st
->codec
, pkt
->size
);
2618 /* HACK/FIXME, we skip the initial 0 size packets as they are most
2619 likely equal to the encoder delay, but it would be better if we
2620 had the real timestamps from the encoder */
2621 if (frame_size
>= 0 && (pkt
->size
|| st
->pts
.num
!=st
->pts
.den
>>1 || st
->pts
.val
)) {
2622 av_frac_add(&st
->pts
, (int64_t)st
->time_base
.den
* frame_size
);
2625 case CODEC_TYPE_VIDEO
:
2626 av_frac_add(&st
->pts
, (int64_t)st
->time_base
.den
* st
->codec
->time_base
.num
);
2634 int av_write_frame(AVFormatContext
*s
, AVPacket
*pkt
)
2636 int ret
= compute_pkt_fields2(s
->streams
[pkt
->stream_index
], pkt
);
2638 if(ret
<0 && !(s
->oformat
->flags
& AVFMT_NOTIMESTAMPS
))
2641 ret
= s
->oformat
->write_packet(s
, pkt
);
2643 ret
= url_ferror(s
->pb
);
2647 void ff_interleave_add_packet(AVFormatContext
*s
, AVPacket
*pkt
,
2648 int (*compare
)(AVFormatContext
*, AVPacket
*, AVPacket
*))
2650 AVPacketList
**next_point
, *this_pktl
;
2652 this_pktl
= av_mallocz(sizeof(AVPacketList
));
2653 this_pktl
->pkt
= *pkt
;
2654 pkt
->destruct
= NULL
; // do not free original but only the copy
2655 av_dup_packet(&this_pktl
->pkt
); // duplicate the packet if it uses non-alloced memory
2657 next_point
= &s
->packet_buffer
;
2659 if(compare(s
, &(*next_point
)->pkt
, pkt
))
2661 next_point
= &(*next_point
)->next
;
2663 this_pktl
->next
= *next_point
;
2664 *next_point
= this_pktl
;
2667 int ff_interleave_compare_dts(AVFormatContext
*s
, AVPacket
*next
, AVPacket
*pkt
)
2669 AVStream
*st
= s
->streams
[ pkt
->stream_index
];
2670 AVStream
*st2
= s
->streams
[ next
->stream_index
];
2671 int64_t left
= st2
->time_base
.num
* (int64_t)st
->time_base
.den
;
2672 int64_t right
= st
->time_base
.num
* (int64_t)st2
->time_base
.den
;
2674 if (pkt
->dts
== AV_NOPTS_VALUE
)
2677 return next
->dts
* left
> pkt
->dts
* right
; //FIXME this can overflow
2680 int av_interleave_packet_per_dts(AVFormatContext
*s
, AVPacket
*out
, AVPacket
*pkt
, int flush
){
2683 int streams
[MAX_STREAMS
];
2686 ff_interleave_add_packet(s
, pkt
, ff_interleave_compare_dts
);
2689 memset(streams
, 0, sizeof(streams
));
2690 pktl
= s
->packet_buffer
;
2692 //av_log(s, AV_LOG_DEBUG, "show st:%d dts:%"PRId64"\n", pktl->pkt.stream_index, pktl->pkt.dts);
2693 if(streams
[ pktl
->pkt
.stream_index
] == 0)
2695 streams
[ pktl
->pkt
.stream_index
]++;
2699 if(stream_count
&& (s
->nb_streams
== stream_count
|| flush
)){
2700 pktl
= s
->packet_buffer
;
2703 s
->packet_buffer
= pktl
->next
;
2707 av_init_packet(out
);
2713 * Interleaves an AVPacket correctly so it can be muxed.
2714 * @param out the interleaved packet will be output here
2715 * @param in the input packet
2716 * @param flush 1 if no further packets are available as input and all
2717 * remaining packets should be output
2718 * @return 1 if a packet was output, 0 if no packet could be output,
2719 * < 0 if an error occurred
2721 static int av_interleave_packet(AVFormatContext
*s
, AVPacket
*out
, AVPacket
*in
, int flush
){
2722 if(s
->oformat
->interleave_packet
)
2723 return s
->oformat
->interleave_packet(s
, out
, in
, flush
);
2725 return av_interleave_packet_per_dts(s
, out
, in
, flush
);
2728 int av_interleaved_write_frame(AVFormatContext
*s
, AVPacket
*pkt
){
2729 AVStream
*st
= s
->streams
[ pkt
->stream_index
];
2731 //FIXME/XXX/HACK drop zero sized packets
2732 if(st
->codec
->codec_type
== CODEC_TYPE_AUDIO
&& pkt
->size
==0)
2735 //av_log(NULL, AV_LOG_DEBUG, "av_interleaved_write_frame %d %"PRId64" %"PRId64"\n", pkt->size, pkt->dts, pkt->pts);
2736 if(compute_pkt_fields2(st
, pkt
) < 0 && !(s
->oformat
->flags
& AVFMT_NOTIMESTAMPS
))
2739 if(pkt
->dts
== AV_NOPTS_VALUE
&& !(s
->oformat
->flags
& AVFMT_NOTIMESTAMPS
))
2744 int ret
= av_interleave_packet(s
, &opkt
, pkt
, 0);
2745 if(ret
<=0) //FIXME cleanup needed for ret<0 ?
2748 ret
= s
->oformat
->write_packet(s
, &opkt
);
2750 av_free_packet(&opkt
);
2755 if(url_ferror(s
->pb
))
2756 return url_ferror(s
->pb
);
2760 int av_write_trailer(AVFormatContext
*s
)
2766 ret
= av_interleave_packet(s
, &pkt
, NULL
, 1);
2767 if(ret
<0) //FIXME cleanup needed for ret<0 ?
2772 ret
= s
->oformat
->write_packet(s
, &pkt
);
2774 av_free_packet(&pkt
);
2778 if(url_ferror(s
->pb
))
2782 if(s
->oformat
->write_trailer
)
2783 ret
= s
->oformat
->write_trailer(s
);
2786 ret
=url_ferror(s
->pb
);
2787 for(i
=0;i
<s
->nb_streams
;i
++)
2788 av_freep(&s
->streams
[i
]->priv_data
);
2789 av_freep(&s
->priv_data
);
2793 void av_program_add_stream_index(AVFormatContext
*ac
, int progid
, unsigned int idx
)
2796 AVProgram
*program
=NULL
;
2799 for(i
=0; i
<ac
->nb_programs
; i
++){
2800 if(ac
->programs
[i
]->id
!= progid
)
2802 program
= ac
->programs
[i
];
2803 for(j
=0; j
<program
->nb_stream_indexes
; j
++)
2804 if(program
->stream_index
[j
] == idx
)
2807 tmp
= av_realloc(program
->stream_index
, sizeof(unsigned int)*(program
->nb_stream_indexes
+1));
2810 program
->stream_index
= tmp
;
2811 program
->stream_index
[program
->nb_stream_indexes
++] = idx
;
2816 static void print_fps(double d
, const char *postfix
){
2817 uint64_t v
= lrintf(d
*100);
2818 if (v
% 100 ) av_log(NULL
, AV_LOG_INFO
, ", %3.2f %s", d
, postfix
);
2819 else if(v
%(100*1000)) av_log(NULL
, AV_LOG_INFO
, ", %1.0f %s", d
, postfix
);
2820 else av_log(NULL
, AV_LOG_INFO
, ", %1.0fk %s", d
/1000, postfix
);
2823 /* "user interface" functions */
2824 static void dump_stream_format(AVFormatContext
*ic
, int i
, int index
, int is_output
)
2827 int flags
= (is_output
? ic
->oformat
->flags
: ic
->iformat
->flags
);
2828 AVStream
*st
= ic
->streams
[i
];
2829 int g
= av_gcd(st
->time_base
.num
, st
->time_base
.den
);
2830 AVMetadataTag
*lang
= av_metadata_get(st
->metadata
, "language", NULL
, 0);
2831 avcodec_string(buf
, sizeof(buf
), st
->codec
, is_output
);
2832 av_log(NULL
, AV_LOG_INFO
, " Stream #%d.%d", index
, i
);
2833 /* the pid is an important information, so we display it */
2834 /* XXX: add a generic system */
2835 if (flags
& AVFMT_SHOW_IDS
)
2836 av_log(NULL
, AV_LOG_INFO
, "[0x%x]", st
->id
);
2838 av_log(NULL
, AV_LOG_INFO
, "(%s)", lang
->value
);
2839 av_log(NULL
, AV_LOG_DEBUG
, ", %d/%d", st
->time_base
.num
/g
, st
->time_base
.den
/g
);
2840 av_log(NULL
, AV_LOG_INFO
, ": %s", buf
);
2841 if (st
->sample_aspect_ratio
.num
&& // default
2842 av_cmp_q(st
->sample_aspect_ratio
, st
->codec
->sample_aspect_ratio
)) {
2843 AVRational display_aspect_ratio
;
2844 av_reduce(&display_aspect_ratio
.num
, &display_aspect_ratio
.den
,
2845 st
->codec
->width
*st
->sample_aspect_ratio
.num
,
2846 st
->codec
->height
*st
->sample_aspect_ratio
.den
,
2848 av_log(NULL
, AV_LOG_INFO
, ", PAR %d:%d DAR %d:%d",
2849 st
->sample_aspect_ratio
.num
, st
->sample_aspect_ratio
.den
,
2850 display_aspect_ratio
.num
, display_aspect_ratio
.den
);
2852 if(st
->codec
->codec_type
== CODEC_TYPE_VIDEO
){
2853 if(st
->r_frame_rate
.den
&& st
->r_frame_rate
.num
)
2854 print_fps(av_q2d(st
->r_frame_rate
), "tbr");
2855 if(st
->time_base
.den
&& st
->time_base
.num
)
2856 print_fps(1/av_q2d(st
->time_base
), "tbn");
2857 if(st
->codec
->time_base
.den
&& st
->codec
->time_base
.num
)
2858 print_fps(1/av_q2d(st
->codec
->time_base
), "tbc");
2860 av_log(NULL
, AV_LOG_INFO
, "\n");
2863 void dump_format(AVFormatContext
*ic
,
2870 av_log(NULL
, AV_LOG_INFO
, "%s #%d, %s, %s '%s':\n",
2871 is_output
? "Output" : "Input",
2873 is_output
? ic
->oformat
->name
: ic
->iformat
->name
,
2874 is_output
? "to" : "from", url
);
2876 av_log(NULL
, AV_LOG_INFO
, " Duration: ");
2877 if (ic
->duration
!= AV_NOPTS_VALUE
) {
2878 int hours
, mins
, secs
, us
;
2879 secs
= ic
->duration
/ AV_TIME_BASE
;
2880 us
= ic
->duration
% AV_TIME_BASE
;
2885 av_log(NULL
, AV_LOG_INFO
, "%02d:%02d:%02d.%02d", hours
, mins
, secs
,
2886 (100 * us
) / AV_TIME_BASE
);
2888 av_log(NULL
, AV_LOG_INFO
, "N/A");
2890 if (ic
->start_time
!= AV_NOPTS_VALUE
) {
2892 av_log(NULL
, AV_LOG_INFO
, ", start: ");
2893 secs
= ic
->start_time
/ AV_TIME_BASE
;
2894 us
= ic
->start_time
% AV_TIME_BASE
;
2895 av_log(NULL
, AV_LOG_INFO
, "%d.%06d",
2896 secs
, (int)av_rescale(us
, 1000000, AV_TIME_BASE
));
2898 av_log(NULL
, AV_LOG_INFO
, ", bitrate: ");
2900 av_log(NULL
, AV_LOG_INFO
,"%d kb/s", ic
->bit_rate
/ 1000);
2902 av_log(NULL
, AV_LOG_INFO
, "N/A");
2904 av_log(NULL
, AV_LOG_INFO
, "\n");
2906 if(ic
->nb_programs
) {
2908 for(j
=0; j
<ic
->nb_programs
; j
++) {
2909 AVMetadataTag
*name
= av_metadata_get(ic
->programs
[j
]->metadata
,
2911 av_log(NULL
, AV_LOG_INFO
, " Program %d %s\n", ic
->programs
[j
]->id
,
2912 name
? name
->value
: "");
2913 for(k
=0; k
<ic
->programs
[j
]->nb_stream_indexes
; k
++)
2914 dump_stream_format(ic
, ic
->programs
[j
]->stream_index
[k
], index
, is_output
);
2917 for(i
=0;i
<ic
->nb_streams
;i
++)
2918 dump_stream_format(ic
, i
, index
, is_output
);
2920 AVMetadataTag
*tag
=NULL
;
2921 av_log(NULL
, AV_LOG_INFO
, " Metadata\n");
2922 while((tag
=av_metadata_get(ic
->metadata
, "", tag
, AV_METADATA_IGNORE_SUFFIX
))) {
2923 av_log(NULL
, AV_LOG_INFO
, " %-16s: %s\n", tag
->key
, tag
->value
);
2929 #if LIBAVFORMAT_VERSION_MAJOR < 53
2930 int parse_image_size(int *width_ptr
, int *height_ptr
, const char *str
)
2932 return av_parse_video_frame_size(width_ptr
, height_ptr
, str
);
2935 int parse_frame_rate(int *frame_rate_num
, int *frame_rate_den
, const char *arg
)
2937 AVRational frame_rate
;
2938 int ret
= av_parse_video_frame_rate(&frame_rate
, arg
);
2939 *frame_rate_num
= frame_rate
.num
;
2940 *frame_rate_den
= frame_rate
.den
;
2945 int64_t av_gettime(void)
2948 gettimeofday(&tv
,NULL
);
2949 return (int64_t)tv
.tv_sec
* 1000000 + tv
.tv_usec
;
2952 int64_t parse_date(const char *datestr
, int duration
)
2958 static const char * const date_fmt
[] = {
2962 static const char * const time_fmt
[] = {
2972 time_t now
= time(0);
2974 len
= strlen(datestr
);
2976 lastch
= datestr
[len
- 1];
2979 is_utc
= (lastch
== 'z' || lastch
== 'Z');
2981 memset(&dt
, 0, sizeof(dt
));
2986 if (!strncasecmp(datestr
, "now", len
))
2987 return (int64_t) now
* 1000000;
2989 /* parse the year-month-day part */
2990 for (i
= 0; i
< FF_ARRAY_ELEMS(date_fmt
); i
++) {
2991 q
= small_strptime(p
, date_fmt
[i
], &dt
);
2997 /* if the year-month-day part is missing, then take the
2998 * current year-month-day time */
3003 dt
= *localtime(&now
);
3005 dt
.tm_hour
= dt
.tm_min
= dt
.tm_sec
= 0;
3010 if (*p
== 'T' || *p
== 't' || *p
== ' ')
3013 /* parse the hour-minute-second part */
3014 for (i
= 0; i
< FF_ARRAY_ELEMS(time_fmt
); i
++) {
3015 q
= small_strptime(p
, time_fmt
[i
], &dt
);
3021 /* parse datestr as a duration */
3026 /* parse datestr as HH:MM:SS */
3027 q
= small_strptime(p
, time_fmt
[0], &dt
);
3029 /* parse datestr as S+ */
3030 dt
.tm_sec
= strtol(p
, (char **)&q
, 10);
3032 /* the parsing didn't succeed */
3039 /* Now we have all the fields that we can get */
3045 t
= dt
.tm_hour
* 3600 + dt
.tm_min
* 60 + dt
.tm_sec
;
3047 dt
.tm_isdst
= -1; /* unknown */
3057 /* parse the .m... part */
3061 for (val
= 0, n
= 100000; n
>= 1; n
/= 10, q
++) {
3064 val
+= n
* (*q
- '0');
3068 return negative
? -t
: t
;
3071 int find_info_tag(char *arg
, int arg_size
, const char *tag1
, const char *info
)
3081 while (*p
!= '\0' && *p
!= '=' && *p
!= '&') {
3082 if ((q
- tag
) < sizeof(tag
) - 1)
3090 while (*p
!= '&' && *p
!= '\0') {
3091 if ((q
- arg
) < arg_size
- 1) {
3101 if (!strcmp(tag
, tag1
))
3110 int av_get_frame_filename(char *buf
, int buf_size
,
3111 const char *path
, int number
)
3114 char *q
, buf1
[20], c
;
3115 int nd
, len
, percentd_found
;
3127 while (isdigit(*p
)) {
3128 nd
= nd
* 10 + *p
++ - '0';
3131 } while (isdigit(c
));
3140 snprintf(buf1
, sizeof(buf1
), "%0*d", nd
, number
);
3142 if ((q
- buf
+ len
) > buf_size
- 1)
3144 memcpy(q
, buf1
, len
);
3152 if ((q
- buf
) < buf_size
- 1)
3156 if (!percentd_found
)
3165 static void hex_dump_internal(void *avcl
, FILE *f
, int level
, uint8_t *buf
, int size
)
3168 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3170 for(i
=0;i
<size
;i
+=16) {
3177 PRINT(" %02x", buf
[i
+j
]);
3182 for(j
=0;j
<len
;j
++) {
3184 if (c
< ' ' || c
> '~')
3193 void av_hex_dump(FILE *f
, uint8_t *buf
, int size
)
3195 hex_dump_internal(NULL
, f
, 0, buf
, size
);
3198 void av_hex_dump_log(void *avcl
, int level
, uint8_t *buf
, int size
)
3200 hex_dump_internal(avcl
, NULL
, level
, buf
, size
);
3203 //FIXME needs to know the time_base
3204 static void pkt_dump_internal(void *avcl
, FILE *f
, int level
, AVPacket
*pkt
, int dump_payload
)
3206 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3207 PRINT("stream #%d:\n", pkt
->stream_index
);
3208 PRINT(" keyframe=%d\n", ((pkt
->flags
& PKT_FLAG_KEY
) != 0));
3209 PRINT(" duration=%0.3f\n", (double)pkt
->duration
/ AV_TIME_BASE
);
3210 /* DTS is _always_ valid after av_read_frame() */
3212 if (pkt
->dts
== AV_NOPTS_VALUE
)
3215 PRINT("%0.3f", (double)pkt
->dts
/ AV_TIME_BASE
);
3216 /* PTS may not be known if B-frames are present. */
3218 if (pkt
->pts
== AV_NOPTS_VALUE
)
3221 PRINT("%0.3f", (double)pkt
->pts
/ AV_TIME_BASE
);
3223 PRINT(" size=%d\n", pkt
->size
);
3226 av_hex_dump(f
, pkt
->data
, pkt
->size
);
3229 void av_pkt_dump(FILE *f
, AVPacket
*pkt
, int dump_payload
)
3231 pkt_dump_internal(NULL
, f
, 0, pkt
, dump_payload
);
3234 void av_pkt_dump_log(void *avcl
, int level
, AVPacket
*pkt
, int dump_payload
)
3236 pkt_dump_internal(avcl
, NULL
, level
, pkt
, dump_payload
);
3239 void url_split(char *proto
, int proto_size
,
3240 char *authorization
, int authorization_size
,
3241 char *hostname
, int hostname_size
,
3243 char *path
, int path_size
,
3246 const char *p
, *ls
, *at
, *col
, *brk
;
3248 if (port_ptr
) *port_ptr
= -1;
3249 if (proto_size
> 0) proto
[0] = 0;
3250 if (authorization_size
> 0) authorization
[0] = 0;
3251 if (hostname_size
> 0) hostname
[0] = 0;
3252 if (path_size
> 0) path
[0] = 0;
3254 /* parse protocol */
3255 if ((p
= strchr(url
, ':'))) {
3256 av_strlcpy(proto
, url
, FFMIN(proto_size
, p
+ 1 - url
));
3261 /* no protocol means plain filename */
3262 av_strlcpy(path
, url
, path_size
);
3266 /* separate path from hostname */
3267 ls
= strchr(p
, '/');
3269 ls
= strchr(p
, '?');
3271 av_strlcpy(path
, ls
, path_size
);
3273 ls
= &p
[strlen(p
)]; // XXX
3275 /* the rest is hostname, use that to parse auth/port */
3277 /* authorization (user[:pass]@hostname) */
3278 if ((at
= strchr(p
, '@')) && at
< ls
) {
3279 av_strlcpy(authorization
, p
,
3280 FFMIN(authorization_size
, at
+ 1 - p
));
3281 p
= at
+ 1; /* skip '@' */
3284 if (*p
== '[' && (brk
= strchr(p
, ']')) && brk
< ls
) {
3286 av_strlcpy(hostname
, p
+ 1,
3287 FFMIN(hostname_size
, brk
- p
));
3288 if (brk
[1] == ':' && port_ptr
)
3289 *port_ptr
= atoi(brk
+ 2);
3290 } else if ((col
= strchr(p
, ':')) && col
< ls
) {
3291 av_strlcpy(hostname
, p
,
3292 FFMIN(col
+ 1 - p
, hostname_size
));
3293 if (port_ptr
) *port_ptr
= atoi(col
+ 1);
3295 av_strlcpy(hostname
, p
,
3296 FFMIN(ls
+ 1 - p
, hostname_size
));
3300 char *ff_data_to_hex(char *buff
, const uint8_t *src
, int s
)
3303 static const char hex_table
[16] = { '0', '1', '2', '3',
3306 'C', 'D', 'E', 'F' };
3308 for(i
= 0; i
< s
; i
++) {
3309 buff
[i
* 2] = hex_table
[src
[i
] >> 4];
3310 buff
[i
* 2 + 1] = hex_table
[src
[i
] & 0xF];
3316 void av_set_pts_info(AVStream
*s
, int pts_wrap_bits
,
3317 unsigned int pts_num
, unsigned int pts_den
)
3319 s
->pts_wrap_bits
= pts_wrap_bits
;
3321 if(av_reduce(&s
->time_base
.num
, &s
->time_base
.den
, pts_num
, pts_den
, INT_MAX
)){
3322 if(s
->time_base
.num
!= pts_num
)
3323 av_log(NULL
, AV_LOG_DEBUG
, "st:%d removing common factor %d from timebase\n", s
->index
, pts_num
/s
->time_base
.num
);
3325 av_log(NULL
, AV_LOG_WARNING
, "st:%d has too large timebase, reducing\n", s
->index
);
3327 if(!s
->time_base
.num
|| !s
->time_base
.den
)
3328 s
->time_base
.num
= s
->time_base
.den
= 0;