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