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