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);
947 if(pkt->duration != 0 && s->packet_buffer)
948 update_initial_durations(s, st, pkt);
950 /* correct timestamps with byte offset if demuxers only have timestamps
951 on packet boundaries */
952 if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
953 /* this will estimate bitrate based on this frame's duration and size */
954 offset = av_rescale(pc->offset, pkt->duration, pkt->size);
955 if(pkt->pts != AV_NOPTS_VALUE)
957 if(pkt->dts != AV_NOPTS_VALUE)
961 if (pc && pc->dts_sync_point >= 0) {
962 // we have synchronization info from the parser
963 int64_t den = st->codec->time_base.den * (int64_t) st->time_base.num;
965 int64_t num = st->codec->time_base.num * (int64_t) st->time_base.den;
966 if (pkt->dts != AV_NOPTS_VALUE) {
967 // got DTS from the stream, update reference timestamp
968 st->reference_dts = pkt->dts - pc->dts_ref_dts_delta * num / den;
969 pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
970 } else if (st->reference_dts != AV_NOPTS_VALUE) {
971 // compute DTS based on reference timestamp
972 pkt->dts = st->reference_dts + pc->dts_ref_dts_delta * num / den;
973 pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
975 if (pc->dts_sync_point > 0)
976 st->reference_dts = pkt->dts; // new reference
980 /* This may be redundant, but it should not hurt. */
981 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
982 presentation_delayed = 1;
984 // 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);
985 /* interpolate PTS and DTS if they are not present */
986 //We skip H264 currently because delay and has_b_frames are not reliably set
987 if((delay==0 || (delay==1 && pc)) && st->codec->codec_id != CODEC_ID_H264){
988 if (presentation_delayed) {
989 /* DTS = decompression timestamp */
990 /* PTS = presentation timestamp */
991 if (pkt->dts == AV_NOPTS_VALUE)
992 pkt->dts = st->last_IP_pts;
993 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
994 if (pkt->dts == AV_NOPTS_VALUE)
995 pkt->dts = st->cur_dts;
997 /* this is tricky: the dts must be incremented by the duration
998 of the frame we are displaying, i.e. the last I- or P-frame */
999 if (st->last_IP_duration == 0)
1000 st->last_IP_duration = pkt->duration;
1001 if(pkt->dts != AV_NOPTS_VALUE)
1002 st->cur_dts = pkt->dts + st->last_IP_duration;
1003 st->last_IP_duration = pkt->duration;
1004 st->last_IP_pts= pkt->pts;
1005 /* cannot compute PTS if not present (we can compute it only
1006 by knowing the future */
1007 } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
1008 if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
1009 int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
1010 int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
1011 if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
1012 pkt->pts += pkt->duration;
1013 // 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);
1017 /* presentation is not delayed : PTS and DTS are the same */
1018 if(pkt->pts == AV_NOPTS_VALUE)
1019 pkt->pts = pkt->dts;
1020 update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
1021 if(pkt->pts == AV_NOPTS_VALUE)
1022 pkt->pts = st->cur_dts;
1023 pkt->dts = pkt->pts;
1024 if(pkt->pts != AV_NOPTS_VALUE)
1025 st->cur_dts = pkt->pts + pkt->duration;
1029 if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
1030 st->pts_buffer[0]= pkt->pts;
1031 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
1032 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
1033 if(pkt->dts == AV_NOPTS_VALUE)
1034 pkt->dts= st->pts_buffer[0];
1035 if(st->codec->codec_id == CODEC_ID_H264){ // we skipped it above so we try here
1036 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
1038 if(pkt->dts > st->cur_dts)
1039 st->cur_dts = pkt->dts;
1042 // 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);
1045 if(is_intra_only(st->codec))
1046 pkt->flags |= AV_PKT_FLAG_KEY;
1049 /* keyframe computation */
1050 if (pc->key_frame == 1)
1051 pkt->flags |= AV_PKT_FLAG_KEY;
1052 else if (pc->key_frame == -1 && pc->pict_type == AV_PICTURE_TYPE_I)
1053 pkt->flags |= AV_PKT_FLAG_KEY;
1056 pkt->convergence_duration = pc->convergence_duration;
1060 static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1065 av_init_packet(pkt);
1068 /* select current input stream component */
1071 if (!st->need_parsing || !st->parser) {
1072 /* no parsing needed: we just output the packet as is */
1073 /* raw data support */
1075 st->cur_pkt.data= NULL;
1076 st->cur_pkt.side_data_elems = 0;
1077 st->cur_pkt.side_data = NULL;
1078 compute_pkt_fields(s, st, NULL, pkt);
1080 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1081 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1082 ff_reduce_index(s, st->index);
1083 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1086 } else if (st->cur_len > 0 && st->discard < AVDISCARD_ALL) {
1087 len = av_parser_parse2(st->parser, st->codec, &pkt->data, &pkt->size,
1088 st->cur_ptr, st->cur_len,
1089 st->cur_pkt.pts, st->cur_pkt.dts,
1091 st->cur_pkt.pts = AV_NOPTS_VALUE;
1092 st->cur_pkt.dts = AV_NOPTS_VALUE;
1093 /* increment read pointer */
1097 /* return packet if any */
1101 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1102 if (st->codec->sample_rate > 0) {
1103 pkt->duration = av_rescale_q_rnd(st->parser->duration,
1104 (AVRational){ 1, st->codec->sample_rate },
1108 } else if (st->codec->time_base.num != 0 &&
1109 st->codec->time_base.den != 0) {
1110 pkt->duration = av_rescale_q_rnd(st->parser->duration,
1111 st->codec->time_base,
1115 pkt->stream_index = st->index;
1116 pkt->pts = st->parser->pts;
1117 pkt->dts = st->parser->dts;
1118 pkt->pos = st->parser->pos;
1119 if(pkt->data == st->cur_pkt.data && pkt->size == st->cur_pkt.size){
1121 pkt->destruct= st->cur_pkt.destruct;
1122 st->cur_pkt.destruct= NULL;
1123 st->cur_pkt.data = NULL;
1124 assert(st->cur_len == 0);
1126 pkt->destruct = NULL;
1128 compute_pkt_fields(s, st, st->parser, pkt);
1130 if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY){
1131 int64_t pos= (st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) ? pkt->pos : st->parser->frame_offset;
1132 ff_reduce_index(s, st->index);
1133 av_add_index_entry(st, pos, pkt->dts,
1134 0, 0, AVINDEX_KEYFRAME);
1141 av_free_packet(&st->cur_pkt);
1146 /* read next packet */
1147 ret = av_read_packet(s, &cur_pkt);
1149 if (ret == AVERROR(EAGAIN))
1151 /* return the last frames, if any */
1152 for(i = 0; i < s->nb_streams; i++) {
1154 if (st->parser && st->need_parsing) {
1155 av_parser_parse2(st->parser, st->codec,
1156 &pkt->data, &pkt->size,
1158 AV_NOPTS_VALUE, AV_NOPTS_VALUE,
1164 /* no more packets: really terminate parsing */
1167 st = s->streams[cur_pkt.stream_index];
1168 st->cur_pkt= cur_pkt;
1170 if(st->cur_pkt.pts != AV_NOPTS_VALUE &&
1171 st->cur_pkt.dts != AV_NOPTS_VALUE &&
1172 st->cur_pkt.pts < st->cur_pkt.dts){
1173 av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
1174 st->cur_pkt.stream_index,
1178 // av_free_packet(&st->cur_pkt);
1182 if(s->debug & FF_FDEBUG_TS)
1183 av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1184 st->cur_pkt.stream_index,
1188 st->cur_pkt.duration,
1192 st->cur_ptr = st->cur_pkt.data;
1193 st->cur_len = st->cur_pkt.size;
1194 if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1195 st->parser = av_parser_init(st->codec->codec_id);
1197 av_log(s, AV_LOG_VERBOSE, "parser not found for codec "
1198 "%s, packets or times may be invalid.\n",
1199 avcodec_get_name(st->codec->codec_id));
1200 /* no parser available: just output the raw packets */
1201 st->need_parsing = AVSTREAM_PARSE_NONE;
1202 }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
1203 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1204 }else if(st->need_parsing == AVSTREAM_PARSE_FULL_ONCE){
1205 st->parser->flags |= PARSER_FLAG_ONCE;
1210 if(s->debug & FF_FDEBUG_TS)
1211 av_log(s, AV_LOG_DEBUG, "read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1222 static int read_from_packet_buffer(AVFormatContext *s, AVPacket *pkt)
1224 AVPacketList *pktl = s->packet_buffer;
1227 s->packet_buffer = pktl->next;
1232 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1234 const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1238 return s->packet_buffer ? read_from_packet_buffer(s, pkt) :
1239 read_frame_internal(s, pkt);
1243 AVPacketList *pktl = s->packet_buffer;
1246 AVPacket *next_pkt = &pktl->pkt;
1248 if (next_pkt->dts != AV_NOPTS_VALUE) {
1249 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1250 while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1251 if (pktl->pkt.stream_index == next_pkt->stream_index &&
1252 (av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)) < 0) &&
1253 av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) { //not b frame
1254 next_pkt->pts = pktl->pkt.dts;
1258 pktl = s->packet_buffer;
1261 /* read packet from packet buffer, if there is data */
1262 if (!(next_pkt->pts == AV_NOPTS_VALUE &&
1263 next_pkt->dts != AV_NOPTS_VALUE && !eof))
1264 return read_from_packet_buffer(s, pkt);
1267 ret = read_frame_internal(s, pkt);
1269 if (pktl && ret != AVERROR(EAGAIN)) {
1276 if (av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1277 &s->packet_buffer_end)) < 0)
1278 return AVERROR(ENOMEM);
1282 /* XXX: suppress the packet queue */
1283 static void flush_packet_queue(AVFormatContext *s)
1288 pktl = s->packet_buffer;
1291 s->packet_buffer = pktl->next;
1292 av_free_packet(&pktl->pkt);
1295 while(s->raw_packet_buffer){
1296 pktl = s->raw_packet_buffer;
1297 s->raw_packet_buffer = pktl->next;
1298 av_free_packet(&pktl->pkt);
1301 s->packet_buffer_end=
1302 s->raw_packet_buffer_end= NULL;
1303 s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1306 /*******************************************************/
1309 int av_find_default_stream_index(AVFormatContext *s)
1311 int first_audio_index = -1;
1315 if (s->nb_streams <= 0)
1317 for(i = 0; i < s->nb_streams; i++) {
1319 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1322 if (first_audio_index < 0 && st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1323 first_audio_index = i;
1325 return first_audio_index >= 0 ? first_audio_index : 0;
1329 * Flush the frame reader.
1331 void ff_read_frame_flush(AVFormatContext *s)
1336 flush_packet_queue(s);
1340 /* for each stream, reset read state */
1341 for(i = 0; i < s->nb_streams; i++) {
1345 av_parser_close(st->parser);
1347 av_free_packet(&st->cur_pkt);
1349 st->last_IP_pts = AV_NOPTS_VALUE;
1350 if(st->first_dts == AV_NOPTS_VALUE) st->cur_dts = 0;
1351 else st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1352 st->reference_dts = AV_NOPTS_VALUE;
1357 st->probe_packets = MAX_PROBE_PACKETS;
1359 for(j=0; j<MAX_REORDER_DELAY+1; j++)
1360 st->pts_buffer[j]= AV_NOPTS_VALUE;
1364 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1368 for(i = 0; i < s->nb_streams; i++) {
1369 AVStream *st = s->streams[i];
1371 st->cur_dts = av_rescale(timestamp,
1372 st->time_base.den * (int64_t)ref_st->time_base.num,
1373 st->time_base.num * (int64_t)ref_st->time_base.den);
1377 void ff_reduce_index(AVFormatContext *s, int stream_index)
1379 AVStream *st= s->streams[stream_index];
1380 unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1382 if((unsigned)st->nb_index_entries >= max_entries){
1384 for(i=0; 2*i<st->nb_index_entries; i++)
1385 st->index_entries[i]= st->index_entries[2*i];
1386 st->nb_index_entries= i;
1390 int ff_add_index_entry(AVIndexEntry **index_entries,
1391 int *nb_index_entries,
1392 unsigned int *index_entries_allocated_size,
1393 int64_t pos, int64_t timestamp, int size, int distance, int flags)
1395 AVIndexEntry *entries, *ie;
1398 if((unsigned)*nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1401 entries = av_fast_realloc(*index_entries,
1402 index_entries_allocated_size,
1403 (*nb_index_entries + 1) *
1404 sizeof(AVIndexEntry));
1408 *index_entries= entries;
1410 index= ff_index_search_timestamp(*index_entries, *nb_index_entries, timestamp, AVSEEK_FLAG_ANY);
1413 index= (*nb_index_entries)++;
1414 ie= &entries[index];
1415 assert(index==0 || ie[-1].timestamp < timestamp);
1417 ie= &entries[index];
1418 if(ie->timestamp != timestamp){
1419 if(ie->timestamp <= timestamp)
1421 memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(*nb_index_entries - index));
1422 (*nb_index_entries)++;
1423 }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1424 distance= ie->min_distance;
1428 ie->timestamp = timestamp;
1429 ie->min_distance= distance;
1436 int av_add_index_entry(AVStream *st,
1437 int64_t pos, int64_t timestamp, int size, int distance, int flags)
1439 return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1440 &st->index_entries_allocated_size, pos,
1441 timestamp, size, distance, flags);
1444 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1445 int64_t wanted_timestamp, int flags)
1453 //optimize appending index entries at the end
1454 if(b && entries[b-1].timestamp < wanted_timestamp)
1459 timestamp = entries[m].timestamp;
1460 if(timestamp >= wanted_timestamp)
1462 if(timestamp <= wanted_timestamp)
1465 m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1467 if(!(flags & AVSEEK_FLAG_ANY)){
1468 while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1469 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1478 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1481 return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
1482 wanted_timestamp, flags);
1485 int ff_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags)
1487 AVInputFormat *avif= s->iformat;
1488 int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1489 int64_t ts_min, ts_max, ts;
1494 if (stream_index < 0)
1497 av_dlog(s, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1500 ts_min= AV_NOPTS_VALUE;
1501 pos_limit= -1; //gcc falsely says it may be uninitialized
1503 st= s->streams[stream_index];
1504 if(st->index_entries){
1507 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()
1508 index= FFMAX(index, 0);
1509 e= &st->index_entries[index];
1511 if(e->timestamp <= target_ts || e->pos == e->min_distance){
1513 ts_min= e->timestamp;
1514 av_dlog(s, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1520 index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1521 assert(index < st->nb_index_entries);
1523 e= &st->index_entries[index];
1524 assert(e->timestamp >= target_ts);
1526 ts_max= e->timestamp;
1527 pos_limit= pos_max - e->min_distance;
1528 av_dlog(s, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1529 pos_max,pos_limit, ts_max);
1533 pos= ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1538 if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
1541 ff_read_frame_flush(s);
1542 ff_update_cur_dts(s, st, ts);
1547 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
1548 int64_t pos_min, int64_t pos_max, int64_t pos_limit,
1549 int64_t ts_min, int64_t ts_max, int flags, int64_t *ts_ret,
1550 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1553 int64_t start_pos, filesize;
1556 av_dlog(s, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1558 if(ts_min == AV_NOPTS_VALUE){
1559 pos_min = s->data_offset;
1560 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1561 if (ts_min == AV_NOPTS_VALUE)
1565 if(ts_min >= target_ts){
1570 if(ts_max == AV_NOPTS_VALUE){
1572 filesize = avio_size(s->pb);
1573 pos_max = filesize - 1;
1576 ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1578 }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1579 if (ts_max == AV_NOPTS_VALUE)
1583 int64_t tmp_pos= pos_max + 1;
1584 int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1585 if(tmp_ts == AV_NOPTS_VALUE)
1589 if(tmp_pos >= filesize)
1595 if(ts_max <= target_ts){
1600 if(ts_min > ts_max){
1602 }else if(ts_min == ts_max){
1607 while (pos_min < pos_limit) {
1608 av_dlog(s, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1609 pos_min, pos_max, ts_min, ts_max);
1610 assert(pos_limit <= pos_max);
1613 int64_t approximate_keyframe_distance= pos_max - pos_limit;
1614 // interpolate position (better than dichotomy)
1615 pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1616 + pos_min - approximate_keyframe_distance;
1617 }else if(no_change==1){
1618 // bisection, if interpolation failed to change min or max pos last time
1619 pos = (pos_min + pos_limit)>>1;
1621 /* linear search if bisection failed, can only happen if there
1622 are very few or no keyframes between min/max */
1627 else if(pos > pos_limit)
1631 ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1636 av_dlog(s, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64" target:%"PRId64" limit:%"PRId64" start:%"PRId64" noc:%d\n",
1637 pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts,
1638 pos_limit, start_pos, no_change);
1639 if(ts == AV_NOPTS_VALUE){
1640 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1643 assert(ts != AV_NOPTS_VALUE);
1644 if (target_ts <= ts) {
1645 pos_limit = start_pos - 1;
1649 if (target_ts >= ts) {
1655 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1656 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
1659 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1661 ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1662 av_dlog(s, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1663 pos, ts_min, target_ts, ts_max);
1669 static int seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1670 int64_t pos_min, pos_max;
1674 if (stream_index < 0)
1677 st= s->streams[stream_index];
1680 pos_min = s->data_offset;
1681 pos_max = avio_size(s->pb) - 1;
1683 if (pos < pos_min) pos= pos_min;
1684 else if(pos > pos_max) pos= pos_max;
1686 avio_seek(s->pb, pos, SEEK_SET);
1689 av_update_cur_dts(s, st, ts);
1694 static int seek_frame_generic(AVFormatContext *s,
1695 int stream_index, int64_t timestamp, int flags)
1702 st = s->streams[stream_index];
1704 index = av_index_search_timestamp(st, timestamp, flags);
1706 if(index < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
1709 if(index < 0 || index==st->nb_index_entries-1){
1713 if(st->nb_index_entries){
1714 assert(st->index_entries);
1715 ie= &st->index_entries[st->nb_index_entries-1];
1716 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1718 ff_update_cur_dts(s, st, ie->timestamp);
1720 if ((ret = avio_seek(s->pb, s->data_offset, SEEK_SET)) < 0)
1726 read_status = av_read_frame(s, &pkt);
1727 } while (read_status == AVERROR(EAGAIN));
1728 if (read_status < 0)
1730 av_free_packet(&pkt);
1731 if(stream_index == pkt.stream_index && pkt.dts > timestamp){
1732 if(pkt.flags & AV_PKT_FLAG_KEY)
1734 if(nonkey++ > 1000 && st->codec->codec_id != CODEC_ID_CDGRAPHICS){
1735 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);
1740 index = av_index_search_timestamp(st, timestamp, flags);
1745 ff_read_frame_flush(s);
1746 AV_NOWARN_DEPRECATED(
1747 if (s->iformat->read_seek){
1748 if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1752 ie = &st->index_entries[index];
1753 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1755 ff_update_cur_dts(s, st, ie->timestamp);
1760 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1765 if (flags & AVSEEK_FLAG_BYTE) {
1766 if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
1768 ff_read_frame_flush(s);
1769 return seek_frame_byte(s, stream_index, timestamp, flags);
1772 if(stream_index < 0){
1773 stream_index= av_find_default_stream_index(s);
1774 if(stream_index < 0)
1777 st= s->streams[stream_index];
1778 /* timestamp for default must be expressed in AV_TIME_BASE units */
1779 timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1782 /* first, we try the format specific seek */
1783 AV_NOWARN_DEPRECATED(
1784 if (s->iformat->read_seek) {
1785 ff_read_frame_flush(s);
1786 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1794 if (s->iformat->read_timestamp && !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
1795 ff_read_frame_flush(s);
1796 return ff_seek_frame_binary(s, stream_index, timestamp, flags);
1797 } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
1798 ff_read_frame_flush(s);
1799 return seek_frame_generic(s, stream_index, timestamp, flags);
1805 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
1807 if(min_ts > ts || max_ts < ts)
1810 if (s->iformat->read_seek2) {
1811 ff_read_frame_flush(s);
1812 return s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
1815 if(s->iformat->read_timestamp){
1816 //try to seek via read_timestamp()
1819 //Fallback to old API if new is not implemented but old is
1820 //Note the old has somewat different sematics
1821 AV_NOWARN_DEPRECATED(
1822 if (s->iformat->read_seek || 1) {
1823 int dir = (ts - min_ts > (uint64_t)(max_ts - ts) ? AVSEEK_FLAG_BACKWARD : 0);
1824 int ret = av_seek_frame(s, stream_index, ts, flags | dir);
1825 if (ret<0 && ts != min_ts && max_ts != ts) {
1826 ret = av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
1828 ret = av_seek_frame(s, stream_index, ts, flags | (dir^AVSEEK_FLAG_BACKWARD));
1834 // try some generic seek like seek_frame_generic() but with new ts semantics
1837 /*******************************************************/
1840 * Return TRUE if the stream has accurate duration in any stream.
1842 * @return TRUE if the stream has accurate duration for at least one component.
1844 static int has_duration(AVFormatContext *ic)
1848 if(ic->duration != AV_NOPTS_VALUE)
1851 for(i = 0;i < ic->nb_streams; i++) {
1852 st = ic->streams[i];
1853 if (st->duration != AV_NOPTS_VALUE)
1860 * Estimate the stream timings from the one of each components.
1862 * Also computes the global bitrate if possible.
1864 static void update_stream_timings(AVFormatContext *ic)
1866 int64_t start_time, start_time1, start_time_text, end_time, end_time1;
1867 int64_t duration, duration1, filesize;
1871 start_time = INT64_MAX;
1872 start_time_text = INT64_MAX;
1873 end_time = INT64_MIN;
1874 duration = INT64_MIN;
1875 for(i = 0;i < ic->nb_streams; i++) {
1876 st = ic->streams[i];
1877 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
1878 start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1879 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1880 if (start_time1 < start_time_text)
1881 start_time_text = start_time1;
1883 start_time = FFMIN(start_time, start_time1);
1884 if (st->duration != AV_NOPTS_VALUE) {
1885 end_time1 = start_time1
1886 + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1887 end_time = FFMAX(end_time, end_time1);
1890 if (st->duration != AV_NOPTS_VALUE) {
1891 duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1892 duration = FFMAX(duration, duration1);
1895 if (start_time == INT64_MAX || (start_time > start_time_text && start_time - start_time_text < AV_TIME_BASE))
1896 start_time = start_time_text;
1897 if (start_time != INT64_MAX) {
1898 ic->start_time = start_time;
1899 if (end_time != INT64_MIN)
1900 duration = FFMAX(duration, end_time - start_time);
1902 if (duration != INT64_MIN && ic->duration == AV_NOPTS_VALUE) {
1903 ic->duration = duration;
1905 if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration != AV_NOPTS_VALUE) {
1906 /* compute the bitrate */
1907 ic->bit_rate = (double)filesize * 8.0 * AV_TIME_BASE /
1908 (double)ic->duration;
1912 static void fill_all_stream_timings(AVFormatContext *ic)
1917 update_stream_timings(ic);
1918 for(i = 0;i < ic->nb_streams; i++) {
1919 st = ic->streams[i];
1920 if (st->start_time == AV_NOPTS_VALUE) {
1921 if(ic->start_time != AV_NOPTS_VALUE)
1922 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1923 if(ic->duration != AV_NOPTS_VALUE)
1924 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1929 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
1931 int64_t filesize, duration;
1935 /* if bit_rate is already set, we believe it */
1936 if (ic->bit_rate <= 0) {
1938 for(i=0;i<ic->nb_streams;i++) {
1939 st = ic->streams[i];
1940 if (st->codec->bit_rate > 0)
1941 bit_rate += st->codec->bit_rate;
1943 ic->bit_rate = bit_rate;
1946 /* if duration is already set, we believe it */
1947 if (ic->duration == AV_NOPTS_VALUE &&
1948 ic->bit_rate != 0) {
1949 filesize = ic->pb ? avio_size(ic->pb) : 0;
1951 for(i = 0; i < ic->nb_streams; i++) {
1952 st = ic->streams[i];
1953 duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1954 if (st->duration == AV_NOPTS_VALUE)
1955 st->duration = duration;
1961 #define DURATION_MAX_READ_SIZE 250000
1962 #define DURATION_MAX_RETRY 3
1964 /* only usable for MPEG-PS streams */
1965 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
1967 AVPacket pkt1, *pkt = &pkt1;
1969 int read_size, i, ret;
1971 int64_t filesize, offset, duration;
1976 /* flush packet queue */
1977 flush_packet_queue(ic);
1979 for (i=0; i<ic->nb_streams; i++) {
1980 st = ic->streams[i];
1981 if (st->start_time == AV_NOPTS_VALUE && st->first_dts == AV_NOPTS_VALUE)
1982 av_log(st->codec, AV_LOG_WARNING, "start time is not set in estimate_timings_from_pts\n");
1985 av_parser_close(st->parser);
1987 av_free_packet(&st->cur_pkt);
1991 /* estimate the end time (duration) */
1992 /* XXX: may need to support wrapping */
1993 filesize = ic->pb ? avio_size(ic->pb) : 0;
1994 end_time = AV_NOPTS_VALUE;
1996 offset = filesize - (DURATION_MAX_READ_SIZE<<retry);
2000 avio_seek(ic->pb, offset, SEEK_SET);
2003 if (read_size >= DURATION_MAX_READ_SIZE<<(FFMAX(retry-1,0)))
2007 ret = av_read_packet(ic, pkt);
2008 } while(ret == AVERROR(EAGAIN));
2011 read_size += pkt->size;
2012 st = ic->streams[pkt->stream_index];
2013 if (pkt->pts != AV_NOPTS_VALUE &&
2014 (st->start_time != AV_NOPTS_VALUE ||
2015 st->first_dts != AV_NOPTS_VALUE)) {
2016 duration = end_time = pkt->pts;
2017 if (st->start_time != AV_NOPTS_VALUE)
2018 duration -= st->start_time;
2020 duration -= st->first_dts;
2022 duration += 1LL<<st->pts_wrap_bits;
2024 if (st->duration == AV_NOPTS_VALUE || st->duration < duration)
2025 st->duration = duration;
2028 av_free_packet(pkt);
2030 }while( end_time==AV_NOPTS_VALUE
2031 && filesize > (DURATION_MAX_READ_SIZE<<retry)
2032 && ++retry <= DURATION_MAX_RETRY);
2034 fill_all_stream_timings(ic);
2036 avio_seek(ic->pb, old_offset, SEEK_SET);
2037 for (i=0; i<ic->nb_streams; i++) {
2039 st->cur_dts= st->first_dts;
2040 st->last_IP_pts = AV_NOPTS_VALUE;
2041 st->reference_dts = AV_NOPTS_VALUE;
2045 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2049 /* get the file size, if possible */
2050 if (ic->iformat->flags & AVFMT_NOFILE) {
2053 file_size = avio_size(ic->pb);
2054 file_size = FFMAX(0, file_size);
2057 if ((!strcmp(ic->iformat->name, "mpeg") ||
2058 !strcmp(ic->iformat->name, "mpegts")) &&
2059 file_size && ic->pb->seekable) {
2060 /* get accurate estimate from the PTSes */
2061 estimate_timings_from_pts(ic, old_offset);
2062 } else if (has_duration(ic)) {
2063 /* at least one component has timings - we use them for all
2065 fill_all_stream_timings(ic);
2067 av_log(ic, AV_LOG_WARNING, "Estimating duration from bitrate, this may be inaccurate\n");
2068 /* less precise: use bitrate info */
2069 estimate_timings_from_bit_rate(ic);
2071 update_stream_timings(ic);
2075 AVStream av_unused *st;
2076 for(i = 0;i < ic->nb_streams; i++) {
2077 st = ic->streams[i];
2078 av_dlog(ic, "%d: start_time: %0.3f duration: %0.3f\n", i,
2079 (double) st->start_time / AV_TIME_BASE,
2080 (double) st->duration / AV_TIME_BASE);
2082 av_dlog(ic, "stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2083 (double) ic->start_time / AV_TIME_BASE,
2084 (double) ic->duration / AV_TIME_BASE,
2085 ic->bit_rate / 1000);
2089 static int has_codec_parameters(AVCodecContext *avctx)
2092 switch (avctx->codec_type) {
2093 case AVMEDIA_TYPE_AUDIO:
2094 val = avctx->sample_rate && avctx->channels && avctx->sample_fmt != AV_SAMPLE_FMT_NONE;
2095 if (!avctx->frame_size &&
2096 (avctx->codec_id == CODEC_ID_VORBIS ||
2097 avctx->codec_id == CODEC_ID_AAC ||
2098 avctx->codec_id == CODEC_ID_MP1 ||
2099 avctx->codec_id == CODEC_ID_MP2 ||
2100 avctx->codec_id == CODEC_ID_MP3 ||
2101 avctx->codec_id == CODEC_ID_CELT))
2104 case AVMEDIA_TYPE_VIDEO:
2105 val = avctx->width && avctx->pix_fmt != PIX_FMT_NONE;
2107 case AVMEDIA_TYPE_DATA:
2108 if(avctx->codec_id == CODEC_ID_NONE) return 1;
2113 return avctx->codec_id != CODEC_ID_NONE && val != 0;
2116 static int has_decode_delay_been_guessed(AVStream *st)
2118 return st->codec->codec_id != CODEC_ID_H264 ||
2119 st->info->nb_decoded_frames >= 6;
2122 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
2123 static int try_decode_frame(AVStream *st, AVPacket *avpkt, AVDictionary **options)
2126 int got_picture = 1, ret = 0;
2128 AVPacket pkt = *avpkt;
2130 if (!avcodec_is_open(st->codec)) {
2131 AVDictionary *thread_opt = NULL;
2133 codec = st->codec->codec ? st->codec->codec :
2134 avcodec_find_decoder(st->codec->codec_id);
2139 /* force thread count to 1 since the h264 decoder will not extract SPS
2140 * and PPS to extradata during multi-threaded decoding */
2141 av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
2142 ret = avcodec_open2(st->codec, codec, options ? options : &thread_opt);
2144 av_dict_free(&thread_opt);
2149 while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
2151 (!has_codec_parameters(st->codec) ||
2152 !has_decode_delay_been_guessed(st) ||
2153 (!st->codec_info_nb_frames && st->codec->codec->capabilities & CODEC_CAP_CHANNEL_CONF))) {
2155 avcodec_get_frame_defaults(&picture);
2156 switch(st->codec->codec_type) {
2157 case AVMEDIA_TYPE_VIDEO:
2158 ret = avcodec_decode_video2(st->codec, &picture,
2159 &got_picture, &pkt);
2161 case AVMEDIA_TYPE_AUDIO:
2162 ret = avcodec_decode_audio4(st->codec, &picture, &got_picture, &pkt);
2169 st->info->nb_decoded_frames++;
2175 if(!pkt.data && !got_picture)
2180 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum CodecID id)
2182 while (tags->id != CODEC_ID_NONE) {
2190 enum CodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2193 for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
2194 if(tag == tags[i].tag)
2197 for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
2198 if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
2201 return CODEC_ID_NONE;
2204 unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum CodecID id)
2207 for(i=0; tags && tags[i]; i++){
2208 int tag= ff_codec_get_tag(tags[i], id);
2214 enum CodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
2217 for(i=0; tags && tags[i]; i++){
2218 enum CodecID id= ff_codec_get_id(tags[i], tag);
2219 if(id!=CODEC_ID_NONE) return id;
2221 return CODEC_ID_NONE;
2224 static void compute_chapters_end(AVFormatContext *s)
2227 int64_t max_time = s->duration + ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
2229 for (i = 0; i < s->nb_chapters; i++)
2230 if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2231 AVChapter *ch = s->chapters[i];
2232 int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q, ch->time_base)
2235 for (j = 0; j < s->nb_chapters; j++) {
2236 AVChapter *ch1 = s->chapters[j];
2237 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base, ch->time_base);
2238 if (j != i && next_start > ch->start && next_start < end)
2241 ch->end = (end == INT64_MAX) ? ch->start : end;
2245 static int get_std_framerate(int i){
2246 if(i<60*12) return i*1001;
2247 else return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
2251 * Is the time base unreliable.
2252 * This is a heuristic to balance between quick acceptance of the values in
2253 * the headers vs. some extra checks.
2254 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2255 * MPEG-2 commonly misuses field repeat flags to store different framerates.
2256 * And there are "variable" fps files this needs to detect as well.
2258 static int tb_unreliable(AVCodecContext *c){
2259 if( c->time_base.den >= 101L*c->time_base.num
2260 || c->time_base.den < 5L*c->time_base.num
2261 /* || c->codec_tag == AV_RL32("DIVX")
2262 || c->codec_tag == AV_RL32("XVID")*/
2263 || c->codec_id == CODEC_ID_MPEG2VIDEO
2264 || c->codec_id == CODEC_ID_H264
2270 #if FF_API_FORMAT_PARAMETERS
2271 int av_find_stream_info(AVFormatContext *ic)
2273 return avformat_find_stream_info(ic, NULL);
2277 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
2279 int i, count, ret, read_size, j;
2281 AVPacket pkt1, *pkt;
2282 int64_t old_offset = avio_tell(ic->pb);
2283 int orig_nb_streams = ic->nb_streams; // new streams might appear, no options for those
2284 int flush_codecs = 1;
2286 for(i=0;i<ic->nb_streams;i++) {
2288 AVDictionary *thread_opt = NULL;
2289 st = ic->streams[i];
2291 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2292 st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2293 /* if(!st->time_base.num)
2295 if(!st->codec->time_base.num)
2296 st->codec->time_base= st->time_base;
2298 //only for the split stuff
2299 if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
2300 st->parser = av_parser_init(st->codec->codec_id);
2301 if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
2302 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2305 codec = st->codec->codec ? st->codec->codec :
2306 avcodec_find_decoder(st->codec->codec_id);
2308 /* force thread count to 1 since the h264 decoder will not extract SPS
2309 * and PPS to extradata during multi-threaded decoding */
2310 av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
2312 /* Ensure that subtitle_header is properly set. */
2313 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
2314 && codec && !st->codec->codec)
2315 avcodec_open2(st->codec, codec, options ? &options[i]
2318 //try to just open decoders, in case this is enough to get parameters
2319 if(!has_codec_parameters(st->codec)){
2320 if (codec && !st->codec->codec)
2321 avcodec_open2(st->codec, codec, options ? &options[i]
2325 av_dict_free(&thread_opt);
2328 for (i=0; i<ic->nb_streams; i++) {
2329 ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
2335 if (ff_check_interrupt(&ic->interrupt_callback)){
2337 av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2341 /* check if one codec still needs to be handled */
2342 for(i=0;i<ic->nb_streams;i++) {
2343 int fps_analyze_framecount = 20;
2345 st = ic->streams[i];
2346 if (!has_codec_parameters(st->codec))
2348 /* if the timebase is coarse (like the usual millisecond precision
2349 of mkv), we need to analyze more frames to reliably arrive at
2351 if (av_q2d(st->time_base) > 0.0005)
2352 fps_analyze_framecount *= 2;
2353 if (ic->fps_probe_size >= 0)
2354 fps_analyze_framecount = ic->fps_probe_size;
2355 /* variable fps and no guess at the real fps */
2356 if( tb_unreliable(st->codec) && !(st->r_frame_rate.num && st->avg_frame_rate.num)
2357 && st->info->duration_count < fps_analyze_framecount
2358 && st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2360 if(st->parser && st->parser->parser->split && !st->codec->extradata)
2362 if(st->first_dts == AV_NOPTS_VALUE && (st->codec->codec_type == AVMEDIA_TYPE_VIDEO || st->codec->codec_type == AVMEDIA_TYPE_AUDIO))
2365 if (i == ic->nb_streams) {
2366 /* NOTE: if the format has no header, then we need to read
2367 some packets to get most of the streams, so we cannot
2369 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2370 /* if we found the info for all the codecs, we can stop */
2372 av_log(ic, AV_LOG_DEBUG, "All info found\n");
2377 /* we did not get all the codec info, but we read too much data */
2378 if (read_size >= ic->probesize) {
2380 av_log(ic, AV_LOG_DEBUG, "Probe buffer size limit %d reached\n", ic->probesize);
2384 /* NOTE: a new stream can be added there if no header in file
2385 (AVFMTCTX_NOHEADER) */
2386 ret = read_frame_internal(ic, &pkt1);
2387 if (ret == AVERROR(EAGAIN))
2395 pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2396 if ((ret = av_dup_packet(pkt)) < 0)
2397 goto find_stream_info_err;
2399 read_size += pkt->size;
2401 st = ic->streams[pkt->stream_index];
2402 if (st->codec_info_nb_frames>1) {
2404 if (st->time_base.den > 0)
2405 t = av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
2406 if (st->avg_frame_rate.num > 0)
2407 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));
2409 if (t >= ic->max_analyze_duration) {
2410 av_log(ic, AV_LOG_WARNING, "max_analyze_duration %d reached at %"PRId64"\n", ic->max_analyze_duration, t);
2413 st->info->codec_info_duration += pkt->duration;
2416 int64_t last = st->info->last_dts;
2418 if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && pkt->dts > last){
2419 double dts= pkt->dts * av_q2d(st->time_base);
2420 int64_t duration= pkt->dts - last;
2422 // if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2423 // av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
2424 for (i=1; i<FF_ARRAY_ELEMS(st->info->duration_error[0][0]); i++) {
2425 int framerate= get_std_framerate(i);
2426 double sdts= dts*framerate/(1001*12);
2428 int ticks= lrintf(sdts+j*0.5);
2429 double error= sdts - ticks + j*0.5;
2430 st->info->duration_error[j][0][i] += error;
2431 st->info->duration_error[j][1][i] += error*error;
2434 st->info->duration_count++;
2435 // ignore the first 4 values, they might have some random jitter
2436 if (st->info->duration_count > 3)
2437 st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2439 if (last == AV_NOPTS_VALUE || st->info->duration_count <= 1)
2440 st->info->last_dts = pkt->dts;
2442 if(st->parser && st->parser->parser->split && !st->codec->extradata){
2443 int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2444 if (i > 0 && i < FF_MAX_EXTRADATA_SIZE) {
2445 st->codec->extradata_size= i;
2446 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2447 if (!st->codec->extradata)
2448 return AVERROR(ENOMEM);
2449 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2450 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2454 /* if still no information, we try to open the codec and to
2455 decompress the frame. We try to avoid that in most cases as
2456 it takes longer and uses more memory. For MPEG-4, we need to
2457 decompress for QuickTime.
2459 If CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
2460 least one frame of codec data, this makes sure the codec initializes
2461 the channel configuration and does not only trust the values from the container.
2463 try_decode_frame(st, pkt, (options && i < orig_nb_streams ) ? &options[i] : NULL);
2465 st->codec_info_nb_frames++;
2470 AVPacket empty_pkt = { 0 };
2472 av_init_packet(&empty_pkt);
2474 ret = -1; /* we could not have all the codec parameters before EOF */
2475 for(i=0;i<ic->nb_streams;i++) {
2476 st = ic->streams[i];
2478 /* flush the decoders */
2480 err = try_decode_frame(st, &empty_pkt,
2481 (options && i < orig_nb_streams) ?
2482 &options[i] : NULL);
2483 } while (err > 0 && !has_codec_parameters(st->codec));
2486 av_log(ic, AV_LOG_INFO,
2487 "decoding for stream %d failed\n", st->index);
2489 if (!has_codec_parameters(st->codec)){
2491 avcodec_string(buf, sizeof(buf), st->codec, 0);
2492 av_log(ic, AV_LOG_WARNING,
2493 "Could not find codec parameters (%s)\n", buf);
2500 // close codecs which were opened in try_decode_frame()
2501 for(i=0;i<ic->nb_streams;i++) {
2502 st = ic->streams[i];
2503 avcodec_close(st->codec);
2505 for(i=0;i<ic->nb_streams;i++) {
2506 st = ic->streams[i];
2507 if (st->codec_info_nb_frames>2 && !st->avg_frame_rate.num && st->info->codec_info_duration)
2508 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2509 (st->codec_info_nb_frames-2)*(int64_t)st->time_base.den,
2510 st->info->codec_info_duration*(int64_t)st->time_base.num, 60000);
2511 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2512 if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample){
2513 uint32_t tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2514 if(ff_find_pix_fmt(ff_raw_pix_fmt_tags, tag) == st->codec->pix_fmt)
2515 st->codec->codec_tag= tag;
2518 // the check for tb_unreliable() is not completely correct, since this is not about handling
2519 // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2520 // ipmovie.c produces.
2521 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)
2522 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);
2523 if (st->info->duration_count && !st->r_frame_rate.num
2524 && tb_unreliable(st->codec) /*&&
2525 //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2526 st->time_base.num*duration_sum[i]/st->info->duration_count*101LL > st->time_base.den*/){
2528 double best_error= 0.01;
2530 for (j=1; j<FF_ARRAY_ELEMS(st->info->duration_error[0][0]); j++) {
2533 if(st->info->codec_info_duration && st->info->codec_info_duration*av_q2d(st->time_base) < (1001*12.0)/get_std_framerate(j))
2535 if(!st->info->codec_info_duration && 1.0 < (1001*12.0)/get_std_framerate(j))
2538 int n= st->info->duration_count;
2539 double a= st->info->duration_error[k][0][j] / n;
2540 double error= st->info->duration_error[k][1][j]/n - a*a;
2542 if(error < best_error && best_error> 0.000000001){
2544 num = get_std_framerate(j);
2547 av_log(NULL, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
2550 // do not increase frame rate by more than 1 % in order to match a standard rate.
2551 if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
2552 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2555 if (!st->r_frame_rate.num){
2556 if( st->codec->time_base.den * (int64_t)st->time_base.num
2557 <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
2558 st->r_frame_rate.num = st->codec->time_base.den;
2559 st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
2561 st->r_frame_rate.num = st->time_base.den;
2562 st->r_frame_rate.den = st->time_base.num;
2565 }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2566 if(!st->codec->bits_per_coded_sample)
2567 st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2568 // set stream disposition based on audio service type
2569 switch (st->codec->audio_service_type) {
2570 case AV_AUDIO_SERVICE_TYPE_EFFECTS:
2571 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS; break;
2572 case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
2573 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED; break;
2574 case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
2575 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED; break;
2576 case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
2577 st->disposition = AV_DISPOSITION_COMMENT; break;
2578 case AV_AUDIO_SERVICE_TYPE_KARAOKE:
2579 st->disposition = AV_DISPOSITION_KARAOKE; break;
2584 estimate_timings(ic, old_offset);
2586 compute_chapters_end(ic);
2589 /* correct DTS for B-frame streams with no timestamps */
2590 for(i=0;i<ic->nb_streams;i++) {
2591 st = ic->streams[i];
2592 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2594 ppktl = &ic->packet_buffer;
2596 if(ppkt1->stream_index != i)
2598 if(ppkt1->pkt->dts < 0)
2600 if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2602 ppkt1->pkt->dts -= delta;
2607 st->cur_dts -= delta;
2613 find_stream_info_err:
2614 for (i=0; i < ic->nb_streams; i++) {
2615 if (ic->streams[i]->codec)
2616 ic->streams[i]->codec->thread_count = 0;
2617 av_freep(&ic->streams[i]->info);
2622 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
2626 for (i = 0; i < ic->nb_programs; i++) {
2627 if (ic->programs[i] == last) {
2631 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
2632 if (ic->programs[i]->stream_index[j] == s)
2633 return ic->programs[i];
2639 int av_find_best_stream(AVFormatContext *ic,
2640 enum AVMediaType type,
2641 int wanted_stream_nb,
2643 AVCodec **decoder_ret,
2646 int i, nb_streams = ic->nb_streams;
2647 int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1;
2648 unsigned *program = NULL;
2649 AVCodec *decoder = NULL, *best_decoder = NULL;
2651 if (related_stream >= 0 && wanted_stream_nb < 0) {
2652 AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
2654 program = p->stream_index;
2655 nb_streams = p->nb_stream_indexes;
2658 for (i = 0; i < nb_streams; i++) {
2659 int real_stream_index = program ? program[i] : i;
2660 AVStream *st = ic->streams[real_stream_index];
2661 AVCodecContext *avctx = st->codec;
2662 if (avctx->codec_type != type)
2664 if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
2666 if (st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED|AV_DISPOSITION_VISUAL_IMPAIRED))
2669 decoder = avcodec_find_decoder(st->codec->codec_id);
2672 ret = AVERROR_DECODER_NOT_FOUND;
2676 if (best_count >= st->codec_info_nb_frames)
2678 best_count = st->codec_info_nb_frames;
2679 ret = real_stream_index;
2680 best_decoder = decoder;
2681 if (program && i == nb_streams - 1 && ret < 0) {
2683 nb_streams = ic->nb_streams;
2684 i = 0; /* no related stream found, try again with everything */
2688 *decoder_ret = best_decoder;
2692 /*******************************************************/
2694 int av_read_play(AVFormatContext *s)
2696 if (s->iformat->read_play)
2697 return s->iformat->read_play(s);
2699 return avio_pause(s->pb, 0);
2700 return AVERROR(ENOSYS);
2703 int av_read_pause(AVFormatContext *s)
2705 if (s->iformat->read_pause)
2706 return s->iformat->read_pause(s);
2708 return avio_pause(s->pb, 1);
2709 return AVERROR(ENOSYS);
2712 void avformat_free_context(AVFormatContext *s)
2718 if (s->iformat && s->iformat->priv_class && s->priv_data)
2719 av_opt_free(s->priv_data);
2721 for(i=0;i<s->nb_streams;i++) {
2722 /* free all data in a stream component */
2725 av_parser_close(st->parser);
2726 av_free_packet(&st->cur_pkt);
2728 av_dict_free(&st->metadata);
2729 av_freep(&st->index_entries);
2730 av_freep(&st->codec->extradata);
2731 av_freep(&st->codec->subtitle_header);
2732 av_freep(&st->codec);
2733 av_freep(&st->priv_data);
2734 av_freep(&st->info);
2737 for(i=s->nb_programs-1; i>=0; i--) {
2738 av_dict_free(&s->programs[i]->metadata);
2739 av_freep(&s->programs[i]->stream_index);
2740 av_freep(&s->programs[i]);
2742 av_freep(&s->programs);
2743 av_freep(&s->priv_data);
2744 while(s->nb_chapters--) {
2745 av_dict_free(&s->chapters[s->nb_chapters]->metadata);
2746 av_freep(&s->chapters[s->nb_chapters]);
2748 av_freep(&s->chapters);
2749 av_dict_free(&s->metadata);
2750 av_freep(&s->streams);
2754 #if FF_API_CLOSE_INPUT_FILE
2755 void av_close_input_file(AVFormatContext *s)
2757 avformat_close_input(&s);
2761 void avformat_close_input(AVFormatContext **ps)
2763 AVFormatContext *s = *ps;
2764 AVIOContext *pb = (s->iformat && (s->iformat->flags & AVFMT_NOFILE)) || (s->flags & AVFMT_FLAG_CUSTOM_IO) ?
2766 flush_packet_queue(s);
2767 if (s->iformat && (s->iformat->read_close))
2768 s->iformat->read_close(s);
2769 avformat_free_context(s);
2775 #if FF_API_NEW_STREAM
2776 AVStream *av_new_stream(AVFormatContext *s, int id)
2778 AVStream *st = avformat_new_stream(s, NULL);
2785 AVStream *avformat_new_stream(AVFormatContext *s, AVCodec *c)
2791 if (s->nb_streams >= INT_MAX/sizeof(*streams))
2793 streams = av_realloc(s->streams, (s->nb_streams + 1) * sizeof(*streams));
2796 s->streams = streams;
2798 st = av_mallocz(sizeof(AVStream));
2801 if (!(st->info = av_mallocz(sizeof(*st->info)))) {
2806 st->codec = avcodec_alloc_context3(c);
2808 /* no default bitrate if decoding */
2809 st->codec->bit_rate = 0;
2811 st->index = s->nb_streams;
2812 st->start_time = AV_NOPTS_VALUE;
2813 st->duration = AV_NOPTS_VALUE;
2814 /* we set the current DTS to 0 so that formats without any timestamps
2815 but durations get some timestamps, formats with some unknown
2816 timestamps have their first few packets buffered and the
2817 timestamps corrected before they are returned to the user */
2819 st->first_dts = AV_NOPTS_VALUE;
2820 st->probe_packets = MAX_PROBE_PACKETS;
2822 /* default pts setting is MPEG-like */
2823 avpriv_set_pts_info(st, 33, 1, 90000);
2824 st->last_IP_pts = AV_NOPTS_VALUE;
2825 for(i=0; i<MAX_REORDER_DELAY+1; i++)
2826 st->pts_buffer[i]= AV_NOPTS_VALUE;
2827 st->reference_dts = AV_NOPTS_VALUE;
2829 st->sample_aspect_ratio = (AVRational){0,1};
2831 s->streams[s->nb_streams++] = st;
2835 AVProgram *av_new_program(AVFormatContext *ac, int id)
2837 AVProgram *program=NULL;
2840 av_dlog(ac, "new_program: id=0x%04x\n", id);
2842 for(i=0; i<ac->nb_programs; i++)
2843 if(ac->programs[i]->id == id)
2844 program = ac->programs[i];
2847 program = av_mallocz(sizeof(AVProgram));
2850 dynarray_add(&ac->programs, &ac->nb_programs, program);
2851 program->discard = AVDISCARD_NONE;
2858 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2860 AVChapter *chapter = NULL;
2863 for(i=0; i<s->nb_chapters; i++)
2864 if(s->chapters[i]->id == id)
2865 chapter = s->chapters[i];
2868 chapter= av_mallocz(sizeof(AVChapter));
2871 dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2873 av_dict_set(&chapter->metadata, "title", title, 0);
2875 chapter->time_base= time_base;
2876 chapter->start = start;
2882 /************************************************************/
2883 /* output media file */
2885 int avformat_alloc_output_context2(AVFormatContext **avctx, AVOutputFormat *oformat,
2886 const char *format, const char *filename)
2888 AVFormatContext *s = avformat_alloc_context();
2897 oformat = av_guess_format(format, NULL, NULL);
2899 av_log(s, AV_LOG_ERROR, "Requested output format '%s' is not a suitable output format\n", format);
2900 ret = AVERROR(EINVAL);
2904 oformat = av_guess_format(NULL, filename, NULL);
2906 ret = AVERROR(EINVAL);
2907 av_log(s, AV_LOG_ERROR, "Unable to find a suitable output format for '%s'\n",
2914 s->oformat = oformat;
2915 if (s->oformat->priv_data_size > 0) {
2916 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2919 if (s->oformat->priv_class) {
2920 *(const AVClass**)s->priv_data= s->oformat->priv_class;
2921 av_opt_set_defaults(s->priv_data);
2924 s->priv_data = NULL;
2927 av_strlcpy(s->filename, filename, sizeof(s->filename));
2931 av_log(s, AV_LOG_ERROR, "Out of memory\n");
2932 ret = AVERROR(ENOMEM);
2934 avformat_free_context(s);
2938 #if FF_API_ALLOC_OUTPUT_CONTEXT
2939 AVFormatContext *avformat_alloc_output_context(const char *format,
2940 AVOutputFormat *oformat, const char *filename)
2942 AVFormatContext *avctx;
2943 int ret = avformat_alloc_output_context2(&avctx, oformat, format, filename);
2944 return ret < 0 ? NULL : avctx;
2948 static int validate_codec_tag(AVFormatContext *s, AVStream *st)
2950 const AVCodecTag *avctag;
2952 enum CodecID id = CODEC_ID_NONE;
2953 unsigned int tag = 0;
2956 * Check that tag + id is in the table
2957 * If neither is in the table -> OK
2958 * If tag is in the table with another id -> FAIL
2959 * If id is in the table with another tag -> FAIL unless strict < normal
2961 for (n = 0; s->oformat->codec_tag[n]; n++) {
2962 avctag = s->oformat->codec_tag[n];
2963 while (avctag->id != CODEC_ID_NONE) {
2964 if (avpriv_toupper4(avctag->tag) == avpriv_toupper4(st->codec->codec_tag)) {
2966 if (id == st->codec->codec_id)
2969 if (avctag->id == st->codec->codec_id)
2974 if (id != CODEC_ID_NONE)
2976 if (tag && (st->codec->strict_std_compliance >= FF_COMPLIANCE_NORMAL))
2981 int avformat_write_header(AVFormatContext *s, AVDictionary **options)
2985 AVDictionary *tmp = NULL;
2988 av_dict_copy(&tmp, *options, 0);
2989 if ((ret = av_opt_set_dict(s, &tmp)) < 0)
2991 if (s->priv_data && s->oformat->priv_class && *(const AVClass**)s->priv_data==s->oformat->priv_class &&
2992 (ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
2995 // some sanity checks
2996 if (s->nb_streams == 0 && !(s->oformat->flags & AVFMT_NOSTREAMS)) {
2997 av_log(s, AV_LOG_ERROR, "no streams\n");
2998 ret = AVERROR(EINVAL);
3002 for(i=0;i<s->nb_streams;i++) {
3005 switch (st->codec->codec_type) {
3006 case AVMEDIA_TYPE_AUDIO:
3007 if(st->codec->sample_rate<=0){
3008 av_log(s, AV_LOG_ERROR, "sample rate not set\n");
3009 ret = AVERROR(EINVAL);
3012 if(!st->codec->block_align)
3013 st->codec->block_align = st->codec->channels *
3014 av_get_bits_per_sample(st->codec->codec_id) >> 3;
3016 case AVMEDIA_TYPE_VIDEO:
3017 if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
3018 av_log(s, AV_LOG_ERROR, "time base not set\n");
3019 ret = AVERROR(EINVAL);
3022 if((st->codec->width<=0 || st->codec->height<=0) && !(s->oformat->flags & AVFMT_NODIMENSIONS)){
3023 av_log(s, AV_LOG_ERROR, "dimensions not set\n");
3024 ret = AVERROR(EINVAL);
3027 if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)
3028 && FFABS(av_q2d(st->sample_aspect_ratio) - av_q2d(st->codec->sample_aspect_ratio)) > 0.004*av_q2d(st->sample_aspect_ratio)
3030 av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between muxer "
3031 "(%d/%d) and encoder layer (%d/%d)\n",
3032 st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3033 st->codec->sample_aspect_ratio.num,
3034 st->codec->sample_aspect_ratio.den);
3035 ret = AVERROR(EINVAL);
3041 if(s->oformat->codec_tag){
3042 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)){
3043 //the current rawvideo encoding system ends up setting the wrong codec_tag for avi, we override it here
3044 st->codec->codec_tag= 0;
3046 if(st->codec->codec_tag){
3047 if (!validate_codec_tag(s, st)) {
3049 av_get_codec_tag_string(tagbuf, sizeof(tagbuf), st->codec->codec_tag);
3050 av_log(s, AV_LOG_ERROR,
3051 "Tag %s/0x%08x incompatible with output codec id '%d'\n",
3052 tagbuf, st->codec->codec_tag, st->codec->codec_id);
3053 ret = AVERROR_INVALIDDATA;
3057 st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
3060 if(s->oformat->flags & AVFMT_GLOBALHEADER &&
3061 !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
3062 av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
3065 if (!s->priv_data && s->oformat->priv_data_size > 0) {
3066 s->priv_data = av_mallocz(s->oformat->priv_data_size);
3067 if (!s->priv_data) {
3068 ret = AVERROR(ENOMEM);
3071 if (s->oformat->priv_class) {
3072 *(const AVClass**)s->priv_data= s->oformat->priv_class;
3073 av_opt_set_defaults(s->priv_data);
3074 if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
3079 /* set muxer identification string */
3080 if (s->nb_streams && !(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
3081 av_dict_set(&s->metadata, "encoder", LIBAVFORMAT_IDENT, 0);
3084 if(s->oformat->write_header){
3085 ret = s->oformat->write_header(s);
3090 /* init PTS generation */
3091 for(i=0;i<s->nb_streams;i++) {
3092 int64_t den = AV_NOPTS_VALUE;
3095 switch (st->codec->codec_type) {
3096 case AVMEDIA_TYPE_AUDIO:
3097 den = (int64_t)st->time_base.num * st->codec->sample_rate;
3099 case AVMEDIA_TYPE_VIDEO:
3100 den = (int64_t)st->time_base.num * st->codec->time_base.den;
3105 if (den != AV_NOPTS_VALUE) {
3107 ret = AVERROR_INVALIDDATA;
3110 frac_init(&st->pts, 0, 0, den);
3115 av_dict_free(options);
3124 //FIXME merge with compute_pkt_fields
3125 static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt){
3126 int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
3127 int num, den, frame_size, i;
3129 av_dlog(s, "compute_pkt_fields2: pts:%"PRId64" dts:%"PRId64" cur_dts:%"PRId64" b:%d size:%d st:%d\n",
3130 pkt->pts, pkt->dts, st->cur_dts, delay, pkt->size, pkt->stream_index);
3132 /* duration field */
3133 if (pkt->duration == 0) {
3134 compute_frame_duration(&num, &den, st, NULL, pkt);
3136 pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
3140 if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
3143 //XXX/FIXME this is a temporary hack until all encoders output pts
3144 if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
3146 // pkt->pts= st->cur_dts;
3147 pkt->pts= st->pts.val;
3150 //calculate dts from pts
3151 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
3152 st->pts_buffer[0]= pkt->pts;
3153 for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
3154 st->pts_buffer[i]= pkt->pts + (i-delay-1) * pkt->duration;
3155 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
3156 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
3158 pkt->dts= st->pts_buffer[0];
3161 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)){
3162 av_log(s, AV_LOG_ERROR,
3163 "Application provided invalid, non monotonically increasing dts to muxer in stream %d: %"PRId64" >= %"PRId64"\n",
3164 st->index, st->cur_dts, pkt->dts);
3165 return AVERROR(EINVAL);
3167 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
3168 av_log(s, AV_LOG_ERROR, "pts < dts in stream %d\n", st->index);
3169 return AVERROR(EINVAL);
3172 // av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
3173 st->cur_dts= pkt->dts;
3174 st->pts.val= pkt->dts;
3177 switch (st->codec->codec_type) {
3178 case AVMEDIA_TYPE_AUDIO:
3179 frame_size = get_audio_frame_size(st->codec, pkt->size);
3181 /* HACK/FIXME, we skip the initial 0 size packets as they are most
3182 likely equal to the encoder delay, but it would be better if we
3183 had the real timestamps from the encoder */
3184 if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
3185 frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
3188 case AVMEDIA_TYPE_VIDEO:
3189 frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
3197 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
3202 if (s->oformat->flags & AVFMT_ALLOW_FLUSH)
3203 return s->oformat->write_packet(s, pkt);
3207 ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt);
3209 if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3212 ret= s->oformat->write_packet(s, pkt);
3215 s->streams[pkt->stream_index]->nb_frames++;
3219 #define CHUNK_START 0x1000
3221 int ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
3222 int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
3224 AVPacketList **next_point, *this_pktl;
3225 AVStream *st= s->streams[pkt->stream_index];
3226 int chunked= s->max_chunk_size || s->max_chunk_duration;
3228 this_pktl = av_mallocz(sizeof(AVPacketList));
3230 return AVERROR(ENOMEM);
3231 this_pktl->pkt= *pkt;
3232 pkt->destruct= NULL; // do not free original but only the copy
3233 av_dup_packet(&this_pktl->pkt); // duplicate the packet if it uses non-alloced memory
3235 if(s->streams[pkt->stream_index]->last_in_packet_buffer){
3236 next_point = &(st->last_in_packet_buffer->next);
3238 next_point = &s->packet_buffer;
3243 uint64_t max= av_rescale_q(s->max_chunk_duration, AV_TIME_BASE_Q, st->time_base);
3244 if( st->interleaver_chunk_size + pkt->size <= s->max_chunk_size-1U
3245 && st->interleaver_chunk_duration + pkt->duration <= max-1U){
3246 st->interleaver_chunk_size += pkt->size;
3247 st->interleaver_chunk_duration += pkt->duration;
3250 st->interleaver_chunk_size =
3251 st->interleaver_chunk_duration = 0;
3252 this_pktl->pkt.flags |= CHUNK_START;
3256 if(compare(s, &s->packet_buffer_end->pkt, pkt)){
3258 && ((chunked && !((*next_point)->pkt.flags&CHUNK_START))
3259 || !compare(s, &(*next_point)->pkt, pkt))){
3260 next_point= &(*next_point)->next;
3265 next_point = &(s->packet_buffer_end->next);
3268 assert(!*next_point);
3270 s->packet_buffer_end= this_pktl;
3273 this_pktl->next= *next_point;
3275 s->streams[pkt->stream_index]->last_in_packet_buffer=
3276 *next_point= this_pktl;
3280 static int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
3282 AVStream *st = s->streams[ pkt ->stream_index];
3283 AVStream *st2= s->streams[ next->stream_index];
3284 int comp = av_compare_ts(next->dts, st2->time_base, pkt->dts,
3286 if(s->audio_preload && ((st->codec->codec_type == AVMEDIA_TYPE_AUDIO) != (st2->codec->codec_type == AVMEDIA_TYPE_AUDIO))){
3287 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);
3288 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);
3290 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
3291 -( 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;
3294 comp= (ts>ts2) - (ts<ts2);
3298 return pkt->stream_index < next->stream_index;
3302 int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
3304 int stream_count=0, noninterleaved_count=0;
3305 int64_t delta_dts_max = 0;
3309 ret = ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
3314 for(i=0; i < s->nb_streams; i++) {
3315 if (s->streams[i]->last_in_packet_buffer) {
3317 } else if(s->streams[i]->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3318 ++noninterleaved_count;
3322 if (s->nb_streams == stream_count) {
3325 for(i=0; i < s->nb_streams; i++) {
3326 if (s->streams[i]->last_in_packet_buffer) {
3328 av_rescale_q(s->streams[i]->last_in_packet_buffer->pkt.dts,
3329 s->streams[i]->time_base,
3331 av_rescale_q(s->packet_buffer->pkt.dts,
3332 s->streams[s->packet_buffer->pkt.stream_index]->time_base,
3334 delta_dts_max= FFMAX(delta_dts_max, delta_dts);
3337 if(s->nb_streams == stream_count+noninterleaved_count &&
3338 delta_dts_max > 20*AV_TIME_BASE) {
3339 av_log(s, AV_LOG_DEBUG, "flushing with %d noninterleaved\n", noninterleaved_count);
3343 if(stream_count && flush){
3344 pktl= s->packet_buffer;
3347 s->packet_buffer= pktl->next;
3348 if(!s->packet_buffer)
3349 s->packet_buffer_end= NULL;
3351 if(s->streams[out->stream_index]->last_in_packet_buffer == pktl)
3352 s->streams[out->stream_index]->last_in_packet_buffer= NULL;
3356 av_init_packet(out);
3362 * Interleave an AVPacket correctly so it can be muxed.
3363 * @param out the interleaved packet will be output here
3364 * @param in the input packet
3365 * @param flush 1 if no further packets are available as input and all
3366 * remaining packets should be output
3367 * @return 1 if a packet was output, 0 if no packet could be output,
3368 * < 0 if an error occurred
3370 static int interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
3371 if (s->oformat->interleave_packet) {
3372 int ret = s->oformat->interleave_packet(s, out, in, flush);
3377 return av_interleave_packet_per_dts(s, out, in, flush);
3380 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
3381 AVStream *st= s->streams[ pkt->stream_index];
3384 //FIXME/XXX/HACK drop zero sized packets
3385 if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO && pkt->size==0)
3388 av_dlog(s, "av_interleaved_write_frame size:%d dts:%"PRId64" pts:%"PRId64"\n",
3389 pkt->size, pkt->dts, pkt->pts);
3390 if((ret = compute_pkt_fields2(s, st, pkt)) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3393 if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3394 return AVERROR(EINVAL);
3398 int ret= interleave_packet(s, &opkt, pkt, 0);
3399 if(ret<=0) //FIXME cleanup needed for ret<0 ?
3402 ret= s->oformat->write_packet(s, &opkt);
3404 s->streams[opkt.stream_index]->nb_frames++;
3406 av_free_packet(&opkt);
3411 if(s->pb && s->pb->error)
3412 return s->pb->error;
3416 int av_write_trailer(AVFormatContext *s)
3422 ret= interleave_packet(s, &pkt, NULL, 1);
3423 if(ret<0) //FIXME cleanup needed for ret<0 ?
3428 ret= s->oformat->write_packet(s, &pkt);
3430 s->streams[pkt.stream_index]->nb_frames++;
3432 av_free_packet(&pkt);
3436 if(s->pb && s->pb->error)
3440 if(s->oformat->write_trailer)
3441 ret = s->oformat->write_trailer(s);
3444 ret = s->pb ? s->pb->error : 0;
3445 for(i=0;i<s->nb_streams;i++) {
3446 av_freep(&s->streams[i]->priv_data);
3447 av_freep(&s->streams[i]->index_entries);
3449 if (s->oformat->priv_class)
3450 av_opt_free(s->priv_data);
3451 av_freep(&s->priv_data);
3455 int av_get_output_timestamp(struct AVFormatContext *s, int stream,
3456 int64_t *dts, int64_t *wall)
3458 if (!s->oformat || !s->oformat->get_output_timestamp)
3459 return AVERROR(ENOSYS);
3460 s->oformat->get_output_timestamp(s, stream, dts, wall);
3464 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
3467 AVProgram *program=NULL;
3470 if (idx >= ac->nb_streams) {
3471 av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3475 for(i=0; i<ac->nb_programs; i++){
3476 if(ac->programs[i]->id != progid)
3478 program = ac->programs[i];
3479 for(j=0; j<program->nb_stream_indexes; j++)
3480 if(program->stream_index[j] == idx)
3483 tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
3486 program->stream_index = tmp;
3487 program->stream_index[program->nb_stream_indexes++] = idx;
3492 static void print_fps(double d, const char *postfix){
3493 uint64_t v= lrintf(d*100);
3494 if (v% 100 ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3495 else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3496 else av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
3499 static void dump_metadata(void *ctx, AVDictionary *m, const char *indent)
3501 if(m && !(m->count == 1 && av_dict_get(m, "language", NULL, 0))){
3502 AVDictionaryEntry *tag=NULL;
3504 av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3505 while((tag=av_dict_get(m, "", tag, AV_DICT_IGNORE_SUFFIX))) {
3506 if(strcmp("language", tag->key)){
3507 const char *p = tag->value;
3508 av_log(ctx, AV_LOG_INFO, "%s %-16s: ", indent, tag->key);
3511 size_t len = strcspn(p, "\xd\xa");
3512 av_strlcpy(tmp, p, FFMIN(sizeof(tmp), len+1));
3513 av_log(ctx, AV_LOG_INFO, "%s", tmp);
3515 if (*p == 0xd) av_log(ctx, AV_LOG_INFO, " ");
3516 if (*p == 0xa) av_log(ctx, AV_LOG_INFO, "\n%s %-16s: ", indent, "");
3519 av_log(ctx, AV_LOG_INFO, "\n");
3525 /* "user interface" functions */
3526 static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
3529 int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
3530 AVStream *st = ic->streams[i];
3531 int g = av_gcd(st->time_base.num, st->time_base.den);
3532 AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL, 0);
3533 avcodec_string(buf, sizeof(buf), st->codec, is_output);
3534 av_log(NULL, AV_LOG_INFO, " Stream #%d:%d", index, i);
3535 /* the pid is an important information, so we display it */
3536 /* XXX: add a generic system */
3537 if (flags & AVFMT_SHOW_IDS)
3538 av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
3540 av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
3541 av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames, st->time_base.num/g, st->time_base.den/g);
3542 av_log(NULL, AV_LOG_INFO, ": %s", buf);
3543 if (st->sample_aspect_ratio.num && // default
3544 av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
3545 AVRational display_aspect_ratio;
3546 av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
3547 st->codec->width*st->sample_aspect_ratio.num,
3548 st->codec->height*st->sample_aspect_ratio.den,
3550 av_log(NULL, AV_LOG_INFO, ", SAR %d:%d DAR %d:%d",
3551 st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3552 display_aspect_ratio.num, display_aspect_ratio.den);
3554 if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
3555 if(st->avg_frame_rate.den && st->avg_frame_rate.num)
3556 print_fps(av_q2d(st->avg_frame_rate), "fps");
3557 if(st->r_frame_rate.den && st->r_frame_rate.num)
3558 print_fps(av_q2d(st->r_frame_rate), "tbr");
3559 if(st->time_base.den && st->time_base.num)
3560 print_fps(1/av_q2d(st->time_base), "tbn");
3561 if(st->codec->time_base.den && st->codec->time_base.num)
3562 print_fps(1/av_q2d(st->codec->time_base), "tbc");
3564 if (st->disposition & AV_DISPOSITION_DEFAULT)
3565 av_log(NULL, AV_LOG_INFO, " (default)");
3566 if (st->disposition & AV_DISPOSITION_DUB)
3567 av_log(NULL, AV_LOG_INFO, " (dub)");
3568 if (st->disposition & AV_DISPOSITION_ORIGINAL)
3569 av_log(NULL, AV_LOG_INFO, " (original)");
3570 if (st->disposition & AV_DISPOSITION_COMMENT)
3571 av_log(NULL, AV_LOG_INFO, " (comment)");
3572 if (st->disposition & AV_DISPOSITION_LYRICS)
3573 av_log(NULL, AV_LOG_INFO, " (lyrics)");
3574 if (st->disposition & AV_DISPOSITION_KARAOKE)
3575 av_log(NULL, AV_LOG_INFO, " (karaoke)");
3576 if (st->disposition & AV_DISPOSITION_FORCED)
3577 av_log(NULL, AV_LOG_INFO, " (forced)");
3578 if (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED)
3579 av_log(NULL, AV_LOG_INFO, " (hearing impaired)");
3580 if (st->disposition & AV_DISPOSITION_VISUAL_IMPAIRED)
3581 av_log(NULL, AV_LOG_INFO, " (visual impaired)");
3582 if (st->disposition & AV_DISPOSITION_CLEAN_EFFECTS)
3583 av_log(NULL, AV_LOG_INFO, " (clean effects)");
3584 av_log(NULL, AV_LOG_INFO, "\n");
3585 dump_metadata(NULL, st->metadata, " ");
3588 void av_dump_format(AVFormatContext *ic,
3594 uint8_t *printed = ic->nb_streams ? av_mallocz(ic->nb_streams) : NULL;
3595 if (ic->nb_streams && !printed)
3598 av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3599 is_output ? "Output" : "Input",
3601 is_output ? ic->oformat->name : ic->iformat->name,
3602 is_output ? "to" : "from", url);
3603 dump_metadata(NULL, ic->metadata, " ");
3605 av_log(NULL, AV_LOG_INFO, " Duration: ");
3606 if (ic->duration != AV_NOPTS_VALUE) {
3607 int hours, mins, secs, us;
3608 secs = ic->duration / AV_TIME_BASE;
3609 us = ic->duration % AV_TIME_BASE;
3614 av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3615 (100 * us) / AV_TIME_BASE);
3617 av_log(NULL, AV_LOG_INFO, "N/A");
3619 if (ic->start_time != AV_NOPTS_VALUE) {
3621 av_log(NULL, AV_LOG_INFO, ", start: ");
3622 secs = ic->start_time / AV_TIME_BASE;
3623 us = abs(ic->start_time % AV_TIME_BASE);
3624 av_log(NULL, AV_LOG_INFO, "%d.%06d",
3625 secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
3627 av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3629 av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
3631 av_log(NULL, AV_LOG_INFO, "N/A");
3633 av_log(NULL, AV_LOG_INFO, "\n");
3635 for (i = 0; i < ic->nb_chapters; i++) {
3636 AVChapter *ch = ic->chapters[i];
3637 av_log(NULL, AV_LOG_INFO, " Chapter #%d.%d: ", index, i);
3638 av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
3639 av_log(NULL, AV_LOG_INFO, "end %f\n", ch->end * av_q2d(ch->time_base));
3641 dump_metadata(NULL, ch->metadata, " ");
3643 if(ic->nb_programs) {
3644 int j, k, total = 0;
3645 for(j=0; j<ic->nb_programs; j++) {
3646 AVDictionaryEntry *name = av_dict_get(ic->programs[j]->metadata,
3648 av_log(NULL, AV_LOG_INFO, " Program %d %s\n", ic->programs[j]->id,
3649 name ? name->value : "");
3650 dump_metadata(NULL, ic->programs[j]->metadata, " ");
3651 for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3652 dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3653 printed[ic->programs[j]->stream_index[k]] = 1;
3655 total += ic->programs[j]->nb_stream_indexes;
3657 if (total < ic->nb_streams)
3658 av_log(NULL, AV_LOG_INFO, " No Program\n");
3660 for(i=0;i<ic->nb_streams;i++)
3662 dump_stream_format(ic, i, index, is_output);
3667 int64_t av_gettime(void)
3670 gettimeofday(&tv,NULL);
3671 return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
3674 uint64_t ff_ntp_time(void)
3676 return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3679 int av_get_frame_filename(char *buf, int buf_size,
3680 const char *path, int number)
3683 char *q, buf1[20], c;
3684 int nd, len, percentd_found;
3696 while (isdigit(*p)) {
3697 nd = nd * 10 + *p++ - '0';
3700 } while (isdigit(c));
3709 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3711 if ((q - buf + len) > buf_size - 1)
3713 memcpy(q, buf1, len);
3721 if ((q - buf) < buf_size - 1)
3725 if (!percentd_found)
3734 static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3738 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3740 for(i=0;i<size;i+=16) {
3747 PRINT(" %02x", buf[i+j]);
3752 for(j=0;j<len;j++) {
3754 if (c < ' ' || c > '~')
3763 void av_hex_dump(FILE *f, uint8_t *buf, int size)
3765 hex_dump_internal(NULL, f, 0, buf, size);
3768 void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3770 hex_dump_internal(avcl, NULL, level, buf, size);
3773 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload, AVRational time_base)
3776 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3777 PRINT("stream #%d:\n", pkt->stream_index);
3778 PRINT(" keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
3779 PRINT(" duration=%0.3f\n", pkt->duration * av_q2d(time_base));
3780 /* DTS is _always_ valid after av_read_frame() */
3782 if (pkt->dts == AV_NOPTS_VALUE)
3785 PRINT("%0.3f", pkt->dts * av_q2d(time_base));
3786 /* PTS may not be known if B-frames are present. */
3788 if (pkt->pts == AV_NOPTS_VALUE)
3791 PRINT("%0.3f", pkt->pts * av_q2d(time_base));
3793 PRINT(" size=%d\n", pkt->size);
3796 av_hex_dump(f, pkt->data, pkt->size);
3800 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3802 AVRational tb = { 1, AV_TIME_BASE };
3803 pkt_dump_internal(NULL, f, 0, pkt, dump_payload, tb);
3807 void av_pkt_dump2(FILE *f, AVPacket *pkt, int dump_payload, AVStream *st)
3809 pkt_dump_internal(NULL, f, 0, pkt, dump_payload, st->time_base);
3813 void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3815 AVRational tb = { 1, AV_TIME_BASE };
3816 pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, tb);
3820 void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload,
3823 pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, st->time_base);
3826 void av_url_split(char *proto, int proto_size,
3827 char *authorization, int authorization_size,
3828 char *hostname, int hostname_size,
3830 char *path, int path_size,
3833 const char *p, *ls, *at, *col, *brk;
3835 if (port_ptr) *port_ptr = -1;
3836 if (proto_size > 0) proto[0] = 0;
3837 if (authorization_size > 0) authorization[0] = 0;
3838 if (hostname_size > 0) hostname[0] = 0;
3839 if (path_size > 0) path[0] = 0;
3841 /* parse protocol */
3842 if ((p = strchr(url, ':'))) {
3843 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3848 /* no protocol means plain filename */
3849 av_strlcpy(path, url, path_size);
3853 /* separate path from hostname */
3854 ls = strchr(p, '/');
3856 ls = strchr(p, '?');
3858 av_strlcpy(path, ls, path_size);
3860 ls = &p[strlen(p)]; // XXX
3862 /* the rest is hostname, use that to parse auth/port */
3864 /* authorization (user[:pass]@hostname) */
3865 if ((at = strchr(p, '@')) && at < ls) {
3866 av_strlcpy(authorization, p,
3867 FFMIN(authorization_size, at + 1 - p));
3868 p = at + 1; /* skip '@' */
3871 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3873 av_strlcpy(hostname, p + 1,
3874 FFMIN(hostname_size, brk - p));
3875 if (brk[1] == ':' && port_ptr)
3876 *port_ptr = atoi(brk + 2);
3877 } else if ((col = strchr(p, ':')) && col < ls) {
3878 av_strlcpy(hostname, p,
3879 FFMIN(col + 1 - p, hostname_size));
3880 if (port_ptr) *port_ptr = atoi(col + 1);
3882 av_strlcpy(hostname, p,
3883 FFMIN(ls + 1 - p, hostname_size));
3887 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3890 static const char hex_table_uc[16] = { '0', '1', '2', '3',
3893 'C', 'D', 'E', 'F' };
3894 static const char hex_table_lc[16] = { '0', '1', '2', '3',
3897 'c', 'd', 'e', 'f' };
3898 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3900 for(i = 0; i < s; i++) {
3901 buff[i * 2] = hex_table[src[i] >> 4];
3902 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3908 int ff_hex_to_data(uint8_t *data, const char *p)
3915 p += strspn(p, SPACE_CHARS);
3918 c = toupper((unsigned char) *p++);
3919 if (c >= '0' && c <= '9')
3921 else if (c >= 'A' && c <= 'F')
3936 #if FF_API_SET_PTS_INFO
3937 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3938 unsigned int pts_num, unsigned int pts_den)
3940 avpriv_set_pts_info(s, pts_wrap_bits, pts_num, pts_den);
3944 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
3945 unsigned int pts_num, unsigned int pts_den)
3948 if(av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)){
3949 if(new_tb.num != pts_num)
3950 av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/new_tb.num);
3952 av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3954 if(new_tb.num <= 0 || new_tb.den <= 0) {
3955 av_log(NULL, AV_LOG_ERROR, "Ignoring attempt to set invalid timebase for st:%d\n", s->index);
3958 s->time_base = new_tb;
3959 s->pts_wrap_bits = pts_wrap_bits;
3962 int ff_url_join(char *str, int size, const char *proto,
3963 const char *authorization, const char *hostname,
3964 int port, const char *fmt, ...)
3967 struct addrinfo hints, *ai;
3972 av_strlcatf(str, size, "%s://", proto);
3973 if (authorization && authorization[0])
3974 av_strlcatf(str, size, "%s@", authorization);
3975 #if CONFIG_NETWORK && defined(AF_INET6)
3976 /* Determine if hostname is a numerical IPv6 address,
3977 * properly escape it within [] in that case. */
3978 memset(&hints, 0, sizeof(hints));
3979 hints.ai_flags = AI_NUMERICHOST;
3980 if (!getaddrinfo(hostname, NULL, &hints, &ai)) {
3981 if (ai->ai_family == AF_INET6) {
3982 av_strlcat(str, "[", size);
3983 av_strlcat(str, hostname, size);
3984 av_strlcat(str, "]", size);
3986 av_strlcat(str, hostname, size);
3991 /* Not an IPv6 address, just output the plain string. */
3992 av_strlcat(str, hostname, size);
3995 av_strlcatf(str, size, ":%d", port);
3998 int len = strlen(str);
4001 vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);
4007 int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
4008 AVFormatContext *src)
4013 local_pkt.stream_index = dst_stream;
4014 if (pkt->pts != AV_NOPTS_VALUE)
4015 local_pkt.pts = av_rescale_q(pkt->pts,
4016 src->streams[pkt->stream_index]->time_base,
4017 dst->streams[dst_stream]->time_base);
4018 if (pkt->dts != AV_NOPTS_VALUE)
4019 local_pkt.dts = av_rescale_q(pkt->dts,
4020 src->streams[pkt->stream_index]->time_base,
4021 dst->streams[dst_stream]->time_base);
4022 return av_write_frame(dst, &local_pkt);
4025 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
4028 const char *ptr = str;
4030 /* Parse key=value pairs. */
4033 char *dest = NULL, *dest_end;
4034 int key_len, dest_len = 0;
4036 /* Skip whitespace and potential commas. */
4037 while (*ptr && (isspace(*ptr) || *ptr == ','))
4044 if (!(ptr = strchr(key, '=')))
4047 key_len = ptr - key;
4049 callback_get_buf(context, key, key_len, &dest, &dest_len);
4050 dest_end = dest + dest_len - 1;
4054 while (*ptr && *ptr != '\"') {
4058 if (dest && dest < dest_end)
4062 if (dest && dest < dest_end)
4070 for (; *ptr && !(isspace(*ptr) || *ptr == ','); ptr++)
4071 if (dest && dest < dest_end)
4079 int ff_find_stream_index(AVFormatContext *s, int id)
4082 for (i = 0; i < s->nb_streams; i++) {
4083 if (s->streams[i]->id == id)
4089 void ff_make_absolute_url(char *buf, int size, const char *base,
4093 /* Absolute path, relative to the current server */
4094 if (base && strstr(base, "://") && rel[0] == '/') {
4096 av_strlcpy(buf, base, size);
4097 sep = strstr(buf, "://");
4100 sep = strchr(sep, '/');
4104 av_strlcat(buf, rel, size);
4107 /* If rel actually is an absolute url, just copy it */
4108 if (!base || strstr(rel, "://") || rel[0] == '/') {
4109 av_strlcpy(buf, rel, size);
4113 av_strlcpy(buf, base, size);
4114 /* Remove the file name from the base url */
4115 sep = strrchr(buf, '/');
4120 while (av_strstart(rel, "../", NULL) && sep) {
4121 /* Remove the path delimiter at the end */
4123 sep = strrchr(buf, '/');
4124 /* If the next directory name to pop off is "..", break here */
4125 if (!strcmp(sep ? &sep[1] : buf, "..")) {
4126 /* Readd the slash we just removed */
4127 av_strlcat(buf, "/", size);
4130 /* Cut off the directory name */
4137 av_strlcat(buf, rel, size);
4140 int64_t ff_iso8601_to_unix_time(const char *datestr)
4143 struct tm time1 = {0}, time2 = {0};
4145 ret1 = strptime(datestr, "%Y - %m - %d %T", &time1);
4146 ret2 = strptime(datestr, "%Y - %m - %dT%T", &time2);
4148 return av_timegm(&time2);
4150 return av_timegm(&time1);
4152 av_log(NULL, AV_LOG_WARNING, "strptime() unavailable on this system, cannot convert "
4153 "the date string.\n");
4158 int avformat_query_codec(AVOutputFormat *ofmt, enum CodecID codec_id, int std_compliance)
4161 if (ofmt->query_codec)
4162 return ofmt->query_codec(codec_id, std_compliance);
4163 else if (ofmt->codec_tag)
4164 return !!av_codec_get_tag(ofmt->codec_tag, codec_id);
4165 else if (codec_id == ofmt->video_codec || codec_id == ofmt->audio_codec ||
4166 codec_id == ofmt->subtitle_codec)
4169 return AVERROR_PATCHWELCOME;
4172 int avformat_network_init(void)
4176 ff_network_inited_globally = 1;
4177 if ((ret = ff_network_init()) < 0)
4184 int avformat_network_deinit(void)
4193 int ff_add_param_change(AVPacket *pkt, int32_t channels,
4194 uint64_t channel_layout, int32_t sample_rate,
4195 int32_t width, int32_t height)
4201 return AVERROR(EINVAL);
4204 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
4206 if (channel_layout) {
4208 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
4212 flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
4214 if (width || height) {
4216 flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
4218 data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
4220 return AVERROR(ENOMEM);
4221 bytestream_put_le32(&data, flags);
4223 bytestream_put_le32(&data, channels);
4225 bytestream_put_le64(&data, channel_layout);
4227 bytestream_put_le32(&data, sample_rate);
4228 if (width || height) {
4229 bytestream_put_le32(&data, width);
4230 bytestream_put_le32(&data, height);
4235 const struct AVCodecTag *avformat_get_riff_video_tags(void)
4237 return ff_codec_bmp_tags;
4239 const struct AVCodecTag *avformat_get_riff_audio_tags(void)
4241 return ff_codec_wav_tags;