use codec_id so that the codec does not need to be opened
[libav.git] / libav / 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;
461 AVPicture picture;
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;
697 st->index = s->nb_streams;
698 st->id = id;
699 s->streams[s->nb_streams++] = st;
700 return st;
701}
702
703/************************************************************/
704/* output media file */
de6d9b64 705
b9a281db
FB
706/**
707 * allocate the stream private data and write the stream header to an
708 * output media file
709 *
710 * @param s media file handle
711 * @return 0 if OK. AVERROR_xxx if error.
712 */
713int av_write_header(AVFormatContext *s)
714{
1e51d801
FB
715 int ret, i;
716 AVStream *st;
717
b9a281db
FB
718 s->priv_data = av_mallocz(s->oformat->priv_data_size);
719 if (!s->priv_data)
720 return AVERROR_NOMEM;
916c80e9
FB
721 /* default pts settings is MPEG like */
722 av_set_pts_info(s, 33, 1, 90000);
1e51d801
FB
723 ret = s->oformat->write_header(s);
724 if (ret < 0)
725 return ret;
726
727 /* init PTS generation */
728 for(i=0;i<s->nb_streams;i++) {
729 st = s->streams[i];
730
731 switch (st->codec.codec_type) {
732 case CODEC_TYPE_AUDIO:
733 av_frac_init(&st->pts, 0, 0,
734 (INT64)s->pts_num * st->codec.sample_rate);
735 break;
736 case CODEC_TYPE_VIDEO:
737 av_frac_init(&st->pts, 0, 0,
738 (INT64)s->pts_num * st->codec.frame_rate);
739 break;
740 default:
741 break;
742 }
743 }
744 return 0;
b9a281db
FB
745}
746
747/**
1e51d801
FB
748 * Write a packet to an output media file. The packet shall contain
749 * one audio or video frame.
b9a281db
FB
750 *
751 * @param s media file handle
1e51d801
FB
752 * @param stream_index stream index
753 * @param buf buffer containing the frame data
754 * @param size size of buffer
d4c0ff91 755 * @return < 0 if error, = 0 if OK, 1 if end of stream wanted.
b9a281db 756 */
1e51d801
FB
757int av_write_frame(AVFormatContext *s, int stream_index, const uint8_t *buf,
758 int size)
de6d9b64 759{
1e51d801
FB
760 AVStream *st;
761 INT64 pts_mask;
7feb950a 762 int ret, frame_size;
1e51d801
FB
763
764 st = s->streams[stream_index];
765 pts_mask = (1LL << s->pts_wrap_bits) - 1;
766 ret = s->oformat->write_packet(s, stream_index, (uint8_t *)buf, size,
767 st->pts.val & pts_mask);
768 if (ret < 0)
769 return ret;
770
771 /* update pts */
772 switch (st->codec.codec_type) {
773 case CODEC_TYPE_AUDIO:
7feb950a
FB
774 if (st->codec.frame_size <= 1) {
775 frame_size = size / st->codec.channels;
776 /* specific hack for pcm codecs because no frame size is provided */
50d5d129 777 switch(st->codec.codec_id) {
7feb950a
FB
778 case CODEC_ID_PCM_S16LE:
779 case CODEC_ID_PCM_S16BE:
780 case CODEC_ID_PCM_U16LE:
781 case CODEC_ID_PCM_U16BE:
782 frame_size >>= 1;
783 break;
784 default:
785 break;
786 }
787 } else {
788 frame_size = st->codec.frame_size;
789 }
1e51d801 790 av_frac_add(&st->pts,
7feb950a 791 (INT64)s->pts_den * frame_size);
1e51d801
FB
792 break;
793 case CODEC_TYPE_VIDEO:
794 av_frac_add(&st->pts,
795 (INT64)s->pts_den * FRAME_RATE_BASE);
796 break;
797 default:
798 break;
799 }
d4c0ff91 800 return ret;
b9a281db
FB
801}
802
803/**
804 * write the stream trailer to an output media file and and free the
805 * file private data.
806 *
807 * @param s media file handle
808 * @return 0 if OK. AVERROR_xxx if error. */
809int av_write_trailer(AVFormatContext *s)
810{
811 int ret;
812 ret = s->oformat->write_trailer(s);
813 av_freep(&s->priv_data);
814 return ret;
de6d9b64
FB
815}
816
817/* "user interface" functions */
818
819void dump_format(AVFormatContext *ic,
820 int index,
821 const char *url,
822 int is_output)
823{
b9a281db 824 int i, flags;
de6d9b64
FB
825 char buf[256];
826
827 fprintf(stderr, "%s #%d, %s, %s '%s':\n",
828 is_output ? "Output" : "Input",
b9a281db
FB
829 index,
830 is_output ? ic->oformat->name : ic->iformat->name,
de6d9b64
FB
831 is_output ? "to" : "from", url);
832 for(i=0;i<ic->nb_streams;i++) {
833 AVStream *st = ic->streams[i];
834 avcodec_string(buf, sizeof(buf), &st->codec, is_output);
b9a281db
FB
835 fprintf(stderr, " Stream #%d.%d", index, i);
836 /* the pid is an important information, so we display it */
837 /* XXX: add a generic system */
838 if (is_output)
839 flags = ic->oformat->flags;
840 else
841 flags = ic->iformat->flags;
842 if (flags & AVFMT_SHOW_IDS) {
843 fprintf(stderr, "[0x%x]", st->id);
844 }
845 fprintf(stderr, ": %s\n", buf);
de6d9b64
FB
846 }
847}
848
849typedef struct {
850 const char *str;
851 int width, height;
852} SizeEntry;
853
854static SizeEntry sizes[] = {
855 { "sqcif", 128, 96 },
856 { "qcif", 176, 144 },
857 { "cif", 352, 288 },
858 { "4cif", 704, 576 },
859};
860
861int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
862{
863 int i;
864 int n = sizeof(sizes) / sizeof(SizeEntry);
865 const char *p;
866 int frame_width = 0, frame_height = 0;
867
868 for(i=0;i<n;i++) {
869 if (!strcmp(sizes[i].str, str)) {
870 frame_width = sizes[i].width;
871 frame_height = sizes[i].height;
872 break;
873 }
874 }
875 if (i == n) {
876 p = str;
877 frame_width = strtol(p, (char **)&p, 10);
878 if (*p)
879 p++;
880 frame_height = strtol(p, (char **)&p, 10);
881 }
882 if (frame_width <= 0 || frame_height <= 0)
883 return -1;
884 *width_ptr = frame_width;
885 *height_ptr = frame_height;
886 return 0;
887}
888
a25e098d 889INT64 av_gettime(void)
de6d9b64 890{
8be1c656
FB
891#ifdef CONFIG_WIN32
892 struct _timeb tb;
893 _ftime(&tb);
894 return ((INT64)tb.time * INT64_C(1000) + (INT64)tb.millitm) * INT64_C(1000);
895#else
de6d9b64
FB
896 struct timeval tv;
897 gettimeofday(&tv,NULL);
898 return (INT64)tv.tv_sec * 1000000 + tv.tv_usec;
8be1c656 899#endif
de6d9b64
FB
900}
901
c5510dd6
PG
902static time_t mktimegm(struct tm *tm)
903{
904 time_t t;
905
906 int y = tm->tm_year + 1900, m = tm->tm_mon + 1, d = tm->tm_mday;
907
908 if (m < 3) {
909 m += 12;
910 y--;
911 }
912
913 t = 86400 *
914 (d + (153 * m - 457) / 5 + 365 * y + y / 4 - y / 100 + y / 400 - 719469);
915
916 t += 3600 * tm->tm_hour + 60 * tm->tm_min + tm->tm_sec;
917
918 return t;
919}
920
916c80e9
FB
921/* Syntax:
922 * - If not a duration:
923 * [{YYYY-MM-DD|YYYYMMDD}]{T| }{HH[:MM[:SS[.m...]]][Z]|HH[MM[SS[.m...]]][Z]}
c5510dd6 924 * Time is localtime unless Z is suffixed to the end. In this case GMT
916c80e9
FB
925 * Return the date in micro seconds since 1970
926 * - If duration:
927 * HH[:MM[:SS[.m...]]]
928 * S+[.m...]
929 */
de6d9b64
FB
930INT64 parse_date(const char *datestr, int duration)
931{
932 const char *p;
933 INT64 t;
2dbceb9f 934 struct tm dt;
c5510dd6
PG
935 int i;
936 static const char *date_fmt[] = {
937 "%Y-%m-%d",
938 "%Y%m%d",
939 };
940 static const char *time_fmt[] = {
941 "%H:%M:%S",
942 "%H%M%S",
943 };
944 const char *q;
916c80e9 945 int is_utc, len;
c5510dd6
PG
946 char lastch;
947 time_t now = time(0);
948
916c80e9
FB
949 len = strlen(datestr);
950 if (len > 0)
951 lastch = datestr[len - 1];
952 else
953 lastch = '\0';
c5510dd6 954 is_utc = (lastch == 'z' || lastch == 'Z');
2dbceb9f
PG
955
956 memset(&dt, 0, sizeof(dt));
de6d9b64
FB
957
958 p = datestr;
916c80e9 959 q = NULL;
de6d9b64 960 if (!duration) {
c5510dd6
PG
961 for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
962 q = strptime(p, date_fmt[i], &dt);
963 if (q) {
964 break;
965 }
966 }
967
968 if (!q) {
969 if (is_utc) {
970 dt = *gmtime(&now);
971 } else {
972 dt = *localtime(&now);
973 }
974 dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
de6d9b64 975 } else {
c5510dd6 976 p = q;
de6d9b64 977 }
c5510dd6
PG
978
979 if (*p == 'T' || *p == 't' || *p == ' ')
980 p++;
c5510dd6 981
916c80e9
FB
982 for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
983 q = strptime(p, time_fmt[i], &dt);
984 if (q) {
985 break;
986 }
987 }
988 } else {
989 q = strptime(p, time_fmt[0], &dt);
990 if (!q) {
991 dt.tm_sec = strtol(p, (char **)&q, 10);
992 dt.tm_min = 0;
993 dt.tm_hour = 0;
c5510dd6
PG
994 }
995 }
996
997 /* Now we have all the fields that we can get */
998 if (!q) {
999 if (duration)
1000 return 0;
1001 else
1002 return now * INT64_C(1000000);
de6d9b64 1003 }
2dbceb9f
PG
1004
1005 if (duration) {
c5510dd6 1006 t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2dbceb9f 1007 } else {
c5510dd6
PG
1008 dt.tm_isdst = -1; /* unknown */
1009 if (is_utc) {
1010 t = mktimegm(&dt);
1011 } else {
1012 t = mktime(&dt);
1013 }
de6d9b64 1014 }
2dbceb9f 1015
c5510dd6
PG
1016 t *= 1000000;
1017
1018 if (*q == '.') {
de6d9b64 1019 int val, n;
c5510dd6
PG
1020 q++;
1021 for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
1022 if (!isdigit(*q))
1023 break;
1024 val += n * (*q - '0');
de6d9b64
FB
1025 }
1026 t += val;
1027 }
1028 return t;
1029}
1030
2dbceb9f 1031/* syntax: '?tag1=val1&tag2=val2...'. Little URL decoding is done. Return
de6d9b64
FB
1032 1 if found */
1033int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
1034{
1035 const char *p;
1036 char tag[128], *q;
1037
1038 p = info;
1039 if (*p == '?')
1040 p++;
1041 for(;;) {
1042 q = tag;
1043 while (*p != '\0' && *p != '=' && *p != '&') {
1044 if ((q - tag) < sizeof(tag) - 1)
1045 *q++ = *p;
1046 p++;
1047 }
1048 *q = '\0';
1049 q = arg;
1050 if (*p == '=') {
1051 p++;
1052 while (*p != '&' && *p != '\0') {
2dbceb9f
PG
1053 if ((q - arg) < arg_size - 1) {
1054 if (*p == '+')
1055 *q++ = ' ';
1056 else
1057 *q++ = *p;
1058 }
de6d9b64
FB
1059 p++;
1060 }
1061 *q = '\0';
1062 }
1063 if (!strcmp(tag, tag1))
1064 return 1;
1065 if (*p != '&')
1066 break;
8d1335ea 1067 p++;
de6d9b64
FB
1068 }
1069 return 0;
1070}
1071
9150f42e
FB
1072/* Return in 'buf' the path with '%d' replaced by number. Also handles
1073 the '%0nd' format where 'n' is the total number of digits and
1074 '%%'. Return 0 if OK, and -1 if format error */
1075int get_frame_filename(char *buf, int buf_size,
1076 const char *path, int number)
1077{
1078 const char *p;
1079 char *q, buf1[20];
1080 int nd, len, c, percentd_found;
1081
1082 q = buf;
1083 p = path;
1084 percentd_found = 0;
1085 for(;;) {
1086 c = *p++;
1087 if (c == '\0')
1088 break;
1089 if (c == '%') {
1090 nd = 0;
1091 while (*p >= '0' && *p <= '9') {
1092 nd = nd * 10 + *p++ - '0';
1093 }
1094 c = *p++;
1095 switch(c) {
1096 case '%':
1097 goto addchar;
1098 case 'd':
1099 if (percentd_found)
1100 goto fail;
1101 percentd_found = 1;
1102 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
1103 len = strlen(buf1);
1104 if ((q - buf + len) > buf_size - 1)
1105 goto fail;
1106 memcpy(q, buf1, len);
1107 q += len;
1108 break;
1109 default:
1110 goto fail;
1111 }
1112 } else {
1113 addchar:
1114 if ((q - buf) < buf_size - 1)
1115 *q++ = c;
1116 }
1117 }
1118 if (!percentd_found)
1119 goto fail;
1120 *q = '\0';
1121 return 0;
1122 fail:
1123 *q = '\0';
1124 return -1;
1125}
1126
b9a281db
FB
1127/**
1128 *
1129 * Print on stdout a nice hexa dump of a buffer
1130 * @param buf buffer
1131 * @param size buffer size
1132 */
1133void av_hex_dump(UINT8 *buf, int size)
1134{
1135 int len, i, j, c;
1136
1137 for(i=0;i<size;i+=16) {
1138 len = size - i;
1139 if (len > 16)
1140 len = 16;
1141 printf("%08x ", i);
1142 for(j=0;j<16;j++) {
1143 if (j < len)
1144 printf(" %02x", buf[i+j]);
1145 else
1146 printf(" ");
1147 }
1148 printf(" ");
1149 for(j=0;j<len;j++) {
1150 c = buf[i+j];
1151 if (c < ' ' || c > '~')
1152 c = '.';
1153 printf("%c", c);
1154 }
1155 printf("\n");
1156 }
1157}
1158
a9a721da
FB
1159void url_split(char *proto, int proto_size,
1160 char *hostname, int hostname_size,
1161 int *port_ptr,
1162 char *path, int path_size,
1163 const char *url)
1164{
1165 const char *p;
1166 char *q;
1167 int port;
1168
1169 port = -1;
1170
1171 p = url;
1172 q = proto;
1173 while (*p != ':' && *p != '\0') {
1174 if ((q - proto) < proto_size - 1)
1175 *q++ = *p;
1176 p++;
1177 }
1178 if (proto_size > 0)
1179 *q = '\0';
1180 if (*p == '\0') {
1181 if (proto_size > 0)
1182 proto[0] = '\0';
1183 if (hostname_size > 0)
1184 hostname[0] = '\0';
1185 p = url;
1186 } else {
1187 p++;
1188 if (*p == '/')
1189 p++;
1190 if (*p == '/')
1191 p++;
1192 q = hostname;
1193 while (*p != ':' && *p != '/' && *p != '?' && *p != '\0') {
1194 if ((q - hostname) < hostname_size - 1)
1195 *q++ = *p;
1196 p++;
1197 }
1198 if (hostname_size > 0)
1199 *q = '\0';
1200 if (*p == ':') {
1201 p++;
1202 port = strtoul(p, (char **)&p, 10);
1203 }
1204 }
1205 if (port_ptr)
1206 *port_ptr = port;
1207 pstrcpy(path, path_size, p);
1208}
1209
916c80e9
FB
1210/**
1211 * Set the pts for a given stream
1212 * @param s stream
1213 * @param pts_wrap_bits number of bits effectively used by the pts
1214 * (used for wrap control, 33 is the value for MPEG)
1215 * @param pts_num numerator to convert to seconds (MPEG: 1)
1216 * @param pts_den denominator to convert to seconds (MPEG: 90000)
1217 */
1218void av_set_pts_info(AVFormatContext *s, int pts_wrap_bits,
1219 int pts_num, int pts_den)
1220{
1221 s->pts_wrap_bits = pts_wrap_bits;
1222 s->pts_num = pts_num;
1223 s->pts_den = pts_den;
1224}
1225
1226/* fraction handling */
1227
1228/**
1229 * f = val + (num / den) + 0.5. 'num' is normalized so that it is such
1230 * as 0 <= num < den.
1231 *
1232 * @param f fractional number
1233 * @param val integer value
1234 * @param num must be >= 0
1235 * @param den must be >= 1
1236 */
1237void av_frac_init(AVFrac *f, INT64 val, INT64 num, INT64 den)
1238{
1239 num += (den >> 1);
1240 if (num >= den) {
1241 val += num / den;
1242 num = num % den;
1243 }
1244 f->val = val;
1245 f->num = num;
1246 f->den = den;
1247}
1248
1249/* set f to (val + 0.5) */
1250void av_frac_set(AVFrac *f, INT64 val)
1251{
1252 f->val = val;
1253 f->num = f->den >> 1;
1254}
1255
1256/**
1257 * Fractionnal addition to f: f = f + (incr / f->den)
1258 *
1259 * @param f fractional number
1260 * @param incr increment, can be positive or negative
1261 */
1262void av_frac_add(AVFrac *f, INT64 incr)
1263{
1264 INT64 num, den;
1265
1266 num = f->num + incr;
1267 den = f->den;
1268 if (num < 0) {
1269 f->val += num / den;
1270 num = num % den;
1271 if (num < 0) {
1272 num += den;
1273 f->val--;
1274 }
1275 } else if (num >= den) {
1276 f->val += num / den;
1277 num = num % den;
1278 }
1279 f->num = num;
1280}