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 if(ts == AV_NOPTS_VALUE){
1221 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1224 assert(ts != AV_NOPTS_VALUE);
1225 if (target_ts <= ts) {
1226 pos_limit = start_pos - 1;
1230 if (target_ts >= ts) {
1236 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1237 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
1240 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1242 ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1243 av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1244 pos, ts_min, target_ts, ts_max);
1250 static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1251 int64_t pos_min, pos_max;
1255 if (stream_index < 0)
1258 st= s->streams[stream_index];
1261 pos_min = s->data_offset;
1262 pos_max = url_fsize(&s->pb) - 1;
1264 if (pos < pos_min) pos= pos_min;
1265 else if(pos > pos_max) pos= pos_max;
1267 url_fseek(&s->pb, pos, SEEK_SET);
1270 av_update_cur_dts(s, st, ts);
1275 static int av_seek_frame_generic(AVFormatContext *s,
1276 int stream_index, int64_t timestamp, int flags)
1282 st = s->streams[stream_index];
1284 index = av_index_search_timestamp(st, timestamp, flags);
1286 if(index < 0 || index==st->nb_index_entries-1){
1290 if(st->index_entries && st->nb_index_entries){
1291 ie= &st->index_entries[st->nb_index_entries-1];
1292 url_fseek(&s->pb, ie->pos, SEEK_SET);
1293 av_update_cur_dts(s, st, ie->timestamp);
1295 url_fseek(&s->pb, 0, SEEK_SET);
1298 int ret = av_read_frame(s, &pkt);
1301 av_free_packet(&pkt);
1302 if(stream_index == pkt.stream_index){
1303 if((pkt.flags & PKT_FLAG_KEY) && pkt.dts > timestamp)
1307 index = av_index_search_timestamp(st, timestamp, flags);
1312 av_read_frame_flush(s);
1313 if (s->iformat->read_seek){
1314 if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1317 ie = &st->index_entries[index];
1318 url_fseek(&s->pb, ie->pos, SEEK_SET);
1320 av_update_cur_dts(s, st, ie->timestamp);
1325 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1330 av_read_frame_flush(s);
1332 if(flags & AVSEEK_FLAG_BYTE)
1333 return av_seek_frame_byte(s, stream_index, timestamp, flags);
1335 if(stream_index < 0){
1336 stream_index= av_find_default_stream_index(s);
1337 if(stream_index < 0)
1340 st= s->streams[stream_index];
1341 /* timestamp for default must be expressed in AV_TIME_BASE units */
1342 timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1344 st= s->streams[stream_index];
1346 /* first, we try the format specific seek */
1347 if (s->iformat->read_seek)
1348 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1355 if(s->iformat->read_timestamp)
1356 return av_seek_frame_binary(s, stream_index, timestamp, flags);
1358 return av_seek_frame_generic(s, stream_index, timestamp, flags);
1361 /*******************************************************/
1364 * Returns TRUE if the stream has accurate timings in any stream.
1366 * @return TRUE if the stream has accurate timings for at least one component.
1368 static int av_has_timings(AVFormatContext *ic)
1373 for(i = 0;i < ic->nb_streams; i++) {
1374 st = ic->streams[i];
1375 if (st->start_time != AV_NOPTS_VALUE &&
1376 st->duration != AV_NOPTS_VALUE)
1383 * Estimate the stream timings from the one of each components.
1385 * Also computes the global bitrate if possible.
1387 static void av_update_stream_timings(AVFormatContext *ic)
1389 int64_t start_time, start_time1, end_time, end_time1;
1393 start_time = INT64_MAX;
1394 end_time = INT64_MIN;
1395 for(i = 0;i < ic->nb_streams; i++) {
1396 st = ic->streams[i];
1397 if (st->start_time != AV_NOPTS_VALUE) {
1398 start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1399 if (start_time1 < start_time)
1400 start_time = start_time1;
1401 if (st->duration != AV_NOPTS_VALUE) {
1402 end_time1 = start_time1
1403 + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1404 if (end_time1 > end_time)
1405 end_time = end_time1;
1409 if (start_time != INT64_MAX) {
1410 ic->start_time = start_time;
1411 if (end_time != INT64_MIN) {
1412 ic->duration = end_time - start_time;
1413 if (ic->file_size > 0) {
1414 /* compute the bit rate */
1415 ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1416 (double)ic->duration;
1423 static void fill_all_stream_timings(AVFormatContext *ic)
1428 av_update_stream_timings(ic);
1429 for(i = 0;i < ic->nb_streams; i++) {
1430 st = ic->streams[i];
1431 if (st->start_time == AV_NOPTS_VALUE) {
1432 if(ic->start_time != AV_NOPTS_VALUE)
1433 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1434 if(ic->duration != AV_NOPTS_VALUE)
1435 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1440 static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1442 int64_t filesize, duration;
1446 /* if bit_rate is already set, we believe it */
1447 if (ic->bit_rate == 0) {
1449 for(i=0;i<ic->nb_streams;i++) {
1450 st = ic->streams[i];
1451 bit_rate += st->codec->bit_rate;
1453 ic->bit_rate = bit_rate;
1456 /* if duration is already set, we believe it */
1457 if (ic->duration == AV_NOPTS_VALUE &&
1458 ic->bit_rate != 0 &&
1459 ic->file_size != 0) {
1460 filesize = ic->file_size;
1462 for(i = 0; i < ic->nb_streams; i++) {
1463 st = ic->streams[i];
1464 duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1465 if (st->start_time == AV_NOPTS_VALUE ||
1466 st->duration == AV_NOPTS_VALUE) {
1468 st->duration = duration;
1475 #define DURATION_MAX_READ_SIZE 250000
1477 /* only usable for MPEG-PS streams */
1478 static void av_estimate_timings_from_pts(AVFormatContext *ic, offset_t old_offset)
1480 AVPacket pkt1, *pkt = &pkt1;
1482 int read_size, i, ret;
1484 int64_t filesize, offset, duration;
1486 av_read_frame_flush(ic);
1488 /* we read the first packets to get the first PTS (not fully
1489 accurate, but it is enough now) */
1490 url_fseek(&ic->pb, 0, SEEK_SET);
1493 if (read_size >= DURATION_MAX_READ_SIZE)
1495 /* if all info is available, we can stop */
1496 for(i = 0;i < ic->nb_streams; i++) {
1497 st = ic->streams[i];
1498 if (st->start_time == AV_NOPTS_VALUE)
1501 if (i == ic->nb_streams)
1504 ret = av_read_packet(ic, pkt);
1507 read_size += pkt->size;
1508 st = ic->streams[pkt->stream_index];
1509 if (pkt->pts != AV_NOPTS_VALUE) {
1510 if (st->start_time == AV_NOPTS_VALUE)
1511 st->start_time = pkt->pts;
1513 av_free_packet(pkt);
1516 /* estimate the end time (duration) */
1517 /* XXX: may need to support wrapping */
1518 filesize = ic->file_size;
1519 offset = filesize - DURATION_MAX_READ_SIZE;
1523 url_fseek(&ic->pb, offset, SEEK_SET);
1526 if (read_size >= DURATION_MAX_READ_SIZE)
1528 /* if all info is available, we can stop */
1529 for(i = 0;i < ic->nb_streams; i++) {
1530 st = ic->streams[i];
1531 if (st->duration == AV_NOPTS_VALUE)
1534 if (i == ic->nb_streams)
1537 ret = av_read_packet(ic, pkt);
1540 read_size += pkt->size;
1541 st = ic->streams[pkt->stream_index];
1542 if (pkt->pts != AV_NOPTS_VALUE) {
1543 end_time = pkt->pts;
1544 duration = end_time - st->start_time;
1546 if (st->duration == AV_NOPTS_VALUE ||
1547 st->duration < duration)
1548 st->duration = duration;
1551 av_free_packet(pkt);
1554 fill_all_stream_timings(ic);
1556 url_fseek(&ic->pb, old_offset, SEEK_SET);
1559 static void av_estimate_timings(AVFormatContext *ic, offset_t old_offset)
1563 /* get the file size, if possible */
1564 if (ic->iformat->flags & AVFMT_NOFILE) {
1567 file_size = url_fsize(&ic->pb);
1571 ic->file_size = file_size;
1573 if ((!strcmp(ic->iformat->name, "mpeg") ||
1574 !strcmp(ic->iformat->name, "mpegts")) &&
1575 file_size && !ic->pb.is_streamed) {
1576 /* get accurate estimate from the PTSes */
1577 av_estimate_timings_from_pts(ic, old_offset);
1578 } else if (av_has_timings(ic)) {
1579 /* at least one components has timings - we use them for all
1581 fill_all_stream_timings(ic);
1583 /* less precise: use bit rate info */
1584 av_estimate_timings_from_bit_rate(ic);
1586 av_update_stream_timings(ic);
1592 for(i = 0;i < ic->nb_streams; i++) {
1593 st = ic->streams[i];
1594 printf("%d: start_time: %0.3f duration: %0.3f\n",
1595 i, (double)st->start_time / AV_TIME_BASE,
1596 (double)st->duration / AV_TIME_BASE);
1598 printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1599 (double)ic->start_time / AV_TIME_BASE,
1600 (double)ic->duration / AV_TIME_BASE,
1601 ic->bit_rate / 1000);
1606 static int has_codec_parameters(AVCodecContext *enc)
1609 switch(enc->codec_type) {
1610 case CODEC_TYPE_AUDIO:
1611 val = enc->sample_rate;
1613 case CODEC_TYPE_VIDEO:
1614 val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
1623 static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1627 int got_picture, data_size, ret=0;
1630 if(!st->codec->codec){
1631 codec = avcodec_find_decoder(st->codec->codec_id);
1634 ret = avcodec_open(st->codec, codec);
1639 if(!has_codec_parameters(st->codec)){
1640 switch(st->codec->codec_type) {
1641 case CODEC_TYPE_VIDEO:
1642 ret = avcodec_decode_video(st->codec, &picture,
1643 &got_picture, (uint8_t *)data, size);
1645 case CODEC_TYPE_AUDIO:
1646 data_size = FFMAX(size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
1647 samples = av_malloc(data_size);
1650 ret = avcodec_decode_audio2(st->codec, samples,
1651 &data_size, (uint8_t *)data, size);
1662 static int set_codec_from_probe_data(AVStream *st, AVProbeData *pd, int score)
1665 fmt = av_probe_input_format2(pd, 1, &score);
1668 if (strncmp(fmt->name, "mp3", 3) == 0)
1669 st->codec->codec_id = CODEC_ID_MP3;
1670 else if (strncmp(fmt->name, "ac3", 3) == 0)
1671 st->codec->codec_id = CODEC_ID_AC3;
1676 /* absolute maximum size we read until we abort */
1677 #define MAX_READ_SIZE 5000000
1679 #define MAX_STD_TIMEBASES (60*12+5)
1680 static int get_std_framerate(int i){
1681 if(i<60*12) return i*1001;
1682 else return ((int[]){24,30,60,12,15})[i-60*12]*1000*12;
1685 int av_find_stream_info(AVFormatContext *ic)
1687 int i, count, ret, read_size, j;
1689 AVPacket pkt1, *pkt;
1690 AVPacketList *pktl=NULL, **ppktl;
1691 int64_t last_dts[MAX_STREAMS];
1692 int duration_count[MAX_STREAMS]={0};
1693 double (*duration_error)[MAX_STD_TIMEBASES];
1694 offset_t old_offset = url_ftell(&ic->pb);
1695 int64_t codec_info_duration[MAX_STREAMS]={0};
1696 int codec_info_nb_frames[MAX_STREAMS]={0};
1697 AVProbeData probe_data[MAX_STREAMS];
1698 int codec_identified[MAX_STREAMS]={0};
1700 duration_error = av_mallocz(MAX_STREAMS * sizeof(*duration_error));
1701 if (!duration_error) return AVERROR_NOMEM;
1703 for(i=0;i<ic->nb_streams;i++) {
1704 st = ic->streams[i];
1705 if(st->codec->codec_type == CODEC_TYPE_VIDEO){
1706 /* if(!st->time_base.num)
1708 if(!st->codec->time_base.num)
1709 st->codec->time_base= st->time_base;
1711 //only for the split stuff
1713 st->parser = av_parser_init(st->codec->codec_id);
1714 if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
1715 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1720 for(i=0;i<MAX_STREAMS;i++){
1721 last_dts[i]= AV_NOPTS_VALUE;
1724 memset(probe_data, 0, sizeof(probe_data));
1727 ppktl = &ic->packet_buffer;
1729 /* check if one codec still needs to be handled */
1730 for(i=0;i<ic->nb_streams;i++) {
1731 st = ic->streams[i];
1732 if (!has_codec_parameters(st->codec))
1734 /* variable fps and no guess at the real fps */
1735 if( (st->codec->time_base.den >= 101LL*st->codec->time_base.num || st->codec->codec_id == CODEC_ID_MPEG2VIDEO)
1736 && duration_count[i]<20 && st->codec->codec_type == CODEC_TYPE_VIDEO)
1738 if(st->parser && st->parser->parser->split && !st->codec->extradata)
1740 if (st->codec->codec_type == CODEC_TYPE_AUDIO &&
1741 st->codec->codec_id == CODEC_ID_NONE)
1744 if (i == ic->nb_streams) {
1745 /* NOTE: if the format has no header, then we need to read
1746 some packets to get most of the streams, so we cannot
1748 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
1749 /* if we found the info for all the codecs, we can stop */
1754 /* we did not get all the codec info, but we read too much data */
1755 if (read_size >= MAX_READ_SIZE) {
1760 /* NOTE: a new stream can be added there if no header in file
1761 (AVFMTCTX_NOHEADER) */
1762 ret = av_read_frame_internal(ic, &pkt1);
1765 ret = -1; /* we could not have all the codec parameters before EOF */
1766 for(i=0;i<ic->nb_streams;i++) {
1767 st = ic->streams[i];
1768 if (!has_codec_parameters(st->codec)){
1770 avcodec_string(buf, sizeof(buf), st->codec, 0);
1771 av_log(ic, AV_LOG_INFO, "Could not find codec parameters (%s)\n", buf);
1779 pktl = av_mallocz(sizeof(AVPacketList));
1781 ret = AVERROR_NOMEM;
1785 /* add the packet in the buffered packet list */
1787 ppktl = &pktl->next;
1792 /* duplicate the packet */
1793 if (av_dup_packet(pkt) < 0) {
1794 ret = AVERROR_NOMEM;
1798 read_size += pkt->size;
1800 st = ic->streams[pkt->stream_index];
1801 if(codec_info_nb_frames[st->index]>1)
1802 codec_info_duration[st->index] += pkt->duration;
1803 if (pkt->duration != 0)
1804 codec_info_nb_frames[st->index]++;
1807 int index= pkt->stream_index;
1808 int64_t last= last_dts[index];
1809 int64_t duration= pkt->dts - last;
1811 if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
1812 double dur= duration * av_q2d(st->time_base);
1814 // if(st->codec->codec_type == CODEC_TYPE_VIDEO)
1815 // av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
1816 if(duration_count[index] < 2)
1817 memset(duration_error, 0, MAX_STREAMS * sizeof(*duration_error));
1818 for(i=1; i<MAX_STD_TIMEBASES; i++){
1819 int framerate= get_std_framerate(i);
1820 int ticks= lrintf(dur*framerate/(1001*12));
1821 double error= dur - ticks*1001*12/(double)framerate;
1822 duration_error[index][i] += error*error;
1824 duration_count[index]++;
1826 if(last == AV_NOPTS_VALUE || duration_count[index]<=1)
1827 last_dts[pkt->stream_index]= pkt->dts;
1829 if (st->codec->codec_id == CODEC_ID_NONE) {
1830 AVProbeData *pd = &(probe_data[st->index]);
1831 pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size);
1832 memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
1833 pd->buf_size += pkt->size;
1836 if(st->parser && st->parser->parser->split && !st->codec->extradata){
1837 int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
1839 st->codec->extradata_size= i;
1840 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
1841 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
1842 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
1846 /* if still no information, we try to open the codec and to
1847 decompress the frame. We try to avoid that in most cases as
1848 it takes longer and uses more memory. For MPEG4, we need to
1849 decompress for Quicktime. */
1850 if (!has_codec_parameters(st->codec) /*&&
1851 (st->codec->codec_id == CODEC_ID_FLV1 ||
1852 st->codec->codec_id == CODEC_ID_H264 ||
1853 st->codec->codec_id == CODEC_ID_H263 ||
1854 st->codec->codec_id == CODEC_ID_H261 ||
1855 st->codec->codec_id == CODEC_ID_VORBIS ||
1856 st->codec->codec_id == CODEC_ID_MJPEG ||
1857 st->codec->codec_id == CODEC_ID_PNG ||
1858 st->codec->codec_id == CODEC_ID_PAM ||
1859 st->codec->codec_id == CODEC_ID_PGM ||
1860 st->codec->codec_id == CODEC_ID_PGMYUV ||
1861 st->codec->codec_id == CODEC_ID_PBM ||
1862 st->codec->codec_id == CODEC_ID_PPM ||
1863 st->codec->codec_id == CODEC_ID_SHORTEN ||
1864 (st->codec->codec_id == CODEC_ID_MPEG4 && !st->need_parsing))*/)
1865 try_decode_frame(st, pkt->data, pkt->size);
1867 if (av_rescale_q(codec_info_duration[st->index], st->time_base, AV_TIME_BASE_Q) >= ic->max_analyze_duration) {
1873 // close codecs which where opened in try_decode_frame()
1874 for(i=0;i<ic->nb_streams;i++) {
1875 st = ic->streams[i];
1876 if(st->codec->codec)
1877 avcodec_close(st->codec);
1879 for(i=0;i<ic->nb_streams;i++) {
1880 st = ic->streams[i];
1881 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1882 if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_sample)
1883 st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
1885 if(duration_count[i]
1886 && (st->codec->time_base.num*101LL <= st->codec->time_base.den || st->codec->codec_id == CODEC_ID_MPEG2VIDEO) /*&&
1887 //FIXME we should not special case mpeg2, but this needs testing with non mpeg2 ...
1888 st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den*/){
1889 double best_error= 2*av_q2d(st->time_base);
1890 best_error= best_error*best_error*duration_count[i]*1000*12*30;
1892 for(j=1; j<MAX_STD_TIMEBASES; j++){
1893 double error= duration_error[i][j] * get_std_framerate(j);
1894 // if(st->codec->codec_type == CODEC_TYPE_VIDEO)
1895 // av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
1896 if(error < best_error){
1898 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, get_std_framerate(j), 12*1001, INT_MAX);
1903 if (!st->r_frame_rate.num){
1904 if( st->codec->time_base.den * (int64_t)st->time_base.num
1905 <= st->codec->time_base.num * (int64_t)st->time_base.den){
1906 st->r_frame_rate.num = st->codec->time_base.den;
1907 st->r_frame_rate.den = st->codec->time_base.num;
1909 st->r_frame_rate.num = st->time_base.den;
1910 st->r_frame_rate.den = st->time_base.num;
1913 }else if(st->codec->codec_type == CODEC_TYPE_AUDIO) {
1914 if (st->codec->codec_id == CODEC_ID_NONE) {
1915 codec_identified[st->index] = set_codec_from_probe_data(st, &(probe_data[st->index]), 0);
1916 if (codec_identified[st->index]) {
1917 st->need_parsing = AVSTREAM_PARSE_FULL;
1920 if(!st->codec->bits_per_sample)
1921 st->codec->bits_per_sample= av_get_bits_per_sample(st->codec->codec_id);
1925 av_estimate_timings(ic, old_offset);
1927 for(i=0;i<ic->nb_streams;i++) {
1928 st = ic->streams[i];
1929 if (codec_identified[st->index]) {
1930 av_read_frame_flush(ic);
1931 av_seek_frame(ic, st->index, 0.0, 0);
1932 url_fseek(&ic->pb, ic->data_offset, SEEK_SET);
1937 /* correct DTS for b frame streams with no timestamps */
1938 for(i=0;i<ic->nb_streams;i++) {
1939 st = ic->streams[i];
1940 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1942 ppktl = &ic->packet_buffer;
1944 if(ppkt1->stream_index != i)
1946 if(ppkt1->pkt->dts < 0)
1948 if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
1950 ppkt1->pkt->dts -= delta;
1955 st->cur_dts -= delta;
1961 av_free(duration_error);
1962 for(i=0;i<MAX_STREAMS;i++){
1963 av_freep(&(probe_data[i].buf));
1969 /*******************************************************/
1971 int av_read_play(AVFormatContext *s)
1973 if (!s->iformat->read_play)
1974 return AVERROR_NOTSUPP;
1975 return s->iformat->read_play(s);
1978 int av_read_pause(AVFormatContext *s)
1980 if (!s->iformat->read_pause)
1981 return AVERROR_NOTSUPP;
1982 return s->iformat->read_pause(s);
1985 void av_close_input_file(AVFormatContext *s)
1987 int i, must_open_file;
1990 /* free previous packet */
1991 if (s->cur_st && s->cur_st->parser)
1992 av_free_packet(&s->cur_pkt);
1994 if (s->iformat->read_close)
1995 s->iformat->read_close(s);
1996 for(i=0;i<s->nb_streams;i++) {
1997 /* free all data in a stream component */
2000 av_parser_close(st->parser);
2002 av_free(st->index_entries);
2003 av_free(st->codec->extradata);
2007 flush_packet_queue(s);
2009 if (s->iformat->flags & AVFMT_NOFILE) {
2012 if (must_open_file) {
2015 av_freep(&s->priv_data);
2019 AVStream *av_new_stream(AVFormatContext *s, int id)
2024 if (s->nb_streams >= MAX_STREAMS)
2027 st = av_mallocz(sizeof(AVStream));
2031 st->codec= avcodec_alloc_context();
2033 /* no default bitrate if decoding */
2034 st->codec->bit_rate = 0;
2036 st->index = s->nb_streams;
2038 st->start_time = AV_NOPTS_VALUE;
2039 st->duration = AV_NOPTS_VALUE;
2040 st->cur_dts = AV_NOPTS_VALUE;
2042 /* default pts settings is MPEG like */
2043 av_set_pts_info(st, 33, 1, 90000);
2044 st->last_IP_pts = AV_NOPTS_VALUE;
2045 for(i=0; i<MAX_REORDER_DELAY+1; i++)
2046 st->pts_buffer[i]= AV_NOPTS_VALUE;
2048 s->streams[s->nb_streams++] = st;
2052 /************************************************************/
2053 /* output media file */
2055 int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2059 if (s->oformat->priv_data_size > 0) {
2060 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2062 return AVERROR_NOMEM;
2064 s->priv_data = NULL;
2066 if (s->oformat->set_parameters) {
2067 ret = s->oformat->set_parameters(s, ap);
2074 int av_write_header(AVFormatContext *s)
2079 // some sanity checks
2080 for(i=0;i<s->nb_streams;i++) {
2083 switch (st->codec->codec_type) {
2084 case CODEC_TYPE_AUDIO:
2085 if(st->codec->sample_rate<=0){
2086 av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2090 case CODEC_TYPE_VIDEO:
2091 if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2092 av_log(s, AV_LOG_ERROR, "time base not set\n");
2095 if(st->codec->width<=0 || st->codec->height<=0){
2096 av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2102 if(s->oformat->codec_tag){
2103 if(st->codec->codec_tag){
2105 //check that tag + id is in the table
2106 //if neither is in the table -> ok
2107 //if tag is in the table with another id -> FAIL
2108 //if id is in the table with another tag -> FAIL unless strict < ?
2110 st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2114 if (!s->priv_data && s->oformat->priv_data_size > 0) {
2115 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2117 return AVERROR_NOMEM;
2120 if(s->oformat->write_header){
2121 ret = s->oformat->write_header(s);
2126 /* init PTS generation */
2127 for(i=0;i<s->nb_streams;i++) {
2128 int64_t den = AV_NOPTS_VALUE;
2131 switch (st->codec->codec_type) {
2132 case CODEC_TYPE_AUDIO:
2133 den = (int64_t)st->time_base.num * st->codec->sample_rate;
2135 case CODEC_TYPE_VIDEO:
2136 den = (int64_t)st->time_base.num * st->codec->time_base.den;
2141 if (den != AV_NOPTS_VALUE) {
2143 return AVERROR_INVALIDDATA;
2144 av_frac_init(&st->pts, 0, 0, den);
2150 //FIXME merge with compute_pkt_fields
2151 static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
2152 int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2153 int num, den, frame_size, i;
2155 // 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);
2157 /* if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2160 /* duration field */
2161 if (pkt->duration == 0) {
2162 compute_frame_duration(&num, &den, st, NULL, pkt);
2164 pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
2168 //XXX/FIXME this is a temporary hack until all encoders output pts
2169 if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2171 // pkt->pts= st->cur_dts;
2172 pkt->pts= st->pts.val;
2175 //calculate dts from pts
2176 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE){
2177 st->pts_buffer[0]= pkt->pts;
2178 for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2179 st->pts_buffer[i]= (i-delay-1) * pkt->duration;
2180 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2181 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2183 pkt->dts= st->pts_buffer[0];
2186 if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2187 av_log(NULL, AV_LOG_ERROR, "error, non monotone timestamps %"PRId64" >= %"PRId64" st:%d\n", st->cur_dts, pkt->dts, st->index);
2190 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2191 av_log(NULL, AV_LOG_ERROR, "error, pts < dts (%"PRId64" < %"PRId64")\n",
2192 pkt->pts, pkt->dts);
2196 // av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2197 st->cur_dts= pkt->dts;
2198 st->pts.val= pkt->dts;
2201 switch (st->codec->codec_type) {
2202 case CODEC_TYPE_AUDIO:
2203 frame_size = get_audio_frame_size(st->codec, pkt->size);
2205 /* HACK/FIXME, we skip the initial 0-size packets as they are most likely equal to the encoder delay,
2206 but it would be better if we had the real timestamps from the encoder */
2207 if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2208 av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2211 case CODEC_TYPE_VIDEO:
2212 av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2220 static void truncate_ts(AVStream *st, AVPacket *pkt){
2221 int64_t pts_mask = (2LL << (st->pts_wrap_bits-1)) - 1;
2224 // pkt->dts= 0; //this happens for low_delay=0 and b frames, FIXME, needs further invstigation about what we should do here
2226 if (pkt->pts != AV_NOPTS_VALUE)
2227 pkt->pts &= pts_mask;
2228 if (pkt->dts != AV_NOPTS_VALUE)
2229 pkt->dts &= pts_mask;
2232 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2236 ret=compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2237 if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2240 truncate_ts(s->streams[pkt->stream_index], pkt);
2242 ret= s->oformat->write_packet(s, pkt);
2244 ret= url_ferror(&s->pb);
2248 int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2249 AVPacketList *pktl, **next_point, *this_pktl;
2251 int streams[MAX_STREAMS];
2254 AVStream *st= s->streams[ pkt->stream_index];
2256 // assert(pkt->destruct != av_destruct_packet); //FIXME
2258 this_pktl = av_mallocz(sizeof(AVPacketList));
2259 this_pktl->pkt= *pkt;
2260 if(pkt->destruct == av_destruct_packet)
2261 pkt->destruct= NULL; // non shared -> must keep original from being freed
2263 av_dup_packet(&this_pktl->pkt); //shared -> must dup
2265 next_point = &s->packet_buffer;
2267 AVStream *st2= s->streams[ (*next_point)->pkt.stream_index];
2268 int64_t left= st2->time_base.num * (int64_t)st ->time_base.den;
2269 int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2270 if((*next_point)->pkt.dts * left > pkt->dts * right) //FIXME this can overflow
2272 next_point= &(*next_point)->next;
2274 this_pktl->next= *next_point;
2275 *next_point= this_pktl;
2278 memset(streams, 0, sizeof(streams));
2279 pktl= s->packet_buffer;
2281 //av_log(s, AV_LOG_DEBUG, "show st:%d dts:%"PRId64"\n", pktl->pkt.stream_index, pktl->pkt.dts);
2282 if(streams[ pktl->pkt.stream_index ] == 0)
2284 streams[ pktl->pkt.stream_index ]++;
2288 if(s->nb_streams == stream_count || (flush && stream_count)){
2289 pktl= s->packet_buffer;
2292 s->packet_buffer= pktl->next;
2296 av_init_packet(out);
2302 * Interleaves a AVPacket correctly so it can be muxed.
2303 * @param out the interleaved packet will be output here
2304 * @param in the input packet
2305 * @param flush 1 if no further packets are available as input and all
2306 * remaining packets should be output
2307 * @return 1 if a packet was output, 0 if no packet could be output,
2308 * < 0 if an error occured
2310 static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2311 if(s->oformat->interleave_packet)
2312 return s->oformat->interleave_packet(s, out, in, flush);
2314 return av_interleave_packet_per_dts(s, out, in, flush);
2317 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2318 AVStream *st= s->streams[ pkt->stream_index];
2320 //FIXME/XXX/HACK drop zero sized packets
2321 if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2324 //av_log(NULL, AV_LOG_DEBUG, "av_interleaved_write_frame %d %"PRId64" %"PRId64"\n", pkt->size, pkt->dts, pkt->pts);
2325 if(compute_pkt_fields2(st, pkt) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2328 if(pkt->dts == AV_NOPTS_VALUE)
2333 int ret= av_interleave_packet(s, &opkt, pkt, 0);
2334 if(ret<=0) //FIXME cleanup needed for ret<0 ?
2337 truncate_ts(s->streams[opkt.stream_index], &opkt);
2338 ret= s->oformat->write_packet(s, &opkt);
2340 av_free_packet(&opkt);
2345 if(url_ferror(&s->pb))
2346 return url_ferror(&s->pb);
2350 int av_write_trailer(AVFormatContext *s)
2356 ret= av_interleave_packet(s, &pkt, NULL, 1);
2357 if(ret<0) //FIXME cleanup needed for ret<0 ?
2362 truncate_ts(s->streams[pkt.stream_index], &pkt);
2363 ret= s->oformat->write_packet(s, &pkt);
2365 av_free_packet(&pkt);
2369 if(url_ferror(&s->pb))
2373 if(s->oformat->write_trailer)
2374 ret = s->oformat->write_trailer(s);
2377 ret=url_ferror(&s->pb);
2378 for(i=0;i<s->nb_streams;i++)
2379 av_freep(&s->streams[i]->priv_data);
2380 av_freep(&s->priv_data);
2384 /* "user interface" functions */
2386 void dump_format(AVFormatContext *ic,
2394 av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
2395 is_output ? "Output" : "Input",
2397 is_output ? ic->oformat->name : ic->iformat->name,
2398 is_output ? "to" : "from", url);
2400 av_log(NULL, AV_LOG_INFO, " Duration: ");
2401 if (ic->duration != AV_NOPTS_VALUE) {
2402 int hours, mins, secs, us;
2403 secs = ic->duration / AV_TIME_BASE;
2404 us = ic->duration % AV_TIME_BASE;
2409 av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%01d", hours, mins, secs,
2410 (10 * us) / AV_TIME_BASE);
2412 av_log(NULL, AV_LOG_INFO, "N/A");
2414 if (ic->start_time != AV_NOPTS_VALUE) {
2416 av_log(NULL, AV_LOG_INFO, ", start: ");
2417 secs = ic->start_time / AV_TIME_BASE;
2418 us = ic->start_time % AV_TIME_BASE;
2419 av_log(NULL, AV_LOG_INFO, "%d.%06d",
2420 secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
2422 av_log(NULL, AV_LOG_INFO, ", bitrate: ");
2424 av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
2426 av_log(NULL, AV_LOG_INFO, "N/A");
2428 av_log(NULL, AV_LOG_INFO, "\n");
2430 for(i=0;i<ic->nb_streams;i++) {
2431 AVStream *st = ic->streams[i];
2432 int g= ff_gcd(st->time_base.num, st->time_base.den);
2433 avcodec_string(buf, sizeof(buf), st->codec, is_output);
2434 av_log(NULL, AV_LOG_INFO, " Stream #%d.%d", index, i);
2435 /* the pid is an important information, so we display it */
2436 /* XXX: add a generic system */
2438 flags = ic->oformat->flags;
2440 flags = ic->iformat->flags;
2441 if (flags & AVFMT_SHOW_IDS) {
2442 av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
2444 if (strlen(st->language) > 0) {
2445 av_log(NULL, AV_LOG_INFO, "(%s)", st->language);
2447 av_log(NULL, AV_LOG_DEBUG, ", %d/%d", st->time_base.num/g, st->time_base.den/g);
2448 av_log(NULL, AV_LOG_INFO, ": %s", buf);
2449 if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2450 if(st->r_frame_rate.den && st->r_frame_rate.num)
2451 av_log(NULL, AV_LOG_INFO, ", %5.2f fps(r)", av_q2d(st->r_frame_rate));
2452 /* else if(st->time_base.den && st->time_base.num)
2453 av_log(NULL, AV_LOG_INFO, ", %5.2f fps(m)", 1/av_q2d(st->time_base));*/
2455 av_log(NULL, AV_LOG_INFO, ", %5.2f fps(c)", 1/av_q2d(st->codec->time_base));
2457 av_log(NULL, AV_LOG_INFO, "\n");
2464 int frame_rate, frame_rate_base;
2467 static AbvEntry frame_abvs[] = {
2468 { "ntsc", 720, 480, 30000, 1001 },
2469 { "pal", 720, 576, 25, 1 },
2470 { "qntsc", 352, 240, 30000, 1001 }, /* VCD compliant ntsc */
2471 { "qpal", 352, 288, 25, 1 }, /* VCD compliant pal */
2472 { "sntsc", 640, 480, 30000, 1001 }, /* square pixel ntsc */
2473 { "spal", 768, 576, 25, 1 }, /* square pixel pal */
2474 { "film", 352, 240, 24, 1 },
2475 { "ntsc-film", 352, 240, 24000, 1001 },
2476 { "sqcif", 128, 96, 0, 0 },
2477 { "qcif", 176, 144, 0, 0 },
2478 { "cif", 352, 288, 0, 0 },
2479 { "4cif", 704, 576, 0, 0 },
2482 int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2485 int n = sizeof(frame_abvs) / sizeof(AbvEntry);
2487 int frame_width = 0, frame_height = 0;
2490 if (!strcmp(frame_abvs[i].abv, str)) {
2491 frame_width = frame_abvs[i].width;
2492 frame_height = frame_abvs[i].height;
2498 frame_width = strtol(p, (char **)&p, 10);
2501 frame_height = strtol(p, (char **)&p, 10);
2503 if (frame_width <= 0 || frame_height <= 0)
2505 *width_ptr = frame_width;
2506 *height_ptr = frame_height;
2510 int parse_frame_rate(int *frame_rate, int *frame_rate_base, const char *arg)
2515 /* First, we check our abbreviation table */
2516 for (i = 0; i < sizeof(frame_abvs)/sizeof(*frame_abvs); ++i)
2517 if (!strcmp(frame_abvs[i].abv, arg)) {
2518 *frame_rate = frame_abvs[i].frame_rate;
2519 *frame_rate_base = frame_abvs[i].frame_rate_base;
2523 /* Then, we try to parse it as fraction */
2524 cp = strchr(arg, '/');
2526 cp = strchr(arg, ':');
2529 *frame_rate = strtol(arg, &cpp, 10);
2530 if (cpp != arg || cpp == cp)
2531 *frame_rate_base = strtol(cp+1, &cpp, 10);
2536 /* Finally we give up and parse it as double */
2537 AVRational time_base = av_d2q(strtod(arg, 0), DEFAULT_FRAME_RATE_BASE);
2538 *frame_rate_base = time_base.den;
2539 *frame_rate = time_base.num;
2541 if (!*frame_rate || !*frame_rate_base)
2547 int64_t parse_date(const char *datestr, int duration)
2553 static const char *date_fmt[] = {
2557 static const char *time_fmt[] = {
2567 time_t now = time(0);
2569 len = strlen(datestr);
2571 lastch = datestr[len - 1];
2574 is_utc = (lastch == 'z' || lastch == 'Z');
2576 memset(&dt, 0, sizeof(dt));
2581 for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
2582 q = small_strptime(p, date_fmt[i], &dt);
2592 dt = *localtime(&now);
2594 dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
2599 if (*p == 'T' || *p == 't' || *p == ' ')
2602 for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
2603 q = small_strptime(p, time_fmt[i], &dt);
2613 q = small_strptime(p, time_fmt[0], &dt);
2615 dt.tm_sec = strtol(p, (char **)&q, 10);
2621 /* Now we have all the fields that we can get */
2626 return now * INT64_C(1000000);
2630 t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2632 dt.tm_isdst = -1; /* unknown */
2645 for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
2648 val += n * (*q - '0');
2652 return negative ? -t : t;
2655 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
2665 while (*p != '\0' && *p != '=' && *p != '&') {
2666 if ((q - tag) < sizeof(tag) - 1)
2674 while (*p != '&' && *p != '\0') {
2675 if ((q - arg) < arg_size - 1) {
2685 if (!strcmp(tag, tag1))
2694 int av_get_frame_filename(char *buf, int buf_size,
2695 const char *path, int number)
2698 char *q, buf1[20], c;
2699 int nd, len, percentd_found;
2711 while (isdigit(*p)) {
2712 nd = nd * 10 + *p++ - '0';
2715 } while (isdigit(c));
2724 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
2726 if ((q - buf + len) > buf_size - 1)
2728 memcpy(q, buf1, len);
2736 if ((q - buf) < buf_size - 1)
2740 if (!percentd_found)
2749 static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
2752 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
2754 for(i=0;i<size;i+=16) {
2761 PRINT(" %02x", buf[i+j]);
2766 for(j=0;j<len;j++) {
2768 if (c < ' ' || c > '~')
2777 void av_hex_dump(FILE *f, uint8_t *buf, int size)
2779 hex_dump_internal(NULL, f, 0, buf, size);
2782 void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
2784 hex_dump_internal(avcl, NULL, level, buf, size);
2787 //FIXME needs to know the time_base
2788 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload)
2790 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
2791 PRINT("stream #%d:\n", pkt->stream_index);
2792 PRINT(" keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
2793 PRINT(" duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
2794 /* DTS is _always_ valid after av_read_frame() */
2796 if (pkt->dts == AV_NOPTS_VALUE)
2799 PRINT("%0.3f", (double)pkt->dts / AV_TIME_BASE);
2800 /* PTS may be not known if B frames are present */
2802 if (pkt->pts == AV_NOPTS_VALUE)
2805 PRINT("%0.3f", (double)pkt->pts / AV_TIME_BASE);
2807 PRINT(" size=%d\n", pkt->size);
2810 av_hex_dump(f, pkt->data, pkt->size);
2813 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
2815 pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
2818 void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
2820 pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
2823 void url_split(char *proto, int proto_size,
2824 char *authorization, int authorization_size,
2825 char *hostname, int hostname_size,
2827 char *path, int path_size,
2838 while (*p != ':' && *p != '\0') {
2839 if ((q - proto) < proto_size - 1)
2845 if (authorization_size > 0)
2846 authorization[0] = '\0';
2850 if (hostname_size > 0)
2854 char *at,*slash; // PETR: position of '@' character and '/' character
2861 at = strchr(p,'@'); // PETR: get the position of '@'
2862 slash = strchr(p,'/'); // PETR: get position of '/' - end of hostname
2863 if (at && slash && at > slash) at = NULL; // PETR: not interested in '@' behind '/'
2865 q = at ? authorization : hostname; // PETR: if '@' exists starting with auth.
2867 while ((at || *p != ':') && *p != '/' && *p != '?' && *p != '\0') { // PETR:
2868 if (*p == '@') { // PETR: passed '@'
2869 if (authorization_size > 0)
2873 } else if (!at) { // PETR: hostname
2874 if ((q - hostname) < hostname_size - 1)
2877 if ((q - authorization) < authorization_size - 1)
2882 if (hostname_size > 0)
2886 port = strtoul(p, (char **)&p, 10);
2891 pstrcpy(path, path_size, p);
2894 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
2895 int pts_num, int pts_den)
2897 s->pts_wrap_bits = pts_wrap_bits;
2898 s->time_base.num = pts_num;
2899 s->time_base.den = pts_den;
2902 /* fraction handling */
2905 * f = val + (num / den) + 0.5.
2907 * 'num' is normalized so that it is such as 0 <= num < den.
2909 * @param f fractional number
2910 * @param val integer value
2911 * @param num must be >= 0
2912 * @param den must be >= 1
2914 static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
2927 * Fractionnal addition to f: f = f + (incr / f->den).
2929 * @param f fractional number
2930 * @param incr increment, can be positive or negative
2932 static void av_frac_add(AVFrac *f, int64_t incr)
2936 num = f->num + incr;
2939 f->val += num / den;
2945 } else if (num >= den) {
2946 f->val += num / den;