2 * various utility functions for use within FFmpeg
3 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23 #include "libavcodec/internal.h"
24 #include "libavcodec/opt.h"
26 #include "libavutil/avstring.h"
28 #include "audiointerleave.h"
42 * various utility functions for use within FFmpeg
45 unsigned avformat_version(void)
47 return LIBAVFORMAT_VERSION_INT;
50 const char *avformat_configuration(void)
52 return FFMPEG_CONFIGURATION;
55 const char *avformat_license(void)
57 #define LICENSE_PREFIX "libavformat license: "
58 return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;
61 /* fraction handling */
64 * f = val + (num / den) + 0.5.
66 * 'num' is normalized so that it is such as 0 <= num < den.
68 * @param f fractional number
69 * @param val integer value
70 * @param num must be >= 0
71 * @param den must be >= 1
73 static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
86 * Fractional addition to f: f = f + (incr / f->den).
88 * @param f fractional number
89 * @param incr increment, can be positive or negative
91 static void av_frac_add(AVFrac *f, int64_t incr)
104 } else if (num >= den) {
111 /** head of registered input format linked list */
112 AVInputFormat *first_iformat = NULL;
113 /** head of registered output format linked list */
114 AVOutputFormat *first_oformat = NULL;
116 AVInputFormat *av_iformat_next(AVInputFormat *f)
118 if(f) return f->next;
119 else return first_iformat;
122 AVOutputFormat *av_oformat_next(AVOutputFormat *f)
124 if(f) return f->next;
125 else return first_oformat;
128 void av_register_input_format(AVInputFormat *format)
132 while (*p != NULL) p = &(*p)->next;
137 void av_register_output_format(AVOutputFormat *format)
141 while (*p != NULL) p = &(*p)->next;
146 int av_match_ext(const char *filename, const char *extensions)
154 ext = strrchr(filename, '.');
160 while (*p != '\0' && *p != ',' && q-ext1<sizeof(ext1)-1)
163 if (!strcasecmp(ext1, ext))
173 static int match_format(const char *name, const char *names)
181 namelen = strlen(name);
182 while ((p = strchr(names, ','))) {
183 len = FFMAX(p - names, namelen);
184 if (!strncasecmp(name, names, len))
188 return !strcasecmp(name, names);
191 #if LIBAVFORMAT_VERSION_MAJOR < 53
192 AVOutputFormat *guess_format(const char *short_name, const char *filename,
193 const char *mime_type)
195 return av_guess_format(short_name, filename, mime_type);
199 AVOutputFormat *av_guess_format(const char *short_name, const char *filename,
200 const char *mime_type)
202 AVOutputFormat *fmt, *fmt_found;
203 int score_max, score;
205 /* specific test for image sequences */
206 #if CONFIG_IMAGE2_MUXER
207 if (!short_name && filename &&
208 av_filename_number_test(filename) &&
209 av_guess_image2_codec(filename) != CODEC_ID_NONE) {
210 return av_guess_format("image2", NULL, NULL);
213 /* Find the proper file type. */
217 while (fmt != NULL) {
219 if (fmt->name && short_name && !strcmp(fmt->name, short_name))
221 if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
223 if (filename && fmt->extensions &&
224 av_match_ext(filename, fmt->extensions)) {
227 if (score > score_max) {
236 #if LIBAVFORMAT_VERSION_MAJOR < 53
237 AVOutputFormat *guess_stream_format(const char *short_name, const char *filename,
238 const char *mime_type)
240 AVOutputFormat *fmt = av_guess_format(short_name, filename, mime_type);
243 AVOutputFormat *stream_fmt;
244 char stream_format_name[64];
246 snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
247 stream_fmt = av_guess_format(stream_format_name, NULL, NULL);
257 enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
258 const char *filename, const char *mime_type, enum AVMediaType type){
259 if(type == AVMEDIA_TYPE_VIDEO){
260 enum CodecID codec_id= CODEC_ID_NONE;
262 #if CONFIG_IMAGE2_MUXER
263 if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
264 codec_id= av_guess_image2_codec(filename);
267 if(codec_id == CODEC_ID_NONE)
268 codec_id= fmt->video_codec;
270 }else if(type == AVMEDIA_TYPE_AUDIO)
271 return fmt->audio_codec;
273 return CODEC_ID_NONE;
276 AVInputFormat *av_find_input_format(const char *short_name)
279 for(fmt = first_iformat; fmt != NULL; fmt = fmt->next) {
280 if (match_format(short_name, fmt->name))
286 /* memory handling */
289 int av_get_packet(ByteIOContext *s, AVPacket *pkt, int size)
291 int ret= av_new_packet(pkt, size);
296 pkt->pos= url_ftell(s);
298 ret= get_buffer(s, pkt->data, size);
302 av_shrink_packet(pkt, ret);
308 int av_filename_number_test(const char *filename)
311 return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
314 AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
316 AVInputFormat *fmt1, *fmt;
320 for(fmt1 = first_iformat; fmt1 != NULL; fmt1 = fmt1->next) {
321 if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
324 if (fmt1->read_probe) {
325 score = fmt1->read_probe(pd);
326 } else if (fmt1->extensions) {
327 if (av_match_ext(pd->filename, fmt1->extensions)) {
331 if (score > *score_max) {
334 }else if (score == *score_max)
340 AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
342 return av_probe_input_format2(pd, is_opened, &score);
345 static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st, AVProbeData *pd, int score)
348 fmt = av_probe_input_format2(pd, 1, &score);
351 av_log(s, AV_LOG_DEBUG, "Probe with size=%d, packets=%d detected %s with score=%d\n",
352 pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets, fmt->name, score);
353 if (!strcmp(fmt->name, "mp3")) {
354 st->codec->codec_id = CODEC_ID_MP3;
355 st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
356 } else if (!strcmp(fmt->name, "ac3")) {
357 st->codec->codec_id = CODEC_ID_AC3;
358 st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
359 } else if (!strcmp(fmt->name, "eac3")) {
360 st->codec->codec_id = CODEC_ID_EAC3;
361 st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
362 } else if (!strcmp(fmt->name, "mpegvideo")) {
363 st->codec->codec_id = CODEC_ID_MPEG2VIDEO;
364 st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
365 } else if (!strcmp(fmt->name, "m4v")) {
366 st->codec->codec_id = CODEC_ID_MPEG4;
367 st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
368 } else if (!strcmp(fmt->name, "h264")) {
369 st->codec->codec_id = CODEC_ID_H264;
370 st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
371 } else if (!strcmp(fmt->name, "dts")) {
372 st->codec->codec_id = CODEC_ID_DTS;
373 st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
374 } else if (!strcmp(fmt->name, "aac")) {
375 st->codec->codec_id = CODEC_ID_AAC;
376 st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
382 /************************************************************/
383 /* input media file */
386 * Open a media file from an IO stream. 'fmt' must be specified.
388 int av_open_input_stream(AVFormatContext **ic_ptr,
389 ByteIOContext *pb, const char *filename,
390 AVInputFormat *fmt, AVFormatParameters *ap)
394 AVFormatParameters default_ap;
398 memset(ap, 0, sizeof(default_ap));
401 if(!ap->prealloced_context)
402 ic = avformat_alloc_context();
406 err = AVERROR(ENOMEM);
411 ic->duration = AV_NOPTS_VALUE;
412 ic->start_time = AV_NOPTS_VALUE;
413 av_strlcpy(ic->filename, filename, sizeof(ic->filename));
415 /* allocate private data */
416 if (fmt->priv_data_size > 0) {
417 ic->priv_data = av_mallocz(fmt->priv_data_size);
418 if (!ic->priv_data) {
419 err = AVERROR(ENOMEM);
423 ic->priv_data = NULL;
426 if (ic->iformat->read_header) {
427 err = ic->iformat->read_header(ic, ap);
432 if (pb && !ic->data_offset)
433 ic->data_offset = url_ftell(ic->pb);
435 #if LIBAVFORMAT_VERSION_MAJOR < 53
436 ff_metadata_demux_compat(ic);
439 ic->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
446 av_freep(&ic->priv_data);
447 for(i=0;i<ic->nb_streams;i++) {
448 AVStream *st = ic->streams[i];
450 av_free(st->priv_data);
451 av_free(st->codec->extradata);
461 /** size of probe buffer, for guessing file type from file contents */
462 #define PROBE_BUF_MIN 2048
463 #define PROBE_BUF_MAX (1<<20)
465 int ff_probe_input_buffer(ByteIOContext **pb, AVInputFormat **fmt,
466 const char *filename, void *logctx,
467 unsigned int offset, unsigned int max_probe_size)
469 AVProbeData pd = { filename ? filename : "", NULL, -offset };
470 unsigned char *buf = NULL;
471 int ret = 0, probe_size;
473 if (!max_probe_size) {
474 max_probe_size = PROBE_BUF_MAX;
475 } else if (max_probe_size > PROBE_BUF_MAX) {
476 max_probe_size = PROBE_BUF_MAX;
477 } else if (max_probe_size < PROBE_BUF_MIN) {
478 return AVERROR(EINVAL);
481 if (offset >= max_probe_size) {
482 return AVERROR(EINVAL);
485 for(probe_size= PROBE_BUF_MIN; probe_size<=max_probe_size && !*fmt && ret >= 0;
486 probe_size = FFMIN(probe_size<<1, FFMAX(max_probe_size, probe_size+1))) {
487 int ret, score = probe_size < max_probe_size ? AVPROBE_SCORE_MAX/4 : 0;
488 int buf_offset = (probe_size == PROBE_BUF_MIN) ? 0 : probe_size>>1;
490 if (probe_size < offset) {
494 /* read probe data */
495 buf = av_realloc(buf, probe_size + AVPROBE_PADDING_SIZE);
496 if ((ret = get_buffer(*pb, buf + buf_offset, probe_size - buf_offset)) < 0) {
497 /* fail if error was not end of file, otherwise, lower score */
498 if (ret != AVERROR_EOF) {
503 ret = 0; /* error was end of file, nothing read */
506 pd.buf = &buf[offset];
508 memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE);
510 /* guess file format */
511 *fmt = av_probe_input_format2(&pd, 1, &score);
513 if(score <= AVPROBE_SCORE_MAX/4){ //this can only be true in the last iteration
514 av_log(logctx, AV_LOG_WARNING, "Format detected only with low score of %d, misdetection possible!\n", score);
516 av_log(logctx, AV_LOG_DEBUG, "Probed with size=%d and score=%d\n", probe_size, score);
522 return AVERROR_INVALIDDATA;
525 /* rewind. reuse probe buffer to avoid seeking */
526 if ((ret = ff_rewind_with_probe_data(*pb, buf, pd.buf_size)) < 0)
532 int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
535 AVFormatParameters *ap)
538 AVProbeData probe_data, *pd = &probe_data;
539 ByteIOContext *pb = NULL;
540 void *logctx= ap && ap->prealloced_context ? *ic_ptr : NULL;
544 pd->filename = filename;
549 /* guess format if no file can be opened */
550 fmt = av_probe_input_format(pd, 0);
553 /* Do not open file if the format does not need it. XXX: specific
554 hack needed to handle RTSP/TCP */
555 if (!fmt || !(fmt->flags & AVFMT_NOFILE)) {
556 /* if no file needed do not try to open one */
557 if ((err=url_fopen(&pb, filename, URL_RDONLY)) < 0) {
561 url_setbufsize(pb, buf_size);
563 if (!fmt && (err = ff_probe_input_buffer(&pb, &fmt, filename, logctx, 0, logctx ? (*ic_ptr)->probesize : 0)) < 0) {
568 /* if still no format found, error */
570 err = AVERROR_INVALIDDATA;
574 /* check filename in case an image number is expected */
575 if (fmt->flags & AVFMT_NEEDNUMBER) {
576 if (!av_filename_number_test(filename)) {
577 err = AVERROR_NUMEXPECTED;
581 err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
589 if (ap && ap->prealloced_context)
596 /*******************************************************/
598 static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
599 AVPacketList **plast_pktl){
600 AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
605 (*plast_pktl)->next = pktl;
607 *packet_buffer = pktl;
609 /* add the packet in the buffered packet list */
615 int av_read_packet(AVFormatContext *s, AVPacket *pkt)
621 AVPacketList *pktl = s->raw_packet_buffer;
625 if(s->streams[pkt->stream_index]->codec->codec_id != CODEC_ID_PROBE ||
626 !s->streams[pkt->stream_index]->probe_packets ||
627 s->raw_packet_buffer_remaining_size < pkt->size){
628 AVProbeData *pd = &s->streams[pkt->stream_index]->probe_data;
631 s->raw_packet_buffer = pktl->next;
632 s->raw_packet_buffer_remaining_size += pkt->size;
639 ret= s->iformat->read_packet(s, pkt);
641 if (!pktl || ret == AVERROR(EAGAIN))
643 for (i = 0; i < s->nb_streams; i++)
644 s->streams[i]->probe_packets = 0;
647 st= s->streams[pkt->stream_index];
649 switch(st->codec->codec_type){
650 case AVMEDIA_TYPE_VIDEO:
651 if(s->video_codec_id) st->codec->codec_id= s->video_codec_id;
653 case AVMEDIA_TYPE_AUDIO:
654 if(s->audio_codec_id) st->codec->codec_id= s->audio_codec_id;
656 case AVMEDIA_TYPE_SUBTITLE:
657 if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
661 if(!pktl && (st->codec->codec_id != CODEC_ID_PROBE ||
665 add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
666 s->raw_packet_buffer_remaining_size -= pkt->size;
668 if(st->codec->codec_id == CODEC_ID_PROBE){
669 AVProbeData *pd = &st->probe_data;
670 av_log(s, AV_LOG_DEBUG, "probing stream %d\n", st->index);
673 pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
674 memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
675 pd->buf_size += pkt->size;
676 memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
678 if(av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)){
679 //FIXME we dont reduce score to 0 for the case of running out of buffer space in bytes
680 set_codec_from_probe_data(s, st, pd, st->probe_packets > 0 ? AVPROBE_SCORE_MAX/4 : 0);
681 if(st->codec->codec_id != CODEC_ID_PROBE){
684 av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
691 /**********************************************************/
694 * Get the number of samples of an audio frame. Return -1 on error.
696 static int get_audio_frame_size(AVCodecContext *enc, int size)
700 if(enc->codec_id == CODEC_ID_VORBIS)
703 if (enc->frame_size <= 1) {
704 int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
706 if (bits_per_sample) {
707 if (enc->channels == 0)
709 frame_size = (size << 3) / (bits_per_sample * enc->channels);
711 /* used for example by ADPCM codecs */
712 if (enc->bit_rate == 0)
714 frame_size = ((int64_t)size * 8 * enc->sample_rate) / enc->bit_rate;
717 frame_size = enc->frame_size;
724 * Return the frame duration in seconds. Return 0 if not available.
726 static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
727 AVCodecParserContext *pc, AVPacket *pkt)
733 switch(st->codec->codec_type) {
734 case AVMEDIA_TYPE_VIDEO:
735 if(st->time_base.num*1000LL > st->time_base.den){
736 *pnum = st->time_base.num;
737 *pden = st->time_base.den;
738 }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
739 *pnum = st->codec->time_base.num;
740 *pden = st->codec->time_base.den;
741 if (pc && pc->repeat_pict) {
742 *pnum = (*pnum) * (1 + pc->repeat_pict);
744 //If this codec can be interlaced or progressive then we need a parser to compute duration of a packet
745 //Thus if we have no parser in such case leave duration undefined.
746 if(st->codec->ticks_per_frame>1 && !pc){
751 case AVMEDIA_TYPE_AUDIO:
752 frame_size = get_audio_frame_size(st->codec, pkt->size);
756 *pden = st->codec->sample_rate;
763 static int is_intra_only(AVCodecContext *enc){
764 if(enc->codec_type == AVMEDIA_TYPE_AUDIO){
766 }else if(enc->codec_type == AVMEDIA_TYPE_VIDEO){
767 switch(enc->codec_id){
769 case CODEC_ID_MJPEGB:
771 case CODEC_ID_RAWVIDEO:
772 case CODEC_ID_DVVIDEO:
773 case CODEC_ID_HUFFYUV:
774 case CODEC_ID_FFVHUFF:
779 case CODEC_ID_JPEG2000:
787 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
788 int64_t dts, int64_t pts)
790 AVStream *st= s->streams[stream_index];
791 AVPacketList *pktl= s->packet_buffer;
793 if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE)
796 st->first_dts= dts - st->cur_dts;
799 for(; pktl; pktl= pktl->next){
800 if(pktl->pkt.stream_index != stream_index)
802 //FIXME think more about this check
803 if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
804 pktl->pkt.pts += st->first_dts;
806 if(pktl->pkt.dts != AV_NOPTS_VALUE)
807 pktl->pkt.dts += st->first_dts;
809 if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
810 st->start_time= pktl->pkt.pts;
812 if (st->start_time == AV_NOPTS_VALUE)
813 st->start_time = pts;
816 static void update_initial_durations(AVFormatContext *s, AVStream *st, AVPacket *pkt)
818 AVPacketList *pktl= s->packet_buffer;
821 if(st->first_dts != AV_NOPTS_VALUE){
822 cur_dts= st->first_dts;
823 for(; pktl; pktl= pktl->next){
824 if(pktl->pkt.stream_index == pkt->stream_index){
825 if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
827 cur_dts -= pkt->duration;
830 pktl= s->packet_buffer;
831 st->first_dts = cur_dts;
832 }else if(st->cur_dts)
835 for(; pktl; pktl= pktl->next){
836 if(pktl->pkt.stream_index != pkt->stream_index)
838 if(pktl->pkt.pts == pktl->pkt.dts && pktl->pkt.dts == AV_NOPTS_VALUE
839 && !pktl->pkt.duration){
840 pktl->pkt.dts= cur_dts;
841 if(!st->codec->has_b_frames)
842 pktl->pkt.pts= cur_dts;
843 cur_dts += pkt->duration;
844 pktl->pkt.duration= pkt->duration;
848 if(st->first_dts == AV_NOPTS_VALUE)
849 st->cur_dts= cur_dts;
852 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
853 AVCodecParserContext *pc, AVPacket *pkt)
855 int num, den, presentation_delayed, delay, i;
858 if (s->flags & AVFMT_FLAG_NOFILLIN)
861 if((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
862 pkt->dts= AV_NOPTS_VALUE;
864 if (st->codec->codec_id != CODEC_ID_H264 && pc && pc->pict_type == FF_B_TYPE)
865 //FIXME Set low_delay = 0 when has_b_frames = 1
866 st->codec->has_b_frames = 1;
868 /* do we have a video B-frame ? */
869 delay= st->codec->has_b_frames;
870 presentation_delayed = 0;
871 /* XXX: need has_b_frame, but cannot get it if the codec is
874 pc && pc->pict_type != FF_B_TYPE)
875 presentation_delayed = 1;
877 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
878 /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
879 pkt->dts -= 1LL<<st->pts_wrap_bits;
882 // some mpeg2 in mpeg-ps lack dts (issue171 / input_file.mpg)
883 // we take the conservative approach and discard both
884 // Note, if this is misbehaving for a H.264 file then possibly presentation_delayed is not set correctly.
885 if(delay==1 && pkt->dts == pkt->pts && pkt->dts != AV_NOPTS_VALUE && presentation_delayed){
886 av_log(s, AV_LOG_WARNING, "invalid dts/pts combination\n");
887 pkt->dts= pkt->pts= AV_NOPTS_VALUE;
890 if (pkt->duration == 0) {
891 compute_frame_duration(&num, &den, st, pc, pkt);
893 pkt->duration = av_rescale_rnd(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num, AV_ROUND_DOWN);
895 if(pkt->duration != 0 && s->packet_buffer)
896 update_initial_durations(s, st, pkt);
900 /* correct timestamps with byte offset if demuxers only have timestamps
901 on packet boundaries */
902 if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
903 /* this will estimate bitrate based on this frame's duration and size */
904 offset = av_rescale(pc->offset, pkt->duration, pkt->size);
905 if(pkt->pts != AV_NOPTS_VALUE)
907 if(pkt->dts != AV_NOPTS_VALUE)
911 if (pc && pc->dts_sync_point >= 0) {
912 // we have synchronization info from the parser
913 int64_t den = st->codec->time_base.den * (int64_t) st->time_base.num;
915 int64_t num = st->codec->time_base.num * (int64_t) st->time_base.den;
916 if (pkt->dts != AV_NOPTS_VALUE) {
917 // got DTS from the stream, update reference timestamp
918 st->reference_dts = pkt->dts - pc->dts_ref_dts_delta * num / den;
919 pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
920 } else if (st->reference_dts != AV_NOPTS_VALUE) {
921 // compute DTS based on reference timestamp
922 pkt->dts = st->reference_dts + pc->dts_ref_dts_delta * num / den;
923 pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
925 if (pc->dts_sync_point > 0)
926 st->reference_dts = pkt->dts; // new reference
930 /* This may be redundant, but it should not hurt. */
931 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
932 presentation_delayed = 1;
934 // 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);
935 /* interpolate PTS and DTS if they are not present */
936 //We skip H264 currently because delay and has_b_frames are not reliably set
937 if((delay==0 || (delay==1 && pc)) && st->codec->codec_id != CODEC_ID_H264){
938 if (presentation_delayed) {
939 /* DTS = decompression timestamp */
940 /* PTS = presentation timestamp */
941 if (pkt->dts == AV_NOPTS_VALUE)
942 pkt->dts = st->last_IP_pts;
943 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
944 if (pkt->dts == AV_NOPTS_VALUE)
945 pkt->dts = st->cur_dts;
947 /* this is tricky: the dts must be incremented by the duration
948 of the frame we are displaying, i.e. the last I- or P-frame */
949 if (st->last_IP_duration == 0)
950 st->last_IP_duration = pkt->duration;
951 if(pkt->dts != AV_NOPTS_VALUE)
952 st->cur_dts = pkt->dts + st->last_IP_duration;
953 st->last_IP_duration = pkt->duration;
954 st->last_IP_pts= pkt->pts;
955 /* cannot compute PTS if not present (we can compute it only
956 by knowing the future */
957 } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
958 if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
959 int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
960 int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
961 if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
962 pkt->pts += pkt->duration;
963 // av_log(NULL, AV_LOG_DEBUG, "id:%d old:%"PRId64" new:%"PRId64" dur:%d cur:%"PRId64" size:%d\n", pkt->stream_index, old_diff, new_diff, pkt->duration, st->cur_dts, pkt->size);
967 /* presentation is not delayed : PTS and DTS are the same */
968 if(pkt->pts == AV_NOPTS_VALUE)
970 update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
971 if(pkt->pts == AV_NOPTS_VALUE)
972 pkt->pts = st->cur_dts;
974 if(pkt->pts != AV_NOPTS_VALUE)
975 st->cur_dts = pkt->pts + pkt->duration;
979 if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
980 st->pts_buffer[0]= pkt->pts;
981 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
982 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
983 if(pkt->dts == AV_NOPTS_VALUE)
984 pkt->dts= st->pts_buffer[0];
985 if(st->codec->codec_id == CODEC_ID_H264){ //we skiped it above so we try here
986 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
988 if(pkt->dts > st->cur_dts)
989 st->cur_dts = pkt->dts;
992 // 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);
995 if(is_intra_only(st->codec))
996 pkt->flags |= AV_PKT_FLAG_KEY;
999 /* keyframe computation */
1000 if (pc->key_frame == 1)
1001 pkt->flags |= AV_PKT_FLAG_KEY;
1002 else if (pc->key_frame == -1 && pc->pict_type == FF_I_TYPE)
1003 pkt->flags |= AV_PKT_FLAG_KEY;
1006 pkt->convergence_duration = pc->convergence_duration;
1010 static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1015 av_init_packet(pkt);
1018 /* select current input stream component */
1021 if (!st->need_parsing || !st->parser) {
1022 /* no parsing needed: we just output the packet as is */
1023 /* raw data support */
1024 *pkt = st->cur_pkt; st->cur_pkt.data= NULL;
1025 compute_pkt_fields(s, st, NULL, pkt);
1027 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1028 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1029 ff_reduce_index(s, st->index);
1030 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1033 } else if (st->cur_len > 0 && st->discard < AVDISCARD_ALL) {
1034 len = av_parser_parse2(st->parser, st->codec, &pkt->data, &pkt->size,
1035 st->cur_ptr, st->cur_len,
1036 st->cur_pkt.pts, st->cur_pkt.dts,
1038 st->cur_pkt.pts = AV_NOPTS_VALUE;
1039 st->cur_pkt.dts = AV_NOPTS_VALUE;
1040 /* increment read pointer */
1044 /* return packet if any */
1048 pkt->stream_index = st->index;
1049 pkt->pts = st->parser->pts;
1050 pkt->dts = st->parser->dts;
1051 pkt->pos = st->parser->pos;
1052 pkt->destruct = NULL;
1053 compute_pkt_fields(s, st, st->parser, pkt);
1055 if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY){
1056 ff_reduce_index(s, st->index);
1057 av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
1058 0, 0, AVINDEX_KEYFRAME);
1065 av_free_packet(&st->cur_pkt);
1070 /* read next packet */
1071 ret = av_read_packet(s, &cur_pkt);
1073 if (ret == AVERROR(EAGAIN))
1075 /* return the last frames, if any */
1076 for(i = 0; i < s->nb_streams; i++) {
1078 if (st->parser && st->need_parsing) {
1079 av_parser_parse2(st->parser, st->codec,
1080 &pkt->data, &pkt->size,
1082 AV_NOPTS_VALUE, AV_NOPTS_VALUE,
1088 /* no more packets: really terminate parsing */
1091 st = s->streams[cur_pkt.stream_index];
1092 st->cur_pkt= cur_pkt;
1094 if(st->cur_pkt.pts != AV_NOPTS_VALUE &&
1095 st->cur_pkt.dts != AV_NOPTS_VALUE &&
1096 st->cur_pkt.pts < st->cur_pkt.dts){
1097 av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
1098 st->cur_pkt.stream_index,
1102 // av_free_packet(&st->cur_pkt);
1106 if(s->debug & FF_FDEBUG_TS)
1107 av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1108 st->cur_pkt.stream_index,
1112 st->cur_pkt.duration,
1116 st->cur_ptr = st->cur_pkt.data;
1117 st->cur_len = st->cur_pkt.size;
1118 if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1119 st->parser = av_parser_init(st->codec->codec_id);
1121 /* no parser available: just output the raw packets */
1122 st->need_parsing = AVSTREAM_PARSE_NONE;
1123 }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
1124 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1126 if(st->parser && (s->iformat->flags & AVFMT_GENERIC_INDEX)){
1127 st->parser->next_frame_offset=
1128 st->parser->cur_offset= st->cur_pkt.pos;
1133 if(s->debug & FF_FDEBUG_TS)
1134 av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1145 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1149 const int genpts= s->flags & AVFMT_FLAG_GENPTS;
1152 pktl = s->packet_buffer;
1154 AVPacket *next_pkt= &pktl->pkt;
1156 if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
1157 while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
1158 if( pktl->pkt.stream_index == next_pkt->stream_index
1159 && next_pkt->dts < pktl->pkt.dts
1160 && pktl->pkt.pts != pktl->pkt.dts //not b frame
1161 /*&& pktl->pkt.dts != AV_NOPTS_VALUE*/){
1162 next_pkt->pts= pktl->pkt.dts;
1166 pktl = s->packet_buffer;
1169 if( next_pkt->pts != AV_NOPTS_VALUE
1170 || next_pkt->dts == AV_NOPTS_VALUE
1172 /* read packet from packet buffer, if there is data */
1174 s->packet_buffer = pktl->next;
1180 int ret= av_read_frame_internal(s, pkt);
1182 if(pktl && ret != AVERROR(EAGAIN)){
1189 if(av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1190 &s->packet_buffer_end)) < 0)
1191 return AVERROR(ENOMEM);
1193 assert(!s->packet_buffer);
1194 return av_read_frame_internal(s, pkt);
1199 /* XXX: suppress the packet queue */
1200 static void flush_packet_queue(AVFormatContext *s)
1205 pktl = s->packet_buffer;
1208 s->packet_buffer = pktl->next;
1209 av_free_packet(&pktl->pkt);
1212 while(s->raw_packet_buffer){
1213 pktl = s->raw_packet_buffer;
1214 s->raw_packet_buffer = pktl->next;
1215 av_free_packet(&pktl->pkt);
1218 s->packet_buffer_end=
1219 s->raw_packet_buffer_end= NULL;
1220 s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1223 /*******************************************************/
1226 int av_find_default_stream_index(AVFormatContext *s)
1228 int first_audio_index = -1;
1232 if (s->nb_streams <= 0)
1234 for(i = 0; i < s->nb_streams; i++) {
1236 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1239 if (first_audio_index < 0 && st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1240 first_audio_index = i;
1242 return first_audio_index >= 0 ? first_audio_index : 0;
1246 * Flush the frame reader.
1248 void ff_read_frame_flush(AVFormatContext *s)
1253 flush_packet_queue(s);
1257 /* for each stream, reset read state */
1258 for(i = 0; i < s->nb_streams; i++) {
1262 av_parser_close(st->parser);
1264 av_free_packet(&st->cur_pkt);
1266 st->last_IP_pts = AV_NOPTS_VALUE;
1267 st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1268 st->reference_dts = AV_NOPTS_VALUE;
1273 st->probe_packets = MAX_PROBE_PACKETS;
1275 for(j=0; j<MAX_REORDER_DELAY+1; j++)
1276 st->pts_buffer[j]= AV_NOPTS_VALUE;
1280 void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1283 for(i = 0; i < s->nb_streams; i++) {
1284 AVStream *st = s->streams[i];
1286 st->cur_dts = av_rescale(timestamp,
1287 st->time_base.den * (int64_t)ref_st->time_base.num,
1288 st->time_base.num * (int64_t)ref_st->time_base.den);
1292 void ff_reduce_index(AVFormatContext *s, int stream_index)
1294 AVStream *st= s->streams[stream_index];
1295 unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1297 if((unsigned)st->nb_index_entries >= max_entries){
1299 for(i=0; 2*i<st->nb_index_entries; i++)
1300 st->index_entries[i]= st->index_entries[2*i];
1301 st->nb_index_entries= i;
1305 int av_add_index_entry(AVStream *st,
1306 int64_t pos, int64_t timestamp, int size, int distance, int flags)
1308 AVIndexEntry *entries, *ie;
1311 if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1314 entries = av_fast_realloc(st->index_entries,
1315 &st->index_entries_allocated_size,
1316 (st->nb_index_entries + 1) *
1317 sizeof(AVIndexEntry));
1321 st->index_entries= entries;
1323 index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
1326 index= st->nb_index_entries++;
1327 ie= &entries[index];
1328 assert(index==0 || ie[-1].timestamp < timestamp);
1330 ie= &entries[index];
1331 if(ie->timestamp != timestamp){
1332 if(ie->timestamp <= timestamp)
1334 memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
1335 st->nb_index_entries++;
1336 }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1337 distance= ie->min_distance;
1341 ie->timestamp = timestamp;
1342 ie->min_distance= distance;
1349 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1352 AVIndexEntry *entries= st->index_entries;
1353 int nb_entries= st->nb_index_entries;
1360 //optimize appending index entries at the end
1361 if(b && entries[b-1].timestamp < wanted_timestamp)
1366 timestamp = entries[m].timestamp;
1367 if(timestamp >= wanted_timestamp)
1369 if(timestamp <= wanted_timestamp)
1372 m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1374 if(!(flags & AVSEEK_FLAG_ANY)){
1375 while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1376 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1387 int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1388 AVInputFormat *avif= s->iformat;
1389 int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1390 int64_t ts_min, ts_max, ts;
1395 if (stream_index < 0)
1399 av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1403 ts_min= AV_NOPTS_VALUE;
1404 pos_limit= -1; //gcc falsely says it may be uninitialized
1406 st= s->streams[stream_index];
1407 if(st->index_entries){
1410 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()
1411 index= FFMAX(index, 0);
1412 e= &st->index_entries[index];
1414 if(e->timestamp <= target_ts || e->pos == e->min_distance){
1416 ts_min= e->timestamp;
1418 av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1425 index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1426 assert(index < st->nb_index_entries);
1428 e= &st->index_entries[index];
1429 assert(e->timestamp >= target_ts);
1431 ts_max= e->timestamp;
1432 pos_limit= pos_max - e->min_distance;
1434 av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1435 pos_max,pos_limit, ts_max);
1440 pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1445 if ((ret = url_fseek(s->pb, pos, SEEK_SET)) < 0)
1448 av_update_cur_dts(s, st, ts);
1453 int64_t av_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts, int64_t pos_min, int64_t pos_max, int64_t pos_limit, int64_t ts_min, int64_t ts_max, int flags, int64_t *ts_ret, int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t )){
1455 int64_t start_pos, filesize;
1459 av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1462 if(ts_min == AV_NOPTS_VALUE){
1463 pos_min = s->data_offset;
1464 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1465 if (ts_min == AV_NOPTS_VALUE)
1469 if(ts_max == AV_NOPTS_VALUE){
1471 filesize = url_fsize(s->pb);
1472 pos_max = filesize - 1;
1475 ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1477 }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1478 if (ts_max == AV_NOPTS_VALUE)
1482 int64_t tmp_pos= pos_max + 1;
1483 int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1484 if(tmp_ts == AV_NOPTS_VALUE)
1488 if(tmp_pos >= filesize)
1494 if(ts_min > ts_max){
1496 }else if(ts_min == ts_max){
1501 while (pos_min < pos_limit) {
1503 av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1507 assert(pos_limit <= pos_max);
1510 int64_t approximate_keyframe_distance= pos_max - pos_limit;
1511 // interpolate position (better than dichotomy)
1512 pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1513 + pos_min - approximate_keyframe_distance;
1514 }else if(no_change==1){
1515 // bisection, if interpolation failed to change min or max pos last time
1516 pos = (pos_min + pos_limit)>>1;
1518 /* linear search if bisection failed, can only happen if there
1519 are very few or no keyframes between min/max */
1524 else if(pos > pos_limit)
1528 ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1534 av_log(s, AV_LOG_DEBUG, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64" target:%"PRId64" limit:%"PRId64" start:%"PRId64" noc:%d\n",
1535 pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts, pos_limit,
1536 start_pos, no_change);
1538 if(ts == AV_NOPTS_VALUE){
1539 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1542 assert(ts != AV_NOPTS_VALUE);
1543 if (target_ts <= ts) {
1544 pos_limit = start_pos - 1;
1548 if (target_ts >= ts) {
1554 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1555 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
1558 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1560 ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1561 av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1562 pos, ts_min, target_ts, ts_max);
1568 static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1569 int64_t pos_min, pos_max;
1573 if (stream_index < 0)
1576 st= s->streams[stream_index];
1579 pos_min = s->data_offset;
1580 pos_max = url_fsize(s->pb) - 1;
1582 if (pos < pos_min) pos= pos_min;
1583 else if(pos > pos_max) pos= pos_max;
1585 url_fseek(s->pb, pos, SEEK_SET);
1588 av_update_cur_dts(s, st, ts);
1593 static int av_seek_frame_generic(AVFormatContext *s,
1594 int stream_index, int64_t timestamp, int flags)
1601 st = s->streams[stream_index];
1603 index = av_index_search_timestamp(st, timestamp, flags);
1605 if(index < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
1608 if(index < 0 || index==st->nb_index_entries-1){
1612 if(st->nb_index_entries){
1613 assert(st->index_entries);
1614 ie= &st->index_entries[st->nb_index_entries-1];
1615 if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
1617 av_update_cur_dts(s, st, ie->timestamp);
1619 if ((ret = url_fseek(s->pb, s->data_offset, SEEK_SET)) < 0)
1625 ret = av_read_frame(s, &pkt);
1626 }while(ret == AVERROR(EAGAIN));
1629 av_free_packet(&pkt);
1630 if(stream_index == pkt.stream_index){
1631 if((pkt.flags & AV_PKT_FLAG_KEY) && pkt.dts > timestamp)
1635 index = av_index_search_timestamp(st, timestamp, flags);
1640 ff_read_frame_flush(s);
1641 if (s->iformat->read_seek){
1642 if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1645 ie = &st->index_entries[index];
1646 if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
1648 av_update_cur_dts(s, st, ie->timestamp);
1653 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1658 ff_read_frame_flush(s);
1660 if(flags & AVSEEK_FLAG_BYTE)
1661 return av_seek_frame_byte(s, stream_index, timestamp, flags);
1663 if(stream_index < 0){
1664 stream_index= av_find_default_stream_index(s);
1665 if(stream_index < 0)
1668 st= s->streams[stream_index];
1669 /* timestamp for default must be expressed in AV_TIME_BASE units */
1670 timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1673 /* first, we try the format specific seek */
1674 if (s->iformat->read_seek)
1675 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1682 if(s->iformat->read_timestamp)
1683 return av_seek_frame_binary(s, stream_index, timestamp, flags);
1685 return av_seek_frame_generic(s, stream_index, timestamp, flags);
1688 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
1690 if(min_ts > ts || max_ts < ts)
1693 ff_read_frame_flush(s);
1695 if (s->iformat->read_seek2)
1696 return s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
1698 if(s->iformat->read_timestamp){
1699 //try to seek via read_timestamp()
1702 //Fallback to old API if new is not implemented but old is
1703 //Note the old has somewat different sematics
1704 if(s->iformat->read_seek || 1)
1705 return av_seek_frame(s, stream_index, ts, flags | (ts - min_ts > (uint64_t)(max_ts - ts) ? AVSEEK_FLAG_BACKWARD : 0));
1707 // try some generic seek like av_seek_frame_generic() but with new ts semantics
1710 /*******************************************************/
1713 * Returns TRUE if the stream has accurate duration in any stream.
1715 * @return TRUE if the stream has accurate duration for at least one component.
1717 static int av_has_duration(AVFormatContext *ic)
1722 for(i = 0;i < ic->nb_streams; i++) {
1723 st = ic->streams[i];
1724 if (st->duration != AV_NOPTS_VALUE)
1731 * Estimate the stream timings from the one of each components.
1733 * Also computes the global bitrate if possible.
1735 static void av_update_stream_timings(AVFormatContext *ic)
1737 int64_t start_time, start_time1, end_time, end_time1;
1738 int64_t duration, duration1;
1742 start_time = INT64_MAX;
1743 end_time = INT64_MIN;
1744 duration = INT64_MIN;
1745 for(i = 0;i < ic->nb_streams; i++) {
1746 st = ic->streams[i];
1747 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
1748 start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1749 if (start_time1 < start_time)
1750 start_time = start_time1;
1751 if (st->duration != AV_NOPTS_VALUE) {
1752 end_time1 = start_time1
1753 + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1754 if (end_time1 > end_time)
1755 end_time = end_time1;
1758 if (st->duration != AV_NOPTS_VALUE) {
1759 duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1760 if (duration1 > duration)
1761 duration = duration1;
1764 if (start_time != INT64_MAX) {
1765 ic->start_time = start_time;
1766 if (end_time != INT64_MIN) {
1767 if (end_time - start_time > duration)
1768 duration = end_time - start_time;
1771 if (duration != INT64_MIN) {
1772 ic->duration = duration;
1773 if (ic->file_size > 0) {
1774 /* compute the bitrate */
1775 ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1776 (double)ic->duration;
1781 static void fill_all_stream_timings(AVFormatContext *ic)
1786 av_update_stream_timings(ic);
1787 for(i = 0;i < ic->nb_streams; i++) {
1788 st = ic->streams[i];
1789 if (st->start_time == AV_NOPTS_VALUE) {
1790 if(ic->start_time != AV_NOPTS_VALUE)
1791 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1792 if(ic->duration != AV_NOPTS_VALUE)
1793 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1798 static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1800 int64_t filesize, duration;
1804 /* if bit_rate is already set, we believe it */
1805 if (ic->bit_rate == 0) {
1807 for(i=0;i<ic->nb_streams;i++) {
1808 st = ic->streams[i];
1809 bit_rate += st->codec->bit_rate;
1811 ic->bit_rate = bit_rate;
1814 /* if duration is already set, we believe it */
1815 if (ic->duration == AV_NOPTS_VALUE &&
1816 ic->bit_rate != 0 &&
1817 ic->file_size != 0) {
1818 filesize = ic->file_size;
1820 for(i = 0; i < ic->nb_streams; i++) {
1821 st = ic->streams[i];
1822 duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1823 if (st->duration == AV_NOPTS_VALUE)
1824 st->duration = duration;
1830 #define DURATION_MAX_READ_SIZE 250000
1831 #define DURATION_MAX_RETRY 3
1833 /* only usable for MPEG-PS streams */
1834 static void av_estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
1836 AVPacket pkt1, *pkt = &pkt1;
1838 int read_size, i, ret;
1839 int64_t end_time, start_time[MAX_STREAMS];
1840 int64_t filesize, offset, duration;
1845 /* flush packet queue */
1846 flush_packet_queue(ic);
1848 for(i=0;i<ic->nb_streams;i++) {
1849 st = ic->streams[i];
1850 if(st->start_time != AV_NOPTS_VALUE){
1851 start_time[i]= st->start_time;
1852 }else if(st->first_dts != AV_NOPTS_VALUE){
1853 start_time[i]= st->first_dts;
1855 av_log(st->codec, AV_LOG_WARNING, "start time is not set in av_estimate_timings_from_pts\n");
1858 av_parser_close(st->parser);
1860 av_free_packet(&st->cur_pkt);
1864 /* estimate the end time (duration) */
1865 /* XXX: may need to support wrapping */
1866 filesize = ic->file_size;
1867 end_time = AV_NOPTS_VALUE;
1869 offset = filesize - (DURATION_MAX_READ_SIZE<<retry);
1873 url_fseek(ic->pb, offset, SEEK_SET);
1876 if (read_size >= DURATION_MAX_READ_SIZE<<(FFMAX(retry-1,0)))
1880 ret = av_read_packet(ic, pkt);
1881 }while(ret == AVERROR(EAGAIN));
1884 read_size += pkt->size;
1885 st = ic->streams[pkt->stream_index];
1886 if (pkt->pts != AV_NOPTS_VALUE &&
1887 start_time[pkt->stream_index] != AV_NOPTS_VALUE) {
1888 end_time = pkt->pts;
1889 duration = end_time - start_time[pkt->stream_index];
1891 duration += 1LL<<st->pts_wrap_bits;
1893 if (st->duration == AV_NOPTS_VALUE ||
1894 st->duration < duration)
1895 st->duration = duration;
1898 av_free_packet(pkt);
1900 }while( end_time==AV_NOPTS_VALUE
1901 && filesize > (DURATION_MAX_READ_SIZE<<retry)
1902 && ++retry <= DURATION_MAX_RETRY);
1904 fill_all_stream_timings(ic);
1906 url_fseek(ic->pb, old_offset, SEEK_SET);
1907 for(i=0; i<ic->nb_streams; i++){
1909 st->cur_dts= st->first_dts;
1910 st->last_IP_pts = AV_NOPTS_VALUE;
1914 static void av_estimate_timings(AVFormatContext *ic, int64_t old_offset)
1918 /* get the file size, if possible */
1919 if (ic->iformat->flags & AVFMT_NOFILE) {
1922 file_size = url_fsize(ic->pb);
1926 ic->file_size = file_size;
1928 if ((!strcmp(ic->iformat->name, "mpeg") ||
1929 !strcmp(ic->iformat->name, "mpegts")) &&
1930 file_size && !url_is_streamed(ic->pb)) {
1931 /* get accurate estimate from the PTSes */
1932 av_estimate_timings_from_pts(ic, old_offset);
1933 } else if (av_has_duration(ic)) {
1934 /* at least one component has timings - we use them for all
1936 fill_all_stream_timings(ic);
1938 av_log(ic, AV_LOG_WARNING, "Estimating duration from bitrate, this may be inaccurate\n");
1939 /* less precise: use bitrate info */
1940 av_estimate_timings_from_bit_rate(ic);
1942 av_update_stream_timings(ic);
1948 for(i = 0;i < ic->nb_streams; i++) {
1949 st = ic->streams[i];
1950 printf("%d: start_time: %0.3f duration: %0.3f\n",
1951 i, (double)st->start_time / AV_TIME_BASE,
1952 (double)st->duration / AV_TIME_BASE);
1954 printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1955 (double)ic->start_time / AV_TIME_BASE,
1956 (double)ic->duration / AV_TIME_BASE,
1957 ic->bit_rate / 1000);
1962 static int has_codec_parameters(AVCodecContext *enc)
1965 switch(enc->codec_type) {
1966 case AVMEDIA_TYPE_AUDIO:
1967 val = enc->sample_rate && enc->channels && enc->sample_fmt != SAMPLE_FMT_NONE;
1968 if(!enc->frame_size &&
1969 (enc->codec_id == CODEC_ID_VORBIS ||
1970 enc->codec_id == CODEC_ID_AAC ||
1971 enc->codec_id == CODEC_ID_MP1 ||
1972 enc->codec_id == CODEC_ID_MP2 ||
1973 enc->codec_id == CODEC_ID_MP3 ||
1974 enc->codec_id == CODEC_ID_SPEEX))
1977 case AVMEDIA_TYPE_VIDEO:
1978 val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
1984 return enc->codec_id != CODEC_ID_NONE && val != 0;
1987 static int try_decode_frame(AVStream *st, AVPacket *avpkt)
1991 int got_picture, data_size, ret=0;
1994 if(!st->codec->codec){
1995 codec = avcodec_find_decoder(st->codec->codec_id);
1998 ret = avcodec_open(st->codec, codec);
2003 if(!has_codec_parameters(st->codec)){
2004 switch(st->codec->codec_type) {
2005 case AVMEDIA_TYPE_VIDEO:
2006 avcodec_get_frame_defaults(&picture);
2007 ret = avcodec_decode_video2(st->codec, &picture,
2008 &got_picture, avpkt);
2010 case AVMEDIA_TYPE_AUDIO:
2011 data_size = FFMAX(avpkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
2012 samples = av_malloc(data_size);
2015 ret = avcodec_decode_audio3(st->codec, samples,
2027 unsigned int ff_codec_get_tag(const AVCodecTag *tags, int id)
2029 while (tags->id != CODEC_ID_NONE) {
2037 enum CodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2040 for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
2041 if(tag == tags[i].tag)
2044 for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
2045 if (ff_toupper4(tag) == ff_toupper4(tags[i].tag))
2048 return CODEC_ID_NONE;
2051 unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum CodecID id)
2054 for(i=0; tags && tags[i]; i++){
2055 int tag= ff_codec_get_tag(tags[i], id);
2061 enum CodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
2064 for(i=0; tags && tags[i]; i++){
2065 enum CodecID id= ff_codec_get_id(tags[i], tag);
2066 if(id!=CODEC_ID_NONE) return id;
2068 return CODEC_ID_NONE;
2071 static void compute_chapters_end(AVFormatContext *s)
2075 for (i=0; i+1<s->nb_chapters; i++)
2076 if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2077 assert(s->chapters[i]->start <= s->chapters[i+1]->start);
2078 assert(!av_cmp_q(s->chapters[i]->time_base, s->chapters[i+1]->time_base));
2079 s->chapters[i]->end = s->chapters[i+1]->start;
2082 if (s->nb_chapters && s->chapters[i]->end == AV_NOPTS_VALUE) {
2083 assert(s->start_time != AV_NOPTS_VALUE);
2084 assert(s->duration > 0);
2085 s->chapters[i]->end = av_rescale_q(s->start_time + s->duration,
2087 s->chapters[i]->time_base);
2091 #define MAX_STD_TIMEBASES (60*12+5)
2092 static int get_std_framerate(int i){
2093 if(i<60*12) return i*1001;
2094 else return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
2098 * Is the time base unreliable.
2099 * This is a heuristic to balance between quick acceptance of the values in
2100 * the headers vs. some extra checks.
2101 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2102 * MPEG-2 commonly misuses field repeat flags to store different framerates.
2103 * And there are "variable" fps files this needs to detect as well.
2105 static int tb_unreliable(AVCodecContext *c){
2106 if( c->time_base.den >= 101L*c->time_base.num
2107 || c->time_base.den < 5L*c->time_base.num
2108 /* || c->codec_tag == AV_RL32("DIVX")
2109 || c->codec_tag == AV_RL32("XVID")*/
2110 || c->codec_id == CODEC_ID_MPEG2VIDEO
2111 || c->codec_id == CODEC_ID_H264
2117 int av_find_stream_info(AVFormatContext *ic)
2119 int i, count, ret, read_size, j;
2121 AVPacket pkt1, *pkt;
2122 int64_t last_dts[MAX_STREAMS];
2123 int64_t duration_gcd[MAX_STREAMS]={0};
2124 int duration_count[MAX_STREAMS]={0};
2125 double (*duration_error)[MAX_STD_TIMEBASES];
2126 int64_t old_offset = url_ftell(ic->pb);
2127 int64_t codec_info_duration[MAX_STREAMS]={0};
2129 duration_error = av_mallocz(MAX_STREAMS * sizeof(*duration_error));
2130 if (!duration_error) return AVERROR(ENOMEM);
2132 for(i=0;i<ic->nb_streams;i++) {
2133 st = ic->streams[i];
2134 if (st->codec->codec_id == CODEC_ID_AAC) {
2135 st->codec->sample_rate = 0;
2136 st->codec->frame_size = 0;
2137 st->codec->channels = 0;
2139 if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
2140 /* if(!st->time_base.num)
2142 if(!st->codec->time_base.num)
2143 st->codec->time_base= st->time_base;
2145 //only for the split stuff
2146 if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
2147 st->parser = av_parser_init(st->codec->codec_id);
2148 if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
2149 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2152 assert(!st->codec->codec);
2153 //try to just open decoders, in case this is enough to get parameters
2154 if(!has_codec_parameters(st->codec)){
2155 AVCodec *codec = avcodec_find_decoder(st->codec->codec_id);
2157 avcodec_open(st->codec, codec);
2161 for(i=0;i<MAX_STREAMS;i++){
2162 last_dts[i]= AV_NOPTS_VALUE;
2168 if(url_interrupt_cb()){
2169 ret= AVERROR(EINTR);
2170 av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2174 /* check if one codec still needs to be handled */
2175 for(i=0;i<ic->nb_streams;i++) {
2176 st = ic->streams[i];
2177 if (!has_codec_parameters(st->codec))
2179 /* variable fps and no guess at the real fps */
2180 if( tb_unreliable(st->codec) && !(st->r_frame_rate.num && st->avg_frame_rate.num)
2181 && duration_count[i]<20 && st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2183 if(st->parser && st->parser->parser->split && !st->codec->extradata)
2185 if(st->first_dts == AV_NOPTS_VALUE)
2188 if (i == ic->nb_streams) {
2189 /* NOTE: if the format has no header, then we need to read
2190 some packets to get most of the streams, so we cannot
2192 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2193 /* if we found the info for all the codecs, we can stop */
2195 av_log(ic, AV_LOG_DEBUG, "All info found\n");
2199 /* we did not get all the codec info, but we read too much data */
2200 if (read_size >= ic->probesize) {
2202 av_log(ic, AV_LOG_DEBUG, "MAX_READ_SIZE:%d reached\n", ic->probesize);
2206 /* NOTE: a new stream can be added there if no header in file
2207 (AVFMTCTX_NOHEADER) */
2208 ret = av_read_frame_internal(ic, &pkt1);
2209 if(ret == AVERROR(EAGAIN))
2213 ret = -1; /* we could not have all the codec parameters before EOF */
2214 for(i=0;i<ic->nb_streams;i++) {
2215 st = ic->streams[i];
2216 if (!has_codec_parameters(st->codec)){
2218 avcodec_string(buf, sizeof(buf), st->codec, 0);
2219 av_log(ic, AV_LOG_WARNING, "Could not find codec parameters (%s)\n", buf);
2227 pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2228 if(av_dup_packet(pkt) < 0) {
2229 av_free(duration_error);
2230 return AVERROR(ENOMEM);
2233 read_size += pkt->size;
2235 st = ic->streams[pkt->stream_index];
2236 if(st->codec_info_nb_frames>1) {
2237 if (st->time_base.den > 0 && av_rescale_q(codec_info_duration[st->index], st->time_base, AV_TIME_BASE_Q) >= ic->max_analyze_duration){
2238 av_log(ic, AV_LOG_WARNING, "max_analyze_duration reached\n");
2241 codec_info_duration[st->index] += pkt->duration;
2243 st->codec_info_nb_frames++;
2246 int index= pkt->stream_index;
2247 int64_t last= last_dts[index];
2248 int64_t duration= pkt->dts - last;
2250 if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
2251 double dur= duration * av_q2d(st->time_base);
2253 // if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2254 // av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
2255 if(duration_count[index] < 2)
2256 memset(duration_error[index], 0, sizeof(*duration_error));
2257 for(i=1; i<MAX_STD_TIMEBASES; i++){
2258 int framerate= get_std_framerate(i);
2259 int ticks= lrintf(dur*framerate/(1001*12));
2260 double error= dur - ticks*1001*12/(double)framerate;
2261 duration_error[index][i] += error*error;
2263 duration_count[index]++;
2264 // ignore the first 4 values, they might have some random jitter
2265 if (duration_count[index] > 3)
2266 duration_gcd[index] = av_gcd(duration_gcd[index], duration);
2268 if(last == AV_NOPTS_VALUE || duration_count[index]<=1)
2269 last_dts[pkt->stream_index]= pkt->dts;
2271 if(st->parser && st->parser->parser->split && !st->codec->extradata){
2272 int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2274 st->codec->extradata_size= i;
2275 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2276 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2277 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2281 /* if still no information, we try to open the codec and to
2282 decompress the frame. We try to avoid that in most cases as
2283 it takes longer and uses more memory. For MPEG-4, we need to
2284 decompress for QuickTime. */
2285 if (!has_codec_parameters(st->codec))
2286 try_decode_frame(st, pkt);
2291 // close codecs which were opened in try_decode_frame()
2292 for(i=0;i<ic->nb_streams;i++) {
2293 st = ic->streams[i];
2294 if(st->codec->codec)
2295 avcodec_close(st->codec);
2297 for(i=0;i<ic->nb_streams;i++) {
2298 st = ic->streams[i];
2299 if(st->codec_info_nb_frames>2 && !st->avg_frame_rate.num && codec_info_duration[i])
2300 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2301 (st->codec_info_nb_frames-2)*(int64_t)st->time_base.den,
2302 codec_info_duration[i] *(int64_t)st->time_base.num, 60000);
2303 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2304 if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample)
2305 st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2307 // the check for tb_unreliable() is not completely correct, since this is not about handling
2308 // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2309 // ipmovie.c produces.
2310 if (tb_unreliable(st->codec) && duration_count[i] > 15 && duration_gcd[i] > 1 && !st->r_frame_rate.num)
2311 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, st->time_base.den, st->time_base.num * duration_gcd[i], INT_MAX);
2312 if(duration_count[i] && !st->r_frame_rate.num
2313 && tb_unreliable(st->codec) /*&&
2314 //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2315 st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den*/){
2317 double best_error= 2*av_q2d(st->time_base);
2318 best_error= best_error*best_error*duration_count[i]*1000*12*30;
2320 for(j=1; j<MAX_STD_TIMEBASES; j++){
2321 double error= duration_error[i][j] * get_std_framerate(j);
2322 // if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2323 // av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
2324 if(error < best_error){
2326 num = get_std_framerate(j);
2329 // do not increase frame rate by more than 1 % in order to match a standard rate.
2330 if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
2331 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2334 if (!st->r_frame_rate.num){
2335 if( st->codec->time_base.den * (int64_t)st->time_base.num
2336 <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
2337 st->r_frame_rate.num = st->codec->time_base.den;
2338 st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
2340 st->r_frame_rate.num = st->time_base.den;
2341 st->r_frame_rate.den = st->time_base.num;
2344 }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2345 if(!st->codec->bits_per_coded_sample)
2346 st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2350 av_estimate_timings(ic, old_offset);
2352 compute_chapters_end(ic);
2355 /* correct DTS for B-frame streams with no timestamps */
2356 for(i=0;i<ic->nb_streams;i++) {
2357 st = ic->streams[i];
2358 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2360 ppktl = &ic->packet_buffer;
2362 if(ppkt1->stream_index != i)
2364 if(ppkt1->pkt->dts < 0)
2366 if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2368 ppkt1->pkt->dts -= delta;
2373 st->cur_dts -= delta;
2379 av_free(duration_error);
2384 /*******************************************************/
2386 int av_read_play(AVFormatContext *s)
2388 if (s->iformat->read_play)
2389 return s->iformat->read_play(s);
2391 return av_url_read_fpause(s->pb, 0);
2392 return AVERROR(ENOSYS);
2395 int av_read_pause(AVFormatContext *s)
2397 if (s->iformat->read_pause)
2398 return s->iformat->read_pause(s);
2400 return av_url_read_fpause(s->pb, 1);
2401 return AVERROR(ENOSYS);
2404 void av_close_input_stream(AVFormatContext *s)
2409 if (s->iformat->read_close)
2410 s->iformat->read_close(s);
2411 for(i=0;i<s->nb_streams;i++) {
2412 /* free all data in a stream component */
2415 av_parser_close(st->parser);
2416 av_free_packet(&st->cur_pkt);
2418 av_metadata_free(&st->metadata);
2419 av_free(st->index_entries);
2420 av_free(st->codec->extradata);
2422 #if LIBAVFORMAT_VERSION_INT < (53<<16)
2423 av_free(st->filename);
2425 av_free(st->priv_data);
2428 for(i=s->nb_programs-1; i>=0; i--) {
2429 #if LIBAVFORMAT_VERSION_INT < (53<<16)
2430 av_freep(&s->programs[i]->provider_name);
2431 av_freep(&s->programs[i]->name);
2433 av_metadata_free(&s->programs[i]->metadata);
2434 av_freep(&s->programs[i]->stream_index);
2435 av_freep(&s->programs[i]);
2437 av_freep(&s->programs);
2438 flush_packet_queue(s);
2439 av_freep(&s->priv_data);
2440 while(s->nb_chapters--) {
2441 #if LIBAVFORMAT_VERSION_INT < (53<<16)
2442 av_free(s->chapters[s->nb_chapters]->title);
2444 av_metadata_free(&s->chapters[s->nb_chapters]->metadata);
2445 av_free(s->chapters[s->nb_chapters]);
2447 av_freep(&s->chapters);
2448 av_metadata_free(&s->metadata);
2452 void av_close_input_file(AVFormatContext *s)
2454 ByteIOContext *pb = s->iformat->flags & AVFMT_NOFILE ? NULL : s->pb;
2455 av_close_input_stream(s);
2460 AVStream *av_new_stream(AVFormatContext *s, int id)
2465 if (s->nb_streams >= MAX_STREAMS)
2468 st = av_mallocz(sizeof(AVStream));
2472 st->codec= avcodec_alloc_context();
2474 /* no default bitrate if decoding */
2475 st->codec->bit_rate = 0;
2477 st->index = s->nb_streams;
2479 st->start_time = AV_NOPTS_VALUE;
2480 st->duration = AV_NOPTS_VALUE;
2481 /* we set the current DTS to 0 so that formats without any timestamps
2482 but durations get some timestamps, formats with some unknown
2483 timestamps have their first few packets buffered and the
2484 timestamps corrected before they are returned to the user */
2486 st->first_dts = AV_NOPTS_VALUE;
2487 st->probe_packets = MAX_PROBE_PACKETS;
2489 /* default pts setting is MPEG-like */
2490 av_set_pts_info(st, 33, 1, 90000);
2491 st->last_IP_pts = AV_NOPTS_VALUE;
2492 for(i=0; i<MAX_REORDER_DELAY+1; i++)
2493 st->pts_buffer[i]= AV_NOPTS_VALUE;
2494 st->reference_dts = AV_NOPTS_VALUE;
2496 st->sample_aspect_ratio = (AVRational){0,1};
2498 s->streams[s->nb_streams++] = st;
2502 AVProgram *av_new_program(AVFormatContext *ac, int id)
2504 AVProgram *program=NULL;
2508 av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2511 for(i=0; i<ac->nb_programs; i++)
2512 if(ac->programs[i]->id == id)
2513 program = ac->programs[i];
2516 program = av_mallocz(sizeof(AVProgram));
2519 dynarray_add(&ac->programs, &ac->nb_programs, program);
2520 program->discard = AVDISCARD_NONE;
2527 AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2529 AVChapter *chapter = NULL;
2532 for(i=0; i<s->nb_chapters; i++)
2533 if(s->chapters[i]->id == id)
2534 chapter = s->chapters[i];
2537 chapter= av_mallocz(sizeof(AVChapter));
2540 dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2542 #if LIBAVFORMAT_VERSION_INT < (53<<16)
2543 av_free(chapter->title);
2545 av_metadata_set2(&chapter->metadata, "title", title, 0);
2547 chapter->time_base= time_base;
2548 chapter->start = start;
2554 /************************************************************/
2555 /* output media file */
2557 int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2561 if (s->oformat->priv_data_size > 0) {
2562 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2564 return AVERROR(ENOMEM);
2566 s->priv_data = NULL;
2568 if (s->oformat->set_parameters) {
2569 ret = s->oformat->set_parameters(s, ap);
2576 static int validate_codec_tag(AVFormatContext *s, AVStream *st)
2578 const AVCodecTag *avctag;
2580 enum CodecID id = CODEC_ID_NONE;
2581 unsigned int tag = 0;
2584 * Check that tag + id is in the table
2585 * If neither is in the table -> OK
2586 * If tag is in the table with another id -> FAIL
2587 * If id is in the table with another tag -> FAIL unless strict < normal
2589 for (n = 0; s->oformat->codec_tag[n]; n++) {
2590 avctag = s->oformat->codec_tag[n];
2591 while (avctag->id != CODEC_ID_NONE) {
2592 if (ff_toupper4(avctag->tag) == ff_toupper4(st->codec->codec_tag)) {
2594 if (id == st->codec->codec_id)
2597 if (avctag->id == st->codec->codec_id)
2602 if (id != CODEC_ID_NONE)
2604 if (tag && (st->codec->strict_std_compliance >= FF_COMPLIANCE_NORMAL))
2609 int av_write_header(AVFormatContext *s)
2614 // some sanity checks
2615 if (s->nb_streams == 0) {
2616 av_log(s, AV_LOG_ERROR, "no streams\n");
2620 for(i=0;i<s->nb_streams;i++) {
2623 switch (st->codec->codec_type) {
2624 case AVMEDIA_TYPE_AUDIO:
2625 if(st->codec->sample_rate<=0){
2626 av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2629 if(!st->codec->block_align)
2630 st->codec->block_align = st->codec->channels *
2631 av_get_bits_per_sample(st->codec->codec_id) >> 3;
2633 case AVMEDIA_TYPE_VIDEO:
2634 if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2635 av_log(s, AV_LOG_ERROR, "time base not set\n");
2638 if((st->codec->width<=0 || st->codec->height<=0) && !(s->oformat->flags & AVFMT_NODIMENSIONS)){
2639 av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2642 if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)){
2643 av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between encoder and muxer layer\n");
2649 if(s->oformat->codec_tag){
2650 if(st->codec->codec_tag){
2651 if (!validate_codec_tag(s, st)) {
2652 av_log(s, AV_LOG_ERROR,
2653 "Tag 0x%08x incompatible with output codec\n",
2654 st->codec->codec_tag);
2655 return AVERROR_INVALIDDATA;
2658 st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2661 if(s->oformat->flags & AVFMT_GLOBALHEADER &&
2662 !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
2663 av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
2666 if (!s->priv_data && s->oformat->priv_data_size > 0) {
2667 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2669 return AVERROR(ENOMEM);
2672 #if LIBAVFORMAT_VERSION_MAJOR < 53
2673 ff_metadata_mux_compat(s);
2676 /* set muxer identification string */
2677 if (!(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
2681 if (!(m = av_mallocz(sizeof(AVMetadata))))
2682 return AVERROR(ENOMEM);
2683 av_metadata_set2(&m, "encoder", LIBAVFORMAT_IDENT, 0);
2684 metadata_conv(&m, s->oformat->metadata_conv, NULL);
2685 if ((t = av_metadata_get(m, "", NULL, AV_METADATA_IGNORE_SUFFIX)))
2686 av_metadata_set2(&s->metadata, t->key, t->value, 0);
2687 av_metadata_free(&m);
2690 if(s->oformat->write_header){
2691 ret = s->oformat->write_header(s);
2696 /* init PTS generation */
2697 for(i=0;i<s->nb_streams;i++) {
2698 int64_t den = AV_NOPTS_VALUE;
2701 switch (st->codec->codec_type) {
2702 case AVMEDIA_TYPE_AUDIO:
2703 den = (int64_t)st->time_base.num * st->codec->sample_rate;
2705 case AVMEDIA_TYPE_VIDEO:
2706 den = (int64_t)st->time_base.num * st->codec->time_base.den;
2711 if (den != AV_NOPTS_VALUE) {
2713 return AVERROR_INVALIDDATA;
2714 av_frac_init(&st->pts, 0, 0, den);
2720 //FIXME merge with compute_pkt_fields
2721 static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt){
2722 int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2723 int num, den, frame_size, i;
2725 // av_log(s, AV_LOG_DEBUG, "av_write_frame: pts:%"PRId64" dts:%"PRId64" cur_dts:%"PRId64" b:%d size:%d st:%d\n", pkt->pts, pkt->dts, st->cur_dts, delay, pkt->size, pkt->stream_index);
2727 /* if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2730 /* duration field */
2731 if (pkt->duration == 0) {
2732 compute_frame_duration(&num, &den, st, NULL, pkt);
2734 pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
2738 if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
2741 //XXX/FIXME this is a temporary hack until all encoders output pts
2742 if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2744 // pkt->pts= st->cur_dts;
2745 pkt->pts= st->pts.val;
2748 //calculate dts from pts
2749 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
2750 st->pts_buffer[0]= pkt->pts;
2751 for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2752 st->pts_buffer[i]= pkt->pts + (i-delay-1) * pkt->duration;
2753 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2754 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2756 pkt->dts= st->pts_buffer[0];
2759 if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2760 av_log(s, AV_LOG_ERROR,
2761 "st:%d error, non monotone timestamps %"PRId64" >= %"PRId64"\n",
2762 st->index, st->cur_dts, pkt->dts);
2765 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2766 av_log(s, AV_LOG_ERROR, "st:%d error, pts < dts\n", st->index);
2770 // av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2771 st->cur_dts= pkt->dts;
2772 st->pts.val= pkt->dts;
2775 switch (st->codec->codec_type) {
2776 case AVMEDIA_TYPE_AUDIO:
2777 frame_size = get_audio_frame_size(st->codec, pkt->size);
2779 /* HACK/FIXME, we skip the initial 0 size packets as they are most
2780 likely equal to the encoder delay, but it would be better if we
2781 had the real timestamps from the encoder */
2782 if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2783 av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2786 case AVMEDIA_TYPE_VIDEO:
2787 av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2795 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2797 int ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt);
2799 if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2802 ret= s->oformat->write_packet(s, pkt);
2804 ret= url_ferror(s->pb);
2808 void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
2809 int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
2811 AVPacketList **next_point, *this_pktl;
2813 this_pktl = av_mallocz(sizeof(AVPacketList));
2814 this_pktl->pkt= *pkt;
2815 pkt->destruct= NULL; // do not free original but only the copy
2816 av_dup_packet(&this_pktl->pkt); // duplicate the packet if it uses non-alloced memory
2818 if(s->streams[pkt->stream_index]->last_in_packet_buffer){
2819 next_point = &(s->streams[pkt->stream_index]->last_in_packet_buffer->next);
2821 next_point = &s->packet_buffer;
2824 if(compare(s, &s->packet_buffer_end->pkt, pkt)){
2825 while(!compare(s, &(*next_point)->pkt, pkt)){
2826 next_point= &(*next_point)->next;
2830 next_point = &(s->packet_buffer_end->next);
2833 assert(!*next_point);
2835 s->packet_buffer_end= this_pktl;
2838 this_pktl->next= *next_point;
2840 s->streams[pkt->stream_index]->last_in_packet_buffer=
2841 *next_point= this_pktl;
2844 int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
2846 AVStream *st = s->streams[ pkt ->stream_index];
2847 AVStream *st2= s->streams[ next->stream_index];
2848 int64_t a= st2->time_base.num * (int64_t)st ->time_base.den;
2849 int64_t b= st ->time_base.num * (int64_t)st2->time_base.den;
2850 return av_rescale_rnd(pkt->dts, b, a, AV_ROUND_DOWN) < next->dts;
2853 int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2859 ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
2862 for(i=0; i < s->nb_streams; i++)
2863 stream_count+= !!s->streams[i]->last_in_packet_buffer;
2865 if(stream_count && (s->nb_streams == stream_count || flush)){
2866 pktl= s->packet_buffer;
2869 s->packet_buffer= pktl->next;
2870 if(!s->packet_buffer)
2871 s->packet_buffer_end= NULL;
2873 if(s->streams[out->stream_index]->last_in_packet_buffer == pktl)
2874 s->streams[out->stream_index]->last_in_packet_buffer= NULL;
2878 av_init_packet(out);
2884 * Interleaves an AVPacket correctly so it can be muxed.
2885 * @param out the interleaved packet will be output here
2886 * @param in the input packet
2887 * @param flush 1 if no further packets are available as input and all
2888 * remaining packets should be output
2889 * @return 1 if a packet was output, 0 if no packet could be output,
2890 * < 0 if an error occurred
2892 static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2893 if(s->oformat->interleave_packet)
2894 return s->oformat->interleave_packet(s, out, in, flush);
2896 return av_interleave_packet_per_dts(s, out, in, flush);
2899 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2900 AVStream *st= s->streams[ pkt->stream_index];
2902 //FIXME/XXX/HACK drop zero sized packets
2903 if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO && pkt->size==0)
2906 //av_log(NULL, AV_LOG_DEBUG, "av_interleaved_write_frame %d %"PRId64" %"PRId64"\n", pkt->size, pkt->dts, pkt->pts);
2907 if(compute_pkt_fields2(s, st, pkt) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2910 if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2915 int ret= av_interleave_packet(s, &opkt, pkt, 0);
2916 if(ret<=0) //FIXME cleanup needed for ret<0 ?
2919 ret= s->oformat->write_packet(s, &opkt);
2921 av_free_packet(&opkt);
2926 if(url_ferror(s->pb))
2927 return url_ferror(s->pb);
2931 int av_write_trailer(AVFormatContext *s)
2937 ret= av_interleave_packet(s, &pkt, NULL, 1);
2938 if(ret<0) //FIXME cleanup needed for ret<0 ?
2943 ret= s->oformat->write_packet(s, &pkt);
2945 av_free_packet(&pkt);
2949 if(url_ferror(s->pb))
2953 if(s->oformat->write_trailer)
2954 ret = s->oformat->write_trailer(s);
2957 ret=url_ferror(s->pb);
2958 for(i=0;i<s->nb_streams;i++) {
2959 av_freep(&s->streams[i]->priv_data);
2960 av_freep(&s->streams[i]->index_entries);
2962 av_freep(&s->priv_data);
2966 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
2969 AVProgram *program=NULL;
2972 if (idx >= ac->nb_streams) {
2973 av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
2977 for(i=0; i<ac->nb_programs; i++){
2978 if(ac->programs[i]->id != progid)
2980 program = ac->programs[i];
2981 for(j=0; j<program->nb_stream_indexes; j++)
2982 if(program->stream_index[j] == idx)
2985 tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
2988 program->stream_index = tmp;
2989 program->stream_index[program->nb_stream_indexes++] = idx;
2994 static void print_fps(double d, const char *postfix){
2995 uint64_t v= lrintf(d*100);
2996 if (v% 100 ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
2997 else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
2998 else av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
3001 static void dump_metadata(void *ctx, AVMetadata *m, const char *indent)
3003 if(m && !(m->count == 1 && av_metadata_get(m, "language", NULL, 0))){
3004 AVMetadataTag *tag=NULL;
3006 av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3007 while((tag=av_metadata_get(m, "", tag, AV_METADATA_IGNORE_SUFFIX))) {
3008 if(strcmp("language", tag->key))
3009 av_log(ctx, AV_LOG_INFO, "%s %-16s: %s\n", indent, tag->key, tag->value);
3014 /* "user interface" functions */
3015 static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
3018 int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
3019 AVStream *st = ic->streams[i];
3020 int g = av_gcd(st->time_base.num, st->time_base.den);
3021 AVMetadataTag *lang = av_metadata_get(st->metadata, "language", NULL, 0);
3022 avcodec_string(buf, sizeof(buf), st->codec, is_output);
3023 av_log(NULL, AV_LOG_INFO, " Stream #%d.%d", index, i);
3024 /* the pid is an important information, so we display it */
3025 /* XXX: add a generic system */
3026 if (flags & AVFMT_SHOW_IDS)
3027 av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
3029 av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
3030 av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames, st->time_base.num/g, st->time_base.den/g);
3031 av_log(NULL, AV_LOG_INFO, ": %s", buf);
3032 if (st->sample_aspect_ratio.num && // default
3033 av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
3034 AVRational display_aspect_ratio;
3035 av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
3036 st->codec->width*st->sample_aspect_ratio.num,
3037 st->codec->height*st->sample_aspect_ratio.den,
3039 av_log(NULL, AV_LOG_INFO, ", PAR %d:%d DAR %d:%d",
3040 st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3041 display_aspect_ratio.num, display_aspect_ratio.den);
3043 if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
3044 if(st->avg_frame_rate.den && st->avg_frame_rate.num)
3045 print_fps(av_q2d(st->avg_frame_rate), "fps");
3046 if(st->r_frame_rate.den && st->r_frame_rate.num)
3047 print_fps(av_q2d(st->r_frame_rate), "tbr");
3048 if(st->time_base.den && st->time_base.num)
3049 print_fps(1/av_q2d(st->time_base), "tbn");
3050 if(st->codec->time_base.den && st->codec->time_base.num)
3051 print_fps(1/av_q2d(st->codec->time_base), "tbc");
3053 av_log(NULL, AV_LOG_INFO, "\n");
3054 dump_metadata(NULL, st->metadata, " ");
3057 void dump_format(AVFormatContext *ic,
3063 uint8_t *printed = av_mallocz(ic->nb_streams);
3064 if (ic->nb_streams && !printed)
3067 av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3068 is_output ? "Output" : "Input",
3070 is_output ? ic->oformat->name : ic->iformat->name,
3071 is_output ? "to" : "from", url);
3072 dump_metadata(NULL, ic->metadata, " ");
3074 av_log(NULL, AV_LOG_INFO, " Duration: ");
3075 if (ic->duration != AV_NOPTS_VALUE) {
3076 int hours, mins, secs, us;
3077 secs = ic->duration / AV_TIME_BASE;
3078 us = ic->duration % AV_TIME_BASE;
3083 av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3084 (100 * us) / AV_TIME_BASE);
3086 av_log(NULL, AV_LOG_INFO, "N/A");
3088 if (ic->start_time != AV_NOPTS_VALUE) {
3090 av_log(NULL, AV_LOG_INFO, ", start: ");
3091 secs = ic->start_time / AV_TIME_BASE;
3092 us = ic->start_time % AV_TIME_BASE;
3093 av_log(NULL, AV_LOG_INFO, "%d.%06d",
3094 secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
3096 av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3098 av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
3100 av_log(NULL, AV_LOG_INFO, "N/A");
3102 av_log(NULL, AV_LOG_INFO, "\n");
3104 for (i = 0; i < ic->nb_chapters; i++) {
3105 AVChapter *ch = ic->chapters[i];
3106 av_log(NULL, AV_LOG_INFO, " Chapter #%d.%d: ", index, i);
3107 av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
3108 av_log(NULL, AV_LOG_INFO, "end %f\n", ch->end * av_q2d(ch->time_base));
3110 dump_metadata(NULL, ch->metadata, " ");
3112 if(ic->nb_programs) {
3113 int j, k, total = 0;
3114 for(j=0; j<ic->nb_programs; j++) {
3115 AVMetadataTag *name = av_metadata_get(ic->programs[j]->metadata,
3117 av_log(NULL, AV_LOG_INFO, " Program %d %s\n", ic->programs[j]->id,
3118 name ? name->value : "");
3119 dump_metadata(NULL, ic->programs[j]->metadata, " ");
3120 for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3121 dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3122 printed[ic->programs[j]->stream_index[k]] = 1;
3124 total += ic->programs[j]->nb_stream_indexes;
3126 if (total < ic->nb_streams)
3127 av_log(NULL, AV_LOG_INFO, " No Program\n");
3129 for(i=0;i<ic->nb_streams;i++)
3131 dump_stream_format(ic, i, index, is_output);
3136 #if LIBAVFORMAT_VERSION_MAJOR < 53
3137 int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
3139 return av_parse_video_frame_size(width_ptr, height_ptr, str);
3142 int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
3144 AVRational frame_rate;
3145 int ret = av_parse_video_frame_rate(&frame_rate, arg);
3146 *frame_rate_num= frame_rate.num;
3147 *frame_rate_den= frame_rate.den;
3152 int64_t av_gettime(void)
3155 gettimeofday(&tv,NULL);
3156 return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
3159 uint64_t ff_ntp_time(void)
3161 return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3164 int64_t parse_date(const char *datestr, int duration)
3170 static const char * const date_fmt[] = {
3174 static const char * const time_fmt[] = {
3184 time_t now = time(0);
3186 len = strlen(datestr);
3188 lastch = datestr[len - 1];
3191 is_utc = (lastch == 'z' || lastch == 'Z');
3193 memset(&dt, 0, sizeof(dt));
3198 if (!strncasecmp(datestr, "now", len))
3199 return (int64_t) now * 1000000;
3201 /* parse the year-month-day part */
3202 for (i = 0; i < FF_ARRAY_ELEMS(date_fmt); i++) {
3203 q = small_strptime(p, date_fmt[i], &dt);
3209 /* if the year-month-day part is missing, then take the
3210 * current year-month-day time */
3215 dt = *localtime(&now);
3217 dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
3222 if (*p == 'T' || *p == 't' || *p == ' ')
3225 /* parse the hour-minute-second part */
3226 for (i = 0; i < FF_ARRAY_ELEMS(time_fmt); i++) {
3227 q = small_strptime(p, time_fmt[i], &dt);
3233 /* parse datestr as a duration */
3238 /* parse datestr as HH:MM:SS */
3239 q = small_strptime(p, time_fmt[0], &dt);
3241 /* parse datestr as S+ */
3242 dt.tm_sec = strtol(p, (char **)&q, 10);
3244 /* the parsing didn't succeed */
3251 /* Now we have all the fields that we can get */
3257 t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
3259 dt.tm_isdst = -1; /* unknown */
3269 /* parse the .m... part */
3273 for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
3276 val += n * (*q - '0');
3280 return negative ? -t : t;
3283 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
3293 while (*p != '\0' && *p != '=' && *p != '&') {
3294 if ((q - tag) < sizeof(tag) - 1)
3302 while (*p != '&' && *p != '\0') {
3303 if ((q - arg) < arg_size - 1) {
3313 if (!strcmp(tag, tag1))
3322 int av_get_frame_filename(char *buf, int buf_size,
3323 const char *path, int number)
3326 char *q, buf1[20], c;
3327 int nd, len, percentd_found;
3339 while (isdigit(*p)) {
3340 nd = nd * 10 + *p++ - '0';
3343 } while (isdigit(c));
3352 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3354 if ((q - buf + len) > buf_size - 1)
3356 memcpy(q, buf1, len);
3364 if ((q - buf) < buf_size - 1)
3368 if (!percentd_found)
3377 static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3381 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3383 for(i=0;i<size;i+=16) {
3390 PRINT(" %02x", buf[i+j]);
3395 for(j=0;j<len;j++) {
3397 if (c < ' ' || c > '~')
3406 void av_hex_dump(FILE *f, uint8_t *buf, int size)
3408 hex_dump_internal(NULL, f, 0, buf, size);
3411 void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3413 hex_dump_internal(avcl, NULL, level, buf, size);
3416 //FIXME needs to know the time_base
3417 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload)
3420 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3421 PRINT("stream #%d:\n", pkt->stream_index);
3422 PRINT(" keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
3423 PRINT(" duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
3424 /* DTS is _always_ valid after av_read_frame() */
3426 if (pkt->dts == AV_NOPTS_VALUE)
3429 PRINT("%0.3f", (double)pkt->dts / AV_TIME_BASE);
3430 /* PTS may not be known if B-frames are present. */
3432 if (pkt->pts == AV_NOPTS_VALUE)
3435 PRINT("%0.3f", (double)pkt->pts / AV_TIME_BASE);
3437 PRINT(" size=%d\n", pkt->size);
3440 av_hex_dump(f, pkt->data, pkt->size);
3443 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3445 pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
3448 void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3450 pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
3453 void ff_url_split(char *proto, int proto_size,
3454 char *authorization, int authorization_size,
3455 char *hostname, int hostname_size,
3457 char *path, int path_size,
3460 const char *p, *ls, *at, *col, *brk;
3462 if (port_ptr) *port_ptr = -1;
3463 if (proto_size > 0) proto[0] = 0;
3464 if (authorization_size > 0) authorization[0] = 0;
3465 if (hostname_size > 0) hostname[0] = 0;
3466 if (path_size > 0) path[0] = 0;
3468 /* parse protocol */
3469 if ((p = strchr(url, ':'))) {
3470 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3475 /* no protocol means plain filename */
3476 av_strlcpy(path, url, path_size);
3480 /* separate path from hostname */
3481 ls = strchr(p, '/');
3483 ls = strchr(p, '?');
3485 av_strlcpy(path, ls, path_size);
3487 ls = &p[strlen(p)]; // XXX
3489 /* the rest is hostname, use that to parse auth/port */
3491 /* authorization (user[:pass]@hostname) */
3492 if ((at = strchr(p, '@')) && at < ls) {
3493 av_strlcpy(authorization, p,
3494 FFMIN(authorization_size, at + 1 - p));
3495 p = at + 1; /* skip '@' */
3498 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3500 av_strlcpy(hostname, p + 1,
3501 FFMIN(hostname_size, brk - p));
3502 if (brk[1] == ':' && port_ptr)
3503 *port_ptr = atoi(brk + 2);
3504 } else if ((col = strchr(p, ':')) && col < ls) {
3505 av_strlcpy(hostname, p,
3506 FFMIN(col + 1 - p, hostname_size));
3507 if (port_ptr) *port_ptr = atoi(col + 1);
3509 av_strlcpy(hostname, p,
3510 FFMIN(ls + 1 - p, hostname_size));
3514 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3517 static const char hex_table_uc[16] = { '0', '1', '2', '3',
3520 'C', 'D', 'E', 'F' };
3521 static const char hex_table_lc[16] = { '0', '1', '2', '3',
3524 'c', 'd', 'e', 'f' };
3525 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3527 for(i = 0; i < s; i++) {
3528 buff[i * 2] = hex_table[src[i] >> 4];
3529 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3535 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3536 unsigned int pts_num, unsigned int pts_den)
3538 s->pts_wrap_bits = pts_wrap_bits;
3540 if(av_reduce(&s->time_base.num, &s->time_base.den, pts_num, pts_den, INT_MAX)){
3541 if(s->time_base.num != pts_num)
3542 av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/s->time_base.num);
3544 av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3546 if(!s->time_base.num || !s->time_base.den)
3547 s->time_base.num= s->time_base.den= 0;
3550 int ff_url_join(char *str, int size, const char *proto,
3551 const char *authorization, const char *hostname,
3552 int port, const char *fmt, ...)
3555 struct addrinfo hints, *ai;
3560 av_strlcatf(str, size, "%s://", proto);
3562 av_strlcatf(str, size, "%s@", authorization);
3563 #if CONFIG_NETWORK && defined(AF_INET6)
3564 /* Determine if hostname is a numerical IPv6 address,
3565 * properly escape it within [] in that case. */
3566 memset(&hints, 0, sizeof(hints));
3567 hints.ai_flags = AI_NUMERICHOST;
3568 if (!getaddrinfo(hostname, NULL, &hints, &ai)) {
3569 if (ai->ai_family == AF_INET6) {
3570 av_strlcat(str, "[", size);
3571 av_strlcat(str, hostname, size);
3572 av_strlcat(str, "]", size);
3574 av_strlcat(str, hostname, size);
3579 /* Not an IPv6 address, just output the plain string. */
3580 av_strlcat(str, hostname, size);
3583 av_strlcatf(str, size, ":%d", port);
3586 int len = strlen(str);
3589 vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);