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 static AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
242 AVInputFormat *fmt1, *fmt;
246 for(fmt1 = first_iformat; fmt1 != NULL; fmt1 = fmt1->next) {
247 if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
250 if (fmt1->read_probe) {
251 score = fmt1->read_probe(pd);
252 } else if (fmt1->extensions) {
253 if (match_ext(pd->filename, fmt1->extensions)) {
257 if (score > *score_max) {
265 AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
267 return av_probe_input_format2(pd, is_opened, &score);
270 /************************************************************/
271 /* input media file */
274 * Open a media file from an IO stream. 'fmt' must be specified.
276 static const char* format_to_name(void* ptr)
278 AVFormatContext* fc = (AVFormatContext*) ptr;
279 if(fc->iformat) return fc->iformat->name;
280 else if(fc->oformat) return fc->oformat->name;
284 #define OFFSET(x) offsetof(AVFormatContext,x)
285 #define DEFAULT 0 //should be NAN but it doesnt work as its not a constant in glibc as required by ANSI/ISO C
286 //these names are too long to be readable
287 #define E AV_OPT_FLAG_ENCODING_PARAM
288 #define D AV_OPT_FLAG_DECODING_PARAM
290 static const AVOption options[]={
291 {"probesize", NULL, OFFSET(probesize), FF_OPT_TYPE_INT, 32000, 32, INT_MAX, D}, /* 32000 from mpegts.c: 1.0 second at 24Mbit/s */
292 {"muxrate", "set mux rate", OFFSET(mux_rate), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
293 {"packetsize", "set packet size", OFFSET(packet_size), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
294 {"fflags", NULL, OFFSET(flags), FF_OPT_TYPE_FLAGS, DEFAULT, INT_MIN, INT_MAX, D|E, "fflags"},
295 {"ignidx", "ignore index", 0, FF_OPT_TYPE_CONST, AVFMT_FLAG_IGNIDX, INT_MIN, INT_MAX, D, "fflags"},
296 {"genpts", "generate pts", 0, FF_OPT_TYPE_CONST, AVFMT_FLAG_GENPTS, INT_MIN, INT_MAX, D, "fflags"},
297 {"track", " set the track number", OFFSET(track), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
298 {"year", "set the year", OFFSET(year), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, E},
299 {"analyzeduration", "how many microseconds are analyzed to estimate duration", OFFSET(max_analyze_duration), FF_OPT_TYPE_INT, 3*AV_TIME_BASE, 0, INT_MAX, D},
307 static const AVClass av_format_context_class = { "AVFormatContext", format_to_name, options };
309 static void avformat_get_context_defaults(AVFormatContext *s)
311 memset(s, 0, sizeof(AVFormatContext));
313 s->av_class = &av_format_context_class;
315 av_opt_set_defaults(s);
318 AVFormatContext *av_alloc_format_context(void)
321 ic = av_malloc(sizeof(AVFormatContext));
323 avformat_get_context_defaults(ic);
324 ic->av_class = &av_format_context_class;
328 int av_open_input_stream(AVFormatContext **ic_ptr,
329 ByteIOContext *pb, const char *filename,
330 AVInputFormat *fmt, AVFormatParameters *ap)
334 AVFormatParameters default_ap;
338 memset(ap, 0, sizeof(default_ap));
341 if(!ap->prealloced_context)
342 ic = av_alloc_format_context();
352 ic->duration = AV_NOPTS_VALUE;
353 ic->start_time = AV_NOPTS_VALUE;
354 pstrcpy(ic->filename, sizeof(ic->filename), filename);
356 /* allocate private data */
357 if (fmt->priv_data_size > 0) {
358 ic->priv_data = av_mallocz(fmt->priv_data_size);
359 if (!ic->priv_data) {
364 ic->priv_data = NULL;
367 err = ic->iformat->read_header(ic, ap);
371 if (pb && !ic->data_offset)
372 ic->data_offset = url_ftell(&ic->pb);
378 av_freep(&ic->priv_data);
385 /** Size of probe buffer, for guessing file type from file contents. */
386 #define PROBE_BUF_MIN 2048
387 #define PROBE_BUF_MAX (1<<20)
389 int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
392 AVFormatParameters *ap)
394 int err, must_open_file, file_opened, probe_size;
395 AVProbeData probe_data, *pd = &probe_data;
396 ByteIOContext pb1, *pb = &pb1;
401 pd->filename = filename;
406 /* guess format if no file can be opened */
407 fmt = av_probe_input_format(pd, 0);
410 /* do not open file if the format does not need it. XXX: specific
411 hack needed to handle RTSP/TCP */
413 if (fmt && (fmt->flags & AVFMT_NOFILE)) {
415 pb= NULL; //FIXME this or memset(pb, 0, sizeof(ByteIOContext)); otherwise its uninitalized
418 if (!fmt || must_open_file) {
419 /* if no file needed do not try to open one */
420 if (url_fopen(pb, filename, URL_RDONLY) < 0) {
426 url_setbufsize(pb, buf_size);
429 for(probe_size= PROBE_BUF_MIN; probe_size<=PROBE_BUF_MAX && !fmt; probe_size<<=1){
430 int score= probe_size < PROBE_BUF_MAX ? AVPROBE_SCORE_MAX/4 : 0;
431 /* read probe data */
432 pd->buf= av_realloc(pd->buf, probe_size + AVPROBE_PADDING_SIZE);
433 pd->buf_size = get_buffer(pb, pd->buf, probe_size);
434 if (url_fseek(pb, 0, SEEK_SET) < 0) {
436 if (url_fopen(pb, filename, URL_RDONLY) < 0) {
442 /* guess file format */
443 fmt = av_probe_input_format2(pd, 1, &score);
448 /* if still no format found, error */
454 /* XXX: suppress this hack for redirectors */
455 #ifdef CONFIG_NETWORK
456 if (fmt == &redir_demuxer) {
457 err = redir_open(ic_ptr, pb);
463 /* check filename in case of an image number is expected */
464 if (fmt->flags & AVFMT_NEEDNUMBER) {
465 if (!av_filename_number_test(filename)) {
466 err = AVERROR_NUMEXPECTED;
470 err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
483 /*******************************************************/
485 int av_read_packet(AVFormatContext *s, AVPacket *pkt)
488 return s->iformat->read_packet(s, pkt);
491 /**********************************************************/
494 * Get the number of samples of an audio frame. Return (-1) if error.
496 static int get_audio_frame_size(AVCodecContext *enc, int size)
500 if (enc->frame_size <= 1) {
501 int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
503 if (bits_per_sample) {
504 if (enc->channels == 0)
506 frame_size = (size << 3) / (bits_per_sample * enc->channels);
508 /* used for example by ADPCM codecs */
509 if (enc->bit_rate == 0)
511 frame_size = (size * 8 * enc->sample_rate) / enc->bit_rate;
514 frame_size = enc->frame_size;
521 * Return the frame duration in seconds, return 0 if not available.
523 static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
524 AVCodecParserContext *pc, AVPacket *pkt)
530 switch(st->codec->codec_type) {
531 case CODEC_TYPE_VIDEO:
532 if(st->time_base.num*1000LL > st->time_base.den){
533 *pnum = st->time_base.num;
534 *pden = st->time_base.den;
535 }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
536 *pnum = st->codec->time_base.num;
537 *pden = st->codec->time_base.den;
538 if (pc && pc->repeat_pict) {
540 *pnum = (*pnum) * (2 + pc->repeat_pict);
544 case CODEC_TYPE_AUDIO:
545 frame_size = get_audio_frame_size(st->codec, pkt->size);
549 *pden = st->codec->sample_rate;
556 static int is_intra_only(AVCodecContext *enc){
557 if(enc->codec_type == CODEC_TYPE_AUDIO){
559 }else if(enc->codec_type == CODEC_TYPE_VIDEO){
560 switch(enc->codec_id){
562 case CODEC_ID_MJPEGB:
564 case CODEC_ID_RAWVIDEO:
565 case CODEC_ID_DVVIDEO:
566 case CODEC_ID_HUFFYUV:
567 case CODEC_ID_FFVHUFF:
578 static int64_t lsb2full(int64_t lsb, int64_t last_ts, int lsb_bits){
579 int64_t mask = lsb_bits < 64 ? (1LL<<lsb_bits)-1 : -1LL;
580 int64_t delta= last_ts - mask/2;
581 return ((lsb - delta)&mask) + delta;
584 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
585 AVCodecParserContext *pc, AVPacket *pkt)
587 int num, den, presentation_delayed, delay, i;
589 /* handle wrapping */
590 if(st->cur_dts != AV_NOPTS_VALUE){
591 if(pkt->pts != AV_NOPTS_VALUE)
592 pkt->pts= lsb2full(pkt->pts, st->cur_dts, st->pts_wrap_bits);
593 if(pkt->dts != AV_NOPTS_VALUE)
594 pkt->dts= lsb2full(pkt->dts, st->cur_dts, st->pts_wrap_bits);
597 if (pkt->duration == 0) {
598 compute_frame_duration(&num, &den, st, pc, pkt);
600 pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
604 /* correct timestamps with byte offset if demuxers only have timestamps on packet boundaries */
605 if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
606 /* this will estimate bitrate based on this frame's duration and size */
607 offset = av_rescale(pc->offset, pkt->duration, pkt->size);
608 if(pkt->pts != AV_NOPTS_VALUE)
610 if(pkt->dts != AV_NOPTS_VALUE)
614 if(is_intra_only(st->codec))
615 pkt->flags |= PKT_FLAG_KEY;
617 /* do we have a video B frame ? */
618 delay= st->codec->has_b_frames;
619 presentation_delayed = 0;
620 /* XXX: need has_b_frame, but cannot get it if the codec is
623 pc && pc->pict_type != FF_B_TYPE)
624 presentation_delayed = 1;
625 /* this may be redundant, but it shouldnt hurt */
626 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
627 presentation_delayed = 1;
629 if(st->cur_dts == AV_NOPTS_VALUE){
630 st->cur_dts = -delay * pkt->duration;
633 // 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);
634 /* interpolate PTS and DTS if they are not present */
636 if (presentation_delayed) {
637 /* DTS = decompression time stamp */
638 /* PTS = presentation time stamp */
639 if (pkt->dts == AV_NOPTS_VALUE)
640 pkt->dts = st->last_IP_pts;
641 if (pkt->dts == AV_NOPTS_VALUE)
642 pkt->dts = st->cur_dts;
644 /* this is tricky: the dts must be incremented by the duration
645 of the frame we are displaying, i.e. the last I or P frame */
646 if (st->last_IP_duration == 0)
647 st->last_IP_duration = pkt->duration;
648 st->cur_dts = pkt->dts + st->last_IP_duration;
649 st->last_IP_duration = pkt->duration;
650 st->last_IP_pts= pkt->pts;
651 /* cannot compute PTS if not present (we can compute it only
652 by knowing the futur */
653 } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
654 if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
655 int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
656 int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
657 if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
658 pkt->pts += pkt->duration;
659 // 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);
663 /* presentation is not delayed : PTS and DTS are the same */
664 if(pkt->pts == AV_NOPTS_VALUE)
666 if(pkt->pts == AV_NOPTS_VALUE)
667 pkt->pts = st->cur_dts;
669 st->cur_dts = pkt->pts + pkt->duration;
673 if(pkt->pts != AV_NOPTS_VALUE){
674 st->pts_buffer[0]= pkt->pts;
675 for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
676 st->pts_buffer[i]= (i-delay-1) * pkt->duration;
677 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
678 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
679 if(pkt->dts == AV_NOPTS_VALUE)
680 pkt->dts= st->pts_buffer[0];
681 if(pkt->dts > st->cur_dts)
682 st->cur_dts = pkt->dts;
685 // 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);
690 /* key frame computation */
691 if (pc->pict_type == FF_I_TYPE)
692 pkt->flags |= PKT_FLAG_KEY;
696 void av_destruct_packet_nofree(AVPacket *pkt)
698 pkt->data = NULL; pkt->size = 0;
701 static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
709 /* select current input stream component */
712 if (!st->need_parsing || !st->parser) {
713 /* no parsing needed: we just output the packet as is */
714 /* raw data support */
716 compute_pkt_fields(s, st, NULL, pkt);
719 } else if (s->cur_len > 0 && st->discard < AVDISCARD_ALL) {
720 len = av_parser_parse(st->parser, st->codec, &pkt->data, &pkt->size,
721 s->cur_ptr, s->cur_len,
722 s->cur_pkt.pts, s->cur_pkt.dts);
723 s->cur_pkt.pts = AV_NOPTS_VALUE;
724 s->cur_pkt.dts = AV_NOPTS_VALUE;
725 /* increment read pointer */
729 /* return packet if any */
733 pkt->stream_index = st->index;
734 pkt->pts = st->parser->pts;
735 pkt->dts = st->parser->dts;
736 pkt->destruct = av_destruct_packet_nofree;
737 compute_pkt_fields(s, st, st->parser, pkt);
739 if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & PKT_FLAG_KEY){
740 av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
741 0, 0, AVINDEX_KEYFRAME);
748 av_free_packet(&s->cur_pkt);
752 /* read next packet */
753 ret = av_read_packet(s, &s->cur_pkt);
755 if (ret == AVERROR(EAGAIN))
757 /* return the last frames, if any */
758 for(i = 0; i < s->nb_streams; i++) {
760 if (st->parser && st->need_parsing) {
761 av_parser_parse(st->parser, st->codec,
762 &pkt->data, &pkt->size,
764 AV_NOPTS_VALUE, AV_NOPTS_VALUE);
769 /* no more packets: really terminates parsing */
773 st = s->streams[s->cur_pkt.stream_index];
774 if(st->codec->debug & FF_DEBUG_PTS)
775 av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
776 s->cur_pkt.stream_index,
782 s->cur_ptr = s->cur_pkt.data;
783 s->cur_len = s->cur_pkt.size;
784 if (st->need_parsing && !st->parser) {
785 st->parser = av_parser_init(st->codec->codec_id);
787 /* no parser available : just output the raw packets */
788 st->need_parsing = AVSTREAM_PARSE_NONE;
789 }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
790 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
792 if(st->parser && (s->iformat->flags & AVFMT_GENERIC_INDEX)){
793 st->parser->last_frame_offset=
794 st->parser->cur_offset= s->cur_pkt.pos;
799 if(st->codec->debug & FF_DEBUG_PTS)
800 av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
809 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
813 const int genpts= s->flags & AVFMT_FLAG_GENPTS;
816 pktl = s->packet_buffer;
818 AVPacket *next_pkt= &pktl->pkt;
820 if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
821 while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
822 if( pktl->pkt.stream_index == next_pkt->stream_index
823 && next_pkt->dts < pktl->pkt.dts
824 && pktl->pkt.pts != pktl->pkt.dts //not b frame
825 /*&& pktl->pkt.dts != AV_NOPTS_VALUE*/){
826 next_pkt->pts= pktl->pkt.dts;
830 pktl = s->packet_buffer;
833 if( next_pkt->pts != AV_NOPTS_VALUE
834 || next_pkt->dts == AV_NOPTS_VALUE
836 /* read packet from packet buffer, if there is data */
838 s->packet_buffer = pktl->next;
844 AVPacketList **plast_pktl= &s->packet_buffer;
845 int ret= av_read_frame_internal(s, pkt);
847 if(pktl && ret != AVERROR(EAGAIN)){
854 /* duplicate the packet */
855 if (av_dup_packet(pkt) < 0)
856 return AVERROR_NOMEM;
858 while(*plast_pktl) plast_pktl= &(*plast_pktl)->next; //FIXME maybe maintain pointer to the last?
860 pktl = av_mallocz(sizeof(AVPacketList));
862 return AVERROR_NOMEM;
864 /* add the packet in the buffered packet list */
868 assert(!s->packet_buffer);
869 return av_read_frame_internal(s, pkt);
874 /* XXX: suppress the packet queue */
875 static void flush_packet_queue(AVFormatContext *s)
880 pktl = s->packet_buffer;
883 s->packet_buffer = pktl->next;
884 av_free_packet(&pktl->pkt);
889 /*******************************************************/
892 int av_find_default_stream_index(AVFormatContext *s)
897 if (s->nb_streams <= 0)
899 for(i = 0; i < s->nb_streams; i++) {
901 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
909 * Flush the frame reader.
911 static void av_read_frame_flush(AVFormatContext *s)
916 flush_packet_queue(s);
918 /* free previous packet */
920 if (s->cur_st->parser)
921 av_free_packet(&s->cur_pkt);
928 /* for each stream, reset read state */
929 for(i = 0; i < s->nb_streams; i++) {
933 av_parser_close(st->parser);
936 st->last_IP_pts = AV_NOPTS_VALUE;
937 st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
941 void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
944 for(i = 0; i < s->nb_streams; i++) {
945 AVStream *st = s->streams[i];
947 st->cur_dts = av_rescale(timestamp,
948 st->time_base.den * (int64_t)ref_st->time_base.num,
949 st->time_base.num * (int64_t)ref_st->time_base.den);
953 int av_add_index_entry(AVStream *st,
954 int64_t pos, int64_t timestamp, int size, int distance, int flags)
956 AVIndexEntry *entries, *ie;
959 if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
962 entries = av_fast_realloc(st->index_entries,
963 &st->index_entries_allocated_size,
964 (st->nb_index_entries + 1) *
965 sizeof(AVIndexEntry));
969 st->index_entries= entries;
971 index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
974 index= st->nb_index_entries++;
976 assert(index==0 || ie[-1].timestamp < timestamp);
979 if(ie->timestamp != timestamp){
980 if(ie->timestamp <= timestamp)
982 memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
983 st->nb_index_entries++;
984 }else if(ie->pos == pos && distance < ie->min_distance) //dont reduce the distance
985 distance= ie->min_distance;
989 ie->timestamp = timestamp;
990 ie->min_distance= distance;
998 * build an index for raw streams using a parser.
1000 static void av_build_index_raw(AVFormatContext *s)
1002 AVPacket pkt1, *pkt = &pkt1;
1007 av_read_frame_flush(s);
1008 url_fseek(&s->pb, s->data_offset, SEEK_SET);
1011 ret = av_read_frame(s, pkt);
1014 if (pkt->stream_index == 0 && st->parser &&
1015 (pkt->flags & PKT_FLAG_KEY)) {
1016 av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
1017 0, 0, AVINDEX_KEYFRAME);
1019 av_free_packet(pkt);
1024 * Returns TRUE if we deal with a raw stream.
1026 * Raw codec data and parsing needed.
1028 static int is_raw_stream(AVFormatContext *s)
1032 if (s->nb_streams != 1)
1035 if (!st->need_parsing)
1040 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1043 AVIndexEntry *entries= st->index_entries;
1044 int nb_entries= st->nb_index_entries;
1053 timestamp = entries[m].timestamp;
1054 if(timestamp >= wanted_timestamp)
1056 if(timestamp <= wanted_timestamp)
1059 m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1061 if(!(flags & AVSEEK_FLAG_ANY)){
1062 while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1063 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1074 int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1075 AVInputFormat *avif= s->iformat;
1076 int64_t pos_min, pos_max, pos, pos_limit;
1077 int64_t ts_min, ts_max, ts;
1081 if (stream_index < 0)
1085 av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1089 ts_min= AV_NOPTS_VALUE;
1090 pos_limit= -1; //gcc falsely says it may be uninitalized
1092 st= s->streams[stream_index];
1093 if(st->index_entries){
1096 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()
1097 index= FFMAX(index, 0);
1098 e= &st->index_entries[index];
1100 if(e->timestamp <= target_ts || e->pos == e->min_distance){
1102 ts_min= e->timestamp;
1104 av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1111 index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1112 assert(index < st->nb_index_entries);
1114 e= &st->index_entries[index];
1115 assert(e->timestamp >= target_ts);
1117 ts_max= e->timestamp;
1118 pos_limit= pos_max - e->min_distance;
1120 av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1121 pos_max,pos_limit, ts_max);
1126 pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1131 url_fseek(&s->pb, pos, SEEK_SET);
1133 av_update_cur_dts(s, st, ts);
1138 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 )){
1140 int64_t start_pos, filesize;
1144 av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1147 if(ts_min == AV_NOPTS_VALUE){
1148 pos_min = s->data_offset;
1149 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1150 if (ts_min == AV_NOPTS_VALUE)
1154 if(ts_max == AV_NOPTS_VALUE){
1156 filesize = url_fsize(&s->pb);
1157 pos_max = filesize - 1;
1160 ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1162 }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1163 if (ts_max == AV_NOPTS_VALUE)
1167 int64_t tmp_pos= pos_max + 1;
1168 int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1169 if(tmp_ts == AV_NOPTS_VALUE)
1173 if(tmp_pos >= filesize)
1179 if(ts_min > ts_max){
1181 }else if(ts_min == ts_max){
1186 while (pos_min < pos_limit) {
1188 av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1192 assert(pos_limit <= pos_max);
1195 int64_t approximate_keyframe_distance= pos_max - pos_limit;
1196 // interpolate position (better than dichotomy)
1197 pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1198 + pos_min - approximate_keyframe_distance;
1199 }else if(no_change==1){
1200 // bisection, if interpolation failed to change min or max pos last time
1201 pos = (pos_min + pos_limit)>>1;
1203 // linear search if bisection failed, can only happen if there are very few or no keframes between min/max
1208 else if(pos > pos_limit)
1212 ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1218 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);
1220 assert(ts != AV_NOPTS_VALUE);
1221 if (target_ts <= ts) {
1222 pos_limit = start_pos - 1;
1226 if (target_ts >= ts) {
1232 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1233 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
1236 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1238 ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1239 av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1240 pos, ts_min, target_ts, ts_max);
1246 static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1247 int64_t pos_min, pos_max;
1251 if (stream_index < 0)
1254 st= s->streams[stream_index];
1257 pos_min = s->data_offset;
1258 pos_max = url_fsize(&s->pb) - 1;
1260 if (pos < pos_min) pos= pos_min;
1261 else if(pos > pos_max) pos= pos_max;
1263 url_fseek(&s->pb, pos, SEEK_SET);
1266 av_update_cur_dts(s, st, ts);
1271 static int av_seek_frame_generic(AVFormatContext *s,
1272 int stream_index, int64_t timestamp, int flags)
1278 st = s->streams[stream_index];
1280 index = av_index_search_timestamp(st, timestamp, flags);
1286 if(st->index_entries && st->nb_index_entries){
1287 ie= &st->index_entries[st->nb_index_entries-1];
1288 url_fseek(&s->pb, ie->pos, SEEK_SET);
1289 av_update_cur_dts(s, st, ie->timestamp);
1291 url_fseek(&s->pb, 0, SEEK_SET);
1294 int ret = av_read_frame(s, &pkt);
1297 av_free_packet(&pkt);
1298 if(stream_index == pkt.stream_index){
1299 if((pkt.flags & PKT_FLAG_KEY) && pkt.dts > timestamp)
1303 index = av_index_search_timestamp(st, timestamp, flags);
1308 av_read_frame_flush(s);
1309 if (s->iformat->read_seek){
1310 if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1313 ie = &st->index_entries[index];
1314 url_fseek(&s->pb, ie->pos, SEEK_SET);
1316 av_update_cur_dts(s, st, ie->timestamp);
1321 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1326 av_read_frame_flush(s);
1328 if(flags & AVSEEK_FLAG_BYTE)
1329 return av_seek_frame_byte(s, stream_index, timestamp, flags);
1331 if(stream_index < 0){
1332 stream_index= av_find_default_stream_index(s);
1333 if(stream_index < 0)
1336 st= s->streams[stream_index];
1337 /* timestamp for default must be expressed in AV_TIME_BASE units */
1338 timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1340 st= s->streams[stream_index];
1342 /* first, we try the format specific seek */
1343 if (s->iformat->read_seek)
1344 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1351 if(s->iformat->read_timestamp)
1352 return av_seek_frame_binary(s, stream_index, timestamp, flags);
1354 return av_seek_frame_generic(s, stream_index, timestamp, flags);
1357 /*******************************************************/
1360 * Returns TRUE if the stream has accurate timings in any stream.
1362 * @return TRUE if the stream has accurate timings for at least one component.
1364 static int av_has_timings(AVFormatContext *ic)
1369 for(i = 0;i < ic->nb_streams; i++) {
1370 st = ic->streams[i];
1371 if (st->start_time != AV_NOPTS_VALUE &&
1372 st->duration != AV_NOPTS_VALUE)
1379 * Estimate the stream timings from the one of each components.
1381 * Also computes the global bitrate if possible.
1383 static void av_update_stream_timings(AVFormatContext *ic)
1385 int64_t start_time, start_time1, end_time, end_time1;
1389 start_time = INT64_MAX;
1390 end_time = INT64_MIN;
1391 for(i = 0;i < ic->nb_streams; i++) {
1392 st = ic->streams[i];
1393 if (st->start_time != AV_NOPTS_VALUE) {
1394 start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1395 if (start_time1 < start_time)
1396 start_time = start_time1;
1397 if (st->duration != AV_NOPTS_VALUE) {
1398 end_time1 = start_time1
1399 + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1400 if (end_time1 > end_time)
1401 end_time = end_time1;
1405 if (start_time != INT64_MAX) {
1406 ic->start_time = start_time;
1407 if (end_time != INT64_MIN) {
1408 ic->duration = end_time - start_time;
1409 if (ic->file_size > 0) {
1410 /* compute the bit rate */
1411 ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1412 (double)ic->duration;
1419 static void fill_all_stream_timings(AVFormatContext *ic)
1424 av_update_stream_timings(ic);
1425 for(i = 0;i < ic->nb_streams; i++) {
1426 st = ic->streams[i];
1427 if (st->start_time == AV_NOPTS_VALUE) {
1428 if(ic->start_time != AV_NOPTS_VALUE)
1429 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1430 if(ic->duration != AV_NOPTS_VALUE)
1431 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1436 static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1438 int64_t filesize, duration;
1442 /* if bit_rate is already set, we believe it */
1443 if (ic->bit_rate == 0) {
1445 for(i=0;i<ic->nb_streams;i++) {
1446 st = ic->streams[i];
1447 bit_rate += st->codec->bit_rate;
1449 ic->bit_rate = bit_rate;
1452 /* if duration is already set, we believe it */
1453 if (ic->duration == AV_NOPTS_VALUE &&
1454 ic->bit_rate != 0 &&
1455 ic->file_size != 0) {
1456 filesize = ic->file_size;
1458 for(i = 0; i < ic->nb_streams; i++) {
1459 st = ic->streams[i];
1460 duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1461 if (st->start_time == AV_NOPTS_VALUE ||
1462 st->duration == AV_NOPTS_VALUE) {
1464 st->duration = duration;
1471 #define DURATION_MAX_READ_SIZE 250000
1473 /* only usable for MPEG-PS streams */
1474 static void av_estimate_timings_from_pts(AVFormatContext *ic, offset_t old_offset)
1476 AVPacket pkt1, *pkt = &pkt1;
1478 int read_size, i, ret;
1480 int64_t filesize, offset, duration;
1482 av_read_frame_flush(ic);
1484 /* we read the first packets to get the first PTS (not fully
1485 accurate, but it is enough now) */
1486 url_fseek(&ic->pb, 0, SEEK_SET);
1489 if (read_size >= DURATION_MAX_READ_SIZE)
1491 /* if all info is available, we can stop */
1492 for(i = 0;i < ic->nb_streams; i++) {
1493 st = ic->streams[i];
1494 if (st->start_time == AV_NOPTS_VALUE)
1497 if (i == ic->nb_streams)
1500 ret = av_read_packet(ic, pkt);
1503 read_size += pkt->size;
1504 st = ic->streams[pkt->stream_index];
1505 if (pkt->pts != AV_NOPTS_VALUE) {
1506 if (st->start_time == AV_NOPTS_VALUE)
1507 st->start_time = pkt->pts;
1509 av_free_packet(pkt);
1512 /* estimate the end time (duration) */
1513 /* XXX: may need to support wrapping */
1514 filesize = ic->file_size;
1515 offset = filesize - DURATION_MAX_READ_SIZE;
1519 url_fseek(&ic->pb, offset, SEEK_SET);
1522 if (read_size >= DURATION_MAX_READ_SIZE)
1524 /* if all info is available, we can stop */
1525 for(i = 0;i < ic->nb_streams; i++) {
1526 st = ic->streams[i];
1527 if (st->duration == AV_NOPTS_VALUE)
1530 if (i == ic->nb_streams)
1533 ret = av_read_packet(ic, pkt);
1536 read_size += pkt->size;
1537 st = ic->streams[pkt->stream_index];
1538 if (pkt->pts != AV_NOPTS_VALUE) {
1539 end_time = pkt->pts;
1540 duration = end_time - st->start_time;
1542 if (st->duration == AV_NOPTS_VALUE ||
1543 st->duration < duration)
1544 st->duration = duration;
1547 av_free_packet(pkt);
1550 fill_all_stream_timings(ic);
1552 url_fseek(&ic->pb, old_offset, SEEK_SET);
1555 static void av_estimate_timings(AVFormatContext *ic, offset_t old_offset)
1559 /* get the file size, if possible */
1560 if (ic->iformat->flags & AVFMT_NOFILE) {
1563 file_size = url_fsize(&ic->pb);
1567 ic->file_size = file_size;
1569 if ((!strcmp(ic->iformat->name, "mpeg") ||
1570 !strcmp(ic->iformat->name, "mpegts")) &&
1571 file_size && !ic->pb.is_streamed) {
1572 /* get accurate estimate from the PTSes */
1573 av_estimate_timings_from_pts(ic, old_offset);
1574 } else if (av_has_timings(ic)) {
1575 /* at least one components has timings - we use them for all
1577 fill_all_stream_timings(ic);
1579 /* less precise: use bit rate info */
1580 av_estimate_timings_from_bit_rate(ic);
1582 av_update_stream_timings(ic);
1588 for(i = 0;i < ic->nb_streams; i++) {
1589 st = ic->streams[i];
1590 printf("%d: start_time: %0.3f duration: %0.3f\n",
1591 i, (double)st->start_time / AV_TIME_BASE,
1592 (double)st->duration / AV_TIME_BASE);
1594 printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1595 (double)ic->start_time / AV_TIME_BASE,
1596 (double)ic->duration / AV_TIME_BASE,
1597 ic->bit_rate / 1000);
1602 static int has_codec_parameters(AVCodecContext *enc)
1605 switch(enc->codec_type) {
1606 case CODEC_TYPE_AUDIO:
1607 val = enc->sample_rate;
1609 case CODEC_TYPE_VIDEO:
1610 val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
1619 static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1623 int got_picture, data_size, ret=0;
1626 if(!st->codec->codec){
1627 codec = avcodec_find_decoder(st->codec->codec_id);
1630 ret = avcodec_open(st->codec, codec);
1635 if(!has_codec_parameters(st->codec)){
1636 switch(st->codec->codec_type) {
1637 case CODEC_TYPE_VIDEO:
1638 ret = avcodec_decode_video(st->codec, &picture,
1639 &got_picture, (uint8_t *)data, size);
1641 case CODEC_TYPE_AUDIO:
1642 data_size = FFMAX(size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
1643 samples = av_malloc(data_size);
1646 ret = avcodec_decode_audio2(st->codec, samples,
1647 &data_size, (uint8_t *)data, size);
1658 static int set_codec_from_probe_data(AVStream *st, AVProbeData *pd, int score)
1661 fmt = av_probe_input_format2(pd, 1, &score);
1664 if (strncmp(fmt->name, "mp3", 3) == 0)
1665 st->codec->codec_id = CODEC_ID_MP3;
1666 else if (strncmp(fmt->name, "ac3", 3) == 0)
1667 st->codec->codec_id = CODEC_ID_AC3;
1672 /* absolute maximum size we read until we abort */
1673 #define MAX_READ_SIZE 5000000
1675 #define MAX_STD_TIMEBASES (60*12+5)
1676 static int get_std_framerate(int i){
1677 if(i<60*12) return i*1001;
1678 else return ((int[]){24,30,60,12,15})[i-60*12]*1000*12;
1681 int av_find_stream_info(AVFormatContext *ic)
1683 int i, count, ret, read_size, j;
1685 AVPacket pkt1, *pkt;
1686 AVPacketList *pktl=NULL, **ppktl;
1687 int64_t last_dts[MAX_STREAMS];
1688 int duration_count[MAX_STREAMS]={0};
1689 double (*duration_error)[MAX_STD_TIMEBASES];
1690 offset_t old_offset = url_ftell(&ic->pb);
1691 int64_t codec_info_duration[MAX_STREAMS]={0};
1692 int codec_info_nb_frames[MAX_STREAMS]={0};
1693 AVProbeData probe_data[MAX_STREAMS];
1694 int codec_identified[MAX_STREAMS]={0};
1696 duration_error = av_mallocz(MAX_STREAMS * sizeof(*duration_error));
1697 if (!duration_error) return AVERROR_NOMEM;
1699 for(i=0;i<ic->nb_streams;i++) {
1700 st = ic->streams[i];
1701 if(st->codec->codec_type == CODEC_TYPE_VIDEO){
1702 /* if(!st->time_base.num)
1704 if(!st->codec->time_base.num)
1705 st->codec->time_base= st->time_base;
1707 //only for the split stuff
1709 st->parser = av_parser_init(st->codec->codec_id);
1710 if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
1711 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1716 for(i=0;i<MAX_STREAMS;i++){
1717 last_dts[i]= AV_NOPTS_VALUE;
1720 memset(probe_data, 0, sizeof(probe_data));
1723 ppktl = &ic->packet_buffer;
1725 /* check if one codec still needs to be handled */
1726 for(i=0;i<ic->nb_streams;i++) {
1727 st = ic->streams[i];
1728 if (!has_codec_parameters(st->codec))
1730 /* variable fps and no guess at the real fps */
1731 if( (st->codec->time_base.den >= 101LL*st->codec->time_base.num || st->codec->codec_id == CODEC_ID_MPEG2VIDEO)
1732 && duration_count[i]<20 && st->codec->codec_type == CODEC_TYPE_VIDEO)
1734 if(st->parser && st->parser->parser->split && !st->codec->extradata)
1736 if (st->codec->codec_type == CODEC_TYPE_AUDIO &&
1737 st->codec->codec_id == CODEC_ID_NONE)
1740 if (i == ic->nb_streams) {
1741 /* NOTE: if the format has no header, then we need to read
1742 some packets to get most of the streams, so we cannot
1744 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
1745 /* if we found the info for all the codecs, we can stop */
1750 /* we did not get all the codec info, but we read too much data */
1751 if (read_size >= MAX_READ_SIZE) {
1756 /* NOTE: a new stream can be added there if no header in file
1757 (AVFMTCTX_NOHEADER) */
1758 ret = av_read_frame_internal(ic, &pkt1);
1761 ret = -1; /* we could not have all the codec parameters before EOF */
1762 for(i=0;i<ic->nb_streams;i++) {
1763 st = ic->streams[i];
1764 if (!has_codec_parameters(st->codec)){
1766 avcodec_string(buf, sizeof(buf), st->codec, 0);
1767 av_log(ic, AV_LOG_INFO, "Could not find codec parameters (%s)\n", buf);
1775 pktl = av_mallocz(sizeof(AVPacketList));
1777 ret = AVERROR_NOMEM;
1781 /* add the packet in the buffered packet list */
1783 ppktl = &pktl->next;
1788 /* duplicate the packet */
1789 if (av_dup_packet(pkt) < 0) {
1790 ret = AVERROR_NOMEM;
1794 read_size += pkt->size;
1796 st = ic->streams[pkt->stream_index];
1797 if(codec_info_nb_frames[st->index]>1)
1798 codec_info_duration[st->index] += pkt->duration;
1799 if (pkt->duration != 0)
1800 codec_info_nb_frames[st->index]++;
1803 int index= pkt->stream_index;
1804 int64_t last= last_dts[index];
1805 int64_t duration= pkt->dts - last;
1807 if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
1808 double dur= duration * av_q2d(st->time_base);
1810 // if(st->codec->codec_type == CODEC_TYPE_VIDEO)
1811 // av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
1812 if(duration_count[index] < 2)
1813 memset(duration_error, 0, MAX_STREAMS * sizeof(*duration_error));
1814 for(i=1; i<MAX_STD_TIMEBASES; i++){
1815 int framerate= get_std_framerate(i);
1816 int ticks= lrintf(dur*framerate/(1001*12));
1817 double error= dur - ticks*1001*12/(double)framerate;
1818 duration_error[index][i] += error*error;
1820 duration_count[index]++;
1822 if(last == AV_NOPTS_VALUE || duration_count[index]<=1)
1823 last_dts[pkt->stream_index]= pkt->dts;
1825 if (st->codec->codec_id == CODEC_ID_NONE) {
1826 AVProbeData *pd = &(probe_data[st->index]);
1827 pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size);
1828 memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
1829 pd->buf_size += pkt->size;
1832 if(st->parser && st->parser->parser->split && !st->codec->extradata){
1833 int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
1835 st->codec->extradata_size= i;
1836 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
1837 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
1838 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
1842 /* if still no information, we try to open the codec and to
1843 decompress the frame. We try to avoid that in most cases as
1844 it takes longer and uses more memory. For MPEG4, we need to
1845 decompress for Quicktime. */
1846 if (!has_codec_parameters(st->codec) /*&&
1847 (st->codec->codec_id == CODEC_ID_FLV1 ||
1848 st->codec->codec_id == CODEC_ID_H264 ||
1849 st->codec->codec_id == CODEC_ID_H263 ||
1850 st->codec->codec_id == CODEC_ID_H261 ||
1851 st->codec->codec_id == CODEC_ID_VORBIS ||
1852 st->codec->codec_id == CODEC_ID_MJPEG ||
1853 st->codec->codec_id == CODEC_ID_PNG ||
1854 st->codec->codec_id == CODEC_ID_PAM ||
1855 st->codec->codec_id == CODEC_ID_PGM ||
1856 st->codec->codec_id == CODEC_ID_PGMYUV ||
1857 st->codec->codec_id == CODEC_ID_PBM ||
1858 st->codec->codec_id == CODEC_ID_PPM ||
1859 st->codec->codec_id == CODEC_ID_SHORTEN ||
1860 (st->codec->codec_id == CODEC_ID_MPEG4 && !st->need_parsing))*/)
1861 try_decode_frame(st, pkt->data, pkt->size);
1863 if (av_rescale_q(codec_info_duration[st->index], st->time_base, AV_TIME_BASE_Q) >= ic->max_analyze_duration) {
1869 // close codecs which where opened in try_decode_frame()
1870 for(i=0;i<ic->nb_streams;i++) {
1871 st = ic->streams[i];
1872 if(st->codec->codec)
1873 avcodec_close(st->codec);
1875 for(i=0;i<ic->nb_streams;i++) {
1876 st = ic->streams[i];
1877 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1878 if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_sample)
1879 st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
1881 if(duration_count[i]
1882 && (st->codec->time_base.num*101LL <= st->codec->time_base.den || st->codec->codec_id == CODEC_ID_MPEG2VIDEO) /*&&
1883 //FIXME we should not special case mpeg2, but this needs testing with non mpeg2 ...
1884 st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den*/){
1885 double best_error= 2*av_q2d(st->time_base);
1886 best_error= best_error*best_error*duration_count[i]*1000*12*30;
1888 for(j=1; j<MAX_STD_TIMEBASES; j++){
1889 double error= duration_error[i][j] * get_std_framerate(j);
1890 // if(st->codec->codec_type == CODEC_TYPE_VIDEO)
1891 // av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
1892 if(error < best_error){
1894 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, get_std_framerate(j), 12*1001, INT_MAX);
1899 if (!st->r_frame_rate.num){
1900 if( st->codec->time_base.den * (int64_t)st->time_base.num
1901 <= st->codec->time_base.num * (int64_t)st->time_base.den){
1902 st->r_frame_rate.num = st->codec->time_base.den;
1903 st->r_frame_rate.den = st->codec->time_base.num;
1905 st->r_frame_rate.num = st->time_base.den;
1906 st->r_frame_rate.den = st->time_base.num;
1909 }else if(st->codec->codec_type == CODEC_TYPE_AUDIO) {
1910 if (st->codec->codec_id == CODEC_ID_NONE) {
1911 codec_identified[st->index] = set_codec_from_probe_data(st, &(probe_data[st->index]), 0);
1912 if (codec_identified[st->index]) {
1913 st->need_parsing = AVSTREAM_PARSE_FULL;
1916 if(!st->codec->bits_per_sample)
1917 st->codec->bits_per_sample= av_get_bits_per_sample(st->codec->codec_id);
1921 av_estimate_timings(ic, old_offset);
1923 for(i=0;i<ic->nb_streams;i++) {
1924 st = ic->streams[i];
1925 if (codec_identified[st->index]) {
1926 av_read_frame_flush(ic);
1927 av_seek_frame(ic, st->index, 0.0, 0);
1928 url_fseek(&ic->pb, ic->data_offset, SEEK_SET);
1933 /* correct DTS for b frame streams with no timestamps */
1934 for(i=0;i<ic->nb_streams;i++) {
1935 st = ic->streams[i];
1936 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1938 ppktl = &ic->packet_buffer;
1940 if(ppkt1->stream_index != i)
1942 if(ppkt1->pkt->dts < 0)
1944 if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
1946 ppkt1->pkt->dts -= delta;
1951 st->cur_dts -= delta;
1957 av_free(duration_error);
1958 for(i=0;i<MAX_STREAMS;i++){
1959 av_freep(&(probe_data[i].buf));
1965 /*******************************************************/
1967 int av_read_play(AVFormatContext *s)
1969 if (!s->iformat->read_play)
1970 return AVERROR_NOTSUPP;
1971 return s->iformat->read_play(s);
1974 int av_read_pause(AVFormatContext *s)
1976 if (!s->iformat->read_pause)
1977 return AVERROR_NOTSUPP;
1978 return s->iformat->read_pause(s);
1981 void av_close_input_file(AVFormatContext *s)
1983 int i, must_open_file;
1986 /* free previous packet */
1987 if (s->cur_st && s->cur_st->parser)
1988 av_free_packet(&s->cur_pkt);
1990 if (s->iformat->read_close)
1991 s->iformat->read_close(s);
1992 for(i=0;i<s->nb_streams;i++) {
1993 /* free all data in a stream component */
1996 av_parser_close(st->parser);
1998 av_free(st->index_entries);
1999 av_free(st->codec->extradata);
2003 flush_packet_queue(s);
2005 if (s->iformat->flags & AVFMT_NOFILE) {
2008 if (must_open_file) {
2011 av_freep(&s->priv_data);
2015 AVStream *av_new_stream(AVFormatContext *s, int id)
2020 if (s->nb_streams >= MAX_STREAMS)
2023 st = av_mallocz(sizeof(AVStream));
2027 st->codec= avcodec_alloc_context();
2029 /* no default bitrate if decoding */
2030 st->codec->bit_rate = 0;
2032 st->index = s->nb_streams;
2034 st->start_time = AV_NOPTS_VALUE;
2035 st->duration = AV_NOPTS_VALUE;
2036 st->cur_dts = AV_NOPTS_VALUE;
2038 /* default pts settings is MPEG like */
2039 av_set_pts_info(st, 33, 1, 90000);
2040 st->last_IP_pts = AV_NOPTS_VALUE;
2041 for(i=0; i<MAX_REORDER_DELAY+1; i++)
2042 st->pts_buffer[i]= AV_NOPTS_VALUE;
2044 s->streams[s->nb_streams++] = st;
2048 /************************************************************/
2049 /* output media file */
2051 int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2055 if (s->oformat->priv_data_size > 0) {
2056 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2058 return AVERROR_NOMEM;
2060 s->priv_data = NULL;
2062 if (s->oformat->set_parameters) {
2063 ret = s->oformat->set_parameters(s, ap);
2070 int av_write_header(AVFormatContext *s)
2075 // some sanity checks
2076 for(i=0;i<s->nb_streams;i++) {
2079 switch (st->codec->codec_type) {
2080 case CODEC_TYPE_AUDIO:
2081 if(st->codec->sample_rate<=0){
2082 av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2086 case CODEC_TYPE_VIDEO:
2087 if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2088 av_log(s, AV_LOG_ERROR, "time base not set\n");
2091 if(st->codec->width<=0 || st->codec->height<=0){
2092 av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2098 if(s->oformat->codec_tag){
2099 if(st->codec->codec_tag){
2101 //check that tag + id is in the table
2102 //if neither is in the table -> ok
2103 //if tag is in the table with another id -> FAIL
2104 //if id is in the table with another tag -> FAIL unless strict < ?
2106 st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2110 if (!s->priv_data && s->oformat->priv_data_size > 0) {
2111 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2113 return AVERROR_NOMEM;
2116 if(s->oformat->write_header){
2117 ret = s->oformat->write_header(s);
2122 /* init PTS generation */
2123 for(i=0;i<s->nb_streams;i++) {
2124 int64_t den = AV_NOPTS_VALUE;
2127 switch (st->codec->codec_type) {
2128 case CODEC_TYPE_AUDIO:
2129 den = (int64_t)st->time_base.num * st->codec->sample_rate;
2131 case CODEC_TYPE_VIDEO:
2132 den = (int64_t)st->time_base.num * st->codec->time_base.den;
2137 if (den != AV_NOPTS_VALUE) {
2139 return AVERROR_INVALIDDATA;
2140 av_frac_init(&st->pts, 0, 0, den);
2146 //FIXME merge with compute_pkt_fields
2147 static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
2148 int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2149 int num, den, frame_size, i;
2151 // 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);
2153 /* if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2156 /* duration field */
2157 if (pkt->duration == 0) {
2158 compute_frame_duration(&num, &den, st, NULL, pkt);
2160 pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
2164 //XXX/FIXME this is a temporary hack until all encoders output pts
2165 if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2167 // pkt->pts= st->cur_dts;
2168 pkt->pts= st->pts.val;
2171 //calculate dts from pts
2172 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE){
2173 st->pts_buffer[0]= pkt->pts;
2174 for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2175 st->pts_buffer[i]= (i-delay-1) * pkt->duration;
2176 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2177 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2179 pkt->dts= st->pts_buffer[0];
2182 if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2183 av_log(NULL, AV_LOG_ERROR, "error, non monotone timestamps %"PRId64" >= %"PRId64" st:%d\n", st->cur_dts, pkt->dts, st->index);
2186 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2187 av_log(NULL, AV_LOG_ERROR, "error, pts < dts (%"PRId64" < %"PRId64")\n",
2188 pkt->pts, pkt->dts);
2192 // av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2193 st->cur_dts= pkt->dts;
2194 st->pts.val= pkt->dts;
2197 switch (st->codec->codec_type) {
2198 case CODEC_TYPE_AUDIO:
2199 frame_size = get_audio_frame_size(st->codec, pkt->size);
2201 /* HACK/FIXME, we skip the initial 0-size packets as they are most likely equal to the encoder delay,
2202 but it would be better if we had the real timestamps from the encoder */
2203 if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2204 av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2207 case CODEC_TYPE_VIDEO:
2208 av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2216 static void truncate_ts(AVStream *st, AVPacket *pkt){
2217 int64_t pts_mask = (2LL << (st->pts_wrap_bits-1)) - 1;
2220 // pkt->dts= 0; //this happens for low_delay=0 and b frames, FIXME, needs further invstigation about what we should do here
2222 if (pkt->pts != AV_NOPTS_VALUE)
2223 pkt->pts &= pts_mask;
2224 if (pkt->dts != AV_NOPTS_VALUE)
2225 pkt->dts &= pts_mask;
2228 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2232 ret=compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2233 if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2236 truncate_ts(s->streams[pkt->stream_index], pkt);
2238 ret= s->oformat->write_packet(s, pkt);
2240 ret= url_ferror(&s->pb);
2244 int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2245 AVPacketList *pktl, **next_point, *this_pktl;
2247 int streams[MAX_STREAMS];
2250 AVStream *st= s->streams[ pkt->stream_index];
2252 // assert(pkt->destruct != av_destruct_packet); //FIXME
2254 this_pktl = av_mallocz(sizeof(AVPacketList));
2255 this_pktl->pkt= *pkt;
2256 if(pkt->destruct == av_destruct_packet)
2257 pkt->destruct= NULL; // non shared -> must keep original from being freed
2259 av_dup_packet(&this_pktl->pkt); //shared -> must dup
2261 next_point = &s->packet_buffer;
2263 AVStream *st2= s->streams[ (*next_point)->pkt.stream_index];
2264 int64_t left= st2->time_base.num * (int64_t)st ->time_base.den;
2265 int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2266 if((*next_point)->pkt.dts * left > pkt->dts * right) //FIXME this can overflow
2268 next_point= &(*next_point)->next;
2270 this_pktl->next= *next_point;
2271 *next_point= this_pktl;
2274 memset(streams, 0, sizeof(streams));
2275 pktl= s->packet_buffer;
2277 //av_log(s, AV_LOG_DEBUG, "show st:%d dts:%"PRId64"\n", pktl->pkt.stream_index, pktl->pkt.dts);
2278 if(streams[ pktl->pkt.stream_index ] == 0)
2280 streams[ pktl->pkt.stream_index ]++;
2284 if(s->nb_streams == stream_count || (flush && stream_count)){
2285 pktl= s->packet_buffer;
2288 s->packet_buffer= pktl->next;
2292 av_init_packet(out);
2298 * Interleaves a AVPacket correctly so it can be muxed.
2299 * @param out the interleaved packet will be output here
2300 * @param in the input packet
2301 * @param flush 1 if no further packets are available as input and all
2302 * remaining packets should be output
2303 * @return 1 if a packet was output, 0 if no packet could be output,
2304 * < 0 if an error occured
2306 static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2307 if(s->oformat->interleave_packet)
2308 return s->oformat->interleave_packet(s, out, in, flush);
2310 return av_interleave_packet_per_dts(s, out, in, flush);
2313 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2314 AVStream *st= s->streams[ pkt->stream_index];
2316 //FIXME/XXX/HACK drop zero sized packets
2317 if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2320 //av_log(NULL, AV_LOG_DEBUG, "av_interleaved_write_frame %d %"PRId64" %"PRId64"\n", pkt->size, pkt->dts, pkt->pts);
2321 if(compute_pkt_fields2(st, pkt) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2324 if(pkt->dts == AV_NOPTS_VALUE)
2329 int ret= av_interleave_packet(s, &opkt, pkt, 0);
2330 if(ret<=0) //FIXME cleanup needed for ret<0 ?
2333 truncate_ts(s->streams[opkt.stream_index], &opkt);
2334 ret= s->oformat->write_packet(s, &opkt);
2336 av_free_packet(&opkt);
2341 if(url_ferror(&s->pb))
2342 return url_ferror(&s->pb);
2346 int av_write_trailer(AVFormatContext *s)
2352 ret= av_interleave_packet(s, &pkt, NULL, 1);
2353 if(ret<0) //FIXME cleanup needed for ret<0 ?
2358 truncate_ts(s->streams[pkt.stream_index], &pkt);
2359 ret= s->oformat->write_packet(s, &pkt);
2361 av_free_packet(&pkt);
2365 if(url_ferror(&s->pb))
2369 if(s->oformat->write_trailer)
2370 ret = s->oformat->write_trailer(s);
2373 ret=url_ferror(&s->pb);
2374 for(i=0;i<s->nb_streams;i++)
2375 av_freep(&s->streams[i]->priv_data);
2376 av_freep(&s->priv_data);
2380 /* "user interface" functions */
2382 void dump_format(AVFormatContext *ic,
2390 av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
2391 is_output ? "Output" : "Input",
2393 is_output ? ic->oformat->name : ic->iformat->name,
2394 is_output ? "to" : "from", url);
2396 av_log(NULL, AV_LOG_INFO, " Duration: ");
2397 if (ic->duration != AV_NOPTS_VALUE) {
2398 int hours, mins, secs, us;
2399 secs = ic->duration / AV_TIME_BASE;
2400 us = ic->duration % AV_TIME_BASE;
2405 av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%01d", hours, mins, secs,
2406 (10 * us) / AV_TIME_BASE);
2408 av_log(NULL, AV_LOG_INFO, "N/A");
2410 if (ic->start_time != AV_NOPTS_VALUE) {
2412 av_log(NULL, AV_LOG_INFO, ", start: ");
2413 secs = ic->start_time / AV_TIME_BASE;
2414 us = ic->start_time % AV_TIME_BASE;
2415 av_log(NULL, AV_LOG_INFO, "%d.%06d",
2416 secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
2418 av_log(NULL, AV_LOG_INFO, ", bitrate: ");
2420 av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
2422 av_log(NULL, AV_LOG_INFO, "N/A");
2424 av_log(NULL, AV_LOG_INFO, "\n");
2426 for(i=0;i<ic->nb_streams;i++) {
2427 AVStream *st = ic->streams[i];
2428 int g= ff_gcd(st->time_base.num, st->time_base.den);
2429 avcodec_string(buf, sizeof(buf), st->codec, is_output);
2430 av_log(NULL, AV_LOG_INFO, " Stream #%d.%d", index, i);
2431 /* the pid is an important information, so we display it */
2432 /* XXX: add a generic system */
2434 flags = ic->oformat->flags;
2436 flags = ic->iformat->flags;
2437 if (flags & AVFMT_SHOW_IDS) {
2438 av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
2440 if (strlen(st->language) > 0) {
2441 av_log(NULL, AV_LOG_INFO, "(%s)", st->language);
2443 av_log(NULL, AV_LOG_DEBUG, ", %d/%d", st->time_base.num/g, st->time_base.den/g);
2444 av_log(NULL, AV_LOG_INFO, ": %s", buf);
2445 if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2446 if(st->r_frame_rate.den && st->r_frame_rate.num)
2447 av_log(NULL, AV_LOG_INFO, ", %5.2f fps(r)", av_q2d(st->r_frame_rate));
2448 /* else if(st->time_base.den && st->time_base.num)
2449 av_log(NULL, AV_LOG_INFO, ", %5.2f fps(m)", 1/av_q2d(st->time_base));*/
2451 av_log(NULL, AV_LOG_INFO, ", %5.2f fps(c)", 1/av_q2d(st->codec->time_base));
2453 av_log(NULL, AV_LOG_INFO, "\n");
2460 int frame_rate, frame_rate_base;
2463 static AbvEntry frame_abvs[] = {
2464 { "ntsc", 720, 480, 30000, 1001 },
2465 { "pal", 720, 576, 25, 1 },
2466 { "qntsc", 352, 240, 30000, 1001 }, /* VCD compliant ntsc */
2467 { "qpal", 352, 288, 25, 1 }, /* VCD compliant pal */
2468 { "sntsc", 640, 480, 30000, 1001 }, /* square pixel ntsc */
2469 { "spal", 768, 576, 25, 1 }, /* square pixel pal */
2470 { "film", 352, 240, 24, 1 },
2471 { "ntsc-film", 352, 240, 24000, 1001 },
2472 { "sqcif", 128, 96, 0, 0 },
2473 { "qcif", 176, 144, 0, 0 },
2474 { "cif", 352, 288, 0, 0 },
2475 { "4cif", 704, 576, 0, 0 },
2478 int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2481 int n = sizeof(frame_abvs) / sizeof(AbvEntry);
2483 int frame_width = 0, frame_height = 0;
2486 if (!strcmp(frame_abvs[i].abv, str)) {
2487 frame_width = frame_abvs[i].width;
2488 frame_height = frame_abvs[i].height;
2494 frame_width = strtol(p, (char **)&p, 10);
2497 frame_height = strtol(p, (char **)&p, 10);
2499 if (frame_width <= 0 || frame_height <= 0)
2501 *width_ptr = frame_width;
2502 *height_ptr = frame_height;
2506 int parse_frame_rate(int *frame_rate, int *frame_rate_base, const char *arg)
2511 /* First, we check our abbreviation table */
2512 for (i = 0; i < sizeof(frame_abvs)/sizeof(*frame_abvs); ++i)
2513 if (!strcmp(frame_abvs[i].abv, arg)) {
2514 *frame_rate = frame_abvs[i].frame_rate;
2515 *frame_rate_base = frame_abvs[i].frame_rate_base;
2519 /* Then, we try to parse it as fraction */
2520 cp = strchr(arg, '/');
2522 cp = strchr(arg, ':');
2525 *frame_rate = strtol(arg, &cpp, 10);
2526 if (cpp != arg || cpp == cp)
2527 *frame_rate_base = strtol(cp+1, &cpp, 10);
2532 /* Finally we give up and parse it as double */
2533 AVRational time_base = av_d2q(strtod(arg, 0), DEFAULT_FRAME_RATE_BASE);
2534 *frame_rate_base = time_base.den;
2535 *frame_rate = time_base.num;
2537 if (!*frame_rate || !*frame_rate_base)
2543 int64_t parse_date(const char *datestr, int duration)
2549 static const char *date_fmt[] = {
2553 static const char *time_fmt[] = {
2563 time_t now = time(0);
2565 len = strlen(datestr);
2567 lastch = datestr[len - 1];
2570 is_utc = (lastch == 'z' || lastch == 'Z');
2572 memset(&dt, 0, sizeof(dt));
2577 for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
2578 q = small_strptime(p, date_fmt[i], &dt);
2588 dt = *localtime(&now);
2590 dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
2595 if (*p == 'T' || *p == 't' || *p == ' ')
2598 for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
2599 q = small_strptime(p, time_fmt[i], &dt);
2609 q = small_strptime(p, time_fmt[0], &dt);
2611 dt.tm_sec = strtol(p, (char **)&q, 10);
2617 /* Now we have all the fields that we can get */
2622 return now * INT64_C(1000000);
2626 t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2628 dt.tm_isdst = -1; /* unknown */
2641 for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
2644 val += n * (*q - '0');
2648 return negative ? -t : t;
2651 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
2661 while (*p != '\0' && *p != '=' && *p != '&') {
2662 if ((q - tag) < sizeof(tag) - 1)
2670 while (*p != '&' && *p != '\0') {
2671 if ((q - arg) < arg_size - 1) {
2681 if (!strcmp(tag, tag1))
2690 int av_get_frame_filename(char *buf, int buf_size,
2691 const char *path, int number)
2694 char *q, buf1[20], c;
2695 int nd, len, percentd_found;
2707 while (isdigit(*p)) {
2708 nd = nd * 10 + *p++ - '0';
2711 } while (isdigit(c));
2720 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
2722 if ((q - buf + len) > buf_size - 1)
2724 memcpy(q, buf1, len);
2732 if ((q - buf) < buf_size - 1)
2736 if (!percentd_found)
2745 static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
2748 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
2750 for(i=0;i<size;i+=16) {
2757 PRINT(" %02x", buf[i+j]);
2762 for(j=0;j<len;j++) {
2764 if (c < ' ' || c > '~')
2773 void av_hex_dump(FILE *f, uint8_t *buf, int size)
2775 hex_dump_internal(NULL, f, 0, buf, size);
2778 void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
2780 hex_dump_internal(avcl, NULL, level, buf, size);
2783 //FIXME needs to know the time_base
2784 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload)
2786 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
2787 PRINT("stream #%d:\n", pkt->stream_index);
2788 PRINT(" keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
2789 PRINT(" duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
2790 /* DTS is _always_ valid after av_read_frame() */
2792 if (pkt->dts == AV_NOPTS_VALUE)
2795 PRINT("%0.3f", (double)pkt->dts / AV_TIME_BASE);
2796 /* PTS may be not known if B frames are present */
2798 if (pkt->pts == AV_NOPTS_VALUE)
2801 PRINT("%0.3f", (double)pkt->pts / AV_TIME_BASE);
2803 PRINT(" size=%d\n", pkt->size);
2806 av_hex_dump(f, pkt->data, pkt->size);
2809 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
2811 pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
2814 void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
2816 pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
2819 void url_split(char *proto, int proto_size,
2820 char *authorization, int authorization_size,
2821 char *hostname, int hostname_size,
2823 char *path, int path_size,
2834 while (*p != ':' && *p != '\0') {
2835 if ((q - proto) < proto_size - 1)
2841 if (authorization_size > 0)
2842 authorization[0] = '\0';
2846 if (hostname_size > 0)
2850 char *at,*slash; // PETR: position of '@' character and '/' character
2857 at = strchr(p,'@'); // PETR: get the position of '@'
2858 slash = strchr(p,'/'); // PETR: get position of '/' - end of hostname
2859 if (at && slash && at > slash) at = NULL; // PETR: not interested in '@' behind '/'
2861 q = at ? authorization : hostname; // PETR: if '@' exists starting with auth.
2863 while ((at || *p != ':') && *p != '/' && *p != '?' && *p != '\0') { // PETR:
2864 if (*p == '@') { // PETR: passed '@'
2865 if (authorization_size > 0)
2869 } else if (!at) { // PETR: hostname
2870 if ((q - hostname) < hostname_size - 1)
2873 if ((q - authorization) < authorization_size - 1)
2878 if (hostname_size > 0)
2882 port = strtoul(p, (char **)&p, 10);
2887 pstrcpy(path, path_size, p);
2890 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
2891 int pts_num, int pts_den)
2893 s->pts_wrap_bits = pts_wrap_bits;
2894 s->time_base.num = pts_num;
2895 s->time_base.den = pts_den;
2898 /* fraction handling */
2901 * f = val + (num / den) + 0.5.
2903 * 'num' is normalized so that it is such as 0 <= num < den.
2905 * @param f fractional number
2906 * @param val integer value
2907 * @param num must be >= 0
2908 * @param den must be >= 1
2910 static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
2923 * Fractionnal addition to f: f = f + (incr / f->den).
2925 * @param f fractional number
2926 * @param incr increment, can be positive or negative
2928 static void av_frac_add(AVFrac *f, int64_t incr)
2932 num = f->num + incr;
2935 f->val += num / den;
2941 } else if (num >= den) {
2942 f->val += num / den;