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