2 * various utility functions for use within FFmpeg
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
23 #include "libavcodec/internal.h"
24 #include "libavutil/opt.h"
27 #include "libavutil/avstring.h"
29 #include "audiointerleave.h"
43 * various utility functions for use within FFmpeg
46 unsigned avformat_version(void)
48 return LIBAVFORMAT_VERSION_INT;
51 const char *avformat_configuration(void)
53 return FFMPEG_CONFIGURATION;
56 const char *avformat_license(void)
58 #define LICENSE_PREFIX "libavformat license: "
59 return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;
62 /* fraction handling */
65 * f = val + (num / den) + 0.5.
67 * 'num' is normalized so that it is such as 0 <= num < den.
69 * @param f fractional number
70 * @param val integer value
71 * @param num must be >= 0
72 * @param den must be >= 1
74 static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
87 * Fractional addition to f: f = f + (incr / f->den).
89 * @param f fractional number
90 * @param incr increment, can be positive or negative
92 static void av_frac_add(AVFrac *f, int64_t incr)
105 } else if (num >= den) {
112 /** head of registered input format linked list */
113 #if !FF_API_FIRST_FORMAT
116 AVInputFormat *first_iformat = NULL;
117 /** head of registered output format linked list */
118 #if !FF_API_FIRST_FORMAT
121 AVOutputFormat *first_oformat = NULL;
123 AVInputFormat *av_iformat_next(AVInputFormat *f)
125 if(f) return f->next;
126 else return first_iformat;
129 AVOutputFormat *av_oformat_next(AVOutputFormat *f)
131 if(f) return f->next;
132 else return first_oformat;
135 void av_register_input_format(AVInputFormat *format)
139 while (*p != NULL) p = &(*p)->next;
144 void av_register_output_format(AVOutputFormat *format)
148 while (*p != NULL) p = &(*p)->next;
153 int av_match_ext(const char *filename, const char *extensions)
161 ext = strrchr(filename, '.');
167 while (*p != '\0' && *p != ',' && q-ext1<sizeof(ext1)-1)
170 if (!strcasecmp(ext1, ext))
180 static int match_format(const char *name, const char *names)
188 namelen = strlen(name);
189 while ((p = strchr(names, ','))) {
190 len = FFMAX(p - names, namelen);
191 if (!strncasecmp(name, names, len))
195 return !strcasecmp(name, names);
198 #if FF_API_GUESS_FORMAT
199 AVOutputFormat *guess_format(const char *short_name, const char *filename,
200 const char *mime_type)
202 return av_guess_format(short_name, filename, mime_type);
206 AVOutputFormat *av_guess_format(const char *short_name, const char *filename,
207 const char *mime_type)
209 AVOutputFormat *fmt = NULL, *fmt_found;
210 int score_max, score;
212 /* specific test for image sequences */
213 #if CONFIG_IMAGE2_MUXER
214 if (!short_name && filename &&
215 av_filename_number_test(filename) &&
216 av_guess_image2_codec(filename) != CODEC_ID_NONE) {
217 return av_guess_format("image2", NULL, NULL);
220 /* Find the proper file type. */
223 while ((fmt = av_oformat_next(fmt))) {
225 if (fmt->name && short_name && !strcmp(fmt->name, short_name))
227 if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
229 if (filename && fmt->extensions &&
230 av_match_ext(filename, fmt->extensions)) {
233 if (score > score_max) {
241 #if FF_API_GUESS_FORMAT
242 AVOutputFormat *guess_stream_format(const char *short_name, const char *filename,
243 const char *mime_type)
245 AVOutputFormat *fmt = av_guess_format(short_name, filename, mime_type);
248 AVOutputFormat *stream_fmt;
249 char stream_format_name[64];
251 snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
252 stream_fmt = av_guess_format(stream_format_name, NULL, NULL);
262 enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
263 const char *filename, const char *mime_type, enum AVMediaType type){
264 if(type == AVMEDIA_TYPE_VIDEO){
265 enum CodecID codec_id= CODEC_ID_NONE;
267 #if CONFIG_IMAGE2_MUXER
268 if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
269 codec_id= av_guess_image2_codec(filename);
272 if(codec_id == CODEC_ID_NONE)
273 codec_id= fmt->video_codec;
275 }else if(type == AVMEDIA_TYPE_AUDIO)
276 return fmt->audio_codec;
277 else if (type == AVMEDIA_TYPE_SUBTITLE)
278 return fmt->subtitle_codec;
280 return CODEC_ID_NONE;
283 AVInputFormat *av_find_input_format(const char *short_name)
285 AVInputFormat *fmt = NULL;
286 while ((fmt = av_iformat_next(fmt))) {
287 if (match_format(short_name, fmt->name))
293 #if FF_API_SYMVER && CONFIG_SHARED && HAVE_SYMVER
294 FF_SYMVER(void, av_destruct_packet_nofree, (AVPacket *pkt), "LIBAVFORMAT_52")
296 av_destruct_packet_nofree(pkt);
299 FF_SYMVER(void, av_destruct_packet, (AVPacket *pkt), "LIBAVFORMAT_52")
301 av_destruct_packet(pkt);
304 FF_SYMVER(int, av_new_packet, (AVPacket *pkt, int size), "LIBAVFORMAT_52")
306 return av_new_packet(pkt, size);
309 FF_SYMVER(int, av_dup_packet, (AVPacket *pkt), "LIBAVFORMAT_52")
311 return av_dup_packet(pkt);
314 FF_SYMVER(void, av_free_packet, (AVPacket *pkt), "LIBAVFORMAT_52")
319 FF_SYMVER(void, av_init_packet, (AVPacket *pkt), "LIBAVFORMAT_52")
321 av_log(NULL, AV_LOG_WARNING, "Diverting av_*_packet function calls to libavcodec. Recompile to improve performance\n");
326 int av_get_packet(ByteIOContext *s, AVPacket *pkt, int size)
328 int ret= av_new_packet(pkt, size);
333 pkt->pos= url_ftell(s);
335 ret= get_buffer(s, pkt->data, size);
339 av_shrink_packet(pkt, ret);
344 int av_append_packet(ByteIOContext *s, AVPacket *pkt, int size)
349 return av_get_packet(s, pkt, size);
350 old_size = pkt->size;
351 ret = av_grow_packet(pkt, size);
354 ret = get_buffer(s, pkt->data + old_size, size);
355 av_shrink_packet(pkt, old_size + FFMAX(ret, 0));
360 int av_filename_number_test(const char *filename)
363 return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
366 AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
368 AVProbeData lpd = *pd;
369 AVInputFormat *fmt1 = NULL, *fmt;
372 if (lpd.buf_size > 10 && ff_id3v2_match(lpd.buf, ID3v2_DEFAULT_MAGIC)) {
373 int id3len = ff_id3v2_tag_len(lpd.buf);
374 if (lpd.buf_size > id3len + 16) {
376 lpd.buf_size -= id3len;
381 while ((fmt1 = av_iformat_next(fmt1))) {
382 if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
385 if (fmt1->read_probe) {
386 score = fmt1->read_probe(&lpd);
387 } else if (fmt1->extensions) {
388 if (av_match_ext(lpd.filename, fmt1->extensions)) {
392 if (score > *score_max) {
395 }else if (score == *score_max)
401 AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
403 return av_probe_input_format2(pd, is_opened, &score);
406 static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st, AVProbeData *pd, int score)
408 static const struct {
409 const char *name; enum CodecID id; enum AVMediaType type;
411 { "aac" , CODEC_ID_AAC , AVMEDIA_TYPE_AUDIO },
412 { "ac3" , CODEC_ID_AC3 , AVMEDIA_TYPE_AUDIO },
413 { "dts" , CODEC_ID_DTS , AVMEDIA_TYPE_AUDIO },
414 { "eac3" , CODEC_ID_EAC3 , AVMEDIA_TYPE_AUDIO },
415 { "h264" , CODEC_ID_H264 , AVMEDIA_TYPE_VIDEO },
416 { "m4v" , CODEC_ID_MPEG4 , AVMEDIA_TYPE_VIDEO },
417 { "mp3" , CODEC_ID_MP3 , AVMEDIA_TYPE_AUDIO },
418 { "mpegvideo", CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
421 AVInputFormat *fmt = av_probe_input_format2(pd, 1, &score);
425 av_log(s, AV_LOG_DEBUG, "Probe with size=%d, packets=%d detected %s with score=%d\n",
426 pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets, fmt->name, score);
427 for (i = 0; fmt_id_type[i].name; i++) {
428 if (!strcmp(fmt->name, fmt_id_type[i].name)) {
429 st->codec->codec_id = fmt_id_type[i].id;
430 st->codec->codec_type = fmt_id_type[i].type;
438 /************************************************************/
439 /* input media file */
442 * Open a media file from an IO stream. 'fmt' must be specified.
444 int av_open_input_stream(AVFormatContext **ic_ptr,
445 ByteIOContext *pb, const char *filename,
446 AVInputFormat *fmt, AVFormatParameters *ap)
450 AVFormatParameters default_ap;
454 memset(ap, 0, sizeof(default_ap));
457 if(!ap->prealloced_context)
458 ic = avformat_alloc_context();
462 err = AVERROR(ENOMEM);
467 ic->duration = AV_NOPTS_VALUE;
468 ic->start_time = AV_NOPTS_VALUE;
469 av_strlcpy(ic->filename, filename, sizeof(ic->filename));
471 /* allocate private data */
472 if (fmt->priv_data_size > 0) {
473 ic->priv_data = av_mallocz(fmt->priv_data_size);
474 if (!ic->priv_data) {
475 err = AVERROR(ENOMEM);
479 ic->priv_data = NULL;
482 // e.g. AVFMT_NOFILE formats will not have a ByteIOContext
484 ff_id3v2_read(ic, ID3v2_DEFAULT_MAGIC);
486 if (ic->iformat->read_header) {
487 err = ic->iformat->read_header(ic, ap);
492 if (pb && !ic->data_offset)
493 ic->data_offset = url_ftell(ic->pb);
495 #if FF_API_OLD_METADATA
496 ff_metadata_demux_compat(ic);
499 ic->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
506 av_freep(&ic->priv_data);
507 for(i=0;i<ic->nb_streams;i++) {
508 AVStream *st = ic->streams[i];
510 av_free(st->priv_data);
511 av_free(st->codec->extradata);
523 /** size of probe buffer, for guessing file type from file contents */
524 #define PROBE_BUF_MIN 2048
525 #define PROBE_BUF_MAX (1<<20)
527 int ff_probe_input_buffer(ByteIOContext **pb, AVInputFormat **fmt,
528 const char *filename, void *logctx,
529 unsigned int offset, unsigned int max_probe_size)
531 AVProbeData pd = { filename ? filename : "", NULL, -offset };
532 unsigned char *buf = NULL;
533 int ret = 0, probe_size;
535 if (!max_probe_size) {
536 max_probe_size = PROBE_BUF_MAX;
537 } else if (max_probe_size > PROBE_BUF_MAX) {
538 max_probe_size = PROBE_BUF_MAX;
539 } else if (max_probe_size < PROBE_BUF_MIN) {
540 return AVERROR(EINVAL);
543 if (offset >= max_probe_size) {
544 return AVERROR(EINVAL);
547 for(probe_size= PROBE_BUF_MIN; probe_size<=max_probe_size && !*fmt && ret >= 0;
548 probe_size = FFMIN(probe_size<<1, FFMAX(max_probe_size, probe_size+1))) {
549 int ret, score = probe_size < max_probe_size ? AVPROBE_SCORE_MAX/4 : 0;
550 int buf_offset = (probe_size == PROBE_BUF_MIN) ? 0 : probe_size>>1;
552 if (probe_size < offset) {
556 /* read probe data */
557 buf = av_realloc(buf, probe_size + AVPROBE_PADDING_SIZE);
558 if ((ret = get_buffer(*pb, buf + buf_offset, probe_size - buf_offset)) < 0) {
559 /* fail if error was not end of file, otherwise, lower score */
560 if (ret != AVERROR_EOF) {
565 ret = 0; /* error was end of file, nothing read */
568 pd.buf = &buf[offset];
570 memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE);
572 /* guess file format */
573 *fmt = av_probe_input_format2(&pd, 1, &score);
575 if(score <= AVPROBE_SCORE_MAX/4){ //this can only be true in the last iteration
576 av_log(logctx, AV_LOG_WARNING, "Format detected only with low score of %d, misdetection possible!\n", score);
578 av_log(logctx, AV_LOG_DEBUG, "Probed with size=%d and score=%d\n", probe_size, score);
584 return AVERROR_INVALIDDATA;
587 /* rewind. reuse probe buffer to avoid seeking */
588 if ((ret = ff_rewind_with_probe_data(*pb, buf, pd.buf_size)) < 0)
594 int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
597 AVFormatParameters *ap)
600 AVProbeData probe_data, *pd = &probe_data;
601 ByteIOContext *pb = NULL;
602 void *logctx= ap && ap->prealloced_context ? *ic_ptr : NULL;
606 pd->filename = filename;
611 /* guess format if no file can be opened */
612 fmt = av_probe_input_format(pd, 0);
615 /* Do not open file if the format does not need it. XXX: specific
616 hack needed to handle RTSP/TCP */
617 if (!fmt || !(fmt->flags & AVFMT_NOFILE)) {
618 /* if no file needed do not try to open one */
619 if ((err=url_fopen(&pb, filename, URL_RDONLY)) < 0) {
623 url_setbufsize(pb, buf_size);
625 if (!fmt && (err = ff_probe_input_buffer(&pb, &fmt, filename, logctx, 0, logctx ? (*ic_ptr)->probesize : 0)) < 0) {
630 /* if still no format found, error */
632 err = AVERROR_INVALIDDATA;
636 /* check filename in case an image number is expected */
637 if (fmt->flags & AVFMT_NEEDNUMBER) {
638 if (!av_filename_number_test(filename)) {
639 err = AVERROR_NUMEXPECTED;
643 err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
651 if (ap && ap->prealloced_context)
658 /*******************************************************/
660 static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
661 AVPacketList **plast_pktl){
662 AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
667 (*plast_pktl)->next = pktl;
669 *packet_buffer = pktl;
671 /* add the packet in the buffered packet list */
677 int av_read_packet(AVFormatContext *s, AVPacket *pkt)
683 AVPacketList *pktl = s->raw_packet_buffer;
687 if(s->streams[pkt->stream_index]->codec->codec_id != CODEC_ID_PROBE ||
688 !s->streams[pkt->stream_index]->probe_packets ||
689 s->raw_packet_buffer_remaining_size < pkt->size){
690 AVProbeData *pd = &s->streams[pkt->stream_index]->probe_data;
693 s->raw_packet_buffer = pktl->next;
694 s->raw_packet_buffer_remaining_size += pkt->size;
701 ret= s->iformat->read_packet(s, pkt);
703 if (!pktl || ret == AVERROR(EAGAIN))
705 for (i = 0; i < s->nb_streams; i++)
706 s->streams[i]->probe_packets = 0;
709 st= s->streams[pkt->stream_index];
711 switch(st->codec->codec_type){
712 case AVMEDIA_TYPE_VIDEO:
713 if(s->video_codec_id) st->codec->codec_id= s->video_codec_id;
715 case AVMEDIA_TYPE_AUDIO:
716 if(s->audio_codec_id) st->codec->codec_id= s->audio_codec_id;
718 case AVMEDIA_TYPE_SUBTITLE:
719 if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
723 if(!pktl && (st->codec->codec_id != CODEC_ID_PROBE ||
727 add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
728 s->raw_packet_buffer_remaining_size -= pkt->size;
730 if(st->codec->codec_id == CODEC_ID_PROBE){
731 AVProbeData *pd = &st->probe_data;
732 av_log(s, AV_LOG_DEBUG, "probing stream %d\n", st->index);
735 pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
736 memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
737 pd->buf_size += pkt->size;
738 memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
740 if(av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)){
741 //FIXME we dont reduce score to 0 for the case of running out of buffer space in bytes
742 set_codec_from_probe_data(s, st, pd, st->probe_packets > 0 ? AVPROBE_SCORE_MAX/4 : 0);
743 if(st->codec->codec_id != CODEC_ID_PROBE){
746 av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
753 /**********************************************************/
756 * Get the number of samples of an audio frame. Return -1 on error.
758 static int get_audio_frame_size(AVCodecContext *enc, int size)
762 if(enc->codec_id == CODEC_ID_VORBIS)
765 if (enc->frame_size <= 1) {
766 int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
768 if (bits_per_sample) {
769 if (enc->channels == 0)
771 frame_size = (size << 3) / (bits_per_sample * enc->channels);
773 /* used for example by ADPCM codecs */
774 if (enc->bit_rate == 0)
776 frame_size = ((int64_t)size * 8 * enc->sample_rate) / enc->bit_rate;
779 frame_size = enc->frame_size;
786 * Return the frame duration in seconds. Return 0 if not available.
788 static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
789 AVCodecParserContext *pc, AVPacket *pkt)
795 switch(st->codec->codec_type) {
796 case AVMEDIA_TYPE_VIDEO:
797 if(st->time_base.num*1000LL > st->time_base.den){
798 *pnum = st->time_base.num;
799 *pden = st->time_base.den;
800 }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
801 *pnum = st->codec->time_base.num;
802 *pden = st->codec->time_base.den;
803 if (pc && pc->repeat_pict) {
804 *pnum = (*pnum) * (1 + pc->repeat_pict);
806 //If this codec can be interlaced or progressive then we need a parser to compute duration of a packet
807 //Thus if we have no parser in such case leave duration undefined.
808 if(st->codec->ticks_per_frame>1 && !pc){
813 case AVMEDIA_TYPE_AUDIO:
814 frame_size = get_audio_frame_size(st->codec, pkt->size);
815 if (frame_size <= 0 || st->codec->sample_rate <= 0)
818 *pden = st->codec->sample_rate;
825 static int is_intra_only(AVCodecContext *enc){
826 if(enc->codec_type == AVMEDIA_TYPE_AUDIO){
828 }else if(enc->codec_type == AVMEDIA_TYPE_VIDEO){
829 switch(enc->codec_id){
831 case CODEC_ID_MJPEGB:
833 case CODEC_ID_RAWVIDEO:
834 case CODEC_ID_DVVIDEO:
835 case CODEC_ID_HUFFYUV:
836 case CODEC_ID_FFVHUFF:
841 case CODEC_ID_JPEG2000:
849 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
850 int64_t dts, int64_t pts)
852 AVStream *st= s->streams[stream_index];
853 AVPacketList *pktl= s->packet_buffer;
855 if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE)
858 st->first_dts= dts - st->cur_dts;
861 for(; pktl; pktl= pktl->next){
862 if(pktl->pkt.stream_index != stream_index)
864 //FIXME think more about this check
865 if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
866 pktl->pkt.pts += st->first_dts;
868 if(pktl->pkt.dts != AV_NOPTS_VALUE)
869 pktl->pkt.dts += st->first_dts;
871 if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
872 st->start_time= pktl->pkt.pts;
874 if (st->start_time == AV_NOPTS_VALUE)
875 st->start_time = pts;
878 static void update_initial_durations(AVFormatContext *s, AVStream *st, AVPacket *pkt)
880 AVPacketList *pktl= s->packet_buffer;
883 if(st->first_dts != AV_NOPTS_VALUE){
884 cur_dts= st->first_dts;
885 for(; pktl; pktl= pktl->next){
886 if(pktl->pkt.stream_index == pkt->stream_index){
887 if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
889 cur_dts -= pkt->duration;
892 pktl= s->packet_buffer;
893 st->first_dts = cur_dts;
894 }else if(st->cur_dts)
897 for(; pktl; pktl= pktl->next){
898 if(pktl->pkt.stream_index != pkt->stream_index)
900 if(pktl->pkt.pts == pktl->pkt.dts && pktl->pkt.dts == AV_NOPTS_VALUE
901 && !pktl->pkt.duration){
902 pktl->pkt.dts= cur_dts;
903 if(!st->codec->has_b_frames)
904 pktl->pkt.pts= cur_dts;
905 cur_dts += pkt->duration;
906 pktl->pkt.duration= pkt->duration;
910 if(st->first_dts == AV_NOPTS_VALUE)
911 st->cur_dts= cur_dts;
914 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
915 AVCodecParserContext *pc, AVPacket *pkt)
917 int num, den, presentation_delayed, delay, i;
920 if (s->flags & AVFMT_FLAG_NOFILLIN)
923 if((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
924 pkt->dts= AV_NOPTS_VALUE;
926 if (st->codec->codec_id != CODEC_ID_H264 && pc && pc->pict_type == FF_B_TYPE)
927 //FIXME Set low_delay = 0 when has_b_frames = 1
928 st->codec->has_b_frames = 1;
930 /* do we have a video B-frame ? */
931 delay= st->codec->has_b_frames;
932 presentation_delayed = 0;
933 /* XXX: need has_b_frame, but cannot get it if the codec is
936 pc && pc->pict_type != FF_B_TYPE)
937 presentation_delayed = 1;
939 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
940 /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
941 pkt->dts -= 1LL<<st->pts_wrap_bits;
944 // some mpeg2 in mpeg-ps lack dts (issue171 / input_file.mpg)
945 // we take the conservative approach and discard both
946 // Note, if this is misbehaving for a H.264 file then possibly presentation_delayed is not set correctly.
947 if(delay==1 && pkt->dts == pkt->pts && pkt->dts != AV_NOPTS_VALUE && presentation_delayed){
948 av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination\n");
949 pkt->dts= pkt->pts= AV_NOPTS_VALUE;
952 if (pkt->duration == 0) {
953 compute_frame_duration(&num, &den, st, pc, pkt);
955 pkt->duration = av_rescale_rnd(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num, AV_ROUND_DOWN);
957 if(pkt->duration != 0 && s->packet_buffer)
958 update_initial_durations(s, st, pkt);
962 /* correct timestamps with byte offset if demuxers only have timestamps
963 on packet boundaries */
964 if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
965 /* this will estimate bitrate based on this frame's duration and size */
966 offset = av_rescale(pc->offset, pkt->duration, pkt->size);
967 if(pkt->pts != AV_NOPTS_VALUE)
969 if(pkt->dts != AV_NOPTS_VALUE)
973 if (pc && pc->dts_sync_point >= 0) {
974 // we have synchronization info from the parser
975 int64_t den = st->codec->time_base.den * (int64_t) st->time_base.num;
977 int64_t num = st->codec->time_base.num * (int64_t) st->time_base.den;
978 if (pkt->dts != AV_NOPTS_VALUE) {
979 // got DTS from the stream, update reference timestamp
980 st->reference_dts = pkt->dts - pc->dts_ref_dts_delta * num / den;
981 pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
982 } else if (st->reference_dts != AV_NOPTS_VALUE) {
983 // compute DTS based on reference timestamp
984 pkt->dts = st->reference_dts + pc->dts_ref_dts_delta * num / den;
985 pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
987 if (pc->dts_sync_point > 0)
988 st->reference_dts = pkt->dts; // new reference
992 /* This may be redundant, but it should not hurt. */
993 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
994 presentation_delayed = 1;
996 // 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);
997 /* interpolate PTS and DTS if they are not present */
998 //We skip H264 currently because delay and has_b_frames are not reliably set
999 if((delay==0 || (delay==1 && pc)) && st->codec->codec_id != CODEC_ID_H264){
1000 if (presentation_delayed) {
1001 /* DTS = decompression timestamp */
1002 /* PTS = presentation timestamp */
1003 if (pkt->dts == AV_NOPTS_VALUE)
1004 pkt->dts = st->last_IP_pts;
1005 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
1006 if (pkt->dts == AV_NOPTS_VALUE)
1007 pkt->dts = st->cur_dts;
1009 /* this is tricky: the dts must be incremented by the duration
1010 of the frame we are displaying, i.e. the last I- or P-frame */
1011 if (st->last_IP_duration == 0)
1012 st->last_IP_duration = pkt->duration;
1013 if(pkt->dts != AV_NOPTS_VALUE)
1014 st->cur_dts = pkt->dts + st->last_IP_duration;
1015 st->last_IP_duration = pkt->duration;
1016 st->last_IP_pts= pkt->pts;
1017 /* cannot compute PTS if not present (we can compute it only
1018 by knowing the future */
1019 } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
1020 if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
1021 int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
1022 int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
1023 if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
1024 pkt->pts += pkt->duration;
1025 // 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);
1029 /* presentation is not delayed : PTS and DTS are the same */
1030 if(pkt->pts == AV_NOPTS_VALUE)
1031 pkt->pts = pkt->dts;
1032 update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
1033 if(pkt->pts == AV_NOPTS_VALUE)
1034 pkt->pts = st->cur_dts;
1035 pkt->dts = pkt->pts;
1036 if(pkt->pts != AV_NOPTS_VALUE)
1037 st->cur_dts = pkt->pts + pkt->duration;
1041 if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
1042 st->pts_buffer[0]= pkt->pts;
1043 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
1044 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
1045 if(pkt->dts == AV_NOPTS_VALUE)
1046 pkt->dts= st->pts_buffer[0];
1047 if(st->codec->codec_id == CODEC_ID_H264){ //we skiped it above so we try here
1048 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
1050 if(pkt->dts > st->cur_dts)
1051 st->cur_dts = pkt->dts;
1054 // av_log(NULL, AV_LOG_ERROR, "OUTdelayed:%d/%d pts:%"PRId64", dts:%"PRId64" cur_dts:%"PRId64"\n", presentation_delayed, delay, pkt->pts, pkt->dts, st->cur_dts);
1057 if(is_intra_only(st->codec))
1058 pkt->flags |= AV_PKT_FLAG_KEY;
1061 /* keyframe computation */
1062 if (pc->key_frame == 1)
1063 pkt->flags |= AV_PKT_FLAG_KEY;
1064 else if (pc->key_frame == -1 && pc->pict_type == FF_I_TYPE)
1065 pkt->flags |= AV_PKT_FLAG_KEY;
1068 pkt->convergence_duration = pc->convergence_duration;
1072 static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1077 av_init_packet(pkt);
1080 /* select current input stream component */
1083 if (!st->need_parsing || !st->parser) {
1084 /* no parsing needed: we just output the packet as is */
1085 /* raw data support */
1086 *pkt = st->cur_pkt; st->cur_pkt.data= NULL;
1087 compute_pkt_fields(s, st, NULL, pkt);
1089 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1090 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1091 ff_reduce_index(s, st->index);
1092 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1095 } else if (st->cur_len > 0 && st->discard < AVDISCARD_ALL) {
1096 len = av_parser_parse2(st->parser, st->codec, &pkt->data, &pkt->size,
1097 st->cur_ptr, st->cur_len,
1098 st->cur_pkt.pts, st->cur_pkt.dts,
1100 st->cur_pkt.pts = AV_NOPTS_VALUE;
1101 st->cur_pkt.dts = AV_NOPTS_VALUE;
1102 /* increment read pointer */
1106 /* return packet if any */
1110 pkt->stream_index = st->index;
1111 pkt->pts = st->parser->pts;
1112 pkt->dts = st->parser->dts;
1113 pkt->pos = st->parser->pos;
1114 if(pkt->data == st->cur_pkt.data && pkt->size == st->cur_pkt.size){
1116 pkt->destruct= st->cur_pkt.destruct;
1117 st->cur_pkt.destruct= NULL;
1118 st->cur_pkt.data = NULL;
1119 assert(st->cur_len == 0);
1121 pkt->destruct = NULL;
1123 compute_pkt_fields(s, st, st->parser, pkt);
1125 if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY){
1126 ff_reduce_index(s, st->index);
1127 av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
1128 0, 0, AVINDEX_KEYFRAME);
1135 av_free_packet(&st->cur_pkt);
1140 /* read next packet */
1141 ret = av_read_packet(s, &cur_pkt);
1143 if (ret == AVERROR(EAGAIN))
1145 /* return the last frames, if any */
1146 for(i = 0; i < s->nb_streams; i++) {
1148 if (st->parser && st->need_parsing) {
1149 av_parser_parse2(st->parser, st->codec,
1150 &pkt->data, &pkt->size,
1152 AV_NOPTS_VALUE, AV_NOPTS_VALUE,
1158 /* no more packets: really terminate parsing */
1161 st = s->streams[cur_pkt.stream_index];
1162 st->cur_pkt= cur_pkt;
1164 if(st->cur_pkt.pts != AV_NOPTS_VALUE &&
1165 st->cur_pkt.dts != AV_NOPTS_VALUE &&
1166 st->cur_pkt.pts < st->cur_pkt.dts){
1167 av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
1168 st->cur_pkt.stream_index,
1172 // av_free_packet(&st->cur_pkt);
1176 if(s->debug & FF_FDEBUG_TS)
1177 av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1178 st->cur_pkt.stream_index,
1182 st->cur_pkt.duration,
1186 st->cur_ptr = st->cur_pkt.data;
1187 st->cur_len = st->cur_pkt.size;
1188 if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1189 st->parser = av_parser_init(st->codec->codec_id);
1191 /* no parser available: just output the raw packets */
1192 st->need_parsing = AVSTREAM_PARSE_NONE;
1193 }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
1194 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1195 }else if(st->need_parsing == AVSTREAM_PARSE_FULL_ONCE){
1196 st->parser->flags |= PARSER_FLAG_ONCE;
1201 if(s->debug & FF_FDEBUG_TS)
1202 av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1213 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1217 const int genpts= s->flags & AVFMT_FLAG_GENPTS;
1220 pktl = s->packet_buffer;
1222 AVPacket *next_pkt= &pktl->pkt;
1224 if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
1225 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1226 while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
1227 if( pktl->pkt.stream_index == next_pkt->stream_index
1228 && (0 > av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)))
1229 && av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) { //not b frame
1230 next_pkt->pts= pktl->pkt.dts;
1234 pktl = s->packet_buffer;
1237 if( next_pkt->pts != AV_NOPTS_VALUE
1238 || next_pkt->dts == AV_NOPTS_VALUE
1240 /* read packet from packet buffer, if there is data */
1242 s->packet_buffer = pktl->next;
1248 int ret= av_read_frame_internal(s, pkt);
1250 if(pktl && ret != AVERROR(EAGAIN)){
1257 if(av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1258 &s->packet_buffer_end)) < 0)
1259 return AVERROR(ENOMEM);
1261 assert(!s->packet_buffer);
1262 return av_read_frame_internal(s, pkt);
1267 /* XXX: suppress the packet queue */
1268 static void flush_packet_queue(AVFormatContext *s)
1273 pktl = s->packet_buffer;
1276 s->packet_buffer = pktl->next;
1277 av_free_packet(&pktl->pkt);
1280 while(s->raw_packet_buffer){
1281 pktl = s->raw_packet_buffer;
1282 s->raw_packet_buffer = pktl->next;
1283 av_free_packet(&pktl->pkt);
1286 s->packet_buffer_end=
1287 s->raw_packet_buffer_end= NULL;
1288 s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1291 /*******************************************************/
1294 int av_find_default_stream_index(AVFormatContext *s)
1296 int first_audio_index = -1;
1300 if (s->nb_streams <= 0)
1302 for(i = 0; i < s->nb_streams; i++) {
1304 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1307 if (first_audio_index < 0 && st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1308 first_audio_index = i;
1310 return first_audio_index >= 0 ? first_audio_index : 0;
1314 * Flush the frame reader.
1316 void ff_read_frame_flush(AVFormatContext *s)
1321 flush_packet_queue(s);
1325 /* for each stream, reset read state */
1326 for(i = 0; i < s->nb_streams; i++) {
1330 av_parser_close(st->parser);
1332 av_free_packet(&st->cur_pkt);
1334 st->last_IP_pts = AV_NOPTS_VALUE;
1335 st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1336 st->reference_dts = AV_NOPTS_VALUE;
1341 st->probe_packets = MAX_PROBE_PACKETS;
1343 for(j=0; j<MAX_REORDER_DELAY+1; j++)
1344 st->pts_buffer[j]= AV_NOPTS_VALUE;
1348 void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1351 for(i = 0; i < s->nb_streams; i++) {
1352 AVStream *st = s->streams[i];
1354 st->cur_dts = av_rescale(timestamp,
1355 st->time_base.den * (int64_t)ref_st->time_base.num,
1356 st->time_base.num * (int64_t)ref_st->time_base.den);
1360 void ff_reduce_index(AVFormatContext *s, int stream_index)
1362 AVStream *st= s->streams[stream_index];
1363 unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1365 if((unsigned)st->nb_index_entries >= max_entries){
1367 for(i=0; 2*i<st->nb_index_entries; i++)
1368 st->index_entries[i]= st->index_entries[2*i];
1369 st->nb_index_entries= i;
1373 int av_add_index_entry(AVStream *st,
1374 int64_t pos, int64_t timestamp, int size, int distance, int flags)
1376 AVIndexEntry *entries, *ie;
1379 if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1382 entries = av_fast_realloc(st->index_entries,
1383 &st->index_entries_allocated_size,
1384 (st->nb_index_entries + 1) *
1385 sizeof(AVIndexEntry));
1389 st->index_entries= entries;
1391 index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
1394 index= st->nb_index_entries++;
1395 ie= &entries[index];
1396 assert(index==0 || ie[-1].timestamp < timestamp);
1398 ie= &entries[index];
1399 if(ie->timestamp != timestamp){
1400 if(ie->timestamp <= timestamp)
1402 memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
1403 st->nb_index_entries++;
1404 }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1405 distance= ie->min_distance;
1409 ie->timestamp = timestamp;
1410 ie->min_distance= distance;
1417 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1420 AVIndexEntry *entries= st->index_entries;
1421 int nb_entries= st->nb_index_entries;
1428 //optimize appending index entries at the end
1429 if(b && entries[b-1].timestamp < wanted_timestamp)
1434 timestamp = entries[m].timestamp;
1435 if(timestamp >= wanted_timestamp)
1437 if(timestamp <= wanted_timestamp)
1440 m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1442 if(!(flags & AVSEEK_FLAG_ANY)){
1443 while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1444 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1455 int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1456 AVInputFormat *avif= s->iformat;
1457 int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1458 int64_t ts_min, ts_max, ts;
1463 if (stream_index < 0)
1467 av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1471 ts_min= AV_NOPTS_VALUE;
1472 pos_limit= -1; //gcc falsely says it may be uninitialized
1474 st= s->streams[stream_index];
1475 if(st->index_entries){
1478 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()
1479 index= FFMAX(index, 0);
1480 e= &st->index_entries[index];
1482 if(e->timestamp <= target_ts || e->pos == e->min_distance){
1484 ts_min= e->timestamp;
1486 av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1493 index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1494 assert(index < st->nb_index_entries);
1496 e= &st->index_entries[index];
1497 assert(e->timestamp >= target_ts);
1499 ts_max= e->timestamp;
1500 pos_limit= pos_max - e->min_distance;
1502 av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1503 pos_max,pos_limit, ts_max);
1508 pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1513 if ((ret = url_fseek(s->pb, pos, SEEK_SET)) < 0)
1516 av_update_cur_dts(s, st, ts);
1521 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 )){
1523 int64_t start_pos, filesize;
1527 av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1530 if(ts_min == AV_NOPTS_VALUE){
1531 pos_min = s->data_offset;
1532 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1533 if (ts_min == AV_NOPTS_VALUE)
1537 if(ts_max == AV_NOPTS_VALUE){
1539 filesize = url_fsize(s->pb);
1540 pos_max = filesize - 1;
1543 ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1545 }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1546 if (ts_max == AV_NOPTS_VALUE)
1550 int64_t tmp_pos= pos_max + 1;
1551 int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1552 if(tmp_ts == AV_NOPTS_VALUE)
1556 if(tmp_pos >= filesize)
1562 if(ts_min > ts_max){
1564 }else if(ts_min == ts_max){
1569 while (pos_min < pos_limit) {
1571 av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1575 assert(pos_limit <= pos_max);
1578 int64_t approximate_keyframe_distance= pos_max - pos_limit;
1579 // interpolate position (better than dichotomy)
1580 pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1581 + pos_min - approximate_keyframe_distance;
1582 }else if(no_change==1){
1583 // bisection, if interpolation failed to change min or max pos last time
1584 pos = (pos_min + pos_limit)>>1;
1586 /* linear search if bisection failed, can only happen if there
1587 are very few or no keyframes between min/max */
1592 else if(pos > pos_limit)
1596 ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1602 av_log(s, AV_LOG_DEBUG, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64" target:%"PRId64" limit:%"PRId64" start:%"PRId64" noc:%d\n",
1603 pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts, pos_limit,
1604 start_pos, no_change);
1606 if(ts == AV_NOPTS_VALUE){
1607 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1610 assert(ts != AV_NOPTS_VALUE);
1611 if (target_ts <= ts) {
1612 pos_limit = start_pos - 1;
1616 if (target_ts >= ts) {
1622 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1623 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
1626 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1628 ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1629 av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1630 pos, ts_min, target_ts, ts_max);
1636 static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1637 int64_t pos_min, pos_max;
1641 if (stream_index < 0)
1644 st= s->streams[stream_index];
1647 pos_min = s->data_offset;
1648 pos_max = url_fsize(s->pb) - 1;
1650 if (pos < pos_min) pos= pos_min;
1651 else if(pos > pos_max) pos= pos_max;
1653 url_fseek(s->pb, pos, SEEK_SET);
1656 av_update_cur_dts(s, st, ts);
1661 static int av_seek_frame_generic(AVFormatContext *s,
1662 int stream_index, int64_t timestamp, int flags)
1669 st = s->streams[stream_index];
1671 index = av_index_search_timestamp(st, timestamp, flags);
1673 if(index < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
1676 if(index < 0 || index==st->nb_index_entries-1){
1680 if(st->nb_index_entries){
1681 assert(st->index_entries);
1682 ie= &st->index_entries[st->nb_index_entries-1];
1683 if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
1685 av_update_cur_dts(s, st, ie->timestamp);
1687 if ((ret = url_fseek(s->pb, s->data_offset, SEEK_SET)) < 0)
1693 ret = av_read_frame(s, &pkt);
1694 }while(ret == AVERROR(EAGAIN));
1697 av_free_packet(&pkt);
1698 if(stream_index == pkt.stream_index){
1699 if((pkt.flags & AV_PKT_FLAG_KEY) && pkt.dts > timestamp)
1703 index = av_index_search_timestamp(st, timestamp, flags);
1708 ff_read_frame_flush(s);
1709 if (s->iformat->read_seek){
1710 if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1713 ie = &st->index_entries[index];
1714 if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
1716 av_update_cur_dts(s, st, ie->timestamp);
1721 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1726 ff_read_frame_flush(s);
1728 if(flags & AVSEEK_FLAG_BYTE)
1729 return av_seek_frame_byte(s, stream_index, timestamp, flags);
1731 if(stream_index < 0){
1732 stream_index= av_find_default_stream_index(s);
1733 if(stream_index < 0)
1736 st= s->streams[stream_index];
1737 /* timestamp for default must be expressed in AV_TIME_BASE units */
1738 timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1741 /* first, we try the format specific seek */
1742 if (s->iformat->read_seek)
1743 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1750 if(s->iformat->read_timestamp)
1751 return av_seek_frame_binary(s, stream_index, timestamp, flags);
1753 return av_seek_frame_generic(s, stream_index, timestamp, flags);
1756 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
1758 if(min_ts > ts || max_ts < ts)
1761 ff_read_frame_flush(s);
1763 if (s->iformat->read_seek2)
1764 return s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
1766 if(s->iformat->read_timestamp){
1767 //try to seek via read_timestamp()
1770 //Fallback to old API if new is not implemented but old is
1771 //Note the old has somewat different sematics
1772 if(s->iformat->read_seek || 1)
1773 return av_seek_frame(s, stream_index, ts, flags | (ts - min_ts > (uint64_t)(max_ts - ts) ? AVSEEK_FLAG_BACKWARD : 0));
1775 // try some generic seek like av_seek_frame_generic() but with new ts semantics
1778 /*******************************************************/
1781 * Return TRUE if the stream has accurate duration in any stream.
1783 * @return TRUE if the stream has accurate duration for at least one component.
1785 static int av_has_duration(AVFormatContext *ic)
1790 for(i = 0;i < ic->nb_streams; i++) {
1791 st = ic->streams[i];
1792 if (st->duration != AV_NOPTS_VALUE)
1799 * Estimate the stream timings from the one of each components.
1801 * Also computes the global bitrate if possible.
1803 static void av_update_stream_timings(AVFormatContext *ic)
1805 int64_t start_time, start_time1, end_time, end_time1;
1806 int64_t duration, duration1;
1810 start_time = INT64_MAX;
1811 end_time = INT64_MIN;
1812 duration = INT64_MIN;
1813 for(i = 0;i < ic->nb_streams; i++) {
1814 st = ic->streams[i];
1815 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
1816 start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1817 if (start_time1 < start_time)
1818 start_time = start_time1;
1819 if (st->duration != AV_NOPTS_VALUE) {
1820 end_time1 = start_time1
1821 + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1822 if (end_time1 > end_time)
1823 end_time = end_time1;
1826 if (st->duration != AV_NOPTS_VALUE) {
1827 duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1828 if (duration1 > duration)
1829 duration = duration1;
1832 if (start_time != INT64_MAX) {
1833 ic->start_time = start_time;
1834 if (end_time != INT64_MIN) {
1835 if (end_time - start_time > duration)
1836 duration = end_time - start_time;
1839 if (duration != INT64_MIN) {
1840 ic->duration = duration;
1841 if (ic->file_size > 0) {
1842 /* compute the bitrate */
1843 ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1844 (double)ic->duration;
1849 static void fill_all_stream_timings(AVFormatContext *ic)
1854 av_update_stream_timings(ic);
1855 for(i = 0;i < ic->nb_streams; i++) {
1856 st = ic->streams[i];
1857 if (st->start_time == AV_NOPTS_VALUE) {
1858 if(ic->start_time != AV_NOPTS_VALUE)
1859 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1860 if(ic->duration != AV_NOPTS_VALUE)
1861 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1866 static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1868 int64_t filesize, duration;
1872 /* if bit_rate is already set, we believe it */
1873 if (ic->bit_rate <= 0) {
1875 for(i=0;i<ic->nb_streams;i++) {
1876 st = ic->streams[i];
1877 if (st->codec->bit_rate > 0)
1878 bit_rate += st->codec->bit_rate;
1880 ic->bit_rate = bit_rate;
1883 /* if duration is already set, we believe it */
1884 if (ic->duration == AV_NOPTS_VALUE &&
1885 ic->bit_rate != 0 &&
1886 ic->file_size != 0) {
1887 filesize = ic->file_size;
1889 for(i = 0; i < ic->nb_streams; i++) {
1890 st = ic->streams[i];
1891 duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1892 if (st->duration == AV_NOPTS_VALUE)
1893 st->duration = duration;
1899 #define DURATION_MAX_READ_SIZE 250000
1900 #define DURATION_MAX_RETRY 3
1902 /* only usable for MPEG-PS streams */
1903 static void av_estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
1905 AVPacket pkt1, *pkt = &pkt1;
1907 int read_size, i, ret;
1909 int64_t filesize, offset, duration;
1914 /* flush packet queue */
1915 flush_packet_queue(ic);
1917 for (i=0; i<ic->nb_streams; i++) {
1918 st = ic->streams[i];
1919 if (st->start_time == AV_NOPTS_VALUE && st->first_dts == AV_NOPTS_VALUE)
1920 av_log(st->codec, AV_LOG_WARNING, "start time is not set in av_estimate_timings_from_pts\n");
1923 av_parser_close(st->parser);
1925 av_free_packet(&st->cur_pkt);
1929 /* estimate the end time (duration) */
1930 /* XXX: may need to support wrapping */
1931 filesize = ic->file_size;
1932 end_time = AV_NOPTS_VALUE;
1934 offset = filesize - (DURATION_MAX_READ_SIZE<<retry);
1938 url_fseek(ic->pb, offset, SEEK_SET);
1941 if (read_size >= DURATION_MAX_READ_SIZE<<(FFMAX(retry-1,0)))
1945 ret = av_read_packet(ic, pkt);
1946 }while(ret == AVERROR(EAGAIN));
1949 read_size += pkt->size;
1950 st = ic->streams[pkt->stream_index];
1951 if (pkt->pts != AV_NOPTS_VALUE &&
1952 (st->start_time != AV_NOPTS_VALUE ||
1953 st->first_dts != AV_NOPTS_VALUE)) {
1954 duration = end_time = pkt->pts;
1955 if (st->start_time != AV_NOPTS_VALUE) duration -= st->start_time;
1956 else duration -= st->first_dts;
1958 duration += 1LL<<st->pts_wrap_bits;
1960 if (st->duration == AV_NOPTS_VALUE ||
1961 st->duration < duration)
1962 st->duration = duration;
1965 av_free_packet(pkt);
1967 }while( end_time==AV_NOPTS_VALUE
1968 && filesize > (DURATION_MAX_READ_SIZE<<retry)
1969 && ++retry <= DURATION_MAX_RETRY);
1971 fill_all_stream_timings(ic);
1973 url_fseek(ic->pb, old_offset, SEEK_SET);
1974 for (i=0; i<ic->nb_streams; i++) {
1976 st->cur_dts= st->first_dts;
1977 st->last_IP_pts = AV_NOPTS_VALUE;
1981 static void av_estimate_timings(AVFormatContext *ic, int64_t old_offset)
1985 /* get the file size, if possible */
1986 if (ic->iformat->flags & AVFMT_NOFILE) {
1989 file_size = url_fsize(ic->pb);
1993 ic->file_size = file_size;
1995 if ((!strcmp(ic->iformat->name, "mpeg") ||
1996 !strcmp(ic->iformat->name, "mpegts")) &&
1997 file_size && !url_is_streamed(ic->pb)) {
1998 /* get accurate estimate from the PTSes */
1999 av_estimate_timings_from_pts(ic, old_offset);
2000 } else if (av_has_duration(ic)) {
2001 /* at least one component has timings - we use them for all
2003 fill_all_stream_timings(ic);
2005 av_log(ic, AV_LOG_WARNING, "Estimating duration from bitrate, this may be inaccurate\n");
2006 /* less precise: use bitrate info */
2007 av_estimate_timings_from_bit_rate(ic);
2009 av_update_stream_timings(ic);
2015 for(i = 0;i < ic->nb_streams; i++) {
2016 st = ic->streams[i];
2017 printf("%d: start_time: %0.3f duration: %0.3f\n",
2018 i, (double)st->start_time / AV_TIME_BASE,
2019 (double)st->duration / AV_TIME_BASE);
2021 printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2022 (double)ic->start_time / AV_TIME_BASE,
2023 (double)ic->duration / AV_TIME_BASE,
2024 ic->bit_rate / 1000);
2029 static int has_codec_parameters(AVCodecContext *enc)
2032 switch(enc->codec_type) {
2033 case AVMEDIA_TYPE_AUDIO:
2034 val = enc->sample_rate && enc->channels && enc->sample_fmt != AV_SAMPLE_FMT_NONE;
2035 if(!enc->frame_size &&
2036 (enc->codec_id == CODEC_ID_VORBIS ||
2037 enc->codec_id == CODEC_ID_AAC ||
2038 enc->codec_id == CODEC_ID_MP1 ||
2039 enc->codec_id == CODEC_ID_MP2 ||
2040 enc->codec_id == CODEC_ID_MP3 ||
2041 enc->codec_id == CODEC_ID_SPEEX))
2044 case AVMEDIA_TYPE_VIDEO:
2045 val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
2051 return enc->codec_id != CODEC_ID_NONE && val != 0;
2054 static int has_decode_delay_been_guessed(AVStream *st)
2056 return st->codec->codec_id != CODEC_ID_H264 ||
2057 st->codec_info_nb_frames >= 6 + st->codec->has_b_frames;
2060 static int try_decode_frame(AVStream *st, AVPacket *avpkt)
2064 int got_picture, data_size, ret=0;
2067 if(!st->codec->codec){
2068 codec = avcodec_find_decoder(st->codec->codec_id);
2071 ret = avcodec_open(st->codec, codec);
2076 if(!has_codec_parameters(st->codec) || !has_decode_delay_been_guessed(st)){
2077 switch(st->codec->codec_type) {
2078 case AVMEDIA_TYPE_VIDEO:
2079 avcodec_get_frame_defaults(&picture);
2080 ret = avcodec_decode_video2(st->codec, &picture,
2081 &got_picture, avpkt);
2083 case AVMEDIA_TYPE_AUDIO:
2084 data_size = FFMAX(avpkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
2085 samples = av_malloc(data_size);
2088 ret = avcodec_decode_audio3(st->codec, samples,
2100 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum CodecID id)
2102 while (tags->id != CODEC_ID_NONE) {
2110 enum CodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2113 for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
2114 if(tag == tags[i].tag)
2117 for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
2118 if (ff_toupper4(tag) == ff_toupper4(tags[i].tag))
2121 return CODEC_ID_NONE;
2124 unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum CodecID id)
2127 for(i=0; tags && tags[i]; i++){
2128 int tag= ff_codec_get_tag(tags[i], id);
2134 enum CodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
2137 for(i=0; tags && tags[i]; i++){
2138 enum CodecID id= ff_codec_get_id(tags[i], tag);
2139 if(id!=CODEC_ID_NONE) return id;
2141 return CODEC_ID_NONE;
2144 static void compute_chapters_end(AVFormatContext *s)
2148 for (i=0; i+1<s->nb_chapters; i++)
2149 if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2150 assert(s->chapters[i]->start <= s->chapters[i+1]->start);
2151 assert(!av_cmp_q(s->chapters[i]->time_base, s->chapters[i+1]->time_base));
2152 s->chapters[i]->end = s->chapters[i+1]->start;
2155 if (s->nb_chapters && s->chapters[i]->end == AV_NOPTS_VALUE) {
2156 assert(s->start_time != AV_NOPTS_VALUE);
2157 assert(s->duration > 0);
2158 s->chapters[i]->end = av_rescale_q(s->start_time + s->duration,
2160 s->chapters[i]->time_base);
2164 static int get_std_framerate(int i){
2165 if(i<60*12) return i*1001;
2166 else return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
2170 * Is the time base unreliable.
2171 * This is a heuristic to balance between quick acceptance of the values in
2172 * the headers vs. some extra checks.
2173 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2174 * MPEG-2 commonly misuses field repeat flags to store different framerates.
2175 * And there are "variable" fps files this needs to detect as well.
2177 static int tb_unreliable(AVCodecContext *c){
2178 if( c->time_base.den >= 101L*c->time_base.num
2179 || c->time_base.den < 5L*c->time_base.num
2180 /* || c->codec_tag == AV_RL32("DIVX")
2181 || c->codec_tag == AV_RL32("XVID")*/
2182 || c->codec_id == CODEC_ID_MPEG2VIDEO
2183 || c->codec_id == CODEC_ID_H264
2189 int av_find_stream_info(AVFormatContext *ic)
2191 int i, count, ret, read_size, j;
2193 AVPacket pkt1, *pkt;
2194 int64_t old_offset = url_ftell(ic->pb);
2196 for(i=0;i<ic->nb_streams;i++) {
2198 st = ic->streams[i];
2199 if (st->codec->codec_id == CODEC_ID_AAC) {
2200 st->codec->sample_rate = 0;
2201 st->codec->frame_size = 0;
2202 st->codec->channels = 0;
2204 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2205 st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2206 /* if(!st->time_base.num)
2208 if(!st->codec->time_base.num)
2209 st->codec->time_base= st->time_base;
2211 //only for the split stuff
2212 if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
2213 st->parser = av_parser_init(st->codec->codec_id);
2214 if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
2215 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2218 assert(!st->codec->codec);
2219 codec = avcodec_find_decoder(st->codec->codec_id);
2221 /* Force decoding of at least one frame of codec data
2222 * this makes sure the codec initializes the channel configuration
2223 * and does not trust the values from the container.
2225 if (codec && codec->capabilities & CODEC_CAP_CHANNEL_CONF)
2226 st->codec->channels = 0;
2228 /* Ensure that subtitle_header is properly set. */
2229 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
2230 && codec && !st->codec->codec)
2231 avcodec_open(st->codec, codec);
2233 //try to just open decoders, in case this is enough to get parameters
2234 if(!has_codec_parameters(st->codec)){
2235 if (codec && !st->codec->codec)
2236 avcodec_open(st->codec, codec);
2240 for (i=0; i<ic->nb_streams; i++) {
2241 ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
2247 if(url_interrupt_cb()){
2248 ret= AVERROR(EINTR);
2249 av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2253 /* check if one codec still needs to be handled */
2254 for(i=0;i<ic->nb_streams;i++) {
2255 st = ic->streams[i];
2256 if (!has_codec_parameters(st->codec))
2258 /* variable fps and no guess at the real fps */
2259 if( tb_unreliable(st->codec) && !(st->r_frame_rate.num && st->avg_frame_rate.num)
2260 && st->info->duration_count<20 && st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2262 if(st->parser && st->parser->parser->split && !st->codec->extradata)
2264 if(st->first_dts == AV_NOPTS_VALUE)
2267 if (i == ic->nb_streams) {
2268 /* NOTE: if the format has no header, then we need to read
2269 some packets to get most of the streams, so we cannot
2271 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2272 /* if we found the info for all the codecs, we can stop */
2274 av_log(ic, AV_LOG_DEBUG, "All info found\n");
2278 /* we did not get all the codec info, but we read too much data */
2279 if (read_size >= ic->probesize) {
2281 av_log(ic, AV_LOG_DEBUG, "Probe buffer size limit %d reached\n", ic->probesize);
2285 /* NOTE: a new stream can be added there if no header in file
2286 (AVFMTCTX_NOHEADER) */
2287 ret = av_read_frame_internal(ic, &pkt1);
2288 if (ret < 0 && ret != AVERROR(EAGAIN)) {
2290 ret = -1; /* we could not have all the codec parameters before EOF */
2291 for(i=0;i<ic->nb_streams;i++) {
2292 st = ic->streams[i];
2293 if (!has_codec_parameters(st->codec)){
2295 avcodec_string(buf, sizeof(buf), st->codec, 0);
2296 av_log(ic, AV_LOG_WARNING, "Could not find codec parameters (%s)\n", buf);
2304 if (ret == AVERROR(EAGAIN))
2307 pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2308 if ((ret = av_dup_packet(pkt)) < 0)
2309 goto find_stream_info_err;
2311 read_size += pkt->size;
2313 st = ic->streams[pkt->stream_index];
2314 if (st->codec_info_nb_frames>1) {
2315 if (st->time_base.den > 0 && av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q) >= ic->max_analyze_duration) {
2316 av_log(ic, AV_LOG_WARNING, "max_analyze_duration reached\n");
2319 st->info->codec_info_duration += pkt->duration;
2322 int64_t last = st->info->last_dts;
2323 int64_t duration= pkt->dts - last;
2325 if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
2326 double dur= duration * av_q2d(st->time_base);
2328 // if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2329 // av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
2330 if (st->info->duration_count < 2)
2331 memset(st->info->duration_error, 0, sizeof(st->info->duration_error));
2332 for (i=1; i<FF_ARRAY_ELEMS(st->info->duration_error); i++) {
2333 int framerate= get_std_framerate(i);
2334 int ticks= lrintf(dur*framerate/(1001*12));
2335 double error= dur - ticks*1001*12/(double)framerate;
2336 st->info->duration_error[i] += error*error;
2338 st->info->duration_count++;
2339 // ignore the first 4 values, they might have some random jitter
2340 if (st->info->duration_count > 3)
2341 st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2343 if (last == AV_NOPTS_VALUE || st->info->duration_count <= 1)
2344 st->info->last_dts = pkt->dts;
2346 if(st->parser && st->parser->parser->split && !st->codec->extradata){
2347 int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2349 st->codec->extradata_size= i;
2350 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2351 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2352 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2356 /* if still no information, we try to open the codec and to
2357 decompress the frame. We try to avoid that in most cases as
2358 it takes longer and uses more memory. For MPEG-4, we need to
2359 decompress for QuickTime. */
2360 if (!has_codec_parameters(st->codec) || !has_decode_delay_been_guessed(st))
2361 try_decode_frame(st, pkt);
2363 st->codec_info_nb_frames++;
2367 // close codecs which were opened in try_decode_frame()
2368 for(i=0;i<ic->nb_streams;i++) {
2369 st = ic->streams[i];
2370 if(st->codec->codec)
2371 avcodec_close(st->codec);
2373 for(i=0;i<ic->nb_streams;i++) {
2374 st = ic->streams[i];
2375 if (st->codec_info_nb_frames>2 && !st->avg_frame_rate.num && st->info->codec_info_duration)
2376 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2377 (st->codec_info_nb_frames-2)*(int64_t)st->time_base.den,
2378 st->info->codec_info_duration*(int64_t)st->time_base.num, 60000);
2379 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2380 if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample)
2381 st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2383 // the check for tb_unreliable() is not completely correct, since this is not about handling
2384 // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2385 // ipmovie.c produces.
2386 if (tb_unreliable(st->codec) && st->info->duration_count > 15 && st->info->duration_gcd > 1 && !st->r_frame_rate.num)
2387 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, st->time_base.den, st->time_base.num * st->info->duration_gcd, INT_MAX);
2388 if (st->info->duration_count && !st->r_frame_rate.num
2389 && tb_unreliable(st->codec) /*&&
2390 //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2391 st->time_base.num*duration_sum[i]/st->info->duration_count*101LL > st->time_base.den*/){
2393 double best_error= 2*av_q2d(st->time_base);
2394 best_error = best_error*best_error*st->info->duration_count*1000*12*30;
2396 for (j=1; j<FF_ARRAY_ELEMS(st->info->duration_error); j++) {
2397 double error = st->info->duration_error[j] * get_std_framerate(j);
2398 // if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2399 // av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
2400 if(error < best_error){
2402 num = get_std_framerate(j);
2405 // do not increase frame rate by more than 1 % in order to match a standard rate.
2406 if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
2407 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2410 if (!st->r_frame_rate.num){
2411 if( st->codec->time_base.den * (int64_t)st->time_base.num
2412 <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
2413 st->r_frame_rate.num = st->codec->time_base.den;
2414 st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
2416 st->r_frame_rate.num = st->time_base.den;
2417 st->r_frame_rate.den = st->time_base.num;
2420 }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2421 if(!st->codec->bits_per_coded_sample)
2422 st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2426 av_estimate_timings(ic, old_offset);
2428 compute_chapters_end(ic);
2431 /* correct DTS for B-frame streams with no timestamps */
2432 for(i=0;i<ic->nb_streams;i++) {
2433 st = ic->streams[i];
2434 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2436 ppktl = &ic->packet_buffer;
2438 if(ppkt1->stream_index != i)
2440 if(ppkt1->pkt->dts < 0)
2442 if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2444 ppkt1->pkt->dts -= delta;
2449 st->cur_dts -= delta;
2455 find_stream_info_err:
2456 for (i=0; i < ic->nb_streams; i++)
2457 av_freep(&ic->streams[i]->info);
2461 static AVProgram *find_program_from_stream(AVFormatContext *ic, int s)
2465 for (i = 0; i < ic->nb_programs; i++)
2466 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
2467 if (ic->programs[i]->stream_index[j] == s)
2468 return ic->programs[i];
2472 int av_find_best_stream(AVFormatContext *ic,
2473 enum AVMediaType type,
2474 int wanted_stream_nb,
2476 AVCodec **decoder_ret,
2479 int i, nb_streams = ic->nb_streams, stream_number = 0;
2480 int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1;
2481 unsigned *program = NULL;
2482 AVCodec *decoder = NULL, *best_decoder = NULL;
2484 if (related_stream >= 0 && wanted_stream_nb < 0) {
2485 AVProgram *p = find_program_from_stream(ic, related_stream);
2487 program = p->stream_index;
2488 nb_streams = p->nb_stream_indexes;
2491 for (i = 0; i < nb_streams; i++) {
2492 AVStream *st = ic->streams[program ? program[i] : i];
2493 AVCodecContext *avctx = st->codec;
2494 if (avctx->codec_type != type)
2496 if (wanted_stream_nb >= 0 && stream_number++ != wanted_stream_nb)
2499 decoder = avcodec_find_decoder(ic->streams[i]->codec->codec_id);
2502 ret = AVERROR_DECODER_NOT_FOUND;
2506 if (best_count >= st->codec_info_nb_frames)
2508 best_count = st->codec_info_nb_frames;
2510 best_decoder = decoder;
2511 if (program && i == nb_streams - 1 && ret < 0) {
2513 nb_streams = ic->nb_streams;
2514 i = 0; /* no related stream found, try again with everything */
2518 *decoder_ret = best_decoder;
2522 /*******************************************************/
2524 int av_read_play(AVFormatContext *s)
2526 if (s->iformat->read_play)
2527 return s->iformat->read_play(s);
2529 return av_url_read_fpause(s->pb, 0);
2530 return AVERROR(ENOSYS);
2533 int av_read_pause(AVFormatContext *s)
2535 if (s->iformat->read_pause)
2536 return s->iformat->read_pause(s);
2538 return av_url_read_fpause(s->pb, 1);
2539 return AVERROR(ENOSYS);
2542 void av_close_input_stream(AVFormatContext *s)
2547 flush_packet_queue(s);
2548 if (s->iformat->read_close)
2549 s->iformat->read_close(s);
2550 for(i=0;i<s->nb_streams;i++) {
2551 /* free all data in a stream component */
2554 av_parser_close(st->parser);
2555 av_free_packet(&st->cur_pkt);
2557 av_metadata_free(&st->metadata);
2558 av_free(st->index_entries);
2559 av_free(st->codec->extradata);
2560 av_free(st->codec->subtitle_header);
2562 #if FF_API_OLD_METADATA
2563 av_free(st->filename);
2565 av_free(st->priv_data);
2569 for(i=s->nb_programs-1; i>=0; i--) {
2570 #if FF_API_OLD_METADATA
2571 av_freep(&s->programs[i]->provider_name);
2572 av_freep(&s->programs[i]->name);
2574 av_metadata_free(&s->programs[i]->metadata);
2575 av_freep(&s->programs[i]->stream_index);
2576 av_freep(&s->programs[i]);
2578 av_freep(&s->programs);
2579 av_freep(&s->priv_data);
2580 while(s->nb_chapters--) {
2581 #if FF_API_OLD_METADATA
2582 av_free(s->chapters[s->nb_chapters]->title);
2584 av_metadata_free(&s->chapters[s->nb_chapters]->metadata);
2585 av_free(s->chapters[s->nb_chapters]);
2587 av_freep(&s->chapters);
2588 av_metadata_free(&s->metadata);
2593 void av_close_input_file(AVFormatContext *s)
2595 ByteIOContext *pb = s->iformat->flags & AVFMT_NOFILE ? NULL : s->pb;
2596 av_close_input_stream(s);
2601 AVStream *av_new_stream(AVFormatContext *s, int id)
2606 #if FF_API_MAX_STREAMS
2607 if (s->nb_streams >= MAX_STREAMS){
2608 av_log(s, AV_LOG_ERROR, "Too many streams\n");
2614 if (s->nb_streams >= INT_MAX/sizeof(*streams))
2616 streams = av_realloc(s->streams, (s->nb_streams + 1) * sizeof(*streams));
2619 s->streams = streams;
2622 st = av_mallocz(sizeof(AVStream));
2625 if (!(st->info = av_mallocz(sizeof(*st->info)))) {
2630 st->codec= avcodec_alloc_context();
2632 /* no default bitrate if decoding */
2633 st->codec->bit_rate = 0;
2635 st->index = s->nb_streams;
2637 st->start_time = AV_NOPTS_VALUE;
2638 st->duration = AV_NOPTS_VALUE;
2639 /* we set the current DTS to 0 so that formats without any timestamps
2640 but durations get some timestamps, formats with some unknown
2641 timestamps have their first few packets buffered and the
2642 timestamps corrected before they are returned to the user */
2644 st->first_dts = AV_NOPTS_VALUE;
2645 st->probe_packets = MAX_PROBE_PACKETS;
2647 /* default pts setting is MPEG-like */
2648 av_set_pts_info(st, 33, 1, 90000);
2649 st->last_IP_pts = AV_NOPTS_VALUE;
2650 for(i=0; i<MAX_REORDER_DELAY+1; i++)
2651 st->pts_buffer[i]= AV_NOPTS_VALUE;
2652 st->reference_dts = AV_NOPTS_VALUE;
2654 st->sample_aspect_ratio = (AVRational){0,1};
2656 s->streams[s->nb_streams++] = st;
2660 AVProgram *av_new_program(AVFormatContext *ac, int id)
2662 AVProgram *program=NULL;
2666 av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2669 for(i=0; i<ac->nb_programs; i++)
2670 if(ac->programs[i]->id == id)
2671 program = ac->programs[i];
2674 program = av_mallocz(sizeof(AVProgram));
2677 dynarray_add(&ac->programs, &ac->nb_programs, program);
2678 program->discard = AVDISCARD_NONE;
2685 AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2687 AVChapter *chapter = NULL;
2690 for(i=0; i<s->nb_chapters; i++)
2691 if(s->chapters[i]->id == id)
2692 chapter = s->chapters[i];
2695 chapter= av_mallocz(sizeof(AVChapter));
2698 dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2700 #if FF_API_OLD_METADATA
2701 av_free(chapter->title);
2703 av_metadata_set2(&chapter->metadata, "title", title, 0);
2705 chapter->time_base= time_base;
2706 chapter->start = start;
2712 /************************************************************/
2713 /* output media file */
2715 int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2719 if (s->oformat->priv_data_size > 0) {
2720 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2722 return AVERROR(ENOMEM);
2723 if (s->oformat->priv_class) {
2724 *(const AVClass**)s->priv_data= s->oformat->priv_class;
2725 av_opt_set_defaults(s->priv_data);
2728 s->priv_data = NULL;
2730 if (s->oformat->set_parameters) {
2731 ret = s->oformat->set_parameters(s, ap);
2738 static int validate_codec_tag(AVFormatContext *s, AVStream *st)
2740 const AVCodecTag *avctag;
2742 enum CodecID id = CODEC_ID_NONE;
2743 unsigned int tag = 0;
2746 * Check that tag + id is in the table
2747 * If neither is in the table -> OK
2748 * If tag is in the table with another id -> FAIL
2749 * If id is in the table with another tag -> FAIL unless strict < normal
2751 for (n = 0; s->oformat->codec_tag[n]; n++) {
2752 avctag = s->oformat->codec_tag[n];
2753 while (avctag->id != CODEC_ID_NONE) {
2754 if (ff_toupper4(avctag->tag) == ff_toupper4(st->codec->codec_tag)) {
2756 if (id == st->codec->codec_id)
2759 if (avctag->id == st->codec->codec_id)
2764 if (id != CODEC_ID_NONE)
2766 if (tag && (st->codec->strict_std_compliance >= FF_COMPLIANCE_NORMAL))
2771 int av_write_header(AVFormatContext *s)
2776 // some sanity checks
2777 if (s->nb_streams == 0 && !(s->oformat->flags & AVFMT_NOSTREAMS)) {
2778 av_log(s, AV_LOG_ERROR, "no streams\n");
2779 return AVERROR(EINVAL);
2782 for(i=0;i<s->nb_streams;i++) {
2785 switch (st->codec->codec_type) {
2786 case AVMEDIA_TYPE_AUDIO:
2787 if(st->codec->sample_rate<=0){
2788 av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2789 return AVERROR(EINVAL);
2791 if(!st->codec->block_align)
2792 st->codec->block_align = st->codec->channels *
2793 av_get_bits_per_sample(st->codec->codec_id) >> 3;
2795 case AVMEDIA_TYPE_VIDEO:
2796 if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2797 av_log(s, AV_LOG_ERROR, "time base not set\n");
2798 return AVERROR(EINVAL);
2800 if((st->codec->width<=0 || st->codec->height<=0) && !(s->oformat->flags & AVFMT_NODIMENSIONS)){
2801 av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2802 return AVERROR(EINVAL);
2804 if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)){
2805 av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between encoder and muxer layer\n");
2806 return AVERROR(EINVAL);
2811 if(s->oformat->codec_tag){
2812 if(st->codec->codec_tag && st->codec->codec_id == CODEC_ID_RAWVIDEO && av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id) == 0 && !validate_codec_tag(s, st)){
2813 //the current rawvideo encoding system ends up setting the wrong codec_tag for avi, we override it here
2814 st->codec->codec_tag= 0;
2816 if(st->codec->codec_tag){
2817 if (!validate_codec_tag(s, st)) {
2819 av_get_codec_tag_string(tagbuf, sizeof(tagbuf), st->codec->codec_tag);
2820 av_log(s, AV_LOG_ERROR,
2821 "Tag %s/0x%08x incompatible with output codec id '%d'\n",
2822 tagbuf, st->codec->codec_tag, st->codec->codec_id);
2823 return AVERROR_INVALIDDATA;
2826 st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2829 if(s->oformat->flags & AVFMT_GLOBALHEADER &&
2830 !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
2831 av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
2834 if (!s->priv_data && s->oformat->priv_data_size > 0) {
2835 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2837 return AVERROR(ENOMEM);
2840 #if FF_API_OLD_METADATA
2841 ff_metadata_mux_compat(s);
2844 /* set muxer identification string */
2845 if (s->nb_streams && !(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
2846 av_metadata_set2(&s->metadata, "encoder", LIBAVFORMAT_IDENT, 0);
2849 if(s->oformat->write_header){
2850 ret = s->oformat->write_header(s);
2855 /* init PTS generation */
2856 for(i=0;i<s->nb_streams;i++) {
2857 int64_t den = AV_NOPTS_VALUE;
2860 switch (st->codec->codec_type) {
2861 case AVMEDIA_TYPE_AUDIO:
2862 den = (int64_t)st->time_base.num * st->codec->sample_rate;
2864 case AVMEDIA_TYPE_VIDEO:
2865 den = (int64_t)st->time_base.num * st->codec->time_base.den;
2870 if (den != AV_NOPTS_VALUE) {
2872 return AVERROR_INVALIDDATA;
2873 av_frac_init(&st->pts, 0, 0, den);
2879 //FIXME merge with compute_pkt_fields
2880 static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt){
2881 int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2882 int num, den, frame_size, i;
2884 // av_log(s, 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);
2886 /* if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2889 /* duration field */
2890 if (pkt->duration == 0) {
2891 compute_frame_duration(&num, &den, st, NULL, pkt);
2893 pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
2897 if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
2900 //XXX/FIXME this is a temporary hack until all encoders output pts
2901 if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2903 // pkt->pts= st->cur_dts;
2904 pkt->pts= st->pts.val;
2907 //calculate dts from pts
2908 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
2909 st->pts_buffer[0]= pkt->pts;
2910 for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2911 st->pts_buffer[i]= pkt->pts + (i-delay-1) * pkt->duration;
2912 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2913 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2915 pkt->dts= st->pts_buffer[0];
2918 if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2919 av_log(s, AV_LOG_ERROR,
2920 "Application provided invalid, non monotonically increasing dts to muxer in stream %d: %"PRId64" >= %"PRId64"\n",
2921 st->index, st->cur_dts, pkt->dts);
2924 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2925 av_log(s, AV_LOG_ERROR, "pts < dts in stream %d\n", st->index);
2929 // av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2930 st->cur_dts= pkt->dts;
2931 st->pts.val= pkt->dts;
2934 switch (st->codec->codec_type) {
2935 case AVMEDIA_TYPE_AUDIO:
2936 frame_size = get_audio_frame_size(st->codec, pkt->size);
2938 /* HACK/FIXME, we skip the initial 0 size packets as they are most
2939 likely equal to the encoder delay, but it would be better if we
2940 had the real timestamps from the encoder */
2941 if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2942 av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2945 case AVMEDIA_TYPE_VIDEO:
2946 av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2954 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2956 int ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt);
2958 if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2961 ret= s->oformat->write_packet(s, pkt);
2963 ret= url_ferror(s->pb);
2967 void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
2968 int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
2970 AVPacketList **next_point, *this_pktl;
2972 this_pktl = av_mallocz(sizeof(AVPacketList));
2973 this_pktl->pkt= *pkt;
2974 pkt->destruct= NULL; // do not free original but only the copy
2975 av_dup_packet(&this_pktl->pkt); // duplicate the packet if it uses non-alloced memory
2977 if(s->streams[pkt->stream_index]->last_in_packet_buffer){
2978 next_point = &(s->streams[pkt->stream_index]->last_in_packet_buffer->next);
2980 next_point = &s->packet_buffer;
2983 if(compare(s, &s->packet_buffer_end->pkt, pkt)){
2984 while(!compare(s, &(*next_point)->pkt, pkt)){
2985 next_point= &(*next_point)->next;
2989 next_point = &(s->packet_buffer_end->next);
2992 assert(!*next_point);
2994 s->packet_buffer_end= this_pktl;
2997 this_pktl->next= *next_point;
2999 s->streams[pkt->stream_index]->last_in_packet_buffer=
3000 *next_point= this_pktl;
3003 static int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
3005 AVStream *st = s->streams[ pkt ->stream_index];
3006 AVStream *st2= s->streams[ next->stream_index];
3007 int64_t a= st2->time_base.num * (int64_t)st ->time_base.den;
3008 int64_t b= st ->time_base.num * (int64_t)st2->time_base.den;
3009 return av_rescale_rnd(pkt->dts, b, a, AV_ROUND_DOWN) < next->dts;
3012 int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
3018 ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
3021 for(i=0; i < s->nb_streams; i++)
3022 stream_count+= !!s->streams[i]->last_in_packet_buffer;
3024 if(stream_count && (s->nb_streams == stream_count || flush)){
3025 pktl= s->packet_buffer;
3028 s->packet_buffer= pktl->next;
3029 if(!s->packet_buffer)
3030 s->packet_buffer_end= NULL;
3032 if(s->streams[out->stream_index]->last_in_packet_buffer == pktl)
3033 s->streams[out->stream_index]->last_in_packet_buffer= NULL;
3037 av_init_packet(out);
3043 * Interleave an AVPacket correctly so it can be muxed.
3044 * @param out the interleaved packet will be output here
3045 * @param in the input packet
3046 * @param flush 1 if no further packets are available as input and all
3047 * remaining packets should be output
3048 * @return 1 if a packet was output, 0 if no packet could be output,
3049 * < 0 if an error occurred
3051 static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
3052 if(s->oformat->interleave_packet)
3053 return s->oformat->interleave_packet(s, out, in, flush);
3055 return av_interleave_packet_per_dts(s, out, in, flush);
3058 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
3059 AVStream *st= s->streams[ pkt->stream_index];
3061 //FIXME/XXX/HACK drop zero sized packets
3062 if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO && pkt->size==0)
3065 //av_log(NULL, AV_LOG_DEBUG, "av_interleaved_write_frame %d %"PRId64" %"PRId64"\n", pkt->size, pkt->dts, pkt->pts);
3066 if(compute_pkt_fields2(s, st, pkt) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3069 if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3074 int ret= av_interleave_packet(s, &opkt, pkt, 0);
3075 if(ret<=0) //FIXME cleanup needed for ret<0 ?
3078 ret= s->oformat->write_packet(s, &opkt);
3080 av_free_packet(&opkt);
3085 if(url_ferror(s->pb))
3086 return url_ferror(s->pb);
3090 int av_write_trailer(AVFormatContext *s)
3096 ret= av_interleave_packet(s, &pkt, NULL, 1);
3097 if(ret<0) //FIXME cleanup needed for ret<0 ?
3102 ret= s->oformat->write_packet(s, &pkt);
3104 av_free_packet(&pkt);
3108 if(url_ferror(s->pb))
3112 if(s->oformat->write_trailer)
3113 ret = s->oformat->write_trailer(s);
3116 ret=url_ferror(s->pb);
3117 for(i=0;i<s->nb_streams;i++) {
3118 av_freep(&s->streams[i]->priv_data);
3119 av_freep(&s->streams[i]->index_entries);
3121 av_freep(&s->priv_data);
3125 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
3128 AVProgram *program=NULL;
3131 if (idx >= ac->nb_streams) {
3132 av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3136 for(i=0; i<ac->nb_programs; i++){
3137 if(ac->programs[i]->id != progid)
3139 program = ac->programs[i];
3140 for(j=0; j<program->nb_stream_indexes; j++)
3141 if(program->stream_index[j] == idx)
3144 tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
3147 program->stream_index = tmp;
3148 program->stream_index[program->nb_stream_indexes++] = idx;
3153 static void print_fps(double d, const char *postfix){
3154 uint64_t v= lrintf(d*100);
3155 if (v% 100 ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3156 else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3157 else av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
3160 static void dump_metadata(void *ctx, AVMetadata *m, const char *indent)
3162 if(m && !(m->count == 1 && av_metadata_get(m, "language", NULL, 0))){
3163 AVMetadataTag *tag=NULL;
3165 av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3166 while((tag=av_metadata_get(m, "", tag, AV_METADATA_IGNORE_SUFFIX))) {
3167 if(strcmp("language", tag->key))
3168 av_log(ctx, AV_LOG_INFO, "%s %-16s: %s\n", indent, tag->key, tag->value);
3173 /* "user interface" functions */
3174 static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
3177 int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
3178 AVStream *st = ic->streams[i];
3179 int g = av_gcd(st->time_base.num, st->time_base.den);
3180 AVMetadataTag *lang = av_metadata_get(st->metadata, "language", NULL, 0);
3181 avcodec_string(buf, sizeof(buf), st->codec, is_output);
3182 av_log(NULL, AV_LOG_INFO, " Stream #%d.%d", index, i);
3183 /* the pid is an important information, so we display it */
3184 /* XXX: add a generic system */
3185 if (flags & AVFMT_SHOW_IDS)
3186 av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
3188 av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
3189 av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames, st->time_base.num/g, st->time_base.den/g);
3190 av_log(NULL, AV_LOG_INFO, ": %s", buf);
3191 if (st->sample_aspect_ratio.num && // default
3192 av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
3193 AVRational display_aspect_ratio;
3194 av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
3195 st->codec->width*st->sample_aspect_ratio.num,
3196 st->codec->height*st->sample_aspect_ratio.den,
3198 av_log(NULL, AV_LOG_INFO, ", PAR %d:%d DAR %d:%d",
3199 st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3200 display_aspect_ratio.num, display_aspect_ratio.den);
3202 if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
3203 if(st->avg_frame_rate.den && st->avg_frame_rate.num)
3204 print_fps(av_q2d(st->avg_frame_rate), "fps");
3205 if(st->r_frame_rate.den && st->r_frame_rate.num)
3206 print_fps(av_q2d(st->r_frame_rate), "tbr");
3207 if(st->time_base.den && st->time_base.num)
3208 print_fps(1/av_q2d(st->time_base), "tbn");
3209 if(st->codec->time_base.den && st->codec->time_base.num)
3210 print_fps(1/av_q2d(st->codec->time_base), "tbc");
3212 av_log(NULL, AV_LOG_INFO, "\n");
3213 dump_metadata(NULL, st->metadata, " ");
3216 void dump_format(AVFormatContext *ic,
3222 uint8_t *printed = av_mallocz(ic->nb_streams);
3223 if (ic->nb_streams && !printed)
3226 av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3227 is_output ? "Output" : "Input",
3229 is_output ? ic->oformat->name : ic->iformat->name,
3230 is_output ? "to" : "from", url);
3231 dump_metadata(NULL, ic->metadata, " ");
3233 av_log(NULL, AV_LOG_INFO, " Duration: ");
3234 if (ic->duration != AV_NOPTS_VALUE) {
3235 int hours, mins, secs, us;
3236 secs = ic->duration / AV_TIME_BASE;
3237 us = ic->duration % AV_TIME_BASE;
3242 av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3243 (100 * us) / AV_TIME_BASE);
3245 av_log(NULL, AV_LOG_INFO, "N/A");
3247 if (ic->start_time != AV_NOPTS_VALUE) {
3249 av_log(NULL, AV_LOG_INFO, ", start: ");
3250 secs = ic->start_time / AV_TIME_BASE;
3251 us = abs(ic->start_time % AV_TIME_BASE);
3252 av_log(NULL, AV_LOG_INFO, "%d.%06d",
3253 secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
3255 av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3257 av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
3259 av_log(NULL, AV_LOG_INFO, "N/A");
3261 av_log(NULL, AV_LOG_INFO, "\n");
3263 for (i = 0; i < ic->nb_chapters; i++) {
3264 AVChapter *ch = ic->chapters[i];
3265 av_log(NULL, AV_LOG_INFO, " Chapter #%d.%d: ", index, i);
3266 av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
3267 av_log(NULL, AV_LOG_INFO, "end %f\n", ch->end * av_q2d(ch->time_base));
3269 dump_metadata(NULL, ch->metadata, " ");
3271 if(ic->nb_programs) {
3272 int j, k, total = 0;
3273 for(j=0; j<ic->nb_programs; j++) {
3274 AVMetadataTag *name = av_metadata_get(ic->programs[j]->metadata,
3276 av_log(NULL, AV_LOG_INFO, " Program %d %s\n", ic->programs[j]->id,
3277 name ? name->value : "");
3278 dump_metadata(NULL, ic->programs[j]->metadata, " ");
3279 for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3280 dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3281 printed[ic->programs[j]->stream_index[k]] = 1;
3283 total += ic->programs[j]->nb_stream_indexes;
3285 if (total < ic->nb_streams)
3286 av_log(NULL, AV_LOG_INFO, " No Program\n");
3288 for(i=0;i<ic->nb_streams;i++)
3290 dump_stream_format(ic, i, index, is_output);
3295 #if FF_API_PARSE_FRAME_PARAM
3296 #include "libavcore/parseutils.h"
3298 int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
3300 return av_parse_video_size(width_ptr, height_ptr, str);
3303 int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
3305 AVRational frame_rate;
3306 int ret = av_parse_video_rate(&frame_rate, arg);
3307 *frame_rate_num= frame_rate.num;
3308 *frame_rate_den= frame_rate.den;
3313 int64_t av_gettime(void)
3316 gettimeofday(&tv,NULL);
3317 return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
3320 uint64_t ff_ntp_time(void)
3322 return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3325 int64_t parse_date(const char *datestr, int duration)
3331 static const char * const date_fmt[] = {
3335 static const char * const time_fmt[] = {
3345 time_t now = time(0);
3347 len = strlen(datestr);
3349 lastch = datestr[len - 1];
3352 is_utc = (lastch == 'z' || lastch == 'Z');
3354 memset(&dt, 0, sizeof(dt));
3359 if (!strncasecmp(datestr, "now", len))
3360 return (int64_t) now * 1000000;
3362 /* parse the year-month-day part */
3363 for (i = 0; i < FF_ARRAY_ELEMS(date_fmt); i++) {
3364 q = small_strptime(p, date_fmt[i], &dt);
3370 /* if the year-month-day part is missing, then take the
3371 * current year-month-day time */
3376 dt = *localtime(&now);
3378 dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
3383 if (*p == 'T' || *p == 't' || *p == ' ')
3386 /* parse the hour-minute-second part */
3387 for (i = 0; i < FF_ARRAY_ELEMS(time_fmt); i++) {
3388 q = small_strptime(p, time_fmt[i], &dt);
3394 /* parse datestr as a duration */
3399 /* parse datestr as HH:MM:SS */
3400 q = small_strptime(p, time_fmt[0], &dt);
3402 /* parse datestr as S+ */
3403 dt.tm_sec = strtol(p, (char **)&q, 10);
3405 /* the parsing didn't succeed */
3412 /* Now we have all the fields that we can get */
3418 t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
3420 dt.tm_isdst = -1; /* unknown */
3430 /* parse the .m... part */
3434 for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
3437 val += n * (*q - '0');
3441 return negative ? -t : t;
3444 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
3454 while (*p != '\0' && *p != '=' && *p != '&') {
3455 if ((q - tag) < sizeof(tag) - 1)
3463 while (*p != '&' && *p != '\0') {
3464 if ((q - arg) < arg_size - 1) {
3474 if (!strcmp(tag, tag1))
3483 int av_get_frame_filename(char *buf, int buf_size,
3484 const char *path, int number)
3487 char *q, buf1[20], c;
3488 int nd, len, percentd_found;
3500 while (isdigit(*p)) {
3501 nd = nd * 10 + *p++ - '0';
3504 } while (isdigit(c));
3513 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3515 if ((q - buf + len) > buf_size - 1)
3517 memcpy(q, buf1, len);
3525 if ((q - buf) < buf_size - 1)
3529 if (!percentd_found)
3538 static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3542 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3544 for(i=0;i<size;i+=16) {
3551 PRINT(" %02x", buf[i+j]);
3556 for(j=0;j<len;j++) {
3558 if (c < ' ' || c > '~')
3567 void av_hex_dump(FILE *f, uint8_t *buf, int size)
3569 hex_dump_internal(NULL, f, 0, buf, size);
3572 void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3574 hex_dump_internal(avcl, NULL, level, buf, size);
3577 //FIXME needs to know the time_base
3578 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload)
3581 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3582 PRINT("stream #%d:\n", pkt->stream_index);
3583 PRINT(" keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
3584 PRINT(" duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
3585 /* DTS is _always_ valid after av_read_frame() */
3587 if (pkt->dts == AV_NOPTS_VALUE)
3590 PRINT("%0.3f", (double)pkt->dts / AV_TIME_BASE);
3591 /* PTS may not be known if B-frames are present. */
3593 if (pkt->pts == AV_NOPTS_VALUE)
3596 PRINT("%0.3f", (double)pkt->pts / AV_TIME_BASE);
3598 PRINT(" size=%d\n", pkt->size);
3601 av_hex_dump(f, pkt->data, pkt->size);
3604 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3606 pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
3609 void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3611 pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
3614 #if FF_API_URL_SPLIT
3615 attribute_deprecated
3616 void ff_url_split(char *proto, int proto_size,
3617 char *authorization, int authorization_size,
3618 char *hostname, int hostname_size,
3620 char *path, int path_size,
3623 av_url_split(proto, proto_size,
3624 authorization, authorization_size,
3625 hostname, hostname_size,
3632 void av_url_split(char *proto, int proto_size,
3633 char *authorization, int authorization_size,
3634 char *hostname, int hostname_size,
3636 char *path, int path_size,
3639 const char *p, *ls, *at, *col, *brk;
3641 if (port_ptr) *port_ptr = -1;
3642 if (proto_size > 0) proto[0] = 0;
3643 if (authorization_size > 0) authorization[0] = 0;
3644 if (hostname_size > 0) hostname[0] = 0;
3645 if (path_size > 0) path[0] = 0;
3647 /* parse protocol */
3648 if ((p = strchr(url, ':'))) {
3649 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3654 /* no protocol means plain filename */
3655 av_strlcpy(path, url, path_size);
3659 /* separate path from hostname */
3660 ls = strchr(p, '/');
3662 ls = strchr(p, '?');
3664 av_strlcpy(path, ls, path_size);
3666 ls = &p[strlen(p)]; // XXX
3668 /* the rest is hostname, use that to parse auth/port */
3670 /* authorization (user[:pass]@hostname) */
3671 if ((at = strchr(p, '@')) && at < ls) {
3672 av_strlcpy(authorization, p,
3673 FFMIN(authorization_size, at + 1 - p));
3674 p = at + 1; /* skip '@' */
3677 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3679 av_strlcpy(hostname, p + 1,
3680 FFMIN(hostname_size, brk - p));
3681 if (brk[1] == ':' && port_ptr)
3682 *port_ptr = atoi(brk + 2);
3683 } else if ((col = strchr(p, ':')) && col < ls) {
3684 av_strlcpy(hostname, p,
3685 FFMIN(col + 1 - p, hostname_size));
3686 if (port_ptr) *port_ptr = atoi(col + 1);
3688 av_strlcpy(hostname, p,
3689 FFMIN(ls + 1 - p, hostname_size));
3693 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3696 static const char hex_table_uc[16] = { '0', '1', '2', '3',
3699 'C', 'D', 'E', 'F' };
3700 static const char hex_table_lc[16] = { '0', '1', '2', '3',
3703 'c', 'd', 'e', 'f' };
3704 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3706 for(i = 0; i < s; i++) {
3707 buff[i * 2] = hex_table[src[i] >> 4];
3708 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3714 int ff_hex_to_data(uint8_t *data, const char *p)
3721 p += strspn(p, SPACE_CHARS);
3724 c = toupper((unsigned char) *p++);
3725 if (c >= '0' && c <= '9')
3727 else if (c >= 'A' && c <= 'F')
3742 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3743 unsigned int pts_num, unsigned int pts_den)
3745 s->pts_wrap_bits = pts_wrap_bits;
3747 if(av_reduce(&s->time_base.num, &s->time_base.den, pts_num, pts_den, INT_MAX)){
3748 if(s->time_base.num != pts_num)
3749 av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/s->time_base.num);
3751 av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3753 if(!s->time_base.num || !s->time_base.den)
3754 s->time_base.num= s->time_base.den= 0;
3757 int ff_url_join(char *str, int size, const char *proto,
3758 const char *authorization, const char *hostname,
3759 int port, const char *fmt, ...)
3762 struct addrinfo hints, *ai;
3767 av_strlcatf(str, size, "%s://", proto);
3768 if (authorization && authorization[0])
3769 av_strlcatf(str, size, "%s@", authorization);
3770 #if CONFIG_NETWORK && defined(AF_INET6)
3771 /* Determine if hostname is a numerical IPv6 address,
3772 * properly escape it within [] in that case. */
3773 memset(&hints, 0, sizeof(hints));
3774 hints.ai_flags = AI_NUMERICHOST;
3775 if (!getaddrinfo(hostname, NULL, &hints, &ai)) {
3776 if (ai->ai_family == AF_INET6) {
3777 av_strlcat(str, "[", size);
3778 av_strlcat(str, hostname, size);
3779 av_strlcat(str, "]", size);
3781 av_strlcat(str, hostname, size);
3786 /* Not an IPv6 address, just output the plain string. */
3787 av_strlcat(str, hostname, size);
3790 av_strlcatf(str, size, ":%d", port);
3793 int len = strlen(str);
3796 vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);
3802 int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
3803 AVFormatContext *src)
3808 local_pkt.stream_index = dst_stream;
3809 if (pkt->pts != AV_NOPTS_VALUE)
3810 local_pkt.pts = av_rescale_q(pkt->pts,
3811 src->streams[pkt->stream_index]->time_base,
3812 dst->streams[dst_stream]->time_base);
3813 if (pkt->dts != AV_NOPTS_VALUE)
3814 local_pkt.dts = av_rescale_q(pkt->dts,
3815 src->streams[pkt->stream_index]->time_base,
3816 dst->streams[dst_stream]->time_base);
3817 return av_write_frame(dst, &local_pkt);
3820 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
3823 const char *ptr = str;
3825 /* Parse key=value pairs. */
3828 char *dest = NULL, *dest_end;
3829 int key_len, dest_len = 0;
3831 /* Skip whitespace and potential commas. */
3832 while (*ptr && (isspace(*ptr) || *ptr == ','))
3839 if (!(ptr = strchr(key, '=')))
3842 key_len = ptr - key;
3844 callback_get_buf(context, key, key_len, &dest, &dest_len);
3845 dest_end = dest + dest_len - 1;
3849 while (*ptr && *ptr != '\"') {
3853 if (dest && dest < dest_end)
3857 if (dest && dest < dest_end)
3865 for (; *ptr && !(isspace(*ptr) || *ptr == ','); ptr++)
3866 if (dest && dest < dest_end)
3874 int ff_find_stream_index(AVFormatContext *s, int id)
3877 for (i = 0; i < s->nb_streams; i++) {
3878 if (s->streams[i]->id == id)