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 /* fraction handling */
47 * f = val + (num / den) + 0.5.
49 * 'num' is normalized so that it is such as 0 <= num < den.
51 * @param f fractional number
52 * @param val integer value
53 * @param num must be >= 0
54 * @param den must be >= 1
56 static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
69 * Fractional addition to f: f = f + (incr / f->den).
71 * @param f fractional number
72 * @param incr increment, can be positive or negative
74 static void av_frac_add(AVFrac *f, int64_t incr)
87 } else if (num >= den) {
94 /** head of registered input format linked list */
95 AVInputFormat *first_iformat = NULL;
96 /** head of registered output format linked list */
97 AVOutputFormat *first_oformat = NULL;
99 AVInputFormat *av_iformat_next(AVInputFormat *f)
101 if(f) return f->next;
102 else return first_iformat;
105 AVOutputFormat *av_oformat_next(AVOutputFormat *f)
107 if(f) return f->next;
108 else return first_oformat;
111 void av_register_input_format(AVInputFormat *format)
115 while (*p != NULL) p = &(*p)->next;
120 void av_register_output_format(AVOutputFormat *format)
124 while (*p != NULL) p = &(*p)->next;
129 int match_ext(const char *filename, const char *extensions)
137 ext = strrchr(filename, '.');
143 while (*p != '\0' && *p != ',' && q-ext1<sizeof(ext1)-1)
146 if (!strcasecmp(ext1, ext))
156 static int match_format(const char *name, const char *names)
164 namelen = strlen(name);
165 while ((p = strchr(names, ','))) {
166 len = FFMAX(p - names, namelen);
167 if (!strncasecmp(name, names, len))
171 return !strcasecmp(name, names);
174 AVOutputFormat *guess_format(const char *short_name, const char *filename,
175 const char *mime_type)
177 AVOutputFormat *fmt, *fmt_found;
178 int score_max, score;
180 /* specific test for image sequences */
181 #if CONFIG_IMAGE2_MUXER
182 if (!short_name && filename &&
183 av_filename_number_test(filename) &&
184 av_guess_image2_codec(filename) != CODEC_ID_NONE) {
185 return guess_format("image2", NULL, NULL);
188 /* Find the proper file type. */
192 while (fmt != NULL) {
194 if (fmt->name && short_name && !strcmp(fmt->name, short_name))
196 if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
198 if (filename && fmt->extensions &&
199 match_ext(filename, fmt->extensions)) {
202 if (score > score_max) {
211 AVOutputFormat *guess_stream_format(const char *short_name, const char *filename,
212 const char *mime_type)
214 AVOutputFormat *fmt = guess_format(short_name, filename, mime_type);
217 AVOutputFormat *stream_fmt;
218 char stream_format_name[64];
220 snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
221 stream_fmt = guess_format(stream_format_name, NULL, NULL);
230 enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
231 const char *filename, const char *mime_type, enum CodecType type){
232 if(type == CODEC_TYPE_VIDEO){
233 enum CodecID codec_id= CODEC_ID_NONE;
235 #if CONFIG_IMAGE2_MUXER
236 if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
237 codec_id= av_guess_image2_codec(filename);
240 if(codec_id == CODEC_ID_NONE)
241 codec_id= fmt->video_codec;
243 }else if(type == CODEC_TYPE_AUDIO)
244 return fmt->audio_codec;
246 return CODEC_ID_NONE;
249 AVInputFormat *av_find_input_format(const char *short_name)
252 for(fmt = first_iformat; fmt != NULL; fmt = fmt->next) {
253 if (match_format(short_name, fmt->name))
259 /* memory handling */
261 void av_destruct_packet(AVPacket *pkt)
264 pkt->data = NULL; pkt->size = 0;
267 void av_init_packet(AVPacket *pkt)
269 pkt->pts = AV_NOPTS_VALUE;
270 pkt->dts = AV_NOPTS_VALUE;
273 pkt->convergence_duration = 0;
275 pkt->stream_index = 0;
276 pkt->destruct= av_destruct_packet_nofree;
279 int av_new_packet(AVPacket *pkt, int size)
282 if((unsigned)size > (unsigned)size + FF_INPUT_BUFFER_PADDING_SIZE)
283 return AVERROR(ENOMEM);
284 data = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
286 return AVERROR(ENOMEM);
287 memset(data + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
292 pkt->destruct = av_destruct_packet;
296 int av_get_packet(ByteIOContext *s, AVPacket *pkt, int size)
298 int ret= av_new_packet(pkt, size);
303 pkt->pos= url_ftell(s);
305 ret= get_buffer(s, pkt->data, size);
314 int av_dup_packet(AVPacket *pkt)
316 if (((pkt->destruct == av_destruct_packet_nofree) || (pkt->destruct == NULL)) && pkt->data) {
318 /* We duplicate the packet and don't forget to add the padding again. */
319 if((unsigned)pkt->size > (unsigned)pkt->size + FF_INPUT_BUFFER_PADDING_SIZE)
320 return AVERROR(ENOMEM);
321 data = av_malloc(pkt->size + FF_INPUT_BUFFER_PADDING_SIZE);
323 return AVERROR(ENOMEM);
325 memcpy(data, pkt->data, pkt->size);
326 memset(data + pkt->size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
328 pkt->destruct = av_destruct_packet;
333 int av_filename_number_test(const char *filename)
336 return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
339 static AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
341 AVInputFormat *fmt1, *fmt;
345 for(fmt1 = first_iformat; fmt1 != NULL; fmt1 = fmt1->next) {
346 if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
349 if (fmt1->read_probe) {
350 score = fmt1->read_probe(pd);
351 } else if (fmt1->extensions) {
352 if (match_ext(pd->filename, fmt1->extensions)) {
356 if (score > *score_max) {
359 }else if (score == *score_max)
365 AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
367 return av_probe_input_format2(pd, is_opened, &score);
370 static int set_codec_from_probe_data(AVStream *st, AVProbeData *pd, int score)
373 fmt = av_probe_input_format2(pd, 1, &score);
376 if (!strcmp(fmt->name, "mp3")) {
377 st->codec->codec_id = CODEC_ID_MP3;
378 st->codec->codec_type = CODEC_TYPE_AUDIO;
379 } else if (!strcmp(fmt->name, "ac3")) {
380 st->codec->codec_id = CODEC_ID_AC3;
381 st->codec->codec_type = CODEC_TYPE_AUDIO;
382 } else if (!strcmp(fmt->name, "mpegvideo")) {
383 st->codec->codec_id = CODEC_ID_MPEG2VIDEO;
384 st->codec->codec_type = CODEC_TYPE_VIDEO;
385 } else if (!strcmp(fmt->name, "m4v")) {
386 st->codec->codec_id = CODEC_ID_MPEG4;
387 st->codec->codec_type = CODEC_TYPE_VIDEO;
388 } else if (!strcmp(fmt->name, "h264")) {
389 st->codec->codec_id = CODEC_ID_H264;
390 st->codec->codec_type = CODEC_TYPE_VIDEO;
396 /************************************************************/
397 /* input media file */
400 * Open a media file from an IO stream. 'fmt' must be specified.
402 int av_open_input_stream(AVFormatContext **ic_ptr,
403 ByteIOContext *pb, const char *filename,
404 AVInputFormat *fmt, AVFormatParameters *ap)
408 AVFormatParameters default_ap;
412 memset(ap, 0, sizeof(default_ap));
415 if(!ap->prealloced_context)
416 ic = avformat_alloc_context();
420 err = AVERROR(ENOMEM);
425 ic->duration = AV_NOPTS_VALUE;
426 ic->start_time = AV_NOPTS_VALUE;
427 av_strlcpy(ic->filename, filename, sizeof(ic->filename));
429 /* allocate private data */
430 if (fmt->priv_data_size > 0) {
431 ic->priv_data = av_mallocz(fmt->priv_data_size);
432 if (!ic->priv_data) {
433 err = AVERROR(ENOMEM);
437 ic->priv_data = NULL;
440 if (ic->iformat->read_header) {
441 err = ic->iformat->read_header(ic, ap);
446 if (pb && !ic->data_offset)
447 ic->data_offset = url_ftell(ic->pb);
449 #if LIBAVFORMAT_VERSION_MAJOR < 53
450 ff_metadata_demux_compat(ic);
458 av_freep(&ic->priv_data);
459 for(i=0;i<ic->nb_streams;i++) {
460 AVStream *st = ic->streams[i];
462 av_free(st->priv_data);
463 av_free(st->codec->extradata);
473 /** size of probe buffer, for guessing file type from file contents */
474 #define PROBE_BUF_MIN 2048
475 #define PROBE_BUF_MAX (1<<20)
477 int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
480 AVFormatParameters *ap)
483 AVProbeData probe_data, *pd = &probe_data;
484 ByteIOContext *pb = NULL;
488 pd->filename = filename;
493 /* guess format if no file can be opened */
494 fmt = av_probe_input_format(pd, 0);
497 /* Do not open file if the format does not need it. XXX: specific
498 hack needed to handle RTSP/TCP */
499 if (!fmt || !(fmt->flags & AVFMT_NOFILE)) {
500 /* if no file needed do not try to open one */
501 if ((err=url_fopen(&pb, filename, URL_RDONLY)) < 0) {
505 url_setbufsize(pb, buf_size);
508 for(probe_size= PROBE_BUF_MIN; probe_size<=PROBE_BUF_MAX && !fmt; probe_size<<=1){
509 int score= probe_size < PROBE_BUF_MAX ? AVPROBE_SCORE_MAX/4 : 0;
510 /* read probe data */
511 pd->buf= av_realloc(pd->buf, probe_size + AVPROBE_PADDING_SIZE);
512 pd->buf_size = get_buffer(pb, pd->buf, probe_size);
513 memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
514 if (url_fseek(pb, 0, SEEK_SET) < 0) {
516 if (url_fopen(&pb, filename, URL_RDONLY) < 0) {
522 /* guess file format */
523 fmt = av_probe_input_format2(pd, 1, &score);
528 /* if still no format found, error */
534 /* check filename in case an image number is expected */
535 if (fmt->flags & AVFMT_NEEDNUMBER) {
536 if (!av_filename_number_test(filename)) {
537 err = AVERROR_NUMEXPECTED;
541 err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
554 /*******************************************************/
556 static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
557 AVPacketList **plast_pktl){
558 AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
563 (*plast_pktl)->next = pktl;
565 *packet_buffer = pktl;
567 /* add the packet in the buffered packet list */
573 int av_read_packet(AVFormatContext *s, AVPacket *pkt)
579 AVPacketList *pktl = s->raw_packet_buffer;
583 if(s->streams[pkt->stream_index]->codec->codec_id != CODEC_ID_PROBE){
584 s->raw_packet_buffer = pktl->next;
591 ret= s->iformat->read_packet(s, pkt);
594 st= s->streams[pkt->stream_index];
596 switch(st->codec->codec_type){
597 case CODEC_TYPE_VIDEO:
598 if(s->video_codec_id) st->codec->codec_id= s->video_codec_id;
600 case CODEC_TYPE_AUDIO:
601 if(s->audio_codec_id) st->codec->codec_id= s->audio_codec_id;
603 case CODEC_TYPE_SUBTITLE:
604 if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
608 if(!pktl && st->codec->codec_id!=CODEC_ID_PROBE)
611 add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
613 if(st->codec->codec_id == CODEC_ID_PROBE){
614 AVProbeData *pd = &st->probe_data;
616 pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
617 memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
618 pd->buf_size += pkt->size;
619 memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
621 if(av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)){
622 set_codec_from_probe_data(st, pd, 1);
623 if(st->codec->codec_id != CODEC_ID_PROBE){
632 /**********************************************************/
635 * Get the number of samples of an audio frame. Return -1 on error.
637 static int get_audio_frame_size(AVCodecContext *enc, int size)
641 if(enc->codec_id == CODEC_ID_VORBIS)
644 if (enc->frame_size <= 1) {
645 int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
647 if (bits_per_sample) {
648 if (enc->channels == 0)
650 frame_size = (size << 3) / (bits_per_sample * enc->channels);
652 /* used for example by ADPCM codecs */
653 if (enc->bit_rate == 0)
655 frame_size = (size * 8 * enc->sample_rate) / enc->bit_rate;
658 frame_size = enc->frame_size;
665 * Return the frame duration in seconds. Return 0 if not available.
667 static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
668 AVCodecParserContext *pc, AVPacket *pkt)
674 switch(st->codec->codec_type) {
675 case CODEC_TYPE_VIDEO:
676 if(st->time_base.num*1000LL > st->time_base.den){
677 *pnum = st->time_base.num;
678 *pden = st->time_base.den;
679 }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
680 *pnum = st->codec->time_base.num;
681 *pden = st->codec->time_base.den;
682 if (pc && pc->repeat_pict) {
684 *pnum = (*pnum) * (2 + pc->repeat_pict);
688 case CODEC_TYPE_AUDIO:
689 frame_size = get_audio_frame_size(st->codec, pkt->size);
693 *pden = st->codec->sample_rate;
700 static int is_intra_only(AVCodecContext *enc){
701 if(enc->codec_type == CODEC_TYPE_AUDIO){
703 }else if(enc->codec_type == CODEC_TYPE_VIDEO){
704 switch(enc->codec_id){
706 case CODEC_ID_MJPEGB:
708 case CODEC_ID_RAWVIDEO:
709 case CODEC_ID_DVVIDEO:
710 case CODEC_ID_HUFFYUV:
711 case CODEC_ID_FFVHUFF:
716 case CODEC_ID_JPEG2000:
724 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
725 int64_t dts, int64_t pts)
727 AVStream *st= s->streams[stream_index];
728 AVPacketList *pktl= s->packet_buffer;
730 if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE)
733 st->first_dts= dts - st->cur_dts;
736 for(; pktl; pktl= pktl->next){
737 if(pktl->pkt.stream_index != stream_index)
739 //FIXME think more about this check
740 if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
741 pktl->pkt.pts += st->first_dts;
743 if(pktl->pkt.dts != AV_NOPTS_VALUE)
744 pktl->pkt.dts += st->first_dts;
746 if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
747 st->start_time= pktl->pkt.pts;
749 if (st->start_time == AV_NOPTS_VALUE)
750 st->start_time = pts;
753 static void update_initial_durations(AVFormatContext *s, AVStream *st, AVPacket *pkt)
755 AVPacketList *pktl= s->packet_buffer;
758 if(st->first_dts != AV_NOPTS_VALUE){
759 cur_dts= st->first_dts;
760 for(; pktl; pktl= pktl->next){
761 if(pktl->pkt.stream_index == pkt->stream_index){
762 if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
764 cur_dts -= pkt->duration;
767 pktl= s->packet_buffer;
768 st->first_dts = cur_dts;
769 }else if(st->cur_dts)
772 for(; pktl; pktl= pktl->next){
773 if(pktl->pkt.stream_index != pkt->stream_index)
775 if(pktl->pkt.pts == pktl->pkt.dts && pktl->pkt.dts == AV_NOPTS_VALUE
776 && !pktl->pkt.duration){
777 pktl->pkt.dts= cur_dts;
778 if(!st->codec->has_b_frames)
779 pktl->pkt.pts= cur_dts;
780 cur_dts += pkt->duration;
781 pktl->pkt.duration= pkt->duration;
785 if(st->first_dts == AV_NOPTS_VALUE)
786 st->cur_dts= cur_dts;
789 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
790 AVCodecParserContext *pc, AVPacket *pkt)
792 int num, den, presentation_delayed, delay, i;
795 /* do we have a video B-frame ? */
796 delay= st->codec->has_b_frames;
797 presentation_delayed = 0;
798 /* XXX: need has_b_frame, but cannot get it if the codec is
801 pc && pc->pict_type != FF_B_TYPE)
802 presentation_delayed = 1;
804 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
805 /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
806 pkt->dts -= 1LL<<st->pts_wrap_bits;
809 // some mpeg2 in mpeg-ps lack dts (issue171 / input_file.mpg)
810 // we take the conservative approach and discard both
811 // Note, if this is misbehaving for a H.264 file then possibly presentation_delayed is not set correctly.
812 if(delay==1 && pkt->dts == pkt->pts && pkt->dts != AV_NOPTS_VALUE && presentation_delayed){
813 av_log(s, AV_LOG_WARNING, "invalid dts/pts combination\n");
814 pkt->dts= pkt->pts= AV_NOPTS_VALUE;
817 if (pkt->duration == 0) {
818 compute_frame_duration(&num, &den, st, pc, pkt);
820 pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
822 if(pkt->duration != 0 && s->packet_buffer)
823 update_initial_durations(s, st, pkt);
827 /* correct timestamps with byte offset if demuxers only have timestamps
828 on packet boundaries */
829 if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
830 /* this will estimate bitrate based on this frame's duration and size */
831 offset = av_rescale(pc->offset, pkt->duration, pkt->size);
832 if(pkt->pts != AV_NOPTS_VALUE)
834 if(pkt->dts != AV_NOPTS_VALUE)
838 /* This may be redundant, but it should not hurt. */
839 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
840 presentation_delayed = 1;
842 // 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);
843 /* interpolate PTS and DTS if they are not present */
844 if(delay==0 || (delay==1 && pc)){
845 if (presentation_delayed) {
846 /* DTS = decompression timestamp */
847 /* PTS = presentation timestamp */
848 if (pkt->dts == AV_NOPTS_VALUE)
849 pkt->dts = st->last_IP_pts;
850 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
851 if (pkt->dts == AV_NOPTS_VALUE)
852 pkt->dts = st->cur_dts;
854 /* this is tricky: the dts must be incremented by the duration
855 of the frame we are displaying, i.e. the last I- or P-frame */
856 if (st->last_IP_duration == 0)
857 st->last_IP_duration = pkt->duration;
858 if(pkt->dts != AV_NOPTS_VALUE)
859 st->cur_dts = pkt->dts + st->last_IP_duration;
860 st->last_IP_duration = pkt->duration;
861 st->last_IP_pts= pkt->pts;
862 /* cannot compute PTS if not present (we can compute it only
863 by knowing the future */
864 } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
865 if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
866 int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
867 int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
868 if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
869 pkt->pts += pkt->duration;
870 // 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);
874 /* presentation is not delayed : PTS and DTS are the same */
875 if(pkt->pts == AV_NOPTS_VALUE)
877 update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
878 if(pkt->pts == AV_NOPTS_VALUE)
879 pkt->pts = st->cur_dts;
881 if(pkt->pts != AV_NOPTS_VALUE)
882 st->cur_dts = pkt->pts + pkt->duration;
886 if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
887 st->pts_buffer[0]= pkt->pts;
888 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
889 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
890 if(pkt->dts == AV_NOPTS_VALUE)
891 pkt->dts= st->pts_buffer[0];
893 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
895 if(pkt->dts > st->cur_dts)
896 st->cur_dts = pkt->dts;
899 // 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);
902 if(is_intra_only(st->codec))
903 pkt->flags |= PKT_FLAG_KEY;
906 /* keyframe computation */
907 if (pc->key_frame == 1)
908 pkt->flags |= PKT_FLAG_KEY;
909 else if (pc->key_frame == -1 && pc->pict_type == FF_I_TYPE)
910 pkt->flags |= PKT_FLAG_KEY;
913 pkt->convergence_duration = pc->convergence_duration;
916 void av_destruct_packet_nofree(AVPacket *pkt)
918 pkt->data = NULL; pkt->size = 0;
921 static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
929 /* select current input stream component */
932 if (!st->need_parsing || !st->parser) {
933 /* no parsing needed: we just output the packet as is */
934 /* raw data support */
935 *pkt = st->cur_pkt; st->cur_pkt.data= NULL;
936 compute_pkt_fields(s, st, NULL, pkt);
939 } else if (st->cur_len > 0 && st->discard < AVDISCARD_ALL) {
940 len = av_parser_parse(st->parser, st->codec, &pkt->data, &pkt->size,
941 st->cur_ptr, st->cur_len,
942 st->cur_pkt.pts, st->cur_pkt.dts);
943 st->cur_pkt.pts = AV_NOPTS_VALUE;
944 st->cur_pkt.dts = AV_NOPTS_VALUE;
945 /* increment read pointer */
949 /* return packet if any */
951 pkt->pos = st->cur_pkt.pos; // Isn't quite accurate but close.
954 pkt->stream_index = st->index;
955 pkt->pts = st->parser->pts;
956 pkt->dts = st->parser->dts;
957 pkt->destruct = av_destruct_packet_nofree;
958 compute_pkt_fields(s, st, st->parser, pkt);
960 if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & PKT_FLAG_KEY){
961 ff_reduce_index(s, st->index);
962 av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
963 0, 0, AVINDEX_KEYFRAME);
970 av_free_packet(&st->cur_pkt);
975 /* read next packet */
976 ret = av_read_packet(s, &cur_pkt);
978 if (ret == AVERROR(EAGAIN))
980 /* return the last frames, if any */
981 for(i = 0; i < s->nb_streams; i++) {
983 if (st->parser && st->need_parsing) {
984 av_parser_parse(st->parser, st->codec,
985 &pkt->data, &pkt->size,
987 AV_NOPTS_VALUE, AV_NOPTS_VALUE);
992 /* no more packets: really terminate parsing */
995 st = s->streams[cur_pkt.stream_index];
996 st->cur_pkt= cur_pkt;
998 if(st->cur_pkt.pts != AV_NOPTS_VALUE &&
999 st->cur_pkt.dts != AV_NOPTS_VALUE &&
1000 st->cur_pkt.pts < st->cur_pkt.dts){
1001 av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
1002 st->cur_pkt.stream_index,
1006 // av_free_packet(&st->cur_pkt);
1010 if(s->debug & FF_FDEBUG_TS)
1011 av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, flags=%d\n",
1012 st->cur_pkt.stream_index,
1019 st->cur_ptr = st->cur_pkt.data;
1020 st->cur_len = st->cur_pkt.size;
1021 if (st->need_parsing && !st->parser) {
1022 st->parser = av_parser_init(st->codec->codec_id);
1024 /* no parser available: just output the raw packets */
1025 st->need_parsing = AVSTREAM_PARSE_NONE;
1026 }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
1027 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1029 if(st->parser && (s->iformat->flags & AVFMT_GENERIC_INDEX)){
1030 st->parser->next_frame_offset=
1031 st->parser->cur_offset= st->cur_pkt.pos;
1036 if(s->debug & FF_FDEBUG_TS)
1037 av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, flags=%d\n",
1047 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1051 const int genpts= s->flags & AVFMT_FLAG_GENPTS;
1054 pktl = s->packet_buffer;
1056 AVPacket *next_pkt= &pktl->pkt;
1058 if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
1059 while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
1060 if( pktl->pkt.stream_index == next_pkt->stream_index
1061 && next_pkt->dts < pktl->pkt.dts
1062 && pktl->pkt.pts != pktl->pkt.dts //not b frame
1063 /*&& pktl->pkt.dts != AV_NOPTS_VALUE*/){
1064 next_pkt->pts= pktl->pkt.dts;
1068 pktl = s->packet_buffer;
1071 if( next_pkt->pts != AV_NOPTS_VALUE
1072 || next_pkt->dts == AV_NOPTS_VALUE
1074 /* read packet from packet buffer, if there is data */
1076 s->packet_buffer = pktl->next;
1082 int ret= av_read_frame_internal(s, pkt);
1084 if(pktl && ret != AVERROR(EAGAIN)){
1091 if(av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1092 &s->packet_buffer_end)) < 0)
1093 return AVERROR(ENOMEM);
1095 assert(!s->packet_buffer);
1096 return av_read_frame_internal(s, pkt);
1101 /* XXX: suppress the packet queue */
1102 static void flush_packet_queue(AVFormatContext *s)
1107 pktl = s->packet_buffer;
1110 s->packet_buffer = pktl->next;
1111 av_free_packet(&pktl->pkt);
1116 /*******************************************************/
1119 int av_find_default_stream_index(AVFormatContext *s)
1121 int first_audio_index = -1;
1125 if (s->nb_streams <= 0)
1127 for(i = 0; i < s->nb_streams; i++) {
1129 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1132 if (first_audio_index < 0 && st->codec->codec_type == CODEC_TYPE_AUDIO)
1133 first_audio_index = i;
1135 return first_audio_index >= 0 ? first_audio_index : 0;
1139 * Flush the frame reader.
1141 static void av_read_frame_flush(AVFormatContext *s)
1146 flush_packet_queue(s);
1150 /* for each stream, reset read state */
1151 for(i = 0; i < s->nb_streams; i++) {
1155 av_parser_close(st->parser);
1157 av_free_packet(&st->cur_pkt);
1159 st->last_IP_pts = AV_NOPTS_VALUE;
1160 st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1167 void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1170 for(i = 0; i < s->nb_streams; i++) {
1171 AVStream *st = s->streams[i];
1173 st->cur_dts = av_rescale(timestamp,
1174 st->time_base.den * (int64_t)ref_st->time_base.num,
1175 st->time_base.num * (int64_t)ref_st->time_base.den);
1179 void ff_reduce_index(AVFormatContext *s, int stream_index)
1181 AVStream *st= s->streams[stream_index];
1182 unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1184 if((unsigned)st->nb_index_entries >= max_entries){
1186 for(i=0; 2*i<st->nb_index_entries; i++)
1187 st->index_entries[i]= st->index_entries[2*i];
1188 st->nb_index_entries= i;
1192 int av_add_index_entry(AVStream *st,
1193 int64_t pos, int64_t timestamp, int size, int distance, int flags)
1195 AVIndexEntry *entries, *ie;
1198 if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1201 entries = av_fast_realloc(st->index_entries,
1202 &st->index_entries_allocated_size,
1203 (st->nb_index_entries + 1) *
1204 sizeof(AVIndexEntry));
1208 st->index_entries= entries;
1210 index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
1213 index= st->nb_index_entries++;
1214 ie= &entries[index];
1215 assert(index==0 || ie[-1].timestamp < timestamp);
1217 ie= &entries[index];
1218 if(ie->timestamp != timestamp){
1219 if(ie->timestamp <= timestamp)
1221 memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
1222 st->nb_index_entries++;
1223 }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1224 distance= ie->min_distance;
1228 ie->timestamp = timestamp;
1229 ie->min_distance= distance;
1236 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1239 AVIndexEntry *entries= st->index_entries;
1240 int nb_entries= st->nb_index_entries;
1249 timestamp = entries[m].timestamp;
1250 if(timestamp >= wanted_timestamp)
1252 if(timestamp <= wanted_timestamp)
1255 m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1257 if(!(flags & AVSEEK_FLAG_ANY)){
1258 while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1259 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1270 int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1271 AVInputFormat *avif= s->iformat;
1272 int64_t pos_min, pos_max, pos, pos_limit;
1273 int64_t ts_min, ts_max, ts;
1277 if (stream_index < 0)
1281 av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1285 ts_min= AV_NOPTS_VALUE;
1286 pos_limit= -1; //gcc falsely says it may be uninitialized
1288 st= s->streams[stream_index];
1289 if(st->index_entries){
1292 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()
1293 index= FFMAX(index, 0);
1294 e= &st->index_entries[index];
1296 if(e->timestamp <= target_ts || e->pos == e->min_distance){
1298 ts_min= e->timestamp;
1300 av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1307 index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1308 assert(index < st->nb_index_entries);
1310 e= &st->index_entries[index];
1311 assert(e->timestamp >= target_ts);
1313 ts_max= e->timestamp;
1314 pos_limit= pos_max - e->min_distance;
1316 av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1317 pos_max,pos_limit, ts_max);
1322 pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1327 url_fseek(s->pb, pos, SEEK_SET);
1329 av_update_cur_dts(s, st, ts);
1334 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 )){
1336 int64_t start_pos, filesize;
1340 av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1343 if(ts_min == AV_NOPTS_VALUE){
1344 pos_min = s->data_offset;
1345 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1346 if (ts_min == AV_NOPTS_VALUE)
1350 if(ts_max == AV_NOPTS_VALUE){
1352 filesize = url_fsize(s->pb);
1353 pos_max = filesize - 1;
1356 ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1358 }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1359 if (ts_max == AV_NOPTS_VALUE)
1363 int64_t tmp_pos= pos_max + 1;
1364 int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1365 if(tmp_ts == AV_NOPTS_VALUE)
1369 if(tmp_pos >= filesize)
1375 if(ts_min > ts_max){
1377 }else if(ts_min == ts_max){
1382 while (pos_min < pos_limit) {
1384 av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1388 assert(pos_limit <= pos_max);
1391 int64_t approximate_keyframe_distance= pos_max - pos_limit;
1392 // interpolate position (better than dichotomy)
1393 pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1394 + pos_min - approximate_keyframe_distance;
1395 }else if(no_change==1){
1396 // bisection, if interpolation failed to change min or max pos last time
1397 pos = (pos_min + pos_limit)>>1;
1399 /* linear search if bisection failed, can only happen if there
1400 are very few or no keyframes between min/max */
1405 else if(pos > pos_limit)
1409 ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1415 av_log(s, AV_LOG_DEBUG, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64" target:%"PRId64" limit:%"PRId64" start:%"PRId64" noc:%d\n", pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts, pos_limit, start_pos, no_change);
1417 if(ts == AV_NOPTS_VALUE){
1418 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1421 assert(ts != AV_NOPTS_VALUE);
1422 if (target_ts <= ts) {
1423 pos_limit = start_pos - 1;
1427 if (target_ts >= ts) {
1433 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1434 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
1437 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1439 ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1440 av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1441 pos, ts_min, target_ts, ts_max);
1447 static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1448 int64_t pos_min, pos_max;
1452 if (stream_index < 0)
1455 st= s->streams[stream_index];
1458 pos_min = s->data_offset;
1459 pos_max = url_fsize(s->pb) - 1;
1461 if (pos < pos_min) pos= pos_min;
1462 else if(pos > pos_max) pos= pos_max;
1464 url_fseek(s->pb, pos, SEEK_SET);
1467 av_update_cur_dts(s, st, ts);
1472 static int av_seek_frame_generic(AVFormatContext *s,
1473 int stream_index, int64_t timestamp, int flags)
1479 st = s->streams[stream_index];
1481 index = av_index_search_timestamp(st, timestamp, flags);
1483 if(index < 0 || index==st->nb_index_entries-1){
1487 if(st->nb_index_entries){
1488 assert(st->index_entries);
1489 ie= &st->index_entries[st->nb_index_entries-1];
1490 if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
1492 av_update_cur_dts(s, st, ie->timestamp);
1494 if ((ret = url_fseek(s->pb, 0, SEEK_SET)) < 0)
1500 ret = av_read_frame(s, &pkt);
1501 }while(ret == AVERROR(EAGAIN));
1504 av_free_packet(&pkt);
1505 if(stream_index == pkt.stream_index){
1506 if((pkt.flags & PKT_FLAG_KEY) && pkt.dts > timestamp)
1510 index = av_index_search_timestamp(st, timestamp, flags);
1515 av_read_frame_flush(s);
1516 if (s->iformat->read_seek){
1517 if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1520 ie = &st->index_entries[index];
1521 if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
1523 av_update_cur_dts(s, st, ie->timestamp);
1528 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1533 av_read_frame_flush(s);
1535 if(flags & AVSEEK_FLAG_BYTE)
1536 return av_seek_frame_byte(s, stream_index, timestamp, flags);
1538 if(stream_index < 0){
1539 stream_index= av_find_default_stream_index(s);
1540 if(stream_index < 0)
1543 st= s->streams[stream_index];
1544 /* timestamp for default must be expressed in AV_TIME_BASE units */
1545 timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1548 /* first, we try the format specific seek */
1549 if (s->iformat->read_seek)
1550 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1557 if(s->iformat->read_timestamp)
1558 return av_seek_frame_binary(s, stream_index, timestamp, flags);
1560 return av_seek_frame_generic(s, stream_index, timestamp, flags);
1563 /*******************************************************/
1566 * Returns TRUE if the stream has accurate duration in any stream.
1568 * @return TRUE if the stream has accurate duration for at least one component.
1570 static int av_has_duration(AVFormatContext *ic)
1575 for(i = 0;i < ic->nb_streams; i++) {
1576 st = ic->streams[i];
1577 if (st->duration != AV_NOPTS_VALUE)
1584 * Estimate the stream timings from the one of each components.
1586 * Also computes the global bitrate if possible.
1588 static void av_update_stream_timings(AVFormatContext *ic)
1590 int64_t start_time, start_time1, end_time, end_time1;
1591 int64_t duration, duration1;
1595 start_time = INT64_MAX;
1596 end_time = INT64_MIN;
1597 duration = INT64_MIN;
1598 for(i = 0;i < ic->nb_streams; i++) {
1599 st = ic->streams[i];
1600 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
1601 start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1602 if (start_time1 < start_time)
1603 start_time = start_time1;
1604 if (st->duration != AV_NOPTS_VALUE) {
1605 end_time1 = start_time1
1606 + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1607 if (end_time1 > end_time)
1608 end_time = end_time1;
1611 if (st->duration != AV_NOPTS_VALUE) {
1612 duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1613 if (duration1 > duration)
1614 duration = duration1;
1617 if (start_time != INT64_MAX) {
1618 ic->start_time = start_time;
1619 if (end_time != INT64_MIN) {
1620 if (end_time - start_time > duration)
1621 duration = end_time - start_time;
1624 if (duration != INT64_MIN) {
1625 ic->duration = duration;
1626 if (ic->file_size > 0) {
1627 /* compute the bitrate */
1628 ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1629 (double)ic->duration;
1634 static void fill_all_stream_timings(AVFormatContext *ic)
1639 av_update_stream_timings(ic);
1640 for(i = 0;i < ic->nb_streams; i++) {
1641 st = ic->streams[i];
1642 if (st->start_time == AV_NOPTS_VALUE) {
1643 if(ic->start_time != AV_NOPTS_VALUE)
1644 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1645 if(ic->duration != AV_NOPTS_VALUE)
1646 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1651 static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1653 int64_t filesize, duration;
1657 /* if bit_rate is already set, we believe it */
1658 if (ic->bit_rate == 0) {
1660 for(i=0;i<ic->nb_streams;i++) {
1661 st = ic->streams[i];
1662 bit_rate += st->codec->bit_rate;
1664 ic->bit_rate = bit_rate;
1667 /* if duration is already set, we believe it */
1668 if (ic->duration == AV_NOPTS_VALUE &&
1669 ic->bit_rate != 0 &&
1670 ic->file_size != 0) {
1671 filesize = ic->file_size;
1673 for(i = 0; i < ic->nb_streams; i++) {
1674 st = ic->streams[i];
1675 duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1676 if (st->duration == AV_NOPTS_VALUE)
1677 st->duration = duration;
1683 #define DURATION_MAX_READ_SIZE 250000
1685 /* only usable for MPEG-PS streams */
1686 static void av_estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
1688 AVPacket pkt1, *pkt = &pkt1;
1690 int read_size, i, ret;
1692 int64_t filesize, offset, duration;
1696 /* flush packet queue */
1697 flush_packet_queue(ic);
1699 for(i=0;i<ic->nb_streams;i++) {
1700 st = ic->streams[i];
1702 av_parser_close(st->parser);
1704 av_free_packet(&st->cur_pkt);
1708 /* we read the first packets to get the first PTS (not fully
1709 accurate, but it is enough now) */
1710 url_fseek(ic->pb, 0, SEEK_SET);
1713 if (read_size >= DURATION_MAX_READ_SIZE)
1715 /* if all info is available, we can stop */
1716 for(i = 0;i < ic->nb_streams; i++) {
1717 st = ic->streams[i];
1718 if (st->start_time == AV_NOPTS_VALUE)
1721 if (i == ic->nb_streams)
1725 ret = av_read_packet(ic, pkt);
1726 }while(ret == AVERROR(EAGAIN));
1729 read_size += pkt->size;
1730 st = ic->streams[pkt->stream_index];
1731 if (pkt->pts != AV_NOPTS_VALUE) {
1732 if (st->start_time == AV_NOPTS_VALUE)
1733 st->start_time = pkt->pts;
1735 av_free_packet(pkt);
1738 /* estimate the end time (duration) */
1739 /* XXX: may need to support wrapping */
1740 filesize = ic->file_size;
1741 offset = filesize - DURATION_MAX_READ_SIZE;
1745 url_fseek(ic->pb, offset, SEEK_SET);
1748 if (read_size >= DURATION_MAX_READ_SIZE)
1752 ret = av_read_packet(ic, pkt);
1753 }while(ret == AVERROR(EAGAIN));
1756 read_size += pkt->size;
1757 st = ic->streams[pkt->stream_index];
1758 if (pkt->pts != AV_NOPTS_VALUE &&
1759 st->start_time != AV_NOPTS_VALUE) {
1760 end_time = pkt->pts;
1761 duration = end_time - st->start_time;
1763 if (st->duration == AV_NOPTS_VALUE ||
1764 st->duration < duration)
1765 st->duration = duration;
1768 av_free_packet(pkt);
1771 fill_all_stream_timings(ic);
1773 url_fseek(ic->pb, old_offset, SEEK_SET);
1774 for(i=0; i<ic->nb_streams; i++){
1776 st->cur_dts= st->first_dts;
1777 st->last_IP_pts = AV_NOPTS_VALUE;
1781 static void av_estimate_timings(AVFormatContext *ic, int64_t old_offset)
1785 /* get the file size, if possible */
1786 if (ic->iformat->flags & AVFMT_NOFILE) {
1789 file_size = url_fsize(ic->pb);
1793 ic->file_size = file_size;
1795 if ((!strcmp(ic->iformat->name, "mpeg") ||
1796 !strcmp(ic->iformat->name, "mpegts")) &&
1797 file_size && !url_is_streamed(ic->pb)) {
1798 /* get accurate estimate from the PTSes */
1799 av_estimate_timings_from_pts(ic, old_offset);
1800 } else if (av_has_duration(ic)) {
1801 /* at least one component has timings - we use them for all
1803 fill_all_stream_timings(ic);
1805 /* less precise: use bitrate info */
1806 av_estimate_timings_from_bit_rate(ic);
1808 av_update_stream_timings(ic);
1814 for(i = 0;i < ic->nb_streams; i++) {
1815 st = ic->streams[i];
1816 printf("%d: start_time: %0.3f duration: %0.3f\n",
1817 i, (double)st->start_time / AV_TIME_BASE,
1818 (double)st->duration / AV_TIME_BASE);
1820 printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1821 (double)ic->start_time / AV_TIME_BASE,
1822 (double)ic->duration / AV_TIME_BASE,
1823 ic->bit_rate / 1000);
1828 static int has_codec_parameters(AVCodecContext *enc)
1831 switch(enc->codec_type) {
1832 case CODEC_TYPE_AUDIO:
1833 val = enc->sample_rate && enc->channels && enc->sample_fmt != SAMPLE_FMT_NONE;
1834 if(!enc->frame_size &&
1835 (enc->codec_id == CODEC_ID_VORBIS ||
1836 enc->codec_id == CODEC_ID_AAC))
1839 case CODEC_TYPE_VIDEO:
1840 val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
1846 return enc->codec_id != CODEC_ID_NONE && val != 0;
1849 static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1853 int got_picture, data_size, ret=0;
1856 if(!st->codec->codec){
1857 codec = avcodec_find_decoder(st->codec->codec_id);
1860 ret = avcodec_open(st->codec, codec);
1865 if(!has_codec_parameters(st->codec)){
1866 switch(st->codec->codec_type) {
1867 case CODEC_TYPE_VIDEO:
1868 ret = avcodec_decode_video(st->codec, &picture,
1869 &got_picture, data, size);
1871 case CODEC_TYPE_AUDIO:
1872 data_size = FFMAX(size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
1873 samples = av_malloc(data_size);
1876 ret = avcodec_decode_audio2(st->codec, samples,
1877 &data_size, data, size);
1888 unsigned int codec_get_tag(const AVCodecTag *tags, int id)
1890 while (tags->id != CODEC_ID_NONE) {
1898 enum CodecID codec_get_id(const AVCodecTag *tags, unsigned int tag)
1901 for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
1902 if(tag == tags[i].tag)
1905 for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
1906 if( toupper((tag >> 0)&0xFF) == toupper((tags[i].tag >> 0)&0xFF)
1907 && toupper((tag >> 8)&0xFF) == toupper((tags[i].tag >> 8)&0xFF)
1908 && toupper((tag >>16)&0xFF) == toupper((tags[i].tag >>16)&0xFF)
1909 && toupper((tag >>24)&0xFF) == toupper((tags[i].tag >>24)&0xFF))
1912 return CODEC_ID_NONE;
1915 unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum CodecID id)
1918 for(i=0; tags && tags[i]; i++){
1919 int tag= codec_get_tag(tags[i], id);
1925 enum CodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
1928 for(i=0; tags && tags[i]; i++){
1929 enum CodecID id= codec_get_id(tags[i], tag);
1930 if(id!=CODEC_ID_NONE) return id;
1932 return CODEC_ID_NONE;
1935 static void compute_chapters_end(AVFormatContext *s)
1939 for (i=0; i+1<s->nb_chapters; i++)
1940 if (s->chapters[i]->end == AV_NOPTS_VALUE) {
1941 assert(s->chapters[i]->start <= s->chapters[i+1]->start);
1942 assert(!av_cmp_q(s->chapters[i]->time_base, s->chapters[i+1]->time_base));
1943 s->chapters[i]->end = s->chapters[i+1]->start;
1946 if (s->nb_chapters && s->chapters[i]->end == AV_NOPTS_VALUE) {
1947 assert(s->start_time != AV_NOPTS_VALUE);
1948 assert(s->duration > 0);
1949 s->chapters[i]->end = av_rescale_q(s->start_time + s->duration,
1951 s->chapters[i]->time_base);
1955 /* absolute maximum size we read until we abort */
1956 #define MAX_READ_SIZE 5000000
1958 #define MAX_STD_TIMEBASES (60*12+5)
1959 static int get_std_framerate(int i){
1960 if(i<60*12) return i*1001;
1961 else return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
1965 * Is the time base unreliable.
1966 * This is a heuristic to balance between quick acceptance of the values in
1967 * the headers vs. some extra checks.
1968 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
1969 * MPEG-2 commonly misuses field repeat flags to store different framerates.
1970 * And there are "variable" fps files this needs to detect as well.
1972 static int tb_unreliable(AVCodecContext *c){
1973 if( c->time_base.den >= 101L*c->time_base.num
1974 || c->time_base.den < 5L*c->time_base.num
1975 /* || c->codec_tag == AV_RL32("DIVX")
1976 || c->codec_tag == AV_RL32("XVID")*/
1977 || c->codec_id == CODEC_ID_MPEG2VIDEO)
1982 int av_find_stream_info(AVFormatContext *ic)
1984 int i, count, ret, read_size, j;
1986 AVPacket pkt1, *pkt;
1987 int64_t last_dts[MAX_STREAMS];
1988 int duration_count[MAX_STREAMS]={0};
1989 double (*duration_error)[MAX_STD_TIMEBASES];
1990 int64_t old_offset = url_ftell(ic->pb);
1991 int64_t codec_info_duration[MAX_STREAMS]={0};
1992 int codec_info_nb_frames[MAX_STREAMS]={0};
1994 duration_error = av_mallocz(MAX_STREAMS * sizeof(*duration_error));
1995 if (!duration_error) return AVERROR(ENOMEM);
1997 for(i=0;i<ic->nb_streams;i++) {
1998 st = ic->streams[i];
1999 if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2000 /* if(!st->time_base.num)
2002 if(!st->codec->time_base.num)
2003 st->codec->time_base= st->time_base;
2005 //only for the split stuff
2007 st->parser = av_parser_init(st->codec->codec_id);
2008 if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
2009 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2014 for(i=0;i<MAX_STREAMS;i++){
2015 last_dts[i]= AV_NOPTS_VALUE;
2021 /* check if one codec still needs to be handled */
2022 for(i=0;i<ic->nb_streams;i++) {
2023 st = ic->streams[i];
2024 if (!has_codec_parameters(st->codec))
2026 /* variable fps and no guess at the real fps */
2027 if( tb_unreliable(st->codec)
2028 && duration_count[i]<20 && st->codec->codec_type == CODEC_TYPE_VIDEO)
2030 if(st->parser && st->parser->parser->split && !st->codec->extradata)
2032 if(st->first_dts == AV_NOPTS_VALUE)
2035 if (i == ic->nb_streams) {
2036 /* NOTE: if the format has no header, then we need to read
2037 some packets to get most of the streams, so we cannot
2039 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2040 /* if we found the info for all the codecs, we can stop */
2045 /* we did not get all the codec info, but we read too much data */
2046 if (read_size >= MAX_READ_SIZE) {
2051 /* NOTE: a new stream can be added there if no header in file
2052 (AVFMTCTX_NOHEADER) */
2053 ret = av_read_frame_internal(ic, &pkt1);
2054 if(ret == AVERROR(EAGAIN))
2058 ret = -1; /* we could not have all the codec parameters before EOF */
2059 for(i=0;i<ic->nb_streams;i++) {
2060 st = ic->streams[i];
2061 if (!has_codec_parameters(st->codec)){
2063 avcodec_string(buf, sizeof(buf), st->codec, 0);
2064 av_log(ic, AV_LOG_INFO, "Could not find codec parameters (%s)\n", buf);
2072 pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2073 if(av_dup_packet(pkt) < 0) {
2074 av_free(duration_error);
2075 return AVERROR(ENOMEM);
2078 read_size += pkt->size;
2080 st = ic->streams[pkt->stream_index];
2081 if(codec_info_nb_frames[st->index]>1)
2082 codec_info_duration[st->index] += pkt->duration;
2083 if (pkt->duration != 0)
2084 codec_info_nb_frames[st->index]++;
2087 int index= pkt->stream_index;
2088 int64_t last= last_dts[index];
2089 int64_t duration= pkt->dts - last;
2091 if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
2092 double dur= duration * av_q2d(st->time_base);
2094 // if(st->codec->codec_type == CODEC_TYPE_VIDEO)
2095 // av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
2096 if(duration_count[index] < 2)
2097 memset(duration_error[index], 0, sizeof(*duration_error));
2098 for(i=1; i<MAX_STD_TIMEBASES; i++){
2099 int framerate= get_std_framerate(i);
2100 int ticks= lrintf(dur*framerate/(1001*12));
2101 double error= dur - ticks*1001*12/(double)framerate;
2102 duration_error[index][i] += error*error;
2104 duration_count[index]++;
2106 if(last == AV_NOPTS_VALUE || duration_count[index]<=1)
2107 last_dts[pkt->stream_index]= pkt->dts;
2109 if(st->parser && st->parser->parser->split && !st->codec->extradata){
2110 int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2112 st->codec->extradata_size= i;
2113 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2114 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2115 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2119 /* if still no information, we try to open the codec and to
2120 decompress the frame. We try to avoid that in most cases as
2121 it takes longer and uses more memory. For MPEG-4, we need to
2122 decompress for QuickTime. */
2123 if (!has_codec_parameters(st->codec) /*&&
2124 (st->codec->codec_id == CODEC_ID_FLV1 ||
2125 st->codec->codec_id == CODEC_ID_H264 ||
2126 st->codec->codec_id == CODEC_ID_H263 ||
2127 st->codec->codec_id == CODEC_ID_H261 ||
2128 st->codec->codec_id == CODEC_ID_VORBIS ||
2129 st->codec->codec_id == CODEC_ID_MJPEG ||
2130 st->codec->codec_id == CODEC_ID_PNG ||
2131 st->codec->codec_id == CODEC_ID_PAM ||
2132 st->codec->codec_id == CODEC_ID_PGM ||
2133 st->codec->codec_id == CODEC_ID_PGMYUV ||
2134 st->codec->codec_id == CODEC_ID_PBM ||
2135 st->codec->codec_id == CODEC_ID_PPM ||
2136 st->codec->codec_id == CODEC_ID_SHORTEN ||
2137 (st->codec->codec_id == CODEC_ID_MPEG4 && !st->need_parsing))*/)
2138 try_decode_frame(st, pkt->data, pkt->size);
2140 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) {
2146 // close codecs which were opened in try_decode_frame()
2147 for(i=0;i<ic->nb_streams;i++) {
2148 st = ic->streams[i];
2149 if(st->codec->codec)
2150 avcodec_close(st->codec);
2152 for(i=0;i<ic->nb_streams;i++) {
2153 st = ic->streams[i];
2154 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2155 if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample)
2156 st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2158 if(duration_count[i]
2159 && tb_unreliable(st->codec) /*&&
2160 //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2161 st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den*/){
2162 double best_error= 2*av_q2d(st->time_base);
2163 best_error= best_error*best_error*duration_count[i]*1000*12*30;
2165 for(j=1; j<MAX_STD_TIMEBASES; j++){
2166 double error= duration_error[i][j] * get_std_framerate(j);
2167 // if(st->codec->codec_type == CODEC_TYPE_VIDEO)
2168 // av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
2169 if(error < best_error){
2171 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, get_std_framerate(j), 12*1001, INT_MAX);
2176 if (!st->r_frame_rate.num){
2177 if( st->codec->time_base.den * (int64_t)st->time_base.num
2178 <= st->codec->time_base.num * (int64_t)st->time_base.den){
2179 st->r_frame_rate.num = st->codec->time_base.den;
2180 st->r_frame_rate.den = st->codec->time_base.num;
2182 st->r_frame_rate.num = st->time_base.den;
2183 st->r_frame_rate.den = st->time_base.num;
2186 }else if(st->codec->codec_type == CODEC_TYPE_AUDIO) {
2187 if(!st->codec->bits_per_coded_sample)
2188 st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2192 av_estimate_timings(ic, old_offset);
2194 compute_chapters_end(ic);
2197 /* correct DTS for B-frame streams with no timestamps */
2198 for(i=0;i<ic->nb_streams;i++) {
2199 st = ic->streams[i];
2200 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2202 ppktl = &ic->packet_buffer;
2204 if(ppkt1->stream_index != i)
2206 if(ppkt1->pkt->dts < 0)
2208 if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2210 ppkt1->pkt->dts -= delta;
2215 st->cur_dts -= delta;
2221 av_free(duration_error);
2226 /*******************************************************/
2228 int av_read_play(AVFormatContext *s)
2230 if (s->iformat->read_play)
2231 return s->iformat->read_play(s);
2233 return av_url_read_fpause(s->pb, 0);
2234 return AVERROR(ENOSYS);
2237 int av_read_pause(AVFormatContext *s)
2239 if (s->iformat->read_pause)
2240 return s->iformat->read_pause(s);
2242 return av_url_read_fpause(s->pb, 1);
2243 return AVERROR(ENOSYS);
2246 void av_close_input_stream(AVFormatContext *s)
2251 if (s->iformat->read_close)
2252 s->iformat->read_close(s);
2253 for(i=0;i<s->nb_streams;i++) {
2254 /* free all data in a stream component */
2257 av_parser_close(st->parser);
2258 av_free_packet(&st->cur_pkt);
2260 av_metadata_free(&st->metadata);
2261 av_free(st->index_entries);
2262 av_free(st->codec->extradata);
2264 av_free(st->filename);
2265 av_free(st->priv_data);
2268 for(i=s->nb_programs-1; i>=0; i--) {
2269 av_freep(&s->programs[i]->provider_name);
2270 av_freep(&s->programs[i]->name);
2271 av_metadata_free(&s->programs[i]->metadata);
2272 av_freep(&s->programs[i]->stream_index);
2273 av_freep(&s->programs[i]);
2275 av_freep(&s->programs);
2276 flush_packet_queue(s);
2277 av_freep(&s->priv_data);
2278 while(s->nb_chapters--) {
2279 av_free(s->chapters[s->nb_chapters]->title);
2280 av_metadata_free(&s->chapters[s->nb_chapters]->metadata);
2281 av_free(s->chapters[s->nb_chapters]);
2283 av_freep(&s->chapters);
2284 av_metadata_free(&s->metadata);
2288 void av_close_input_file(AVFormatContext *s)
2290 ByteIOContext *pb = s->iformat->flags & AVFMT_NOFILE ? NULL : s->pb;
2291 av_close_input_stream(s);
2296 AVStream *av_new_stream(AVFormatContext *s, int id)
2301 if (s->nb_streams >= MAX_STREAMS)
2304 st = av_mallocz(sizeof(AVStream));
2308 st->codec= avcodec_alloc_context();
2310 /* no default bitrate if decoding */
2311 st->codec->bit_rate = 0;
2313 st->index = s->nb_streams;
2315 st->start_time = AV_NOPTS_VALUE;
2316 st->duration = AV_NOPTS_VALUE;
2317 /* we set the current DTS to 0 so that formats without any timestamps
2318 but durations get some timestamps, formats with some unknown
2319 timestamps have their first few packets buffered and the
2320 timestamps corrected before they are returned to the user */
2322 st->first_dts = AV_NOPTS_VALUE;
2324 /* default pts setting is MPEG-like */
2325 av_set_pts_info(st, 33, 1, 90000);
2326 st->last_IP_pts = AV_NOPTS_VALUE;
2327 for(i=0; i<MAX_REORDER_DELAY+1; i++)
2328 st->pts_buffer[i]= AV_NOPTS_VALUE;
2330 st->sample_aspect_ratio = (AVRational){0,1};
2332 s->streams[s->nb_streams++] = st;
2336 AVProgram *av_new_program(AVFormatContext *ac, int id)
2338 AVProgram *program=NULL;
2342 av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2345 for(i=0; i<ac->nb_programs; i++)
2346 if(ac->programs[i]->id == id)
2347 program = ac->programs[i];
2350 program = av_mallocz(sizeof(AVProgram));
2353 dynarray_add(&ac->programs, &ac->nb_programs, program);
2354 program->discard = AVDISCARD_NONE;
2361 AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2363 AVChapter *chapter = NULL;
2366 for(i=0; i<s->nb_chapters; i++)
2367 if(s->chapters[i]->id == id)
2368 chapter = s->chapters[i];
2371 chapter= av_mallocz(sizeof(AVChapter));
2374 dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2376 av_free(chapter->title);
2377 chapter->title = av_strdup(title);
2379 chapter->time_base= time_base;
2380 chapter->start = start;
2386 /************************************************************/
2387 /* output media file */
2389 int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2393 if (s->oformat->priv_data_size > 0) {
2394 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2396 return AVERROR(ENOMEM);
2398 s->priv_data = NULL;
2400 if (s->oformat->set_parameters) {
2401 ret = s->oformat->set_parameters(s, ap);
2408 int av_write_header(AVFormatContext *s)
2413 // some sanity checks
2414 for(i=0;i<s->nb_streams;i++) {
2417 switch (st->codec->codec_type) {
2418 case CODEC_TYPE_AUDIO:
2419 if(st->codec->sample_rate<=0){
2420 av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2423 if(!st->codec->block_align)
2424 st->codec->block_align = st->codec->channels *
2425 av_get_bits_per_sample(st->codec->codec_id) >> 3;
2427 case CODEC_TYPE_VIDEO:
2428 if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2429 av_log(s, AV_LOG_ERROR, "time base not set\n");
2432 if(st->codec->width<=0 || st->codec->height<=0){
2433 av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2436 if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)){
2437 av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between encoder and muxer layer\n");
2443 if(s->oformat->codec_tag){
2444 if(st->codec->codec_tag){
2446 //check that tag + id is in the table
2447 //if neither is in the table -> OK
2448 //if tag is in the table with another id -> FAIL
2449 //if id is in the table with another tag -> FAIL unless strict < ?
2451 st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2454 if(s->oformat->flags & AVFMT_GLOBALHEADER &&
2455 !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
2456 av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
2459 if (!s->priv_data && s->oformat->priv_data_size > 0) {
2460 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2462 return AVERROR(ENOMEM);
2465 #if LIBAVFORMAT_VERSION_MAJOR < 53
2466 ff_metadata_mux_compat(s);
2469 if(s->oformat->write_header){
2470 ret = s->oformat->write_header(s);
2475 /* init PTS generation */
2476 for(i=0;i<s->nb_streams;i++) {
2477 int64_t den = AV_NOPTS_VALUE;
2480 switch (st->codec->codec_type) {
2481 case CODEC_TYPE_AUDIO:
2482 den = (int64_t)st->time_base.num * st->codec->sample_rate;
2484 case CODEC_TYPE_VIDEO:
2485 den = (int64_t)st->time_base.num * st->codec->time_base.den;
2490 if (den != AV_NOPTS_VALUE) {
2492 return AVERROR_INVALIDDATA;
2493 av_frac_init(&st->pts, 0, 0, den);
2499 //FIXME merge with compute_pkt_fields
2500 static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
2501 int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2502 int num, den, frame_size, i;
2504 // av_log(st->codec, 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);
2506 /* if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2509 /* duration field */
2510 if (pkt->duration == 0) {
2511 compute_frame_duration(&num, &den, st, NULL, pkt);
2513 pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
2517 if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
2520 //XXX/FIXME this is a temporary hack until all encoders output pts
2521 if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2523 // pkt->pts= st->cur_dts;
2524 pkt->pts= st->pts.val;
2527 //calculate dts from pts
2528 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
2529 st->pts_buffer[0]= pkt->pts;
2530 for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2531 st->pts_buffer[i]= (i-delay-1) * pkt->duration;
2532 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2533 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2535 pkt->dts= st->pts_buffer[0];
2538 if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2539 av_log(st->codec, AV_LOG_ERROR, "error, non monotone timestamps %"PRId64" >= %"PRId64"\n", st->cur_dts, pkt->dts);
2542 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2543 av_log(st->codec, AV_LOG_ERROR, "error, pts < dts\n");
2547 // av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2548 st->cur_dts= pkt->dts;
2549 st->pts.val= pkt->dts;
2552 switch (st->codec->codec_type) {
2553 case CODEC_TYPE_AUDIO:
2554 frame_size = get_audio_frame_size(st->codec, pkt->size);
2556 /* HACK/FIXME, we skip the initial 0 size packets as they are most
2557 likely equal to the encoder delay, but it would be better if we
2558 had the real timestamps from the encoder */
2559 if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2560 av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2563 case CODEC_TYPE_VIDEO:
2564 av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2572 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2574 int ret = compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2576 if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2579 ret= s->oformat->write_packet(s, pkt);
2581 ret= url_ferror(s->pb);
2585 void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
2586 int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
2588 AVPacketList **next_point, *this_pktl;
2590 this_pktl = av_mallocz(sizeof(AVPacketList));
2591 this_pktl->pkt= *pkt;
2592 if(pkt->destruct == av_destruct_packet)
2593 pkt->destruct= NULL; // not shared -> must keep original from being freed
2595 av_dup_packet(&this_pktl->pkt); //shared -> must dup
2597 next_point = &s->packet_buffer;
2599 if(compare(s, &(*next_point)->pkt, pkt))
2601 next_point= &(*next_point)->next;
2603 this_pktl->next= *next_point;
2604 *next_point= this_pktl;
2607 int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
2609 AVStream *st = s->streams[ pkt ->stream_index];
2610 AVStream *st2= s->streams[ next->stream_index];
2611 int64_t left = st2->time_base.num * (int64_t)st ->time_base.den;
2612 int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2614 if (pkt->dts == AV_NOPTS_VALUE)
2617 return next->dts * left > pkt->dts * right; //FIXME this can overflow
2620 int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2623 int streams[MAX_STREAMS];
2626 ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
2629 memset(streams, 0, sizeof(streams));
2630 pktl= s->packet_buffer;
2632 //av_log(s, AV_LOG_DEBUG, "show st:%d dts:%"PRId64"\n", pktl->pkt.stream_index, pktl->pkt.dts);
2633 if(streams[ pktl->pkt.stream_index ] == 0)
2635 streams[ pktl->pkt.stream_index ]++;
2639 if(stream_count && (s->nb_streams == stream_count || flush)){
2640 pktl= s->packet_buffer;
2643 s->packet_buffer= pktl->next;
2647 av_init_packet(out);
2653 * Interleaves an AVPacket correctly so it can be muxed.
2654 * @param out the interleaved packet will be output here
2655 * @param in the input packet
2656 * @param flush 1 if no further packets are available as input and all
2657 * remaining packets should be output
2658 * @return 1 if a packet was output, 0 if no packet could be output,
2659 * < 0 if an error occurred
2661 static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2662 if(s->oformat->interleave_packet)
2663 return s->oformat->interleave_packet(s, out, in, flush);
2665 return av_interleave_packet_per_dts(s, out, in, flush);
2668 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2669 AVStream *st= s->streams[ pkt->stream_index];
2671 //FIXME/XXX/HACK drop zero sized packets
2672 if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2675 //av_log(NULL, AV_LOG_DEBUG, "av_interleaved_write_frame %d %"PRId64" %"PRId64"\n", pkt->size, pkt->dts, pkt->pts);
2676 if(compute_pkt_fields2(st, pkt) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2679 if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2684 int ret= av_interleave_packet(s, &opkt, pkt, 0);
2685 if(ret<=0) //FIXME cleanup needed for ret<0 ?
2688 ret= s->oformat->write_packet(s, &opkt);
2690 av_free_packet(&opkt);
2695 if(url_ferror(s->pb))
2696 return url_ferror(s->pb);
2700 int av_write_trailer(AVFormatContext *s)
2706 ret= av_interleave_packet(s, &pkt, NULL, 1);
2707 if(ret<0) //FIXME cleanup needed for ret<0 ?
2712 ret= s->oformat->write_packet(s, &pkt);
2714 av_free_packet(&pkt);
2718 if(url_ferror(s->pb))
2722 if(s->oformat->write_trailer)
2723 ret = s->oformat->write_trailer(s);
2726 ret=url_ferror(s->pb);
2727 for(i=0;i<s->nb_streams;i++)
2728 av_freep(&s->streams[i]->priv_data);
2729 av_freep(&s->priv_data);
2733 void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
2736 AVProgram *program=NULL;
2739 for(i=0; i<ac->nb_programs; i++){
2740 if(ac->programs[i]->id != progid)
2742 program = ac->programs[i];
2743 for(j=0; j<program->nb_stream_indexes; j++)
2744 if(program->stream_index[j] == idx)
2747 tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
2750 program->stream_index = tmp;
2751 program->stream_index[program->nb_stream_indexes++] = idx;
2756 /* "user interface" functions */
2757 static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
2760 int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
2761 AVStream *st = ic->streams[i];
2762 int g = av_gcd(st->time_base.num, st->time_base.den);
2763 avcodec_string(buf, sizeof(buf), st->codec, is_output);
2764 av_log(NULL, AV_LOG_INFO, " Stream #%d.%d", index, i);
2765 /* the pid is an important information, so we display it */
2766 /* XXX: add a generic system */
2767 if (flags & AVFMT_SHOW_IDS)
2768 av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
2769 if (strlen(st->language) > 0)
2770 av_log(NULL, AV_LOG_INFO, "(%s)", st->language);
2771 av_log(NULL, AV_LOG_DEBUG, ", %d/%d", st->time_base.num/g, st->time_base.den/g);
2772 av_log(NULL, AV_LOG_INFO, ": %s", buf);
2773 if (st->sample_aspect_ratio.num && // default
2774 av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
2775 AVRational display_aspect_ratio;
2776 av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
2777 st->codec->width*st->sample_aspect_ratio.num,
2778 st->codec->height*st->sample_aspect_ratio.den,
2780 av_log(NULL, AV_LOG_INFO, ", PAR %d:%d DAR %d:%d",
2781 st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
2782 display_aspect_ratio.num, display_aspect_ratio.den);
2784 if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2785 if(st->r_frame_rate.den && st->r_frame_rate.num)
2786 av_log(NULL, AV_LOG_INFO, ", %5.2f tb(r)", av_q2d(st->r_frame_rate));
2787 /* else if(st->time_base.den && st->time_base.num)
2788 av_log(NULL, AV_LOG_INFO, ", %5.2f tb(m)", 1/av_q2d(st->time_base));*/
2790 av_log(NULL, AV_LOG_INFO, ", %5.2f tb(c)", 1/av_q2d(st->codec->time_base));
2792 av_log(NULL, AV_LOG_INFO, "\n");
2795 void dump_format(AVFormatContext *ic,
2802 av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
2803 is_output ? "Output" : "Input",
2805 is_output ? ic->oformat->name : ic->iformat->name,
2806 is_output ? "to" : "from", url);
2808 av_log(NULL, AV_LOG_INFO, " Duration: ");
2809 if (ic->duration != AV_NOPTS_VALUE) {
2810 int hours, mins, secs, us;
2811 secs = ic->duration / AV_TIME_BASE;
2812 us = ic->duration % AV_TIME_BASE;
2817 av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
2818 (100 * us) / AV_TIME_BASE);
2820 av_log(NULL, AV_LOG_INFO, "N/A");
2822 if (ic->start_time != AV_NOPTS_VALUE) {
2824 av_log(NULL, AV_LOG_INFO, ", start: ");
2825 secs = ic->start_time / AV_TIME_BASE;
2826 us = ic->start_time % AV_TIME_BASE;
2827 av_log(NULL, AV_LOG_INFO, "%d.%06d",
2828 secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
2830 av_log(NULL, AV_LOG_INFO, ", bitrate: ");
2832 av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
2834 av_log(NULL, AV_LOG_INFO, "N/A");
2836 av_log(NULL, AV_LOG_INFO, "\n");
2838 if(ic->nb_programs) {
2840 for(j=0; j<ic->nb_programs; j++) {
2841 av_log(NULL, AV_LOG_INFO, " Program %d %s\n", ic->programs[j]->id,
2842 ic->programs[j]->name ? ic->programs[j]->name : "");
2843 for(k=0; k<ic->programs[j]->nb_stream_indexes; k++)
2844 dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
2847 for(i=0;i<ic->nb_streams;i++)
2848 dump_stream_format(ic, i, index, is_output);
2851 #if LIBAVFORMAT_VERSION_MAJOR < 53
2852 int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2854 return av_parse_video_frame_size(width_ptr, height_ptr, str);
2857 int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
2859 AVRational frame_rate;
2860 int ret = av_parse_video_frame_rate(&frame_rate, arg);
2861 *frame_rate_num= frame_rate.num;
2862 *frame_rate_den= frame_rate.den;
2867 int64_t av_gettime(void)
2870 gettimeofday(&tv,NULL);
2871 return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
2874 int64_t parse_date(const char *datestr, int duration)
2880 static const char * const date_fmt[] = {
2884 static const char * const time_fmt[] = {
2894 time_t now = time(0);
2896 len = strlen(datestr);
2898 lastch = datestr[len - 1];
2901 is_utc = (lastch == 'z' || lastch == 'Z');
2903 memset(&dt, 0, sizeof(dt));
2908 if (!strncasecmp(datestr, "now", len))
2909 return (int64_t) now * 1000000;
2911 /* parse the year-month-day part */
2912 for (i = 0; i < FF_ARRAY_ELEMS(date_fmt); i++) {
2913 q = small_strptime(p, date_fmt[i], &dt);
2919 /* if the year-month-day part is missing, then take the
2920 * current year-month-day time */
2925 dt = *localtime(&now);
2927 dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
2932 if (*p == 'T' || *p == 't' || *p == ' ')
2935 /* parse the hour-minute-second part */
2936 for (i = 0; i < FF_ARRAY_ELEMS(time_fmt); i++) {
2937 q = small_strptime(p, time_fmt[i], &dt);
2943 /* parse datestr as a duration */
2948 /* parse datestr as HH:MM:SS */
2949 q = small_strptime(p, time_fmt[0], &dt);
2951 /* parse datestr as S+ */
2952 dt.tm_sec = strtol(p, (char **)&q, 10);
2954 /* the parsing didn't succeed */
2961 /* Now we have all the fields that we can get */
2967 t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2969 dt.tm_isdst = -1; /* unknown */
2979 /* parse the .m... part */
2983 for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
2986 val += n * (*q - '0');
2990 return negative ? -t : t;
2993 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
3003 while (*p != '\0' && *p != '=' && *p != '&') {
3004 if ((q - tag) < sizeof(tag) - 1)
3012 while (*p != '&' && *p != '\0') {
3013 if ((q - arg) < arg_size - 1) {
3023 if (!strcmp(tag, tag1))
3032 int av_get_frame_filename(char *buf, int buf_size,
3033 const char *path, int number)
3036 char *q, buf1[20], c;
3037 int nd, len, percentd_found;
3049 while (isdigit(*p)) {
3050 nd = nd * 10 + *p++ - '0';
3053 } while (isdigit(c));
3062 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3064 if ((q - buf + len) > buf_size - 1)
3066 memcpy(q, buf1, len);
3074 if ((q - buf) < buf_size - 1)
3078 if (!percentd_found)
3087 static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3090 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3092 for(i=0;i<size;i+=16) {
3099 PRINT(" %02x", buf[i+j]);
3104 for(j=0;j<len;j++) {
3106 if (c < ' ' || c > '~')
3115 void av_hex_dump(FILE *f, uint8_t *buf, int size)
3117 hex_dump_internal(NULL, f, 0, buf, size);
3120 void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3122 hex_dump_internal(avcl, NULL, level, buf, size);
3125 //FIXME needs to know the time_base
3126 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload)
3128 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3129 PRINT("stream #%d:\n", pkt->stream_index);
3130 PRINT(" keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
3131 PRINT(" duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
3132 /* DTS is _always_ valid after av_read_frame() */
3134 if (pkt->dts == AV_NOPTS_VALUE)
3137 PRINT("%0.3f", (double)pkt->dts / AV_TIME_BASE);
3138 /* PTS may not be known if B-frames are present. */
3140 if (pkt->pts == AV_NOPTS_VALUE)
3143 PRINT("%0.3f", (double)pkt->pts / AV_TIME_BASE);
3145 PRINT(" size=%d\n", pkt->size);
3148 av_hex_dump(f, pkt->data, pkt->size);
3151 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3153 pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
3156 void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3158 pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
3161 void url_split(char *proto, int proto_size,
3162 char *authorization, int authorization_size,
3163 char *hostname, int hostname_size,
3165 char *path, int path_size,
3168 const char *p, *ls, *at, *col, *brk;
3170 if (port_ptr) *port_ptr = -1;
3171 if (proto_size > 0) proto[0] = 0;
3172 if (authorization_size > 0) authorization[0] = 0;
3173 if (hostname_size > 0) hostname[0] = 0;
3174 if (path_size > 0) path[0] = 0;
3176 /* parse protocol */
3177 if ((p = strchr(url, ':'))) {
3178 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3183 /* no protocol means plain filename */
3184 av_strlcpy(path, url, path_size);
3188 /* separate path from hostname */
3189 ls = strchr(p, '/');
3191 ls = strchr(p, '?');
3193 av_strlcpy(path, ls, path_size);
3195 ls = &p[strlen(p)]; // XXX
3197 /* the rest is hostname, use that to parse auth/port */
3199 /* authorization (user[:pass]@hostname) */
3200 if ((at = strchr(p, '@')) && at < ls) {
3201 av_strlcpy(authorization, p,
3202 FFMIN(authorization_size, at + 1 - p));
3203 p = at + 1; /* skip '@' */
3206 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3208 av_strlcpy(hostname, p + 1,
3209 FFMIN(hostname_size, brk - p));
3210 if (brk[1] == ':' && port_ptr)
3211 *port_ptr = atoi(brk + 2);
3212 } else if ((col = strchr(p, ':')) && col < ls) {
3213 av_strlcpy(hostname, p,
3214 FFMIN(col + 1 - p, hostname_size));
3215 if (port_ptr) *port_ptr = atoi(col + 1);
3217 av_strlcpy(hostname, p,
3218 FFMIN(ls + 1 - p, hostname_size));
3222 char *ff_data_to_hex(char *buff, const uint8_t *src, int s)
3225 static const char hex_table[16] = { '0', '1', '2', '3',
3228 'C', 'D', 'E', 'F' };
3230 for(i = 0; i < s; i++) {
3231 buff[i * 2] = hex_table[src[i] >> 4];
3232 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3238 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3239 int pts_num, int pts_den)
3241 unsigned int gcd= av_gcd(pts_num, pts_den);
3242 s->pts_wrap_bits = pts_wrap_bits;
3243 s->time_base.num = pts_num/gcd;
3244 s->time_base.den = pts_den/gcd;
3247 av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, gcd);