2 * Various utilities for ffmpeg system
3 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
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.
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.
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
24 AVInputFormat *first_iformat;
25 AVOutputFormat *first_oformat;
26 AVImageFormat *first_image_format;
28 void av_register_input_format(AVInputFormat *format)
32 while (*p != NULL) p = &(*p)->next;
37 void av_register_output_format(AVOutputFormat *format)
41 while (*p != NULL) p = &(*p)->next;
46 int match_ext(const char *filename, const char *extensions)
54 ext = strrchr(filename, '.');
60 while (*p != '\0' && *p != ',')
63 if (!strcasecmp(ext1, ext))
73 AVOutputFormat *guess_format(const char *short_name, const char *filename,
74 const char *mime_type)
76 AVOutputFormat *fmt, *fmt_found;
79 /* specific test for image sequences */
80 if (!short_name && filename &&
81 filename_number_test(filename) >= 0 &&
82 guess_image_format(filename)) {
83 return guess_format("image", NULL, NULL);
86 /* find the proper file type */
92 if (fmt->name && short_name && !strcmp(fmt->name, short_name))
94 if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
96 if (filename && fmt->extensions &&
97 match_ext(filename, fmt->extensions)) {
100 if (score > score_max) {
109 AVOutputFormat *guess_stream_format(const char *short_name, const char *filename,
110 const char *mime_type)
112 AVOutputFormat *fmt = guess_format(short_name, filename, mime_type);
115 AVOutputFormat *stream_fmt;
116 char stream_format_name[64];
118 snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
119 stream_fmt = guess_format(stream_format_name, NULL, NULL);
128 AVInputFormat *av_find_input_format(const char *short_name)
131 for(fmt = first_iformat; fmt != NULL; fmt = fmt->next) {
132 if (!strcmp(fmt->name, short_name))
138 /* memory handling */
141 * Default packet destructor
143 static void av_destruct_packet(AVPacket *pkt)
146 pkt->data = NULL; pkt->size = 0;
150 * Allocate the payload of a packet and intialized its fields to default values.
153 * @param size wanted payload size
154 * @return 0 if OK. AVERROR_xxx otherwise.
156 int av_new_packet(AVPacket *pkt, int size)
158 void *data = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
160 return AVERROR_NOMEM;
161 memset(data + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
166 pkt->destruct = av_destruct_packet;
170 /* This is a hack - the packet memory allocation stuff is broken. The
171 packet is allocated if it was not really allocated */
172 int av_dup_packet(AVPacket *pkt)
174 if (pkt->destruct != av_destruct_packet) {
176 /* we duplicate the packet and don't forget to put the padding
178 data = av_malloc(pkt->size + FF_INPUT_BUFFER_PADDING_SIZE);
180 return AVERROR_NOMEM;
182 memcpy(data, pkt->data, pkt->size);
183 memset(data + pkt->size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
185 pkt->destruct = av_destruct_packet;
192 int fifo_init(FifoBuffer *f, int size)
194 f->buffer = av_malloc(size);
197 f->end = f->buffer + size;
198 f->wptr = f->rptr = f->buffer;
202 void fifo_free(FifoBuffer *f)
207 int fifo_size(FifoBuffer *f, uint8_t *rptr)
211 if (f->wptr >= rptr) {
212 size = f->wptr - rptr;
214 size = (f->end - rptr) + (f->wptr - f->buffer);
219 /* get data from the fifo (return -1 if not enough data) */
220 int fifo_read(FifoBuffer *f, uint8_t *buf, int buf_size, uint8_t **rptr_ptr)
222 uint8_t *rptr = *rptr_ptr;
225 if (f->wptr >= rptr) {
226 size = f->wptr - rptr;
228 size = (f->end - rptr) + (f->wptr - f->buffer);
233 while (buf_size > 0) {
237 memcpy(buf, rptr, len);
248 void fifo_write(FifoBuffer *f, uint8_t *buf, int size, uint8_t **wptr_ptr)
257 memcpy(wptr, buf, len);
267 int filename_number_test(const char *filename)
272 return get_frame_filename(buf, sizeof(buf), filename, 1);
275 /* guess file format */
276 AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened)
278 AVInputFormat *fmt1, *fmt;
279 int score, score_max;
283 for(fmt1 = first_iformat; fmt1 != NULL; fmt1 = fmt1->next) {
284 if (!is_opened && !(fmt1->flags & AVFMT_NOFILE))
287 if (fmt1->read_probe) {
288 score = fmt1->read_probe(pd);
289 } else if (fmt1->extensions) {
290 if (match_ext(pd->filename, fmt1->extensions)) {
294 if (score > score_max) {
302 /************************************************************/
303 /* input media file */
306 * open a media file from an IO stream. 'fmt' must be specified.
309 static const char* format_to_name(void* ptr)
311 AVFormatContext* fc = (AVFormatContext*) ptr;
312 if(fc->iformat) return fc->iformat->name;
313 else if(fc->oformat) return fc->oformat->name;
317 static const AVClass av_format_context_class = { "AVFormatContext", format_to_name };
319 AVFormatContext *av_alloc_format_context(void)
322 ic = av_mallocz(sizeof(AVFormatContext));
324 ic->av_class = &av_format_context_class;
328 int av_open_input_stream(AVFormatContext **ic_ptr,
329 ByteIOContext *pb, const char *filename,
330 AVInputFormat *fmt, AVFormatParameters *ap)
335 ic = av_alloc_format_context();
343 ic->duration = AV_NOPTS_VALUE;
344 ic->start_time = AV_NOPTS_VALUE;
345 pstrcpy(ic->filename, sizeof(ic->filename), filename);
347 /* allocate private data */
348 if (fmt->priv_data_size > 0) {
349 ic->priv_data = av_mallocz(fmt->priv_data_size);
350 if (!ic->priv_data) {
355 ic->priv_data = NULL;
358 err = ic->iformat->read_header(ic, ap);
363 ic->data_offset = url_ftell(&ic->pb);
369 av_freep(&ic->priv_data);
376 #define PROBE_BUF_SIZE 2048
379 * Open a media file as input. The codec are not opened. Only the file
380 * header (if present) is read.
382 * @param ic_ptr the opened media file handle is put here
383 * @param filename filename to open.
384 * @param fmt if non NULL, force the file format to use
385 * @param buf_size optional buffer size (zero if default is OK)
386 * @param ap additionnal parameters needed when opening the file (NULL if default)
387 * @return 0 if OK. AVERROR_xxx otherwise.
389 int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
392 AVFormatParameters *ap)
394 int err, must_open_file, file_opened;
395 uint8_t buf[PROBE_BUF_SIZE];
396 AVProbeData probe_data, *pd = &probe_data;
397 ByteIOContext pb1, *pb = &pb1;
402 pd->filename = filename;
407 /* guess format if no file can be opened */
408 fmt = av_probe_input_format(pd, 0);
411 /* do not open file if the format does not need it. XXX: specific
412 hack needed to handle RTSP/TCP */
414 if (fmt && (fmt->flags & AVFMT_NOFILE)) {
418 if (!fmt || must_open_file) {
419 /* if no file needed do not try to open one */
420 if (url_fopen(pb, filename, URL_RDONLY) < 0) {
426 url_setbufsize(pb, buf_size);
429 /* read probe data */
430 pd->buf_size = get_buffer(pb, buf, PROBE_BUF_SIZE);
431 url_fseek(pb, 0, SEEK_SET);
435 /* guess file format */
437 fmt = av_probe_input_format(pd, 1);
440 /* if still no format found, error */
446 /* XXX: suppress this hack for redirectors */
447 #ifdef CONFIG_NETWORK
448 if (fmt == &redir_demux) {
449 err = redir_open(ic_ptr, pb);
455 /* check filename in case of an image number is expected */
456 if (fmt->flags & AVFMT_NEEDNUMBER) {
457 if (filename_number_test(filename) < 0) {
458 err = AVERROR_NUMEXPECTED;
462 err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
474 /*******************************************************/
477 * Read a transport packet from a media file. This function is
478 * absolete and should never be used. Use av_read_frame() instead.
480 * @param s media file handle
481 * @param pkt is filled
482 * @return 0 if OK. AVERROR_xxx if error.
484 int av_read_packet(AVFormatContext *s, AVPacket *pkt)
486 return s->iformat->read_packet(s, pkt);
489 /**********************************************************/
491 /* convert the packet time stamp units and handle wrapping. The
492 wrapping is handled by considering the next PTS/DTS as a delta to
493 the previous value. We handle the delta as a fraction to avoid any
495 static inline int64_t convert_timestamp_units(AVStream *s,
496 int64_t *plast_pkt_pts,
497 int *plast_pkt_pts_frac,
498 int64_t *plast_pkt_stream_pts,
505 if (pts != AV_NOPTS_VALUE) {
507 if (*plast_pkt_stream_pts != AV_NOPTS_VALUE) {
508 shift = 64 - s->pts_wrap_bits;
509 delta_pts = ((stream_pts - *plast_pkt_stream_pts) << shift) >> shift;
510 /* XXX: overflow possible but very unlikely as it is a delta */
511 delta_pts = delta_pts * AV_TIME_BASE * s->time_base.num;
512 pts = *plast_pkt_pts + (delta_pts / s->time_base.den);
513 pts_frac = *plast_pkt_pts_frac + (delta_pts % s->time_base.den);
514 if (pts_frac >= s->time_base.den) {
515 pts_frac -= s->time_base.den;
519 /* no previous pts, so no wrapping possible */
520 // pts = av_rescale(stream_pts, (int64_t)AV_TIME_BASE * s->time_base.num, s->time_base.den);
521 pts = (int64_t)(((double)stream_pts * AV_TIME_BASE * s->time_base.num) /
522 (double)s->time_base.den);
525 *plast_pkt_stream_pts = stream_pts;
526 *plast_pkt_pts = pts;
527 *plast_pkt_pts_frac = pts_frac;
532 /* get the number of samples of an audio frame. Return (-1) if error */
533 static int get_audio_frame_size(AVCodecContext *enc, int size)
537 if (enc->frame_size <= 1) {
538 /* specific hack for pcm codecs because no frame size is
540 switch(enc->codec_id) {
541 case CODEC_ID_PCM_S16LE:
542 case CODEC_ID_PCM_S16BE:
543 case CODEC_ID_PCM_U16LE:
544 case CODEC_ID_PCM_U16BE:
545 if (enc->channels == 0)
547 frame_size = size / (2 * enc->channels);
549 case CODEC_ID_PCM_S8:
550 case CODEC_ID_PCM_U8:
551 case CODEC_ID_PCM_MULAW:
552 case CODEC_ID_PCM_ALAW:
553 if (enc->channels == 0)
555 frame_size = size / (enc->channels);
558 /* used for example by ADPCM codecs */
559 if (enc->bit_rate == 0)
561 frame_size = (size * 8 * enc->sample_rate) / enc->bit_rate;
565 frame_size = enc->frame_size;
571 /* return the frame duration in seconds, return 0 if not available */
572 static void compute_frame_duration(int *pnum, int *pden,
573 AVFormatContext *s, AVStream *st,
574 AVCodecParserContext *pc, AVPacket *pkt)
580 switch(st->codec.codec_type) {
581 case CODEC_TYPE_VIDEO:
582 *pnum = st->codec.frame_rate_base;
583 *pden = st->codec.frame_rate;
584 if (pc && pc->repeat_pict) {
586 *pnum = (*pnum) * (2 + pc->repeat_pict);
589 case CODEC_TYPE_AUDIO:
590 frame_size = get_audio_frame_size(&st->codec, pkt->size);
594 *pden = st->codec.sample_rate;
601 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
602 AVCodecParserContext *pc, AVPacket *pkt)
604 int num, den, presentation_delayed;
606 if (pkt->duration == 0) {
607 compute_frame_duration(&num, &den, s, st, pc, pkt);
609 pkt->duration = (num * (int64_t)AV_TIME_BASE) / den;
613 /* do we have a video B frame ? */
614 presentation_delayed = 0;
615 if (st->codec.codec_type == CODEC_TYPE_VIDEO) {
616 /* XXX: need has_b_frame, but cannot get it if the codec is
618 if ((st->codec.codec_id == CODEC_ID_MPEG1VIDEO ||
619 st->codec.codec_id == CODEC_ID_MPEG2VIDEO ||
620 st->codec.codec_id == CODEC_ID_MPEG4 ||
621 st->codec.codec_id == CODEC_ID_H264) &&
622 pc && pc->pict_type != FF_B_TYPE)
623 presentation_delayed = 1;
626 /* interpolate PTS and DTS if they are not present */
627 if (presentation_delayed) {
628 /* DTS = decompression time stamp */
629 /* PTS = presentation time stamp */
630 if (pkt->dts == AV_NOPTS_VALUE) {
631 pkt->dts = st->cur_dts;
633 st->cur_dts = pkt->dts;
635 /* this is tricky: the dts must be incremented by the duration
636 of the frame we are displaying, i.e. the last I or P frame */
637 if (st->last_IP_duration == 0)
638 st->cur_dts += pkt->duration;
640 st->cur_dts += st->last_IP_duration;
641 st->last_IP_duration = pkt->duration;
642 /* cannot compute PTS if not present (we can compute it only
643 by knowing the futur */
645 /* presentation is not delayed : PTS and DTS are the same */
646 if (pkt->pts == AV_NOPTS_VALUE) {
647 if (pkt->dts == AV_NOPTS_VALUE) {
648 pkt->pts = st->cur_dts;
649 pkt->dts = st->cur_dts;
652 st->cur_dts = pkt->dts;
656 st->cur_dts = pkt->pts;
659 st->cur_dts += pkt->duration;
665 /* key frame computation */
666 switch(st->codec.codec_type) {
667 case CODEC_TYPE_VIDEO:
668 if (pc->pict_type == FF_I_TYPE)
669 pkt->flags |= PKT_FLAG_KEY;
671 case CODEC_TYPE_AUDIO:
672 pkt->flags |= PKT_FLAG_KEY;
681 static void av_destruct_packet_nofree(AVPacket *pkt)
683 pkt->data = NULL; pkt->size = 0;
686 static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
692 /* select current input stream component */
696 /* no parsing needed: we just output the packet as is */
697 /* raw data support */
699 compute_pkt_fields(s, st, NULL, pkt);
702 } else if (s->cur_len > 0) {
703 len = av_parser_parse(st->parser, &st->codec, &pkt->data, &pkt->size,
704 s->cur_ptr, s->cur_len,
705 s->cur_pkt.pts, s->cur_pkt.dts);
706 s->cur_pkt.pts = AV_NOPTS_VALUE;
707 s->cur_pkt.dts = AV_NOPTS_VALUE;
708 /* increment read pointer */
712 /* return packet if any */
716 pkt->stream_index = st->index;
717 pkt->pts = st->parser->pts;
718 pkt->dts = st->parser->dts;
719 pkt->destruct = av_destruct_packet_nofree;
720 compute_pkt_fields(s, st, st->parser, pkt);
725 av_free_packet(&s->cur_pkt);
729 /* read next packet */
730 ret = av_read_packet(s, &s->cur_pkt);
734 /* return the last frames, if any */
735 for(i = 0; i < s->nb_streams; i++) {
738 av_parser_parse(st->parser, &st->codec,
739 &pkt->data, &pkt->size,
741 AV_NOPTS_VALUE, AV_NOPTS_VALUE);
746 /* no more packets: really terminates parsing */
750 st = s->streams[s->cur_pkt.stream_index];
752 /* convert the packet time stamp units and handle wrapping */
753 s->cur_pkt.pts = convert_timestamp_units(st,
754 &st->last_pkt_pts, &st->last_pkt_pts_frac,
755 &st->last_pkt_stream_pts,
757 s->cur_pkt.dts = convert_timestamp_units(st,
758 &st->last_pkt_dts, &st->last_pkt_dts_frac,
759 &st->last_pkt_stream_dts,
762 if (s->cur_pkt.stream_index == 0) {
763 if (s->cur_pkt.pts != AV_NOPTS_VALUE)
764 printf("PACKET pts=%0.3f\n",
765 (double)s->cur_pkt.pts / AV_TIME_BASE);
766 if (s->cur_pkt.dts != AV_NOPTS_VALUE)
767 printf("PACKET dts=%0.3f\n",
768 (double)s->cur_pkt.dts / AV_TIME_BASE);
773 s->cur_pkt.duration = av_rescale(s->cur_pkt.duration, AV_TIME_BASE * (int64_t)st->time_base.num, st->time_base.den);
776 s->cur_ptr = s->cur_pkt.data;
777 s->cur_len = s->cur_pkt.size;
778 if (st->need_parsing && !st->parser) {
779 st->parser = av_parser_init(st->codec.codec_id);
781 /* no parser available : just output the raw packets */
782 st->need_parsing = 0;
790 * Return the next frame of a stream. The returned packet is valid
791 * until the next av_read_frame() or until av_close_input_file() and
792 * must be freed with av_free_packet. For video, the packet contains
793 * exactly one frame. For audio, it contains an integer number of
794 * frames if each frame has a known fixed size (e.g. PCM or ADPCM
795 * data). If the audio frames have a variable size (e.g. MPEG audio),
796 * then it contains one frame.
798 * pkt->pts, pkt->dts and pkt->duration are always set to correct
799 * values in AV_TIME_BASE unit (and guessed if the format cannot
800 * provided them). pkt->pts can be AV_NOPTS_VALUE if the video format
801 * has B frames, so it is better to rely on pkt->dts if you do not
802 * decompress the payload.
804 * Return 0 if OK, < 0 if error or end of file.
806 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
810 pktl = s->packet_buffer;
812 /* read packet from packet buffer, if there is data */
814 s->packet_buffer = pktl->next;
818 return av_read_frame_internal(s, pkt);
822 /* XXX: suppress the packet queue */
823 static void flush_packet_queue(AVFormatContext *s)
828 pktl = s->packet_buffer;
831 s->packet_buffer = pktl->next;
832 av_free_packet(&pktl->pkt);
837 /*******************************************************/
840 int av_find_default_stream_index(AVFormatContext *s)
845 if (s->nb_streams <= 0)
847 for(i = 0; i < s->nb_streams; i++) {
849 if (st->codec.codec_type == CODEC_TYPE_VIDEO) {
856 /* flush the frame reader */
857 static void av_read_frame_flush(AVFormatContext *s)
862 flush_packet_queue(s);
864 /* free previous packet */
866 if (s->cur_st->parser)
867 av_free_packet(&s->cur_pkt);
874 /* for each stream, reset read state */
875 for(i = 0; i < s->nb_streams; i++) {
879 av_parser_close(st->parser);
882 st->cur_dts = 0; /* we set the current DTS to an unspecified origin */
886 /* add a index entry into a sorted list updateing if it is already there */
887 int av_add_index_entry(AVStream *st,
888 int64_t pos, int64_t timestamp, int distance, int flags)
890 AVIndexEntry *entries, *ie;
893 entries = av_fast_realloc(st->index_entries,
894 &st->index_entries_allocated_size,
895 (st->nb_index_entries + 1) *
896 sizeof(AVIndexEntry));
897 st->index_entries= entries;
899 if(st->nb_index_entries){
900 index= av_index_search_timestamp(st, timestamp);
903 if(ie->timestamp != timestamp){
904 if(ie->timestamp < timestamp){
905 index++; //index points to next instead of previous entry, maybe nonexistant
906 ie= &st->index_entries[index];
910 if(index != st->nb_index_entries){
911 assert(index < st->nb_index_entries);
912 memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
914 st->nb_index_entries++;
916 if(ie->pos == pos && distance < ie->min_distance) //dont reduce the distance
917 distance= ie->min_distance;
920 index= st->nb_index_entries++;
925 ie->timestamp = timestamp;
926 ie->min_distance= distance;
932 /* build an index for raw streams using a parser */
933 static void av_build_index_raw(AVFormatContext *s)
935 AVPacket pkt1, *pkt = &pkt1;
940 av_read_frame_flush(s);
941 url_fseek(&s->pb, s->data_offset, SEEK_SET);
944 ret = av_read_frame(s, pkt);
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);
956 /* return TRUE if we deal with a raw stream (raw codec data and
958 static int is_raw_stream(AVFormatContext *s)
962 if (s->nb_streams != 1)
965 if (!st->need_parsing)
970 /* return the largest index entry whose timestamp is <=
972 int av_index_search_timestamp(AVStream *st, int wanted_timestamp)
974 AVIndexEntry *entries= st->index_entries;
975 int nb_entries= st->nb_index_entries;
986 m = (a + b + 1) >> 1;
987 timestamp = entries[m].timestamp;
988 if (timestamp > wanted_timestamp) {
999 int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts){
1000 AVInputFormat *avif= s->iformat;
1001 int64_t pos_min, pos_max, pos, pos_limit;
1002 int64_t ts_min, ts_max, ts;
1004 int index, no_change;
1007 if (stream_index < 0) {
1008 stream_index = av_find_default_stream_index(s);
1009 if (stream_index < 0)
1014 av_log(s, AV_LOG_DEBUG, "read_seek: %d %lld\n", stream_index, target_ts);
1018 ts_min= AV_NOPTS_VALUE;
1019 pos_limit= -1; //gcc falsely says it may be uninitalized
1021 st= s->streams[stream_index];
1022 if(st->index_entries){
1025 index= av_index_search_timestamp(st, target_ts);
1026 e= &st->index_entries[index];
1028 if(e->timestamp <= target_ts || e->pos == e->min_distance){
1030 ts_min= e->timestamp;
1032 av_log(s, AV_LOG_DEBUG, "unsing cached pos_min=0x%llx dts_min=%lld\n",
1039 if(index < st->nb_index_entries){
1040 e= &st->index_entries[index];
1041 assert(e->timestamp >= target_ts);
1043 ts_max= e->timestamp;
1044 pos_limit= pos_max - e->min_distance;
1046 av_log(s, AV_LOG_DEBUG, "unsing cached pos_max=0x%llx pos_limit=0x%llx dts_max=%lld\n",
1047 pos_max,pos_limit, ts_max);
1052 if(ts_min == AV_NOPTS_VALUE){
1053 pos_min = s->data_offset;
1054 ts_min = avif->read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1055 if (ts_min == AV_NOPTS_VALUE)
1059 if(ts_max == AV_NOPTS_VALUE){
1061 pos_max = url_filesize(url_fileno(&s->pb)) - 1;
1064 ts_max = avif->read_timestamp(s, stream_index, &pos_max, pos_max + step);
1066 }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1067 if (ts_max == AV_NOPTS_VALUE)
1071 int64_t tmp_pos= pos_max + 1;
1072 int64_t tmp_ts= avif->read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1073 if(tmp_ts == AV_NOPTS_VALUE)
1082 while (pos_min < pos_limit) {
1084 av_log(s, AV_LOG_DEBUG, "pos_min=0x%llx pos_max=0x%llx dts_min=%lld dts_max=%lld\n",
1088 assert(pos_limit <= pos_max);
1091 int64_t approximate_keyframe_distance= pos_max - pos_limit;
1092 // interpolate position (better than dichotomy)
1093 pos = (int64_t)((double)(pos_max - pos_min) *
1094 (double)(target_ts - ts_min) /
1095 (double)(ts_max - ts_min)) + pos_min - approximate_keyframe_distance;
1096 }else if(no_change==1){
1097 // bisection, if interpolation failed to change min or max pos last time
1098 pos = (pos_min + pos_limit)>>1;
1100 // linear search if bisection failed, can only happen if there are very few or no keframes between min/max
1105 else if(pos > pos_limit)
1109 ts = avif->read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1115 av_log(s, AV_LOG_DEBUG, "%Ld %Ld %Ld / %Ld %Ld %Ld target:%Ld limit:%Ld start:%Ld noc:%d\n", pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts, pos_limit, start_pos, no_change);
1117 assert(ts != AV_NOPTS_VALUE);
1118 if (target_ts < ts) {
1119 pos_limit = start_pos - 1;
1125 /* check if we are lucky */
1126 if (target_ts == ts)
1134 ts_min = avif->read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1136 ts_max = avif->read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1137 av_log(s, AV_LOG_DEBUG, "pos=0x%llx %lld<=%lld<=%lld\n",
1138 pos, ts_min, target_ts, ts_max);
1141 url_fseek(&s->pb, pos, SEEK_SET);
1142 st->cur_dts = ts_min;
1147 static int av_seek_frame_generic(AVFormatContext *s,
1148 int stream_index, int64_t timestamp)
1154 if (!s->index_built) {
1155 if (is_raw_stream(s)) {
1156 av_build_index_raw(s);
1163 if (stream_index < 0)
1165 st = s->streams[stream_index];
1166 index = av_index_search_timestamp(st, timestamp);
1170 /* now we have found the index, we can seek */
1171 ie = &st->index_entries[index];
1172 av_read_frame_flush(s);
1173 url_fseek(&s->pb, ie->pos, SEEK_SET);
1174 st->cur_dts = ie->timestamp;
1179 * Seek to the key frame just before the frame at timestamp
1180 * 'timestamp' in 'stream_index'. If stream_index is (-1), a default
1181 * stream is selected
1183 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp)
1187 av_read_frame_flush(s);
1189 /* first, we try the format specific seek */
1190 if (s->iformat->read_seek)
1191 ret = s->iformat->read_seek(s, stream_index, timestamp);
1198 if(s->iformat->read_timestamp)
1199 return av_seek_frame_binary(s, stream_index, timestamp);
1201 return av_seek_frame_generic(s, stream_index, timestamp);
1204 /*******************************************************/
1206 /* return TRUE if the stream has accurate timings for at least one component */
1207 static int av_has_timings(AVFormatContext *ic)
1212 for(i = 0;i < ic->nb_streams; i++) {
1213 st = ic->streams[i];
1214 if (st->start_time != AV_NOPTS_VALUE &&
1215 st->duration != AV_NOPTS_VALUE)
1221 /* estimate the stream timings from the one of each components. Also
1222 compute the global bitrate if possible */
1223 static void av_update_stream_timings(AVFormatContext *ic)
1225 int64_t start_time, end_time, end_time1;
1229 start_time = MAXINT64;
1230 end_time = MININT64;
1231 for(i = 0;i < ic->nb_streams; i++) {
1232 st = ic->streams[i];
1233 if (st->start_time != AV_NOPTS_VALUE) {
1234 if (st->start_time < start_time)
1235 start_time = st->start_time;
1236 if (st->duration != AV_NOPTS_VALUE) {
1237 end_time1 = st->start_time + st->duration;
1238 if (end_time1 > end_time)
1239 end_time = end_time1;
1243 if (start_time != MAXINT64) {
1244 ic->start_time = start_time;
1245 if (end_time != MAXINT64) {
1246 ic->duration = end_time - start_time;
1247 if (ic->file_size > 0) {
1248 /* compute the bit rate */
1249 ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1250 (double)ic->duration;
1257 static void fill_all_stream_timings(AVFormatContext *ic)
1262 av_update_stream_timings(ic);
1263 for(i = 0;i < ic->nb_streams; i++) {
1264 st = ic->streams[i];
1265 if (st->start_time == AV_NOPTS_VALUE) {
1266 st->start_time = ic->start_time;
1267 st->duration = ic->duration;
1272 static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1274 int64_t filesize, duration;
1278 /* if bit_rate is already set, we believe it */
1279 if (ic->bit_rate == 0) {
1281 for(i=0;i<ic->nb_streams;i++) {
1282 st = ic->streams[i];
1283 bit_rate += st->codec.bit_rate;
1285 ic->bit_rate = bit_rate;
1288 /* if duration is already set, we believe it */
1289 if (ic->duration == AV_NOPTS_VALUE &&
1290 ic->bit_rate != 0 &&
1291 ic->file_size != 0) {
1292 filesize = ic->file_size;
1294 duration = (int64_t)((8 * AV_TIME_BASE * (double)filesize) / (double)ic->bit_rate);
1295 for(i = 0; i < ic->nb_streams; i++) {
1296 st = ic->streams[i];
1297 if (st->start_time == AV_NOPTS_VALUE ||
1298 st->duration == AV_NOPTS_VALUE) {
1300 st->duration = duration;
1307 #define DURATION_MAX_READ_SIZE 250000
1309 /* only usable for MPEG-PS streams */
1310 static void av_estimate_timings_from_pts(AVFormatContext *ic)
1312 AVPacket pkt1, *pkt = &pkt1;
1314 int read_size, i, ret;
1315 int64_t start_time, end_time, end_time1;
1316 int64_t filesize, offset, duration;
1318 /* free previous packet */
1319 if (ic->cur_st && ic->cur_st->parser)
1320 av_free_packet(&ic->cur_pkt);
1323 /* flush packet queue */
1324 flush_packet_queue(ic);
1327 /* we read the first packets to get the first PTS (not fully
1328 accurate, but it is enough now) */
1329 url_fseek(&ic->pb, 0, SEEK_SET);
1332 if (read_size >= DURATION_MAX_READ_SIZE)
1334 /* if all info is available, we can stop */
1335 for(i = 0;i < ic->nb_streams; i++) {
1336 st = ic->streams[i];
1337 if (st->start_time == AV_NOPTS_VALUE)
1340 if (i == ic->nb_streams)
1343 ret = av_read_packet(ic, pkt);
1346 read_size += pkt->size;
1347 st = ic->streams[pkt->stream_index];
1348 if (pkt->pts != AV_NOPTS_VALUE) {
1349 if (st->start_time == AV_NOPTS_VALUE)
1350 st->start_time = av_rescale(pkt->pts, st->time_base.num * (int64_t)AV_TIME_BASE, st->time_base.den);
1352 av_free_packet(pkt);
1355 /* we compute the minimum start_time and use it as default */
1356 start_time = MAXINT64;
1357 for(i = 0; i < ic->nb_streams; i++) {
1358 st = ic->streams[i];
1359 if (st->start_time != AV_NOPTS_VALUE &&
1360 st->start_time < start_time)
1361 start_time = st->start_time;
1363 if (start_time != MAXINT64)
1364 ic->start_time = start_time;
1366 /* estimate the end time (duration) */
1367 /* XXX: may need to support wrapping */
1368 filesize = ic->file_size;
1369 offset = filesize - DURATION_MAX_READ_SIZE;
1373 url_fseek(&ic->pb, offset, SEEK_SET);
1376 if (read_size >= DURATION_MAX_READ_SIZE)
1378 /* if all info is available, we can stop */
1379 for(i = 0;i < ic->nb_streams; i++) {
1380 st = ic->streams[i];
1381 if (st->duration == AV_NOPTS_VALUE)
1384 if (i == ic->nb_streams)
1387 ret = av_read_packet(ic, pkt);
1390 read_size += pkt->size;
1391 st = ic->streams[pkt->stream_index];
1392 if (pkt->pts != AV_NOPTS_VALUE) {
1393 end_time = av_rescale(pkt->pts, st->time_base.num * (int64_t)AV_TIME_BASE, st->time_base.den);
1394 duration = end_time - st->start_time;
1396 if (st->duration == AV_NOPTS_VALUE ||
1397 st->duration < duration)
1398 st->duration = duration;
1401 av_free_packet(pkt);
1404 /* estimate total duration */
1405 end_time = MININT64;
1406 for(i = 0;i < ic->nb_streams; i++) {
1407 st = ic->streams[i];
1408 if (st->duration != AV_NOPTS_VALUE) {
1409 end_time1 = st->start_time + st->duration;
1410 if (end_time1 > end_time)
1411 end_time = end_time1;
1415 /* update start_time (new stream may have been created, so we do
1417 if (ic->start_time != AV_NOPTS_VALUE) {
1418 for(i = 0; i < ic->nb_streams; i++) {
1419 st = ic->streams[i];
1420 if (st->start_time == AV_NOPTS_VALUE)
1421 st->start_time = ic->start_time;
1425 if (end_time != MININT64) {
1426 /* put dummy values for duration if needed */
1427 for(i = 0;i < ic->nb_streams; i++) {
1428 st = ic->streams[i];
1429 if (st->duration == AV_NOPTS_VALUE &&
1430 st->start_time != AV_NOPTS_VALUE)
1431 st->duration = end_time - st->start_time;
1433 ic->duration = end_time - ic->start_time;
1436 url_fseek(&ic->pb, 0, SEEK_SET);
1439 static void av_estimate_timings(AVFormatContext *ic)
1444 /* get the file size, if possible */
1445 if (ic->iformat->flags & AVFMT_NOFILE) {
1448 h = url_fileno(&ic->pb);
1449 file_size = url_filesize(h);
1453 ic->file_size = file_size;
1455 if (ic->iformat == &mpegps_demux) {
1456 /* get accurate estimate from the PTSes */
1457 av_estimate_timings_from_pts(ic);
1458 } else if (av_has_timings(ic)) {
1459 /* at least one components has timings - we use them for all
1461 fill_all_stream_timings(ic);
1463 /* less precise: use bit rate info */
1464 av_estimate_timings_from_bit_rate(ic);
1466 av_update_stream_timings(ic);
1472 for(i = 0;i < ic->nb_streams; i++) {
1473 st = ic->streams[i];
1474 printf("%d: start_time: %0.3f duration: %0.3f\n",
1475 i, (double)st->start_time / AV_TIME_BASE,
1476 (double)st->duration / AV_TIME_BASE);
1478 printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1479 (double)ic->start_time / AV_TIME_BASE,
1480 (double)ic->duration / AV_TIME_BASE,
1481 ic->bit_rate / 1000);
1486 static int has_codec_parameters(AVCodecContext *enc)
1489 switch(enc->codec_type) {
1490 case CODEC_TYPE_AUDIO:
1491 val = enc->sample_rate;
1493 case CODEC_TYPE_VIDEO:
1503 static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1507 int got_picture, ret;
1510 codec = avcodec_find_decoder(st->codec.codec_id);
1513 ret = avcodec_open(&st->codec, codec);
1516 switch(st->codec.codec_type) {
1517 case CODEC_TYPE_VIDEO:
1518 ret = avcodec_decode_video(&st->codec, &picture,
1519 &got_picture, (uint8_t *)data, size);
1521 case CODEC_TYPE_AUDIO:
1522 samples = av_malloc(AVCODEC_MAX_AUDIO_FRAME_SIZE);
1525 ret = avcodec_decode_audio(&st->codec, samples,
1526 &got_picture, (uint8_t *)data, size);
1533 avcodec_close(&st->codec);
1537 /* absolute maximum size we read until we abort */
1538 #define MAX_READ_SIZE 5000000
1540 /* maximum duration until we stop analysing the stream */
1541 #define MAX_STREAM_DURATION ((int)(AV_TIME_BASE * 1.0))
1544 * Read the beginning of a media file to get stream information. This
1545 * is useful for file formats with no headers such as MPEG. This
1546 * function also compute the real frame rate in case of mpeg2 repeat
1549 * @param ic media file handle
1550 * @return >=0 if OK. AVERROR_xxx if error.
1552 int av_find_stream_info(AVFormatContext *ic)
1554 int i, count, ret, read_size;
1556 AVPacket pkt1, *pkt;
1557 AVPacketList *pktl=NULL, **ppktl;
1561 ppktl = &ic->packet_buffer;
1563 /* check if one codec still needs to be handled */
1564 for(i=0;i<ic->nb_streams;i++) {
1565 st = ic->streams[i];
1566 if (!has_codec_parameters(&st->codec))
1569 if (i == ic->nb_streams) {
1570 /* NOTE: if the format has no header, then we need to read
1571 some packets to get most of the streams, so we cannot
1573 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
1574 /* if we found the info for all the codecs, we can stop */
1579 /* we did not get all the codec info, but we read too much data */
1580 if (read_size >= MAX_READ_SIZE) {
1586 /* NOTE: a new stream can be added there if no header in file
1587 (AVFMTCTX_NOHEADER) */
1588 ret = av_read_frame_internal(ic, &pkt1);
1591 ret = -1; /* we could not have all the codec parameters before EOF */
1592 if ((ic->ctx_flags & AVFMTCTX_NOHEADER) &&
1593 i == ic->nb_streams)
1598 pktl = av_mallocz(sizeof(AVPacketList));
1600 ret = AVERROR_NOMEM;
1604 /* add the packet in the buffered packet list */
1606 ppktl = &pktl->next;
1611 /* duplicate the packet */
1612 if (av_dup_packet(pkt) < 0) {
1613 ret = AVERROR_NOMEM;
1617 read_size += pkt->size;
1619 st = ic->streams[pkt->stream_index];
1620 st->codec_info_duration += pkt->duration;
1621 if (pkt->duration != 0)
1622 st->codec_info_nb_frames++;
1624 /* if still no information, we try to open the codec and to
1625 decompress the frame. We try to avoid that in most cases as
1626 it takes longer and uses more memory. For MPEG4, we need to
1627 decompress for Quicktime. */
1628 if (!has_codec_parameters(&st->codec) &&
1629 (st->codec.codec_id == CODEC_ID_FLV1 ||
1630 st->codec.codec_id == CODEC_ID_H264 ||
1631 st->codec.codec_id == CODEC_ID_H263 ||
1632 st->codec.codec_id == CODEC_ID_VORBIS ||
1633 (st->codec.codec_id == CODEC_ID_MPEG4 && !st->need_parsing)))
1634 try_decode_frame(st, pkt->data, pkt->size);
1636 if (st->codec_info_duration >= MAX_STREAM_DURATION) {
1642 /* set real frame rate info */
1643 for(i=0;i<ic->nb_streams;i++) {
1644 st = ic->streams[i];
1645 if (st->codec.codec_type == CODEC_TYPE_VIDEO) {
1646 /* compute the real frame rate for telecine */
1647 if ((st->codec.codec_id == CODEC_ID_MPEG1VIDEO ||
1648 st->codec.codec_id == CODEC_ID_MPEG2VIDEO) &&
1649 st->codec.sub_id == 2) {
1650 if (st->codec_info_nb_frames >= 20) {
1651 float coded_frame_rate, est_frame_rate;
1652 est_frame_rate = ((double)st->codec_info_nb_frames * AV_TIME_BASE) /
1653 (double)st->codec_info_duration ;
1654 coded_frame_rate = (double)st->codec.frame_rate /
1655 (double)st->codec.frame_rate_base;
1657 printf("telecine: coded_frame_rate=%0.3f est_frame_rate=%0.3f\n",
1658 coded_frame_rate, est_frame_rate);
1660 /* if we detect that it could be a telecine, we
1661 signal it. It would be better to do it at a
1662 higher level as it can change in a film */
1663 if (coded_frame_rate >= 24.97 &&
1664 (est_frame_rate >= 23.5 && est_frame_rate < 24.5)) {
1665 st->r_frame_rate = 24024;
1666 st->r_frame_rate_base = 1001;
1670 /* if no real frame rate, use the codec one */
1671 if (!st->r_frame_rate){
1672 st->r_frame_rate = st->codec.frame_rate;
1673 st->r_frame_rate_base = st->codec.frame_rate_base;
1678 av_estimate_timings(ic);
1682 /*******************************************************/
1685 * start playing a network based stream (e.g. RTSP stream) at the
1688 int av_read_play(AVFormatContext *s)
1690 if (!s->iformat->read_play)
1691 return AVERROR_NOTSUPP;
1692 return s->iformat->read_play(s);
1696 * pause a network based stream (e.g. RTSP stream). Use av_read_play()
1699 int av_read_pause(AVFormatContext *s)
1701 if (!s->iformat->read_pause)
1702 return AVERROR_NOTSUPP;
1703 return s->iformat->read_pause(s);
1707 * Close a media file (but not its codecs)
1709 * @param s media file handle
1711 void av_close_input_file(AVFormatContext *s)
1713 int i, must_open_file;
1716 /* free previous packet */
1717 if (s->cur_st && s->cur_st->parser)
1718 av_free_packet(&s->cur_pkt);
1720 if (s->iformat->read_close)
1721 s->iformat->read_close(s);
1722 for(i=0;i<s->nb_streams;i++) {
1723 /* free all data in a stream component */
1726 av_parser_close(st->parser);
1728 av_free(st->index_entries);
1731 flush_packet_queue(s);
1733 if (s->iformat->flags & AVFMT_NOFILE) {
1736 if (must_open_file) {
1739 av_freep(&s->priv_data);
1744 * Add a new stream to a media file. Can only be called in the
1745 * read_header function. If the flag AVFMTCTX_NOHEADER is in the
1746 * format context, then new streams can be added in read_packet too.
1749 * @param s media file handle
1750 * @param id file format dependent stream id
1752 AVStream *av_new_stream(AVFormatContext *s, int id)
1756 if (s->nb_streams >= MAX_STREAMS)
1759 st = av_mallocz(sizeof(AVStream));
1762 avcodec_get_context_defaults(&st->codec);
1764 /* no default bitrate if decoding */
1765 st->codec.bit_rate = 0;
1767 st->index = s->nb_streams;
1769 st->start_time = AV_NOPTS_VALUE;
1770 st->duration = AV_NOPTS_VALUE;
1772 /* default pts settings is MPEG like */
1773 av_set_pts_info(st, 33, 1, 90000);
1774 st->last_pkt_pts = AV_NOPTS_VALUE;
1775 st->last_pkt_dts = AV_NOPTS_VALUE;
1776 st->last_pkt_stream_pts = AV_NOPTS_VALUE;
1777 st->last_pkt_stream_dts = AV_NOPTS_VALUE;
1779 s->streams[s->nb_streams++] = st;
1783 /************************************************************/
1784 /* output media file */
1786 int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
1790 if (s->oformat->priv_data_size > 0) {
1791 s->priv_data = av_mallocz(s->oformat->priv_data_size);
1793 return AVERROR_NOMEM;
1795 s->priv_data = NULL;
1797 if (s->oformat->set_parameters) {
1798 ret = s->oformat->set_parameters(s, ap);
1806 * allocate the stream private data and write the stream header to an
1809 * @param s media file handle
1810 * @return 0 if OK. AVERROR_xxx if error.
1812 int av_write_header(AVFormatContext *s)
1817 ret = s->oformat->write_header(s);
1821 /* init PTS generation */
1822 for(i=0;i<s->nb_streams;i++) {
1825 switch (st->codec.codec_type) {
1826 case CODEC_TYPE_AUDIO:
1827 av_frac_init(&st->pts, 0, 0,
1828 (int64_t)st->time_base.num * st->codec.sample_rate);
1830 case CODEC_TYPE_VIDEO:
1831 av_frac_init(&st->pts, 0, 0,
1832 (int64_t)st->time_base.num * st->codec.frame_rate);
1842 * Write a packet to an output media file. The packet shall contain
1843 * one audio or video frame.
1845 * @param s media file handle
1846 * @param stream_index stream index
1847 * @param buf buffer containing the frame data
1848 * @param size size of buffer
1849 * @return < 0 if error, = 0 if OK, 1 if end of stream wanted.
1851 int av_write_frame(AVFormatContext *s, int stream_index, const uint8_t *buf,
1856 int ret, frame_size;
1858 st = s->streams[stream_index];
1859 pts_mask = (1LL << st->pts_wrap_bits) - 1;
1861 /* HACK/FIXME we skip all zero size audio packets so a encoder can pass pts by outputing zero size packets */
1862 if(st->codec.codec_type==CODEC_TYPE_AUDIO && size==0)
1865 ret = s->oformat->write_packet(s, stream_index, buf, size,
1866 st->pts.val & pts_mask);
1872 switch (st->codec.codec_type) {
1873 case CODEC_TYPE_AUDIO:
1874 frame_size = get_audio_frame_size(&st->codec, size);
1876 /* HACK/FIXME, we skip the initial 0-size packets as they are most likely equal to the encoder delay,
1877 but it would be better if we had the real timestamps from the encoder */
1878 if (frame_size >= 0 && (size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
1879 av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
1882 case CODEC_TYPE_VIDEO:
1883 av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec.frame_rate_base);
1892 * write the stream trailer to an output media file and and free the
1893 * file private data.
1895 * @param s media file handle
1896 * @return 0 if OK. AVERROR_xxx if error. */
1897 int av_write_trailer(AVFormatContext *s)
1900 ret = s->oformat->write_trailer(s);
1901 av_freep(&s->priv_data);
1905 /* "user interface" functions */
1907 void dump_format(AVFormatContext *ic,
1915 av_log(NULL, AV_LOG_DEBUG, "%s #%d, %s, %s '%s':\n",
1916 is_output ? "Output" : "Input",
1918 is_output ? ic->oformat->name : ic->iformat->name,
1919 is_output ? "to" : "from", url);
1921 av_log(NULL, AV_LOG_DEBUG, " Duration: ");
1922 if (ic->duration != AV_NOPTS_VALUE) {
1923 int hours, mins, secs, us;
1924 secs = ic->duration / AV_TIME_BASE;
1925 us = ic->duration % AV_TIME_BASE;
1930 av_log(NULL, AV_LOG_DEBUG, "%02d:%02d:%02d.%01d", hours, mins, secs,
1931 (10 * us) / AV_TIME_BASE);
1933 av_log(NULL, AV_LOG_DEBUG, "N/A");
1935 av_log(NULL, AV_LOG_DEBUG, ", bitrate: ");
1937 av_log(NULL, AV_LOG_DEBUG,"%d kb/s", ic->bit_rate / 1000);
1939 av_log(NULL, AV_LOG_DEBUG, "N/A");
1941 av_log(NULL, AV_LOG_DEBUG, "\n");
1943 for(i=0;i<ic->nb_streams;i++) {
1944 AVStream *st = ic->streams[i];
1945 avcodec_string(buf, sizeof(buf), &st->codec, is_output);
1946 av_log(NULL, AV_LOG_DEBUG, " Stream #%d.%d", index, i);
1947 /* the pid is an important information, so we display it */
1948 /* XXX: add a generic system */
1950 flags = ic->oformat->flags;
1952 flags = ic->iformat->flags;
1953 if (flags & AVFMT_SHOW_IDS) {
1954 av_log(NULL, AV_LOG_DEBUG, "[0x%x]", st->id);
1956 av_log(NULL, AV_LOG_DEBUG, ": %s\n", buf);
1963 int frame_rate, frame_rate_base;
1966 static AbvEntry frame_abvs[] = {
1967 { "ntsc", 720, 480, 30000, 1001 },
1968 { "pal", 720, 576, 25, 1 },
1969 { "qntsc", 352, 240, 30000, 1001 }, /* VCD compliant ntsc */
1970 { "qpal", 352, 288, 25, 1 }, /* VCD compliant pal */
1971 { "sntsc", 640, 480, 30000, 1001 }, /* square pixel ntsc */
1972 { "spal", 768, 576, 25, 1 }, /* square pixel pal */
1973 { "film", 352, 240, 24, 1 },
1974 { "ntsc-film", 352, 240, 24000, 1001 },
1975 { "sqcif", 128, 96, 0, 0 },
1976 { "qcif", 176, 144, 0, 0 },
1977 { "cif", 352, 288, 0, 0 },
1978 { "4cif", 704, 576, 0, 0 },
1981 int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
1984 int n = sizeof(frame_abvs) / sizeof(AbvEntry);
1986 int frame_width = 0, frame_height = 0;
1989 if (!strcmp(frame_abvs[i].abv, str)) {
1990 frame_width = frame_abvs[i].width;
1991 frame_height = frame_abvs[i].height;
1997 frame_width = strtol(p, (char **)&p, 10);
2000 frame_height = strtol(p, (char **)&p, 10);
2002 if (frame_width <= 0 || frame_height <= 0)
2004 *width_ptr = frame_width;
2005 *height_ptr = frame_height;
2009 int parse_frame_rate(int *frame_rate, int *frame_rate_base, const char *arg)
2014 /* First, we check our abbreviation table */
2015 for (i = 0; i < sizeof(frame_abvs)/sizeof(*frame_abvs); ++i)
2016 if (!strcmp(frame_abvs[i].abv, arg)) {
2017 *frame_rate = frame_abvs[i].frame_rate;
2018 *frame_rate_base = frame_abvs[i].frame_rate_base;
2022 /* Then, we try to parse it as fraction */
2023 cp = strchr(arg, '/');
2026 *frame_rate = strtol(arg, &cpp, 10);
2027 if (cpp != arg || cpp == cp)
2028 *frame_rate_base = strtol(cp+1, &cpp, 10);
2033 /* Finally we give up and parse it as double */
2034 *frame_rate_base = DEFAULT_FRAME_RATE_BASE; //FIXME use av_d2q()
2035 *frame_rate = (int)(strtod(arg, 0) * (*frame_rate_base) + 0.5);
2037 if (!*frame_rate || !*frame_rate_base)
2044 * - If not a duration:
2045 * [{YYYY-MM-DD|YYYYMMDD}]{T| }{HH[:MM[:SS[.m...]]][Z]|HH[MM[SS[.m...]]][Z]}
2046 * Time is localtime unless Z is suffixed to the end. In this case GMT
2047 * Return the date in micro seconds since 1970
2049 * HH[:MM[:SS[.m...]]]
2052 int64_t parse_date(const char *datestr, int duration)
2058 static const char *date_fmt[] = {
2062 static const char *time_fmt[] = {
2071 time_t now = time(0);
2073 len = strlen(datestr);
2075 lastch = datestr[len - 1];
2078 is_utc = (lastch == 'z' || lastch == 'Z');
2080 memset(&dt, 0, sizeof(dt));
2085 for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
2086 q = small_strptime(p, date_fmt[i], &dt);
2096 dt = *localtime(&now);
2098 dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
2103 if (*p == 'T' || *p == 't' || *p == ' ')
2106 for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
2107 q = small_strptime(p, time_fmt[i], &dt);
2113 q = small_strptime(p, time_fmt[0], &dt);
2115 dt.tm_sec = strtol(p, (char **)&q, 10);
2121 /* Now we have all the fields that we can get */
2126 return now * int64_t_C(1000000);
2130 t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2132 dt.tm_isdst = -1; /* unknown */
2145 for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
2148 val += n * (*q - '0');
2155 /* syntax: '?tag1=val1&tag2=val2...'. Little URL decoding is done. Return
2157 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
2167 while (*p != '\0' && *p != '=' && *p != '&') {
2168 if ((q - tag) < sizeof(tag) - 1)
2176 while (*p != '&' && *p != '\0') {
2177 if ((q - arg) < arg_size - 1) {
2187 if (!strcmp(tag, tag1))
2196 /* Return in 'buf' the path with '%d' replaced by number. Also handles
2197 the '%0nd' format where 'n' is the total number of digits and
2198 '%%'. Return 0 if OK, and -1 if format error */
2199 int get_frame_filename(char *buf, int buf_size,
2200 const char *path, int number)
2203 char *q, buf1[20], c;
2204 int nd, len, percentd_found;
2216 while (isdigit(*p)) {
2217 nd = nd * 10 + *p++ - '0';
2220 } while (isdigit(c));
2229 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
2231 if ((q - buf + len) > buf_size - 1)
2233 memcpy(q, buf1, len);
2241 if ((q - buf) < buf_size - 1)
2245 if (!percentd_found)
2255 * Print nice hexa dump of a buffer
2256 * @param f stream for output
2258 * @param size buffer size
2260 void av_hex_dump(FILE *f, uint8_t *buf, int size)
2264 for(i=0;i<size;i+=16) {
2268 fprintf(f, "%08x ", i);
2271 fprintf(f, " %02x", buf[i+j]);
2276 for(j=0;j<len;j++) {
2278 if (c < ' ' || c > '~')
2280 fprintf(f, "%c", c);
2287 * Print on 'f' a nice dump of a packet
2288 * @param f stream for output
2289 * @param pkt packet to dump
2290 * @param dump_payload true if the payload must be displayed too
2292 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
2294 fprintf(f, "stream #%d:\n", pkt->stream_index);
2295 fprintf(f, " keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
2296 fprintf(f, " duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
2297 /* DTS is _always_ valid after av_read_frame() */
2298 fprintf(f, " dts=");
2299 if (pkt->dts == AV_NOPTS_VALUE)
2302 fprintf(f, "%0.3f", (double)pkt->dts / AV_TIME_BASE);
2303 /* PTS may be not known if B frames are present */
2304 fprintf(f, " pts=");
2305 if (pkt->pts == AV_NOPTS_VALUE)
2308 fprintf(f, "%0.3f", (double)pkt->pts / AV_TIME_BASE);
2310 fprintf(f, " size=%d\n", pkt->size);
2312 av_hex_dump(f, pkt->data, pkt->size);
2315 void url_split(char *proto, int proto_size,
2316 char *hostname, int hostname_size,
2318 char *path, int path_size,
2329 while (*p != ':' && *p != '\0') {
2330 if ((q - proto) < proto_size - 1)
2339 if (hostname_size > 0)
2349 while (*p != ':' && *p != '/' && *p != '?' && *p != '\0') {
2350 if ((q - hostname) < hostname_size - 1)
2354 if (hostname_size > 0)
2358 port = strtoul(p, (char **)&p, 10);
2363 pstrcpy(path, path_size, p);
2367 * Set the pts for a given stream
2369 * @param pts_wrap_bits number of bits effectively used by the pts
2370 * (used for wrap control, 33 is the value for MPEG)
2371 * @param pts_num numerator to convert to seconds (MPEG: 1)
2372 * @param pts_den denominator to convert to seconds (MPEG: 90000)
2374 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
2375 int pts_num, int pts_den)
2377 s->pts_wrap_bits = pts_wrap_bits;
2378 s->time_base.num = pts_num;
2379 s->time_base.den = pts_den;
2382 /* fraction handling */
2385 * f = val + (num / den) + 0.5. 'num' is normalized so that it is such
2386 * as 0 <= num < den.
2388 * @param f fractional number
2389 * @param val integer value
2390 * @param num must be >= 0
2391 * @param den must be >= 1
2393 void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
2405 /* set f to (val + 0.5) */
2406 void av_frac_set(AVFrac *f, int64_t val)
2409 f->num = f->den >> 1;
2413 * Fractionnal addition to f: f = f + (incr / f->den)
2415 * @param f fractional number
2416 * @param incr increment, can be positive or negative
2418 void av_frac_add(AVFrac *f, int64_t incr)
2422 num = f->num + incr;
2425 f->val += num / den;
2431 } else if (num >= den) {
2432 f->val += num / den;
2439 * register a new image format
2440 * @param img_fmt Image format descriptor
2442 void av_register_image_format(AVImageFormat *img_fmt)
2446 p = &first_image_format;
2447 while (*p != NULL) p = &(*p)->next;
2449 img_fmt->next = NULL;
2452 /* guess image format */
2453 AVImageFormat *av_probe_image_format(AVProbeData *pd)
2455 AVImageFormat *fmt1, *fmt;
2456 int score, score_max;
2460 for(fmt1 = first_image_format; fmt1 != NULL; fmt1 = fmt1->next) {
2461 if (fmt1->img_probe) {
2462 score = fmt1->img_probe(pd);
2463 if (score > score_max) {
2472 AVImageFormat *guess_image_format(const char *filename)
2474 AVImageFormat *fmt1;
2476 for(fmt1 = first_image_format; fmt1 != NULL; fmt1 = fmt1->next) {
2477 if (fmt1->extensions && match_ext(filename, fmt1->extensions))
2484 * Read an image from a stream.
2485 * @param gb byte stream containing the image
2486 * @param fmt image format, NULL if probing is required
2488 int av_read_image(ByteIOContext *pb, const char *filename,
2490 int (*alloc_cb)(void *, AVImageInfo *info), void *opaque)
2492 char buf[PROBE_BUF_SIZE];
2493 AVProbeData probe_data, *pd = &probe_data;
2498 pd->filename = filename;
2500 pos = url_ftell(pb);
2501 pd->buf_size = get_buffer(pb, buf, PROBE_BUF_SIZE);
2502 url_fseek(pb, pos, SEEK_SET);
2503 fmt = av_probe_image_format(pd);
2506 return AVERROR_NOFMT;
2507 ret = fmt->img_read(pb, alloc_cb, opaque);
2512 * Write an image to a stream.
2513 * @param pb byte stream for the image output
2514 * @param fmt image format
2515 * @param img image data and informations
2517 int av_write_image(ByteIOContext *pb, AVImageFormat *fmt, AVImageInfo *img)
2519 return fmt->img_write(pb, img);