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