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