2 * Various utilities for ffmpeg system
3 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22 #include "allformats.h"
29 * @file libavformat/utils.c
30 * Various utility functions for using ffmpeg library.
33 static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den);
34 static void av_frac_add(AVFrac *f, int64_t incr);
36 /** head of registered input format linked list. */
37 AVInputFormat *first_iformat = NULL;
38 /** head of registered output format linked list. */
39 AVOutputFormat *first_oformat = NULL;
41 void av_register_input_format(AVInputFormat *format)
45 while (*p != NULL) p = &(*p)->next;
50 void av_register_output_format(AVOutputFormat *format)
54 while (*p != NULL) p = &(*p)->next;
59 int match_ext(const char *filename, const char *extensions)
67 ext = strrchr(filename, '.');
73 while (*p != '\0' && *p != ',' && q-ext1<sizeof(ext1)-1)
76 if (!strcasecmp(ext1, ext))
86 AVOutputFormat *guess_format(const char *short_name, const char *filename,
87 const char *mime_type)
89 AVOutputFormat *fmt, *fmt_found;
92 /* specific test for image sequences */
93 #ifdef CONFIG_IMAGE2_MUXER
94 if (!short_name && filename &&
95 av_filename_number_test(filename) &&
96 av_guess_image2_codec(filename) != CODEC_ID_NONE) {
97 return guess_format("image2", NULL, NULL);
100 /* find the proper file type */
104 while (fmt != NULL) {
106 if (fmt->name && short_name && !strcmp(fmt->name, short_name))
108 if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
110 if (filename && fmt->extensions &&
111 match_ext(filename, fmt->extensions)) {
114 if (score > score_max) {
123 AVOutputFormat *guess_stream_format(const char *short_name, const char *filename,
124 const char *mime_type)
126 AVOutputFormat *fmt = guess_format(short_name, filename, mime_type);
129 AVOutputFormat *stream_fmt;
130 char stream_format_name[64];
132 snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
133 stream_fmt = guess_format(stream_format_name, NULL, NULL);
142 enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
143 const char *filename, const char *mime_type, enum CodecType type){
144 if(type == CODEC_TYPE_VIDEO){
145 enum CodecID codec_id= CODEC_ID_NONE;
147 #ifdef CONFIG_IMAGE2_MUXER
148 if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
149 codec_id= av_guess_image2_codec(filename);
152 if(codec_id == CODEC_ID_NONE)
153 codec_id= fmt->video_codec;
155 }else if(type == CODEC_TYPE_AUDIO)
156 return fmt->audio_codec;
158 return CODEC_ID_NONE;
161 AVInputFormat *av_find_input_format(const char *short_name)
164 for(fmt = first_iformat; fmt != NULL; fmt = fmt->next) {
165 if (!strcmp(fmt->name, short_name))
171 /* memory handling */
173 void av_destruct_packet(AVPacket *pkt)
176 pkt->data = NULL; pkt->size = 0;
179 int av_new_packet(AVPacket *pkt, int size)
182 if((unsigned)size > (unsigned)size + FF_INPUT_BUFFER_PADDING_SIZE)
183 return AVERROR_NOMEM;
184 data = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
186 return AVERROR_NOMEM;
187 memset(data + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
192 pkt->destruct = av_destruct_packet;
196 int av_get_packet(ByteIOContext *s, AVPacket *pkt, int size)
198 int ret= av_new_packet(pkt, size);
203 pkt->pos= url_ftell(s);
205 ret= get_buffer(s, pkt->data, size);
214 int av_dup_packet(AVPacket *pkt)
216 if (pkt->destruct != av_destruct_packet) {
218 /* we duplicate the packet and don't forget to put the padding
220 if((unsigned)pkt->size > (unsigned)pkt->size + FF_INPUT_BUFFER_PADDING_SIZE)
221 return AVERROR_NOMEM;
222 data = av_malloc(pkt->size + FF_INPUT_BUFFER_PADDING_SIZE);
224 return AVERROR_NOMEM;
226 memcpy(data, pkt->data, pkt->size);
227 memset(data + pkt->size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
229 pkt->destruct = av_destruct_packet;
234 int av_filename_number_test(const char *filename)
237 return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
240 AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened)
242 AVInputFormat *fmt1, *fmt;
243 int score, score_max;
247 for(fmt1 = first_iformat; fmt1 != NULL; fmt1 = fmt1->next) {
248 if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
251 if (fmt1->read_probe) {
252 score = fmt1->read_probe(pd);
253 } else if (fmt1->extensions) {
254 if (match_ext(pd->filename, fmt1->extensions)) {
258 if (score > score_max) {
266 /************************************************************/
267 /* input media file */
270 * Open a media file from an IO stream. 'fmt' must be specified.
272 static const char* format_to_name(void* ptr)
274 AVFormatContext* fc = (AVFormatContext*) ptr;
275 if(fc->iformat) return fc->iformat->name;
276 else if(fc->oformat) return fc->oformat->name;
280 #define OFFSET(x) offsetof(AVFormatContext,x)
281 #define DEFAULT 0 //should be NAN but it doesnt work as its not a constant in glibc as required by ANSI/ISO C
282 //these names are too long to be readable
283 #define E AV_OPT_FLAG_ENCODING_PARAM
284 #define D AV_OPT_FLAG_DECODING_PARAM
286 static const AVOption options[]={
287 {"probesize", NULL, OFFSET(probesize), FF_OPT_TYPE_INT, 32000, 32, INT_MAX, D}, /* 32000 from mpegts.c: 1.0 second at 24Mbit/s */
288 {"muxrate", "set mux rate", OFFSET(mux_rate), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
289 {"packetsize", "set packet size", OFFSET(packet_size), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
290 {"fflags", NULL, OFFSET(flags), FF_OPT_TYPE_FLAGS, DEFAULT, INT_MIN, INT_MAX, D|E, "fflags"},
291 {"ignidx", "ignore index", 0, FF_OPT_TYPE_CONST, AVFMT_FLAG_IGNIDX, INT_MIN, INT_MAX, D, "fflags"},
292 {"genpts", "generate pts", 0, FF_OPT_TYPE_CONST, AVFMT_FLAG_GENPTS, INT_MIN, INT_MAX, D, "fflags"},
293 {"track", " set the track number", OFFSET(track), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
294 {"year", "set the year", OFFSET(year), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, E},
295 {"analyzeduration", NULL, OFFSET(max_analyze_duration), FF_OPT_TYPE_INT, 3*AV_TIME_BASE, 0, INT_MAX, D},
303 static const AVClass av_format_context_class = { "AVFormatContext", format_to_name, options };
305 static void avformat_get_context_defaults(AVFormatContext *s)
307 memset(s, 0, sizeof(AVFormatContext));
309 s->av_class = &av_format_context_class;
311 av_opt_set_defaults(s);
314 AVFormatContext *av_alloc_format_context(void)
317 ic = av_malloc(sizeof(AVFormatContext));
319 avformat_get_context_defaults(ic);
320 ic->av_class = &av_format_context_class;
324 int av_open_input_stream(AVFormatContext **ic_ptr,
325 ByteIOContext *pb, const char *filename,
326 AVInputFormat *fmt, AVFormatParameters *ap)
330 AVFormatParameters default_ap;
334 memset(ap, 0, sizeof(default_ap));
337 if(!ap->prealloced_context)
338 ic = av_alloc_format_context();
348 ic->duration = AV_NOPTS_VALUE;
349 ic->start_time = AV_NOPTS_VALUE;
350 pstrcpy(ic->filename, sizeof(ic->filename), filename);
352 /* allocate private data */
353 if (fmt->priv_data_size > 0) {
354 ic->priv_data = av_mallocz(fmt->priv_data_size);
355 if (!ic->priv_data) {
360 ic->priv_data = NULL;
363 err = ic->iformat->read_header(ic, ap);
367 if (pb && !ic->data_offset)
368 ic->data_offset = url_ftell(&ic->pb);
374 av_freep(&ic->priv_data);
381 /** Size of probe buffer, for guessing file type from file contents. */
382 #define PROBE_BUF_MIN 2048
383 #define PROBE_BUF_MAX (1<<20)
385 int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
388 AVFormatParameters *ap)
390 int err, must_open_file, file_opened, probe_size;
391 AVProbeData probe_data, *pd = &probe_data;
392 ByteIOContext pb1, *pb = &pb1;
397 pd->filename = filename;
402 /* guess format if no file can be opened */
403 fmt = av_probe_input_format(pd, 0);
406 /* do not open file if the format does not need it. XXX: specific
407 hack needed to handle RTSP/TCP */
409 if (fmt && (fmt->flags & AVFMT_NOFILE)) {
411 pb= NULL; //FIXME this or memset(pb, 0, sizeof(ByteIOContext)); otherwise its uninitalized
414 if (!fmt || must_open_file) {
415 /* if no file needed do not try to open one */
416 if (url_fopen(pb, filename, URL_RDONLY) < 0) {
422 url_setbufsize(pb, buf_size);
425 for(probe_size= PROBE_BUF_MIN; probe_size<=PROBE_BUF_MAX && !fmt; probe_size<<=1){
426 /* read probe data */
427 pd->buf= av_realloc(pd->buf, probe_size);
428 pd->buf_size = get_buffer(pb, pd->buf, probe_size);
429 if (url_fseek(pb, 0, SEEK_SET) < 0) {
431 if (url_fopen(pb, filename, URL_RDONLY) < 0) {
437 /* guess file format */
438 fmt = av_probe_input_format(pd, 1);
443 /* if still no format found, error */
449 /* XXX: suppress this hack for redirectors */
450 #ifdef CONFIG_NETWORK
451 if (fmt == &redir_demuxer) {
452 err = redir_open(ic_ptr, pb);
458 /* check filename in case of an image number is expected */
459 if (fmt->flags & AVFMT_NEEDNUMBER) {
460 if (!av_filename_number_test(filename)) {
461 err = AVERROR_NUMEXPECTED;
465 err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
478 /*******************************************************/
480 int av_read_packet(AVFormatContext *s, AVPacket *pkt)
482 return s->iformat->read_packet(s, pkt);
485 /**********************************************************/
488 * Get the number of samples of an audio frame. Return (-1) if error.
490 static int get_audio_frame_size(AVCodecContext *enc, int size)
494 if (enc->frame_size <= 1) {
495 int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
497 if (bits_per_sample) {
498 if (enc->channels == 0)
500 frame_size = (size << 3) / (bits_per_sample * enc->channels);
502 /* used for example by ADPCM codecs */
503 if (enc->bit_rate == 0)
505 frame_size = (size * 8 * enc->sample_rate) / enc->bit_rate;
508 frame_size = enc->frame_size;
515 * Return the frame duration in seconds, return 0 if not available.
517 static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
518 AVCodecParserContext *pc, AVPacket *pkt)
524 switch(st->codec->codec_type) {
525 case CODEC_TYPE_VIDEO:
526 if(st->time_base.num*1000LL > st->time_base.den){
527 *pnum = st->time_base.num;
528 *pden = st->time_base.den;
529 }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
530 *pnum = st->codec->time_base.num;
531 *pden = st->codec->time_base.den;
532 if (pc && pc->repeat_pict) {
534 *pnum = (*pnum) * (2 + pc->repeat_pict);
538 case CODEC_TYPE_AUDIO:
539 frame_size = get_audio_frame_size(st->codec, pkt->size);
543 *pden = st->codec->sample_rate;
550 static int is_intra_only(AVCodecContext *enc){
551 if(enc->codec_type == CODEC_TYPE_AUDIO){
553 }else if(enc->codec_type == CODEC_TYPE_VIDEO){
554 switch(enc->codec_id){
556 case CODEC_ID_MJPEGB:
558 case CODEC_ID_RAWVIDEO:
559 case CODEC_ID_DVVIDEO:
560 case CODEC_ID_HUFFYUV:
561 case CODEC_ID_FFVHUFF:
572 static int64_t lsb2full(int64_t lsb, int64_t last_ts, int lsb_bits){
573 int64_t mask = lsb_bits < 64 ? (1LL<<lsb_bits)-1 : -1LL;
574 int64_t delta= last_ts - mask/2;
575 return ((lsb - delta)&mask) + delta;
578 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
579 AVCodecParserContext *pc, AVPacket *pkt)
581 int num, den, presentation_delayed, delay;
582 /* handle wrapping */
583 if(st->cur_dts != AV_NOPTS_VALUE){
584 if(pkt->pts != AV_NOPTS_VALUE)
585 pkt->pts= lsb2full(pkt->pts, st->cur_dts, st->pts_wrap_bits);
586 if(pkt->dts != AV_NOPTS_VALUE)
587 pkt->dts= lsb2full(pkt->dts, st->cur_dts, st->pts_wrap_bits);
590 if (pkt->duration == 0) {
591 compute_frame_duration(&num, &den, st, pc, pkt);
593 pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
597 if(is_intra_only(st->codec))
598 pkt->flags |= PKT_FLAG_KEY;
600 /* do we have a video B frame ? */
601 delay= st->codec->has_b_frames;
602 presentation_delayed = 0;
603 /* XXX: need has_b_frame, but cannot get it if the codec is
606 pc && pc->pict_type != FF_B_TYPE)
607 presentation_delayed = 1;
608 /* this may be redundant, but it shouldnt hurt */
609 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
610 presentation_delayed = 1;
612 if(st->cur_dts == AV_NOPTS_VALUE){
613 st->cur_dts = -delay * pkt->duration;
616 // av_log(NULL, AV_LOG_DEBUG, "IN delayed:%d pts:%"PRId64", dts:%"PRId64" cur_dts:%"PRId64" st:%d pc:%p\n", presentation_delayed, pkt->pts, pkt->dts, st->cur_dts, pkt->stream_index, pc);
617 /* interpolate PTS and DTS if they are not present */
618 if (presentation_delayed) {
619 /* DTS = decompression time stamp */
620 /* PTS = presentation time stamp */
621 if (pkt->dts == AV_NOPTS_VALUE) {
622 /* if we know the last pts, use it */
623 if(st->last_IP_pts != AV_NOPTS_VALUE)
624 st->cur_dts = pkt->dts = st->last_IP_pts;
626 pkt->dts = st->cur_dts;
628 st->cur_dts = pkt->dts;
630 /* this is tricky: the dts must be incremented by the duration
631 of the frame we are displaying, i.e. the last I or P frame */
632 if (st->last_IP_duration == 0)
633 st->cur_dts += pkt->duration;
635 st->cur_dts += st->last_IP_duration;
636 st->last_IP_duration = pkt->duration;
637 st->last_IP_pts= pkt->pts;
638 /* cannot compute PTS if not present (we can compute it only
639 by knowing the futur */
640 } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
641 if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
642 int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
643 int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
644 if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
645 pkt->pts += pkt->duration;
646 // 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);
650 /* presentation is not delayed : PTS and DTS are the same */
651 if(pkt->pts == AV_NOPTS_VALUE)
653 if(pkt->pts == AV_NOPTS_VALUE)
654 pkt->pts = st->cur_dts;
656 st->cur_dts = pkt->pts + pkt->duration;
658 // av_log(NULL, AV_LOG_DEBUG, "OUTdelayed:%d pts:%"PRId64", dts:%"PRId64" cur_dts:%"PRId64"\n", presentation_delayed, pkt->pts, pkt->dts, st->cur_dts);
663 /* key frame computation */
664 switch(st->codec->codec_type) {
665 case CODEC_TYPE_VIDEO:
666 if (pc->pict_type == FF_I_TYPE)
667 pkt->flags |= PKT_FLAG_KEY;
669 case CODEC_TYPE_AUDIO:
670 pkt->flags |= PKT_FLAG_KEY;
678 void av_destruct_packet_nofree(AVPacket *pkt)
680 pkt->data = NULL; pkt->size = 0;
683 static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
689 /* select current input stream component */
692 if (!st->need_parsing || !st->parser) {
693 /* no parsing needed: we just output the packet as is */
694 /* raw data support */
696 compute_pkt_fields(s, st, NULL, pkt);
699 } else if (s->cur_len > 0 && st->discard < AVDISCARD_ALL) {
700 len = av_parser_parse(st->parser, st->codec, &pkt->data, &pkt->size,
701 s->cur_ptr, s->cur_len,
702 s->cur_pkt.pts, s->cur_pkt.dts);
703 s->cur_pkt.pts = AV_NOPTS_VALUE;
704 s->cur_pkt.dts = AV_NOPTS_VALUE;
705 /* increment read pointer */
709 /* return packet if any */
713 pkt->stream_index = st->index;
714 pkt->pts = st->parser->pts;
715 pkt->dts = st->parser->dts;
716 pkt->destruct = av_destruct_packet_nofree;
717 compute_pkt_fields(s, st, st->parser, pkt);
719 if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & PKT_FLAG_KEY){
720 av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
721 0, 0, AVINDEX_KEYFRAME);
728 av_free_packet(&s->cur_pkt);
732 /* read next packet */
733 ret = av_read_packet(s, &s->cur_pkt);
735 if (ret == AVERROR(EAGAIN))
737 /* return the last frames, if any */
738 for(i = 0; i < s->nb_streams; i++) {
740 if (st->parser && st->need_parsing) {
741 av_parser_parse(st->parser, st->codec,
742 &pkt->data, &pkt->size,
744 AV_NOPTS_VALUE, AV_NOPTS_VALUE);
749 /* no more packets: really terminates parsing */
753 st = s->streams[s->cur_pkt.stream_index];
754 if(st->codec->debug & FF_DEBUG_PTS)
755 av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
756 s->cur_pkt.stream_index,
762 s->cur_ptr = s->cur_pkt.data;
763 s->cur_len = s->cur_pkt.size;
764 if (st->need_parsing && !st->parser) {
765 st->parser = av_parser_init(st->codec->codec_id);
767 /* no parser available : just output the raw packets */
768 st->need_parsing = 0;
769 }else if(st->need_parsing == 2){
770 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
772 if(st->parser && (s->iformat->flags & AVFMT_GENERIC_INDEX)){
773 st->parser->last_frame_offset=
774 st->parser->cur_offset= s->cur_pkt.pos;
779 if(st->codec->debug & FF_DEBUG_PTS)
780 av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
789 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
793 const int genpts= s->flags & AVFMT_FLAG_GENPTS;
796 pktl = s->packet_buffer;
798 AVPacket *next_pkt= &pktl->pkt;
800 if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
801 while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
802 if( pktl->pkt.stream_index == next_pkt->stream_index
803 && next_pkt->dts < pktl->pkt.dts
804 && pktl->pkt.pts != pktl->pkt.dts //not b frame
805 /*&& pktl->pkt.dts != AV_NOPTS_VALUE*/){
806 next_pkt->pts= pktl->pkt.dts;
810 pktl = s->packet_buffer;
813 if( next_pkt->pts != AV_NOPTS_VALUE
814 || next_pkt->dts == AV_NOPTS_VALUE
816 /* read packet from packet buffer, if there is data */
818 s->packet_buffer = pktl->next;
824 AVPacketList **plast_pktl= &s->packet_buffer;
825 int ret= av_read_frame_internal(s, pkt);
827 if(pktl && ret != AVERROR(EAGAIN)){
834 /* duplicate the packet */
835 if (av_dup_packet(pkt) < 0)
836 return AVERROR_NOMEM;
838 while(*plast_pktl) plast_pktl= &(*plast_pktl)->next; //FIXME maybe maintain pointer to the last?
840 pktl = av_mallocz(sizeof(AVPacketList));
842 return AVERROR_NOMEM;
844 /* add the packet in the buffered packet list */
848 assert(!s->packet_buffer);
849 return av_read_frame_internal(s, pkt);
854 /* XXX: suppress the packet queue */
855 static void flush_packet_queue(AVFormatContext *s)
860 pktl = s->packet_buffer;
863 s->packet_buffer = pktl->next;
864 av_free_packet(&pktl->pkt);
869 /*******************************************************/
872 int av_find_default_stream_index(AVFormatContext *s)
877 if (s->nb_streams <= 0)
879 for(i = 0; i < s->nb_streams; i++) {
881 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
889 * Flush the frame reader.
891 static void av_read_frame_flush(AVFormatContext *s)
896 flush_packet_queue(s);
898 /* free previous packet */
900 if (s->cur_st->parser)
901 av_free_packet(&s->cur_pkt);
908 /* for each stream, reset read state */
909 for(i = 0; i < s->nb_streams; i++) {
913 av_parser_close(st->parser);
916 st->last_IP_pts = AV_NOPTS_VALUE;
917 st->cur_dts = 0; /* we set the current DTS to an unspecified origin */
921 void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
924 for(i = 0; i < s->nb_streams; i++) {
925 AVStream *st = s->streams[i];
927 st->cur_dts = av_rescale(timestamp,
928 st->time_base.den * (int64_t)ref_st->time_base.num,
929 st->time_base.num * (int64_t)ref_st->time_base.den);
933 int av_add_index_entry(AVStream *st,
934 int64_t pos, int64_t timestamp, int size, int distance, int flags)
936 AVIndexEntry *entries, *ie;
939 if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
942 entries = av_fast_realloc(st->index_entries,
943 &st->index_entries_allocated_size,
944 (st->nb_index_entries + 1) *
945 sizeof(AVIndexEntry));
949 st->index_entries= entries;
951 index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
954 index= st->nb_index_entries++;
956 assert(index==0 || ie[-1].timestamp < timestamp);
959 if(ie->timestamp != timestamp){
960 if(ie->timestamp <= timestamp)
962 memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
963 st->nb_index_entries++;
964 }else if(ie->pos == pos && distance < ie->min_distance) //dont reduce the distance
965 distance= ie->min_distance;
969 ie->timestamp = timestamp;
970 ie->min_distance= distance;
978 * build an index for raw streams using a parser.
980 static void av_build_index_raw(AVFormatContext *s)
982 AVPacket pkt1, *pkt = &pkt1;
987 av_read_frame_flush(s);
988 url_fseek(&s->pb, s->data_offset, SEEK_SET);
991 ret = av_read_frame(s, pkt);
994 if (pkt->stream_index == 0 && st->parser &&
995 (pkt->flags & PKT_FLAG_KEY)) {
996 av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
997 0, 0, AVINDEX_KEYFRAME);
1004 * Returns TRUE if we deal with a raw stream.
1006 * Raw codec data and parsing needed.
1008 static int is_raw_stream(AVFormatContext *s)
1012 if (s->nb_streams != 1)
1015 if (!st->need_parsing)
1020 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1023 AVIndexEntry *entries= st->index_entries;
1024 int nb_entries= st->nb_index_entries;
1033 timestamp = entries[m].timestamp;
1034 if(timestamp >= wanted_timestamp)
1036 if(timestamp <= wanted_timestamp)
1039 m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1041 if(!(flags & AVSEEK_FLAG_ANY)){
1042 while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1043 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1054 int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1055 AVInputFormat *avif= s->iformat;
1056 int64_t pos_min, pos_max, pos, pos_limit;
1057 int64_t ts_min, ts_max, ts;
1061 if (stream_index < 0)
1065 av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1069 ts_min= AV_NOPTS_VALUE;
1070 pos_limit= -1; //gcc falsely says it may be uninitalized
1072 st= s->streams[stream_index];
1073 if(st->index_entries){
1076 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()
1077 index= FFMAX(index, 0);
1078 e= &st->index_entries[index];
1080 if(e->timestamp <= target_ts || e->pos == e->min_distance){
1082 ts_min= e->timestamp;
1084 av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1091 index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1092 assert(index < st->nb_index_entries);
1094 e= &st->index_entries[index];
1095 assert(e->timestamp >= target_ts);
1097 ts_max= e->timestamp;
1098 pos_limit= pos_max - e->min_distance;
1100 av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1101 pos_max,pos_limit, ts_max);
1106 pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1111 url_fseek(&s->pb, pos, SEEK_SET);
1113 av_update_cur_dts(s, st, ts);
1118 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 )){
1120 int64_t start_pos, filesize;
1124 av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1127 if(ts_min == AV_NOPTS_VALUE){
1128 pos_min = s->data_offset;
1129 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1130 if (ts_min == AV_NOPTS_VALUE)
1134 if(ts_max == AV_NOPTS_VALUE){
1136 filesize = url_fsize(&s->pb);
1137 pos_max = filesize - 1;
1140 ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1142 }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1143 if (ts_max == AV_NOPTS_VALUE)
1147 int64_t tmp_pos= pos_max + 1;
1148 int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1149 if(tmp_ts == AV_NOPTS_VALUE)
1153 if(tmp_pos >= filesize)
1159 if(ts_min > ts_max){
1161 }else if(ts_min == ts_max){
1166 while (pos_min < pos_limit) {
1168 av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1172 assert(pos_limit <= pos_max);
1175 int64_t approximate_keyframe_distance= pos_max - pos_limit;
1176 // interpolate position (better than dichotomy)
1177 pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1178 + pos_min - approximate_keyframe_distance;
1179 }else if(no_change==1){
1180 // bisection, if interpolation failed to change min or max pos last time
1181 pos = (pos_min + pos_limit)>>1;
1183 // linear search if bisection failed, can only happen if there are very few or no keframes between min/max
1188 else if(pos > pos_limit)
1192 ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1198 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);
1200 assert(ts != AV_NOPTS_VALUE);
1201 if (target_ts <= ts) {
1202 pos_limit = start_pos - 1;
1206 if (target_ts >= ts) {
1212 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1213 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
1216 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1218 ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1219 av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1220 pos, ts_min, target_ts, ts_max);
1226 static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1227 int64_t pos_min, pos_max;
1231 if (stream_index < 0)
1234 st= s->streams[stream_index];
1237 pos_min = s->data_offset;
1238 pos_max = url_fsize(&s->pb) - 1;
1240 if (pos < pos_min) pos= pos_min;
1241 else if(pos > pos_max) pos= pos_max;
1243 url_fseek(&s->pb, pos, SEEK_SET);
1246 av_update_cur_dts(s, st, ts);
1251 static int av_seek_frame_generic(AVFormatContext *s,
1252 int stream_index, int64_t timestamp, int flags)
1258 st = s->streams[stream_index];
1260 index = av_index_search_timestamp(st, timestamp, flags);
1266 if(st->index_entries && st->nb_index_entries){
1267 ie= &st->index_entries[st->nb_index_entries-1];
1268 url_fseek(&s->pb, ie->pos, SEEK_SET);
1269 av_update_cur_dts(s, st, ie->timestamp);
1271 url_fseek(&s->pb, 0, SEEK_SET);
1274 int ret = av_read_frame(s, &pkt);
1277 av_free_packet(&pkt);
1278 if(stream_index == pkt.stream_index){
1279 if((pkt.flags & PKT_FLAG_KEY) && pkt.dts > timestamp)
1283 index = av_index_search_timestamp(st, timestamp, flags);
1288 av_read_frame_flush(s);
1289 if (s->iformat->read_seek){
1290 if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1293 ie = &st->index_entries[index];
1294 url_fseek(&s->pb, ie->pos, SEEK_SET);
1296 av_update_cur_dts(s, st, ie->timestamp);
1301 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1306 av_read_frame_flush(s);
1308 if(flags & AVSEEK_FLAG_BYTE)
1309 return av_seek_frame_byte(s, stream_index, timestamp, flags);
1311 if(stream_index < 0){
1312 stream_index= av_find_default_stream_index(s);
1313 if(stream_index < 0)
1316 st= s->streams[stream_index];
1317 /* timestamp for default must be expressed in AV_TIME_BASE units */
1318 timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1320 st= s->streams[stream_index];
1322 /* first, we try the format specific seek */
1323 if (s->iformat->read_seek)
1324 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1331 if(s->iformat->read_timestamp)
1332 return av_seek_frame_binary(s, stream_index, timestamp, flags);
1334 return av_seek_frame_generic(s, stream_index, timestamp, flags);
1337 /*******************************************************/
1340 * Returns TRUE if the stream has accurate timings in any stream.
1342 * @return TRUE if the stream has accurate timings for at least one component.
1344 static int av_has_timings(AVFormatContext *ic)
1349 for(i = 0;i < ic->nb_streams; i++) {
1350 st = ic->streams[i];
1351 if (st->start_time != AV_NOPTS_VALUE &&
1352 st->duration != AV_NOPTS_VALUE)
1359 * Estimate the stream timings from the one of each components.
1361 * Also computes the global bitrate if possible.
1363 static void av_update_stream_timings(AVFormatContext *ic)
1365 int64_t start_time, start_time1, end_time, end_time1;
1369 start_time = INT64_MAX;
1370 end_time = INT64_MIN;
1371 for(i = 0;i < ic->nb_streams; i++) {
1372 st = ic->streams[i];
1373 if (st->start_time != AV_NOPTS_VALUE) {
1374 start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1375 if (start_time1 < start_time)
1376 start_time = start_time1;
1377 if (st->duration != AV_NOPTS_VALUE) {
1378 end_time1 = start_time1
1379 + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1380 if (end_time1 > end_time)
1381 end_time = end_time1;
1385 if (start_time != INT64_MAX) {
1386 ic->start_time = start_time;
1387 if (end_time != INT64_MIN) {
1388 ic->duration = end_time - start_time;
1389 if (ic->file_size > 0) {
1390 /* compute the bit rate */
1391 ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1392 (double)ic->duration;
1399 static void fill_all_stream_timings(AVFormatContext *ic)
1404 av_update_stream_timings(ic);
1405 for(i = 0;i < ic->nb_streams; i++) {
1406 st = ic->streams[i];
1407 if (st->start_time == AV_NOPTS_VALUE) {
1408 if(ic->start_time != AV_NOPTS_VALUE)
1409 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1410 if(ic->duration != AV_NOPTS_VALUE)
1411 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1416 static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1418 int64_t filesize, duration;
1422 /* if bit_rate is already set, we believe it */
1423 if (ic->bit_rate == 0) {
1425 for(i=0;i<ic->nb_streams;i++) {
1426 st = ic->streams[i];
1427 bit_rate += st->codec->bit_rate;
1429 ic->bit_rate = bit_rate;
1432 /* if duration is already set, we believe it */
1433 if (ic->duration == AV_NOPTS_VALUE &&
1434 ic->bit_rate != 0 &&
1435 ic->file_size != 0) {
1436 filesize = ic->file_size;
1438 for(i = 0; i < ic->nb_streams; i++) {
1439 st = ic->streams[i];
1440 duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1441 if (st->start_time == AV_NOPTS_VALUE ||
1442 st->duration == AV_NOPTS_VALUE) {
1444 st->duration = duration;
1451 #define DURATION_MAX_READ_SIZE 250000
1453 /* only usable for MPEG-PS streams */
1454 static void av_estimate_timings_from_pts(AVFormatContext *ic, offset_t old_offset)
1456 AVPacket pkt1, *pkt = &pkt1;
1458 int read_size, i, ret;
1460 int64_t filesize, offset, duration;
1462 /* free previous packet */
1463 if (ic->cur_st && ic->cur_st->parser)
1464 av_free_packet(&ic->cur_pkt);
1467 /* flush packet queue */
1468 flush_packet_queue(ic);
1470 for(i=0;i<ic->nb_streams;i++) {
1471 st = ic->streams[i];
1473 av_parser_close(st->parser);
1478 /* we read the first packets to get the first PTS (not fully
1479 accurate, but it is enough now) */
1480 url_fseek(&ic->pb, 0, SEEK_SET);
1483 if (read_size >= DURATION_MAX_READ_SIZE)
1485 /* if all info is available, we can stop */
1486 for(i = 0;i < ic->nb_streams; i++) {
1487 st = ic->streams[i];
1488 if (st->start_time == AV_NOPTS_VALUE)
1491 if (i == ic->nb_streams)
1494 ret = av_read_packet(ic, pkt);
1497 read_size += pkt->size;
1498 st = ic->streams[pkt->stream_index];
1499 if (pkt->pts != AV_NOPTS_VALUE) {
1500 if (st->start_time == AV_NOPTS_VALUE)
1501 st->start_time = pkt->pts;
1503 av_free_packet(pkt);
1506 /* estimate the end time (duration) */
1507 /* XXX: may need to support wrapping */
1508 filesize = ic->file_size;
1509 offset = filesize - DURATION_MAX_READ_SIZE;
1513 url_fseek(&ic->pb, offset, SEEK_SET);
1516 if (read_size >= DURATION_MAX_READ_SIZE)
1518 /* if all info is available, we can stop */
1519 for(i = 0;i < ic->nb_streams; i++) {
1520 st = ic->streams[i];
1521 if (st->duration == AV_NOPTS_VALUE)
1524 if (i == ic->nb_streams)
1527 ret = av_read_packet(ic, pkt);
1530 read_size += pkt->size;
1531 st = ic->streams[pkt->stream_index];
1532 if (pkt->pts != AV_NOPTS_VALUE) {
1533 end_time = pkt->pts;
1534 duration = end_time - st->start_time;
1536 if (st->duration == AV_NOPTS_VALUE ||
1537 st->duration < duration)
1538 st->duration = duration;
1541 av_free_packet(pkt);
1544 fill_all_stream_timings(ic);
1546 url_fseek(&ic->pb, old_offset, SEEK_SET);
1549 static void av_estimate_timings(AVFormatContext *ic, offset_t old_offset)
1553 /* get the file size, if possible */
1554 if (ic->iformat->flags & AVFMT_NOFILE) {
1557 file_size = url_fsize(&ic->pb);
1561 ic->file_size = file_size;
1563 if ((!strcmp(ic->iformat->name, "mpeg") ||
1564 !strcmp(ic->iformat->name, "mpegts")) &&
1565 file_size && !ic->pb.is_streamed) {
1566 /* get accurate estimate from the PTSes */
1567 av_estimate_timings_from_pts(ic, old_offset);
1568 } else if (av_has_timings(ic)) {
1569 /* at least one components has timings - we use them for all
1571 fill_all_stream_timings(ic);
1573 /* less precise: use bit rate info */
1574 av_estimate_timings_from_bit_rate(ic);
1576 av_update_stream_timings(ic);
1582 for(i = 0;i < ic->nb_streams; i++) {
1583 st = ic->streams[i];
1584 printf("%d: start_time: %0.3f duration: %0.3f\n",
1585 i, (double)st->start_time / AV_TIME_BASE,
1586 (double)st->duration / AV_TIME_BASE);
1588 printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1589 (double)ic->start_time / AV_TIME_BASE,
1590 (double)ic->duration / AV_TIME_BASE,
1591 ic->bit_rate / 1000);
1596 static int has_codec_parameters(AVCodecContext *enc)
1599 switch(enc->codec_type) {
1600 case CODEC_TYPE_AUDIO:
1601 val = enc->sample_rate;
1603 case CODEC_TYPE_VIDEO:
1604 val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
1613 static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1617 int got_picture, data_size, ret=0;
1620 if(!st->codec->codec){
1621 codec = avcodec_find_decoder(st->codec->codec_id);
1624 ret = avcodec_open(st->codec, codec);
1629 if(!has_codec_parameters(st->codec)){
1630 switch(st->codec->codec_type) {
1631 case CODEC_TYPE_VIDEO:
1632 ret = avcodec_decode_video(st->codec, &picture,
1633 &got_picture, (uint8_t *)data, size);
1635 case CODEC_TYPE_AUDIO:
1636 data_size = FFMAX(size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
1637 samples = av_malloc(data_size);
1640 ret = avcodec_decode_audio2(st->codec, samples,
1641 &data_size, (uint8_t *)data, size);
1652 /* absolute maximum size we read until we abort */
1653 #define MAX_READ_SIZE 5000000
1655 #define MAX_STD_TIMEBASES (60*12+5)
1656 static int get_std_framerate(int i){
1657 if(i<60*12) return i*1001;
1658 else return ((int[]){24,30,60,12,15})[i-60*12]*1000*12;
1661 int av_find_stream_info(AVFormatContext *ic)
1663 int i, count, ret, read_size, j;
1665 AVPacket pkt1, *pkt;
1666 AVPacketList *pktl=NULL, **ppktl;
1667 int64_t last_dts[MAX_STREAMS];
1668 int duration_count[MAX_STREAMS]={0};
1669 double (*duration_error)[MAX_STD_TIMEBASES];
1670 offset_t old_offset = url_ftell(&ic->pb);
1671 int64_t codec_info_duration[MAX_STREAMS]={0};
1672 int codec_info_nb_frames[MAX_STREAMS]={0};
1674 duration_error = av_mallocz(MAX_STREAMS * sizeof(*duration_error));
1675 if (!duration_error) return AVERROR_NOMEM;
1677 for(i=0;i<ic->nb_streams;i++) {
1678 st = ic->streams[i];
1679 if(st->codec->codec_type == CODEC_TYPE_VIDEO){
1680 /* if(!st->time_base.num)
1682 if(!st->codec->time_base.num)
1683 st->codec->time_base= st->time_base;
1685 //only for the split stuff
1687 st->parser = av_parser_init(st->codec->codec_id);
1688 if(st->need_parsing == 2 && st->parser){
1689 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1694 for(i=0;i<MAX_STREAMS;i++){
1695 last_dts[i]= AV_NOPTS_VALUE;
1700 ppktl = &ic->packet_buffer;
1702 /* check if one codec still needs to be handled */
1703 for(i=0;i<ic->nb_streams;i++) {
1704 st = ic->streams[i];
1705 if (!has_codec_parameters(st->codec))
1707 /* variable fps and no guess at the real fps */
1708 if( st->codec->time_base.den >= 101LL*st->codec->time_base.num
1709 && duration_count[i]<20 && st->codec->codec_type == CODEC_TYPE_VIDEO)
1711 if(st->parser && st->parser->parser->split && !st->codec->extradata)
1714 if (i == ic->nb_streams) {
1715 /* NOTE: if the format has no header, then we need to read
1716 some packets to get most of the streams, so we cannot
1718 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
1719 /* if we found the info for all the codecs, we can stop */
1724 /* we did not get all the codec info, but we read too much data */
1725 if (read_size >= MAX_READ_SIZE) {
1730 /* NOTE: a new stream can be added there if no header in file
1731 (AVFMTCTX_NOHEADER) */
1732 ret = av_read_frame_internal(ic, &pkt1);
1735 ret = -1; /* we could not have all the codec parameters before EOF */
1736 for(i=0;i<ic->nb_streams;i++) {
1737 st = ic->streams[i];
1738 if (!has_codec_parameters(st->codec)){
1740 avcodec_string(buf, sizeof(buf), st->codec, 0);
1741 av_log(ic, AV_LOG_INFO, "Could not find codec parameters (%s)\n", buf);
1749 pktl = av_mallocz(sizeof(AVPacketList));
1751 ret = AVERROR_NOMEM;
1755 /* add the packet in the buffered packet list */
1757 ppktl = &pktl->next;
1762 /* duplicate the packet */
1763 if (av_dup_packet(pkt) < 0) {
1764 ret = AVERROR_NOMEM;
1768 read_size += pkt->size;
1770 st = ic->streams[pkt->stream_index];
1771 if(codec_info_nb_frames[st->index]>1)
1772 codec_info_duration[st->index] += pkt->duration;
1773 if (pkt->duration != 0)
1774 codec_info_nb_frames[st->index]++;
1777 int index= pkt->stream_index;
1778 int64_t last= last_dts[index];
1779 int64_t duration= pkt->dts - last;
1781 if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
1782 double dur= duration * av_q2d(st->time_base);
1784 // if(st->codec->codec_type == CODEC_TYPE_VIDEO)
1785 // av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
1786 if(duration_count[index] < 2)
1787 memset(duration_error, 0, MAX_STREAMS * sizeof(*duration_error));
1788 for(i=1; i<MAX_STD_TIMEBASES; i++){
1789 int framerate= get_std_framerate(i);
1790 int ticks= lrintf(dur*framerate/(1001*12));
1791 double error= dur - ticks*1001*12/(double)framerate;
1792 duration_error[index][i] += error*error;
1794 duration_count[index]++;
1796 if(last == AV_NOPTS_VALUE || duration_count[index]<=1)
1797 last_dts[pkt->stream_index]= pkt->dts;
1799 if(st->parser && st->parser->parser->split && !st->codec->extradata){
1800 int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
1802 st->codec->extradata_size= i;
1803 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
1804 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
1805 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
1809 /* if still no information, we try to open the codec and to
1810 decompress the frame. We try to avoid that in most cases as
1811 it takes longer and uses more memory. For MPEG4, we need to
1812 decompress for Quicktime. */
1813 if (!has_codec_parameters(st->codec) /*&&
1814 (st->codec->codec_id == CODEC_ID_FLV1 ||
1815 st->codec->codec_id == CODEC_ID_H264 ||
1816 st->codec->codec_id == CODEC_ID_H263 ||
1817 st->codec->codec_id == CODEC_ID_H261 ||
1818 st->codec->codec_id == CODEC_ID_VORBIS ||
1819 st->codec->codec_id == CODEC_ID_MJPEG ||
1820 st->codec->codec_id == CODEC_ID_PNG ||
1821 st->codec->codec_id == CODEC_ID_PAM ||
1822 st->codec->codec_id == CODEC_ID_PGM ||
1823 st->codec->codec_id == CODEC_ID_PGMYUV ||
1824 st->codec->codec_id == CODEC_ID_PBM ||
1825 st->codec->codec_id == CODEC_ID_PPM ||
1826 st->codec->codec_id == CODEC_ID_SHORTEN ||
1827 (st->codec->codec_id == CODEC_ID_MPEG4 && !st->need_parsing))*/)
1828 try_decode_frame(st, pkt->data, pkt->size);
1830 if (av_rescale_q(codec_info_duration[st->index], st->time_base, AV_TIME_BASE_Q) >= ic->max_analyze_duration) {
1836 // close codecs which where opened in try_decode_frame()
1837 for(i=0;i<ic->nb_streams;i++) {
1838 st = ic->streams[i];
1839 if(st->codec->codec)
1840 avcodec_close(st->codec);
1842 for(i=0;i<ic->nb_streams;i++) {
1843 st = ic->streams[i];
1844 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1845 if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_sample)
1846 st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
1848 if(duration_count[i]
1849 && (st->codec->time_base.num*101LL <= st->codec->time_base.den || st->codec->codec_id == CODEC_ID_MPEG2VIDEO) /*&&
1850 //FIXME we should not special case mpeg2, but this needs testing with non mpeg2 ...
1851 st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den*/){
1852 double best_error= 2*av_q2d(st->time_base);
1853 best_error= best_error*best_error*duration_count[i]*1000*12*30;
1855 for(j=1; j<MAX_STD_TIMEBASES; j++){
1856 double error= duration_error[i][j] * get_std_framerate(j);
1857 // if(st->codec->codec_type == CODEC_TYPE_VIDEO)
1858 // av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
1859 if(error < best_error){
1861 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, get_std_framerate(j), 12*1001, INT_MAX);
1866 if (!st->r_frame_rate.num){
1867 if( st->codec->time_base.den * (int64_t)st->time_base.num
1868 <= st->codec->time_base.num * (int64_t)st->time_base.den){
1869 st->r_frame_rate.num = st->codec->time_base.den;
1870 st->r_frame_rate.den = st->codec->time_base.num;
1872 st->r_frame_rate.num = st->time_base.den;
1873 st->r_frame_rate.den = st->time_base.num;
1876 }else if(st->codec->codec_type == CODEC_TYPE_AUDIO) {
1877 if(!st->codec->bits_per_sample)
1878 st->codec->bits_per_sample= av_get_bits_per_sample(st->codec->codec_id);
1882 av_estimate_timings(ic, old_offset);
1884 /* correct DTS for b frame streams with no timestamps */
1885 for(i=0;i<ic->nb_streams;i++) {
1886 st = ic->streams[i];
1887 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1889 ppktl = &ic->packet_buffer;
1891 if(ppkt1->stream_index != i)
1893 if(ppkt1->pkt->dts < 0)
1895 if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
1897 ppkt1->pkt->dts -= delta;
1902 st->cur_dts -= delta;
1908 av_free(duration_error);
1913 /*******************************************************/
1915 int av_read_play(AVFormatContext *s)
1917 if (!s->iformat->read_play)
1918 return AVERROR_NOTSUPP;
1919 return s->iformat->read_play(s);
1922 int av_read_pause(AVFormatContext *s)
1924 if (!s->iformat->read_pause)
1925 return AVERROR_NOTSUPP;
1926 return s->iformat->read_pause(s);
1929 void av_close_input_file(AVFormatContext *s)
1931 int i, must_open_file;
1934 /* free previous packet */
1935 if (s->cur_st && s->cur_st->parser)
1936 av_free_packet(&s->cur_pkt);
1938 if (s->iformat->read_close)
1939 s->iformat->read_close(s);
1940 for(i=0;i<s->nb_streams;i++) {
1941 /* free all data in a stream component */
1944 av_parser_close(st->parser);
1946 av_free(st->index_entries);
1947 av_free(st->codec->extradata);
1951 flush_packet_queue(s);
1953 if (s->iformat->flags & AVFMT_NOFILE) {
1956 if (must_open_file) {
1959 av_freep(&s->priv_data);
1963 AVStream *av_new_stream(AVFormatContext *s, int id)
1968 if (s->nb_streams >= MAX_STREAMS)
1971 st = av_mallocz(sizeof(AVStream));
1975 st->codec= avcodec_alloc_context();
1977 /* no default bitrate if decoding */
1978 st->codec->bit_rate = 0;
1980 st->index = s->nb_streams;
1982 st->start_time = AV_NOPTS_VALUE;
1983 st->duration = AV_NOPTS_VALUE;
1984 st->cur_dts = AV_NOPTS_VALUE;
1986 /* default pts settings is MPEG like */
1987 av_set_pts_info(st, 33, 1, 90000);
1988 st->last_IP_pts = AV_NOPTS_VALUE;
1989 for(i=0; i<MAX_REORDER_DELAY+1; i++)
1990 st->pts_buffer[i]= AV_NOPTS_VALUE;
1992 s->streams[s->nb_streams++] = st;
1996 /************************************************************/
1997 /* output media file */
1999 int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2003 if (s->oformat->priv_data_size > 0) {
2004 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2006 return AVERROR_NOMEM;
2008 s->priv_data = NULL;
2010 if (s->oformat->set_parameters) {
2011 ret = s->oformat->set_parameters(s, ap);
2018 int av_write_header(AVFormatContext *s)
2023 // some sanity checks
2024 for(i=0;i<s->nb_streams;i++) {
2027 switch (st->codec->codec_type) {
2028 case CODEC_TYPE_AUDIO:
2029 if(st->codec->sample_rate<=0){
2030 av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2034 case CODEC_TYPE_VIDEO:
2035 if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2036 av_log(s, AV_LOG_ERROR, "time base not set\n");
2039 if(st->codec->width<=0 || st->codec->height<=0){
2040 av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2046 if(s->oformat->codec_tag){
2047 if(st->codec->codec_tag){
2049 //check that tag + id is in the table
2050 //if neither is in the table -> ok
2051 //if tag is in the table with another id -> FAIL
2052 //if id is in the table with another tag -> FAIL unless strict < ?
2054 st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2058 if (!s->priv_data && s->oformat->priv_data_size > 0) {
2059 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2061 return AVERROR_NOMEM;
2064 if(s->oformat->write_header){
2065 ret = s->oformat->write_header(s);
2070 /* init PTS generation */
2071 for(i=0;i<s->nb_streams;i++) {
2072 int64_t den = AV_NOPTS_VALUE;
2075 switch (st->codec->codec_type) {
2076 case CODEC_TYPE_AUDIO:
2077 den = (int64_t)st->time_base.num * st->codec->sample_rate;
2079 case CODEC_TYPE_VIDEO:
2080 den = (int64_t)st->time_base.num * st->codec->time_base.den;
2085 if (den != AV_NOPTS_VALUE) {
2087 return AVERROR_INVALIDDATA;
2088 av_frac_init(&st->pts, 0, 0, den);
2094 //FIXME merge with compute_pkt_fields
2095 static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
2096 int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2097 int num, den, frame_size, i;
2099 // 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);
2101 /* if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2104 /* duration field */
2105 if (pkt->duration == 0) {
2106 compute_frame_duration(&num, &den, st, NULL, pkt);
2108 pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
2112 //XXX/FIXME this is a temporary hack until all encoders output pts
2113 if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2115 // pkt->pts= st->cur_dts;
2116 pkt->pts= st->pts.val;
2119 //calculate dts from pts
2120 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE){
2121 st->pts_buffer[0]= pkt->pts;
2122 for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2123 st->pts_buffer[i]= (i-delay-1) * pkt->duration;
2124 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2125 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2127 pkt->dts= st->pts_buffer[0];
2130 if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2131 av_log(NULL, AV_LOG_ERROR, "error, non monotone timestamps %"PRId64" >= %"PRId64"\n", st->cur_dts, pkt->dts);
2134 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2135 av_log(NULL, AV_LOG_ERROR, "error, pts < dts\n");
2139 // av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2140 st->cur_dts= pkt->dts;
2141 st->pts.val= pkt->dts;
2144 switch (st->codec->codec_type) {
2145 case CODEC_TYPE_AUDIO:
2146 frame_size = get_audio_frame_size(st->codec, pkt->size);
2148 /* HACK/FIXME, we skip the initial 0-size packets as they are most likely equal to the encoder delay,
2149 but it would be better if we had the real timestamps from the encoder */
2150 if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2151 av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2154 case CODEC_TYPE_VIDEO:
2155 av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2163 static void truncate_ts(AVStream *st, AVPacket *pkt){
2164 int64_t pts_mask = (2LL << (st->pts_wrap_bits-1)) - 1;
2167 // pkt->dts= 0; //this happens for low_delay=0 and b frames, FIXME, needs further invstigation about what we should do here
2169 if (pkt->pts != AV_NOPTS_VALUE)
2170 pkt->pts &= pts_mask;
2171 if (pkt->dts != AV_NOPTS_VALUE)
2172 pkt->dts &= pts_mask;
2175 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2179 ret=compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2180 if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2183 truncate_ts(s->streams[pkt->stream_index], pkt);
2185 ret= s->oformat->write_packet(s, pkt);
2187 ret= url_ferror(&s->pb);
2191 int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2192 AVPacketList *pktl, **next_point, *this_pktl;
2194 int streams[MAX_STREAMS];
2197 AVStream *st= s->streams[ pkt->stream_index];
2199 // assert(pkt->destruct != av_destruct_packet); //FIXME
2201 this_pktl = av_mallocz(sizeof(AVPacketList));
2202 this_pktl->pkt= *pkt;
2203 if(pkt->destruct == av_destruct_packet)
2204 pkt->destruct= NULL; // non shared -> must keep original from being freed
2206 av_dup_packet(&this_pktl->pkt); //shared -> must dup
2208 next_point = &s->packet_buffer;
2210 AVStream *st2= s->streams[ (*next_point)->pkt.stream_index];
2211 int64_t left= st2->time_base.num * (int64_t)st ->time_base.den;
2212 int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2213 if((*next_point)->pkt.dts * left > pkt->dts * right) //FIXME this can overflow
2215 next_point= &(*next_point)->next;
2217 this_pktl->next= *next_point;
2218 *next_point= this_pktl;
2221 memset(streams, 0, sizeof(streams));
2222 pktl= s->packet_buffer;
2224 //av_log(s, AV_LOG_DEBUG, "show st:%d dts:%"PRId64"\n", pktl->pkt.stream_index, pktl->pkt.dts);
2225 if(streams[ pktl->pkt.stream_index ] == 0)
2227 streams[ pktl->pkt.stream_index ]++;
2231 if(s->nb_streams == stream_count || (flush && stream_count)){
2232 pktl= s->packet_buffer;
2235 s->packet_buffer= pktl->next;
2239 av_init_packet(out);
2245 * Interleaves a AVPacket correctly so it can be muxed.
2246 * @param out the interleaved packet will be output here
2247 * @param in the input packet
2248 * @param flush 1 if no further packets are available as input and all
2249 * remaining packets should be output
2250 * @return 1 if a packet was output, 0 if no packet could be output,
2251 * < 0 if an error occured
2253 static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2254 if(s->oformat->interleave_packet)
2255 return s->oformat->interleave_packet(s, out, in, flush);
2257 return av_interleave_packet_per_dts(s, out, in, flush);
2260 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2261 AVStream *st= s->streams[ pkt->stream_index];
2263 //FIXME/XXX/HACK drop zero sized packets
2264 if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2267 //av_log(NULL, AV_LOG_DEBUG, "av_interleaved_write_frame %d %"PRId64" %"PRId64"\n", pkt->size, pkt->dts, pkt->pts);
2268 if(compute_pkt_fields2(st, pkt) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2271 if(pkt->dts == AV_NOPTS_VALUE)
2276 int ret= av_interleave_packet(s, &opkt, pkt, 0);
2277 if(ret<=0) //FIXME cleanup needed for ret<0 ?
2280 truncate_ts(s->streams[opkt.stream_index], &opkt);
2281 ret= s->oformat->write_packet(s, &opkt);
2283 av_free_packet(&opkt);
2288 if(url_ferror(&s->pb))
2289 return url_ferror(&s->pb);
2293 int av_write_trailer(AVFormatContext *s)
2299 ret= av_interleave_packet(s, &pkt, NULL, 1);
2300 if(ret<0) //FIXME cleanup needed for ret<0 ?
2305 truncate_ts(s->streams[pkt.stream_index], &pkt);
2306 ret= s->oformat->write_packet(s, &pkt);
2308 av_free_packet(&pkt);
2312 if(url_ferror(&s->pb))
2316 if(s->oformat->write_trailer)
2317 ret = s->oformat->write_trailer(s);
2320 ret=url_ferror(&s->pb);
2321 for(i=0;i<s->nb_streams;i++)
2322 av_freep(&s->streams[i]->priv_data);
2323 av_freep(&s->priv_data);
2327 /* "user interface" functions */
2329 void dump_format(AVFormatContext *ic,
2337 av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
2338 is_output ? "Output" : "Input",
2340 is_output ? ic->oformat->name : ic->iformat->name,
2341 is_output ? "to" : "from", url);
2343 av_log(NULL, AV_LOG_INFO, " Duration: ");
2344 if (ic->duration != AV_NOPTS_VALUE) {
2345 int hours, mins, secs, us;
2346 secs = ic->duration / AV_TIME_BASE;
2347 us = ic->duration % AV_TIME_BASE;
2352 av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%01d", hours, mins, secs,
2353 (10 * us) / AV_TIME_BASE);
2355 av_log(NULL, AV_LOG_INFO, "N/A");
2357 if (ic->start_time != AV_NOPTS_VALUE) {
2359 av_log(NULL, AV_LOG_INFO, ", start: ");
2360 secs = ic->start_time / AV_TIME_BASE;
2361 us = ic->start_time % AV_TIME_BASE;
2362 av_log(NULL, AV_LOG_INFO, "%d.%06d",
2363 secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
2365 av_log(NULL, AV_LOG_INFO, ", bitrate: ");
2367 av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
2369 av_log(NULL, AV_LOG_INFO, "N/A");
2371 av_log(NULL, AV_LOG_INFO, "\n");
2373 for(i=0;i<ic->nb_streams;i++) {
2374 AVStream *st = ic->streams[i];
2375 int g= ff_gcd(st->time_base.num, st->time_base.den);
2376 avcodec_string(buf, sizeof(buf), st->codec, is_output);
2377 av_log(NULL, AV_LOG_INFO, " Stream #%d.%d", index, i);
2378 /* the pid is an important information, so we display it */
2379 /* XXX: add a generic system */
2381 flags = ic->oformat->flags;
2383 flags = ic->iformat->flags;
2384 if (flags & AVFMT_SHOW_IDS) {
2385 av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
2387 if (strlen(st->language) > 0) {
2388 av_log(NULL, AV_LOG_INFO, "(%s)", st->language);
2390 av_log(NULL, AV_LOG_DEBUG, ", %d/%d", st->time_base.num/g, st->time_base.den/g);
2391 av_log(NULL, AV_LOG_INFO, ": %s", buf);
2392 if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2393 if(st->r_frame_rate.den && st->r_frame_rate.num)
2394 av_log(NULL, AV_LOG_INFO, ", %5.2f fps(r)", av_q2d(st->r_frame_rate));
2395 /* else if(st->time_base.den && st->time_base.num)
2396 av_log(NULL, AV_LOG_INFO, ", %5.2f fps(m)", 1/av_q2d(st->time_base));*/
2398 av_log(NULL, AV_LOG_INFO, ", %5.2f fps(c)", 1/av_q2d(st->codec->time_base));
2400 av_log(NULL, AV_LOG_INFO, "\n");
2407 int frame_rate, frame_rate_base;
2410 static AbvEntry frame_abvs[] = {
2411 { "ntsc", 720, 480, 30000, 1001 },
2412 { "pal", 720, 576, 25, 1 },
2413 { "qntsc", 352, 240, 30000, 1001 }, /* VCD compliant ntsc */
2414 { "qpal", 352, 288, 25, 1 }, /* VCD compliant pal */
2415 { "sntsc", 640, 480, 30000, 1001 }, /* square pixel ntsc */
2416 { "spal", 768, 576, 25, 1 }, /* square pixel pal */
2417 { "film", 352, 240, 24, 1 },
2418 { "ntsc-film", 352, 240, 24000, 1001 },
2419 { "sqcif", 128, 96, 0, 0 },
2420 { "qcif", 176, 144, 0, 0 },
2421 { "cif", 352, 288, 0, 0 },
2422 { "4cif", 704, 576, 0, 0 },
2425 int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2428 int n = sizeof(frame_abvs) / sizeof(AbvEntry);
2430 int frame_width = 0, frame_height = 0;
2433 if (!strcmp(frame_abvs[i].abv, str)) {
2434 frame_width = frame_abvs[i].width;
2435 frame_height = frame_abvs[i].height;
2441 frame_width = strtol(p, (char **)&p, 10);
2444 frame_height = strtol(p, (char **)&p, 10);
2446 if (frame_width <= 0 || frame_height <= 0)
2448 *width_ptr = frame_width;
2449 *height_ptr = frame_height;
2453 int parse_frame_rate(int *frame_rate, int *frame_rate_base, const char *arg)
2458 /* First, we check our abbreviation table */
2459 for (i = 0; i < sizeof(frame_abvs)/sizeof(*frame_abvs); ++i)
2460 if (!strcmp(frame_abvs[i].abv, arg)) {
2461 *frame_rate = frame_abvs[i].frame_rate;
2462 *frame_rate_base = frame_abvs[i].frame_rate_base;
2466 /* Then, we try to parse it as fraction */
2467 cp = strchr(arg, '/');
2469 cp = strchr(arg, ':');
2472 *frame_rate = strtol(arg, &cpp, 10);
2473 if (cpp != arg || cpp == cp)
2474 *frame_rate_base = strtol(cp+1, &cpp, 10);
2479 /* Finally we give up and parse it as double */
2480 AVRational time_base = av_d2q(strtod(arg, 0), DEFAULT_FRAME_RATE_BASE);
2481 *frame_rate_base = time_base.den;
2482 *frame_rate = time_base.num;
2484 if (!*frame_rate || !*frame_rate_base)
2490 #ifndef CONFIG_WINCE
2491 int64_t parse_date(const char *datestr, int duration)
2497 static const char *date_fmt[] = {
2501 static const char *time_fmt[] = {
2511 time_t now = time(0);
2513 len = strlen(datestr);
2515 lastch = datestr[len - 1];
2518 is_utc = (lastch == 'z' || lastch == 'Z');
2520 memset(&dt, 0, sizeof(dt));
2525 for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
2526 q = small_strptime(p, date_fmt[i], &dt);
2536 dt = *localtime(&now);
2538 dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
2543 if (*p == 'T' || *p == 't' || *p == ' ')
2546 for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
2547 q = small_strptime(p, time_fmt[i], &dt);
2557 q = small_strptime(p, time_fmt[0], &dt);
2559 dt.tm_sec = strtol(p, (char **)&q, 10);
2565 /* Now we have all the fields that we can get */
2570 return now * INT64_C(1000000);
2574 t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2576 dt.tm_isdst = -1; /* unknown */
2589 for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
2592 val += n * (*q - '0');
2596 return negative ? -t : t;
2598 #endif /* CONFIG_WINCE */
2600 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
2610 while (*p != '\0' && *p != '=' && *p != '&') {
2611 if ((q - tag) < sizeof(tag) - 1)
2619 while (*p != '&' && *p != '\0') {
2620 if ((q - arg) < arg_size - 1) {
2630 if (!strcmp(tag, tag1))
2639 int av_get_frame_filename(char *buf, int buf_size,
2640 const char *path, int number)
2643 char *q, buf1[20], c;
2644 int nd, len, percentd_found;
2656 while (isdigit(*p)) {
2657 nd = nd * 10 + *p++ - '0';
2660 } while (isdigit(c));
2669 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
2671 if ((q - buf + len) > buf_size - 1)
2673 memcpy(q, buf1, len);
2681 if ((q - buf) < buf_size - 1)
2685 if (!percentd_found)
2694 static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
2697 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
2699 for(i=0;i<size;i+=16) {
2706 PRINT(" %02x", buf[i+j]);
2711 for(j=0;j<len;j++) {
2713 if (c < ' ' || c > '~')
2722 void av_hex_dump(FILE *f, uint8_t *buf, int size)
2724 hex_dump_internal(NULL, f, 0, buf, size);
2727 void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
2729 hex_dump_internal(avcl, NULL, level, buf, size);
2732 //FIXME needs to know the time_base
2733 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload)
2735 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
2736 PRINT("stream #%d:\n", pkt->stream_index);
2737 PRINT(" keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
2738 PRINT(" duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
2739 /* DTS is _always_ valid after av_read_frame() */
2741 if (pkt->dts == AV_NOPTS_VALUE)
2744 PRINT("%0.3f", (double)pkt->dts / AV_TIME_BASE);
2745 /* PTS may be not known if B frames are present */
2747 if (pkt->pts == AV_NOPTS_VALUE)
2750 PRINT("%0.3f", (double)pkt->pts / AV_TIME_BASE);
2752 PRINT(" size=%d\n", pkt->size);
2755 av_hex_dump(f, pkt->data, pkt->size);
2758 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
2760 pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
2763 void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
2765 pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
2768 void url_split(char *proto, int proto_size,
2769 char *authorization, int authorization_size,
2770 char *hostname, int hostname_size,
2772 char *path, int path_size,
2783 while (*p != ':' && *p != '\0') {
2784 if ((q - proto) < proto_size - 1)
2790 if (authorization_size > 0)
2791 authorization[0] = '\0';
2795 if (hostname_size > 0)
2799 char *at,*slash; // PETR: position of '@' character and '/' character
2806 at = strchr(p,'@'); // PETR: get the position of '@'
2807 slash = strchr(p,'/'); // PETR: get position of '/' - end of hostname
2808 if (at && slash && at > slash) at = NULL; // PETR: not interested in '@' behind '/'
2810 q = at ? authorization : hostname; // PETR: if '@' exists starting with auth.
2812 while ((at || *p != ':') && *p != '/' && *p != '?' && *p != '\0') { // PETR:
2813 if (*p == '@') { // PETR: passed '@'
2814 if (authorization_size > 0)
2818 } else if (!at) { // PETR: hostname
2819 if ((q - hostname) < hostname_size - 1)
2822 if ((q - authorization) < authorization_size - 1)
2827 if (hostname_size > 0)
2831 port = strtoul(p, (char **)&p, 10);
2836 pstrcpy(path, path_size, p);
2839 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
2840 int pts_num, int pts_den)
2842 s->pts_wrap_bits = pts_wrap_bits;
2843 s->time_base.num = pts_num;
2844 s->time_base.den = pts_den;
2847 /* fraction handling */
2850 * f = val + (num / den) + 0.5.
2852 * 'num' is normalized so that it is such as 0 <= num < den.
2854 * @param f fractional number
2855 * @param val integer value
2856 * @param num must be >= 0
2857 * @param den must be >= 1
2859 static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
2872 * Fractionnal addition to f: f = f + (incr / f->den).
2874 * @param f fractional number
2875 * @param incr increment, can be positive or negative
2877 static void av_frac_add(AVFrac *f, int64_t incr)
2881 num = f->num + incr;
2884 f->val += num / den;
2890 } else if (num >= den) {
2891 f->val += num / den;