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