path: root/libavformat/utils.c (plain)
blob: 265813693ab8dfea3d65f0542658b5075369c97b

1	/*
2	* various utility functions for use within FFmpeg
3	* Copyright (c) 2000, 2001, 2002 Fabrice Bellard
4	*
5	* This file is part of FFmpeg.
6	*
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.
11	*
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.
16	*
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
20	*/
21
22	#include "avformat.h"
23	#include "avio_internal.h"
24	#include "internal.h"
25	#include "libavcodec/internal.h"
26	#include "libavcodec/raw.h"
27	#include "libavcodec/bytestream.h"
28	#include "libavutil/opt.h"
29	#include "libavutil/dict.h"
30	#include "libavutil/internal.h"
31	#include "libavutil/pixdesc.h"
32	#include "metadata.h"
33	#include "id3v2.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"
40	#include "riff.h"
41	#include "audiointerleave.h"
42	#include "url.h"
43	#include <stdarg.h>
44	#if CONFIG_NETWORK
45	#include "network.h"
46	#endif
47
48	#undef NDEBUG
49	#include <assert.h>
50
51	/**
52	* @file
53	* various utility functions for use within FFmpeg
54	*/
55
56	unsigned avformat_version(void)
57	{
58	av_assert0(LIBAVFORMAT_VERSION_MICRO >= 100);
59	return LIBAVFORMAT_VERSION_INT;
60	}
61
62	const char *avformat_configuration(void)
63	{
64	return FFMPEG_CONFIGURATION;
65	}
66
67	const char *avformat_license(void)
68	{
69	#define LICENSE_PREFIX "libavformat license: "
70	return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;
71	}
72
73	#define RELATIVE_TS_BASE (INT64_MAX - (1LL<<48))
74
75	static int is_relative(int64_t ts) {
76	return ts > (RELATIVE_TS_BASE - (1LL<<48));
77	}
78
79	/**
80	* Wrap a given time stamp, if there is an indication for an overflow
81	*
82	* @param st stream
83	* @param timestamp the time stamp to wrap
84	* @return resulting time stamp
85	*/
86	static int64_t wrap_timestamp(AVStream *st, int64_t timestamp)
87	{
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);
96	}
97	return timestamp;
98	}
99
100	MAKE_ACCESSORS(AVStream, stream, AVRational, r_frame_rate)
101	MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, video_codec)
102	MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, audio_codec)
103	MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, subtitle_codec)
104
105	static AVCodec *find_decoder(AVFormatContext *s, AVStream *st, enum AVCodecID codec_id)
106	{
107	if (st->codec->codec)
108	return st->codec->codec;
109
110	switch(st->codec->codec_type){
111	case AVMEDIA_TYPE_VIDEO:
112	if(s->video_codec) return s->video_codec;
113	break;
114	case AVMEDIA_TYPE_AUDIO:
115	if(s->audio_codec) return s->audio_codec;
116	break;
117	case AVMEDIA_TYPE_SUBTITLE:
118	if(s->subtitle_codec) return s->subtitle_codec;
119	break;
120	}
121
122	return avcodec_find_decoder(codec_id);
123	}
124
125	int av_format_get_probe_score(const AVFormatContext *s)
126	{
127	return s->probe_score;
128	}
129
130	/* an arbitrarily chosen "sane" max packet size -- 50M */
131	#define SANE_CHUNK_SIZE (50000000)
132
133	int ffio_limit(AVIOContext *s, int size)
134	{
135	if(s->maxsize>=0){
136	int64_t remaining= s->maxsize - avio_tell(s);
137	if(remaining < size){
138	int64_t newsize= avio_size(s);
139	if(!s->maxsize || s->maxsize<newsize)
140	s->maxsize= newsize - !newsize;
141	remaining= s->maxsize - avio_tell(s);
142	remaining= FFMAX(remaining, 0);
143	}
144
145	if(s->maxsize>=0 && remaining+1 < size){
146	av_log(NULL, remaining ? AV_LOG_ERROR : AV_LOG_DEBUG, "Truncating packet of size %d to %"PRId64"\n", size, remaining+1);
147	size= remaining+1;
148	}
149	}
150	return size;
151	}
152
153	/*
154	* Read the data in sane-sized chunks and append to pkt.
155	* Return the number of bytes read or an error.
156	*/
157	static int append_packet_chunked(AVIOContext *s, AVPacket *pkt, int size)
158	{
159	int64_t orig_pos = pkt->pos; // av_grow_packet might reset pos
160	int orig_size = pkt->size;
161	int ret;
162
163	do {
164	int prev_size = pkt->size;
165	int read_size;
166
167	/*
168	* When the caller requests a lot of data, limit it to the amount left
169	* in file or SANE_CHUNK_SIZE when it is not known
170	*/
171	read_size = size;
172	if (read_size > SANE_CHUNK_SIZE/10) {
173	read_size = ffio_limit(s, read_size);
174	// If filesize/maxsize is unknown, limit to SANE_CHUNK_SIZE
175	if (s->maxsize < 0)
176	read_size = FFMIN(read_size, SANE_CHUNK_SIZE);
177	}
178
179	ret = av_grow_packet(pkt, read_size);
180	if (ret < 0)
181	break;
182
183	ret = avio_read(s, pkt->data + prev_size, read_size);
184	if (ret != read_size) {
185	av_shrink_packet(pkt, prev_size + FFMAX(ret, 0));
186	break;
187	}
188
189	size -= read_size;
190	} while (size > 0);
191	if (size > 0)
192	pkt->flags |= AV_PKT_FLAG_CORRUPT;
193
194	pkt->pos = orig_pos;
195	if (!pkt->size)
196	av_free_packet(pkt);
197	return pkt->size > orig_size ? pkt->size - orig_size : ret;
198	}
199
200	int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
201	{
202	av_init_packet(pkt);
203	pkt->data = NULL;
204	pkt->size = 0;
205	pkt->pos = avio_tell(s);
206
207	return append_packet_chunked(s, pkt, size);
208	}
209
210	int av_append_packet(AVIOContext *s, AVPacket *pkt, int size)
211	{
212	if (!pkt->size)
213	return av_get_packet(s, pkt, size);
214	return append_packet_chunked(s, pkt, size);
215	}
216
217
218	int av_filename_number_test(const char *filename)
219	{
220	char buf[1024];
221	return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
222	}
223
224	AVInputFormat *av_probe_input_format3(AVProbeData *pd, int is_opened, int *score_ret)
225	{
226	AVProbeData lpd = *pd;
227	AVInputFormat *fmt1 = NULL, *fmt;
228	int score, nodat = 0, score_max=0;
229	const static uint8_t zerobuffer[AVPROBE_PADDING_SIZE];
230
231	if (!lpd.buf)
232	lpd.buf = zerobuffer;
233
234	if (lpd.buf_size > 10 && ff_id3v2_match(lpd.buf, ID3v2_DEFAULT_MAGIC)) {
235	int id3len = ff_id3v2_tag_len(lpd.buf);
236	if (lpd.buf_size > id3len + 16) {
237	lpd.buf += id3len;
238	lpd.buf_size -= id3len;
239	}else
240	nodat = 1;
241	}
242
243	fmt = NULL;
244	while ((fmt1 = av_iformat_next(fmt1))) {
245	if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
246	continue;
247	score = 0;
248	if (fmt1->read_probe) {
249	score = fmt1->read_probe(&lpd);
250	if(fmt1->extensions && av_match_ext(lpd.filename, fmt1->extensions))
251	score = FFMAX(score, nodat ? AVPROBE_SCORE_EXTENSION / 2 - 1 : 1);
252	} else if (fmt1->extensions) {
253	if (av_match_ext(lpd.filename, fmt1->extensions)) {
254	score = AVPROBE_SCORE_EXTENSION;
255	}
256	}
257	if (score > score_max) {
258	score_max = score;
259	fmt = fmt1;
260	}else if (score == score_max)
261	fmt = NULL;
262	}
263	if(nodat)
264	score_max = FFMIN(AVPROBE_SCORE_EXTENSION / 2 - 1, score_max);
265	*score_ret= score_max;
266
267	return fmt;
268	}
269
270	AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
271	{
272	int score_ret;
273	AVInputFormat *fmt= av_probe_input_format3(pd, is_opened, &score_ret);
274	if(score_ret > *score_max){
275	*score_max= score_ret;
276	return fmt;
277	}else
278	return NULL;
279	}
280
281	AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
282	int score=0;
283	return av_probe_input_format2(pd, is_opened, &score);
284	}
285
286	static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st, AVProbeData *pd)
287	{
288	static const struct {
289	const char *name; enum AVCodecID id; enum AVMediaType type;
290	} fmt_id_type[] = {
291	{ "aac" , AV_CODEC_ID_AAC , AVMEDIA_TYPE_AUDIO },
292	{ "ac3" , AV_CODEC_ID_AC3 , AVMEDIA_TYPE_AUDIO },
293	{ "dts" , AV_CODEC_ID_DTS , AVMEDIA_TYPE_AUDIO },
294	{ "eac3" , AV_CODEC_ID_EAC3 , AVMEDIA_TYPE_AUDIO },
295	{ "h264" , AV_CODEC_ID_H264 , AVMEDIA_TYPE_VIDEO },
296	{ "loas" , AV_CODEC_ID_AAC_LATM , AVMEDIA_TYPE_AUDIO },
297	{ "m4v" , AV_CODEC_ID_MPEG4 , AVMEDIA_TYPE_VIDEO },
298	{ "mp3" , AV_CODEC_ID_MP3 , AVMEDIA_TYPE_AUDIO },
299	{ "mpegvideo", AV_CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
300	{ 0 }
301	};
302	int score;
303	AVInputFormat *fmt = av_probe_input_format3(pd, 1, &score);
304
305	if (fmt && st->request_probe <= score) {
306	int i;
307	av_log(s, AV_LOG_DEBUG, "Probe with size=%d, packets=%d detected %s with score=%d\n",
308	pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets, fmt->name, score);
309	for (i = 0; fmt_id_type[i].name; i++) {
310	if (!strcmp(fmt->name, fmt_id_type[i].name)) {
311	st->codec->codec_id = fmt_id_type[i].id;
312	st->codec->codec_type = fmt_id_type[i].type;
313	break;
314	}
315	}
316	}
317	return score;
318	}
319
320	/************************************************************/
321	/* input media file */
322
323	int av_demuxer_open(AVFormatContext *ic){
324	int err;
325
326	if (ic->iformat->read_header) {
327	err = ic->iformat->read_header(ic);
328	if (err < 0)
329	return err;
330	}
331
332	if (ic->pb && !ic->data_offset)
333	ic->data_offset = avio_tell(ic->pb);
334
335	return 0;
336	}
337
338
339	int av_probe_input_buffer2(AVIOContext *pb, AVInputFormat **fmt,
340	const char *filename, void *logctx,
341	unsigned int offset, unsigned int max_probe_size)
342	{
343	AVProbeData pd = { filename ? filename : "", NULL, -offset };
344	unsigned char *buf = NULL;
345	uint8_t *mime_type;
346	int ret = 0, probe_size, buf_offset = 0;
347	int score = 0;
348
349	if (!max_probe_size) {
350	max_probe_size = PROBE_BUF_MAX;
351	} else if (max_probe_size > PROBE_BUF_MAX) {
352	max_probe_size = PROBE_BUF_MAX;
353	} else if (max_probe_size < PROBE_BUF_MIN) {
354	av_log(logctx, AV_LOG_ERROR,
355	"Specified probe size value %u cannot be < %u\n", max_probe_size, PROBE_BUF_MIN);
356	return AVERROR(EINVAL);
357	}
358
359	if (offset >= max_probe_size) {
360	return AVERROR(EINVAL);
361	}
362
363	if (!*fmt && pb->av_class && av_opt_get(pb, "mime_type", AV_OPT_SEARCH_CHILDREN, &mime_type) >= 0 && mime_type) {
364	if (!av_strcasecmp(mime_type, "audio/aacp")) {
365	*fmt = av_find_input_format("aac");
366	}
367	av_freep(&mime_type);
368	}
369
370	for(probe_size= PROBE_BUF_MIN; probe_size<=max_probe_size && !*fmt;
371	probe_size = FFMIN(probe_size<<1, FFMAX(max_probe_size, probe_size+1))) {
372
373	if (probe_size < offset) {
374	continue;
375	}
376	score = probe_size < max_probe_size ? AVPROBE_SCORE_RETRY : 0;
377
378	/* read probe data */
379	if ((ret = av_reallocp(&buf, probe_size + AVPROBE_PADDING_SIZE)) < 0)
380	return ret;
381	if ((ret = avio_read(pb, buf + buf_offset, probe_size - buf_offset)) < 0) {
382	/* fail if error was not end of file, otherwise, lower score */
383	if (ret != AVERROR_EOF) {
384	av_free(buf);
385	return ret;
386	}
387	score = 0;
388	ret = 0; /* error was end of file, nothing read */
389	}
390	pd.buf_size = buf_offset += ret;
391	pd.buf = &buf[offset];
392
393	memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE);
394
395	/* guess file format */
396	*fmt = av_probe_input_format2(&pd, 1, &score);
397	if(*fmt){
398	if(score <= AVPROBE_SCORE_RETRY){ //this can only be true in the last iteration
399	av_log(logctx, AV_LOG_WARNING, "Format %s detected only with low score of %d, misdetection possible!\n", (*fmt)->name, score);
400	}else
401	av_log(logctx, AV_LOG_DEBUG, "Format %s probed with size=%d and score=%d\n", (*fmt)->name, probe_size, score);
402	}
403	}
404
405	if (!*fmt) {
406	av_free(buf);
407	return AVERROR_INVALIDDATA;
408	}
409
410	/* rewind. reuse probe buffer to avoid seeking */
411	ret = ffio_rewind_with_probe_data(pb, &buf, pd.buf_size);
412
413	return ret < 0 ? ret : score;
414	}
415
416	int av_probe_input_buffer(AVIOContext *pb, AVInputFormat **fmt,
417	const char *filename, void *logctx,
418	unsigned int offset, unsigned int max_probe_size)
419	{
420	int ret = av_probe_input_buffer2(pb, fmt, filename, logctx, offset, max_probe_size);
421	return ret < 0 ? ret : 0;
422	}
423
424
425	/* open input file and probe the format if necessary */
426	static int init_input(AVFormatContext *s, const char *filename, AVDictionary **options)
427	{
428	int ret;
429	AVProbeData pd = {filename, NULL, 0};
430	int score = AVPROBE_SCORE_RETRY;
431
432	if (s->pb) {
433	s->flags |= AVFMT_FLAG_CUSTOM_IO;
434	if (!s->iformat)
435	return av_probe_input_buffer2(s->pb, &s->iformat, filename, s, 0, s->probesize);
436	else if (s->iformat->flags & AVFMT_NOFILE)
437	av_log(s, AV_LOG_WARNING, "Custom AVIOContext makes no sense and "
438	"will be ignored with AVFMT_NOFILE format.\n");
439	return 0;
440	}
441
442	if ( (s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
443	(!s->iformat && (s->iformat = av_probe_input_format2(&pd, 0, &score))))
444	return score;
445
446	if ((ret = avio_open2(&s->pb, filename, AVIO_FLAG_READ | s->avio_flags,
447	&s->interrupt_callback, options)) < 0)
448	return ret;
449	if (s->iformat)
450	return 0;
451	return av_probe_input_buffer2(s->pb, &s->iformat, filename, s, 0, s->probesize);
452	}
453
454	static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
455	AVPacketList **plast_pktl){
456	AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
457	if (!pktl)
458	return NULL;
459
460	if (*packet_buffer)
461	(*plast_pktl)->next = pktl;
462	else
463	*packet_buffer = pktl;
464
465	/* add the packet in the buffered packet list */
466	*plast_pktl = pktl;
467	pktl->pkt= *pkt;
468	return &pktl->pkt;
469	}
470
471	int avformat_queue_attached_pictures(AVFormatContext *s)
472	{
473	int i;
474	for (i = 0; i < s->nb_streams; i++)
475	if (s->streams[i]->disposition & AV_DISPOSITION_ATTACHED_PIC &&
476	s->streams[i]->discard < AVDISCARD_ALL) {
477	AVPacket copy = s->streams[i]->attached_pic;
478	copy.buf = av_buffer_ref(copy.buf);
479	if (!copy.buf)
480	return AVERROR(ENOMEM);
481
482	add_to_pktbuf(&s->raw_packet_buffer, &copy, &s->raw_packet_buffer_end);
483	}
484	return 0;
485	}
486
487	int avformat_open_input(AVFormatContext **ps, const char *filename, AVInputFormat *fmt, AVDictionary **options)
488	{
489	AVFormatContext *s = *ps;
490	int ret = 0;
491	AVDictionary *tmp = NULL;
492	ID3v2ExtraMeta *id3v2_extra_meta = NULL;
493
494	if (!s && !(s = avformat_alloc_context()))
495	return AVERROR(ENOMEM);
496	if (!s->av_class){
497	av_log(NULL, AV_LOG_ERROR, "Input context has not been properly allocated by avformat_alloc_context() and is not NULL either\n");
498	return AVERROR(EINVAL);
499	}
500	if (fmt)
501	s->iformat = fmt;
502
503	if (options)
504	av_dict_copy(&tmp, *options, 0);
505
506	if ((ret = av_opt_set_dict(s, &tmp)) < 0)
507	goto fail;
508
509	if ((ret = init_input(s, filename, &tmp)) < 0)
510	goto fail;
511	s->probe_score = ret;
512	avio_skip(s->pb, s->skip_initial_bytes);
513
514	/* check filename in case an image number is expected */
515	if (s->iformat->flags & AVFMT_NEEDNUMBER) {
516	if (!av_filename_number_test(filename)) {
517	ret = AVERROR(EINVAL);
518	goto fail;
519	}
520	}
521
522	s->duration = s->start_time = AV_NOPTS_VALUE;
523	av_strlcpy(s->filename, filename ? filename : "", sizeof(s->filename));
524
525	/* allocate private data */
526	if (s->iformat->priv_data_size > 0) {
527	if (!(s->priv_data = av_mallocz(s->iformat->priv_data_size))) {
528	ret = AVERROR(ENOMEM);
529	goto fail;
530	}
531	if (s->iformat->priv_class) {
532	*(const AVClass**)s->priv_data = s->iformat->priv_class;
533	av_opt_set_defaults(s->priv_data);
534	if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
535	goto fail;
536	}
537	}
538
539	/* e.g. AVFMT_NOFILE formats will not have a AVIOContext */
540	if (s->pb)
541	ff_id3v2_read(s, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta);
542
543	if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->iformat->read_header)
544	if ((ret = s->iformat->read_header(s)) < 0)
545	goto fail;
546
547	if (id3v2_extra_meta) {
548	if (!strcmp(s->iformat->name, "mp3") || !strcmp(s->iformat->name, "aac") ||
549	!strcmp(s->iformat->name, "tta")) {
550	if((ret = ff_id3v2_parse_apic(s, &id3v2_extra_meta)) < 0)
551	goto fail;
552	} else
553	av_log(s, AV_LOG_DEBUG, "demuxer does not support additional id3 data, skipping\n");
554	}
555	ff_id3v2_free_extra_meta(&id3v2_extra_meta);
556
557	if ((ret = avformat_queue_attached_pictures(s)) < 0)
558	goto fail;
559
560	if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->pb && !s->data_offset)
561	s->data_offset = avio_tell(s->pb);
562
563	s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
564
565	if (options) {
566	av_dict_free(options);
567	*options = tmp;
568	}
569	*ps = s;
570	return 0;
571
572	fail:
573	ff_id3v2_free_extra_meta(&id3v2_extra_meta);
574	av_dict_free(&tmp);
575	if (s->pb && !(s->flags & AVFMT_FLAG_CUSTOM_IO))
576	avio_close(s->pb);
577	avformat_free_context(s);
578	*ps = NULL;
579	return ret;
580	}
581
582	/*******************************************************/
583
584	static void force_codec_ids(AVFormatContext *s, AVStream *st)
585	{
586	switch(st->codec->codec_type){
587	case AVMEDIA_TYPE_VIDEO:
588	if(s->video_codec_id) st->codec->codec_id= s->video_codec_id;
589	break;
590	case AVMEDIA_TYPE_AUDIO:
591	if(s->audio_codec_id) st->codec->codec_id= s->audio_codec_id;
592	break;
593	case AVMEDIA_TYPE_SUBTITLE:
594	if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
595	break;
596	}
597	}
598
599	static int probe_codec(AVFormatContext *s, AVStream *st, const AVPacket *pkt)
600	{
601	if(st->request_probe>0){
602	AVProbeData *pd = &st->probe_data;
603	int end;
604	av_log(s, AV_LOG_DEBUG, "probing stream %d pp:%d\n", st->index, st->probe_packets);
605	--st->probe_packets;
606
607	if (pkt) {
608	uint8_t *new_buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
609	if(!new_buf) {
610	av_log(s, AV_LOG_WARNING,
611	"Failed to reallocate probe buffer for stream %d\n",
612	st->index);
613	goto no_packet;
614	}
615	pd->buf = new_buf;
616	memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
617	pd->buf_size += pkt->size;
618	memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
619	} else {
620	no_packet:
621	st->probe_packets = 0;
622	if (!pd->buf_size) {
623	av_log(s, AV_LOG_WARNING, "nothing to probe for stream %d\n",
624	st->index);
625	}
626	}
627
628	end= s->raw_packet_buffer_remaining_size <= 0
629	|| st->probe_packets<=0;
630
631	if(end || av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)){
632	int score= set_codec_from_probe_data(s, st, pd);
633	if( (st->codec->codec_id != AV_CODEC_ID_NONE && score > AVPROBE_SCORE_RETRY)
634	|| end){
635	pd->buf_size=0;
636	av_freep(&pd->buf);
637	st->request_probe= -1;
638	if(st->codec->codec_id != AV_CODEC_ID_NONE){
639	av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
640	}else
641	av_log(s, AV_LOG_WARNING, "probed stream %d failed\n", st->index);
642	}
643	force_codec_ids(s, st);
644	}
645	}
646	return 0;
647	}
648
649	int ff_read_packet(AVFormatContext *s, AVPacket *pkt)
650	{
651	int ret, i, err;
652	AVStream *st;
653
654	for(;;){
655	AVPacketList *pktl = s->raw_packet_buffer;
656
657	if (pktl) {
658	*pkt = pktl->pkt;
659	st = s->streams[pkt->stream_index];
660	if (s->raw_packet_buffer_remaining_size <= 0) {
661	if ((err = probe_codec(s, st, NULL)) < 0)
662	return err;
663	}
664	if(st->request_probe <= 0){
665	s->raw_packet_buffer = pktl->next;
666	s->raw_packet_buffer_remaining_size += pkt->size;
667	av_free(pktl);
668	return 0;
669	}
670	}
671
672	pkt->data = NULL;
673	pkt->size = 0;
674	av_init_packet(pkt);
675	ret= s->iformat->read_packet(s, pkt);
676	if (ret < 0) {
677	if (!pktl || ret == AVERROR(EAGAIN))
678	return ret;
679	for (i = 0; i < s->nb_streams; i++) {
680	st = s->streams[i];
681	if (st->probe_packets) {
682	if ((err = probe_codec(s, st, NULL)) < 0)
683	return err;
684	}
685	av_assert0(st->request_probe <= 0);
686	}
687	continue;
688	}
689
690	if ((s->flags & AVFMT_FLAG_DISCARD_CORRUPT) &&
691	(pkt->flags & AV_PKT_FLAG_CORRUPT)) {
692	av_log(s, AV_LOG_WARNING,
693	"Dropped corrupted packet (stream = %d)\n",
694	pkt->stream_index);
695	av_free_packet(pkt);
696	continue;
697	}
698
699	if(!(s->flags & AVFMT_FLAG_KEEP_SIDE_DATA))
700	av_packet_merge_side_data(pkt);
701
702	if(pkt->stream_index >= (unsigned)s->nb_streams){
703	av_log(s, AV_LOG_ERROR, "Invalid stream index %d\n", pkt->stream_index);
704	continue;
705	}
706
707	st= s->streams[pkt->stream_index];
708	pkt->dts = wrap_timestamp(st, pkt->dts);
709	pkt->pts = wrap_timestamp(st, pkt->pts);
710
711	force_codec_ids(s, st);
712
713	/* TODO: audio: time filter; video: frame reordering (pts != dts) */
714	if (s->use_wallclock_as_timestamps)
715	pkt->dts = pkt->pts = av_rescale_q(av_gettime(), AV_TIME_BASE_Q, st->time_base);
716
717	if(!pktl && st->request_probe <= 0)
718	return ret;
719
720	add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
721	s->raw_packet_buffer_remaining_size -= pkt->size;
722
723	if ((err = probe_codec(s, st, pkt)) < 0)
724	return err;
725	}
726	}
727
728	#if FF_API_READ_PACKET
729	int av_read_packet(AVFormatContext *s, AVPacket *pkt)
730	{
731	return ff_read_packet(s, pkt);
732	}
733	#endif
734
735
736	/**********************************************************/
737
738	static int determinable_frame_size(AVCodecContext *avctx)
739	{
740	if (/*avctx->codec_id == AV_CODEC_ID_AAC ||*/
741	avctx->codec_id == AV_CODEC_ID_MP1 ||
742	avctx->codec_id == AV_CODEC_ID_MP2 ||
743	avctx->codec_id == AV_CODEC_ID_MP3/* ||
744	avctx->codec_id == AV_CODEC_ID_CELT*/)
745	return 1;
746	return 0;
747	}
748
749	/**
750	* Get the number of samples of an audio frame. Return -1 on error.
751	*/
752	int ff_get_audio_frame_size(AVCodecContext *enc, int size, int mux)
753	{
754	int frame_size;
755
756	/* give frame_size priority if demuxing */
757	if (!mux && enc->frame_size > 1)
758	return enc->frame_size;
759
760	if ((frame_size = av_get_audio_frame_duration(enc, size)) > 0)
761	return frame_size;
762
763	/* Fall back on using frame_size if muxing. */
764	if (enc->frame_size > 1)
765	return enc->frame_size;
766
767	//For WMA we currently have no other means to calculate duration thus we
768	//do it here by assuming CBR, which is true for all known cases.
769	if(!mux && enc->bit_rate>0 && size>0 && enc->sample_rate>0 && enc->block_align>1) {
770	if (enc->codec_id == AV_CODEC_ID_WMAV1 || enc->codec_id == AV_CODEC_ID_WMAV2)
771	return ((int64_t)size * 8 * enc->sample_rate) / enc->bit_rate;
772	}
773
774	return -1;
775	}
776
777
778	/**
779	* Return the frame duration in seconds. Return 0 if not available.
780	*/
781	void ff_compute_frame_duration(int *pnum, int *pden, AVStream *st,
782	AVCodecParserContext *pc, AVPacket *pkt)
783	{
784	int frame_size;
785
786	*pnum = 0;
787	*pden = 0;
788	switch(st->codec->codec_type) {
789	case AVMEDIA_TYPE_VIDEO:
790	if (st->r_frame_rate.num && !pc) {
791	*pnum = st->r_frame_rate.den;
792	*pden = st->r_frame_rate.num;
793	} else if(st->time_base.num*1000LL > st->time_base.den) {
794	*pnum = st->time_base.num;
795	*pden = st->time_base.den;
796	}else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
797	*pnum = st->codec->time_base.num;
798	*pden = st->codec->time_base.den;
799	if (pc && pc->repeat_pict) {
800	if (*pnum > INT_MAX / (1 + pc->repeat_pict))
801	*pden /= 1 + pc->repeat_pict;
802	else
803	*pnum *= 1 + pc->repeat_pict;
804	}
805	//If this codec can be interlaced or progressive then we need a parser to compute duration of a packet
806	//Thus if we have no parser in such case leave duration undefined.
807	if(st->codec->ticks_per_frame>1 && !pc){
808	*pnum = *pden = 0;
809	}
810	}
811	break;
812	case AVMEDIA_TYPE_AUDIO:
813	frame_size = ff_get_audio_frame_size(st->codec, pkt->size, 0);
814	if (frame_size <= 0 || st->codec->sample_rate <= 0)
815	break;
816	*pnum = frame_size;
817	*pden = st->codec->sample_rate;
818	break;
819	default:
820	break;
821	}
822	}
823
824	static int is_intra_only(AVCodecContext *enc){
825	const AVCodecDescriptor *desc;
826
827	if(enc->codec_type != AVMEDIA_TYPE_VIDEO)
828	return 1;
829
830	desc = av_codec_get_codec_descriptor(enc);
831	if (!desc) {
832	desc = avcodec_descriptor_get(enc->codec_id);
833	av_codec_set_codec_descriptor(enc, desc);
834	}
835	if (desc)
836	return !!(desc->props & AV_CODEC_PROP_INTRA_ONLY);
837	return 0;
838	}
839
840	static int has_decode_delay_been_guessed(AVStream *st)
841	{
842	if(st->codec->codec_id != AV_CODEC_ID_H264) return 1;
843	if(!st->info) // if we have left find_stream_info then nb_decoded_frames won't increase anymore for stream copy
844	return 1;
845	#if CONFIG_H264_DECODER
846	if(st->codec->has_b_frames &&
847	avpriv_h264_has_num_reorder_frames(st->codec) == st->codec->has_b_frames)
848	return 1;
849	#endif
850	if(st->codec->has_b_frames<3)
851	return st->nb_decoded_frames >= 7;
852	else if(st->codec->has_b_frames<4)
853	return st->nb_decoded_frames >= 18;
854	else
855	return st->nb_decoded_frames >= 20;
856	}
857
858	static AVPacketList *get_next_pkt(AVFormatContext *s, AVStream *st, AVPacketList *pktl)
859	{
860	if (pktl->next)
861	return pktl->next;
862	if (pktl == s->parse_queue_end)
863	return s->packet_buffer;
864	return NULL;
865	}
866
867	static int update_wrap_reference(AVFormatContext *s, AVStream *st, int stream_index)
868	{
869	if (s->correct_ts_overflow && st->pts_wrap_bits < 63 &&
870	st->pts_wrap_reference == AV_NOPTS_VALUE && st->first_dts != AV_NOPTS_VALUE) {
871	int i;
872
873	// reference time stamp should be 60 s before first time stamp
874	int64_t pts_wrap_reference = st->first_dts - av_rescale(60, st->time_base.den, st->time_base.num);
875	// if first time stamp is not more than 1/8 and 60s before the wrap point, subtract rather than add wrap offset
876	int pts_wrap_behavior = (st->first_dts < (1LL<<st->pts_wrap_bits) - (1LL<<st->pts_wrap_bits-3)) ||
877	(st->first_dts < (1LL<<st->pts_wrap_bits) - av_rescale(60, st->time_base.den, st->time_base.num)) ?
878	AV_PTS_WRAP_ADD_OFFSET : AV_PTS_WRAP_SUB_OFFSET;
879
880	AVProgram *first_program = av_find_program_from_stream(s, NULL, stream_index);
881
882	if (!first_program) {
883	int default_stream_index = av_find_default_stream_index(s);
884	if (s->streams[default_stream_index]->pts_wrap_reference == AV_NOPTS_VALUE) {
885	for (i=0; i<s->nb_streams; i++) {
886	s->streams[i]->pts_wrap_reference = pts_wrap_reference;
887	s->streams[i]->pts_wrap_behavior = pts_wrap_behavior;
888	}
889	}
890	else {
891	st->pts_wrap_reference = s->streams[default_stream_index]->pts_wrap_reference;
892	st->pts_wrap_behavior = s->streams[default_stream_index]->pts_wrap_behavior;
893	}
894	}
895	else {
896	AVProgram *program = first_program;
897	while (program) {
898	if (program->pts_wrap_reference != AV_NOPTS_VALUE) {
899	pts_wrap_reference = program->pts_wrap_reference;
900	pts_wrap_behavior = program->pts_wrap_behavior;
901	break;
902	}
903	program = av_find_program_from_stream(s, program, stream_index);
904	}
905
906	// update every program with differing pts_wrap_reference
907	program = first_program;
908	while(program) {
909	if (program->pts_wrap_reference != pts_wrap_reference) {
910	for (i=0; i<program->nb_stream_indexes; i++) {
911	s->streams[program->stream_index[i]]->pts_wrap_reference = pts_wrap_reference;
912	s->streams[program->stream_index[i]]->pts_wrap_behavior = pts_wrap_behavior;
913	}
914
915	program->pts_wrap_reference = pts_wrap_reference;
916	program->pts_wrap_behavior = pts_wrap_behavior;
917	}
918	program = av_find_program_from_stream(s, program, stream_index);
919	}
920	}
921	return 1;
922	}
923	return 0;
924	}
925
926	static void update_initial_timestamps(AVFormatContext *s, int stream_index,
927	int64_t dts, int64_t pts, AVPacket *pkt)
928	{
929	AVStream *st= s->streams[stream_index];
930	AVPacketList *pktl= s->parse_queue ? s->parse_queue : s->packet_buffer;
931	int64_t pts_buffer[MAX_REORDER_DELAY+1];
932	int64_t shift;
933	int i, delay;
934
935	if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE || is_relative(dts))
936	return;
937
938	delay = st->codec->has_b_frames;
939	st->first_dts= dts - (st->cur_dts - RELATIVE_TS_BASE);
940	st->cur_dts= dts;
941	shift = st->first_dts - RELATIVE_TS_BASE;
942
943	for (i=0; i<MAX_REORDER_DELAY+1; i++)
944	pts_buffer[i] = AV_NOPTS_VALUE;
945
946	if (is_relative(pts))
947	pts += shift;
948
949	for(; pktl; pktl= get_next_pkt(s, st, pktl)){
950	if(pktl->pkt.stream_index != stream_index)
951	continue;
952	if(is_relative(pktl->pkt.pts))
953	pktl->pkt.pts += shift;
954
955	if(is_relative(pktl->pkt.dts))
956	pktl->pkt.dts += shift;
957
958	if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
959	st->start_time= pktl->pkt.pts;
960
961	if(pktl->pkt.pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY && has_decode_delay_been_guessed(st)){
962	pts_buffer[0]= pktl->pkt.pts;
963	for(i=0; i<delay && pts_buffer[i] > pts_buffer[i+1]; i++)
964	FFSWAP(int64_t, pts_buffer[i], pts_buffer[i+1]);
965	if(pktl->pkt.dts == AV_NOPTS_VALUE)
966	pktl->pkt.dts= pts_buffer[0];
967	}
968	}
969
970	if (update_wrap_reference(s, st, stream_index) && st->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET) {
971	// correct first time stamps to negative values
972	st->first_dts = wrap_timestamp(st, st->first_dts);
973	st->cur_dts = wrap_timestamp(st, st->cur_dts);
974	pkt->dts = wrap_timestamp(st, pkt->dts);
975	pkt->pts = wrap_timestamp(st, pkt->pts);
976	pts = wrap_timestamp(st, pts);
977	}
978
979	if (st->start_time == AV_NOPTS_VALUE)
980	st->start_time = pts;
981	}
982
983	static void update_initial_durations(AVFormatContext *s, AVStream *st,
984	int stream_index, int duration)
985	{
986	AVPacketList *pktl= s->parse_queue ? s->parse_queue : s->packet_buffer;
987	int64_t cur_dts= RELATIVE_TS_BASE;
988
989	if(st->first_dts != AV_NOPTS_VALUE){
990	cur_dts= st->first_dts;
991	for(; pktl; pktl= get_next_pkt(s, st, pktl)){
992	if(pktl->pkt.stream_index == stream_index){
993	if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
994	break;
995	cur_dts -= duration;
996	}
997	}
998	if(pktl && pktl->pkt.dts != st->first_dts) {
999	av_log(s, AV_LOG_DEBUG, "first_dts %s not matching first dts %s (pts %s, duration %d) in the queue\n",
1000	av_ts2str(st->first_dts), av_ts2str(pktl->pkt.dts), av_ts2str(pktl->pkt.pts), pktl->pkt.duration);
1001	return;
1002	}
1003	if(!pktl) {
1004	av_log(s, AV_LOG_DEBUG, "first_dts %s but no packet with dts in the queue\n", av_ts2str(st->first_dts));
1005	return;
1006	}
1007	pktl= s->parse_queue ? s->parse_queue : s->packet_buffer;
1008	st->first_dts = cur_dts;
1009	}else if(st->cur_dts != RELATIVE_TS_BASE)
1010	return;
1011
1012	for(; pktl; pktl= get_next_pkt(s, st, pktl)){
1013	if(pktl->pkt.stream_index != stream_index)
1014	continue;
1015	if(pktl->pkt.pts == pktl->pkt.dts && (pktl->pkt.dts == AV_NOPTS_VALUE || pktl->pkt.dts == st->first_dts)
1016	&& !pktl->pkt.duration){
1017	pktl->pkt.dts= cur_dts;
1018	if(!st->codec->has_b_frames)
1019	pktl->pkt.pts= cur_dts;
1020	// if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO)
1021	pktl->pkt.duration = duration;
1022	}else
1023	break;
1024	cur_dts = pktl->pkt.dts + pktl->pkt.duration;
1025	}
1026	if(!pktl)
1027	st->cur_dts= cur_dts;
1028	}
1029
1030	static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
1031	AVCodecParserContext *pc, AVPacket *pkt)
1032	{
1033	int num, den, presentation_delayed, delay, i;
1034	int64_t offset;
1035
1036	if (s->flags & AVFMT_FLAG_NOFILLIN)
1037	return;
1038
1039	if((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
1040	pkt->dts= AV_NOPTS_VALUE;
1041
1042	if (st->codec->codec_id != AV_CODEC_ID_H264 && pc && pc->pict_type == AV_PICTURE_TYPE_B)
1043	//FIXME Set low_delay = 0 when has_b_frames = 1
1044	st->codec->has_b_frames = 1;
1045
1046	/* do we have a video B-frame ? */
1047	delay= st->codec->has_b_frames;
1048	presentation_delayed = 0;
1049
1050	/* XXX: need has_b_frame, but cannot get it if the codec is
1051	not initialized */
1052	if (delay &&
1053	pc && pc->pict_type != AV_PICTURE_TYPE_B)
1054	presentation_delayed = 1;
1055
1056	if (pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE &&
1057	st->pts_wrap_bits < 63 &&
1058	pkt->dts - (1LL << (st->pts_wrap_bits - 1)) > pkt->pts) {
1059	if(is_relative(st->cur_dts) || pkt->dts - (1LL<<(st->pts_wrap_bits-1)) > st->cur_dts) {
1060	pkt->dts -= 1LL<<st->pts_wrap_bits;
1061	} else
1062	pkt->pts += 1LL<<st->pts_wrap_bits;
1063	}
1064
1065	// some mpeg2 in mpeg-ps lack dts (issue171 / input_file.mpg)
1066	// we take the conservative approach and discard both
1067	// Note, if this is misbehaving for a H.264 file then possibly presentation_delayed is not set correctly.
1068	if(delay==1 && pkt->dts == pkt->pts && pkt->dts != AV_NOPTS_VALUE && presentation_delayed){
1069	av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination %"PRIi64"\n", pkt->dts);
1070	if(strcmp(s->iformat->name, "mov,mp4,m4a,3gp,3g2,mj2")) // otherwise we discard correct timestamps for vc1-wmapro.ism
1071	pkt->dts= AV_NOPTS_VALUE;
1072	}
1073
1074	if (pkt->duration == 0) {
1075	ff_compute_frame_duration(&num, &den, st, pc, pkt);
1076	if (den && num) {
1077	pkt->duration = av_rescale_rnd(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num, AV_ROUND_DOWN);
1078	}
1079	}
1080	if(pkt->duration != 0 && (s->packet_buffer || s->parse_queue))
1081	update_initial_durations(s, st, pkt->stream_index, pkt->duration);
1082
1083	/* correct timestamps with byte offset if demuxers only have timestamps
1084	on packet boundaries */
1085	if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
1086	/* this will estimate bitrate based on this frame's duration and size */
1087	offset = av_rescale(pc->offset, pkt->duration, pkt->size);
1088	if(pkt->pts != AV_NOPTS_VALUE)
1089	pkt->pts += offset;
1090	if(pkt->dts != AV_NOPTS_VALUE)
1091	pkt->dts += offset;
1092	}
1093
1094	if (pc && pc->dts_sync_point >= 0) {
1095	// we have synchronization info from the parser
1096	int64_t den = st->codec->time_base.den * (int64_t) st->time_base.num;
1097	if (den > 0) {
1098	int64_t num = st->codec->time_base.num * (int64_t) st->time_base.den;
1099	if (pkt->dts != AV_NOPTS_VALUE) {
1100	// got DTS from the stream, update reference timestamp
1101	st->reference_dts = pkt->dts - pc->dts_ref_dts_delta * num / den;
1102	} else if (st->reference_dts != AV_NOPTS_VALUE) {
1103	// compute DTS based on reference timestamp
1104	pkt->dts = st->reference_dts + pc->dts_ref_dts_delta * num / den;
1105	}
1106
1107	if (st->reference_dts != AV_NOPTS_VALUE && pkt->pts == AV_NOPTS_VALUE)
1108	pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
1109
1110	if (pc->dts_sync_point > 0)
1111	st->reference_dts = pkt->dts; // new reference
1112	}
1113	}
1114
1115	/* This may be redundant, but it should not hurt. */
1116	if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
1117	presentation_delayed = 1;
1118
1119	av_dlog(NULL, "IN delayed:%d pts:%s, dts:%s cur_dts:%s st:%d pc:%p duration:%d\n",
1120	presentation_delayed, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts), pkt->stream_index, pc, pkt->duration);
1121	/* interpolate PTS and DTS if they are not present */
1122	//We skip H264 currently because delay and has_b_frames are not reliably set
1123	if((delay==0 || (delay==1 && pc)) && st->codec->codec_id != AV_CODEC_ID_H264){
1124	if (presentation_delayed) {
1125	/* DTS = decompression timestamp */
1126	/* PTS = presentation timestamp */
1127	if (pkt->dts == AV_NOPTS_VALUE)
1128	pkt->dts = st->last_IP_pts;
1129	update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1130	if (pkt->dts == AV_NOPTS_VALUE)
1131	pkt->dts = st->cur_dts;
1132
1133	/* this is tricky: the dts must be incremented by the duration
1134	of the frame we are displaying, i.e. the last I- or P-frame */
1135	if (st->last_IP_duration == 0)
1136	st->last_IP_duration = pkt->duration;
1137	if(pkt->dts != AV_NOPTS_VALUE)
1138	st->cur_dts = pkt->dts + st->last_IP_duration;
1139	st->last_IP_duration = pkt->duration;
1140	st->last_IP_pts= pkt->pts;
1141	/* cannot compute PTS if not present (we can compute it only
1142	by knowing the future */
1143	} else if (pkt->pts != AV_NOPTS_VALUE ||
1144	pkt->dts != AV_NOPTS_VALUE ||
1145	pkt->duration ) {
1146	int duration = pkt->duration;
1147
1148	/* presentation is not delayed : PTS and DTS are the same */
1149	if (pkt->pts == AV_NOPTS_VALUE)
1150	pkt->pts = pkt->dts;
1151	update_initial_timestamps(s, pkt->stream_index, pkt->pts,
1152	pkt->pts, pkt);
1153	if (pkt->pts == AV_NOPTS_VALUE)
1154	pkt->pts = st->cur_dts;
1155	pkt->dts = pkt->pts;
1156	if (pkt->pts != AV_NOPTS_VALUE)
1157	st->cur_dts = pkt->pts + duration;
1158	}
1159	}
1160
1161	if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY && has_decode_delay_been_guessed(st)){
1162	st->pts_buffer[0]= pkt->pts;
1163	for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
1164	FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
1165	if(pkt->dts == AV_NOPTS_VALUE)
1166	pkt->dts= st->pts_buffer[0];
1167	}
1168	if(st->codec->codec_id == AV_CODEC_ID_H264){ // we skipped it above so we try here
1169	update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt); // this should happen on the first packet
1170	}
1171	if(pkt->dts > st->cur_dts)
1172	st->cur_dts = pkt->dts;
1173
1174	av_dlog(NULL, "OUTdelayed:%d/%d pts:%s, dts:%s cur_dts:%s\n",
1175	presentation_delayed, delay, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts));
1176
1177	/* update flags */
1178	if (is_intra_only(st->codec))
1179	pkt->flags |= AV_PKT_FLAG_KEY;
1180	if (pc)
1181	pkt->convergence_duration = pc->convergence_duration;
1182	}
1183
1184	static void free_packet_buffer(AVPacketList **pkt_buf, AVPacketList **pkt_buf_end)
1185	{
1186	while (*pkt_buf) {
1187	AVPacketList *pktl = *pkt_buf;
1188	*pkt_buf = pktl->next;
1189	av_free_packet(&pktl->pkt);
1190	av_freep(&pktl);
1191	}
1192	*pkt_buf_end = NULL;
1193	}
1194
1195	/**
1196	* Parse a packet, add all split parts to parse_queue
1197	*
1198	* @param pkt packet to parse, NULL when flushing the parser at end of stream
1199	*/
1200	static int parse_packet(AVFormatContext *s, AVPacket *pkt, int stream_index)
1201	{
1202	AVPacket out_pkt = { 0 }, flush_pkt = { 0 };
1203	AVStream *st = s->streams[stream_index];
1204	uint8_t *data = pkt ? pkt->data : NULL;
1205	int size = pkt ? pkt->size : 0;
1206	int ret = 0, got_output = 0;
1207
1208	if (!pkt) {
1209	av_init_packet(&flush_pkt);
1210	pkt = &flush_pkt;
1211	got_output = 1;
1212	} else if (!size && st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) {
1213	// preserve 0-size sync packets
1214	compute_pkt_fields(s, st, st->parser, pkt);
1215	}
1216
1217	while (size > 0 || (pkt == &flush_pkt && got_output)) {
1218	int len;
1219
1220	av_init_packet(&out_pkt);
1221	len = av_parser_parse2(st->parser, st->codec,
1222	&out_pkt.data, &out_pkt.size, data, size,
1223	pkt->pts, pkt->dts, pkt->pos);
1224
1225	pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1226	pkt->pos = -1;
1227	/* increment read pointer */
1228	data += len;
1229	size -= len;
1230
1231	got_output = !!out_pkt.size;
1232
1233	if (!out_pkt.size)
1234	continue;
1235
1236	if (pkt->side_data) {
1237	out_pkt.side_data = pkt->side_data;
1238	out_pkt.side_data_elems = pkt->side_data_elems;
1239	pkt->side_data = NULL;
1240	pkt->side_data_elems = 0;
1241	}
1242
1243	/* set the duration */
1244	out_pkt.duration = 0;
1245	if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1246	if (st->codec->sample_rate > 0) {
1247	out_pkt.duration = av_rescale_q_rnd(st->parser->duration,
1248	(AVRational){ 1, st->codec->sample_rate },
1249	st->time_base,
1250	AV_ROUND_DOWN);
1251	}
1252	} else if (st->codec->time_base.num != 0 &&
1253	st->codec->time_base.den != 0) {
1254	out_pkt.duration = av_rescale_q_rnd(st->parser->duration,
1255	st->codec->time_base,
1256	st->time_base,
1257	AV_ROUND_DOWN);
1258	}
1259
1260	out_pkt.stream_index = st->index;
1261	out_pkt.pts = st->parser->pts;
1262	out_pkt.dts = st->parser->dts;
1263	out_pkt.pos = st->parser->pos;
1264
1265	if(st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1266	out_pkt.pos = st->parser->frame_offset;
1267
1268	if (st->parser->key_frame == 1 ||
1269	(st->parser->key_frame == -1 &&
1270	st->parser->pict_type == AV_PICTURE_TYPE_I))
1271	out_pkt.flags |= AV_PKT_FLAG_KEY;
1272
1273	if(st->parser->key_frame == -1 && st->parser->pict_type==AV_PICTURE_TYPE_NONE && (pkt->flags&AV_PKT_FLAG_KEY))
1274	out_pkt.flags |= AV_PKT_FLAG_KEY;
1275
1276	compute_pkt_fields(s, st, st->parser, &out_pkt);
1277
1278	if (out_pkt.data == pkt->data && out_pkt.size == pkt->size) {
1279	out_pkt.buf = pkt->buf;
1280	pkt->buf = NULL;
1281	#if FF_API_DESTRUCT_PACKET
1282	FF_DISABLE_DEPRECATION_WARNINGS
1283	out_pkt.destruct = pkt->destruct;
1284	pkt->destruct = NULL;
1285	FF_ENABLE_DEPRECATION_WARNINGS
1286	#endif
1287	}
1288	if ((ret = av_dup_packet(&out_pkt)) < 0)
1289	goto fail;
1290
1291	if (!add_to_pktbuf(&s->parse_queue, &out_pkt, &s->parse_queue_end)) {
1292	av_free_packet(&out_pkt);
1293	ret = AVERROR(ENOMEM);
1294	goto fail;
1295	}
1296	}
1297
1298
1299	/* end of the stream => close and free the parser */
1300	if (pkt == &flush_pkt) {
1301	av_parser_close(st->parser);
1302	st->parser = NULL;
1303	}
1304
1305	fail:
1306	av_free_packet(pkt);
1307	return ret;
1308	}
1309
1310	static int read_from_packet_buffer(AVPacketList **pkt_buffer,
1311	AVPacketList **pkt_buffer_end,
1312	AVPacket *pkt)
1313	{
1314	AVPacketList *pktl;
1315	av_assert0(*pkt_buffer);
1316	pktl = *pkt_buffer;
1317	*pkt = pktl->pkt;
1318	*pkt_buffer = pktl->next;
1319	if (!pktl->next)
1320	*pkt_buffer_end = NULL;
1321	av_freep(&pktl);
1322	return 0;
1323	}
1324
1325	static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1326	{
1327	int ret = 0, i, got_packet = 0;
1328
1329	av_init_packet(pkt);
1330
1331	while (!got_packet && !s->parse_queue) {
1332	AVStream *st;
1333	AVPacket cur_pkt;
1334
1335	/* read next packet */
1336	ret = ff_read_packet(s, &cur_pkt);
1337	if (ret < 0) {
1338	if (ret == AVERROR(EAGAIN))
1339	return ret;
1340	/* flush the parsers */
1341	for(i = 0; i < s->nb_streams; i++) {
1342	st = s->streams[i];
1343	if (st->parser && st->need_parsing)
1344	parse_packet(s, NULL, st->index);
1345	}
1346	/* all remaining packets are now in parse_queue =>
1347	* really terminate parsing */
1348	break;
1349	}
1350	ret = 0;
1351	st = s->streams[cur_pkt.stream_index];
1352
1353	if (cur_pkt.pts != AV_NOPTS_VALUE &&
1354	cur_pkt.dts != AV_NOPTS_VALUE &&
1355	cur_pkt.pts < cur_pkt.dts) {
1356	av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%s, dts=%s, size=%d\n",
1357	cur_pkt.stream_index,
1358	av_ts2str(cur_pkt.pts),
1359	av_ts2str(cur_pkt.dts),
1360	cur_pkt.size);
1361	}
1362	if (s->debug & FF_FDEBUG_TS)
1363	av_log(s, AV_LOG_DEBUG, "ff_read_packet stream=%d, pts=%s, dts=%s, size=%d, duration=%d, flags=%d\n",
1364	cur_pkt.stream_index,
1365	av_ts2str(cur_pkt.pts),
1366	av_ts2str(cur_pkt.dts),
1367	cur_pkt.size,
1368	cur_pkt.duration,
1369	cur_pkt.flags);
1370
1371	if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1372	st->parser = av_parser_init(st->codec->codec_id);
1373	if (!st->parser) {
1374	av_log(s, AV_LOG_VERBOSE, "parser not found for codec "
1375	"%s, packets or times may be invalid.\n",
1376	avcodec_get_name(st->codec->codec_id));
1377	/* no parser available: just output the raw packets */
1378	st->need_parsing = AVSTREAM_PARSE_NONE;
1379	} else if(st->need_parsing == AVSTREAM_PARSE_HEADERS) {
1380	st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1381	} else if(st->need_parsing == AVSTREAM_PARSE_FULL_ONCE) {
1382	st->parser->flags |= PARSER_FLAG_ONCE;
1383	} else if(st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
1384	st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
1385	}
1386	}
1387
1388	if (!st->need_parsing || !st->parser) {
1389	/* no parsing needed: we just output the packet as is */
1390	*pkt = cur_pkt;
1391	compute_pkt_fields(s, st, NULL, pkt);
1392	if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1393	(pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1394	ff_reduce_index(s, st->index);
1395	av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1396	}
1397	got_packet = 1;
1398	} else if (st->discard < AVDISCARD_ALL) {
1399	if ((ret = parse_packet(s, &cur_pkt, cur_pkt.stream_index)) < 0)
1400	return ret;
1401	} else {
1402	/* free packet */
1403	av_free_packet(&cur_pkt);
1404	}
1405	if (pkt->flags & AV_PKT_FLAG_KEY)
1406	st->skip_to_keyframe = 0;
1407	if (st->skip_to_keyframe) {
1408	av_free_packet(&cur_pkt);
1409	if (got_packet) {
1410	*pkt = cur_pkt;
1411	}
1412	got_packet = 0;
1413	}
1414	}
1415
1416	if (!got_packet && s->parse_queue)
1417	ret = read_from_packet_buffer(&s->parse_queue, &s->parse_queue_end, pkt);
1418
1419	if(s->debug & FF_FDEBUG_TS)
1420	av_log(s, AV_LOG_DEBUG, "read_frame_internal stream=%d, pts=%s, dts=%s, size=%d, duration=%d, flags=%d\n",
1421	pkt->stream_index,
1422	av_ts2str(pkt->pts),
1423	av_ts2str(pkt->dts),
1424	pkt->size,
1425	pkt->duration,
1426	pkt->flags);
1427
1428	return ret;
1429	}
1430
1431	int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1432	{
1433	const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1434	int eof = 0;
1435	int ret;
1436	AVStream *st;
1437
1438	if (!genpts) {
1439	ret = s->packet_buffer ?
1440	read_from_packet_buffer(&s->packet_buffer, &s->packet_buffer_end, pkt) :
1441	read_frame_internal(s, pkt);
1442	if (ret < 0)
1443	return ret;
1444	goto return_packet;
1445	}
1446
1447	for (;;) {
1448	AVPacketList *pktl = s->packet_buffer;
1449
1450	if (pktl) {
1451	AVPacket *next_pkt = &pktl->pkt;
1452
1453	if (next_pkt->dts != AV_NOPTS_VALUE) {
1454	int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1455	// last dts seen for this stream. if any of packets following
1456	// current one had no dts, we will set this to AV_NOPTS_VALUE.
1457	int64_t last_dts = next_pkt->dts;
1458	while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1459	if (pktl->pkt.stream_index == next_pkt->stream_index &&
1460	(av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)) < 0)) {
1461	if (av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) { //not b frame
1462	next_pkt->pts = pktl->pkt.dts;
1463	}
1464	if (last_dts != AV_NOPTS_VALUE) {
1465	// Once last dts was set to AV_NOPTS_VALUE, we don't change it.
1466	last_dts = pktl->pkt.dts;
1467	}
1468	}
1469	pktl = pktl->next;
1470	}
1471	if (eof && next_pkt->pts == AV_NOPTS_VALUE && last_dts != AV_NOPTS_VALUE) {
1472	// Fixing the last reference frame had none pts issue (For MXF etc).
1473	// We only do this when
1474	// 1. eof.
1475	// 2. we are not able to resolve a pts value for current packet.
1476	// 3. the packets for this stream at the end of the files had valid dts.
1477	next_pkt->pts = last_dts + next_pkt->duration;
1478	}
1479	pktl = s->packet_buffer;
1480	}
1481
1482	/* read packet from packet buffer, if there is data */
1483	if (!(next_pkt->pts == AV_NOPTS_VALUE &&
1484	next_pkt->dts != AV_NOPTS_VALUE && !eof)) {
1485	ret = read_from_packet_buffer(&s->packet_buffer,
1486	&s->packet_buffer_end, pkt);
1487	goto return_packet;
1488	}
1489	}
1490
1491	ret = read_frame_internal(s, pkt);
1492	if (ret < 0) {
1493	if (pktl && ret != AVERROR(EAGAIN)) {
1494	eof = 1;
1495	continue;
1496	} else
1497	return ret;
1498	}
1499
1500	if (av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1501	&s->packet_buffer_end)) < 0)
1502	return AVERROR(ENOMEM);
1503	}
1504
1505	return_packet:
1506
1507	st = s->streams[pkt->stream_index];
1508	if (st->skip_samples) {
1509	uint8_t *p = av_packet_new_side_data(pkt, AV_PKT_DATA_SKIP_SAMPLES, 10);
1510	if (p) {
1511	AV_WL32(p, st->skip_samples);
1512	av_log(s, AV_LOG_DEBUG, "demuxer injecting skip %d\n", st->skip_samples);
1513	}
1514	st->skip_samples = 0;
1515	}
1516
1517	if ((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY) {
1518	ff_reduce_index(s, st->index);
1519	av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1520	}
1521
1522	if (is_relative(pkt->dts))
1523	pkt->dts -= RELATIVE_TS_BASE;
1524	if (is_relative(pkt->pts))
1525	pkt->pts -= RELATIVE_TS_BASE;
1526
1527	return ret;
1528	}
1529
1530	/* XXX: suppress the packet queue */
1531	static void flush_packet_queue(AVFormatContext *s)
1532	{
1533	free_packet_buffer(&s->parse_queue, &s->parse_queue_end);
1534	free_packet_buffer(&s->packet_buffer, &s->packet_buffer_end);
1535	free_packet_buffer(&s->raw_packet_buffer, &s->raw_packet_buffer_end);
1536
1537	s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1538	}
1539
1540	/*******************************************************/
1541	/* seek support */
1542
1543	int av_find_default_stream_index(AVFormatContext *s)
1544	{
1545	int first_audio_index = -1;
1546	int i;
1547	AVStream *st;
1548
1549	if (s->nb_streams <= 0)
1550	return -1;
1551	for(i = 0; i < s->nb_streams; i++) {
1552	st = s->streams[i];
1553	if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1554	!(st->disposition & AV_DISPOSITION_ATTACHED_PIC)) {
1555	return i;
1556	}
1557	if (first_audio_index < 0 && st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1558	first_audio_index = i;
1559	}
1560	return first_audio_index >= 0 ? first_audio_index : 0;
1561	}
1562
1563	/**
1564	* Flush the frame reader.
1565	*/
1566	void ff_read_frame_flush(AVFormatContext *s)
1567	{
1568	AVStream *st;
1569	int i, j;
1570
1571	flush_packet_queue(s);
1572
1573	/* for each stream, reset read state */
1574	for(i = 0; i < s->nb_streams; i++) {
1575	st = s->streams[i];
1576
1577	if (st->parser) {
1578	av_parser_close(st->parser);
1579	st->parser = NULL;
1580	}
1581	st->last_IP_pts = AV_NOPTS_VALUE;
1582	if(st->first_dts == AV_NOPTS_VALUE) st->cur_dts = RELATIVE_TS_BASE;
1583	else st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1584	st->reference_dts = AV_NOPTS_VALUE;
1585
1586	st->probe_packets = MAX_PROBE_PACKETS;
1587
1588	for(j=0; j<MAX_REORDER_DELAY+1; j++)
1589	st->pts_buffer[j]= AV_NOPTS_VALUE;
1590	}
1591	}
1592
1593	void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1594	{
1595	int i;
1596
1597	for(i = 0; i < s->nb_streams; i++) {
1598	AVStream *st = s->streams[i];
1599
1600	st->cur_dts = av_rescale(timestamp,
1601	st->time_base.den * (int64_t)ref_st->time_base.num,
1602	st->time_base.num * (int64_t)ref_st->time_base.den);
1603	}
1604	}
1605
1606	void ff_reduce_index(AVFormatContext *s, int stream_index)
1607	{
1608	AVStream *st= s->streams[stream_index];
1609	unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1610
1611	if((unsigned)st->nb_index_entries >= max_entries){
1612	int i;
1613	for(i=0; 2*i<st->nb_index_entries; i++)
1614	st->index_entries[i]= st->index_entries[2*i];
1615	st->nb_index_entries= i;
1616	}
1617	}
1618
1619	int ff_add_index_entry(AVIndexEntry **index_entries,
1620	int *nb_index_entries,
1621	unsigned int *index_entries_allocated_size,
1622	int64_t pos, int64_t timestamp, int size, int distance, int flags)
1623	{
1624	AVIndexEntry *entries, *ie;
1625	int index;
1626
1627	if((unsigned)*nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1628	return -1;
1629
1630	if(timestamp == AV_NOPTS_VALUE)
1631	return AVERROR(EINVAL);
1632
1633	if (size < 0 || size > 0x3FFFFFFF)
1634	return AVERROR(EINVAL);
1635
1636	if (is_relative(timestamp)) //FIXME this maintains previous behavior but we should shift by the correct offset once known
1637	timestamp -= RELATIVE_TS_BASE;
1638
1639	entries = av_fast_realloc(*index_entries,
1640	index_entries_allocated_size,
1641	(*nb_index_entries + 1) *
1642	sizeof(AVIndexEntry));
1643	if(!entries)
1644	return -1;
1645
1646	*index_entries= entries;
1647
1648	index= ff_index_search_timestamp(*index_entries, *nb_index_entries, timestamp, AVSEEK_FLAG_ANY);
1649
1650	if(index<0){
1651	index= (*nb_index_entries)++;
1652	ie= &entries[index];
1653	av_assert0(index==0 || ie[-1].timestamp < timestamp);
1654	}else{
1655	ie= &entries[index];
1656	if(ie->timestamp != timestamp){
1657	if(ie->timestamp <= timestamp)
1658	return -1;
1659	memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(*nb_index_entries - index));
1660	(*nb_index_entries)++;
1661	}else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1662	distance= ie->min_distance;
1663	}
1664
1665	ie->pos = pos;
1666	ie->timestamp = timestamp;
1667	ie->min_distance= distance;
1668	ie->size= size;
1669	ie->flags = flags;
1670
1671	return index;
1672	}
1673
1674	int av_add_index_entry(AVStream *st,
1675	int64_t pos, int64_t timestamp, int size, int distance, int flags)
1676	{
1677	timestamp = wrap_timestamp(st, timestamp);
1678	return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1679	&st->index_entries_allocated_size, pos,
1680	timestamp, size, distance, flags);
1681	}
1682
1683	int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1684	int64_t wanted_timestamp, int flags)
1685	{
1686	int a, b, m;
1687	int64_t timestamp;
1688
1689	a = - 1;
1690	b = nb_entries;
1691
1692	//optimize appending index entries at the end
1693	if(b && entries[b-1].timestamp < wanted_timestamp)
1694	a= b-1;
1695
1696	while (b - a > 1) {
1697	m = (a + b) >> 1;
1698	timestamp = entries[m].timestamp;
1699	if(timestamp >= wanted_timestamp)
1700	b = m;
1701	if(timestamp <= wanted_timestamp)
1702	a = m;
1703	}
1704	m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1705
1706	if(!(flags & AVSEEK_FLAG_ANY)){
1707	while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1708	m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1709	}
1710	}
1711
1712	if(m == nb_entries)
1713	return -1;
1714	return m;
1715	}
1716
1717	int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1718	int flags)
1719	{
1720	return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
1721	wanted_timestamp, flags);
1722	}
1723
1724	static int64_t ff_read_timestamp(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit,
1725	int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1726	{
1727	int64_t ts = read_timestamp(s, stream_index, ppos, pos_limit);
1728	if (stream_index >= 0)
1729	ts = wrap_timestamp(s->streams[stream_index], ts);
1730	return ts;
1731	}
1732
1733	int ff_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags)
1734	{
1735	AVInputFormat *avif= s->iformat;
1736	int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1737	int64_t ts_min, ts_max, ts;
1738	int index;
1739	int64_t ret;
1740	AVStream *st;
1741
1742	if (stream_index < 0)
1743	return -1;
1744
1745	av_dlog(s, "read_seek: %d %s\n", stream_index, av_ts2str(target_ts));
1746
1747	ts_max=
1748	ts_min= AV_NOPTS_VALUE;
1749	pos_limit= -1; //gcc falsely says it may be uninitialized
1750
1751	st= s->streams[stream_index];
1752	if(st->index_entries){
1753	AVIndexEntry *e;
1754
1755	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()
1756	index= FFMAX(index, 0);
1757	e= &st->index_entries[index];
1758
1759	if(e->timestamp <= target_ts || e->pos == e->min_distance){
1760	pos_min= e->pos;
1761	ts_min= e->timestamp;
1762	av_dlog(s, "using cached pos_min=0x%"PRIx64" dts_min=%s\n",
1763	pos_min, av_ts2str(ts_min));
1764	}else{
1765	av_assert1(index==0);
1766	}
1767
1768	index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1769	av_assert0(index < st->nb_index_entries);
1770	if(index >= 0){
1771	e= &st->index_entries[index];
1772	av_assert1(e->timestamp >= target_ts);
1773	pos_max= e->pos;
1774	ts_max= e->timestamp;
1775	pos_limit= pos_max - e->min_distance;
1776	av_dlog(s, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%s\n",
1777	pos_max, pos_limit, av_ts2str(ts_max));
1778	}
1779	}
1780
1781	pos= ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1782	if(pos<0)
1783	return -1;
1784
1785	/* do the seek */
1786	if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
1787	return ret;
1788
1789	ff_read_frame_flush(s);
1790	ff_update_cur_dts(s, st, ts);
1791
1792	return 0;
1793	}
1794
1795	int ff_find_last_ts(AVFormatContext *s, int stream_index, int64_t *ts, int64_t *pos,
1796	int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1797	{
1798	int64_t step= 1024;
1799	int64_t limit, ts_max;
1800	int64_t filesize = avio_size(s->pb);
1801	int64_t pos_max = filesize - 1;
1802	do{
1803	limit = pos_max;
1804	pos_max = FFMAX(0, (pos_max) - step);
1805	ts_max = ff_read_timestamp(s, stream_index, &pos_max, limit, read_timestamp);
1806	step += step;
1807	}while(ts_max == AV_NOPTS_VALUE && 2*limit > step);
1808	if (ts_max == AV_NOPTS_VALUE)
1809	return -1;
1810
1811	for(;;){
1812	int64_t tmp_pos = pos_max + 1;
1813	int64_t tmp_ts = ff_read_timestamp(s, stream_index, &tmp_pos, INT64_MAX, read_timestamp);
1814	if(tmp_ts == AV_NOPTS_VALUE)
1815	break;
1816	av_assert0(tmp_pos > pos_max);
1817	ts_max = tmp_ts;
1818	pos_max = tmp_pos;
1819	if(tmp_pos >= filesize)
1820	break;
1821	}
1822
1823	if (ts)
1824	*ts = ts_max;
1825	if (pos)
1826	*pos = pos_max;
1827
1828	return 0;
1829	}
1830
1831	int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
1832	int64_t pos_min, int64_t pos_max, int64_t pos_limit,
1833	int64_t ts_min, int64_t ts_max, int flags, int64_t *ts_ret,
1834	int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1835	{
1836	int64_t pos, ts;
1837	int64_t start_pos;
1838	int no_change;
1839	int ret;
1840
1841	av_dlog(s, "gen_seek: %d %s\n", stream_index, av_ts2str(target_ts));
1842
1843	if(ts_min == AV_NOPTS_VALUE){
1844	pos_min = s->data_offset;
1845	ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1846	if (ts_min == AV_NOPTS_VALUE)
1847	return -1;
1848	}
1849
1850	if(ts_min >= target_ts){
1851	*ts_ret= ts_min;
1852	return pos_min;
1853	}
1854
1855	if(ts_max == AV_NOPTS_VALUE){
1856	if ((ret = ff_find_last_ts(s, stream_index, &ts_max, &pos_max, read_timestamp)) < 0)
1857	return ret;
1858	pos_limit= pos_max;
1859	}
1860
1861	if(ts_max <= target_ts){
1862	*ts_ret= ts_max;
1863	return pos_max;
1864	}
1865
1866	if(ts_min > ts_max){
1867	return -1;
1868	}else if(ts_min == ts_max){
1869	pos_limit= pos_min;
1870	}
1871
1872	no_change=0;
1873	while (pos_min < pos_limit) {
1874	av_dlog(s, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%s dts_max=%s\n",
1875	pos_min, pos_max, av_ts2str(ts_min), av_ts2str(ts_max));
1876	assert(pos_limit <= pos_max);
1877
1878	if(no_change==0){
1879	int64_t approximate_keyframe_distance= pos_max - pos_limit;
1880	// interpolate position (better than dichotomy)
1881	pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1882	+ pos_min - approximate_keyframe_distance;
1883	}else if(no_change==1){
1884	// bisection, if interpolation failed to change min or max pos last time
1885	pos = (pos_min + pos_limit)>>1;
1886	}else{
1887	/* linear search if bisection failed, can only happen if there
1888	are very few or no keyframes between min/max */
1889	pos=pos_min;
1890	}
1891	if(pos <= pos_min)
1892	pos= pos_min + 1;
1893	else if(pos > pos_limit)
1894	pos= pos_limit;
1895	start_pos= pos;
1896
1897	ts = ff_read_timestamp(s, stream_index, &pos, INT64_MAX, read_timestamp); //may pass pos_limit instead of -1
1898	if(pos == pos_max)
1899	no_change++;
1900	else
1901	no_change=0;
1902	av_dlog(s, "%"PRId64" %"PRId64" %"PRId64" / %s %s %s target:%s limit:%"PRId64" start:%"PRId64" noc:%d\n",
1903	pos_min, pos, pos_max,
1904	av_ts2str(ts_min), av_ts2str(ts), av_ts2str(ts_max), av_ts2str(target_ts),
1905	pos_limit, start_pos, no_change);
1906	if(ts == AV_NOPTS_VALUE){
1907	av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1908	return -1;
1909	}
1910	assert(ts != AV_NOPTS_VALUE);
1911	if (target_ts <= ts) {
1912	pos_limit = start_pos - 1;
1913	pos_max = pos;
1914	ts_max = ts;
1915	}
1916	if (target_ts >= ts) {
1917	pos_min = pos;
1918	ts_min = ts;
1919	}
1920	}
1921
1922	pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1923	ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
1924	#if 0
1925	pos_min = pos;
1926	ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1927	pos_min++;
1928	ts_max = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1929	av_dlog(s, "pos=0x%"PRIx64" %s<=%s<=%s\n",
1930	pos, av_ts2str(ts_min), av_ts2str(target_ts), av_ts2str(ts_max));
1931	#endif
1932	*ts_ret= ts;
1933	return pos;
1934	}
1935
1936	static int seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1937	int64_t pos_min, pos_max;
1938
1939	pos_min = s->data_offset;
1940	pos_max = avio_size(s->pb) - 1;
1941
1942	if (pos < pos_min) pos= pos_min;
1943	else if(pos > pos_max) pos= pos_max;
1944
1945	avio_seek(s->pb, pos, SEEK_SET);
1946
1947	s->io_repositioned = 1;
1948
1949	return 0;
1950	}
1951
1952	static int seek_frame_generic(AVFormatContext *s,
1953	int stream_index, int64_t timestamp, int flags)
1954	{
1955	int index;
1956	int64_t ret;
1957	AVStream *st;
1958	AVIndexEntry *ie;
1959
1960	st = s->streams[stream_index];
1961
1962	index = av_index_search_timestamp(st, timestamp, flags);
1963
1964	if(index < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
1965	return -1;
1966
1967	if(index < 0 || index==st->nb_index_entries-1){
1968	AVPacket pkt;
1969	int nonkey=0;
1970
1971	if(st->nb_index_entries){
1972	av_assert0(st->index_entries);
1973	ie= &st->index_entries[st->nb_index_entries-1];
1974	if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1975	return ret;
1976	ff_update_cur_dts(s, st, ie->timestamp);
1977	}else{
1978	if ((ret = avio_seek(s->pb, s->data_offset, SEEK_SET)) < 0)
1979	return ret;
1980	}
1981	for (;;) {
1982	int read_status;
1983	do{
1984	read_status = av_read_frame(s, &pkt);
1985	} while (read_status == AVERROR(EAGAIN));
1986	if (read_status < 0)
1987	break;
1988	av_free_packet(&pkt);
1989	if(stream_index == pkt.stream_index && pkt.dts > timestamp){
1990	if(pkt.flags & AV_PKT_FLAG_KEY)
1991	break;
1992	if(nonkey++ > 1000 && st->codec->codec_id != AV_CODEC_ID_CDGRAPHICS){
1993	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);
1994	break;
1995	}
1996	}
1997	}
1998	index = av_index_search_timestamp(st, timestamp, flags);
1999	}
2000	if (index < 0)
2001	return -1;
2002
2003	ff_read_frame_flush(s);
2004	if (s->iformat->read_seek){
2005	if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
2006	return 0;
2007	}
2008	ie = &st->index_entries[index];
2009	if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2010	return ret;
2011	ff_update_cur_dts(s, st, ie->timestamp);
2012
2013	return 0;
2014	}
2015
2016	static int seek_frame_internal(AVFormatContext *s, int stream_index,
2017	int64_t timestamp, int flags)
2018	{
2019	int ret;
2020	AVStream *st;
2021
2022	if (flags & AVSEEK_FLAG_BYTE) {
2023	if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
2024	return -1;
2025	ff_read_frame_flush(s);
2026	return seek_frame_byte(s, stream_index, timestamp, flags);
2027	}
2028
2029	if(stream_index < 0){
2030	stream_index= av_find_default_stream_index(s);
2031	if(stream_index < 0)
2032	return -1;
2033
2034	st= s->streams[stream_index];
2035	/* timestamp for default must be expressed in AV_TIME_BASE units */
2036	timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
2037	}
2038
2039	/* first, we try the format specific seek */
2040	if (s->iformat->read_seek) {
2041	ff_read_frame_flush(s);
2042	ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
2043	} else
2044	ret = -1;
2045	if (ret >= 0) {
2046	return 0;
2047	}
2048
2049	if (s->iformat->read_timestamp && !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
2050	ff_read_frame_flush(s);
2051	return ff_seek_frame_binary(s, stream_index, timestamp, flags);
2052	} else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
2053	ff_read_frame_flush(s);
2054	return seek_frame_generic(s, stream_index, timestamp, flags);
2055	}
2056	else
2057	return -1;
2058	}
2059
2060	int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
2061	{
2062	int ret;
2063
2064	if (s->iformat->read_seek2 && !s->iformat->read_seek) {
2065	int64_t min_ts = INT64_MIN, max_ts = INT64_MAX;
2066	if ((flags & AVSEEK_FLAG_BACKWARD))
2067	max_ts = timestamp;
2068	else
2069	min_ts = timestamp;
2070	return avformat_seek_file(s, stream_index, min_ts, timestamp, max_ts,
2071	flags & ~AVSEEK_FLAG_BACKWARD);
2072	}
2073
2074	ret = seek_frame_internal(s, stream_index, timestamp, flags);
2075
2076	if (ret >= 0)
2077	ret = avformat_queue_attached_pictures(s);
2078
2079	return ret;
2080	}
2081
2082	int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
2083	{
2084	if(min_ts > ts || max_ts < ts)
2085	return -1;
2086	if (stream_index < -1 || stream_index >= (int)s->nb_streams)
2087	return AVERROR(EINVAL);
2088
2089	if(s->seek2any>0)
2090	flags |= AVSEEK_FLAG_ANY;
2091	flags &= ~AVSEEK_FLAG_BACKWARD;
2092
2093	if (s->iformat->read_seek2) {
2094	int ret;
2095	ff_read_frame_flush(s);
2096
2097	if (stream_index == -1 && s->nb_streams == 1) {
2098	AVRational time_base = s->streams[0]->time_base;
2099	ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
2100	min_ts = av_rescale_rnd(min_ts, time_base.den,
2101	time_base.num * (int64_t)AV_TIME_BASE,
2102	AV_ROUND_UP | AV_ROUND_PASS_MINMAX);
2103	max_ts = av_rescale_rnd(max_ts, time_base.den,
2104	time_base.num * (int64_t)AV_TIME_BASE,
2105	AV_ROUND_DOWN | AV_ROUND_PASS_MINMAX);
2106	}
2107
2108	ret = s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
2109
2110	if (ret >= 0)
2111	ret = avformat_queue_attached_pictures(s);
2112	return ret;
2113	}
2114
2115	if(s->iformat->read_timestamp){
2116	//try to seek via read_timestamp()
2117	}
2118
2119	// Fall back on old API if new is not implemented but old is.
2120	// Note the old API has somewhat different semantics.
2121	if (s->iformat->read_seek || 1) {
2122	int dir = (ts - (uint64_t)min_ts > (uint64_t)max_ts - ts ? AVSEEK_FLAG_BACKWARD : 0);
2123	int ret = av_seek_frame(s, stream_index, ts, flags | dir);
2124	if (ret<0 && ts != min_ts && max_ts != ts) {
2125	ret = av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
2126	if (ret >= 0)
2127	ret = av_seek_frame(s, stream_index, ts, flags | (dir^AVSEEK_FLAG_BACKWARD));
2128	}
2129	return ret;
2130	}
2131
2132	// try some generic seek like seek_frame_generic() but with new ts semantics
2133	return -1; //unreachable
2134	}
2135
2136	/*******************************************************/
2137
2138	/**
2139	* Return TRUE if the stream has accurate duration in any stream.
2140	*
2141	* @return TRUE if the stream has accurate duration for at least one component.
2142	*/
2143	static int has_duration(AVFormatContext *ic)
2144	{
2145	int i;
2146	AVStream *st;
2147
2148	for(i = 0;i < ic->nb_streams; i++) {
2149	st = ic->streams[i];
2150	if (st->duration != AV_NOPTS_VALUE)
2151	return 1;
2152	}
2153	if (ic->duration != AV_NOPTS_VALUE)
2154	return 1;
2155	return 0;
2156	}
2157
2158	/**
2159	* Estimate the stream timings from the one of each components.
2160	*
2161	* Also computes the global bitrate if possible.
2162	*/
2163	static void update_stream_timings(AVFormatContext *ic)
2164	{
2165	int64_t start_time, start_time1, start_time_text, end_time, end_time1;
2166	int64_t duration, duration1, filesize;
2167	int i;
2168	AVStream *st;
2169	AVProgram *p;
2170
2171	start_time = INT64_MAX;
2172	start_time_text = INT64_MAX;
2173	end_time = INT64_MIN;
2174	duration = INT64_MIN;
2175	for(i = 0;i < ic->nb_streams; i++) {
2176	st = ic->streams[i];
2177	if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
2178	start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
2179	if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE || st->codec->codec_type == AVMEDIA_TYPE_DATA) {
2180	if (start_time1 < start_time_text)
2181	start_time_text = start_time1;
2182	} else
2183	start_time = FFMIN(start_time, start_time1);
2184	end_time1 = AV_NOPTS_VALUE;
2185	if (st->duration != AV_NOPTS_VALUE) {
2186	end_time1 = start_time1
2187	+ av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
2188	end_time = FFMAX(end_time, end_time1);
2189	}
2190	for(p = NULL; (p = av_find_program_from_stream(ic, p, i)); ){
2191	if(p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1)
2192	p->start_time = start_time1;
2193	if(p->end_time < end_time1)
2194	p->end_time = end_time1;
2195	}
2196	}
2197	if (st->duration != AV_NOPTS_VALUE) {
2198	duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
2199	duration = FFMAX(duration, duration1);
2200	}
2201	}
2202	if (start_time == INT64_MAX || (start_time > start_time_text && start_time - start_time_text < AV_TIME_BASE))
2203	start_time = start_time_text;
2204	else if(start_time > start_time_text)
2205	av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);
2206
2207	if (start_time != INT64_MAX) {
2208	ic->start_time = start_time;
2209	if (end_time != INT64_MIN) {
2210	if (ic->nb_programs) {
2211	for (i=0; i<ic->nb_programs; i++) {
2212	p = ic->programs[i];
2213	if(p->start_time != AV_NOPTS_VALUE && p->end_time > p->start_time)
2214	duration = FFMAX(duration, p->end_time - p->start_time);
2215	}
2216	} else
2217	duration = FFMAX(duration, end_time - start_time);
2218	}
2219	}
2220	if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
2221	ic->duration = duration;
2222	}
2223	if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration != AV_NOPTS_VALUE) {
2224	/* compute the bitrate */
2225	double bitrate = (double)filesize * 8.0 * AV_TIME_BASE /
2226	(double)ic->duration;
2227	if (bitrate >= 0 && bitrate <= INT_MAX)
2228	ic->bit_rate = bitrate;
2229	}
2230	}
2231
2232	static void fill_all_stream_timings(AVFormatContext *ic)
2233	{
2234	int i;
2235	AVStream *st;
2236
2237	update_stream_timings(ic);
2238	for(i = 0;i < ic->nb_streams; i++) {
2239	st = ic->streams[i];
2240	if (st->start_time == AV_NOPTS_VALUE) {
2241	if(ic->start_time != AV_NOPTS_VALUE)
2242	st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
2243	if(ic->duration != AV_NOPTS_VALUE)
2244	st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
2245	}
2246	}
2247	}
2248
2249	static void estimate_timings_from_bit_rate(AVFormatContext *ic)
2250	{
2251	int64_t filesize, duration;
2252	int i, show_warning = 0;
2253	AVStream *st;
2254
2255	/* if bit_rate is already set, we believe it */
2256	if (ic->bit_rate <= 0) {
2257	int bit_rate = 0;
2258	for(i=0;i<ic->nb_streams;i++) {
2259	st = ic->streams[i];
2260	if (st->codec->bit_rate > 0) {
2261	if (INT_MAX - st->codec->bit_rate < bit_rate) {
2262	bit_rate = 0;
2263	break;
2264	}
2265	bit_rate += st->codec->bit_rate;
2266	}
2267	}
2268	ic->bit_rate = bit_rate;
2269	}
2270
2271	/* if duration is already set, we believe it */
2272	if (ic->duration == AV_NOPTS_VALUE &&
2273	ic->bit_rate != 0) {
2274	filesize = ic->pb ? avio_size(ic->pb) : 0;
2275	if (filesize > 0) {
2276	for(i = 0; i < ic->nb_streams; i++) {
2277	st = ic->streams[i];
2278	if ( st->time_base.num <= INT64_MAX / ic->bit_rate
2279	&& st->duration == AV_NOPTS_VALUE) {
2280	duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
2281	st->duration = duration;
2282	show_warning = 1;
2283	}
2284	}
2285	}
2286	}
2287	if (show_warning)
2288	av_log(ic, AV_LOG_WARNING, "Estimating duration from bitrate, this may be inaccurate\n");
2289	}
2290
2291	#define DURATION_MAX_READ_SIZE 250000LL
2292	#define DURATION_MAX_RETRY 4
2293
2294	/* only usable for MPEG-PS streams */
2295	static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2296	{
2297	AVPacket pkt1, *pkt = &pkt1;
2298	AVStream *st;
2299	int read_size, i, ret;
2300	int64_t end_time;
2301	int64_t filesize, offset, duration;
2302	int retry=0;
2303
2304	/* flush packet queue */
2305	flush_packet_queue(ic);
2306
2307	for (i=0; i<ic->nb_streams; i++) {
2308	st = ic->streams[i];
2309	if (st->start_time == AV_NOPTS_VALUE && st->first_dts == AV_NOPTS_VALUE)
2310	av_log(st->codec, AV_LOG_WARNING, "start time is not set in estimate_timings_from_pts\n");
2311
2312	if (st->parser) {
2313	av_parser_close(st->parser);
2314	st->parser= NULL;
2315	}
2316	}
2317
2318	/* estimate the end time (duration) */
2319	/* XXX: may need to support wrapping */
2320	filesize = ic->pb ? avio_size(ic->pb) : 0;
2321	end_time = AV_NOPTS_VALUE;
2322	do{
2323	offset = filesize - (DURATION_MAX_READ_SIZE<<retry);
2324	if (offset < 0)
2325	offset = 0;
2326
2327	avio_seek(ic->pb, offset, SEEK_SET);
2328	read_size = 0;
2329	for(;;) {
2330	if (read_size >= DURATION_MAX_READ_SIZE<<(FFMAX(retry-1,0)))
2331	break;
2332
2333	do {
2334	ret = ff_read_packet(ic, pkt);
2335	} while(ret == AVERROR(EAGAIN));
2336	if (ret != 0)
2337	break;
2338	read_size += pkt->size;
2339	st = ic->streams[pkt->stream_index];
2340	if (pkt->pts != AV_NOPTS_VALUE &&
2341	(st->start_time != AV_NOPTS_VALUE ||
2342	st->first_dts != AV_NOPTS_VALUE)) {
2343	duration = end_time = pkt->pts;
2344	if (st->start_time != AV_NOPTS_VALUE)
2345	duration -= st->start_time;
2346	else
2347	duration -= st->first_dts;
2348	if (duration > 0) {
2349	if (st->duration == AV_NOPTS_VALUE || st->info->last_duration<=0 ||
2350	(st->duration < duration && FFABS(duration - st->info->last_duration) < 60LL*st->time_base.den / st->time_base.num))
2351	st->duration = duration;
2352	st->info->last_duration = duration;
2353	}
2354	}
2355	av_free_packet(pkt);
2356	}
2357	}while( end_time==AV_NOPTS_VALUE
2358	&& filesize > (DURATION_MAX_READ_SIZE<<retry)
2359	&& ++retry <= DURATION_MAX_RETRY);
2360
2361	fill_all_stream_timings(ic);
2362
2363	avio_seek(ic->pb, old_offset, SEEK_SET);
2364	for (i=0; i<ic->nb_streams; i++) {
2365	st= ic->streams[i];
2366	st->cur_dts= st->first_dts;
2367	st->last_IP_pts = AV_NOPTS_VALUE;
2368	st->reference_dts = AV_NOPTS_VALUE;
2369	}
2370	}
2371
2372	static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2373	{
2374	int64_t file_size;
2375
2376	/* get the file size, if possible */
2377	if (ic->iformat->flags & AVFMT_NOFILE) {
2378	file_size = 0;
2379	} else {
2380	file_size = avio_size(ic->pb);
2381	file_size = FFMAX(0, file_size);
2382	}
2383
2384	if ((!strcmp(ic->iformat->name, "mpeg") ||
2385	!strcmp(ic->iformat->name, "mpegts")) &&
2386	file_size && ic->pb->seekable) {
2387	/* get accurate estimate from the PTSes */
2388	estimate_timings_from_pts(ic, old_offset);
2389	ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
2390	} else if (has_duration(ic)) {
2391	/* at least one component has timings - we use them for all
2392	the components */
2393	fill_all_stream_timings(ic);
2394	ic->duration_estimation_method = AVFMT_DURATION_FROM_STREAM;
2395	} else {
2396	/* less precise: use bitrate info */
2397	estimate_timings_from_bit_rate(ic);
2398	ic->duration_estimation_method = AVFMT_DURATION_FROM_BITRATE;
2399	}
2400	update_stream_timings(ic);
2401
2402	{
2403	int i;
2404	AVStream av_unused *st;
2405	for(i = 0;i < ic->nb_streams; i++) {
2406	st = ic->streams[i];
2407	av_dlog(ic, "%d: start_time: %0.3f duration: %0.3f\n", i,
2408	(double) st->start_time / AV_TIME_BASE,
2409	(double) st->duration / AV_TIME_BASE);
2410	}
2411	av_dlog(ic, "stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2412	(double) ic->start_time / AV_TIME_BASE,
2413	(double) ic->duration / AV_TIME_BASE,
2414	ic->bit_rate / 1000);
2415	}
2416	}
2417
2418	static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
2419	{
2420	AVCodecContext *avctx = st->codec;
2421
2422	#define FAIL(errmsg) do { \
2423	if (errmsg_ptr) \
2424	*errmsg_ptr = errmsg; \
2425	return 0; \
2426	} while (0)
2427
2428	switch (avctx->codec_type) {
2429	case AVMEDIA_TYPE_AUDIO:
2430	if (!avctx->frame_size && determinable_frame_size(avctx))
2431	FAIL("unspecified frame size");
2432	if (st->info->found_decoder >= 0 && avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
2433	FAIL("unspecified sample format");
2434	if (!avctx->sample_rate)
2435	FAIL("unspecified sample rate");
2436	if (!avctx->channels)
2437	FAIL("unspecified number of channels");
2438	if (st->info->found_decoder >= 0 && !st->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
2439	FAIL("no decodable DTS frames");
2440	break;
2441	case AVMEDIA_TYPE_VIDEO:
2442	if (!avctx->width)
2443	FAIL("unspecified size");
2444	if (st->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
2445	FAIL("unspecified pixel format");
2446	if (st->codec->codec_id == AV_CODEC_ID_RV30 || st->codec->codec_id == AV_CODEC_ID_RV40)
2447	if (!st->sample_aspect_ratio.num && !st->codec->sample_aspect_ratio.num && !st->codec_info_nb_frames)
2448	FAIL("no frame in rv30/40 and no sar");
2449	break;
2450	case AVMEDIA_TYPE_SUBTITLE:
2451	if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
2452	FAIL("unspecified size");
2453	break;
2454	case AVMEDIA_TYPE_DATA:
2455	if(avctx->codec_id == AV_CODEC_ID_NONE) return 1;
2456	}
2457
2458	if (avctx->codec_id == AV_CODEC_ID_NONE)
2459	FAIL("unknown codec");
2460	return 1;
2461	}
2462
2463	/* returns 1 or 0 if or if not decoded data was returned, or a negative error */
2464	static int try_decode_frame(AVFormatContext *s, AVStream *st, AVPacket *avpkt, AVDictionary **options)
2465	{
2466	const AVCodec *codec;
2467	int got_picture = 1, ret = 0;
2468	AVFrame *frame = avcodec_alloc_frame();
2469	AVSubtitle subtitle;
2470	AVPacket pkt = *avpkt;
2471
2472	if (!frame)
2473	return AVERROR(ENOMEM);
2474
2475	if (!avcodec_is_open(st->codec) && !st->info->found_decoder) {
2476	AVDictionary *thread_opt = NULL;
2477
2478	codec = find_decoder(s, st, st->codec->codec_id);
2479
2480	if (!codec) {
2481	st->info->found_decoder = -1;
2482	ret = -1;
2483	goto fail;
2484	}
2485
2486	/* force thread count to 1 since the h264 decoder will not extract SPS
2487	* and PPS to extradata during multi-threaded decoding */
2488	av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
2489	ret = avcodec_open2(st->codec, codec, options ? options : &thread_opt);
2490	if (!options)
2491	av_dict_free(&thread_opt);
2492	if (ret < 0) {
2493	st->info->found_decoder = -1;
2494	goto fail;
2495	}
2496	st->info->found_decoder = 1;
2497	} else if (!st->info->found_decoder)
2498	st->info->found_decoder = 1;
2499
2500	if (st->info->found_decoder < 0) {
2501	ret = -1;
2502	goto fail;
2503	}
2504
2505	while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
2506	ret >= 0 &&
2507	(!has_codec_parameters(st, NULL) ||
2508	!has_decode_delay_been_guessed(st) ||
2509	(!st->codec_info_nb_frames && st->codec->codec->capabilities & CODEC_CAP_CHANNEL_CONF))) {
2510	got_picture = 0;
2511	avcodec_get_frame_defaults(frame);
2512	switch(st->codec->codec_type) {
2513	case AVMEDIA_TYPE_VIDEO:
2514	ret = avcodec_decode_video2(st->codec, frame,
2515	&got_picture, &pkt);
2516	break;
2517	case AVMEDIA_TYPE_AUDIO:
2518	ret = avcodec_decode_audio4(st->codec, frame, &got_picture, &pkt);
2519	break;
2520	case AVMEDIA_TYPE_SUBTITLE:
2521	ret = avcodec_decode_subtitle2(st->codec, &subtitle,
2522	&got_picture, &pkt);
2523	ret = pkt.size;
2524	break;
2525	default:
2526	break;
2527	}
2528	if (ret >= 0) {
2529	if (got_picture)
2530	st->nb_decoded_frames++;
2531	pkt.data += ret;
2532	pkt.size -= ret;
2533	ret = got_picture;
2534	}
2535	}
2536
2537	if(!pkt.data && !got_picture)
2538	ret = -1;
2539
2540	fail:
2541	avcodec_free_frame(&frame);
2542	return ret;
2543	}
2544
2545	unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
2546	{
2547	while (tags->id != AV_CODEC_ID_NONE) {
2548	if (tags->id == id)
2549	return tags->tag;
2550	tags++;
2551	}
2552	return 0;
2553	}
2554
2555	enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2556	{
2557	int i;
2558	for(i=0; tags[i].id != AV_CODEC_ID_NONE;i++) {
2559	if(tag == tags[i].tag)
2560	return tags[i].id;
2561	}
2562	for(i=0; tags[i].id != AV_CODEC_ID_NONE; i++) {
2563	if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
2564	return tags[i].id;
2565	}
2566	return AV_CODEC_ID_NONE;
2567	}
2568
2569	enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
2570	{
2571	if (flt) {
2572	switch (bps) {
2573	case 32: return be ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;
2574	case 64: return be ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE;
2575	default: return AV_CODEC_ID_NONE;
2576	}
2577	} else {
2578	bps += 7;
2579	bps >>= 3;
2580	if (sflags & (1 << (bps - 1))) {
2581	switch (bps) {
2582	case 1: return AV_CODEC_ID_PCM_S8;
2583	case 2: return be ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;
2584	case 3: return be ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
2585	case 4: return be ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
2586	default: return AV_CODEC_ID_NONE;
2587	}
2588	} else {
2589	switch (bps) {
2590	case 1: return AV_CODEC_ID_PCM_U8;
2591	case 2: return be ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE;
2592	case 3: return be ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE;
2593	case 4: return be ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE;
2594	default: return AV_CODEC_ID_NONE;
2595	}
2596	}
2597	}
2598	}
2599
2600	unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum AVCodecID id)
2601	{
2602	unsigned int tag;
2603	if (!av_codec_get_tag2(tags, id, &tag))
2604	return 0;
2605	return tag;
2606	}
2607
2608	int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
2609	unsigned int *tag)
2610	{
2611	int i;
2612	for(i=0; tags && tags[i]; i++){
2613	const AVCodecTag *codec_tags = tags[i];
2614	while (codec_tags->id != AV_CODEC_ID_NONE) {
2615	if (codec_tags->id == id) {
2616	*tag = codec_tags->tag;
2617	return 1;
2618	}
2619	codec_tags++;
2620	}
2621	}
2622	return 0;
2623	}
2624
2625	enum AVCodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
2626	{
2627	int i;
2628	for(i=0; tags && tags[i]; i++){
2629	enum AVCodecID id= ff_codec_get_id(tags[i], tag);
2630	if(id!=AV_CODEC_ID_NONE) return id;
2631	}
2632	return AV_CODEC_ID_NONE;
2633	}
2634
2635	static void compute_chapters_end(AVFormatContext *s)
2636	{
2637	unsigned int i, j;
2638	int64_t max_time = s->duration + ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
2639
2640	for (i = 0; i < s->nb_chapters; i++)
2641	if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2642	AVChapter *ch = s->chapters[i];
2643	int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q, ch->time_base)
2644	: INT64_MAX;
2645
2646	for (j = 0; j < s->nb_chapters; j++) {
2647	AVChapter *ch1 = s->chapters[j];
2648	int64_t next_start = av_rescale_q(ch1->start, ch1->time_base, ch->time_base);
2649	if (j != i && next_start > ch->start && next_start < end)
2650	end = next_start;
2651	}
2652	ch->end = (end == INT64_MAX) ? ch->start : end;
2653	}
2654	}
2655
2656	static int get_std_framerate(int i){
2657	if(i<60*12) return (i+1)*1001;
2658	else return ((const int[]){24,30,60,12,15,48})[i-60*12]*1000*12;
2659	}
2660
2661	/*
2662	* Is the time base unreliable.
2663	* This is a heuristic to balance between quick acceptance of the values in
2664	* the headers vs. some extra checks.
2665	* Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2666	* MPEG-2 commonly misuses field repeat flags to store different framerates.
2667	* And there are "variable" fps files this needs to detect as well.
2668	*/
2669	static int tb_unreliable(AVCodecContext *c){
2670	if( c->time_base.den >= 101L*c->time_base.num
2671	|| c->time_base.den < 5L*c->time_base.num
2672	/* || c->codec_tag == AV_RL32("DIVX")
2673	|| c->codec_tag == AV_RL32("XVID")*/
2674	|| c->codec_tag == AV_RL32("mp4v")
2675	|| c->codec_id == AV_CODEC_ID_MPEG2VIDEO
2676	|| c->codec_id == AV_CODEC_ID_H264
2677	)
2678	return 1;
2679	return 0;
2680	}
2681
2682	#if FF_API_FORMAT_PARAMETERS
2683	int av_find_stream_info(AVFormatContext *ic)
2684	{
2685	return avformat_find_stream_info(ic, NULL);
2686	}
2687	#endif
2688
2689	int ff_alloc_extradata(AVCodecContext *avctx, int size)
2690	{
2691	int ret;
2692
2693	if (size < 0 || size >= INT32_MAX - FF_INPUT_BUFFER_PADDING_SIZE) {
2694	avctx->extradata_size = 0;
2695	return AVERROR(EINVAL);
2696	}
2697	avctx->extradata = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
2698	if (avctx->extradata) {
2699	memset(avctx->extradata + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2700	avctx->extradata_size = size;
2701	ret = 0;
2702	} else {
2703	avctx->extradata_size = 0;
2704	ret = AVERROR(ENOMEM);
2705	}
2706	return ret;
2707	}
2708
2709	int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
2710	{
2711	int i, count, ret = 0, j;
2712	int64_t read_size;
2713	AVStream *st;
2714	AVPacket pkt1, *pkt;
2715	int64_t old_offset = avio_tell(ic->pb);
2716	int orig_nb_streams = ic->nb_streams; // new streams might appear, no options for those
2717	int flush_codecs = ic->probesize > 0;
2718
2719	if(ic->pb)
2720	av_log(ic, AV_LOG_DEBUG, "File position before avformat_find_stream_info() is %"PRId64"\n", avio_tell(ic->pb));
2721
2722	for(i=0;i<ic->nb_streams;i++) {
2723	const AVCodec *codec;
2724	AVDictionary *thread_opt = NULL;
2725	st = ic->streams[i];
2726
2727	if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2728	st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2729	/* if(!st->time_base.num)
2730	st->time_base= */
2731	if(!st->codec->time_base.num)
2732	st->codec->time_base= st->time_base;
2733	}
2734	//only for the split stuff
2735	if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
2736	st->parser = av_parser_init(st->codec->codec_id);
2737	if(st->parser){
2738	if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
2739	st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2740	} else if(st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
2741	st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
2742	}
2743	} else if (st->need_parsing) {
2744	av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
2745	"%s, packets or times may be invalid.\n",
2746	avcodec_get_name(st->codec->codec_id));
2747	}
2748	}
2749	codec = find_decoder(ic, st, st->codec->codec_id);
2750
2751	/* force thread count to 1 since the h264 decoder will not extract SPS
2752	* and PPS to extradata during multi-threaded decoding */
2753	av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
2754
2755	/* Ensure that subtitle_header is properly set. */
2756	if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
2757	&& codec && !st->codec->codec)
2758	avcodec_open2(st->codec, codec, options ? &options[i]
2759	: &thread_opt);
2760
2761	//try to just open decoders, in case this is enough to get parameters
2762	if (!has_codec_parameters(st, NULL) && st->request_probe <= 0) {
2763	if (codec && !st->codec->codec)
2764	avcodec_open2(st->codec, codec, options ? &options[i]
2765	: &thread_opt);
2766	}
2767	if (!options)
2768	av_dict_free(&thread_opt);
2769	}
2770
2771	for (i=0; i<ic->nb_streams; i++) {
2772	#if FF_API_R_FRAME_RATE
2773	ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
2774	#endif
2775	ic->streams[i]->info->fps_first_dts = AV_NOPTS_VALUE;
2776	ic->streams[i]->info->fps_last_dts = AV_NOPTS_VALUE;
2777	}
2778
2779	count = 0;
2780	read_size = 0;
2781	for(;;) {
2782	if (ff_check_interrupt(&ic->interrupt_callback)){
2783	ret= AVERROR_EXIT;
2784	av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2785	break;
2786	}
2787
2788	/* check if one codec still needs to be handled */
2789	for(i=0;i<ic->nb_streams;i++) {
2790	int fps_analyze_framecount = 20;
2791
2792	st = ic->streams[i];
2793	if (!has_codec_parameters(st, NULL))
2794	break;
2795	/* if the timebase is coarse (like the usual millisecond precision
2796	of mkv), we need to analyze more frames to reliably arrive at
2797	the correct fps */
2798	if (av_q2d(st->time_base) > 0.0005)
2799	fps_analyze_framecount *= 2;
2800	if (ic->fps_probe_size >= 0)
2801	fps_analyze_framecount = ic->fps_probe_size;
2802	if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
2803	fps_analyze_framecount = 0;
2804	/* variable fps and no guess at the real fps */
2805	if( tb_unreliable(st->codec) && !(st->r_frame_rate.num && st->avg_frame_rate.num)
2806	&& st->info->duration_count < fps_analyze_framecount
2807	&& st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2808	break;
2809	if(st->parser && st->parser->parser->split && !st->codec->extradata)
2810	break;
2811	if (st->first_dts == AV_NOPTS_VALUE &&
2812	(st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2813	st->codec->codec_type == AVMEDIA_TYPE_AUDIO))
2814	break;
2815	}
2816	if (i == ic->nb_streams) {
2817	/* NOTE: if the format has no header, then we need to read
2818	some packets to get most of the streams, so we cannot
2819	stop here */
2820	if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2821	/* if we found the info for all the codecs, we can stop */
2822	ret = count;
2823	av_log(ic, AV_LOG_DEBUG, "All info found\n");
2824	flush_codecs = 0;
2825	break;
2826	}
2827	}
2828	/* we did not get all the codec info, but we read too much data */
2829	if (read_size >= ic->probesize) {
2830	ret = count;
2831	av_log(ic, AV_LOG_DEBUG, "Probe buffer size limit of %d bytes reached\n", ic->probesize);
2832	for (i = 0; i < ic->nb_streams; i++)
2833	if (!ic->streams[i]->r_frame_rate.num &&
2834	ic->streams[i]->info->duration_count <= 1 &&
2835	strcmp(ic->iformat->name, "image2"))
2836	av_log(ic, AV_LOG_WARNING,
2837	"Stream #%d: not enough frames to estimate rate; "
2838	"consider increasing probesize\n", i);
2839	break;
2840	}
2841
2842	/* NOTE: a new stream can be added there if no header in file
2843	(AVFMTCTX_NOHEADER) */
2844	ret = read_frame_internal(ic, &pkt1);
2845	if (ret == AVERROR(EAGAIN))
2846	continue;
2847
2848	if (ret < 0) {
2849	/* EOF or error*/
2850	break;
2851	}
2852
2853	if (ic->flags & AVFMT_FLAG_NOBUFFER)
2854	free_packet_buffer(&ic->packet_buffer, &ic->packet_buffer_end);
2855	{
2856	pkt = add_to_pktbuf(&ic->packet_buffer, &pkt1,
2857	&ic->packet_buffer_end);
2858	if (!pkt) {
2859	ret = AVERROR(ENOMEM);
2860	goto find_stream_info_err;
2861	}
2862	if ((ret = av_dup_packet(pkt)) < 0)
2863	goto find_stream_info_err;
2864	}
2865
2866	read_size += pkt->size;
2867
2868	st = ic->streams[pkt->stream_index];
2869	if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
2870	/* check for non-increasing dts */
2871	if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
2872	st->info->fps_last_dts >= pkt->dts) {
2873	av_log(ic, AV_LOG_DEBUG, "Non-increasing DTS in stream %d: "
2874	"packet %d with DTS %"PRId64", packet %d with DTS "
2875	"%"PRId64"\n", st->index, st->info->fps_last_dts_idx,
2876	st->info->fps_last_dts, st->codec_info_nb_frames, pkt->dts);
2877	st->info->fps_first_dts = st->info->fps_last_dts = AV_NOPTS_VALUE;
2878	}
2879	/* check for a discontinuity in dts - if the difference in dts
2880	* is more than 1000 times the average packet duration in the sequence,
2881	* we treat it as a discontinuity */
2882	if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
2883	st->info->fps_last_dts_idx > st->info->fps_first_dts_idx &&
2884	(pkt->dts - st->info->fps_last_dts) / 1000 >
2885	(st->info->fps_last_dts - st->info->fps_first_dts) / (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
2886	av_log(ic, AV_LOG_WARNING, "DTS discontinuity in stream %d: "
2887	"packet %d with DTS %"PRId64", packet %d with DTS "
2888	"%"PRId64"\n", st->index, st->info->fps_last_dts_idx,
2889	st->info->fps_last_dts, st->codec_info_nb_frames, pkt->dts);
2890	st->info->fps_first_dts = st->info->fps_last_dts = AV_NOPTS_VALUE;
2891	}
2892
2893	/* update stored dts values */
2894	if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
2895	st->info->fps_first_dts = pkt->dts;
2896	st->info->fps_first_dts_idx = st->codec_info_nb_frames;
2897	}
2898	st->info->fps_last_dts = pkt->dts;
2899	st->info->fps_last_dts_idx = st->codec_info_nb_frames;
2900	}
2901	if (st->codec_info_nb_frames>1) {
2902	int64_t t=0;
2903	if (st->time_base.den > 0)
2904	t = av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
2905	if (st->avg_frame_rate.num > 0)
2906	t = FFMAX(t, av_rescale_q(st->codec_info_nb_frames, av_inv_q(st->avg_frame_rate), AV_TIME_BASE_Q));
2907
2908	if ( t==0
2909	&& st->codec_info_nb_frames>30
2910	&& st->info->fps_first_dts != AV_NOPTS_VALUE
2911	&& st->info->fps_last_dts != AV_NOPTS_VALUE)
2912	t = FFMAX(t, av_rescale_q(st->info->fps_last_dts - st->info->fps_first_dts, st->time_base, AV_TIME_BASE_Q));
2913
2914	if (t >= ic->max_analyze_duration) {
2915	av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %d reached at %"PRId64" microseconds\n", ic->max_analyze_duration, t);
2916	break;
2917	}
2918	if (pkt->duration) {
2919	st->info->codec_info_duration += pkt->duration;
2920	st->info->codec_info_duration_fields += st->parser && st->need_parsing && st->codec->ticks_per_frame==2 ? st->parser->repeat_pict + 1 : 2;
2921	}
2922	}
2923	#if FF_API_R_FRAME_RATE
2924	{
2925	int64_t last = st->info->last_dts;
2926
2927	if( pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && pkt->dts > last
2928	&& pkt->dts - (uint64_t)last < INT64_MAX){
2929	double dts= (is_relative(pkt->dts) ? pkt->dts - RELATIVE_TS_BASE : pkt->dts) * av_q2d(st->time_base);
2930	int64_t duration= pkt->dts - last;
2931
2932	if (!st->info->duration_error)
2933	st->info->duration_error = av_mallocz(sizeof(st->info->duration_error[0])*2);
2934	if (!st->info->duration_error)
2935	return AVERROR(ENOMEM);
2936
2937	// if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2938	// av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
2939	for (i=0; i<MAX_STD_TIMEBASES; i++) {
2940	int framerate= get_std_framerate(i);
2941	double sdts= dts*framerate/(1001*12);
2942	for(j=0; j<2; j++){
2943	int64_t ticks= llrint(sdts+j*0.5);
2944	double error= sdts - ticks + j*0.5;
2945	st->info->duration_error[j][0][i] += error;
2946	st->info->duration_error[j][1][i] += error*error;
2947	}
2948	}
2949	st->info->duration_count++;
2950	// ignore the first 4 values, they might have some random jitter
2951	if (st->info->duration_count > 3 && is_relative(pkt->dts) == is_relative(last))
2952	st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2953	}
2954	if (pkt->dts != AV_NOPTS_VALUE)
2955	st->info->last_dts = pkt->dts;
2956	}
2957	#endif
2958	if(st->parser && st->parser->parser->split && !st->codec->extradata){
2959	int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2960	if (i > 0 && i < FF_MAX_EXTRADATA_SIZE) {
2961	if (ff_alloc_extradata(st->codec, i))
2962	return AVERROR(ENOMEM);
2963	memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2964	}
2965	}
2966
2967	/* if still no information, we try to open the codec and to
2968	decompress the frame. We try to avoid that in most cases as
2969	it takes longer and uses more memory. For MPEG-4, we need to
2970	decompress for QuickTime.
2971
2972	If CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
2973	least one frame of codec data, this makes sure the codec initializes
2974	the channel configuration and does not only trust the values from the container.
2975	*/
2976	try_decode_frame(ic, st, pkt, (options && i < orig_nb_streams ) ? &options[i] : NULL);
2977
2978	st->codec_info_nb_frames++;
2979	count++;
2980	}
2981
2982	if (flush_codecs) {
2983	AVPacket empty_pkt = { 0 };
2984	int err = 0;
2985	av_init_packet(&empty_pkt);
2986
2987	for(i=0;i<ic->nb_streams;i++) {
2988
2989	st = ic->streams[i];
2990
2991	/* flush the decoders */
2992	if (st->info->found_decoder == 1) {
2993	do {
2994	err = try_decode_frame(ic, st, &empty_pkt,
2995	(options && i < orig_nb_streams) ?
2996	&options[i] : NULL);
2997	} while (err > 0 && !has_codec_parameters(st, NULL));
2998
2999	if (err < 0) {
3000	av_log(ic, AV_LOG_INFO,
3001	"decoding for stream %d failed\n", st->index);
3002	}
3003	}
3004	}
3005	}
3006
3007	// close codecs which were opened in try_decode_frame()
3008	for(i=0;i<ic->nb_streams;i++) {
3009	st = ic->streams[i];
3010	avcodec_close(st->codec);
3011	}
3012	for(i=0;i<ic->nb_streams;i++) {
3013	st = ic->streams[i];
3014	if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
3015	if(st->codec->codec_id == AV_CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample){
3016	uint32_t tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
3017	if (avpriv_find_pix_fmt(ff_raw_pix_fmt_tags, tag) == st->codec->pix_fmt)
3018	st->codec->codec_tag= tag;
3019	}
3020
3021	/* estimate average framerate if not set by demuxer */
3022	if (st->info->codec_info_duration_fields && !st->avg_frame_rate.num && st->info->codec_info_duration) {
3023	int best_fps = 0;
3024	double best_error = 0.01;
3025
3026	if (st->info->codec_info_duration >= INT64_MAX / st->time_base.num / 2||
3027	st->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
3028	st->info->codec_info_duration < 0)
3029	continue;
3030	av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3031	st->info->codec_info_duration_fields*(int64_t)st->time_base.den,
3032	st->info->codec_info_duration*2*(int64_t)st->time_base.num, 60000);
3033
3034	/* round guessed framerate to a "standard" framerate if it's
3035	* within 1% of the original estimate*/
3036	for (j = 1; j < MAX_STD_TIMEBASES; j++) {
3037	AVRational std_fps = { get_std_framerate(j), 12*1001 };
3038	double error = fabs(av_q2d(st->avg_frame_rate) / av_q2d(std_fps) - 1);
3039
3040	if (error < best_error) {
3041	best_error = error;
3042	best_fps = std_fps.num;
3043	}
3044	}
3045	if (best_fps) {
3046	av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3047	best_fps, 12*1001, INT_MAX);
3048	}
3049	}
3050	// the check for tb_unreliable() is not completely correct, since this is not about handling
3051	// a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
3052	// ipmovie.c produces.
3053	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)
3054	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);
3055	if (st->info->duration_count>1 && !st->r_frame_rate.num
3056	&& tb_unreliable(st->codec)) {
3057	int num = 0;
3058	double best_error= 0.01;
3059
3060	for (j=0; j<MAX_STD_TIMEBASES; j++) {
3061	int k;
3062
3063	if(st->info->codec_info_duration && st->info->codec_info_duration*av_q2d(st->time_base) < (1001*12.0)/get_std_framerate(j))
3064	continue;
3065	if(!st->info->codec_info_duration && 1.0 < (1001*12.0)/get_std_framerate(j))
3066	continue;
3067	for(k=0; k<2; k++){
3068	int n= st->info->duration_count;
3069	double a= st->info->duration_error[k][0][j] / n;
3070	double error= st->info->duration_error[k][1][j]/n - a*a;
3071
3072	if(error < best_error && best_error> 0.000000001){
3073	best_error= error;
3074	num = get_std_framerate(j);
3075	}
3076	if(error < 0.02)
3077	av_log(NULL, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
3078	}
3079	}
3080	// do not increase frame rate by more than 1 % in order to match a standard rate.
3081	if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
3082	av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
3083	}
3084
3085	if (!st->r_frame_rate.num){
3086	if( st->codec->time_base.den * (int64_t)st->time_base.num
3087	<= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
3088	st->r_frame_rate.num = st->codec->time_base.den;
3089	st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
3090	}else{
3091	st->r_frame_rate.num = st->time_base.den;
3092	st->r_frame_rate.den = st->time_base.num;
3093	}
3094	}
3095	}else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
3096	if(!st->codec->bits_per_coded_sample)
3097	st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
3098	// set stream disposition based on audio service type
3099	switch (st->codec->audio_service_type) {
3100	case AV_AUDIO_SERVICE_TYPE_EFFECTS:
3101	st->disposition = AV_DISPOSITION_CLEAN_EFFECTS; break;
3102	case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
3103	st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED; break;
3104	case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
3105	st->disposition = AV_DISPOSITION_HEARING_IMPAIRED; break;
3106	case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
3107	st->disposition = AV_DISPOSITION_COMMENT; break;
3108	case AV_AUDIO_SERVICE_TYPE_KARAOKE:
3109	st->disposition = AV_DISPOSITION_KARAOKE; break;
3110	}
3111	}
3112	}
3113
3114	if(ic->probesize)
3115	estimate_timings(ic, old_offset);
3116
3117	if (ret >= 0 && ic->nb_streams)
3118	ret = -1; /* we could not have all the codec parameters before EOF */
3119	for(i=0;i<ic->nb_streams;i++) {
3120	const char *errmsg;
3121	st = ic->streams[i];
3122	if (!has_codec_parameters(st, &errmsg)) {
3123	char buf[256];
3124	avcodec_string(buf, sizeof(buf), st->codec, 0);
3125	av_log(ic, AV_LOG_WARNING,
3126	"Could not find codec parameters for stream %d (%s): %s\n"
3127	"Consider increasing the value for the 'analyzeduration' and 'probesize' options\n",
3128	i, buf, errmsg);
3129	} else {
3130	ret = 0;
3131	}
3132	}
3133
3134	compute_chapters_end(ic);
3135
3136	find_stream_info_err:
3137	for (i=0; i < ic->nb_streams; i++) {
3138	st = ic->streams[i];
3139	if (ic->streams[i]->codec && ic->streams[i]->codec->codec_type != AVMEDIA_TYPE_AUDIO)
3140	ic->streams[i]->codec->thread_count = 0;
3141	if (st->info)
3142	av_freep(&st->info->duration_error);
3143	av_freep(&ic->streams[i]->info);
3144	}
3145	if(ic->pb)
3146	av_log(ic, AV_LOG_DEBUG, "File position after avformat_find_stream_info() is %"PRId64"\n", avio_tell(ic->pb));
3147	return ret;
3148	}
3149
3150	AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
3151	{
3152	int i, j;
3153
3154	for (i = 0; i < ic->nb_programs; i++) {
3155	if (ic->programs[i] == last) {
3156	last = NULL;
3157	} else {
3158	if (!last)
3159	for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
3160	if (ic->programs[i]->stream_index[j] == s)
3161	return ic->programs[i];
3162	}
3163	}
3164	return NULL;
3165	}
3166
3167	int av_find_best_stream(AVFormatContext *ic,
3168	enum AVMediaType type,
3169	int wanted_stream_nb,
3170	int related_stream,
3171	AVCodec **decoder_ret,
3172	int flags)
3173	{
3174	int i, nb_streams = ic->nb_streams;
3175	int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1, best_bitrate = -1, best_multiframe = -1, count, bitrate, multiframe;
3176	unsigned *program = NULL;
3177	AVCodec *decoder = NULL, *best_decoder = NULL;
3178
3179	if (related_stream >= 0 && wanted_stream_nb < 0) {
3180	AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
3181	if (p) {
3182	program = p->stream_index;
3183	nb_streams = p->nb_stream_indexes;
3184	}
3185	}
3186	for (i = 0; i < nb_streams; i++) {
3187	int real_stream_index = program ? program[i] : i;
3188	AVStream *st = ic->streams[real_stream_index];
3189	AVCodecContext *avctx = st->codec;
3190	if (avctx->codec_type != type)
3191	continue;
3192	if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
3193	continue;
3194	if (st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED|AV_DISPOSITION_VISUAL_IMPAIRED))
3195	continue;
3196	if (decoder_ret) {
3197	decoder = find_decoder(ic, st, st->codec->codec_id);
3198	if (!decoder) {
3199	if (ret < 0)
3200	ret = AVERROR_DECODER_NOT_FOUND;
3201	continue;
3202	}
3203	}
3204	count = st->codec_info_nb_frames;
3205	bitrate = avctx->bit_rate;
3206	multiframe = FFMIN(5, count);
3207	if ((best_multiframe > multiframe) ||
3208	(best_multiframe == multiframe && best_bitrate > bitrate) ||
3209	(best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
3210	continue;
3211	best_count = count;
3212	best_bitrate = bitrate;
3213	best_multiframe = multiframe;
3214	ret = real_stream_index;
3215	best_decoder = decoder;
3216	if (program && i == nb_streams - 1 && ret < 0) {
3217	program = NULL;
3218	nb_streams = ic->nb_streams;
3219	i = 0; /* no related stream found, try again with everything */
3220	}
3221	}
3222	if (decoder_ret)
3223	*decoder_ret = best_decoder;
3224	return ret;
3225	}
3226
3227	/*******************************************************/
3228
3229	int av_read_play(AVFormatContext *s)
3230	{
3231	if (s->iformat->read_play)
3232	return s->iformat->read_play(s);
3233	if (s->pb)
3234	return avio_pause(s->pb, 0);
3235	return AVERROR(ENOSYS);
3236	}
3237
3238	int av_read_pause(AVFormatContext *s)
3239	{
3240	if (s->iformat->read_pause)
3241	return s->iformat->read_pause(s);
3242	if (s->pb)
3243	return avio_pause(s->pb, 1);
3244	return AVERROR(ENOSYS);
3245	}
3246
3247	void ff_free_stream(AVFormatContext *s, AVStream *st){
3248	av_assert0(s->nb_streams>0);
3249	av_assert0(s->streams[ s->nb_streams-1 ] == st);
3250
3251	if (st->parser) {
3252	av_parser_close(st->parser);
3253	}
3254	if (st->attached_pic.data)
3255	av_free_packet(&st->attached_pic);
3256	av_dict_free(&st->metadata);
3257	av_freep(&st->probe_data.buf);
3258	av_freep(&st->index_entries);
3259	av_freep(&st->codec->extradata);
3260	av_freep(&st->codec->subtitle_header);
3261	av_freep(&st->codec);
3262	av_freep(&st->priv_data);
3263	if (st->info)
3264	av_freep(&st->info->duration_error);
3265	av_freep(&st->info);
3266	av_freep(&s->streams[ --s->nb_streams ]);
3267	}
3268
3269	void avformat_free_context(AVFormatContext *s)
3270	{
3271	int i;
3272
3273	if (!s)
3274	return;
3275
3276	av_opt_free(s);
3277	if (s->iformat && s->iformat->priv_class && s->priv_data)
3278	av_opt_free(s->priv_data);
3279
3280	for(i=s->nb_streams-1; i>=0; i--) {
3281	ff_free_stream(s, s->streams[i]);
3282	}
3283	for(i=s->nb_programs-1; i>=0; i--) {
3284	av_dict_free(&s->programs[i]->metadata);
3285	av_freep(&s->programs[i]->stream_index);
3286	av_freep(&s->programs[i]);
3287	}
3288	av_freep(&s->programs);
3289	av_freep(&s->priv_data);
3290	while(s->nb_chapters--) {
3291	av_dict_free(&s->chapters[s->nb_chapters]->metadata);
3292	av_freep(&s->chapters[s->nb_chapters]);
3293	}
3294	av_freep(&s->chapters);
3295	av_dict_free(&s->metadata);
3296	av_freep(&s->streams);
3297	av_free(s);
3298	}
3299
3300	#if FF_API_CLOSE_INPUT_FILE
3301	void av_close_input_file(AVFormatContext *s)
3302	{
3303	avformat_close_input(&s);
3304	}
3305	#endif
3306
3307	void avformat_close_input(AVFormatContext **ps)
3308	{
3309	AVFormatContext *s;
3310	AVIOContext *pb;
3311
3312	if (!ps || !*ps)
3313	return;
3314
3315	s = *ps;
3316	pb = s->pb;
3317
3318	if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
3319	(s->flags & AVFMT_FLAG_CUSTOM_IO))
3320	pb = NULL;
3321
3322	flush_packet_queue(s);
3323
3324	if (s->iformat) {
3325	if (s->iformat->read_close)
3326	s->iformat->read_close(s);
3327	}
3328
3329	avformat_free_context(s);
3330
3331	*ps = NULL;
3332
3333	avio_close(pb);
3334	}
3335
3336	#if FF_API_NEW_STREAM
3337	AVStream *av_new_stream(AVFormatContext *s, int id)
3338	{
3339	AVStream *st = avformat_new_stream(s, NULL);
3340	if (st)
3341	st->id = id;
3342	return st;
3343	}
3344	#endif
3345
3346	AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
3347	{
3348	AVStream *st;
3349	int i;
3350	AVStream **streams;
3351
3352	if (s->nb_streams >= INT_MAX/sizeof(*streams))
3353	return NULL;
3354	streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
3355	if (!streams)
3356	return NULL;
3357	s->streams = streams;
3358
3359	st = av_mallocz(sizeof(AVStream));
3360	if (!st)
3361	return NULL;
3362	if (!(st->info = av_mallocz(sizeof(*st->info)))) {
3363	av_free(st);
3364	return NULL;
3365	}
3366	st->info->last_dts = AV_NOPTS_VALUE;
3367
3368	st->codec = avcodec_alloc_context3(c);
3369	if (s->iformat) {
3370	/* no default bitrate if decoding */
3371	st->codec->bit_rate = 0;
3372	}
3373	st->index = s->nb_streams;
3374	st->start_time = AV_NOPTS_VALUE;
3375	st->duration = AV_NOPTS_VALUE;
3376	/* we set the current DTS to 0 so that formats without any timestamps
3377	but durations get some timestamps, formats with some unknown
3378	timestamps have their first few packets buffered and the
3379	timestamps corrected before they are returned to the user */
3380	st->cur_dts = s->iformat ? RELATIVE_TS_BASE : 0;
3381	st->first_dts = AV_NOPTS_VALUE;
3382	st->probe_packets = MAX_PROBE_PACKETS;
3383	st->pts_wrap_reference = AV_NOPTS_VALUE;
3384	st->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3385
3386	/* default pts setting is MPEG-like */
3387	avpriv_set_pts_info(st, 33, 1, 90000);
3388	st->last_IP_pts = AV_NOPTS_VALUE;
3389	for(i=0; i<MAX_REORDER_DELAY+1; i++)
3390	st->pts_buffer[i]= AV_NOPTS_VALUE;
3391	st->reference_dts = AV_NOPTS_VALUE;
3392
3393	st->sample_aspect_ratio = (AVRational){0,1};
3394
3395	#if FF_API_R_FRAME_RATE
3396	st->info->last_dts = AV_NOPTS_VALUE;
3397	#endif
3398	st->info->fps_first_dts = AV_NOPTS_VALUE;
3399	st->info->fps_last_dts = AV_NOPTS_VALUE;
3400
3401	s->streams[s->nb_streams++] = st;
3402	return st;
3403	}
3404
3405	AVProgram *av_new_program(AVFormatContext *ac, int id)
3406	{
3407	AVProgram *program=NULL;
3408	int i;
3409
3410	av_dlog(ac, "new_program: id=0x%04x\n", id);
3411
3412	for(i=0; i<ac->nb_programs; i++)
3413	if(ac->programs[i]->id == id)
3414	program = ac->programs[i];
3415
3416	if(!program){
3417	program = av_mallocz(sizeof(AVProgram));
3418	if (!program)
3419	return NULL;
3420	dynarray_add(&ac->programs, &ac->nb_programs, program);
3421	program->discard = AVDISCARD_NONE;
3422	}
3423	program->id = id;
3424	program->pts_wrap_reference = AV_NOPTS_VALUE;
3425	program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3426
3427	program->start_time =
3428	program->end_time = AV_NOPTS_VALUE;
3429
3430	return program;
3431	}
3432
3433	AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
3434	{
3435	AVChapter *chapter = NULL;
3436	int i;
3437
3438	for(i=0; i<s->nb_chapters; i++)
3439	if(s->chapters[i]->id == id)
3440	chapter = s->chapters[i];
3441
3442	if(!chapter){
3443	chapter= av_mallocz(sizeof(AVChapter));
3444	if(!chapter)
3445	return NULL;
3446	dynarray_add(&s->chapters, &s->nb_chapters, chapter);
3447	}
3448	av_dict_set(&chapter->metadata, "title", title, 0);
3449	chapter->id = id;
3450	chapter->time_base= time_base;
3451	chapter->start = start;
3452	chapter->end = end;
3453
3454	return chapter;
3455	}
3456
3457	void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
3458	{
3459	int i, j;
3460	AVProgram *program=NULL;
3461	void *tmp;
3462
3463	if (idx >= ac->nb_streams) {
3464	av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3465	return;
3466	}
3467
3468	for(i=0; i<ac->nb_programs; i++){
3469	if(ac->programs[i]->id != progid)
3470	continue;
3471	program = ac->programs[i];
3472	for(j=0; j<program->nb_stream_indexes; j++)
3473	if(program->stream_index[j] == idx)
3474	return;
3475
3476	tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
3477	if(!tmp)
3478	return;
3479	program->stream_index = tmp;
3480	program->stream_index[program->nb_stream_indexes++] = idx;
3481	return;
3482	}
3483	}
3484
3485	static void print_fps(double d, const char *postfix){
3486	uint64_t v= lrintf(d*100);
3487	if (v% 100 ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3488	else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3489	else av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
3490	}
3491
3492	static void dump_metadata(void *ctx, AVDictionary *m, const char *indent)
3493	{
3494	if(m && !(av_dict_count(m) == 1 && av_dict_get(m, "language", NULL, 0))){
3495	AVDictionaryEntry *tag=NULL;
3496
3497	av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3498	while((tag=av_dict_get(m, "", tag, AV_DICT_IGNORE_SUFFIX))) {
3499	if(strcmp("language", tag->key)){
3500	const char *p = tag->value;
3501	av_log(ctx, AV_LOG_INFO, "%s %-16s: ", indent, tag->key);
3502	while(*p) {
3503	char tmp[256];
3504	size_t len = strcspn(p, "\x8\xa\xb\xc\xd");
3505	av_strlcpy(tmp, p, FFMIN(sizeof(tmp), len+1));
3506	av_log(ctx, AV_LOG_INFO, "%s", tmp);
3507	p += len;
3508	if (*p == 0xd) av_log(ctx, AV_LOG_INFO, " ");
3509	if (*p == 0xa) av_log(ctx, AV_LOG_INFO, "\n%s %-16s: ", indent, "");
3510	if (*p) p++;
3511	}
3512	av_log(ctx, AV_LOG_INFO, "\n");
3513	}
3514	}
3515	}
3516	}
3517
3518	/* "user interface" functions */
3519	static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
3520	{
3521	char buf[256];
3522	int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
3523	AVStream *st = ic->streams[i];
3524	int g = av_gcd(st->time_base.num, st->time_base.den);
3525	AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL, 0);
3526	avcodec_string(buf, sizeof(buf), st->codec, is_output);
3527	av_log(NULL, AV_LOG_INFO, " Stream #%d:%d", index, i);
3528	/* the pid is an important information, so we display it */
3529	/* XXX: add a generic system */
3530	if (flags & AVFMT_SHOW_IDS)
3531	av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
3532	if (lang)
3533	av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
3534	av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames, st->time_base.num/g, st->time_base.den/g);
3535	av_log(NULL, AV_LOG_INFO, ": %s", buf);
3536	if (st->sample_aspect_ratio.num && // default
3537	av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
3538	AVRational display_aspect_ratio;
3539	av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
3540	st->codec->width*st->sample_aspect_ratio.num,
3541	st->codec->height*st->sample_aspect_ratio.den,
3542	1024*1024);
3543	av_log(NULL, AV_LOG_INFO, ", SAR %d:%d DAR %d:%d",
3544	st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3545	display_aspect_ratio.num, display_aspect_ratio.den);
3546	}
3547	if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
3548	if(st->avg_frame_rate.den && st->avg_frame_rate.num)
3549	print_fps(av_q2d(st->avg_frame_rate), "fps");
3550	#if FF_API_R_FRAME_RATE
3551	if(st->r_frame_rate.den && st->r_frame_rate.num)
3552	print_fps(av_q2d(st->r_frame_rate), "tbr");
3553	#endif
3554	if(st->time_base.den && st->time_base.num)
3555	print_fps(1/av_q2d(st->time_base), "tbn");
3556	if(st->codec->time_base.den && st->codec->time_base.num)
3557	print_fps(1/av_q2d(st->codec->time_base), "tbc");
3558	}
3559	if (st->disposition & AV_DISPOSITION_DEFAULT)
3560	av_log(NULL, AV_LOG_INFO, " (default)");
3561	if (st->disposition & AV_DISPOSITION_DUB)
3562	av_log(NULL, AV_LOG_INFO, " (dub)");
3563	if (st->disposition & AV_DISPOSITION_ORIGINAL)
3564	av_log(NULL, AV_LOG_INFO, " (original)");
3565	if (st->disposition & AV_DISPOSITION_COMMENT)
3566	av_log(NULL, AV_LOG_INFO, " (comment)");
3567	if (st->disposition & AV_DISPOSITION_LYRICS)
3568	av_log(NULL, AV_LOG_INFO, " (lyrics)");
3569	if (st->disposition & AV_DISPOSITION_KARAOKE)
3570	av_log(NULL, AV_LOG_INFO, " (karaoke)");
3571	if (st->disposition & AV_DISPOSITION_FORCED)
3572	av_log(NULL, AV_LOG_INFO, " (forced)");
3573	if (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED)
3574	av_log(NULL, AV_LOG_INFO, " (hearing impaired)");
3575	if (st->disposition & AV_DISPOSITION_VISUAL_IMPAIRED)
3576	av_log(NULL, AV_LOG_INFO, " (visual impaired)");
3577	if (st->disposition & AV_DISPOSITION_CLEAN_EFFECTS)
3578	av_log(NULL, AV_LOG_INFO, " (clean effects)");
3579	av_log(NULL, AV_LOG_INFO, "\n");
3580	dump_metadata(NULL, st->metadata, " ");
3581	}
3582
3583	void av_dump_format(AVFormatContext *ic,
3584	int index,
3585	const char *url,
3586	int is_output)
3587	{
3588	int i;
3589	uint8_t *printed = ic->nb_streams ? av_mallocz(ic->nb_streams) : NULL;
3590	if (ic->nb_streams && !printed)
3591	return;
3592
3593	av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3594	is_output ? "Output" : "Input",
3595	index,
3596	is_output ? ic->oformat->name : ic->iformat->name,
3597	is_output ? "to" : "from", url);
3598	dump_metadata(NULL, ic->metadata, " ");
3599	if (!is_output) {
3600	av_log(NULL, AV_LOG_INFO, " Duration: ");
3601	if (ic->duration != AV_NOPTS_VALUE) {
3602	int hours, mins, secs, us;
3603	int64_t duration = ic->duration + 5000;
3604	secs = duration / AV_TIME_BASE;
3605	us = duration % AV_TIME_BASE;
3606	mins = secs / 60;
3607	secs %= 60;
3608	hours = mins / 60;
3609	mins %= 60;
3610	av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3611	(100 * us) / AV_TIME_BASE);
3612	} else {
3613	av_log(NULL, AV_LOG_INFO, "N/A");
3614	}
3615	if (ic->start_time != AV_NOPTS_VALUE) {
3616	int secs, us;
3617	av_log(NULL, AV_LOG_INFO, ", start: ");
3618	secs = ic->start_time / AV_TIME_BASE;
3619	us = abs(ic->start_time % AV_TIME_BASE);
3620	av_log(NULL, AV_LOG_INFO, "%d.%06d",
3621	secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
3622	}
3623	av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3624	if (ic->bit_rate) {
3625	av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
3626	} else {
3627	av_log(NULL, AV_LOG_INFO, "N/A");
3628	}
3629	av_log(NULL, AV_LOG_INFO, "\n");
3630	}
3631	for (i = 0; i < ic->nb_chapters; i++) {
3632	AVChapter *ch = ic->chapters[i];
3633	av_log(NULL, AV_LOG_INFO, " Chapter #%d.%d: ", index, i);
3634	av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
3635	av_log(NULL, AV_LOG_INFO, "end %f\n", ch->end * av_q2d(ch->time_base));
3636
3637	dump_metadata(NULL, ch->metadata, " ");
3638	}
3639	if(ic->nb_programs) {
3640	int j, k, total = 0;
3641	for(j=0; j<ic->nb_programs; j++) {
3642	AVDictionaryEntry *name = av_dict_get(ic->programs[j]->metadata,
3643	"name", NULL, 0);
3644	av_log(NULL, AV_LOG_INFO, " Program %d %s\n", ic->programs[j]->id,
3645	name ? name->value : "");
3646	dump_metadata(NULL, ic->programs[j]->metadata, " ");
3647	for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3648	dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3649	printed[ic->programs[j]->stream_index[k]] = 1;
3650	}
3651	total += ic->programs[j]->nb_stream_indexes;
3652	}
3653	if (total < ic->nb_streams)
3654	av_log(NULL, AV_LOG_INFO, " No Program\n");
3655	}
3656	for(i=0;i<ic->nb_streams;i++)
3657	if (!printed[i])
3658	dump_stream_format(ic, i, index, is_output);
3659
3660	av_free(printed);
3661	}
3662
3663	uint64_t ff_ntp_time(void)
3664	{
3665	return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3666	}
3667
3668	int av_get_frame_filename(char *buf, int buf_size,
3669	const char *path, int number)
3670	{
3671	const char *p;
3672	char *q, buf1[20], c;
3673	int nd, len, percentd_found;
3674
3675	q = buf;
3676	p = path;
3677	percentd_found = 0;
3678	for(;;) {
3679	c = *p++;
3680	if (c == '\0')
3681	break;
3682	if (c == '%') {
3683	do {
3684	nd = 0;
3685	while (av_isdigit(*p)) {
3686	nd = nd * 10 + *p++ - '0';
3687	}
3688	c = *p++;
3689	} while (av_isdigit(c));
3690
3691	switch(c) {
3692	case '%':
3693	goto addchar;
3694	case 'd':
3695	if (percentd_found)
3696	goto fail;
3697	percentd_found = 1;
3698	snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3699	len = strlen(buf1);
3700	if ((q - buf + len) > buf_size - 1)
3701	goto fail;
3702	memcpy(q, buf1, len);
3703	q += len;
3704	break;
3705	default:
3706	goto fail;
3707	}
3708	} else {
3709	addchar:
3710	if ((q - buf) < buf_size - 1)
3711	*q++ = c;
3712	}
3713	}
3714	if (!percentd_found)
3715	goto fail;
3716	*q = '\0';
3717	return 0;
3718	fail:
3719	*q = '\0';
3720	return -1;
3721	}
3722
3723	static void hex_dump_internal(void *avcl, FILE *f, int level,
3724	const uint8_t *buf, int size)
3725	{
3726	int len, i, j, c;
3727	#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3728
3729	for(i=0;i<size;i+=16) {
3730	len = size - i;
3731	if (len > 16)
3732	len = 16;
3733	PRINT("%08x ", i);
3734	for(j=0;j<16;j++) {
3735	if (j < len)
3736	PRINT(" %02x", buf[i+j]);
3737	else
3738	PRINT(" ");
3739	}
3740	PRINT(" ");
3741	for(j=0;j<len;j++) {
3742	c = buf[i+j];
3743	if (c < ' ' || c > '~')
3744	c = '.';
3745	PRINT("%c", c);
3746	}
3747	PRINT("\n");
3748	}
3749	#undef PRINT
3750	}
3751
3752	void av_hex_dump(FILE *f, const uint8_t *buf, int size)
3753	{
3754	hex_dump_internal(NULL, f, 0, buf, size);
3755	}
3756
3757	void av_hex_dump_log(void *avcl, int level, const uint8_t *buf, int size)
3758	{
3759	hex_dump_internal(avcl, NULL, level, buf, size);
3760	}
3761
3762	static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload, AVRational time_base)
3763	{
3764	#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3765	PRINT("stream #%d:\n", pkt->stream_index);
3766	PRINT(" keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
3767	PRINT(" duration=%0.3f\n", pkt->duration * av_q2d(time_base));
3768	/* DTS is _always_ valid after av_read_frame() */
3769	PRINT(" dts=");
3770	if (pkt->dts == AV_NOPTS_VALUE)
3771	PRINT("N/A");
3772	else
3773	PRINT("%0.3f", pkt->dts * av_q2d(time_base));
3774	/* PTS may not be known if B-frames are present. */
3775	PRINT(" pts=");
3776	if (pkt->pts == AV_NOPTS_VALUE)
3777	PRINT("N/A");
3778	else
3779	PRINT("%0.3f", pkt->pts * av_q2d(time_base));
3780	PRINT("\n");
3781	PRINT(" size=%d\n", pkt->size);
3782	#undef PRINT
3783	if (dump_payload)
3784	av_hex_dump(f, pkt->data, pkt->size);
3785	}
3786
3787	void av_pkt_dump2(FILE *f, AVPacket *pkt, int dump_payload, AVStream *st)
3788	{
3789	pkt_dump_internal(NULL, f, 0, pkt, dump_payload, st->time_base);
3790	}
3791
3792	void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload,
3793	AVStream *st)
3794	{
3795	pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, st->time_base);
3796	}
3797
3798	void av_url_split(char *proto, int proto_size,
3799	char *authorization, int authorization_size,
3800	char *hostname, int hostname_size,
3801	int *port_ptr,
3802	char *path, int path_size,
3803	const char *url)
3804	{
3805	const char *p, *ls, *ls2, *at, *at2, *col, *brk;
3806
3807	if (port_ptr) *port_ptr = -1;
3808	if (proto_size > 0) proto[0] = 0;
3809	if (authorization_size > 0) authorization[0] = 0;
3810	if (hostname_size > 0) hostname[0] = 0;
3811	if (path_size > 0) path[0] = 0;
3812
3813	/* parse protocol */
3814	if ((p = strchr(url, ':'))) {
3815	av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3816	p++; /* skip ':' */
3817	if (*p == '/') p++;
3818	if (*p == '/') p++;
3819	} else {
3820	/* no protocol means plain filename */
3821	av_strlcpy(path, url, path_size);
3822	return;
3823	}
3824
3825	/* separate path from hostname */
3826	ls = strchr(p, '/');
3827	ls2 = strchr(p, '?');
3828	if(!ls)
3829	ls = ls2;
3830	else if (ls && ls2)
3831	ls = FFMIN(ls, ls2);
3832	if(ls)
3833	av_strlcpy(path, ls, path_size);
3834	else
3835	ls = &p[strlen(p)]; // XXX
3836
3837	/* the rest is hostname, use that to parse auth/port */
3838	if (ls != p) {
3839	/* authorization (user[:pass]@hostname) */
3840	at2 = p;
3841	while ((at = strchr(p, '@')) && at < ls) {
3842	av_strlcpy(authorization, at2,
3843	FFMIN(authorization_size, at + 1 - at2));
3844	p = at + 1; /* skip '@' */
3845	}
3846
3847	if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3848	/* [host]:port */
3849	av_strlcpy(hostname, p + 1,
3850	FFMIN(hostname_size, brk - p));
3851	if (brk[1] == ':' && port_ptr)
3852	*port_ptr = atoi(brk + 2);
3853	} else if ((col = strchr(p, ':')) && col < ls) {
3854	av_strlcpy(hostname, p,
3855	FFMIN(col + 1 - p, hostname_size));
3856	if (port_ptr) *port_ptr = atoi(col + 1);
3857	} else
3858	av_strlcpy(hostname, p,
3859	FFMIN(ls + 1 - p, hostname_size));
3860	}
3861	}
3862
3863	char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3864	{
3865	int i;
3866	static const char hex_table_uc[16] = { '0', '1', '2', '3',
3867	'4', '5', '6', '7',
3868	'8', '9', 'A', 'B',
3869	'C', 'D', 'E', 'F' };
3870	static const char hex_table_lc[16] = { '0', '1', '2', '3',
3871	'4', '5', '6', '7',
3872	'8', '9', 'a', 'b',
3873	'c', 'd', 'e', 'f' };
3874	const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3875
3876	for(i = 0; i < s; i++) {
3877	buff[i * 2] = hex_table[src[i] >> 4];
3878	buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3879	}
3880
3881	return buff;
3882	}
3883
3884	int ff_hex_to_data(uint8_t *data, const char *p)
3885	{
3886	int c, len, v;
3887
3888	len = 0;
3889	v = 1;
3890	for (;;) {
3891	p += strspn(p, SPACE_CHARS);
3892	if (*p == '\0')
3893	break;
3894	c = av_toupper((unsigned char) *p++);
3895	if (c >= '0' && c <= '9')
3896	c = c - '0';
3897	else if (c >= 'A' && c <= 'F')
3898	c = c - 'A' + 10;
3899	else
3900	break;
3901	v = (v << 4) | c;
3902	if (v & 0x100) {
3903	if (data)
3904	data[len] = v;
3905	len++;
3906	v = 1;
3907	}
3908	}
3909	return len;
3910	}
3911
3912	#if FF_API_SET_PTS_INFO
3913	void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3914	unsigned int pts_num, unsigned int pts_den)
3915	{
3916	avpriv_set_pts_info(s, pts_wrap_bits, pts_num, pts_den);
3917	}
3918	#endif
3919
3920	void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
3921	unsigned int pts_num, unsigned int pts_den)
3922	{
3923	AVRational new_tb;
3924	if(av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)){
3925	if(new_tb.num != pts_num)
3926	av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/new_tb.num);
3927	}else
3928	av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3929
3930	if(new_tb.num <= 0 || new_tb.den <= 0) {
3931	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);
3932	return;
3933	}
3934	s->time_base = new_tb;
3935	av_codec_set_pkt_timebase(s->codec, new_tb);
3936	s->pts_wrap_bits = pts_wrap_bits;
3937	}
3938
3939	void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
3940	void *context)
3941	{
3942	const char *ptr = str;
3943
3944	/* Parse key=value pairs. */
3945	for (;;) {
3946	const char *key;
3947	char *dest = NULL, *dest_end;
3948	int key_len, dest_len = 0;
3949
3950	/* Skip whitespace and potential commas. */
3951	while (*ptr && (av_isspace(*ptr) || *ptr == ','))
3952	ptr++;
3953	if (!*ptr)
3954	break;
3955
3956	key = ptr;
3957
3958	if (!(ptr = strchr(key, '=')))
3959	break;
3960	ptr++;
3961	key_len = ptr - key;
3962
3963	callback_get_buf(context, key, key_len, &dest, &dest_len);
3964	dest_end = dest + dest_len - 1;
3965
3966	if (*ptr == '\"') {
3967	ptr++;
3968	while (*ptr && *ptr != '\"') {
3969	if (*ptr == '\\') {
3970	if (!ptr[1])
3971	break;
3972	if (dest && dest < dest_end)
3973	*dest++ = ptr[1];
3974	ptr += 2;
3975	} else {
3976	if (dest && dest < dest_end)
3977	*dest++ = *ptr;
3978	ptr++;
3979	}
3980	}
3981	if (*ptr == '\"')
3982	ptr++;
3983	} else {
3984	for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
3985	if (dest && dest < dest_end)
3986	*dest++ = *ptr;
3987	}
3988	if (dest)
3989	*dest = 0;
3990	}
3991	}
3992
3993	int ff_find_stream_index(AVFormatContext *s, int id)
3994	{
3995	int i;
3996	for (i = 0; i < s->nb_streams; i++) {
3997	if (s->streams[i]->id == id)
3998	return i;
3999	}
4000	return -1;
4001	}
4002
4003	int64_t ff_iso8601_to_unix_time(const char *datestr)
4004	{
4005	struct tm time1 = {0}, time2 = {0};
4006	char *ret1, *ret2;
4007	ret1 = av_small_strptime(datestr, "%Y - %m - %d %H:%M:%S", &time1);
4008	ret2 = av_small_strptime(datestr, "%Y - %m - %dT%H:%M:%S", &time2);
4009	if (ret2 && !ret1)
4010	return av_timegm(&time2);
4011	else
4012	return av_timegm(&time1);
4013	}
4014
4015	int avformat_query_codec(AVOutputFormat *ofmt, enum AVCodecID codec_id, int std_compliance)
4016	{
4017	if (ofmt) {
4018	if (ofmt->query_codec)
4019	return ofmt->query_codec(codec_id, std_compliance);
4020	else if (ofmt->codec_tag)
4021	return !!av_codec_get_tag(ofmt->codec_tag, codec_id);
4022	else if (codec_id == ofmt->video_codec || codec_id == ofmt->audio_codec ||
4023	codec_id == ofmt->subtitle_codec)
4024	return 1;
4025	}
4026	return AVERROR_PATCHWELCOME;
4027	}
4028
4029	int avformat_network_init(void)
4030	{
4031	#if CONFIG_NETWORK
4032	int ret;
4033	ff_network_inited_globally = 1;
4034	if ((ret = ff_network_init()) < 0)
4035	return ret;
4036	ff_tls_init();
4037	#endif
4038	return 0;
4039	}
4040
4041	int avformat_network_deinit(void)
4042	{
4043	#if CONFIG_NETWORK
4044	ff_network_close();
4045	ff_tls_deinit();
4046	#endif
4047	return 0;
4048	}
4049
4050	int ff_add_param_change(AVPacket *pkt, int32_t channels,
4051	uint64_t channel_layout, int32_t sample_rate,
4052	int32_t width, int32_t height)
4053	{
4054	uint32_t flags = 0;
4055	int size = 4;
4056	uint8_t *data;
4057	if (!pkt)
4058	return AVERROR(EINVAL);
4059	if (channels) {
4060	size += 4;
4061	flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
4062	}
4063	if (channel_layout) {
4064	size += 8;
4065	flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
4066	}
4067	if (sample_rate) {
4068	size += 4;
4069	flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
4070	}
4071	if (width || height) {
4072	size += 8;
4073	flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
4074	}
4075	data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
4076	if (!data)
4077	return AVERROR(ENOMEM);
4078	bytestream_put_le32(&data, flags);
4079	if (channels)
4080	bytestream_put_le32(&data, channels);
4081	if (channel_layout)
4082	bytestream_put_le64(&data, channel_layout);
4083	if (sample_rate)
4084	bytestream_put_le32(&data, sample_rate);
4085	if (width || height) {
4086	bytestream_put_le32(&data, width);
4087	bytestream_put_le32(&data, height);
4088	}
4089	return 0;
4090	}
4091
4092	AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
4093	{
4094	AVRational undef = {0, 1};
4095	AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
4096	AVRational codec_sample_aspect_ratio = stream && stream->codec ? stream->codec->sample_aspect_ratio : undef;
4097	AVRational frame_sample_aspect_ratio = frame ? frame->sample_aspect_ratio : codec_sample_aspect_ratio;
4098
4099	av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
4100	stream_sample_aspect_ratio.num, stream_sample_aspect_ratio.den, INT_MAX);
4101	if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
4102	stream_sample_aspect_ratio = undef;
4103
4104	av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
4105	frame_sample_aspect_ratio.num, frame_sample_aspect_ratio.den, INT_MAX);
4106	if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
4107	frame_sample_aspect_ratio = undef;
4108
4109	if (stream_sample_aspect_ratio.num)
4110	return stream_sample_aspect_ratio;
4111	else
4112	return frame_sample_aspect_ratio;
4113	}
4114
4115	AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
4116	{
4117	AVRational fr = st->r_frame_rate;
4118
4119	if (st->codec->ticks_per_frame > 1) {
4120	AVRational codec_fr = av_inv_q(st->codec->time_base);
4121	AVRational avg_fr = st->avg_frame_rate;
4122	codec_fr.den *= st->codec->ticks_per_frame;
4123	if ( codec_fr.num > 0 && codec_fr.den > 0 && av_q2d(codec_fr) < av_q2d(fr)*0.7
4124	&& fabs(1.0 - av_q2d(av_div_q(avg_fr, fr))) > 0.1)
4125	fr = codec_fr;
4126	}
4127
4128	return fr;
4129	}
4130
4131	int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
4132	const char *spec)
4133	{
4134	if (*spec <= '9' && *spec >= '0') /* opt:index */
4135	return strtol(spec, NULL, 0) == st->index;
4136	else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
4137	*spec == 't') { /* opt:[vasdt] */
4138	enum AVMediaType type;
4139
4140	switch (*spec++) {
4141	case 'v': type = AVMEDIA_TYPE_VIDEO; break;
4142	case 'a': type = AVMEDIA_TYPE_AUDIO; break;
4143	case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
4144	case 'd': type = AVMEDIA_TYPE_DATA; break;
4145	case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
4146	default: av_assert0(0);
4147	}
4148	if (type != st->codec->codec_type)
4149	return 0;
4150	if (*spec++ == ':') { /* possibly followed by :index */
4151	int i, index = strtol(spec, NULL, 0);
4152	for (i = 0; i < s->nb_streams; i++)
4153	if (s->streams[i]->codec->codec_type == type && index-- == 0)
4154	return i == st->index;
4155	return 0;
4156	}
4157	return 1;
4158	} else if (*spec == 'p' && *(spec + 1) == ':') {
4159	int prog_id, i, j;
4160	char *endptr;
4161	spec += 2;
4162	prog_id = strtol(spec, &endptr, 0);
4163	for (i = 0; i < s->nb_programs; i++) {
4164	if (s->programs[i]->id != prog_id)
4165	continue;
4166
4167	if (*endptr++ == ':') {
4168	int stream_idx = strtol(endptr, NULL, 0);
4169	return stream_idx >= 0 &&
4170	stream_idx < s->programs[i]->nb_stream_indexes &&
4171	st->index == s->programs[i]->stream_index[stream_idx];
4172	}
4173
4174	for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
4175	if (st->index == s->programs[i]->stream_index[j])
4176	return 1;
4177	}
4178	return 0;
4179	} else if (*spec == '#') {
4180	int sid;
4181	char *endptr;
4182	sid = strtol(spec + 1, &endptr, 0);
4183	if (!*endptr)
4184	return st->id == sid;
4185	} else if (!*spec) /* empty specifier, matches everything */
4186	return 1;
4187
4188	av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
4189	return AVERROR(EINVAL);
4190	}
4191
4192	void ff_generate_avci_extradata(AVStream *st)
4193	{
4194	static const uint8_t avci100_1080p_extradata[] = {
4195	// SPS
4196	0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4197	0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4198	0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4199	0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
4200	0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
4201	0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
4202	0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
4203	0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
4204	0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4205	// PPS
4206	0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4207	0xd0
4208	};
4209	static const uint8_t avci100_1080i_extradata[] = {
4210	// SPS
4211	0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4212	0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4213	0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4214	0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
4215	0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
4216	0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
4217	0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
4218	0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
4219	0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
4220	0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
4221	0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x00,
4222	// PPS
4223	0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4224	0xd0
4225	};
4226	static const uint8_t avci50_1080i_extradata[] = {
4227	// SPS
4228	0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
4229	0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4230	0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4231	0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
4232	0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
4233	0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
4234	0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
4235	0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
4236	0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
4237	0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
4238	0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
4239	// PPS
4240	0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4241	0x11
4242	};
4243	static const uint8_t avci100_720p_extradata[] = {
4244	// SPS
4245	0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4246	0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
4247	0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
4248	0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
4249	0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
4250	0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
4251	0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
4252	0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
4253	0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
4254	0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
4255	// PPS
4256	0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
4257	0x11
4258	};
4259	int size = 0;
4260	const uint8_t *data = 0;
4261	if (st->codec->width == 1920) {
4262	if (st->codec->field_order == AV_FIELD_PROGRESSIVE) {
4263	data = avci100_1080p_extradata;
4264	size = sizeof(avci100_1080p_extradata);
4265	} else {
4266	data = avci100_1080i_extradata;
4267	size = sizeof(avci100_1080i_extradata);
4268	}
4269	} else if (st->codec->width == 1440) {
4270	data = avci50_1080i_extradata;
4271	size = sizeof(avci50_1080i_extradata);
4272	} else if (st->codec->width == 1280) {
4273	data = avci100_720p_extradata;
4274	size = sizeof(avci100_720p_extradata);
4275	}
4276	if (!size)
4277	return;
4278	av_freep(&st->codec->extradata);
4279	if (ff_alloc_extradata(st->codec, size))
4280	return;
4281	memcpy(st->codec->extradata, data, size);
4282	}
4283