av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
[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
b9a281db
FB
24AVInputFormat *first_iformat;
25AVOutputFormat *first_oformat;
87a0a681 26AVImageFormat *first_image_format;
de6d9b64 27
b9a281db 28void av_register_input_format(AVInputFormat *format)
de6d9b64 29{
b9a281db
FB
30 AVInputFormat **p;
31 p = &first_iformat;
32 while (*p != NULL) p = &(*p)->next;
33 *p = format;
34 format->next = NULL;
35}
36
37void av_register_output_format(AVOutputFormat *format)
38{
39 AVOutputFormat **p;
40 p = &first_oformat;
de6d9b64
FB
41 while (*p != NULL) p = &(*p)->next;
42 *p = format;
43 format->next = NULL;
44}
45
5b25dfa7 46int match_ext(const char *filename, const char *extensions)
de6d9b64
FB
47{
48 const char *ext, *p;
49 char ext1[32], *q;
50
51 ext = strrchr(filename, '.');
52 if (ext) {
53 ext++;
54 p = extensions;
55 for(;;) {
56 q = ext1;
57 while (*p != '\0' && *p != ',')
58 *q++ = *p++;
59 *q = '\0';
60 if (!strcasecmp(ext1, ext))
61 return 1;
62 if (*p == '\0')
63 break;
64 p++;
65 }
66 }
67 return 0;
68}
69
b9a281db
FB
70AVOutputFormat *guess_format(const char *short_name, const char *filename,
71 const char *mime_type)
de6d9b64 72{
b9a281db 73 AVOutputFormat *fmt, *fmt_found;
de6d9b64
FB
74 int score_max, score;
75
87a0a681 76 /* specific test for image sequences */
94d883e8
FB
77 if (!short_name && filename &&
78 filename_number_test(filename) >= 0 &&
79 guess_image_format(filename)) {
87a0a681
FB
80 return guess_format("image", NULL, NULL);
81 }
82
de6d9b64
FB
83 /* find the proper file type */
84 fmt_found = NULL;
85 score_max = 0;
b9a281db 86 fmt = first_oformat;
de6d9b64
FB
87 while (fmt != NULL) {
88 score = 0;
89 if (fmt->name && short_name && !strcmp(fmt->name, short_name))
90 score += 100;
91 if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
92 score += 10;
93 if (filename && fmt->extensions &&
94 match_ext(filename, fmt->extensions)) {
95 score += 5;
96 }
97 if (score > score_max) {
98 score_max = score;
99 fmt_found = fmt;
100 }
101 fmt = fmt->next;
102 }
103 return fmt_found;
104}
105
c5510dd6
PG
106AVOutputFormat *guess_stream_format(const char *short_name, const char *filename,
107 const char *mime_type)
108{
109 AVOutputFormat *fmt = guess_format(short_name, filename, mime_type);
110
111 if (fmt) {
112 AVOutputFormat *stream_fmt;
113 char stream_format_name[64];
114
115 snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
116 stream_fmt = guess_format(stream_format_name, NULL, NULL);
117
118 if (stream_fmt)
119 fmt = stream_fmt;
120 }
121
122 return fmt;
123}
124
b9a281db
FB
125AVInputFormat *av_find_input_format(const char *short_name)
126{
127 AVInputFormat *fmt;
128 for(fmt = first_iformat; fmt != NULL; fmt = fmt->next) {
129 if (!strcmp(fmt->name, short_name))
130 return fmt;
131 }
132 return NULL;
133}
134
de6d9b64
FB
135/* memory handling */
136
b9a281db 137/**
6fa5a56c
FB
138 * Default packet destructor
139 */
140static void av_destruct_packet(AVPacket *pkt)
141{
142 av_free(pkt->data);
143 pkt->data = NULL; pkt->size = 0;
144}
145
146/**
b9a281db
FB
147 * Allocate the payload of a packet and intialized its fields to default values.
148 *
149 * @param pkt packet
150 * @param size wanted payload size
151 * @return 0 if OK. AVERROR_xxx otherwise.
152 */
de6d9b64
FB
153int av_new_packet(AVPacket *pkt, int size)
154{
6fa5a56c
FB
155 void *data = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
156 if (!data)
b9a281db 157 return AVERROR_NOMEM;
6fa5a56c 158 memset(data + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
8cd5be98 159
6fa5a56c
FB
160 av_init_packet(pkt);
161 pkt->data = data;
162 pkt->size = size;
163 pkt->destruct = av_destruct_packet;
de6d9b64
FB
164 return 0;
165}
166
fb2758c8
FB
167/* This is a hack - the packet memory allocation stuff is broken. The
168 packet is allocated if it was not really allocated */
169int av_dup_packet(AVPacket *pkt)
170{
171 if (pkt->destruct != av_destruct_packet) {
172 uint8_t *data;
8a56ac7b
FB
173 /* we duplicate the packet and don't forget to put the padding
174 again */
175 data = av_malloc(pkt->size + FF_INPUT_BUFFER_PADDING_SIZE);
fb2758c8
FB
176 if (!data) {
177 return AVERROR_NOMEM;
178 }
179 memcpy(data, pkt->data, pkt->size);
8a56ac7b 180 memset(data + pkt->size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
fb2758c8
FB
181 pkt->data = data;
182 pkt->destruct = av_destruct_packet;
183 }
184 return 0;
185}
186
de6d9b64
FB
187/* fifo handling */
188
189int fifo_init(FifoBuffer *f, int size)
190{
1ea4f593 191 f->buffer = av_malloc(size);
de6d9b64
FB
192 if (!f->buffer)
193 return -1;
194 f->end = f->buffer + size;
195 f->wptr = f->rptr = f->buffer;
196 return 0;
197}
198
199void fifo_free(FifoBuffer *f)
200{
1ea4f593 201 av_free(f->buffer);
de6d9b64
FB
202}
203
0c1a9eda 204int fifo_size(FifoBuffer *f, uint8_t *rptr)
de6d9b64
FB
205{
206 int size;
207
208 if (f->wptr >= rptr) {
209 size = f->wptr - rptr;
210 } else {
211 size = (f->end - rptr) + (f->wptr - f->buffer);
212 }
213 return size;
214}
215
216/* get data from the fifo (return -1 if not enough data) */
0c1a9eda 217int fifo_read(FifoBuffer *f, uint8_t *buf, int buf_size, uint8_t **rptr_ptr)
de6d9b64 218{
0c1a9eda 219 uint8_t *rptr = *rptr_ptr;
de6d9b64
FB
220 int size, len;
221
222 if (f->wptr >= rptr) {
223 size = f->wptr - rptr;
224 } else {
225 size = (f->end - rptr) + (f->wptr - f->buffer);
226 }
227
228 if (size < buf_size)
229 return -1;
230 while (buf_size > 0) {
231 len = f->end - rptr;
232 if (len > buf_size)
233 len = buf_size;
234 memcpy(buf, rptr, len);
235 buf += len;
236 rptr += len;
237 if (rptr >= f->end)
238 rptr = f->buffer;
239 buf_size -= len;
240 }
241 *rptr_ptr = rptr;
242 return 0;
243}
244
0c1a9eda 245void fifo_write(FifoBuffer *f, uint8_t *buf, int size, uint8_t **wptr_ptr)
de6d9b64
FB
246{
247 int len;
0c1a9eda 248 uint8_t *wptr;
de6d9b64
FB
249 wptr = *wptr_ptr;
250 while (size > 0) {
251 len = f->end - wptr;
252 if (len > size)
253 len = size;
254 memcpy(wptr, buf, len);
255 wptr += len;
256 if (wptr >= f->end)
257 wptr = f->buffer;
258 buf += len;
259 size -= len;
260 }
261 *wptr_ptr = wptr;
262}
263
b9a281db
FB
264int filename_number_test(const char *filename)
265{
266 char buf[1024];
267 return get_frame_filename(buf, sizeof(buf), filename, 1);
268}
269
270/* guess file format */
a25e098d 271AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened)
b9a281db
FB
272{
273 AVInputFormat *fmt1, *fmt;
274 int score, score_max;
275
276 fmt = NULL;
277 score_max = 0;
278 for(fmt1 = first_iformat; fmt1 != NULL; fmt1 = fmt1->next) {
279 if (!is_opened && !(fmt1->flags & AVFMT_NOFILE))
280 continue;
281 score = 0;
a8dbe951
PG
282 if (fmt1->read_probe) {
283 score = fmt1->read_probe(pd);
284 } else if (fmt1->extensions) {
b9a281db
FB
285 if (match_ext(pd->filename, fmt1->extensions)) {
286 score = 50;
287 }
a8dbe951 288 }
b9a281db
FB
289 if (score > score_max) {
290 score_max = score;
291 fmt = fmt1;
292 }
293 }
294 return fmt;
295}
296
297/************************************************************/
298/* input media file */
96baaa6a 299
da24c5e3
FB
300/**
301 * open a media file from an IO stream. 'fmt' must be specified.
302 */
bc874dae
MB
303
304static const char* format_to_name(void* class_ptr)
305{
306 AVFormatContext* fc = (AVFormatContext*) class_ptr;
307 if(fc->iformat) return fc->iformat->name;
308 else if(fc->oformat) return fc->oformat->name;
309 else return "NULL";
310}
311
312static const AVClass av_format_context_class = { "AVFormatContext", format_to_name };
313
314AVFormatContext *av_alloc_format_context(void)
315{
316 AVFormatContext *ic;
317 ic = av_mallocz(sizeof(AVFormatContext));
318 if (!ic) return ic;
319 ic->class = av_format_context_class;
320 return ic;
321}
322
da24c5e3
FB
323int av_open_input_stream(AVFormatContext **ic_ptr,
324 ByteIOContext *pb, const char *filename,
325 AVInputFormat *fmt, AVFormatParameters *ap)
326{
327 int err;
328 AVFormatContext *ic;
329
bc874dae 330 ic = av_alloc_format_context();
da24c5e3
FB
331 if (!ic) {
332 err = AVERROR_NOMEM;
333 goto fail;
334 }
335 ic->iformat = fmt;
336 if (pb)
337 ic->pb = *pb;
338 ic->duration = AV_NOPTS_VALUE;
339 ic->start_time = AV_NOPTS_VALUE;
340 pstrcpy(ic->filename, sizeof(ic->filename), filename);
341
342 /* allocate private data */
343 if (fmt->priv_data_size > 0) {
344 ic->priv_data = av_mallocz(fmt->priv_data_size);
345 if (!ic->priv_data) {
346 err = AVERROR_NOMEM;
347 goto fail;
348 }
349 } else {
350 ic->priv_data = NULL;
351 }
352
353 /* default pts settings is MPEG like */
354 av_set_pts_info(ic, 33, 1, 90000);
fb2758c8
FB
355 ic->last_pkt_pts = AV_NOPTS_VALUE;
356 ic->last_pkt_dts = AV_NOPTS_VALUE;
357 ic->last_pkt_stream_pts = AV_NOPTS_VALUE;
358 ic->last_pkt_stream_dts = AV_NOPTS_VALUE;
359
da24c5e3
FB
360 err = ic->iformat->read_header(ic, ap);
361 if (err < 0)
362 goto fail;
fb2758c8
FB
363
364 if (pb)
365 ic->data_offset = url_ftell(&ic->pb);
366
da24c5e3
FB
367 *ic_ptr = ic;
368 return 0;
369 fail:
370 if (ic) {
371 av_freep(&ic->priv_data);
372 }
373 av_free(ic);
374 *ic_ptr = NULL;
375 return err;
376}
377
b9a281db
FB
378#define PROBE_BUF_SIZE 2048
379
380/**
381 * Open a media file as input. The codec are not opened. Only the file
382 * header (if present) is read.
383 *
384 * @param ic_ptr the opened media file handle is put here
385 * @param filename filename to open.
386 * @param fmt if non NULL, force the file format to use
387 * @param buf_size optional buffer size (zero if default is OK)
388 * @param ap additionnal parameters needed when opening the file (NULL if default)
389 * @return 0 if OK. AVERROR_xxx otherwise.
390 */
391int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
392 AVInputFormat *fmt,
393 int buf_size,
394 AVFormatParameters *ap)
de6d9b64 395{
da24c5e3
FB
396 int err, must_open_file, file_opened;
397 uint8_t buf[PROBE_BUF_SIZE];
b9a281db 398 AVProbeData probe_data, *pd = &probe_data;
da24c5e3
FB
399 ByteIOContext pb1, *pb = &pb1;
400
401 file_opened = 0;
402 pd->filename = "";
403 if (filename)
404 pd->filename = filename;
b9a281db
FB
405 pd->buf = buf;
406 pd->buf_size = 0;
407
408 if (!fmt) {
409 /* guess format if no file can be opened */
a25e098d 410 fmt = av_probe_input_format(pd, 0);
de6d9b64 411 }
de6d9b64 412
b6892136
FB
413 /* do not open file if the format does not need it. XXX: specific
414 hack needed to handle RTSP/TCP */
415 must_open_file = 1;
da24c5e3 416 if (fmt && (fmt->flags & AVFMT_NOFILE)) {
b6892136
FB
417 must_open_file = 0;
418 }
419
420 if (!fmt || must_open_file) {
87a0a681 421 /* if no file needed do not try to open one */
da24c5e3 422 if (url_fopen(pb, filename, URL_RDONLY) < 0) {
b9a281db 423 err = AVERROR_IO;
96baaa6a 424 goto fail;
b9a281db 425 }
da24c5e3 426 file_opened = 1;
96baaa6a 427 if (buf_size > 0) {
da24c5e3 428 url_setbufsize(pb, buf_size);
96baaa6a 429 }
5b25dfa7
FB
430 if (!fmt) {
431 /* read probe data */
da24c5e3
FB
432 pd->buf_size = get_buffer(pb, buf, PROBE_BUF_SIZE);
433 url_fseek(pb, 0, SEEK_SET);
5b25dfa7 434 }
96baaa6a
FB
435 }
436
b9a281db
FB
437 /* guess file format */
438 if (!fmt) {
a25e098d 439 fmt = av_probe_input_format(pd, 1);
b9a281db
FB
440 }
441
442 /* if still no format found, error */
443 if (!fmt) {
444 err = AVERROR_NOFMT;
da24c5e3 445 goto fail;
de6d9b64 446 }
b9a281db 447
67d06418 448 /* XXX: suppress this hack for redirectors */
f3ec2d46 449#ifdef CONFIG_NETWORK
67d06418 450 if (fmt == &redir_demux) {
da24c5e3
FB
451 err = redir_open(ic_ptr, pb);
452 url_fclose(pb);
67d06418
FB
453 return err;
454 }
9b2e001f 455#endif
67d06418 456
87a0a681 457 /* check filename in case of an image number is expected */
da24c5e3
FB
458 if (fmt->flags & AVFMT_NEEDNUMBER) {
459 if (filename_number_test(filename) < 0) {
87a0a681 460 err = AVERROR_NUMEXPECTED;
da24c5e3 461 goto fail;
87a0a681
FB
462 }
463 }
da24c5e3
FB
464 err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
465 if (err)
466 goto fail;
b9a281db 467 return 0;
de6d9b64 468 fail:
da24c5e3
FB
469 if (file_opened)
470 url_fclose(pb);
b9a281db
FB
471 *ic_ptr = NULL;
472 return err;
da24c5e3 473
de6d9b64
FB
474}
475
da24c5e3
FB
476/*******************************************************/
477
b9a281db 478/**
fb2758c8
FB
479 * Read a transport packet from a media file. This function is
480 * absolete and should never be used. Use av_read_frame() instead.
da24c5e3 481 *
b9a281db
FB
482 * @param s media file handle
483 * @param pkt is filled
da24c5e3 484 * @return 0 if OK. AVERROR_xxx if error.
b9a281db 485 */
de6d9b64
FB
486int av_read_packet(AVFormatContext *s, AVPacket *pkt)
487{
fb2758c8
FB
488 return s->iformat->read_packet(s, pkt);
489}
490
491/**********************************************************/
492
493/* convert the packet time stamp units and handle wrapping. The
494 wrapping is handled by considering the next PTS/DTS as a delta to
495 the previous value. We handle the delta as a fraction to avoid any
496 rounding errors. */
497static inline int64_t convert_timestamp_units(AVFormatContext *s,
498 int64_t *plast_pkt_pts,
499 int *plast_pkt_pts_frac,
500 int64_t *plast_pkt_stream_pts,
501 int64_t pts)
502{
503 int64_t stream_pts;
504 int64_t delta_pts;
505 int shift, pts_frac;
506
507 if (pts != AV_NOPTS_VALUE) {
508 stream_pts = pts;
509 if (*plast_pkt_stream_pts != AV_NOPTS_VALUE) {
510 shift = 64 - s->pts_wrap_bits;
511 delta_pts = ((stream_pts - *plast_pkt_stream_pts) << shift) >> shift;
512 /* XXX: overflow possible but very unlikely as it is a delta */
513 delta_pts = delta_pts * AV_TIME_BASE * s->pts_num;
514 pts = *plast_pkt_pts + (delta_pts / s->pts_den);
515 pts_frac = *plast_pkt_pts_frac + (delta_pts % s->pts_den);
516 if (pts_frac >= s->pts_den) {
517 pts_frac -= s->pts_den;
518 pts++;
519 }
520 } else {
521 /* no previous pts, so no wrapping possible */
522 pts = (int64_t)(((double)stream_pts * AV_TIME_BASE * s->pts_num) /
523 (double)s->pts_den);
524 pts_frac = 0;
525 }
526 *plast_pkt_stream_pts = stream_pts;
527 *plast_pkt_pts = pts;
528 *plast_pkt_pts_frac = pts_frac;
529 }
530 return pts;
531}
532
533/* get the number of samples of an audio frame. Return (-1) if error */
534static int get_audio_frame_size(AVCodecContext *enc, int size)
535{
536 int frame_size;
537
538 if (enc->frame_size <= 1) {
539 /* specific hack for pcm codecs because no frame size is
540 provided */
541 switch(enc->codec_id) {
542 case CODEC_ID_PCM_S16LE:
543 case CODEC_ID_PCM_S16BE:
544 case CODEC_ID_PCM_U16LE:
545 case CODEC_ID_PCM_U16BE:
546 if (enc->channels == 0)
547 return -1;
548 frame_size = size / (2 * enc->channels);
549 break;
550 case CODEC_ID_PCM_S8:
551 case CODEC_ID_PCM_U8:
552 case CODEC_ID_PCM_MULAW:
553 case CODEC_ID_PCM_ALAW:
554 if (enc->channels == 0)
555 return -1;
556 frame_size = size / (enc->channels);
557 break;
558 default:
559 /* used for example by ADPCM codecs */
560 if (enc->bit_rate == 0)
561 return -1;
562 frame_size = (size * 8 * enc->sample_rate) / enc->bit_rate;
563 break;
564 }
565 } else {
566 frame_size = enc->frame_size;
567 }
568 return frame_size;
569}
570
571
572/* return the frame duration in seconds, return 0 if not available */
573static void compute_frame_duration(int *pnum, int *pden,
574 AVFormatContext *s, AVStream *st,
575 AVCodecParserContext *pc, AVPacket *pkt)
576{
577 int frame_size;
578
579 *pnum = 0;
580 *pden = 0;
581 switch(st->codec.codec_type) {
582 case CODEC_TYPE_VIDEO:
583 *pnum = st->codec.frame_rate_base;
584 *pden = st->codec.frame_rate;
585 if (pc && pc->repeat_pict) {
586 *pden *= 2;
587 *pnum = (*pnum) * (2 + pc->repeat_pict);
588 }
589 break;
590 case CODEC_TYPE_AUDIO:
591 frame_size = get_audio_frame_size(&st->codec, pkt->size);
592 if (frame_size < 0)
593 break;
594 *pnum = frame_size;
595 *pden = st->codec.sample_rate;
596 break;
597 default:
598 break;
599 }
600}
601
602static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
603 AVCodecParserContext *pc, AVPacket *pkt)
604{
605 int num, den, presentation_delayed;
606
607 if (pkt->duration == 0) {
608 compute_frame_duration(&num, &den, s, st, pc, pkt);
609 if (den && num) {
610 pkt->duration = (num * (int64_t)AV_TIME_BASE) / den;
611 }
612 }
613
614 /* do we have a video B frame ? */
615 presentation_delayed = 0;
616 if (st->codec.codec_type == CODEC_TYPE_VIDEO) {
617 /* XXX: need has_b_frame, but cannot get it if the codec is
618 not initialized */
619 if ((st->codec.codec_id == CODEC_ID_MPEG1VIDEO ||
620 st->codec.codec_id == CODEC_ID_MPEG2VIDEO ||
621 st->codec.codec_id == CODEC_ID_MPEG4 ||
622 st->codec.codec_id == CODEC_ID_H264) &&
623 pc && pc->pict_type != FF_B_TYPE)
624 presentation_delayed = 1;
625 }
626
627 /* interpolate PTS and DTS if they are not present */
628 if (presentation_delayed) {
629 /* DTS = decompression time stamp */
630 /* PTS = presentation time stamp */
631 if (pkt->dts == AV_NOPTS_VALUE) {
632 pkt->dts = st->cur_dts;
633 } else {
634 st->cur_dts = pkt->dts;
635 }
636 /* this is tricky: the dts must be incremented by the duration
637 of the frame we are displaying, i.e. the last I or P frame */
638 if (st->last_IP_duration == 0)
639 st->cur_dts += pkt->duration;
640 else
641 st->cur_dts += st->last_IP_duration;
642 st->last_IP_duration = pkt->duration;
643 /* cannot compute PTS if not present (we can compute it only
644 by knowing the futur */
645 } else {
646 /* presentation is not delayed : PTS and DTS are the same */
647 if (pkt->pts == AV_NOPTS_VALUE) {
2092bd75
GB
648 if (pkt->dts == AV_NOPTS_VALUE) {
649 pkt->pts = st->cur_dts;
650 pkt->dts = st->cur_dts;
651 }
652 else {
653 st->cur_dts = pkt->dts;
654 pkt->pts = pkt->dts;
655 }
fb2758c8
FB
656 } else {
657 st->cur_dts = pkt->pts;
658 pkt->dts = pkt->pts;
659 }
660 st->cur_dts += pkt->duration;
661 }
662
663 /* update flags */
664 if (pc) {
665 pkt->flags = 0;
666 /* key frame computation */
667 switch(st->codec.codec_type) {
668 case CODEC_TYPE_VIDEO:
669 if (pc->pict_type == FF_I_TYPE)
670 pkt->flags |= PKT_FLAG_KEY;
671 break;
672 case CODEC_TYPE_AUDIO:
673 pkt->flags |= PKT_FLAG_KEY;
674 break;
675 default:
676 break;
677 }
678 }
679
680}
681
682static void av_destruct_packet_nofree(AVPacket *pkt)
683{
684 pkt->data = NULL; pkt->size = 0;
685}
686
687static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
688{
689 AVStream *st;
37353960 690 int len, ret, i;
fb2758c8
FB
691
692 for(;;) {
693 /* select current input stream component */
694 st = s->cur_st;
695 if (st) {
696 if (!st->parser) {
697 /* no parsing needed: we just output the packet as is */
698 /* raw data support */
699 *pkt = s->cur_pkt;
700 compute_pkt_fields(s, st, NULL, pkt);
701 s->cur_st = NULL;
702 return 0;
703 } else if (s->cur_len > 0) {
fb2758c8 704 len = av_parser_parse(st->parser, &st->codec, &pkt->data, &pkt->size,
6ec87caa
FB
705 s->cur_ptr, s->cur_len,
706 s->cur_pkt.pts, s->cur_pkt.dts);
707 s->cur_pkt.pts = AV_NOPTS_VALUE;
708 s->cur_pkt.dts = AV_NOPTS_VALUE;
fb2758c8
FB
709 /* increment read pointer */
710 s->cur_ptr += len;
711 s->cur_len -= len;
712
713 /* return packet if any */
714 if (pkt->size) {
37353960 715 got_packet:
fb2758c8
FB
716 pkt->duration = 0;
717 pkt->stream_index = st->index;
6ec87caa
FB
718 pkt->pts = st->parser->pts;
719 pkt->dts = st->parser->dts;
fb2758c8
FB
720 pkt->destruct = av_destruct_packet_nofree;
721 compute_pkt_fields(s, st, st->parser, pkt);
fb2758c8
FB
722 return 0;
723 }
724 } else {
bcbecff1
FB
725 /* free packet */
726 av_free_packet(&s->cur_pkt);
fb2758c8
FB
727 s->cur_st = NULL;
728 }
729 } else {
fb2758c8
FB
730 /* read next packet */
731 ret = av_read_packet(s, &s->cur_pkt);
37353960
FB
732 if (ret < 0) {
733 if (ret == -EAGAIN)
734 return ret;
735 /* return the last frames, if any */
736 for(i = 0; i < s->nb_streams; i++) {
737 st = s->streams[i];
738 if (st->parser) {
739 av_parser_parse(st->parser, &st->codec,
740 &pkt->data, &pkt->size,
6ec87caa
FB
741 NULL, 0,
742 AV_NOPTS_VALUE, AV_NOPTS_VALUE);
37353960
FB
743 if (pkt->size)
744 goto got_packet;
745 }
746 }
747 /* no more packets: really terminates parsing */
fb2758c8 748 return ret;
37353960 749 }
fb2758c8
FB
750
751 /* convert the packet time stamp units and handle wrapping */
752 s->cur_pkt.pts = convert_timestamp_units(s,
753 &s->last_pkt_pts, &s->last_pkt_pts_frac,
754 &s->last_pkt_stream_pts,
755 s->cur_pkt.pts);
756 s->cur_pkt.dts = convert_timestamp_units(s,
757 &s->last_pkt_dts, &s->last_pkt_dts_frac,
758 &s->last_pkt_stream_dts,
759 s->cur_pkt.dts);
760#if 0
6ec87caa 761 if (s->cur_pkt.stream_index == 0) {
fb2758c8
FB
762 if (s->cur_pkt.pts != AV_NOPTS_VALUE)
763 printf("PACKET pts=%0.3f\n",
764 (double)s->cur_pkt.pts / AV_TIME_BASE);
765 if (s->cur_pkt.dts != AV_NOPTS_VALUE)
766 printf("PACKET dts=%0.3f\n",
767 (double)s->cur_pkt.dts / AV_TIME_BASE);
768 }
769#endif
770
771 /* duration field */
772 if (s->cur_pkt.duration != 0) {
773 s->cur_pkt.duration = ((int64_t)s->cur_pkt.duration * AV_TIME_BASE * s->pts_num) /
774 s->pts_den;
775 }
776
777 st = s->streams[s->cur_pkt.stream_index];
778 s->cur_st = st;
779 s->cur_ptr = s->cur_pkt.data;
780 s->cur_len = s->cur_pkt.size;
781 if (st->need_parsing && !st->parser) {
782 st->parser = av_parser_init(st->codec.codec_id);
783 if (!st->parser) {
784 /* no parser available : just output the raw packets */
785 st->need_parsing = 0;
786 }
787 }
788 }
789 }
790}
791
792/**
793 * Return the next frame of a stream. The returned packet is valid
794 * until the next av_read_frame() or until av_close_input_file() and
795 * must be freed with av_free_packet. For video, the packet contains
796 * exactly one frame. For audio, it contains an integer number of
797 * frames if each frame has a known fixed size (e.g. PCM or ADPCM
798 * data). If the audio frames have a variable size (e.g. MPEG audio),
799 * then it contains one frame.
800 *
801 * pkt->pts, pkt->dts and pkt->duration are always set to correct
802 * values in AV_TIME_BASE unit (and guessed if the format cannot
803 * provided them). pkt->pts can be AV_NOPTS_VALUE if the video format
804 * has B frames, so it is better to rely on pkt->dts if you do not
805 * decompress the payload.
806 *
807 * Return 0 if OK, < 0 if error or end of file.
808 */
809int av_read_frame(AVFormatContext *s, AVPacket *pkt)
810{
de6d9b64
FB
811 AVPacketList *pktl;
812
813 pktl = s->packet_buffer;
814 if (pktl) {
815 /* read packet from packet buffer, if there is data */
816 *pkt = pktl->pkt;
817 s->packet_buffer = pktl->next;
1ea4f593 818 av_free(pktl);
de6d9b64
FB
819 return 0;
820 } else {
fb2758c8
FB
821 return av_read_frame_internal(s, pkt);
822 }
823}
824
825/* XXX: suppress the packet queue */
826static void flush_packet_queue(AVFormatContext *s)
827{
828 AVPacketList *pktl;
829
830 for(;;) {
831 pktl = s->packet_buffer;
832 if (!pktl)
833 break;
834 s->packet_buffer = pktl->next;
835 av_free_packet(&pktl->pkt);
836 av_free(pktl);
b9a281db
FB
837 }
838}
839
da24c5e3 840/*******************************************************/
fb2758c8
FB
841/* seek support */
842
b754978a
MN
843int av_find_default_stream_index(AVFormatContext *s)
844{
845 int i;
846 AVStream *st;
847
848 if (s->nb_streams <= 0)
849 return -1;
850 for(i = 0; i < s->nb_streams; i++) {
851 st = s->streams[i];
852 if (st->codec.codec_type == CODEC_TYPE_VIDEO) {
853 return i;
854 }
855 }
856 return 0;
857}
858
fb2758c8
FB
859/* flush the frame reader */
860static void av_read_frame_flush(AVFormatContext *s)
861{
862 AVStream *st;
863 int i;
864
865 flush_packet_queue(s);
866
867 /* free previous packet */
868 if (s->cur_st) {
869 if (s->cur_st->parser)
870 av_free_packet(&s->cur_pkt);
871 s->cur_st = NULL;
872 }
873 /* fail safe */
874 s->cur_ptr = NULL;
875 s->cur_len = 0;
876
877 /* for each stream, reset read state */
878 for(i = 0; i < s->nb_streams; i++) {
879 st = s->streams[i];
880
881 if (st->parser) {
882 av_parser_close(st->parser);
883 st->parser = NULL;
884 }
fb2758c8
FB
885 st->cur_dts = 0; /* we set the current DTS to an unspecified origin */
886 }
887}
888
b754978a 889/* add a index entry into a sorted list updateing if it is already there */
3e9245a9
MN
890int av_add_index_entry(AVStream *st,
891 int64_t pos, int64_t timestamp, int distance, int flags)
fb2758c8
FB
892{
893 AVIndexEntry *entries, *ie;
b754978a 894 int index;
fb2758c8
FB
895
896 entries = av_fast_realloc(st->index_entries,
897 &st->index_entries_allocated_size,
898 (st->nb_index_entries + 1) *
899 sizeof(AVIndexEntry));
b754978a
MN
900 st->index_entries= entries;
901
902 if(st->nb_index_entries){
903 index= av_index_search_timestamp(st, timestamp);
904 ie= &entries[index];
905
906 if(ie->timestamp != timestamp){
907 if(ie->timestamp < timestamp){
908 index++; //index points to next instead of previous entry, maybe nonexistant
909 ie= &st->index_entries[index];
910 }else
911 assert(index==0);
912
913 if(index != st->nb_index_entries){
914 assert(index < st->nb_index_entries);
915 memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
916 }
917 st->nb_index_entries++;
918 }
3e9245a9
MN
919 }else{
920 index= st->nb_index_entries++;
921 ie= &entries[index];
922 }
b754978a
MN
923
924 ie->pos = pos;
925 ie->timestamp = timestamp;
3e9245a9 926 ie->min_distance= distance;
b754978a 927 ie->flags = flags;
3e9245a9
MN
928
929 return index;
fb2758c8
FB
930}
931
932/* build an index for raw streams using a parser */
933static void av_build_index_raw(AVFormatContext *s)
934{
935 AVPacket pkt1, *pkt = &pkt1;
936 int ret;
937 AVStream *st;
938
939 st = s->streams[0];
940 av_read_frame_flush(s);
941 url_fseek(&s->pb, s->data_offset, SEEK_SET);
942
943 for(;;) {
944 ret = av_read_frame(s, pkt);
945 if (ret < 0)
946 break;
947 if (pkt->stream_index == 0 && st->parser &&
948 (pkt->flags & PKT_FLAG_KEY)) {
b754978a 949 av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
3e9245a9 950 0, AVINDEX_KEYFRAME);
fb2758c8
FB
951 }
952 av_free_packet(pkt);
953 }
954}
955
956/* return TRUE if we deal with a raw stream (raw codec data and
957 parsing needed) */
958static int is_raw_stream(AVFormatContext *s)
959{
960 AVStream *st;
961
962 if (s->nb_streams != 1)
963 return 0;
964 st = s->streams[0];
965 if (!st->need_parsing)
966 return 0;
967 return 1;
968}
969
970/* return the largest index entry whose timestamp is <=
971 wanted_timestamp */
b754978a 972int av_index_search_timestamp(AVStream *st, int wanted_timestamp)
fb2758c8 973{
b754978a
MN
974 AVIndexEntry *entries= st->index_entries;
975 int nb_entries= st->nb_index_entries;
fb2758c8
FB
976 int a, b, m;
977 int64_t timestamp;
978
979 if (nb_entries <= 0)
980 return -1;
981
982 a = 0;
983 b = nb_entries - 1;
b754978a
MN
984
985 while (a < b) {
986 m = (a + b + 1) >> 1;
fb2758c8 987 timestamp = entries[m].timestamp;
b754978a 988 if (timestamp > wanted_timestamp) {
fb2758c8
FB
989 b = m - 1;
990 } else {
b754978a 991 a = m;
fb2758c8
FB
992 }
993 }
b754978a 994 return a;
fb2758c8
FB
995}
996
997static int av_seek_frame_generic(AVFormatContext *s,
998 int stream_index, int64_t timestamp)
999{
1000 int index;
1001 AVStream *st;
1002 AVIndexEntry *ie;
1003
1004 if (!s->index_built) {
1005 if (is_raw_stream(s)) {
1006 av_build_index_raw(s);
1007 } else {
1008 return -1;
1009 }
1010 s->index_built = 1;
1011 }
1012
1013 if (stream_index < 0)
1014 stream_index = 0;
1015 st = s->streams[stream_index];
b754978a 1016 index = av_index_search_timestamp(st, timestamp);
fb2758c8
FB
1017 if (index < 0)
1018 return -1;
1019
1020 /* now we have found the index, we can seek */
1021 ie = &st->index_entries[index];
1022 av_read_frame_flush(s);
1023 url_fseek(&s->pb, ie->pos, SEEK_SET);
1024 st->cur_dts = ie->timestamp;
1025 return 0;
1026}
1027
1028/**
1029 * Seek to the key frame just before the frame at timestamp
1030 * 'timestamp' in 'stream_index'. If stream_index is (-1), a default
1031 * stream is selected
1032 */
1033int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp)
1034{
1035 int ret;
1036
1037 av_read_frame_flush(s);
1038
1039 /* first, we try the format specific seek */
1040 if (s->iformat->read_seek)
1041 ret = s->iformat->read_seek(s, stream_index, timestamp);
1042 else
1043 ret = -1;
1044 if (ret >= 0) {
1045 return 0;
1046 }
1047
1048 return av_seek_frame_generic(s, stream_index, timestamp);
1049}
1050
1051/*******************************************************/
12f996ed
FB
1052
1053/* return TRUE if the stream has accurate timings for at least one component */
1054static int av_has_timings(AVFormatContext *ic)
1055{
1056 int i;
1057 AVStream *st;
1058
1059 for(i = 0;i < ic->nb_streams; i++) {
1060 st = ic->streams[i];
1061 if (st->start_time != AV_NOPTS_VALUE &&
1062 st->duration != AV_NOPTS_VALUE)
1063 return 1;
1064 }
1065 return 0;
1066}
1067
1068/* estimate the stream timings from the one of each components. Also
1069 compute the global bitrate if possible */
1070static void av_update_stream_timings(AVFormatContext *ic)
1071{
1072 int64_t start_time, end_time, end_time1;
1073 int i;
1074 AVStream *st;
1075
1076 start_time = MAXINT64;
1077 end_time = MININT64;
1078 for(i = 0;i < ic->nb_streams; i++) {
1079 st = ic->streams[i];
1080 if (st->start_time != AV_NOPTS_VALUE) {
1081 if (st->start_time < start_time)
1082 start_time = st->start_time;
1083 if (st->duration != AV_NOPTS_VALUE) {
1084 end_time1 = st->start_time + st->duration;
1085 if (end_time1 > end_time)
1086 end_time = end_time1;
1087 }
1088 }
1089 }
1090 if (start_time != MAXINT64) {
1091 ic->start_time = start_time;
1092 if (end_time != MAXINT64) {
1093 ic->duration = end_time - start_time;
1094 if (ic->file_size > 0) {
1095 /* compute the bit rate */
1096 ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1097 (double)ic->duration;
1098 }
1099 }
1100 }
1101
1102}
1103
1104static void fill_all_stream_timings(AVFormatContext *ic)
1105{
1106 int i;
1107 AVStream *st;
1108
1109 av_update_stream_timings(ic);
1110 for(i = 0;i < ic->nb_streams; i++) {
1111 st = ic->streams[i];
1112 if (st->start_time == AV_NOPTS_VALUE) {
1113 st->start_time = ic->start_time;
1114 st->duration = ic->duration;
1115 }
1116 }
1117}
1118
1119static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1120{
1121 int64_t filesize, duration;
1122 int bit_rate, i;
1123 AVStream *st;
1124
1125 /* if bit_rate is already set, we believe it */
1126 if (ic->bit_rate == 0) {
1127 bit_rate = 0;
1128 for(i=0;i<ic->nb_streams;i++) {
1129 st = ic->streams[i];
1130 bit_rate += st->codec.bit_rate;
1131 }
1132 ic->bit_rate = bit_rate;
1133 }
1134
1135 /* if duration is already set, we believe it */
1136 if (ic->duration == AV_NOPTS_VALUE &&
1137 ic->bit_rate != 0 &&
1138 ic->file_size != 0) {
1139 filesize = ic->file_size;
1140 if (filesize > 0) {
1141 duration = (int64_t)((8 * AV_TIME_BASE * (double)filesize) / (double)ic->bit_rate);
1142 for(i = 0; i < ic->nb_streams; i++) {
1143 st = ic->streams[i];
1144 if (st->start_time == AV_NOPTS_VALUE ||
1145 st->duration == AV_NOPTS_VALUE) {
1146 st->start_time = 0;
1147 st->duration = duration;
1148 }
1149 }
1150 }
1151 }
1152}
1153
12f996ed
FB
1154#define DURATION_MAX_READ_SIZE 250000
1155
1156/* only usable for MPEG-PS streams */
1157static void av_estimate_timings_from_pts(AVFormatContext *ic)
1158{
1159 AVPacket pkt1, *pkt = &pkt1;
1160 AVStream *st;
1161 int read_size, i, ret;
1162 int64_t start_time, end_time, end_time1;
1163 int64_t filesize, offset, duration;
1164
fb2758c8
FB
1165 /* free previous packet */
1166 if (ic->cur_st && ic->cur_st->parser)
1167 av_free_packet(&ic->cur_pkt);
1168 ic->cur_st = NULL;
1169
1170 /* flush packet queue */
1171 flush_packet_queue(ic);
1172
1173
12f996ed
FB
1174 /* we read the first packets to get the first PTS (not fully
1175 accurate, but it is enough now) */
1176 url_fseek(&ic->pb, 0, SEEK_SET);
1177 read_size = 0;
1178 for(;;) {
1179 if (read_size >= DURATION_MAX_READ_SIZE)
1180 break;
1181 /* if all info is available, we can stop */
1182 for(i = 0;i < ic->nb_streams; i++) {
1183 st = ic->streams[i];
1184 if (st->start_time == AV_NOPTS_VALUE)
1185 break;
1186 }
1187 if (i == ic->nb_streams)
1188 break;
1189
1190 ret = av_read_packet(ic, pkt);
1191 if (ret != 0)
1192 break;
1193 read_size += pkt->size;
1194 st = ic->streams[pkt->stream_index];
1195 if (pkt->pts != AV_NOPTS_VALUE) {
1196 if (st->start_time == AV_NOPTS_VALUE)
1197 st->start_time = (int64_t)((double)pkt->pts * ic->pts_num * (double)AV_TIME_BASE / ic->pts_den);
0a5f92a1
MN
1198 }
1199 av_free_packet(pkt);
1200 }
12f996ed
FB
1201
1202 /* we compute the minimum start_time and use it as default */
1203 start_time = MAXINT64;
1204 for(i = 0; i < ic->nb_streams; i++) {
1205 st = ic->streams[i];
1206 if (st->start_time != AV_NOPTS_VALUE &&
1207 st->start_time < start_time)
1208 start_time = st->start_time;
1209 }
12f996ed
FB
1210 if (start_time != MAXINT64)
1211 ic->start_time = start_time;
1212
1213 /* estimate the end time (duration) */
1214 /* XXX: may need to support wrapping */
1215 filesize = ic->file_size;
1216 offset = filesize - DURATION_MAX_READ_SIZE;
1217 if (offset < 0)
1218 offset = 0;
1219
12f996ed
FB
1220 url_fseek(&ic->pb, offset, SEEK_SET);
1221 read_size = 0;
1222 for(;;) {
1223 if (read_size >= DURATION_MAX_READ_SIZE)
1224 break;
1225 /* if all info is available, we can stop */
1226 for(i = 0;i < ic->nb_streams; i++) {
1227 st = ic->streams[i];
1228 if (st->duration == AV_NOPTS_VALUE)
1229 break;
1230 }
1231 if (i == ic->nb_streams)
1232 break;
1233
1234 ret = av_read_packet(ic, pkt);
1235 if (ret != 0)
1236 break;
1237 read_size += pkt->size;
1238 st = ic->streams[pkt->stream_index];
1239 if (pkt->pts != AV_NOPTS_VALUE) {
1240 end_time = (int64_t)((double)pkt->pts * ic->pts_num * (double)AV_TIME_BASE / ic->pts_den);
1241 duration = end_time - st->start_time;
1242 if (duration > 0) {
1243 if (st->duration == AV_NOPTS_VALUE ||
1244 st->duration < duration)
1245 st->duration = duration;
1246 }
1247 }
1248 av_free_packet(pkt);
1249 }
1250
1251 /* estimate total duration */
1252 end_time = MININT64;
1253 for(i = 0;i < ic->nb_streams; i++) {
1254 st = ic->streams[i];
1255 if (st->duration != AV_NOPTS_VALUE) {
1256 end_time1 = st->start_time + st->duration;
1257 if (end_time1 > end_time)
1258 end_time = end_time1;
1259 }
1260 }
1261
1262 /* update start_time (new stream may have been created, so we do
1263 it at the end */
1264 if (ic->start_time != AV_NOPTS_VALUE) {
1265 for(i = 0; i < ic->nb_streams; i++) {
1266 st = ic->streams[i];
1267 if (st->start_time == AV_NOPTS_VALUE)
1268 st->start_time = ic->start_time;
1269 }
1270 }
1271
1272 if (end_time != MININT64) {
1273 /* put dummy values for duration if needed */
1274 for(i = 0;i < ic->nb_streams; i++) {
1275 st = ic->streams[i];
1276 if (st->duration == AV_NOPTS_VALUE &&
1277 st->start_time != AV_NOPTS_VALUE)
1278 st->duration = end_time - st->start_time;
1279 }
1280 ic->duration = end_time - ic->start_time;
1281 }
1282
1283 url_fseek(&ic->pb, 0, SEEK_SET);
1284}
1285
1286static void av_estimate_timings(AVFormatContext *ic)
1287{
1288 URLContext *h;
1289 int64_t file_size;
1290
1291 /* get the file size, if possible */
1292 if (ic->iformat->flags & AVFMT_NOFILE) {
1293 file_size = 0;
1294 } else {
1295 h = url_fileno(&ic->pb);
1296 file_size = url_filesize(h);
1297 if (file_size < 0)
1298 file_size = 0;
1299 }
1300 ic->file_size = file_size;
1301
1302 if (ic->iformat == &mpegps_demux) {
1303 /* get accurate estimate from the PTSes */
1304 av_estimate_timings_from_pts(ic);
1305 } else if (av_has_timings(ic)) {
1306 /* at least one components has timings - we use them for all
1307 the components */
1308 fill_all_stream_timings(ic);
1309 } else {
1310 /* less precise: use bit rate info */
1311 av_estimate_timings_from_bit_rate(ic);
1312 }
1313 av_update_stream_timings(ic);
1314
1315#if 0
1316 {
1317 int i;
1318 AVStream *st;
1319 for(i = 0;i < ic->nb_streams; i++) {
1320 st = ic->streams[i];
1321 printf("%d: start_time: %0.3f duration: %0.3f\n",
1322 i, (double)st->start_time / AV_TIME_BASE,
1323 (double)st->duration / AV_TIME_BASE);
1324 }
1325 printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1326 (double)ic->start_time / AV_TIME_BASE,
1327 (double)ic->duration / AV_TIME_BASE,
1328 ic->bit_rate / 1000);
1329 }
1330#endif
1331}
1332
b9a281db
FB
1333static int has_codec_parameters(AVCodecContext *enc)
1334{
1335 int val;
1336 switch(enc->codec_type) {
1337 case CODEC_TYPE_AUDIO:
1338 val = enc->sample_rate;
1339 break;
1340 case CODEC_TYPE_VIDEO:
1341 val = enc->width;
1342 break;
1343 default:
1344 val = 1;
1345 break;
1346 }
1347 return (val != 0);
1348}
1349
fb2758c8
FB
1350static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1351{
1352 int16_t *samples;
1353 AVCodec *codec;
1354 int got_picture, ret;
1355 AVFrame picture;
1356
1357 codec = avcodec_find_decoder(st->codec.codec_id);
1358 if (!codec)
1359 return -1;
1360 ret = avcodec_open(&st->codec, codec);
1361 if (ret < 0)
1362 return ret;
1363 switch(st->codec.codec_type) {
1364 case CODEC_TYPE_VIDEO:
1365 ret = avcodec_decode_video(&st->codec, &picture,
1366 &got_picture, (uint8_t *)data, size);
1367 break;
1368 case CODEC_TYPE_AUDIO:
1369 samples = av_malloc(AVCODEC_MAX_AUDIO_FRAME_SIZE);
1370 if (!samples)
1371 goto fail;
1372 ret = avcodec_decode_audio(&st->codec, samples,
1373 &got_picture, (uint8_t *)data, size);
1374 av_free(samples);
1375 break;
1376 default:
1377 break;
1378 }
1379 fail:
1380 avcodec_close(&st->codec);
1381 return ret;
1382}
1383
1384/* absolute maximum size we read until we abort */
1385#define MAX_READ_SIZE 5000000
1386
1387/* maximum duration until we stop analysing the stream */
1388#define MAX_STREAM_DURATION ((int)(AV_TIME_BASE * 1.0))
1389
b9a281db
FB
1390/**
1391 * Read the beginning of a media file to get stream information. This
1392 * is useful for file formats with no headers such as MPEG. This
1393 * function also compute the real frame rate in case of mpeg2 repeat
1394 * frame mode.
1395 *
1396 * @param ic media file handle
1397 * @return >=0 if OK. AVERROR_xxx if error.
1398 */
1399int av_find_stream_info(AVFormatContext *ic)
1400{
fb2758c8 1401 int i, count, ret, read_size;
b9a281db 1402 AVStream *st;
fb2758c8 1403 AVPacket pkt1, *pkt;
b9a281db 1404 AVPacketList *pktl=NULL, **ppktl;
b9a281db
FB
1405
1406 count = 0;
1407 read_size = 0;
1408 ppktl = &ic->packet_buffer;
1409 for(;;) {
1410 /* check if one codec still needs to be handled */
1411 for(i=0;i<ic->nb_streams;i++) {
1412 st = ic->streams[i];
fb2758c8 1413 if (!has_codec_parameters(&st->codec))
b9a281db
FB
1414 break;
1415 }
1416 if (i == ic->nb_streams) {
1417 /* NOTE: if the format has no header, then we need to read
1418 some packets to get most of the streams, so we cannot
1419 stop here */
fb2758c8 1420 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
b9a281db
FB
1421 /* if we found the info for all the codecs, we can stop */
1422 ret = count;
1423 break;
1424 }
1425 } else {
1426 /* we did not get all the codec info, but we read too much data */
fb2758c8 1427 if (read_size >= MAX_READ_SIZE) {
b9a281db
FB
1428 ret = count;
1429 break;
1430 }
1431 }
1432
fb2758c8
FB
1433 /* NOTE: a new stream can be added there if no header in file
1434 (AVFMTCTX_NOHEADER) */
1435 ret = av_read_frame_internal(ic, &pkt1);
1436 if (ret < 0) {
1437 /* EOF or error */
1438 ret = -1; /* we could not have all the codec parameters before EOF */
1439 if ((ic->ctx_flags & AVFMTCTX_NOHEADER) &&
1440 i == ic->nb_streams)
1441 ret = 0;
1442 break;
1443 }
1444
b9a281db
FB
1445 pktl = av_mallocz(sizeof(AVPacketList));
1446 if (!pktl) {
1447 ret = AVERROR_NOMEM;
1448 break;
1449 }
1450
1451 /* add the packet in the buffered packet list */
1452 *ppktl = pktl;
1453 ppktl = &pktl->next;
1454
b9a281db 1455 pkt = &pktl->pkt;
fb2758c8
FB
1456 *pkt = pkt1;
1457
1458 /* duplicate the packet */
1459 if (av_dup_packet(pkt) < 0) {
1460 ret = AVERROR_NOMEM;
1461 break;
b9a281db 1462 }
b9a281db 1463
fb2758c8 1464 read_size += pkt->size;
b9a281db
FB
1465
1466 st = ic->streams[pkt->stream_index];
fb2758c8
FB
1467 st->codec_info_duration += pkt->duration;
1468 if (pkt->duration != 0)
1469 st->codec_info_nb_frames++;
1470
1471 /* if still no information, we try to open the codec and to
1472 decompress the frame. We try to avoid that in most cases as
1473 it takes longer and uses more memory. For MPEG4, we need to
1474 decompress for Quicktime. */
1475 if (!has_codec_parameters(&st->codec) &&
1476 (st->codec.codec_id == CODEC_ID_FLV1 ||
1477 st->codec.codec_id == CODEC_ID_H264 ||
1478 st->codec.codec_id == CODEC_ID_H263 ||
1479 (st->codec.codec_id == CODEC_ID_MPEG4 && !st->need_parsing)))
1480 try_decode_frame(st, pkt->data, pkt->size);
1481
1482 if (st->codec_info_duration >= MAX_STREAM_DURATION) {
1483 break;
b9a281db
FB
1484 }
1485 count++;
1486 }
1487
b9a281db
FB
1488 /* set real frame rate info */
1489 for(i=0;i<ic->nb_streams;i++) {
1490 st = ic->streams[i];
1491 if (st->codec.codec_type == CODEC_TYPE_VIDEO) {
fb2758c8
FB
1492 /* compute the real frame rate for telecine */
1493 if ((st->codec.codec_id == CODEC_ID_MPEG1VIDEO ||
1494 st->codec.codec_id == CODEC_ID_MPEG2VIDEO) &&
1495 st->codec.sub_id == 2) {
1496 if (st->codec_info_nb_frames >= 20) {
1497 float coded_frame_rate, est_frame_rate;
1498 est_frame_rate = ((double)st->codec_info_nb_frames * AV_TIME_BASE) /
1499 (double)st->codec_info_duration ;
1500 coded_frame_rate = (double)st->codec.frame_rate /
1501 (double)st->codec.frame_rate_base;
1502#if 0
1503 printf("telecine: coded_frame_rate=%0.3f est_frame_rate=%0.3f\n",
1504 coded_frame_rate, est_frame_rate);
1505#endif
1506 /* if we detect that it could be a telecine, we
1507 signal it. It would be better to do it at a
1508 higher level as it can change in a film */
1509 if (coded_frame_rate >= 24.97 &&
1510 (est_frame_rate >= 23.5 && est_frame_rate < 24.5)) {
1511 st->r_frame_rate = 24024;
1512 st->r_frame_rate_base = 1001;
1513 }
1514 }
1515 }
1516 /* if no real frame rate, use the codec one */
14bea432
MN
1517 if (!st->r_frame_rate){
1518 st->r_frame_rate = st->codec.frame_rate;
1519 st->r_frame_rate_base = st->codec.frame_rate_base;
1520 }
b9a281db 1521 }
de6d9b64 1522 }
b9a281db 1523
12f996ed 1524 av_estimate_timings(ic);
b9a281db 1525 return ret;
de6d9b64
FB
1526}
1527
fb2758c8
FB
1528/*******************************************************/
1529
1530/**
1531 * start playing a network based stream (e.g. RTSP stream) at the
1532 * current position
1533 */
1534int av_read_play(AVFormatContext *s)
1535{
1536 if (!s->iformat->read_play)
1537 return AVERROR_NOTSUPP;
1538 return s->iformat->read_play(s);
1539}
1540
1541/**
1542 * pause a network based stream (e.g. RTSP stream). Use av_read_play()
1543 * to resume it.
1544 */
1545int av_read_pause(AVFormatContext *s)
1546{
1547 if (!s->iformat->read_pause)
1548 return AVERROR_NOTSUPP;
1549 return s->iformat->read_pause(s);
1550}
1551
b9a281db
FB
1552/**
1553 * Close a media file (but not its codecs)
1554 *
1555 * @param s media file handle
1556 */
de6d9b64
FB
1557void av_close_input_file(AVFormatContext *s)
1558{
b6892136 1559 int i, must_open_file;
da24c5e3 1560 AVStream *st;
de6d9b64 1561
fb2758c8
FB
1562 /* free previous packet */
1563 if (s->cur_st && s->cur_st->parser)
1564 av_free_packet(&s->cur_pkt);
1565
b9a281db
FB
1566 if (s->iformat->read_close)
1567 s->iformat->read_close(s);
de6d9b64 1568 for(i=0;i<s->nb_streams;i++) {
da24c5e3
FB
1569 /* free all data in a stream component */
1570 st = s->streams[i];
fb2758c8
FB
1571 if (st->parser) {
1572 av_parser_close(st->parser);
de6d9b64 1573 }
fb2758c8
FB
1574 av_free(st->index_entries);
1575 av_free(st);
de6d9b64 1576 }
fb2758c8 1577 flush_packet_queue(s);
b6892136 1578 must_open_file = 1;
da24c5e3 1579 if (s->iformat->flags & AVFMT_NOFILE) {
b6892136
FB
1580 must_open_file = 0;
1581 }
1582 if (must_open_file) {
96baaa6a
FB
1583 url_fclose(&s->pb);
1584 }
a8dbe951 1585 av_freep(&s->priv_data);
1ea4f593 1586 av_free(s);
de6d9b64
FB
1587}
1588
b9a281db
FB
1589/**
1590 * Add a new stream to a media file. Can only be called in the
da24c5e3
FB
1591 * read_header function. If the flag AVFMTCTX_NOHEADER is in the
1592 * format context, then new streams can be added in read_packet too.
b9a281db
FB
1593 *
1594 *
1595 * @param s media file handle
da24c5e3 1596 * @param id file format dependent stream id
b9a281db
FB
1597 */
1598AVStream *av_new_stream(AVFormatContext *s, int id)
1599{
1600 AVStream *st;
1601
1602 if (s->nb_streams >= MAX_STREAMS)
1603 return NULL;
1604
1605 st = av_mallocz(sizeof(AVStream));
1606 if (!st)
1607 return NULL;
1e491e29 1608 avcodec_get_context_defaults(&st->codec);
48091512
FB
1609 if (s->iformat) {
1610 /* no default bitrate if decoding */
1611 st->codec.bit_rate = 0;
1612 }
b9a281db
FB
1613 st->index = s->nb_streams;
1614 st->id = id;
12f996ed
FB
1615 st->start_time = AV_NOPTS_VALUE;
1616 st->duration = AV_NOPTS_VALUE;
b9a281db
FB
1617 s->streams[s->nb_streams++] = st;
1618 return st;
1619}
1620
1621/************************************************************/
1622/* output media file */
de6d9b64 1623
87a0a681
FB
1624int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
1625{
1626 int ret;
98486a6b
RS
1627
1628 if (s->oformat->priv_data_size > 0) {
1629 s->priv_data = av_mallocz(s->oformat->priv_data_size);
1630 if (!s->priv_data)
1631 return AVERROR_NOMEM;
1632 } else
1633 s->priv_data = NULL;
1634
87a0a681
FB
1635 if (s->oformat->set_parameters) {
1636 ret = s->oformat->set_parameters(s, ap);
1637 if (ret < 0)
1638 return ret;
1639 }
1640 return 0;
1641}
1642
b9a281db
FB
1643/**
1644 * allocate the stream private data and write the stream header to an
1645 * output media file
1646 *
1647 * @param s media file handle
1648 * @return 0 if OK. AVERROR_xxx if error.
1649 */
1650int av_write_header(AVFormatContext *s)
1651{
1e51d801
FB
1652 int ret, i;
1653 AVStream *st;
1654
916c80e9
FB
1655 /* default pts settings is MPEG like */
1656 av_set_pts_info(s, 33, 1, 90000);
1e51d801
FB
1657 ret = s->oformat->write_header(s);
1658 if (ret < 0)
1659 return ret;
1660
1661 /* init PTS generation */
1662 for(i=0;i<s->nb_streams;i++) {
1663 st = s->streams[i];
1664
1665 switch (st->codec.codec_type) {
1666 case CODEC_TYPE_AUDIO:
1667 av_frac_init(&st->pts, 0, 0,
0c1a9eda 1668 (int64_t)s->pts_num * st->codec.sample_rate);
1e51d801
FB
1669 break;
1670 case CODEC_TYPE_VIDEO:
1671 av_frac_init(&st->pts, 0, 0,
0c1a9eda 1672 (int64_t)s->pts_num * st->codec.frame_rate);
1e51d801
FB
1673 break;
1674 default:
1675 break;
1676 }
1677 }
1678 return 0;
b9a281db
FB
1679}
1680
1681/**
1e51d801
FB
1682 * Write a packet to an output media file. The packet shall contain
1683 * one audio or video frame.
b9a281db
FB
1684 *
1685 * @param s media file handle
1e51d801
FB
1686 * @param stream_index stream index
1687 * @param buf buffer containing the frame data
1688 * @param size size of buffer
d4c0ff91 1689 * @return < 0 if error, = 0 if OK, 1 if end of stream wanted.
b9a281db 1690 */
1e51d801
FB
1691int av_write_frame(AVFormatContext *s, int stream_index, const uint8_t *buf,
1692 int size)
de6d9b64 1693{
1e51d801 1694 AVStream *st;
0c1a9eda 1695 int64_t pts_mask;
7feb950a 1696 int ret, frame_size;
1e51d801
FB
1697
1698 st = s->streams[stream_index];
1699 pts_mask = (1LL << s->pts_wrap_bits) - 1;
fb2758c8 1700 ret = s->oformat->write_packet(s, stream_index, buf, size,
1e51d801
FB
1701 st->pts.val & pts_mask);
1702 if (ret < 0)
1703 return ret;
1704
1705 /* update pts */
1706 switch (st->codec.codec_type) {
1707 case CODEC_TYPE_AUDIO:
fb2758c8
FB
1708 frame_size = get_audio_frame_size(&st->codec, size);
1709 if (frame_size >= 0) {
1710 av_frac_add(&st->pts,
1711 (int64_t)s->pts_den * frame_size);
7feb950a 1712 }
1e51d801
FB
1713 break;
1714 case CODEC_TYPE_VIDEO:
1715 av_frac_add(&st->pts,
14bea432 1716 (int64_t)s->pts_den * st->codec.frame_rate_base);
1e51d801
FB
1717 break;
1718 default:
1719 break;
1720 }
d4c0ff91 1721 return ret;
b9a281db
FB
1722}
1723
1724/**
1725 * write the stream trailer to an output media file and and free the
1726 * file private data.
1727 *
1728 * @param s media file handle
1729 * @return 0 if OK. AVERROR_xxx if error. */
1730int av_write_trailer(AVFormatContext *s)
1731{
1732 int ret;
1733 ret = s->oformat->write_trailer(s);
1734 av_freep(&s->priv_data);
1735 return ret;
de6d9b64
FB
1736}
1737
1738/* "user interface" functions */
1739
1740void dump_format(AVFormatContext *ic,
1741 int index,
1742 const char *url,
1743 int is_output)
1744{
b9a281db 1745 int i, flags;
de6d9b64
FB
1746 char buf[256];
1747
bc874dae 1748 av_log(ic, AV_LOG_DEBUG, "%s #%d, %s, %s '%s':\n",
de6d9b64 1749 is_output ? "Output" : "Input",
b9a281db
FB
1750 index,
1751 is_output ? ic->oformat->name : ic->iformat->name,
de6d9b64 1752 is_output ? "to" : "from", url);
12f996ed 1753 if (!is_output) {
bc874dae 1754 av_log(ic, AV_LOG_DEBUG, " Duration: ");
12f996ed
FB
1755 if (ic->duration != AV_NOPTS_VALUE) {
1756 int hours, mins, secs, us;
1757 secs = ic->duration / AV_TIME_BASE;
1758 us = ic->duration % AV_TIME_BASE;
1759 mins = secs / 60;
1760 secs %= 60;
1761 hours = mins / 60;
1762 mins %= 60;
bc874dae 1763 av_log(ic, AV_LOG_DEBUG, "%02d:%02d:%02d.%01d", hours, mins, secs,
12f996ed
FB
1764 (10 * us) / AV_TIME_BASE);
1765 } else {
bc874dae 1766 av_log(ic, AV_LOG_DEBUG, "N/A");
12f996ed 1767 }
bc874dae 1768 av_log(ic, AV_LOG_DEBUG, ", bitrate: ");
12f996ed 1769 if (ic->bit_rate) {
bc874dae 1770 av_log(ic, AV_LOG_DEBUG,"%d kb/s", ic->bit_rate / 1000);
12f996ed 1771 } else {
bc874dae 1772 av_log(ic, AV_LOG_DEBUG, "N/A");
12f996ed 1773 }
bc874dae 1774 av_log(ic, AV_LOG_DEBUG, "\n");
12f996ed 1775 }
de6d9b64
FB
1776 for(i=0;i<ic->nb_streams;i++) {
1777 AVStream *st = ic->streams[i];
1778 avcodec_string(buf, sizeof(buf), &st->codec, is_output);
bc874dae 1779 av_log(ic, AV_LOG_DEBUG, " Stream #%d.%d", index, i);
b9a281db
FB
1780 /* the pid is an important information, so we display it */
1781 /* XXX: add a generic system */
1782 if (is_output)
1783 flags = ic->oformat->flags;
1784 else
1785 flags = ic->iformat->flags;
1786 if (flags & AVFMT_SHOW_IDS) {
bc874dae 1787 av_log(ic, AV_LOG_DEBUG, "[0x%x]", st->id);
b9a281db 1788 }
bc874dae 1789 av_log(ic, AV_LOG_DEBUG, ": %s\n", buf);
de6d9b64
FB
1790 }
1791}
1792
1793typedef struct {
445f1b83 1794 const char *abv;
de6d9b64 1795 int width, height;
445f1b83
RS
1796 int frame_rate, frame_rate_base;
1797} AbvEntry;
1798
1799static AbvEntry frame_abvs[] = {
ba2a8cb4
RS
1800 { "ntsc", 720, 480, 30000, 1001 },
1801 { "pal", 720, 576, 25, 1 },
1802 { "qntsc", 352, 240, 30000, 1001 }, /* VCD compliant ntsc */
1803 { "qpal", 352, 288, 25, 1 }, /* VCD compliant pal */
904736b5
RS
1804 { "sntsc", 640, 480, 30000, 1001 }, /* square pixel ntsc */
1805 { "spal", 768, 576, 25, 1 }, /* square pixel pal */
445f1b83
RS
1806 { "film", 352, 240, 24, 1 },
1807 { "ntsc-film", 352, 240, 24000, 1001 },
1808 { "sqcif", 128, 96, 0, 0 },
1809 { "qcif", 176, 144, 0, 0 },
1810 { "cif", 352, 288, 0, 0 },
1811 { "4cif", 704, 576, 0, 0 },
de6d9b64 1812};
445f1b83 1813
de6d9b64
FB
1814int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
1815{
1816 int i;
445f1b83 1817 int n = sizeof(frame_abvs) / sizeof(AbvEntry);
de6d9b64
FB
1818 const char *p;
1819 int frame_width = 0, frame_height = 0;
1820
1821 for(i=0;i<n;i++) {
445f1b83
RS
1822 if (!strcmp(frame_abvs[i].abv, str)) {
1823 frame_width = frame_abvs[i].width;
1824 frame_height = frame_abvs[i].height;
de6d9b64
FB
1825 break;
1826 }
1827 }
1828 if (i == n) {
1829 p = str;
1830 frame_width = strtol(p, (char **)&p, 10);
1831 if (*p)
1832 p++;
1833 frame_height = strtol(p, (char **)&p, 10);
1834 }
1835 if (frame_width <= 0 || frame_height <= 0)
1836 return -1;
1837 *width_ptr = frame_width;
1838 *height_ptr = frame_height;
1839 return 0;
1840}
1841
445f1b83
RS
1842int parse_frame_rate(int *frame_rate, int *frame_rate_base, const char *arg)
1843{
1844 int i;
1845 char* cp;
1846
1847 /* First, we check our abbreviation table */
1848 for (i = 0; i < sizeof(frame_abvs)/sizeof(*frame_abvs); ++i)
1849 if (!strcmp(frame_abvs[i].abv, arg)) {
1850 *frame_rate = frame_abvs[i].frame_rate;
1851 *frame_rate_base = frame_abvs[i].frame_rate_base;
1852 return 0;
1853 }
1854
1855 /* Then, we try to parse it as fraction */
1856 cp = strchr(arg, '/');
1857 if (cp) {
1858 char* cpp;
1859 *frame_rate = strtol(arg, &cpp, 10);
1860 if (cpp != arg || cpp == cp)
1861 *frame_rate_base = strtol(cp+1, &cpp, 10);
1862 else
1863 *frame_rate = 0;
1864 }
1865 else {
1866 /* Finally we give up and parse it as double */
1867 *frame_rate_base = DEFAULT_FRAME_RATE_BASE;
1868 *frame_rate = (int)(strtod(arg, 0) * (*frame_rate_base) + 0.5);
1869 }
1870 if (!*frame_rate || !*frame_rate_base)
1871 return -1;
1872 else
1873 return 0;
1874}
1875
916c80e9
FB
1876/* Syntax:
1877 * - If not a duration:
1878 * [{YYYY-MM-DD|YYYYMMDD}]{T| }{HH[:MM[:SS[.m...]]][Z]|HH[MM[SS[.m...]]][Z]}
c5510dd6 1879 * Time is localtime unless Z is suffixed to the end. In this case GMT
916c80e9
FB
1880 * Return the date in micro seconds since 1970
1881 * - If duration:
1882 * HH[:MM[:SS[.m...]]]
1883 * S+[.m...]
1884 */
0c1a9eda 1885int64_t parse_date(const char *datestr, int duration)
de6d9b64
FB
1886{
1887 const char *p;
0c1a9eda 1888 int64_t t;
2dbceb9f 1889 struct tm dt;
c5510dd6
PG
1890 int i;
1891 static const char *date_fmt[] = {
1892 "%Y-%m-%d",
1893 "%Y%m%d",
1894 };
1895 static const char *time_fmt[] = {
1896 "%H:%M:%S",
1897 "%H%M%S",
1898 };
1899 const char *q;
916c80e9 1900 int is_utc, len;
c5510dd6
PG
1901 char lastch;
1902 time_t now = time(0);
1903
916c80e9
FB
1904 len = strlen(datestr);
1905 if (len > 0)
1906 lastch = datestr[len - 1];
1907 else
1908 lastch = '\0';
c5510dd6 1909 is_utc = (lastch == 'z' || lastch == 'Z');
2dbceb9f
PG
1910
1911 memset(&dt, 0, sizeof(dt));
de6d9b64
FB
1912
1913 p = datestr;
916c80e9 1914 q = NULL;
de6d9b64 1915 if (!duration) {
c5510dd6 1916 for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
f71869a4 1917 q = small_strptime(p, date_fmt[i], &dt);
c5510dd6
PG
1918 if (q) {
1919 break;
1920 }
1921 }
1922
1923 if (!q) {
1924 if (is_utc) {
1925 dt = *gmtime(&now);
1926 } else {
1927 dt = *localtime(&now);
1928 }
1929 dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
de6d9b64 1930 } else {
c5510dd6 1931 p = q;
de6d9b64 1932 }
c5510dd6
PG
1933
1934 if (*p == 'T' || *p == 't' || *p == ' ')
1935 p++;
c5510dd6 1936
916c80e9 1937 for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
f71869a4 1938 q = small_strptime(p, time_fmt[i], &dt);
916c80e9
FB
1939 if (q) {
1940 break;
1941 }
1942 }
1943 } else {
f71869a4 1944 q = small_strptime(p, time_fmt[0], &dt);
916c80e9
FB
1945 if (!q) {
1946 dt.tm_sec = strtol(p, (char **)&q, 10);
1947 dt.tm_min = 0;
1948 dt.tm_hour = 0;
c5510dd6
PG
1949 }
1950 }
1951
1952 /* Now we have all the fields that we can get */
1953 if (!q) {
1954 if (duration)
1955 return 0;
1956 else
0c1a9eda 1957 return now * int64_t_C(1000000);
de6d9b64 1958 }
2dbceb9f
PG
1959
1960 if (duration) {
c5510dd6 1961 t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2dbceb9f 1962 } else {
c5510dd6
PG
1963 dt.tm_isdst = -1; /* unknown */
1964 if (is_utc) {
1965 t = mktimegm(&dt);
1966 } else {
1967 t = mktime(&dt);
1968 }
de6d9b64 1969 }
2dbceb9f 1970
c5510dd6
PG
1971 t *= 1000000;
1972
1973 if (*q == '.') {
de6d9b64 1974 int val, n;
c5510dd6
PG
1975 q++;
1976 for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
1977 if (!isdigit(*q))
1978 break;
1979 val += n * (*q - '0');
de6d9b64
FB
1980 }
1981 t += val;
1982 }
1983 return t;
1984}
1985
2dbceb9f 1986/* syntax: '?tag1=val1&tag2=val2...'. Little URL decoding is done. Return
de6d9b64
FB
1987 1 if found */
1988int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
1989{
1990 const char *p;
1991 char tag[128], *q;
1992
1993 p = info;
1994 if (*p == '?')
1995 p++;
1996 for(;;) {
1997 q = tag;
1998 while (*p != '\0' && *p != '=' && *p != '&') {
1999 if ((q - tag) < sizeof(tag) - 1)
2000 *q++ = *p;
2001 p++;
2002 }
2003 *q = '\0';
2004 q = arg;
2005 if (*p == '=') {
2006 p++;
2007 while (*p != '&' && *p != '\0') {
2dbceb9f
PG
2008 if ((q - arg) < arg_size - 1) {
2009 if (*p == '+')
2010 *q++ = ' ';
2011 else
2012 *q++ = *p;
2013 }
de6d9b64
FB
2014 p++;
2015 }
2016 *q = '\0';
2017 }
2018 if (!strcmp(tag, tag1))
2019 return 1;
2020 if (*p != '&')
2021 break;
8d1335ea 2022 p++;
de6d9b64
FB
2023 }
2024 return 0;
2025}
2026
9150f42e
FB
2027/* Return in 'buf' the path with '%d' replaced by number. Also handles
2028 the '%0nd' format where 'n' is the total number of digits and
2029 '%%'. Return 0 if OK, and -1 if format error */
2030int get_frame_filename(char *buf, int buf_size,
2031 const char *path, int number)
2032{
2033 const char *p;
0bf92f79
PI
2034 char *q, buf1[20], c;
2035 int nd, len, percentd_found;
9150f42e
FB
2036
2037 q = buf;
2038 p = path;
2039 percentd_found = 0;
2040 for(;;) {
2041 c = *p++;
2042 if (c == '\0')
2043 break;
2044 if (c == '%') {
c9646fda
PG
2045 do {
2046 nd = 0;
2047 while (isdigit(*p)) {
2048 nd = nd * 10 + *p++ - '0';
2049 }
2050 c = *p++;
c9646fda
PG
2051 } while (isdigit(c));
2052
9150f42e
FB
2053 switch(c) {
2054 case '%':
2055 goto addchar;
2056 case 'd':
2057 if (percentd_found)
2058 goto fail;
2059 percentd_found = 1;
2060 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
2061 len = strlen(buf1);
2062 if ((q - buf + len) > buf_size - 1)
2063 goto fail;
2064 memcpy(q, buf1, len);
2065 q += len;
2066 break;
2067 default:
2068 goto fail;
2069 }
2070 } else {
2071 addchar:
2072 if ((q - buf) < buf_size - 1)
2073 *q++ = c;
2074 }
2075 }
2076 if (!percentd_found)
2077 goto fail;
2078 *q = '\0';
2079 return 0;
2080 fail:
2081 *q = '\0';
2082 return -1;
2083}
2084
b9a281db 2085/**
fb2758c8
FB
2086 * Print nice hexa dump of a buffer
2087 * @param f stream for output
b9a281db
FB
2088 * @param buf buffer
2089 * @param size buffer size
2090 */
fb2758c8 2091void av_hex_dump(FILE *f, uint8_t *buf, int size)
b9a281db
FB
2092{
2093 int len, i, j, c;
2094
2095 for(i=0;i<size;i+=16) {
2096 len = size - i;
2097 if (len > 16)
2098 len = 16;
fb2758c8 2099 fprintf(f, "%08x ", i);
b9a281db
FB
2100 for(j=0;j<16;j++) {
2101 if (j < len)
fb2758c8 2102 fprintf(f, " %02x", buf[i+j]);
b9a281db 2103 else
fb2758c8 2104 fprintf(f, " ");
b9a281db 2105 }
fb2758c8 2106 fprintf(f, " ");
b9a281db
FB
2107 for(j=0;j<len;j++) {
2108 c = buf[i+j];
2109 if (c < ' ' || c > '~')
2110 c = '.';
fb2758c8 2111 fprintf(f, "%c", c);
b9a281db 2112 }
fb2758c8 2113 fprintf(f, "\n");
b9a281db
FB
2114 }
2115}
2116
fb2758c8
FB
2117/**
2118 * Print on 'f' a nice dump of a packet
2119 * @param f stream for output
2120 * @param pkt packet to dump
2121 * @param dump_payload true if the payload must be displayed too
2122 */
2123void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
2124{
2125 fprintf(f, "stream #%d:\n", pkt->stream_index);
2126 fprintf(f, " keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
2127 fprintf(f, " duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
37353960
FB
2128 /* DTS is _always_ valid after av_read_frame() */
2129 fprintf(f, " dts=");
2130 if (pkt->dts == AV_NOPTS_VALUE)
2131 fprintf(f, "N/A");
2132 else
2133 fprintf(f, "%0.3f", (double)pkt->dts / AV_TIME_BASE);
fb2758c8
FB
2134 /* PTS may be not known if B frames are present */
2135 fprintf(f, " pts=");
2136 if (pkt->pts == AV_NOPTS_VALUE)
2137 fprintf(f, "N/A");
2138 else
2139 fprintf(f, "%0.3f", (double)pkt->pts / AV_TIME_BASE);
2140 fprintf(f, "\n");
2141 fprintf(f, " size=%d\n", pkt->size);
2142 if (dump_payload)
2143 av_hex_dump(f, pkt->data, pkt->size);
2144}
2145
a9a721da
FB
2146void url_split(char *proto, int proto_size,
2147 char *hostname, int hostname_size,
2148 int *port_ptr,
2149 char *path, int path_size,
2150 const char *url)
2151{
2152 const char *p;
2153 char *q;
2154 int port;
2155
2156 port = -1;
2157
2158 p = url;
2159 q = proto;
2160 while (*p != ':' && *p != '\0') {
2161 if ((q - proto) < proto_size - 1)
2162 *q++ = *p;
2163 p++;
2164 }
2165 if (proto_size > 0)
2166 *q = '\0';
2167 if (*p == '\0') {
2168 if (proto_size > 0)
2169 proto[0] = '\0';
2170 if (hostname_size > 0)
2171 hostname[0] = '\0';
2172 p = url;
2173 } else {
2174 p++;
2175 if (*p == '/')
2176 p++;
2177 if (*p == '/')
2178 p++;
2179 q = hostname;
2180 while (*p != ':' && *p != '/' && *p != '?' && *p != '\0') {
2181 if ((q - hostname) < hostname_size - 1)
2182 *q++ = *p;
2183 p++;
2184 }
2185 if (hostname_size > 0)
2186 *q = '\0';
2187 if (*p == ':') {
2188 p++;
2189 port = strtoul(p, (char **)&p, 10);
2190 }
2191 }
2192 if (port_ptr)
2193 *port_ptr = port;
2194 pstrcpy(path, path_size, p);
2195}
2196
916c80e9
FB
2197/**
2198 * Set the pts for a given stream
2199 * @param s stream
2200 * @param pts_wrap_bits number of bits effectively used by the pts
2201 * (used for wrap control, 33 is the value for MPEG)
2202 * @param pts_num numerator to convert to seconds (MPEG: 1)
2203 * @param pts_den denominator to convert to seconds (MPEG: 90000)
2204 */
2205void av_set_pts_info(AVFormatContext *s, int pts_wrap_bits,
2206 int pts_num, int pts_den)
2207{
2208 s->pts_wrap_bits = pts_wrap_bits;
2209 s->pts_num = pts_num;
2210 s->pts_den = pts_den;
2211}
2212
2213/* fraction handling */
2214
2215/**
2216 * f = val + (num / den) + 0.5. 'num' is normalized so that it is such
2217 * as 0 <= num < den.
2218 *
2219 * @param f fractional number
2220 * @param val integer value
2221 * @param num must be >= 0
2222 * @param den must be >= 1
2223 */
0c1a9eda 2224void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
916c80e9
FB
2225{
2226 num += (den >> 1);
2227 if (num >= den) {
2228 val += num / den;
2229 num = num % den;
2230 }
2231 f->val = val;
2232 f->num = num;
2233 f->den = den;
2234}
2235
2236/* set f to (val + 0.5) */
0c1a9eda 2237void av_frac_set(AVFrac *f, int64_t val)
916c80e9
FB
2238{
2239 f->val = val;
2240 f->num = f->den >> 1;
2241}
2242
2243/**
2244 * Fractionnal addition to f: f = f + (incr / f->den)
2245 *
2246 * @param f fractional number
2247 * @param incr increment, can be positive or negative
2248 */
0c1a9eda 2249void av_frac_add(AVFrac *f, int64_t incr)
916c80e9 2250{
0c1a9eda 2251 int64_t num, den;
916c80e9
FB
2252
2253 num = f->num + incr;
2254 den = f->den;
2255 if (num < 0) {
2256 f->val += num / den;
2257 num = num % den;
2258 if (num < 0) {
2259 num += den;
2260 f->val--;
2261 }
2262 } else if (num >= den) {
2263 f->val += num / den;
2264 num = num % den;
2265 }
2266 f->num = num;
2267}
87a0a681
FB
2268
2269/**
2270 * register a new image format
2271 * @param img_fmt Image format descriptor
2272 */
2273void av_register_image_format(AVImageFormat *img_fmt)
2274{
2275 AVImageFormat **p;
2276
2277 p = &first_image_format;
2278 while (*p != NULL) p = &(*p)->next;
2279 *p = img_fmt;
2280 img_fmt->next = NULL;
2281}
2282
2283/* guess image format */
2284AVImageFormat *av_probe_image_format(AVProbeData *pd)
2285{
2286 AVImageFormat *fmt1, *fmt;
2287 int score, score_max;
2288
2289 fmt = NULL;
2290 score_max = 0;
2291 for(fmt1 = first_image_format; fmt1 != NULL; fmt1 = fmt1->next) {
2292 if (fmt1->img_probe) {
2293 score = fmt1->img_probe(pd);
2294 if (score > score_max) {
2295 score_max = score;
2296 fmt = fmt1;
2297 }
2298 }
2299 }
2300 return fmt;
2301}
2302
2303AVImageFormat *guess_image_format(const char *filename)
2304{
2305 AVImageFormat *fmt1;
2306
2307 for(fmt1 = first_image_format; fmt1 != NULL; fmt1 = fmt1->next) {
2308 if (fmt1->extensions && match_ext(filename, fmt1->extensions))
2309 return fmt1;
2310 }
2311 return NULL;
2312}
2313
2314/**
2315 * Read an image from a stream.
2316 * @param gb byte stream containing the image
2317 * @param fmt image format, NULL if probing is required
2318 */
2319int av_read_image(ByteIOContext *pb, const char *filename,
2320 AVImageFormat *fmt,
2321 int (*alloc_cb)(void *, AVImageInfo *info), void *opaque)
2322{
2323 char buf[PROBE_BUF_SIZE];
2324 AVProbeData probe_data, *pd = &probe_data;
2325 offset_t pos;
2326 int ret;
2327
2328 if (!fmt) {
5c91a675 2329 pd->filename = filename;
87a0a681
FB
2330 pd->buf = buf;
2331 pos = url_ftell(pb);
2332 pd->buf_size = get_buffer(pb, buf, PROBE_BUF_SIZE);
2333 url_fseek(pb, pos, SEEK_SET);
2334 fmt = av_probe_image_format(pd);
2335 }
2336 if (!fmt)
2337 return AVERROR_NOFMT;
2338 ret = fmt->img_read(pb, alloc_cb, opaque);
2339 return ret;
2340}
2341
2342/**
2343 * Write an image to a stream.
2344 * @param pb byte stream for the image output
2345 * @param fmt image format
2346 * @param img image data and informations
2347 */
2348int av_write_image(ByteIOContext *pb, AVImageFormat *fmt, AVImageInfo *img)
2349{
2350 return fmt->img_write(pb, img);
2351}
2352