tiny docs improvement which i apparebtly forgot to commit
[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 */
168static void av_destruct_packet(AVPacket *pkt)
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) {
837 if (!st->parser) {
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];
879 if (st->parser) {
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;
1678 int got_picture, ret;
1679 AVFrame picture;
1680
1681 codec = avcodec_find_decoder(st->codec.codec_id);
1682 if (!codec)
1683 return -1;
1684 ret = avcodec_open(&st->codec, codec);
1685 if (ret < 0)
1686 return ret;
644a9262
MN
1687
1688 if(!has_codec_parameters(&st->codec)){
fb2758c8
FB
1689 switch(st->codec.codec_type) {
1690 case CODEC_TYPE_VIDEO:
1691 ret = avcodec_decode_video(&st->codec, &picture,
1692 &got_picture, (uint8_t *)data, size);
1693 break;
1694 case CODEC_TYPE_AUDIO:
1695 samples = av_malloc(AVCODEC_MAX_AUDIO_FRAME_SIZE);
1696 if (!samples)
1697 goto fail;
1698 ret = avcodec_decode_audio(&st->codec, samples,
1699 &got_picture, (uint8_t *)data, size);
1700 av_free(samples);
1701 break;
1702 default:
1703 break;
1704 }
644a9262 1705 }
fb2758c8
FB
1706 fail:
1707 avcodec_close(&st->codec);
1708 return ret;
1709}
1710
1711/* absolute maximum size we read until we abort */
1712#define MAX_READ_SIZE 5000000
1713
1714/* maximum duration until we stop analysing the stream */
1715#define MAX_STREAM_DURATION ((int)(AV_TIME_BASE * 1.0))
1716
b9a281db
FB
1717/**
1718 * Read the beginning of a media file to get stream information. This
1719 * is useful for file formats with no headers such as MPEG. This
1720 * function also compute the real frame rate in case of mpeg2 repeat
1721 * frame mode.
1722 *
1723 * @param ic media file handle
1724 * @return >=0 if OK. AVERROR_xxx if error.
644a9262 1725 * @todo let user decide somehow what information is needed so we dont waste time geting stuff the user doesnt need
b9a281db
FB
1726 */
1727int av_find_stream_info(AVFormatContext *ic)
1728{
fb2758c8 1729 int i, count, ret, read_size;
b9a281db 1730 AVStream *st;
fb2758c8 1731 AVPacket pkt1, *pkt;
b9a281db 1732 AVPacketList *pktl=NULL, **ppktl;
15bc38e5 1733 int64_t last_dts[MAX_STREAMS];
3c150d16
MN
1734 int64_t duration_sum[MAX_STREAMS];
1735 int duration_count[MAX_STREAMS]={0};
b9a281db 1736
c0df9d75
MN
1737 for(i=0;i<ic->nb_streams;i++) {
1738 st = ic->streams[i];
1739 if(st->codec.codec_type == CODEC_TYPE_VIDEO){
1740/* if(!st->time_base.num)
1741 st->time_base= */
1742 if(!st->codec.time_base.num)
1743 st->codec.time_base= st->time_base;
1744 }
1745 }
1746
15bc38e5
MN
1747 for(i=0;i<MAX_STREAMS;i++){
1748 last_dts[i]= AV_NOPTS_VALUE;
3c150d16 1749 duration_sum[i]= INT64_MAX;
15bc38e5
MN
1750 }
1751
b9a281db
FB
1752 count = 0;
1753 read_size = 0;
1754 ppktl = &ic->packet_buffer;
1755 for(;;) {
1756 /* check if one codec still needs to be handled */
1757 for(i=0;i<ic->nb_streams;i++) {
1758 st = ic->streams[i];
fb2758c8 1759 if (!has_codec_parameters(&st->codec))
b9a281db 1760 break;
3e76d1b5 1761 /* variable fps and no guess at the real fps */
c0df9d75 1762 if( st->codec.time_base.den >= 1000LL*st->codec.time_base.num
3c150d16 1763 && duration_count[i]<20 && st->codec.codec_type == CODEC_TYPE_VIDEO)
3e76d1b5 1764 break;
b9a281db
FB
1765 }
1766 if (i == ic->nb_streams) {
1767 /* NOTE: if the format has no header, then we need to read
1768 some packets to get most of the streams, so we cannot
1769 stop here */
fb2758c8 1770 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
b9a281db
FB
1771 /* if we found the info for all the codecs, we can stop */
1772 ret = count;
1773 break;
1774 }
1775 } else {
1776 /* we did not get all the codec info, but we read too much data */
fb2758c8 1777 if (read_size >= MAX_READ_SIZE) {
b9a281db
FB
1778 ret = count;
1779 break;
1780 }
1781 }
1782
fb2758c8
FB
1783 /* NOTE: a new stream can be added there if no header in file
1784 (AVFMTCTX_NOHEADER) */
1785 ret = av_read_frame_internal(ic, &pkt1);
1786 if (ret < 0) {
1787 /* EOF or error */
1788 ret = -1; /* we could not have all the codec parameters before EOF */
e19456e3
MN
1789 for(i=0;i<ic->nb_streams;i++) {
1790 st = ic->streams[i];
1791 if (!has_codec_parameters(&st->codec))
1792 break;
1793 }
3c150d16 1794 if (i == ic->nb_streams)
fb2758c8
FB
1795 ret = 0;
1796 break;
1797 }
1798
b9a281db
FB
1799 pktl = av_mallocz(sizeof(AVPacketList));
1800 if (!pktl) {
1801 ret = AVERROR_NOMEM;
1802 break;
1803 }
1804
1805 /* add the packet in the buffered packet list */
1806 *ppktl = pktl;
1807 ppktl = &pktl->next;
1808
b9a281db 1809 pkt = &pktl->pkt;
fb2758c8
FB
1810 *pkt = pkt1;
1811
1812 /* duplicate the packet */
1813 if (av_dup_packet(pkt) < 0) {
1814 ret = AVERROR_NOMEM;
1815 break;
b9a281db 1816 }
b9a281db 1817
fb2758c8 1818 read_size += pkt->size;
b9a281db
FB
1819
1820 st = ic->streams[pkt->stream_index];
fb2758c8
FB
1821 st->codec_info_duration += pkt->duration;
1822 if (pkt->duration != 0)
1823 st->codec_info_nb_frames++;
1824
cefe0607 1825 {
3c150d16
MN
1826 int index= pkt->stream_index;
1827 int64_t last= last_dts[index];
1828 int64_t duration= pkt->dts - last;
1829
1830 if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
1831 if(duration*duration_count[index]*10/9 < duration_sum[index]){
1832 duration_sum[index]= duration;
1833 duration_count[index]=1;
1834 }else{
1835 int factor= av_rescale(duration, duration_count[index], duration_sum[index]);
1836 duration_sum[index] += duration;
1837 duration_count[index]+= factor;
1838 }
cefe0607
MN
1839 if(st->codec_info_nb_frames == 0)
1840 st->codec_info_duration += duration;
15bc38e5
MN
1841 }
1842 last_dts[pkt->stream_index]= pkt->dts;
1843 }
fb2758c8
FB
1844 /* if still no information, we try to open the codec and to
1845 decompress the frame. We try to avoid that in most cases as
1846 it takes longer and uses more memory. For MPEG4, we need to
1847 decompress for Quicktime. */
644a9262 1848 if (!has_codec_parameters(&st->codec) /*&&
fb2758c8
FB
1849 (st->codec.codec_id == CODEC_ID_FLV1 ||
1850 st->codec.codec_id == CODEC_ID_H264 ||
1851 st->codec.codec_id == CODEC_ID_H263 ||
61c7c3e3 1852 st->codec.codec_id == CODEC_ID_H261 ||
8bfed902 1853 st->codec.codec_id == CODEC_ID_VORBIS ||
03cfe134 1854 st->codec.codec_id == CODEC_ID_MJPEG ||
4eff7cf4 1855 st->codec.codec_id == CODEC_ID_PNG ||
5b6d5596
MN
1856 st->codec.codec_id == CODEC_ID_PAM ||
1857 st->codec.codec_id == CODEC_ID_PGM ||
1858 st->codec.codec_id == CODEC_ID_PGMYUV ||
1859 st->codec.codec_id == CODEC_ID_PBM ||
1860 st->codec.codec_id == CODEC_ID_PPM ||
85ad5695 1861 st->codec.codec_id == CODEC_ID_SHORTEN ||
644a9262 1862 (st->codec.codec_id == CODEC_ID_MPEG4 && !st->need_parsing))*/)
fb2758c8
FB
1863 try_decode_frame(st, pkt->data, pkt->size);
1864
cefe0607 1865 if (av_rescale_q(st->codec_info_duration, st->time_base, AV_TIME_BASE_Q) >= MAX_STREAM_DURATION) {
fb2758c8 1866 break;
b9a281db
FB
1867 }
1868 count++;
1869 }
1870
b9a281db
FB
1871 for(i=0;i<ic->nb_streams;i++) {
1872 st = ic->streams[i];
1873 if (st->codec.codec_type == CODEC_TYPE_VIDEO) {
1b307feb 1874 if(st->codec.codec_id == CODEC_ID_RAWVIDEO && !st->codec.codec_tag && !st->codec.bits_per_sample)
d07730dd 1875 st->codec.codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec.pix_fmt);
15bc38e5 1876
1677155d 1877 if(duration_count[i] && st->codec.time_base.num*1000LL <= st->codec.time_base.den &&
3c150d16
MN
1878 st->time_base.num*duration_sum[i]/duration_count[i]*1000LL > st->time_base.den){
1879 AVRational fps1;
1880 int64_t num, den;
b3506cb4 1881
3c150d16
MN
1882 num= st->time_base.den*duration_count[i];
1883 den= st->time_base.num*duration_sum[i];
b3506cb4 1884
3c150d16
MN
1885 av_reduce(&fps1.num, &fps1.den, num*1001, den*1000, FFMAX(st->time_base.den, st->time_base.num)/4);
1886 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, den, FFMAX(st->time_base.den, st->time_base.num)/4);
1887 if(fps1.num < st->r_frame_rate.num && fps1.den == 1 && (fps1.num==24 || fps1.num==30)){ //FIXME better decission
1888 st->r_frame_rate.num= fps1.num*1000;
1889 st->r_frame_rate.den= fps1.den*1001;
1890 }
15bc38e5
MN
1891 }
1892
d07730dd 1893 /* set real frame rate info */
fb2758c8
FB
1894 /* compute the real frame rate for telecine */
1895 if ((st->codec.codec_id == CODEC_ID_MPEG1VIDEO ||
1896 st->codec.codec_id == CODEC_ID_MPEG2VIDEO) &&
1897 st->codec.sub_id == 2) {
1898 if (st->codec_info_nb_frames >= 20) {
1899 float coded_frame_rate, est_frame_rate;
1900 est_frame_rate = ((double)st->codec_info_nb_frames * AV_TIME_BASE) /
1901 (double)st->codec_info_duration ;
c0df9d75 1902 coded_frame_rate = 1.0/av_q2d(st->codec.time_base);
fb2758c8
FB
1903#if 0
1904 printf("telecine: coded_frame_rate=%0.3f est_frame_rate=%0.3f\n",
1905 coded_frame_rate, est_frame_rate);
1906#endif
1907 /* if we detect that it could be a telecine, we
1908 signal it. It would be better to do it at a
1909 higher level as it can change in a film */
1910 if (coded_frame_rate >= 24.97 &&
1911 (est_frame_rate >= 23.5 && est_frame_rate < 24.5)) {
c0df9d75 1912 st->r_frame_rate = (AVRational){24000, 1001};
fb2758c8
FB
1913 }
1914 }
1915 }
1916 /* if no real frame rate, use the codec one */
c0df9d75
MN
1917 if (!st->r_frame_rate.num){
1918 st->r_frame_rate.num = st->codec.time_base.den;
1919 st->r_frame_rate.den = st->codec.time_base.num;
14bea432 1920 }
b9a281db 1921 }
de6d9b64 1922 }
b9a281db 1923
12f996ed 1924 av_estimate_timings(ic);
e928649b
MN
1925#if 0
1926 /* correct DTS for b frame streams with no timestamps */
1927 for(i=0;i<ic->nb_streams;i++) {
1928 st = ic->streams[i];
1929 if (st->codec.codec_type == CODEC_TYPE_VIDEO) {
1930 if(b-frames){
1931 ppktl = &ic->packet_buffer;
1932 while(ppkt1){
1933 if(ppkt1->stream_index != i)
1934 continue;
1935 if(ppkt1->pkt->dts < 0)
1936 break;
1937 if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
1938 break;
1939 ppkt1->pkt->dts -= delta;
1940 ppkt1= ppkt1->next;
1941 }
1942 if(ppkt1)
1943 continue;
1944 st->cur_dts -= delta;
1945 }
1946 }
1947 }
1948#endif
b9a281db 1949 return ret;
de6d9b64
FB
1950}
1951
fb2758c8
FB
1952/*******************************************************/
1953
1954/**
1955 * start playing a network based stream (e.g. RTSP stream) at the
1956 * current position
1957 */
1958int av_read_play(AVFormatContext *s)
1959{
1960 if (!s->iformat->read_play)
1961 return AVERROR_NOTSUPP;
1962 return s->iformat->read_play(s);
1963}
1964
1965/**
1966 * pause a network based stream (e.g. RTSP stream). Use av_read_play()
1967 * to resume it.
1968 */
1969int av_read_pause(AVFormatContext *s)
1970{
1971 if (!s->iformat->read_pause)
1972 return AVERROR_NOTSUPP;
1973 return s->iformat->read_pause(s);
1974}
1975
b9a281db
FB
1976/**
1977 * Close a media file (but not its codecs)
1978 *
1979 * @param s media file handle
1980 */
de6d9b64
FB
1981void av_close_input_file(AVFormatContext *s)
1982{
b6892136 1983 int i, must_open_file;
da24c5e3 1984 AVStream *st;
de6d9b64 1985
fb2758c8
FB
1986 /* free previous packet */
1987 if (s->cur_st && s->cur_st->parser)
1988 av_free_packet(&s->cur_pkt);
1989
b9a281db
FB
1990 if (s->iformat->read_close)
1991 s->iformat->read_close(s);
de6d9b64 1992 for(i=0;i<s->nb_streams;i++) {
da24c5e3
FB
1993 /* free all data in a stream component */
1994 st = s->streams[i];
fb2758c8
FB
1995 if (st->parser) {
1996 av_parser_close(st->parser);
de6d9b64 1997 }
fb2758c8
FB
1998 av_free(st->index_entries);
1999 av_free(st);
de6d9b64 2000 }
fb2758c8 2001 flush_packet_queue(s);
b6892136 2002 must_open_file = 1;
da24c5e3 2003 if (s->iformat->flags & AVFMT_NOFILE) {
b6892136
FB
2004 must_open_file = 0;
2005 }
2006 if (must_open_file) {
96baaa6a
FB
2007 url_fclose(&s->pb);
2008 }
a8dbe951 2009 av_freep(&s->priv_data);
1ea4f593 2010 av_free(s);
de6d9b64
FB
2011}
2012
b9a281db
FB
2013/**
2014 * Add a new stream to a media file. Can only be called in the
da24c5e3
FB
2015 * read_header function. If the flag AVFMTCTX_NOHEADER is in the
2016 * format context, then new streams can be added in read_packet too.
b9a281db
FB
2017 *
2018 *
2019 * @param s media file handle
da24c5e3 2020 * @param id file format dependent stream id
b9a281db
FB
2021 */
2022AVStream *av_new_stream(AVFormatContext *s, int id)
2023{
2024 AVStream *st;
2025
2026 if (s->nb_streams >= MAX_STREAMS)
2027 return NULL;
2028
2029 st = av_mallocz(sizeof(AVStream));
2030 if (!st)
2031 return NULL;
1e491e29 2032 avcodec_get_context_defaults(&st->codec);
48091512
FB
2033 if (s->iformat) {
2034 /* no default bitrate if decoding */
2035 st->codec.bit_rate = 0;
2036 }
b9a281db
FB
2037 st->index = s->nb_streams;
2038 st->id = id;
12f996ed
FB
2039 st->start_time = AV_NOPTS_VALUE;
2040 st->duration = AV_NOPTS_VALUE;
e928649b 2041 st->cur_dts = AV_NOPTS_VALUE;
9ee91c2f
MN
2042
2043 /* default pts settings is MPEG like */
2044 av_set_pts_info(st, 33, 1, 90000);
77405fc8 2045 st->last_IP_pts = AV_NOPTS_VALUE;
9ee91c2f 2046
b9a281db
FB
2047 s->streams[s->nb_streams++] = st;
2048 return st;
2049}
2050
2051/************************************************************/
2052/* output media file */
de6d9b64 2053
87a0a681
FB
2054int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2055{
2056 int ret;
98486a6b
RS
2057
2058 if (s->oformat->priv_data_size > 0) {
2059 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2060 if (!s->priv_data)
2061 return AVERROR_NOMEM;
2062 } else
2063 s->priv_data = NULL;
2064
87a0a681
FB
2065 if (s->oformat->set_parameters) {
2066 ret = s->oformat->set_parameters(s, ap);
2067 if (ret < 0)
2068 return ret;
2069 }
2070 return 0;
2071}
2072
b9a281db
FB
2073/**
2074 * allocate the stream private data and write the stream header to an
2075 * output media file
2076 *
2077 * @param s media file handle
2078 * @return 0 if OK. AVERROR_xxx if error.
2079 */
2080int av_write_header(AVFormatContext *s)
2081{
1e51d801
FB
2082 int ret, i;
2083 AVStream *st;
2084
1e51d801
FB
2085 ret = s->oformat->write_header(s);
2086 if (ret < 0)
2087 return ret;
2088
2089 /* init PTS generation */
2090 for(i=0;i<s->nb_streams;i++) {
2091 st = s->streams[i];
2092
2093 switch (st->codec.codec_type) {
2094 case CODEC_TYPE_AUDIO:
2095 av_frac_init(&st->pts, 0, 0,
9ee91c2f 2096 (int64_t)st->time_base.num * st->codec.sample_rate);
1e51d801
FB
2097 break;
2098 case CODEC_TYPE_VIDEO:
2099 av_frac_init(&st->pts, 0, 0,
c0df9d75 2100 (int64_t)st->time_base.num * st->codec.time_base.den);
1e51d801
FB
2101 break;
2102 default:
2103 break;
2104 }
2105 }
2106 return 0;
b9a281db
FB
2107}
2108
3c895fc0 2109//FIXME merge with compute_pkt_fields
5edea431 2110static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
3c895fc0
MN
2111 int b_frames = FFMAX(st->codec.has_b_frames, st->codec.max_b_frames);
2112 int num, den, frame_size;
b0c7f5a9 2113
3c895fc0 2114// 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
2115
2116/* if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2117 return -1;*/
2118
e928649b 2119 /* duration field */
3c895fc0
MN
2120 if (pkt->duration == 0) {
2121 compute_frame_duration(&num, &den, st, NULL, pkt);
2122 if (den && num) {
2123 pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
2124 }
2125 }
e928649b
MN
2126
2127 //XXX/FIXME this is a temporary hack until all encoders output pts
2128 if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !b_frames){
2129 pkt->dts=
2130// pkt->pts= st->cur_dts;
2131 pkt->pts= st->pts.val;
2132 }
2133
2134 //calculate dts from pts
2135 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE){
2136 if(b_frames){
2137 if(st->last_IP_pts == AV_NOPTS_VALUE){
3c895fc0 2138 st->last_IP_pts= -pkt->duration;
e928649b
MN
2139 }
2140 if(st->last_IP_pts < pkt->pts){
2141 pkt->dts= st->last_IP_pts;
2142 st->last_IP_pts= pkt->pts;
2143 }else
2144 pkt->dts= pkt->pts;
2145 }else
2146 pkt->dts= pkt->pts;
2147 }
2148
5edea431
MN
2149 if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2150 av_log(NULL, AV_LOG_ERROR, "error, non monotone timestamps %Ld >= %Ld\n", st->cur_dts, pkt->dts);
2151 return -1;
2152 }
2153 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2154 av_log(NULL, AV_LOG_ERROR, "error, pts < dts\n");
2155 return -1;
2156 }
2157
3c895fc0 2158// av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%lld dts2:%lld\n", pkt->pts, pkt->dts);
e928649b
MN
2159 st->cur_dts= pkt->dts;
2160 st->pts.val= pkt->dts;
2161
1e51d801
FB
2162 /* update pts */
2163 switch (st->codec.codec_type) {
2164 case CODEC_TYPE_AUDIO:
e928649b 2165 frame_size = get_audio_frame_size(&st->codec, pkt->size);
6d8f985e 2166
b0c7f5a9 2167 /* HACK/FIXME, we skip the initial 0-size packets as they are most likely equal to the encoder delay,
6d8f985e 2168 but it would be better if we had the real timestamps from the encoder */
e928649b 2169 if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
9ee91c2f 2170 av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
7feb950a 2171 }
1e51d801
FB
2172 break;
2173 case CODEC_TYPE_VIDEO:
c0df9d75 2174 av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec.time_base.num);
1e51d801
FB
2175 break;
2176 default:
2177 break;
2178 }
5edea431 2179 return 0;
3c895fc0
MN
2180}
2181
2182static void truncate_ts(AVStream *st, AVPacket *pkt){
2183 int64_t pts_mask = (2LL << (st->pts_wrap_bits-1)) - 1;
2184
e0c91bc2
MN
2185// if(pkt->dts < 0)
2186// pkt->dts= 0; //this happens for low_delay=0 and b frames, FIXME, needs further invstigation about what we should do here
3c895fc0
MN
2187
2188 pkt->pts &= pts_mask;
2189 pkt->dts &= pts_mask;
2190}
2191
2192/**
2193 * Write a packet to an output media file. The packet shall contain
2194 * one audio or video frame.
2195 *
2196 * @param s media file handle
2197 * @param pkt the packet, which contains the stream_index, buf/buf_size, dts/pts, ...
2198 * @return < 0 if error, = 0 if OK, 1 if end of stream wanted.
2199 */
2200int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2201{
576ae256
MN
2202 int ret;
2203
5edea431
MN
2204 ret=compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2205 if(ret<0)
2206 return ret;
3c895fc0
MN
2207
2208 truncate_ts(s->streams[pkt->stream_index], pkt);
2209
576ae256
MN
2210 ret= s->oformat->write_packet(s, pkt);
2211 if(!ret)
2212 ret= url_ferror(&s->pb);
2213 return ret;
3c895fc0
MN
2214}
2215
2216/**
fe2d6fe2
MN
2217 * interleave_packet implementation which will interleave per DTS.
2218 */
2219static int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2220 AVPacketList *pktl, **next_point, *this_pktl;
2221 int stream_count=0;
2222 int streams[MAX_STREAMS];
2223
2224 if(pkt){
2225 AVStream *st= s->streams[ pkt->stream_index];
2226
2227 assert(pkt->destruct != av_destruct_packet); //FIXME
2228
2229 this_pktl = av_mallocz(sizeof(AVPacketList));
2230 this_pktl->pkt= *pkt;
2231 av_dup_packet(&this_pktl->pkt);
2232
2233 next_point = &s->packet_buffer;
2234 while(*next_point){
2235 AVStream *st2= s->streams[ (*next_point)->pkt.stream_index];
2236 int64_t left= st2->time_base.num * (int64_t)st ->time_base.den;
2237 int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2238 if((*next_point)->pkt.dts * left > pkt->dts * right) //FIXME this can overflow
2239 break;
2240 next_point= &(*next_point)->next;
2241 }
2242 this_pktl->next= *next_point;
2243 *next_point= this_pktl;
2244 }
2245
2246 memset(streams, 0, sizeof(streams));
2247 pktl= s->packet_buffer;
2248 while(pktl){
2249//av_log(s, AV_LOG_DEBUG, "show st:%d dts:%lld\n", pktl->pkt.stream_index, pktl->pkt.dts);
2250 if(streams[ pktl->pkt.stream_index ] == 0)
2251 stream_count++;
2252 streams[ pktl->pkt.stream_index ]++;
2253 pktl= pktl->next;
2254 }
2255
2256 if(s->nb_streams == stream_count || (flush && stream_count)){
2257 pktl= s->packet_buffer;
2258 *out= pktl->pkt;
2259
2260 s->packet_buffer= pktl->next;
2261 av_freep(&pktl);
2262 return 1;
2263 }else{
2264 av_init_packet(out);
2265 return 0;
2266 }
2267}
2268
2269/**
2270 * Interleaves a AVPacket correctly so it can be muxed.
2271 * @param out the interleaved packet will be output here
2272 * @param in the input packet
2273 * @param flush 1 if no further packets are available as input and all
2274 * remaining packets should be output
2275 * @return 1 if a packet was output, 0 if no packet could be output,
2276 * < 0 if an error occured
2277 */
2278static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2279 if(s->oformat->interleave_packet)
2280 return s->oformat->interleave_packet(s, out, in, flush);
2281 else
2282 return av_interleave_packet_per_dts(s, out, in, flush);
2283}
2284
2285/**
3c895fc0
MN
2286 * Writes a packet to an output media file ensuring correct interleaving.
2287 * The packet shall contain one audio or video frame.
2288 * If the packets are already correctly interleaved the application should
2289 * call av_write_frame() instead as its slightly faster, its also important
fe2d6fe2 2290 * to keep in mind that completly non interleaved input will need huge amounts
3c895fc0
MN
2291 * of memory to interleave with this, so its prefereable to interleave at the
2292 * demuxer level
2293 *
2294 * @param s media file handle
2295 * @param pkt the packet, which contains the stream_index, buf/buf_size, dts/pts, ...
2296 * @return < 0 if error, = 0 if OK, 1 if end of stream wanted.
2297 */
2298int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
3c895fc0
MN
2299 AVStream *st= s->streams[ pkt->stream_index];
2300
6f824977
MN
2301 //FIXME/XXX/HACK drop zero sized packets
2302 if(st->codec.codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2303 return 0;
3ce16b30
MN
2304
2305//av_log(NULL, AV_LOG_DEBUG, "av_interleaved_write_frame %d %Ld %Ld\n", pkt->size, pkt->dts, pkt->pts);
2306 if(compute_pkt_fields2(st, pkt) < 0)
2307 return -1;
fe2d6fe2 2308
3c895fc0
MN
2309 if(pkt->dts == AV_NOPTS_VALUE)
2310 return -1;
3c895fc0 2311
fe2d6fe2
MN
2312 for(;;){
2313 AVPacket opkt;
2314 int ret= av_interleave_packet(s, &opkt, pkt, 0);
2315 if(ret<=0) //FIXME cleanup needed for ret<0 ?
2316 return ret;
3c895fc0 2317
fe2d6fe2
MN
2318 truncate_ts(s->streams[opkt.stream_index], &opkt);
2319 ret= s->oformat->write_packet(s, &opkt);
2320
2321 av_free_packet(&opkt);
2322 pkt= NULL;
3c895fc0
MN
2323
2324 if(ret<0)
2325 return ret;
576ae256
MN
2326 if(url_ferror(&s->pb))
2327 return url_ferror(&s->pb);
3c895fc0 2328 }
b9a281db
FB
2329}
2330
2331/**
2332 * write the stream trailer to an output media file and and free the
2333 * file private data.
2334 *
2335 * @param s media file handle
2336 * @return 0 if OK. AVERROR_xxx if error. */
2337int av_write_trailer(AVFormatContext *s)
2338{
c40a3a42 2339 int ret, i;
3c895fc0 2340
fe2d6fe2
MN
2341 for(;;){
2342 AVPacket pkt;
2343 ret= av_interleave_packet(s, &pkt, NULL, 1);
2344 if(ret<0) //FIXME cleanup needed for ret<0 ?
c40a3a42 2345 goto fail;
fe2d6fe2
MN
2346 if(!ret)
2347 break;
3c895fc0 2348
fe2d6fe2
MN
2349 truncate_ts(s->streams[pkt.stream_index], &pkt);
2350 ret= s->oformat->write_packet(s, &pkt);
2351
2352 av_free_packet(&pkt);
3c895fc0
MN
2353
2354 if(ret<0)
c40a3a42 2355 goto fail;
576ae256
MN
2356 if(url_ferror(&s->pb))
2357 goto fail;
3c895fc0
MN
2358 }
2359
b9a281db 2360 ret = s->oformat->write_trailer(s);
c40a3a42 2361fail:
576ae256
MN
2362 if(ret == 0)
2363 ret=url_ferror(&s->pb);
c40a3a42
MN
2364 for(i=0;i<s->nb_streams;i++)
2365 av_freep(&s->streams[i]->priv_data);
b9a281db
FB
2366 av_freep(&s->priv_data);
2367 return ret;
de6d9b64
FB
2368}
2369
2370/* "user interface" functions */
2371
2372void dump_format(AVFormatContext *ic,
2373 int index,
2374 const char *url,
2375 int is_output)
2376{
b9a281db 2377 int i, flags;
de6d9b64
FB
2378 char buf[256];
2379
2143116d 2380 av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
de6d9b64 2381 is_output ? "Output" : "Input",
b9a281db
FB
2382 index,
2383 is_output ? ic->oformat->name : ic->iformat->name,
de6d9b64 2384 is_output ? "to" : "from", url);
12f996ed 2385 if (!is_output) {
2143116d 2386 av_log(NULL, AV_LOG_INFO, " Duration: ");
12f996ed
FB
2387 if (ic->duration != AV_NOPTS_VALUE) {
2388 int hours, mins, secs, us;
2389 secs = ic->duration / AV_TIME_BASE;
2390 us = ic->duration % AV_TIME_BASE;
2391 mins = secs / 60;
2392 secs %= 60;
2393 hours = mins / 60;
2394 mins %= 60;
2143116d 2395 av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%01d", hours, mins, secs,
12f996ed
FB
2396 (10 * us) / AV_TIME_BASE);
2397 } else {
2143116d 2398 av_log(NULL, AV_LOG_INFO, "N/A");
12f996ed 2399 }
d0f3f159
WG
2400 if (ic->start_time != AV_NOPTS_VALUE) {
2401 int secs, us;
2143116d 2402 av_log(NULL, AV_LOG_INFO, ", start: ");
d0f3f159
WG
2403 secs = ic->start_time / AV_TIME_BASE;
2404 us = ic->start_time % AV_TIME_BASE;
2143116d 2405 av_log(NULL, AV_LOG_INFO, "%d.%06d",
d0f3f159
WG
2406 secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
2407 }
2143116d 2408 av_log(NULL, AV_LOG_INFO, ", bitrate: ");
12f996ed 2409 if (ic->bit_rate) {
2143116d 2410 av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
12f996ed 2411 } else {
2143116d 2412 av_log(NULL, AV_LOG_INFO, "N/A");
12f996ed 2413 }
2143116d 2414 av_log(NULL, AV_LOG_INFO, "\n");
12f996ed 2415 }
de6d9b64
FB
2416 for(i=0;i<ic->nb_streams;i++) {
2417 AVStream *st = ic->streams[i];
2418 avcodec_string(buf, sizeof(buf), &st->codec, is_output);
2143116d 2419 av_log(NULL, AV_LOG_INFO, " Stream #%d.%d", index, i);
b9a281db
FB
2420 /* the pid is an important information, so we display it */
2421 /* XXX: add a generic system */
2422 if (is_output)
2423 flags = ic->oformat->flags;
2424 else
2425 flags = ic->iformat->flags;
2426 if (flags & AVFMT_SHOW_IDS) {
2143116d 2427 av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
b9a281db 2428 }
2143116d 2429 av_log(NULL, AV_LOG_INFO, ": %s\n", buf);
de6d9b64
FB
2430 }
2431}
2432
2433typedef struct {
445f1b83 2434 const char *abv;
de6d9b64 2435 int width, height;
445f1b83
RS
2436 int frame_rate, frame_rate_base;
2437} AbvEntry;
2438
2439static AbvEntry frame_abvs[] = {
ba2a8cb4
RS
2440 { "ntsc", 720, 480, 30000, 1001 },
2441 { "pal", 720, 576, 25, 1 },
2442 { "qntsc", 352, 240, 30000, 1001 }, /* VCD compliant ntsc */
2443 { "qpal", 352, 288, 25, 1 }, /* VCD compliant pal */
904736b5
RS
2444 { "sntsc", 640, 480, 30000, 1001 }, /* square pixel ntsc */
2445 { "spal", 768, 576, 25, 1 }, /* square pixel pal */
445f1b83
RS
2446 { "film", 352, 240, 24, 1 },
2447 { "ntsc-film", 352, 240, 24000, 1001 },
2448 { "sqcif", 128, 96, 0, 0 },
2449 { "qcif", 176, 144, 0, 0 },
2450 { "cif", 352, 288, 0, 0 },
2451 { "4cif", 704, 576, 0, 0 },
de6d9b64 2452};
445f1b83 2453
de6d9b64
FB
2454int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2455{
2456 int i;
445f1b83 2457 int n = sizeof(frame_abvs) / sizeof(AbvEntry);
de6d9b64
FB
2458 const char *p;
2459 int frame_width = 0, frame_height = 0;
2460
2461 for(i=0;i<n;i++) {
445f1b83
RS
2462 if (!strcmp(frame_abvs[i].abv, str)) {
2463 frame_width = frame_abvs[i].width;
2464 frame_height = frame_abvs[i].height;
de6d9b64
FB
2465 break;
2466 }
2467 }
2468 if (i == n) {
2469 p = str;
2470 frame_width = strtol(p, (char **)&p, 10);
2471 if (*p)
2472 p++;
2473 frame_height = strtol(p, (char **)&p, 10);
2474 }
2475 if (frame_width <= 0 || frame_height <= 0)
2476 return -1;
2477 *width_ptr = frame_width;
2478 *height_ptr = frame_height;
2479 return 0;
2480}
2481
445f1b83
RS
2482int parse_frame_rate(int *frame_rate, int *frame_rate_base, const char *arg)
2483{
2484 int i;
2485 char* cp;
2486
2487 /* First, we check our abbreviation table */
2488 for (i = 0; i < sizeof(frame_abvs)/sizeof(*frame_abvs); ++i)
2489 if (!strcmp(frame_abvs[i].abv, arg)) {
2490 *frame_rate = frame_abvs[i].frame_rate;
2491 *frame_rate_base = frame_abvs[i].frame_rate_base;
2492 return 0;
2493 }
2494
2495 /* Then, we try to parse it as fraction */
2496 cp = strchr(arg, '/');
88805317
RG
2497 if (!cp)
2498 cp = strchr(arg, ':');
445f1b83
RS
2499 if (cp) {
2500 char* cpp;
2501 *frame_rate = strtol(arg, &cpp, 10);
2502 if (cpp != arg || cpp == cp)
2503 *frame_rate_base = strtol(cp+1, &cpp, 10);
2504 else
2505 *frame_rate = 0;
2506 }
2507 else {
2508 /* Finally we give up and parse it as double */
8bfed902 2509 *frame_rate_base = DEFAULT_FRAME_RATE_BASE; //FIXME use av_d2q()
445f1b83
RS
2510 *frame_rate = (int)(strtod(arg, 0) * (*frame_rate_base) + 0.5);
2511 }
2512 if (!*frame_rate || !*frame_rate_base)
2513 return -1;
2514 else
2515 return 0;
2516}
2517
916c80e9
FB
2518/* Syntax:
2519 * - If not a duration:
2520 * [{YYYY-MM-DD|YYYYMMDD}]{T| }{HH[:MM[:SS[.m...]]][Z]|HH[MM[SS[.m...]]][Z]}
c5510dd6 2521 * Time is localtime unless Z is suffixed to the end. In this case GMT
916c80e9
FB
2522 * Return the date in micro seconds since 1970
2523 * - If duration:
2524 * HH[:MM[:SS[.m...]]]
2525 * S+[.m...]
2526 */
0c1a9eda 2527int64_t parse_date(const char *datestr, int duration)
de6d9b64
FB
2528{
2529 const char *p;
0c1a9eda 2530 int64_t t;
2dbceb9f 2531 struct tm dt;
c5510dd6
PG
2532 int i;
2533 static const char *date_fmt[] = {
2534 "%Y-%m-%d",
2535 "%Y%m%d",
2536 };
2537 static const char *time_fmt[] = {
2538 "%H:%M:%S",
2539 "%H%M%S",
2540 };
2541 const char *q;
916c80e9 2542 int is_utc, len;
c5510dd6 2543 char lastch;
a6a92a9a 2544 int negative = 0;
6d8f985e
MN
2545
2546#undef time
c5510dd6
PG
2547 time_t now = time(0);
2548
916c80e9
FB
2549 len = strlen(datestr);
2550 if (len > 0)
2551 lastch = datestr[len - 1];
2552 else
2553 lastch = '\0';
c5510dd6 2554 is_utc = (lastch == 'z' || lastch == 'Z');
2dbceb9f
PG
2555
2556 memset(&dt, 0, sizeof(dt));
de6d9b64
FB
2557
2558 p = datestr;
916c80e9 2559 q = NULL;
de6d9b64 2560 if (!duration) {
c5510dd6 2561 for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
f71869a4 2562 q = small_strptime(p, date_fmt[i], &dt);
c5510dd6
PG
2563 if (q) {
2564 break;
2565 }
2566 }
2567
2568 if (!q) {
2569 if (is_utc) {
2570 dt = *gmtime(&now);
2571 } else {
2572 dt = *localtime(&now);
2573 }
2574 dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
de6d9b64 2575 } else {
c5510dd6 2576 p = q;
de6d9b64 2577 }
c5510dd6
PG
2578
2579 if (*p == 'T' || *p == 't' || *p == ' ')
2580 p++;
c5510dd6 2581
916c80e9 2582 for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
f71869a4 2583 q = small_strptime(p, time_fmt[i], &dt);
916c80e9
FB
2584 if (q) {
2585 break;
2586 }
2587 }
2588 } else {
a6a92a9a
WG
2589 if (p[0] == '-') {
2590 negative = 1;
2591 ++p;
2592 }
f71869a4 2593 q = small_strptime(p, time_fmt[0], &dt);
916c80e9
FB
2594 if (!q) {
2595 dt.tm_sec = strtol(p, (char **)&q, 10);
2596 dt.tm_min = 0;
2597 dt.tm_hour = 0;
c5510dd6
PG
2598 }
2599 }
2600
2601 /* Now we have all the fields that we can get */
2602 if (!q) {
2603 if (duration)
2604 return 0;
2605 else
0c1a9eda 2606 return now * int64_t_C(1000000);
de6d9b64 2607 }
2dbceb9f
PG
2608
2609 if (duration) {
c5510dd6 2610 t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2dbceb9f 2611 } else {
c5510dd6
PG
2612 dt.tm_isdst = -1; /* unknown */
2613 if (is_utc) {
2614 t = mktimegm(&dt);
2615 } else {
2616 t = mktime(&dt);
2617 }
de6d9b64 2618 }
2dbceb9f 2619
c5510dd6
PG
2620 t *= 1000000;
2621
2622 if (*q == '.') {
de6d9b64 2623 int val, n;
c5510dd6
PG
2624 q++;
2625 for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
2626 if (!isdigit(*q))
2627 break;
2628 val += n * (*q - '0');
de6d9b64
FB
2629 }
2630 t += val;
2631 }
a6a92a9a 2632 return negative ? -t : t;
de6d9b64
FB
2633}
2634
2dbceb9f 2635/* syntax: '?tag1=val1&tag2=val2...'. Little URL decoding is done. Return
de6d9b64
FB
2636 1 if found */
2637int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
2638{
2639 const char *p;
2640 char tag[128], *q;
2641
2642 p = info;
2643 if (*p == '?')
2644 p++;
2645 for(;;) {
2646 q = tag;
2647 while (*p != '\0' && *p != '=' && *p != '&') {
2648 if ((q - tag) < sizeof(tag) - 1)
2649 *q++ = *p;
2650 p++;
2651 }
2652 *q = '\0';
2653 q = arg;
2654 if (*p == '=') {
2655 p++;
2656 while (*p != '&' && *p != '\0') {
2dbceb9f
PG
2657 if ((q - arg) < arg_size - 1) {
2658 if (*p == '+')
2659 *q++ = ' ';
2660 else
2661 *q++ = *p;
2662 }
de6d9b64
FB
2663 p++;
2664 }
2665 *q = '\0';
2666 }
2667 if (!strcmp(tag, tag1))
2668 return 1;
2669 if (*p != '&')
2670 break;
8d1335ea 2671 p++;
de6d9b64
FB
2672 }
2673 return 0;
2674}
2675
9150f42e
FB
2676/* Return in 'buf' the path with '%d' replaced by number. Also handles
2677 the '%0nd' format where 'n' is the total number of digits and
2678 '%%'. Return 0 if OK, and -1 if format error */
2679int get_frame_filename(char *buf, int buf_size,
2680 const char *path, int number)
2681{
2682 const char *p;
0bf92f79
PI
2683 char *q, buf1[20], c;
2684 int nd, len, percentd_found;
9150f42e
FB
2685
2686 q = buf;
2687 p = path;
2688 percentd_found = 0;
2689 for(;;) {
2690 c = *p++;
2691 if (c == '\0')
2692 break;
2693 if (c == '%') {
c9646fda
PG
2694 do {
2695 nd = 0;
2696 while (isdigit(*p)) {
2697 nd = nd * 10 + *p++ - '0';
2698 }
2699 c = *p++;
c9646fda
PG
2700 } while (isdigit(c));
2701
9150f42e
FB
2702 switch(c) {
2703 case '%':
2704 goto addchar;
2705 case 'd':
2706 if (percentd_found)
2707 goto fail;
2708 percentd_found = 1;
2709 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
2710 len = strlen(buf1);
2711 if ((q - buf + len) > buf_size - 1)
2712 goto fail;
2713 memcpy(q, buf1, len);
2714 q += len;
2715 break;
2716 default:
2717 goto fail;
2718 }
2719 } else {
2720 addchar:
2721 if ((q - buf) < buf_size - 1)
2722 *q++ = c;
2723 }
2724 }
2725 if (!percentd_found)
2726 goto fail;
2727 *q = '\0';
2728 return 0;
2729 fail:
2730 *q = '\0';
2731 return -1;
2732}
2733
b9a281db 2734/**
fb2758c8
FB
2735 * Print nice hexa dump of a buffer
2736 * @param f stream for output
b9a281db
FB
2737 * @param buf buffer
2738 * @param size buffer size
2739 */
fb2758c8 2740void av_hex_dump(FILE *f, uint8_t *buf, int size)
b9a281db
FB
2741{
2742 int len, i, j, c;
2743
2744 for(i=0;i<size;i+=16) {
2745 len = size - i;
2746 if (len > 16)
2747 len = 16;
fb2758c8 2748 fprintf(f, "%08x ", i);
b9a281db
FB
2749 for(j=0;j<16;j++) {
2750 if (j < len)
fb2758c8 2751 fprintf(f, " %02x", buf[i+j]);
b9a281db 2752 else
fb2758c8 2753 fprintf(f, " ");
b9a281db 2754 }
fb2758c8 2755 fprintf(f, " ");
b9a281db
FB
2756 for(j=0;j<len;j++) {
2757 c = buf[i+j];
2758 if (c < ' ' || c > '~')
2759 c = '.';
fb2758c8 2760 fprintf(f, "%c", c);
b9a281db 2761 }
fb2758c8 2762 fprintf(f, "\n");
b9a281db
FB
2763 }
2764}
2765
fb2758c8
FB
2766/**
2767 * Print on 'f' a nice dump of a packet
2768 * @param f stream for output
2769 * @param pkt packet to dump
2770 * @param dump_payload true if the payload must be displayed too
2771 */
c0df9d75 2772 //FIXME needs to know the time_base
fb2758c8
FB
2773void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
2774{
2775 fprintf(f, "stream #%d:\n", pkt->stream_index);
2776 fprintf(f, " keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
2777 fprintf(f, " duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
37353960
FB
2778 /* DTS is _always_ valid after av_read_frame() */
2779 fprintf(f, " dts=");
2780 if (pkt->dts == AV_NOPTS_VALUE)
2781 fprintf(f, "N/A");
2782 else
2783 fprintf(f, "%0.3f", (double)pkt->dts / AV_TIME_BASE);
fb2758c8
FB
2784 /* PTS may be not known if B frames are present */
2785 fprintf(f, " pts=");
2786 if (pkt->pts == AV_NOPTS_VALUE)
2787 fprintf(f, "N/A");
2788 else
2789 fprintf(f, "%0.3f", (double)pkt->pts / AV_TIME_BASE);
2790 fprintf(f, "\n");
2791 fprintf(f, " size=%d\n", pkt->size);
2792 if (dump_payload)
2793 av_hex_dump(f, pkt->data, pkt->size);
2794}
2795
a9a721da 2796void url_split(char *proto, int proto_size,
6ba5cbc6 2797 char *authorization, int authorization_size,
a9a721da
FB
2798 char *hostname, int hostname_size,
2799 int *port_ptr,
2800 char *path, int path_size,
2801 const char *url)
2802{
2803 const char *p;
2804 char *q;
2805 int port;
2806
2807 port = -1;
2808
2809 p = url;
2810 q = proto;
2811 while (*p != ':' && *p != '\0') {
2812 if ((q - proto) < proto_size - 1)
2813 *q++ = *p;
2814 p++;
2815 }
2816 if (proto_size > 0)
2817 *q = '\0';
6ba5cbc6
PD
2818 if (authorization_size > 0)
2819 authorization[0] = '\0';
a9a721da
FB
2820 if (*p == '\0') {
2821 if (proto_size > 0)
2822 proto[0] = '\0';
2823 if (hostname_size > 0)
2824 hostname[0] = '\0';
2825 p = url;
2826 } else {
6ba5cbc6
PD
2827 char *at,*slash; // PETR: position of '@' character and '/' character
2828
a9a721da
FB
2829 p++;
2830 if (*p == '/')
2831 p++;
2832 if (*p == '/')
2833 p++;
6ba5cbc6
PD
2834 at = strchr(p,'@'); // PETR: get the position of '@'
2835 slash = strchr(p,'/'); // PETR: get position of '/' - end of hostname
2836 if (at && slash && at > slash) at = NULL; // PETR: not interested in '@' behind '/'
2837
2838 q = at ? authorization : hostname; // PETR: if '@' exists starting with auth.
2839
2840 while ((at || *p != ':') && *p != '/' && *p != '?' && *p != '\0') { // PETR:
2841 if (*p == '@') { // PETR: passed '@'
2842 if (authorization_size > 0)
2843 *q = '\0';
2844 q = hostname;
2845 at = NULL;
2846 } else if (!at) { // PETR: hostname
2847 if ((q - hostname) < hostname_size - 1)
2848 *q++ = *p;
2849 } else {
2850 if ((q - authorization) < authorization_size - 1)
a9a721da 2851 *q++ = *p;
6ba5cbc6 2852 }
a9a721da
FB
2853 p++;
2854 }
2855 if (hostname_size > 0)
2856 *q = '\0';
2857 if (*p == ':') {
2858 p++;
2859 port = strtoul(p, (char **)&p, 10);
2860 }
2861 }
2862 if (port_ptr)
2863 *port_ptr = port;
2864 pstrcpy(path, path_size, p);
2865}
2866
916c80e9
FB
2867/**
2868 * Set the pts for a given stream
2869 * @param s stream
2870 * @param pts_wrap_bits number of bits effectively used by the pts
2871 * (used for wrap control, 33 is the value for MPEG)
2872 * @param pts_num numerator to convert to seconds (MPEG: 1)
2873 * @param pts_den denominator to convert to seconds (MPEG: 90000)
2874 */
9ee91c2f 2875void av_set_pts_info(AVStream *s, int pts_wrap_bits,
916c80e9
FB
2876 int pts_num, int pts_den)
2877{
2878 s->pts_wrap_bits = pts_wrap_bits;
9ee91c2f
MN
2879 s->time_base.num = pts_num;
2880 s->time_base.den = pts_den;
916c80e9
FB
2881}
2882
2883/* fraction handling */
2884
2885/**
2886 * f = val + (num / den) + 0.5. 'num' is normalized so that it is such
2887 * as 0 <= num < den.
2888 *
2889 * @param f fractional number
2890 * @param val integer value
2891 * @param num must be >= 0
2892 * @param den must be >= 1
2893 */
0c1a9eda 2894void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
916c80e9
FB
2895{
2896 num += (den >> 1);
2897 if (num >= den) {
2898 val += num / den;
2899 num = num % den;
2900 }
2901 f->val = val;
2902 f->num = num;
2903 f->den = den;
2904}
2905
2906/* set f to (val + 0.5) */
0c1a9eda 2907void av_frac_set(AVFrac *f, int64_t val)
916c80e9
FB
2908{
2909 f->val = val;
2910 f->num = f->den >> 1;
2911}
2912
2913/**
2914 * Fractionnal addition to f: f = f + (incr / f->den)
2915 *
2916 * @param f fractional number
2917 * @param incr increment, can be positive or negative
2918 */
0c1a9eda 2919void av_frac_add(AVFrac *f, int64_t incr)
916c80e9 2920{
0c1a9eda 2921 int64_t num, den;
916c80e9
FB
2922
2923 num = f->num + incr;
2924 den = f->den;
2925 if (num < 0) {
2926 f->val += num / den;
2927 num = num % den;
2928 if (num < 0) {
2929 num += den;
2930 f->val--;
2931 }
2932 } else if (num >= den) {
2933 f->val += num / den;
2934 num = num % den;
2935 }
2936 f->num = num;
2937}
87a0a681
FB
2938
2939/**
2940 * register a new image format
2941 * @param img_fmt Image format descriptor
2942 */
2943void av_register_image_format(AVImageFormat *img_fmt)
2944{
2945 AVImageFormat **p;
2946
2947 p = &first_image_format;
2948 while (*p != NULL) p = &(*p)->next;
2949 *p = img_fmt;
2950 img_fmt->next = NULL;
2951}
2952
2953/* guess image format */
2954AVImageFormat *av_probe_image_format(AVProbeData *pd)
2955{
2956 AVImageFormat *fmt1, *fmt;
2957 int score, score_max;
2958
2959 fmt = NULL;
2960 score_max = 0;
2961 for(fmt1 = first_image_format; fmt1 != NULL; fmt1 = fmt1->next) {
2962 if (fmt1->img_probe) {
2963 score = fmt1->img_probe(pd);
2964 if (score > score_max) {
2965 score_max = score;
2966 fmt = fmt1;
2967 }
2968 }
2969 }
2970 return fmt;
2971}
2972
2973AVImageFormat *guess_image_format(const char *filename)
2974{
2975 AVImageFormat *fmt1;
2976
2977 for(fmt1 = first_image_format; fmt1 != NULL; fmt1 = fmt1->next) {
2978 if (fmt1->extensions && match_ext(filename, fmt1->extensions))
2979 return fmt1;
2980 }
2981 return NULL;
2982}
2983
2984/**
2985 * Read an image from a stream.
2986 * @param gb byte stream containing the image
2987 * @param fmt image format, NULL if probing is required
2988 */
2989int av_read_image(ByteIOContext *pb, const char *filename,
2990 AVImageFormat *fmt,
2991 int (*alloc_cb)(void *, AVImageInfo *info), void *opaque)
2992{
2993 char buf[PROBE_BUF_SIZE];
2994 AVProbeData probe_data, *pd = &probe_data;
2995 offset_t pos;
2996 int ret;
2997
2998 if (!fmt) {
5c91a675 2999 pd->filename = filename;
87a0a681
FB
3000 pd->buf = buf;
3001 pos = url_ftell(pb);
3002 pd->buf_size = get_buffer(pb, buf, PROBE_BUF_SIZE);
3003 url_fseek(pb, pos, SEEK_SET);
3004 fmt = av_probe_image_format(pd);
3005 }
3006 if (!fmt)
3007 return AVERROR_NOFMT;
3008 ret = fmt->img_read(pb, alloc_cb, opaque);
3009 return ret;
3010}
3011
3012/**
3013 * Write an image to a stream.
3014 * @param pb byte stream for the image output
3015 * @param fmt image format
3016 * @param img image data and informations
3017 */
3018int av_write_image(ByteIOContext *pb, AVImageFormat *fmt, AVImageInfo *img)
3019{
3020 return fmt->img_write(pb, img);
3021}
3022