use codec_id so that the codec does not need to be opened
[libav.git] / libav / utils.c
1 /*
2 * Various utilities for ffmpeg system
3 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
4 *
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.
9 *
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
14 *
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
18 */
19 #include "avformat.h"
20 #include <ctype.h>
21 #ifndef CONFIG_WIN32
22 #include <unistd.h>
23 #include <fcntl.h>
24 #include <sys/time.h>
25 #else
26 #define strcasecmp _stricmp
27 #include <sys/types.h>
28 #include <sys/timeb.h>
29 #endif
30 #include <time.h>
31
32 #ifndef HAVE_STRPTIME
33 #include "strptime.h"
34 #endif
35
36 AVInputFormat *first_iformat;
37 AVOutputFormat *first_oformat;
38
39 void av_register_input_format(AVInputFormat *format)
40 {
41 AVInputFormat **p;
42 p = &first_iformat;
43 while (*p != NULL) p = &(*p)->next;
44 *p = format;
45 format->next = NULL;
46 }
47
48 void av_register_output_format(AVOutputFormat *format)
49 {
50 AVOutputFormat **p;
51 p = &first_oformat;
52 while (*p != NULL) p = &(*p)->next;
53 *p = format;
54 format->next = NULL;
55 }
56
57 int match_ext(const char *filename, const char *extensions)
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
81 AVOutputFormat *guess_format(const char *short_name, const char *filename,
82 const char *mime_type)
83 {
84 AVOutputFormat *fmt, *fmt_found;
85 int score_max, score;
86
87 /* find the proper file type */
88 fmt_found = NULL;
89 score_max = 0;
90 fmt = first_oformat;
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
110 AVOutputFormat *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
129 AVInputFormat *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
139 /* memory handling */
140
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 */
148 int av_new_packet(AVPacket *pkt, int size)
149 {
150 int i;
151 pkt->data = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
152 if (!pkt->data)
153 return AVERROR_NOMEM;
154 pkt->size = size;
155 /* sane state */
156 pkt->pts = AV_NOPTS_VALUE;
157 pkt->stream_index = 0;
158 pkt->flags = 0;
159
160 for(i=0; i<FF_INPUT_BUFFER_PADDING_SIZE; i++)
161 pkt->data[size+i]= 0;
162
163 return 0;
164 }
165
166 /**
167 * Free a packet
168 *
169 * @param pkt packet to free
170 */
171 void av_free_packet(AVPacket *pkt)
172 {
173 av_freep(&pkt->data);
174 /* fail safe */
175 pkt->size = 0;
176 }
177
178 /* fifo handling */
179
180 int fifo_init(FifoBuffer *f, int size)
181 {
182 f->buffer = av_malloc(size);
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
190 void fifo_free(FifoBuffer *f)
191 {
192 av_free(f->buffer);
193 }
194
195 int 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) */
208 int 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
236 void 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
255 int 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 */
262 AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened)
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;
273 if (fmt1->read_probe) {
274 score = fmt1->read_probe(pd);
275 } else if (fmt1->extensions) {
276 if (match_ext(pd->filename, fmt1->extensions)) {
277 score = 50;
278 }
279 }
280 if (score > score_max) {
281 score_max = score;
282 fmt = fmt1;
283 }
284 }
285 return fmt;
286 }
287
288 /************************************************************/
289 /* input media file */
290
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 */
304 int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
305 AVInputFormat *fmt,
306 int buf_size,
307 AVFormatParameters *ap)
308 {
309 AVFormatContext *ic = NULL;
310 int err;
311 char buf[PROBE_BUF_SIZE];
312 AVProbeData probe_data, *pd = &probe_data;
313
314 ic = av_mallocz(sizeof(AVFormatContext));
315 if (!ic) {
316 err = AVERROR_NOMEM;
317 goto fail;
318 }
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 */
326 fmt = av_probe_input_format(pd, 0);
327 }
328
329 /* if no file needed do not try to open one */
330 if (!fmt || !(fmt->flags & AVFMT_NOFILE)) {
331 if (url_fopen(&ic->pb, filename, URL_RDONLY) < 0) {
332 err = AVERROR_IO;
333 goto fail;
334 }
335 if (buf_size > 0) {
336 url_setbufsize(&ic->pb, buf_size);
337 }
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 }
343 }
344
345 /* guess file format */
346 if (!fmt) {
347 fmt = av_probe_input_format(pd, 1);
348 }
349
350 /* if still no format found, error */
351 if (!fmt) {
352 err = AVERROR_NOFMT;
353 goto fail;
354 }
355
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
364 ic->iformat = fmt;
365
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
373 /* default pts settings is MPEG like */
374 av_set_pts_info(ic, 33, 1, 90000);
375
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 }
393 fail:
394 if (ic) {
395 av_freep(&ic->priv_data);
396 }
397 av_free(ic);
398 *ic_ptr = NULL;
399 return err;
400 }
401
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 */
408 int 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;
417 av_free(pktl);
418 return 0;
419 } else {
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
429 static 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 */
455 int 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) {
551 if(codec->capabilities & CODEC_CAP_TRUNCATED)
552 st->codec.flags |= CODEC_FLAG_TRUNCATED;
553
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);
617 break;
618 }
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 }
641 }
642
643 return ret;
644 }
645
646 /**
647 * Close a media file (but not its codecs)
648 *
649 * @param s media file handle
650 */
651 void av_close_input_file(AVFormatContext *s)
652 {
653 int i;
654
655 if (s->iformat->read_close)
656 s->iformat->read_close(s);
657 for(i=0;i<s->nb_streams;i++) {
658 av_free(s->streams[i]);
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);
666 av_free(p);
667 p = p1;
668 }
669 s->packet_buffer = NULL;
670 }
671 if (!(s->iformat->flags & AVFMT_NOFILE)) {
672 url_fclose(&s->pb);
673 }
674 av_freep(&s->priv_data);
675 av_free(s);
676 }
677
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 */
687 AVStream *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 */
705
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 */
713 int av_write_header(AVFormatContext *s)
714 {
715 int ret, i;
716 AVStream *st;
717
718 s->priv_data = av_mallocz(s->oformat->priv_data_size);
719 if (!s->priv_data)
720 return AVERROR_NOMEM;
721 /* default pts settings is MPEG like */
722 av_set_pts_info(s, 33, 1, 90000);
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;
745 }
746
747 /**
748 * Write a packet to an output media file. The packet shall contain
749 * one audio or video frame.
750 *
751 * @param s media file handle
752 * @param stream_index stream index
753 * @param buf buffer containing the frame data
754 * @param size size of buffer
755 * @return < 0 if error, = 0 if OK, 1 if end of stream wanted.
756 */
757 int av_write_frame(AVFormatContext *s, int stream_index, const uint8_t *buf,
758 int size)
759 {
760 AVStream *st;
761 INT64 pts_mask;
762 int ret, frame_size;
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:
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 */
777 switch(st->codec.codec_id) {
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 }
790 av_frac_add(&st->pts,
791 (INT64)s->pts_den * frame_size);
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 }
800 return ret;
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. */
809 int 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;
815 }
816
817 /* "user interface" functions */
818
819 void dump_format(AVFormatContext *ic,
820 int index,
821 const char *url,
822 int is_output)
823 {
824 int i, flags;
825 char buf[256];
826
827 fprintf(stderr, "%s #%d, %s, %s '%s':\n",
828 is_output ? "Output" : "Input",
829 index,
830 is_output ? ic->oformat->name : ic->iformat->name,
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);
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);
846 }
847 }
848
849 typedef struct {
850 const char *str;
851 int width, height;
852 } SizeEntry;
853
854 static SizeEntry sizes[] = {
855 { "sqcif", 128, 96 },
856 { "qcif", 176, 144 },
857 { "cif", 352, 288 },
858 { "4cif", 704, 576 },
859 };
860
861 int 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
889 INT64 av_gettime(void)
890 {
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
896 struct timeval tv;
897 gettimeofday(&tv,NULL);
898 return (INT64)tv.tv_sec * 1000000 + tv.tv_usec;
899 #endif
900 }
901
902 static 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
921 /* Syntax:
922 * - If not a duration:
923 * [{YYYY-MM-DD|YYYYMMDD}]{T| }{HH[:MM[:SS[.m...]]][Z]|HH[MM[SS[.m...]]][Z]}
924 * Time is localtime unless Z is suffixed to the end. In this case GMT
925 * Return the date in micro seconds since 1970
926 * - If duration:
927 * HH[:MM[:SS[.m...]]]
928 * S+[.m...]
929 */
930 INT64 parse_date(const char *datestr, int duration)
931 {
932 const char *p;
933 INT64 t;
934 struct tm dt;
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;
945 int is_utc, len;
946 char lastch;
947 time_t now = time(0);
948
949 len = strlen(datestr);
950 if (len > 0)
951 lastch = datestr[len - 1];
952 else
953 lastch = '\0';
954 is_utc = (lastch == 'z' || lastch == 'Z');
955
956 memset(&dt, 0, sizeof(dt));
957
958 p = datestr;
959 q = NULL;
960 if (!duration) {
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;
975 } else {
976 p = q;
977 }
978
979 if (*p == 'T' || *p == 't' || *p == ' ')
980 p++;
981
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;
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);
1003 }
1004
1005 if (duration) {
1006 t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
1007 } else {
1008 dt.tm_isdst = -1; /* unknown */
1009 if (is_utc) {
1010 t = mktimegm(&dt);
1011 } else {
1012 t = mktime(&dt);
1013 }
1014 }
1015
1016 t *= 1000000;
1017
1018 if (*q == '.') {
1019 int val, n;
1020 q++;
1021 for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
1022 if (!isdigit(*q))
1023 break;
1024 val += n * (*q - '0');
1025 }
1026 t += val;
1027 }
1028 return t;
1029 }
1030
1031 /* syntax: '?tag1=val1&tag2=val2...'. Little URL decoding is done. Return
1032 1 if found */
1033 int 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') {
1053 if ((q - arg) < arg_size - 1) {
1054 if (*p == '+')
1055 *q++ = ' ';
1056 else
1057 *q++ = *p;
1058 }
1059 p++;
1060 }
1061 *q = '\0';
1062 }
1063 if (!strcmp(tag, tag1))
1064 return 1;
1065 if (*p != '&')
1066 break;
1067 p++;
1068 }
1069 return 0;
1070 }
1071
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 */
1075 int 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
1127 /**
1128 *
1129 * Print on stdout a nice hexa dump of a buffer
1130 * @param buf buffer
1131 * @param size buffer size
1132 */
1133 void 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
1159 void 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
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 */
1218 void 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 */
1237 void 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) */
1250 void 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 */
1262 void 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 }