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