10000l : fix a crash on x86 due to an horrible mistake in my x86_64 patch
[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 894/**
8bcb147f
MN
895 * updates the cur_dts field based on the given timestamp and AVStream.
896 * only needed if (dts are not set and pts!=dts) or for timestamp wrapping
897 */
898static void av_update_cur_dts(AVFormatContext *s, AVStream *st, int64_t timestamp){
899 int i;
900
901 for(i = 0; i < s->nb_streams; i++) {
902 AVStream *st2 = s->streams[i];
903
904 st->cur_dts = av_rescale(timestamp,
905 st2->time_base.den * (int64_t)st ->time_base.num,
906 st ->time_base.den * (int64_t)st2->time_base.num);
907 }
908}
909
910/**
cdd5034f
MN
911 * add a index entry into a sorted list updateing if it is already there.
912 * @param timestamp timestamp in the timebase of the given stream
913 */
3e9245a9
MN
914int av_add_index_entry(AVStream *st,
915 int64_t pos, int64_t timestamp, int distance, int flags)
fb2758c8
FB
916{
917 AVIndexEntry *entries, *ie;
b754978a 918 int index;
fb2758c8
FB
919
920 entries = av_fast_realloc(st->index_entries,
921 &st->index_entries_allocated_size,
922 (st->nb_index_entries + 1) *
923 sizeof(AVIndexEntry));
b754978a
MN
924 st->index_entries= entries;
925
3ba1438d 926 index= av_index_search_timestamp(st, timestamp, 0);
b754978a 927
3ba1438d 928 if(index<0){
3e9245a9
MN
929 index= st->nb_index_entries++;
930 ie= &entries[index];
3ba1438d
MN
931 assert(index==0 || ie[-1].timestamp < timestamp);
932 }else{
933 ie= &entries[index];
934 if(ie->timestamp != timestamp){
528c2c73
MN
935 if(ie->timestamp <= timestamp)
936 return -1;
3ba1438d
MN
937 memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
938 st->nb_index_entries++;
939 }else if(ie->pos == pos && distance < ie->min_distance) //dont reduce the distance
940 distance= ie->min_distance;
3e9245a9 941 }
3ba1438d 942
b754978a
MN
943 ie->pos = pos;
944 ie->timestamp = timestamp;
3e9245a9 945 ie->min_distance= distance;
b754978a 946 ie->flags = flags;
3e9245a9
MN
947
948 return index;
fb2758c8
FB
949}
950
951/* build an index for raw streams using a parser */
952static void av_build_index_raw(AVFormatContext *s)
953{
954 AVPacket pkt1, *pkt = &pkt1;
955 int ret;
956 AVStream *st;
957
958 st = s->streams[0];
959 av_read_frame_flush(s);
960 url_fseek(&s->pb, s->data_offset, SEEK_SET);
961
962 for(;;) {
963 ret = av_read_frame(s, pkt);
964 if (ret < 0)
965 break;
966 if (pkt->stream_index == 0 && st->parser &&
967 (pkt->flags & PKT_FLAG_KEY)) {
cdd5034f
MN
968 int64_t dts= av_rescale(pkt->dts, st->time_base.den, AV_TIME_BASE*(int64_t)st->time_base.num);
969 av_add_index_entry(st, st->parser->frame_offset, dts,
3e9245a9 970 0, AVINDEX_KEYFRAME);
fb2758c8
FB
971 }
972 av_free_packet(pkt);
973 }
974}
975
976/* return TRUE if we deal with a raw stream (raw codec data and
977 parsing needed) */
978static int is_raw_stream(AVFormatContext *s)
979{
980 AVStream *st;
981
982 if (s->nb_streams != 1)
983 return 0;
984 st = s->streams[0];
985 if (!st->need_parsing)
986 return 0;
987 return 1;
988}
989
3ba1438d
MN
990/**
991 * gets the index for a specific timestamp.
992 * @param backward if non zero then the returned index will correspond to
993 * the timestamp which is <= the requested one, if backward is 0
994 * then it will be >=
995 * @return < 0 if no such timestamp could be found
996 */
997int av_index_search_timestamp(AVStream *st, int wanted_timestamp, int backward)
fb2758c8 998{
b754978a
MN
999 AVIndexEntry *entries= st->index_entries;
1000 int nb_entries= st->nb_index_entries;
fb2758c8
FB
1001 int a, b, m;
1002 int64_t timestamp;
1003
3ba1438d
MN
1004 a = - 1;
1005 b = nb_entries;
b754978a 1006
3ba1438d
MN
1007 while (b - a > 1) {
1008 m = (a + b) >> 1;
fb2758c8 1009 timestamp = entries[m].timestamp;
3ba1438d
MN
1010 if(timestamp >= wanted_timestamp)
1011 b = m;
1012 if(timestamp <= wanted_timestamp)
b754978a 1013 a = m;
fb2758c8 1014 }
3ba1438d
MN
1015 m= backward ? a : b;
1016
1017 if(m == nb_entries)
1018 return -1;
1019 return m;
fb2758c8
FB
1020}
1021
8d14a25c
MN
1022#define DEBUG_SEEK
1023
cdd5034f
MN
1024/**
1025 * Does a binary search using av_index_search_timestamp() and AVCodec.read_timestamp().
1026 * this isnt supposed to be called directly by a user application, but by demuxers
1027 * @param target_ts target timestamp in the time base of the given stream
1028 * @param stream_index stream number
1029 */
3ba1438d 1030int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
8d14a25c
MN
1031 AVInputFormat *avif= s->iformat;
1032 int64_t pos_min, pos_max, pos, pos_limit;
1033 int64_t ts_min, ts_max, ts;
1034 int64_t start_pos;
8bcb147f 1035 int index, no_change;
8d14a25c
MN
1036 AVStream *st;
1037
cdd5034f
MN
1038 if (stream_index < 0)
1039 return -1;
1040
8d14a25c
MN
1041#ifdef DEBUG_SEEK
1042 av_log(s, AV_LOG_DEBUG, "read_seek: %d %lld\n", stream_index, target_ts);
1043#endif
1044
1045 ts_max=
1046 ts_min= AV_NOPTS_VALUE;
1047 pos_limit= -1; //gcc falsely says it may be uninitalized
1048
1049 st= s->streams[stream_index];
1050 if(st->index_entries){
1051 AVIndexEntry *e;
1052
3ba1438d
MN
1053 index= av_index_search_timestamp(st, target_ts, 1);
1054 index= FFMAX(index, 0);
8d14a25c
MN
1055 e= &st->index_entries[index];
1056
1057 if(e->timestamp <= target_ts || e->pos == e->min_distance){
1058 pos_min= e->pos;
1059 ts_min= e->timestamp;
1060#ifdef DEBUG_SEEK
a6a92a9a 1061 av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%llx dts_min=%lld\n",
8d14a25c
MN
1062 pos_min,ts_min);
1063#endif
1064 }else{
1065 assert(index==0);
1066 }
1067 index++;
1068 if(index < st->nb_index_entries){
1069 e= &st->index_entries[index];
1070 assert(e->timestamp >= target_ts);
1071 pos_max= e->pos;
1072 ts_max= e->timestamp;
1073 pos_limit= pos_max - e->min_distance;
1074#ifdef DEBUG_SEEK
a6a92a9a 1075 av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%llx pos_limit=0x%llx dts_max=%lld\n",
8d14a25c
MN
1076 pos_max,pos_limit, ts_max);
1077#endif
1078 }
1079 }
1080
1081 if(ts_min == AV_NOPTS_VALUE){
1082 pos_min = s->data_offset;
1083 ts_min = avif->read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1084 if (ts_min == AV_NOPTS_VALUE)
1085 return -1;
1086 }
1087
1088 if(ts_max == AV_NOPTS_VALUE){
1089 int step= 1024;
1090 pos_max = url_filesize(url_fileno(&s->pb)) - 1;
1091 do{
1092 pos_max -= step;
1093 ts_max = avif->read_timestamp(s, stream_index, &pos_max, pos_max + step);
1094 step += step;
1095 }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1096 if (ts_max == AV_NOPTS_VALUE)
1097 return -1;
1098
1099 for(;;){
1100 int64_t tmp_pos= pos_max + 1;
1101 int64_t tmp_ts= avif->read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1102 if(tmp_ts == AV_NOPTS_VALUE)
1103 break;
1104 ts_max= tmp_ts;
1105 pos_max= tmp_pos;
1106 }
1107 pos_limit= pos_max;
1108 }
1109
1110 no_change=0;
1111 while (pos_min < pos_limit) {
1112#ifdef DEBUG_SEEK
1113 av_log(s, AV_LOG_DEBUG, "pos_min=0x%llx pos_max=0x%llx dts_min=%lld dts_max=%lld\n",
1114 pos_min, pos_max,
1115 ts_min, ts_max);
1116#endif
1117 assert(pos_limit <= pos_max);
1118
1119 if(no_change==0){
1120 int64_t approximate_keyframe_distance= pos_max - pos_limit;
1121 // interpolate position (better than dichotomy)
3ba1438d
MN
1122 pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1123 + pos_min - approximate_keyframe_distance;
8d14a25c
MN
1124 }else if(no_change==1){
1125 // bisection, if interpolation failed to change min or max pos last time
1126 pos = (pos_min + pos_limit)>>1;
1127 }else{
1128 // linear search if bisection failed, can only happen if there are very few or no keframes between min/max
1129 pos=pos_min;
1130 }
1131 if(pos <= pos_min)
1132 pos= pos_min + 1;
1133 else if(pos > pos_limit)
1134 pos= pos_limit;
1135 start_pos= pos;
1136
1137 ts = avif->read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1138 if(pos == pos_max)
1139 no_change++;
1140 else
1141 no_change=0;
1142#ifdef DEBUG_SEEK
1143av_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);
1144#endif
1145 assert(ts != AV_NOPTS_VALUE);
3ba1438d 1146 if (target_ts <= ts) {
8d14a25c
MN
1147 pos_limit = start_pos - 1;
1148 pos_max = pos;
1149 ts_max = ts;
3ba1438d
MN
1150 }
1151 if (target_ts >= ts) {
8d14a25c
MN
1152 pos_min = pos;
1153 ts_min = ts;
8d14a25c
MN
1154 }
1155 }
1156
3ba1438d
MN
1157 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1158 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
8d14a25c
MN
1159#ifdef DEBUG_SEEK
1160 pos_min = pos;
1161 ts_min = avif->read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1162 pos_min++;
1163 ts_max = avif->read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1164 av_log(s, AV_LOG_DEBUG, "pos=0x%llx %lld<=%lld<=%lld\n",
1165 pos, ts_min, target_ts, ts_max);
1166#endif
1167 /* do the seek */
1168 url_fseek(&s->pb, pos, SEEK_SET);
cdd5034f 1169
8bcb147f 1170 av_update_cur_dts(s, st, ts);
8d14a25c
MN
1171
1172 return 0;
1173}
1174
3ba1438d
MN
1175static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1176 AVInputFormat *avif= s->iformat;
1177 int64_t pos_min, pos_max;
1178#if 0
1179 AVStream *st;
1180
1181 if (stream_index < 0)
1182 return -1;
1183
1184 st= s->streams[stream_index];
1185#endif
1186
1187 pos_min = s->data_offset;
1188 pos_max = url_filesize(url_fileno(&s->pb)) - 1;
1189
1190 if (pos < pos_min) pos= pos_min;
1191 else if(pos > pos_max) pos= pos_max;
1192
1193 url_fseek(&s->pb, pos, SEEK_SET);
1194
1195#if 0
8bcb147f 1196 av_update_cur_dts(s, st, ts);
3ba1438d
MN
1197#endif
1198 return 0;
1199}
1200
fb2758c8 1201static int av_seek_frame_generic(AVFormatContext *s,
3ba1438d 1202 int stream_index, int64_t timestamp, int flags)
fb2758c8 1203{
8bcb147f 1204 int index;
fb2758c8
FB
1205 AVStream *st;
1206 AVIndexEntry *ie;
1207
1208 if (!s->index_built) {
1209 if (is_raw_stream(s)) {
1210 av_build_index_raw(s);
1211 } else {
1212 return -1;
1213 }
1214 s->index_built = 1;
1215 }
1216
fb2758c8 1217 st = s->streams[stream_index];
3ba1438d 1218 index = av_index_search_timestamp(st, timestamp, flags & AVSEEK_FLAG_BACKWARD);
fb2758c8
FB
1219 if (index < 0)
1220 return -1;
1221
1222 /* now we have found the index, we can seek */
1223 ie = &st->index_entries[index];
1224 av_read_frame_flush(s);
1225 url_fseek(&s->pb, ie->pos, SEEK_SET);
3ba1438d 1226
8bcb147f 1227 av_update_cur_dts(s, st, ie->timestamp);
cdd5034f 1228
fb2758c8
FB
1229 return 0;
1230}
1231
1232/**
3ba1438d 1233 * Seek to the key frame at timestamp.
cdd5034f
MN
1234 * 'timestamp' in 'stream_index'.
1235 * @param stream_index If stream_index is (-1), a default
eb497825
NK
1236 * stream is selected, and timestamp is automatically converted
1237 * from AV_TIME_BASE units to the stream specific time_base.
3ba1438d
MN
1238 * @param timestamp timestamp in AVStream.time_base units
1239 * @param flags flags which select direction and seeking mode
cdd5034f 1240 * @return >= 0 on success
fb2758c8 1241 */
3ba1438d 1242int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
fb2758c8
FB
1243{
1244 int ret;
cdd5034f 1245 AVStream *st;
fb2758c8
FB
1246
1247 av_read_frame_flush(s);
cdd5034f 1248
3ba1438d
MN
1249 if(flags & AVSEEK_FLAG_BYTE)
1250 return av_seek_frame_byte(s, stream_index, timestamp, flags);
1251
cdd5034f
MN
1252 if(stream_index < 0){
1253 stream_index= av_find_default_stream_index(s);
1254 if(stream_index < 0)
1255 return -1;
3ba1438d
MN
1256
1257 st= s->streams[stream_index];
eb497825 1258 /* timestamp for default must be expressed in AV_TIME_BASE units */
3ba1438d 1259 timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
cdd5034f
MN
1260 }
1261 st= s->streams[stream_index];
1262
fb2758c8
FB
1263 /* first, we try the format specific seek */
1264 if (s->iformat->read_seek)
3ba1438d 1265 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
fb2758c8
FB
1266 else
1267 ret = -1;
1268 if (ret >= 0) {
1269 return 0;
1270 }
8d14a25c
MN
1271
1272 if(s->iformat->read_timestamp)
3ba1438d 1273 return av_seek_frame_binary(s, stream_index, timestamp, flags);
8d14a25c 1274 else
3ba1438d 1275 return av_seek_frame_generic(s, stream_index, timestamp, flags);
fb2758c8
FB
1276}
1277
1278/*******************************************************/
12f996ed
FB
1279
1280/* return TRUE if the stream has accurate timings for at least one component */
1281static int av_has_timings(AVFormatContext *ic)
1282{
1283 int i;
1284 AVStream *st;
1285
1286 for(i = 0;i < ic->nb_streams; i++) {
1287 st = ic->streams[i];
1288 if (st->start_time != AV_NOPTS_VALUE &&
1289 st->duration != AV_NOPTS_VALUE)
1290 return 1;
1291 }
1292 return 0;
1293}
1294
1295/* estimate the stream timings from the one of each components. Also
1296 compute the global bitrate if possible */
1297static void av_update_stream_timings(AVFormatContext *ic)
1298{
1299 int64_t start_time, end_time, end_time1;
1300 int i;
1301 AVStream *st;
1302
1303 start_time = MAXINT64;
1304 end_time = MININT64;
1305 for(i = 0;i < ic->nb_streams; i++) {
1306 st = ic->streams[i];
1307 if (st->start_time != AV_NOPTS_VALUE) {
1308 if (st->start_time < start_time)
1309 start_time = st->start_time;
1310 if (st->duration != AV_NOPTS_VALUE) {
1311 end_time1 = st->start_time + st->duration;
1312 if (end_time1 > end_time)
1313 end_time = end_time1;
1314 }
1315 }
1316 }
1317 if (start_time != MAXINT64) {
1318 ic->start_time = start_time;
1319 if (end_time != MAXINT64) {
1320 ic->duration = end_time - start_time;
1321 if (ic->file_size > 0) {
1322 /* compute the bit rate */
1323 ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1324 (double)ic->duration;
1325 }
1326 }
1327 }
1328
1329}
1330
1331static void fill_all_stream_timings(AVFormatContext *ic)
1332{
1333 int i;
1334 AVStream *st;
1335
1336 av_update_stream_timings(ic);
1337 for(i = 0;i < ic->nb_streams; i++) {
1338 st = ic->streams[i];
1339 if (st->start_time == AV_NOPTS_VALUE) {
1340 st->start_time = ic->start_time;
1341 st->duration = ic->duration;
1342 }
1343 }
1344}
1345
1346static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1347{
1348 int64_t filesize, duration;
1349 int bit_rate, i;
1350 AVStream *st;
1351
1352 /* if bit_rate is already set, we believe it */
1353 if (ic->bit_rate == 0) {
1354 bit_rate = 0;
1355 for(i=0;i<ic->nb_streams;i++) {
1356 st = ic->streams[i];
1357 bit_rate += st->codec.bit_rate;
1358 }
1359 ic->bit_rate = bit_rate;
1360 }
1361
1362 /* if duration is already set, we believe it */
1363 if (ic->duration == AV_NOPTS_VALUE &&
1364 ic->bit_rate != 0 &&
1365 ic->file_size != 0) {
1366 filesize = ic->file_size;
1367 if (filesize > 0) {
1368 duration = (int64_t)((8 * AV_TIME_BASE * (double)filesize) / (double)ic->bit_rate);
1369 for(i = 0; i < ic->nb_streams; i++) {
1370 st = ic->streams[i];
1371 if (st->start_time == AV_NOPTS_VALUE ||
1372 st->duration == AV_NOPTS_VALUE) {
1373 st->start_time = 0;
1374 st->duration = duration;
1375 }
1376 }
1377 }
1378 }
1379}
1380
12f996ed
FB
1381#define DURATION_MAX_READ_SIZE 250000
1382
1383/* only usable for MPEG-PS streams */
1384static void av_estimate_timings_from_pts(AVFormatContext *ic)
1385{
1386 AVPacket pkt1, *pkt = &pkt1;
1387 AVStream *st;
1388 int read_size, i, ret;
1389 int64_t start_time, end_time, end_time1;
1390 int64_t filesize, offset, duration;
1391
fb2758c8
FB
1392 /* free previous packet */
1393 if (ic->cur_st && ic->cur_st->parser)
1394 av_free_packet(&ic->cur_pkt);
1395 ic->cur_st = NULL;
1396
1397 /* flush packet queue */
1398 flush_packet_queue(ic);
fb2758c8 1399
0ff7199f
MN
1400 for(i=0;i<ic->nb_streams;i++) {
1401 st = ic->streams[i];
1402 if (st->parser) {
1403 av_parser_close(st->parser);
1404 st->parser= NULL;
1405 }
1406 }
1407
12f996ed
FB
1408 /* we read the first packets to get the first PTS (not fully
1409 accurate, but it is enough now) */
1410 url_fseek(&ic->pb, 0, SEEK_SET);
1411 read_size = 0;
1412 for(;;) {
1413 if (read_size >= DURATION_MAX_READ_SIZE)
1414 break;
1415 /* if all info is available, we can stop */
1416 for(i = 0;i < ic->nb_streams; i++) {
1417 st = ic->streams[i];
1418 if (st->start_time == AV_NOPTS_VALUE)
1419 break;
1420 }
1421 if (i == ic->nb_streams)
1422 break;
1423
1424 ret = av_read_packet(ic, pkt);
1425 if (ret != 0)
1426 break;
1427 read_size += pkt->size;
1428 st = ic->streams[pkt->stream_index];
1429 if (pkt->pts != AV_NOPTS_VALUE) {
1430 if (st->start_time == AV_NOPTS_VALUE)
9ee91c2f 1431 st->start_time = av_rescale(pkt->pts, st->time_base.num * (int64_t)AV_TIME_BASE, st->time_base.den);
0a5f92a1
MN
1432 }
1433 av_free_packet(pkt);
1434 }
12f996ed
FB
1435
1436 /* we compute the minimum start_time and use it as default */
1437 start_time = MAXINT64;
1438 for(i = 0; i < ic->nb_streams; i++) {
1439 st = ic->streams[i];
1440 if (st->start_time != AV_NOPTS_VALUE &&
1441 st->start_time < start_time)
1442 start_time = st->start_time;
1443 }
12f996ed
FB
1444 if (start_time != MAXINT64)
1445 ic->start_time = start_time;
1446
1447 /* estimate the end time (duration) */
1448 /* XXX: may need to support wrapping */
1449 filesize = ic->file_size;
1450 offset = filesize - DURATION_MAX_READ_SIZE;
1451 if (offset < 0)
1452 offset = 0;
1453
12f996ed
FB
1454 url_fseek(&ic->pb, offset, SEEK_SET);
1455 read_size = 0;
1456 for(;;) {
1457 if (read_size >= DURATION_MAX_READ_SIZE)
1458 break;
1459 /* if all info is available, we can stop */
1460 for(i = 0;i < ic->nb_streams; i++) {
1461 st = ic->streams[i];
1462 if (st->duration == AV_NOPTS_VALUE)
1463 break;
1464 }
1465 if (i == ic->nb_streams)
1466 break;
1467
1468 ret = av_read_packet(ic, pkt);
1469 if (ret != 0)
1470 break;
1471 read_size += pkt->size;
1472 st = ic->streams[pkt->stream_index];
1473 if (pkt->pts != AV_NOPTS_VALUE) {
9ee91c2f 1474 end_time = av_rescale(pkt->pts, st->time_base.num * (int64_t)AV_TIME_BASE, st->time_base.den);
12f996ed
FB
1475 duration = end_time - st->start_time;
1476 if (duration > 0) {
1477 if (st->duration == AV_NOPTS_VALUE ||
1478 st->duration < duration)
1479 st->duration = duration;
1480 }
1481 }
1482 av_free_packet(pkt);
1483 }
1484
1485 /* estimate total duration */
1486 end_time = MININT64;
1487 for(i = 0;i < ic->nb_streams; i++) {
1488 st = ic->streams[i];
1489 if (st->duration != AV_NOPTS_VALUE) {
1490 end_time1 = st->start_time + st->duration;
1491 if (end_time1 > end_time)
1492 end_time = end_time1;
1493 }
1494 }
1495
1496 /* update start_time (new stream may have been created, so we do
1497 it at the end */
1498 if (ic->start_time != AV_NOPTS_VALUE) {
1499 for(i = 0; i < ic->nb_streams; i++) {
1500 st = ic->streams[i];
1501 if (st->start_time == AV_NOPTS_VALUE)
1502 st->start_time = ic->start_time;
1503 }
1504 }
1505
1506 if (end_time != MININT64) {
1507 /* put dummy values for duration if needed */
1508 for(i = 0;i < ic->nb_streams; i++) {
1509 st = ic->streams[i];
1510 if (st->duration == AV_NOPTS_VALUE &&
1511 st->start_time != AV_NOPTS_VALUE)
1512 st->duration = end_time - st->start_time;
1513 }
1514 ic->duration = end_time - ic->start_time;
1515 }
1516
1517 url_fseek(&ic->pb, 0, SEEK_SET);
1518}
1519
1520static void av_estimate_timings(AVFormatContext *ic)
1521{
1522 URLContext *h;
1523 int64_t file_size;
1524
1525 /* get the file size, if possible */
1526 if (ic->iformat->flags & AVFMT_NOFILE) {
1527 file_size = 0;
1528 } else {
1529 h = url_fileno(&ic->pb);
1530 file_size = url_filesize(h);
1531 if (file_size < 0)
1532 file_size = 0;
1533 }
1534 ic->file_size = file_size;
1535
1536 if (ic->iformat == &mpegps_demux) {
1537 /* get accurate estimate from the PTSes */
1538 av_estimate_timings_from_pts(ic);
1539 } else if (av_has_timings(ic)) {
1540 /* at least one components has timings - we use them for all
1541 the components */
1542 fill_all_stream_timings(ic);
1543 } else {
1544 /* less precise: use bit rate info */
1545 av_estimate_timings_from_bit_rate(ic);
1546 }
1547 av_update_stream_timings(ic);
1548
1549#if 0
1550 {
1551 int i;
1552 AVStream *st;
1553 for(i = 0;i < ic->nb_streams; i++) {
1554 st = ic->streams[i];
1555 printf("%d: start_time: %0.3f duration: %0.3f\n",
1556 i, (double)st->start_time / AV_TIME_BASE,
1557 (double)st->duration / AV_TIME_BASE);
1558 }
1559 printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1560 (double)ic->start_time / AV_TIME_BASE,
1561 (double)ic->duration / AV_TIME_BASE,
1562 ic->bit_rate / 1000);
1563 }
1564#endif
1565}
1566
b9a281db
FB
1567static int has_codec_parameters(AVCodecContext *enc)
1568{
1569 int val;
1570 switch(enc->codec_type) {
1571 case CODEC_TYPE_AUDIO:
1572 val = enc->sample_rate;
1573 break;
1574 case CODEC_TYPE_VIDEO:
1575 val = enc->width;
1576 break;
1577 default:
1578 val = 1;
1579 break;
1580 }
1581 return (val != 0);
1582}
1583
fb2758c8
FB
1584static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1585{
1586 int16_t *samples;
1587 AVCodec *codec;
1588 int got_picture, ret;
1589 AVFrame picture;
1590
1591 codec = avcodec_find_decoder(st->codec.codec_id);
1592 if (!codec)
1593 return -1;
1594 ret = avcodec_open(&st->codec, codec);
1595 if (ret < 0)
1596 return ret;
1597 switch(st->codec.codec_type) {
1598 case CODEC_TYPE_VIDEO:
1599 ret = avcodec_decode_video(&st->codec, &picture,
1600 &got_picture, (uint8_t *)data, size);
1601 break;
1602 case CODEC_TYPE_AUDIO:
1603 samples = av_malloc(AVCODEC_MAX_AUDIO_FRAME_SIZE);
1604 if (!samples)
1605 goto fail;
1606 ret = avcodec_decode_audio(&st->codec, samples,
1607 &got_picture, (uint8_t *)data, size);
1608 av_free(samples);
1609 break;
1610 default:
1611 break;
1612 }
1613 fail:
1614 avcodec_close(&st->codec);
1615 return ret;
1616}
1617
1618/* absolute maximum size we read until we abort */
1619#define MAX_READ_SIZE 5000000
1620
1621/* maximum duration until we stop analysing the stream */
1622#define MAX_STREAM_DURATION ((int)(AV_TIME_BASE * 1.0))
1623
b9a281db
FB
1624/**
1625 * Read the beginning of a media file to get stream information. This
1626 * is useful for file formats with no headers such as MPEG. This
1627 * function also compute the real frame rate in case of mpeg2 repeat
1628 * frame mode.
1629 *
1630 * @param ic media file handle
1631 * @return >=0 if OK. AVERROR_xxx if error.
1632 */
1633int av_find_stream_info(AVFormatContext *ic)
1634{
fb2758c8 1635 int i, count, ret, read_size;
b9a281db 1636 AVStream *st;
fb2758c8 1637 AVPacket pkt1, *pkt;
b9a281db 1638 AVPacketList *pktl=NULL, **ppktl;
b9a281db
FB
1639
1640 count = 0;
1641 read_size = 0;
1642 ppktl = &ic->packet_buffer;
1643 for(;;) {
1644 /* check if one codec still needs to be handled */
1645 for(i=0;i<ic->nb_streams;i++) {
1646 st = ic->streams[i];
fb2758c8 1647 if (!has_codec_parameters(&st->codec))
b9a281db
FB
1648 break;
1649 }
1650 if (i == ic->nb_streams) {
1651 /* NOTE: if the format has no header, then we need to read
1652 some packets to get most of the streams, so we cannot
1653 stop here */
fb2758c8 1654 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
b9a281db
FB
1655 /* if we found the info for all the codecs, we can stop */
1656 ret = count;
1657 break;
1658 }
1659 } else {
1660 /* we did not get all the codec info, but we read too much data */
fb2758c8 1661 if (read_size >= MAX_READ_SIZE) {
b9a281db
FB
1662 ret = count;
1663 break;
1664 }
1665 }
1666
fb2758c8
FB
1667 /* NOTE: a new stream can be added there if no header in file
1668 (AVFMTCTX_NOHEADER) */
1669 ret = av_read_frame_internal(ic, &pkt1);
1670 if (ret < 0) {
1671 /* EOF or error */
1672 ret = -1; /* we could not have all the codec parameters before EOF */
1673 if ((ic->ctx_flags & AVFMTCTX_NOHEADER) &&
1674 i == ic->nb_streams)
1675 ret = 0;
1676 break;
1677 }
1678
b9a281db
FB
1679 pktl = av_mallocz(sizeof(AVPacketList));
1680 if (!pktl) {
1681 ret = AVERROR_NOMEM;
1682 break;
1683 }
1684
1685 /* add the packet in the buffered packet list */
1686 *ppktl = pktl;
1687 ppktl = &pktl->next;
1688
b9a281db 1689 pkt = &pktl->pkt;
fb2758c8
FB
1690 *pkt = pkt1;
1691
1692 /* duplicate the packet */
1693 if (av_dup_packet(pkt) < 0) {
1694 ret = AVERROR_NOMEM;
1695 break;
b9a281db 1696 }
b9a281db 1697
fb2758c8 1698 read_size += pkt->size;
b9a281db
FB
1699
1700 st = ic->streams[pkt->stream_index];
fb2758c8
FB
1701 st->codec_info_duration += pkt->duration;
1702 if (pkt->duration != 0)
1703 st->codec_info_nb_frames++;
1704
1705 /* if still no information, we try to open the codec and to
1706 decompress the frame. We try to avoid that in most cases as
1707 it takes longer and uses more memory. For MPEG4, we need to
1708 decompress for Quicktime. */
1709 if (!has_codec_parameters(&st->codec) &&
1710 (st->codec.codec_id == CODEC_ID_FLV1 ||
1711 st->codec.codec_id == CODEC_ID_H264 ||
1712 st->codec.codec_id == CODEC_ID_H263 ||
8bfed902 1713 st->codec.codec_id == CODEC_ID_VORBIS ||
03cfe134 1714 st->codec.codec_id == CODEC_ID_MJPEG ||
fb2758c8
FB
1715 (st->codec.codec_id == CODEC_ID_MPEG4 && !st->need_parsing)))
1716 try_decode_frame(st, pkt->data, pkt->size);
1717
1718 if (st->codec_info_duration >= MAX_STREAM_DURATION) {
1719 break;
b9a281db
FB
1720 }
1721 count++;
1722 }
1723
b9a281db
FB
1724 /* set real frame rate info */
1725 for(i=0;i<ic->nb_streams;i++) {
1726 st = ic->streams[i];
1727 if (st->codec.codec_type == CODEC_TYPE_VIDEO) {
fb2758c8
FB
1728 /* compute the real frame rate for telecine */
1729 if ((st->codec.codec_id == CODEC_ID_MPEG1VIDEO ||
1730 st->codec.codec_id == CODEC_ID_MPEG2VIDEO) &&
1731 st->codec.sub_id == 2) {
1732 if (st->codec_info_nb_frames >= 20) {
1733 float coded_frame_rate, est_frame_rate;
1734 est_frame_rate = ((double)st->codec_info_nb_frames * AV_TIME_BASE) /
1735 (double)st->codec_info_duration ;
1736 coded_frame_rate = (double)st->codec.frame_rate /
1737 (double)st->codec.frame_rate_base;
1738#if 0
1739 printf("telecine: coded_frame_rate=%0.3f est_frame_rate=%0.3f\n",
1740 coded_frame_rate, est_frame_rate);
1741#endif
1742 /* if we detect that it could be a telecine, we
1743 signal it. It would be better to do it at a
1744 higher level as it can change in a film */
1745 if (coded_frame_rate >= 24.97 &&
1746 (est_frame_rate >= 23.5 && est_frame_rate < 24.5)) {
1747 st->r_frame_rate = 24024;
1748 st->r_frame_rate_base = 1001;
1749 }
1750 }
1751 }
1752 /* if no real frame rate, use the codec one */
14bea432
MN
1753 if (!st->r_frame_rate){
1754 st->r_frame_rate = st->codec.frame_rate;
1755 st->r_frame_rate_base = st->codec.frame_rate_base;
1756 }
b9a281db 1757 }
de6d9b64 1758 }
b9a281db 1759
12f996ed 1760 av_estimate_timings(ic);
e928649b
MN
1761#if 0
1762 /* correct DTS for b frame streams with no timestamps */
1763 for(i=0;i<ic->nb_streams;i++) {
1764 st = ic->streams[i];
1765 if (st->codec.codec_type == CODEC_TYPE_VIDEO) {
1766 if(b-frames){
1767 ppktl = &ic->packet_buffer;
1768 while(ppkt1){
1769 if(ppkt1->stream_index != i)
1770 continue;
1771 if(ppkt1->pkt->dts < 0)
1772 break;
1773 if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
1774 break;
1775 ppkt1->pkt->dts -= delta;
1776 ppkt1= ppkt1->next;
1777 }
1778 if(ppkt1)
1779 continue;
1780 st->cur_dts -= delta;
1781 }
1782 }
1783 }
1784#endif
b9a281db 1785 return ret;
de6d9b64
FB
1786}
1787
fb2758c8
FB
1788/*******************************************************/
1789
1790/**
1791 * start playing a network based stream (e.g. RTSP stream) at the
1792 * current position
1793 */
1794int av_read_play(AVFormatContext *s)
1795{
1796 if (!s->iformat->read_play)
1797 return AVERROR_NOTSUPP;
1798 return s->iformat->read_play(s);
1799}
1800
1801/**
1802 * pause a network based stream (e.g. RTSP stream). Use av_read_play()
1803 * to resume it.
1804 */
1805int av_read_pause(AVFormatContext *s)
1806{
1807 if (!s->iformat->read_pause)
1808 return AVERROR_NOTSUPP;
1809 return s->iformat->read_pause(s);
1810}
1811
b9a281db
FB
1812/**
1813 * Close a media file (but not its codecs)
1814 *
1815 * @param s media file handle
1816 */
de6d9b64
FB
1817void av_close_input_file(AVFormatContext *s)
1818{
b6892136 1819 int i, must_open_file;
da24c5e3 1820 AVStream *st;
de6d9b64 1821
fb2758c8
FB
1822 /* free previous packet */
1823 if (s->cur_st && s->cur_st->parser)
1824 av_free_packet(&s->cur_pkt);
1825
b9a281db
FB
1826 if (s->iformat->read_close)
1827 s->iformat->read_close(s);
de6d9b64 1828 for(i=0;i<s->nb_streams;i++) {
da24c5e3
FB
1829 /* free all data in a stream component */
1830 st = s->streams[i];
fb2758c8
FB
1831 if (st->parser) {
1832 av_parser_close(st->parser);
de6d9b64 1833 }
fb2758c8
FB
1834 av_free(st->index_entries);
1835 av_free(st);
de6d9b64 1836 }
fb2758c8 1837 flush_packet_queue(s);
b6892136 1838 must_open_file = 1;
da24c5e3 1839 if (s->iformat->flags & AVFMT_NOFILE) {
b6892136
FB
1840 must_open_file = 0;
1841 }
1842 if (must_open_file) {
96baaa6a
FB
1843 url_fclose(&s->pb);
1844 }
a8dbe951 1845 av_freep(&s->priv_data);
1ea4f593 1846 av_free(s);
de6d9b64
FB
1847}
1848
b9a281db
FB
1849/**
1850 * Add a new stream to a media file. Can only be called in the
da24c5e3
FB
1851 * read_header function. If the flag AVFMTCTX_NOHEADER is in the
1852 * format context, then new streams can be added in read_packet too.
b9a281db
FB
1853 *
1854 *
1855 * @param s media file handle
da24c5e3 1856 * @param id file format dependent stream id
b9a281db
FB
1857 */
1858AVStream *av_new_stream(AVFormatContext *s, int id)
1859{
1860 AVStream *st;
1861
1862 if (s->nb_streams >= MAX_STREAMS)
1863 return NULL;
1864
1865 st = av_mallocz(sizeof(AVStream));
1866 if (!st)
1867 return NULL;
1e491e29 1868 avcodec_get_context_defaults(&st->codec);
48091512
FB
1869 if (s->iformat) {
1870 /* no default bitrate if decoding */
1871 st->codec.bit_rate = 0;
1872 }
b9a281db
FB
1873 st->index = s->nb_streams;
1874 st->id = id;
12f996ed
FB
1875 st->start_time = AV_NOPTS_VALUE;
1876 st->duration = AV_NOPTS_VALUE;
e928649b 1877 st->cur_dts = AV_NOPTS_VALUE;
9ee91c2f
MN
1878
1879 /* default pts settings is MPEG like */
1880 av_set_pts_info(st, 33, 1, 90000);
77405fc8 1881 st->last_IP_pts = AV_NOPTS_VALUE;
9ee91c2f 1882
b9a281db
FB
1883 s->streams[s->nb_streams++] = st;
1884 return st;
1885}
1886
1887/************************************************************/
1888/* output media file */
de6d9b64 1889
87a0a681
FB
1890int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
1891{
1892 int ret;
98486a6b
RS
1893
1894 if (s->oformat->priv_data_size > 0) {
1895 s->priv_data = av_mallocz(s->oformat->priv_data_size);
1896 if (!s->priv_data)
1897 return AVERROR_NOMEM;
1898 } else
1899 s->priv_data = NULL;
1900
87a0a681
FB
1901 if (s->oformat->set_parameters) {
1902 ret = s->oformat->set_parameters(s, ap);
1903 if (ret < 0)
1904 return ret;
1905 }
1906 return 0;
1907}
1908
b9a281db
FB
1909/**
1910 * allocate the stream private data and write the stream header to an
1911 * output media file
1912 *
1913 * @param s media file handle
1914 * @return 0 if OK. AVERROR_xxx if error.
1915 */
1916int av_write_header(AVFormatContext *s)
1917{
1e51d801
FB
1918 int ret, i;
1919 AVStream *st;
1920
1e51d801
FB
1921 ret = s->oformat->write_header(s);
1922 if (ret < 0)
1923 return ret;
1924
1925 /* init PTS generation */
1926 for(i=0;i<s->nb_streams;i++) {
1927 st = s->streams[i];
1928
1929 switch (st->codec.codec_type) {
1930 case CODEC_TYPE_AUDIO:
1931 av_frac_init(&st->pts, 0, 0,
9ee91c2f 1932 (int64_t)st->time_base.num * st->codec.sample_rate);
1e51d801
FB
1933 break;
1934 case CODEC_TYPE_VIDEO:
1935 av_frac_init(&st->pts, 0, 0,
9ee91c2f 1936 (int64_t)st->time_base.num * st->codec.frame_rate);
1e51d801
FB
1937 break;
1938 default:
1939 break;
1940 }
1941 }
1942 return 0;
b9a281db
FB
1943}
1944
3c895fc0
MN
1945//FIXME merge with compute_pkt_fields
1946static void compute_pkt_fields2(AVStream *st, AVPacket *pkt){
1947 int b_frames = FFMAX(st->codec.has_b_frames, st->codec.max_b_frames);
1948 int num, den, frame_size;
b0c7f5a9 1949
3c895fc0 1950// 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
1951
1952/* if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
1953 return -1;*/
1954
1955 if(pkt->pts != AV_NOPTS_VALUE)
1956 pkt->pts = av_rescale(pkt->pts, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1957 if(pkt->dts != AV_NOPTS_VALUE)
1958 pkt->dts = av_rescale(pkt->dts, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1959
1960 /* duration field */
1961 pkt->duration = av_rescale(pkt->duration, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
3c895fc0
MN
1962 if (pkt->duration == 0) {
1963 compute_frame_duration(&num, &den, st, NULL, pkt);
1964 if (den && num) {
1965 pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
1966 }
1967 }
e928649b
MN
1968
1969 //XXX/FIXME this is a temporary hack until all encoders output pts
1970 if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !b_frames){
1971 pkt->dts=
1972// pkt->pts= st->cur_dts;
1973 pkt->pts= st->pts.val;
1974 }
1975
1976 //calculate dts from pts
1977 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE){
1978 if(b_frames){
1979 if(st->last_IP_pts == AV_NOPTS_VALUE){
3c895fc0 1980 st->last_IP_pts= -pkt->duration;
e928649b
MN
1981 }
1982 if(st->last_IP_pts < pkt->pts){
1983 pkt->dts= st->last_IP_pts;
1984 st->last_IP_pts= pkt->pts;
1985 }else
1986 pkt->dts= pkt->pts;
1987 }else
1988 pkt->dts= pkt->pts;
1989 }
1990
3c895fc0 1991// av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%lld dts2:%lld\n", pkt->pts, pkt->dts);
e928649b
MN
1992 st->cur_dts= pkt->dts;
1993 st->pts.val= pkt->dts;
1994
1e51d801
FB
1995 /* update pts */
1996 switch (st->codec.codec_type) {
1997 case CODEC_TYPE_AUDIO:
e928649b 1998 frame_size = get_audio_frame_size(&st->codec, pkt->size);
6d8f985e 1999
b0c7f5a9 2000 /* HACK/FIXME, we skip the initial 0-size packets as they are most likely equal to the encoder delay,
6d8f985e 2001 but it would be better if we had the real timestamps from the encoder */
e928649b 2002 if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
9ee91c2f 2003 av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
7feb950a 2004 }
1e51d801
FB
2005 break;
2006 case CODEC_TYPE_VIDEO:
9ee91c2f 2007 av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec.frame_rate_base);
1e51d801
FB
2008 break;
2009 default:
2010 break;
2011 }
3c895fc0
MN
2012}
2013
2014static void truncate_ts(AVStream *st, AVPacket *pkt){
2015 int64_t pts_mask = (2LL << (st->pts_wrap_bits-1)) - 1;
2016
e0c91bc2
MN
2017// if(pkt->dts < 0)
2018// pkt->dts= 0; //this happens for low_delay=0 and b frames, FIXME, needs further invstigation about what we should do here
3c895fc0
MN
2019
2020 pkt->pts &= pts_mask;
2021 pkt->dts &= pts_mask;
2022}
2023
2024/**
2025 * Write a packet to an output media file. The packet shall contain
2026 * one audio or video frame.
2027 *
2028 * @param s media file handle
2029 * @param pkt the packet, which contains the stream_index, buf/buf_size, dts/pts, ...
2030 * @return < 0 if error, = 0 if OK, 1 if end of stream wanted.
2031 */
2032int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2033{
576ae256
MN
2034 int ret;
2035
3c895fc0
MN
2036 compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2037
2038 truncate_ts(s->streams[pkt->stream_index], pkt);
2039
576ae256
MN
2040 ret= s->oformat->write_packet(s, pkt);
2041 if(!ret)
2042 ret= url_ferror(&s->pb);
2043 return ret;
3c895fc0
MN
2044}
2045
2046/**
fe2d6fe2
MN
2047 * interleave_packet implementation which will interleave per DTS.
2048 */
2049static int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2050 AVPacketList *pktl, **next_point, *this_pktl;
2051 int stream_count=0;
2052 int streams[MAX_STREAMS];
2053
2054 if(pkt){
2055 AVStream *st= s->streams[ pkt->stream_index];
2056
2057 assert(pkt->destruct != av_destruct_packet); //FIXME
2058
2059 this_pktl = av_mallocz(sizeof(AVPacketList));
2060 this_pktl->pkt= *pkt;
2061 av_dup_packet(&this_pktl->pkt);
2062
2063 next_point = &s->packet_buffer;
2064 while(*next_point){
2065 AVStream *st2= s->streams[ (*next_point)->pkt.stream_index];
2066 int64_t left= st2->time_base.num * (int64_t)st ->time_base.den;
2067 int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2068 if((*next_point)->pkt.dts * left > pkt->dts * right) //FIXME this can overflow
2069 break;
2070 next_point= &(*next_point)->next;
2071 }
2072 this_pktl->next= *next_point;
2073 *next_point= this_pktl;
2074 }
2075
2076 memset(streams, 0, sizeof(streams));
2077 pktl= s->packet_buffer;
2078 while(pktl){
2079//av_log(s, AV_LOG_DEBUG, "show st:%d dts:%lld\n", pktl->pkt.stream_index, pktl->pkt.dts);
2080 if(streams[ pktl->pkt.stream_index ] == 0)
2081 stream_count++;
2082 streams[ pktl->pkt.stream_index ]++;
2083 pktl= pktl->next;
2084 }
2085
2086 if(s->nb_streams == stream_count || (flush && stream_count)){
2087 pktl= s->packet_buffer;
2088 *out= pktl->pkt;
2089
2090 s->packet_buffer= pktl->next;
2091 av_freep(&pktl);
2092 return 1;
2093 }else{
2094 av_init_packet(out);
2095 return 0;
2096 }
2097}
2098
2099/**
2100 * Interleaves a AVPacket correctly so it can be muxed.
2101 * @param out the interleaved packet will be output here
2102 * @param in the input packet
2103 * @param flush 1 if no further packets are available as input and all
2104 * remaining packets should be output
2105 * @return 1 if a packet was output, 0 if no packet could be output,
2106 * < 0 if an error occured
2107 */
2108static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2109 if(s->oformat->interleave_packet)
2110 return s->oformat->interleave_packet(s, out, in, flush);
2111 else
2112 return av_interleave_packet_per_dts(s, out, in, flush);
2113}
2114
2115/**
3c895fc0
MN
2116 * Writes a packet to an output media file ensuring correct interleaving.
2117 * The packet shall contain one audio or video frame.
2118 * If the packets are already correctly interleaved the application should
2119 * call av_write_frame() instead as its slightly faster, its also important
fe2d6fe2 2120 * to keep in mind that completly non interleaved input will need huge amounts
3c895fc0
MN
2121 * of memory to interleave with this, so its prefereable to interleave at the
2122 * demuxer level
2123 *
2124 * @param s media file handle
2125 * @param pkt the packet, which contains the stream_index, buf/buf_size, dts/pts, ...
2126 * @return < 0 if error, = 0 if OK, 1 if end of stream wanted.
2127 */
2128int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
3c895fc0
MN
2129 AVStream *st= s->streams[ pkt->stream_index];
2130
2131 compute_pkt_fields2(st, pkt);
6f824977
MN
2132
2133 //FIXME/XXX/HACK drop zero sized packets
2134 if(st->codec.codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2135 return 0;
fe2d6fe2 2136
3c895fc0
MN
2137 if(pkt->dts == AV_NOPTS_VALUE)
2138 return -1;
3c895fc0 2139
fe2d6fe2
MN
2140 for(;;){
2141 AVPacket opkt;
2142 int ret= av_interleave_packet(s, &opkt, pkt, 0);
2143 if(ret<=0) //FIXME cleanup needed for ret<0 ?
2144 return ret;
3c895fc0 2145
fe2d6fe2
MN
2146 truncate_ts(s->streams[opkt.stream_index], &opkt);
2147 ret= s->oformat->write_packet(s, &opkt);
2148
2149 av_free_packet(&opkt);
2150 pkt= NULL;
3c895fc0
MN
2151
2152 if(ret<0)
2153 return ret;
576ae256
MN
2154 if(url_ferror(&s->pb))
2155 return url_ferror(&s->pb);
3c895fc0 2156 }
b9a281db
FB
2157}
2158
2159/**
2160 * write the stream trailer to an output media file and and free the
2161 * file private data.
2162 *
2163 * @param s media file handle
2164 * @return 0 if OK. AVERROR_xxx if error. */
2165int av_write_trailer(AVFormatContext *s)
2166{
c40a3a42 2167 int ret, i;
3c895fc0 2168
fe2d6fe2
MN
2169 for(;;){
2170 AVPacket pkt;
2171 ret= av_interleave_packet(s, &pkt, NULL, 1);
2172 if(ret<0) //FIXME cleanup needed for ret<0 ?
c40a3a42 2173 goto fail;
fe2d6fe2
MN
2174 if(!ret)
2175 break;
3c895fc0 2176
fe2d6fe2
MN
2177 truncate_ts(s->streams[pkt.stream_index], &pkt);
2178 ret= s->oformat->write_packet(s, &pkt);
2179
2180 av_free_packet(&pkt);
3c895fc0
MN
2181
2182 if(ret<0)
c40a3a42 2183 goto fail;
576ae256
MN
2184 if(url_ferror(&s->pb))
2185 goto fail;
3c895fc0
MN
2186 }
2187
b9a281db 2188 ret = s->oformat->write_trailer(s);
c40a3a42 2189fail:
576ae256
MN
2190 if(ret == 0)
2191 ret=url_ferror(&s->pb);
c40a3a42
MN
2192 for(i=0;i<s->nb_streams;i++)
2193 av_freep(&s->streams[i]->priv_data);
b9a281db
FB
2194 av_freep(&s->priv_data);
2195 return ret;
de6d9b64
FB
2196}
2197
2198/* "user interface" functions */
2199
2200void dump_format(AVFormatContext *ic,
2201 int index,
2202 const char *url,
2203 int is_output)
2204{
b9a281db 2205 int i, flags;
de6d9b64
FB
2206 char buf[256];
2207
43465395 2208 av_log(NULL, AV_LOG_DEBUG, "%s #%d, %s, %s '%s':\n",
de6d9b64 2209 is_output ? "Output" : "Input",
b9a281db
FB
2210 index,
2211 is_output ? ic->oformat->name : ic->iformat->name,
de6d9b64 2212 is_output ? "to" : "from", url);
12f996ed 2213 if (!is_output) {
43465395 2214 av_log(NULL, AV_LOG_DEBUG, " Duration: ");
12f996ed
FB
2215 if (ic->duration != AV_NOPTS_VALUE) {
2216 int hours, mins, secs, us;
2217 secs = ic->duration / AV_TIME_BASE;
2218 us = ic->duration % AV_TIME_BASE;
2219 mins = secs / 60;
2220 secs %= 60;
2221 hours = mins / 60;
2222 mins %= 60;
43465395 2223 av_log(NULL, AV_LOG_DEBUG, "%02d:%02d:%02d.%01d", hours, mins, secs,
12f996ed
FB
2224 (10 * us) / AV_TIME_BASE);
2225 } else {
43465395 2226 av_log(NULL, AV_LOG_DEBUG, "N/A");
12f996ed 2227 }
d0f3f159
WG
2228 if (ic->start_time != AV_NOPTS_VALUE) {
2229 int secs, us;
2230 av_log(NULL, AV_LOG_DEBUG, ", start: ");
2231 secs = ic->start_time / AV_TIME_BASE;
2232 us = ic->start_time % AV_TIME_BASE;
2233 av_log(NULL, AV_LOG_DEBUG, "%d.%06d",
2234 secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
2235 }
43465395 2236 av_log(NULL, AV_LOG_DEBUG, ", bitrate: ");
12f996ed 2237 if (ic->bit_rate) {
43465395 2238 av_log(NULL, AV_LOG_DEBUG,"%d kb/s", ic->bit_rate / 1000);
12f996ed 2239 } else {
43465395 2240 av_log(NULL, AV_LOG_DEBUG, "N/A");
12f996ed 2241 }
43465395 2242 av_log(NULL, AV_LOG_DEBUG, "\n");
12f996ed 2243 }
de6d9b64
FB
2244 for(i=0;i<ic->nb_streams;i++) {
2245 AVStream *st = ic->streams[i];
2246 avcodec_string(buf, sizeof(buf), &st->codec, is_output);
43465395 2247 av_log(NULL, AV_LOG_DEBUG, " Stream #%d.%d", index, i);
b9a281db
FB
2248 /* the pid is an important information, so we display it */
2249 /* XXX: add a generic system */
2250 if (is_output)
2251 flags = ic->oformat->flags;
2252 else
2253 flags = ic->iformat->flags;
2254 if (flags & AVFMT_SHOW_IDS) {
43465395 2255 av_log(NULL, AV_LOG_DEBUG, "[0x%x]", st->id);
b9a281db 2256 }
43465395 2257 av_log(NULL, AV_LOG_DEBUG, ": %s\n", buf);
de6d9b64
FB
2258 }
2259}
2260
2261typedef struct {
445f1b83 2262 const char *abv;
de6d9b64 2263 int width, height;
445f1b83
RS
2264 int frame_rate, frame_rate_base;
2265} AbvEntry;
2266
2267static AbvEntry frame_abvs[] = {
ba2a8cb4
RS
2268 { "ntsc", 720, 480, 30000, 1001 },
2269 { "pal", 720, 576, 25, 1 },
2270 { "qntsc", 352, 240, 30000, 1001 }, /* VCD compliant ntsc */
2271 { "qpal", 352, 288, 25, 1 }, /* VCD compliant pal */
904736b5
RS
2272 { "sntsc", 640, 480, 30000, 1001 }, /* square pixel ntsc */
2273 { "spal", 768, 576, 25, 1 }, /* square pixel pal */
445f1b83
RS
2274 { "film", 352, 240, 24, 1 },
2275 { "ntsc-film", 352, 240, 24000, 1001 },
2276 { "sqcif", 128, 96, 0, 0 },
2277 { "qcif", 176, 144, 0, 0 },
2278 { "cif", 352, 288, 0, 0 },
2279 { "4cif", 704, 576, 0, 0 },
de6d9b64 2280};
445f1b83 2281
de6d9b64
FB
2282int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2283{
2284 int i;
445f1b83 2285 int n = sizeof(frame_abvs) / sizeof(AbvEntry);
de6d9b64
FB
2286 const char *p;
2287 int frame_width = 0, frame_height = 0;
2288
2289 for(i=0;i<n;i++) {
445f1b83
RS
2290 if (!strcmp(frame_abvs[i].abv, str)) {
2291 frame_width = frame_abvs[i].width;
2292 frame_height = frame_abvs[i].height;
de6d9b64
FB
2293 break;
2294 }
2295 }
2296 if (i == n) {
2297 p = str;
2298 frame_width = strtol(p, (char **)&p, 10);
2299 if (*p)
2300 p++;
2301 frame_height = strtol(p, (char **)&p, 10);
2302 }
2303 if (frame_width <= 0 || frame_height <= 0)
2304 return -1;
2305 *width_ptr = frame_width;
2306 *height_ptr = frame_height;
2307 return 0;
2308}
2309
445f1b83
RS
2310int parse_frame_rate(int *frame_rate, int *frame_rate_base, const char *arg)
2311{
2312 int i;
2313 char* cp;
2314
2315 /* First, we check our abbreviation table */
2316 for (i = 0; i < sizeof(frame_abvs)/sizeof(*frame_abvs); ++i)
2317 if (!strcmp(frame_abvs[i].abv, arg)) {
2318 *frame_rate = frame_abvs[i].frame_rate;
2319 *frame_rate_base = frame_abvs[i].frame_rate_base;
2320 return 0;
2321 }
2322
2323 /* Then, we try to parse it as fraction */
2324 cp = strchr(arg, '/');
2325 if (cp) {
2326 char* cpp;
2327 *frame_rate = strtol(arg, &cpp, 10);
2328 if (cpp != arg || cpp == cp)
2329 *frame_rate_base = strtol(cp+1, &cpp, 10);
2330 else
2331 *frame_rate = 0;
2332 }
2333 else {
2334 /* Finally we give up and parse it as double */
8bfed902 2335 *frame_rate_base = DEFAULT_FRAME_RATE_BASE; //FIXME use av_d2q()
445f1b83
RS
2336 *frame_rate = (int)(strtod(arg, 0) * (*frame_rate_base) + 0.5);
2337 }
2338 if (!*frame_rate || !*frame_rate_base)
2339 return -1;
2340 else
2341 return 0;
2342}
2343
916c80e9
FB
2344/* Syntax:
2345 * - If not a duration:
2346 * [{YYYY-MM-DD|YYYYMMDD}]{T| }{HH[:MM[:SS[.m...]]][Z]|HH[MM[SS[.m...]]][Z]}
c5510dd6 2347 * Time is localtime unless Z is suffixed to the end. In this case GMT
916c80e9
FB
2348 * Return the date in micro seconds since 1970
2349 * - If duration:
2350 * HH[:MM[:SS[.m...]]]
2351 * S+[.m...]
2352 */
0c1a9eda 2353int64_t parse_date(const char *datestr, int duration)
de6d9b64
FB
2354{
2355 const char *p;
0c1a9eda 2356 int64_t t;
2dbceb9f 2357 struct tm dt;
c5510dd6
PG
2358 int i;
2359 static const char *date_fmt[] = {
2360 "%Y-%m-%d",
2361 "%Y%m%d",
2362 };
2363 static const char *time_fmt[] = {
2364 "%H:%M:%S",
2365 "%H%M%S",
2366 };
2367 const char *q;
916c80e9 2368 int is_utc, len;
c5510dd6 2369 char lastch;
a6a92a9a 2370 int negative = 0;
6d8f985e
MN
2371
2372#undef time
c5510dd6
PG
2373 time_t now = time(0);
2374
916c80e9
FB
2375 len = strlen(datestr);
2376 if (len > 0)
2377 lastch = datestr[len - 1];
2378 else
2379 lastch = '\0';
c5510dd6 2380 is_utc = (lastch == 'z' || lastch == 'Z');
2dbceb9f
PG
2381
2382 memset(&dt, 0, sizeof(dt));
de6d9b64
FB
2383
2384 p = datestr;
916c80e9 2385 q = NULL;
de6d9b64 2386 if (!duration) {
c5510dd6 2387 for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
f71869a4 2388 q = small_strptime(p, date_fmt[i], &dt);
c5510dd6
PG
2389 if (q) {
2390 break;
2391 }
2392 }
2393
2394 if (!q) {
2395 if (is_utc) {
2396 dt = *gmtime(&now);
2397 } else {
2398 dt = *localtime(&now);
2399 }
2400 dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
de6d9b64 2401 } else {
c5510dd6 2402 p = q;
de6d9b64 2403 }
c5510dd6
PG
2404
2405 if (*p == 'T' || *p == 't' || *p == ' ')
2406 p++;
c5510dd6 2407
916c80e9 2408 for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
f71869a4 2409 q = small_strptime(p, time_fmt[i], &dt);
916c80e9
FB
2410 if (q) {
2411 break;
2412 }
2413 }
2414 } else {
a6a92a9a
WG
2415 if (p[0] == '-') {
2416 negative = 1;
2417 ++p;
2418 }
f71869a4 2419 q = small_strptime(p, time_fmt[0], &dt);
916c80e9
FB
2420 if (!q) {
2421 dt.tm_sec = strtol(p, (char **)&q, 10);
2422 dt.tm_min = 0;
2423 dt.tm_hour = 0;
c5510dd6
PG
2424 }
2425 }
2426
2427 /* Now we have all the fields that we can get */
2428 if (!q) {
2429 if (duration)
2430 return 0;
2431 else
0c1a9eda 2432 return now * int64_t_C(1000000);
de6d9b64 2433 }
2dbceb9f
PG
2434
2435 if (duration) {
c5510dd6 2436 t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2dbceb9f 2437 } else {
c5510dd6
PG
2438 dt.tm_isdst = -1; /* unknown */
2439 if (is_utc) {
2440 t = mktimegm(&dt);
2441 } else {
2442 t = mktime(&dt);
2443 }
de6d9b64 2444 }
2dbceb9f 2445
c5510dd6
PG
2446 t *= 1000000;
2447
2448 if (*q == '.') {
de6d9b64 2449 int val, n;
c5510dd6
PG
2450 q++;
2451 for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
2452 if (!isdigit(*q))
2453 break;
2454 val += n * (*q - '0');
de6d9b64
FB
2455 }
2456 t += val;
2457 }
a6a92a9a 2458 return negative ? -t : t;
de6d9b64
FB
2459}
2460
2dbceb9f 2461/* syntax: '?tag1=val1&tag2=val2...'. Little URL decoding is done. Return
de6d9b64
FB
2462 1 if found */
2463int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
2464{
2465 const char *p;
2466 char tag[128], *q;
2467
2468 p = info;
2469 if (*p == '?')
2470 p++;
2471 for(;;) {
2472 q = tag;
2473 while (*p != '\0' && *p != '=' && *p != '&') {
2474 if ((q - tag) < sizeof(tag) - 1)
2475 *q++ = *p;
2476 p++;
2477 }
2478 *q = '\0';
2479 q = arg;
2480 if (*p == '=') {
2481 p++;
2482 while (*p != '&' && *p != '\0') {
2dbceb9f
PG
2483 if ((q - arg) < arg_size - 1) {
2484 if (*p == '+')
2485 *q++ = ' ';
2486 else
2487 *q++ = *p;
2488 }
de6d9b64
FB
2489 p++;
2490 }
2491 *q = '\0';
2492 }
2493 if (!strcmp(tag, tag1))
2494 return 1;
2495 if (*p != '&')
2496 break;
8d1335ea 2497 p++;
de6d9b64
FB
2498 }
2499 return 0;
2500}
2501
9150f42e
FB
2502/* Return in 'buf' the path with '%d' replaced by number. Also handles
2503 the '%0nd' format where 'n' is the total number of digits and
2504 '%%'. Return 0 if OK, and -1 if format error */
2505int get_frame_filename(char *buf, int buf_size,
2506 const char *path, int number)
2507{
2508 const char *p;
0bf92f79
PI
2509 char *q, buf1[20], c;
2510 int nd, len, percentd_found;
9150f42e
FB
2511
2512 q = buf;
2513 p = path;
2514 percentd_found = 0;
2515 for(;;) {
2516 c = *p++;
2517 if (c == '\0')
2518 break;
2519 if (c == '%') {
c9646fda
PG
2520 do {
2521 nd = 0;
2522 while (isdigit(*p)) {
2523 nd = nd * 10 + *p++ - '0';
2524 }
2525 c = *p++;
c9646fda
PG
2526 } while (isdigit(c));
2527
9150f42e
FB
2528 switch(c) {
2529 case '%':
2530 goto addchar;
2531 case 'd':
2532 if (percentd_found)
2533 goto fail;
2534 percentd_found = 1;
2535 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
2536 len = strlen(buf1);
2537 if ((q - buf + len) > buf_size - 1)
2538 goto fail;
2539 memcpy(q, buf1, len);
2540 q += len;
2541 break;
2542 default:
2543 goto fail;
2544 }
2545 } else {
2546 addchar:
2547 if ((q - buf) < buf_size - 1)
2548 *q++ = c;
2549 }
2550 }
2551 if (!percentd_found)
2552 goto fail;
2553 *q = '\0';
2554 return 0;
2555 fail:
2556 *q = '\0';
2557 return -1;
2558}
2559
b9a281db 2560/**
fb2758c8
FB
2561 * Print nice hexa dump of a buffer
2562 * @param f stream for output
b9a281db
FB
2563 * @param buf buffer
2564 * @param size buffer size
2565 */
fb2758c8 2566void av_hex_dump(FILE *f, uint8_t *buf, int size)
b9a281db
FB
2567{
2568 int len, i, j, c;
2569
2570 for(i=0;i<size;i+=16) {
2571 len = size - i;
2572 if (len > 16)
2573 len = 16;
fb2758c8 2574 fprintf(f, "%08x ", i);
b9a281db
FB
2575 for(j=0;j<16;j++) {
2576 if (j < len)
fb2758c8 2577 fprintf(f, " %02x", buf[i+j]);
b9a281db 2578 else
fb2758c8 2579 fprintf(f, " ");
b9a281db 2580 }
fb2758c8 2581 fprintf(f, " ");
b9a281db
FB
2582 for(j=0;j<len;j++) {
2583 c = buf[i+j];
2584 if (c < ' ' || c > '~')
2585 c = '.';
fb2758c8 2586 fprintf(f, "%c", c);
b9a281db 2587 }
fb2758c8 2588 fprintf(f, "\n");
b9a281db
FB
2589 }
2590}
2591
fb2758c8
FB
2592/**
2593 * Print on 'f' a nice dump of a packet
2594 * @param f stream for output
2595 * @param pkt packet to dump
2596 * @param dump_payload true if the payload must be displayed too
2597 */
2598void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
2599{
2600 fprintf(f, "stream #%d:\n", pkt->stream_index);
2601 fprintf(f, " keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
2602 fprintf(f, " duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
37353960
FB
2603 /* DTS is _always_ valid after av_read_frame() */
2604 fprintf(f, " dts=");
2605 if (pkt->dts == AV_NOPTS_VALUE)
2606 fprintf(f, "N/A");
2607 else
2608 fprintf(f, "%0.3f", (double)pkt->dts / AV_TIME_BASE);
fb2758c8
FB
2609 /* PTS may be not known if B frames are present */
2610 fprintf(f, " pts=");
2611 if (pkt->pts == AV_NOPTS_VALUE)
2612 fprintf(f, "N/A");
2613 else
2614 fprintf(f, "%0.3f", (double)pkt->pts / AV_TIME_BASE);
2615 fprintf(f, "\n");
2616 fprintf(f, " size=%d\n", pkt->size);
2617 if (dump_payload)
2618 av_hex_dump(f, pkt->data, pkt->size);
2619}
2620
a9a721da 2621void url_split(char *proto, int proto_size,
6ba5cbc6 2622 char *authorization, int authorization_size,
a9a721da
FB
2623 char *hostname, int hostname_size,
2624 int *port_ptr,
2625 char *path, int path_size,
2626 const char *url)
2627{
2628 const char *p;
2629 char *q;
2630 int port;
2631
2632 port = -1;
2633
2634 p = url;
2635 q = proto;
2636 while (*p != ':' && *p != '\0') {
2637 if ((q - proto) < proto_size - 1)
2638 *q++ = *p;
2639 p++;
2640 }
2641 if (proto_size > 0)
2642 *q = '\0';
6ba5cbc6
PD
2643 if (authorization_size > 0)
2644 authorization[0] = '\0';
a9a721da
FB
2645 if (*p == '\0') {
2646 if (proto_size > 0)
2647 proto[0] = '\0';
2648 if (hostname_size > 0)
2649 hostname[0] = '\0';
2650 p = url;
2651 } else {
6ba5cbc6
PD
2652 char *at,*slash; // PETR: position of '@' character and '/' character
2653
a9a721da
FB
2654 p++;
2655 if (*p == '/')
2656 p++;
2657 if (*p == '/')
2658 p++;
6ba5cbc6
PD
2659 at = strchr(p,'@'); // PETR: get the position of '@'
2660 slash = strchr(p,'/'); // PETR: get position of '/' - end of hostname
2661 if (at && slash && at > slash) at = NULL; // PETR: not interested in '@' behind '/'
2662
2663 q = at ? authorization : hostname; // PETR: if '@' exists starting with auth.
2664
2665 while ((at || *p != ':') && *p != '/' && *p != '?' && *p != '\0') { // PETR:
2666 if (*p == '@') { // PETR: passed '@'
2667 if (authorization_size > 0)
2668 *q = '\0';
2669 q = hostname;
2670 at = NULL;
2671 } else if (!at) { // PETR: hostname
2672 if ((q - hostname) < hostname_size - 1)
2673 *q++ = *p;
2674 } else {
2675 if ((q - authorization) < authorization_size - 1)
a9a721da 2676 *q++ = *p;
6ba5cbc6 2677 }
a9a721da
FB
2678 p++;
2679 }
2680 if (hostname_size > 0)
2681 *q = '\0';
2682 if (*p == ':') {
2683 p++;
2684 port = strtoul(p, (char **)&p, 10);
2685 }
2686 }
2687 if (port_ptr)
2688 *port_ptr = port;
2689 pstrcpy(path, path_size, p);
2690}
2691
916c80e9
FB
2692/**
2693 * Set the pts for a given stream
2694 * @param s stream
2695 * @param pts_wrap_bits number of bits effectively used by the pts
2696 * (used for wrap control, 33 is the value for MPEG)
2697 * @param pts_num numerator to convert to seconds (MPEG: 1)
2698 * @param pts_den denominator to convert to seconds (MPEG: 90000)
2699 */
9ee91c2f 2700void av_set_pts_info(AVStream *s, int pts_wrap_bits,
916c80e9
FB
2701 int pts_num, int pts_den)
2702{
2703 s->pts_wrap_bits = pts_wrap_bits;
9ee91c2f
MN
2704 s->time_base.num = pts_num;
2705 s->time_base.den = pts_den;
916c80e9
FB
2706}
2707
2708/* fraction handling */
2709
2710/**
2711 * f = val + (num / den) + 0.5. 'num' is normalized so that it is such
2712 * as 0 <= num < den.
2713 *
2714 * @param f fractional number
2715 * @param val integer value
2716 * @param num must be >= 0
2717 * @param den must be >= 1
2718 */
0c1a9eda 2719void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
916c80e9
FB
2720{
2721 num += (den >> 1);
2722 if (num >= den) {
2723 val += num / den;
2724 num = num % den;
2725 }
2726 f->val = val;
2727 f->num = num;
2728 f->den = den;
2729}
2730
2731/* set f to (val + 0.5) */
0c1a9eda 2732void av_frac_set(AVFrac *f, int64_t val)
916c80e9
FB
2733{
2734 f->val = val;
2735 f->num = f->den >> 1;
2736}
2737
2738/**
2739 * Fractionnal addition to f: f = f + (incr / f->den)
2740 *
2741 * @param f fractional number
2742 * @param incr increment, can be positive or negative
2743 */
0c1a9eda 2744void av_frac_add(AVFrac *f, int64_t incr)
916c80e9 2745{
0c1a9eda 2746 int64_t num, den;
916c80e9
FB
2747
2748 num = f->num + incr;
2749 den = f->den;
2750 if (num < 0) {
2751 f->val += num / den;
2752 num = num % den;
2753 if (num < 0) {
2754 num += den;
2755 f->val--;
2756 }
2757 } else if (num >= den) {
2758 f->val += num / den;
2759 num = num % den;
2760 }
2761 f->num = num;
2762}
87a0a681
FB
2763
2764/**
2765 * register a new image format
2766 * @param img_fmt Image format descriptor
2767 */
2768void av_register_image_format(AVImageFormat *img_fmt)
2769{
2770 AVImageFormat **p;
2771
2772 p = &first_image_format;
2773 while (*p != NULL) p = &(*p)->next;
2774 *p = img_fmt;
2775 img_fmt->next = NULL;
2776}
2777
2778/* guess image format */
2779AVImageFormat *av_probe_image_format(AVProbeData *pd)
2780{
2781 AVImageFormat *fmt1, *fmt;
2782 int score, score_max;
2783
2784 fmt = NULL;
2785 score_max = 0;
2786 for(fmt1 = first_image_format; fmt1 != NULL; fmt1 = fmt1->next) {
2787 if (fmt1->img_probe) {
2788 score = fmt1->img_probe(pd);
2789 if (score > score_max) {
2790 score_max = score;
2791 fmt = fmt1;
2792 }
2793 }
2794 }
2795 return fmt;
2796}
2797
2798AVImageFormat *guess_image_format(const char *filename)
2799{
2800 AVImageFormat *fmt1;
2801
2802 for(fmt1 = first_image_format; fmt1 != NULL; fmt1 = fmt1->next) {
2803 if (fmt1->extensions && match_ext(filename, fmt1->extensions))
2804 return fmt1;
2805 }
2806 return NULL;
2807}
2808
2809/**
2810 * Read an image from a stream.
2811 * @param gb byte stream containing the image
2812 * @param fmt image format, NULL if probing is required
2813 */
2814int av_read_image(ByteIOContext *pb, const char *filename,
2815 AVImageFormat *fmt,
2816 int (*alloc_cb)(void *, AVImageInfo *info), void *opaque)
2817{
2818 char buf[PROBE_BUF_SIZE];
2819 AVProbeData probe_data, *pd = &probe_data;
2820 offset_t pos;
2821 int ret;
2822
2823 if (!fmt) {
5c91a675 2824 pd->filename = filename;
87a0a681
FB
2825 pd->buf = buf;
2826 pos = url_ftell(pb);
2827 pd->buf_size = get_buffer(pb, buf, PROBE_BUF_SIZE);
2828 url_fseek(pb, pos, SEEK_SET);
2829 fmt = av_probe_image_format(pd);
2830 }
2831 if (!fmt)
2832 return AVERROR_NOFMT;
2833 ret = fmt->img_read(pb, alloc_cb, opaque);
2834 return ret;
2835}
2836
2837/**
2838 * Write an image to a stream.
2839 * @param pb byte stream for the image output
2840 * @param fmt image format
2841 * @param img image data and informations
2842 */
2843int av_write_image(ByteIOContext *pb, AVImageFormat *fmt, AVImageInfo *img)
2844{
2845 return fmt->img_write(pb, img);
2846}
2847