* Extend the syntax of a filename for the img reader to allow looping. Thus
[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#include <ctype.h>
8be1c656 21#ifndef CONFIG_WIN32
de6d9b64
FB
22#include <unistd.h>
23#include <fcntl.h>
de6d9b64 24#include <sys/time.h>
8be1c656
FB
25#else
26#define strcasecmp _stricmp
27#include <sys/types.h>
28#include <sys/timeb.h>
29#endif
9235088f 30#include <time.h>
de6d9b64 31
c5510dd6
PG
32#ifndef HAVE_STRPTIME
33#include "strptime.h"
34#endif
35
b9a281db
FB
36AVInputFormat *first_iformat;
37AVOutputFormat *first_oformat;
de6d9b64 38
b9a281db 39void av_register_input_format(AVInputFormat *format)
de6d9b64 40{
b9a281db
FB
41 AVInputFormat **p;
42 p = &first_iformat;
43 while (*p != NULL) p = &(*p)->next;
44 *p = format;
45 format->next = NULL;
46}
47
48void av_register_output_format(AVOutputFormat *format)
49{
50 AVOutputFormat **p;
51 p = &first_oformat;
de6d9b64
FB
52 while (*p != NULL) p = &(*p)->next;
53 *p = format;
54 format->next = NULL;
55}
56
5b25dfa7 57int match_ext(const char *filename, const char *extensions)
de6d9b64
FB
58{
59 const char *ext, *p;
60 char ext1[32], *q;
61
62 ext = strrchr(filename, '.');
63 if (ext) {
64 ext++;
65 p = extensions;
66 for(;;) {
67 q = ext1;
68 while (*p != '\0' && *p != ',')
69 *q++ = *p++;
70 *q = '\0';
71 if (!strcasecmp(ext1, ext))
72 return 1;
73 if (*p == '\0')
74 break;
75 p++;
76 }
77 }
78 return 0;
79}
80
b9a281db
FB
81AVOutputFormat *guess_format(const char *short_name, const char *filename,
82 const char *mime_type)
de6d9b64 83{
b9a281db 84 AVOutputFormat *fmt, *fmt_found;
de6d9b64
FB
85 int score_max, score;
86
87 /* find the proper file type */
88 fmt_found = NULL;
89 score_max = 0;
b9a281db 90 fmt = first_oformat;
de6d9b64
FB
91 while (fmt != NULL) {
92 score = 0;
93 if (fmt->name && short_name && !strcmp(fmt->name, short_name))
94 score += 100;
95 if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
96 score += 10;
97 if (filename && fmt->extensions &&
98 match_ext(filename, fmt->extensions)) {
99 score += 5;
100 }
101 if (score > score_max) {
102 score_max = score;
103 fmt_found = fmt;
104 }
105 fmt = fmt->next;
106 }
107 return fmt_found;
108}
109
c5510dd6
PG
110AVOutputFormat *guess_stream_format(const char *short_name, const char *filename,
111 const char *mime_type)
112{
113 AVOutputFormat *fmt = guess_format(short_name, filename, mime_type);
114
115 if (fmt) {
116 AVOutputFormat *stream_fmt;
117 char stream_format_name[64];
118
119 snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
120 stream_fmt = guess_format(stream_format_name, NULL, NULL);
121
122 if (stream_fmt)
123 fmt = stream_fmt;
124 }
125
126 return fmt;
127}
128
b9a281db
FB
129AVInputFormat *av_find_input_format(const char *short_name)
130{
131 AVInputFormat *fmt;
132 for(fmt = first_iformat; fmt != NULL; fmt = fmt->next) {
133 if (!strcmp(fmt->name, short_name))
134 return fmt;
135 }
136 return NULL;
137}
138
de6d9b64
FB
139/* memory handling */
140
b9a281db
FB
141/**
142 * Allocate the payload of a packet and intialized its fields to default values.
143 *
144 * @param pkt packet
145 * @param size wanted payload size
146 * @return 0 if OK. AVERROR_xxx otherwise.
147 */
de6d9b64
FB
148int av_new_packet(AVPacket *pkt, int size)
149{
8cd5be98
MN
150 int i;
151 pkt->data = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
de6d9b64 152 if (!pkt->data)
b9a281db 153 return AVERROR_NOMEM;
de6d9b64
FB
154 pkt->size = size;
155 /* sane state */
916c80e9 156 pkt->pts = AV_NOPTS_VALUE;
de6d9b64
FB
157 pkt->stream_index = 0;
158 pkt->flags = 0;
8cd5be98
MN
159
160 for(i=0; i<FF_INPUT_BUFFER_PADDING_SIZE; i++)
161 pkt->data[size+i]= 0;
162
de6d9b64
FB
163 return 0;
164}
165
b9a281db
FB
166/**
167 * Free a packet
168 *
169 * @param pkt packet to free
170 */
de6d9b64
FB
171void av_free_packet(AVPacket *pkt)
172{
1ea4f593 173 av_freep(&pkt->data);
de6d9b64 174 /* fail safe */
de6d9b64
FB
175 pkt->size = 0;
176}
177
178/* fifo handling */
179
180int fifo_init(FifoBuffer *f, int size)
181{
1ea4f593 182 f->buffer = av_malloc(size);
de6d9b64
FB
183 if (!f->buffer)
184 return -1;
185 f->end = f->buffer + size;
186 f->wptr = f->rptr = f->buffer;
187 return 0;
188}
189
190void fifo_free(FifoBuffer *f)
191{
1ea4f593 192 av_free(f->buffer);
de6d9b64
FB
193}
194
195int fifo_size(FifoBuffer *f, UINT8 *rptr)
196{
197 int size;
198
199 if (f->wptr >= rptr) {
200 size = f->wptr - rptr;
201 } else {
202 size = (f->end - rptr) + (f->wptr - f->buffer);
203 }
204 return size;
205}
206
207/* get data from the fifo (return -1 if not enough data) */
208int fifo_read(FifoBuffer *f, UINT8 *buf, int buf_size, UINT8 **rptr_ptr)
209{
210 UINT8 *rptr = *rptr_ptr;
211 int size, len;
212
213 if (f->wptr >= rptr) {
214 size = f->wptr - rptr;
215 } else {
216 size = (f->end - rptr) + (f->wptr - f->buffer);
217 }
218
219 if (size < buf_size)
220 return -1;
221 while (buf_size > 0) {
222 len = f->end - rptr;
223 if (len > buf_size)
224 len = buf_size;
225 memcpy(buf, rptr, len);
226 buf += len;
227 rptr += len;
228 if (rptr >= f->end)
229 rptr = f->buffer;
230 buf_size -= len;
231 }
232 *rptr_ptr = rptr;
233 return 0;
234}
235
236void fifo_write(FifoBuffer *f, UINT8 *buf, int size, UINT8 **wptr_ptr)
237{
238 int len;
239 UINT8 *wptr;
240 wptr = *wptr_ptr;
241 while (size > 0) {
242 len = f->end - wptr;
243 if (len > size)
244 len = size;
245 memcpy(wptr, buf, len);
246 wptr += len;
247 if (wptr >= f->end)
248 wptr = f->buffer;
249 buf += len;
250 size -= len;
251 }
252 *wptr_ptr = wptr;
253}
254
b9a281db
FB
255int filename_number_test(const char *filename)
256{
257 char buf[1024];
258 return get_frame_filename(buf, sizeof(buf), filename, 1);
259}
260
261/* guess file format */
a25e098d 262AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened)
b9a281db
FB
263{
264 AVInputFormat *fmt1, *fmt;
265 int score, score_max;
266
267 fmt = NULL;
268 score_max = 0;
269 for(fmt1 = first_iformat; fmt1 != NULL; fmt1 = fmt1->next) {
270 if (!is_opened && !(fmt1->flags & AVFMT_NOFILE))
271 continue;
272 score = 0;
a8dbe951
PG
273 if (fmt1->read_probe) {
274 score = fmt1->read_probe(pd);
275 } else if (fmt1->extensions) {
b9a281db
FB
276 if (match_ext(pd->filename, fmt1->extensions)) {
277 score = 50;
278 }
a8dbe951 279 }
b9a281db
FB
280 if (score > score_max) {
281 score_max = score;
282 fmt = fmt1;
283 }
284 }
285 return fmt;
286}
287
288/************************************************************/
289/* input media file */
96baaa6a 290
b9a281db
FB
291#define PROBE_BUF_SIZE 2048
292
293/**
294 * Open a media file as input. The codec are not opened. Only the file
295 * header (if present) is read.
296 *
297 * @param ic_ptr the opened media file handle is put here
298 * @param filename filename to open.
299 * @param fmt if non NULL, force the file format to use
300 * @param buf_size optional buffer size (zero if default is OK)
301 * @param ap additionnal parameters needed when opening the file (NULL if default)
302 * @return 0 if OK. AVERROR_xxx otherwise.
303 */
304int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
305 AVInputFormat *fmt,
306 int buf_size,
307 AVFormatParameters *ap)
de6d9b64 308{
de6d9b64 309 AVFormatContext *ic = NULL;
de6d9b64 310 int err;
b9a281db
FB
311 char buf[PROBE_BUF_SIZE];
312 AVProbeData probe_data, *pd = &probe_data;
de6d9b64
FB
313
314 ic = av_mallocz(sizeof(AVFormatContext));
b9a281db
FB
315 if (!ic) {
316 err = AVERROR_NOMEM;
de6d9b64 317 goto fail;
de6d9b64 318 }
b9a281db
FB
319 pstrcpy(ic->filename, sizeof(ic->filename), filename);
320 pd->filename = ic->filename;
321 pd->buf = buf;
322 pd->buf_size = 0;
323
324 if (!fmt) {
325 /* guess format if no file can be opened */
a25e098d 326 fmt = av_probe_input_format(pd, 0);
de6d9b64 327 }
de6d9b64 328
96baaa6a 329 /* if no file needed do not try to open one */
b9a281db
FB
330 if (!fmt || !(fmt->flags & AVFMT_NOFILE)) {
331 if (url_fopen(&ic->pb, filename, URL_RDONLY) < 0) {
332 err = AVERROR_IO;
96baaa6a 333 goto fail;
b9a281db 334 }
96baaa6a
FB
335 if (buf_size > 0) {
336 url_setbufsize(&ic->pb, buf_size);
337 }
5b25dfa7
FB
338 if (!fmt) {
339 /* read probe data */
340 pd->buf_size = get_buffer(&ic->pb, buf, PROBE_BUF_SIZE);
341 url_fseek(&ic->pb, 0, SEEK_SET);
342 }
96baaa6a
FB
343 }
344
b9a281db
FB
345 /* guess file format */
346 if (!fmt) {
a25e098d 347 fmt = av_probe_input_format(pd, 1);
b9a281db
FB
348 }
349
350 /* if still no format found, error */
351 if (!fmt) {
352 err = AVERROR_NOFMT;
de6d9b64
FB
353 goto fail;
354 }
b9a281db 355
67d06418
FB
356 /* XXX: suppress this hack for redirectors */
357 if (fmt == &redir_demux) {
358 err = redir_open(ic_ptr, &ic->pb);
359 url_fclose(&ic->pb);
360 av_free(ic);
361 return err;
362 }
363
b9a281db 364 ic->iformat = fmt;
de6d9b64 365
b9a281db
FB
366 /* allocate private data */
367 ic->priv_data = av_mallocz(fmt->priv_data_size);
368 if (!ic->priv_data) {
369 err = AVERROR_NOMEM;
370 goto fail;
371 }
372
916c80e9
FB
373 /* default pts settings is MPEG like */
374 av_set_pts_info(ic, 33, 1, 90000);
375
b9a281db
FB
376 /* check filename in case of an image number is expected */
377 if (ic->iformat->flags & AVFMT_NEEDNUMBER) {
378 if (filename_number_test(ic->filename) < 0) {
379 err = AVERROR_NUMEXPECTED;
380 goto fail1;
381 }
382 }
383
384 err = ic->iformat->read_header(ic, ap);
385 if (err < 0)
386 goto fail1;
387 *ic_ptr = ic;
388 return 0;
389 fail1:
390 if (!(fmt->flags & AVFMT_NOFILE)) {
391 url_fclose(&ic->pb);
392 }
de6d9b64 393 fail:
b9a281db 394 if (ic) {
a8dbe951 395 av_freep(&ic->priv_data);
b9a281db 396 }
1ea4f593 397 av_free(ic);
b9a281db
FB
398 *ic_ptr = NULL;
399 return err;
de6d9b64
FB
400}
401
b9a281db
FB
402/**
403 * Read a packet from a media file
404 * @param s media file handle
405 * @param pkt is filled
406 * @return 0 if OK. AVERROR_xxx if error.
407 */
de6d9b64
FB
408int av_read_packet(AVFormatContext *s, AVPacket *pkt)
409{
410 AVPacketList *pktl;
411
412 pktl = s->packet_buffer;
413 if (pktl) {
414 /* read packet from packet buffer, if there is data */
415 *pkt = pktl->pkt;
416 s->packet_buffer = pktl->next;
1ea4f593 417 av_free(pktl);
de6d9b64
FB
418 return 0;
419 } else {
b9a281db
FB
420 return s->iformat->read_packet(s, pkt);
421 }
422}
423
424/* state for codec information */
425#define CSTATE_NOTFOUND 0
426#define CSTATE_DECODING 1
427#define CSTATE_FOUND 2
428
429static int has_codec_parameters(AVCodecContext *enc)
430{
431 int val;
432 switch(enc->codec_type) {
433 case CODEC_TYPE_AUDIO:
434 val = enc->sample_rate;
435 break;
436 case CODEC_TYPE_VIDEO:
437 val = enc->width;
438 break;
439 default:
440 val = 1;
441 break;
442 }
443 return (val != 0);
444}
445
446/**
447 * Read the beginning of a media file to get stream information. This
448 * is useful for file formats with no headers such as MPEG. This
449 * function also compute the real frame rate in case of mpeg2 repeat
450 * frame mode.
451 *
452 * @param ic media file handle
453 * @return >=0 if OK. AVERROR_xxx if error.
454 */
455int av_find_stream_info(AVFormatContext *ic)
456{
457 int i, count, ret, got_picture, size, read_size;
458 AVCodec *codec;
459 AVStream *st;
460 AVPacket *pkt;
492cd3a9 461 AVFrame picture;
b9a281db
FB
462 AVPacketList *pktl=NULL, **ppktl;
463 short samples[AVCODEC_MAX_AUDIO_FRAME_SIZE / 2];
464 UINT8 *ptr;
465 int min_read_size, max_read_size;
466
467 /* typical mpeg ts rate is 40 Mbits. DVD rate is about 10
468 Mbits. We read at most 0.1 second of file to find all streams */
469
470 /* XXX: base it on stream bitrate when possible */
471 if (ic->iformat == &mpegts_demux) {
472 /* maximum number of bytes we accept to read to find all the streams
473 in a file */
474 min_read_size = 3000000;
475 } else {
476 min_read_size = 125000;
477 }
478 /* max read size is 2 seconds of video max */
479 max_read_size = min_read_size * 20;
480
481 /* set initial codec state */
482 for(i=0;i<ic->nb_streams;i++) {
483 st = ic->streams[i];
484 if (has_codec_parameters(&st->codec))
485 st->codec_info_state = CSTATE_FOUND;
486 else
487 st->codec_info_state = CSTATE_NOTFOUND;
488 st->codec_info_nb_repeat_frames = 0;
489 st->codec_info_nb_real_frames = 0;
490 }
491
492 count = 0;
493 read_size = 0;
494 ppktl = &ic->packet_buffer;
495 for(;;) {
496 /* check if one codec still needs to be handled */
497 for(i=0;i<ic->nb_streams;i++) {
498 st = ic->streams[i];
499 if (st->codec_info_state != CSTATE_FOUND)
500 break;
501 }
502 if (i == ic->nb_streams) {
503 /* NOTE: if the format has no header, then we need to read
504 some packets to get most of the streams, so we cannot
505 stop here */
506 if (!(ic->iformat->flags & AVFMT_NOHEADER) ||
507 read_size >= min_read_size) {
508 /* if we found the info for all the codecs, we can stop */
509 ret = count;
510 break;
511 }
512 } else {
513 /* we did not get all the codec info, but we read too much data */
514 if (read_size >= max_read_size) {
515 ret = count;
516 break;
517 }
518 }
519
520 pktl = av_mallocz(sizeof(AVPacketList));
521 if (!pktl) {
522 ret = AVERROR_NOMEM;
523 break;
524 }
525
526 /* add the packet in the buffered packet list */
527 *ppktl = pktl;
528 ppktl = &pktl->next;
529
530 /* NOTE: a new stream can be added there if no header in file
531 (AVFMT_NOHEADER) */
532 pkt = &pktl->pkt;
533 if (ic->iformat->read_packet(ic, pkt) < 0) {
534 /* EOF or error */
535 ret = -1; /* we could not have all the codec parameters before EOF */
536 if ((ic->iformat->flags & AVFMT_NOHEADER) &&
537 i == ic->nb_streams)
538 ret = 0;
539 break;
540 }
541 read_size += pkt->size;
542
543 /* open new codecs */
544 for(i=0;i<ic->nb_streams;i++) {
545 st = ic->streams[i];
546 if (st->codec_info_state == CSTATE_NOTFOUND) {
547 /* set to found in case of error */
548 st->codec_info_state = CSTATE_FOUND;
549 codec = avcodec_find_decoder(st->codec.codec_id);
550 if (codec) {
d7425f59
MN
551 if(codec->capabilities & CODEC_CAP_TRUNCATED)
552 st->codec.flags |= CODEC_FLAG_TRUNCATED;
553
b9a281db
FB
554 ret = avcodec_open(&st->codec, codec);
555 if (ret >= 0)
556 st->codec_info_state = CSTATE_DECODING;
557 }
558 }
559 }
560
561 st = ic->streams[pkt->stream_index];
562 if (st->codec_info_state == CSTATE_DECODING) {
563 /* decode the data and update codec parameters */
564 ptr = pkt->data;
565 size = pkt->size;
566 while (size > 0) {
567 switch(st->codec.codec_type) {
568 case CODEC_TYPE_VIDEO:
569 ret = avcodec_decode_video(&st->codec, &picture,
570 &got_picture, ptr, size);
571 break;
572 case CODEC_TYPE_AUDIO:
573 ret = avcodec_decode_audio(&st->codec, samples,
574 &got_picture, ptr, size);
575 break;
576 default:
577 ret = -1;
578 break;
579 }
580 if (ret < 0) {
581 /* if error, simply ignore because another packet
582 may be OK */
583 break;
584 }
585 if (got_picture) {
586 /* we got the parameters - now we can stop
587 examining this stream */
588 /* XXX: add a codec info so that we can decide if
589 the codec can repeat frames */
590 if (st->codec.codec_id == CODEC_ID_MPEG1VIDEO &&
591 ic->iformat != &mpegts_demux &&
592 st->codec.sub_id == 2) {
593 /* for mpeg2 video, we want to know the real
594 frame rate, so we decode 40 frames. In mpeg
595 TS case we do not do it because it would be
596 too long */
597 st->codec_info_nb_real_frames++;
598 st->codec_info_nb_repeat_frames += st->codec.repeat_pict;
599#if 0
600 /* XXX: testing */
601 if ((st->codec_info_nb_real_frames % 24) == 23) {
602 st->codec_info_nb_repeat_frames += 2;
603 }
604#endif
605 /* stop after 40 frames */
606 if (st->codec_info_nb_real_frames >= 40) {
607 st->r_frame_rate = (st->codec.frame_rate *
608 st->codec_info_nb_real_frames) /
609 (st->codec_info_nb_real_frames +
610 (st->codec_info_nb_repeat_frames >> 1));
611 goto close_codec;
612 }
613 } else {
614 close_codec:
615 st->codec_info_state = CSTATE_FOUND;
616 avcodec_close(&st->codec);
24f9709b 617 break;
b9a281db 618 }
b9a281db
FB
619 }
620 ptr += ret;
621 size -= ret;
622 }
623 }
624 count++;
625 }
626
627 /* close each codec if there are opened */
628 for(i=0;i<ic->nb_streams;i++) {
629 st = ic->streams[i];
630 if (st->codec_info_state == CSTATE_DECODING)
631 avcodec_close(&st->codec);
632 }
633
634 /* set real frame rate info */
635 for(i=0;i<ic->nb_streams;i++) {
636 st = ic->streams[i];
637 if (st->codec.codec_type == CODEC_TYPE_VIDEO) {
638 if (!st->r_frame_rate)
639 st->r_frame_rate = st->codec.frame_rate;
640 }
de6d9b64 641 }
b9a281db
FB
642
643 return ret;
de6d9b64
FB
644}
645
b9a281db
FB
646/**
647 * Close a media file (but not its codecs)
648 *
649 * @param s media file handle
650 */
de6d9b64
FB
651void av_close_input_file(AVFormatContext *s)
652{
653 int i;
654
b9a281db
FB
655 if (s->iformat->read_close)
656 s->iformat->read_close(s);
de6d9b64 657 for(i=0;i<s->nb_streams;i++) {
1ea4f593 658 av_free(s->streams[i]);
de6d9b64
FB
659 }
660 if (s->packet_buffer) {
661 AVPacketList *p, *p1;
662 p = s->packet_buffer;
663 while (p != NULL) {
664 p1 = p->next;
665 av_free_packet(&p->pkt);
1ea4f593 666 av_free(p);
de6d9b64
FB
667 p = p1;
668 }
669 s->packet_buffer = NULL;
670 }
b9a281db 671 if (!(s->iformat->flags & AVFMT_NOFILE)) {
96baaa6a
FB
672 url_fclose(&s->pb);
673 }
a8dbe951 674 av_freep(&s->priv_data);
1ea4f593 675 av_free(s);
de6d9b64
FB
676}
677
b9a281db
FB
678/**
679 * Add a new stream to a media file. Can only be called in the
680 * read_header function. If the flag AVFMT_NOHEADER is in the format
681 * description, then new streams can be added in read_packet too.
682 *
683 *
684 * @param s media file handle
685 * @param id file format dependent stream id
686 */
687AVStream *av_new_stream(AVFormatContext *s, int id)
688{
689 AVStream *st;
690
691 if (s->nb_streams >= MAX_STREAMS)
692 return NULL;
693
694 st = av_mallocz(sizeof(AVStream));
695 if (!st)
696 return NULL;
1e491e29
MN
697 avcodec_get_context_defaults(&st->codec);
698
b9a281db
FB
699 st->index = s->nb_streams;
700 st->id = id;
701 s->streams[s->nb_streams++] = st;
702 return st;
703}
704
705/************************************************************/
706/* output media file */
de6d9b64 707
b9a281db
FB
708/**
709 * allocate the stream private data and write the stream header to an
710 * output media file
711 *
712 * @param s media file handle
713 * @return 0 if OK. AVERROR_xxx if error.
714 */
715int av_write_header(AVFormatContext *s)
716{
1e51d801
FB
717 int ret, i;
718 AVStream *st;
719
b9a281db
FB
720 s->priv_data = av_mallocz(s->oformat->priv_data_size);
721 if (!s->priv_data)
722 return AVERROR_NOMEM;
916c80e9
FB
723 /* default pts settings is MPEG like */
724 av_set_pts_info(s, 33, 1, 90000);
1e51d801
FB
725 ret = s->oformat->write_header(s);
726 if (ret < 0)
727 return ret;
728
729 /* init PTS generation */
730 for(i=0;i<s->nb_streams;i++) {
731 st = s->streams[i];
732
733 switch (st->codec.codec_type) {
734 case CODEC_TYPE_AUDIO:
735 av_frac_init(&st->pts, 0, 0,
736 (INT64)s->pts_num * st->codec.sample_rate);
737 break;
738 case CODEC_TYPE_VIDEO:
739 av_frac_init(&st->pts, 0, 0,
740 (INT64)s->pts_num * st->codec.frame_rate);
741 break;
742 default:
743 break;
744 }
745 }
746 return 0;
b9a281db
FB
747}
748
749/**
1e51d801
FB
750 * Write a packet to an output media file. The packet shall contain
751 * one audio or video frame.
b9a281db
FB
752 *
753 * @param s media file handle
1e51d801
FB
754 * @param stream_index stream index
755 * @param buf buffer containing the frame data
756 * @param size size of buffer
d4c0ff91 757 * @return < 0 if error, = 0 if OK, 1 if end of stream wanted.
b9a281db 758 */
1e51d801
FB
759int av_write_frame(AVFormatContext *s, int stream_index, const uint8_t *buf,
760 int size)
de6d9b64 761{
1e51d801
FB
762 AVStream *st;
763 INT64 pts_mask;
7feb950a 764 int ret, frame_size;
1e51d801
FB
765
766 st = s->streams[stream_index];
767 pts_mask = (1LL << s->pts_wrap_bits) - 1;
768 ret = s->oformat->write_packet(s, stream_index, (uint8_t *)buf, size,
769 st->pts.val & pts_mask);
770 if (ret < 0)
771 return ret;
772
773 /* update pts */
774 switch (st->codec.codec_type) {
775 case CODEC_TYPE_AUDIO:
7feb950a
FB
776 if (st->codec.frame_size <= 1) {
777 frame_size = size / st->codec.channels;
778 /* specific hack for pcm codecs because no frame size is provided */
50d5d129 779 switch(st->codec.codec_id) {
7feb950a
FB
780 case CODEC_ID_PCM_S16LE:
781 case CODEC_ID_PCM_S16BE:
782 case CODEC_ID_PCM_U16LE:
783 case CODEC_ID_PCM_U16BE:
784 frame_size >>= 1;
785 break;
786 default:
787 break;
788 }
789 } else {
790 frame_size = st->codec.frame_size;
791 }
1e51d801 792 av_frac_add(&st->pts,
7feb950a 793 (INT64)s->pts_den * frame_size);
1e51d801
FB
794 break;
795 case CODEC_TYPE_VIDEO:
796 av_frac_add(&st->pts,
797 (INT64)s->pts_den * FRAME_RATE_BASE);
798 break;
799 default:
800 break;
801 }
d4c0ff91 802 return ret;
b9a281db
FB
803}
804
805/**
806 * write the stream trailer to an output media file and and free the
807 * file private data.
808 *
809 * @param s media file handle
810 * @return 0 if OK. AVERROR_xxx if error. */
811int av_write_trailer(AVFormatContext *s)
812{
813 int ret;
814 ret = s->oformat->write_trailer(s);
815 av_freep(&s->priv_data);
816 return ret;
de6d9b64
FB
817}
818
819/* "user interface" functions */
820
821void dump_format(AVFormatContext *ic,
822 int index,
823 const char *url,
824 int is_output)
825{
b9a281db 826 int i, flags;
de6d9b64
FB
827 char buf[256];
828
829 fprintf(stderr, "%s #%d, %s, %s '%s':\n",
830 is_output ? "Output" : "Input",
b9a281db
FB
831 index,
832 is_output ? ic->oformat->name : ic->iformat->name,
de6d9b64
FB
833 is_output ? "to" : "from", url);
834 for(i=0;i<ic->nb_streams;i++) {
835 AVStream *st = ic->streams[i];
836 avcodec_string(buf, sizeof(buf), &st->codec, is_output);
b9a281db
FB
837 fprintf(stderr, " Stream #%d.%d", index, i);
838 /* the pid is an important information, so we display it */
839 /* XXX: add a generic system */
840 if (is_output)
841 flags = ic->oformat->flags;
842 else
843 flags = ic->iformat->flags;
844 if (flags & AVFMT_SHOW_IDS) {
845 fprintf(stderr, "[0x%x]", st->id);
846 }
847 fprintf(stderr, ": %s\n", buf);
de6d9b64
FB
848 }
849}
850
851typedef struct {
852 const char *str;
853 int width, height;
854} SizeEntry;
855
856static SizeEntry sizes[] = {
857 { "sqcif", 128, 96 },
858 { "qcif", 176, 144 },
859 { "cif", 352, 288 },
860 { "4cif", 704, 576 },
861};
862
863int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
864{
865 int i;
866 int n = sizeof(sizes) / sizeof(SizeEntry);
867 const char *p;
868 int frame_width = 0, frame_height = 0;
869
870 for(i=0;i<n;i++) {
871 if (!strcmp(sizes[i].str, str)) {
872 frame_width = sizes[i].width;
873 frame_height = sizes[i].height;
874 break;
875 }
876 }
877 if (i == n) {
878 p = str;
879 frame_width = strtol(p, (char **)&p, 10);
880 if (*p)
881 p++;
882 frame_height = strtol(p, (char **)&p, 10);
883 }
884 if (frame_width <= 0 || frame_height <= 0)
885 return -1;
886 *width_ptr = frame_width;
887 *height_ptr = frame_height;
888 return 0;
889}
890
a25e098d 891INT64 av_gettime(void)
de6d9b64 892{
8be1c656
FB
893#ifdef CONFIG_WIN32
894 struct _timeb tb;
895 _ftime(&tb);
896 return ((INT64)tb.time * INT64_C(1000) + (INT64)tb.millitm) * INT64_C(1000);
897#else
de6d9b64
FB
898 struct timeval tv;
899 gettimeofday(&tv,NULL);
900 return (INT64)tv.tv_sec * 1000000 + tv.tv_usec;
8be1c656 901#endif
de6d9b64
FB
902}
903
c5510dd6
PG
904static time_t mktimegm(struct tm *tm)
905{
906 time_t t;
907
908 int y = tm->tm_year + 1900, m = tm->tm_mon + 1, d = tm->tm_mday;
909
910 if (m < 3) {
911 m += 12;
912 y--;
913 }
914
915 t = 86400 *
916 (d + (153 * m - 457) / 5 + 365 * y + y / 4 - y / 100 + y / 400 - 719469);
917
918 t += 3600 * tm->tm_hour + 60 * tm->tm_min + tm->tm_sec;
919
920 return t;
921}
922
916c80e9
FB
923/* Syntax:
924 * - If not a duration:
925 * [{YYYY-MM-DD|YYYYMMDD}]{T| }{HH[:MM[:SS[.m...]]][Z]|HH[MM[SS[.m...]]][Z]}
c5510dd6 926 * Time is localtime unless Z is suffixed to the end. In this case GMT
916c80e9
FB
927 * Return the date in micro seconds since 1970
928 * - If duration:
929 * HH[:MM[:SS[.m...]]]
930 * S+[.m...]
931 */
de6d9b64
FB
932INT64 parse_date(const char *datestr, int duration)
933{
934 const char *p;
935 INT64 t;
2dbceb9f 936 struct tm dt;
c5510dd6
PG
937 int i;
938 static const char *date_fmt[] = {
939 "%Y-%m-%d",
940 "%Y%m%d",
941 };
942 static const char *time_fmt[] = {
943 "%H:%M:%S",
944 "%H%M%S",
945 };
946 const char *q;
916c80e9 947 int is_utc, len;
c5510dd6
PG
948 char lastch;
949 time_t now = time(0);
950
916c80e9
FB
951 len = strlen(datestr);
952 if (len > 0)
953 lastch = datestr[len - 1];
954 else
955 lastch = '\0';
c5510dd6 956 is_utc = (lastch == 'z' || lastch == 'Z');
2dbceb9f
PG
957
958 memset(&dt, 0, sizeof(dt));
de6d9b64
FB
959
960 p = datestr;
916c80e9 961 q = NULL;
de6d9b64 962 if (!duration) {
c5510dd6
PG
963 for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
964 q = strptime(p, date_fmt[i], &dt);
965 if (q) {
966 break;
967 }
968 }
969
970 if (!q) {
971 if (is_utc) {
972 dt = *gmtime(&now);
973 } else {
974 dt = *localtime(&now);
975 }
976 dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
de6d9b64 977 } else {
c5510dd6 978 p = q;
de6d9b64 979 }
c5510dd6
PG
980
981 if (*p == 'T' || *p == 't' || *p == ' ')
982 p++;
c5510dd6 983
916c80e9
FB
984 for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
985 q = strptime(p, time_fmt[i], &dt);
986 if (q) {
987 break;
988 }
989 }
990 } else {
991 q = strptime(p, time_fmt[0], &dt);
992 if (!q) {
993 dt.tm_sec = strtol(p, (char **)&q, 10);
994 dt.tm_min = 0;
995 dt.tm_hour = 0;
c5510dd6
PG
996 }
997 }
998
999 /* Now we have all the fields that we can get */
1000 if (!q) {
1001 if (duration)
1002 return 0;
1003 else
1004 return now * INT64_C(1000000);
de6d9b64 1005 }
2dbceb9f
PG
1006
1007 if (duration) {
c5510dd6 1008 t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2dbceb9f 1009 } else {
c5510dd6
PG
1010 dt.tm_isdst = -1; /* unknown */
1011 if (is_utc) {
1012 t = mktimegm(&dt);
1013 } else {
1014 t = mktime(&dt);
1015 }
de6d9b64 1016 }
2dbceb9f 1017
c5510dd6
PG
1018 t *= 1000000;
1019
1020 if (*q == '.') {
de6d9b64 1021 int val, n;
c5510dd6
PG
1022 q++;
1023 for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
1024 if (!isdigit(*q))
1025 break;
1026 val += n * (*q - '0');
de6d9b64
FB
1027 }
1028 t += val;
1029 }
1030 return t;
1031}
1032
2dbceb9f 1033/* syntax: '?tag1=val1&tag2=val2...'. Little URL decoding is done. Return
de6d9b64
FB
1034 1 if found */
1035int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
1036{
1037 const char *p;
1038 char tag[128], *q;
1039
1040 p = info;
1041 if (*p == '?')
1042 p++;
1043 for(;;) {
1044 q = tag;
1045 while (*p != '\0' && *p != '=' && *p != '&') {
1046 if ((q - tag) < sizeof(tag) - 1)
1047 *q++ = *p;
1048 p++;
1049 }
1050 *q = '\0';
1051 q = arg;
1052 if (*p == '=') {
1053 p++;
1054 while (*p != '&' && *p != '\0') {
2dbceb9f
PG
1055 if ((q - arg) < arg_size - 1) {
1056 if (*p == '+')
1057 *q++ = ' ';
1058 else
1059 *q++ = *p;
1060 }
de6d9b64
FB
1061 p++;
1062 }
1063 *q = '\0';
1064 }
1065 if (!strcmp(tag, tag1))
1066 return 1;
1067 if (*p != '&')
1068 break;
8d1335ea 1069 p++;
de6d9b64
FB
1070 }
1071 return 0;
1072}
1073
9150f42e
FB
1074/* Return in 'buf' the path with '%d' replaced by number. Also handles
1075 the '%0nd' format where 'n' is the total number of digits and
1076 '%%'. Return 0 if OK, and -1 if format error */
1077int get_frame_filename(char *buf, int buf_size,
1078 const char *path, int number)
1079{
1080 const char *p;
1081 char *q, buf1[20];
1082 int nd, len, c, percentd_found;
1083
1084 q = buf;
1085 p = path;
1086 percentd_found = 0;
1087 for(;;) {
1088 c = *p++;
1089 if (c == '\0')
1090 break;
1091 if (c == '%') {
c9646fda
PG
1092 do {
1093 nd = 0;
1094 while (isdigit(*p)) {
1095 nd = nd * 10 + *p++ - '0';
1096 }
1097 c = *p++;
1098 if (c == '*' && nd > 0) {
1099 // The nd field is actually the modulus
1100 number = number % nd;
1101 c = *p++;
1102 nd = 0;
1103 }
1104 } while (isdigit(c));
1105
9150f42e
FB
1106 switch(c) {
1107 case '%':
1108 goto addchar;
1109 case 'd':
1110 if (percentd_found)
1111 goto fail;
1112 percentd_found = 1;
1113 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
1114 len = strlen(buf1);
1115 if ((q - buf + len) > buf_size - 1)
1116 goto fail;
1117 memcpy(q, buf1, len);
1118 q += len;
1119 break;
1120 default:
1121 goto fail;
1122 }
1123 } else {
1124 addchar:
1125 if ((q - buf) < buf_size - 1)
1126 *q++ = c;
1127 }
1128 }
1129 if (!percentd_found)
1130 goto fail;
1131 *q = '\0';
1132 return 0;
1133 fail:
1134 *q = '\0';
1135 return -1;
1136}
1137
b9a281db
FB
1138/**
1139 *
1140 * Print on stdout a nice hexa dump of a buffer
1141 * @param buf buffer
1142 * @param size buffer size
1143 */
1144void av_hex_dump(UINT8 *buf, int size)
1145{
1146 int len, i, j, c;
1147
1148 for(i=0;i<size;i+=16) {
1149 len = size - i;
1150 if (len > 16)
1151 len = 16;
1152 printf("%08x ", i);
1153 for(j=0;j<16;j++) {
1154 if (j < len)
1155 printf(" %02x", buf[i+j]);
1156 else
1157 printf(" ");
1158 }
1159 printf(" ");
1160 for(j=0;j<len;j++) {
1161 c = buf[i+j];
1162 if (c < ' ' || c > '~')
1163 c = '.';
1164 printf("%c", c);
1165 }
1166 printf("\n");
1167 }
1168}
1169
a9a721da
FB
1170void url_split(char *proto, int proto_size,
1171 char *hostname, int hostname_size,
1172 int *port_ptr,
1173 char *path, int path_size,
1174 const char *url)
1175{
1176 const char *p;
1177 char *q;
1178 int port;
1179
1180 port = -1;
1181
1182 p = url;
1183 q = proto;
1184 while (*p != ':' && *p != '\0') {
1185 if ((q - proto) < proto_size - 1)
1186 *q++ = *p;
1187 p++;
1188 }
1189 if (proto_size > 0)
1190 *q = '\0';
1191 if (*p == '\0') {
1192 if (proto_size > 0)
1193 proto[0] = '\0';
1194 if (hostname_size > 0)
1195 hostname[0] = '\0';
1196 p = url;
1197 } else {
1198 p++;
1199 if (*p == '/')
1200 p++;
1201 if (*p == '/')
1202 p++;
1203 q = hostname;
1204 while (*p != ':' && *p != '/' && *p != '?' && *p != '\0') {
1205 if ((q - hostname) < hostname_size - 1)
1206 *q++ = *p;
1207 p++;
1208 }
1209 if (hostname_size > 0)
1210 *q = '\0';
1211 if (*p == ':') {
1212 p++;
1213 port = strtoul(p, (char **)&p, 10);
1214 }
1215 }
1216 if (port_ptr)
1217 *port_ptr = port;
1218 pstrcpy(path, path_size, p);
1219}
1220
916c80e9
FB
1221/**
1222 * Set the pts for a given stream
1223 * @param s stream
1224 * @param pts_wrap_bits number of bits effectively used by the pts
1225 * (used for wrap control, 33 is the value for MPEG)
1226 * @param pts_num numerator to convert to seconds (MPEG: 1)
1227 * @param pts_den denominator to convert to seconds (MPEG: 90000)
1228 */
1229void av_set_pts_info(AVFormatContext *s, int pts_wrap_bits,
1230 int pts_num, int pts_den)
1231{
1232 s->pts_wrap_bits = pts_wrap_bits;
1233 s->pts_num = pts_num;
1234 s->pts_den = pts_den;
1235}
1236
1237/* fraction handling */
1238
1239/**
1240 * f = val + (num / den) + 0.5. 'num' is normalized so that it is such
1241 * as 0 <= num < den.
1242 *
1243 * @param f fractional number
1244 * @param val integer value
1245 * @param num must be >= 0
1246 * @param den must be >= 1
1247 */
1248void av_frac_init(AVFrac *f, INT64 val, INT64 num, INT64 den)
1249{
1250 num += (den >> 1);
1251 if (num >= den) {
1252 val += num / den;
1253 num = num % den;
1254 }
1255 f->val = val;
1256 f->num = num;
1257 f->den = den;
1258}
1259
1260/* set f to (val + 0.5) */
1261void av_frac_set(AVFrac *f, INT64 val)
1262{
1263 f->val = val;
1264 f->num = f->den >> 1;
1265}
1266
1267/**
1268 * Fractionnal addition to f: f = f + (incr / f->den)
1269 *
1270 * @param f fractional number
1271 * @param incr increment, can be positive or negative
1272 */
1273void av_frac_add(AVFrac *f, INT64 incr)
1274{
1275 INT64 num, den;
1276
1277 num = f->num + incr;
1278 den = f->den;
1279 if (num < 0) {
1280 f->val += num / den;
1281 num = num % den;
1282 if (num < 0) {
1283 num += den;
1284 f->val--;
1285 }
1286 } else if (num >= den) {
1287 f->val += num / den;
1288 num = num % den;
1289 }
1290 f->num = num;
1291}