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