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