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_ERROR, "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->pict_type == FF_I_TYPE)
908 pkt->flags |= PKT_FLAG_KEY;
912 void av_destruct_packet_nofree(AVPacket *pkt)
914 pkt->data = NULL; pkt->size = 0;
917 static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
925 /* select current input stream component */
928 if (!st->need_parsing || !st->parser) {
929 /* no parsing needed: we just output the packet as is */
930 /* raw data support */
931 *pkt = st->cur_pkt; st->cur_pkt.data= NULL;
932 compute_pkt_fields(s, st, NULL, pkt);
935 } else if (st->cur_len > 0 && st->discard < AVDISCARD_ALL) {
936 len = av_parser_parse(st->parser, st->codec, &pkt->data, &pkt->size,
937 st->cur_ptr, st->cur_len,
938 st->cur_pkt.pts, st->cur_pkt.dts);
939 st->cur_pkt.pts = AV_NOPTS_VALUE;
940 st->cur_pkt.dts = AV_NOPTS_VALUE;
941 /* increment read pointer */
945 /* return packet if any */
947 pkt->pos = st->cur_pkt.pos; // Isn't quite accurate but close.
950 pkt->stream_index = st->index;
951 pkt->pts = st->parser->pts;
952 pkt->dts = st->parser->dts;
953 pkt->destruct = av_destruct_packet_nofree;
954 compute_pkt_fields(s, st, st->parser, pkt);
956 if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & PKT_FLAG_KEY){
957 ff_reduce_index(s, st->index);
958 av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
959 0, 0, AVINDEX_KEYFRAME);
966 av_free_packet(&st->cur_pkt);
971 /* read next packet */
972 ret = av_read_packet(s, &cur_pkt);
974 if (ret == AVERROR(EAGAIN))
976 /* return the last frames, if any */
977 for(i = 0; i < s->nb_streams; i++) {
979 if (st->parser && st->need_parsing) {
980 av_parser_parse(st->parser, st->codec,
981 &pkt->data, &pkt->size,
983 AV_NOPTS_VALUE, AV_NOPTS_VALUE);
988 /* no more packets: really terminate parsing */
991 st = s->streams[cur_pkt.stream_index];
992 st->cur_pkt= cur_pkt;
994 if(st->cur_pkt.pts != AV_NOPTS_VALUE &&
995 st->cur_pkt.dts != AV_NOPTS_VALUE &&
996 st->cur_pkt.pts < st->cur_pkt.dts){
997 av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
998 st->cur_pkt.stream_index,
1002 // av_free_packet(&st->cur_pkt);
1006 if(s->debug & FF_FDEBUG_TS)
1007 av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, flags=%d\n",
1008 st->cur_pkt.stream_index,
1015 st->cur_ptr = st->cur_pkt.data;
1016 st->cur_len = st->cur_pkt.size;
1017 if (st->need_parsing && !st->parser) {
1018 st->parser = av_parser_init(st->codec->codec_id);
1020 /* no parser available: just output the raw packets */
1021 st->need_parsing = AVSTREAM_PARSE_NONE;
1022 }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
1023 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1025 if(st->parser && (s->iformat->flags & AVFMT_GENERIC_INDEX)){
1026 st->parser->next_frame_offset=
1027 st->parser->cur_offset= st->cur_pkt.pos;
1032 if(s->debug & FF_FDEBUG_TS)
1033 av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, flags=%d\n",
1043 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1047 const int genpts= s->flags & AVFMT_FLAG_GENPTS;
1050 pktl = s->packet_buffer;
1052 AVPacket *next_pkt= &pktl->pkt;
1054 if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
1055 while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
1056 if( pktl->pkt.stream_index == next_pkt->stream_index
1057 && next_pkt->dts < pktl->pkt.dts
1058 && pktl->pkt.pts != pktl->pkt.dts //not b frame
1059 /*&& pktl->pkt.dts != AV_NOPTS_VALUE*/){
1060 next_pkt->pts= pktl->pkt.dts;
1064 pktl = s->packet_buffer;
1067 if( next_pkt->pts != AV_NOPTS_VALUE
1068 || next_pkt->dts == AV_NOPTS_VALUE
1070 /* read packet from packet buffer, if there is data */
1072 s->packet_buffer = pktl->next;
1078 int ret= av_read_frame_internal(s, pkt);
1080 if(pktl && ret != AVERROR(EAGAIN)){
1087 if(av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1088 &s->packet_buffer_end)) < 0)
1089 return AVERROR(ENOMEM);
1091 assert(!s->packet_buffer);
1092 return av_read_frame_internal(s, pkt);
1097 /* XXX: suppress the packet queue */
1098 static void flush_packet_queue(AVFormatContext *s)
1103 pktl = s->packet_buffer;
1106 s->packet_buffer = pktl->next;
1107 av_free_packet(&pktl->pkt);
1112 /*******************************************************/
1115 int av_find_default_stream_index(AVFormatContext *s)
1117 int first_audio_index = -1;
1121 if (s->nb_streams <= 0)
1123 for(i = 0; i < s->nb_streams; i++) {
1125 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1128 if (first_audio_index < 0 && st->codec->codec_type == CODEC_TYPE_AUDIO)
1129 first_audio_index = i;
1131 return first_audio_index >= 0 ? first_audio_index : 0;
1135 * Flush the frame reader.
1137 static void av_read_frame_flush(AVFormatContext *s)
1142 flush_packet_queue(s);
1146 /* for each stream, reset read state */
1147 for(i = 0; i < s->nb_streams; i++) {
1151 av_parser_close(st->parser);
1153 av_free_packet(&st->cur_pkt);
1155 st->last_IP_pts = AV_NOPTS_VALUE;
1156 st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1163 void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1166 for(i = 0; i < s->nb_streams; i++) {
1167 AVStream *st = s->streams[i];
1169 st->cur_dts = av_rescale(timestamp,
1170 st->time_base.den * (int64_t)ref_st->time_base.num,
1171 st->time_base.num * (int64_t)ref_st->time_base.den);
1175 void ff_reduce_index(AVFormatContext *s, int stream_index)
1177 AVStream *st= s->streams[stream_index];
1178 unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1180 if((unsigned)st->nb_index_entries >= max_entries){
1182 for(i=0; 2*i<st->nb_index_entries; i++)
1183 st->index_entries[i]= st->index_entries[2*i];
1184 st->nb_index_entries= i;
1188 int av_add_index_entry(AVStream *st,
1189 int64_t pos, int64_t timestamp, int size, int distance, int flags)
1191 AVIndexEntry *entries, *ie;
1194 if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1197 entries = av_fast_realloc(st->index_entries,
1198 &st->index_entries_allocated_size,
1199 (st->nb_index_entries + 1) *
1200 sizeof(AVIndexEntry));
1204 st->index_entries= entries;
1206 index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
1209 index= st->nb_index_entries++;
1210 ie= &entries[index];
1211 assert(index==0 || ie[-1].timestamp < timestamp);
1213 ie= &entries[index];
1214 if(ie->timestamp != timestamp){
1215 if(ie->timestamp <= timestamp)
1217 memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
1218 st->nb_index_entries++;
1219 }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1220 distance= ie->min_distance;
1224 ie->timestamp = timestamp;
1225 ie->min_distance= distance;
1232 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1235 AVIndexEntry *entries= st->index_entries;
1236 int nb_entries= st->nb_index_entries;
1245 timestamp = entries[m].timestamp;
1246 if(timestamp >= wanted_timestamp)
1248 if(timestamp <= wanted_timestamp)
1251 m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1253 if(!(flags & AVSEEK_FLAG_ANY)){
1254 while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1255 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1266 int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1267 AVInputFormat *avif= s->iformat;
1268 int64_t pos_min, pos_max, pos, pos_limit;
1269 int64_t ts_min, ts_max, ts;
1273 if (stream_index < 0)
1277 av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1281 ts_min= AV_NOPTS_VALUE;
1282 pos_limit= -1; //gcc falsely says it may be uninitialized
1284 st= s->streams[stream_index];
1285 if(st->index_entries){
1288 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()
1289 index= FFMAX(index, 0);
1290 e= &st->index_entries[index];
1292 if(e->timestamp <= target_ts || e->pos == e->min_distance){
1294 ts_min= e->timestamp;
1296 av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1303 index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1304 assert(index < st->nb_index_entries);
1306 e= &st->index_entries[index];
1307 assert(e->timestamp >= target_ts);
1309 ts_max= e->timestamp;
1310 pos_limit= pos_max - e->min_distance;
1312 av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1313 pos_max,pos_limit, ts_max);
1318 pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1323 url_fseek(s->pb, pos, SEEK_SET);
1325 av_update_cur_dts(s, st, ts);
1330 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 )){
1332 int64_t start_pos, filesize;
1336 av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1339 if(ts_min == AV_NOPTS_VALUE){
1340 pos_min = s->data_offset;
1341 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1342 if (ts_min == AV_NOPTS_VALUE)
1346 if(ts_max == AV_NOPTS_VALUE){
1348 filesize = url_fsize(s->pb);
1349 pos_max = filesize - 1;
1352 ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1354 }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1355 if (ts_max == AV_NOPTS_VALUE)
1359 int64_t tmp_pos= pos_max + 1;
1360 int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1361 if(tmp_ts == AV_NOPTS_VALUE)
1365 if(tmp_pos >= filesize)
1371 if(ts_min > ts_max){
1373 }else if(ts_min == ts_max){
1378 while (pos_min < pos_limit) {
1380 av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1384 assert(pos_limit <= pos_max);
1387 int64_t approximate_keyframe_distance= pos_max - pos_limit;
1388 // interpolate position (better than dichotomy)
1389 pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1390 + pos_min - approximate_keyframe_distance;
1391 }else if(no_change==1){
1392 // bisection, if interpolation failed to change min or max pos last time
1393 pos = (pos_min + pos_limit)>>1;
1395 /* linear search if bisection failed, can only happen if there
1396 are very few or no keyframes between min/max */
1401 else if(pos > pos_limit)
1405 ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1411 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);
1413 if(ts == AV_NOPTS_VALUE){
1414 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1417 assert(ts != AV_NOPTS_VALUE);
1418 if (target_ts <= ts) {
1419 pos_limit = start_pos - 1;
1423 if (target_ts >= ts) {
1429 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1430 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
1433 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1435 ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1436 av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1437 pos, ts_min, target_ts, ts_max);
1443 static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1444 int64_t pos_min, pos_max;
1448 if (stream_index < 0)
1451 st= s->streams[stream_index];
1454 pos_min = s->data_offset;
1455 pos_max = url_fsize(s->pb) - 1;
1457 if (pos < pos_min) pos= pos_min;
1458 else if(pos > pos_max) pos= pos_max;
1460 url_fseek(s->pb, pos, SEEK_SET);
1463 av_update_cur_dts(s, st, ts);
1468 static int av_seek_frame_generic(AVFormatContext *s,
1469 int stream_index, int64_t timestamp, int flags)
1475 st = s->streams[stream_index];
1477 index = av_index_search_timestamp(st, timestamp, flags);
1479 if(index < 0 || index==st->nb_index_entries-1){
1483 if(st->nb_index_entries){
1484 assert(st->index_entries);
1485 ie= &st->index_entries[st->nb_index_entries-1];
1486 if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
1488 av_update_cur_dts(s, st, ie->timestamp);
1490 if ((ret = url_fseek(s->pb, 0, SEEK_SET)) < 0)
1496 ret = av_read_frame(s, &pkt);
1497 }while(ret == AVERROR(EAGAIN));
1500 av_free_packet(&pkt);
1501 if(stream_index == pkt.stream_index){
1502 if((pkt.flags & PKT_FLAG_KEY) && pkt.dts > timestamp)
1506 index = av_index_search_timestamp(st, timestamp, flags);
1511 av_read_frame_flush(s);
1512 if (s->iformat->read_seek){
1513 if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1516 ie = &st->index_entries[index];
1517 if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
1519 av_update_cur_dts(s, st, ie->timestamp);
1524 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1529 av_read_frame_flush(s);
1531 if(flags & AVSEEK_FLAG_BYTE)
1532 return av_seek_frame_byte(s, stream_index, timestamp, flags);
1534 if(stream_index < 0){
1535 stream_index= av_find_default_stream_index(s);
1536 if(stream_index < 0)
1539 st= s->streams[stream_index];
1540 /* timestamp for default must be expressed in AV_TIME_BASE units */
1541 timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1544 /* first, we try the format specific seek */
1545 if (s->iformat->read_seek)
1546 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1553 if(s->iformat->read_timestamp)
1554 return av_seek_frame_binary(s, stream_index, timestamp, flags);
1556 return av_seek_frame_generic(s, stream_index, timestamp, flags);
1559 /*******************************************************/
1562 * Returns TRUE if the stream has accurate duration in any stream.
1564 * @return TRUE if the stream has accurate duration for at least one component.
1566 static int av_has_duration(AVFormatContext *ic)
1571 for(i = 0;i < ic->nb_streams; i++) {
1572 st = ic->streams[i];
1573 if (st->duration != AV_NOPTS_VALUE)
1580 * Estimate the stream timings from the one of each components.
1582 * Also computes the global bitrate if possible.
1584 static void av_update_stream_timings(AVFormatContext *ic)
1586 int64_t start_time, start_time1, end_time, end_time1;
1587 int64_t duration, duration1;
1591 start_time = INT64_MAX;
1592 end_time = INT64_MIN;
1593 duration = INT64_MIN;
1594 for(i = 0;i < ic->nb_streams; i++) {
1595 st = ic->streams[i];
1596 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
1597 start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1598 if (start_time1 < start_time)
1599 start_time = start_time1;
1600 if (st->duration != AV_NOPTS_VALUE) {
1601 end_time1 = start_time1
1602 + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1603 if (end_time1 > end_time)
1604 end_time = end_time1;
1607 if (st->duration != AV_NOPTS_VALUE) {
1608 duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1609 if (duration1 > duration)
1610 duration = duration1;
1613 if (start_time != INT64_MAX) {
1614 ic->start_time = start_time;
1615 if (end_time != INT64_MIN) {
1616 if (end_time - start_time > duration)
1617 duration = end_time - start_time;
1620 if (duration != INT64_MIN) {
1621 ic->duration = duration;
1622 if (ic->file_size > 0) {
1623 /* compute the bitrate */
1624 ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1625 (double)ic->duration;
1630 static void fill_all_stream_timings(AVFormatContext *ic)
1635 av_update_stream_timings(ic);
1636 for(i = 0;i < ic->nb_streams; i++) {
1637 st = ic->streams[i];
1638 if (st->start_time == AV_NOPTS_VALUE) {
1639 if(ic->start_time != AV_NOPTS_VALUE)
1640 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1641 if(ic->duration != AV_NOPTS_VALUE)
1642 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1647 static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1649 int64_t filesize, duration;
1653 /* if bit_rate is already set, we believe it */
1654 if (ic->bit_rate == 0) {
1656 for(i=0;i<ic->nb_streams;i++) {
1657 st = ic->streams[i];
1658 bit_rate += st->codec->bit_rate;
1660 ic->bit_rate = bit_rate;
1663 /* if duration is already set, we believe it */
1664 if (ic->duration == AV_NOPTS_VALUE &&
1665 ic->bit_rate != 0 &&
1666 ic->file_size != 0) {
1667 filesize = ic->file_size;
1669 for(i = 0; i < ic->nb_streams; i++) {
1670 st = ic->streams[i];
1671 duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1672 if (st->duration == AV_NOPTS_VALUE)
1673 st->duration = duration;
1679 #define DURATION_MAX_READ_SIZE 250000
1681 /* only usable for MPEG-PS streams */
1682 static void av_estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
1684 AVPacket pkt1, *pkt = &pkt1;
1686 int read_size, i, ret;
1688 int64_t filesize, offset, duration;
1692 /* flush packet queue */
1693 flush_packet_queue(ic);
1695 for(i=0;i<ic->nb_streams;i++) {
1696 st = ic->streams[i];
1698 av_parser_close(st->parser);
1700 av_free_packet(&st->cur_pkt);
1704 /* we read the first packets to get the first PTS (not fully
1705 accurate, but it is enough now) */
1706 url_fseek(ic->pb, 0, SEEK_SET);
1709 if (read_size >= DURATION_MAX_READ_SIZE)
1711 /* if all info is available, we can stop */
1712 for(i = 0;i < ic->nb_streams; i++) {
1713 st = ic->streams[i];
1714 if (st->start_time == AV_NOPTS_VALUE)
1717 if (i == ic->nb_streams)
1721 ret = av_read_packet(ic, pkt);
1722 }while(ret == AVERROR(EAGAIN));
1725 read_size += pkt->size;
1726 st = ic->streams[pkt->stream_index];
1727 if (pkt->pts != AV_NOPTS_VALUE) {
1728 if (st->start_time == AV_NOPTS_VALUE)
1729 st->start_time = pkt->pts;
1731 av_free_packet(pkt);
1734 /* estimate the end time (duration) */
1735 /* XXX: may need to support wrapping */
1736 filesize = ic->file_size;
1737 offset = filesize - DURATION_MAX_READ_SIZE;
1741 url_fseek(ic->pb, offset, SEEK_SET);
1744 if (read_size >= DURATION_MAX_READ_SIZE)
1748 ret = av_read_packet(ic, pkt);
1749 }while(ret == AVERROR(EAGAIN));
1752 read_size += pkt->size;
1753 st = ic->streams[pkt->stream_index];
1754 if (pkt->pts != AV_NOPTS_VALUE &&
1755 st->start_time != AV_NOPTS_VALUE) {
1756 end_time = pkt->pts;
1757 duration = end_time - st->start_time;
1759 if (st->duration == AV_NOPTS_VALUE ||
1760 st->duration < duration)
1761 st->duration = duration;
1764 av_free_packet(pkt);
1767 fill_all_stream_timings(ic);
1769 url_fseek(ic->pb, old_offset, SEEK_SET);
1770 for(i=0; i<ic->nb_streams; i++){
1772 st->cur_dts= st->first_dts;
1773 st->last_IP_pts = AV_NOPTS_VALUE;
1777 static void av_estimate_timings(AVFormatContext *ic, int64_t old_offset)
1781 /* get the file size, if possible */
1782 if (ic->iformat->flags & AVFMT_NOFILE) {
1785 file_size = url_fsize(ic->pb);
1789 ic->file_size = file_size;
1791 if ((!strcmp(ic->iformat->name, "mpeg") ||
1792 !strcmp(ic->iformat->name, "mpegts")) &&
1793 file_size && !url_is_streamed(ic->pb)) {
1794 /* get accurate estimate from the PTSes */
1795 av_estimate_timings_from_pts(ic, old_offset);
1796 } else if (av_has_duration(ic)) {
1797 /* at least one component has timings - we use them for all
1799 fill_all_stream_timings(ic);
1801 /* less precise: use bitrate info */
1802 av_estimate_timings_from_bit_rate(ic);
1804 av_update_stream_timings(ic);
1810 for(i = 0;i < ic->nb_streams; i++) {
1811 st = ic->streams[i];
1812 printf("%d: start_time: %0.3f duration: %0.3f\n",
1813 i, (double)st->start_time / AV_TIME_BASE,
1814 (double)st->duration / AV_TIME_BASE);
1816 printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1817 (double)ic->start_time / AV_TIME_BASE,
1818 (double)ic->duration / AV_TIME_BASE,
1819 ic->bit_rate / 1000);
1824 static int has_codec_parameters(AVCodecContext *enc)
1827 switch(enc->codec_type) {
1828 case CODEC_TYPE_AUDIO:
1829 val = enc->sample_rate && enc->channels && enc->sample_fmt != SAMPLE_FMT_NONE;
1830 if(!enc->frame_size &&
1831 (enc->codec_id == CODEC_ID_VORBIS ||
1832 enc->codec_id == CODEC_ID_AAC))
1835 case CODEC_TYPE_VIDEO:
1836 val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
1842 return enc->codec_id != CODEC_ID_NONE && val != 0;
1845 static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1849 int got_picture, data_size, ret=0;
1852 if(!st->codec->codec){
1853 codec = avcodec_find_decoder(st->codec->codec_id);
1856 ret = avcodec_open(st->codec, codec);
1861 if(!has_codec_parameters(st->codec)){
1862 switch(st->codec->codec_type) {
1863 case CODEC_TYPE_VIDEO:
1864 ret = avcodec_decode_video(st->codec, &picture,
1865 &got_picture, data, size);
1867 case CODEC_TYPE_AUDIO:
1868 data_size = FFMAX(size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
1869 samples = av_malloc(data_size);
1872 ret = avcodec_decode_audio2(st->codec, samples,
1873 &data_size, data, size);
1884 unsigned int codec_get_tag(const AVCodecTag *tags, int id)
1886 while (tags->id != CODEC_ID_NONE) {
1894 enum CodecID codec_get_id(const AVCodecTag *tags, unsigned int tag)
1897 for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
1898 if(tag == tags[i].tag)
1901 for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
1902 if( toupper((tag >> 0)&0xFF) == toupper((tags[i].tag >> 0)&0xFF)
1903 && toupper((tag >> 8)&0xFF) == toupper((tags[i].tag >> 8)&0xFF)
1904 && toupper((tag >>16)&0xFF) == toupper((tags[i].tag >>16)&0xFF)
1905 && toupper((tag >>24)&0xFF) == toupper((tags[i].tag >>24)&0xFF))
1908 return CODEC_ID_NONE;
1911 unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum CodecID id)
1914 for(i=0; tags && tags[i]; i++){
1915 int tag= codec_get_tag(tags[i], id);
1921 enum CodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
1924 for(i=0; tags && tags[i]; i++){
1925 enum CodecID id= codec_get_id(tags[i], tag);
1926 if(id!=CODEC_ID_NONE) return id;
1928 return CODEC_ID_NONE;
1931 static void compute_chapters_end(AVFormatContext *s)
1935 for (i=0; i+1<s->nb_chapters; i++)
1936 if (s->chapters[i]->end == AV_NOPTS_VALUE) {
1937 assert(s->chapters[i]->start <= s->chapters[i+1]->start);
1938 assert(!av_cmp_q(s->chapters[i]->time_base, s->chapters[i+1]->time_base));
1939 s->chapters[i]->end = s->chapters[i+1]->start;
1942 if (s->nb_chapters && s->chapters[i]->end == AV_NOPTS_VALUE) {
1943 assert(s->start_time != AV_NOPTS_VALUE);
1944 assert(s->duration > 0);
1945 s->chapters[i]->end = av_rescale_q(s->start_time + s->duration,
1947 s->chapters[i]->time_base);
1951 /* absolute maximum size we read until we abort */
1952 #define MAX_READ_SIZE 5000000
1954 #define MAX_STD_TIMEBASES (60*12+5)
1955 static int get_std_framerate(int i){
1956 if(i<60*12) return i*1001;
1957 else return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
1961 * Is the time base unreliable.
1962 * This is a heuristic to balance between quick acceptance of the values in
1963 * the headers vs. some extra checks.
1964 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
1965 * MPEG-2 commonly misuses field repeat flags to store different framerates.
1966 * And there are "variable" fps files this needs to detect as well.
1968 static int tb_unreliable(AVCodecContext *c){
1969 if( c->time_base.den >= 101L*c->time_base.num
1970 || c->time_base.den < 5L*c->time_base.num
1971 /* || c->codec_tag == AV_RL32("DIVX")
1972 || c->codec_tag == AV_RL32("XVID")*/
1973 || c->codec_id == CODEC_ID_MPEG2VIDEO)
1978 int av_find_stream_info(AVFormatContext *ic)
1980 int i, count, ret, read_size, j;
1982 AVPacket pkt1, *pkt;
1983 int64_t last_dts[MAX_STREAMS];
1984 int duration_count[MAX_STREAMS]={0};
1985 double (*duration_error)[MAX_STD_TIMEBASES];
1986 int64_t old_offset = url_ftell(ic->pb);
1987 int64_t codec_info_duration[MAX_STREAMS]={0};
1988 int codec_info_nb_frames[MAX_STREAMS]={0};
1990 duration_error = av_mallocz(MAX_STREAMS * sizeof(*duration_error));
1991 if (!duration_error) return AVERROR(ENOMEM);
1993 for(i=0;i<ic->nb_streams;i++) {
1994 st = ic->streams[i];
1995 if(st->codec->codec_type == CODEC_TYPE_VIDEO){
1996 /* if(!st->time_base.num)
1998 if(!st->codec->time_base.num)
1999 st->codec->time_base= st->time_base;
2001 //only for the split stuff
2003 st->parser = av_parser_init(st->codec->codec_id);
2004 if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
2005 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2010 for(i=0;i<MAX_STREAMS;i++){
2011 last_dts[i]= AV_NOPTS_VALUE;
2017 /* check if one codec still needs to be handled */
2018 for(i=0;i<ic->nb_streams;i++) {
2019 st = ic->streams[i];
2020 if (!has_codec_parameters(st->codec))
2022 /* variable fps and no guess at the real fps */
2023 if( tb_unreliable(st->codec)
2024 && duration_count[i]<20 && st->codec->codec_type == CODEC_TYPE_VIDEO)
2026 if(st->parser && st->parser->parser->split && !st->codec->extradata)
2028 if(st->first_dts == AV_NOPTS_VALUE)
2031 if (i == ic->nb_streams) {
2032 /* NOTE: if the format has no header, then we need to read
2033 some packets to get most of the streams, so we cannot
2035 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2036 /* if we found the info for all the codecs, we can stop */
2041 /* we did not get all the codec info, but we read too much data */
2042 if (read_size >= MAX_READ_SIZE) {
2047 /* NOTE: a new stream can be added there if no header in file
2048 (AVFMTCTX_NOHEADER) */
2049 ret = av_read_frame_internal(ic, &pkt1);
2050 if(ret == AVERROR(EAGAIN))
2054 ret = -1; /* we could not have all the codec parameters before EOF */
2055 for(i=0;i<ic->nb_streams;i++) {
2056 st = ic->streams[i];
2057 if (!has_codec_parameters(st->codec)){
2059 avcodec_string(buf, sizeof(buf), st->codec, 0);
2060 av_log(ic, AV_LOG_INFO, "Could not find codec parameters (%s)\n", buf);
2068 pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2069 if(av_dup_packet(pkt) < 0) {
2070 av_free(duration_error);
2071 return AVERROR(ENOMEM);
2074 read_size += pkt->size;
2076 st = ic->streams[pkt->stream_index];
2077 if(codec_info_nb_frames[st->index]>1)
2078 codec_info_duration[st->index] += pkt->duration;
2079 if (pkt->duration != 0)
2080 codec_info_nb_frames[st->index]++;
2083 int index= pkt->stream_index;
2084 int64_t last= last_dts[index];
2085 int64_t duration= pkt->dts - last;
2087 if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
2088 double dur= duration * av_q2d(st->time_base);
2090 // if(st->codec->codec_type == CODEC_TYPE_VIDEO)
2091 // av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
2092 if(duration_count[index] < 2)
2093 memset(duration_error[index], 0, sizeof(*duration_error));
2094 for(i=1; i<MAX_STD_TIMEBASES; i++){
2095 int framerate= get_std_framerate(i);
2096 int ticks= lrintf(dur*framerate/(1001*12));
2097 double error= dur - ticks*1001*12/(double)framerate;
2098 duration_error[index][i] += error*error;
2100 duration_count[index]++;
2102 if(last == AV_NOPTS_VALUE || duration_count[index]<=1)
2103 last_dts[pkt->stream_index]= pkt->dts;
2105 if(st->parser && st->parser->parser->split && !st->codec->extradata){
2106 int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2108 st->codec->extradata_size= i;
2109 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2110 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2111 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2115 /* if still no information, we try to open the codec and to
2116 decompress the frame. We try to avoid that in most cases as
2117 it takes longer and uses more memory. For MPEG-4, we need to
2118 decompress for QuickTime. */
2119 if (!has_codec_parameters(st->codec) /*&&
2120 (st->codec->codec_id == CODEC_ID_FLV1 ||
2121 st->codec->codec_id == CODEC_ID_H264 ||
2122 st->codec->codec_id == CODEC_ID_H263 ||
2123 st->codec->codec_id == CODEC_ID_H261 ||
2124 st->codec->codec_id == CODEC_ID_VORBIS ||
2125 st->codec->codec_id == CODEC_ID_MJPEG ||
2126 st->codec->codec_id == CODEC_ID_PNG ||
2127 st->codec->codec_id == CODEC_ID_PAM ||
2128 st->codec->codec_id == CODEC_ID_PGM ||
2129 st->codec->codec_id == CODEC_ID_PGMYUV ||
2130 st->codec->codec_id == CODEC_ID_PBM ||
2131 st->codec->codec_id == CODEC_ID_PPM ||
2132 st->codec->codec_id == CODEC_ID_SHORTEN ||
2133 (st->codec->codec_id == CODEC_ID_MPEG4 && !st->need_parsing))*/)
2134 try_decode_frame(st, pkt->data, pkt->size);
2136 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) {
2142 // close codecs which were opened in try_decode_frame()
2143 for(i=0;i<ic->nb_streams;i++) {
2144 st = ic->streams[i];
2145 if(st->codec->codec)
2146 avcodec_close(st->codec);
2148 for(i=0;i<ic->nb_streams;i++) {
2149 st = ic->streams[i];
2150 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2151 if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample)
2152 st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2154 if(duration_count[i]
2155 && tb_unreliable(st->codec) /*&&
2156 //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2157 st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den*/){
2158 double best_error= 2*av_q2d(st->time_base);
2159 best_error= best_error*best_error*duration_count[i]*1000*12*30;
2161 for(j=1; j<MAX_STD_TIMEBASES; j++){
2162 double error= duration_error[i][j] * get_std_framerate(j);
2163 // if(st->codec->codec_type == CODEC_TYPE_VIDEO)
2164 // av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
2165 if(error < best_error){
2167 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, get_std_framerate(j), 12*1001, INT_MAX);
2172 if (!st->r_frame_rate.num){
2173 if( st->codec->time_base.den * (int64_t)st->time_base.num
2174 <= st->codec->time_base.num * (int64_t)st->time_base.den){
2175 st->r_frame_rate.num = st->codec->time_base.den;
2176 st->r_frame_rate.den = st->codec->time_base.num;
2178 st->r_frame_rate.num = st->time_base.den;
2179 st->r_frame_rate.den = st->time_base.num;
2182 }else if(st->codec->codec_type == CODEC_TYPE_AUDIO) {
2183 if(!st->codec->bits_per_coded_sample)
2184 st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2188 av_estimate_timings(ic, old_offset);
2190 compute_chapters_end(ic);
2193 /* correct DTS for B-frame streams with no timestamps */
2194 for(i=0;i<ic->nb_streams;i++) {
2195 st = ic->streams[i];
2196 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2198 ppktl = &ic->packet_buffer;
2200 if(ppkt1->stream_index != i)
2202 if(ppkt1->pkt->dts < 0)
2204 if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2206 ppkt1->pkt->dts -= delta;
2211 st->cur_dts -= delta;
2217 av_free(duration_error);
2222 /*******************************************************/
2224 int av_read_play(AVFormatContext *s)
2226 if (s->iformat->read_play)
2227 return s->iformat->read_play(s);
2229 return av_url_read_fpause(s->pb, 0);
2230 return AVERROR(ENOSYS);
2233 int av_read_pause(AVFormatContext *s)
2235 if (s->iformat->read_pause)
2236 return s->iformat->read_pause(s);
2238 return av_url_read_fpause(s->pb, 1);
2239 return AVERROR(ENOSYS);
2242 void av_close_input_stream(AVFormatContext *s)
2247 if (s->iformat->read_close)
2248 s->iformat->read_close(s);
2249 for(i=0;i<s->nb_streams;i++) {
2250 /* free all data in a stream component */
2253 av_parser_close(st->parser);
2254 av_free_packet(&st->cur_pkt);
2256 av_metadata_free(&st->metadata);
2257 av_free(st->index_entries);
2258 av_free(st->codec->extradata);
2260 av_free(st->filename);
2261 av_free(st->priv_data);
2264 for(i=s->nb_programs-1; i>=0; i--) {
2265 av_freep(&s->programs[i]->provider_name);
2266 av_freep(&s->programs[i]->name);
2267 av_metadata_free(&s->programs[i]->metadata);
2268 av_freep(&s->programs[i]->stream_index);
2269 av_freep(&s->programs[i]);
2271 av_freep(&s->programs);
2272 flush_packet_queue(s);
2273 av_freep(&s->priv_data);
2274 while(s->nb_chapters--) {
2275 av_free(s->chapters[s->nb_chapters]->title);
2276 av_metadata_free(&s->chapters[s->nb_chapters]->metadata);
2277 av_free(s->chapters[s->nb_chapters]);
2279 av_freep(&s->chapters);
2280 av_metadata_free(&s->metadata);
2284 void av_close_input_file(AVFormatContext *s)
2286 ByteIOContext *pb = s->iformat->flags & AVFMT_NOFILE ? NULL : s->pb;
2287 av_close_input_stream(s);
2292 AVStream *av_new_stream(AVFormatContext *s, int id)
2297 if (s->nb_streams >= MAX_STREAMS)
2300 st = av_mallocz(sizeof(AVStream));
2304 st->codec= avcodec_alloc_context();
2306 /* no default bitrate if decoding */
2307 st->codec->bit_rate = 0;
2309 st->index = s->nb_streams;
2311 st->start_time = AV_NOPTS_VALUE;
2312 st->duration = AV_NOPTS_VALUE;
2313 /* we set the current DTS to 0 so that formats without any timestamps
2314 but durations get some timestamps, formats with some unknown
2315 timestamps have their first few packets buffered and the
2316 timestamps corrected before they are returned to the user */
2318 st->first_dts = AV_NOPTS_VALUE;
2320 /* default pts setting is MPEG-like */
2321 av_set_pts_info(st, 33, 1, 90000);
2322 st->last_IP_pts = AV_NOPTS_VALUE;
2323 for(i=0; i<MAX_REORDER_DELAY+1; i++)
2324 st->pts_buffer[i]= AV_NOPTS_VALUE;
2326 st->sample_aspect_ratio = (AVRational){0,1};
2328 s->streams[s->nb_streams++] = st;
2332 AVProgram *av_new_program(AVFormatContext *ac, int id)
2334 AVProgram *program=NULL;
2338 av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2341 for(i=0; i<ac->nb_programs; i++)
2342 if(ac->programs[i]->id == id)
2343 program = ac->programs[i];
2346 program = av_mallocz(sizeof(AVProgram));
2349 dynarray_add(&ac->programs, &ac->nb_programs, program);
2350 program->discard = AVDISCARD_NONE;
2357 AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2359 AVChapter *chapter = NULL;
2362 for(i=0; i<s->nb_chapters; i++)
2363 if(s->chapters[i]->id == id)
2364 chapter = s->chapters[i];
2367 chapter= av_mallocz(sizeof(AVChapter));
2370 dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2372 av_free(chapter->title);
2373 chapter->title = av_strdup(title);
2375 chapter->time_base= time_base;
2376 chapter->start = start;
2382 /************************************************************/
2383 /* output media file */
2385 int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2389 if (s->oformat->priv_data_size > 0) {
2390 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2392 return AVERROR(ENOMEM);
2394 s->priv_data = NULL;
2396 if (s->oformat->set_parameters) {
2397 ret = s->oformat->set_parameters(s, ap);
2404 int av_write_header(AVFormatContext *s)
2409 // some sanity checks
2410 for(i=0;i<s->nb_streams;i++) {
2413 switch (st->codec->codec_type) {
2414 case CODEC_TYPE_AUDIO:
2415 if(st->codec->sample_rate<=0){
2416 av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2419 if(!st->codec->block_align)
2420 st->codec->block_align = st->codec->channels *
2421 av_get_bits_per_sample(st->codec->codec_id) >> 3;
2423 case CODEC_TYPE_VIDEO:
2424 if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2425 av_log(s, AV_LOG_ERROR, "time base not set\n");
2428 if(st->codec->width<=0 || st->codec->height<=0){
2429 av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2432 if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)){
2433 av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between encoder and muxer layer\n");
2439 if(s->oformat->codec_tag){
2440 if(st->codec->codec_tag){
2442 //check that tag + id is in the table
2443 //if neither is in the table -> OK
2444 //if tag is in the table with another id -> FAIL
2445 //if id is in the table with another tag -> FAIL unless strict < ?
2447 st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2451 if (!s->priv_data && s->oformat->priv_data_size > 0) {
2452 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2454 return AVERROR(ENOMEM);
2457 #if LIBAVFORMAT_VERSION_MAJOR < 53
2458 ff_metadata_mux_compat(s);
2461 if(s->oformat->write_header){
2462 ret = s->oformat->write_header(s);
2467 /* init PTS generation */
2468 for(i=0;i<s->nb_streams;i++) {
2469 int64_t den = AV_NOPTS_VALUE;
2472 switch (st->codec->codec_type) {
2473 case CODEC_TYPE_AUDIO:
2474 den = (int64_t)st->time_base.num * st->codec->sample_rate;
2476 case CODEC_TYPE_VIDEO:
2477 den = (int64_t)st->time_base.num * st->codec->time_base.den;
2482 if (den != AV_NOPTS_VALUE) {
2484 return AVERROR_INVALIDDATA;
2485 av_frac_init(&st->pts, 0, 0, den);
2491 //FIXME merge with compute_pkt_fields
2492 static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
2493 int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2494 int num, den, frame_size, i;
2496 // 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);
2498 /* if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2501 /* duration field */
2502 if (pkt->duration == 0) {
2503 compute_frame_duration(&num, &den, st, NULL, pkt);
2505 pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
2509 if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
2512 //XXX/FIXME this is a temporary hack until all encoders output pts
2513 if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2515 // pkt->pts= st->cur_dts;
2516 pkt->pts= st->pts.val;
2519 //calculate dts from pts
2520 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
2521 st->pts_buffer[0]= pkt->pts;
2522 for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2523 st->pts_buffer[i]= (i-delay-1) * pkt->duration;
2524 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2525 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2527 pkt->dts= st->pts_buffer[0];
2530 if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2531 av_log(st->codec, AV_LOG_ERROR, "error, non monotone timestamps %"PRId64" >= %"PRId64"\n", st->cur_dts, pkt->dts);
2534 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2535 av_log(st->codec, AV_LOG_ERROR, "error, pts < dts\n");
2539 // av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2540 st->cur_dts= pkt->dts;
2541 st->pts.val= pkt->dts;
2544 switch (st->codec->codec_type) {
2545 case CODEC_TYPE_AUDIO:
2546 frame_size = get_audio_frame_size(st->codec, pkt->size);
2548 /* HACK/FIXME, we skip the initial 0 size packets as they are most
2549 likely equal to the encoder delay, but it would be better if we
2550 had the real timestamps from the encoder */
2551 if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2552 av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2555 case CODEC_TYPE_VIDEO:
2556 av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2564 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2566 int ret = compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2568 if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2571 ret= s->oformat->write_packet(s, pkt);
2573 ret= url_ferror(s->pb);
2577 void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
2578 int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
2580 AVPacketList **next_point, *this_pktl;
2582 this_pktl = av_mallocz(sizeof(AVPacketList));
2583 this_pktl->pkt= *pkt;
2584 if(pkt->destruct == av_destruct_packet)
2585 pkt->destruct= NULL; // not shared -> must keep original from being freed
2587 av_dup_packet(&this_pktl->pkt); //shared -> must dup
2589 next_point = &s->packet_buffer;
2591 if(compare(s, &(*next_point)->pkt, pkt))
2593 next_point= &(*next_point)->next;
2595 this_pktl->next= *next_point;
2596 *next_point= this_pktl;
2599 int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
2601 AVStream *st = s->streams[ pkt ->stream_index];
2602 AVStream *st2= s->streams[ next->stream_index];
2603 int64_t left = st2->time_base.num * (int64_t)st ->time_base.den;
2604 int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2606 if (pkt->dts == AV_NOPTS_VALUE)
2609 return next->dts * left > pkt->dts * right; //FIXME this can overflow
2612 int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2615 int streams[MAX_STREAMS];
2618 ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
2621 memset(streams, 0, sizeof(streams));
2622 pktl= s->packet_buffer;
2624 //av_log(s, AV_LOG_DEBUG, "show st:%d dts:%"PRId64"\n", pktl->pkt.stream_index, pktl->pkt.dts);
2625 if(streams[ pktl->pkt.stream_index ] == 0)
2627 streams[ pktl->pkt.stream_index ]++;
2631 if(stream_count && (s->nb_streams == stream_count || flush)){
2632 pktl= s->packet_buffer;
2635 s->packet_buffer= pktl->next;
2639 av_init_packet(out);
2645 * Interleaves an AVPacket correctly so it can be muxed.
2646 * @param out the interleaved packet will be output here
2647 * @param in the input packet
2648 * @param flush 1 if no further packets are available as input and all
2649 * remaining packets should be output
2650 * @return 1 if a packet was output, 0 if no packet could be output,
2651 * < 0 if an error occurred
2653 static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2654 if(s->oformat->interleave_packet)
2655 return s->oformat->interleave_packet(s, out, in, flush);
2657 return av_interleave_packet_per_dts(s, out, in, flush);
2660 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2661 AVStream *st= s->streams[ pkt->stream_index];
2663 //FIXME/XXX/HACK drop zero sized packets
2664 if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2667 //av_log(NULL, AV_LOG_DEBUG, "av_interleaved_write_frame %d %"PRId64" %"PRId64"\n", pkt->size, pkt->dts, pkt->pts);
2668 if(compute_pkt_fields2(st, pkt) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2671 if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2676 int ret= av_interleave_packet(s, &opkt, pkt, 0);
2677 if(ret<=0) //FIXME cleanup needed for ret<0 ?
2680 ret= s->oformat->write_packet(s, &opkt);
2682 av_free_packet(&opkt);
2687 if(url_ferror(s->pb))
2688 return url_ferror(s->pb);
2692 int av_write_trailer(AVFormatContext *s)
2698 ret= av_interleave_packet(s, &pkt, NULL, 1);
2699 if(ret<0) //FIXME cleanup needed for ret<0 ?
2704 ret= s->oformat->write_packet(s, &pkt);
2706 av_free_packet(&pkt);
2710 if(url_ferror(s->pb))
2714 if(s->oformat->write_trailer)
2715 ret = s->oformat->write_trailer(s);
2718 ret=url_ferror(s->pb);
2719 for(i=0;i<s->nb_streams;i++)
2720 av_freep(&s->streams[i]->priv_data);
2721 av_freep(&s->priv_data);
2725 void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
2728 AVProgram *program=NULL;
2731 for(i=0; i<ac->nb_programs; i++){
2732 if(ac->programs[i]->id != progid)
2734 program = ac->programs[i];
2735 for(j=0; j<program->nb_stream_indexes; j++)
2736 if(program->stream_index[j] == idx)
2739 tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
2742 program->stream_index = tmp;
2743 program->stream_index[program->nb_stream_indexes++] = idx;
2748 /* "user interface" functions */
2749 static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
2752 int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
2753 AVStream *st = ic->streams[i];
2754 int g = av_gcd(st->time_base.num, st->time_base.den);
2755 avcodec_string(buf, sizeof(buf), st->codec, is_output);
2756 av_log(NULL, AV_LOG_INFO, " Stream #%d.%d", index, i);
2757 /* the pid is an important information, so we display it */
2758 /* XXX: add a generic system */
2759 if (flags & AVFMT_SHOW_IDS)
2760 av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
2761 if (strlen(st->language) > 0)
2762 av_log(NULL, AV_LOG_INFO, "(%s)", st->language);
2763 av_log(NULL, AV_LOG_DEBUG, ", %d/%d", st->time_base.num/g, st->time_base.den/g);
2764 av_log(NULL, AV_LOG_INFO, ": %s", buf);
2765 if (st->sample_aspect_ratio.num && // default
2766 av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
2767 AVRational display_aspect_ratio;
2768 av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
2769 st->codec->width*st->sample_aspect_ratio.num,
2770 st->codec->height*st->sample_aspect_ratio.den,
2772 av_log(NULL, AV_LOG_INFO, ", PAR %d:%d DAR %d:%d",
2773 st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
2774 display_aspect_ratio.num, display_aspect_ratio.den);
2776 if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2777 if(st->r_frame_rate.den && st->r_frame_rate.num)
2778 av_log(NULL, AV_LOG_INFO, ", %5.2f tb(r)", av_q2d(st->r_frame_rate));
2779 /* else if(st->time_base.den && st->time_base.num)
2780 av_log(NULL, AV_LOG_INFO, ", %5.2f tb(m)", 1/av_q2d(st->time_base));*/
2782 av_log(NULL, AV_LOG_INFO, ", %5.2f tb(c)", 1/av_q2d(st->codec->time_base));
2784 av_log(NULL, AV_LOG_INFO, "\n");
2787 void dump_format(AVFormatContext *ic,
2794 av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
2795 is_output ? "Output" : "Input",
2797 is_output ? ic->oformat->name : ic->iformat->name,
2798 is_output ? "to" : "from", url);
2800 av_log(NULL, AV_LOG_INFO, " Duration: ");
2801 if (ic->duration != AV_NOPTS_VALUE) {
2802 int hours, mins, secs, us;
2803 secs = ic->duration / AV_TIME_BASE;
2804 us = ic->duration % AV_TIME_BASE;
2809 av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
2810 (100 * us) / AV_TIME_BASE);
2812 av_log(NULL, AV_LOG_INFO, "N/A");
2814 if (ic->start_time != AV_NOPTS_VALUE) {
2816 av_log(NULL, AV_LOG_INFO, ", start: ");
2817 secs = ic->start_time / AV_TIME_BASE;
2818 us = ic->start_time % AV_TIME_BASE;
2819 av_log(NULL, AV_LOG_INFO, "%d.%06d",
2820 secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
2822 av_log(NULL, AV_LOG_INFO, ", bitrate: ");
2824 av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
2826 av_log(NULL, AV_LOG_INFO, "N/A");
2828 av_log(NULL, AV_LOG_INFO, "\n");
2830 if(ic->nb_programs) {
2832 for(j=0; j<ic->nb_programs; j++) {
2833 av_log(NULL, AV_LOG_INFO, " Program %d %s\n", ic->programs[j]->id,
2834 ic->programs[j]->name ? ic->programs[j]->name : "");
2835 for(k=0; k<ic->programs[j]->nb_stream_indexes; k++)
2836 dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
2839 for(i=0;i<ic->nb_streams;i++)
2840 dump_stream_format(ic, i, index, is_output);
2843 #if LIBAVFORMAT_VERSION_MAJOR < 53
2844 int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2846 return av_parse_video_frame_size(width_ptr, height_ptr, str);
2849 int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
2851 AVRational frame_rate;
2852 int ret = av_parse_video_frame_rate(&frame_rate, arg);
2853 *frame_rate_num= frame_rate.num;
2854 *frame_rate_den= frame_rate.den;
2859 int64_t av_gettime(void)
2862 gettimeofday(&tv,NULL);
2863 return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
2866 int64_t parse_date(const char *datestr, int duration)
2872 static const char * const date_fmt[] = {
2876 static const char * const time_fmt[] = {
2886 time_t now = time(0);
2888 len = strlen(datestr);
2890 lastch = datestr[len - 1];
2893 is_utc = (lastch == 'z' || lastch == 'Z');
2895 memset(&dt, 0, sizeof(dt));
2900 if (!strncasecmp(datestr, "now", len))
2901 return (int64_t) now * 1000000;
2903 /* parse the year-month-day part */
2904 for (i = 0; i < FF_ARRAY_ELEMS(date_fmt); i++) {
2905 q = small_strptime(p, date_fmt[i], &dt);
2911 /* if the year-month-day part is missing, then take the
2912 * current year-month-day time */
2917 dt = *localtime(&now);
2919 dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
2924 if (*p == 'T' || *p == 't' || *p == ' ')
2927 /* parse the hour-minute-second part */
2928 for (i = 0; i < FF_ARRAY_ELEMS(time_fmt); i++) {
2929 q = small_strptime(p, time_fmt[i], &dt);
2935 /* parse datestr as a duration */
2940 /* parse datestr as HH:MM:SS */
2941 q = small_strptime(p, time_fmt[0], &dt);
2943 /* parse datestr as S+ */
2944 dt.tm_sec = strtol(p, (char **)&q, 10);
2946 /* the parsing didn't succeed */
2953 /* Now we have all the fields that we can get */
2959 t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2961 dt.tm_isdst = -1; /* unknown */
2971 /* parse the .m... part */
2975 for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
2978 val += n * (*q - '0');
2982 return negative ? -t : t;
2985 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
2995 while (*p != '\0' && *p != '=' && *p != '&') {
2996 if ((q - tag) < sizeof(tag) - 1)
3004 while (*p != '&' && *p != '\0') {
3005 if ((q - arg) < arg_size - 1) {
3015 if (!strcmp(tag, tag1))
3024 int av_get_frame_filename(char *buf, int buf_size,
3025 const char *path, int number)
3028 char *q, buf1[20], c;
3029 int nd, len, percentd_found;
3041 while (isdigit(*p)) {
3042 nd = nd * 10 + *p++ - '0';
3045 } while (isdigit(c));
3054 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3056 if ((q - buf + len) > buf_size - 1)
3058 memcpy(q, buf1, len);
3066 if ((q - buf) < buf_size - 1)
3070 if (!percentd_found)
3079 static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3082 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3084 for(i=0;i<size;i+=16) {
3091 PRINT(" %02x", buf[i+j]);
3096 for(j=0;j<len;j++) {
3098 if (c < ' ' || c > '~')
3107 void av_hex_dump(FILE *f, uint8_t *buf, int size)
3109 hex_dump_internal(NULL, f, 0, buf, size);
3112 void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3114 hex_dump_internal(avcl, NULL, level, buf, size);
3117 //FIXME needs to know the time_base
3118 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload)
3120 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3121 PRINT("stream #%d:\n", pkt->stream_index);
3122 PRINT(" keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
3123 PRINT(" duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
3124 /* DTS is _always_ valid after av_read_frame() */
3126 if (pkt->dts == AV_NOPTS_VALUE)
3129 PRINT("%0.3f", (double)pkt->dts / AV_TIME_BASE);
3130 /* PTS may not be known if B-frames are present. */
3132 if (pkt->pts == AV_NOPTS_VALUE)
3135 PRINT("%0.3f", (double)pkt->pts / AV_TIME_BASE);
3137 PRINT(" size=%d\n", pkt->size);
3140 av_hex_dump(f, pkt->data, pkt->size);
3143 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3145 pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
3148 void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3150 pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
3153 void url_split(char *proto, int proto_size,
3154 char *authorization, int authorization_size,
3155 char *hostname, int hostname_size,
3157 char *path, int path_size,
3160 const char *p, *ls, *at, *col, *brk;
3162 if (port_ptr) *port_ptr = -1;
3163 if (proto_size > 0) proto[0] = 0;
3164 if (authorization_size > 0) authorization[0] = 0;
3165 if (hostname_size > 0) hostname[0] = 0;
3166 if (path_size > 0) path[0] = 0;
3168 /* parse protocol */
3169 if ((p = strchr(url, ':'))) {
3170 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3175 /* no protocol means plain filename */
3176 av_strlcpy(path, url, path_size);
3180 /* separate path from hostname */
3181 ls = strchr(p, '/');
3183 ls = strchr(p, '?');
3185 av_strlcpy(path, ls, path_size);
3187 ls = &p[strlen(p)]; // XXX
3189 /* the rest is hostname, use that to parse auth/port */
3191 /* authorization (user[:pass]@hostname) */
3192 if ((at = strchr(p, '@')) && at < ls) {
3193 av_strlcpy(authorization, p,
3194 FFMIN(authorization_size, at + 1 - p));
3195 p = at + 1; /* skip '@' */
3198 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3200 av_strlcpy(hostname, p + 1,
3201 FFMIN(hostname_size, brk - p));
3202 if (brk[1] == ':' && port_ptr)
3203 *port_ptr = atoi(brk + 2);
3204 } else if ((col = strchr(p, ':')) && col < ls) {
3205 av_strlcpy(hostname, p,
3206 FFMIN(col + 1 - p, hostname_size));
3207 if (port_ptr) *port_ptr = atoi(col + 1);
3209 av_strlcpy(hostname, p,
3210 FFMIN(ls + 1 - p, hostname_size));
3214 char *ff_data_to_hex(char *buff, const uint8_t *src, int s)
3217 static const char hex_table[16] = { '0', '1', '2', '3',
3220 'C', 'D', 'E', 'F' };
3222 for(i = 0; i < s; i++) {
3223 buff[i * 2] = hex_table[src[i] >> 4];
3224 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3230 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3231 int pts_num, int pts_den)
3233 unsigned int gcd= av_gcd(pts_num, pts_den);
3234 s->pts_wrap_bits = pts_wrap_bits;
3235 s->time_base.num = pts_num/gcd;
3236 s->time_base.den = pts_den/gcd;
3239 av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, gcd);