caching of timestamps for mpeg-ps so seeking is faster
[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 pkt->pts = st->cur_dts;
629 pkt->dts = st->cur_dts;
630 } else {
631 st->cur_dts = pkt->pts;
632 pkt->dts = pkt->pts;
633 }
634 st->cur_dts += pkt->duration;
635 }
636
637 /* update flags */
638 if (pc) {
639 pkt->flags = 0;
640 /* key frame computation */
641 switch(st->codec.codec_type) {
642 case CODEC_TYPE_VIDEO:
643 if (pc->pict_type == FF_I_TYPE)
644 pkt->flags |= PKT_FLAG_KEY;
645 break;
646 case CODEC_TYPE_AUDIO:
647 pkt->flags |= PKT_FLAG_KEY;
648 break;
649 default:
650 break;
651 }
652 }
653
654 }
655
656 static void av_destruct_packet_nofree(AVPacket *pkt)
657 {
658 pkt->data = NULL; pkt->size = 0;
659 }
660
661 static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
662 {
663 AVStream *st;
664 int len, ret, i;
665
666 for(;;) {
667 /* select current input stream component */
668 st = s->cur_st;
669 if (st) {
670 if (!st->parser) {
671 /* no parsing needed: we just output the packet as is */
672 /* raw data support */
673 *pkt = s->cur_pkt;
674 compute_pkt_fields(s, st, NULL, pkt);
675 s->cur_st = NULL;
676 return 0;
677 } else if (s->cur_len > 0) {
678 len = av_parser_parse(st->parser, &st->codec, &pkt->data, &pkt->size,
679 s->cur_ptr, s->cur_len,
680 s->cur_pkt.pts, s->cur_pkt.dts);
681 s->cur_pkt.pts = AV_NOPTS_VALUE;
682 s->cur_pkt.dts = AV_NOPTS_VALUE;
683 /* increment read pointer */
684 s->cur_ptr += len;
685 s->cur_len -= len;
686
687 /* return packet if any */
688 if (pkt->size) {
689 got_packet:
690 pkt->duration = 0;
691 pkt->stream_index = st->index;
692 pkt->pts = st->parser->pts;
693 pkt->dts = st->parser->dts;
694 pkt->destruct = av_destruct_packet_nofree;
695 compute_pkt_fields(s, st, st->parser, pkt);
696 return 0;
697 }
698 } else {
699 /* free packet */
700 av_free_packet(&s->cur_pkt);
701 s->cur_st = NULL;
702 }
703 } else {
704 /* read next packet */
705 ret = av_read_packet(s, &s->cur_pkt);
706 if (ret < 0) {
707 if (ret == -EAGAIN)
708 return ret;
709 /* return the last frames, if any */
710 for(i = 0; i < s->nb_streams; i++) {
711 st = s->streams[i];
712 if (st->parser) {
713 av_parser_parse(st->parser, &st->codec,
714 &pkt->data, &pkt->size,
715 NULL, 0,
716 AV_NOPTS_VALUE, AV_NOPTS_VALUE);
717 if (pkt->size)
718 goto got_packet;
719 }
720 }
721 /* no more packets: really terminates parsing */
722 return ret;
723 }
724
725 /* convert the packet time stamp units and handle wrapping */
726 s->cur_pkt.pts = convert_timestamp_units(s,
727 &s->last_pkt_pts, &s->last_pkt_pts_frac,
728 &s->last_pkt_stream_pts,
729 s->cur_pkt.pts);
730 s->cur_pkt.dts = convert_timestamp_units(s,
731 &s->last_pkt_dts, &s->last_pkt_dts_frac,
732 &s->last_pkt_stream_dts,
733 s->cur_pkt.dts);
734 #if 0
735 if (s->cur_pkt.stream_index == 0) {
736 if (s->cur_pkt.pts != AV_NOPTS_VALUE)
737 printf("PACKET pts=%0.3f\n",
738 (double)s->cur_pkt.pts / AV_TIME_BASE);
739 if (s->cur_pkt.dts != AV_NOPTS_VALUE)
740 printf("PACKET dts=%0.3f\n",
741 (double)s->cur_pkt.dts / AV_TIME_BASE);
742 }
743 #endif
744
745 /* duration field */
746 if (s->cur_pkt.duration != 0) {
747 s->cur_pkt.duration = ((int64_t)s->cur_pkt.duration * AV_TIME_BASE * s->pts_num) /
748 s->pts_den;
749 }
750
751 st = s->streams[s->cur_pkt.stream_index];
752 s->cur_st = st;
753 s->cur_ptr = s->cur_pkt.data;
754 s->cur_len = s->cur_pkt.size;
755 if (st->need_parsing && !st->parser) {
756 st->parser = av_parser_init(st->codec.codec_id);
757 if (!st->parser) {
758 /* no parser available : just output the raw packets */
759 st->need_parsing = 0;
760 }
761 }
762 }
763 }
764 }
765
766 /**
767 * Return the next frame of a stream. The returned packet is valid
768 * until the next av_read_frame() or until av_close_input_file() and
769 * must be freed with av_free_packet. For video, the packet contains
770 * exactly one frame. For audio, it contains an integer number of
771 * frames if each frame has a known fixed size (e.g. PCM or ADPCM
772 * data). If the audio frames have a variable size (e.g. MPEG audio),
773 * then it contains one frame.
774 *
775 * pkt->pts, pkt->dts and pkt->duration are always set to correct
776 * values in AV_TIME_BASE unit (and guessed if the format cannot
777 * provided them). pkt->pts can be AV_NOPTS_VALUE if the video format
778 * has B frames, so it is better to rely on pkt->dts if you do not
779 * decompress the payload.
780 *
781 * Return 0 if OK, < 0 if error or end of file.
782 */
783 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
784 {
785 AVPacketList *pktl;
786
787 pktl = s->packet_buffer;
788 if (pktl) {
789 /* read packet from packet buffer, if there is data */
790 *pkt = pktl->pkt;
791 s->packet_buffer = pktl->next;
792 av_free(pktl);
793 return 0;
794 } else {
795 return av_read_frame_internal(s, pkt);
796 }
797 }
798
799 /* XXX: suppress the packet queue */
800 static void flush_packet_queue(AVFormatContext *s)
801 {
802 AVPacketList *pktl;
803
804 for(;;) {
805 pktl = s->packet_buffer;
806 if (!pktl)
807 break;
808 s->packet_buffer = pktl->next;
809 av_free_packet(&pktl->pkt);
810 av_free(pktl);
811 }
812 }
813
814 /*******************************************************/
815 /* seek support */
816
817 int av_find_default_stream_index(AVFormatContext *s)
818 {
819 int i;
820 AVStream *st;
821
822 if (s->nb_streams <= 0)
823 return -1;
824 for(i = 0; i < s->nb_streams; i++) {
825 st = s->streams[i];
826 if (st->codec.codec_type == CODEC_TYPE_VIDEO) {
827 return i;
828 }
829 }
830 return 0;
831 }
832
833 /* flush the frame reader */
834 static void av_read_frame_flush(AVFormatContext *s)
835 {
836 AVStream *st;
837 int i;
838
839 flush_packet_queue(s);
840
841 /* free previous packet */
842 if (s->cur_st) {
843 if (s->cur_st->parser)
844 av_free_packet(&s->cur_pkt);
845 s->cur_st = NULL;
846 }
847 /* fail safe */
848 s->cur_ptr = NULL;
849 s->cur_len = 0;
850
851 /* for each stream, reset read state */
852 for(i = 0; i < s->nb_streams; i++) {
853 st = s->streams[i];
854
855 if (st->parser) {
856 av_parser_close(st->parser);
857 st->parser = NULL;
858 }
859 st->cur_dts = 0; /* we set the current DTS to an unspecified origin */
860 }
861 }
862
863 /* add a index entry into a sorted list updateing if it is already there */
864 void av_add_index_entry(AVStream *st,
865 int64_t pos, int64_t timestamp, int flags)
866 {
867 AVIndexEntry *entries, *ie;
868 int index;
869
870 entries = av_fast_realloc(st->index_entries,
871 &st->index_entries_allocated_size,
872 (st->nb_index_entries + 1) *
873 sizeof(AVIndexEntry));
874 st->index_entries= entries;
875
876 if(st->nb_index_entries){
877 index= av_index_search_timestamp(st, timestamp);
878 ie= &entries[index];
879
880 if(ie->timestamp != timestamp){
881 if(ie->timestamp < timestamp){
882 index++; //index points to next instead of previous entry, maybe nonexistant
883 ie= &st->index_entries[index];
884 }else
885 assert(index==0);
886
887 if(index != st->nb_index_entries){
888 assert(index < st->nb_index_entries);
889 memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
890 }
891 st->nb_index_entries++;
892 }
893 }else
894 ie= &entries[st->nb_index_entries++];
895
896 ie->pos = pos;
897 ie->timestamp = timestamp;
898 ie->flags = flags;
899 }
900
901 /* build an index for raw streams using a parser */
902 static void av_build_index_raw(AVFormatContext *s)
903 {
904 AVPacket pkt1, *pkt = &pkt1;
905 int ret;
906 AVStream *st;
907
908 st = s->streams[0];
909 av_read_frame_flush(s);
910 url_fseek(&s->pb, s->data_offset, SEEK_SET);
911
912 for(;;) {
913 ret = av_read_frame(s, pkt);
914 if (ret < 0)
915 break;
916 if (pkt->stream_index == 0 && st->parser &&
917 (pkt->flags & PKT_FLAG_KEY)) {
918 av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
919 AVINDEX_KEYFRAME);
920 }
921 av_free_packet(pkt);
922 }
923 }
924
925 /* return TRUE if we deal with a raw stream (raw codec data and
926 parsing needed) */
927 static int is_raw_stream(AVFormatContext *s)
928 {
929 AVStream *st;
930
931 if (s->nb_streams != 1)
932 return 0;
933 st = s->streams[0];
934 if (!st->need_parsing)
935 return 0;
936 return 1;
937 }
938
939 /* return the largest index entry whose timestamp is <=
940 wanted_timestamp */
941 int av_index_search_timestamp(AVStream *st, int wanted_timestamp)
942 {
943 AVIndexEntry *entries= st->index_entries;
944 int nb_entries= st->nb_index_entries;
945 int a, b, m;
946 int64_t timestamp;
947
948 if (nb_entries <= 0)
949 return -1;
950
951 a = 0;
952 b = nb_entries - 1;
953
954 while (a < b) {
955 m = (a + b + 1) >> 1;
956 timestamp = entries[m].timestamp;
957 if (timestamp > wanted_timestamp) {
958 b = m - 1;
959 } else {
960 a = m;
961 }
962 }
963 return a;
964 }
965
966 static int av_seek_frame_generic(AVFormatContext *s,
967 int stream_index, int64_t timestamp)
968 {
969 int index;
970 AVStream *st;
971 AVIndexEntry *ie;
972
973 if (!s->index_built) {
974 if (is_raw_stream(s)) {
975 av_build_index_raw(s);
976 } else {
977 return -1;
978 }
979 s->index_built = 1;
980 }
981
982 if (stream_index < 0)
983 stream_index = 0;
984 st = s->streams[stream_index];
985 index = av_index_search_timestamp(st, timestamp);
986 if (index < 0)
987 return -1;
988
989 /* now we have found the index, we can seek */
990 ie = &st->index_entries[index];
991 av_read_frame_flush(s);
992 url_fseek(&s->pb, ie->pos, SEEK_SET);
993 st->cur_dts = ie->timestamp;
994 return 0;
995 }
996
997 /**
998 * Seek to the key frame just before the frame at timestamp
999 * 'timestamp' in 'stream_index'. If stream_index is (-1), a default
1000 * stream is selected
1001 */
1002 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp)
1003 {
1004 int ret;
1005
1006 av_read_frame_flush(s);
1007
1008 /* first, we try the format specific seek */
1009 if (s->iformat->read_seek)
1010 ret = s->iformat->read_seek(s, stream_index, timestamp);
1011 else
1012 ret = -1;
1013 if (ret >= 0) {
1014 return 0;
1015 }
1016
1017 return av_seek_frame_generic(s, stream_index, timestamp);
1018 }
1019
1020 /*******************************************************/
1021
1022 /* return TRUE if the stream has accurate timings for at least one component */
1023 static int av_has_timings(AVFormatContext *ic)
1024 {
1025 int i;
1026 AVStream *st;
1027
1028 for(i = 0;i < ic->nb_streams; i++) {
1029 st = ic->streams[i];
1030 if (st->start_time != AV_NOPTS_VALUE &&
1031 st->duration != AV_NOPTS_VALUE)
1032 return 1;
1033 }
1034 return 0;
1035 }
1036
1037 /* estimate the stream timings from the one of each components. Also
1038 compute the global bitrate if possible */
1039 static void av_update_stream_timings(AVFormatContext *ic)
1040 {
1041 int64_t start_time, end_time, end_time1;
1042 int i;
1043 AVStream *st;
1044
1045 start_time = MAXINT64;
1046 end_time = MININT64;
1047 for(i = 0;i < ic->nb_streams; i++) {
1048 st = ic->streams[i];
1049 if (st->start_time != AV_NOPTS_VALUE) {
1050 if (st->start_time < start_time)
1051 start_time = st->start_time;
1052 if (st->duration != AV_NOPTS_VALUE) {
1053 end_time1 = st->start_time + st->duration;
1054 if (end_time1 > end_time)
1055 end_time = end_time1;
1056 }
1057 }
1058 }
1059 if (start_time != MAXINT64) {
1060 ic->start_time = start_time;
1061 if (end_time != MAXINT64) {
1062 ic->duration = end_time - start_time;
1063 if (ic->file_size > 0) {
1064 /* compute the bit rate */
1065 ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1066 (double)ic->duration;
1067 }
1068 }
1069 }
1070
1071 }
1072
1073 static void fill_all_stream_timings(AVFormatContext *ic)
1074 {
1075 int i;
1076 AVStream *st;
1077
1078 av_update_stream_timings(ic);
1079 for(i = 0;i < ic->nb_streams; i++) {
1080 st = ic->streams[i];
1081 if (st->start_time == AV_NOPTS_VALUE) {
1082 st->start_time = ic->start_time;
1083 st->duration = ic->duration;
1084 }
1085 }
1086 }
1087
1088 static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1089 {
1090 int64_t filesize, duration;
1091 int bit_rate, i;
1092 AVStream *st;
1093
1094 /* if bit_rate is already set, we believe it */
1095 if (ic->bit_rate == 0) {
1096 bit_rate = 0;
1097 for(i=0;i<ic->nb_streams;i++) {
1098 st = ic->streams[i];
1099 bit_rate += st->codec.bit_rate;
1100 }
1101 ic->bit_rate = bit_rate;
1102 }
1103
1104 /* if duration is already set, we believe it */
1105 if (ic->duration == AV_NOPTS_VALUE &&
1106 ic->bit_rate != 0 &&
1107 ic->file_size != 0) {
1108 filesize = ic->file_size;
1109 if (filesize > 0) {
1110 duration = (int64_t)((8 * AV_TIME_BASE * (double)filesize) / (double)ic->bit_rate);
1111 for(i = 0; i < ic->nb_streams; i++) {
1112 st = ic->streams[i];
1113 if (st->start_time == AV_NOPTS_VALUE ||
1114 st->duration == AV_NOPTS_VALUE) {
1115 st->start_time = 0;
1116 st->duration = duration;
1117 }
1118 }
1119 }
1120 }
1121 }
1122
1123 #define DURATION_MAX_READ_SIZE 250000
1124
1125 /* only usable for MPEG-PS streams */
1126 static void av_estimate_timings_from_pts(AVFormatContext *ic)
1127 {
1128 AVPacket pkt1, *pkt = &pkt1;
1129 AVStream *st;
1130 int read_size, i, ret;
1131 int64_t start_time, end_time, end_time1;
1132 int64_t filesize, offset, duration;
1133
1134 /* free previous packet */
1135 if (ic->cur_st && ic->cur_st->parser)
1136 av_free_packet(&ic->cur_pkt);
1137 ic->cur_st = NULL;
1138
1139 /* flush packet queue */
1140 flush_packet_queue(ic);
1141
1142
1143 /* we read the first packets to get the first PTS (not fully
1144 accurate, but it is enough now) */
1145 url_fseek(&ic->pb, 0, SEEK_SET);
1146 read_size = 0;
1147 for(;;) {
1148 if (read_size >= DURATION_MAX_READ_SIZE)
1149 break;
1150 /* if all info is available, we can stop */
1151 for(i = 0;i < ic->nb_streams; i++) {
1152 st = ic->streams[i];
1153 if (st->start_time == AV_NOPTS_VALUE)
1154 break;
1155 }
1156 if (i == ic->nb_streams)
1157 break;
1158
1159 ret = av_read_packet(ic, pkt);
1160 if (ret != 0)
1161 break;
1162 read_size += pkt->size;
1163 st = ic->streams[pkt->stream_index];
1164 if (pkt->pts != AV_NOPTS_VALUE) {
1165 if (st->start_time == AV_NOPTS_VALUE)
1166 st->start_time = (int64_t)((double)pkt->pts * ic->pts_num * (double)AV_TIME_BASE / ic->pts_den);
1167 }
1168 av_free_packet(pkt);
1169 }
1170
1171 /* we compute the minimum start_time and use it as default */
1172 start_time = MAXINT64;
1173 for(i = 0; i < ic->nb_streams; i++) {
1174 st = ic->streams[i];
1175 if (st->start_time != AV_NOPTS_VALUE &&
1176 st->start_time < start_time)
1177 start_time = st->start_time;
1178 }
1179 if (start_time != MAXINT64)
1180 ic->start_time = start_time;
1181
1182 /* estimate the end time (duration) */
1183 /* XXX: may need to support wrapping */
1184 filesize = ic->file_size;
1185 offset = filesize - DURATION_MAX_READ_SIZE;
1186 if (offset < 0)
1187 offset = 0;
1188
1189 url_fseek(&ic->pb, offset, SEEK_SET);
1190 read_size = 0;
1191 for(;;) {
1192 if (read_size >= DURATION_MAX_READ_SIZE)
1193 break;
1194 /* if all info is available, we can stop */
1195 for(i = 0;i < ic->nb_streams; i++) {
1196 st = ic->streams[i];
1197 if (st->duration == AV_NOPTS_VALUE)
1198 break;
1199 }
1200 if (i == ic->nb_streams)
1201 break;
1202
1203 ret = av_read_packet(ic, pkt);
1204 if (ret != 0)
1205 break;
1206 read_size += pkt->size;
1207 st = ic->streams[pkt->stream_index];
1208 if (pkt->pts != AV_NOPTS_VALUE) {
1209 end_time = (int64_t)((double)pkt->pts * ic->pts_num * (double)AV_TIME_BASE / ic->pts_den);
1210 duration = end_time - st->start_time;
1211 if (duration > 0) {
1212 if (st->duration == AV_NOPTS_VALUE ||
1213 st->duration < duration)
1214 st->duration = duration;
1215 }
1216 }
1217 av_free_packet(pkt);
1218 }
1219
1220 /* estimate total duration */
1221 end_time = MININT64;
1222 for(i = 0;i < ic->nb_streams; i++) {
1223 st = ic->streams[i];
1224 if (st->duration != AV_NOPTS_VALUE) {
1225 end_time1 = st->start_time + st->duration;
1226 if (end_time1 > end_time)
1227 end_time = end_time1;
1228 }
1229 }
1230
1231 /* update start_time (new stream may have been created, so we do
1232 it at the end */
1233 if (ic->start_time != AV_NOPTS_VALUE) {
1234 for(i = 0; i < ic->nb_streams; i++) {
1235 st = ic->streams[i];
1236 if (st->start_time == AV_NOPTS_VALUE)
1237 st->start_time = ic->start_time;
1238 }
1239 }
1240
1241 if (end_time != MININT64) {
1242 /* put dummy values for duration if needed */
1243 for(i = 0;i < ic->nb_streams; i++) {
1244 st = ic->streams[i];
1245 if (st->duration == AV_NOPTS_VALUE &&
1246 st->start_time != AV_NOPTS_VALUE)
1247 st->duration = end_time - st->start_time;
1248 }
1249 ic->duration = end_time - ic->start_time;
1250 }
1251
1252 url_fseek(&ic->pb, 0, SEEK_SET);
1253 }
1254
1255 static void av_estimate_timings(AVFormatContext *ic)
1256 {
1257 URLContext *h;
1258 int64_t file_size;
1259
1260 /* get the file size, if possible */
1261 if (ic->iformat->flags & AVFMT_NOFILE) {
1262 file_size = 0;
1263 } else {
1264 h = url_fileno(&ic->pb);
1265 file_size = url_filesize(h);
1266 if (file_size < 0)
1267 file_size = 0;
1268 }
1269 ic->file_size = file_size;
1270
1271 if (ic->iformat == &mpegps_demux) {
1272 /* get accurate estimate from the PTSes */
1273 av_estimate_timings_from_pts(ic);
1274 } else if (av_has_timings(ic)) {
1275 /* at least one components has timings - we use them for all
1276 the components */
1277 fill_all_stream_timings(ic);
1278 } else {
1279 /* less precise: use bit rate info */
1280 av_estimate_timings_from_bit_rate(ic);
1281 }
1282 av_update_stream_timings(ic);
1283
1284 #if 0
1285 {
1286 int i;
1287 AVStream *st;
1288 for(i = 0;i < ic->nb_streams; i++) {
1289 st = ic->streams[i];
1290 printf("%d: start_time: %0.3f duration: %0.3f\n",
1291 i, (double)st->start_time / AV_TIME_BASE,
1292 (double)st->duration / AV_TIME_BASE);
1293 }
1294 printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1295 (double)ic->start_time / AV_TIME_BASE,
1296 (double)ic->duration / AV_TIME_BASE,
1297 ic->bit_rate / 1000);
1298 }
1299 #endif
1300 }
1301
1302 static int has_codec_parameters(AVCodecContext *enc)
1303 {
1304 int val;
1305 switch(enc->codec_type) {
1306 case CODEC_TYPE_AUDIO:
1307 val = enc->sample_rate;
1308 break;
1309 case CODEC_TYPE_VIDEO:
1310 val = enc->width;
1311 break;
1312 default:
1313 val = 1;
1314 break;
1315 }
1316 return (val != 0);
1317 }
1318
1319 static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1320 {
1321 int16_t *samples;
1322 AVCodec *codec;
1323 int got_picture, ret;
1324 AVFrame picture;
1325
1326 codec = avcodec_find_decoder(st->codec.codec_id);
1327 if (!codec)
1328 return -1;
1329 ret = avcodec_open(&st->codec, codec);
1330 if (ret < 0)
1331 return ret;
1332 switch(st->codec.codec_type) {
1333 case CODEC_TYPE_VIDEO:
1334 ret = avcodec_decode_video(&st->codec, &picture,
1335 &got_picture, (uint8_t *)data, size);
1336 break;
1337 case CODEC_TYPE_AUDIO:
1338 samples = av_malloc(AVCODEC_MAX_AUDIO_FRAME_SIZE);
1339 if (!samples)
1340 goto fail;
1341 ret = avcodec_decode_audio(&st->codec, samples,
1342 &got_picture, (uint8_t *)data, size);
1343 av_free(samples);
1344 break;
1345 default:
1346 break;
1347 }
1348 fail:
1349 avcodec_close(&st->codec);
1350 return ret;
1351 }
1352
1353 /* absolute maximum size we read until we abort */
1354 #define MAX_READ_SIZE 5000000
1355
1356 /* maximum duration until we stop analysing the stream */
1357 #define MAX_STREAM_DURATION ((int)(AV_TIME_BASE * 1.0))
1358
1359 /**
1360 * Read the beginning of a media file to get stream information. This
1361 * is useful for file formats with no headers such as MPEG. This
1362 * function also compute the real frame rate in case of mpeg2 repeat
1363 * frame mode.
1364 *
1365 * @param ic media file handle
1366 * @return >=0 if OK. AVERROR_xxx if error.
1367 */
1368 int av_find_stream_info(AVFormatContext *ic)
1369 {
1370 int i, count, ret, read_size;
1371 AVStream *st;
1372 AVPacket pkt1, *pkt;
1373 AVPacketList *pktl=NULL, **ppktl;
1374
1375 count = 0;
1376 read_size = 0;
1377 ppktl = &ic->packet_buffer;
1378 for(;;) {
1379 /* check if one codec still needs to be handled */
1380 for(i=0;i<ic->nb_streams;i++) {
1381 st = ic->streams[i];
1382 if (!has_codec_parameters(&st->codec))
1383 break;
1384 }
1385 if (i == ic->nb_streams) {
1386 /* NOTE: if the format has no header, then we need to read
1387 some packets to get most of the streams, so we cannot
1388 stop here */
1389 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
1390 /* if we found the info for all the codecs, we can stop */
1391 ret = count;
1392 break;
1393 }
1394 } else {
1395 /* we did not get all the codec info, but we read too much data */
1396 if (read_size >= MAX_READ_SIZE) {
1397 ret = count;
1398 break;
1399 }
1400 }
1401
1402 /* NOTE: a new stream can be added there if no header in file
1403 (AVFMTCTX_NOHEADER) */
1404 ret = av_read_frame_internal(ic, &pkt1);
1405 if (ret < 0) {
1406 /* EOF or error */
1407 ret = -1; /* we could not have all the codec parameters before EOF */
1408 if ((ic->ctx_flags & AVFMTCTX_NOHEADER) &&
1409 i == ic->nb_streams)
1410 ret = 0;
1411 break;
1412 }
1413
1414 pktl = av_mallocz(sizeof(AVPacketList));
1415 if (!pktl) {
1416 ret = AVERROR_NOMEM;
1417 break;
1418 }
1419
1420 /* add the packet in the buffered packet list */
1421 *ppktl = pktl;
1422 ppktl = &pktl->next;
1423
1424 pkt = &pktl->pkt;
1425 *pkt = pkt1;
1426
1427 /* duplicate the packet */
1428 if (av_dup_packet(pkt) < 0) {
1429 ret = AVERROR_NOMEM;
1430 break;
1431 }
1432
1433 read_size += pkt->size;
1434
1435 st = ic->streams[pkt->stream_index];
1436 st->codec_info_duration += pkt->duration;
1437 if (pkt->duration != 0)
1438 st->codec_info_nb_frames++;
1439
1440 /* if still no information, we try to open the codec and to
1441 decompress the frame. We try to avoid that in most cases as
1442 it takes longer and uses more memory. For MPEG4, we need to
1443 decompress for Quicktime. */
1444 if (!has_codec_parameters(&st->codec) &&
1445 (st->codec.codec_id == CODEC_ID_FLV1 ||
1446 st->codec.codec_id == CODEC_ID_H264 ||
1447 st->codec.codec_id == CODEC_ID_H263 ||
1448 (st->codec.codec_id == CODEC_ID_MPEG4 && !st->need_parsing)))
1449 try_decode_frame(st, pkt->data, pkt->size);
1450
1451 if (st->codec_info_duration >= MAX_STREAM_DURATION) {
1452 break;
1453 }
1454 count++;
1455 }
1456
1457 /* set real frame rate info */
1458 for(i=0;i<ic->nb_streams;i++) {
1459 st = ic->streams[i];
1460 if (st->codec.codec_type == CODEC_TYPE_VIDEO) {
1461 /* compute the real frame rate for telecine */
1462 if ((st->codec.codec_id == CODEC_ID_MPEG1VIDEO ||
1463 st->codec.codec_id == CODEC_ID_MPEG2VIDEO) &&
1464 st->codec.sub_id == 2) {
1465 if (st->codec_info_nb_frames >= 20) {
1466 float coded_frame_rate, est_frame_rate;
1467 est_frame_rate = ((double)st->codec_info_nb_frames * AV_TIME_BASE) /
1468 (double)st->codec_info_duration ;
1469 coded_frame_rate = (double)st->codec.frame_rate /
1470 (double)st->codec.frame_rate_base;
1471 #if 0
1472 printf("telecine: coded_frame_rate=%0.3f est_frame_rate=%0.3f\n",
1473 coded_frame_rate, est_frame_rate);
1474 #endif
1475 /* if we detect that it could be a telecine, we
1476 signal it. It would be better to do it at a
1477 higher level as it can change in a film */
1478 if (coded_frame_rate >= 24.97 &&
1479 (est_frame_rate >= 23.5 && est_frame_rate < 24.5)) {
1480 st->r_frame_rate = 24024;
1481 st->r_frame_rate_base = 1001;
1482 }
1483 }
1484 }
1485 /* if no real frame rate, use the codec one */
1486 if (!st->r_frame_rate){
1487 st->r_frame_rate = st->codec.frame_rate;
1488 st->r_frame_rate_base = st->codec.frame_rate_base;
1489 }
1490 }
1491 }
1492
1493 av_estimate_timings(ic);
1494 return ret;
1495 }
1496
1497 /*******************************************************/
1498
1499 /**
1500 * start playing a network based stream (e.g. RTSP stream) at the
1501 * current position
1502 */
1503 int av_read_play(AVFormatContext *s)
1504 {
1505 if (!s->iformat->read_play)
1506 return AVERROR_NOTSUPP;
1507 return s->iformat->read_play(s);
1508 }
1509
1510 /**
1511 * pause a network based stream (e.g. RTSP stream). Use av_read_play()
1512 * to resume it.
1513 */
1514 int av_read_pause(AVFormatContext *s)
1515 {
1516 if (!s->iformat->read_pause)
1517 return AVERROR_NOTSUPP;
1518 return s->iformat->read_pause(s);
1519 }
1520
1521 /**
1522 * Close a media file (but not its codecs)
1523 *
1524 * @param s media file handle
1525 */
1526 void av_close_input_file(AVFormatContext *s)
1527 {
1528 int i, must_open_file;
1529 AVStream *st;
1530
1531 /* free previous packet */
1532 if (s->cur_st && s->cur_st->parser)
1533 av_free_packet(&s->cur_pkt);
1534
1535 if (s->iformat->read_close)
1536 s->iformat->read_close(s);
1537 for(i=0;i<s->nb_streams;i++) {
1538 /* free all data in a stream component */
1539 st = s->streams[i];
1540 if (st->parser) {
1541 av_parser_close(st->parser);
1542 }
1543 av_free(st->index_entries);
1544 av_free(st);
1545 }
1546 flush_packet_queue(s);
1547 must_open_file = 1;
1548 if (s->iformat->flags & AVFMT_NOFILE) {
1549 must_open_file = 0;
1550 }
1551 if (must_open_file) {
1552 url_fclose(&s->pb);
1553 }
1554 av_freep(&s->priv_data);
1555 av_free(s);
1556 }
1557
1558 /**
1559 * Add a new stream to a media file. Can only be called in the
1560 * read_header function. If the flag AVFMTCTX_NOHEADER is in the
1561 * format context, then new streams can be added in read_packet too.
1562 *
1563 *
1564 * @param s media file handle
1565 * @param id file format dependent stream id
1566 */
1567 AVStream *av_new_stream(AVFormatContext *s, int id)
1568 {
1569 AVStream *st;
1570
1571 if (s->nb_streams >= MAX_STREAMS)
1572 return NULL;
1573
1574 st = av_mallocz(sizeof(AVStream));
1575 if (!st)
1576 return NULL;
1577 avcodec_get_context_defaults(&st->codec);
1578 if (s->iformat) {
1579 /* no default bitrate if decoding */
1580 st->codec.bit_rate = 0;
1581 }
1582 st->index = s->nb_streams;
1583 st->id = id;
1584 st->start_time = AV_NOPTS_VALUE;
1585 st->duration = AV_NOPTS_VALUE;
1586 s->streams[s->nb_streams++] = st;
1587 return st;
1588 }
1589
1590 /************************************************************/
1591 /* output media file */
1592
1593 int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
1594 {
1595 int ret;
1596
1597 if (s->oformat->priv_data_size > 0) {
1598 s->priv_data = av_mallocz(s->oformat->priv_data_size);
1599 if (!s->priv_data)
1600 return AVERROR_NOMEM;
1601 } else
1602 s->priv_data = NULL;
1603
1604 if (s->oformat->set_parameters) {
1605 ret = s->oformat->set_parameters(s, ap);
1606 if (ret < 0)
1607 return ret;
1608 }
1609 return 0;
1610 }
1611
1612 /**
1613 * allocate the stream private data and write the stream header to an
1614 * output media file
1615 *
1616 * @param s media file handle
1617 * @return 0 if OK. AVERROR_xxx if error.
1618 */
1619 int av_write_header(AVFormatContext *s)
1620 {
1621 int ret, i;
1622 AVStream *st;
1623
1624 /* default pts settings is MPEG like */
1625 av_set_pts_info(s, 33, 1, 90000);
1626 ret = s->oformat->write_header(s);
1627 if (ret < 0)
1628 return ret;
1629
1630 /* init PTS generation */
1631 for(i=0;i<s->nb_streams;i++) {
1632 st = s->streams[i];
1633
1634 switch (st->codec.codec_type) {
1635 case CODEC_TYPE_AUDIO:
1636 av_frac_init(&st->pts, 0, 0,
1637 (int64_t)s->pts_num * st->codec.sample_rate);
1638 break;
1639 case CODEC_TYPE_VIDEO:
1640 av_frac_init(&st->pts, 0, 0,
1641 (int64_t)s->pts_num * st->codec.frame_rate);
1642 break;
1643 default:
1644 break;
1645 }
1646 }
1647 return 0;
1648 }
1649
1650 /**
1651 * Write a packet to an output media file. The packet shall contain
1652 * one audio or video frame.
1653 *
1654 * @param s media file handle
1655 * @param stream_index stream index
1656 * @param buf buffer containing the frame data
1657 * @param size size of buffer
1658 * @return < 0 if error, = 0 if OK, 1 if end of stream wanted.
1659 */
1660 int av_write_frame(AVFormatContext *s, int stream_index, const uint8_t *buf,
1661 int size)
1662 {
1663 AVStream *st;
1664 int64_t pts_mask;
1665 int ret, frame_size;
1666
1667 st = s->streams[stream_index];
1668 pts_mask = (1LL << s->pts_wrap_bits) - 1;
1669 ret = s->oformat->write_packet(s, stream_index, buf, size,
1670 st->pts.val & pts_mask);
1671 if (ret < 0)
1672 return ret;
1673
1674 /* update pts */
1675 switch (st->codec.codec_type) {
1676 case CODEC_TYPE_AUDIO:
1677 frame_size = get_audio_frame_size(&st->codec, size);
1678 if (frame_size >= 0) {
1679 av_frac_add(&st->pts,
1680 (int64_t)s->pts_den * frame_size);
1681 }
1682 break;
1683 case CODEC_TYPE_VIDEO:
1684 av_frac_add(&st->pts,
1685 (int64_t)s->pts_den * st->codec.frame_rate_base);
1686 break;
1687 default:
1688 break;
1689 }
1690 return ret;
1691 }
1692
1693 /**
1694 * write the stream trailer to an output media file and and free the
1695 * file private data.
1696 *
1697 * @param s media file handle
1698 * @return 0 if OK. AVERROR_xxx if error. */
1699 int av_write_trailer(AVFormatContext *s)
1700 {
1701 int ret;
1702 ret = s->oformat->write_trailer(s);
1703 av_freep(&s->priv_data);
1704 return ret;
1705 }
1706
1707 /* "user interface" functions */
1708
1709 void dump_format(AVFormatContext *ic,
1710 int index,
1711 const char *url,
1712 int is_output)
1713 {
1714 int i, flags;
1715 char buf[256];
1716
1717 fprintf(stderr, "%s #%d, %s, %s '%s':\n",
1718 is_output ? "Output" : "Input",
1719 index,
1720 is_output ? ic->oformat->name : ic->iformat->name,
1721 is_output ? "to" : "from", url);
1722 if (!is_output) {
1723 fprintf(stderr, " Duration: ");
1724 if (ic->duration != AV_NOPTS_VALUE) {
1725 int hours, mins, secs, us;
1726 secs = ic->duration / AV_TIME_BASE;
1727 us = ic->duration % AV_TIME_BASE;
1728 mins = secs / 60;
1729 secs %= 60;
1730 hours = mins / 60;
1731 mins %= 60;
1732 fprintf(stderr, "%02d:%02d:%02d.%01d", hours, mins, secs,
1733 (10 * us) / AV_TIME_BASE);
1734 } else {
1735 fprintf(stderr, "N/A");
1736 }
1737 fprintf(stderr, ", bitrate: ");
1738 if (ic->bit_rate) {
1739 fprintf(stderr,"%d kb/s", ic->bit_rate / 1000);
1740 } else {
1741 fprintf(stderr, "N/A");
1742 }
1743 fprintf(stderr, "\n");
1744 }
1745 for(i=0;i<ic->nb_streams;i++) {
1746 AVStream *st = ic->streams[i];
1747 avcodec_string(buf, sizeof(buf), &st->codec, is_output);
1748 fprintf(stderr, " Stream #%d.%d", index, i);
1749 /* the pid is an important information, so we display it */
1750 /* XXX: add a generic system */
1751 if (is_output)
1752 flags = ic->oformat->flags;
1753 else
1754 flags = ic->iformat->flags;
1755 if (flags & AVFMT_SHOW_IDS) {
1756 fprintf(stderr, "[0x%x]", st->id);
1757 }
1758 fprintf(stderr, ": %s\n", buf);
1759 }
1760 }
1761
1762 typedef struct {
1763 const char *abv;
1764 int width, height;
1765 int frame_rate, frame_rate_base;
1766 } AbvEntry;
1767
1768 static AbvEntry frame_abvs[] = {
1769 { "ntsc", 720, 480, 30000, 1001 },
1770 { "pal", 720, 576, 25, 1 },
1771 { "qntsc", 352, 240, 30000, 1001 }, /* VCD compliant ntsc */
1772 { "qpal", 352, 288, 25, 1 }, /* VCD compliant pal */
1773 { "sntsc", 640, 480, 30000, 1001 }, /* square pixel ntsc */
1774 { "spal", 768, 576, 25, 1 }, /* square pixel pal */
1775 { "film", 352, 240, 24, 1 },
1776 { "ntsc-film", 352, 240, 24000, 1001 },
1777 { "sqcif", 128, 96, 0, 0 },
1778 { "qcif", 176, 144, 0, 0 },
1779 { "cif", 352, 288, 0, 0 },
1780 { "4cif", 704, 576, 0, 0 },
1781 };
1782
1783 int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
1784 {
1785 int i;
1786 int n = sizeof(frame_abvs) / sizeof(AbvEntry);
1787 const char *p;
1788 int frame_width = 0, frame_height = 0;
1789
1790 for(i=0;i<n;i++) {
1791 if (!strcmp(frame_abvs[i].abv, str)) {
1792 frame_width = frame_abvs[i].width;
1793 frame_height = frame_abvs[i].height;
1794 break;
1795 }
1796 }
1797 if (i == n) {
1798 p = str;
1799 frame_width = strtol(p, (char **)&p, 10);
1800 if (*p)
1801 p++;
1802 frame_height = strtol(p, (char **)&p, 10);
1803 }
1804 if (frame_width <= 0 || frame_height <= 0)
1805 return -1;
1806 *width_ptr = frame_width;
1807 *height_ptr = frame_height;
1808 return 0;
1809 }
1810
1811 int parse_frame_rate(int *frame_rate, int *frame_rate_base, const char *arg)
1812 {
1813 int i;
1814 char* cp;
1815
1816 /* First, we check our abbreviation table */
1817 for (i = 0; i < sizeof(frame_abvs)/sizeof(*frame_abvs); ++i)
1818 if (!strcmp(frame_abvs[i].abv, arg)) {
1819 *frame_rate = frame_abvs[i].frame_rate;
1820 *frame_rate_base = frame_abvs[i].frame_rate_base;
1821 return 0;
1822 }
1823
1824 /* Then, we try to parse it as fraction */
1825 cp = strchr(arg, '/');
1826 if (cp) {
1827 char* cpp;
1828 *frame_rate = strtol(arg, &cpp, 10);
1829 if (cpp != arg || cpp == cp)
1830 *frame_rate_base = strtol(cp+1, &cpp, 10);
1831 else
1832 *frame_rate = 0;
1833 }
1834 else {
1835 /* Finally we give up and parse it as double */
1836 *frame_rate_base = DEFAULT_FRAME_RATE_BASE;
1837 *frame_rate = (int)(strtod(arg, 0) * (*frame_rate_base) + 0.5);
1838 }
1839 if (!*frame_rate || !*frame_rate_base)
1840 return -1;
1841 else
1842 return 0;
1843 }
1844
1845 /* Syntax:
1846 * - If not a duration:
1847 * [{YYYY-MM-DD|YYYYMMDD}]{T| }{HH[:MM[:SS[.m...]]][Z]|HH[MM[SS[.m...]]][Z]}
1848 * Time is localtime unless Z is suffixed to the end. In this case GMT
1849 * Return the date in micro seconds since 1970
1850 * - If duration:
1851 * HH[:MM[:SS[.m...]]]
1852 * S+[.m...]
1853 */
1854 int64_t parse_date(const char *datestr, int duration)
1855 {
1856 const char *p;
1857 int64_t t;
1858 struct tm dt;
1859 int i;
1860 static const char *date_fmt[] = {
1861 "%Y-%m-%d",
1862 "%Y%m%d",
1863 };
1864 static const char *time_fmt[] = {
1865 "%H:%M:%S",
1866 "%H%M%S",
1867 };
1868 const char *q;
1869 int is_utc, len;
1870 char lastch;
1871 time_t now = time(0);
1872
1873 len = strlen(datestr);
1874 if (len > 0)
1875 lastch = datestr[len - 1];
1876 else
1877 lastch = '\0';
1878 is_utc = (lastch == 'z' || lastch == 'Z');
1879
1880 memset(&dt, 0, sizeof(dt));
1881
1882 p = datestr;
1883 q = NULL;
1884 if (!duration) {
1885 for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
1886 q = small_strptime(p, date_fmt[i], &dt);
1887 if (q) {
1888 break;
1889 }
1890 }
1891
1892 if (!q) {
1893 if (is_utc) {
1894 dt = *gmtime(&now);
1895 } else {
1896 dt = *localtime(&now);
1897 }
1898 dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
1899 } else {
1900 p = q;
1901 }
1902
1903 if (*p == 'T' || *p == 't' || *p == ' ')
1904 p++;
1905
1906 for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
1907 q = small_strptime(p, time_fmt[i], &dt);
1908 if (q) {
1909 break;
1910 }
1911 }
1912 } else {
1913 q = small_strptime(p, time_fmt[0], &dt);
1914 if (!q) {
1915 dt.tm_sec = strtol(p, (char **)&q, 10);
1916 dt.tm_min = 0;
1917 dt.tm_hour = 0;
1918 }
1919 }
1920
1921 /* Now we have all the fields that we can get */
1922 if (!q) {
1923 if (duration)
1924 return 0;
1925 else
1926 return now * int64_t_C(1000000);
1927 }
1928
1929 if (duration) {
1930 t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
1931 } else {
1932 dt.tm_isdst = -1; /* unknown */
1933 if (is_utc) {
1934 t = mktimegm(&dt);
1935 } else {
1936 t = mktime(&dt);
1937 }
1938 }
1939
1940 t *= 1000000;
1941
1942 if (*q == '.') {
1943 int val, n;
1944 q++;
1945 for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
1946 if (!isdigit(*q))
1947 break;
1948 val += n * (*q - '0');
1949 }
1950 t += val;
1951 }
1952 return t;
1953 }
1954
1955 /* syntax: '?tag1=val1&tag2=val2...'. Little URL decoding is done. Return
1956 1 if found */
1957 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
1958 {
1959 const char *p;
1960 char tag[128], *q;
1961
1962 p = info;
1963 if (*p == '?')
1964 p++;
1965 for(;;) {
1966 q = tag;
1967 while (*p != '\0' && *p != '=' && *p != '&') {
1968 if ((q - tag) < sizeof(tag) - 1)
1969 *q++ = *p;
1970 p++;
1971 }
1972 *q = '\0';
1973 q = arg;
1974 if (*p == '=') {
1975 p++;
1976 while (*p != '&' && *p != '\0') {
1977 if ((q - arg) < arg_size - 1) {
1978 if (*p == '+')
1979 *q++ = ' ';
1980 else
1981 *q++ = *p;
1982 }
1983 p++;
1984 }
1985 *q = '\0';
1986 }
1987 if (!strcmp(tag, tag1))
1988 return 1;
1989 if (*p != '&')
1990 break;
1991 p++;
1992 }
1993 return 0;
1994 }
1995
1996 /* Return in 'buf' the path with '%d' replaced by number. Also handles
1997 the '%0nd' format where 'n' is the total number of digits and
1998 '%%'. Return 0 if OK, and -1 if format error */
1999 int get_frame_filename(char *buf, int buf_size,
2000 const char *path, int number)
2001 {
2002 const char *p;
2003 char *q, buf1[20], c;
2004 int nd, len, percentd_found;
2005
2006 q = buf;
2007 p = path;
2008 percentd_found = 0;
2009 for(;;) {
2010 c = *p++;
2011 if (c == '\0')
2012 break;
2013 if (c == '%') {
2014 do {
2015 nd = 0;
2016 while (isdigit(*p)) {
2017 nd = nd * 10 + *p++ - '0';
2018 }
2019 c = *p++;
2020 } while (isdigit(c));
2021
2022 switch(c) {
2023 case '%':
2024 goto addchar;
2025 case 'd':
2026 if (percentd_found)
2027 goto fail;
2028 percentd_found = 1;
2029 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
2030 len = strlen(buf1);
2031 if ((q - buf + len) > buf_size - 1)
2032 goto fail;
2033 memcpy(q, buf1, len);
2034 q += len;
2035 break;
2036 default:
2037 goto fail;
2038 }
2039 } else {
2040 addchar:
2041 if ((q - buf) < buf_size - 1)
2042 *q++ = c;
2043 }
2044 }
2045 if (!percentd_found)
2046 goto fail;
2047 *q = '\0';
2048 return 0;
2049 fail:
2050 *q = '\0';
2051 return -1;
2052 }
2053
2054 /**
2055 * Print nice hexa dump of a buffer
2056 * @param f stream for output
2057 * @param buf buffer
2058 * @param size buffer size
2059 */
2060 void av_hex_dump(FILE *f, uint8_t *buf, int size)
2061 {
2062 int len, i, j, c;
2063
2064 for(i=0;i<size;i+=16) {
2065 len = size - i;
2066 if (len > 16)
2067 len = 16;
2068 fprintf(f, "%08x ", i);
2069 for(j=0;j<16;j++) {
2070 if (j < len)
2071 fprintf(f, " %02x", buf[i+j]);
2072 else
2073 fprintf(f, " ");
2074 }
2075 fprintf(f, " ");
2076 for(j=0;j<len;j++) {
2077 c = buf[i+j];
2078 if (c < ' ' || c > '~')
2079 c = '.';
2080 fprintf(f, "%c", c);
2081 }
2082 fprintf(f, "\n");
2083 }
2084 }
2085
2086 /**
2087 * Print on 'f' a nice dump of a packet
2088 * @param f stream for output
2089 * @param pkt packet to dump
2090 * @param dump_payload true if the payload must be displayed too
2091 */
2092 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
2093 {
2094 fprintf(f, "stream #%d:\n", pkt->stream_index);
2095 fprintf(f, " keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
2096 fprintf(f, " duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
2097 /* DTS is _always_ valid after av_read_frame() */
2098 fprintf(f, " dts=");
2099 if (pkt->dts == AV_NOPTS_VALUE)
2100 fprintf(f, "N/A");
2101 else
2102 fprintf(f, "%0.3f", (double)pkt->dts / AV_TIME_BASE);
2103 /* PTS may be not known if B frames are present */
2104 fprintf(f, " pts=");
2105 if (pkt->pts == AV_NOPTS_VALUE)
2106 fprintf(f, "N/A");
2107 else
2108 fprintf(f, "%0.3f", (double)pkt->pts / AV_TIME_BASE);
2109 fprintf(f, "\n");
2110 fprintf(f, " size=%d\n", pkt->size);
2111 if (dump_payload)
2112 av_hex_dump(f, pkt->data, pkt->size);
2113 }
2114
2115 void url_split(char *proto, int proto_size,
2116 char *hostname, int hostname_size,
2117 int *port_ptr,
2118 char *path, int path_size,
2119 const char *url)
2120 {
2121 const char *p;
2122 char *q;
2123 int port;
2124
2125 port = -1;
2126
2127 p = url;
2128 q = proto;
2129 while (*p != ':' && *p != '\0') {
2130 if ((q - proto) < proto_size - 1)
2131 *q++ = *p;
2132 p++;
2133 }
2134 if (proto_size > 0)
2135 *q = '\0';
2136 if (*p == '\0') {
2137 if (proto_size > 0)
2138 proto[0] = '\0';
2139 if (hostname_size > 0)
2140 hostname[0] = '\0';
2141 p = url;
2142 } else {
2143 p++;
2144 if (*p == '/')
2145 p++;
2146 if (*p == '/')
2147 p++;
2148 q = hostname;
2149 while (*p != ':' && *p != '/' && *p != '?' && *p != '\0') {
2150 if ((q - hostname) < hostname_size - 1)
2151 *q++ = *p;
2152 p++;
2153 }
2154 if (hostname_size > 0)
2155 *q = '\0';
2156 if (*p == ':') {
2157 p++;
2158 port = strtoul(p, (char **)&p, 10);
2159 }
2160 }
2161 if (port_ptr)
2162 *port_ptr = port;
2163 pstrcpy(path, path_size, p);
2164 }
2165
2166 /**
2167 * Set the pts for a given stream
2168 * @param s stream
2169 * @param pts_wrap_bits number of bits effectively used by the pts
2170 * (used for wrap control, 33 is the value for MPEG)
2171 * @param pts_num numerator to convert to seconds (MPEG: 1)
2172 * @param pts_den denominator to convert to seconds (MPEG: 90000)
2173 */
2174 void av_set_pts_info(AVFormatContext *s, int pts_wrap_bits,
2175 int pts_num, int pts_den)
2176 {
2177 s->pts_wrap_bits = pts_wrap_bits;
2178 s->pts_num = pts_num;
2179 s->pts_den = pts_den;
2180 }
2181
2182 /* fraction handling */
2183
2184 /**
2185 * f = val + (num / den) + 0.5. 'num' is normalized so that it is such
2186 * as 0 <= num < den.
2187 *
2188 * @param f fractional number
2189 * @param val integer value
2190 * @param num must be >= 0
2191 * @param den must be >= 1
2192 */
2193 void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
2194 {
2195 num += (den >> 1);
2196 if (num >= den) {
2197 val += num / den;
2198 num = num % den;
2199 }
2200 f->val = val;
2201 f->num = num;
2202 f->den = den;
2203 }
2204
2205 /* set f to (val + 0.5) */
2206 void av_frac_set(AVFrac *f, int64_t val)
2207 {
2208 f->val = val;
2209 f->num = f->den >> 1;
2210 }
2211
2212 /**
2213 * Fractionnal addition to f: f = f + (incr / f->den)
2214 *
2215 * @param f fractional number
2216 * @param incr increment, can be positive or negative
2217 */
2218 void av_frac_add(AVFrac *f, int64_t incr)
2219 {
2220 int64_t num, den;
2221
2222 num = f->num + incr;
2223 den = f->den;
2224 if (num < 0) {
2225 f->val += num / den;
2226 num = num % den;
2227 if (num < 0) {
2228 num += den;
2229 f->val--;
2230 }
2231 } else if (num >= den) {
2232 f->val += num / den;
2233 num = num % den;
2234 }
2235 f->num = num;
2236 }
2237
2238 /**
2239 * register a new image format
2240 * @param img_fmt Image format descriptor
2241 */
2242 void av_register_image_format(AVImageFormat *img_fmt)
2243 {
2244 AVImageFormat **p;
2245
2246 p = &first_image_format;
2247 while (*p != NULL) p = &(*p)->next;
2248 *p = img_fmt;
2249 img_fmt->next = NULL;
2250 }
2251
2252 /* guess image format */
2253 AVImageFormat *av_probe_image_format(AVProbeData *pd)
2254 {
2255 AVImageFormat *fmt1, *fmt;
2256 int score, score_max;
2257
2258 fmt = NULL;
2259 score_max = 0;
2260 for(fmt1 = first_image_format; fmt1 != NULL; fmt1 = fmt1->next) {
2261 if (fmt1->img_probe) {
2262 score = fmt1->img_probe(pd);
2263 if (score > score_max) {
2264 score_max = score;
2265 fmt = fmt1;
2266 }
2267 }
2268 }
2269 return fmt;
2270 }
2271
2272 AVImageFormat *guess_image_format(const char *filename)
2273 {
2274 AVImageFormat *fmt1;
2275
2276 for(fmt1 = first_image_format; fmt1 != NULL; fmt1 = fmt1->next) {
2277 if (fmt1->extensions && match_ext(filename, fmt1->extensions))
2278 return fmt1;
2279 }
2280 return NULL;
2281 }
2282
2283 /**
2284 * Read an image from a stream.
2285 * @param gb byte stream containing the image
2286 * @param fmt image format, NULL if probing is required
2287 */
2288 int av_read_image(ByteIOContext *pb, const char *filename,
2289 AVImageFormat *fmt,
2290 int (*alloc_cb)(void *, AVImageInfo *info), void *opaque)
2291 {
2292 char buf[PROBE_BUF_SIZE];
2293 AVProbeData probe_data, *pd = &probe_data;
2294 offset_t pos;
2295 int ret;
2296
2297 if (!fmt) {
2298 pd->filename = filename;
2299 pd->buf = buf;
2300 pos = url_ftell(pb);
2301 pd->buf_size = get_buffer(pb, buf, PROBE_BUF_SIZE);
2302 url_fseek(pb, pos, SEEK_SET);
2303 fmt = av_probe_image_format(pd);
2304 }
2305 if (!fmt)
2306 return AVERROR_NOFMT;
2307 ret = fmt->img_read(pb, alloc_cb, opaque);
2308 return ret;
2309 }
2310
2311 /**
2312 * Write an image to a stream.
2313 * @param pb byte stream for the image output
2314 * @param fmt image format
2315 * @param img image data and informations
2316 */
2317 int av_write_image(ByteIOContext *pb, AVImageFormat *fmt, AVImageInfo *img)
2318 {
2319 return fmt->img_write(pb, img);
2320 }
2321