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
25 #include "avio_internal.h"
27 #include "libavcodec/internal.h"
28 #include "libavcodec/raw.h"
29 #include "libavutil/opt.h"
32 #include "libavutil/avstring.h"
34 #include "audiointerleave.h"
49 * various utility functions for use within FFmpeg
52 unsigned avformat_version(void)
54 return LIBAVFORMAT_VERSION_INT;
57 const char *avformat_configuration(void)
59 return FFMPEG_CONFIGURATION;
62 const char *avformat_license(void)
64 #define LICENSE_PREFIX "libavformat license: "
65 return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;
68 /* fraction handling */
71 * f = val + (num / den) + 0.5.
73 * 'num' is normalized so that it is such as 0 <= num < den.
75 * @param f fractional number
76 * @param val integer value
77 * @param num must be >= 0
78 * @param den must be >= 1
80 static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
93 * Fractional addition to f: f = f + (incr / f->den).
95 * @param f fractional number
96 * @param incr increment, can be positive or negative
98 static void av_frac_add(AVFrac *f, int64_t incr)
111 } else if (num >= den) {
118 /** head of registered input format linked list */
119 static AVInputFormat *first_iformat = NULL;
120 /** head of registered output format linked list */
121 static 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 AVOutputFormat *av_guess_format(const char *short_name, const char *filename,
199 const char *mime_type)
201 AVOutputFormat *fmt = NULL, *fmt_found;
202 int score_max, score;
204 /* specific test for image sequences */
205 #if CONFIG_IMAGE2_MUXER
206 if (!short_name && filename &&
207 av_filename_number_test(filename) &&
208 ff_guess_image2_codec(filename) != CODEC_ID_NONE) {
209 return av_guess_format("image2", NULL, NULL);
212 /* Find the proper file type. */
215 while ((fmt = av_oformat_next(fmt))) {
217 if (fmt->name && short_name && !strcmp(fmt->name, short_name))
219 if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
221 if (filename && fmt->extensions &&
222 av_match_ext(filename, fmt->extensions)) {
225 if (score > score_max) {
233 enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
234 const char *filename, const char *mime_type, enum AVMediaType type){
235 if(type == AVMEDIA_TYPE_VIDEO){
236 enum CodecID codec_id= CODEC_ID_NONE;
238 #if CONFIG_IMAGE2_MUXER
239 if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
240 codec_id= ff_guess_image2_codec(filename);
243 if(codec_id == CODEC_ID_NONE)
244 codec_id= fmt->video_codec;
246 }else if(type == AVMEDIA_TYPE_AUDIO)
247 return fmt->audio_codec;
248 else if (type == AVMEDIA_TYPE_SUBTITLE)
249 return fmt->subtitle_codec;
251 return CODEC_ID_NONE;
254 AVInputFormat *av_find_input_format(const char *short_name)
256 AVInputFormat *fmt = NULL;
257 while ((fmt = av_iformat_next(fmt))) {
258 if (match_format(short_name, fmt->name))
265 int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
267 int ret= av_new_packet(pkt, size);
272 pkt->pos= avio_tell(s);
274 ret= avio_read(s, pkt->data, size);
278 av_shrink_packet(pkt, ret);
283 int av_append_packet(AVIOContext *s, AVPacket *pkt, int size)
288 return av_get_packet(s, pkt, size);
289 old_size = pkt->size;
290 ret = av_grow_packet(pkt, size);
293 ret = avio_read(s, pkt->data + old_size, size);
294 av_shrink_packet(pkt, old_size + FFMAX(ret, 0));
299 int av_filename_number_test(const char *filename)
302 return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
305 AVInputFormat *av_probe_input_format3(AVProbeData *pd, int is_opened, int *score_ret)
307 AVProbeData lpd = *pd;
308 AVInputFormat *fmt1 = NULL, *fmt;
309 int score, score_max=0;
311 if (lpd.buf_size > 10 && ff_id3v2_match(lpd.buf, ID3v2_DEFAULT_MAGIC)) {
312 int id3len = ff_id3v2_tag_len(lpd.buf);
313 if (lpd.buf_size > id3len + 16) {
315 lpd.buf_size -= id3len;
320 while ((fmt1 = av_iformat_next(fmt1))) {
321 if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
324 if (fmt1->read_probe) {
325 score = fmt1->read_probe(&lpd);
326 if(!score && fmt1->extensions && av_match_ext(lpd.filename, fmt1->extensions))
328 } else if (fmt1->extensions) {
329 if (av_match_ext(lpd.filename, fmt1->extensions)) {
333 if (score > score_max) {
336 }else if (score == score_max)
339 *score_ret= score_max;
343 AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
346 AVInputFormat *fmt= av_probe_input_format3(pd, is_opened, &score_ret);
347 if(score_ret > *score_max){
348 *score_max= score_ret;
354 AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
356 return av_probe_input_format2(pd, is_opened, &score);
359 static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st, AVProbeData *pd)
361 static const struct {
362 const char *name; enum CodecID id; enum AVMediaType type;
364 { "aac" , CODEC_ID_AAC , AVMEDIA_TYPE_AUDIO },
365 { "ac3" , CODEC_ID_AC3 , AVMEDIA_TYPE_AUDIO },
366 { "dts" , CODEC_ID_DTS , AVMEDIA_TYPE_AUDIO },
367 { "eac3" , CODEC_ID_EAC3 , AVMEDIA_TYPE_AUDIO },
368 { "h264" , CODEC_ID_H264 , AVMEDIA_TYPE_VIDEO },
369 { "m4v" , CODEC_ID_MPEG4 , AVMEDIA_TYPE_VIDEO },
370 { "mp3" , CODEC_ID_MP3 , AVMEDIA_TYPE_AUDIO },
371 { "mpegvideo", CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
375 AVInputFormat *fmt = av_probe_input_format3(pd, 1, &score);
379 av_log(s, AV_LOG_DEBUG, "Probe with size=%d, packets=%d detected %s with score=%d\n",
380 pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets, fmt->name, score);
381 for (i = 0; fmt_id_type[i].name; i++) {
382 if (!strcmp(fmt->name, fmt_id_type[i].name)) {
383 st->codec->codec_id = fmt_id_type[i].id;
384 st->codec->codec_type = fmt_id_type[i].type;
392 /************************************************************/
393 /* input media file */
396 * Open a media file from an IO stream. 'fmt' must be specified.
398 int av_open_input_stream(AVFormatContext **ic_ptr,
399 AVIOContext *pb, const char *filename,
400 AVInputFormat *fmt, AVFormatParameters *ap)
404 AVFormatParameters default_ap;
408 memset(ap, 0, sizeof(default_ap));
411 if(!ap->prealloced_context)
412 ic = avformat_alloc_context();
416 err = AVERROR(ENOMEM);
421 ic->duration = AV_NOPTS_VALUE;
422 ic->start_time = AV_NOPTS_VALUE;
423 av_strlcpy(ic->filename, filename, sizeof(ic->filename));
425 /* allocate private data */
426 if (fmt->priv_data_size > 0) {
427 ic->priv_data = av_mallocz(fmt->priv_data_size);
428 if (!ic->priv_data) {
429 err = AVERROR(ENOMEM);
432 if (fmt->priv_class) {
433 *(const AVClass**)ic->priv_data= fmt->priv_class;
434 av_opt_set_defaults(ic->priv_data);
437 ic->priv_data = NULL;
440 // e.g. AVFMT_NOFILE formats will not have a AVIOContext
442 ff_id3v2_read(ic, ID3v2_DEFAULT_MAGIC);
444 if (!(ic->flags&AVFMT_FLAG_PRIV_OPT) && ic->iformat->read_header) {
445 err = ic->iformat->read_header(ic, ap);
450 if (!(ic->flags&AVFMT_FLAG_PRIV_OPT) && pb && !ic->data_offset)
451 ic->data_offset = avio_tell(ic->pb);
453 ic->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
460 av_freep(&ic->priv_data);
461 for(i=0;i<ic->nb_streams;i++) {
462 AVStream *st = ic->streams[i];
464 av_free(st->priv_data);
465 av_free(st->codec->extradata);
477 int av_demuxer_open(AVFormatContext *ic, AVFormatParameters *ap){
480 if (ic->iformat->read_header) {
481 err = ic->iformat->read_header(ic, ap);
486 if (ic->pb && !ic->data_offset)
487 ic->data_offset = avio_tell(ic->pb);
493 /** size of probe buffer, for guessing file type from file contents */
494 #define PROBE_BUF_MIN 2048
495 #define PROBE_BUF_MAX (1<<20)
497 int av_probe_input_buffer(AVIOContext *pb, AVInputFormat **fmt,
498 const char *filename, void *logctx,
499 unsigned int offset, unsigned int max_probe_size)
501 AVProbeData pd = { filename ? filename : "", NULL, -offset };
502 unsigned char *buf = NULL;
503 int ret = 0, probe_size;
505 if (!max_probe_size) {
506 max_probe_size = PROBE_BUF_MAX;
507 } else if (max_probe_size > PROBE_BUF_MAX) {
508 max_probe_size = PROBE_BUF_MAX;
509 } else if (max_probe_size < PROBE_BUF_MIN) {
510 return AVERROR(EINVAL);
513 if (offset >= max_probe_size) {
514 return AVERROR(EINVAL);
517 for(probe_size= PROBE_BUF_MIN; probe_size<=max_probe_size && !*fmt && ret >= 0;
518 probe_size = FFMIN(probe_size<<1, FFMAX(max_probe_size, probe_size+1))) {
519 int ret, score = probe_size < max_probe_size ? AVPROBE_SCORE_MAX/4 : 0;
520 int buf_offset = (probe_size == PROBE_BUF_MIN) ? 0 : probe_size>>1;
522 if (probe_size < offset) {
526 /* read probe data */
527 buf = av_realloc(buf, probe_size + AVPROBE_PADDING_SIZE);
528 if ((ret = avio_read(pb, buf + buf_offset, probe_size - buf_offset)) < 0) {
529 /* fail if error was not end of file, otherwise, lower score */
530 if (ret != AVERROR_EOF) {
535 ret = 0; /* error was end of file, nothing read */
538 pd.buf = &buf[offset];
540 memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE);
542 /* guess file format */
543 *fmt = av_probe_input_format2(&pd, 1, &score);
545 if(score <= AVPROBE_SCORE_MAX/4){ //this can only be true in the last iteration
546 av_log(logctx, AV_LOG_WARNING, "Format %s detected only with low score of %d, misdetection possible!\n", (*fmt)->name, score);
548 av_log(logctx, AV_LOG_DEBUG, "Format %s probed with size=%d and score=%d\n", (*fmt)->name, probe_size, score);
554 return AVERROR_INVALIDDATA;
557 /* rewind. reuse probe buffer to avoid seeking */
558 if ((ret = ffio_rewind_with_probe_data(pb, buf, pd.buf_size)) < 0)
564 int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
567 AVFormatParameters *ap)
570 AVProbeData probe_data, *pd = &probe_data;
571 AVIOContext *pb = NULL;
572 void *logctx= ap && ap->prealloced_context ? *ic_ptr : NULL;
576 pd->filename = filename;
581 /* guess format if no file can be opened */
582 fmt = av_probe_input_format(pd, 0);
585 /* Do not open file if the format does not need it. XXX: specific
586 hack needed to handle RTSP/TCP */
587 if (!fmt || !(fmt->flags & AVFMT_NOFILE)) {
588 /* if no file needed do not try to open one */
589 if ((err=avio_open(&pb, filename, AVIO_FLAG_READ)) < 0) {
593 ffio_set_buf_size(pb, buf_size);
595 if (!fmt && (err = av_probe_input_buffer(pb, &fmt, filename, logctx, 0, logctx ? (*ic_ptr)->probesize : 0)) < 0) {
600 /* if still no format found, error */
602 err = AVERROR_INVALIDDATA;
606 /* check filename in case an image number is expected */
607 if (fmt->flags & AVFMT_NEEDNUMBER) {
608 if (!av_filename_number_test(filename)) {
609 err = AVERROR(EINVAL);
613 err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
621 if (ap && ap->prealloced_context)
628 /*******************************************************/
630 static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
631 AVPacketList **plast_pktl){
632 AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
637 (*plast_pktl)->next = pktl;
639 *packet_buffer = pktl;
641 /* add the packet in the buffered packet list */
647 int av_read_packet(AVFormatContext *s, AVPacket *pkt)
653 AVPacketList *pktl = s->raw_packet_buffer;
657 if(s->streams[pkt->stream_index]->request_probe <= 0){
658 s->raw_packet_buffer = pktl->next;
659 s->raw_packet_buffer_remaining_size += pkt->size;
666 ret= s->iformat->read_packet(s, pkt);
668 if (!pktl || ret == AVERROR(EAGAIN))
670 for (i = 0; i < s->nb_streams; i++)
671 if(s->streams[i]->request_probe > 0)
672 s->streams[i]->request_probe = -1;
675 st= s->streams[pkt->stream_index];
677 switch(st->codec->codec_type){
678 case AVMEDIA_TYPE_VIDEO:
679 if(s->video_codec_id) st->codec->codec_id= s->video_codec_id;
681 case AVMEDIA_TYPE_AUDIO:
682 if(s->audio_codec_id) st->codec->codec_id= s->audio_codec_id;
684 case AVMEDIA_TYPE_SUBTITLE:
685 if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
689 if(!pktl && st->request_probe <= 0)
692 add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
693 s->raw_packet_buffer_remaining_size -= pkt->size;
695 if(st->request_probe>0){
696 AVProbeData *pd = &st->probe_data;
698 av_log(s, AV_LOG_DEBUG, "probing stream %d pp:%d\n", st->index, st->probe_packets);
701 pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
702 memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
703 pd->buf_size += pkt->size;
704 memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
706 end= s->raw_packet_buffer_remaining_size <= 0
707 || st->probe_packets<=0;
709 if(end || av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)){
710 int score= set_codec_from_probe_data(s, st, pd);
711 if( (st->codec->codec_id != CODEC_ID_NONE && score > AVPROBE_SCORE_MAX/4)
715 st->request_probe= -1;
716 if(st->codec->codec_id != CODEC_ID_NONE){
717 av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
719 av_log(s, AV_LOG_WARNING, "probed stream %d failed\n", st->index);
726 /**********************************************************/
729 * Get the number of samples of an audio frame. Return -1 on error.
731 static int get_audio_frame_size(AVCodecContext *enc, int size)
735 if(enc->codec_id == CODEC_ID_VORBIS)
738 if (enc->frame_size <= 1) {
739 int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
741 if (bits_per_sample) {
742 if (enc->channels == 0)
744 frame_size = (size << 3) / (bits_per_sample * enc->channels);
746 /* used for example by ADPCM codecs */
747 if (enc->bit_rate == 0)
749 frame_size = ((int64_t)size * 8 * enc->sample_rate) / enc->bit_rate;
752 frame_size = enc->frame_size;
759 * Return the frame duration in seconds. Return 0 if not available.
761 static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
762 AVCodecParserContext *pc, AVPacket *pkt)
768 switch(st->codec->codec_type) {
769 case AVMEDIA_TYPE_VIDEO:
770 if(st->time_base.num*1000LL > st->time_base.den){
771 *pnum = st->time_base.num;
772 *pden = st->time_base.den;
773 }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
774 *pnum = st->codec->time_base.num;
775 *pden = st->codec->time_base.den;
776 if (pc && pc->repeat_pict) {
777 *pnum = (*pnum) * (1 + pc->repeat_pict);
779 //If this codec can be interlaced or progressive then we need a parser to compute duration of a packet
780 //Thus if we have no parser in such case leave duration undefined.
781 if(st->codec->ticks_per_frame>1 && !pc){
786 case AVMEDIA_TYPE_AUDIO:
787 frame_size = get_audio_frame_size(st->codec, pkt->size);
788 if (frame_size <= 0 || st->codec->sample_rate <= 0)
791 *pden = st->codec->sample_rate;
798 static int is_intra_only(AVCodecContext *enc){
799 if(enc->codec_type == AVMEDIA_TYPE_AUDIO){
801 }else if(enc->codec_type == AVMEDIA_TYPE_VIDEO){
802 switch(enc->codec_id){
804 case CODEC_ID_MJPEGB:
806 case CODEC_ID_RAWVIDEO:
807 case CODEC_ID_DVVIDEO:
808 case CODEC_ID_HUFFYUV:
809 case CODEC_ID_FFVHUFF:
814 case CODEC_ID_JPEG2000:
822 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
823 int64_t dts, int64_t pts)
825 AVStream *st= s->streams[stream_index];
826 AVPacketList *pktl= s->packet_buffer;
828 if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE)
831 st->first_dts= dts - st->cur_dts;
834 for(; pktl; pktl= pktl->next){
835 if(pktl->pkt.stream_index != stream_index)
837 //FIXME think more about this check
838 if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
839 pktl->pkt.pts += st->first_dts;
841 if(pktl->pkt.dts != AV_NOPTS_VALUE)
842 pktl->pkt.dts += st->first_dts;
844 if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
845 st->start_time= pktl->pkt.pts;
847 if (st->start_time == AV_NOPTS_VALUE)
848 st->start_time = pts;
851 static void update_initial_durations(AVFormatContext *s, AVStream *st, AVPacket *pkt)
853 AVPacketList *pktl= s->packet_buffer;
856 if(st->first_dts != AV_NOPTS_VALUE){
857 cur_dts= st->first_dts;
858 for(; pktl; pktl= pktl->next){
859 if(pktl->pkt.stream_index == pkt->stream_index){
860 if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
862 cur_dts -= pkt->duration;
865 pktl= s->packet_buffer;
866 st->first_dts = cur_dts;
867 }else if(st->cur_dts)
870 for(; pktl; pktl= pktl->next){
871 if(pktl->pkt.stream_index != pkt->stream_index)
873 if(pktl->pkt.pts == pktl->pkt.dts && pktl->pkt.dts == AV_NOPTS_VALUE
874 && !pktl->pkt.duration){
875 pktl->pkt.dts= cur_dts;
876 if(!st->codec->has_b_frames)
877 pktl->pkt.pts= cur_dts;
878 cur_dts += pkt->duration;
879 pktl->pkt.duration= pkt->duration;
883 if(st->first_dts == AV_NOPTS_VALUE)
884 st->cur_dts= cur_dts;
887 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
888 AVCodecParserContext *pc, AVPacket *pkt)
890 int num, den, presentation_delayed, delay, i;
893 if (s->flags & AVFMT_FLAG_NOFILLIN)
896 if((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
897 pkt->dts= AV_NOPTS_VALUE;
899 if (st->codec->codec_id != CODEC_ID_H264 && pc && pc->pict_type == AV_PICTURE_TYPE_B)
900 //FIXME Set low_delay = 0 when has_b_frames = 1
901 st->codec->has_b_frames = 1;
903 /* do we have a video B-frame ? */
904 delay= st->codec->has_b_frames;
905 presentation_delayed = 0;
907 // ignore delay caused by frame threading so that the mpeg2-without-dts
908 // warning will not trigger
909 if (delay && st->codec->active_thread_type&FF_THREAD_FRAME)
910 delay -= st->codec->thread_count-1;
912 /* XXX: need has_b_frame, but cannot get it if the codec is
915 pc && pc->pict_type != AV_PICTURE_TYPE_B)
916 presentation_delayed = 1;
918 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
919 /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
920 pkt->dts -= 1LL<<st->pts_wrap_bits;
923 // some mpeg2 in mpeg-ps lack dts (issue171 / input_file.mpg)
924 // we take the conservative approach and discard both
925 // Note, if this is misbehaving for a H.264 file then possibly presentation_delayed is not set correctly.
926 if(delay==1 && pkt->dts == pkt->pts && pkt->dts != AV_NOPTS_VALUE && presentation_delayed){
927 av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination\n");
928 pkt->dts= pkt->pts= AV_NOPTS_VALUE;
931 if (pkt->duration == 0) {
932 compute_frame_duration(&num, &den, st, pc, pkt);
934 pkt->duration = av_rescale_rnd(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num, AV_ROUND_DOWN);
936 if(pkt->duration != 0 && s->packet_buffer)
937 update_initial_durations(s, st, pkt);
941 /* correct timestamps with byte offset if demuxers only have timestamps
942 on packet boundaries */
943 if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
944 /* this will estimate bitrate based on this frame's duration and size */
945 offset = av_rescale(pc->offset, pkt->duration, pkt->size);
946 if(pkt->pts != AV_NOPTS_VALUE)
948 if(pkt->dts != AV_NOPTS_VALUE)
952 if (pc && pc->dts_sync_point >= 0) {
953 // we have synchronization info from the parser
954 int64_t den = st->codec->time_base.den * (int64_t) st->time_base.num;
956 int64_t num = st->codec->time_base.num * (int64_t) st->time_base.den;
957 if (pkt->dts != AV_NOPTS_VALUE) {
958 // got DTS from the stream, update reference timestamp
959 st->reference_dts = pkt->dts - pc->dts_ref_dts_delta * num / den;
960 pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
961 } else if (st->reference_dts != AV_NOPTS_VALUE) {
962 // compute DTS based on reference timestamp
963 pkt->dts = st->reference_dts + pc->dts_ref_dts_delta * num / den;
964 pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
966 if (pc->dts_sync_point > 0)
967 st->reference_dts = pkt->dts; // new reference
971 /* This may be redundant, but it should not hurt. */
972 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
973 presentation_delayed = 1;
975 // 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);
976 /* interpolate PTS and DTS if they are not present */
977 //We skip H264 currently because delay and has_b_frames are not reliably set
978 if((delay==0 || (delay==1 && pc)) && st->codec->codec_id != CODEC_ID_H264){
979 if (presentation_delayed) {
980 /* DTS = decompression timestamp */
981 /* PTS = presentation timestamp */
982 if (pkt->dts == AV_NOPTS_VALUE)
983 pkt->dts = st->last_IP_pts;
984 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
985 if (pkt->dts == AV_NOPTS_VALUE)
986 pkt->dts = st->cur_dts;
988 /* this is tricky: the dts must be incremented by the duration
989 of the frame we are displaying, i.e. the last I- or P-frame */
990 if (st->last_IP_duration == 0)
991 st->last_IP_duration = pkt->duration;
992 if(pkt->dts != AV_NOPTS_VALUE)
993 st->cur_dts = pkt->dts + st->last_IP_duration;
994 st->last_IP_duration = pkt->duration;
995 st->last_IP_pts= pkt->pts;
996 /* cannot compute PTS if not present (we can compute it only
997 by knowing the future */
998 } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
999 if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
1000 int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
1001 int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
1002 if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
1003 pkt->pts += pkt->duration;
1004 // 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);
1008 /* presentation is not delayed : PTS and DTS are the same */
1009 if(pkt->pts == AV_NOPTS_VALUE)
1010 pkt->pts = pkt->dts;
1011 update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
1012 if(pkt->pts == AV_NOPTS_VALUE)
1013 pkt->pts = st->cur_dts;
1014 pkt->dts = pkt->pts;
1015 if(pkt->pts != AV_NOPTS_VALUE)
1016 st->cur_dts = pkt->pts + pkt->duration;
1020 if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
1021 st->pts_buffer[0]= pkt->pts;
1022 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
1023 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
1024 if(pkt->dts == AV_NOPTS_VALUE)
1025 pkt->dts= st->pts_buffer[0];
1026 if(st->codec->codec_id == CODEC_ID_H264){ //we skiped it above so we try here
1027 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
1029 if(pkt->dts > st->cur_dts)
1030 st->cur_dts = pkt->dts;
1033 // 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);
1036 if(is_intra_only(st->codec))
1037 pkt->flags |= AV_PKT_FLAG_KEY;
1040 /* keyframe computation */
1041 if (pc->key_frame == 1)
1042 pkt->flags |= AV_PKT_FLAG_KEY;
1043 else if (pc->key_frame == -1 && pc->pict_type == AV_PICTURE_TYPE_I)
1044 pkt->flags |= AV_PKT_FLAG_KEY;
1047 pkt->convergence_duration = pc->convergence_duration;
1051 static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1056 av_init_packet(pkt);
1059 /* select current input stream component */
1062 if (!st->need_parsing || !st->parser) {
1063 /* no parsing needed: we just output the packet as is */
1064 /* raw data support */
1065 *pkt = st->cur_pkt; st->cur_pkt.data= NULL;
1066 compute_pkt_fields(s, st, NULL, pkt);
1068 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1069 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1070 ff_reduce_index(s, st->index);
1071 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1074 } else if (st->cur_len > 0 && st->discard < AVDISCARD_ALL) {
1075 len = av_parser_parse2(st->parser, st->codec, &pkt->data, &pkt->size,
1076 st->cur_ptr, st->cur_len,
1077 st->cur_pkt.pts, st->cur_pkt.dts,
1079 st->cur_pkt.pts = AV_NOPTS_VALUE;
1080 st->cur_pkt.dts = AV_NOPTS_VALUE;
1081 /* increment read pointer */
1085 /* return packet if any */
1089 pkt->stream_index = st->index;
1090 pkt->pts = st->parser->pts;
1091 pkt->dts = st->parser->dts;
1092 pkt->pos = st->parser->pos;
1093 if(pkt->data == st->cur_pkt.data && pkt->size == st->cur_pkt.size){
1095 pkt->destruct= st->cur_pkt.destruct;
1096 st->cur_pkt.destruct= NULL;
1097 st->cur_pkt.data = NULL;
1098 assert(st->cur_len == 0);
1100 pkt->destruct = NULL;
1102 compute_pkt_fields(s, st, st->parser, pkt);
1104 if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY){
1105 ff_reduce_index(s, st->index);
1106 av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
1107 0, 0, AVINDEX_KEYFRAME);
1114 av_free_packet(&st->cur_pkt);
1119 /* read next packet */
1120 ret = av_read_packet(s, &cur_pkt);
1122 if (ret == AVERROR(EAGAIN))
1124 /* return the last frames, if any */
1125 for(i = 0; i < s->nb_streams; i++) {
1127 if (st->parser && st->need_parsing) {
1128 av_parser_parse2(st->parser, st->codec,
1129 &pkt->data, &pkt->size,
1131 AV_NOPTS_VALUE, AV_NOPTS_VALUE,
1137 /* no more packets: really terminate parsing */
1140 st = s->streams[cur_pkt.stream_index];
1141 st->cur_pkt= cur_pkt;
1143 if(st->cur_pkt.pts != AV_NOPTS_VALUE &&
1144 st->cur_pkt.dts != AV_NOPTS_VALUE &&
1145 st->cur_pkt.pts < st->cur_pkt.dts){
1146 av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
1147 st->cur_pkt.stream_index,
1151 // av_free_packet(&st->cur_pkt);
1155 if(s->debug & FF_FDEBUG_TS)
1156 av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1157 st->cur_pkt.stream_index,
1161 st->cur_pkt.duration,
1165 st->cur_ptr = st->cur_pkt.data;
1166 st->cur_len = st->cur_pkt.size;
1167 if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1168 st->parser = av_parser_init(st->codec->codec_id);
1170 /* no parser available: just output the raw packets */
1171 st->need_parsing = AVSTREAM_PARSE_NONE;
1172 }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
1173 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1174 }else if(st->need_parsing == AVSTREAM_PARSE_FULL_ONCE){
1175 st->parser->flags |= PARSER_FLAG_ONCE;
1180 if(s->debug & FF_FDEBUG_TS)
1181 av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1192 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1196 const int genpts= s->flags & AVFMT_FLAG_GENPTS;
1199 pktl = s->packet_buffer;
1201 AVPacket *next_pkt= &pktl->pkt;
1203 if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
1204 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1205 while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
1206 if( pktl->pkt.stream_index == next_pkt->stream_index
1207 && (0 > av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)))
1208 && av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) { //not b frame
1209 next_pkt->pts= pktl->pkt.dts;
1213 pktl = s->packet_buffer;
1216 if( next_pkt->pts != AV_NOPTS_VALUE
1217 || next_pkt->dts == AV_NOPTS_VALUE
1219 /* read packet from packet buffer, if there is data */
1221 s->packet_buffer = pktl->next;
1227 int ret= av_read_frame_internal(s, pkt);
1229 if(pktl && ret != AVERROR(EAGAIN)){
1236 if(av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1237 &s->packet_buffer_end)) < 0)
1238 return AVERROR(ENOMEM);
1240 assert(!s->packet_buffer);
1241 return av_read_frame_internal(s, pkt);
1246 /* XXX: suppress the packet queue */
1247 static void flush_packet_queue(AVFormatContext *s)
1252 pktl = s->packet_buffer;
1255 s->packet_buffer = pktl->next;
1256 av_free_packet(&pktl->pkt);
1259 while(s->raw_packet_buffer){
1260 pktl = s->raw_packet_buffer;
1261 s->raw_packet_buffer = pktl->next;
1262 av_free_packet(&pktl->pkt);
1265 s->packet_buffer_end=
1266 s->raw_packet_buffer_end= NULL;
1267 s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1270 /*******************************************************/
1273 int av_find_default_stream_index(AVFormatContext *s)
1275 int first_audio_index = -1;
1279 if (s->nb_streams <= 0)
1281 for(i = 0; i < s->nb_streams; i++) {
1283 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1286 if (first_audio_index < 0 && st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1287 first_audio_index = i;
1289 return first_audio_index >= 0 ? first_audio_index : 0;
1293 * Flush the frame reader.
1295 void ff_read_frame_flush(AVFormatContext *s)
1300 flush_packet_queue(s);
1304 /* for each stream, reset read state */
1305 for(i = 0; i < s->nb_streams; i++) {
1309 av_parser_close(st->parser);
1311 av_free_packet(&st->cur_pkt);
1313 st->last_IP_pts = AV_NOPTS_VALUE;
1314 st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1315 st->reference_dts = AV_NOPTS_VALUE;
1320 st->probe_packets = MAX_PROBE_PACKETS;
1322 for(j=0; j<MAX_REORDER_DELAY+1; j++)
1323 st->pts_buffer[j]= AV_NOPTS_VALUE;
1327 void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1330 for(i = 0; i < s->nb_streams; i++) {
1331 AVStream *st = s->streams[i];
1333 st->cur_dts = av_rescale(timestamp,
1334 st->time_base.den * (int64_t)ref_st->time_base.num,
1335 st->time_base.num * (int64_t)ref_st->time_base.den);
1339 void ff_reduce_index(AVFormatContext *s, int stream_index)
1341 AVStream *st= s->streams[stream_index];
1342 unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1344 if((unsigned)st->nb_index_entries >= max_entries){
1346 for(i=0; 2*i<st->nb_index_entries; i++)
1347 st->index_entries[i]= st->index_entries[2*i];
1348 st->nb_index_entries= i;
1352 int ff_add_index_entry(AVIndexEntry **index_entries,
1353 int *nb_index_entries,
1354 unsigned int *index_entries_allocated_size,
1355 int64_t pos, int64_t timestamp, int size, int distance, int flags)
1357 AVIndexEntry *entries, *ie;
1360 if((unsigned)*nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1363 entries = av_fast_realloc(*index_entries,
1364 index_entries_allocated_size,
1365 (*nb_index_entries + 1) *
1366 sizeof(AVIndexEntry));
1370 *index_entries= entries;
1372 index= ff_index_search_timestamp(*index_entries, *nb_index_entries, timestamp, AVSEEK_FLAG_ANY);
1375 index= (*nb_index_entries)++;
1376 ie= &entries[index];
1377 assert(index==0 || ie[-1].timestamp < timestamp);
1379 ie= &entries[index];
1380 if(ie->timestamp != timestamp){
1381 if(ie->timestamp <= timestamp)
1383 memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(*nb_index_entries - index));
1384 (*nb_index_entries)++;
1385 }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1386 distance= ie->min_distance;
1390 ie->timestamp = timestamp;
1391 ie->min_distance= distance;
1398 int av_add_index_entry(AVStream *st,
1399 int64_t pos, int64_t timestamp, int size, int distance, int flags)
1401 return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1402 &st->index_entries_allocated_size, pos,
1403 timestamp, size, distance, flags);
1406 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1407 int64_t wanted_timestamp, int flags)
1415 //optimize appending index entries at the end
1416 if(b && entries[b-1].timestamp < wanted_timestamp)
1421 timestamp = entries[m].timestamp;
1422 if(timestamp >= wanted_timestamp)
1424 if(timestamp <= wanted_timestamp)
1427 m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1429 if(!(flags & AVSEEK_FLAG_ANY)){
1430 while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1431 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1440 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1443 return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
1444 wanted_timestamp, flags);
1449 int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1450 AVInputFormat *avif= s->iformat;
1451 int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1452 int64_t ts_min, ts_max, ts;
1457 if (stream_index < 0)
1461 av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1465 ts_min= AV_NOPTS_VALUE;
1466 pos_limit= -1; //gcc falsely says it may be uninitialized
1468 st= s->streams[stream_index];
1469 if(st->index_entries){
1472 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()
1473 index= FFMAX(index, 0);
1474 e= &st->index_entries[index];
1476 if(e->timestamp <= target_ts || e->pos == e->min_distance){
1478 ts_min= e->timestamp;
1480 av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1487 index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1488 assert(index < st->nb_index_entries);
1490 e= &st->index_entries[index];
1491 assert(e->timestamp >= target_ts);
1493 ts_max= e->timestamp;
1494 pos_limit= pos_max - e->min_distance;
1496 av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1497 pos_max,pos_limit, ts_max);
1502 pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1507 if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
1510 av_update_cur_dts(s, st, ts);
1515 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 )){
1517 int64_t start_pos, filesize;
1521 av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1524 if(ts_min == AV_NOPTS_VALUE){
1525 pos_min = s->data_offset;
1526 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1527 if (ts_min == AV_NOPTS_VALUE)
1531 if(ts_max == AV_NOPTS_VALUE){
1533 filesize = avio_size(s->pb);
1534 pos_max = filesize - 1;
1537 ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1539 }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1540 if (ts_max == AV_NOPTS_VALUE)
1544 int64_t tmp_pos= pos_max + 1;
1545 int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1546 if(tmp_ts == AV_NOPTS_VALUE)
1550 if(tmp_pos >= filesize)
1556 if(ts_min > ts_max){
1558 }else if(ts_min == ts_max){
1563 while (pos_min < pos_limit) {
1565 av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1569 assert(pos_limit <= pos_max);
1572 int64_t approximate_keyframe_distance= pos_max - pos_limit;
1573 // interpolate position (better than dichotomy)
1574 pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1575 + pos_min - approximate_keyframe_distance;
1576 }else if(no_change==1){
1577 // bisection, if interpolation failed to change min or max pos last time
1578 pos = (pos_min + pos_limit)>>1;
1580 /* linear search if bisection failed, can only happen if there
1581 are very few or no keyframes between min/max */
1586 else if(pos > pos_limit)
1590 ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1596 av_log(s, AV_LOG_DEBUG, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64" target:%"PRId64" limit:%"PRId64" start:%"PRId64" noc:%d\n",
1597 pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts, pos_limit,
1598 start_pos, no_change);
1600 if(ts == AV_NOPTS_VALUE){
1601 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1604 assert(ts != AV_NOPTS_VALUE);
1605 if (target_ts <= ts) {
1606 pos_limit = start_pos - 1;
1610 if (target_ts >= ts) {
1616 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1617 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
1620 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1622 ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1623 av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1624 pos, ts_min, target_ts, ts_max);
1630 static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1631 int64_t pos_min, pos_max;
1635 if (stream_index < 0)
1638 st= s->streams[stream_index];
1641 pos_min = s->data_offset;
1642 pos_max = avio_size(s->pb) - 1;
1644 if (pos < pos_min) pos= pos_min;
1645 else if(pos > pos_max) pos= pos_max;
1647 avio_seek(s->pb, pos, SEEK_SET);
1650 av_update_cur_dts(s, st, ts);
1655 static int av_seek_frame_generic(AVFormatContext *s,
1656 int stream_index, int64_t timestamp, int flags)
1663 st = s->streams[stream_index];
1665 index = av_index_search_timestamp(st, timestamp, flags);
1667 if(index < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
1670 if(index < 0 || index==st->nb_index_entries-1){
1674 if(st->nb_index_entries){
1675 assert(st->index_entries);
1676 ie= &st->index_entries[st->nb_index_entries-1];
1677 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1679 av_update_cur_dts(s, st, ie->timestamp);
1681 if ((ret = avio_seek(s->pb, s->data_offset, SEEK_SET)) < 0)
1687 ret = av_read_frame(s, &pkt);
1688 }while(ret == AVERROR(EAGAIN));
1691 av_free_packet(&pkt);
1692 if(stream_index == pkt.stream_index){
1693 if((pkt.flags & AV_PKT_FLAG_KEY) && pkt.dts > timestamp)
1697 index = av_index_search_timestamp(st, timestamp, flags);
1702 ff_read_frame_flush(s);
1703 if (s->iformat->read_seek){
1704 if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1707 ie = &st->index_entries[index];
1708 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1710 av_update_cur_dts(s, st, ie->timestamp);
1715 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1720 ff_read_frame_flush(s);
1722 if(flags & AVSEEK_FLAG_BYTE)
1723 return av_seek_frame_byte(s, stream_index, timestamp, flags);
1725 if(stream_index < 0){
1726 stream_index= av_find_default_stream_index(s);
1727 if(stream_index < 0)
1730 st= s->streams[stream_index];
1731 /* timestamp for default must be expressed in AV_TIME_BASE units */
1732 timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1735 /* first, we try the format specific seek */
1736 if (s->iformat->read_seek)
1737 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1744 if(s->iformat->read_timestamp)
1745 return av_seek_frame_binary(s, stream_index, timestamp, flags);
1747 return av_seek_frame_generic(s, stream_index, timestamp, flags);
1750 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
1752 if(min_ts > ts || max_ts < ts)
1755 ff_read_frame_flush(s);
1757 if (s->iformat->read_seek2)
1758 return s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
1760 if(s->iformat->read_timestamp){
1761 //try to seek via read_timestamp()
1764 //Fallback to old API if new is not implemented but old is
1765 //Note the old has somewat different sematics
1766 if(s->iformat->read_seek || 1)
1767 return av_seek_frame(s, stream_index, ts, flags | (ts - min_ts > (uint64_t)(max_ts - ts) ? AVSEEK_FLAG_BACKWARD : 0));
1769 // try some generic seek like av_seek_frame_generic() but with new ts semantics
1772 /*******************************************************/
1775 * Return TRUE if the stream has accurate duration in any stream.
1777 * @return TRUE if the stream has accurate duration for at least one component.
1779 static int av_has_duration(AVFormatContext *ic)
1784 for(i = 0;i < ic->nb_streams; i++) {
1785 st = ic->streams[i];
1786 if (st->duration != AV_NOPTS_VALUE)
1793 * Estimate the stream timings from the one of each components.
1795 * Also computes the global bitrate if possible.
1797 static void av_update_stream_timings(AVFormatContext *ic)
1799 int64_t start_time, start_time1, end_time, end_time1;
1800 int64_t duration, duration1;
1804 start_time = INT64_MAX;
1805 end_time = INT64_MIN;
1806 duration = INT64_MIN;
1807 for(i = 0;i < ic->nb_streams; i++) {
1808 st = ic->streams[i];
1809 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
1810 start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1811 if (start_time1 < start_time)
1812 start_time = start_time1;
1813 if (st->duration != AV_NOPTS_VALUE) {
1814 end_time1 = start_time1
1815 + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1816 if (end_time1 > end_time)
1817 end_time = end_time1;
1820 if (st->duration != AV_NOPTS_VALUE) {
1821 duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1822 if (duration1 > duration)
1823 duration = duration1;
1826 if (start_time != INT64_MAX) {
1827 ic->start_time = start_time;
1828 if (end_time != INT64_MIN) {
1829 if (end_time - start_time > duration)
1830 duration = end_time - start_time;
1833 if (duration != INT64_MIN) {
1834 ic->duration = duration;
1835 if (ic->file_size > 0) {
1836 /* compute the bitrate */
1837 ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1838 (double)ic->duration;
1843 static void fill_all_stream_timings(AVFormatContext *ic)
1848 av_update_stream_timings(ic);
1849 for(i = 0;i < ic->nb_streams; i++) {
1850 st = ic->streams[i];
1851 if (st->start_time == AV_NOPTS_VALUE) {
1852 if(ic->start_time != AV_NOPTS_VALUE)
1853 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1854 if(ic->duration != AV_NOPTS_VALUE)
1855 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1860 static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1862 int64_t filesize, duration;
1866 /* if bit_rate is already set, we believe it */
1867 if (ic->bit_rate <= 0) {
1869 for(i=0;i<ic->nb_streams;i++) {
1870 st = ic->streams[i];
1871 if (st->codec->bit_rate > 0)
1872 bit_rate += st->codec->bit_rate;
1874 ic->bit_rate = bit_rate;
1877 /* if duration is already set, we believe it */
1878 if (ic->duration == AV_NOPTS_VALUE &&
1879 ic->bit_rate != 0 &&
1880 ic->file_size != 0) {
1881 filesize = ic->file_size;
1883 for(i = 0; i < ic->nb_streams; i++) {
1884 st = ic->streams[i];
1885 duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1886 if (st->duration == AV_NOPTS_VALUE)
1887 st->duration = duration;
1893 #define DURATION_MAX_READ_SIZE 250000
1894 #define DURATION_MAX_RETRY 3
1896 /* only usable for MPEG-PS streams */
1897 static void av_estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
1899 AVPacket pkt1, *pkt = &pkt1;
1901 int read_size, i, ret;
1903 int64_t filesize, offset, duration;
1908 /* flush packet queue */
1909 flush_packet_queue(ic);
1911 for (i=0; i<ic->nb_streams; i++) {
1912 st = ic->streams[i];
1913 if (st->start_time == AV_NOPTS_VALUE && st->first_dts == AV_NOPTS_VALUE)
1914 av_log(st->codec, AV_LOG_WARNING, "start time is not set in av_estimate_timings_from_pts\n");
1917 av_parser_close(st->parser);
1919 av_free_packet(&st->cur_pkt);
1923 /* estimate the end time (duration) */
1924 /* XXX: may need to support wrapping */
1925 filesize = ic->file_size;
1926 end_time = AV_NOPTS_VALUE;
1928 offset = filesize - (DURATION_MAX_READ_SIZE<<retry);
1932 avio_seek(ic->pb, offset, SEEK_SET);
1935 if (read_size >= DURATION_MAX_READ_SIZE<<(FFMAX(retry-1,0)))
1939 ret = av_read_packet(ic, pkt);
1940 }while(ret == AVERROR(EAGAIN));
1943 read_size += pkt->size;
1944 st = ic->streams[pkt->stream_index];
1945 if (pkt->pts != AV_NOPTS_VALUE &&
1946 (st->start_time != AV_NOPTS_VALUE ||
1947 st->first_dts != AV_NOPTS_VALUE)) {
1948 duration = end_time = pkt->pts;
1949 if (st->start_time != AV_NOPTS_VALUE) duration -= st->start_time;
1950 else duration -= st->first_dts;
1952 duration += 1LL<<st->pts_wrap_bits;
1954 if (st->duration == AV_NOPTS_VALUE ||
1955 st->duration < duration)
1956 st->duration = duration;
1959 av_free_packet(pkt);
1961 }while( end_time==AV_NOPTS_VALUE
1962 && filesize > (DURATION_MAX_READ_SIZE<<retry)
1963 && ++retry <= DURATION_MAX_RETRY);
1965 fill_all_stream_timings(ic);
1967 avio_seek(ic->pb, old_offset, SEEK_SET);
1968 for (i=0; i<ic->nb_streams; i++) {
1970 st->cur_dts= st->first_dts;
1971 st->last_IP_pts = AV_NOPTS_VALUE;
1972 st->reference_dts = AV_NOPTS_VALUE;
1976 static void av_estimate_timings(AVFormatContext *ic, int64_t old_offset)
1980 /* get the file size, if possible */
1981 if (ic->iformat->flags & AVFMT_NOFILE) {
1984 file_size = avio_size(ic->pb);
1988 ic->file_size = file_size;
1990 if ((!strcmp(ic->iformat->name, "mpeg") ||
1991 !strcmp(ic->iformat->name, "mpegts")) &&
1992 file_size && ic->pb->seekable) {
1993 /* get accurate estimate from the PTSes */
1994 av_estimate_timings_from_pts(ic, old_offset);
1995 } else if (av_has_duration(ic)) {
1996 /* at least one component has timings - we use them for all
1998 fill_all_stream_timings(ic);
2000 av_log(ic, AV_LOG_WARNING, "Estimating duration from bitrate, this may be inaccurate\n");
2001 /* less precise: use bitrate info */
2002 av_estimate_timings_from_bit_rate(ic);
2004 av_update_stream_timings(ic);
2010 for(i = 0;i < ic->nb_streams; i++) {
2011 st = ic->streams[i];
2012 printf("%d: start_time: %0.3f duration: %0.3f\n",
2013 i, (double)st->start_time / AV_TIME_BASE,
2014 (double)st->duration / AV_TIME_BASE);
2016 printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2017 (double)ic->start_time / AV_TIME_BASE,
2018 (double)ic->duration / AV_TIME_BASE,
2019 ic->bit_rate / 1000);
2024 static int has_codec_parameters(AVCodecContext *enc)
2027 switch(enc->codec_type) {
2028 case AVMEDIA_TYPE_AUDIO:
2029 val = enc->sample_rate && enc->channels && enc->sample_fmt != AV_SAMPLE_FMT_NONE;
2030 if(!enc->frame_size &&
2031 (enc->codec_id == CODEC_ID_VORBIS ||
2032 enc->codec_id == CODEC_ID_AAC ||
2033 enc->codec_id == CODEC_ID_MP1 ||
2034 enc->codec_id == CODEC_ID_MP2 ||
2035 enc->codec_id == CODEC_ID_MP3 ||
2036 enc->codec_id == CODEC_ID_SPEEX ||
2037 enc->codec_id == CODEC_ID_CELT))
2040 case AVMEDIA_TYPE_VIDEO:
2041 val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
2047 return enc->codec_id != CODEC_ID_NONE && val != 0;
2050 static int has_decode_delay_been_guessed(AVStream *st)
2052 return st->codec->codec_id != CODEC_ID_H264 ||
2053 st->codec_info_nb_frames >= 6 + st->codec->has_b_frames;
2056 static int try_decode_frame(AVStream *st, AVPacket *avpkt)
2060 int got_picture, data_size, ret=0;
2063 if(!st->codec->codec){
2064 codec = avcodec_find_decoder(st->codec->codec_id);
2067 ret = avcodec_open(st->codec, codec);
2072 if(!has_codec_parameters(st->codec) || !has_decode_delay_been_guessed(st)){
2073 switch(st->codec->codec_type) {
2074 case AVMEDIA_TYPE_VIDEO:
2075 avcodec_get_frame_defaults(&picture);
2076 ret = avcodec_decode_video2(st->codec, &picture,
2077 &got_picture, avpkt);
2079 case AVMEDIA_TYPE_AUDIO:
2080 data_size = FFMAX(avpkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
2081 samples = av_malloc(data_size);
2084 ret = avcodec_decode_audio3(st->codec, samples,
2096 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum CodecID id)
2098 while (tags->id != CODEC_ID_NONE) {
2106 enum CodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2109 for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
2110 if(tag == tags[i].tag)
2113 for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
2114 if (ff_toupper4(tag) == ff_toupper4(tags[i].tag))
2117 return CODEC_ID_NONE;
2120 unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum CodecID id)
2123 for(i=0; tags && tags[i]; i++){
2124 int tag= ff_codec_get_tag(tags[i], id);
2130 enum CodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
2133 for(i=0; tags && tags[i]; i++){
2134 enum CodecID id= ff_codec_get_id(tags[i], tag);
2135 if(id!=CODEC_ID_NONE) return id;
2137 return CODEC_ID_NONE;
2140 static void compute_chapters_end(AVFormatContext *s)
2143 int64_t max_time = s->duration + (s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time;
2145 for (i = 0; i < s->nb_chapters; i++)
2146 if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2147 AVChapter *ch = s->chapters[i];
2148 int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q, ch->time_base)
2151 for (j = 0; j < s->nb_chapters; j++) {
2152 AVChapter *ch1 = s->chapters[j];
2153 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base, ch->time_base);
2154 if (j != i && next_start > ch->start && next_start < end)
2157 ch->end = (end == INT64_MAX) ? ch->start : end;
2161 static int get_std_framerate(int i){
2162 if(i<60*12) return i*1001;
2163 else return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
2167 * Is the time base unreliable.
2168 * This is a heuristic to balance between quick acceptance of the values in
2169 * the headers vs. some extra checks.
2170 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2171 * MPEG-2 commonly misuses field repeat flags to store different framerates.
2172 * And there are "variable" fps files this needs to detect as well.
2174 static int tb_unreliable(AVCodecContext *c){
2175 if( c->time_base.den >= 101L*c->time_base.num
2176 || c->time_base.den < 5L*c->time_base.num
2177 /* || c->codec_tag == AV_RL32("DIVX")
2178 || c->codec_tag == AV_RL32("XVID")*/
2179 || c->codec_id == CODEC_ID_MPEG2VIDEO
2180 || c->codec_id == CODEC_ID_H264
2186 int av_find_stream_info(AVFormatContext *ic)
2188 int i, count, ret, read_size, j;
2190 AVPacket pkt1, *pkt;
2191 int64_t old_offset = avio_tell(ic->pb);
2193 for(i=0;i<ic->nb_streams;i++) {
2195 st = ic->streams[i];
2196 if (st->codec->codec_id == CODEC_ID_AAC) {
2197 st->codec->sample_rate = 0;
2198 st->codec->frame_size = 0;
2199 st->codec->channels = 0;
2201 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2202 st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2203 /* if(!st->time_base.num)
2205 if(!st->codec->time_base.num)
2206 st->codec->time_base= st->time_base;
2208 //only for the split stuff
2209 if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
2210 st->parser = av_parser_init(st->codec->codec_id);
2211 if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
2212 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2215 assert(!st->codec->codec);
2216 codec = avcodec_find_decoder(st->codec->codec_id);
2218 /* Force decoding of at least one frame of codec data
2219 * this makes sure the codec initializes the channel configuration
2220 * and does not trust the values from the container.
2222 if (codec && codec->capabilities & CODEC_CAP_CHANNEL_CONF)
2223 st->codec->channels = 0;
2225 /* Ensure that subtitle_header is properly set. */
2226 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
2227 && codec && !st->codec->codec)
2228 avcodec_open(st->codec, codec);
2230 //try to just open decoders, in case this is enough to get parameters
2231 if(!has_codec_parameters(st->codec)){
2232 if (codec && !st->codec->codec)
2233 avcodec_open(st->codec, codec);
2237 for (i=0; i<ic->nb_streams; i++) {
2238 ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
2244 if(url_interrupt_cb()){
2246 av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2250 /* check if one codec still needs to be handled */
2251 for(i=0;i<ic->nb_streams;i++) {
2252 int fps_analyze_framecount = 20;
2254 st = ic->streams[i];
2255 if (!has_codec_parameters(st->codec))
2257 /* if the timebase is coarse (like the usual millisecond precision
2258 of mkv), we need to analyze more frames to reliably arrive at
2260 if (av_q2d(st->time_base) > 0.0005)
2261 fps_analyze_framecount *= 2;
2262 /* variable fps and no guess at the real fps */
2263 if( tb_unreliable(st->codec) && !(st->r_frame_rate.num && st->avg_frame_rate.num)
2264 && st->info->duration_count < fps_analyze_framecount
2265 && st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2267 if(st->parser && st->parser->parser->split && !st->codec->extradata)
2269 if(st->first_dts == AV_NOPTS_VALUE)
2272 if (i == ic->nb_streams) {
2273 /* NOTE: if the format has no header, then we need to read
2274 some packets to get most of the streams, so we cannot
2276 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2277 /* if we found the info for all the codecs, we can stop */
2279 av_log(ic, AV_LOG_DEBUG, "All info found\n");
2283 /* we did not get all the codec info, but we read too much data */
2284 if (read_size >= ic->probesize) {
2286 av_log(ic, AV_LOG_DEBUG, "Probe buffer size limit %d reached\n", ic->probesize);
2290 /* NOTE: a new stream can be added there if no header in file
2291 (AVFMTCTX_NOHEADER) */
2292 ret = av_read_frame_internal(ic, &pkt1);
2293 if (ret < 0 && ret != AVERROR(EAGAIN)) {
2295 ret = -1; /* we could not have all the codec parameters before EOF */
2296 for(i=0;i<ic->nb_streams;i++) {
2297 st = ic->streams[i];
2298 if (!has_codec_parameters(st->codec)){
2300 avcodec_string(buf, sizeof(buf), st->codec, 0);
2301 av_log(ic, AV_LOG_WARNING, "Could not find codec parameters (%s)\n", buf);
2309 if (ret == AVERROR(EAGAIN))
2312 pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2313 if ((ret = av_dup_packet(pkt)) < 0)
2314 goto find_stream_info_err;
2316 read_size += pkt->size;
2318 st = ic->streams[pkt->stream_index];
2319 if (st->codec_info_nb_frames>1) {
2320 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) {
2321 av_log(ic, AV_LOG_WARNING, "max_analyze_duration reached\n");
2324 st->info->codec_info_duration += pkt->duration;
2327 int64_t last = st->info->last_dts;
2328 int64_t duration= pkt->dts - last;
2330 if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
2331 double dur= duration * av_q2d(st->time_base);
2333 // if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2334 // av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
2335 if (st->info->duration_count < 2)
2336 memset(st->info->duration_error, 0, sizeof(st->info->duration_error));
2337 for (i=1; i<FF_ARRAY_ELEMS(st->info->duration_error); i++) {
2338 int framerate= get_std_framerate(i);
2339 int ticks= lrintf(dur*framerate/(1001*12));
2340 double error= dur - ticks*1001*12/(double)framerate;
2341 st->info->duration_error[i] += error*error;
2343 st->info->duration_count++;
2344 // ignore the first 4 values, they might have some random jitter
2345 if (st->info->duration_count > 3)
2346 st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2348 if (last == AV_NOPTS_VALUE || st->info->duration_count <= 1)
2349 st->info->last_dts = pkt->dts;
2351 if(st->parser && st->parser->parser->split && !st->codec->extradata){
2352 int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2354 st->codec->extradata_size= i;
2355 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2356 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2357 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2361 /* if still no information, we try to open the codec and to
2362 decompress the frame. We try to avoid that in most cases as
2363 it takes longer and uses more memory. For MPEG-4, we need to
2364 decompress for QuickTime. */
2365 if (!has_codec_parameters(st->codec) || !has_decode_delay_been_guessed(st))
2366 try_decode_frame(st, pkt);
2368 st->codec_info_nb_frames++;
2372 // close codecs which were opened in try_decode_frame()
2373 for(i=0;i<ic->nb_streams;i++) {
2374 st = ic->streams[i];
2375 if(st->codec->codec)
2376 avcodec_close(st->codec);
2378 for(i=0;i<ic->nb_streams;i++) {
2379 st = ic->streams[i];
2380 if (st->codec_info_nb_frames>2 && !st->avg_frame_rate.num && st->info->codec_info_duration)
2381 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2382 (st->codec_info_nb_frames-2)*(int64_t)st->time_base.den,
2383 st->info->codec_info_duration*(int64_t)st->time_base.num, 60000);
2384 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2385 if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample){
2386 uint32_t tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2387 if(ff_find_pix_fmt(ff_raw_pix_fmt_tags, tag) == st->codec->pix_fmt)
2388 st->codec->codec_tag= tag;
2391 // the check for tb_unreliable() is not completely correct, since this is not about handling
2392 // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2393 // ipmovie.c produces.
2394 if (tb_unreliable(st->codec) && st->info->duration_count > 15 && st->info->duration_gcd > FFMAX(1, st->time_base.den/(500LL*st->time_base.num)) && !st->r_frame_rate.num)
2395 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);
2396 if (st->info->duration_count && !st->r_frame_rate.num
2397 && tb_unreliable(st->codec) /*&&
2398 //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2399 st->time_base.num*duration_sum[i]/st->info->duration_count*101LL > st->time_base.den*/){
2401 double best_error= 2*av_q2d(st->time_base);
2402 best_error = best_error*best_error*st->info->duration_count*1000*12*30;
2404 for (j=1; j<FF_ARRAY_ELEMS(st->info->duration_error); j++) {
2405 double error = st->info->duration_error[j] * get_std_framerate(j);
2406 // if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2407 // av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
2408 if(error < best_error){
2410 num = get_std_framerate(j);
2413 // do not increase frame rate by more than 1 % in order to match a standard rate.
2414 if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
2415 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2418 if (!st->r_frame_rate.num){
2419 if( st->codec->time_base.den * (int64_t)st->time_base.num
2420 <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
2421 st->r_frame_rate.num = st->codec->time_base.den;
2422 st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
2424 st->r_frame_rate.num = st->time_base.den;
2425 st->r_frame_rate.den = st->time_base.num;
2428 }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2429 if(!st->codec->bits_per_coded_sample)
2430 st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2431 // set stream disposition based on audio service type
2432 switch (st->codec->audio_service_type) {
2433 case AV_AUDIO_SERVICE_TYPE_EFFECTS:
2434 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS; break;
2435 case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
2436 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED; break;
2437 case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
2438 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED; break;
2439 case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
2440 st->disposition = AV_DISPOSITION_COMMENT; break;
2441 case AV_AUDIO_SERVICE_TYPE_KARAOKE:
2442 st->disposition = AV_DISPOSITION_KARAOKE; break;
2447 av_estimate_timings(ic, old_offset);
2449 compute_chapters_end(ic);
2452 /* correct DTS for B-frame streams with no timestamps */
2453 for(i=0;i<ic->nb_streams;i++) {
2454 st = ic->streams[i];
2455 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2457 ppktl = &ic->packet_buffer;
2459 if(ppkt1->stream_index != i)
2461 if(ppkt1->pkt->dts < 0)
2463 if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2465 ppkt1->pkt->dts -= delta;
2470 st->cur_dts -= delta;
2476 find_stream_info_err:
2477 for (i=0; i < ic->nb_streams; i++)
2478 av_freep(&ic->streams[i]->info);
2482 static AVProgram *find_program_from_stream(AVFormatContext *ic, int s)
2486 for (i = 0; i < ic->nb_programs; i++)
2487 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
2488 if (ic->programs[i]->stream_index[j] == s)
2489 return ic->programs[i];
2493 int av_find_best_stream(AVFormatContext *ic,
2494 enum AVMediaType type,
2495 int wanted_stream_nb,
2497 AVCodec **decoder_ret,
2500 int i, nb_streams = ic->nb_streams;
2501 int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1;
2502 unsigned *program = NULL;
2503 AVCodec *decoder = NULL, *best_decoder = NULL;
2505 if (related_stream >= 0 && wanted_stream_nb < 0) {
2506 AVProgram *p = find_program_from_stream(ic, related_stream);
2508 program = p->stream_index;
2509 nb_streams = p->nb_stream_indexes;
2512 for (i = 0; i < nb_streams; i++) {
2513 int real_stream_index = program ? program[i] : i;
2514 AVStream *st = ic->streams[real_stream_index];
2515 AVCodecContext *avctx = st->codec;
2516 if (avctx->codec_type != type)
2518 if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
2520 if (st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED|AV_DISPOSITION_VISUAL_IMPAIRED))
2523 decoder = avcodec_find_decoder(st->codec->codec_id);
2526 ret = AVERROR_DECODER_NOT_FOUND;
2530 if (best_count >= st->codec_info_nb_frames)
2532 best_count = st->codec_info_nb_frames;
2533 ret = real_stream_index;
2534 best_decoder = decoder;
2535 if (program && i == nb_streams - 1 && ret < 0) {
2537 nb_streams = ic->nb_streams;
2538 i = 0; /* no related stream found, try again with everything */
2542 *decoder_ret = best_decoder;
2546 /*******************************************************/
2548 int av_read_play(AVFormatContext *s)
2550 if (s->iformat->read_play)
2551 return s->iformat->read_play(s);
2553 return avio_pause(s->pb, 0);
2554 return AVERROR(ENOSYS);
2557 int av_read_pause(AVFormatContext *s)
2559 if (s->iformat->read_pause)
2560 return s->iformat->read_pause(s);
2562 return avio_pause(s->pb, 1);
2563 return AVERROR(ENOSYS);
2566 void av_close_input_stream(AVFormatContext *s)
2568 flush_packet_queue(s);
2569 if (s->iformat->read_close)
2570 s->iformat->read_close(s);
2571 avformat_free_context(s);
2574 void avformat_free_context(AVFormatContext *s)
2579 for(i=0;i<s->nb_streams;i++) {
2580 /* free all data in a stream component */
2583 av_parser_close(st->parser);
2584 av_free_packet(&st->cur_pkt);
2586 av_metadata_free(&st->metadata);
2587 av_free(st->index_entries);
2588 av_free(st->codec->extradata);
2589 av_free(st->codec->subtitle_header);
2591 av_free(st->priv_data);
2595 for(i=s->nb_programs-1; i>=0; i--) {
2596 av_metadata_free(&s->programs[i]->metadata);
2597 av_freep(&s->programs[i]->stream_index);
2598 av_freep(&s->programs[i]);
2600 av_freep(&s->programs);
2601 av_freep(&s->priv_data);
2602 while(s->nb_chapters--) {
2603 av_metadata_free(&s->chapters[s->nb_chapters]->metadata);
2604 av_free(s->chapters[s->nb_chapters]);
2606 av_freep(&s->chapters);
2607 av_metadata_free(&s->metadata);
2609 av_freep(&s->streams);
2613 void av_close_input_file(AVFormatContext *s)
2615 AVIOContext *pb = s->iformat->flags & AVFMT_NOFILE ? NULL : s->pb;
2616 av_close_input_stream(s);
2621 AVStream *av_new_stream(AVFormatContext *s, int id)
2627 if (s->nb_streams >= INT_MAX/sizeof(*streams))
2629 streams = av_realloc(s->streams, (s->nb_streams + 1) * sizeof(*streams));
2632 s->streams = streams;
2634 st = av_mallocz(sizeof(AVStream));
2637 if (!(st->info = av_mallocz(sizeof(*st->info)))) {
2642 st->codec= avcodec_alloc_context();
2644 /* no default bitrate if decoding */
2645 st->codec->bit_rate = 0;
2647 st->index = s->nb_streams;
2649 st->start_time = AV_NOPTS_VALUE;
2650 st->duration = AV_NOPTS_VALUE;
2651 /* we set the current DTS to 0 so that formats without any timestamps
2652 but durations get some timestamps, formats with some unknown
2653 timestamps have their first few packets buffered and the
2654 timestamps corrected before they are returned to the user */
2656 st->first_dts = AV_NOPTS_VALUE;
2657 st->probe_packets = MAX_PROBE_PACKETS;
2659 /* default pts setting is MPEG-like */
2660 av_set_pts_info(st, 33, 1, 90000);
2661 st->last_IP_pts = AV_NOPTS_VALUE;
2662 for(i=0; i<MAX_REORDER_DELAY+1; i++)
2663 st->pts_buffer[i]= AV_NOPTS_VALUE;
2664 st->reference_dts = AV_NOPTS_VALUE;
2666 st->sample_aspect_ratio = (AVRational){0,1};
2668 s->streams[s->nb_streams++] = st;
2672 AVProgram *av_new_program(AVFormatContext *ac, int id)
2674 AVProgram *program=NULL;
2678 av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2681 for(i=0; i<ac->nb_programs; i++)
2682 if(ac->programs[i]->id == id)
2683 program = ac->programs[i];
2686 program = av_mallocz(sizeof(AVProgram));
2689 dynarray_add(&ac->programs, &ac->nb_programs, program);
2690 program->discard = AVDISCARD_NONE;
2697 AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2699 AVChapter *chapter = NULL;
2702 for(i=0; i<s->nb_chapters; i++)
2703 if(s->chapters[i]->id == id)
2704 chapter = s->chapters[i];
2707 chapter= av_mallocz(sizeof(AVChapter));
2710 dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2712 av_metadata_set2(&chapter->metadata, "title", title, 0);
2714 chapter->time_base= time_base;
2715 chapter->start = start;
2721 /************************************************************/
2722 /* output media file */
2724 int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2728 if (s->oformat->priv_data_size > 0) {
2729 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2731 return AVERROR(ENOMEM);
2732 if (s->oformat->priv_class) {
2733 *(const AVClass**)s->priv_data= s->oformat->priv_class;
2734 av_opt_set_defaults(s->priv_data);
2737 s->priv_data = NULL;
2742 AVFormatContext *avformat_alloc_output_context(const char *format, AVOutputFormat *oformat, const char *filename){
2743 AVFormatContext *s= avformat_alloc_context();
2749 oformat = av_guess_format(format, NULL, NULL);
2751 av_log(s, AV_LOG_ERROR, "Requested output format '%s' is not a suitable output format\n", format);
2755 oformat = av_guess_format(NULL, filename, NULL);
2757 av_log(s, AV_LOG_ERROR, "Unable to find a suitable output format for '%s'\n",
2764 s->oformat= oformat;
2765 if (s->oformat->priv_data_size > 0) {
2766 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2769 if (s->oformat->priv_class) {
2770 *(const AVClass**)s->priv_data= s->oformat->priv_class;
2771 av_opt_set_defaults(s->priv_data);
2774 s->priv_data = NULL;
2777 av_strlcpy(s->filename, filename, sizeof(s->filename));
2780 av_log(s, AV_LOG_ERROR, "Out of memory\n");
2782 avformat_free_context(s);
2786 static int validate_codec_tag(AVFormatContext *s, AVStream *st)
2788 const AVCodecTag *avctag;
2790 enum CodecID id = CODEC_ID_NONE;
2791 unsigned int tag = 0;
2794 * Check that tag + id is in the table
2795 * If neither is in the table -> OK
2796 * If tag is in the table with another id -> FAIL
2797 * If id is in the table with another tag -> FAIL unless strict < normal
2799 for (n = 0; s->oformat->codec_tag[n]; n++) {
2800 avctag = s->oformat->codec_tag[n];
2801 while (avctag->id != CODEC_ID_NONE) {
2802 if (ff_toupper4(avctag->tag) == ff_toupper4(st->codec->codec_tag)) {
2804 if (id == st->codec->codec_id)
2807 if (avctag->id == st->codec->codec_id)
2812 if (id != CODEC_ID_NONE)
2814 if (tag && (st->codec->strict_std_compliance >= FF_COMPLIANCE_NORMAL))
2819 int av_write_header(AVFormatContext *s)
2824 // some sanity checks
2825 if (s->nb_streams == 0 && !(s->oformat->flags & AVFMT_NOSTREAMS)) {
2826 av_log(s, AV_LOG_ERROR, "no streams\n");
2827 return AVERROR(EINVAL);
2830 for(i=0;i<s->nb_streams;i++) {
2833 switch (st->codec->codec_type) {
2834 case AVMEDIA_TYPE_AUDIO:
2835 if(st->codec->sample_rate<=0){
2836 av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2837 return AVERROR(EINVAL);
2839 if(!st->codec->block_align)
2840 st->codec->block_align = st->codec->channels *
2841 av_get_bits_per_sample(st->codec->codec_id) >> 3;
2843 case AVMEDIA_TYPE_VIDEO:
2844 if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2845 av_log(s, AV_LOG_ERROR, "time base not set\n");
2846 return AVERROR(EINVAL);
2848 if((st->codec->width<=0 || st->codec->height<=0) && !(s->oformat->flags & AVFMT_NODIMENSIONS)){
2849 av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2850 return AVERROR(EINVAL);
2852 if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)){
2853 av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between encoder and muxer layer\n");
2854 return AVERROR(EINVAL);
2859 if(s->oformat->codec_tag){
2860 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)){
2861 //the current rawvideo encoding system ends up setting the wrong codec_tag for avi, we override it here
2862 st->codec->codec_tag= 0;
2864 if(st->codec->codec_tag){
2865 if (!validate_codec_tag(s, st)) {
2867 av_get_codec_tag_string(tagbuf, sizeof(tagbuf), st->codec->codec_tag);
2868 av_log(s, AV_LOG_ERROR,
2869 "Tag %s/0x%08x incompatible with output codec id '%d'\n",
2870 tagbuf, st->codec->codec_tag, st->codec->codec_id);
2871 return AVERROR_INVALIDDATA;
2874 st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2877 if(s->oformat->flags & AVFMT_GLOBALHEADER &&
2878 !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
2879 av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
2882 if (!s->priv_data && s->oformat->priv_data_size > 0) {
2883 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2885 return AVERROR(ENOMEM);
2888 /* set muxer identification string */
2889 if (s->nb_streams && !(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
2890 av_metadata_set2(&s->metadata, "encoder", LIBAVFORMAT_IDENT, 0);
2893 if(s->oformat->write_header){
2894 ret = s->oformat->write_header(s);
2899 /* init PTS generation */
2900 for(i=0;i<s->nb_streams;i++) {
2901 int64_t den = AV_NOPTS_VALUE;
2904 switch (st->codec->codec_type) {
2905 case AVMEDIA_TYPE_AUDIO:
2906 den = (int64_t)st->time_base.num * st->codec->sample_rate;
2908 case AVMEDIA_TYPE_VIDEO:
2909 den = (int64_t)st->time_base.num * st->codec->time_base.den;
2914 if (den != AV_NOPTS_VALUE) {
2916 return AVERROR_INVALIDDATA;
2917 av_frac_init(&st->pts, 0, 0, den);
2923 //FIXME merge with compute_pkt_fields
2924 static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt){
2925 int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2926 int num, den, frame_size, i;
2928 av_dlog(s, "compute_pkt_fields2: pts:%"PRId64" dts:%"PRId64" cur_dts:%"PRId64" b:%d size:%d st:%d\n",
2929 pkt->pts, pkt->dts, st->cur_dts, delay, pkt->size, pkt->stream_index);
2931 /* if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2932 return AVERROR(EINVAL);*/
2934 /* duration field */
2935 if (pkt->duration == 0) {
2936 compute_frame_duration(&num, &den, st, NULL, pkt);
2938 pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
2942 if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
2945 //XXX/FIXME this is a temporary hack until all encoders output pts
2946 if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2948 // pkt->pts= st->cur_dts;
2949 pkt->pts= st->pts.val;
2952 //calculate dts from pts
2953 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
2954 st->pts_buffer[0]= pkt->pts;
2955 for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2956 st->pts_buffer[i]= pkt->pts + (i-delay-1) * pkt->duration;
2957 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2958 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2960 pkt->dts= st->pts_buffer[0];
2963 if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2964 av_log(s, AV_LOG_ERROR,
2965 "Application provided invalid, non monotonically increasing dts to muxer in stream %d: %"PRId64" >= %"PRId64"\n",
2966 st->index, st->cur_dts, pkt->dts);
2967 return AVERROR(EINVAL);
2969 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2970 av_log(s, AV_LOG_ERROR, "pts < dts in stream %d\n", st->index);
2971 return AVERROR(EINVAL);
2974 // av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2975 st->cur_dts= pkt->dts;
2976 st->pts.val= pkt->dts;
2979 switch (st->codec->codec_type) {
2980 case AVMEDIA_TYPE_AUDIO:
2981 frame_size = get_audio_frame_size(st->codec, pkt->size);
2983 /* HACK/FIXME, we skip the initial 0 size packets as they are most
2984 likely equal to the encoder delay, but it would be better if we
2985 had the real timestamps from the encoder */
2986 if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2987 av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2990 case AVMEDIA_TYPE_VIDEO:
2991 av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2999 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
3001 int ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt);
3003 if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3006 ret= s->oformat->write_packet(s, pkt);
3008 ret= url_ferror(s->pb);
3012 void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
3013 int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
3015 AVPacketList **next_point, *this_pktl;
3017 this_pktl = av_mallocz(sizeof(AVPacketList));
3018 this_pktl->pkt= *pkt;
3019 pkt->destruct= NULL; // do not free original but only the copy
3020 av_dup_packet(&this_pktl->pkt); // duplicate the packet if it uses non-alloced memory
3022 if(s->streams[pkt->stream_index]->last_in_packet_buffer){
3023 next_point = &(s->streams[pkt->stream_index]->last_in_packet_buffer->next);
3025 next_point = &s->packet_buffer;
3028 if(compare(s, &s->packet_buffer_end->pkt, pkt)){
3029 while(!compare(s, &(*next_point)->pkt, pkt)){
3030 next_point= &(*next_point)->next;
3034 next_point = &(s->packet_buffer_end->next);
3037 assert(!*next_point);
3039 s->packet_buffer_end= this_pktl;
3042 this_pktl->next= *next_point;
3044 s->streams[pkt->stream_index]->last_in_packet_buffer=
3045 *next_point= this_pktl;
3048 static int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
3050 AVStream *st = s->streams[ pkt ->stream_index];
3051 AVStream *st2= s->streams[ next->stream_index];
3052 int64_t a= st2->time_base.num * (int64_t)st ->time_base.den;
3053 int64_t b= st ->time_base.num * (int64_t)st2->time_base.den;
3054 int64_t dts1 = av_rescale_rnd(pkt->dts, b, a, AV_ROUND_DOWN);
3055 if (dts1==next->dts && dts1==av_rescale_rnd(pkt->dts, b, a, AV_ROUND_UP))
3056 return pkt->stream_index < next->stream_index;
3057 return dts1 < next->dts;
3060 int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
3066 ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
3069 for(i=0; i < s->nb_streams; i++)
3070 stream_count+= !!s->streams[i]->last_in_packet_buffer;
3072 if(stream_count && (s->nb_streams == stream_count || flush)){
3073 pktl= s->packet_buffer;
3076 s->packet_buffer= pktl->next;
3077 if(!s->packet_buffer)
3078 s->packet_buffer_end= NULL;
3080 if(s->streams[out->stream_index]->last_in_packet_buffer == pktl)
3081 s->streams[out->stream_index]->last_in_packet_buffer= NULL;
3085 av_init_packet(out);
3091 * Interleave an AVPacket correctly so it can be muxed.
3092 * @param out the interleaved packet will be output here
3093 * @param in the input packet
3094 * @param flush 1 if no further packets are available as input and all
3095 * remaining packets should be output
3096 * @return 1 if a packet was output, 0 if no packet could be output,
3097 * < 0 if an error occurred
3099 static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
3100 if(s->oformat->interleave_packet)
3101 return s->oformat->interleave_packet(s, out, in, flush);
3103 return av_interleave_packet_per_dts(s, out, in, flush);
3106 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
3107 AVStream *st= s->streams[ pkt->stream_index];
3110 //FIXME/XXX/HACK drop zero sized packets
3111 if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO && pkt->size==0)
3114 av_dlog(s, "av_interleaved_write_frame size:%d dts:%"PRId64" pts:%"PRId64"\n",
3115 pkt->size, pkt->dts, pkt->pts);
3116 if((ret = compute_pkt_fields2(s, st, pkt)) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3119 if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3120 return AVERROR(EINVAL);
3124 int ret= av_interleave_packet(s, &opkt, pkt, 0);
3125 if(ret<=0) //FIXME cleanup needed for ret<0 ?
3128 ret= s->oformat->write_packet(s, &opkt);
3130 av_free_packet(&opkt);
3135 if(url_ferror(s->pb))
3136 return url_ferror(s->pb);
3140 int av_write_trailer(AVFormatContext *s)
3146 ret= av_interleave_packet(s, &pkt, NULL, 1);
3147 if(ret<0) //FIXME cleanup needed for ret<0 ?
3152 ret= s->oformat->write_packet(s, &pkt);
3154 av_free_packet(&pkt);
3158 if(url_ferror(s->pb))
3162 if(s->oformat->write_trailer)
3163 ret = s->oformat->write_trailer(s);
3166 ret=url_ferror(s->pb);
3167 for(i=0;i<s->nb_streams;i++) {
3168 av_freep(&s->streams[i]->priv_data);
3169 av_freep(&s->streams[i]->index_entries);
3171 av_freep(&s->priv_data);
3175 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
3178 AVProgram *program=NULL;
3181 if (idx >= ac->nb_streams) {
3182 av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3186 for(i=0; i<ac->nb_programs; i++){
3187 if(ac->programs[i]->id != progid)
3189 program = ac->programs[i];
3190 for(j=0; j<program->nb_stream_indexes; j++)
3191 if(program->stream_index[j] == idx)
3194 tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
3197 program->stream_index = tmp;
3198 program->stream_index[program->nb_stream_indexes++] = idx;
3203 static void print_fps(double d, const char *postfix){
3204 uint64_t v= lrintf(d*100);
3205 if (v% 100 ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3206 else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3207 else av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
3210 static void dump_metadata(void *ctx, AVMetadata *m, const char *indent)
3212 if(m && !(m->count == 1 && av_metadata_get(m, "language", NULL, 0))){
3213 AVMetadataTag *tag=NULL;
3215 av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3216 while((tag=av_metadata_get(m, "", tag, AV_METADATA_IGNORE_SUFFIX))) {
3217 if(strcmp("language", tag->key))
3218 av_log(ctx, AV_LOG_INFO, "%s %-16s: %s\n", indent, tag->key, tag->value);
3223 /* "user interface" functions */
3224 static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
3227 int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
3228 AVStream *st = ic->streams[i];
3229 int g = av_gcd(st->time_base.num, st->time_base.den);
3230 AVMetadataTag *lang = av_metadata_get(st->metadata, "language", NULL, 0);
3231 avcodec_string(buf, sizeof(buf), st->codec, is_output);
3232 av_log(NULL, AV_LOG_INFO, " Stream #%d.%d", index, i);
3233 /* the pid is an important information, so we display it */
3234 /* XXX: add a generic system */
3235 if (flags & AVFMT_SHOW_IDS)
3236 av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
3238 av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
3239 av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames, st->time_base.num/g, st->time_base.den/g);
3240 av_log(NULL, AV_LOG_INFO, ": %s", buf);
3241 if (st->sample_aspect_ratio.num && // default
3242 av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
3243 AVRational display_aspect_ratio;
3244 av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
3245 st->codec->width*st->sample_aspect_ratio.num,
3246 st->codec->height*st->sample_aspect_ratio.den,
3248 av_log(NULL, AV_LOG_INFO, ", PAR %d:%d DAR %d:%d",
3249 st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3250 display_aspect_ratio.num, display_aspect_ratio.den);
3252 if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
3253 if(st->avg_frame_rate.den && st->avg_frame_rate.num)
3254 print_fps(av_q2d(st->avg_frame_rate), "fps");
3255 if(st->r_frame_rate.den && st->r_frame_rate.num)
3256 print_fps(av_q2d(st->r_frame_rate), "tbr");
3257 if(st->time_base.den && st->time_base.num)
3258 print_fps(1/av_q2d(st->time_base), "tbn");
3259 if(st->codec->time_base.den && st->codec->time_base.num)
3260 print_fps(1/av_q2d(st->codec->time_base), "tbc");
3262 if (st->disposition & AV_DISPOSITION_DEFAULT)
3263 av_log(NULL, AV_LOG_INFO, " (default)");
3264 if (st->disposition & AV_DISPOSITION_DUB)
3265 av_log(NULL, AV_LOG_INFO, " (dub)");
3266 if (st->disposition & AV_DISPOSITION_ORIGINAL)
3267 av_log(NULL, AV_LOG_INFO, " (original)");
3268 if (st->disposition & AV_DISPOSITION_COMMENT)
3269 av_log(NULL, AV_LOG_INFO, " (comment)");
3270 if (st->disposition & AV_DISPOSITION_LYRICS)
3271 av_log(NULL, AV_LOG_INFO, " (lyrics)");
3272 if (st->disposition & AV_DISPOSITION_KARAOKE)
3273 av_log(NULL, AV_LOG_INFO, " (karaoke)");
3274 if (st->disposition & AV_DISPOSITION_FORCED)
3275 av_log(NULL, AV_LOG_INFO, " (forced)");
3276 if (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED)
3277 av_log(NULL, AV_LOG_INFO, " (hearing impaired)");
3278 if (st->disposition & AV_DISPOSITION_VISUAL_IMPAIRED)
3279 av_log(NULL, AV_LOG_INFO, " (visual impaired)");
3280 if (st->disposition & AV_DISPOSITION_CLEAN_EFFECTS)
3281 av_log(NULL, AV_LOG_INFO, " (clean effects)");
3282 av_log(NULL, AV_LOG_INFO, "\n");
3283 dump_metadata(NULL, st->metadata, " ");
3286 #if FF_API_DUMP_FORMAT
3287 void dump_format(AVFormatContext *ic,
3292 av_dump_format(ic, index, url, is_output);
3296 void av_dump_format(AVFormatContext *ic,
3302 uint8_t *printed = av_mallocz(ic->nb_streams);
3303 if (ic->nb_streams && !printed)
3306 av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3307 is_output ? "Output" : "Input",
3309 is_output ? ic->oformat->name : ic->iformat->name,
3310 is_output ? "to" : "from", url);
3311 dump_metadata(NULL, ic->metadata, " ");
3313 av_log(NULL, AV_LOG_INFO, " Duration: ");
3314 if (ic->duration != AV_NOPTS_VALUE) {
3315 int hours, mins, secs, us;
3316 secs = ic->duration / AV_TIME_BASE;
3317 us = ic->duration % AV_TIME_BASE;
3322 av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3323 (100 * us) / AV_TIME_BASE);
3325 av_log(NULL, AV_LOG_INFO, "N/A");
3327 if (ic->start_time != AV_NOPTS_VALUE) {
3329 av_log(NULL, AV_LOG_INFO, ", start: ");
3330 secs = ic->start_time / AV_TIME_BASE;
3331 us = abs(ic->start_time % AV_TIME_BASE);
3332 av_log(NULL, AV_LOG_INFO, "%d.%06d",
3333 secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
3335 av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3337 av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
3339 av_log(NULL, AV_LOG_INFO, "N/A");
3341 av_log(NULL, AV_LOG_INFO, "\n");
3343 for (i = 0; i < ic->nb_chapters; i++) {
3344 AVChapter *ch = ic->chapters[i];
3345 av_log(NULL, AV_LOG_INFO, " Chapter #%d.%d: ", index, i);
3346 av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
3347 av_log(NULL, AV_LOG_INFO, "end %f\n", ch->end * av_q2d(ch->time_base));
3349 dump_metadata(NULL, ch->metadata, " ");
3351 if(ic->nb_programs) {
3352 int j, k, total = 0;
3353 for(j=0; j<ic->nb_programs; j++) {
3354 AVMetadataTag *name = av_metadata_get(ic->programs[j]->metadata,
3356 av_log(NULL, AV_LOG_INFO, " Program %d %s\n", ic->programs[j]->id,
3357 name ? name->value : "");
3358 dump_metadata(NULL, ic->programs[j]->metadata, " ");
3359 for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3360 dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3361 printed[ic->programs[j]->stream_index[k]] = 1;
3363 total += ic->programs[j]->nb_stream_indexes;
3365 if (total < ic->nb_streams)
3366 av_log(NULL, AV_LOG_INFO, " No Program\n");
3368 for(i=0;i<ic->nb_streams;i++)
3370 dump_stream_format(ic, i, index, is_output);
3375 int64_t av_gettime(void)
3378 gettimeofday(&tv,NULL);
3379 return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
3382 uint64_t ff_ntp_time(void)
3384 return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3387 #if FF_API_PARSE_DATE
3388 #include "libavutil/parseutils.h"
3390 int64_t parse_date(const char *timestr, int duration)
3393 av_parse_time(&timeval, timestr, duration);
3398 #if FF_API_FIND_INFO_TAG
3399 #include "libavutil/parseutils.h"
3401 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
3403 return av_find_info_tag(arg, arg_size, tag1, info);
3407 int av_get_frame_filename(char *buf, int buf_size,
3408 const char *path, int number)
3411 char *q, buf1[20], c;
3412 int nd, len, percentd_found;
3424 while (isdigit(*p)) {
3425 nd = nd * 10 + *p++ - '0';
3428 } while (isdigit(c));
3437 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3439 if ((q - buf + len) > buf_size - 1)
3441 memcpy(q, buf1, len);
3449 if ((q - buf) < buf_size - 1)
3453 if (!percentd_found)
3462 static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3466 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3468 for(i=0;i<size;i+=16) {
3475 PRINT(" %02x", buf[i+j]);
3480 for(j=0;j<len;j++) {
3482 if (c < ' ' || c > '~')
3491 void av_hex_dump(FILE *f, uint8_t *buf, int size)
3493 hex_dump_internal(NULL, f, 0, buf, size);
3496 void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3498 hex_dump_internal(avcl, NULL, level, buf, size);
3501 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload, AVRational time_base)
3504 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3505 PRINT("stream #%d:\n", pkt->stream_index);
3506 PRINT(" keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
3507 PRINT(" duration=%0.3f\n", pkt->duration * av_q2d(time_base));
3508 /* DTS is _always_ valid after av_read_frame() */
3510 if (pkt->dts == AV_NOPTS_VALUE)
3513 PRINT("%0.3f", pkt->dts * av_q2d(time_base));
3514 /* PTS may not be known if B-frames are present. */
3516 if (pkt->pts == AV_NOPTS_VALUE)
3519 PRINT("%0.3f", pkt->pts * av_q2d(time_base));
3521 PRINT(" size=%d\n", pkt->size);
3524 av_hex_dump(f, pkt->data, pkt->size);
3528 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3530 AVRational tb = { 1, AV_TIME_BASE };
3531 pkt_dump_internal(NULL, f, 0, pkt, dump_payload, tb);
3535 void av_pkt_dump2(FILE *f, AVPacket *pkt, int dump_payload, AVStream *st)
3537 pkt_dump_internal(NULL, f, 0, pkt, dump_payload, st->time_base);
3541 void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3543 AVRational tb = { 1, AV_TIME_BASE };
3544 pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, tb);
3548 void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload,
3551 pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, st->time_base);
3554 void av_url_split(char *proto, int proto_size,
3555 char *authorization, int authorization_size,
3556 char *hostname, int hostname_size,
3558 char *path, int path_size,
3561 const char *p, *ls, *at, *col, *brk;
3563 if (port_ptr) *port_ptr = -1;
3564 if (proto_size > 0) proto[0] = 0;
3565 if (authorization_size > 0) authorization[0] = 0;
3566 if (hostname_size > 0) hostname[0] = 0;
3567 if (path_size > 0) path[0] = 0;
3569 /* parse protocol */
3570 if ((p = strchr(url, ':'))) {
3571 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3576 /* no protocol means plain filename */
3577 av_strlcpy(path, url, path_size);
3581 /* separate path from hostname */
3582 ls = strchr(p, '/');
3584 ls = strchr(p, '?');
3586 av_strlcpy(path, ls, path_size);
3588 ls = &p[strlen(p)]; // XXX
3590 /* the rest is hostname, use that to parse auth/port */
3592 /* authorization (user[:pass]@hostname) */
3593 if ((at = strchr(p, '@')) && at < ls) {
3594 av_strlcpy(authorization, p,
3595 FFMIN(authorization_size, at + 1 - p));
3596 p = at + 1; /* skip '@' */
3599 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3601 av_strlcpy(hostname, p + 1,
3602 FFMIN(hostname_size, brk - p));
3603 if (brk[1] == ':' && port_ptr)
3604 *port_ptr = atoi(brk + 2);
3605 } else if ((col = strchr(p, ':')) && col < ls) {
3606 av_strlcpy(hostname, p,
3607 FFMIN(col + 1 - p, hostname_size));
3608 if (port_ptr) *port_ptr = atoi(col + 1);
3610 av_strlcpy(hostname, p,
3611 FFMIN(ls + 1 - p, hostname_size));
3615 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3618 static const char hex_table_uc[16] = { '0', '1', '2', '3',
3621 'C', 'D', 'E', 'F' };
3622 static const char hex_table_lc[16] = { '0', '1', '2', '3',
3625 'c', 'd', 'e', 'f' };
3626 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3628 for(i = 0; i < s; i++) {
3629 buff[i * 2] = hex_table[src[i] >> 4];
3630 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3636 int ff_hex_to_data(uint8_t *data, const char *p)
3643 p += strspn(p, SPACE_CHARS);
3646 c = toupper((unsigned char) *p++);
3647 if (c >= '0' && c <= '9')
3649 else if (c >= 'A' && c <= 'F')
3664 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3665 unsigned int pts_num, unsigned int pts_den)
3668 if(av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)){
3669 if(new_tb.num != pts_num)
3670 av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/new_tb.num);
3672 av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3674 if(new_tb.num <= 0 || new_tb.den <= 0) {
3675 av_log(NULL, AV_LOG_ERROR, "Ignoring attempt to set invalid timebase for st:%d\n", s->index);
3678 s->time_base = new_tb;
3679 s->pts_wrap_bits = pts_wrap_bits;
3682 int ff_url_join(char *str, int size, const char *proto,
3683 const char *authorization, const char *hostname,
3684 int port, const char *fmt, ...)
3687 struct addrinfo hints, *ai;
3692 av_strlcatf(str, size, "%s://", proto);
3693 if (authorization && authorization[0])
3694 av_strlcatf(str, size, "%s@", authorization);
3695 #if CONFIG_NETWORK && defined(AF_INET6)
3696 /* Determine if hostname is a numerical IPv6 address,
3697 * properly escape it within [] in that case. */
3698 memset(&hints, 0, sizeof(hints));
3699 hints.ai_flags = AI_NUMERICHOST;
3700 if (!getaddrinfo(hostname, NULL, &hints, &ai)) {
3701 if (ai->ai_family == AF_INET6) {
3702 av_strlcat(str, "[", size);
3703 av_strlcat(str, hostname, size);
3704 av_strlcat(str, "]", size);
3706 av_strlcat(str, hostname, size);
3711 /* Not an IPv6 address, just output the plain string. */
3712 av_strlcat(str, hostname, size);
3715 av_strlcatf(str, size, ":%d", port);
3718 int len = strlen(str);
3721 vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);
3727 int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
3728 AVFormatContext *src)
3733 local_pkt.stream_index = dst_stream;
3734 if (pkt->pts != AV_NOPTS_VALUE)
3735 local_pkt.pts = av_rescale_q(pkt->pts,
3736 src->streams[pkt->stream_index]->time_base,
3737 dst->streams[dst_stream]->time_base);
3738 if (pkt->dts != AV_NOPTS_VALUE)
3739 local_pkt.dts = av_rescale_q(pkt->dts,
3740 src->streams[pkt->stream_index]->time_base,
3741 dst->streams[dst_stream]->time_base);
3742 return av_write_frame(dst, &local_pkt);
3745 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
3748 const char *ptr = str;
3750 /* Parse key=value pairs. */
3753 char *dest = NULL, *dest_end;
3754 int key_len, dest_len = 0;
3756 /* Skip whitespace and potential commas. */
3757 while (*ptr && (isspace(*ptr) || *ptr == ','))
3764 if (!(ptr = strchr(key, '=')))
3767 key_len = ptr - key;
3769 callback_get_buf(context, key, key_len, &dest, &dest_len);
3770 dest_end = dest + dest_len - 1;
3774 while (*ptr && *ptr != '\"') {
3778 if (dest && dest < dest_end)
3782 if (dest && dest < dest_end)
3790 for (; *ptr && !(isspace(*ptr) || *ptr == ','); ptr++)
3791 if (dest && dest < dest_end)
3799 int ff_find_stream_index(AVFormatContext *s, int id)
3802 for (i = 0; i < s->nb_streams; i++) {
3803 if (s->streams[i]->id == id)
3809 void ff_make_absolute_url(char *buf, int size, const char *base,
3813 /* Absolute path, relative to the current server */
3814 if (base && strstr(base, "://") && rel[0] == '/') {
3816 av_strlcpy(buf, base, size);
3817 sep = strstr(buf, "://");
3820 sep = strchr(sep, '/');
3824 av_strlcat(buf, rel, size);
3827 /* If rel actually is an absolute url, just copy it */
3828 if (!base || strstr(rel, "://") || rel[0] == '/') {
3829 av_strlcpy(buf, rel, size);
3833 av_strlcpy(buf, base, size);
3834 /* Remove the file name from the base url */
3835 sep = strrchr(buf, '/');
3840 while (av_strstart(rel, "../", NULL) && sep) {
3841 /* Remove the path delimiter at the end */
3843 sep = strrchr(buf, '/');
3844 /* If the next directory name to pop off is "..", break here */
3845 if (!strcmp(sep ? &sep[1] : buf, "..")) {
3846 /* Readd the slash we just removed */
3847 av_strlcat(buf, "/", size);
3850 /* Cut off the directory name */
3857 av_strlcat(buf, rel, size);