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
23 #include "libavcodec/internal.h"
24 #include "libavutil/opt.h"
27 #include "libavutil/avstring.h"
29 #include "audiointerleave.h"
43 * various utility functions for use within FFmpeg
46 unsigned avformat_version(void)
48 return LIBAVFORMAT_VERSION_INT;
51 const char *avformat_configuration(void)
53 return FFMPEG_CONFIGURATION;
56 const char *avformat_license(void)
58 #define LICENSE_PREFIX "libavformat license: "
59 return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;
62 /* fraction handling */
65 * f = val + (num / den) + 0.5.
67 * 'num' is normalized so that it is such as 0 <= num < den.
69 * @param f fractional number
70 * @param val integer value
71 * @param num must be >= 0
72 * @param den must be >= 1
74 static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
87 * Fractional addition to f: f = f + (incr / f->den).
89 * @param f fractional number
90 * @param incr increment, can be positive or negative
92 static void av_frac_add(AVFrac *f, int64_t incr)
105 } else if (num >= den) {
112 /** head of registered input format linked list */
113 #if !FF_API_FIRST_FORMAT
116 AVInputFormat *first_iformat = NULL;
117 /** head of registered output format linked list */
118 #if !FF_API_FIRST_FORMAT
121 AVOutputFormat *first_oformat = NULL;
123 AVInputFormat *av_iformat_next(AVInputFormat *f)
125 if(f) return f->next;
126 else return first_iformat;
129 AVOutputFormat *av_oformat_next(AVOutputFormat *f)
131 if(f) return f->next;
132 else return first_oformat;
135 void av_register_input_format(AVInputFormat *format)
139 while (*p != NULL) p = &(*p)->next;
144 void av_register_output_format(AVOutputFormat *format)
148 while (*p != NULL) p = &(*p)->next;
153 int av_match_ext(const char *filename, const char *extensions)
161 ext = strrchr(filename, '.');
167 while (*p != '\0' && *p != ',' && q-ext1<sizeof(ext1)-1)
170 if (!strcasecmp(ext1, ext))
180 static int match_format(const char *name, const char *names)
188 namelen = strlen(name);
189 while ((p = strchr(names, ','))) {
190 len = FFMAX(p - names, namelen);
191 if (!strncasecmp(name, names, len))
195 return !strcasecmp(name, names);
198 #if FF_API_GUESS_FORMAT
199 AVOutputFormat *guess_format(const char *short_name, const char *filename,
200 const char *mime_type)
202 return av_guess_format(short_name, filename, mime_type);
206 AVOutputFormat *av_guess_format(const char *short_name, const char *filename,
207 const char *mime_type)
209 AVOutputFormat *fmt = NULL, *fmt_found;
210 int score_max, score;
212 /* specific test for image sequences */
213 #if CONFIG_IMAGE2_MUXER
214 if (!short_name && filename &&
215 av_filename_number_test(filename) &&
216 av_guess_image2_codec(filename) != CODEC_ID_NONE) {
217 return av_guess_format("image2", NULL, NULL);
220 /* Find the proper file type. */
223 while ((fmt = av_oformat_next(fmt))) {
225 if (fmt->name && short_name && !strcmp(fmt->name, short_name))
227 if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
229 if (filename && fmt->extensions &&
230 av_match_ext(filename, fmt->extensions)) {
233 if (score > score_max) {
241 #if FF_API_GUESS_FORMAT
242 AVOutputFormat *guess_stream_format(const char *short_name, const char *filename,
243 const char *mime_type)
245 AVOutputFormat *fmt = av_guess_format(short_name, filename, mime_type);
248 AVOutputFormat *stream_fmt;
249 char stream_format_name[64];
251 snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
252 stream_fmt = av_guess_format(stream_format_name, NULL, NULL);
262 enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
263 const char *filename, const char *mime_type, enum AVMediaType type){
264 if(type == AVMEDIA_TYPE_VIDEO){
265 enum CodecID codec_id= CODEC_ID_NONE;
267 #if CONFIG_IMAGE2_MUXER
268 if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
269 codec_id= av_guess_image2_codec(filename);
272 if(codec_id == CODEC_ID_NONE)
273 codec_id= fmt->video_codec;
275 }else if(type == AVMEDIA_TYPE_AUDIO)
276 return fmt->audio_codec;
277 else if (type == AVMEDIA_TYPE_SUBTITLE)
278 return fmt->subtitle_codec;
280 return CODEC_ID_NONE;
283 AVInputFormat *av_find_input_format(const char *short_name)
285 AVInputFormat *fmt = NULL;
286 while ((fmt = av_iformat_next(fmt))) {
287 if (match_format(short_name, fmt->name))
293 #if FF_API_SYMVER && CONFIG_SHARED && HAVE_SYMVER
294 FF_SYMVER(void, av_destruct_packet_nofree, (AVPacket *pkt), "LIBAVFORMAT_52")
296 av_destruct_packet_nofree(pkt);
299 FF_SYMVER(void, av_destruct_packet, (AVPacket *pkt), "LIBAVFORMAT_52")
301 av_destruct_packet(pkt);
304 FF_SYMVER(int, av_new_packet, (AVPacket *pkt, int size), "LIBAVFORMAT_52")
306 return av_new_packet(pkt, size);
309 FF_SYMVER(int, av_dup_packet, (AVPacket *pkt), "LIBAVFORMAT_52")
311 return av_dup_packet(pkt);
314 FF_SYMVER(void, av_free_packet, (AVPacket *pkt), "LIBAVFORMAT_52")
319 FF_SYMVER(void, av_init_packet, (AVPacket *pkt), "LIBAVFORMAT_52")
321 av_log(NULL, AV_LOG_WARNING, "Diverting av_*_packet function calls to libavcodec. Recompile to improve performance\n");
326 int av_get_packet(ByteIOContext *s, AVPacket *pkt, int size)
328 int ret= av_new_packet(pkt, size);
333 pkt->pos= url_ftell(s);
335 ret= get_buffer(s, pkt->data, size);
339 av_shrink_packet(pkt, ret);
344 int av_append_packet(ByteIOContext *s, AVPacket *pkt, int size)
349 return av_get_packet(s, pkt, size);
350 old_size = pkt->size;
351 ret = av_grow_packet(pkt, size);
354 ret = get_buffer(s, pkt->data + old_size, size);
355 av_shrink_packet(pkt, old_size + FFMAX(ret, 0));
360 int av_filename_number_test(const char *filename)
363 return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
366 AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
368 AVProbeData lpd = *pd;
369 AVInputFormat *fmt1 = NULL, *fmt;
372 if (lpd.buf_size > 10 && ff_id3v2_match(lpd.buf, ID3v2_DEFAULT_MAGIC)) {
373 int id3len = ff_id3v2_tag_len(lpd.buf);
374 if (lpd.buf_size > id3len + 16) {
376 lpd.buf_size -= id3len;
381 while ((fmt1 = av_iformat_next(fmt1))) {
382 if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
385 if (fmt1->read_probe) {
386 score = fmt1->read_probe(&lpd);
387 } else if (fmt1->extensions) {
388 if (av_match_ext(lpd.filename, fmt1->extensions)) {
392 if (score > *score_max) {
395 }else if (score == *score_max)
401 AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
403 return av_probe_input_format2(pd, is_opened, &score);
406 static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st, AVProbeData *pd, int score)
408 static const struct {
409 const char *name; enum CodecID id; enum AVMediaType type;
411 { "aac" , CODEC_ID_AAC , AVMEDIA_TYPE_AUDIO },
412 { "ac3" , CODEC_ID_AC3 , AVMEDIA_TYPE_AUDIO },
413 { "dts" , CODEC_ID_DTS , AVMEDIA_TYPE_AUDIO },
414 { "eac3" , CODEC_ID_EAC3 , AVMEDIA_TYPE_AUDIO },
415 { "h264" , CODEC_ID_H264 , AVMEDIA_TYPE_VIDEO },
416 { "m4v" , CODEC_ID_MPEG4 , AVMEDIA_TYPE_VIDEO },
417 { "mp3" , CODEC_ID_MP3 , AVMEDIA_TYPE_AUDIO },
418 { "mpegvideo", CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
421 AVInputFormat *fmt = av_probe_input_format2(pd, 1, &score);
425 av_log(s, AV_LOG_DEBUG, "Probe with size=%d, packets=%d detected %s with score=%d\n",
426 pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets, fmt->name, score);
427 for (i = 0; fmt_id_type[i].name; i++) {
428 if (!strcmp(fmt->name, fmt_id_type[i].name)) {
429 st->codec->codec_id = fmt_id_type[i].id;
430 st->codec->codec_type = fmt_id_type[i].type;
438 /************************************************************/
439 /* input media file */
442 * Open a media file from an IO stream. 'fmt' must be specified.
444 int av_open_input_stream(AVFormatContext **ic_ptr,
445 ByteIOContext *pb, const char *filename,
446 AVInputFormat *fmt, AVFormatParameters *ap)
450 AVFormatParameters default_ap;
454 memset(ap, 0, sizeof(default_ap));
457 if(!ap->prealloced_context)
458 ic = avformat_alloc_context();
462 err = AVERROR(ENOMEM);
467 ic->duration = AV_NOPTS_VALUE;
468 ic->start_time = AV_NOPTS_VALUE;
469 av_strlcpy(ic->filename, filename, sizeof(ic->filename));
471 /* allocate private data */
472 if (fmt->priv_data_size > 0) {
473 ic->priv_data = av_mallocz(fmt->priv_data_size);
474 if (!ic->priv_data) {
475 err = AVERROR(ENOMEM);
479 ic->priv_data = NULL;
482 // e.g. AVFMT_NOFILE formats will not have a ByteIOContext
484 ff_id3v2_read(ic, ID3v2_DEFAULT_MAGIC);
486 if (ic->iformat->read_header) {
487 err = ic->iformat->read_header(ic, ap);
492 if (pb && !ic->data_offset)
493 ic->data_offset = url_ftell(ic->pb);
495 #if FF_API_OLD_METADATA
496 ff_metadata_demux_compat(ic);
499 ic->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
506 av_freep(&ic->priv_data);
507 for(i=0;i<ic->nb_streams;i++) {
508 AVStream *st = ic->streams[i];
510 av_free(st->priv_data);
511 av_free(st->codec->extradata);
523 /** size of probe buffer, for guessing file type from file contents */
524 #define PROBE_BUF_MIN 2048
525 #define PROBE_BUF_MAX (1<<20)
527 int av_probe_input_buffer(ByteIOContext *pb, AVInputFormat **fmt,
528 const char *filename, void *logctx,
529 unsigned int offset, unsigned int max_probe_size)
531 AVProbeData pd = { filename ? filename : "", NULL, -offset };
532 unsigned char *buf = NULL;
533 int ret = 0, probe_size;
535 if (!max_probe_size) {
536 max_probe_size = PROBE_BUF_MAX;
537 } else if (max_probe_size > PROBE_BUF_MAX) {
538 max_probe_size = PROBE_BUF_MAX;
539 } else if (max_probe_size < PROBE_BUF_MIN) {
540 return AVERROR(EINVAL);
543 if (offset >= max_probe_size) {
544 return AVERROR(EINVAL);
547 for(probe_size= PROBE_BUF_MIN; probe_size<=max_probe_size && !*fmt && ret >= 0;
548 probe_size = FFMIN(probe_size<<1, FFMAX(max_probe_size, probe_size+1))) {
549 int ret, score = probe_size < max_probe_size ? AVPROBE_SCORE_MAX/4 : 0;
550 int buf_offset = (probe_size == PROBE_BUF_MIN) ? 0 : probe_size>>1;
552 if (probe_size < offset) {
556 /* read probe data */
557 buf = av_realloc(buf, probe_size + AVPROBE_PADDING_SIZE);
558 if ((ret = get_buffer(pb, buf + buf_offset, probe_size - buf_offset)) < 0) {
559 /* fail if error was not end of file, otherwise, lower score */
560 if (ret != AVERROR_EOF) {
565 ret = 0; /* error was end of file, nothing read */
568 pd.buf = &buf[offset];
570 memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE);
572 /* guess file format */
573 *fmt = av_probe_input_format2(&pd, 1, &score);
575 if(score <= AVPROBE_SCORE_MAX/4){ //this can only be true in the last iteration
576 av_log(logctx, AV_LOG_WARNING, "Format detected only with low score of %d, misdetection possible!\n", score);
578 av_log(logctx, AV_LOG_DEBUG, "Probed with size=%d and score=%d\n", probe_size, score);
584 return AVERROR_INVALIDDATA;
587 /* rewind. reuse probe buffer to avoid seeking */
588 if ((ret = ff_rewind_with_probe_data(pb, buf, pd.buf_size)) < 0)
594 int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
597 AVFormatParameters *ap)
600 AVProbeData probe_data, *pd = &probe_data;
601 ByteIOContext *pb = NULL;
602 void *logctx= ap && ap->prealloced_context ? *ic_ptr : NULL;
606 pd->filename = filename;
611 /* guess format if no file can be opened */
612 fmt = av_probe_input_format(pd, 0);
615 /* Do not open file if the format does not need it. XXX: specific
616 hack needed to handle RTSP/TCP */
617 if (!fmt || !(fmt->flags & AVFMT_NOFILE)) {
618 /* if no file needed do not try to open one */
619 if ((err=url_fopen(&pb, filename, URL_RDONLY)) < 0) {
623 url_setbufsize(pb, buf_size);
625 if (!fmt && (err = av_probe_input_buffer(pb, &fmt, filename, logctx, 0, logctx ? (*ic_ptr)->probesize : 0)) < 0) {
630 /* if still no format found, error */
632 err = AVERROR_INVALIDDATA;
636 /* check filename in case an image number is expected */
637 if (fmt->flags & AVFMT_NEEDNUMBER) {
638 if (!av_filename_number_test(filename)) {
639 err = AVERROR_NUMEXPECTED;
643 err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
651 if (ap && ap->prealloced_context)
658 /*******************************************************/
660 static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
661 AVPacketList **plast_pktl){
662 AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
667 (*plast_pktl)->next = pktl;
669 *packet_buffer = pktl;
671 /* add the packet in the buffered packet list */
677 int av_read_packet(AVFormatContext *s, AVPacket *pkt)
683 AVPacketList *pktl = s->raw_packet_buffer;
687 if(s->streams[pkt->stream_index]->codec->codec_id != CODEC_ID_PROBE ||
688 !s->streams[pkt->stream_index]->probe_packets ||
689 s->raw_packet_buffer_remaining_size < pkt->size){
690 AVProbeData *pd = &s->streams[pkt->stream_index]->probe_data;
693 s->raw_packet_buffer = pktl->next;
694 s->raw_packet_buffer_remaining_size += pkt->size;
701 ret= s->iformat->read_packet(s, pkt);
703 if (!pktl || ret == AVERROR(EAGAIN))
705 for (i = 0; i < s->nb_streams; i++)
706 s->streams[i]->probe_packets = 0;
709 st= s->streams[pkt->stream_index];
711 switch(st->codec->codec_type){
712 case AVMEDIA_TYPE_VIDEO:
713 if(s->video_codec_id) st->codec->codec_id= s->video_codec_id;
715 case AVMEDIA_TYPE_AUDIO:
716 if(s->audio_codec_id) st->codec->codec_id= s->audio_codec_id;
718 case AVMEDIA_TYPE_SUBTITLE:
719 if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
723 if(!pktl && (st->codec->codec_id != CODEC_ID_PROBE ||
727 add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
728 s->raw_packet_buffer_remaining_size -= pkt->size;
730 if(st->codec->codec_id == CODEC_ID_PROBE){
731 AVProbeData *pd = &st->probe_data;
732 av_log(s, AV_LOG_DEBUG, "probing stream %d\n", st->index);
735 pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
736 memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
737 pd->buf_size += pkt->size;
738 memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
740 if(av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)){
741 //FIXME we dont reduce score to 0 for the case of running out of buffer space in bytes
742 set_codec_from_probe_data(s, st, pd, st->probe_packets > 0 ? AVPROBE_SCORE_MAX/4 : 0);
743 if(st->codec->codec_id != CODEC_ID_PROBE){
746 av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
753 /**********************************************************/
756 * Get the number of samples of an audio frame. Return -1 on error.
758 static int get_audio_frame_size(AVCodecContext *enc, int size)
762 if(enc->codec_id == CODEC_ID_VORBIS)
765 if (enc->frame_size <= 1) {
766 int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
768 if (bits_per_sample) {
769 if (enc->channels == 0)
771 frame_size = (size << 3) / (bits_per_sample * enc->channels);
773 /* used for example by ADPCM codecs */
774 if (enc->bit_rate == 0)
776 frame_size = ((int64_t)size * 8 * enc->sample_rate) / enc->bit_rate;
779 frame_size = enc->frame_size;
786 * Return the frame duration in seconds. Return 0 if not available.
788 static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
789 AVCodecParserContext *pc, AVPacket *pkt)
795 switch(st->codec->codec_type) {
796 case AVMEDIA_TYPE_VIDEO:
797 if(st->time_base.num*1000LL > st->time_base.den){
798 *pnum = st->time_base.num;
799 *pden = st->time_base.den;
800 }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
801 *pnum = st->codec->time_base.num;
802 *pden = st->codec->time_base.den;
803 if (pc && pc->repeat_pict) {
804 *pnum = (*pnum) * (1 + pc->repeat_pict);
806 //If this codec can be interlaced or progressive then we need a parser to compute duration of a packet
807 //Thus if we have no parser in such case leave duration undefined.
808 if(st->codec->ticks_per_frame>1 && !pc){
813 case AVMEDIA_TYPE_AUDIO:
814 frame_size = get_audio_frame_size(st->codec, pkt->size);
815 if (frame_size <= 0 || st->codec->sample_rate <= 0)
818 *pden = st->codec->sample_rate;
825 static int is_intra_only(AVCodecContext *enc){
826 if(enc->codec_type == AVMEDIA_TYPE_AUDIO){
828 }else if(enc->codec_type == AVMEDIA_TYPE_VIDEO){
829 switch(enc->codec_id){
831 case CODEC_ID_MJPEGB:
833 case CODEC_ID_RAWVIDEO:
834 case CODEC_ID_DVVIDEO:
835 case CODEC_ID_HUFFYUV:
836 case CODEC_ID_FFVHUFF:
841 case CODEC_ID_JPEG2000:
849 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
850 int64_t dts, int64_t pts)
852 AVStream *st= s->streams[stream_index];
853 AVPacketList *pktl= s->packet_buffer;
855 if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE)
858 st->first_dts= dts - st->cur_dts;
861 for(; pktl; pktl= pktl->next){
862 if(pktl->pkt.stream_index != stream_index)
864 //FIXME think more about this check
865 if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
866 pktl->pkt.pts += st->first_dts;
868 if(pktl->pkt.dts != AV_NOPTS_VALUE)
869 pktl->pkt.dts += st->first_dts;
871 if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
872 st->start_time= pktl->pkt.pts;
874 if (st->start_time == AV_NOPTS_VALUE)
875 st->start_time = pts;
878 static void update_initial_durations(AVFormatContext *s, AVStream *st, AVPacket *pkt)
880 AVPacketList *pktl= s->packet_buffer;
883 if(st->first_dts != AV_NOPTS_VALUE){
884 cur_dts= st->first_dts;
885 for(; pktl; pktl= pktl->next){
886 if(pktl->pkt.stream_index == pkt->stream_index){
887 if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
889 cur_dts -= pkt->duration;
892 pktl= s->packet_buffer;
893 st->first_dts = cur_dts;
894 }else if(st->cur_dts)
897 for(; pktl; pktl= pktl->next){
898 if(pktl->pkt.stream_index != pkt->stream_index)
900 if(pktl->pkt.pts == pktl->pkt.dts && pktl->pkt.dts == AV_NOPTS_VALUE
901 && !pktl->pkt.duration){
902 pktl->pkt.dts= cur_dts;
903 if(!st->codec->has_b_frames)
904 pktl->pkt.pts= cur_dts;
905 cur_dts += pkt->duration;
906 pktl->pkt.duration= pkt->duration;
910 if(st->first_dts == AV_NOPTS_VALUE)
911 st->cur_dts= cur_dts;
914 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
915 AVCodecParserContext *pc, AVPacket *pkt)
917 int num, den, presentation_delayed, delay, i;
920 if (s->flags & AVFMT_FLAG_NOFILLIN)
923 if((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
924 pkt->dts= AV_NOPTS_VALUE;
926 if (st->codec->codec_id != CODEC_ID_H264 && pc && pc->pict_type == FF_B_TYPE)
927 //FIXME Set low_delay = 0 when has_b_frames = 1
928 st->codec->has_b_frames = 1;
930 /* do we have a video B-frame ? */
931 delay= st->codec->has_b_frames;
932 presentation_delayed = 0;
934 // ignore delay caused by frame threading so that the mpeg2-without-dts
935 // warning will not trigger
936 if (delay && st->codec->active_thread_type&FF_THREAD_FRAME)
937 delay -= st->codec->thread_count-1;
939 /* XXX: need has_b_frame, but cannot get it if the codec is
942 pc && pc->pict_type != FF_B_TYPE)
943 presentation_delayed = 1;
945 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
946 /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
947 pkt->dts -= 1LL<<st->pts_wrap_bits;
950 // some mpeg2 in mpeg-ps lack dts (issue171 / input_file.mpg)
951 // we take the conservative approach and discard both
952 // Note, if this is misbehaving for a H.264 file then possibly presentation_delayed is not set correctly.
953 if(delay==1 && pkt->dts == pkt->pts && pkt->dts != AV_NOPTS_VALUE && presentation_delayed){
954 av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination\n");
955 pkt->dts= pkt->pts= AV_NOPTS_VALUE;
958 if (pkt->duration == 0) {
959 compute_frame_duration(&num, &den, st, pc, pkt);
961 pkt->duration = av_rescale_rnd(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num, AV_ROUND_DOWN);
963 if(pkt->duration != 0 && s->packet_buffer)
964 update_initial_durations(s, st, pkt);
968 /* correct timestamps with byte offset if demuxers only have timestamps
969 on packet boundaries */
970 if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
971 /* this will estimate bitrate based on this frame's duration and size */
972 offset = av_rescale(pc->offset, pkt->duration, pkt->size);
973 if(pkt->pts != AV_NOPTS_VALUE)
975 if(pkt->dts != AV_NOPTS_VALUE)
979 if (pc && pc->dts_sync_point >= 0) {
980 // we have synchronization info from the parser
981 int64_t den = st->codec->time_base.den * (int64_t) st->time_base.num;
983 int64_t num = st->codec->time_base.num * (int64_t) st->time_base.den;
984 if (pkt->dts != AV_NOPTS_VALUE) {
985 // got DTS from the stream, update reference timestamp
986 st->reference_dts = pkt->dts - pc->dts_ref_dts_delta * num / den;
987 pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
988 } else if (st->reference_dts != AV_NOPTS_VALUE) {
989 // compute DTS based on reference timestamp
990 pkt->dts = st->reference_dts + pc->dts_ref_dts_delta * num / den;
991 pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
993 if (pc->dts_sync_point > 0)
994 st->reference_dts = pkt->dts; // new reference
998 /* This may be redundant, but it should not hurt. */
999 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
1000 presentation_delayed = 1;
1002 // 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);
1003 /* interpolate PTS and DTS if they are not present */
1004 //We skip H264 currently because delay and has_b_frames are not reliably set
1005 if((delay==0 || (delay==1 && pc)) && st->codec->codec_id != CODEC_ID_H264){
1006 if (presentation_delayed) {
1007 /* DTS = decompression timestamp */
1008 /* PTS = presentation timestamp */
1009 if (pkt->dts == AV_NOPTS_VALUE)
1010 pkt->dts = st->last_IP_pts;
1011 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
1012 if (pkt->dts == AV_NOPTS_VALUE)
1013 pkt->dts = st->cur_dts;
1015 /* this is tricky: the dts must be incremented by the duration
1016 of the frame we are displaying, i.e. the last I- or P-frame */
1017 if (st->last_IP_duration == 0)
1018 st->last_IP_duration = pkt->duration;
1019 if(pkt->dts != AV_NOPTS_VALUE)
1020 st->cur_dts = pkt->dts + st->last_IP_duration;
1021 st->last_IP_duration = pkt->duration;
1022 st->last_IP_pts= pkt->pts;
1023 /* cannot compute PTS if not present (we can compute it only
1024 by knowing the future */
1025 } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
1026 if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
1027 int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
1028 int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
1029 if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
1030 pkt->pts += pkt->duration;
1031 // 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);
1035 /* presentation is not delayed : PTS and DTS are the same */
1036 if(pkt->pts == AV_NOPTS_VALUE)
1037 pkt->pts = pkt->dts;
1038 update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
1039 if(pkt->pts == AV_NOPTS_VALUE)
1040 pkt->pts = st->cur_dts;
1041 pkt->dts = pkt->pts;
1042 if(pkt->pts != AV_NOPTS_VALUE)
1043 st->cur_dts = pkt->pts + pkt->duration;
1047 if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
1048 st->pts_buffer[0]= pkt->pts;
1049 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
1050 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
1051 if(pkt->dts == AV_NOPTS_VALUE)
1052 pkt->dts= st->pts_buffer[0];
1053 if(st->codec->codec_id == CODEC_ID_H264){ //we skiped it above so we try here
1054 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
1056 if(pkt->dts > st->cur_dts)
1057 st->cur_dts = pkt->dts;
1060 // 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);
1063 if(is_intra_only(st->codec))
1064 pkt->flags |= AV_PKT_FLAG_KEY;
1067 /* keyframe computation */
1068 if (pc->key_frame == 1)
1069 pkt->flags |= AV_PKT_FLAG_KEY;
1070 else if (pc->key_frame == -1 && pc->pict_type == FF_I_TYPE)
1071 pkt->flags |= AV_PKT_FLAG_KEY;
1074 pkt->convergence_duration = pc->convergence_duration;
1078 static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1083 av_init_packet(pkt);
1086 /* select current input stream component */
1089 if (!st->need_parsing || !st->parser) {
1090 /* no parsing needed: we just output the packet as is */
1091 /* raw data support */
1092 *pkt = st->cur_pkt; st->cur_pkt.data= NULL;
1093 compute_pkt_fields(s, st, NULL, pkt);
1095 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1096 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1097 ff_reduce_index(s, st->index);
1098 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1101 } else if (st->cur_len > 0 && st->discard < AVDISCARD_ALL) {
1102 len = av_parser_parse2(st->parser, st->codec, &pkt->data, &pkt->size,
1103 st->cur_ptr, st->cur_len,
1104 st->cur_pkt.pts, st->cur_pkt.dts,
1106 st->cur_pkt.pts = AV_NOPTS_VALUE;
1107 st->cur_pkt.dts = AV_NOPTS_VALUE;
1108 /* increment read pointer */
1112 /* return packet if any */
1116 pkt->stream_index = st->index;
1117 pkt->pts = st->parser->pts;
1118 pkt->dts = st->parser->dts;
1119 pkt->pos = st->parser->pos;
1120 if(pkt->data == st->cur_pkt.data && pkt->size == st->cur_pkt.size){
1122 pkt->destruct= st->cur_pkt.destruct;
1123 st->cur_pkt.destruct= NULL;
1124 st->cur_pkt.data = NULL;
1125 assert(st->cur_len == 0);
1127 pkt->destruct = NULL;
1129 compute_pkt_fields(s, st, st->parser, pkt);
1131 if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY){
1132 ff_reduce_index(s, st->index);
1133 av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
1134 0, 0, AVINDEX_KEYFRAME);
1141 av_free_packet(&st->cur_pkt);
1146 /* read next packet */
1147 ret = av_read_packet(s, &cur_pkt);
1149 if (ret == AVERROR(EAGAIN))
1151 /* return the last frames, if any */
1152 for(i = 0; i < s->nb_streams; i++) {
1154 if (st->parser && st->need_parsing) {
1155 av_parser_parse2(st->parser, st->codec,
1156 &pkt->data, &pkt->size,
1158 AV_NOPTS_VALUE, AV_NOPTS_VALUE,
1164 /* no more packets: really terminate parsing */
1167 st = s->streams[cur_pkt.stream_index];
1168 st->cur_pkt= cur_pkt;
1170 if(st->cur_pkt.pts != AV_NOPTS_VALUE &&
1171 st->cur_pkt.dts != AV_NOPTS_VALUE &&
1172 st->cur_pkt.pts < st->cur_pkt.dts){
1173 av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
1174 st->cur_pkt.stream_index,
1178 // av_free_packet(&st->cur_pkt);
1182 if(s->debug & FF_FDEBUG_TS)
1183 av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1184 st->cur_pkt.stream_index,
1188 st->cur_pkt.duration,
1192 st->cur_ptr = st->cur_pkt.data;
1193 st->cur_len = st->cur_pkt.size;
1194 if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1195 st->parser = av_parser_init(st->codec->codec_id);
1197 /* no parser available: just output the raw packets */
1198 st->need_parsing = AVSTREAM_PARSE_NONE;
1199 }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
1200 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1201 }else if(st->need_parsing == AVSTREAM_PARSE_FULL_ONCE){
1202 st->parser->flags |= PARSER_FLAG_ONCE;
1207 if(s->debug & FF_FDEBUG_TS)
1208 av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1219 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1223 const int genpts= s->flags & AVFMT_FLAG_GENPTS;
1226 pktl = s->packet_buffer;
1228 AVPacket *next_pkt= &pktl->pkt;
1230 if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
1231 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1232 while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
1233 if( pktl->pkt.stream_index == next_pkt->stream_index
1234 && (0 > av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)))
1235 && av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) { //not b frame
1236 next_pkt->pts= pktl->pkt.dts;
1240 pktl = s->packet_buffer;
1243 if( next_pkt->pts != AV_NOPTS_VALUE
1244 || next_pkt->dts == AV_NOPTS_VALUE
1246 /* read packet from packet buffer, if there is data */
1248 s->packet_buffer = pktl->next;
1254 int ret= av_read_frame_internal(s, pkt);
1256 if(pktl && ret != AVERROR(EAGAIN)){
1263 if(av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1264 &s->packet_buffer_end)) < 0)
1265 return AVERROR(ENOMEM);
1267 assert(!s->packet_buffer);
1268 return av_read_frame_internal(s, pkt);
1273 /* XXX: suppress the packet queue */
1274 static void flush_packet_queue(AVFormatContext *s)
1279 pktl = s->packet_buffer;
1282 s->packet_buffer = pktl->next;
1283 av_free_packet(&pktl->pkt);
1286 while(s->raw_packet_buffer){
1287 pktl = s->raw_packet_buffer;
1288 s->raw_packet_buffer = pktl->next;
1289 av_free_packet(&pktl->pkt);
1292 s->packet_buffer_end=
1293 s->raw_packet_buffer_end= NULL;
1294 s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1297 /*******************************************************/
1300 int av_find_default_stream_index(AVFormatContext *s)
1302 int first_audio_index = -1;
1306 if (s->nb_streams <= 0)
1308 for(i = 0; i < s->nb_streams; i++) {
1310 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1313 if (first_audio_index < 0 && st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1314 first_audio_index = i;
1316 return first_audio_index >= 0 ? first_audio_index : 0;
1320 * Flush the frame reader.
1322 void ff_read_frame_flush(AVFormatContext *s)
1327 flush_packet_queue(s);
1331 /* for each stream, reset read state */
1332 for(i = 0; i < s->nb_streams; i++) {
1336 av_parser_close(st->parser);
1338 av_free_packet(&st->cur_pkt);
1340 st->last_IP_pts = AV_NOPTS_VALUE;
1341 st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1342 st->reference_dts = AV_NOPTS_VALUE;
1347 st->probe_packets = MAX_PROBE_PACKETS;
1349 for(j=0; j<MAX_REORDER_DELAY+1; j++)
1350 st->pts_buffer[j]= AV_NOPTS_VALUE;
1354 void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1357 for(i = 0; i < s->nb_streams; i++) {
1358 AVStream *st = s->streams[i];
1360 st->cur_dts = av_rescale(timestamp,
1361 st->time_base.den * (int64_t)ref_st->time_base.num,
1362 st->time_base.num * (int64_t)ref_st->time_base.den);
1366 void ff_reduce_index(AVFormatContext *s, int stream_index)
1368 AVStream *st= s->streams[stream_index];
1369 unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1371 if((unsigned)st->nb_index_entries >= max_entries){
1373 for(i=0; 2*i<st->nb_index_entries; i++)
1374 st->index_entries[i]= st->index_entries[2*i];
1375 st->nb_index_entries= i;
1379 int ff_add_index_entry(AVIndexEntry **index_entries,
1380 int *nb_index_entries,
1381 unsigned int *index_entries_allocated_size,
1382 int64_t pos, int64_t timestamp, int size, int distance, int flags)
1384 AVIndexEntry *entries, *ie;
1387 if((unsigned)*nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1390 entries = av_fast_realloc(*index_entries,
1391 index_entries_allocated_size,
1392 (*nb_index_entries + 1) *
1393 sizeof(AVIndexEntry));
1397 *index_entries= entries;
1399 index= ff_index_search_timestamp(*index_entries, *nb_index_entries, timestamp, AVSEEK_FLAG_ANY);
1402 index= (*nb_index_entries)++;
1403 ie= &entries[index];
1404 assert(index==0 || ie[-1].timestamp < timestamp);
1406 ie= &entries[index];
1407 if(ie->timestamp != timestamp){
1408 if(ie->timestamp <= timestamp)
1410 memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(*nb_index_entries - index));
1411 (*nb_index_entries)++;
1412 }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1413 distance= ie->min_distance;
1417 ie->timestamp = timestamp;
1418 ie->min_distance= distance;
1425 int av_add_index_entry(AVStream *st,
1426 int64_t pos, int64_t timestamp, int size, int distance, int flags)
1428 return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1429 &st->index_entries_allocated_size, pos,
1430 timestamp, size, distance, flags);
1433 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1434 int64_t wanted_timestamp, int flags)
1442 //optimize appending index entries at the end
1443 if(b && entries[b-1].timestamp < wanted_timestamp)
1448 timestamp = entries[m].timestamp;
1449 if(timestamp >= wanted_timestamp)
1451 if(timestamp <= wanted_timestamp)
1454 m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1456 if(!(flags & AVSEEK_FLAG_ANY)){
1457 while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1458 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1467 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1470 return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
1471 wanted_timestamp, flags);
1476 int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1477 AVInputFormat *avif= s->iformat;
1478 int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1479 int64_t ts_min, ts_max, ts;
1484 if (stream_index < 0)
1488 av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1492 ts_min= AV_NOPTS_VALUE;
1493 pos_limit= -1; //gcc falsely says it may be uninitialized
1495 st= s->streams[stream_index];
1496 if(st->index_entries){
1499 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()
1500 index= FFMAX(index, 0);
1501 e= &st->index_entries[index];
1503 if(e->timestamp <= target_ts || e->pos == e->min_distance){
1505 ts_min= e->timestamp;
1507 av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1514 index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1515 assert(index < st->nb_index_entries);
1517 e= &st->index_entries[index];
1518 assert(e->timestamp >= target_ts);
1520 ts_max= e->timestamp;
1521 pos_limit= pos_max - e->min_distance;
1523 av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1524 pos_max,pos_limit, ts_max);
1529 pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1534 if ((ret = url_fseek(s->pb, pos, SEEK_SET)) < 0)
1537 av_update_cur_dts(s, st, ts);
1542 int64_t av_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts, int64_t pos_min, int64_t pos_max, int64_t pos_limit, int64_t ts_min, int64_t ts_max, int flags, int64_t *ts_ret, int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t )){
1544 int64_t start_pos, filesize;
1548 av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1551 if(ts_min == AV_NOPTS_VALUE){
1552 pos_min = s->data_offset;
1553 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1554 if (ts_min == AV_NOPTS_VALUE)
1558 if(ts_max == AV_NOPTS_VALUE){
1560 filesize = url_fsize(s->pb);
1561 pos_max = filesize - 1;
1564 ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1566 }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1567 if (ts_max == AV_NOPTS_VALUE)
1571 int64_t tmp_pos= pos_max + 1;
1572 int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1573 if(tmp_ts == AV_NOPTS_VALUE)
1577 if(tmp_pos >= filesize)
1583 if(ts_min > ts_max){
1585 }else if(ts_min == ts_max){
1590 while (pos_min < pos_limit) {
1592 av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1596 assert(pos_limit <= pos_max);
1599 int64_t approximate_keyframe_distance= pos_max - pos_limit;
1600 // interpolate position (better than dichotomy)
1601 pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1602 + pos_min - approximate_keyframe_distance;
1603 }else if(no_change==1){
1604 // bisection, if interpolation failed to change min or max pos last time
1605 pos = (pos_min + pos_limit)>>1;
1607 /* linear search if bisection failed, can only happen if there
1608 are very few or no keyframes between min/max */
1613 else if(pos > pos_limit)
1617 ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1623 av_log(s, AV_LOG_DEBUG, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64" target:%"PRId64" limit:%"PRId64" start:%"PRId64" noc:%d\n",
1624 pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts, pos_limit,
1625 start_pos, no_change);
1627 if(ts == AV_NOPTS_VALUE){
1628 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1631 assert(ts != AV_NOPTS_VALUE);
1632 if (target_ts <= ts) {
1633 pos_limit = start_pos - 1;
1637 if (target_ts >= ts) {
1643 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1644 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
1647 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1649 ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1650 av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1651 pos, ts_min, target_ts, ts_max);
1657 static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1658 int64_t pos_min, pos_max;
1662 if (stream_index < 0)
1665 st= s->streams[stream_index];
1668 pos_min = s->data_offset;
1669 pos_max = url_fsize(s->pb) - 1;
1671 if (pos < pos_min) pos= pos_min;
1672 else if(pos > pos_max) pos= pos_max;
1674 url_fseek(s->pb, pos, SEEK_SET);
1677 av_update_cur_dts(s, st, ts);
1682 static int av_seek_frame_generic(AVFormatContext *s,
1683 int stream_index, int64_t timestamp, int flags)
1690 st = s->streams[stream_index];
1692 index = av_index_search_timestamp(st, timestamp, flags);
1694 if(index < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
1697 if(index < 0 || index==st->nb_index_entries-1){
1701 if(st->nb_index_entries){
1702 assert(st->index_entries);
1703 ie= &st->index_entries[st->nb_index_entries-1];
1704 if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
1706 av_update_cur_dts(s, st, ie->timestamp);
1708 if ((ret = url_fseek(s->pb, s->data_offset, SEEK_SET)) < 0)
1714 ret = av_read_frame(s, &pkt);
1715 }while(ret == AVERROR(EAGAIN));
1718 av_free_packet(&pkt);
1719 if(stream_index == pkt.stream_index){
1720 if((pkt.flags & AV_PKT_FLAG_KEY) && pkt.dts > timestamp)
1724 index = av_index_search_timestamp(st, timestamp, flags);
1729 ff_read_frame_flush(s);
1730 if (s->iformat->read_seek){
1731 if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1734 ie = &st->index_entries[index];
1735 if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
1737 av_update_cur_dts(s, st, ie->timestamp);
1742 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1747 ff_read_frame_flush(s);
1749 if(flags & AVSEEK_FLAG_BYTE)
1750 return av_seek_frame_byte(s, stream_index, timestamp, flags);
1752 if(stream_index < 0){
1753 stream_index= av_find_default_stream_index(s);
1754 if(stream_index < 0)
1757 st= s->streams[stream_index];
1758 /* timestamp for default must be expressed in AV_TIME_BASE units */
1759 timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1762 /* first, we try the format specific seek */
1763 if (s->iformat->read_seek)
1764 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1771 if(s->iformat->read_timestamp)
1772 return av_seek_frame_binary(s, stream_index, timestamp, flags);
1774 return av_seek_frame_generic(s, stream_index, timestamp, flags);
1777 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
1779 if(min_ts > ts || max_ts < ts)
1782 ff_read_frame_flush(s);
1784 if (s->iformat->read_seek2)
1785 return s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
1787 if(s->iformat->read_timestamp){
1788 //try to seek via read_timestamp()
1791 //Fallback to old API if new is not implemented but old is
1792 //Note the old has somewat different sematics
1793 if(s->iformat->read_seek || 1)
1794 return av_seek_frame(s, stream_index, ts, flags | (ts - min_ts > (uint64_t)(max_ts - ts) ? AVSEEK_FLAG_BACKWARD : 0));
1796 // try some generic seek like av_seek_frame_generic() but with new ts semantics
1799 /*******************************************************/
1802 * Return TRUE if the stream has accurate duration in any stream.
1804 * @return TRUE if the stream has accurate duration for at least one component.
1806 static int av_has_duration(AVFormatContext *ic)
1811 for(i = 0;i < ic->nb_streams; i++) {
1812 st = ic->streams[i];
1813 if (st->duration != AV_NOPTS_VALUE)
1820 * Estimate the stream timings from the one of each components.
1822 * Also computes the global bitrate if possible.
1824 static void av_update_stream_timings(AVFormatContext *ic)
1826 int64_t start_time, start_time1, end_time, end_time1;
1827 int64_t duration, duration1;
1831 start_time = INT64_MAX;
1832 end_time = INT64_MIN;
1833 duration = INT64_MIN;
1834 for(i = 0;i < ic->nb_streams; i++) {
1835 st = ic->streams[i];
1836 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
1837 start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1838 if (start_time1 < start_time)
1839 start_time = start_time1;
1840 if (st->duration != AV_NOPTS_VALUE) {
1841 end_time1 = start_time1
1842 + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1843 if (end_time1 > end_time)
1844 end_time = end_time1;
1847 if (st->duration != AV_NOPTS_VALUE) {
1848 duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1849 if (duration1 > duration)
1850 duration = duration1;
1853 if (start_time != INT64_MAX) {
1854 ic->start_time = start_time;
1855 if (end_time != INT64_MIN) {
1856 if (end_time - start_time > duration)
1857 duration = end_time - start_time;
1860 if (duration != INT64_MIN) {
1861 ic->duration = duration;
1862 if (ic->file_size > 0) {
1863 /* compute the bitrate */
1864 ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1865 (double)ic->duration;
1870 static void fill_all_stream_timings(AVFormatContext *ic)
1875 av_update_stream_timings(ic);
1876 for(i = 0;i < ic->nb_streams; i++) {
1877 st = ic->streams[i];
1878 if (st->start_time == AV_NOPTS_VALUE) {
1879 if(ic->start_time != AV_NOPTS_VALUE)
1880 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1881 if(ic->duration != AV_NOPTS_VALUE)
1882 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1887 static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1889 int64_t filesize, duration;
1893 /* if bit_rate is already set, we believe it */
1894 if (ic->bit_rate <= 0) {
1896 for(i=0;i<ic->nb_streams;i++) {
1897 st = ic->streams[i];
1898 if (st->codec->bit_rate > 0)
1899 bit_rate += st->codec->bit_rate;
1901 ic->bit_rate = bit_rate;
1904 /* if duration is already set, we believe it */
1905 if (ic->duration == AV_NOPTS_VALUE &&
1906 ic->bit_rate != 0 &&
1907 ic->file_size != 0) {
1908 filesize = ic->file_size;
1910 for(i = 0; i < ic->nb_streams; i++) {
1911 st = ic->streams[i];
1912 duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1913 if (st->duration == AV_NOPTS_VALUE)
1914 st->duration = duration;
1920 #define DURATION_MAX_READ_SIZE 250000
1921 #define DURATION_MAX_RETRY 3
1923 /* only usable for MPEG-PS streams */
1924 static void av_estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
1926 AVPacket pkt1, *pkt = &pkt1;
1928 int read_size, i, ret;
1930 int64_t filesize, offset, duration;
1935 /* flush packet queue */
1936 flush_packet_queue(ic);
1938 for (i=0; i<ic->nb_streams; i++) {
1939 st = ic->streams[i];
1940 if (st->start_time == AV_NOPTS_VALUE && st->first_dts == AV_NOPTS_VALUE)
1941 av_log(st->codec, AV_LOG_WARNING, "start time is not set in av_estimate_timings_from_pts\n");
1944 av_parser_close(st->parser);
1946 av_free_packet(&st->cur_pkt);
1950 /* estimate the end time (duration) */
1951 /* XXX: may need to support wrapping */
1952 filesize = ic->file_size;
1953 end_time = AV_NOPTS_VALUE;
1955 offset = filesize - (DURATION_MAX_READ_SIZE<<retry);
1959 url_fseek(ic->pb, offset, SEEK_SET);
1962 if (read_size >= DURATION_MAX_READ_SIZE<<(FFMAX(retry-1,0)))
1966 ret = av_read_packet(ic, pkt);
1967 }while(ret == AVERROR(EAGAIN));
1970 read_size += pkt->size;
1971 st = ic->streams[pkt->stream_index];
1972 if (pkt->pts != AV_NOPTS_VALUE &&
1973 (st->start_time != AV_NOPTS_VALUE ||
1974 st->first_dts != AV_NOPTS_VALUE)) {
1975 duration = end_time = pkt->pts;
1976 if (st->start_time != AV_NOPTS_VALUE) duration -= st->start_time;
1977 else duration -= st->first_dts;
1979 duration += 1LL<<st->pts_wrap_bits;
1981 if (st->duration == AV_NOPTS_VALUE ||
1982 st->duration < duration)
1983 st->duration = duration;
1986 av_free_packet(pkt);
1988 }while( end_time==AV_NOPTS_VALUE
1989 && filesize > (DURATION_MAX_READ_SIZE<<retry)
1990 && ++retry <= DURATION_MAX_RETRY);
1992 fill_all_stream_timings(ic);
1994 url_fseek(ic->pb, old_offset, SEEK_SET);
1995 for (i=0; i<ic->nb_streams; i++) {
1997 st->cur_dts= st->first_dts;
1998 st->last_IP_pts = AV_NOPTS_VALUE;
2002 static void av_estimate_timings(AVFormatContext *ic, int64_t old_offset)
2006 /* get the file size, if possible */
2007 if (ic->iformat->flags & AVFMT_NOFILE) {
2010 file_size = url_fsize(ic->pb);
2014 ic->file_size = file_size;
2016 if ((!strcmp(ic->iformat->name, "mpeg") ||
2017 !strcmp(ic->iformat->name, "mpegts")) &&
2018 file_size && !url_is_streamed(ic->pb)) {
2019 /* get accurate estimate from the PTSes */
2020 av_estimate_timings_from_pts(ic, old_offset);
2021 } else if (av_has_duration(ic)) {
2022 /* at least one component has timings - we use them for all
2024 fill_all_stream_timings(ic);
2026 av_log(ic, AV_LOG_WARNING, "Estimating duration from bitrate, this may be inaccurate\n");
2027 /* less precise: use bitrate info */
2028 av_estimate_timings_from_bit_rate(ic);
2030 av_update_stream_timings(ic);
2036 for(i = 0;i < ic->nb_streams; i++) {
2037 st = ic->streams[i];
2038 printf("%d: start_time: %0.3f duration: %0.3f\n",
2039 i, (double)st->start_time / AV_TIME_BASE,
2040 (double)st->duration / AV_TIME_BASE);
2042 printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2043 (double)ic->start_time / AV_TIME_BASE,
2044 (double)ic->duration / AV_TIME_BASE,
2045 ic->bit_rate / 1000);
2050 static int has_codec_parameters(AVCodecContext *enc)
2053 switch(enc->codec_type) {
2054 case AVMEDIA_TYPE_AUDIO:
2055 val = enc->sample_rate && enc->channels && enc->sample_fmt != AV_SAMPLE_FMT_NONE;
2056 if(!enc->frame_size &&
2057 (enc->codec_id == CODEC_ID_VORBIS ||
2058 enc->codec_id == CODEC_ID_AAC ||
2059 enc->codec_id == CODEC_ID_MP1 ||
2060 enc->codec_id == CODEC_ID_MP2 ||
2061 enc->codec_id == CODEC_ID_MP3 ||
2062 enc->codec_id == CODEC_ID_SPEEX))
2065 case AVMEDIA_TYPE_VIDEO:
2066 val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
2072 return enc->codec_id != CODEC_ID_NONE && val != 0;
2075 static int has_decode_delay_been_guessed(AVStream *st)
2077 return st->codec->codec_id != CODEC_ID_H264 ||
2078 st->codec_info_nb_frames >= 6 + st->codec->has_b_frames;
2081 static int try_decode_frame(AVStream *st, AVPacket *avpkt)
2085 int got_picture, data_size, ret=0;
2088 if(!st->codec->codec){
2089 codec = avcodec_find_decoder(st->codec->codec_id);
2092 ret = avcodec_open(st->codec, codec);
2097 if(!has_codec_parameters(st->codec) || !has_decode_delay_been_guessed(st)){
2098 switch(st->codec->codec_type) {
2099 case AVMEDIA_TYPE_VIDEO:
2100 avcodec_get_frame_defaults(&picture);
2101 ret = avcodec_decode_video2(st->codec, &picture,
2102 &got_picture, avpkt);
2104 case AVMEDIA_TYPE_AUDIO:
2105 data_size = FFMAX(avpkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
2106 samples = av_malloc(data_size);
2109 ret = avcodec_decode_audio3(st->codec, samples,
2121 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum CodecID id)
2123 while (tags->id != CODEC_ID_NONE) {
2131 enum CodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2134 for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
2135 if(tag == tags[i].tag)
2138 for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
2139 if (ff_toupper4(tag) == ff_toupper4(tags[i].tag))
2142 return CODEC_ID_NONE;
2145 unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum CodecID id)
2148 for(i=0; tags && tags[i]; i++){
2149 int tag= ff_codec_get_tag(tags[i], id);
2155 enum CodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
2158 for(i=0; tags && tags[i]; i++){
2159 enum CodecID id= ff_codec_get_id(tags[i], tag);
2160 if(id!=CODEC_ID_NONE) return id;
2162 return CODEC_ID_NONE;
2165 static void compute_chapters_end(AVFormatContext *s)
2169 for (i=0; i+1<s->nb_chapters; i++)
2170 if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2171 assert(s->chapters[i]->start <= s->chapters[i+1]->start);
2172 assert(!av_cmp_q(s->chapters[i]->time_base, s->chapters[i+1]->time_base));
2173 s->chapters[i]->end = s->chapters[i+1]->start;
2176 if (s->nb_chapters && s->chapters[i]->end == AV_NOPTS_VALUE) {
2177 assert(s->start_time != AV_NOPTS_VALUE);
2178 assert(s->duration > 0);
2179 s->chapters[i]->end = av_rescale_q(s->start_time + s->duration,
2181 s->chapters[i]->time_base);
2185 static int get_std_framerate(int i){
2186 if(i<60*12) return i*1001;
2187 else return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
2191 * Is the time base unreliable.
2192 * This is a heuristic to balance between quick acceptance of the values in
2193 * the headers vs. some extra checks.
2194 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2195 * MPEG-2 commonly misuses field repeat flags to store different framerates.
2196 * And there are "variable" fps files this needs to detect as well.
2198 static int tb_unreliable(AVCodecContext *c){
2199 if( c->time_base.den >= 101L*c->time_base.num
2200 || c->time_base.den < 5L*c->time_base.num
2201 /* || c->codec_tag == AV_RL32("DIVX")
2202 || c->codec_tag == AV_RL32("XVID")*/
2203 || c->codec_id == CODEC_ID_MPEG2VIDEO
2204 || c->codec_id == CODEC_ID_H264
2210 int av_find_stream_info(AVFormatContext *ic)
2212 int i, count, ret, read_size, j;
2214 AVPacket pkt1, *pkt;
2215 int64_t old_offset = url_ftell(ic->pb);
2217 for(i=0;i<ic->nb_streams;i++) {
2219 st = ic->streams[i];
2220 if (st->codec->codec_id == CODEC_ID_AAC) {
2221 st->codec->sample_rate = 0;
2222 st->codec->frame_size = 0;
2223 st->codec->channels = 0;
2225 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2226 st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2227 /* if(!st->time_base.num)
2229 if(!st->codec->time_base.num)
2230 st->codec->time_base= st->time_base;
2232 //only for the split stuff
2233 if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
2234 st->parser = av_parser_init(st->codec->codec_id);
2235 if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
2236 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2239 assert(!st->codec->codec);
2240 codec = avcodec_find_decoder(st->codec->codec_id);
2242 /* Force decoding of at least one frame of codec data
2243 * this makes sure the codec initializes the channel configuration
2244 * and does not trust the values from the container.
2246 if (codec && codec->capabilities & CODEC_CAP_CHANNEL_CONF)
2247 st->codec->channels = 0;
2249 /* Ensure that subtitle_header is properly set. */
2250 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
2251 && codec && !st->codec->codec)
2252 avcodec_open(st->codec, codec);
2254 //try to just open decoders, in case this is enough to get parameters
2255 if(!has_codec_parameters(st->codec)){
2256 if (codec && !st->codec->codec)
2257 avcodec_open(st->codec, codec);
2261 for (i=0; i<ic->nb_streams; i++) {
2262 ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
2268 if(url_interrupt_cb()){
2269 ret= AVERROR(EINTR);
2270 av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2274 /* check if one codec still needs to be handled */
2275 for(i=0;i<ic->nb_streams;i++) {
2276 st = ic->streams[i];
2277 if (!has_codec_parameters(st->codec))
2279 /* variable fps and no guess at the real fps */
2280 if( tb_unreliable(st->codec) && !(st->r_frame_rate.num && st->avg_frame_rate.num)
2281 && st->info->duration_count<20 && st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2283 if(st->parser && st->parser->parser->split && !st->codec->extradata)
2285 if(st->first_dts == AV_NOPTS_VALUE)
2288 if (i == ic->nb_streams) {
2289 /* NOTE: if the format has no header, then we need to read
2290 some packets to get most of the streams, so we cannot
2292 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2293 /* if we found the info for all the codecs, we can stop */
2295 av_log(ic, AV_LOG_DEBUG, "All info found\n");
2299 /* we did not get all the codec info, but we read too much data */
2300 if (read_size >= ic->probesize) {
2302 av_log(ic, AV_LOG_DEBUG, "Probe buffer size limit %d reached\n", ic->probesize);
2306 /* NOTE: a new stream can be added there if no header in file
2307 (AVFMTCTX_NOHEADER) */
2308 ret = av_read_frame_internal(ic, &pkt1);
2309 if (ret < 0 && ret != AVERROR(EAGAIN)) {
2311 ret = -1; /* we could not have all the codec parameters before EOF */
2312 for(i=0;i<ic->nb_streams;i++) {
2313 st = ic->streams[i];
2314 if (!has_codec_parameters(st->codec)){
2316 avcodec_string(buf, sizeof(buf), st->codec, 0);
2317 av_log(ic, AV_LOG_WARNING, "Could not find codec parameters (%s)\n", buf);
2325 if (ret == AVERROR(EAGAIN))
2328 pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2329 if ((ret = av_dup_packet(pkt)) < 0)
2330 goto find_stream_info_err;
2332 read_size += pkt->size;
2334 st = ic->streams[pkt->stream_index];
2335 if (st->codec_info_nb_frames>1) {
2336 if (st->time_base.den > 0 && av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q) >= ic->max_analyze_duration) {
2337 av_log(ic, AV_LOG_WARNING, "max_analyze_duration reached\n");
2340 st->info->codec_info_duration += pkt->duration;
2343 int64_t last = st->info->last_dts;
2344 int64_t duration= pkt->dts - last;
2346 if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
2347 double dur= duration * av_q2d(st->time_base);
2349 // if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2350 // av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
2351 if (st->info->duration_count < 2)
2352 memset(st->info->duration_error, 0, sizeof(st->info->duration_error));
2353 for (i=1; i<FF_ARRAY_ELEMS(st->info->duration_error); i++) {
2354 int framerate= get_std_framerate(i);
2355 int ticks= lrintf(dur*framerate/(1001*12));
2356 double error= dur - ticks*1001*12/(double)framerate;
2357 st->info->duration_error[i] += error*error;
2359 st->info->duration_count++;
2360 // ignore the first 4 values, they might have some random jitter
2361 if (st->info->duration_count > 3)
2362 st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2364 if (last == AV_NOPTS_VALUE || st->info->duration_count <= 1)
2365 st->info->last_dts = pkt->dts;
2367 if(st->parser && st->parser->parser->split && !st->codec->extradata){
2368 int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2370 st->codec->extradata_size= i;
2371 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2372 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2373 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2377 /* if still no information, we try to open the codec and to
2378 decompress the frame. We try to avoid that in most cases as
2379 it takes longer and uses more memory. For MPEG-4, we need to
2380 decompress for QuickTime. */
2381 if (!has_codec_parameters(st->codec) || !has_decode_delay_been_guessed(st))
2382 try_decode_frame(st, pkt);
2384 st->codec_info_nb_frames++;
2388 // close codecs which were opened in try_decode_frame()
2389 for(i=0;i<ic->nb_streams;i++) {
2390 st = ic->streams[i];
2391 if(st->codec->codec)
2392 avcodec_close(st->codec);
2394 for(i=0;i<ic->nb_streams;i++) {
2395 st = ic->streams[i];
2396 if (st->codec_info_nb_frames>2 && !st->avg_frame_rate.num && st->info->codec_info_duration)
2397 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2398 (st->codec_info_nb_frames-2)*(int64_t)st->time_base.den,
2399 st->info->codec_info_duration*(int64_t)st->time_base.num, 60000);
2400 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2401 if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample)
2402 st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2404 // the check for tb_unreliable() is not completely correct, since this is not about handling
2405 // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2406 // ipmovie.c produces.
2407 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)
2408 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);
2409 if (st->info->duration_count && !st->r_frame_rate.num
2410 && tb_unreliable(st->codec) /*&&
2411 //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2412 st->time_base.num*duration_sum[i]/st->info->duration_count*101LL > st->time_base.den*/){
2414 double best_error= 2*av_q2d(st->time_base);
2415 best_error = best_error*best_error*st->info->duration_count*1000*12*30;
2417 for (j=1; j<FF_ARRAY_ELEMS(st->info->duration_error); j++) {
2418 double error = st->info->duration_error[j] * get_std_framerate(j);
2419 // if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2420 // av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
2421 if(error < best_error){
2423 num = get_std_framerate(j);
2426 // do not increase frame rate by more than 1 % in order to match a standard rate.
2427 if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
2428 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2431 if (!st->r_frame_rate.num){
2432 if( st->codec->time_base.den * (int64_t)st->time_base.num
2433 <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
2434 st->r_frame_rate.num = st->codec->time_base.den;
2435 st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
2437 st->r_frame_rate.num = st->time_base.den;
2438 st->r_frame_rate.den = st->time_base.num;
2441 }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2442 if(!st->codec->bits_per_coded_sample)
2443 st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2447 av_estimate_timings(ic, old_offset);
2449 compute_chapters_end(ic);
2452 /* correct DTS for B-frame streams with no timestamps */
2453 for(i=0;i<ic->nb_streams;i++) {
2454 st = ic->streams[i];
2455 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2457 ppktl = &ic->packet_buffer;
2459 if(ppkt1->stream_index != i)
2461 if(ppkt1->pkt->dts < 0)
2463 if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2465 ppkt1->pkt->dts -= delta;
2470 st->cur_dts -= delta;
2476 find_stream_info_err:
2477 for (i=0; i < ic->nb_streams; i++)
2478 av_freep(&ic->streams[i]->info);
2482 static AVProgram *find_program_from_stream(AVFormatContext *ic, int s)
2486 for (i = 0; i < ic->nb_programs; i++)
2487 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
2488 if (ic->programs[i]->stream_index[j] == s)
2489 return ic->programs[i];
2493 int av_find_best_stream(AVFormatContext *ic,
2494 enum AVMediaType type,
2495 int wanted_stream_nb,
2497 AVCodec **decoder_ret,
2500 int i, nb_streams = ic->nb_streams, stream_number = 0;
2501 int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1;
2502 unsigned *program = NULL;
2503 AVCodec *decoder = NULL, *best_decoder = NULL;
2505 if (related_stream >= 0 && wanted_stream_nb < 0) {
2506 AVProgram *p = find_program_from_stream(ic, related_stream);
2508 program = p->stream_index;
2509 nb_streams = p->nb_stream_indexes;
2512 for (i = 0; i < nb_streams; i++) {
2513 AVStream *st = ic->streams[program ? program[i] : i];
2514 AVCodecContext *avctx = st->codec;
2515 if (avctx->codec_type != type)
2517 if (wanted_stream_nb >= 0 && stream_number++ != wanted_stream_nb)
2519 if (st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED|AV_DISPOSITION_VISUAL_IMPAIRED))
2522 decoder = avcodec_find_decoder(ic->streams[i]->codec->codec_id);
2525 ret = AVERROR_DECODER_NOT_FOUND;
2529 if (best_count >= st->codec_info_nb_frames)
2531 best_count = st->codec_info_nb_frames;
2533 best_decoder = decoder;
2534 if (program && i == nb_streams - 1 && ret < 0) {
2536 nb_streams = ic->nb_streams;
2537 i = 0; /* no related stream found, try again with everything */
2541 *decoder_ret = best_decoder;
2545 /*******************************************************/
2547 int av_read_play(AVFormatContext *s)
2549 if (s->iformat->read_play)
2550 return s->iformat->read_play(s);
2552 return av_url_read_fpause(s->pb, 0);
2553 return AVERROR(ENOSYS);
2556 int av_read_pause(AVFormatContext *s)
2558 if (s->iformat->read_pause)
2559 return s->iformat->read_pause(s);
2561 return av_url_read_fpause(s->pb, 1);
2562 return AVERROR(ENOSYS);
2565 void av_close_input_stream(AVFormatContext *s)
2567 flush_packet_queue(s);
2568 if (s->iformat->read_close)
2569 s->iformat->read_close(s);
2570 avformat_free_context(s);
2573 void avformat_free_context(AVFormatContext *s)
2578 for(i=0;i<s->nb_streams;i++) {
2579 /* free all data in a stream component */
2582 av_parser_close(st->parser);
2583 av_free_packet(&st->cur_pkt);
2585 av_metadata_free(&st->metadata);
2586 av_free(st->index_entries);
2587 av_free(st->codec->extradata);
2588 av_free(st->codec->subtitle_header);
2590 #if FF_API_OLD_METADATA
2591 av_free(st->filename);
2593 av_free(st->priv_data);
2597 for(i=s->nb_programs-1; i>=0; i--) {
2598 #if FF_API_OLD_METADATA
2599 av_freep(&s->programs[i]->provider_name);
2600 av_freep(&s->programs[i]->name);
2602 av_metadata_free(&s->programs[i]->metadata);
2603 av_freep(&s->programs[i]->stream_index);
2604 av_freep(&s->programs[i]);
2606 av_freep(&s->programs);
2607 av_freep(&s->priv_data);
2608 while(s->nb_chapters--) {
2609 #if FF_API_OLD_METADATA
2610 av_free(s->chapters[s->nb_chapters]->title);
2612 av_metadata_free(&s->chapters[s->nb_chapters]->metadata);
2613 av_free(s->chapters[s->nb_chapters]);
2615 av_freep(&s->chapters);
2616 av_metadata_free(&s->metadata);
2621 void av_close_input_file(AVFormatContext *s)
2623 ByteIOContext *pb = s->iformat->flags & AVFMT_NOFILE ? NULL : s->pb;
2624 av_close_input_stream(s);
2629 AVStream *av_new_stream(AVFormatContext *s, int id)
2634 #if FF_API_MAX_STREAMS
2635 if (s->nb_streams >= MAX_STREAMS){
2636 av_log(s, AV_LOG_ERROR, "Too many streams\n");
2642 if (s->nb_streams >= INT_MAX/sizeof(*streams))
2644 streams = av_realloc(s->streams, (s->nb_streams + 1) * sizeof(*streams));
2647 s->streams = streams;
2650 st = av_mallocz(sizeof(AVStream));
2653 if (!(st->info = av_mallocz(sizeof(*st->info)))) {
2658 st->codec= avcodec_alloc_context();
2660 /* no default bitrate if decoding */
2661 st->codec->bit_rate = 0;
2663 st->index = s->nb_streams;
2665 st->start_time = AV_NOPTS_VALUE;
2666 st->duration = AV_NOPTS_VALUE;
2667 /* we set the current DTS to 0 so that formats without any timestamps
2668 but durations get some timestamps, formats with some unknown
2669 timestamps have their first few packets buffered and the
2670 timestamps corrected before they are returned to the user */
2672 st->first_dts = AV_NOPTS_VALUE;
2673 st->probe_packets = MAX_PROBE_PACKETS;
2675 /* default pts setting is MPEG-like */
2676 av_set_pts_info(st, 33, 1, 90000);
2677 st->last_IP_pts = AV_NOPTS_VALUE;
2678 for(i=0; i<MAX_REORDER_DELAY+1; i++)
2679 st->pts_buffer[i]= AV_NOPTS_VALUE;
2680 st->reference_dts = AV_NOPTS_VALUE;
2682 st->sample_aspect_ratio = (AVRational){0,1};
2684 s->streams[s->nb_streams++] = st;
2688 AVProgram *av_new_program(AVFormatContext *ac, int id)
2690 AVProgram *program=NULL;
2694 av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2697 for(i=0; i<ac->nb_programs; i++)
2698 if(ac->programs[i]->id == id)
2699 program = ac->programs[i];
2702 program = av_mallocz(sizeof(AVProgram));
2705 dynarray_add(&ac->programs, &ac->nb_programs, program);
2706 program->discard = AVDISCARD_NONE;
2713 AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2715 AVChapter *chapter = NULL;
2718 for(i=0; i<s->nb_chapters; i++)
2719 if(s->chapters[i]->id == id)
2720 chapter = s->chapters[i];
2723 chapter= av_mallocz(sizeof(AVChapter));
2726 dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2728 #if FF_API_OLD_METADATA
2729 av_free(chapter->title);
2731 av_metadata_set2(&chapter->metadata, "title", title, 0);
2733 chapter->time_base= time_base;
2734 chapter->start = start;
2740 /************************************************************/
2741 /* output media file */
2743 int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2747 if (s->oformat->priv_data_size > 0) {
2748 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2750 return AVERROR(ENOMEM);
2751 if (s->oformat->priv_class) {
2752 *(const AVClass**)s->priv_data= s->oformat->priv_class;
2753 av_opt_set_defaults(s->priv_data);
2756 s->priv_data = NULL;
2758 if (s->oformat->set_parameters) {
2759 ret = s->oformat->set_parameters(s, ap);
2766 static int validate_codec_tag(AVFormatContext *s, AVStream *st)
2768 const AVCodecTag *avctag;
2770 enum CodecID id = CODEC_ID_NONE;
2771 unsigned int tag = 0;
2774 * Check that tag + id is in the table
2775 * If neither is in the table -> OK
2776 * If tag is in the table with another id -> FAIL
2777 * If id is in the table with another tag -> FAIL unless strict < normal
2779 for (n = 0; s->oformat->codec_tag[n]; n++) {
2780 avctag = s->oformat->codec_tag[n];
2781 while (avctag->id != CODEC_ID_NONE) {
2782 if (ff_toupper4(avctag->tag) == ff_toupper4(st->codec->codec_tag)) {
2784 if (id == st->codec->codec_id)
2787 if (avctag->id == st->codec->codec_id)
2792 if (id != CODEC_ID_NONE)
2794 if (tag && (st->codec->strict_std_compliance >= FF_COMPLIANCE_NORMAL))
2799 int av_write_header(AVFormatContext *s)
2804 // some sanity checks
2805 if (s->nb_streams == 0 && !(s->oformat->flags & AVFMT_NOSTREAMS)) {
2806 av_log(s, AV_LOG_ERROR, "no streams\n");
2807 return AVERROR(EINVAL);
2810 for(i=0;i<s->nb_streams;i++) {
2813 switch (st->codec->codec_type) {
2814 case AVMEDIA_TYPE_AUDIO:
2815 if(st->codec->sample_rate<=0){
2816 av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2817 return AVERROR(EINVAL);
2819 if(!st->codec->block_align)
2820 st->codec->block_align = st->codec->channels *
2821 av_get_bits_per_sample(st->codec->codec_id) >> 3;
2823 case AVMEDIA_TYPE_VIDEO:
2824 if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2825 av_log(s, AV_LOG_ERROR, "time base not set\n");
2826 return AVERROR(EINVAL);
2828 if((st->codec->width<=0 || st->codec->height<=0) && !(s->oformat->flags & AVFMT_NODIMENSIONS)){
2829 av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2830 return AVERROR(EINVAL);
2832 if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)){
2833 av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between encoder and muxer layer\n");
2834 return AVERROR(EINVAL);
2839 if(s->oformat->codec_tag){
2840 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)){
2841 //the current rawvideo encoding system ends up setting the wrong codec_tag for avi, we override it here
2842 st->codec->codec_tag= 0;
2844 if(st->codec->codec_tag){
2845 if (!validate_codec_tag(s, st)) {
2847 av_get_codec_tag_string(tagbuf, sizeof(tagbuf), st->codec->codec_tag);
2848 av_log(s, AV_LOG_ERROR,
2849 "Tag %s/0x%08x incompatible with output codec id '%d'\n",
2850 tagbuf, st->codec->codec_tag, st->codec->codec_id);
2851 return AVERROR_INVALIDDATA;
2854 st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2857 if(s->oformat->flags & AVFMT_GLOBALHEADER &&
2858 !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
2859 av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
2862 if (!s->priv_data && s->oformat->priv_data_size > 0) {
2863 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2865 return AVERROR(ENOMEM);
2868 #if FF_API_OLD_METADATA
2869 ff_metadata_mux_compat(s);
2872 /* set muxer identification string */
2873 if (s->nb_streams && !(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
2874 av_metadata_set2(&s->metadata, "encoder", LIBAVFORMAT_IDENT, 0);
2877 if(s->oformat->write_header){
2878 ret = s->oformat->write_header(s);
2883 /* init PTS generation */
2884 for(i=0;i<s->nb_streams;i++) {
2885 int64_t den = AV_NOPTS_VALUE;
2888 switch (st->codec->codec_type) {
2889 case AVMEDIA_TYPE_AUDIO:
2890 den = (int64_t)st->time_base.num * st->codec->sample_rate;
2892 case AVMEDIA_TYPE_VIDEO:
2893 den = (int64_t)st->time_base.num * st->codec->time_base.den;
2898 if (den != AV_NOPTS_VALUE) {
2900 return AVERROR_INVALIDDATA;
2901 av_frac_init(&st->pts, 0, 0, den);
2907 //FIXME merge with compute_pkt_fields
2908 static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt){
2909 int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2910 int num, den, frame_size, i;
2912 // av_log(s, AV_LOG_DEBUG, "av_write_frame: pts:%"PRId64" dts:%"PRId64" cur_dts:%"PRId64" b:%d size:%d st:%d\n", pkt->pts, pkt->dts, st->cur_dts, delay, pkt->size, pkt->stream_index);
2914 /* if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2917 /* duration field */
2918 if (pkt->duration == 0) {
2919 compute_frame_duration(&num, &den, st, NULL, pkt);
2921 pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
2925 if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
2928 //XXX/FIXME this is a temporary hack until all encoders output pts
2929 if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2931 // pkt->pts= st->cur_dts;
2932 pkt->pts= st->pts.val;
2935 //calculate dts from pts
2936 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
2937 st->pts_buffer[0]= pkt->pts;
2938 for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2939 st->pts_buffer[i]= pkt->pts + (i-delay-1) * pkt->duration;
2940 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2941 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2943 pkt->dts= st->pts_buffer[0];
2946 if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2947 av_log(s, AV_LOG_ERROR,
2948 "Application provided invalid, non monotonically increasing dts to muxer in stream %d: %"PRId64" >= %"PRId64"\n",
2949 st->index, st->cur_dts, pkt->dts);
2952 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2953 av_log(s, AV_LOG_ERROR, "pts < dts in stream %d\n", st->index);
2957 // av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2958 st->cur_dts= pkt->dts;
2959 st->pts.val= pkt->dts;
2962 switch (st->codec->codec_type) {
2963 case AVMEDIA_TYPE_AUDIO:
2964 frame_size = get_audio_frame_size(st->codec, pkt->size);
2966 /* HACK/FIXME, we skip the initial 0 size packets as they are most
2967 likely equal to the encoder delay, but it would be better if we
2968 had the real timestamps from the encoder */
2969 if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2970 av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2973 case AVMEDIA_TYPE_VIDEO:
2974 av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2982 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2984 int ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt);
2986 if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2989 ret= s->oformat->write_packet(s, pkt);
2991 ret= url_ferror(s->pb);
2995 void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
2996 int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
2998 AVPacketList **next_point, *this_pktl;
3000 this_pktl = av_mallocz(sizeof(AVPacketList));
3001 this_pktl->pkt= *pkt;
3002 pkt->destruct= NULL; // do not free original but only the copy
3003 av_dup_packet(&this_pktl->pkt); // duplicate the packet if it uses non-alloced memory
3005 if(s->streams[pkt->stream_index]->last_in_packet_buffer){
3006 next_point = &(s->streams[pkt->stream_index]->last_in_packet_buffer->next);
3008 next_point = &s->packet_buffer;
3011 if(compare(s, &s->packet_buffer_end->pkt, pkt)){
3012 while(!compare(s, &(*next_point)->pkt, pkt)){
3013 next_point= &(*next_point)->next;
3017 next_point = &(s->packet_buffer_end->next);
3020 assert(!*next_point);
3022 s->packet_buffer_end= this_pktl;
3025 this_pktl->next= *next_point;
3027 s->streams[pkt->stream_index]->last_in_packet_buffer=
3028 *next_point= this_pktl;
3031 static int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
3033 AVStream *st = s->streams[ pkt ->stream_index];
3034 AVStream *st2= s->streams[ next->stream_index];
3035 int64_t a= st2->time_base.num * (int64_t)st ->time_base.den;
3036 int64_t b= st ->time_base.num * (int64_t)st2->time_base.den;
3037 return av_rescale_rnd(pkt->dts, b, a, AV_ROUND_DOWN) < next->dts;
3040 int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
3046 ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
3049 for(i=0; i < s->nb_streams; i++)
3050 stream_count+= !!s->streams[i]->last_in_packet_buffer;
3052 if(stream_count && (s->nb_streams == stream_count || flush)){
3053 pktl= s->packet_buffer;
3056 s->packet_buffer= pktl->next;
3057 if(!s->packet_buffer)
3058 s->packet_buffer_end= NULL;
3060 if(s->streams[out->stream_index]->last_in_packet_buffer == pktl)
3061 s->streams[out->stream_index]->last_in_packet_buffer= NULL;
3065 av_init_packet(out);
3071 * Interleave an AVPacket correctly so it can be muxed.
3072 * @param out the interleaved packet will be output here
3073 * @param in the input packet
3074 * @param flush 1 if no further packets are available as input and all
3075 * remaining packets should be output
3076 * @return 1 if a packet was output, 0 if no packet could be output,
3077 * < 0 if an error occurred
3079 static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
3080 if(s->oformat->interleave_packet)
3081 return s->oformat->interleave_packet(s, out, in, flush);
3083 return av_interleave_packet_per_dts(s, out, in, flush);
3086 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
3087 AVStream *st= s->streams[ pkt->stream_index];
3089 //FIXME/XXX/HACK drop zero sized packets
3090 if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO && pkt->size==0)
3093 //av_log(NULL, AV_LOG_DEBUG, "av_interleaved_write_frame %d %"PRId64" %"PRId64"\n", pkt->size, pkt->dts, pkt->pts);
3094 if(compute_pkt_fields2(s, st, pkt) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3097 if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3102 int ret= av_interleave_packet(s, &opkt, pkt, 0);
3103 if(ret<=0) //FIXME cleanup needed for ret<0 ?
3106 ret= s->oformat->write_packet(s, &opkt);
3108 av_free_packet(&opkt);
3113 if(url_ferror(s->pb))
3114 return url_ferror(s->pb);
3118 int av_write_trailer(AVFormatContext *s)
3124 ret= av_interleave_packet(s, &pkt, NULL, 1);
3125 if(ret<0) //FIXME cleanup needed for ret<0 ?
3130 ret= s->oformat->write_packet(s, &pkt);
3132 av_free_packet(&pkt);
3136 if(url_ferror(s->pb))
3140 if(s->oformat->write_trailer)
3141 ret = s->oformat->write_trailer(s);
3144 ret=url_ferror(s->pb);
3145 for(i=0;i<s->nb_streams;i++) {
3146 av_freep(&s->streams[i]->priv_data);
3147 av_freep(&s->streams[i]->index_entries);
3149 av_freep(&s->priv_data);
3153 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
3156 AVProgram *program=NULL;
3159 if (idx >= ac->nb_streams) {
3160 av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3164 for(i=0; i<ac->nb_programs; i++){
3165 if(ac->programs[i]->id != progid)
3167 program = ac->programs[i];
3168 for(j=0; j<program->nb_stream_indexes; j++)
3169 if(program->stream_index[j] == idx)
3172 tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
3175 program->stream_index = tmp;
3176 program->stream_index[program->nb_stream_indexes++] = idx;
3181 static void print_fps(double d, const char *postfix){
3182 uint64_t v= lrintf(d*100);
3183 if (v% 100 ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3184 else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3185 else av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
3188 static void dump_metadata(void *ctx, AVMetadata *m, const char *indent)
3190 if(m && !(m->count == 1 && av_metadata_get(m, "language", NULL, 0))){
3191 AVMetadataTag *tag=NULL;
3193 av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3194 while((tag=av_metadata_get(m, "", tag, AV_METADATA_IGNORE_SUFFIX))) {
3195 if(strcmp("language", tag->key))
3196 av_log(ctx, AV_LOG_INFO, "%s %-16s: %s\n", indent, tag->key, tag->value);
3201 /* "user interface" functions */
3202 static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
3205 int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
3206 AVStream *st = ic->streams[i];
3207 int g = av_gcd(st->time_base.num, st->time_base.den);
3208 AVMetadataTag *lang = av_metadata_get(st->metadata, "language", NULL, 0);
3209 avcodec_string(buf, sizeof(buf), st->codec, is_output);
3210 av_log(NULL, AV_LOG_INFO, " Stream #%d.%d", index, i);
3211 /* the pid is an important information, so we display it */
3212 /* XXX: add a generic system */
3213 if (flags & AVFMT_SHOW_IDS)
3214 av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
3216 av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
3217 av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames, st->time_base.num/g, st->time_base.den/g);
3218 av_log(NULL, AV_LOG_INFO, ": %s", buf);
3219 if (st->sample_aspect_ratio.num && // default
3220 av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
3221 AVRational display_aspect_ratio;
3222 av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
3223 st->codec->width*st->sample_aspect_ratio.num,
3224 st->codec->height*st->sample_aspect_ratio.den,
3226 av_log(NULL, AV_LOG_INFO, ", PAR %d:%d DAR %d:%d",
3227 st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3228 display_aspect_ratio.num, display_aspect_ratio.den);
3230 if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
3231 if(st->avg_frame_rate.den && st->avg_frame_rate.num)
3232 print_fps(av_q2d(st->avg_frame_rate), "fps");
3233 if(st->r_frame_rate.den && st->r_frame_rate.num)
3234 print_fps(av_q2d(st->r_frame_rate), "tbr");
3235 if(st->time_base.den && st->time_base.num)
3236 print_fps(1/av_q2d(st->time_base), "tbn");
3237 if(st->codec->time_base.den && st->codec->time_base.num)
3238 print_fps(1/av_q2d(st->codec->time_base), "tbc");
3240 if (st->disposition & AV_DISPOSITION_DEFAULT)
3241 av_log(NULL, AV_LOG_INFO, " (default)");
3242 if (st->disposition & AV_DISPOSITION_DUB)
3243 av_log(NULL, AV_LOG_INFO, " (dub)");
3244 if (st->disposition & AV_DISPOSITION_ORIGINAL)
3245 av_log(NULL, AV_LOG_INFO, " (original)");
3246 if (st->disposition & AV_DISPOSITION_COMMENT)
3247 av_log(NULL, AV_LOG_INFO, " (comment)");
3248 if (st->disposition & AV_DISPOSITION_LYRICS)
3249 av_log(NULL, AV_LOG_INFO, " (lyrics)");
3250 if (st->disposition & AV_DISPOSITION_KARAOKE)
3251 av_log(NULL, AV_LOG_INFO, " (karaoke)");
3252 if (st->disposition & AV_DISPOSITION_FORCED)
3253 av_log(NULL, AV_LOG_INFO, " (forced)");
3254 if (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED)
3255 av_log(NULL, AV_LOG_INFO, " (hearing impaired)");
3256 if (st->disposition & AV_DISPOSITION_VISUAL_IMPAIRED)
3257 av_log(NULL, AV_LOG_INFO, " (visual impaired)");
3258 if (st->disposition & AV_DISPOSITION_CLEAN_EFFECTS)
3259 av_log(NULL, AV_LOG_INFO, " (clean effects)");
3260 av_log(NULL, AV_LOG_INFO, "\n");
3261 dump_metadata(NULL, st->metadata, " ");
3264 void dump_format(AVFormatContext *ic,
3270 uint8_t *printed = av_mallocz(ic->nb_streams);
3271 if (ic->nb_streams && !printed)
3274 av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3275 is_output ? "Output" : "Input",
3277 is_output ? ic->oformat->name : ic->iformat->name,
3278 is_output ? "to" : "from", url);
3279 dump_metadata(NULL, ic->metadata, " ");
3281 av_log(NULL, AV_LOG_INFO, " Duration: ");
3282 if (ic->duration != AV_NOPTS_VALUE) {
3283 int hours, mins, secs, us;
3284 secs = ic->duration / AV_TIME_BASE;
3285 us = ic->duration % AV_TIME_BASE;
3290 av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3291 (100 * us) / AV_TIME_BASE);
3293 av_log(NULL, AV_LOG_INFO, "N/A");
3295 if (ic->start_time != AV_NOPTS_VALUE) {
3297 av_log(NULL, AV_LOG_INFO, ", start: ");
3298 secs = ic->start_time / AV_TIME_BASE;
3299 us = abs(ic->start_time % AV_TIME_BASE);
3300 av_log(NULL, AV_LOG_INFO, "%d.%06d",
3301 secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
3303 av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3305 av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
3307 av_log(NULL, AV_LOG_INFO, "N/A");
3309 av_log(NULL, AV_LOG_INFO, "\n");
3311 for (i = 0; i < ic->nb_chapters; i++) {
3312 AVChapter *ch = ic->chapters[i];
3313 av_log(NULL, AV_LOG_INFO, " Chapter #%d.%d: ", index, i);
3314 av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
3315 av_log(NULL, AV_LOG_INFO, "end %f\n", ch->end * av_q2d(ch->time_base));
3317 dump_metadata(NULL, ch->metadata, " ");
3319 if(ic->nb_programs) {
3320 int j, k, total = 0;
3321 for(j=0; j<ic->nb_programs; j++) {
3322 AVMetadataTag *name = av_metadata_get(ic->programs[j]->metadata,
3324 av_log(NULL, AV_LOG_INFO, " Program %d %s\n", ic->programs[j]->id,
3325 name ? name->value : "");
3326 dump_metadata(NULL, ic->programs[j]->metadata, " ");
3327 for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3328 dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3329 printed[ic->programs[j]->stream_index[k]] = 1;
3331 total += ic->programs[j]->nb_stream_indexes;
3333 if (total < ic->nb_streams)
3334 av_log(NULL, AV_LOG_INFO, " No Program\n");
3336 for(i=0;i<ic->nb_streams;i++)
3338 dump_stream_format(ic, i, index, is_output);
3343 #if FF_API_PARSE_FRAME_PARAM
3344 #include "libavcore/parseutils.h"
3346 int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
3348 return av_parse_video_size(width_ptr, height_ptr, str);
3351 int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
3353 AVRational frame_rate;
3354 int ret = av_parse_video_rate(&frame_rate, arg);
3355 *frame_rate_num= frame_rate.num;
3356 *frame_rate_den= frame_rate.den;
3361 int64_t av_gettime(void)
3364 gettimeofday(&tv,NULL);
3365 return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
3368 uint64_t ff_ntp_time(void)
3370 return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3373 int64_t parse_date(const char *datestr, int duration)
3379 static const char * const date_fmt[] = {
3383 static const char * const time_fmt[] = {
3393 time_t now = time(0);
3395 len = strlen(datestr);
3397 lastch = datestr[len - 1];
3400 is_utc = (lastch == 'z' || lastch == 'Z');
3402 memset(&dt, 0, sizeof(dt));
3407 if (!strncasecmp(datestr, "now", len))
3408 return (int64_t) now * 1000000;
3410 /* parse the year-month-day part */
3411 for (i = 0; i < FF_ARRAY_ELEMS(date_fmt); i++) {
3412 q = small_strptime(p, date_fmt[i], &dt);
3418 /* if the year-month-day part is missing, then take the
3419 * current year-month-day time */
3424 dt = *localtime(&now);
3426 dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
3431 if (*p == 'T' || *p == 't' || *p == ' ')
3434 /* parse the hour-minute-second part */
3435 for (i = 0; i < FF_ARRAY_ELEMS(time_fmt); i++) {
3436 q = small_strptime(p, time_fmt[i], &dt);
3442 /* parse datestr as a duration */
3447 /* parse datestr as HH:MM:SS */
3448 q = small_strptime(p, time_fmt[0], &dt);
3450 /* parse datestr as S+ */
3451 dt.tm_sec = strtol(p, (char **)&q, 10);
3453 /* the parsing didn't succeed */
3460 /* Now we have all the fields that we can get */
3466 t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
3468 dt.tm_isdst = -1; /* unknown */
3478 /* parse the .m... part */
3482 for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
3485 val += n * (*q - '0');
3489 return negative ? -t : t;
3492 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
3502 while (*p != '\0' && *p != '=' && *p != '&') {
3503 if ((q - tag) < sizeof(tag) - 1)
3511 while (*p != '&' && *p != '\0') {
3512 if ((q - arg) < arg_size - 1) {
3522 if (!strcmp(tag, tag1))
3531 int av_get_frame_filename(char *buf, int buf_size,
3532 const char *path, int number)
3535 char *q, buf1[20], c;
3536 int nd, len, percentd_found;
3548 while (isdigit(*p)) {
3549 nd = nd * 10 + *p++ - '0';
3552 } while (isdigit(c));
3561 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3563 if ((q - buf + len) > buf_size - 1)
3565 memcpy(q, buf1, len);
3573 if ((q - buf) < buf_size - 1)
3577 if (!percentd_found)
3586 static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3590 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3592 for(i=0;i<size;i+=16) {
3599 PRINT(" %02x", buf[i+j]);
3604 for(j=0;j<len;j++) {
3606 if (c < ' ' || c > '~')
3615 void av_hex_dump(FILE *f, uint8_t *buf, int size)
3617 hex_dump_internal(NULL, f, 0, buf, size);
3620 void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3622 hex_dump_internal(avcl, NULL, level, buf, size);
3625 //FIXME needs to know the time_base
3626 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload)
3629 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3630 PRINT("stream #%d:\n", pkt->stream_index);
3631 PRINT(" keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
3632 PRINT(" duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
3633 /* DTS is _always_ valid after av_read_frame() */
3635 if (pkt->dts == AV_NOPTS_VALUE)
3638 PRINT("%0.3f", (double)pkt->dts / AV_TIME_BASE);
3639 /* PTS may not be known if B-frames are present. */
3641 if (pkt->pts == AV_NOPTS_VALUE)
3644 PRINT("%0.3f", (double)pkt->pts / AV_TIME_BASE);
3646 PRINT(" size=%d\n", pkt->size);
3649 av_hex_dump(f, pkt->data, pkt->size);
3652 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3654 pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
3657 void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3659 pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
3662 #if FF_API_URL_SPLIT
3663 attribute_deprecated
3664 void ff_url_split(char *proto, int proto_size,
3665 char *authorization, int authorization_size,
3666 char *hostname, int hostname_size,
3668 char *path, int path_size,
3671 av_url_split(proto, proto_size,
3672 authorization, authorization_size,
3673 hostname, hostname_size,
3680 void av_url_split(char *proto, int proto_size,
3681 char *authorization, int authorization_size,
3682 char *hostname, int hostname_size,
3684 char *path, int path_size,
3687 const char *p, *ls, *at, *col, *brk;
3689 if (port_ptr) *port_ptr = -1;
3690 if (proto_size > 0) proto[0] = 0;
3691 if (authorization_size > 0) authorization[0] = 0;
3692 if (hostname_size > 0) hostname[0] = 0;
3693 if (path_size > 0) path[0] = 0;
3695 /* parse protocol */
3696 if ((p = strchr(url, ':'))) {
3697 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3702 /* no protocol means plain filename */
3703 av_strlcpy(path, url, path_size);
3707 /* separate path from hostname */
3708 ls = strchr(p, '/');
3710 ls = strchr(p, '?');
3712 av_strlcpy(path, ls, path_size);
3714 ls = &p[strlen(p)]; // XXX
3716 /* the rest is hostname, use that to parse auth/port */
3718 /* authorization (user[:pass]@hostname) */
3719 if ((at = strchr(p, '@')) && at < ls) {
3720 av_strlcpy(authorization, p,
3721 FFMIN(authorization_size, at + 1 - p));
3722 p = at + 1; /* skip '@' */
3725 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3727 av_strlcpy(hostname, p + 1,
3728 FFMIN(hostname_size, brk - p));
3729 if (brk[1] == ':' && port_ptr)
3730 *port_ptr = atoi(brk + 2);
3731 } else if ((col = strchr(p, ':')) && col < ls) {
3732 av_strlcpy(hostname, p,
3733 FFMIN(col + 1 - p, hostname_size));
3734 if (port_ptr) *port_ptr = atoi(col + 1);
3736 av_strlcpy(hostname, p,
3737 FFMIN(ls + 1 - p, hostname_size));
3741 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3744 static const char hex_table_uc[16] = { '0', '1', '2', '3',
3747 'C', 'D', 'E', 'F' };
3748 static const char hex_table_lc[16] = { '0', '1', '2', '3',
3751 'c', 'd', 'e', 'f' };
3752 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3754 for(i = 0; i < s; i++) {
3755 buff[i * 2] = hex_table[src[i] >> 4];
3756 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3762 int ff_hex_to_data(uint8_t *data, const char *p)
3769 p += strspn(p, SPACE_CHARS);
3772 c = toupper((unsigned char) *p++);
3773 if (c >= '0' && c <= '9')
3775 else if (c >= 'A' && c <= 'F')
3790 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3791 unsigned int pts_num, unsigned int pts_den)
3794 if(av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)){
3795 if(new_tb.num != pts_num)
3796 av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/new_tb.num);
3798 av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3800 if(new_tb.num <= 0 || new_tb.den <= 0) {
3801 av_log(NULL, AV_LOG_ERROR, "Ignoring attempt to set invalid timebase for st:%d\n", s->index);
3804 s->time_base = new_tb;
3805 s->pts_wrap_bits = pts_wrap_bits;
3808 int ff_url_join(char *str, int size, const char *proto,
3809 const char *authorization, const char *hostname,
3810 int port, const char *fmt, ...)
3813 struct addrinfo hints, *ai;
3818 av_strlcatf(str, size, "%s://", proto);
3819 if (authorization && authorization[0])
3820 av_strlcatf(str, size, "%s@", authorization);
3821 #if CONFIG_NETWORK && defined(AF_INET6)
3822 /* Determine if hostname is a numerical IPv6 address,
3823 * properly escape it within [] in that case. */
3824 memset(&hints, 0, sizeof(hints));
3825 hints.ai_flags = AI_NUMERICHOST;
3826 if (!getaddrinfo(hostname, NULL, &hints, &ai)) {
3827 if (ai->ai_family == AF_INET6) {
3828 av_strlcat(str, "[", size);
3829 av_strlcat(str, hostname, size);
3830 av_strlcat(str, "]", size);
3832 av_strlcat(str, hostname, size);
3837 /* Not an IPv6 address, just output the plain string. */
3838 av_strlcat(str, hostname, size);
3841 av_strlcatf(str, size, ":%d", port);
3844 int len = strlen(str);
3847 vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);
3853 int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
3854 AVFormatContext *src)
3859 local_pkt.stream_index = dst_stream;
3860 if (pkt->pts != AV_NOPTS_VALUE)
3861 local_pkt.pts = av_rescale_q(pkt->pts,
3862 src->streams[pkt->stream_index]->time_base,
3863 dst->streams[dst_stream]->time_base);
3864 if (pkt->dts != AV_NOPTS_VALUE)
3865 local_pkt.dts = av_rescale_q(pkt->dts,
3866 src->streams[pkt->stream_index]->time_base,
3867 dst->streams[dst_stream]->time_base);
3868 return av_write_frame(dst, &local_pkt);
3871 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
3874 const char *ptr = str;
3876 /* Parse key=value pairs. */
3879 char *dest = NULL, *dest_end;
3880 int key_len, dest_len = 0;
3882 /* Skip whitespace and potential commas. */
3883 while (*ptr && (isspace(*ptr) || *ptr == ','))
3890 if (!(ptr = strchr(key, '=')))
3893 key_len = ptr - key;
3895 callback_get_buf(context, key, key_len, &dest, &dest_len);
3896 dest_end = dest + dest_len - 1;
3900 while (*ptr && *ptr != '\"') {
3904 if (dest && dest < dest_end)
3908 if (dest && dest < dest_end)
3916 for (; *ptr && !(isspace(*ptr) || *ptr == ','); ptr++)
3917 if (dest && dest < dest_end)
3925 int ff_find_stream_index(AVFormatContext *s, int id)
3928 for (i = 0; i < s->nb_streams; i++) {
3929 if (s->streams[i]->id == id)