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 "libavcodec/bytestream.h"
30 #include "libavutil/avassert.h"
31 #include "libavutil/opt.h"
32 #include "libavutil/dict.h"
33 #include "libavutil/pixdesc.h"
36 #include "libavutil/avassert.h"
37 #include "libavutil/avstring.h"
38 #include "libavutil/mathematics.h"
39 #include "libavutil/parseutils.h"
41 #include "audiointerleave.h"
55 * various utility functions for use within FFmpeg
58 unsigned avformat_version(void)
60 av_assert0(LIBAVFORMAT_VERSION_MICRO >= 100);
61 return LIBAVFORMAT_VERSION_INT;
64 const char *avformat_configuration(void)
66 return FFMPEG_CONFIGURATION;
69 const char *avformat_license(void)
71 #define LICENSE_PREFIX "libavformat license: "
72 return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;
75 /* fraction handling */
78 * f = val + (num / den) + 0.5.
80 * 'num' is normalized so that it is such as 0 <= num < den.
82 * @param f fractional number
83 * @param val integer value
84 * @param num must be >= 0
85 * @param den must be >= 1
87 static void frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
100 * Fractional addition to f: f = f + (incr / f->den).
102 * @param f fractional number
103 * @param incr increment, can be positive or negative
105 static void frac_add(AVFrac *f, int64_t incr)
118 } else if (num >= den) {
125 /** head of registered input format linked list */
126 static AVInputFormat *first_iformat = NULL;
127 /** head of registered output format linked list */
128 static AVOutputFormat *first_oformat = NULL;
130 AVInputFormat *av_iformat_next(AVInputFormat *f)
132 if(f) return f->next;
133 else return first_iformat;
136 AVOutputFormat *av_oformat_next(AVOutputFormat *f)
138 if(f) return f->next;
139 else return first_oformat;
142 void av_register_input_format(AVInputFormat *format)
146 while (*p != NULL) p = &(*p)->next;
151 void av_register_output_format(AVOutputFormat *format)
155 while (*p != NULL) p = &(*p)->next;
160 int av_match_ext(const char *filename, const char *extensions)
168 ext = strrchr(filename, '.');
174 while (*p != '\0' && *p != ',' && q-ext1<sizeof(ext1)-1)
177 if (!av_strcasecmp(ext1, ext))
187 static int match_format(const char *name, const char *names)
195 namelen = strlen(name);
196 while ((p = strchr(names, ','))) {
197 len = FFMAX(p - names, namelen);
198 if (!av_strncasecmp(name, names, len))
202 return !av_strcasecmp(name, names);
205 AVOutputFormat *av_guess_format(const char *short_name, const char *filename,
206 const char *mime_type)
208 AVOutputFormat *fmt = NULL, *fmt_found;
209 int score_max, score;
211 /* specific test for image sequences */
212 #if CONFIG_IMAGE2_MUXER
213 if (!short_name && filename &&
214 av_filename_number_test(filename) &&
215 ff_guess_image2_codec(filename) != CODEC_ID_NONE) {
216 return av_guess_format("image2", NULL, NULL);
219 /* Find the proper file type. */
222 while ((fmt = av_oformat_next(fmt))) {
224 if (fmt->name && short_name && !strcmp(fmt->name, short_name))
226 if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
228 if (filename && fmt->extensions &&
229 av_match_ext(filename, fmt->extensions)) {
232 if (score > score_max) {
240 enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
241 const char *filename, const char *mime_type, enum AVMediaType type){
242 if(type == AVMEDIA_TYPE_VIDEO){
243 enum CodecID codec_id= CODEC_ID_NONE;
245 #if CONFIG_IMAGE2_MUXER
246 if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
247 codec_id= ff_guess_image2_codec(filename);
250 if(codec_id == CODEC_ID_NONE)
251 codec_id= fmt->video_codec;
253 }else if(type == AVMEDIA_TYPE_AUDIO)
254 return fmt->audio_codec;
255 else if (type == AVMEDIA_TYPE_SUBTITLE)
256 return fmt->subtitle_codec;
258 return CODEC_ID_NONE;
261 AVInputFormat *av_find_input_format(const char *short_name)
263 AVInputFormat *fmt = NULL;
264 while ((fmt = av_iformat_next(fmt))) {
265 if (match_format(short_name, fmt->name))
271 int ffio_limit(AVIOContext *s, int size)
274 int64_t remaining= s->maxsize - avio_tell(s);
275 if(remaining < size){
276 int64_t newsize= avio_size(s);
277 if(!s->maxsize || s->maxsize<newsize)
278 s->maxsize= newsize - !newsize;
279 remaining= s->maxsize - avio_tell(s);
280 remaining= FFMAX(remaining, 0);
283 if(s->maxsize>=0 && remaining+1 < size){
284 av_log(0, AV_LOG_ERROR, "Truncating packet of size %d to %"PRId64"\n", size, remaining+1);
291 int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
294 size= ffio_limit(s, size);
296 ret= av_new_packet(pkt, size);
301 pkt->pos= avio_tell(s);
303 ret= avio_read(s, pkt->data, size);
307 av_shrink_packet(pkt, ret);
312 int av_append_packet(AVIOContext *s, AVPacket *pkt, int size)
317 return av_get_packet(s, pkt, size);
318 old_size = pkt->size;
319 ret = av_grow_packet(pkt, size);
322 ret = avio_read(s, pkt->data + old_size, size);
323 av_shrink_packet(pkt, old_size + FFMAX(ret, 0));
328 int av_filename_number_test(const char *filename)
331 return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
334 AVInputFormat *av_probe_input_format3(AVProbeData *pd, int is_opened, int *score_ret)
336 AVProbeData lpd = *pd;
337 AVInputFormat *fmt1 = NULL, *fmt;
338 int score, nodat = 0, score_max=0;
340 if (lpd.buf_size > 10 && ff_id3v2_match(lpd.buf, ID3v2_DEFAULT_MAGIC)) {
341 int id3len = ff_id3v2_tag_len(lpd.buf);
342 if (lpd.buf_size > id3len + 16) {
344 lpd.buf_size -= id3len;
350 while ((fmt1 = av_iformat_next(fmt1))) {
351 if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
354 if (fmt1->read_probe) {
355 score = fmt1->read_probe(&lpd);
356 if(fmt1->extensions && av_match_ext(lpd.filename, fmt1->extensions))
357 score = FFMAX(score, nodat ? AVPROBE_SCORE_MAX/4-1 : 1);
358 } else if (fmt1->extensions) {
359 if (av_match_ext(lpd.filename, fmt1->extensions)) {
363 if (score > score_max) {
366 }else if (score == score_max)
369 *score_ret= score_max;
374 AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
377 AVInputFormat *fmt= av_probe_input_format3(pd, is_opened, &score_ret);
378 if(score_ret > *score_max){
379 *score_max= score_ret;
385 AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
387 return av_probe_input_format2(pd, is_opened, &score);
390 static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st, AVProbeData *pd)
392 static const struct {
393 const char *name; enum CodecID id; enum AVMediaType type;
395 { "aac" , CODEC_ID_AAC , AVMEDIA_TYPE_AUDIO },
396 { "ac3" , CODEC_ID_AC3 , AVMEDIA_TYPE_AUDIO },
397 { "dts" , CODEC_ID_DTS , AVMEDIA_TYPE_AUDIO },
398 { "eac3" , CODEC_ID_EAC3 , AVMEDIA_TYPE_AUDIO },
399 { "h264" , CODEC_ID_H264 , AVMEDIA_TYPE_VIDEO },
400 { "loas" , CODEC_ID_AAC_LATM , AVMEDIA_TYPE_AUDIO },
401 { "m4v" , CODEC_ID_MPEG4 , AVMEDIA_TYPE_VIDEO },
402 { "mp3" , CODEC_ID_MP3 , AVMEDIA_TYPE_AUDIO },
403 { "mpegvideo", CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
407 AVInputFormat *fmt = av_probe_input_format3(pd, 1, &score);
411 av_log(s, AV_LOG_DEBUG, "Probe with size=%d, packets=%d detected %s with score=%d\n",
412 pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets, fmt->name, score);
413 for (i = 0; fmt_id_type[i].name; i++) {
414 if (!strcmp(fmt->name, fmt_id_type[i].name)) {
415 st->codec->codec_id = fmt_id_type[i].id;
416 st->codec->codec_type = fmt_id_type[i].type;
424 /************************************************************/
425 /* input media file */
427 int av_demuxer_open(AVFormatContext *ic){
430 if (ic->iformat->read_header) {
431 err = ic->iformat->read_header(ic);
436 if (ic->pb && !ic->data_offset)
437 ic->data_offset = avio_tell(ic->pb);
443 /** size of probe buffer, for guessing file type from file contents */
444 #define PROBE_BUF_MIN 2048
445 #define PROBE_BUF_MAX (1<<20)
447 int av_probe_input_buffer(AVIOContext *pb, AVInputFormat **fmt,
448 const char *filename, void *logctx,
449 unsigned int offset, unsigned int max_probe_size)
451 AVProbeData pd = { filename ? filename : "", NULL, -offset };
452 unsigned char *buf = NULL;
453 int ret = 0, probe_size;
455 if (!max_probe_size) {
456 max_probe_size = PROBE_BUF_MAX;
457 } else if (max_probe_size > PROBE_BUF_MAX) {
458 max_probe_size = PROBE_BUF_MAX;
459 } else if (max_probe_size < PROBE_BUF_MIN) {
460 return AVERROR(EINVAL);
463 if (offset >= max_probe_size) {
464 return AVERROR(EINVAL);
467 for(probe_size= PROBE_BUF_MIN; probe_size<=max_probe_size && !*fmt;
468 probe_size = FFMIN(probe_size<<1, FFMAX(max_probe_size, probe_size+1))) {
469 int score = probe_size < max_probe_size ? AVPROBE_SCORE_MAX/4 : 0;
470 int buf_offset = (probe_size == PROBE_BUF_MIN) ? 0 : probe_size>>1;
473 if (probe_size < offset) {
477 /* read probe data */
478 buftmp = av_realloc(buf, probe_size + AVPROBE_PADDING_SIZE);
481 return AVERROR(ENOMEM);
484 if ((ret = avio_read(pb, buf + buf_offset, probe_size - buf_offset)) < 0) {
485 /* fail if error was not end of file, otherwise, lower score */
486 if (ret != AVERROR_EOF) {
491 ret = 0; /* error was end of file, nothing read */
494 pd.buf = &buf[offset];
496 memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE);
498 /* guess file format */
499 *fmt = av_probe_input_format2(&pd, 1, &score);
501 if(score <= AVPROBE_SCORE_MAX/4){ //this can only be true in the last iteration
502 av_log(logctx, AV_LOG_WARNING, "Format %s detected only with low score of %d, misdetection possible!\n", (*fmt)->name, score);
504 av_log(logctx, AV_LOG_DEBUG, "Format %s probed with size=%d and score=%d\n", (*fmt)->name, probe_size, score);
510 return AVERROR_INVALIDDATA;
513 /* rewind. reuse probe buffer to avoid seeking */
514 if ((ret = ffio_rewind_with_probe_data(pb, buf, pd.buf_size)) < 0)
520 /* open input file and probe the format if necessary */
521 static int init_input(AVFormatContext *s, const char *filename, AVDictionary **options)
524 AVProbeData pd = {filename, NULL, 0};
527 s->flags |= AVFMT_FLAG_CUSTOM_IO;
529 return av_probe_input_buffer(s->pb, &s->iformat, filename, s, 0, 0);
530 else if (s->iformat->flags & AVFMT_NOFILE)
531 av_log(s, AV_LOG_WARNING, "Custom AVIOContext makes no sense and "
532 "will be ignored with AVFMT_NOFILE format.\n");
536 if ( (s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
537 (!s->iformat && (s->iformat = av_probe_input_format(&pd, 0))))
540 if ((ret = avio_open2(&s->pb, filename, AVIO_FLAG_READ,
541 &s->interrupt_callback, options)) < 0)
545 return av_probe_input_buffer(s->pb, &s->iformat, filename, s, 0, 0);
548 int avformat_open_input(AVFormatContext **ps, const char *filename, AVInputFormat *fmt, AVDictionary **options)
550 AVFormatContext *s = *ps;
552 AVDictionary *tmp = NULL;
554 if (!s && !(s = avformat_alloc_context()))
555 return AVERROR(ENOMEM);
560 av_dict_copy(&tmp, *options, 0);
562 if ((ret = av_opt_set_dict(s, &tmp)) < 0)
565 if ((ret = init_input(s, filename, &tmp)) < 0)
568 /* check filename in case an image number is expected */
569 if (s->iformat->flags & AVFMT_NEEDNUMBER) {
570 if (!av_filename_number_test(filename)) {
571 ret = AVERROR(EINVAL);
576 s->duration = s->start_time = AV_NOPTS_VALUE;
577 av_strlcpy(s->filename, filename, sizeof(s->filename));
579 /* allocate private data */
580 if (s->iformat->priv_data_size > 0) {
581 if (!(s->priv_data = av_mallocz(s->iformat->priv_data_size))) {
582 ret = AVERROR(ENOMEM);
585 if (s->iformat->priv_class) {
586 *(const AVClass**)s->priv_data = s->iformat->priv_class;
587 av_opt_set_defaults(s->priv_data);
588 if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
593 /* e.g. AVFMT_NOFILE formats will not have a AVIOContext */
595 ff_id3v2_read(s, ID3v2_DEFAULT_MAGIC);
597 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->iformat->read_header)
598 if ((ret = s->iformat->read_header(s)) < 0)
601 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->pb && !s->data_offset)
602 s->data_offset = avio_tell(s->pb);
604 s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
607 av_dict_free(options);
615 if (s->pb && !(s->flags & AVFMT_FLAG_CUSTOM_IO))
617 avformat_free_context(s);
622 /*******************************************************/
624 static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
625 AVPacketList **plast_pktl){
626 AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
631 (*plast_pktl)->next = pktl;
633 *packet_buffer = pktl;
635 /* add the packet in the buffered packet list */
641 int av_read_packet(AVFormatContext *s, AVPacket *pkt)
647 AVPacketList *pktl = s->raw_packet_buffer;
651 if(s->streams[pkt->stream_index]->request_probe <= 0){
652 s->raw_packet_buffer = pktl->next;
653 s->raw_packet_buffer_remaining_size += pkt->size;
660 ret= s->iformat->read_packet(s, pkt);
662 if (!pktl || ret == AVERROR(EAGAIN))
664 for (i = 0; i < s->nb_streams; i++)
665 if(s->streams[i]->request_probe > 0)
666 s->streams[i]->request_probe = -1;
670 if ((s->flags & AVFMT_FLAG_DISCARD_CORRUPT) &&
671 (pkt->flags & AV_PKT_FLAG_CORRUPT)) {
672 av_log(s, AV_LOG_WARNING,
673 "Dropped corrupted packet (stream = %d)\n",
679 if(!(s->flags & AVFMT_FLAG_KEEP_SIDE_DATA))
680 av_packet_merge_side_data(pkt);
682 if(pkt->stream_index >= (unsigned)s->nb_streams){
683 av_log(s, AV_LOG_ERROR, "Invalid stream index %d\n", pkt->stream_index);
687 st= s->streams[pkt->stream_index];
689 switch(st->codec->codec_type){
690 case AVMEDIA_TYPE_VIDEO:
691 if(s->video_codec_id) st->codec->codec_id= s->video_codec_id;
693 case AVMEDIA_TYPE_AUDIO:
694 if(s->audio_codec_id) st->codec->codec_id= s->audio_codec_id;
696 case AVMEDIA_TYPE_SUBTITLE:
697 if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
701 if(!pktl && st->request_probe <= 0)
704 add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
705 s->raw_packet_buffer_remaining_size -= pkt->size;
707 if(st->request_probe>0){
708 AVProbeData *pd = &st->probe_data;
710 av_log(s, AV_LOG_DEBUG, "probing stream %d pp:%d\n", st->index, st->probe_packets);
713 pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
714 memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
715 pd->buf_size += pkt->size;
716 memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
718 end= s->raw_packet_buffer_remaining_size <= 0
719 || st->probe_packets<=0;
721 if(end || av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)){
722 int score= set_codec_from_probe_data(s, st, pd);
723 if( (st->codec->codec_id != CODEC_ID_NONE && score > AVPROBE_SCORE_MAX/4)
727 st->request_probe= -1;
728 if(st->codec->codec_id != CODEC_ID_NONE){
729 av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
731 av_log(s, AV_LOG_WARNING, "probed stream %d failed\n", st->index);
738 /**********************************************************/
741 * Get the number of samples of an audio frame. Return -1 on error.
743 static int get_audio_frame_size(AVCodecContext *enc, int size)
747 if(enc->codec_id == CODEC_ID_VORBIS)
750 if (enc->frame_size <= 1) {
751 int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
753 if (bits_per_sample) {
754 if (enc->channels == 0)
756 frame_size = (size << 3) / (bits_per_sample * enc->channels);
758 /* used for example by ADPCM codecs */
759 if (enc->bit_rate == 0)
761 frame_size = ((int64_t)size * 8 * enc->sample_rate) / enc->bit_rate;
764 frame_size = enc->frame_size;
771 * Return the frame duration in seconds. Return 0 if not available.
773 static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
774 AVCodecParserContext *pc, AVPacket *pkt)
780 switch(st->codec->codec_type) {
781 case AVMEDIA_TYPE_VIDEO:
782 if (st->r_frame_rate.num && !pc) {
783 *pnum = st->r_frame_rate.den;
784 *pden = st->r_frame_rate.num;
785 } else if(st->time_base.num*1000LL > st->time_base.den) {
786 *pnum = st->time_base.num;
787 *pden = st->time_base.den;
788 }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
789 *pnum = st->codec->time_base.num;
790 *pden = st->codec->time_base.den;
791 if (pc && pc->repeat_pict) {
792 *pnum = (*pnum) * (1 + pc->repeat_pict);
794 //If this codec can be interlaced or progressive then we need a parser to compute duration of a packet
795 //Thus if we have no parser in such case leave duration undefined.
796 if(st->codec->ticks_per_frame>1 && !pc){
801 case AVMEDIA_TYPE_AUDIO:
802 frame_size = get_audio_frame_size(st->codec, pkt->size);
803 if (frame_size <= 0 || st->codec->sample_rate <= 0)
806 *pden = st->codec->sample_rate;
813 static int is_intra_only(AVCodecContext *enc){
814 if(enc->codec_type == AVMEDIA_TYPE_AUDIO){
816 }else if(enc->codec_type == AVMEDIA_TYPE_VIDEO){
817 switch(enc->codec_id){
819 case CODEC_ID_MJPEGB:
821 case CODEC_ID_PRORES:
822 case CODEC_ID_RAWVIDEO:
823 case CODEC_ID_DVVIDEO:
824 case CODEC_ID_HUFFYUV:
825 case CODEC_ID_FFVHUFF:
830 case CODEC_ID_JPEG2000:
838 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
839 int64_t dts, int64_t pts)
841 AVStream *st= s->streams[stream_index];
842 AVPacketList *pktl= s->packet_buffer;
844 if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE)
847 st->first_dts= dts - st->cur_dts;
850 for(; pktl; pktl= pktl->next){
851 if(pktl->pkt.stream_index != stream_index)
853 //FIXME think more about this check
854 if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
855 pktl->pkt.pts += st->first_dts;
857 if(pktl->pkt.dts != AV_NOPTS_VALUE)
858 pktl->pkt.dts += st->first_dts;
860 if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
861 st->start_time= pktl->pkt.pts;
863 if (st->start_time == AV_NOPTS_VALUE)
864 st->start_time = pts;
867 static void update_initial_durations(AVFormatContext *s, AVStream *st, AVPacket *pkt)
869 AVPacketList *pktl= s->packet_buffer;
872 if(st->first_dts != AV_NOPTS_VALUE){
873 cur_dts= st->first_dts;
874 for(; pktl; pktl= pktl->next){
875 if(pktl->pkt.stream_index == pkt->stream_index){
876 if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
878 cur_dts -= pkt->duration;
881 pktl= s->packet_buffer;
882 st->first_dts = cur_dts;
883 }else if(st->cur_dts)
886 for(; pktl; pktl= pktl->next){
887 if(pktl->pkt.stream_index != pkt->stream_index)
889 if(pktl->pkt.pts == pktl->pkt.dts && pktl->pkt.dts == AV_NOPTS_VALUE
890 && !pktl->pkt.duration){
891 pktl->pkt.dts= cur_dts;
892 if(!st->codec->has_b_frames)
893 pktl->pkt.pts= cur_dts;
894 cur_dts += pkt->duration;
895 pktl->pkt.duration= pkt->duration;
899 if(st->first_dts == AV_NOPTS_VALUE)
900 st->cur_dts= cur_dts;
903 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
904 AVCodecParserContext *pc, AVPacket *pkt)
906 int num, den, presentation_delayed, delay, i;
909 if (s->flags & AVFMT_FLAG_NOFILLIN)
912 if((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
913 pkt->dts= AV_NOPTS_VALUE;
915 if (st->codec->codec_id != CODEC_ID_H264 && pc && pc->pict_type == AV_PICTURE_TYPE_B)
916 //FIXME Set low_delay = 0 when has_b_frames = 1
917 st->codec->has_b_frames = 1;
919 /* do we have a video B-frame ? */
920 delay= st->codec->has_b_frames;
921 presentation_delayed = 0;
923 /* XXX: need has_b_frame, but cannot get it if the codec is
926 pc && pc->pict_type != AV_PICTURE_TYPE_B)
927 presentation_delayed = 1;
929 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts - (1LL<<(st->pts_wrap_bits-1)) > pkt->pts && st->pts_wrap_bits<63){
930 pkt->dts -= 1LL<<st->pts_wrap_bits;
933 // some mpeg2 in mpeg-ps lack dts (issue171 / input_file.mpg)
934 // we take the conservative approach and discard both
935 // Note, if this is misbehaving for a H.264 file then possibly presentation_delayed is not set correctly.
936 if(delay==1 && pkt->dts == pkt->pts && pkt->dts != AV_NOPTS_VALUE && presentation_delayed){
937 av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination %"PRIi64"\n", pkt->dts);
938 pkt->dts= AV_NOPTS_VALUE;
941 if (pkt->duration == 0) {
942 compute_frame_duration(&num, &den, st, pc, pkt);
944 pkt->duration = av_rescale_rnd(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num, AV_ROUND_DOWN);
946 if(pkt->duration != 0 && s->packet_buffer)
947 update_initial_durations(s, st, pkt);
951 /* correct timestamps with byte offset if demuxers only have timestamps
952 on packet boundaries */
953 if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
954 /* this will estimate bitrate based on this frame's duration and size */
955 offset = av_rescale(pc->offset, pkt->duration, pkt->size);
956 if(pkt->pts != AV_NOPTS_VALUE)
958 if(pkt->dts != AV_NOPTS_VALUE)
962 if (pc && pc->dts_sync_point >= 0) {
963 // we have synchronization info from the parser
964 int64_t den = st->codec->time_base.den * (int64_t) st->time_base.num;
966 int64_t num = st->codec->time_base.num * (int64_t) st->time_base.den;
967 if (pkt->dts != AV_NOPTS_VALUE) {
968 // got DTS from the stream, update reference timestamp
969 st->reference_dts = pkt->dts - pc->dts_ref_dts_delta * num / den;
970 pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
971 } else if (st->reference_dts != AV_NOPTS_VALUE) {
972 // compute DTS based on reference timestamp
973 pkt->dts = st->reference_dts + pc->dts_ref_dts_delta * num / den;
974 pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
976 if (pc->dts_sync_point > 0)
977 st->reference_dts = pkt->dts; // new reference
981 /* This may be redundant, but it should not hurt. */
982 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
983 presentation_delayed = 1;
985 // 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);
986 /* interpolate PTS and DTS if they are not present */
987 //We skip H264 currently because delay and has_b_frames are not reliably set
988 if((delay==0 || (delay==1 && pc)) && st->codec->codec_id != CODEC_ID_H264){
989 if (presentation_delayed) {
990 /* DTS = decompression timestamp */
991 /* PTS = presentation timestamp */
992 if (pkt->dts == AV_NOPTS_VALUE)
993 pkt->dts = st->last_IP_pts;
994 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
995 if (pkt->dts == AV_NOPTS_VALUE)
996 pkt->dts = st->cur_dts;
998 /* this is tricky: the dts must be incremented by the duration
999 of the frame we are displaying, i.e. the last I- or P-frame */
1000 if (st->last_IP_duration == 0)
1001 st->last_IP_duration = pkt->duration;
1002 if(pkt->dts != AV_NOPTS_VALUE)
1003 st->cur_dts = pkt->dts + st->last_IP_duration;
1004 st->last_IP_duration = pkt->duration;
1005 st->last_IP_pts= pkt->pts;
1006 /* cannot compute PTS if not present (we can compute it only
1007 by knowing the future */
1008 } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
1009 if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
1010 int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
1011 int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
1012 if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
1013 pkt->pts += pkt->duration;
1014 // 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);
1018 /* presentation is not delayed : PTS and DTS are the same */
1019 if(pkt->pts == AV_NOPTS_VALUE)
1020 pkt->pts = pkt->dts;
1021 update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
1022 if(pkt->pts == AV_NOPTS_VALUE)
1023 pkt->pts = st->cur_dts;
1024 pkt->dts = pkt->pts;
1025 if(pkt->pts != AV_NOPTS_VALUE)
1026 st->cur_dts = pkt->pts + pkt->duration;
1030 if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
1031 st->pts_buffer[0]= pkt->pts;
1032 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
1033 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
1034 if(pkt->dts == AV_NOPTS_VALUE)
1035 pkt->dts= st->pts_buffer[0];
1036 if(st->codec->codec_id == CODEC_ID_H264){ // we skipped it above so we try here
1037 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
1039 if(pkt->dts > st->cur_dts)
1040 st->cur_dts = pkt->dts;
1043 // 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);
1046 if(is_intra_only(st->codec))
1047 pkt->flags |= AV_PKT_FLAG_KEY;
1050 /* keyframe computation */
1051 if (pc->key_frame == 1)
1052 pkt->flags |= AV_PKT_FLAG_KEY;
1053 else if (pc->key_frame == -1 && pc->pict_type == AV_PICTURE_TYPE_I)
1054 pkt->flags |= AV_PKT_FLAG_KEY;
1057 pkt->convergence_duration = pc->convergence_duration;
1061 static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1066 av_init_packet(pkt);
1069 /* select current input stream component */
1072 if (!st->need_parsing || !st->parser) {
1073 /* no parsing needed: we just output the packet as is */
1074 /* raw data support */
1076 st->cur_pkt.data= NULL;
1077 st->cur_pkt.side_data_elems = 0;
1078 st->cur_pkt.side_data = NULL;
1079 compute_pkt_fields(s, st, NULL, pkt);
1081 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1082 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1083 ff_reduce_index(s, st->index);
1084 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1087 } else if (st->cur_len > 0 && st->discard < AVDISCARD_ALL) {
1088 len = av_parser_parse2(st->parser, st->codec, &pkt->data, &pkt->size,
1089 st->cur_ptr, st->cur_len,
1090 st->cur_pkt.pts, st->cur_pkt.dts,
1092 st->cur_pkt.pts = AV_NOPTS_VALUE;
1093 st->cur_pkt.dts = AV_NOPTS_VALUE;
1094 /* increment read pointer */
1098 /* return packet if any */
1102 pkt->stream_index = st->index;
1103 pkt->pts = st->parser->pts;
1104 pkt->dts = st->parser->dts;
1105 pkt->pos = st->parser->pos;
1106 if(pkt->data == st->cur_pkt.data && pkt->size == st->cur_pkt.size){
1108 pkt->destruct= st->cur_pkt.destruct;
1109 st->cur_pkt.destruct= NULL;
1110 st->cur_pkt.data = NULL;
1111 assert(st->cur_len == 0);
1113 pkt->destruct = NULL;
1115 compute_pkt_fields(s, st, st->parser, pkt);
1117 if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY){
1118 int64_t pos= (st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) ? pkt->pos : st->parser->frame_offset;
1119 ff_reduce_index(s, st->index);
1120 av_add_index_entry(st, pos, pkt->dts,
1121 0, 0, AVINDEX_KEYFRAME);
1128 av_free_packet(&st->cur_pkt);
1133 /* read next packet */
1134 ret = av_read_packet(s, &cur_pkt);
1136 if (ret == AVERROR(EAGAIN))
1138 /* return the last frames, if any */
1139 for(i = 0; i < s->nb_streams; i++) {
1141 if (st->parser && st->need_parsing) {
1142 av_parser_parse2(st->parser, st->codec,
1143 &pkt->data, &pkt->size,
1145 AV_NOPTS_VALUE, AV_NOPTS_VALUE,
1151 /* no more packets: really terminate parsing */
1154 st = s->streams[cur_pkt.stream_index];
1155 st->cur_pkt= cur_pkt;
1157 if(st->cur_pkt.pts != AV_NOPTS_VALUE &&
1158 st->cur_pkt.dts != AV_NOPTS_VALUE &&
1159 st->cur_pkt.pts < st->cur_pkt.dts){
1160 av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
1161 st->cur_pkt.stream_index,
1165 // av_free_packet(&st->cur_pkt);
1169 if(s->debug & FF_FDEBUG_TS)
1170 av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1171 st->cur_pkt.stream_index,
1175 st->cur_pkt.duration,
1179 st->cur_ptr = st->cur_pkt.data;
1180 st->cur_len = st->cur_pkt.size;
1181 if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1182 st->parser = av_parser_init(st->codec->codec_id);
1184 av_log(s, AV_LOG_VERBOSE, "parser not found for codec "
1185 "%s, packets or times may be invalid.\n",
1186 avcodec_get_name(st->codec->codec_id));
1187 /* no parser available: just output the raw packets */
1188 st->need_parsing = AVSTREAM_PARSE_NONE;
1189 }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
1190 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1191 }else if(st->need_parsing == AVSTREAM_PARSE_FULL_ONCE){
1192 st->parser->flags |= PARSER_FLAG_ONCE;
1197 if(s->debug & FF_FDEBUG_TS)
1198 av_log(s, AV_LOG_DEBUG, "read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1209 static int read_from_packet_buffer(AVFormatContext *s, AVPacket *pkt)
1211 AVPacketList *pktl = s->packet_buffer;
1214 s->packet_buffer = pktl->next;
1219 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1221 const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1225 return s->packet_buffer ? read_from_packet_buffer(s, pkt) :
1226 read_frame_internal(s, pkt);
1230 AVPacketList *pktl = s->packet_buffer;
1233 AVPacket *next_pkt = &pktl->pkt;
1235 if (next_pkt->dts != AV_NOPTS_VALUE) {
1236 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1237 while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1238 if (pktl->pkt.stream_index == next_pkt->stream_index &&
1239 (av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)) < 0) &&
1240 av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) { //not b frame
1241 next_pkt->pts = pktl->pkt.dts;
1245 pktl = s->packet_buffer;
1248 /* read packet from packet buffer, if there is data */
1249 if (!(next_pkt->pts == AV_NOPTS_VALUE &&
1250 next_pkt->dts != AV_NOPTS_VALUE && !eof))
1251 return read_from_packet_buffer(s, pkt);
1254 ret = read_frame_internal(s, pkt);
1256 if (pktl && ret != AVERROR(EAGAIN)) {
1263 if (av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1264 &s->packet_buffer_end)) < 0)
1265 return AVERROR(ENOMEM);
1269 /* XXX: suppress the packet queue */
1270 static void flush_packet_queue(AVFormatContext *s)
1275 pktl = s->packet_buffer;
1278 s->packet_buffer = pktl->next;
1279 av_free_packet(&pktl->pkt);
1282 while(s->raw_packet_buffer){
1283 pktl = s->raw_packet_buffer;
1284 s->raw_packet_buffer = pktl->next;
1285 av_free_packet(&pktl->pkt);
1288 s->packet_buffer_end=
1289 s->raw_packet_buffer_end= NULL;
1290 s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1293 /*******************************************************/
1296 int av_find_default_stream_index(AVFormatContext *s)
1298 int first_audio_index = -1;
1302 if (s->nb_streams <= 0)
1304 for(i = 0; i < s->nb_streams; i++) {
1306 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1309 if (first_audio_index < 0 && st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1310 first_audio_index = i;
1312 return first_audio_index >= 0 ? first_audio_index : 0;
1316 * Flush the frame reader.
1318 void ff_read_frame_flush(AVFormatContext *s)
1323 flush_packet_queue(s);
1327 /* for each stream, reset read state */
1328 for(i = 0; i < s->nb_streams; i++) {
1332 av_parser_close(st->parser);
1334 av_free_packet(&st->cur_pkt);
1336 st->last_IP_pts = AV_NOPTS_VALUE;
1337 if(st->first_dts == AV_NOPTS_VALUE) st->cur_dts = 0;
1338 else st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1339 st->reference_dts = AV_NOPTS_VALUE;
1344 st->probe_packets = MAX_PROBE_PACKETS;
1346 for(j=0; j<MAX_REORDER_DELAY+1; j++)
1347 st->pts_buffer[j]= AV_NOPTS_VALUE;
1351 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1355 for(i = 0; i < s->nb_streams; i++) {
1356 AVStream *st = s->streams[i];
1358 st->cur_dts = av_rescale(timestamp,
1359 st->time_base.den * (int64_t)ref_st->time_base.num,
1360 st->time_base.num * (int64_t)ref_st->time_base.den);
1364 void ff_reduce_index(AVFormatContext *s, int stream_index)
1366 AVStream *st= s->streams[stream_index];
1367 unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1369 if((unsigned)st->nb_index_entries >= max_entries){
1371 for(i=0; 2*i<st->nb_index_entries; i++)
1372 st->index_entries[i]= st->index_entries[2*i];
1373 st->nb_index_entries= i;
1377 int ff_add_index_entry(AVIndexEntry **index_entries,
1378 int *nb_index_entries,
1379 unsigned int *index_entries_allocated_size,
1380 int64_t pos, int64_t timestamp, int size, int distance, int flags)
1382 AVIndexEntry *entries, *ie;
1385 if((unsigned)*nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1388 entries = av_fast_realloc(*index_entries,
1389 index_entries_allocated_size,
1390 (*nb_index_entries + 1) *
1391 sizeof(AVIndexEntry));
1395 *index_entries= entries;
1397 index= ff_index_search_timestamp(*index_entries, *nb_index_entries, timestamp, AVSEEK_FLAG_ANY);
1400 index= (*nb_index_entries)++;
1401 ie= &entries[index];
1402 assert(index==0 || ie[-1].timestamp < timestamp);
1404 ie= &entries[index];
1405 if(ie->timestamp != timestamp){
1406 if(ie->timestamp <= timestamp)
1408 memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(*nb_index_entries - index));
1409 (*nb_index_entries)++;
1410 }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1411 distance= ie->min_distance;
1415 ie->timestamp = timestamp;
1416 ie->min_distance= distance;
1423 int av_add_index_entry(AVStream *st,
1424 int64_t pos, int64_t timestamp, int size, int distance, int flags)
1426 return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1427 &st->index_entries_allocated_size, pos,
1428 timestamp, size, distance, flags);
1431 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1432 int64_t wanted_timestamp, int flags)
1440 //optimize appending index entries at the end
1441 if(b && entries[b-1].timestamp < wanted_timestamp)
1446 timestamp = entries[m].timestamp;
1447 if(timestamp >= wanted_timestamp)
1449 if(timestamp <= wanted_timestamp)
1452 m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1454 if(!(flags & AVSEEK_FLAG_ANY)){
1455 while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1456 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1465 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1468 return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
1469 wanted_timestamp, flags);
1472 int ff_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags)
1474 AVInputFormat *avif= s->iformat;
1475 int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1476 int64_t ts_min, ts_max, ts;
1481 if (stream_index < 0)
1484 av_dlog(s, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1487 ts_min= AV_NOPTS_VALUE;
1488 pos_limit= -1; //gcc falsely says it may be uninitialized
1490 st= s->streams[stream_index];
1491 if(st->index_entries){
1494 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()
1495 index= FFMAX(index, 0);
1496 e= &st->index_entries[index];
1498 if(e->timestamp <= target_ts || e->pos == e->min_distance){
1500 ts_min= e->timestamp;
1501 av_dlog(s, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1507 index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1508 assert(index < st->nb_index_entries);
1510 e= &st->index_entries[index];
1511 assert(e->timestamp >= target_ts);
1513 ts_max= e->timestamp;
1514 pos_limit= pos_max - e->min_distance;
1515 av_dlog(s, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1516 pos_max,pos_limit, ts_max);
1520 pos= ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1525 if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
1528 ff_read_frame_flush(s);
1529 ff_update_cur_dts(s, st, ts);
1534 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
1535 int64_t pos_min, int64_t pos_max, int64_t pos_limit,
1536 int64_t ts_min, int64_t ts_max, int flags, int64_t *ts_ret,
1537 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1540 int64_t start_pos, filesize;
1543 av_dlog(s, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1545 if(ts_min == AV_NOPTS_VALUE){
1546 pos_min = s->data_offset;
1547 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1548 if (ts_min == AV_NOPTS_VALUE)
1552 if(ts_min >= target_ts){
1557 if(ts_max == AV_NOPTS_VALUE){
1559 filesize = avio_size(s->pb);
1560 pos_max = filesize - 1;
1563 ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1565 }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1566 if (ts_max == AV_NOPTS_VALUE)
1570 int64_t tmp_pos= pos_max + 1;
1571 int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1572 if(tmp_ts == AV_NOPTS_VALUE)
1576 if(tmp_pos >= filesize)
1582 if(ts_max <= target_ts){
1587 if(ts_min > ts_max){
1589 }else if(ts_min == ts_max){
1594 while (pos_min < pos_limit) {
1595 av_dlog(s, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1596 pos_min, pos_max, ts_min, ts_max);
1597 assert(pos_limit <= pos_max);
1600 int64_t approximate_keyframe_distance= pos_max - pos_limit;
1601 // interpolate position (better than dichotomy)
1602 pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1603 + pos_min - approximate_keyframe_distance;
1604 }else if(no_change==1){
1605 // bisection, if interpolation failed to change min or max pos last time
1606 pos = (pos_min + pos_limit)>>1;
1608 /* linear search if bisection failed, can only happen if there
1609 are very few or no keyframes between min/max */
1614 else if(pos > pos_limit)
1618 ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1623 av_dlog(s, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64" target:%"PRId64" limit:%"PRId64" start:%"PRId64" noc:%d\n",
1624 pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts,
1625 pos_limit, start_pos, no_change);
1626 if(ts == AV_NOPTS_VALUE){
1627 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1630 assert(ts != AV_NOPTS_VALUE);
1631 if (target_ts <= ts) {
1632 pos_limit = start_pos - 1;
1636 if (target_ts >= ts) {
1642 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1643 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
1646 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1648 ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1649 av_dlog(s, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1650 pos, ts_min, target_ts, ts_max);
1656 static int seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1657 int64_t pos_min, pos_max;
1661 if (stream_index < 0)
1664 st= s->streams[stream_index];
1667 pos_min = s->data_offset;
1668 pos_max = avio_size(s->pb) - 1;
1670 if (pos < pos_min) pos= pos_min;
1671 else if(pos > pos_max) pos= pos_max;
1673 avio_seek(s->pb, pos, SEEK_SET);
1676 av_update_cur_dts(s, st, ts);
1681 static int seek_frame_generic(AVFormatContext *s,
1682 int stream_index, int64_t timestamp, int flags)
1689 st = s->streams[stream_index];
1691 index = av_index_search_timestamp(st, timestamp, flags);
1693 if(index < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
1696 if(index < 0 || index==st->nb_index_entries-1){
1700 if(st->nb_index_entries){
1701 assert(st->index_entries);
1702 ie= &st->index_entries[st->nb_index_entries-1];
1703 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1705 ff_update_cur_dts(s, st, ie->timestamp);
1707 if ((ret = avio_seek(s->pb, s->data_offset, SEEK_SET)) < 0)
1713 read_status = av_read_frame(s, &pkt);
1714 } while (read_status == AVERROR(EAGAIN));
1715 if (read_status < 0)
1717 av_free_packet(&pkt);
1718 if(stream_index == pkt.stream_index && pkt.dts > timestamp){
1719 if(pkt.flags & AV_PKT_FLAG_KEY)
1721 if(nonkey++ > 1000 && st->codec->codec_id != CODEC_ID_CDGRAPHICS){
1722 av_log(s, AV_LOG_ERROR,"seek_frame_generic failed as this stream seems to contain no keyframes after the target timestamp, %d non keyframes found\n", nonkey);
1727 index = av_index_search_timestamp(st, timestamp, flags);
1732 ff_read_frame_flush(s);
1733 AV_NOWARN_DEPRECATED(
1734 if (s->iformat->read_seek){
1735 if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1739 ie = &st->index_entries[index];
1740 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1742 ff_update_cur_dts(s, st, ie->timestamp);
1747 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1752 if (flags & AVSEEK_FLAG_BYTE) {
1753 if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
1755 ff_read_frame_flush(s);
1756 return seek_frame_byte(s, stream_index, timestamp, flags);
1759 if(stream_index < 0){
1760 stream_index= av_find_default_stream_index(s);
1761 if(stream_index < 0)
1764 st= s->streams[stream_index];
1765 /* timestamp for default must be expressed in AV_TIME_BASE units */
1766 timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1769 /* first, we try the format specific seek */
1770 AV_NOWARN_DEPRECATED(
1771 if (s->iformat->read_seek) {
1772 ff_read_frame_flush(s);
1773 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1781 if (s->iformat->read_timestamp && !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
1782 ff_read_frame_flush(s);
1783 return ff_seek_frame_binary(s, stream_index, timestamp, flags);
1784 } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
1785 ff_read_frame_flush(s);
1786 return seek_frame_generic(s, stream_index, timestamp, flags);
1792 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
1794 if(min_ts > ts || max_ts < ts)
1797 if (s->iformat->read_seek2) {
1798 ff_read_frame_flush(s);
1799 return s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
1802 if(s->iformat->read_timestamp){
1803 //try to seek via read_timestamp()
1806 //Fallback to old API if new is not implemented but old is
1807 //Note the old has somewat different sematics
1808 AV_NOWARN_DEPRECATED(
1809 if(s->iformat->read_seek || 1)
1810 return av_seek_frame(s, stream_index, ts, flags | (ts - min_ts > (uint64_t)(max_ts - ts) ? AVSEEK_FLAG_BACKWARD : 0));
1813 // try some generic seek like seek_frame_generic() but with new ts semantics
1816 /*******************************************************/
1819 * Return TRUE if the stream has accurate duration in any stream.
1821 * @return TRUE if the stream has accurate duration for at least one component.
1823 static int has_duration(AVFormatContext *ic)
1827 if(ic->duration != AV_NOPTS_VALUE)
1830 for(i = 0;i < ic->nb_streams; i++) {
1831 st = ic->streams[i];
1832 if (st->duration != AV_NOPTS_VALUE)
1839 * Estimate the stream timings from the one of each components.
1841 * Also computes the global bitrate if possible.
1843 static void update_stream_timings(AVFormatContext *ic)
1845 int64_t start_time, start_time1, start_time_text, end_time, end_time1;
1846 int64_t duration, duration1, filesize;
1850 start_time = INT64_MAX;
1851 start_time_text = INT64_MAX;
1852 end_time = INT64_MIN;
1853 duration = INT64_MIN;
1854 for(i = 0;i < ic->nb_streams; i++) {
1855 st = ic->streams[i];
1856 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
1857 start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1858 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1859 if (start_time1 < start_time_text)
1860 start_time_text = start_time1;
1862 start_time = FFMIN(start_time, start_time1);
1863 if (st->duration != AV_NOPTS_VALUE) {
1864 end_time1 = start_time1
1865 + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1866 end_time = FFMAX(end_time, end_time1);
1869 if (st->duration != AV_NOPTS_VALUE) {
1870 duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1871 duration = FFMAX(duration, duration1);
1874 if (start_time == INT64_MAX || (start_time > start_time_text && start_time - start_time_text < AV_TIME_BASE))
1875 start_time = start_time_text;
1876 if (start_time != INT64_MAX) {
1877 ic->start_time = start_time;
1878 if (end_time != INT64_MIN)
1879 duration = FFMAX(duration, end_time - start_time);
1881 if (duration != INT64_MIN && ic->duration == AV_NOPTS_VALUE) {
1882 ic->duration = duration;
1884 if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration != AV_NOPTS_VALUE) {
1885 /* compute the bitrate */
1886 ic->bit_rate = (double)filesize * 8.0 * AV_TIME_BASE /
1887 (double)ic->duration;
1891 static void fill_all_stream_timings(AVFormatContext *ic)
1896 update_stream_timings(ic);
1897 for(i = 0;i < ic->nb_streams; i++) {
1898 st = ic->streams[i];
1899 if (st->start_time == AV_NOPTS_VALUE) {
1900 if(ic->start_time != AV_NOPTS_VALUE)
1901 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1902 if(ic->duration != AV_NOPTS_VALUE)
1903 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1908 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
1910 int64_t filesize, duration;
1914 /* if bit_rate is already set, we believe it */
1915 if (ic->bit_rate <= 0) {
1917 for(i=0;i<ic->nb_streams;i++) {
1918 st = ic->streams[i];
1919 if (st->codec->bit_rate > 0)
1920 bit_rate += st->codec->bit_rate;
1922 ic->bit_rate = bit_rate;
1925 /* if duration is already set, we believe it */
1926 if (ic->duration == AV_NOPTS_VALUE &&
1927 ic->bit_rate != 0) {
1928 filesize = ic->pb ? avio_size(ic->pb) : 0;
1930 for(i = 0; i < ic->nb_streams; i++) {
1931 st = ic->streams[i];
1932 duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1933 if (st->duration == AV_NOPTS_VALUE)
1934 st->duration = duration;
1940 #define DURATION_MAX_READ_SIZE 250000
1941 #define DURATION_MAX_RETRY 3
1943 /* only usable for MPEG-PS streams */
1944 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
1946 AVPacket pkt1, *pkt = &pkt1;
1948 int read_size, i, ret;
1950 int64_t filesize, offset, duration;
1955 /* flush packet queue */
1956 flush_packet_queue(ic);
1958 for (i=0; i<ic->nb_streams; i++) {
1959 st = ic->streams[i];
1960 if (st->start_time == AV_NOPTS_VALUE && st->first_dts == AV_NOPTS_VALUE)
1961 av_log(st->codec, AV_LOG_WARNING, "start time is not set in estimate_timings_from_pts\n");
1964 av_parser_close(st->parser);
1966 av_free_packet(&st->cur_pkt);
1970 /* estimate the end time (duration) */
1971 /* XXX: may need to support wrapping */
1972 filesize = ic->pb ? avio_size(ic->pb) : 0;
1973 end_time = AV_NOPTS_VALUE;
1975 offset = filesize - (DURATION_MAX_READ_SIZE<<retry);
1979 avio_seek(ic->pb, offset, SEEK_SET);
1982 if (read_size >= DURATION_MAX_READ_SIZE<<(FFMAX(retry-1,0)))
1986 ret = av_read_packet(ic, pkt);
1987 } while(ret == AVERROR(EAGAIN));
1990 read_size += pkt->size;
1991 st = ic->streams[pkt->stream_index];
1992 if (pkt->pts != AV_NOPTS_VALUE &&
1993 (st->start_time != AV_NOPTS_VALUE ||
1994 st->first_dts != AV_NOPTS_VALUE)) {
1995 duration = end_time = pkt->pts;
1996 if (st->start_time != AV_NOPTS_VALUE)
1997 duration -= st->start_time;
1999 duration -= st->first_dts;
2001 duration += 1LL<<st->pts_wrap_bits;
2003 if (st->duration == AV_NOPTS_VALUE || st->duration < duration)
2004 st->duration = duration;
2007 av_free_packet(pkt);
2009 }while( end_time==AV_NOPTS_VALUE
2010 && filesize > (DURATION_MAX_READ_SIZE<<retry)
2011 && ++retry <= DURATION_MAX_RETRY);
2013 fill_all_stream_timings(ic);
2015 avio_seek(ic->pb, old_offset, SEEK_SET);
2016 for (i=0; i<ic->nb_streams; i++) {
2018 st->cur_dts= st->first_dts;
2019 st->last_IP_pts = AV_NOPTS_VALUE;
2020 st->reference_dts = AV_NOPTS_VALUE;
2024 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2028 /* get the file size, if possible */
2029 if (ic->iformat->flags & AVFMT_NOFILE) {
2032 file_size = avio_size(ic->pb);
2033 file_size = FFMAX(0, file_size);
2036 if ((!strcmp(ic->iformat->name, "mpeg") ||
2037 !strcmp(ic->iformat->name, "mpegts")) &&
2038 file_size && ic->pb->seekable) {
2039 /* get accurate estimate from the PTSes */
2040 estimate_timings_from_pts(ic, old_offset);
2041 } else if (has_duration(ic)) {
2042 /* at least one component has timings - we use them for all
2044 fill_all_stream_timings(ic);
2046 av_log(ic, AV_LOG_WARNING, "Estimating duration from bitrate, this may be inaccurate\n");
2047 /* less precise: use bitrate info */
2048 estimate_timings_from_bit_rate(ic);
2050 update_stream_timings(ic);
2054 AVStream av_unused *st;
2055 for(i = 0;i < ic->nb_streams; i++) {
2056 st = ic->streams[i];
2057 av_dlog(ic, "%d: start_time: %0.3f duration: %0.3f\n", i,
2058 (double) st->start_time / AV_TIME_BASE,
2059 (double) st->duration / AV_TIME_BASE);
2061 av_dlog(ic, "stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2062 (double) ic->start_time / AV_TIME_BASE,
2063 (double) ic->duration / AV_TIME_BASE,
2064 ic->bit_rate / 1000);
2068 static int has_codec_parameters(AVCodecContext *avctx)
2071 switch (avctx->codec_type) {
2072 case AVMEDIA_TYPE_AUDIO:
2073 val = avctx->sample_rate && avctx->channels && avctx->sample_fmt != AV_SAMPLE_FMT_NONE;
2074 if (!avctx->frame_size &&
2075 (avctx->codec_id == CODEC_ID_VORBIS ||
2076 avctx->codec_id == CODEC_ID_AAC ||
2077 avctx->codec_id == CODEC_ID_MP1 ||
2078 avctx->codec_id == CODEC_ID_MP2 ||
2079 avctx->codec_id == CODEC_ID_MP3 ||
2080 avctx->codec_id == CODEC_ID_CELT))
2083 case AVMEDIA_TYPE_VIDEO:
2084 val = avctx->width && avctx->pix_fmt != PIX_FMT_NONE;
2086 case AVMEDIA_TYPE_DATA:
2087 if(avctx->codec_id == CODEC_ID_NONE) return 1;
2092 return avctx->codec_id != CODEC_ID_NONE && val != 0;
2095 static int has_decode_delay_been_guessed(AVStream *st)
2097 return st->codec->codec_id != CODEC_ID_H264 ||
2098 st->info->nb_decoded_frames >= 6;
2101 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
2102 static int try_decode_frame(AVStream *st, AVPacket *avpkt, AVDictionary **options)
2105 int got_picture = 1, ret = 0;
2107 AVPacket pkt = *avpkt;
2109 if (!avcodec_is_open(st->codec)) {
2110 AVDictionary *thread_opt = NULL;
2112 codec = st->codec->codec ? st->codec->codec :
2113 avcodec_find_decoder(st->codec->codec_id);
2118 /* force thread count to 1 since the h264 decoder will not extract SPS
2119 * and PPS to extradata during multi-threaded decoding */
2120 av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
2121 ret = avcodec_open2(st->codec, codec, options ? options : &thread_opt);
2123 av_dict_free(&thread_opt);
2128 while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
2130 (!has_codec_parameters(st->codec) ||
2131 !has_decode_delay_been_guessed(st) ||
2132 (!st->codec_info_nb_frames && st->codec->codec->capabilities & CODEC_CAP_CHANNEL_CONF))) {
2134 avcodec_get_frame_defaults(&picture);
2135 switch(st->codec->codec_type) {
2136 case AVMEDIA_TYPE_VIDEO:
2137 ret = avcodec_decode_video2(st->codec, &picture,
2138 &got_picture, &pkt);
2140 case AVMEDIA_TYPE_AUDIO:
2141 ret = avcodec_decode_audio4(st->codec, &picture, &got_picture, &pkt);
2148 st->info->nb_decoded_frames++;
2154 if(!pkt.data && !got_picture)
2159 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum CodecID id)
2161 while (tags->id != CODEC_ID_NONE) {
2169 enum CodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2172 for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
2173 if(tag == tags[i].tag)
2176 for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
2177 if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
2180 return CODEC_ID_NONE;
2183 unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum CodecID id)
2186 for(i=0; tags && tags[i]; i++){
2187 int tag= ff_codec_get_tag(tags[i], id);
2193 enum CodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
2196 for(i=0; tags && tags[i]; i++){
2197 enum CodecID id= ff_codec_get_id(tags[i], tag);
2198 if(id!=CODEC_ID_NONE) return id;
2200 return CODEC_ID_NONE;
2203 static void compute_chapters_end(AVFormatContext *s)
2206 int64_t max_time = s->duration + ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
2208 for (i = 0; i < s->nb_chapters; i++)
2209 if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2210 AVChapter *ch = s->chapters[i];
2211 int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q, ch->time_base)
2214 for (j = 0; j < s->nb_chapters; j++) {
2215 AVChapter *ch1 = s->chapters[j];
2216 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base, ch->time_base);
2217 if (j != i && next_start > ch->start && next_start < end)
2220 ch->end = (end == INT64_MAX) ? ch->start : end;
2224 static int get_std_framerate(int i){
2225 if(i<60*12) return i*1001;
2226 else return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
2230 * Is the time base unreliable.
2231 * This is a heuristic to balance between quick acceptance of the values in
2232 * the headers vs. some extra checks.
2233 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2234 * MPEG-2 commonly misuses field repeat flags to store different framerates.
2235 * And there are "variable" fps files this needs to detect as well.
2237 static int tb_unreliable(AVCodecContext *c){
2238 if( c->time_base.den >= 101L*c->time_base.num
2239 || c->time_base.den < 5L*c->time_base.num
2240 /* || c->codec_tag == AV_RL32("DIVX")
2241 || c->codec_tag == AV_RL32("XVID")*/
2242 || c->codec_id == CODEC_ID_MPEG2VIDEO
2243 || c->codec_id == CODEC_ID_H264
2249 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
2251 int i, count, ret, read_size, j;
2253 AVPacket pkt1, *pkt;
2254 int64_t old_offset = avio_tell(ic->pb);
2255 int orig_nb_streams = ic->nb_streams; // new streams might appear, no options for those
2256 int flush_codecs = 1;
2258 for(i=0;i<ic->nb_streams;i++) {
2260 AVDictionary *thread_opt = NULL;
2261 st = ic->streams[i];
2263 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2264 st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2265 /* if(!st->time_base.num)
2267 if(!st->codec->time_base.num)
2268 st->codec->time_base= st->time_base;
2270 //only for the split stuff
2271 if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
2272 st->parser = av_parser_init(st->codec->codec_id);
2273 if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
2274 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2277 codec = st->codec->codec ? st->codec->codec :
2278 avcodec_find_decoder(st->codec->codec_id);
2280 /* force thread count to 1 since the h264 decoder will not extract SPS
2281 * and PPS to extradata during multi-threaded decoding */
2282 av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
2284 /* Ensure that subtitle_header is properly set. */
2285 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
2286 && codec && !st->codec->codec)
2287 avcodec_open2(st->codec, codec, options ? &options[i]
2290 //try to just open decoders, in case this is enough to get parameters
2291 if(!has_codec_parameters(st->codec)){
2292 if (codec && !st->codec->codec)
2293 avcodec_open2(st->codec, codec, options ? &options[i]
2297 av_dict_free(&thread_opt);
2300 for (i=0; i<ic->nb_streams; i++) {
2301 ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
2307 if (ff_check_interrupt(&ic->interrupt_callback)){
2309 av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2313 /* check if one codec still needs to be handled */
2314 for(i=0;i<ic->nb_streams;i++) {
2315 int fps_analyze_framecount = 20;
2317 st = ic->streams[i];
2318 if (!has_codec_parameters(st->codec))
2320 /* if the timebase is coarse (like the usual millisecond precision
2321 of mkv), we need to analyze more frames to reliably arrive at
2323 if (av_q2d(st->time_base) > 0.0005)
2324 fps_analyze_framecount *= 2;
2325 if (ic->fps_probe_size >= 0)
2326 fps_analyze_framecount = ic->fps_probe_size;
2327 /* variable fps and no guess at the real fps */
2328 if( tb_unreliable(st->codec) && !(st->r_frame_rate.num && st->avg_frame_rate.num)
2329 && st->info->duration_count < fps_analyze_framecount
2330 && st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2332 if(st->parser && st->parser->parser->split && !st->codec->extradata)
2334 if(st->first_dts == AV_NOPTS_VALUE && (st->codec->codec_type == AVMEDIA_TYPE_VIDEO || st->codec->codec_type == AVMEDIA_TYPE_AUDIO))
2337 if (i == ic->nb_streams) {
2338 /* NOTE: if the format has no header, then we need to read
2339 some packets to get most of the streams, so we cannot
2341 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2342 /* if we found the info for all the codecs, we can stop */
2344 av_log(ic, AV_LOG_DEBUG, "All info found\n");
2349 /* we did not get all the codec info, but we read too much data */
2350 if (read_size >= ic->probesize) {
2352 av_log(ic, AV_LOG_DEBUG, "Probe buffer size limit %d reached\n", ic->probesize);
2356 /* NOTE: a new stream can be added there if no header in file
2357 (AVFMTCTX_NOHEADER) */
2358 ret = read_frame_internal(ic, &pkt1);
2359 if (ret == AVERROR(EAGAIN))
2367 pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2368 if ((ret = av_dup_packet(pkt)) < 0)
2369 goto find_stream_info_err;
2371 read_size += pkt->size;
2373 st = ic->streams[pkt->stream_index];
2374 if (st->codec_info_nb_frames>1) {
2376 if (st->time_base.den > 0)
2377 t = av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
2378 if (st->avg_frame_rate.num > 0)
2379 t = FFMAX(t, av_rescale_q(st->codec_info_nb_frames, (AVRational){st->avg_frame_rate.den, st->avg_frame_rate.num}, AV_TIME_BASE_Q));
2381 if (t >= ic->max_analyze_duration) {
2382 av_log(ic, AV_LOG_WARNING, "max_analyze_duration %d reached at %"PRId64"\n", ic->max_analyze_duration, t);
2385 st->info->codec_info_duration += pkt->duration;
2388 int64_t last = st->info->last_dts;
2390 if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && pkt->dts > last){
2391 double dts= pkt->dts * av_q2d(st->time_base);
2392 int64_t duration= pkt->dts - last;
2394 // if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2395 // av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
2396 for (i=1; i<FF_ARRAY_ELEMS(st->info->duration_error[0][0]); i++) {
2397 int framerate= get_std_framerate(i);
2398 double sdts= dts*framerate/(1001*12);
2400 int ticks= lrintf(sdts+j*0.5);
2401 double error= sdts - ticks + j*0.5;
2402 st->info->duration_error[j][0][i] += error;
2403 st->info->duration_error[j][1][i] += error*error;
2406 st->info->duration_count++;
2407 // ignore the first 4 values, they might have some random jitter
2408 if (st->info->duration_count > 3)
2409 st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2411 if (last == AV_NOPTS_VALUE || st->info->duration_count <= 1)
2412 st->info->last_dts = pkt->dts;
2414 if(st->parser && st->parser->parser->split && !st->codec->extradata){
2415 int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2416 if (i > 0 && i < FF_MAX_EXTRADATA_SIZE) {
2417 st->codec->extradata_size= i;
2418 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2419 if (!st->codec->extradata)
2420 return AVERROR(ENOMEM);
2421 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2422 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2426 /* if still no information, we try to open the codec and to
2427 decompress the frame. We try to avoid that in most cases as
2428 it takes longer and uses more memory. For MPEG-4, we need to
2429 decompress for QuickTime.
2431 If CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
2432 least one frame of codec data, this makes sure the codec initializes
2433 the channel configuration and does not only trust the values from the container.
2435 try_decode_frame(st, pkt, (options && i < orig_nb_streams ) ? &options[i] : NULL);
2437 st->codec_info_nb_frames++;
2442 AVPacket empty_pkt = { 0 };
2444 av_init_packet(&empty_pkt);
2446 ret = -1; /* we could not have all the codec parameters before EOF */
2447 for(i=0;i<ic->nb_streams;i++) {
2448 st = ic->streams[i];
2450 /* flush the decoders */
2452 err = try_decode_frame(st, &empty_pkt,
2453 (options && i < orig_nb_streams) ?
2454 &options[i] : NULL);
2455 } while (err > 0 && !has_codec_parameters(st->codec));
2458 av_log(ic, AV_LOG_INFO,
2459 "decoding for stream %d failed\n", st->index);
2461 if (!has_codec_parameters(st->codec)){
2463 avcodec_string(buf, sizeof(buf), st->codec, 0);
2464 av_log(ic, AV_LOG_WARNING,
2465 "Could not find codec parameters (%s)\n", buf);
2472 // close codecs which were opened in try_decode_frame()
2473 for(i=0;i<ic->nb_streams;i++) {
2474 st = ic->streams[i];
2475 avcodec_close(st->codec);
2477 for(i=0;i<ic->nb_streams;i++) {
2478 st = ic->streams[i];
2479 if (st->codec_info_nb_frames>2 && !st->avg_frame_rate.num && st->info->codec_info_duration)
2480 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2481 (st->codec_info_nb_frames-2)*(int64_t)st->time_base.den,
2482 st->info->codec_info_duration*(int64_t)st->time_base.num, 60000);
2483 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2484 if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample){
2485 uint32_t tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2486 if(ff_find_pix_fmt(ff_raw_pix_fmt_tags, tag) == st->codec->pix_fmt)
2487 st->codec->codec_tag= tag;
2490 // the check for tb_unreliable() is not completely correct, since this is not about handling
2491 // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2492 // ipmovie.c produces.
2493 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)
2494 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);
2495 if (st->info->duration_count && !st->r_frame_rate.num
2496 && tb_unreliable(st->codec) /*&&
2497 //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2498 st->time_base.num*duration_sum[i]/st->info->duration_count*101LL > st->time_base.den*/){
2500 double best_error= 0.01;
2502 for (j=1; j<FF_ARRAY_ELEMS(st->info->duration_error[0][0]); j++) {
2505 if(st->info->codec_info_duration && st->info->codec_info_duration*av_q2d(st->time_base) < (1001*12.0)/get_std_framerate(j))
2507 if(!st->info->codec_info_duration && 1.0 < (1001*12.0)/get_std_framerate(j))
2510 int n= st->info->duration_count;
2511 double a= st->info->duration_error[k][0][j] / n;
2512 double error= st->info->duration_error[k][1][j]/n - a*a;
2514 if(error < best_error && best_error> 0.000000001){
2516 num = get_std_framerate(j);
2519 av_log(NULL, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
2522 // do not increase frame rate by more than 1 % in order to match a standard rate.
2523 if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
2524 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2527 if (!st->r_frame_rate.num){
2528 if( st->codec->time_base.den * (int64_t)st->time_base.num
2529 <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
2530 st->r_frame_rate.num = st->codec->time_base.den;
2531 st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
2533 st->r_frame_rate.num = st->time_base.den;
2534 st->r_frame_rate.den = st->time_base.num;
2537 }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2538 if(!st->codec->bits_per_coded_sample)
2539 st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2540 // set stream disposition based on audio service type
2541 switch (st->codec->audio_service_type) {
2542 case AV_AUDIO_SERVICE_TYPE_EFFECTS:
2543 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS; break;
2544 case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
2545 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED; break;
2546 case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
2547 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED; break;
2548 case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
2549 st->disposition = AV_DISPOSITION_COMMENT; break;
2550 case AV_AUDIO_SERVICE_TYPE_KARAOKE:
2551 st->disposition = AV_DISPOSITION_KARAOKE; break;
2556 estimate_timings(ic, old_offset);
2558 compute_chapters_end(ic);
2561 /* correct DTS for B-frame streams with no timestamps */
2562 for(i=0;i<ic->nb_streams;i++) {
2563 st = ic->streams[i];
2564 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2566 ppktl = &ic->packet_buffer;
2568 if(ppkt1->stream_index != i)
2570 if(ppkt1->pkt->dts < 0)
2572 if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2574 ppkt1->pkt->dts -= delta;
2579 st->cur_dts -= delta;
2585 find_stream_info_err:
2586 for (i=0; i < ic->nb_streams; i++) {
2587 if (ic->streams[i]->codec)
2588 ic->streams[i]->codec->thread_count = 0;
2589 av_freep(&ic->streams[i]->info);
2594 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
2598 for (i = 0; i < ic->nb_programs; i++) {
2599 if (ic->programs[i] == last) {
2603 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
2604 if (ic->programs[i]->stream_index[j] == s)
2605 return ic->programs[i];
2611 int av_find_best_stream(AVFormatContext *ic,
2612 enum AVMediaType type,
2613 int wanted_stream_nb,
2615 AVCodec **decoder_ret,
2618 int i, nb_streams = ic->nb_streams;
2619 int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1;
2620 unsigned *program = NULL;
2621 AVCodec *decoder = NULL, *best_decoder = NULL;
2623 if (related_stream >= 0 && wanted_stream_nb < 0) {
2624 AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
2626 program = p->stream_index;
2627 nb_streams = p->nb_stream_indexes;
2630 for (i = 0; i < nb_streams; i++) {
2631 int real_stream_index = program ? program[i] : i;
2632 AVStream *st = ic->streams[real_stream_index];
2633 AVCodecContext *avctx = st->codec;
2634 if (avctx->codec_type != type)
2636 if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
2638 if (st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED|AV_DISPOSITION_VISUAL_IMPAIRED))
2641 decoder = avcodec_find_decoder(st->codec->codec_id);
2644 ret = AVERROR_DECODER_NOT_FOUND;
2648 if (best_count >= st->codec_info_nb_frames)
2650 best_count = st->codec_info_nb_frames;
2651 ret = real_stream_index;
2652 best_decoder = decoder;
2653 if (program && i == nb_streams - 1 && ret < 0) {
2655 nb_streams = ic->nb_streams;
2656 i = 0; /* no related stream found, try again with everything */
2660 *decoder_ret = best_decoder;
2664 /*******************************************************/
2666 int av_read_play(AVFormatContext *s)
2668 if (s->iformat->read_play)
2669 return s->iformat->read_play(s);
2671 return avio_pause(s->pb, 0);
2672 return AVERROR(ENOSYS);
2675 int av_read_pause(AVFormatContext *s)
2677 if (s->iformat->read_pause)
2678 return s->iformat->read_pause(s);
2680 return avio_pause(s->pb, 1);
2681 return AVERROR(ENOSYS);
2684 void avformat_free_context(AVFormatContext *s)
2690 if (s->iformat && s->iformat->priv_class && s->priv_data)
2691 av_opt_free(s->priv_data);
2693 for(i=0;i<s->nb_streams;i++) {
2694 /* free all data in a stream component */
2697 av_parser_close(st->parser);
2698 av_free_packet(&st->cur_pkt);
2700 av_dict_free(&st->metadata);
2701 av_freep(&st->index_entries);
2702 av_freep(&st->codec->extradata);
2703 av_freep(&st->codec->subtitle_header);
2704 av_freep(&st->codec);
2705 av_freep(&st->priv_data);
2706 av_freep(&st->info);
2709 for(i=s->nb_programs-1; i>=0; i--) {
2710 av_dict_free(&s->programs[i]->metadata);
2711 av_freep(&s->programs[i]->stream_index);
2712 av_freep(&s->programs[i]);
2714 av_freep(&s->programs);
2715 av_freep(&s->priv_data);
2716 while(s->nb_chapters--) {
2717 av_dict_free(&s->chapters[s->nb_chapters]->metadata);
2718 av_freep(&s->chapters[s->nb_chapters]);
2720 av_freep(&s->chapters);
2721 av_dict_free(&s->metadata);
2722 av_freep(&s->streams);
2726 #if FF_API_CLOSE_INPUT_FILE
2727 void av_close_input_file(AVFormatContext *s)
2729 avformat_close_input(&s);
2733 void avformat_close_input(AVFormatContext **ps)
2735 AVFormatContext *s = *ps;
2736 AVIOContext *pb = (s->iformat && (s->iformat->flags & AVFMT_NOFILE)) || (s->flags & AVFMT_FLAG_CUSTOM_IO) ?
2738 flush_packet_queue(s);
2739 if (s->iformat && (s->iformat->read_close))
2740 s->iformat->read_close(s);
2741 avformat_free_context(s);
2747 AVStream *avformat_new_stream(AVFormatContext *s, AVCodec *c)
2753 if (s->nb_streams >= INT_MAX/sizeof(*streams))
2755 streams = av_realloc(s->streams, (s->nb_streams + 1) * sizeof(*streams));
2758 s->streams = streams;
2760 st = av_mallocz(sizeof(AVStream));
2763 if (!(st->info = av_mallocz(sizeof(*st->info)))) {
2768 st->codec = avcodec_alloc_context3(c);
2770 /* no default bitrate if decoding */
2771 st->codec->bit_rate = 0;
2773 st->index = s->nb_streams;
2774 st->start_time = AV_NOPTS_VALUE;
2775 st->duration = AV_NOPTS_VALUE;
2776 /* we set the current DTS to 0 so that formats without any timestamps
2777 but durations get some timestamps, formats with some unknown
2778 timestamps have their first few packets buffered and the
2779 timestamps corrected before they are returned to the user */
2781 st->first_dts = AV_NOPTS_VALUE;
2782 st->probe_packets = MAX_PROBE_PACKETS;
2784 /* default pts setting is MPEG-like */
2785 avpriv_set_pts_info(st, 33, 1, 90000);
2786 st->last_IP_pts = AV_NOPTS_VALUE;
2787 for(i=0; i<MAX_REORDER_DELAY+1; i++)
2788 st->pts_buffer[i]= AV_NOPTS_VALUE;
2789 st->reference_dts = AV_NOPTS_VALUE;
2791 st->sample_aspect_ratio = (AVRational){0,1};
2793 s->streams[s->nb_streams++] = st;
2797 AVProgram *av_new_program(AVFormatContext *ac, int id)
2799 AVProgram *program=NULL;
2802 av_dlog(ac, "new_program: id=0x%04x\n", id);
2804 for(i=0; i<ac->nb_programs; i++)
2805 if(ac->programs[i]->id == id)
2806 program = ac->programs[i];
2809 program = av_mallocz(sizeof(AVProgram));
2812 dynarray_add(&ac->programs, &ac->nb_programs, program);
2813 program->discard = AVDISCARD_NONE;
2820 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2822 AVChapter *chapter = NULL;
2825 for(i=0; i<s->nb_chapters; i++)
2826 if(s->chapters[i]->id == id)
2827 chapter = s->chapters[i];
2830 chapter= av_mallocz(sizeof(AVChapter));
2833 dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2835 av_dict_set(&chapter->metadata, "title", title, 0);
2837 chapter->time_base= time_base;
2838 chapter->start = start;
2844 /************************************************************/
2845 /* output media file */
2847 int avformat_alloc_output_context2(AVFormatContext **avctx, AVOutputFormat *oformat,
2848 const char *format, const char *filename)
2850 AVFormatContext *s = avformat_alloc_context();
2859 oformat = av_guess_format(format, NULL, NULL);
2861 av_log(s, AV_LOG_ERROR, "Requested output format '%s' is not a suitable output format\n", format);
2862 ret = AVERROR(EINVAL);
2866 oformat = av_guess_format(NULL, filename, NULL);
2868 ret = AVERROR(EINVAL);
2869 av_log(s, AV_LOG_ERROR, "Unable to find a suitable output format for '%s'\n",
2876 s->oformat = oformat;
2877 if (s->oformat->priv_data_size > 0) {
2878 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2881 if (s->oformat->priv_class) {
2882 *(const AVClass**)s->priv_data= s->oformat->priv_class;
2883 av_opt_set_defaults(s->priv_data);
2886 s->priv_data = NULL;
2889 av_strlcpy(s->filename, filename, sizeof(s->filename));
2893 av_log(s, AV_LOG_ERROR, "Out of memory\n");
2894 ret = AVERROR(ENOMEM);
2896 avformat_free_context(s);
2900 #if FF_API_ALLOC_OUTPUT_CONTEXT
2901 AVFormatContext *avformat_alloc_output_context(const char *format,
2902 AVOutputFormat *oformat, const char *filename)
2904 AVFormatContext *avctx;
2905 int ret = avformat_alloc_output_context2(&avctx, oformat, format, filename);
2906 return ret < 0 ? NULL : avctx;
2910 static int validate_codec_tag(AVFormatContext *s, AVStream *st)
2912 const AVCodecTag *avctag;
2914 enum CodecID id = CODEC_ID_NONE;
2915 unsigned int tag = 0;
2918 * Check that tag + id is in the table
2919 * If neither is in the table -> OK
2920 * If tag is in the table with another id -> FAIL
2921 * If id is in the table with another tag -> FAIL unless strict < normal
2923 for (n = 0; s->oformat->codec_tag[n]; n++) {
2924 avctag = s->oformat->codec_tag[n];
2925 while (avctag->id != CODEC_ID_NONE) {
2926 if (avpriv_toupper4(avctag->tag) == avpriv_toupper4(st->codec->codec_tag)) {
2928 if (id == st->codec->codec_id)
2931 if (avctag->id == st->codec->codec_id)
2936 if (id != CODEC_ID_NONE)
2938 if (tag && (st->codec->strict_std_compliance >= FF_COMPLIANCE_NORMAL))
2943 int avformat_write_header(AVFormatContext *s, AVDictionary **options)
2947 AVDictionary *tmp = NULL;
2950 av_dict_copy(&tmp, *options, 0);
2951 if ((ret = av_opt_set_dict(s, &tmp)) < 0)
2953 if (s->priv_data && s->oformat->priv_class && *(const AVClass**)s->priv_data==s->oformat->priv_class &&
2954 (ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
2957 // some sanity checks
2958 if (s->nb_streams == 0 && !(s->oformat->flags & AVFMT_NOSTREAMS)) {
2959 av_log(s, AV_LOG_ERROR, "no streams\n");
2960 ret = AVERROR(EINVAL);
2964 for(i=0;i<s->nb_streams;i++) {
2967 switch (st->codec->codec_type) {
2968 case AVMEDIA_TYPE_AUDIO:
2969 if(st->codec->sample_rate<=0){
2970 av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2971 ret = AVERROR(EINVAL);
2974 if(!st->codec->block_align)
2975 st->codec->block_align = st->codec->channels *
2976 av_get_bits_per_sample(st->codec->codec_id) >> 3;
2978 case AVMEDIA_TYPE_VIDEO:
2979 if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2980 av_log(s, AV_LOG_ERROR, "time base not set\n");
2981 ret = AVERROR(EINVAL);
2984 if((st->codec->width<=0 || st->codec->height<=0) && !(s->oformat->flags & AVFMT_NODIMENSIONS)){
2985 av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2986 ret = AVERROR(EINVAL);
2989 if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)
2990 && FFABS(av_q2d(st->sample_aspect_ratio) - av_q2d(st->codec->sample_aspect_ratio)) > 0.004*av_q2d(st->sample_aspect_ratio)
2992 av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between encoder "
2993 "(%d/%d) and muxer layer (%d/%d)\n",
2994 st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
2995 st->codec->sample_aspect_ratio.num,
2996 st->codec->sample_aspect_ratio.den);
2997 ret = AVERROR(EINVAL);
3003 if(s->oformat->codec_tag){
3004 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)){
3005 //the current rawvideo encoding system ends up setting the wrong codec_tag for avi, we override it here
3006 st->codec->codec_tag= 0;
3008 if(st->codec->codec_tag){
3009 if (!validate_codec_tag(s, st)) {
3011 av_get_codec_tag_string(tagbuf, sizeof(tagbuf), st->codec->codec_tag);
3012 av_log(s, AV_LOG_ERROR,
3013 "Tag %s/0x%08x incompatible with output codec id '%d'\n",
3014 tagbuf, st->codec->codec_tag, st->codec->codec_id);
3015 ret = AVERROR_INVALIDDATA;
3019 st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
3022 if(s->oformat->flags & AVFMT_GLOBALHEADER &&
3023 !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
3024 av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
3027 if (!s->priv_data && s->oformat->priv_data_size > 0) {
3028 s->priv_data = av_mallocz(s->oformat->priv_data_size);
3029 if (!s->priv_data) {
3030 ret = AVERROR(ENOMEM);
3033 if (s->oformat->priv_class) {
3034 *(const AVClass**)s->priv_data= s->oformat->priv_class;
3035 av_opt_set_defaults(s->priv_data);
3036 if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
3041 /* set muxer identification string */
3042 if (s->nb_streams && !(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
3043 av_dict_set(&s->metadata, "encoder", LIBAVFORMAT_IDENT, 0);
3046 if(s->oformat->write_header){
3047 ret = s->oformat->write_header(s);
3052 /* init PTS generation */
3053 for(i=0;i<s->nb_streams;i++) {
3054 int64_t den = AV_NOPTS_VALUE;
3057 switch (st->codec->codec_type) {
3058 case AVMEDIA_TYPE_AUDIO:
3059 den = (int64_t)st->time_base.num * st->codec->sample_rate;
3061 case AVMEDIA_TYPE_VIDEO:
3062 den = (int64_t)st->time_base.num * st->codec->time_base.den;
3067 if (den != AV_NOPTS_VALUE) {
3069 ret = AVERROR_INVALIDDATA;
3072 frac_init(&st->pts, 0, 0, den);
3077 av_dict_free(options);
3086 //FIXME merge with compute_pkt_fields
3087 static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt){
3088 int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
3089 int num, den, frame_size, i;
3091 av_dlog(s, "compute_pkt_fields2: pts:%"PRId64" dts:%"PRId64" cur_dts:%"PRId64" b:%d size:%d st:%d\n",
3092 pkt->pts, pkt->dts, st->cur_dts, delay, pkt->size, pkt->stream_index);
3094 /* duration field */
3095 if (pkt->duration == 0) {
3096 compute_frame_duration(&num, &den, st, NULL, pkt);
3098 pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
3102 if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
3105 //XXX/FIXME this is a temporary hack until all encoders output pts
3106 if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
3108 // pkt->pts= st->cur_dts;
3109 pkt->pts= st->pts.val;
3112 //calculate dts from pts
3113 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
3114 st->pts_buffer[0]= pkt->pts;
3115 for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
3116 st->pts_buffer[i]= pkt->pts + (i-delay-1) * pkt->duration;
3117 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
3118 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
3120 pkt->dts= st->pts_buffer[0];
3123 if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && ((!(s->oformat->flags & AVFMT_TS_NONSTRICT) && st->cur_dts >= pkt->dts) || st->cur_dts > pkt->dts)){
3124 av_log(s, AV_LOG_ERROR,
3125 "Application provided invalid, non monotonically increasing dts to muxer in stream %d: %"PRId64" >= %"PRId64"\n",
3126 st->index, st->cur_dts, pkt->dts);
3127 return AVERROR(EINVAL);
3129 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
3130 av_log(s, AV_LOG_ERROR, "pts < dts in stream %d\n", st->index);
3131 return AVERROR(EINVAL);
3134 // av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
3135 st->cur_dts= pkt->dts;
3136 st->pts.val= pkt->dts;
3139 switch (st->codec->codec_type) {
3140 case AVMEDIA_TYPE_AUDIO:
3141 frame_size = get_audio_frame_size(st->codec, pkt->size);
3143 /* HACK/FIXME, we skip the initial 0 size packets as they are most
3144 likely equal to the encoder delay, but it would be better if we
3145 had the real timestamps from the encoder */
3146 if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
3147 frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
3150 case AVMEDIA_TYPE_VIDEO:
3151 frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
3159 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
3164 if (s->oformat->flags & AVFMT_ALLOW_FLUSH)
3165 return s->oformat->write_packet(s, pkt);
3169 ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt);
3171 if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3174 ret= s->oformat->write_packet(s, pkt);
3177 s->streams[pkt->stream_index]->nb_frames++;
3181 #define CHUNK_START 0x1000
3183 int ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
3184 int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
3186 AVPacketList **next_point, *this_pktl;
3187 AVStream *st= s->streams[pkt->stream_index];
3188 int chunked= s->max_chunk_size || s->max_chunk_duration;
3190 this_pktl = av_mallocz(sizeof(AVPacketList));
3192 return AVERROR(ENOMEM);
3193 this_pktl->pkt= *pkt;
3194 pkt->destruct= NULL; // do not free original but only the copy
3195 av_dup_packet(&this_pktl->pkt); // duplicate the packet if it uses non-alloced memory
3197 if(s->streams[pkt->stream_index]->last_in_packet_buffer){
3198 next_point = &(st->last_in_packet_buffer->next);
3200 next_point = &s->packet_buffer;
3205 uint64_t max= av_rescale_q(s->max_chunk_duration, AV_TIME_BASE_Q, st->time_base);
3206 if( st->interleaver_chunk_size + pkt->size <= s->max_chunk_size-1U
3207 && st->interleaver_chunk_duration + pkt->duration <= max-1U){
3208 st->interleaver_chunk_size += pkt->size;
3209 st->interleaver_chunk_duration += pkt->duration;
3212 st->interleaver_chunk_size =
3213 st->interleaver_chunk_duration = 0;
3214 this_pktl->pkt.flags |= CHUNK_START;
3218 if(compare(s, &s->packet_buffer_end->pkt, pkt)){
3220 && ((chunked && !((*next_point)->pkt.flags&CHUNK_START))
3221 || !compare(s, &(*next_point)->pkt, pkt))){
3222 next_point= &(*next_point)->next;
3227 next_point = &(s->packet_buffer_end->next);
3230 assert(!*next_point);
3232 s->packet_buffer_end= this_pktl;
3235 this_pktl->next= *next_point;
3237 s->streams[pkt->stream_index]->last_in_packet_buffer=
3238 *next_point= this_pktl;
3242 static int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
3244 AVStream *st = s->streams[ pkt ->stream_index];
3245 AVStream *st2= s->streams[ next->stream_index];
3246 int comp = av_compare_ts(next->dts, st2->time_base, pkt->dts,
3248 if(s->audio_preload && ((st->codec->codec_type == AVMEDIA_TYPE_AUDIO) != (st2->codec->codec_type == AVMEDIA_TYPE_AUDIO))){
3249 int64_t ts = av_rescale_q(pkt ->dts, st ->time_base, AV_TIME_BASE_Q) - s->audio_preload*(st ->codec->codec_type == AVMEDIA_TYPE_AUDIO);
3250 int64_t ts2= av_rescale_q(next->dts, st2->time_base, AV_TIME_BASE_Q) - s->audio_preload*(st2->codec->codec_type == AVMEDIA_TYPE_AUDIO);
3252 ts= ( pkt ->dts* st->time_base.num*AV_TIME_BASE - s->audio_preload*(int64_t)(st ->codec->codec_type == AVMEDIA_TYPE_AUDIO)* st->time_base.den)*st2->time_base.den
3253 -( next->dts*st2->time_base.num*AV_TIME_BASE - s->audio_preload*(int64_t)(st2->codec->codec_type == AVMEDIA_TYPE_AUDIO)*st2->time_base.den)* st->time_base.den;
3256 comp= (ts>ts2) - (ts<ts2);
3260 return pkt->stream_index < next->stream_index;
3264 int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
3266 int stream_count=0, noninterleaved_count=0;
3267 int64_t delta_dts_max = 0;
3271 ret = ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
3276 for(i=0; i < s->nb_streams; i++) {
3277 if (s->streams[i]->last_in_packet_buffer) {
3279 } else if(s->streams[i]->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3280 ++noninterleaved_count;
3284 if (s->nb_streams == stream_count) {
3287 for(i=0; i < s->nb_streams; i++) {
3288 if (s->streams[i]->last_in_packet_buffer) {
3290 av_rescale_q(s->streams[i]->last_in_packet_buffer->pkt.dts,
3291 s->streams[i]->time_base,
3293 av_rescale_q(s->packet_buffer->pkt.dts,
3294 s->streams[s->packet_buffer->pkt.stream_index]->time_base,
3296 delta_dts_max= FFMAX(delta_dts_max, delta_dts);
3299 if(s->nb_streams == stream_count+noninterleaved_count &&
3300 delta_dts_max > 20*AV_TIME_BASE) {
3301 av_log(s, AV_LOG_DEBUG, "flushing with %d noninterleaved\n", noninterleaved_count);
3305 if(stream_count && flush){
3306 pktl= s->packet_buffer;
3309 s->packet_buffer= pktl->next;
3310 if(!s->packet_buffer)
3311 s->packet_buffer_end= NULL;
3313 if(s->streams[out->stream_index]->last_in_packet_buffer == pktl)
3314 s->streams[out->stream_index]->last_in_packet_buffer= NULL;
3318 av_init_packet(out);
3324 * Interleave an AVPacket correctly so it can be muxed.
3325 * @param out the interleaved packet will be output here
3326 * @param in the input packet
3327 * @param flush 1 if no further packets are available as input and all
3328 * remaining packets should be output
3329 * @return 1 if a packet was output, 0 if no packet could be output,
3330 * < 0 if an error occurred
3332 static int interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
3333 if (s->oformat->interleave_packet) {
3334 int ret = s->oformat->interleave_packet(s, out, in, flush);
3339 return av_interleave_packet_per_dts(s, out, in, flush);
3342 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
3343 AVStream *st= s->streams[ pkt->stream_index];
3346 //FIXME/XXX/HACK drop zero sized packets
3347 if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO && pkt->size==0)
3350 av_dlog(s, "av_interleaved_write_frame size:%d dts:%"PRId64" pts:%"PRId64"\n",
3351 pkt->size, pkt->dts, pkt->pts);
3352 if((ret = compute_pkt_fields2(s, st, pkt)) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3355 if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3356 return AVERROR(EINVAL);
3360 int ret= interleave_packet(s, &opkt, pkt, 0);
3361 if(ret<=0) //FIXME cleanup needed for ret<0 ?
3364 ret= s->oformat->write_packet(s, &opkt);
3366 s->streams[opkt.stream_index]->nb_frames++;
3368 av_free_packet(&opkt);
3373 if(s->pb && s->pb->error)
3374 return s->pb->error;
3378 int av_write_trailer(AVFormatContext *s)
3384 ret= interleave_packet(s, &pkt, NULL, 1);
3385 if(ret<0) //FIXME cleanup needed for ret<0 ?
3390 ret= s->oformat->write_packet(s, &pkt);
3392 s->streams[pkt.stream_index]->nb_frames++;
3394 av_free_packet(&pkt);
3398 if(s->pb && s->pb->error)
3402 if(s->oformat->write_trailer)
3403 ret = s->oformat->write_trailer(s);
3406 ret = s->pb ? s->pb->error : 0;
3407 for(i=0;i<s->nb_streams;i++) {
3408 av_freep(&s->streams[i]->priv_data);
3409 av_freep(&s->streams[i]->index_entries);
3411 if (s->oformat->priv_class)
3412 av_opt_free(s->priv_data);
3413 av_freep(&s->priv_data);
3417 int av_get_output_timestamp(struct AVFormatContext *s, int stream,
3418 int64_t *dts, int64_t *wall)
3420 if (!s->oformat || !s->oformat->get_output_timestamp)
3421 return AVERROR(ENOSYS);
3422 s->oformat->get_output_timestamp(s, stream, dts, wall);
3426 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
3429 AVProgram *program=NULL;
3432 if (idx >= ac->nb_streams) {
3433 av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3437 for(i=0; i<ac->nb_programs; i++){
3438 if(ac->programs[i]->id != progid)
3440 program = ac->programs[i];
3441 for(j=0; j<program->nb_stream_indexes; j++)
3442 if(program->stream_index[j] == idx)
3445 tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
3448 program->stream_index = tmp;
3449 program->stream_index[program->nb_stream_indexes++] = idx;
3454 static void print_fps(double d, const char *postfix){
3455 uint64_t v= lrintf(d*100);
3456 if (v% 100 ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3457 else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3458 else av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
3461 static void dump_metadata(void *ctx, AVDictionary *m, const char *indent)
3463 if(m && !(m->count == 1 && av_dict_get(m, "language", NULL, 0))){
3464 AVDictionaryEntry *tag=NULL;
3466 av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3467 while((tag=av_dict_get(m, "", tag, AV_DICT_IGNORE_SUFFIX))) {
3468 if(strcmp("language", tag->key)){
3471 av_strlcpy(tmp, tag->value, sizeof(tmp));
3472 for(i=0; i<strlen(tmp); i++) if(tmp[i]==0xd) tmp[i]=' ';
3473 av_log(ctx, AV_LOG_INFO, "%s %-16s: %s\n", indent, tag->key, tmp);
3479 /* "user interface" functions */
3480 static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
3483 int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
3484 AVStream *st = ic->streams[i];
3485 int g = av_gcd(st->time_base.num, st->time_base.den);
3486 AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL, 0);
3487 avcodec_string(buf, sizeof(buf), st->codec, is_output);
3488 av_log(NULL, AV_LOG_INFO, " Stream #%d:%d", index, i);
3489 /* the pid is an important information, so we display it */
3490 /* XXX: add a generic system */
3491 if (flags & AVFMT_SHOW_IDS)
3492 av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
3494 av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
3495 av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames, st->time_base.num/g, st->time_base.den/g);
3496 av_log(NULL, AV_LOG_INFO, ": %s", buf);
3497 if (st->sample_aspect_ratio.num && // default
3498 av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
3499 AVRational display_aspect_ratio;
3500 av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
3501 st->codec->width*st->sample_aspect_ratio.num,
3502 st->codec->height*st->sample_aspect_ratio.den,
3504 av_log(NULL, AV_LOG_INFO, ", SAR %d:%d DAR %d:%d",
3505 st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3506 display_aspect_ratio.num, display_aspect_ratio.den);
3508 if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
3509 if(st->avg_frame_rate.den && st->avg_frame_rate.num)
3510 print_fps(av_q2d(st->avg_frame_rate), "fps");
3511 if(st->r_frame_rate.den && st->r_frame_rate.num)
3512 print_fps(av_q2d(st->r_frame_rate), "tbr");
3513 if(st->time_base.den && st->time_base.num)
3514 print_fps(1/av_q2d(st->time_base), "tbn");
3515 if(st->codec->time_base.den && st->codec->time_base.num)
3516 print_fps(1/av_q2d(st->codec->time_base), "tbc");
3518 if (st->disposition & AV_DISPOSITION_DEFAULT)
3519 av_log(NULL, AV_LOG_INFO, " (default)");
3520 if (st->disposition & AV_DISPOSITION_DUB)
3521 av_log(NULL, AV_LOG_INFO, " (dub)");
3522 if (st->disposition & AV_DISPOSITION_ORIGINAL)
3523 av_log(NULL, AV_LOG_INFO, " (original)");
3524 if (st->disposition & AV_DISPOSITION_COMMENT)
3525 av_log(NULL, AV_LOG_INFO, " (comment)");
3526 if (st->disposition & AV_DISPOSITION_LYRICS)
3527 av_log(NULL, AV_LOG_INFO, " (lyrics)");
3528 if (st->disposition & AV_DISPOSITION_KARAOKE)
3529 av_log(NULL, AV_LOG_INFO, " (karaoke)");
3530 if (st->disposition & AV_DISPOSITION_FORCED)
3531 av_log(NULL, AV_LOG_INFO, " (forced)");
3532 if (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED)
3533 av_log(NULL, AV_LOG_INFO, " (hearing impaired)");
3534 if (st->disposition & AV_DISPOSITION_VISUAL_IMPAIRED)
3535 av_log(NULL, AV_LOG_INFO, " (visual impaired)");
3536 if (st->disposition & AV_DISPOSITION_CLEAN_EFFECTS)
3537 av_log(NULL, AV_LOG_INFO, " (clean effects)");
3538 av_log(NULL, AV_LOG_INFO, "\n");
3539 dump_metadata(NULL, st->metadata, " ");
3542 void av_dump_format(AVFormatContext *ic,
3548 uint8_t *printed = ic->nb_streams ? av_mallocz(ic->nb_streams) : NULL;
3549 if (ic->nb_streams && !printed)
3552 av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3553 is_output ? "Output" : "Input",
3555 is_output ? ic->oformat->name : ic->iformat->name,
3556 is_output ? "to" : "from", url);
3557 dump_metadata(NULL, ic->metadata, " ");
3559 av_log(NULL, AV_LOG_INFO, " Duration: ");
3560 if (ic->duration != AV_NOPTS_VALUE) {
3561 int hours, mins, secs, us;
3562 secs = ic->duration / AV_TIME_BASE;
3563 us = ic->duration % AV_TIME_BASE;
3568 av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3569 (100 * us) / AV_TIME_BASE);
3571 av_log(NULL, AV_LOG_INFO, "N/A");
3573 if (ic->start_time != AV_NOPTS_VALUE) {
3575 av_log(NULL, AV_LOG_INFO, ", start: ");
3576 secs = ic->start_time / AV_TIME_BASE;
3577 us = abs(ic->start_time % AV_TIME_BASE);
3578 av_log(NULL, AV_LOG_INFO, "%d.%06d",
3579 secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
3581 av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3583 av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
3585 av_log(NULL, AV_LOG_INFO, "N/A");
3587 av_log(NULL, AV_LOG_INFO, "\n");
3589 for (i = 0; i < ic->nb_chapters; i++) {
3590 AVChapter *ch = ic->chapters[i];
3591 av_log(NULL, AV_LOG_INFO, " Chapter #%d.%d: ", index, i);
3592 av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
3593 av_log(NULL, AV_LOG_INFO, "end %f\n", ch->end * av_q2d(ch->time_base));
3595 dump_metadata(NULL, ch->metadata, " ");
3597 if(ic->nb_programs) {
3598 int j, k, total = 0;
3599 for(j=0; j<ic->nb_programs; j++) {
3600 AVDictionaryEntry *name = av_dict_get(ic->programs[j]->metadata,
3602 av_log(NULL, AV_LOG_INFO, " Program %d %s\n", ic->programs[j]->id,
3603 name ? name->value : "");
3604 dump_metadata(NULL, ic->programs[j]->metadata, " ");
3605 for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3606 dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3607 printed[ic->programs[j]->stream_index[k]] = 1;
3609 total += ic->programs[j]->nb_stream_indexes;
3611 if (total < ic->nb_streams)
3612 av_log(NULL, AV_LOG_INFO, " No Program\n");
3614 for(i=0;i<ic->nb_streams;i++)
3616 dump_stream_format(ic, i, index, is_output);
3621 int64_t av_gettime(void)
3624 gettimeofday(&tv,NULL);
3625 return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
3628 uint64_t ff_ntp_time(void)
3630 return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3633 int av_get_frame_filename(char *buf, int buf_size,
3634 const char *path, int number)
3637 char *q, buf1[20], c;
3638 int nd, len, percentd_found;
3650 while (isdigit(*p)) {
3651 nd = nd * 10 + *p++ - '0';
3654 } while (isdigit(c));
3663 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3665 if ((q - buf + len) > buf_size - 1)
3667 memcpy(q, buf1, len);
3675 if ((q - buf) < buf_size - 1)
3679 if (!percentd_found)
3688 static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3692 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3694 for(i=0;i<size;i+=16) {
3701 PRINT(" %02x", buf[i+j]);
3706 for(j=0;j<len;j++) {
3708 if (c < ' ' || c > '~')
3717 void av_hex_dump(FILE *f, uint8_t *buf, int size)
3719 hex_dump_internal(NULL, f, 0, buf, size);
3722 void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3724 hex_dump_internal(avcl, NULL, level, buf, size);
3727 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload, AVRational time_base)
3730 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3731 PRINT("stream #%d:\n", pkt->stream_index);
3732 PRINT(" keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
3733 PRINT(" duration=%0.3f\n", pkt->duration * av_q2d(time_base));
3734 /* DTS is _always_ valid after av_read_frame() */
3736 if (pkt->dts == AV_NOPTS_VALUE)
3739 PRINT("%0.3f", pkt->dts * av_q2d(time_base));
3740 /* PTS may not be known if B-frames are present. */
3742 if (pkt->pts == AV_NOPTS_VALUE)
3745 PRINT("%0.3f", pkt->pts * av_q2d(time_base));
3747 PRINT(" size=%d\n", pkt->size);
3750 av_hex_dump(f, pkt->data, pkt->size);
3754 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3756 AVRational tb = { 1, AV_TIME_BASE };
3757 pkt_dump_internal(NULL, f, 0, pkt, dump_payload, tb);
3761 void av_pkt_dump2(FILE *f, AVPacket *pkt, int dump_payload, AVStream *st)
3763 pkt_dump_internal(NULL, f, 0, pkt, dump_payload, st->time_base);
3767 void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3769 AVRational tb = { 1, AV_TIME_BASE };
3770 pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, tb);
3774 void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload,
3777 pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, st->time_base);
3780 void av_url_split(char *proto, int proto_size,
3781 char *authorization, int authorization_size,
3782 char *hostname, int hostname_size,
3784 char *path, int path_size,
3787 const char *p, *ls, *at, *col, *brk;
3789 if (port_ptr) *port_ptr = -1;
3790 if (proto_size > 0) proto[0] = 0;
3791 if (authorization_size > 0) authorization[0] = 0;
3792 if (hostname_size > 0) hostname[0] = 0;
3793 if (path_size > 0) path[0] = 0;
3795 /* parse protocol */
3796 if ((p = strchr(url, ':'))) {
3797 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3802 /* no protocol means plain filename */
3803 av_strlcpy(path, url, path_size);
3807 /* separate path from hostname */
3808 ls = strchr(p, '/');
3810 ls = strchr(p, '?');
3812 av_strlcpy(path, ls, path_size);
3814 ls = &p[strlen(p)]; // XXX
3816 /* the rest is hostname, use that to parse auth/port */
3818 /* authorization (user[:pass]@hostname) */
3819 if ((at = strchr(p, '@')) && at < ls) {
3820 av_strlcpy(authorization, p,
3821 FFMIN(authorization_size, at + 1 - p));
3822 p = at + 1; /* skip '@' */
3825 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3827 av_strlcpy(hostname, p + 1,
3828 FFMIN(hostname_size, brk - p));
3829 if (brk[1] == ':' && port_ptr)
3830 *port_ptr = atoi(brk + 2);
3831 } else if ((col = strchr(p, ':')) && col < ls) {
3832 av_strlcpy(hostname, p,
3833 FFMIN(col + 1 - p, hostname_size));
3834 if (port_ptr) *port_ptr = atoi(col + 1);
3836 av_strlcpy(hostname, p,
3837 FFMIN(ls + 1 - p, hostname_size));
3841 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3844 static const char hex_table_uc[16] = { '0', '1', '2', '3',
3847 'C', 'D', 'E', 'F' };
3848 static const char hex_table_lc[16] = { '0', '1', '2', '3',
3851 'c', 'd', 'e', 'f' };
3852 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3854 for(i = 0; i < s; i++) {
3855 buff[i * 2] = hex_table[src[i] >> 4];
3856 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3862 int ff_hex_to_data(uint8_t *data, const char *p)
3869 p += strspn(p, SPACE_CHARS);
3872 c = toupper((unsigned char) *p++);
3873 if (c >= '0' && c <= '9')
3875 else if (c >= 'A' && c <= 'F')
3890 #if FF_API_SET_PTS_INFO
3891 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3892 unsigned int pts_num, unsigned int pts_den)
3894 avpriv_set_pts_info(s, pts_wrap_bits, pts_num, pts_den);
3898 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
3899 unsigned int pts_num, unsigned int pts_den)
3902 if(av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)){
3903 if(new_tb.num != pts_num)
3904 av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/new_tb.num);
3906 av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3908 if(new_tb.num <= 0 || new_tb.den <= 0) {
3909 av_log(NULL, AV_LOG_ERROR, "Ignoring attempt to set invalid timebase for st:%d\n", s->index);
3912 s->time_base = new_tb;
3913 s->pts_wrap_bits = pts_wrap_bits;
3916 int ff_url_join(char *str, int size, const char *proto,
3917 const char *authorization, const char *hostname,
3918 int port, const char *fmt, ...)
3921 struct addrinfo hints, *ai;
3926 av_strlcatf(str, size, "%s://", proto);
3927 if (authorization && authorization[0])
3928 av_strlcatf(str, size, "%s@", authorization);
3929 #if CONFIG_NETWORK && defined(AF_INET6)
3930 /* Determine if hostname is a numerical IPv6 address,
3931 * properly escape it within [] in that case. */
3932 memset(&hints, 0, sizeof(hints));
3933 hints.ai_flags = AI_NUMERICHOST;
3934 if (!getaddrinfo(hostname, NULL, &hints, &ai)) {
3935 if (ai->ai_family == AF_INET6) {
3936 av_strlcat(str, "[", size);
3937 av_strlcat(str, hostname, size);
3938 av_strlcat(str, "]", size);
3940 av_strlcat(str, hostname, size);
3945 /* Not an IPv6 address, just output the plain string. */
3946 av_strlcat(str, hostname, size);
3949 av_strlcatf(str, size, ":%d", port);
3952 int len = strlen(str);
3955 vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);
3961 int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
3962 AVFormatContext *src)
3967 local_pkt.stream_index = dst_stream;
3968 if (pkt->pts != AV_NOPTS_VALUE)
3969 local_pkt.pts = av_rescale_q(pkt->pts,
3970 src->streams[pkt->stream_index]->time_base,
3971 dst->streams[dst_stream]->time_base);
3972 if (pkt->dts != AV_NOPTS_VALUE)
3973 local_pkt.dts = av_rescale_q(pkt->dts,
3974 src->streams[pkt->stream_index]->time_base,
3975 dst->streams[dst_stream]->time_base);
3976 return av_write_frame(dst, &local_pkt);
3979 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
3982 const char *ptr = str;
3984 /* Parse key=value pairs. */
3987 char *dest = NULL, *dest_end;
3988 int key_len, dest_len = 0;
3990 /* Skip whitespace and potential commas. */
3991 while (*ptr && (isspace(*ptr) || *ptr == ','))
3998 if (!(ptr = strchr(key, '=')))
4001 key_len = ptr - key;
4003 callback_get_buf(context, key, key_len, &dest, &dest_len);
4004 dest_end = dest + dest_len - 1;
4008 while (*ptr && *ptr != '\"') {
4012 if (dest && dest < dest_end)
4016 if (dest && dest < dest_end)
4024 for (; *ptr && !(isspace(*ptr) || *ptr == ','); ptr++)
4025 if (dest && dest < dest_end)
4033 int ff_find_stream_index(AVFormatContext *s, int id)
4036 for (i = 0; i < s->nb_streams; i++) {
4037 if (s->streams[i]->id == id)
4043 void ff_make_absolute_url(char *buf, int size, const char *base,
4047 /* Absolute path, relative to the current server */
4048 if (base && strstr(base, "://") && rel[0] == '/') {
4050 av_strlcpy(buf, base, size);
4051 sep = strstr(buf, "://");
4054 sep = strchr(sep, '/');
4058 av_strlcat(buf, rel, size);
4061 /* If rel actually is an absolute url, just copy it */
4062 if (!base || strstr(rel, "://") || rel[0] == '/') {
4063 av_strlcpy(buf, rel, size);
4067 av_strlcpy(buf, base, size);
4068 /* Remove the file name from the base url */
4069 sep = strrchr(buf, '/');
4074 while (av_strstart(rel, "../", NULL) && sep) {
4075 /* Remove the path delimiter at the end */
4077 sep = strrchr(buf, '/');
4078 /* If the next directory name to pop off is "..", break here */
4079 if (!strcmp(sep ? &sep[1] : buf, "..")) {
4080 /* Readd the slash we just removed */
4081 av_strlcat(buf, "/", size);
4084 /* Cut off the directory name */
4091 av_strlcat(buf, rel, size);
4094 int64_t ff_iso8601_to_unix_time(const char *datestr)
4097 struct tm time1 = {0}, time2 = {0};
4099 ret1 = strptime(datestr, "%Y - %m - %d %T", &time1);
4100 ret2 = strptime(datestr, "%Y - %m - %dT%T", &time2);
4102 return av_timegm(&time2);
4104 return av_timegm(&time1);
4106 av_log(NULL, AV_LOG_WARNING, "strptime() unavailable on this system, cannot convert "
4107 "the date string.\n");
4112 int avformat_query_codec(AVOutputFormat *ofmt, enum CodecID codec_id, int std_compliance)
4115 if (ofmt->query_codec)
4116 return ofmt->query_codec(codec_id, std_compliance);
4117 else if (ofmt->codec_tag)
4118 return !!av_codec_get_tag(ofmt->codec_tag, codec_id);
4119 else if (codec_id == ofmt->video_codec || codec_id == ofmt->audio_codec ||
4120 codec_id == ofmt->subtitle_codec)
4123 return AVERROR_PATCHWELCOME;
4126 int avformat_network_init(void)
4130 ff_network_inited_globally = 1;
4131 if ((ret = ff_network_init()) < 0)
4138 int avformat_network_deinit(void)
4147 int ff_add_param_change(AVPacket *pkt, int32_t channels,
4148 uint64_t channel_layout, int32_t sample_rate,
4149 int32_t width, int32_t height)
4155 return AVERROR(EINVAL);
4158 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
4160 if (channel_layout) {
4162 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
4166 flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
4168 if (width || height) {
4170 flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
4172 data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
4174 return AVERROR(ENOMEM);
4175 bytestream_put_le32(&data, flags);
4177 bytestream_put_le32(&data, channels);
4179 bytestream_put_le64(&data, channel_layout);
4181 bytestream_put_le32(&data, sample_rate);
4182 if (width || height) {
4183 bytestream_put_le32(&data, width);
4184 bytestream_put_le32(&data, height);
4189 const struct AVCodecTag *avformat_get_riff_video_tags(void)
4191 return ff_codec_bmp_tags;
4193 const struct AVCodecTag *avformat_get_riff_audio_tags(void)
4195 return ff_codec_wav_tags;