2 * various utility functions for use within Libav
3 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
5 * This file is part of Libav.
7 * Libav 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 * Libav 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 Libav; 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 "libavutil/opt.h"
29 #include "libavutil/dict.h"
30 #include "libavutil/pixdesc.h"
33 #include "libavutil/avstring.h"
34 #include "libavutil/mathematics.h"
36 #include "audiointerleave.h"
51 * various utility functions for use within Libav
54 unsigned avformat_version(void)
56 return LIBAVFORMAT_VERSION_INT;
59 const char *avformat_configuration(void)
61 return LIBAV_CONFIGURATION;
64 const char *avformat_license(void)
66 #define LICENSE_PREFIX "libavformat license: "
67 return LICENSE_PREFIX LIBAV_LICENSE + sizeof(LICENSE_PREFIX) - 1;
70 /* fraction handling */
73 * f = val + (num / den) + 0.5.
75 * 'num' is normalized so that it is such as 0 <= num < den.
77 * @param f fractional number
78 * @param val integer value
79 * @param num must be >= 0
80 * @param den must be >= 1
82 static void frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
95 * Fractional addition to f: f = f + (incr / f->den).
97 * @param f fractional number
98 * @param incr increment, can be positive or negative
100 static void frac_add(AVFrac *f, int64_t incr)
113 } else if (num >= den) {
120 /** head of registered input format linked list */
121 static AVInputFormat *first_iformat = NULL;
122 /** head of registered output format linked list */
123 static AVOutputFormat *first_oformat = NULL;
125 AVInputFormat *av_iformat_next(AVInputFormat *f)
127 if(f) return f->next;
128 else return first_iformat;
131 AVOutputFormat *av_oformat_next(AVOutputFormat *f)
133 if(f) return f->next;
134 else return first_oformat;
137 void av_register_input_format(AVInputFormat *format)
141 while (*p != NULL) p = &(*p)->next;
146 void av_register_output_format(AVOutputFormat *format)
150 while (*p != NULL) p = &(*p)->next;
155 int av_match_ext(const char *filename, const char *extensions)
163 ext = strrchr(filename, '.');
169 while (*p != '\0' && *p != ',' && q-ext1<sizeof(ext1)-1)
172 if (!strcasecmp(ext1, ext))
182 static int match_format(const char *name, const char *names)
190 namelen = strlen(name);
191 while ((p = strchr(names, ','))) {
192 len = FFMAX(p - names, namelen);
193 if (!strncasecmp(name, names, len))
197 return !strcasecmp(name, names);
200 AVOutputFormat *av_guess_format(const char *short_name, const char *filename,
201 const char *mime_type)
203 AVOutputFormat *fmt = NULL, *fmt_found;
204 int score_max, score;
206 /* specific test for image sequences */
207 #if CONFIG_IMAGE2_MUXER
208 if (!short_name && filename &&
209 av_filename_number_test(filename) &&
210 ff_guess_image2_codec(filename) != CODEC_ID_NONE) {
211 return av_guess_format("image2", NULL, NULL);
214 /* Find the proper file type. */
217 while ((fmt = av_oformat_next(fmt))) {
219 if (fmt->name && short_name && !strcmp(fmt->name, short_name))
221 if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
223 if (filename && fmt->extensions &&
224 av_match_ext(filename, fmt->extensions)) {
227 if (score > score_max) {
235 enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
236 const char *filename, const char *mime_type, enum AVMediaType type){
237 if(type == AVMEDIA_TYPE_VIDEO){
238 enum CodecID codec_id= CODEC_ID_NONE;
240 #if CONFIG_IMAGE2_MUXER
241 if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
242 codec_id= ff_guess_image2_codec(filename);
245 if(codec_id == CODEC_ID_NONE)
246 codec_id= fmt->video_codec;
248 }else if(type == AVMEDIA_TYPE_AUDIO)
249 return fmt->audio_codec;
250 else if (type == AVMEDIA_TYPE_SUBTITLE)
251 return fmt->subtitle_codec;
253 return CODEC_ID_NONE;
256 AVInputFormat *av_find_input_format(const char *short_name)
258 AVInputFormat *fmt = NULL;
259 while ((fmt = av_iformat_next(fmt))) {
260 if (match_format(short_name, fmt->name))
267 int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
269 int ret= av_new_packet(pkt, size);
274 pkt->pos= avio_tell(s);
276 ret= avio_read(s, pkt->data, size);
280 av_shrink_packet(pkt, ret);
285 int av_append_packet(AVIOContext *s, AVPacket *pkt, int size)
290 return av_get_packet(s, pkt, size);
291 old_size = pkt->size;
292 ret = av_grow_packet(pkt, size);
295 ret = avio_read(s, pkt->data + old_size, size);
296 av_shrink_packet(pkt, old_size + FFMAX(ret, 0));
301 int av_filename_number_test(const char *filename)
304 return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
307 AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
309 AVProbeData lpd = *pd;
310 AVInputFormat *fmt1 = NULL, *fmt;
313 if (lpd.buf_size > 10 && ff_id3v2_match(lpd.buf, ID3v2_DEFAULT_MAGIC)) {
314 int id3len = ff_id3v2_tag_len(lpd.buf);
315 if (lpd.buf_size > id3len + 16) {
317 lpd.buf_size -= id3len;
323 while ((fmt1 = av_iformat_next(fmt1))) {
324 if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
327 if (fmt1->read_probe) {
328 score = fmt1->read_probe(&lpd);
329 } else if (fmt1->extensions) {
330 if (av_match_ext(lpd.filename, fmt1->extensions)) {
334 if (score > *score_max) {
337 }else if (score == *score_max)
341 /* a hack for files with huge id3v2 tags -- try to guess by file extension. */
342 if (!fmt && id3 && *score_max < AVPROBE_SCORE_MAX/4) {
343 while ((fmt = av_iformat_next(fmt)))
344 if (fmt->extensions && av_match_ext(lpd.filename, fmt->extensions)) {
345 *score_max = AVPROBE_SCORE_MAX/4;
353 AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
355 return av_probe_input_format2(pd, is_opened, &score);
358 static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st, AVProbeData *pd, int score)
360 static const struct {
361 const char *name; enum CodecID id; enum AVMediaType type;
363 { "aac" , CODEC_ID_AAC , AVMEDIA_TYPE_AUDIO },
364 { "ac3" , CODEC_ID_AC3 , AVMEDIA_TYPE_AUDIO },
365 { "dts" , CODEC_ID_DTS , AVMEDIA_TYPE_AUDIO },
366 { "eac3" , CODEC_ID_EAC3 , AVMEDIA_TYPE_AUDIO },
367 { "h264" , CODEC_ID_H264 , AVMEDIA_TYPE_VIDEO },
368 { "m4v" , CODEC_ID_MPEG4 , AVMEDIA_TYPE_VIDEO },
369 { "mp3" , CODEC_ID_MP3 , AVMEDIA_TYPE_AUDIO },
370 { "mpegvideo", CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
373 AVInputFormat *fmt = av_probe_input_format2(pd, 1, &score);
377 av_log(s, AV_LOG_DEBUG, "Probe with size=%d, packets=%d detected %s with score=%d\n",
378 pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets, fmt->name, score);
379 for (i = 0; fmt_id_type[i].name; i++) {
380 if (!strcmp(fmt->name, fmt_id_type[i].name)) {
381 st->codec->codec_id = fmt_id_type[i].id;
382 st->codec->codec_type = fmt_id_type[i].type;
390 /************************************************************/
391 /* input media file */
393 #if FF_API_FORMAT_PARAMETERS
394 static AVDictionary *convert_format_parameters(AVFormatParameters *ap)
397 AVDictionary *opts = NULL;
402 if (ap->time_base.num) {
403 snprintf(buf, sizeof(buf), "%d/%d", ap->time_base.den, ap->time_base.num);
404 av_dict_set(&opts, "framerate", buf, 0);
406 if (ap->sample_rate) {
407 snprintf(buf, sizeof(buf), "%d", ap->sample_rate);
408 av_dict_set(&opts, "sample_rate", buf, 0);
411 snprintf(buf, sizeof(buf), "%d", ap->channels);
412 av_dict_set(&opts, "channels", buf, 0);
414 if (ap->width || ap->height) {
415 snprintf(buf, sizeof(buf), "%dx%d", ap->width, ap->height);
416 av_dict_set(&opts, "video_size", buf, 0);
418 if (ap->pix_fmt != PIX_FMT_NONE) {
419 av_dict_set(&opts, "pixel_format", av_get_pix_fmt_name(ap->pix_fmt), 0);
422 snprintf(buf, sizeof(buf), "%d", ap->channel);
423 av_dict_set(&opts, "channel", buf, 0);
426 av_dict_set(&opts, "standard", ap->standard, 0);
428 if (ap->mpeg2ts_compute_pcr) {
429 av_dict_set(&opts, "mpeg2ts_compute_pcr", "1", 0);
431 if (ap->initial_pause) {
432 av_dict_set(&opts, "initial_pause", "1", 0);
438 * Open a media file from an IO stream. 'fmt' must be specified.
440 int av_open_input_stream(AVFormatContext **ic_ptr,
441 AVIOContext *pb, const char *filename,
442 AVInputFormat *fmt, AVFormatParameters *ap)
447 AVFormatParameters default_ap;
451 memset(ap, 0, sizeof(default_ap));
453 opts = convert_format_parameters(ap);
455 if(!ap->prealloced_context)
456 ic = avformat_alloc_context();
460 err = AVERROR(ENOMEM);
463 if (pb && fmt && fmt->flags & AVFMT_NOFILE)
464 av_log(ic, AV_LOG_WARNING, "Custom AVIOContext makes no sense and "
465 "will be ignored with AVFMT_NOFILE format.\n");
469 if ((err = avformat_open_input(&ic, filename, fmt, &opts)) < 0)
471 ic->pb = ic->pb ? ic->pb : pb; // don't leak custom pb if it wasn't set above
480 /** size of probe buffer, for guessing file type from file contents */
481 #define PROBE_BUF_MIN 2048
482 #define PROBE_BUF_MAX (1<<20)
484 int av_probe_input_buffer(AVIOContext *pb, AVInputFormat **fmt,
485 const char *filename, void *logctx,
486 unsigned int offset, unsigned int max_probe_size)
488 AVProbeData pd = { filename ? filename : "", NULL, -offset };
489 unsigned char *buf = NULL;
490 int ret = 0, probe_size;
492 if (!max_probe_size) {
493 max_probe_size = PROBE_BUF_MAX;
494 } else if (max_probe_size > PROBE_BUF_MAX) {
495 max_probe_size = PROBE_BUF_MAX;
496 } else if (max_probe_size < PROBE_BUF_MIN) {
497 return AVERROR(EINVAL);
500 if (offset >= max_probe_size) {
501 return AVERROR(EINVAL);
504 for(probe_size= PROBE_BUF_MIN; probe_size<=max_probe_size && !*fmt && ret >= 0;
505 probe_size = FFMIN(probe_size<<1, FFMAX(max_probe_size, probe_size+1))) {
506 int ret, score = probe_size < max_probe_size ? AVPROBE_SCORE_MAX/4 : 0;
507 int buf_offset = (probe_size == PROBE_BUF_MIN) ? 0 : probe_size>>1;
509 if (probe_size < offset) {
513 /* read probe data */
514 buf = av_realloc(buf, probe_size + AVPROBE_PADDING_SIZE);
515 if ((ret = avio_read(pb, buf + buf_offset, probe_size - buf_offset)) < 0) {
516 /* fail if error was not end of file, otherwise, lower score */
517 if (ret != AVERROR_EOF) {
522 ret = 0; /* error was end of file, nothing read */
525 pd.buf = &buf[offset];
527 memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE);
529 /* guess file format */
530 *fmt = av_probe_input_format2(&pd, 1, &score);
532 if(score <= AVPROBE_SCORE_MAX/4){ //this can only be true in the last iteration
533 av_log(logctx, AV_LOG_WARNING, "Format detected only with low score of %d, misdetection possible!\n", score);
535 av_log(logctx, AV_LOG_DEBUG, "Probed with size=%d and score=%d\n", probe_size, score);
541 return AVERROR_INVALIDDATA;
544 /* rewind. reuse probe buffer to avoid seeking */
545 if ((ret = ffio_rewind_with_probe_data(pb, buf, pd.buf_size)) < 0)
551 #if FF_API_FORMAT_PARAMETERS
552 int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
555 AVFormatParameters *ap)
558 AVDictionary *opts = convert_format_parameters(ap);
560 if (!ap || !ap->prealloced_context)
563 err = avformat_open_input(ic_ptr, filename, fmt, &opts);
570 /* open input file and probe the format if necessary */
571 static int init_input(AVFormatContext *s, const char *filename)
574 AVProbeData pd = {filename, NULL, 0};
577 s->flags |= AVFMT_FLAG_CUSTOM_IO;
579 return av_probe_input_buffer(s->pb, &s->iformat, filename, s, 0, 0);
580 else if (s->iformat->flags & AVFMT_NOFILE)
581 return AVERROR(EINVAL);
585 if ( (s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
586 (!s->iformat && (s->iformat = av_probe_input_format(&pd, 0))))
589 if ((ret = avio_open(&s->pb, filename, AVIO_FLAG_READ)) < 0)
593 return av_probe_input_buffer(s->pb, &s->iformat, filename, s, 0, 0);
596 int avformat_open_input(AVFormatContext **ps, const char *filename, AVInputFormat *fmt, AVDictionary **options)
598 AVFormatContext *s = *ps;
600 AVFormatParameters ap = { { 0 } };
601 AVDictionary *tmp = NULL;
603 if (!s && !(s = avformat_alloc_context()))
604 return AVERROR(ENOMEM);
609 av_dict_copy(&tmp, *options, 0);
611 if ((ret = av_opt_set_dict(s, &tmp)) < 0)
614 if ((ret = init_input(s, filename)) < 0)
617 /* check filename in case an image number is expected */
618 if (s->iformat->flags & AVFMT_NEEDNUMBER) {
619 if (!av_filename_number_test(filename)) {
620 ret = AVERROR(EINVAL);
625 s->duration = s->start_time = AV_NOPTS_VALUE;
626 av_strlcpy(s->filename, filename, sizeof(s->filename));
628 /* allocate private data */
629 if (s->iformat->priv_data_size > 0) {
630 if (!(s->priv_data = av_mallocz(s->iformat->priv_data_size))) {
631 ret = AVERROR(ENOMEM);
634 if (s->iformat->priv_class) {
635 *(const AVClass**)s->priv_data = s->iformat->priv_class;
636 av_opt_set_defaults(s->priv_data);
637 if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
642 /* e.g. AVFMT_NOFILE formats will not have a AVIOContext */
644 ff_id3v2_read(s, ID3v2_DEFAULT_MAGIC);
646 if (s->iformat->read_header)
647 if ((ret = s->iformat->read_header(s, &ap)) < 0)
650 if (s->pb && !s->data_offset)
651 s->data_offset = avio_tell(s->pb);
653 s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
656 av_dict_free(options);
664 if (s->pb && !(s->flags & AVFMT_FLAG_CUSTOM_IO))
666 avformat_free_context(s);
671 /*******************************************************/
673 static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
674 AVPacketList **plast_pktl){
675 AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
680 (*plast_pktl)->next = pktl;
682 *packet_buffer = pktl;
684 /* add the packet in the buffered packet list */
690 int av_read_packet(AVFormatContext *s, AVPacket *pkt)
696 AVPacketList *pktl = s->raw_packet_buffer;
700 if(s->streams[pkt->stream_index]->codec->codec_id != CODEC_ID_PROBE ||
701 !s->streams[pkt->stream_index]->probe_packets ||
702 s->raw_packet_buffer_remaining_size < pkt->size){
703 AVProbeData *pd = &s->streams[pkt->stream_index]->probe_data;
706 s->raw_packet_buffer = pktl->next;
707 s->raw_packet_buffer_remaining_size += pkt->size;
714 ret= s->iformat->read_packet(s, pkt);
716 if (!pktl || ret == AVERROR(EAGAIN))
718 for (i = 0; i < s->nb_streams; i++)
719 s->streams[i]->probe_packets = 0;
722 st= s->streams[pkt->stream_index];
724 switch(st->codec->codec_type){
725 case AVMEDIA_TYPE_VIDEO:
726 if(s->video_codec_id) st->codec->codec_id= s->video_codec_id;
728 case AVMEDIA_TYPE_AUDIO:
729 if(s->audio_codec_id) st->codec->codec_id= s->audio_codec_id;
731 case AVMEDIA_TYPE_SUBTITLE:
732 if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
736 if(!pktl && (st->codec->codec_id != CODEC_ID_PROBE ||
740 add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
741 s->raw_packet_buffer_remaining_size -= pkt->size;
743 if(st->codec->codec_id == CODEC_ID_PROBE){
744 AVProbeData *pd = &st->probe_data;
745 av_log(s, AV_LOG_DEBUG, "probing stream %d\n", st->index);
748 pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
749 memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
750 pd->buf_size += pkt->size;
751 memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
753 if(av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)){
754 //FIXME we dont reduce score to 0 for the case of running out of buffer space in bytes
755 set_codec_from_probe_data(s, st, pd, st->probe_packets > 0 ? AVPROBE_SCORE_MAX/4 : 0);
756 if(st->codec->codec_id != CODEC_ID_PROBE){
759 av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
766 /**********************************************************/
769 * Get the number of samples of an audio frame. Return -1 on error.
771 static int get_audio_frame_size(AVCodecContext *enc, int size)
775 if(enc->codec_id == CODEC_ID_VORBIS)
778 if (enc->frame_size <= 1) {
779 int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
781 if (bits_per_sample) {
782 if (enc->channels == 0)
784 frame_size = (size << 3) / (bits_per_sample * enc->channels);
786 /* used for example by ADPCM codecs */
787 if (enc->bit_rate == 0)
789 frame_size = ((int64_t)size * 8 * enc->sample_rate) / enc->bit_rate;
792 frame_size = enc->frame_size;
799 * Return the frame duration in seconds. Return 0 if not available.
801 static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
802 AVCodecParserContext *pc, AVPacket *pkt)
808 switch(st->codec->codec_type) {
809 case AVMEDIA_TYPE_VIDEO:
810 if(st->time_base.num*1000LL > st->time_base.den){
811 *pnum = st->time_base.num;
812 *pden = st->time_base.den;
813 }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
814 *pnum = st->codec->time_base.num;
815 *pden = st->codec->time_base.den;
816 if (pc && pc->repeat_pict) {
817 *pnum = (*pnum) * (1 + pc->repeat_pict);
819 //If this codec can be interlaced or progressive then we need a parser to compute duration of a packet
820 //Thus if we have no parser in such case leave duration undefined.
821 if(st->codec->ticks_per_frame>1 && !pc){
826 case AVMEDIA_TYPE_AUDIO:
827 frame_size = get_audio_frame_size(st->codec, pkt->size);
828 if (frame_size <= 0 || st->codec->sample_rate <= 0)
831 *pden = st->codec->sample_rate;
838 static int is_intra_only(AVCodecContext *enc){
839 if(enc->codec_type == AVMEDIA_TYPE_AUDIO){
841 }else if(enc->codec_type == AVMEDIA_TYPE_VIDEO){
842 switch(enc->codec_id){
844 case CODEC_ID_MJPEGB:
846 case CODEC_ID_RAWVIDEO:
847 case CODEC_ID_DVVIDEO:
848 case CODEC_ID_HUFFYUV:
849 case CODEC_ID_FFVHUFF:
854 case CODEC_ID_JPEG2000:
862 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
863 int64_t dts, int64_t pts)
865 AVStream *st= s->streams[stream_index];
866 AVPacketList *pktl= s->packet_buffer;
868 if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE)
871 st->first_dts= dts - st->cur_dts;
874 for(; pktl; pktl= pktl->next){
875 if(pktl->pkt.stream_index != stream_index)
877 //FIXME think more about this check
878 if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
879 pktl->pkt.pts += st->first_dts;
881 if(pktl->pkt.dts != AV_NOPTS_VALUE)
882 pktl->pkt.dts += st->first_dts;
884 if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
885 st->start_time= pktl->pkt.pts;
887 if (st->start_time == AV_NOPTS_VALUE)
888 st->start_time = pts;
891 static void update_initial_durations(AVFormatContext *s, AVStream *st, AVPacket *pkt)
893 AVPacketList *pktl= s->packet_buffer;
896 if(st->first_dts != AV_NOPTS_VALUE){
897 cur_dts= st->first_dts;
898 for(; pktl; pktl= pktl->next){
899 if(pktl->pkt.stream_index == pkt->stream_index){
900 if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
902 cur_dts -= pkt->duration;
905 pktl= s->packet_buffer;
906 st->first_dts = cur_dts;
907 }else if(st->cur_dts)
910 for(; pktl; pktl= pktl->next){
911 if(pktl->pkt.stream_index != pkt->stream_index)
913 if(pktl->pkt.pts == pktl->pkt.dts && pktl->pkt.dts == AV_NOPTS_VALUE
914 && !pktl->pkt.duration){
915 pktl->pkt.dts= cur_dts;
916 if(!st->codec->has_b_frames)
917 pktl->pkt.pts= cur_dts;
918 cur_dts += pkt->duration;
919 pktl->pkt.duration= pkt->duration;
923 if(st->first_dts == AV_NOPTS_VALUE)
924 st->cur_dts= cur_dts;
927 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
928 AVCodecParserContext *pc, AVPacket *pkt)
930 int num, den, presentation_delayed, delay, i;
933 if (s->flags & AVFMT_FLAG_NOFILLIN)
936 if((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
937 pkt->dts= AV_NOPTS_VALUE;
939 if (st->codec->codec_id != CODEC_ID_H264 && pc && pc->pict_type == AV_PICTURE_TYPE_B)
940 //FIXME Set low_delay = 0 when has_b_frames = 1
941 st->codec->has_b_frames = 1;
943 /* do we have a video B-frame ? */
944 delay= st->codec->has_b_frames;
945 presentation_delayed = 0;
947 // ignore delay caused by frame threading so that the mpeg2-without-dts
948 // warning will not trigger
949 if (delay && st->codec->active_thread_type&FF_THREAD_FRAME)
950 delay -= st->codec->thread_count-1;
952 /* XXX: need has_b_frame, but cannot get it if the codec is
955 pc && pc->pict_type != AV_PICTURE_TYPE_B)
956 presentation_delayed = 1;
958 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
959 /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
960 pkt->dts -= 1LL<<st->pts_wrap_bits;
963 // some mpeg2 in mpeg-ps lack dts (issue171 / input_file.mpg)
964 // we take the conservative approach and discard both
965 // Note, if this is misbehaving for a H.264 file then possibly presentation_delayed is not set correctly.
966 if(delay==1 && pkt->dts == pkt->pts && pkt->dts != AV_NOPTS_VALUE && presentation_delayed){
967 av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination\n");
968 pkt->dts= pkt->pts= AV_NOPTS_VALUE;
971 if (pkt->duration == 0) {
972 compute_frame_duration(&num, &den, st, pc, pkt);
974 pkt->duration = av_rescale_rnd(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num, AV_ROUND_DOWN);
976 if(pkt->duration != 0 && s->packet_buffer)
977 update_initial_durations(s, st, pkt);
981 /* correct timestamps with byte offset if demuxers only have timestamps
982 on packet boundaries */
983 if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
984 /* this will estimate bitrate based on this frame's duration and size */
985 offset = av_rescale(pc->offset, pkt->duration, pkt->size);
986 if(pkt->pts != AV_NOPTS_VALUE)
988 if(pkt->dts != AV_NOPTS_VALUE)
992 if (pc && pc->dts_sync_point >= 0) {
993 // we have synchronization info from the parser
994 int64_t den = st->codec->time_base.den * (int64_t) st->time_base.num;
996 int64_t num = st->codec->time_base.num * (int64_t) st->time_base.den;
997 if (pkt->dts != AV_NOPTS_VALUE) {
998 // got DTS from the stream, update reference timestamp
999 st->reference_dts = pkt->dts - pc->dts_ref_dts_delta * num / den;
1000 pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
1001 } else if (st->reference_dts != AV_NOPTS_VALUE) {
1002 // compute DTS based on reference timestamp
1003 pkt->dts = st->reference_dts + pc->dts_ref_dts_delta * num / den;
1004 pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
1006 if (pc->dts_sync_point > 0)
1007 st->reference_dts = pkt->dts; // new reference
1011 /* This may be redundant, but it should not hurt. */
1012 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
1013 presentation_delayed = 1;
1015 // 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);
1016 /* interpolate PTS and DTS if they are not present */
1017 //We skip H264 currently because delay and has_b_frames are not reliably set
1018 if((delay==0 || (delay==1 && pc)) && st->codec->codec_id != CODEC_ID_H264){
1019 if (presentation_delayed) {
1020 /* DTS = decompression timestamp */
1021 /* PTS = presentation timestamp */
1022 if (pkt->dts == AV_NOPTS_VALUE)
1023 pkt->dts = st->last_IP_pts;
1024 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
1025 if (pkt->dts == AV_NOPTS_VALUE)
1026 pkt->dts = st->cur_dts;
1028 /* this is tricky: the dts must be incremented by the duration
1029 of the frame we are displaying, i.e. the last I- or P-frame */
1030 if (st->last_IP_duration == 0)
1031 st->last_IP_duration = pkt->duration;
1032 if(pkt->dts != AV_NOPTS_VALUE)
1033 st->cur_dts = pkt->dts + st->last_IP_duration;
1034 st->last_IP_duration = pkt->duration;
1035 st->last_IP_pts= pkt->pts;
1036 /* cannot compute PTS if not present (we can compute it only
1037 by knowing the future */
1038 } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
1039 if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
1040 int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
1041 int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
1042 if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
1043 pkt->pts += pkt->duration;
1044 // 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);
1048 /* presentation is not delayed : PTS and DTS are the same */
1049 if(pkt->pts == AV_NOPTS_VALUE)
1050 pkt->pts = pkt->dts;
1051 update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
1052 if(pkt->pts == AV_NOPTS_VALUE)
1053 pkt->pts = st->cur_dts;
1054 pkt->dts = pkt->pts;
1055 if(pkt->pts != AV_NOPTS_VALUE)
1056 st->cur_dts = pkt->pts + pkt->duration;
1060 if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
1061 st->pts_buffer[0]= pkt->pts;
1062 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
1063 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
1064 if(pkt->dts == AV_NOPTS_VALUE)
1065 pkt->dts= st->pts_buffer[0];
1066 if(st->codec->codec_id == CODEC_ID_H264){ //we skiped it above so we try here
1067 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
1069 if(pkt->dts > st->cur_dts)
1070 st->cur_dts = pkt->dts;
1073 // 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);
1076 if(is_intra_only(st->codec))
1077 pkt->flags |= AV_PKT_FLAG_KEY;
1080 /* keyframe computation */
1081 if (pc->key_frame == 1)
1082 pkt->flags |= AV_PKT_FLAG_KEY;
1083 else if (pc->key_frame == -1 && pc->pict_type == AV_PICTURE_TYPE_I)
1084 pkt->flags |= AV_PKT_FLAG_KEY;
1087 pkt->convergence_duration = pc->convergence_duration;
1091 static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1096 av_init_packet(pkt);
1099 /* select current input stream component */
1102 if (!st->need_parsing || !st->parser) {
1103 /* no parsing needed: we just output the packet as is */
1104 /* raw data support */
1105 *pkt = st->cur_pkt; st->cur_pkt.data= NULL;
1106 compute_pkt_fields(s, st, NULL, pkt);
1108 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1109 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1110 ff_reduce_index(s, st->index);
1111 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1114 } else if (st->cur_len > 0 && st->discard < AVDISCARD_ALL) {
1115 len = av_parser_parse2(st->parser, st->codec, &pkt->data, &pkt->size,
1116 st->cur_ptr, st->cur_len,
1117 st->cur_pkt.pts, st->cur_pkt.dts,
1119 st->cur_pkt.pts = AV_NOPTS_VALUE;
1120 st->cur_pkt.dts = AV_NOPTS_VALUE;
1121 /* increment read pointer */
1125 /* return packet if any */
1129 pkt->stream_index = st->index;
1130 pkt->pts = st->parser->pts;
1131 pkt->dts = st->parser->dts;
1132 pkt->pos = st->parser->pos;
1133 if(pkt->data == st->cur_pkt.data && pkt->size == st->cur_pkt.size){
1135 pkt->destruct= st->cur_pkt.destruct;
1136 st->cur_pkt.destruct= NULL;
1137 st->cur_pkt.data = NULL;
1138 assert(st->cur_len == 0);
1140 pkt->destruct = NULL;
1142 compute_pkt_fields(s, st, st->parser, pkt);
1144 if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY){
1145 ff_reduce_index(s, st->index);
1146 av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
1147 0, 0, AVINDEX_KEYFRAME);
1154 av_free_packet(&st->cur_pkt);
1159 /* read next packet */
1160 ret = av_read_packet(s, &cur_pkt);
1162 if (ret == AVERROR(EAGAIN))
1164 /* return the last frames, if any */
1165 for(i = 0; i < s->nb_streams; i++) {
1167 if (st->parser && st->need_parsing) {
1168 av_parser_parse2(st->parser, st->codec,
1169 &pkt->data, &pkt->size,
1171 AV_NOPTS_VALUE, AV_NOPTS_VALUE,
1177 /* no more packets: really terminate parsing */
1180 st = s->streams[cur_pkt.stream_index];
1181 st->cur_pkt= cur_pkt;
1183 if(st->cur_pkt.pts != AV_NOPTS_VALUE &&
1184 st->cur_pkt.dts != AV_NOPTS_VALUE &&
1185 st->cur_pkt.pts < st->cur_pkt.dts){
1186 av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
1187 st->cur_pkt.stream_index,
1191 // av_free_packet(&st->cur_pkt);
1195 if(s->debug & FF_FDEBUG_TS)
1196 av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1197 st->cur_pkt.stream_index,
1201 st->cur_pkt.duration,
1205 st->cur_ptr = st->cur_pkt.data;
1206 st->cur_len = st->cur_pkt.size;
1207 if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1208 st->parser = av_parser_init(st->codec->codec_id);
1210 /* no parser available: just output the raw packets */
1211 st->need_parsing = AVSTREAM_PARSE_NONE;
1212 }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
1213 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1214 }else if(st->need_parsing == AVSTREAM_PARSE_FULL_ONCE){
1215 st->parser->flags |= PARSER_FLAG_ONCE;
1220 if(s->debug & FF_FDEBUG_TS)
1221 av_log(s, AV_LOG_DEBUG, "read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1232 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1236 const int genpts= s->flags & AVFMT_FLAG_GENPTS;
1239 pktl = s->packet_buffer;
1241 AVPacket *next_pkt= &pktl->pkt;
1243 if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
1244 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1245 while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
1246 if( pktl->pkt.stream_index == next_pkt->stream_index
1247 && (0 > av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)))
1248 && av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) { //not b frame
1249 next_pkt->pts= pktl->pkt.dts;
1253 pktl = s->packet_buffer;
1256 if( next_pkt->pts != AV_NOPTS_VALUE
1257 || next_pkt->dts == AV_NOPTS_VALUE
1259 /* read packet from packet buffer, if there is data */
1261 s->packet_buffer = pktl->next;
1267 int 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);
1280 assert(!s->packet_buffer);
1281 return read_frame_internal(s, pkt);
1286 /* XXX: suppress the packet queue */
1287 static void flush_packet_queue(AVFormatContext *s)
1292 pktl = s->packet_buffer;
1295 s->packet_buffer = pktl->next;
1296 av_free_packet(&pktl->pkt);
1299 while(s->raw_packet_buffer){
1300 pktl = s->raw_packet_buffer;
1301 s->raw_packet_buffer = pktl->next;
1302 av_free_packet(&pktl->pkt);
1305 s->packet_buffer_end=
1306 s->raw_packet_buffer_end= NULL;
1307 s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1310 /*******************************************************/
1313 int av_find_default_stream_index(AVFormatContext *s)
1315 int first_audio_index = -1;
1319 if (s->nb_streams <= 0)
1321 for(i = 0; i < s->nb_streams; i++) {
1323 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1326 if (first_audio_index < 0 && st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1327 first_audio_index = i;
1329 return first_audio_index >= 0 ? first_audio_index : 0;
1333 * Flush the frame reader.
1335 void ff_read_frame_flush(AVFormatContext *s)
1340 flush_packet_queue(s);
1344 /* for each stream, reset read state */
1345 for(i = 0; i < s->nb_streams; i++) {
1349 av_parser_close(st->parser);
1351 av_free_packet(&st->cur_pkt);
1353 st->last_IP_pts = AV_NOPTS_VALUE;
1354 st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1355 st->reference_dts = AV_NOPTS_VALUE;
1360 st->probe_packets = MAX_PROBE_PACKETS;
1362 for(j=0; j<MAX_REORDER_DELAY+1; j++)
1363 st->pts_buffer[j]= AV_NOPTS_VALUE;
1367 void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1370 for(i = 0; i < s->nb_streams; i++) {
1371 AVStream *st = s->streams[i];
1373 st->cur_dts = av_rescale(timestamp,
1374 st->time_base.den * (int64_t)ref_st->time_base.num,
1375 st->time_base.num * (int64_t)ref_st->time_base.den);
1379 void ff_reduce_index(AVFormatContext *s, int stream_index)
1381 AVStream *st= s->streams[stream_index];
1382 unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1384 if((unsigned)st->nb_index_entries >= max_entries){
1386 for(i=0; 2*i<st->nb_index_entries; i++)
1387 st->index_entries[i]= st->index_entries[2*i];
1388 st->nb_index_entries= i;
1392 int ff_add_index_entry(AVIndexEntry **index_entries,
1393 int *nb_index_entries,
1394 unsigned int *index_entries_allocated_size,
1395 int64_t pos, int64_t timestamp, int size, int distance, int flags)
1397 AVIndexEntry *entries, *ie;
1400 if((unsigned)*nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1403 entries = av_fast_realloc(*index_entries,
1404 index_entries_allocated_size,
1405 (*nb_index_entries + 1) *
1406 sizeof(AVIndexEntry));
1410 *index_entries= entries;
1412 index= ff_index_search_timestamp(*index_entries, *nb_index_entries, timestamp, AVSEEK_FLAG_ANY);
1415 index= (*nb_index_entries)++;
1416 ie= &entries[index];
1417 assert(index==0 || ie[-1].timestamp < timestamp);
1419 ie= &entries[index];
1420 if(ie->timestamp != timestamp){
1421 if(ie->timestamp <= timestamp)
1423 memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(*nb_index_entries - index));
1424 (*nb_index_entries)++;
1425 }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1426 distance= ie->min_distance;
1430 ie->timestamp = timestamp;
1431 ie->min_distance= distance;
1438 int av_add_index_entry(AVStream *st,
1439 int64_t pos, int64_t timestamp, int size, int distance, int flags)
1441 return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1442 &st->index_entries_allocated_size, pos,
1443 timestamp, size, distance, flags);
1446 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1447 int64_t wanted_timestamp, int flags)
1455 //optimize appending index entries at the end
1456 if(b && entries[b-1].timestamp < wanted_timestamp)
1461 timestamp = entries[m].timestamp;
1462 if(timestamp >= wanted_timestamp)
1464 if(timestamp <= wanted_timestamp)
1467 m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1469 if(!(flags & AVSEEK_FLAG_ANY)){
1470 while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1471 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1480 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1483 return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
1484 wanted_timestamp, flags);
1487 int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1488 AVInputFormat *avif= s->iformat;
1489 int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1490 int64_t ts_min, ts_max, ts;
1495 if (stream_index < 0)
1498 av_dlog(s, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1501 ts_min= AV_NOPTS_VALUE;
1502 pos_limit= -1; //gcc falsely says it may be uninitialized
1504 st= s->streams[stream_index];
1505 if(st->index_entries){
1508 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()
1509 index= FFMAX(index, 0);
1510 e= &st->index_entries[index];
1512 if(e->timestamp <= target_ts || e->pos == e->min_distance){
1514 ts_min= e->timestamp;
1515 av_dlog(s, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1521 index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1522 assert(index < st->nb_index_entries);
1524 e= &st->index_entries[index];
1525 assert(e->timestamp >= target_ts);
1527 ts_max= e->timestamp;
1528 pos_limit= pos_max - e->min_distance;
1529 av_dlog(s, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1530 pos_max,pos_limit, ts_max);
1534 pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1539 if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
1542 av_update_cur_dts(s, st, ts);
1547 int64_t av_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts, int64_t pos_min, int64_t pos_max, int64_t pos_limit, int64_t ts_min, int64_t ts_max, int flags, int64_t *ts_ret, int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t )){
1549 int64_t start_pos, filesize;
1552 av_dlog(s, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1554 if(ts_min == AV_NOPTS_VALUE){
1555 pos_min = s->data_offset;
1556 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1557 if (ts_min == AV_NOPTS_VALUE)
1561 if(ts_max == AV_NOPTS_VALUE){
1563 filesize = avio_size(s->pb);
1564 pos_max = filesize - 1;
1567 ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1569 }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1570 if (ts_max == AV_NOPTS_VALUE)
1574 int64_t tmp_pos= pos_max + 1;
1575 int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1576 if(tmp_ts == AV_NOPTS_VALUE)
1580 if(tmp_pos >= filesize)
1586 if(ts_min > ts_max){
1588 }else if(ts_min == ts_max){
1593 while (pos_min < pos_limit) {
1594 av_dlog(s, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1595 pos_min, pos_max, ts_min, ts_max);
1596 assert(pos_limit <= pos_max);
1599 int64_t approximate_keyframe_distance= pos_max - pos_limit;
1600 // interpolate position (better than dichotomy)
1601 pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1602 + pos_min - approximate_keyframe_distance;
1603 }else if(no_change==1){
1604 // bisection, if interpolation failed to change min or max pos last time
1605 pos = (pos_min + pos_limit)>>1;
1607 /* linear search if bisection failed, can only happen if there
1608 are very few or no keyframes between min/max */
1613 else if(pos > pos_limit)
1617 ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1622 av_dlog(s, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64" target:%"PRId64" limit:%"PRId64" start:%"PRId64" noc:%d\n",
1623 pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts,
1624 pos_limit, start_pos, no_change);
1625 if(ts == AV_NOPTS_VALUE){
1626 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1629 assert(ts != AV_NOPTS_VALUE);
1630 if (target_ts <= ts) {
1631 pos_limit = start_pos - 1;
1635 if (target_ts >= ts) {
1641 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1642 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
1644 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1646 ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1647 av_dlog(s, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1648 pos, ts_min, target_ts, ts_max);
1653 static int seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1654 int64_t pos_min, pos_max;
1658 if (stream_index < 0)
1661 st= s->streams[stream_index];
1664 pos_min = s->data_offset;
1665 pos_max = avio_size(s->pb) - 1;
1667 if (pos < pos_min) pos= pos_min;
1668 else if(pos > pos_max) pos= pos_max;
1670 avio_seek(s->pb, pos, SEEK_SET);
1673 av_update_cur_dts(s, st, ts);
1678 static int seek_frame_generic(AVFormatContext *s,
1679 int stream_index, int64_t timestamp, int flags)
1686 st = s->streams[stream_index];
1688 index = av_index_search_timestamp(st, timestamp, flags);
1690 if(index < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
1693 if(index < 0 || index==st->nb_index_entries-1){
1697 if(st->nb_index_entries){
1698 assert(st->index_entries);
1699 ie= &st->index_entries[st->nb_index_entries-1];
1700 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1702 av_update_cur_dts(s, st, ie->timestamp);
1704 if ((ret = avio_seek(s->pb, s->data_offset, SEEK_SET)) < 0)
1710 ret = av_read_frame(s, &pkt);
1711 }while(ret == AVERROR(EAGAIN));
1714 av_free_packet(&pkt);
1715 if(stream_index == pkt.stream_index){
1716 if((pkt.flags & AV_PKT_FLAG_KEY) && pkt.dts > timestamp)
1720 index = av_index_search_timestamp(st, timestamp, flags);
1725 ff_read_frame_flush(s);
1726 if (s->iformat->read_seek){
1727 if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1730 ie = &st->index_entries[index];
1731 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1733 av_update_cur_dts(s, st, ie->timestamp);
1738 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1743 ff_read_frame_flush(s);
1745 if(flags & AVSEEK_FLAG_BYTE)
1746 return seek_frame_byte(s, stream_index, timestamp, flags);
1748 if(stream_index < 0){
1749 stream_index= av_find_default_stream_index(s);
1750 if(stream_index < 0)
1753 st= s->streams[stream_index];
1754 /* timestamp for default must be expressed in AV_TIME_BASE units */
1755 timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1758 /* first, we try the format specific seek */
1759 if (s->iformat->read_seek)
1760 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1767 if(s->iformat->read_timestamp && !(s->iformat->flags & AVFMT_NOBINSEARCH))
1768 return av_seek_frame_binary(s, stream_index, timestamp, flags);
1769 else if (!(s->iformat->flags & AVFMT_NOGENSEARCH))
1770 return seek_frame_generic(s, stream_index, timestamp, flags);
1775 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
1777 if(min_ts > ts || max_ts < ts)
1780 ff_read_frame_flush(s);
1782 if (s->iformat->read_seek2)
1783 return s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
1785 if(s->iformat->read_timestamp){
1786 //try to seek via read_timestamp()
1789 //Fallback to old API if new is not implemented but old is
1790 //Note the old has somewat different sematics
1791 if(s->iformat->read_seek || 1)
1792 return av_seek_frame(s, stream_index, ts, flags | (ts - min_ts > (uint64_t)(max_ts - ts) ? AVSEEK_FLAG_BACKWARD : 0));
1794 // try some generic seek like seek_frame_generic() but with new ts semantics
1797 /*******************************************************/
1800 * Return TRUE if the stream has accurate duration in any stream.
1802 * @return TRUE if the stream has accurate duration for at least one component.
1804 static int has_duration(AVFormatContext *ic)
1809 for(i = 0;i < ic->nb_streams; i++) {
1810 st = ic->streams[i];
1811 if (st->duration != AV_NOPTS_VALUE)
1818 * Estimate the stream timings from the one of each components.
1820 * Also computes the global bitrate if possible.
1822 static void update_stream_timings(AVFormatContext *ic)
1824 int64_t start_time, start_time1, end_time, end_time1;
1825 int64_t duration, duration1;
1829 start_time = INT64_MAX;
1830 end_time = INT64_MIN;
1831 duration = INT64_MIN;
1832 for(i = 0;i < ic->nb_streams; i++) {
1833 st = ic->streams[i];
1834 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
1835 start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1836 if (start_time1 < start_time)
1837 start_time = start_time1;
1838 if (st->duration != AV_NOPTS_VALUE) {
1839 end_time1 = start_time1
1840 + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1841 if (end_time1 > end_time)
1842 end_time = end_time1;
1845 if (st->duration != AV_NOPTS_VALUE) {
1846 duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1847 if (duration1 > duration)
1848 duration = duration1;
1851 if (start_time != INT64_MAX) {
1852 ic->start_time = start_time;
1853 if (end_time != INT64_MIN) {
1854 if (end_time - start_time > duration)
1855 duration = end_time - start_time;
1858 if (duration != INT64_MIN) {
1859 ic->duration = duration;
1860 if (ic->file_size > 0) {
1861 /* compute the bitrate */
1862 ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1863 (double)ic->duration;
1868 static void fill_all_stream_timings(AVFormatContext *ic)
1873 update_stream_timings(ic);
1874 for(i = 0;i < ic->nb_streams; i++) {
1875 st = ic->streams[i];
1876 if (st->start_time == AV_NOPTS_VALUE) {
1877 if(ic->start_time != AV_NOPTS_VALUE)
1878 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1879 if(ic->duration != AV_NOPTS_VALUE)
1880 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1885 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
1887 int64_t filesize, duration;
1891 /* if bit_rate is already set, we believe it */
1892 if (ic->bit_rate <= 0) {
1894 for(i=0;i<ic->nb_streams;i++) {
1895 st = ic->streams[i];
1896 if (st->codec->bit_rate > 0)
1897 bit_rate += st->codec->bit_rate;
1899 ic->bit_rate = bit_rate;
1902 /* if duration is already set, we believe it */
1903 if (ic->duration == AV_NOPTS_VALUE &&
1904 ic->bit_rate != 0 &&
1905 ic->file_size != 0) {
1906 filesize = ic->file_size;
1908 for(i = 0; i < ic->nb_streams; i++) {
1909 st = ic->streams[i];
1910 duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1911 if (st->duration == AV_NOPTS_VALUE)
1912 st->duration = duration;
1918 #define DURATION_MAX_READ_SIZE 250000
1919 #define DURATION_MAX_RETRY 3
1921 /* only usable for MPEG-PS streams */
1922 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
1924 AVPacket pkt1, *pkt = &pkt1;
1926 int read_size, i, ret;
1928 int64_t filesize, offset, duration;
1933 /* flush packet queue */
1934 flush_packet_queue(ic);
1936 for (i=0; i<ic->nb_streams; i++) {
1937 st = ic->streams[i];
1938 if (st->start_time == AV_NOPTS_VALUE && st->first_dts == AV_NOPTS_VALUE)
1939 av_log(st->codec, AV_LOG_WARNING, "start time is not set in estimate_timings_from_pts\n");
1942 av_parser_close(st->parser);
1944 av_free_packet(&st->cur_pkt);
1948 /* estimate the end time (duration) */
1949 /* XXX: may need to support wrapping */
1950 filesize = ic->file_size;
1951 end_time = AV_NOPTS_VALUE;
1953 offset = filesize - (DURATION_MAX_READ_SIZE<<retry);
1957 avio_seek(ic->pb, offset, SEEK_SET);
1960 if (read_size >= DURATION_MAX_READ_SIZE<<(FFMAX(retry-1,0)))
1964 ret = av_read_packet(ic, pkt);
1965 }while(ret == AVERROR(EAGAIN));
1968 read_size += pkt->size;
1969 st = ic->streams[pkt->stream_index];
1970 if (pkt->pts != AV_NOPTS_VALUE &&
1971 (st->start_time != AV_NOPTS_VALUE ||
1972 st->first_dts != AV_NOPTS_VALUE)) {
1973 duration = end_time = pkt->pts;
1974 if (st->start_time != AV_NOPTS_VALUE) duration -= st->start_time;
1975 else duration -= st->first_dts;
1977 duration += 1LL<<st->pts_wrap_bits;
1979 if (st->duration == AV_NOPTS_VALUE ||
1980 st->duration < duration)
1981 st->duration = duration;
1984 av_free_packet(pkt);
1986 }while( end_time==AV_NOPTS_VALUE
1987 && filesize > (DURATION_MAX_READ_SIZE<<retry)
1988 && ++retry <= DURATION_MAX_RETRY);
1990 fill_all_stream_timings(ic);
1992 avio_seek(ic->pb, old_offset, SEEK_SET);
1993 for (i=0; i<ic->nb_streams; i++) {
1995 st->cur_dts= st->first_dts;
1996 st->last_IP_pts = AV_NOPTS_VALUE;
1997 st->reference_dts = AV_NOPTS_VALUE;
2001 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2005 /* get the file size, if possible */
2006 if (ic->iformat->flags & AVFMT_NOFILE) {
2009 file_size = avio_size(ic->pb);
2013 ic->file_size = file_size;
2015 if ((!strcmp(ic->iformat->name, "mpeg") ||
2016 !strcmp(ic->iformat->name, "mpegts")) &&
2017 file_size && ic->pb->seekable) {
2018 /* get accurate estimate from the PTSes */
2019 estimate_timings_from_pts(ic, old_offset);
2020 } else if (has_duration(ic)) {
2021 /* at least one component has timings - we use them for all
2023 fill_all_stream_timings(ic);
2025 av_log(ic, AV_LOG_WARNING, "Estimating duration from bitrate, this may be inaccurate\n");
2026 /* less precise: use bitrate info */
2027 estimate_timings_from_bit_rate(ic);
2029 update_stream_timings(ic);
2033 AVStream av_unused *st;
2034 for(i = 0;i < ic->nb_streams; i++) {
2035 st = ic->streams[i];
2036 av_dlog(ic, "%d: start_time: %0.3f duration: %0.3f\n", i,
2037 (double) st->start_time / AV_TIME_BASE,
2038 (double) st->duration / AV_TIME_BASE);
2040 av_dlog(ic, "stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2041 (double) ic->start_time / AV_TIME_BASE,
2042 (double) ic->duration / AV_TIME_BASE,
2043 ic->bit_rate / 1000);
2047 static int has_codec_parameters(AVCodecContext *avctx)
2050 switch (avctx->codec_type) {
2051 case AVMEDIA_TYPE_AUDIO:
2052 val = avctx->sample_rate && avctx->channels && avctx->sample_fmt != AV_SAMPLE_FMT_NONE;
2053 if (!avctx->frame_size &&
2054 (avctx->codec_id == CODEC_ID_VORBIS ||
2055 avctx->codec_id == CODEC_ID_AAC ||
2056 avctx->codec_id == CODEC_ID_MP1 ||
2057 avctx->codec_id == CODEC_ID_MP2 ||
2058 avctx->codec_id == CODEC_ID_MP3 ||
2059 avctx->codec_id == CODEC_ID_SPEEX))
2062 case AVMEDIA_TYPE_VIDEO:
2063 val = avctx->width && avctx->pix_fmt != PIX_FMT_NONE;
2069 return avctx->codec_id != CODEC_ID_NONE && val != 0;
2072 static int has_decode_delay_been_guessed(AVStream *st)
2074 return st->codec->codec_id != CODEC_ID_H264 ||
2075 st->codec_info_nb_frames >= 6 + st->codec->has_b_frames;
2078 static int try_decode_frame(AVStream *st, AVPacket *avpkt, AVDictionary **options)
2082 int got_picture, data_size, ret=0;
2085 if(!st->codec->codec){
2086 codec = avcodec_find_decoder(st->codec->codec_id);
2089 ret = avcodec_open2(st->codec, codec, options);
2094 if(!has_codec_parameters(st->codec) || !has_decode_delay_been_guessed(st) ||
2095 (!st->codec_info_nb_frames && st->codec->codec->capabilities & CODEC_CAP_CHANNEL_CONF)) {
2096 switch(st->codec->codec_type) {
2097 case AVMEDIA_TYPE_VIDEO:
2098 avcodec_get_frame_defaults(&picture);
2099 ret = avcodec_decode_video2(st->codec, &picture,
2100 &got_picture, avpkt);
2102 case AVMEDIA_TYPE_AUDIO:
2103 data_size = FFMAX(avpkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
2104 samples = av_malloc(data_size);
2107 ret = avcodec_decode_audio3(st->codec, samples,
2119 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum CodecID id)
2121 while (tags->id != CODEC_ID_NONE) {
2129 enum CodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2132 for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
2133 if(tag == tags[i].tag)
2136 for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
2137 if (ff_toupper4(tag) == ff_toupper4(tags[i].tag))
2140 return CODEC_ID_NONE;
2143 unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum CodecID id)
2146 for(i=0; tags && tags[i]; i++){
2147 int tag= ff_codec_get_tag(tags[i], id);
2153 enum CodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
2156 for(i=0; tags && tags[i]; i++){
2157 enum CodecID id= ff_codec_get_id(tags[i], tag);
2158 if(id!=CODEC_ID_NONE) return id;
2160 return CODEC_ID_NONE;
2163 static void compute_chapters_end(AVFormatContext *s)
2166 int64_t max_time = s->duration + ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
2168 for (i = 0; i < s->nb_chapters; i++)
2169 if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2170 AVChapter *ch = s->chapters[i];
2171 int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q, ch->time_base)
2174 for (j = 0; j < s->nb_chapters; j++) {
2175 AVChapter *ch1 = s->chapters[j];
2176 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base, ch->time_base);
2177 if (j != i && next_start > ch->start && next_start < end)
2180 ch->end = (end == INT64_MAX) ? ch->start : end;
2184 static int get_std_framerate(int i){
2185 if(i<60*12) return i*1001;
2186 else return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
2190 * Is the time base unreliable.
2191 * This is a heuristic to balance between quick acceptance of the values in
2192 * the headers vs. some extra checks.
2193 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2194 * MPEG-2 commonly misuses field repeat flags to store different framerates.
2195 * And there are "variable" fps files this needs to detect as well.
2197 static int tb_unreliable(AVCodecContext *c){
2198 if( c->time_base.den >= 101L*c->time_base.num
2199 || c->time_base.den < 5L*c->time_base.num
2200 /* || c->codec_tag == AV_RL32("DIVX")
2201 || c->codec_tag == AV_RL32("XVID")*/
2202 || c->codec_id == CODEC_ID_MPEG2VIDEO
2203 || c->codec_id == CODEC_ID_H264
2209 #if FF_API_FORMAT_PARAMETERS
2210 int av_find_stream_info(AVFormatContext *ic)
2212 return avformat_find_stream_info(ic, NULL);
2216 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
2218 int i, count, ret, read_size, j;
2220 AVPacket pkt1, *pkt;
2221 int64_t old_offset = avio_tell(ic->pb);
2222 int orig_nb_streams = ic->nb_streams; // new streams might appear, no options for those
2224 for(i=0;i<ic->nb_streams;i++) {
2226 st = ic->streams[i];
2228 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2229 st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2230 /* if(!st->time_base.num)
2232 if(!st->codec->time_base.num)
2233 st->codec->time_base= st->time_base;
2235 //only for the split stuff
2236 if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
2237 st->parser = av_parser_init(st->codec->codec_id);
2238 if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
2239 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2242 assert(!st->codec->codec);
2243 codec = avcodec_find_decoder(st->codec->codec_id);
2245 /* Ensure that subtitle_header is properly set. */
2246 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
2247 && codec && !st->codec->codec)
2248 avcodec_open2(st->codec, codec, options ? &options[i] : NULL);
2250 //try to just open decoders, in case this is enough to get parameters
2251 if(!has_codec_parameters(st->codec)){
2252 if (codec && !st->codec->codec)
2253 avcodec_open2(st->codec, codec, options ? &options[i] : NULL);
2257 for (i=0; i<ic->nb_streams; i++) {
2258 ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
2264 if(url_interrupt_cb()){
2266 av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2270 /* check if one codec still needs to be handled */
2271 for(i=0;i<ic->nb_streams;i++) {
2272 int fps_analyze_framecount = 20;
2274 st = ic->streams[i];
2275 if (!has_codec_parameters(st->codec))
2277 /* if the timebase is coarse (like the usual millisecond precision
2278 of mkv), we need to analyze more frames to reliably arrive at
2280 if (av_q2d(st->time_base) > 0.0005)
2281 fps_analyze_framecount *= 2;
2282 if (ic->fps_probe_size >= 0)
2283 fps_analyze_framecount = ic->fps_probe_size;
2284 /* variable fps and no guess at the real fps */
2285 if( tb_unreliable(st->codec) && !(st->r_frame_rate.num && st->avg_frame_rate.num)
2286 && st->info->duration_count < fps_analyze_framecount
2287 && st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2289 if(st->parser && st->parser->parser->split && !st->codec->extradata)
2291 if(st->first_dts == AV_NOPTS_VALUE)
2294 if (i == ic->nb_streams) {
2295 /* NOTE: if the format has no header, then we need to read
2296 some packets to get most of the streams, so we cannot
2298 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2299 /* if we found the info for all the codecs, we can stop */
2301 av_log(ic, AV_LOG_DEBUG, "All info found\n");
2305 /* we did not get all the codec info, but we read too much data */
2306 if (read_size >= ic->probesize) {
2308 av_log(ic, AV_LOG_DEBUG, "Probe buffer size limit %d reached\n", ic->probesize);
2312 /* NOTE: a new stream can be added there if no header in file
2313 (AVFMTCTX_NOHEADER) */
2314 ret = read_frame_internal(ic, &pkt1);
2315 if (ret == AVERROR(EAGAIN))
2320 ret = -1; /* we could not have all the codec parameters before EOF */
2321 for(i=0;i<ic->nb_streams;i++) {
2322 st = ic->streams[i];
2323 if (!has_codec_parameters(st->codec)){
2325 avcodec_string(buf, sizeof(buf), st->codec, 0);
2326 av_log(ic, AV_LOG_WARNING, "Could not find codec parameters (%s)\n", buf);
2334 pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2335 if ((ret = av_dup_packet(pkt)) < 0)
2336 goto find_stream_info_err;
2338 read_size += pkt->size;
2340 st = ic->streams[pkt->stream_index];
2341 if (st->codec_info_nb_frames>1) {
2342 if (st->time_base.den > 0 && av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q) >= ic->max_analyze_duration) {
2343 av_log(ic, AV_LOG_WARNING, "max_analyze_duration reached\n");
2346 st->info->codec_info_duration += pkt->duration;
2349 int64_t last = st->info->last_dts;
2350 int64_t duration= pkt->dts - last;
2352 if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
2353 double dur= duration * av_q2d(st->time_base);
2355 // if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2356 // av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
2357 if (st->info->duration_count < 2)
2358 memset(st->info->duration_error, 0, sizeof(st->info->duration_error));
2359 for (i=1; i<FF_ARRAY_ELEMS(st->info->duration_error); i++) {
2360 int framerate= get_std_framerate(i);
2361 int ticks= lrintf(dur*framerate/(1001*12));
2362 double error= dur - ticks*1001*12/(double)framerate;
2363 st->info->duration_error[i] += error*error;
2365 st->info->duration_count++;
2366 // ignore the first 4 values, they might have some random jitter
2367 if (st->info->duration_count > 3)
2368 st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2370 if (last == AV_NOPTS_VALUE || st->info->duration_count <= 1)
2371 st->info->last_dts = pkt->dts;
2373 if(st->parser && st->parser->parser->split && !st->codec->extradata){
2374 int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2376 st->codec->extradata_size= i;
2377 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2378 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2379 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2383 /* if still no information, we try to open the codec and to
2384 decompress the frame. We try to avoid that in most cases as
2385 it takes longer and uses more memory. For MPEG-4, we need to
2386 decompress for QuickTime.
2388 If CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
2389 least one frame of codec data, this makes sure the codec initializes
2390 the channel configuration and does not only trust the values from the container.
2392 try_decode_frame(st, pkt, (options && i < orig_nb_streams )? &options[i] : NULL);
2394 st->codec_info_nb_frames++;
2398 // close codecs which were opened in try_decode_frame()
2399 for(i=0;i<ic->nb_streams;i++) {
2400 st = ic->streams[i];
2401 if(st->codec->codec)
2402 avcodec_close(st->codec);
2404 for(i=0;i<ic->nb_streams;i++) {
2405 st = ic->streams[i];
2406 if (st->codec_info_nb_frames>2 && !st->avg_frame_rate.num && st->info->codec_info_duration)
2407 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2408 (st->codec_info_nb_frames-2)*(int64_t)st->time_base.den,
2409 st->info->codec_info_duration*(int64_t)st->time_base.num, 60000);
2410 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2411 if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample)
2412 st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2414 // the check for tb_unreliable() is not completely correct, since this is not about handling
2415 // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2416 // ipmovie.c produces.
2417 if (tb_unreliable(st->codec) && st->info->duration_count > 15 && st->info->duration_gcd > 1 && !st->r_frame_rate.num)
2418 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);
2419 if (st->info->duration_count && !st->r_frame_rate.num
2420 && tb_unreliable(st->codec) /*&&
2421 //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2422 st->time_base.num*duration_sum[i]/st->info->duration_count*101LL > st->time_base.den*/){
2424 double best_error= 2*av_q2d(st->time_base);
2425 best_error = best_error*best_error*st->info->duration_count*1000*12*30;
2427 for (j=1; j<FF_ARRAY_ELEMS(st->info->duration_error); j++) {
2428 double error = st->info->duration_error[j] * get_std_framerate(j);
2429 // if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2430 // av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
2431 if(error < best_error){
2433 num = get_std_framerate(j);
2436 // do not increase frame rate by more than 1 % in order to match a standard rate.
2437 if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
2438 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2441 if (!st->r_frame_rate.num){
2442 if( st->codec->time_base.den * (int64_t)st->time_base.num
2443 <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
2444 st->r_frame_rate.num = st->codec->time_base.den;
2445 st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
2447 st->r_frame_rate.num = st->time_base.den;
2448 st->r_frame_rate.den = st->time_base.num;
2451 }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2452 if(!st->codec->bits_per_coded_sample)
2453 st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2454 // set stream disposition based on audio service type
2455 switch (st->codec->audio_service_type) {
2456 case AV_AUDIO_SERVICE_TYPE_EFFECTS:
2457 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS; break;
2458 case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
2459 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED; break;
2460 case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
2461 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED; break;
2462 case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
2463 st->disposition = AV_DISPOSITION_COMMENT; break;
2464 case AV_AUDIO_SERVICE_TYPE_KARAOKE:
2465 st->disposition = AV_DISPOSITION_KARAOKE; break;
2470 estimate_timings(ic, old_offset);
2472 compute_chapters_end(ic);
2475 /* correct DTS for B-frame streams with no timestamps */
2476 for(i=0;i<ic->nb_streams;i++) {
2477 st = ic->streams[i];
2478 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2480 ppktl = &ic->packet_buffer;
2482 if(ppkt1->stream_index != i)
2484 if(ppkt1->pkt->dts < 0)
2486 if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2488 ppkt1->pkt->dts -= delta;
2493 st->cur_dts -= delta;
2499 find_stream_info_err:
2500 for (i=0; i < ic->nb_streams; i++)
2501 av_freep(&ic->streams[i]->info);
2505 static AVProgram *find_program_from_stream(AVFormatContext *ic, int s)
2509 for (i = 0; i < ic->nb_programs; i++)
2510 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
2511 if (ic->programs[i]->stream_index[j] == s)
2512 return ic->programs[i];
2516 int av_find_best_stream(AVFormatContext *ic,
2517 enum AVMediaType type,
2518 int wanted_stream_nb,
2520 AVCodec **decoder_ret,
2523 int i, nb_streams = ic->nb_streams;
2524 int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1;
2525 unsigned *program = NULL;
2526 AVCodec *decoder = NULL, *best_decoder = NULL;
2528 if (related_stream >= 0 && wanted_stream_nb < 0) {
2529 AVProgram *p = find_program_from_stream(ic, related_stream);
2531 program = p->stream_index;
2532 nb_streams = p->nb_stream_indexes;
2535 for (i = 0; i < nb_streams; i++) {
2536 int real_stream_index = program ? program[i] : i;
2537 AVStream *st = ic->streams[real_stream_index];
2538 AVCodecContext *avctx = st->codec;
2539 if (avctx->codec_type != type)
2541 if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
2543 if (st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED|AV_DISPOSITION_VISUAL_IMPAIRED))
2546 decoder = avcodec_find_decoder(st->codec->codec_id);
2549 ret = AVERROR_DECODER_NOT_FOUND;
2553 if (best_count >= st->codec_info_nb_frames)
2555 best_count = st->codec_info_nb_frames;
2556 ret = real_stream_index;
2557 best_decoder = decoder;
2558 if (program && i == nb_streams - 1 && ret < 0) {
2560 nb_streams = ic->nb_streams;
2561 i = 0; /* no related stream found, try again with everything */
2565 *decoder_ret = best_decoder;
2569 /*******************************************************/
2571 int av_read_play(AVFormatContext *s)
2573 if (s->iformat->read_play)
2574 return s->iformat->read_play(s);
2576 return avio_pause(s->pb, 0);
2577 return AVERROR(ENOSYS);
2580 int av_read_pause(AVFormatContext *s)
2582 if (s->iformat->read_pause)
2583 return s->iformat->read_pause(s);
2585 return avio_pause(s->pb, 1);
2586 return AVERROR(ENOSYS);
2589 void av_close_input_stream(AVFormatContext *s)
2591 flush_packet_queue(s);
2592 if (s->iformat->read_close)
2593 s->iformat->read_close(s);
2594 avformat_free_context(s);
2597 void avformat_free_context(AVFormatContext *s)
2603 if (s->iformat && s->iformat->priv_class && s->priv_data)
2604 av_opt_free(s->priv_data);
2606 for(i=0;i<s->nb_streams;i++) {
2607 /* free all data in a stream component */
2610 av_parser_close(st->parser);
2611 av_free_packet(&st->cur_pkt);
2613 av_dict_free(&st->metadata);
2614 av_free(st->index_entries);
2615 av_free(st->codec->extradata);
2616 av_free(st->codec->subtitle_header);
2618 av_free(st->priv_data);
2622 for(i=s->nb_programs-1; i>=0; i--) {
2623 av_dict_free(&s->programs[i]->metadata);
2624 av_freep(&s->programs[i]->stream_index);
2625 av_freep(&s->programs[i]);
2627 av_freep(&s->programs);
2628 av_freep(&s->priv_data);
2629 while(s->nb_chapters--) {
2630 av_dict_free(&s->chapters[s->nb_chapters]->metadata);
2631 av_free(s->chapters[s->nb_chapters]);
2633 av_freep(&s->chapters);
2634 av_dict_free(&s->metadata);
2635 av_freep(&s->streams);
2639 void av_close_input_file(AVFormatContext *s)
2641 AVIOContext *pb = (s->iformat->flags & AVFMT_NOFILE) || (s->flags & AVFMT_FLAG_CUSTOM_IO) ?
2643 av_close_input_stream(s);
2648 AVStream *av_new_stream(AVFormatContext *s, int id)
2654 if (s->nb_streams >= INT_MAX/sizeof(*streams))
2656 streams = av_realloc(s->streams, (s->nb_streams + 1) * sizeof(*streams));
2659 s->streams = streams;
2661 st = av_mallocz(sizeof(AVStream));
2664 if (!(st->info = av_mallocz(sizeof(*st->info)))) {
2669 st->codec = avcodec_alloc_context3(NULL);
2671 /* no default bitrate if decoding */
2672 st->codec->bit_rate = 0;
2674 st->index = s->nb_streams;
2676 st->start_time = AV_NOPTS_VALUE;
2677 st->duration = AV_NOPTS_VALUE;
2678 /* we set the current DTS to 0 so that formats without any timestamps
2679 but durations get some timestamps, formats with some unknown
2680 timestamps have their first few packets buffered and the
2681 timestamps corrected before they are returned to the user */
2683 st->first_dts = AV_NOPTS_VALUE;
2684 st->probe_packets = MAX_PROBE_PACKETS;
2686 /* default pts setting is MPEG-like */
2687 av_set_pts_info(st, 33, 1, 90000);
2688 st->last_IP_pts = AV_NOPTS_VALUE;
2689 for(i=0; i<MAX_REORDER_DELAY+1; i++)
2690 st->pts_buffer[i]= AV_NOPTS_VALUE;
2691 st->reference_dts = AV_NOPTS_VALUE;
2693 st->sample_aspect_ratio = (AVRational){0,1};
2695 s->streams[s->nb_streams++] = st;
2699 AVProgram *av_new_program(AVFormatContext *ac, int id)
2701 AVProgram *program=NULL;
2704 av_dlog(ac, "new_program: id=0x%04x\n", id);
2706 for(i=0; i<ac->nb_programs; i++)
2707 if(ac->programs[i]->id == id)
2708 program = ac->programs[i];
2711 program = av_mallocz(sizeof(AVProgram));
2714 dynarray_add(&ac->programs, &ac->nb_programs, program);
2715 program->discard = AVDISCARD_NONE;
2722 AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2724 AVChapter *chapter = NULL;
2727 for(i=0; i<s->nb_chapters; i++)
2728 if(s->chapters[i]->id == id)
2729 chapter = s->chapters[i];
2732 chapter= av_mallocz(sizeof(AVChapter));
2735 dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2737 av_dict_set(&chapter->metadata, "title", title, 0);
2739 chapter->time_base= time_base;
2740 chapter->start = start;
2746 /************************************************************/
2747 /* output media file */
2749 #if FF_API_FORMAT_PARAMETERS
2750 int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2754 if (s->oformat->priv_data_size > 0) {
2755 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2757 return AVERROR(ENOMEM);
2758 if (s->oformat->priv_class) {
2759 *(const AVClass**)s->priv_data= s->oformat->priv_class;
2760 av_opt_set_defaults(s->priv_data);
2763 s->priv_data = NULL;
2765 if (s->oformat->set_parameters) {
2766 ret = s->oformat->set_parameters(s, ap);
2774 static int validate_codec_tag(AVFormatContext *s, AVStream *st)
2776 const AVCodecTag *avctag;
2778 enum CodecID id = CODEC_ID_NONE;
2779 unsigned int tag = 0;
2782 * Check that tag + id is in the table
2783 * If neither is in the table -> OK
2784 * If tag is in the table with another id -> FAIL
2785 * If id is in the table with another tag -> FAIL unless strict < normal
2787 for (n = 0; s->oformat->codec_tag[n]; n++) {
2788 avctag = s->oformat->codec_tag[n];
2789 while (avctag->id != CODEC_ID_NONE) {
2790 if (ff_toupper4(avctag->tag) == ff_toupper4(st->codec->codec_tag)) {
2792 if (id == st->codec->codec_id)
2795 if (avctag->id == st->codec->codec_id)
2800 if (id != CODEC_ID_NONE)
2802 if (tag && (st->codec->strict_std_compliance >= FF_COMPLIANCE_NORMAL))
2807 #if FF_API_FORMAT_PARAMETERS
2808 int av_write_header(AVFormatContext *s)
2810 return avformat_write_header(s, NULL);
2814 int avformat_write_header(AVFormatContext *s, AVDictionary **options)
2818 AVDictionary *tmp = NULL;
2821 av_dict_copy(&tmp, *options, 0);
2822 if ((ret = av_opt_set_dict(s, &tmp)) < 0)
2825 // some sanity checks
2826 if (s->nb_streams == 0 && !(s->oformat->flags & AVFMT_NOSTREAMS)) {
2827 av_log(s, AV_LOG_ERROR, "no streams\n");
2828 ret = AVERROR(EINVAL);
2832 for(i=0;i<s->nb_streams;i++) {
2835 switch (st->codec->codec_type) {
2836 case AVMEDIA_TYPE_AUDIO:
2837 if(st->codec->sample_rate<=0){
2838 av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2839 ret = AVERROR(EINVAL);
2842 if(!st->codec->block_align)
2843 st->codec->block_align = st->codec->channels *
2844 av_get_bits_per_sample(st->codec->codec_id) >> 3;
2846 case AVMEDIA_TYPE_VIDEO:
2847 if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2848 av_log(s, AV_LOG_ERROR, "time base not set\n");
2849 ret = AVERROR(EINVAL);
2852 if((st->codec->width<=0 || st->codec->height<=0) && !(s->oformat->flags & AVFMT_NODIMENSIONS)){
2853 av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2854 ret = AVERROR(EINVAL);
2857 if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)){
2858 av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between encoder and muxer layer\n");
2859 ret = AVERROR(EINVAL);
2865 if(s->oformat->codec_tag){
2866 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)){
2867 //the current rawvideo encoding system ends up setting the wrong codec_tag for avi, we override it here
2868 st->codec->codec_tag= 0;
2870 if(st->codec->codec_tag){
2871 if (!validate_codec_tag(s, st)) {
2873 av_get_codec_tag_string(tagbuf, sizeof(tagbuf), st->codec->codec_tag);
2874 av_log(s, AV_LOG_ERROR,
2875 "Tag %s/0x%08x incompatible with output codec id '%d'\n",
2876 tagbuf, st->codec->codec_tag, st->codec->codec_id);
2877 ret = AVERROR_INVALIDDATA;
2881 st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2884 if(s->oformat->flags & AVFMT_GLOBALHEADER &&
2885 !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
2886 av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
2889 if (!s->priv_data && s->oformat->priv_data_size > 0) {
2890 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2891 if (!s->priv_data) {
2892 ret = AVERROR(ENOMEM);
2895 if (s->oformat->priv_class) {
2896 *(const AVClass**)s->priv_data= s->oformat->priv_class;
2897 av_opt_set_defaults(s->priv_data);
2898 if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
2903 /* set muxer identification string */
2904 if (s->nb_streams && !(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
2905 av_dict_set(&s->metadata, "encoder", LIBAVFORMAT_IDENT, 0);
2908 if(s->oformat->write_header){
2909 ret = s->oformat->write_header(s);
2914 /* init PTS generation */
2915 for(i=0;i<s->nb_streams;i++) {
2916 int64_t den = AV_NOPTS_VALUE;
2919 switch (st->codec->codec_type) {
2920 case AVMEDIA_TYPE_AUDIO:
2921 den = (int64_t)st->time_base.num * st->codec->sample_rate;
2923 case AVMEDIA_TYPE_VIDEO:
2924 den = (int64_t)st->time_base.num * st->codec->time_base.den;
2929 if (den != AV_NOPTS_VALUE) {
2931 ret = AVERROR_INVALIDDATA;
2934 frac_init(&st->pts, 0, 0, den);
2939 av_dict_free(options);
2948 //FIXME merge with compute_pkt_fields
2949 static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt){
2950 int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2951 int num, den, frame_size, i;
2953 av_dlog(s, "compute_pkt_fields2: pts:%"PRId64" dts:%"PRId64" cur_dts:%"PRId64" b:%d size:%d st:%d\n",
2954 pkt->pts, pkt->dts, st->cur_dts, delay, pkt->size, pkt->stream_index);
2956 /* if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2957 return AVERROR(EINVAL);*/
2959 /* duration field */
2960 if (pkt->duration == 0) {
2961 compute_frame_duration(&num, &den, st, NULL, pkt);
2963 pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
2967 if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
2970 //XXX/FIXME this is a temporary hack until all encoders output pts
2971 if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2973 // pkt->pts= st->cur_dts;
2974 pkt->pts= st->pts.val;
2977 //calculate dts from pts
2978 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
2979 st->pts_buffer[0]= pkt->pts;
2980 for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2981 st->pts_buffer[i]= pkt->pts + (i-delay-1) * pkt->duration;
2982 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2983 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2985 pkt->dts= st->pts_buffer[0];
2988 if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2989 av_log(s, AV_LOG_ERROR,
2990 "Application provided invalid, non monotonically increasing dts to muxer in stream %d: %"PRId64" >= %"PRId64"\n",
2991 st->index, st->cur_dts, pkt->dts);
2992 return AVERROR(EINVAL);
2994 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2995 av_log(s, AV_LOG_ERROR, "pts < dts in stream %d\n", st->index);
2996 return AVERROR(EINVAL);
2999 // av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
3000 st->cur_dts= pkt->dts;
3001 st->pts.val= pkt->dts;
3004 switch (st->codec->codec_type) {
3005 case AVMEDIA_TYPE_AUDIO:
3006 frame_size = get_audio_frame_size(st->codec, pkt->size);
3008 /* HACK/FIXME, we skip the initial 0 size packets as they are most
3009 likely equal to the encoder delay, but it would be better if we
3010 had the real timestamps from the encoder */
3011 if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
3012 frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
3015 case AVMEDIA_TYPE_VIDEO:
3016 frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
3024 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
3026 int ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt);
3028 if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3031 ret= s->oformat->write_packet(s, pkt);
3034 s->streams[pkt->stream_index]->nb_frames++;
3038 void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
3039 int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
3041 AVPacketList **next_point, *this_pktl;
3043 this_pktl = av_mallocz(sizeof(AVPacketList));
3044 this_pktl->pkt= *pkt;
3045 pkt->destruct= NULL; // do not free original but only the copy
3046 av_dup_packet(&this_pktl->pkt); // duplicate the packet if it uses non-alloced memory
3048 if(s->streams[pkt->stream_index]->last_in_packet_buffer){
3049 next_point = &(s->streams[pkt->stream_index]->last_in_packet_buffer->next);
3051 next_point = &s->packet_buffer;
3054 if(compare(s, &s->packet_buffer_end->pkt, pkt)){
3055 while(!compare(s, &(*next_point)->pkt, pkt)){
3056 next_point= &(*next_point)->next;
3060 next_point = &(s->packet_buffer_end->next);
3063 assert(!*next_point);
3065 s->packet_buffer_end= this_pktl;
3068 this_pktl->next= *next_point;
3070 s->streams[pkt->stream_index]->last_in_packet_buffer=
3071 *next_point= this_pktl;
3074 static int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
3076 AVStream *st = s->streams[ pkt ->stream_index];
3077 AVStream *st2= s->streams[ next->stream_index];
3078 int comp = av_compare_ts(next->dts, st2->time_base, pkt->dts,
3082 return pkt->stream_index < next->stream_index;
3086 int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
3092 ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
3095 for(i=0; i < s->nb_streams; i++)
3096 stream_count+= !!s->streams[i]->last_in_packet_buffer;
3098 if(stream_count && (s->nb_streams == stream_count || flush)){
3099 pktl= s->packet_buffer;
3102 s->packet_buffer= pktl->next;
3103 if(!s->packet_buffer)
3104 s->packet_buffer_end= NULL;
3106 if(s->streams[out->stream_index]->last_in_packet_buffer == pktl)
3107 s->streams[out->stream_index]->last_in_packet_buffer= NULL;
3111 av_init_packet(out);
3117 * Interleave an AVPacket correctly so it can be muxed.
3118 * @param out the interleaved packet will be output here
3119 * @param in the input packet
3120 * @param flush 1 if no further packets are available as input and all
3121 * remaining packets should be output
3122 * @return 1 if a packet was output, 0 if no packet could be output,
3123 * < 0 if an error occurred
3125 static int interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
3126 if(s->oformat->interleave_packet)
3127 return s->oformat->interleave_packet(s, out, in, flush);
3129 return av_interleave_packet_per_dts(s, out, in, flush);
3132 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
3133 AVStream *st= s->streams[ pkt->stream_index];
3136 //FIXME/XXX/HACK drop zero sized packets
3137 if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO && pkt->size==0)
3140 av_dlog(s, "av_interleaved_write_frame size:%d dts:%"PRId64" pts:%"PRId64"\n",
3141 pkt->size, pkt->dts, pkt->pts);
3142 if((ret = compute_pkt_fields2(s, st, pkt)) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3145 if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3146 return AVERROR(EINVAL);
3150 int ret= interleave_packet(s, &opkt, pkt, 0);
3151 if(ret<=0) //FIXME cleanup needed for ret<0 ?
3154 ret= s->oformat->write_packet(s, &opkt);
3156 s->streams[opkt.stream_index]->nb_frames++;
3158 av_free_packet(&opkt);
3166 int av_write_trailer(AVFormatContext *s)
3172 ret= interleave_packet(s, &pkt, NULL, 1);
3173 if(ret<0) //FIXME cleanup needed for ret<0 ?
3178 ret= s->oformat->write_packet(s, &pkt);
3180 s->streams[pkt.stream_index]->nb_frames++;
3182 av_free_packet(&pkt);
3188 if(s->oformat->write_trailer)
3189 ret = s->oformat->write_trailer(s);
3191 for(i=0;i<s->nb_streams;i++) {
3192 av_freep(&s->streams[i]->priv_data);
3193 av_freep(&s->streams[i]->index_entries);
3195 if (s->iformat && s->iformat->priv_class)
3196 av_opt_free(s->priv_data);
3197 av_freep(&s->priv_data);
3201 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
3204 AVProgram *program=NULL;
3207 if (idx >= ac->nb_streams) {
3208 av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3212 for(i=0; i<ac->nb_programs; i++){
3213 if(ac->programs[i]->id != progid)
3215 program = ac->programs[i];
3216 for(j=0; j<program->nb_stream_indexes; j++)
3217 if(program->stream_index[j] == idx)
3220 tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
3223 program->stream_index = tmp;
3224 program->stream_index[program->nb_stream_indexes++] = idx;
3229 static void print_fps(double d, const char *postfix){
3230 uint64_t v= lrintf(d*100);
3231 if (v% 100 ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3232 else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3233 else av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
3236 static void dump_metadata(void *ctx, AVDictionary *m, const char *indent)
3238 if(m && !(m->count == 1 && av_dict_get(m, "language", NULL, 0))){
3239 AVDictionaryEntry *tag=NULL;
3241 av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3242 while((tag=av_dict_get(m, "", tag, AV_DICT_IGNORE_SUFFIX))) {
3243 if(strcmp("language", tag->key))
3244 av_log(ctx, AV_LOG_INFO, "%s %-16s: %s\n", indent, tag->key, tag->value);
3249 /* "user interface" functions */
3250 static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
3253 int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
3254 AVStream *st = ic->streams[i];
3255 int g = av_gcd(st->time_base.num, st->time_base.den);
3256 AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL, 0);
3257 avcodec_string(buf, sizeof(buf), st->codec, is_output);
3258 av_log(NULL, AV_LOG_INFO, " Stream #%d.%d", index, i);
3259 /* the pid is an important information, so we display it */
3260 /* XXX: add a generic system */
3261 if (flags & AVFMT_SHOW_IDS)
3262 av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
3264 av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
3265 av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames, st->time_base.num/g, st->time_base.den/g);
3266 av_log(NULL, AV_LOG_INFO, ": %s", buf);
3267 if (st->sample_aspect_ratio.num && // default
3268 av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
3269 AVRational display_aspect_ratio;
3270 av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
3271 st->codec->width*st->sample_aspect_ratio.num,
3272 st->codec->height*st->sample_aspect_ratio.den,
3274 av_log(NULL, AV_LOG_INFO, ", PAR %d:%d DAR %d:%d",
3275 st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3276 display_aspect_ratio.num, display_aspect_ratio.den);
3278 if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
3279 if(st->avg_frame_rate.den && st->avg_frame_rate.num)
3280 print_fps(av_q2d(st->avg_frame_rate), "fps");
3281 if(st->r_frame_rate.den && st->r_frame_rate.num)
3282 print_fps(av_q2d(st->r_frame_rate), "tbr");
3283 if(st->time_base.den && st->time_base.num)
3284 print_fps(1/av_q2d(st->time_base), "tbn");
3285 if(st->codec->time_base.den && st->codec->time_base.num)
3286 print_fps(1/av_q2d(st->codec->time_base), "tbc");
3288 if (st->disposition & AV_DISPOSITION_DEFAULT)
3289 av_log(NULL, AV_LOG_INFO, " (default)");
3290 if (st->disposition & AV_DISPOSITION_DUB)
3291 av_log(NULL, AV_LOG_INFO, " (dub)");
3292 if (st->disposition & AV_DISPOSITION_ORIGINAL)
3293 av_log(NULL, AV_LOG_INFO, " (original)");
3294 if (st->disposition & AV_DISPOSITION_COMMENT)
3295 av_log(NULL, AV_LOG_INFO, " (comment)");
3296 if (st->disposition & AV_DISPOSITION_LYRICS)
3297 av_log(NULL, AV_LOG_INFO, " (lyrics)");
3298 if (st->disposition & AV_DISPOSITION_KARAOKE)
3299 av_log(NULL, AV_LOG_INFO, " (karaoke)");
3300 if (st->disposition & AV_DISPOSITION_FORCED)
3301 av_log(NULL, AV_LOG_INFO, " (forced)");
3302 if (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED)
3303 av_log(NULL, AV_LOG_INFO, " (hearing impaired)");
3304 if (st->disposition & AV_DISPOSITION_VISUAL_IMPAIRED)
3305 av_log(NULL, AV_LOG_INFO, " (visual impaired)");
3306 if (st->disposition & AV_DISPOSITION_CLEAN_EFFECTS)
3307 av_log(NULL, AV_LOG_INFO, " (clean effects)");
3308 av_log(NULL, AV_LOG_INFO, "\n");
3309 dump_metadata(NULL, st->metadata, " ");
3312 #if FF_API_DUMP_FORMAT
3313 void dump_format(AVFormatContext *ic,
3318 av_dump_format(ic, index, url, is_output);
3322 void av_dump_format(AVFormatContext *ic,
3328 uint8_t *printed = av_mallocz(ic->nb_streams);
3329 if (ic->nb_streams && !printed)
3332 av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3333 is_output ? "Output" : "Input",
3335 is_output ? ic->oformat->name : ic->iformat->name,
3336 is_output ? "to" : "from", url);
3337 dump_metadata(NULL, ic->metadata, " ");
3339 av_log(NULL, AV_LOG_INFO, " Duration: ");
3340 if (ic->duration != AV_NOPTS_VALUE) {
3341 int hours, mins, secs, us;
3342 secs = ic->duration / AV_TIME_BASE;
3343 us = ic->duration % AV_TIME_BASE;
3348 av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3349 (100 * us) / AV_TIME_BASE);
3351 av_log(NULL, AV_LOG_INFO, "N/A");
3353 if (ic->start_time != AV_NOPTS_VALUE) {
3355 av_log(NULL, AV_LOG_INFO, ", start: ");
3356 secs = ic->start_time / AV_TIME_BASE;
3357 us = abs(ic->start_time % AV_TIME_BASE);
3358 av_log(NULL, AV_LOG_INFO, "%d.%06d",
3359 secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
3361 av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3363 av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
3365 av_log(NULL, AV_LOG_INFO, "N/A");
3367 av_log(NULL, AV_LOG_INFO, "\n");
3369 for (i = 0; i < ic->nb_chapters; i++) {
3370 AVChapter *ch = ic->chapters[i];
3371 av_log(NULL, AV_LOG_INFO, " Chapter #%d.%d: ", index, i);
3372 av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
3373 av_log(NULL, AV_LOG_INFO, "end %f\n", ch->end * av_q2d(ch->time_base));
3375 dump_metadata(NULL, ch->metadata, " ");
3377 if(ic->nb_programs) {
3378 int j, k, total = 0;
3379 for(j=0; j<ic->nb_programs; j++) {
3380 AVDictionaryEntry *name = av_dict_get(ic->programs[j]->metadata,
3382 av_log(NULL, AV_LOG_INFO, " Program %d %s\n", ic->programs[j]->id,
3383 name ? name->value : "");
3384 dump_metadata(NULL, ic->programs[j]->metadata, " ");
3385 for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3386 dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3387 printed[ic->programs[j]->stream_index[k]] = 1;
3389 total += ic->programs[j]->nb_stream_indexes;
3391 if (total < ic->nb_streams)
3392 av_log(NULL, AV_LOG_INFO, " No Program\n");
3394 for(i=0;i<ic->nb_streams;i++)
3396 dump_stream_format(ic, i, index, is_output);
3401 int64_t av_gettime(void)
3404 gettimeofday(&tv,NULL);
3405 return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
3408 uint64_t ff_ntp_time(void)
3410 return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3413 #if FF_API_PARSE_DATE
3414 #include "libavutil/parseutils.h"
3416 int64_t parse_date(const char *timestr, int duration)
3419 av_parse_time(&timeval, timestr, duration);
3424 #if FF_API_FIND_INFO_TAG
3425 #include "libavutil/parseutils.h"
3427 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
3429 return av_find_info_tag(arg, arg_size, tag1, info);
3433 int av_get_frame_filename(char *buf, int buf_size,
3434 const char *path, int number)
3437 char *q, buf1[20], c;
3438 int nd, len, percentd_found;
3450 while (isdigit(*p)) {
3451 nd = nd * 10 + *p++ - '0';
3454 } while (isdigit(c));
3463 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3465 if ((q - buf + len) > buf_size - 1)
3467 memcpy(q, buf1, len);
3475 if ((q - buf) < buf_size - 1)
3479 if (!percentd_found)
3488 static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3492 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3494 for(i=0;i<size;i+=16) {
3501 PRINT(" %02x", buf[i+j]);
3506 for(j=0;j<len;j++) {
3508 if (c < ' ' || c > '~')
3517 void av_hex_dump(FILE *f, uint8_t *buf, int size)
3519 hex_dump_internal(NULL, f, 0, buf, size);
3522 void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3524 hex_dump_internal(avcl, NULL, level, buf, size);
3527 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload, AVRational time_base)
3530 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3531 PRINT("stream #%d:\n", pkt->stream_index);
3532 PRINT(" keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
3533 PRINT(" duration=%0.3f\n", pkt->duration * av_q2d(time_base));
3534 /* DTS is _always_ valid after av_read_frame() */
3536 if (pkt->dts == AV_NOPTS_VALUE)
3539 PRINT("%0.3f", pkt->dts * av_q2d(time_base));
3540 /* PTS may not be known if B-frames are present. */
3542 if (pkt->pts == AV_NOPTS_VALUE)
3545 PRINT("%0.3f", pkt->pts * av_q2d(time_base));
3547 PRINT(" size=%d\n", pkt->size);
3550 av_hex_dump(f, pkt->data, pkt->size);
3554 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3556 AVRational tb = { 1, AV_TIME_BASE };
3557 pkt_dump_internal(NULL, f, 0, pkt, dump_payload, tb);
3561 void av_pkt_dump2(FILE *f, AVPacket *pkt, int dump_payload, AVStream *st)
3563 pkt_dump_internal(NULL, f, 0, pkt, dump_payload, st->time_base);
3567 void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3569 AVRational tb = { 1, AV_TIME_BASE };
3570 pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, tb);
3574 void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload,
3577 pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, st->time_base);
3580 void av_url_split(char *proto, int proto_size,
3581 char *authorization, int authorization_size,
3582 char *hostname, int hostname_size,
3584 char *path, int path_size,
3587 const char *p, *ls, *at, *col, *brk;
3589 if (port_ptr) *port_ptr = -1;
3590 if (proto_size > 0) proto[0] = 0;
3591 if (authorization_size > 0) authorization[0] = 0;
3592 if (hostname_size > 0) hostname[0] = 0;
3593 if (path_size > 0) path[0] = 0;
3595 /* parse protocol */
3596 if ((p = strchr(url, ':'))) {
3597 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3602 /* no protocol means plain filename */
3603 av_strlcpy(path, url, path_size);
3607 /* separate path from hostname */
3608 ls = strchr(p, '/');
3610 ls = strchr(p, '?');
3612 av_strlcpy(path, ls, path_size);
3614 ls = &p[strlen(p)]; // XXX
3616 /* the rest is hostname, use that to parse auth/port */
3618 /* authorization (user[:pass]@hostname) */
3619 if ((at = strchr(p, '@')) && at < ls) {
3620 av_strlcpy(authorization, p,
3621 FFMIN(authorization_size, at + 1 - p));
3622 p = at + 1; /* skip '@' */
3625 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3627 av_strlcpy(hostname, p + 1,
3628 FFMIN(hostname_size, brk - p));
3629 if (brk[1] == ':' && port_ptr)
3630 *port_ptr = atoi(brk + 2);
3631 } else if ((col = strchr(p, ':')) && col < ls) {
3632 av_strlcpy(hostname, p,
3633 FFMIN(col + 1 - p, hostname_size));
3634 if (port_ptr) *port_ptr = atoi(col + 1);
3636 av_strlcpy(hostname, p,
3637 FFMIN(ls + 1 - p, hostname_size));
3641 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3644 static const char hex_table_uc[16] = { '0', '1', '2', '3',
3647 'C', 'D', 'E', 'F' };
3648 static const char hex_table_lc[16] = { '0', '1', '2', '3',
3651 'c', 'd', 'e', 'f' };
3652 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3654 for(i = 0; i < s; i++) {
3655 buff[i * 2] = hex_table[src[i] >> 4];
3656 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3662 int ff_hex_to_data(uint8_t *data, const char *p)
3669 p += strspn(p, SPACE_CHARS);
3672 c = toupper((unsigned char) *p++);
3673 if (c >= '0' && c <= '9')
3675 else if (c >= 'A' && c <= 'F')
3690 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3691 unsigned int pts_num, unsigned int pts_den)
3694 if(av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)){
3695 if(new_tb.num != pts_num)
3696 av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/new_tb.num);
3698 av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3700 if(new_tb.num <= 0 || new_tb.den <= 0) {
3701 av_log(NULL, AV_LOG_ERROR, "Ignoring attempt to set invalid timebase for st:%d\n", s->index);
3704 s->time_base = new_tb;
3705 s->pts_wrap_bits = pts_wrap_bits;
3708 int ff_url_join(char *str, int size, const char *proto,
3709 const char *authorization, const char *hostname,
3710 int port, const char *fmt, ...)
3713 struct addrinfo hints, *ai;
3718 av_strlcatf(str, size, "%s://", proto);
3719 if (authorization && authorization[0])
3720 av_strlcatf(str, size, "%s@", authorization);
3721 #if CONFIG_NETWORK && defined(AF_INET6)
3722 /* Determine if hostname is a numerical IPv6 address,
3723 * properly escape it within [] in that case. */
3724 memset(&hints, 0, sizeof(hints));
3725 hints.ai_flags = AI_NUMERICHOST;
3726 if (!getaddrinfo(hostname, NULL, &hints, &ai)) {
3727 if (ai->ai_family == AF_INET6) {
3728 av_strlcat(str, "[", size);
3729 av_strlcat(str, hostname, size);
3730 av_strlcat(str, "]", size);
3732 av_strlcat(str, hostname, size);
3737 /* Not an IPv6 address, just output the plain string. */
3738 av_strlcat(str, hostname, size);
3741 av_strlcatf(str, size, ":%d", port);
3744 int len = strlen(str);
3747 vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);
3753 int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
3754 AVFormatContext *src)
3759 local_pkt.stream_index = dst_stream;
3760 if (pkt->pts != AV_NOPTS_VALUE)
3761 local_pkt.pts = av_rescale_q(pkt->pts,
3762 src->streams[pkt->stream_index]->time_base,
3763 dst->streams[dst_stream]->time_base);
3764 if (pkt->dts != AV_NOPTS_VALUE)
3765 local_pkt.dts = av_rescale_q(pkt->dts,
3766 src->streams[pkt->stream_index]->time_base,
3767 dst->streams[dst_stream]->time_base);
3768 return av_write_frame(dst, &local_pkt);
3771 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
3774 const char *ptr = str;
3776 /* Parse key=value pairs. */
3779 char *dest = NULL, *dest_end;
3780 int key_len, dest_len = 0;
3782 /* Skip whitespace and potential commas. */
3783 while (*ptr && (isspace(*ptr) || *ptr == ','))
3790 if (!(ptr = strchr(key, '=')))
3793 key_len = ptr - key;
3795 callback_get_buf(context, key, key_len, &dest, &dest_len);
3796 dest_end = dest + dest_len - 1;
3800 while (*ptr && *ptr != '\"') {
3804 if (dest && dest < dest_end)
3808 if (dest && dest < dest_end)
3816 for (; *ptr && !(isspace(*ptr) || *ptr == ','); ptr++)
3817 if (dest && dest < dest_end)
3825 int ff_find_stream_index(AVFormatContext *s, int id)
3828 for (i = 0; i < s->nb_streams; i++) {
3829 if (s->streams[i]->id == id)
3835 void ff_make_absolute_url(char *buf, int size, const char *base,
3839 /* Absolute path, relative to the current server */
3840 if (base && strstr(base, "://") && rel[0] == '/') {
3842 av_strlcpy(buf, base, size);
3843 sep = strstr(buf, "://");
3846 sep = strchr(sep, '/');
3850 av_strlcat(buf, rel, size);
3853 /* If rel actually is an absolute url, just copy it */
3854 if (!base || strstr(rel, "://") || rel[0] == '/') {
3855 av_strlcpy(buf, rel, size);
3859 av_strlcpy(buf, base, size);
3860 /* Remove the file name from the base url */
3861 sep = strrchr(buf, '/');
3866 while (av_strstart(rel, "../", NULL) && sep) {
3867 /* Remove the path delimiter at the end */
3869 sep = strrchr(buf, '/');
3870 /* If the next directory name to pop off is "..", break here */
3871 if (!strcmp(sep ? &sep[1] : buf, "..")) {
3872 /* Readd the slash we just removed */
3873 av_strlcat(buf, "/", size);
3876 /* Cut off the directory name */
3883 av_strlcat(buf, rel, size);
3886 int64_t ff_iso8601_to_unix_time(const char *datestr)
3889 struct tm time = {0};
3890 strptime(datestr, "%Y - %m - %dT%T", &time);
3891 return mktime(&time);
3893 av_log(NULL, AV_LOG_WARNING, "strptime() unavailable on this system, cannot convert "
3894 "the date string.\n");