oops, revert accidental checkin
[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);
53e2f9ca
MN
481 if (url_fseek(pb, 0, SEEK_SET) == (offset_t)-EPIPE) {
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);
434cab9e 791 break;
fb2758c8
FB
792 }
793 } else {
bcbecff1 794 /* free packet */
115329f1 795 av_free_packet(&s->cur_pkt);
fb2758c8
FB
796 s->cur_st = NULL;
797 }
798 } else {
fb2758c8
FB
799 /* read next packet */
800 ret = av_read_packet(s, &s->cur_pkt);
37353960
FB
801 if (ret < 0) {
802 if (ret == -EAGAIN)
803 return ret;
804 /* return the last frames, if any */
805 for(i = 0; i < s->nb_streams; i++) {
806 st = s->streams[i];
90ad92b3 807 if (st->parser && st->need_parsing) {
115329f1
DB
808 av_parser_parse(st->parser, st->codec,
809 &pkt->data, &pkt->size,
810 NULL, 0,
6ec87caa 811 AV_NOPTS_VALUE, AV_NOPTS_VALUE);
37353960
FB
812 if (pkt->size)
813 goto got_packet;
814 }
815 }
816 /* no more packets: really terminates parsing */
fb2758c8 817 return ret;
37353960 818 }
115329f1 819
9ee91c2f 820 st = s->streams[s->cur_pkt.stream_index];
434cab9e 821 if(st->codec->debug & FF_DEBUG_PTS)
ccd3228e 822 av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
434cab9e
MN
823 s->cur_pkt.stream_index,
824 s->cur_pkt.pts,
825 s->cur_pkt.dts,
826 s->cur_pkt.size);
fb2758c8 827
fb2758c8
FB
828 s->cur_st = st;
829 s->cur_ptr = s->cur_pkt.data;
830 s->cur_len = s->cur_pkt.size;
831 if (st->need_parsing && !st->parser) {
01f4895c 832 st->parser = av_parser_init(st->codec->codec_id);
fb2758c8
FB
833 if (!st->parser) {
834 /* no parser available : just output the raw packets */
835 st->need_parsing = 0;
7cbaa7ba
MN
836 }else if(st->need_parsing == 2){
837 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
fb2758c8
FB
838 }
839 }
840 }
841 }
434cab9e 842 if(st->codec->debug & FF_DEBUG_PTS)
ccd3228e 843 av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
434cab9e
MN
844 pkt->stream_index,
845 pkt->pts,
846 pkt->dts,
847 pkt->size);
848
849 return 0;
fb2758c8
FB
850}
851
852/**
e36bdf8b
DK
853 * Return the next frame of a stream.
854 *
855 * The returned packet is valid
fb2758c8
FB
856 * until the next av_read_frame() or until av_close_input_file() and
857 * must be freed with av_free_packet. For video, the packet contains
858 * exactly one frame. For audio, it contains an integer number of
859 * frames if each frame has a known fixed size (e.g. PCM or ADPCM
860 * data). If the audio frames have a variable size (e.g. MPEG audio),
861 * then it contains one frame.
115329f1 862 *
fb2758c8
FB
863 * pkt->pts, pkt->dts and pkt->duration are always set to correct
864 * values in AV_TIME_BASE unit (and guessed if the format cannot
865 * provided them). pkt->pts can be AV_NOPTS_VALUE if the video format
866 * has B frames, so it is better to rely on pkt->dts if you do not
867 * decompress the payload.
115329f1 868 *
e36bdf8b 869 * @return 0 if OK, < 0 if error or end of file.
fb2758c8
FB
870 */
871int av_read_frame(AVFormatContext *s, AVPacket *pkt)
872{
de6d9b64 873 AVPacketList *pktl;
30bc6613
MN
874 int eof=0;
875 const int genpts= s->flags & AVFMT_FLAG_GENPTS;
876
877 for(;;){
878 pktl = s->packet_buffer;
879 if (pktl) {
880 AVPacket *next_pkt= &pktl->pkt;
30bc6613
MN
881
882 if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
883 while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
115329f1 884 if( pktl->pkt.stream_index == next_pkt->stream_index
30bc6613
MN
885 && next_pkt->dts < pktl->pkt.dts
886 && pktl->pkt.pts != pktl->pkt.dts //not b frame
887 /*&& pktl->pkt.dts != AV_NOPTS_VALUE*/){
888 next_pkt->pts= pktl->pkt.dts;
889 }
890 pktl= pktl->next;
891 }
892 pktl = s->packet_buffer;
893 }
115329f1
DB
894
895 if( next_pkt->pts != AV_NOPTS_VALUE
896 || next_pkt->dts == AV_NOPTS_VALUE
30bc6613
MN
897 || !genpts || eof){
898 /* read packet from packet buffer, if there is data */
899 *pkt = *next_pkt;
900 s->packet_buffer = pktl->next;
901 av_free(pktl);
902 return 0;
903 }
904 }
905 if(genpts){
906 AVPacketList **plast_pktl= &s->packet_buffer;
907 int ret= av_read_frame_internal(s, pkt);
908 if(ret<0){
909 if(pktl && ret != -EAGAIN){
910 eof=1;
911 continue;
912 }else
913 return ret;
914 }
115329f1 915
30bc6613
MN
916 /* duplicate the packet */
917 if (av_dup_packet(pkt) < 0)
918 return AVERROR_NOMEM;
de6d9b64 919
30bc6613 920 while(*plast_pktl) plast_pktl= &(*plast_pktl)->next; //FIXME maybe maintain pointer to the last?
115329f1 921
30bc6613
MN
922 pktl = av_mallocz(sizeof(AVPacketList));
923 if (!pktl)
924 return AVERROR_NOMEM;
115329f1 925
30bc6613
MN
926 /* add the packet in the buffered packet list */
927 *plast_pktl = pktl;
115329f1 928 pktl->pkt= *pkt;
30bc6613
MN
929 }else{
930 assert(!s->packet_buffer);
931 return av_read_frame_internal(s, pkt);
932 }
fb2758c8
FB
933 }
934}
935
936/* XXX: suppress the packet queue */
937static void flush_packet_queue(AVFormatContext *s)
938{
939 AVPacketList *pktl;
940
941 for(;;) {
942 pktl = s->packet_buffer;
115329f1 943 if (!pktl)
fb2758c8
FB
944 break;
945 s->packet_buffer = pktl->next;
946 av_free_packet(&pktl->pkt);
947 av_free(pktl);
b9a281db
FB
948 }
949}
950
da24c5e3 951/*******************************************************/
fb2758c8
FB
952/* seek support */
953
b754978a
MN
954int av_find_default_stream_index(AVFormatContext *s)
955{
956 int i;
957 AVStream *st;
958
959 if (s->nb_streams <= 0)
960 return -1;
961 for(i = 0; i < s->nb_streams; i++) {
962 st = s->streams[i];
01f4895c 963 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
b754978a
MN
964 return i;
965 }
966 }
967 return 0;
968}
969
e36bdf8b
DK
970/**
971 * Flush the frame reader.
972 */
fb2758c8
FB
973static void av_read_frame_flush(AVFormatContext *s)
974{
975 AVStream *st;
976 int i;
977
978 flush_packet_queue(s);
979
980 /* free previous packet */
981 if (s->cur_st) {
982 if (s->cur_st->parser)
983 av_free_packet(&s->cur_pkt);
984 s->cur_st = NULL;
985 }
986 /* fail safe */
987 s->cur_ptr = NULL;
988 s->cur_len = 0;
115329f1 989
fb2758c8
FB
990 /* for each stream, reset read state */
991 for(i = 0; i < s->nb_streams; i++) {
992 st = s->streams[i];
115329f1 993
fb2758c8
FB
994 if (st->parser) {
995 av_parser_close(st->parser);
996 st->parser = NULL;
997 }
77405fc8 998 st->last_IP_pts = AV_NOPTS_VALUE;
fb2758c8
FB
999 st->cur_dts = 0; /* we set the current DTS to an unspecified origin */
1000 }
1001}
1002
cdd5034f 1003/**
e36bdf8b
DK
1004 * Updates cur_dts of all streams based on given timestamp and AVStream.
1005 *
1006 * Stream ref_st unchanged, others set cur_dts in their native timebase
1a1dc611
NK
1007 * only needed for timestamp wrapping or if (dts not set and pts!=dts)
1008 * @param timestamp new dts expressed in time_base of param ref_st
1009 * @param ref_st reference stream giving time_base of param timestamp
8bcb147f 1010 */
22ffac70 1011void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
8bcb147f
MN
1012 int i;
1013
1014 for(i = 0; i < s->nb_streams; i++) {
1a1dc611 1015 AVStream *st = s->streams[i];
8bcb147f 1016
115329f1 1017 st->cur_dts = av_rescale(timestamp,
1a1dc611
NK
1018 st->time_base.den * (int64_t)ref_st->time_base.num,
1019 st->time_base.num * (int64_t)ref_st->time_base.den);
8bcb147f
MN
1020 }
1021}
1022
1023/**
e36bdf8b
DK
1024 * Add a index entry into a sorted list updateing if it is already there.
1025 *
cdd5034f
MN
1026 * @param timestamp timestamp in the timebase of the given stream
1027 */
3e9245a9 1028int av_add_index_entry(AVStream *st,
30a43f2d 1029 int64_t pos, int64_t timestamp, int size, int distance, int flags)
fb2758c8
FB
1030{
1031 AVIndexEntry *entries, *ie;
b754978a 1032 int index;
115329f1 1033
568e18b1
MN
1034 if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1035 return -1;
115329f1 1036
fb2758c8
FB
1037 entries = av_fast_realloc(st->index_entries,
1038 &st->index_entries_allocated_size,
115329f1 1039 (st->nb_index_entries + 1) *
fb2758c8 1040 sizeof(AVIndexEntry));
568e18b1
MN
1041 if(!entries)
1042 return -1;
1043
b754978a
MN
1044 st->index_entries= entries;
1045
27a5fe5f 1046 index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
b754978a 1047
3ba1438d 1048 if(index<0){
3e9245a9
MN
1049 index= st->nb_index_entries++;
1050 ie= &entries[index];
3ba1438d
MN
1051 assert(index==0 || ie[-1].timestamp < timestamp);
1052 }else{
1053 ie= &entries[index];
1054 if(ie->timestamp != timestamp){
528c2c73
MN
1055 if(ie->timestamp <= timestamp)
1056 return -1;
3ba1438d
MN
1057 memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
1058 st->nb_index_entries++;
1059 }else if(ie->pos == pos && distance < ie->min_distance) //dont reduce the distance
1060 distance= ie->min_distance;
3e9245a9 1061 }
3ba1438d 1062
b754978a
MN
1063 ie->pos = pos;
1064 ie->timestamp = timestamp;
3e9245a9 1065 ie->min_distance= distance;
30a43f2d 1066 ie->size= size;
b754978a 1067 ie->flags = flags;
115329f1 1068
3e9245a9 1069 return index;
fb2758c8
FB
1070}
1071
e36bdf8b
DK
1072/**
1073 * build an index for raw streams using a parser.
1074 */
fb2758c8
FB
1075static void av_build_index_raw(AVFormatContext *s)
1076{
1077 AVPacket pkt1, *pkt = &pkt1;
1078 int ret;
1079 AVStream *st;
1080
1081 st = s->streams[0];
1082 av_read_frame_flush(s);
1083 url_fseek(&s->pb, s->data_offset, SEEK_SET);
1084
1085 for(;;) {
1086 ret = av_read_frame(s, pkt);
1087 if (ret < 0)
1088 break;
1089 if (pkt->stream_index == 0 && st->parser &&
1090 (pkt->flags & PKT_FLAG_KEY)) {
115329f1 1091 av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
30a43f2d 1092 0, 0, AVINDEX_KEYFRAME);
fb2758c8
FB
1093 }
1094 av_free_packet(pkt);
1095 }
1096}
1097
e36bdf8b
DK
1098/**
1099 * Returns TRUE if we deal with a raw stream.
1100 *
1101 * Raw codec data and parsing needed.
1102 */
fb2758c8
FB
1103static int is_raw_stream(AVFormatContext *s)
1104{
1105 AVStream *st;
1106
1107 if (s->nb_streams != 1)
1108 return 0;
1109 st = s->streams[0];
1110 if (!st->need_parsing)
1111 return 0;
1112 return 1;
1113}
1114
3ba1438d 1115/**
e36bdf8b 1116 * Gets the index for a specific timestamp.
115329f1
DB
1117 * @param flags if AVSEEK_FLAG_BACKWARD then the returned index will correspond to
1118 * the timestamp which is <= the requested one, if backward is 0
3ba1438d 1119 * then it will be >=
27a5fe5f 1120 * if AVSEEK_FLAG_ANY seek to any frame, only keyframes otherwise
3ba1438d
MN
1121 * @return < 0 if no such timestamp could be found
1122 */
dc56fc38 1123int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
27a5fe5f 1124 int flags)
fb2758c8 1125{
b754978a
MN
1126 AVIndexEntry *entries= st->index_entries;
1127 int nb_entries= st->nb_index_entries;
fb2758c8
FB
1128 int a, b, m;
1129 int64_t timestamp;
1130
3ba1438d
MN
1131 a = - 1;
1132 b = nb_entries;
b754978a 1133
3ba1438d
MN
1134 while (b - a > 1) {
1135 m = (a + b) >> 1;
fb2758c8 1136 timestamp = entries[m].timestamp;
3ba1438d
MN
1137 if(timestamp >= wanted_timestamp)
1138 b = m;
1139 if(timestamp <= wanted_timestamp)
b754978a 1140 a = m;
fb2758c8 1141 }
27a5fe5f 1142 m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
115329f1 1143
27a5fe5f
MN
1144 if(!(flags & AVSEEK_FLAG_ANY)){
1145 while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1146 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1147 }
1148 }
3ba1438d 1149
115329f1 1150 if(m == nb_entries)
3ba1438d
MN
1151 return -1;
1152 return m;
fb2758c8
FB
1153}
1154
8d14a25c
MN
1155#define DEBUG_SEEK
1156
cdd5034f
MN
1157/**
1158 * Does a binary search using av_index_search_timestamp() and AVCodec.read_timestamp().
1159 * this isnt supposed to be called directly by a user application, but by demuxers
1160 * @param target_ts target timestamp in the time base of the given stream
1161 * @param stream_index stream number
1162 */
3ba1438d 1163int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
8d14a25c
MN
1164 AVInputFormat *avif= s->iformat;
1165 int64_t pos_min, pos_max, pos, pos_limit;
1166 int64_t ts_min, ts_max, ts;
89ddd2a9 1167 int index;
8d14a25c
MN
1168 AVStream *st;
1169
cdd5034f
MN
1170 if (stream_index < 0)
1171 return -1;
115329f1 1172
8d14a25c 1173#ifdef DEBUG_SEEK
4733abcb 1174 av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
8d14a25c
MN
1175#endif
1176
1177 ts_max=
1178 ts_min= AV_NOPTS_VALUE;
1179 pos_limit= -1; //gcc falsely says it may be uninitalized
1180
1181 st= s->streams[stream_index];
1182 if(st->index_entries){
1183 AVIndexEntry *e;
1184
27a5fe5f 1185 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 1186 index= FFMAX(index, 0);
8d14a25c
MN
1187 e= &st->index_entries[index];
1188
1189 if(e->timestamp <= target_ts || e->pos == e->min_distance){
1190 pos_min= e->pos;
1191 ts_min= e->timestamp;
1192#ifdef DEBUG_SEEK
115329f1 1193 av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
8d14a25c
MN
1194 pos_min,ts_min);
1195#endif
1196 }else{
1197 assert(index==0);
1198 }
115329f1
DB
1199
1200 index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
27a5fe5f
MN
1201 assert(index < st->nb_index_entries);
1202 if(index >= 0){
8d14a25c
MN
1203 e= &st->index_entries[index];
1204 assert(e->timestamp >= target_ts);
1205 pos_max= e->pos;
1206 ts_max= e->timestamp;
1207 pos_limit= pos_max - e->min_distance;
1208#ifdef DEBUG_SEEK
115329f1 1209 av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
8d14a25c
MN
1210 pos_max,pos_limit, ts_max);
1211#endif
1212 }
1213 }
1214
89ddd2a9
MN
1215 pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1216 if(pos<0)
1217 return -1;
1218
1219 /* do the seek */
1220 url_fseek(&s->pb, pos, SEEK_SET);
1221
1222 av_update_cur_dts(s, st, ts);
1223
1224 return 0;
1225}
1226
1227/**
1228 * Does a binary search using read_timestamp().
1229 * this isnt supposed to be called directly by a user application, but by demuxers
1230 * @param target_ts target timestamp in the time base of the given stream
1231 * @param stream_index stream number
1232 */
1233int64_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 )){
1234 int64_t pos, ts;
1235 int64_t start_pos, filesize;
1236 int no_change;
1237
1238#ifdef DEBUG_SEEK
1239 av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1240#endif
1241
8d14a25c
MN
1242 if(ts_min == AV_NOPTS_VALUE){
1243 pos_min = s->data_offset;
89ddd2a9 1244 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
8d14a25c
MN
1245 if (ts_min == AV_NOPTS_VALUE)
1246 return -1;
1247 }
1248
1249 if(ts_max == AV_NOPTS_VALUE){
1250 int step= 1024;
6fd93ce2
KA
1251 filesize = url_fsize(&s->pb);
1252 pos_max = filesize - 1;
8d14a25c
MN
1253 do{
1254 pos_max -= step;
89ddd2a9 1255 ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
8d14a25c
MN
1256 step += step;
1257 }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1258 if (ts_max == AV_NOPTS_VALUE)
1259 return -1;
115329f1 1260
8d14a25c
MN
1261 for(;;){
1262 int64_t tmp_pos= pos_max + 1;
89ddd2a9 1263 int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
8d14a25c
MN
1264 if(tmp_ts == AV_NOPTS_VALUE)
1265 break;
1266 ts_max= tmp_ts;
1267 pos_max= tmp_pos;
6fd93ce2
KA
1268 if(tmp_pos >= filesize)
1269 break;
8d14a25c
MN
1270 }
1271 pos_limit= pos_max;
1272 }
1273
53f7c43f
MN
1274 if(ts_min > ts_max){
1275 return -1;
1276 }else if(ts_min == ts_max){
1277 pos_limit= pos_min;
1278 }
1279
8d14a25c
MN
1280 no_change=0;
1281 while (pos_min < pos_limit) {
1282#ifdef DEBUG_SEEK
115329f1 1283 av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
8d14a25c
MN
1284 pos_min, pos_max,
1285 ts_min, ts_max);
1286#endif
1287 assert(pos_limit <= pos_max);
1288
1289 if(no_change==0){
1290 int64_t approximate_keyframe_distance= pos_max - pos_limit;
1291 // interpolate position (better than dichotomy)
3ba1438d
MN
1292 pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1293 + pos_min - approximate_keyframe_distance;
8d14a25c
MN
1294 }else if(no_change==1){
1295 // bisection, if interpolation failed to change min or max pos last time
1296 pos = (pos_min + pos_limit)>>1;
1297 }else{
1298 // linear search if bisection failed, can only happen if there are very few or no keframes between min/max
1299 pos=pos_min;
1300 }
1301 if(pos <= pos_min)
1302 pos= pos_min + 1;
1303 else if(pos > pos_limit)
1304 pos= pos_limit;
1305 start_pos= pos;
1306
89ddd2a9 1307 ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
8d14a25c
MN
1308 if(pos == pos_max)
1309 no_change++;
1310 else
1311 no_change=0;
1312#ifdef DEBUG_SEEK
4733abcb 1313av_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
1314#endif
1315 assert(ts != AV_NOPTS_VALUE);
3ba1438d 1316 if (target_ts <= ts) {
8d14a25c
MN
1317 pos_limit = start_pos - 1;
1318 pos_max = pos;
1319 ts_max = ts;
3ba1438d
MN
1320 }
1321 if (target_ts >= ts) {
8d14a25c
MN
1322 pos_min = pos;
1323 ts_min = ts;
8d14a25c
MN
1324 }
1325 }
115329f1 1326
3ba1438d
MN
1327 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1328 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
8d14a25c
MN
1329#ifdef DEBUG_SEEK
1330 pos_min = pos;
89ddd2a9 1331 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
8d14a25c 1332 pos_min++;
89ddd2a9 1333 ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
115329f1 1334 av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
8d14a25c
MN
1335 pos, ts_min, target_ts, ts_max);
1336#endif
89ddd2a9
MN
1337 *ts_ret= ts;
1338 return pos;
8d14a25c
MN
1339}
1340
3ba1438d 1341static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
3ba1438d
MN
1342 int64_t pos_min, pos_max;
1343#if 0
1344 AVStream *st;
1345
1346 if (stream_index < 0)
1347 return -1;
1348
1349 st= s->streams[stream_index];
1350#endif
1351
1352 pos_min = s->data_offset;
a965c478 1353 pos_max = url_fsize(&s->pb) - 1;
3ba1438d
MN
1354
1355 if (pos < pos_min) pos= pos_min;
1356 else if(pos > pos_max) pos= pos_max;
1357
1358 url_fseek(&s->pb, pos, SEEK_SET);
1359
1360#if 0
8bcb147f 1361 av_update_cur_dts(s, st, ts);
3ba1438d
MN
1362#endif
1363 return 0;
1364}
1365
115329f1 1366static int av_seek_frame_generic(AVFormatContext *s,
3ba1438d 1367 int stream_index, int64_t timestamp, int flags)
fb2758c8 1368{
8bcb147f 1369 int index;
fb2758c8
FB
1370 AVStream *st;
1371 AVIndexEntry *ie;
1372
1373 if (!s->index_built) {
1374 if (is_raw_stream(s)) {
1375 av_build_index_raw(s);
1376 } else {
1377 return -1;
1378 }
1379 s->index_built = 1;
1380 }
1381
fb2758c8 1382 st = s->streams[stream_index];
27a5fe5f 1383 index = av_index_search_timestamp(st, timestamp, flags);
fb2758c8
FB
1384 if (index < 0)
1385 return -1;
1386
1387 /* now we have found the index, we can seek */
1388 ie = &st->index_entries[index];
1389 av_read_frame_flush(s);
1390 url_fseek(&s->pb, ie->pos, SEEK_SET);
3ba1438d 1391
8bcb147f 1392 av_update_cur_dts(s, st, ie->timestamp);
cdd5034f 1393
fb2758c8
FB
1394 return 0;
1395}
1396
1397/**
3ba1438d 1398 * Seek to the key frame at timestamp.
cdd5034f
MN
1399 * 'timestamp' in 'stream_index'.
1400 * @param stream_index If stream_index is (-1), a default
115329f1 1401 * stream is selected, and timestamp is automatically converted
eb497825 1402 * from AV_TIME_BASE units to the stream specific time_base.
3ba1438d 1403 * @param timestamp timestamp in AVStream.time_base units
9c98cdbc 1404 * or if there is no stream specified then in AV_TIME_BASE units
3ba1438d 1405 * @param flags flags which select direction and seeking mode
cdd5034f 1406 * @return >= 0 on success
fb2758c8 1407 */
3ba1438d 1408int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
fb2758c8
FB
1409{
1410 int ret;
cdd5034f 1411 AVStream *st;
115329f1 1412
fb2758c8 1413 av_read_frame_flush(s);
115329f1 1414
3ba1438d
MN
1415 if(flags & AVSEEK_FLAG_BYTE)
1416 return av_seek_frame_byte(s, stream_index, timestamp, flags);
115329f1 1417
cdd5034f
MN
1418 if(stream_index < 0){
1419 stream_index= av_find_default_stream_index(s);
1420 if(stream_index < 0)
1421 return -1;
115329f1 1422
3ba1438d 1423 st= s->streams[stream_index];
eb497825 1424 /* timestamp for default must be expressed in AV_TIME_BASE units */
3ba1438d 1425 timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
cdd5034f
MN
1426 }
1427 st= s->streams[stream_index];
1428
fb2758c8
FB
1429 /* first, we try the format specific seek */
1430 if (s->iformat->read_seek)
3ba1438d 1431 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
fb2758c8
FB
1432 else
1433 ret = -1;
1434 if (ret >= 0) {
1435 return 0;
1436 }
8d14a25c
MN
1437
1438 if(s->iformat->read_timestamp)
3ba1438d 1439 return av_seek_frame_binary(s, stream_index, timestamp, flags);
8d14a25c 1440 else
3ba1438d 1441 return av_seek_frame_generic(s, stream_index, timestamp, flags);
fb2758c8
FB
1442}
1443
1444/*******************************************************/
12f996ed 1445
e36bdf8b
DK
1446/**
1447 * Returns TRUE if the stream has accurate timings in any stream.
1448 *
1449 * @return TRUE if the stream has accurate timings for at least one component.
1450 */
12f996ed
FB
1451static int av_has_timings(AVFormatContext *ic)
1452{
1453 int i;
1454 AVStream *st;
1455
1456 for(i = 0;i < ic->nb_streams; i++) {
1457 st = ic->streams[i];
1458 if (st->start_time != AV_NOPTS_VALUE &&
1459 st->duration != AV_NOPTS_VALUE)
1460 return 1;
1461 }
1462 return 0;
1463}
1464
e36bdf8b
DK
1465/**
1466 * Estimate the stream timings from the one of each components.
1467 *
1468 * Also computes the global bitrate if possible.
1469 */
12f996ed
FB
1470static void av_update_stream_timings(AVFormatContext *ic)
1471{
c0df9d75 1472 int64_t start_time, start_time1, end_time, end_time1;
12f996ed
FB
1473 int i;
1474 AVStream *st;
1475
f27a7268
MR
1476 start_time = INT64_MAX;
1477 end_time = INT64_MIN;
12f996ed
FB
1478 for(i = 0;i < ic->nb_streams; i++) {
1479 st = ic->streams[i];
1480 if (st->start_time != AV_NOPTS_VALUE) {
c0df9d75
MN
1481 start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1482 if (start_time1 < start_time)
1483 start_time = start_time1;
12f996ed 1484 if (st->duration != AV_NOPTS_VALUE) {
c0df9d75
MN
1485 end_time1 = start_time1
1486 + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
12f996ed
FB
1487 if (end_time1 > end_time)
1488 end_time = end_time1;
1489 }
1490 }
1491 }
f27a7268 1492 if (start_time != INT64_MAX) {
12f996ed 1493 ic->start_time = start_time;
f27a7268 1494 if (end_time != INT64_MIN) {
12f996ed
FB
1495 ic->duration = end_time - start_time;
1496 if (ic->file_size > 0) {
1497 /* compute the bit rate */
115329f1 1498 ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
12f996ed
FB
1499 (double)ic->duration;
1500 }
1501 }
1502 }
1503
1504}
1505
1506static void fill_all_stream_timings(AVFormatContext *ic)
1507{
1508 int i;
1509 AVStream *st;
1510
1511 av_update_stream_timings(ic);
1512 for(i = 0;i < ic->nb_streams; i++) {
1513 st = ic->streams[i];
1514 if (st->start_time == AV_NOPTS_VALUE) {
c0df9d75
MN
1515 if(ic->start_time != AV_NOPTS_VALUE)
1516 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1517 if(ic->duration != AV_NOPTS_VALUE)
1518 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
12f996ed
FB
1519 }
1520 }
1521}
1522
1523static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1524{
1525 int64_t filesize, duration;
1526 int bit_rate, i;
1527 AVStream *st;
1528
1529 /* if bit_rate is already set, we believe it */
1530 if (ic->bit_rate == 0) {
1531 bit_rate = 0;
1532 for(i=0;i<ic->nb_streams;i++) {
1533 st = ic->streams[i];
01f4895c 1534 bit_rate += st->codec->bit_rate;
12f996ed
FB
1535 }
1536 ic->bit_rate = bit_rate;
1537 }
1538
1539 /* if duration is already set, we believe it */
115329f1
DB
1540 if (ic->duration == AV_NOPTS_VALUE &&
1541 ic->bit_rate != 0 &&
12f996ed
FB
1542 ic->file_size != 0) {
1543 filesize = ic->file_size;
1544 if (filesize > 0) {
12f996ed
FB
1545 for(i = 0; i < ic->nb_streams; i++) {
1546 st = ic->streams[i];
c0df9d75 1547 duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
12f996ed
FB
1548 if (st->start_time == AV_NOPTS_VALUE ||
1549 st->duration == AV_NOPTS_VALUE) {
1550 st->start_time = 0;
1551 st->duration = duration;
1552 }
1553 }
1554 }
1555 }
1556}
1557
12f996ed
FB
1558#define DURATION_MAX_READ_SIZE 250000
1559
1560/* only usable for MPEG-PS streams */
9ecf7fad 1561static void av_estimate_timings_from_pts(AVFormatContext *ic, offset_t old_offset)
12f996ed
FB
1562{
1563 AVPacket pkt1, *pkt = &pkt1;
1564 AVStream *st;
1565 int read_size, i, ret;
bf4e3bd2 1566 int64_t end_time;
12f996ed 1567 int64_t filesize, offset, duration;
115329f1 1568
fb2758c8
FB
1569 /* free previous packet */
1570 if (ic->cur_st && ic->cur_st->parser)
115329f1 1571 av_free_packet(&ic->cur_pkt);
fb2758c8
FB
1572 ic->cur_st = NULL;
1573
1574 /* flush packet queue */
1575 flush_packet_queue(ic);
fb2758c8 1576
0ff7199f
MN
1577 for(i=0;i<ic->nb_streams;i++) {
1578 st = ic->streams[i];
1579 if (st->parser) {
1580 av_parser_close(st->parser);
1581 st->parser= NULL;
1582 }
1583 }
115329f1 1584
12f996ed
FB
1585 /* we read the first packets to get the first PTS (not fully
1586 accurate, but it is enough now) */
1587 url_fseek(&ic->pb, 0, SEEK_SET);
1588 read_size = 0;
1589 for(;;) {
1590 if (read_size >= DURATION_MAX_READ_SIZE)
1591 break;
1592 /* if all info is available, we can stop */
1593 for(i = 0;i < ic->nb_streams; i++) {
1594 st = ic->streams[i];
1595 if (st->start_time == AV_NOPTS_VALUE)
1596 break;
1597 }
1598 if (i == ic->nb_streams)
1599 break;
1600
1601 ret = av_read_packet(ic, pkt);
1602 if (ret != 0)
1603 break;
1604 read_size += pkt->size;
1605 st = ic->streams[pkt->stream_index];
1606 if (pkt->pts != AV_NOPTS_VALUE) {
1607 if (st->start_time == AV_NOPTS_VALUE)
c0df9d75 1608 st->start_time = pkt->pts;
0a5f92a1
MN
1609 }
1610 av_free_packet(pkt);
1611 }
12f996ed 1612
12f996ed
FB
1613 /* estimate the end time (duration) */
1614 /* XXX: may need to support wrapping */
1615 filesize = ic->file_size;
1616 offset = filesize - DURATION_MAX_READ_SIZE;
1617 if (offset < 0)
1618 offset = 0;
1619
12f996ed
FB
1620 url_fseek(&ic->pb, offset, SEEK_SET);
1621 read_size = 0;
1622 for(;;) {
1623 if (read_size >= DURATION_MAX_READ_SIZE)
1624 break;
1625 /* if all info is available, we can stop */
1626 for(i = 0;i < ic->nb_streams; i++) {
1627 st = ic->streams[i];
1628 if (st->duration == AV_NOPTS_VALUE)
1629 break;
1630 }
1631 if (i == ic->nb_streams)
1632 break;
115329f1 1633
12f996ed
FB
1634 ret = av_read_packet(ic, pkt);
1635 if (ret != 0)
1636 break;
1637 read_size += pkt->size;
1638 st = ic->streams[pkt->stream_index];
1639 if (pkt->pts != AV_NOPTS_VALUE) {
c0df9d75 1640 end_time = pkt->pts;
12f996ed
FB
1641 duration = end_time - st->start_time;
1642 if (duration > 0) {
1643 if (st->duration == AV_NOPTS_VALUE ||
1644 st->duration < duration)
1645 st->duration = duration;
1646 }
1647 }
1648 av_free_packet(pkt);
1649 }
115329f1 1650
c0df9d75 1651 fill_all_stream_timings(ic);
12f996ed 1652
9ecf7fad 1653 url_fseek(&ic->pb, old_offset, SEEK_SET);
12f996ed
FB
1654}
1655
9ecf7fad 1656static void av_estimate_timings(AVFormatContext *ic, offset_t old_offset)
12f996ed 1657{
12f996ed
FB
1658 int64_t file_size;
1659
1660 /* get the file size, if possible */
1661 if (ic->iformat->flags & AVFMT_NOFILE) {
1662 file_size = 0;
1663 } else {
a965c478 1664 file_size = url_fsize(&ic->pb);
12f996ed
FB
1665 if (file_size < 0)
1666 file_size = 0;
1667 }
1668 ic->file_size = file_size;
1669
ff70e601
MR
1670 if ((!strcmp(ic->iformat->name, "mpeg") ||
1671 !strcmp(ic->iformat->name, "mpegts")) &&
1672 file_size && !ic->pb.is_streamed) {
12f996ed 1673 /* get accurate estimate from the PTSes */
9ecf7fad 1674 av_estimate_timings_from_pts(ic, old_offset);
12f996ed
FB
1675 } else if (av_has_timings(ic)) {
1676 /* at least one components has timings - we use them for all
1677 the components */
1678 fill_all_stream_timings(ic);
1679 } else {
1680 /* less precise: use bit rate info */
1681 av_estimate_timings_from_bit_rate(ic);
1682 }
1683 av_update_stream_timings(ic);
1684
1685#if 0
1686 {
1687 int i;
1688 AVStream *st;
1689 for(i = 0;i < ic->nb_streams; i++) {
1690 st = ic->streams[i];
115329f1
DB
1691 printf("%d: start_time: %0.3f duration: %0.3f\n",
1692 i, (double)st->start_time / AV_TIME_BASE,
12f996ed
FB
1693 (double)st->duration / AV_TIME_BASE);
1694 }
115329f1
DB
1695 printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1696 (double)ic->start_time / AV_TIME_BASE,
12f996ed
FB
1697 (double)ic->duration / AV_TIME_BASE,
1698 ic->bit_rate / 1000);
1699 }
1700#endif
1701}
1702
b9a281db
FB
1703static int has_codec_parameters(AVCodecContext *enc)
1704{
1705 int val;
1706 switch(enc->codec_type) {
1707 case CODEC_TYPE_AUDIO:
1708 val = enc->sample_rate;
1709 break;
1710 case CODEC_TYPE_VIDEO:
644a9262 1711 val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
b9a281db
FB
1712 break;
1713 default:
1714 val = 1;
1715 break;
1716 }
1717 return (val != 0);
1718}
1719
fb2758c8
FB
1720static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1721{
1722 int16_t *samples;
1723 AVCodec *codec;
43c0040a 1724 int got_picture, ret=0;
fb2758c8 1725 AVFrame picture;
115329f1 1726
01f4895c
MN
1727 if(!st->codec->codec){
1728 codec = avcodec_find_decoder(st->codec->codec_id);
fb2758c8
FB
1729 if (!codec)
1730 return -1;
01f4895c 1731 ret = avcodec_open(st->codec, codec);
fb2758c8
FB
1732 if (ret < 0)
1733 return ret;
43c0040a 1734 }
644a9262 1735
01f4895c
MN
1736 if(!has_codec_parameters(st->codec)){
1737 switch(st->codec->codec_type) {
fb2758c8 1738 case CODEC_TYPE_VIDEO:
115329f1 1739 ret = avcodec_decode_video(st->codec, &picture,
fb2758c8
FB
1740 &got_picture, (uint8_t *)data, size);
1741 break;
1742 case CODEC_TYPE_AUDIO:
1743 samples = av_malloc(AVCODEC_MAX_AUDIO_FRAME_SIZE);
1744 if (!samples)
1745 goto fail;
115329f1 1746 ret = avcodec_decode_audio(st->codec, samples,
fb2758c8
FB
1747 &got_picture, (uint8_t *)data, size);
1748 av_free(samples);
1749 break;
1750 default:
1751 break;
1752 }
644a9262 1753 }
fb2758c8 1754 fail:
fb2758c8
FB
1755 return ret;
1756}
1757
1758/* absolute maximum size we read until we abort */
1759#define MAX_READ_SIZE 5000000
1760
fd97f6a2 1761#define MAX_STD_TIMEBASES (60*12+5)
4d43cbcc
MN
1762static int get_std_framerate(int i){
1763 if(i<60*12) return i*1001;
fd97f6a2 1764 else return ((int[]){24,30,60,12,15})[i-60*12]*1000*12;
4d43cbcc
MN
1765}
1766
b9a281db 1767/**
9ecf7fad 1768 * Read packets of a media file to get stream information. This
b9a281db 1769 * is useful for file formats with no headers such as MPEG. This
9ecf7fad 1770 * function also computes the real frame rate in case of mpeg2 repeat
b9a281db 1771 * frame mode.
9ecf7fad
WG
1772 * The logical file position is not changed by this function;
1773 * examined packets may be buffered for later processing.
b9a281db
FB
1774 *
1775 * @param ic media file handle
115329f1 1776 * @return >=0 if OK. AVERROR_xxx if error.
644a9262 1777 * @todo let user decide somehow what information is needed so we dont waste time geting stuff the user doesnt need
b9a281db
FB
1778 */
1779int av_find_stream_info(AVFormatContext *ic)
1780{
9f75260e 1781 int i, count, ret, read_size, j;
b9a281db 1782 AVStream *st;
fb2758c8 1783 AVPacket pkt1, *pkt;
b9a281db 1784 AVPacketList *pktl=NULL, **ppktl;
15bc38e5 1785 int64_t last_dts[MAX_STREAMS];
3c150d16 1786 int duration_count[MAX_STREAMS]={0};
4d43cbcc 1787 double duration_error[MAX_STREAMS][MAX_STD_TIMEBASES]={{0}}; //FIXME malloc()?
9ecf7fad 1788 offset_t old_offset = url_ftell(&ic->pb);
b9a281db 1789
c0df9d75
MN
1790 for(i=0;i<ic->nb_streams;i++) {
1791 st = ic->streams[i];
01f4895c 1792 if(st->codec->codec_type == CODEC_TYPE_VIDEO){
c0df9d75
MN
1793/* if(!st->time_base.num)
1794 st->time_base= */
01f4895c
MN
1795 if(!st->codec->time_base.num)
1796 st->codec->time_base= st->time_base;
c0df9d75 1797 }
90ad92b3
MN
1798 //only for the split stuff
1799 if (!st->parser) {
01f4895c 1800 st->parser = av_parser_init(st->codec->codec_id);
7cbaa7ba
MN
1801 if(st->need_parsing == 2 && st->parser){
1802 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1803 }
90ad92b3 1804 }
c0df9d75
MN
1805 }
1806
15bc38e5
MN
1807 for(i=0;i<MAX_STREAMS;i++){
1808 last_dts[i]= AV_NOPTS_VALUE;
15bc38e5 1809 }
115329f1 1810
b9a281db
FB
1811 count = 0;
1812 read_size = 0;
1813 ppktl = &ic->packet_buffer;
1814 for(;;) {
1815 /* check if one codec still needs to be handled */
1816 for(i=0;i<ic->nb_streams;i++) {
1817 st = ic->streams[i];
01f4895c 1818 if (!has_codec_parameters(st->codec))
b9a281db 1819 break;
3e76d1b5 1820 /* variable fps and no guess at the real fps */
9f75260e 1821 if( st->codec->time_base.den >= 101LL*st->codec->time_base.num
01f4895c 1822 && duration_count[i]<20 && st->codec->codec_type == CODEC_TYPE_VIDEO)
3e76d1b5 1823 break;
01f4895c 1824 if(st->parser && st->parser->parser->split && !st->codec->extradata)
90ad92b3 1825 break;
b9a281db
FB
1826 }
1827 if (i == ic->nb_streams) {
1828 /* NOTE: if the format has no header, then we need to read
1829 some packets to get most of the streams, so we cannot
1830 stop here */
fb2758c8 1831 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
b9a281db
FB
1832 /* if we found the info for all the codecs, we can stop */
1833 ret = count;
1834 break;
1835 }
5fb83c38 1836 }
35eab0c0
MN
1837 /* we did not get all the codec info, but we read too much data */
1838 if (read_size >= MAX_READ_SIZE) {
1839 ret = count;
1840 break;
1841 }
b9a281db 1842
fb2758c8
FB
1843 /* NOTE: a new stream can be added there if no header in file
1844 (AVFMTCTX_NOHEADER) */
1845 ret = av_read_frame_internal(ic, &pkt1);
1846 if (ret < 0) {
1847 /* EOF or error */
1848 ret = -1; /* we could not have all the codec parameters before EOF */
e19456e3
MN
1849 for(i=0;i<ic->nb_streams;i++) {
1850 st = ic->streams[i];
305ee50f
MN
1851 if (!has_codec_parameters(st->codec)){
1852 char buf[256];
1853 avcodec_string(buf, sizeof(buf), st->codec, 0);
1854 av_log(ic, AV_LOG_INFO, "Could not find codec parameters (%s)\n", buf);
344a18c3
MR
1855 } else {
1856 ret = 0;
305ee50f 1857 }
e19456e3 1858 }
fb2758c8
FB
1859 break;
1860 }
1861
b9a281db
FB
1862 pktl = av_mallocz(sizeof(AVPacketList));
1863 if (!pktl) {
1864 ret = AVERROR_NOMEM;
1865 break;
1866 }
1867
1868 /* add the packet in the buffered packet list */
1869 *ppktl = pktl;
1870 ppktl = &pktl->next;
1871
b9a281db 1872 pkt = &pktl->pkt;
fb2758c8 1873 *pkt = pkt1;
115329f1 1874
fb2758c8
FB
1875 /* duplicate the packet */
1876 if (av_dup_packet(pkt) < 0) {
e344c1ea
SH
1877 ret = AVERROR_NOMEM;
1878 break;
b9a281db 1879 }
b9a281db 1880
fb2758c8 1881 read_size += pkt->size;
b9a281db
FB
1882
1883 st = ic->streams[pkt->stream_index];
4b96d28a
MN
1884 if(st->codec_info_nb_frames>1) //FIXME move codec_info_nb_frames and codec_info_duration from AVStream into this func
1885 st->codec_info_duration += pkt->duration;
fb2758c8
FB
1886 if (pkt->duration != 0)
1887 st->codec_info_nb_frames++;
1888
cefe0607 1889 {
3c150d16
MN
1890 int index= pkt->stream_index;
1891 int64_t last= last_dts[index];
1892 int64_t duration= pkt->dts - last;
1893
1894 if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
4d43cbcc
MN
1895 double dur= duration * av_q2d(st->time_base);
1896
1897// if(st->codec->codec_type == CODEC_TYPE_VIDEO)
1898// av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
1694118b
MN
1899 if(duration_count[index] < 2)
1900 memset(duration_error, 0, sizeof(duration_error));
69c262d1
MN
1901 for(i=1; i<MAX_STD_TIMEBASES; i++){
1902 int framerate= get_std_framerate(i);
1903 int ticks= lrintf(dur*framerate/(1001*12));
1904 double error= dur - ticks*1001*12/(double)framerate;
1905 duration_error[index][i] += error*error;
1906 }
4d43cbcc
MN
1907 duration_count[index]++;
1908
43c0040a 1909 if(st->codec_info_nb_frames == 0 && 0)
cefe0607 1910 st->codec_info_duration += duration;
15bc38e5 1911 }
fd97f6a2
MN
1912 if(last == AV_NOPTS_VALUE || duration_count[index]<=1)
1913 last_dts[pkt->stream_index]= pkt->dts;
15bc38e5 1914 }
01f4895c
MN
1915 if(st->parser && st->parser->parser->split && !st->codec->extradata){
1916 int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
90ad92b3 1917 if(i){
01f4895c 1918 st->codec->extradata_size= i;
62c52121 1919 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
01f4895c 1920 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
62c52121 1921 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
90ad92b3
MN
1922 }
1923 }
115329f1 1924
fb2758c8
FB
1925 /* if still no information, we try to open the codec and to
1926 decompress the frame. We try to avoid that in most cases as
1927 it takes longer and uses more memory. For MPEG4, we need to
1928 decompress for Quicktime. */
01f4895c
MN
1929 if (!has_codec_parameters(st->codec) /*&&
1930 (st->codec->codec_id == CODEC_ID_FLV1 ||
1931 st->codec->codec_id == CODEC_ID_H264 ||
1932 st->codec->codec_id == CODEC_ID_H263 ||
1933 st->codec->codec_id == CODEC_ID_H261 ||
1934 st->codec->codec_id == CODEC_ID_VORBIS ||
1935 st->codec->codec_id == CODEC_ID_MJPEG ||
1936 st->codec->codec_id == CODEC_ID_PNG ||
1937 st->codec->codec_id == CODEC_ID_PAM ||
1938 st->codec->codec_id == CODEC_ID_PGM ||
1939 st->codec->codec_id == CODEC_ID_PGMYUV ||
1940 st->codec->codec_id == CODEC_ID_PBM ||
1941 st->codec->codec_id == CODEC_ID_PPM ||
1942 st->codec->codec_id == CODEC_ID_SHORTEN ||
1943 (st->codec->codec_id == CODEC_ID_MPEG4 && !st->need_parsing))*/)
fb2758c8 1944 try_decode_frame(st, pkt->data, pkt->size);
115329f1 1945
a44b3c4d 1946 if (av_rescale_q(st->codec_info_duration, st->time_base, AV_TIME_BASE_Q) >= ic->max_analyze_duration) {
fb2758c8 1947 break;
b9a281db
FB
1948 }
1949 count++;
1950 }
1951
43c0040a
MN
1952 // close codecs which where opened in try_decode_frame()
1953 for(i=0;i<ic->nb_streams;i++) {
1954 st = ic->streams[i];
01f4895c
MN
1955 if(st->codec->codec)
1956 avcodec_close(st->codec);
43c0040a 1957 }
b9a281db
FB
1958 for(i=0;i<ic->nb_streams;i++) {
1959 st = ic->streams[i];
01f4895c
MN
1960 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1961 if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_sample)
1962 st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
15bc38e5 1963
1694118b 1964 if(duration_count[i]
4d43cbcc 1965 && (st->codec->time_base.num*101LL <= st->codec->time_base.den || st->codec->codec_id == CODEC_ID_MPEG2VIDEO) /*&&
730ba406 1966 //FIXME we should not special case mpeg2, but this needs testing with non mpeg2 ...
4d43cbcc
MN
1967 st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den*/){
1968 double best_error= 2*av_q2d(st->time_base);
1969 best_error= best_error*best_error*duration_count[i]*1000*12*30;
1970
1971 for(j=1; j<MAX_STD_TIMEBASES; j++){
1972 double error= duration_error[i][j] * get_std_framerate(j);
1973// if(st->codec->codec_type == CODEC_TYPE_VIDEO)
1974// av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
9f75260e
MN
1975 if(error < best_error){
1976 best_error= error;
4d43cbcc 1977 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, get_std_framerate(j), 12*1001, INT_MAX);
9f75260e 1978 }
3c150d16 1979 }
15bc38e5
MN
1980 }
1981
c0df9d75 1982 if (!st->r_frame_rate.num){
5523d5f4
MN
1983 if( st->codec->time_base.den * (int64_t)st->time_base.num
1984 <= st->codec->time_base.num * (int64_t)st->time_base.den){
1985 st->r_frame_rate.num = st->codec->time_base.den;
1986 st->r_frame_rate.den = st->codec->time_base.num;
1987 }else{
1988 st->r_frame_rate.num = st->time_base.den;
1989 st->r_frame_rate.den = st->time_base.num;
1990 }
14bea432 1991 }
b9a281db 1992 }
de6d9b64 1993 }
b9a281db 1994
9ecf7fad 1995 av_estimate_timings(ic, old_offset);
e928649b
MN
1996#if 0
1997 /* correct DTS for b frame streams with no timestamps */
1998 for(i=0;i<ic->nb_streams;i++) {
1999 st = ic->streams[i];
01f4895c 2000 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
e928649b
MN
2001 if(b-frames){
2002 ppktl = &ic->packet_buffer;
2003 while(ppkt1){
2004 if(ppkt1->stream_index != i)
2005 continue;
2006 if(ppkt1->pkt->dts < 0)
2007 break;
2008 if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2009 break;
2010 ppkt1->pkt->dts -= delta;
2011 ppkt1= ppkt1->next;
2012 }
2013 if(ppkt1)
2014 continue;
2015 st->cur_dts -= delta;
2016 }
2017 }
2018 }
2019#endif
b9a281db 2020 return ret;
de6d9b64
FB
2021}
2022
fb2758c8
FB
2023/*******************************************************/
2024
2025/**
2026 * start playing a network based stream (e.g. RTSP stream) at the
115329f1 2027 * current position
fb2758c8
FB
2028 */
2029int av_read_play(AVFormatContext *s)
2030{
2031 if (!s->iformat->read_play)
2032 return AVERROR_NOTSUPP;
2033 return s->iformat->read_play(s);
2034}
2035
2036/**
e36bdf8b
DK
2037 * Pause a network based stream (e.g. RTSP stream).
2038 *
2039 * Use av_read_play() to resume it.
fb2758c8
FB
2040 */
2041int av_read_pause(AVFormatContext *s)
2042{
2043 if (!s->iformat->read_pause)
2044 return AVERROR_NOTSUPP;
2045 return s->iformat->read_pause(s);
2046}
2047
b9a281db 2048/**
e36bdf8b 2049 * Close a media file (but not its codecs).
b9a281db
FB
2050 *
2051 * @param s media file handle
2052 */
de6d9b64
FB
2053void av_close_input_file(AVFormatContext *s)
2054{
b6892136 2055 int i, must_open_file;
da24c5e3 2056 AVStream *st;
de6d9b64 2057
fb2758c8
FB
2058 /* free previous packet */
2059 if (s->cur_st && s->cur_st->parser)
115329f1 2060 av_free_packet(&s->cur_pkt);
fb2758c8 2061
b9a281db
FB
2062 if (s->iformat->read_close)
2063 s->iformat->read_close(s);
de6d9b64 2064 for(i=0;i<s->nb_streams;i++) {
da24c5e3
FB
2065 /* free all data in a stream component */
2066 st = s->streams[i];
fb2758c8
FB
2067 if (st->parser) {
2068 av_parser_close(st->parser);
de6d9b64 2069 }
fb2758c8 2070 av_free(st->index_entries);
a5e9102b 2071 av_free(st->codec->extradata);
01f4895c 2072 av_free(st->codec);
fb2758c8 2073 av_free(st);
de6d9b64 2074 }
fb2758c8 2075 flush_packet_queue(s);
b6892136 2076 must_open_file = 1;
da24c5e3 2077 if (s->iformat->flags & AVFMT_NOFILE) {
b6892136
FB
2078 must_open_file = 0;
2079 }
2080 if (must_open_file) {
96baaa6a
FB
2081 url_fclose(&s->pb);
2082 }
a8dbe951 2083 av_freep(&s->priv_data);
1ea4f593 2084 av_free(s);
de6d9b64
FB
2085}
2086
b9a281db 2087/**
e36bdf8b 2088 * Add a new stream to a media file.
b9a281db 2089 *
e36bdf8b
DK
2090 * Can only be called in the read_header() function. If the flag
2091 * AVFMTCTX_NOHEADER is in the format context, then new streams
2092 * can be added in read_packet too.
b9a281db
FB
2093 *
2094 * @param s media file handle
115329f1 2095 * @param id file format dependent stream id
b9a281db
FB
2096 */
2097AVStream *av_new_stream(AVFormatContext *s, int id)
2098{
2099 AVStream *st;
504ee036 2100 int i;
b9a281db
FB
2101
2102 if (s->nb_streams >= MAX_STREAMS)
2103 return NULL;
2104
2105 st = av_mallocz(sizeof(AVStream));
2106 if (!st)
2107 return NULL;
115329f1 2108
01f4895c 2109 st->codec= avcodec_alloc_context();
48091512
FB
2110 if (s->iformat) {
2111 /* no default bitrate if decoding */
01f4895c 2112 st->codec->bit_rate = 0;
48091512 2113 }
b9a281db
FB
2114 st->index = s->nb_streams;
2115 st->id = id;
12f996ed
FB
2116 st->start_time = AV_NOPTS_VALUE;
2117 st->duration = AV_NOPTS_VALUE;
e928649b 2118 st->cur_dts = AV_NOPTS_VALUE;
9ee91c2f
MN
2119
2120 /* default pts settings is MPEG like */
2121 av_set_pts_info(st, 33, 1, 90000);
77405fc8 2122 st->last_IP_pts = AV_NOPTS_VALUE;
504ee036
MN
2123 for(i=0; i<MAX_REORDER_DELAY+1; i++)
2124 st->pts_buffer[i]= AV_NOPTS_VALUE;
9ee91c2f 2125
b9a281db
FB
2126 s->streams[s->nb_streams++] = st;
2127 return st;
2128}
2129
2130/************************************************************/
2131/* output media file */
de6d9b64 2132
87a0a681
FB
2133int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2134{
2135 int ret;
115329f1 2136
98486a6b
RS
2137 if (s->oformat->priv_data_size > 0) {
2138 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2139 if (!s->priv_data)
2140 return AVERROR_NOMEM;
2141 } else
2142 s->priv_data = NULL;
115329f1 2143
87a0a681
FB
2144 if (s->oformat->set_parameters) {
2145 ret = s->oformat->set_parameters(s, ap);
2146 if (ret < 0)
2147 return ret;
2148 }
2149 return 0;
2150}
2151
b9a281db
FB
2152/**
2153 * allocate the stream private data and write the stream header to an
2154 * output media file
2155 *
2156 * @param s media file handle
115329f1 2157 * @return 0 if OK. AVERROR_xxx if error.
b9a281db
FB
2158 */
2159int av_write_header(AVFormatContext *s)
2160{
1e51d801
FB
2161 int ret, i;
2162 AVStream *st;
2163
9450118b
MN
2164 // some sanity checks
2165 for(i=0;i<s->nb_streams;i++) {
2166 st = s->streams[i];
2167
2168 switch (st->codec->codec_type) {
2169 case CODEC_TYPE_AUDIO:
2170 if(st->codec->sample_rate<=0){
2171 av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2172 return -1;
2173 }
2174 break;
2175 case CODEC_TYPE_VIDEO:
2176 if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2177 av_log(s, AV_LOG_ERROR, "time base not set\n");
2178 return -1;
2179 }
2180 if(st->codec->width<=0 || st->codec->height<=0){
2181 av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2182 return -1;
2183 }
2184 break;
2185 }
5ecfa9f5
MN
2186
2187 if(s->oformat->codec_tag){
2188 if(st->codec->codec_tag){
2189 //FIXME
2190 //check that tag + id is in the table
2191 //if neither is in the table -> ok
2192 //if tag is in the table with another id -> FAIL
2193 //if id is in the table with another tag -> FAIL unless strict < ?
2194 }else
2195 st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2196 }
9450118b
MN
2197 }
2198
8fae2df5 2199 if (!s->priv_data && s->oformat->priv_data_size > 0) {
c6efa4b5
BC
2200 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2201 if (!s->priv_data)
2202 return AVERROR_NOMEM;
8fae2df5 2203 }
c6efa4b5 2204
31e11451
MN
2205 if(s->oformat->write_header){
2206 ret = s->oformat->write_header(s);
2207 if (ret < 0)
2208 return ret;
2209 }
1e51d801
FB
2210
2211 /* init PTS generation */
2212 for(i=0;i<s->nb_streams;i++) {
f0ff20a1 2213 int64_t den = AV_NOPTS_VALUE;
1e51d801
FB
2214 st = s->streams[i];
2215
01f4895c 2216 switch (st->codec->codec_type) {
1e51d801 2217 case CODEC_TYPE_AUDIO:
f0ff20a1 2218 den = (int64_t)st->time_base.num * st->codec->sample_rate;
1e51d801
FB
2219 break;
2220 case CODEC_TYPE_VIDEO:
f0ff20a1 2221 den = (int64_t)st->time_base.num * st->codec->time_base.den;
1e51d801
FB
2222 break;
2223 default:
2224 break;
2225 }
f0ff20a1
WG
2226 if (den != AV_NOPTS_VALUE) {
2227 if (den <= 0)
2228 return AVERROR_INVALIDDATA;
2229 av_frac_init(&st->pts, 0, 0, den);
2230 }
1e51d801
FB
2231 }
2232 return 0;
b9a281db
FB
2233}
2234
3c895fc0 2235//FIXME merge with compute_pkt_fields
5edea431 2236static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
504ee036
MN
2237 int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2238 int num, den, frame_size, i;
b0c7f5a9 2239
949b1a13 2240// 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 2241
e928649b
MN
2242/* if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2243 return -1;*/
115329f1 2244
e928649b 2245 /* duration field */
3c895fc0
MN
2246 if (pkt->duration == 0) {
2247 compute_frame_duration(&num, &den, st, NULL, pkt);
2248 if (den && num) {
2249 pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
2250 }
2251 }
e928649b
MN
2252
2253 //XXX/FIXME this is a temporary hack until all encoders output pts
504ee036 2254 if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
e928649b
MN
2255 pkt->dts=
2256// pkt->pts= st->cur_dts;
2257 pkt->pts= st->pts.val;
2258 }
2259
115329f1 2260 //calculate dts from pts
e928649b 2261 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE){
504ee036
MN
2262 st->pts_buffer[0]= pkt->pts;
2263 for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2264 st->pts_buffer[i]= (i-delay-1) * pkt->duration;
2265 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
1345f4ed 2266 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
504ee036
MN
2267
2268 pkt->dts= st->pts_buffer[0];
e928649b 2269 }
115329f1 2270
5edea431 2271 if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
4733abcb 2272 av_log(NULL, AV_LOG_ERROR, "error, non monotone timestamps %"PRId64" >= %"PRId64"\n", st->cur_dts, pkt->dts);
5edea431
MN
2273 return -1;
2274 }
2275 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2276 av_log(NULL, AV_LOG_ERROR, "error, pts < dts\n");
2277 return -1;
2278 }
2279
949b1a13 2280// av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
e928649b
MN
2281 st->cur_dts= pkt->dts;
2282 st->pts.val= pkt->dts;
2283
1e51d801 2284 /* update pts */
01f4895c 2285 switch (st->codec->codec_type) {
1e51d801 2286 case CODEC_TYPE_AUDIO:
01f4895c 2287 frame_size = get_audio_frame_size(st->codec, pkt->size);
6d8f985e 2288
b0c7f5a9 2289 /* HACK/FIXME, we skip the initial 0-size packets as they are most likely equal to the encoder delay,
6d8f985e 2290 but it would be better if we had the real timestamps from the encoder */
e928649b 2291 if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
9ee91c2f 2292 av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
7feb950a 2293 }
1e51d801
FB
2294 break;
2295 case CODEC_TYPE_VIDEO:
01f4895c 2296 av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
1e51d801
FB
2297 break;
2298 default:
2299 break;
2300 }
5edea431 2301 return 0;
3c895fc0
MN
2302}
2303
2304static void truncate_ts(AVStream *st, AVPacket *pkt){
2305 int64_t pts_mask = (2LL << (st->pts_wrap_bits-1)) - 1;
115329f1 2306
e0c91bc2
MN
2307// if(pkt->dts < 0)
2308// pkt->dts= 0; //this happens for low_delay=0 and b frames, FIXME, needs further invstigation about what we should do here
115329f1 2309
68a432cf 2310 if (pkt->pts != AV_NOPTS_VALUE)
8533284d 2311 pkt->pts &= pts_mask;
68a432cf 2312 if (pkt->dts != AV_NOPTS_VALUE)
8533284d 2313 pkt->dts &= pts_mask;
3c895fc0
MN
2314}
2315
2316/**
e36bdf8b
DK
2317 * Write a packet to an output media file.
2318 *
2319 * The packet shall contain one audio or video frame.
5a461d8e
MN
2320 * The packet must be correctly interleaved according to the container specification,
2321 * if not then av_interleaved_write_frame must be used
3c895fc0
MN
2322 *
2323 * @param s media file handle
2324 * @param pkt the packet, which contains the stream_index, buf/buf_size, dts/pts, ...
2325 * @return < 0 if error, = 0 if OK, 1 if end of stream wanted.
2326 */
2327int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2328{
576ae256
MN
2329 int ret;
2330
5edea431 2331 ret=compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
494bbf58 2332 if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
5edea431 2333 return ret;
115329f1 2334
3c895fc0
MN
2335 truncate_ts(s->streams[pkt->stream_index], pkt);
2336
576ae256
MN
2337 ret= s->oformat->write_packet(s, pkt);
2338 if(!ret)
2339 ret= url_ferror(&s->pb);
2340 return ret;
3c895fc0
MN
2341}
2342
2343/**
81f0f938
BC
2344 * Interleave a packet per DTS in an output media file.
2345 *
2346 * Packets with pkt->destruct == av_destruct_packet will be freed inside this function,
2347 * so they cannot be used after it, note calling av_free_packet() on them is still safe.
2348 *
2349 * @param s media file handle
2350 * @param out the interleaved packet will be output here
2351 * @param in the input packet
2352 * @param flush 1 if no further packets are available as input and all
2353 * remaining packets should be output
2354 * @return 1 if a packet was output, 0 if no packet could be output,
2355 * < 0 if an error occured
fe2d6fe2 2356 */
f21c0b4c 2357int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
fe2d6fe2
MN
2358 AVPacketList *pktl, **next_point, *this_pktl;
2359 int stream_count=0;
2360 int streams[MAX_STREAMS];
2361
2362 if(pkt){
2363 AVStream *st= s->streams[ pkt->stream_index];
2364
2577897d 2365// assert(pkt->destruct != av_destruct_packet); //FIXME
fe2d6fe2
MN
2366
2367 this_pktl = av_mallocz(sizeof(AVPacketList));
2368 this_pktl->pkt= *pkt;
2577897d
MN
2369 if(pkt->destruct == av_destruct_packet)
2370 pkt->destruct= NULL; // non shared -> must keep original from being freed
2371 else
2372 av_dup_packet(&this_pktl->pkt); //shared -> must dup
fe2d6fe2
MN
2373
2374 next_point = &s->packet_buffer;
2375 while(*next_point){
2376 AVStream *st2= s->streams[ (*next_point)->pkt.stream_index];
2377 int64_t left= st2->time_base.num * (int64_t)st ->time_base.den;
2378 int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2379 if((*next_point)->pkt.dts * left > pkt->dts * right) //FIXME this can overflow
2380 break;
2381 next_point= &(*next_point)->next;
2382 }
2383 this_pktl->next= *next_point;
2384 *next_point= this_pktl;
2385 }
115329f1 2386
fe2d6fe2
MN
2387 memset(streams, 0, sizeof(streams));
2388 pktl= s->packet_buffer;
2389 while(pktl){
949b1a13 2390//av_log(s, AV_LOG_DEBUG, "show st:%d dts:%"PRId64"\n", pktl->pkt.stream_index, pktl->pkt.dts);
fe2d6fe2
MN
2391 if(streams[ pktl->pkt.stream_index ] == 0)
2392 stream_count++;
2393 streams[ pktl->pkt.stream_index ]++;
2394 pktl= pktl->next;
2395 }
115329f1 2396
fe2d6fe2
MN
2397 if(s->nb_streams == stream_count || (flush && stream_count)){
2398 pktl= s->packet_buffer;
2399 *out= pktl->pkt;
115329f1
DB
2400
2401 s->packet_buffer= pktl->next;
fe2d6fe2
MN
2402 av_freep(&pktl);
2403 return 1;
2404 }else{
2405 av_init_packet(out);
2406 return 0;
2407 }
2408}
2409
2410/**
2411 * Interleaves a AVPacket correctly so it can be muxed.
2412 * @param out the interleaved packet will be output here
2413 * @param in the input packet
2414 * @param flush 1 if no further packets are available as input and all
2415 * remaining packets should be output
115329f1 2416 * @return 1 if a packet was output, 0 if no packet could be output,
fe2d6fe2
MN
2417 * < 0 if an error occured
2418 */
2419static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2420 if(s->oformat->interleave_packet)
2421 return s->oformat->interleave_packet(s, out, in, flush);
2422 else
2423 return av_interleave_packet_per_dts(s, out, in, flush);
2424}
2425
2426/**
e36bdf8b
DK
2427 * Writes a packet to an output media file ensuring correct interleaving.
2428 *
2429 * The packet must contain one audio or video frame.
3c895fc0
MN
2430 * If the packets are already correctly interleaved the application should
2431 * call av_write_frame() instead as its slightly faster, its also important
fe2d6fe2 2432 * to keep in mind that completly non interleaved input will need huge amounts
3c895fc0
MN
2433 * of memory to interleave with this, so its prefereable to interleave at the
2434 * demuxer level
2435 *
2436 * @param s media file handle
2437 * @param pkt the packet, which contains the stream_index, buf/buf_size, dts/pts, ...
2438 * @return < 0 if error, = 0 if OK, 1 if end of stream wanted.
2439 */
2440int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
3c895fc0
MN
2441 AVStream *st= s->streams[ pkt->stream_index];
2442
6f824977 2443 //FIXME/XXX/HACK drop zero sized packets
01f4895c 2444 if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
6f824977 2445 return 0;
3ce16b30 2446
949b1a13 2447//av_log(NULL, AV_LOG_DEBUG, "av_interleaved_write_frame %d %"PRId64" %"PRId64"\n", pkt->size, pkt->dts, pkt->pts);
494bbf58 2448 if(compute_pkt_fields2(st, pkt) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3ce16b30 2449 return -1;
115329f1 2450
3c895fc0
MN
2451 if(pkt->dts == AV_NOPTS_VALUE)
2452 return -1;
3c895fc0 2453
fe2d6fe2
MN
2454 for(;;){
2455 AVPacket opkt;
2456 int ret= av_interleave_packet(s, &opkt, pkt, 0);
2457 if(ret<=0) //FIXME cleanup needed for ret<0 ?
2458 return ret;
115329f1 2459
fe2d6fe2
MN
2460 truncate_ts(s->streams[opkt.stream_index], &opkt);
2461 ret= s->oformat->write_packet(s, &opkt);
115329f1 2462
fe2d6fe2
MN
2463 av_free_packet(&opkt);
2464 pkt= NULL;
115329f1 2465
3c895fc0
MN
2466 if(ret<0)
2467 return ret;
576ae256
MN
2468 if(url_ferror(&s->pb))
2469 return url_ferror(&s->pb);
3c895fc0 2470 }
b9a281db
FB
2471}
2472
2473/**
e36bdf8b
DK
2474 * @brief Write the stream trailer to an output media file and
2475 * free the file private data.
b9a281db
FB
2476 *
2477 * @param s media file handle
e36bdf8b
DK
2478 * @return 0 if OK. AVERROR_xxx if error.
2479 */
b9a281db
FB
2480int av_write_trailer(AVFormatContext *s)
2481{
c40a3a42 2482 int ret, i;
115329f1 2483
fe2d6fe2
MN
2484 for(;;){
2485 AVPacket pkt;
2486 ret= av_interleave_packet(s, &pkt, NULL, 1);
2487 if(ret<0) //FIXME cleanup needed for ret<0 ?
c40a3a42 2488 goto fail;
fe2d6fe2
MN
2489 if(!ret)
2490 break;
115329f1 2491
fe2d6fe2
MN
2492 truncate_ts(s->streams[pkt.stream_index], &pkt);
2493 ret= s->oformat->write_packet(s, &pkt);
115329f1 2494
fe2d6fe2 2495 av_free_packet(&pkt);
115329f1 2496
3c895fc0 2497 if(ret<0)
c40a3a42 2498 goto fail;
576ae256
MN
2499 if(url_ferror(&s->pb))
2500 goto fail;
3c895fc0
MN
2501 }
2502
31e11451
MN
2503 if(s->oformat->write_trailer)
2504 ret = s->oformat->write_trailer(s);
c40a3a42 2505fail:
576ae256
MN
2506 if(ret == 0)
2507 ret=url_ferror(&s->pb);
c40a3a42
MN
2508 for(i=0;i<s->nb_streams;i++)
2509 av_freep(&s->streams[i]->priv_data);
b9a281db
FB
2510 av_freep(&s->priv_data);
2511 return ret;
de6d9b64
FB
2512}
2513
2514/* "user interface" functions */
2515
2516void dump_format(AVFormatContext *ic,
115329f1 2517 int index,
de6d9b64
FB
2518 const char *url,
2519 int is_output)
2520{
b9a281db 2521 int i, flags;
de6d9b64
FB
2522 char buf[256];
2523
115329f1 2524 av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
de6d9b64 2525 is_output ? "Output" : "Input",
115329f1
DB
2526 index,
2527 is_output ? ic->oformat->name : ic->iformat->name,
de6d9b64 2528 is_output ? "to" : "from", url);
12f996ed 2529 if (!is_output) {
2143116d 2530 av_log(NULL, AV_LOG_INFO, " Duration: ");
12f996ed
FB
2531 if (ic->duration != AV_NOPTS_VALUE) {
2532 int hours, mins, secs, us;
2533 secs = ic->duration / AV_TIME_BASE;
2534 us = ic->duration % AV_TIME_BASE;
2535 mins = secs / 60;
2536 secs %= 60;
2537 hours = mins / 60;
2538 mins %= 60;
115329f1 2539 av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%01d", hours, mins, secs,
12f996ed
FB
2540 (10 * us) / AV_TIME_BASE);
2541 } else {
2143116d 2542 av_log(NULL, AV_LOG_INFO, "N/A");
12f996ed 2543 }
d0f3f159
WG
2544 if (ic->start_time != AV_NOPTS_VALUE) {
2545 int secs, us;
2143116d 2546 av_log(NULL, AV_LOG_INFO, ", start: ");
d0f3f159
WG
2547 secs = ic->start_time / AV_TIME_BASE;
2548 us = ic->start_time % AV_TIME_BASE;
2143116d 2549 av_log(NULL, AV_LOG_INFO, "%d.%06d",
d0f3f159
WG
2550 secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
2551 }
2143116d 2552 av_log(NULL, AV_LOG_INFO, ", bitrate: ");
12f996ed 2553 if (ic->bit_rate) {
2143116d 2554 av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
12f996ed 2555 } else {
2143116d 2556 av_log(NULL, AV_LOG_INFO, "N/A");
12f996ed 2557 }
2143116d 2558 av_log(NULL, AV_LOG_INFO, "\n");
12f996ed 2559 }
de6d9b64
FB
2560 for(i=0;i<ic->nb_streams;i++) {
2561 AVStream *st = ic->streams[i];
21189011 2562 int g= ff_gcd(st->time_base.num, st->time_base.den);
01f4895c 2563 avcodec_string(buf, sizeof(buf), st->codec, is_output);
2143116d 2564 av_log(NULL, AV_LOG_INFO, " Stream #%d.%d", index, i);
b9a281db
FB
2565 /* the pid is an important information, so we display it */
2566 /* XXX: add a generic system */
2567 if (is_output)
2568 flags = ic->oformat->flags;
2569 else
2570 flags = ic->iformat->flags;
2571 if (flags & AVFMT_SHOW_IDS) {
2143116d 2572 av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
b9a281db 2573 }
c6ec28b1
MN
2574 if (strlen(st->language) > 0) {
2575 av_log(NULL, AV_LOG_INFO, "(%s)", st->language);
2576 }
21189011 2577 av_log(NULL, AV_LOG_DEBUG, ", %d/%d", st->time_base.num/g, st->time_base.den/g);
47dd81c7 2578 av_log(NULL, AV_LOG_INFO, ": %s", buf);
21189011 2579 if(st->codec->codec_type == CODEC_TYPE_VIDEO){
780eb1c9
MN
2580 if(st->r_frame_rate.den && st->r_frame_rate.num)
2581 av_log(NULL, AV_LOG_INFO, ", %5.2f fps(r)", av_q2d(st->r_frame_rate));
2582/* else if(st->time_base.den && st->time_base.num)
2583 av_log(NULL, AV_LOG_INFO, ", %5.2f fps(m)", 1/av_q2d(st->time_base));*/
2584 else
2585 av_log(NULL, AV_LOG_INFO, ", %5.2f fps(c)", 1/av_q2d(st->codec->time_base));
21189011 2586 }
47dd81c7 2587 av_log(NULL, AV_LOG_INFO, "\n");
de6d9b64
FB
2588 }
2589}
2590
2591typedef struct {
445f1b83 2592 const char *abv;
de6d9b64 2593 int width, height;
445f1b83
RS
2594 int frame_rate, frame_rate_base;
2595} AbvEntry;
2596
2597static AbvEntry frame_abvs[] = {
ba2a8cb4
RS
2598 { "ntsc", 720, 480, 30000, 1001 },
2599 { "pal", 720, 576, 25, 1 },
2600 { "qntsc", 352, 240, 30000, 1001 }, /* VCD compliant ntsc */
2601 { "qpal", 352, 288, 25, 1 }, /* VCD compliant pal */
904736b5
RS
2602 { "sntsc", 640, 480, 30000, 1001 }, /* square pixel ntsc */
2603 { "spal", 768, 576, 25, 1 }, /* square pixel pal */
445f1b83
RS
2604 { "film", 352, 240, 24, 1 },
2605 { "ntsc-film", 352, 240, 24000, 1001 },
2606 { "sqcif", 128, 96, 0, 0 },
2607 { "qcif", 176, 144, 0, 0 },
2608 { "cif", 352, 288, 0, 0 },
2609 { "4cif", 704, 576, 0, 0 },
de6d9b64 2610};
445f1b83 2611
e36bdf8b
DK
2612/**
2613 * parses width and height out of string str.
2614 */
de6d9b64
FB
2615int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2616{
2617 int i;
445f1b83 2618 int n = sizeof(frame_abvs) / sizeof(AbvEntry);
de6d9b64
FB
2619 const char *p;
2620 int frame_width = 0, frame_height = 0;
2621
2622 for(i=0;i<n;i++) {
445f1b83
RS
2623 if (!strcmp(frame_abvs[i].abv, str)) {
2624 frame_width = frame_abvs[i].width;
2625 frame_height = frame_abvs[i].height;
de6d9b64
FB
2626 break;
2627 }
2628 }
2629 if (i == n) {
2630 p = str;
2631 frame_width = strtol(p, (char **)&p, 10);
2632 if (*p)
2633 p++;
2634 frame_height = strtol(p, (char **)&p, 10);
2635 }
2636 if (frame_width <= 0 || frame_height <= 0)
2637 return -1;
2638 *width_ptr = frame_width;
2639 *height_ptr = frame_height;
2640 return 0;
2641}
2642
e36bdf8b
DK
2643/**
2644 * Converts frame rate from string to a fraction.
2645 *
2646 * First we try to get an exact integer or fractional frame rate.
2647 * If this fails we convert the frame rate to a double and return
2648 * an approximate fraction using the DEFAULT_FRAME_RATE_BASE.
2649 */
445f1b83
RS
2650int parse_frame_rate(int *frame_rate, int *frame_rate_base, const char *arg)
2651{
2652 int i;
2653 char* cp;
115329f1 2654
445f1b83
RS
2655 /* First, we check our abbreviation table */
2656 for (i = 0; i < sizeof(frame_abvs)/sizeof(*frame_abvs); ++i)
2657 if (!strcmp(frame_abvs[i].abv, arg)) {
bb270c08
DB
2658 *frame_rate = frame_abvs[i].frame_rate;
2659 *frame_rate_base = frame_abvs[i].frame_rate_base;
2660 return 0;
2661 }
445f1b83
RS
2662
2663 /* Then, we try to parse it as fraction */
2664 cp = strchr(arg, '/');
88805317
RG
2665 if (!cp)
2666 cp = strchr(arg, ':');
445f1b83
RS
2667 if (cp) {
2668 char* cpp;
bb270c08
DB
2669 *frame_rate = strtol(arg, &cpp, 10);
2670 if (cpp != arg || cpp == cp)
2671 *frame_rate_base = strtol(cp+1, &cpp, 10);
2672 else
2673 *frame_rate = 0;
115329f1 2674 }
445f1b83
RS
2675 else {
2676 /* Finally we give up and parse it as double */
67dd33f9
BC
2677 AVRational time_base = av_d2q(strtod(arg, 0), DEFAULT_FRAME_RATE_BASE);
2678 *frame_rate_base = time_base.den;
2679 *frame_rate = time_base.num;
445f1b83
RS
2680 }
2681 if (!*frame_rate || !*frame_rate_base)
2682 return -1;
2683 else
2684 return 0;
2685}
2686
e36bdf8b
DK
2687/**
2688 * Converts date string to number of seconds since Jan 1st, 1970.
2689 *
2690 * @code
2691 * Syntax:
916c80e9
FB
2692 * - If not a duration:
2693 * [{YYYY-MM-DD|YYYYMMDD}]{T| }{HH[:MM[:SS[.m...]]][Z]|HH[MM[SS[.m...]]][Z]}
c5510dd6 2694 * Time is localtime unless Z is suffixed to the end. In this case GMT
115329f1 2695 * Return the date in micro seconds since 1970
e36bdf8b
DK
2696 *
2697 * - If a duration:
916c80e9
FB
2698 * HH[:MM[:SS[.m...]]]
2699 * S+[.m...]
e36bdf8b 2700 * @endcode
916c80e9 2701 */
ac44871c 2702#ifndef CONFIG_WINCE
0c1a9eda 2703int64_t parse_date(const char *datestr, int duration)
de6d9b64
FB
2704{
2705 const char *p;
0c1a9eda 2706 int64_t t;
2dbceb9f 2707 struct tm dt;
c5510dd6
PG
2708 int i;
2709 static const char *date_fmt[] = {
2710 "%Y-%m-%d",
2711 "%Y%m%d",
2712 };
2713 static const char *time_fmt[] = {
2714 "%H:%M:%S",
2715 "%H%M%S",
2716 };
2717 const char *q;
916c80e9 2718 int is_utc, len;
c5510dd6 2719 char lastch;
a6a92a9a 2720 int negative = 0;
6d8f985e
MN
2721
2722#undef time
c5510dd6
PG
2723 time_t now = time(0);
2724
916c80e9
FB
2725 len = strlen(datestr);
2726 if (len > 0)
2727 lastch = datestr[len - 1];
2728 else
2729 lastch = '\0';
c5510dd6 2730 is_utc = (lastch == 'z' || lastch == 'Z');
2dbceb9f
PG
2731
2732 memset(&dt, 0, sizeof(dt));
de6d9b64
FB
2733
2734 p = datestr;
916c80e9 2735 q = NULL;
de6d9b64 2736 if (!duration) {
c5510dd6 2737 for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
f71869a4 2738 q = small_strptime(p, date_fmt[i], &dt);
c5510dd6
PG
2739 if (q) {
2740 break;
2741 }
2742 }
2743
2744 if (!q) {
2745 if (is_utc) {
2746 dt = *gmtime(&now);
2747 } else {
2748 dt = *localtime(&now);
2749 }
2750 dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
de6d9b64 2751 } else {
c5510dd6 2752 p = q;
de6d9b64 2753 }
c5510dd6
PG
2754
2755 if (*p == 'T' || *p == 't' || *p == ' ')
2756 p++;
c5510dd6 2757
916c80e9 2758 for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
f71869a4 2759 q = small_strptime(p, time_fmt[i], &dt);
916c80e9
FB
2760 if (q) {
2761 break;
2762 }
2763 }
2764 } else {
bb270c08
DB
2765 if (p[0] == '-') {
2766 negative = 1;
2767 ++p;
2768 }
f71869a4 2769 q = small_strptime(p, time_fmt[0], &dt);
916c80e9
FB
2770 if (!q) {
2771 dt.tm_sec = strtol(p, (char **)&q, 10);
2772 dt.tm_min = 0;
2773 dt.tm_hour = 0;
c5510dd6
PG
2774 }
2775 }
2776
2777 /* Now we have all the fields that we can get */
2778 if (!q) {
2779 if (duration)
2780 return 0;
2781 else
8da9266c 2782 return now * INT64_C(1000000);
de6d9b64 2783 }
2dbceb9f
PG
2784
2785 if (duration) {
c5510dd6 2786 t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2dbceb9f 2787 } else {
c5510dd6
PG
2788 dt.tm_isdst = -1; /* unknown */
2789 if (is_utc) {
2790 t = mktimegm(&dt);
2791 } else {
2792 t = mktime(&dt);
2793 }
de6d9b64 2794 }
2dbceb9f 2795
c5510dd6
PG
2796 t *= 1000000;
2797
2798 if (*q == '.') {
de6d9b64 2799 int val, n;
c5510dd6
PG
2800 q++;
2801 for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
115329f1 2802 if (!isdigit(*q))
c5510dd6
PG
2803 break;
2804 val += n * (*q - '0');
de6d9b64
FB
2805 }
2806 t += val;
2807 }
a6a92a9a 2808 return negative ? -t : t;
de6d9b64 2809}
ac44871c 2810#endif /* CONFIG_WINCE */
de6d9b64 2811
e36bdf8b
DK
2812/**
2813 * Attempts to find a specific tag in a URL.
2814 *
2815 * syntax: '?tag1=val1&tag2=val2...'. Little URL decoding is done.
2816 * Return 1 if found.
2817 */
de6d9b64
FB
2818int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
2819{
2820 const char *p;
2821 char tag[128], *q;
2822
2823 p = info;
2824 if (*p == '?')
2825 p++;
2826 for(;;) {
2827 q = tag;
2828 while (*p != '\0' && *p != '=' && *p != '&') {
2829 if ((q - tag) < sizeof(tag) - 1)
2830 *q++ = *p;
2831 p++;
2832 }
2833 *q = '\0';
2834 q = arg;
2835 if (*p == '=') {
2836 p++;
2837 while (*p != '&' && *p != '\0') {
2dbceb9f
PG
2838 if ((q - arg) < arg_size - 1) {
2839 if (*p == '+')
2840 *q++ = ' ';
2841 else
2842 *q++ = *p;
2843 }
de6d9b64
FB
2844 p++;
2845 }
2846 *q = '\0';
2847 }
115329f1 2848 if (!strcmp(tag, tag1))
de6d9b64
FB
2849 return 1;
2850 if (*p != '&')
2851 break;
8d1335ea 2852 p++;
de6d9b64
FB
2853 }
2854 return 0;
2855}
2856
e36bdf8b
DK
2857/**
2858 * Returns in 'buf' the path with '%d' replaced by number.
5c07cf53 2859
e36bdf8b 2860 * Also handles the '%0nd' format where 'n' is the total number
5c07cf53
MB
2861 * of digits and '%%'.
2862 *
2863 * @param buf destination buffer
2864 * @param buf_size destination buffer size
2865 * @param path numbered sequence string
2866 * @number frame number
2867 * @return 0 if OK, -1 if format error.
e36bdf8b 2868 */
5c07cf53
MB
2869int av_get_frame_filename(char *buf, int buf_size,
2870 const char *path, int number)
9150f42e
FB
2871{
2872 const char *p;
0bf92f79
PI
2873 char *q, buf1[20], c;
2874 int nd, len, percentd_found;
9150f42e
FB
2875
2876 q = buf;
2877 p = path;
2878 percentd_found = 0;
2879 for(;;) {
2880 c = *p++;
2881 if (c == '\0')
2882 break;
2883 if (c == '%') {
c9646fda
PG
2884 do {
2885 nd = 0;
2886 while (isdigit(*p)) {
2887 nd = nd * 10 + *p++ - '0';
2888 }
2889 c = *p++;
c9646fda
PG
2890 } while (isdigit(c));
2891
9150f42e
FB
2892 switch(c) {
2893 case '%':
2894 goto addchar;
2895 case 'd':
2896 if (percentd_found)
2897 goto fail;
2898 percentd_found = 1;
2899 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
2900 len = strlen(buf1);
2901 if ((q - buf + len) > buf_size - 1)
2902 goto fail;
2903 memcpy(q, buf1, len);
2904 q += len;
2905 break;
2906 default:
2907 goto fail;
2908 }
2909 } else {
2910 addchar:
2911 if ((q - buf) < buf_size - 1)
2912 *q++ = c;
2913 }
2914 }
2915 if (!percentd_found)
2916 goto fail;
2917 *q = '\0';
2918 return 0;
2919 fail:
2920 *q = '\0';
2921 return -1;
2922}
2923
b9a281db 2924/**
fb2758c8
FB
2925 * Print nice hexa dump of a buffer
2926 * @param f stream for output
b9a281db
FB
2927 * @param buf buffer
2928 * @param size buffer size
2929 */
fb2758c8 2930void av_hex_dump(FILE *f, uint8_t *buf, int size)
b9a281db
FB
2931{
2932 int len, i, j, c;
2933
2934 for(i=0;i<size;i+=16) {
2935 len = size - i;
2936 if (len > 16)
2937 len = 16;
fb2758c8 2938 fprintf(f, "%08x ", i);
b9a281db
FB
2939 for(j=0;j<16;j++) {
2940 if (j < len)
fb2758c8 2941 fprintf(f, " %02x", buf[i+j]);
b9a281db 2942 else
fb2758c8 2943 fprintf(f, " ");
b9a281db 2944 }
fb2758c8 2945 fprintf(f, " ");
b9a281db
FB
2946 for(j=0;j<len;j++) {
2947 c = buf[i+j];
2948 if (c < ' ' || c > '~')
2949 c = '.';
fb2758c8 2950 fprintf(f, "%c", c);
b9a281db 2951 }
fb2758c8 2952 fprintf(f, "\n");
b9a281db
FB
2953 }
2954}
2955
fb2758c8
FB
2956/**
2957 * Print on 'f' a nice dump of a packet
2958 * @param f stream for output
2959 * @param pkt packet to dump
2960 * @param dump_payload true if the payload must be displayed too
2961 */
c0df9d75 2962 //FIXME needs to know the time_base
fb2758c8
FB
2963void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
2964{
2965 fprintf(f, "stream #%d:\n", pkt->stream_index);
2966 fprintf(f, " keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
2967 fprintf(f, " duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
37353960
FB
2968 /* DTS is _always_ valid after av_read_frame() */
2969 fprintf(f, " dts=");
2970 if (pkt->dts == AV_NOPTS_VALUE)
2971 fprintf(f, "N/A");
2972 else
2973 fprintf(f, "%0.3f", (double)pkt->dts / AV_TIME_BASE);
fb2758c8
FB
2974 /* PTS may be not known if B frames are present */
2975 fprintf(f, " pts=");
2976 if (pkt->pts == AV_NOPTS_VALUE)
2977 fprintf(f, "N/A");
2978 else
2979 fprintf(f, "%0.3f", (double)pkt->pts / AV_TIME_BASE);
2980 fprintf(f, "\n");
2981 fprintf(f, " size=%d\n", pkt->size);
2982 if (dump_payload)
2983 av_hex_dump(f, pkt->data, pkt->size);
2984}
2985
a9a721da 2986void url_split(char *proto, int proto_size,
6ba5cbc6 2987 char *authorization, int authorization_size,
a9a721da
FB
2988 char *hostname, int hostname_size,
2989 int *port_ptr,
2990 char *path, int path_size,
2991 const char *url)
2992{
2993 const char *p;
2994 char *q;
2995 int port;
2996
2997 port = -1;
2998
2999 p = url;
3000 q = proto;
3001 while (*p != ':' && *p != '\0') {
3002 if ((q - proto) < proto_size - 1)
3003 *q++ = *p;
3004 p++;
3005 }
3006 if (proto_size > 0)
3007 *q = '\0';
6ba5cbc6
PD
3008 if (authorization_size > 0)
3009 authorization[0] = '\0';
a9a721da
FB
3010 if (*p == '\0') {
3011 if (proto_size > 0)
3012 proto[0] = '\0';
3013 if (hostname_size > 0)
3014 hostname[0] = '\0';
3015 p = url;
3016 } else {
6ba5cbc6
PD
3017 char *at,*slash; // PETR: position of '@' character and '/' character
3018
a9a721da
FB
3019 p++;
3020 if (*p == '/')
3021 p++;
3022 if (*p == '/')
3023 p++;
6ba5cbc6
PD
3024 at = strchr(p,'@'); // PETR: get the position of '@'
3025 slash = strchr(p,'/'); // PETR: get position of '/' - end of hostname
3026 if (at && slash && at > slash) at = NULL; // PETR: not interested in '@' behind '/'
3027
3028 q = at ? authorization : hostname; // PETR: if '@' exists starting with auth.
3029
3030 while ((at || *p != ':') && *p != '/' && *p != '?' && *p != '\0') { // PETR:
3031 if (*p == '@') { // PETR: passed '@'
3032 if (authorization_size > 0)
3033 *q = '\0';
3034 q = hostname;
3035 at = NULL;
3036 } else if (!at) { // PETR: hostname
3037 if ((q - hostname) < hostname_size - 1)
3038 *q++ = *p;
3039 } else {
3040 if ((q - authorization) < authorization_size - 1)
a9a721da 3041 *q++ = *p;
6ba5cbc6 3042 }
a9a721da
FB
3043 p++;
3044 }
3045 if (hostname_size > 0)
3046 *q = '\0';
3047 if (*p == ':') {
3048 p++;
3049 port = strtoul(p, (char **)&p, 10);
3050 }
3051 }
3052 if (port_ptr)
3053 *port_ptr = port;
3054 pstrcpy(path, path_size, p);
3055}
3056
916c80e9 3057/**
e36bdf8b
DK
3058 * Set the pts for a given stream.
3059 *
115329f1 3060 * @param s stream
916c80e9 3061 * @param pts_wrap_bits number of bits effectively used by the pts
115329f1
DB
3062 * (used for wrap control, 33 is the value for MPEG)
3063 * @param pts_num numerator to convert to seconds (MPEG: 1)
916c80e9
FB
3064 * @param pts_den denominator to convert to seconds (MPEG: 90000)
3065 */
9ee91c2f 3066void av_set_pts_info(AVStream *s, int pts_wrap_bits,
916c80e9
FB
3067 int pts_num, int pts_den)
3068{
3069 s->pts_wrap_bits = pts_wrap_bits;
9ee91c2f
MN
3070 s->time_base.num = pts_num;
3071 s->time_base.den = pts_den;
916c80e9
FB
3072}
3073
3074/* fraction handling */
3075
3076/**
e36bdf8b
DK
3077 * f = val + (num / den) + 0.5.
3078 *
3079 * 'num' is normalized so that it is such as 0 <= num < den.
916c80e9
FB
3080 *
3081 * @param f fractional number
3082 * @param val integer value
3083 * @param num must be >= 0
115329f1 3084 * @param den must be >= 1
916c80e9 3085 */
f3a30e3a 3086static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
916c80e9
FB
3087{
3088 num += (den >> 1);
3089 if (num >= den) {
3090 val += num / den;
3091 num = num % den;
3092 }
3093 f->val = val;
3094 f->num = num;
3095 f->den = den;
3096}
3097
e36bdf8b 3098/**
e36bdf8b 3099 * Fractionnal addition to f: f = f + (incr / f->den).
916c80e9
FB
3100 *
3101 * @param f fractional number
3102 * @param incr increment, can be positive or negative
3103 */
f3a30e3a 3104static void av_frac_add(AVFrac *f, int64_t incr)
916c80e9 3105{
0c1a9eda 3106 int64_t num, den;
916c80e9
FB
3107
3108 num = f->num + incr;
3109 den = f->den;
3110 if (num < 0) {
3111 f->val += num / den;
3112 num = num % den;
3113 if (num < 0) {
3114 num += den;
3115 f->val--;
3116 }
3117 } else if (num >= den) {
3118 f->val += num / den;
3119 num = num % den;
3120 }
3121 f->num = num;
3122}