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) {
683 *pnum = (*pnum) * (1 + pc->repeat_pict);
687 case CODEC_TYPE_AUDIO:
688 frame_size = get_audio_frame_size(st->codec, pkt->size);
692 *pden = st->codec->sample_rate;
699 static int is_intra_only(AVCodecContext *enc){
700 if(enc->codec_type == CODEC_TYPE_AUDIO){
702 }else if(enc->codec_type == CODEC_TYPE_VIDEO){
703 switch(enc->codec_id){
705 case CODEC_ID_MJPEGB:
707 case CODEC_ID_RAWVIDEO:
708 case CODEC_ID_DVVIDEO:
709 case CODEC_ID_HUFFYUV:
710 case CODEC_ID_FFVHUFF:
715 case CODEC_ID_JPEG2000:
723 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
724 int64_t dts, int64_t pts)
726 AVStream *st= s->streams[stream_index];
727 AVPacketList *pktl= s->packet_buffer;
729 if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE)
732 st->first_dts= dts - st->cur_dts;
735 for(; pktl; pktl= pktl->next){
736 if(pktl->pkt.stream_index != stream_index)
738 //FIXME think more about this check
739 if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
740 pktl->pkt.pts += st->first_dts;
742 if(pktl->pkt.dts != AV_NOPTS_VALUE)
743 pktl->pkt.dts += st->first_dts;
745 if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
746 st->start_time= pktl->pkt.pts;
748 if (st->start_time == AV_NOPTS_VALUE)
749 st->start_time = pts;
752 static void update_initial_durations(AVFormatContext *s, AVStream *st, AVPacket *pkt)
754 AVPacketList *pktl= s->packet_buffer;
757 if(st->first_dts != AV_NOPTS_VALUE){
758 cur_dts= st->first_dts;
759 for(; pktl; pktl= pktl->next){
760 if(pktl->pkt.stream_index == pkt->stream_index){
761 if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
763 cur_dts -= pkt->duration;
766 pktl= s->packet_buffer;
767 st->first_dts = cur_dts;
768 }else if(st->cur_dts)
771 for(; pktl; pktl= pktl->next){
772 if(pktl->pkt.stream_index != pkt->stream_index)
774 if(pktl->pkt.pts == pktl->pkt.dts && pktl->pkt.dts == AV_NOPTS_VALUE
775 && !pktl->pkt.duration){
776 pktl->pkt.dts= cur_dts;
777 if(!st->codec->has_b_frames)
778 pktl->pkt.pts= cur_dts;
779 cur_dts += pkt->duration;
780 pktl->pkt.duration= pkt->duration;
784 if(st->first_dts == AV_NOPTS_VALUE)
785 st->cur_dts= cur_dts;
788 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
789 AVCodecParserContext *pc, AVPacket *pkt)
791 int num, den, presentation_delayed, delay, i;
794 /* do we have a video B-frame ? */
795 delay= st->codec->has_b_frames;
796 presentation_delayed = 0;
797 /* XXX: need has_b_frame, but cannot get it if the codec is
800 pc && pc->pict_type != FF_B_TYPE)
801 presentation_delayed = 1;
803 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
804 /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
805 pkt->dts -= 1LL<<st->pts_wrap_bits;
808 // some mpeg2 in mpeg-ps lack dts (issue171 / input_file.mpg)
809 // we take the conservative approach and discard both
810 // Note, if this is misbehaving for a H.264 file then possibly presentation_delayed is not set correctly.
811 if(delay==1 && pkt->dts == pkt->pts && pkt->dts != AV_NOPTS_VALUE && presentation_delayed){
812 av_log(s, AV_LOG_WARNING, "invalid dts/pts combination\n");
813 pkt->dts= pkt->pts= AV_NOPTS_VALUE;
816 if (pkt->duration == 0) {
817 compute_frame_duration(&num, &den, st, pc, pkt);
819 pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
821 if(pkt->duration != 0 && s->packet_buffer)
822 update_initial_durations(s, st, pkt);
826 /* correct timestamps with byte offset if demuxers only have timestamps
827 on packet boundaries */
828 if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
829 /* this will estimate bitrate based on this frame's duration and size */
830 offset = av_rescale(pc->offset, pkt->duration, pkt->size);
831 if(pkt->pts != AV_NOPTS_VALUE)
833 if(pkt->dts != AV_NOPTS_VALUE)
837 if (pc && pc->dts_sync_point >= 0) {
838 // we have synchronization info from the parser
839 int64_t den = st->codec->time_base.den * (int64_t) st->time_base.num;
841 int64_t num = st->codec->time_base.num * (int64_t) st->time_base.den;
842 if (pkt->dts != AV_NOPTS_VALUE) {
843 // got DTS from the stream, update reference timestamp
844 st->reference_dts = pkt->dts - pc->dts_ref_dts_delta * num / den;
845 pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
846 } else if (st->reference_dts != AV_NOPTS_VALUE) {
847 // compute DTS based on reference timestamp
848 pkt->dts = st->reference_dts + pc->dts_ref_dts_delta * num / den;
849 pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
851 if (pc->dts_sync_point > 0)
852 st->reference_dts = pkt->dts; // new reference
856 /* This may be redundant, but it should not hurt. */
857 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
858 presentation_delayed = 1;
860 // 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);
861 /* interpolate PTS and DTS if they are not present */
862 //We skip H264 currently because delay and has_b_frames are not reliably set
863 if((delay==0 || (delay==1 && pc)) && st->codec->codec_id != CODEC_ID_H264){
864 if (presentation_delayed) {
865 /* DTS = decompression timestamp */
866 /* PTS = presentation timestamp */
867 if (pkt->dts == AV_NOPTS_VALUE)
868 pkt->dts = st->last_IP_pts;
869 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
870 if (pkt->dts == AV_NOPTS_VALUE)
871 pkt->dts = st->cur_dts;
873 /* this is tricky: the dts must be incremented by the duration
874 of the frame we are displaying, i.e. the last I- or P-frame */
875 if (st->last_IP_duration == 0)
876 st->last_IP_duration = pkt->duration;
877 if(pkt->dts != AV_NOPTS_VALUE)
878 st->cur_dts = pkt->dts + st->last_IP_duration;
879 st->last_IP_duration = pkt->duration;
880 st->last_IP_pts= pkt->pts;
881 /* cannot compute PTS if not present (we can compute it only
882 by knowing the future */
883 } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
884 if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
885 int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
886 int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
887 if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
888 pkt->pts += pkt->duration;
889 // 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);
893 /* presentation is not delayed : PTS and DTS are the same */
894 if(pkt->pts == AV_NOPTS_VALUE)
896 update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
897 if(pkt->pts == AV_NOPTS_VALUE)
898 pkt->pts = st->cur_dts;
900 if(pkt->pts != AV_NOPTS_VALUE)
901 st->cur_dts = pkt->pts + pkt->duration;
905 if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
906 st->pts_buffer[0]= pkt->pts;
907 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
908 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
909 if(pkt->dts == AV_NOPTS_VALUE)
910 pkt->dts= st->pts_buffer[0];
911 if(st->codec->codec_id == CODEC_ID_H264){ //we skiped it above so we try here
912 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
914 if(pkt->dts > st->cur_dts)
915 st->cur_dts = pkt->dts;
918 // 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);
921 if(is_intra_only(st->codec))
922 pkt->flags |= PKT_FLAG_KEY;
925 /* keyframe computation */
926 if (pc->key_frame == 1)
927 pkt->flags |= PKT_FLAG_KEY;
928 else if (pc->key_frame == -1 && pc->pict_type == FF_I_TYPE)
929 pkt->flags |= PKT_FLAG_KEY;
932 pkt->convergence_duration = pc->convergence_duration;
935 void av_destruct_packet_nofree(AVPacket *pkt)
937 pkt->data = NULL; pkt->size = 0;
940 static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
948 /* select current input stream component */
951 if (!st->need_parsing || !st->parser) {
952 /* no parsing needed: we just output the packet as is */
953 /* raw data support */
954 *pkt = st->cur_pkt; st->cur_pkt.data= NULL;
955 compute_pkt_fields(s, st, NULL, pkt);
958 } else if (st->cur_len > 0 && st->discard < AVDISCARD_ALL) {
959 len = av_parser_parse2(st->parser, st->codec, &pkt->data, &pkt->size,
960 st->cur_ptr, st->cur_len,
961 st->cur_pkt.pts, st->cur_pkt.dts,
963 st->cur_pkt.pts = AV_NOPTS_VALUE;
964 st->cur_pkt.dts = AV_NOPTS_VALUE;
965 /* increment read pointer */
969 /* return packet if any */
973 pkt->stream_index = st->index;
974 pkt->pts = st->parser->pts;
975 pkt->dts = st->parser->dts;
976 pkt->pos = st->parser->pos;
977 pkt->destruct = av_destruct_packet_nofree;
978 compute_pkt_fields(s, st, st->parser, pkt);
980 if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & PKT_FLAG_KEY){
981 ff_reduce_index(s, st->index);
982 av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
983 0, 0, AVINDEX_KEYFRAME);
990 av_free_packet(&st->cur_pkt);
995 /* read next packet */
996 ret = av_read_packet(s, &cur_pkt);
998 if (ret == AVERROR(EAGAIN))
1000 /* return the last frames, if any */
1001 for(i = 0; i < s->nb_streams; i++) {
1003 if (st->parser && st->need_parsing) {
1004 av_parser_parse2(st->parser, st->codec,
1005 &pkt->data, &pkt->size,
1007 AV_NOPTS_VALUE, AV_NOPTS_VALUE,
1013 /* no more packets: really terminate parsing */
1016 st = s->streams[cur_pkt.stream_index];
1017 st->cur_pkt= cur_pkt;
1019 if(st->cur_pkt.pts != AV_NOPTS_VALUE &&
1020 st->cur_pkt.dts != AV_NOPTS_VALUE &&
1021 st->cur_pkt.pts < st->cur_pkt.dts){
1022 av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
1023 st->cur_pkt.stream_index,
1027 // av_free_packet(&st->cur_pkt);
1031 if(s->debug & FF_FDEBUG_TS)
1032 av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, flags=%d\n",
1033 st->cur_pkt.stream_index,
1040 st->cur_ptr = st->cur_pkt.data;
1041 st->cur_len = st->cur_pkt.size;
1042 if (st->need_parsing && !st->parser) {
1043 st->parser = av_parser_init(st->codec->codec_id);
1045 /* no parser available: just output the raw packets */
1046 st->need_parsing = AVSTREAM_PARSE_NONE;
1047 }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
1048 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1050 if(st->parser && (s->iformat->flags & AVFMT_GENERIC_INDEX)){
1051 st->parser->next_frame_offset=
1052 st->parser->cur_offset= st->cur_pkt.pos;
1057 if(s->debug & FF_FDEBUG_TS)
1058 av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, flags=%d\n",
1068 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1072 const int genpts= s->flags & AVFMT_FLAG_GENPTS;
1075 pktl = s->packet_buffer;
1077 AVPacket *next_pkt= &pktl->pkt;
1079 if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
1080 while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
1081 if( pktl->pkt.stream_index == next_pkt->stream_index
1082 && next_pkt->dts < pktl->pkt.dts
1083 && pktl->pkt.pts != pktl->pkt.dts //not b frame
1084 /*&& pktl->pkt.dts != AV_NOPTS_VALUE*/){
1085 next_pkt->pts= pktl->pkt.dts;
1089 pktl = s->packet_buffer;
1092 if( next_pkt->pts != AV_NOPTS_VALUE
1093 || next_pkt->dts == AV_NOPTS_VALUE
1095 /* read packet from packet buffer, if there is data */
1097 s->packet_buffer = pktl->next;
1103 int ret= av_read_frame_internal(s, pkt);
1105 if(pktl && ret != AVERROR(EAGAIN)){
1112 if(av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1113 &s->packet_buffer_end)) < 0)
1114 return AVERROR(ENOMEM);
1116 assert(!s->packet_buffer);
1117 return av_read_frame_internal(s, pkt);
1122 /* XXX: suppress the packet queue */
1123 static void flush_packet_queue(AVFormatContext *s)
1128 pktl = s->packet_buffer;
1131 s->packet_buffer = pktl->next;
1132 av_free_packet(&pktl->pkt);
1137 /*******************************************************/
1140 int av_find_default_stream_index(AVFormatContext *s)
1142 int first_audio_index = -1;
1146 if (s->nb_streams <= 0)
1148 for(i = 0; i < s->nb_streams; i++) {
1150 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1153 if (first_audio_index < 0 && st->codec->codec_type == CODEC_TYPE_AUDIO)
1154 first_audio_index = i;
1156 return first_audio_index >= 0 ? first_audio_index : 0;
1160 * Flush the frame reader.
1162 static void av_read_frame_flush(AVFormatContext *s)
1167 flush_packet_queue(s);
1171 /* for each stream, reset read state */
1172 for(i = 0; i < s->nb_streams; i++) {
1176 av_parser_close(st->parser);
1178 av_free_packet(&st->cur_pkt);
1180 st->last_IP_pts = AV_NOPTS_VALUE;
1181 st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1182 st->reference_dts = AV_NOPTS_VALUE;
1189 void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1192 for(i = 0; i < s->nb_streams; i++) {
1193 AVStream *st = s->streams[i];
1195 st->cur_dts = av_rescale(timestamp,
1196 st->time_base.den * (int64_t)ref_st->time_base.num,
1197 st->time_base.num * (int64_t)ref_st->time_base.den);
1201 void ff_reduce_index(AVFormatContext *s, int stream_index)
1203 AVStream *st= s->streams[stream_index];
1204 unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1206 if((unsigned)st->nb_index_entries >= max_entries){
1208 for(i=0; 2*i<st->nb_index_entries; i++)
1209 st->index_entries[i]= st->index_entries[2*i];
1210 st->nb_index_entries= i;
1214 int av_add_index_entry(AVStream *st,
1215 int64_t pos, int64_t timestamp, int size, int distance, int flags)
1217 AVIndexEntry *entries, *ie;
1220 if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1223 entries = av_fast_realloc(st->index_entries,
1224 &st->index_entries_allocated_size,
1225 (st->nb_index_entries + 1) *
1226 sizeof(AVIndexEntry));
1230 st->index_entries= entries;
1232 index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
1235 index= st->nb_index_entries++;
1236 ie= &entries[index];
1237 assert(index==0 || ie[-1].timestamp < timestamp);
1239 ie= &entries[index];
1240 if(ie->timestamp != timestamp){
1241 if(ie->timestamp <= timestamp)
1243 memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
1244 st->nb_index_entries++;
1245 }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1246 distance= ie->min_distance;
1250 ie->timestamp = timestamp;
1251 ie->min_distance= distance;
1258 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1261 AVIndexEntry *entries= st->index_entries;
1262 int nb_entries= st->nb_index_entries;
1271 timestamp = entries[m].timestamp;
1272 if(timestamp >= wanted_timestamp)
1274 if(timestamp <= wanted_timestamp)
1277 m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1279 if(!(flags & AVSEEK_FLAG_ANY)){
1280 while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1281 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1292 int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1293 AVInputFormat *avif= s->iformat;
1294 int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1295 int64_t ts_min, ts_max, ts;
1299 if (stream_index < 0)
1303 av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1307 ts_min= AV_NOPTS_VALUE;
1308 pos_limit= -1; //gcc falsely says it may be uninitialized
1310 st= s->streams[stream_index];
1311 if(st->index_entries){
1314 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()
1315 index= FFMAX(index, 0);
1316 e= &st->index_entries[index];
1318 if(e->timestamp <= target_ts || e->pos == e->min_distance){
1320 ts_min= e->timestamp;
1322 av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1329 index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1330 assert(index < st->nb_index_entries);
1332 e= &st->index_entries[index];
1333 assert(e->timestamp >= target_ts);
1335 ts_max= e->timestamp;
1336 pos_limit= pos_max - e->min_distance;
1338 av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1339 pos_max,pos_limit, ts_max);
1344 pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1349 url_fseek(s->pb, pos, SEEK_SET);
1351 av_update_cur_dts(s, st, ts);
1356 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 )){
1358 int64_t start_pos, filesize;
1362 av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1365 if(ts_min == AV_NOPTS_VALUE){
1366 pos_min = s->data_offset;
1367 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1368 if (ts_min == AV_NOPTS_VALUE)
1372 if(ts_max == AV_NOPTS_VALUE){
1374 filesize = url_fsize(s->pb);
1375 pos_max = filesize - 1;
1378 ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1380 }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1381 if (ts_max == AV_NOPTS_VALUE)
1385 int64_t tmp_pos= pos_max + 1;
1386 int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1387 if(tmp_ts == AV_NOPTS_VALUE)
1391 if(tmp_pos >= filesize)
1397 if(ts_min > ts_max){
1399 }else if(ts_min == ts_max){
1404 while (pos_min < pos_limit) {
1406 av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1410 assert(pos_limit <= pos_max);
1413 int64_t approximate_keyframe_distance= pos_max - pos_limit;
1414 // interpolate position (better than dichotomy)
1415 pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1416 + pos_min - approximate_keyframe_distance;
1417 }else if(no_change==1){
1418 // bisection, if interpolation failed to change min or max pos last time
1419 pos = (pos_min + pos_limit)>>1;
1421 /* linear search if bisection failed, can only happen if there
1422 are very few or no keyframes between min/max */
1427 else if(pos > pos_limit)
1431 ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1437 av_log(s, AV_LOG_DEBUG, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64" target:%"PRId64" limit:%"PRId64" start:%"PRId64" noc:%d\n",
1438 pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts, pos_limit,
1439 start_pos, no_change);
1441 if(ts == AV_NOPTS_VALUE){
1442 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1445 assert(ts != AV_NOPTS_VALUE);
1446 if (target_ts <= ts) {
1447 pos_limit = start_pos - 1;
1451 if (target_ts >= ts) {
1457 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1458 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
1461 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1463 ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1464 av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1465 pos, ts_min, target_ts, ts_max);
1471 static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1472 int64_t pos_min, pos_max;
1476 if (stream_index < 0)
1479 st= s->streams[stream_index];
1482 pos_min = s->data_offset;
1483 pos_max = url_fsize(s->pb) - 1;
1485 if (pos < pos_min) pos= pos_min;
1486 else if(pos > pos_max) pos= pos_max;
1488 url_fseek(s->pb, pos, SEEK_SET);
1491 av_update_cur_dts(s, st, ts);
1496 static int av_seek_frame_generic(AVFormatContext *s,
1497 int stream_index, int64_t timestamp, int flags)
1503 st = s->streams[stream_index];
1505 index = av_index_search_timestamp(st, timestamp, flags);
1507 if(index < 0 || index==st->nb_index_entries-1){
1511 if(st->nb_index_entries){
1512 assert(st->index_entries);
1513 ie= &st->index_entries[st->nb_index_entries-1];
1514 if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
1516 av_update_cur_dts(s, st, ie->timestamp);
1518 if ((ret = url_fseek(s->pb, s->data_offset, SEEK_SET)) < 0)
1524 ret = av_read_frame(s, &pkt);
1525 }while(ret == AVERROR(EAGAIN));
1528 av_free_packet(&pkt);
1529 if(stream_index == pkt.stream_index){
1530 if((pkt.flags & PKT_FLAG_KEY) && pkt.dts > timestamp)
1534 index = av_index_search_timestamp(st, timestamp, flags);
1539 av_read_frame_flush(s);
1540 if (s->iformat->read_seek){
1541 if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1544 ie = &st->index_entries[index];
1545 if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
1547 av_update_cur_dts(s, st, ie->timestamp);
1552 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1557 av_read_frame_flush(s);
1559 if(flags & AVSEEK_FLAG_BYTE)
1560 return av_seek_frame_byte(s, stream_index, timestamp, flags);
1562 if(stream_index < 0){
1563 stream_index= av_find_default_stream_index(s);
1564 if(stream_index < 0)
1567 st= s->streams[stream_index];
1568 /* timestamp for default must be expressed in AV_TIME_BASE units */
1569 timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1572 /* first, we try the format specific seek */
1573 if (s->iformat->read_seek)
1574 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1581 if(s->iformat->read_timestamp)
1582 return av_seek_frame_binary(s, stream_index, timestamp, flags);
1584 return av_seek_frame_generic(s, stream_index, timestamp, flags);
1587 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
1589 if(min_ts > ts || max_ts < ts)
1592 av_read_frame_flush(s);
1594 if (s->iformat->read_seek2)
1595 return s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
1597 if(s->iformat->read_timestamp){
1598 //try to seek via read_timestamp()
1601 //Fallback to old API if new is not implemented but old is
1602 //Note the old has somewat different sematics
1603 if(s->iformat->read_seek || 1)
1604 return av_seek_frame(s, stream_index, ts, flags | (ts - min_ts > (uint64_t)(max_ts - ts) ? AVSEEK_FLAG_BACKWARD : 0));
1606 // try some generic seek like av_seek_frame_generic() but with new ts semantics
1609 /*******************************************************/
1612 * Returns TRUE if the stream has accurate duration in any stream.
1614 * @return TRUE if the stream has accurate duration for at least one component.
1616 static int av_has_duration(AVFormatContext *ic)
1621 for(i = 0;i < ic->nb_streams; i++) {
1622 st = ic->streams[i];
1623 if (st->duration != AV_NOPTS_VALUE)
1630 * Estimate the stream timings from the one of each components.
1632 * Also computes the global bitrate if possible.
1634 static void av_update_stream_timings(AVFormatContext *ic)
1636 int64_t start_time, start_time1, end_time, end_time1;
1637 int64_t duration, duration1;
1641 start_time = INT64_MAX;
1642 end_time = INT64_MIN;
1643 duration = INT64_MIN;
1644 for(i = 0;i < ic->nb_streams; i++) {
1645 st = ic->streams[i];
1646 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
1647 start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1648 if (start_time1 < start_time)
1649 start_time = start_time1;
1650 if (st->duration != AV_NOPTS_VALUE) {
1651 end_time1 = start_time1
1652 + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1653 if (end_time1 > end_time)
1654 end_time = end_time1;
1657 if (st->duration != AV_NOPTS_VALUE) {
1658 duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1659 if (duration1 > duration)
1660 duration = duration1;
1663 if (start_time != INT64_MAX) {
1664 ic->start_time = start_time;
1665 if (end_time != INT64_MIN) {
1666 if (end_time - start_time > duration)
1667 duration = end_time - start_time;
1670 if (duration != INT64_MIN) {
1671 ic->duration = duration;
1672 if (ic->file_size > 0) {
1673 /* compute the bitrate */
1674 ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1675 (double)ic->duration;
1680 static void fill_all_stream_timings(AVFormatContext *ic)
1685 av_update_stream_timings(ic);
1686 for(i = 0;i < ic->nb_streams; i++) {
1687 st = ic->streams[i];
1688 if (st->start_time == AV_NOPTS_VALUE) {
1689 if(ic->start_time != AV_NOPTS_VALUE)
1690 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1691 if(ic->duration != AV_NOPTS_VALUE)
1692 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1697 static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1699 int64_t filesize, duration;
1703 /* if bit_rate is already set, we believe it */
1704 if (ic->bit_rate == 0) {
1706 for(i=0;i<ic->nb_streams;i++) {
1707 st = ic->streams[i];
1708 bit_rate += st->codec->bit_rate;
1710 ic->bit_rate = bit_rate;
1713 /* if duration is already set, we believe it */
1714 if (ic->duration == AV_NOPTS_VALUE &&
1715 ic->bit_rate != 0 &&
1716 ic->file_size != 0) {
1717 filesize = ic->file_size;
1719 for(i = 0; i < ic->nb_streams; i++) {
1720 st = ic->streams[i];
1721 duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1722 if (st->duration == AV_NOPTS_VALUE)
1723 st->duration = duration;
1729 #define DURATION_MAX_READ_SIZE 250000
1731 /* only usable for MPEG-PS streams */
1732 static void av_estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
1734 AVPacket pkt1, *pkt = &pkt1;
1736 int read_size, i, ret;
1738 int64_t filesize, offset, duration;
1742 /* flush packet queue */
1743 flush_packet_queue(ic);
1745 for(i=0;i<ic->nb_streams;i++) {
1746 st = ic->streams[i];
1748 av_parser_close(st->parser);
1750 av_free_packet(&st->cur_pkt);
1754 /* we read the first packets to get the first PTS (not fully
1755 accurate, but it is enough now) */
1756 url_fseek(ic->pb, 0, SEEK_SET);
1759 if (read_size >= DURATION_MAX_READ_SIZE)
1761 /* if all info is available, we can stop */
1762 for(i = 0;i < ic->nb_streams; i++) {
1763 st = ic->streams[i];
1764 if (st->start_time == AV_NOPTS_VALUE)
1767 if (i == ic->nb_streams)
1771 ret = av_read_packet(ic, pkt);
1772 }while(ret == AVERROR(EAGAIN));
1775 read_size += pkt->size;
1776 st = ic->streams[pkt->stream_index];
1777 if (pkt->pts != AV_NOPTS_VALUE) {
1778 if (st->start_time == AV_NOPTS_VALUE)
1779 st->start_time = pkt->pts;
1781 av_free_packet(pkt);
1784 /* estimate the end time (duration) */
1785 /* XXX: may need to support wrapping */
1786 filesize = ic->file_size;
1787 offset = filesize - DURATION_MAX_READ_SIZE;
1791 url_fseek(ic->pb, offset, SEEK_SET);
1794 if (read_size >= DURATION_MAX_READ_SIZE)
1798 ret = av_read_packet(ic, pkt);
1799 }while(ret == AVERROR(EAGAIN));
1802 read_size += pkt->size;
1803 st = ic->streams[pkt->stream_index];
1804 if (pkt->pts != AV_NOPTS_VALUE &&
1805 st->start_time != AV_NOPTS_VALUE) {
1806 end_time = pkt->pts;
1807 duration = end_time - st->start_time;
1809 if (st->duration == AV_NOPTS_VALUE ||
1810 st->duration < duration)
1811 st->duration = duration;
1814 av_free_packet(pkt);
1817 fill_all_stream_timings(ic);
1819 url_fseek(ic->pb, old_offset, SEEK_SET);
1820 for(i=0; i<ic->nb_streams; i++){
1822 st->cur_dts= st->first_dts;
1823 st->last_IP_pts = AV_NOPTS_VALUE;
1827 static void av_estimate_timings(AVFormatContext *ic, int64_t old_offset)
1831 /* get the file size, if possible */
1832 if (ic->iformat->flags & AVFMT_NOFILE) {
1835 file_size = url_fsize(ic->pb);
1839 ic->file_size = file_size;
1841 if ((!strcmp(ic->iformat->name, "mpeg") ||
1842 !strcmp(ic->iformat->name, "mpegts")) &&
1843 file_size && !url_is_streamed(ic->pb)) {
1844 /* get accurate estimate from the PTSes */
1845 av_estimate_timings_from_pts(ic, old_offset);
1846 } else if (av_has_duration(ic)) {
1847 /* at least one component has timings - we use them for all
1849 fill_all_stream_timings(ic);
1851 /* less precise: use bitrate info */
1852 av_estimate_timings_from_bit_rate(ic);
1854 av_update_stream_timings(ic);
1860 for(i = 0;i < ic->nb_streams; i++) {
1861 st = ic->streams[i];
1862 printf("%d: start_time: %0.3f duration: %0.3f\n",
1863 i, (double)st->start_time / AV_TIME_BASE,
1864 (double)st->duration / AV_TIME_BASE);
1866 printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1867 (double)ic->start_time / AV_TIME_BASE,
1868 (double)ic->duration / AV_TIME_BASE,
1869 ic->bit_rate / 1000);
1874 static int has_codec_parameters(AVCodecContext *enc)
1877 switch(enc->codec_type) {
1878 case CODEC_TYPE_AUDIO:
1879 val = enc->sample_rate && enc->channels && enc->sample_fmt != SAMPLE_FMT_NONE;
1880 if(!enc->frame_size &&
1881 (enc->codec_id == CODEC_ID_VORBIS ||
1882 enc->codec_id == CODEC_ID_AAC))
1885 case CODEC_TYPE_VIDEO:
1886 val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
1892 return enc->codec_id != CODEC_ID_NONE && val != 0;
1895 static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1899 int got_picture, data_size, ret=0;
1902 if(!st->codec->codec){
1903 codec = avcodec_find_decoder(st->codec->codec_id);
1906 ret = avcodec_open(st->codec, codec);
1911 if(!has_codec_parameters(st->codec)){
1912 switch(st->codec->codec_type) {
1913 case CODEC_TYPE_VIDEO:
1914 ret = avcodec_decode_video(st->codec, &picture,
1915 &got_picture, data, size);
1917 case CODEC_TYPE_AUDIO:
1918 data_size = FFMAX(size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
1919 samples = av_malloc(data_size);
1922 ret = avcodec_decode_audio2(st->codec, samples,
1923 &data_size, data, size);
1934 unsigned int codec_get_tag(const AVCodecTag *tags, int id)
1936 while (tags->id != CODEC_ID_NONE) {
1944 enum CodecID codec_get_id(const AVCodecTag *tags, unsigned int tag)
1947 for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
1948 if(tag == tags[i].tag)
1951 for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
1952 if( toupper((tag >> 0)&0xFF) == toupper((tags[i].tag >> 0)&0xFF)
1953 && toupper((tag >> 8)&0xFF) == toupper((tags[i].tag >> 8)&0xFF)
1954 && toupper((tag >>16)&0xFF) == toupper((tags[i].tag >>16)&0xFF)
1955 && toupper((tag >>24)&0xFF) == toupper((tags[i].tag >>24)&0xFF))
1958 return CODEC_ID_NONE;
1961 unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum CodecID id)
1964 for(i=0; tags && tags[i]; i++){
1965 int tag= codec_get_tag(tags[i], id);
1971 enum CodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
1974 for(i=0; tags && tags[i]; i++){
1975 enum CodecID id= codec_get_id(tags[i], tag);
1976 if(id!=CODEC_ID_NONE) return id;
1978 return CODEC_ID_NONE;
1981 static void compute_chapters_end(AVFormatContext *s)
1985 for (i=0; i+1<s->nb_chapters; i++)
1986 if (s->chapters[i]->end == AV_NOPTS_VALUE) {
1987 assert(s->chapters[i]->start <= s->chapters[i+1]->start);
1988 assert(!av_cmp_q(s->chapters[i]->time_base, s->chapters[i+1]->time_base));
1989 s->chapters[i]->end = s->chapters[i+1]->start;
1992 if (s->nb_chapters && s->chapters[i]->end == AV_NOPTS_VALUE) {
1993 assert(s->start_time != AV_NOPTS_VALUE);
1994 assert(s->duration > 0);
1995 s->chapters[i]->end = av_rescale_q(s->start_time + s->duration,
1997 s->chapters[i]->time_base);
2001 /* absolute maximum size we read until we abort */
2002 #define MAX_READ_SIZE 5000000
2004 #define MAX_STD_TIMEBASES (60*12+5)
2005 static int get_std_framerate(int i){
2006 if(i<60*12) return i*1001;
2007 else return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
2011 * Is the time base unreliable.
2012 * This is a heuristic to balance between quick acceptance of the values in
2013 * the headers vs. some extra checks.
2014 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2015 * MPEG-2 commonly misuses field repeat flags to store different framerates.
2016 * And there are "variable" fps files this needs to detect as well.
2018 static int tb_unreliable(AVCodecContext *c){
2019 if( c->time_base.den >= 101L*c->time_base.num
2020 || c->time_base.den < 5L*c->time_base.num
2021 /* || c->codec_tag == AV_RL32("DIVX")
2022 || c->codec_tag == AV_RL32("XVID")*/
2023 || c->codec_id == CODEC_ID_MPEG2VIDEO
2024 || c->codec_id == CODEC_ID_H264
2030 int av_find_stream_info(AVFormatContext *ic)
2032 int i, count, ret, read_size, j;
2034 AVPacket pkt1, *pkt;
2035 int64_t last_dts[MAX_STREAMS];
2036 int64_t duration_gcd[MAX_STREAMS]={0};
2037 int duration_count[MAX_STREAMS]={0};
2038 double (*duration_error)[MAX_STD_TIMEBASES];
2039 int64_t old_offset = url_ftell(ic->pb);
2040 int64_t codec_info_duration[MAX_STREAMS]={0};
2041 int codec_info_nb_frames[MAX_STREAMS]={0};
2043 duration_error = av_mallocz(MAX_STREAMS * sizeof(*duration_error));
2044 if (!duration_error) return AVERROR(ENOMEM);
2046 for(i=0;i<ic->nb_streams;i++) {
2047 st = ic->streams[i];
2048 if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2049 /* if(!st->time_base.num)
2051 if(!st->codec->time_base.num)
2052 st->codec->time_base= st->time_base;
2054 //only for the split stuff
2056 st->parser = av_parser_init(st->codec->codec_id);
2057 if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
2058 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2063 for(i=0;i<MAX_STREAMS;i++){
2064 last_dts[i]= AV_NOPTS_VALUE;
2070 if(url_interrupt_cb()){
2071 ret= AVERROR(EINTR);
2075 /* check if one codec still needs to be handled */
2076 for(i=0;i<ic->nb_streams;i++) {
2077 st = ic->streams[i];
2078 if (!has_codec_parameters(st->codec))
2080 /* variable fps and no guess at the real fps */
2081 if( tb_unreliable(st->codec)
2082 && duration_count[i]<20 && st->codec->codec_type == CODEC_TYPE_VIDEO)
2084 if(st->parser && st->parser->parser->split && !st->codec->extradata)
2086 if(st->first_dts == AV_NOPTS_VALUE)
2089 if (i == ic->nb_streams) {
2090 /* NOTE: if the format has no header, then we need to read
2091 some packets to get most of the streams, so we cannot
2093 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2094 /* if we found the info for all the codecs, we can stop */
2099 /* we did not get all the codec info, but we read too much data */
2100 if (read_size >= MAX_READ_SIZE) {
2105 /* NOTE: a new stream can be added there if no header in file
2106 (AVFMTCTX_NOHEADER) */
2107 ret = av_read_frame_internal(ic, &pkt1);
2108 if(ret == AVERROR(EAGAIN))
2112 ret = -1; /* we could not have all the codec parameters before EOF */
2113 for(i=0;i<ic->nb_streams;i++) {
2114 st = ic->streams[i];
2115 if (!has_codec_parameters(st->codec)){
2117 avcodec_string(buf, sizeof(buf), st->codec, 0);
2118 av_log(ic, AV_LOG_INFO, "Could not find codec parameters (%s)\n", buf);
2126 pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2127 if(av_dup_packet(pkt) < 0) {
2128 av_free(duration_error);
2129 return AVERROR(ENOMEM);
2132 read_size += pkt->size;
2134 st = ic->streams[pkt->stream_index];
2135 if(codec_info_nb_frames[st->index]>1)
2136 codec_info_duration[st->index] += pkt->duration;
2137 if (pkt->duration != 0)
2138 codec_info_nb_frames[st->index]++;
2141 int index= pkt->stream_index;
2142 int64_t last= last_dts[index];
2143 int64_t duration= pkt->dts - last;
2145 if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
2146 double dur= duration * av_q2d(st->time_base);
2148 // if(st->codec->codec_type == CODEC_TYPE_VIDEO)
2149 // av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
2150 if(duration_count[index] < 2)
2151 memset(duration_error[index], 0, sizeof(*duration_error));
2152 for(i=1; i<MAX_STD_TIMEBASES; i++){
2153 int framerate= get_std_framerate(i);
2154 int ticks= lrintf(dur*framerate/(1001*12));
2155 double error= dur - ticks*1001*12/(double)framerate;
2156 duration_error[index][i] += error*error;
2158 duration_count[index]++;
2159 // ignore the first 4 values, they might have some random jitter
2160 if (duration_count[index] > 3)
2161 duration_gcd[index] = av_gcd(duration_gcd[index], duration);
2163 if(last == AV_NOPTS_VALUE || duration_count[index]<=1)
2164 last_dts[pkt->stream_index]= pkt->dts;
2166 if(st->parser && st->parser->parser->split && !st->codec->extradata){
2167 int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2169 st->codec->extradata_size= i;
2170 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2171 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2172 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2176 /* if still no information, we try to open the codec and to
2177 decompress the frame. We try to avoid that in most cases as
2178 it takes longer and uses more memory. For MPEG-4, we need to
2179 decompress for QuickTime. */
2180 if (!has_codec_parameters(st->codec) /*&&
2181 (st->codec->codec_id == CODEC_ID_FLV1 ||
2182 st->codec->codec_id == CODEC_ID_H264 ||
2183 st->codec->codec_id == CODEC_ID_H263 ||
2184 st->codec->codec_id == CODEC_ID_H261 ||
2185 st->codec->codec_id == CODEC_ID_VORBIS ||
2186 st->codec->codec_id == CODEC_ID_MJPEG ||
2187 st->codec->codec_id == CODEC_ID_PNG ||
2188 st->codec->codec_id == CODEC_ID_PAM ||
2189 st->codec->codec_id == CODEC_ID_PGM ||
2190 st->codec->codec_id == CODEC_ID_PGMYUV ||
2191 st->codec->codec_id == CODEC_ID_PBM ||
2192 st->codec->codec_id == CODEC_ID_PPM ||
2193 st->codec->codec_id == CODEC_ID_SHORTEN ||
2194 (st->codec->codec_id == CODEC_ID_MPEG4 && !st->need_parsing))*/)
2195 try_decode_frame(st, pkt->data, pkt->size);
2197 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) {
2203 // close codecs which were opened in try_decode_frame()
2204 for(i=0;i<ic->nb_streams;i++) {
2205 st = ic->streams[i];
2206 if(st->codec->codec)
2207 avcodec_close(st->codec);
2209 for(i=0;i<ic->nb_streams;i++) {
2210 st = ic->streams[i];
2211 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2212 if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample)
2213 st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2215 // the check for tb_unreliable() is not completely correct, since this is not about handling
2216 // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2217 // ipmovie.c produces.
2218 if (tb_unreliable(st->codec) && duration_count[i] > 15 && duration_gcd[i] > 1)
2219 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);
2220 if(duration_count[i]
2221 && tb_unreliable(st->codec) /*&&
2222 //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2223 st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den*/){
2225 double best_error= 2*av_q2d(st->time_base);
2226 best_error= best_error*best_error*duration_count[i]*1000*12*30;
2228 for(j=1; j<MAX_STD_TIMEBASES; j++){
2229 double error= duration_error[i][j] * get_std_framerate(j);
2230 // if(st->codec->codec_type == CODEC_TYPE_VIDEO)
2231 // av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
2232 if(error < best_error){
2234 num = get_std_framerate(j);
2237 // do not increase frame rate by more than 1 % in order to match a standard rate.
2238 if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
2239 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2242 if (!st->r_frame_rate.num){
2243 if( st->codec->time_base.den * (int64_t)st->time_base.num
2244 <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
2245 st->r_frame_rate.num = st->codec->time_base.den;
2246 st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
2248 st->r_frame_rate.num = st->time_base.den;
2249 st->r_frame_rate.den = st->time_base.num;
2252 }else if(st->codec->codec_type == CODEC_TYPE_AUDIO) {
2253 if(!st->codec->bits_per_coded_sample)
2254 st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2258 av_estimate_timings(ic, old_offset);
2260 compute_chapters_end(ic);
2263 /* correct DTS for B-frame streams with no timestamps */
2264 for(i=0;i<ic->nb_streams;i++) {
2265 st = ic->streams[i];
2266 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2268 ppktl = &ic->packet_buffer;
2270 if(ppkt1->stream_index != i)
2272 if(ppkt1->pkt->dts < 0)
2274 if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2276 ppkt1->pkt->dts -= delta;
2281 st->cur_dts -= delta;
2287 av_free(duration_error);
2292 /*******************************************************/
2294 int av_read_play(AVFormatContext *s)
2296 if (s->iformat->read_play)
2297 return s->iformat->read_play(s);
2299 return av_url_read_fpause(s->pb, 0);
2300 return AVERROR(ENOSYS);
2303 int av_read_pause(AVFormatContext *s)
2305 if (s->iformat->read_pause)
2306 return s->iformat->read_pause(s);
2308 return av_url_read_fpause(s->pb, 1);
2309 return AVERROR(ENOSYS);
2312 void av_close_input_stream(AVFormatContext *s)
2317 if (s->iformat->read_close)
2318 s->iformat->read_close(s);
2319 for(i=0;i<s->nb_streams;i++) {
2320 /* free all data in a stream component */
2323 av_parser_close(st->parser);
2324 av_free_packet(&st->cur_pkt);
2326 av_metadata_free(&st->metadata);
2327 av_free(st->index_entries);
2328 av_free(st->codec->extradata);
2330 #if LIBAVFORMAT_VERSION_INT < (53<<16)
2331 av_free(st->filename);
2333 av_free(st->priv_data);
2336 for(i=s->nb_programs-1; i>=0; i--) {
2337 #if LIBAVFORMAT_VERSION_INT < (53<<16)
2338 av_freep(&s->programs[i]->provider_name);
2339 av_freep(&s->programs[i]->name);
2341 av_metadata_free(&s->programs[i]->metadata);
2342 av_freep(&s->programs[i]->stream_index);
2343 av_freep(&s->programs[i]);
2345 av_freep(&s->programs);
2346 flush_packet_queue(s);
2347 av_freep(&s->priv_data);
2348 while(s->nb_chapters--) {
2349 #if LIBAVFORMAT_VERSION_INT < (53<<16)
2350 av_free(s->chapters[s->nb_chapters]->title);
2352 av_metadata_free(&s->chapters[s->nb_chapters]->metadata);
2353 av_free(s->chapters[s->nb_chapters]);
2355 av_freep(&s->chapters);
2356 av_metadata_free(&s->metadata);
2360 void av_close_input_file(AVFormatContext *s)
2362 ByteIOContext *pb = s->iformat->flags & AVFMT_NOFILE ? NULL : s->pb;
2363 av_close_input_stream(s);
2368 AVStream *av_new_stream(AVFormatContext *s, int id)
2373 if (s->nb_streams >= MAX_STREAMS)
2376 st = av_mallocz(sizeof(AVStream));
2380 st->codec= avcodec_alloc_context();
2382 /* no default bitrate if decoding */
2383 st->codec->bit_rate = 0;
2385 st->index = s->nb_streams;
2387 st->start_time = AV_NOPTS_VALUE;
2388 st->duration = AV_NOPTS_VALUE;
2389 /* we set the current DTS to 0 so that formats without any timestamps
2390 but durations get some timestamps, formats with some unknown
2391 timestamps have their first few packets buffered and the
2392 timestamps corrected before they are returned to the user */
2394 st->first_dts = AV_NOPTS_VALUE;
2396 /* default pts setting is MPEG-like */
2397 av_set_pts_info(st, 33, 1, 90000);
2398 st->last_IP_pts = AV_NOPTS_VALUE;
2399 for(i=0; i<MAX_REORDER_DELAY+1; i++)
2400 st->pts_buffer[i]= AV_NOPTS_VALUE;
2401 st->reference_dts = AV_NOPTS_VALUE;
2403 st->sample_aspect_ratio = (AVRational){0,1};
2405 s->streams[s->nb_streams++] = st;
2409 AVProgram *av_new_program(AVFormatContext *ac, int id)
2411 AVProgram *program=NULL;
2415 av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2418 for(i=0; i<ac->nb_programs; i++)
2419 if(ac->programs[i]->id == id)
2420 program = ac->programs[i];
2423 program = av_mallocz(sizeof(AVProgram));
2426 dynarray_add(&ac->programs, &ac->nb_programs, program);
2427 program->discard = AVDISCARD_NONE;
2434 AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2436 AVChapter *chapter = NULL;
2439 for(i=0; i<s->nb_chapters; i++)
2440 if(s->chapters[i]->id == id)
2441 chapter = s->chapters[i];
2444 chapter= av_mallocz(sizeof(AVChapter));
2447 dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2449 #if LIBAVFORMAT_VERSION_INT < (53<<16)
2450 av_free(chapter->title);
2452 av_metadata_set(&chapter->metadata, "title", title);
2454 chapter->time_base= time_base;
2455 chapter->start = start;
2461 /************************************************************/
2462 /* output media file */
2464 int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2468 if (s->oformat->priv_data_size > 0) {
2469 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2471 return AVERROR(ENOMEM);
2473 s->priv_data = NULL;
2475 if (s->oformat->set_parameters) {
2476 ret = s->oformat->set_parameters(s, ap);
2483 int av_write_header(AVFormatContext *s)
2488 // some sanity checks
2489 for(i=0;i<s->nb_streams;i++) {
2492 switch (st->codec->codec_type) {
2493 case CODEC_TYPE_AUDIO:
2494 if(st->codec->sample_rate<=0){
2495 av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2498 if(!st->codec->block_align)
2499 st->codec->block_align = st->codec->channels *
2500 av_get_bits_per_sample(st->codec->codec_id) >> 3;
2502 case CODEC_TYPE_VIDEO:
2503 if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2504 av_log(s, AV_LOG_ERROR, "time base not set\n");
2507 if(st->codec->width<=0 || st->codec->height<=0){
2508 av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2511 if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)){
2512 av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between encoder and muxer layer\n");
2518 if(s->oformat->codec_tag){
2519 if(st->codec->codec_tag){
2521 //check that tag + id is in the table
2522 //if neither is in the table -> OK
2523 //if tag is in the table with another id -> FAIL
2524 //if id is in the table with another tag -> FAIL unless strict < ?
2526 st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2529 if(s->oformat->flags & AVFMT_GLOBALHEADER &&
2530 !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
2531 av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
2534 if (!s->priv_data && s->oformat->priv_data_size > 0) {
2535 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2537 return AVERROR(ENOMEM);
2540 #if LIBAVFORMAT_VERSION_MAJOR < 53
2541 ff_metadata_mux_compat(s);
2544 if(s->oformat->write_header){
2545 ret = s->oformat->write_header(s);
2550 /* init PTS generation */
2551 for(i=0;i<s->nb_streams;i++) {
2552 int64_t den = AV_NOPTS_VALUE;
2555 switch (st->codec->codec_type) {
2556 case CODEC_TYPE_AUDIO:
2557 den = (int64_t)st->time_base.num * st->codec->sample_rate;
2559 case CODEC_TYPE_VIDEO:
2560 den = (int64_t)st->time_base.num * st->codec->time_base.den;
2565 if (den != AV_NOPTS_VALUE) {
2567 return AVERROR_INVALIDDATA;
2568 av_frac_init(&st->pts, 0, 0, den);
2574 //FIXME merge with compute_pkt_fields
2575 static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
2576 int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2577 int num, den, frame_size, i;
2579 // 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);
2581 /* if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2584 /* duration field */
2585 if (pkt->duration == 0) {
2586 compute_frame_duration(&num, &den, st, NULL, pkt);
2588 pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
2592 if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
2595 //XXX/FIXME this is a temporary hack until all encoders output pts
2596 if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2598 // pkt->pts= st->cur_dts;
2599 pkt->pts= st->pts.val;
2602 //calculate dts from pts
2603 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
2604 st->pts_buffer[0]= pkt->pts;
2605 for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2606 st->pts_buffer[i]= (i-delay-1) * pkt->duration;
2607 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2608 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2610 pkt->dts= st->pts_buffer[0];
2613 if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2614 av_log(st->codec, AV_LOG_ERROR, "error, non monotone timestamps %"PRId64" >= %"PRId64"\n", st->cur_dts, pkt->dts);
2617 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2618 av_log(st->codec, AV_LOG_ERROR, "error, pts < dts\n");
2622 // av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2623 st->cur_dts= pkt->dts;
2624 st->pts.val= pkt->dts;
2627 switch (st->codec->codec_type) {
2628 case CODEC_TYPE_AUDIO:
2629 frame_size = get_audio_frame_size(st->codec, pkt->size);
2631 /* HACK/FIXME, we skip the initial 0 size packets as they are most
2632 likely equal to the encoder delay, but it would be better if we
2633 had the real timestamps from the encoder */
2634 if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2635 av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2638 case CODEC_TYPE_VIDEO:
2639 av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2647 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2649 int ret = compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2651 if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2654 ret= s->oformat->write_packet(s, pkt);
2656 ret= url_ferror(s->pb);
2660 void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
2661 int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
2663 AVPacketList **next_point, *this_pktl;
2665 this_pktl = av_mallocz(sizeof(AVPacketList));
2666 this_pktl->pkt= *pkt;
2667 if(pkt->destruct == av_destruct_packet)
2668 pkt->destruct= NULL; // not shared -> must keep original from being freed
2670 av_dup_packet(&this_pktl->pkt); //shared -> must dup
2672 next_point = &s->packet_buffer;
2674 if(compare(s, &(*next_point)->pkt, pkt))
2676 next_point= &(*next_point)->next;
2678 this_pktl->next= *next_point;
2679 *next_point= this_pktl;
2682 int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
2684 AVStream *st = s->streams[ pkt ->stream_index];
2685 AVStream *st2= s->streams[ next->stream_index];
2686 int64_t left = st2->time_base.num * (int64_t)st ->time_base.den;
2687 int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2689 if (pkt->dts == AV_NOPTS_VALUE)
2692 return next->dts * left > pkt->dts * right; //FIXME this can overflow
2695 int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2698 int streams[MAX_STREAMS];
2701 ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
2704 memset(streams, 0, sizeof(streams));
2705 pktl= s->packet_buffer;
2707 //av_log(s, AV_LOG_DEBUG, "show st:%d dts:%"PRId64"\n", pktl->pkt.stream_index, pktl->pkt.dts);
2708 if(streams[ pktl->pkt.stream_index ] == 0)
2710 streams[ pktl->pkt.stream_index ]++;
2714 if(stream_count && (s->nb_streams == stream_count || flush)){
2715 pktl= s->packet_buffer;
2718 s->packet_buffer= pktl->next;
2722 av_init_packet(out);
2728 * Interleaves an AVPacket correctly so it can be muxed.
2729 * @param out the interleaved packet will be output here
2730 * @param in the input packet
2731 * @param flush 1 if no further packets are available as input and all
2732 * remaining packets should be output
2733 * @return 1 if a packet was output, 0 if no packet could be output,
2734 * < 0 if an error occurred
2736 static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2737 if(s->oformat->interleave_packet)
2738 return s->oformat->interleave_packet(s, out, in, flush);
2740 return av_interleave_packet_per_dts(s, out, in, flush);
2743 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2744 AVStream *st= s->streams[ pkt->stream_index];
2746 //FIXME/XXX/HACK drop zero sized packets
2747 if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2750 //av_log(NULL, AV_LOG_DEBUG, "av_interleaved_write_frame %d %"PRId64" %"PRId64"\n", pkt->size, pkt->dts, pkt->pts);
2751 if(compute_pkt_fields2(st, pkt) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2754 if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2759 int ret= av_interleave_packet(s, &opkt, pkt, 0);
2760 if(ret<=0) //FIXME cleanup needed for ret<0 ?
2763 ret= s->oformat->write_packet(s, &opkt);
2765 av_free_packet(&opkt);
2770 if(url_ferror(s->pb))
2771 return url_ferror(s->pb);
2775 int av_write_trailer(AVFormatContext *s)
2781 ret= av_interleave_packet(s, &pkt, NULL, 1);
2782 if(ret<0) //FIXME cleanup needed for ret<0 ?
2787 ret= s->oformat->write_packet(s, &pkt);
2789 av_free_packet(&pkt);
2793 if(url_ferror(s->pb))
2797 if(s->oformat->write_trailer)
2798 ret = s->oformat->write_trailer(s);
2801 ret=url_ferror(s->pb);
2802 for(i=0;i<s->nb_streams;i++)
2803 av_freep(&s->streams[i]->priv_data);
2804 av_freep(&s->priv_data);
2808 void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
2811 AVProgram *program=NULL;
2814 for(i=0; i<ac->nb_programs; i++){
2815 if(ac->programs[i]->id != progid)
2817 program = ac->programs[i];
2818 for(j=0; j<program->nb_stream_indexes; j++)
2819 if(program->stream_index[j] == idx)
2822 tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
2825 program->stream_index = tmp;
2826 program->stream_index[program->nb_stream_indexes++] = idx;
2831 static void print_fps(double d, const char *postfix){
2832 uint64_t v= lrintf(d*100);
2833 if (v% 100 ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
2834 else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
2835 else av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
2838 /* "user interface" functions */
2839 static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
2842 int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
2843 AVStream *st = ic->streams[i];
2844 int g = av_gcd(st->time_base.num, st->time_base.den);
2845 AVMetadataTag *lang = av_metadata_get(st->metadata, "language", NULL, 0);
2846 avcodec_string(buf, sizeof(buf), st->codec, is_output);
2847 av_log(NULL, AV_LOG_INFO, " Stream #%d.%d", index, i);
2848 /* the pid is an important information, so we display it */
2849 /* XXX: add a generic system */
2850 if (flags & AVFMT_SHOW_IDS)
2851 av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
2853 av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
2854 av_log(NULL, AV_LOG_DEBUG, ", %d/%d", st->time_base.num/g, st->time_base.den/g);
2855 av_log(NULL, AV_LOG_INFO, ": %s", buf);
2856 if (st->sample_aspect_ratio.num && // default
2857 av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
2858 AVRational display_aspect_ratio;
2859 av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
2860 st->codec->width*st->sample_aspect_ratio.num,
2861 st->codec->height*st->sample_aspect_ratio.den,
2863 av_log(NULL, AV_LOG_INFO, ", PAR %d:%d DAR %d:%d",
2864 st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
2865 display_aspect_ratio.num, display_aspect_ratio.den);
2867 if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2868 if(st->r_frame_rate.den && st->r_frame_rate.num)
2869 print_fps(av_q2d(st->r_frame_rate), "tbr");
2870 if(st->time_base.den && st->time_base.num)
2871 print_fps(1/av_q2d(st->time_base), "tbn");
2872 if(st->codec->time_base.den && st->codec->time_base.num)
2873 print_fps(1/av_q2d(st->codec->time_base), "tbc");
2875 av_log(NULL, AV_LOG_INFO, "\n");
2878 void dump_format(AVFormatContext *ic,
2885 av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
2886 is_output ? "Output" : "Input",
2888 is_output ? ic->oformat->name : ic->iformat->name,
2889 is_output ? "to" : "from", url);
2891 av_log(NULL, AV_LOG_INFO, " Duration: ");
2892 if (ic->duration != AV_NOPTS_VALUE) {
2893 int hours, mins, secs, us;
2894 secs = ic->duration / AV_TIME_BASE;
2895 us = ic->duration % AV_TIME_BASE;
2900 av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
2901 (100 * us) / AV_TIME_BASE);
2903 av_log(NULL, AV_LOG_INFO, "N/A");
2905 if (ic->start_time != AV_NOPTS_VALUE) {
2907 av_log(NULL, AV_LOG_INFO, ", start: ");
2908 secs = ic->start_time / AV_TIME_BASE;
2909 us = ic->start_time % AV_TIME_BASE;
2910 av_log(NULL, AV_LOG_INFO, "%d.%06d",
2911 secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
2913 av_log(NULL, AV_LOG_INFO, ", bitrate: ");
2915 av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
2917 av_log(NULL, AV_LOG_INFO, "N/A");
2919 av_log(NULL, AV_LOG_INFO, "\n");
2921 if(ic->nb_programs) {
2923 for(j=0; j<ic->nb_programs; j++) {
2924 AVMetadataTag *name = av_metadata_get(ic->programs[j]->metadata,
2926 av_log(NULL, AV_LOG_INFO, " Program %d %s\n", ic->programs[j]->id,
2927 name ? name->value : "");
2928 for(k=0; k<ic->programs[j]->nb_stream_indexes; k++)
2929 dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
2932 for(i=0;i<ic->nb_streams;i++)
2933 dump_stream_format(ic, i, index, is_output);
2936 #if LIBAVFORMAT_VERSION_MAJOR < 53
2937 int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2939 return av_parse_video_frame_size(width_ptr, height_ptr, str);
2942 int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
2944 AVRational frame_rate;
2945 int ret = av_parse_video_frame_rate(&frame_rate, arg);
2946 *frame_rate_num= frame_rate.num;
2947 *frame_rate_den= frame_rate.den;
2952 int64_t av_gettime(void)
2955 gettimeofday(&tv,NULL);
2956 return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
2959 int64_t parse_date(const char *datestr, int duration)
2965 static const char * const date_fmt[] = {
2969 static const char * const time_fmt[] = {
2979 time_t now = time(0);
2981 len = strlen(datestr);
2983 lastch = datestr[len - 1];
2986 is_utc = (lastch == 'z' || lastch == 'Z');
2988 memset(&dt, 0, sizeof(dt));
2993 if (!strncasecmp(datestr, "now", len))
2994 return (int64_t) now * 1000000;
2996 /* parse the year-month-day part */
2997 for (i = 0; i < FF_ARRAY_ELEMS(date_fmt); i++) {
2998 q = small_strptime(p, date_fmt[i], &dt);
3004 /* if the year-month-day part is missing, then take the
3005 * current year-month-day time */
3010 dt = *localtime(&now);
3012 dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
3017 if (*p == 'T' || *p == 't' || *p == ' ')
3020 /* parse the hour-minute-second part */
3021 for (i = 0; i < FF_ARRAY_ELEMS(time_fmt); i++) {
3022 q = small_strptime(p, time_fmt[i], &dt);
3028 /* parse datestr as a duration */
3033 /* parse datestr as HH:MM:SS */
3034 q = small_strptime(p, time_fmt[0], &dt);
3036 /* parse datestr as S+ */
3037 dt.tm_sec = strtol(p, (char **)&q, 10);
3039 /* the parsing didn't succeed */
3046 /* Now we have all the fields that we can get */
3052 t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
3054 dt.tm_isdst = -1; /* unknown */
3064 /* parse the .m... part */
3068 for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
3071 val += n * (*q - '0');
3075 return negative ? -t : t;
3078 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
3088 while (*p != '\0' && *p != '=' && *p != '&') {
3089 if ((q - tag) < sizeof(tag) - 1)
3097 while (*p != '&' && *p != '\0') {
3098 if ((q - arg) < arg_size - 1) {
3108 if (!strcmp(tag, tag1))
3117 int av_get_frame_filename(char *buf, int buf_size,
3118 const char *path, int number)
3121 char *q, buf1[20], c;
3122 int nd, len, percentd_found;
3134 while (isdigit(*p)) {
3135 nd = nd * 10 + *p++ - '0';
3138 } while (isdigit(c));
3147 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3149 if ((q - buf + len) > buf_size - 1)
3151 memcpy(q, buf1, len);
3159 if ((q - buf) < buf_size - 1)
3163 if (!percentd_found)
3172 static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3175 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3177 for(i=0;i<size;i+=16) {
3184 PRINT(" %02x", buf[i+j]);
3189 for(j=0;j<len;j++) {
3191 if (c < ' ' || c > '~')
3200 void av_hex_dump(FILE *f, uint8_t *buf, int size)
3202 hex_dump_internal(NULL, f, 0, buf, size);
3205 void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3207 hex_dump_internal(avcl, NULL, level, buf, size);
3210 //FIXME needs to know the time_base
3211 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload)
3213 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3214 PRINT("stream #%d:\n", pkt->stream_index);
3215 PRINT(" keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
3216 PRINT(" duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
3217 /* DTS is _always_ valid after av_read_frame() */
3219 if (pkt->dts == AV_NOPTS_VALUE)
3222 PRINT("%0.3f", (double)pkt->dts / AV_TIME_BASE);
3223 /* PTS may not be known if B-frames are present. */
3225 if (pkt->pts == AV_NOPTS_VALUE)
3228 PRINT("%0.3f", (double)pkt->pts / AV_TIME_BASE);
3230 PRINT(" size=%d\n", pkt->size);
3233 av_hex_dump(f, pkt->data, pkt->size);
3236 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3238 pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
3241 void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3243 pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
3246 void url_split(char *proto, int proto_size,
3247 char *authorization, int authorization_size,
3248 char *hostname, int hostname_size,
3250 char *path, int path_size,
3253 const char *p, *ls, *at, *col, *brk;
3255 if (port_ptr) *port_ptr = -1;
3256 if (proto_size > 0) proto[0] = 0;
3257 if (authorization_size > 0) authorization[0] = 0;
3258 if (hostname_size > 0) hostname[0] = 0;
3259 if (path_size > 0) path[0] = 0;
3261 /* parse protocol */
3262 if ((p = strchr(url, ':'))) {
3263 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3268 /* no protocol means plain filename */
3269 av_strlcpy(path, url, path_size);
3273 /* separate path from hostname */
3274 ls = strchr(p, '/');
3276 ls = strchr(p, '?');
3278 av_strlcpy(path, ls, path_size);
3280 ls = &p[strlen(p)]; // XXX
3282 /* the rest is hostname, use that to parse auth/port */
3284 /* authorization (user[:pass]@hostname) */
3285 if ((at = strchr(p, '@')) && at < ls) {
3286 av_strlcpy(authorization, p,
3287 FFMIN(authorization_size, at + 1 - p));
3288 p = at + 1; /* skip '@' */
3291 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3293 av_strlcpy(hostname, p + 1,
3294 FFMIN(hostname_size, brk - p));
3295 if (brk[1] == ':' && port_ptr)
3296 *port_ptr = atoi(brk + 2);
3297 } else if ((col = strchr(p, ':')) && col < ls) {
3298 av_strlcpy(hostname, p,
3299 FFMIN(col + 1 - p, hostname_size));
3300 if (port_ptr) *port_ptr = atoi(col + 1);
3302 av_strlcpy(hostname, p,
3303 FFMIN(ls + 1 - p, hostname_size));
3307 char *ff_data_to_hex(char *buff, const uint8_t *src, int s)
3310 static const char hex_table[16] = { '0', '1', '2', '3',
3313 'C', 'D', 'E', 'F' };
3315 for(i = 0; i < s; i++) {
3316 buff[i * 2] = hex_table[src[i] >> 4];
3317 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3323 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3324 int pts_num, int pts_den)
3326 unsigned int gcd= av_gcd(pts_num, pts_den);
3327 s->pts_wrap_bits = pts_wrap_bits;
3328 s->time_base.num = pts_num/gcd;
3329 s->time_base.den = pts_den/gcd;
3332 av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, gcd);