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);
143 * Guesses the codec id based upon muxer and filename.
145 enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
146 const char *filename, const char *mime_type, enum CodecType type){
147 if(type == CODEC_TYPE_VIDEO){
148 enum CodecID codec_id= CODEC_ID_NONE;
150 #ifdef CONFIG_IMAGE2_MUXER
151 if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
152 codec_id= av_guess_image2_codec(filename);
155 if(codec_id == CODEC_ID_NONE)
156 codec_id= fmt->video_codec;
158 }else if(type == CODEC_TYPE_AUDIO)
159 return fmt->audio_codec;
161 return CODEC_ID_NONE;
165 * finds AVInputFormat based on input format's short name.
167 AVInputFormat *av_find_input_format(const char *short_name)
170 for(fmt = first_iformat; fmt != NULL; fmt = fmt->next) {
171 if (!strcmp(fmt->name, short_name))
177 /* memory handling */
180 * Default packet destructor.
182 void av_destruct_packet(AVPacket *pkt)
185 pkt->data = NULL; pkt->size = 0;
189 * Allocate the payload of a packet and intialized its fields to default values.
192 * @param size wanted payload size
193 * @return 0 if OK. AVERROR_xxx otherwise.
195 int av_new_packet(AVPacket *pkt, int size)
198 if((unsigned)size > (unsigned)size + FF_INPUT_BUFFER_PADDING_SIZE)
199 return AVERROR_NOMEM;
200 data = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
202 return AVERROR_NOMEM;
203 memset(data + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
208 pkt->destruct = av_destruct_packet;
213 * Allocate and read the payload of a packet and intialized its fields to default values.
216 * @param size wanted payload size
217 * @return >0 (read size) if OK. AVERROR_xxx otherwise.
219 int av_get_packet(ByteIOContext *s, AVPacket *pkt, int size)
221 int ret= av_new_packet(pkt, size);
226 pkt->pos= url_ftell(s);
228 ret= get_buffer(s, pkt->data, size);
237 /* This is a hack - the packet memory allocation stuff is broken. The
238 packet is allocated if it was not really allocated */
239 int av_dup_packet(AVPacket *pkt)
241 if (pkt->destruct != av_destruct_packet) {
243 /* we duplicate the packet and don't forget to put the padding
245 if((unsigned)pkt->size > (unsigned)pkt->size + FF_INPUT_BUFFER_PADDING_SIZE)
246 return AVERROR_NOMEM;
247 data = av_malloc(pkt->size + FF_INPUT_BUFFER_PADDING_SIZE);
249 return AVERROR_NOMEM;
251 memcpy(data, pkt->data, pkt->size);
252 memset(data + pkt->size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
254 pkt->destruct = av_destruct_packet;
260 * Check whether filename actually is a numbered sequence generator.
262 * @param filename possible numbered sequence string
263 * @return 1 if a valid numbered sequence string, 0 otherwise.
265 int av_filename_number_test(const char *filename)
268 return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
274 * @param is_opened whether the file is already opened, determines whether
275 * demuxers with or without AVFMT_NOFILE are probed
277 AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened)
279 AVInputFormat *fmt1, *fmt;
280 int score, score_max;
284 for(fmt1 = first_iformat; fmt1 != NULL; fmt1 = fmt1->next) {
285 if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
288 if (fmt1->read_probe) {
289 score = fmt1->read_probe(pd);
290 } else if (fmt1->extensions) {
291 if (match_ext(pd->filename, fmt1->extensions)) {
295 if (score > score_max) {
303 /************************************************************/
304 /* input media file */
307 * Open a media file from an IO stream. 'fmt' must be specified.
309 static const char* format_to_name(void* ptr)
311 AVFormatContext* fc = (AVFormatContext*) ptr;
312 if(fc->iformat) return fc->iformat->name;
313 else if(fc->oformat) return fc->oformat->name;
317 #define OFFSET(x) offsetof(AVFormatContext,x)
318 #define DEFAULT 0 //should be NAN but it doesnt work as its not a constant in glibc as required by ANSI/ISO C
319 //these names are too long to be readable
320 #define E AV_OPT_FLAG_ENCODING_PARAM
321 #define D AV_OPT_FLAG_DECODING_PARAM
323 static const AVOption options[]={
324 {"probesize", NULL, OFFSET(probesize), FF_OPT_TYPE_INT, 32000, 32, INT_MAX, D}, /* 32000 from mpegts.c: 1.0 second at 24Mbit/s */
325 {"muxrate", "set mux rate", OFFSET(mux_rate), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
326 {"packetsize", "set packet size", OFFSET(packet_size), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
327 {"fflags", NULL, OFFSET(flags), FF_OPT_TYPE_FLAGS, DEFAULT, INT_MIN, INT_MAX, D|E, "fflags"},
328 {"ignidx", "ignore index", 0, FF_OPT_TYPE_CONST, AVFMT_FLAG_IGNIDX, INT_MIN, INT_MAX, D, "fflags"},
329 {"genpts", "generate pts", 0, FF_OPT_TYPE_CONST, AVFMT_FLAG_GENPTS, INT_MIN, INT_MAX, D, "fflags"},
330 {"track", " set the track number", OFFSET(track), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
331 {"year", "set the year", OFFSET(year), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, E},
332 {"analyzeduration", NULL, OFFSET(max_analyze_duration), FF_OPT_TYPE_INT, 3*AV_TIME_BASE, 0, INT_MAX, D},
340 static const AVClass av_format_context_class = { "AVFormatContext", format_to_name, options };
342 static void avformat_get_context_defaults(AVFormatContext *s)
344 memset(s, 0, sizeof(AVFormatContext));
346 s->av_class = &av_format_context_class;
348 av_opt_set_defaults(s);
351 AVFormatContext *av_alloc_format_context(void)
354 ic = av_malloc(sizeof(AVFormatContext));
356 avformat_get_context_defaults(ic);
357 ic->av_class = &av_format_context_class;
362 * Allocates all the structures needed to read an input stream.
363 * This does not open the needed codecs for decoding the stream[s].
365 int av_open_input_stream(AVFormatContext **ic_ptr,
366 ByteIOContext *pb, const char *filename,
367 AVInputFormat *fmt, AVFormatParameters *ap)
371 AVFormatParameters default_ap;
375 memset(ap, 0, sizeof(default_ap));
378 if(!ap->prealloced_context)
379 ic = av_alloc_format_context();
389 ic->duration = AV_NOPTS_VALUE;
390 ic->start_time = AV_NOPTS_VALUE;
391 pstrcpy(ic->filename, sizeof(ic->filename), filename);
393 /* allocate private data */
394 if (fmt->priv_data_size > 0) {
395 ic->priv_data = av_mallocz(fmt->priv_data_size);
396 if (!ic->priv_data) {
401 ic->priv_data = NULL;
404 err = ic->iformat->read_header(ic, ap);
408 if (pb && !ic->data_offset)
409 ic->data_offset = url_ftell(&ic->pb);
415 av_freep(&ic->priv_data);
422 /** Size of probe buffer, for guessing file type from file contents. */
423 #define PROBE_BUF_MIN 2048
424 #define PROBE_BUF_MAX (1<<20)
427 * Open a media file as input. The codec are not opened. Only the file
428 * header (if present) is read.
430 * @param ic_ptr the opened media file handle is put here
431 * @param filename filename to open.
432 * @param fmt if non NULL, force the file format to use
433 * @param buf_size optional buffer size (zero if default is OK)
434 * @param ap additionnal parameters needed when opening the file (NULL if default)
435 * @return 0 if OK. AVERROR_xxx otherwise.
437 int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
440 AVFormatParameters *ap)
442 int err, must_open_file, file_opened, probe_size;
443 AVProbeData probe_data, *pd = &probe_data;
444 ByteIOContext pb1, *pb = &pb1;
449 pd->filename = filename;
454 /* guess format if no file can be opened */
455 fmt = av_probe_input_format(pd, 0);
458 /* do not open file if the format does not need it. XXX: specific
459 hack needed to handle RTSP/TCP */
461 if (fmt && (fmt->flags & AVFMT_NOFILE)) {
463 pb= NULL; //FIXME this or memset(pb, 0, sizeof(ByteIOContext)); otherwise its uninitalized
466 if (!fmt || must_open_file) {
467 /* if no file needed do not try to open one */
468 if (url_fopen(pb, filename, URL_RDONLY) < 0) {
474 url_setbufsize(pb, buf_size);
477 for(probe_size= PROBE_BUF_MIN; probe_size<=PROBE_BUF_MAX && !fmt; probe_size<<=1){
478 /* read probe data */
479 pd->buf= av_realloc(pd->buf, probe_size);
480 pd->buf_size = get_buffer(pb, pd->buf, probe_size);
481 if (url_fseek(pb, 0, SEEK_SET) == (offset_t)AVERROR(EPIPE)) {
483 if (url_fopen(pb, filename, URL_RDONLY) < 0) {
489 /* guess file format */
490 fmt = av_probe_input_format(pd, 1);
495 /* if still no format found, error */
501 /* XXX: suppress this hack for redirectors */
502 #ifdef CONFIG_NETWORK
503 if (fmt == &redir_demuxer) {
504 err = redir_open(ic_ptr, pb);
510 /* check filename in case of an image number is expected */
511 if (fmt->flags & AVFMT_NEEDNUMBER) {
512 if (!av_filename_number_test(filename)) {
513 err = AVERROR_NUMEXPECTED;
517 err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
530 /*******************************************************/
533 * Read a transport packet from a media file.
535 * This function is absolete and should never be used.
536 * Use av_read_frame() instead.
538 * @param s media file handle
539 * @param pkt is filled
540 * @return 0 if OK. AVERROR_xxx if error.
542 int av_read_packet(AVFormatContext *s, AVPacket *pkt)
544 return s->iformat->read_packet(s, pkt);
547 /**********************************************************/
550 * Get the number of samples of an audio frame. Return (-1) if error.
552 static int get_audio_frame_size(AVCodecContext *enc, int size)
556 if (enc->frame_size <= 1) {
557 int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
559 if (bits_per_sample) {
560 if (enc->channels == 0)
562 frame_size = (size << 3) / (bits_per_sample * enc->channels);
564 /* used for example by ADPCM codecs */
565 if (enc->bit_rate == 0)
567 frame_size = (size * 8 * enc->sample_rate) / enc->bit_rate;
570 frame_size = enc->frame_size;
577 * Return the frame duration in seconds, return 0 if not available.
579 static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
580 AVCodecParserContext *pc, AVPacket *pkt)
586 switch(st->codec->codec_type) {
587 case CODEC_TYPE_VIDEO:
588 if(st->time_base.num*1000LL > st->time_base.den){
589 *pnum = st->time_base.num;
590 *pden = st->time_base.den;
591 }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
592 *pnum = st->codec->time_base.num;
593 *pden = st->codec->time_base.den;
594 if (pc && pc->repeat_pict) {
596 *pnum = (*pnum) * (2 + pc->repeat_pict);
600 case CODEC_TYPE_AUDIO:
601 frame_size = get_audio_frame_size(st->codec, pkt->size);
605 *pden = st->codec->sample_rate;
612 static int is_intra_only(AVCodecContext *enc){
613 if(enc->codec_type == CODEC_TYPE_AUDIO){
615 }else if(enc->codec_type == CODEC_TYPE_VIDEO){
616 switch(enc->codec_id){
618 case CODEC_ID_MJPEGB:
620 case CODEC_ID_RAWVIDEO:
621 case CODEC_ID_DVVIDEO:
622 case CODEC_ID_HUFFYUV:
623 case CODEC_ID_FFVHUFF:
634 static int64_t lsb2full(int64_t lsb, int64_t last_ts, int lsb_bits){
635 int64_t mask = lsb_bits < 64 ? (1LL<<lsb_bits)-1 : -1LL;
636 int64_t delta= last_ts - mask/2;
637 return ((lsb - delta)&mask) + delta;
640 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
641 AVCodecParserContext *pc, AVPacket *pkt)
643 int num, den, presentation_delayed;
644 /* handle wrapping */
645 if(st->cur_dts != AV_NOPTS_VALUE){
646 if(pkt->pts != AV_NOPTS_VALUE)
647 pkt->pts= lsb2full(pkt->pts, st->cur_dts, st->pts_wrap_bits);
648 if(pkt->dts != AV_NOPTS_VALUE)
649 pkt->dts= lsb2full(pkt->dts, st->cur_dts, st->pts_wrap_bits);
652 if (pkt->duration == 0) {
653 compute_frame_duration(&num, &den, st, pc, pkt);
655 pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
659 if(is_intra_only(st->codec))
660 pkt->flags |= PKT_FLAG_KEY;
662 /* do we have a video B frame ? */
663 presentation_delayed = 0;
664 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
665 /* XXX: need has_b_frame, but cannot get it if the codec is
667 if (( st->codec->codec_id == CODEC_ID_H264
668 || st->codec->has_b_frames) &&
669 pc && pc->pict_type != FF_B_TYPE)
670 presentation_delayed = 1;
671 /* this may be redundant, but it shouldnt hurt */
672 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
673 presentation_delayed = 1;
676 if(st->cur_dts == AV_NOPTS_VALUE){
677 if(presentation_delayed) st->cur_dts = -pkt->duration;
678 else st->cur_dts = 0;
681 // 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);
682 /* interpolate PTS and DTS if they are not present */
683 if (presentation_delayed) {
684 /* DTS = decompression time stamp */
685 /* PTS = presentation time stamp */
686 if (pkt->dts == AV_NOPTS_VALUE) {
687 /* if we know the last pts, use it */
688 if(st->last_IP_pts != AV_NOPTS_VALUE)
689 st->cur_dts = pkt->dts = st->last_IP_pts;
691 pkt->dts = st->cur_dts;
693 st->cur_dts = pkt->dts;
695 /* this is tricky: the dts must be incremented by the duration
696 of the frame we are displaying, i.e. the last I or P frame */
697 if (st->last_IP_duration == 0)
698 st->cur_dts += pkt->duration;
700 st->cur_dts += st->last_IP_duration;
701 st->last_IP_duration = pkt->duration;
702 st->last_IP_pts= pkt->pts;
703 /* cannot compute PTS if not present (we can compute it only
704 by knowing the futur */
705 } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
706 if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
707 int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
708 int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
709 if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
710 pkt->pts += pkt->duration;
711 // 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);
715 /* presentation is not delayed : PTS and DTS are the same */
716 if (pkt->pts == AV_NOPTS_VALUE) {
717 if (pkt->dts == AV_NOPTS_VALUE) {
718 pkt->pts = st->cur_dts;
719 pkt->dts = st->cur_dts;
722 st->cur_dts = pkt->dts;
726 st->cur_dts = pkt->pts;
729 st->cur_dts += pkt->duration;
731 // 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);
736 /* key frame computation */
737 switch(st->codec->codec_type) {
738 case CODEC_TYPE_VIDEO:
739 if (pc->pict_type == FF_I_TYPE)
740 pkt->flags |= PKT_FLAG_KEY;
742 case CODEC_TYPE_AUDIO:
743 pkt->flags |= PKT_FLAG_KEY;
751 void av_destruct_packet_nofree(AVPacket *pkt)
753 pkt->data = NULL; pkt->size = 0;
756 static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
762 /* select current input stream component */
765 if (!st->need_parsing || !st->parser) {
766 /* no parsing needed: we just output the packet as is */
767 /* raw data support */
769 compute_pkt_fields(s, st, NULL, pkt);
772 } else if (s->cur_len > 0 && st->discard < AVDISCARD_ALL) {
773 len = av_parser_parse(st->parser, st->codec, &pkt->data, &pkt->size,
774 s->cur_ptr, s->cur_len,
775 s->cur_pkt.pts, s->cur_pkt.dts);
776 s->cur_pkt.pts = AV_NOPTS_VALUE;
777 s->cur_pkt.dts = AV_NOPTS_VALUE;
778 /* increment read pointer */
782 /* return packet if any */
786 pkt->stream_index = st->index;
787 pkt->pts = st->parser->pts;
788 pkt->dts = st->parser->dts;
789 pkt->destruct = av_destruct_packet_nofree;
790 compute_pkt_fields(s, st, st->parser, pkt);
792 if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & PKT_FLAG_KEY){
793 av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
794 0, 0, AVINDEX_KEYFRAME);
801 av_free_packet(&s->cur_pkt);
805 /* read next packet */
806 ret = av_read_packet(s, &s->cur_pkt);
808 if (ret == AVERROR(EAGAIN))
810 /* return the last frames, if any */
811 for(i = 0; i < s->nb_streams; i++) {
813 if (st->parser && st->need_parsing) {
814 av_parser_parse(st->parser, st->codec,
815 &pkt->data, &pkt->size,
817 AV_NOPTS_VALUE, AV_NOPTS_VALUE);
822 /* no more packets: really terminates parsing */
826 st = s->streams[s->cur_pkt.stream_index];
827 if(st->codec->debug & FF_DEBUG_PTS)
828 av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
829 s->cur_pkt.stream_index,
835 s->cur_ptr = s->cur_pkt.data;
836 s->cur_len = s->cur_pkt.size;
837 if (st->need_parsing && !st->parser) {
838 st->parser = av_parser_init(st->codec->codec_id);
840 /* no parser available : just output the raw packets */
841 st->need_parsing = 0;
842 }else if(st->need_parsing == 2){
843 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
845 if(st->parser && (s->iformat->flags & AVFMT_GENERIC_INDEX)){
846 st->parser->last_frame_offset=
847 st->parser->cur_offset= s->cur_pkt.pos;
852 if(st->codec->debug & FF_DEBUG_PTS)
853 av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
863 * Return the next frame of a stream.
865 * The returned packet is valid
866 * until the next av_read_frame() or until av_close_input_file() and
867 * must be freed with av_free_packet. For video, the packet contains
868 * exactly one frame. For audio, it contains an integer number of
869 * frames if each frame has a known fixed size (e.g. PCM or ADPCM
870 * data). If the audio frames have a variable size (e.g. MPEG audio),
871 * then it contains one frame.
873 * pkt->pts, pkt->dts and pkt->duration are always set to correct
874 * values in AV_TIME_BASE unit (and guessed if the format cannot
875 * provided them). pkt->pts can be AV_NOPTS_VALUE if the video format
876 * has B frames, so it is better to rely on pkt->dts if you do not
877 * decompress the payload.
879 * @return 0 if OK, < 0 if error or end of file.
881 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
885 const int genpts= s->flags & AVFMT_FLAG_GENPTS;
888 pktl = s->packet_buffer;
890 AVPacket *next_pkt= &pktl->pkt;
892 if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
893 while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
894 if( pktl->pkt.stream_index == next_pkt->stream_index
895 && next_pkt->dts < pktl->pkt.dts
896 && pktl->pkt.pts != pktl->pkt.dts //not b frame
897 /*&& pktl->pkt.dts != AV_NOPTS_VALUE*/){
898 next_pkt->pts= pktl->pkt.dts;
902 pktl = s->packet_buffer;
905 if( next_pkt->pts != AV_NOPTS_VALUE
906 || next_pkt->dts == AV_NOPTS_VALUE
908 /* read packet from packet buffer, if there is data */
910 s->packet_buffer = pktl->next;
916 AVPacketList **plast_pktl= &s->packet_buffer;
917 int ret= av_read_frame_internal(s, pkt);
919 if(pktl && ret != AVERROR(EAGAIN)){
926 /* duplicate the packet */
927 if (av_dup_packet(pkt) < 0)
928 return AVERROR_NOMEM;
930 while(*plast_pktl) plast_pktl= &(*plast_pktl)->next; //FIXME maybe maintain pointer to the last?
932 pktl = av_mallocz(sizeof(AVPacketList));
934 return AVERROR_NOMEM;
936 /* add the packet in the buffered packet list */
940 assert(!s->packet_buffer);
941 return av_read_frame_internal(s, pkt);
946 /* XXX: suppress the packet queue */
947 static void flush_packet_queue(AVFormatContext *s)
952 pktl = s->packet_buffer;
955 s->packet_buffer = pktl->next;
956 av_free_packet(&pktl->pkt);
961 /*******************************************************/
964 int av_find_default_stream_index(AVFormatContext *s)
969 if (s->nb_streams <= 0)
971 for(i = 0; i < s->nb_streams; i++) {
973 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
981 * Flush the frame reader.
983 static void av_read_frame_flush(AVFormatContext *s)
988 flush_packet_queue(s);
990 /* free previous packet */
992 if (s->cur_st->parser)
993 av_free_packet(&s->cur_pkt);
1000 /* for each stream, reset read state */
1001 for(i = 0; i < s->nb_streams; i++) {
1005 av_parser_close(st->parser);
1008 st->last_IP_pts = AV_NOPTS_VALUE;
1009 st->cur_dts = 0; /* we set the current DTS to an unspecified origin */
1014 * Updates cur_dts of all streams based on given timestamp and AVStream.
1016 * Stream ref_st unchanged, others set cur_dts in their native timebase
1017 * only needed for timestamp wrapping or if (dts not set and pts!=dts)
1018 * @param timestamp new dts expressed in time_base of param ref_st
1019 * @param ref_st reference stream giving time_base of param timestamp
1021 void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1024 for(i = 0; i < s->nb_streams; i++) {
1025 AVStream *st = s->streams[i];
1027 st->cur_dts = av_rescale(timestamp,
1028 st->time_base.den * (int64_t)ref_st->time_base.num,
1029 st->time_base.num * (int64_t)ref_st->time_base.den);
1034 * Add a index entry into a sorted list updateing if it is already there.
1036 * @param timestamp timestamp in the timebase of the given stream
1038 int av_add_index_entry(AVStream *st,
1039 int64_t pos, int64_t timestamp, int size, int distance, int flags)
1041 AVIndexEntry *entries, *ie;
1044 if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1047 entries = av_fast_realloc(st->index_entries,
1048 &st->index_entries_allocated_size,
1049 (st->nb_index_entries + 1) *
1050 sizeof(AVIndexEntry));
1054 st->index_entries= entries;
1056 index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
1059 index= st->nb_index_entries++;
1060 ie= &entries[index];
1061 assert(index==0 || ie[-1].timestamp < timestamp);
1063 ie= &entries[index];
1064 if(ie->timestamp != timestamp){
1065 if(ie->timestamp <= timestamp)
1067 memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
1068 st->nb_index_entries++;
1069 }else if(ie->pos == pos && distance < ie->min_distance) //dont reduce the distance
1070 distance= ie->min_distance;
1074 ie->timestamp = timestamp;
1075 ie->min_distance= distance;
1083 * build an index for raw streams using a parser.
1085 static void av_build_index_raw(AVFormatContext *s)
1087 AVPacket pkt1, *pkt = &pkt1;
1092 av_read_frame_flush(s);
1093 url_fseek(&s->pb, s->data_offset, SEEK_SET);
1096 ret = av_read_frame(s, pkt);
1099 if (pkt->stream_index == 0 && st->parser &&
1100 (pkt->flags & PKT_FLAG_KEY)) {
1101 av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
1102 0, 0, AVINDEX_KEYFRAME);
1104 av_free_packet(pkt);
1109 * Returns TRUE if we deal with a raw stream.
1111 * Raw codec data and parsing needed.
1113 static int is_raw_stream(AVFormatContext *s)
1117 if (s->nb_streams != 1)
1120 if (!st->need_parsing)
1126 * Gets the index for a specific timestamp.
1127 * @param flags if AVSEEK_FLAG_BACKWARD then the returned index will correspond to
1128 * the timestamp which is <= the requested one, if backward is 0
1129 * then it will be >=
1130 * if AVSEEK_FLAG_ANY seek to any frame, only keyframes otherwise
1131 * @return < 0 if no such timestamp could be found
1133 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1136 AVIndexEntry *entries= st->index_entries;
1137 int nb_entries= st->nb_index_entries;
1146 timestamp = entries[m].timestamp;
1147 if(timestamp >= wanted_timestamp)
1149 if(timestamp <= wanted_timestamp)
1152 m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1154 if(!(flags & AVSEEK_FLAG_ANY)){
1155 while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1156 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1168 * Does a binary search using av_index_search_timestamp() and AVCodec.read_timestamp().
1169 * this isnt supposed to be called directly by a user application, but by demuxers
1170 * @param target_ts target timestamp in the time base of the given stream
1171 * @param stream_index stream number
1173 int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1174 AVInputFormat *avif= s->iformat;
1175 int64_t pos_min, pos_max, pos, pos_limit;
1176 int64_t ts_min, ts_max, ts;
1180 if (stream_index < 0)
1184 av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1188 ts_min= AV_NOPTS_VALUE;
1189 pos_limit= -1; //gcc falsely says it may be uninitalized
1191 st= s->streams[stream_index];
1192 if(st->index_entries){
1195 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()
1196 index= FFMAX(index, 0);
1197 e= &st->index_entries[index];
1199 if(e->timestamp <= target_ts || e->pos == e->min_distance){
1201 ts_min= e->timestamp;
1203 av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1210 index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1211 assert(index < st->nb_index_entries);
1213 e= &st->index_entries[index];
1214 assert(e->timestamp >= target_ts);
1216 ts_max= e->timestamp;
1217 pos_limit= pos_max - e->min_distance;
1219 av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1220 pos_max,pos_limit, ts_max);
1225 pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1230 url_fseek(&s->pb, pos, SEEK_SET);
1232 av_update_cur_dts(s, st, ts);
1238 * Does a binary search using read_timestamp().
1239 * this isnt supposed to be called directly by a user application, but by demuxers
1240 * @param target_ts target timestamp in the time base of the given stream
1241 * @param stream_index stream number
1243 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 )){
1245 int64_t start_pos, filesize;
1249 av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1252 if(ts_min == AV_NOPTS_VALUE){
1253 pos_min = s->data_offset;
1254 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1255 if (ts_min == AV_NOPTS_VALUE)
1259 if(ts_max == AV_NOPTS_VALUE){
1261 filesize = url_fsize(&s->pb);
1262 pos_max = filesize - 1;
1265 ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1267 }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1268 if (ts_max == AV_NOPTS_VALUE)
1272 int64_t tmp_pos= pos_max + 1;
1273 int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1274 if(tmp_ts == AV_NOPTS_VALUE)
1278 if(tmp_pos >= filesize)
1284 if(ts_min > ts_max){
1286 }else if(ts_min == ts_max){
1291 while (pos_min < pos_limit) {
1293 av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1297 assert(pos_limit <= pos_max);
1300 int64_t approximate_keyframe_distance= pos_max - pos_limit;
1301 // interpolate position (better than dichotomy)
1302 pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1303 + pos_min - approximate_keyframe_distance;
1304 }else if(no_change==1){
1305 // bisection, if interpolation failed to change min or max pos last time
1306 pos = (pos_min + pos_limit)>>1;
1308 // linear search if bisection failed, can only happen if there are very few or no keframes between min/max
1313 else if(pos > pos_limit)
1317 ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1323 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);
1325 assert(ts != AV_NOPTS_VALUE);
1326 if (target_ts <= ts) {
1327 pos_limit = start_pos - 1;
1331 if (target_ts >= ts) {
1337 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1338 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
1341 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1343 ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1344 av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1345 pos, ts_min, target_ts, ts_max);
1351 static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1352 int64_t pos_min, pos_max;
1356 if (stream_index < 0)
1359 st= s->streams[stream_index];
1362 pos_min = s->data_offset;
1363 pos_max = url_fsize(&s->pb) - 1;
1365 if (pos < pos_min) pos= pos_min;
1366 else if(pos > pos_max) pos= pos_max;
1368 url_fseek(&s->pb, pos, SEEK_SET);
1371 av_update_cur_dts(s, st, ts);
1376 static int av_seek_frame_generic(AVFormatContext *s,
1377 int stream_index, int64_t timestamp, int flags)
1383 st = s->streams[stream_index];
1385 index = av_index_search_timestamp(st, timestamp, flags);
1391 if(st->index_entries && st->nb_index_entries){
1392 ie= &st->index_entries[st->nb_index_entries-1];
1393 url_fseek(&s->pb, ie->pos, SEEK_SET);
1394 av_update_cur_dts(s, st, ie->timestamp);
1396 url_fseek(&s->pb, 0, SEEK_SET);
1399 int ret = av_read_frame(s, &pkt);
1402 av_free_packet(&pkt);
1403 if(stream_index == pkt.stream_index){
1404 if((pkt.flags & PKT_FLAG_KEY) && pkt.dts > timestamp)
1408 index = av_index_search_timestamp(st, timestamp, flags);
1413 av_read_frame_flush(s);
1414 if (s->iformat->read_seek){
1415 if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1418 ie = &st->index_entries[index];
1419 url_fseek(&s->pb, ie->pos, SEEK_SET);
1421 av_update_cur_dts(s, st, ie->timestamp);
1427 * Seek to the key frame at timestamp.
1428 * 'timestamp' in 'stream_index'.
1429 * @param stream_index If stream_index is (-1), a default
1430 * stream is selected, and timestamp is automatically converted
1431 * from AV_TIME_BASE units to the stream specific time_base.
1432 * @param timestamp timestamp in AVStream.time_base units
1433 * or if there is no stream specified then in AV_TIME_BASE units
1434 * @param flags flags which select direction and seeking mode
1435 * @return >= 0 on success
1437 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1442 av_read_frame_flush(s);
1444 if(flags & AVSEEK_FLAG_BYTE)
1445 return av_seek_frame_byte(s, stream_index, timestamp, flags);
1447 if(stream_index < 0){
1448 stream_index= av_find_default_stream_index(s);
1449 if(stream_index < 0)
1452 st= s->streams[stream_index];
1453 /* timestamp for default must be expressed in AV_TIME_BASE units */
1454 timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1456 st= s->streams[stream_index];
1458 /* first, we try the format specific seek */
1459 if (s->iformat->read_seek)
1460 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1467 if(s->iformat->read_timestamp)
1468 return av_seek_frame_binary(s, stream_index, timestamp, flags);
1470 return av_seek_frame_generic(s, stream_index, timestamp, flags);
1473 /*******************************************************/
1476 * Returns TRUE if the stream has accurate timings in any stream.
1478 * @return TRUE if the stream has accurate timings for at least one component.
1480 static int av_has_timings(AVFormatContext *ic)
1485 for(i = 0;i < ic->nb_streams; i++) {
1486 st = ic->streams[i];
1487 if (st->start_time != AV_NOPTS_VALUE &&
1488 st->duration != AV_NOPTS_VALUE)
1495 * Estimate the stream timings from the one of each components.
1497 * Also computes the global bitrate if possible.
1499 static void av_update_stream_timings(AVFormatContext *ic)
1501 int64_t start_time, start_time1, end_time, end_time1;
1505 start_time = INT64_MAX;
1506 end_time = INT64_MIN;
1507 for(i = 0;i < ic->nb_streams; i++) {
1508 st = ic->streams[i];
1509 if (st->start_time != AV_NOPTS_VALUE) {
1510 start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1511 if (start_time1 < start_time)
1512 start_time = start_time1;
1513 if (st->duration != AV_NOPTS_VALUE) {
1514 end_time1 = start_time1
1515 + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1516 if (end_time1 > end_time)
1517 end_time = end_time1;
1521 if (start_time != INT64_MAX) {
1522 ic->start_time = start_time;
1523 if (end_time != INT64_MIN) {
1524 ic->duration = end_time - start_time;
1525 if (ic->file_size > 0) {
1526 /* compute the bit rate */
1527 ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1528 (double)ic->duration;
1535 static void fill_all_stream_timings(AVFormatContext *ic)
1540 av_update_stream_timings(ic);
1541 for(i = 0;i < ic->nb_streams; i++) {
1542 st = ic->streams[i];
1543 if (st->start_time == AV_NOPTS_VALUE) {
1544 if(ic->start_time != AV_NOPTS_VALUE)
1545 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1546 if(ic->duration != AV_NOPTS_VALUE)
1547 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1552 static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1554 int64_t filesize, duration;
1558 /* if bit_rate is already set, we believe it */
1559 if (ic->bit_rate == 0) {
1561 for(i=0;i<ic->nb_streams;i++) {
1562 st = ic->streams[i];
1563 bit_rate += st->codec->bit_rate;
1565 ic->bit_rate = bit_rate;
1568 /* if duration is already set, we believe it */
1569 if (ic->duration == AV_NOPTS_VALUE &&
1570 ic->bit_rate != 0 &&
1571 ic->file_size != 0) {
1572 filesize = ic->file_size;
1574 for(i = 0; i < ic->nb_streams; i++) {
1575 st = ic->streams[i];
1576 duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1577 if (st->start_time == AV_NOPTS_VALUE ||
1578 st->duration == AV_NOPTS_VALUE) {
1580 st->duration = duration;
1587 #define DURATION_MAX_READ_SIZE 250000
1589 /* only usable for MPEG-PS streams */
1590 static void av_estimate_timings_from_pts(AVFormatContext *ic, offset_t old_offset)
1592 AVPacket pkt1, *pkt = &pkt1;
1594 int read_size, i, ret;
1596 int64_t filesize, offset, duration;
1598 /* free previous packet */
1599 if (ic->cur_st && ic->cur_st->parser)
1600 av_free_packet(&ic->cur_pkt);
1603 /* flush packet queue */
1604 flush_packet_queue(ic);
1606 for(i=0;i<ic->nb_streams;i++) {
1607 st = ic->streams[i];
1609 av_parser_close(st->parser);
1614 /* we read the first packets to get the first PTS (not fully
1615 accurate, but it is enough now) */
1616 url_fseek(&ic->pb, 0, SEEK_SET);
1619 if (read_size >= DURATION_MAX_READ_SIZE)
1621 /* if all info is available, we can stop */
1622 for(i = 0;i < ic->nb_streams; i++) {
1623 st = ic->streams[i];
1624 if (st->start_time == AV_NOPTS_VALUE)
1627 if (i == ic->nb_streams)
1630 ret = av_read_packet(ic, pkt);
1633 read_size += pkt->size;
1634 st = ic->streams[pkt->stream_index];
1635 if (pkt->pts != AV_NOPTS_VALUE) {
1636 if (st->start_time == AV_NOPTS_VALUE)
1637 st->start_time = pkt->pts;
1639 av_free_packet(pkt);
1642 /* estimate the end time (duration) */
1643 /* XXX: may need to support wrapping */
1644 filesize = ic->file_size;
1645 offset = filesize - DURATION_MAX_READ_SIZE;
1649 url_fseek(&ic->pb, offset, SEEK_SET);
1652 if (read_size >= DURATION_MAX_READ_SIZE)
1654 /* if all info is available, we can stop */
1655 for(i = 0;i < ic->nb_streams; i++) {
1656 st = ic->streams[i];
1657 if (st->duration == AV_NOPTS_VALUE)
1660 if (i == ic->nb_streams)
1663 ret = av_read_packet(ic, pkt);
1666 read_size += pkt->size;
1667 st = ic->streams[pkt->stream_index];
1668 if (pkt->pts != AV_NOPTS_VALUE) {
1669 end_time = pkt->pts;
1670 duration = end_time - st->start_time;
1672 if (st->duration == AV_NOPTS_VALUE ||
1673 st->duration < duration)
1674 st->duration = duration;
1677 av_free_packet(pkt);
1680 fill_all_stream_timings(ic);
1682 url_fseek(&ic->pb, old_offset, SEEK_SET);
1685 static void av_estimate_timings(AVFormatContext *ic, offset_t old_offset)
1689 /* get the file size, if possible */
1690 if (ic->iformat->flags & AVFMT_NOFILE) {
1693 file_size = url_fsize(&ic->pb);
1697 ic->file_size = file_size;
1699 if ((!strcmp(ic->iformat->name, "mpeg") ||
1700 !strcmp(ic->iformat->name, "mpegts")) &&
1701 file_size && !ic->pb.is_streamed) {
1702 /* get accurate estimate from the PTSes */
1703 av_estimate_timings_from_pts(ic, old_offset);
1704 } else if (av_has_timings(ic)) {
1705 /* at least one components has timings - we use them for all
1707 fill_all_stream_timings(ic);
1709 /* less precise: use bit rate info */
1710 av_estimate_timings_from_bit_rate(ic);
1712 av_update_stream_timings(ic);
1718 for(i = 0;i < ic->nb_streams; i++) {
1719 st = ic->streams[i];
1720 printf("%d: start_time: %0.3f duration: %0.3f\n",
1721 i, (double)st->start_time / AV_TIME_BASE,
1722 (double)st->duration / AV_TIME_BASE);
1724 printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1725 (double)ic->start_time / AV_TIME_BASE,
1726 (double)ic->duration / AV_TIME_BASE,
1727 ic->bit_rate / 1000);
1732 static int has_codec_parameters(AVCodecContext *enc)
1735 switch(enc->codec_type) {
1736 case CODEC_TYPE_AUDIO:
1737 val = enc->sample_rate;
1739 case CODEC_TYPE_VIDEO:
1740 val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
1749 static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1753 int got_picture, ret=0;
1756 if(!st->codec->codec){
1757 codec = avcodec_find_decoder(st->codec->codec_id);
1760 ret = avcodec_open(st->codec, codec);
1765 if(!has_codec_parameters(st->codec)){
1766 switch(st->codec->codec_type) {
1767 case CODEC_TYPE_VIDEO:
1768 ret = avcodec_decode_video(st->codec, &picture,
1769 &got_picture, (uint8_t *)data, size);
1771 case CODEC_TYPE_AUDIO:
1772 samples = av_malloc(AVCODEC_MAX_AUDIO_FRAME_SIZE);
1775 ret = avcodec_decode_audio(st->codec, samples,
1776 &got_picture, (uint8_t *)data, size);
1787 /* absolute maximum size we read until we abort */
1788 #define MAX_READ_SIZE 5000000
1790 #define MAX_STD_TIMEBASES (60*12+5)
1791 static int get_std_framerate(int i){
1792 if(i<60*12) return i*1001;
1793 else return ((int[]){24,30,60,12,15})[i-60*12]*1000*12;
1797 * Read packets of a media file to get stream information. This
1798 * is useful for file formats with no headers such as MPEG. This
1799 * function also computes the real frame rate in case of mpeg2 repeat
1801 * The logical file position is not changed by this function;
1802 * examined packets may be buffered for later processing.
1804 * @param ic media file handle
1805 * @return >=0 if OK. AVERROR_xxx if error.
1806 * @todo let user decide somehow what information is needed so we dont waste time geting stuff the user doesnt need
1808 int av_find_stream_info(AVFormatContext *ic)
1810 int i, count, ret, read_size, j;
1812 AVPacket pkt1, *pkt;
1813 AVPacketList *pktl=NULL, **ppktl;
1814 int64_t last_dts[MAX_STREAMS];
1815 int duration_count[MAX_STREAMS]={0};
1816 double duration_error[MAX_STREAMS][MAX_STD_TIMEBASES]={{0}}; //FIXME malloc()?
1817 offset_t old_offset = url_ftell(&ic->pb);
1819 for(i=0;i<ic->nb_streams;i++) {
1820 st = ic->streams[i];
1821 if(st->codec->codec_type == CODEC_TYPE_VIDEO){
1822 /* if(!st->time_base.num)
1824 if(!st->codec->time_base.num)
1825 st->codec->time_base= st->time_base;
1827 //only for the split stuff
1829 st->parser = av_parser_init(st->codec->codec_id);
1830 if(st->need_parsing == 2 && st->parser){
1831 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1836 for(i=0;i<MAX_STREAMS;i++){
1837 last_dts[i]= AV_NOPTS_VALUE;
1842 ppktl = &ic->packet_buffer;
1844 /* check if one codec still needs to be handled */
1845 for(i=0;i<ic->nb_streams;i++) {
1846 st = ic->streams[i];
1847 if (!has_codec_parameters(st->codec))
1849 /* variable fps and no guess at the real fps */
1850 if( st->codec->time_base.den >= 101LL*st->codec->time_base.num
1851 && duration_count[i]<20 && st->codec->codec_type == CODEC_TYPE_VIDEO)
1853 if(st->parser && st->parser->parser->split && !st->codec->extradata)
1856 if (i == ic->nb_streams) {
1857 /* NOTE: if the format has no header, then we need to read
1858 some packets to get most of the streams, so we cannot
1860 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
1861 /* if we found the info for all the codecs, we can stop */
1866 /* we did not get all the codec info, but we read too much data */
1867 if (read_size >= MAX_READ_SIZE) {
1872 /* NOTE: a new stream can be added there if no header in file
1873 (AVFMTCTX_NOHEADER) */
1874 ret = av_read_frame_internal(ic, &pkt1);
1877 ret = -1; /* we could not have all the codec parameters before EOF */
1878 for(i=0;i<ic->nb_streams;i++) {
1879 st = ic->streams[i];
1880 if (!has_codec_parameters(st->codec)){
1882 avcodec_string(buf, sizeof(buf), st->codec, 0);
1883 av_log(ic, AV_LOG_INFO, "Could not find codec parameters (%s)\n", buf);
1891 pktl = av_mallocz(sizeof(AVPacketList));
1893 ret = AVERROR_NOMEM;
1897 /* add the packet in the buffered packet list */
1899 ppktl = &pktl->next;
1904 /* duplicate the packet */
1905 if (av_dup_packet(pkt) < 0) {
1906 ret = AVERROR_NOMEM;
1910 read_size += pkt->size;
1912 st = ic->streams[pkt->stream_index];
1913 if(st->codec_info_nb_frames>1) //FIXME move codec_info_nb_frames and codec_info_duration from AVStream into this func
1914 st->codec_info_duration += pkt->duration;
1915 if (pkt->duration != 0)
1916 st->codec_info_nb_frames++;
1919 int index= pkt->stream_index;
1920 int64_t last= last_dts[index];
1921 int64_t duration= pkt->dts - last;
1923 if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
1924 double dur= duration * av_q2d(st->time_base);
1926 // if(st->codec->codec_type == CODEC_TYPE_VIDEO)
1927 // av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
1928 if(duration_count[index] < 2)
1929 memset(duration_error, 0, sizeof(duration_error));
1930 for(i=1; i<MAX_STD_TIMEBASES; i++){
1931 int framerate= get_std_framerate(i);
1932 int ticks= lrintf(dur*framerate/(1001*12));
1933 double error= dur - ticks*1001*12/(double)framerate;
1934 duration_error[index][i] += error*error;
1936 duration_count[index]++;
1938 if(st->codec_info_nb_frames == 0 && 0)
1939 st->codec_info_duration += duration;
1941 if(last == AV_NOPTS_VALUE || duration_count[index]<=1)
1942 last_dts[pkt->stream_index]= pkt->dts;
1944 if(st->parser && st->parser->parser->split && !st->codec->extradata){
1945 int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
1947 st->codec->extradata_size= i;
1948 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
1949 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
1950 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
1954 /* if still no information, we try to open the codec and to
1955 decompress the frame. We try to avoid that in most cases as
1956 it takes longer and uses more memory. For MPEG4, we need to
1957 decompress for Quicktime. */
1958 if (!has_codec_parameters(st->codec) /*&&
1959 (st->codec->codec_id == CODEC_ID_FLV1 ||
1960 st->codec->codec_id == CODEC_ID_H264 ||
1961 st->codec->codec_id == CODEC_ID_H263 ||
1962 st->codec->codec_id == CODEC_ID_H261 ||
1963 st->codec->codec_id == CODEC_ID_VORBIS ||
1964 st->codec->codec_id == CODEC_ID_MJPEG ||
1965 st->codec->codec_id == CODEC_ID_PNG ||
1966 st->codec->codec_id == CODEC_ID_PAM ||
1967 st->codec->codec_id == CODEC_ID_PGM ||
1968 st->codec->codec_id == CODEC_ID_PGMYUV ||
1969 st->codec->codec_id == CODEC_ID_PBM ||
1970 st->codec->codec_id == CODEC_ID_PPM ||
1971 st->codec->codec_id == CODEC_ID_SHORTEN ||
1972 (st->codec->codec_id == CODEC_ID_MPEG4 && !st->need_parsing))*/)
1973 try_decode_frame(st, pkt->data, pkt->size);
1975 if (av_rescale_q(st->codec_info_duration, st->time_base, AV_TIME_BASE_Q) >= ic->max_analyze_duration) {
1981 // close codecs which where opened in try_decode_frame()
1982 for(i=0;i<ic->nb_streams;i++) {
1983 st = ic->streams[i];
1984 if(st->codec->codec)
1985 avcodec_close(st->codec);
1987 for(i=0;i<ic->nb_streams;i++) {
1988 st = ic->streams[i];
1989 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1990 if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_sample)
1991 st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
1993 if(duration_count[i]
1994 && (st->codec->time_base.num*101LL <= st->codec->time_base.den || st->codec->codec_id == CODEC_ID_MPEG2VIDEO) /*&&
1995 //FIXME we should not special case mpeg2, but this needs testing with non mpeg2 ...
1996 st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den*/){
1997 double best_error= 2*av_q2d(st->time_base);
1998 best_error= best_error*best_error*duration_count[i]*1000*12*30;
2000 for(j=1; j<MAX_STD_TIMEBASES; j++){
2001 double error= duration_error[i][j] * get_std_framerate(j);
2002 // if(st->codec->codec_type == CODEC_TYPE_VIDEO)
2003 // av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
2004 if(error < best_error){
2006 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, get_std_framerate(j), 12*1001, INT_MAX);
2011 if (!st->r_frame_rate.num){
2012 if( st->codec->time_base.den * (int64_t)st->time_base.num
2013 <= st->codec->time_base.num * (int64_t)st->time_base.den){
2014 st->r_frame_rate.num = st->codec->time_base.den;
2015 st->r_frame_rate.den = st->codec->time_base.num;
2017 st->r_frame_rate.num = st->time_base.den;
2018 st->r_frame_rate.den = st->time_base.num;
2021 }else if(st->codec->codec_type == CODEC_TYPE_AUDIO) {
2022 if(!st->codec->bits_per_sample)
2023 st->codec->bits_per_sample= av_get_bits_per_sample(st->codec->codec_id);
2027 av_estimate_timings(ic, old_offset);
2029 /* correct DTS for b frame streams with no timestamps */
2030 for(i=0;i<ic->nb_streams;i++) {
2031 st = ic->streams[i];
2032 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2034 ppktl = &ic->packet_buffer;
2036 if(ppkt1->stream_index != i)
2038 if(ppkt1->pkt->dts < 0)
2040 if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2042 ppkt1->pkt->dts -= delta;
2047 st->cur_dts -= delta;
2055 /*******************************************************/
2058 * start playing a network based stream (e.g. RTSP stream) at the
2061 int av_read_play(AVFormatContext *s)
2063 if (!s->iformat->read_play)
2064 return AVERROR_NOTSUPP;
2065 return s->iformat->read_play(s);
2069 * Pause a network based stream (e.g. RTSP stream).
2071 * Use av_read_play() to resume it.
2073 int av_read_pause(AVFormatContext *s)
2075 if (!s->iformat->read_pause)
2076 return AVERROR_NOTSUPP;
2077 return s->iformat->read_pause(s);
2081 * Close a media file (but not its codecs).
2083 * @param s media file handle
2085 void av_close_input_file(AVFormatContext *s)
2087 int i, must_open_file;
2090 /* free previous packet */
2091 if (s->cur_st && s->cur_st->parser)
2092 av_free_packet(&s->cur_pkt);
2094 if (s->iformat->read_close)
2095 s->iformat->read_close(s);
2096 for(i=0;i<s->nb_streams;i++) {
2097 /* free all data in a stream component */
2100 av_parser_close(st->parser);
2102 av_free(st->index_entries);
2103 av_free(st->codec->extradata);
2107 flush_packet_queue(s);
2109 if (s->iformat->flags & AVFMT_NOFILE) {
2112 if (must_open_file) {
2115 av_freep(&s->priv_data);
2120 * Add a new stream to a media file.
2122 * Can only be called in the read_header() function. If the flag
2123 * AVFMTCTX_NOHEADER is in the format context, then new streams
2124 * can be added in read_packet too.
2126 * @param s media file handle
2127 * @param id file format dependent stream id
2129 AVStream *av_new_stream(AVFormatContext *s, int id)
2134 if (s->nb_streams >= MAX_STREAMS)
2137 st = av_mallocz(sizeof(AVStream));
2141 st->codec= avcodec_alloc_context();
2143 /* no default bitrate if decoding */
2144 st->codec->bit_rate = 0;
2146 st->index = s->nb_streams;
2148 st->start_time = AV_NOPTS_VALUE;
2149 st->duration = AV_NOPTS_VALUE;
2150 st->cur_dts = AV_NOPTS_VALUE;
2152 /* default pts settings is MPEG like */
2153 av_set_pts_info(st, 33, 1, 90000);
2154 st->last_IP_pts = AV_NOPTS_VALUE;
2155 for(i=0; i<MAX_REORDER_DELAY+1; i++)
2156 st->pts_buffer[i]= AV_NOPTS_VALUE;
2158 s->streams[s->nb_streams++] = st;
2162 /************************************************************/
2163 /* output media file */
2165 int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2169 if (s->oformat->priv_data_size > 0) {
2170 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2172 return AVERROR_NOMEM;
2174 s->priv_data = NULL;
2176 if (s->oformat->set_parameters) {
2177 ret = s->oformat->set_parameters(s, ap);
2185 * allocate the stream private data and write the stream header to an
2188 * @param s media file handle
2189 * @return 0 if OK. AVERROR_xxx if error.
2191 int av_write_header(AVFormatContext *s)
2196 // some sanity checks
2197 for(i=0;i<s->nb_streams;i++) {
2200 switch (st->codec->codec_type) {
2201 case CODEC_TYPE_AUDIO:
2202 if(st->codec->sample_rate<=0){
2203 av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2207 case CODEC_TYPE_VIDEO:
2208 if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2209 av_log(s, AV_LOG_ERROR, "time base not set\n");
2212 if(st->codec->width<=0 || st->codec->height<=0){
2213 av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2219 if(s->oformat->codec_tag){
2220 if(st->codec->codec_tag){
2222 //check that tag + id is in the table
2223 //if neither is in the table -> ok
2224 //if tag is in the table with another id -> FAIL
2225 //if id is in the table with another tag -> FAIL unless strict < ?
2227 st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2231 if (!s->priv_data && s->oformat->priv_data_size > 0) {
2232 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2234 return AVERROR_NOMEM;
2237 if(s->oformat->write_header){
2238 ret = s->oformat->write_header(s);
2243 /* init PTS generation */
2244 for(i=0;i<s->nb_streams;i++) {
2245 int64_t den = AV_NOPTS_VALUE;
2248 switch (st->codec->codec_type) {
2249 case CODEC_TYPE_AUDIO:
2250 den = (int64_t)st->time_base.num * st->codec->sample_rate;
2252 case CODEC_TYPE_VIDEO:
2253 den = (int64_t)st->time_base.num * st->codec->time_base.den;
2258 if (den != AV_NOPTS_VALUE) {
2260 return AVERROR_INVALIDDATA;
2261 av_frac_init(&st->pts, 0, 0, den);
2267 //FIXME merge with compute_pkt_fields
2268 static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
2269 int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2270 int num, den, frame_size, i;
2272 // 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);
2274 /* if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2277 /* duration field */
2278 if (pkt->duration == 0) {
2279 compute_frame_duration(&num, &den, st, NULL, pkt);
2281 pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
2285 //XXX/FIXME this is a temporary hack until all encoders output pts
2286 if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2288 // pkt->pts= st->cur_dts;
2289 pkt->pts= st->pts.val;
2292 //calculate dts from pts
2293 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE){
2294 st->pts_buffer[0]= pkt->pts;
2295 for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2296 st->pts_buffer[i]= (i-delay-1) * pkt->duration;
2297 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2298 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2300 pkt->dts= st->pts_buffer[0];
2303 if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2304 av_log(NULL, AV_LOG_ERROR, "error, non monotone timestamps %"PRId64" >= %"PRId64"\n", st->cur_dts, pkt->dts);
2307 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2308 av_log(NULL, AV_LOG_ERROR, "error, pts < dts\n");
2312 // av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2313 st->cur_dts= pkt->dts;
2314 st->pts.val= pkt->dts;
2317 switch (st->codec->codec_type) {
2318 case CODEC_TYPE_AUDIO:
2319 frame_size = get_audio_frame_size(st->codec, pkt->size);
2321 /* HACK/FIXME, we skip the initial 0-size packets as they are most likely equal to the encoder delay,
2322 but it would be better if we had the real timestamps from the encoder */
2323 if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2324 av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2327 case CODEC_TYPE_VIDEO:
2328 av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2336 static void truncate_ts(AVStream *st, AVPacket *pkt){
2337 int64_t pts_mask = (2LL << (st->pts_wrap_bits-1)) - 1;
2340 // pkt->dts= 0; //this happens for low_delay=0 and b frames, FIXME, needs further invstigation about what we should do here
2342 if (pkt->pts != AV_NOPTS_VALUE)
2343 pkt->pts &= pts_mask;
2344 if (pkt->dts != AV_NOPTS_VALUE)
2345 pkt->dts &= pts_mask;
2349 * Write a packet to an output media file.
2351 * The packet shall contain one audio or video frame.
2352 * The packet must be correctly interleaved according to the container specification,
2353 * if not then av_interleaved_write_frame must be used
2355 * @param s media file handle
2356 * @param pkt the packet, which contains the stream_index, buf/buf_size, dts/pts, ...
2357 * @return < 0 if error, = 0 if OK, 1 if end of stream wanted.
2359 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2363 ret=compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2364 if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2367 truncate_ts(s->streams[pkt->stream_index], pkt);
2369 ret= s->oformat->write_packet(s, pkt);
2371 ret= url_ferror(&s->pb);
2376 * Interleave a packet per DTS in an output media file.
2378 * Packets with pkt->destruct == av_destruct_packet will be freed inside this function,
2379 * so they cannot be used after it, note calling av_free_packet() on them is still safe.
2381 * @param s media file handle
2382 * @param out the interleaved packet will be output here
2383 * @param in the input packet
2384 * @param flush 1 if no further packets are available as input and all
2385 * remaining packets should be output
2386 * @return 1 if a packet was output, 0 if no packet could be output,
2387 * < 0 if an error occured
2389 int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2390 AVPacketList *pktl, **next_point, *this_pktl;
2392 int streams[MAX_STREAMS];
2395 AVStream *st= s->streams[ pkt->stream_index];
2397 // assert(pkt->destruct != av_destruct_packet); //FIXME
2399 this_pktl = av_mallocz(sizeof(AVPacketList));
2400 this_pktl->pkt= *pkt;
2401 if(pkt->destruct == av_destruct_packet)
2402 pkt->destruct= NULL; // non shared -> must keep original from being freed
2404 av_dup_packet(&this_pktl->pkt); //shared -> must dup
2406 next_point = &s->packet_buffer;
2408 AVStream *st2= s->streams[ (*next_point)->pkt.stream_index];
2409 int64_t left= st2->time_base.num * (int64_t)st ->time_base.den;
2410 int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2411 if((*next_point)->pkt.dts * left > pkt->dts * right) //FIXME this can overflow
2413 next_point= &(*next_point)->next;
2415 this_pktl->next= *next_point;
2416 *next_point= this_pktl;
2419 memset(streams, 0, sizeof(streams));
2420 pktl= s->packet_buffer;
2422 //av_log(s, AV_LOG_DEBUG, "show st:%d dts:%"PRId64"\n", pktl->pkt.stream_index, pktl->pkt.dts);
2423 if(streams[ pktl->pkt.stream_index ] == 0)
2425 streams[ pktl->pkt.stream_index ]++;
2429 if(s->nb_streams == stream_count || (flush && stream_count)){
2430 pktl= s->packet_buffer;
2433 s->packet_buffer= pktl->next;
2437 av_init_packet(out);
2443 * Interleaves a AVPacket correctly so it can be muxed.
2444 * @param out the interleaved packet will be output here
2445 * @param in the input packet
2446 * @param flush 1 if no further packets are available as input and all
2447 * remaining packets should be output
2448 * @return 1 if a packet was output, 0 if no packet could be output,
2449 * < 0 if an error occured
2451 static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2452 if(s->oformat->interleave_packet)
2453 return s->oformat->interleave_packet(s, out, in, flush);
2455 return av_interleave_packet_per_dts(s, out, in, flush);
2459 * Writes a packet to an output media file ensuring correct interleaving.
2461 * The packet must contain one audio or video frame.
2462 * If the packets are already correctly interleaved the application should
2463 * call av_write_frame() instead as its slightly faster, its also important
2464 * to keep in mind that completly non interleaved input will need huge amounts
2465 * of memory to interleave with this, so its prefereable to interleave at the
2468 * @param s media file handle
2469 * @param pkt the packet, which contains the stream_index, buf/buf_size, dts/pts, ...
2470 * @return < 0 if error, = 0 if OK, 1 if end of stream wanted.
2472 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2473 AVStream *st= s->streams[ pkt->stream_index];
2475 //FIXME/XXX/HACK drop zero sized packets
2476 if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2479 //av_log(NULL, AV_LOG_DEBUG, "av_interleaved_write_frame %d %"PRId64" %"PRId64"\n", pkt->size, pkt->dts, pkt->pts);
2480 if(compute_pkt_fields2(st, pkt) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2483 if(pkt->dts == AV_NOPTS_VALUE)
2488 int ret= av_interleave_packet(s, &opkt, pkt, 0);
2489 if(ret<=0) //FIXME cleanup needed for ret<0 ?
2492 truncate_ts(s->streams[opkt.stream_index], &opkt);
2493 ret= s->oformat->write_packet(s, &opkt);
2495 av_free_packet(&opkt);
2500 if(url_ferror(&s->pb))
2501 return url_ferror(&s->pb);
2506 * @brief Write the stream trailer to an output media file and
2507 * free the file private data.
2509 * @param s media file handle
2510 * @return 0 if OK. AVERROR_xxx if error.
2512 int av_write_trailer(AVFormatContext *s)
2518 ret= av_interleave_packet(s, &pkt, NULL, 1);
2519 if(ret<0) //FIXME cleanup needed for ret<0 ?
2524 truncate_ts(s->streams[pkt.stream_index], &pkt);
2525 ret= s->oformat->write_packet(s, &pkt);
2527 av_free_packet(&pkt);
2531 if(url_ferror(&s->pb))
2535 if(s->oformat->write_trailer)
2536 ret = s->oformat->write_trailer(s);
2539 ret=url_ferror(&s->pb);
2540 for(i=0;i<s->nb_streams;i++)
2541 av_freep(&s->streams[i]->priv_data);
2542 av_freep(&s->priv_data);
2546 /* "user interface" functions */
2548 void dump_format(AVFormatContext *ic,
2556 av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
2557 is_output ? "Output" : "Input",
2559 is_output ? ic->oformat->name : ic->iformat->name,
2560 is_output ? "to" : "from", url);
2562 av_log(NULL, AV_LOG_INFO, " Duration: ");
2563 if (ic->duration != AV_NOPTS_VALUE) {
2564 int hours, mins, secs, us;
2565 secs = ic->duration / AV_TIME_BASE;
2566 us = ic->duration % AV_TIME_BASE;
2571 av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%01d", hours, mins, secs,
2572 (10 * us) / AV_TIME_BASE);
2574 av_log(NULL, AV_LOG_INFO, "N/A");
2576 if (ic->start_time != AV_NOPTS_VALUE) {
2578 av_log(NULL, AV_LOG_INFO, ", start: ");
2579 secs = ic->start_time / AV_TIME_BASE;
2580 us = ic->start_time % AV_TIME_BASE;
2581 av_log(NULL, AV_LOG_INFO, "%d.%06d",
2582 secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
2584 av_log(NULL, AV_LOG_INFO, ", bitrate: ");
2586 av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
2588 av_log(NULL, AV_LOG_INFO, "N/A");
2590 av_log(NULL, AV_LOG_INFO, "\n");
2592 for(i=0;i<ic->nb_streams;i++) {
2593 AVStream *st = ic->streams[i];
2594 int g= ff_gcd(st->time_base.num, st->time_base.den);
2595 avcodec_string(buf, sizeof(buf), st->codec, is_output);
2596 av_log(NULL, AV_LOG_INFO, " Stream #%d.%d", index, i);
2597 /* the pid is an important information, so we display it */
2598 /* XXX: add a generic system */
2600 flags = ic->oformat->flags;
2602 flags = ic->iformat->flags;
2603 if (flags & AVFMT_SHOW_IDS) {
2604 av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
2606 if (strlen(st->language) > 0) {
2607 av_log(NULL, AV_LOG_INFO, "(%s)", st->language);
2609 av_log(NULL, AV_LOG_DEBUG, ", %d/%d", st->time_base.num/g, st->time_base.den/g);
2610 av_log(NULL, AV_LOG_INFO, ": %s", buf);
2611 if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2612 if(st->r_frame_rate.den && st->r_frame_rate.num)
2613 av_log(NULL, AV_LOG_INFO, ", %5.2f fps(r)", av_q2d(st->r_frame_rate));
2614 /* else if(st->time_base.den && st->time_base.num)
2615 av_log(NULL, AV_LOG_INFO, ", %5.2f fps(m)", 1/av_q2d(st->time_base));*/
2617 av_log(NULL, AV_LOG_INFO, ", %5.2f fps(c)", 1/av_q2d(st->codec->time_base));
2619 av_log(NULL, AV_LOG_INFO, "\n");
2626 int frame_rate, frame_rate_base;
2629 static AbvEntry frame_abvs[] = {
2630 { "ntsc", 720, 480, 30000, 1001 },
2631 { "pal", 720, 576, 25, 1 },
2632 { "qntsc", 352, 240, 30000, 1001 }, /* VCD compliant ntsc */
2633 { "qpal", 352, 288, 25, 1 }, /* VCD compliant pal */
2634 { "sntsc", 640, 480, 30000, 1001 }, /* square pixel ntsc */
2635 { "spal", 768, 576, 25, 1 }, /* square pixel pal */
2636 { "film", 352, 240, 24, 1 },
2637 { "ntsc-film", 352, 240, 24000, 1001 },
2638 { "sqcif", 128, 96, 0, 0 },
2639 { "qcif", 176, 144, 0, 0 },
2640 { "cif", 352, 288, 0, 0 },
2641 { "4cif", 704, 576, 0, 0 },
2645 * parses width and height out of string str.
2647 int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2650 int n = sizeof(frame_abvs) / sizeof(AbvEntry);
2652 int frame_width = 0, frame_height = 0;
2655 if (!strcmp(frame_abvs[i].abv, str)) {
2656 frame_width = frame_abvs[i].width;
2657 frame_height = frame_abvs[i].height;
2663 frame_width = strtol(p, (char **)&p, 10);
2666 frame_height = strtol(p, (char **)&p, 10);
2668 if (frame_width <= 0 || frame_height <= 0)
2670 *width_ptr = frame_width;
2671 *height_ptr = frame_height;
2676 * Converts frame rate from string to a fraction.
2678 * First we try to get an exact integer or fractional frame rate.
2679 * If this fails we convert the frame rate to a double and return
2680 * an approximate fraction using the DEFAULT_FRAME_RATE_BASE.
2682 int parse_frame_rate(int *frame_rate, int *frame_rate_base, const char *arg)
2687 /* First, we check our abbreviation table */
2688 for (i = 0; i < sizeof(frame_abvs)/sizeof(*frame_abvs); ++i)
2689 if (!strcmp(frame_abvs[i].abv, arg)) {
2690 *frame_rate = frame_abvs[i].frame_rate;
2691 *frame_rate_base = frame_abvs[i].frame_rate_base;
2695 /* Then, we try to parse it as fraction */
2696 cp = strchr(arg, '/');
2698 cp = strchr(arg, ':');
2701 *frame_rate = strtol(arg, &cpp, 10);
2702 if (cpp != arg || cpp == cp)
2703 *frame_rate_base = strtol(cp+1, &cpp, 10);
2708 /* Finally we give up and parse it as double */
2709 AVRational time_base = av_d2q(strtod(arg, 0), DEFAULT_FRAME_RATE_BASE);
2710 *frame_rate_base = time_base.den;
2711 *frame_rate = time_base.num;
2713 if (!*frame_rate || !*frame_rate_base)
2720 * Converts date string to number of seconds since Jan 1st, 1970.
2724 * - If not a duration:
2725 * [{YYYY-MM-DD|YYYYMMDD}]{T| }{HH[:MM[:SS[.m...]]][Z]|HH[MM[SS[.m...]]][Z]}
2726 * Time is localtime unless Z is suffixed to the end. In this case GMT
2727 * Return the date in micro seconds since 1970
2730 * HH[:MM[:SS[.m...]]]
2734 #ifndef CONFIG_WINCE
2735 int64_t parse_date(const char *datestr, int duration)
2741 static const char *date_fmt[] = {
2745 static const char *time_fmt[] = {
2755 time_t now = time(0);
2757 len = strlen(datestr);
2759 lastch = datestr[len - 1];
2762 is_utc = (lastch == 'z' || lastch == 'Z');
2764 memset(&dt, 0, sizeof(dt));
2769 for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
2770 q = small_strptime(p, date_fmt[i], &dt);
2780 dt = *localtime(&now);
2782 dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
2787 if (*p == 'T' || *p == 't' || *p == ' ')
2790 for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
2791 q = small_strptime(p, time_fmt[i], &dt);
2801 q = small_strptime(p, time_fmt[0], &dt);
2803 dt.tm_sec = strtol(p, (char **)&q, 10);
2809 /* Now we have all the fields that we can get */
2814 return now * INT64_C(1000000);
2818 t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2820 dt.tm_isdst = -1; /* unknown */
2833 for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
2836 val += n * (*q - '0');
2840 return negative ? -t : t;
2842 #endif /* CONFIG_WINCE */
2845 * Attempts to find a specific tag in a URL.
2847 * syntax: '?tag1=val1&tag2=val2...'. Little URL decoding is done.
2848 * Return 1 if found.
2850 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
2860 while (*p != '\0' && *p != '=' && *p != '&') {
2861 if ((q - tag) < sizeof(tag) - 1)
2869 while (*p != '&' && *p != '\0') {
2870 if ((q - arg) < arg_size - 1) {
2880 if (!strcmp(tag, tag1))
2890 * Returns in 'buf' the path with '%d' replaced by number.
2892 * Also handles the '%0nd' format where 'n' is the total number
2893 * of digits and '%%'.
2895 * @param buf destination buffer
2896 * @param buf_size destination buffer size
2897 * @param path numbered sequence string
2898 * @number frame number
2899 * @return 0 if OK, -1 if format error.
2901 int av_get_frame_filename(char *buf, int buf_size,
2902 const char *path, int number)
2905 char *q, buf1[20], c;
2906 int nd, len, percentd_found;
2918 while (isdigit(*p)) {
2919 nd = nd * 10 + *p++ - '0';
2922 } while (isdigit(c));
2931 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
2933 if ((q - buf + len) > buf_size - 1)
2935 memcpy(q, buf1, len);
2943 if ((q - buf) < buf_size - 1)
2947 if (!percentd_found)
2957 * Print nice hexa dump of a buffer
2958 * @param f stream for output
2960 * @param size buffer size
2962 void av_hex_dump(FILE *f, uint8_t *buf, int size)
2966 for(i=0;i<size;i+=16) {
2970 fprintf(f, "%08x ", i);
2973 fprintf(f, " %02x", buf[i+j]);
2978 for(j=0;j<len;j++) {
2980 if (c < ' ' || c > '~')
2982 fprintf(f, "%c", c);
2989 * Print on 'f' a nice dump of a packet
2990 * @param f stream for output
2991 * @param pkt packet to dump
2992 * @param dump_payload true if the payload must be displayed too
2994 //FIXME needs to know the time_base
2995 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
2997 fprintf(f, "stream #%d:\n", pkt->stream_index);
2998 fprintf(f, " keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
2999 fprintf(f, " duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
3000 /* DTS is _always_ valid after av_read_frame() */
3001 fprintf(f, " dts=");
3002 if (pkt->dts == AV_NOPTS_VALUE)
3005 fprintf(f, "%0.3f", (double)pkt->dts / AV_TIME_BASE);
3006 /* PTS may be not known if B frames are present */
3007 fprintf(f, " pts=");
3008 if (pkt->pts == AV_NOPTS_VALUE)
3011 fprintf(f, "%0.3f", (double)pkt->pts / AV_TIME_BASE);
3013 fprintf(f, " size=%d\n", pkt->size);
3015 av_hex_dump(f, pkt->data, pkt->size);
3018 void url_split(char *proto, int proto_size,
3019 char *authorization, int authorization_size,
3020 char *hostname, int hostname_size,
3022 char *path, int path_size,
3033 while (*p != ':' && *p != '\0') {
3034 if ((q - proto) < proto_size - 1)
3040 if (authorization_size > 0)
3041 authorization[0] = '\0';
3045 if (hostname_size > 0)
3049 char *at,*slash; // PETR: position of '@' character and '/' character
3056 at = strchr(p,'@'); // PETR: get the position of '@'
3057 slash = strchr(p,'/'); // PETR: get position of '/' - end of hostname
3058 if (at && slash && at > slash) at = NULL; // PETR: not interested in '@' behind '/'
3060 q = at ? authorization : hostname; // PETR: if '@' exists starting with auth.
3062 while ((at || *p != ':') && *p != '/' && *p != '?' && *p != '\0') { // PETR:
3063 if (*p == '@') { // PETR: passed '@'
3064 if (authorization_size > 0)
3068 } else if (!at) { // PETR: hostname
3069 if ((q - hostname) < hostname_size - 1)
3072 if ((q - authorization) < authorization_size - 1)
3077 if (hostname_size > 0)
3081 port = strtoul(p, (char **)&p, 10);
3086 pstrcpy(path, path_size, p);
3090 * Set the pts for a given stream.
3093 * @param pts_wrap_bits number of bits effectively used by the pts
3094 * (used for wrap control, 33 is the value for MPEG)
3095 * @param pts_num numerator to convert to seconds (MPEG: 1)
3096 * @param pts_den denominator to convert to seconds (MPEG: 90000)
3098 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3099 int pts_num, int pts_den)
3101 s->pts_wrap_bits = pts_wrap_bits;
3102 s->time_base.num = pts_num;
3103 s->time_base.den = pts_den;
3106 /* fraction handling */
3109 * f = val + (num / den) + 0.5.
3111 * 'num' is normalized so that it is such as 0 <= num < den.
3113 * @param f fractional number
3114 * @param val integer value
3115 * @param num must be >= 0
3116 * @param den must be >= 1
3118 static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
3131 * Fractionnal addition to f: f = f + (incr / f->den).
3133 * @param f fractional number
3134 * @param incr increment, can be positive or negative
3136 static void av_frac_add(AVFrac *f, int64_t incr)
3140 num = f->num + incr;
3143 f->val += num / den;
3149 } else if (num >= den) {
3150 f->val += num / den;