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