2 * various utility functions for use within Libav
3 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
5 * This file is part of Libav.
7 * Libav is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * Libav is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with Libav; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
25 #include "avio_internal.h"
27 #include "libavcodec/internal.h"
28 #include "libavcodec/bytestream.h"
29 #include "libavutil/opt.h"
30 #include "libavutil/dict.h"
31 #include "libavutil/pixdesc.h"
34 #include "libavutil/avassert.h"
35 #include "libavutil/avstring.h"
36 #include "libavutil/mathematics.h"
37 #include "libavutil/parseutils.h"
39 #include "audiointerleave.h"
51 * various utility functions for use within Libav
54 unsigned avformat_version(void)
56 return LIBAVFORMAT_VERSION_INT;
59 const char *avformat_configuration(void)
61 return LIBAV_CONFIGURATION;
64 const char *avformat_license(void)
66 #define LICENSE_PREFIX "libavformat license: "
67 return LICENSE_PREFIX LIBAV_LICENSE + sizeof(LICENSE_PREFIX) - 1;
70 /* fraction handling */
73 * f = val + (num / den) + 0.5.
75 * 'num' is normalized so that it is such as 0 <= num < den.
77 * @param f fractional number
78 * @param val integer value
79 * @param num must be >= 0
80 * @param den must be >= 1
82 static void frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
95 * Fractional addition to f: f = f + (incr / f->den).
97 * @param f fractional number
98 * @param incr increment, can be positive or negative
100 static void frac_add(AVFrac *f, int64_t incr)
113 } else if (num >= den) {
120 /** head of registered input format linked list */
121 static AVInputFormat *first_iformat = NULL;
122 /** head of registered output format linked list */
123 static AVOutputFormat *first_oformat = NULL;
125 AVInputFormat *av_iformat_next(AVInputFormat *f)
127 if(f) return f->next;
128 else return first_iformat;
131 AVOutputFormat *av_oformat_next(AVOutputFormat *f)
133 if(f) return f->next;
134 else return first_oformat;
137 void av_register_input_format(AVInputFormat *format)
141 while (*p != NULL) p = &(*p)->next;
146 void av_register_output_format(AVOutputFormat *format)
150 while (*p != NULL) p = &(*p)->next;
155 int av_match_ext(const char *filename, const char *extensions)
163 ext = strrchr(filename, '.');
169 while (*p != '\0' && *p != ',' && q-ext1<sizeof(ext1)-1)
172 if (!av_strcasecmp(ext1, ext))
182 static int match_format(const char *name, const char *names)
190 namelen = strlen(name);
191 while ((p = strchr(names, ','))) {
192 len = FFMAX(p - names, namelen);
193 if (!av_strncasecmp(name, names, len))
197 return !av_strcasecmp(name, names);
200 AVOutputFormat *av_guess_format(const char *short_name, const char *filename,
201 const char *mime_type)
203 AVOutputFormat *fmt = NULL, *fmt_found;
204 int score_max, score;
206 /* specific test for image sequences */
207 #if CONFIG_IMAGE2_MUXER
208 if (!short_name && filename &&
209 av_filename_number_test(filename) &&
210 ff_guess_image2_codec(filename) != CODEC_ID_NONE) {
211 return av_guess_format("image2", NULL, NULL);
214 /* Find the proper file type. */
217 while ((fmt = av_oformat_next(fmt))) {
219 if (fmt->name && short_name && !av_strcasecmp(fmt->name, short_name))
221 if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
223 if (filename && fmt->extensions &&
224 av_match_ext(filename, fmt->extensions)) {
227 if (score > score_max) {
235 enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
236 const char *filename, const char *mime_type, enum AVMediaType type){
237 if(type == AVMEDIA_TYPE_VIDEO){
238 enum CodecID codec_id= CODEC_ID_NONE;
240 #if CONFIG_IMAGE2_MUXER
241 if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
242 codec_id= ff_guess_image2_codec(filename);
245 if(codec_id == CODEC_ID_NONE)
246 codec_id= fmt->video_codec;
248 }else if(type == AVMEDIA_TYPE_AUDIO)
249 return fmt->audio_codec;
250 else if (type == AVMEDIA_TYPE_SUBTITLE)
251 return fmt->subtitle_codec;
253 return CODEC_ID_NONE;
256 AVInputFormat *av_find_input_format(const char *short_name)
258 AVInputFormat *fmt = NULL;
259 while ((fmt = av_iformat_next(fmt))) {
260 if (match_format(short_name, fmt->name))
267 int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
269 int ret= av_new_packet(pkt, size);
274 pkt->pos= avio_tell(s);
276 ret= avio_read(s, pkt->data, size);
280 av_shrink_packet(pkt, ret);
285 int av_append_packet(AVIOContext *s, AVPacket *pkt, int size)
290 return av_get_packet(s, pkt, size);
291 old_size = pkt->size;
292 ret = av_grow_packet(pkt, size);
295 ret = avio_read(s, pkt->data + old_size, size);
296 av_shrink_packet(pkt, old_size + FFMAX(ret, 0));
301 int av_filename_number_test(const char *filename)
304 return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
307 AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
309 AVProbeData lpd = *pd;
310 AVInputFormat *fmt1 = NULL, *fmt;
313 if (lpd.buf_size > 10 && ff_id3v2_match(lpd.buf, ID3v2_DEFAULT_MAGIC)) {
314 int id3len = ff_id3v2_tag_len(lpd.buf);
315 if (lpd.buf_size > id3len + 16) {
317 lpd.buf_size -= id3len;
323 while ((fmt1 = av_iformat_next(fmt1))) {
324 if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
327 if (fmt1->read_probe) {
328 score = fmt1->read_probe(&lpd);
329 } else if (fmt1->extensions) {
330 if (av_match_ext(lpd.filename, fmt1->extensions)) {
334 if (score > *score_max) {
337 }else if (score == *score_max)
341 /* a hack for files with huge id3v2 tags -- try to guess by file extension. */
342 if (!fmt && is_opened && *score_max < AVPROBE_SCORE_MAX/4) {
343 while ((fmt = av_iformat_next(fmt)))
344 if (fmt->extensions && av_match_ext(lpd.filename, fmt->extensions)) {
345 *score_max = AVPROBE_SCORE_MAX/4;
350 if (!fmt && id3 && *score_max < AVPROBE_SCORE_MAX/4-1) {
351 while ((fmt = av_iformat_next(fmt)))
352 if (fmt->extensions && av_match_ext("mp3", fmt->extensions)) {
353 *score_max = AVPROBE_SCORE_MAX/4-1;
361 AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
363 return av_probe_input_format2(pd, is_opened, &score);
366 static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st, AVProbeData *pd, int score)
368 static const struct {
369 const char *name; enum CodecID id; enum AVMediaType type;
371 { "aac" , CODEC_ID_AAC , AVMEDIA_TYPE_AUDIO },
372 { "ac3" , CODEC_ID_AC3 , AVMEDIA_TYPE_AUDIO },
373 { "dts" , CODEC_ID_DTS , AVMEDIA_TYPE_AUDIO },
374 { "eac3" , CODEC_ID_EAC3 , AVMEDIA_TYPE_AUDIO },
375 { "h264" , CODEC_ID_H264 , AVMEDIA_TYPE_VIDEO },
376 { "m4v" , CODEC_ID_MPEG4 , AVMEDIA_TYPE_VIDEO },
377 { "mp3" , CODEC_ID_MP3 , AVMEDIA_TYPE_AUDIO },
378 { "mpegvideo", CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
381 AVInputFormat *fmt = av_probe_input_format2(pd, 1, &score);
385 av_log(s, AV_LOG_DEBUG, "Probe with size=%d, packets=%d detected %s with score=%d\n",
386 pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets, fmt->name, score);
387 for (i = 0; fmt_id_type[i].name; i++) {
388 if (!strcmp(fmt->name, fmt_id_type[i].name)) {
389 st->codec->codec_id = fmt_id_type[i].id;
390 st->codec->codec_type = fmt_id_type[i].type;
398 /************************************************************/
399 /* input media file */
401 /** size of probe buffer, for guessing file type from file contents */
402 #define PROBE_BUF_MIN 2048
403 #define PROBE_BUF_MAX (1<<20)
405 int av_probe_input_buffer(AVIOContext *pb, AVInputFormat **fmt,
406 const char *filename, void *logctx,
407 unsigned int offset, unsigned int max_probe_size)
409 AVProbeData pd = { filename ? filename : "", NULL, -offset };
410 unsigned char *buf = NULL;
411 int ret = 0, probe_size;
413 if (!max_probe_size) {
414 max_probe_size = PROBE_BUF_MAX;
415 } else if (max_probe_size > PROBE_BUF_MAX) {
416 max_probe_size = PROBE_BUF_MAX;
417 } else if (max_probe_size < PROBE_BUF_MIN) {
418 return AVERROR(EINVAL);
421 if (offset >= max_probe_size) {
422 return AVERROR(EINVAL);
425 for(probe_size= PROBE_BUF_MIN; probe_size<=max_probe_size && !*fmt;
426 probe_size = FFMIN(probe_size<<1, FFMAX(max_probe_size, probe_size+1))) {
427 int score = probe_size < max_probe_size ? AVPROBE_SCORE_MAX/4 : 0;
428 int buf_offset = (probe_size == PROBE_BUF_MIN) ? 0 : probe_size>>1;
430 if (probe_size < offset) {
434 /* read probe data */
435 buf = av_realloc(buf, probe_size + AVPROBE_PADDING_SIZE);
436 if ((ret = avio_read(pb, buf + buf_offset, probe_size - buf_offset)) < 0) {
437 /* fail if error was not end of file, otherwise, lower score */
438 if (ret != AVERROR_EOF) {
443 ret = 0; /* error was end of file, nothing read */
446 pd.buf = &buf[offset];
448 memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE);
450 /* guess file format */
451 *fmt = av_probe_input_format2(&pd, 1, &score);
453 if(score <= AVPROBE_SCORE_MAX/4){ //this can only be true in the last iteration
454 av_log(logctx, AV_LOG_WARNING, "Format detected only with low score of %d, misdetection possible!\n", score);
456 av_log(logctx, AV_LOG_DEBUG, "Probed with size=%d and score=%d\n", probe_size, score);
462 return AVERROR_INVALIDDATA;
465 /* rewind. reuse probe buffer to avoid seeking */
466 if ((ret = ffio_rewind_with_probe_data(pb, buf, pd.buf_size)) < 0)
472 /* open input file and probe the format if necessary */
473 static int init_input(AVFormatContext *s, const char *filename, AVDictionary **options)
476 AVProbeData pd = {filename, NULL, 0};
479 s->flags |= AVFMT_FLAG_CUSTOM_IO;
481 return av_probe_input_buffer(s->pb, &s->iformat, filename, s, 0, s->probesize);
482 else if (s->iformat->flags & AVFMT_NOFILE)
483 return AVERROR(EINVAL);
487 if ( (s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
488 (!s->iformat && (s->iformat = av_probe_input_format(&pd, 0))))
491 if ((ret = avio_open2(&s->pb, filename, AVIO_FLAG_READ,
492 &s->interrupt_callback, options)) < 0)
496 return av_probe_input_buffer(s->pb, &s->iformat, filename, s, 0, s->probesize);
499 static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
500 AVPacketList **plast_pktl){
501 AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
506 (*plast_pktl)->next = pktl;
508 *packet_buffer = pktl;
510 /* add the packet in the buffered packet list */
516 static void queue_attached_pictures(AVFormatContext *s)
519 for (i = 0; i < s->nb_streams; i++)
520 if (s->streams[i]->disposition & AV_DISPOSITION_ATTACHED_PIC &&
521 s->streams[i]->discard < AVDISCARD_ALL) {
522 AVPacket copy = s->streams[i]->attached_pic;
523 copy.destruct = NULL;
524 add_to_pktbuf(&s->raw_packet_buffer, ©, &s->raw_packet_buffer_end);
528 int avformat_open_input(AVFormatContext **ps, const char *filename, AVInputFormat *fmt, AVDictionary **options)
530 AVFormatContext *s = *ps;
532 AVDictionary *tmp = NULL;
533 ID3v2ExtraMeta *id3v2_extra_meta = NULL;
535 if (!s && !(s = avformat_alloc_context()))
536 return AVERROR(ENOMEM);
541 av_dict_copy(&tmp, *options, 0);
543 if ((ret = av_opt_set_dict(s, &tmp)) < 0)
546 if ((ret = init_input(s, filename, &tmp)) < 0)
549 /* check filename in case an image number is expected */
550 if (s->iformat->flags & AVFMT_NEEDNUMBER) {
551 if (!av_filename_number_test(filename)) {
552 ret = AVERROR(EINVAL);
557 s->duration = s->start_time = AV_NOPTS_VALUE;
558 av_strlcpy(s->filename, filename ? filename : "", sizeof(s->filename));
560 /* allocate private data */
561 if (s->iformat->priv_data_size > 0) {
562 if (!(s->priv_data = av_mallocz(s->iformat->priv_data_size))) {
563 ret = AVERROR(ENOMEM);
566 if (s->iformat->priv_class) {
567 *(const AVClass**)s->priv_data = s->iformat->priv_class;
568 av_opt_set_defaults(s->priv_data);
569 if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
574 /* e.g. AVFMT_NOFILE formats will not have a AVIOContext */
576 ff_id3v2_read(s, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta);
578 if (s->iformat->read_header)
579 if ((ret = s->iformat->read_header(s)) < 0)
582 if (id3v2_extra_meta &&
583 (ret = ff_id3v2_parse_apic(s, &id3v2_extra_meta)) < 0)
585 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
587 queue_attached_pictures(s);
589 if (s->pb && !s->data_offset)
590 s->data_offset = avio_tell(s->pb);
592 s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
595 av_dict_free(options);
602 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
604 if (s->pb && !(s->flags & AVFMT_FLAG_CUSTOM_IO))
606 avformat_free_context(s);
611 /*******************************************************/
613 static void probe_codec(AVFormatContext *s, AVStream *st, const AVPacket *pkt)
615 if(st->codec->codec_id == CODEC_ID_PROBE){
616 AVProbeData *pd = &st->probe_data;
617 av_log(s, AV_LOG_DEBUG, "probing stream %d\n", st->index);
621 pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
622 memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
623 pd->buf_size += pkt->size;
624 memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
626 st->probe_packets = 0;
629 if (!st->probe_packets ||
630 av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)) {
631 set_codec_from_probe_data(s, st, pd, st->probe_packets > 0 ? AVPROBE_SCORE_MAX/4 : 0);
632 if(st->codec->codec_id != CODEC_ID_PROBE){
635 av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
641 int ff_read_packet(AVFormatContext *s, AVPacket *pkt)
647 AVPacketList *pktl = s->raw_packet_buffer;
651 st = s->streams[pkt->stream_index];
652 if (st->codec->codec_id != CODEC_ID_PROBE || !st->probe_packets ||
653 s->raw_packet_buffer_remaining_size < pkt->size) {
655 if (st->probe_packets) {
656 probe_codec(s, st, NULL);
658 pd = &st->probe_data;
661 s->raw_packet_buffer = pktl->next;
662 s->raw_packet_buffer_remaining_size += pkt->size;
669 ret= s->iformat->read_packet(s, pkt);
671 if (!pktl || ret == AVERROR(EAGAIN))
673 for (i = 0; i < s->nb_streams; i++) {
675 if (st->probe_packets) {
676 probe_codec(s, st, NULL);
682 if ((s->flags & AVFMT_FLAG_DISCARD_CORRUPT) &&
683 (pkt->flags & AV_PKT_FLAG_CORRUPT)) {
684 av_log(s, AV_LOG_WARNING,
685 "Dropped corrupted packet (stream = %d)\n",
691 st= s->streams[pkt->stream_index];
693 switch(st->codec->codec_type){
694 case AVMEDIA_TYPE_VIDEO:
695 if(s->video_codec_id) st->codec->codec_id= s->video_codec_id;
697 case AVMEDIA_TYPE_AUDIO:
698 if(s->audio_codec_id) st->codec->codec_id= s->audio_codec_id;
700 case AVMEDIA_TYPE_SUBTITLE:
701 if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
705 if(!pktl && (st->codec->codec_id != CODEC_ID_PROBE ||
709 add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
710 s->raw_packet_buffer_remaining_size -= pkt->size;
712 probe_codec(s, st, pkt);
716 #if FF_API_READ_PACKET
717 int av_read_packet(AVFormatContext *s, AVPacket *pkt)
719 return ff_read_packet(s, pkt);
724 /**********************************************************/
727 * Get the number of samples of an audio frame. Return -1 on error.
729 static int get_audio_frame_size(AVCodecContext *enc, int size, int mux)
733 /* give frame_size priority if demuxing */
734 if (!mux && enc->frame_size > 1)
735 return enc->frame_size;
737 if ((frame_size = av_get_audio_frame_duration(enc, size)) > 0)
740 /* fallback to using frame_size if muxing */
741 if (enc->frame_size > 1)
742 return enc->frame_size;
749 * Return the frame duration in seconds. Return 0 if not available.
751 static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
752 AVCodecParserContext *pc, AVPacket *pkt)
758 switch(st->codec->codec_type) {
759 case AVMEDIA_TYPE_VIDEO:
760 if (st->r_frame_rate.num) {
761 *pnum = st->r_frame_rate.den;
762 *pden = st->r_frame_rate.num;
763 } else if(st->time_base.num*1000LL > st->time_base.den) {
764 *pnum = st->time_base.num;
765 *pden = st->time_base.den;
766 }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
767 *pnum = st->codec->time_base.num;
768 *pden = st->codec->time_base.den;
769 if (pc && pc->repeat_pict) {
770 *pnum = (*pnum) * (1 + pc->repeat_pict);
772 //If this codec can be interlaced or progressive then we need a parser to compute duration of a packet
773 //Thus if we have no parser in such case leave duration undefined.
774 if(st->codec->ticks_per_frame>1 && !pc){
779 case AVMEDIA_TYPE_AUDIO:
780 frame_size = get_audio_frame_size(st->codec, pkt->size, 0);
781 if (frame_size <= 0 || st->codec->sample_rate <= 0)
784 *pden = st->codec->sample_rate;
791 static int is_intra_only(AVCodecContext *enc){
792 if(enc->codec_type == AVMEDIA_TYPE_AUDIO){
794 }else if(enc->codec_type == AVMEDIA_TYPE_VIDEO){
795 switch(enc->codec_id){
797 case CODEC_ID_MJPEGB:
799 case CODEC_ID_PRORES:
800 case CODEC_ID_RAWVIDEO:
801 case CODEC_ID_DVVIDEO:
802 case CODEC_ID_HUFFYUV:
803 case CODEC_ID_FFVHUFF:
808 case CODEC_ID_JPEG2000:
817 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
818 int64_t dts, int64_t pts)
820 AVStream *st= s->streams[stream_index];
821 AVPacketList *pktl= s->packet_buffer;
823 if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE)
826 st->first_dts= dts - st->cur_dts;
829 for(; pktl; pktl= pktl->next){
830 if(pktl->pkt.stream_index != stream_index)
832 //FIXME think more about this check
833 if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
834 pktl->pkt.pts += st->first_dts;
836 if(pktl->pkt.dts != AV_NOPTS_VALUE)
837 pktl->pkt.dts += st->first_dts;
839 if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
840 st->start_time= pktl->pkt.pts;
842 if (st->start_time == AV_NOPTS_VALUE)
843 st->start_time = pts;
846 static void update_initial_durations(AVFormatContext *s, AVStream *st,
847 int stream_index, int duration)
849 AVPacketList *pktl= s->packet_buffer;
852 if(st->first_dts != AV_NOPTS_VALUE){
853 cur_dts= st->first_dts;
854 for(; pktl; pktl= pktl->next){
855 if(pktl->pkt.stream_index == stream_index){
856 if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
861 pktl= s->packet_buffer;
862 st->first_dts = cur_dts;
863 }else if(st->cur_dts)
866 for(; pktl; pktl= pktl->next){
867 if(pktl->pkt.stream_index != stream_index)
869 if(pktl->pkt.pts == pktl->pkt.dts && pktl->pkt.dts == AV_NOPTS_VALUE
870 && !pktl->pkt.duration){
871 pktl->pkt.dts= cur_dts;
872 if(!st->codec->has_b_frames)
873 pktl->pkt.pts= cur_dts;
875 if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO)
876 pktl->pkt.duration = duration;
880 if(st->first_dts == AV_NOPTS_VALUE)
881 st->cur_dts= cur_dts;
884 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
885 AVCodecParserContext *pc, AVPacket *pkt)
887 int num, den, presentation_delayed, delay, i;
890 if (s->flags & AVFMT_FLAG_NOFILLIN)
893 if((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
894 pkt->dts= AV_NOPTS_VALUE;
896 /* do we have a video B-frame ? */
897 delay= st->codec->has_b_frames;
898 presentation_delayed = 0;
900 /* XXX: need has_b_frame, but cannot get it if the codec is
903 pc && pc->pict_type != AV_PICTURE_TYPE_B)
904 presentation_delayed = 1;
906 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
907 /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
908 pkt->dts -= 1LL<<st->pts_wrap_bits;
911 // some mpeg2 in mpeg-ps lack dts (issue171 / input_file.mpg)
912 // we take the conservative approach and discard both
913 // Note, if this is misbehaving for a H.264 file then possibly presentation_delayed is not set correctly.
914 if(delay==1 && pkt->dts == pkt->pts && pkt->dts != AV_NOPTS_VALUE && presentation_delayed){
915 av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination\n");
916 pkt->dts= pkt->pts= AV_NOPTS_VALUE;
919 if (pkt->duration == 0 && st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
920 compute_frame_duration(&num, &den, st, pc, pkt);
922 pkt->duration = av_rescale_rnd(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num, AV_ROUND_DOWN);
924 if(pkt->duration != 0 && s->packet_buffer)
925 update_initial_durations(s, st, pkt->stream_index, pkt->duration);
929 /* correct timestamps with byte offset if demuxers only have timestamps
930 on packet boundaries */
931 if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
932 /* this will estimate bitrate based on this frame's duration and size */
933 offset = av_rescale(pc->offset, pkt->duration, pkt->size);
934 if(pkt->pts != AV_NOPTS_VALUE)
936 if(pkt->dts != AV_NOPTS_VALUE)
940 if (pc && pc->dts_sync_point >= 0) {
941 // we have synchronization info from the parser
942 int64_t den = st->codec->time_base.den * (int64_t) st->time_base.num;
944 int64_t num = st->codec->time_base.num * (int64_t) st->time_base.den;
945 if (pkt->dts != AV_NOPTS_VALUE) {
946 // got DTS from the stream, update reference timestamp
947 st->reference_dts = pkt->dts - pc->dts_ref_dts_delta * num / den;
948 pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
949 } else if (st->reference_dts != AV_NOPTS_VALUE) {
950 // compute DTS based on reference timestamp
951 pkt->dts = st->reference_dts + pc->dts_ref_dts_delta * num / den;
952 pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
954 if (pc->dts_sync_point > 0)
955 st->reference_dts = pkt->dts; // new reference
959 /* This may be redundant, but it should not hurt. */
960 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
961 presentation_delayed = 1;
963 // 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);
964 /* interpolate PTS and DTS if they are not present */
965 //We skip H264 currently because delay and has_b_frames are not reliably set
966 if((delay==0 || (delay==1 && pc)) && st->codec->codec_id != CODEC_ID_H264){
967 if (presentation_delayed) {
968 /* DTS = decompression timestamp */
969 /* PTS = presentation timestamp */
970 if (pkt->dts == AV_NOPTS_VALUE)
971 pkt->dts = st->last_IP_pts;
972 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
973 if (pkt->dts == AV_NOPTS_VALUE)
974 pkt->dts = st->cur_dts;
976 /* this is tricky: the dts must be incremented by the duration
977 of the frame we are displaying, i.e. the last I- or P-frame */
978 if (st->last_IP_duration == 0)
979 st->last_IP_duration = pkt->duration;
980 if(pkt->dts != AV_NOPTS_VALUE)
981 st->cur_dts = pkt->dts + st->last_IP_duration;
982 st->last_IP_duration = pkt->duration;
983 st->last_IP_pts= pkt->pts;
984 /* cannot compute PTS if not present (we can compute it only
985 by knowing the future */
986 } else if (pkt->pts != AV_NOPTS_VALUE ||
987 pkt->dts != AV_NOPTS_VALUE ||
989 st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
990 int duration = pkt->duration;
991 if (!duration && st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
992 compute_frame_duration(&num, &den, st, pc, pkt);
994 duration = av_rescale_rnd(1, num * (int64_t)st->time_base.den,
995 den * (int64_t)st->time_base.num,
997 if (duration != 0 && s->packet_buffer) {
998 update_initial_durations(s, st, pkt->stream_index,
1004 if (pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE ||
1006 /* presentation is not delayed : PTS and DTS are the same */
1007 if (pkt->pts == AV_NOPTS_VALUE)
1008 pkt->pts = pkt->dts;
1009 update_initial_timestamps(s, pkt->stream_index, pkt->pts,
1011 if (pkt->pts == AV_NOPTS_VALUE)
1012 pkt->pts = st->cur_dts;
1013 pkt->dts = pkt->pts;
1014 if (pkt->pts != AV_NOPTS_VALUE)
1015 st->cur_dts = pkt->pts + duration;
1020 if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
1021 st->pts_buffer[0]= pkt->pts;
1022 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
1023 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
1024 if(pkt->dts == AV_NOPTS_VALUE)
1025 pkt->dts= st->pts_buffer[0];
1026 if(st->codec->codec_id == CODEC_ID_H264){ // we skipped it above so we try here
1027 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
1029 if(pkt->dts > st->cur_dts)
1030 st->cur_dts = pkt->dts;
1033 // 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);
1036 if(is_intra_only(st->codec))
1037 pkt->flags |= AV_PKT_FLAG_KEY;
1039 pkt->convergence_duration = pc->convergence_duration;
1042 static void free_packet_buffer(AVPacketList **pkt_buf, AVPacketList **pkt_buf_end)
1045 AVPacketList *pktl = *pkt_buf;
1046 *pkt_buf = pktl->next;
1047 av_free_packet(&pktl->pkt);
1050 *pkt_buf_end = NULL;
1054 * Parse a packet, add all split parts to parse_queue
1056 * @param pkt packet to parse, NULL when flushing the parser at end of stream
1058 static int parse_packet(AVFormatContext *s, AVPacket *pkt, int stream_index)
1060 AVPacket out_pkt = { 0 }, flush_pkt = { 0 };
1061 AVStream *st = s->streams[stream_index];
1062 uint8_t *data = pkt ? pkt->data : NULL;
1063 int size = pkt ? pkt->size : 0;
1064 int ret = 0, got_output = 0;
1067 av_init_packet(&flush_pkt);
1072 while (size > 0 || (pkt == &flush_pkt && got_output)) {
1075 av_init_packet(&out_pkt);
1076 len = av_parser_parse2(st->parser, st->codec,
1077 &out_pkt.data, &out_pkt.size, data, size,
1078 pkt->pts, pkt->dts, pkt->pos);
1080 pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1081 /* increment read pointer */
1085 got_output = !!out_pkt.size;
1090 /* set the duration */
1091 out_pkt.duration = 0;
1092 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1093 if (st->codec->sample_rate > 0) {
1094 out_pkt.duration = av_rescale_q_rnd(st->parser->duration,
1095 (AVRational){ 1, st->codec->sample_rate },
1099 } else if (st->codec->time_base.num != 0 &&
1100 st->codec->time_base.den != 0) {
1101 out_pkt.duration = av_rescale_q_rnd(st->parser->duration,
1102 st->codec->time_base,
1107 out_pkt.stream_index = st->index;
1108 out_pkt.pts = st->parser->pts;
1109 out_pkt.dts = st->parser->dts;
1110 out_pkt.pos = st->parser->pos;
1112 if (st->parser->key_frame == 1 ||
1113 (st->parser->key_frame == -1 &&
1114 st->parser->pict_type == AV_PICTURE_TYPE_I))
1115 out_pkt.flags |= AV_PKT_FLAG_KEY;
1117 compute_pkt_fields(s, st, st->parser, &out_pkt);
1119 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1120 out_pkt.flags & AV_PKT_FLAG_KEY) {
1121 ff_reduce_index(s, st->index);
1122 av_add_index_entry(st, st->parser->frame_offset, out_pkt.dts,
1123 0, 0, AVINDEX_KEYFRAME);
1126 if (out_pkt.data == pkt->data && out_pkt.size == pkt->size) {
1127 out_pkt.destruct = pkt->destruct;
1128 pkt->destruct = NULL;
1130 if ((ret = av_dup_packet(&out_pkt)) < 0)
1133 if (!add_to_pktbuf(&s->parse_queue, &out_pkt, &s->parse_queue_end)) {
1134 av_free_packet(&out_pkt);
1135 ret = AVERROR(ENOMEM);
1141 /* end of the stream => close and free the parser */
1142 if (pkt == &flush_pkt) {
1143 av_parser_close(st->parser);
1148 av_free_packet(pkt);
1152 static int read_from_packet_buffer(AVPacketList **pkt_buffer,
1153 AVPacketList **pkt_buffer_end,
1157 av_assert0(*pkt_buffer);
1160 *pkt_buffer = pktl->next;
1162 *pkt_buffer_end = NULL;
1167 static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1169 int ret = 0, i, got_packet = 0;
1171 av_init_packet(pkt);
1173 while (!got_packet && !s->parse_queue) {
1177 /* read next packet */
1178 ret = ff_read_packet(s, &cur_pkt);
1180 if (ret == AVERROR(EAGAIN))
1182 /* flush the parsers */
1183 for(i = 0; i < s->nb_streams; i++) {
1185 if (st->parser && st->need_parsing)
1186 parse_packet(s, NULL, st->index);
1188 /* all remaining packets are now in parse_queue =>
1189 * really terminate parsing */
1193 st = s->streams[cur_pkt.stream_index];
1195 if (cur_pkt.pts != AV_NOPTS_VALUE &&
1196 cur_pkt.dts != AV_NOPTS_VALUE &&
1197 cur_pkt.pts < cur_pkt.dts) {
1198 av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
1199 cur_pkt.stream_index,
1204 if (s->debug & FF_FDEBUG_TS)
1205 av_log(s, AV_LOG_DEBUG, "ff_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1206 cur_pkt.stream_index,
1213 if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1214 st->parser = av_parser_init(st->codec->codec_id);
1216 /* no parser available: just output the raw packets */
1217 st->need_parsing = AVSTREAM_PARSE_NONE;
1218 } else if(st->need_parsing == AVSTREAM_PARSE_HEADERS) {
1219 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1220 } else if(st->need_parsing == AVSTREAM_PARSE_FULL_ONCE) {
1221 st->parser->flags |= PARSER_FLAG_ONCE;
1225 if (!st->need_parsing || !st->parser) {
1226 /* no parsing needed: we just output the packet as is */
1228 compute_pkt_fields(s, st, NULL, pkt);
1229 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1230 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1231 ff_reduce_index(s, st->index);
1232 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1235 } else if (st->discard < AVDISCARD_ALL) {
1236 if ((ret = parse_packet(s, &cur_pkt, cur_pkt.stream_index)) < 0)
1240 av_free_packet(&cur_pkt);
1244 if (!got_packet && s->parse_queue)
1245 ret = read_from_packet_buffer(&s->parse_queue, &s->parse_queue_end, pkt);
1247 if(s->debug & FF_FDEBUG_TS)
1248 av_log(s, AV_LOG_DEBUG, "read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1259 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1261 const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1265 return s->packet_buffer ? read_from_packet_buffer(&s->packet_buffer,
1266 &s->packet_buffer_end,
1268 read_frame_internal(s, pkt);
1272 AVPacketList *pktl = s->packet_buffer;
1275 AVPacket *next_pkt = &pktl->pkt;
1277 if (next_pkt->dts != AV_NOPTS_VALUE) {
1278 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1279 while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1280 if (pktl->pkt.stream_index == next_pkt->stream_index &&
1281 (av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)) < 0) &&
1282 av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) { //not b frame
1283 next_pkt->pts = pktl->pkt.dts;
1287 pktl = s->packet_buffer;
1290 /* read packet from packet buffer, if there is data */
1291 if (!(next_pkt->pts == AV_NOPTS_VALUE &&
1292 next_pkt->dts != AV_NOPTS_VALUE && !eof))
1293 return read_from_packet_buffer(&s->packet_buffer,
1294 &s->packet_buffer_end, pkt);
1297 ret = read_frame_internal(s, pkt);
1299 if (pktl && ret != AVERROR(EAGAIN)) {
1306 if (av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1307 &s->packet_buffer_end)) < 0)
1308 return AVERROR(ENOMEM);
1312 /* XXX: suppress the packet queue */
1313 static void flush_packet_queue(AVFormatContext *s)
1315 free_packet_buffer(&s->parse_queue, &s->parse_queue_end);
1316 free_packet_buffer(&s->packet_buffer, &s->packet_buffer_end);
1317 free_packet_buffer(&s->raw_packet_buffer, &s->raw_packet_buffer_end);
1319 s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1322 /*******************************************************/
1325 int av_find_default_stream_index(AVFormatContext *s)
1327 int first_audio_index = -1;
1331 if (s->nb_streams <= 0)
1333 for(i = 0; i < s->nb_streams; i++) {
1335 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1336 !(st->disposition & AV_DISPOSITION_ATTACHED_PIC)) {
1339 if (first_audio_index < 0 && st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1340 first_audio_index = i;
1342 return first_audio_index >= 0 ? first_audio_index : 0;
1346 * Flush the frame reader.
1348 void ff_read_frame_flush(AVFormatContext *s)
1353 flush_packet_queue(s);
1355 /* for each stream, reset read state */
1356 for(i = 0; i < s->nb_streams; i++) {
1360 av_parser_close(st->parser);
1363 st->last_IP_pts = AV_NOPTS_VALUE;
1364 st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1365 st->reference_dts = AV_NOPTS_VALUE;
1367 st->probe_packets = MAX_PROBE_PACKETS;
1369 for(j=0; j<MAX_REORDER_DELAY+1; j++)
1370 st->pts_buffer[j]= AV_NOPTS_VALUE;
1374 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1378 for(i = 0; i < s->nb_streams; i++) {
1379 AVStream *st = s->streams[i];
1381 st->cur_dts = av_rescale(timestamp,
1382 st->time_base.den * (int64_t)ref_st->time_base.num,
1383 st->time_base.num * (int64_t)ref_st->time_base.den);
1387 void ff_reduce_index(AVFormatContext *s, int stream_index)
1389 AVStream *st= s->streams[stream_index];
1390 unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1392 if((unsigned)st->nb_index_entries >= max_entries){
1394 for(i=0; 2*i<st->nb_index_entries; i++)
1395 st->index_entries[i]= st->index_entries[2*i];
1396 st->nb_index_entries= i;
1400 int ff_add_index_entry(AVIndexEntry **index_entries,
1401 int *nb_index_entries,
1402 unsigned int *index_entries_allocated_size,
1403 int64_t pos, int64_t timestamp, int size, int distance, int flags)
1405 AVIndexEntry *entries, *ie;
1408 if((unsigned)*nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1411 entries = av_fast_realloc(*index_entries,
1412 index_entries_allocated_size,
1413 (*nb_index_entries + 1) *
1414 sizeof(AVIndexEntry));
1418 *index_entries= entries;
1420 index= ff_index_search_timestamp(*index_entries, *nb_index_entries, timestamp, AVSEEK_FLAG_ANY);
1423 index= (*nb_index_entries)++;
1424 ie= &entries[index];
1425 assert(index==0 || ie[-1].timestamp < timestamp);
1427 ie= &entries[index];
1428 if(ie->timestamp != timestamp){
1429 if(ie->timestamp <= timestamp)
1431 memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(*nb_index_entries - index));
1432 (*nb_index_entries)++;
1433 }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1434 distance= ie->min_distance;
1438 ie->timestamp = timestamp;
1439 ie->min_distance= distance;
1446 int av_add_index_entry(AVStream *st,
1447 int64_t pos, int64_t timestamp, int size, int distance, int flags)
1449 return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1450 &st->index_entries_allocated_size, pos,
1451 timestamp, size, distance, flags);
1454 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1455 int64_t wanted_timestamp, int flags)
1463 //optimize appending index entries at the end
1464 if(b && entries[b-1].timestamp < wanted_timestamp)
1469 timestamp = entries[m].timestamp;
1470 if(timestamp >= wanted_timestamp)
1472 if(timestamp <= wanted_timestamp)
1475 m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1477 if(!(flags & AVSEEK_FLAG_ANY)){
1478 while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1479 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1488 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1491 return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
1492 wanted_timestamp, flags);
1495 int ff_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags)
1497 AVInputFormat *avif= s->iformat;
1498 int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1499 int64_t ts_min, ts_max, ts;
1504 if (stream_index < 0)
1507 av_dlog(s, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1510 ts_min= AV_NOPTS_VALUE;
1511 pos_limit= -1; //gcc falsely says it may be uninitialized
1513 st= s->streams[stream_index];
1514 if(st->index_entries){
1517 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()
1518 index= FFMAX(index, 0);
1519 e= &st->index_entries[index];
1521 if(e->timestamp <= target_ts || e->pos == e->min_distance){
1523 ts_min= e->timestamp;
1524 av_dlog(s, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1530 index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1531 assert(index < st->nb_index_entries);
1533 e= &st->index_entries[index];
1534 assert(e->timestamp >= target_ts);
1536 ts_max= e->timestamp;
1537 pos_limit= pos_max - e->min_distance;
1538 av_dlog(s, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1539 pos_max,pos_limit, ts_max);
1543 pos= ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1548 if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
1551 ff_update_cur_dts(s, st, ts);
1556 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
1557 int64_t pos_min, int64_t pos_max, int64_t pos_limit,
1558 int64_t ts_min, int64_t ts_max, int flags, int64_t *ts_ret,
1559 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1562 int64_t start_pos, filesize;
1565 av_dlog(s, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1567 if(ts_min == AV_NOPTS_VALUE){
1568 pos_min = s->data_offset;
1569 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1570 if (ts_min == AV_NOPTS_VALUE)
1574 if(ts_max == AV_NOPTS_VALUE){
1576 filesize = avio_size(s->pb);
1577 pos_max = filesize - 1;
1580 ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1582 }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1583 if (ts_max == AV_NOPTS_VALUE)
1587 int64_t tmp_pos= pos_max + 1;
1588 int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1589 if(tmp_ts == AV_NOPTS_VALUE)
1593 if(tmp_pos >= filesize)
1599 if(ts_min > ts_max){
1601 }else if(ts_min == ts_max){
1606 while (pos_min < pos_limit) {
1607 av_dlog(s, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1608 pos_min, pos_max, ts_min, ts_max);
1609 assert(pos_limit <= pos_max);
1612 int64_t approximate_keyframe_distance= pos_max - pos_limit;
1613 // interpolate position (better than dichotomy)
1614 pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1615 + pos_min - approximate_keyframe_distance;
1616 }else if(no_change==1){
1617 // bisection, if interpolation failed to change min or max pos last time
1618 pos = (pos_min + pos_limit)>>1;
1620 /* linear search if bisection failed, can only happen if there
1621 are very few or no keyframes between min/max */
1626 else if(pos > pos_limit)
1630 ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1635 av_dlog(s, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64" target:%"PRId64" limit:%"PRId64" start:%"PRId64" noc:%d\n",
1636 pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts,
1637 pos_limit, start_pos, no_change);
1638 if(ts == AV_NOPTS_VALUE){
1639 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1642 assert(ts != AV_NOPTS_VALUE);
1643 if (target_ts <= ts) {
1644 pos_limit = start_pos - 1;
1648 if (target_ts >= ts) {
1654 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1655 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
1657 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1659 ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1660 av_dlog(s, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1661 pos, ts_min, target_ts, ts_max);
1666 static int seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1667 int64_t pos_min, pos_max;
1669 pos_min = s->data_offset;
1670 pos_max = avio_size(s->pb) - 1;
1672 if (pos < pos_min) pos= pos_min;
1673 else if(pos > pos_max) pos= pos_max;
1675 avio_seek(s->pb, pos, SEEK_SET);
1680 static int seek_frame_generic(AVFormatContext *s,
1681 int stream_index, int64_t timestamp, int flags)
1688 st = s->streams[stream_index];
1690 index = av_index_search_timestamp(st, timestamp, flags);
1692 if(index < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
1695 if(index < 0 || index==st->nb_index_entries-1){
1698 if(st->nb_index_entries){
1699 assert(st->index_entries);
1700 ie= &st->index_entries[st->nb_index_entries-1];
1701 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1703 ff_update_cur_dts(s, st, ie->timestamp);
1705 if ((ret = avio_seek(s->pb, s->data_offset, SEEK_SET)) < 0)
1711 read_status = av_read_frame(s, &pkt);
1712 } while (read_status == AVERROR(EAGAIN));
1713 if (read_status < 0)
1715 av_free_packet(&pkt);
1716 if(stream_index == pkt.stream_index){
1717 if((pkt.flags & AV_PKT_FLAG_KEY) && pkt.dts > timestamp)
1721 index = av_index_search_timestamp(st, timestamp, flags);
1726 ff_read_frame_flush(s);
1727 if (s->iformat->read_seek){
1728 if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1731 ie = &st->index_entries[index];
1732 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1734 ff_update_cur_dts(s, st, ie->timestamp);
1739 static int seek_frame_internal(AVFormatContext *s, int stream_index,
1740 int64_t timestamp, int flags)
1745 if (flags & AVSEEK_FLAG_BYTE) {
1746 if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
1748 ff_read_frame_flush(s);
1749 return 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 ff_read_frame_flush(s);
1765 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1772 if (s->iformat->read_timestamp && !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
1773 ff_read_frame_flush(s);
1774 return ff_seek_frame_binary(s, stream_index, timestamp, flags);
1775 } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
1776 ff_read_frame_flush(s);
1777 return seek_frame_generic(s, stream_index, timestamp, flags);
1783 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1785 int ret = seek_frame_internal(s, stream_index, timestamp, flags);
1788 queue_attached_pictures(s);
1793 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
1795 if(min_ts > ts || max_ts < ts)
1798 if (s->iformat->read_seek2) {
1800 ff_read_frame_flush(s);
1801 ret = s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
1804 queue_attached_pictures(s);
1808 if(s->iformat->read_timestamp){
1809 //try to seek via read_timestamp()
1812 //Fallback to old API if new is not implemented but old is
1813 //Note the old has somewat different sematics
1814 if(s->iformat->read_seek || 1)
1815 return av_seek_frame(s, stream_index, ts, flags | (ts - min_ts > (uint64_t)(max_ts - ts) ? AVSEEK_FLAG_BACKWARD : 0));
1817 // try some generic seek like seek_frame_generic() but with new ts semantics
1820 /*******************************************************/
1823 * Return TRUE if the stream has accurate duration in any stream.
1825 * @return TRUE if the stream has accurate duration for at least one component.
1827 static int has_duration(AVFormatContext *ic)
1832 for(i = 0;i < ic->nb_streams; i++) {
1833 st = ic->streams[i];
1834 if (st->duration != AV_NOPTS_VALUE)
1837 if (ic->duration != AV_NOPTS_VALUE)
1843 * Estimate the stream timings from the one of each components.
1845 * Also computes the global bitrate if possible.
1847 static void update_stream_timings(AVFormatContext *ic)
1849 int64_t start_time, start_time1, end_time, end_time1;
1850 int64_t duration, duration1, filesize;
1854 start_time = INT64_MAX;
1855 end_time = INT64_MIN;
1856 duration = INT64_MIN;
1857 for(i = 0;i < ic->nb_streams; i++) {
1858 st = ic->streams[i];
1859 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
1860 start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1861 start_time = FFMIN(start_time, start_time1);
1862 if (st->duration != AV_NOPTS_VALUE) {
1863 end_time1 = start_time1
1864 + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1865 end_time = FFMAX(end_time, end_time1);
1868 if (st->duration != AV_NOPTS_VALUE) {
1869 duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1870 duration = FFMAX(duration, duration1);
1873 if (start_time != INT64_MAX) {
1874 ic->start_time = start_time;
1875 if (end_time != INT64_MIN)
1876 duration = FFMAX(duration, end_time - start_time);
1878 if (duration != INT64_MIN) {
1879 ic->duration = duration;
1880 if (ic->pb && (filesize = avio_size(ic->pb)) > 0) {
1881 /* compute the bitrate */
1882 ic->bit_rate = (double)filesize * 8.0 * AV_TIME_BASE /
1883 (double)ic->duration;
1888 static void fill_all_stream_timings(AVFormatContext *ic)
1893 update_stream_timings(ic);
1894 for(i = 0;i < ic->nb_streams; i++) {
1895 st = ic->streams[i];
1896 if (st->start_time == AV_NOPTS_VALUE) {
1897 if(ic->start_time != AV_NOPTS_VALUE)
1898 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1899 if(ic->duration != AV_NOPTS_VALUE)
1900 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1905 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
1907 int64_t filesize, duration;
1911 /* if bit_rate is already set, we believe it */
1912 if (ic->bit_rate <= 0) {
1914 for(i=0;i<ic->nb_streams;i++) {
1915 st = ic->streams[i];
1916 if (st->codec->bit_rate > 0)
1917 bit_rate += st->codec->bit_rate;
1919 ic->bit_rate = bit_rate;
1922 /* if duration is already set, we believe it */
1923 if (ic->duration == AV_NOPTS_VALUE &&
1924 ic->bit_rate != 0) {
1925 filesize = ic->pb ? avio_size(ic->pb) : 0;
1927 for(i = 0; i < ic->nb_streams; i++) {
1928 st = ic->streams[i];
1929 duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1930 if (st->duration == AV_NOPTS_VALUE)
1931 st->duration = duration;
1937 #define DURATION_MAX_READ_SIZE 250000
1938 #define DURATION_MAX_RETRY 3
1940 /* only usable for MPEG-PS streams */
1941 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
1943 AVPacket pkt1, *pkt = &pkt1;
1945 int read_size, i, ret;
1947 int64_t filesize, offset, duration;
1950 /* flush packet queue */
1951 flush_packet_queue(ic);
1953 for (i=0; i<ic->nb_streams; i++) {
1954 st = ic->streams[i];
1955 if (st->start_time == AV_NOPTS_VALUE && st->first_dts == AV_NOPTS_VALUE)
1956 av_log(st->codec, AV_LOG_WARNING, "start time is not set in estimate_timings_from_pts\n");
1959 av_parser_close(st->parser);
1964 /* estimate the end time (duration) */
1965 /* XXX: may need to support wrapping */
1966 filesize = ic->pb ? avio_size(ic->pb) : 0;
1967 end_time = AV_NOPTS_VALUE;
1969 offset = filesize - (DURATION_MAX_READ_SIZE<<retry);
1973 avio_seek(ic->pb, offset, SEEK_SET);
1976 if (read_size >= DURATION_MAX_READ_SIZE<<(FFMAX(retry-1,0)))
1980 ret = ff_read_packet(ic, pkt);
1981 } while(ret == AVERROR(EAGAIN));
1984 read_size += pkt->size;
1985 st = ic->streams[pkt->stream_index];
1986 if (pkt->pts != AV_NOPTS_VALUE &&
1987 (st->start_time != AV_NOPTS_VALUE ||
1988 st->first_dts != AV_NOPTS_VALUE)) {
1989 duration = end_time = pkt->pts;
1990 if (st->start_time != AV_NOPTS_VALUE)
1991 duration -= st->start_time;
1993 duration -= st->first_dts;
1995 duration += 1LL<<st->pts_wrap_bits;
1997 if (st->duration == AV_NOPTS_VALUE || st->duration < duration)
1998 st->duration = duration;
2001 av_free_packet(pkt);
2003 }while( end_time==AV_NOPTS_VALUE
2004 && filesize > (DURATION_MAX_READ_SIZE<<retry)
2005 && ++retry <= DURATION_MAX_RETRY);
2007 fill_all_stream_timings(ic);
2009 avio_seek(ic->pb, old_offset, SEEK_SET);
2010 for (i=0; i<ic->nb_streams; i++) {
2012 st->cur_dts= st->first_dts;
2013 st->last_IP_pts = AV_NOPTS_VALUE;
2014 st->reference_dts = AV_NOPTS_VALUE;
2018 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2022 /* get the file size, if possible */
2023 if (ic->iformat->flags & AVFMT_NOFILE) {
2026 file_size = avio_size(ic->pb);
2027 file_size = FFMAX(0, file_size);
2030 if ((!strcmp(ic->iformat->name, "mpeg") ||
2031 !strcmp(ic->iformat->name, "mpegts")) &&
2032 file_size && ic->pb->seekable) {
2033 /* get accurate estimate from the PTSes */
2034 estimate_timings_from_pts(ic, old_offset);
2035 } else if (has_duration(ic)) {
2036 /* at least one component has timings - we use them for all
2038 fill_all_stream_timings(ic);
2040 av_log(ic, AV_LOG_WARNING, "Estimating duration from bitrate, this may be inaccurate\n");
2041 /* less precise: use bitrate info */
2042 estimate_timings_from_bit_rate(ic);
2044 update_stream_timings(ic);
2048 AVStream av_unused *st;
2049 for(i = 0;i < ic->nb_streams; i++) {
2050 st = ic->streams[i];
2051 av_dlog(ic, "%d: start_time: %0.3f duration: %0.3f\n", i,
2052 (double) st->start_time / AV_TIME_BASE,
2053 (double) st->duration / AV_TIME_BASE);
2055 av_dlog(ic, "stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2056 (double) ic->start_time / AV_TIME_BASE,
2057 (double) ic->duration / AV_TIME_BASE,
2058 ic->bit_rate / 1000);
2062 static int has_codec_parameters(AVStream *st)
2064 AVCodecContext *avctx = st->codec;
2066 switch (avctx->codec_type) {
2067 case AVMEDIA_TYPE_AUDIO:
2068 val = avctx->sample_rate && avctx->channels;
2069 if (st->info->found_decoder >= 0 && avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
2072 case AVMEDIA_TYPE_VIDEO:
2074 if (st->info->found_decoder >= 0 && avctx->pix_fmt == PIX_FMT_NONE)
2081 return avctx->codec_id != CODEC_ID_NONE && val != 0;
2084 static int has_decode_delay_been_guessed(AVStream *st)
2086 return st->codec->codec_id != CODEC_ID_H264 ||
2087 st->info->nb_decoded_frames >= 6;
2090 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
2091 static int try_decode_frame(AVStream *st, AVPacket *avpkt, AVDictionary **options)
2094 int got_picture = 1, ret = 0;
2096 AVPacket pkt = *avpkt;
2098 if (!avcodec_is_open(st->codec) && !st->info->found_decoder) {
2099 AVDictionary *thread_opt = NULL;
2101 codec = st->codec->codec ? st->codec->codec :
2102 avcodec_find_decoder(st->codec->codec_id);
2105 st->info->found_decoder = -1;
2109 /* force thread count to 1 since the h264 decoder will not extract SPS
2110 * and PPS to extradata during multi-threaded decoding */
2111 av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
2112 ret = avcodec_open2(st->codec, codec, options ? options : &thread_opt);
2114 av_dict_free(&thread_opt);
2116 st->info->found_decoder = -1;
2119 st->info->found_decoder = 1;
2120 } else if (!st->info->found_decoder)
2121 st->info->found_decoder = 1;
2123 if (st->info->found_decoder < 0)
2126 while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
2128 (!has_codec_parameters(st) ||
2129 !has_decode_delay_been_guessed(st) ||
2130 (!st->codec_info_nb_frames && st->codec->codec->capabilities & CODEC_CAP_CHANNEL_CONF))) {
2132 avcodec_get_frame_defaults(&picture);
2133 switch(st->codec->codec_type) {
2134 case AVMEDIA_TYPE_VIDEO:
2135 ret = avcodec_decode_video2(st->codec, &picture,
2136 &got_picture, &pkt);
2138 case AVMEDIA_TYPE_AUDIO:
2139 ret = avcodec_decode_audio4(st->codec, &picture, &got_picture, &pkt);
2146 st->info->nb_decoded_frames++;
2155 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum CodecID id)
2157 while (tags->id != CODEC_ID_NONE) {
2165 enum CodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2168 for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
2169 if(tag == tags[i].tag)
2172 for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
2173 if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
2176 return CODEC_ID_NONE;
2179 unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum CodecID id)
2182 for(i=0; tags && tags[i]; i++){
2183 int tag= ff_codec_get_tag(tags[i], id);
2189 enum CodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
2192 for(i=0; tags && tags[i]; i++){
2193 enum CodecID id= ff_codec_get_id(tags[i], tag);
2194 if(id!=CODEC_ID_NONE) return id;
2196 return CODEC_ID_NONE;
2199 static void compute_chapters_end(AVFormatContext *s)
2202 int64_t max_time = s->duration + ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
2204 for (i = 0; i < s->nb_chapters; i++)
2205 if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2206 AVChapter *ch = s->chapters[i];
2207 int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q, ch->time_base)
2210 for (j = 0; j < s->nb_chapters; j++) {
2211 AVChapter *ch1 = s->chapters[j];
2212 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base, ch->time_base);
2213 if (j != i && next_start > ch->start && next_start < end)
2216 ch->end = (end == INT64_MAX) ? ch->start : end;
2220 static int get_std_framerate(int i){
2221 if(i<60*12) return i*1001;
2222 else return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
2226 * Is the time base unreliable.
2227 * This is a heuristic to balance between quick acceptance of the values in
2228 * the headers vs. some extra checks.
2229 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2230 * MPEG-2 commonly misuses field repeat flags to store different framerates.
2231 * And there are "variable" fps files this needs to detect as well.
2233 static int tb_unreliable(AVCodecContext *c){
2234 if( c->time_base.den >= 101L*c->time_base.num
2235 || c->time_base.den < 5L*c->time_base.num
2236 /* || c->codec_tag == AV_RL32("DIVX")
2237 || c->codec_tag == AV_RL32("XVID")*/
2238 || c->codec_id == CODEC_ID_MPEG2VIDEO
2239 || c->codec_id == CODEC_ID_H264
2245 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
2247 int i, count, ret, read_size, j;
2249 AVPacket pkt1, *pkt;
2250 int64_t old_offset = avio_tell(ic->pb);
2251 int orig_nb_streams = ic->nb_streams; // new streams might appear, no options for those
2253 for(i=0;i<ic->nb_streams;i++) {
2255 AVDictionary *thread_opt = NULL;
2256 st = ic->streams[i];
2258 //only for the split stuff
2259 if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
2260 st->parser = av_parser_init(st->codec->codec_id);
2261 if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
2262 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2265 codec = st->codec->codec ? st->codec->codec :
2266 avcodec_find_decoder(st->codec->codec_id);
2268 /* force thread count to 1 since the h264 decoder will not extract SPS
2269 * and PPS to extradata during multi-threaded decoding */
2270 av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
2272 /* Ensure that subtitle_header is properly set. */
2273 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
2274 && codec && !st->codec->codec)
2275 avcodec_open2(st->codec, codec, options ? &options[i]
2278 //try to just open decoders, in case this is enough to get parameters
2279 if (!has_codec_parameters(st)) {
2280 if (codec && !st->codec->codec)
2281 avcodec_open2(st->codec, codec, options ? &options[i]
2285 av_dict_free(&thread_opt);
2288 for (i=0; i<ic->nb_streams; i++) {
2289 ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
2295 if (ff_check_interrupt(&ic->interrupt_callback)){
2297 av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2301 /* check if one codec still needs to be handled */
2302 for(i=0;i<ic->nb_streams;i++) {
2303 int fps_analyze_framecount = 20;
2305 st = ic->streams[i];
2306 if (!has_codec_parameters(st))
2308 /* if the timebase is coarse (like the usual millisecond precision
2309 of mkv), we need to analyze more frames to reliably arrive at
2311 if (av_q2d(st->time_base) > 0.0005)
2312 fps_analyze_framecount *= 2;
2313 if (ic->fps_probe_size >= 0)
2314 fps_analyze_framecount = ic->fps_probe_size;
2315 /* variable fps and no guess at the real fps */
2316 if( tb_unreliable(st->codec) && !(st->r_frame_rate.num && st->avg_frame_rate.num)
2317 && st->info->duration_count < fps_analyze_framecount
2318 && st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2320 if(st->parser && st->parser->parser->split && !st->codec->extradata)
2322 if (st->first_dts == AV_NOPTS_VALUE &&
2323 (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2324 st->codec->codec_type == AVMEDIA_TYPE_AUDIO))
2327 if (i == ic->nb_streams) {
2328 /* NOTE: if the format has no header, then we need to read
2329 some packets to get most of the streams, so we cannot
2331 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2332 /* if we found the info for all the codecs, we can stop */
2334 av_log(ic, AV_LOG_DEBUG, "All info found\n");
2338 /* we did not get all the codec info, but we read too much data */
2339 if (read_size >= ic->probesize) {
2341 av_log(ic, AV_LOG_DEBUG, "Probe buffer size limit %d reached\n", ic->probesize);
2345 /* NOTE: a new stream can be added there if no header in file
2346 (AVFMTCTX_NOHEADER) */
2347 ret = read_frame_internal(ic, &pkt1);
2348 if (ret == AVERROR(EAGAIN))
2353 AVPacket empty_pkt = { 0 };
2355 av_init_packet(&empty_pkt);
2357 ret = -1; /* we could not have all the codec parameters before EOF */
2358 for(i=0;i<ic->nb_streams;i++) {
2359 st = ic->streams[i];
2361 /* flush the decoders */
2362 if (st->info->found_decoder == 1) {
2364 err = try_decode_frame(st, &empty_pkt,
2365 (options && i < orig_nb_streams) ?
2366 &options[i] : NULL);
2367 } while (err > 0 && !has_codec_parameters(st));
2371 av_log(ic, AV_LOG_WARNING,
2372 "decoding for stream %d failed\n", st->index);
2373 } else if (!has_codec_parameters(st)) {
2375 avcodec_string(buf, sizeof(buf), st->codec, 0);
2376 av_log(ic, AV_LOG_WARNING,
2377 "Could not find codec parameters (%s)\n", buf);
2385 pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2386 if ((ret = av_dup_packet(pkt)) < 0)
2387 goto find_stream_info_err;
2389 read_size += pkt->size;
2391 st = ic->streams[pkt->stream_index];
2392 if (st->codec_info_nb_frames>1) {
2393 if (av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q) >= ic->max_analyze_duration) {
2394 av_log(ic, AV_LOG_WARNING, "max_analyze_duration reached\n");
2397 st->info->codec_info_duration += pkt->duration;
2400 int64_t last = st->info->last_dts;
2402 if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && pkt->dts > last){
2403 int64_t duration= pkt->dts - last;
2404 double dur= duration * av_q2d(st->time_base);
2406 // if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2407 // av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
2408 if (st->info->duration_count < 2)
2409 memset(st->info->duration_error, 0, sizeof(st->info->duration_error));
2410 for (i=1; i<FF_ARRAY_ELEMS(st->info->duration_error); i++) {
2411 int framerate= get_std_framerate(i);
2412 int ticks= lrintf(dur*framerate/(1001*12));
2413 double error = dur - (double)ticks*1001*12 / framerate;
2414 st->info->duration_error[i] += error*error;
2416 st->info->duration_count++;
2417 // ignore the first 4 values, they might have some random jitter
2418 if (st->info->duration_count > 3)
2419 st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2421 if (last == AV_NOPTS_VALUE || st->info->duration_count <= 1)
2422 st->info->last_dts = pkt->dts;
2424 if(st->parser && st->parser->parser->split && !st->codec->extradata){
2425 int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2426 if (i > 0 && i < FF_MAX_EXTRADATA_SIZE) {
2427 st->codec->extradata_size= i;
2428 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2429 if (!st->codec->extradata)
2430 return AVERROR(ENOMEM);
2431 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2432 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2436 /* if still no information, we try to open the codec and to
2437 decompress the frame. We try to avoid that in most cases as
2438 it takes longer and uses more memory. For MPEG-4, we need to
2439 decompress for QuickTime.
2441 If CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
2442 least one frame of codec data, this makes sure the codec initializes
2443 the channel configuration and does not only trust the values from the container.
2445 try_decode_frame(st, pkt, (options && i < orig_nb_streams ) ? &options[i] : NULL);
2447 st->codec_info_nb_frames++;
2451 // close codecs which were opened in try_decode_frame()
2452 for(i=0;i<ic->nb_streams;i++) {
2453 st = ic->streams[i];
2454 avcodec_close(st->codec);
2456 for(i=0;i<ic->nb_streams;i++) {
2457 st = ic->streams[i];
2458 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2459 if (st->codec_info_nb_frames>2 && !st->avg_frame_rate.num && st->info->codec_info_duration)
2460 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2461 (st->codec_info_nb_frames-2)*(int64_t)st->time_base.den,
2462 st->info->codec_info_duration*(int64_t)st->time_base.num, 60000);
2463 // the check for tb_unreliable() is not completely correct, since this is not about handling
2464 // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2465 // ipmovie.c produces.
2466 if (tb_unreliable(st->codec) && st->info->duration_count > 15 && st->info->duration_gcd > 1 && !st->r_frame_rate.num)
2467 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);
2468 if (st->info->duration_count && !st->r_frame_rate.num
2469 && tb_unreliable(st->codec) /*&&
2470 //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2471 st->time_base.num*duration_sum[i]/st->info->duration_count*101LL > st->time_base.den*/){
2473 double best_error= 2*av_q2d(st->time_base);
2474 best_error = best_error*best_error*st->info->duration_count*1000*12*30;
2476 for (j=1; j<FF_ARRAY_ELEMS(st->info->duration_error); j++) {
2477 double error = st->info->duration_error[j] * get_std_framerate(j);
2478 // if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2479 // av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
2480 if(error < best_error){
2482 num = get_std_framerate(j);
2485 // do not increase frame rate by more than 1 % in order to match a standard rate.
2486 if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
2487 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2489 }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2490 if(!st->codec->bits_per_coded_sample)
2491 st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2492 // set stream disposition based on audio service type
2493 switch (st->codec->audio_service_type) {
2494 case AV_AUDIO_SERVICE_TYPE_EFFECTS:
2495 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS; break;
2496 case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
2497 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED; break;
2498 case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
2499 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED; break;
2500 case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
2501 st->disposition = AV_DISPOSITION_COMMENT; break;
2502 case AV_AUDIO_SERVICE_TYPE_KARAOKE:
2503 st->disposition = AV_DISPOSITION_KARAOKE; break;
2508 estimate_timings(ic, old_offset);
2510 compute_chapters_end(ic);
2512 find_stream_info_err:
2513 for (i=0; i < ic->nb_streams; i++) {
2514 if (ic->streams[i]->codec)
2515 ic->streams[i]->codec->thread_count = 0;
2516 av_freep(&ic->streams[i]->info);
2521 static AVProgram *find_program_from_stream(AVFormatContext *ic, int s)
2525 for (i = 0; i < ic->nb_programs; i++)
2526 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
2527 if (ic->programs[i]->stream_index[j] == s)
2528 return ic->programs[i];
2532 int av_find_best_stream(AVFormatContext *ic,
2533 enum AVMediaType type,
2534 int wanted_stream_nb,
2536 AVCodec **decoder_ret,
2539 int i, nb_streams = ic->nb_streams;
2540 int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1;
2541 unsigned *program = NULL;
2542 AVCodec *decoder = NULL, *best_decoder = NULL;
2544 if (related_stream >= 0 && wanted_stream_nb < 0) {
2545 AVProgram *p = find_program_from_stream(ic, related_stream);
2547 program = p->stream_index;
2548 nb_streams = p->nb_stream_indexes;
2551 for (i = 0; i < nb_streams; i++) {
2552 int real_stream_index = program ? program[i] : i;
2553 AVStream *st = ic->streams[real_stream_index];
2554 AVCodecContext *avctx = st->codec;
2555 if (avctx->codec_type != type)
2557 if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
2559 if (st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED|AV_DISPOSITION_VISUAL_IMPAIRED))
2562 decoder = avcodec_find_decoder(st->codec->codec_id);
2565 ret = AVERROR_DECODER_NOT_FOUND;
2569 if (best_count >= st->codec_info_nb_frames)
2571 best_count = st->codec_info_nb_frames;
2572 ret = real_stream_index;
2573 best_decoder = decoder;
2574 if (program && i == nb_streams - 1 && ret < 0) {
2576 nb_streams = ic->nb_streams;
2577 i = 0; /* no related stream found, try again with everything */
2581 *decoder_ret = best_decoder;
2585 /*******************************************************/
2587 int av_read_play(AVFormatContext *s)
2589 if (s->iformat->read_play)
2590 return s->iformat->read_play(s);
2592 return avio_pause(s->pb, 0);
2593 return AVERROR(ENOSYS);
2596 int av_read_pause(AVFormatContext *s)
2598 if (s->iformat->read_pause)
2599 return s->iformat->read_pause(s);
2601 return avio_pause(s->pb, 1);
2602 return AVERROR(ENOSYS);
2605 void avformat_free_context(AVFormatContext *s)
2611 if (s->iformat && s->iformat->priv_class && s->priv_data)
2612 av_opt_free(s->priv_data);
2614 for(i=0;i<s->nb_streams;i++) {
2615 /* free all data in a stream component */
2618 av_parser_close(st->parser);
2620 if (st->attached_pic.data)
2621 av_free_packet(&st->attached_pic);
2622 av_dict_free(&st->metadata);
2623 av_free(st->index_entries);
2624 av_free(st->codec->extradata);
2625 av_free(st->codec->subtitle_header);
2627 av_free(st->priv_data);
2631 for(i=s->nb_programs-1; i>=0; i--) {
2632 av_dict_free(&s->programs[i]->metadata);
2633 av_freep(&s->programs[i]->stream_index);
2634 av_freep(&s->programs[i]);
2636 av_freep(&s->programs);
2637 av_freep(&s->priv_data);
2638 while(s->nb_chapters--) {
2639 av_dict_free(&s->chapters[s->nb_chapters]->metadata);
2640 av_free(s->chapters[s->nb_chapters]);
2642 av_freep(&s->chapters);
2643 av_dict_free(&s->metadata);
2644 av_freep(&s->streams);
2648 #if FF_API_CLOSE_INPUT_FILE
2649 void av_close_input_file(AVFormatContext *s)
2651 avformat_close_input(&s);
2655 void avformat_close_input(AVFormatContext **ps)
2657 AVFormatContext *s = *ps;
2658 AVIOContext *pb = (s->iformat->flags & AVFMT_NOFILE) || (s->flags & AVFMT_FLAG_CUSTOM_IO) ?
2660 flush_packet_queue(s);
2661 if (s->iformat->read_close)
2662 s->iformat->read_close(s);
2663 avformat_free_context(s);
2669 AVStream *avformat_new_stream(AVFormatContext *s, AVCodec *c)
2675 if (s->nb_streams >= INT_MAX/sizeof(*streams))
2677 streams = av_realloc(s->streams, (s->nb_streams + 1) * sizeof(*streams));
2680 s->streams = streams;
2682 st = av_mallocz(sizeof(AVStream));
2685 if (!(st->info = av_mallocz(sizeof(*st->info)))) {
2690 st->codec = avcodec_alloc_context3(c);
2692 /* no default bitrate if decoding */
2693 st->codec->bit_rate = 0;
2695 st->index = s->nb_streams;
2696 st->start_time = AV_NOPTS_VALUE;
2697 st->duration = AV_NOPTS_VALUE;
2698 /* we set the current DTS to 0 so that formats without any timestamps
2699 but durations get some timestamps, formats with some unknown
2700 timestamps have their first few packets buffered and the
2701 timestamps corrected before they are returned to the user */
2703 st->first_dts = AV_NOPTS_VALUE;
2704 st->probe_packets = MAX_PROBE_PACKETS;
2706 /* default pts setting is MPEG-like */
2707 avpriv_set_pts_info(st, 33, 1, 90000);
2708 st->last_IP_pts = AV_NOPTS_VALUE;
2709 for(i=0; i<MAX_REORDER_DELAY+1; i++)
2710 st->pts_buffer[i]= AV_NOPTS_VALUE;
2711 st->reference_dts = AV_NOPTS_VALUE;
2713 st->sample_aspect_ratio = (AVRational){0,1};
2715 s->streams[s->nb_streams++] = st;
2719 AVProgram *av_new_program(AVFormatContext *ac, int id)
2721 AVProgram *program=NULL;
2724 av_dlog(ac, "new_program: id=0x%04x\n", id);
2726 for(i=0; i<ac->nb_programs; i++)
2727 if(ac->programs[i]->id == id)
2728 program = ac->programs[i];
2731 program = av_mallocz(sizeof(AVProgram));
2734 dynarray_add(&ac->programs, &ac->nb_programs, program);
2735 program->discard = AVDISCARD_NONE;
2742 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2744 AVChapter *chapter = NULL;
2747 for(i=0; i<s->nb_chapters; i++)
2748 if(s->chapters[i]->id == id)
2749 chapter = s->chapters[i];
2752 chapter= av_mallocz(sizeof(AVChapter));
2755 dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2757 av_dict_set(&chapter->metadata, "title", title, 0);
2759 chapter->time_base= time_base;
2760 chapter->start = start;
2766 /************************************************************/
2767 /* output media file */
2769 static int validate_codec_tag(AVFormatContext *s, AVStream *st)
2771 const AVCodecTag *avctag;
2773 enum CodecID id = CODEC_ID_NONE;
2774 unsigned int tag = 0;
2777 * Check that tag + id is in the table
2778 * If neither is in the table -> OK
2779 * If tag is in the table with another id -> FAIL
2780 * If id is in the table with another tag -> FAIL unless strict < normal
2782 for (n = 0; s->oformat->codec_tag[n]; n++) {
2783 avctag = s->oformat->codec_tag[n];
2784 while (avctag->id != CODEC_ID_NONE) {
2785 if (avpriv_toupper4(avctag->tag) == avpriv_toupper4(st->codec->codec_tag)) {
2787 if (id == st->codec->codec_id)
2790 if (avctag->id == st->codec->codec_id)
2795 if (id != CODEC_ID_NONE)
2797 if (tag && (st->codec->strict_std_compliance >= FF_COMPLIANCE_NORMAL))
2802 int avformat_write_header(AVFormatContext *s, AVDictionary **options)
2806 AVDictionary *tmp = NULL;
2809 av_dict_copy(&tmp, *options, 0);
2810 if ((ret = av_opt_set_dict(s, &tmp)) < 0)
2813 // some sanity checks
2814 if (s->nb_streams == 0 && !(s->oformat->flags & AVFMT_NOSTREAMS)) {
2815 av_log(s, AV_LOG_ERROR, "no streams\n");
2816 ret = AVERROR(EINVAL);
2820 for(i=0;i<s->nb_streams;i++) {
2823 switch (st->codec->codec_type) {
2824 case AVMEDIA_TYPE_AUDIO:
2825 if(st->codec->sample_rate<=0){
2826 av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2827 ret = AVERROR(EINVAL);
2830 if(!st->codec->block_align)
2831 st->codec->block_align = st->codec->channels *
2832 av_get_bits_per_sample(st->codec->codec_id) >> 3;
2834 case AVMEDIA_TYPE_VIDEO:
2835 if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2836 av_log(s, AV_LOG_ERROR, "time base not set\n");
2837 ret = AVERROR(EINVAL);
2840 if((st->codec->width<=0 || st->codec->height<=0) && !(s->oformat->flags & AVFMT_NODIMENSIONS)){
2841 av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2842 ret = AVERROR(EINVAL);
2845 if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)){
2846 av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between muxer "
2847 "(%d/%d) and encoder layer (%d/%d)\n",
2848 st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
2849 st->codec->sample_aspect_ratio.num,
2850 st->codec->sample_aspect_ratio.den);
2851 ret = AVERROR(EINVAL);
2857 if(s->oformat->codec_tag){
2858 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)){
2859 //the current rawvideo encoding system ends up setting the wrong codec_tag for avi, we override it here
2860 st->codec->codec_tag= 0;
2862 if(st->codec->codec_tag){
2863 if (!validate_codec_tag(s, st)) {
2865 av_get_codec_tag_string(tagbuf, sizeof(tagbuf), st->codec->codec_tag);
2866 av_log(s, AV_LOG_ERROR,
2867 "Tag %s/0x%08x incompatible with output codec id '%d'\n",
2868 tagbuf, st->codec->codec_tag, st->codec->codec_id);
2869 ret = AVERROR_INVALIDDATA;
2873 st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2876 if(s->oformat->flags & AVFMT_GLOBALHEADER &&
2877 !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
2878 av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
2881 if (!s->priv_data && s->oformat->priv_data_size > 0) {
2882 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2883 if (!s->priv_data) {
2884 ret = AVERROR(ENOMEM);
2887 if (s->oformat->priv_class) {
2888 *(const AVClass**)s->priv_data= s->oformat->priv_class;
2889 av_opt_set_defaults(s->priv_data);
2890 if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
2895 /* set muxer identification string */
2896 if (s->nb_streams && !(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
2897 av_dict_set(&s->metadata, "encoder", LIBAVFORMAT_IDENT, 0);
2900 if(s->oformat->write_header){
2901 ret = s->oformat->write_header(s);
2906 /* init PTS generation */
2907 for(i=0;i<s->nb_streams;i++) {
2908 int64_t den = AV_NOPTS_VALUE;
2911 switch (st->codec->codec_type) {
2912 case AVMEDIA_TYPE_AUDIO:
2913 den = (int64_t)st->time_base.num * st->codec->sample_rate;
2915 case AVMEDIA_TYPE_VIDEO:
2916 den = (int64_t)st->time_base.num * st->codec->time_base.den;
2921 if (den != AV_NOPTS_VALUE) {
2923 ret = AVERROR_INVALIDDATA;
2926 frac_init(&st->pts, 0, 0, den);
2931 av_dict_free(options);
2940 //FIXME merge with compute_pkt_fields
2941 static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt){
2942 int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2943 int num, den, frame_size, i;
2945 av_dlog(s, "compute_pkt_fields2: pts:%"PRId64" dts:%"PRId64" cur_dts:%"PRId64" b:%d size:%d st:%d\n",
2946 pkt->pts, pkt->dts, st->cur_dts, delay, pkt->size, pkt->stream_index);
2948 /* if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2949 return AVERROR(EINVAL);*/
2951 /* duration field */
2952 if (pkt->duration == 0) {
2953 compute_frame_duration(&num, &den, st, NULL, pkt);
2955 pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
2959 if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
2962 //XXX/FIXME this is a temporary hack until all encoders output pts
2963 if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2965 // pkt->pts= st->cur_dts;
2966 pkt->pts= st->pts.val;
2969 //calculate dts from pts
2970 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
2971 st->pts_buffer[0]= pkt->pts;
2972 for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2973 st->pts_buffer[i]= pkt->pts + (i-delay-1) * pkt->duration;
2974 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2975 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2977 pkt->dts= st->pts_buffer[0];
2980 if (st->cur_dts && st->cur_dts != AV_NOPTS_VALUE &&
2981 ((!(s->oformat->flags & AVFMT_TS_NONSTRICT) &&
2982 st->cur_dts >= pkt->dts) || st->cur_dts > pkt->dts)) {
2983 av_log(s, AV_LOG_ERROR,
2984 "Application provided invalid, non monotonically increasing dts to muxer in stream %d: %"PRId64" >= %"PRId64"\n",
2985 st->index, st->cur_dts, pkt->dts);
2986 return AVERROR(EINVAL);
2988 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2989 av_log(s, AV_LOG_ERROR, "pts < dts in stream %d\n", st->index);
2990 return AVERROR(EINVAL);
2993 // av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2994 st->cur_dts= pkt->dts;
2995 st->pts.val= pkt->dts;
2998 switch (st->codec->codec_type) {
2999 case AVMEDIA_TYPE_AUDIO:
3000 frame_size = get_audio_frame_size(st->codec, pkt->size, 1);
3002 /* HACK/FIXME, we skip the initial 0 size packets as they are most
3003 likely equal to the encoder delay, but it would be better if we
3004 had the real timestamps from the encoder */
3005 if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
3006 frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
3009 case AVMEDIA_TYPE_VIDEO:
3010 frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
3018 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
3023 if (s->oformat->flags & AVFMT_ALLOW_FLUSH)
3024 return s->oformat->write_packet(s, pkt);
3028 ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt);
3030 if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3033 ret= s->oformat->write_packet(s, pkt);
3036 s->streams[pkt->stream_index]->nb_frames++;
3040 void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
3041 int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
3043 AVPacketList **next_point, *this_pktl;
3045 this_pktl = av_mallocz(sizeof(AVPacketList));
3046 this_pktl->pkt= *pkt;
3047 pkt->destruct= NULL; // do not free original but only the copy
3048 av_dup_packet(&this_pktl->pkt); // duplicate the packet if it uses non-alloced memory
3050 if(s->streams[pkt->stream_index]->last_in_packet_buffer){
3051 next_point = &(s->streams[pkt->stream_index]->last_in_packet_buffer->next);
3053 next_point = &s->packet_buffer;
3056 if(compare(s, &s->packet_buffer_end->pkt, pkt)){
3057 while(!compare(s, &(*next_point)->pkt, pkt)){
3058 next_point= &(*next_point)->next;
3062 next_point = &(s->packet_buffer_end->next);
3065 assert(!*next_point);
3067 s->packet_buffer_end= this_pktl;
3070 this_pktl->next= *next_point;
3072 s->streams[pkt->stream_index]->last_in_packet_buffer=
3073 *next_point= this_pktl;
3076 static int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
3078 AVStream *st = s->streams[ pkt ->stream_index];
3079 AVStream *st2= s->streams[ next->stream_index];
3080 int comp = av_compare_ts(next->dts, st2->time_base, pkt->dts,
3084 return pkt->stream_index < next->stream_index;
3088 int ff_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out,
3089 AVPacket *pkt, int flush)
3096 ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
3099 for(i=0; i < s->nb_streams; i++)
3100 stream_count+= !!s->streams[i]->last_in_packet_buffer;
3102 if(stream_count && (s->nb_streams == stream_count || flush)){
3103 pktl= s->packet_buffer;
3106 s->packet_buffer= pktl->next;
3107 if(!s->packet_buffer)
3108 s->packet_buffer_end= NULL;
3110 if(s->streams[out->stream_index]->last_in_packet_buffer == pktl)
3111 s->streams[out->stream_index]->last_in_packet_buffer= NULL;
3115 av_init_packet(out);
3120 #if FF_API_INTERLEAVE_PACKET
3121 int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out,
3122 AVPacket *pkt, int flush)
3124 return ff_interleave_packet_per_dts(s, out, pkt, flush);
3129 * Interleave an AVPacket correctly so it can be muxed.
3130 * @param out the interleaved packet will be output here
3131 * @param in the input packet
3132 * @param flush 1 if no further packets are available as input and all
3133 * remaining packets should be output
3134 * @return 1 if a packet was output, 0 if no packet could be output,
3135 * < 0 if an error occurred
3137 static int interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
3138 if (s->oformat->interleave_packet) {
3139 int ret = s->oformat->interleave_packet(s, out, in, flush);
3144 return ff_interleave_packet_per_dts(s, out, in, flush);
3147 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
3151 AVStream *st= s->streams[ pkt->stream_index];
3153 //FIXME/XXX/HACK drop zero sized packets
3154 if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO && pkt->size==0)
3157 av_dlog(s, "av_interleaved_write_frame size:%d dts:%"PRId64" pts:%"PRId64"\n",
3158 pkt->size, pkt->dts, pkt->pts);
3159 if((ret = compute_pkt_fields2(s, st, pkt)) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3162 if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3163 return AVERROR(EINVAL);
3165 av_dlog(s, "av_interleaved_write_frame FLUSH\n");
3171 int ret= interleave_packet(s, &opkt, pkt, flush);
3172 if(ret<=0) //FIXME cleanup needed for ret<0 ?
3175 ret= s->oformat->write_packet(s, &opkt);
3177 s->streams[opkt.stream_index]->nb_frames++;
3179 av_free_packet(&opkt);
3187 int av_write_trailer(AVFormatContext *s)
3193 ret= interleave_packet(s, &pkt, NULL, 1);
3194 if(ret<0) //FIXME cleanup needed for ret<0 ?
3199 ret= s->oformat->write_packet(s, &pkt);
3201 s->streams[pkt.stream_index]->nb_frames++;
3203 av_free_packet(&pkt);
3209 if(s->oformat->write_trailer)
3210 ret = s->oformat->write_trailer(s);
3212 for(i=0;i<s->nb_streams;i++) {
3213 av_freep(&s->streams[i]->priv_data);
3214 av_freep(&s->streams[i]->index_entries);
3216 if (s->oformat->priv_class)
3217 av_opt_free(s->priv_data);
3218 av_freep(&s->priv_data);
3222 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
3225 AVProgram *program=NULL;
3228 if (idx >= ac->nb_streams) {
3229 av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3233 for(i=0; i<ac->nb_programs; i++){
3234 if(ac->programs[i]->id != progid)
3236 program = ac->programs[i];
3237 for(j=0; j<program->nb_stream_indexes; j++)
3238 if(program->stream_index[j] == idx)
3241 tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
3244 program->stream_index = tmp;
3245 program->stream_index[program->nb_stream_indexes++] = idx;
3250 static void print_fps(double d, const char *postfix){
3251 uint64_t v= lrintf(d*100);
3252 if (v% 100 ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3253 else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3254 else av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
3257 static void dump_metadata(void *ctx, AVDictionary *m, const char *indent)
3259 if(m && !(m->count == 1 && av_dict_get(m, "language", NULL, 0))){
3260 AVDictionaryEntry *tag=NULL;
3262 av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3263 while((tag=av_dict_get(m, "", tag, AV_DICT_IGNORE_SUFFIX))) {
3264 if(strcmp("language", tag->key))
3265 av_log(ctx, AV_LOG_INFO, "%s %-16s: %s\n", indent, tag->key, tag->value);
3270 /* "user interface" functions */
3271 static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
3274 int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
3275 AVStream *st = ic->streams[i];
3276 int g = av_gcd(st->time_base.num, st->time_base.den);
3277 AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL, 0);
3278 avcodec_string(buf, sizeof(buf), st->codec, is_output);
3279 av_log(NULL, AV_LOG_INFO, " Stream #%d.%d", index, i);
3280 /* the pid is an important information, so we display it */
3281 /* XXX: add a generic system */
3282 if (flags & AVFMT_SHOW_IDS)
3283 av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
3285 av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
3286 av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames, st->time_base.num/g, st->time_base.den/g);
3287 av_log(NULL, AV_LOG_INFO, ": %s", buf);
3288 if (st->sample_aspect_ratio.num && // default
3289 av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
3290 AVRational display_aspect_ratio;
3291 av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
3292 st->codec->width*st->sample_aspect_ratio.num,
3293 st->codec->height*st->sample_aspect_ratio.den,
3295 av_log(NULL, AV_LOG_INFO, ", PAR %d:%d DAR %d:%d",
3296 st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3297 display_aspect_ratio.num, display_aspect_ratio.den);
3299 if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
3300 if(st->avg_frame_rate.den && st->avg_frame_rate.num)
3301 print_fps(av_q2d(st->avg_frame_rate), "fps");
3302 if(st->r_frame_rate.den && st->r_frame_rate.num)
3303 print_fps(av_q2d(st->r_frame_rate), "tbr");
3304 if(st->time_base.den && st->time_base.num)
3305 print_fps(1/av_q2d(st->time_base), "tbn");
3306 if(st->codec->time_base.den && st->codec->time_base.num)
3307 print_fps(1/av_q2d(st->codec->time_base), "tbc");
3309 if (st->disposition & AV_DISPOSITION_DEFAULT)
3310 av_log(NULL, AV_LOG_INFO, " (default)");
3311 if (st->disposition & AV_DISPOSITION_DUB)
3312 av_log(NULL, AV_LOG_INFO, " (dub)");
3313 if (st->disposition & AV_DISPOSITION_ORIGINAL)
3314 av_log(NULL, AV_LOG_INFO, " (original)");
3315 if (st->disposition & AV_DISPOSITION_COMMENT)
3316 av_log(NULL, AV_LOG_INFO, " (comment)");
3317 if (st->disposition & AV_DISPOSITION_LYRICS)
3318 av_log(NULL, AV_LOG_INFO, " (lyrics)");
3319 if (st->disposition & AV_DISPOSITION_KARAOKE)
3320 av_log(NULL, AV_LOG_INFO, " (karaoke)");
3321 if (st->disposition & AV_DISPOSITION_FORCED)
3322 av_log(NULL, AV_LOG_INFO, " (forced)");
3323 if (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED)
3324 av_log(NULL, AV_LOG_INFO, " (hearing impaired)");
3325 if (st->disposition & AV_DISPOSITION_VISUAL_IMPAIRED)
3326 av_log(NULL, AV_LOG_INFO, " (visual impaired)");
3327 if (st->disposition & AV_DISPOSITION_CLEAN_EFFECTS)
3328 av_log(NULL, AV_LOG_INFO, " (clean effects)");
3329 av_log(NULL, AV_LOG_INFO, "\n");
3330 dump_metadata(NULL, st->metadata, " ");
3333 void av_dump_format(AVFormatContext *ic,
3339 uint8_t *printed = ic->nb_streams ? av_mallocz(ic->nb_streams) : NULL;
3340 if (ic->nb_streams && !printed)
3343 av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3344 is_output ? "Output" : "Input",
3346 is_output ? ic->oformat->name : ic->iformat->name,
3347 is_output ? "to" : "from", url);
3348 dump_metadata(NULL, ic->metadata, " ");
3350 av_log(NULL, AV_LOG_INFO, " Duration: ");
3351 if (ic->duration != AV_NOPTS_VALUE) {
3352 int hours, mins, secs, us;
3353 secs = ic->duration / AV_TIME_BASE;
3354 us = ic->duration % AV_TIME_BASE;
3359 av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3360 (100 * us) / AV_TIME_BASE);
3362 av_log(NULL, AV_LOG_INFO, "N/A");
3364 if (ic->start_time != AV_NOPTS_VALUE) {
3366 av_log(NULL, AV_LOG_INFO, ", start: ");
3367 secs = ic->start_time / AV_TIME_BASE;
3368 us = abs(ic->start_time % AV_TIME_BASE);
3369 av_log(NULL, AV_LOG_INFO, "%d.%06d",
3370 secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
3372 av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3374 av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
3376 av_log(NULL, AV_LOG_INFO, "N/A");
3378 av_log(NULL, AV_LOG_INFO, "\n");
3380 for (i = 0; i < ic->nb_chapters; i++) {
3381 AVChapter *ch = ic->chapters[i];
3382 av_log(NULL, AV_LOG_INFO, " Chapter #%d.%d: ", index, i);
3383 av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
3384 av_log(NULL, AV_LOG_INFO, "end %f\n", ch->end * av_q2d(ch->time_base));
3386 dump_metadata(NULL, ch->metadata, " ");
3388 if(ic->nb_programs) {
3389 int j, k, total = 0;
3390 for(j=0; j<ic->nb_programs; j++) {
3391 AVDictionaryEntry *name = av_dict_get(ic->programs[j]->metadata,
3393 av_log(NULL, AV_LOG_INFO, " Program %d %s\n", ic->programs[j]->id,
3394 name ? name->value : "");
3395 dump_metadata(NULL, ic->programs[j]->metadata, " ");
3396 for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3397 dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3398 printed[ic->programs[j]->stream_index[k]] = 1;
3400 total += ic->programs[j]->nb_stream_indexes;
3402 if (total < ic->nb_streams)
3403 av_log(NULL, AV_LOG_INFO, " No Program\n");
3405 for(i=0;i<ic->nb_streams;i++)
3407 dump_stream_format(ic, i, index, is_output);
3412 #if FF_API_AV_GETTIME && CONFIG_SHARED && HAVE_SYMVER
3413 FF_SYMVER(int64_t, av_gettime, (void), "LIBAVFORMAT_54")
3415 return av_gettime();
3419 uint64_t ff_ntp_time(void)
3421 return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3424 int av_get_frame_filename(char *buf, int buf_size,
3425 const char *path, int number)
3428 char *q, buf1[20], c;
3429 int nd, len, percentd_found;
3441 while (isdigit(*p)) {
3442 nd = nd * 10 + *p++ - '0';
3445 } while (isdigit(c));
3454 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3456 if ((q - buf + len) > buf_size - 1)
3458 memcpy(q, buf1, len);
3466 if ((q - buf) < buf_size - 1)
3470 if (!percentd_found)
3479 static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3483 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3485 for(i=0;i<size;i+=16) {
3492 PRINT(" %02x", buf[i+j]);
3497 for(j=0;j<len;j++) {
3499 if (c < ' ' || c > '~')
3508 void av_hex_dump(FILE *f, uint8_t *buf, int size)
3510 hex_dump_internal(NULL, f, 0, buf, size);
3513 void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3515 hex_dump_internal(avcl, NULL, level, buf, size);
3518 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload, AVRational time_base)
3521 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3522 PRINT("stream #%d:\n", pkt->stream_index);
3523 PRINT(" keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
3524 PRINT(" duration=%0.3f\n", pkt->duration * av_q2d(time_base));
3525 /* DTS is _always_ valid after av_read_frame() */
3527 if (pkt->dts == AV_NOPTS_VALUE)
3530 PRINT("%0.3f", pkt->dts * av_q2d(time_base));
3531 /* PTS may not be known if B-frames are present. */
3533 if (pkt->pts == AV_NOPTS_VALUE)
3536 PRINT("%0.3f", pkt->pts * av_q2d(time_base));
3538 PRINT(" size=%d\n", pkt->size);
3541 av_hex_dump(f, pkt->data, pkt->size);
3544 void av_pkt_dump2(FILE *f, AVPacket *pkt, int dump_payload, AVStream *st)
3546 pkt_dump_internal(NULL, f, 0, pkt, dump_payload, st->time_base);
3549 void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload,
3552 pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, st->time_base);
3555 void av_url_split(char *proto, int proto_size,
3556 char *authorization, int authorization_size,
3557 char *hostname, int hostname_size,
3559 char *path, int path_size,
3562 const char *p, *ls, *at, *col, *brk;
3564 if (port_ptr) *port_ptr = -1;
3565 if (proto_size > 0) proto[0] = 0;
3566 if (authorization_size > 0) authorization[0] = 0;
3567 if (hostname_size > 0) hostname[0] = 0;
3568 if (path_size > 0) path[0] = 0;
3570 /* parse protocol */
3571 if ((p = strchr(url, ':'))) {
3572 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3577 /* no protocol means plain filename */
3578 av_strlcpy(path, url, path_size);
3582 /* separate path from hostname */
3583 ls = strchr(p, '/');
3585 ls = strchr(p, '?');
3587 av_strlcpy(path, ls, path_size);
3589 ls = &p[strlen(p)]; // XXX
3591 /* the rest is hostname, use that to parse auth/port */
3593 /* authorization (user[:pass]@hostname) */
3594 if ((at = strchr(p, '@')) && at < ls) {
3595 av_strlcpy(authorization, p,
3596 FFMIN(authorization_size, at + 1 - p));
3597 p = at + 1; /* skip '@' */
3600 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3602 av_strlcpy(hostname, p + 1,
3603 FFMIN(hostname_size, brk - p));
3604 if (brk[1] == ':' && port_ptr)
3605 *port_ptr = atoi(brk + 2);
3606 } else if ((col = strchr(p, ':')) && col < ls) {
3607 av_strlcpy(hostname, p,
3608 FFMIN(col + 1 - p, hostname_size));
3609 if (port_ptr) *port_ptr = atoi(col + 1);
3611 av_strlcpy(hostname, p,
3612 FFMIN(ls + 1 - p, hostname_size));
3616 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3619 static const char hex_table_uc[16] = { '0', '1', '2', '3',
3622 'C', 'D', 'E', 'F' };
3623 static const char hex_table_lc[16] = { '0', '1', '2', '3',
3626 'c', 'd', 'e', 'f' };
3627 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3629 for(i = 0; i < s; i++) {
3630 buff[i * 2] = hex_table[src[i] >> 4];
3631 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3637 int ff_hex_to_data(uint8_t *data, const char *p)
3644 p += strspn(p, SPACE_CHARS);
3647 c = toupper((unsigned char) *p++);
3648 if (c >= '0' && c <= '9')
3650 else if (c >= 'A' && c <= 'F')
3665 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
3666 unsigned int pts_num, unsigned int pts_den)
3669 if(av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)){
3670 if(new_tb.num != pts_num)
3671 av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/new_tb.num);
3673 av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3675 if(new_tb.num <= 0 || new_tb.den <= 0) {
3676 av_log(NULL, AV_LOG_ERROR, "Ignoring attempt to set invalid timebase for st:%d\n", s->index);
3679 s->time_base = new_tb;
3680 s->pts_wrap_bits = pts_wrap_bits;
3683 int ff_url_join(char *str, int size, const char *proto,
3684 const char *authorization, const char *hostname,
3685 int port, const char *fmt, ...)
3688 struct addrinfo hints = { 0 }, *ai;
3693 av_strlcatf(str, size, "%s://", proto);
3694 if (authorization && authorization[0])
3695 av_strlcatf(str, size, "%s@", authorization);
3696 #if CONFIG_NETWORK && defined(AF_INET6)
3697 /* Determine if hostname is a numerical IPv6 address,
3698 * properly escape it within [] in that case. */
3699 hints.ai_flags = AI_NUMERICHOST;
3700 if (!getaddrinfo(hostname, NULL, &hints, &ai)) {
3701 if (ai->ai_family == AF_INET6) {
3702 av_strlcat(str, "[", size);
3703 av_strlcat(str, hostname, size);
3704 av_strlcat(str, "]", size);
3706 av_strlcat(str, hostname, size);
3711 /* Not an IPv6 address, just output the plain string. */
3712 av_strlcat(str, hostname, size);
3715 av_strlcatf(str, size, ":%d", port);
3718 int len = strlen(str);
3721 vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);
3727 int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
3728 AVFormatContext *src)
3733 local_pkt.stream_index = dst_stream;
3734 if (pkt->pts != AV_NOPTS_VALUE)
3735 local_pkt.pts = av_rescale_q(pkt->pts,
3736 src->streams[pkt->stream_index]->time_base,
3737 dst->streams[dst_stream]->time_base);
3738 if (pkt->dts != AV_NOPTS_VALUE)
3739 local_pkt.dts = av_rescale_q(pkt->dts,
3740 src->streams[pkt->stream_index]->time_base,
3741 dst->streams[dst_stream]->time_base);
3742 return av_write_frame(dst, &local_pkt);
3745 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
3748 const char *ptr = str;
3750 /* Parse key=value pairs. */
3753 char *dest = NULL, *dest_end;
3754 int key_len, dest_len = 0;
3756 /* Skip whitespace and potential commas. */
3757 while (*ptr && (isspace(*ptr) || *ptr == ','))
3764 if (!(ptr = strchr(key, '=')))
3767 key_len = ptr - key;
3769 callback_get_buf(context, key, key_len, &dest, &dest_len);
3770 dest_end = dest + dest_len - 1;
3774 while (*ptr && *ptr != '\"') {
3778 if (dest && dest < dest_end)
3782 if (dest && dest < dest_end)
3790 for (; *ptr && !(isspace(*ptr) || *ptr == ','); ptr++)
3791 if (dest && dest < dest_end)
3799 int ff_find_stream_index(AVFormatContext *s, int id)
3802 for (i = 0; i < s->nb_streams; i++) {
3803 if (s->streams[i]->id == id)
3809 void ff_make_absolute_url(char *buf, int size, const char *base,
3813 /* Absolute path, relative to the current server */
3814 if (base && strstr(base, "://") && rel[0] == '/') {
3816 av_strlcpy(buf, base, size);
3817 sep = strstr(buf, "://");
3820 sep = strchr(sep, '/');
3824 av_strlcat(buf, rel, size);
3827 /* If rel actually is an absolute url, just copy it */
3828 if (!base || strstr(rel, "://") || rel[0] == '/') {
3829 av_strlcpy(buf, rel, size);
3833 av_strlcpy(buf, base, size);
3834 /* Remove the file name from the base url */
3835 sep = strrchr(buf, '/');
3840 while (av_strstart(rel, "../", NULL) && sep) {
3841 /* Remove the path delimiter at the end */
3843 sep = strrchr(buf, '/');
3844 /* If the next directory name to pop off is "..", break here */
3845 if (!strcmp(sep ? &sep[1] : buf, "..")) {
3846 /* Readd the slash we just removed */
3847 av_strlcat(buf, "/", size);
3850 /* Cut off the directory name */
3857 av_strlcat(buf, rel, size);
3860 int64_t ff_iso8601_to_unix_time(const char *datestr)
3863 struct tm time1 = {0}, time2 = {0};
3865 ret1 = strptime(datestr, "%Y - %m - %d %T", &time1);
3866 ret2 = strptime(datestr, "%Y - %m - %dT%T", &time2);
3868 return av_timegm(&time2);
3870 return av_timegm(&time1);
3872 av_log(NULL, AV_LOG_WARNING, "strptime() unavailable on this system, cannot convert "
3873 "the date string.\n");
3878 int avformat_query_codec(AVOutputFormat *ofmt, enum CodecID codec_id, int std_compliance)
3881 if (ofmt->query_codec)
3882 return ofmt->query_codec(codec_id, std_compliance);
3883 else if (ofmt->codec_tag)
3884 return !!av_codec_get_tag(ofmt->codec_tag, codec_id);
3885 else if (codec_id == ofmt->video_codec || codec_id == ofmt->audio_codec ||
3886 codec_id == ofmt->subtitle_codec)
3889 return AVERROR_PATCHWELCOME;
3892 int avformat_network_init(void)
3896 ff_network_inited_globally = 1;
3897 if ((ret = ff_network_init()) < 0)
3904 int avformat_network_deinit(void)
3913 int ff_add_param_change(AVPacket *pkt, int32_t channels,
3914 uint64_t channel_layout, int32_t sample_rate,
3915 int32_t width, int32_t height)
3921 return AVERROR(EINVAL);
3924 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
3926 if (channel_layout) {
3928 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
3932 flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
3934 if (width || height) {
3936 flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
3938 data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
3940 return AVERROR(ENOMEM);
3941 bytestream_put_le32(&data, flags);
3943 bytestream_put_le32(&data, channels);
3945 bytestream_put_le64(&data, channel_layout);
3947 bytestream_put_le32(&data, sample_rate);
3948 if (width || height) {
3949 bytestream_put_le32(&data, width);
3950 bytestream_put_le32(&data, height);
3955 const struct AVCodecTag *avformat_get_riff_video_tags(void)
3957 return ff_codec_bmp_tags;
3959 const struct AVCodecTag *avformat_get_riff_audio_tags(void)
3961 return ff_codec_wav_tags;