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 "avio_internal.h"
25 #include "libavcodec/internal.h"
26 #include "libavcodec/raw.h"
27 #include "libavcodec/bytestream.h"
28 #include "libavutil/avassert.h"
29 #include "libavutil/opt.h"
30 #include "libavutil/dict.h"
31 #include "libavutil/pixdesc.h"
34 #include "libavutil/avassert.h"
35 #include "libavutil/avstring.h"
36 #include "libavutil/mathematics.h"
37 #include "libavutil/parseutils.h"
38 #include "libavutil/time.h"
39 #include "libavutil/timestamp.h"
41 #include "audiointerleave.h"
53 * various utility functions for use within FFmpeg
56 unsigned avformat_version(void)
58 av_assert0(LIBAVFORMAT_VERSION_MICRO >= 100);
59 return LIBAVFORMAT_VERSION_INT;
62 const char *avformat_configuration(void)
64 return FFMPEG_CONFIGURATION;
67 const char *avformat_license(void)
69 #define LICENSE_PREFIX "libavformat license: "
70 return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;
73 #define RELATIVE_TS_BASE (INT64_MAX - (1LL<<48))
75 static int is_relative(int64_t ts) {
76 return ts > (RELATIVE_TS_BASE - (1LL<<48));
80 * Wrap a given time stamp, if there is an indication for an overflow
83 * @param timestamp the time stamp to wrap
84 * @return resulting time stamp
86 static int64_t wrap_timestamp(AVStream *st, int64_t timestamp)
88 if (st->pts_wrap_behavior != AV_PTS_WRAP_IGNORE &&
89 st->pts_wrap_reference != AV_NOPTS_VALUE && timestamp != AV_NOPTS_VALUE) {
90 if (st->pts_wrap_behavior == AV_PTS_WRAP_ADD_OFFSET &&
91 timestamp < st->pts_wrap_reference)
92 return timestamp + (1ULL<<st->pts_wrap_bits);
93 else if (st->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET &&
94 timestamp >= st->pts_wrap_reference)
95 return timestamp - (1ULL<<st->pts_wrap_bits);
100 #define MAKE_ACCESSORS(str, name, type, field) \
101 type av_##name##_get_##field(const str *s) { return s->field; } \
102 void av_##name##_set_##field(str *s, type v) { s->field = v; }
104 MAKE_ACCESSORS(AVStream, stream, AVRational, r_frame_rate)
106 /** head of registered input format linked list */
107 static AVInputFormat *first_iformat = NULL;
108 /** head of registered output format linked list */
109 static AVOutputFormat *first_oformat = NULL;
111 AVInputFormat *av_iformat_next(AVInputFormat *f)
113 if(f) return f->next;
114 else return first_iformat;
117 AVOutputFormat *av_oformat_next(AVOutputFormat *f)
119 if(f) return f->next;
120 else return first_oformat;
123 void av_register_input_format(AVInputFormat *format)
127 while (*p != NULL) p = &(*p)->next;
132 void av_register_output_format(AVOutputFormat *format)
136 while (*p != NULL) p = &(*p)->next;
141 int av_match_ext(const char *filename, const char *extensions)
149 ext = strrchr(filename, '.');
155 while (*p != '\0' && *p != ',' && q-ext1<sizeof(ext1)-1)
158 if (!av_strcasecmp(ext1, ext))
168 static int match_format(const char *name, const char *names)
176 namelen = strlen(name);
177 while ((p = strchr(names, ','))) {
178 len = FFMAX(p - names, namelen);
179 if (!av_strncasecmp(name, names, len))
183 return !av_strcasecmp(name, names);
186 AVOutputFormat *av_guess_format(const char *short_name, const char *filename,
187 const char *mime_type)
189 AVOutputFormat *fmt = NULL, *fmt_found;
190 int score_max, score;
192 /* specific test for image sequences */
193 #if CONFIG_IMAGE2_MUXER
194 if (!short_name && filename &&
195 av_filename_number_test(filename) &&
196 ff_guess_image2_codec(filename) != AV_CODEC_ID_NONE) {
197 return av_guess_format("image2", NULL, NULL);
200 /* Find the proper file type. */
203 while ((fmt = av_oformat_next(fmt))) {
205 if (fmt->name && short_name && match_format(short_name, fmt->name))
207 if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
209 if (filename && fmt->extensions &&
210 av_match_ext(filename, fmt->extensions)) {
213 if (score > score_max) {
221 enum AVCodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
222 const char *filename, const char *mime_type, enum AVMediaType type){
223 if (!strcmp(fmt->name, "segment") || !strcmp(fmt->name, "ssegment")) {
224 fmt = av_guess_format(NULL, filename, NULL);
227 if(type == AVMEDIA_TYPE_VIDEO){
228 enum AVCodecID codec_id= AV_CODEC_ID_NONE;
230 #if CONFIG_IMAGE2_MUXER
231 if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
232 codec_id= ff_guess_image2_codec(filename);
235 if(codec_id == AV_CODEC_ID_NONE)
236 codec_id= fmt->video_codec;
238 }else if(type == AVMEDIA_TYPE_AUDIO)
239 return fmt->audio_codec;
240 else if (type == AVMEDIA_TYPE_SUBTITLE)
241 return fmt->subtitle_codec;
243 return AV_CODEC_ID_NONE;
246 AVInputFormat *av_find_input_format(const char *short_name)
248 AVInputFormat *fmt = NULL;
249 while ((fmt = av_iformat_next(fmt))) {
250 if (match_format(short_name, fmt->name))
256 /* an arbitrarily chosen "sane" max packet size -- 50M */
257 #define SANE_CHUNK_SIZE (50000000)
259 int ffio_limit(AVIOContext *s, int size)
262 int64_t remaining= s->maxsize - avio_tell(s);
263 if(remaining < size){
264 int64_t newsize= avio_size(s);
265 if(!s->maxsize || s->maxsize<newsize)
266 s->maxsize= newsize - !newsize;
267 remaining= s->maxsize - avio_tell(s);
268 remaining= FFMAX(remaining, 0);
271 if(s->maxsize>=0 && remaining+1 < size){
272 av_log(NULL, remaining ? AV_LOG_ERROR : AV_LOG_DEBUG, "Truncating packet of size %d to %"PRId64"\n", size, remaining+1);
280 * Read the data in sane-sized chunks and append to pkt.
281 * Return the number of bytes read or an error.
283 static int append_packet_chunked(AVIOContext *s, AVPacket *pkt, int size)
285 int64_t orig_pos = pkt->pos; // av_grow_packet might reset pos
286 int orig_size = pkt->size;
290 int prev_size = pkt->size;
294 * When the caller requests a lot of data, limit it to the amount left
295 * in file or SANE_CHUNK_SIZE when it is not known
298 if (read_size > SANE_CHUNK_SIZE/10) {
299 read_size = ffio_limit(s, read_size);
300 // If filesize/maxsize is unknown, limit to SANE_CHUNK_SIZE
302 read_size = FFMIN(read_size, SANE_CHUNK_SIZE);
305 ret = av_grow_packet(pkt, read_size);
309 ret = avio_read(s, pkt->data + prev_size, read_size);
310 if (ret != read_size) {
311 av_shrink_packet(pkt, prev_size + FFMAX(ret, 0));
318 pkt->flags |= AV_PKT_FLAG_CORRUPT;
323 return pkt->size > orig_size ? pkt->size - orig_size : ret;
326 int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
331 pkt->pos = avio_tell(s);
333 return append_packet_chunked(s, pkt, size);
336 int av_append_packet(AVIOContext *s, AVPacket *pkt, int size)
339 return av_get_packet(s, pkt, size);
340 return append_packet_chunked(s, pkt, size);
344 int av_filename_number_test(const char *filename)
347 return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
350 AVInputFormat *av_probe_input_format3(AVProbeData *pd, int is_opened, int *score_ret)
352 AVProbeData lpd = *pd;
353 AVInputFormat *fmt1 = NULL, *fmt;
354 int score, nodat = 0, score_max=0;
355 const static uint8_t zerobuffer[AVPROBE_PADDING_SIZE];
358 lpd.buf = zerobuffer;
360 if (lpd.buf_size > 10 && ff_id3v2_match(lpd.buf, ID3v2_DEFAULT_MAGIC)) {
361 int id3len = ff_id3v2_tag_len(lpd.buf);
362 if (lpd.buf_size > id3len + 16) {
364 lpd.buf_size -= id3len;
370 while ((fmt1 = av_iformat_next(fmt1))) {
371 if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
374 if (fmt1->read_probe) {
375 score = fmt1->read_probe(&lpd);
376 if(fmt1->extensions && av_match_ext(lpd.filename, fmt1->extensions))
377 score = FFMAX(score, nodat ? AVPROBE_SCORE_EXTENSION / 2 - 1 : 1);
378 } else if (fmt1->extensions) {
379 if (av_match_ext(lpd.filename, fmt1->extensions)) {
380 score = AVPROBE_SCORE_EXTENSION;
383 if (score > score_max) {
386 }else if (score == score_max)
390 score_max = FFMIN(AVPROBE_SCORE_EXTENSION / 2 - 1, score_max);
391 *score_ret= score_max;
396 AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
399 AVInputFormat *fmt= av_probe_input_format3(pd, is_opened, &score_ret);
400 if(score_ret > *score_max){
401 *score_max= score_ret;
407 AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
409 return av_probe_input_format2(pd, is_opened, &score);
412 static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st, AVProbeData *pd)
414 static const struct {
415 const char *name; enum AVCodecID id; enum AVMediaType type;
417 { "aac" , AV_CODEC_ID_AAC , AVMEDIA_TYPE_AUDIO },
418 { "ac3" , AV_CODEC_ID_AC3 , AVMEDIA_TYPE_AUDIO },
419 { "dts" , AV_CODEC_ID_DTS , AVMEDIA_TYPE_AUDIO },
420 { "eac3" , AV_CODEC_ID_EAC3 , AVMEDIA_TYPE_AUDIO },
421 { "h264" , AV_CODEC_ID_H264 , AVMEDIA_TYPE_VIDEO },
422 { "loas" , AV_CODEC_ID_AAC_LATM , AVMEDIA_TYPE_AUDIO },
423 { "m4v" , AV_CODEC_ID_MPEG4 , AVMEDIA_TYPE_VIDEO },
424 { "mp3" , AV_CODEC_ID_MP3 , AVMEDIA_TYPE_AUDIO },
425 { "mpegvideo", AV_CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
429 AVInputFormat *fmt = av_probe_input_format3(pd, 1, &score);
431 if (fmt && st->request_probe <= score) {
433 av_log(s, AV_LOG_DEBUG, "Probe with size=%d, packets=%d detected %s with score=%d\n",
434 pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets, fmt->name, score);
435 for (i = 0; fmt_id_type[i].name; i++) {
436 if (!strcmp(fmt->name, fmt_id_type[i].name)) {
437 st->codec->codec_id = fmt_id_type[i].id;
438 st->codec->codec_type = fmt_id_type[i].type;
446 /************************************************************/
447 /* input media file */
449 int av_demuxer_open(AVFormatContext *ic){
452 if (ic->iformat->read_header) {
453 err = ic->iformat->read_header(ic);
458 if (ic->pb && !ic->data_offset)
459 ic->data_offset = avio_tell(ic->pb);
465 /** size of probe buffer, for guessing file type from file contents */
466 #define PROBE_BUF_MIN 2048
467 #define PROBE_BUF_MAX (1<<20)
469 int av_probe_input_buffer(AVIOContext *pb, AVInputFormat **fmt,
470 const char *filename, void *logctx,
471 unsigned int offset, unsigned int max_probe_size)
473 AVProbeData pd = { filename ? filename : "", NULL, -offset };
474 unsigned char *buf = NULL;
476 int ret = 0, probe_size, buf_offset = 0;
478 if (!max_probe_size) {
479 max_probe_size = PROBE_BUF_MAX;
480 } else if (max_probe_size > PROBE_BUF_MAX) {
481 max_probe_size = PROBE_BUF_MAX;
482 } else if (max_probe_size < PROBE_BUF_MIN) {
483 av_log(logctx, AV_LOG_ERROR,
484 "Specified probe size value %u cannot be < %u\n", max_probe_size, PROBE_BUF_MIN);
485 return AVERROR(EINVAL);
488 if (offset >= max_probe_size) {
489 return AVERROR(EINVAL);
492 if (!*fmt && pb->av_class && av_opt_get(pb, "mime_type", AV_OPT_SEARCH_CHILDREN, &mime_type) >= 0 && mime_type) {
493 if (!av_strcasecmp(mime_type, "audio/aacp")) {
494 *fmt = av_find_input_format("aac");
496 av_freep(&mime_type);
499 for(probe_size= PROBE_BUF_MIN; probe_size<=max_probe_size && !*fmt;
500 probe_size = FFMIN(probe_size<<1, FFMAX(max_probe_size, probe_size+1))) {
501 int score = probe_size < max_probe_size ? AVPROBE_SCORE_RETRY : 0;
504 if (probe_size < offset) {
508 /* read probe data */
509 buftmp = av_realloc(buf, probe_size + AVPROBE_PADDING_SIZE);
512 return AVERROR(ENOMEM);
515 if ((ret = avio_read(pb, buf + buf_offset, probe_size - buf_offset)) < 0) {
516 /* fail if error was not end of file, otherwise, lower score */
517 if (ret != AVERROR_EOF) {
522 ret = 0; /* error was end of file, nothing read */
524 pd.buf_size = buf_offset += ret;
525 pd.buf = &buf[offset];
527 memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE);
529 /* guess file format */
530 *fmt = av_probe_input_format2(&pd, 1, &score);
532 if(score <= AVPROBE_SCORE_RETRY){ //this can only be true in the last iteration
533 av_log(logctx, AV_LOG_WARNING, "Format %s detected only with low score of %d, misdetection possible!\n", (*fmt)->name, score);
535 av_log(logctx, AV_LOG_DEBUG, "Format %s probed with size=%d and score=%d\n", (*fmt)->name, probe_size, score);
541 return AVERROR_INVALIDDATA;
544 /* rewind. reuse probe buffer to avoid seeking */
545 ret = ffio_rewind_with_probe_data(pb, &buf, pd.buf_size);
550 /* open input file and probe the format if necessary */
551 static int init_input(AVFormatContext *s, const char *filename, AVDictionary **options)
554 AVProbeData pd = {filename, NULL, 0};
555 int score = AVPROBE_SCORE_RETRY;
558 s->flags |= AVFMT_FLAG_CUSTOM_IO;
560 return av_probe_input_buffer(s->pb, &s->iformat, filename, s, 0, s->probesize);
561 else if (s->iformat->flags & AVFMT_NOFILE)
562 av_log(s, AV_LOG_WARNING, "Custom AVIOContext makes no sense and "
563 "will be ignored with AVFMT_NOFILE format.\n");
567 if ( (s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
568 (!s->iformat && (s->iformat = av_probe_input_format2(&pd, 0, &score))))
571 if ((ret = avio_open2(&s->pb, filename, AVIO_FLAG_READ | s->avio_flags,
572 &s->interrupt_callback, options)) < 0)
576 return av_probe_input_buffer(s->pb, &s->iformat, filename, s, 0, s->probesize);
579 static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
580 AVPacketList **plast_pktl){
581 AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
586 (*plast_pktl)->next = pktl;
588 *packet_buffer = pktl;
590 /* add the packet in the buffered packet list */
596 int avformat_queue_attached_pictures(AVFormatContext *s)
599 for (i = 0; i < s->nb_streams; i++)
600 if (s->streams[i]->disposition & AV_DISPOSITION_ATTACHED_PIC &&
601 s->streams[i]->discard < AVDISCARD_ALL) {
602 AVPacket copy = s->streams[i]->attached_pic;
603 copy.buf = av_buffer_ref(copy.buf);
605 return AVERROR(ENOMEM);
607 add_to_pktbuf(&s->raw_packet_buffer, ©, &s->raw_packet_buffer_end);
612 int avformat_open_input(AVFormatContext **ps, const char *filename, AVInputFormat *fmt, AVDictionary **options)
614 AVFormatContext *s = *ps;
616 AVDictionary *tmp = NULL;
617 ID3v2ExtraMeta *id3v2_extra_meta = NULL;
619 if (!s && !(s = avformat_alloc_context()))
620 return AVERROR(ENOMEM);
622 av_log(NULL, AV_LOG_ERROR, "Input context has not been properly allocated by avformat_alloc_context() and is not NULL either\n");
623 return AVERROR(EINVAL);
629 av_dict_copy(&tmp, *options, 0);
631 if ((ret = av_opt_set_dict(s, &tmp)) < 0)
634 if ((ret = init_input(s, filename, &tmp)) < 0)
636 avio_skip(s->pb, s->skip_initial_bytes);
638 /* check filename in case an image number is expected */
639 if (s->iformat->flags & AVFMT_NEEDNUMBER) {
640 if (!av_filename_number_test(filename)) {
641 ret = AVERROR(EINVAL);
646 s->duration = s->start_time = AV_NOPTS_VALUE;
647 av_strlcpy(s->filename, filename ? filename : "", sizeof(s->filename));
649 /* allocate private data */
650 if (s->iformat->priv_data_size > 0) {
651 if (!(s->priv_data = av_mallocz(s->iformat->priv_data_size))) {
652 ret = AVERROR(ENOMEM);
655 if (s->iformat->priv_class) {
656 *(const AVClass**)s->priv_data = s->iformat->priv_class;
657 av_opt_set_defaults(s->priv_data);
658 if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
663 /* e.g. AVFMT_NOFILE formats will not have a AVIOContext */
665 ff_id3v2_read(s, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta);
667 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->iformat->read_header)
668 if ((ret = s->iformat->read_header(s)) < 0)
671 if (id3v2_extra_meta) {
672 if (!strcmp(s->iformat->name, "mp3") || !strcmp(s->iformat->name, "aac")) {
673 if((ret = ff_id3v2_parse_apic(s, &id3v2_extra_meta)) < 0)
676 av_log(s, AV_LOG_DEBUG, "demuxer does not support additional id3 data, skipping\n");
678 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
680 if ((ret = avformat_queue_attached_pictures(s)) < 0)
683 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->pb && !s->data_offset)
684 s->data_offset = avio_tell(s->pb);
686 s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
689 av_dict_free(options);
696 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
698 if (s->pb && !(s->flags & AVFMT_FLAG_CUSTOM_IO))
700 avformat_free_context(s);
705 /*******************************************************/
707 static void force_codec_ids(AVFormatContext *s, AVStream *st)
709 switch(st->codec->codec_type){
710 case AVMEDIA_TYPE_VIDEO:
711 if(s->video_codec_id) st->codec->codec_id= s->video_codec_id;
713 case AVMEDIA_TYPE_AUDIO:
714 if(s->audio_codec_id) st->codec->codec_id= s->audio_codec_id;
716 case AVMEDIA_TYPE_SUBTITLE:
717 if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
722 static void probe_codec(AVFormatContext *s, AVStream *st, const AVPacket *pkt)
724 if(st->request_probe>0){
725 AVProbeData *pd = &st->probe_data;
727 av_log(s, AV_LOG_DEBUG, "probing stream %d pp:%d\n", st->index, st->probe_packets);
731 uint8_t *new_buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
735 memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
736 pd->buf_size += pkt->size;
737 memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
740 st->probe_packets = 0;
742 av_log(s, AV_LOG_WARNING, "nothing to probe for stream %d\n",
747 end= s->raw_packet_buffer_remaining_size <= 0
748 || st->probe_packets<=0;
750 if(end || av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)){
751 int score= set_codec_from_probe_data(s, st, pd);
752 if( (st->codec->codec_id != AV_CODEC_ID_NONE && score > AVPROBE_SCORE_RETRY)
756 st->request_probe= -1;
757 if(st->codec->codec_id != AV_CODEC_ID_NONE){
758 av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
760 av_log(s, AV_LOG_WARNING, "probed stream %d failed\n", st->index);
762 force_codec_ids(s, st);
767 int ff_read_packet(AVFormatContext *s, AVPacket *pkt)
773 AVPacketList *pktl = s->raw_packet_buffer;
777 st = s->streams[pkt->stream_index];
778 if (s->raw_packet_buffer_remaining_size <= 0)
779 probe_codec(s, st, NULL);
780 if(st->request_probe <= 0){
781 s->raw_packet_buffer = pktl->next;
782 s->raw_packet_buffer_remaining_size += pkt->size;
791 ret= s->iformat->read_packet(s, pkt);
793 if (!pktl || ret == AVERROR(EAGAIN))
795 for (i = 0; i < s->nb_streams; i++) {
797 if (st->probe_packets) {
798 probe_codec(s, st, NULL);
800 av_assert0(st->request_probe <= 0);
805 if ((s->flags & AVFMT_FLAG_DISCARD_CORRUPT) &&
806 (pkt->flags & AV_PKT_FLAG_CORRUPT)) {
807 av_log(s, AV_LOG_WARNING,
808 "Dropped corrupted packet (stream = %d)\n",
814 if(!(s->flags & AVFMT_FLAG_KEEP_SIDE_DATA))
815 av_packet_merge_side_data(pkt);
817 if(pkt->stream_index >= (unsigned)s->nb_streams){
818 av_log(s, AV_LOG_ERROR, "Invalid stream index %d\n", pkt->stream_index);
822 st= s->streams[pkt->stream_index];
823 pkt->dts = wrap_timestamp(st, pkt->dts);
824 pkt->pts = wrap_timestamp(st, pkt->pts);
826 force_codec_ids(s, st);
828 /* TODO: audio: time filter; video: frame reordering (pts != dts) */
829 if (s->use_wallclock_as_timestamps)
830 pkt->dts = pkt->pts = av_rescale_q(av_gettime(), AV_TIME_BASE_Q, st->time_base);
832 if(!pktl && st->request_probe <= 0)
835 add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
836 s->raw_packet_buffer_remaining_size -= pkt->size;
838 probe_codec(s, st, pkt);
842 #if FF_API_READ_PACKET
843 int av_read_packet(AVFormatContext *s, AVPacket *pkt)
845 return ff_read_packet(s, pkt);
850 /**********************************************************/
852 static int determinable_frame_size(AVCodecContext *avctx)
854 if (/*avctx->codec_id == AV_CODEC_ID_AAC ||*/
855 avctx->codec_id == AV_CODEC_ID_MP1 ||
856 avctx->codec_id == AV_CODEC_ID_MP2 ||
857 avctx->codec_id == AV_CODEC_ID_MP3/* ||
858 avctx->codec_id == AV_CODEC_ID_CELT*/)
864 * Get the number of samples of an audio frame. Return -1 on error.
866 int ff_get_audio_frame_size(AVCodecContext *enc, int size, int mux)
870 /* give frame_size priority if demuxing */
871 if (!mux && enc->frame_size > 1)
872 return enc->frame_size;
874 if ((frame_size = av_get_audio_frame_duration(enc, size)) > 0)
877 /* Fall back on using frame_size if muxing. */
878 if (enc->frame_size > 1)
879 return enc->frame_size;
881 //For WMA we currently have no other means to calculate duration thus we
882 //do it here by assuming CBR, which is true for all known cases.
883 if(!mux && enc->bit_rate>0 && size>0 && enc->sample_rate>0 && enc->block_align>1) {
884 if (enc->codec_id == AV_CODEC_ID_WMAV1 || enc->codec_id == AV_CODEC_ID_WMAV2)
885 return ((int64_t)size * 8 * enc->sample_rate) / enc->bit_rate;
893 * Return the frame duration in seconds. Return 0 if not available.
895 void ff_compute_frame_duration(int *pnum, int *pden, AVStream *st,
896 AVCodecParserContext *pc, AVPacket *pkt)
902 switch(st->codec->codec_type) {
903 case AVMEDIA_TYPE_VIDEO:
904 if (st->r_frame_rate.num && !pc) {
905 *pnum = st->r_frame_rate.den;
906 *pden = st->r_frame_rate.num;
907 } else if(st->time_base.num*1000LL > st->time_base.den) {
908 *pnum = st->time_base.num;
909 *pden = st->time_base.den;
910 }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
911 *pnum = st->codec->time_base.num;
912 *pden = st->codec->time_base.den;
913 if (pc && pc->repeat_pict) {
914 if (*pnum > INT_MAX / (1 + pc->repeat_pict))
915 *pden /= 1 + pc->repeat_pict;
917 *pnum *= 1 + pc->repeat_pict;
919 //If this codec can be interlaced or progressive then we need a parser to compute duration of a packet
920 //Thus if we have no parser in such case leave duration undefined.
921 if(st->codec->ticks_per_frame>1 && !pc){
926 case AVMEDIA_TYPE_AUDIO:
927 frame_size = ff_get_audio_frame_size(st->codec, pkt->size, 0);
928 if (frame_size <= 0 || st->codec->sample_rate <= 0)
931 *pden = st->codec->sample_rate;
938 static int is_intra_only(AVCodecContext *enc){
939 const AVCodecDescriptor *desc;
941 if(enc->codec_type != AVMEDIA_TYPE_VIDEO)
944 desc = av_codec_get_codec_descriptor(enc);
946 desc = avcodec_descriptor_get(enc->codec_id);
947 av_codec_set_codec_descriptor(enc, desc);
950 return !!(desc->props & AV_CODEC_PROP_INTRA_ONLY);
954 static int has_decode_delay_been_guessed(AVStream *st)
956 if(st->codec->codec_id != AV_CODEC_ID_H264) return 1;
957 if(!st->info) // if we have left find_stream_info then nb_decoded_frames wont increase anymore for stream copy
959 #if CONFIG_H264_DECODER
960 if(st->codec->has_b_frames &&
961 avpriv_h264_has_num_reorder_frames(st->codec) == st->codec->has_b_frames)
964 if(st->codec->has_b_frames<3)
965 return st->nb_decoded_frames >= 7;
966 else if(st->codec->has_b_frames<4)
967 return st->nb_decoded_frames >= 18;
969 return st->nb_decoded_frames >= 20;
972 static AVPacketList *get_next_pkt(AVFormatContext *s, AVStream *st, AVPacketList *pktl)
976 if (pktl == s->parse_queue_end)
977 return s->packet_buffer;
981 static int update_wrap_reference(AVFormatContext *s, AVStream *st, int stream_index)
983 if (s->correct_ts_overflow && st->pts_wrap_bits < 63 &&
984 st->pts_wrap_reference == AV_NOPTS_VALUE && st->first_dts != AV_NOPTS_VALUE) {
987 // reference time stamp should be 60 s before first time stamp
988 int64_t pts_wrap_reference = st->first_dts - av_rescale(60, st->time_base.den, st->time_base.num);
989 // if first time stamp is not more than 1/8 and 60s before the wrap point, subtract rather than add wrap offset
990 int pts_wrap_behavior = (st->first_dts < (1LL<<st->pts_wrap_bits) - (1LL<<st->pts_wrap_bits-3)) ||
991 (st->first_dts < (1LL<<st->pts_wrap_bits) - av_rescale(60, st->time_base.den, st->time_base.num)) ?
992 AV_PTS_WRAP_ADD_OFFSET : AV_PTS_WRAP_SUB_OFFSET;
994 AVProgram *first_program = av_find_program_from_stream(s, NULL, stream_index);
996 if (!first_program) {
997 int default_stream_index = av_find_default_stream_index(s);
998 if (s->streams[default_stream_index]->pts_wrap_reference == AV_NOPTS_VALUE) {
999 for (i=0; i<s->nb_streams; i++) {
1000 s->streams[i]->pts_wrap_reference = pts_wrap_reference;
1001 s->streams[i]->pts_wrap_behavior = pts_wrap_behavior;
1005 st->pts_wrap_reference = s->streams[default_stream_index]->pts_wrap_reference;
1006 st->pts_wrap_behavior = s->streams[default_stream_index]->pts_wrap_behavior;
1010 AVProgram *program = first_program;
1012 if (program->pts_wrap_reference != AV_NOPTS_VALUE) {
1013 pts_wrap_reference = program->pts_wrap_reference;
1014 pts_wrap_behavior = program->pts_wrap_behavior;
1017 program = av_find_program_from_stream(s, program, stream_index);
1020 // update every program with differing pts_wrap_reference
1021 program = first_program;
1023 if (program->pts_wrap_reference != pts_wrap_reference) {
1024 for (i=0; i<program->nb_stream_indexes; i++) {
1025 s->streams[program->stream_index[i]]->pts_wrap_reference = pts_wrap_reference;
1026 s->streams[program->stream_index[i]]->pts_wrap_behavior = pts_wrap_behavior;
1029 program->pts_wrap_reference = pts_wrap_reference;
1030 program->pts_wrap_behavior = pts_wrap_behavior;
1032 program = av_find_program_from_stream(s, program, stream_index);
1040 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
1041 int64_t dts, int64_t pts, AVPacket *pkt)
1043 AVStream *st= s->streams[stream_index];
1044 AVPacketList *pktl= s->parse_queue ? s->parse_queue : s->packet_buffer;
1045 int64_t pts_buffer[MAX_REORDER_DELAY+1];
1049 if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE || is_relative(dts))
1052 delay = st->codec->has_b_frames;
1053 st->first_dts= dts - (st->cur_dts - RELATIVE_TS_BASE);
1055 shift = st->first_dts - RELATIVE_TS_BASE;
1057 for (i=0; i<MAX_REORDER_DELAY+1; i++)
1058 pts_buffer[i] = AV_NOPTS_VALUE;
1060 if (is_relative(pts))
1063 for(; pktl; pktl= get_next_pkt(s, st, pktl)){
1064 if(pktl->pkt.stream_index != stream_index)
1066 if(is_relative(pktl->pkt.pts))
1067 pktl->pkt.pts += shift;
1069 if(is_relative(pktl->pkt.dts))
1070 pktl->pkt.dts += shift;
1072 if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
1073 st->start_time= pktl->pkt.pts;
1075 if(pktl->pkt.pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY && has_decode_delay_been_guessed(st)){
1076 pts_buffer[0]= pktl->pkt.pts;
1077 for(i=0; i<delay && pts_buffer[i] > pts_buffer[i+1]; i++)
1078 FFSWAP(int64_t, pts_buffer[i], pts_buffer[i+1]);
1079 if(pktl->pkt.dts == AV_NOPTS_VALUE)
1080 pktl->pkt.dts= pts_buffer[0];
1084 if (update_wrap_reference(s, st, stream_index) && st->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET) {
1085 // correct first time stamps to negative values
1086 st->first_dts = wrap_timestamp(st, st->first_dts);
1087 st->cur_dts = wrap_timestamp(st, st->cur_dts);
1088 pkt->dts = wrap_timestamp(st, pkt->dts);
1089 pkt->pts = wrap_timestamp(st, pkt->pts);
1090 pts = wrap_timestamp(st, pts);
1093 if (st->start_time == AV_NOPTS_VALUE)
1094 st->start_time = pts;
1097 static void update_initial_durations(AVFormatContext *s, AVStream *st,
1098 int stream_index, int duration)
1100 AVPacketList *pktl= s->parse_queue ? s->parse_queue : s->packet_buffer;
1101 int64_t cur_dts= RELATIVE_TS_BASE;
1103 if(st->first_dts != AV_NOPTS_VALUE){
1104 cur_dts= st->first_dts;
1105 for(; pktl; pktl= get_next_pkt(s, st, pktl)){
1106 if(pktl->pkt.stream_index == stream_index){
1107 if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
1109 cur_dts -= duration;
1112 if(pktl && pktl->pkt.dts != st->first_dts) {
1113 av_log(s, AV_LOG_DEBUG, "first_dts %s not matching first dts %s in the queue\n", av_ts2str(st->first_dts), av_ts2str(pktl->pkt.dts));
1117 av_log(s, AV_LOG_DEBUG, "first_dts %s but no packet with dts in the queue\n", av_ts2str(st->first_dts));
1120 pktl= s->parse_queue ? s->parse_queue : s->packet_buffer;
1121 st->first_dts = cur_dts;
1122 }else if(st->cur_dts != RELATIVE_TS_BASE)
1125 for(; pktl; pktl= get_next_pkt(s, st, pktl)){
1126 if(pktl->pkt.stream_index != stream_index)
1128 if(pktl->pkt.pts == pktl->pkt.dts && (pktl->pkt.dts == AV_NOPTS_VALUE || pktl->pkt.dts == st->first_dts)
1129 && !pktl->pkt.duration){
1130 pktl->pkt.dts= cur_dts;
1131 if(!st->codec->has_b_frames)
1132 pktl->pkt.pts= cur_dts;
1133 // if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO)
1134 pktl->pkt.duration = duration;
1137 cur_dts = pktl->pkt.dts + pktl->pkt.duration;
1140 st->cur_dts= cur_dts;
1143 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
1144 AVCodecParserContext *pc, AVPacket *pkt)
1146 int num, den, presentation_delayed, delay, i;
1149 if (s->flags & AVFMT_FLAG_NOFILLIN)
1152 if((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
1153 pkt->dts= AV_NOPTS_VALUE;
1155 if (st->codec->codec_id != AV_CODEC_ID_H264 && pc && pc->pict_type == AV_PICTURE_TYPE_B)
1156 //FIXME Set low_delay = 0 when has_b_frames = 1
1157 st->codec->has_b_frames = 1;
1159 /* do we have a video B-frame ? */
1160 delay= st->codec->has_b_frames;
1161 presentation_delayed = 0;
1163 /* XXX: need has_b_frame, but cannot get it if the codec is
1166 pc && pc->pict_type != AV_PICTURE_TYPE_B)
1167 presentation_delayed = 1;
1169 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && st->pts_wrap_bits<63 && pkt->dts - (1LL<<(st->pts_wrap_bits-1)) > pkt->pts){
1170 if(is_relative(st->cur_dts) || pkt->dts - (1LL<<(st->pts_wrap_bits-1)) > st->cur_dts) {
1171 pkt->dts -= 1LL<<st->pts_wrap_bits;
1173 pkt->pts += 1LL<<st->pts_wrap_bits;
1176 // some mpeg2 in mpeg-ps lack dts (issue171 / input_file.mpg)
1177 // we take the conservative approach and discard both
1178 // Note, if this is misbehaving for a H.264 file then possibly presentation_delayed is not set correctly.
1179 if(delay==1 && pkt->dts == pkt->pts && pkt->dts != AV_NOPTS_VALUE && presentation_delayed){
1180 av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination %"PRIi64"\n", pkt->dts);
1181 if(strcmp(s->iformat->name, "mov,mp4,m4a,3gp,3g2,mj2")) // otherwise we discard correct timestamps for vc1-wmapro.ism
1182 pkt->dts= AV_NOPTS_VALUE;
1185 if (pkt->duration == 0) {
1186 ff_compute_frame_duration(&num, &den, st, pc, pkt);
1188 pkt->duration = av_rescale_rnd(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num, AV_ROUND_DOWN);
1191 if(pkt->duration != 0 && (s->packet_buffer || s->parse_queue))
1192 update_initial_durations(s, st, pkt->stream_index, pkt->duration);
1194 /* correct timestamps with byte offset if demuxers only have timestamps
1195 on packet boundaries */
1196 if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
1197 /* this will estimate bitrate based on this frame's duration and size */
1198 offset = av_rescale(pc->offset, pkt->duration, pkt->size);
1199 if(pkt->pts != AV_NOPTS_VALUE)
1201 if(pkt->dts != AV_NOPTS_VALUE)
1205 if (pc && pc->dts_sync_point >= 0) {
1206 // we have synchronization info from the parser
1207 int64_t den = st->codec->time_base.den * (int64_t) st->time_base.num;
1209 int64_t num = st->codec->time_base.num * (int64_t) st->time_base.den;
1210 if (pkt->dts != AV_NOPTS_VALUE) {
1211 // got DTS from the stream, update reference timestamp
1212 st->reference_dts = pkt->dts - pc->dts_ref_dts_delta * num / den;
1213 pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
1214 } else if (st->reference_dts != AV_NOPTS_VALUE) {
1215 // compute DTS based on reference timestamp
1216 pkt->dts = st->reference_dts + pc->dts_ref_dts_delta * num / den;
1217 pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
1219 if (pc->dts_sync_point > 0)
1220 st->reference_dts = pkt->dts; // new reference
1224 /* This may be redundant, but it should not hurt. */
1225 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
1226 presentation_delayed = 1;
1228 av_dlog(NULL, "IN delayed:%d pts:%s, dts:%s cur_dts:%s st:%d pc:%p duration:%d\n",
1229 presentation_delayed, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts), pkt->stream_index, pc, pkt->duration);
1230 /* interpolate PTS and DTS if they are not present */
1231 //We skip H264 currently because delay and has_b_frames are not reliably set
1232 if((delay==0 || (delay==1 && pc)) && st->codec->codec_id != AV_CODEC_ID_H264){
1233 if (presentation_delayed) {
1234 /* DTS = decompression timestamp */
1235 /* PTS = presentation timestamp */
1236 if (pkt->dts == AV_NOPTS_VALUE)
1237 pkt->dts = st->last_IP_pts;
1238 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1239 if (pkt->dts == AV_NOPTS_VALUE)
1240 pkt->dts = st->cur_dts;
1242 /* this is tricky: the dts must be incremented by the duration
1243 of the frame we are displaying, i.e. the last I- or P-frame */
1244 if (st->last_IP_duration == 0)
1245 st->last_IP_duration = pkt->duration;
1246 if(pkt->dts != AV_NOPTS_VALUE)
1247 st->cur_dts = pkt->dts + st->last_IP_duration;
1248 st->last_IP_duration = pkt->duration;
1249 st->last_IP_pts= pkt->pts;
1250 /* cannot compute PTS if not present (we can compute it only
1251 by knowing the future */
1252 } else if (pkt->pts != AV_NOPTS_VALUE ||
1253 pkt->dts != AV_NOPTS_VALUE ||
1255 int duration = pkt->duration;
1257 /* presentation is not delayed : PTS and DTS are the same */
1258 if (pkt->pts == AV_NOPTS_VALUE)
1259 pkt->pts = pkt->dts;
1260 update_initial_timestamps(s, pkt->stream_index, pkt->pts,
1262 if (pkt->pts == AV_NOPTS_VALUE)
1263 pkt->pts = st->cur_dts;
1264 pkt->dts = pkt->pts;
1265 if (pkt->pts != AV_NOPTS_VALUE)
1266 st->cur_dts = pkt->pts + duration;
1270 if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY && has_decode_delay_been_guessed(st)){
1271 st->pts_buffer[0]= pkt->pts;
1272 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
1273 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
1274 if(pkt->dts == AV_NOPTS_VALUE)
1275 pkt->dts= st->pts_buffer[0];
1277 if(st->codec->codec_id == AV_CODEC_ID_H264){ // we skipped it above so we try here
1278 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt); // this should happen on the first packet
1280 if(pkt->dts > st->cur_dts)
1281 st->cur_dts = pkt->dts;
1283 av_dlog(NULL, "OUTdelayed:%d/%d pts:%s, dts:%s cur_dts:%s\n",
1284 presentation_delayed, delay, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts));
1287 if (is_intra_only(st->codec))
1288 pkt->flags |= AV_PKT_FLAG_KEY;
1290 pkt->convergence_duration = pc->convergence_duration;
1293 static void free_packet_buffer(AVPacketList **pkt_buf, AVPacketList **pkt_buf_end)
1296 AVPacketList *pktl = *pkt_buf;
1297 *pkt_buf = pktl->next;
1298 av_free_packet(&pktl->pkt);
1301 *pkt_buf_end = NULL;
1305 * Parse a packet, add all split parts to parse_queue
1307 * @param pkt packet to parse, NULL when flushing the parser at end of stream
1309 static int parse_packet(AVFormatContext *s, AVPacket *pkt, int stream_index)
1311 AVPacket out_pkt = { 0 }, flush_pkt = { 0 };
1312 AVStream *st = s->streams[stream_index];
1313 uint8_t *data = pkt ? pkt->data : NULL;
1314 int size = pkt ? pkt->size : 0;
1315 int ret = 0, got_output = 0;
1318 av_init_packet(&flush_pkt);
1321 } else if (!size && st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) {
1322 // preserve 0-size sync packets
1323 compute_pkt_fields(s, st, st->parser, pkt);
1326 while (size > 0 || (pkt == &flush_pkt && got_output)) {
1329 av_init_packet(&out_pkt);
1330 len = av_parser_parse2(st->parser, st->codec,
1331 &out_pkt.data, &out_pkt.size, data, size,
1332 pkt->pts, pkt->dts, pkt->pos);
1334 pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1336 /* increment read pointer */
1340 got_output = !!out_pkt.size;
1345 if (pkt->side_data) {
1346 out_pkt.side_data = pkt->side_data;
1347 out_pkt.side_data_elems = pkt->side_data_elems;
1348 pkt->side_data = NULL;
1349 pkt->side_data_elems = 0;
1352 /* set the duration */
1353 out_pkt.duration = 0;
1354 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1355 if (st->codec->sample_rate > 0) {
1356 out_pkt.duration = av_rescale_q_rnd(st->parser->duration,
1357 (AVRational){ 1, st->codec->sample_rate },
1361 } else if (st->codec->time_base.num != 0 &&
1362 st->codec->time_base.den != 0) {
1363 out_pkt.duration = av_rescale_q_rnd(st->parser->duration,
1364 st->codec->time_base,
1369 out_pkt.stream_index = st->index;
1370 out_pkt.pts = st->parser->pts;
1371 out_pkt.dts = st->parser->dts;
1372 out_pkt.pos = st->parser->pos;
1374 if(st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1375 out_pkt.pos = st->parser->frame_offset;
1377 if (st->parser->key_frame == 1 ||
1378 (st->parser->key_frame == -1 &&
1379 st->parser->pict_type == AV_PICTURE_TYPE_I))
1380 out_pkt.flags |= AV_PKT_FLAG_KEY;
1382 if(st->parser->key_frame == -1 && st->parser->pict_type==AV_PICTURE_TYPE_NONE && (pkt->flags&AV_PKT_FLAG_KEY))
1383 out_pkt.flags |= AV_PKT_FLAG_KEY;
1385 compute_pkt_fields(s, st, st->parser, &out_pkt);
1387 if (out_pkt.data == pkt->data && out_pkt.size == pkt->size) {
1388 out_pkt.buf = pkt->buf;
1390 #if FF_API_DESTRUCT_PACKET
1391 out_pkt.destruct = pkt->destruct;
1392 pkt->destruct = NULL;
1395 if ((ret = av_dup_packet(&out_pkt)) < 0)
1398 if (!add_to_pktbuf(&s->parse_queue, &out_pkt, &s->parse_queue_end)) {
1399 av_free_packet(&out_pkt);
1400 ret = AVERROR(ENOMEM);
1406 /* end of the stream => close and free the parser */
1407 if (pkt == &flush_pkt) {
1408 av_parser_close(st->parser);
1413 av_free_packet(pkt);
1417 static int read_from_packet_buffer(AVPacketList **pkt_buffer,
1418 AVPacketList **pkt_buffer_end,
1422 av_assert0(*pkt_buffer);
1425 *pkt_buffer = pktl->next;
1427 *pkt_buffer_end = NULL;
1432 static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1434 int ret = 0, i, got_packet = 0;
1436 av_init_packet(pkt);
1438 while (!got_packet && !s->parse_queue) {
1442 /* read next packet */
1443 ret = ff_read_packet(s, &cur_pkt);
1445 if (ret == AVERROR(EAGAIN))
1447 /* flush the parsers */
1448 for(i = 0; i < s->nb_streams; i++) {
1450 if (st->parser && st->need_parsing)
1451 parse_packet(s, NULL, st->index);
1453 /* all remaining packets are now in parse_queue =>
1454 * really terminate parsing */
1458 st = s->streams[cur_pkt.stream_index];
1460 if (cur_pkt.pts != AV_NOPTS_VALUE &&
1461 cur_pkt.dts != AV_NOPTS_VALUE &&
1462 cur_pkt.pts < cur_pkt.dts) {
1463 av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%s, dts=%s, size=%d\n",
1464 cur_pkt.stream_index,
1465 av_ts2str(cur_pkt.pts),
1466 av_ts2str(cur_pkt.dts),
1469 if (s->debug & FF_FDEBUG_TS)
1470 av_log(s, AV_LOG_DEBUG, "ff_read_packet stream=%d, pts=%s, dts=%s, size=%d, duration=%d, flags=%d\n",
1471 cur_pkt.stream_index,
1472 av_ts2str(cur_pkt.pts),
1473 av_ts2str(cur_pkt.dts),
1478 if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1479 st->parser = av_parser_init(st->codec->codec_id);
1481 av_log(s, AV_LOG_VERBOSE, "parser not found for codec "
1482 "%s, packets or times may be invalid.\n",
1483 avcodec_get_name(st->codec->codec_id));
1484 /* no parser available: just output the raw packets */
1485 st->need_parsing = AVSTREAM_PARSE_NONE;
1486 } else if(st->need_parsing == AVSTREAM_PARSE_HEADERS) {
1487 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1488 } else if(st->need_parsing == AVSTREAM_PARSE_FULL_ONCE) {
1489 st->parser->flags |= PARSER_FLAG_ONCE;
1490 } else if(st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
1491 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
1495 if (!st->need_parsing || !st->parser) {
1496 /* no parsing needed: we just output the packet as is */
1498 compute_pkt_fields(s, st, NULL, pkt);
1499 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1500 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1501 ff_reduce_index(s, st->index);
1502 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1505 } else if (st->discard < AVDISCARD_ALL) {
1506 if ((ret = parse_packet(s, &cur_pkt, cur_pkt.stream_index)) < 0)
1510 av_free_packet(&cur_pkt);
1512 if (pkt->flags & AV_PKT_FLAG_KEY)
1513 st->skip_to_keyframe = 0;
1514 if (st->skip_to_keyframe) {
1515 av_free_packet(&cur_pkt);
1523 if (!got_packet && s->parse_queue)
1524 ret = read_from_packet_buffer(&s->parse_queue, &s->parse_queue_end, pkt);
1526 if(s->debug & FF_FDEBUG_TS)
1527 av_log(s, AV_LOG_DEBUG, "read_frame_internal stream=%d, pts=%s, dts=%s, size=%d, duration=%d, flags=%d\n",
1529 av_ts2str(pkt->pts),
1530 av_ts2str(pkt->dts),
1538 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1540 const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1546 ret = s->packet_buffer ?
1547 read_from_packet_buffer(&s->packet_buffer, &s->packet_buffer_end, pkt) :
1548 read_frame_internal(s, pkt);
1555 AVPacketList *pktl = s->packet_buffer;
1558 AVPacket *next_pkt = &pktl->pkt;
1560 if (next_pkt->dts != AV_NOPTS_VALUE) {
1561 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1562 // last dts seen for this stream. if any of packets following
1563 // current one had no dts, we will set this to AV_NOPTS_VALUE.
1564 int64_t last_dts = next_pkt->dts;
1565 while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1566 if (pktl->pkt.stream_index == next_pkt->stream_index &&
1567 (av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)) < 0)) {
1568 if (av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) { //not b frame
1569 next_pkt->pts = pktl->pkt.dts;
1571 if (last_dts != AV_NOPTS_VALUE) {
1572 // Once last dts was set to AV_NOPTS_VALUE, we don't change it.
1573 last_dts = pktl->pkt.dts;
1578 if (eof && next_pkt->pts == AV_NOPTS_VALUE && last_dts != AV_NOPTS_VALUE) {
1579 // Fixing the last reference frame had none pts issue (For MXF etc).
1580 // We only do this when
1582 // 2. we are not able to resolve a pts value for current packet.
1583 // 3. the packets for this stream at the end of the files had valid dts.
1584 next_pkt->pts = last_dts + next_pkt->duration;
1586 pktl = s->packet_buffer;
1589 /* read packet from packet buffer, if there is data */
1590 if (!(next_pkt->pts == AV_NOPTS_VALUE &&
1591 next_pkt->dts != AV_NOPTS_VALUE && !eof)) {
1592 ret = read_from_packet_buffer(&s->packet_buffer,
1593 &s->packet_buffer_end, pkt);
1598 ret = read_frame_internal(s, pkt);
1600 if (pktl && ret != AVERROR(EAGAIN)) {
1607 if (av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1608 &s->packet_buffer_end)) < 0)
1609 return AVERROR(ENOMEM);
1614 st = s->streams[pkt->stream_index];
1615 if (st->skip_samples) {
1616 uint8_t *p = av_packet_new_side_data(pkt, AV_PKT_DATA_SKIP_SAMPLES, 10);
1617 AV_WL32(p, st->skip_samples);
1618 av_log(s, AV_LOG_DEBUG, "demuxer injecting skip %d\n", st->skip_samples);
1619 st->skip_samples = 0;
1622 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY) {
1623 ff_reduce_index(s, st->index);
1624 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1627 if (is_relative(pkt->dts))
1628 pkt->dts -= RELATIVE_TS_BASE;
1629 if (is_relative(pkt->pts))
1630 pkt->pts -= RELATIVE_TS_BASE;
1635 /* XXX: suppress the packet queue */
1636 static void flush_packet_queue(AVFormatContext *s)
1638 free_packet_buffer(&s->parse_queue, &s->parse_queue_end);
1639 free_packet_buffer(&s->packet_buffer, &s->packet_buffer_end);
1640 free_packet_buffer(&s->raw_packet_buffer, &s->raw_packet_buffer_end);
1642 s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1645 /*******************************************************/
1648 int av_find_default_stream_index(AVFormatContext *s)
1650 int first_audio_index = -1;
1654 if (s->nb_streams <= 0)
1656 for(i = 0; i < s->nb_streams; i++) {
1658 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1659 !(st->disposition & AV_DISPOSITION_ATTACHED_PIC)) {
1662 if (first_audio_index < 0 && st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1663 first_audio_index = i;
1665 return first_audio_index >= 0 ? first_audio_index : 0;
1669 * Flush the frame reader.
1671 void ff_read_frame_flush(AVFormatContext *s)
1676 flush_packet_queue(s);
1678 /* for each stream, reset read state */
1679 for(i = 0; i < s->nb_streams; i++) {
1683 av_parser_close(st->parser);
1686 st->last_IP_pts = AV_NOPTS_VALUE;
1687 if(st->first_dts == AV_NOPTS_VALUE) st->cur_dts = RELATIVE_TS_BASE;
1688 else st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1689 st->reference_dts = AV_NOPTS_VALUE;
1691 st->probe_packets = MAX_PROBE_PACKETS;
1693 for(j=0; j<MAX_REORDER_DELAY+1; j++)
1694 st->pts_buffer[j]= AV_NOPTS_VALUE;
1698 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1702 for(i = 0; i < s->nb_streams; i++) {
1703 AVStream *st = s->streams[i];
1705 st->cur_dts = av_rescale(timestamp,
1706 st->time_base.den * (int64_t)ref_st->time_base.num,
1707 st->time_base.num * (int64_t)ref_st->time_base.den);
1711 void ff_reduce_index(AVFormatContext *s, int stream_index)
1713 AVStream *st= s->streams[stream_index];
1714 unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1716 if((unsigned)st->nb_index_entries >= max_entries){
1718 for(i=0; 2*i<st->nb_index_entries; i++)
1719 st->index_entries[i]= st->index_entries[2*i];
1720 st->nb_index_entries= i;
1724 int ff_add_index_entry(AVIndexEntry **index_entries,
1725 int *nb_index_entries,
1726 unsigned int *index_entries_allocated_size,
1727 int64_t pos, int64_t timestamp, int size, int distance, int flags)
1729 AVIndexEntry *entries, *ie;
1732 if((unsigned)*nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1735 if(timestamp == AV_NOPTS_VALUE)
1736 return AVERROR(EINVAL);
1738 if (is_relative(timestamp)) //FIXME this maintains previous behavior but we should shift by the correct offset once known
1739 timestamp -= RELATIVE_TS_BASE;
1741 entries = av_fast_realloc(*index_entries,
1742 index_entries_allocated_size,
1743 (*nb_index_entries + 1) *
1744 sizeof(AVIndexEntry));
1748 *index_entries= entries;
1750 index= ff_index_search_timestamp(*index_entries, *nb_index_entries, timestamp, AVSEEK_FLAG_ANY);
1753 index= (*nb_index_entries)++;
1754 ie= &entries[index];
1755 av_assert0(index==0 || ie[-1].timestamp < timestamp);
1757 ie= &entries[index];
1758 if(ie->timestamp != timestamp){
1759 if(ie->timestamp <= timestamp)
1761 memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(*nb_index_entries - index));
1762 (*nb_index_entries)++;
1763 }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1764 distance= ie->min_distance;
1768 ie->timestamp = timestamp;
1769 ie->min_distance= distance;
1776 int av_add_index_entry(AVStream *st,
1777 int64_t pos, int64_t timestamp, int size, int distance, int flags)
1779 timestamp = wrap_timestamp(st, timestamp);
1780 return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1781 &st->index_entries_allocated_size, pos,
1782 timestamp, size, distance, flags);
1785 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1786 int64_t wanted_timestamp, int flags)
1794 //optimize appending index entries at the end
1795 if(b && entries[b-1].timestamp < wanted_timestamp)
1800 timestamp = entries[m].timestamp;
1801 if(timestamp >= wanted_timestamp)
1803 if(timestamp <= wanted_timestamp)
1806 m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1808 if(!(flags & AVSEEK_FLAG_ANY)){
1809 while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1810 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1819 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1822 return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
1823 wanted_timestamp, flags);
1826 static int64_t ff_read_timestamp(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit,
1827 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1829 int64_t ts = read_timestamp(s, stream_index, ppos, pos_limit);
1830 if (stream_index >= 0)
1831 ts = wrap_timestamp(s->streams[stream_index], ts);
1835 int ff_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags)
1837 AVInputFormat *avif= s->iformat;
1838 int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1839 int64_t ts_min, ts_max, ts;
1844 if (stream_index < 0)
1847 av_dlog(s, "read_seek: %d %s\n", stream_index, av_ts2str(target_ts));
1850 ts_min= AV_NOPTS_VALUE;
1851 pos_limit= -1; //gcc falsely says it may be uninitialized
1853 st= s->streams[stream_index];
1854 if(st->index_entries){
1857 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()
1858 index= FFMAX(index, 0);
1859 e= &st->index_entries[index];
1861 if(e->timestamp <= target_ts || e->pos == e->min_distance){
1863 ts_min= e->timestamp;
1864 av_dlog(s, "using cached pos_min=0x%"PRIx64" dts_min=%s\n",
1865 pos_min, av_ts2str(ts_min));
1867 av_assert1(index==0);
1870 index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1871 av_assert0(index < st->nb_index_entries);
1873 e= &st->index_entries[index];
1874 av_assert1(e->timestamp >= target_ts);
1876 ts_max= e->timestamp;
1877 pos_limit= pos_max - e->min_distance;
1878 av_dlog(s, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%s\n",
1879 pos_max, pos_limit, av_ts2str(ts_max));
1883 pos= ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1888 if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
1891 ff_read_frame_flush(s);
1892 ff_update_cur_dts(s, st, ts);
1897 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
1898 int64_t pos_min, int64_t pos_max, int64_t pos_limit,
1899 int64_t ts_min, int64_t ts_max, int flags, int64_t *ts_ret,
1900 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1903 int64_t start_pos, filesize;
1906 av_dlog(s, "gen_seek: %d %s\n", stream_index, av_ts2str(target_ts));
1908 if(ts_min == AV_NOPTS_VALUE){
1909 pos_min = s->data_offset;
1910 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1911 if (ts_min == AV_NOPTS_VALUE)
1915 if(ts_min >= target_ts){
1920 if(ts_max == AV_NOPTS_VALUE){
1922 filesize = avio_size(s->pb);
1923 pos_max = filesize - 1;
1925 pos_max = FFMAX(0, pos_max - step);
1926 ts_max = ff_read_timestamp(s, stream_index, &pos_max, pos_max + step, read_timestamp);
1928 }while(ts_max == AV_NOPTS_VALUE && pos_max > 0);
1929 if (ts_max == AV_NOPTS_VALUE)
1933 int64_t tmp_pos= pos_max + 1;
1934 int64_t tmp_ts= ff_read_timestamp(s, stream_index, &tmp_pos, INT64_MAX, read_timestamp);
1935 if(tmp_ts == AV_NOPTS_VALUE)
1939 if(tmp_pos >= filesize)
1945 if(ts_max <= target_ts){
1950 if(ts_min > ts_max){
1952 }else if(ts_min == ts_max){
1957 while (pos_min < pos_limit) {
1958 av_dlog(s, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%s dts_max=%s\n",
1959 pos_min, pos_max, av_ts2str(ts_min), av_ts2str(ts_max));
1960 assert(pos_limit <= pos_max);
1963 int64_t approximate_keyframe_distance= pos_max - pos_limit;
1964 // interpolate position (better than dichotomy)
1965 pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1966 + pos_min - approximate_keyframe_distance;
1967 }else if(no_change==1){
1968 // bisection, if interpolation failed to change min or max pos last time
1969 pos = (pos_min + pos_limit)>>1;
1971 /* linear search if bisection failed, can only happen if there
1972 are very few or no keyframes between min/max */
1977 else if(pos > pos_limit)
1981 ts = ff_read_timestamp(s, stream_index, &pos, INT64_MAX, read_timestamp); //may pass pos_limit instead of -1
1986 av_dlog(s, "%"PRId64" %"PRId64" %"PRId64" / %s %s %s target:%s limit:%"PRId64" start:%"PRId64" noc:%d\n",
1987 pos_min, pos, pos_max,
1988 av_ts2str(ts_min), av_ts2str(ts), av_ts2str(ts_max), av_ts2str(target_ts),
1989 pos_limit, start_pos, no_change);
1990 if(ts == AV_NOPTS_VALUE){
1991 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1994 assert(ts != AV_NOPTS_VALUE);
1995 if (target_ts <= ts) {
1996 pos_limit = start_pos - 1;
2000 if (target_ts >= ts) {
2006 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
2007 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
2010 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2012 ts_max = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2013 av_dlog(s, "pos=0x%"PRIx64" %s<=%s<=%s\n",
2014 pos, av_ts2str(ts_min), av_ts2str(target_ts), av_ts2str(ts_max));
2020 static int seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
2021 int64_t pos_min, pos_max;
2023 pos_min = s->data_offset;
2024 pos_max = avio_size(s->pb) - 1;
2026 if (pos < pos_min) pos= pos_min;
2027 else if(pos > pos_max) pos= pos_max;
2029 avio_seek(s->pb, pos, SEEK_SET);
2031 s->io_repositioned = 1;
2036 static int seek_frame_generic(AVFormatContext *s,
2037 int stream_index, int64_t timestamp, int flags)
2044 st = s->streams[stream_index];
2046 index = av_index_search_timestamp(st, timestamp, flags);
2048 if(index < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
2051 if(index < 0 || index==st->nb_index_entries-1){
2055 if(st->nb_index_entries){
2056 av_assert0(st->index_entries);
2057 ie= &st->index_entries[st->nb_index_entries-1];
2058 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2060 ff_update_cur_dts(s, st, ie->timestamp);
2062 if ((ret = avio_seek(s->pb, s->data_offset, SEEK_SET)) < 0)
2068 read_status = av_read_frame(s, &pkt);
2069 } while (read_status == AVERROR(EAGAIN));
2070 if (read_status < 0)
2072 av_free_packet(&pkt);
2073 if(stream_index == pkt.stream_index && pkt.dts > timestamp){
2074 if(pkt.flags & AV_PKT_FLAG_KEY)
2076 if(nonkey++ > 1000 && st->codec->codec_id != AV_CODEC_ID_CDGRAPHICS){
2077 av_log(s, AV_LOG_ERROR,"seek_frame_generic failed as this stream seems to contain no keyframes after the target timestamp, %d non keyframes found\n", nonkey);
2082 index = av_index_search_timestamp(st, timestamp, flags);
2087 ff_read_frame_flush(s);
2088 if (s->iformat->read_seek){
2089 if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
2092 ie = &st->index_entries[index];
2093 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2095 ff_update_cur_dts(s, st, ie->timestamp);
2100 static int seek_frame_internal(AVFormatContext *s, int stream_index,
2101 int64_t timestamp, int flags)
2106 if (flags & AVSEEK_FLAG_BYTE) {
2107 if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
2109 ff_read_frame_flush(s);
2110 return seek_frame_byte(s, stream_index, timestamp, flags);
2113 if(stream_index < 0){
2114 stream_index= av_find_default_stream_index(s);
2115 if(stream_index < 0)
2118 st= s->streams[stream_index];
2119 /* timestamp for default must be expressed in AV_TIME_BASE units */
2120 timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
2123 /* first, we try the format specific seek */
2124 if (s->iformat->read_seek) {
2125 ff_read_frame_flush(s);
2126 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
2133 if (s->iformat->read_timestamp && !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
2134 ff_read_frame_flush(s);
2135 return ff_seek_frame_binary(s, stream_index, timestamp, flags);
2136 } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
2137 ff_read_frame_flush(s);
2138 return seek_frame_generic(s, stream_index, timestamp, flags);
2144 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
2148 if (s->iformat->read_seek2 && !s->iformat->read_seek) {
2149 int64_t min_ts = INT64_MIN, max_ts = INT64_MAX;
2150 if ((flags & AVSEEK_FLAG_BACKWARD))
2154 return avformat_seek_file(s, stream_index, min_ts, timestamp, max_ts,
2155 flags & ~AVSEEK_FLAG_BACKWARD);
2158 ret = seek_frame_internal(s, stream_index, timestamp, flags);
2161 ret = avformat_queue_attached_pictures(s);
2166 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
2168 if(min_ts > ts || max_ts < ts)
2170 if (stream_index < -1 || stream_index >= (int)s->nb_streams)
2171 return AVERROR(EINVAL);
2174 flags |= AVSEEK_FLAG_ANY;
2175 flags &= ~AVSEEK_FLAG_BACKWARD;
2177 if (s->iformat->read_seek2) {
2179 ff_read_frame_flush(s);
2181 if (stream_index == -1 && s->nb_streams == 1) {
2182 AVRational time_base = s->streams[0]->time_base;
2183 ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
2184 min_ts = av_rescale_rnd(min_ts, time_base.den,
2185 time_base.num * (int64_t)AV_TIME_BASE,
2186 AV_ROUND_UP | AV_ROUND_PASS_MINMAX);
2187 max_ts = av_rescale_rnd(max_ts, time_base.den,
2188 time_base.num * (int64_t)AV_TIME_BASE,
2189 AV_ROUND_DOWN | AV_ROUND_PASS_MINMAX);
2192 ret = s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
2195 ret = avformat_queue_attached_pictures(s);
2199 if(s->iformat->read_timestamp){
2200 //try to seek via read_timestamp()
2203 // Fall back on old API if new is not implemented but old is.
2204 // Note the old API has somewhat different semantics.
2205 if (s->iformat->read_seek || 1) {
2206 int dir = (ts - (uint64_t)min_ts > (uint64_t)max_ts - ts ? AVSEEK_FLAG_BACKWARD : 0);
2207 int ret = av_seek_frame(s, stream_index, ts, flags | dir);
2208 if (ret<0 && ts != min_ts && max_ts != ts) {
2209 ret = av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
2211 ret = av_seek_frame(s, stream_index, ts, flags | (dir^AVSEEK_FLAG_BACKWARD));
2216 // try some generic seek like seek_frame_generic() but with new ts semantics
2217 return -1; //unreachable
2220 /*******************************************************/
2223 * Return TRUE if the stream has accurate duration in any stream.
2225 * @return TRUE if the stream has accurate duration for at least one component.
2227 static int has_duration(AVFormatContext *ic)
2232 for(i = 0;i < ic->nb_streams; i++) {
2233 st = ic->streams[i];
2234 if (st->duration != AV_NOPTS_VALUE)
2237 if (ic->duration != AV_NOPTS_VALUE)
2243 * Estimate the stream timings from the one of each components.
2245 * Also computes the global bitrate if possible.
2247 static void update_stream_timings(AVFormatContext *ic)
2249 int64_t start_time, start_time1, start_time_text, end_time, end_time1;
2250 int64_t duration, duration1, filesize;
2255 start_time = INT64_MAX;
2256 start_time_text = INT64_MAX;
2257 end_time = INT64_MIN;
2258 duration = INT64_MIN;
2259 for(i = 0;i < ic->nb_streams; i++) {
2260 st = ic->streams[i];
2261 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
2262 start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
2263 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE || st->codec->codec_type == AVMEDIA_TYPE_DATA) {
2264 if (start_time1 < start_time_text)
2265 start_time_text = start_time1;
2267 start_time = FFMIN(start_time, start_time1);
2268 end_time1 = AV_NOPTS_VALUE;
2269 if (st->duration != AV_NOPTS_VALUE) {
2270 end_time1 = start_time1
2271 + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
2272 end_time = FFMAX(end_time, end_time1);
2274 for(p = NULL; (p = av_find_program_from_stream(ic, p, i)); ){
2275 if(p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1)
2276 p->start_time = start_time1;
2277 if(p->end_time < end_time1)
2278 p->end_time = end_time1;
2281 if (st->duration != AV_NOPTS_VALUE) {
2282 duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
2283 duration = FFMAX(duration, duration1);
2286 if (start_time == INT64_MAX || (start_time > start_time_text && start_time - start_time_text < AV_TIME_BASE))
2287 start_time = start_time_text;
2288 else if(start_time > start_time_text)
2289 av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);
2291 if (start_time != INT64_MAX) {
2292 ic->start_time = start_time;
2293 if (end_time != INT64_MIN) {
2294 if (ic->nb_programs) {
2295 for (i=0; i<ic->nb_programs; i++) {
2296 p = ic->programs[i];
2297 if(p->start_time != AV_NOPTS_VALUE && p->end_time > p->start_time)
2298 duration = FFMAX(duration, p->end_time - p->start_time);
2301 duration = FFMAX(duration, end_time - start_time);
2304 if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
2305 ic->duration = duration;
2307 if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration != AV_NOPTS_VALUE) {
2308 /* compute the bitrate */
2309 double bitrate = (double)filesize * 8.0 * AV_TIME_BASE /
2310 (double)ic->duration;
2311 if (bitrate >= 0 && bitrate <= INT_MAX)
2312 ic->bit_rate = bitrate;
2316 static void fill_all_stream_timings(AVFormatContext *ic)
2321 update_stream_timings(ic);
2322 for(i = 0;i < ic->nb_streams; i++) {
2323 st = ic->streams[i];
2324 if (st->start_time == AV_NOPTS_VALUE) {
2325 if(ic->start_time != AV_NOPTS_VALUE)
2326 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
2327 if(ic->duration != AV_NOPTS_VALUE)
2328 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
2333 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
2335 int64_t filesize, duration;
2336 int bit_rate, i, show_warning = 0;
2339 /* if bit_rate is already set, we believe it */
2340 if (ic->bit_rate <= 0) {
2342 for(i=0;i<ic->nb_streams;i++) {
2343 st = ic->streams[i];
2344 if (st->codec->bit_rate > 0)
2345 bit_rate += st->codec->bit_rate;
2347 ic->bit_rate = bit_rate;
2350 /* if duration is already set, we believe it */
2351 if (ic->duration == AV_NOPTS_VALUE &&
2352 ic->bit_rate != 0) {
2353 filesize = ic->pb ? avio_size(ic->pb) : 0;
2355 for(i = 0; i < ic->nb_streams; i++) {
2356 st = ic->streams[i];
2357 if ( st->time_base.num <= INT64_MAX / ic->bit_rate
2358 && st->duration == AV_NOPTS_VALUE) {
2359 duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
2360 st->duration = duration;
2367 av_log(ic, AV_LOG_WARNING, "Estimating duration from bitrate, this may be inaccurate\n");
2370 #define DURATION_MAX_READ_SIZE 250000LL
2371 #define DURATION_MAX_RETRY 4
2373 /* only usable for MPEG-PS streams */
2374 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2376 AVPacket pkt1, *pkt = &pkt1;
2378 int read_size, i, ret;
2380 int64_t filesize, offset, duration;
2383 /* flush packet queue */
2384 flush_packet_queue(ic);
2386 for (i=0; i<ic->nb_streams; i++) {
2387 st = ic->streams[i];
2388 if (st->start_time == AV_NOPTS_VALUE && st->first_dts == AV_NOPTS_VALUE)
2389 av_log(st->codec, AV_LOG_WARNING, "start time is not set in estimate_timings_from_pts\n");
2392 av_parser_close(st->parser);
2397 /* estimate the end time (duration) */
2398 /* XXX: may need to support wrapping */
2399 filesize = ic->pb ? avio_size(ic->pb) : 0;
2400 end_time = AV_NOPTS_VALUE;
2402 offset = filesize - (DURATION_MAX_READ_SIZE<<retry);
2406 avio_seek(ic->pb, offset, SEEK_SET);
2409 if (read_size >= DURATION_MAX_READ_SIZE<<(FFMAX(retry-1,0)))
2413 ret = ff_read_packet(ic, pkt);
2414 } while(ret == AVERROR(EAGAIN));
2417 read_size += pkt->size;
2418 st = ic->streams[pkt->stream_index];
2419 if (pkt->pts != AV_NOPTS_VALUE &&
2420 (st->start_time != AV_NOPTS_VALUE ||
2421 st->first_dts != AV_NOPTS_VALUE)) {
2422 duration = end_time = pkt->pts;
2423 if (st->start_time != AV_NOPTS_VALUE)
2424 duration -= st->start_time;
2426 duration -= st->first_dts;
2428 if (st->duration == AV_NOPTS_VALUE || st->info->last_duration<=0 ||
2429 (st->duration < duration && FFABS(duration - st->info->last_duration) < 60LL*st->time_base.den / st->time_base.num))
2430 st->duration = duration;
2431 st->info->last_duration = duration;
2434 av_free_packet(pkt);
2436 }while( end_time==AV_NOPTS_VALUE
2437 && filesize > (DURATION_MAX_READ_SIZE<<retry)
2438 && ++retry <= DURATION_MAX_RETRY);
2440 fill_all_stream_timings(ic);
2442 avio_seek(ic->pb, old_offset, SEEK_SET);
2443 for (i=0; i<ic->nb_streams; i++) {
2445 st->cur_dts= st->first_dts;
2446 st->last_IP_pts = AV_NOPTS_VALUE;
2447 st->reference_dts = AV_NOPTS_VALUE;
2451 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2455 /* get the file size, if possible */
2456 if (ic->iformat->flags & AVFMT_NOFILE) {
2459 file_size = avio_size(ic->pb);
2460 file_size = FFMAX(0, file_size);
2463 if ((!strcmp(ic->iformat->name, "mpeg") ||
2464 !strcmp(ic->iformat->name, "mpegts")) &&
2465 file_size && ic->pb->seekable) {
2466 /* get accurate estimate from the PTSes */
2467 estimate_timings_from_pts(ic, old_offset);
2468 ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
2469 } else if (has_duration(ic)) {
2470 /* at least one component has timings - we use them for all
2472 fill_all_stream_timings(ic);
2473 ic->duration_estimation_method = AVFMT_DURATION_FROM_STREAM;
2475 /* less precise: use bitrate info */
2476 estimate_timings_from_bit_rate(ic);
2477 ic->duration_estimation_method = AVFMT_DURATION_FROM_BITRATE;
2479 update_stream_timings(ic);
2483 AVStream av_unused *st;
2484 for(i = 0;i < ic->nb_streams; i++) {
2485 st = ic->streams[i];
2486 av_dlog(ic, "%d: start_time: %0.3f duration: %0.3f\n", i,
2487 (double) st->start_time / AV_TIME_BASE,
2488 (double) st->duration / AV_TIME_BASE);
2490 av_dlog(ic, "stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2491 (double) ic->start_time / AV_TIME_BASE,
2492 (double) ic->duration / AV_TIME_BASE,
2493 ic->bit_rate / 1000);
2497 static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
2499 AVCodecContext *avctx = st->codec;
2501 #define FAIL(errmsg) do { \
2503 *errmsg_ptr = errmsg; \
2507 switch (avctx->codec_type) {
2508 case AVMEDIA_TYPE_AUDIO:
2509 if (!avctx->frame_size && determinable_frame_size(avctx))
2510 FAIL("unspecified frame size");
2511 if (st->info->found_decoder >= 0 && avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
2512 FAIL("unspecified sample format");
2513 if (!avctx->sample_rate)
2514 FAIL("unspecified sample rate");
2515 if (!avctx->channels)
2516 FAIL("unspecified number of channels");
2517 if (st->info->found_decoder >= 0 && !st->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
2518 FAIL("no decodable DTS frames");
2520 case AVMEDIA_TYPE_VIDEO:
2522 FAIL("unspecified size");
2523 if (st->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
2524 FAIL("unspecified pixel format");
2525 if (st->codec->codec_id == AV_CODEC_ID_RV30 || st->codec->codec_id == AV_CODEC_ID_RV40)
2526 if (!st->sample_aspect_ratio.num && !st->codec->sample_aspect_ratio.num && !st->codec_info_nb_frames)
2527 FAIL("no frame in rv30/40 and no sar");
2529 case AVMEDIA_TYPE_SUBTITLE:
2530 if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
2531 FAIL("unspecified size");
2533 case AVMEDIA_TYPE_DATA:
2534 if(avctx->codec_id == AV_CODEC_ID_NONE) return 1;
2537 if (avctx->codec_id == AV_CODEC_ID_NONE)
2538 FAIL("unknown codec");
2542 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
2543 static int try_decode_frame(AVStream *st, AVPacket *avpkt, AVDictionary **options)
2545 const AVCodec *codec;
2546 int got_picture = 1, ret = 0;
2547 AVFrame *frame = avcodec_alloc_frame();
2548 AVSubtitle subtitle;
2549 AVPacket pkt = *avpkt;
2552 return AVERROR(ENOMEM);
2554 if (!avcodec_is_open(st->codec) && !st->info->found_decoder) {
2555 AVDictionary *thread_opt = NULL;
2557 codec = st->codec->codec ? st->codec->codec :
2558 avcodec_find_decoder(st->codec->codec_id);
2561 st->info->found_decoder = -1;
2566 /* force thread count to 1 since the h264 decoder will not extract SPS
2567 * and PPS to extradata during multi-threaded decoding */
2568 av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
2569 ret = avcodec_open2(st->codec, codec, options ? options : &thread_opt);
2571 av_dict_free(&thread_opt);
2573 st->info->found_decoder = -1;
2576 st->info->found_decoder = 1;
2577 } else if (!st->info->found_decoder)
2578 st->info->found_decoder = 1;
2580 if (st->info->found_decoder < 0) {
2585 while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
2587 (!has_codec_parameters(st, NULL) ||
2588 !has_decode_delay_been_guessed(st) ||
2589 (!st->codec_info_nb_frames && st->codec->codec->capabilities & CODEC_CAP_CHANNEL_CONF))) {
2591 avcodec_get_frame_defaults(frame);
2592 switch(st->codec->codec_type) {
2593 case AVMEDIA_TYPE_VIDEO:
2594 ret = avcodec_decode_video2(st->codec, frame,
2595 &got_picture, &pkt);
2597 case AVMEDIA_TYPE_AUDIO:
2598 ret = avcodec_decode_audio4(st->codec, frame, &got_picture, &pkt);
2600 case AVMEDIA_TYPE_SUBTITLE:
2601 ret = avcodec_decode_subtitle2(st->codec, &subtitle,
2602 &got_picture, &pkt);
2610 st->nb_decoded_frames++;
2617 if(!pkt.data && !got_picture)
2621 avcodec_free_frame(&frame);
2625 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
2627 while (tags->id != AV_CODEC_ID_NONE) {
2635 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2638 for(i=0; tags[i].id != AV_CODEC_ID_NONE;i++) {
2639 if(tag == tags[i].tag)
2642 for(i=0; tags[i].id != AV_CODEC_ID_NONE; i++) {
2643 if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
2646 return AV_CODEC_ID_NONE;
2649 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
2653 case 32: return be ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;
2654 case 64: return be ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE;
2655 default: return AV_CODEC_ID_NONE;
2660 if (sflags & (1 << (bps - 1))) {
2662 case 1: return AV_CODEC_ID_PCM_S8;
2663 case 2: return be ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;
2664 case 3: return be ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
2665 case 4: return be ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
2666 default: return AV_CODEC_ID_NONE;
2670 case 1: return AV_CODEC_ID_PCM_U8;
2671 case 2: return be ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE;
2672 case 3: return be ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE;
2673 case 4: return be ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE;
2674 default: return AV_CODEC_ID_NONE;
2680 unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum AVCodecID id)
2683 if (!av_codec_get_tag2(tags, id, &tag))
2688 int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
2692 for(i=0; tags && tags[i]; i++){
2693 const AVCodecTag *codec_tags = tags[i];
2694 while (codec_tags->id != AV_CODEC_ID_NONE) {
2695 if (codec_tags->id == id) {
2696 *tag = codec_tags->tag;
2705 enum AVCodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
2708 for(i=0; tags && tags[i]; i++){
2709 enum AVCodecID id= ff_codec_get_id(tags[i], tag);
2710 if(id!=AV_CODEC_ID_NONE) return id;
2712 return AV_CODEC_ID_NONE;
2715 static void compute_chapters_end(AVFormatContext *s)
2718 int64_t max_time = s->duration + ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
2720 for (i = 0; i < s->nb_chapters; i++)
2721 if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2722 AVChapter *ch = s->chapters[i];
2723 int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q, ch->time_base)
2726 for (j = 0; j < s->nb_chapters; j++) {
2727 AVChapter *ch1 = s->chapters[j];
2728 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base, ch->time_base);
2729 if (j != i && next_start > ch->start && next_start < end)
2732 ch->end = (end == INT64_MAX) ? ch->start : end;
2736 static int get_std_framerate(int i){
2737 if(i<60*12) return (i+1)*1001;
2738 else return ((const int[]){24,30,60,12,15,48})[i-60*12]*1000*12;
2742 * Is the time base unreliable.
2743 * This is a heuristic to balance between quick acceptance of the values in
2744 * the headers vs. some extra checks.
2745 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2746 * MPEG-2 commonly misuses field repeat flags to store different framerates.
2747 * And there are "variable" fps files this needs to detect as well.
2749 static int tb_unreliable(AVCodecContext *c){
2750 if( c->time_base.den >= 101L*c->time_base.num
2751 || c->time_base.den < 5L*c->time_base.num
2752 /* || c->codec_tag == AV_RL32("DIVX")
2753 || c->codec_tag == AV_RL32("XVID")*/
2754 || c->codec_tag == AV_RL32("mp4v")
2755 || c->codec_id == AV_CODEC_ID_MPEG2VIDEO
2756 || c->codec_id == AV_CODEC_ID_H264
2762 #if FF_API_FORMAT_PARAMETERS
2763 int av_find_stream_info(AVFormatContext *ic)
2765 return avformat_find_stream_info(ic, NULL);
2769 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
2771 int i, count, ret, j;
2774 AVPacket pkt1, *pkt;
2775 int64_t old_offset = avio_tell(ic->pb);
2776 int orig_nb_streams = ic->nb_streams; // new streams might appear, no options for those
2777 int flush_codecs = ic->probesize > 0;
2780 av_log(ic, AV_LOG_DEBUG, "File position before avformat_find_stream_info() is %"PRId64"\n", avio_tell(ic->pb));
2782 for(i=0;i<ic->nb_streams;i++) {
2783 const AVCodec *codec;
2784 AVDictionary *thread_opt = NULL;
2785 st = ic->streams[i];
2787 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2788 st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2789 /* if(!st->time_base.num)
2791 if(!st->codec->time_base.num)
2792 st->codec->time_base= st->time_base;
2794 //only for the split stuff
2795 if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
2796 st->parser = av_parser_init(st->codec->codec_id);
2798 if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
2799 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2800 } else if(st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
2801 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
2803 } else if (st->need_parsing) {
2804 av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
2805 "%s, packets or times may be invalid.\n",
2806 avcodec_get_name(st->codec->codec_id));
2809 codec = st->codec->codec ? st->codec->codec :
2810 avcodec_find_decoder(st->codec->codec_id);
2812 /* force thread count to 1 since the h264 decoder will not extract SPS
2813 * and PPS to extradata during multi-threaded decoding */
2814 av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
2816 /* Ensure that subtitle_header is properly set. */
2817 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
2818 && codec && !st->codec->codec)
2819 avcodec_open2(st->codec, codec, options ? &options[i]
2822 //try to just open decoders, in case this is enough to get parameters
2823 if (!has_codec_parameters(st, NULL) && st->request_probe <= 0) {
2824 if (codec && !st->codec->codec)
2825 avcodec_open2(st->codec, codec, options ? &options[i]
2829 av_dict_free(&thread_opt);
2832 for (i=0; i<ic->nb_streams; i++) {
2833 #if FF_API_R_FRAME_RATE
2834 ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
2836 ic->streams[i]->info->fps_first_dts = AV_NOPTS_VALUE;
2837 ic->streams[i]->info->fps_last_dts = AV_NOPTS_VALUE;
2843 if (ff_check_interrupt(&ic->interrupt_callback)){
2845 av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2849 /* check if one codec still needs to be handled */
2850 for(i=0;i<ic->nb_streams;i++) {
2851 int fps_analyze_framecount = 20;
2853 st = ic->streams[i];
2854 if (!has_codec_parameters(st, NULL))
2856 /* if the timebase is coarse (like the usual millisecond precision
2857 of mkv), we need to analyze more frames to reliably arrive at
2859 if (av_q2d(st->time_base) > 0.0005)
2860 fps_analyze_framecount *= 2;
2861 if (ic->fps_probe_size >= 0)
2862 fps_analyze_framecount = ic->fps_probe_size;
2863 if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
2864 fps_analyze_framecount = 0;
2865 /* variable fps and no guess at the real fps */
2866 if( tb_unreliable(st->codec) && !(st->r_frame_rate.num && st->avg_frame_rate.num)
2867 && st->info->duration_count < fps_analyze_framecount
2868 && st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2870 if(st->parser && st->parser->parser->split && !st->codec->extradata)
2872 if (st->first_dts == AV_NOPTS_VALUE &&
2873 (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2874 st->codec->codec_type == AVMEDIA_TYPE_AUDIO))
2877 if (i == ic->nb_streams) {
2878 /* NOTE: if the format has no header, then we need to read
2879 some packets to get most of the streams, so we cannot
2881 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2882 /* if we found the info for all the codecs, we can stop */
2884 av_log(ic, AV_LOG_DEBUG, "All info found\n");
2889 /* we did not get all the codec info, but we read too much data */
2890 if (read_size >= ic->probesize) {
2892 av_log(ic, AV_LOG_DEBUG, "Probe buffer size limit of %d bytes reached\n", ic->probesize);
2893 for (i = 0; i < ic->nb_streams; i++)
2894 if (!ic->streams[i]->r_frame_rate.num &&
2895 ic->streams[i]->info->duration_count <= 1)
2896 av_log(ic, AV_LOG_WARNING,
2897 "Stream #%d: not enough frames to estimate rate; "
2898 "consider increasing probesize\n", i);
2902 /* NOTE: a new stream can be added there if no header in file
2903 (AVFMTCTX_NOHEADER) */
2904 ret = read_frame_internal(ic, &pkt1);
2905 if (ret == AVERROR(EAGAIN))
2913 if (ic->flags & AVFMT_FLAG_NOBUFFER) {
2916 pkt = add_to_pktbuf(&ic->packet_buffer, &pkt1,
2917 &ic->packet_buffer_end);
2918 if ((ret = av_dup_packet(pkt)) < 0)
2919 goto find_stream_info_err;
2922 read_size += pkt->size;
2924 st = ic->streams[pkt->stream_index];
2925 if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
2926 /* check for non-increasing dts */
2927 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
2928 st->info->fps_last_dts >= pkt->dts) {
2929 av_log(ic, AV_LOG_DEBUG, "Non-increasing DTS in stream %d: "
2930 "packet %d with DTS %"PRId64", packet %d with DTS "
2931 "%"PRId64"\n", st->index, st->info->fps_last_dts_idx,
2932 st->info->fps_last_dts, st->codec_info_nb_frames, pkt->dts);
2933 st->info->fps_first_dts = st->info->fps_last_dts = AV_NOPTS_VALUE;
2935 /* check for a discontinuity in dts - if the difference in dts
2936 * is more than 1000 times the average packet duration in the sequence,
2937 * we treat it as a discontinuity */
2938 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
2939 st->info->fps_last_dts_idx > st->info->fps_first_dts_idx &&
2940 (pkt->dts - st->info->fps_last_dts) / 1000 >
2941 (st->info->fps_last_dts - st->info->fps_first_dts) / (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
2942 av_log(ic, AV_LOG_WARNING, "DTS discontinuity in stream %d: "
2943 "packet %d with DTS %"PRId64", packet %d with DTS "
2944 "%"PRId64"\n", st->index, st->info->fps_last_dts_idx,
2945 st->info->fps_last_dts, st->codec_info_nb_frames, pkt->dts);
2946 st->info->fps_first_dts = st->info->fps_last_dts = AV_NOPTS_VALUE;
2949 /* update stored dts values */
2950 if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
2951 st->info->fps_first_dts = pkt->dts;
2952 st->info->fps_first_dts_idx = st->codec_info_nb_frames;
2954 st->info->fps_last_dts = pkt->dts;
2955 st->info->fps_last_dts_idx = st->codec_info_nb_frames;
2957 if (st->codec_info_nb_frames>1) {
2959 if (st->time_base.den > 0)
2960 t = av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
2961 if (st->avg_frame_rate.num > 0)
2962 t = FFMAX(t, av_rescale_q(st->codec_info_nb_frames, av_inv_q(st->avg_frame_rate), AV_TIME_BASE_Q));
2964 if (t >= ic->max_analyze_duration) {
2965 av_log(ic, AV_LOG_WARNING, "max_analyze_duration %d reached at %"PRId64" microseconds\n", ic->max_analyze_duration, t);
2968 if (pkt->duration) {
2969 st->info->codec_info_duration += pkt->duration;
2970 st->info->codec_info_duration_fields += st->parser && st->codec->ticks_per_frame==2 ? st->parser->repeat_pict + 1 : 2;
2973 #if FF_API_R_FRAME_RATE
2975 int64_t last = st->info->last_dts;
2977 if( pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && pkt->dts > last
2978 && pkt->dts - (uint64_t)last < INT64_MAX){
2979 double dts= (is_relative(pkt->dts) ? pkt->dts - RELATIVE_TS_BASE : pkt->dts) * av_q2d(st->time_base);
2980 int64_t duration= pkt->dts - last;
2982 if (!st->info->duration_error)
2983 st->info->duration_error = av_mallocz(sizeof(st->info->duration_error[0])*2);
2985 // if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2986 // av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
2987 for (i=0; i<MAX_STD_TIMEBASES; i++) {
2988 int framerate= get_std_framerate(i);
2989 double sdts= dts*framerate/(1001*12);
2991 int64_t ticks= llrint(sdts+j*0.5);
2992 double error= sdts - ticks + j*0.5;
2993 st->info->duration_error[j][0][i] += error;
2994 st->info->duration_error[j][1][i] += error*error;
2997 st->info->duration_count++;
2998 // ignore the first 4 values, they might have some random jitter
2999 if (st->info->duration_count > 3 && is_relative(pkt->dts) == is_relative(last))
3000 st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
3002 if (pkt->dts != AV_NOPTS_VALUE)
3003 st->info->last_dts = pkt->dts;
3006 if(st->parser && st->parser->parser->split && !st->codec->extradata){
3007 int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
3008 if (i > 0 && i < FF_MAX_EXTRADATA_SIZE) {
3009 st->codec->extradata_size= i;
3010 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
3011 if (!st->codec->extradata)
3012 return AVERROR(ENOMEM);
3013 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
3014 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
3018 /* if still no information, we try to open the codec and to
3019 decompress the frame. We try to avoid that in most cases as
3020 it takes longer and uses more memory. For MPEG-4, we need to
3021 decompress for QuickTime.
3023 If CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
3024 least one frame of codec data, this makes sure the codec initializes
3025 the channel configuration and does not only trust the values from the container.
3027 try_decode_frame(st, pkt, (options && i < orig_nb_streams ) ? &options[i] : NULL);
3029 st->codec_info_nb_frames++;
3034 AVPacket empty_pkt = { 0 };
3036 av_init_packet(&empty_pkt);
3038 ret = -1; /* we could not have all the codec parameters before EOF */
3039 for(i=0;i<ic->nb_streams;i++) {
3042 st = ic->streams[i];
3044 /* flush the decoders */
3045 if (st->info->found_decoder == 1) {
3047 err = try_decode_frame(st, &empty_pkt,
3048 (options && i < orig_nb_streams) ?
3049 &options[i] : NULL);
3050 } while (err > 0 && !has_codec_parameters(st, NULL));
3053 av_log(ic, AV_LOG_INFO,
3054 "decoding for stream %d failed\n", st->index);
3058 if (!has_codec_parameters(st, &errmsg)) {
3060 avcodec_string(buf, sizeof(buf), st->codec, 0);
3061 av_log(ic, AV_LOG_WARNING,
3062 "Could not find codec parameters for stream %d (%s): %s\n"
3063 "Consider increasing the value for the 'analyzeduration' and 'probesize' options\n",
3071 // close codecs which were opened in try_decode_frame()
3072 for(i=0;i<ic->nb_streams;i++) {
3073 st = ic->streams[i];
3074 avcodec_close(st->codec);
3076 for(i=0;i<ic->nb_streams;i++) {
3077 st = ic->streams[i];
3078 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
3079 if(st->codec->codec_id == AV_CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample){
3080 uint32_t tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
3081 if (avpriv_find_pix_fmt(ff_raw_pix_fmt_tags, tag) == st->codec->pix_fmt)
3082 st->codec->codec_tag= tag;
3085 /* estimate average framerate if not set by demuxer */
3086 if (st->info->codec_info_duration_fields && !st->avg_frame_rate.num && st->info->codec_info_duration) {
3088 double best_error = 0.01;
3090 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3091 st->info->codec_info_duration_fields*(int64_t)st->time_base.den,
3092 st->info->codec_info_duration*2*(int64_t)st->time_base.num, 60000);
3094 /* round guessed framerate to a "standard" framerate if it's
3095 * within 1% of the original estimate*/
3096 for (j = 1; j < MAX_STD_TIMEBASES; j++) {
3097 AVRational std_fps = { get_std_framerate(j), 12*1001 };
3098 double error = fabs(av_q2d(st->avg_frame_rate) / av_q2d(std_fps) - 1);
3100 if (error < best_error) {
3102 best_fps = std_fps.num;
3106 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3107 best_fps, 12*1001, INT_MAX);
3110 // the check for tb_unreliable() is not completely correct, since this is not about handling
3111 // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
3112 // ipmovie.c produces.
3113 if (tb_unreliable(st->codec) && st->info->duration_count > 15 && st->info->duration_gcd > FFMAX(1, st->time_base.den/(500LL*st->time_base.num)) && !st->r_frame_rate.num)
3114 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, st->time_base.den, st->time_base.num * st->info->duration_gcd, INT_MAX);
3115 if (st->info->duration_count>1 && !st->r_frame_rate.num
3116 && tb_unreliable(st->codec)) {
3118 double best_error= 0.01;
3120 for (j=0; j<MAX_STD_TIMEBASES; j++) {
3123 if(st->info->codec_info_duration && st->info->codec_info_duration*av_q2d(st->time_base) < (1001*12.0)/get_std_framerate(j))
3125 if(!st->info->codec_info_duration && 1.0 < (1001*12.0)/get_std_framerate(j))
3128 int n= st->info->duration_count;
3129 double a= st->info->duration_error[k][0][j] / n;
3130 double error= st->info->duration_error[k][1][j]/n - a*a;
3132 if(error < best_error && best_error> 0.000000001){
3134 num = get_std_framerate(j);
3137 av_log(NULL, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
3140 // do not increase frame rate by more than 1 % in order to match a standard rate.
3141 if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
3142 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
3145 if (!st->r_frame_rate.num){
3146 if( st->codec->time_base.den * (int64_t)st->time_base.num
3147 <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
3148 st->r_frame_rate.num = st->codec->time_base.den;
3149 st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
3151 st->r_frame_rate.num = st->time_base.den;
3152 st->r_frame_rate.den = st->time_base.num;
3155 }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
3156 if(!st->codec->bits_per_coded_sample)
3157 st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
3158 // set stream disposition based on audio service type
3159 switch (st->codec->audio_service_type) {
3160 case AV_AUDIO_SERVICE_TYPE_EFFECTS:
3161 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS; break;
3162 case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
3163 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED; break;
3164 case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
3165 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED; break;
3166 case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
3167 st->disposition = AV_DISPOSITION_COMMENT; break;
3168 case AV_AUDIO_SERVICE_TYPE_KARAOKE:
3169 st->disposition = AV_DISPOSITION_KARAOKE; break;
3175 estimate_timings(ic, old_offset);
3177 compute_chapters_end(ic);
3179 find_stream_info_err:
3180 for (i=0; i < ic->nb_streams; i++) {
3181 st = ic->streams[i];
3182 if (ic->streams[i]->codec)
3183 ic->streams[i]->codec->thread_count = 0;
3185 av_freep(&st->info->duration_error);
3186 av_freep(&ic->streams[i]->info);
3189 av_log(ic, AV_LOG_DEBUG, "File position after avformat_find_stream_info() is %"PRId64"\n", avio_tell(ic->pb));
3193 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
3197 for (i = 0; i < ic->nb_programs; i++) {
3198 if (ic->programs[i] == last) {
3202 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
3203 if (ic->programs[i]->stream_index[j] == s)
3204 return ic->programs[i];
3210 int av_find_best_stream(AVFormatContext *ic,
3211 enum AVMediaType type,
3212 int wanted_stream_nb,
3214 AVCodec **decoder_ret,
3217 int i, nb_streams = ic->nb_streams;
3218 int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1, best_bitrate = -1, best_multiframe = -1, count, bitrate, multiframe;
3219 unsigned *program = NULL;
3220 AVCodec *decoder = NULL, *best_decoder = NULL;
3222 if (related_stream >= 0 && wanted_stream_nb < 0) {
3223 AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
3225 program = p->stream_index;
3226 nb_streams = p->nb_stream_indexes;
3229 for (i = 0; i < nb_streams; i++) {
3230 int real_stream_index = program ? program[i] : i;
3231 AVStream *st = ic->streams[real_stream_index];
3232 AVCodecContext *avctx = st->codec;
3233 if (avctx->codec_type != type)
3235 if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
3237 if (st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED|AV_DISPOSITION_VISUAL_IMPAIRED))
3240 decoder = avcodec_find_decoder(st->codec->codec_id);
3243 ret = AVERROR_DECODER_NOT_FOUND;
3247 count = st->codec_info_nb_frames;
3248 bitrate = avctx->bit_rate;
3249 multiframe = FFMIN(5, count);
3250 if ((best_multiframe > multiframe) ||
3251 (best_multiframe == multiframe && best_bitrate > bitrate) ||
3252 (best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
3255 best_bitrate = bitrate;
3256 best_multiframe = multiframe;
3257 ret = real_stream_index;
3258 best_decoder = decoder;
3259 if (program && i == nb_streams - 1 && ret < 0) {
3261 nb_streams = ic->nb_streams;
3262 i = 0; /* no related stream found, try again with everything */
3266 *decoder_ret = best_decoder;
3270 /*******************************************************/
3272 int av_read_play(AVFormatContext *s)
3274 if (s->iformat->read_play)
3275 return s->iformat->read_play(s);
3277 return avio_pause(s->pb, 0);
3278 return AVERROR(ENOSYS);
3281 int av_read_pause(AVFormatContext *s)
3283 if (s->iformat->read_pause)
3284 return s->iformat->read_pause(s);
3286 return avio_pause(s->pb, 1);
3287 return AVERROR(ENOSYS);
3290 void ff_free_stream(AVFormatContext *s, AVStream *st){
3291 av_assert0(s->nb_streams>0);
3292 av_assert0(s->streams[ s->nb_streams-1 ] == st);
3295 av_parser_close(st->parser);
3297 if (st->attached_pic.data)
3298 av_free_packet(&st->attached_pic);
3299 av_dict_free(&st->metadata);
3300 av_freep(&st->probe_data.buf);
3301 av_freep(&st->index_entries);
3302 av_freep(&st->codec->extradata);
3303 av_freep(&st->codec->subtitle_header);
3304 av_freep(&st->codec);
3305 av_freep(&st->priv_data);
3307 av_freep(&st->info->duration_error);
3308 av_freep(&st->info);
3309 av_freep(&s->streams[ --s->nb_streams ]);
3312 void avformat_free_context(AVFormatContext *s)
3320 if (s->iformat && s->iformat->priv_class && s->priv_data)
3321 av_opt_free(s->priv_data);
3323 for(i=s->nb_streams-1; i>=0; i--) {
3324 ff_free_stream(s, s->streams[i]);
3326 for(i=s->nb_programs-1; i>=0; i--) {
3327 av_dict_free(&s->programs[i]->metadata);
3328 av_freep(&s->programs[i]->stream_index);
3329 av_freep(&s->programs[i]);
3331 av_freep(&s->programs);
3332 av_freep(&s->priv_data);
3333 while(s->nb_chapters--) {
3334 av_dict_free(&s->chapters[s->nb_chapters]->metadata);
3335 av_freep(&s->chapters[s->nb_chapters]);
3337 av_freep(&s->chapters);
3338 av_dict_free(&s->metadata);
3339 av_freep(&s->streams);
3343 #if FF_API_CLOSE_INPUT_FILE
3344 void av_close_input_file(AVFormatContext *s)
3346 avformat_close_input(&s);
3350 void avformat_close_input(AVFormatContext **ps)
3352 AVFormatContext *s = *ps;
3353 AVIOContext *pb = s->pb;
3355 if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
3356 (s->flags & AVFMT_FLAG_CUSTOM_IO))
3359 flush_packet_queue(s);
3362 if (s->iformat->read_close)
3363 s->iformat->read_close(s);
3366 avformat_free_context(s);
3373 #if FF_API_NEW_STREAM
3374 AVStream *av_new_stream(AVFormatContext *s, int id)
3376 AVStream *st = avformat_new_stream(s, NULL);
3383 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
3389 if (s->nb_streams >= INT_MAX/sizeof(*streams))
3391 streams = av_realloc(s->streams, (s->nb_streams + 1) * sizeof(*streams));
3394 s->streams = streams;
3396 st = av_mallocz(sizeof(AVStream));
3399 if (!(st->info = av_mallocz(sizeof(*st->info)))) {
3403 st->info->last_dts = AV_NOPTS_VALUE;
3405 st->codec = avcodec_alloc_context3(c);
3407 /* no default bitrate if decoding */
3408 st->codec->bit_rate = 0;
3410 st->index = s->nb_streams;
3411 st->start_time = AV_NOPTS_VALUE;
3412 st->duration = AV_NOPTS_VALUE;
3413 /* we set the current DTS to 0 so that formats without any timestamps
3414 but durations get some timestamps, formats with some unknown
3415 timestamps have their first few packets buffered and the
3416 timestamps corrected before they are returned to the user */
3417 st->cur_dts = s->iformat ? RELATIVE_TS_BASE : 0;
3418 st->first_dts = AV_NOPTS_VALUE;
3419 st->probe_packets = MAX_PROBE_PACKETS;
3420 st->pts_wrap_reference = AV_NOPTS_VALUE;
3421 st->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3423 /* default pts setting is MPEG-like */
3424 avpriv_set_pts_info(st, 33, 1, 90000);
3425 st->last_IP_pts = AV_NOPTS_VALUE;
3426 for(i=0; i<MAX_REORDER_DELAY+1; i++)
3427 st->pts_buffer[i]= AV_NOPTS_VALUE;
3428 st->reference_dts = AV_NOPTS_VALUE;
3430 st->sample_aspect_ratio = (AVRational){0,1};
3432 #if FF_API_R_FRAME_RATE
3433 st->info->last_dts = AV_NOPTS_VALUE;
3435 st->info->fps_first_dts = AV_NOPTS_VALUE;
3436 st->info->fps_last_dts = AV_NOPTS_VALUE;
3438 s->streams[s->nb_streams++] = st;
3442 AVProgram *av_new_program(AVFormatContext *ac, int id)
3444 AVProgram *program=NULL;
3447 av_dlog(ac, "new_program: id=0x%04x\n", id);
3449 for(i=0; i<ac->nb_programs; i++)
3450 if(ac->programs[i]->id == id)
3451 program = ac->programs[i];
3454 program = av_mallocz(sizeof(AVProgram));
3457 dynarray_add(&ac->programs, &ac->nb_programs, program);
3458 program->discard = AVDISCARD_NONE;
3461 program->pts_wrap_reference = AV_NOPTS_VALUE;
3462 program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3464 program->start_time =
3465 program->end_time = AV_NOPTS_VALUE;
3470 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
3472 AVChapter *chapter = NULL;
3475 for(i=0; i<s->nb_chapters; i++)
3476 if(s->chapters[i]->id == id)
3477 chapter = s->chapters[i];
3480 chapter= av_mallocz(sizeof(AVChapter));
3483 dynarray_add(&s->chapters, &s->nb_chapters, chapter);
3485 av_dict_set(&chapter->metadata, "title", title, 0);
3487 chapter->time_base= time_base;
3488 chapter->start = start;
3494 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
3497 AVProgram *program=NULL;
3500 if (idx >= ac->nb_streams) {
3501 av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3505 for(i=0; i<ac->nb_programs; i++){
3506 if(ac->programs[i]->id != progid)
3508 program = ac->programs[i];
3509 for(j=0; j<program->nb_stream_indexes; j++)
3510 if(program->stream_index[j] == idx)
3513 tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
3516 program->stream_index = tmp;
3517 program->stream_index[program->nb_stream_indexes++] = idx;
3522 static void print_fps(double d, const char *postfix){
3523 uint64_t v= lrintf(d*100);
3524 if (v% 100 ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3525 else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3526 else av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
3529 static void dump_metadata(void *ctx, AVDictionary *m, const char *indent)
3531 if(m && !(av_dict_count(m) == 1 && av_dict_get(m, "language", NULL, 0))){
3532 AVDictionaryEntry *tag=NULL;
3534 av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3535 while((tag=av_dict_get(m, "", tag, AV_DICT_IGNORE_SUFFIX))) {
3536 if(strcmp("language", tag->key)){
3537 const char *p = tag->value;
3538 av_log(ctx, AV_LOG_INFO, "%s %-16s: ", indent, tag->key);
3541 size_t len = strcspn(p, "\x8\xa\xb\xc\xd");
3542 av_strlcpy(tmp, p, FFMIN(sizeof(tmp), len+1));
3543 av_log(ctx, AV_LOG_INFO, "%s", tmp);
3545 if (*p == 0xd) av_log(ctx, AV_LOG_INFO, " ");
3546 if (*p == 0xa) av_log(ctx, AV_LOG_INFO, "\n%s %-16s: ", indent, "");
3549 av_log(ctx, AV_LOG_INFO, "\n");
3555 /* "user interface" functions */
3556 static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
3559 int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
3560 AVStream *st = ic->streams[i];
3561 int g = av_gcd(st->time_base.num, st->time_base.den);
3562 AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL, 0);
3563 avcodec_string(buf, sizeof(buf), st->codec, is_output);
3564 av_log(NULL, AV_LOG_INFO, " Stream #%d:%d", index, i);
3565 /* the pid is an important information, so we display it */
3566 /* XXX: add a generic system */
3567 if (flags & AVFMT_SHOW_IDS)
3568 av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
3570 av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
3571 av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames, st->time_base.num/g, st->time_base.den/g);
3572 av_log(NULL, AV_LOG_INFO, ": %s", buf);
3573 if (st->sample_aspect_ratio.num && // default
3574 av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
3575 AVRational display_aspect_ratio;
3576 av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
3577 st->codec->width*st->sample_aspect_ratio.num,
3578 st->codec->height*st->sample_aspect_ratio.den,
3580 av_log(NULL, AV_LOG_INFO, ", SAR %d:%d DAR %d:%d",
3581 st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3582 display_aspect_ratio.num, display_aspect_ratio.den);
3584 if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
3585 if(st->avg_frame_rate.den && st->avg_frame_rate.num)
3586 print_fps(av_q2d(st->avg_frame_rate), "fps");
3587 #if FF_API_R_FRAME_RATE
3588 if(st->r_frame_rate.den && st->r_frame_rate.num)
3589 print_fps(av_q2d(st->r_frame_rate), "tbr");
3591 if(st->time_base.den && st->time_base.num)
3592 print_fps(1/av_q2d(st->time_base), "tbn");
3593 if(st->codec->time_base.den && st->codec->time_base.num)
3594 print_fps(1/av_q2d(st->codec->time_base), "tbc");
3596 if (st->disposition & AV_DISPOSITION_DEFAULT)
3597 av_log(NULL, AV_LOG_INFO, " (default)");
3598 if (st->disposition & AV_DISPOSITION_DUB)
3599 av_log(NULL, AV_LOG_INFO, " (dub)");
3600 if (st->disposition & AV_DISPOSITION_ORIGINAL)
3601 av_log(NULL, AV_LOG_INFO, " (original)");
3602 if (st->disposition & AV_DISPOSITION_COMMENT)
3603 av_log(NULL, AV_LOG_INFO, " (comment)");
3604 if (st->disposition & AV_DISPOSITION_LYRICS)
3605 av_log(NULL, AV_LOG_INFO, " (lyrics)");
3606 if (st->disposition & AV_DISPOSITION_KARAOKE)
3607 av_log(NULL, AV_LOG_INFO, " (karaoke)");
3608 if (st->disposition & AV_DISPOSITION_FORCED)
3609 av_log(NULL, AV_LOG_INFO, " (forced)");
3610 if (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED)
3611 av_log(NULL, AV_LOG_INFO, " (hearing impaired)");
3612 if (st->disposition & AV_DISPOSITION_VISUAL_IMPAIRED)
3613 av_log(NULL, AV_LOG_INFO, " (visual impaired)");
3614 if (st->disposition & AV_DISPOSITION_CLEAN_EFFECTS)
3615 av_log(NULL, AV_LOG_INFO, " (clean effects)");
3616 av_log(NULL, AV_LOG_INFO, "\n");
3617 dump_metadata(NULL, st->metadata, " ");
3620 void av_dump_format(AVFormatContext *ic,
3626 uint8_t *printed = ic->nb_streams ? av_mallocz(ic->nb_streams) : NULL;
3627 if (ic->nb_streams && !printed)
3630 av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3631 is_output ? "Output" : "Input",
3633 is_output ? ic->oformat->name : ic->iformat->name,
3634 is_output ? "to" : "from", url);
3635 dump_metadata(NULL, ic->metadata, " ");
3637 av_log(NULL, AV_LOG_INFO, " Duration: ");
3638 if (ic->duration != AV_NOPTS_VALUE) {
3639 int hours, mins, secs, us;
3640 int64_t duration = ic->duration + 5000;
3641 secs = duration / AV_TIME_BASE;
3642 us = duration % AV_TIME_BASE;
3647 av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3648 (100 * us) / AV_TIME_BASE);
3650 av_log(NULL, AV_LOG_INFO, "N/A");
3652 if (ic->start_time != AV_NOPTS_VALUE) {
3654 av_log(NULL, AV_LOG_INFO, ", start: ");
3655 secs = ic->start_time / AV_TIME_BASE;
3656 us = abs(ic->start_time % AV_TIME_BASE);
3657 av_log(NULL, AV_LOG_INFO, "%d.%06d",
3658 secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
3660 av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3662 av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
3664 av_log(NULL, AV_LOG_INFO, "N/A");
3666 av_log(NULL, AV_LOG_INFO, "\n");
3668 for (i = 0; i < ic->nb_chapters; i++) {
3669 AVChapter *ch = ic->chapters[i];
3670 av_log(NULL, AV_LOG_INFO, " Chapter #%d.%d: ", index, i);
3671 av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
3672 av_log(NULL, AV_LOG_INFO, "end %f\n", ch->end * av_q2d(ch->time_base));
3674 dump_metadata(NULL, ch->metadata, " ");
3676 if(ic->nb_programs) {
3677 int j, k, total = 0;
3678 for(j=0; j<ic->nb_programs; j++) {
3679 AVDictionaryEntry *name = av_dict_get(ic->programs[j]->metadata,
3681 av_log(NULL, AV_LOG_INFO, " Program %d %s\n", ic->programs[j]->id,
3682 name ? name->value : "");
3683 dump_metadata(NULL, ic->programs[j]->metadata, " ");
3684 for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3685 dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3686 printed[ic->programs[j]->stream_index[k]] = 1;
3688 total += ic->programs[j]->nb_stream_indexes;
3690 if (total < ic->nb_streams)
3691 av_log(NULL, AV_LOG_INFO, " No Program\n");
3693 for(i=0;i<ic->nb_streams;i++)
3695 dump_stream_format(ic, i, index, is_output);
3700 uint64_t ff_ntp_time(void)
3702 return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3705 int av_get_frame_filename(char *buf, int buf_size,
3706 const char *path, int number)
3709 char *q, buf1[20], c;
3710 int nd, len, percentd_found;
3722 while (av_isdigit(*p)) {
3723 nd = nd * 10 + *p++ - '0';
3726 } while (av_isdigit(c));
3735 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3737 if ((q - buf + len) > buf_size - 1)
3739 memcpy(q, buf1, len);
3747 if ((q - buf) < buf_size - 1)
3751 if (!percentd_found)
3760 static void hex_dump_internal(void *avcl, FILE *f, int level,
3761 const uint8_t *buf, int size)
3764 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3766 for(i=0;i<size;i+=16) {
3773 PRINT(" %02x", buf[i+j]);
3778 for(j=0;j<len;j++) {
3780 if (c < ' ' || c > '~')
3789 void av_hex_dump(FILE *f, const uint8_t *buf, int size)
3791 hex_dump_internal(NULL, f, 0, buf, size);
3794 void av_hex_dump_log(void *avcl, int level, const uint8_t *buf, int size)
3796 hex_dump_internal(avcl, NULL, level, buf, size);
3799 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload, AVRational time_base)
3801 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3802 PRINT("stream #%d:\n", pkt->stream_index);
3803 PRINT(" keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
3804 PRINT(" duration=%0.3f\n", pkt->duration * av_q2d(time_base));
3805 /* DTS is _always_ valid after av_read_frame() */
3807 if (pkt->dts == AV_NOPTS_VALUE)
3810 PRINT("%0.3f", pkt->dts * av_q2d(time_base));
3811 /* PTS may not be known if B-frames are present. */
3813 if (pkt->pts == AV_NOPTS_VALUE)
3816 PRINT("%0.3f", pkt->pts * av_q2d(time_base));
3818 PRINT(" size=%d\n", pkt->size);
3821 av_hex_dump(f, pkt->data, pkt->size);
3825 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3827 AVRational tb = { 1, AV_TIME_BASE };
3828 pkt_dump_internal(NULL, f, 0, pkt, dump_payload, tb);
3832 void av_pkt_dump2(FILE *f, AVPacket *pkt, int dump_payload, AVStream *st)
3834 pkt_dump_internal(NULL, f, 0, pkt, dump_payload, st->time_base);
3838 void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3840 AVRational tb = { 1, AV_TIME_BASE };
3841 pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, tb);
3845 void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload,
3848 pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, st->time_base);
3851 void av_url_split(char *proto, int proto_size,
3852 char *authorization, int authorization_size,
3853 char *hostname, int hostname_size,
3855 char *path, int path_size,
3858 const char *p, *ls, *ls2, *at, *at2, *col, *brk;
3860 if (port_ptr) *port_ptr = -1;
3861 if (proto_size > 0) proto[0] = 0;
3862 if (authorization_size > 0) authorization[0] = 0;
3863 if (hostname_size > 0) hostname[0] = 0;
3864 if (path_size > 0) path[0] = 0;
3866 /* parse protocol */
3867 if ((p = strchr(url, ':'))) {
3868 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3873 /* no protocol means plain filename */
3874 av_strlcpy(path, url, path_size);
3878 /* separate path from hostname */
3879 ls = strchr(p, '/');
3880 ls2 = strchr(p, '?');
3884 ls = FFMIN(ls, ls2);
3886 av_strlcpy(path, ls, path_size);
3888 ls = &p[strlen(p)]; // XXX
3890 /* the rest is hostname, use that to parse auth/port */
3892 /* authorization (user[:pass]@hostname) */
3894 while ((at = strchr(p, '@')) && at < ls) {
3895 av_strlcpy(authorization, at2,
3896 FFMIN(authorization_size, at + 1 - at2));
3897 p = at + 1; /* skip '@' */
3900 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3902 av_strlcpy(hostname, p + 1,
3903 FFMIN(hostname_size, brk - p));
3904 if (brk[1] == ':' && port_ptr)
3905 *port_ptr = atoi(brk + 2);
3906 } else if ((col = strchr(p, ':')) && col < ls) {
3907 av_strlcpy(hostname, p,
3908 FFMIN(col + 1 - p, hostname_size));
3909 if (port_ptr) *port_ptr = atoi(col + 1);
3911 av_strlcpy(hostname, p,
3912 FFMIN(ls + 1 - p, hostname_size));
3916 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3919 static const char hex_table_uc[16] = { '0', '1', '2', '3',
3922 'C', 'D', 'E', 'F' };
3923 static const char hex_table_lc[16] = { '0', '1', '2', '3',
3926 'c', 'd', 'e', 'f' };
3927 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3929 for(i = 0; i < s; i++) {
3930 buff[i * 2] = hex_table[src[i] >> 4];
3931 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3937 int ff_hex_to_data(uint8_t *data, const char *p)
3944 p += strspn(p, SPACE_CHARS);
3947 c = av_toupper((unsigned char) *p++);
3948 if (c >= '0' && c <= '9')
3950 else if (c >= 'A' && c <= 'F')
3965 #if FF_API_SET_PTS_INFO
3966 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3967 unsigned int pts_num, unsigned int pts_den)
3969 avpriv_set_pts_info(s, pts_wrap_bits, pts_num, pts_den);
3973 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
3974 unsigned int pts_num, unsigned int pts_den)
3977 if(av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)){
3978 if(new_tb.num != pts_num)
3979 av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/new_tb.num);
3981 av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3983 if(new_tb.num <= 0 || new_tb.den <= 0) {
3984 av_log(NULL, AV_LOG_ERROR, "Ignoring attempt to set invalid timebase %d/%d for st:%d\n", new_tb.num, new_tb.den, s->index);
3987 s->time_base = new_tb;
3988 av_codec_set_pkt_timebase(s->codec, new_tb);
3989 s->pts_wrap_bits = pts_wrap_bits;
3992 int ff_url_join(char *str, int size, const char *proto,
3993 const char *authorization, const char *hostname,
3994 int port, const char *fmt, ...)
3997 struct addrinfo hints = { 0 }, *ai;
4002 av_strlcatf(str, size, "%s://", proto);
4003 if (authorization && authorization[0])
4004 av_strlcatf(str, size, "%s@", authorization);
4005 #if CONFIG_NETWORK && defined(AF_INET6)
4006 /* Determine if hostname is a numerical IPv6 address,
4007 * properly escape it within [] in that case. */
4008 hints.ai_flags = AI_NUMERICHOST;
4009 if (!getaddrinfo(hostname, NULL, &hints, &ai)) {
4010 if (ai->ai_family == AF_INET6) {
4011 av_strlcat(str, "[", size);
4012 av_strlcat(str, hostname, size);
4013 av_strlcat(str, "]", size);
4015 av_strlcat(str, hostname, size);
4020 /* Not an IPv6 address, just output the plain string. */
4021 av_strlcat(str, hostname, size);
4024 av_strlcatf(str, size, ":%d", port);
4027 int len = strlen(str);
4030 vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);
4036 int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
4037 AVFormatContext *src)
4042 local_pkt.stream_index = dst_stream;
4043 if (pkt->pts != AV_NOPTS_VALUE)
4044 local_pkt.pts = av_rescale_q(pkt->pts,
4045 src->streams[pkt->stream_index]->time_base,
4046 dst->streams[dst_stream]->time_base);
4047 if (pkt->dts != AV_NOPTS_VALUE)
4048 local_pkt.dts = av_rescale_q(pkt->dts,
4049 src->streams[pkt->stream_index]->time_base,
4050 dst->streams[dst_stream]->time_base);
4052 local_pkt.duration = av_rescale_q(pkt->duration,
4053 src->streams[pkt->stream_index]->time_base,
4054 dst->streams[dst_stream]->time_base);
4055 return av_write_frame(dst, &local_pkt);
4058 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
4061 const char *ptr = str;
4063 /* Parse key=value pairs. */
4066 char *dest = NULL, *dest_end;
4067 int key_len, dest_len = 0;
4069 /* Skip whitespace and potential commas. */
4070 while (*ptr && (av_isspace(*ptr) || *ptr == ','))
4077 if (!(ptr = strchr(key, '=')))
4080 key_len = ptr - key;
4082 callback_get_buf(context, key, key_len, &dest, &dest_len);
4083 dest_end = dest + dest_len - 1;
4087 while (*ptr && *ptr != '\"') {
4091 if (dest && dest < dest_end)
4095 if (dest && dest < dest_end)
4103 for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
4104 if (dest && dest < dest_end)
4112 int ff_find_stream_index(AVFormatContext *s, int id)
4115 for (i = 0; i < s->nb_streams; i++) {
4116 if (s->streams[i]->id == id)
4122 void ff_make_absolute_url(char *buf, int size, const char *base,
4125 char *sep, *path_query;
4126 /* Absolute path, relative to the current server */
4127 if (base && strstr(base, "://") && rel[0] == '/') {
4129 av_strlcpy(buf, base, size);
4130 sep = strstr(buf, "://");
4132 /* Take scheme from base url */
4133 if (rel[1] == '/') {
4136 /* Take scheme and host from base url */
4138 sep = strchr(sep, '/');
4143 av_strlcat(buf, rel, size);
4146 /* If rel actually is an absolute url, just copy it */
4147 if (!base || strstr(rel, "://") || rel[0] == '/') {
4148 av_strlcpy(buf, rel, size);
4152 av_strlcpy(buf, base, size);
4154 /* Strip off any query string from base */
4155 path_query = strchr(buf, '?');
4156 if (path_query != NULL)
4159 /* Is relative path just a new query part? */
4160 if (rel[0] == '?') {
4161 av_strlcat(buf, rel, size);
4165 /* Remove the file name from the base url */
4166 sep = strrchr(buf, '/');
4171 while (av_strstart(rel, "../", NULL) && sep) {
4172 /* Remove the path delimiter at the end */
4174 sep = strrchr(buf, '/');
4175 /* If the next directory name to pop off is "..", break here */
4176 if (!strcmp(sep ? &sep[1] : buf, "..")) {
4177 /* Readd the slash we just removed */
4178 av_strlcat(buf, "/", size);
4181 /* Cut off the directory name */
4188 av_strlcat(buf, rel, size);
4191 int64_t ff_iso8601_to_unix_time(const char *datestr)
4193 struct tm time1 = {0}, time2 = {0};
4195 ret1 = av_small_strptime(datestr, "%Y - %m - %d %H:%M:%S", &time1);
4196 ret2 = av_small_strptime(datestr, "%Y - %m - %dT%H:%M:%S", &time2);
4198 return av_timegm(&time2);
4200 return av_timegm(&time1);
4203 int avformat_query_codec(AVOutputFormat *ofmt, enum AVCodecID codec_id, int std_compliance)
4206 if (ofmt->query_codec)
4207 return ofmt->query_codec(codec_id, std_compliance);
4208 else if (ofmt->codec_tag)
4209 return !!av_codec_get_tag(ofmt->codec_tag, codec_id);
4210 else if (codec_id == ofmt->video_codec || codec_id == ofmt->audio_codec ||
4211 codec_id == ofmt->subtitle_codec)
4214 return AVERROR_PATCHWELCOME;
4217 int avformat_network_init(void)
4221 ff_network_inited_globally = 1;
4222 if ((ret = ff_network_init()) < 0)
4229 int avformat_network_deinit(void)
4238 int ff_add_param_change(AVPacket *pkt, int32_t channels,
4239 uint64_t channel_layout, int32_t sample_rate,
4240 int32_t width, int32_t height)
4246 return AVERROR(EINVAL);
4249 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
4251 if (channel_layout) {
4253 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
4257 flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
4259 if (width || height) {
4261 flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
4263 data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
4265 return AVERROR(ENOMEM);
4266 bytestream_put_le32(&data, flags);
4268 bytestream_put_le32(&data, channels);
4270 bytestream_put_le64(&data, channel_layout);
4272 bytestream_put_le32(&data, sample_rate);
4273 if (width || height) {
4274 bytestream_put_le32(&data, width);
4275 bytestream_put_le32(&data, height);
4280 const struct AVCodecTag *avformat_get_riff_video_tags(void)
4282 return ff_codec_bmp_tags;
4284 const struct AVCodecTag *avformat_get_riff_audio_tags(void)
4286 return ff_codec_wav_tags;
4289 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
4291 AVRational undef = {0, 1};
4292 AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
4293 AVRational codec_sample_aspect_ratio = stream && stream->codec ? stream->codec->sample_aspect_ratio : undef;
4294 AVRational frame_sample_aspect_ratio = frame ? frame->sample_aspect_ratio : codec_sample_aspect_ratio;
4296 av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
4297 stream_sample_aspect_ratio.num, stream_sample_aspect_ratio.den, INT_MAX);
4298 if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
4299 stream_sample_aspect_ratio = undef;
4301 av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
4302 frame_sample_aspect_ratio.num, frame_sample_aspect_ratio.den, INT_MAX);
4303 if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
4304 frame_sample_aspect_ratio = undef;
4306 if (stream_sample_aspect_ratio.num)
4307 return stream_sample_aspect_ratio;
4309 return frame_sample_aspect_ratio;
4312 AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
4314 AVRational fr = st->r_frame_rate;
4316 if (st->codec->ticks_per_frame > 1) {
4317 AVRational codec_fr = av_inv_q(st->codec->time_base);
4318 AVRational avg_fr = st->avg_frame_rate;
4319 codec_fr.den *= st->codec->ticks_per_frame;
4320 if ( codec_fr.num > 0 && codec_fr.den > 0 && av_q2d(codec_fr) < av_q2d(fr)*0.7
4321 && fabs(1.0 - av_q2d(av_div_q(avg_fr, fr))) > 0.1)
4328 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
4331 if (*spec <= '9' && *spec >= '0') /* opt:index */
4332 return strtol(spec, NULL, 0) == st->index;
4333 else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
4334 *spec == 't') { /* opt:[vasdt] */
4335 enum AVMediaType type;
4338 case 'v': type = AVMEDIA_TYPE_VIDEO; break;
4339 case 'a': type = AVMEDIA_TYPE_AUDIO; break;
4340 case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
4341 case 'd': type = AVMEDIA_TYPE_DATA; break;
4342 case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
4343 default: av_assert0(0);
4345 if (type != st->codec->codec_type)
4347 if (*spec++ == ':') { /* possibly followed by :index */
4348 int i, index = strtol(spec, NULL, 0);
4349 for (i = 0; i < s->nb_streams; i++)
4350 if (s->streams[i]->codec->codec_type == type && index-- == 0)
4351 return i == st->index;
4355 } else if (*spec == 'p' && *(spec + 1) == ':') {
4359 prog_id = strtol(spec, &endptr, 0);
4360 for (i = 0; i < s->nb_programs; i++) {
4361 if (s->programs[i]->id != prog_id)
4364 if (*endptr++ == ':') {
4365 int stream_idx = strtol(endptr, NULL, 0);
4366 return stream_idx >= 0 &&
4367 stream_idx < s->programs[i]->nb_stream_indexes &&
4368 st->index == s->programs[i]->stream_index[stream_idx];
4371 for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
4372 if (st->index == s->programs[i]->stream_index[j])
4376 } else if (*spec == '#') {
4379 sid = strtol(spec + 1, &endptr, 0);
4381 return st->id == sid;
4382 } else if (!*spec) /* empty specifier, matches everything */
4385 av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
4386 return AVERROR(EINVAL);
4389 void ff_generate_avci_extradata(AVStream *st)
4391 static const uint8_t avci100_1080p_extradata[] = {
4393 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4394 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4395 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4396 0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
4397 0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
4398 0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
4399 0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
4400 0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
4401 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4403 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4406 static const uint8_t avci100_1080i_extradata[] = {
4408 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4409 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4410 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4411 0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
4412 0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
4413 0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
4414 0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
4415 0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
4416 0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
4417 0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
4418 0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x00,
4420 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4423 static const uint8_t avci50_1080i_extradata[] = {
4425 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
4426 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4427 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4428 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
4429 0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
4430 0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
4431 0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
4432 0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
4433 0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
4434 0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
4435 0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
4437 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4440 static const uint8_t avci100_720p_extradata[] = {
4442 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4443 0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
4444 0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
4445 0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
4446 0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
4447 0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
4448 0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
4449 0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
4450 0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
4451 0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
4453 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
4457 const uint8_t *data = 0;
4458 if (st->codec->width == 1920) {
4459 if (st->codec->field_order == AV_FIELD_PROGRESSIVE) {
4460 data = avci100_1080p_extradata;
4461 size = sizeof(avci100_1080p_extradata);
4463 data = avci100_1080i_extradata;
4464 size = sizeof(avci100_1080i_extradata);
4466 } else if (st->codec->width == 1440) {
4467 data = avci50_1080i_extradata;
4468 size = sizeof(avci50_1080i_extradata);
4469 } else if (st->codec->width == 1280) {
4470 data = avci100_720p_extradata;
4471 size = sizeof(avci100_720p_extradata);
4475 av_freep(&st->codec->extradata);
4476 st->codec->extradata_size = 0;
4477 st->codec->extradata = av_mallocz(size + FF_INPUT_BUFFER_PADDING_SIZE);
4478 if (!st->codec->extradata)
4480 memcpy(st->codec->extradata, data, size);
4481 st->codec->extradata_size = size;
4484 static int match_host_pattern(const char *pattern, const char *hostname)
4487 if (!strcmp(pattern, "*"))
4489 // Skip a possible *. at the start of the pattern
4490 if (pattern[0] == '*')
4492 if (pattern[0] == '.')
4494 len_p = strlen(pattern);
4495 len_h = strlen(hostname);
4498 // Simply check if the end of hostname is equal to 'pattern'
4499 if (!strcmp(pattern, &hostname[len_h - len_p])) {
4501 return 1; // Exact match
4502 if (hostname[len_h - len_p - 1] == '.')
4503 return 1; // The matched substring is a domain and not just a substring of a domain
4508 int ff_http_match_no_proxy(const char *no_proxy, const char *hostname)
4516 buf = av_strdup(no_proxy);
4521 char *sep, *next = NULL;
4522 start += strspn(start, " ,");
4523 sep = start + strcspn(start, " ,");
4528 if (match_host_pattern(start, hostname)) {