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