Do not call update_initial_durations if pkt->duration is 0.
[libav.git] / libavformat / utils.c
CommitLineData
de6d9b64 1/*
a85736f2 2 * various utility functions for use within FFmpeg
19720f15 3 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
de6d9b64 4 *
b78e7197
DB
5 * This file is part of FFmpeg.
6 *
7 * FFmpeg is free software; you can redistribute it and/or
19720f15
FB
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
b78e7197 10 * version 2.1 of the License, or (at your option) any later version.
de6d9b64 11 *
b78e7197 12 * FFmpeg is distributed in the hope that it will be useful,
de6d9b64 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19720f15
FB
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
de6d9b64 16 *
19720f15 17 * You should have received a copy of the GNU Lesser General Public
b78e7197 18 * License along with FFmpeg; if not, write to the Free Software
5509bffa 19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
de6d9b64 20 */
8be1c656 21#include "avformat.h"
4eb72c6b 22#include "opt.h"
75e61b0e 23#include "avstring.h"
45da8124 24#include "riff.h"
82e4ac2c
RP
25#include <sys/time.h>
26#include <time.h>
c5510dd6 27
b754978a
MN
28#undef NDEBUG
29#include <assert.h>
30
e36bdf8b
DK
31/**
32 * @file libavformat/utils.c
a85736f2 33 * various utility functions for use within FFmpeg
e36bdf8b
DK
34 */
35
f3a30e3a
LB
36static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den);
37static void av_frac_add(AVFrac *f, int64_t incr);
f3a30e3a 38
a85736f2 39/** head of registered input format linked list */
8b69867f 40AVInputFormat *first_iformat = NULL;
a85736f2 41/** head of registered output format linked list */
8b69867f 42AVOutputFormat *first_oformat = NULL;
de6d9b64 43
84be6e72
MN
44AVInputFormat *av_iformat_next(AVInputFormat *f)
45{
46 if(f) return f->next;
47 else return first_iformat;
48}
49
50AVOutputFormat *av_oformat_next(AVOutputFormat *f)
51{
52 if(f) return f->next;
53 else return first_oformat;
54}
55
b9a281db 56void av_register_input_format(AVInputFormat *format)
de6d9b64 57{
b9a281db
FB
58 AVInputFormat **p;
59 p = &first_iformat;
60 while (*p != NULL) p = &(*p)->next;
61 *p = format;
62 format->next = NULL;
63}
64
65void av_register_output_format(AVOutputFormat *format)
66{
67 AVOutputFormat **p;
68 p = &first_oformat;
de6d9b64
FB
69 while (*p != NULL) p = &(*p)->next;
70 *p = format;
71 format->next = NULL;
72}
73
5b25dfa7 74int match_ext(const char *filename, const char *extensions)
de6d9b64
FB
75{
76 const char *ext, *p;
77 char ext1[32], *q;
78
293ed23f
MN
79 if(!filename)
80 return 0;
115329f1 81
de6d9b64
FB
82 ext = strrchr(filename, '.');
83 if (ext) {
84 ext++;
85 p = extensions;
86 for(;;) {
87 q = ext1;
115329f1 88 while (*p != '\0' && *p != ',' && q-ext1<sizeof(ext1)-1)
de6d9b64
FB
89 *q++ = *p++;
90 *q = '\0';
115329f1 91 if (!strcasecmp(ext1, ext))
de6d9b64 92 return 1;
115329f1 93 if (*p == '\0')
de6d9b64
FB
94 break;
95 p++;
96 }
97 }
98 return 0;
99}
100
115329f1 101AVOutputFormat *guess_format(const char *short_name, const char *filename,
b9a281db 102 const char *mime_type)
de6d9b64 103{
b9a281db 104 AVOutputFormat *fmt, *fmt_found;
de6d9b64
FB
105 int score_max, score;
106
87a0a681 107 /* specific test for image sequences */
ff70e601 108#ifdef CONFIG_IMAGE2_MUXER
115329f1 109 if (!short_name && filename &&
5c07cf53 110 av_filename_number_test(filename) &&
5b6d5596
MN
111 av_guess_image2_codec(filename) != CODEC_ID_NONE) {
112 return guess_format("image2", NULL, NULL);
113 }
ff70e601 114#endif
a85736f2 115 /* Find the proper file type. */
de6d9b64
FB
116 fmt_found = NULL;
117 score_max = 0;
b9a281db 118 fmt = first_oformat;
de6d9b64
FB
119 while (fmt != NULL) {
120 score = 0;
121 if (fmt->name && short_name && !strcmp(fmt->name, short_name))
122 score += 100;
123 if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
124 score += 10;
115329f1 125 if (filename && fmt->extensions &&
de6d9b64
FB
126 match_ext(filename, fmt->extensions)) {
127 score += 5;
128 }
129 if (score > score_max) {
130 score_max = score;
131 fmt_found = fmt;
132 }
133 fmt = fmt->next;
134 }
135 return fmt_found;
115329f1 136}
de6d9b64 137
115329f1 138AVOutputFormat *guess_stream_format(const char *short_name, const char *filename,
c5510dd6
PG
139 const char *mime_type)
140{
141 AVOutputFormat *fmt = guess_format(short_name, filename, mime_type);
142
143 if (fmt) {
144 AVOutputFormat *stream_fmt;
145 char stream_format_name[64];
146
147 snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
148 stream_fmt = guess_format(stream_format_name, NULL, NULL);
149
150 if (stream_fmt)
151 fmt = stream_fmt;
152 }
153
154 return fmt;
155}
156
115329f1 157enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
5b6d5596
MN
158 const char *filename, const char *mime_type, enum CodecType type){
159 if(type == CODEC_TYPE_VIDEO){
160 enum CodecID codec_id= CODEC_ID_NONE;
161
ff70e601 162#ifdef CONFIG_IMAGE2_MUXER
ae214ac3 163 if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
5b6d5596
MN
164 codec_id= av_guess_image2_codec(filename);
165 }
ff70e601 166#endif
5b6d5596
MN
167 if(codec_id == CODEC_ID_NONE)
168 codec_id= fmt->video_codec;
169 return codec_id;
170 }else if(type == CODEC_TYPE_AUDIO)
171 return fmt->audio_codec;
172 else
173 return CODEC_ID_NONE;
174}
175
b9a281db
FB
176AVInputFormat *av_find_input_format(const char *short_name)
177{
178 AVInputFormat *fmt;
179 for(fmt = first_iformat; fmt != NULL; fmt = fmt->next) {
180 if (!strcmp(fmt->name, short_name))
181 return fmt;
182 }
183 return NULL;
184}
185
de6d9b64
FB
186/* memory handling */
187
90ad92b3 188void av_destruct_packet(AVPacket *pkt)
6fa5a56c
FB
189{
190 av_free(pkt->data);
191 pkt->data = NULL; pkt->size = 0;
192}
193
659596f0
RP
194void av_init_packet(AVPacket *pkt)
195{
196 pkt->pts = AV_NOPTS_VALUE;
197 pkt->dts = AV_NOPTS_VALUE;
198 pkt->pos = -1;
199 pkt->duration = 0;
200 pkt->flags = 0;
201 pkt->stream_index = 0;
202 pkt->destruct= av_destruct_packet_nofree;
203}
204
de6d9b64
FB
205int av_new_packet(AVPacket *pkt, int size)
206{
55bdd34d 207 uint8_t *data;
568e18b1 208 if((unsigned)size > (unsigned)size + FF_INPUT_BUFFER_PADDING_SIZE)
769e10f0 209 return AVERROR(ENOMEM);
568e18b1 210 data = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
6fa5a56c 211 if (!data)
769e10f0 212 return AVERROR(ENOMEM);
6fa5a56c 213 memset(data + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
8cd5be98 214
6fa5a56c 215 av_init_packet(pkt);
115329f1 216 pkt->data = data;
6fa5a56c
FB
217 pkt->size = size;
218 pkt->destruct = av_destruct_packet;
de6d9b64
FB
219 return 0;
220}
221
2692067a
MN
222int av_get_packet(ByteIOContext *s, AVPacket *pkt, int size)
223{
224 int ret= av_new_packet(pkt, size);
225
226 if(ret<0)
227 return ret;
228
229 pkt->pos= url_ftell(s);
230
231 ret= get_buffer(s, pkt->data, size);
232 if(ret<=0)
233 av_free_packet(pkt);
234 else
235 pkt->size= ret;
236
237 return ret;
238}
239
fb2758c8
FB
240int av_dup_packet(AVPacket *pkt)
241{
242 if (pkt->destruct != av_destruct_packet) {
243 uint8_t *data;
a85736f2 244 /* We duplicate the packet and don't forget to add the padding again. */
568e18b1 245 if((unsigned)pkt->size > (unsigned)pkt->size + FF_INPUT_BUFFER_PADDING_SIZE)
769e10f0 246 return AVERROR(ENOMEM);
8a56ac7b 247 data = av_malloc(pkt->size + FF_INPUT_BUFFER_PADDING_SIZE);
fb2758c8 248 if (!data) {
769e10f0 249 return AVERROR(ENOMEM);
fb2758c8
FB
250 }
251 memcpy(data, pkt->data, pkt->size);
8a56ac7b 252 memset(data + pkt->size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
fb2758c8
FB
253 pkt->data = data;
254 pkt->destruct = av_destruct_packet;
255 }
256 return 0;
257}
258
5c07cf53 259int av_filename_number_test(const char *filename)
b9a281db
FB
260{
261 char buf[1024];
5c07cf53 262 return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
b9a281db
FB
263}
264
79750486 265static AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
b9a281db
FB
266{
267 AVInputFormat *fmt1, *fmt;
79750486 268 int score;
b9a281db
FB
269
270 fmt = NULL;
b9a281db 271 for(fmt1 = first_iformat; fmt1 != NULL; fmt1 = fmt1->next) {
b8e705ec 272 if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
b9a281db
FB
273 continue;
274 score = 0;
a8dbe951
PG
275 if (fmt1->read_probe) {
276 score = fmt1->read_probe(pd);
277 } else if (fmt1->extensions) {
b9a281db
FB
278 if (match_ext(pd->filename, fmt1->extensions)) {
279 score = 50;
280 }
115329f1 281 }
79750486
MN
282 if (score > *score_max) {
283 *score_max = score;
b9a281db
FB
284 fmt = fmt1;
285 }
286 }
287 return fmt;
288}
289
79750486
MN
290AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
291 int score=0;
292 return av_probe_input_format2(pd, is_opened, &score);
293}
294
b9a281db
FB
295/************************************************************/
296/* input media file */
96baaa6a 297
da24c5e3 298/**
e36bdf8b 299 * Open a media file from an IO stream. 'fmt' must be specified.
da24c5e3 300 */
43465395 301static const char* format_to_name(void* ptr)
bc874dae 302{
43465395 303 AVFormatContext* fc = (AVFormatContext*) ptr;
bc874dae
MB
304 if(fc->iformat) return fc->iformat->name;
305 else if(fc->oformat) return fc->oformat->name;
306 else return "NULL";
307}
308
66acccf0 309#define OFFSET(x) offsetof(AVFormatContext,x)
755bfeab 310#define DEFAULT 0 //should be NAN but it does not work as it is not a constant in glibc as required by ANSI/ISO C
4eb72c6b
NS
311//these names are too long to be readable
312#define E AV_OPT_FLAG_ENCODING_PARAM
313#define D AV_OPT_FLAG_DECODING_PARAM
314
315static const AVOption options[]={
8c3dd5dc 316{"probesize", NULL, OFFSET(probesize), FF_OPT_TYPE_INT, 32000, 32, INT_MAX, D}, /* 32000 from mpegts.c: 1.0 second at 24Mbit/s */
09a45576 317{"muxrate", "set mux rate", OFFSET(mux_rate), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
4ff8fcef 318{"packetsize", "set packet size", OFFSET(packet_size), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
18de0b81 319{"fflags", NULL, OFFSET(flags), FF_OPT_TYPE_FLAGS, DEFAULT, INT_MIN, INT_MAX, D|E, "fflags"},
2c00106c
MN
320{"ignidx", "ignore index", 0, FF_OPT_TYPE_CONST, AVFMT_FLAG_IGNIDX, INT_MIN, INT_MAX, D, "fflags"},
321{"genpts", "generate pts", 0, FF_OPT_TYPE_CONST, AVFMT_FLAG_GENPTS, INT_MIN, INT_MAX, D, "fflags"},
8c3dd5dc 322{"track", " set the track number", OFFSET(track), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
ec1b10f4 323{"year", "set the year", OFFSET(year), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, E},
e19fbbec 324{"analyzeduration", "how many microseconds are analyzed to estimate duration", OFFSET(max_analyze_duration), FF_OPT_TYPE_INT, 3*AV_TIME_BASE, 0, INT_MAX, D},
841f39a7 325{"cryptokey", "decryption key", OFFSET(key), FF_OPT_TYPE_BINARY, 0, 0, 0, D},
ac6f1330 326{"indexmem", "max memory used for timestamp index (per stream)", OFFSET(max_index_size), FF_OPT_TYPE_INT, 1<<20, 0, INT_MAX, D},
ab8ab30c 327{"rtbufsize", "max memory used for buffering real-time frames", OFFSET(max_picture_buffer), FF_OPT_TYPE_INT, 3041280, 0, INT_MAX, D}, /* defaults to 1s of 15fps 352x288 YUYV422 video */
4eb72c6b
NS
328{NULL},
329};
330
5e89b50b
PI
331#undef E
332#undef D
333#undef DEFAULT
334
4eb72c6b
NS
335static const AVClass av_format_context_class = { "AVFormatContext", format_to_name, options };
336
702dfe01
BC
337static void avformat_get_context_defaults(AVFormatContext *s)
338{
4eb72c6b 339 memset(s, 0, sizeof(AVFormatContext));
9e6c9470 340
73a8ceaa
PI
341 s->av_class = &av_format_context_class;
342
343 av_opt_set_defaults(s);
4eb72c6b 344}
bc874dae
MB
345
346AVFormatContext *av_alloc_format_context(void)
347{
348 AVFormatContext *ic;
5894991f 349 ic = av_malloc(sizeof(AVFormatContext));
bc874dae 350 if (!ic) return ic;
4eb72c6b 351 avformat_get_context_defaults(ic);
43465395 352 ic->av_class = &av_format_context_class;
bc874dae
MB
353 return ic;
354}
355
115329f1
DB
356int av_open_input_stream(AVFormatContext **ic_ptr,
357 ByteIOContext *pb, const char *filename,
da24c5e3
FB
358 AVInputFormat *fmt, AVFormatParameters *ap)
359{
360 int err;
361 AVFormatContext *ic;
c04c3282
MN
362 AVFormatParameters default_ap;
363
364 if(!ap){
365 ap=&default_ap;
366 memset(ap, 0, sizeof(default_ap));
367 }
da24c5e3 368
4eb72c6b
NS
369 if(!ap->prealloced_context)
370 ic = av_alloc_format_context();
371 else
372 ic = *ic_ptr;
da24c5e3 373 if (!ic) {
769e10f0 374 err = AVERROR(ENOMEM);
da24c5e3
FB
375 goto fail;
376 }
377 ic->iformat = fmt;
899681cd 378 ic->pb = pb;
da24c5e3
FB
379 ic->duration = AV_NOPTS_VALUE;
380 ic->start_time = AV_NOPTS_VALUE;
75e61b0e 381 av_strlcpy(ic->filename, filename, sizeof(ic->filename));
da24c5e3
FB
382
383 /* allocate private data */
384 if (fmt->priv_data_size > 0) {
385 ic->priv_data = av_mallocz(fmt->priv_data_size);
386 if (!ic->priv_data) {
769e10f0 387 err = AVERROR(ENOMEM);
da24c5e3
FB
388 goto fail;
389 }
390 } else {
391 ic->priv_data = NULL;
392 }
393
da24c5e3
FB
394 err = ic->iformat->read_header(ic, ap);
395 if (err < 0)
396 goto fail;
fb2758c8 397
faf7cbf1 398 if (pb && !ic->data_offset)
899681cd 399 ic->data_offset = url_ftell(ic->pb);
fb2758c8 400
da24c5e3
FB
401 *ic_ptr = ic;
402 return 0;
403 fail:
404 if (ic) {
405 av_freep(&ic->priv_data);
406 }
407 av_free(ic);
408 *ic_ptr = NULL;
409 return err;
410}
411
a85736f2 412/** size of probe buffer, for guessing file type from file contents */
a877eedc 413#define PROBE_BUF_MIN 2048
329b1e75 414#define PROBE_BUF_MAX (1<<20)
b9a281db 415
115329f1 416int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
b9a281db
FB
417 AVInputFormat *fmt,
418 int buf_size,
419 AVFormatParameters *ap)
de6d9b64 420{
17acc63a 421 int err, probe_size;
b9a281db 422 AVProbeData probe_data, *pd = &probe_data;
17acc63a 423 ByteIOContext *pb = NULL;
115329f1 424
da24c5e3
FB
425 pd->filename = "";
426 if (filename)
427 pd->filename = filename;
a877eedc 428 pd->buf = NULL;
b9a281db
FB
429 pd->buf_size = 0;
430
431 if (!fmt) {
a85736f2 432 /* guess format if no file can be opened */
a25e098d 433 fmt = av_probe_input_format(pd, 0);
de6d9b64 434 }
de6d9b64 435
a85736f2 436 /* Do not open file if the format does not need it. XXX: specific
b6892136 437 hack needed to handle RTSP/TCP */
17acc63a 438 if (!fmt || !(fmt->flags & AVFMT_NOFILE)) {
87a0a681 439 /* if no file needed do not try to open one */
899681cd 440 if ((err=url_fopen(&pb, filename, URL_RDONLY)) < 0) {
96baaa6a 441 goto fail;
b9a281db 442 }
96baaa6a 443 if (buf_size > 0) {
da24c5e3 444 url_setbufsize(pb, buf_size);
96baaa6a 445 }
a877eedc
MN
446
447 for(probe_size= PROBE_BUF_MIN; probe_size<=PROBE_BUF_MAX && !fmt; probe_size<<=1){
79750486 448 int score= probe_size < PROBE_BUF_MAX ? AVPROBE_SCORE_MAX/4 : 0;
5b25dfa7 449 /* read probe data */
87e87886 450 pd->buf= av_realloc(pd->buf, probe_size + AVPROBE_PADDING_SIZE);
a877eedc 451 pd->buf_size = get_buffer(pb, pd->buf, probe_size);
9be51815 452 memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
497244a8 453 if (url_fseek(pb, 0, SEEK_SET) < 0) {
53e2f9ca 454 url_fclose(pb);
899681cd 455 if (url_fopen(&pb, filename, URL_RDONLY) < 0) {
17acc63a 456 pb = NULL;
6f3e0b21 457 err = AVERROR(EIO);
53e2f9ca
MN
458 goto fail;
459 }
460 }
a877eedc 461 /* guess file format */
79750486 462 fmt = av_probe_input_format2(pd, 1, &score);
5b25dfa7 463 }
a877eedc 464 av_freep(&pd->buf);
b9a281db
FB
465 }
466
467 /* if still no format found, error */
468 if (!fmt) {
469 err = AVERROR_NOFMT;
da24c5e3 470 goto fail;
de6d9b64 471 }
115329f1 472
a85736f2 473 /* check filename in case an image number is expected */
da24c5e3 474 if (fmt->flags & AVFMT_NEEDNUMBER) {
5c07cf53 475 if (!av_filename_number_test(filename)) {
87a0a681 476 err = AVERROR_NUMEXPECTED;
da24c5e3 477 goto fail;
87a0a681
FB
478 }
479 }
da24c5e3
FB
480 err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
481 if (err)
482 goto fail;
b9a281db 483 return 0;
de6d9b64 484 fail:
a877eedc 485 av_freep(&pd->buf);
17acc63a 486 if (pb)
da24c5e3 487 url_fclose(pb);
b9a281db
FB
488 *ic_ptr = NULL;
489 return err;
115329f1 490
de6d9b64
FB
491}
492
da24c5e3
FB
493/*******************************************************/
494
de6d9b64
FB
495int av_read_packet(AVFormatContext *s, AVPacket *pkt)
496{
62600469
MN
497 int ret;
498 AVStream *st;
b237eb80 499 av_init_packet(pkt);
62600469 500 ret= s->iformat->read_packet(s, pkt);
88b00723
RD
501 if (ret < 0)
502 return ret;
62600469
MN
503 st= s->streams[pkt->stream_index];
504
505 switch(st->codec->codec_type){
506 case CODEC_TYPE_VIDEO:
507 if(s->video_codec_id) st->codec->codec_id= s->video_codec_id;
508 break;
509 case CODEC_TYPE_AUDIO:
510 if(s->audio_codec_id) st->codec->codec_id= s->audio_codec_id;
511 break;
512 case CODEC_TYPE_SUBTITLE:
513 if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
514 break;
515 }
516
517 return ret;
fb2758c8
FB
518}
519
520/**********************************************************/
521
e36bdf8b 522/**
a85736f2 523 * Get the number of samples of an audio frame. Return -1 on error.
e36bdf8b 524 */
fb2758c8
FB
525static int get_audio_frame_size(AVCodecContext *enc, int size)
526{
527 int frame_size;
528
529 if (enc->frame_size <= 1) {
ac3e1834
BC
530 int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
531
532 if (bits_per_sample) {
fb2758c8
FB
533 if (enc->channels == 0)
534 return -1;
f1b163e0 535 frame_size = (size << 3) / (bits_per_sample * enc->channels);
ac3e1834 536 } else {
fb2758c8
FB
537 /* used for example by ADPCM codecs */
538 if (enc->bit_rate == 0)
539 return -1;
540 frame_size = (size * 8 * enc->sample_rate) / enc->bit_rate;
fb2758c8
FB
541 }
542 } else {
543 frame_size = enc->frame_size;
544 }
545 return frame_size;
546}
547
548
e36bdf8b 549/**
a85736f2 550 * Return the frame duration in seconds. Return 0 if not available.
e36bdf8b 551 */
115329f1 552static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
fb2758c8
FB
553 AVCodecParserContext *pc, AVPacket *pkt)
554{
555 int frame_size;
556
557 *pnum = 0;
558 *pden = 0;
01f4895c 559 switch(st->codec->codec_type) {
fb2758c8 560 case CODEC_TYPE_VIDEO:
1677155d 561 if(st->time_base.num*1000LL > st->time_base.den){
c0df9d75
MN
562 *pnum = st->time_base.num;
563 *pden = st->time_base.den;
01f4895c
MN
564 }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
565 *pnum = st->codec->time_base.num;
566 *pden = st->codec->time_base.den;
327c4076
MN
567 if (pc && pc->repeat_pict) {
568 *pden *= 2;
569 *pnum = (*pnum) * (2 + pc->repeat_pict);
570 }
fb2758c8
FB
571 }
572 break;
573 case CODEC_TYPE_AUDIO:
01f4895c 574 frame_size = get_audio_frame_size(st->codec, pkt->size);
fb2758c8
FB
575 if (frame_size < 0)
576 break;
577 *pnum = frame_size;
01f4895c 578 *pden = st->codec->sample_rate;
fb2758c8
FB
579 break;
580 default:
581 break;
582 }
583}
584
5ba7c3d7
MN
585static int is_intra_only(AVCodecContext *enc){
586 if(enc->codec_type == CODEC_TYPE_AUDIO){
587 return 1;
588 }else if(enc->codec_type == CODEC_TYPE_VIDEO){
589 switch(enc->codec_id){
590 case CODEC_ID_MJPEG:
591 case CODEC_ID_MJPEGB:
592 case CODEC_ID_LJPEG:
593 case CODEC_ID_RAWVIDEO:
594 case CODEC_ID_DVVIDEO:
595 case CODEC_ID_HUFFYUV:
f37b9768 596 case CODEC_ID_FFVHUFF:
5ba7c3d7
MN
597 case CODEC_ID_ASV1:
598 case CODEC_ID_ASV2:
599 case CODEC_ID_VCR1:
600 return 1;
601 default: break;
602 }
603 }
604 return 0;
605}
606
9fcbcca6
NB
607static void update_initial_timestamps(AVFormatContext *s, int stream_index,
608 int64_t dts, int64_t pts)
609{
82583548
MN
610 AVStream *st= s->streams[stream_index];
611 AVPacketList *pktl= s->packet_buffer;
612
613 if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE)
614 return;
615
616 st->first_dts= dts - st->cur_dts;
617 st->cur_dts= dts;
618
619 for(; pktl; pktl= pktl->next){
620 if(pktl->pkt.stream_index != stream_index)
621 continue;
622 //FIXME think more about this check
623 if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
624 pktl->pkt.pts += st->first_dts;
625
626 if(pktl->pkt.dts != AV_NOPTS_VALUE)
627 pktl->pkt.dts += st->first_dts;
48a59dfe
MN
628
629 if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
630 st->start_time= pktl->pkt.pts;
82583548 631 }
9fcbcca6
NB
632 if (st->start_time == AV_NOPTS_VALUE)
633 st->start_time = pts;
82583548
MN
634}
635
83a9db42
MN
636static void update_initial_durations(AVFormatContext *s, AVStream *st, AVPacket *pkt)
637{
638 AVPacketList *pktl= s->packet_buffer;
639
640 assert(pkt->duration && !st->cur_dts);
641
642 for(; pktl; pktl= pktl->next){
643 if(pktl->pkt.stream_index != pkt->stream_index)
644 continue;
91acf9a8
MN
645 if(pktl->pkt.pts == pktl->pkt.dts && pktl->pkt.dts == AV_NOPTS_VALUE
646 && !pktl->pkt.duration){
83a9db42
MN
647 pktl->pkt.pts= pktl->pkt.dts= st->cur_dts;
648 st->cur_dts += pkt->duration;
649 pktl->pkt.duration= pkt->duration;
650 }else
651 break;
652 }
653}
654
115329f1 655static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
fb2758c8
FB
656 AVCodecParserContext *pc, AVPacket *pkt)
657{
d9e1efb7 658 int num, den, presentation_delayed, delay, i;
a74008a4 659 int64_t offset;
115329f1 660
10a7571b
MN
661 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
662 /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
663 pkt->dts -= 1LL<<st->pts_wrap_bits;
664 }
665
fb2758c8 666 if (pkt->duration == 0) {
3c895fc0 667 compute_frame_duration(&num, &den, st, pc, pkt);
fb2758c8 668 if (den && num) {
77405fc8 669 pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
83a9db42 670
ee794d1e 671 if(st->cur_dts == 0 && pkt->duration != 0)
83a9db42 672 update_initial_durations(s, st, pkt);
fb2758c8
FB
673 }
674 }
675
a85736f2
DB
676 /* correct timestamps with byte offset if demuxers only have timestamps
677 on packet boundaries */
a74008a4
JP
678 if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
679 /* this will estimate bitrate based on this frame's duration and size */
680 offset = av_rescale(pc->offset, pkt->duration, pkt->size);
681 if(pkt->pts != AV_NOPTS_VALUE)
682 pkt->pts += offset;
683 if(pkt->dts != AV_NOPTS_VALUE)
684 pkt->dts += offset;
685 }
686
a85736f2 687 /* do we have a video B-frame ? */
befe3b05 688 delay= st->codec->has_b_frames;
fb2758c8 689 presentation_delayed = 0;
7e4baa66
MN
690 /* XXX: need has_b_frame, but cannot get it if the codec is
691 not initialized */
692 if (delay &&
693 pc && pc->pict_type != FF_B_TYPE)
694 presentation_delayed = 1;
755bfeab 695 /* This may be redundant, but it should not hurt. */
7e4baa66
MN
696 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
697 presentation_delayed = 1;
115329f1 698
e928649b 699 if(st->cur_dts == AV_NOPTS_VALUE){
82583548 700 st->cur_dts = 0; //FIXME maybe set it to 0 during init
e928649b 701 }
fb2758c8 702
949b1a13 703// 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);
fb2758c8 704 /* interpolate PTS and DTS if they are not present */
7e4baa66
MN
705 if(delay <=1){
706 if (presentation_delayed) {
a85736f2
DB
707 /* DTS = decompression timestamp */
708 /* PTS = presentation timestamp */
7e4baa66 709 if (pkt->dts == AV_NOPTS_VALUE)
635fbcb1 710 pkt->dts = st->last_IP_pts;
9fcbcca6 711 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
7e4baa66
MN
712 if (pkt->dts == AV_NOPTS_VALUE)
713 pkt->dts = st->cur_dts;
714
715 /* this is tricky: the dts must be incremented by the duration
a85736f2 716 of the frame we are displaying, i.e. the last I- or P-frame */
635fbcb1
MN
717 if (st->last_IP_duration == 0)
718 st->last_IP_duration = pkt->duration;
719 st->cur_dts = pkt->dts + st->last_IP_duration;
720 st->last_IP_duration = pkt->duration;
721 st->last_IP_pts= pkt->pts;
7e4baa66 722 /* cannot compute PTS if not present (we can compute it only
a85736f2 723 by knowing the future */
028d6f3e 724 } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
7e4baa66
MN
725 if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
726 int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
727 int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
728 if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
729 pkt->pts += pkt->duration;
730 // 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);
731 }
90bb394d 732 }
115329f1 733
7e4baa66
MN
734 /* presentation is not delayed : PTS and DTS are the same */
735 if(pkt->pts == AV_NOPTS_VALUE)
736 pkt->pts = pkt->dts;
9fcbcca6 737 update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
7e4baa66
MN
738 if(pkt->pts == AV_NOPTS_VALUE)
739 pkt->pts = st->cur_dts;
740 pkt->dts = pkt->pts;
741 st->cur_dts = pkt->pts + pkt->duration;
742 }
fb2758c8 743 }
d9e1efb7
MN
744
745 if(pkt->pts != AV_NOPTS_VALUE){
746 st->pts_buffer[0]= pkt->pts;
747 for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
748 st->pts_buffer[i]= (i-delay-1) * pkt->duration;
749 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
750 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
751 if(pkt->dts == AV_NOPTS_VALUE)
752 pkt->dts= st->pts_buffer[0];
82583548 753 if(delay>1){
9fcbcca6 754 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
82583548 755 }
d9e1efb7
MN
756 if(pkt->dts > st->cur_dts)
757 st->cur_dts = pkt->dts;
758 }
759
760// 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);
115329f1 761
fb2758c8 762 /* update flags */
3a1d3588
JD
763 if(is_intra_only(st->codec))
764 pkt->flags |= PKT_FLAG_KEY;
765 else if (pc) {
fb2758c8 766 pkt->flags = 0;
a85736f2 767 /* keyframe computation */
fb2758c8
FB
768 if (pc->pict_type == FF_I_TYPE)
769 pkt->flags |= PKT_FLAG_KEY;
fb2758c8 770 }
fb2758c8
FB
771}
772
63dd1377 773void av_destruct_packet_nofree(AVPacket *pkt)
fb2758c8
FB
774{
775 pkt->data = NULL; pkt->size = 0;
776}
777
778static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
779{
780 AVStream *st;
37353960 781 int len, ret, i;
fb2758c8 782
b237eb80
MN
783 av_init_packet(pkt);
784
fb2758c8
FB
785 for(;;) {
786 /* select current input stream component */
787 st = s->cur_st;
788 if (st) {
90ad92b3 789 if (!st->need_parsing || !st->parser) {
fb2758c8
FB
790 /* no parsing needed: we just output the packet as is */
791 /* raw data support */
792 *pkt = s->cur_pkt;
793 compute_pkt_fields(s, st, NULL, pkt);
794 s->cur_st = NULL;
434cab9e 795 break;
f3356e9c 796 } else if (s->cur_len > 0 && st->discard < AVDISCARD_ALL) {
115329f1 797 len = av_parser_parse(st->parser, st->codec, &pkt->data, &pkt->size,
6ec87caa
FB
798 s->cur_ptr, s->cur_len,
799 s->cur_pkt.pts, s->cur_pkt.dts);
800 s->cur_pkt.pts = AV_NOPTS_VALUE;
801 s->cur_pkt.dts = AV_NOPTS_VALUE;
fb2758c8
FB
802 /* increment read pointer */
803 s->cur_ptr += len;
804 s->cur_len -= len;
115329f1 805
fb2758c8
FB
806 /* return packet if any */
807 if (pkt->size) {
37353960 808 got_packet:
711737af 809 pkt->pos = s->cur_pkt.pos; // Isn't quite accurate but close.
fb2758c8
FB
810 pkt->duration = 0;
811 pkt->stream_index = st->index;
6ec87caa
FB
812 pkt->pts = st->parser->pts;
813 pkt->dts = st->parser->dts;
fb2758c8
FB
814 pkt->destruct = av_destruct_packet_nofree;
815 compute_pkt_fields(s, st, st->parser, pkt);
e9b78eeb
MN
816
817 if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & PKT_FLAG_KEY){
3dea63bd 818 ff_reduce_index(s, st->index);
e9b78eeb
MN
819 av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
820 0, 0, AVINDEX_KEYFRAME);
821 }
822
434cab9e 823 break;
fb2758c8
FB
824 }
825 } else {
bcbecff1 826 /* free packet */
115329f1 827 av_free_packet(&s->cur_pkt);
fb2758c8
FB
828 s->cur_st = NULL;
829 }
830 } else {
fb2758c8
FB
831 /* read next packet */
832 ret = av_read_packet(s, &s->cur_pkt);
37353960 833 if (ret < 0) {
8fa36ae0 834 if (ret == AVERROR(EAGAIN))
37353960
FB
835 return ret;
836 /* return the last frames, if any */
837 for(i = 0; i < s->nb_streams; i++) {
838 st = s->streams[i];
90ad92b3 839 if (st->parser && st->need_parsing) {
115329f1
DB
840 av_parser_parse(st->parser, st->codec,
841 &pkt->data, &pkt->size,
842 NULL, 0,
6ec87caa 843 AV_NOPTS_VALUE, AV_NOPTS_VALUE);
37353960
FB
844 if (pkt->size)
845 goto got_packet;
846 }
847 }
a85736f2 848 /* no more packets: really terminate parsing */
fb2758c8 849 return ret;
37353960 850 }
115329f1 851
9ee91c2f 852 st = s->streams[s->cur_pkt.stream_index];
434cab9e 853 if(st->codec->debug & FF_DEBUG_PTS)
ccd3228e 854 av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
434cab9e
MN
855 s->cur_pkt.stream_index,
856 s->cur_pkt.pts,
857 s->cur_pkt.dts,
858 s->cur_pkt.size);
fb2758c8 859
fb2758c8
FB
860 s->cur_st = st;
861 s->cur_ptr = s->cur_pkt.data;
862 s->cur_len = s->cur_pkt.size;
863 if (st->need_parsing && !st->parser) {
01f4895c 864 st->parser = av_parser_init(st->codec->codec_id);
fb2758c8 865 if (!st->parser) {
a85736f2 866 /* no parser available: just output the raw packets */
57004ff1
AJ
867 st->need_parsing = AVSTREAM_PARSE_NONE;
868 }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
7cbaa7ba 869 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
fb2758c8 870 }
e9b78eeb
MN
871 if(st->parser && (s->iformat->flags & AVFMT_GENERIC_INDEX)){
872 st->parser->last_frame_offset=
873 st->parser->cur_offset= s->cur_pkt.pos;
874 }
fb2758c8
FB
875 }
876 }
877 }
434cab9e 878 if(st->codec->debug & FF_DEBUG_PTS)
ccd3228e 879 av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
434cab9e
MN
880 pkt->stream_index,
881 pkt->pts,
882 pkt->dts,
883 pkt->size);
884
885 return 0;
fb2758c8
FB
886}
887
02b15cc8
MN
888static AVPacket *add_to_pktbuf(AVFormatContext *s, AVPacket *pkt){
889 AVPacketList *pktl= s->packet_buffer;
890 AVPacketList **plast_pktl= &s->packet_buffer;
891
892 while(*plast_pktl) plast_pktl= &(*plast_pktl)->next; //FIXME maybe maintain pointer to the last?
893
894 pktl = av_mallocz(sizeof(AVPacketList));
895 if (!pktl)
896 return NULL;
897
898 /* add the packet in the buffered packet list */
899 *plast_pktl = pktl;
900 pktl->pkt= *pkt;
901 return &pktl->pkt;
902}
903
fb2758c8
FB
904int av_read_frame(AVFormatContext *s, AVPacket *pkt)
905{
de6d9b64 906 AVPacketList *pktl;
30bc6613
MN
907 int eof=0;
908 const int genpts= s->flags & AVFMT_FLAG_GENPTS;
909
910 for(;;){
911 pktl = s->packet_buffer;
912 if (pktl) {
913 AVPacket *next_pkt= &pktl->pkt;
30bc6613
MN
914
915 if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
916 while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
115329f1 917 if( pktl->pkt.stream_index == next_pkt->stream_index
30bc6613
MN
918 && next_pkt->dts < pktl->pkt.dts
919 && pktl->pkt.pts != pktl->pkt.dts //not b frame
920 /*&& pktl->pkt.dts != AV_NOPTS_VALUE*/){
921 next_pkt->pts= pktl->pkt.dts;
922 }
923 pktl= pktl->next;
924 }
925 pktl = s->packet_buffer;
926 }
115329f1
DB
927
928 if( next_pkt->pts != AV_NOPTS_VALUE
929 || next_pkt->dts == AV_NOPTS_VALUE
30bc6613
MN
930 || !genpts || eof){
931 /* read packet from packet buffer, if there is data */
932 *pkt = *next_pkt;
933 s->packet_buffer = pktl->next;
934 av_free(pktl);
935 return 0;
936 }
937 }
938 if(genpts){
30bc6613
MN
939 int ret= av_read_frame_internal(s, pkt);
940 if(ret<0){
8fa36ae0 941 if(pktl && ret != AVERROR(EAGAIN)){
30bc6613
MN
942 eof=1;
943 continue;
944 }else
945 return ret;
946 }
115329f1 947
02b15cc8 948 if(av_dup_packet(add_to_pktbuf(s, pkt)) < 0)
769e10f0 949 return AVERROR(ENOMEM);
30bc6613
MN
950 }else{
951 assert(!s->packet_buffer);
952 return av_read_frame_internal(s, pkt);
953 }
fb2758c8
FB
954 }
955}
956
957/* XXX: suppress the packet queue */
958static void flush_packet_queue(AVFormatContext *s)
959{
960 AVPacketList *pktl;
961
962 for(;;) {
963 pktl = s->packet_buffer;
115329f1 964 if (!pktl)
fb2758c8
FB
965 break;
966 s->packet_buffer = pktl->next;
967 av_free_packet(&pktl->pkt);
968 av_free(pktl);
b9a281db
FB
969 }
970}
971
da24c5e3 972/*******************************************************/
fb2758c8
FB
973/* seek support */
974
b754978a
MN
975int av_find_default_stream_index(AVFormatContext *s)
976{
977 int i;
978 AVStream *st;
979
980 if (s->nb_streams <= 0)
981 return -1;
982 for(i = 0; i < s->nb_streams; i++) {
983 st = s->streams[i];
01f4895c 984 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
b754978a
MN
985 return i;
986 }
987 }
988 return 0;
989}
990
e36bdf8b
DK
991/**
992 * Flush the frame reader.
993 */
fb2758c8
FB
994static void av_read_frame_flush(AVFormatContext *s)
995{
996 AVStream *st;
997 int i;
998
999 flush_packet_queue(s);
1000
1001 /* free previous packet */
1002 if (s->cur_st) {
1003 if (s->cur_st->parser)
1004 av_free_packet(&s->cur_pkt);
1005 s->cur_st = NULL;
1006 }
1007 /* fail safe */
1008 s->cur_ptr = NULL;
1009 s->cur_len = 0;
115329f1 1010
fb2758c8
FB
1011 /* for each stream, reset read state */
1012 for(i = 0; i < s->nb_streams; i++) {
1013 st = s->streams[i];
115329f1 1014
fb2758c8
FB
1015 if (st->parser) {
1016 av_parser_close(st->parser);
1017 st->parser = NULL;
1018 }
635fbcb1 1019 st->last_IP_pts = AV_NOPTS_VALUE;
a843d1ff 1020 st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
fb2758c8
FB
1021 }
1022}
1023
22ffac70 1024void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
8bcb147f
MN
1025 int i;
1026
1027 for(i = 0; i < s->nb_streams; i++) {
1a1dc611 1028 AVStream *st = s->streams[i];
8bcb147f 1029
115329f1 1030 st->cur_dts = av_rescale(timestamp,
1a1dc611
NK
1031 st->time_base.den * (int64_t)ref_st->time_base.num,
1032 st->time_base.num * (int64_t)ref_st->time_base.den);
8bcb147f
MN
1033 }
1034}
1035
3dea63bd
PK
1036void ff_reduce_index(AVFormatContext *s, int stream_index)
1037{
1038 AVStream *st= s->streams[stream_index];
1039 unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1040
1041 if((unsigned)st->nb_index_entries >= max_entries){
1042 int i;
1043 for(i=0; 2*i<st->nb_index_entries; i++)
1044 st->index_entries[i]= st->index_entries[2*i];
1045 st->nb_index_entries= i;
1046 }
1047}
1048
3e9245a9 1049int av_add_index_entry(AVStream *st,
30a43f2d 1050 int64_t pos, int64_t timestamp, int size, int distance, int flags)
fb2758c8
FB
1051{
1052 AVIndexEntry *entries, *ie;
b754978a 1053 int index;
115329f1 1054
568e18b1
MN
1055 if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1056 return -1;
115329f1 1057
fb2758c8
FB
1058 entries = av_fast_realloc(st->index_entries,
1059 &st->index_entries_allocated_size,
115329f1 1060 (st->nb_index_entries + 1) *
fb2758c8 1061 sizeof(AVIndexEntry));
568e18b1
MN
1062 if(!entries)
1063 return -1;
1064
b754978a
MN
1065 st->index_entries= entries;
1066
27a5fe5f 1067 index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
b754978a 1068
3ba1438d 1069 if(index<0){
3e9245a9
MN
1070 index= st->nb_index_entries++;
1071 ie= &entries[index];
3ba1438d
MN
1072 assert(index==0 || ie[-1].timestamp < timestamp);
1073 }else{
1074 ie= &entries[index];
1075 if(ie->timestamp != timestamp){
528c2c73
MN
1076 if(ie->timestamp <= timestamp)
1077 return -1;
3ba1438d
MN
1078 memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
1079 st->nb_index_entries++;
755bfeab 1080 }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
3ba1438d 1081 distance= ie->min_distance;
3e9245a9 1082 }
3ba1438d 1083
b754978a
MN
1084 ie->pos = pos;
1085 ie->timestamp = timestamp;
3e9245a9 1086 ie->min_distance= distance;
30a43f2d 1087 ie->size= size;
b754978a 1088 ie->flags = flags;
115329f1 1089
3e9245a9 1090 return index;
fb2758c8
FB
1091}
1092
dc56fc38 1093int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
27a5fe5f 1094 int flags)
fb2758c8 1095{
b754978a
MN
1096 AVIndexEntry *entries= st->index_entries;
1097 int nb_entries= st->nb_index_entries;
fb2758c8
FB
1098 int a, b, m;
1099 int64_t timestamp;
1100
3ba1438d
MN
1101 a = - 1;
1102 b = nb_entries;
b754978a 1103
3ba1438d
MN
1104 while (b - a > 1) {
1105 m = (a + b) >> 1;
fb2758c8 1106 timestamp = entries[m].timestamp;
3ba1438d
MN
1107 if(timestamp >= wanted_timestamp)
1108 b = m;
1109 if(timestamp <= wanted_timestamp)
b754978a 1110 a = m;
fb2758c8 1111 }
27a5fe5f 1112 m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
115329f1 1113
27a5fe5f
MN
1114 if(!(flags & AVSEEK_FLAG_ANY)){
1115 while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1116 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1117 }
1118 }
3ba1438d 1119
115329f1 1120 if(m == nb_entries)
3ba1438d
MN
1121 return -1;
1122 return m;
fb2758c8
FB
1123}
1124
0f652a8e 1125#define DEBUG_SEEK
8d14a25c 1126
3ba1438d 1127int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
8d14a25c
MN
1128 AVInputFormat *avif= s->iformat;
1129 int64_t pos_min, pos_max, pos, pos_limit;
1130 int64_t ts_min, ts_max, ts;
89ddd2a9 1131 int index;
8d14a25c
MN
1132 AVStream *st;
1133
cdd5034f
MN
1134 if (stream_index < 0)
1135 return -1;
115329f1 1136
8d14a25c 1137#ifdef DEBUG_SEEK
4733abcb 1138 av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
8d14a25c
MN
1139#endif
1140
1141 ts_max=
1142 ts_min= AV_NOPTS_VALUE;
90b5b51e 1143 pos_limit= -1; //gcc falsely says it may be uninitialized
8d14a25c
MN
1144
1145 st= s->streams[stream_index];
1146 if(st->index_entries){
1147 AVIndexEntry *e;
1148
a85736f2 1149 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()
3ba1438d 1150 index= FFMAX(index, 0);
8d14a25c
MN
1151 e= &st->index_entries[index];
1152
1153 if(e->timestamp <= target_ts || e->pos == e->min_distance){
1154 pos_min= e->pos;
1155 ts_min= e->timestamp;
1156#ifdef DEBUG_SEEK
115329f1 1157 av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
8d14a25c
MN
1158 pos_min,ts_min);
1159#endif
1160 }else{
1161 assert(index==0);
1162 }
115329f1
DB
1163
1164 index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
27a5fe5f
MN
1165 assert(index < st->nb_index_entries);
1166 if(index >= 0){
8d14a25c
MN
1167 e= &st->index_entries[index];
1168 assert(e->timestamp >= target_ts);
1169 pos_max= e->pos;
1170 ts_max= e->timestamp;
1171 pos_limit= pos_max - e->min_distance;
1172#ifdef DEBUG_SEEK
115329f1 1173 av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
8d14a25c
MN
1174 pos_max,pos_limit, ts_max);
1175#endif
1176 }
1177 }
1178
89ddd2a9
MN
1179 pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1180 if(pos<0)
1181 return -1;
1182
1183 /* do the seek */
899681cd 1184 url_fseek(s->pb, pos, SEEK_SET);
89ddd2a9
MN
1185
1186 av_update_cur_dts(s, st, ts);
1187
1188 return 0;
1189}
1190
89ddd2a9
MN
1191int64_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 )){
1192 int64_t pos, ts;
1193 int64_t start_pos, filesize;
1194 int no_change;
1195
1196#ifdef DEBUG_SEEK
1197 av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1198#endif
1199
8d14a25c
MN
1200 if(ts_min == AV_NOPTS_VALUE){
1201 pos_min = s->data_offset;
89ddd2a9 1202 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
8d14a25c
MN
1203 if (ts_min == AV_NOPTS_VALUE)
1204 return -1;
1205 }
1206
1207 if(ts_max == AV_NOPTS_VALUE){
1208 int step= 1024;
899681cd 1209 filesize = url_fsize(s->pb);
6fd93ce2 1210 pos_max = filesize - 1;
8d14a25c
MN
1211 do{
1212 pos_max -= step;
89ddd2a9 1213 ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
8d14a25c
MN
1214 step += step;
1215 }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1216 if (ts_max == AV_NOPTS_VALUE)
1217 return -1;
115329f1 1218
8d14a25c
MN
1219 for(;;){
1220 int64_t tmp_pos= pos_max + 1;
89ddd2a9 1221 int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
8d14a25c
MN
1222 if(tmp_ts == AV_NOPTS_VALUE)
1223 break;
1224 ts_max= tmp_ts;
1225 pos_max= tmp_pos;
6fd93ce2
KA
1226 if(tmp_pos >= filesize)
1227 break;
8d14a25c
MN
1228 }
1229 pos_limit= pos_max;
1230 }
1231
53f7c43f
MN
1232 if(ts_min > ts_max){
1233 return -1;
1234 }else if(ts_min == ts_max){
1235 pos_limit= pos_min;
1236 }
1237
8d14a25c
MN
1238 no_change=0;
1239 while (pos_min < pos_limit) {
1240#ifdef DEBUG_SEEK
115329f1 1241 av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
8d14a25c
MN
1242 pos_min, pos_max,
1243 ts_min, ts_max);
1244#endif
1245 assert(pos_limit <= pos_max);
1246
1247 if(no_change==0){
1248 int64_t approximate_keyframe_distance= pos_max - pos_limit;
1249 // interpolate position (better than dichotomy)
3ba1438d
MN
1250 pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1251 + pos_min - approximate_keyframe_distance;
8d14a25c
MN
1252 }else if(no_change==1){
1253 // bisection, if interpolation failed to change min or max pos last time
1254 pos = (pos_min + pos_limit)>>1;
1255 }else{
a85736f2
DB
1256 /* linear search if bisection failed, can only happen if there
1257 are very few or no keyframes between min/max */
8d14a25c
MN
1258 pos=pos_min;
1259 }
1260 if(pos <= pos_min)
1261 pos= pos_min + 1;
1262 else if(pos > pos_limit)
1263 pos= pos_limit;
1264 start_pos= pos;
1265
89ddd2a9 1266 ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
8d14a25c
MN
1267 if(pos == pos_max)
1268 no_change++;
1269 else
1270 no_change=0;
1271#ifdef DEBUG_SEEK
4733abcb 1272av_log(s, AV_LOG_DEBUG, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64" target:%"PRId64" limit:%"PRId64" start:%"PRId64" noc:%d\n", pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts, pos_limit, start_pos, no_change);
8d14a25c 1273#endif
db2a0e22
MN
1274 if(ts == AV_NOPTS_VALUE){
1275 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1276 return -1;
1277 }
8d14a25c 1278 assert(ts != AV_NOPTS_VALUE);
3ba1438d 1279 if (target_ts <= ts) {
8d14a25c
MN
1280 pos_limit = start_pos - 1;
1281 pos_max = pos;
1282 ts_max = ts;
3ba1438d
MN
1283 }
1284 if (target_ts >= ts) {
8d14a25c
MN
1285 pos_min = pos;
1286 ts_min = ts;
8d14a25c
MN
1287 }
1288 }
115329f1 1289
3ba1438d
MN
1290 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1291 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
8d14a25c
MN
1292#ifdef DEBUG_SEEK
1293 pos_min = pos;
89ddd2a9 1294 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
8d14a25c 1295 pos_min++;
89ddd2a9 1296 ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
115329f1 1297 av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
8d14a25c
MN
1298 pos, ts_min, target_ts, ts_max);
1299#endif
89ddd2a9
MN
1300 *ts_ret= ts;
1301 return pos;
8d14a25c
MN
1302}
1303
3ba1438d 1304static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
3ba1438d
MN
1305 int64_t pos_min, pos_max;
1306#if 0
1307 AVStream *st;
1308
1309 if (stream_index < 0)
1310 return -1;
1311
1312 st= s->streams[stream_index];
1313#endif
1314
1315 pos_min = s->data_offset;
899681cd 1316 pos_max = url_fsize(s->pb) - 1;
3ba1438d
MN
1317
1318 if (pos < pos_min) pos= pos_min;
1319 else if(pos > pos_max) pos= pos_max;
1320
899681cd 1321 url_fseek(s->pb, pos, SEEK_SET);
3ba1438d
MN
1322
1323#if 0
8bcb147f 1324 av_update_cur_dts(s, st, ts);
3ba1438d
MN
1325#endif
1326 return 0;
1327}
1328
115329f1 1329static int av_seek_frame_generic(AVFormatContext *s,
3ba1438d 1330 int stream_index, int64_t timestamp, int flags)
fb2758c8 1331{
8bcb147f 1332 int index;
fb2758c8
FB
1333 AVStream *st;
1334 AVIndexEntry *ie;
1335
fb2758c8 1336 st = s->streams[stream_index];
e9b78eeb 1337
27a5fe5f 1338 index = av_index_search_timestamp(st, timestamp, flags);
e9b78eeb 1339
b5a3541d 1340 if(index < 0 || index==st->nb_index_entries-1){
e9b78eeb
MN
1341 int i;
1342 AVPacket pkt;
1343
1344 if(st->index_entries && st->nb_index_entries){
1345 ie= &st->index_entries[st->nb_index_entries-1];
899681cd 1346 url_fseek(s->pb, ie->pos, SEEK_SET);
e9b78eeb
MN
1347 av_update_cur_dts(s, st, ie->timestamp);
1348 }else
899681cd 1349 url_fseek(s->pb, 0, SEEK_SET);
e9b78eeb
MN
1350
1351 for(i=0;; i++) {
1352 int ret = av_read_frame(s, &pkt);
1353 if(ret<0)
1354 break;
1355 av_free_packet(&pkt);
1356 if(stream_index == pkt.stream_index){
1357 if((pkt.flags & PKT_FLAG_KEY) && pkt.dts > timestamp)
1358 break;
1359 }
1360 }
1361 index = av_index_search_timestamp(st, timestamp, flags);
1362 }
fb2758c8
FB
1363 if (index < 0)
1364 return -1;
1365
fb2758c8 1366 av_read_frame_flush(s);
e9b78eeb
MN
1367 if (s->iformat->read_seek){
1368 if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1369 return 0;
1370 }
1371 ie = &st->index_entries[index];
899681cd 1372 url_fseek(s->pb, ie->pos, SEEK_SET);
3ba1438d 1373
8bcb147f 1374 av_update_cur_dts(s, st, ie->timestamp);
cdd5034f 1375
fb2758c8
FB
1376 return 0;
1377}
1378
3ba1438d 1379int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
fb2758c8
FB
1380{
1381 int ret;
cdd5034f 1382 AVStream *st;
115329f1 1383
fb2758c8 1384 av_read_frame_flush(s);
115329f1 1385
3ba1438d
MN
1386 if(flags & AVSEEK_FLAG_BYTE)
1387 return av_seek_frame_byte(s, stream_index, timestamp, flags);
115329f1 1388
cdd5034f
MN
1389 if(stream_index < 0){
1390 stream_index= av_find_default_stream_index(s);
1391 if(stream_index < 0)
1392 return -1;
115329f1 1393
3ba1438d 1394 st= s->streams[stream_index];
eb497825 1395 /* timestamp for default must be expressed in AV_TIME_BASE units */
3ba1438d 1396 timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
cdd5034f
MN
1397 }
1398 st= s->streams[stream_index];
1399
fb2758c8
FB
1400 /* first, we try the format specific seek */
1401 if (s->iformat->read_seek)
3ba1438d 1402 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
fb2758c8
FB
1403 else
1404 ret = -1;
1405 if (ret >= 0) {
1406 return 0;
1407 }
8d14a25c
MN
1408
1409 if(s->iformat->read_timestamp)
3ba1438d 1410 return av_seek_frame_binary(s, stream_index, timestamp, flags);
8d14a25c 1411 else
3ba1438d 1412 return av_seek_frame_generic(s, stream_index, timestamp, flags);
fb2758c8
FB
1413}
1414
1415/*******************************************************/
12f996ed 1416
e36bdf8b 1417/**
c1e8b678 1418 * Returns TRUE if the stream has accurate duration in any stream.
e36bdf8b 1419 *
c1e8b678 1420 * @return TRUE if the stream has accurate duration for at least one component.
e36bdf8b 1421 */
c1e8b678 1422static int av_has_duration(AVFormatContext *ic)
12f996ed
FB
1423{
1424 int i;
1425 AVStream *st;
1426
1427 for(i = 0;i < ic->nb_streams; i++) {
1428 st = ic->streams[i];
c1e8b678 1429 if (st->duration != AV_NOPTS_VALUE)
12f996ed
FB
1430 return 1;
1431 }
1432 return 0;
1433}
1434
e36bdf8b
DK
1435/**
1436 * Estimate the stream timings from the one of each components.
1437 *
1438 * Also computes the global bitrate if possible.
1439 */
12f996ed
FB
1440static void av_update_stream_timings(AVFormatContext *ic)
1441{
c0df9d75 1442 int64_t start_time, start_time1, end_time, end_time1;
c1e8b678 1443 int64_t duration, duration1;
12f996ed
FB
1444 int i;
1445 AVStream *st;
1446
f27a7268
MR
1447 start_time = INT64_MAX;
1448 end_time = INT64_MIN;
c1e8b678 1449 duration = INT64_MIN;
12f996ed
FB
1450 for(i = 0;i < ic->nb_streams; i++) {
1451 st = ic->streams[i];
7f938dd3 1452 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
c0df9d75
MN
1453 start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1454 if (start_time1 < start_time)
1455 start_time = start_time1;
12f996ed 1456 if (st->duration != AV_NOPTS_VALUE) {
c0df9d75
MN
1457 end_time1 = start_time1
1458 + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
12f996ed
FB
1459 if (end_time1 > end_time)
1460 end_time = end_time1;
1461 }
1462 }
c1e8b678
NB
1463 if (st->duration != AV_NOPTS_VALUE) {
1464 duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1465 if (duration1 > duration)
1466 duration = duration1;
1467 }
12f996ed 1468 }
f27a7268 1469 if (start_time != INT64_MAX) {
12f996ed 1470 ic->start_time = start_time;
f27a7268 1471 if (end_time != INT64_MIN) {
c1e8b678
NB
1472 if (end_time - start_time > duration)
1473 duration = end_time - start_time;
1474 }
1475 }
1476 if (duration != INT64_MIN) {
1477 ic->duration = duration;
1478 if (ic->file_size > 0) {
a85736f2 1479 /* compute the bitrate */
c1e8b678
NB
1480 ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1481 (double)ic->duration;
12f996ed
FB
1482 }
1483 }
12f996ed
FB
1484}
1485
1486static void fill_all_stream_timings(AVFormatContext *ic)
1487{
1488 int i;
1489 AVStream *st;
1490
1491 av_update_stream_timings(ic);
1492 for(i = 0;i < ic->nb_streams; i++) {
1493 st = ic->streams[i];
1494 if (st->start_time == AV_NOPTS_VALUE) {
c0df9d75
MN
1495 if(ic->start_time != AV_NOPTS_VALUE)
1496 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1497 if(ic->duration != AV_NOPTS_VALUE)
1498 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
12f996ed
FB
1499 }
1500 }
1501}
1502
1503static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1504{
1505 int64_t filesize, duration;
1506 int bit_rate, i;
1507 AVStream *st;
1508
1509 /* if bit_rate is already set, we believe it */
1510 if (ic->bit_rate == 0) {
1511 bit_rate = 0;
1512 for(i=0;i<ic->nb_streams;i++) {
1513 st = ic->streams[i];
01f4895c 1514 bit_rate += st->codec->bit_rate;
12f996ed
FB
1515 }
1516 ic->bit_rate = bit_rate;
1517 }
1518
1519 /* if duration is already set, we believe it */
115329f1
DB
1520 if (ic->duration == AV_NOPTS_VALUE &&
1521 ic->bit_rate != 0 &&
12f996ed
FB
1522 ic->file_size != 0) {
1523 filesize = ic->file_size;
1524 if (filesize > 0) {
12f996ed
FB
1525 for(i = 0; i < ic->nb_streams; i++) {
1526 st = ic->streams[i];
c0df9d75 1527 duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
9f32041d 1528 if (st->duration == AV_NOPTS_VALUE)
12f996ed 1529 st->duration = duration;
12f996ed
FB
1530 }
1531 }
1532 }
1533}
1534
12f996ed
FB
1535#define DURATION_MAX_READ_SIZE 250000
1536
1537/* only usable for MPEG-PS streams */
9ecf7fad 1538static void av_estimate_timings_from_pts(AVFormatContext *ic, offset_t old_offset)
12f996ed
FB
1539{
1540 AVPacket pkt1, *pkt = &pkt1;
1541 AVStream *st;
1542 int read_size, i, ret;
bf4e3bd2 1543 int64_t end_time;
12f996ed 1544 int64_t filesize, offset, duration;
115329f1 1545
578688fa
LA
1546 /* free previous packet */
1547 if (ic->cur_st && ic->cur_st->parser)
1548 av_free_packet(&ic->cur_pkt);
1549 ic->cur_st = NULL;
1550
1551 /* flush packet queue */
1552 flush_packet_queue(ic);
1553
1554 for(i=0;i<ic->nb_streams;i++) {
1555 st = ic->streams[i];
1556 if (st->parser) {
1557 av_parser_close(st->parser);
1558 st->parser= NULL;
1559 }
1560 }
115329f1 1561
12f996ed
FB
1562 /* we read the first packets to get the first PTS (not fully
1563 accurate, but it is enough now) */
899681cd 1564 url_fseek(ic->pb, 0, SEEK_SET);
12f996ed
FB
1565 read_size = 0;
1566 for(;;) {
1567 if (read_size >= DURATION_MAX_READ_SIZE)
1568 break;
1569 /* if all info is available, we can stop */
1570 for(i = 0;i < ic->nb_streams; i++) {
1571 st = ic->streams[i];
1572 if (st->start_time == AV_NOPTS_VALUE)
1573 break;
1574 }
1575 if (i == ic->nb_streams)
1576 break;
1577
1578 ret = av_read_packet(ic, pkt);
1579 if (ret != 0)
1580 break;
1581 read_size += pkt->size;
1582 st = ic->streams[pkt->stream_index];
1583 if (pkt->pts != AV_NOPTS_VALUE) {
1584 if (st->start_time == AV_NOPTS_VALUE)
c0df9d75 1585 st->start_time = pkt->pts;
0a5f92a1
MN
1586 }
1587 av_free_packet(pkt);
1588 }
12f996ed 1589
12f996ed
FB
1590 /* estimate the end time (duration) */
1591 /* XXX: may need to support wrapping */
1592 filesize = ic->file_size;
1593 offset = filesize - DURATION_MAX_READ_SIZE;
1594 if (offset < 0)
1595 offset = 0;
1596
899681cd 1597 url_fseek(ic->pb, offset, SEEK_SET);
12f996ed
FB
1598 read_size = 0;
1599 for(;;) {
1600 if (read_size >= DURATION_MAX_READ_SIZE)
1601 break;
115329f1 1602
12f996ed
FB
1603 ret = av_read_packet(ic, pkt);
1604 if (ret != 0)
1605 break;
1606 read_size += pkt->size;
1607 st = ic->streams[pkt->stream_index];
bf494092
NB
1608 if (pkt->pts != AV_NOPTS_VALUE &&
1609 st->start_time != AV_NOPTS_VALUE) {
c0df9d75 1610 end_time = pkt->pts;
12f996ed
FB
1611 duration = end_time - st->start_time;
1612 if (duration > 0) {
1613 if (st->duration == AV_NOPTS_VALUE ||
1614 st->duration < duration)
1615 st->duration = duration;
1616 }
1617 }
1618 av_free_packet(pkt);
1619 }
115329f1 1620
c0df9d75 1621 fill_all_stream_timings(ic);
12f996ed 1622
899681cd 1623 url_fseek(ic->pb, old_offset, SEEK_SET);
df886e7e
MN
1624 for(i=0; i<ic->nb_streams; i++){
1625 st= ic->streams[i];
1626 st->cur_dts= st->first_dts;
635fbcb1 1627 st->last_IP_pts = AV_NOPTS_VALUE;
df886e7e 1628 }
12f996ed
FB
1629}
1630
9ecf7fad 1631static void av_estimate_timings(AVFormatContext *ic, offset_t old_offset)
12f996ed 1632{
12f996ed
FB
1633 int64_t file_size;
1634
1635 /* get the file size, if possible */
1636 if (ic->iformat->flags & AVFMT_NOFILE) {
1637 file_size = 0;
1638 } else {
899681cd 1639 file_size = url_fsize(ic->pb);
12f996ed
FB
1640 if (file_size < 0)
1641 file_size = 0;
1642 }
1643 ic->file_size = file_size;
1644
ff70e601
MR
1645 if ((!strcmp(ic->iformat->name, "mpeg") ||
1646 !strcmp(ic->iformat->name, "mpegts")) &&
ceeacce6 1647 file_size && !url_is_streamed(ic->pb)) {
12f996ed 1648 /* get accurate estimate from the PTSes */
9ecf7fad 1649 av_estimate_timings_from_pts(ic, old_offset);
c1e8b678 1650 } else if (av_has_duration(ic)) {
a85736f2 1651 /* at least one component has timings - we use them for all
12f996ed
FB
1652 the components */
1653 fill_all_stream_timings(ic);
1654 } else {
a85736f2 1655 /* less precise: use bitrate info */
12f996ed
FB
1656 av_estimate_timings_from_bit_rate(ic);
1657 }
1658 av_update_stream_timings(ic);
1659
1660#if 0
1661 {
1662 int i;
1663 AVStream *st;
1664 for(i = 0;i < ic->nb_streams; i++) {
1665 st = ic->streams[i];
115329f1
DB
1666 printf("%d: start_time: %0.3f duration: %0.3f\n",
1667 i, (double)st->start_time / AV_TIME_BASE,
12f996ed
FB
1668 (double)st->duration / AV_TIME_BASE);
1669 }
115329f1
DB
1670 printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1671 (double)ic->start_time / AV_TIME_BASE,
12f996ed
FB
1672 (double)ic->duration / AV_TIME_BASE,
1673 ic->bit_rate / 1000);
1674 }
1675#endif
1676}
1677
b9a281db
FB
1678static int has_codec_parameters(AVCodecContext *enc)
1679{
1680 int val;
1681 switch(enc->codec_type) {
1682 case CODEC_TYPE_AUDIO:
1683 val = enc->sample_rate;
1684 break;
1685 case CODEC_TYPE_VIDEO:
644a9262 1686 val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
b9a281db
FB
1687 break;
1688 default:
1689 val = 1;
1690 break;
1691 }
3303926c 1692 return (enc->codec_id != CODEC_ID_NONE && val != 0);
b9a281db
FB
1693}
1694
fb2758c8
FB
1695static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1696{
1697 int16_t *samples;
1698 AVCodec *codec;
3fdb6af9 1699 int got_picture, data_size, ret=0;
fb2758c8 1700 AVFrame picture;
115329f1 1701
01f4895c
MN
1702 if(!st->codec->codec){
1703 codec = avcodec_find_decoder(st->codec->codec_id);
fb2758c8
FB
1704 if (!codec)
1705 return -1;
01f4895c 1706 ret = avcodec_open(st->codec, codec);
fb2758c8
FB
1707 if (ret < 0)
1708 return ret;
43c0040a 1709 }
644a9262 1710
01f4895c
MN
1711 if(!has_codec_parameters(st->codec)){
1712 switch(st->codec->codec_type) {
fb2758c8 1713 case CODEC_TYPE_VIDEO:
115329f1 1714 ret = avcodec_decode_video(st->codec, &picture,
dc296223 1715 &got_picture, data, size);
fb2758c8
FB
1716 break;
1717 case CODEC_TYPE_AUDIO:
3fdb6af9
BC
1718 data_size = FFMAX(size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
1719 samples = av_malloc(data_size);
fb2758c8
FB
1720 if (!samples)
1721 goto fail;
3fdb6af9 1722 ret = avcodec_decode_audio2(st->codec, samples,
dc296223 1723 &data_size, data, size);
fb2758c8
FB
1724 av_free(samples);
1725 break;
1726 default:
1727 break;
1728 }
644a9262 1729 }
fb2758c8 1730 fail:
fb2758c8
FB
1731 return ret;
1732}
1733
6fea687e
JD
1734static int set_codec_from_probe_data(AVStream *st, AVProbeData *pd, int score)
1735{
1736 AVInputFormat *fmt;
1737 fmt = av_probe_input_format2(pd, 1, &score);
1738
1739 if (fmt) {
1740 if (strncmp(fmt->name, "mp3", 3) == 0)
1741 st->codec->codec_id = CODEC_ID_MP3;
1742 else if (strncmp(fmt->name, "ac3", 3) == 0)
1743 st->codec->codec_id = CODEC_ID_AC3;
1744 }
efd5fc53 1745 return !!fmt;
6fea687e
JD
1746}
1747
45da8124
AJ
1748unsigned int codec_get_tag(const AVCodecTag *tags, int id)
1749{
1750 while (tags->id != CODEC_ID_NONE) {
1751 if (tags->id == id)
1752 return tags->tag;
1753 tags++;
1754 }
1755 return 0;
1756}
1757
1758enum CodecID codec_get_id(const AVCodecTag *tags, unsigned int tag)
1759{
41415d28
MN
1760 int i;
1761 for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
1762 if(tag == tags[i].tag)
1763 return tags[i].id;
1764 }
1765 for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
1766 if( toupper((tag >> 0)&0xFF) == toupper((tags[i].tag >> 0)&0xFF)
1767 && toupper((tag >> 8)&0xFF) == toupper((tags[i].tag >> 8)&0xFF)
1768 && toupper((tag >>16)&0xFF) == toupper((tags[i].tag >>16)&0xFF)
1769 && toupper((tag >>24)&0xFF) == toupper((tags[i].tag >>24)&0xFF))
1770 return tags[i].id;
45da8124
AJ
1771 }
1772 return CODEC_ID_NONE;
1773}
1774
1775unsigned int av_codec_get_tag(const AVCodecTag *tags[4], enum CodecID id)
1776{
1777 int i;
1778 for(i=0; tags && tags[i]; i++){
1779 int tag= codec_get_tag(tags[i], id);
1780 if(tag) return tag;
1781 }
1782 return 0;
1783}
1784
1785enum CodecID av_codec_get_id(const AVCodecTag *tags[4], unsigned int tag)
1786{
1787 int i;
1788 for(i=0; tags && tags[i]; i++){
1789 enum CodecID id= codec_get_id(tags[i], tag);
1790 if(id!=CODEC_ID_NONE) return id;
1791 }
1792 return CODEC_ID_NONE;
1793}
1794
fb2758c8
FB
1795/* absolute maximum size we read until we abort */
1796#define MAX_READ_SIZE 5000000
1797
fd97f6a2 1798#define MAX_STD_TIMEBASES (60*12+5)
4d43cbcc
MN
1799static int get_std_framerate(int i){
1800 if(i<60*12) return i*1001;
fd97f6a2 1801 else return ((int[]){24,30,60,12,15})[i-60*12]*1000*12;
4d43cbcc
MN
1802}
1803
945208ca
MN
1804/*
1805 * Is the time base unreliable.
1806 * This is a heuristic to balance between quick acceptance of the values in
1807 * the headers vs. some extra checks.
a85736f2
DB
1808 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
1809 * MPEG-2 commonly misuses field repeat flags to store different framerates.
945208ca
MN
1810 * And there are "variable" fps files this needs to detect as well.
1811 */
1812static int tb_unreliable(AVCodecContext *c){
1813 if( c->time_base.den >= 101L*c->time_base.num
1814 || c->time_base.den < 5L*c->time_base.num
1815/* || c->codec_tag == ff_get_fourcc("DIVX")
1816 || c->codec_tag == ff_get_fourcc("XVID")*/
1817 || c->codec_id == CODEC_ID_MPEG2VIDEO)
1818 return 1;
1819 return 0;
1820}
1821
b9a281db
FB
1822int av_find_stream_info(AVFormatContext *ic)
1823{
9f75260e 1824 int i, count, ret, read_size, j;
b9a281db 1825 AVStream *st;
fb2758c8 1826 AVPacket pkt1, *pkt;
15bc38e5 1827 int64_t last_dts[MAX_STREAMS];
3c150d16 1828 int duration_count[MAX_STREAMS]={0};
0cbff027 1829 double (*duration_error)[MAX_STD_TIMEBASES];
899681cd 1830 offset_t old_offset = url_ftell(ic->pb);
ea486ab3
BC
1831 int64_t codec_info_duration[MAX_STREAMS]={0};
1832 int codec_info_nb_frames[MAX_STREAMS]={0};
6fea687e
JD
1833 AVProbeData probe_data[MAX_STREAMS];
1834 int codec_identified[MAX_STREAMS]={0};
b9a281db 1835
0cbff027 1836 duration_error = av_mallocz(MAX_STREAMS * sizeof(*duration_error));
769e10f0 1837 if (!duration_error) return AVERROR(ENOMEM);
0cbff027 1838
c0df9d75
MN
1839 for(i=0;i<ic->nb_streams;i++) {
1840 st = ic->streams[i];
01f4895c 1841 if(st->codec->codec_type == CODEC_TYPE_VIDEO){
c0df9d75
MN
1842/* if(!st->time_base.num)
1843 st->time_base= */
01f4895c
MN
1844 if(!st->codec->time_base.num)
1845 st->codec->time_base= st->time_base;
c0df9d75 1846 }
90ad92b3
MN
1847 //only for the split stuff
1848 if (!st->parser) {
01f4895c 1849 st->parser = av_parser_init(st->codec->codec_id);
57004ff1 1850 if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
7cbaa7ba
MN
1851 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1852 }
90ad92b3 1853 }
c0df9d75
MN
1854 }
1855
15bc38e5
MN
1856 for(i=0;i<MAX_STREAMS;i++){
1857 last_dts[i]= AV_NOPTS_VALUE;
15bc38e5 1858 }
115329f1 1859
6fea687e 1860 memset(probe_data, 0, sizeof(probe_data));
b9a281db
FB
1861 count = 0;
1862 read_size = 0;
b9a281db
FB
1863 for(;;) {
1864 /* check if one codec still needs to be handled */
1865 for(i=0;i<ic->nb_streams;i++) {
1866 st = ic->streams[i];
01f4895c 1867 if (!has_codec_parameters(st->codec))
b9a281db 1868 break;
3e76d1b5 1869 /* variable fps and no guess at the real fps */
945208ca 1870 if( tb_unreliable(st->codec)
01f4895c 1871 && duration_count[i]<20 && st->codec->codec_type == CODEC_TYPE_VIDEO)
3e76d1b5 1872 break;
01f4895c 1873 if(st->parser && st->parser->parser->split && !st->codec->extradata)
90ad92b3 1874 break;
82583548
MN
1875 if(st->first_dts == AV_NOPTS_VALUE)
1876 break;
b9a281db
FB
1877 }
1878 if (i == ic->nb_streams) {
1879 /* NOTE: if the format has no header, then we need to read
1880 some packets to get most of the streams, so we cannot
1881 stop here */
fb2758c8 1882 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
b9a281db
FB
1883 /* if we found the info for all the codecs, we can stop */
1884 ret = count;
1885 break;
1886 }
5fb83c38 1887 }
35eab0c0
MN
1888 /* we did not get all the codec info, but we read too much data */
1889 if (read_size >= MAX_READ_SIZE) {
1890 ret = count;
1891 break;
1892 }
b9a281db 1893
fb2758c8
FB
1894 /* NOTE: a new stream can be added there if no header in file
1895 (AVFMTCTX_NOHEADER) */
1896 ret = av_read_frame_internal(ic, &pkt1);
1897 if (ret < 0) {
1898 /* EOF or error */
1899 ret = -1; /* we could not have all the codec parameters before EOF */
e19456e3
MN
1900 for(i=0;i<ic->nb_streams;i++) {
1901 st = ic->streams[i];
305ee50f
MN
1902 if (!has_codec_parameters(st->codec)){
1903 char buf[256];
1904 avcodec_string(buf, sizeof(buf), st->codec, 0);
1905 av_log(ic, AV_LOG_INFO, "Could not find codec parameters (%s)\n", buf);
344a18c3
MR
1906 } else {
1907 ret = 0;
305ee50f 1908 }
e19456e3 1909 }
fb2758c8
FB
1910 break;
1911 }
1912
02b15cc8
MN
1913 pkt= add_to_pktbuf(ic, &pkt1);
1914 if(av_dup_packet(pkt) < 0)
1915 return AVERROR(ENOMEM);
b9a281db 1916
fb2758c8 1917 read_size += pkt->size;
b9a281db
FB
1918
1919 st = ic->streams[pkt->stream_index];
ea486ab3
BC
1920 if(codec_info_nb_frames[st->index]>1)
1921 codec_info_duration[st->index] += pkt->duration;
fb2758c8 1922 if (pkt->duration != 0)
ea486ab3 1923 codec_info_nb_frames[st->index]++;
fb2758c8 1924
cefe0607 1925 {
3c150d16
MN
1926 int index= pkt->stream_index;
1927 int64_t last= last_dts[index];
1928 int64_t duration= pkt->dts - last;
1929
1930 if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
4d43cbcc
MN
1931 double dur= duration * av_q2d(st->time_base);
1932
1933// if(st->codec->codec_type == CODEC_TYPE_VIDEO)
1934// av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
1694118b 1935 if(duration_count[index] < 2)
4c7981ba 1936 memset(duration_error[index], 0, sizeof(*duration_error));
69c262d1
MN
1937 for(i=1; i<MAX_STD_TIMEBASES; i++){
1938 int framerate= get_std_framerate(i);
1939 int ticks= lrintf(dur*framerate/(1001*12));
1940 double error= dur - ticks*1001*12/(double)framerate;
1941 duration_error[index][i] += error*error;
1942 }
4d43cbcc 1943 duration_count[index]++;
15bc38e5 1944 }
fd97f6a2
MN
1945 if(last == AV_NOPTS_VALUE || duration_count[index]<=1)
1946 last_dts[pkt->stream_index]= pkt->dts;
6fea687e
JD
1947
1948 if (st->codec->codec_id == CODEC_ID_NONE) {
1949 AVProbeData *pd = &(probe_data[st->index]);
9be51815 1950 pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
6fea687e
JD
1951 memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
1952 pd->buf_size += pkt->size;
9be51815 1953 memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
6fea687e 1954 }
15bc38e5 1955 }
01f4895c
MN
1956 if(st->parser && st->parser->parser->split && !st->codec->extradata){
1957 int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
90ad92b3 1958 if(i){
01f4895c 1959 st->codec->extradata_size= i;
62c52121 1960 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
01f4895c 1961 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
62c52121 1962 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
90ad92b3
MN
1963 }
1964 }
115329f1 1965
fb2758c8
FB
1966 /* if still no information, we try to open the codec and to
1967 decompress the frame. We try to avoid that in most cases as
a85736f2
DB
1968 it takes longer and uses more memory. For MPEG-4, we need to
1969 decompress for QuickTime. */
01f4895c
MN
1970 if (!has_codec_parameters(st->codec) /*&&
1971 (st->codec->codec_id == CODEC_ID_FLV1 ||
1972 st->codec->codec_id == CODEC_ID_H264 ||
1973 st->codec->codec_id == CODEC_ID_H263 ||
1974 st->codec->codec_id == CODEC_ID_H261 ||
1975 st->codec->codec_id == CODEC_ID_VORBIS ||
1976 st->codec->codec_id == CODEC_ID_MJPEG ||
1977 st->codec->codec_id == CODEC_ID_PNG ||
1978 st->codec->codec_id == CODEC_ID_PAM ||
1979 st->codec->codec_id == CODEC_ID_PGM ||
1980 st->codec->codec_id == CODEC_ID_PGMYUV ||
1981 st->codec->codec_id == CODEC_ID_PBM ||
1982 st->codec->codec_id == CODEC_ID_PPM ||
1983 st->codec->codec_id == CODEC_ID_SHORTEN ||
1984 (st->codec->codec_id == CODEC_ID_MPEG4 && !st->need_parsing))*/)
fb2758c8 1985 try_decode_frame(st, pkt->data, pkt->size);
115329f1 1986
b3fc0925 1987 if (st->time_base.den > 0 && av_rescale_q(codec_info_duration[st->index], st->time_base, AV_TIME_BASE_Q) >= ic->max_analyze_duration) {
fb2758c8 1988 break;
b9a281db
FB
1989 }
1990 count++;
1991 }
1992
bd107136 1993 // close codecs which were opened in try_decode_frame()
43c0040a
MN
1994 for(i=0;i<ic->nb_streams;i++) {
1995 st = ic->streams[i];
01f4895c
MN
1996 if(st->codec->codec)
1997 avcodec_close(st->codec);
43c0040a 1998 }
b9a281db
FB
1999 for(i=0;i<ic->nb_streams;i++) {
2000 st = ic->streams[i];
01f4895c
MN
2001 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2002 if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_sample)
2003 st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
15bc38e5 2004
1694118b 2005 if(duration_count[i]
945208ca 2006 && tb_unreliable(st->codec) /*&&
a85736f2 2007 //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
4d43cbcc
MN
2008 st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den*/){
2009 double best_error= 2*av_q2d(st->time_base);
2010 best_error= best_error*best_error*duration_count[i]*1000*12*30;
2011
2012 for(j=1; j<MAX_STD_TIMEBASES; j++){
2013 double error= duration_error[i][j] * get_std_framerate(j);
2014// if(st->codec->codec_type == CODEC_TYPE_VIDEO)
2015// av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
9f75260e
MN
2016 if(error < best_error){
2017 best_error= error;
4d43cbcc 2018 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, get_std_framerate(j), 12*1001, INT_MAX);
9f75260e 2019 }
3c150d16 2020 }
15bc38e5
MN
2021 }
2022
c0df9d75 2023 if (!st->r_frame_rate.num){
5523d5f4
MN
2024 if( st->codec->time_base.den * (int64_t)st->time_base.num
2025 <= st->codec->time_base.num * (int64_t)st->time_base.den){
2026 st->r_frame_rate.num = st->codec->time_base.den;
2027 st->r_frame_rate.den = st->codec->time_base.num;
2028 }else{
2029 st->r_frame_rate.num = st->time_base.den;
2030 st->r_frame_rate.den = st->time_base.num;
2031 }
14bea432 2032 }
a185f52a 2033 }else if(st->codec->codec_type == CODEC_TYPE_AUDIO) {
19ecf882 2034 if (st->codec->codec_id == CODEC_ID_NONE && probe_data[st->index].buf_size > 0) {
e0c850a8 2035 codec_identified[st->index] = set_codec_from_probe_data(st, &(probe_data[st->index]), 1);
6fea687e 2036 if (codec_identified[st->index]) {
57004ff1 2037 st->need_parsing = AVSTREAM_PARSE_FULL;
6fea687e
JD
2038 }
2039 }
a185f52a
MN
2040 if(!st->codec->bits_per_sample)
2041 st->codec->bits_per_sample= av_get_bits_per_sample(st->codec->codec_id);
b9a281db 2042 }
de6d9b64 2043 }
b9a281db 2044
9ecf7fad 2045 av_estimate_timings(ic, old_offset);
6fea687e
JD
2046
2047 for(i=0;i<ic->nb_streams;i++) {
2048 st = ic->streams[i];
c7385375
MN
2049 if (codec_identified[st->index])
2050 break;
2051 }
2052 //FIXME this is a mess
2053 if(i!=ic->nb_streams){
2054 av_read_frame_flush(ic);
2055 for(i=0;i<ic->nb_streams;i++) {
2056 st = ic->streams[i];
2057 if (codec_identified[st->index]) {
2058 av_seek_frame(ic, st->index, 0.0, 0);
2059 }
2060 st->cur_dts= st->first_dts;
6fea687e 2061 }
899681cd 2062 url_fseek(ic->pb, ic->data_offset, SEEK_SET);
6fea687e
JD
2063 }
2064
e928649b 2065#if 0
a85736f2 2066 /* correct DTS for B-frame streams with no timestamps */
e928649b
MN
2067 for(i=0;i<ic->nb_streams;i++) {
2068 st = ic->streams[i];
01f4895c 2069 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
e928649b
MN
2070 if(b-frames){
2071 ppktl = &ic->packet_buffer;
2072 while(ppkt1){
2073 if(ppkt1->stream_index != i)
2074 continue;
2075 if(ppkt1->pkt->dts < 0)
2076 break;
2077 if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2078 break;
2079 ppkt1->pkt->dts -= delta;
2080 ppkt1= ppkt1->next;
2081 }
2082 if(ppkt1)
2083 continue;
2084 st->cur_dts -= delta;
2085 }
2086 }
2087 }
2088#endif
0cbff027
KA
2089
2090 av_free(duration_error);
6fea687e
JD
2091 for(i=0;i<MAX_STREAMS;i++){
2092 av_freep(&(probe_data[i].buf));
2093 }
0cbff027 2094
b9a281db 2095 return ret;
de6d9b64
FB
2096}
2097
fb2758c8
FB
2098/*******************************************************/
2099
fb2758c8
FB
2100int av_read_play(AVFormatContext *s)
2101{
fa13095a
BA
2102 if (s->iformat->read_play)
2103 return s->iformat->read_play(s);
fd2982a0 2104 if (s->pb)
502bdf68 2105 return av_url_read_fpause(s->pb, 0);
fa13095a 2106 return AVERROR(ENOSYS);
fb2758c8
FB
2107}
2108
fb2758c8
FB
2109int av_read_pause(AVFormatContext *s)
2110{
fa13095a
BA
2111 if (s->iformat->read_pause)
2112 return s->iformat->read_pause(s);
fd2982a0 2113 if (s->pb)
502bdf68 2114 return av_url_read_fpause(s->pb, 1);
fa13095a 2115 return AVERROR(ENOSYS);
fb2758c8
FB
2116}
2117
2506fd54 2118void av_close_input_stream(AVFormatContext *s)
de6d9b64 2119{
ca75a923 2120 int i;
da24c5e3 2121 AVStream *st;
de6d9b64 2122
fb2758c8
FB
2123 /* free previous packet */
2124 if (s->cur_st && s->cur_st->parser)
115329f1 2125 av_free_packet(&s->cur_pkt);
fb2758c8 2126
b9a281db
FB
2127 if (s->iformat->read_close)
2128 s->iformat->read_close(s);
de6d9b64 2129 for(i=0;i<s->nb_streams;i++) {
da24c5e3
FB
2130 /* free all data in a stream component */
2131 st = s->streams[i];
fb2758c8
FB
2132 if (st->parser) {
2133 av_parser_close(st->parser);
de6d9b64 2134 }
fb2758c8 2135 av_free(st->index_entries);
a5e9102b 2136 av_free(st->codec->extradata);
01f4895c 2137 av_free(st->codec);
f8d7c9d3 2138 av_free(st->filename);
fb2758c8 2139 av_free(st);
de6d9b64 2140 }
15afa396
NS
2141 for(i=s->nb_programs-1; i>=0; i--) {
2142 av_freep(&s->programs[i]->provider_name);
2143 av_freep(&s->programs[i]->name);
526efa10 2144 av_freep(&s->programs[i]->stream_index);
15afa396
NS
2145 av_freep(&s->programs[i]);
2146 }
fb2758c8 2147 flush_packet_queue(s);
a8dbe951 2148 av_freep(&s->priv_data);
1ea4f593 2149 av_free(s);
de6d9b64
FB
2150}
2151
2506fd54
RD
2152void av_close_input_file(AVFormatContext *s)
2153{
2154 ByteIOContext *pb = s->iformat->flags & AVFMT_NOFILE ? NULL : s->pb;
2155 av_close_input_stream(s);
2156 if (pb)
2157 url_fclose(pb);
2158}
2159
b9a281db
FB
2160AVStream *av_new_stream(AVFormatContext *s, int id)
2161{
2162 AVStream *st;
504ee036 2163 int i;
b9a281db
FB
2164
2165 if (s->nb_streams >= MAX_STREAMS)
2166 return NULL;
2167
2168 st = av_mallocz(sizeof(AVStream));
2169 if (!st)
2170 return NULL;
115329f1 2171
01f4895c 2172 st->codec= avcodec_alloc_context();
48091512
FB
2173 if (s->iformat) {
2174 /* no default bitrate if decoding */
01f4895c 2175 st->codec->bit_rate = 0;
48091512 2176 }
b9a281db
FB
2177 st->index = s->nb_streams;
2178 st->id = id;
12f996ed
FB
2179 st->start_time = AV_NOPTS_VALUE;
2180 st->duration = AV_NOPTS_VALUE;
e928649b 2181 st->cur_dts = AV_NOPTS_VALUE;
82583548 2182 st->first_dts = AV_NOPTS_VALUE;
9ee91c2f 2183
a85736f2 2184 /* default pts setting is MPEG-like */
9ee91c2f 2185 av_set_pts_info(st, 33, 1, 90000);
635fbcb1 2186 st->last_IP_pts = AV_NOPTS_VALUE;
504ee036
MN
2187 for(i=0; i<MAX_REORDER_DELAY+1; i++)
2188 st->pts_buffer[i]= AV_NOPTS_VALUE;
9ee91c2f 2189
b9a281db
FB
2190 s->streams[s->nb_streams++] = st;
2191 return st;
2192}
2193
15afa396
NS
2194AVProgram *av_new_program(AVFormatContext *ac, int id)
2195{
2196 AVProgram *program=NULL;
2197 int i;
2198
2199#ifdef DEBUG_SI
2200 av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2201#endif
2202
2203 for(i=0; i<ac->nb_programs; i++)
2204 if(ac->programs[i]->id == id)
2205 program = ac->programs[i];
2206
2207 if(!program){
2208 program = av_mallocz(sizeof(AVProgram));
2209 if (!program)
2210 return NULL;
2211 dynarray_add(&ac->programs, &ac->nb_programs, program);
2212 program->discard = AVDISCARD_NONE;
2213 }
2214 program->id = id;
2215
2216 return program;
2217}
2218
2219void av_set_program_name(AVProgram *program, char *provider_name, char *name)
2220{
2221 assert(!provider_name == !name);
2222 if(name){
2223 av_free(program->provider_name);
2224 av_free(program-> name);
2225 program->provider_name = av_strdup(provider_name);
2226 program-> name = av_strdup( name);
2227 }
2228}
2229
2230
b9a281db
FB
2231/************************************************************/
2232/* output media file */
de6d9b64 2233
87a0a681
FB
2234int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2235{
2236 int ret;
115329f1 2237
98486a6b
RS
2238 if (s->oformat->priv_data_size > 0) {
2239 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2240 if (!s->priv_data)
769e10f0 2241 return AVERROR(ENOMEM);
98486a6b
RS
2242 } else
2243 s->priv_data = NULL;
115329f1 2244
87a0a681
FB
2245 if (s->oformat->set_parameters) {
2246 ret = s->oformat->set_parameters(s, ap);
2247 if (ret < 0)
2248 return ret;
2249 }
2250 return 0;
2251}
2252
b9a281db
FB
2253int av_write_header(AVFormatContext *s)
2254{
1e51d801
FB
2255 int ret, i;
2256 AVStream *st;
2257
9450118b
MN
2258 // some sanity checks
2259 for(i=0;i<s->nb_streams;i++) {
2260 st = s->streams[i];
2261
2262 switch (st->codec->codec_type) {
2263 case CODEC_TYPE_AUDIO:
2264 if(st->codec->sample_rate<=0){
2265 av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2266 return -1;
2267 }
2268 break;
2269 case CODEC_TYPE_VIDEO:
2270 if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2271 av_log(s, AV_LOG_ERROR, "time base not set\n");
2272 return -1;
2273 }
2274 if(st->codec->width<=0 || st->codec->height<=0){
2275 av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2276 return -1;
2277 }
2278 break;
2279 }
5ecfa9f5
MN
2280
2281 if(s->oformat->codec_tag){
2282 if(st->codec->codec_tag){
2283 //FIXME
2284 //check that tag + id is in the table
a85736f2 2285 //if neither is in the table -> OK
5ecfa9f5
MN
2286 //if tag is in the table with another id -> FAIL
2287 //if id is in the table with another tag -> FAIL unless strict < ?
2288 }else
2289 st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2290 }
9450118b
MN
2291 }
2292
8fae2df5 2293 if (!s->priv_data && s->oformat->priv_data_size > 0) {
c6efa4b5
BC
2294 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2295 if (!s->priv_data)
769e10f0 2296 return AVERROR(ENOMEM);
8fae2df5 2297 }
c6efa4b5 2298
31e11451
MN
2299 if(s->oformat->write_header){
2300 ret = s->oformat->write_header(s);
2301 if (ret < 0)
2302 return ret;
2303 }
1e51d801
FB
2304
2305 /* init PTS generation */
2306 for(i=0;i<s->nb_streams;i++) {
f0ff20a1 2307 int64_t den = AV_NOPTS_VALUE;
1e51d801
FB
2308 st = s->streams[i];
2309
01f4895c 2310 switch (st->codec->codec_type) {
1e51d801 2311 case CODEC_TYPE_AUDIO:
f0ff20a1 2312 den = (int64_t)st->time_base.num * st->codec->sample_rate;
1e51d801
FB
2313 break;
2314 case CODEC_TYPE_VIDEO:
f0ff20a1 2315 den = (int64_t)st->time_base.num * st->codec->time_base.den;
1e51d801
FB
2316 break;
2317 default:
2318 break;
2319 }
f0ff20a1
WG
2320 if (den != AV_NOPTS_VALUE) {
2321 if (den <= 0)
2322 return AVERROR_INVALIDDATA;
2323 av_frac_init(&st->pts, 0, 0, den);
2324 }
1e51d801
FB
2325 }
2326 return 0;
b9a281db
FB
2327}
2328
3c895fc0 2329//FIXME merge with compute_pkt_fields
5edea431 2330static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
504ee036
MN
2331 int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2332 int num, den, frame_size, i;
b0c7f5a9 2333
949b1a13 2334// av_log(st->codec, AV_LOG_DEBUG, "av_write_frame: pts:%"PRId64" dts:%"PRId64" cur_dts:%"PRId64" b:%d size:%d st:%d\n", pkt->pts, pkt->dts, st->cur_dts, delay, pkt->size, pkt->stream_index);
115329f1 2335
e928649b
MN
2336/* if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2337 return -1;*/
115329f1 2338
e928649b 2339 /* duration field */
3c895fc0
MN
2340 if (pkt->duration == 0) {
2341 compute_frame_duration(&num, &den, st, NULL, pkt);
2342 if (den && num) {
2343 pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
2344 }
2345 }
e928649b
MN
2346
2347 //XXX/FIXME this is a temporary hack until all encoders output pts
504ee036 2348 if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
e928649b
MN
2349 pkt->dts=
2350// pkt->pts= st->cur_dts;
2351 pkt->pts= st->pts.val;
2352 }
2353
115329f1 2354 //calculate dts from pts
e928649b 2355 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE){
504ee036
MN
2356 st->pts_buffer[0]= pkt->pts;
2357 for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2358 st->pts_buffer[i]= (i-delay-1) * pkt->duration;
2359 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
1345f4ed 2360 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
504ee036
MN
2361
2362 pkt->dts= st->pts_buffer[0];
e928649b 2363 }
115329f1 2364
5edea431 2365 if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
578688fa 2366 av_log(NULL, AV_LOG_ERROR, "error, non monotone timestamps %"PRId64" >= %"PRId64"\n", st->cur_dts, pkt->dts);
5edea431
MN
2367 return -1;
2368 }
2369 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
578688fa 2370 av_log(NULL, AV_LOG_ERROR, "error, pts < dts\n");
5edea431
MN
2371 return -1;
2372 }
2373
949b1a13 2374// av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
e928649b
MN
2375 st->cur_dts= pkt->dts;
2376 st->pts.val= pkt->dts;
2377
1e51d801 2378 /* update pts */
01f4895c 2379 switch (st->codec->codec_type) {
1e51d801 2380 case CODEC_TYPE_AUDIO:
01f4895c 2381 frame_size = get_audio_frame_size(st->codec, pkt->size);
6d8f985e 2382
a85736f2
DB
2383 /* HACK/FIXME, we skip the initial 0 size packets as they are most
2384 likely equal to the encoder delay, but it would be better if we
2385 had the real timestamps from the encoder */
e928649b 2386 if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
9ee91c2f 2387 av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
7feb950a 2388 }
1e51d801
FB
2389 break;
2390 case CODEC_TYPE_VIDEO:
01f4895c 2391 av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
1e51d801
FB
2392 break;
2393 default:
2394 break;
2395 }
5edea431 2396 return 0;
3c895fc0
MN
2397}
2398
2399static void truncate_ts(AVStream *st, AVPacket *pkt){
2400 int64_t pts_mask = (2LL << (st->pts_wrap_bits-1)) - 1;
115329f1 2401
e0c91bc2 2402// if(pkt->dts < 0)
a85736f2 2403// pkt->dts= 0; //this happens for low_delay=0 and B-frames, FIXME, needs further investigation about what we should do here
115329f1 2404
68a432cf 2405 if (pkt->pts != AV_NOPTS_VALUE)
8533284d 2406 pkt->pts &= pts_mask;
68a432cf 2407 if (pkt->dts != AV_NOPTS_VALUE)
8533284d 2408 pkt->dts &= pts_mask;
3c895fc0
MN
2409}
2410
3c895fc0
MN
2411int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2412{
576ae256
MN
2413 int ret;
2414
5edea431 2415 ret=compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
494bbf58 2416 if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
5edea431 2417 return ret;
115329f1 2418
3c895fc0
MN
2419 truncate_ts(s->streams[pkt->stream_index], pkt);
2420
576ae256
MN
2421 ret= s->oformat->write_packet(s, pkt);
2422 if(!ret)
899681cd 2423 ret= url_ferror(s->pb);
576ae256 2424 return ret;
3c895fc0
MN
2425}
2426
f21c0b4c 2427int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
fe2d6fe2
MN
2428 AVPacketList *pktl, **next_point, *this_pktl;
2429 int stream_count=0;
2430 int streams[MAX_STREAMS];
2431
2432 if(pkt){
2433 AVStream *st= s->streams[ pkt->stream_index];
2434
2577897d 2435// assert(pkt->destruct != av_destruct_packet); //FIXME
fe2d6fe2
MN
2436
2437 this_pktl = av_mallocz(sizeof(AVPacketList));
2438 this_pktl->pkt= *pkt;
2577897d 2439 if(pkt->destruct == av_destruct_packet)
a85736f2 2440 pkt->destruct= NULL; // not shared -> must keep original from being freed
2577897d
MN
2441 else
2442 av_dup_packet(&this_pktl->pkt); //shared -> must dup
fe2d6fe2
MN
2443
2444 next_point = &s->packet_buffer;
2445 while(*next_point){
2446 AVStream *st2= s->streams[ (*next_point)->pkt.stream_index];
2447 int64_t left= st2->time_base.num * (int64_t)st ->time_base.den;
2448 int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2449 if((*next_point)->pkt.dts * left > pkt->dts * right) //FIXME this can overflow
2450 break;
2451 next_point= &(*next_point)->next;
2452 }
2453 this_pktl->next= *next_point;
2454 *next_point= this_pktl;
2455 }
115329f1 2456
fe2d6fe2
MN
2457 memset(streams, 0, sizeof(streams));
2458 pktl= s->packet_buffer;
2459 while(pktl){
949b1a13 2460//av_log(s, AV_LOG_DEBUG, "show st:%d dts:%"PRId64"\n", pktl->pkt.stream_index, pktl->pkt.dts);
fe2d6fe2
MN
2461 if(streams[ pktl->pkt.stream_index ] == 0)
2462 stream_count++;
2463 streams[ pktl->pkt.stream_index ]++;
2464 pktl= pktl->next;
2465 }
115329f1 2466
fe2d6fe2
MN
2467 if(s->nb_streams == stream_count || (flush && stream_count)){
2468 pktl= s->packet_buffer;
2469 *out= pktl->pkt;
115329f1
DB
2470
2471 s->packet_buffer= pktl->next;
fe2d6fe2
MN
2472 av_freep(&pktl);
2473 return 1;
2474 }else{
2475 av_init_packet(out);
2476 return 0;
2477 }
2478}
2479
2480/**
a85736f2 2481 * Interleaves an AVPacket correctly so it can be muxed.
fe2d6fe2
MN
2482 * @param out the interleaved packet will be output here
2483 * @param in the input packet
2484 * @param flush 1 if no further packets are available as input and all
2485 * remaining packets should be output
115329f1 2486 * @return 1 if a packet was output, 0 if no packet could be output,
d9526386 2487 * < 0 if an error occurred
fe2d6fe2
MN
2488 */
2489static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2490 if(s->oformat->interleave_packet)
2491 return s->oformat->interleave_packet(s, out, in, flush);
2492 else
2493 return av_interleave_packet_per_dts(s, out, in, flush);
2494}
2495
3c895fc0 2496int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
3c895fc0
MN
2497 AVStream *st= s->streams[ pkt->stream_index];
2498
6f824977 2499 //FIXME/XXX/HACK drop zero sized packets
01f4895c 2500 if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
6f824977 2501 return 0;
3ce16b30 2502
949b1a13 2503//av_log(NULL, AV_LOG_DEBUG, "av_interleaved_write_frame %d %"PRId64" %"PRId64"\n", pkt->size, pkt->dts, pkt->pts);
494bbf58 2504 if(compute_pkt_fields2(st, pkt) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3ce16b30 2505 return -1;
115329f1 2506
3c895fc0
MN
2507 if(pkt->dts == AV_NOPTS_VALUE)
2508 return -1;
3c895fc0 2509
fe2d6fe2
MN
2510 for(;;){
2511 AVPacket opkt;
2512 int ret= av_interleave_packet(s, &opkt, pkt, 0);
2513 if(ret<=0) //FIXME cleanup needed for ret<0 ?
2514 return ret;
115329f1 2515
fe2d6fe2
MN
2516 truncate_ts(s->streams[opkt.stream_index], &opkt);
2517 ret= s->oformat->write_packet(s, &opkt);
115329f1 2518
fe2d6fe2
MN
2519 av_free_packet(&opkt);
2520 pkt= NULL;
115329f1 2521
3c895fc0
MN
2522 if(ret<0)
2523 return ret;
899681cd
BA
2524 if(url_ferror(s->pb))
2525 return url_ferror(s->pb);
3c895fc0 2526 }
b9a281db
FB
2527}
2528
b9a281db
FB
2529int av_write_trailer(AVFormatContext *s)
2530{
c40a3a42 2531 int ret, i;
115329f1 2532
fe2d6fe2
MN
2533 for(;;){
2534 AVPacket pkt;
2535 ret= av_interleave_packet(s, &pkt, NULL, 1);
2536 if(ret<0) //FIXME cleanup needed for ret<0 ?
c40a3a42 2537 goto fail;
fe2d6fe2
MN
2538 if(!ret)
2539 break;
115329f1 2540
fe2d6fe2
MN
2541 truncate_ts(s->streams[pkt.stream_index], &pkt);
2542 ret= s->oformat->write_packet(s, &pkt);
115329f1 2543
fe2d6fe2 2544 av_free_packet(&pkt);
115329f1 2545
3c895fc0 2546 if(ret<0)
c40a3a42 2547 goto fail;
899681cd 2548 if(url_ferror(s->pb))
576ae256 2549 goto fail;
3c895fc0
MN
2550 }
2551
31e11451
MN
2552 if(s->oformat->write_trailer)
2553 ret = s->oformat->write_trailer(s);
c40a3a42 2554fail:
576ae256 2555 if(ret == 0)
899681cd 2556 ret=url_ferror(s->pb);
c40a3a42
MN
2557 for(i=0;i<s->nb_streams;i++)
2558 av_freep(&s->streams[i]->priv_data);
b9a281db
FB
2559 av_freep(&s->priv_data);
2560 return ret;
de6d9b64
FB
2561}
2562
526efa10
NS
2563void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
2564{
2565 int i, j;
2566 AVProgram *program=NULL;
2567 void *tmp;
2568
2569 for(i=0; i<ac->nb_programs; i++){
2570 if(ac->programs[i]->id != progid)
2571 continue;
2572 program = ac->programs[i];
2573 for(j=0; j<program->nb_stream_indexes; j++)
2574 if(program->stream_index[j] == idx)
2575 return;
2576
2577 tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
2578 if(!tmp)
2579 return;
2580 program->stream_index = tmp;
2581 program->stream_index[program->nb_stream_indexes++] = idx;
2582 return;
2583 }
2584}
2585
de6d9b64 2586/* "user interface" functions */
4e745a3b 2587static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
fad0e030 2588{
4e745a3b 2589 char buf[256];
fad0e030
NS
2590 int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
2591 AVStream *st = ic->streams[i];
2592 int g = ff_gcd(st->time_base.num, st->time_base.den);
2593 avcodec_string(buf, sizeof(buf), st->codec, is_output);
2594 av_log(NULL, AV_LOG_INFO, " Stream #%d.%d", index, i);
2595 /* the pid is an important information, so we display it */
2596 /* XXX: add a generic system */
2597 if (flags & AVFMT_SHOW_IDS)
2598 av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
2599 if (strlen(st->language) > 0)
2600 av_log(NULL, AV_LOG_INFO, "(%s)", st->language);
2601 av_log(NULL, AV_LOG_DEBUG, ", %d/%d", st->time_base.num/g, st->time_base.den/g);
2602 av_log(NULL, AV_LOG_INFO, ": %s", buf);
2603 if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2604 if(st->r_frame_rate.den && st->r_frame_rate.num)
5fba300d 2605 av_log(NULL, AV_LOG_INFO, ", %5.2f tb(r)", av_q2d(st->r_frame_rate));
fad0e030 2606/* else if(st->time_base.den && st->time_base.num)
5fba300d 2607 av_log(NULL, AV_LOG_INFO, ", %5.2f tb(m)", 1/av_q2d(st->time_base));*/
fad0e030 2608 else
5fba300d 2609 av_log(NULL, AV_LOG_INFO, ", %5.2f tb(c)", 1/av_q2d(st->codec->time_base));
fad0e030
NS
2610 }
2611 av_log(NULL, AV_LOG_INFO, "\n");
2612}
de6d9b64
FB
2613
2614void dump_format(AVFormatContext *ic,
115329f1 2615 int index,
de6d9b64
FB
2616 const char *url,
2617 int is_output)
2618{
63bb42fb 2619 int i;
de6d9b64 2620
115329f1 2621 av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
de6d9b64 2622 is_output ? "Output" : "Input",
115329f1
DB
2623 index,
2624 is_output ? ic->oformat->name : ic->iformat->name,
de6d9b64 2625 is_output ? "to" : "from", url);
12f996ed 2626 if (!is_output) {
2143116d 2627 av_log(NULL, AV_LOG_INFO, " Duration: ");
12f996ed
FB
2628 if (ic->duration != AV_NOPTS_VALUE) {
2629 int hours, mins, secs, us;
2630 secs = ic->duration / AV_TIME_BASE;
2631 us = ic->duration % AV_TIME_BASE;
2632 mins = secs / 60;
2633 secs %= 60;
2634 hours = mins / 60;
2635 mins %= 60;
115329f1 2636 av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%01d", hours, mins, secs,
12f996ed
FB
2637 (10 * us) / AV_TIME_BASE);
2638 } else {
2143116d 2639 av_log(NULL, AV_LOG_INFO, "N/A");
12f996ed 2640 }
d0f3f159
WG
2641 if (ic->start_time != AV_NOPTS_VALUE) {
2642 int secs, us;
2143116d 2643 av_log(NULL, AV_LOG_INFO, ", start: ");
d0f3f159
WG
2644 secs = ic->start_time / AV_TIME_BASE;
2645 us = ic->start_time % AV_TIME_BASE;
2143116d 2646 av_log(NULL, AV_LOG_INFO, "%d.%06d",
d0f3f159
WG
2647 secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
2648 }
2143116d 2649 av_log(NULL, AV_LOG_INFO, ", bitrate: ");
12f996ed 2650 if (ic->bit_rate) {
2143116d 2651 av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
12f996ed 2652 } else {
2143116d 2653 av_log(NULL, AV_LOG_INFO, "N/A");
12f996ed 2654 }
2143116d 2655 av_log(NULL, AV_LOG_INFO, "\n");
12f996ed 2656 }
526efa10
NS
2657 if(ic->nb_programs) {
2658 int j, k;
2659 for(j=0; j<ic->nb_programs; j++) {
f473666f
NS
2660 av_log(NULL, AV_LOG_INFO, " Program %d %s\n", ic->programs[j]->id,
2661 ic->programs[j]->name ? ic->programs[j]->name : "");
526efa10 2662 for(k=0; k<ic->programs[j]->nb_stream_indexes; k++)
4e745a3b 2663 dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
526efa10
NS
2664 }
2665 } else
fad0e030 2666 for(i=0;i<ic->nb_streams;i++)
4e745a3b 2667 dump_stream_format(ic, i, index, is_output);
de6d9b64
FB
2668}
2669
de6d9b64
FB
2670int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2671{
26ef3220 2672 return av_parse_video_frame_size(width_ptr, height_ptr, str);
de6d9b64
FB
2673}
2674
26ef3220 2675int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
445f1b83 2676{
26ef3220
SS
2677 AVRational frame_rate;
2678 int ret = av_parse_video_frame_rate(&frame_rate, arg);
2679 *frame_rate_num= frame_rate.num;
2680 *frame_rate_den= frame_rate.den;
2681 return ret;
445f1b83
RS
2682}
2683
82e4ac2c 2684/**
a85736f2 2685 * Gets the current time in microseconds.
82e4ac2c
RP
2686 */
2687int64_t av_gettime(void)
2688{
2689 struct timeval tv;
2690 gettimeofday(&tv,NULL);
2691 return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
2692}
2693
0c1a9eda 2694int64_t parse_date(const char *datestr, int duration)
de6d9b64
FB
2695{
2696 const char *p;
0c1a9eda 2697 int64_t t;
2dbceb9f 2698 struct tm dt;
c5510dd6
PG
2699 int i;
2700 static const char *date_fmt[] = {
2701 "%Y-%m-%d",
2702 "%Y%m%d",
2703 };
2704 static const char *time_fmt[] = {
2705 "%H:%M:%S",
2706 "%H%M%S",
2707 };
2708 const char *q;
916c80e9 2709 int is_utc, len;
c5510dd6 2710 char lastch;
a6a92a9a 2711 int negative = 0;
6d8f985e
MN
2712
2713#undef time
c5510dd6
PG
2714 time_t now = time(0);
2715
916c80e9
FB
2716 len = strlen(datestr);
2717 if (len > 0)
2718 lastch = datestr[len - 1];
2719 else
2720 lastch = '\0';
c5510dd6 2721 is_utc = (lastch == 'z' || lastch == 'Z');
2dbceb9f
PG
2722
2723 memset(&dt, 0, sizeof(dt));
de6d9b64
FB
2724
2725 p = datestr;
916c80e9 2726 q = NULL;
de6d9b64 2727 if (!duration) {
a8f70d72 2728 /* parse the year-month-day part */
c5510dd6 2729 for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
f71869a4 2730 q = small_strptime(p, date_fmt[i], &dt);
c5510dd6
PG
2731 if (q) {
2732 break;
2733 }
2734 }
2735
a8f70d72
SS
2736 /* if the year-month-day part is missing, then take the
2737 * current year-month-day time */
c5510dd6
PG
2738 if (!q) {
2739 if (is_utc) {
2740 dt = *gmtime(&now);
2741 } else {
2742 dt = *localtime(&now);
2743 }
2744 dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
de6d9b64 2745 } else {
c5510dd6 2746 p = q;
de6d9b64 2747 }
c5510dd6
PG
2748
2749 if (*p == 'T' || *p == 't' || *p == ' ')
2750 p++;
c5510dd6 2751
a8f70d72 2752 /* parse the hour-minute-second part */
916c80e9 2753 for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
f71869a4 2754 q = small_strptime(p, time_fmt[i], &dt);
916c80e9
FB
2755 if (q) {
2756 break;
2757 }
2758 }
2759 } else {
a8f70d72 2760 /* parse datestr as a duration */
bb270c08
DB
2761 if (p[0] == '-') {
2762 negative = 1;
2763 ++p;
2764 }
a8f70d72 2765 /* parse datestr as HH:MM:SS */
f71869a4 2766 q = small_strptime(p, time_fmt[0], &dt);
916c80e9 2767 if (!q) {
a8f70d72 2768 /* parse datestr as S+ */
916c80e9 2769 dt.tm_sec = strtol(p, (char **)&q, 10);
f9436161
SS
2770 if (q == p)
2771 /* the parsing didn't succeed */
2772 return INT64_MIN;
916c80e9
FB
2773 dt.tm_min = 0;
2774 dt.tm_hour = 0;
c5510dd6
PG
2775 }
2776 }
2777
2778 /* Now we have all the fields that we can get */
2779 if (!q) {
f9436161 2780 return INT64_MIN;
de6d9b64 2781 }
2dbceb9f
PG
2782
2783 if (duration) {
c5510dd6 2784 t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2dbceb9f 2785 } else {
c5510dd6
PG
2786 dt.tm_isdst = -1; /* unknown */
2787 if (is_utc) {
2788 t = mktimegm(&dt);
2789 } else {
2790 t = mktime(&dt);
2791 }
de6d9b64 2792 }
2dbceb9f 2793
c5510dd6
PG
2794 t *= 1000000;
2795
a8f70d72 2796 /* parse the .m... part */
c5510dd6 2797 if (*q == '.') {
de6d9b64 2798 int val, n;
c5510dd6
PG
2799 q++;
2800 for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
115329f1 2801 if (!isdigit(*q))
c5510dd6
PG
2802 break;
2803 val += n * (*q - '0');
de6d9b64
FB
2804 }
2805 t += val;
2806 }
a6a92a9a 2807 return negative ? -t : t;
de6d9b64
FB
2808}
2809
de6d9b64
FB
2810int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
2811{
2812 const char *p;
2813 char tag[128], *q;
2814
2815 p = info;
2816 if (*p == '?')
2817 p++;
2818 for(;;) {
2819 q = tag;
2820 while (*p != '\0' && *p != '=' && *p != '&') {
2821 if ((q - tag) < sizeof(tag) - 1)
2822 *q++ = *p;
2823 p++;
2824 }
2825 *q = '\0';
2826 q = arg;
2827 if (*p == '=') {
2828 p++;
2829 while (*p != '&' && *p != '\0') {
2dbceb9f
PG
2830 if ((q - arg) < arg_size - 1) {
2831 if (*p == '+')
2832 *q++ = ' ';
2833 else
2834 *q++ = *p;
2835 }
de6d9b64
FB
2836 p++;
2837 }
2838 *q = '\0';
2839 }
115329f1 2840 if (!strcmp(tag, tag1))
de6d9b64
FB
2841 return 1;
2842 if (*p != '&')
2843 break;
8d1335ea 2844 p++;
de6d9b64
FB
2845 }
2846 return 0;
2847}
2848
5c07cf53
MB
2849int av_get_frame_filename(char *buf, int buf_size,
2850 const char *path, int number)
9150f42e
FB
2851{
2852 const char *p;
0bf92f79
PI
2853 char *q, buf1[20], c;
2854 int nd, len, percentd_found;
9150f42e
FB
2855
2856 q = buf;
2857 p = path;
2858 percentd_found = 0;
2859 for(;;) {
2860 c = *p++;
2861 if (c == '\0')
2862 break;
2863 if (c == '%') {
c9646fda
PG
2864 do {
2865 nd = 0;
2866 while (isdigit(*p)) {
2867 nd = nd * 10 + *p++ - '0';
2868 }
2869 c = *p++;
c9646fda
PG
2870 } while (isdigit(c));
2871
9150f42e
FB
2872 switch(c) {
2873 case '%':
2874 goto addchar;
2875 case 'd':
2876 if (percentd_found)
2877 goto fail;
2878 percentd_found = 1;
2879 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
2880 len = strlen(buf1);
2881 if ((q - buf + len) > buf_size - 1)
2882 goto fail;
2883 memcpy(q, buf1, len);
2884 q += len;
2885 break;
2886 default:
2887 goto fail;
2888 }
2889 } else {
2890 addchar:
2891 if ((q - buf) < buf_size - 1)
2892 *q++ = c;
2893 }
2894 }
2895 if (!percentd_found)
2896 goto fail;
2897 *q = '\0';
2898 return 0;
2899 fail:
2900 *q = '\0';
2901 return -1;
2902}
2903
750f0e1f 2904static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
b9a281db
FB
2905{
2906 int len, i, j, c;
750f0e1f 2907#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
b9a281db
FB
2908
2909 for(i=0;i<size;i+=16) {
2910 len = size - i;
2911 if (len > 16)
2912 len = 16;
750f0e1f 2913 PRINT("%08x ", i);
b9a281db
FB
2914 for(j=0;j<16;j++) {
2915 if (j < len)
750f0e1f 2916 PRINT(" %02x", buf[i+j]);
b9a281db 2917 else
750f0e1f 2918 PRINT(" ");
b9a281db 2919 }
750f0e1f 2920 PRINT(" ");
b9a281db
FB
2921 for(j=0;j<len;j++) {
2922 c = buf[i+j];
2923 if (c < ' ' || c > '~')
2924 c = '.';
750f0e1f 2925 PRINT("%c", c);
b9a281db 2926 }
750f0e1f 2927 PRINT("\n");
b9a281db 2928 }
750f0e1f
PI
2929#undef PRINT
2930}
2931
2932void av_hex_dump(FILE *f, uint8_t *buf, int size)
2933{
2934 hex_dump_internal(NULL, f, 0, buf, size);
2935}
2936
2937void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
2938{
2939 hex_dump_internal(avcl, NULL, level, buf, size);
b9a281db
FB
2940}
2941
c0df9d75 2942 //FIXME needs to know the time_base
750f0e1f 2943static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload)
fb2758c8 2944{
750f0e1f
PI
2945#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
2946 PRINT("stream #%d:\n", pkt->stream_index);
2947 PRINT(" keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
2948 PRINT(" duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
37353960 2949 /* DTS is _always_ valid after av_read_frame() */
750f0e1f 2950 PRINT(" dts=");
37353960 2951 if (pkt->dts == AV_NOPTS_VALUE)
750f0e1f 2952 PRINT("N/A");
37353960 2953 else
750f0e1f 2954 PRINT("%0.3f", (double)pkt->dts / AV_TIME_BASE);
a85736f2 2955 /* PTS may not be known if B-frames are present. */
750f0e1f 2956 PRINT(" pts=");
fb2758c8 2957 if (pkt->pts == AV_NOPTS_VALUE)
750f0e1f 2958 PRINT("N/A");
fb2758c8 2959 else
750f0e1f
PI
2960 PRINT("%0.3f", (double)pkt->pts / AV_TIME_BASE);
2961 PRINT("\n");
2962 PRINT(" size=%d\n", pkt->size);
2963#undef PRINT
fb2758c8
FB
2964 if (dump_payload)
2965 av_hex_dump(f, pkt->data, pkt->size);
2966}
2967
750f0e1f
PI
2968void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
2969{
2970 pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
2971}
2972
2973void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
2974{
2975 pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
2976}
2977
a9a721da 2978void url_split(char *proto, int proto_size,
6ba5cbc6 2979 char *authorization, int authorization_size,
a9a721da
FB
2980 char *hostname, int hostname_size,
2981 int *port_ptr,
2982 char *path, int path_size,
2983 const char *url)
2984{
7ef55085 2985 const char *p, *ls, *at, *col, *brk;
7e1e297e
RB
2986
2987 if (port_ptr) *port_ptr = -1;
2988 if (proto_size > 0) proto[0] = 0;
2989 if (authorization_size > 0) authorization[0] = 0;
2990 if (hostname_size > 0) hostname[0] = 0;
2991 if (path_size > 0) path[0] = 0;
2992
2993 /* parse protocol */
2994 if ((p = strchr(url, ':'))) {
2995 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
2996 p++; /* skip ':' */
2997 if (*p == '/') p++;
2998 if (*p == '/') p++;
a9a721da 2999 } else {
7e1e297e
RB
3000 /* no protocol means plain filename */
3001 av_strlcpy(path, url, path_size);
3002 return;
3003 }
6ba5cbc6 3004
7e1e297e 3005 /* separate path from hostname */
7ef55085
MN
3006 ls = strchr(p, '/');
3007 if(!ls)
3008 ls = strchr(p, '?');
3009 if(ls)
5cc9253f 3010 av_strlcpy(path, ls, path_size);
7ef55085 3011 else
7e1e297e
RB
3012 ls = &p[strlen(p)]; // XXX
3013
3014 /* the rest is hostname, use that to parse auth/port */
3015 if (ls != p) {
3016 /* authorization (user[:pass]@hostname) */
3017 if ((at = strchr(p, '@')) && at < ls) {
3018 av_strlcpy(authorization, p,
3019 FFMIN(authorization_size, at + 1 - p));
3020 p = at + 1; /* skip '@' */
a9a721da 3021 }
7e1e297e 3022
f8f88a42
RB
3023 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3024 /* [host]:port */
3025 av_strlcpy(hostname, p + 1,
3026 FFMIN(hostname_size, brk - p));
3027 if (brk[1] == ':' && port_ptr)
3028 *port_ptr = atoi(brk + 2);
3029 } else if ((col = strchr(p, ':')) && col < ls) {
3030 av_strlcpy(hostname, p,
3031 FFMIN(col + 1 - p, hostname_size));
3032 if (port_ptr) *port_ptr = atoi(col + 1);
3033 } else
3034 av_strlcpy(hostname, p,
3035 FFMIN(ls + 1 - p, hostname_size));
a9a721da 3036 }
a9a721da
FB
3037}
3038
9ee91c2f 3039void av_set_pts_info(AVStream *s, int pts_wrap_bits,
916c80e9
FB
3040 int pts_num, int pts_den)
3041{
3042 s->pts_wrap_bits = pts_wrap_bits;
9ee91c2f
MN
3043 s->time_base.num = pts_num;
3044 s->time_base.den = pts_den;
916c80e9
FB
3045}
3046
3047/* fraction handling */
3048
3049/**
e36bdf8b
DK
3050 * f = val + (num / den) + 0.5.
3051 *
3052 * 'num' is normalized so that it is such as 0 <= num < den.
916c80e9
FB
3053 *
3054 * @param f fractional number
3055 * @param val integer value
3056 * @param num must be >= 0
115329f1 3057 * @param den must be >= 1
916c80e9 3058 */
f3a30e3a 3059static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
916c80e9
FB
3060{
3061 num += (den >> 1);
3062 if (num >= den) {
3063 val += num / den;
3064 num = num % den;
3065 }
3066 f->val = val;
3067 f->num = num;
3068 f->den = den;
3069}
3070
e36bdf8b 3071/**
a85736f2 3072 * Fractional addition to f: f = f + (incr / f->den).
916c80e9
FB
3073 *
3074 * @param f fractional number
3075 * @param incr increment, can be positive or negative
3076 */
f3a30e3a 3077static void av_frac_add(AVFrac *f, int64_t incr)
916c80e9 3078{
0c1a9eda 3079 int64_t num, den;
916c80e9
FB
3080
3081 num = f->num + incr;
3082 den = f->den;
3083 if (num < 0) {
3084 f->val += num / den;
3085 num = num % den;
3086 if (num < 0) {
3087 num += den;
3088 f->val--;
3089 }
3090 } else if (num >= den) {
3091 f->val += num / den;
3092 num = num % den;
3093 }
3094 f->num = num;
3095}