8f9b97e7b059993faf61e265c482fe0ff5847d68
[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
21 #undef NDEBUG
22 #include <assert.h>
23
24 AVInputFormat *first_iformat;
25 AVOutputFormat *first_oformat;
26 AVImageFormat *first_image_format;
27
28 void av_register_input_format(AVInputFormat *format)
29 {
30 AVInputFormat **p;
31 p = &first_iformat;
32 while (*p != NULL) p = &(*p)->next;
33 *p = format;
34 format->next = NULL;
35 }
36
37 void av_register_output_format(AVOutputFormat *format)
38 {
39 AVOutputFormat **p;
40 p = &first_oformat;
41 while (*p != NULL) p = &(*p)->next;
42 *p = format;
43 format->next = NULL;
44 }
45
46 int match_ext(const char *filename, const char *extensions)
47 {
48 const char *ext, *p;
49 char ext1[32], *q;
50
51 ext = strrchr(filename, '.');
52 if (ext) {
53 ext++;
54 p = extensions;
55 for(;;) {
56 q = ext1;
57 while (*p != '\0' && *p != ',')
58 *q++ = *p++;
59 *q = '\0';
60 if (!strcasecmp(ext1, ext))
61 return 1;
62 if (*p == '\0')
63 break;
64 p++;
65 }
66 }
67 return 0;
68 }
69
70 AVOutputFormat *guess_format(const char *short_name, const char *filename,
71 const char *mime_type)
72 {
73 AVOutputFormat *fmt, *fmt_found;
74 int score_max, score;
75
76 /* specific test for image sequences */
77 if (!short_name && filename &&
78 filename_number_test(filename) >= 0 &&
79 guess_image_format(filename)) {
80 return guess_format("image", NULL, NULL);
81 }
82
83 /* find the proper file type */
84 fmt_found = NULL;
85 score_max = 0;
86 fmt = first_oformat;
87 while (fmt != NULL) {
88 score = 0;
89 if (fmt->name && short_name && !strcmp(fmt->name, short_name))
90 score += 100;
91 if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
92 score += 10;
93 if (filename && fmt->extensions &&
94 match_ext(filename, fmt->extensions)) {
95 score += 5;
96 }
97 if (score > score_max) {
98 score_max = score;
99 fmt_found = fmt;
100 }
101 fmt = fmt->next;
102 }
103 return fmt_found;
104 }
105
106 AVOutputFormat *guess_stream_format(const char *short_name, const char *filename,
107 const char *mime_type)
108 {
109 AVOutputFormat *fmt = guess_format(short_name, filename, mime_type);
110
111 if (fmt) {
112 AVOutputFormat *stream_fmt;
113 char stream_format_name[64];
114
115 snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
116 stream_fmt = guess_format(stream_format_name, NULL, NULL);
117
118 if (stream_fmt)
119 fmt = stream_fmt;
120 }
121
122 return fmt;
123 }
124
125 AVInputFormat *av_find_input_format(const char *short_name)
126 {
127 AVInputFormat *fmt;
128 for(fmt = first_iformat; fmt != NULL; fmt = fmt->next) {
129 if (!strcmp(fmt->name, short_name))
130 return fmt;
131 }
132 return NULL;
133 }
134
135 /* memory handling */
136
137 /**
138 * Default packet destructor
139 */
140 static void av_destruct_packet(AVPacket *pkt)
141 {
142 av_free(pkt->data);
143 pkt->data = NULL; pkt->size = 0;
144 }
145
146 /**
147 * Allocate the payload of a packet and intialized its fields to default values.
148 *
149 * @param pkt packet
150 * @param size wanted payload size
151 * @return 0 if OK. AVERROR_xxx otherwise.
152 */
153 int av_new_packet(AVPacket *pkt, int size)
154 {
155 void *data = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
156 if (!data)
157 return AVERROR_NOMEM;
158 memset(data + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
159
160 av_init_packet(pkt);
161 pkt->data = data;
162 pkt->size = size;
163 pkt->destruct = av_destruct_packet;
164 return 0;
165 }
166
167 /* This is a hack - the packet memory allocation stuff is broken. The
168 packet is allocated if it was not really allocated */
169 int av_dup_packet(AVPacket *pkt)
170 {
171 if (pkt->destruct != av_destruct_packet) {
172 uint8_t *data;
173 /* we duplicate the packet and don't forget to put the padding
174 again */
175 data = av_malloc(pkt->size + FF_INPUT_BUFFER_PADDING_SIZE);
176 if (!data) {
177 return AVERROR_NOMEM;
178 }
179 memcpy(data, pkt->data, pkt->size);
180 memset(data + pkt->size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
181 pkt->data = data;
182 pkt->destruct = av_destruct_packet;
183 }
184 return 0;
185 }
186
187 /* fifo handling */
188
189 int fifo_init(FifoBuffer *f, int size)
190 {
191 f->buffer = av_malloc(size);
192 if (!f->buffer)
193 return -1;
194 f->end = f->buffer + size;
195 f->wptr = f->rptr = f->buffer;
196 return 0;
197 }
198
199 void fifo_free(FifoBuffer *f)
200 {
201 av_free(f->buffer);
202 }
203
204 int fifo_size(FifoBuffer *f, uint8_t *rptr)
205 {
206 int size;
207
208 if (f->wptr >= rptr) {
209 size = f->wptr - rptr;
210 } else {
211 size = (f->end - rptr) + (f->wptr - f->buffer);
212 }
213 return size;
214 }
215
216 /* get data from the fifo (return -1 if not enough data) */
217 int fifo_read(FifoBuffer *f, uint8_t *buf, int buf_size, uint8_t **rptr_ptr)
218 {
219 uint8_t *rptr = *rptr_ptr;
220 int size, len;
221
222 if (f->wptr >= rptr) {
223 size = f->wptr - rptr;
224 } else {
225 size = (f->end - rptr) + (f->wptr - f->buffer);
226 }
227
228 if (size < buf_size)
229 return -1;
230 while (buf_size > 0) {
231 len = f->end - rptr;
232 if (len > buf_size)
233 len = buf_size;
234 memcpy(buf, rptr, len);
235 buf += len;
236 rptr += len;
237 if (rptr >= f->end)
238 rptr = f->buffer;
239 buf_size -= len;
240 }
241 *rptr_ptr = rptr;
242 return 0;
243 }
244
245 void fifo_write(FifoBuffer *f, uint8_t *buf, int size, uint8_t **wptr_ptr)
246 {
247 int len;
248 uint8_t *wptr;
249 wptr = *wptr_ptr;
250 while (size > 0) {
251 len = f->end - wptr;
252 if (len > size)
253 len = size;
254 memcpy(wptr, buf, len);
255 wptr += len;
256 if (wptr >= f->end)
257 wptr = f->buffer;
258 buf += len;
259 size -= len;
260 }
261 *wptr_ptr = wptr;
262 }
263
264 int filename_number_test(const char *filename)
265 {
266 char buf[1024];
267 return get_frame_filename(buf, sizeof(buf), filename, 1);
268 }
269
270 /* guess file format */
271 AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened)
272 {
273 AVInputFormat *fmt1, *fmt;
274 int score, score_max;
275
276 fmt = NULL;
277 score_max = 0;
278 for(fmt1 = first_iformat; fmt1 != NULL; fmt1 = fmt1->next) {
279 if (!is_opened && !(fmt1->flags & AVFMT_NOFILE))
280 continue;
281 score = 0;
282 if (fmt1->read_probe) {
283 score = fmt1->read_probe(pd);
284 } else if (fmt1->extensions) {
285 if (match_ext(pd->filename, fmt1->extensions)) {
286 score = 50;
287 }
288 }
289 if (score > score_max) {
290 score_max = score;
291 fmt = fmt1;
292 }
293 }
294 return fmt;
295 }
296
297 /************************************************************/
298 /* input media file */
299
300 /**
301 * open a media file from an IO stream. 'fmt' must be specified.
302 */
303 int av_open_input_stream(AVFormatContext **ic_ptr,
304 ByteIOContext *pb, const char *filename,
305 AVInputFormat *fmt, AVFormatParameters *ap)
306 {
307 int err;
308 AVFormatContext *ic;
309
310 ic = av_mallocz(sizeof(AVFormatContext));
311 if (!ic) {
312 err = AVERROR_NOMEM;
313 goto fail;
314 }
315 ic->iformat = fmt;
316 if (pb)
317 ic->pb = *pb;
318 ic->duration = AV_NOPTS_VALUE;
319 ic->start_time = AV_NOPTS_VALUE;
320 pstrcpy(ic->filename, sizeof(ic->filename), filename);
321
322 /* allocate private data */
323 if (fmt->priv_data_size > 0) {
324 ic->priv_data = av_mallocz(fmt->priv_data_size);
325 if (!ic->priv_data) {
326 err = AVERROR_NOMEM;
327 goto fail;
328 }
329 } else {
330 ic->priv_data = NULL;
331 }
332
333 /* default pts settings is MPEG like */
334 av_set_pts_info(ic, 33, 1, 90000);
335 ic->last_pkt_pts = AV_NOPTS_VALUE;
336 ic->last_pkt_dts = AV_NOPTS_VALUE;
337 ic->last_pkt_stream_pts = AV_NOPTS_VALUE;
338 ic->last_pkt_stream_dts = AV_NOPTS_VALUE;
339
340 err = ic->iformat->read_header(ic, ap);
341 if (err < 0)
342 goto fail;
343
344 if (pb)
345 ic->data_offset = url_ftell(&ic->pb);
346
347 *ic_ptr = ic;
348 return 0;
349 fail:
350 if (ic) {
351 av_freep(&ic->priv_data);
352 }
353 av_free(ic);
354 *ic_ptr = NULL;
355 return err;
356 }
357
358 #define PROBE_BUF_SIZE 2048
359
360 /**
361 * Open a media file as input. The codec are not opened. Only the file
362 * header (if present) is read.
363 *
364 * @param ic_ptr the opened media file handle is put here
365 * @param filename filename to open.
366 * @param fmt if non NULL, force the file format to use
367 * @param buf_size optional buffer size (zero if default is OK)
368 * @param ap additionnal parameters needed when opening the file (NULL if default)
369 * @return 0 if OK. AVERROR_xxx otherwise.
370 */
371 int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
372 AVInputFormat *fmt,
373 int buf_size,
374 AVFormatParameters *ap)
375 {
376 int err, must_open_file, file_opened;
377 uint8_t buf[PROBE_BUF_SIZE];
378 AVProbeData probe_data, *pd = &probe_data;
379 ByteIOContext pb1, *pb = &pb1;
380
381 file_opened = 0;
382 pd->filename = "";
383 if (filename)
384 pd->filename = filename;
385 pd->buf = buf;
386 pd->buf_size = 0;
387
388 if (!fmt) {
389 /* guess format if no file can be opened */
390 fmt = av_probe_input_format(pd, 0);
391 }
392
393 /* do not open file if the format does not need it. XXX: specific
394 hack needed to handle RTSP/TCP */
395 must_open_file = 1;
396 if (fmt && (fmt->flags & AVFMT_NOFILE)) {
397 must_open_file = 0;
398 }
399
400 if (!fmt || must_open_file) {
401 /* if no file needed do not try to open one */
402 if (url_fopen(pb, filename, URL_RDONLY) < 0) {
403 err = AVERROR_IO;
404 goto fail;
405 }
406 file_opened = 1;
407 if (buf_size > 0) {
408 url_setbufsize(pb, buf_size);
409 }
410 if (!fmt) {
411 /* read probe data */
412 pd->buf_size = get_buffer(pb, buf, PROBE_BUF_SIZE);
413 url_fseek(pb, 0, SEEK_SET);
414 }
415 }
416
417 /* guess file format */
418 if (!fmt) {
419 fmt = av_probe_input_format(pd, 1);
420 }
421
422 /* if still no format found, error */
423 if (!fmt) {
424 err = AVERROR_NOFMT;
425 goto fail;
426 }
427
428 /* XXX: suppress this hack for redirectors */
429 #ifdef CONFIG_NETWORK
430 if (fmt == &redir_demux) {
431 err = redir_open(ic_ptr, pb);
432 url_fclose(pb);
433 return err;
434 }
435 #endif
436
437 /* check filename in case of an image number is expected */
438 if (fmt->flags & AVFMT_NEEDNUMBER) {
439 if (filename_number_test(filename) < 0) {
440 err = AVERROR_NUMEXPECTED;
441 goto fail;
442 }
443 }
444 err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
445 if (err)
446 goto fail;
447 return 0;
448 fail:
449 if (file_opened)
450 url_fclose(pb);
451 *ic_ptr = NULL;
452 return err;
453
454 }
455
456 /*******************************************************/
457
458 /**
459 * Read a transport packet from a media file. This function is
460 * absolete and should never be used. Use av_read_frame() instead.
461 *
462 * @param s media file handle
463 * @param pkt is filled
464 * @return 0 if OK. AVERROR_xxx if error.
465 */
466 int av_read_packet(AVFormatContext *s, AVPacket *pkt)
467 {
468 return s->iformat->read_packet(s, pkt);
469 }
470
471 /**********************************************************/
472
473 /* convert the packet time stamp units and handle wrapping. The
474 wrapping is handled by considering the next PTS/DTS as a delta to
475 the previous value. We handle the delta as a fraction to avoid any
476 rounding errors. */
477 static inline int64_t convert_timestamp_units(AVFormatContext *s,
478 int64_t *plast_pkt_pts,
479 int *plast_pkt_pts_frac,
480 int64_t *plast_pkt_stream_pts,
481 int64_t pts)
482 {
483 int64_t stream_pts;
484 int64_t delta_pts;
485 int shift, pts_frac;
486
487 if (pts != AV_NOPTS_VALUE) {
488 stream_pts = pts;
489 if (*plast_pkt_stream_pts != AV_NOPTS_VALUE) {
490 shift = 64 - s->pts_wrap_bits;
491 delta_pts = ((stream_pts - *plast_pkt_stream_pts) << shift) >> shift;
492 /* XXX: overflow possible but very unlikely as it is a delta */
493 delta_pts = delta_pts * AV_TIME_BASE * s->pts_num;
494 pts = *plast_pkt_pts + (delta_pts / s->pts_den);
495 pts_frac = *plast_pkt_pts_frac + (delta_pts % s->pts_den);
496 if (pts_frac >= s->pts_den) {
497 pts_frac -= s->pts_den;
498 pts++;
499 }
500 } else {
501 /* no previous pts, so no wrapping possible */
502 pts = (int64_t)(((double)stream_pts * AV_TIME_BASE * s->pts_num) /
503 (double)s->pts_den);
504 pts_frac = 0;
505 }
506 *plast_pkt_stream_pts = stream_pts;
507 *plast_pkt_pts = pts;
508 *plast_pkt_pts_frac = pts_frac;
509 }
510 return pts;
511 }
512
513 /* get the number of samples of an audio frame. Return (-1) if error */
514 static int get_audio_frame_size(AVCodecContext *enc, int size)
515 {
516 int frame_size;
517
518 if (enc->frame_size <= 1) {
519 /* specific hack for pcm codecs because no frame size is
520 provided */
521 switch(enc->codec_id) {
522 case CODEC_ID_PCM_S16LE:
523 case CODEC_ID_PCM_S16BE:
524 case CODEC_ID_PCM_U16LE:
525 case CODEC_ID_PCM_U16BE:
526 if (enc->channels == 0)
527 return -1;
528 frame_size = size / (2 * enc->channels);
529 break;
530 case CODEC_ID_PCM_S8:
531 case CODEC_ID_PCM_U8:
532 case CODEC_ID_PCM_MULAW:
533 case CODEC_ID_PCM_ALAW:
534 if (enc->channels == 0)
535 return -1;
536 frame_size = size / (enc->channels);
537 break;
538 default:
539 /* used for example by ADPCM codecs */
540 if (enc->bit_rate == 0)
541 return -1;
542 frame_size = (size * 8 * enc->sample_rate) / enc->bit_rate;
543 break;
544 }
545 } else {
546 frame_size = enc->frame_size;
547 }
548 return frame_size;
549 }
550
551
552 /* return the frame duration in seconds, return 0 if not available */
553 static void compute_frame_duration(int *pnum, int *pden,
554 AVFormatContext *s, AVStream *st,
555 AVCodecParserContext *pc, AVPacket *pkt)
556 {
557 int frame_size;
558
559 *pnum = 0;
560 *pden = 0;
561 switch(st->codec.codec_type) {
562 case CODEC_TYPE_VIDEO:
563 *pnum = st->codec.frame_rate_base;
564 *pden = st->codec.frame_rate;
565 if (pc && pc->repeat_pict) {
566 *pden *= 2;
567 *pnum = (*pnum) * (2 + pc->repeat_pict);
568 }
569 break;
570 case CODEC_TYPE_AUDIO:
571 frame_size = get_audio_frame_size(&st->codec, pkt->size);
572 if (frame_size < 0)
573 break;
574 *pnum = frame_size;
575 *pden = st->codec.sample_rate;
576 break;
577 default:
578 break;
579 }
580 }
581
582 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
583 AVCodecParserContext *pc, AVPacket *pkt)
584 {
585 int num, den, presentation_delayed;
586
587 if (pkt->duration == 0) {
588 compute_frame_duration(&num, &den, s, st, pc, pkt);
589 if (den && num) {
590 pkt->duration = (num * (int64_t)AV_TIME_BASE) / den;
591 }
592 }
593
594 /* do we have a video B frame ? */
595 presentation_delayed = 0;
596 if (st->codec.codec_type == CODEC_TYPE_VIDEO) {
597 /* XXX: need has_b_frame, but cannot get it if the codec is
598 not initialized */
599 if ((st->codec.codec_id == CODEC_ID_MPEG1VIDEO ||
600 st->codec.codec_id == CODEC_ID_MPEG2VIDEO ||
601 st->codec.codec_id == CODEC_ID_MPEG4 ||
602 st->codec.codec_id == CODEC_ID_H264) &&
603 pc && pc->pict_type != FF_B_TYPE)
604 presentation_delayed = 1;
605 }
606
607 /* interpolate PTS and DTS if they are not present */
608 if (presentation_delayed) {
609 /* DTS = decompression time stamp */
610 /* PTS = presentation time stamp */
611 if (pkt->dts == AV_NOPTS_VALUE) {
612 pkt->dts = st->cur_dts;
613 } else {
614 st->cur_dts = pkt->dts;
615 }
616 /* this is tricky: the dts must be incremented by the duration
617 of the frame we are displaying, i.e. the last I or P frame */
618 if (st->last_IP_duration == 0)
619 st->cur_dts += pkt->duration;
620 else
621 st->cur_dts += st->last_IP_duration;
622 st->last_IP_duration = pkt->duration;
623 /* cannot compute PTS if not present (we can compute it only
624 by knowing the futur */
625 } else {
626 /* presentation is not delayed : PTS and DTS are the same */
627 if (pkt->pts == AV_NOPTS_VALUE) {
628 if (pkt->dts == AV_NOPTS_VALUE) {
629 pkt->pts = st->cur_dts;
630 pkt->dts = st->cur_dts;
631 }
632 else {
633 st->cur_dts = pkt->dts;
634 pkt->pts = pkt->dts;
635 }
636 } else {
637 st->cur_dts = pkt->pts;
638 pkt->dts = pkt->pts;
639 }
640 st->cur_dts += pkt->duration;
641 }
642
643 /* update flags */
644 if (pc) {
645 pkt->flags = 0;
646 /* key frame computation */
647 switch(st->codec.codec_type) {
648 case CODEC_TYPE_VIDEO:
649 if (pc->pict_type == FF_I_TYPE)
650 pkt->flags |= PKT_FLAG_KEY;
651 break;
652 case CODEC_TYPE_AUDIO:
653 pkt->flags |= PKT_FLAG_KEY;
654 break;
655 default:
656 break;
657 }
658 }
659
660 }
661
662 static void av_destruct_packet_nofree(AVPacket *pkt)
663 {
664 pkt->data = NULL; pkt->size = 0;
665 }
666
667 static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
668 {
669 AVStream *st;
670 int len, ret, i;
671
672 for(;;) {
673 /* select current input stream component */
674 st = s->cur_st;
675 if (st) {
676 if (!st->parser) {
677 /* no parsing needed: we just output the packet as is */
678 /* raw data support */
679 *pkt = s->cur_pkt;
680 compute_pkt_fields(s, st, NULL, pkt);
681 s->cur_st = NULL;
682 return 0;
683 } else if (s->cur_len > 0) {
684 len = av_parser_parse(st->parser, &st->codec, &pkt->data, &pkt->size,
685 s->cur_ptr, s->cur_len,
686 s->cur_pkt.pts, s->cur_pkt.dts);
687 s->cur_pkt.pts = AV_NOPTS_VALUE;
688 s->cur_pkt.dts = AV_NOPTS_VALUE;
689 /* increment read pointer */
690 s->cur_ptr += len;
691 s->cur_len -= len;
692
693 /* return packet if any */
694 if (pkt->size) {
695 got_packet:
696 pkt->duration = 0;
697 pkt->stream_index = st->index;
698 pkt->pts = st->parser->pts;
699 pkt->dts = st->parser->dts;
700 pkt->destruct = av_destruct_packet_nofree;
701 compute_pkt_fields(s, st, st->parser, pkt);
702 return 0;
703 }
704 } else {
705 /* free packet */
706 av_free_packet(&s->cur_pkt);
707 s->cur_st = NULL;
708 }
709 } else {
710 /* read next packet */
711 ret = av_read_packet(s, &s->cur_pkt);
712 if (ret < 0) {
713 if (ret == -EAGAIN)
714 return ret;
715 /* return the last frames, if any */
716 for(i = 0; i < s->nb_streams; i++) {
717 st = s->streams[i];
718 if (st->parser) {
719 av_parser_parse(st->parser, &st->codec,
720 &pkt->data, &pkt->size,
721 NULL, 0,
722 AV_NOPTS_VALUE, AV_NOPTS_VALUE);
723 if (pkt->size)
724 goto got_packet;
725 }
726 }
727 /* no more packets: really terminates parsing */
728 return ret;
729 }
730
731 /* convert the packet time stamp units and handle wrapping */
732 s->cur_pkt.pts = convert_timestamp_units(s,
733 &s->last_pkt_pts, &s->last_pkt_pts_frac,
734 &s->last_pkt_stream_pts,
735 s->cur_pkt.pts);
736 s->cur_pkt.dts = convert_timestamp_units(s,
737 &s->last_pkt_dts, &s->last_pkt_dts_frac,
738 &s->last_pkt_stream_dts,
739 s->cur_pkt.dts);
740 #if 0
741 if (s->cur_pkt.stream_index == 0) {
742 if (s->cur_pkt.pts != AV_NOPTS_VALUE)
743 printf("PACKET pts=%0.3f\n",
744 (double)s->cur_pkt.pts / AV_TIME_BASE);
745 if (s->cur_pkt.dts != AV_NOPTS_VALUE)
746 printf("PACKET dts=%0.3f\n",
747 (double)s->cur_pkt.dts / AV_TIME_BASE);
748 }
749 #endif
750
751 /* duration field */
752 if (s->cur_pkt.duration != 0) {
753 s->cur_pkt.duration = ((int64_t)s->cur_pkt.duration * AV_TIME_BASE * s->pts_num) /
754 s->pts_den;
755 }
756
757 st = s->streams[s->cur_pkt.stream_index];
758 s->cur_st = st;
759 s->cur_ptr = s->cur_pkt.data;
760 s->cur_len = s->cur_pkt.size;
761 if (st->need_parsing && !st->parser) {
762 st->parser = av_parser_init(st->codec.codec_id);
763 if (!st->parser) {
764 /* no parser available : just output the raw packets */
765 st->need_parsing = 0;
766 }
767 }
768 }
769 }
770 }
771
772 /**
773 * Return the next frame of a stream. The returned packet is valid
774 * until the next av_read_frame() or until av_close_input_file() and
775 * must be freed with av_free_packet. For video, the packet contains
776 * exactly one frame. For audio, it contains an integer number of
777 * frames if each frame has a known fixed size (e.g. PCM or ADPCM
778 * data). If the audio frames have a variable size (e.g. MPEG audio),
779 * then it contains one frame.
780 *
781 * pkt->pts, pkt->dts and pkt->duration are always set to correct
782 * values in AV_TIME_BASE unit (and guessed if the format cannot
783 * provided them). pkt->pts can be AV_NOPTS_VALUE if the video format
784 * has B frames, so it is better to rely on pkt->dts if you do not
785 * decompress the payload.
786 *
787 * Return 0 if OK, < 0 if error or end of file.
788 */
789 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
790 {
791 AVPacketList *pktl;
792
793 pktl = s->packet_buffer;
794 if (pktl) {
795 /* read packet from packet buffer, if there is data */
796 *pkt = pktl->pkt;
797 s->packet_buffer = pktl->next;
798 av_free(pktl);
799 return 0;
800 } else {
801 return av_read_frame_internal(s, pkt);
802 }
803 }
804
805 /* XXX: suppress the packet queue */
806 static void flush_packet_queue(AVFormatContext *s)
807 {
808 AVPacketList *pktl;
809
810 for(;;) {
811 pktl = s->packet_buffer;
812 if (!pktl)
813 break;
814 s->packet_buffer = pktl->next;
815 av_free_packet(&pktl->pkt);
816 av_free(pktl);
817 }
818 }
819
820 /*******************************************************/
821 /* seek support */
822
823 int av_find_default_stream_index(AVFormatContext *s)
824 {
825 int i;
826 AVStream *st;
827
828 if (s->nb_streams <= 0)
829 return -1;
830 for(i = 0; i < s->nb_streams; i++) {
831 st = s->streams[i];
832 if (st->codec.codec_type == CODEC_TYPE_VIDEO) {
833 return i;
834 }
835 }
836 return 0;
837 }
838
839 /* flush the frame reader */
840 static void av_read_frame_flush(AVFormatContext *s)
841 {
842 AVStream *st;
843 int i;
844
845 flush_packet_queue(s);
846
847 /* free previous packet */
848 if (s->cur_st) {
849 if (s->cur_st->parser)
850 av_free_packet(&s->cur_pkt);
851 s->cur_st = NULL;
852 }
853 /* fail safe */
854 s->cur_ptr = NULL;
855 s->cur_len = 0;
856
857 /* for each stream, reset read state */
858 for(i = 0; i < s->nb_streams; i++) {
859 st = s->streams[i];
860
861 if (st->parser) {
862 av_parser_close(st->parser);
863 st->parser = NULL;
864 }
865 st->cur_dts = 0; /* we set the current DTS to an unspecified origin */
866 }
867 }
868
869 /* add a index entry into a sorted list updateing if it is already there */
870 int av_add_index_entry(AVStream *st,
871 int64_t pos, int64_t timestamp, int distance, int flags)
872 {
873 AVIndexEntry *entries, *ie;
874 int index;
875
876 entries = av_fast_realloc(st->index_entries,
877 &st->index_entries_allocated_size,
878 (st->nb_index_entries + 1) *
879 sizeof(AVIndexEntry));
880 st->index_entries= entries;
881
882 if(st->nb_index_entries){
883 index= av_index_search_timestamp(st, timestamp);
884 ie= &entries[index];
885
886 if(ie->timestamp != timestamp){
887 if(ie->timestamp < timestamp){
888 index++; //index points to next instead of previous entry, maybe nonexistant
889 ie= &st->index_entries[index];
890 }else
891 assert(index==0);
892
893 if(index != st->nb_index_entries){
894 assert(index < st->nb_index_entries);
895 memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
896 }
897 st->nb_index_entries++;
898 }
899 }else{
900 index= st->nb_index_entries++;
901 ie= &entries[index];
902 }
903
904 ie->pos = pos;
905 ie->timestamp = timestamp;
906 ie->min_distance= distance;
907 ie->flags = flags;
908
909 return index;
910 }
911
912 /* build an index for raw streams using a parser */
913 static void av_build_index_raw(AVFormatContext *s)
914 {
915 AVPacket pkt1, *pkt = &pkt1;
916 int ret;
917 AVStream *st;
918
919 st = s->streams[0];
920 av_read_frame_flush(s);
921 url_fseek(&s->pb, s->data_offset, SEEK_SET);
922
923 for(;;) {
924 ret = av_read_frame(s, pkt);
925 if (ret < 0)
926 break;
927 if (pkt->stream_index == 0 && st->parser &&
928 (pkt->flags & PKT_FLAG_KEY)) {
929 av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
930 0, AVINDEX_KEYFRAME);
931 }
932 av_free_packet(pkt);
933 }
934 }
935
936 /* return TRUE if we deal with a raw stream (raw codec data and
937 parsing needed) */
938 static int is_raw_stream(AVFormatContext *s)
939 {
940 AVStream *st;
941
942 if (s->nb_streams != 1)
943 return 0;
944 st = s->streams[0];
945 if (!st->need_parsing)
946 return 0;
947 return 1;
948 }
949
950 /* return the largest index entry whose timestamp is <=
951 wanted_timestamp */
952 int av_index_search_timestamp(AVStream *st, int wanted_timestamp)
953 {
954 AVIndexEntry *entries= st->index_entries;
955 int nb_entries= st->nb_index_entries;
956 int a, b, m;
957 int64_t timestamp;
958
959 if (nb_entries <= 0)
960 return -1;
961
962 a = 0;
963 b = nb_entries - 1;
964
965 while (a < b) {
966 m = (a + b + 1) >> 1;
967 timestamp = entries[m].timestamp;
968 if (timestamp > wanted_timestamp) {
969 b = m - 1;
970 } else {
971 a = m;
972 }
973 }
974 return a;
975 }
976
977 static int av_seek_frame_generic(AVFormatContext *s,
978 int stream_index, int64_t timestamp)
979 {
980 int index;
981 AVStream *st;
982 AVIndexEntry *ie;
983
984 if (!s->index_built) {
985 if (is_raw_stream(s)) {
986 av_build_index_raw(s);
987 } else {
988 return -1;
989 }
990 s->index_built = 1;
991 }
992
993 if (stream_index < 0)
994 stream_index = 0;
995 st = s->streams[stream_index];
996 index = av_index_search_timestamp(st, timestamp);
997 if (index < 0)
998 return -1;
999
1000 /* now we have found the index, we can seek */
1001 ie = &st->index_entries[index];
1002 av_read_frame_flush(s);
1003 url_fseek(&s->pb, ie->pos, SEEK_SET);
1004 st->cur_dts = ie->timestamp;
1005 return 0;
1006 }
1007
1008 /**
1009 * Seek to the key frame just before the frame at timestamp
1010 * 'timestamp' in 'stream_index'. If stream_index is (-1), a default
1011 * stream is selected
1012 */
1013 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp)
1014 {
1015 int ret;
1016
1017 av_read_frame_flush(s);
1018
1019 /* first, we try the format specific seek */
1020 if (s->iformat->read_seek)
1021 ret = s->iformat->read_seek(s, stream_index, timestamp);
1022 else
1023 ret = -1;
1024 if (ret >= 0) {
1025 return 0;
1026 }
1027
1028 return av_seek_frame_generic(s, stream_index, timestamp);
1029 }
1030
1031 /*******************************************************/
1032
1033 /* return TRUE if the stream has accurate timings for at least one component */
1034 static int av_has_timings(AVFormatContext *ic)
1035 {
1036 int i;
1037 AVStream *st;
1038
1039 for(i = 0;i < ic->nb_streams; i++) {
1040 st = ic->streams[i];
1041 if (st->start_time != AV_NOPTS_VALUE &&
1042 st->duration != AV_NOPTS_VALUE)
1043 return 1;
1044 }
1045 return 0;
1046 }
1047
1048 /* estimate the stream timings from the one of each components. Also
1049 compute the global bitrate if possible */
1050 static void av_update_stream_timings(AVFormatContext *ic)
1051 {
1052 int64_t start_time, end_time, end_time1;
1053 int i;
1054 AVStream *st;
1055
1056 start_time = MAXINT64;
1057 end_time = MININT64;
1058 for(i = 0;i < ic->nb_streams; i++) {
1059 st = ic->streams[i];
1060 if (st->start_time != AV_NOPTS_VALUE) {
1061 if (st->start_time < start_time)
1062 start_time = st->start_time;
1063 if (st->duration != AV_NOPTS_VALUE) {
1064 end_time1 = st->start_time + st->duration;
1065 if (end_time1 > end_time)
1066 end_time = end_time1;
1067 }
1068 }
1069 }
1070 if (start_time != MAXINT64) {
1071 ic->start_time = start_time;
1072 if (end_time != MAXINT64) {
1073 ic->duration = end_time - start_time;
1074 if (ic->file_size > 0) {
1075 /* compute the bit rate */
1076 ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1077 (double)ic->duration;
1078 }
1079 }
1080 }
1081
1082 }
1083
1084 static void fill_all_stream_timings(AVFormatContext *ic)
1085 {
1086 int i;
1087 AVStream *st;
1088
1089 av_update_stream_timings(ic);
1090 for(i = 0;i < ic->nb_streams; i++) {
1091 st = ic->streams[i];
1092 if (st->start_time == AV_NOPTS_VALUE) {
1093 st->start_time = ic->start_time;
1094 st->duration = ic->duration;
1095 }
1096 }
1097 }
1098
1099 static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1100 {
1101 int64_t filesize, duration;
1102 int bit_rate, i;
1103 AVStream *st;
1104
1105 /* if bit_rate is already set, we believe it */
1106 if (ic->bit_rate == 0) {
1107 bit_rate = 0;
1108 for(i=0;i<ic->nb_streams;i++) {
1109 st = ic->streams[i];
1110 bit_rate += st->codec.bit_rate;
1111 }
1112 ic->bit_rate = bit_rate;
1113 }
1114
1115 /* if duration is already set, we believe it */
1116 if (ic->duration == AV_NOPTS_VALUE &&
1117 ic->bit_rate != 0 &&
1118 ic->file_size != 0) {
1119 filesize = ic->file_size;
1120 if (filesize > 0) {
1121 duration = (int64_t)((8 * AV_TIME_BASE * (double)filesize) / (double)ic->bit_rate);
1122 for(i = 0; i < ic->nb_streams; i++) {
1123 st = ic->streams[i];
1124 if (st->start_time == AV_NOPTS_VALUE ||
1125 st->duration == AV_NOPTS_VALUE) {
1126 st->start_time = 0;
1127 st->duration = duration;
1128 }
1129 }
1130 }
1131 }
1132 }
1133
1134 #define DURATION_MAX_READ_SIZE 250000
1135
1136 /* only usable for MPEG-PS streams */
1137 static void av_estimate_timings_from_pts(AVFormatContext *ic)
1138 {
1139 AVPacket pkt1, *pkt = &pkt1;
1140 AVStream *st;
1141 int read_size, i, ret;
1142 int64_t start_time, end_time, end_time1;
1143 int64_t filesize, offset, duration;
1144
1145 /* free previous packet */
1146 if (ic->cur_st && ic->cur_st->parser)
1147 av_free_packet(&ic->cur_pkt);
1148 ic->cur_st = NULL;
1149
1150 /* flush packet queue */
1151 flush_packet_queue(ic);
1152
1153
1154 /* we read the first packets to get the first PTS (not fully
1155 accurate, but it is enough now) */
1156 url_fseek(&ic->pb, 0, SEEK_SET);
1157 read_size = 0;
1158 for(;;) {
1159 if (read_size >= DURATION_MAX_READ_SIZE)
1160 break;
1161 /* if all info is available, we can stop */
1162 for(i = 0;i < ic->nb_streams; i++) {
1163 st = ic->streams[i];
1164 if (st->start_time == AV_NOPTS_VALUE)
1165 break;
1166 }
1167 if (i == ic->nb_streams)
1168 break;
1169
1170 ret = av_read_packet(ic, pkt);
1171 if (ret != 0)
1172 break;
1173 read_size += pkt->size;
1174 st = ic->streams[pkt->stream_index];
1175 if (pkt->pts != AV_NOPTS_VALUE) {
1176 if (st->start_time == AV_NOPTS_VALUE)
1177 st->start_time = (int64_t)((double)pkt->pts * ic->pts_num * (double)AV_TIME_BASE / ic->pts_den);
1178 }
1179 av_free_packet(pkt);
1180 }
1181
1182 /* we compute the minimum start_time and use it as default */
1183 start_time = MAXINT64;
1184 for(i = 0; i < ic->nb_streams; i++) {
1185 st = ic->streams[i];
1186 if (st->start_time != AV_NOPTS_VALUE &&
1187 st->start_time < start_time)
1188 start_time = st->start_time;
1189 }
1190 if (start_time != MAXINT64)
1191 ic->start_time = start_time;
1192
1193 /* estimate the end time (duration) */
1194 /* XXX: may need to support wrapping */
1195 filesize = ic->file_size;
1196 offset = filesize - DURATION_MAX_READ_SIZE;
1197 if (offset < 0)
1198 offset = 0;
1199
1200 url_fseek(&ic->pb, offset, SEEK_SET);
1201 read_size = 0;
1202 for(;;) {
1203 if (read_size >= DURATION_MAX_READ_SIZE)
1204 break;
1205 /* if all info is available, we can stop */
1206 for(i = 0;i < ic->nb_streams; i++) {
1207 st = ic->streams[i];
1208 if (st->duration == AV_NOPTS_VALUE)
1209 break;
1210 }
1211 if (i == ic->nb_streams)
1212 break;
1213
1214 ret = av_read_packet(ic, pkt);
1215 if (ret != 0)
1216 break;
1217 read_size += pkt->size;
1218 st = ic->streams[pkt->stream_index];
1219 if (pkt->pts != AV_NOPTS_VALUE) {
1220 end_time = (int64_t)((double)pkt->pts * ic->pts_num * (double)AV_TIME_BASE / ic->pts_den);
1221 duration = end_time - st->start_time;
1222 if (duration > 0) {
1223 if (st->duration == AV_NOPTS_VALUE ||
1224 st->duration < duration)
1225 st->duration = duration;
1226 }
1227 }
1228 av_free_packet(pkt);
1229 }
1230
1231 /* estimate total duration */
1232 end_time = MININT64;
1233 for(i = 0;i < ic->nb_streams; i++) {
1234 st = ic->streams[i];
1235 if (st->duration != AV_NOPTS_VALUE) {
1236 end_time1 = st->start_time + st->duration;
1237 if (end_time1 > end_time)
1238 end_time = end_time1;
1239 }
1240 }
1241
1242 /* update start_time (new stream may have been created, so we do
1243 it at the end */
1244 if (ic->start_time != AV_NOPTS_VALUE) {
1245 for(i = 0; i < ic->nb_streams; i++) {
1246 st = ic->streams[i];
1247 if (st->start_time == AV_NOPTS_VALUE)
1248 st->start_time = ic->start_time;
1249 }
1250 }
1251
1252 if (end_time != MININT64) {
1253 /* put dummy values for duration if needed */
1254 for(i = 0;i < ic->nb_streams; i++) {
1255 st = ic->streams[i];
1256 if (st->duration == AV_NOPTS_VALUE &&
1257 st->start_time != AV_NOPTS_VALUE)
1258 st->duration = end_time - st->start_time;
1259 }
1260 ic->duration = end_time - ic->start_time;
1261 }
1262
1263 url_fseek(&ic->pb, 0, SEEK_SET);
1264 }
1265
1266 static void av_estimate_timings(AVFormatContext *ic)
1267 {
1268 URLContext *h;
1269 int64_t file_size;
1270
1271 /* get the file size, if possible */
1272 if (ic->iformat->flags & AVFMT_NOFILE) {
1273 file_size = 0;
1274 } else {
1275 h = url_fileno(&ic->pb);
1276 file_size = url_filesize(h);
1277 if (file_size < 0)
1278 file_size = 0;
1279 }
1280 ic->file_size = file_size;
1281
1282 if (ic->iformat == &mpegps_demux) {
1283 /* get accurate estimate from the PTSes */
1284 av_estimate_timings_from_pts(ic);
1285 } else if (av_has_timings(ic)) {
1286 /* at least one components has timings - we use them for all
1287 the components */
1288 fill_all_stream_timings(ic);
1289 } else {
1290 /* less precise: use bit rate info */
1291 av_estimate_timings_from_bit_rate(ic);
1292 }
1293 av_update_stream_timings(ic);
1294
1295 #if 0
1296 {
1297 int i;
1298 AVStream *st;
1299 for(i = 0;i < ic->nb_streams; i++) {
1300 st = ic->streams[i];
1301 printf("%d: start_time: %0.3f duration: %0.3f\n",
1302 i, (double)st->start_time / AV_TIME_BASE,
1303 (double)st->duration / AV_TIME_BASE);
1304 }
1305 printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1306 (double)ic->start_time / AV_TIME_BASE,
1307 (double)ic->duration / AV_TIME_BASE,
1308 ic->bit_rate / 1000);
1309 }
1310 #endif
1311 }
1312
1313 static int has_codec_parameters(AVCodecContext *enc)
1314 {
1315 int val;
1316 switch(enc->codec_type) {
1317 case CODEC_TYPE_AUDIO:
1318 val = enc->sample_rate;
1319 break;
1320 case CODEC_TYPE_VIDEO:
1321 val = enc->width;
1322 break;
1323 default:
1324 val = 1;
1325 break;
1326 }
1327 return (val != 0);
1328 }
1329
1330 static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1331 {
1332 int16_t *samples;
1333 AVCodec *codec;
1334 int got_picture, ret;
1335 AVFrame picture;
1336
1337 codec = avcodec_find_decoder(st->codec.codec_id);
1338 if (!codec)
1339 return -1;
1340 ret = avcodec_open(&st->codec, codec);
1341 if (ret < 0)
1342 return ret;
1343 switch(st->codec.codec_type) {
1344 case CODEC_TYPE_VIDEO:
1345 ret = avcodec_decode_video(&st->codec, &picture,
1346 &got_picture, (uint8_t *)data, size);
1347 break;
1348 case CODEC_TYPE_AUDIO:
1349 samples = av_malloc(AVCODEC_MAX_AUDIO_FRAME_SIZE);
1350 if (!samples)
1351 goto fail;
1352 ret = avcodec_decode_audio(&st->codec, samples,
1353 &got_picture, (uint8_t *)data, size);
1354 av_free(samples);
1355 break;
1356 default:
1357 break;
1358 }
1359 fail:
1360 avcodec_close(&st->codec);
1361 return ret;
1362 }
1363
1364 /* absolute maximum size we read until we abort */
1365 #define MAX_READ_SIZE 5000000
1366
1367 /* maximum duration until we stop analysing the stream */
1368 #define MAX_STREAM_DURATION ((int)(AV_TIME_BASE * 1.0))
1369
1370 /**
1371 * Read the beginning of a media file to get stream information. This
1372 * is useful for file formats with no headers such as MPEG. This
1373 * function also compute the real frame rate in case of mpeg2 repeat
1374 * frame mode.
1375 *
1376 * @param ic media file handle
1377 * @return >=0 if OK. AVERROR_xxx if error.
1378 */
1379 int av_find_stream_info(AVFormatContext *ic)
1380 {
1381 int i, count, ret, read_size;
1382 AVStream *st;
1383 AVPacket pkt1, *pkt;
1384 AVPacketList *pktl=NULL, **ppktl;
1385
1386 count = 0;
1387 read_size = 0;
1388 ppktl = &ic->packet_buffer;
1389 for(;;) {
1390 /* check if one codec still needs to be handled */
1391 for(i=0;i<ic->nb_streams;i++) {
1392 st = ic->streams[i];
1393 if (!has_codec_parameters(&st->codec))
1394 break;
1395 }
1396 if (i == ic->nb_streams) {
1397 /* NOTE: if the format has no header, then we need to read
1398 some packets to get most of the streams, so we cannot
1399 stop here */
1400 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
1401 /* if we found the info for all the codecs, we can stop */
1402 ret = count;
1403 break;
1404 }
1405 } else {
1406 /* we did not get all the codec info, but we read too much data */
1407 if (read_size >= MAX_READ_SIZE) {
1408 ret = count;
1409 break;
1410 }
1411 }
1412
1413 /* NOTE: a new stream can be added there if no header in file
1414 (AVFMTCTX_NOHEADER) */
1415 ret = av_read_frame_internal(ic, &pkt1);
1416 if (ret < 0) {
1417 /* EOF or error */
1418 ret = -1; /* we could not have all the codec parameters before EOF */
1419 if ((ic->ctx_flags & AVFMTCTX_NOHEADER) &&
1420 i == ic->nb_streams)
1421 ret = 0;
1422 break;
1423 }
1424
1425 pktl = av_mallocz(sizeof(AVPacketList));
1426 if (!pktl) {
1427 ret = AVERROR_NOMEM;
1428 break;
1429 }
1430
1431 /* add the packet in the buffered packet list */
1432 *ppktl = pktl;
1433 ppktl = &pktl->next;
1434
1435 pkt = &pktl->pkt;
1436 *pkt = pkt1;
1437
1438 /* duplicate the packet */
1439 if (av_dup_packet(pkt) < 0) {
1440 ret = AVERROR_NOMEM;
1441 break;
1442 }
1443
1444 read_size += pkt->size;
1445
1446 st = ic->streams[pkt->stream_index];
1447 st->codec_info_duration += pkt->duration;
1448 if (pkt->duration != 0)
1449 st->codec_info_nb_frames++;
1450
1451 /* if still no information, we try to open the codec and to
1452 decompress the frame. We try to avoid that in most cases as
1453 it takes longer and uses more memory. For MPEG4, we need to
1454 decompress for Quicktime. */
1455 if (!has_codec_parameters(&st->codec) &&
1456 (st->codec.codec_id == CODEC_ID_FLV1 ||
1457 st->codec.codec_id == CODEC_ID_H264 ||
1458 st->codec.codec_id == CODEC_ID_H263 ||
1459 (st->codec.codec_id == CODEC_ID_MPEG4 && !st->need_parsing)))
1460 try_decode_frame(st, pkt->data, pkt->size);
1461
1462 if (st->codec_info_duration >= MAX_STREAM_DURATION) {
1463 break;
1464 }
1465 count++;
1466 }
1467
1468 /* set real frame rate info */
1469 for(i=0;i<ic->nb_streams;i++) {
1470 st = ic->streams[i];
1471 if (st->codec.codec_type == CODEC_TYPE_VIDEO) {
1472 /* compute the real frame rate for telecine */
1473 if ((st->codec.codec_id == CODEC_ID_MPEG1VIDEO ||
1474 st->codec.codec_id == CODEC_ID_MPEG2VIDEO) &&
1475 st->codec.sub_id == 2) {
1476 if (st->codec_info_nb_frames >= 20) {
1477 float coded_frame_rate, est_frame_rate;
1478 est_frame_rate = ((double)st->codec_info_nb_frames * AV_TIME_BASE) /
1479 (double)st->codec_info_duration ;
1480 coded_frame_rate = (double)st->codec.frame_rate /
1481 (double)st->codec.frame_rate_base;
1482 #if 0
1483 printf("telecine: coded_frame_rate=%0.3f est_frame_rate=%0.3f\n",
1484 coded_frame_rate, est_frame_rate);
1485 #endif
1486 /* if we detect that it could be a telecine, we
1487 signal it. It would be better to do it at a
1488 higher level as it can change in a film */
1489 if (coded_frame_rate >= 24.97 &&
1490 (est_frame_rate >= 23.5 && est_frame_rate < 24.5)) {
1491 st->r_frame_rate = 24024;
1492 st->r_frame_rate_base = 1001;
1493 }
1494 }
1495 }
1496 /* if no real frame rate, use the codec one */
1497 if (!st->r_frame_rate){
1498 st->r_frame_rate = st->codec.frame_rate;
1499 st->r_frame_rate_base = st->codec.frame_rate_base;
1500 }
1501 }
1502 }
1503
1504 av_estimate_timings(ic);
1505 return ret;
1506 }
1507
1508 /*******************************************************/
1509
1510 /**
1511 * start playing a network based stream (e.g. RTSP stream) at the
1512 * current position
1513 */
1514 int av_read_play(AVFormatContext *s)
1515 {
1516 if (!s->iformat->read_play)
1517 return AVERROR_NOTSUPP;
1518 return s->iformat->read_play(s);
1519 }
1520
1521 /**
1522 * pause a network based stream (e.g. RTSP stream). Use av_read_play()
1523 * to resume it.
1524 */
1525 int av_read_pause(AVFormatContext *s)
1526 {
1527 if (!s->iformat->read_pause)
1528 return AVERROR_NOTSUPP;
1529 return s->iformat->read_pause(s);
1530 }
1531
1532 /**
1533 * Close a media file (but not its codecs)
1534 *
1535 * @param s media file handle
1536 */
1537 void av_close_input_file(AVFormatContext *s)
1538 {
1539 int i, must_open_file;
1540 AVStream *st;
1541
1542 /* free previous packet */
1543 if (s->cur_st && s->cur_st->parser)
1544 av_free_packet(&s->cur_pkt);
1545
1546 if (s->iformat->read_close)
1547 s->iformat->read_close(s);
1548 for(i=0;i<s->nb_streams;i++) {
1549 /* free all data in a stream component */
1550 st = s->streams[i];
1551 if (st->parser) {
1552 av_parser_close(st->parser);
1553 }
1554 av_free(st->index_entries);
1555 av_free(st);
1556 }
1557 flush_packet_queue(s);
1558 must_open_file = 1;
1559 if (s->iformat->flags & AVFMT_NOFILE) {
1560 must_open_file = 0;
1561 }
1562 if (must_open_file) {
1563 url_fclose(&s->pb);
1564 }
1565 av_freep(&s->priv_data);
1566 av_free(s);
1567 }
1568
1569 /**
1570 * Add a new stream to a media file. Can only be called in the
1571 * read_header function. If the flag AVFMTCTX_NOHEADER is in the
1572 * format context, then new streams can be added in read_packet too.
1573 *
1574 *
1575 * @param s media file handle
1576 * @param id file format dependent stream id
1577 */
1578 AVStream *av_new_stream(AVFormatContext *s, int id)
1579 {
1580 AVStream *st;
1581
1582 if (s->nb_streams >= MAX_STREAMS)
1583 return NULL;
1584
1585 st = av_mallocz(sizeof(AVStream));
1586 if (!st)
1587 return NULL;
1588 avcodec_get_context_defaults(&st->codec);
1589 if (s->iformat) {
1590 /* no default bitrate if decoding */
1591 st->codec.bit_rate = 0;
1592 }
1593 st->index = s->nb_streams;
1594 st->id = id;
1595 st->start_time = AV_NOPTS_VALUE;
1596 st->duration = AV_NOPTS_VALUE;
1597 s->streams[s->nb_streams++] = st;
1598 return st;
1599 }
1600
1601 /************************************************************/
1602 /* output media file */
1603
1604 int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
1605 {
1606 int ret;
1607
1608 if (s->oformat->priv_data_size > 0) {
1609 s->priv_data = av_mallocz(s->oformat->priv_data_size);
1610 if (!s->priv_data)
1611 return AVERROR_NOMEM;
1612 } else
1613 s->priv_data = NULL;
1614
1615 if (s->oformat->set_parameters) {
1616 ret = s->oformat->set_parameters(s, ap);
1617 if (ret < 0)
1618 return ret;
1619 }
1620 return 0;
1621 }
1622
1623 /**
1624 * allocate the stream private data and write the stream header to an
1625 * output media file
1626 *
1627 * @param s media file handle
1628 * @return 0 if OK. AVERROR_xxx if error.
1629 */
1630 int av_write_header(AVFormatContext *s)
1631 {
1632 int ret, i;
1633 AVStream *st;
1634
1635 /* default pts settings is MPEG like */
1636 av_set_pts_info(s, 33, 1, 90000);
1637 ret = s->oformat->write_header(s);
1638 if (ret < 0)
1639 return ret;
1640
1641 /* init PTS generation */
1642 for(i=0;i<s->nb_streams;i++) {
1643 st = s->streams[i];
1644
1645 switch (st->codec.codec_type) {
1646 case CODEC_TYPE_AUDIO:
1647 av_frac_init(&st->pts, 0, 0,
1648 (int64_t)s->pts_num * st->codec.sample_rate);
1649 break;
1650 case CODEC_TYPE_VIDEO:
1651 av_frac_init(&st->pts, 0, 0,
1652 (int64_t)s->pts_num * st->codec.frame_rate);
1653 break;
1654 default:
1655 break;
1656 }
1657 }
1658 return 0;
1659 }
1660
1661 /**
1662 * Write a packet to an output media file. The packet shall contain
1663 * one audio or video frame.
1664 *
1665 * @param s media file handle
1666 * @param stream_index stream index
1667 * @param buf buffer containing the frame data
1668 * @param size size of buffer
1669 * @return < 0 if error, = 0 if OK, 1 if end of stream wanted.
1670 */
1671 int av_write_frame(AVFormatContext *s, int stream_index, const uint8_t *buf,
1672 int size)
1673 {
1674 AVStream *st;
1675 int64_t pts_mask;
1676 int ret, frame_size;
1677
1678 st = s->streams[stream_index];
1679 pts_mask = (1LL << s->pts_wrap_bits) - 1;
1680 ret = s->oformat->write_packet(s, stream_index, buf, size,
1681 st->pts.val & pts_mask);
1682 if (ret < 0)
1683 return ret;
1684
1685 /* update pts */
1686 switch (st->codec.codec_type) {
1687 case CODEC_TYPE_AUDIO:
1688 frame_size = get_audio_frame_size(&st->codec, size);
1689 if (frame_size >= 0) {
1690 av_frac_add(&st->pts,
1691 (int64_t)s->pts_den * frame_size);
1692 }
1693 break;
1694 case CODEC_TYPE_VIDEO:
1695 av_frac_add(&st->pts,
1696 (int64_t)s->pts_den * st->codec.frame_rate_base);
1697 break;
1698 default:
1699 break;
1700 }
1701 return ret;
1702 }
1703
1704 /**
1705 * write the stream trailer to an output media file and and free the
1706 * file private data.
1707 *
1708 * @param s media file handle
1709 * @return 0 if OK. AVERROR_xxx if error. */
1710 int av_write_trailer(AVFormatContext *s)
1711 {
1712 int ret;
1713 ret = s->oformat->write_trailer(s);
1714 av_freep(&s->priv_data);
1715 return ret;
1716 }
1717
1718 /* "user interface" functions */
1719
1720 void dump_format(AVFormatContext *ic,
1721 int index,
1722 const char *url,
1723 int is_output)
1724 {
1725 int i, flags;
1726 char buf[256];
1727
1728 fprintf(stderr, "%s #%d, %s, %s '%s':\n",
1729 is_output ? "Output" : "Input",
1730 index,
1731 is_output ? ic->oformat->name : ic->iformat->name,
1732 is_output ? "to" : "from", url);
1733 if (!is_output) {
1734 fprintf(stderr, " Duration: ");
1735 if (ic->duration != AV_NOPTS_VALUE) {
1736 int hours, mins, secs, us;
1737 secs = ic->duration / AV_TIME_BASE;
1738 us = ic->duration % AV_TIME_BASE;
1739 mins = secs / 60;
1740 secs %= 60;
1741 hours = mins / 60;
1742 mins %= 60;
1743 fprintf(stderr, "%02d:%02d:%02d.%01d", hours, mins, secs,
1744 (10 * us) / AV_TIME_BASE);
1745 } else {
1746 fprintf(stderr, "N/A");
1747 }
1748 fprintf(stderr, ", bitrate: ");
1749 if (ic->bit_rate) {
1750 fprintf(stderr,"%d kb/s", ic->bit_rate / 1000);
1751 } else {
1752 fprintf(stderr, "N/A");
1753 }
1754 fprintf(stderr, "\n");
1755 }
1756 for(i=0;i<ic->nb_streams;i++) {
1757 AVStream *st = ic->streams[i];
1758 avcodec_string(buf, sizeof(buf), &st->codec, is_output);
1759 fprintf(stderr, " Stream #%d.%d", index, i);
1760 /* the pid is an important information, so we display it */
1761 /* XXX: add a generic system */
1762 if (is_output)
1763 flags = ic->oformat->flags;
1764 else
1765 flags = ic->iformat->flags;
1766 if (flags & AVFMT_SHOW_IDS) {
1767 fprintf(stderr, "[0x%x]", st->id);
1768 }
1769 fprintf(stderr, ": %s\n", buf);
1770 }
1771 }
1772
1773 typedef struct {
1774 const char *abv;
1775 int width, height;
1776 int frame_rate, frame_rate_base;
1777 } AbvEntry;
1778
1779 static AbvEntry frame_abvs[] = {
1780 { "ntsc", 720, 480, 30000, 1001 },
1781 { "pal", 720, 576, 25, 1 },
1782 { "qntsc", 352, 240, 30000, 1001 }, /* VCD compliant ntsc */
1783 { "qpal", 352, 288, 25, 1 }, /* VCD compliant pal */
1784 { "sntsc", 640, 480, 30000, 1001 }, /* square pixel ntsc */
1785 { "spal", 768, 576, 25, 1 }, /* square pixel pal */
1786 { "film", 352, 240, 24, 1 },
1787 { "ntsc-film", 352, 240, 24000, 1001 },
1788 { "sqcif", 128, 96, 0, 0 },
1789 { "qcif", 176, 144, 0, 0 },
1790 { "cif", 352, 288, 0, 0 },
1791 { "4cif", 704, 576, 0, 0 },
1792 };
1793
1794 int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
1795 {
1796 int i;
1797 int n = sizeof(frame_abvs) / sizeof(AbvEntry);
1798 const char *p;
1799 int frame_width = 0, frame_height = 0;
1800
1801 for(i=0;i<n;i++) {
1802 if (!strcmp(frame_abvs[i].abv, str)) {
1803 frame_width = frame_abvs[i].width;
1804 frame_height = frame_abvs[i].height;
1805 break;
1806 }
1807 }
1808 if (i == n) {
1809 p = str;
1810 frame_width = strtol(p, (char **)&p, 10);
1811 if (*p)
1812 p++;
1813 frame_height = strtol(p, (char **)&p, 10);
1814 }
1815 if (frame_width <= 0 || frame_height <= 0)
1816 return -1;
1817 *width_ptr = frame_width;
1818 *height_ptr = frame_height;
1819 return 0;
1820 }
1821
1822 int parse_frame_rate(int *frame_rate, int *frame_rate_base, const char *arg)
1823 {
1824 int i;
1825 char* cp;
1826
1827 /* First, we check our abbreviation table */
1828 for (i = 0; i < sizeof(frame_abvs)/sizeof(*frame_abvs); ++i)
1829 if (!strcmp(frame_abvs[i].abv, arg)) {
1830 *frame_rate = frame_abvs[i].frame_rate;
1831 *frame_rate_base = frame_abvs[i].frame_rate_base;
1832 return 0;
1833 }
1834
1835 /* Then, we try to parse it as fraction */
1836 cp = strchr(arg, '/');
1837 if (cp) {
1838 char* cpp;
1839 *frame_rate = strtol(arg, &cpp, 10);
1840 if (cpp != arg || cpp == cp)
1841 *frame_rate_base = strtol(cp+1, &cpp, 10);
1842 else
1843 *frame_rate = 0;
1844 }
1845 else {
1846 /* Finally we give up and parse it as double */
1847 *frame_rate_base = DEFAULT_FRAME_RATE_BASE;
1848 *frame_rate = (int)(strtod(arg, 0) * (*frame_rate_base) + 0.5);
1849 }
1850 if (!*frame_rate || !*frame_rate_base)
1851 return -1;
1852 else
1853 return 0;
1854 }
1855
1856 /* Syntax:
1857 * - If not a duration:
1858 * [{YYYY-MM-DD|YYYYMMDD}]{T| }{HH[:MM[:SS[.m...]]][Z]|HH[MM[SS[.m...]]][Z]}
1859 * Time is localtime unless Z is suffixed to the end. In this case GMT
1860 * Return the date in micro seconds since 1970
1861 * - If duration:
1862 * HH[:MM[:SS[.m...]]]
1863 * S+[.m...]
1864 */
1865 int64_t parse_date(const char *datestr, int duration)
1866 {
1867 const char *p;
1868 int64_t t;
1869 struct tm dt;
1870 int i;
1871 static const char *date_fmt[] = {
1872 "%Y-%m-%d",
1873 "%Y%m%d",
1874 };
1875 static const char *time_fmt[] = {
1876 "%H:%M:%S",
1877 "%H%M%S",
1878 };
1879 const char *q;
1880 int is_utc, len;
1881 char lastch;
1882 time_t now = time(0);
1883
1884 len = strlen(datestr);
1885 if (len > 0)
1886 lastch = datestr[len - 1];
1887 else
1888 lastch = '\0';
1889 is_utc = (lastch == 'z' || lastch == 'Z');
1890
1891 memset(&dt, 0, sizeof(dt));
1892
1893 p = datestr;
1894 q = NULL;
1895 if (!duration) {
1896 for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
1897 q = small_strptime(p, date_fmt[i], &dt);
1898 if (q) {
1899 break;
1900 }
1901 }
1902
1903 if (!q) {
1904 if (is_utc) {
1905 dt = *gmtime(&now);
1906 } else {
1907 dt = *localtime(&now);
1908 }
1909 dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
1910 } else {
1911 p = q;
1912 }
1913
1914 if (*p == 'T' || *p == 't' || *p == ' ')
1915 p++;
1916
1917 for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
1918 q = small_strptime(p, time_fmt[i], &dt);
1919 if (q) {
1920 break;
1921 }
1922 }
1923 } else {
1924 q = small_strptime(p, time_fmt[0], &dt);
1925 if (!q) {
1926 dt.tm_sec = strtol(p, (char **)&q, 10);
1927 dt.tm_min = 0;
1928 dt.tm_hour = 0;
1929 }
1930 }
1931
1932 /* Now we have all the fields that we can get */
1933 if (!q) {
1934 if (duration)
1935 return 0;
1936 else
1937 return now * int64_t_C(1000000);
1938 }
1939
1940 if (duration) {
1941 t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
1942 } else {
1943 dt.tm_isdst = -1; /* unknown */
1944 if (is_utc) {
1945 t = mktimegm(&dt);
1946 } else {
1947 t = mktime(&dt);
1948 }
1949 }
1950
1951 t *= 1000000;
1952
1953 if (*q == '.') {
1954 int val, n;
1955 q++;
1956 for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
1957 if (!isdigit(*q))
1958 break;
1959 val += n * (*q - '0');
1960 }
1961 t += val;
1962 }
1963 return t;
1964 }
1965
1966 /* syntax: '?tag1=val1&tag2=val2...'. Little URL decoding is done. Return
1967 1 if found */
1968 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
1969 {
1970 const char *p;
1971 char tag[128], *q;
1972
1973 p = info;
1974 if (*p == '?')
1975 p++;
1976 for(;;) {
1977 q = tag;
1978 while (*p != '\0' && *p != '=' && *p != '&') {
1979 if ((q - tag) < sizeof(tag) - 1)
1980 *q++ = *p;
1981 p++;
1982 }
1983 *q = '\0';
1984 q = arg;
1985 if (*p == '=') {
1986 p++;
1987 while (*p != '&' && *p != '\0') {
1988 if ((q - arg) < arg_size - 1) {
1989 if (*p == '+')
1990 *q++ = ' ';
1991 else
1992 *q++ = *p;
1993 }
1994 p++;
1995 }
1996 *q = '\0';
1997 }
1998 if (!strcmp(tag, tag1))
1999 return 1;
2000 if (*p != '&')
2001 break;
2002 p++;
2003 }
2004 return 0;
2005 }
2006
2007 /* Return in 'buf' the path with '%d' replaced by number. Also handles
2008 the '%0nd' format where 'n' is the total number of digits and
2009 '%%'. Return 0 if OK, and -1 if format error */
2010 int get_frame_filename(char *buf, int buf_size,
2011 const char *path, int number)
2012 {
2013 const char *p;
2014 char *q, buf1[20], c;
2015 int nd, len, percentd_found;
2016
2017 q = buf;
2018 p = path;
2019 percentd_found = 0;
2020 for(;;) {
2021 c = *p++;
2022 if (c == '\0')
2023 break;
2024 if (c == '%') {
2025 do {
2026 nd = 0;
2027 while (isdigit(*p)) {
2028 nd = nd * 10 + *p++ - '0';
2029 }
2030 c = *p++;
2031 } while (isdigit(c));
2032
2033 switch(c) {
2034 case '%':
2035 goto addchar;
2036 case 'd':
2037 if (percentd_found)
2038 goto fail;
2039 percentd_found = 1;
2040 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
2041 len = strlen(buf1);
2042 if ((q - buf + len) > buf_size - 1)
2043 goto fail;
2044 memcpy(q, buf1, len);
2045 q += len;
2046 break;
2047 default:
2048 goto fail;
2049 }
2050 } else {
2051 addchar:
2052 if ((q - buf) < buf_size - 1)
2053 *q++ = c;
2054 }
2055 }
2056 if (!percentd_found)
2057 goto fail;
2058 *q = '\0';
2059 return 0;
2060 fail:
2061 *q = '\0';
2062 return -1;
2063 }
2064
2065 /**
2066 * Print nice hexa dump of a buffer
2067 * @param f stream for output
2068 * @param buf buffer
2069 * @param size buffer size
2070 */
2071 void av_hex_dump(FILE *f, uint8_t *buf, int size)
2072 {
2073 int len, i, j, c;
2074
2075 for(i=0;i<size;i+=16) {
2076 len = size - i;
2077 if (len > 16)
2078 len = 16;
2079 fprintf(f, "%08x ", i);
2080 for(j=0;j<16;j++) {
2081 if (j < len)
2082 fprintf(f, " %02x", buf[i+j]);
2083 else
2084 fprintf(f, " ");
2085 }
2086 fprintf(f, " ");
2087 for(j=0;j<len;j++) {
2088 c = buf[i+j];
2089 if (c < ' ' || c > '~')
2090 c = '.';
2091 fprintf(f, "%c", c);
2092 }
2093 fprintf(f, "\n");
2094 }
2095 }
2096
2097 /**
2098 * Print on 'f' a nice dump of a packet
2099 * @param f stream for output
2100 * @param pkt packet to dump
2101 * @param dump_payload true if the payload must be displayed too
2102 */
2103 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
2104 {
2105 fprintf(f, "stream #%d:\n", pkt->stream_index);
2106 fprintf(f, " keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
2107 fprintf(f, " duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
2108 /* DTS is _always_ valid after av_read_frame() */
2109 fprintf(f, " dts=");
2110 if (pkt->dts == AV_NOPTS_VALUE)
2111 fprintf(f, "N/A");
2112 else
2113 fprintf(f, "%0.3f", (double)pkt->dts / AV_TIME_BASE);
2114 /* PTS may be not known if B frames are present */
2115 fprintf(f, " pts=");
2116 if (pkt->pts == AV_NOPTS_VALUE)
2117 fprintf(f, "N/A");
2118 else
2119 fprintf(f, "%0.3f", (double)pkt->pts / AV_TIME_BASE);
2120 fprintf(f, "\n");
2121 fprintf(f, " size=%d\n", pkt->size);
2122 if (dump_payload)
2123 av_hex_dump(f, pkt->data, pkt->size);
2124 }
2125
2126 void url_split(char *proto, int proto_size,
2127 char *hostname, int hostname_size,
2128 int *port_ptr,
2129 char *path, int path_size,
2130 const char *url)
2131 {
2132 const char *p;
2133 char *q;
2134 int port;
2135
2136 port = -1;
2137
2138 p = url;
2139 q = proto;
2140 while (*p != ':' && *p != '\0') {
2141 if ((q - proto) < proto_size - 1)
2142 *q++ = *p;
2143 p++;
2144 }
2145 if (proto_size > 0)
2146 *q = '\0';
2147 if (*p == '\0') {
2148 if (proto_size > 0)
2149 proto[0] = '\0';
2150 if (hostname_size > 0)
2151 hostname[0] = '\0';
2152 p = url;
2153 } else {
2154 p++;
2155 if (*p == '/')
2156 p++;
2157 if (*p == '/')
2158 p++;
2159 q = hostname;
2160 while (*p != ':' && *p != '/' && *p != '?' && *p != '\0') {
2161 if ((q - hostname) < hostname_size - 1)
2162 *q++ = *p;
2163 p++;
2164 }
2165 if (hostname_size > 0)
2166 *q = '\0';
2167 if (*p == ':') {
2168 p++;
2169 port = strtoul(p, (char **)&p, 10);
2170 }
2171 }
2172 if (port_ptr)
2173 *port_ptr = port;
2174 pstrcpy(path, path_size, p);
2175 }
2176
2177 /**
2178 * Set the pts for a given stream
2179 * @param s stream
2180 * @param pts_wrap_bits number of bits effectively used by the pts
2181 * (used for wrap control, 33 is the value for MPEG)
2182 * @param pts_num numerator to convert to seconds (MPEG: 1)
2183 * @param pts_den denominator to convert to seconds (MPEG: 90000)
2184 */
2185 void av_set_pts_info(AVFormatContext *s, int pts_wrap_bits,
2186 int pts_num, int pts_den)
2187 {
2188 s->pts_wrap_bits = pts_wrap_bits;
2189 s->pts_num = pts_num;
2190 s->pts_den = pts_den;
2191 }
2192
2193 /* fraction handling */
2194
2195 /**
2196 * f = val + (num / den) + 0.5. 'num' is normalized so that it is such
2197 * as 0 <= num < den.
2198 *
2199 * @param f fractional number
2200 * @param val integer value
2201 * @param num must be >= 0
2202 * @param den must be >= 1
2203 */
2204 void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
2205 {
2206 num += (den >> 1);
2207 if (num >= den) {
2208 val += num / den;
2209 num = num % den;
2210 }
2211 f->val = val;
2212 f->num = num;
2213 f->den = den;
2214 }
2215
2216 /* set f to (val + 0.5) */
2217 void av_frac_set(AVFrac *f, int64_t val)
2218 {
2219 f->val = val;
2220 f->num = f->den >> 1;
2221 }
2222
2223 /**
2224 * Fractionnal addition to f: f = f + (incr / f->den)
2225 *
2226 * @param f fractional number
2227 * @param incr increment, can be positive or negative
2228 */
2229 void av_frac_add(AVFrac *f, int64_t incr)
2230 {
2231 int64_t num, den;
2232
2233 num = f->num + incr;
2234 den = f->den;
2235 if (num < 0) {
2236 f->val += num / den;
2237 num = num % den;
2238 if (num < 0) {
2239 num += den;
2240 f->val--;
2241 }
2242 } else if (num >= den) {
2243 f->val += num / den;
2244 num = num % den;
2245 }
2246 f->num = num;
2247 }
2248
2249 /**
2250 * register a new image format
2251 * @param img_fmt Image format descriptor
2252 */
2253 void av_register_image_format(AVImageFormat *img_fmt)
2254 {
2255 AVImageFormat **p;
2256
2257 p = &first_image_format;
2258 while (*p != NULL) p = &(*p)->next;
2259 *p = img_fmt;
2260 img_fmt->next = NULL;
2261 }
2262
2263 /* guess image format */
2264 AVImageFormat *av_probe_image_format(AVProbeData *pd)
2265 {
2266 AVImageFormat *fmt1, *fmt;
2267 int score, score_max;
2268
2269 fmt = NULL;
2270 score_max = 0;
2271 for(fmt1 = first_image_format; fmt1 != NULL; fmt1 = fmt1->next) {
2272 if (fmt1->img_probe) {
2273 score = fmt1->img_probe(pd);
2274 if (score > score_max) {
2275 score_max = score;
2276 fmt = fmt1;
2277 }
2278 }
2279 }
2280 return fmt;
2281 }
2282
2283 AVImageFormat *guess_image_format(const char *filename)
2284 {
2285 AVImageFormat *fmt1;
2286
2287 for(fmt1 = first_image_format; fmt1 != NULL; fmt1 = fmt1->next) {
2288 if (fmt1->extensions && match_ext(filename, fmt1->extensions))
2289 return fmt1;
2290 }
2291 return NULL;
2292 }
2293
2294 /**
2295 * Read an image from a stream.
2296 * @param gb byte stream containing the image
2297 * @param fmt image format, NULL if probing is required
2298 */
2299 int av_read_image(ByteIOContext *pb, const char *filename,
2300 AVImageFormat *fmt,
2301 int (*alloc_cb)(void *, AVImageInfo *info), void *opaque)
2302 {
2303 char buf[PROBE_BUF_SIZE];
2304 AVProbeData probe_data, *pd = &probe_data;
2305 offset_t pos;
2306 int ret;
2307
2308 if (!fmt) {
2309 pd->filename = filename;
2310 pd->buf = buf;
2311 pos = url_ftell(pb);
2312 pd->buf_size = get_buffer(pb, buf, PROBE_BUF_SIZE);
2313 url_fseek(pb, pos, SEEK_SET);
2314 fmt = av_probe_image_format(pd);
2315 }
2316 if (!fmt)
2317 return AVERROR_NOFMT;
2318 ret = fmt->img_read(pb, alloc_cb, opaque);
2319 return ret;
2320 }
2321
2322 /**
2323 * Write an image to a stream.
2324 * @param pb byte stream for the image output
2325 * @param fmt image format
2326 * @param img image data and informations
2327 */
2328 int av_write_image(ByteIOContext *pb, AVImageFormat *fmt, AVImageInfo *img)
2329 {
2330 return fmt->img_write(pb, img);
2331 }
2332