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