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/opt.h"
25 #include "libavutil/avstring.h"
35 * @file libavformat/utils.c
36 * various utility functions for use within FFmpeg
39 unsigned avformat_version(void)
41 return LIBAVFORMAT_VERSION_INT;
44 const char *avformat_configuration(void)
46 return FFMPEG_CONFIGURATION;
49 const char *avformat_license(void)
51 #define LICENSE_PREFIX "libavformat license: "
52 return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;
55 /* fraction handling */
58 * f = val + (num / den) + 0.5.
60 * 'num' is normalized so that it is such as 0 <= num < den.
62 * @param f fractional number
63 * @param val integer value
64 * @param num must be >= 0
65 * @param den must be >= 1
67 static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
80 * Fractional addition to f: f = f + (incr / f->den).
82 * @param f fractional number
83 * @param incr increment, can be positive or negative
85 static void av_frac_add(AVFrac *f, int64_t incr)
98 } else if (num >= den) {
105 /** head of registered input format linked list */
106 AVInputFormat *first_iformat = NULL;
107 /** head of registered output format linked list */
108 AVOutputFormat *first_oformat = NULL;
110 AVInputFormat *av_iformat_next(AVInputFormat *f)
112 if(f) return f->next;
113 else return first_iformat;
116 AVOutputFormat *av_oformat_next(AVOutputFormat *f)
118 if(f) return f->next;
119 else return first_oformat;
122 void av_register_input_format(AVInputFormat *format)
126 while (*p != NULL) p = &(*p)->next;
131 void av_register_output_format(AVOutputFormat *format)
135 while (*p != NULL) p = &(*p)->next;
140 #if LIBAVFORMAT_VERSION_MAJOR < 53
141 int match_ext(const char *filename, const char *extensions)
143 return av_match_ext(filename, extensions);
147 int av_match_ext(const char *filename, const char *extensions)
155 ext = strrchr(filename, '.');
161 while (*p != '\0' && *p != ',' && q-ext1<sizeof(ext1)-1)
164 if (!strcasecmp(ext1, ext))
174 static int match_format(const char *name, const char *names)
182 namelen = strlen(name);
183 while ((p = strchr(names, ','))) {
184 len = FFMAX(p - names, namelen);
185 if (!strncasecmp(name, names, len))
189 return !strcasecmp(name, names);
192 #if LIBAVFORMAT_VERSION_MAJOR < 53
193 AVOutputFormat *guess_format(const char *short_name, const char *filename,
194 const char *mime_type)
196 return av_guess_format(short_name, filename, mime_type);
200 AVOutputFormat *av_guess_format(const char *short_name, const char *filename,
201 const char *mime_type)
203 AVOutputFormat *fmt, *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 av_guess_image2_codec(filename) != CODEC_ID_NONE) {
211 return av_guess_format("image2", NULL, NULL);
214 /* Find the proper file type. */
218 while (fmt != NULL) {
220 if (fmt->name && short_name && !strcmp(fmt->name, short_name))
222 if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
224 if (filename && fmt->extensions &&
225 av_match_ext(filename, fmt->extensions)) {
228 if (score > score_max) {
237 #if LIBAVFORMAT_VERSION_MAJOR < 53
238 AVOutputFormat *guess_stream_format(const char *short_name, const char *filename,
239 const char *mime_type)
241 AVOutputFormat *fmt = av_guess_format(short_name, filename, mime_type);
244 AVOutputFormat *stream_fmt;
245 char stream_format_name[64];
247 snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
248 stream_fmt = av_guess_format(stream_format_name, NULL, NULL);
258 enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
259 const char *filename, const char *mime_type, enum CodecType type){
260 if(type == CODEC_TYPE_VIDEO){
261 enum CodecID codec_id= CODEC_ID_NONE;
263 #if CONFIG_IMAGE2_MUXER
264 if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
265 codec_id= av_guess_image2_codec(filename);
268 if(codec_id == CODEC_ID_NONE)
269 codec_id= fmt->video_codec;
271 }else if(type == CODEC_TYPE_AUDIO)
272 return fmt->audio_codec;
274 return CODEC_ID_NONE;
277 AVInputFormat *av_find_input_format(const char *short_name)
280 for(fmt = first_iformat; fmt != NULL; fmt = fmt->next) {
281 if (match_format(short_name, fmt->name))
287 /* memory handling */
290 int av_get_packet(ByteIOContext *s, AVPacket *pkt, int size)
292 int ret= av_new_packet(pkt, size);
297 pkt->pos= url_ftell(s);
299 ret= get_buffer(s, pkt->data, size);
303 av_shrink_packet(pkt, ret);
309 int av_filename_number_test(const char *filename)
312 return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
315 static AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
317 AVInputFormat *fmt1, *fmt;
321 for(fmt1 = first_iformat; fmt1 != NULL; fmt1 = fmt1->next) {
322 if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
325 if (fmt1->read_probe) {
326 score = fmt1->read_probe(pd);
327 } else if (fmt1->extensions) {
328 if (av_match_ext(pd->filename, fmt1->extensions)) {
332 if (score > *score_max) {
335 }else if (score == *score_max)
341 AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
343 return av_probe_input_format2(pd, is_opened, &score);
346 static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st, AVProbeData *pd, int score)
349 fmt = av_probe_input_format2(pd, 1, &score);
352 av_log(s, AV_LOG_DEBUG, "Probe with size=%d, packets=%d detected %s with score=%d\n",
353 pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets, fmt->name, score);
354 if (!strcmp(fmt->name, "mp3")) {
355 st->codec->codec_id = CODEC_ID_MP3;
356 st->codec->codec_type = CODEC_TYPE_AUDIO;
357 } else if (!strcmp(fmt->name, "ac3")) {
358 st->codec->codec_id = CODEC_ID_AC3;
359 st->codec->codec_type = CODEC_TYPE_AUDIO;
360 } else if (!strcmp(fmt->name, "eac3")) {
361 st->codec->codec_id = CODEC_ID_EAC3;
362 st->codec->codec_type = CODEC_TYPE_AUDIO;
363 } else if (!strcmp(fmt->name, "mpegvideo")) {
364 st->codec->codec_id = CODEC_ID_MPEG2VIDEO;
365 st->codec->codec_type = CODEC_TYPE_VIDEO;
366 } else if (!strcmp(fmt->name, "m4v")) {
367 st->codec->codec_id = CODEC_ID_MPEG4;
368 st->codec->codec_type = CODEC_TYPE_VIDEO;
369 } else if (!strcmp(fmt->name, "h264")) {
370 st->codec->codec_id = CODEC_ID_H264;
371 st->codec->codec_type = CODEC_TYPE_VIDEO;
372 } else if (!strcmp(fmt->name, "dts")) {
373 st->codec->codec_id = CODEC_ID_DTS;
374 st->codec->codec_type = CODEC_TYPE_AUDIO;
380 /************************************************************/
381 /* input media file */
384 * Open a media file from an IO stream. 'fmt' must be specified.
386 int av_open_input_stream(AVFormatContext **ic_ptr,
387 ByteIOContext *pb, const char *filename,
388 AVInputFormat *fmt, AVFormatParameters *ap)
392 AVFormatParameters default_ap;
396 memset(ap, 0, sizeof(default_ap));
399 if(!ap->prealloced_context)
400 ic = avformat_alloc_context();
404 err = AVERROR(ENOMEM);
409 ic->duration = AV_NOPTS_VALUE;
410 ic->start_time = AV_NOPTS_VALUE;
411 av_strlcpy(ic->filename, filename, sizeof(ic->filename));
413 /* allocate private data */
414 if (fmt->priv_data_size > 0) {
415 ic->priv_data = av_mallocz(fmt->priv_data_size);
416 if (!ic->priv_data) {
417 err = AVERROR(ENOMEM);
421 ic->priv_data = NULL;
424 if (ic->iformat->read_header) {
425 err = ic->iformat->read_header(ic, ap);
430 if (pb && !ic->data_offset)
431 ic->data_offset = url_ftell(ic->pb);
433 #if LIBAVFORMAT_VERSION_MAJOR < 53
434 ff_metadata_demux_compat(ic);
437 ic->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
444 av_freep(&ic->priv_data);
445 for(i=0;i<ic->nb_streams;i++) {
446 AVStream *st = ic->streams[i];
448 av_free(st->priv_data);
449 av_free(st->codec->extradata);
459 /** size of probe buffer, for guessing file type from file contents */
460 #define PROBE_BUF_MIN 2048
461 #define PROBE_BUF_MAX (1<<20)
463 int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
466 AVFormatParameters *ap)
469 AVProbeData probe_data, *pd = &probe_data;
470 ByteIOContext *pb = NULL;
471 void *logctx= ap && ap->prealloced_context ? *ic_ptr : NULL;
475 pd->filename = filename;
480 /* guess format if no file can be opened */
481 fmt = av_probe_input_format(pd, 0);
484 /* Do not open file if the format does not need it. XXX: specific
485 hack needed to handle RTSP/TCP */
486 if (!fmt || !(fmt->flags & AVFMT_NOFILE)) {
487 /* if no file needed do not try to open one */
488 if ((err=url_fopen(&pb, filename, URL_RDONLY)) < 0) {
492 url_setbufsize(pb, buf_size);
495 for(probe_size= PROBE_BUF_MIN; probe_size<=PROBE_BUF_MAX && !fmt; probe_size<<=1){
496 int score= probe_size < PROBE_BUF_MAX ? AVPROBE_SCORE_MAX/4 : 0;
497 /* read probe data */
498 pd->buf= av_realloc(pd->buf, probe_size + AVPROBE_PADDING_SIZE);
499 pd->buf_size = get_buffer(pb, pd->buf, probe_size);
501 if ((int)pd->buf_size < 0) {
506 memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
507 if (url_fseek(pb, 0, SEEK_SET) < 0) {
509 if (url_fopen(&pb, filename, URL_RDONLY) < 0) {
515 /* guess file format */
516 fmt = av_probe_input_format2(pd, 1, &score);
518 if(score <= AVPROBE_SCORE_MAX/4){ //this can only be true in the last iteration
519 av_log(logctx, AV_LOG_WARNING, "Format detected only with low score of %d, misdetection possible!\n", score);
521 av_log(logctx, AV_LOG_DEBUG, "Probed with size=%d and score=%d\n", probe_size, score);
527 /* if still no format found, error */
533 /* check filename in case an image number is expected */
534 if (fmt->flags & AVFMT_NEEDNUMBER) {
535 if (!av_filename_number_test(filename)) {
536 err = AVERROR_NUMEXPECTED;
540 err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
548 if (ap && ap->prealloced_context)
555 /*******************************************************/
557 static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
558 AVPacketList **plast_pktl){
559 AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
564 (*plast_pktl)->next = pktl;
566 *packet_buffer = pktl;
568 /* add the packet in the buffered packet list */
574 int av_read_packet(AVFormatContext *s, AVPacket *pkt)
580 AVPacketList *pktl = s->raw_packet_buffer;
584 if(s->streams[pkt->stream_index]->codec->codec_id != CODEC_ID_PROBE ||
585 !s->streams[pkt->stream_index]->probe_packets ||
586 s->raw_packet_buffer_remaining_size < pkt->size){
587 AVProbeData *pd = &s->streams[pkt->stream_index]->probe_data;
590 s->raw_packet_buffer = pktl->next;
591 s->raw_packet_buffer_remaining_size += pkt->size;
598 ret= s->iformat->read_packet(s, pkt);
600 if (!pktl || ret == AVERROR(EAGAIN))
602 for (i = 0; i < s->nb_streams; i++)
603 s->streams[i]->probe_packets = 0;
606 st= s->streams[pkt->stream_index];
608 switch(st->codec->codec_type){
609 case CODEC_TYPE_VIDEO:
610 if(s->video_codec_id) st->codec->codec_id= s->video_codec_id;
612 case CODEC_TYPE_AUDIO:
613 if(s->audio_codec_id) st->codec->codec_id= s->audio_codec_id;
615 case CODEC_TYPE_SUBTITLE:
616 if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
620 if(!pktl && (st->codec->codec_id != CODEC_ID_PROBE ||
624 add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
625 s->raw_packet_buffer_remaining_size -= pkt->size;
627 if(st->codec->codec_id == CODEC_ID_PROBE){
628 AVProbeData *pd = &st->probe_data;
629 av_log(s, AV_LOG_DEBUG, "probing stream %d\n", st->index);
632 pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
633 memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
634 pd->buf_size += pkt->size;
635 memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
637 if(av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)){
638 set_codec_from_probe_data(s, st, pd, 1);
639 if(st->codec->codec_id != CODEC_ID_PROBE){
642 av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
649 /**********************************************************/
652 * Get the number of samples of an audio frame. Return -1 on error.
654 static int get_audio_frame_size(AVCodecContext *enc, int size)
658 if(enc->codec_id == CODEC_ID_VORBIS)
661 if (enc->frame_size <= 1) {
662 int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
664 if (bits_per_sample) {
665 if (enc->channels == 0)
667 frame_size = (size << 3) / (bits_per_sample * enc->channels);
669 /* used for example by ADPCM codecs */
670 if (enc->bit_rate == 0)
672 frame_size = ((int64_t)size * 8 * enc->sample_rate) / enc->bit_rate;
675 frame_size = enc->frame_size;
682 * Return the frame duration in seconds. Return 0 if not available.
684 static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
685 AVCodecParserContext *pc, AVPacket *pkt)
691 switch(st->codec->codec_type) {
692 case CODEC_TYPE_VIDEO:
693 if(st->time_base.num*1000LL > st->time_base.den){
694 *pnum = st->time_base.num;
695 *pden = st->time_base.den;
696 }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
697 *pnum = st->codec->time_base.num;
698 *pden = st->codec->time_base.den;
699 if (pc && pc->repeat_pict) {
700 *pnum = (*pnum) * (1 + pc->repeat_pict);
704 case CODEC_TYPE_AUDIO:
705 frame_size = get_audio_frame_size(st->codec, pkt->size);
709 *pden = st->codec->sample_rate;
716 static int is_intra_only(AVCodecContext *enc){
717 if(enc->codec_type == CODEC_TYPE_AUDIO){
719 }else if(enc->codec_type == CODEC_TYPE_VIDEO){
720 switch(enc->codec_id){
722 case CODEC_ID_MJPEGB:
724 case CODEC_ID_RAWVIDEO:
725 case CODEC_ID_DVVIDEO:
726 case CODEC_ID_HUFFYUV:
727 case CODEC_ID_FFVHUFF:
732 case CODEC_ID_JPEG2000:
740 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
741 int64_t dts, int64_t pts)
743 AVStream *st= s->streams[stream_index];
744 AVPacketList *pktl= s->packet_buffer;
746 if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE)
749 st->first_dts= dts - st->cur_dts;
752 for(; pktl; pktl= pktl->next){
753 if(pktl->pkt.stream_index != stream_index)
755 //FIXME think more about this check
756 if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
757 pktl->pkt.pts += st->first_dts;
759 if(pktl->pkt.dts != AV_NOPTS_VALUE)
760 pktl->pkt.dts += st->first_dts;
762 if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
763 st->start_time= pktl->pkt.pts;
765 if (st->start_time == AV_NOPTS_VALUE)
766 st->start_time = pts;
769 static void update_initial_durations(AVFormatContext *s, AVStream *st, AVPacket *pkt)
771 AVPacketList *pktl= s->packet_buffer;
774 if(st->first_dts != AV_NOPTS_VALUE){
775 cur_dts= st->first_dts;
776 for(; pktl; pktl= pktl->next){
777 if(pktl->pkt.stream_index == pkt->stream_index){
778 if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
780 cur_dts -= pkt->duration;
783 pktl= s->packet_buffer;
784 st->first_dts = cur_dts;
785 }else if(st->cur_dts)
788 for(; pktl; pktl= pktl->next){
789 if(pktl->pkt.stream_index != pkt->stream_index)
791 if(pktl->pkt.pts == pktl->pkt.dts && pktl->pkt.dts == AV_NOPTS_VALUE
792 && !pktl->pkt.duration){
793 pktl->pkt.dts= cur_dts;
794 if(!st->codec->has_b_frames)
795 pktl->pkt.pts= cur_dts;
796 cur_dts += pkt->duration;
797 pktl->pkt.duration= pkt->duration;
801 if(st->first_dts == AV_NOPTS_VALUE)
802 st->cur_dts= cur_dts;
805 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
806 AVCodecParserContext *pc, AVPacket *pkt)
808 int num, den, presentation_delayed, delay, i;
811 if (st->codec->codec_id != CODEC_ID_H264 && pc && pc->pict_type == FF_B_TYPE)
812 //FIXME Set low_delay = 0 when has_b_frames = 1
813 st->codec->has_b_frames = 1;
815 /* do we have a video B-frame ? */
816 delay= st->codec->has_b_frames;
817 presentation_delayed = 0;
818 /* XXX: need has_b_frame, but cannot get it if the codec is
821 pc && pc->pict_type != FF_B_TYPE)
822 presentation_delayed = 1;
824 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
825 /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
826 pkt->dts -= 1LL<<st->pts_wrap_bits;
829 // some mpeg2 in mpeg-ps lack dts (issue171 / input_file.mpg)
830 // we take the conservative approach and discard both
831 // Note, if this is misbehaving for a H.264 file then possibly presentation_delayed is not set correctly.
832 if(delay==1 && pkt->dts == pkt->pts && pkt->dts != AV_NOPTS_VALUE && presentation_delayed){
833 av_log(s, AV_LOG_WARNING, "invalid dts/pts combination\n");
834 pkt->dts= pkt->pts= AV_NOPTS_VALUE;
837 if (pkt->duration == 0) {
838 compute_frame_duration(&num, &den, st, pc, pkt);
840 pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
842 if(pkt->duration != 0 && s->packet_buffer)
843 update_initial_durations(s, st, pkt);
847 /* correct timestamps with byte offset if demuxers only have timestamps
848 on packet boundaries */
849 if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
850 /* this will estimate bitrate based on this frame's duration and size */
851 offset = av_rescale(pc->offset, pkt->duration, pkt->size);
852 if(pkt->pts != AV_NOPTS_VALUE)
854 if(pkt->dts != AV_NOPTS_VALUE)
858 if (pc && pc->dts_sync_point >= 0) {
859 // we have synchronization info from the parser
860 int64_t den = st->codec->time_base.den * (int64_t) st->time_base.num;
862 int64_t num = st->codec->time_base.num * (int64_t) st->time_base.den;
863 if (pkt->dts != AV_NOPTS_VALUE) {
864 // got DTS from the stream, update reference timestamp
865 st->reference_dts = pkt->dts - pc->dts_ref_dts_delta * num / den;
866 pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
867 } else if (st->reference_dts != AV_NOPTS_VALUE) {
868 // compute DTS based on reference timestamp
869 pkt->dts = st->reference_dts + pc->dts_ref_dts_delta * num / den;
870 pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
872 if (pc->dts_sync_point > 0)
873 st->reference_dts = pkt->dts; // new reference
877 /* This may be redundant, but it should not hurt. */
878 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
879 presentation_delayed = 1;
881 // 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);
882 /* interpolate PTS and DTS if they are not present */
883 //We skip H264 currently because delay and has_b_frames are not reliably set
884 if((delay==0 || (delay==1 && pc)) && st->codec->codec_id != CODEC_ID_H264){
885 if (presentation_delayed) {
886 /* DTS = decompression timestamp */
887 /* PTS = presentation timestamp */
888 if (pkt->dts == AV_NOPTS_VALUE)
889 pkt->dts = st->last_IP_pts;
890 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
891 if (pkt->dts == AV_NOPTS_VALUE)
892 pkt->dts = st->cur_dts;
894 /* this is tricky: the dts must be incremented by the duration
895 of the frame we are displaying, i.e. the last I- or P-frame */
896 if (st->last_IP_duration == 0)
897 st->last_IP_duration = pkt->duration;
898 if(pkt->dts != AV_NOPTS_VALUE)
899 st->cur_dts = pkt->dts + st->last_IP_duration;
900 st->last_IP_duration = pkt->duration;
901 st->last_IP_pts= pkt->pts;
902 /* cannot compute PTS if not present (we can compute it only
903 by knowing the future */
904 } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
905 if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
906 int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
907 int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
908 if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
909 pkt->pts += pkt->duration;
910 // 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);
914 /* presentation is not delayed : PTS and DTS are the same */
915 if(pkt->pts == AV_NOPTS_VALUE)
917 update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
918 if(pkt->pts == AV_NOPTS_VALUE)
919 pkt->pts = st->cur_dts;
921 if(pkt->pts != AV_NOPTS_VALUE)
922 st->cur_dts = pkt->pts + pkt->duration;
926 if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
927 st->pts_buffer[0]= pkt->pts;
928 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
929 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
930 if(pkt->dts == AV_NOPTS_VALUE)
931 pkt->dts= st->pts_buffer[0];
932 if(st->codec->codec_id == CODEC_ID_H264){ //we skiped it above so we try here
933 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
935 if(pkt->dts > st->cur_dts)
936 st->cur_dts = pkt->dts;
939 // 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);
942 if(is_intra_only(st->codec))
943 pkt->flags |= PKT_FLAG_KEY;
946 /* keyframe computation */
947 if (pc->key_frame == 1)
948 pkt->flags |= PKT_FLAG_KEY;
949 else if (pc->key_frame == -1 && pc->pict_type == FF_I_TYPE)
950 pkt->flags |= PKT_FLAG_KEY;
953 pkt->convergence_duration = pc->convergence_duration;
957 static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
965 /* select current input stream component */
968 if (!st->need_parsing || !st->parser) {
969 /* no parsing needed: we just output the packet as is */
970 /* raw data support */
971 *pkt = st->cur_pkt; st->cur_pkt.data= NULL;
972 compute_pkt_fields(s, st, NULL, pkt);
974 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
975 (pkt->flags & PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
976 ff_reduce_index(s, st->index);
977 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
980 } else if (st->cur_len > 0 && st->discard < AVDISCARD_ALL) {
981 len = av_parser_parse2(st->parser, st->codec, &pkt->data, &pkt->size,
982 st->cur_ptr, st->cur_len,
983 st->cur_pkt.pts, st->cur_pkt.dts,
985 st->cur_pkt.pts = AV_NOPTS_VALUE;
986 st->cur_pkt.dts = AV_NOPTS_VALUE;
987 /* increment read pointer */
991 /* return packet if any */
995 pkt->stream_index = st->index;
996 pkt->pts = st->parser->pts;
997 pkt->dts = st->parser->dts;
998 pkt->pos = st->parser->pos;
999 pkt->destruct = NULL;
1000 compute_pkt_fields(s, st, st->parser, pkt);
1002 if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & PKT_FLAG_KEY){
1003 ff_reduce_index(s, st->index);
1004 av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
1005 0, 0, AVINDEX_KEYFRAME);
1012 av_free_packet(&st->cur_pkt);
1017 /* read next packet */
1018 ret = av_read_packet(s, &cur_pkt);
1020 if (ret == AVERROR(EAGAIN))
1022 /* return the last frames, if any */
1023 for(i = 0; i < s->nb_streams; i++) {
1025 if (st->parser && st->need_parsing) {
1026 av_parser_parse2(st->parser, st->codec,
1027 &pkt->data, &pkt->size,
1029 AV_NOPTS_VALUE, AV_NOPTS_VALUE,
1035 /* no more packets: really terminate parsing */
1038 st = s->streams[cur_pkt.stream_index];
1039 st->cur_pkt= cur_pkt;
1041 if(st->cur_pkt.pts != AV_NOPTS_VALUE &&
1042 st->cur_pkt.dts != AV_NOPTS_VALUE &&
1043 st->cur_pkt.pts < st->cur_pkt.dts){
1044 av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
1045 st->cur_pkt.stream_index,
1049 // av_free_packet(&st->cur_pkt);
1053 if(s->debug & FF_FDEBUG_TS)
1054 av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1055 st->cur_pkt.stream_index,
1059 st->cur_pkt.duration,
1063 st->cur_ptr = st->cur_pkt.data;
1064 st->cur_len = st->cur_pkt.size;
1065 if (st->need_parsing && !st->parser) {
1066 st->parser = av_parser_init(st->codec->codec_id);
1068 /* no parser available: just output the raw packets */
1069 st->need_parsing = AVSTREAM_PARSE_NONE;
1070 }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
1071 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1073 if(st->parser && (s->iformat->flags & AVFMT_GENERIC_INDEX)){
1074 st->parser->next_frame_offset=
1075 st->parser->cur_offset= st->cur_pkt.pos;
1080 if(s->debug & FF_FDEBUG_TS)
1081 av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1092 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1096 const int genpts= s->flags & AVFMT_FLAG_GENPTS;
1099 pktl = s->packet_buffer;
1101 AVPacket *next_pkt= &pktl->pkt;
1103 if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
1104 while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
1105 if( pktl->pkt.stream_index == next_pkt->stream_index
1106 && next_pkt->dts < pktl->pkt.dts
1107 && pktl->pkt.pts != pktl->pkt.dts //not b frame
1108 /*&& pktl->pkt.dts != AV_NOPTS_VALUE*/){
1109 next_pkt->pts= pktl->pkt.dts;
1113 pktl = s->packet_buffer;
1116 if( next_pkt->pts != AV_NOPTS_VALUE
1117 || next_pkt->dts == AV_NOPTS_VALUE
1119 /* read packet from packet buffer, if there is data */
1121 s->packet_buffer = pktl->next;
1127 int ret= av_read_frame_internal(s, pkt);
1129 if(pktl && ret != AVERROR(EAGAIN)){
1136 if(av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1137 &s->packet_buffer_end)) < 0)
1138 return AVERROR(ENOMEM);
1140 assert(!s->packet_buffer);
1141 return av_read_frame_internal(s, pkt);
1146 /* XXX: suppress the packet queue */
1147 static void flush_packet_queue(AVFormatContext *s)
1152 pktl = s->packet_buffer;
1155 s->packet_buffer = pktl->next;
1156 av_free_packet(&pktl->pkt);
1159 while(s->raw_packet_buffer){
1160 pktl = s->raw_packet_buffer;
1161 s->raw_packet_buffer = pktl->next;
1162 av_free_packet(&pktl->pkt);
1165 s->packet_buffer_end=
1166 s->raw_packet_buffer_end= NULL;
1167 s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1170 /*******************************************************/
1173 int av_find_default_stream_index(AVFormatContext *s)
1175 int first_audio_index = -1;
1179 if (s->nb_streams <= 0)
1181 for(i = 0; i < s->nb_streams; i++) {
1183 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1186 if (first_audio_index < 0 && st->codec->codec_type == CODEC_TYPE_AUDIO)
1187 first_audio_index = i;
1189 return first_audio_index >= 0 ? first_audio_index : 0;
1193 * Flush the frame reader.
1195 void av_read_frame_flush(AVFormatContext *s)
1200 flush_packet_queue(s);
1204 /* for each stream, reset read state */
1205 for(i = 0; i < s->nb_streams; i++) {
1209 av_parser_close(st->parser);
1211 av_free_packet(&st->cur_pkt);
1213 st->last_IP_pts = AV_NOPTS_VALUE;
1214 st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1215 st->reference_dts = AV_NOPTS_VALUE;
1220 st->probe_packets = MAX_PROBE_PACKETS;
1222 for(j=0; j<MAX_REORDER_DELAY+1; j++)
1223 st->pts_buffer[j]= AV_NOPTS_VALUE;
1227 void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1230 for(i = 0; i < s->nb_streams; i++) {
1231 AVStream *st = s->streams[i];
1233 st->cur_dts = av_rescale(timestamp,
1234 st->time_base.den * (int64_t)ref_st->time_base.num,
1235 st->time_base.num * (int64_t)ref_st->time_base.den);
1239 void ff_reduce_index(AVFormatContext *s, int stream_index)
1241 AVStream *st= s->streams[stream_index];
1242 unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1244 if((unsigned)st->nb_index_entries >= max_entries){
1246 for(i=0; 2*i<st->nb_index_entries; i++)
1247 st->index_entries[i]= st->index_entries[2*i];
1248 st->nb_index_entries= i;
1252 int av_add_index_entry(AVStream *st,
1253 int64_t pos, int64_t timestamp, int size, int distance, int flags)
1255 AVIndexEntry *entries, *ie;
1258 if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1261 entries = av_fast_realloc(st->index_entries,
1262 &st->index_entries_allocated_size,
1263 (st->nb_index_entries + 1) *
1264 sizeof(AVIndexEntry));
1268 st->index_entries= entries;
1270 index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
1273 index= st->nb_index_entries++;
1274 ie= &entries[index];
1275 assert(index==0 || ie[-1].timestamp < timestamp);
1277 ie= &entries[index];
1278 if(ie->timestamp != timestamp){
1279 if(ie->timestamp <= timestamp)
1281 memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
1282 st->nb_index_entries++;
1283 }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1284 distance= ie->min_distance;
1288 ie->timestamp = timestamp;
1289 ie->min_distance= distance;
1296 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1299 AVIndexEntry *entries= st->index_entries;
1300 int nb_entries= st->nb_index_entries;
1309 timestamp = entries[m].timestamp;
1310 if(timestamp >= wanted_timestamp)
1312 if(timestamp <= wanted_timestamp)
1315 m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1317 if(!(flags & AVSEEK_FLAG_ANY)){
1318 while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1319 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1330 int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1331 AVInputFormat *avif= s->iformat;
1332 int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1333 int64_t ts_min, ts_max, ts;
1338 if (stream_index < 0)
1342 av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1346 ts_min= AV_NOPTS_VALUE;
1347 pos_limit= -1; //gcc falsely says it may be uninitialized
1349 st= s->streams[stream_index];
1350 if(st->index_entries){
1353 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()
1354 index= FFMAX(index, 0);
1355 e= &st->index_entries[index];
1357 if(e->timestamp <= target_ts || e->pos == e->min_distance){
1359 ts_min= e->timestamp;
1361 av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1368 index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1369 assert(index < st->nb_index_entries);
1371 e= &st->index_entries[index];
1372 assert(e->timestamp >= target_ts);
1374 ts_max= e->timestamp;
1375 pos_limit= pos_max - e->min_distance;
1377 av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1378 pos_max,pos_limit, ts_max);
1383 pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1388 if ((ret = url_fseek(s->pb, pos, SEEK_SET)) < 0)
1391 av_update_cur_dts(s, st, ts);
1396 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 )){
1398 int64_t start_pos, filesize;
1402 av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1405 if(ts_min == AV_NOPTS_VALUE){
1406 pos_min = s->data_offset;
1407 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1408 if (ts_min == AV_NOPTS_VALUE)
1412 if(ts_max == AV_NOPTS_VALUE){
1414 filesize = url_fsize(s->pb);
1415 pos_max = filesize - 1;
1418 ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1420 }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1421 if (ts_max == AV_NOPTS_VALUE)
1425 int64_t tmp_pos= pos_max + 1;
1426 int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1427 if(tmp_ts == AV_NOPTS_VALUE)
1431 if(tmp_pos >= filesize)
1437 if(ts_min > ts_max){
1439 }else if(ts_min == ts_max){
1444 while (pos_min < pos_limit) {
1446 av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1450 assert(pos_limit <= pos_max);
1453 int64_t approximate_keyframe_distance= pos_max - pos_limit;
1454 // interpolate position (better than dichotomy)
1455 pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1456 + pos_min - approximate_keyframe_distance;
1457 }else if(no_change==1){
1458 // bisection, if interpolation failed to change min or max pos last time
1459 pos = (pos_min + pos_limit)>>1;
1461 /* linear search if bisection failed, can only happen if there
1462 are very few or no keyframes between min/max */
1467 else if(pos > pos_limit)
1471 ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1477 av_log(s, AV_LOG_DEBUG, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64" target:%"PRId64" limit:%"PRId64" start:%"PRId64" noc:%d\n",
1478 pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts, pos_limit,
1479 start_pos, no_change);
1481 if(ts == AV_NOPTS_VALUE){
1482 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1485 assert(ts != AV_NOPTS_VALUE);
1486 if (target_ts <= ts) {
1487 pos_limit = start_pos - 1;
1491 if (target_ts >= ts) {
1497 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1498 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
1501 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1503 ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1504 av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1505 pos, ts_min, target_ts, ts_max);
1511 static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1512 int64_t pos_min, pos_max;
1516 if (stream_index < 0)
1519 st= s->streams[stream_index];
1522 pos_min = s->data_offset;
1523 pos_max = url_fsize(s->pb) - 1;
1525 if (pos < pos_min) pos= pos_min;
1526 else if(pos > pos_max) pos= pos_max;
1528 url_fseek(s->pb, pos, SEEK_SET);
1531 av_update_cur_dts(s, st, ts);
1536 static int av_seek_frame_generic(AVFormatContext *s,
1537 int stream_index, int64_t timestamp, int flags)
1544 st = s->streams[stream_index];
1546 index = av_index_search_timestamp(st, timestamp, flags);
1548 if(index < 0 || index==st->nb_index_entries-1){
1552 if(st->nb_index_entries){
1553 assert(st->index_entries);
1554 ie= &st->index_entries[st->nb_index_entries-1];
1555 if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
1557 av_update_cur_dts(s, st, ie->timestamp);
1559 if ((ret = url_fseek(s->pb, s->data_offset, SEEK_SET)) < 0)
1565 ret = av_read_frame(s, &pkt);
1566 }while(ret == AVERROR(EAGAIN));
1569 av_free_packet(&pkt);
1570 if(stream_index == pkt.stream_index){
1571 if((pkt.flags & PKT_FLAG_KEY) && pkt.dts > timestamp)
1575 index = av_index_search_timestamp(st, timestamp, flags);
1580 av_read_frame_flush(s);
1581 if (s->iformat->read_seek){
1582 if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1585 ie = &st->index_entries[index];
1586 if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
1588 av_update_cur_dts(s, st, ie->timestamp);
1593 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1598 av_read_frame_flush(s);
1600 if(flags & AVSEEK_FLAG_BYTE)
1601 return av_seek_frame_byte(s, stream_index, timestamp, flags);
1603 if(stream_index < 0){
1604 stream_index= av_find_default_stream_index(s);
1605 if(stream_index < 0)
1608 st= s->streams[stream_index];
1609 /* timestamp for default must be expressed in AV_TIME_BASE units */
1610 timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1613 /* first, we try the format specific seek */
1614 if (s->iformat->read_seek)
1615 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1622 if(s->iformat->read_timestamp)
1623 return av_seek_frame_binary(s, stream_index, timestamp, flags);
1625 return av_seek_frame_generic(s, stream_index, timestamp, flags);
1628 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
1630 if(min_ts > ts || max_ts < ts)
1633 av_read_frame_flush(s);
1635 if (s->iformat->read_seek2)
1636 return s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
1638 if(s->iformat->read_timestamp){
1639 //try to seek via read_timestamp()
1642 //Fallback to old API if new is not implemented but old is
1643 //Note the old has somewat different sematics
1644 if(s->iformat->read_seek || 1)
1645 return av_seek_frame(s, stream_index, ts, flags | (ts - min_ts > (uint64_t)(max_ts - ts) ? AVSEEK_FLAG_BACKWARD : 0));
1647 // try some generic seek like av_seek_frame_generic() but with new ts semantics
1650 /*******************************************************/
1653 * Returns TRUE if the stream has accurate duration in any stream.
1655 * @return TRUE if the stream has accurate duration for at least one component.
1657 static int av_has_duration(AVFormatContext *ic)
1662 for(i = 0;i < ic->nb_streams; i++) {
1663 st = ic->streams[i];
1664 if (st->duration != AV_NOPTS_VALUE)
1671 * Estimate the stream timings from the one of each components.
1673 * Also computes the global bitrate if possible.
1675 static void av_update_stream_timings(AVFormatContext *ic)
1677 int64_t start_time, start_time1, end_time, end_time1;
1678 int64_t duration, duration1;
1682 start_time = INT64_MAX;
1683 end_time = INT64_MIN;
1684 duration = INT64_MIN;
1685 for(i = 0;i < ic->nb_streams; i++) {
1686 st = ic->streams[i];
1687 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
1688 start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1689 if (start_time1 < start_time)
1690 start_time = start_time1;
1691 if (st->duration != AV_NOPTS_VALUE) {
1692 end_time1 = start_time1
1693 + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1694 if (end_time1 > end_time)
1695 end_time = end_time1;
1698 if (st->duration != AV_NOPTS_VALUE) {
1699 duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1700 if (duration1 > duration)
1701 duration = duration1;
1704 if (start_time != INT64_MAX) {
1705 ic->start_time = start_time;
1706 if (end_time != INT64_MIN) {
1707 if (end_time - start_time > duration)
1708 duration = end_time - start_time;
1711 if (duration != INT64_MIN) {
1712 ic->duration = duration;
1713 if (ic->file_size > 0) {
1714 /* compute the bitrate */
1715 ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1716 (double)ic->duration;
1721 static void fill_all_stream_timings(AVFormatContext *ic)
1726 av_update_stream_timings(ic);
1727 for(i = 0;i < ic->nb_streams; i++) {
1728 st = ic->streams[i];
1729 if (st->start_time == AV_NOPTS_VALUE) {
1730 if(ic->start_time != AV_NOPTS_VALUE)
1731 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1732 if(ic->duration != AV_NOPTS_VALUE)
1733 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1738 static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1740 int64_t filesize, duration;
1744 /* if bit_rate is already set, we believe it */
1745 if (ic->bit_rate == 0) {
1747 for(i=0;i<ic->nb_streams;i++) {
1748 st = ic->streams[i];
1749 bit_rate += st->codec->bit_rate;
1751 ic->bit_rate = bit_rate;
1754 /* if duration is already set, we believe it */
1755 if (ic->duration == AV_NOPTS_VALUE &&
1756 ic->bit_rate != 0 &&
1757 ic->file_size != 0) {
1758 filesize = ic->file_size;
1760 for(i = 0; i < ic->nb_streams; i++) {
1761 st = ic->streams[i];
1762 duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1763 if (st->duration == AV_NOPTS_VALUE)
1764 st->duration = duration;
1770 #define DURATION_MAX_READ_SIZE 250000
1772 /* only usable for MPEG-PS streams */
1773 static void av_estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
1775 AVPacket pkt1, *pkt = &pkt1;
1777 int read_size, i, ret;
1778 int64_t end_time, start_time[MAX_STREAMS];
1779 int64_t filesize, offset, duration;
1783 /* flush packet queue */
1784 flush_packet_queue(ic);
1786 for(i=0;i<ic->nb_streams;i++) {
1787 st = ic->streams[i];
1788 if(st->start_time != AV_NOPTS_VALUE){
1789 start_time[i]= st->start_time;
1790 }else if(st->first_dts != AV_NOPTS_VALUE){
1791 start_time[i]= st->first_dts;
1793 av_log(st->codec, AV_LOG_WARNING, "start time is not set in av_estimate_timings_from_pts\n");
1796 av_parser_close(st->parser);
1798 av_free_packet(&st->cur_pkt);
1802 /* estimate the end time (duration) */
1803 /* XXX: may need to support wrapping */
1804 filesize = ic->file_size;
1805 offset = filesize - DURATION_MAX_READ_SIZE;
1809 url_fseek(ic->pb, offset, SEEK_SET);
1812 if (read_size >= DURATION_MAX_READ_SIZE)
1816 ret = av_read_packet(ic, pkt);
1817 }while(ret == AVERROR(EAGAIN));
1820 read_size += pkt->size;
1821 st = ic->streams[pkt->stream_index];
1822 if (pkt->pts != AV_NOPTS_VALUE &&
1823 start_time[pkt->stream_index] != AV_NOPTS_VALUE) {
1824 end_time = pkt->pts;
1825 duration = end_time - start_time[pkt->stream_index];
1827 duration += 1LL<<st->pts_wrap_bits;
1829 if (st->duration == AV_NOPTS_VALUE ||
1830 st->duration < duration)
1831 st->duration = duration;
1834 av_free_packet(pkt);
1837 fill_all_stream_timings(ic);
1839 url_fseek(ic->pb, old_offset, SEEK_SET);
1840 for(i=0; i<ic->nb_streams; i++){
1842 st->cur_dts= st->first_dts;
1843 st->last_IP_pts = AV_NOPTS_VALUE;
1847 static void av_estimate_timings(AVFormatContext *ic, int64_t old_offset)
1851 /* get the file size, if possible */
1852 if (ic->iformat->flags & AVFMT_NOFILE) {
1855 file_size = url_fsize(ic->pb);
1859 ic->file_size = file_size;
1861 if ((!strcmp(ic->iformat->name, "mpeg") ||
1862 !strcmp(ic->iformat->name, "mpegts")) &&
1863 file_size && !url_is_streamed(ic->pb)) {
1864 /* get accurate estimate from the PTSes */
1865 av_estimate_timings_from_pts(ic, old_offset);
1866 } else if (av_has_duration(ic)) {
1867 /* at least one component has timings - we use them for all
1869 fill_all_stream_timings(ic);
1871 av_log(ic, AV_LOG_WARNING, "Estimating duration from bitrate, this may be inaccurate\n");
1872 /* less precise: use bitrate info */
1873 av_estimate_timings_from_bit_rate(ic);
1875 av_update_stream_timings(ic);
1881 for(i = 0;i < ic->nb_streams; i++) {
1882 st = ic->streams[i];
1883 printf("%d: start_time: %0.3f duration: %0.3f\n",
1884 i, (double)st->start_time / AV_TIME_BASE,
1885 (double)st->duration / AV_TIME_BASE);
1887 printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1888 (double)ic->start_time / AV_TIME_BASE,
1889 (double)ic->duration / AV_TIME_BASE,
1890 ic->bit_rate / 1000);
1895 static int has_codec_parameters(AVCodecContext *enc)
1898 switch(enc->codec_type) {
1899 case CODEC_TYPE_AUDIO:
1900 val = enc->sample_rate && enc->channels && enc->sample_fmt != SAMPLE_FMT_NONE;
1901 if(!enc->frame_size &&
1902 (enc->codec_id == CODEC_ID_VORBIS ||
1903 enc->codec_id == CODEC_ID_AAC ||
1904 enc->codec_id == CODEC_ID_MP3 ||
1905 enc->codec_id == CODEC_ID_SPEEX))
1908 case CODEC_TYPE_VIDEO:
1909 val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
1915 return enc->codec_id != CODEC_ID_NONE && val != 0;
1918 static int try_decode_frame(AVStream *st, AVPacket *avpkt)
1922 int got_picture, data_size, ret=0;
1925 if(!st->codec->codec){
1926 codec = avcodec_find_decoder(st->codec->codec_id);
1929 ret = avcodec_open(st->codec, codec);
1934 if(!has_codec_parameters(st->codec)){
1935 switch(st->codec->codec_type) {
1936 case CODEC_TYPE_VIDEO:
1937 avcodec_get_frame_defaults(&picture);
1938 ret = avcodec_decode_video2(st->codec, &picture,
1939 &got_picture, avpkt);
1941 case CODEC_TYPE_AUDIO:
1942 data_size = FFMAX(avpkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
1943 samples = av_malloc(data_size);
1946 ret = avcodec_decode_audio3(st->codec, samples,
1958 unsigned int ff_codec_get_tag(const AVCodecTag *tags, int id)
1960 while (tags->id != CODEC_ID_NONE) {
1968 enum CodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
1971 for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
1972 if(tag == tags[i].tag)
1975 for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
1976 if( toupper((tag >> 0)&0xFF) == toupper((tags[i].tag >> 0)&0xFF)
1977 && toupper((tag >> 8)&0xFF) == toupper((tags[i].tag >> 8)&0xFF)
1978 && toupper((tag >>16)&0xFF) == toupper((tags[i].tag >>16)&0xFF)
1979 && toupper((tag >>24)&0xFF) == toupper((tags[i].tag >>24)&0xFF))
1982 return CODEC_ID_NONE;
1985 unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum CodecID id)
1988 for(i=0; tags && tags[i]; i++){
1989 int tag= ff_codec_get_tag(tags[i], id);
1995 enum CodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
1998 for(i=0; tags && tags[i]; i++){
1999 enum CodecID id= ff_codec_get_id(tags[i], tag);
2000 if(id!=CODEC_ID_NONE) return id;
2002 return CODEC_ID_NONE;
2005 static void compute_chapters_end(AVFormatContext *s)
2009 for (i=0; i+1<s->nb_chapters; i++)
2010 if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2011 assert(s->chapters[i]->start <= s->chapters[i+1]->start);
2012 assert(!av_cmp_q(s->chapters[i]->time_base, s->chapters[i+1]->time_base));
2013 s->chapters[i]->end = s->chapters[i+1]->start;
2016 if (s->nb_chapters && s->chapters[i]->end == AV_NOPTS_VALUE) {
2017 assert(s->start_time != AV_NOPTS_VALUE);
2018 assert(s->duration > 0);
2019 s->chapters[i]->end = av_rescale_q(s->start_time + s->duration,
2021 s->chapters[i]->time_base);
2025 #define MAX_STD_TIMEBASES (60*12+5)
2026 static int get_std_framerate(int i){
2027 if(i<60*12) return i*1001;
2028 else return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
2032 * Is the time base unreliable.
2033 * This is a heuristic to balance between quick acceptance of the values in
2034 * the headers vs. some extra checks.
2035 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2036 * MPEG-2 commonly misuses field repeat flags to store different framerates.
2037 * And there are "variable" fps files this needs to detect as well.
2039 static int tb_unreliable(AVCodecContext *c){
2040 if( c->time_base.den >= 101L*c->time_base.num
2041 || c->time_base.den < 5L*c->time_base.num
2042 /* || c->codec_tag == AV_RL32("DIVX")
2043 || c->codec_tag == AV_RL32("XVID")*/
2044 || c->codec_id == CODEC_ID_MPEG2VIDEO
2045 || c->codec_id == CODEC_ID_H264
2051 int av_find_stream_info(AVFormatContext *ic)
2053 int i, count, ret, read_size, j;
2055 AVPacket pkt1, *pkt;
2056 int64_t last_dts[MAX_STREAMS];
2057 int64_t duration_gcd[MAX_STREAMS]={0};
2058 int duration_count[MAX_STREAMS]={0};
2059 double (*duration_error)[MAX_STD_TIMEBASES];
2060 int64_t old_offset = url_ftell(ic->pb);
2061 int64_t codec_info_duration[MAX_STREAMS]={0};
2062 int codec_info_nb_frames[MAX_STREAMS]={0};
2064 duration_error = av_mallocz(MAX_STREAMS * sizeof(*duration_error));
2065 if (!duration_error) return AVERROR(ENOMEM);
2067 for(i=0;i<ic->nb_streams;i++) {
2068 st = ic->streams[i];
2069 if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2070 /* if(!st->time_base.num)
2072 if(!st->codec->time_base.num)
2073 st->codec->time_base= st->time_base;
2075 //only for the split stuff
2077 st->parser = av_parser_init(st->codec->codec_id);
2078 if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
2079 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2084 for(i=0;i<MAX_STREAMS;i++){
2085 last_dts[i]= AV_NOPTS_VALUE;
2091 if(url_interrupt_cb()){
2092 ret= AVERROR(EINTR);
2093 av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2097 /* check if one codec still needs to be handled */
2098 for(i=0;i<ic->nb_streams;i++) {
2099 st = ic->streams[i];
2100 if (!has_codec_parameters(st->codec))
2102 /* variable fps and no guess at the real fps */
2103 if( tb_unreliable(st->codec)
2104 && duration_count[i]<20 && st->codec->codec_type == CODEC_TYPE_VIDEO)
2106 if(st->parser && st->parser->parser->split && !st->codec->extradata)
2108 if(st->first_dts == AV_NOPTS_VALUE)
2111 if (i == ic->nb_streams) {
2112 /* NOTE: if the format has no header, then we need to read
2113 some packets to get most of the streams, so we cannot
2115 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2116 /* if we found the info for all the codecs, we can stop */
2118 av_log(ic, AV_LOG_DEBUG, "All info found\n");
2122 /* we did not get all the codec info, but we read too much data */
2123 if (read_size >= ic->probesize) {
2125 av_log(ic, AV_LOG_WARNING, "MAX_READ_SIZE:%d reached\n", ic->probesize);
2129 /* NOTE: a new stream can be added there if no header in file
2130 (AVFMTCTX_NOHEADER) */
2131 ret = av_read_frame_internal(ic, &pkt1);
2132 if(ret == AVERROR(EAGAIN))
2136 ret = -1; /* we could not have all the codec parameters before EOF */
2137 for(i=0;i<ic->nb_streams;i++) {
2138 st = ic->streams[i];
2139 if (!has_codec_parameters(st->codec)){
2141 avcodec_string(buf, sizeof(buf), st->codec, 0);
2142 av_log(ic, AV_LOG_WARNING, "Could not find codec parameters (%s)\n", buf);
2150 pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2151 if(av_dup_packet(pkt) < 0) {
2152 av_free(duration_error);
2153 return AVERROR(ENOMEM);
2156 read_size += pkt->size;
2158 st = ic->streams[pkt->stream_index];
2159 if(codec_info_nb_frames[st->index]>1) {
2160 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){
2161 av_log(ic, AV_LOG_WARNING, "max_analyze_duration reached\n");
2164 codec_info_duration[st->index] += pkt->duration;
2166 if (pkt->duration != 0)
2167 codec_info_nb_frames[st->index]++;
2170 int index= pkt->stream_index;
2171 int64_t last= last_dts[index];
2172 int64_t duration= pkt->dts - last;
2174 if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
2175 double dur= duration * av_q2d(st->time_base);
2177 // if(st->codec->codec_type == CODEC_TYPE_VIDEO)
2178 // av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
2179 if(duration_count[index] < 2)
2180 memset(duration_error[index], 0, sizeof(*duration_error));
2181 for(i=1; i<MAX_STD_TIMEBASES; i++){
2182 int framerate= get_std_framerate(i);
2183 int ticks= lrintf(dur*framerate/(1001*12));
2184 double error= dur - ticks*1001*12/(double)framerate;
2185 duration_error[index][i] += error*error;
2187 duration_count[index]++;
2188 // ignore the first 4 values, they might have some random jitter
2189 if (duration_count[index] > 3)
2190 duration_gcd[index] = av_gcd(duration_gcd[index], duration);
2192 if(last == AV_NOPTS_VALUE || duration_count[index]<=1)
2193 last_dts[pkt->stream_index]= pkt->dts;
2195 if(st->parser && st->parser->parser->split && !st->codec->extradata){
2196 int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2198 st->codec->extradata_size= i;
2199 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2200 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2201 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2205 /* if still no information, we try to open the codec and to
2206 decompress the frame. We try to avoid that in most cases as
2207 it takes longer and uses more memory. For MPEG-4, we need to
2208 decompress for QuickTime. */
2209 if (!has_codec_parameters(st->codec))
2210 try_decode_frame(st, pkt);
2215 // close codecs which were opened in try_decode_frame()
2216 for(i=0;i<ic->nb_streams;i++) {
2217 st = ic->streams[i];
2218 if(st->codec->codec)
2219 avcodec_close(st->codec);
2221 for(i=0;i<ic->nb_streams;i++) {
2222 st = ic->streams[i];
2223 if(codec_info_nb_frames[i]>2 && !st->avg_frame_rate.num)
2224 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2225 (codec_info_nb_frames[i]-2)*(int64_t)st->time_base.den,
2226 codec_info_duration[i] *(int64_t)st->time_base.num, 60000);
2227 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2228 if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample)
2229 st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2231 // the check for tb_unreliable() is not completely correct, since this is not about handling
2232 // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2233 // ipmovie.c produces.
2234 if (tb_unreliable(st->codec) && duration_count[i] > 15 && duration_gcd[i] > 1)
2235 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);
2236 if(duration_count[i]
2237 && tb_unreliable(st->codec) /*&&
2238 //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2239 st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den*/){
2241 double best_error= 2*av_q2d(st->time_base);
2242 best_error= best_error*best_error*duration_count[i]*1000*12*30;
2244 for(j=1; j<MAX_STD_TIMEBASES; j++){
2245 double error= duration_error[i][j] * get_std_framerate(j);
2246 // if(st->codec->codec_type == CODEC_TYPE_VIDEO)
2247 // av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
2248 if(error < best_error){
2250 num = get_std_framerate(j);
2253 // do not increase frame rate by more than 1 % in order to match a standard rate.
2254 if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
2255 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2258 if (!st->r_frame_rate.num){
2259 if( st->codec->time_base.den * (int64_t)st->time_base.num
2260 <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
2261 st->r_frame_rate.num = st->codec->time_base.den;
2262 st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
2264 st->r_frame_rate.num = st->time_base.den;
2265 st->r_frame_rate.den = st->time_base.num;
2268 }else if(st->codec->codec_type == CODEC_TYPE_AUDIO) {
2269 if(!st->codec->bits_per_coded_sample)
2270 st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2274 av_estimate_timings(ic, old_offset);
2276 compute_chapters_end(ic);
2279 /* correct DTS for B-frame streams with no timestamps */
2280 for(i=0;i<ic->nb_streams;i++) {
2281 st = ic->streams[i];
2282 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2284 ppktl = &ic->packet_buffer;
2286 if(ppkt1->stream_index != i)
2288 if(ppkt1->pkt->dts < 0)
2290 if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2292 ppkt1->pkt->dts -= delta;
2297 st->cur_dts -= delta;
2303 av_free(duration_error);
2308 /*******************************************************/
2310 int av_read_play(AVFormatContext *s)
2312 if (s->iformat->read_play)
2313 return s->iformat->read_play(s);
2315 return av_url_read_fpause(s->pb, 0);
2316 return AVERROR(ENOSYS);
2319 int av_read_pause(AVFormatContext *s)
2321 if (s->iformat->read_pause)
2322 return s->iformat->read_pause(s);
2324 return av_url_read_fpause(s->pb, 1);
2325 return AVERROR(ENOSYS);
2328 void av_close_input_stream(AVFormatContext *s)
2333 if (s->iformat->read_close)
2334 s->iformat->read_close(s);
2335 for(i=0;i<s->nb_streams;i++) {
2336 /* free all data in a stream component */
2339 av_parser_close(st->parser);
2340 av_free_packet(&st->cur_pkt);
2342 av_metadata_free(&st->metadata);
2343 av_free(st->index_entries);
2344 av_free(st->codec->extradata);
2346 #if LIBAVFORMAT_VERSION_INT < (53<<16)
2347 av_free(st->filename);
2349 av_free(st->priv_data);
2352 for(i=s->nb_programs-1; i>=0; i--) {
2353 #if LIBAVFORMAT_VERSION_INT < (53<<16)
2354 av_freep(&s->programs[i]->provider_name);
2355 av_freep(&s->programs[i]->name);
2357 av_metadata_free(&s->programs[i]->metadata);
2358 av_freep(&s->programs[i]->stream_index);
2359 av_freep(&s->programs[i]);
2361 av_freep(&s->programs);
2362 flush_packet_queue(s);
2363 av_freep(&s->priv_data);
2364 while(s->nb_chapters--) {
2365 #if LIBAVFORMAT_VERSION_INT < (53<<16)
2366 av_free(s->chapters[s->nb_chapters]->title);
2368 av_metadata_free(&s->chapters[s->nb_chapters]->metadata);
2369 av_free(s->chapters[s->nb_chapters]);
2371 av_freep(&s->chapters);
2372 av_metadata_free(&s->metadata);
2376 void av_close_input_file(AVFormatContext *s)
2378 ByteIOContext *pb = s->iformat->flags & AVFMT_NOFILE ? NULL : s->pb;
2379 av_close_input_stream(s);
2384 AVStream *av_new_stream(AVFormatContext *s, int id)
2389 if (s->nb_streams >= MAX_STREAMS)
2392 st = av_mallocz(sizeof(AVStream));
2396 st->codec= avcodec_alloc_context();
2398 /* no default bitrate if decoding */
2399 st->codec->bit_rate = 0;
2401 st->index = s->nb_streams;
2403 st->start_time = AV_NOPTS_VALUE;
2404 st->duration = AV_NOPTS_VALUE;
2405 /* we set the current DTS to 0 so that formats without any timestamps
2406 but durations get some timestamps, formats with some unknown
2407 timestamps have their first few packets buffered and the
2408 timestamps corrected before they are returned to the user */
2410 st->first_dts = AV_NOPTS_VALUE;
2411 st->probe_packets = MAX_PROBE_PACKETS;
2413 /* default pts setting is MPEG-like */
2414 av_set_pts_info(st, 33, 1, 90000);
2415 st->last_IP_pts = AV_NOPTS_VALUE;
2416 for(i=0; i<MAX_REORDER_DELAY+1; i++)
2417 st->pts_buffer[i]= AV_NOPTS_VALUE;
2418 st->reference_dts = AV_NOPTS_VALUE;
2420 st->sample_aspect_ratio = (AVRational){0,1};
2422 s->streams[s->nb_streams++] = st;
2426 AVProgram *av_new_program(AVFormatContext *ac, int id)
2428 AVProgram *program=NULL;
2432 av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2435 for(i=0; i<ac->nb_programs; i++)
2436 if(ac->programs[i]->id == id)
2437 program = ac->programs[i];
2440 program = av_mallocz(sizeof(AVProgram));
2443 dynarray_add(&ac->programs, &ac->nb_programs, program);
2444 program->discard = AVDISCARD_NONE;
2451 AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2453 AVChapter *chapter = NULL;
2456 for(i=0; i<s->nb_chapters; i++)
2457 if(s->chapters[i]->id == id)
2458 chapter = s->chapters[i];
2461 chapter= av_mallocz(sizeof(AVChapter));
2464 dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2466 #if LIBAVFORMAT_VERSION_INT < (53<<16)
2467 av_free(chapter->title);
2469 av_metadata_set(&chapter->metadata, "title", title);
2471 chapter->time_base= time_base;
2472 chapter->start = start;
2478 /************************************************************/
2479 /* output media file */
2481 int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2485 if (s->oformat->priv_data_size > 0) {
2486 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2488 return AVERROR(ENOMEM);
2490 s->priv_data = NULL;
2492 if (s->oformat->set_parameters) {
2493 ret = s->oformat->set_parameters(s, ap);
2500 int av_write_header(AVFormatContext *s)
2505 // some sanity checks
2506 if (s->nb_streams == 0) {
2507 av_log(s, AV_LOG_ERROR, "no streams\n");
2511 for(i=0;i<s->nb_streams;i++) {
2514 switch (st->codec->codec_type) {
2515 case CODEC_TYPE_AUDIO:
2516 if(st->codec->sample_rate<=0){
2517 av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2520 if(!st->codec->block_align)
2521 st->codec->block_align = st->codec->channels *
2522 av_get_bits_per_sample(st->codec->codec_id) >> 3;
2524 case CODEC_TYPE_VIDEO:
2525 if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2526 av_log(s, AV_LOG_ERROR, "time base not set\n");
2529 if(st->codec->width<=0 || st->codec->height<=0){
2530 av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2533 if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)){
2534 av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between encoder and muxer layer\n");
2540 if(s->oformat->codec_tag){
2541 if(st->codec->codec_tag){
2543 //check that tag + id is in the table
2544 //if neither is in the table -> OK
2545 //if tag is in the table with another id -> FAIL
2546 //if id is in the table with another tag -> FAIL unless strict < ?
2548 st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2551 if(s->oformat->flags & AVFMT_GLOBALHEADER &&
2552 !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
2553 av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
2556 if (!s->priv_data && s->oformat->priv_data_size > 0) {
2557 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2559 return AVERROR(ENOMEM);
2562 #if LIBAVFORMAT_VERSION_MAJOR < 53
2563 ff_metadata_mux_compat(s);
2566 if(s->oformat->write_header){
2567 ret = s->oformat->write_header(s);
2572 /* init PTS generation */
2573 for(i=0;i<s->nb_streams;i++) {
2574 int64_t den = AV_NOPTS_VALUE;
2577 switch (st->codec->codec_type) {
2578 case CODEC_TYPE_AUDIO:
2579 den = (int64_t)st->time_base.num * st->codec->sample_rate;
2581 case CODEC_TYPE_VIDEO:
2582 den = (int64_t)st->time_base.num * st->codec->time_base.den;
2587 if (den != AV_NOPTS_VALUE) {
2589 return AVERROR_INVALIDDATA;
2590 av_frac_init(&st->pts, 0, 0, den);
2596 //FIXME merge with compute_pkt_fields
2597 static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt){
2598 int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2599 int num, den, frame_size, i;
2601 // 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);
2603 /* if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2606 /* duration field */
2607 if (pkt->duration == 0) {
2608 compute_frame_duration(&num, &den, st, NULL, pkt);
2610 pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
2614 if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
2617 //XXX/FIXME this is a temporary hack until all encoders output pts
2618 if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2620 // pkt->pts= st->cur_dts;
2621 pkt->pts= st->pts.val;
2624 //calculate dts from pts
2625 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
2626 st->pts_buffer[0]= pkt->pts;
2627 for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2628 st->pts_buffer[i]= (i-delay-1) * pkt->duration;
2629 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2630 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2632 pkt->dts= st->pts_buffer[0];
2635 if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2636 av_log(s, AV_LOG_ERROR,
2637 "st:%d error, non monotone timestamps %"PRId64" >= %"PRId64"\n",
2638 st->index, st->cur_dts, pkt->dts);
2641 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2642 av_log(s, AV_LOG_ERROR, "st:%d error, pts < dts\n", st->index);
2646 // av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2647 st->cur_dts= pkt->dts;
2648 st->pts.val= pkt->dts;
2651 switch (st->codec->codec_type) {
2652 case CODEC_TYPE_AUDIO:
2653 frame_size = get_audio_frame_size(st->codec, pkt->size);
2655 /* HACK/FIXME, we skip the initial 0 size packets as they are most
2656 likely equal to the encoder delay, but it would be better if we
2657 had the real timestamps from the encoder */
2658 if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2659 av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2662 case CODEC_TYPE_VIDEO:
2663 av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2671 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2673 int ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt);
2675 if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2678 ret= s->oformat->write_packet(s, pkt);
2680 ret= url_ferror(s->pb);
2684 void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
2685 int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
2687 AVPacketList **next_point, *this_pktl;
2689 this_pktl = av_mallocz(sizeof(AVPacketList));
2690 this_pktl->pkt= *pkt;
2691 pkt->destruct= NULL; // do not free original but only the copy
2692 av_dup_packet(&this_pktl->pkt); // duplicate the packet if it uses non-alloced memory
2694 if(s->streams[pkt->stream_index]->last_in_packet_buffer){
2695 next_point = &(s->streams[pkt->stream_index]->last_in_packet_buffer->next);
2697 next_point = &s->packet_buffer;
2700 if(compare(s, &s->packet_buffer_end->pkt, pkt)){
2701 while(!compare(s, &(*next_point)->pkt, pkt)){
2702 next_point= &(*next_point)->next;
2706 next_point = &(s->packet_buffer_end->next);
2709 assert(!*next_point);
2711 s->packet_buffer_end= this_pktl;
2714 this_pktl->next= *next_point;
2716 s->streams[pkt->stream_index]->last_in_packet_buffer=
2717 *next_point= this_pktl;
2720 int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
2722 AVStream *st = s->streams[ pkt ->stream_index];
2723 AVStream *st2= s->streams[ next->stream_index];
2724 int64_t left = st2->time_base.num * (int64_t)st ->time_base.den;
2725 int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2727 if (pkt->dts == AV_NOPTS_VALUE)
2730 return next->dts * left > pkt->dts * right; //FIXME this can overflow
2733 int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2739 ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
2742 for(i=0; i < s->nb_streams; i++)
2743 stream_count+= !!s->streams[i]->last_in_packet_buffer;
2745 if(stream_count && (s->nb_streams == stream_count || flush)){
2746 pktl= s->packet_buffer;
2749 s->packet_buffer= pktl->next;
2750 if(!s->packet_buffer)
2751 s->packet_buffer_end= NULL;
2753 if(s->streams[out->stream_index]->last_in_packet_buffer == pktl)
2754 s->streams[out->stream_index]->last_in_packet_buffer= NULL;
2758 av_init_packet(out);
2764 * Interleaves an AVPacket correctly so it can be muxed.
2765 * @param out the interleaved packet will be output here
2766 * @param in the input packet
2767 * @param flush 1 if no further packets are available as input and all
2768 * remaining packets should be output
2769 * @return 1 if a packet was output, 0 if no packet could be output,
2770 * < 0 if an error occurred
2772 static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2773 if(s->oformat->interleave_packet)
2774 return s->oformat->interleave_packet(s, out, in, flush);
2776 return av_interleave_packet_per_dts(s, out, in, flush);
2779 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2780 AVStream *st= s->streams[ pkt->stream_index];
2782 //FIXME/XXX/HACK drop zero sized packets
2783 if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2786 //av_log(NULL, AV_LOG_DEBUG, "av_interleaved_write_frame %d %"PRId64" %"PRId64"\n", pkt->size, pkt->dts, pkt->pts);
2787 if(compute_pkt_fields2(s, st, pkt) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2790 if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2795 int ret= av_interleave_packet(s, &opkt, pkt, 0);
2796 if(ret<=0) //FIXME cleanup needed for ret<0 ?
2799 ret= s->oformat->write_packet(s, &opkt);
2801 av_free_packet(&opkt);
2806 if(url_ferror(s->pb))
2807 return url_ferror(s->pb);
2811 int av_write_trailer(AVFormatContext *s)
2817 ret= av_interleave_packet(s, &pkt, NULL, 1);
2818 if(ret<0) //FIXME cleanup needed for ret<0 ?
2823 ret= s->oformat->write_packet(s, &pkt);
2825 av_free_packet(&pkt);
2829 if(url_ferror(s->pb))
2833 if(s->oformat->write_trailer)
2834 ret = s->oformat->write_trailer(s);
2837 ret=url_ferror(s->pb);
2838 for(i=0;i<s->nb_streams;i++)
2839 av_freep(&s->streams[i]->priv_data);
2840 av_freep(&s->priv_data);
2844 void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
2847 AVProgram *program=NULL;
2850 if (idx >= ac->nb_streams) {
2851 av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
2855 for(i=0; i<ac->nb_programs; i++){
2856 if(ac->programs[i]->id != progid)
2858 program = ac->programs[i];
2859 for(j=0; j<program->nb_stream_indexes; j++)
2860 if(program->stream_index[j] == idx)
2863 tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
2866 program->stream_index = tmp;
2867 program->stream_index[program->nb_stream_indexes++] = idx;
2872 static void print_fps(double d, const char *postfix){
2873 uint64_t v= lrintf(d*100);
2874 if (v% 100 ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
2875 else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
2876 else av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
2879 static void dump_metadata(void *ctx, AVMetadata *m, const char *indent)
2881 if(m && !(m->count == 1 && av_metadata_get(m, "language", NULL, 0))){
2882 AVMetadataTag *tag=NULL;
2884 av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
2885 while((tag=av_metadata_get(m, "", tag, AV_METADATA_IGNORE_SUFFIX))) {
2886 if(strcmp("language", tag->key))
2887 av_log(ctx, AV_LOG_INFO, "%s %-16s: %s\n", indent, tag->key, tag->value);
2892 /* "user interface" functions */
2893 static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
2896 int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
2897 AVStream *st = ic->streams[i];
2898 int g = av_gcd(st->time_base.num, st->time_base.den);
2899 AVMetadataTag *lang = av_metadata_get(st->metadata, "language", NULL, 0);
2900 avcodec_string(buf, sizeof(buf), st->codec, is_output);
2901 av_log(NULL, AV_LOG_INFO, " Stream #%d.%d", index, i);
2902 /* the pid is an important information, so we display it */
2903 /* XXX: add a generic system */
2904 if (flags & AVFMT_SHOW_IDS)
2905 av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
2907 av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
2908 av_log(NULL, AV_LOG_DEBUG, ", %d/%d", st->time_base.num/g, st->time_base.den/g);
2909 av_log(NULL, AV_LOG_INFO, ": %s", buf);
2910 if (st->sample_aspect_ratio.num && // default
2911 av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
2912 AVRational display_aspect_ratio;
2913 av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
2914 st->codec->width*st->sample_aspect_ratio.num,
2915 st->codec->height*st->sample_aspect_ratio.den,
2917 av_log(NULL, AV_LOG_INFO, ", PAR %d:%d DAR %d:%d",
2918 st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
2919 display_aspect_ratio.num, display_aspect_ratio.den);
2921 if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2922 if(st->avg_frame_rate.den && st->avg_frame_rate.num)
2923 print_fps(av_q2d(st->avg_frame_rate), "fps");
2924 if(st->r_frame_rate.den && st->r_frame_rate.num)
2925 print_fps(av_q2d(st->r_frame_rate), "tbr");
2926 if(st->time_base.den && st->time_base.num)
2927 print_fps(1/av_q2d(st->time_base), "tbn");
2928 if(st->codec->time_base.den && st->codec->time_base.num)
2929 print_fps(1/av_q2d(st->codec->time_base), "tbc");
2931 av_log(NULL, AV_LOG_INFO, "\n");
2932 dump_metadata(NULL, st->metadata, " ");
2935 void dump_format(AVFormatContext *ic,
2941 uint8_t *printed = av_mallocz(ic->nb_streams);
2942 if (ic->nb_streams && !printed)
2945 av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
2946 is_output ? "Output" : "Input",
2948 is_output ? ic->oformat->name : ic->iformat->name,
2949 is_output ? "to" : "from", url);
2950 dump_metadata(NULL, ic->metadata, " ");
2952 av_log(NULL, AV_LOG_INFO, " Duration: ");
2953 if (ic->duration != AV_NOPTS_VALUE) {
2954 int hours, mins, secs, us;
2955 secs = ic->duration / AV_TIME_BASE;
2956 us = ic->duration % AV_TIME_BASE;
2961 av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
2962 (100 * us) / AV_TIME_BASE);
2964 av_log(NULL, AV_LOG_INFO, "N/A");
2966 if (ic->start_time != AV_NOPTS_VALUE) {
2968 av_log(NULL, AV_LOG_INFO, ", start: ");
2969 secs = ic->start_time / AV_TIME_BASE;
2970 us = ic->start_time % AV_TIME_BASE;
2971 av_log(NULL, AV_LOG_INFO, "%d.%06d",
2972 secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
2974 av_log(NULL, AV_LOG_INFO, ", bitrate: ");
2976 av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
2978 av_log(NULL, AV_LOG_INFO, "N/A");
2980 av_log(NULL, AV_LOG_INFO, "\n");
2982 if(ic->nb_programs) {
2983 int j, k, total = 0;
2984 for(j=0; j<ic->nb_programs; j++) {
2985 AVMetadataTag *name = av_metadata_get(ic->programs[j]->metadata,
2987 av_log(NULL, AV_LOG_INFO, " Program %d %s\n", ic->programs[j]->id,
2988 name ? name->value : "");
2989 dump_metadata(NULL, ic->programs[j]->metadata, " ");
2990 for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
2991 dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
2992 printed[ic->programs[j]->stream_index[k]] = 1;
2994 total += ic->programs[j]->nb_stream_indexes;
2996 if (total < ic->nb_streams)
2997 av_log(NULL, AV_LOG_INFO, " No Program\n");
2999 for(i=0;i<ic->nb_streams;i++)
3001 dump_stream_format(ic, i, index, is_output);
3006 #if LIBAVFORMAT_VERSION_MAJOR < 53
3007 int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
3009 return av_parse_video_frame_size(width_ptr, height_ptr, str);
3012 int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
3014 AVRational frame_rate;
3015 int ret = av_parse_video_frame_rate(&frame_rate, arg);
3016 *frame_rate_num= frame_rate.num;
3017 *frame_rate_den= frame_rate.den;
3022 int64_t av_gettime(void)
3025 gettimeofday(&tv,NULL);
3026 return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
3029 int64_t parse_date(const char *datestr, int duration)
3035 static const char * const date_fmt[] = {
3039 static const char * const time_fmt[] = {
3049 time_t now = time(0);
3051 len = strlen(datestr);
3053 lastch = datestr[len - 1];
3056 is_utc = (lastch == 'z' || lastch == 'Z');
3058 memset(&dt, 0, sizeof(dt));
3063 if (!strncasecmp(datestr, "now", len))
3064 return (int64_t) now * 1000000;
3066 /* parse the year-month-day part */
3067 for (i = 0; i < FF_ARRAY_ELEMS(date_fmt); i++) {
3068 q = small_strptime(p, date_fmt[i], &dt);
3074 /* if the year-month-day part is missing, then take the
3075 * current year-month-day time */
3080 dt = *localtime(&now);
3082 dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
3087 if (*p == 'T' || *p == 't' || *p == ' ')
3090 /* parse the hour-minute-second part */
3091 for (i = 0; i < FF_ARRAY_ELEMS(time_fmt); i++) {
3092 q = small_strptime(p, time_fmt[i], &dt);
3098 /* parse datestr as a duration */
3103 /* parse datestr as HH:MM:SS */
3104 q = small_strptime(p, time_fmt[0], &dt);
3106 /* parse datestr as S+ */
3107 dt.tm_sec = strtol(p, (char **)&q, 10);
3109 /* the parsing didn't succeed */
3116 /* Now we have all the fields that we can get */
3122 t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
3124 dt.tm_isdst = -1; /* unknown */
3134 /* parse the .m... part */
3138 for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
3141 val += n * (*q - '0');
3145 return negative ? -t : t;
3148 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
3158 while (*p != '\0' && *p != '=' && *p != '&') {
3159 if ((q - tag) < sizeof(tag) - 1)
3167 while (*p != '&' && *p != '\0') {
3168 if ((q - arg) < arg_size - 1) {
3178 if (!strcmp(tag, tag1))
3187 int av_get_frame_filename(char *buf, int buf_size,
3188 const char *path, int number)
3191 char *q, buf1[20], c;
3192 int nd, len, percentd_found;
3204 while (isdigit(*p)) {
3205 nd = nd * 10 + *p++ - '0';
3208 } while (isdigit(c));
3217 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3219 if ((q - buf + len) > buf_size - 1)
3221 memcpy(q, buf1, len);
3229 if ((q - buf) < buf_size - 1)
3233 if (!percentd_found)
3242 static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3246 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3248 for(i=0;i<size;i+=16) {
3255 PRINT(" %02x", buf[i+j]);
3260 for(j=0;j<len;j++) {
3262 if (c < ' ' || c > '~')
3271 void av_hex_dump(FILE *f, uint8_t *buf, int size)
3273 hex_dump_internal(NULL, f, 0, buf, size);
3276 void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3278 hex_dump_internal(avcl, NULL, level, buf, size);
3281 //FIXME needs to know the time_base
3282 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload)
3285 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3286 PRINT("stream #%d:\n", pkt->stream_index);
3287 PRINT(" keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
3288 PRINT(" duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
3289 /* DTS is _always_ valid after av_read_frame() */
3291 if (pkt->dts == AV_NOPTS_VALUE)
3294 PRINT("%0.3f", (double)pkt->dts / AV_TIME_BASE);
3295 /* PTS may not be known if B-frames are present. */
3297 if (pkt->pts == AV_NOPTS_VALUE)
3300 PRINT("%0.3f", (double)pkt->pts / AV_TIME_BASE);
3302 PRINT(" size=%d\n", pkt->size);
3305 av_hex_dump(f, pkt->data, pkt->size);
3308 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3310 pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
3313 void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3315 pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
3318 void url_split(char *proto, int proto_size,
3319 char *authorization, int authorization_size,
3320 char *hostname, int hostname_size,
3322 char *path, int path_size,
3325 const char *p, *ls, *at, *col, *brk;
3327 if (port_ptr) *port_ptr = -1;
3328 if (proto_size > 0) proto[0] = 0;
3329 if (authorization_size > 0) authorization[0] = 0;
3330 if (hostname_size > 0) hostname[0] = 0;
3331 if (path_size > 0) path[0] = 0;
3333 /* parse protocol */
3334 if ((p = strchr(url, ':'))) {
3335 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3340 /* no protocol means plain filename */
3341 av_strlcpy(path, url, path_size);
3345 /* separate path from hostname */
3346 ls = strchr(p, '/');
3348 ls = strchr(p, '?');
3350 av_strlcpy(path, ls, path_size);
3352 ls = &p[strlen(p)]; // XXX
3354 /* the rest is hostname, use that to parse auth/port */
3356 /* authorization (user[:pass]@hostname) */
3357 if ((at = strchr(p, '@')) && at < ls) {
3358 av_strlcpy(authorization, p,
3359 FFMIN(authorization_size, at + 1 - p));
3360 p = at + 1; /* skip '@' */
3363 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3365 av_strlcpy(hostname, p + 1,
3366 FFMIN(hostname_size, brk - p));
3367 if (brk[1] == ':' && port_ptr)
3368 *port_ptr = atoi(brk + 2);
3369 } else if ((col = strchr(p, ':')) && col < ls) {
3370 av_strlcpy(hostname, p,
3371 FFMIN(col + 1 - p, hostname_size));
3372 if (port_ptr) *port_ptr = atoi(col + 1);
3374 av_strlcpy(hostname, p,
3375 FFMIN(ls + 1 - p, hostname_size));
3379 char *ff_data_to_hex(char *buff, const uint8_t *src, int s)
3382 static const char hex_table[16] = { '0', '1', '2', '3',
3385 'C', 'D', 'E', 'F' };
3387 for(i = 0; i < s; i++) {
3388 buff[i * 2] = hex_table[src[i] >> 4];
3389 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3395 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3396 unsigned int pts_num, unsigned int pts_den)
3398 s->pts_wrap_bits = pts_wrap_bits;
3400 if(av_reduce(&s->time_base.num, &s->time_base.den, pts_num, pts_den, INT_MAX)){
3401 if(s->time_base.num != pts_num)
3402 av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/s->time_base.num);
3404 av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3406 if(!s->time_base.num || !s->time_base.den)
3407 s->time_base.num= s->time_base.den= 0;