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