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