2 * various utility functions for use within FFmpeg
3 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
25 #include "avio_internal.h"
27 #include "libavcodec/internal.h"
28 #include "libavcodec/raw.h"
29 #include "libavutil/opt.h"
30 #include "libavutil/dict.h"
31 #include "libavutil/pixdesc.h"
34 #include "libavutil/avstring.h"
35 #include "libavutil/mathematics.h"
36 #include "libavutil/parseutils.h"
38 #include "audiointerleave.h"
52 * various utility functions for use within FFmpeg
55 unsigned avformat_version(void)
57 return LIBAVFORMAT_VERSION_INT;
60 const char *avformat_configuration(void)
62 return FFMPEG_CONFIGURATION;
65 const char *avformat_license(void)
67 #define LICENSE_PREFIX "libavformat license: "
68 return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;
71 /* fraction handling */
74 * f = val + (num / den) + 0.5.
76 * 'num' is normalized so that it is such as 0 <= num < den.
78 * @param f fractional number
79 * @param val integer value
80 * @param num must be >= 0
81 * @param den must be >= 1
83 static void frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
96 * Fractional addition to f: f = f + (incr / f->den).
98 * @param f fractional number
99 * @param incr increment, can be positive or negative
101 static void frac_add(AVFrac *f, int64_t incr)
114 } else if (num >= den) {
121 /** head of registered input format linked list */
122 static AVInputFormat *first_iformat = NULL;
123 /** head of registered output format linked list */
124 static AVOutputFormat *first_oformat = NULL;
126 AVInputFormat *av_iformat_next(AVInputFormat *f)
128 if(f) return f->next;
129 else return first_iformat;
132 AVOutputFormat *av_oformat_next(AVOutputFormat *f)
134 if(f) return f->next;
135 else return first_oformat;
138 void av_register_input_format(AVInputFormat *format)
142 while (*p != NULL) p = &(*p)->next;
147 void av_register_output_format(AVOutputFormat *format)
151 while (*p != NULL) p = &(*p)->next;
156 int av_match_ext(const char *filename, const char *extensions)
164 ext = strrchr(filename, '.');
170 while (*p != '\0' && *p != ',' && q-ext1<sizeof(ext1)-1)
173 if (!av_strcasecmp(ext1, ext))
183 static int match_format(const char *name, const char *names)
191 namelen = strlen(name);
192 while ((p = strchr(names, ','))) {
193 len = FFMAX(p - names, namelen);
194 if (!av_strncasecmp(name, names, len))
198 return !av_strcasecmp(name, names);
201 AVOutputFormat *av_guess_format(const char *short_name, const char *filename,
202 const char *mime_type)
204 AVOutputFormat *fmt = NULL, *fmt_found;
205 int score_max, score;
207 /* specific test for image sequences */
208 #if CONFIG_IMAGE2_MUXER
209 if (!short_name && filename &&
210 av_filename_number_test(filename) &&
211 ff_guess_image2_codec(filename) != CODEC_ID_NONE) {
212 return av_guess_format("image2", NULL, NULL);
215 /* Find the proper file type. */
218 while ((fmt = av_oformat_next(fmt))) {
220 if (fmt->name && short_name && !strcmp(fmt->name, short_name))
222 if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
224 if (filename && fmt->extensions &&
225 av_match_ext(filename, fmt->extensions)) {
228 if (score > score_max) {
236 enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
237 const char *filename, const char *mime_type, enum AVMediaType type){
238 if(type == AVMEDIA_TYPE_VIDEO){
239 enum CodecID codec_id= CODEC_ID_NONE;
241 #if CONFIG_IMAGE2_MUXER
242 if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
243 codec_id= ff_guess_image2_codec(filename);
246 if(codec_id == CODEC_ID_NONE)
247 codec_id= fmt->video_codec;
249 }else if(type == AVMEDIA_TYPE_AUDIO)
250 return fmt->audio_codec;
251 else if (type == AVMEDIA_TYPE_SUBTITLE)
252 return fmt->subtitle_codec;
254 return CODEC_ID_NONE;
257 AVInputFormat *av_find_input_format(const char *short_name)
259 AVInputFormat *fmt = NULL;
260 while ((fmt = av_iformat_next(fmt))) {
261 if (match_format(short_name, fmt->name))
268 int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
270 int ret= av_new_packet(pkt, size);
275 pkt->pos= avio_tell(s);
277 ret= avio_read(s, pkt->data, size);
281 av_shrink_packet(pkt, ret);
286 int av_append_packet(AVIOContext *s, AVPacket *pkt, int size)
291 return av_get_packet(s, pkt, size);
292 old_size = pkt->size;
293 ret = av_grow_packet(pkt, size);
296 ret = avio_read(s, pkt->data + old_size, size);
297 av_shrink_packet(pkt, old_size + FFMAX(ret, 0));
302 int av_filename_number_test(const char *filename)
305 return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
308 AVInputFormat *av_probe_input_format3(AVProbeData *pd, int is_opened, int *score_ret)
310 AVProbeData lpd = *pd;
311 AVInputFormat *fmt1 = NULL, *fmt;
312 int score, score_max=0;
314 if (lpd.buf_size > 10 && ff_id3v2_match(lpd.buf, ID3v2_DEFAULT_MAGIC)) {
315 int id3len = ff_id3v2_tag_len(lpd.buf);
316 if (lpd.buf_size > id3len + 16) {
318 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 if(!score && fmt1->extensions && av_match_ext(lpd.filename, fmt1->extensions))
331 } else if (fmt1->extensions) {
332 if (av_match_ext(lpd.filename, fmt1->extensions)) {
336 if (score > score_max) {
339 }else if (score == score_max)
342 *score_ret= score_max;
347 AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
350 AVInputFormat *fmt= av_probe_input_format3(pd, is_opened, &score_ret);
351 if(score_ret > *score_max){
352 *score_max= score_ret;
358 AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
360 return av_probe_input_format2(pd, is_opened, &score);
363 static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st, AVProbeData *pd)
365 static const struct {
366 const char *name; enum CodecID id; enum AVMediaType type;
368 { "aac" , CODEC_ID_AAC , AVMEDIA_TYPE_AUDIO },
369 { "ac3" , CODEC_ID_AC3 , AVMEDIA_TYPE_AUDIO },
370 { "dts" , CODEC_ID_DTS , AVMEDIA_TYPE_AUDIO },
371 { "eac3" , CODEC_ID_EAC3 , AVMEDIA_TYPE_AUDIO },
372 { "h264" , CODEC_ID_H264 , AVMEDIA_TYPE_VIDEO },
373 { "loas" , CODEC_ID_AAC_LATM , AVMEDIA_TYPE_AUDIO },
374 { "m4v" , CODEC_ID_MPEG4 , AVMEDIA_TYPE_VIDEO },
375 { "mp3" , CODEC_ID_MP3 , AVMEDIA_TYPE_AUDIO },
376 { "mpegvideo", CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
380 AVInputFormat *fmt = av_probe_input_format3(pd, 1, &score);
384 av_log(s, AV_LOG_DEBUG, "Probe with size=%d, packets=%d detected %s with score=%d\n",
385 pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets, fmt->name, score);
386 for (i = 0; fmt_id_type[i].name; i++) {
387 if (!strcmp(fmt->name, fmt_id_type[i].name)) {
388 st->codec->codec_id = fmt_id_type[i].id;
389 st->codec->codec_type = fmt_id_type[i].type;
397 /************************************************************/
398 /* input media file */
400 #if FF_API_FORMAT_PARAMETERS
401 static AVDictionary *convert_format_parameters(AVFormatParameters *ap)
404 AVDictionary *opts = NULL;
409 AV_NOWARN_DEPRECATED(
410 if (ap->time_base.num) {
411 snprintf(buf, sizeof(buf), "%d/%d", ap->time_base.den, ap->time_base.num);
412 av_dict_set(&opts, "framerate", buf, 0);
414 if (ap->sample_rate) {
415 snprintf(buf, sizeof(buf), "%d", ap->sample_rate);
416 av_dict_set(&opts, "sample_rate", buf, 0);
419 snprintf(buf, sizeof(buf), "%d", ap->channels);
420 av_dict_set(&opts, "channels", buf, 0);
422 if (ap->width || ap->height) {
423 snprintf(buf, sizeof(buf), "%dx%d", ap->width, ap->height);
424 av_dict_set(&opts, "video_size", buf, 0);
426 if (ap->pix_fmt != PIX_FMT_NONE) {
427 av_dict_set(&opts, "pixel_format", av_get_pix_fmt_name(ap->pix_fmt), 0);
430 snprintf(buf, sizeof(buf), "%d", ap->channel);
431 av_dict_set(&opts, "channel", buf, 0);
434 av_dict_set(&opts, "standard", ap->standard, 0);
436 if (ap->mpeg2ts_compute_pcr) {
437 av_dict_set(&opts, "mpeg2ts_compute_pcr", "1", 0);
439 if (ap->initial_pause) {
440 av_dict_set(&opts, "initial_pause", "1", 0);
447 * Open a media file from an IO stream. 'fmt' must be specified.
449 int av_open_input_stream(AVFormatContext **ic_ptr,
450 AVIOContext *pb, const char *filename,
451 AVInputFormat *fmt, AVFormatParameters *ap)
456 AVFormatParameters default_ap;
460 memset(ap, 0, sizeof(default_ap));
462 opts = convert_format_parameters(ap);
464 AV_NOWARN_DEPRECATED(
465 if(!ap->prealloced_context)
466 *ic_ptr = ic = avformat_alloc_context();
471 err = AVERROR(ENOMEM);
474 if (pb && fmt && fmt->flags & AVFMT_NOFILE)
475 av_log(ic, AV_LOG_WARNING, "Custom AVIOContext makes no sense and "
476 "will be ignored with AVFMT_NOFILE format.\n");
480 if ((err = avformat_open_input(&ic, filename, fmt, &opts)) < 0)
482 ic->pb = ic->pb ? ic->pb : pb; // don't leak custom pb if it wasn't set above
491 int av_demuxer_open(AVFormatContext *ic, AVFormatParameters *ap){
494 if (ic->iformat->read_header) {
495 err = ic->iformat->read_header(ic, ap);
500 if (ic->pb && !ic->data_offset)
501 ic->data_offset = avio_tell(ic->pb);
507 /** size of probe buffer, for guessing file type from file contents */
508 #define PROBE_BUF_MIN 2048
509 #define PROBE_BUF_MAX (1<<20)
511 int av_probe_input_buffer(AVIOContext *pb, AVInputFormat **fmt,
512 const char *filename, void *logctx,
513 unsigned int offset, unsigned int max_probe_size)
515 AVProbeData pd = { filename ? filename : "", NULL, -offset };
516 unsigned char *buf = NULL;
517 int ret = 0, probe_size;
519 if (!max_probe_size) {
520 max_probe_size = PROBE_BUF_MAX;
521 } else if (max_probe_size > PROBE_BUF_MAX) {
522 max_probe_size = PROBE_BUF_MAX;
523 } else if (max_probe_size < PROBE_BUF_MIN) {
524 return AVERROR(EINVAL);
527 if (offset >= max_probe_size) {
528 return AVERROR(EINVAL);
531 for(probe_size= PROBE_BUF_MIN; probe_size<=max_probe_size && !*fmt;
532 probe_size = FFMIN(probe_size<<1, FFMAX(max_probe_size, probe_size+1))) {
533 int score = probe_size < max_probe_size ? AVPROBE_SCORE_MAX/4 : 0;
534 int buf_offset = (probe_size == PROBE_BUF_MIN) ? 0 : probe_size>>1;
537 if (probe_size < offset) {
541 /* read probe data */
542 buftmp = av_realloc(buf, probe_size + AVPROBE_PADDING_SIZE);
545 return AVERROR(ENOMEM);
548 if ((ret = avio_read(pb, buf + buf_offset, probe_size - buf_offset)) < 0) {
549 /* fail if error was not end of file, otherwise, lower score */
550 if (ret != AVERROR_EOF) {
555 ret = 0; /* error was end of file, nothing read */
558 pd.buf = &buf[offset];
560 memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE);
562 /* guess file format */
563 *fmt = av_probe_input_format2(&pd, 1, &score);
565 if(score <= AVPROBE_SCORE_MAX/4){ //this can only be true in the last iteration
566 av_log(logctx, AV_LOG_WARNING, "Format %s detected only with low score of %d, misdetection possible!\n", (*fmt)->name, score);
568 av_log(logctx, AV_LOG_DEBUG, "Format %s probed with size=%d and score=%d\n", (*fmt)->name, probe_size, score);
574 return AVERROR_INVALIDDATA;
577 /* rewind. reuse probe buffer to avoid seeking */
578 if ((ret = ffio_rewind_with_probe_data(pb, buf, pd.buf_size)) < 0)
584 #if FF_API_FORMAT_PARAMETERS
585 int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
588 AVFormatParameters *ap)
591 AVDictionary *opts = convert_format_parameters(ap);
593 AV_NOWARN_DEPRECATED(
594 if (!ap || !ap->prealloced_context)
598 err = avformat_open_input(ic_ptr, filename, fmt, &opts);
605 /* open input file and probe the format if necessary */
606 static int init_input(AVFormatContext *s, const char *filename, AVDictionary **options)
609 AVProbeData pd = {filename, NULL, 0};
611 if(s->iformat && !strlen(filename))
615 s->flags |= AVFMT_FLAG_CUSTOM_IO;
617 return av_probe_input_buffer(s->pb, &s->iformat, filename, s, 0, 0);
618 else if (s->iformat->flags & AVFMT_NOFILE)
619 av_log(s, AV_LOG_WARNING, "Custom AVIOContext makes no sense and "
620 "will be ignored with AVFMT_NOFILE format.\n");
624 if ( (s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
625 (!s->iformat && (s->iformat = av_probe_input_format(&pd, 0))))
628 if ((ret = avio_open2(&s->pb, filename, AVIO_FLAG_READ,
629 &s->interrupt_callback, options)) < 0)
633 return av_probe_input_buffer(s->pb, &s->iformat, filename, s, 0, 0);
636 int avformat_open_input(AVFormatContext **ps, const char *filename, AVInputFormat *fmt, AVDictionary **options)
638 AVFormatContext *s = *ps;
640 AVFormatParameters ap = { { 0 } };
641 AVDictionary *tmp = NULL;
643 if (!s && !(s = avformat_alloc_context()))
644 return AVERROR(ENOMEM);
649 av_dict_copy(&tmp, *options, 0);
651 if ((ret = av_opt_set_dict(s, &tmp)) < 0)
654 if ((ret = init_input(s, filename, &tmp)) < 0)
657 /* check filename in case an image number is expected */
658 if (s->iformat->flags & AVFMT_NEEDNUMBER) {
659 if (!av_filename_number_test(filename)) {
660 ret = AVERROR(EINVAL);
665 s->duration = s->start_time = AV_NOPTS_VALUE;
666 av_strlcpy(s->filename, filename, sizeof(s->filename));
668 /* allocate private data */
669 if (s->iformat->priv_data_size > 0) {
670 if (!(s->priv_data = av_mallocz(s->iformat->priv_data_size))) {
671 ret = AVERROR(ENOMEM);
674 if (s->iformat->priv_class) {
675 *(const AVClass**)s->priv_data = s->iformat->priv_class;
676 av_opt_set_defaults(s->priv_data);
677 if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
682 /* e.g. AVFMT_NOFILE formats will not have a AVIOContext */
684 ff_id3v2_read(s, ID3v2_DEFAULT_MAGIC);
686 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->iformat->read_header)
687 if ((ret = s->iformat->read_header(s, &ap)) < 0)
690 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->pb && !s->data_offset)
691 s->data_offset = avio_tell(s->pb);
693 s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
696 av_dict_free(options);
704 if (s->pb && !(s->flags & AVFMT_FLAG_CUSTOM_IO))
706 avformat_free_context(s);
711 /*******************************************************/
713 static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
714 AVPacketList **plast_pktl){
715 AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
720 (*plast_pktl)->next = pktl;
722 *packet_buffer = pktl;
724 /* add the packet in the buffered packet list */
730 int av_read_packet(AVFormatContext *s, AVPacket *pkt)
736 AVPacketList *pktl = s->raw_packet_buffer;
740 if(s->streams[pkt->stream_index]->request_probe <= 0){
741 s->raw_packet_buffer = pktl->next;
742 s->raw_packet_buffer_remaining_size += pkt->size;
749 ret= s->iformat->read_packet(s, pkt);
751 if (!pktl || ret == AVERROR(EAGAIN))
753 for (i = 0; i < s->nb_streams; i++)
754 if(s->streams[i]->request_probe > 0)
755 s->streams[i]->request_probe = -1;
759 if ((s->flags & AVFMT_FLAG_DISCARD_CORRUPT) &&
760 (pkt->flags & AV_PKT_FLAG_CORRUPT)) {
761 av_log(s, AV_LOG_WARNING,
762 "Dropped corrupted packet (stream = %d)\n",
768 if(!(s->flags & AVFMT_FLAG_KEEP_SIDE_DATA))
769 av_packet_merge_side_data(pkt);
771 if(pkt->stream_index >= (unsigned)s->nb_streams){
772 av_log(s, AV_LOG_ERROR, "Invalid stream index %d\n", pkt->stream_index);
776 st= s->streams[pkt->stream_index];
778 switch(st->codec->codec_type){
779 case AVMEDIA_TYPE_VIDEO:
780 if(s->video_codec_id) st->codec->codec_id= s->video_codec_id;
782 case AVMEDIA_TYPE_AUDIO:
783 if(s->audio_codec_id) st->codec->codec_id= s->audio_codec_id;
785 case AVMEDIA_TYPE_SUBTITLE:
786 if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
790 if(!pktl && st->request_probe <= 0)
793 add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
794 s->raw_packet_buffer_remaining_size -= pkt->size;
796 if(st->request_probe>0){
797 AVProbeData *pd = &st->probe_data;
799 av_log(s, AV_LOG_DEBUG, "probing stream %d pp:%d\n", st->index, st->probe_packets);
802 pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
803 memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
804 pd->buf_size += pkt->size;
805 memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
807 end= s->raw_packet_buffer_remaining_size <= 0
808 || st->probe_packets<=0;
810 if(end || av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)){
811 int score= set_codec_from_probe_data(s, st, pd);
812 if( (st->codec->codec_id != CODEC_ID_NONE && score > AVPROBE_SCORE_MAX/4)
816 st->request_probe= -1;
817 if(st->codec->codec_id != CODEC_ID_NONE){
818 av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
820 av_log(s, AV_LOG_WARNING, "probed stream %d failed\n", st->index);
827 /**********************************************************/
830 * Get the number of samples of an audio frame. Return -1 on error.
832 static int get_audio_frame_size(AVCodecContext *enc, int size)
836 if(enc->codec_id == CODEC_ID_VORBIS)
839 if (enc->frame_size <= 1) {
840 int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
842 if (bits_per_sample) {
843 if (enc->channels == 0)
845 frame_size = (size << 3) / (bits_per_sample * enc->channels);
847 /* used for example by ADPCM codecs */
848 if (enc->bit_rate == 0)
850 frame_size = ((int64_t)size * 8 * enc->sample_rate) / enc->bit_rate;
853 frame_size = enc->frame_size;
860 * Return the frame duration in seconds. Return 0 if not available.
862 static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
863 AVCodecParserContext *pc, AVPacket *pkt)
869 switch(st->codec->codec_type) {
870 case AVMEDIA_TYPE_VIDEO:
871 if(st->time_base.num*1000LL > st->time_base.den){
872 *pnum = st->time_base.num;
873 *pden = st->time_base.den;
874 }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
875 *pnum = st->codec->time_base.num;
876 *pden = st->codec->time_base.den;
877 if (pc && pc->repeat_pict) {
878 *pnum = (*pnum) * (1 + pc->repeat_pict);
880 //If this codec can be interlaced or progressive then we need a parser to compute duration of a packet
881 //Thus if we have no parser in such case leave duration undefined.
882 if(st->codec->ticks_per_frame>1 && !pc){
887 case AVMEDIA_TYPE_AUDIO:
888 frame_size = get_audio_frame_size(st->codec, pkt->size);
889 if (frame_size <= 0 || st->codec->sample_rate <= 0)
892 *pden = st->codec->sample_rate;
899 static int is_intra_only(AVCodecContext *enc){
900 if(enc->codec_type == AVMEDIA_TYPE_AUDIO){
902 }else if(enc->codec_type == AVMEDIA_TYPE_VIDEO){
903 switch(enc->codec_id){
905 case CODEC_ID_MJPEGB:
907 case CODEC_ID_PRORES:
908 case CODEC_ID_RAWVIDEO:
909 case CODEC_ID_DVVIDEO:
910 case CODEC_ID_HUFFYUV:
911 case CODEC_ID_FFVHUFF:
916 case CODEC_ID_JPEG2000:
924 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
925 int64_t dts, int64_t pts)
927 AVStream *st= s->streams[stream_index];
928 AVPacketList *pktl= s->packet_buffer;
930 if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE)
933 st->first_dts= dts - st->cur_dts;
936 for(; pktl; pktl= pktl->next){
937 if(pktl->pkt.stream_index != stream_index)
939 //FIXME think more about this check
940 if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
941 pktl->pkt.pts += st->first_dts;
943 if(pktl->pkt.dts != AV_NOPTS_VALUE)
944 pktl->pkt.dts += st->first_dts;
946 if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
947 st->start_time= pktl->pkt.pts;
949 if (st->start_time == AV_NOPTS_VALUE)
950 st->start_time = pts;
953 static void update_initial_durations(AVFormatContext *s, AVStream *st, AVPacket *pkt)
955 AVPacketList *pktl= s->packet_buffer;
958 if(st->first_dts != AV_NOPTS_VALUE){
959 cur_dts= st->first_dts;
960 for(; pktl; pktl= pktl->next){
961 if(pktl->pkt.stream_index == pkt->stream_index){
962 if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
964 cur_dts -= pkt->duration;
967 pktl= s->packet_buffer;
968 st->first_dts = cur_dts;
969 }else if(st->cur_dts)
972 for(; pktl; pktl= pktl->next){
973 if(pktl->pkt.stream_index != pkt->stream_index)
975 if(pktl->pkt.pts == pktl->pkt.dts && pktl->pkt.dts == AV_NOPTS_VALUE
976 && !pktl->pkt.duration){
977 pktl->pkt.dts= cur_dts;
978 if(!st->codec->has_b_frames)
979 pktl->pkt.pts= cur_dts;
980 cur_dts += pkt->duration;
981 pktl->pkt.duration= pkt->duration;
985 if(st->first_dts == AV_NOPTS_VALUE)
986 st->cur_dts= cur_dts;
989 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
990 AVCodecParserContext *pc, AVPacket *pkt)
992 int num, den, presentation_delayed, delay, i;
995 if (s->flags & AVFMT_FLAG_NOFILLIN)
998 if((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
999 pkt->dts= AV_NOPTS_VALUE;
1001 if (st->codec->codec_id != CODEC_ID_H264 && pc && pc->pict_type == AV_PICTURE_TYPE_B)
1002 //FIXME Set low_delay = 0 when has_b_frames = 1
1003 st->codec->has_b_frames = 1;
1005 /* do we have a video B-frame ? */
1006 delay= st->codec->has_b_frames;
1007 presentation_delayed = 0;
1009 /* XXX: need has_b_frame, but cannot get it if the codec is
1012 pc && pc->pict_type != AV_PICTURE_TYPE_B)
1013 presentation_delayed = 1;
1015 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts - (1LL<<(st->pts_wrap_bits-1)) > pkt->pts && st->pts_wrap_bits<63){
1016 pkt->dts -= 1LL<<st->pts_wrap_bits;
1019 // some mpeg2 in mpeg-ps lack dts (issue171 / input_file.mpg)
1020 // we take the conservative approach and discard both
1021 // Note, if this is misbehaving for a H.264 file then possibly presentation_delayed is not set correctly.
1022 if(delay==1 && pkt->dts == pkt->pts && pkt->dts != AV_NOPTS_VALUE && presentation_delayed){
1023 av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination %"PRIi64"\n", pkt->dts);
1024 pkt->dts= AV_NOPTS_VALUE;
1027 if (pkt->duration == 0) {
1028 compute_frame_duration(&num, &den, st, pc, pkt);
1030 pkt->duration = av_rescale_rnd(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num, AV_ROUND_DOWN);
1032 if(pkt->duration != 0 && s->packet_buffer)
1033 update_initial_durations(s, st, pkt);
1037 /* correct timestamps with byte offset if demuxers only have timestamps
1038 on packet boundaries */
1039 if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
1040 /* this will estimate bitrate based on this frame's duration and size */
1041 offset = av_rescale(pc->offset, pkt->duration, pkt->size);
1042 if(pkt->pts != AV_NOPTS_VALUE)
1044 if(pkt->dts != AV_NOPTS_VALUE)
1048 if (pc && pc->dts_sync_point >= 0) {
1049 // we have synchronization info from the parser
1050 int64_t den = st->codec->time_base.den * (int64_t) st->time_base.num;
1052 int64_t num = st->codec->time_base.num * (int64_t) st->time_base.den;
1053 if (pkt->dts != AV_NOPTS_VALUE) {
1054 // got DTS from the stream, update reference timestamp
1055 st->reference_dts = pkt->dts - pc->dts_ref_dts_delta * num / den;
1056 pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
1057 } else if (st->reference_dts != AV_NOPTS_VALUE) {
1058 // compute DTS based on reference timestamp
1059 pkt->dts = st->reference_dts + pc->dts_ref_dts_delta * num / den;
1060 pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
1062 if (pc->dts_sync_point > 0)
1063 st->reference_dts = pkt->dts; // new reference
1067 /* This may be redundant, but it should not hurt. */
1068 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
1069 presentation_delayed = 1;
1071 // 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);
1072 /* interpolate PTS and DTS if they are not present */
1073 //We skip H264 currently because delay and has_b_frames are not reliably set
1074 if((delay==0 || (delay==1 && pc)) && st->codec->codec_id != CODEC_ID_H264){
1075 if (presentation_delayed) {
1076 /* DTS = decompression timestamp */
1077 /* PTS = presentation timestamp */
1078 if (pkt->dts == AV_NOPTS_VALUE)
1079 pkt->dts = st->last_IP_pts;
1080 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
1081 if (pkt->dts == AV_NOPTS_VALUE)
1082 pkt->dts = st->cur_dts;
1084 /* this is tricky: the dts must be incremented by the duration
1085 of the frame we are displaying, i.e. the last I- or P-frame */
1086 if (st->last_IP_duration == 0)
1087 st->last_IP_duration = pkt->duration;
1088 if(pkt->dts != AV_NOPTS_VALUE)
1089 st->cur_dts = pkt->dts + st->last_IP_duration;
1090 st->last_IP_duration = pkt->duration;
1091 st->last_IP_pts= pkt->pts;
1092 /* cannot compute PTS if not present (we can compute it only
1093 by knowing the future */
1094 } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
1095 if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
1096 int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
1097 int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
1098 if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
1099 pkt->pts += pkt->duration;
1100 // 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);
1104 /* presentation is not delayed : PTS and DTS are the same */
1105 if(pkt->pts == AV_NOPTS_VALUE)
1106 pkt->pts = pkt->dts;
1107 update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
1108 if(pkt->pts == AV_NOPTS_VALUE)
1109 pkt->pts = st->cur_dts;
1110 pkt->dts = pkt->pts;
1111 if(pkt->pts != AV_NOPTS_VALUE)
1112 st->cur_dts = pkt->pts + pkt->duration;
1116 if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
1117 st->pts_buffer[0]= pkt->pts;
1118 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
1119 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
1120 if(pkt->dts == AV_NOPTS_VALUE)
1121 pkt->dts= st->pts_buffer[0];
1122 if(st->codec->codec_id == CODEC_ID_H264){ //we skiped it above so we try here
1123 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
1125 if(pkt->dts > st->cur_dts)
1126 st->cur_dts = pkt->dts;
1129 // 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);
1132 if(is_intra_only(st->codec))
1133 pkt->flags |= AV_PKT_FLAG_KEY;
1136 /* keyframe computation */
1137 if (pc->key_frame == 1)
1138 pkt->flags |= AV_PKT_FLAG_KEY;
1139 else if (pc->key_frame == -1 && pc->pict_type == AV_PICTURE_TYPE_I)
1140 pkt->flags |= AV_PKT_FLAG_KEY;
1143 pkt->convergence_duration = pc->convergence_duration;
1147 static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1152 av_init_packet(pkt);
1155 /* select current input stream component */
1158 if (!st->need_parsing || !st->parser) {
1159 /* no parsing needed: we just output the packet as is */
1160 /* raw data support */
1162 st->cur_pkt.data= NULL;
1163 st->cur_pkt.side_data_elems = 0;
1164 st->cur_pkt.side_data = NULL;
1165 compute_pkt_fields(s, st, NULL, pkt);
1167 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1168 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1169 ff_reduce_index(s, st->index);
1170 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1173 } else if (st->cur_len > 0 && st->discard < AVDISCARD_ALL) {
1174 len = av_parser_parse2(st->parser, st->codec, &pkt->data, &pkt->size,
1175 st->cur_ptr, st->cur_len,
1176 st->cur_pkt.pts, st->cur_pkt.dts,
1178 st->cur_pkt.pts = AV_NOPTS_VALUE;
1179 st->cur_pkt.dts = AV_NOPTS_VALUE;
1180 /* increment read pointer */
1184 /* return packet if any */
1188 pkt->stream_index = st->index;
1189 pkt->pts = st->parser->pts;
1190 pkt->dts = st->parser->dts;
1191 pkt->pos = st->parser->pos;
1192 if(pkt->data == st->cur_pkt.data && pkt->size == st->cur_pkt.size){
1194 pkt->destruct= st->cur_pkt.destruct;
1195 st->cur_pkt.destruct= NULL;
1196 st->cur_pkt.data = NULL;
1197 assert(st->cur_len == 0);
1199 pkt->destruct = NULL;
1201 compute_pkt_fields(s, st, st->parser, pkt);
1203 if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY){
1204 int64_t pos= (st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) ? pkt->pos : st->parser->frame_offset;
1205 ff_reduce_index(s, st->index);
1206 av_add_index_entry(st, pos, pkt->dts,
1207 0, 0, AVINDEX_KEYFRAME);
1214 av_free_packet(&st->cur_pkt);
1219 /* read next packet */
1220 ret = av_read_packet(s, &cur_pkt);
1222 if (ret == AVERROR(EAGAIN))
1224 /* return the last frames, if any */
1225 for(i = 0; i < s->nb_streams; i++) {
1227 if (st->parser && st->need_parsing) {
1228 av_parser_parse2(st->parser, st->codec,
1229 &pkt->data, &pkt->size,
1231 AV_NOPTS_VALUE, AV_NOPTS_VALUE,
1237 /* no more packets: really terminate parsing */
1240 st = s->streams[cur_pkt.stream_index];
1241 st->cur_pkt= cur_pkt;
1243 if(st->cur_pkt.pts != AV_NOPTS_VALUE &&
1244 st->cur_pkt.dts != AV_NOPTS_VALUE &&
1245 st->cur_pkt.pts < st->cur_pkt.dts){
1246 av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
1247 st->cur_pkt.stream_index,
1251 // av_free_packet(&st->cur_pkt);
1255 if(s->debug & FF_FDEBUG_TS)
1256 av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1257 st->cur_pkt.stream_index,
1261 st->cur_pkt.duration,
1265 st->cur_ptr = st->cur_pkt.data;
1266 st->cur_len = st->cur_pkt.size;
1267 if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1268 st->parser = av_parser_init(st->codec->codec_id);
1270 av_log(s, AV_LOG_WARNING, "parser not found for codec "
1271 "%s, packets or times may be invalid.\n",
1272 avcodec_get_name(st->codec->codec_id));
1273 /* no parser available: just output the raw packets */
1274 st->need_parsing = AVSTREAM_PARSE_NONE;
1275 }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
1276 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1277 }else if(st->need_parsing == AVSTREAM_PARSE_FULL_ONCE){
1278 st->parser->flags |= PARSER_FLAG_ONCE;
1283 if(s->debug & FF_FDEBUG_TS)
1284 av_log(s, AV_LOG_DEBUG, "read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1295 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1299 const int genpts= s->flags & AVFMT_FLAG_GENPTS;
1302 pktl = s->packet_buffer;
1304 AVPacket *next_pkt= &pktl->pkt;
1306 if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
1307 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1308 while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
1309 if( pktl->pkt.stream_index == next_pkt->stream_index
1310 && (0 > av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)))
1311 && av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) { //not b frame
1312 next_pkt->pts= pktl->pkt.dts;
1316 pktl = s->packet_buffer;
1319 if( next_pkt->pts != AV_NOPTS_VALUE
1320 || next_pkt->dts == AV_NOPTS_VALUE
1322 /* read packet from packet buffer, if there is data */
1324 s->packet_buffer = pktl->next;
1330 int ret= read_frame_internal(s, pkt);
1332 if(pktl && ret != AVERROR(EAGAIN)){
1339 if(av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1340 &s->packet_buffer_end)) < 0)
1341 return AVERROR(ENOMEM);
1343 assert(!s->packet_buffer);
1344 return read_frame_internal(s, pkt);
1349 /* XXX: suppress the packet queue */
1350 static void flush_packet_queue(AVFormatContext *s)
1355 pktl = s->packet_buffer;
1358 s->packet_buffer = pktl->next;
1359 av_free_packet(&pktl->pkt);
1362 while(s->raw_packet_buffer){
1363 pktl = s->raw_packet_buffer;
1364 s->raw_packet_buffer = pktl->next;
1365 av_free_packet(&pktl->pkt);
1368 s->packet_buffer_end=
1369 s->raw_packet_buffer_end= NULL;
1370 s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1373 /*******************************************************/
1376 int av_find_default_stream_index(AVFormatContext *s)
1378 int first_audio_index = -1;
1382 if (s->nb_streams <= 0)
1384 for(i = 0; i < s->nb_streams; i++) {
1386 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1389 if (first_audio_index < 0 && st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1390 first_audio_index = i;
1392 return first_audio_index >= 0 ? first_audio_index : 0;
1396 * Flush the frame reader.
1398 void ff_read_frame_flush(AVFormatContext *s)
1403 flush_packet_queue(s);
1407 /* for each stream, reset read state */
1408 for(i = 0; i < s->nb_streams; i++) {
1412 av_parser_close(st->parser);
1414 av_free_packet(&st->cur_pkt);
1416 st->last_IP_pts = AV_NOPTS_VALUE;
1417 if(st->first_dts == AV_NOPTS_VALUE) st->cur_dts = 0;
1418 else st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1419 st->reference_dts = AV_NOPTS_VALUE;
1424 st->probe_packets = MAX_PROBE_PACKETS;
1426 for(j=0; j<MAX_REORDER_DELAY+1; j++)
1427 st->pts_buffer[j]= AV_NOPTS_VALUE;
1431 #if FF_API_SEEK_PUBLIC
1432 void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1434 ff_update_cur_dts(s, ref_st, timestamp);
1438 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1442 for(i = 0; i < s->nb_streams; i++) {
1443 AVStream *st = s->streams[i];
1445 st->cur_dts = av_rescale(timestamp,
1446 st->time_base.den * (int64_t)ref_st->time_base.num,
1447 st->time_base.num * (int64_t)ref_st->time_base.den);
1451 void ff_reduce_index(AVFormatContext *s, int stream_index)
1453 AVStream *st= s->streams[stream_index];
1454 unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1456 if((unsigned)st->nb_index_entries >= max_entries){
1458 for(i=0; 2*i<st->nb_index_entries; i++)
1459 st->index_entries[i]= st->index_entries[2*i];
1460 st->nb_index_entries= i;
1464 int ff_add_index_entry(AVIndexEntry **index_entries,
1465 int *nb_index_entries,
1466 unsigned int *index_entries_allocated_size,
1467 int64_t pos, int64_t timestamp, int size, int distance, int flags)
1469 AVIndexEntry *entries, *ie;
1472 if((unsigned)*nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1475 entries = av_fast_realloc(*index_entries,
1476 index_entries_allocated_size,
1477 (*nb_index_entries + 1) *
1478 sizeof(AVIndexEntry));
1482 *index_entries= entries;
1484 index= ff_index_search_timestamp(*index_entries, *nb_index_entries, timestamp, AVSEEK_FLAG_ANY);
1487 index= (*nb_index_entries)++;
1488 ie= &entries[index];
1489 assert(index==0 || ie[-1].timestamp < timestamp);
1491 ie= &entries[index];
1492 if(ie->timestamp != timestamp){
1493 if(ie->timestamp <= timestamp)
1495 memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(*nb_index_entries - index));
1496 (*nb_index_entries)++;
1497 }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1498 distance= ie->min_distance;
1502 ie->timestamp = timestamp;
1503 ie->min_distance= distance;
1510 int av_add_index_entry(AVStream *st,
1511 int64_t pos, int64_t timestamp, int size, int distance, int flags)
1513 return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1514 &st->index_entries_allocated_size, pos,
1515 timestamp, size, distance, flags);
1518 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1519 int64_t wanted_timestamp, int flags)
1527 //optimize appending index entries at the end
1528 if(b && entries[b-1].timestamp < wanted_timestamp)
1533 timestamp = entries[m].timestamp;
1534 if(timestamp >= wanted_timestamp)
1536 if(timestamp <= wanted_timestamp)
1539 m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1541 if(!(flags & AVSEEK_FLAG_ANY)){
1542 while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1543 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1552 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1555 return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
1556 wanted_timestamp, flags);
1559 #if FF_API_SEEK_PUBLIC
1560 int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1561 return ff_seek_frame_binary(s, stream_index, target_ts, flags);
1565 int ff_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags)
1567 AVInputFormat *avif= s->iformat;
1568 int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1569 int64_t ts_min, ts_max, ts;
1574 if (stream_index < 0)
1577 av_dlog(s, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1580 ts_min= AV_NOPTS_VALUE;
1581 pos_limit= -1; //gcc falsely says it may be uninitialized
1583 st= s->streams[stream_index];
1584 if(st->index_entries){
1587 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()
1588 index= FFMAX(index, 0);
1589 e= &st->index_entries[index];
1591 if(e->timestamp <= target_ts || e->pos == e->min_distance){
1593 ts_min= e->timestamp;
1594 av_dlog(s, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1600 index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1601 assert(index < st->nb_index_entries);
1603 e= &st->index_entries[index];
1604 assert(e->timestamp >= target_ts);
1606 ts_max= e->timestamp;
1607 pos_limit= pos_max - e->min_distance;
1608 av_dlog(s, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1609 pos_max,pos_limit, ts_max);
1613 pos= ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1618 if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
1621 ff_read_frame_flush(s);
1622 ff_update_cur_dts(s, st, ts);
1627 #if FF_API_SEEK_PUBLIC
1628 int64_t av_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
1629 int64_t pos_min, int64_t pos_max, int64_t pos_limit,
1630 int64_t ts_min, int64_t ts_max, int flags, int64_t *ts_ret,
1631 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1633 return ff_gen_search(s, stream_index, target_ts, pos_min, pos_max,
1634 pos_limit, ts_min, ts_max, flags, ts_ret,
1639 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
1640 int64_t pos_min, int64_t pos_max, int64_t pos_limit,
1641 int64_t ts_min, int64_t ts_max, int flags, int64_t *ts_ret,
1642 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1645 int64_t start_pos, filesize;
1648 av_dlog(s, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1650 if(ts_min == AV_NOPTS_VALUE){
1651 pos_min = s->data_offset;
1652 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1653 if (ts_min == AV_NOPTS_VALUE)
1657 if(ts_min >= target_ts){
1662 if(ts_max == AV_NOPTS_VALUE){
1664 filesize = avio_size(s->pb);
1665 pos_max = filesize - 1;
1668 ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1670 }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1671 if (ts_max == AV_NOPTS_VALUE)
1675 int64_t tmp_pos= pos_max + 1;
1676 int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1677 if(tmp_ts == AV_NOPTS_VALUE)
1681 if(tmp_pos >= filesize)
1687 if(ts_max <= target_ts){
1692 if(ts_min > ts_max){
1694 }else if(ts_min == ts_max){
1699 while (pos_min < pos_limit) {
1700 av_dlog(s, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1701 pos_min, pos_max, ts_min, ts_max);
1702 assert(pos_limit <= pos_max);
1705 int64_t approximate_keyframe_distance= pos_max - pos_limit;
1706 // interpolate position (better than dichotomy)
1707 pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1708 + pos_min - approximate_keyframe_distance;
1709 }else if(no_change==1){
1710 // bisection, if interpolation failed to change min or max pos last time
1711 pos = (pos_min + pos_limit)>>1;
1713 /* linear search if bisection failed, can only happen if there
1714 are very few or no keyframes between min/max */
1719 else if(pos > pos_limit)
1723 ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1728 av_dlog(s, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64" target:%"PRId64" limit:%"PRId64" start:%"PRId64" noc:%d\n",
1729 pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts,
1730 pos_limit, start_pos, no_change);
1731 if(ts == AV_NOPTS_VALUE){
1732 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1735 assert(ts != AV_NOPTS_VALUE);
1736 if (target_ts <= ts) {
1737 pos_limit = start_pos - 1;
1741 if (target_ts >= ts) {
1747 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1748 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
1751 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1753 ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1754 av_dlog(s, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1755 pos, ts_min, target_ts, ts_max);
1761 static int seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1762 int64_t pos_min, pos_max;
1766 if (stream_index < 0)
1769 st= s->streams[stream_index];
1772 pos_min = s->data_offset;
1773 pos_max = avio_size(s->pb) - 1;
1775 if (pos < pos_min) pos= pos_min;
1776 else if(pos > pos_max) pos= pos_max;
1778 avio_seek(s->pb, pos, SEEK_SET);
1781 av_update_cur_dts(s, st, ts);
1786 static int seek_frame_generic(AVFormatContext *s,
1787 int stream_index, int64_t timestamp, int flags)
1794 st = s->streams[stream_index];
1796 index = av_index_search_timestamp(st, timestamp, flags);
1798 if(index < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
1801 if(index < 0 || index==st->nb_index_entries-1){
1805 if(st->nb_index_entries){
1806 assert(st->index_entries);
1807 ie= &st->index_entries[st->nb_index_entries-1];
1808 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1810 ff_update_cur_dts(s, st, ie->timestamp);
1812 if ((ret = avio_seek(s->pb, s->data_offset, SEEK_SET)) < 0)
1818 read_status = av_read_frame(s, &pkt);
1819 } while (read_status == AVERROR(EAGAIN));
1820 if (read_status < 0)
1822 av_free_packet(&pkt);
1823 if(stream_index == pkt.stream_index && pkt.dts > timestamp){
1824 if(pkt.flags & AV_PKT_FLAG_KEY)
1826 if(nonkey++ > 1000 && st->codec->codec_id != CODEC_ID_CDGRAPHICS){
1827 av_log(s, AV_LOG_ERROR,"seek_frame_generic failed as this stream seems to contain no keyframes after the target timestamp, %d non keyframes found\n", nonkey);
1832 index = av_index_search_timestamp(st, timestamp, flags);
1837 ff_read_frame_flush(s);
1838 AV_NOWARN_DEPRECATED(
1839 if (s->iformat->read_seek){
1840 if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1844 ie = &st->index_entries[index];
1845 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1847 ff_update_cur_dts(s, st, ie->timestamp);
1852 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1857 if (flags & AVSEEK_FLAG_BYTE) {
1858 if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
1860 ff_read_frame_flush(s);
1861 return seek_frame_byte(s, stream_index, timestamp, flags);
1864 if(stream_index < 0){
1865 stream_index= av_find_default_stream_index(s);
1866 if(stream_index < 0)
1869 st= s->streams[stream_index];
1870 /* timestamp for default must be expressed in AV_TIME_BASE units */
1871 timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1874 /* first, we try the format specific seek */
1875 AV_NOWARN_DEPRECATED(
1876 if (s->iformat->read_seek) {
1877 ff_read_frame_flush(s);
1878 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1886 if (s->iformat->read_timestamp && !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
1887 ff_read_frame_flush(s);
1888 return ff_seek_frame_binary(s, stream_index, timestamp, flags);
1889 } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
1890 ff_read_frame_flush(s);
1891 return seek_frame_generic(s, stream_index, timestamp, flags);
1897 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
1899 if(min_ts > ts || max_ts < ts)
1902 if (s->iformat->read_seek2) {
1903 ff_read_frame_flush(s);
1904 return s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
1907 if(s->iformat->read_timestamp){
1908 //try to seek via read_timestamp()
1911 //Fallback to old API if new is not implemented but old is
1912 //Note the old has somewat different sematics
1913 AV_NOWARN_DEPRECATED(
1914 if(s->iformat->read_seek || 1)
1915 return av_seek_frame(s, stream_index, ts, flags | (ts - min_ts > (uint64_t)(max_ts - ts) ? AVSEEK_FLAG_BACKWARD : 0));
1918 // try some generic seek like seek_frame_generic() but with new ts semantics
1921 /*******************************************************/
1924 * Return TRUE if the stream has accurate duration in any stream.
1926 * @return TRUE if the stream has accurate duration for at least one component.
1928 static int has_duration(AVFormatContext *ic)
1932 if(ic->duration != AV_NOPTS_VALUE)
1935 for(i = 0;i < ic->nb_streams; i++) {
1936 st = ic->streams[i];
1937 if (st->duration != AV_NOPTS_VALUE)
1944 * Estimate the stream timings from the one of each components.
1946 * Also computes the global bitrate if possible.
1948 static void update_stream_timings(AVFormatContext *ic)
1950 int64_t start_time, start_time1, start_time_text, end_time, end_time1;
1951 int64_t duration, duration1, filesize;
1955 start_time = INT64_MAX;
1956 start_time_text = INT64_MAX;
1957 end_time = INT64_MIN;
1958 duration = INT64_MIN;
1959 for(i = 0;i < ic->nb_streams; i++) {
1960 st = ic->streams[i];
1961 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
1962 start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1963 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1964 if (start_time1 < start_time_text)
1965 start_time_text = start_time1;
1967 start_time = FFMIN(start_time, start_time1);
1968 if (st->duration != AV_NOPTS_VALUE) {
1969 end_time1 = start_time1
1970 + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1971 end_time = FFMAX(end_time, end_time1);
1974 if (st->duration != AV_NOPTS_VALUE) {
1975 duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1976 duration = FFMAX(duration, duration1);
1979 if (start_time == INT64_MAX || (start_time > start_time_text && start_time - start_time_text < AV_TIME_BASE))
1980 start_time = start_time_text;
1981 if (start_time != INT64_MAX) {
1982 ic->start_time = start_time;
1983 if (end_time != INT64_MIN)
1984 duration = FFMAX(duration, end_time - start_time);
1986 if (duration != INT64_MIN && ic->duration == AV_NOPTS_VALUE) {
1987 ic->duration = duration;
1989 if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration != AV_NOPTS_VALUE) {
1990 /* compute the bitrate */
1991 ic->bit_rate = (double)filesize * 8.0 * AV_TIME_BASE /
1992 (double)ic->duration;
1996 static void fill_all_stream_timings(AVFormatContext *ic)
2001 update_stream_timings(ic);
2002 for(i = 0;i < ic->nb_streams; i++) {
2003 st = ic->streams[i];
2004 if (st->start_time == AV_NOPTS_VALUE) {
2005 if(ic->start_time != AV_NOPTS_VALUE)
2006 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
2007 if(ic->duration != AV_NOPTS_VALUE)
2008 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
2013 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
2015 int64_t filesize, duration;
2019 /* if bit_rate is already set, we believe it */
2020 if (ic->bit_rate <= 0) {
2022 for(i=0;i<ic->nb_streams;i++) {
2023 st = ic->streams[i];
2024 if (st->codec->bit_rate > 0)
2025 bit_rate += st->codec->bit_rate;
2027 ic->bit_rate = bit_rate;
2030 /* if duration is already set, we believe it */
2031 if (ic->duration == AV_NOPTS_VALUE &&
2032 ic->bit_rate != 0) {
2033 filesize = ic->pb ? avio_size(ic->pb) : 0;
2035 for(i = 0; i < ic->nb_streams; i++) {
2036 st = ic->streams[i];
2037 duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
2038 if (st->duration == AV_NOPTS_VALUE)
2039 st->duration = duration;
2045 #define DURATION_MAX_READ_SIZE 250000
2046 #define DURATION_MAX_RETRY 3
2048 /* only usable for MPEG-PS streams */
2049 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2051 AVPacket pkt1, *pkt = &pkt1;
2053 int read_size, i, ret;
2055 int64_t filesize, offset, duration;
2060 /* flush packet queue */
2061 flush_packet_queue(ic);
2063 for (i=0; i<ic->nb_streams; i++) {
2064 st = ic->streams[i];
2065 if (st->start_time == AV_NOPTS_VALUE && st->first_dts == AV_NOPTS_VALUE)
2066 av_log(st->codec, AV_LOG_WARNING, "start time is not set in estimate_timings_from_pts\n");
2069 av_parser_close(st->parser);
2071 av_free_packet(&st->cur_pkt);
2075 /* estimate the end time (duration) */
2076 /* XXX: may need to support wrapping */
2077 filesize = ic->pb ? avio_size(ic->pb) : 0;
2078 end_time = AV_NOPTS_VALUE;
2080 offset = filesize - (DURATION_MAX_READ_SIZE<<retry);
2084 avio_seek(ic->pb, offset, SEEK_SET);
2087 if (read_size >= DURATION_MAX_READ_SIZE<<(FFMAX(retry-1,0)))
2091 ret = av_read_packet(ic, pkt);
2092 } while(ret == AVERROR(EAGAIN));
2095 read_size += pkt->size;
2096 st = ic->streams[pkt->stream_index];
2097 if (pkt->pts != AV_NOPTS_VALUE &&
2098 (st->start_time != AV_NOPTS_VALUE ||
2099 st->first_dts != AV_NOPTS_VALUE)) {
2100 duration = end_time = pkt->pts;
2101 if (st->start_time != AV_NOPTS_VALUE)
2102 duration -= st->start_time;
2104 duration -= st->first_dts;
2106 duration += 1LL<<st->pts_wrap_bits;
2108 if (st->duration == AV_NOPTS_VALUE || st->duration < duration)
2109 st->duration = duration;
2112 av_free_packet(pkt);
2114 }while( end_time==AV_NOPTS_VALUE
2115 && filesize > (DURATION_MAX_READ_SIZE<<retry)
2116 && ++retry <= DURATION_MAX_RETRY);
2118 fill_all_stream_timings(ic);
2120 avio_seek(ic->pb, old_offset, SEEK_SET);
2121 for (i=0; i<ic->nb_streams; i++) {
2123 st->cur_dts= st->first_dts;
2124 st->last_IP_pts = AV_NOPTS_VALUE;
2125 st->reference_dts = AV_NOPTS_VALUE;
2129 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2133 /* get the file size, if possible */
2134 if (ic->iformat->flags & AVFMT_NOFILE) {
2137 file_size = avio_size(ic->pb);
2138 file_size = FFMAX(0, file_size);
2141 if ((!strcmp(ic->iformat->name, "mpeg") ||
2142 !strcmp(ic->iformat->name, "mpegts")) &&
2143 file_size && ic->pb->seekable) {
2144 /* get accurate estimate from the PTSes */
2145 estimate_timings_from_pts(ic, old_offset);
2146 } else if (has_duration(ic)) {
2147 /* at least one component has timings - we use them for all
2149 fill_all_stream_timings(ic);
2151 av_log(ic, AV_LOG_WARNING, "Estimating duration from bitrate, this may be inaccurate\n");
2152 /* less precise: use bitrate info */
2153 estimate_timings_from_bit_rate(ic);
2155 update_stream_timings(ic);
2159 AVStream av_unused *st;
2160 for(i = 0;i < ic->nb_streams; i++) {
2161 st = ic->streams[i];
2162 av_dlog(ic, "%d: start_time: %0.3f duration: %0.3f\n", i,
2163 (double) st->start_time / AV_TIME_BASE,
2164 (double) st->duration / AV_TIME_BASE);
2166 av_dlog(ic, "stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2167 (double) ic->start_time / AV_TIME_BASE,
2168 (double) ic->duration / AV_TIME_BASE,
2169 ic->bit_rate / 1000);
2173 static int has_codec_parameters(AVCodecContext *avctx)
2176 switch (avctx->codec_type) {
2177 case AVMEDIA_TYPE_AUDIO:
2178 val = avctx->sample_rate && avctx->channels && avctx->sample_fmt != AV_SAMPLE_FMT_NONE;
2179 if (!avctx->frame_size &&
2180 (avctx->codec_id == CODEC_ID_VORBIS ||
2181 avctx->codec_id == CODEC_ID_AAC ||
2182 avctx->codec_id == CODEC_ID_MP1 ||
2183 avctx->codec_id == CODEC_ID_MP2 ||
2184 avctx->codec_id == CODEC_ID_MP3 ||
2185 avctx->codec_id == CODEC_ID_CELT))
2188 case AVMEDIA_TYPE_VIDEO:
2189 val = avctx->width && avctx->pix_fmt != PIX_FMT_NONE;
2191 case AVMEDIA_TYPE_DATA:
2192 if(avctx->codec_id == CODEC_ID_NONE) return 1;
2197 return avctx->codec_id != CODEC_ID_NONE && val != 0;
2200 static int has_decode_delay_been_guessed(AVStream *st)
2202 return st->codec->codec_id != CODEC_ID_H264 ||
2203 st->info->nb_decoded_frames >= 6;
2206 static int try_decode_frame(AVStream *st, AVPacket *avpkt, AVDictionary **options)
2210 int got_picture, data_size, ret=0;
2213 if(!st->codec->codec){
2214 codec = avcodec_find_decoder(st->codec->codec_id);
2217 ret = avcodec_open2(st->codec, codec, options);
2222 if(!has_codec_parameters(st->codec) || !has_decode_delay_been_guessed(st) ||
2223 (!st->codec_info_nb_frames && st->codec->codec->capabilities & CODEC_CAP_CHANNEL_CONF)) {
2224 switch(st->codec->codec_type) {
2225 case AVMEDIA_TYPE_VIDEO:
2226 avcodec_get_frame_defaults(&picture);
2227 ret = avcodec_decode_video2(st->codec, &picture,
2228 &got_picture, avpkt);
2230 st->info->nb_decoded_frames++;
2232 case AVMEDIA_TYPE_AUDIO:
2233 data_size = FFMAX(avpkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
2234 samples = av_malloc(data_size);
2237 ret = avcodec_decode_audio3(st->codec, samples,
2249 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum CodecID id)
2251 while (tags->id != CODEC_ID_NONE) {
2259 enum CodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2262 for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
2263 if(tag == tags[i].tag)
2266 for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
2267 if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
2270 return CODEC_ID_NONE;
2273 unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum CodecID id)
2276 for(i=0; tags && tags[i]; i++){
2277 int tag= ff_codec_get_tag(tags[i], id);
2283 enum CodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
2286 for(i=0; tags && tags[i]; i++){
2287 enum CodecID id= ff_codec_get_id(tags[i], tag);
2288 if(id!=CODEC_ID_NONE) return id;
2290 return CODEC_ID_NONE;
2293 static void compute_chapters_end(AVFormatContext *s)
2296 int64_t max_time = s->duration + ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
2298 for (i = 0; i < s->nb_chapters; i++)
2299 if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2300 AVChapter *ch = s->chapters[i];
2301 int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q, ch->time_base)
2304 for (j = 0; j < s->nb_chapters; j++) {
2305 AVChapter *ch1 = s->chapters[j];
2306 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base, ch->time_base);
2307 if (j != i && next_start > ch->start && next_start < end)
2310 ch->end = (end == INT64_MAX) ? ch->start : end;
2314 static int get_std_framerate(int i){
2315 if(i<60*12) return i*1001;
2316 else return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
2320 * Is the time base unreliable.
2321 * This is a heuristic to balance between quick acceptance of the values in
2322 * the headers vs. some extra checks.
2323 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2324 * MPEG-2 commonly misuses field repeat flags to store different framerates.
2325 * And there are "variable" fps files this needs to detect as well.
2327 static int tb_unreliable(AVCodecContext *c){
2328 if( c->time_base.den >= 101L*c->time_base.num
2329 || c->time_base.den < 5L*c->time_base.num
2330 /* || c->codec_tag == AV_RL32("DIVX")
2331 || c->codec_tag == AV_RL32("XVID")*/
2332 || c->codec_id == CODEC_ID_MPEG2VIDEO
2333 || c->codec_id == CODEC_ID_H264
2339 #if FF_API_FORMAT_PARAMETERS
2340 int av_find_stream_info(AVFormatContext *ic)
2342 return avformat_find_stream_info(ic, NULL);
2346 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
2348 int i, count, ret, read_size, j;
2350 AVPacket pkt1, *pkt;
2351 int64_t old_offset = avio_tell(ic->pb);
2352 int orig_nb_streams = ic->nb_streams; // new streams might appear, no options for those
2354 for(i=0;i<ic->nb_streams;i++) {
2356 st = ic->streams[i];
2358 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2359 st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2360 /* if(!st->time_base.num)
2362 if(!st->codec->time_base.num)
2363 st->codec->time_base= st->time_base;
2365 //only for the split stuff
2366 if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
2367 st->parser = av_parser_init(st->codec->codec_id);
2368 if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
2369 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2372 assert(!st->codec->codec);
2373 codec = avcodec_find_decoder(st->codec->codec_id);
2375 /* Ensure that subtitle_header is properly set. */
2376 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
2377 && codec && !st->codec->codec)
2378 avcodec_open2(st->codec, codec, options ? &options[i] : NULL);
2380 //try to just open decoders, in case this is enough to get parameters
2381 if(!has_codec_parameters(st->codec)){
2382 if (codec && !st->codec->codec){
2383 AVDictionary *tmp = NULL;
2385 av_dict_copy(&tmp, options[i], 0);
2386 av_dict_set(&tmp, "threads", 0, 0);
2388 avcodec_open2(st->codec, codec, options ? &tmp : NULL);
2394 for (i=0; i<ic->nb_streams; i++) {
2395 ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
2401 if (ff_check_interrupt(&ic->interrupt_callback)){
2403 av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2407 /* check if one codec still needs to be handled */
2408 for(i=0;i<ic->nb_streams;i++) {
2409 int fps_analyze_framecount = 20;
2411 st = ic->streams[i];
2412 if (!has_codec_parameters(st->codec))
2414 /* if the timebase is coarse (like the usual millisecond precision
2415 of mkv), we need to analyze more frames to reliably arrive at
2417 if (av_q2d(st->time_base) > 0.0005)
2418 fps_analyze_framecount *= 2;
2419 if (ic->fps_probe_size >= 0)
2420 fps_analyze_framecount = ic->fps_probe_size;
2421 /* variable fps and no guess at the real fps */
2422 if( tb_unreliable(st->codec) && !(st->r_frame_rate.num && st->avg_frame_rate.num)
2423 && st->info->duration_count < fps_analyze_framecount
2424 && st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2426 if(st->parser && st->parser->parser->split && !st->codec->extradata)
2428 if(st->first_dts == AV_NOPTS_VALUE && (st->codec->codec_type == AVMEDIA_TYPE_VIDEO || st->codec->codec_type == AVMEDIA_TYPE_AUDIO))
2431 if (i == ic->nb_streams) {
2432 /* NOTE: if the format has no header, then we need to read
2433 some packets to get most of the streams, so we cannot
2435 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2436 /* if we found the info for all the codecs, we can stop */
2438 av_log(ic, AV_LOG_DEBUG, "All info found\n");
2442 /* we did not get all the codec info, but we read too much data */
2443 if (read_size >= ic->probesize) {
2445 av_log(ic, AV_LOG_DEBUG, "Probe buffer size limit %d reached\n", ic->probesize);
2449 /* NOTE: a new stream can be added there if no header in file
2450 (AVFMTCTX_NOHEADER) */
2451 ret = read_frame_internal(ic, &pkt1);
2452 if (ret == AVERROR(EAGAIN))
2457 ret = -1; /* we could not have all the codec parameters before EOF */
2458 for(i=0;i<ic->nb_streams;i++) {
2459 st = ic->streams[i];
2460 if (!has_codec_parameters(st->codec)){
2462 avcodec_string(buf, sizeof(buf), st->codec, 0);
2463 av_log(ic, AV_LOG_WARNING, "Could not find codec parameters (%s)\n", buf);
2471 pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2472 if ((ret = av_dup_packet(pkt)) < 0)
2473 goto find_stream_info_err;
2475 read_size += pkt->size;
2477 st = ic->streams[pkt->stream_index];
2478 if (st->codec_info_nb_frames>1) {
2480 if (st->time_base.den > 0 && (t=av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q)) >= ic->max_analyze_duration) {
2481 av_log(ic, AV_LOG_WARNING, "max_analyze_duration %d reached at %"PRId64"\n", ic->max_analyze_duration, t);
2484 st->info->codec_info_duration += pkt->duration;
2487 int64_t last = st->info->last_dts;
2489 if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && pkt->dts > last){
2490 double dts= pkt->dts * av_q2d(st->time_base);
2491 int64_t duration= pkt->dts - last;
2493 // if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2494 // av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
2495 for (i=1; i<FF_ARRAY_ELEMS(st->info->duration_error[0][0]); i++) {
2496 int framerate= get_std_framerate(i);
2497 double sdts= dts*framerate/(1001*12);
2499 int ticks= lrintf(sdts+j*0.5);
2500 double error= sdts - ticks + j*0.5;
2501 st->info->duration_error[j][0][i] += error;
2502 st->info->duration_error[j][1][i] += error*error;
2505 st->info->duration_count++;
2506 // ignore the first 4 values, they might have some random jitter
2507 if (st->info->duration_count > 3)
2508 st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2510 if (last == AV_NOPTS_VALUE || st->info->duration_count <= 1)
2511 st->info->last_dts = pkt->dts;
2513 if(st->parser && st->parser->parser->split && !st->codec->extradata){
2514 int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2516 st->codec->extradata_size= i;
2517 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2518 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2519 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2523 /* if still no information, we try to open the codec and to
2524 decompress the frame. We try to avoid that in most cases as
2525 it takes longer and uses more memory. For MPEG-4, we need to
2526 decompress for QuickTime.
2528 If CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
2529 least one frame of codec data, this makes sure the codec initializes
2530 the channel configuration and does not only trust the values from the container.
2532 try_decode_frame(st, pkt, (options && i < orig_nb_streams )? &options[i] : NULL);
2534 st->codec_info_nb_frames++;
2538 // close codecs which were opened in try_decode_frame()
2539 for(i=0;i<ic->nb_streams;i++) {
2540 st = ic->streams[i];
2541 if(st->codec->codec)
2542 avcodec_close(st->codec);
2544 for(i=0;i<ic->nb_streams;i++) {
2545 st = ic->streams[i];
2546 if (st->codec_info_nb_frames>2 && !st->avg_frame_rate.num && st->info->codec_info_duration)
2547 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2548 (st->codec_info_nb_frames-2)*(int64_t)st->time_base.den,
2549 st->info->codec_info_duration*(int64_t)st->time_base.num, 60000);
2550 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2551 if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample){
2552 uint32_t tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2553 if(ff_find_pix_fmt(ff_raw_pix_fmt_tags, tag) == st->codec->pix_fmt)
2554 st->codec->codec_tag= tag;
2557 // the check for tb_unreliable() is not completely correct, since this is not about handling
2558 // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2559 // ipmovie.c produces.
2560 if (tb_unreliable(st->codec) && st->info->duration_count > 15 && st->info->duration_gcd > FFMAX(1, st->time_base.den/(500LL*st->time_base.num)) && !st->r_frame_rate.num)
2561 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);
2562 if (st->info->duration_count && !st->r_frame_rate.num
2563 && tb_unreliable(st->codec) /*&&
2564 //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2565 st->time_base.num*duration_sum[i]/st->info->duration_count*101LL > st->time_base.den*/){
2567 double best_error= 0.01;
2569 for (j=1; j<FF_ARRAY_ELEMS(st->info->duration_error[0][0]); j++) {
2572 if(st->info->codec_info_duration && st->info->codec_info_duration*av_q2d(st->time_base) < (1001*12.0)/get_std_framerate(j))
2575 int n= st->info->duration_count;
2576 double a= st->info->duration_error[k][0][j] / n;
2577 double error= st->info->duration_error[k][1][j]/n - a*a;
2579 if(error < best_error && best_error> 0.000000001){
2581 num = get_std_framerate(j);
2584 av_log(NULL, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
2587 // do not increase frame rate by more than 1 % in order to match a standard rate.
2588 if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
2589 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2592 if (!st->r_frame_rate.num){
2593 if( st->codec->time_base.den * (int64_t)st->time_base.num
2594 <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
2595 st->r_frame_rate.num = st->codec->time_base.den;
2596 st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
2598 st->r_frame_rate.num = st->time_base.den;
2599 st->r_frame_rate.den = st->time_base.num;
2602 }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2603 if(!st->codec->bits_per_coded_sample)
2604 st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2605 // set stream disposition based on audio service type
2606 switch (st->codec->audio_service_type) {
2607 case AV_AUDIO_SERVICE_TYPE_EFFECTS:
2608 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS; break;
2609 case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
2610 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED; break;
2611 case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
2612 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED; break;
2613 case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
2614 st->disposition = AV_DISPOSITION_COMMENT; break;
2615 case AV_AUDIO_SERVICE_TYPE_KARAOKE:
2616 st->disposition = AV_DISPOSITION_KARAOKE; break;
2621 estimate_timings(ic, old_offset);
2623 compute_chapters_end(ic);
2626 /* correct DTS for B-frame streams with no timestamps */
2627 for(i=0;i<ic->nb_streams;i++) {
2628 st = ic->streams[i];
2629 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2631 ppktl = &ic->packet_buffer;
2633 if(ppkt1->stream_index != i)
2635 if(ppkt1->pkt->dts < 0)
2637 if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2639 ppkt1->pkt->dts -= delta;
2644 st->cur_dts -= delta;
2650 find_stream_info_err:
2651 for (i=0; i < ic->nb_streams; i++)
2652 av_freep(&ic->streams[i]->info);
2656 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
2660 for (i = 0; i < ic->nb_programs; i++) {
2661 if (ic->programs[i] == last) {
2665 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
2666 if (ic->programs[i]->stream_index[j] == s)
2667 return ic->programs[i];
2673 int av_find_best_stream(AVFormatContext *ic,
2674 enum AVMediaType type,
2675 int wanted_stream_nb,
2677 AVCodec **decoder_ret,
2680 int i, nb_streams = ic->nb_streams;
2681 int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1;
2682 unsigned *program = NULL;
2683 AVCodec *decoder = NULL, *best_decoder = NULL;
2685 if (related_stream >= 0 && wanted_stream_nb < 0) {
2686 AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
2688 program = p->stream_index;
2689 nb_streams = p->nb_stream_indexes;
2692 for (i = 0; i < nb_streams; i++) {
2693 int real_stream_index = program ? program[i] : i;
2694 AVStream *st = ic->streams[real_stream_index];
2695 AVCodecContext *avctx = st->codec;
2696 if (avctx->codec_type != type)
2698 if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
2700 if (st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED|AV_DISPOSITION_VISUAL_IMPAIRED))
2703 decoder = avcodec_find_decoder(st->codec->codec_id);
2706 ret = AVERROR_DECODER_NOT_FOUND;
2710 if (best_count >= st->codec_info_nb_frames)
2712 best_count = st->codec_info_nb_frames;
2713 ret = real_stream_index;
2714 best_decoder = decoder;
2715 if (program && i == nb_streams - 1 && ret < 0) {
2717 nb_streams = ic->nb_streams;
2718 i = 0; /* no related stream found, try again with everything */
2722 *decoder_ret = best_decoder;
2726 /*******************************************************/
2728 int av_read_play(AVFormatContext *s)
2730 if (s->iformat->read_play)
2731 return s->iformat->read_play(s);
2733 return avio_pause(s->pb, 0);
2734 return AVERROR(ENOSYS);
2737 int av_read_pause(AVFormatContext *s)
2739 if (s->iformat->read_pause)
2740 return s->iformat->read_pause(s);
2742 return avio_pause(s->pb, 1);
2743 return AVERROR(ENOSYS);
2746 void av_close_input_stream(AVFormatContext *s)
2748 flush_packet_queue(s);
2749 if (s->iformat->read_close)
2750 s->iformat->read_close(s);
2751 avformat_free_context(s);
2754 void avformat_free_context(AVFormatContext *s)
2760 if (s->iformat && s->iformat->priv_class && s->priv_data)
2761 av_opt_free(s->priv_data);
2763 for(i=0;i<s->nb_streams;i++) {
2764 /* free all data in a stream component */
2767 av_parser_close(st->parser);
2768 av_free_packet(&st->cur_pkt);
2770 av_dict_free(&st->metadata);
2771 av_freep(&st->index_entries);
2772 av_freep(&st->codec->extradata);
2773 av_freep(&st->codec->subtitle_header);
2774 av_freep(&st->codec);
2775 av_freep(&st->priv_data);
2776 av_freep(&st->info);
2779 for(i=s->nb_programs-1; i>=0; i--) {
2780 av_dict_free(&s->programs[i]->metadata);
2781 av_freep(&s->programs[i]->stream_index);
2782 av_freep(&s->programs[i]);
2784 av_freep(&s->programs);
2785 av_freep(&s->priv_data);
2786 while(s->nb_chapters--) {
2787 av_dict_free(&s->chapters[s->nb_chapters]->metadata);
2788 av_freep(&s->chapters[s->nb_chapters]);
2790 av_freep(&s->chapters);
2791 av_dict_free(&s->metadata);
2792 av_freep(&s->streams);
2796 void av_close_input_file(AVFormatContext *s)
2798 AVIOContext *pb = (s->iformat->flags & AVFMT_NOFILE) || (s->flags & AVFMT_FLAG_CUSTOM_IO) ?
2800 av_close_input_stream(s);
2805 #if FF_API_NEW_STREAM
2806 AVStream *av_new_stream(AVFormatContext *s, int id)
2808 AVStream *st = avformat_new_stream(s, NULL);
2815 AVStream *avformat_new_stream(AVFormatContext *s, AVCodec *c)
2821 if (s->nb_streams >= INT_MAX/sizeof(*streams))
2823 streams = av_realloc(s->streams, (s->nb_streams + 1) * sizeof(*streams));
2826 s->streams = streams;
2828 st = av_mallocz(sizeof(AVStream));
2831 if (!(st->info = av_mallocz(sizeof(*st->info)))) {
2836 st->codec = avcodec_alloc_context3(c);
2838 /* no default bitrate if decoding */
2839 st->codec->bit_rate = 0;
2841 st->index = s->nb_streams;
2842 st->start_time = AV_NOPTS_VALUE;
2843 st->duration = AV_NOPTS_VALUE;
2844 /* we set the current DTS to 0 so that formats without any timestamps
2845 but durations get some timestamps, formats with some unknown
2846 timestamps have their first few packets buffered and the
2847 timestamps corrected before they are returned to the user */
2849 st->first_dts = AV_NOPTS_VALUE;
2850 st->probe_packets = MAX_PROBE_PACKETS;
2852 /* default pts setting is MPEG-like */
2853 av_set_pts_info(st, 33, 1, 90000);
2854 st->last_IP_pts = AV_NOPTS_VALUE;
2855 for(i=0; i<MAX_REORDER_DELAY+1; i++)
2856 st->pts_buffer[i]= AV_NOPTS_VALUE;
2857 st->reference_dts = AV_NOPTS_VALUE;
2859 st->sample_aspect_ratio = (AVRational){0,1};
2861 s->streams[s->nb_streams++] = st;
2865 AVProgram *av_new_program(AVFormatContext *ac, int id)
2867 AVProgram *program=NULL;
2870 av_dlog(ac, "new_program: id=0x%04x\n", id);
2872 for(i=0; i<ac->nb_programs; i++)
2873 if(ac->programs[i]->id == id)
2874 program = ac->programs[i];
2877 program = av_mallocz(sizeof(AVProgram));
2880 dynarray_add(&ac->programs, &ac->nb_programs, program);
2881 program->discard = AVDISCARD_NONE;
2888 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2890 AVChapter *chapter = NULL;
2893 for(i=0; i<s->nb_chapters; i++)
2894 if(s->chapters[i]->id == id)
2895 chapter = s->chapters[i];
2898 chapter= av_mallocz(sizeof(AVChapter));
2901 dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2903 av_dict_set(&chapter->metadata, "title", title, 0);
2905 chapter->time_base= time_base;
2906 chapter->start = start;
2912 /************************************************************/
2913 /* output media file */
2915 #if FF_API_FORMAT_PARAMETERS
2916 int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2918 if (s->oformat->priv_data_size > 0) {
2919 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2921 return AVERROR(ENOMEM);
2922 if (s->oformat->priv_class) {
2923 *(const AVClass**)s->priv_data= s->oformat->priv_class;
2924 av_opt_set_defaults(s->priv_data);
2927 s->priv_data = NULL;
2933 int avformat_alloc_output_context2(AVFormatContext **avctx, AVOutputFormat *oformat,
2934 const char *format, const char *filename)
2936 AVFormatContext *s = avformat_alloc_context();
2945 oformat = av_guess_format(format, NULL, NULL);
2947 av_log(s, AV_LOG_ERROR, "Requested output format '%s' is not a suitable output format\n", format);
2948 ret = AVERROR(EINVAL);
2952 oformat = av_guess_format(NULL, filename, NULL);
2954 ret = AVERROR(EINVAL);
2955 av_log(s, AV_LOG_ERROR, "Unable to find a suitable output format for '%s'\n",
2962 s->oformat = oformat;
2963 if (s->oformat->priv_data_size > 0) {
2964 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2967 if (s->oformat->priv_class) {
2968 *(const AVClass**)s->priv_data= s->oformat->priv_class;
2969 av_opt_set_defaults(s->priv_data);
2972 s->priv_data = NULL;
2975 av_strlcpy(s->filename, filename, sizeof(s->filename));
2979 av_log(s, AV_LOG_ERROR, "Out of memory\n");
2980 ret = AVERROR(ENOMEM);
2982 avformat_free_context(s);
2986 #if FF_API_ALLOC_OUTPUT_CONTEXT
2987 AVFormatContext *avformat_alloc_output_context(const char *format,
2988 AVOutputFormat *oformat, const char *filename)
2990 AVFormatContext *avctx;
2991 int ret = avformat_alloc_output_context2(&avctx, oformat, format, filename);
2992 return ret < 0 ? NULL : avctx;
2996 static int validate_codec_tag(AVFormatContext *s, AVStream *st)
2998 const AVCodecTag *avctag;
3000 enum CodecID id = CODEC_ID_NONE;
3001 unsigned int tag = 0;
3004 * Check that tag + id is in the table
3005 * If neither is in the table -> OK
3006 * If tag is in the table with another id -> FAIL
3007 * If id is in the table with another tag -> FAIL unless strict < normal
3009 for (n = 0; s->oformat->codec_tag[n]; n++) {
3010 avctag = s->oformat->codec_tag[n];
3011 while (avctag->id != CODEC_ID_NONE) {
3012 if (avpriv_toupper4(avctag->tag) == avpriv_toupper4(st->codec->codec_tag)) {
3014 if (id == st->codec->codec_id)
3017 if (avctag->id == st->codec->codec_id)
3022 if (id != CODEC_ID_NONE)
3024 if (tag && (st->codec->strict_std_compliance >= FF_COMPLIANCE_NORMAL))
3029 #if FF_API_FORMAT_PARAMETERS
3030 int av_write_header(AVFormatContext *s)
3032 return avformat_write_header(s, NULL);
3036 int avformat_write_header(AVFormatContext *s, AVDictionary **options)
3040 AVDictionary *tmp = NULL;
3043 av_dict_copy(&tmp, *options, 0);
3044 if ((ret = av_opt_set_dict(s, &tmp)) < 0)
3046 if (s->priv_data && s->oformat->priv_class && *(const AVClass**)s->priv_data==s->oformat->priv_class &&
3047 (ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
3050 // some sanity checks
3051 if (s->nb_streams == 0 && !(s->oformat->flags & AVFMT_NOSTREAMS)) {
3052 av_log(s, AV_LOG_ERROR, "no streams\n");
3053 ret = AVERROR(EINVAL);
3057 for(i=0;i<s->nb_streams;i++) {
3060 switch (st->codec->codec_type) {
3061 case AVMEDIA_TYPE_AUDIO:
3062 if(st->codec->sample_rate<=0){
3063 av_log(s, AV_LOG_ERROR, "sample rate not set\n");
3064 ret = AVERROR(EINVAL);
3067 if(!st->codec->block_align)
3068 st->codec->block_align = st->codec->channels *
3069 av_get_bits_per_sample(st->codec->codec_id) >> 3;
3071 case AVMEDIA_TYPE_VIDEO:
3072 if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
3073 av_log(s, AV_LOG_ERROR, "time base not set\n");
3074 ret = AVERROR(EINVAL);
3077 if((st->codec->width<=0 || st->codec->height<=0) && !(s->oformat->flags & AVFMT_NODIMENSIONS)){
3078 av_log(s, AV_LOG_ERROR, "dimensions not set\n");
3079 ret = AVERROR(EINVAL);
3082 if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)
3083 && FFABS(av_q2d(st->sample_aspect_ratio) - av_q2d(st->codec->sample_aspect_ratio)) > 0.004*av_q2d(st->sample_aspect_ratio)
3085 av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between encoder and muxer layer\n");
3086 ret = AVERROR(EINVAL);
3092 if(s->oformat->codec_tag){
3093 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)){
3094 //the current rawvideo encoding system ends up setting the wrong codec_tag for avi, we override it here
3095 st->codec->codec_tag= 0;
3097 if(st->codec->codec_tag){
3098 if (!validate_codec_tag(s, st)) {
3100 av_get_codec_tag_string(tagbuf, sizeof(tagbuf), st->codec->codec_tag);
3101 av_log(s, AV_LOG_ERROR,
3102 "Tag %s/0x%08x incompatible with output codec id '%d'\n",
3103 tagbuf, st->codec->codec_tag, st->codec->codec_id);
3104 ret = AVERROR_INVALIDDATA;
3108 st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
3111 if(s->oformat->flags & AVFMT_GLOBALHEADER &&
3112 !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
3113 av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
3116 if (!s->priv_data && s->oformat->priv_data_size > 0) {
3117 s->priv_data = av_mallocz(s->oformat->priv_data_size);
3118 if (!s->priv_data) {
3119 ret = AVERROR(ENOMEM);
3122 if (s->oformat->priv_class) {
3123 *(const AVClass**)s->priv_data= s->oformat->priv_class;
3124 av_opt_set_defaults(s->priv_data);
3125 if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
3130 /* set muxer identification string */
3131 if (s->nb_streams && !(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
3132 av_dict_set(&s->metadata, "encoder", LIBAVFORMAT_IDENT, 0);
3135 if(s->oformat->write_header){
3136 ret = s->oformat->write_header(s);
3141 /* init PTS generation */
3142 for(i=0;i<s->nb_streams;i++) {
3143 int64_t den = AV_NOPTS_VALUE;
3146 switch (st->codec->codec_type) {
3147 case AVMEDIA_TYPE_AUDIO:
3148 den = (int64_t)st->time_base.num * st->codec->sample_rate;
3150 case AVMEDIA_TYPE_VIDEO:
3151 den = (int64_t)st->time_base.num * st->codec->time_base.den;
3156 if (den != AV_NOPTS_VALUE) {
3158 ret = AVERROR_INVALIDDATA;
3161 frac_init(&st->pts, 0, 0, den);
3166 av_dict_free(options);
3175 //FIXME merge with compute_pkt_fields
3176 static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt){
3177 int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
3178 int num, den, frame_size, i;
3180 av_dlog(s, "compute_pkt_fields2: pts:%"PRId64" dts:%"PRId64" cur_dts:%"PRId64" b:%d size:%d st:%d\n",
3181 pkt->pts, pkt->dts, st->cur_dts, delay, pkt->size, pkt->stream_index);
3183 /* duration field */
3184 if (pkt->duration == 0) {
3185 compute_frame_duration(&num, &den, st, NULL, pkt);
3187 pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
3191 if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
3194 //XXX/FIXME this is a temporary hack until all encoders output pts
3195 if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
3197 // pkt->pts= st->cur_dts;
3198 pkt->pts= st->pts.val;
3201 //calculate dts from pts
3202 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
3203 st->pts_buffer[0]= pkt->pts;
3204 for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
3205 st->pts_buffer[i]= pkt->pts + (i-delay-1) * pkt->duration;
3206 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
3207 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
3209 pkt->dts= st->pts_buffer[0];
3212 if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && ((!(s->oformat->flags & AVFMT_TS_NONSTRICT) && st->cur_dts >= pkt->dts) || st->cur_dts > pkt->dts)){
3213 av_log(s, AV_LOG_ERROR,
3214 "Application provided invalid, non monotonically increasing dts to muxer in stream %d: %"PRId64" >= %"PRId64"\n",
3215 st->index, st->cur_dts, pkt->dts);
3216 return AVERROR(EINVAL);
3218 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
3219 av_log(s, AV_LOG_ERROR, "pts < dts in stream %d\n", st->index);
3220 return AVERROR(EINVAL);
3223 // av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
3224 st->cur_dts= pkt->dts;
3225 st->pts.val= pkt->dts;
3228 switch (st->codec->codec_type) {
3229 case AVMEDIA_TYPE_AUDIO:
3230 frame_size = get_audio_frame_size(st->codec, pkt->size);
3232 /* HACK/FIXME, we skip the initial 0 size packets as they are most
3233 likely equal to the encoder delay, but it would be better if we
3234 had the real timestamps from the encoder */
3235 if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
3236 frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
3239 case AVMEDIA_TYPE_VIDEO:
3240 frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
3248 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
3250 int ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt);
3252 if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3255 ret= s->oformat->write_packet(s, pkt);
3258 s->streams[pkt->stream_index]->nb_frames++;
3262 int ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
3263 int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
3265 AVPacketList **next_point, *this_pktl;
3267 this_pktl = av_mallocz(sizeof(AVPacketList));
3269 return AVERROR(ENOMEM);
3270 this_pktl->pkt= *pkt;
3271 pkt->destruct= NULL; // do not free original but only the copy
3272 av_dup_packet(&this_pktl->pkt); // duplicate the packet if it uses non-alloced memory
3274 if(s->streams[pkt->stream_index]->last_in_packet_buffer){
3275 next_point = &(s->streams[pkt->stream_index]->last_in_packet_buffer->next);
3277 next_point = &s->packet_buffer;
3280 if(compare(s, &s->packet_buffer_end->pkt, pkt)){
3281 while(!compare(s, &(*next_point)->pkt, pkt)){
3282 next_point= &(*next_point)->next;
3286 next_point = &(s->packet_buffer_end->next);
3289 assert(!*next_point);
3291 s->packet_buffer_end= this_pktl;
3294 this_pktl->next= *next_point;
3296 s->streams[pkt->stream_index]->last_in_packet_buffer=
3297 *next_point= this_pktl;
3301 static int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
3303 AVStream *st = s->streams[ pkt ->stream_index];
3304 AVStream *st2= s->streams[ next->stream_index];
3305 int comp = av_compare_ts(next->dts, st2->time_base, pkt->dts,
3309 return pkt->stream_index < next->stream_index;
3313 int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
3315 int stream_count=0, noninterleaved_count=0;
3316 int64_t delta_dts_max = 0;
3320 ret = ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
3325 for(i=0; i < s->nb_streams; i++) {
3326 if (s->streams[i]->last_in_packet_buffer) {
3328 } else if(s->streams[i]->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3329 ++noninterleaved_count;
3333 if (s->nb_streams == stream_count) {
3336 for(i=0; i < s->nb_streams; i++) {
3337 if (s->streams[i]->last_in_packet_buffer) {
3339 av_rescale_q(s->streams[i]->last_in_packet_buffer->pkt.dts,
3340 s->streams[i]->time_base,
3342 av_rescale_q(s->packet_buffer->pkt.dts,
3343 s->streams[s->packet_buffer->pkt.stream_index]->time_base,
3345 delta_dts_max= FFMAX(delta_dts_max, delta_dts);
3348 if(s->nb_streams == stream_count+noninterleaved_count &&
3349 delta_dts_max > 20*AV_TIME_BASE) {
3350 av_log(s, AV_LOG_DEBUG, "flushing with %d noninterleaved\n", noninterleaved_count);
3354 if(stream_count && flush){
3355 pktl= s->packet_buffer;
3358 s->packet_buffer= pktl->next;
3359 if(!s->packet_buffer)
3360 s->packet_buffer_end= NULL;
3362 if(s->streams[out->stream_index]->last_in_packet_buffer == pktl)
3363 s->streams[out->stream_index]->last_in_packet_buffer= NULL;
3367 av_init_packet(out);
3373 * Interleave an AVPacket correctly so it can be muxed.
3374 * @param out the interleaved packet will be output here
3375 * @param in the input packet
3376 * @param flush 1 if no further packets are available as input and all
3377 * remaining packets should be output
3378 * @return 1 if a packet was output, 0 if no packet could be output,
3379 * < 0 if an error occurred
3381 static int interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
3382 if(s->oformat->interleave_packet)
3383 return s->oformat->interleave_packet(s, out, in, flush);
3385 return av_interleave_packet_per_dts(s, out, in, flush);
3388 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
3389 AVStream *st= s->streams[ pkt->stream_index];
3392 //FIXME/XXX/HACK drop zero sized packets
3393 if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO && pkt->size==0)
3396 av_dlog(s, "av_interleaved_write_frame size:%d dts:%"PRId64" pts:%"PRId64"\n",
3397 pkt->size, pkt->dts, pkt->pts);
3398 if((ret = compute_pkt_fields2(s, st, pkt)) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3401 if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3402 return AVERROR(EINVAL);
3406 int ret= interleave_packet(s, &opkt, pkt, 0);
3407 if(ret<=0) //FIXME cleanup needed for ret<0 ?
3410 ret= s->oformat->write_packet(s, &opkt);
3412 s->streams[opkt.stream_index]->nb_frames++;
3414 av_free_packet(&opkt);
3419 if(s->pb && s->pb->error)
3420 return s->pb->error;
3424 int av_write_trailer(AVFormatContext *s)
3430 ret= interleave_packet(s, &pkt, NULL, 1);
3431 if(ret<0) //FIXME cleanup needed for ret<0 ?
3436 ret= s->oformat->write_packet(s, &pkt);
3438 s->streams[pkt.stream_index]->nb_frames++;
3440 av_free_packet(&pkt);
3444 if(s->pb && s->pb->error)
3448 if(s->oformat->write_trailer)
3449 ret = s->oformat->write_trailer(s);
3452 ret = s->pb ? s->pb->error : 0;
3453 for(i=0;i<s->nb_streams;i++) {
3454 av_freep(&s->streams[i]->priv_data);
3455 av_freep(&s->streams[i]->index_entries);
3457 if (s->iformat && s->iformat->priv_class)
3458 av_opt_free(s->priv_data);
3459 av_freep(&s->priv_data);
3463 int av_get_output_timestamp(struct AVFormatContext *s, int stream,
3464 int64_t *dts, int64_t *wall)
3466 if (!s->oformat || !s->oformat->get_output_timestamp)
3467 return AVERROR(ENOSYS);
3468 s->oformat->get_output_timestamp(s, stream, dts, wall);
3472 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
3475 AVProgram *program=NULL;
3478 if (idx >= ac->nb_streams) {
3479 av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3483 for(i=0; i<ac->nb_programs; i++){
3484 if(ac->programs[i]->id != progid)
3486 program = ac->programs[i];
3487 for(j=0; j<program->nb_stream_indexes; j++)
3488 if(program->stream_index[j] == idx)
3491 tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
3494 program->stream_index = tmp;
3495 program->stream_index[program->nb_stream_indexes++] = idx;
3500 static void print_fps(double d, const char *postfix){
3501 uint64_t v= lrintf(d*100);
3502 if (v% 100 ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3503 else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3504 else av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
3507 static void dump_metadata(void *ctx, AVDictionary *m, const char *indent)
3509 if(m && !(m->count == 1 && av_dict_get(m, "language", NULL, 0))){
3510 AVDictionaryEntry *tag=NULL;
3512 av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3513 while((tag=av_dict_get(m, "", tag, AV_DICT_IGNORE_SUFFIX))) {
3514 if(strcmp("language", tag->key)){
3517 av_strlcpy(tmp, tag->value, sizeof(tmp));
3518 for(i=0; i<strlen(tmp); i++) if(tmp[i]==0xd) tmp[i]=' ';
3519 av_log(ctx, AV_LOG_INFO, "%s %-16s: %s\n", indent, tag->key, tmp);
3525 /* "user interface" functions */
3526 static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
3529 int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
3530 AVStream *st = ic->streams[i];
3531 int g = av_gcd(st->time_base.num, st->time_base.den);
3532 AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL, 0);
3533 avcodec_string(buf, sizeof(buf), st->codec, is_output);
3534 av_log(NULL, AV_LOG_INFO, " Stream #%d:%d", index, i);
3535 /* the pid is an important information, so we display it */
3536 /* XXX: add a generic system */
3537 if (flags & AVFMT_SHOW_IDS)
3538 av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
3540 av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
3541 av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames, st->time_base.num/g, st->time_base.den/g);
3542 av_log(NULL, AV_LOG_INFO, ": %s", buf);
3543 if (st->sample_aspect_ratio.num && // default
3544 av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
3545 AVRational display_aspect_ratio;
3546 av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
3547 st->codec->width*st->sample_aspect_ratio.num,
3548 st->codec->height*st->sample_aspect_ratio.den,
3550 av_log(NULL, AV_LOG_INFO, ", SAR %d:%d DAR %d:%d",
3551 st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3552 display_aspect_ratio.num, display_aspect_ratio.den);
3554 if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
3555 if(st->avg_frame_rate.den && st->avg_frame_rate.num)
3556 print_fps(av_q2d(st->avg_frame_rate), "fps");
3557 if(st->r_frame_rate.den && st->r_frame_rate.num)
3558 print_fps(av_q2d(st->r_frame_rate), "tbr");
3559 if(st->time_base.den && st->time_base.num)
3560 print_fps(1/av_q2d(st->time_base), "tbn");
3561 if(st->codec->time_base.den && st->codec->time_base.num)
3562 print_fps(1/av_q2d(st->codec->time_base), "tbc");
3564 if (st->disposition & AV_DISPOSITION_DEFAULT)
3565 av_log(NULL, AV_LOG_INFO, " (default)");
3566 if (st->disposition & AV_DISPOSITION_DUB)
3567 av_log(NULL, AV_LOG_INFO, " (dub)");
3568 if (st->disposition & AV_DISPOSITION_ORIGINAL)
3569 av_log(NULL, AV_LOG_INFO, " (original)");
3570 if (st->disposition & AV_DISPOSITION_COMMENT)
3571 av_log(NULL, AV_LOG_INFO, " (comment)");
3572 if (st->disposition & AV_DISPOSITION_LYRICS)
3573 av_log(NULL, AV_LOG_INFO, " (lyrics)");
3574 if (st->disposition & AV_DISPOSITION_KARAOKE)
3575 av_log(NULL, AV_LOG_INFO, " (karaoke)");
3576 if (st->disposition & AV_DISPOSITION_FORCED)
3577 av_log(NULL, AV_LOG_INFO, " (forced)");
3578 if (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED)
3579 av_log(NULL, AV_LOG_INFO, " (hearing impaired)");
3580 if (st->disposition & AV_DISPOSITION_VISUAL_IMPAIRED)
3581 av_log(NULL, AV_LOG_INFO, " (visual impaired)");
3582 if (st->disposition & AV_DISPOSITION_CLEAN_EFFECTS)
3583 av_log(NULL, AV_LOG_INFO, " (clean effects)");
3584 av_log(NULL, AV_LOG_INFO, "\n");
3585 dump_metadata(NULL, st->metadata, " ");
3588 #if FF_API_DUMP_FORMAT
3589 void dump_format(AVFormatContext *ic,
3594 av_dump_format(ic, index, url, is_output);
3598 void av_dump_format(AVFormatContext *ic,
3604 uint8_t *printed = ic->nb_streams ? av_mallocz(ic->nb_streams) : NULL;
3605 if (ic->nb_streams && !printed)
3608 av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3609 is_output ? "Output" : "Input",
3611 is_output ? ic->oformat->name : ic->iformat->name,
3612 is_output ? "to" : "from", url);
3613 dump_metadata(NULL, ic->metadata, " ");
3615 av_log(NULL, AV_LOG_INFO, " Duration: ");
3616 if (ic->duration != AV_NOPTS_VALUE) {
3617 int hours, mins, secs, us;
3618 secs = ic->duration / AV_TIME_BASE;
3619 us = ic->duration % AV_TIME_BASE;
3624 av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3625 (100 * us) / AV_TIME_BASE);
3627 av_log(NULL, AV_LOG_INFO, "N/A");
3629 if (ic->start_time != AV_NOPTS_VALUE) {
3631 av_log(NULL, AV_LOG_INFO, ", start: ");
3632 secs = ic->start_time / AV_TIME_BASE;
3633 us = abs(ic->start_time % AV_TIME_BASE);
3634 av_log(NULL, AV_LOG_INFO, "%d.%06d",
3635 secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
3637 av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3639 av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
3641 av_log(NULL, AV_LOG_INFO, "N/A");
3643 av_log(NULL, AV_LOG_INFO, "\n");
3645 for (i = 0; i < ic->nb_chapters; i++) {
3646 AVChapter *ch = ic->chapters[i];
3647 av_log(NULL, AV_LOG_INFO, " Chapter #%d.%d: ", index, i);
3648 av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
3649 av_log(NULL, AV_LOG_INFO, "end %f\n", ch->end * av_q2d(ch->time_base));
3651 dump_metadata(NULL, ch->metadata, " ");
3653 if(ic->nb_programs) {
3654 int j, k, total = 0;
3655 for(j=0; j<ic->nb_programs; j++) {
3656 AVDictionaryEntry *name = av_dict_get(ic->programs[j]->metadata,
3658 av_log(NULL, AV_LOG_INFO, " Program %d %s\n", ic->programs[j]->id,
3659 name ? name->value : "");
3660 dump_metadata(NULL, ic->programs[j]->metadata, " ");
3661 for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3662 dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3663 printed[ic->programs[j]->stream_index[k]] = 1;
3665 total += ic->programs[j]->nb_stream_indexes;
3667 if (total < ic->nb_streams)
3668 av_log(NULL, AV_LOG_INFO, " No Program\n");
3670 for(i=0;i<ic->nb_streams;i++)
3672 dump_stream_format(ic, i, index, is_output);
3677 int64_t av_gettime(void)
3680 gettimeofday(&tv,NULL);
3681 return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
3684 uint64_t ff_ntp_time(void)
3686 return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3689 #if FF_API_PARSE_DATE
3690 #include "libavutil/parseutils.h"
3692 int64_t parse_date(const char *timestr, int duration)
3695 av_parse_time(&timeval, timestr, duration);
3700 #if FF_API_FIND_INFO_TAG
3701 #include "libavutil/parseutils.h"
3703 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
3705 return av_find_info_tag(arg, arg_size, tag1, info);
3709 int av_get_frame_filename(char *buf, int buf_size,
3710 const char *path, int number)
3713 char *q, buf1[20], c;
3714 int nd, len, percentd_found;
3726 while (isdigit(*p)) {
3727 nd = nd * 10 + *p++ - '0';
3730 } while (isdigit(c));
3739 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3741 if ((q - buf + len) > buf_size - 1)
3743 memcpy(q, buf1, len);
3751 if ((q - buf) < buf_size - 1)
3755 if (!percentd_found)
3764 static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3768 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3770 for(i=0;i<size;i+=16) {
3777 PRINT(" %02x", buf[i+j]);
3782 for(j=0;j<len;j++) {
3784 if (c < ' ' || c > '~')
3793 void av_hex_dump(FILE *f, uint8_t *buf, int size)
3795 hex_dump_internal(NULL, f, 0, buf, size);
3798 void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3800 hex_dump_internal(avcl, NULL, level, buf, size);
3803 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload, AVRational time_base)
3806 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3807 PRINT("stream #%d:\n", pkt->stream_index);
3808 PRINT(" keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
3809 PRINT(" duration=%0.3f\n", pkt->duration * av_q2d(time_base));
3810 /* DTS is _always_ valid after av_read_frame() */
3812 if (pkt->dts == AV_NOPTS_VALUE)
3815 PRINT("%0.3f", pkt->dts * av_q2d(time_base));
3816 /* PTS may not be known if B-frames are present. */
3818 if (pkt->pts == AV_NOPTS_VALUE)
3821 PRINT("%0.3f", pkt->pts * av_q2d(time_base));
3823 PRINT(" size=%d\n", pkt->size);
3826 av_hex_dump(f, pkt->data, pkt->size);
3830 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3832 AVRational tb = { 1, AV_TIME_BASE };
3833 pkt_dump_internal(NULL, f, 0, pkt, dump_payload, tb);
3837 void av_pkt_dump2(FILE *f, AVPacket *pkt, int dump_payload, AVStream *st)
3839 pkt_dump_internal(NULL, f, 0, pkt, dump_payload, st->time_base);
3843 void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3845 AVRational tb = { 1, AV_TIME_BASE };
3846 pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, tb);
3850 void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload,
3853 pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, st->time_base);
3856 void av_url_split(char *proto, int proto_size,
3857 char *authorization, int authorization_size,
3858 char *hostname, int hostname_size,
3860 char *path, int path_size,
3863 const char *p, *ls, *at, *col, *brk;
3865 if (port_ptr) *port_ptr = -1;
3866 if (proto_size > 0) proto[0] = 0;
3867 if (authorization_size > 0) authorization[0] = 0;
3868 if (hostname_size > 0) hostname[0] = 0;
3869 if (path_size > 0) path[0] = 0;
3871 /* parse protocol */
3872 if ((p = strchr(url, ':'))) {
3873 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3878 /* no protocol means plain filename */
3879 av_strlcpy(path, url, path_size);
3883 /* separate path from hostname */
3884 ls = strchr(p, '/');
3886 ls = strchr(p, '?');
3888 av_strlcpy(path, ls, path_size);
3890 ls = &p[strlen(p)]; // XXX
3892 /* the rest is hostname, use that to parse auth/port */
3894 /* authorization (user[:pass]@hostname) */
3895 if ((at = strchr(p, '@')) && at < ls) {
3896 av_strlcpy(authorization, p,
3897 FFMIN(authorization_size, at + 1 - p));
3898 p = at + 1; /* skip '@' */
3901 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3903 av_strlcpy(hostname, p + 1,
3904 FFMIN(hostname_size, brk - p));
3905 if (brk[1] == ':' && port_ptr)
3906 *port_ptr = atoi(brk + 2);
3907 } else if ((col = strchr(p, ':')) && col < ls) {
3908 av_strlcpy(hostname, p,
3909 FFMIN(col + 1 - p, hostname_size));
3910 if (port_ptr) *port_ptr = atoi(col + 1);
3912 av_strlcpy(hostname, p,
3913 FFMIN(ls + 1 - p, hostname_size));
3917 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3920 static const char hex_table_uc[16] = { '0', '1', '2', '3',
3923 'C', 'D', 'E', 'F' };
3924 static const char hex_table_lc[16] = { '0', '1', '2', '3',
3927 'c', 'd', 'e', 'f' };
3928 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3930 for(i = 0; i < s; i++) {
3931 buff[i * 2] = hex_table[src[i] >> 4];
3932 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3938 int ff_hex_to_data(uint8_t *data, const char *p)
3945 p += strspn(p, SPACE_CHARS);
3948 c = toupper((unsigned char) *p++);
3949 if (c >= '0' && c <= '9')
3951 else if (c >= 'A' && c <= 'F')
3966 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3967 unsigned int pts_num, unsigned int pts_den)
3970 if(av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)){
3971 if(new_tb.num != pts_num)
3972 av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/new_tb.num);
3974 av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3976 if(new_tb.num <= 0 || new_tb.den <= 0) {
3977 av_log(NULL, AV_LOG_ERROR, "Ignoring attempt to set invalid timebase for st:%d\n", s->index);
3980 s->time_base = new_tb;
3981 s->pts_wrap_bits = pts_wrap_bits;
3984 int ff_url_join(char *str, int size, const char *proto,
3985 const char *authorization, const char *hostname,
3986 int port, const char *fmt, ...)
3989 struct addrinfo hints, *ai;
3994 av_strlcatf(str, size, "%s://", proto);
3995 if (authorization && authorization[0])
3996 av_strlcatf(str, size, "%s@", authorization);
3997 #if CONFIG_NETWORK && defined(AF_INET6)
3998 /* Determine if hostname is a numerical IPv6 address,
3999 * properly escape it within [] in that case. */
4000 memset(&hints, 0, sizeof(hints));
4001 hints.ai_flags = AI_NUMERICHOST;
4002 if (!getaddrinfo(hostname, NULL, &hints, &ai)) {
4003 if (ai->ai_family == AF_INET6) {
4004 av_strlcat(str, "[", size);
4005 av_strlcat(str, hostname, size);
4006 av_strlcat(str, "]", size);
4008 av_strlcat(str, hostname, size);
4013 /* Not an IPv6 address, just output the plain string. */
4014 av_strlcat(str, hostname, size);
4017 av_strlcatf(str, size, ":%d", port);
4020 int len = strlen(str);
4023 vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);
4029 int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
4030 AVFormatContext *src)
4035 local_pkt.stream_index = dst_stream;
4036 if (pkt->pts != AV_NOPTS_VALUE)
4037 local_pkt.pts = av_rescale_q(pkt->pts,
4038 src->streams[pkt->stream_index]->time_base,
4039 dst->streams[dst_stream]->time_base);
4040 if (pkt->dts != AV_NOPTS_VALUE)
4041 local_pkt.dts = av_rescale_q(pkt->dts,
4042 src->streams[pkt->stream_index]->time_base,
4043 dst->streams[dst_stream]->time_base);
4044 return av_write_frame(dst, &local_pkt);
4047 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
4050 const char *ptr = str;
4052 /* Parse key=value pairs. */
4055 char *dest = NULL, *dest_end;
4056 int key_len, dest_len = 0;
4058 /* Skip whitespace and potential commas. */
4059 while (*ptr && (isspace(*ptr) || *ptr == ','))
4066 if (!(ptr = strchr(key, '=')))
4069 key_len = ptr - key;
4071 callback_get_buf(context, key, key_len, &dest, &dest_len);
4072 dest_end = dest + dest_len - 1;
4076 while (*ptr && *ptr != '\"') {
4080 if (dest && dest < dest_end)
4084 if (dest && dest < dest_end)
4092 for (; *ptr && !(isspace(*ptr) || *ptr == ','); ptr++)
4093 if (dest && dest < dest_end)
4101 int ff_find_stream_index(AVFormatContext *s, int id)
4104 for (i = 0; i < s->nb_streams; i++) {
4105 if (s->streams[i]->id == id)
4111 void ff_make_absolute_url(char *buf, int size, const char *base,
4115 /* Absolute path, relative to the current server */
4116 if (base && strstr(base, "://") && rel[0] == '/') {
4118 av_strlcpy(buf, base, size);
4119 sep = strstr(buf, "://");
4122 sep = strchr(sep, '/');
4126 av_strlcat(buf, rel, size);
4129 /* If rel actually is an absolute url, just copy it */
4130 if (!base || strstr(rel, "://") || rel[0] == '/') {
4131 av_strlcpy(buf, rel, size);
4135 av_strlcpy(buf, base, size);
4136 /* Remove the file name from the base url */
4137 sep = strrchr(buf, '/');
4142 while (av_strstart(rel, "../", NULL) && sep) {
4143 /* Remove the path delimiter at the end */
4145 sep = strrchr(buf, '/');
4146 /* If the next directory name to pop off is "..", break here */
4147 if (!strcmp(sep ? &sep[1] : buf, "..")) {
4148 /* Readd the slash we just removed */
4149 av_strlcat(buf, "/", size);
4152 /* Cut off the directory name */
4159 av_strlcat(buf, rel, size);
4162 int64_t ff_iso8601_to_unix_time(const char *datestr)
4165 struct tm time1 = {0}, time2 = {0};
4167 ret1 = strptime(datestr, "%Y - %m - %d %T", &time1);
4168 ret2 = strptime(datestr, "%Y - %m - %dT%T", &time2);
4170 return av_timegm(&time2);
4172 return av_timegm(&time1);
4174 av_log(NULL, AV_LOG_WARNING, "strptime() unavailable on this system, cannot convert "
4175 "the date string.\n");
4180 int avformat_query_codec(AVOutputFormat *ofmt, enum CodecID codec_id, int std_compliance)
4183 if (ofmt->query_codec)
4184 return ofmt->query_codec(codec_id, std_compliance);
4185 else if (ofmt->codec_tag)
4186 return !!av_codec_get_tag(ofmt->codec_tag, codec_id);
4187 else if (codec_id == ofmt->video_codec || codec_id == ofmt->audio_codec ||
4188 codec_id == ofmt->subtitle_codec)
4191 return AVERROR_PATCHWELCOME;
4194 int avformat_network_init(void)
4198 ff_network_inited_globally = 1;
4199 if ((ret = ff_network_init()) < 0)
4206 int avformat_network_deinit(void)