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