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