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"
30 * @file libavformat/utils.c
31 * Various utility functions for using ffmpeg library.
34 static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den);
35 static void av_frac_add(AVFrac *f, int64_t incr);
37 /** head of registered input format linked list. */
38 AVInputFormat *first_iformat = NULL;
39 /** head of registered output format linked list. */
40 AVOutputFormat *first_oformat = NULL;
42 void av_register_input_format(AVInputFormat *format)
46 while (*p != NULL) p = &(*p)->next;
51 void av_register_output_format(AVOutputFormat *format)
55 while (*p != NULL) p = &(*p)->next;
60 int match_ext(const char *filename, const char *extensions)
68 ext = strrchr(filename, '.');
74 while (*p != '\0' && *p != ',' && q-ext1<sizeof(ext1)-1)
77 if (!strcasecmp(ext1, ext))
87 AVOutputFormat *guess_format(const char *short_name, const char *filename,
88 const char *mime_type)
90 AVOutputFormat *fmt, *fmt_found;
93 /* specific test for image sequences */
94 #ifdef CONFIG_IMAGE2_MUXER
95 if (!short_name && filename &&
96 av_filename_number_test(filename) &&
97 av_guess_image2_codec(filename) != CODEC_ID_NONE) {
98 return guess_format("image2", NULL, NULL);
101 /* find the proper file type */
105 while (fmt != NULL) {
107 if (fmt->name && short_name && !strcmp(fmt->name, short_name))
109 if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
111 if (filename && fmt->extensions &&
112 match_ext(filename, fmt->extensions)) {
115 if (score > score_max) {
124 AVOutputFormat *guess_stream_format(const char *short_name, const char *filename,
125 const char *mime_type)
127 AVOutputFormat *fmt = guess_format(short_name, filename, mime_type);
130 AVOutputFormat *stream_fmt;
131 char stream_format_name[64];
133 snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
134 stream_fmt = guess_format(stream_format_name, NULL, NULL);
143 enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
144 const char *filename, const char *mime_type, enum CodecType type){
145 if(type == CODEC_TYPE_VIDEO){
146 enum CodecID codec_id= CODEC_ID_NONE;
148 #ifdef CONFIG_IMAGE2_MUXER
149 if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
150 codec_id= av_guess_image2_codec(filename);
153 if(codec_id == CODEC_ID_NONE)
154 codec_id= fmt->video_codec;
156 }else if(type == CODEC_TYPE_AUDIO)
157 return fmt->audio_codec;
159 return CODEC_ID_NONE;
162 AVInputFormat *av_find_input_format(const char *short_name)
165 for(fmt = first_iformat; fmt != NULL; fmt = fmt->next) {
166 if (!strcmp(fmt->name, short_name))
172 /* memory handling */
174 void av_destruct_packet(AVPacket *pkt)
177 pkt->data = NULL; pkt->size = 0;
180 void av_init_packet(AVPacket *pkt)
182 pkt->pts = AV_NOPTS_VALUE;
183 pkt->dts = AV_NOPTS_VALUE;
187 pkt->stream_index = 0;
188 pkt->destruct= av_destruct_packet_nofree;
191 int av_new_packet(AVPacket *pkt, int size)
194 if((unsigned)size > (unsigned)size + FF_INPUT_BUFFER_PADDING_SIZE)
195 return AVERROR_NOMEM;
196 data = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
198 return AVERROR_NOMEM;
199 memset(data + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
204 pkt->destruct = av_destruct_packet;
208 int av_get_packet(ByteIOContext *s, AVPacket *pkt, int size)
210 int ret= av_new_packet(pkt, size);
215 pkt->pos= url_ftell(s);
217 ret= get_buffer(s, pkt->data, size);
226 int av_dup_packet(AVPacket *pkt)
228 if (pkt->destruct != av_destruct_packet) {
230 /* we duplicate the packet and don't forget to put the padding
232 if((unsigned)pkt->size > (unsigned)pkt->size + FF_INPUT_BUFFER_PADDING_SIZE)
233 return AVERROR_NOMEM;
234 data = av_malloc(pkt->size + FF_INPUT_BUFFER_PADDING_SIZE);
236 return AVERROR_NOMEM;
238 memcpy(data, pkt->data, pkt->size);
239 memset(data + pkt->size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
241 pkt->destruct = av_destruct_packet;
246 int av_filename_number_test(const char *filename)
249 return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
252 static AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
254 AVInputFormat *fmt1, *fmt;
258 for(fmt1 = first_iformat; fmt1 != NULL; fmt1 = fmt1->next) {
259 if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
262 if (fmt1->read_probe) {
263 score = fmt1->read_probe(pd);
264 } else if (fmt1->extensions) {
265 if (match_ext(pd->filename, fmt1->extensions)) {
269 if (score > *score_max) {
277 AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
279 return av_probe_input_format2(pd, is_opened, &score);
282 /************************************************************/
283 /* input media file */
286 * Open a media file from an IO stream. 'fmt' must be specified.
288 static const char* format_to_name(void* ptr)
290 AVFormatContext* fc = (AVFormatContext*) ptr;
291 if(fc->iformat) return fc->iformat->name;
292 else if(fc->oformat) return fc->oformat->name;
296 #define OFFSET(x) offsetof(AVFormatContext,x)
297 #define DEFAULT 0 //should be NAN but it does not work as it is not a constant in glibc as required by ANSI/ISO C
298 //these names are too long to be readable
299 #define E AV_OPT_FLAG_ENCODING_PARAM
300 #define D AV_OPT_FLAG_DECODING_PARAM
302 static const AVOption options[]={
303 {"probesize", NULL, OFFSET(probesize), FF_OPT_TYPE_INT, 32000, 32, INT_MAX, D}, /* 32000 from mpegts.c: 1.0 second at 24Mbit/s */
304 {"muxrate", "set mux rate", OFFSET(mux_rate), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
305 {"packetsize", "set packet size", OFFSET(packet_size), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
306 {"fflags", NULL, OFFSET(flags), FF_OPT_TYPE_FLAGS, DEFAULT, INT_MIN, INT_MAX, D|E, "fflags"},
307 {"ignidx", "ignore index", 0, FF_OPT_TYPE_CONST, AVFMT_FLAG_IGNIDX, INT_MIN, INT_MAX, D, "fflags"},
308 {"genpts", "generate pts", 0, FF_OPT_TYPE_CONST, AVFMT_FLAG_GENPTS, INT_MIN, INT_MAX, D, "fflags"},
309 {"track", " set the track number", OFFSET(track), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
310 {"year", "set the year", OFFSET(year), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, E},
311 {"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},
319 static const AVClass av_format_context_class = { "AVFormatContext", format_to_name, options };
321 static void avformat_get_context_defaults(AVFormatContext *s)
323 memset(s, 0, sizeof(AVFormatContext));
325 s->av_class = &av_format_context_class;
327 av_opt_set_defaults(s);
330 AVFormatContext *av_alloc_format_context(void)
333 ic = av_malloc(sizeof(AVFormatContext));
335 avformat_get_context_defaults(ic);
336 ic->av_class = &av_format_context_class;
340 int av_open_input_stream(AVFormatContext **ic_ptr,
341 ByteIOContext *pb, const char *filename,
342 AVInputFormat *fmt, AVFormatParameters *ap)
346 AVFormatParameters default_ap;
350 memset(ap, 0, sizeof(default_ap));
353 if(!ap->prealloced_context)
354 ic = av_alloc_format_context();
364 ic->duration = AV_NOPTS_VALUE;
365 ic->start_time = AV_NOPTS_VALUE;
366 av_strlcpy(ic->filename, filename, sizeof(ic->filename));
368 /* allocate private data */
369 if (fmt->priv_data_size > 0) {
370 ic->priv_data = av_mallocz(fmt->priv_data_size);
371 if (!ic->priv_data) {
376 ic->priv_data = NULL;
379 err = ic->iformat->read_header(ic, ap);
383 if (pb && !ic->data_offset)
384 ic->data_offset = url_ftell(&ic->pb);
390 av_freep(&ic->priv_data);
397 /** Size of probe buffer, for guessing file type from file contents. */
398 #define PROBE_BUF_MIN 2048
399 #define PROBE_BUF_MAX (1<<20)
401 int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
404 AVFormatParameters *ap)
406 int err, must_open_file, file_opened, probe_size;
407 AVProbeData probe_data, *pd = &probe_data;
408 ByteIOContext pb1, *pb = &pb1;
413 pd->filename = filename;
418 /* guess format if no file can be opened */
419 fmt = av_probe_input_format(pd, 0);
422 /* do not open file if the format does not need it. XXX: specific
423 hack needed to handle RTSP/TCP */
425 if (fmt && (fmt->flags & AVFMT_NOFILE)) {
427 pb= NULL; //FIXME this or memset(pb, 0, sizeof(ByteIOContext)); otherwise it is uninitialized
430 if (!fmt || must_open_file) {
431 /* if no file needed do not try to open one */
432 if ((err=url_fopen(pb, filename, URL_RDONLY)) < 0) {
437 url_setbufsize(pb, buf_size);
440 for(probe_size= PROBE_BUF_MIN; probe_size<=PROBE_BUF_MAX && !fmt; probe_size<<=1){
441 int score= probe_size < PROBE_BUF_MAX ? AVPROBE_SCORE_MAX/4 : 0;
442 /* read probe data */
443 pd->buf= av_realloc(pd->buf, probe_size + AVPROBE_PADDING_SIZE);
444 pd->buf_size = get_buffer(pb, pd->buf, probe_size);
445 if (url_fseek(pb, 0, SEEK_SET) < 0) {
447 if (url_fopen(pb, filename, URL_RDONLY) < 0) {
453 /* guess file format */
454 fmt = av_probe_input_format2(pd, 1, &score);
459 /* if still no format found, error */
465 /* XXX: suppress this hack for redirectors */
466 #ifdef CONFIG_REDIR_DEMUXER
467 if (fmt == &redir_demuxer) {
468 err = redir_open(ic_ptr, pb);
474 /* check filename in case of an image number is expected */
475 if (fmt->flags & AVFMT_NEEDNUMBER) {
476 if (!av_filename_number_test(filename)) {
477 err = AVERROR_NUMEXPECTED;
481 err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
494 /*******************************************************/
496 int av_read_packet(AVFormatContext *s, AVPacket *pkt)
499 return s->iformat->read_packet(s, pkt);
502 /**********************************************************/
505 * Get the number of samples of an audio frame. Return (-1) if error.
507 static int get_audio_frame_size(AVCodecContext *enc, int size)
511 if (enc->frame_size <= 1) {
512 int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
514 if (bits_per_sample) {
515 if (enc->channels == 0)
517 frame_size = (size << 3) / (bits_per_sample * enc->channels);
519 /* used for example by ADPCM codecs */
520 if (enc->bit_rate == 0)
522 frame_size = (size * 8 * enc->sample_rate) / enc->bit_rate;
525 frame_size = enc->frame_size;
532 * Return the frame duration in seconds, return 0 if not available.
534 static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
535 AVCodecParserContext *pc, AVPacket *pkt)
541 switch(st->codec->codec_type) {
542 case CODEC_TYPE_VIDEO:
543 if(st->time_base.num*1000LL > st->time_base.den){
544 *pnum = st->time_base.num;
545 *pden = st->time_base.den;
546 }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
547 *pnum = st->codec->time_base.num;
548 *pden = st->codec->time_base.den;
549 if (pc && pc->repeat_pict) {
551 *pnum = (*pnum) * (2 + pc->repeat_pict);
555 case CODEC_TYPE_AUDIO:
556 frame_size = get_audio_frame_size(st->codec, pkt->size);
560 *pden = st->codec->sample_rate;
567 static int is_intra_only(AVCodecContext *enc){
568 if(enc->codec_type == CODEC_TYPE_AUDIO){
570 }else if(enc->codec_type == CODEC_TYPE_VIDEO){
571 switch(enc->codec_id){
573 case CODEC_ID_MJPEGB:
575 case CODEC_ID_RAWVIDEO:
576 case CODEC_ID_DVVIDEO:
577 case CODEC_ID_HUFFYUV:
578 case CODEC_ID_FFVHUFF:
589 static int64_t lsb2full(int64_t lsb, int64_t last_ts, int lsb_bits){
590 int64_t mask = lsb_bits < 64 ? (1LL<<lsb_bits)-1 : -1LL;
591 int64_t delta= last_ts - mask/2;
592 return ((lsb - delta)&mask) + delta;
595 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
596 AVCodecParserContext *pc, AVPacket *pkt)
598 int num, den, presentation_delayed, delay, i;
600 /* handle wrapping */
601 if(st->cur_dts != AV_NOPTS_VALUE){
602 if(pkt->pts != AV_NOPTS_VALUE)
603 pkt->pts= lsb2full(pkt->pts, st->cur_dts, st->pts_wrap_bits);
604 if(pkt->dts != AV_NOPTS_VALUE)
605 pkt->dts= lsb2full(pkt->dts, st->cur_dts, st->pts_wrap_bits);
608 if (pkt->duration == 0) {
609 compute_frame_duration(&num, &den, st, pc, pkt);
611 pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
615 /* correct timestamps with byte offset if demuxers only have timestamps on packet boundaries */
616 if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
617 /* this will estimate bitrate based on this frame's duration and size */
618 offset = av_rescale(pc->offset, pkt->duration, pkt->size);
619 if(pkt->pts != AV_NOPTS_VALUE)
621 if(pkt->dts != AV_NOPTS_VALUE)
625 if(is_intra_only(st->codec))
626 pkt->flags |= PKT_FLAG_KEY;
628 /* do we have a video B frame ? */
629 delay= st->codec->has_b_frames;
630 presentation_delayed = 0;
631 /* XXX: need has_b_frame, but cannot get it if the codec is
634 pc && pc->pict_type != FF_B_TYPE)
635 presentation_delayed = 1;
636 /* This may be redundant, but it should not hurt. */
637 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
638 presentation_delayed = 1;
640 if(st->cur_dts == AV_NOPTS_VALUE){
641 st->cur_dts = -delay * pkt->duration;
644 // 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);
645 /* interpolate PTS and DTS if they are not present */
647 if (presentation_delayed) {
648 /* DTS = decompression time stamp */
649 /* PTS = presentation time stamp */
650 if (pkt->dts == AV_NOPTS_VALUE)
651 pkt->dts = st->last_IP_pts;
652 if (pkt->dts == AV_NOPTS_VALUE)
653 pkt->dts = st->cur_dts;
655 /* this is tricky: the dts must be incremented by the duration
656 of the frame we are displaying, i.e. the last I or P frame */
657 if (st->last_IP_duration == 0)
658 st->last_IP_duration = pkt->duration;
659 st->cur_dts = pkt->dts + st->last_IP_duration;
660 st->last_IP_duration = pkt->duration;
661 st->last_IP_pts= pkt->pts;
662 /* cannot compute PTS if not present (we can compute it only
663 by knowing the futur */
664 } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
665 if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
666 int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
667 int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
668 if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
669 pkt->pts += pkt->duration;
670 // 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);
674 /* presentation is not delayed : PTS and DTS are the same */
675 if(pkt->pts == AV_NOPTS_VALUE)
677 if(pkt->pts == AV_NOPTS_VALUE)
678 pkt->pts = st->cur_dts;
680 st->cur_dts = pkt->pts + pkt->duration;
684 if(pkt->pts != AV_NOPTS_VALUE){
685 st->pts_buffer[0]= pkt->pts;
686 for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
687 st->pts_buffer[i]= (i-delay-1) * pkt->duration;
688 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
689 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
690 if(pkt->dts == AV_NOPTS_VALUE)
691 pkt->dts= st->pts_buffer[0];
692 if(pkt->dts > st->cur_dts)
693 st->cur_dts = pkt->dts;
696 // 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);
701 /* key frame computation */
702 if (pc->pict_type == FF_I_TYPE)
703 pkt->flags |= PKT_FLAG_KEY;
707 void av_destruct_packet_nofree(AVPacket *pkt)
709 pkt->data = NULL; pkt->size = 0;
712 static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
720 /* select current input stream component */
723 if (!st->need_parsing || !st->parser) {
724 /* no parsing needed: we just output the packet as is */
725 /* raw data support */
727 compute_pkt_fields(s, st, NULL, pkt);
730 } else if (s->cur_len > 0 && st->discard < AVDISCARD_ALL) {
731 len = av_parser_parse(st->parser, st->codec, &pkt->data, &pkt->size,
732 s->cur_ptr, s->cur_len,
733 s->cur_pkt.pts, s->cur_pkt.dts);
734 s->cur_pkt.pts = AV_NOPTS_VALUE;
735 s->cur_pkt.dts = AV_NOPTS_VALUE;
736 /* increment read pointer */
740 /* return packet if any */
743 pkt->pos = s->cur_pkt.pos; // Isn't quite accurate but close.
745 pkt->stream_index = st->index;
746 pkt->pts = st->parser->pts;
747 pkt->dts = st->parser->dts;
748 pkt->destruct = av_destruct_packet_nofree;
749 compute_pkt_fields(s, st, st->parser, pkt);
751 if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & PKT_FLAG_KEY){
752 av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
753 0, 0, AVINDEX_KEYFRAME);
760 av_free_packet(&s->cur_pkt);
764 /* read next packet */
765 ret = av_read_packet(s, &s->cur_pkt);
767 if (ret == AVERROR(EAGAIN))
769 /* return the last frames, if any */
770 for(i = 0; i < s->nb_streams; i++) {
772 if (st->parser && st->need_parsing) {
773 av_parser_parse(st->parser, st->codec,
774 &pkt->data, &pkt->size,
776 AV_NOPTS_VALUE, AV_NOPTS_VALUE);
781 /* no more packets: really terminates parsing */
785 st = s->streams[s->cur_pkt.stream_index];
786 if(st->codec->debug & FF_DEBUG_PTS)
787 av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
788 s->cur_pkt.stream_index,
794 s->cur_ptr = s->cur_pkt.data;
795 s->cur_len = s->cur_pkt.size;
796 if (st->need_parsing && !st->parser) {
797 st->parser = av_parser_init(st->codec->codec_id);
799 /* no parser available : just output the raw packets */
800 st->need_parsing = AVSTREAM_PARSE_NONE;
801 }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
802 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
804 if(st->parser && (s->iformat->flags & AVFMT_GENERIC_INDEX)){
805 st->parser->last_frame_offset=
806 st->parser->cur_offset= s->cur_pkt.pos;
811 if(st->codec->debug & FF_DEBUG_PTS)
812 av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
821 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
825 const int genpts= s->flags & AVFMT_FLAG_GENPTS;
828 pktl = s->packet_buffer;
830 AVPacket *next_pkt= &pktl->pkt;
832 if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
833 while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
834 if( pktl->pkt.stream_index == next_pkt->stream_index
835 && next_pkt->dts < pktl->pkt.dts
836 && pktl->pkt.pts != pktl->pkt.dts //not b frame
837 /*&& pktl->pkt.dts != AV_NOPTS_VALUE*/){
838 next_pkt->pts= pktl->pkt.dts;
842 pktl = s->packet_buffer;
845 if( next_pkt->pts != AV_NOPTS_VALUE
846 || next_pkt->dts == AV_NOPTS_VALUE
848 /* read packet from packet buffer, if there is data */
850 s->packet_buffer = pktl->next;
856 AVPacketList **plast_pktl= &s->packet_buffer;
857 int ret= av_read_frame_internal(s, pkt);
859 if(pktl && ret != AVERROR(EAGAIN)){
866 /* duplicate the packet */
867 if (av_dup_packet(pkt) < 0)
868 return AVERROR_NOMEM;
870 while(*plast_pktl) plast_pktl= &(*plast_pktl)->next; //FIXME maybe maintain pointer to the last?
872 pktl = av_mallocz(sizeof(AVPacketList));
874 return AVERROR_NOMEM;
876 /* add the packet in the buffered packet list */
880 assert(!s->packet_buffer);
881 return av_read_frame_internal(s, pkt);
886 /* XXX: suppress the packet queue */
887 static void flush_packet_queue(AVFormatContext *s)
892 pktl = s->packet_buffer;
895 s->packet_buffer = pktl->next;
896 av_free_packet(&pktl->pkt);
901 /*******************************************************/
904 int av_find_default_stream_index(AVFormatContext *s)
909 if (s->nb_streams <= 0)
911 for(i = 0; i < s->nb_streams; i++) {
913 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
921 * Flush the frame reader.
923 static void av_read_frame_flush(AVFormatContext *s)
928 flush_packet_queue(s);
930 /* free previous packet */
932 if (s->cur_st->parser)
933 av_free_packet(&s->cur_pkt);
940 /* for each stream, reset read state */
941 for(i = 0; i < s->nb_streams; i++) {
945 av_parser_close(st->parser);
948 st->last_IP_pts = AV_NOPTS_VALUE;
949 st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
953 void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
956 for(i = 0; i < s->nb_streams; i++) {
957 AVStream *st = s->streams[i];
959 st->cur_dts = av_rescale(timestamp,
960 st->time_base.den * (int64_t)ref_st->time_base.num,
961 st->time_base.num * (int64_t)ref_st->time_base.den);
965 int av_add_index_entry(AVStream *st,
966 int64_t pos, int64_t timestamp, int size, int distance, int flags)
968 AVIndexEntry *entries, *ie;
971 if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
974 entries = av_fast_realloc(st->index_entries,
975 &st->index_entries_allocated_size,
976 (st->nb_index_entries + 1) *
977 sizeof(AVIndexEntry));
981 st->index_entries= entries;
983 index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
986 index= st->nb_index_entries++;
988 assert(index==0 || ie[-1].timestamp < timestamp);
991 if(ie->timestamp != timestamp){
992 if(ie->timestamp <= timestamp)
994 memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
995 st->nb_index_entries++;
996 }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
997 distance= ie->min_distance;
1001 ie->timestamp = timestamp;
1002 ie->min_distance= distance;
1009 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1012 AVIndexEntry *entries= st->index_entries;
1013 int nb_entries= st->nb_index_entries;
1022 timestamp = entries[m].timestamp;
1023 if(timestamp >= wanted_timestamp)
1025 if(timestamp <= wanted_timestamp)
1028 m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1030 if(!(flags & AVSEEK_FLAG_ANY)){
1031 while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1032 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1043 int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1044 AVInputFormat *avif= s->iformat;
1045 int64_t pos_min, pos_max, pos, pos_limit;
1046 int64_t ts_min, ts_max, ts;
1050 if (stream_index < 0)
1054 av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1058 ts_min= AV_NOPTS_VALUE;
1059 pos_limit= -1; //gcc falsely says it may be uninitialized
1061 st= s->streams[stream_index];
1062 if(st->index_entries){
1065 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()
1066 index= FFMAX(index, 0);
1067 e= &st->index_entries[index];
1069 if(e->timestamp <= target_ts || e->pos == e->min_distance){
1071 ts_min= e->timestamp;
1073 av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1080 index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1081 assert(index < st->nb_index_entries);
1083 e= &st->index_entries[index];
1084 assert(e->timestamp >= target_ts);
1086 ts_max= e->timestamp;
1087 pos_limit= pos_max - e->min_distance;
1089 av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1090 pos_max,pos_limit, ts_max);
1095 pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1100 url_fseek(&s->pb, pos, SEEK_SET);
1102 av_update_cur_dts(s, st, ts);
1107 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 )){
1109 int64_t start_pos, filesize;
1113 av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1116 if(ts_min == AV_NOPTS_VALUE){
1117 pos_min = s->data_offset;
1118 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1119 if (ts_min == AV_NOPTS_VALUE)
1123 if(ts_max == AV_NOPTS_VALUE){
1125 filesize = url_fsize(&s->pb);
1126 pos_max = filesize - 1;
1129 ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1131 }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1132 if (ts_max == AV_NOPTS_VALUE)
1136 int64_t tmp_pos= pos_max + 1;
1137 int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1138 if(tmp_ts == AV_NOPTS_VALUE)
1142 if(tmp_pos >= filesize)
1148 if(ts_min > ts_max){
1150 }else if(ts_min == ts_max){
1155 while (pos_min < pos_limit) {
1157 av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1161 assert(pos_limit <= pos_max);
1164 int64_t approximate_keyframe_distance= pos_max - pos_limit;
1165 // interpolate position (better than dichotomy)
1166 pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1167 + pos_min - approximate_keyframe_distance;
1168 }else if(no_change==1){
1169 // bisection, if interpolation failed to change min or max pos last time
1170 pos = (pos_min + pos_limit)>>1;
1172 // linear search if bisection failed, can only happen if there are very few or no keframes between min/max
1177 else if(pos > pos_limit)
1181 ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1187 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);
1189 if(ts == AV_NOPTS_VALUE){
1190 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1193 assert(ts != AV_NOPTS_VALUE);
1194 if (target_ts <= ts) {
1195 pos_limit = start_pos - 1;
1199 if (target_ts >= ts) {
1205 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1206 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
1209 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1211 ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1212 av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1213 pos, ts_min, target_ts, ts_max);
1219 static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1220 int64_t pos_min, pos_max;
1224 if (stream_index < 0)
1227 st= s->streams[stream_index];
1230 pos_min = s->data_offset;
1231 pos_max = url_fsize(&s->pb) - 1;
1233 if (pos < pos_min) pos= pos_min;
1234 else if(pos > pos_max) pos= pos_max;
1236 url_fseek(&s->pb, pos, SEEK_SET);
1239 av_update_cur_dts(s, st, ts);
1244 static int av_seek_frame_generic(AVFormatContext *s,
1245 int stream_index, int64_t timestamp, int flags)
1251 st = s->streams[stream_index];
1253 index = av_index_search_timestamp(st, timestamp, flags);
1255 if(index < 0 || index==st->nb_index_entries-1){
1259 if(st->index_entries && st->nb_index_entries){
1260 ie= &st->index_entries[st->nb_index_entries-1];
1261 url_fseek(&s->pb, ie->pos, SEEK_SET);
1262 av_update_cur_dts(s, st, ie->timestamp);
1264 url_fseek(&s->pb, 0, SEEK_SET);
1267 int ret = av_read_frame(s, &pkt);
1270 av_free_packet(&pkt);
1271 if(stream_index == pkt.stream_index){
1272 if((pkt.flags & PKT_FLAG_KEY) && pkt.dts > timestamp)
1276 index = av_index_search_timestamp(st, timestamp, flags);
1281 av_read_frame_flush(s);
1282 if (s->iformat->read_seek){
1283 if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1286 ie = &st->index_entries[index];
1287 url_fseek(&s->pb, ie->pos, SEEK_SET);
1289 av_update_cur_dts(s, st, ie->timestamp);
1294 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1299 av_read_frame_flush(s);
1301 if(flags & AVSEEK_FLAG_BYTE)
1302 return av_seek_frame_byte(s, stream_index, timestamp, flags);
1304 if(stream_index < 0){
1305 stream_index= av_find_default_stream_index(s);
1306 if(stream_index < 0)
1309 st= s->streams[stream_index];
1310 /* timestamp for default must be expressed in AV_TIME_BASE units */
1311 timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1313 st= s->streams[stream_index];
1315 /* first, we try the format specific seek */
1316 if (s->iformat->read_seek)
1317 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1324 if(s->iformat->read_timestamp)
1325 return av_seek_frame_binary(s, stream_index, timestamp, flags);
1327 return av_seek_frame_generic(s, stream_index, timestamp, flags);
1330 /*******************************************************/
1333 * Returns TRUE if the stream has accurate timings in any stream.
1335 * @return TRUE if the stream has accurate timings for at least one component.
1337 static int av_has_timings(AVFormatContext *ic)
1342 for(i = 0;i < ic->nb_streams; i++) {
1343 st = ic->streams[i];
1344 if (st->start_time != AV_NOPTS_VALUE &&
1345 st->duration != AV_NOPTS_VALUE)
1352 * Estimate the stream timings from the one of each components.
1354 * Also computes the global bitrate if possible.
1356 static void av_update_stream_timings(AVFormatContext *ic)
1358 int64_t start_time, start_time1, end_time, end_time1;
1362 start_time = INT64_MAX;
1363 end_time = INT64_MIN;
1364 for(i = 0;i < ic->nb_streams; i++) {
1365 st = ic->streams[i];
1366 if (st->start_time != AV_NOPTS_VALUE) {
1367 start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1368 if (start_time1 < start_time)
1369 start_time = start_time1;
1370 if (st->duration != AV_NOPTS_VALUE) {
1371 end_time1 = start_time1
1372 + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1373 if (end_time1 > end_time)
1374 end_time = end_time1;
1378 if (start_time != INT64_MAX) {
1379 ic->start_time = start_time;
1380 if (end_time != INT64_MIN) {
1381 ic->duration = end_time - start_time;
1382 if (ic->file_size > 0) {
1383 /* compute the bit rate */
1384 ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1385 (double)ic->duration;
1392 static void fill_all_stream_timings(AVFormatContext *ic)
1397 av_update_stream_timings(ic);
1398 for(i = 0;i < ic->nb_streams; i++) {
1399 st = ic->streams[i];
1400 if (st->start_time == AV_NOPTS_VALUE) {
1401 if(ic->start_time != AV_NOPTS_VALUE)
1402 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1403 if(ic->duration != AV_NOPTS_VALUE)
1404 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1409 static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1411 int64_t filesize, duration;
1415 /* if bit_rate is already set, we believe it */
1416 if (ic->bit_rate == 0) {
1418 for(i=0;i<ic->nb_streams;i++) {
1419 st = ic->streams[i];
1420 bit_rate += st->codec->bit_rate;
1422 ic->bit_rate = bit_rate;
1425 /* if duration is already set, we believe it */
1426 if (ic->duration == AV_NOPTS_VALUE &&
1427 ic->bit_rate != 0 &&
1428 ic->file_size != 0) {
1429 filesize = ic->file_size;
1431 for(i = 0; i < ic->nb_streams; i++) {
1432 st = ic->streams[i];
1433 duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1434 if (st->start_time == AV_NOPTS_VALUE ||
1435 st->duration == AV_NOPTS_VALUE) {
1437 st->duration = duration;
1444 #define DURATION_MAX_READ_SIZE 250000
1446 /* only usable for MPEG-PS streams */
1447 static void av_estimate_timings_from_pts(AVFormatContext *ic, offset_t old_offset)
1449 AVPacket pkt1, *pkt = &pkt1;
1451 int read_size, i, ret;
1453 int64_t filesize, offset, duration;
1455 /* free previous packet */
1456 if (ic->cur_st && ic->cur_st->parser)
1457 av_free_packet(&ic->cur_pkt);
1460 /* flush packet queue */
1461 flush_packet_queue(ic);
1463 for(i=0;i<ic->nb_streams;i++) {
1464 st = ic->streams[i];
1466 av_parser_close(st->parser);
1471 /* we read the first packets to get the first PTS (not fully
1472 accurate, but it is enough now) */
1473 url_fseek(&ic->pb, 0, SEEK_SET);
1476 if (read_size >= DURATION_MAX_READ_SIZE)
1478 /* if all info is available, we can stop */
1479 for(i = 0;i < ic->nb_streams; i++) {
1480 st = ic->streams[i];
1481 if (st->start_time == AV_NOPTS_VALUE)
1484 if (i == ic->nb_streams)
1487 ret = av_read_packet(ic, pkt);
1490 read_size += pkt->size;
1491 st = ic->streams[pkt->stream_index];
1492 if (pkt->pts != AV_NOPTS_VALUE) {
1493 if (st->start_time == AV_NOPTS_VALUE)
1494 st->start_time = pkt->pts;
1496 av_free_packet(pkt);
1499 /* estimate the end time (duration) */
1500 /* XXX: may need to support wrapping */
1501 filesize = ic->file_size;
1502 offset = filesize - DURATION_MAX_READ_SIZE;
1506 url_fseek(&ic->pb, offset, SEEK_SET);
1509 if (read_size >= DURATION_MAX_READ_SIZE)
1511 /* if all info is available, we can stop */
1512 for(i = 0;i < ic->nb_streams; i++) {
1513 st = ic->streams[i];
1514 if (st->duration == AV_NOPTS_VALUE)
1517 if (i == ic->nb_streams)
1520 ret = av_read_packet(ic, pkt);
1523 read_size += pkt->size;
1524 st = ic->streams[pkt->stream_index];
1525 if (pkt->pts != AV_NOPTS_VALUE) {
1526 end_time = pkt->pts;
1527 duration = end_time - st->start_time;
1529 if (st->duration == AV_NOPTS_VALUE ||
1530 st->duration < duration)
1531 st->duration = duration;
1534 av_free_packet(pkt);
1537 fill_all_stream_timings(ic);
1539 url_fseek(&ic->pb, old_offset, SEEK_SET);
1542 static void av_estimate_timings(AVFormatContext *ic, offset_t old_offset)
1546 /* get the file size, if possible */
1547 if (ic->iformat->flags & AVFMT_NOFILE) {
1550 file_size = url_fsize(&ic->pb);
1554 ic->file_size = file_size;
1556 if ((!strcmp(ic->iformat->name, "mpeg") ||
1557 !strcmp(ic->iformat->name, "mpegts")) &&
1558 file_size && !ic->pb.is_streamed) {
1559 /* get accurate estimate from the PTSes */
1560 av_estimate_timings_from_pts(ic, old_offset);
1561 } else if (av_has_timings(ic)) {
1562 /* at least one components has timings - we use them for all
1564 fill_all_stream_timings(ic);
1566 /* less precise: use bit rate info */
1567 av_estimate_timings_from_bit_rate(ic);
1569 av_update_stream_timings(ic);
1575 for(i = 0;i < ic->nb_streams; i++) {
1576 st = ic->streams[i];
1577 printf("%d: start_time: %0.3f duration: %0.3f\n",
1578 i, (double)st->start_time / AV_TIME_BASE,
1579 (double)st->duration / AV_TIME_BASE);
1581 printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1582 (double)ic->start_time / AV_TIME_BASE,
1583 (double)ic->duration / AV_TIME_BASE,
1584 ic->bit_rate / 1000);
1589 static int has_codec_parameters(AVCodecContext *enc)
1592 switch(enc->codec_type) {
1593 case CODEC_TYPE_AUDIO:
1594 val = enc->sample_rate;
1596 case CODEC_TYPE_VIDEO:
1597 val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
1606 static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1610 int got_picture, data_size, ret=0;
1613 if(!st->codec->codec){
1614 codec = avcodec_find_decoder(st->codec->codec_id);
1617 ret = avcodec_open(st->codec, codec);
1622 if(!has_codec_parameters(st->codec)){
1623 switch(st->codec->codec_type) {
1624 case CODEC_TYPE_VIDEO:
1625 ret = avcodec_decode_video(st->codec, &picture,
1626 &got_picture, (uint8_t *)data, size);
1628 case CODEC_TYPE_AUDIO:
1629 data_size = FFMAX(size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
1630 samples = av_malloc(data_size);
1633 ret = avcodec_decode_audio2(st->codec, samples,
1634 &data_size, (uint8_t *)data, size);
1645 static int set_codec_from_probe_data(AVStream *st, AVProbeData *pd, int score)
1648 fmt = av_probe_input_format2(pd, 1, &score);
1651 if (strncmp(fmt->name, "mp3", 3) == 0)
1652 st->codec->codec_id = CODEC_ID_MP3;
1653 else if (strncmp(fmt->name, "ac3", 3) == 0)
1654 st->codec->codec_id = CODEC_ID_AC3;
1659 /* absolute maximum size we read until we abort */
1660 #define MAX_READ_SIZE 5000000
1662 #define MAX_STD_TIMEBASES (60*12+5)
1663 static int get_std_framerate(int i){
1664 if(i<60*12) return i*1001;
1665 else return ((int[]){24,30,60,12,15})[i-60*12]*1000*12;
1668 int av_find_stream_info(AVFormatContext *ic)
1670 int i, count, ret, read_size, j;
1672 AVPacket pkt1, *pkt;
1673 AVPacketList *pktl=NULL, **ppktl;
1674 int64_t last_dts[MAX_STREAMS];
1675 int duration_count[MAX_STREAMS]={0};
1676 double (*duration_error)[MAX_STD_TIMEBASES];
1677 offset_t old_offset = url_ftell(&ic->pb);
1678 int64_t codec_info_duration[MAX_STREAMS]={0};
1679 int codec_info_nb_frames[MAX_STREAMS]={0};
1680 AVProbeData probe_data[MAX_STREAMS];
1681 int codec_identified[MAX_STREAMS]={0};
1683 duration_error = av_mallocz(MAX_STREAMS * sizeof(*duration_error));
1684 if (!duration_error) return AVERROR_NOMEM;
1686 for(i=0;i<ic->nb_streams;i++) {
1687 st = ic->streams[i];
1688 if(st->codec->codec_type == CODEC_TYPE_VIDEO){
1689 /* if(!st->time_base.num)
1691 if(!st->codec->time_base.num)
1692 st->codec->time_base= st->time_base;
1694 //only for the split stuff
1696 st->parser = av_parser_init(st->codec->codec_id);
1697 if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
1698 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1703 for(i=0;i<MAX_STREAMS;i++){
1704 last_dts[i]= AV_NOPTS_VALUE;
1707 memset(probe_data, 0, sizeof(probe_data));
1710 ppktl = &ic->packet_buffer;
1712 /* check if one codec still needs to be handled */
1713 for(i=0;i<ic->nb_streams;i++) {
1714 st = ic->streams[i];
1715 if (!has_codec_parameters(st->codec))
1717 /* variable fps and no guess at the real fps */
1718 if( (st->codec->time_base.den >= 101LL*st->codec->time_base.num || st->codec->codec_id == CODEC_ID_MPEG2VIDEO)
1719 && duration_count[i]<20 && st->codec->codec_type == CODEC_TYPE_VIDEO)
1721 if(st->parser && st->parser->parser->split && !st->codec->extradata)
1723 if (st->codec->codec_type == CODEC_TYPE_AUDIO &&
1724 st->codec->codec_id == CODEC_ID_NONE)
1727 if (i == ic->nb_streams) {
1728 /* NOTE: if the format has no header, then we need to read
1729 some packets to get most of the streams, so we cannot
1731 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
1732 /* if we found the info for all the codecs, we can stop */
1737 /* we did not get all the codec info, but we read too much data */
1738 if (read_size >= MAX_READ_SIZE) {
1743 /* NOTE: a new stream can be added there if no header in file
1744 (AVFMTCTX_NOHEADER) */
1745 ret = av_read_frame_internal(ic, &pkt1);
1748 ret = -1; /* we could not have all the codec parameters before EOF */
1749 for(i=0;i<ic->nb_streams;i++) {
1750 st = ic->streams[i];
1751 if (!has_codec_parameters(st->codec)){
1753 avcodec_string(buf, sizeof(buf), st->codec, 0);
1754 av_log(ic, AV_LOG_INFO, "Could not find codec parameters (%s)\n", buf);
1762 pktl = av_mallocz(sizeof(AVPacketList));
1764 ret = AVERROR_NOMEM;
1768 /* add the packet in the buffered packet list */
1770 ppktl = &pktl->next;
1775 /* duplicate the packet */
1776 if (av_dup_packet(pkt) < 0) {
1777 ret = AVERROR_NOMEM;
1781 read_size += pkt->size;
1783 st = ic->streams[pkt->stream_index];
1784 if(codec_info_nb_frames[st->index]>1)
1785 codec_info_duration[st->index] += pkt->duration;
1786 if (pkt->duration != 0)
1787 codec_info_nb_frames[st->index]++;
1790 int index= pkt->stream_index;
1791 int64_t last= last_dts[index];
1792 int64_t duration= pkt->dts - last;
1794 if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
1795 double dur= duration * av_q2d(st->time_base);
1797 // if(st->codec->codec_type == CODEC_TYPE_VIDEO)
1798 // av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
1799 if(duration_count[index] < 2)
1800 memset(duration_error, 0, MAX_STREAMS * sizeof(*duration_error));
1801 for(i=1; i<MAX_STD_TIMEBASES; i++){
1802 int framerate= get_std_framerate(i);
1803 int ticks= lrintf(dur*framerate/(1001*12));
1804 double error= dur - ticks*1001*12/(double)framerate;
1805 duration_error[index][i] += error*error;
1807 duration_count[index]++;
1809 if(last == AV_NOPTS_VALUE || duration_count[index]<=1)
1810 last_dts[pkt->stream_index]= pkt->dts;
1812 if (st->codec->codec_id == CODEC_ID_NONE) {
1813 AVProbeData *pd = &(probe_data[st->index]);
1814 pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size);
1815 memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
1816 pd->buf_size += pkt->size;
1819 if(st->parser && st->parser->parser->split && !st->codec->extradata){
1820 int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
1822 st->codec->extradata_size= i;
1823 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
1824 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
1825 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
1829 /* if still no information, we try to open the codec and to
1830 decompress the frame. We try to avoid that in most cases as
1831 it takes longer and uses more memory. For MPEG4, we need to
1832 decompress for Quicktime. */
1833 if (!has_codec_parameters(st->codec) /*&&
1834 (st->codec->codec_id == CODEC_ID_FLV1 ||
1835 st->codec->codec_id == CODEC_ID_H264 ||
1836 st->codec->codec_id == CODEC_ID_H263 ||
1837 st->codec->codec_id == CODEC_ID_H261 ||
1838 st->codec->codec_id == CODEC_ID_VORBIS ||
1839 st->codec->codec_id == CODEC_ID_MJPEG ||
1840 st->codec->codec_id == CODEC_ID_PNG ||
1841 st->codec->codec_id == CODEC_ID_PAM ||
1842 st->codec->codec_id == CODEC_ID_PGM ||
1843 st->codec->codec_id == CODEC_ID_PGMYUV ||
1844 st->codec->codec_id == CODEC_ID_PBM ||
1845 st->codec->codec_id == CODEC_ID_PPM ||
1846 st->codec->codec_id == CODEC_ID_SHORTEN ||
1847 (st->codec->codec_id == CODEC_ID_MPEG4 && !st->need_parsing))*/)
1848 try_decode_frame(st, pkt->data, pkt->size);
1850 if (av_rescale_q(codec_info_duration[st->index], st->time_base, AV_TIME_BASE_Q) >= ic->max_analyze_duration) {
1856 // close codecs which where opened in try_decode_frame()
1857 for(i=0;i<ic->nb_streams;i++) {
1858 st = ic->streams[i];
1859 if(st->codec->codec)
1860 avcodec_close(st->codec);
1862 for(i=0;i<ic->nb_streams;i++) {
1863 st = ic->streams[i];
1864 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1865 if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_sample)
1866 st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
1868 if(duration_count[i]
1869 && (st->codec->time_base.num*101LL <= st->codec->time_base.den || st->codec->codec_id == CODEC_ID_MPEG2VIDEO) /*&&
1870 //FIXME we should not special case mpeg2, but this needs testing with non mpeg2 ...
1871 st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den*/){
1872 double best_error= 2*av_q2d(st->time_base);
1873 best_error= best_error*best_error*duration_count[i]*1000*12*30;
1875 for(j=1; j<MAX_STD_TIMEBASES; j++){
1876 double error= duration_error[i][j] * get_std_framerate(j);
1877 // if(st->codec->codec_type == CODEC_TYPE_VIDEO)
1878 // av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
1879 if(error < best_error){
1881 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, get_std_framerate(j), 12*1001, INT_MAX);
1886 if (!st->r_frame_rate.num){
1887 if( st->codec->time_base.den * (int64_t)st->time_base.num
1888 <= st->codec->time_base.num * (int64_t)st->time_base.den){
1889 st->r_frame_rate.num = st->codec->time_base.den;
1890 st->r_frame_rate.den = st->codec->time_base.num;
1892 st->r_frame_rate.num = st->time_base.den;
1893 st->r_frame_rate.den = st->time_base.num;
1896 }else if(st->codec->codec_type == CODEC_TYPE_AUDIO) {
1897 if (st->codec->codec_id == CODEC_ID_NONE && probe_data[st->index].buf_size > 0) {
1898 codec_identified[st->index] = set_codec_from_probe_data(st, &(probe_data[st->index]), 0);
1899 if (codec_identified[st->index]) {
1900 st->need_parsing = AVSTREAM_PARSE_FULL;
1903 if(!st->codec->bits_per_sample)
1904 st->codec->bits_per_sample= av_get_bits_per_sample(st->codec->codec_id);
1908 av_estimate_timings(ic, old_offset);
1910 for(i=0;i<ic->nb_streams;i++) {
1911 st = ic->streams[i];
1912 if (codec_identified[st->index]) {
1913 av_read_frame_flush(ic);
1914 av_seek_frame(ic, st->index, 0.0, 0);
1915 url_fseek(&ic->pb, ic->data_offset, SEEK_SET);
1920 /* correct DTS for b frame streams with no timestamps */
1921 for(i=0;i<ic->nb_streams;i++) {
1922 st = ic->streams[i];
1923 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1925 ppktl = &ic->packet_buffer;
1927 if(ppkt1->stream_index != i)
1929 if(ppkt1->pkt->dts < 0)
1931 if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
1933 ppkt1->pkt->dts -= delta;
1938 st->cur_dts -= delta;
1944 av_free(duration_error);
1945 for(i=0;i<MAX_STREAMS;i++){
1946 av_freep(&(probe_data[i].buf));
1952 /*******************************************************/
1954 int av_read_play(AVFormatContext *s)
1956 if (!s->iformat->read_play)
1957 return AVERROR_NOTSUPP;
1958 return s->iformat->read_play(s);
1961 int av_read_pause(AVFormatContext *s)
1963 if (!s->iformat->read_pause)
1964 return AVERROR_NOTSUPP;
1965 return s->iformat->read_pause(s);
1968 void av_close_input_file(AVFormatContext *s)
1970 int i, must_open_file;
1973 /* free previous packet */
1974 if (s->cur_st && s->cur_st->parser)
1975 av_free_packet(&s->cur_pkt);
1977 if (s->iformat->read_close)
1978 s->iformat->read_close(s);
1979 for(i=0;i<s->nb_streams;i++) {
1980 /* free all data in a stream component */
1983 av_parser_close(st->parser);
1985 av_free(st->index_entries);
1986 av_free(st->codec->extradata);
1990 flush_packet_queue(s);
1992 if (s->iformat->flags & AVFMT_NOFILE) {
1995 if (must_open_file) {
1998 av_freep(&s->priv_data);
2002 AVStream *av_new_stream(AVFormatContext *s, int id)
2007 if (s->nb_streams >= MAX_STREAMS)
2010 st = av_mallocz(sizeof(AVStream));
2014 st->codec= avcodec_alloc_context();
2016 /* no default bitrate if decoding */
2017 st->codec->bit_rate = 0;
2019 st->index = s->nb_streams;
2021 st->start_time = AV_NOPTS_VALUE;
2022 st->duration = AV_NOPTS_VALUE;
2023 st->cur_dts = AV_NOPTS_VALUE;
2025 /* default pts settings is MPEG like */
2026 av_set_pts_info(st, 33, 1, 90000);
2027 st->last_IP_pts = AV_NOPTS_VALUE;
2028 for(i=0; i<MAX_REORDER_DELAY+1; i++)
2029 st->pts_buffer[i]= AV_NOPTS_VALUE;
2031 s->streams[s->nb_streams++] = st;
2035 /************************************************************/
2036 /* output media file */
2038 int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2042 if (s->oformat->priv_data_size > 0) {
2043 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2045 return AVERROR_NOMEM;
2047 s->priv_data = NULL;
2049 if (s->oformat->set_parameters) {
2050 ret = s->oformat->set_parameters(s, ap);
2057 int av_write_header(AVFormatContext *s)
2062 // some sanity checks
2063 for(i=0;i<s->nb_streams;i++) {
2066 switch (st->codec->codec_type) {
2067 case CODEC_TYPE_AUDIO:
2068 if(st->codec->sample_rate<=0){
2069 av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2073 case CODEC_TYPE_VIDEO:
2074 if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2075 av_log(s, AV_LOG_ERROR, "time base not set\n");
2078 if(st->codec->width<=0 || st->codec->height<=0){
2079 av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2085 if(s->oformat->codec_tag){
2086 if(st->codec->codec_tag){
2088 //check that tag + id is in the table
2089 //if neither is in the table -> ok
2090 //if tag is in the table with another id -> FAIL
2091 //if id is in the table with another tag -> FAIL unless strict < ?
2093 st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2097 if (!s->priv_data && s->oformat->priv_data_size > 0) {
2098 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2100 return AVERROR_NOMEM;
2103 if(s->oformat->write_header){
2104 ret = s->oformat->write_header(s);
2109 /* init PTS generation */
2110 for(i=0;i<s->nb_streams;i++) {
2111 int64_t den = AV_NOPTS_VALUE;
2114 switch (st->codec->codec_type) {
2115 case CODEC_TYPE_AUDIO:
2116 den = (int64_t)st->time_base.num * st->codec->sample_rate;
2118 case CODEC_TYPE_VIDEO:
2119 den = (int64_t)st->time_base.num * st->codec->time_base.den;
2124 if (den != AV_NOPTS_VALUE) {
2126 return AVERROR_INVALIDDATA;
2127 av_frac_init(&st->pts, 0, 0, den);
2133 //FIXME merge with compute_pkt_fields
2134 static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
2135 int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2136 int num, den, frame_size, i;
2138 // 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);
2140 /* if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2143 /* duration field */
2144 if (pkt->duration == 0) {
2145 compute_frame_duration(&num, &den, st, NULL, pkt);
2147 pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
2151 //XXX/FIXME this is a temporary hack until all encoders output pts
2152 if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2154 // pkt->pts= st->cur_dts;
2155 pkt->pts= st->pts.val;
2158 //calculate dts from pts
2159 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE){
2160 st->pts_buffer[0]= pkt->pts;
2161 for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2162 st->pts_buffer[i]= (i-delay-1) * pkt->duration;
2163 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2164 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2166 pkt->dts= st->pts_buffer[0];
2169 if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2170 av_log(NULL, AV_LOG_ERROR, "error, non monotone timestamps %"PRId64" >= %"PRId64"\n", st->cur_dts, pkt->dts);
2173 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2174 av_log(NULL, AV_LOG_ERROR, "error, pts < dts\n");
2178 // av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2179 st->cur_dts= pkt->dts;
2180 st->pts.val= pkt->dts;
2183 switch (st->codec->codec_type) {
2184 case CODEC_TYPE_AUDIO:
2185 frame_size = get_audio_frame_size(st->codec, pkt->size);
2187 /* HACK/FIXME, we skip the initial 0-size packets as they are most likely equal to the encoder delay,
2188 but it would be better if we had the real timestamps from the encoder */
2189 if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2190 av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2193 case CODEC_TYPE_VIDEO:
2194 av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2202 static void truncate_ts(AVStream *st, AVPacket *pkt){
2203 int64_t pts_mask = (2LL << (st->pts_wrap_bits-1)) - 1;
2206 // pkt->dts= 0; //this happens for low_delay=0 and b frames, FIXME, needs further invstigation about what we should do here
2208 if (pkt->pts != AV_NOPTS_VALUE)
2209 pkt->pts &= pts_mask;
2210 if (pkt->dts != AV_NOPTS_VALUE)
2211 pkt->dts &= pts_mask;
2214 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2218 ret=compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2219 if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2222 truncate_ts(s->streams[pkt->stream_index], pkt);
2224 ret= s->oformat->write_packet(s, pkt);
2226 ret= url_ferror(&s->pb);
2230 int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2231 AVPacketList *pktl, **next_point, *this_pktl;
2233 int streams[MAX_STREAMS];
2236 AVStream *st= s->streams[ pkt->stream_index];
2238 // assert(pkt->destruct != av_destruct_packet); //FIXME
2240 this_pktl = av_mallocz(sizeof(AVPacketList));
2241 this_pktl->pkt= *pkt;
2242 if(pkt->destruct == av_destruct_packet)
2243 pkt->destruct= NULL; // non shared -> must keep original from being freed
2245 av_dup_packet(&this_pktl->pkt); //shared -> must dup
2247 next_point = &s->packet_buffer;
2249 AVStream *st2= s->streams[ (*next_point)->pkt.stream_index];
2250 int64_t left= st2->time_base.num * (int64_t)st ->time_base.den;
2251 int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2252 if((*next_point)->pkt.dts * left > pkt->dts * right) //FIXME this can overflow
2254 next_point= &(*next_point)->next;
2256 this_pktl->next= *next_point;
2257 *next_point= this_pktl;
2260 memset(streams, 0, sizeof(streams));
2261 pktl= s->packet_buffer;
2263 //av_log(s, AV_LOG_DEBUG, "show st:%d dts:%"PRId64"\n", pktl->pkt.stream_index, pktl->pkt.dts);
2264 if(streams[ pktl->pkt.stream_index ] == 0)
2266 streams[ pktl->pkt.stream_index ]++;
2270 if(s->nb_streams == stream_count || (flush && stream_count)){
2271 pktl= s->packet_buffer;
2274 s->packet_buffer= pktl->next;
2278 av_init_packet(out);
2284 * Interleaves a AVPacket correctly so it can be muxed.
2285 * @param out the interleaved packet will be output here
2286 * @param in the input packet
2287 * @param flush 1 if no further packets are available as input and all
2288 * remaining packets should be output
2289 * @return 1 if a packet was output, 0 if no packet could be output,
2290 * < 0 if an error occured
2292 static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2293 if(s->oformat->interleave_packet)
2294 return s->oformat->interleave_packet(s, out, in, flush);
2296 return av_interleave_packet_per_dts(s, out, in, flush);
2299 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2300 AVStream *st= s->streams[ pkt->stream_index];
2302 //FIXME/XXX/HACK drop zero sized packets
2303 if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2306 //av_log(NULL, AV_LOG_DEBUG, "av_interleaved_write_frame %d %"PRId64" %"PRId64"\n", pkt->size, pkt->dts, pkt->pts);
2307 if(compute_pkt_fields2(st, pkt) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2310 if(pkt->dts == AV_NOPTS_VALUE)
2315 int ret= av_interleave_packet(s, &opkt, pkt, 0);
2316 if(ret<=0) //FIXME cleanup needed for ret<0 ?
2319 truncate_ts(s->streams[opkt.stream_index], &opkt);
2320 ret= s->oformat->write_packet(s, &opkt);
2322 av_free_packet(&opkt);
2327 if(url_ferror(&s->pb))
2328 return url_ferror(&s->pb);
2332 int av_write_trailer(AVFormatContext *s)
2338 ret= av_interleave_packet(s, &pkt, NULL, 1);
2339 if(ret<0) //FIXME cleanup needed for ret<0 ?
2344 truncate_ts(s->streams[pkt.stream_index], &pkt);
2345 ret= s->oformat->write_packet(s, &pkt);
2347 av_free_packet(&pkt);
2351 if(url_ferror(&s->pb))
2355 if(s->oformat->write_trailer)
2356 ret = s->oformat->write_trailer(s);
2359 ret=url_ferror(&s->pb);
2360 for(i=0;i<s->nb_streams;i++)
2361 av_freep(&s->streams[i]->priv_data);
2362 av_freep(&s->priv_data);
2366 /* "user interface" functions */
2368 void dump_format(AVFormatContext *ic,
2376 av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
2377 is_output ? "Output" : "Input",
2379 is_output ? ic->oformat->name : ic->iformat->name,
2380 is_output ? "to" : "from", url);
2382 av_log(NULL, AV_LOG_INFO, " Duration: ");
2383 if (ic->duration != AV_NOPTS_VALUE) {
2384 int hours, mins, secs, us;
2385 secs = ic->duration / AV_TIME_BASE;
2386 us = ic->duration % AV_TIME_BASE;
2391 av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%01d", hours, mins, secs,
2392 (10 * us) / AV_TIME_BASE);
2394 av_log(NULL, AV_LOG_INFO, "N/A");
2396 if (ic->start_time != AV_NOPTS_VALUE) {
2398 av_log(NULL, AV_LOG_INFO, ", start: ");
2399 secs = ic->start_time / AV_TIME_BASE;
2400 us = ic->start_time % AV_TIME_BASE;
2401 av_log(NULL, AV_LOG_INFO, "%d.%06d",
2402 secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
2404 av_log(NULL, AV_LOG_INFO, ", bitrate: ");
2406 av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
2408 av_log(NULL, AV_LOG_INFO, "N/A");
2410 av_log(NULL, AV_LOG_INFO, "\n");
2412 for(i=0;i<ic->nb_streams;i++) {
2413 AVStream *st = ic->streams[i];
2414 int g= ff_gcd(st->time_base.num, st->time_base.den);
2415 avcodec_string(buf, sizeof(buf), st->codec, is_output);
2416 av_log(NULL, AV_LOG_INFO, " Stream #%d.%d", index, i);
2417 /* the pid is an important information, so we display it */
2418 /* XXX: add a generic system */
2420 flags = ic->oformat->flags;
2422 flags = ic->iformat->flags;
2423 if (flags & AVFMT_SHOW_IDS) {
2424 av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
2426 if (strlen(st->language) > 0) {
2427 av_log(NULL, AV_LOG_INFO, "(%s)", st->language);
2429 av_log(NULL, AV_LOG_DEBUG, ", %d/%d", st->time_base.num/g, st->time_base.den/g);
2430 av_log(NULL, AV_LOG_INFO, ": %s", buf);
2431 if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2432 if(st->r_frame_rate.den && st->r_frame_rate.num)
2433 av_log(NULL, AV_LOG_INFO, ", %5.2f fps(r)", av_q2d(st->r_frame_rate));
2434 /* else if(st->time_base.den && st->time_base.num)
2435 av_log(NULL, AV_LOG_INFO, ", %5.2f fps(m)", 1/av_q2d(st->time_base));*/
2437 av_log(NULL, AV_LOG_INFO, ", %5.2f fps(c)", 1/av_q2d(st->codec->time_base));
2439 av_log(NULL, AV_LOG_INFO, "\n");
2443 int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2445 return av_parse_video_frame_size(width_ptr, height_ptr, str);
2448 int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
2450 AVRational frame_rate;
2451 int ret = av_parse_video_frame_rate(&frame_rate, arg);
2452 *frame_rate_num= frame_rate.num;
2453 *frame_rate_den= frame_rate.den;
2457 int64_t parse_date(const char *datestr, int duration)
2463 static const char *date_fmt[] = {
2467 static const char *time_fmt[] = {
2477 time_t now = time(0);
2479 len = strlen(datestr);
2481 lastch = datestr[len - 1];
2484 is_utc = (lastch == 'z' || lastch == 'Z');
2486 memset(&dt, 0, sizeof(dt));
2491 for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
2492 q = small_strptime(p, date_fmt[i], &dt);
2502 dt = *localtime(&now);
2504 dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
2509 if (*p == 'T' || *p == 't' || *p == ' ')
2512 for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
2513 q = small_strptime(p, time_fmt[i], &dt);
2523 q = small_strptime(p, time_fmt[0], &dt);
2525 dt.tm_sec = strtol(p, (char **)&q, 10);
2531 /* Now we have all the fields that we can get */
2536 return now * INT64_C(1000000);
2540 t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2542 dt.tm_isdst = -1; /* unknown */
2555 for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
2558 val += n * (*q - '0');
2562 return negative ? -t : t;
2565 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
2575 while (*p != '\0' && *p != '=' && *p != '&') {
2576 if ((q - tag) < sizeof(tag) - 1)
2584 while (*p != '&' && *p != '\0') {
2585 if ((q - arg) < arg_size - 1) {
2595 if (!strcmp(tag, tag1))
2604 int av_get_frame_filename(char *buf, int buf_size,
2605 const char *path, int number)
2608 char *q, buf1[20], c;
2609 int nd, len, percentd_found;
2621 while (isdigit(*p)) {
2622 nd = nd * 10 + *p++ - '0';
2625 } while (isdigit(c));
2634 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
2636 if ((q - buf + len) > buf_size - 1)
2638 memcpy(q, buf1, len);
2646 if ((q - buf) < buf_size - 1)
2650 if (!percentd_found)
2659 static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
2662 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
2664 for(i=0;i<size;i+=16) {
2671 PRINT(" %02x", buf[i+j]);
2676 for(j=0;j<len;j++) {
2678 if (c < ' ' || c > '~')
2687 void av_hex_dump(FILE *f, uint8_t *buf, int size)
2689 hex_dump_internal(NULL, f, 0, buf, size);
2692 void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
2694 hex_dump_internal(avcl, NULL, level, buf, size);
2697 //FIXME needs to know the time_base
2698 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload)
2700 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
2701 PRINT("stream #%d:\n", pkt->stream_index);
2702 PRINT(" keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
2703 PRINT(" duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
2704 /* DTS is _always_ valid after av_read_frame() */
2706 if (pkt->dts == AV_NOPTS_VALUE)
2709 PRINT("%0.3f", (double)pkt->dts / AV_TIME_BASE);
2710 /* PTS may be not known if B frames are present */
2712 if (pkt->pts == AV_NOPTS_VALUE)
2715 PRINT("%0.3f", (double)pkt->pts / AV_TIME_BASE);
2717 PRINT(" size=%d\n", pkt->size);
2720 av_hex_dump(f, pkt->data, pkt->size);
2723 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
2725 pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
2728 void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
2730 pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
2733 void url_split(char *proto, int proto_size,
2734 char *authorization, int authorization_size,
2735 char *hostname, int hostname_size,
2737 char *path, int path_size,
2748 while (*p != ':' && *p != '\0') {
2749 if ((q - proto) < proto_size - 1)
2755 if (authorization_size > 0)
2756 authorization[0] = '\0';
2760 if (hostname_size > 0)
2764 char *at,*slash; // PETR: position of '@' character and '/' character
2771 at = strchr(p,'@'); // PETR: get the position of '@'
2772 slash = strchr(p,'/'); // PETR: get position of '/' - end of hostname
2773 if (at && slash && at > slash) at = NULL; // PETR: not interested in '@' behind '/'
2775 q = at ? authorization : hostname; // PETR: if '@' exists starting with auth.
2777 while ((at || *p != ':') && *p != '/' && *p != '?' && *p != '\0') { // PETR:
2778 if (*p == '@') { // PETR: passed '@'
2779 if (authorization_size > 0)
2783 } else if (!at) { // PETR: hostname
2784 if ((q - hostname) < hostname_size - 1)
2787 if ((q - authorization) < authorization_size - 1)
2792 if (hostname_size > 0)
2796 port = strtoul(p, (char **)&p, 10);
2801 av_strlcpy(path, p, path_size);
2804 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
2805 int pts_num, int pts_den)
2807 s->pts_wrap_bits = pts_wrap_bits;
2808 s->time_base.num = pts_num;
2809 s->time_base.den = pts_den;
2812 /* fraction handling */
2815 * f = val + (num / den) + 0.5.
2817 * 'num' is normalized so that it is such as 0 <= num < den.
2819 * @param f fractional number
2820 * @param val integer value
2821 * @param num must be >= 0
2822 * @param den must be >= 1
2824 static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
2837 * Fractionnal addition to f: f = f + (incr / f->den).
2839 * @param f fractional number
2840 * @param incr increment, can be positive or negative
2842 static void av_frac_add(AVFrac *f, int64_t incr)
2846 num = f->num + incr;
2849 f->val += num / den;
2855 } else if (num >= den) {
2856 f->val += num / den;