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