2 * Various utilities for ffmpeg system
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
22 #include "allformats.h"
29 * @file libavformat/utils.c
30 * Various utility functions for using ffmpeg library.
33 static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den);
34 static void av_frac_add(AVFrac *f, int64_t incr);
36 /** head of registered input format linked list. */
37 AVInputFormat *first_iformat = NULL;
38 /** head of registered output format linked list. */
39 AVOutputFormat *first_oformat = NULL;
41 void av_register_input_format(AVInputFormat *format)
45 while (*p != NULL) p = &(*p)->next;
50 void av_register_output_format(AVOutputFormat *format)
54 while (*p != NULL) p = &(*p)->next;
59 int match_ext(const char *filename, const char *extensions)
67 ext = strrchr(filename, '.');
73 while (*p != '\0' && *p != ',' && q-ext1<sizeof(ext1)-1)
76 if (!strcasecmp(ext1, ext))
86 AVOutputFormat *guess_format(const char *short_name, const char *filename,
87 const char *mime_type)
89 AVOutputFormat *fmt, *fmt_found;
92 /* specific test for image sequences */
93 #ifdef CONFIG_IMAGE2_MUXER
94 if (!short_name && filename &&
95 av_filename_number_test(filename) &&
96 av_guess_image2_codec(filename) != CODEC_ID_NONE) {
97 return guess_format("image2", NULL, NULL);
100 /* find the proper file type */
104 while (fmt != NULL) {
106 if (fmt->name && short_name && !strcmp(fmt->name, short_name))
108 if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
110 if (filename && fmt->extensions &&
111 match_ext(filename, fmt->extensions)) {
114 if (score > score_max) {
123 AVOutputFormat *guess_stream_format(const char *short_name, const char *filename,
124 const char *mime_type)
126 AVOutputFormat *fmt = guess_format(short_name, filename, mime_type);
129 AVOutputFormat *stream_fmt;
130 char stream_format_name[64];
132 snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
133 stream_fmt = guess_format(stream_format_name, NULL, NULL);
142 enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
143 const char *filename, const char *mime_type, enum CodecType type){
144 if(type == CODEC_TYPE_VIDEO){
145 enum CodecID codec_id= CODEC_ID_NONE;
147 #ifdef CONFIG_IMAGE2_MUXER
148 if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
149 codec_id= av_guess_image2_codec(filename);
152 if(codec_id == CODEC_ID_NONE)
153 codec_id= fmt->video_codec;
155 }else if(type == CODEC_TYPE_AUDIO)
156 return fmt->audio_codec;
158 return CODEC_ID_NONE;
161 AVInputFormat *av_find_input_format(const char *short_name)
164 for(fmt = first_iformat; fmt != NULL; fmt = fmt->next) {
165 if (!strcmp(fmt->name, short_name))
171 /* memory handling */
173 void av_destruct_packet(AVPacket *pkt)
176 pkt->data = NULL; pkt->size = 0;
179 void av_init_packet(AVPacket *pkt)
181 pkt->pts = AV_NOPTS_VALUE;
182 pkt->dts = AV_NOPTS_VALUE;
186 pkt->stream_index = 0;
187 pkt->destruct= av_destruct_packet_nofree;
190 int av_new_packet(AVPacket *pkt, int size)
193 if((unsigned)size > (unsigned)size + FF_INPUT_BUFFER_PADDING_SIZE)
194 return AVERROR_NOMEM;
195 data = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
197 return AVERROR_NOMEM;
198 memset(data + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
203 pkt->destruct = av_destruct_packet;
207 int av_get_packet(ByteIOContext *s, AVPacket *pkt, int size)
209 int ret= av_new_packet(pkt, size);
214 pkt->pos= url_ftell(s);
216 ret= get_buffer(s, pkt->data, size);
225 int av_dup_packet(AVPacket *pkt)
227 if (pkt->destruct != av_destruct_packet) {
229 /* we duplicate the packet and don't forget to put the padding
231 if((unsigned)pkt->size > (unsigned)pkt->size + FF_INPUT_BUFFER_PADDING_SIZE)
232 return AVERROR_NOMEM;
233 data = av_malloc(pkt->size + FF_INPUT_BUFFER_PADDING_SIZE);
235 return AVERROR_NOMEM;
237 memcpy(data, pkt->data, pkt->size);
238 memset(data + pkt->size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
240 pkt->destruct = av_destruct_packet;
245 int av_filename_number_test(const char *filename)
248 return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
251 static AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
253 AVInputFormat *fmt1, *fmt;
257 for(fmt1 = first_iformat; fmt1 != NULL; fmt1 = fmt1->next) {
258 if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
261 if (fmt1->read_probe) {
262 score = fmt1->read_probe(pd);
263 } else if (fmt1->extensions) {
264 if (match_ext(pd->filename, fmt1->extensions)) {
268 if (score > *score_max) {
276 AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
278 return av_probe_input_format2(pd, is_opened, &score);
281 /************************************************************/
282 /* input media file */
285 * Open a media file from an IO stream. 'fmt' must be specified.
287 static const char* format_to_name(void* ptr)
289 AVFormatContext* fc = (AVFormatContext*) ptr;
290 if(fc->iformat) return fc->iformat->name;
291 else if(fc->oformat) return fc->oformat->name;
295 #define OFFSET(x) offsetof(AVFormatContext,x)
296 #define DEFAULT 0 //should be NAN but it does not work as it is not a constant in glibc as required by ANSI/ISO C
297 //these names are too long to be readable
298 #define E AV_OPT_FLAG_ENCODING_PARAM
299 #define D AV_OPT_FLAG_DECODING_PARAM
301 static const AVOption options[]={
302 {"probesize", NULL, OFFSET(probesize), FF_OPT_TYPE_INT, 32000, 32, INT_MAX, D}, /* 32000 from mpegts.c: 1.0 second at 24Mbit/s */
303 {"muxrate", "set mux rate", OFFSET(mux_rate), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
304 {"packetsize", "set packet size", OFFSET(packet_size), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
305 {"fflags", NULL, OFFSET(flags), FF_OPT_TYPE_FLAGS, DEFAULT, INT_MIN, INT_MAX, D|E, "fflags"},
306 {"ignidx", "ignore index", 0, FF_OPT_TYPE_CONST, AVFMT_FLAG_IGNIDX, INT_MIN, INT_MAX, D, "fflags"},
307 {"genpts", "generate pts", 0, FF_OPT_TYPE_CONST, AVFMT_FLAG_GENPTS, INT_MIN, INT_MAX, D, "fflags"},
308 {"track", " set the track number", OFFSET(track), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
309 {"year", "set the year", OFFSET(year), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, E},
310 {"analyzeduration", "how many microseconds are analyzed to estimate duration", OFFSET(max_analyze_duration), FF_OPT_TYPE_INT, 3*AV_TIME_BASE, 0, INT_MAX, D},
318 static const AVClass av_format_context_class = { "AVFormatContext", format_to_name, options };
320 static void avformat_get_context_defaults(AVFormatContext *s)
322 memset(s, 0, sizeof(AVFormatContext));
324 s->av_class = &av_format_context_class;
326 av_opt_set_defaults(s);
329 AVFormatContext *av_alloc_format_context(void)
332 ic = av_malloc(sizeof(AVFormatContext));
334 avformat_get_context_defaults(ic);
335 ic->av_class = &av_format_context_class;
339 int av_open_input_stream(AVFormatContext **ic_ptr,
340 ByteIOContext *pb, const char *filename,
341 AVInputFormat *fmt, AVFormatParameters *ap)
345 AVFormatParameters default_ap;
349 memset(ap, 0, sizeof(default_ap));
352 if(!ap->prealloced_context)
353 ic = av_alloc_format_context();
363 ic->duration = AV_NOPTS_VALUE;
364 ic->start_time = AV_NOPTS_VALUE;
365 pstrcpy(ic->filename, sizeof(ic->filename), filename);
367 /* allocate private data */
368 if (fmt->priv_data_size > 0) {
369 ic->priv_data = av_mallocz(fmt->priv_data_size);
370 if (!ic->priv_data) {
375 ic->priv_data = NULL;
378 err = ic->iformat->read_header(ic, ap);
382 if (pb && !ic->data_offset)
383 ic->data_offset = url_ftell(&ic->pb);
389 av_freep(&ic->priv_data);
396 /** Size of probe buffer, for guessing file type from file contents. */
397 #define PROBE_BUF_MIN 2048
398 #define PROBE_BUF_MAX (1<<20)
400 int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
403 AVFormatParameters *ap)
405 int err, must_open_file, file_opened, probe_size;
406 AVProbeData probe_data, *pd = &probe_data;
407 ByteIOContext pb1, *pb = &pb1;
412 pd->filename = filename;
417 /* guess format if no file can be opened */
418 fmt = av_probe_input_format(pd, 0);
421 /* do not open file if the format does not need it. XXX: specific
422 hack needed to handle RTSP/TCP */
424 if (fmt && (fmt->flags & AVFMT_NOFILE)) {
426 pb= NULL; //FIXME this or memset(pb, 0, sizeof(ByteIOContext)); otherwise its uninitalized
429 if (!fmt || must_open_file) {
430 /* if no file needed do not try to open one */
431 if ((err=url_fopen(pb, filename, URL_RDONLY)) < 0) {
436 url_setbufsize(pb, buf_size);
439 for(probe_size= PROBE_BUF_MIN; probe_size<=PROBE_BUF_MAX && !fmt; probe_size<<=1){
440 int score= probe_size < PROBE_BUF_MAX ? AVPROBE_SCORE_MAX/4 : 0;
441 /* read probe data */
442 pd->buf= av_realloc(pd->buf, probe_size + AVPROBE_PADDING_SIZE);
443 pd->buf_size = get_buffer(pb, pd->buf, probe_size);
444 if (url_fseek(pb, 0, SEEK_SET) < 0) {
446 if (url_fopen(pb, filename, URL_RDONLY) < 0) {
452 /* guess file format */
453 fmt = av_probe_input_format2(pd, 1, &score);
458 /* if still no format found, error */
464 /* XXX: suppress this hack for redirectors */
465 #ifdef CONFIG_REDIR_DEMUXER
466 if (fmt == &redir_demuxer) {
467 err = redir_open(ic_ptr, pb);
473 /* check filename in case of an image number is expected */
474 if (fmt->flags & AVFMT_NEEDNUMBER) {
475 if (!av_filename_number_test(filename)) {
476 err = AVERROR_NUMEXPECTED;
480 err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
493 /*******************************************************/
495 int av_read_packet(AVFormatContext *s, AVPacket *pkt)
498 return s->iformat->read_packet(s, pkt);
501 /**********************************************************/
504 * Get the number of samples of an audio frame. Return (-1) if error.
506 static int get_audio_frame_size(AVCodecContext *enc, int size)
510 if (enc->frame_size <= 1) {
511 int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
513 if (bits_per_sample) {
514 if (enc->channels == 0)
516 frame_size = (size << 3) / (bits_per_sample * enc->channels);
518 /* used for example by ADPCM codecs */
519 if (enc->bit_rate == 0)
521 frame_size = (size * 8 * enc->sample_rate) / enc->bit_rate;
524 frame_size = enc->frame_size;
531 * Return the frame duration in seconds, return 0 if not available.
533 static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
534 AVCodecParserContext *pc, AVPacket *pkt)
540 switch(st->codec->codec_type) {
541 case CODEC_TYPE_VIDEO:
542 if(st->time_base.num*1000LL > st->time_base.den){
543 *pnum = st->time_base.num;
544 *pden = st->time_base.den;
545 }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
546 *pnum = st->codec->time_base.num;
547 *pden = st->codec->time_base.den;
548 if (pc && pc->repeat_pict) {
550 *pnum = (*pnum) * (2 + pc->repeat_pict);
554 case CODEC_TYPE_AUDIO:
555 frame_size = get_audio_frame_size(st->codec, pkt->size);
559 *pden = st->codec->sample_rate;
566 static int is_intra_only(AVCodecContext *enc){
567 if(enc->codec_type == CODEC_TYPE_AUDIO){
569 }else if(enc->codec_type == CODEC_TYPE_VIDEO){
570 switch(enc->codec_id){
572 case CODEC_ID_MJPEGB:
574 case CODEC_ID_RAWVIDEO:
575 case CODEC_ID_DVVIDEO:
576 case CODEC_ID_HUFFYUV:
577 case CODEC_ID_FFVHUFF:
588 static int64_t lsb2full(int64_t lsb, int64_t last_ts, int lsb_bits){
589 int64_t mask = lsb_bits < 64 ? (1LL<<lsb_bits)-1 : -1LL;
590 int64_t delta= last_ts - mask/2;
591 return ((lsb - delta)&mask) + delta;
594 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
595 AVCodecParserContext *pc, AVPacket *pkt)
597 int num, den, presentation_delayed, delay, i;
599 /* handle wrapping */
600 if(st->cur_dts != AV_NOPTS_VALUE){
601 if(pkt->pts != AV_NOPTS_VALUE)
602 pkt->pts= lsb2full(pkt->pts, st->cur_dts, st->pts_wrap_bits);
603 if(pkt->dts != AV_NOPTS_VALUE)
604 pkt->dts= lsb2full(pkt->dts, st->cur_dts, st->pts_wrap_bits);
607 if (pkt->duration == 0) {
608 compute_frame_duration(&num, &den, st, pc, pkt);
610 pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
614 /* correct timestamps with byte offset if demuxers only have timestamps on packet boundaries */
615 if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
616 /* this will estimate bitrate based on this frame's duration and size */
617 offset = av_rescale(pc->offset, pkt->duration, pkt->size);
618 if(pkt->pts != AV_NOPTS_VALUE)
620 if(pkt->dts != AV_NOPTS_VALUE)
624 if(is_intra_only(st->codec))
625 pkt->flags |= PKT_FLAG_KEY;
627 /* do we have a video B frame ? */
628 delay= st->codec->has_b_frames;
629 presentation_delayed = 0;
630 /* XXX: need has_b_frame, but cannot get it if the codec is
633 pc && pc->pict_type != FF_B_TYPE)
634 presentation_delayed = 1;
635 /* This may be redundant, but it should not hurt. */
636 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
637 presentation_delayed = 1;
639 if(st->cur_dts == AV_NOPTS_VALUE){
640 st->cur_dts = -delay * pkt->duration;
643 // 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);
644 /* interpolate PTS and DTS if they are not present */
646 if (presentation_delayed) {
647 /* DTS = decompression time stamp */
648 /* PTS = presentation time stamp */
649 if (pkt->dts == AV_NOPTS_VALUE)
650 pkt->dts = st->last_IP_pts;
651 if (pkt->dts == AV_NOPTS_VALUE)
652 pkt->dts = st->cur_dts;
654 /* this is tricky: the dts must be incremented by the duration
655 of the frame we are displaying, i.e. the last I or P frame */
656 if (st->last_IP_duration == 0)
657 st->last_IP_duration = pkt->duration;
658 st->cur_dts = pkt->dts + st->last_IP_duration;
659 st->last_IP_duration = pkt->duration;
660 st->last_IP_pts= pkt->pts;
661 /* cannot compute PTS if not present (we can compute it only
662 by knowing the futur */
663 } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
664 if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
665 int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
666 int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
667 if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
668 pkt->pts += pkt->duration;
669 // 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);
673 /* presentation is not delayed : PTS and DTS are the same */
674 if(pkt->pts == AV_NOPTS_VALUE)
676 if(pkt->pts == AV_NOPTS_VALUE)
677 pkt->pts = st->cur_dts;
679 st->cur_dts = pkt->pts + pkt->duration;
683 if(pkt->pts != AV_NOPTS_VALUE){
684 st->pts_buffer[0]= pkt->pts;
685 for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
686 st->pts_buffer[i]= (i-delay-1) * pkt->duration;
687 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
688 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
689 if(pkt->dts == AV_NOPTS_VALUE)
690 pkt->dts= st->pts_buffer[0];
691 if(pkt->dts > st->cur_dts)
692 st->cur_dts = pkt->dts;
695 // 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);
700 /* key frame computation */
701 if (pc->pict_type == FF_I_TYPE)
702 pkt->flags |= PKT_FLAG_KEY;
706 void av_destruct_packet_nofree(AVPacket *pkt)
708 pkt->data = NULL; pkt->size = 0;
711 static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
719 /* select current input stream component */
722 if (!st->need_parsing || !st->parser) {
723 /* no parsing needed: we just output the packet as is */
724 /* raw data support */
726 compute_pkt_fields(s, st, NULL, pkt);
729 } else if (s->cur_len > 0 && st->discard < AVDISCARD_ALL) {
730 len = av_parser_parse(st->parser, st->codec, &pkt->data, &pkt->size,
731 s->cur_ptr, s->cur_len,
732 s->cur_pkt.pts, s->cur_pkt.dts);
733 s->cur_pkt.pts = AV_NOPTS_VALUE;
734 s->cur_pkt.dts = AV_NOPTS_VALUE;
735 /* increment read pointer */
739 /* return packet if any */
742 pkt->pos = s->cur_pkt.pos; // Isn't quite accurate but close.
744 pkt->stream_index = st->index;
745 pkt->pts = st->parser->pts;
746 pkt->dts = st->parser->dts;
747 pkt->destruct = av_destruct_packet_nofree;
748 compute_pkt_fields(s, st, st->parser, pkt);
750 if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & PKT_FLAG_KEY){
751 av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
752 0, 0, AVINDEX_KEYFRAME);
759 av_free_packet(&s->cur_pkt);
763 /* read next packet */
764 ret = av_read_packet(s, &s->cur_pkt);
766 if (ret == AVERROR(EAGAIN))
768 /* return the last frames, if any */
769 for(i = 0; i < s->nb_streams; i++) {
771 if (st->parser && st->need_parsing) {
772 av_parser_parse(st->parser, st->codec,
773 &pkt->data, &pkt->size,
775 AV_NOPTS_VALUE, AV_NOPTS_VALUE);
780 /* no more packets: really terminates parsing */
784 st = s->streams[s->cur_pkt.stream_index];
785 if(st->codec->debug & FF_DEBUG_PTS)
786 av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
787 s->cur_pkt.stream_index,
793 s->cur_ptr = s->cur_pkt.data;
794 s->cur_len = s->cur_pkt.size;
795 if (st->need_parsing && !st->parser) {
796 st->parser = av_parser_init(st->codec->codec_id);
798 /* no parser available : just output the raw packets */
799 st->need_parsing = AVSTREAM_PARSE_NONE;
800 }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
801 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
803 if(st->parser && (s->iformat->flags & AVFMT_GENERIC_INDEX)){
804 st->parser->last_frame_offset=
805 st->parser->cur_offset= s->cur_pkt.pos;
810 if(st->codec->debug & FF_DEBUG_PTS)
811 av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
820 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
824 const int genpts= s->flags & AVFMT_FLAG_GENPTS;
827 pktl = s->packet_buffer;
829 AVPacket *next_pkt= &pktl->pkt;
831 if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
832 while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
833 if( pktl->pkt.stream_index == next_pkt->stream_index
834 && next_pkt->dts < pktl->pkt.dts
835 && pktl->pkt.pts != pktl->pkt.dts //not b frame
836 /*&& pktl->pkt.dts != AV_NOPTS_VALUE*/){
837 next_pkt->pts= pktl->pkt.dts;
841 pktl = s->packet_buffer;
844 if( next_pkt->pts != AV_NOPTS_VALUE
845 || next_pkt->dts == AV_NOPTS_VALUE
847 /* read packet from packet buffer, if there is data */
849 s->packet_buffer = pktl->next;
855 AVPacketList **plast_pktl= &s->packet_buffer;
856 int ret= av_read_frame_internal(s, pkt);
858 if(pktl && ret != AVERROR(EAGAIN)){
865 /* duplicate the packet */
866 if (av_dup_packet(pkt) < 0)
867 return AVERROR_NOMEM;
869 while(*plast_pktl) plast_pktl= &(*plast_pktl)->next; //FIXME maybe maintain pointer to the last?
871 pktl = av_mallocz(sizeof(AVPacketList));
873 return AVERROR_NOMEM;
875 /* add the packet in the buffered packet list */
879 assert(!s->packet_buffer);
880 return av_read_frame_internal(s, pkt);
885 /* XXX: suppress the packet queue */
886 static void flush_packet_queue(AVFormatContext *s)
891 pktl = s->packet_buffer;
894 s->packet_buffer = pktl->next;
895 av_free_packet(&pktl->pkt);
900 /*******************************************************/
903 int av_find_default_stream_index(AVFormatContext *s)
908 if (s->nb_streams <= 0)
910 for(i = 0; i < s->nb_streams; i++) {
912 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
920 * Flush the frame reader.
922 static void av_read_frame_flush(AVFormatContext *s)
927 flush_packet_queue(s);
929 /* free previous packet */
931 if (s->cur_st->parser)
932 av_free_packet(&s->cur_pkt);
939 /* for each stream, reset read state */
940 for(i = 0; i < s->nb_streams; i++) {
944 av_parser_close(st->parser);
947 st->last_IP_pts = AV_NOPTS_VALUE;
948 st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
952 void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
955 for(i = 0; i < s->nb_streams; i++) {
956 AVStream *st = s->streams[i];
958 st->cur_dts = av_rescale(timestamp,
959 st->time_base.den * (int64_t)ref_st->time_base.num,
960 st->time_base.num * (int64_t)ref_st->time_base.den);
964 int av_add_index_entry(AVStream *st,
965 int64_t pos, int64_t timestamp, int size, int distance, int flags)
967 AVIndexEntry *entries, *ie;
970 if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
973 entries = av_fast_realloc(st->index_entries,
974 &st->index_entries_allocated_size,
975 (st->nb_index_entries + 1) *
976 sizeof(AVIndexEntry));
980 st->index_entries= entries;
982 index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
985 index= st->nb_index_entries++;
987 assert(index==0 || ie[-1].timestamp < timestamp);
990 if(ie->timestamp != timestamp){
991 if(ie->timestamp <= timestamp)
993 memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
994 st->nb_index_entries++;
995 }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
996 distance= ie->min_distance;
1000 ie->timestamp = timestamp;
1001 ie->min_distance= distance;
1009 * build an index for raw streams using a parser.
1011 static void av_build_index_raw(AVFormatContext *s)
1013 AVPacket pkt1, *pkt = &pkt1;
1018 av_read_frame_flush(s);
1019 url_fseek(&s->pb, s->data_offset, SEEK_SET);
1022 ret = av_read_frame(s, pkt);
1025 if (pkt->stream_index == 0 && st->parser &&
1026 (pkt->flags & PKT_FLAG_KEY)) {
1027 av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
1028 0, 0, AVINDEX_KEYFRAME);
1030 av_free_packet(pkt);
1035 * Returns TRUE if we deal with a raw stream.
1037 * Raw codec data and parsing needed.
1039 static int is_raw_stream(AVFormatContext *s)
1043 if (s->nb_streams != 1)
1046 if (!st->need_parsing)
1051 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1054 AVIndexEntry *entries= st->index_entries;
1055 int nb_entries= st->nb_index_entries;
1064 timestamp = entries[m].timestamp;
1065 if(timestamp >= wanted_timestamp)
1067 if(timestamp <= wanted_timestamp)
1070 m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1072 if(!(flags & AVSEEK_FLAG_ANY)){
1073 while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1074 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1085 int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1086 AVInputFormat *avif= s->iformat;
1087 int64_t pos_min, pos_max, pos, pos_limit;
1088 int64_t ts_min, ts_max, ts;
1092 if (stream_index < 0)
1096 av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1100 ts_min= AV_NOPTS_VALUE;
1101 pos_limit= -1; //gcc falsely says it may be uninitalized
1103 st= s->streams[stream_index];
1104 if(st->index_entries){
1107 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()
1108 index= FFMAX(index, 0);
1109 e= &st->index_entries[index];
1111 if(e->timestamp <= target_ts || e->pos == e->min_distance){
1113 ts_min= e->timestamp;
1115 av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1122 index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1123 assert(index < st->nb_index_entries);
1125 e= &st->index_entries[index];
1126 assert(e->timestamp >= target_ts);
1128 ts_max= e->timestamp;
1129 pos_limit= pos_max - e->min_distance;
1131 av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1132 pos_max,pos_limit, ts_max);
1137 pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1142 url_fseek(&s->pb, pos, SEEK_SET);
1144 av_update_cur_dts(s, st, ts);
1149 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 )){
1151 int64_t start_pos, filesize;
1155 av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1158 if(ts_min == AV_NOPTS_VALUE){
1159 pos_min = s->data_offset;
1160 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1161 if (ts_min == AV_NOPTS_VALUE)
1165 if(ts_max == AV_NOPTS_VALUE){
1167 filesize = url_fsize(&s->pb);
1168 pos_max = filesize - 1;
1171 ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1173 }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1174 if (ts_max == AV_NOPTS_VALUE)
1178 int64_t tmp_pos= pos_max + 1;
1179 int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1180 if(tmp_ts == AV_NOPTS_VALUE)
1184 if(tmp_pos >= filesize)
1190 if(ts_min > ts_max){
1192 }else if(ts_min == ts_max){
1197 while (pos_min < pos_limit) {
1199 av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1203 assert(pos_limit <= pos_max);
1206 int64_t approximate_keyframe_distance= pos_max - pos_limit;
1207 // interpolate position (better than dichotomy)
1208 pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1209 + pos_min - approximate_keyframe_distance;
1210 }else if(no_change==1){
1211 // bisection, if interpolation failed to change min or max pos last time
1212 pos = (pos_min + pos_limit)>>1;
1214 // linear search if bisection failed, can only happen if there are very few or no keframes between min/max
1219 else if(pos > pos_limit)
1223 ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1229 av_log(s, AV_LOG_DEBUG, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64" target:%"PRId64" limit:%"PRId64" start:%"PRId64" noc:%d\n", pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts, pos_limit, start_pos, no_change);
1231 if(ts == AV_NOPTS_VALUE){
1232 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1235 assert(ts != AV_NOPTS_VALUE);
1236 if (target_ts <= ts) {
1237 pos_limit = start_pos - 1;
1241 if (target_ts >= ts) {
1247 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1248 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
1251 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1253 ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1254 av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1255 pos, ts_min, target_ts, ts_max);
1261 static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1262 int64_t pos_min, pos_max;
1266 if (stream_index < 0)
1269 st= s->streams[stream_index];
1272 pos_min = s->data_offset;
1273 pos_max = url_fsize(&s->pb) - 1;
1275 if (pos < pos_min) pos= pos_min;
1276 else if(pos > pos_max) pos= pos_max;
1278 url_fseek(&s->pb, pos, SEEK_SET);
1281 av_update_cur_dts(s, st, ts);
1286 static int av_seek_frame_generic(AVFormatContext *s,
1287 int stream_index, int64_t timestamp, int flags)
1293 st = s->streams[stream_index];
1295 index = av_index_search_timestamp(st, timestamp, flags);
1297 if(index < 0 || index==st->nb_index_entries-1){
1301 if(st->index_entries && st->nb_index_entries){
1302 ie= &st->index_entries[st->nb_index_entries-1];
1303 url_fseek(&s->pb, ie->pos, SEEK_SET);
1304 av_update_cur_dts(s, st, ie->timestamp);
1306 url_fseek(&s->pb, 0, SEEK_SET);
1309 int ret = av_read_frame(s, &pkt);
1312 av_free_packet(&pkt);
1313 if(stream_index == pkt.stream_index){
1314 if((pkt.flags & PKT_FLAG_KEY) && pkt.dts > timestamp)
1318 index = av_index_search_timestamp(st, timestamp, flags);
1323 av_read_frame_flush(s);
1324 if (s->iformat->read_seek){
1325 if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1328 ie = &st->index_entries[index];
1329 url_fseek(&s->pb, ie->pos, SEEK_SET);
1331 av_update_cur_dts(s, st, ie->timestamp);
1336 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1341 av_read_frame_flush(s);
1343 if(flags & AVSEEK_FLAG_BYTE)
1344 return av_seek_frame_byte(s, stream_index, timestamp, flags);
1346 if(stream_index < 0){
1347 stream_index= av_find_default_stream_index(s);
1348 if(stream_index < 0)
1351 st= s->streams[stream_index];
1352 /* timestamp for default must be expressed in AV_TIME_BASE units */
1353 timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1355 st= s->streams[stream_index];
1357 /* first, we try the format specific seek */
1358 if (s->iformat->read_seek)
1359 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1366 if(s->iformat->read_timestamp)
1367 return av_seek_frame_binary(s, stream_index, timestamp, flags);
1369 return av_seek_frame_generic(s, stream_index, timestamp, flags);
1372 /*******************************************************/
1375 * Returns TRUE if the stream has accurate timings in any stream.
1377 * @return TRUE if the stream has accurate timings for at least one component.
1379 static int av_has_timings(AVFormatContext *ic)
1384 for(i = 0;i < ic->nb_streams; i++) {
1385 st = ic->streams[i];
1386 if (st->start_time != AV_NOPTS_VALUE &&
1387 st->duration != AV_NOPTS_VALUE)
1394 * Estimate the stream timings from the one of each components.
1396 * Also computes the global bitrate if possible.
1398 static void av_update_stream_timings(AVFormatContext *ic)
1400 int64_t start_time, start_time1, end_time, end_time1;
1404 start_time = INT64_MAX;
1405 end_time = INT64_MIN;
1406 for(i = 0;i < ic->nb_streams; i++) {
1407 st = ic->streams[i];
1408 if (st->start_time != AV_NOPTS_VALUE) {
1409 start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1410 if (start_time1 < start_time)
1411 start_time = start_time1;
1412 if (st->duration != AV_NOPTS_VALUE) {
1413 end_time1 = start_time1
1414 + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1415 if (end_time1 > end_time)
1416 end_time = end_time1;
1420 if (start_time != INT64_MAX) {
1421 ic->start_time = start_time;
1422 if (end_time != INT64_MIN) {
1423 ic->duration = end_time - start_time;
1424 if (ic->file_size > 0) {
1425 /* compute the bit rate */
1426 ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1427 (double)ic->duration;
1434 static void fill_all_stream_timings(AVFormatContext *ic)
1439 av_update_stream_timings(ic);
1440 for(i = 0;i < ic->nb_streams; i++) {
1441 st = ic->streams[i];
1442 if (st->start_time == AV_NOPTS_VALUE) {
1443 if(ic->start_time != AV_NOPTS_VALUE)
1444 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1445 if(ic->duration != AV_NOPTS_VALUE)
1446 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1451 static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1453 int64_t filesize, duration;
1457 /* if bit_rate is already set, we believe it */
1458 if (ic->bit_rate == 0) {
1460 for(i=0;i<ic->nb_streams;i++) {
1461 st = ic->streams[i];
1462 bit_rate += st->codec->bit_rate;
1464 ic->bit_rate = bit_rate;
1467 /* if duration is already set, we believe it */
1468 if (ic->duration == AV_NOPTS_VALUE &&
1469 ic->bit_rate != 0 &&
1470 ic->file_size != 0) {
1471 filesize = ic->file_size;
1473 for(i = 0; i < ic->nb_streams; i++) {
1474 st = ic->streams[i];
1475 duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1476 if (st->start_time == AV_NOPTS_VALUE ||
1477 st->duration == AV_NOPTS_VALUE) {
1479 st->duration = duration;
1486 #define DURATION_MAX_READ_SIZE 250000
1488 /* only usable for MPEG-PS streams */
1489 static void av_estimate_timings_from_pts(AVFormatContext *ic, offset_t old_offset)
1491 AVPacket pkt1, *pkt = &pkt1;
1493 int read_size, i, ret;
1495 int64_t filesize, offset, duration;
1497 /* free previous packet */
1498 if (ic->cur_st && ic->cur_st->parser)
1499 av_free_packet(&ic->cur_pkt);
1502 /* flush packet queue */
1503 flush_packet_queue(ic);
1505 for(i=0;i<ic->nb_streams;i++) {
1506 st = ic->streams[i];
1508 av_parser_close(st->parser);
1513 /* we read the first packets to get the first PTS (not fully
1514 accurate, but it is enough now) */
1515 url_fseek(&ic->pb, 0, SEEK_SET);
1518 if (read_size >= DURATION_MAX_READ_SIZE)
1520 /* if all info is available, we can stop */
1521 for(i = 0;i < ic->nb_streams; i++) {
1522 st = ic->streams[i];
1523 if (st->start_time == AV_NOPTS_VALUE)
1526 if (i == ic->nb_streams)
1529 ret = av_read_packet(ic, pkt);
1532 read_size += pkt->size;
1533 st = ic->streams[pkt->stream_index];
1534 if (pkt->pts != AV_NOPTS_VALUE) {
1535 if (st->start_time == AV_NOPTS_VALUE)
1536 st->start_time = pkt->pts;
1538 av_free_packet(pkt);
1541 /* estimate the end time (duration) */
1542 /* XXX: may need to support wrapping */
1543 filesize = ic->file_size;
1544 offset = filesize - DURATION_MAX_READ_SIZE;
1548 url_fseek(&ic->pb, offset, SEEK_SET);
1551 if (read_size >= DURATION_MAX_READ_SIZE)
1553 /* if all info is available, we can stop */
1554 for(i = 0;i < ic->nb_streams; i++) {
1555 st = ic->streams[i];
1556 if (st->duration == AV_NOPTS_VALUE)
1559 if (i == ic->nb_streams)
1562 ret = av_read_packet(ic, pkt);
1565 read_size += pkt->size;
1566 st = ic->streams[pkt->stream_index];
1567 if (pkt->pts != AV_NOPTS_VALUE) {
1568 end_time = pkt->pts;
1569 duration = end_time - st->start_time;
1571 if (st->duration == AV_NOPTS_VALUE ||
1572 st->duration < duration)
1573 st->duration = duration;
1576 av_free_packet(pkt);
1579 fill_all_stream_timings(ic);
1581 url_fseek(&ic->pb, old_offset, SEEK_SET);
1584 static void av_estimate_timings(AVFormatContext *ic, offset_t old_offset)
1588 /* get the file size, if possible */
1589 if (ic->iformat->flags & AVFMT_NOFILE) {
1592 file_size = url_fsize(&ic->pb);
1596 ic->file_size = file_size;
1598 if ((!strcmp(ic->iformat->name, "mpeg") ||
1599 !strcmp(ic->iformat->name, "mpegts")) &&
1600 file_size && !ic->pb.is_streamed) {
1601 /* get accurate estimate from the PTSes */
1602 av_estimate_timings_from_pts(ic, old_offset);
1603 } else if (av_has_timings(ic)) {
1604 /* at least one components has timings - we use them for all
1606 fill_all_stream_timings(ic);
1608 /* less precise: use bit rate info */
1609 av_estimate_timings_from_bit_rate(ic);
1611 av_update_stream_timings(ic);
1617 for(i = 0;i < ic->nb_streams; i++) {
1618 st = ic->streams[i];
1619 printf("%d: start_time: %0.3f duration: %0.3f\n",
1620 i, (double)st->start_time / AV_TIME_BASE,
1621 (double)st->duration / AV_TIME_BASE);
1623 printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1624 (double)ic->start_time / AV_TIME_BASE,
1625 (double)ic->duration / AV_TIME_BASE,
1626 ic->bit_rate / 1000);
1631 static int has_codec_parameters(AVCodecContext *enc)
1634 switch(enc->codec_type) {
1635 case CODEC_TYPE_AUDIO:
1636 val = enc->sample_rate;
1638 case CODEC_TYPE_VIDEO:
1639 val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
1648 static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1652 int got_picture, data_size, ret=0;
1655 if(!st->codec->codec){
1656 codec = avcodec_find_decoder(st->codec->codec_id);
1659 ret = avcodec_open(st->codec, codec);
1664 if(!has_codec_parameters(st->codec)){
1665 switch(st->codec->codec_type) {
1666 case CODEC_TYPE_VIDEO:
1667 ret = avcodec_decode_video(st->codec, &picture,
1668 &got_picture, (uint8_t *)data, size);
1670 case CODEC_TYPE_AUDIO:
1671 data_size = FFMAX(size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
1672 samples = av_malloc(data_size);
1675 ret = avcodec_decode_audio2(st->codec, samples,
1676 &data_size, (uint8_t *)data, size);
1687 static int set_codec_from_probe_data(AVStream *st, AVProbeData *pd, int score)
1690 fmt = av_probe_input_format2(pd, 1, &score);
1693 if (strncmp(fmt->name, "mp3", 3) == 0)
1694 st->codec->codec_id = CODEC_ID_MP3;
1695 else if (strncmp(fmt->name, "ac3", 3) == 0)
1696 st->codec->codec_id = CODEC_ID_AC3;
1701 /* absolute maximum size we read until we abort */
1702 #define MAX_READ_SIZE 5000000
1704 #define MAX_STD_TIMEBASES (60*12+5)
1705 static int get_std_framerate(int i){
1706 if(i<60*12) return i*1001;
1707 else return ((int[]){24,30,60,12,15})[i-60*12]*1000*12;
1710 int av_find_stream_info(AVFormatContext *ic)
1712 int i, count, ret, read_size, j;
1714 AVPacket pkt1, *pkt;
1715 AVPacketList *pktl=NULL, **ppktl;
1716 int64_t last_dts[MAX_STREAMS];
1717 int duration_count[MAX_STREAMS]={0};
1718 double (*duration_error)[MAX_STD_TIMEBASES];
1719 offset_t old_offset = url_ftell(&ic->pb);
1720 int64_t codec_info_duration[MAX_STREAMS]={0};
1721 int codec_info_nb_frames[MAX_STREAMS]={0};
1722 AVProbeData probe_data[MAX_STREAMS];
1723 int codec_identified[MAX_STREAMS]={0};
1725 duration_error = av_mallocz(MAX_STREAMS * sizeof(*duration_error));
1726 if (!duration_error) return AVERROR_NOMEM;
1728 for(i=0;i<ic->nb_streams;i++) {
1729 st = ic->streams[i];
1730 if(st->codec->codec_type == CODEC_TYPE_VIDEO){
1731 /* if(!st->time_base.num)
1733 if(!st->codec->time_base.num)
1734 st->codec->time_base= st->time_base;
1736 //only for the split stuff
1738 st->parser = av_parser_init(st->codec->codec_id);
1739 if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
1740 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1745 for(i=0;i<MAX_STREAMS;i++){
1746 last_dts[i]= AV_NOPTS_VALUE;
1749 memset(probe_data, 0, sizeof(probe_data));
1752 ppktl = &ic->packet_buffer;
1754 /* check if one codec still needs to be handled */
1755 for(i=0;i<ic->nb_streams;i++) {
1756 st = ic->streams[i];
1757 if (!has_codec_parameters(st->codec))
1759 /* variable fps and no guess at the real fps */
1760 if( (st->codec->time_base.den >= 101LL*st->codec->time_base.num || st->codec->codec_id == CODEC_ID_MPEG2VIDEO)
1761 && duration_count[i]<20 && st->codec->codec_type == CODEC_TYPE_VIDEO)
1763 if(st->parser && st->parser->parser->split && !st->codec->extradata)
1765 if (st->codec->codec_type == CODEC_TYPE_AUDIO &&
1766 st->codec->codec_id == CODEC_ID_NONE)
1769 if (i == ic->nb_streams) {
1770 /* NOTE: if the format has no header, then we need to read
1771 some packets to get most of the streams, so we cannot
1773 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
1774 /* if we found the info for all the codecs, we can stop */
1779 /* we did not get all the codec info, but we read too much data */
1780 if (read_size >= MAX_READ_SIZE) {
1785 /* NOTE: a new stream can be added there if no header in file
1786 (AVFMTCTX_NOHEADER) */
1787 ret = av_read_frame_internal(ic, &pkt1);
1790 ret = -1; /* we could not have all the codec parameters before EOF */
1791 for(i=0;i<ic->nb_streams;i++) {
1792 st = ic->streams[i];
1793 if (!has_codec_parameters(st->codec)){
1795 avcodec_string(buf, sizeof(buf), st->codec, 0);
1796 av_log(ic, AV_LOG_INFO, "Could not find codec parameters (%s)\n", buf);
1804 pktl = av_mallocz(sizeof(AVPacketList));
1806 ret = AVERROR_NOMEM;
1810 /* add the packet in the buffered packet list */
1812 ppktl = &pktl->next;
1817 /* duplicate the packet */
1818 if (av_dup_packet(pkt) < 0) {
1819 ret = AVERROR_NOMEM;
1823 read_size += pkt->size;
1825 st = ic->streams[pkt->stream_index];
1826 if(codec_info_nb_frames[st->index]>1)
1827 codec_info_duration[st->index] += pkt->duration;
1828 if (pkt->duration != 0)
1829 codec_info_nb_frames[st->index]++;
1832 int index= pkt->stream_index;
1833 int64_t last= last_dts[index];
1834 int64_t duration= pkt->dts - last;
1836 if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
1837 double dur= duration * av_q2d(st->time_base);
1839 // if(st->codec->codec_type == CODEC_TYPE_VIDEO)
1840 // av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
1841 if(duration_count[index] < 2)
1842 memset(duration_error, 0, MAX_STREAMS * sizeof(*duration_error));
1843 for(i=1; i<MAX_STD_TIMEBASES; i++){
1844 int framerate= get_std_framerate(i);
1845 int ticks= lrintf(dur*framerate/(1001*12));
1846 double error= dur - ticks*1001*12/(double)framerate;
1847 duration_error[index][i] += error*error;
1849 duration_count[index]++;
1851 if(last == AV_NOPTS_VALUE || duration_count[index]<=1)
1852 last_dts[pkt->stream_index]= pkt->dts;
1854 if (st->codec->codec_id == CODEC_ID_NONE) {
1855 AVProbeData *pd = &(probe_data[st->index]);
1856 pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size);
1857 memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
1858 pd->buf_size += pkt->size;
1861 if(st->parser && st->parser->parser->split && !st->codec->extradata){
1862 int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
1864 st->codec->extradata_size= i;
1865 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
1866 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
1867 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
1871 /* if still no information, we try to open the codec and to
1872 decompress the frame. We try to avoid that in most cases as
1873 it takes longer and uses more memory. For MPEG4, we need to
1874 decompress for Quicktime. */
1875 if (!has_codec_parameters(st->codec) /*&&
1876 (st->codec->codec_id == CODEC_ID_FLV1 ||
1877 st->codec->codec_id == CODEC_ID_H264 ||
1878 st->codec->codec_id == CODEC_ID_H263 ||
1879 st->codec->codec_id == CODEC_ID_H261 ||
1880 st->codec->codec_id == CODEC_ID_VORBIS ||
1881 st->codec->codec_id == CODEC_ID_MJPEG ||
1882 st->codec->codec_id == CODEC_ID_PNG ||
1883 st->codec->codec_id == CODEC_ID_PAM ||
1884 st->codec->codec_id == CODEC_ID_PGM ||
1885 st->codec->codec_id == CODEC_ID_PGMYUV ||
1886 st->codec->codec_id == CODEC_ID_PBM ||
1887 st->codec->codec_id == CODEC_ID_PPM ||
1888 st->codec->codec_id == CODEC_ID_SHORTEN ||
1889 (st->codec->codec_id == CODEC_ID_MPEG4 && !st->need_parsing))*/)
1890 try_decode_frame(st, pkt->data, pkt->size);
1892 if (av_rescale_q(codec_info_duration[st->index], st->time_base, AV_TIME_BASE_Q) >= ic->max_analyze_duration) {
1898 // close codecs which where opened in try_decode_frame()
1899 for(i=0;i<ic->nb_streams;i++) {
1900 st = ic->streams[i];
1901 if(st->codec->codec)
1902 avcodec_close(st->codec);
1904 for(i=0;i<ic->nb_streams;i++) {
1905 st = ic->streams[i];
1906 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1907 if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_sample)
1908 st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
1910 if(duration_count[i]
1911 && (st->codec->time_base.num*101LL <= st->codec->time_base.den || st->codec->codec_id == CODEC_ID_MPEG2VIDEO) /*&&
1912 //FIXME we should not special case mpeg2, but this needs testing with non mpeg2 ...
1913 st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den*/){
1914 double best_error= 2*av_q2d(st->time_base);
1915 best_error= best_error*best_error*duration_count[i]*1000*12*30;
1917 for(j=1; j<MAX_STD_TIMEBASES; j++){
1918 double error= duration_error[i][j] * get_std_framerate(j);
1919 // if(st->codec->codec_type == CODEC_TYPE_VIDEO)
1920 // av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
1921 if(error < best_error){
1923 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, get_std_framerate(j), 12*1001, INT_MAX);
1928 if (!st->r_frame_rate.num){
1929 if( st->codec->time_base.den * (int64_t)st->time_base.num
1930 <= st->codec->time_base.num * (int64_t)st->time_base.den){
1931 st->r_frame_rate.num = st->codec->time_base.den;
1932 st->r_frame_rate.den = st->codec->time_base.num;
1934 st->r_frame_rate.num = st->time_base.den;
1935 st->r_frame_rate.den = st->time_base.num;
1938 }else if(st->codec->codec_type == CODEC_TYPE_AUDIO) {
1939 if (st->codec->codec_id == CODEC_ID_NONE && probe_data[st->index].buf_size > 0) {
1940 codec_identified[st->index] = set_codec_from_probe_data(st, &(probe_data[st->index]), 0);
1941 if (codec_identified[st->index]) {
1942 st->need_parsing = AVSTREAM_PARSE_FULL;
1945 if(!st->codec->bits_per_sample)
1946 st->codec->bits_per_sample= av_get_bits_per_sample(st->codec->codec_id);
1950 av_estimate_timings(ic, old_offset);
1952 for(i=0;i<ic->nb_streams;i++) {
1953 st = ic->streams[i];
1954 if (codec_identified[st->index]) {
1955 av_read_frame_flush(ic);
1956 av_seek_frame(ic, st->index, 0.0, 0);
1957 url_fseek(&ic->pb, ic->data_offset, SEEK_SET);
1962 /* correct DTS for b frame streams with no timestamps */
1963 for(i=0;i<ic->nb_streams;i++) {
1964 st = ic->streams[i];
1965 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1967 ppktl = &ic->packet_buffer;
1969 if(ppkt1->stream_index != i)
1971 if(ppkt1->pkt->dts < 0)
1973 if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
1975 ppkt1->pkt->dts -= delta;
1980 st->cur_dts -= delta;
1986 av_free(duration_error);
1987 for(i=0;i<MAX_STREAMS;i++){
1988 av_freep(&(probe_data[i].buf));
1994 /*******************************************************/
1996 int av_read_play(AVFormatContext *s)
1998 if (!s->iformat->read_play)
1999 return AVERROR_NOTSUPP;
2000 return s->iformat->read_play(s);
2003 int av_read_pause(AVFormatContext *s)
2005 if (!s->iformat->read_pause)
2006 return AVERROR_NOTSUPP;
2007 return s->iformat->read_pause(s);
2010 void av_close_input_file(AVFormatContext *s)
2012 int i, must_open_file;
2015 /* free previous packet */
2016 if (s->cur_st && s->cur_st->parser)
2017 av_free_packet(&s->cur_pkt);
2019 if (s->iformat->read_close)
2020 s->iformat->read_close(s);
2021 for(i=0;i<s->nb_streams;i++) {
2022 /* free all data in a stream component */
2025 av_parser_close(st->parser);
2027 av_free(st->index_entries);
2028 av_free(st->codec->extradata);
2032 flush_packet_queue(s);
2034 if (s->iformat->flags & AVFMT_NOFILE) {
2037 if (must_open_file) {
2040 av_freep(&s->priv_data);
2044 AVStream *av_new_stream(AVFormatContext *s, int id)
2049 if (s->nb_streams >= MAX_STREAMS)
2052 st = av_mallocz(sizeof(AVStream));
2056 st->codec= avcodec_alloc_context();
2058 /* no default bitrate if decoding */
2059 st->codec->bit_rate = 0;
2061 st->index = s->nb_streams;
2063 st->start_time = AV_NOPTS_VALUE;
2064 st->duration = AV_NOPTS_VALUE;
2065 st->cur_dts = AV_NOPTS_VALUE;
2067 /* default pts settings is MPEG like */
2068 av_set_pts_info(st, 33, 1, 90000);
2069 st->last_IP_pts = AV_NOPTS_VALUE;
2070 for(i=0; i<MAX_REORDER_DELAY+1; i++)
2071 st->pts_buffer[i]= AV_NOPTS_VALUE;
2073 s->streams[s->nb_streams++] = st;
2077 /************************************************************/
2078 /* output media file */
2080 int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2084 if (s->oformat->priv_data_size > 0) {
2085 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2087 return AVERROR_NOMEM;
2089 s->priv_data = NULL;
2091 if (s->oformat->set_parameters) {
2092 ret = s->oformat->set_parameters(s, ap);
2099 int av_write_header(AVFormatContext *s)
2104 // some sanity checks
2105 for(i=0;i<s->nb_streams;i++) {
2108 switch (st->codec->codec_type) {
2109 case CODEC_TYPE_AUDIO:
2110 if(st->codec->sample_rate<=0){
2111 av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2115 case CODEC_TYPE_VIDEO:
2116 if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2117 av_log(s, AV_LOG_ERROR, "time base not set\n");
2120 if(st->codec->width<=0 || st->codec->height<=0){
2121 av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2127 if(s->oformat->codec_tag){
2128 if(st->codec->codec_tag){
2130 //check that tag + id is in the table
2131 //if neither is in the table -> ok
2132 //if tag is in the table with another id -> FAIL
2133 //if id is in the table with another tag -> FAIL unless strict < ?
2135 st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2139 if (!s->priv_data && s->oformat->priv_data_size > 0) {
2140 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2142 return AVERROR_NOMEM;
2145 if(s->oformat->write_header){
2146 ret = s->oformat->write_header(s);
2151 /* init PTS generation */
2152 for(i=0;i<s->nb_streams;i++) {
2153 int64_t den = AV_NOPTS_VALUE;
2156 switch (st->codec->codec_type) {
2157 case CODEC_TYPE_AUDIO:
2158 den = (int64_t)st->time_base.num * st->codec->sample_rate;
2160 case CODEC_TYPE_VIDEO:
2161 den = (int64_t)st->time_base.num * st->codec->time_base.den;
2166 if (den != AV_NOPTS_VALUE) {
2168 return AVERROR_INVALIDDATA;
2169 av_frac_init(&st->pts, 0, 0, den);
2175 //FIXME merge with compute_pkt_fields
2176 static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
2177 int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2178 int num, den, frame_size, i;
2180 // 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);
2182 /* if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2185 /* duration field */
2186 if (pkt->duration == 0) {
2187 compute_frame_duration(&num, &den, st, NULL, pkt);
2189 pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
2193 //XXX/FIXME this is a temporary hack until all encoders output pts
2194 if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2196 // pkt->pts= st->cur_dts;
2197 pkt->pts= st->pts.val;
2200 //calculate dts from pts
2201 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE){
2202 st->pts_buffer[0]= pkt->pts;
2203 for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2204 st->pts_buffer[i]= (i-delay-1) * pkt->duration;
2205 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2206 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2208 pkt->dts= st->pts_buffer[0];
2211 if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2212 av_log(NULL, AV_LOG_ERROR, "error, non monotone timestamps %"PRId64" >= %"PRId64"\n", st->cur_dts, pkt->dts);
2215 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2216 av_log(NULL, AV_LOG_ERROR, "error, pts < dts\n");
2220 // av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2221 st->cur_dts= pkt->dts;
2222 st->pts.val= pkt->dts;
2225 switch (st->codec->codec_type) {
2226 case CODEC_TYPE_AUDIO:
2227 frame_size = get_audio_frame_size(st->codec, pkt->size);
2229 /* HACK/FIXME, we skip the initial 0-size packets as they are most likely equal to the encoder delay,
2230 but it would be better if we had the real timestamps from the encoder */
2231 if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2232 av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2235 case CODEC_TYPE_VIDEO:
2236 av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2244 static void truncate_ts(AVStream *st, AVPacket *pkt){
2245 int64_t pts_mask = (2LL << (st->pts_wrap_bits-1)) - 1;
2248 // pkt->dts= 0; //this happens for low_delay=0 and b frames, FIXME, needs further invstigation about what we should do here
2250 if (pkt->pts != AV_NOPTS_VALUE)
2251 pkt->pts &= pts_mask;
2252 if (pkt->dts != AV_NOPTS_VALUE)
2253 pkt->dts &= pts_mask;
2256 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2260 ret=compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2261 if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2264 truncate_ts(s->streams[pkt->stream_index], pkt);
2266 ret= s->oformat->write_packet(s, pkt);
2268 ret= url_ferror(&s->pb);
2272 int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2273 AVPacketList *pktl, **next_point, *this_pktl;
2275 int streams[MAX_STREAMS];
2278 AVStream *st= s->streams[ pkt->stream_index];
2280 // assert(pkt->destruct != av_destruct_packet); //FIXME
2282 this_pktl = av_mallocz(sizeof(AVPacketList));
2283 this_pktl->pkt= *pkt;
2284 if(pkt->destruct == av_destruct_packet)
2285 pkt->destruct= NULL; // non shared -> must keep original from being freed
2287 av_dup_packet(&this_pktl->pkt); //shared -> must dup
2289 next_point = &s->packet_buffer;
2291 AVStream *st2= s->streams[ (*next_point)->pkt.stream_index];
2292 int64_t left= st2->time_base.num * (int64_t)st ->time_base.den;
2293 int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2294 if((*next_point)->pkt.dts * left > pkt->dts * right) //FIXME this can overflow
2296 next_point= &(*next_point)->next;
2298 this_pktl->next= *next_point;
2299 *next_point= this_pktl;
2302 memset(streams, 0, sizeof(streams));
2303 pktl= s->packet_buffer;
2305 //av_log(s, AV_LOG_DEBUG, "show st:%d dts:%"PRId64"\n", pktl->pkt.stream_index, pktl->pkt.dts);
2306 if(streams[ pktl->pkt.stream_index ] == 0)
2308 streams[ pktl->pkt.stream_index ]++;
2312 if(s->nb_streams == stream_count || (flush && stream_count)){
2313 pktl= s->packet_buffer;
2316 s->packet_buffer= pktl->next;
2320 av_init_packet(out);
2326 * Interleaves a AVPacket correctly so it can be muxed.
2327 * @param out the interleaved packet will be output here
2328 * @param in the input packet
2329 * @param flush 1 if no further packets are available as input and all
2330 * remaining packets should be output
2331 * @return 1 if a packet was output, 0 if no packet could be output,
2332 * < 0 if an error occured
2334 static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2335 if(s->oformat->interleave_packet)
2336 return s->oformat->interleave_packet(s, out, in, flush);
2338 return av_interleave_packet_per_dts(s, out, in, flush);
2341 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2342 AVStream *st= s->streams[ pkt->stream_index];
2344 //FIXME/XXX/HACK drop zero sized packets
2345 if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2348 //av_log(NULL, AV_LOG_DEBUG, "av_interleaved_write_frame %d %"PRId64" %"PRId64"\n", pkt->size, pkt->dts, pkt->pts);
2349 if(compute_pkt_fields2(st, pkt) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2352 if(pkt->dts == AV_NOPTS_VALUE)
2357 int ret= av_interleave_packet(s, &opkt, pkt, 0);
2358 if(ret<=0) //FIXME cleanup needed for ret<0 ?
2361 truncate_ts(s->streams[opkt.stream_index], &opkt);
2362 ret= s->oformat->write_packet(s, &opkt);
2364 av_free_packet(&opkt);
2369 if(url_ferror(&s->pb))
2370 return url_ferror(&s->pb);
2374 int av_write_trailer(AVFormatContext *s)
2380 ret= av_interleave_packet(s, &pkt, NULL, 1);
2381 if(ret<0) //FIXME cleanup needed for ret<0 ?
2386 truncate_ts(s->streams[pkt.stream_index], &pkt);
2387 ret= s->oformat->write_packet(s, &pkt);
2389 av_free_packet(&pkt);
2393 if(url_ferror(&s->pb))
2397 if(s->oformat->write_trailer)
2398 ret = s->oformat->write_trailer(s);
2401 ret=url_ferror(&s->pb);
2402 for(i=0;i<s->nb_streams;i++)
2403 av_freep(&s->streams[i]->priv_data);
2404 av_freep(&s->priv_data);
2408 /* "user interface" functions */
2410 void dump_format(AVFormatContext *ic,
2418 av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
2419 is_output ? "Output" : "Input",
2421 is_output ? ic->oformat->name : ic->iformat->name,
2422 is_output ? "to" : "from", url);
2424 av_log(NULL, AV_LOG_INFO, " Duration: ");
2425 if (ic->duration != AV_NOPTS_VALUE) {
2426 int hours, mins, secs, us;
2427 secs = ic->duration / AV_TIME_BASE;
2428 us = ic->duration % AV_TIME_BASE;
2433 av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%01d", hours, mins, secs,
2434 (10 * us) / AV_TIME_BASE);
2436 av_log(NULL, AV_LOG_INFO, "N/A");
2438 if (ic->start_time != AV_NOPTS_VALUE) {
2440 av_log(NULL, AV_LOG_INFO, ", start: ");
2441 secs = ic->start_time / AV_TIME_BASE;
2442 us = ic->start_time % AV_TIME_BASE;
2443 av_log(NULL, AV_LOG_INFO, "%d.%06d",
2444 secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
2446 av_log(NULL, AV_LOG_INFO, ", bitrate: ");
2448 av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
2450 av_log(NULL, AV_LOG_INFO, "N/A");
2452 av_log(NULL, AV_LOG_INFO, "\n");
2454 for(i=0;i<ic->nb_streams;i++) {
2455 AVStream *st = ic->streams[i];
2456 int g= ff_gcd(st->time_base.num, st->time_base.den);
2457 avcodec_string(buf, sizeof(buf), st->codec, is_output);
2458 av_log(NULL, AV_LOG_INFO, " Stream #%d.%d", index, i);
2459 /* the pid is an important information, so we display it */
2460 /* XXX: add a generic system */
2462 flags = ic->oformat->flags;
2464 flags = ic->iformat->flags;
2465 if (flags & AVFMT_SHOW_IDS) {
2466 av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
2468 if (strlen(st->language) > 0) {
2469 av_log(NULL, AV_LOG_INFO, "(%s)", st->language);
2471 av_log(NULL, AV_LOG_DEBUG, ", %d/%d", st->time_base.num/g, st->time_base.den/g);
2472 av_log(NULL, AV_LOG_INFO, ": %s", buf);
2473 if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2474 if(st->r_frame_rate.den && st->r_frame_rate.num)
2475 av_log(NULL, AV_LOG_INFO, ", %5.2f fps(r)", av_q2d(st->r_frame_rate));
2476 /* else if(st->time_base.den && st->time_base.num)
2477 av_log(NULL, AV_LOG_INFO, ", %5.2f fps(m)", 1/av_q2d(st->time_base));*/
2479 av_log(NULL, AV_LOG_INFO, ", %5.2f fps(c)", 1/av_q2d(st->codec->time_base));
2481 av_log(NULL, AV_LOG_INFO, "\n");
2485 int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2487 return av_parse_video_frame_size(width_ptr, height_ptr, str);
2490 int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
2492 AVRational frame_rate;
2493 int ret = av_parse_video_frame_rate(&frame_rate, arg);
2494 *frame_rate_num= frame_rate.num;
2495 *frame_rate_den= frame_rate.den;
2499 int64_t parse_date(const char *datestr, int duration)
2505 static const char *date_fmt[] = {
2509 static const char *time_fmt[] = {
2519 time_t now = time(0);
2521 len = strlen(datestr);
2523 lastch = datestr[len - 1];
2526 is_utc = (lastch == 'z' || lastch == 'Z');
2528 memset(&dt, 0, sizeof(dt));
2533 for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
2534 q = small_strptime(p, date_fmt[i], &dt);
2544 dt = *localtime(&now);
2546 dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
2551 if (*p == 'T' || *p == 't' || *p == ' ')
2554 for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
2555 q = small_strptime(p, time_fmt[i], &dt);
2565 q = small_strptime(p, time_fmt[0], &dt);
2567 dt.tm_sec = strtol(p, (char **)&q, 10);
2573 /* Now we have all the fields that we can get */
2578 return now * INT64_C(1000000);
2582 t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2584 dt.tm_isdst = -1; /* unknown */
2597 for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
2600 val += n * (*q - '0');
2604 return negative ? -t : t;
2607 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
2617 while (*p != '\0' && *p != '=' && *p != '&') {
2618 if ((q - tag) < sizeof(tag) - 1)
2626 while (*p != '&' && *p != '\0') {
2627 if ((q - arg) < arg_size - 1) {
2637 if (!strcmp(tag, tag1))
2646 int av_get_frame_filename(char *buf, int buf_size,
2647 const char *path, int number)
2650 char *q, buf1[20], c;
2651 int nd, len, percentd_found;
2663 while (isdigit(*p)) {
2664 nd = nd * 10 + *p++ - '0';
2667 } while (isdigit(c));
2676 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
2678 if ((q - buf + len) > buf_size - 1)
2680 memcpy(q, buf1, len);
2688 if ((q - buf) < buf_size - 1)
2692 if (!percentd_found)
2701 static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
2704 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
2706 for(i=0;i<size;i+=16) {
2713 PRINT(" %02x", buf[i+j]);
2718 for(j=0;j<len;j++) {
2720 if (c < ' ' || c > '~')
2729 void av_hex_dump(FILE *f, uint8_t *buf, int size)
2731 hex_dump_internal(NULL, f, 0, buf, size);
2734 void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
2736 hex_dump_internal(avcl, NULL, level, buf, size);
2739 //FIXME needs to know the time_base
2740 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload)
2742 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
2743 PRINT("stream #%d:\n", pkt->stream_index);
2744 PRINT(" keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
2745 PRINT(" duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
2746 /* DTS is _always_ valid after av_read_frame() */
2748 if (pkt->dts == AV_NOPTS_VALUE)
2751 PRINT("%0.3f", (double)pkt->dts / AV_TIME_BASE);
2752 /* PTS may be not known if B frames are present */
2754 if (pkt->pts == AV_NOPTS_VALUE)
2757 PRINT("%0.3f", (double)pkt->pts / AV_TIME_BASE);
2759 PRINT(" size=%d\n", pkt->size);
2762 av_hex_dump(f, pkt->data, pkt->size);
2765 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
2767 pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
2770 void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
2772 pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
2775 void url_split(char *proto, int proto_size,
2776 char *authorization, int authorization_size,
2777 char *hostname, int hostname_size,
2779 char *path, int path_size,
2790 while (*p != ':' && *p != '\0') {
2791 if ((q - proto) < proto_size - 1)
2797 if (authorization_size > 0)
2798 authorization[0] = '\0';
2802 if (hostname_size > 0)
2806 char *at,*slash; // PETR: position of '@' character and '/' character
2813 at = strchr(p,'@'); // PETR: get the position of '@'
2814 slash = strchr(p,'/'); // PETR: get position of '/' - end of hostname
2815 if (at && slash && at > slash) at = NULL; // PETR: not interested in '@' behind '/'
2817 q = at ? authorization : hostname; // PETR: if '@' exists starting with auth.
2819 while ((at || *p != ':') && *p != '/' && *p != '?' && *p != '\0') { // PETR:
2820 if (*p == '@') { // PETR: passed '@'
2821 if (authorization_size > 0)
2825 } else if (!at) { // PETR: hostname
2826 if ((q - hostname) < hostname_size - 1)
2829 if ((q - authorization) < authorization_size - 1)
2834 if (hostname_size > 0)
2838 port = strtoul(p, (char **)&p, 10);
2843 pstrcpy(path, path_size, p);
2846 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
2847 int pts_num, int pts_den)
2849 s->pts_wrap_bits = pts_wrap_bits;
2850 s->time_base.num = pts_num;
2851 s->time_base.den = pts_den;
2854 /* fraction handling */
2857 * f = val + (num / den) + 0.5.
2859 * 'num' is normalized so that it is such as 0 <= num < den.
2861 * @param f fractional number
2862 * @param val integer value
2863 * @param num must be >= 0
2864 * @param den must be >= 1
2866 static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
2879 * Fractionnal addition to f: f = f + (incr / f->den).
2881 * @param f fractional number
2882 * @param incr increment, can be positive or negative
2884 static void av_frac_add(AVFrac *f, int64_t incr)
2888 num = f->num + incr;
2891 f->val += num / den;
2897 } else if (num >= den) {
2898 f->val += num / den;