initial duration/start_time generic support - displays stream duration and average...
[libav.git] / libavformat / 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 #ifdef CONFIG_WIN32
22 #define strcasecmp _stricmp
23 #include <sys/types.h>
24 #include <sys/timeb.h>
25 #elif defined(CONFIG_OS2)
26 #include <string.h>
27 #define strcasecmp stricmp
28 #include <sys/time.h>
29 #else
30 #include <unistd.h>
31 #include <fcntl.h>
32 #include <sys/time.h>
33 #endif
34 #include <time.h>
35
36 #ifndef HAVE_STRPTIME
37 #include "strptime.h"
38 #endif
39
40 AVInputFormat *first_iformat;
41 AVOutputFormat *first_oformat;
42 AVImageFormat *first_image_format;
43
44 void av_register_input_format(AVInputFormat *format)
45 {
46 AVInputFormat **p;
47 p = &first_iformat;
48 while (*p != NULL) p = &(*p)->next;
49 *p = format;
50 format->next = NULL;
51 }
52
53 void av_register_output_format(AVOutputFormat *format)
54 {
55 AVOutputFormat **p;
56 p = &first_oformat;
57 while (*p != NULL) p = &(*p)->next;
58 *p = format;
59 format->next = NULL;
60 }
61
62 int match_ext(const char *filename, const char *extensions)
63 {
64 const char *ext, *p;
65 char ext1[32], *q;
66
67 ext = strrchr(filename, '.');
68 if (ext) {
69 ext++;
70 p = extensions;
71 for(;;) {
72 q = ext1;
73 while (*p != '\0' && *p != ',')
74 *q++ = *p++;
75 *q = '\0';
76 if (!strcasecmp(ext1, ext))
77 return 1;
78 if (*p == '\0')
79 break;
80 p++;
81 }
82 }
83 return 0;
84 }
85
86 AVOutputFormat *guess_format(const char *short_name, const char *filename,
87 const char *mime_type)
88 {
89 AVOutputFormat *fmt, *fmt_found;
90 int score_max, score;
91
92 /* specific test for image sequences */
93 if (!short_name && filename &&
94 filename_number_test(filename) >= 0 &&
95 guess_image_format(filename)) {
96 return guess_format("image", NULL, NULL);
97 }
98
99 /* find the proper file type */
100 fmt_found = NULL;
101 score_max = 0;
102 fmt = first_oformat;
103 while (fmt != NULL) {
104 score = 0;
105 if (fmt->name && short_name && !strcmp(fmt->name, short_name))
106 score += 100;
107 if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
108 score += 10;
109 if (filename && fmt->extensions &&
110 match_ext(filename, fmt->extensions)) {
111 score += 5;
112 }
113 if (score > score_max) {
114 score_max = score;
115 fmt_found = fmt;
116 }
117 fmt = fmt->next;
118 }
119 return fmt_found;
120 }
121
122 AVOutputFormat *guess_stream_format(const char *short_name, const char *filename,
123 const char *mime_type)
124 {
125 AVOutputFormat *fmt = guess_format(short_name, filename, mime_type);
126
127 if (fmt) {
128 AVOutputFormat *stream_fmt;
129 char stream_format_name[64];
130
131 snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
132 stream_fmt = guess_format(stream_format_name, NULL, NULL);
133
134 if (stream_fmt)
135 fmt = stream_fmt;
136 }
137
138 return fmt;
139 }
140
141 AVInputFormat *av_find_input_format(const char *short_name)
142 {
143 AVInputFormat *fmt;
144 for(fmt = first_iformat; fmt != NULL; fmt = fmt->next) {
145 if (!strcmp(fmt->name, short_name))
146 return fmt;
147 }
148 return NULL;
149 }
150
151 /* memory handling */
152
153 /**
154 * Default packet destructor
155 */
156 static void av_destruct_packet(AVPacket *pkt)
157 {
158 av_free(pkt->data);
159 pkt->data = NULL; pkt->size = 0;
160 }
161
162 /**
163 * Allocate the payload of a packet and intialized its fields to default values.
164 *
165 * @param pkt packet
166 * @param size wanted payload size
167 * @return 0 if OK. AVERROR_xxx otherwise.
168 */
169 int av_new_packet(AVPacket *pkt, int size)
170 {
171 void *data = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
172 if (!data)
173 return AVERROR_NOMEM;
174 memset(data + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
175
176 av_init_packet(pkt);
177 pkt->data = data;
178 pkt->size = size;
179 pkt->destruct = av_destruct_packet;
180 return 0;
181 }
182
183 /* fifo handling */
184
185 int fifo_init(FifoBuffer *f, int size)
186 {
187 f->buffer = av_malloc(size);
188 if (!f->buffer)
189 return -1;
190 f->end = f->buffer + size;
191 f->wptr = f->rptr = f->buffer;
192 return 0;
193 }
194
195 void fifo_free(FifoBuffer *f)
196 {
197 av_free(f->buffer);
198 }
199
200 int fifo_size(FifoBuffer *f, uint8_t *rptr)
201 {
202 int size;
203
204 if (f->wptr >= rptr) {
205 size = f->wptr - rptr;
206 } else {
207 size = (f->end - rptr) + (f->wptr - f->buffer);
208 }
209 return size;
210 }
211
212 /* get data from the fifo (return -1 if not enough data) */
213 int fifo_read(FifoBuffer *f, uint8_t *buf, int buf_size, uint8_t **rptr_ptr)
214 {
215 uint8_t *rptr = *rptr_ptr;
216 int size, len;
217
218 if (f->wptr >= rptr) {
219 size = f->wptr - rptr;
220 } else {
221 size = (f->end - rptr) + (f->wptr - f->buffer);
222 }
223
224 if (size < buf_size)
225 return -1;
226 while (buf_size > 0) {
227 len = f->end - rptr;
228 if (len > buf_size)
229 len = buf_size;
230 memcpy(buf, rptr, len);
231 buf += len;
232 rptr += len;
233 if (rptr >= f->end)
234 rptr = f->buffer;
235 buf_size -= len;
236 }
237 *rptr_ptr = rptr;
238 return 0;
239 }
240
241 void fifo_write(FifoBuffer *f, uint8_t *buf, int size, uint8_t **wptr_ptr)
242 {
243 int len;
244 uint8_t *wptr;
245 wptr = *wptr_ptr;
246 while (size > 0) {
247 len = f->end - wptr;
248 if (len > size)
249 len = size;
250 memcpy(wptr, buf, len);
251 wptr += len;
252 if (wptr >= f->end)
253 wptr = f->buffer;
254 buf += len;
255 size -= len;
256 }
257 *wptr_ptr = wptr;
258 }
259
260 int filename_number_test(const char *filename)
261 {
262 char buf[1024];
263 return get_frame_filename(buf, sizeof(buf), filename, 1);
264 }
265
266 /* guess file format */
267 AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened)
268 {
269 AVInputFormat *fmt1, *fmt;
270 int score, score_max;
271
272 fmt = NULL;
273 score_max = 0;
274 for(fmt1 = first_iformat; fmt1 != NULL; fmt1 = fmt1->next) {
275 if (!is_opened && !(fmt1->flags & AVFMT_NOFILE))
276 continue;
277 score = 0;
278 if (fmt1->read_probe) {
279 score = fmt1->read_probe(pd);
280 } else if (fmt1->extensions) {
281 if (match_ext(pd->filename, fmt1->extensions)) {
282 score = 50;
283 }
284 }
285 if (score > score_max) {
286 score_max = score;
287 fmt = fmt1;
288 }
289 }
290 return fmt;
291 }
292
293 /************************************************************/
294 /* input media file */
295
296 #define PROBE_BUF_SIZE 2048
297
298 /**
299 * Open a media file as input. The codec are not opened. Only the file
300 * header (if present) is read.
301 *
302 * @param ic_ptr the opened media file handle is put here
303 * @param filename filename to open.
304 * @param fmt if non NULL, force the file format to use
305 * @param buf_size optional buffer size (zero if default is OK)
306 * @param ap additionnal parameters needed when opening the file (NULL if default)
307 * @return 0 if OK. AVERROR_xxx otherwise.
308 */
309 int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
310 AVInputFormat *fmt,
311 int buf_size,
312 AVFormatParameters *ap)
313 {
314 AVFormatContext *ic = NULL;
315 int err, must_open_file;
316 char buf[PROBE_BUF_SIZE];
317 AVProbeData probe_data, *pd = &probe_data;
318
319 ic = av_mallocz(sizeof(AVFormatContext));
320 if (!ic) {
321 err = AVERROR_NOMEM;
322 goto fail;
323 }
324 ic->duration = AV_NOPTS_VALUE;
325 ic->start_time = AV_NOPTS_VALUE;
326 pstrcpy(ic->filename, sizeof(ic->filename), filename);
327 pd->filename = ic->filename;
328 pd->buf = buf;
329 pd->buf_size = 0;
330
331 if (!fmt) {
332 /* guess format if no file can be opened */
333 fmt = av_probe_input_format(pd, 0);
334 }
335
336 /* do not open file if the format does not need it. XXX: specific
337 hack needed to handle RTSP/TCP */
338 must_open_file = 1;
339 if ((fmt && (fmt->flags & AVFMT_NOFILE)) ||
340 (fmt == &rtp_demux && !strcmp(filename, "null"))) {
341 must_open_file = 0;
342 }
343
344 if (!fmt || must_open_file) {
345 /* if no file needed do not try to open one */
346 if (url_fopen(&ic->pb, filename, URL_RDONLY) < 0) {
347 err = AVERROR_IO;
348 goto fail;
349 }
350 if (buf_size > 0) {
351 url_setbufsize(&ic->pb, buf_size);
352 }
353 if (!fmt) {
354 /* read probe data */
355 pd->buf_size = get_buffer(&ic->pb, buf, PROBE_BUF_SIZE);
356 url_fseek(&ic->pb, 0, SEEK_SET);
357 }
358 }
359
360 /* guess file format */
361 if (!fmt) {
362 fmt = av_probe_input_format(pd, 1);
363 }
364
365 /* if still no format found, error */
366 if (!fmt) {
367 err = AVERROR_NOFMT;
368 goto fail1;
369 }
370
371 /* XXX: suppress this hack for redirectors */
372 #ifdef CONFIG_NETWORK
373 if (fmt == &redir_demux) {
374 err = redir_open(ic_ptr, &ic->pb);
375 url_fclose(&ic->pb);
376 av_free(ic);
377 return err;
378 }
379 #endif
380
381 ic->iformat = fmt;
382
383 /* check filename in case of an image number is expected */
384 if (ic->iformat->flags & AVFMT_NEEDNUMBER) {
385 if (filename_number_test(ic->filename) < 0) {
386 err = AVERROR_NUMEXPECTED;
387 goto fail1;
388 }
389 }
390
391 /* allocate private data */
392 if (fmt->priv_data_size > 0) {
393 ic->priv_data = av_mallocz(fmt->priv_data_size);
394 if (!ic->priv_data) {
395 err = AVERROR_NOMEM;
396 goto fail1;
397 }
398 } else
399 ic->priv_data = NULL;
400
401 /* default pts settings is MPEG like */
402 av_set_pts_info(ic, 33, 1, 90000);
403
404 err = ic->iformat->read_header(ic, ap);
405 if (err < 0)
406 goto fail1;
407 *ic_ptr = ic;
408 return 0;
409 fail1:
410 if (!fmt || must_open_file) {
411 url_fclose(&ic->pb);
412 }
413 fail:
414 if (ic) {
415 av_freep(&ic->priv_data);
416 }
417 av_free(ic);
418 *ic_ptr = NULL;
419 return err;
420 }
421
422 /**
423 * Read a packet from a media file
424 * @param s media file handle
425 * @param pkt is filled
426 * @return 0 if OK. AVERROR_xxx if error.
427 */
428 int av_read_packet(AVFormatContext *s, AVPacket *pkt)
429 {
430 AVPacketList *pktl;
431
432 pktl = s->packet_buffer;
433 if (pktl) {
434 /* read packet from packet buffer, if there is data */
435 *pkt = pktl->pkt;
436 s->packet_buffer = pktl->next;
437 av_free(pktl);
438 return 0;
439 } else {
440 return s->iformat->read_packet(s, pkt);
441 }
442 }
443
444
445 /* return TRUE if the stream has accurate timings for at least one component */
446 static int av_has_timings(AVFormatContext *ic)
447 {
448 int i;
449 AVStream *st;
450
451 for(i = 0;i < ic->nb_streams; i++) {
452 st = ic->streams[i];
453 if (st->start_time != AV_NOPTS_VALUE &&
454 st->duration != AV_NOPTS_VALUE)
455 return 1;
456 }
457 return 0;
458 }
459
460 /* estimate the stream timings from the one of each components. Also
461 compute the global bitrate if possible */
462 static void av_update_stream_timings(AVFormatContext *ic)
463 {
464 int64_t start_time, end_time, end_time1;
465 int i;
466 AVStream *st;
467
468 start_time = MAXINT64;
469 end_time = MININT64;
470 for(i = 0;i < ic->nb_streams; i++) {
471 st = ic->streams[i];
472 if (st->start_time != AV_NOPTS_VALUE) {
473 if (st->start_time < start_time)
474 start_time = st->start_time;
475 if (st->duration != AV_NOPTS_VALUE) {
476 end_time1 = st->start_time + st->duration;
477 if (end_time1 > end_time)
478 end_time = end_time1;
479 }
480 }
481 }
482 if (start_time != MAXINT64) {
483 ic->start_time = start_time;
484 if (end_time != MAXINT64) {
485 ic->duration = end_time - start_time;
486 if (ic->file_size > 0) {
487 /* compute the bit rate */
488 ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
489 (double)ic->duration;
490 }
491 }
492 }
493
494 }
495
496 static void fill_all_stream_timings(AVFormatContext *ic)
497 {
498 int i;
499 AVStream *st;
500
501 av_update_stream_timings(ic);
502 for(i = 0;i < ic->nb_streams; i++) {
503 st = ic->streams[i];
504 if (st->start_time == AV_NOPTS_VALUE) {
505 st->start_time = ic->start_time;
506 st->duration = ic->duration;
507 }
508 }
509 }
510
511 static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
512 {
513 int64_t filesize, duration;
514 int bit_rate, i;
515 AVStream *st;
516
517 /* if bit_rate is already set, we believe it */
518 if (ic->bit_rate == 0) {
519 bit_rate = 0;
520 for(i=0;i<ic->nb_streams;i++) {
521 st = ic->streams[i];
522 bit_rate += st->codec.bit_rate;
523 }
524 ic->bit_rate = bit_rate;
525 }
526
527 /* if duration is already set, we believe it */
528 if (ic->duration == AV_NOPTS_VALUE &&
529 ic->bit_rate != 0 &&
530 ic->file_size != 0) {
531 filesize = ic->file_size;
532 if (filesize > 0) {
533 duration = (int64_t)((8 * AV_TIME_BASE * (double)filesize) / (double)ic->bit_rate);
534 for(i = 0; i < ic->nb_streams; i++) {
535 st = ic->streams[i];
536 if (st->start_time == AV_NOPTS_VALUE ||
537 st->duration == AV_NOPTS_VALUE) {
538 st->start_time = 0;
539 st->duration = duration;
540 }
541 }
542 }
543 }
544 }
545
546 static void flush_packet_queue(AVFormatContext *s)
547 {
548 AVPacketList *pktl;
549
550 for(;;) {
551 pktl = s->packet_buffer;
552 if (!pktl)
553 break;
554 s->packet_buffer = pktl->next;
555 av_free(pktl);
556 }
557 }
558
559 #define DURATION_MAX_READ_SIZE 250000
560
561 /* only usable for MPEG-PS streams */
562 static void av_estimate_timings_from_pts(AVFormatContext *ic)
563 {
564 AVPacket pkt1, *pkt = &pkt1;
565 AVStream *st;
566 int read_size, i, ret;
567 int64_t start_time, end_time, end_time1;
568 int64_t filesize, offset, duration;
569
570 /* we read the first packets to get the first PTS (not fully
571 accurate, but it is enough now) */
572 url_fseek(&ic->pb, 0, SEEK_SET);
573 read_size = 0;
574 for(;;) {
575 if (read_size >= DURATION_MAX_READ_SIZE)
576 break;
577 /* if all info is available, we can stop */
578 for(i = 0;i < ic->nb_streams; i++) {
579 st = ic->streams[i];
580 if (st->start_time == AV_NOPTS_VALUE)
581 break;
582 }
583 if (i == ic->nb_streams)
584 break;
585
586 ret = av_read_packet(ic, pkt);
587 if (ret != 0)
588 break;
589 read_size += pkt->size;
590 st = ic->streams[pkt->stream_index];
591 if (pkt->pts != AV_NOPTS_VALUE) {
592 if (st->start_time == AV_NOPTS_VALUE)
593 st->start_time = (int64_t)((double)pkt->pts * ic->pts_num * (double)AV_TIME_BASE / ic->pts_den);
594 }
595 av_free_packet(pkt);
596 }
597
598 /* we compute the minimum start_time and use it as default */
599 start_time = MAXINT64;
600 for(i = 0; i < ic->nb_streams; i++) {
601 st = ic->streams[i];
602 if (st->start_time != AV_NOPTS_VALUE &&
603 st->start_time < start_time)
604 start_time = st->start_time;
605 }
606 printf("start=%lld\n", start_time);
607 if (start_time != MAXINT64)
608 ic->start_time = start_time;
609
610 /* estimate the end time (duration) */
611 /* XXX: may need to support wrapping */
612 filesize = ic->file_size;
613 offset = filesize - DURATION_MAX_READ_SIZE;
614 if (offset < 0)
615 offset = 0;
616
617 /* flush packet queue */
618 flush_packet_queue(ic);
619
620 url_fseek(&ic->pb, offset, SEEK_SET);
621 read_size = 0;
622 for(;;) {
623 if (read_size >= DURATION_MAX_READ_SIZE)
624 break;
625 /* if all info is available, we can stop */
626 for(i = 0;i < ic->nb_streams; i++) {
627 st = ic->streams[i];
628 if (st->duration == AV_NOPTS_VALUE)
629 break;
630 }
631 if (i == ic->nb_streams)
632 break;
633
634 ret = av_read_packet(ic, pkt);
635 if (ret != 0)
636 break;
637 read_size += pkt->size;
638 st = ic->streams[pkt->stream_index];
639 if (pkt->pts != AV_NOPTS_VALUE) {
640 end_time = (int64_t)((double)pkt->pts * ic->pts_num * (double)AV_TIME_BASE / ic->pts_den);
641 duration = end_time - st->start_time;
642 if (duration > 0) {
643 if (st->duration == AV_NOPTS_VALUE ||
644 st->duration < duration)
645 st->duration = duration;
646 }
647 }
648 av_free_packet(pkt);
649 }
650
651 /* estimate total duration */
652 end_time = MININT64;
653 for(i = 0;i < ic->nb_streams; i++) {
654 st = ic->streams[i];
655 if (st->duration != AV_NOPTS_VALUE) {
656 end_time1 = st->start_time + st->duration;
657 if (end_time1 > end_time)
658 end_time = end_time1;
659 }
660 }
661
662 /* update start_time (new stream may have been created, so we do
663 it at the end */
664 if (ic->start_time != AV_NOPTS_VALUE) {
665 for(i = 0; i < ic->nb_streams; i++) {
666 st = ic->streams[i];
667 if (st->start_time == AV_NOPTS_VALUE)
668 st->start_time = ic->start_time;
669 }
670 }
671
672 if (end_time != MININT64) {
673 /* put dummy values for duration if needed */
674 for(i = 0;i < ic->nb_streams; i++) {
675 st = ic->streams[i];
676 if (st->duration == AV_NOPTS_VALUE &&
677 st->start_time != AV_NOPTS_VALUE)
678 st->duration = end_time - st->start_time;
679 }
680 ic->duration = end_time - ic->start_time;
681 }
682
683 url_fseek(&ic->pb, 0, SEEK_SET);
684 }
685
686 static void av_estimate_timings(AVFormatContext *ic)
687 {
688 URLContext *h;
689 int64_t file_size;
690
691 /* get the file size, if possible */
692 if (ic->iformat->flags & AVFMT_NOFILE) {
693 file_size = 0;
694 } else {
695 h = url_fileno(&ic->pb);
696 file_size = url_filesize(h);
697 if (file_size < 0)
698 file_size = 0;
699 }
700 ic->file_size = file_size;
701
702 if (ic->iformat == &mpegps_demux) {
703 /* get accurate estimate from the PTSes */
704 av_estimate_timings_from_pts(ic);
705 } else if (av_has_timings(ic)) {
706 /* at least one components has timings - we use them for all
707 the components */
708 fill_all_stream_timings(ic);
709 } else {
710 /* less precise: use bit rate info */
711 av_estimate_timings_from_bit_rate(ic);
712 }
713 av_update_stream_timings(ic);
714
715 #if 0
716 {
717 int i;
718 AVStream *st;
719 for(i = 0;i < ic->nb_streams; i++) {
720 st = ic->streams[i];
721 printf("%d: start_time: %0.3f duration: %0.3f\n",
722 i, (double)st->start_time / AV_TIME_BASE,
723 (double)st->duration / AV_TIME_BASE);
724 }
725 printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
726 (double)ic->start_time / AV_TIME_BASE,
727 (double)ic->duration / AV_TIME_BASE,
728 ic->bit_rate / 1000);
729 }
730 #endif
731 }
732
733 /* state for codec information */
734 #define CSTATE_NOTFOUND 0
735 #define CSTATE_DECODING 1
736 #define CSTATE_FOUND 2
737
738 static int has_codec_parameters(AVCodecContext *enc)
739 {
740 int val;
741 switch(enc->codec_type) {
742 case CODEC_TYPE_AUDIO:
743 val = enc->sample_rate;
744 break;
745 case CODEC_TYPE_VIDEO:
746 val = enc->width;
747 break;
748 default:
749 val = 1;
750 break;
751 }
752 return (val != 0);
753 }
754
755 /**
756 * Read the beginning of a media file to get stream information. This
757 * is useful for file formats with no headers such as MPEG. This
758 * function also compute the real frame rate in case of mpeg2 repeat
759 * frame mode.
760 *
761 * @param ic media file handle
762 * @return >=0 if OK. AVERROR_xxx if error.
763 */
764 int av_find_stream_info(AVFormatContext *ic)
765 {
766 int i, count, ret, got_picture, size, read_size;
767 AVCodec *codec;
768 AVStream *st;
769 AVPacket *pkt;
770 AVFrame picture;
771 AVPacketList *pktl=NULL, **ppktl;
772 short samples[AVCODEC_MAX_AUDIO_FRAME_SIZE / 2];
773 uint8_t *ptr;
774 int min_read_size, max_read_size;
775
776 /* typical mpeg ts rate is 40 Mbits. DVD rate is about 10
777 Mbits. We read at most 0.2 second of file to find all streams */
778
779 /* XXX: base it on stream bitrate when possible */
780 if (ic->iformat == &mpegts_demux) {
781 /* maximum number of bytes we accept to read to find all the streams
782 in a file */
783 min_read_size = 6000000;
784 } else {
785 min_read_size = 250000;
786 }
787 /* max read size is 2 seconds of video max */
788 max_read_size = min_read_size * 10;
789
790 /* set initial codec state */
791 for(i=0;i<ic->nb_streams;i++) {
792 st = ic->streams[i];
793 if (has_codec_parameters(&st->codec))
794 st->codec_info_state = CSTATE_FOUND;
795 else
796 st->codec_info_state = CSTATE_NOTFOUND;
797 st->codec_info_nb_repeat_frames = 0;
798 st->codec_info_nb_real_frames = 0;
799 }
800
801 count = 0;
802 read_size = 0;
803 ppktl = &ic->packet_buffer;
804 for(;;) {
805 /* check if one codec still needs to be handled */
806 for(i=0;i<ic->nb_streams;i++) {
807 st = ic->streams[i];
808 if (st->codec_info_state != CSTATE_FOUND)
809 break;
810 }
811 if (i == ic->nb_streams) {
812 /* NOTE: if the format has no header, then we need to read
813 some packets to get most of the streams, so we cannot
814 stop here */
815 if (!(ic->iformat->flags & AVFMT_NOHEADER) ||
816 read_size >= min_read_size) {
817 /* if we found the info for all the codecs, we can stop */
818 ret = count;
819 break;
820 }
821 } else {
822 /* we did not get all the codec info, but we read too much data */
823 if (read_size >= max_read_size) {
824 ret = count;
825 break;
826 }
827 }
828
829 pktl = av_mallocz(sizeof(AVPacketList));
830 if (!pktl) {
831 ret = AVERROR_NOMEM;
832 break;
833 }
834
835 /* add the packet in the buffered packet list */
836 *ppktl = pktl;
837 ppktl = &pktl->next;
838
839 /* NOTE: a new stream can be added there if no header in file
840 (AVFMT_NOHEADER) */
841 pkt = &pktl->pkt;
842 if (ic->iformat->read_packet(ic, pkt) < 0) {
843 /* EOF or error */
844 ret = -1; /* we could not have all the codec parameters before EOF */
845 if ((ic->iformat->flags & AVFMT_NOHEADER) &&
846 i == ic->nb_streams)
847 ret = 0;
848 break;
849 }
850 read_size += pkt->size;
851
852 /* open new codecs */
853 for(i=0;i<ic->nb_streams;i++) {
854 st = ic->streams[i];
855 if (st->codec_info_state == CSTATE_NOTFOUND) {
856 /* set to found in case of error */
857 st->codec_info_state = CSTATE_FOUND;
858 codec = avcodec_find_decoder(st->codec.codec_id);
859 if (codec) {
860 if(codec->capabilities & CODEC_CAP_TRUNCATED)
861 st->codec.flags |= CODEC_FLAG_TRUNCATED;
862
863 ret = avcodec_open(&st->codec, codec);
864 if (ret >= 0)
865 st->codec_info_state = CSTATE_DECODING;
866 }
867 }
868 }
869
870 st = ic->streams[pkt->stream_index];
871 if (st->codec_info_state == CSTATE_DECODING) {
872 /* decode the data and update codec parameters */
873 ptr = pkt->data;
874 size = pkt->size;
875 while (size > 0) {
876 switch(st->codec.codec_type) {
877 case CODEC_TYPE_VIDEO:
878 ret = avcodec_decode_video(&st->codec, &picture,
879 &got_picture, ptr, size);
880 break;
881 case CODEC_TYPE_AUDIO:
882 ret = avcodec_decode_audio(&st->codec, samples,
883 &got_picture, ptr, size);
884 break;
885 default:
886 ret = -1;
887 break;
888 }
889 if (ret < 0) {
890 /* if error, simply ignore because another packet
891 may be OK */
892 break;
893 }
894 if (got_picture) {
895 /* we got the parameters - now we can stop
896 examining this stream */
897 /* XXX: add a codec info so that we can decide if
898 the codec can repeat frames */
899 if (st->codec.codec_id == CODEC_ID_MPEG1VIDEO &&
900 ic->iformat != &mpegts_demux &&
901 st->codec.sub_id == 2) {
902 /* for mpeg2 video, we want to know the real
903 frame rate, so we decode 40 frames. In mpeg
904 TS case we do not do it because it would be
905 too long */
906 st->codec_info_nb_real_frames++;
907 st->codec_info_nb_repeat_frames += st->codec.coded_frame->repeat_pict;
908 #if 0
909 /* XXX: testing */
910 if ((st->codec_info_nb_real_frames % 24) == 23) {
911 st->codec_info_nb_repeat_frames += 2;
912 }
913 #endif
914 /* stop after 40 frames */
915 if (st->codec_info_nb_real_frames >= 40) {
916 av_reduce(
917 &st->r_frame_rate,
918 &st->r_frame_rate_base,
919 (int64_t)st->codec.frame_rate * st->codec_info_nb_real_frames,
920 (st->codec_info_nb_real_frames + (st->codec_info_nb_repeat_frames >> 1)) * st->codec.frame_rate_base,
921 1<<30);
922 goto close_codec;
923 }
924 } else {
925 close_codec:
926 st->codec_info_state = CSTATE_FOUND;
927 avcodec_close(&st->codec);
928 break;
929 }
930 }
931 ptr += ret;
932 size -= ret;
933 }
934 }
935 count++;
936 }
937
938 /* close each codec if there are opened */
939 for(i=0;i<ic->nb_streams;i++) {
940 st = ic->streams[i];
941 if (st->codec_info_state == CSTATE_DECODING)
942 avcodec_close(&st->codec);
943 }
944
945 /* set real frame rate info */
946 for(i=0;i<ic->nb_streams;i++) {
947 st = ic->streams[i];
948 if (st->codec.codec_type == CODEC_TYPE_VIDEO) {
949 if (!st->r_frame_rate){
950 st->r_frame_rate = st->codec.frame_rate;
951 st->r_frame_rate_base = st->codec.frame_rate_base;
952 }
953 }
954 }
955
956
957 av_estimate_timings(ic);
958 return ret;
959 }
960
961 /**
962 * Close a media file (but not its codecs)
963 *
964 * @param s media file handle
965 */
966 void av_close_input_file(AVFormatContext *s)
967 {
968 int i, must_open_file;
969
970 if (s->iformat->read_close)
971 s->iformat->read_close(s);
972 for(i=0;i<s->nb_streams;i++) {
973 av_free(s->streams[i]);
974 }
975 if (s->packet_buffer) {
976 AVPacketList *p, *p1;
977 p = s->packet_buffer;
978 while (p != NULL) {
979 p1 = p->next;
980 av_free_packet(&p->pkt);
981 av_free(p);
982 p = p1;
983 }
984 s->packet_buffer = NULL;
985 }
986 must_open_file = 1;
987 if ((s->iformat->flags & AVFMT_NOFILE) ||
988 (s->iformat == &rtp_demux && !strcmp(s->filename, "null"))) {
989 must_open_file = 0;
990 }
991 if (must_open_file) {
992 url_fclose(&s->pb);
993 }
994 av_freep(&s->priv_data);
995 av_free(s);
996 }
997
998 /**
999 * Add a new stream to a media file. Can only be called in the
1000 * read_header function. If the flag AVFMT_NOHEADER is in the format
1001 * description, then new streams can be added in read_packet too.
1002 *
1003 *
1004 * @param s media file handle
1005 * @param id file format dependent stream id
1006 */
1007 AVStream *av_new_stream(AVFormatContext *s, int id)
1008 {
1009 AVStream *st;
1010
1011 if (s->nb_streams >= MAX_STREAMS)
1012 return NULL;
1013
1014 st = av_mallocz(sizeof(AVStream));
1015 if (!st)
1016 return NULL;
1017 avcodec_get_context_defaults(&st->codec);
1018
1019 st->index = s->nb_streams;
1020 st->id = id;
1021 st->start_time = AV_NOPTS_VALUE;
1022 st->duration = AV_NOPTS_VALUE;
1023 s->streams[s->nb_streams++] = st;
1024 return st;
1025 }
1026
1027 /************************************************************/
1028 /* output media file */
1029
1030 int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
1031 {
1032 int ret;
1033
1034 if (s->oformat->priv_data_size > 0) {
1035 s->priv_data = av_mallocz(s->oformat->priv_data_size);
1036 if (!s->priv_data)
1037 return AVERROR_NOMEM;
1038 } else
1039 s->priv_data = NULL;
1040
1041 if (s->oformat->set_parameters) {
1042 ret = s->oformat->set_parameters(s, ap);
1043 if (ret < 0)
1044 return ret;
1045 }
1046 return 0;
1047 }
1048
1049 /**
1050 * allocate the stream private data and write the stream header to an
1051 * output media file
1052 *
1053 * @param s media file handle
1054 * @return 0 if OK. AVERROR_xxx if error.
1055 */
1056 int av_write_header(AVFormatContext *s)
1057 {
1058 int ret, i;
1059 AVStream *st;
1060
1061 /* default pts settings is MPEG like */
1062 av_set_pts_info(s, 33, 1, 90000);
1063 ret = s->oformat->write_header(s);
1064 if (ret < 0)
1065 return ret;
1066
1067 /* init PTS generation */
1068 for(i=0;i<s->nb_streams;i++) {
1069 st = s->streams[i];
1070
1071 switch (st->codec.codec_type) {
1072 case CODEC_TYPE_AUDIO:
1073 av_frac_init(&st->pts, 0, 0,
1074 (int64_t)s->pts_num * st->codec.sample_rate);
1075 break;
1076 case CODEC_TYPE_VIDEO:
1077 av_frac_init(&st->pts, 0, 0,
1078 (int64_t)s->pts_num * st->codec.frame_rate);
1079 break;
1080 default:
1081 break;
1082 }
1083 }
1084 return 0;
1085 }
1086
1087 /**
1088 * Write a packet to an output media file. The packet shall contain
1089 * one audio or video frame.
1090 *
1091 * @param s media file handle
1092 * @param stream_index stream index
1093 * @param buf buffer containing the frame data
1094 * @param size size of buffer
1095 * @return < 0 if error, = 0 if OK, 1 if end of stream wanted.
1096 */
1097 int av_write_frame(AVFormatContext *s, int stream_index, const uint8_t *buf,
1098 int size)
1099 {
1100 AVStream *st;
1101 int64_t pts_mask;
1102 int ret, frame_size;
1103
1104 st = s->streams[stream_index];
1105 pts_mask = (1LL << s->pts_wrap_bits) - 1;
1106 ret = s->oformat->write_packet(s, stream_index, (uint8_t *)buf, size,
1107 st->pts.val & pts_mask);
1108 if (ret < 0)
1109 return ret;
1110
1111 /* update pts */
1112 switch (st->codec.codec_type) {
1113 case CODEC_TYPE_AUDIO:
1114 if (st->codec.frame_size <= 1) {
1115 frame_size = size / st->codec.channels;
1116 /* specific hack for pcm codecs because no frame size is provided */
1117 switch(st->codec.codec_id) {
1118 case CODEC_ID_PCM_S16LE:
1119 case CODEC_ID_PCM_S16BE:
1120 case CODEC_ID_PCM_U16LE:
1121 case CODEC_ID_PCM_U16BE:
1122 frame_size >>= 1;
1123 break;
1124 default:
1125 break;
1126 }
1127 } else {
1128 frame_size = st->codec.frame_size;
1129 }
1130 av_frac_add(&st->pts,
1131 (int64_t)s->pts_den * frame_size);
1132 break;
1133 case CODEC_TYPE_VIDEO:
1134 av_frac_add(&st->pts,
1135 (int64_t)s->pts_den * st->codec.frame_rate_base);
1136 break;
1137 default:
1138 break;
1139 }
1140 return ret;
1141 }
1142
1143 /**
1144 * write the stream trailer to an output media file and and free the
1145 * file private data.
1146 *
1147 * @param s media file handle
1148 * @return 0 if OK. AVERROR_xxx if error. */
1149 int av_write_trailer(AVFormatContext *s)
1150 {
1151 int ret;
1152 ret = s->oformat->write_trailer(s);
1153 av_freep(&s->priv_data);
1154 return ret;
1155 }
1156
1157 /* "user interface" functions */
1158
1159 void dump_format(AVFormatContext *ic,
1160 int index,
1161 const char *url,
1162 int is_output)
1163 {
1164 int i, flags;
1165 char buf[256];
1166
1167 fprintf(stderr, "%s #%d, %s, %s '%s':\n",
1168 is_output ? "Output" : "Input",
1169 index,
1170 is_output ? ic->oformat->name : ic->iformat->name,
1171 is_output ? "to" : "from", url);
1172 if (!is_output) {
1173 printf(" Duration: ");
1174 if (ic->duration != AV_NOPTS_VALUE) {
1175 int hours, mins, secs, us;
1176 secs = ic->duration / AV_TIME_BASE;
1177 us = ic->duration % AV_TIME_BASE;
1178 mins = secs / 60;
1179 secs %= 60;
1180 hours = mins / 60;
1181 mins %= 60;
1182 printf("%02d:%02d:%02d.%01d", hours, mins, secs,
1183 (10 * us) / AV_TIME_BASE);
1184 } else {
1185 printf("N/A");
1186 }
1187 printf(", bitrate: ");
1188 if (ic->bit_rate) {
1189 printf("%d kb/s", ic->bit_rate / 1000);
1190 } else {
1191 printf("N/A");
1192 }
1193 printf("\n");
1194 }
1195 for(i=0;i<ic->nb_streams;i++) {
1196 AVStream *st = ic->streams[i];
1197 avcodec_string(buf, sizeof(buf), &st->codec, is_output);
1198 fprintf(stderr, " Stream #%d.%d", index, i);
1199 /* the pid is an important information, so we display it */
1200 /* XXX: add a generic system */
1201 if (is_output)
1202 flags = ic->oformat->flags;
1203 else
1204 flags = ic->iformat->flags;
1205 if (flags & AVFMT_SHOW_IDS) {
1206 fprintf(stderr, "[0x%x]", st->id);
1207 }
1208 fprintf(stderr, ": %s\n", buf);
1209 }
1210 }
1211
1212 typedef struct {
1213 const char *abv;
1214 int width, height;
1215 int frame_rate, frame_rate_base;
1216 } AbvEntry;
1217
1218 static AbvEntry frame_abvs[] = {
1219 { "ntsc", 352, 240, 30000, 1001 },
1220 { "pal", 352, 288, 25, 1 },
1221 { "film", 352, 240, 24, 1 },
1222 { "ntsc-film", 352, 240, 24000, 1001 },
1223 { "sqcif", 128, 96, 0, 0 },
1224 { "qcif", 176, 144, 0, 0 },
1225 { "cif", 352, 288, 0, 0 },
1226 { "4cif", 704, 576, 0, 0 },
1227 };
1228
1229 int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
1230 {
1231 int i;
1232 int n = sizeof(frame_abvs) / sizeof(AbvEntry);
1233 const char *p;
1234 int frame_width = 0, frame_height = 0;
1235
1236 for(i=0;i<n;i++) {
1237 if (!strcmp(frame_abvs[i].abv, str)) {
1238 frame_width = frame_abvs[i].width;
1239 frame_height = frame_abvs[i].height;
1240 break;
1241 }
1242 }
1243 if (i == n) {
1244 p = str;
1245 frame_width = strtol(p, (char **)&p, 10);
1246 if (*p)
1247 p++;
1248 frame_height = strtol(p, (char **)&p, 10);
1249 }
1250 if (frame_width <= 0 || frame_height <= 0)
1251 return -1;
1252 *width_ptr = frame_width;
1253 *height_ptr = frame_height;
1254 return 0;
1255 }
1256
1257 int parse_frame_rate(int *frame_rate, int *frame_rate_base, const char *arg)
1258 {
1259 int i;
1260 char* cp;
1261
1262 /* First, we check our abbreviation table */
1263 for (i = 0; i < sizeof(frame_abvs)/sizeof(*frame_abvs); ++i)
1264 if (!strcmp(frame_abvs[i].abv, arg)) {
1265 *frame_rate = frame_abvs[i].frame_rate;
1266 *frame_rate_base = frame_abvs[i].frame_rate_base;
1267 return 0;
1268 }
1269
1270 /* Then, we try to parse it as fraction */
1271 cp = strchr(arg, '/');
1272 if (cp) {
1273 char* cpp;
1274 *frame_rate = strtol(arg, &cpp, 10);
1275 if (cpp != arg || cpp == cp)
1276 *frame_rate_base = strtol(cp+1, &cpp, 10);
1277 else
1278 *frame_rate = 0;
1279 }
1280 else {
1281 /* Finally we give up and parse it as double */
1282 *frame_rate_base = DEFAULT_FRAME_RATE_BASE;
1283 *frame_rate = (int)(strtod(arg, 0) * (*frame_rate_base) + 0.5);
1284 }
1285 if (!*frame_rate || !*frame_rate_base)
1286 return -1;
1287 else
1288 return 0;
1289 }
1290
1291 int64_t av_gettime(void)
1292 {
1293 #ifdef CONFIG_WIN32
1294 struct _timeb tb;
1295 _ftime(&tb);
1296 return ((int64_t)tb.time * int64_t_C(1000) + (int64_t)tb.millitm) * int64_t_C(1000);
1297 #else
1298 struct timeval tv;
1299 gettimeofday(&tv,NULL);
1300 return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
1301 #endif
1302 }
1303
1304 static time_t mktimegm(struct tm *tm)
1305 {
1306 time_t t;
1307
1308 int y = tm->tm_year + 1900, m = tm->tm_mon + 1, d = tm->tm_mday;
1309
1310 if (m < 3) {
1311 m += 12;
1312 y--;
1313 }
1314
1315 t = 86400 *
1316 (d + (153 * m - 457) / 5 + 365 * y + y / 4 - y / 100 + y / 400 - 719469);
1317
1318 t += 3600 * tm->tm_hour + 60 * tm->tm_min + tm->tm_sec;
1319
1320 return t;
1321 }
1322
1323 /* Syntax:
1324 * - If not a duration:
1325 * [{YYYY-MM-DD|YYYYMMDD}]{T| }{HH[:MM[:SS[.m...]]][Z]|HH[MM[SS[.m...]]][Z]}
1326 * Time is localtime unless Z is suffixed to the end. In this case GMT
1327 * Return the date in micro seconds since 1970
1328 * - If duration:
1329 * HH[:MM[:SS[.m...]]]
1330 * S+[.m...]
1331 */
1332 int64_t parse_date(const char *datestr, int duration)
1333 {
1334 const char *p;
1335 int64_t t;
1336 struct tm dt;
1337 int i;
1338 static const char *date_fmt[] = {
1339 "%Y-%m-%d",
1340 "%Y%m%d",
1341 };
1342 static const char *time_fmt[] = {
1343 "%H:%M:%S",
1344 "%H%M%S",
1345 };
1346 const char *q;
1347 int is_utc, len;
1348 char lastch;
1349 time_t now = time(0);
1350
1351 len = strlen(datestr);
1352 if (len > 0)
1353 lastch = datestr[len - 1];
1354 else
1355 lastch = '\0';
1356 is_utc = (lastch == 'z' || lastch == 'Z');
1357
1358 memset(&dt, 0, sizeof(dt));
1359
1360 p = datestr;
1361 q = NULL;
1362 if (!duration) {
1363 for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
1364 q = strptime(p, date_fmt[i], &dt);
1365 if (q) {
1366 break;
1367 }
1368 }
1369
1370 if (!q) {
1371 if (is_utc) {
1372 dt = *gmtime(&now);
1373 } else {
1374 dt = *localtime(&now);
1375 }
1376 dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
1377 } else {
1378 p = q;
1379 }
1380
1381 if (*p == 'T' || *p == 't' || *p == ' ')
1382 p++;
1383
1384 for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
1385 q = strptime(p, time_fmt[i], &dt);
1386 if (q) {
1387 break;
1388 }
1389 }
1390 } else {
1391 q = strptime(p, time_fmt[0], &dt);
1392 if (!q) {
1393 dt.tm_sec = strtol(p, (char **)&q, 10);
1394 dt.tm_min = 0;
1395 dt.tm_hour = 0;
1396 }
1397 }
1398
1399 /* Now we have all the fields that we can get */
1400 if (!q) {
1401 if (duration)
1402 return 0;
1403 else
1404 return now * int64_t_C(1000000);
1405 }
1406
1407 if (duration) {
1408 t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
1409 } else {
1410 dt.tm_isdst = -1; /* unknown */
1411 if (is_utc) {
1412 t = mktimegm(&dt);
1413 } else {
1414 t = mktime(&dt);
1415 }
1416 }
1417
1418 t *= 1000000;
1419
1420 if (*q == '.') {
1421 int val, n;
1422 q++;
1423 for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
1424 if (!isdigit(*q))
1425 break;
1426 val += n * (*q - '0');
1427 }
1428 t += val;
1429 }
1430 return t;
1431 }
1432
1433 /* syntax: '?tag1=val1&tag2=val2...'. Little URL decoding is done. Return
1434 1 if found */
1435 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
1436 {
1437 const char *p;
1438 char tag[128], *q;
1439
1440 p = info;
1441 if (*p == '?')
1442 p++;
1443 for(;;) {
1444 q = tag;
1445 while (*p != '\0' && *p != '=' && *p != '&') {
1446 if ((q - tag) < sizeof(tag) - 1)
1447 *q++ = *p;
1448 p++;
1449 }
1450 *q = '\0';
1451 q = arg;
1452 if (*p == '=') {
1453 p++;
1454 while (*p != '&' && *p != '\0') {
1455 if ((q - arg) < arg_size - 1) {
1456 if (*p == '+')
1457 *q++ = ' ';
1458 else
1459 *q++ = *p;
1460 }
1461 p++;
1462 }
1463 *q = '\0';
1464 }
1465 if (!strcmp(tag, tag1))
1466 return 1;
1467 if (*p != '&')
1468 break;
1469 p++;
1470 }
1471 return 0;
1472 }
1473
1474 /* Return in 'buf' the path with '%d' replaced by number. Also handles
1475 the '%0nd' format where 'n' is the total number of digits and
1476 '%%'. Return 0 if OK, and -1 if format error */
1477 int get_frame_filename(char *buf, int buf_size,
1478 const char *path, int number)
1479 {
1480 const char *p;
1481 char *q, buf1[20];
1482 int nd, len, c, percentd_found;
1483
1484 q = buf;
1485 p = path;
1486 percentd_found = 0;
1487 for(;;) {
1488 c = *p++;
1489 if (c == '\0')
1490 break;
1491 if (c == '%') {
1492 do {
1493 nd = 0;
1494 while (isdigit(*p)) {
1495 nd = nd * 10 + *p++ - '0';
1496 }
1497 c = *p++;
1498 if (c == '*' && nd > 0) {
1499 // The nd field is actually the modulus
1500 number = number % nd;
1501 c = *p++;
1502 nd = 0;
1503 }
1504 } while (isdigit(c));
1505
1506 switch(c) {
1507 case '%':
1508 goto addchar;
1509 case 'd':
1510 if (percentd_found)
1511 goto fail;
1512 percentd_found = 1;
1513 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
1514 len = strlen(buf1);
1515 if ((q - buf + len) > buf_size - 1)
1516 goto fail;
1517 memcpy(q, buf1, len);
1518 q += len;
1519 break;
1520 default:
1521 goto fail;
1522 }
1523 } else {
1524 addchar:
1525 if ((q - buf) < buf_size - 1)
1526 *q++ = c;
1527 }
1528 }
1529 if (!percentd_found)
1530 goto fail;
1531 *q = '\0';
1532 return 0;
1533 fail:
1534 *q = '\0';
1535 return -1;
1536 }
1537
1538 /**
1539 *
1540 * Print on stdout a nice hexa dump of a buffer
1541 * @param buf buffer
1542 * @param size buffer size
1543 */
1544 void av_hex_dump(uint8_t *buf, int size)
1545 {
1546 int len, i, j, c;
1547
1548 for(i=0;i<size;i+=16) {
1549 len = size - i;
1550 if (len > 16)
1551 len = 16;
1552 printf("%08x ", i);
1553 for(j=0;j<16;j++) {
1554 if (j < len)
1555 printf(" %02x", buf[i+j]);
1556 else
1557 printf(" ");
1558 }
1559 printf(" ");
1560 for(j=0;j<len;j++) {
1561 c = buf[i+j];
1562 if (c < ' ' || c > '~')
1563 c = '.';
1564 printf("%c", c);
1565 }
1566 printf("\n");
1567 }
1568 }
1569
1570 void url_split(char *proto, int proto_size,
1571 char *hostname, int hostname_size,
1572 int *port_ptr,
1573 char *path, int path_size,
1574 const char *url)
1575 {
1576 const char *p;
1577 char *q;
1578 int port;
1579
1580 port = -1;
1581
1582 p = url;
1583 q = proto;
1584 while (*p != ':' && *p != '\0') {
1585 if ((q - proto) < proto_size - 1)
1586 *q++ = *p;
1587 p++;
1588 }
1589 if (proto_size > 0)
1590 *q = '\0';
1591 if (*p == '\0') {
1592 if (proto_size > 0)
1593 proto[0] = '\0';
1594 if (hostname_size > 0)
1595 hostname[0] = '\0';
1596 p = url;
1597 } else {
1598 p++;
1599 if (*p == '/')
1600 p++;
1601 if (*p == '/')
1602 p++;
1603 q = hostname;
1604 while (*p != ':' && *p != '/' && *p != '?' && *p != '\0') {
1605 if ((q - hostname) < hostname_size - 1)
1606 *q++ = *p;
1607 p++;
1608 }
1609 if (hostname_size > 0)
1610 *q = '\0';
1611 if (*p == ':') {
1612 p++;
1613 port = strtoul(p, (char **)&p, 10);
1614 }
1615 }
1616 if (port_ptr)
1617 *port_ptr = port;
1618 pstrcpy(path, path_size, p);
1619 }
1620
1621 /**
1622 * Set the pts for a given stream
1623 * @param s stream
1624 * @param pts_wrap_bits number of bits effectively used by the pts
1625 * (used for wrap control, 33 is the value for MPEG)
1626 * @param pts_num numerator to convert to seconds (MPEG: 1)
1627 * @param pts_den denominator to convert to seconds (MPEG: 90000)
1628 */
1629 void av_set_pts_info(AVFormatContext *s, int pts_wrap_bits,
1630 int pts_num, int pts_den)
1631 {
1632 s->pts_wrap_bits = pts_wrap_bits;
1633 s->pts_num = pts_num;
1634 s->pts_den = pts_den;
1635 }
1636
1637 /* fraction handling */
1638
1639 /**
1640 * f = val + (num / den) + 0.5. 'num' is normalized so that it is such
1641 * as 0 <= num < den.
1642 *
1643 * @param f fractional number
1644 * @param val integer value
1645 * @param num must be >= 0
1646 * @param den must be >= 1
1647 */
1648 void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
1649 {
1650 num += (den >> 1);
1651 if (num >= den) {
1652 val += num / den;
1653 num = num % den;
1654 }
1655 f->val = val;
1656 f->num = num;
1657 f->den = den;
1658 }
1659
1660 /* set f to (val + 0.5) */
1661 void av_frac_set(AVFrac *f, int64_t val)
1662 {
1663 f->val = val;
1664 f->num = f->den >> 1;
1665 }
1666
1667 /**
1668 * Fractionnal addition to f: f = f + (incr / f->den)
1669 *
1670 * @param f fractional number
1671 * @param incr increment, can be positive or negative
1672 */
1673 void av_frac_add(AVFrac *f, int64_t incr)
1674 {
1675 int64_t num, den;
1676
1677 num = f->num + incr;
1678 den = f->den;
1679 if (num < 0) {
1680 f->val += num / den;
1681 num = num % den;
1682 if (num < 0) {
1683 num += den;
1684 f->val--;
1685 }
1686 } else if (num >= den) {
1687 f->val += num / den;
1688 num = num % den;
1689 }
1690 f->num = num;
1691 }
1692
1693 /**
1694 * register a new image format
1695 * @param img_fmt Image format descriptor
1696 */
1697 void av_register_image_format(AVImageFormat *img_fmt)
1698 {
1699 AVImageFormat **p;
1700
1701 p = &first_image_format;
1702 while (*p != NULL) p = &(*p)->next;
1703 *p = img_fmt;
1704 img_fmt->next = NULL;
1705 }
1706
1707 /* guess image format */
1708 AVImageFormat *av_probe_image_format(AVProbeData *pd)
1709 {
1710 AVImageFormat *fmt1, *fmt;
1711 int score, score_max;
1712
1713 fmt = NULL;
1714 score_max = 0;
1715 for(fmt1 = first_image_format; fmt1 != NULL; fmt1 = fmt1->next) {
1716 if (fmt1->img_probe) {
1717 score = fmt1->img_probe(pd);
1718 if (score > score_max) {
1719 score_max = score;
1720 fmt = fmt1;
1721 }
1722 }
1723 }
1724 return fmt;
1725 }
1726
1727 AVImageFormat *guess_image_format(const char *filename)
1728 {
1729 AVImageFormat *fmt1;
1730
1731 for(fmt1 = first_image_format; fmt1 != NULL; fmt1 = fmt1->next) {
1732 if (fmt1->extensions && match_ext(filename, fmt1->extensions))
1733 return fmt1;
1734 }
1735 return NULL;
1736 }
1737
1738 /**
1739 * Read an image from a stream.
1740 * @param gb byte stream containing the image
1741 * @param fmt image format, NULL if probing is required
1742 */
1743 int av_read_image(ByteIOContext *pb, const char *filename,
1744 AVImageFormat *fmt,
1745 int (*alloc_cb)(void *, AVImageInfo *info), void *opaque)
1746 {
1747 char buf[PROBE_BUF_SIZE];
1748 AVProbeData probe_data, *pd = &probe_data;
1749 offset_t pos;
1750 int ret;
1751
1752 if (!fmt) {
1753 pd->filename = filename;
1754 pd->buf = buf;
1755 pos = url_ftell(pb);
1756 pd->buf_size = get_buffer(pb, buf, PROBE_BUF_SIZE);
1757 url_fseek(pb, pos, SEEK_SET);
1758 fmt = av_probe_image_format(pd);
1759 }
1760 if (!fmt)
1761 return AVERROR_NOFMT;
1762 ret = fmt->img_read(pb, alloc_cb, opaque);
1763 return ret;
1764 }
1765
1766 /**
1767 * Write an image to a stream.
1768 * @param pb byte stream for the image output
1769 * @param fmt image format
1770 * @param img image data and informations
1771 */
1772 int av_write_image(ByteIOContext *pb, AVImageFormat *fmt, AVImageInfo *img)
1773 {
1774 return fmt->img_write(pb, img);
1775 }
1776