/libavformat/utils.c - Annotate - PeerStreamer - Redmine

ffmpeg / libavformat / utils.c @ 4dcde00c

History | View | Annotate | Download (124 KB)

1	de6d9b64	Fabrice Bellard	/*
2	2912e87a	Mans Rullgard	* various utility functions for use within Libav
3	19720f15	Fabrice Bellard	* Copyright (c) 2000, 2001, 2002 Fabrice Bellard
4	de6d9b64	Fabrice Bellard	*
5	2912e87a	Mans Rullgard	* This file is part of Libav.
6	b78e7197	Diego Biurrun	*
7	2912e87a	Mans Rullgard	* Libav is free software; you can redistribute it and/or
8	19720f15	Fabrice Bellard	* modify it under the terms of the GNU Lesser General Public
9			* License as published by the Free Software Foundation; either
10	b78e7197	Diego Biurrun	* version 2.1 of the License, or (at your option) any later version.
11	de6d9b64	Fabrice Bellard	*
12	2912e87a	Mans Rullgard	* Libav is distributed in the hope that it will be useful,
13	de6d9b64	Fabrice Bellard	* but WITHOUT ANY WARRANTY; without even the implied warranty of
14	19720f15	Fabrice Bellard	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15			* Lesser General Public License for more details.
16	de6d9b64	Fabrice Bellard	*
17	19720f15	Fabrice Bellard	* You should have received a copy of the GNU Lesser General Public
18	2912e87a	Mans Rullgard	* License along with Libav; if not, write to the Free Software
19	5509bffa	Diego Biurrun	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20	de6d9b64	Fabrice Bellard	*/
21	79f43a8c	Stefano Sabatini
22			/* #define DEBUG */
23
24	8be1c656	Fabrice Bellard	#include "avformat.h"
25	f1ef2cd9	Anton Khirnov	#include "avio_internal.h"
26	f1c80e35	Ronald S. Bultje	#include "internal.h"
27	603a5f04	Francesco Lavra	#include "libavcodec/internal.h"
28	6ed04040	Michael Niedermayer	#include "libavutil/opt.h"
29	06a7bd9a	Michael Niedermayer	#include "metadata.h"
30	6612d8cf	Reimar Döffinger	#include "id3v2.h"
31	245976da	Diego Biurrun	#include "libavutil/avstring.h"
32	45da8124	Aurelien Jacobs	#include "riff.h"
33	c26e58e3	Måns Rullgård	#include "audiointerleave.h"
34	82e4ac2c	Ramiro Polla	#include <sys/time.h>
35			#include <time.h>
36	ea452b54	Aurelien Jacobs	#include <strings.h>
37	780d7897	Martin Storsjö	#include <stdarg.h>
38			#if CONFIG_NETWORK
39			#include "network.h"
40			#endif
41	c5510dd6	Philip Gladstone
42	b754978a	Michael Niedermayer	#undef NDEBUG
43			#include <assert.h>
44
45	e36bdf8b	Daniel Kristjansson	/**
46	ba87f080	Diego Biurrun	* @file
47	2912e87a	Mans Rullgard	* various utility functions for use within Libav
48	e36bdf8b	Daniel Kristjansson	*/
49
50	c97429e2	Stefano Sabatini	unsigned avformat_version(void)
51			{
52			return LIBAVFORMAT_VERSION_INT;
53			}
54
55	41600690	Stefano Sabatini	const char *avformat_configuration(void)
56	c1736936	Diego Biurrun	{
57	29ba0911	Janne Grunau	return LIBAV_CONFIGURATION;
58	c1736936	Diego Biurrun	}
59
60	41600690	Stefano Sabatini	const char *avformat_license(void)
61	c1736936	Diego Biurrun	{
62			#define LICENSE_PREFIX "libavformat license: "
63	a03be6e1	Janne Grunau	return LICENSE_PREFIX LIBAV_LICENSE + sizeof(LICENSE_PREFIX) - 1;
64	c1736936	Diego Biurrun	}
65
66	8163c870	Stefano Sabatini	/* fraction handling */
67
68			/**
69			* f = val + (num / den) + 0.5.
70			*
71			* 'num' is normalized so that it is such as 0 <= num < den.
72			*
73			* @param f fractional number
74			* @param val integer value
75			* @param num must be >= 0
76			* @param den must be >= 1
77			*/
78			static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
79			{
80			num += (den >> 1);
81			if (num >= den) {
82			val += num / den;
83			num = num % den;
84			}
85			f->val = val;
86			f->num = num;
87			f->den = den;
88			}
89
90			/**
91			* Fractional addition to f: f = f + (incr / f->den).
92			*
93			* @param f fractional number
94			* @param incr increment, can be positive or negative
95			*/
96			static void av_frac_add(AVFrac *f, int64_t incr)
97			{
98			int64_t num, den;
99
100			num = f->num + incr;
101			den = f->den;
102			if (num < 0) {
103			f->val += num / den;
104			num = num % den;
105			if (num < 0) {
106			num += den;
107			f->val--;
108			}
109			} else if (num >= den) {
110			f->val += num / den;
111			num = num % den;
112			}
113			f->num = num;
114			}
115	f3a30e3a	Luca Barbato
116	a85736f2	Diego Biurrun	/** head of registered input format linked list */
117	114c9a59	Aurelien Jacobs	#if !FF_API_FIRST_FORMAT
118			static
119			#endif
120	8b69867f	Michael Niedermayer	AVInputFormat *first_iformat = NULL;
121	a85736f2	Diego Biurrun	/** head of registered output format linked list */
122	114c9a59	Aurelien Jacobs	#if !FF_API_FIRST_FORMAT
123			static
124			#endif
125	8b69867f	Michael Niedermayer	AVOutputFormat *first_oformat = NULL;
126	de6d9b64	Fabrice Bellard
127	84be6e72	Michael Niedermayer	AVInputFormat av_iformat_next(AVInputFormat f)
128			{
129			if(f) return f->next;
130			else return first_iformat;
131			}
132
133			AVOutputFormat av_oformat_next(AVOutputFormat f)
134			{
135			if(f) return f->next;
136			else return first_oformat;
137			}
138
139	b9a281db	Fabrice Bellard	void av_register_input_format(AVInputFormat *format)
140	de6d9b64	Fabrice Bellard	{
141	b9a281db	Fabrice Bellard	AVInputFormat **p;
142			p = &first_iformat;
143			while (p != NULL) p = &(p)->next;
144			*p = format;
145			format->next = NULL;
146			}
147
148			void av_register_output_format(AVOutputFormat *format)
149			{
150			AVOutputFormat **p;
151			p = &first_oformat;
152	de6d9b64	Fabrice Bellard	while (p != NULL) p = &(p)->next;
153			*p = format;
154			format->next = NULL;
155			}
156
157	8eb631fa	Stefano Sabatini	int av_match_ext(const char filename, const char extensions)
158			{
159	de6d9b64	Fabrice Bellard	const char ext, p;
160			char ext1[32], *q;
161
162	293ed23f	Michael Niedermayer	if(!filename)
163			return 0;
164	115329f1	Diego Biurrun
165	de6d9b64	Fabrice Bellard	ext = strrchr(filename, '.');
166			if (ext) {
167			ext++;
168			p = extensions;
169			for(;;) {
170			q = ext1;
171	115329f1	Diego Biurrun	while (p != '\0' && p != ',' && q-ext1<sizeof(ext1)-1)
172	de6d9b64	Fabrice Bellard	q++ = p++;
173			*q = '\0';
174	115329f1	Diego Biurrun	if (!strcasecmp(ext1, ext))
175	de6d9b64	Fabrice Bellard	return 1;
176	115329f1	Diego Biurrun	if (*p == '\0')
177	de6d9b64	Fabrice Bellard	break;
178			p++;
179			}
180			}
181			return 0;
182			}
183
184	2323ac01	Baptiste Coudurier	static int match_format(const char name, const char names)
185			{
186			const char *p;
187			int len, namelen;
188
189			if (!name \|\| !names)
190			return 0;
191
192			namelen = strlen(name);
193			while ((p = strchr(names, ','))) {
194			len = FFMAX(p - names, namelen);
195			if (!strncasecmp(name, names, len))
196			return 1;
197			names = p+1;
198			}
199			return !strcasecmp(name, names);
200			}
201
202	198ac67f	Aurelien Jacobs	#if FF_API_GUESS_FORMAT
203	115329f1	Diego Biurrun	AVOutputFormat guess_format(const char short_name, const char *filename,
204	b9a281db	Fabrice Bellard	const char *mime_type)
205	de6d9b64	Fabrice Bellard	{
206	a1f547b9	Stefano Sabatini	return av_guess_format(short_name, filename, mime_type);
207			}
208			#endif
209
210			AVOutputFormat av_guess_format(const char short_name, const char *filename,
211			const char *mime_type)
212			{
213	27323146	Anton Khirnov	AVOutputFormat fmt = NULL, fmt_found;
214	de6d9b64	Fabrice Bellard	int score_max, score;
215
216	87a0a681	Fabrice Bellard	/* specific test for image sequences */
217	b250f9c6	Aurelien Jacobs	#if CONFIG_IMAGE2_MUXER
218	115329f1	Diego Biurrun	if (!short_name && filename &&
219	5c07cf53	Michel Bardiaux	av_filename_number_test(filename) &&
220	5b6d5596	Michael Niedermayer	av_guess_image2_codec(filename) != CODEC_ID_NONE) {
221	0f52ef1a	Stefano Sabatini	return av_guess_format("image2", NULL, NULL);
222	5b6d5596	Michael Niedermayer	}
223	ff70e601	Måns Rullgård	#endif
224	a85736f2	Diego Biurrun	/* Find the proper file type. */
225	de6d9b64	Fabrice Bellard	fmt_found = NULL;
226			score_max = 0;
227	27323146	Anton Khirnov	while ((fmt = av_oformat_next(fmt))) {
228	de6d9b64	Fabrice Bellard	score = 0;
229			if (fmt->name && short_name && !strcmp(fmt->name, short_name))
230			score += 100;
231			if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
232			score += 10;
233	115329f1	Diego Biurrun	if (filename && fmt->extensions &&
234	aa13b573	Stefano Sabatini	av_match_ext(filename, fmt->extensions)) {
235	de6d9b64	Fabrice Bellard	score += 5;
236			}
237			if (score > score_max) {
238			score_max = score;
239			fmt_found = fmt;
240			}
241			}
242			return fmt_found;
243	115329f1	Diego Biurrun	}
244	de6d9b64	Fabrice Bellard
245	198ac67f	Aurelien Jacobs	#if FF_API_GUESS_FORMAT
246	115329f1	Diego Biurrun	AVOutputFormat guess_stream_format(const char short_name, const char *filename,
247	c5510dd6	Philip Gladstone	const char *mime_type)
248			{
249	0f52ef1a	Stefano Sabatini	AVOutputFormat *fmt = av_guess_format(short_name, filename, mime_type);
250	c5510dd6	Philip Gladstone
251			if (fmt) {
252			AVOutputFormat *stream_fmt;
253			char stream_format_name[64];
254
255			snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
256	0f52ef1a	Stefano Sabatini	stream_fmt = av_guess_format(stream_format_name, NULL, NULL);
257	c5510dd6	Philip Gladstone
258			if (stream_fmt)
259			fmt = stream_fmt;
260			}
261
262			return fmt;
263			}
264	1642ee43	Stefano Sabatini	#endif
265	c5510dd6	Philip Gladstone
266	115329f1	Diego Biurrun	enum CodecID av_guess_codec(AVOutputFormat fmt, const char short_name,
267	72415b2a	Stefano Sabatini	const char filename, const char mime_type, enum AVMediaType type){
268			if(type == AVMEDIA_TYPE_VIDEO){
269	5b6d5596	Michael Niedermayer	enum CodecID codec_id= CODEC_ID_NONE;
270
271	b250f9c6	Aurelien Jacobs	#if CONFIG_IMAGE2_MUXER
272	ae214ac3	Michael Niedermayer	if(!strcmp(fmt->name, "image2") \|\| !strcmp(fmt->name, "image2pipe")){
273	5b6d5596	Michael Niedermayer	codec_id= av_guess_image2_codec(filename);
274			}
275	ff70e601	Måns Rullgård	#endif
276	5b6d5596	Michael Niedermayer	if(codec_id == CODEC_ID_NONE)
277			codec_id= fmt->video_codec;
278			return codec_id;
279	72415b2a	Stefano Sabatini	}else if(type == AVMEDIA_TYPE_AUDIO)
280	5b6d5596	Michael Niedermayer	return fmt->audio_codec;
281	118ccae0	Aurelien Jacobs	else if (type == AVMEDIA_TYPE_SUBTITLE)
282			return fmt->subtitle_codec;
283	5b6d5596	Michael Niedermayer	else
284			return CODEC_ID_NONE;
285			}
286
287	b9a281db	Fabrice Bellard	AVInputFormat av_find_input_format(const char short_name)
288			{
289	27323146	Anton Khirnov	AVInputFormat *fmt = NULL;
290			while ((fmt = av_iformat_next(fmt))) {
291	2323ac01	Baptiste Coudurier	if (match_format(short_name, fmt->name))
292	b9a281db	Fabrice Bellard	return fmt;
293			}
294			return NULL;
295			}
296
297	13728334	Aurelien Jacobs	#if FF_API_SYMVER && CONFIG_SHARED && HAVE_SYMVER
298	b462d132	Måns Rullgård	FF_SYMVER(void, av_destruct_packet_nofree, (AVPacket *pkt), "LIBAVFORMAT_52")
299			{
300			av_destruct_packet_nofree(pkt);
301			}
302
303			FF_SYMVER(void, av_destruct_packet, (AVPacket *pkt), "LIBAVFORMAT_52")
304			{
305			av_destruct_packet(pkt);
306			}
307	de6d9b64	Fabrice Bellard
308	b462d132	Måns Rullgård	FF_SYMVER(int, av_new_packet, (AVPacket *pkt, int size), "LIBAVFORMAT_52")
309			{
310			return av_new_packet(pkt, size);
311			}
312
313			FF_SYMVER(int, av_dup_packet, (AVPacket *pkt), "LIBAVFORMAT_52")
314			{
315			return av_dup_packet(pkt);
316			}
317
318			FF_SYMVER(void, av_free_packet, (AVPacket *pkt), "LIBAVFORMAT_52")
319			{
320			av_free_packet(pkt);
321			}
322
323			FF_SYMVER(void, av_init_packet, (AVPacket *pkt), "LIBAVFORMAT_52")
324			{
325			av_log(NULL, AV_LOG_WARNING, "Diverting av_*_packet function calls to libavcodec. Recompile to improve performance\n");
326			av_init_packet(pkt);
327			}
328			#endif
329	de6d9b64	Fabrice Bellard
330	ae628ec1	Anton Khirnov	int av_get_packet(AVIOContext s, AVPacket pkt, int size)
331	2692067a	Michael Niedermayer	{
332			int ret= av_new_packet(pkt, size);
333
334			if(ret<0)
335			return ret;
336
337	a2704c97	Anton Khirnov	pkt->pos= avio_tell(s);
338	2692067a	Michael Niedermayer
339	b7effd4e	Anton Khirnov	ret= avio_read(s, pkt->data, size);
340	2692067a	Michael Niedermayer	if(ret<=0)
341			av_free_packet(pkt);
342			else
343	feb993e5	Reimar Döffinger	av_shrink_packet(pkt, ret);
344	2692067a	Michael Niedermayer
345			return ret;
346			}
347
348	ae628ec1	Anton Khirnov	int av_append_packet(AVIOContext s, AVPacket pkt, int size)
349	6bfc2683	Reimar Döffinger	{
350			int ret;
351			int old_size;
352			if (!pkt->size)
353			return av_get_packet(s, pkt, size);
354			old_size = pkt->size;
355			ret = av_grow_packet(pkt, size);
356			if (ret < 0)
357			return ret;
358	b7effd4e	Anton Khirnov	ret = avio_read(s, pkt->data + old_size, size);
359	6bfc2683	Reimar Döffinger	av_shrink_packet(pkt, old_size + FFMAX(ret, 0));
360			return ret;
361			}
362
363	fb2758c8	Fabrice Bellard
364	5c07cf53	Michel Bardiaux	int av_filename_number_test(const char *filename)
365	b9a281db	Fabrice Bellard	{
366			char buf[1024];
367	5c07cf53	Michel Bardiaux	return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
368	b9a281db	Fabrice Bellard	}
369
370	8e2ee182	Reimar Döffinger	AVInputFormat av_probe_input_format2(AVProbeData pd, int is_opened, int *score_max)
371	b9a281db	Fabrice Bellard	{
372	6612d8cf	Reimar Döffinger	AVProbeData lpd = *pd;
373	27323146	Anton Khirnov	AVInputFormat fmt1 = NULL, fmt;
374	79750486	Michael Niedermayer	int score;
375	b9a281db	Fabrice Bellard
376	6612d8cf	Reimar Döffinger	if (lpd.buf_size > 10 && ff_id3v2_match(lpd.buf, ID3v2_DEFAULT_MAGIC)) {
377			int id3len = ff_id3v2_tag_len(lpd.buf);
378			if (lpd.buf_size > id3len + 16) {
379			lpd.buf += id3len;
380			lpd.buf_size -= id3len;
381			}
382			}
383
384	b9a281db	Fabrice Bellard	fmt = NULL;
385	27323146	Anton Khirnov	while ((fmt1 = av_iformat_next(fmt1))) {
386	b8e705ec	Reimar Döffinger	if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
387	b9a281db	Fabrice Bellard	continue;
388			score = 0;
389	a8dbe951	Philip Gladstone	if (fmt1->read_probe) {
390	6612d8cf	Reimar Döffinger	score = fmt1->read_probe(&lpd);
391	a8dbe951	Philip Gladstone	} else if (fmt1->extensions) {
392	6612d8cf	Reimar Döffinger	if (av_match_ext(lpd.filename, fmt1->extensions)) {
393	b9a281db	Fabrice Bellard	score = 50;
394			}
395	115329f1	Diego Biurrun	}
396	79750486	Michael Niedermayer	if (score > *score_max) {
397			*score_max = score;
398	b9a281db	Fabrice Bellard	fmt = fmt1;
399	4b3cca36	Michael Niedermayer	}else if (score == *score_max)
400			fmt = NULL;
401	b9a281db	Fabrice Bellard	}
402			return fmt;
403			}
404
405	79750486	Michael Niedermayer	AVInputFormat av_probe_input_format(AVProbeData pd, int is_opened){
406			int score=0;
407			return av_probe_input_format2(pd, is_opened, &score);
408			}
409
410	db46c4e1	Baptiste Coudurier	static int set_codec_from_probe_data(AVFormatContext s, AVStream st, AVProbeData *pd, int score)
411	64cd3108	Michael Niedermayer	{
412	cf5b33d9	Stefano Sabatini	static const struct {
413			const char *name; enum CodecID id; enum AVMediaType type;
414			} fmt_id_type[] = {
415			{ "aac" , CODEC_ID_AAC , AVMEDIA_TYPE_AUDIO },
416			{ "ac3" , CODEC_ID_AC3 , AVMEDIA_TYPE_AUDIO },
417			{ "dts" , CODEC_ID_DTS , AVMEDIA_TYPE_AUDIO },
418			{ "eac3" , CODEC_ID_EAC3 , AVMEDIA_TYPE_AUDIO },
419			{ "h264" , CODEC_ID_H264 , AVMEDIA_TYPE_VIDEO },
420			{ "m4v" , CODEC_ID_MPEG4 , AVMEDIA_TYPE_VIDEO },
421			{ "mp3" , CODEC_ID_MP3 , AVMEDIA_TYPE_AUDIO },
422			{ "mpegvideo", CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
423			{ 0 }
424			};
425			AVInputFormat *fmt = av_probe_input_format2(pd, 1, &score);
426	64cd3108	Michael Niedermayer
427			if (fmt) {
428	cf5b33d9	Stefano Sabatini	int i;
429	db46c4e1	Baptiste Coudurier	av_log(s, AV_LOG_DEBUG, "Probe with size=%d, packets=%d detected %s with score=%d\n",
430			pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets, fmt->name, score);
431	cf5b33d9	Stefano Sabatini	for (i = 0; fmt_id_type[i].name; i++) {
432			if (!strcmp(fmt->name, fmt_id_type[i].name)) {
433			st->codec->codec_id = fmt_id_type[i].id;
434			st->codec->codec_type = fmt_id_type[i].type;
435			break;
436			}
437	f1588ed5	Andreas Öman	}
438	64cd3108	Michael Niedermayer	}
439			return !!fmt;
440			}
441
442	b9a281db	Fabrice Bellard	/************************************************************/
443			/* input media file */
444	96baaa6a	Fabrice Bellard
445	da24c5e3	Fabrice Bellard	/**
446	e36bdf8b	Daniel Kristjansson	* Open a media file from an IO stream. 'fmt' must be specified.
447	da24c5e3	Fabrice Bellard	*/
448	115329f1	Diego Biurrun	int av_open_input_stream(AVFormatContext **ic_ptr,
449	ae628ec1	Anton Khirnov	AVIOContext pb, const char filename,
450	da24c5e3	Fabrice Bellard	AVInputFormat fmt, AVFormatParameters ap)
451			{
452			int err;
453			AVFormatContext *ic;
454	c04c3282	Michael Niedermayer	AVFormatParameters default_ap;
455
456			if(!ap){
457			ap=&default_ap;
458			memset(ap, 0, sizeof(default_ap));
459			}
460	da24c5e3	Fabrice Bellard
461	4eb72c6b	Nico Sabbi	if(!ap->prealloced_context)
462	8e2fd8e1	Stefano Sabatini	ic = avformat_alloc_context();
463	4eb72c6b	Nico Sabbi	else
464			ic = *ic_ptr;
465	da24c5e3	Fabrice Bellard	if (!ic) {
466	769e10f0	Panagiotis Issaris	err = AVERROR(ENOMEM);
467	da24c5e3	Fabrice Bellard	goto fail;
468			}
469			ic->iformat = fmt;
470	899681cd	Björn Axelsson	ic->pb = pb;
471	da24c5e3	Fabrice Bellard	ic->duration = AV_NOPTS_VALUE;
472			ic->start_time = AV_NOPTS_VALUE;
473	75e61b0e	Måns Rullgård	av_strlcpy(ic->filename, filename, sizeof(ic->filename));
474	da24c5e3	Fabrice Bellard
475			/* allocate private data */
476			if (fmt->priv_data_size > 0) {
477			ic->priv_data = av_mallocz(fmt->priv_data_size);
478			if (!ic->priv_data) {
479	769e10f0	Panagiotis Issaris	err = AVERROR(ENOMEM);
480	da24c5e3	Fabrice Bellard	goto fail;
481			}
482			} else {
483			ic->priv_data = NULL;
484			}
485
486	ae628ec1	Anton Khirnov	// e.g. AVFMT_NOFILE formats will not have a AVIOContext
487	6612d8cf	Reimar Döffinger	if (ic->pb)
488			ff_id3v2_read(ic, ID3v2_DEFAULT_MAGIC);
489
490	e145ce20	Ronald S. Bultje	if (ic->iformat->read_header) {
491	1e2802c5	Ronald S. Bultje	err = ic->iformat->read_header(ic, ap);
492			if (err < 0)
493			goto fail;
494	e145ce20	Ronald S. Bultje	}
495	fb2758c8	Fabrice Bellard
496	faf7cbf1	Michael Niedermayer	if (pb && !ic->data_offset)
497	a2704c97	Anton Khirnov	ic->data_offset = avio_tell(ic->pb);
498	fb2758c8	Fabrice Bellard
499	54036be1	Aurelien Jacobs	#if FF_API_OLD_METADATA
500	e99f76ab	Aurelien Jacobs	ff_metadata_demux_compat(ic);
501			#endif
502
503	af122d6a	Baptiste Coudurier	ic->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
504
505	da24c5e3	Fabrice Bellard	*ic_ptr = ic;
506			return 0;
507			fail:
508			if (ic) {
509	ccafd472	Baptiste Coudurier	int i;
510	da24c5e3	Fabrice Bellard	av_freep(&ic->priv_data);
511	ccafd472	Baptiste Coudurier	for(i=0;i<ic->nb_streams;i++) {
512			AVStream *st = ic->streams[i];
513			if (st) {
514			av_free(st->priv_data);
515			av_free(st->codec->extradata);
516	ec973f45	Przemysław Sobala	av_free(st->codec);
517	fd0368e7	Aurelien Jacobs	av_free(st->info);
518	ccafd472	Baptiste Coudurier	}
519			av_free(st);
520			}
521	da24c5e3	Fabrice Bellard	}
522			av_free(ic);
523			*ic_ptr = NULL;
524			return err;
525			}
526
527	a85736f2	Diego Biurrun	/** size of probe buffer, for guessing file type from file contents */
528	a877eedc	Michael Niedermayer	#define PROBE_BUF_MIN 2048
529	329b1e75	Michael Niedermayer	#define PROBE_BUF_MAX (1<<20)
530	b9a281db	Fabrice Bellard
531	ae628ec1	Anton Khirnov	int av_probe_input_buffer(AVIOContext pb, AVInputFormat *fmt,
532	eadd495d	Micah F. Galizia	const char filename, void logctx,
533			unsigned int offset, unsigned int max_probe_size)
534			{
535			AVProbeData pd = { filename ? filename : "", NULL, -offset };
536			unsigned char *buf = NULL;
537			int ret = 0, probe_size;
538
539			if (!max_probe_size) {
540			max_probe_size = PROBE_BUF_MAX;
541			} else if (max_probe_size > PROBE_BUF_MAX) {
542			max_probe_size = PROBE_BUF_MAX;
543			} else if (max_probe_size < PROBE_BUF_MIN) {
544			return AVERROR(EINVAL);
545			}
546
547			if (offset >= max_probe_size) {
548			return AVERROR(EINVAL);
549			}
550
551	532aa889	Micah F. Galizia	for(probe_size= PROBE_BUF_MIN; probe_size<=max_probe_size && !*fmt && ret >= 0;
552			probe_size = FFMIN(probe_size<<1, FFMAX(max_probe_size, probe_size+1))) {
553	eadd495d	Micah F. Galizia	int ret, score = probe_size < max_probe_size ? AVPROBE_SCORE_MAX/4 : 0;
554			int buf_offset = (probe_size == PROBE_BUF_MIN) ? 0 : probe_size>>1;
555
556			if (probe_size < offset) {
557			continue;
558			}
559
560			/* read probe data */
561			buf = av_realloc(buf, probe_size + AVPROBE_PADDING_SIZE);
562	b7effd4e	Anton Khirnov	if ((ret = avio_read(pb, buf + buf_offset, probe_size - buf_offset)) < 0) {
563	eadd495d	Micah F. Galizia	/* fail if error was not end of file, otherwise, lower score */
564			if (ret != AVERROR_EOF) {
565			av_free(buf);
566			return ret;
567			}
568			score = 0;
569	c7f625ee	Måns Rullgård	ret = 0; /* error was end of file, nothing read */
570	eadd495d	Micah F. Galizia	}
571			pd.buf_size += ret;
572			pd.buf = &buf[offset];
573
574			memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE);
575
576			/* guess file format */
577			*fmt = av_probe_input_format2(&pd, 1, &score);
578			if(*fmt){
579			if(score <= AVPROBE_SCORE_MAX/4){ //this can only be true in the last iteration
580			av_log(logctx, AV_LOG_WARNING, "Format detected only with low score of %d, misdetection possible!\n", score);
581			}else
582			av_log(logctx, AV_LOG_DEBUG, "Probed with size=%d and score=%d\n", probe_size, score);
583			}
584			}
585
586	532aa889	Micah F. Galizia	if (!*fmt) {
587	01d91b9b	Tomas Härdin	av_free(buf);
588	532aa889	Micah F. Galizia	return AVERROR_INVALIDDATA;
589			}
590
591	01d91b9b	Tomas Härdin	/* rewind. reuse probe buffer to avoid seeking */
592	f1ef2cd9	Anton Khirnov	if ((ret = ffio_rewind_with_probe_data(pb, buf, pd.buf_size)) < 0)
593	01d91b9b	Tomas Härdin	av_free(buf);
594	eadd495d	Micah F. Galizia
595	01d91b9b	Tomas Härdin	return ret;
596	eadd495d	Micah F. Galizia	}
597
598	115329f1	Diego Biurrun	int av_open_input_file(AVFormatContext *ic_ptr, const char filename,
599	b9a281db	Fabrice Bellard	AVInputFormat *fmt,
600			int buf_size,
601			AVFormatParameters *ap)
602	de6d9b64	Fabrice Bellard	{
603	eadd495d	Micah F. Galizia	int err;
604	b9a281db	Fabrice Bellard	AVProbeData probe_data, *pd = &probe_data;
605	ae628ec1	Anton Khirnov	AVIOContext *pb = NULL;
606	e9b06816	Michael Niedermayer	void logctx= ap && ap->prealloced_context ? ic_ptr : NULL;
607	115329f1	Diego Biurrun
608	da24c5e3	Fabrice Bellard	pd->filename = "";
609			if (filename)
610			pd->filename = filename;
611	a877eedc	Michael Niedermayer	pd->buf = NULL;
612	b9a281db	Fabrice Bellard	pd->buf_size = 0;
613
614			if (!fmt) {
615	a85736f2	Diego Biurrun	/* guess format if no file can be opened */
616	a25e098d	Fabrice Bellard	fmt = av_probe_input_format(pd, 0);
617	de6d9b64	Fabrice Bellard	}
618
619	a85736f2	Diego Biurrun	/* Do not open file if the format does not need it. XXX: specific
620	b6892136	Fabrice Bellard	hack needed to handle RTSP/TCP */
621	17acc63a	Reimar Döffinger	if (!fmt \|\| !(fmt->flags & AVFMT_NOFILE)) {
622	87a0a681	Fabrice Bellard	/* if no file needed do not try to open one */
623	22a3212e	Anton Khirnov	if ((err=avio_open(&pb, filename, URL_RDONLY)) < 0) {
624	96baaa6a	Fabrice Bellard	goto fail;
625	b9a281db	Fabrice Bellard	}
626	96baaa6a	Fabrice Bellard	if (buf_size > 0) {
627	59f65d95	Anton Khirnov	ffio_set_buf_size(pb, buf_size);
628	96baaa6a	Fabrice Bellard	}
629	3940caad	Anssi Hannula	if (!fmt && (err = av_probe_input_buffer(pb, &fmt, filename, logctx, 0, logctx ? (*ic_ptr)->probesize : 0)) < 0) {
630	eadd495d	Micah F. Galizia	goto fail;
631	5b25dfa7	Fabrice Bellard	}
632	b9a281db	Fabrice Bellard	}
633
634			/* if still no format found, error */
635			if (!fmt) {
636	2928b83c	Stefano Sabatini	err = AVERROR_INVALIDDATA;
637	da24c5e3	Fabrice Bellard	goto fail;
638	de6d9b64	Fabrice Bellard	}
639	115329f1	Diego Biurrun
640	a85736f2	Diego Biurrun	/* check filename in case an image number is expected */
641	da24c5e3	Fabrice Bellard	if (fmt->flags & AVFMT_NEEDNUMBER) {
642	5c07cf53	Michel Bardiaux	if (!av_filename_number_test(filename)) {
643	87a0a681	Fabrice Bellard	err = AVERROR_NUMEXPECTED;
644	da24c5e3	Fabrice Bellard	goto fail;
645	87a0a681	Fabrice Bellard	}
646			}
647	da24c5e3	Fabrice Bellard	err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
648			if (err)
649			goto fail;
650	b9a281db	Fabrice Bellard	return 0;
651	de6d9b64	Fabrice Bellard	fail:
652	a877eedc	Michael Niedermayer	av_freep(&pd->buf);
653	17acc63a	Reimar Döffinger	if (pb)
654	22a3212e	Anton Khirnov	avio_close(pb);
655	ebb82604	Art Clarke	if (ap && ap->prealloced_context)
656			av_free(*ic_ptr);
657			*ic_ptr = NULL;
658	b9a281db	Fabrice Bellard	return err;
659	115329f1	Diego Biurrun
660	de6d9b64	Fabrice Bellard	}
661
662	da24c5e3	Fabrice Bellard	/*******************************************************/
663
664	5c5b1731	Måns Rullgård	static AVPacket add_to_pktbuf(AVPacketList packet_buffer, AVPacket pkt,
665			AVPacketList **plast_pktl){
666			AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
667	9d3b9f2c	Michael Niedermayer	if (!pktl)
668			return NULL;
669
670	5c5b1731	Måns Rullgård	if (*packet_buffer)
671			(*plast_pktl)->next = pktl;
672			else
673			*packet_buffer = pktl;
674
675	9d3b9f2c	Michael Niedermayer	/* add the packet in the buffered packet list */
676			*plast_pktl = pktl;
677			pktl->pkt= *pkt;
678			return &pktl->pkt;
679			}
680
681	de6d9b64	Fabrice Bellard	int av_read_packet(AVFormatContext s, AVPacket pkt)
682			{
683	86cb7e33	Baptiste Coudurier	int ret, i;
684	62600469	Michael Niedermayer	AVStream *st;
685	0bef08e5	Michael Niedermayer
686			for(;;){
687			AVPacketList *pktl = s->raw_packet_buffer;
688
689			if (pktl) {
690			*pkt = pktl->pkt;
691	86cb7e33	Baptiste Coudurier	if(s->streams[pkt->stream_index]->codec->codec_id != CODEC_ID_PROBE \|\|
692	af122d6a	Baptiste Coudurier	!s->streams[pkt->stream_index]->probe_packets \|\|
693			s->raw_packet_buffer_remaining_size < pkt->size){
694			AVProbeData *pd = &s->streams[pkt->stream_index]->probe_data;
695			av_freep(&pd->buf);
696			pd->buf_size = 0;
697	0bef08e5	Michael Niedermayer	s->raw_packet_buffer = pktl->next;
698	af122d6a	Baptiste Coudurier	s->raw_packet_buffer_remaining_size += pkt->size;
699	0bef08e5	Michael Niedermayer	av_free(pktl);
700			return 0;
701			}
702			}
703
704	55823964	Michael Niedermayer	av_init_packet(pkt);
705			ret= s->iformat->read_packet(s, pkt);
706	86cb7e33	Baptiste Coudurier	if (ret < 0) {
707			if (!pktl \|\| ret == AVERROR(EAGAIN))
708			return ret;
709			for (i = 0; i < s->nb_streams; i++)
710			s->streams[i]->probe_packets = 0;
711			continue;
712			}
713	55823964	Michael Niedermayer	st= s->streams[pkt->stream_index];
714	62600469	Michael Niedermayer
715	55823964	Michael Niedermayer	switch(st->codec->codec_type){
716	72415b2a	Stefano Sabatini	case AVMEDIA_TYPE_VIDEO:
717	55823964	Michael Niedermayer	if(s->video_codec_id) st->codec->codec_id= s->video_codec_id;
718			break;
719	72415b2a	Stefano Sabatini	case AVMEDIA_TYPE_AUDIO:
720	55823964	Michael Niedermayer	if(s->audio_codec_id) st->codec->codec_id= s->audio_codec_id;
721			break;
722	72415b2a	Stefano Sabatini	case AVMEDIA_TYPE_SUBTITLE:
723	55823964	Michael Niedermayer	if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
724			break;
725			}
726	62600469	Michael Niedermayer
727	86cb7e33	Baptiste Coudurier	if(!pktl && (st->codec->codec_id != CODEC_ID_PROBE \|\|
728			!st->probe_packets))
729	744b4c02	Michael Niedermayer	return ret;
730
731	5c5b1731	Måns Rullgård	add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
732	af122d6a	Baptiste Coudurier	s->raw_packet_buffer_remaining_size -= pkt->size;
733	744b4c02	Michael Niedermayer
734	0bef08e5	Michael Niedermayer	if(st->codec->codec_id == CODEC_ID_PROBE){
735			AVProbeData *pd = &st->probe_data;
736	0e500e0d	Michael Niedermayer	av_log(s, AV_LOG_DEBUG, "probing stream %d\n", st->index);
737	86cb7e33	Baptiste Coudurier	--st->probe_packets;
738
739	0bef08e5	Michael Niedermayer	pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
740			memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
741			pd->buf_size += pkt->size;
742			memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
743
744	942de2f4	Michael Niedermayer	if(av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)){
745	0f1f4816	Michael Niedermayer	//FIXME we dont reduce score to 0 for the case of running out of buffer space in bytes
746			set_codec_from_probe_data(s, st, pd, st->probe_packets > 0 ? AVPROBE_SCORE_MAX/4 : 0);
747	25d3fb73	Michael Niedermayer	if(st->codec->codec_id != CODEC_ID_PROBE){
748			pd->buf_size=0;
749			av_freep(&pd->buf);
750	0e500e0d	Michael Niedermayer	av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
751	25d3fb73	Michael Niedermayer	}
752	942de2f4	Michael Niedermayer	}
753	0bef08e5	Michael Niedermayer	}
754			}
755	fb2758c8	Fabrice Bellard	}
756
757			/**********************************************************/
758
759	e36bdf8b	Daniel Kristjansson	/**
760	a85736f2	Diego Biurrun	* Get the number of samples of an audio frame. Return -1 on error.
761	e36bdf8b	Daniel Kristjansson	*/
762	fb2758c8	Fabrice Bellard	static int get_audio_frame_size(AVCodecContext *enc, int size)
763			{
764			int frame_size;
765
766	c924ca78	Michael Niedermayer	if(enc->codec_id == CODEC_ID_VORBIS)
767			return -1;
768
769	fb2758c8	Fabrice Bellard	if (enc->frame_size <= 1) {
770	ac3e1834	Baptiste Coudurier	int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
771
772			if (bits_per_sample) {
773	fb2758c8	Fabrice Bellard	if (enc->channels == 0)
774			return -1;
775	f1b163e0	Aurelien Jacobs	frame_size = (size << 3) / (bits_per_sample * enc->channels);
776	ac3e1834	Baptiste Coudurier	} else {
777	fb2758c8	Fabrice Bellard	/* used for example by ADPCM codecs */
778			if (enc->bit_rate == 0)
779			return -1;
780	db5dc02b	Baptiste Coudurier	frame_size = ((int64_t)size * 8 * enc->sample_rate) / enc->bit_rate;
781	fb2758c8	Fabrice Bellard	}
782			} else {
783			frame_size = enc->frame_size;
784			}
785			return frame_size;
786			}
787
788
789	e36bdf8b	Daniel Kristjansson	/**
790	a85736f2	Diego Biurrun	* Return the frame duration in seconds. Return 0 if not available.
791	e36bdf8b	Daniel Kristjansson	*/
792	115329f1	Diego Biurrun	static void compute_frame_duration(int pnum, int pden, AVStream *st,
793	fb2758c8	Fabrice Bellard	AVCodecParserContext pc, AVPacket pkt)
794			{
795			int frame_size;
796
797			*pnum = 0;
798			*pden = 0;
799	01f4895c	Michael Niedermayer	switch(st->codec->codec_type) {
800	72415b2a	Stefano Sabatini	case AVMEDIA_TYPE_VIDEO:
801	1677155d	Michael Niedermayer	if(st->time_base.num*1000LL > st->time_base.den){
802	c0df9d75	Michael Niedermayer	*pnum = st->time_base.num;
803			*pden = st->time_base.den;
804	01f4895c	Michael Niedermayer	}else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
805			*pnum = st->codec->time_base.num;
806			*pden = st->codec->time_base.den;
807	327c4076	Michael Niedermayer	if (pc && pc->repeat_pict) {
808	810c451b	Ivan Schreter	pnum = (pnum) * (1 + pc->repeat_pict);
809	327c4076	Michael Niedermayer	}
810	497431a5	Michael Niedermayer	//If this codec can be interlaced or progressive then we need a parser to compute duration of a packet
811			//Thus if we have no parser in such case leave duration undefined.
812			if(st->codec->ticks_per_frame>1 && !pc){
813			pnum = pden = 0;
814			}
815	fb2758c8	Fabrice Bellard	}
816			break;
817	72415b2a	Stefano Sabatini	case AVMEDIA_TYPE_AUDIO:
818	01f4895c	Michael Niedermayer	frame_size = get_audio_frame_size(st->codec, pkt->size);
819	6cbce636	Daniel Kang	if (frame_size <= 0 \|\| st->codec->sample_rate <= 0)
820	fb2758c8	Fabrice Bellard	break;
821			*pnum = frame_size;
822	01f4895c	Michael Niedermayer	*pden = st->codec->sample_rate;
823	fb2758c8	Fabrice Bellard	break;
824			default:
825			break;
826			}
827			}
828
829	5ba7c3d7	Michael Niedermayer	static int is_intra_only(AVCodecContext *enc){
830	72415b2a	Stefano Sabatini	if(enc->codec_type == AVMEDIA_TYPE_AUDIO){
831	5ba7c3d7	Michael Niedermayer	return 1;
832	72415b2a	Stefano Sabatini	}else if(enc->codec_type == AVMEDIA_TYPE_VIDEO){
833	5ba7c3d7	Michael Niedermayer	switch(enc->codec_id){
834			case CODEC_ID_MJPEG:
835			case CODEC_ID_MJPEGB:
836			case CODEC_ID_LJPEG:
837			case CODEC_ID_RAWVIDEO:
838			case CODEC_ID_DVVIDEO:
839			case CODEC_ID_HUFFYUV:
840	f37b9768	Loren Merritt	case CODEC_ID_FFVHUFF:
841	5ba7c3d7	Michael Niedermayer	case CODEC_ID_ASV1:
842			case CODEC_ID_ASV2:
843			case CODEC_ID_VCR1:
844	b774fdd7	Baptiste Coudurier	case CODEC_ID_DNXHD:
845	aa915625	Baptiste Coudurier	case CODEC_ID_JPEG2000:
846	5ba7c3d7	Michael Niedermayer	return 1;
847			default: break;
848			}
849			}
850			return 0;
851			}
852
853	9fcbcca6	Neil Brown	static void update_initial_timestamps(AVFormatContext *s, int stream_index,
854			int64_t dts, int64_t pts)
855			{
856	82583548	Michael Niedermayer	AVStream *st= s->streams[stream_index];
857			AVPacketList *pktl= s->packet_buffer;
858
859	7efeb73a	Michael Niedermayer	if(st->first_dts != AV_NOPTS_VALUE \|\| dts == AV_NOPTS_VALUE \|\| st->cur_dts == AV_NOPTS_VALUE)
860	82583548	Michael Niedermayer	return;
861
862			st->first_dts= dts - st->cur_dts;
863			st->cur_dts= dts;
864
865			for(; pktl; pktl= pktl->next){
866			if(pktl->pkt.stream_index != stream_index)
867			continue;
868			//FIXME think more about this check
869			if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
870			pktl->pkt.pts += st->first_dts;
871
872			if(pktl->pkt.dts != AV_NOPTS_VALUE)
873			pktl->pkt.dts += st->first_dts;
874	48a59dfe	Michael Niedermayer
875			if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
876			st->start_time= pktl->pkt.pts;
877	82583548	Michael Niedermayer	}
878	9fcbcca6	Neil Brown	if (st->start_time == AV_NOPTS_VALUE)
879			st->start_time = pts;
880	82583548	Michael Niedermayer	}
881
882	83a9db42	Michael Niedermayer	static void update_initial_durations(AVFormatContext s, AVStream st, AVPacket *pkt)
883			{
884			AVPacketList *pktl= s->packet_buffer;
885	820ad60c	Michael Niedermayer	int64_t cur_dts= 0;
886
887			if(st->first_dts != AV_NOPTS_VALUE){
888			cur_dts= st->first_dts;
889			for(; pktl; pktl= pktl->next){
890			if(pktl->pkt.stream_index == pkt->stream_index){
891			if(pktl->pkt.pts != pktl->pkt.dts \|\| pktl->pkt.dts != AV_NOPTS_VALUE \|\| pktl->pkt.duration)
892			break;
893			cur_dts -= pkt->duration;
894			}
895			}
896			pktl= s->packet_buffer;
897			st->first_dts = cur_dts;
898			}else if(st->cur_dts)
899			return;
900	83a9db42	Michael Niedermayer
901			for(; pktl; pktl= pktl->next){
902			if(pktl->pkt.stream_index != pkt->stream_index)
903			continue;
904	91acf9a8	Michael Niedermayer	if(pktl->pkt.pts == pktl->pkt.dts && pktl->pkt.dts == AV_NOPTS_VALUE
905			&& !pktl->pkt.duration){
906	820ad60c	Michael Niedermayer	pktl->pkt.dts= cur_dts;
907	5853423c	Michael Niedermayer	if(!st->codec->has_b_frames)
908	820ad60c	Michael Niedermayer	pktl->pkt.pts= cur_dts;
909			cur_dts += pkt->duration;
910	83a9db42	Michael Niedermayer	pktl->pkt.duration= pkt->duration;
911			}else
912			break;
913			}
914	820ad60c	Michael Niedermayer	if(st->first_dts == AV_NOPTS_VALUE)
915			st->cur_dts= cur_dts;
916	83a9db42	Michael Niedermayer	}
917
918	115329f1	Diego Biurrun	static void compute_pkt_fields(AVFormatContext s, AVStream st,
919	fb2758c8	Fabrice Bellard	AVCodecParserContext pc, AVPacket pkt)
920			{
921	d9e1efb7	Michael Niedermayer	int num, den, presentation_delayed, delay, i;
922	a74008a4	Joakim Plate	int64_t offset;
923	115329f1	Diego Biurrun
924	fe8344a2	Michael Niedermayer	if (s->flags & AVFMT_FLAG_NOFILLIN)
925			return;
926
927	c55806e3	Michael Niedermayer	if((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
928			pkt->dts= AV_NOPTS_VALUE;
929
930	f4a4be3f	Wallak	if (st->codec->codec_id != CODEC_ID_H264 && pc && pc->pict_type == FF_B_TYPE)
931	e18027ac	Carl Eugen Hoyos	//FIXME Set low_delay = 0 when has_b_frames = 1
932	818062f2	Baptiste Coudurier	st->codec->has_b_frames = 1;
933
934	f781f748	Michael Niedermayer	/* do we have a video B-frame ? */
935			delay= st->codec->has_b_frames;
936			presentation_delayed = 0;
937	37b00b47	Alexander Strange
938			// ignore delay caused by frame threading so that the mpeg2-without-dts
939			// warning will not trigger
940			if (delay && st->codec->active_thread_type&FF_THREAD_FRAME)
941			delay -= st->codec->thread_count-1;
942
943	f781f748	Michael Niedermayer	/* XXX: need has_b_frame, but cannot get it if the codec is
944			not initialized */
945			if (delay &&
946			pc && pc->pict_type != FF_B_TYPE)
947			presentation_delayed = 1;
948
949	10a7571b	Michael Niedermayer	if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
950			/&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts/){
951			pkt->dts -= 1LL<<st->pts_wrap_bits;
952			}
953
954	9806f846	Michael Niedermayer	// some mpeg2 in mpeg-ps lack dts (issue171 / input_file.mpg)
955			// we take the conservative approach and discard both
956			// Note, if this is misbehaving for a H.264 file then possibly presentation_delayed is not set correctly.
957			if(delay==1 && pkt->dts == pkt->pts && pkt->dts != AV_NOPTS_VALUE && presentation_delayed){
958	b0a18c2f	XBMC	av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination\n");
959	9806f846	Michael Niedermayer	pkt->dts= pkt->pts= AV_NOPTS_VALUE;
960			}
961
962	fb2758c8	Fabrice Bellard	if (pkt->duration == 0) {
963	3c895fc0	Michael Niedermayer	compute_frame_duration(&num, &den, st, pc, pkt);
964	fb2758c8	Fabrice Bellard	if (den && num) {
965	0e1f78f9	Michael Niedermayer	pkt->duration = av_rescale_rnd(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num, AV_ROUND_DOWN);
966	83a9db42	Michael Niedermayer
967	820ad60c	Michael Niedermayer	if(pkt->duration != 0 && s->packet_buffer)
968	83a9db42	Michael Niedermayer	update_initial_durations(s, st, pkt);
969	fb2758c8	Fabrice Bellard	}
970			}
971
972	a85736f2	Diego Biurrun	/* correct timestamps with byte offset if demuxers only have timestamps
973			on packet boundaries */
974	a74008a4	Joakim Plate	if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
975			/* this will estimate bitrate based on this frame's duration and size */
976			offset = av_rescale(pc->offset, pkt->duration, pkt->size);
977			if(pkt->pts != AV_NOPTS_VALUE)
978			pkt->pts += offset;
979			if(pkt->dts != AV_NOPTS_VALUE)
980			pkt->dts += offset;
981			}
982
983	27ca0a79	Ivan Schreter	if (pc && pc->dts_sync_point >= 0) {
984			// we have synchronization info from the parser
985			int64_t den = st->codec->time_base.den * (int64_t) st->time_base.num;
986			if (den > 0) {
987			int64_t num = st->codec->time_base.num * (int64_t) st->time_base.den;
988			if (pkt->dts != AV_NOPTS_VALUE) {
989			// got DTS from the stream, update reference timestamp
990			st->reference_dts = pkt->dts - pc->dts_ref_dts_delta * num / den;
991			pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
992			} else if (st->reference_dts != AV_NOPTS_VALUE) {
993			// compute DTS based on reference timestamp
994			pkt->dts = st->reference_dts + pc->dts_ref_dts_delta * num / den;
995			pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
996			}
997			if (pc->dts_sync_point > 0)
998			st->reference_dts = pkt->dts; // new reference
999			}
1000			}
1001
1002	755bfeab	Diego Biurrun	/* This may be redundant, but it should not hurt. */
1003	7e4baa66	Michael Niedermayer	if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
1004			presentation_delayed = 1;
1005	115329f1	Diego Biurrun
1006	949b1a13	Steve L'Homme	// av_log(NULL, AV_LOG_DEBUG, "IN delayed:%d pts:%"PRId64", dts:%"PRId64" cur_dts:%"PRId64" st:%d pc:%p\n", presentation_delayed, pkt->pts, pkt->dts, st->cur_dts, pkt->stream_index, pc);
1007	fb2758c8	Fabrice Bellard	/* interpolate PTS and DTS if they are not present */
1008	9e6c124a	Michael Niedermayer	//We skip H264 currently because delay and has_b_frames are not reliably set
1009			if((delay==0 \|\| (delay==1 && pc)) && st->codec->codec_id != CODEC_ID_H264){
1010	7e4baa66	Michael Niedermayer	if (presentation_delayed) {
1011	a85736f2	Diego Biurrun	/* DTS = decompression timestamp */
1012			/* PTS = presentation timestamp */
1013	7e4baa66	Michael Niedermayer	if (pkt->dts == AV_NOPTS_VALUE)
1014	635fbcb1	Michael Niedermayer	pkt->dts = st->last_IP_pts;
1015	9fcbcca6	Neil Brown	update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
1016	7e4baa66	Michael Niedermayer	if (pkt->dts == AV_NOPTS_VALUE)
1017			pkt->dts = st->cur_dts;
1018
1019			/* this is tricky: the dts must be incremented by the duration
1020	a85736f2	Diego Biurrun	of the frame we are displaying, i.e. the last I- or P-frame */
1021	635fbcb1	Michael Niedermayer	if (st->last_IP_duration == 0)
1022			st->last_IP_duration = pkt->duration;
1023	7efeb73a	Michael Niedermayer	if(pkt->dts != AV_NOPTS_VALUE)
1024	cdb5af79	Michael Niedermayer	st->cur_dts = pkt->dts + st->last_IP_duration;
1025	635fbcb1	Michael Niedermayer	st->last_IP_duration = pkt->duration;
1026			st->last_IP_pts= pkt->pts;
1027	7e4baa66	Michael Niedermayer	/* cannot compute PTS if not present (we can compute it only
1028	a85736f2	Diego Biurrun	by knowing the future */
1029	028d6f3e	Michael Niedermayer	} else if(pkt->pts != AV_NOPTS_VALUE \|\| pkt->dts != AV_NOPTS_VALUE \|\| pkt->duration){
1030	7e4baa66	Michael Niedermayer	if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
1031			int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
1032			int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
1033			if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
1034			pkt->pts += pkt->duration;
1035			// av_log(NULL, AV_LOG_DEBUG, "id:%d old:%"PRId64" new:%"PRId64" dur:%d cur:%"PRId64" size:%d\n", pkt->stream_index, old_diff, new_diff, pkt->duration, st->cur_dts, pkt->size);
1036			}
1037	90bb394d	Michael Niedermayer	}
1038	115329f1	Diego Biurrun
1039	7e4baa66	Michael Niedermayer	/* presentation is not delayed : PTS and DTS are the same */
1040			if(pkt->pts == AV_NOPTS_VALUE)
1041			pkt->pts = pkt->dts;
1042	9fcbcca6	Neil Brown	update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
1043	7e4baa66	Michael Niedermayer	if(pkt->pts == AV_NOPTS_VALUE)
1044			pkt->pts = st->cur_dts;
1045			pkt->dts = pkt->pts;
1046	7efeb73a	Michael Niedermayer	if(pkt->pts != AV_NOPTS_VALUE)
1047	cdb5af79	Michael Niedermayer	st->cur_dts = pkt->pts + pkt->duration;
1048	7e4baa66	Michael Niedermayer	}
1049	fb2758c8	Fabrice Bellard	}
1050	d9e1efb7	Michael Niedermayer
1051	cb5b96cd	Baptiste Coudurier	if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
1052	d9e1efb7	Michael Niedermayer	st->pts_buffer[0]= pkt->pts;
1053			for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
1054			FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
1055			if(pkt->dts == AV_NOPTS_VALUE)
1056			pkt->dts= st->pts_buffer[0];
1057	9e6c124a	Michael Niedermayer	if(st->codec->codec_id == CODEC_ID_H264){ //we skiped it above so we try here
1058	9fcbcca6	Neil Brown	update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
1059	82583548	Michael Niedermayer	}
1060	d9e1efb7	Michael Niedermayer	if(pkt->dts > st->cur_dts)
1061			st->cur_dts = pkt->dts;
1062			}
1063
1064			// av_log(NULL, AV_LOG_ERROR, "OUTdelayed:%d/%d pts:%"PRId64", dts:%"PRId64" cur_dts:%"PRId64"\n", presentation_delayed, delay, pkt->pts, pkt->dts, st->cur_dts);
1065	115329f1	Diego Biurrun
1066	fb2758c8	Fabrice Bellard	/* update flags */
1067	3a1d3588	Jeff Downs	if(is_intra_only(st->codec))
1068	cc947f04	Jean-Daniel Dupas	pkt->flags \|= AV_PKT_FLAG_KEY;
1069	3a1d3588	Jeff Downs	else if (pc) {
1070	fb2758c8	Fabrice Bellard	pkt->flags = 0;
1071	a85736f2	Diego Biurrun	/* keyframe computation */
1072	6363af44	Ivan Schreter	if (pc->key_frame == 1)
1073	cc947f04	Jean-Daniel Dupas	pkt->flags \|= AV_PKT_FLAG_KEY;
1074	6363af44	Ivan Schreter	else if (pc->key_frame == -1 && pc->pict_type == FF_I_TYPE)
1075	cc947f04	Jean-Daniel Dupas	pkt->flags \|= AV_PKT_FLAG_KEY;
1076	fb2758c8	Fabrice Bellard	}
1077	b1fa4942	Ivan Schreter	if (pc)
1078			pkt->convergence_duration = pc->convergence_duration;
1079	fb2758c8	Fabrice Bellard	}
1080
1081
1082			static int av_read_frame_internal(AVFormatContext s, AVPacket pkt)
1083			{
1084			AVStream *st;
1085	37353960	Fabrice Bellard	int len, ret, i;
1086	fb2758c8	Fabrice Bellard
1087	b237eb80	Michael Niedermayer	av_init_packet(pkt);
1088
1089	fb2758c8	Fabrice Bellard	for(;;) {
1090			/* select current input stream component */
1091			st = s->cur_st;
1092			if (st) {
1093	90ad92b3	Michael Niedermayer	if (!st->need_parsing \|\| !st->parser) {
1094	fb2758c8	Fabrice Bellard	/* no parsing needed: we just output the packet as is */
1095			/* raw data support */
1096	3a41c2f7	Michael Niedermayer	*pkt = st->cur_pkt; st->cur_pkt.data= NULL;
1097	fb2758c8	Fabrice Bellard	compute_pkt_fields(s, st, NULL, pkt);
1098			s->cur_st = NULL;
1099	74f5ae84	Reimar Döffinger	if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1100	cc947f04	Jean-Daniel Dupas	(pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1101	74f5ae84	Reimar Döffinger	ff_reduce_index(s, st->index);
1102			av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1103			}
1104	434cab9e	Michael Niedermayer	break;
1105	3a41c2f7	Michael Niedermayer	} else if (st->cur_len > 0 && st->discard < AVDISCARD_ALL) {
1106	61c23c15	Ivan Schreter	len = av_parser_parse2(st->parser, st->codec, &pkt->data, &pkt->size,
1107			st->cur_ptr, st->cur_len,
1108			st->cur_pkt.pts, st->cur_pkt.dts,
1109			st->cur_pkt.pos);
1110	3a41c2f7	Michael Niedermayer	st->cur_pkt.pts = AV_NOPTS_VALUE;
1111			st->cur_pkt.dts = AV_NOPTS_VALUE;
1112	fb2758c8	Fabrice Bellard	/* increment read pointer */
1113	3a41c2f7	Michael Niedermayer	st->cur_ptr += len;
1114			st->cur_len -= len;
1115	115329f1	Diego Biurrun
1116	fb2758c8	Fabrice Bellard	/* return packet if any */
1117			if (pkt->size) {
1118	37353960	Fabrice Bellard	got_packet:
1119	fb2758c8	Fabrice Bellard	pkt->duration = 0;
1120			pkt->stream_index = st->index;
1121	6ec87caa	Fabrice Bellard	pkt->pts = st->parser->pts;
1122			pkt->dts = st->parser->dts;
1123	61c23c15	Ivan Schreter	pkt->pos = st->parser->pos;
1124	a5266a47	Michael Niedermayer	if(pkt->data == st->cur_pkt.data && pkt->size == st->cur_pkt.size){
1125			s->cur_st = NULL;
1126			pkt->destruct= st->cur_pkt.destruct;
1127	22d78b05	Eli Friedman	st->cur_pkt.destruct= NULL;
1128	a5266a47	Michael Niedermayer	st->cur_pkt.data = NULL;
1129			assert(st->cur_len == 0);
1130			}else{
1131	80d403fc	Reimar Döffinger	pkt->destruct = NULL;
1132	a5266a47	Michael Niedermayer	}
1133	fb2758c8	Fabrice Bellard	compute_pkt_fields(s, st, st->parser, pkt);
1134	e9b78eeb	Michael Niedermayer
1135	cc947f04	Jean-Daniel Dupas	if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY){
1136	3dea63bd	Paul Kelly	ff_reduce_index(s, st->index);
1137	e9b78eeb	Michael Niedermayer	av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
1138			0, 0, AVINDEX_KEYFRAME);
1139			}
1140
1141	434cab9e	Michael Niedermayer	break;
1142	fb2758c8	Fabrice Bellard	}
1143			} else {
1144	bcbecff1	Fabrice Bellard	/* free packet */
1145	3a41c2f7	Michael Niedermayer	av_free_packet(&st->cur_pkt);
1146	fb2758c8	Fabrice Bellard	s->cur_st = NULL;
1147			}
1148			} else {
1149	3a41c2f7	Michael Niedermayer	AVPacket cur_pkt;
1150	fb2758c8	Fabrice Bellard	/* read next packet */
1151	3a41c2f7	Michael Niedermayer	ret = av_read_packet(s, &cur_pkt);
1152	37353960	Fabrice Bellard	if (ret < 0) {
1153	8fa36ae0	François Revol	if (ret == AVERROR(EAGAIN))
1154	37353960	Fabrice Bellard	return ret;
1155			/* return the last frames, if any */
1156			for(i = 0; i < s->nb_streams; i++) {
1157			st = s->streams[i];
1158	90ad92b3	Michael Niedermayer	if (st->parser && st->need_parsing) {
1159	61c23c15	Ivan Schreter	av_parser_parse2(st->parser, st->codec,
1160	115329f1	Diego Biurrun	&pkt->data, &pkt->size,
1161			NULL, 0,
1162	61c23c15	Ivan Schreter	AV_NOPTS_VALUE, AV_NOPTS_VALUE,
1163			AV_NOPTS_VALUE);
1164	37353960	Fabrice Bellard	if (pkt->size)
1165			goto got_packet;
1166			}
1167			}
1168	a85736f2	Diego Biurrun	/* no more packets: really terminate parsing */
1169	fb2758c8	Fabrice Bellard	return ret;
1170	37353960	Fabrice Bellard	}
1171	3a41c2f7	Michael Niedermayer	st = s->streams[cur_pkt.stream_index];
1172			st->cur_pkt= cur_pkt;
1173	115329f1	Diego Biurrun
1174	3a41c2f7	Michael Niedermayer	if(st->cur_pkt.pts != AV_NOPTS_VALUE &&
1175			st->cur_pkt.dts != AV_NOPTS_VALUE &&
1176			st->cur_pkt.pts < st->cur_pkt.dts){
1177	b18a4ab2	Michael Niedermayer	av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
1178	3a41c2f7	Michael Niedermayer	st->cur_pkt.stream_index,
1179			st->cur_pkt.pts,
1180			st->cur_pkt.dts,
1181			st->cur_pkt.size);
1182			// av_free_packet(&st->cur_pkt);
1183	b18a4ab2	Michael Niedermayer	// return -1;
1184			}
1185
1186	45b2b05f	Michael Niedermayer	if(s->debug & FF_FDEBUG_TS)
1187	050ba6f4	Baptiste Coudurier	av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1188	3a41c2f7	Michael Niedermayer	st->cur_pkt.stream_index,
1189			st->cur_pkt.pts,
1190			st->cur_pkt.dts,
1191			st->cur_pkt.size,
1192	050ba6f4	Baptiste Coudurier	st->cur_pkt.duration,
1193	3a41c2f7	Michael Niedermayer	st->cur_pkt.flags);
1194	fb2758c8	Fabrice Bellard
1195			s->cur_st = st;
1196	3a41c2f7	Michael Niedermayer	st->cur_ptr = st->cur_pkt.data;
1197			st->cur_len = st->cur_pkt.size;
1198	fe8344a2	Michael Niedermayer	if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1199	01f4895c	Michael Niedermayer	st->parser = av_parser_init(st->codec->codec_id);
1200	fb2758c8	Fabrice Bellard	if (!st->parser) {
1201	a85736f2	Diego Biurrun	/* no parser available: just output the raw packets */
1202	57004ff1	Aurelien Jacobs	st->need_parsing = AVSTREAM_PARSE_NONE;
1203			}else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
1204	7cbaa7ba	Michael Niedermayer	st->parser->flags \|= PARSER_FLAG_COMPLETE_FRAMES;
1205	74a6df59	Alex Converse	}else if(st->need_parsing == AVSTREAM_PARSE_FULL_ONCE){
1206			st->parser->flags \|= PARSER_FLAG_ONCE;
1207	fb2758c8	Fabrice Bellard	}
1208			}
1209			}
1210			}
1211	45b2b05f	Michael Niedermayer	if(s->debug & FF_FDEBUG_TS)
1212	050ba6f4	Baptiste Coudurier	av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1213	434cab9e	Michael Niedermayer	pkt->stream_index,
1214			pkt->pts,
1215			pkt->dts,
1216	3041a4a1	Michael Niedermayer	pkt->size,
1217	050ba6f4	Baptiste Coudurier	pkt->duration,
1218	3041a4a1	Michael Niedermayer	pkt->flags);
1219	434cab9e	Michael Niedermayer
1220			return 0;
1221	fb2758c8	Fabrice Bellard	}
1222
1223			int av_read_frame(AVFormatContext s, AVPacket pkt)
1224			{
1225	de6d9b64	Fabrice Bellard	AVPacketList *pktl;
1226	30bc6613	Michael Niedermayer	int eof=0;
1227			const int genpts= s->flags & AVFMT_FLAG_GENPTS;
1228
1229			for(;;){
1230			pktl = s->packet_buffer;
1231			if (pktl) {
1232			AVPacket *next_pkt= &pktl->pkt;
1233
1234			if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
1235	5be5d28c	Stephen Dredge	int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1236	30bc6613	Michael Niedermayer	while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
1237	115329f1	Diego Biurrun	if( pktl->pkt.stream_index == next_pkt->stream_index
1238	5be5d28c	Stephen Dredge	&& (0 > av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)))
1239			&& av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) { //not b frame
1240	30bc6613	Michael Niedermayer	next_pkt->pts= pktl->pkt.dts;
1241			}
1242			pktl= pktl->next;
1243			}
1244			pktl = s->packet_buffer;
1245			}
1246	115329f1	Diego Biurrun
1247			if( next_pkt->pts != AV_NOPTS_VALUE
1248			\|\| next_pkt->dts == AV_NOPTS_VALUE
1249	30bc6613	Michael Niedermayer	\|\| !genpts \|\| eof){
1250			/* read packet from packet buffer, if there is data */
1251			pkt = next_pkt;
1252			s->packet_buffer = pktl->next;
1253			av_free(pktl);
1254			return 0;
1255			}
1256			}
1257			if(genpts){
1258			int ret= av_read_frame_internal(s, pkt);
1259			if(ret<0){
1260	8fa36ae0	François Revol	if(pktl && ret != AVERROR(EAGAIN)){
1261	30bc6613	Michael Niedermayer	eof=1;
1262			continue;
1263			}else
1264			return ret;
1265			}
1266	115329f1	Diego Biurrun
1267	5c5b1731	Måns Rullgård	if(av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1268			&s->packet_buffer_end)) < 0)
1269	769e10f0	Panagiotis Issaris	return AVERROR(ENOMEM);
1270	30bc6613	Michael Niedermayer	}else{
1271			assert(!s->packet_buffer);
1272			return av_read_frame_internal(s, pkt);
1273			}
1274	fb2758c8	Fabrice Bellard	}
1275			}
1276
1277			/* XXX: suppress the packet queue */
1278			static void flush_packet_queue(AVFormatContext *s)
1279			{
1280			AVPacketList *pktl;
1281
1282			for(;;) {
1283			pktl = s->packet_buffer;
1284	115329f1	Diego Biurrun	if (!pktl)
1285	fb2758c8	Fabrice Bellard	break;
1286			s->packet_buffer = pktl->next;
1287			av_free_packet(&pktl->pkt);
1288			av_free(pktl);
1289	b9a281db	Fabrice Bellard	}
1290	86cb7e33	Baptiste Coudurier	while(s->raw_packet_buffer){
1291			pktl = s->raw_packet_buffer;
1292			s->raw_packet_buffer = pktl->next;
1293			av_free_packet(&pktl->pkt);
1294			av_free(pktl);
1295			}
1296	42831b46	Michael Niedermayer	s->packet_buffer_end=
1297			s->raw_packet_buffer_end= NULL;
1298	af122d6a	Baptiste Coudurier	s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1299	b9a281db	Fabrice Bellard	}
1300
1301	da24c5e3	Fabrice Bellard	/*******************************************************/
1302	fb2758c8	Fabrice Bellard	/* seek support */
1303
1304	b754978a	Michael Niedermayer	int av_find_default_stream_index(AVFormatContext *s)
1305			{
1306	ca162a50	Aurelien Jacobs	int first_audio_index = -1;
1307	b754978a	Michael Niedermayer	int i;
1308			AVStream *st;
1309
1310			if (s->nb_streams <= 0)
1311			return -1;
1312			for(i = 0; i < s->nb_streams; i++) {
1313			st = s->streams[i];
1314	72415b2a	Stefano Sabatini	if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1315	b754978a	Michael Niedermayer	return i;
1316			}
1317	72415b2a	Stefano Sabatini	if (first_audio_index < 0 && st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1318	ca162a50	Aurelien Jacobs	first_audio_index = i;
1319	b754978a	Michael Niedermayer	}
1320	ca162a50	Aurelien Jacobs	return first_audio_index >= 0 ? first_audio_index : 0;
1321	b754978a	Michael Niedermayer	}
1322
1323	e36bdf8b	Daniel Kristjansson	/**
1324			* Flush the frame reader.
1325			*/
1326	972ffe62	Aurelien Jacobs	void ff_read_frame_flush(AVFormatContext *s)
1327	fb2758c8	Fabrice Bellard	{
1328			AVStream *st;
1329	106fa129	John Stebbins	int i, j;
1330	fb2758c8	Fabrice Bellard
1331			flush_packet_queue(s);
1332
1333	3a41c2f7	Michael Niedermayer	s->cur_st = NULL;
1334	115329f1	Diego Biurrun
1335	fb2758c8	Fabrice Bellard	/* for each stream, reset read state */
1336			for(i = 0; i < s->nb_streams; i++) {
1337			st = s->streams[i];
1338	115329f1	Diego Biurrun
1339	fb2758c8	Fabrice Bellard	if (st->parser) {
1340			av_parser_close(st->parser);
1341			st->parser = NULL;
1342	3a41c2f7	Michael Niedermayer	av_free_packet(&st->cur_pkt);
1343	fb2758c8	Fabrice Bellard	}
1344	635fbcb1	Michael Niedermayer	st->last_IP_pts = AV_NOPTS_VALUE;
1345	a843d1ff	Michael Niedermayer	st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1346	27ca0a79	Ivan Schreter	st->reference_dts = AV_NOPTS_VALUE;
1347	3a41c2f7	Michael Niedermayer	/* fail safe */
1348			st->cur_ptr = NULL;
1349			st->cur_len = 0;
1350	86cb7e33	Baptiste Coudurier
1351			st->probe_packets = MAX_PROBE_PACKETS;
1352	106fa129	John Stebbins
1353			for(j=0; j<MAX_REORDER_DELAY+1; j++)
1354			st->pts_buffer[j]= AV_NOPTS_VALUE;
1355	fb2758c8	Fabrice Bellard	}
1356			}
1357
1358	22ffac70	Reimar Döffinger	void av_update_cur_dts(AVFormatContext s, AVStream ref_st, int64_t timestamp){
1359	8bcb147f	Michael Niedermayer	int i;
1360
1361			for(i = 0; i < s->nb_streams; i++) {
1362	1a1dc611	Nathan Kurz	AVStream *st = s->streams[i];
1363	8bcb147f	Michael Niedermayer
1364	115329f1	Diego Biurrun	st->cur_dts = av_rescale(timestamp,
1365	1a1dc611	Nathan Kurz	st->time_base.den * (int64_t)ref_st->time_base.num,
1366			st->time_base.num * (int64_t)ref_st->time_base.den);
1367	8bcb147f	Michael Niedermayer	}
1368			}
1369
1370	3dea63bd	Paul Kelly	void ff_reduce_index(AVFormatContext *s, int stream_index)
1371			{
1372			AVStream *st= s->streams[stream_index];
1373			unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1374
1375			if((unsigned)st->nb_index_entries >= max_entries){
1376			int i;
1377			for(i=0; 2*i<st->nb_index_entries; i++)
1378			st->index_entries[i]= st->index_entries[2*i];
1379			st->nb_index_entries= i;
1380			}
1381			}
1382
1383	e6fb5a4f	Peter Ross	int ff_add_index_entry(AVIndexEntry **index_entries,
1384			int *nb_index_entries,
1385			unsigned int *index_entries_allocated_size,
1386			int64_t pos, int64_t timestamp, int size, int distance, int flags)
1387	fb2758c8	Fabrice Bellard	{
1388			AVIndexEntry entries, ie;
1389	b754978a	Michael Niedermayer	int index;
1390	115329f1	Diego Biurrun
1391	e6fb5a4f	Peter Ross	if((unsigned)*nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1392	568e18b1	Michael Niedermayer	return -1;
1393	115329f1	Diego Biurrun
1394	e6fb5a4f	Peter Ross	entries = av_fast_realloc(*index_entries,
1395			index_entries_allocated_size,
1396			(nb_index_entries + 1)
1397	fb2758c8	Fabrice Bellard	sizeof(AVIndexEntry));
1398	568e18b1	Michael Niedermayer	if(!entries)
1399			return -1;
1400
1401	e6fb5a4f	Peter Ross	*index_entries= entries;
1402	b754978a	Michael Niedermayer
1403	e6fb5a4f	Peter Ross	index= ff_index_search_timestamp(index_entries, nb_index_entries, timestamp, AVSEEK_FLAG_ANY);
1404	b754978a	Michael Niedermayer
1405	3ba1438d	Michael Niedermayer	if(index<0){
1406	e6fb5a4f	Peter Ross	index= (*nb_index_entries)++;
1407	3e9245a9	Michael Niedermayer	ie= &entries[index];
1408	3ba1438d	Michael Niedermayer	assert(index==0 \|\| ie[-1].timestamp < timestamp);
1409			}else{
1410			ie= &entries[index];
1411			if(ie->timestamp != timestamp){
1412	528c2c73	Michael Niedermayer	if(ie->timestamp <= timestamp)
1413			return -1;
1414	e6fb5a4f	Peter Ross	memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)(nb_index_entries - index));
1415			(*nb_index_entries)++;
1416	755bfeab	Diego Biurrun	}else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1417	3ba1438d	Michael Niedermayer	distance= ie->min_distance;
1418	3e9245a9	Michael Niedermayer	}
1419	3ba1438d	Michael Niedermayer
1420	b754978a	Michael Niedermayer	ie->pos = pos;
1421			ie->timestamp = timestamp;
1422	3e9245a9	Michael Niedermayer	ie->min_distance= distance;
1423	30a43f2d	Michael Niedermayer	ie->size= size;
1424	b754978a	Michael Niedermayer	ie->flags = flags;
1425	115329f1	Diego Biurrun
1426	3e9245a9	Michael Niedermayer	return index;
1427	fb2758c8	Fabrice Bellard	}
1428
1429	e6fb5a4f	Peter Ross	int av_add_index_entry(AVStream *st,
1430			int64_t pos, int64_t timestamp, int size, int distance, int flags)
1431			{
1432			return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1433			&st->index_entries_allocated_size, pos,
1434			timestamp, size, distance, flags);
1435			}
1436
1437			int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1438			int64_t wanted_timestamp, int flags)
1439	fb2758c8	Fabrice Bellard	{
1440			int a, b, m;
1441			int64_t timestamp;
1442
1443	3ba1438d	Michael Niedermayer	a = - 1;
1444			b = nb_entries;
1445	b754978a	Michael Niedermayer
1446	67c10de7	Michael Niedermayer	//optimize appending index entries at the end
1447			if(b && entries[b-1].timestamp < wanted_timestamp)
1448			a= b-1;
1449
1450	3ba1438d	Michael Niedermayer	while (b - a > 1) {
1451			m = (a + b) >> 1;
1452	fb2758c8	Fabrice Bellard	timestamp = entries[m].timestamp;
1453	3ba1438d	Michael Niedermayer	if(timestamp >= wanted_timestamp)
1454			b = m;
1455			if(timestamp <= wanted_timestamp)
1456	b754978a	Michael Niedermayer	a = m;
1457	fb2758c8	Fabrice Bellard	}
1458	27a5fe5f	Michael Niedermayer	m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1459	115329f1	Diego Biurrun
1460	27a5fe5f	Michael Niedermayer	if(!(flags & AVSEEK_FLAG_ANY)){
1461			while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1462			m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1463			}
1464			}
1465	3ba1438d	Michael Niedermayer
1466	115329f1	Diego Biurrun	if(m == nb_entries)
1467	3ba1438d	Michael Niedermayer	return -1;
1468			return m;
1469	fb2758c8	Fabrice Bellard	}
1470
1471	e6fb5a4f	Peter Ross	int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1472			int flags)
1473			{
1474			return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
1475			wanted_timestamp, flags);
1476			}
1477
1478	0f652a8e	Benoit Fouet	#define DEBUG_SEEK
1479	8d14a25c	Michael Niedermayer
1480	3ba1438d	Michael Niedermayer	int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1481	8d14a25c	Michael Niedermayer	AVInputFormat *avif= s->iformat;
1482	e6586575	Diego Biurrun	int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1483	8d14a25c	Michael Niedermayer	int64_t ts_min, ts_max, ts;
1484	89ddd2a9	Michael Niedermayer	int index;
1485	b593f7fd	Sean Soria	int64_t ret;
1486	8d14a25c	Michael Niedermayer	AVStream *st;
1487
1488	cdd5034f	Michael Niedermayer	if (stream_index < 0)
1489			return -1;
1490	115329f1	Diego Biurrun
1491	8d14a25c	Michael Niedermayer	#ifdef DEBUG_SEEK
1492	4733abcb	Måns Rullgård	av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1493	8d14a25c	Michael Niedermayer	#endif
1494
1495			ts_max=
1496			ts_min= AV_NOPTS_VALUE;
1497	90b5b51e	Diego Biurrun	pos_limit= -1; //gcc falsely says it may be uninitialized
1498	8d14a25c	Michael Niedermayer
1499			st= s->streams[stream_index];
1500			if(st->index_entries){
1501			AVIndexEntry *e;
1502
1503	a85736f2	Diego Biurrun	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()
1504	3ba1438d	Michael Niedermayer	index= FFMAX(index, 0);
1505	8d14a25c	Michael Niedermayer	e= &st->index_entries[index];
1506
1507			if(e->timestamp <= target_ts \|\| e->pos == e->min_distance){
1508			pos_min= e->pos;
1509			ts_min= e->timestamp;
1510			#ifdef DEBUG_SEEK
1511	c0492097	Diego Biurrun	av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1512			pos_min,ts_min);
1513	8d14a25c	Michael Niedermayer	#endif
1514			}else{
1515			assert(index==0);
1516			}
1517	115329f1	Diego Biurrun
1518			index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1519	27a5fe5f	Michael Niedermayer	assert(index < st->nb_index_entries);
1520			if(index >= 0){
1521	8d14a25c	Michael Niedermayer	e= &st->index_entries[index];
1522			assert(e->timestamp >= target_ts);
1523			pos_max= e->pos;
1524			ts_max= e->timestamp;
1525			pos_limit= pos_max - e->min_distance;
1526			#ifdef DEBUG_SEEK
1527	c0492097	Diego Biurrun	av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1528			pos_max,pos_limit, ts_max);
1529	8d14a25c	Michael Niedermayer	#endif
1530			}
1531			}
1532
1533	89ddd2a9	Michael Niedermayer	pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1534			if(pos<0)
1535			return -1;
1536
1537			/* do the seek */
1538	6b4aa5da	Anton Khirnov	if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
1539	b593f7fd	Sean Soria	return ret;
1540	89ddd2a9	Michael Niedermayer
1541			av_update_cur_dts(s, st, ts);
1542
1543			return 0;
1544			}
1545
1546			int64_t av_gen_search(AVFormatContext s, int stream_index, int64_t target_ts, int64_t pos_min, int64_t pos_max, int64_t pos_limit, int64_t ts_min, int64_t ts_max, int flags, int64_t ts_ret, int64_t (read_timestamp)(struct AVFormatContext , int , int64_t *, int64_t )){
1547			int64_t pos, ts;
1548			int64_t start_pos, filesize;
1549			int no_change;
1550
1551			#ifdef DEBUG_SEEK
1552			av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1553			#endif
1554
1555	8d14a25c	Michael Niedermayer	if(ts_min == AV_NOPTS_VALUE){
1556			pos_min = s->data_offset;
1557	89ddd2a9	Michael Niedermayer	ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1558	8d14a25c	Michael Niedermayer	if (ts_min == AV_NOPTS_VALUE)
1559			return -1;
1560			}
1561
1562			if(ts_max == AV_NOPTS_VALUE){
1563			int step= 1024;
1564	76aa876e	Anton Khirnov	filesize = avio_size(s->pb);
1565	6fd93ce2	Kenneth Aafløy	pos_max = filesize - 1;
1566	8d14a25c	Michael Niedermayer	do{
1567			pos_max -= step;
1568	89ddd2a9	Michael Niedermayer	ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1569	8d14a25c	Michael Niedermayer	step += step;
1570			}while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1571			if (ts_max == AV_NOPTS_VALUE)
1572			return -1;
1573	115329f1	Diego Biurrun
1574	8d14a25c	Michael Niedermayer	for(;;){
1575			int64_t tmp_pos= pos_max + 1;
1576	89ddd2a9	Michael Niedermayer	int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1577	8d14a25c	Michael Niedermayer	if(tmp_ts == AV_NOPTS_VALUE)
1578			break;
1579			ts_max= tmp_ts;
1580			pos_max= tmp_pos;
1581	6fd93ce2	Kenneth Aafløy	if(tmp_pos >= filesize)
1582			break;
1583	8d14a25c	Michael Niedermayer	}
1584			pos_limit= pos_max;
1585			}
1586
1587	53f7c43f	Michael Niedermayer	if(ts_min > ts_max){
1588			return -1;
1589			}else if(ts_min == ts_max){
1590			pos_limit= pos_min;
1591			}
1592
1593	8d14a25c	Michael Niedermayer	no_change=0;
1594			while (pos_min < pos_limit) {
1595			#ifdef DEBUG_SEEK
1596	115329f1	Diego Biurrun	av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1597	8d14a25c	Michael Niedermayer	pos_min, pos_max,
1598			ts_min, ts_max);
1599			#endif
1600			assert(pos_limit <= pos_max);
1601
1602			if(no_change==0){
1603			int64_t approximate_keyframe_distance= pos_max - pos_limit;
1604			// interpolate position (better than dichotomy)
1605	3ba1438d	Michael Niedermayer	pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1606			+ pos_min - approximate_keyframe_distance;
1607	8d14a25c	Michael Niedermayer	}else if(no_change==1){
1608			// bisection, if interpolation failed to change min or max pos last time
1609			pos = (pos_min + pos_limit)>>1;
1610			}else{
1611	a85736f2	Diego Biurrun	/* linear search if bisection failed, can only happen if there
1612			are very few or no keyframes between min/max */
1613	8d14a25c	Michael Niedermayer	pos=pos_min;
1614			}
1615			if(pos <= pos_min)
1616			pos= pos_min + 1;
1617			else if(pos > pos_limit)
1618			pos= pos_limit;
1619			start_pos= pos;
1620
1621	89ddd2a9	Michael Niedermayer	ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1622	8d14a25c	Michael Niedermayer	if(pos == pos_max)
1623			no_change++;
1624			else
1625			no_change=0;
1626			#ifdef DEBUG_SEEK
1627	c0492097	Diego Biurrun	av_log(s, AV_LOG_DEBUG, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64" target:%"PRId64" limit:%"PRId64" start:%"PRId64" noc:%d\n",
1628			pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts, pos_limit,
1629			start_pos, no_change);
1630	8d14a25c	Michael Niedermayer	#endif
1631	db2a0e22	Michael Niedermayer	if(ts == AV_NOPTS_VALUE){
1632			av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1633			return -1;
1634			}
1635	8d14a25c	Michael Niedermayer	assert(ts != AV_NOPTS_VALUE);
1636	3ba1438d	Michael Niedermayer	if (target_ts <= ts) {
1637	8d14a25c	Michael Niedermayer	pos_limit = start_pos - 1;
1638			pos_max = pos;
1639			ts_max = ts;
1640	3ba1438d	Michael Niedermayer	}
1641			if (target_ts >= ts) {
1642	8d14a25c	Michael Niedermayer	pos_min = pos;
1643			ts_min = ts;
1644			}
1645			}
1646	115329f1	Diego Biurrun
1647	3ba1438d	Michael Niedermayer	pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1648			ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
1649	8d14a25c	Michael Niedermayer	#ifdef DEBUG_SEEK
1650			pos_min = pos;
1651	89ddd2a9	Michael Niedermayer	ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1652	8d14a25c	Michael Niedermayer	pos_min++;
1653	89ddd2a9	Michael Niedermayer	ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1654	115329f1	Diego Biurrun	av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1655	8d14a25c	Michael Niedermayer	pos, ts_min, target_ts, ts_max);
1656			#endif
1657	89ddd2a9	Michael Niedermayer	*ts_ret= ts;
1658			return pos;
1659	8d14a25c	Michael Niedermayer	}
1660
1661	3ba1438d	Michael Niedermayer	static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1662			int64_t pos_min, pos_max;
1663			#if 0
1664			AVStream *st;
1665
1666			if (stream_index < 0)
1667			return -1;
1668
1669			st= s->streams[stream_index];
1670			#endif
1671
1672			pos_min = s->data_offset;
1673	76aa876e	Anton Khirnov	pos_max = avio_size(s->pb) - 1;
1674	3ba1438d	Michael Niedermayer
1675			if (pos < pos_min) pos= pos_min;
1676			else if(pos > pos_max) pos= pos_max;
1677
1678	6b4aa5da	Anton Khirnov	avio_seek(s->pb, pos, SEEK_SET);
1679	3ba1438d	Michael Niedermayer
1680			#if 0
1681	8bcb147f	Michael Niedermayer	av_update_cur_dts(s, st, ts);
1682	3ba1438d	Michael Niedermayer	#endif
1683			return 0;
1684			}
1685
1686	115329f1	Diego Biurrun	static int av_seek_frame_generic(AVFormatContext *s,
1687	3ba1438d	Michael Niedermayer	int stream_index, int64_t timestamp, int flags)
1688	fb2758c8	Fabrice Bellard	{
1689	6659b32a	Sean Soria	int index;
1690			int64_t ret;
1691	fb2758c8	Fabrice Bellard	AVStream *st;
1692			AVIndexEntry *ie;
1693
1694			st = s->streams[stream_index];
1695	e9b78eeb	Michael Niedermayer
1696	27a5fe5f	Michael Niedermayer	index = av_index_search_timestamp(st, timestamp, flags);
1697	e9b78eeb	Michael Niedermayer
1698	8c3b161e	Michael Niedermayer	if(index < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
1699			return -1;
1700
1701	b5a3541d	Michael Niedermayer	if(index < 0 \|\| index==st->nb_index_entries-1){
1702	e9b78eeb	Michael Niedermayer	int i;
1703			AVPacket pkt;
1704
1705	5e5c9086	Michael Niedermayer	if(st->nb_index_entries){
1706			assert(st->index_entries);
1707	e9b78eeb	Michael Niedermayer	ie= &st->index_entries[st->nb_index_entries-1];
1708	6b4aa5da	Anton Khirnov	if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1709	aaec4e03	Baptiste Coudurier	return ret;
1710	e9b78eeb	Michael Niedermayer	av_update_cur_dts(s, st, ie->timestamp);
1711	aaec4e03	Baptiste Coudurier	}else{
1712	6b4aa5da	Anton Khirnov	if ((ret = avio_seek(s->pb, s->data_offset, SEEK_SET)) < 0)
1713	aaec4e03	Baptiste Coudurier	return ret;
1714			}
1715	e9b78eeb	Michael Niedermayer	for(i=0;; i++) {
1716	cda6902d	Michael Niedermayer	int ret;
1717			do{
1718			ret = av_read_frame(s, &pkt);
1719			}while(ret == AVERROR(EAGAIN));
1720	e9b78eeb	Michael Niedermayer	if(ret<0)
1721			break;
1722			av_free_packet(&pkt);
1723			if(stream_index == pkt.stream_index){
1724	cc947f04	Jean-Daniel Dupas	if((pkt.flags & AV_PKT_FLAG_KEY) && pkt.dts > timestamp)
1725	e9b78eeb	Michael Niedermayer	break;
1726			}
1727			}
1728			index = av_index_search_timestamp(st, timestamp, flags);
1729			}
1730	fb2758c8	Fabrice Bellard	if (index < 0)
1731			return -1;
1732
1733	972ffe62	Aurelien Jacobs	ff_read_frame_flush(s);
1734	e9b78eeb	Michael Niedermayer	if (s->iformat->read_seek){
1735			if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1736			return 0;
1737			}
1738			ie = &st->index_entries[index];
1739	6b4aa5da	Anton Khirnov	if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1740	aaec4e03	Baptiste Coudurier	return ret;
1741	8bcb147f	Michael Niedermayer	av_update_cur_dts(s, st, ie->timestamp);
1742	cdd5034f	Michael Niedermayer
1743	fb2758c8	Fabrice Bellard	return 0;
1744			}
1745
1746	3ba1438d	Michael Niedermayer	int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1747	fb2758c8	Fabrice Bellard	{
1748			int ret;
1749	cdd5034f	Michael Niedermayer	AVStream *st;
1750	115329f1	Diego Biurrun
1751	972ffe62	Aurelien Jacobs	ff_read_frame_flush(s);
1752	115329f1	Diego Biurrun
1753	3ba1438d	Michael Niedermayer	if(flags & AVSEEK_FLAG_BYTE)
1754			return av_seek_frame_byte(s, stream_index, timestamp, flags);
1755	115329f1	Diego Biurrun
1756	cdd5034f	Michael Niedermayer	if(stream_index < 0){
1757			stream_index= av_find_default_stream_index(s);
1758			if(stream_index < 0)
1759			return -1;
1760	115329f1	Diego Biurrun
1761	3ba1438d	Michael Niedermayer	st= s->streams[stream_index];
1762	eb497825	Nathan Kurz	/* timestamp for default must be expressed in AV_TIME_BASE units */
1763	3ba1438d	Michael Niedermayer	timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1764	cdd5034f	Michael Niedermayer	}
1765
1766	fb2758c8	Fabrice Bellard	/* first, we try the format specific seek */
1767			if (s->iformat->read_seek)
1768	3ba1438d	Michael Niedermayer	ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1769	fb2758c8	Fabrice Bellard	else
1770			ret = -1;
1771			if (ret >= 0) {
1772			return 0;
1773			}
1774	8d14a25c	Michael Niedermayer
1775			if(s->iformat->read_timestamp)
1776	3ba1438d	Michael Niedermayer	return av_seek_frame_binary(s, stream_index, timestamp, flags);
1777	8d14a25c	Michael Niedermayer	else
1778	3ba1438d	Michael Niedermayer	return av_seek_frame_generic(s, stream_index, timestamp, flags);
1779	fb2758c8	Fabrice Bellard	}
1780
1781	32d88592	Michael Niedermayer	int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
1782			{
1783			if(min_ts > ts \|\| max_ts < ts)
1784			return -1;
1785
1786	972ffe62	Aurelien Jacobs	ff_read_frame_flush(s);
1787	32d88592	Michael Niedermayer
1788			if (s->iformat->read_seek2)
1789			return s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
1790
1791			if(s->iformat->read_timestamp){
1792			//try to seek via read_timestamp()
1793			}
1794
1795			//Fallback to old API if new is not implemented but old is
1796			//Note the old has somewat different sematics
1797			if(s->iformat->read_seek \|\| 1)
1798	85b4230f	Michael Niedermayer	return av_seek_frame(s, stream_index, ts, flags \| (ts - min_ts > (uint64_t)(max_ts - ts) ? AVSEEK_FLAG_BACKWARD : 0));
1799	32d88592	Michael Niedermayer
1800			// try some generic seek like av_seek_frame_generic() but with new ts semantics
1801			}
1802
1803	fb2758c8	Fabrice Bellard	/*******************************************************/
1804	12f996ed	Fabrice Bellard
1805	e36bdf8b	Daniel Kristjansson	/**
1806	49bd8e4b	Måns Rullgård	* Return TRUE if the stream has accurate duration in any stream.
1807	e36bdf8b	Daniel Kristjansson	*
1808	c1e8b678	Neil Brown	* @return TRUE if the stream has accurate duration for at least one component.
1809	e36bdf8b	Daniel Kristjansson	*/
1810	c1e8b678	Neil Brown	static int av_has_duration(AVFormatContext *ic)
1811	12f996ed	Fabrice Bellard	{
1812			int i;
1813			AVStream *st;
1814
1815			for(i = 0;i < ic->nb_streams; i++) {
1816			st = ic->streams[i];
1817	c1e8b678	Neil Brown	if (st->duration != AV_NOPTS_VALUE)
1818	12f996ed	Fabrice Bellard	return 1;
1819			}
1820			return 0;
1821			}
1822
1823	e36bdf8b	Daniel Kristjansson	/**
1824			* Estimate the stream timings from the one of each components.
1825			*
1826			* Also computes the global bitrate if possible.
1827			*/
1828	12f996ed	Fabrice Bellard	static void av_update_stream_timings(AVFormatContext *ic)
1829			{
1830	c0df9d75	Michael Niedermayer	int64_t start_time, start_time1, end_time, end_time1;
1831	c1e8b678	Neil Brown	int64_t duration, duration1;
1832	12f996ed	Fabrice Bellard	int i;
1833			AVStream *st;
1834
1835	f27a7268	Måns Rullgård	start_time = INT64_MAX;
1836			end_time = INT64_MIN;
1837	c1e8b678	Neil Brown	duration = INT64_MIN;
1838	12f996ed	Fabrice Bellard	for(i = 0;i < ic->nb_streams; i++) {
1839			st = ic->streams[i];
1840	7f938dd3	Aurelien Jacobs	if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
1841	c0df9d75	Michael Niedermayer	start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1842			if (start_time1 < start_time)
1843			start_time = start_time1;
1844	12f996ed	Fabrice Bellard	if (st->duration != AV_NOPTS_VALUE) {
1845	c0df9d75	Michael Niedermayer	end_time1 = start_time1
1846			+ av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1847	12f996ed	Fabrice Bellard	if (end_time1 > end_time)
1848			end_time = end_time1;
1849			}
1850			}
1851	c1e8b678	Neil Brown	if (st->duration != AV_NOPTS_VALUE) {
1852			duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1853			if (duration1 > duration)
1854			duration = duration1;
1855			}
1856	12f996ed	Fabrice Bellard	}
1857	f27a7268	Måns Rullgård	if (start_time != INT64_MAX) {
1858	12f996ed	Fabrice Bellard	ic->start_time = start_time;
1859	f27a7268	Måns Rullgård	if (end_time != INT64_MIN) {
1860	c1e8b678	Neil Brown	if (end_time - start_time > duration)
1861			duration = end_time - start_time;
1862			}
1863			}
1864			if (duration != INT64_MIN) {
1865			ic->duration = duration;
1866			if (ic->file_size > 0) {
1867	a85736f2	Diego Biurrun	/* compute the bitrate */
1868	c1e8b678	Neil Brown	ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1869			(double)ic->duration;
1870	12f996ed	Fabrice Bellard	}
1871			}
1872			}
1873
1874			static void fill_all_stream_timings(AVFormatContext *ic)
1875			{
1876			int i;
1877			AVStream *st;
1878
1879			av_update_stream_timings(ic);
1880			for(i = 0;i < ic->nb_streams; i++) {
1881			st = ic->streams[i];
1882			if (st->start_time == AV_NOPTS_VALUE) {
1883	c0df9d75	Michael Niedermayer	if(ic->start_time != AV_NOPTS_VALUE)
1884			st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1885			if(ic->duration != AV_NOPTS_VALUE)
1886			st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1887	12f996ed	Fabrice Bellard	}
1888			}
1889			}
1890
1891			static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1892			{
1893			int64_t filesize, duration;
1894			int bit_rate, i;
1895			AVStream *st;
1896
1897			/* if bit_rate is already set, we believe it */
1898	9100d4d6	David Czech	if (ic->bit_rate <= 0) {
1899	12f996ed	Fabrice Bellard	bit_rate = 0;
1900			for(i=0;i<ic->nb_streams;i++) {
1901			st = ic->streams[i];
1902	9100d4d6	David Czech	if (st->codec->bit_rate > 0)
1903	01f4895c	Michael Niedermayer	bit_rate += st->codec->bit_rate;
1904	12f996ed	Fabrice Bellard	}
1905			ic->bit_rate = bit_rate;
1906			}
1907
1908			/* if duration is already set, we believe it */
1909	115329f1	Diego Biurrun	if (ic->duration == AV_NOPTS_VALUE &&
1910			ic->bit_rate != 0 &&
1911	12f996ed	Fabrice Bellard	ic->file_size != 0) {
1912			filesize = ic->file_size;
1913			if (filesize > 0) {
1914			for(i = 0; i < ic->nb_streams; i++) {
1915			st = ic->streams[i];
1916	c0df9d75	Michael Niedermayer	duration= av_rescale(8filesize, st->time_base.den, ic->bit_rate(int64_t)st->time_base.num);
1917	9f32041d	Neil Brown	if (st->duration == AV_NOPTS_VALUE)
1918	12f996ed	Fabrice Bellard	st->duration = duration;
1919			}
1920			}
1921			}
1922			}
1923
1924			#define DURATION_MAX_READ_SIZE 250000
1925	411ff322	Michael Niedermayer	#define DURATION_MAX_RETRY 3
1926	12f996ed	Fabrice Bellard
1927			/* only usable for MPEG-PS streams */
1928	bc5c918e	Diego Biurrun	static void av_estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
1929	12f996ed	Fabrice Bellard	{
1930			AVPacket pkt1, *pkt = &pkt1;
1931			AVStream *st;
1932			int read_size, i, ret;
1933	3e4318bf	Aurelien Jacobs	int64_t end_time;
1934	12f996ed	Fabrice Bellard	int64_t filesize, offset, duration;
1935	411ff322	Michael Niedermayer	int retry=0;
1936	115329f1	Diego Biurrun
1937	578688fa	Luca Abeni	ic->cur_st = NULL;
1938
1939			/* flush packet queue */
1940			flush_packet_queue(ic);
1941
1942	e99179de	Aurelien Jacobs	for (i=0; i<ic->nb_streams; i++) {
1943	578688fa	Luca Abeni	st = ic->streams[i];
1944	3e4318bf	Aurelien Jacobs	if (st->start_time == AV_NOPTS_VALUE && st->first_dts == AV_NOPTS_VALUE)
1945	cc20679a	Michael Niedermayer	av_log(st->codec, AV_LOG_WARNING, "start time is not set in av_estimate_timings_from_pts\n");
1946
1947	578688fa	Luca Abeni	if (st->parser) {
1948			av_parser_close(st->parser);
1949			st->parser= NULL;
1950	3a41c2f7	Michael Niedermayer	av_free_packet(&st->cur_pkt);
1951	578688fa	Luca Abeni	}
1952			}
1953	115329f1	Diego Biurrun
1954	12f996ed	Fabrice Bellard	/* estimate the end time (duration) */
1955			/* XXX: may need to support wrapping */
1956			filesize = ic->file_size;
1957	411ff322	Michael Niedermayer	end_time = AV_NOPTS_VALUE;
1958			do{
1959			offset = filesize - (DURATION_MAX_READ_SIZE<<retry);
1960	12f996ed	Fabrice Bellard	if (offset < 0)
1961			offset = 0;
1962
1963	6b4aa5da	Anton Khirnov	avio_seek(ic->pb, offset, SEEK_SET);
1964	12f996ed	Fabrice Bellard	read_size = 0;
1965			for(;;) {
1966	411ff322	Michael Niedermayer	if (read_size >= DURATION_MAX_READ_SIZE<<(FFMAX(retry-1,0)))
1967	12f996ed	Fabrice Bellard	break;
1968	115329f1	Diego Biurrun
1969	cda6902d	Michael Niedermayer	do{
1970			ret = av_read_packet(ic, pkt);
1971			}while(ret == AVERROR(EAGAIN));
1972	12f996ed	Fabrice Bellard	if (ret != 0)
1973			break;
1974			read_size += pkt->size;
1975			st = ic->streams[pkt->stream_index];
1976	bf494092	Neil Brown	if (pkt->pts != AV_NOPTS_VALUE &&
1977	3e4318bf	Aurelien Jacobs	(st->start_time != AV_NOPTS_VALUE \|\|
1978			st->first_dts != AV_NOPTS_VALUE)) {
1979			duration = end_time = pkt->pts;
1980			if (st->start_time != AV_NOPTS_VALUE) duration -= st->start_time;
1981			else duration -= st->first_dts;
1982	d30a8beb	Michael Niedermayer	if (duration < 0)
1983			duration += 1LL<<st->pts_wrap_bits;
1984	12f996ed	Fabrice Bellard	if (duration > 0) {
1985			if (st->duration == AV_NOPTS_VALUE \|\|
1986			st->duration < duration)
1987			st->duration = duration;
1988			}
1989			}
1990			av_free_packet(pkt);
1991			}
1992	411ff322	Michael Niedermayer	}while( end_time==AV_NOPTS_VALUE
1993			&& filesize > (DURATION_MAX_READ_SIZE<<retry)
1994			&& ++retry <= DURATION_MAX_RETRY);
1995	115329f1	Diego Biurrun
1996	c0df9d75	Michael Niedermayer	fill_all_stream_timings(ic);
1997	12f996ed	Fabrice Bellard
1998	6b4aa5da	Anton Khirnov	avio_seek(ic->pb, old_offset, SEEK_SET);
1999	e99179de	Aurelien Jacobs	for (i=0; i<ic->nb_streams; i++) {
2000	df886e7e	Michael Niedermayer	st= ic->streams[i];
2001			st->cur_dts= st->first_dts;
2002	635fbcb1	Michael Niedermayer	st->last_IP_pts = AV_NOPTS_VALUE;
2003	df886e7e	Michael Niedermayer	}
2004	12f996ed	Fabrice Bellard	}
2005
2006	bc5c918e	Diego Biurrun	static void av_estimate_timings(AVFormatContext *ic, int64_t old_offset)
2007	12f996ed	Fabrice Bellard	{
2008			int64_t file_size;
2009
2010			/* get the file size, if possible */
2011			if (ic->iformat->flags & AVFMT_NOFILE) {
2012			file_size = 0;
2013			} else {
2014	76aa876e	Anton Khirnov	file_size = avio_size(ic->pb);
2015	12f996ed	Fabrice Bellard	if (file_size < 0)
2016			file_size = 0;
2017			}
2018			ic->file_size = file_size;
2019
2020	ff70e601	Måns Rullgård	if ((!strcmp(ic->iformat->name, "mpeg") \|\|
2021			!strcmp(ic->iformat->name, "mpegts")) &&
2022	8978feda	Anton Khirnov	file_size && ic->pb->seekable) {
2023	12f996ed	Fabrice Bellard	/* get accurate estimate from the PTSes */
2024	9ecf7fad	Wolfram Gloger	av_estimate_timings_from_pts(ic, old_offset);
2025	c1e8b678	Neil Brown	} else if (av_has_duration(ic)) {
2026	a85736f2	Diego Biurrun	/* at least one component has timings - we use them for all
2027	12f996ed	Fabrice Bellard	the components */
2028			fill_all_stream_timings(ic);
2029			} else {
2030	77ac76a3	Michael Niedermayer	av_log(ic, AV_LOG_WARNING, "Estimating duration from bitrate, this may be inaccurate\n");
2031	a85736f2	Diego Biurrun	/* less precise: use bitrate info */
2032	12f996ed	Fabrice Bellard	av_estimate_timings_from_bit_rate(ic);
2033			}
2034			av_update_stream_timings(ic);
2035
2036			#if 0
2037			{
2038			int i;
2039			AVStream *st;
2040			for(i = 0;i < ic->nb_streams; i++) {
2041			st = ic->streams[i];
2042	115329f1	Diego Biurrun	printf("%d: start_time: %0.3f duration: %0.3f\n",
2043			i, (double)st->start_time / AV_TIME_BASE,
2044	12f996ed	Fabrice Bellard	(double)st->duration / AV_TIME_BASE);
2045			}
2046	115329f1	Diego Biurrun	printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2047			(double)ic->start_time / AV_TIME_BASE,
2048	12f996ed	Fabrice Bellard	(double)ic->duration / AV_TIME_BASE,
2049			ic->bit_rate / 1000);
2050			}
2051			#endif
2052			}
2053
2054	b9a281db	Fabrice Bellard	static int has_codec_parameters(AVCodecContext *enc)
2055			{
2056			int val;
2057			switch(enc->codec_type) {
2058	72415b2a	Stefano Sabatini	case AVMEDIA_TYPE_AUDIO:
2059	5d6e4c16	Stefano Sabatini	val = enc->sample_rate && enc->channels && enc->sample_fmt != AV_SAMPLE_FMT_NONE;
2060	f3b5a1a2	Baptiste Coudurier	if(!enc->frame_size &&
2061			(enc->codec_id == CODEC_ID_VORBIS \|\|
2062	1d07029f	Justin Ruggles	enc->codec_id == CODEC_ID_AAC \|\|
2063	b7884740	Michael Niedermayer	enc->codec_id == CODEC_ID_MP1 \|\|
2064			enc->codec_id == CODEC_ID_MP2 \|\|
2065	8425ceca	Baptiste Coudurier	enc->codec_id == CODEC_ID_MP3 \|\|
2066	1d07029f	Justin Ruggles	enc->codec_id == CODEC_ID_SPEEX))
2067	4d35bf74	Michael Niedermayer	return 0;
2068	b9a281db	Fabrice Bellard	break;
2069	72415b2a	Stefano Sabatini	case AVMEDIA_TYPE_VIDEO:
2070	644a9262	Michael Niedermayer	val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
2071	b9a281db	Fabrice Bellard	break;
2072			default:
2073			val = 1;
2074			break;
2075			}
2076	ccd425e7	Diego Biurrun	return enc->codec_id != CODEC_ID_NONE && val != 0;
2077	b9a281db	Fabrice Bellard	}
2078
2079	ae447836	Baptiste Coudurier	static int has_decode_delay_been_guessed(AVStream *st)
2080			{
2081			return st->codec->codec_id != CODEC_ID_H264 \|\|
2082	581ba2ce	Baptiste Coudurier	st->codec_info_nb_frames >= 6 + st->codec->has_b_frames;
2083	ae447836	Baptiste Coudurier	}
2084
2085	655d47c2	Thilo Borgmann	static int try_decode_frame(AVStream st, AVPacket avpkt)
2086	fb2758c8	Fabrice Bellard	{
2087			int16_t *samples;
2088			AVCodec *codec;
2089	3fdb6af9	Baptiste Coudurier	int got_picture, data_size, ret=0;
2090	fb2758c8	Fabrice Bellard	AVFrame picture;
2091	115329f1	Diego Biurrun
2092	e472ea34	Baptiste Coudurier	if(!st->codec->codec){
2093			codec = avcodec_find_decoder(st->codec->codec_id);
2094			if (!codec)
2095			return -1;
2096			ret = avcodec_open(st->codec, codec);
2097			if (ret < 0)
2098			return ret;
2099			}
2100	644a9262	Michael Niedermayer
2101	ae447836	Baptiste Coudurier	if(!has_codec_parameters(st->codec) \|\| !has_decode_delay_been_guessed(st)){
2102	e472ea34	Baptiste Coudurier	switch(st->codec->codec_type) {
2103	72415b2a	Stefano Sabatini	case AVMEDIA_TYPE_VIDEO:
2104	1bd280f7	Baptiste Coudurier	avcodec_get_frame_defaults(&picture);
2105	e472ea34	Baptiste Coudurier	ret = avcodec_decode_video2(st->codec, &picture,
2106			&got_picture, avpkt);
2107			break;
2108	72415b2a	Stefano Sabatini	case AVMEDIA_TYPE_AUDIO:
2109	e472ea34	Baptiste Coudurier	data_size = FFMAX(avpkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
2110			samples = av_malloc(data_size);
2111			if (!samples)
2112			goto fail;
2113			ret = avcodec_decode_audio3(st->codec, samples,
2114			&data_size, avpkt);
2115			av_free(samples);
2116			break;
2117			default:
2118			break;
2119			}
2120	fb2758c8	Fabrice Bellard	}
2121			fail:
2122			return ret;
2123			}
2124
2125	83c27079	Stefano Sabatini	unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum CodecID id)
2126	45da8124	Aurelien Jacobs	{
2127			while (tags->id != CODEC_ID_NONE) {
2128			if (tags->id == id)
2129			return tags->tag;
2130			tags++;
2131			}
2132			return 0;
2133			}
2134
2135	1a40491e	Daniel Verkamp	enum CodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2136	45da8124	Aurelien Jacobs	{
2137	41415d28	Michael Niedermayer	int i;
2138			for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
2139			if(tag == tags[i].tag)
2140			return tags[i].id;
2141			}
2142			for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
2143	603a5f04	Francesco Lavra	if (ff_toupper4(tag) == ff_toupper4(tags[i].tag))
2144	41415d28	Michael Niedermayer	return tags[i].id;
2145	45da8124	Aurelien Jacobs	}
2146			return CODEC_ID_NONE;
2147			}
2148
2149	15545a09	Stefano Sabatini	unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum CodecID id)
2150	45da8124	Aurelien Jacobs	{
2151			int i;
2152			for(i=0; tags && tags[i]; i++){
2153	1a40491e	Daniel Verkamp	int tag= ff_codec_get_tag(tags[i], id);
2154	45da8124	Aurelien Jacobs	if(tag) return tag;
2155			}
2156			return 0;
2157			}
2158
2159	15545a09	Stefano Sabatini	enum CodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
2160	45da8124	Aurelien Jacobs	{
2161			int i;
2162			for(i=0; tags && tags[i]; i++){
2163	1a40491e	Daniel Verkamp	enum CodecID id= ff_codec_get_id(tags[i], tag);
2164	45da8124	Aurelien Jacobs	if(id!=CODEC_ID_NONE) return id;
2165			}
2166			return CODEC_ID_NONE;
2167			}
2168
2169	c2c3dedf	Aurelien Jacobs	static void compute_chapters_end(AVFormatContext *s)
2170			{
2171	ab11317c	Anton Khirnov	unsigned int i, j;
2172			int64_t max_time = s->duration + (s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time;
2173	c2c3dedf	Aurelien Jacobs
2174	ab11317c	Anton Khirnov	for (i = 0; i < s->nb_chapters; i++)
2175	c2c3dedf	Aurelien Jacobs	if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2176	ab11317c	Anton Khirnov	AVChapter *ch = s->chapters[i];
2177			int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q, ch->time_base)
2178			: INT64_MAX;
2179
2180			for (j = 0; j < s->nb_chapters; j++) {
2181			AVChapter *ch1 = s->chapters[j];
2182			int64_t next_start = av_rescale_q(ch1->start, ch1->time_base, ch->time_base);
2183			if (j != i && next_start > ch->start && next_start < end)
2184			end = next_start;
2185			}
2186			ch->end = (end == INT64_MAX) ? ch->start : end;
2187	c2c3dedf	Aurelien Jacobs	}
2188			}
2189
2190	4d43cbcc	Michael Niedermayer	static int get_std_framerate(int i){
2191			if(i<6012) return i1001;
2192	aecf157e	Reimar Döffinger	else return ((const int[]){24,30,60,12,15})[i-6012]1000*12;
2193	4d43cbcc	Michael Niedermayer	}
2194
2195	945208ca	Michael Niedermayer	/*
2196			* Is the time base unreliable.
2197			* This is a heuristic to balance between quick acceptance of the values in
2198			* the headers vs. some extra checks.
2199	a85736f2	Diego Biurrun	* Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2200			* MPEG-2 commonly misuses field repeat flags to store different framerates.
2201	945208ca	Michael Niedermayer	* And there are "variable" fps files this needs to detect as well.
2202			*/
2203			static int tb_unreliable(AVCodecContext *c){
2204			if( c->time_base.den >= 101L*c->time_base.num
2205			\|\| c->time_base.den < 5L*c->time_base.num
2206	2bb6eba2	Aurelien Jacobs	/* \|\| c->codec_tag == AV_RL32("DIVX")
2207			\|\| c->codec_tag == AV_RL32("XVID")*/
2208	7f123e7f	Michael Niedermayer	\|\| c->codec_id == CODEC_ID_MPEG2VIDEO
2209			\|\| c->codec_id == CODEC_ID_H264
2210			)
2211	945208ca	Michael Niedermayer	return 1;
2212			return 0;
2213			}
2214
2215	b9a281db	Fabrice Bellard	int av_find_stream_info(AVFormatContext *ic)
2216			{
2217	9f75260e	Michael Niedermayer	int i, count, ret, read_size, j;
2218	b9a281db	Fabrice Bellard	AVStream *st;
2219	fb2758c8	Fabrice Bellard	AVPacket pkt1, *pkt;
2220	a2704c97	Anton Khirnov	int64_t old_offset = avio_tell(ic->pb);
2221	0cbff027	Kristian Amlie
2222	c0df9d75	Michael Niedermayer	for(i=0;i<ic->nb_streams;i++) {
2223	62784e37	Benjamin Larsson	AVCodec *codec;
2224	c0df9d75	Michael Niedermayer	st = ic->streams[i];
2225	e7e291e9	Alex Converse	if (st->codec->codec_id == CODEC_ID_AAC) {
2226			st->codec->sample_rate = 0;
2227			st->codec->frame_size = 0;
2228			st->codec->channels = 0;
2229			}
2230	b3c0fc76	Aurelien Jacobs	if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO \|\|
2231			st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2232	c0df9d75	Michael Niedermayer	/* if(!st->time_base.num)
2233			st->time_base= */
2234	01f4895c	Michael Niedermayer	if(!st->codec->time_base.num)
2235			st->codec->time_base= st->time_base;
2236	c0df9d75	Michael Niedermayer	}
2237	90ad92b3	Michael Niedermayer	//only for the split stuff
2238	fe8344a2	Michael Niedermayer	if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
2239	01f4895c	Michael Niedermayer	st->parser = av_parser_init(st->codec->codec_id);
2240	57004ff1	Aurelien Jacobs	if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
2241	7cbaa7ba	Michael Niedermayer	st->parser->flags \|= PARSER_FLAG_COMPLETE_FRAMES;
2242			}
2243	90ad92b3	Michael Niedermayer	}
2244	43e4d57f	Michael Niedermayer	assert(!st->codec->codec);
2245	62784e37	Benjamin Larsson	codec = avcodec_find_decoder(st->codec->codec_id);
2246
2247			/* Force decoding of at least one frame of codec data
2248			* this makes sure the codec initializes the channel configuration
2249			* and does not trust the values from the container.
2250			*/
2251			if (codec && codec->capabilities & CODEC_CAP_CHANNEL_CONF)
2252			st->codec->channels = 0;
2253
2254	cb2c971d	Aurelien Jacobs	/* Ensure that subtitle_header is properly set. */
2255			if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
2256			&& codec && !st->codec->codec)
2257			avcodec_open(st->codec, codec);
2258
2259	43e4d57f	Michael Niedermayer	//try to just open decoders, in case this is enough to get parameters
2260			if(!has_codec_parameters(st->codec)){
2261	cb2c971d	Aurelien Jacobs	if (codec && !st->codec->codec)
2262	43e4d57f	Michael Niedermayer	avcodec_open(st->codec, codec);
2263			}
2264	c0df9d75	Michael Niedermayer	}
2265
2266	feb2440c	Aurelien Jacobs	for (i=0; i<ic->nb_streams; i++) {
2267	fd0368e7	Aurelien Jacobs	ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
2268	15bc38e5	Michael Niedermayer	}
2269	115329f1	Diego Biurrun
2270	b9a281db	Fabrice Bellard	count = 0;
2271			read_size = 0;
2272			for(;;) {
2273	1d14361d	Michael Niedermayer	if(url_interrupt_cb()){
2274	c76374c6	Nicolas George	ret= AVERROR_EXIT;
2275	71ee6515	Michael Niedermayer	av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2276	1d14361d	Michael Niedermayer	break;
2277			}
2278
2279	b9a281db	Fabrice Bellard	/* check if one codec still needs to be handled */
2280			for(i=0;i<ic->nb_streams;i++) {
2281			st = ic->streams[i];
2282	01f4895c	Michael Niedermayer	if (!has_codec_parameters(st->codec))
2283	b9a281db	Fabrice Bellard	break;
2284	3e76d1b5	Michael Niedermayer	/* variable fps and no guess at the real fps */
2285	0e5f33f2	Michael Niedermayer	if( tb_unreliable(st->codec) && !(st->r_frame_rate.num && st->avg_frame_rate.num)
2286	fd0368e7	Aurelien Jacobs	&& st->info->duration_count<20 && st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2287	3e76d1b5	Michael Niedermayer	break;
2288	01f4895c	Michael Niedermayer	if(st->parser && st->parser->parser->split && !st->codec->extradata)
2289	90ad92b3	Michael Niedermayer	break;
2290	82583548	Michael Niedermayer	if(st->first_dts == AV_NOPTS_VALUE)
2291			break;
2292	b9a281db	Fabrice Bellard	}
2293			if (i == ic->nb_streams) {
2294			/* NOTE: if the format has no header, then we need to read
2295			some packets to get most of the streams, so we cannot
2296			stop here */
2297	fb2758c8	Fabrice Bellard	if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2298	b9a281db	Fabrice Bellard	/* if we found the info for all the codecs, we can stop */
2299			ret = count;
2300	71ee6515	Michael Niedermayer	av_log(ic, AV_LOG_DEBUG, "All info found\n");
2301	b9a281db	Fabrice Bellard	break;
2302			}
2303	5fb83c38	Michael Niedermayer	}
2304	35eab0c0	Michael Niedermayer	/* we did not get all the codec info, but we read too much data */
2305	57011a13	Baptiste Coudurier	if (read_size >= ic->probesize) {
2306	35eab0c0	Michael Niedermayer	ret = count;
2307	9bbe9a0d	Jai Menon	av_log(ic, AV_LOG_DEBUG, "Probe buffer size limit %d reached\n", ic->probesize);
2308	35eab0c0	Michael Niedermayer	break;
2309			}
2310	b9a281db	Fabrice Bellard
2311	fb2758c8	Fabrice Bellard	/* NOTE: a new stream can be added there if no header in file
2312			(AVFMTCTX_NOHEADER) */
2313			ret = av_read_frame_internal(ic, &pkt1);
2314	feb2440c	Aurelien Jacobs	if (ret < 0 && ret != AVERROR(EAGAIN)) {
2315	fb2758c8	Fabrice Bellard	/* EOF or error */
2316			ret = -1; /* we could not have all the codec parameters before EOF */
2317	e19456e3	Michael Niedermayer	for(i=0;i<ic->nb_streams;i++) {
2318			st = ic->streams[i];
2319	305ee50f	Michael Niedermayer	if (!has_codec_parameters(st->codec)){
2320			char buf[256];
2321			avcodec_string(buf, sizeof(buf), st->codec, 0);
2322	657eca1f	Michael Niedermayer	av_log(ic, AV_LOG_WARNING, "Could not find codec parameters (%s)\n", buf);
2323	344a18c3	Måns Rullgård	} else {
2324			ret = 0;
2325	305ee50f	Michael Niedermayer	}
2326	e19456e3	Michael Niedermayer	}
2327	fb2758c8	Fabrice Bellard	break;
2328			}
2329
2330	feb2440c	Aurelien Jacobs	if (ret == AVERROR(EAGAIN))
2331			continue;
2332
2333	5c5b1731	Måns Rullgård	pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2334	fd0368e7	Aurelien Jacobs	if ((ret = av_dup_packet(pkt)) < 0)
2335			goto find_stream_info_err;
2336	b9a281db	Fabrice Bellard
2337	fb2758c8	Fabrice Bellard	read_size += pkt->size;
2338	b9a281db	Fabrice Bellard
2339			st = ic->streams[pkt->stream_index];
2340	fd0368e7	Aurelien Jacobs	if (st->codec_info_nb_frames>1) {
2341			if (st->time_base.den > 0 && av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q) >= ic->max_analyze_duration) {
2342	657eca1f	Michael Niedermayer	av_log(ic, AV_LOG_WARNING, "max_analyze_duration reached\n");
2343	3a560188	Baptiste Coudurier	break;
2344	71ee6515	Michael Niedermayer	}
2345	fd0368e7	Aurelien Jacobs	st->info->codec_info_duration += pkt->duration;
2346	3a560188	Baptiste Coudurier	}
2347	cefe0607	Michael Niedermayer	{
2348	fd0368e7	Aurelien Jacobs	int64_t last = st->info->last_dts;
2349	3c150d16	Michael Niedermayer	int64_t duration= pkt->dts - last;
2350
2351			if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
2352	4d43cbcc	Michael Niedermayer	double dur= duration * av_q2d(st->time_base);
2353
2354	72415b2a	Stefano Sabatini	// if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2355	4d43cbcc	Michael Niedermayer	// av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
2356	fd0368e7	Aurelien Jacobs	if (st->info->duration_count < 2)
2357			memset(st->info->duration_error, 0, sizeof(st->info->duration_error));
2358			for (i=1; i<FF_ARRAY_ELEMS(st->info->duration_error); i++) {
2359	69c262d1	Michael Niedermayer	int framerate= get_std_framerate(i);
2360			int ticks= lrintf(durframerate/(100112));
2361			double error= dur - ticks100112/(double)framerate;
2362	fd0368e7	Aurelien Jacobs	st->info->duration_error[i] += error*error;
2363	69c262d1	Michael Niedermayer	}
2364	fd0368e7	Aurelien Jacobs	st->info->duration_count++;
2365	85142724	Reimar Döffinger	// ignore the first 4 values, they might have some random jitter
2366	fd0368e7	Aurelien Jacobs	if (st->info->duration_count > 3)
2367			st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2368	15bc38e5	Michael Niedermayer	}
2369	fd0368e7	Aurelien Jacobs	if (last == AV_NOPTS_VALUE \|\| st->info->duration_count <= 1)
2370			st->info->last_dts = pkt->dts;
2371	15bc38e5	Michael Niedermayer	}
2372	01f4895c	Michael Niedermayer	if(st->parser && st->parser->parser->split && !st->codec->extradata){
2373			int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2374	90ad92b3	Michael Niedermayer	if(i){
2375	01f4895c	Michael Niedermayer	st->codec->extradata_size= i;
2376	62c52121	Måns Rullgård	st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2377	01f4895c	Michael Niedermayer	memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2378	62c52121	Måns Rullgård	memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2379	90ad92b3	Michael Niedermayer	}
2380			}
2381	115329f1	Diego Biurrun
2382	fb2758c8	Fabrice Bellard	/* if still no information, we try to open the codec and to
2383			decompress the frame. We try to avoid that in most cases as
2384	a85736f2	Diego Biurrun	it takes longer and uses more memory. For MPEG-4, we need to
2385			decompress for QuickTime. */
2386	ae447836	Baptiste Coudurier	if (!has_codec_parameters(st->codec) \|\| !has_decode_delay_been_guessed(st))
2387	655d47c2	Thilo Borgmann	try_decode_frame(st, pkt);
2388	115329f1	Diego Biurrun
2389	9d3fdf20	Baptiste Coudurier	st->codec_info_nb_frames++;
2390	b9a281db	Fabrice Bellard	count++;
2391			}
2392
2393	bd107136	Diego Biurrun	// close codecs which were opened in try_decode_frame()
2394	43c0040a	Michael Niedermayer	for(i=0;i<ic->nb_streams;i++) {
2395			st = ic->streams[i];
2396	01f4895c	Michael Niedermayer	if(st->codec->codec)
2397			avcodec_close(st->codec);
2398	43c0040a	Michael Niedermayer	}
2399	b9a281db	Fabrice Bellard	for(i=0;i<ic->nb_streams;i++) {
2400			st = ic->streams[i];
2401	fd0368e7	Aurelien Jacobs	if (st->codec_info_nb_frames>2 && !st->avg_frame_rate.num && st->info->codec_info_duration)
2402	02b398ef	Michael Niedermayer	av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2403	6c6e6ef5	Michael Niedermayer	(st->codec_info_nb_frames-2)*(int64_t)st->time_base.den,
2404	fd0368e7	Aurelien Jacobs	st->info->codec_info_duration*(int64_t)st->time_base.num, 60000);
2405	72415b2a	Stefano Sabatini	if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2406	dd1c8f3e	Luca Abeni	if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample)
2407	01f4895c	Michael Niedermayer	st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2408	15bc38e5	Michael Niedermayer
2409	85142724	Reimar Döffinger	// the check for tb_unreliable() is not completely correct, since this is not about handling
2410			// a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2411			// ipmovie.c produces.
2412	fd0368e7	Aurelien Jacobs	if (tb_unreliable(st->codec) && st->info->duration_count > 15 && st->info->duration_gcd > 1 && !st->r_frame_rate.num)
2413			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);
2414			if (st->info->duration_count && !st->r_frame_rate.num
2415	945208ca	Michael Niedermayer	&& tb_unreliable(st->codec) /*&&
2416	a85736f2	Diego Biurrun	//FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2417	fd0368e7	Aurelien Jacobs	st->time_base.numduration_sum[i]/st->info->duration_count101LL > st->time_base.den*/){
2418	fe02d9e7	Reimar Döffinger	int num = 0;
2419	4d43cbcc	Michael Niedermayer	double best_error= 2*av_q2d(st->time_base);
2420	fd0368e7	Aurelien Jacobs	best_error = best_errorbest_errorst->info->duration_count100012*30;
2421	4d43cbcc	Michael Niedermayer
2422	fd0368e7	Aurelien Jacobs	for (j=1; j<FF_ARRAY_ELEMS(st->info->duration_error); j++) {
2423			double error = st->info->duration_error[j] * get_std_framerate(j);
2424	72415b2a	Stefano Sabatini	// if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2425	4d43cbcc	Michael Niedermayer	// av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
2426	9f75260e	Michael Niedermayer	if(error < best_error){
2427			best_error= error;
2428	fe02d9e7	Reimar Döffinger	num = get_std_framerate(j);
2429	9f75260e	Michael Niedermayer	}
2430	3c150d16	Michael Niedermayer	}
2431	fe02d9e7	Reimar Döffinger	// do not increase frame rate by more than 1 % in order to match a standard rate.
2432			if (num && (!st->r_frame_rate.num \|\| (double)num/(121001) < 1.01 av_q2d(st->r_frame_rate)))
2433			av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2434	15bc38e5	Michael Niedermayer	}
2435
2436	c0df9d75	Michael Niedermayer	if (!st->r_frame_rate.num){
2437	5523d5f4	Michael Niedermayer	if( st->codec->time_base.den * (int64_t)st->time_base.num
2438	3797c74b	Michael Niedermayer	<= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
2439	5523d5f4	Michael Niedermayer	st->r_frame_rate.num = st->codec->time_base.den;
2440	3797c74b	Michael Niedermayer	st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
2441	5523d5f4	Michael Niedermayer	}else{
2442			st->r_frame_rate.num = st->time_base.den;
2443			st->r_frame_rate.den = st->time_base.num;
2444			}
2445	14bea432	Michael Niedermayer	}
2446	72415b2a	Stefano Sabatini	}else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2447	dd1c8f3e	Luca Abeni	if(!st->codec->bits_per_coded_sample)
2448			st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2449	c70a6a41	Justin Ruggles	// set stream disposition based on audio service type
2450			switch (st->codec->audio_service_type) {
2451			case AV_AUDIO_SERVICE_TYPE_EFFECTS:
2452			st->disposition = AV_DISPOSITION_CLEAN_EFFECTS; break;
2453			case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
2454			st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED; break;
2455			case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
2456			st->disposition = AV_DISPOSITION_HEARING_IMPAIRED; break;
2457			case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
2458			st->disposition = AV_DISPOSITION_COMMENT; break;
2459			case AV_AUDIO_SERVICE_TYPE_KARAOKE:
2460			st->disposition = AV_DISPOSITION_KARAOKE; break;
2461			}
2462	b9a281db	Fabrice Bellard	}
2463	de6d9b64	Fabrice Bellard	}
2464	b9a281db	Fabrice Bellard
2465	9ecf7fad	Wolfram Gloger	av_estimate_timings(ic, old_offset);
2466	6fea687e	John Donaghy
2467	c2c3dedf	Aurelien Jacobs	compute_chapters_end(ic);
2468
2469	e928649b	Michael Niedermayer	#if 0
2470	a85736f2	Diego Biurrun	/* correct DTS for B-frame streams with no timestamps */
2471	e928649b	Michael Niedermayer	for(i=0;i<ic->nb_streams;i++) {
2472			st = ic->streams[i];
2473	72415b2a	Stefano Sabatini	if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2474	e928649b	Michael Niedermayer	if(b-frames){
2475			ppktl = &ic->packet_buffer;
2476			while(ppkt1){
2477			if(ppkt1->stream_index != i)
2478			continue;
2479			if(ppkt1->pkt->dts < 0)
2480			break;
2481			if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2482			break;
2483			ppkt1->pkt->dts -= delta;
2484			ppkt1= ppkt1->next;
2485			}
2486			if(ppkt1)
2487			continue;
2488			st->cur_dts -= delta;
2489			}
2490			}
2491			}
2492			#endif
2493	0cbff027	Kristian Amlie
2494	fd0368e7	Aurelien Jacobs	find_stream_info_err:
2495			for (i=0; i < ic->nb_streams; i++)
2496			av_freep(&ic->streams[i]->info);
2497	b9a281db	Fabrice Bellard	return ret;
2498	de6d9b64	Fabrice Bellard	}
2499
2500	9128ae08	Nicolas George	static AVProgram find_program_from_stream(AVFormatContext ic, int s)
2501			{
2502			int i, j;
2503
2504			for (i = 0; i < ic->nb_programs; i++)
2505			for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
2506			if (ic->programs[i]->stream_index[j] == s)
2507			return ic->programs[i];
2508			return NULL;
2509			}
2510
2511			int av_find_best_stream(AVFormatContext *ic,
2512			enum AVMediaType type,
2513			int wanted_stream_nb,
2514			int related_stream,
2515			AVCodec **decoder_ret,
2516			int flags)
2517			{
2518			int i, nb_streams = ic->nb_streams, stream_number = 0;
2519			int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1;
2520			unsigned *program = NULL;
2521			AVCodec decoder = NULL, best_decoder = NULL;
2522
2523			if (related_stream >= 0 && wanted_stream_nb < 0) {
2524			AVProgram *p = find_program_from_stream(ic, related_stream);
2525			if (p) {
2526			program = p->stream_index;
2527			nb_streams = p->nb_stream_indexes;
2528			}
2529			}
2530			for (i = 0; i < nb_streams; i++) {
2531			AVStream *st = ic->streams[program ? program[i] : i];
2532			AVCodecContext *avctx = st->codec;
2533			if (avctx->codec_type != type)
2534			continue;
2535			if (wanted_stream_nb >= 0 && stream_number++ != wanted_stream_nb)
2536			continue;
2537	52091491	Peter Ross	if (st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED\|AV_DISPOSITION_VISUAL_IMPAIRED))
2538			continue;
2539	9128ae08	Nicolas George	if (decoder_ret) {
2540			decoder = avcodec_find_decoder(ic->streams[i]->codec->codec_id);
2541			if (!decoder) {
2542			if (ret < 0)
2543			ret = AVERROR_DECODER_NOT_FOUND;
2544			continue;
2545			}
2546			}
2547			if (best_count >= st->codec_info_nb_frames)
2548			continue;
2549			best_count = st->codec_info_nb_frames;
2550	22ec6b73	Balint Marton	ret = program ? program[i] : i;
2551	9128ae08	Nicolas George	best_decoder = decoder;
2552			if (program && i == nb_streams - 1 && ret < 0) {
2553			program = NULL;
2554			nb_streams = ic->nb_streams;
2555			i = 0; /* no related stream found, try again with everything */
2556			}
2557			}
2558			if (decoder_ret)
2559			*decoder_ret = best_decoder;
2560			return ret;
2561			}
2562
2563	fb2758c8	Fabrice Bellard	/*******************************************************/
2564
2565			int av_read_play(AVFormatContext *s)
2566			{
2567	fa13095a	Björn Axelsson	if (s->iformat->read_play)
2568			return s->iformat->read_play(s);
2569	fd2982a0	Aurelien Jacobs	if (s->pb)
2570	933e90a6	Anton Khirnov	return ffio_read_pause(s->pb, 0);
2571	fa13095a	Björn Axelsson	return AVERROR(ENOSYS);
2572	fb2758c8	Fabrice Bellard	}
2573
2574			int av_read_pause(AVFormatContext *s)
2575			{
2576	fa13095a	Björn Axelsson	if (s->iformat->read_pause)
2577			return s->iformat->read_pause(s);
2578	fd2982a0	Aurelien Jacobs	if (s->pb)
2579	933e90a6	Anton Khirnov	return ffio_read_pause(s->pb, 1);
2580	fa13095a	Björn Axelsson	return AVERROR(ENOSYS);
2581	fb2758c8	Fabrice Bellard	}
2582
2583	2506fd54	Reimar Döffinger	void av_close_input_stream(AVFormatContext *s)
2584	de6d9b64	Fabrice Bellard	{
2585	81bd4119	Stefano Sabatini	flush_packet_queue(s);
2586	b9a281db	Fabrice Bellard	if (s->iformat->read_close)
2587			s->iformat->read_close(s);
2588	f124b087	Martin Storsjö	avformat_free_context(s);
2589			}
2590
2591			void avformat_free_context(AVFormatContext *s)
2592			{
2593			int i;
2594			AVStream *st;
2595
2596	de6d9b64	Fabrice Bellard	for(i=0;i<s->nb_streams;i++) {
2597	da24c5e3	Fabrice Bellard	/* free all data in a stream component */
2598			st = s->streams[i];
2599	fb2758c8	Fabrice Bellard	if (st->parser) {
2600			av_parser_close(st->parser);
2601	3a41c2f7	Michael Niedermayer	av_free_packet(&st->cur_pkt);
2602	de6d9b64	Fabrice Bellard	}
2603	094d9df7	Aurelien Jacobs	av_metadata_free(&st->metadata);
2604	fb2758c8	Fabrice Bellard	av_free(st->index_entries);
2605	a5e9102b	Måns Rullgård	av_free(st->codec->extradata);
2606	cb2c971d	Aurelien Jacobs	av_free(st->codec->subtitle_header);
2607	01f4895c	Michael Niedermayer	av_free(st->codec);
2608	54036be1	Aurelien Jacobs	#if FF_API_OLD_METADATA
2609	f8d7c9d3	Evgeniy Stepanov	av_free(st->filename);
2610	827f7e28	Aurelien Jacobs	#endif
2611	ade8d8b9	Baptiste Coudurier	av_free(st->priv_data);
2612	fd0368e7	Aurelien Jacobs	av_free(st->info);
2613	fb2758c8	Fabrice Bellard	av_free(st);
2614	de6d9b64	Fabrice Bellard	}
2615	15afa396	Nico Sabbi	for(i=s->nb_programs-1; i>=0; i--) {
2616	54036be1	Aurelien Jacobs	#if FF_API_OLD_METADATA
2617	15afa396	Nico Sabbi	av_freep(&s->programs[i]->provider_name);
2618			av_freep(&s->programs[i]->name);
2619	827f7e28	Aurelien Jacobs	#endif
2620	094d9df7	Aurelien Jacobs	av_metadata_free(&s->programs[i]->metadata);
2621	526efa10	Nico Sabbi	av_freep(&s->programs[i]->stream_index);
2622	15afa396	Nico Sabbi	av_freep(&s->programs[i]);
2623			}
2624	ceedda75	Michael Niedermayer	av_freep(&s->programs);
2625	a8dbe951	Philip Gladstone	av_freep(&s->priv_data);
2626	7c8202cc	Michael Niedermayer	while(s->nb_chapters--) {
2627	54036be1	Aurelien Jacobs	#if FF_API_OLD_METADATA
2628	7c8202cc	Michael Niedermayer	av_free(s->chapters[s->nb_chapters]->title);
2629	827f7e28	Aurelien Jacobs	#endif
2630	094d9df7	Aurelien Jacobs	av_metadata_free(&s->chapters[s->nb_chapters]->metadata);
2631	7c8202cc	Michael Niedermayer	av_free(s->chapters[s->nb_chapters]);
2632	79d7836a	Anton Khirnov	}
2633			av_freep(&s->chapters);
2634	094d9df7	Aurelien Jacobs	av_metadata_free(&s->metadata);
2635	668338c5	Måns Rullgård	av_freep(&s->key);
2636	1ea4f593	Fabrice Bellard	av_free(s);
2637	de6d9b64	Fabrice Bellard	}
2638
2639	2506fd54	Reimar Döffinger	void av_close_input_file(AVFormatContext *s)
2640			{
2641	ae628ec1	Anton Khirnov	AVIOContext *pb = s->iformat->flags & AVFMT_NOFILE ? NULL : s->pb;
2642	2506fd54	Reimar Döffinger	av_close_input_stream(s);
2643			if (pb)
2644	22a3212e	Anton Khirnov	avio_close(pb);
2645	2506fd54	Reimar Döffinger	}
2646
2647	b9a281db	Fabrice Bellard	AVStream av_new_stream(AVFormatContext s, int id)
2648			{
2649			AVStream *st;
2650	504ee036	Michael Niedermayer	int i;
2651	61138c43	Aurelien Jacobs
2652			#if FF_API_MAX_STREAMS
2653			if (s->nb_streams >= MAX_STREAMS){
2654			av_log(s, AV_LOG_ERROR, "Too many streams\n");
2655			return NULL;
2656			}
2657			#else
2658	38aab35f	Aurelien Jacobs	AVStream **streams;
2659	b9a281db	Fabrice Bellard
2660	38aab35f	Aurelien Jacobs	if (s->nb_streams >= INT_MAX/sizeof(*streams))
2661			return NULL;
2662			streams = av_realloc(s->streams, (s->nb_streams + 1) * sizeof(*streams));
2663			if (!streams)
2664			return NULL;
2665			s->streams = streams;
2666			#endif
2667	b9a281db	Fabrice Bellard
2668			st = av_mallocz(sizeof(AVStream));
2669			if (!st)
2670			return NULL;
2671	fd0368e7	Aurelien Jacobs	if (!(st->info = av_mallocz(sizeof(*st->info)))) {
2672			av_free(st);
2673			return NULL;
2674			}
2675	115329f1	Diego Biurrun
2676	01f4895c	Michael Niedermayer	st->codec= avcodec_alloc_context();
2677	48091512	Fabrice Bellard	if (s->iformat) {
2678			/* no default bitrate if decoding */
2679	01f4895c	Michael Niedermayer	st->codec->bit_rate = 0;
2680	48091512	Fabrice Bellard	}
2681	b9a281db	Fabrice Bellard	st->index = s->nb_streams;
2682			st->id = id;
2683	12f996ed	Fabrice Bellard	st->start_time = AV_NOPTS_VALUE;
2684			st->duration = AV_NOPTS_VALUE;
2685	6d77d9ac	Michael Niedermayer	/* we set the current DTS to 0 so that formats without any timestamps
2686			but durations get some timestamps, formats with some unknown
2687			timestamps have their first few packets buffered and the
2688			timestamps corrected before they are returned to the user */
2689			st->cur_dts = 0;
2690	82583548	Michael Niedermayer	st->first_dts = AV_NOPTS_VALUE;
2691	86cb7e33	Baptiste Coudurier	st->probe_packets = MAX_PROBE_PACKETS;
2692	9ee91c2f	Michael Niedermayer
2693	a85736f2	Diego Biurrun	/* default pts setting is MPEG-like */
2694	9ee91c2f	Michael Niedermayer	av_set_pts_info(st, 33, 1, 90000);
2695