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 if (pc->pict_type == FF_I_TYPE)
675 pkt->flags |= PKT_FLAG_KEY;
679 void av_destruct_packet_nofree(AVPacket *pkt)
681 pkt->data = NULL; pkt->size = 0;
684 static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
690 /* select current input stream component */
693 if (!st->need_parsing || !st->parser) {
694 /* no parsing needed: we just output the packet as is */
695 /* raw data support */
697 compute_pkt_fields(s, st, NULL, pkt);
700 } else if (s->cur_len > 0 && st->discard < AVDISCARD_ALL) {
701 len = av_parser_parse(st->parser, st->codec, &pkt->data, &pkt->size,
702 s->cur_ptr, s->cur_len,
703 s->cur_pkt.pts, s->cur_pkt.dts);
704 s->cur_pkt.pts = AV_NOPTS_VALUE;
705 s->cur_pkt.dts = AV_NOPTS_VALUE;
706 /* increment read pointer */
710 /* return packet if any */
714 pkt->stream_index = st->index;
715 pkt->pts = st->parser->pts;
716 pkt->dts = st->parser->dts;
717 pkt->destruct = av_destruct_packet_nofree;
718 compute_pkt_fields(s, st, st->parser, pkt);
720 if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & PKT_FLAG_KEY){
721 av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
722 0, 0, AVINDEX_KEYFRAME);
729 av_free_packet(&s->cur_pkt);
733 /* read next packet */
734 ret = av_read_packet(s, &s->cur_pkt);
736 if (ret == AVERROR(EAGAIN))
738 /* return the last frames, if any */
739 for(i = 0; i < s->nb_streams; i++) {
741 if (st->parser && st->need_parsing) {
742 av_parser_parse(st->parser, st->codec,
743 &pkt->data, &pkt->size,
745 AV_NOPTS_VALUE, AV_NOPTS_VALUE);
750 /* no more packets: really terminates parsing */
754 st = s->streams[s->cur_pkt.stream_index];
755 if(st->codec->debug & FF_DEBUG_PTS)
756 av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
757 s->cur_pkt.stream_index,
763 s->cur_ptr = s->cur_pkt.data;
764 s->cur_len = s->cur_pkt.size;
765 if (st->need_parsing && !st->parser) {
766 st->parser = av_parser_init(st->codec->codec_id);
768 /* no parser available : just output the raw packets */
769 st->need_parsing = 0;
770 }else if(st->need_parsing == 2){
771 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
773 if(st->parser && (s->iformat->flags & AVFMT_GENERIC_INDEX)){
774 st->parser->last_frame_offset=
775 st->parser->cur_offset= s->cur_pkt.pos;
780 if(st->codec->debug & FF_DEBUG_PTS)
781 av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
790 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
794 const int genpts= s->flags & AVFMT_FLAG_GENPTS;
797 pktl = s->packet_buffer;
799 AVPacket *next_pkt= &pktl->pkt;
801 if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
802 while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
803 if( pktl->pkt.stream_index == next_pkt->stream_index
804 && next_pkt->dts < pktl->pkt.dts
805 && pktl->pkt.pts != pktl->pkt.dts //not b frame
806 /*&& pktl->pkt.dts != AV_NOPTS_VALUE*/){
807 next_pkt->pts= pktl->pkt.dts;
811 pktl = s->packet_buffer;
814 if( next_pkt->pts != AV_NOPTS_VALUE
815 || next_pkt->dts == AV_NOPTS_VALUE
817 /* read packet from packet buffer, if there is data */
819 s->packet_buffer = pktl->next;
825 AVPacketList **plast_pktl= &s->packet_buffer;
826 int ret= av_read_frame_internal(s, pkt);
828 if(pktl && ret != AVERROR(EAGAIN)){
835 /* duplicate the packet */
836 if (av_dup_packet(pkt) < 0)
837 return AVERROR_NOMEM;
839 while(*plast_pktl) plast_pktl= &(*plast_pktl)->next; //FIXME maybe maintain pointer to the last?
841 pktl = av_mallocz(sizeof(AVPacketList));
843 return AVERROR_NOMEM;
845 /* add the packet in the buffered packet list */
849 assert(!s->packet_buffer);
850 return av_read_frame_internal(s, pkt);
855 /* XXX: suppress the packet queue */
856 static void flush_packet_queue(AVFormatContext *s)
861 pktl = s->packet_buffer;
864 s->packet_buffer = pktl->next;
865 av_free_packet(&pktl->pkt);
870 /*******************************************************/
873 int av_find_default_stream_index(AVFormatContext *s)
878 if (s->nb_streams <= 0)
880 for(i = 0; i < s->nb_streams; i++) {
882 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
890 * Flush the frame reader.
892 static void av_read_frame_flush(AVFormatContext *s)
897 flush_packet_queue(s);
899 /* free previous packet */
901 if (s->cur_st->parser)
902 av_free_packet(&s->cur_pkt);
909 /* for each stream, reset read state */
910 for(i = 0; i < s->nb_streams; i++) {
914 av_parser_close(st->parser);
917 st->last_IP_pts = AV_NOPTS_VALUE;
918 st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
922 void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
925 for(i = 0; i < s->nb_streams; i++) {
926 AVStream *st = s->streams[i];
928 st->cur_dts = av_rescale(timestamp,
929 st->time_base.den * (int64_t)ref_st->time_base.num,
930 st->time_base.num * (int64_t)ref_st->time_base.den);
934 int av_add_index_entry(AVStream *st,
935 int64_t pos, int64_t timestamp, int size, int distance, int flags)
937 AVIndexEntry *entries, *ie;
940 if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
943 entries = av_fast_realloc(st->index_entries,
944 &st->index_entries_allocated_size,
945 (st->nb_index_entries + 1) *
946 sizeof(AVIndexEntry));
950 st->index_entries= entries;
952 index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
955 index= st->nb_index_entries++;
957 assert(index==0 || ie[-1].timestamp < timestamp);
960 if(ie->timestamp != timestamp){
961 if(ie->timestamp <= timestamp)
963 memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
964 st->nb_index_entries++;
965 }else if(ie->pos == pos && distance < ie->min_distance) //dont reduce the distance
966 distance= ie->min_distance;
970 ie->timestamp = timestamp;
971 ie->min_distance= distance;
979 * build an index for raw streams using a parser.
981 static void av_build_index_raw(AVFormatContext *s)
983 AVPacket pkt1, *pkt = &pkt1;
988 av_read_frame_flush(s);
989 url_fseek(&s->pb, s->data_offset, SEEK_SET);
992 ret = av_read_frame(s, pkt);
995 if (pkt->stream_index == 0 && st->parser &&
996 (pkt->flags & PKT_FLAG_KEY)) {
997 av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
998 0, 0, AVINDEX_KEYFRAME);
1000 av_free_packet(pkt);
1005 * Returns TRUE if we deal with a raw stream.
1007 * Raw codec data and parsing needed.
1009 static int is_raw_stream(AVFormatContext *s)
1013 if (s->nb_streams != 1)
1016 if (!st->need_parsing)
1021 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1024 AVIndexEntry *entries= st->index_entries;
1025 int nb_entries= st->nb_index_entries;
1034 timestamp = entries[m].timestamp;
1035 if(timestamp >= wanted_timestamp)
1037 if(timestamp <= wanted_timestamp)
1040 m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1042 if(!(flags & AVSEEK_FLAG_ANY)){
1043 while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1044 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1055 int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1056 AVInputFormat *avif= s->iformat;
1057 int64_t pos_min, pos_max, pos, pos_limit;
1058 int64_t ts_min, ts_max, ts;
1062 if (stream_index < 0)
1066 av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1070 ts_min= AV_NOPTS_VALUE;
1071 pos_limit= -1; //gcc falsely says it may be uninitalized
1073 st= s->streams[stream_index];
1074 if(st->index_entries){
1077 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()
1078 index= FFMAX(index, 0);
1079 e= &st->index_entries[index];
1081 if(e->timestamp <= target_ts || e->pos == e->min_distance){
1083 ts_min= e->timestamp;
1085 av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1092 index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1093 assert(index < st->nb_index_entries);
1095 e= &st->index_entries[index];
1096 assert(e->timestamp >= target_ts);
1098 ts_max= e->timestamp;
1099 pos_limit= pos_max - e->min_distance;
1101 av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1102 pos_max,pos_limit, ts_max);
1107 pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1112 url_fseek(&s->pb, pos, SEEK_SET);
1114 av_update_cur_dts(s, st, ts);
1119 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 )){
1121 int64_t start_pos, filesize;
1125 av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1128 if(ts_min == AV_NOPTS_VALUE){
1129 pos_min = s->data_offset;
1130 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1131 if (ts_min == AV_NOPTS_VALUE)
1135 if(ts_max == AV_NOPTS_VALUE){
1137 filesize = url_fsize(&s->pb);
1138 pos_max = filesize - 1;
1141 ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1143 }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1144 if (ts_max == AV_NOPTS_VALUE)
1148 int64_t tmp_pos= pos_max + 1;
1149 int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1150 if(tmp_ts == AV_NOPTS_VALUE)
1154 if(tmp_pos >= filesize)
1160 if(ts_min > ts_max){
1162 }else if(ts_min == ts_max){
1167 while (pos_min < pos_limit) {
1169 av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1173 assert(pos_limit <= pos_max);
1176 int64_t approximate_keyframe_distance= pos_max - pos_limit;
1177 // interpolate position (better than dichotomy)
1178 pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1179 + pos_min - approximate_keyframe_distance;
1180 }else if(no_change==1){
1181 // bisection, if interpolation failed to change min or max pos last time
1182 pos = (pos_min + pos_limit)>>1;
1184 // linear search if bisection failed, can only happen if there are very few or no keframes between min/max
1189 else if(pos > pos_limit)
1193 ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1199 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);
1201 assert(ts != AV_NOPTS_VALUE);
1202 if (target_ts <= ts) {
1203 pos_limit = start_pos - 1;
1207 if (target_ts >= ts) {
1213 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1214 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
1217 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1219 ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1220 av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1221 pos, ts_min, target_ts, ts_max);
1227 static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1228 int64_t pos_min, pos_max;
1232 if (stream_index < 0)
1235 st= s->streams[stream_index];
1238 pos_min = s->data_offset;
1239 pos_max = url_fsize(&s->pb) - 1;
1241 if (pos < pos_min) pos= pos_min;
1242 else if(pos > pos_max) pos= pos_max;
1244 url_fseek(&s->pb, pos, SEEK_SET);
1247 av_update_cur_dts(s, st, ts);
1252 static int av_seek_frame_generic(AVFormatContext *s,
1253 int stream_index, int64_t timestamp, int flags)
1259 st = s->streams[stream_index];
1261 index = av_index_search_timestamp(st, timestamp, flags);
1267 if(st->index_entries && st->nb_index_entries){
1268 ie= &st->index_entries[st->nb_index_entries-1];
1269 url_fseek(&s->pb, ie->pos, SEEK_SET);
1270 av_update_cur_dts(s, st, ie->timestamp);
1272 url_fseek(&s->pb, 0, SEEK_SET);
1275 int ret = av_read_frame(s, &pkt);
1278 av_free_packet(&pkt);
1279 if(stream_index == pkt.stream_index){
1280 if((pkt.flags & PKT_FLAG_KEY) && pkt.dts > timestamp)
1284 index = av_index_search_timestamp(st, timestamp, flags);
1289 av_read_frame_flush(s);
1290 if (s->iformat->read_seek){
1291 if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1294 ie = &st->index_entries[index];
1295 url_fseek(&s->pb, ie->pos, SEEK_SET);
1297 av_update_cur_dts(s, st, ie->timestamp);
1302 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1307 av_read_frame_flush(s);
1309 if(flags & AVSEEK_FLAG_BYTE)
1310 return av_seek_frame_byte(s, stream_index, timestamp, flags);
1312 if(stream_index < 0){
1313 stream_index= av_find_default_stream_index(s);
1314 if(stream_index < 0)
1317 st= s->streams[stream_index];
1318 /* timestamp for default must be expressed in AV_TIME_BASE units */
1319 timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1321 st= s->streams[stream_index];
1323 /* first, we try the format specific seek */
1324 if (s->iformat->read_seek)
1325 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1332 if(s->iformat->read_timestamp)
1333 return av_seek_frame_binary(s, stream_index, timestamp, flags);
1335 return av_seek_frame_generic(s, stream_index, timestamp, flags);
1338 /*******************************************************/
1341 * Returns TRUE if the stream has accurate timings in any stream.
1343 * @return TRUE if the stream has accurate timings for at least one component.
1345 static int av_has_timings(AVFormatContext *ic)
1350 for(i = 0;i < ic->nb_streams; i++) {
1351 st = ic->streams[i];
1352 if (st->start_time != AV_NOPTS_VALUE &&
1353 st->duration != AV_NOPTS_VALUE)
1360 * Estimate the stream timings from the one of each components.
1362 * Also computes the global bitrate if possible.
1364 static void av_update_stream_timings(AVFormatContext *ic)
1366 int64_t start_time, start_time1, end_time, end_time1;
1370 start_time = INT64_MAX;
1371 end_time = INT64_MIN;
1372 for(i = 0;i < ic->nb_streams; i++) {
1373 st = ic->streams[i];
1374 if (st->start_time != AV_NOPTS_VALUE) {
1375 start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1376 if (start_time1 < start_time)
1377 start_time = start_time1;
1378 if (st->duration != AV_NOPTS_VALUE) {
1379 end_time1 = start_time1
1380 + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1381 if (end_time1 > end_time)
1382 end_time = end_time1;
1386 if (start_time != INT64_MAX) {
1387 ic->start_time = start_time;
1388 if (end_time != INT64_MIN) {
1389 ic->duration = end_time - start_time;
1390 if (ic->file_size > 0) {
1391 /* compute the bit rate */
1392 ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1393 (double)ic->duration;
1400 static void fill_all_stream_timings(AVFormatContext *ic)
1405 av_update_stream_timings(ic);
1406 for(i = 0;i < ic->nb_streams; i++) {
1407 st = ic->streams[i];
1408 if (st->start_time == AV_NOPTS_VALUE) {
1409 if(ic->start_time != AV_NOPTS_VALUE)
1410 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1411 if(ic->duration != AV_NOPTS_VALUE)
1412 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1417 static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1419 int64_t filesize, duration;
1423 /* if bit_rate is already set, we believe it */
1424 if (ic->bit_rate == 0) {
1426 for(i=0;i<ic->nb_streams;i++) {
1427 st = ic->streams[i];
1428 bit_rate += st->codec->bit_rate;
1430 ic->bit_rate = bit_rate;
1433 /* if duration is already set, we believe it */
1434 if (ic->duration == AV_NOPTS_VALUE &&
1435 ic->bit_rate != 0 &&
1436 ic->file_size != 0) {
1437 filesize = ic->file_size;
1439 for(i = 0; i < ic->nb_streams; i++) {
1440 st = ic->streams[i];
1441 duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1442 if (st->start_time == AV_NOPTS_VALUE ||
1443 st->duration == AV_NOPTS_VALUE) {
1445 st->duration = duration;
1452 #define DURATION_MAX_READ_SIZE 250000
1454 /* only usable for MPEG-PS streams */
1455 static void av_estimate_timings_from_pts(AVFormatContext *ic, offset_t old_offset)
1457 AVPacket pkt1, *pkt = &pkt1;
1459 int read_size, i, ret;
1461 int64_t filesize, offset, duration;
1463 /* free previous packet */
1464 if (ic->cur_st && ic->cur_st->parser)
1465 av_free_packet(&ic->cur_pkt);
1468 /* flush packet queue */
1469 flush_packet_queue(ic);
1471 for(i=0;i<ic->nb_streams;i++) {
1472 st = ic->streams[i];
1474 av_parser_close(st->parser);
1479 /* we read the first packets to get the first PTS (not fully
1480 accurate, but it is enough now) */
1481 url_fseek(&ic->pb, 0, SEEK_SET);
1484 if (read_size >= DURATION_MAX_READ_SIZE)
1486 /* if all info is available, we can stop */
1487 for(i = 0;i < ic->nb_streams; i++) {
1488 st = ic->streams[i];
1489 if (st->start_time == AV_NOPTS_VALUE)
1492 if (i == ic->nb_streams)
1495 ret = av_read_packet(ic, pkt);
1498 read_size += pkt->size;
1499 st = ic->streams[pkt->stream_index];
1500 if (pkt->pts != AV_NOPTS_VALUE) {
1501 if (st->start_time == AV_NOPTS_VALUE)
1502 st->start_time = pkt->pts;
1504 av_free_packet(pkt);
1507 /* estimate the end time (duration) */
1508 /* XXX: may need to support wrapping */
1509 filesize = ic->file_size;
1510 offset = filesize - DURATION_MAX_READ_SIZE;
1514 url_fseek(&ic->pb, offset, SEEK_SET);
1517 if (read_size >= DURATION_MAX_READ_SIZE)
1519 /* if all info is available, we can stop */
1520 for(i = 0;i < ic->nb_streams; i++) {
1521 st = ic->streams[i];
1522 if (st->duration == AV_NOPTS_VALUE)
1525 if (i == ic->nb_streams)
1528 ret = av_read_packet(ic, pkt);
1531 read_size += pkt->size;
1532 st = ic->streams[pkt->stream_index];
1533 if (pkt->pts != AV_NOPTS_VALUE) {
1534 end_time = pkt->pts;
1535 duration = end_time - st->start_time;
1537 if (st->duration == AV_NOPTS_VALUE ||
1538 st->duration < duration)
1539 st->duration = duration;
1542 av_free_packet(pkt);
1545 fill_all_stream_timings(ic);
1547 url_fseek(&ic->pb, old_offset, SEEK_SET);
1550 static void av_estimate_timings(AVFormatContext *ic, offset_t old_offset)
1554 /* get the file size, if possible */
1555 if (ic->iformat->flags & AVFMT_NOFILE) {
1558 file_size = url_fsize(&ic->pb);
1562 ic->file_size = file_size;
1564 if ((!strcmp(ic->iformat->name, "mpeg") ||
1565 !strcmp(ic->iformat->name, "mpegts")) &&
1566 file_size && !ic->pb.is_streamed) {
1567 /* get accurate estimate from the PTSes */
1568 av_estimate_timings_from_pts(ic, old_offset);
1569 } else if (av_has_timings(ic)) {
1570 /* at least one components has timings - we use them for all
1572 fill_all_stream_timings(ic);
1574 /* less precise: use bit rate info */
1575 av_estimate_timings_from_bit_rate(ic);
1577 av_update_stream_timings(ic);
1583 for(i = 0;i < ic->nb_streams; i++) {
1584 st = ic->streams[i];
1585 printf("%d: start_time: %0.3f duration: %0.3f\n",
1586 i, (double)st->start_time / AV_TIME_BASE,
1587 (double)st->duration / AV_TIME_BASE);
1589 printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1590 (double)ic->start_time / AV_TIME_BASE,
1591 (double)ic->duration / AV_TIME_BASE,
1592 ic->bit_rate / 1000);
1597 static int has_codec_parameters(AVCodecContext *enc)
1600 switch(enc->codec_type) {
1601 case CODEC_TYPE_AUDIO:
1602 val = enc->sample_rate;
1604 case CODEC_TYPE_VIDEO:
1605 val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
1614 static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1618 int got_picture, data_size, ret=0;
1621 if(!st->codec->codec){
1622 codec = avcodec_find_decoder(st->codec->codec_id);
1625 ret = avcodec_open(st->codec, codec);
1630 if(!has_codec_parameters(st->codec)){
1631 switch(st->codec->codec_type) {
1632 case CODEC_TYPE_VIDEO:
1633 ret = avcodec_decode_video(st->codec, &picture,
1634 &got_picture, (uint8_t *)data, size);
1636 case CODEC_TYPE_AUDIO:
1637 data_size = FFMAX(size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
1638 samples = av_malloc(data_size);
1641 ret = avcodec_decode_audio2(st->codec, samples,
1642 &data_size, (uint8_t *)data, size);
1653 /* absolute maximum size we read until we abort */
1654 #define MAX_READ_SIZE 5000000
1656 #define MAX_STD_TIMEBASES (60*12+5)
1657 static int get_std_framerate(int i){
1658 if(i<60*12) return i*1001;
1659 else return ((int[]){24,30,60,12,15})[i-60*12]*1000*12;
1662 int av_find_stream_info(AVFormatContext *ic)
1664 int i, count, ret, read_size, j;
1666 AVPacket pkt1, *pkt;
1667 AVPacketList *pktl=NULL, **ppktl;
1668 int64_t last_dts[MAX_STREAMS];
1669 int duration_count[MAX_STREAMS]={0};
1670 double (*duration_error)[MAX_STD_TIMEBASES];
1671 offset_t old_offset = url_ftell(&ic->pb);
1672 int64_t codec_info_duration[MAX_STREAMS]={0};
1673 int codec_info_nb_frames[MAX_STREAMS]={0};
1675 duration_error = av_mallocz(MAX_STREAMS * sizeof(*duration_error));
1676 if (!duration_error) return AVERROR_NOMEM;
1678 for(i=0;i<ic->nb_streams;i++) {
1679 st = ic->streams[i];
1680 if(st->codec->codec_type == CODEC_TYPE_VIDEO){
1681 /* if(!st->time_base.num)
1683 if(!st->codec->time_base.num)
1684 st->codec->time_base= st->time_base;
1686 //only for the split stuff
1688 st->parser = av_parser_init(st->codec->codec_id);
1689 if(st->need_parsing == 2 && st->parser){
1690 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1695 for(i=0;i<MAX_STREAMS;i++){
1696 last_dts[i]= AV_NOPTS_VALUE;
1701 ppktl = &ic->packet_buffer;
1703 /* check if one codec still needs to be handled */
1704 for(i=0;i<ic->nb_streams;i++) {
1705 st = ic->streams[i];
1706 if (!has_codec_parameters(st->codec))
1708 /* variable fps and no guess at the real fps */
1709 if( st->codec->time_base.den >= 101LL*st->codec->time_base.num
1710 && duration_count[i]<20 && st->codec->codec_type == CODEC_TYPE_VIDEO)
1712 if(st->parser && st->parser->parser->split && !st->codec->extradata)
1715 if (i == ic->nb_streams) {
1716 /* NOTE: if the format has no header, then we need to read
1717 some packets to get most of the streams, so we cannot
1719 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
1720 /* if we found the info for all the codecs, we can stop */
1725 /* we did not get all the codec info, but we read too much data */
1726 if (read_size >= MAX_READ_SIZE) {
1731 /* NOTE: a new stream can be added there if no header in file
1732 (AVFMTCTX_NOHEADER) */
1733 ret = av_read_frame_internal(ic, &pkt1);
1736 ret = -1; /* we could not have all the codec parameters before EOF */
1737 for(i=0;i<ic->nb_streams;i++) {
1738 st = ic->streams[i];
1739 if (!has_codec_parameters(st->codec)){
1741 avcodec_string(buf, sizeof(buf), st->codec, 0);
1742 av_log(ic, AV_LOG_INFO, "Could not find codec parameters (%s)\n", buf);
1750 pktl = av_mallocz(sizeof(AVPacketList));
1752 ret = AVERROR_NOMEM;
1756 /* add the packet in the buffered packet list */
1758 ppktl = &pktl->next;
1763 /* duplicate the packet */
1764 if (av_dup_packet(pkt) < 0) {
1765 ret = AVERROR_NOMEM;
1769 read_size += pkt->size;
1771 st = ic->streams[pkt->stream_index];
1772 if(codec_info_nb_frames[st->index]>1)
1773 codec_info_duration[st->index] += pkt->duration;
1774 if (pkt->duration != 0)
1775 codec_info_nb_frames[st->index]++;
1778 int index= pkt->stream_index;
1779 int64_t last= last_dts[index];
1780 int64_t duration= pkt->dts - last;
1782 if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
1783 double dur= duration * av_q2d(st->time_base);
1785 // if(st->codec->codec_type == CODEC_TYPE_VIDEO)
1786 // av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
1787 if(duration_count[index] < 2)
1788 memset(duration_error, 0, MAX_STREAMS * sizeof(*duration_error));
1789 for(i=1; i<MAX_STD_TIMEBASES; i++){
1790 int framerate= get_std_framerate(i);
1791 int ticks= lrintf(dur*framerate/(1001*12));
1792 double error= dur - ticks*1001*12/(double)framerate;
1793 duration_error[index][i] += error*error;
1795 duration_count[index]++;
1797 if(last == AV_NOPTS_VALUE || duration_count[index]<=1)
1798 last_dts[pkt->stream_index]= pkt->dts;
1800 if(st->parser && st->parser->parser->split && !st->codec->extradata){
1801 int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
1803 st->codec->extradata_size= i;
1804 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
1805 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
1806 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
1810 /* if still no information, we try to open the codec and to
1811 decompress the frame. We try to avoid that in most cases as
1812 it takes longer and uses more memory. For MPEG4, we need to
1813 decompress for Quicktime. */
1814 if (!has_codec_parameters(st->codec) /*&&
1815 (st->codec->codec_id == CODEC_ID_FLV1 ||
1816 st->codec->codec_id == CODEC_ID_H264 ||
1817 st->codec->codec_id == CODEC_ID_H263 ||
1818 st->codec->codec_id == CODEC_ID_H261 ||
1819 st->codec->codec_id == CODEC_ID_VORBIS ||
1820 st->codec->codec_id == CODEC_ID_MJPEG ||
1821 st->codec->codec_id == CODEC_ID_PNG ||
1822 st->codec->codec_id == CODEC_ID_PAM ||
1823 st->codec->codec_id == CODEC_ID_PGM ||
1824 st->codec->codec_id == CODEC_ID_PGMYUV ||
1825 st->codec->codec_id == CODEC_ID_PBM ||
1826 st->codec->codec_id == CODEC_ID_PPM ||
1827 st->codec->codec_id == CODEC_ID_SHORTEN ||
1828 (st->codec->codec_id == CODEC_ID_MPEG4 && !st->need_parsing))*/)
1829 try_decode_frame(st, pkt->data, pkt->size);
1831 if (av_rescale_q(codec_info_duration[st->index], st->time_base, AV_TIME_BASE_Q) >= ic->max_analyze_duration) {
1837 // close codecs which where opened in try_decode_frame()
1838 for(i=0;i<ic->nb_streams;i++) {
1839 st = ic->streams[i];
1840 if(st->codec->codec)
1841 avcodec_close(st->codec);
1843 for(i=0;i<ic->nb_streams;i++) {
1844 st = ic->streams[i];
1845 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1846 if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_sample)
1847 st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
1849 if(duration_count[i]
1850 && (st->codec->time_base.num*101LL <= st->codec->time_base.den || st->codec->codec_id == CODEC_ID_MPEG2VIDEO) /*&&
1851 //FIXME we should not special case mpeg2, but this needs testing with non mpeg2 ...
1852 st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den*/){
1853 double best_error= 2*av_q2d(st->time_base);
1854 best_error= best_error*best_error*duration_count[i]*1000*12*30;
1856 for(j=1; j<MAX_STD_TIMEBASES; j++){
1857 double error= duration_error[i][j] * get_std_framerate(j);
1858 // if(st->codec->codec_type == CODEC_TYPE_VIDEO)
1859 // av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
1860 if(error < best_error){
1862 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, get_std_framerate(j), 12*1001, INT_MAX);
1867 if (!st->r_frame_rate.num){
1868 if( st->codec->time_base.den * (int64_t)st->time_base.num
1869 <= st->codec->time_base.num * (int64_t)st->time_base.den){
1870 st->r_frame_rate.num = st->codec->time_base.den;
1871 st->r_frame_rate.den = st->codec->time_base.num;
1873 st->r_frame_rate.num = st->time_base.den;
1874 st->r_frame_rate.den = st->time_base.num;
1877 }else if(st->codec->codec_type == CODEC_TYPE_AUDIO) {
1878 if(!st->codec->bits_per_sample)
1879 st->codec->bits_per_sample= av_get_bits_per_sample(st->codec->codec_id);
1883 av_estimate_timings(ic, old_offset);
1885 /* correct DTS for b frame streams with no timestamps */
1886 for(i=0;i<ic->nb_streams;i++) {
1887 st = ic->streams[i];
1888 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1890 ppktl = &ic->packet_buffer;
1892 if(ppkt1->stream_index != i)
1894 if(ppkt1->pkt->dts < 0)
1896 if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
1898 ppkt1->pkt->dts -= delta;
1903 st->cur_dts -= delta;
1909 av_free(duration_error);
1914 /*******************************************************/
1916 int av_read_play(AVFormatContext *s)
1918 if (!s->iformat->read_play)
1919 return AVERROR_NOTSUPP;
1920 return s->iformat->read_play(s);
1923 int av_read_pause(AVFormatContext *s)
1925 if (!s->iformat->read_pause)
1926 return AVERROR_NOTSUPP;
1927 return s->iformat->read_pause(s);
1930 void av_close_input_file(AVFormatContext *s)
1932 int i, must_open_file;
1935 /* free previous packet */
1936 if (s->cur_st && s->cur_st->parser)
1937 av_free_packet(&s->cur_pkt);
1939 if (s->iformat->read_close)
1940 s->iformat->read_close(s);
1941 for(i=0;i<s->nb_streams;i++) {
1942 /* free all data in a stream component */
1945 av_parser_close(st->parser);
1947 av_free(st->index_entries);
1948 av_free(st->codec->extradata);
1952 flush_packet_queue(s);
1954 if (s->iformat->flags & AVFMT_NOFILE) {
1957 if (must_open_file) {
1960 av_freep(&s->priv_data);
1964 AVStream *av_new_stream(AVFormatContext *s, int id)
1969 if (s->nb_streams >= MAX_STREAMS)
1972 st = av_mallocz(sizeof(AVStream));
1976 st->codec= avcodec_alloc_context();
1978 /* no default bitrate if decoding */
1979 st->codec->bit_rate = 0;
1981 st->index = s->nb_streams;
1983 st->start_time = AV_NOPTS_VALUE;
1984 st->duration = AV_NOPTS_VALUE;
1985 st->cur_dts = AV_NOPTS_VALUE;
1987 /* default pts settings is MPEG like */
1988 av_set_pts_info(st, 33, 1, 90000);
1989 st->last_IP_pts = AV_NOPTS_VALUE;
1990 for(i=0; i<MAX_REORDER_DELAY+1; i++)
1991 st->pts_buffer[i]= AV_NOPTS_VALUE;
1993 s->streams[s->nb_streams++] = st;
1997 /************************************************************/
1998 /* output media file */
2000 int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2004 if (s->oformat->priv_data_size > 0) {
2005 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2007 return AVERROR_NOMEM;
2009 s->priv_data = NULL;
2011 if (s->oformat->set_parameters) {
2012 ret = s->oformat->set_parameters(s, ap);
2019 int av_write_header(AVFormatContext *s)
2024 // some sanity checks
2025 for(i=0;i<s->nb_streams;i++) {
2028 switch (st->codec->codec_type) {
2029 case CODEC_TYPE_AUDIO:
2030 if(st->codec->sample_rate<=0){
2031 av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2035 case CODEC_TYPE_VIDEO:
2036 if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2037 av_log(s, AV_LOG_ERROR, "time base not set\n");
2040 if(st->codec->width<=0 || st->codec->height<=0){
2041 av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2047 if(s->oformat->codec_tag){
2048 if(st->codec->codec_tag){
2050 //check that tag + id is in the table
2051 //if neither is in the table -> ok
2052 //if tag is in the table with another id -> FAIL
2053 //if id is in the table with another tag -> FAIL unless strict < ?
2055 st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2059 if (!s->priv_data && s->oformat->priv_data_size > 0) {
2060 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2062 return AVERROR_NOMEM;
2065 if(s->oformat->write_header){
2066 ret = s->oformat->write_header(s);
2071 /* init PTS generation */
2072 for(i=0;i<s->nb_streams;i++) {
2073 int64_t den = AV_NOPTS_VALUE;
2076 switch (st->codec->codec_type) {
2077 case CODEC_TYPE_AUDIO:
2078 den = (int64_t)st->time_base.num * st->codec->sample_rate;
2080 case CODEC_TYPE_VIDEO:
2081 den = (int64_t)st->time_base.num * st->codec->time_base.den;
2086 if (den != AV_NOPTS_VALUE) {
2088 return AVERROR_INVALIDDATA;
2089 av_frac_init(&st->pts, 0, 0, den);
2095 //FIXME merge with compute_pkt_fields
2096 static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
2097 int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2098 int num, den, frame_size, i;
2100 // 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);
2102 /* if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2105 /* duration field */
2106 if (pkt->duration == 0) {
2107 compute_frame_duration(&num, &den, st, NULL, pkt);
2109 pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
2113 //XXX/FIXME this is a temporary hack until all encoders output pts
2114 if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2116 // pkt->pts= st->cur_dts;
2117 pkt->pts= st->pts.val;
2120 //calculate dts from pts
2121 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE){
2122 st->pts_buffer[0]= pkt->pts;
2123 for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2124 st->pts_buffer[i]= (i-delay-1) * pkt->duration;
2125 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2126 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2128 pkt->dts= st->pts_buffer[0];
2131 if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2132 av_log(NULL, AV_LOG_ERROR, "error, non monotone timestamps %"PRId64" >= %"PRId64"\n", st->cur_dts, pkt->dts);
2135 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2136 av_log(NULL, AV_LOG_ERROR, "error, pts < dts\n");
2140 // av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2141 st->cur_dts= pkt->dts;
2142 st->pts.val= pkt->dts;
2145 switch (st->codec->codec_type) {
2146 case CODEC_TYPE_AUDIO:
2147 frame_size = get_audio_frame_size(st->codec, pkt->size);
2149 /* HACK/FIXME, we skip the initial 0-size packets as they are most likely equal to the encoder delay,
2150 but it would be better if we had the real timestamps from the encoder */
2151 if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2152 av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2155 case CODEC_TYPE_VIDEO:
2156 av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2164 static void truncate_ts(AVStream *st, AVPacket *pkt){
2165 int64_t pts_mask = (2LL << (st->pts_wrap_bits-1)) - 1;
2168 // pkt->dts= 0; //this happens for low_delay=0 and b frames, FIXME, needs further invstigation about what we should do here
2170 if (pkt->pts != AV_NOPTS_VALUE)
2171 pkt->pts &= pts_mask;
2172 if (pkt->dts != AV_NOPTS_VALUE)
2173 pkt->dts &= pts_mask;
2176 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2180 ret=compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2181 if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2184 truncate_ts(s->streams[pkt->stream_index], pkt);
2186 ret= s->oformat->write_packet(s, pkt);
2188 ret= url_ferror(&s->pb);
2192 int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2193 AVPacketList *pktl, **next_point, *this_pktl;
2195 int streams[MAX_STREAMS];
2198 AVStream *st= s->streams[ pkt->stream_index];
2200 // assert(pkt->destruct != av_destruct_packet); //FIXME
2202 this_pktl = av_mallocz(sizeof(AVPacketList));
2203 this_pktl->pkt= *pkt;
2204 if(pkt->destruct == av_destruct_packet)
2205 pkt->destruct= NULL; // non shared -> must keep original from being freed
2207 av_dup_packet(&this_pktl->pkt); //shared -> must dup
2209 next_point = &s->packet_buffer;
2211 AVStream *st2= s->streams[ (*next_point)->pkt.stream_index];
2212 int64_t left= st2->time_base.num * (int64_t)st ->time_base.den;
2213 int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2214 if((*next_point)->pkt.dts * left > pkt->dts * right) //FIXME this can overflow
2216 next_point= &(*next_point)->next;
2218 this_pktl->next= *next_point;
2219 *next_point= this_pktl;
2222 memset(streams, 0, sizeof(streams));
2223 pktl= s->packet_buffer;
2225 //av_log(s, AV_LOG_DEBUG, "show st:%d dts:%"PRId64"\n", pktl->pkt.stream_index, pktl->pkt.dts);
2226 if(streams[ pktl->pkt.stream_index ] == 0)
2228 streams[ pktl->pkt.stream_index ]++;
2232 if(s->nb_streams == stream_count || (flush && stream_count)){
2233 pktl= s->packet_buffer;
2236 s->packet_buffer= pktl->next;
2240 av_init_packet(out);
2246 * Interleaves a AVPacket correctly so it can be muxed.
2247 * @param out the interleaved packet will be output here
2248 * @param in the input packet
2249 * @param flush 1 if no further packets are available as input and all
2250 * remaining packets should be output
2251 * @return 1 if a packet was output, 0 if no packet could be output,
2252 * < 0 if an error occured
2254 static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2255 if(s->oformat->interleave_packet)
2256 return s->oformat->interleave_packet(s, out, in, flush);
2258 return av_interleave_packet_per_dts(s, out, in, flush);
2261 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2262 AVStream *st= s->streams[ pkt->stream_index];
2264 //FIXME/XXX/HACK drop zero sized packets
2265 if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2268 //av_log(NULL, AV_LOG_DEBUG, "av_interleaved_write_frame %d %"PRId64" %"PRId64"\n", pkt->size, pkt->dts, pkt->pts);
2269 if(compute_pkt_fields2(st, pkt) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2272 if(pkt->dts == AV_NOPTS_VALUE)
2277 int ret= av_interleave_packet(s, &opkt, pkt, 0);
2278 if(ret<=0) //FIXME cleanup needed for ret<0 ?
2281 truncate_ts(s->streams[opkt.stream_index], &opkt);
2282 ret= s->oformat->write_packet(s, &opkt);
2284 av_free_packet(&opkt);
2289 if(url_ferror(&s->pb))
2290 return url_ferror(&s->pb);
2294 int av_write_trailer(AVFormatContext *s)
2300 ret= av_interleave_packet(s, &pkt, NULL, 1);
2301 if(ret<0) //FIXME cleanup needed for ret<0 ?
2306 truncate_ts(s->streams[pkt.stream_index], &pkt);
2307 ret= s->oformat->write_packet(s, &pkt);
2309 av_free_packet(&pkt);
2313 if(url_ferror(&s->pb))
2317 if(s->oformat->write_trailer)
2318 ret = s->oformat->write_trailer(s);
2321 ret=url_ferror(&s->pb);
2322 for(i=0;i<s->nb_streams;i++)
2323 av_freep(&s->streams[i]->priv_data);
2324 av_freep(&s->priv_data);
2328 /* "user interface" functions */
2330 void dump_format(AVFormatContext *ic,
2338 av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
2339 is_output ? "Output" : "Input",
2341 is_output ? ic->oformat->name : ic->iformat->name,
2342 is_output ? "to" : "from", url);
2344 av_log(NULL, AV_LOG_INFO, " Duration: ");
2345 if (ic->duration != AV_NOPTS_VALUE) {
2346 int hours, mins, secs, us;
2347 secs = ic->duration / AV_TIME_BASE;
2348 us = ic->duration % AV_TIME_BASE;
2353 av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%01d", hours, mins, secs,
2354 (10 * us) / AV_TIME_BASE);
2356 av_log(NULL, AV_LOG_INFO, "N/A");
2358 if (ic->start_time != AV_NOPTS_VALUE) {
2360 av_log(NULL, AV_LOG_INFO, ", start: ");
2361 secs = ic->start_time / AV_TIME_BASE;
2362 us = ic->start_time % AV_TIME_BASE;
2363 av_log(NULL, AV_LOG_INFO, "%d.%06d",
2364 secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
2366 av_log(NULL, AV_LOG_INFO, ", bitrate: ");
2368 av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
2370 av_log(NULL, AV_LOG_INFO, "N/A");
2372 av_log(NULL, AV_LOG_INFO, "\n");
2374 for(i=0;i<ic->nb_streams;i++) {
2375 AVStream *st = ic->streams[i];
2376 int g= ff_gcd(st->time_base.num, st->time_base.den);
2377 avcodec_string(buf, sizeof(buf), st->codec, is_output);
2378 av_log(NULL, AV_LOG_INFO, " Stream #%d.%d", index, i);
2379 /* the pid is an important information, so we display it */
2380 /* XXX: add a generic system */
2382 flags = ic->oformat->flags;
2384 flags = ic->iformat->flags;
2385 if (flags & AVFMT_SHOW_IDS) {
2386 av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
2388 if (strlen(st->language) > 0) {
2389 av_log(NULL, AV_LOG_INFO, "(%s)", st->language);
2391 av_log(NULL, AV_LOG_DEBUG, ", %d/%d", st->time_base.num/g, st->time_base.den/g);
2392 av_log(NULL, AV_LOG_INFO, ": %s", buf);
2393 if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2394 if(st->r_frame_rate.den && st->r_frame_rate.num)
2395 av_log(NULL, AV_LOG_INFO, ", %5.2f fps(r)", av_q2d(st->r_frame_rate));
2396 /* else if(st->time_base.den && st->time_base.num)
2397 av_log(NULL, AV_LOG_INFO, ", %5.2f fps(m)", 1/av_q2d(st->time_base));*/
2399 av_log(NULL, AV_LOG_INFO, ", %5.2f fps(c)", 1/av_q2d(st->codec->time_base));
2401 av_log(NULL, AV_LOG_INFO, "\n");
2408 int frame_rate, frame_rate_base;
2411 static AbvEntry frame_abvs[] = {
2412 { "ntsc", 720, 480, 30000, 1001 },
2413 { "pal", 720, 576, 25, 1 },
2414 { "qntsc", 352, 240, 30000, 1001 }, /* VCD compliant ntsc */
2415 { "qpal", 352, 288, 25, 1 }, /* VCD compliant pal */
2416 { "sntsc", 640, 480, 30000, 1001 }, /* square pixel ntsc */
2417 { "spal", 768, 576, 25, 1 }, /* square pixel pal */
2418 { "film", 352, 240, 24, 1 },
2419 { "ntsc-film", 352, 240, 24000, 1001 },
2420 { "sqcif", 128, 96, 0, 0 },
2421 { "qcif", 176, 144, 0, 0 },
2422 { "cif", 352, 288, 0, 0 },
2423 { "4cif", 704, 576, 0, 0 },
2426 int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2429 int n = sizeof(frame_abvs) / sizeof(AbvEntry);
2431 int frame_width = 0, frame_height = 0;
2434 if (!strcmp(frame_abvs[i].abv, str)) {
2435 frame_width = frame_abvs[i].width;
2436 frame_height = frame_abvs[i].height;
2442 frame_width = strtol(p, (char **)&p, 10);
2445 frame_height = strtol(p, (char **)&p, 10);
2447 if (frame_width <= 0 || frame_height <= 0)
2449 *width_ptr = frame_width;
2450 *height_ptr = frame_height;
2454 int parse_frame_rate(int *frame_rate, int *frame_rate_base, const char *arg)
2459 /* First, we check our abbreviation table */
2460 for (i = 0; i < sizeof(frame_abvs)/sizeof(*frame_abvs); ++i)
2461 if (!strcmp(frame_abvs[i].abv, arg)) {
2462 *frame_rate = frame_abvs[i].frame_rate;
2463 *frame_rate_base = frame_abvs[i].frame_rate_base;
2467 /* Then, we try to parse it as fraction */
2468 cp = strchr(arg, '/');
2470 cp = strchr(arg, ':');
2473 *frame_rate = strtol(arg, &cpp, 10);
2474 if (cpp != arg || cpp == cp)
2475 *frame_rate_base = strtol(cp+1, &cpp, 10);
2480 /* Finally we give up and parse it as double */
2481 AVRational time_base = av_d2q(strtod(arg, 0), DEFAULT_FRAME_RATE_BASE);
2482 *frame_rate_base = time_base.den;
2483 *frame_rate = time_base.num;
2485 if (!*frame_rate || !*frame_rate_base)
2491 #ifndef CONFIG_WINCE
2492 int64_t parse_date(const char *datestr, int duration)
2498 static const char *date_fmt[] = {
2502 static const char *time_fmt[] = {
2512 time_t now = time(0);
2514 len = strlen(datestr);
2516 lastch = datestr[len - 1];
2519 is_utc = (lastch == 'z' || lastch == 'Z');
2521 memset(&dt, 0, sizeof(dt));
2526 for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
2527 q = small_strptime(p, date_fmt[i], &dt);
2537 dt = *localtime(&now);
2539 dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
2544 if (*p == 'T' || *p == 't' || *p == ' ')
2547 for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
2548 q = small_strptime(p, time_fmt[i], &dt);
2558 q = small_strptime(p, time_fmt[0], &dt);
2560 dt.tm_sec = strtol(p, (char **)&q, 10);
2566 /* Now we have all the fields that we can get */
2571 return now * INT64_C(1000000);
2575 t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2577 dt.tm_isdst = -1; /* unknown */
2590 for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
2593 val += n * (*q - '0');
2597 return negative ? -t : t;
2599 #endif /* CONFIG_WINCE */
2601 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
2611 while (*p != '\0' && *p != '=' && *p != '&') {
2612 if ((q - tag) < sizeof(tag) - 1)
2620 while (*p != '&' && *p != '\0') {
2621 if ((q - arg) < arg_size - 1) {
2631 if (!strcmp(tag, tag1))
2640 int av_get_frame_filename(char *buf, int buf_size,
2641 const char *path, int number)
2644 char *q, buf1[20], c;
2645 int nd, len, percentd_found;
2657 while (isdigit(*p)) {
2658 nd = nd * 10 + *p++ - '0';
2661 } while (isdigit(c));
2670 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
2672 if ((q - buf + len) > buf_size - 1)
2674 memcpy(q, buf1, len);
2682 if ((q - buf) < buf_size - 1)
2686 if (!percentd_found)
2695 static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
2698 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
2700 for(i=0;i<size;i+=16) {
2707 PRINT(" %02x", buf[i+j]);
2712 for(j=0;j<len;j++) {
2714 if (c < ' ' || c > '~')
2723 void av_hex_dump(FILE *f, uint8_t *buf, int size)
2725 hex_dump_internal(NULL, f, 0, buf, size);
2728 void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
2730 hex_dump_internal(avcl, NULL, level, buf, size);
2733 //FIXME needs to know the time_base
2734 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload)
2736 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
2737 PRINT("stream #%d:\n", pkt->stream_index);
2738 PRINT(" keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
2739 PRINT(" duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
2740 /* DTS is _always_ valid after av_read_frame() */
2742 if (pkt->dts == AV_NOPTS_VALUE)
2745 PRINT("%0.3f", (double)pkt->dts / AV_TIME_BASE);
2746 /* PTS may be not known if B frames are present */
2748 if (pkt->pts == AV_NOPTS_VALUE)
2751 PRINT("%0.3f", (double)pkt->pts / AV_TIME_BASE);
2753 PRINT(" size=%d\n", pkt->size);
2756 av_hex_dump(f, pkt->data, pkt->size);
2759 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
2761 pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
2764 void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
2766 pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
2769 void url_split(char *proto, int proto_size,
2770 char *authorization, int authorization_size,
2771 char *hostname, int hostname_size,
2773 char *path, int path_size,
2784 while (*p != ':' && *p != '\0') {
2785 if ((q - proto) < proto_size - 1)
2791 if (authorization_size > 0)
2792 authorization[0] = '\0';
2796 if (hostname_size > 0)
2800 char *at,*slash; // PETR: position of '@' character and '/' character
2807 at = strchr(p,'@'); // PETR: get the position of '@'
2808 slash = strchr(p,'/'); // PETR: get position of '/' - end of hostname
2809 if (at && slash && at > slash) at = NULL; // PETR: not interested in '@' behind '/'
2811 q = at ? authorization : hostname; // PETR: if '@' exists starting with auth.
2813 while ((at || *p != ':') && *p != '/' && *p != '?' && *p != '\0') { // PETR:
2814 if (*p == '@') { // PETR: passed '@'
2815 if (authorization_size > 0)
2819 } else if (!at) { // PETR: hostname
2820 if ((q - hostname) < hostname_size - 1)
2823 if ((q - authorization) < authorization_size - 1)
2828 if (hostname_size > 0)
2832 port = strtoul(p, (char **)&p, 10);
2837 pstrcpy(path, path_size, p);
2840 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
2841 int pts_num, int pts_den)
2843 s->pts_wrap_bits = pts_wrap_bits;
2844 s->time_base.num = pts_num;
2845 s->time_base.den = pts_den;
2848 /* fraction handling */
2851 * f = val + (num / den) + 0.5.
2853 * 'num' is normalized so that it is such as 0 <= num < den.
2855 * @param f fractional number
2856 * @param val integer value
2857 * @param num must be >= 0
2858 * @param den must be >= 1
2860 static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
2873 * Fractionnal addition to f: f = f + (incr / f->den).
2875 * @param f fractional number
2876 * @param incr increment, can be positive or negative
2878 static void av_frac_add(AVFrac *f, int64_t incr)
2882 num = f->num + incr;
2885 f->val += num / den;
2891 } else if (num >= den) {
2892 f->val += num / den;