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