codec tag for FLV
[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 303
43465395 304static const char* format_to_name(void* ptr)
bc874dae 305{
43465395 306 AVFormatContext* fc = (AVFormatContext*) ptr;
bc874dae
MB
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;
43465395 319 ic->av_class = &av_format_context_class;
bc874dae
MB
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++;
c9247fc3
MN
918 }else{
919 if(ie->pos == pos && distance < ie->min_distance) //dont reduce the distance
920 distance= ie->min_distance;
b754978a 921 }
3e9245a9
MN
922 }else{
923 index= st->nb_index_entries++;
924 ie= &entries[index];
925 }
b754978a
MN
926
927 ie->pos = pos;
928 ie->timestamp = timestamp;
3e9245a9 929 ie->min_distance= distance;
b754978a 930 ie->flags = flags;
3e9245a9
MN
931
932 return index;
fb2758c8
FB
933}
934
935/* build an index for raw streams using a parser */
936static void av_build_index_raw(AVFormatContext *s)
937{
938 AVPacket pkt1, *pkt = &pkt1;
939 int ret;
940 AVStream *st;
941
942 st = s->streams[0];
943 av_read_frame_flush(s);
944 url_fseek(&s->pb, s->data_offset, SEEK_SET);
945
946 for(;;) {
947 ret = av_read_frame(s, pkt);
948 if (ret < 0)
949 break;
950 if (pkt->stream_index == 0 && st->parser &&
951 (pkt->flags & PKT_FLAG_KEY)) {
b754978a 952 av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
3e9245a9 953 0, AVINDEX_KEYFRAME);
fb2758c8
FB
954 }
955 av_free_packet(pkt);
956 }
957}
958
959/* return TRUE if we deal with a raw stream (raw codec data and
960 parsing needed) */
961static int is_raw_stream(AVFormatContext *s)
962{
963 AVStream *st;
964
965 if (s->nb_streams != 1)
966 return 0;
967 st = s->streams[0];
968 if (!st->need_parsing)
969 return 0;
970 return 1;
971}
972
973/* return the largest index entry whose timestamp is <=
974 wanted_timestamp */
b754978a 975int av_index_search_timestamp(AVStream *st, int wanted_timestamp)
fb2758c8 976{
b754978a
MN
977 AVIndexEntry *entries= st->index_entries;
978 int nb_entries= st->nb_index_entries;
fb2758c8
FB
979 int a, b, m;
980 int64_t timestamp;
981
982 if (nb_entries <= 0)
983 return -1;
984
985 a = 0;
986 b = nb_entries - 1;
b754978a
MN
987
988 while (a < b) {
989 m = (a + b + 1) >> 1;
fb2758c8 990 timestamp = entries[m].timestamp;
b754978a 991 if (timestamp > wanted_timestamp) {
fb2758c8
FB
992 b = m - 1;
993 } else {
b754978a 994 a = m;
fb2758c8
FB
995 }
996 }
b754978a 997 return a;
fb2758c8
FB
998}
999
1000static int av_seek_frame_generic(AVFormatContext *s,
1001 int stream_index, int64_t timestamp)
1002{
1003 int index;
1004 AVStream *st;
1005 AVIndexEntry *ie;
1006
1007 if (!s->index_built) {
1008 if (is_raw_stream(s)) {
1009 av_build_index_raw(s);
1010 } else {
1011 return -1;
1012 }
1013 s->index_built = 1;
1014 }
1015
1016 if (stream_index < 0)
1017 stream_index = 0;
1018 st = s->streams[stream_index];
b754978a 1019 index = av_index_search_timestamp(st, timestamp);
fb2758c8
FB
1020 if (index < 0)
1021 return -1;
1022
1023 /* now we have found the index, we can seek */
1024 ie = &st->index_entries[index];
1025 av_read_frame_flush(s);
1026 url_fseek(&s->pb, ie->pos, SEEK_SET);
1027 st->cur_dts = ie->timestamp;
1028 return 0;
1029}
1030
1031/**
1032 * Seek to the key frame just before the frame at timestamp
1033 * 'timestamp' in 'stream_index'. If stream_index is (-1), a default
1034 * stream is selected
1035 */
1036int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp)
1037{
1038 int ret;
1039
1040 av_read_frame_flush(s);
1041
1042 /* first, we try the format specific seek */
1043 if (s->iformat->read_seek)
1044 ret = s->iformat->read_seek(s, stream_index, timestamp);
1045 else
1046 ret = -1;
1047 if (ret >= 0) {
1048 return 0;
1049 }
1050
1051 return av_seek_frame_generic(s, stream_index, timestamp);
1052}
1053
1054/*******************************************************/
12f996ed
FB
1055
1056/* return TRUE if the stream has accurate timings for at least one component */
1057static int av_has_timings(AVFormatContext *ic)
1058{
1059 int i;
1060 AVStream *st;
1061
1062 for(i = 0;i < ic->nb_streams; i++) {
1063 st = ic->streams[i];
1064 if (st->start_time != AV_NOPTS_VALUE &&
1065 st->duration != AV_NOPTS_VALUE)
1066 return 1;
1067 }
1068 return 0;
1069}
1070
1071/* estimate the stream timings from the one of each components. Also
1072 compute the global bitrate if possible */
1073static void av_update_stream_timings(AVFormatContext *ic)
1074{
1075 int64_t start_time, end_time, end_time1;
1076 int i;
1077 AVStream *st;
1078
1079 start_time = MAXINT64;
1080 end_time = MININT64;
1081 for(i = 0;i < ic->nb_streams; i++) {
1082 st = ic->streams[i];
1083 if (st->start_time != AV_NOPTS_VALUE) {
1084 if (st->start_time < start_time)
1085 start_time = st->start_time;
1086 if (st->duration != AV_NOPTS_VALUE) {
1087 end_time1 = st->start_time + st->duration;
1088 if (end_time1 > end_time)
1089 end_time = end_time1;
1090 }
1091 }
1092 }
1093 if (start_time != MAXINT64) {
1094 ic->start_time = start_time;
1095 if (end_time != MAXINT64) {
1096 ic->duration = end_time - start_time;
1097 if (ic->file_size > 0) {
1098 /* compute the bit rate */
1099 ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1100 (double)ic->duration;
1101 }
1102 }
1103 }
1104
1105}
1106
1107static void fill_all_stream_timings(AVFormatContext *ic)
1108{
1109 int i;
1110 AVStream *st;
1111
1112 av_update_stream_timings(ic);
1113 for(i = 0;i < ic->nb_streams; i++) {
1114 st = ic->streams[i];
1115 if (st->start_time == AV_NOPTS_VALUE) {
1116 st->start_time = ic->start_time;
1117 st->duration = ic->duration;
1118 }
1119 }
1120}
1121
1122static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1123{
1124 int64_t filesize, duration;
1125 int bit_rate, i;
1126 AVStream *st;
1127
1128 /* if bit_rate is already set, we believe it */
1129 if (ic->bit_rate == 0) {
1130 bit_rate = 0;
1131 for(i=0;i<ic->nb_streams;i++) {
1132 st = ic->streams[i];
1133 bit_rate += st->codec.bit_rate;
1134 }
1135 ic->bit_rate = bit_rate;
1136 }
1137
1138 /* if duration is already set, we believe it */
1139 if (ic->duration == AV_NOPTS_VALUE &&
1140 ic->bit_rate != 0 &&
1141 ic->file_size != 0) {
1142 filesize = ic->file_size;
1143 if (filesize > 0) {
1144 duration = (int64_t)((8 * AV_TIME_BASE * (double)filesize) / (double)ic->bit_rate);
1145 for(i = 0; i < ic->nb_streams; i++) {
1146 st = ic->streams[i];
1147 if (st->start_time == AV_NOPTS_VALUE ||
1148 st->duration == AV_NOPTS_VALUE) {
1149 st->start_time = 0;
1150 st->duration = duration;
1151 }
1152 }
1153 }
1154 }
1155}
1156
12f996ed
FB
1157#define DURATION_MAX_READ_SIZE 250000
1158
1159/* only usable for MPEG-PS streams */
1160static void av_estimate_timings_from_pts(AVFormatContext *ic)
1161{
1162 AVPacket pkt1, *pkt = &pkt1;
1163 AVStream *st;
1164 int read_size, i, ret;
1165 int64_t start_time, end_time, end_time1;
1166 int64_t filesize, offset, duration;
1167
fb2758c8
FB
1168 /* free previous packet */
1169 if (ic->cur_st && ic->cur_st->parser)
1170 av_free_packet(&ic->cur_pkt);
1171 ic->cur_st = NULL;
1172
1173 /* flush packet queue */
1174 flush_packet_queue(ic);
1175
1176
12f996ed
FB
1177 /* we read the first packets to get the first PTS (not fully
1178 accurate, but it is enough now) */
1179 url_fseek(&ic->pb, 0, SEEK_SET);
1180 read_size = 0;
1181 for(;;) {
1182 if (read_size >= DURATION_MAX_READ_SIZE)
1183 break;
1184 /* if all info is available, we can stop */
1185 for(i = 0;i < ic->nb_streams; i++) {
1186 st = ic->streams[i];
1187 if (st->start_time == AV_NOPTS_VALUE)
1188 break;
1189 }
1190 if (i == ic->nb_streams)
1191 break;
1192
1193 ret = av_read_packet(ic, pkt);
1194 if (ret != 0)
1195 break;
1196 read_size += pkt->size;
1197 st = ic->streams[pkt->stream_index];
1198 if (pkt->pts != AV_NOPTS_VALUE) {
1199 if (st->start_time == AV_NOPTS_VALUE)
1200 st->start_time = (int64_t)((double)pkt->pts * ic->pts_num * (double)AV_TIME_BASE / ic->pts_den);
0a5f92a1
MN
1201 }
1202 av_free_packet(pkt);
1203 }
12f996ed
FB
1204
1205 /* we compute the minimum start_time and use it as default */
1206 start_time = MAXINT64;
1207 for(i = 0; i < ic->nb_streams; i++) {
1208 st = ic->streams[i];
1209 if (st->start_time != AV_NOPTS_VALUE &&
1210 st->start_time < start_time)
1211 start_time = st->start_time;
1212 }
12f996ed
FB
1213 if (start_time != MAXINT64)
1214 ic->start_time = start_time;
1215
1216 /* estimate the end time (duration) */
1217 /* XXX: may need to support wrapping */
1218 filesize = ic->file_size;
1219 offset = filesize - DURATION_MAX_READ_SIZE;
1220 if (offset < 0)
1221 offset = 0;
1222
12f996ed
FB
1223 url_fseek(&ic->pb, offset, SEEK_SET);
1224 read_size = 0;
1225 for(;;) {
1226 if (read_size >= DURATION_MAX_READ_SIZE)
1227 break;
1228 /* if all info is available, we can stop */
1229 for(i = 0;i < ic->nb_streams; i++) {
1230 st = ic->streams[i];
1231 if (st->duration == AV_NOPTS_VALUE)
1232 break;
1233 }
1234 if (i == ic->nb_streams)
1235 break;
1236
1237 ret = av_read_packet(ic, pkt);
1238 if (ret != 0)
1239 break;
1240 read_size += pkt->size;
1241 st = ic->streams[pkt->stream_index];
1242 if (pkt->pts != AV_NOPTS_VALUE) {
1243 end_time = (int64_t)((double)pkt->pts * ic->pts_num * (double)AV_TIME_BASE / ic->pts_den);
1244 duration = end_time - st->start_time;
1245 if (duration > 0) {
1246 if (st->duration == AV_NOPTS_VALUE ||
1247 st->duration < duration)
1248 st->duration = duration;
1249 }
1250 }
1251 av_free_packet(pkt);
1252 }
1253
1254 /* estimate total duration */
1255 end_time = MININT64;
1256 for(i = 0;i < ic->nb_streams; i++) {
1257 st = ic->streams[i];
1258 if (st->duration != AV_NOPTS_VALUE) {
1259 end_time1 = st->start_time + st->duration;
1260 if (end_time1 > end_time)
1261 end_time = end_time1;
1262 }
1263 }
1264
1265 /* update start_time (new stream may have been created, so we do
1266 it at the end */
1267 if (ic->start_time != AV_NOPTS_VALUE) {
1268 for(i = 0; i < ic->nb_streams; i++) {
1269 st = ic->streams[i];
1270 if (st->start_time == AV_NOPTS_VALUE)
1271 st->start_time = ic->start_time;
1272 }
1273 }
1274
1275 if (end_time != MININT64) {
1276 /* put dummy values for duration if needed */
1277 for(i = 0;i < ic->nb_streams; i++) {
1278 st = ic->streams[i];
1279 if (st->duration == AV_NOPTS_VALUE &&
1280 st->start_time != AV_NOPTS_VALUE)
1281 st->duration = end_time - st->start_time;
1282 }
1283 ic->duration = end_time - ic->start_time;
1284 }
1285
1286 url_fseek(&ic->pb, 0, SEEK_SET);
1287}
1288
1289static void av_estimate_timings(AVFormatContext *ic)
1290{
1291 URLContext *h;
1292 int64_t file_size;
1293
1294 /* get the file size, if possible */
1295 if (ic->iformat->flags & AVFMT_NOFILE) {
1296 file_size = 0;
1297 } else {
1298 h = url_fileno(&ic->pb);
1299 file_size = url_filesize(h);
1300 if (file_size < 0)
1301 file_size = 0;
1302 }
1303 ic->file_size = file_size;
1304
1305 if (ic->iformat == &mpegps_demux) {
1306 /* get accurate estimate from the PTSes */
1307 av_estimate_timings_from_pts(ic);
1308 } else if (av_has_timings(ic)) {
1309 /* at least one components has timings - we use them for all
1310 the components */
1311 fill_all_stream_timings(ic);
1312 } else {
1313 /* less precise: use bit rate info */
1314 av_estimate_timings_from_bit_rate(ic);
1315 }
1316 av_update_stream_timings(ic);
1317
1318#if 0
1319 {
1320 int i;
1321 AVStream *st;
1322 for(i = 0;i < ic->nb_streams; i++) {
1323 st = ic->streams[i];
1324 printf("%d: start_time: %0.3f duration: %0.3f\n",
1325 i, (double)st->start_time / AV_TIME_BASE,
1326 (double)st->duration / AV_TIME_BASE);
1327 }
1328 printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1329 (double)ic->start_time / AV_TIME_BASE,
1330 (double)ic->duration / AV_TIME_BASE,
1331 ic->bit_rate / 1000);
1332 }
1333#endif
1334}
1335
b9a281db
FB
1336static int has_codec_parameters(AVCodecContext *enc)
1337{
1338 int val;
1339 switch(enc->codec_type) {
1340 case CODEC_TYPE_AUDIO:
1341 val = enc->sample_rate;
1342 break;
1343 case CODEC_TYPE_VIDEO:
1344 val = enc->width;
1345 break;
1346 default:
1347 val = 1;
1348 break;
1349 }
1350 return (val != 0);
1351}
1352
fb2758c8
FB
1353static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1354{
1355 int16_t *samples;
1356 AVCodec *codec;
1357 int got_picture, ret;
1358 AVFrame picture;
1359
1360 codec = avcodec_find_decoder(st->codec.codec_id);
1361 if (!codec)
1362 return -1;
1363 ret = avcodec_open(&st->codec, codec);
1364 if (ret < 0)
1365 return ret;
1366 switch(st->codec.codec_type) {
1367 case CODEC_TYPE_VIDEO:
1368 ret = avcodec_decode_video(&st->codec, &picture,
1369 &got_picture, (uint8_t *)data, size);
1370 break;
1371 case CODEC_TYPE_AUDIO:
1372 samples = av_malloc(AVCODEC_MAX_AUDIO_FRAME_SIZE);
1373 if (!samples)
1374 goto fail;
1375 ret = avcodec_decode_audio(&st->codec, samples,
1376 &got_picture, (uint8_t *)data, size);
1377 av_free(samples);
1378 break;
1379 default:
1380 break;
1381 }
1382 fail:
1383 avcodec_close(&st->codec);
1384 return ret;
1385}
1386
1387/* absolute maximum size we read until we abort */
1388#define MAX_READ_SIZE 5000000
1389
1390/* maximum duration until we stop analysing the stream */
1391#define MAX_STREAM_DURATION ((int)(AV_TIME_BASE * 1.0))
1392
b9a281db
FB
1393/**
1394 * Read the beginning of a media file to get stream information. This
1395 * is useful for file formats with no headers such as MPEG. This
1396 * function also compute the real frame rate in case of mpeg2 repeat
1397 * frame mode.
1398 *
1399 * @param ic media file handle
1400 * @return >=0 if OK. AVERROR_xxx if error.
1401 */
1402int av_find_stream_info(AVFormatContext *ic)
1403{
fb2758c8 1404 int i, count, ret, read_size;
b9a281db 1405 AVStream *st;
fb2758c8 1406 AVPacket pkt1, *pkt;
b9a281db 1407 AVPacketList *pktl=NULL, **ppktl;
b9a281db
FB
1408
1409 count = 0;
1410 read_size = 0;
1411 ppktl = &ic->packet_buffer;
1412 for(;;) {
1413 /* check if one codec still needs to be handled */
1414 for(i=0;i<ic->nb_streams;i++) {
1415 st = ic->streams[i];
fb2758c8 1416 if (!has_codec_parameters(&st->codec))
b9a281db
FB
1417 break;
1418 }
1419 if (i == ic->nb_streams) {
1420 /* NOTE: if the format has no header, then we need to read
1421 some packets to get most of the streams, so we cannot
1422 stop here */
fb2758c8 1423 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
b9a281db
FB
1424 /* if we found the info for all the codecs, we can stop */
1425 ret = count;
1426 break;
1427 }
1428 } else {
1429 /* we did not get all the codec info, but we read too much data */
fb2758c8 1430 if (read_size >= MAX_READ_SIZE) {
b9a281db
FB
1431 ret = count;
1432 break;
1433 }
1434 }
1435
fb2758c8
FB
1436 /* NOTE: a new stream can be added there if no header in file
1437 (AVFMTCTX_NOHEADER) */
1438 ret = av_read_frame_internal(ic, &pkt1);
1439 if (ret < 0) {
1440 /* EOF or error */
1441 ret = -1; /* we could not have all the codec parameters before EOF */
1442 if ((ic->ctx_flags & AVFMTCTX_NOHEADER) &&
1443 i == ic->nb_streams)
1444 ret = 0;
1445 break;
1446 }
1447
b9a281db
FB
1448 pktl = av_mallocz(sizeof(AVPacketList));
1449 if (!pktl) {
1450 ret = AVERROR_NOMEM;
1451 break;
1452 }
1453
1454 /* add the packet in the buffered packet list */
1455 *ppktl = pktl;
1456 ppktl = &pktl->next;
1457
b9a281db 1458 pkt = &pktl->pkt;
fb2758c8
FB
1459 *pkt = pkt1;
1460
1461 /* duplicate the packet */
1462 if (av_dup_packet(pkt) < 0) {
1463 ret = AVERROR_NOMEM;
1464 break;
b9a281db 1465 }
b9a281db 1466
fb2758c8 1467 read_size += pkt->size;
b9a281db
FB
1468
1469 st = ic->streams[pkt->stream_index];
fb2758c8
FB
1470 st->codec_info_duration += pkt->duration;
1471 if (pkt->duration != 0)
1472 st->codec_info_nb_frames++;
1473
1474 /* if still no information, we try to open the codec and to
1475 decompress the frame. We try to avoid that in most cases as
1476 it takes longer and uses more memory. For MPEG4, we need to
1477 decompress for Quicktime. */
1478 if (!has_codec_parameters(&st->codec) &&
1479 (st->codec.codec_id == CODEC_ID_FLV1 ||
1480 st->codec.codec_id == CODEC_ID_H264 ||
1481 st->codec.codec_id == CODEC_ID_H263 ||
8bfed902 1482 st->codec.codec_id == CODEC_ID_VORBIS ||
fb2758c8
FB
1483 (st->codec.codec_id == CODEC_ID_MPEG4 && !st->need_parsing)))
1484 try_decode_frame(st, pkt->data, pkt->size);
1485
1486 if (st->codec_info_duration >= MAX_STREAM_DURATION) {
1487 break;
b9a281db
FB
1488 }
1489 count++;
1490 }
1491
b9a281db
FB
1492 /* set real frame rate info */
1493 for(i=0;i<ic->nb_streams;i++) {
1494 st = ic->streams[i];
1495 if (st->codec.codec_type == CODEC_TYPE_VIDEO) {
fb2758c8
FB
1496 /* compute the real frame rate for telecine */
1497 if ((st->codec.codec_id == CODEC_ID_MPEG1VIDEO ||
1498 st->codec.codec_id == CODEC_ID_MPEG2VIDEO) &&
1499 st->codec.sub_id == 2) {
1500 if (st->codec_info_nb_frames >= 20) {
1501 float coded_frame_rate, est_frame_rate;
1502 est_frame_rate = ((double)st->codec_info_nb_frames * AV_TIME_BASE) /
1503 (double)st->codec_info_duration ;
1504 coded_frame_rate = (double)st->codec.frame_rate /
1505 (double)st->codec.frame_rate_base;
1506#if 0
1507 printf("telecine: coded_frame_rate=%0.3f est_frame_rate=%0.3f\n",
1508 coded_frame_rate, est_frame_rate);
1509#endif
1510 /* if we detect that it could be a telecine, we
1511 signal it. It would be better to do it at a
1512 higher level as it can change in a film */
1513 if (coded_frame_rate >= 24.97 &&
1514 (est_frame_rate >= 23.5 && est_frame_rate < 24.5)) {
1515 st->r_frame_rate = 24024;
1516 st->r_frame_rate_base = 1001;
1517 }
1518 }
1519 }
1520 /* if no real frame rate, use the codec one */
14bea432
MN
1521 if (!st->r_frame_rate){
1522 st->r_frame_rate = st->codec.frame_rate;
1523 st->r_frame_rate_base = st->codec.frame_rate_base;
1524 }
b9a281db 1525 }
de6d9b64 1526 }
b9a281db 1527
12f996ed 1528 av_estimate_timings(ic);
b9a281db 1529 return ret;
de6d9b64
FB
1530}
1531
fb2758c8
FB
1532/*******************************************************/
1533
1534/**
1535 * start playing a network based stream (e.g. RTSP stream) at the
1536 * current position
1537 */
1538int av_read_play(AVFormatContext *s)
1539{
1540 if (!s->iformat->read_play)
1541 return AVERROR_NOTSUPP;
1542 return s->iformat->read_play(s);
1543}
1544
1545/**
1546 * pause a network based stream (e.g. RTSP stream). Use av_read_play()
1547 * to resume it.
1548 */
1549int av_read_pause(AVFormatContext *s)
1550{
1551 if (!s->iformat->read_pause)
1552 return AVERROR_NOTSUPP;
1553 return s->iformat->read_pause(s);
1554}
1555
b9a281db
FB
1556/**
1557 * Close a media file (but not its codecs)
1558 *
1559 * @param s media file handle
1560 */
de6d9b64
FB
1561void av_close_input_file(AVFormatContext *s)
1562{
b6892136 1563 int i, must_open_file;
da24c5e3 1564 AVStream *st;
de6d9b64 1565
fb2758c8
FB
1566 /* free previous packet */
1567 if (s->cur_st && s->cur_st->parser)
1568 av_free_packet(&s->cur_pkt);
1569
b9a281db
FB
1570 if (s->iformat->read_close)
1571 s->iformat->read_close(s);
de6d9b64 1572 for(i=0;i<s->nb_streams;i++) {
da24c5e3
FB
1573 /* free all data in a stream component */
1574 st = s->streams[i];
fb2758c8
FB
1575 if (st->parser) {
1576 av_parser_close(st->parser);
de6d9b64 1577 }
fb2758c8
FB
1578 av_free(st->index_entries);
1579 av_free(st);
de6d9b64 1580 }
fb2758c8 1581 flush_packet_queue(s);
b6892136 1582 must_open_file = 1;
da24c5e3 1583 if (s->iformat->flags & AVFMT_NOFILE) {
b6892136
FB
1584 must_open_file = 0;
1585 }
1586 if (must_open_file) {
96baaa6a
FB
1587 url_fclose(&s->pb);
1588 }
a8dbe951 1589 av_freep(&s->priv_data);
1ea4f593 1590 av_free(s);
de6d9b64
FB
1591}
1592
b9a281db
FB
1593/**
1594 * Add a new stream to a media file. Can only be called in the
da24c5e3
FB
1595 * read_header function. If the flag AVFMTCTX_NOHEADER is in the
1596 * format context, then new streams can be added in read_packet too.
b9a281db
FB
1597 *
1598 *
1599 * @param s media file handle
da24c5e3 1600 * @param id file format dependent stream id
b9a281db
FB
1601 */
1602AVStream *av_new_stream(AVFormatContext *s, int id)
1603{
1604 AVStream *st;
1605
1606 if (s->nb_streams >= MAX_STREAMS)
1607 return NULL;
1608
1609 st = av_mallocz(sizeof(AVStream));
1610 if (!st)
1611 return NULL;
1e491e29 1612 avcodec_get_context_defaults(&st->codec);
48091512
FB
1613 if (s->iformat) {
1614 /* no default bitrate if decoding */
1615 st->codec.bit_rate = 0;
1616 }
b9a281db
FB
1617 st->index = s->nb_streams;
1618 st->id = id;
12f996ed
FB
1619 st->start_time = AV_NOPTS_VALUE;
1620 st->duration = AV_NOPTS_VALUE;
b9a281db
FB
1621 s->streams[s->nb_streams++] = st;
1622 return st;
1623}
1624
1625/************************************************************/
1626/* output media file */
de6d9b64 1627
87a0a681
FB
1628int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
1629{
1630 int ret;
98486a6b
RS
1631
1632 if (s->oformat->priv_data_size > 0) {
1633 s->priv_data = av_mallocz(s->oformat->priv_data_size);
1634 if (!s->priv_data)
1635 return AVERROR_NOMEM;
1636 } else
1637 s->priv_data = NULL;
1638
87a0a681
FB
1639 if (s->oformat->set_parameters) {
1640 ret = s->oformat->set_parameters(s, ap);
1641 if (ret < 0)
1642 return ret;
1643 }
1644 return 0;
1645}
1646
b9a281db
FB
1647/**
1648 * allocate the stream private data and write the stream header to an
1649 * output media file
1650 *
1651 * @param s media file handle
1652 * @return 0 if OK. AVERROR_xxx if error.
1653 */
1654int av_write_header(AVFormatContext *s)
1655{
1e51d801
FB
1656 int ret, i;
1657 AVStream *st;
1658
916c80e9
FB
1659 /* default pts settings is MPEG like */
1660 av_set_pts_info(s, 33, 1, 90000);
1e51d801
FB
1661 ret = s->oformat->write_header(s);
1662 if (ret < 0)
1663 return ret;
1664
1665 /* init PTS generation */
1666 for(i=0;i<s->nb_streams;i++) {
1667 st = s->streams[i];
1668
1669 switch (st->codec.codec_type) {
1670 case CODEC_TYPE_AUDIO:
1671 av_frac_init(&st->pts, 0, 0,
0c1a9eda 1672 (int64_t)s->pts_num * st->codec.sample_rate);
1e51d801
FB
1673 break;
1674 case CODEC_TYPE_VIDEO:
1675 av_frac_init(&st->pts, 0, 0,
0c1a9eda 1676 (int64_t)s->pts_num * st->codec.frame_rate);
1e51d801
FB
1677 break;
1678 default:
1679 break;
1680 }
1681 }
1682 return 0;
b9a281db
FB
1683}
1684
1685/**
1e51d801
FB
1686 * Write a packet to an output media file. The packet shall contain
1687 * one audio or video frame.
b9a281db
FB
1688 *
1689 * @param s media file handle
1e51d801
FB
1690 * @param stream_index stream index
1691 * @param buf buffer containing the frame data
1692 * @param size size of buffer
d4c0ff91 1693 * @return < 0 if error, = 0 if OK, 1 if end of stream wanted.
b9a281db 1694 */
1e51d801
FB
1695int av_write_frame(AVFormatContext *s, int stream_index, const uint8_t *buf,
1696 int size)
de6d9b64 1697{
1e51d801 1698 AVStream *st;
0c1a9eda 1699 int64_t pts_mask;
7feb950a 1700 int ret, frame_size;
1e51d801
FB
1701
1702 st = s->streams[stream_index];
1703 pts_mask = (1LL << s->pts_wrap_bits) - 1;
b0c7f5a9
MN
1704
1705 /* HACK/FIXME we skip all zero size audio packets so a encoder can pass pts by outputing zero size packets */
1706 if(st->codec.codec_type==CODEC_TYPE_AUDIO && size==0)
1707 ret = 0;
1708 else
1709 ret = s->oformat->write_packet(s, stream_index, buf, size,
1710 st->pts.val & pts_mask);
1711
1e51d801
FB
1712 if (ret < 0)
1713 return ret;
1714
1715 /* update pts */
1716 switch (st->codec.codec_type) {
1717 case CODEC_TYPE_AUDIO:
fb2758c8 1718 frame_size = get_audio_frame_size(&st->codec, size);
6d8f985e 1719
b0c7f5a9 1720 /* HACK/FIXME, we skip the initial 0-size packets as they are most likely equal to the encoder delay,
6d8f985e 1721 but it would be better if we had the real timestamps from the encoder */
6d8f985e 1722 if (frame_size >= 0 && (size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
fb2758c8
FB
1723 av_frac_add(&st->pts,
1724 (int64_t)s->pts_den * frame_size);
7feb950a 1725 }
1e51d801
FB
1726 break;
1727 case CODEC_TYPE_VIDEO:
1728 av_frac_add(&st->pts,
14bea432 1729 (int64_t)s->pts_den * st->codec.frame_rate_base);
1e51d801
FB
1730 break;
1731 default:
1732 break;
1733 }
d4c0ff91 1734 return ret;
b9a281db
FB
1735}
1736
1737/**
1738 * write the stream trailer to an output media file and and free the
1739 * file private data.
1740 *
1741 * @param s media file handle
1742 * @return 0 if OK. AVERROR_xxx if error. */
1743int av_write_trailer(AVFormatContext *s)
1744{
1745 int ret;
1746 ret = s->oformat->write_trailer(s);
1747 av_freep(&s->priv_data);
1748 return ret;
de6d9b64
FB
1749}
1750
1751/* "user interface" functions */
1752
1753void dump_format(AVFormatContext *ic,
1754 int index,
1755 const char *url,
1756 int is_output)
1757{
b9a281db 1758 int i, flags;
de6d9b64
FB
1759 char buf[256];
1760
43465395 1761 av_log(NULL, AV_LOG_DEBUG, "%s #%d, %s, %s '%s':\n",
de6d9b64 1762 is_output ? "Output" : "Input",
b9a281db
FB
1763 index,
1764 is_output ? ic->oformat->name : ic->iformat->name,
de6d9b64 1765 is_output ? "to" : "from", url);
12f996ed 1766 if (!is_output) {
43465395 1767 av_log(NULL, AV_LOG_DEBUG, " Duration: ");
12f996ed
FB
1768 if (ic->duration != AV_NOPTS_VALUE) {
1769 int hours, mins, secs, us;
1770 secs = ic->duration / AV_TIME_BASE;
1771 us = ic->duration % AV_TIME_BASE;
1772 mins = secs / 60;
1773 secs %= 60;
1774 hours = mins / 60;
1775 mins %= 60;
43465395 1776 av_log(NULL, AV_LOG_DEBUG, "%02d:%02d:%02d.%01d", hours, mins, secs,
12f996ed
FB
1777 (10 * us) / AV_TIME_BASE);
1778 } else {
43465395 1779 av_log(NULL, AV_LOG_DEBUG, "N/A");
12f996ed 1780 }
43465395 1781 av_log(NULL, AV_LOG_DEBUG, ", bitrate: ");
12f996ed 1782 if (ic->bit_rate) {
43465395 1783 av_log(NULL, AV_LOG_DEBUG,"%d kb/s", ic->bit_rate / 1000);
12f996ed 1784 } else {
43465395 1785 av_log(NULL, AV_LOG_DEBUG, "N/A");
12f996ed 1786 }
43465395 1787 av_log(NULL, AV_LOG_DEBUG, "\n");
12f996ed 1788 }
de6d9b64
FB
1789 for(i=0;i<ic->nb_streams;i++) {
1790 AVStream *st = ic->streams[i];
1791 avcodec_string(buf, sizeof(buf), &st->codec, is_output);
43465395 1792 av_log(NULL, AV_LOG_DEBUG, " Stream #%d.%d", index, i);
b9a281db
FB
1793 /* the pid is an important information, so we display it */
1794 /* XXX: add a generic system */
1795 if (is_output)
1796 flags = ic->oformat->flags;
1797 else
1798 flags = ic->iformat->flags;
1799 if (flags & AVFMT_SHOW_IDS) {
43465395 1800 av_log(NULL, AV_LOG_DEBUG, "[0x%x]", st->id);
b9a281db 1801 }
43465395 1802 av_log(NULL, AV_LOG_DEBUG, ": %s\n", buf);
de6d9b64
FB
1803 }
1804}
1805
1806typedef struct {
445f1b83 1807 const char *abv;
de6d9b64 1808 int width, height;
445f1b83
RS
1809 int frame_rate, frame_rate_base;
1810} AbvEntry;
1811
1812static AbvEntry frame_abvs[] = {
ba2a8cb4
RS
1813 { "ntsc", 720, 480, 30000, 1001 },
1814 { "pal", 720, 576, 25, 1 },
1815 { "qntsc", 352, 240, 30000, 1001 }, /* VCD compliant ntsc */
1816 { "qpal", 352, 288, 25, 1 }, /* VCD compliant pal */
904736b5
RS
1817 { "sntsc", 640, 480, 30000, 1001 }, /* square pixel ntsc */
1818 { "spal", 768, 576, 25, 1 }, /* square pixel pal */
445f1b83
RS
1819 { "film", 352, 240, 24, 1 },
1820 { "ntsc-film", 352, 240, 24000, 1001 },
1821 { "sqcif", 128, 96, 0, 0 },
1822 { "qcif", 176, 144, 0, 0 },
1823 { "cif", 352, 288, 0, 0 },
1824 { "4cif", 704, 576, 0, 0 },
de6d9b64 1825};
445f1b83 1826
de6d9b64
FB
1827int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
1828{
1829 int i;
445f1b83 1830 int n = sizeof(frame_abvs) / sizeof(AbvEntry);
de6d9b64
FB
1831 const char *p;
1832 int frame_width = 0, frame_height = 0;
1833
1834 for(i=0;i<n;i++) {
445f1b83
RS
1835 if (!strcmp(frame_abvs[i].abv, str)) {
1836 frame_width = frame_abvs[i].width;
1837 frame_height = frame_abvs[i].height;
de6d9b64
FB
1838 break;
1839 }
1840 }
1841 if (i == n) {
1842 p = str;
1843 frame_width = strtol(p, (char **)&p, 10);
1844 if (*p)
1845 p++;
1846 frame_height = strtol(p, (char **)&p, 10);
1847 }
1848 if (frame_width <= 0 || frame_height <= 0)
1849 return -1;
1850 *width_ptr = frame_width;
1851 *height_ptr = frame_height;
1852 return 0;
1853}
1854
445f1b83
RS
1855int parse_frame_rate(int *frame_rate, int *frame_rate_base, const char *arg)
1856{
1857 int i;
1858 char* cp;
1859
1860 /* First, we check our abbreviation table */
1861 for (i = 0; i < sizeof(frame_abvs)/sizeof(*frame_abvs); ++i)
1862 if (!strcmp(frame_abvs[i].abv, arg)) {
1863 *frame_rate = frame_abvs[i].frame_rate;
1864 *frame_rate_base = frame_abvs[i].frame_rate_base;
1865 return 0;
1866 }
1867
1868 /* Then, we try to parse it as fraction */
1869 cp = strchr(arg, '/');
1870 if (cp) {
1871 char* cpp;
1872 *frame_rate = strtol(arg, &cpp, 10);
1873 if (cpp != arg || cpp == cp)
1874 *frame_rate_base = strtol(cp+1, &cpp, 10);
1875 else
1876 *frame_rate = 0;
1877 }
1878 else {
1879 /* Finally we give up and parse it as double */
8bfed902 1880 *frame_rate_base = DEFAULT_FRAME_RATE_BASE; //FIXME use av_d2q()
445f1b83
RS
1881 *frame_rate = (int)(strtod(arg, 0) * (*frame_rate_base) + 0.5);
1882 }
1883 if (!*frame_rate || !*frame_rate_base)
1884 return -1;
1885 else
1886 return 0;
1887}
1888
916c80e9
FB
1889/* Syntax:
1890 * - If not a duration:
1891 * [{YYYY-MM-DD|YYYYMMDD}]{T| }{HH[:MM[:SS[.m...]]][Z]|HH[MM[SS[.m...]]][Z]}
c5510dd6 1892 * Time is localtime unless Z is suffixed to the end. In this case GMT
916c80e9
FB
1893 * Return the date in micro seconds since 1970
1894 * - If duration:
1895 * HH[:MM[:SS[.m...]]]
1896 * S+[.m...]
1897 */
0c1a9eda 1898int64_t parse_date(const char *datestr, int duration)
de6d9b64
FB
1899{
1900 const char *p;
0c1a9eda 1901 int64_t t;
2dbceb9f 1902 struct tm dt;
c5510dd6
PG
1903 int i;
1904 static const char *date_fmt[] = {
1905 "%Y-%m-%d",
1906 "%Y%m%d",
1907 };
1908 static const char *time_fmt[] = {
1909 "%H:%M:%S",
1910 "%H%M%S",
1911 };
1912 const char *q;
916c80e9 1913 int is_utc, len;
c5510dd6 1914 char lastch;
6d8f985e
MN
1915
1916#undef time
c5510dd6
PG
1917 time_t now = time(0);
1918
916c80e9
FB
1919 len = strlen(datestr);
1920 if (len > 0)
1921 lastch = datestr[len - 1];
1922 else
1923 lastch = '\0';
c5510dd6 1924 is_utc = (lastch == 'z' || lastch == 'Z');
2dbceb9f
PG
1925
1926 memset(&dt, 0, sizeof(dt));
de6d9b64
FB
1927
1928 p = datestr;
916c80e9 1929 q = NULL;
de6d9b64 1930 if (!duration) {
c5510dd6 1931 for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
f71869a4 1932 q = small_strptime(p, date_fmt[i], &dt);
c5510dd6
PG
1933 if (q) {
1934 break;
1935 }
1936 }
1937
1938 if (!q) {
1939 if (is_utc) {
1940 dt = *gmtime(&now);
1941 } else {
1942 dt = *localtime(&now);
1943 }
1944 dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
de6d9b64 1945 } else {
c5510dd6 1946 p = q;
de6d9b64 1947 }
c5510dd6
PG
1948
1949 if (*p == 'T' || *p == 't' || *p == ' ')
1950 p++;
c5510dd6 1951
916c80e9 1952 for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
f71869a4 1953 q = small_strptime(p, time_fmt[i], &dt);
916c80e9
FB
1954 if (q) {
1955 break;
1956 }
1957 }
1958 } else {
f71869a4 1959 q = small_strptime(p, time_fmt[0], &dt);
916c80e9
FB
1960 if (!q) {
1961 dt.tm_sec = strtol(p, (char **)&q, 10);
1962 dt.tm_min = 0;
1963 dt.tm_hour = 0;
c5510dd6
PG
1964 }
1965 }
1966
1967 /* Now we have all the fields that we can get */
1968 if (!q) {
1969 if (duration)
1970 return 0;
1971 else
0c1a9eda 1972 return now * int64_t_C(1000000);
de6d9b64 1973 }
2dbceb9f
PG
1974
1975 if (duration) {
c5510dd6 1976 t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2dbceb9f 1977 } else {
c5510dd6
PG
1978 dt.tm_isdst = -1; /* unknown */
1979 if (is_utc) {
1980 t = mktimegm(&dt);
1981 } else {
1982 t = mktime(&dt);
1983 }
de6d9b64 1984 }
2dbceb9f 1985
c5510dd6
PG
1986 t *= 1000000;
1987
1988 if (*q == '.') {
de6d9b64 1989 int val, n;
c5510dd6
PG
1990 q++;
1991 for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
1992 if (!isdigit(*q))
1993 break;
1994 val += n * (*q - '0');
de6d9b64
FB
1995 }
1996 t += val;
1997 }
1998 return t;
1999}
2000
2dbceb9f 2001/* syntax: '?tag1=val1&tag2=val2...'. Little URL decoding is done. Return
de6d9b64
FB
2002 1 if found */
2003int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
2004{
2005 const char *p;
2006 char tag[128], *q;
2007
2008 p = info;
2009 if (*p == '?')
2010 p++;
2011 for(;;) {
2012 q = tag;
2013 while (*p != '\0' && *p != '=' && *p != '&') {
2014 if ((q - tag) < sizeof(tag) - 1)
2015 *q++ = *p;
2016 p++;
2017 }
2018 *q = '\0';
2019 q = arg;
2020 if (*p == '=') {
2021 p++;
2022 while (*p != '&' && *p != '\0') {
2dbceb9f
PG
2023 if ((q - arg) < arg_size - 1) {
2024 if (*p == '+')
2025 *q++ = ' ';
2026 else
2027 *q++ = *p;
2028 }
de6d9b64
FB
2029 p++;
2030 }
2031 *q = '\0';
2032 }
2033 if (!strcmp(tag, tag1))
2034 return 1;
2035 if (*p != '&')
2036 break;
8d1335ea 2037 p++;
de6d9b64
FB
2038 }
2039 return 0;
2040}
2041
9150f42e
FB
2042/* Return in 'buf' the path with '%d' replaced by number. Also handles
2043 the '%0nd' format where 'n' is the total number of digits and
2044 '%%'. Return 0 if OK, and -1 if format error */
2045int get_frame_filename(char *buf, int buf_size,
2046 const char *path, int number)
2047{
2048 const char *p;
0bf92f79
PI
2049 char *q, buf1[20], c;
2050 int nd, len, percentd_found;
9150f42e
FB
2051
2052 q = buf;
2053 p = path;
2054 percentd_found = 0;
2055 for(;;) {
2056 c = *p++;
2057 if (c == '\0')
2058 break;
2059 if (c == '%') {
c9646fda
PG
2060 do {
2061 nd = 0;
2062 while (isdigit(*p)) {
2063 nd = nd * 10 + *p++ - '0';
2064 }
2065 c = *p++;
c9646fda
PG
2066 } while (isdigit(c));
2067
9150f42e
FB
2068 switch(c) {
2069 case '%':
2070 goto addchar;
2071 case 'd':
2072 if (percentd_found)
2073 goto fail;
2074 percentd_found = 1;
2075 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
2076 len = strlen(buf1);
2077 if ((q - buf + len) > buf_size - 1)
2078 goto fail;
2079 memcpy(q, buf1, len);
2080 q += len;
2081 break;
2082 default:
2083 goto fail;
2084 }
2085 } else {
2086 addchar:
2087 if ((q - buf) < buf_size - 1)
2088 *q++ = c;
2089 }
2090 }
2091 if (!percentd_found)
2092 goto fail;
2093 *q = '\0';
2094 return 0;
2095 fail:
2096 *q = '\0';
2097 return -1;
2098}
2099
b9a281db 2100/**
fb2758c8
FB
2101 * Print nice hexa dump of a buffer
2102 * @param f stream for output
b9a281db
FB
2103 * @param buf buffer
2104 * @param size buffer size
2105 */
fb2758c8 2106void av_hex_dump(FILE *f, uint8_t *buf, int size)
b9a281db
FB
2107{
2108 int len, i, j, c;
2109
2110 for(i=0;i<size;i+=16) {
2111 len = size - i;
2112 if (len > 16)
2113 len = 16;
fb2758c8 2114 fprintf(f, "%08x ", i);
b9a281db
FB
2115 for(j=0;j<16;j++) {
2116 if (j < len)
fb2758c8 2117 fprintf(f, " %02x", buf[i+j]);
b9a281db 2118 else
fb2758c8 2119 fprintf(f, " ");
b9a281db 2120 }
fb2758c8 2121 fprintf(f, " ");
b9a281db
FB
2122 for(j=0;j<len;j++) {
2123 c = buf[i+j];
2124 if (c < ' ' || c > '~')
2125 c = '.';
fb2758c8 2126 fprintf(f, "%c", c);
b9a281db 2127 }
fb2758c8 2128 fprintf(f, "\n");
b9a281db
FB
2129 }
2130}
2131
fb2758c8
FB
2132/**
2133 * Print on 'f' a nice dump of a packet
2134 * @param f stream for output
2135 * @param pkt packet to dump
2136 * @param dump_payload true if the payload must be displayed too
2137 */
2138void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
2139{
2140 fprintf(f, "stream #%d:\n", pkt->stream_index);
2141 fprintf(f, " keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
2142 fprintf(f, " duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
37353960
FB
2143 /* DTS is _always_ valid after av_read_frame() */
2144 fprintf(f, " dts=");
2145 if (pkt->dts == AV_NOPTS_VALUE)
2146 fprintf(f, "N/A");
2147 else
2148 fprintf(f, "%0.3f", (double)pkt->dts / AV_TIME_BASE);
fb2758c8
FB
2149 /* PTS may be not known if B frames are present */
2150 fprintf(f, " pts=");
2151 if (pkt->pts == AV_NOPTS_VALUE)
2152 fprintf(f, "N/A");
2153 else
2154 fprintf(f, "%0.3f", (double)pkt->pts / AV_TIME_BASE);
2155 fprintf(f, "\n");
2156 fprintf(f, " size=%d\n", pkt->size);
2157 if (dump_payload)
2158 av_hex_dump(f, pkt->data, pkt->size);
2159}
2160
a9a721da
FB
2161void url_split(char *proto, int proto_size,
2162 char *hostname, int hostname_size,
2163 int *port_ptr,
2164 char *path, int path_size,
2165 const char *url)
2166{
2167 const char *p;
2168 char *q;
2169 int port;
2170
2171 port = -1;
2172
2173 p = url;
2174 q = proto;
2175 while (*p != ':' && *p != '\0') {
2176 if ((q - proto) < proto_size - 1)
2177 *q++ = *p;
2178 p++;
2179 }
2180 if (proto_size > 0)
2181 *q = '\0';
2182 if (*p == '\0') {
2183 if (proto_size > 0)
2184 proto[0] = '\0';
2185 if (hostname_size > 0)
2186 hostname[0] = '\0';
2187 p = url;
2188 } else {
2189 p++;
2190 if (*p == '/')
2191 p++;
2192 if (*p == '/')
2193 p++;
2194 q = hostname;
2195 while (*p != ':' && *p != '/' && *p != '?' && *p != '\0') {
2196 if ((q - hostname) < hostname_size - 1)
2197 *q++ = *p;
2198 p++;
2199 }
2200 if (hostname_size > 0)
2201 *q = '\0';
2202 if (*p == ':') {
2203 p++;
2204 port = strtoul(p, (char **)&p, 10);
2205 }
2206 }
2207 if (port_ptr)
2208 *port_ptr = port;
2209 pstrcpy(path, path_size, p);
2210}
2211
916c80e9
FB
2212/**
2213 * Set the pts for a given stream
2214 * @param s stream
2215 * @param pts_wrap_bits number of bits effectively used by the pts
2216 * (used for wrap control, 33 is the value for MPEG)
2217 * @param pts_num numerator to convert to seconds (MPEG: 1)
2218 * @param pts_den denominator to convert to seconds (MPEG: 90000)
2219 */
2220void av_set_pts_info(AVFormatContext *s, int pts_wrap_bits,
2221 int pts_num, int pts_den)
2222{
2223 s->pts_wrap_bits = pts_wrap_bits;
2224 s->pts_num = pts_num;
2225 s->pts_den = pts_den;
2226}
2227
2228/* fraction handling */
2229
2230/**
2231 * f = val + (num / den) + 0.5. 'num' is normalized so that it is such
2232 * as 0 <= num < den.
2233 *
2234 * @param f fractional number
2235 * @param val integer value
2236 * @param num must be >= 0
2237 * @param den must be >= 1
2238 */
0c1a9eda 2239void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
916c80e9
FB
2240{
2241 num += (den >> 1);
2242 if (num >= den) {
2243 val += num / den;
2244 num = num % den;
2245 }
2246 f->val = val;
2247 f->num = num;
2248 f->den = den;
2249}
2250
2251/* set f to (val + 0.5) */
0c1a9eda 2252void av_frac_set(AVFrac *f, int64_t val)
916c80e9
FB
2253{
2254 f->val = val;
2255 f->num = f->den >> 1;
2256}
2257
2258/**
2259 * Fractionnal addition to f: f = f + (incr / f->den)
2260 *
2261 * @param f fractional number
2262 * @param incr increment, can be positive or negative
2263 */
0c1a9eda 2264void av_frac_add(AVFrac *f, int64_t incr)
916c80e9 2265{
0c1a9eda 2266 int64_t num, den;
916c80e9
FB
2267
2268 num = f->num + incr;
2269 den = f->den;
2270 if (num < 0) {
2271 f->val += num / den;
2272 num = num % den;
2273 if (num < 0) {
2274 num += den;
2275 f->val--;
2276 }
2277 } else if (num >= den) {
2278 f->val += num / den;
2279 num = num % den;
2280 }
2281 f->num = num;
2282}
87a0a681
FB
2283
2284/**
2285 * register a new image format
2286 * @param img_fmt Image format descriptor
2287 */
2288void av_register_image_format(AVImageFormat *img_fmt)
2289{
2290 AVImageFormat **p;
2291
2292 p = &first_image_format;
2293 while (*p != NULL) p = &(*p)->next;
2294 *p = img_fmt;
2295 img_fmt->next = NULL;
2296}
2297
2298/* guess image format */
2299AVImageFormat *av_probe_image_format(AVProbeData *pd)
2300{
2301 AVImageFormat *fmt1, *fmt;
2302 int score, score_max;
2303
2304 fmt = NULL;
2305 score_max = 0;
2306 for(fmt1 = first_image_format; fmt1 != NULL; fmt1 = fmt1->next) {
2307 if (fmt1->img_probe) {
2308 score = fmt1->img_probe(pd);
2309 if (score > score_max) {
2310 score_max = score;
2311 fmt = fmt1;
2312 }
2313 }
2314 }
2315 return fmt;
2316}
2317
2318AVImageFormat *guess_image_format(const char *filename)
2319{
2320 AVImageFormat *fmt1;
2321
2322 for(fmt1 = first_image_format; fmt1 != NULL; fmt1 = fmt1->next) {
2323 if (fmt1->extensions && match_ext(filename, fmt1->extensions))
2324 return fmt1;
2325 }
2326 return NULL;
2327}
2328
2329/**
2330 * Read an image from a stream.
2331 * @param gb byte stream containing the image
2332 * @param fmt image format, NULL if probing is required
2333 */
2334int av_read_image(ByteIOContext *pb, const char *filename,
2335 AVImageFormat *fmt,
2336 int (*alloc_cb)(void *, AVImageInfo *info), void *opaque)
2337{
2338 char buf[PROBE_BUF_SIZE];
2339 AVProbeData probe_data, *pd = &probe_data;
2340 offset_t pos;
2341 int ret;
2342
2343 if (!fmt) {
5c91a675 2344 pd->filename = filename;
87a0a681
FB
2345 pd->buf = buf;
2346 pos = url_ftell(pb);
2347 pd->buf_size = get_buffer(pb, buf, PROBE_BUF_SIZE);
2348 url_fseek(pb, pos, SEEK_SET);
2349 fmt = av_probe_image_format(pd);
2350 }
2351 if (!fmt)
2352 return AVERROR_NOFMT;
2353 ret = fmt->img_read(pb, alloc_cb, opaque);
2354 return ret;
2355}
2356
2357/**
2358 * Write an image to a stream.
2359 * @param pb byte stream for the image output
2360 * @param fmt image format
2361 * @param img image data and informations
2362 */
2363int av_write_image(ByteIOContext *pb, AVImageFormat *fmt, AVImageInfo *img)
2364{
2365 return fmt->img_write(pb, img);
2366}
2367