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 int av_new_packet(AVPacket *pkt, int size)
182 if((unsigned)size > (unsigned)size + FF_INPUT_BUFFER_PADDING_SIZE)
183 return AVERROR_NOMEM;
184 data = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
186 return AVERROR_NOMEM;
187 memset(data + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
192 pkt->destruct = av_destruct_packet;
196 int av_get_packet(ByteIOContext *s, AVPacket *pkt, int size)
198 int ret= av_new_packet(pkt, size);
203 pkt->pos= url_ftell(s);
205 ret= get_buffer(s, pkt->data, size);
214 int av_dup_packet(AVPacket *pkt)
216 if (pkt->destruct != av_destruct_packet) {
218 /* we duplicate the packet and don't forget to put the padding
220 if((unsigned)pkt->size > (unsigned)pkt->size + FF_INPUT_BUFFER_PADDING_SIZE)
221 return AVERROR_NOMEM;
222 data = av_malloc(pkt->size + FF_INPUT_BUFFER_PADDING_SIZE);
224 return AVERROR_NOMEM;
226 memcpy(data, pkt->data, pkt->size);
227 memset(data + pkt->size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
229 pkt->destruct = av_destruct_packet;
234 int av_filename_number_test(const char *filename)
237 return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
240 AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened)
242 AVInputFormat *fmt1, *fmt;
243 int score, score_max;
247 for(fmt1 = first_iformat; fmt1 != NULL; fmt1 = fmt1->next) {
248 if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
251 if (fmt1->read_probe) {
252 score = fmt1->read_probe(pd);
253 } else if (fmt1->extensions) {
254 if (match_ext(pd->filename, fmt1->extensions)) {
258 if (score > score_max) {
266 /************************************************************/
267 /* input media file */
270 * Open a media file from an IO stream. 'fmt' must be specified.
272 static const char* format_to_name(void* ptr)
274 AVFormatContext* fc = (AVFormatContext*) ptr;
275 if(fc->iformat) return fc->iformat->name;
276 else if(fc->oformat) return fc->oformat->name;
280 #define OFFSET(x) offsetof(AVFormatContext,x)
281 #define DEFAULT 0 //should be NAN but it doesnt work as its not a constant in glibc as required by ANSI/ISO C
282 //these names are too long to be readable
283 #define E AV_OPT_FLAG_ENCODING_PARAM
284 #define D AV_OPT_FLAG_DECODING_PARAM
286 static const AVOption options[]={
287 {"probesize", NULL, OFFSET(probesize), FF_OPT_TYPE_INT, 32000, 32, INT_MAX, D}, /* 32000 from mpegts.c: 1.0 second at 24Mbit/s */
288 {"muxrate", "set mux rate", OFFSET(mux_rate), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
289 {"packetsize", "set packet size", OFFSET(packet_size), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
290 {"fflags", NULL, OFFSET(flags), FF_OPT_TYPE_FLAGS, DEFAULT, INT_MIN, INT_MAX, D|E, "fflags"},
291 {"ignidx", "ignore index", 0, FF_OPT_TYPE_CONST, AVFMT_FLAG_IGNIDX, INT_MIN, INT_MAX, D, "fflags"},
292 {"genpts", "generate pts", 0, FF_OPT_TYPE_CONST, AVFMT_FLAG_GENPTS, INT_MIN, INT_MAX, D, "fflags"},
293 {"track", " set the track number", OFFSET(track), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
294 {"year", "set the year", OFFSET(year), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, E},
295 {"analyzeduration", NULL, OFFSET(max_analyze_duration), FF_OPT_TYPE_INT, 3*AV_TIME_BASE, 0, INT_MAX, D},
303 static const AVClass av_format_context_class = { "AVFormatContext", format_to_name, options };
305 static void avformat_get_context_defaults(AVFormatContext *s)
307 memset(s, 0, sizeof(AVFormatContext));
309 s->av_class = &av_format_context_class;
311 av_opt_set_defaults(s);
314 AVFormatContext *av_alloc_format_context(void)
317 ic = av_malloc(sizeof(AVFormatContext));
319 avformat_get_context_defaults(ic);
320 ic->av_class = &av_format_context_class;
324 int av_open_input_stream(AVFormatContext **ic_ptr,
325 ByteIOContext *pb, const char *filename,
326 AVInputFormat *fmt, AVFormatParameters *ap)
330 AVFormatParameters default_ap;
334 memset(ap, 0, sizeof(default_ap));
337 if(!ap->prealloced_context)
338 ic = av_alloc_format_context();
348 ic->duration = AV_NOPTS_VALUE;
349 ic->start_time = AV_NOPTS_VALUE;
350 pstrcpy(ic->filename, sizeof(ic->filename), filename);
352 /* allocate private data */
353 if (fmt->priv_data_size > 0) {
354 ic->priv_data = av_mallocz(fmt->priv_data_size);
355 if (!ic->priv_data) {
360 ic->priv_data = NULL;
363 err = ic->iformat->read_header(ic, ap);
367 if (pb && !ic->data_offset)
368 ic->data_offset = url_ftell(&ic->pb);
374 av_freep(&ic->priv_data);
381 /** Size of probe buffer, for guessing file type from file contents. */
382 #define PROBE_BUF_MIN 2048
383 #define PROBE_BUF_MAX (1<<20)
385 int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
388 AVFormatParameters *ap)
390 int err, must_open_file, file_opened, probe_size;
391 AVProbeData probe_data, *pd = &probe_data;
392 ByteIOContext pb1, *pb = &pb1;
397 pd->filename = filename;
402 /* guess format if no file can be opened */
403 fmt = av_probe_input_format(pd, 0);
406 /* do not open file if the format does not need it. XXX: specific
407 hack needed to handle RTSP/TCP */
409 if (fmt && (fmt->flags & AVFMT_NOFILE)) {
411 pb= NULL; //FIXME this or memset(pb, 0, sizeof(ByteIOContext)); otherwise its uninitalized
414 if (!fmt || must_open_file) {
415 /* if no file needed do not try to open one */
416 if (url_fopen(pb, filename, URL_RDONLY) < 0) {
422 url_setbufsize(pb, buf_size);
425 for(probe_size= PROBE_BUF_MIN; probe_size<=PROBE_BUF_MAX && !fmt; probe_size<<=1){
426 /* read probe data */
427 pd->buf= av_realloc(pd->buf, probe_size);
428 pd->buf_size = get_buffer(pb, pd->buf, probe_size);
429 if (url_fseek(pb, 0, SEEK_SET) < 0) {
431 if (url_fopen(pb, filename, URL_RDONLY) < 0) {
437 /* guess file format */
438 fmt = av_probe_input_format(pd, 1);
443 /* if still no format found, error */
449 /* XXX: suppress this hack for redirectors */
450 #ifdef CONFIG_NETWORK
451 if (fmt == &redir_demuxer) {
452 err = redir_open(ic_ptr, pb);
458 /* check filename in case of an image number is expected */
459 if (fmt->flags & AVFMT_NEEDNUMBER) {
460 if (!av_filename_number_test(filename)) {
461 err = AVERROR_NUMEXPECTED;
465 err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
478 /*******************************************************/
480 int av_read_packet(AVFormatContext *s, AVPacket *pkt)
482 return s->iformat->read_packet(s, pkt);
485 /**********************************************************/
488 * Get the number of samples of an audio frame. Return (-1) if error.
490 static int get_audio_frame_size(AVCodecContext *enc, int size)
494 if (enc->frame_size <= 1) {
495 int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
497 if (bits_per_sample) {
498 if (enc->channels == 0)
500 frame_size = (size << 3) / (bits_per_sample * enc->channels);
502 /* used for example by ADPCM codecs */
503 if (enc->bit_rate == 0)
505 frame_size = (size * 8 * enc->sample_rate) / enc->bit_rate;
508 frame_size = enc->frame_size;
515 * Return the frame duration in seconds, return 0 if not available.
517 static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
518 AVCodecParserContext *pc, AVPacket *pkt)
524 switch(st->codec->codec_type) {
525 case CODEC_TYPE_VIDEO:
526 if(st->time_base.num*1000LL > st->time_base.den){
527 *pnum = st->time_base.num;
528 *pden = st->time_base.den;
529 }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
530 *pnum = st->codec->time_base.num;
531 *pden = st->codec->time_base.den;
532 if (pc && pc->repeat_pict) {
534 *pnum = (*pnum) * (2 + pc->repeat_pict);
538 case CODEC_TYPE_AUDIO:
539 frame_size = get_audio_frame_size(st->codec, pkt->size);
543 *pden = st->codec->sample_rate;
550 static int is_intra_only(AVCodecContext *enc){
551 if(enc->codec_type == CODEC_TYPE_AUDIO){
553 }else if(enc->codec_type == CODEC_TYPE_VIDEO){
554 switch(enc->codec_id){
556 case CODEC_ID_MJPEGB:
558 case CODEC_ID_RAWVIDEO:
559 case CODEC_ID_DVVIDEO:
560 case CODEC_ID_HUFFYUV:
561 case CODEC_ID_FFVHUFF:
572 static int64_t lsb2full(int64_t lsb, int64_t last_ts, int lsb_bits){
573 int64_t mask = lsb_bits < 64 ? (1LL<<lsb_bits)-1 : -1LL;
574 int64_t delta= last_ts - mask/2;
575 return ((lsb - delta)&mask) + delta;
578 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
579 AVCodecParserContext *pc, AVPacket *pkt)
581 int num, den, presentation_delayed, delay, i;
582 /* handle wrapping */
583 if(st->cur_dts != AV_NOPTS_VALUE){
584 if(pkt->pts != AV_NOPTS_VALUE)
585 pkt->pts= lsb2full(pkt->pts, st->cur_dts, st->pts_wrap_bits);
586 if(pkt->dts != AV_NOPTS_VALUE)
587 pkt->dts= lsb2full(pkt->dts, st->cur_dts, st->pts_wrap_bits);
590 if (pkt->duration == 0) {
591 compute_frame_duration(&num, &den, st, pc, pkt);
593 pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
597 if(is_intra_only(st->codec))
598 pkt->flags |= PKT_FLAG_KEY;
600 /* do we have a video B frame ? */
601 delay= st->codec->has_b_frames;
602 presentation_delayed = 0;
603 /* XXX: need has_b_frame, but cannot get it if the codec is
606 pc && pc->pict_type != FF_B_TYPE)
607 presentation_delayed = 1;
608 /* this may be redundant, but it shouldnt hurt */
609 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
610 presentation_delayed = 1;
612 if(st->cur_dts == AV_NOPTS_VALUE){
613 st->cur_dts = -delay * pkt->duration;
616 // 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);
617 /* interpolate PTS and DTS if they are not present */
619 if (presentation_delayed) {
620 /* DTS = decompression time stamp */
621 /* PTS = presentation time stamp */
622 if (pkt->dts == AV_NOPTS_VALUE)
623 pkt->dts = st->last_IP_pts;
624 if (pkt->dts == AV_NOPTS_VALUE)
625 pkt->dts = st->cur_dts;
627 /* this is tricky: the dts must be incremented by the duration
628 of the frame we are displaying, i.e. the last I or P frame */
629 if (st->last_IP_duration == 0)
630 st->last_IP_duration = pkt->duration;
631 st->cur_dts = pkt->dts + st->last_IP_duration;
632 st->last_IP_duration = pkt->duration;
633 st->last_IP_pts= pkt->pts;
634 /* cannot compute PTS if not present (we can compute it only
635 by knowing the futur */
637 if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
638 int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
639 int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
640 if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
641 pkt->pts += pkt->duration;
642 // 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);
646 /* presentation is not delayed : PTS and DTS are the same */
647 if(pkt->pts == AV_NOPTS_VALUE)
649 if(pkt->pts == AV_NOPTS_VALUE)
650 pkt->pts = st->cur_dts;
652 st->cur_dts = pkt->pts + pkt->duration;
656 if(pkt->pts != AV_NOPTS_VALUE){
657 st->pts_buffer[0]= pkt->pts;
658 for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
659 st->pts_buffer[i]= (i-delay-1) * pkt->duration;
660 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
661 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
662 if(pkt->dts == AV_NOPTS_VALUE)
663 pkt->dts= st->pts_buffer[0];
664 if(pkt->dts > st->cur_dts)
665 st->cur_dts = pkt->dts;
668 // 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);
673 /* key frame computation */
674 switch(st->codec->codec_type) {
675 case CODEC_TYPE_VIDEO:
676 if (pc->pict_type == FF_I_TYPE)
677 pkt->flags |= PKT_FLAG_KEY;
679 case CODEC_TYPE_AUDIO:
680 pkt->flags |= PKT_FLAG_KEY;
688 void av_destruct_packet_nofree(AVPacket *pkt)
690 pkt->data = NULL; pkt->size = 0;
693 static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
699 /* select current input stream component */
702 if (!st->need_parsing || !st->parser) {
703 /* no parsing needed: we just output the packet as is */
704 /* raw data support */
706 compute_pkt_fields(s, st, NULL, pkt);
709 } else if (s->cur_len > 0 && st->discard < AVDISCARD_ALL) {
710 len = av_parser_parse(st->parser, st->codec, &pkt->data, &pkt->size,
711 s->cur_ptr, s->cur_len,
712 s->cur_pkt.pts, s->cur_pkt.dts);
713 s->cur_pkt.pts = AV_NOPTS_VALUE;
714 s->cur_pkt.dts = AV_NOPTS_VALUE;
715 /* increment read pointer */
719 /* return packet if any */
723 pkt->stream_index = st->index;
724 pkt->pts = st->parser->pts;
725 pkt->dts = st->parser->dts;
726 pkt->destruct = av_destruct_packet_nofree;
727 compute_pkt_fields(s, st, st->parser, pkt);
729 if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & PKT_FLAG_KEY){
730 av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
731 0, 0, AVINDEX_KEYFRAME);
738 av_free_packet(&s->cur_pkt);
742 /* read next packet */
743 ret = av_read_packet(s, &s->cur_pkt);
745 if (ret == AVERROR(EAGAIN))
747 /* return the last frames, if any */
748 for(i = 0; i < s->nb_streams; i++) {
750 if (st->parser && st->need_parsing) {
751 av_parser_parse(st->parser, st->codec,
752 &pkt->data, &pkt->size,
754 AV_NOPTS_VALUE, AV_NOPTS_VALUE);
759 /* no more packets: really terminates parsing */
763 st = s->streams[s->cur_pkt.stream_index];
764 if(st->codec->debug & FF_DEBUG_PTS)
765 av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
766 s->cur_pkt.stream_index,
772 s->cur_ptr = s->cur_pkt.data;
773 s->cur_len = s->cur_pkt.size;
774 if (st->need_parsing && !st->parser) {
775 st->parser = av_parser_init(st->codec->codec_id);
777 /* no parser available : just output the raw packets */
778 st->need_parsing = 0;
779 }else if(st->need_parsing == 2){
780 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
782 if(st->parser && (s->iformat->flags & AVFMT_GENERIC_INDEX)){
783 st->parser->last_frame_offset=
784 st->parser->cur_offset= s->cur_pkt.pos;
789 if(st->codec->debug & FF_DEBUG_PTS)
790 av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
799 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
803 const int genpts= s->flags & AVFMT_FLAG_GENPTS;
806 pktl = s->packet_buffer;
808 AVPacket *next_pkt= &pktl->pkt;
810 if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
811 while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
812 if( pktl->pkt.stream_index == next_pkt->stream_index
813 && next_pkt->dts < pktl->pkt.dts
814 && pktl->pkt.pts != pktl->pkt.dts //not b frame
815 /*&& pktl->pkt.dts != AV_NOPTS_VALUE*/){
816 next_pkt->pts= pktl->pkt.dts;
820 pktl = s->packet_buffer;
823 if( next_pkt->pts != AV_NOPTS_VALUE
824 || next_pkt->dts == AV_NOPTS_VALUE
826 /* read packet from packet buffer, if there is data */
828 s->packet_buffer = pktl->next;
834 AVPacketList **plast_pktl= &s->packet_buffer;
835 int ret= av_read_frame_internal(s, pkt);
837 if(pktl && ret != AVERROR(EAGAIN)){
844 /* duplicate the packet */
845 if (av_dup_packet(pkt) < 0)
846 return AVERROR_NOMEM;
848 while(*plast_pktl) plast_pktl= &(*plast_pktl)->next; //FIXME maybe maintain pointer to the last?
850 pktl = av_mallocz(sizeof(AVPacketList));
852 return AVERROR_NOMEM;
854 /* add the packet in the buffered packet list */
858 assert(!s->packet_buffer);
859 return av_read_frame_internal(s, pkt);
864 /* XXX: suppress the packet queue */
865 static void flush_packet_queue(AVFormatContext *s)
870 pktl = s->packet_buffer;
873 s->packet_buffer = pktl->next;
874 av_free_packet(&pktl->pkt);
879 /*******************************************************/
882 int av_find_default_stream_index(AVFormatContext *s)
887 if (s->nb_streams <= 0)
889 for(i = 0; i < s->nb_streams; i++) {
891 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
899 * Flush the frame reader.
901 static void av_read_frame_flush(AVFormatContext *s)
906 flush_packet_queue(s);
908 /* free previous packet */
910 if (s->cur_st->parser)
911 av_free_packet(&s->cur_pkt);
918 /* for each stream, reset read state */
919 for(i = 0; i < s->nb_streams; i++) {
923 av_parser_close(st->parser);
926 st->last_IP_pts = AV_NOPTS_VALUE;
927 st->cur_dts = 0; /* we set the current DTS to an unspecified origin */
931 void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
934 for(i = 0; i < s->nb_streams; i++) {
935 AVStream *st = s->streams[i];
937 st->cur_dts = av_rescale(timestamp,
938 st->time_base.den * (int64_t)ref_st->time_base.num,
939 st->time_base.num * (int64_t)ref_st->time_base.den);
943 int av_add_index_entry(AVStream *st,
944 int64_t pos, int64_t timestamp, int size, int distance, int flags)
946 AVIndexEntry *entries, *ie;
949 if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
952 entries = av_fast_realloc(st->index_entries,
953 &st->index_entries_allocated_size,
954 (st->nb_index_entries + 1) *
955 sizeof(AVIndexEntry));
959 st->index_entries= entries;
961 index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
964 index= st->nb_index_entries++;
966 assert(index==0 || ie[-1].timestamp < timestamp);
969 if(ie->timestamp != timestamp){
970 if(ie->timestamp <= timestamp)
972 memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
973 st->nb_index_entries++;
974 }else if(ie->pos == pos && distance < ie->min_distance) //dont reduce the distance
975 distance= ie->min_distance;
979 ie->timestamp = timestamp;
980 ie->min_distance= distance;
988 * build an index for raw streams using a parser.
990 static void av_build_index_raw(AVFormatContext *s)
992 AVPacket pkt1, *pkt = &pkt1;
997 av_read_frame_flush(s);
998 url_fseek(&s->pb, s->data_offset, SEEK_SET);
1001 ret = av_read_frame(s, pkt);
1004 if (pkt->stream_index == 0 && st->parser &&
1005 (pkt->flags & PKT_FLAG_KEY)) {
1006 av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
1007 0, 0, AVINDEX_KEYFRAME);
1009 av_free_packet(pkt);
1014 * Returns TRUE if we deal with a raw stream.
1016 * Raw codec data and parsing needed.
1018 static int is_raw_stream(AVFormatContext *s)
1022 if (s->nb_streams != 1)
1025 if (!st->need_parsing)
1030 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1033 AVIndexEntry *entries= st->index_entries;
1034 int nb_entries= st->nb_index_entries;
1043 timestamp = entries[m].timestamp;
1044 if(timestamp >= wanted_timestamp)
1046 if(timestamp <= wanted_timestamp)
1049 m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1051 if(!(flags & AVSEEK_FLAG_ANY)){
1052 while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1053 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1064 int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1065 AVInputFormat *avif= s->iformat;
1066 int64_t pos_min, pos_max, pos, pos_limit;
1067 int64_t ts_min, ts_max, ts;
1071 if (stream_index < 0)
1075 av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1079 ts_min= AV_NOPTS_VALUE;
1080 pos_limit= -1; //gcc falsely says it may be uninitalized
1082 st= s->streams[stream_index];
1083 if(st->index_entries){
1086 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()
1087 index= FFMAX(index, 0);
1088 e= &st->index_entries[index];
1090 if(e->timestamp <= target_ts || e->pos == e->min_distance){
1092 ts_min= e->timestamp;
1094 av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1101 index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1102 assert(index < st->nb_index_entries);
1104 e= &st->index_entries[index];
1105 assert(e->timestamp >= target_ts);
1107 ts_max= e->timestamp;
1108 pos_limit= pos_max - e->min_distance;
1110 av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1111 pos_max,pos_limit, ts_max);
1116 pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1121 url_fseek(&s->pb, pos, SEEK_SET);
1123 av_update_cur_dts(s, st, ts);
1128 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 )){
1130 int64_t start_pos, filesize;
1134 av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1137 if(ts_min == AV_NOPTS_VALUE){
1138 pos_min = s->data_offset;
1139 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1140 if (ts_min == AV_NOPTS_VALUE)
1144 if(ts_max == AV_NOPTS_VALUE){
1146 filesize = url_fsize(&s->pb);
1147 pos_max = filesize - 1;
1150 ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1152 }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1153 if (ts_max == AV_NOPTS_VALUE)
1157 int64_t tmp_pos= pos_max + 1;
1158 int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1159 if(tmp_ts == AV_NOPTS_VALUE)
1163 if(tmp_pos >= filesize)
1169 if(ts_min > ts_max){
1171 }else if(ts_min == ts_max){
1176 while (pos_min < pos_limit) {
1178 av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1182 assert(pos_limit <= pos_max);
1185 int64_t approximate_keyframe_distance= pos_max - pos_limit;
1186 // interpolate position (better than dichotomy)
1187 pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1188 + pos_min - approximate_keyframe_distance;
1189 }else if(no_change==1){
1190 // bisection, if interpolation failed to change min or max pos last time
1191 pos = (pos_min + pos_limit)>>1;
1193 // linear search if bisection failed, can only happen if there are very few or no keframes between min/max
1198 else if(pos > pos_limit)
1202 ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1208 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);
1210 assert(ts != AV_NOPTS_VALUE);
1211 if (target_ts <= ts) {
1212 pos_limit = start_pos - 1;
1216 if (target_ts >= ts) {
1222 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1223 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
1226 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1228 ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1229 av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1230 pos, ts_min, target_ts, ts_max);
1236 static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1237 int64_t pos_min, pos_max;
1241 if (stream_index < 0)
1244 st= s->streams[stream_index];
1247 pos_min = s->data_offset;
1248 pos_max = url_fsize(&s->pb) - 1;
1250 if (pos < pos_min) pos= pos_min;
1251 else if(pos > pos_max) pos= pos_max;
1253 url_fseek(&s->pb, pos, SEEK_SET);
1256 av_update_cur_dts(s, st, ts);
1261 static int av_seek_frame_generic(AVFormatContext *s,
1262 int stream_index, int64_t timestamp, int flags)
1268 st = s->streams[stream_index];
1270 index = av_index_search_timestamp(st, timestamp, flags);
1276 if(st->index_entries && st->nb_index_entries){
1277 ie= &st->index_entries[st->nb_index_entries-1];
1278 url_fseek(&s->pb, ie->pos, SEEK_SET);
1279 av_update_cur_dts(s, st, ie->timestamp);
1281 url_fseek(&s->pb, 0, SEEK_SET);
1284 int ret = av_read_frame(s, &pkt);
1287 av_free_packet(&pkt);
1288 if(stream_index == pkt.stream_index){
1289 if((pkt.flags & PKT_FLAG_KEY) && pkt.dts > timestamp)
1293 index = av_index_search_timestamp(st, timestamp, flags);
1298 av_read_frame_flush(s);
1299 if (s->iformat->read_seek){
1300 if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1303 ie = &st->index_entries[index];
1304 url_fseek(&s->pb, ie->pos, SEEK_SET);
1306 av_update_cur_dts(s, st, ie->timestamp);
1311 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1316 av_read_frame_flush(s);
1318 if(flags & AVSEEK_FLAG_BYTE)
1319 return av_seek_frame_byte(s, stream_index, timestamp, flags);
1321 if(stream_index < 0){
1322 stream_index= av_find_default_stream_index(s);
1323 if(stream_index < 0)
1326 st= s->streams[stream_index];
1327 /* timestamp for default must be expressed in AV_TIME_BASE units */
1328 timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1330 st= s->streams[stream_index];
1332 /* first, we try the format specific seek */
1333 if (s->iformat->read_seek)
1334 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1341 if(s->iformat->read_timestamp)
1342 return av_seek_frame_binary(s, stream_index, timestamp, flags);
1344 return av_seek_frame_generic(s, stream_index, timestamp, flags);
1347 /*******************************************************/
1350 * Returns TRUE if the stream has accurate timings in any stream.
1352 * @return TRUE if the stream has accurate timings for at least one component.
1354 static int av_has_timings(AVFormatContext *ic)
1359 for(i = 0;i < ic->nb_streams; i++) {
1360 st = ic->streams[i];
1361 if (st->start_time != AV_NOPTS_VALUE &&
1362 st->duration != AV_NOPTS_VALUE)
1369 * Estimate the stream timings from the one of each components.
1371 * Also computes the global bitrate if possible.
1373 static void av_update_stream_timings(AVFormatContext *ic)
1375 int64_t start_time, start_time1, end_time, end_time1;
1379 start_time = INT64_MAX;
1380 end_time = INT64_MIN;
1381 for(i = 0;i < ic->nb_streams; i++) {
1382 st = ic->streams[i];
1383 if (st->start_time != AV_NOPTS_VALUE) {
1384 start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1385 if (start_time1 < start_time)
1386 start_time = start_time1;
1387 if (st->duration != AV_NOPTS_VALUE) {
1388 end_time1 = start_time1
1389 + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1390 if (end_time1 > end_time)
1391 end_time = end_time1;
1395 if (start_time != INT64_MAX) {
1396 ic->start_time = start_time;
1397 if (end_time != INT64_MIN) {
1398 ic->duration = end_time - start_time;
1399 if (ic->file_size > 0) {
1400 /* compute the bit rate */
1401 ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1402 (double)ic->duration;
1409 static void fill_all_stream_timings(AVFormatContext *ic)
1414 av_update_stream_timings(ic);
1415 for(i = 0;i < ic->nb_streams; i++) {
1416 st = ic->streams[i];
1417 if (st->start_time == AV_NOPTS_VALUE) {
1418 if(ic->start_time != AV_NOPTS_VALUE)
1419 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1420 if(ic->duration != AV_NOPTS_VALUE)
1421 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1426 static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1428 int64_t filesize, duration;
1432 /* if bit_rate is already set, we believe it */
1433 if (ic->bit_rate == 0) {
1435 for(i=0;i<ic->nb_streams;i++) {
1436 st = ic->streams[i];
1437 bit_rate += st->codec->bit_rate;
1439 ic->bit_rate = bit_rate;
1442 /* if duration is already set, we believe it */
1443 if (ic->duration == AV_NOPTS_VALUE &&
1444 ic->bit_rate != 0 &&
1445 ic->file_size != 0) {
1446 filesize = ic->file_size;
1448 for(i = 0; i < ic->nb_streams; i++) {
1449 st = ic->streams[i];
1450 duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1451 if (st->start_time == AV_NOPTS_VALUE ||
1452 st->duration == AV_NOPTS_VALUE) {
1454 st->duration = duration;
1461 #define DURATION_MAX_READ_SIZE 250000
1463 /* only usable for MPEG-PS streams */
1464 static void av_estimate_timings_from_pts(AVFormatContext *ic, offset_t old_offset)
1466 AVPacket pkt1, *pkt = &pkt1;
1468 int read_size, i, ret;
1470 int64_t filesize, offset, duration;
1472 /* free previous packet */
1473 if (ic->cur_st && ic->cur_st->parser)
1474 av_free_packet(&ic->cur_pkt);
1477 /* flush packet queue */
1478 flush_packet_queue(ic);
1480 for(i=0;i<ic->nb_streams;i++) {
1481 st = ic->streams[i];
1483 av_parser_close(st->parser);
1488 /* we read the first packets to get the first PTS (not fully
1489 accurate, but it is enough now) */
1490 url_fseek(&ic->pb, 0, SEEK_SET);
1493 if (read_size >= DURATION_MAX_READ_SIZE)
1495 /* if all info is available, we can stop */
1496 for(i = 0;i < ic->nb_streams; i++) {
1497 st = ic->streams[i];
1498 if (st->start_time == AV_NOPTS_VALUE)
1501 if (i == ic->nb_streams)
1504 ret = av_read_packet(ic, pkt);
1507 read_size += pkt->size;
1508 st = ic->streams[pkt->stream_index];
1509 if (pkt->pts != AV_NOPTS_VALUE) {
1510 if (st->start_time == AV_NOPTS_VALUE)
1511 st->start_time = pkt->pts;
1513 av_free_packet(pkt);
1516 /* estimate the end time (duration) */
1517 /* XXX: may need to support wrapping */
1518 filesize = ic->file_size;
1519 offset = filesize - DURATION_MAX_READ_SIZE;
1523 url_fseek(&ic->pb, offset, SEEK_SET);
1526 if (read_size >= DURATION_MAX_READ_SIZE)
1528 /* if all info is available, we can stop */
1529 for(i = 0;i < ic->nb_streams; i++) {
1530 st = ic->streams[i];
1531 if (st->duration == AV_NOPTS_VALUE)
1534 if (i == ic->nb_streams)
1537 ret = av_read_packet(ic, pkt);
1540 read_size += pkt->size;
1541 st = ic->streams[pkt->stream_index];
1542 if (pkt->pts != AV_NOPTS_VALUE) {
1543 end_time = pkt->pts;
1544 duration = end_time - st->start_time;
1546 if (st->duration == AV_NOPTS_VALUE ||
1547 st->duration < duration)
1548 st->duration = duration;
1551 av_free_packet(pkt);
1554 fill_all_stream_timings(ic);
1556 url_fseek(&ic->pb, old_offset, SEEK_SET);
1559 static void av_estimate_timings(AVFormatContext *ic, offset_t old_offset)
1563 /* get the file size, if possible */
1564 if (ic->iformat->flags & AVFMT_NOFILE) {
1567 file_size = url_fsize(&ic->pb);
1571 ic->file_size = file_size;
1573 if ((!strcmp(ic->iformat->name, "mpeg") ||
1574 !strcmp(ic->iformat->name, "mpegts")) &&
1575 file_size && !ic->pb.is_streamed) {
1576 /* get accurate estimate from the PTSes */
1577 av_estimate_timings_from_pts(ic, old_offset);
1578 } else if (av_has_timings(ic)) {
1579 /* at least one components has timings - we use them for all
1581 fill_all_stream_timings(ic);
1583 /* less precise: use bit rate info */
1584 av_estimate_timings_from_bit_rate(ic);
1586 av_update_stream_timings(ic);
1592 for(i = 0;i < ic->nb_streams; i++) {
1593 st = ic->streams[i];
1594 printf("%d: start_time: %0.3f duration: %0.3f\n",
1595 i, (double)st->start_time / AV_TIME_BASE,
1596 (double)st->duration / AV_TIME_BASE);
1598 printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1599 (double)ic->start_time / AV_TIME_BASE,
1600 (double)ic->duration / AV_TIME_BASE,
1601 ic->bit_rate / 1000);
1606 static int has_codec_parameters(AVCodecContext *enc)
1609 switch(enc->codec_type) {
1610 case CODEC_TYPE_AUDIO:
1611 val = enc->sample_rate;
1613 case CODEC_TYPE_VIDEO:
1614 val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
1623 static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1627 int got_picture, data_size, ret=0;
1630 if(!st->codec->codec){
1631 codec = avcodec_find_decoder(st->codec->codec_id);
1634 ret = avcodec_open(st->codec, codec);
1639 if(!has_codec_parameters(st->codec)){
1640 switch(st->codec->codec_type) {
1641 case CODEC_TYPE_VIDEO:
1642 ret = avcodec_decode_video(st->codec, &picture,
1643 &got_picture, (uint8_t *)data, size);
1645 case CODEC_TYPE_AUDIO:
1646 data_size = FFMAX(size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
1647 samples = av_malloc(data_size);
1650 ret = avcodec_decode_audio2(st->codec, samples,
1651 &data_size, (uint8_t *)data, size);
1662 /* absolute maximum size we read until we abort */
1663 #define MAX_READ_SIZE 5000000
1665 #define MAX_STD_TIMEBASES (60*12+5)
1666 static int get_std_framerate(int i){
1667 if(i<60*12) return i*1001;
1668 else return ((int[]){24,30,60,12,15})[i-60*12]*1000*12;
1671 int av_find_stream_info(AVFormatContext *ic)
1673 int i, count, ret, read_size, j;
1675 AVPacket pkt1, *pkt;
1676 AVPacketList *pktl=NULL, **ppktl;
1677 int64_t last_dts[MAX_STREAMS];
1678 int duration_count[MAX_STREAMS]={0};
1679 double (*duration_error)[MAX_STD_TIMEBASES];
1680 offset_t old_offset = url_ftell(&ic->pb);
1681 int64_t codec_info_duration[MAX_STREAMS]={0};
1682 int codec_info_nb_frames[MAX_STREAMS]={0};
1684 duration_error = av_mallocz(MAX_STREAMS * sizeof(*duration_error));
1685 if (!duration_error) return AVERROR_NOMEM;
1687 for(i=0;i<ic->nb_streams;i++) {
1688 st = ic->streams[i];
1689 if(st->codec->codec_type == CODEC_TYPE_VIDEO){
1690 /* if(!st->time_base.num)
1692 if(!st->codec->time_base.num)
1693 st->codec->time_base= st->time_base;
1695 //only for the split stuff
1697 st->parser = av_parser_init(st->codec->codec_id);
1698 if(st->need_parsing == 2 && st->parser){
1699 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1704 for(i=0;i<MAX_STREAMS;i++){
1705 last_dts[i]= AV_NOPTS_VALUE;
1710 ppktl = &ic->packet_buffer;
1712 /* check if one codec still needs to be handled */
1713 for(i=0;i<ic->nb_streams;i++) {
1714 st = ic->streams[i];
1715 if (!has_codec_parameters(st->codec))
1717 /* variable fps and no guess at the real fps */
1718 if( st->codec->time_base.den >= 101LL*st->codec->time_base.num
1719 && duration_count[i]<20 && st->codec->codec_type == CODEC_TYPE_VIDEO)
1721 if(st->parser && st->parser->parser->split && !st->codec->extradata)
1724 if (i == ic->nb_streams) {
1725 /* NOTE: if the format has no header, then we need to read
1726 some packets to get most of the streams, so we cannot
1728 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
1729 /* if we found the info for all the codecs, we can stop */
1734 /* we did not get all the codec info, but we read too much data */
1735 if (read_size >= MAX_READ_SIZE) {
1740 /* NOTE: a new stream can be added there if no header in file
1741 (AVFMTCTX_NOHEADER) */
1742 ret = av_read_frame_internal(ic, &pkt1);
1745 ret = -1; /* we could not have all the codec parameters before EOF */
1746 for(i=0;i<ic->nb_streams;i++) {
1747 st = ic->streams[i];
1748 if (!has_codec_parameters(st->codec)){
1750 avcodec_string(buf, sizeof(buf), st->codec, 0);
1751 av_log(ic, AV_LOG_INFO, "Could not find codec parameters (%s)\n", buf);
1759 pktl = av_mallocz(sizeof(AVPacketList));
1761 ret = AVERROR_NOMEM;
1765 /* add the packet in the buffered packet list */
1767 ppktl = &pktl->next;
1772 /* duplicate the packet */
1773 if (av_dup_packet(pkt) < 0) {
1774 ret = AVERROR_NOMEM;
1778 read_size += pkt->size;
1780 st = ic->streams[pkt->stream_index];
1781 if(codec_info_nb_frames[st->index]>1)
1782 codec_info_duration[st->index] += pkt->duration;
1783 if (pkt->duration != 0)
1784 codec_info_nb_frames[st->index]++;
1787 int index= pkt->stream_index;
1788 int64_t last= last_dts[index];
1789 int64_t duration= pkt->dts - last;
1791 if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
1792 double dur= duration * av_q2d(st->time_base);
1794 // if(st->codec->codec_type == CODEC_TYPE_VIDEO)
1795 // av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
1796 if(duration_count[index] < 2)
1797 memset(duration_error, 0, MAX_STREAMS * sizeof(*duration_error));
1798 for(i=1; i<MAX_STD_TIMEBASES; i++){
1799 int framerate= get_std_framerate(i);
1800 int ticks= lrintf(dur*framerate/(1001*12));
1801 double error= dur - ticks*1001*12/(double)framerate;
1802 duration_error[index][i] += error*error;
1804 duration_count[index]++;
1806 if(last == AV_NOPTS_VALUE || duration_count[index]<=1)
1807 last_dts[pkt->stream_index]= pkt->dts;
1809 if(st->parser && st->parser->parser->split && !st->codec->extradata){
1810 int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
1812 st->codec->extradata_size= i;
1813 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
1814 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
1815 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
1819 /* if still no information, we try to open the codec and to
1820 decompress the frame. We try to avoid that in most cases as
1821 it takes longer and uses more memory. For MPEG4, we need to
1822 decompress for Quicktime. */
1823 if (!has_codec_parameters(st->codec) /*&&
1824 (st->codec->codec_id == CODEC_ID_FLV1 ||
1825 st->codec->codec_id == CODEC_ID_H264 ||
1826 st->codec->codec_id == CODEC_ID_H263 ||
1827 st->codec->codec_id == CODEC_ID_H261 ||
1828 st->codec->codec_id == CODEC_ID_VORBIS ||
1829 st->codec->codec_id == CODEC_ID_MJPEG ||
1830 st->codec->codec_id == CODEC_ID_PNG ||
1831 st->codec->codec_id == CODEC_ID_PAM ||
1832 st->codec->codec_id == CODEC_ID_PGM ||
1833 st->codec->codec_id == CODEC_ID_PGMYUV ||
1834 st->codec->codec_id == CODEC_ID_PBM ||
1835 st->codec->codec_id == CODEC_ID_PPM ||
1836 st->codec->codec_id == CODEC_ID_SHORTEN ||
1837 (st->codec->codec_id == CODEC_ID_MPEG4 && !st->need_parsing))*/)
1838 try_decode_frame(st, pkt->data, pkt->size);
1840 if (av_rescale_q(codec_info_duration[st->index], st->time_base, AV_TIME_BASE_Q) >= ic->max_analyze_duration) {
1846 // close codecs which where opened in try_decode_frame()
1847 for(i=0;i<ic->nb_streams;i++) {
1848 st = ic->streams[i];
1849 if(st->codec->codec)
1850 avcodec_close(st->codec);
1852 for(i=0;i<ic->nb_streams;i++) {
1853 st = ic->streams[i];
1854 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1855 if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_sample)
1856 st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
1858 if(duration_count[i]
1859 && (st->codec->time_base.num*101LL <= st->codec->time_base.den || st->codec->codec_id == CODEC_ID_MPEG2VIDEO) /*&&
1860 //FIXME we should not special case mpeg2, but this needs testing with non mpeg2 ...
1861 st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den*/){
1862 double best_error= 2*av_q2d(st->time_base);
1863 best_error= best_error*best_error*duration_count[i]*1000*12*30;
1865 for(j=1; j<MAX_STD_TIMEBASES; j++){
1866 double error= duration_error[i][j] * get_std_framerate(j);
1867 // if(st->codec->codec_type == CODEC_TYPE_VIDEO)
1868 // av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
1869 if(error < best_error){
1871 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, get_std_framerate(j), 12*1001, INT_MAX);
1876 if (!st->r_frame_rate.num){
1877 if( st->codec->time_base.den * (int64_t)st->time_base.num
1878 <= st->codec->time_base.num * (int64_t)st->time_base.den){
1879 st->r_frame_rate.num = st->codec->time_base.den;
1880 st->r_frame_rate.den = st->codec->time_base.num;
1882 st->r_frame_rate.num = st->time_base.den;
1883 st->r_frame_rate.den = st->time_base.num;
1886 }else if(st->codec->codec_type == CODEC_TYPE_AUDIO) {
1887 if(!st->codec->bits_per_sample)
1888 st->codec->bits_per_sample= av_get_bits_per_sample(st->codec->codec_id);
1892 av_estimate_timings(ic, old_offset);
1894 /* correct DTS for b frame streams with no timestamps */
1895 for(i=0;i<ic->nb_streams;i++) {
1896 st = ic->streams[i];
1897 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1899 ppktl = &ic->packet_buffer;
1901 if(ppkt1->stream_index != i)
1903 if(ppkt1->pkt->dts < 0)
1905 if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
1907 ppkt1->pkt->dts -= delta;
1912 st->cur_dts -= delta;
1918 av_free(duration_error);
1923 /*******************************************************/
1925 int av_read_play(AVFormatContext *s)
1927 if (!s->iformat->read_play)
1928 return AVERROR_NOTSUPP;
1929 return s->iformat->read_play(s);
1932 int av_read_pause(AVFormatContext *s)
1934 if (!s->iformat->read_pause)
1935 return AVERROR_NOTSUPP;
1936 return s->iformat->read_pause(s);
1939 void av_close_input_file(AVFormatContext *s)
1941 int i, must_open_file;
1944 /* free previous packet */
1945 if (s->cur_st && s->cur_st->parser)
1946 av_free_packet(&s->cur_pkt);
1948 if (s->iformat->read_close)
1949 s->iformat->read_close(s);
1950 for(i=0;i<s->nb_streams;i++) {
1951 /* free all data in a stream component */
1954 av_parser_close(st->parser);
1956 av_free(st->index_entries);
1957 av_free(st->codec->extradata);
1961 flush_packet_queue(s);
1963 if (s->iformat->flags & AVFMT_NOFILE) {
1966 if (must_open_file) {
1969 av_freep(&s->priv_data);
1973 AVStream *av_new_stream(AVFormatContext *s, int id)
1978 if (s->nb_streams >= MAX_STREAMS)
1981 st = av_mallocz(sizeof(AVStream));
1985 st->codec= avcodec_alloc_context();
1987 /* no default bitrate if decoding */
1988 st->codec->bit_rate = 0;
1990 st->index = s->nb_streams;
1992 st->start_time = AV_NOPTS_VALUE;
1993 st->duration = AV_NOPTS_VALUE;
1994 st->cur_dts = AV_NOPTS_VALUE;
1996 /* default pts settings is MPEG like */
1997 av_set_pts_info(st, 33, 1, 90000);
1998 st->last_IP_pts = AV_NOPTS_VALUE;
1999 for(i=0; i<MAX_REORDER_DELAY+1; i++)
2000 st->pts_buffer[i]= AV_NOPTS_VALUE;
2002 s->streams[s->nb_streams++] = st;
2006 /************************************************************/
2007 /* output media file */
2009 int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2013 if (s->oformat->priv_data_size > 0) {
2014 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2016 return AVERROR_NOMEM;
2018 s->priv_data = NULL;
2020 if (s->oformat->set_parameters) {
2021 ret = s->oformat->set_parameters(s, ap);
2028 int av_write_header(AVFormatContext *s)
2033 // some sanity checks
2034 for(i=0;i<s->nb_streams;i++) {
2037 switch (st->codec->codec_type) {
2038 case CODEC_TYPE_AUDIO:
2039 if(st->codec->sample_rate<=0){
2040 av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2044 case CODEC_TYPE_VIDEO:
2045 if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2046 av_log(s, AV_LOG_ERROR, "time base not set\n");
2049 if(st->codec->width<=0 || st->codec->height<=0){
2050 av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2056 if(s->oformat->codec_tag){
2057 if(st->codec->codec_tag){
2059 //check that tag + id is in the table
2060 //if neither is in the table -> ok
2061 //if tag is in the table with another id -> FAIL
2062 //if id is in the table with another tag -> FAIL unless strict < ?
2064 st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2068 if (!s->priv_data && s->oformat->priv_data_size > 0) {
2069 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2071 return AVERROR_NOMEM;
2074 if(s->oformat->write_header){
2075 ret = s->oformat->write_header(s);
2080 /* init PTS generation */
2081 for(i=0;i<s->nb_streams;i++) {
2082 int64_t den = AV_NOPTS_VALUE;
2085 switch (st->codec->codec_type) {
2086 case CODEC_TYPE_AUDIO:
2087 den = (int64_t)st->time_base.num * st->codec->sample_rate;
2089 case CODEC_TYPE_VIDEO:
2090 den = (int64_t)st->time_base.num * st->codec->time_base.den;
2095 if (den != AV_NOPTS_VALUE) {
2097 return AVERROR_INVALIDDATA;
2098 av_frac_init(&st->pts, 0, 0, den);
2104 //FIXME merge with compute_pkt_fields
2105 static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
2106 int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2107 int num, den, frame_size, i;
2109 // 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);
2111 /* if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2114 /* duration field */
2115 if (pkt->duration == 0) {
2116 compute_frame_duration(&num, &den, st, NULL, pkt);
2118 pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
2122 //XXX/FIXME this is a temporary hack until all encoders output pts
2123 if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2125 // pkt->pts= st->cur_dts;
2126 pkt->pts= st->pts.val;
2129 //calculate dts from pts
2130 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE){
2131 st->pts_buffer[0]= pkt->pts;
2132 for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2133 st->pts_buffer[i]= (i-delay-1) * pkt->duration;
2134 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2135 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2137 pkt->dts= st->pts_buffer[0];
2140 if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2141 av_log(NULL, AV_LOG_ERROR, "error, non monotone timestamps %"PRId64" >= %"PRId64"\n", st->cur_dts, pkt->dts);
2144 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2145 av_log(NULL, AV_LOG_ERROR, "error, pts < dts\n");
2149 // av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2150 st->cur_dts= pkt->dts;
2151 st->pts.val= pkt->dts;
2154 switch (st->codec->codec_type) {
2155 case CODEC_TYPE_AUDIO:
2156 frame_size = get_audio_frame_size(st->codec, pkt->size);
2158 /* HACK/FIXME, we skip the initial 0-size packets as they are most likely equal to the encoder delay,
2159 but it would be better if we had the real timestamps from the encoder */
2160 if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2161 av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2164 case CODEC_TYPE_VIDEO:
2165 av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2173 static void truncate_ts(AVStream *st, AVPacket *pkt){
2174 int64_t pts_mask = (2LL << (st->pts_wrap_bits-1)) - 1;
2177 // pkt->dts= 0; //this happens for low_delay=0 and b frames, FIXME, needs further invstigation about what we should do here
2179 if (pkt->pts != AV_NOPTS_VALUE)
2180 pkt->pts &= pts_mask;
2181 if (pkt->dts != AV_NOPTS_VALUE)
2182 pkt->dts &= pts_mask;
2185 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2189 ret=compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2190 if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2193 truncate_ts(s->streams[pkt->stream_index], pkt);
2195 ret= s->oformat->write_packet(s, pkt);
2197 ret= url_ferror(&s->pb);
2201 int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2202 AVPacketList *pktl, **next_point, *this_pktl;
2204 int streams[MAX_STREAMS];
2207 AVStream *st= s->streams[ pkt->stream_index];
2209 // assert(pkt->destruct != av_destruct_packet); //FIXME
2211 this_pktl = av_mallocz(sizeof(AVPacketList));
2212 this_pktl->pkt= *pkt;
2213 if(pkt->destruct == av_destruct_packet)
2214 pkt->destruct= NULL; // non shared -> must keep original from being freed
2216 av_dup_packet(&this_pktl->pkt); //shared -> must dup
2218 next_point = &s->packet_buffer;
2220 AVStream *st2= s->streams[ (*next_point)->pkt.stream_index];
2221 int64_t left= st2->time_base.num * (int64_t)st ->time_base.den;
2222 int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2223 if((*next_point)->pkt.dts * left > pkt->dts * right) //FIXME this can overflow
2225 next_point= &(*next_point)->next;
2227 this_pktl->next= *next_point;
2228 *next_point= this_pktl;
2231 memset(streams, 0, sizeof(streams));
2232 pktl= s->packet_buffer;
2234 //av_log(s, AV_LOG_DEBUG, "show st:%d dts:%"PRId64"\n", pktl->pkt.stream_index, pktl->pkt.dts);
2235 if(streams[ pktl->pkt.stream_index ] == 0)
2237 streams[ pktl->pkt.stream_index ]++;
2241 if(s->nb_streams == stream_count || (flush && stream_count)){
2242 pktl= s->packet_buffer;
2245 s->packet_buffer= pktl->next;
2249 av_init_packet(out);
2255 * Interleaves a AVPacket correctly so it can be muxed.
2256 * @param out the interleaved packet will be output here
2257 * @param in the input packet
2258 * @param flush 1 if no further packets are available as input and all
2259 * remaining packets should be output
2260 * @return 1 if a packet was output, 0 if no packet could be output,
2261 * < 0 if an error occured
2263 static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2264 if(s->oformat->interleave_packet)
2265 return s->oformat->interleave_packet(s, out, in, flush);
2267 return av_interleave_packet_per_dts(s, out, in, flush);
2270 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2271 AVStream *st= s->streams[ pkt->stream_index];
2273 //FIXME/XXX/HACK drop zero sized packets
2274 if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2277 //av_log(NULL, AV_LOG_DEBUG, "av_interleaved_write_frame %d %"PRId64" %"PRId64"\n", pkt->size, pkt->dts, pkt->pts);
2278 if(compute_pkt_fields2(st, pkt) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2281 if(pkt->dts == AV_NOPTS_VALUE)
2286 int ret= av_interleave_packet(s, &opkt, pkt, 0);
2287 if(ret<=0) //FIXME cleanup needed for ret<0 ?
2290 truncate_ts(s->streams[opkt.stream_index], &opkt);
2291 ret= s->oformat->write_packet(s, &opkt);
2293 av_free_packet(&opkt);
2298 if(url_ferror(&s->pb))
2299 return url_ferror(&s->pb);
2303 int av_write_trailer(AVFormatContext *s)
2309 ret= av_interleave_packet(s, &pkt, NULL, 1);
2310 if(ret<0) //FIXME cleanup needed for ret<0 ?
2315 truncate_ts(s->streams[pkt.stream_index], &pkt);
2316 ret= s->oformat->write_packet(s, &pkt);
2318 av_free_packet(&pkt);
2322 if(url_ferror(&s->pb))
2326 if(s->oformat->write_trailer)
2327 ret = s->oformat->write_trailer(s);
2330 ret=url_ferror(&s->pb);
2331 for(i=0;i<s->nb_streams;i++)
2332 av_freep(&s->streams[i]->priv_data);
2333 av_freep(&s->priv_data);
2337 /* "user interface" functions */
2339 void dump_format(AVFormatContext *ic,
2347 av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
2348 is_output ? "Output" : "Input",
2350 is_output ? ic->oformat->name : ic->iformat->name,
2351 is_output ? "to" : "from", url);
2353 av_log(NULL, AV_LOG_INFO, " Duration: ");
2354 if (ic->duration != AV_NOPTS_VALUE) {
2355 int hours, mins, secs, us;
2356 secs = ic->duration / AV_TIME_BASE;
2357 us = ic->duration % AV_TIME_BASE;
2362 av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%01d", hours, mins, secs,
2363 (10 * us) / AV_TIME_BASE);
2365 av_log(NULL, AV_LOG_INFO, "N/A");
2367 if (ic->start_time != AV_NOPTS_VALUE) {
2369 av_log(NULL, AV_LOG_INFO, ", start: ");
2370 secs = ic->start_time / AV_TIME_BASE;
2371 us = ic->start_time % AV_TIME_BASE;
2372 av_log(NULL, AV_LOG_INFO, "%d.%06d",
2373 secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
2375 av_log(NULL, AV_LOG_INFO, ", bitrate: ");
2377 av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
2379 av_log(NULL, AV_LOG_INFO, "N/A");
2381 av_log(NULL, AV_LOG_INFO, "\n");
2383 for(i=0;i<ic->nb_streams;i++) {
2384 AVStream *st = ic->streams[i];
2385 int g= ff_gcd(st->time_base.num, st->time_base.den);
2386 avcodec_string(buf, sizeof(buf), st->codec, is_output);
2387 av_log(NULL, AV_LOG_INFO, " Stream #%d.%d", index, i);
2388 /* the pid is an important information, so we display it */
2389 /* XXX: add a generic system */
2391 flags = ic->oformat->flags;
2393 flags = ic->iformat->flags;
2394 if (flags & AVFMT_SHOW_IDS) {
2395 av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
2397 if (strlen(st->language) > 0) {
2398 av_log(NULL, AV_LOG_INFO, "(%s)", st->language);
2400 av_log(NULL, AV_LOG_DEBUG, ", %d/%d", st->time_base.num/g, st->time_base.den/g);
2401 av_log(NULL, AV_LOG_INFO, ": %s", buf);
2402 if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2403 if(st->r_frame_rate.den && st->r_frame_rate.num)
2404 av_log(NULL, AV_LOG_INFO, ", %5.2f fps(r)", av_q2d(st->r_frame_rate));
2405 /* else if(st->time_base.den && st->time_base.num)
2406 av_log(NULL, AV_LOG_INFO, ", %5.2f fps(m)", 1/av_q2d(st->time_base));*/
2408 av_log(NULL, AV_LOG_INFO, ", %5.2f fps(c)", 1/av_q2d(st->codec->time_base));
2410 av_log(NULL, AV_LOG_INFO, "\n");
2417 int frame_rate, frame_rate_base;
2420 static AbvEntry frame_abvs[] = {
2421 { "ntsc", 720, 480, 30000, 1001 },
2422 { "pal", 720, 576, 25, 1 },
2423 { "qntsc", 352, 240, 30000, 1001 }, /* VCD compliant ntsc */
2424 { "qpal", 352, 288, 25, 1 }, /* VCD compliant pal */
2425 { "sntsc", 640, 480, 30000, 1001 }, /* square pixel ntsc */
2426 { "spal", 768, 576, 25, 1 }, /* square pixel pal */
2427 { "film", 352, 240, 24, 1 },
2428 { "ntsc-film", 352, 240, 24000, 1001 },
2429 { "sqcif", 128, 96, 0, 0 },
2430 { "qcif", 176, 144, 0, 0 },
2431 { "cif", 352, 288, 0, 0 },
2432 { "4cif", 704, 576, 0, 0 },
2435 int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2438 int n = sizeof(frame_abvs) / sizeof(AbvEntry);
2440 int frame_width = 0, frame_height = 0;
2443 if (!strcmp(frame_abvs[i].abv, str)) {
2444 frame_width = frame_abvs[i].width;
2445 frame_height = frame_abvs[i].height;
2451 frame_width = strtol(p, (char **)&p, 10);
2454 frame_height = strtol(p, (char **)&p, 10);
2456 if (frame_width <= 0 || frame_height <= 0)
2458 *width_ptr = frame_width;
2459 *height_ptr = frame_height;
2463 int parse_frame_rate(int *frame_rate, int *frame_rate_base, const char *arg)
2468 /* First, we check our abbreviation table */
2469 for (i = 0; i < sizeof(frame_abvs)/sizeof(*frame_abvs); ++i)
2470 if (!strcmp(frame_abvs[i].abv, arg)) {
2471 *frame_rate = frame_abvs[i].frame_rate;
2472 *frame_rate_base = frame_abvs[i].frame_rate_base;
2476 /* Then, we try to parse it as fraction */
2477 cp = strchr(arg, '/');
2479 cp = strchr(arg, ':');
2482 *frame_rate = strtol(arg, &cpp, 10);
2483 if (cpp != arg || cpp == cp)
2484 *frame_rate_base = strtol(cp+1, &cpp, 10);
2489 /* Finally we give up and parse it as double */
2490 AVRational time_base = av_d2q(strtod(arg, 0), DEFAULT_FRAME_RATE_BASE);
2491 *frame_rate_base = time_base.den;
2492 *frame_rate = time_base.num;
2494 if (!*frame_rate || !*frame_rate_base)
2500 #ifndef CONFIG_WINCE
2501 int64_t parse_date(const char *datestr, int duration)
2507 static const char *date_fmt[] = {
2511 static const char *time_fmt[] = {
2521 time_t now = time(0);
2523 len = strlen(datestr);
2525 lastch = datestr[len - 1];
2528 is_utc = (lastch == 'z' || lastch == 'Z');
2530 memset(&dt, 0, sizeof(dt));
2535 for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
2536 q = small_strptime(p, date_fmt[i], &dt);
2546 dt = *localtime(&now);
2548 dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
2553 if (*p == 'T' || *p == 't' || *p == ' ')
2556 for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
2557 q = small_strptime(p, time_fmt[i], &dt);
2567 q = small_strptime(p, time_fmt[0], &dt);
2569 dt.tm_sec = strtol(p, (char **)&q, 10);
2575 /* Now we have all the fields that we can get */
2580 return now * INT64_C(1000000);
2584 t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2586 dt.tm_isdst = -1; /* unknown */
2599 for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
2602 val += n * (*q - '0');
2606 return negative ? -t : t;
2608 #endif /* CONFIG_WINCE */
2610 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
2620 while (*p != '\0' && *p != '=' && *p != '&') {
2621 if ((q - tag) < sizeof(tag) - 1)
2629 while (*p != '&' && *p != '\0') {
2630 if ((q - arg) < arg_size - 1) {
2640 if (!strcmp(tag, tag1))
2649 int av_get_frame_filename(char *buf, int buf_size,
2650 const char *path, int number)
2653 char *q, buf1[20], c;
2654 int nd, len, percentd_found;
2666 while (isdigit(*p)) {
2667 nd = nd * 10 + *p++ - '0';
2670 } while (isdigit(c));
2679 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
2681 if ((q - buf + len) > buf_size - 1)
2683 memcpy(q, buf1, len);
2691 if ((q - buf) < buf_size - 1)
2695 if (!percentd_found)
2704 static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
2707 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
2709 for(i=0;i<size;i+=16) {
2716 PRINT(" %02x", buf[i+j]);
2721 for(j=0;j<len;j++) {
2723 if (c < ' ' || c > '~')
2732 void av_hex_dump(FILE *f, uint8_t *buf, int size)
2734 hex_dump_internal(NULL, f, 0, buf, size);
2737 void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
2739 hex_dump_internal(avcl, NULL, level, buf, size);
2742 //FIXME needs to know the time_base
2743 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload)
2745 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
2746 PRINT("stream #%d:\n", pkt->stream_index);
2747 PRINT(" keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
2748 PRINT(" duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
2749 /* DTS is _always_ valid after av_read_frame() */
2751 if (pkt->dts == AV_NOPTS_VALUE)
2754 PRINT("%0.3f", (double)pkt->dts / AV_TIME_BASE);
2755 /* PTS may be not known if B frames are present */
2757 if (pkt->pts == AV_NOPTS_VALUE)
2760 PRINT("%0.3f", (double)pkt->pts / AV_TIME_BASE);
2762 PRINT(" size=%d\n", pkt->size);
2765 av_hex_dump(f, pkt->data, pkt->size);
2768 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
2770 pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
2773 void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
2775 pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
2778 void url_split(char *proto, int proto_size,
2779 char *authorization, int authorization_size,
2780 char *hostname, int hostname_size,
2782 char *path, int path_size,
2793 while (*p != ':' && *p != '\0') {
2794 if ((q - proto) < proto_size - 1)
2800 if (authorization_size > 0)
2801 authorization[0] = '\0';
2805 if (hostname_size > 0)
2809 char *at,*slash; // PETR: position of '@' character and '/' character
2816 at = strchr(p,'@'); // PETR: get the position of '@'
2817 slash = strchr(p,'/'); // PETR: get position of '/' - end of hostname
2818 if (at && slash && at > slash) at = NULL; // PETR: not interested in '@' behind '/'
2820 q = at ? authorization : hostname; // PETR: if '@' exists starting with auth.
2822 while ((at || *p != ':') && *p != '/' && *p != '?' && *p != '\0') { // PETR:
2823 if (*p == '@') { // PETR: passed '@'
2824 if (authorization_size > 0)
2828 } else if (!at) { // PETR: hostname
2829 if ((q - hostname) < hostname_size - 1)
2832 if ((q - authorization) < authorization_size - 1)
2837 if (hostname_size > 0)
2841 port = strtoul(p, (char **)&p, 10);
2846 pstrcpy(path, path_size, p);
2849 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
2850 int pts_num, int pts_den)
2852 s->pts_wrap_bits = pts_wrap_bits;
2853 s->time_base.num = pts_num;
2854 s->time_base.den = pts_den;
2857 /* fraction handling */
2860 * f = val + (num / den) + 0.5.
2862 * 'num' is normalized so that it is such as 0 <= num < den.
2864 * @param f fractional number
2865 * @param val integer value
2866 * @param num must be >= 0
2867 * @param den must be >= 1
2869 static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
2882 * Fractionnal addition to f: f = f + (incr / f->den).
2884 * @param f fractional number
2885 * @param incr increment, can be positive or negative
2887 static void av_frac_add(AVFrac *f, int64_t incr)
2891 num = f->num + incr;
2894 f->val += num / den;
2900 } else if (num >= den) {
2901 f->val += num / den;