* Moving FifoBuffer out of libavformat/avformat.h and
[ffmpeg.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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
18  */
19 #include "avformat.h"
20 #include "allformats.h"
21 #include "opt.h"
22
23 #undef NDEBUG
24 #include <assert.h>
25
26 /**
27  * @file libavformat/utils.c
28  * Various utility functions for using ffmpeg library.
29  */
30
31 static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den);
32 static void av_frac_add(AVFrac *f, int64_t incr);
33 static void av_frac_set(AVFrac *f, int64_t val);
34
35 /** head of registered input format linked list. */
36 AVInputFormat *first_iformat = NULL;
37 /** head of registered output format linked list. */
38 AVOutputFormat *first_oformat = NULL;
39 /** head of registered image format linked list. */
40 AVImageFormat *first_image_format = NULL;
41
42 void av_register_input_format(AVInputFormat *format)
43 {
44     AVInputFormat **p;
45     p = &first_iformat;
46     while (*p != NULL) p = &(*p)->next;
47     *p = format;
48     format->next = NULL;
49 }
50
51 void av_register_output_format(AVOutputFormat *format)
52 {
53     AVOutputFormat **p;
54     p = &first_oformat;
55     while (*p != NULL) p = &(*p)->next;
56     *p = format;
57     format->next = NULL;
58 }
59
60 int match_ext(const char *filename, const char *extensions)
61 {
62     const char *ext, *p;
63     char ext1[32], *q;
64
65     if(!filename)
66         return 0;
67
68     ext = strrchr(filename, '.');
69     if (ext) {
70         ext++;
71         p = extensions;
72         for(;;) {
73             q = ext1;
74             while (*p != '\0' && *p != ',' && q-ext1<sizeof(ext1)-1)
75                 *q++ = *p++;
76             *q = '\0';
77             if (!strcasecmp(ext1, ext))
78                 return 1;
79             if (*p == '\0')
80                 break;
81             p++;
82         }
83     }
84     return 0;
85 }
86
87 AVOutputFormat *guess_format(const char *short_name, const char *filename,
88                              const char *mime_type)
89 {
90     AVOutputFormat *fmt, *fmt_found;
91     int score_max, score;
92
93     /* specific test for image sequences */
94 #ifdef CONFIG_IMAGE2_MUXER
95     if (!short_name && filename &&
96         av_filename_number_test(filename) &&
97         av_guess_image2_codec(filename) != CODEC_ID_NONE) {
98         return guess_format("image2", NULL, NULL);
99     }
100 #endif
101     if (!short_name && filename &&
102         av_filename_number_test(filename) &&
103         guess_image_format(filename)) {
104         return guess_format("image", NULL, NULL);
105     }
106
107     /* find the proper file type */
108     fmt_found = NULL;
109     score_max = 0;
110     fmt = first_oformat;
111     while (fmt != NULL) {
112         score = 0;
113         if (fmt->name && short_name && !strcmp(fmt->name, short_name))
114             score += 100;
115         if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
116             score += 10;
117         if (filename && fmt->extensions &&
118             match_ext(filename, fmt->extensions)) {
119             score += 5;
120         }
121         if (score > score_max) {
122             score_max = score;
123             fmt_found = fmt;
124         }
125         fmt = fmt->next;
126     }
127     return fmt_found;
128 }
129
130 AVOutputFormat *guess_stream_format(const char *short_name, const char *filename,
131                              const char *mime_type)
132 {
133     AVOutputFormat *fmt = guess_format(short_name, filename, mime_type);
134
135     if (fmt) {
136         AVOutputFormat *stream_fmt;
137         char stream_format_name[64];
138
139         snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
140         stream_fmt = guess_format(stream_format_name, NULL, NULL);
141
142         if (stream_fmt)
143             fmt = stream_fmt;
144     }
145
146     return fmt;
147 }
148
149 /**
150  * Guesses the codec id based upon muxer and filename.
151  */
152 enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
153                             const char *filename, const char *mime_type, enum CodecType type){
154     if(type == CODEC_TYPE_VIDEO){
155         enum CodecID codec_id= CODEC_ID_NONE;
156
157 #ifdef CONFIG_IMAGE2_MUXER
158         if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
159             codec_id= av_guess_image2_codec(filename);
160         }
161 #endif
162         if(codec_id == CODEC_ID_NONE)
163             codec_id= fmt->video_codec;
164         return codec_id;
165     }else if(type == CODEC_TYPE_AUDIO)
166         return fmt->audio_codec;
167     else
168         return CODEC_ID_NONE;
169 }
170
171 /**
172  * finds AVInputFormat based on input format's short name.
173  */
174 AVInputFormat *av_find_input_format(const char *short_name)
175 {
176     AVInputFormat *fmt;
177     for(fmt = first_iformat; fmt != NULL; fmt = fmt->next) {
178         if (!strcmp(fmt->name, short_name))
179             return fmt;
180     }
181     return NULL;
182 }
183
184 /* memory handling */
185
186 /**
187  * Default packet destructor.
188  */
189 void av_destruct_packet(AVPacket *pkt)
190 {
191     av_free(pkt->data);
192     pkt->data = NULL; pkt->size = 0;
193 }
194
195 /**
196  * Allocate the payload of a packet and intialized its fields to default values.
197  *
198  * @param pkt packet
199  * @param size wanted payload size
200  * @return 0 if OK. AVERROR_xxx otherwise.
201  */
202 int av_new_packet(AVPacket *pkt, int size)
203 {
204     void *data;
205     if((unsigned)size > (unsigned)size + FF_INPUT_BUFFER_PADDING_SIZE)
206         return AVERROR_NOMEM;
207     data = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
208     if (!data)
209         return AVERROR_NOMEM;
210     memset(data + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
211
212     av_init_packet(pkt);
213     pkt->data = data;
214     pkt->size = size;
215     pkt->destruct = av_destruct_packet;
216     return 0;
217 }
218
219 /**
220  * Allocate and read the payload of a packet and intialized its fields to default values.
221  *
222  * @param pkt packet
223  * @param size wanted payload size
224  * @return >0 (read size) if OK. AVERROR_xxx otherwise.
225  */
226 int av_get_packet(ByteIOContext *s, AVPacket *pkt, int size)
227 {
228     int ret= av_new_packet(pkt, size);
229
230     if(ret<0)
231         return ret;
232
233     pkt->pos= url_ftell(s);
234
235     ret= get_buffer(s, pkt->data, size);
236     if(ret<=0)
237         av_free_packet(pkt);
238     else
239         pkt->size= ret;
240
241     return ret;
242 }
243
244 /* This is a hack - the packet memory allocation stuff is broken. The
245    packet is allocated if it was not really allocated */
246 int av_dup_packet(AVPacket *pkt)
247 {
248     if (pkt->destruct != av_destruct_packet) {
249         uint8_t *data;
250         /* we duplicate the packet and don't forget to put the padding
251            again */
252         if((unsigned)pkt->size > (unsigned)pkt->size + FF_INPUT_BUFFER_PADDING_SIZE)
253             return AVERROR_NOMEM;
254         data = av_malloc(pkt->size + FF_INPUT_BUFFER_PADDING_SIZE);
255         if (!data) {
256             return AVERROR_NOMEM;
257         }
258         memcpy(data, pkt->data, pkt->size);
259         memset(data + pkt->size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
260         pkt->data = data;
261         pkt->destruct = av_destruct_packet;
262     }
263     return 0;
264 }
265
266 /**
267  * Allocate the payload of a packet and intialized its fields to default values.
268  *
269  * @param filename possible numbered sequence string
270  * @return 1 if a valid numbered sequence string, 0 otherwise.
271  */
272 int av_filename_number_test(const char *filename)
273 {
274     char buf[1024];
275     return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
276 }
277
278 /**
279  * Guess file format.
280  */
281 AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened)
282 {
283     AVInputFormat *fmt1, *fmt;
284     int score, score_max;
285
286     fmt = NULL;
287     score_max = 0;
288     for(fmt1 = first_iformat; fmt1 != NULL; fmt1 = fmt1->next) {
289         if (!is_opened && !(fmt1->flags & AVFMT_NOFILE))
290             continue;
291         score = 0;
292         if (fmt1->read_probe) {
293             score = fmt1->read_probe(pd);
294         } else if (fmt1->extensions) {
295             if (match_ext(pd->filename, fmt1->extensions)) {
296                 score = 50;
297             }
298         }
299         if (score > score_max) {
300             score_max = score;
301             fmt = fmt1;
302         }
303     }
304     return fmt;
305 }
306
307 /************************************************************/
308 /* input media file */
309
310 /**
311  * Open a media file from an IO stream. 'fmt' must be specified.
312  */
313 static const char* format_to_name(void* ptr)
314 {
315     AVFormatContext* fc = (AVFormatContext*) ptr;
316     if(fc->iformat) return fc->iformat->name;
317     else if(fc->oformat) return fc->oformat->name;
318     else return "NULL";
319 }
320
321 #define OFFSET(x) offsetof(AVFormatContext,x)
322 #define DEFAULT 0 //should be NAN but it doesnt work as its not a constant in glibc as required by ANSI/ISO C
323 //these names are too long to be readable
324 #define E AV_OPT_FLAG_ENCODING_PARAM
325 #define D AV_OPT_FLAG_DECODING_PARAM
326
327 static const AVOption options[]={
328 {"probesize", NULL, OFFSET(probesize), FF_OPT_TYPE_INT, 32000, 32, INT_MAX, D}, /* 32000 from mpegts.c: 1.0 second at 24Mbit/s */
329 {"muxrate", "set mux rate", OFFSET(mux_rate), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
330 {"packetsize", "set packet size", OFFSET(packet_size), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
331 {"fflags", NULL, OFFSET(flags), FF_OPT_TYPE_FLAGS, DEFAULT, INT_MIN, INT_MAX, D, "fflags"},
332 {"ignidx", "ignore index", 0, FF_OPT_TYPE_CONST, AVFMT_FLAG_IGNIDX, INT_MIN, INT_MAX, D, "fflags"},
333 {"genpts", "generate pts", 0, FF_OPT_TYPE_CONST, AVFMT_FLAG_GENPTS, INT_MIN, INT_MAX, D, "fflags"},
334 {"track", " set the track number", OFFSET(track), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
335 {"year", "set the year", OFFSET(year), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, E},
336 {NULL},
337 };
338
339 #undef E
340 #undef D
341 #undef DEFAULT
342
343 static const AVClass av_format_context_class = { "AVFormatContext", format_to_name, options };
344
345 #if LIBAVCODEC_VERSION_INT > ((52<<16)+(0<<8)+0)
346 static
347 #endif
348 void avformat_get_context_defaults(AVFormatContext *s){
349     memset(s, 0, sizeof(AVFormatContext));
350
351     s->av_class = &av_format_context_class;
352
353     av_opt_set_defaults(s);
354 }
355
356 AVFormatContext *av_alloc_format_context(void)
357 {
358     AVFormatContext *ic;
359     ic = av_malloc(sizeof(AVFormatContext));
360     if (!ic) return ic;
361     avformat_get_context_defaults(ic);
362     ic->av_class = &av_format_context_class;
363     return ic;
364 }
365
366 /**
367  * Allocates all the structures needed to read an input stream.
368  *        This does not open the needed codecs for decoding the stream[s].
369  */
370 int av_open_input_stream(AVFormatContext **ic_ptr,
371                          ByteIOContext *pb, const char *filename,
372                          AVInputFormat *fmt, AVFormatParameters *ap)
373 {
374     int err;
375     AVFormatContext *ic;
376     AVFormatParameters default_ap;
377
378     if(!ap){
379         ap=&default_ap;
380         memset(ap, 0, sizeof(default_ap));
381     }
382
383     if(!ap->prealloced_context)
384         ic = av_alloc_format_context();
385     else
386         ic = *ic_ptr;
387     if (!ic) {
388         err = AVERROR_NOMEM;
389         goto fail;
390     }
391     ic->iformat = fmt;
392     if (pb)
393         ic->pb = *pb;
394     ic->duration = AV_NOPTS_VALUE;
395     ic->start_time = AV_NOPTS_VALUE;
396     pstrcpy(ic->filename, sizeof(ic->filename), filename);
397
398     /* allocate private data */
399     if (fmt->priv_data_size > 0) {
400         ic->priv_data = av_mallocz(fmt->priv_data_size);
401         if (!ic->priv_data) {
402             err = AVERROR_NOMEM;
403             goto fail;
404         }
405     } else {
406         ic->priv_data = NULL;
407     }
408
409     err = ic->iformat->read_header(ic, ap);
410     if (err < 0)
411         goto fail;
412
413     if (pb)
414         ic->data_offset = url_ftell(&ic->pb);
415
416     *ic_ptr = ic;
417     return 0;
418  fail:
419     if (ic) {
420         av_freep(&ic->priv_data);
421     }
422     av_free(ic);
423     *ic_ptr = NULL;
424     return err;
425 }
426
427 /** Size of probe buffer, for guessing file type from file contents. */
428 #define PROBE_BUF_MIN 2048
429 #define PROBE_BUF_MAX (1<<20)
430
431 /**
432  * Open a media file as input. The codec are not opened. Only the file
433  * header (if present) is read.
434  *
435  * @param ic_ptr the opened media file handle is put here
436  * @param filename filename to open.
437  * @param fmt if non NULL, force the file format to use
438  * @param buf_size optional buffer size (zero if default is OK)
439  * @param ap additionnal parameters needed when opening the file (NULL if default)
440  * @return 0 if OK. AVERROR_xxx otherwise.
441  */
442 int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
443                        AVInputFormat *fmt,
444                        int buf_size,
445                        AVFormatParameters *ap)
446 {
447     int err, must_open_file, file_opened, probe_size;
448     AVProbeData probe_data, *pd = &probe_data;
449     ByteIOContext pb1, *pb = &pb1;
450
451     file_opened = 0;
452     pd->filename = "";
453     if (filename)
454         pd->filename = filename;
455     pd->buf = NULL;
456     pd->buf_size = 0;
457
458     if (!fmt) {
459         /* guess format if no file can be opened  */
460         fmt = av_probe_input_format(pd, 0);
461     }
462
463     /* do not open file if the format does not need it. XXX: specific
464        hack needed to handle RTSP/TCP */
465     must_open_file = 1;
466     if (fmt && (fmt->flags & AVFMT_NOFILE)) {
467         must_open_file = 0;
468         pb= NULL; //FIXME this or memset(pb, 0, sizeof(ByteIOContext)); otherwise its uninitalized
469     }
470
471     if (!fmt || must_open_file) {
472         /* if no file needed do not try to open one */
473         if (url_fopen(pb, filename, URL_RDONLY) < 0) {
474             err = AVERROR_IO;
475             goto fail;
476         }
477         file_opened = 1;
478         if (buf_size > 0) {
479             url_setbufsize(pb, buf_size);
480         }
481
482         for(probe_size= PROBE_BUF_MIN; probe_size<=PROBE_BUF_MAX && !fmt; probe_size<<=1){
483             /* read probe data */
484             pd->buf= av_realloc(pd->buf, probe_size);
485             pd->buf_size = get_buffer(pb, pd->buf, probe_size);
486             if (url_fseek(pb, 0, SEEK_SET) == (offset_t)-EPIPE) {
487                 url_fclose(pb);
488                 if (url_fopen(pb, filename, URL_RDONLY) < 0) {
489                     file_opened = 0;
490                     err = AVERROR_IO;
491                     goto fail;
492                 }
493             }
494             /* guess file format */
495             fmt = av_probe_input_format(pd, 1);
496         }
497         av_freep(&pd->buf);
498     }
499
500     /* if still no format found, error */
501     if (!fmt) {
502         err = AVERROR_NOFMT;
503         goto fail;
504     }
505
506     /* XXX: suppress this hack for redirectors */
507 #ifdef CONFIG_NETWORK
508     if (fmt == &redir_demuxer) {
509         err = redir_open(ic_ptr, pb);
510         url_fclose(pb);
511         return err;
512     }
513 #endif
514
515     /* check filename in case of an image number is expected */
516     if (fmt->flags & AVFMT_NEEDNUMBER) {
517         if (!av_filename_number_test(filename)) {
518             err = AVERROR_NUMEXPECTED;
519             goto fail;
520         }
521     }
522     err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
523     if (err)
524         goto fail;
525     return 0;
526  fail:
527     av_freep(&pd->buf);
528     if (file_opened)
529         url_fclose(pb);
530     *ic_ptr = NULL;
531     return err;
532
533 }
534
535 /*******************************************************/
536
537 /**
538  * Read a transport packet from a media file.
539  *
540  * This function is absolete and should never be used.
541  * Use av_read_frame() instead.
542  *
543  * @param s media file handle
544  * @param pkt is filled
545  * @return 0 if OK. AVERROR_xxx if error.
546  */
547 int av_read_packet(AVFormatContext *s, AVPacket *pkt)
548 {
549     return s->iformat->read_packet(s, pkt);
550 }
551
552 /**********************************************************/
553
554 /**
555  * Get the number of samples of an audio frame. Return (-1) if error.
556  */
557 static int get_audio_frame_size(AVCodecContext *enc, int size)
558 {
559     int frame_size;
560
561     if (enc->frame_size <= 1) {
562         int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
563
564         if (bits_per_sample) {
565             if (enc->channels == 0)
566                 return -1;
567             frame_size = (size << 3) / (bits_per_sample * enc->channels);
568         } else {
569             /* used for example by ADPCM codecs */
570             if (enc->bit_rate == 0)
571                 return -1;
572             frame_size = (size * 8 * enc->sample_rate) / enc->bit_rate;
573         }
574     } else {
575         frame_size = enc->frame_size;
576     }
577     return frame_size;
578 }
579
580
581 /**
582  * Return the frame duration in seconds, return 0 if not available.
583  */
584 static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
585                                    AVCodecParserContext *pc, AVPacket *pkt)
586 {
587     int frame_size;
588
589     *pnum = 0;
590     *pden = 0;
591     switch(st->codec->codec_type) {
592     case CODEC_TYPE_VIDEO:
593         if(st->time_base.num*1000LL > st->time_base.den){
594             *pnum = st->time_base.num;
595             *pden = st->time_base.den;
596         }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
597             *pnum = st->codec->time_base.num;
598             *pden = st->codec->time_base.den;
599             if (pc && pc->repeat_pict) {
600                 *pden *= 2;
601                 *pnum = (*pnum) * (2 + pc->repeat_pict);
602             }
603         }
604         break;
605     case CODEC_TYPE_AUDIO:
606         frame_size = get_audio_frame_size(st->codec, pkt->size);
607         if (frame_size < 0)
608             break;
609         *pnum = frame_size;
610         *pden = st->codec->sample_rate;
611         break;
612     default:
613         break;
614     }
615 }
616
617 static int is_intra_only(AVCodecContext *enc){
618     if(enc->codec_type == CODEC_TYPE_AUDIO){
619         return 1;
620     }else if(enc->codec_type == CODEC_TYPE_VIDEO){
621         switch(enc->codec_id){
622         case CODEC_ID_MJPEG:
623         case CODEC_ID_MJPEGB:
624         case CODEC_ID_LJPEG:
625         case CODEC_ID_RAWVIDEO:
626         case CODEC_ID_DVVIDEO:
627         case CODEC_ID_HUFFYUV:
628         case CODEC_ID_FFVHUFF:
629         case CODEC_ID_ASV1:
630         case CODEC_ID_ASV2:
631         case CODEC_ID_VCR1:
632             return 1;
633         default: break;
634         }
635     }
636     return 0;
637 }
638
639 static int64_t lsb2full(int64_t lsb, int64_t last_ts, int lsb_bits){
640     int64_t mask = lsb_bits < 64 ? (1LL<<lsb_bits)-1 : -1LL;
641     int64_t delta= last_ts - mask/2;
642     return  ((lsb - delta)&mask) + delta;
643 }
644
645 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
646                                AVCodecParserContext *pc, AVPacket *pkt)
647 {
648     int num, den, presentation_delayed;
649     /* handle wrapping */
650     if(st->cur_dts != AV_NOPTS_VALUE){
651         if(pkt->pts != AV_NOPTS_VALUE)
652             pkt->pts= lsb2full(pkt->pts, st->cur_dts, st->pts_wrap_bits);
653         if(pkt->dts != AV_NOPTS_VALUE)
654             pkt->dts= lsb2full(pkt->dts, st->cur_dts, st->pts_wrap_bits);
655     }
656
657     if (pkt->duration == 0) {
658         compute_frame_duration(&num, &den, st, pc, pkt);
659         if (den && num) {
660             pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
661         }
662     }
663
664     if(is_intra_only(st->codec))
665         pkt->flags |= PKT_FLAG_KEY;
666
667     /* do we have a video B frame ? */
668     presentation_delayed = 0;
669     if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
670         /* XXX: need has_b_frame, but cannot get it if the codec is
671            not initialized */
672         if ((   st->codec->codec_id == CODEC_ID_H264
673              || st->codec->has_b_frames) &&
674             pc && pc->pict_type != FF_B_TYPE)
675             presentation_delayed = 1;
676         /* this may be redundant, but it shouldnt hurt */
677         if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
678             presentation_delayed = 1;
679     }
680
681     if(st->cur_dts == AV_NOPTS_VALUE){
682         if(presentation_delayed) st->cur_dts = -pkt->duration;
683         else                     st->cur_dts = 0;
684     }
685
686 //    av_log(NULL, AV_LOG_DEBUG, "IN delayed:%d pts:%lld, dts:%lld cur_dts:%lld st:%d pc:%p\n", presentation_delayed, pkt->pts, pkt->dts, st->cur_dts, pkt->stream_index, pc);
687     /* interpolate PTS and DTS if they are not present */
688     if (presentation_delayed) {
689         /* DTS = decompression time stamp */
690         /* PTS = presentation time stamp */
691         if (pkt->dts == AV_NOPTS_VALUE) {
692             /* if we know the last pts, use it */
693             if(st->last_IP_pts != AV_NOPTS_VALUE)
694                 st->cur_dts = pkt->dts = st->last_IP_pts;
695             else
696                 pkt->dts = st->cur_dts;
697         } else {
698             st->cur_dts = pkt->dts;
699         }
700         /* this is tricky: the dts must be incremented by the duration
701            of the frame we are displaying, i.e. the last I or P frame */
702         if (st->last_IP_duration == 0)
703             st->cur_dts += pkt->duration;
704         else
705             st->cur_dts += st->last_IP_duration;
706         st->last_IP_duration  = pkt->duration;
707         st->last_IP_pts= pkt->pts;
708         /* cannot compute PTS if not present (we can compute it only
709            by knowing the futur */
710     } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
711         if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
712             int64_t old_diff= ABS(st->cur_dts - pkt->duration - pkt->pts);
713             int64_t new_diff= ABS(st->cur_dts - pkt->pts);
714             if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
715                 pkt->pts += pkt->duration;
716 //                av_log(NULL, AV_LOG_DEBUG, "id:%d old:%Ld new:%Ld dur:%d cur:%Ld size:%d\n", pkt->stream_index, old_diff, new_diff, pkt->duration, st->cur_dts, pkt->size);
717             }
718         }
719
720         /* presentation is not delayed : PTS and DTS are the same */
721         if (pkt->pts == AV_NOPTS_VALUE) {
722             if (pkt->dts == AV_NOPTS_VALUE) {
723                 pkt->pts = st->cur_dts;
724                 pkt->dts = st->cur_dts;
725             }
726             else {
727                 st->cur_dts = pkt->dts;
728                 pkt->pts = pkt->dts;
729             }
730         } else {
731             st->cur_dts = pkt->pts;
732             pkt->dts = pkt->pts;
733         }
734         st->cur_dts += pkt->duration;
735     }
736 //    av_log(NULL, AV_LOG_DEBUG, "OUTdelayed:%d pts:%lld, dts:%lld cur_dts:%lld\n", presentation_delayed, pkt->pts, pkt->dts, st->cur_dts);
737
738     /* update flags */
739     if (pc) {
740         pkt->flags = 0;
741         /* key frame computation */
742         switch(st->codec->codec_type) {
743         case CODEC_TYPE_VIDEO:
744             if (pc->pict_type == FF_I_TYPE)
745                 pkt->flags |= PKT_FLAG_KEY;
746             break;
747         case CODEC_TYPE_AUDIO:
748             pkt->flags |= PKT_FLAG_KEY;
749             break;
750         default:
751             break;
752         }
753     }
754 }
755
756 void av_destruct_packet_nofree(AVPacket *pkt)
757 {
758     pkt->data = NULL; pkt->size = 0;
759 }
760
761 static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
762 {
763     AVStream *st;
764     int len, ret, i;
765
766     for(;;) {
767         /* select current input stream component */
768         st = s->cur_st;
769         if (st) {
770             if (!st->need_parsing || !st->parser) {
771                 /* no parsing needed: we just output the packet as is */
772                 /* raw data support */
773                 *pkt = s->cur_pkt;
774                 compute_pkt_fields(s, st, NULL, pkt);
775                 s->cur_st = NULL;
776                 break;
777             } else if (s->cur_len > 0 && st->discard < AVDISCARD_ALL) {
778                 len = av_parser_parse(st->parser, st->codec, &pkt->data, &pkt->size,
779                                       s->cur_ptr, s->cur_len,
780                                       s->cur_pkt.pts, s->cur_pkt.dts);
781                 s->cur_pkt.pts = AV_NOPTS_VALUE;
782                 s->cur_pkt.dts = AV_NOPTS_VALUE;
783                 /* increment read pointer */
784                 s->cur_ptr += len;
785                 s->cur_len -= len;
786
787                 /* return packet if any */
788                 if (pkt->size) {
789                 got_packet:
790                     pkt->duration = 0;
791                     pkt->stream_index = st->index;
792                     pkt->pts = st->parser->pts;
793                     pkt->dts = st->parser->dts;
794                     pkt->destruct = av_destruct_packet_nofree;
795                     compute_pkt_fields(s, st, st->parser, pkt);
796                     break;
797                 }
798             } else {
799                 /* free packet */
800                 av_free_packet(&s->cur_pkt);
801                 s->cur_st = NULL;
802             }
803         } else {
804             /* read next packet */
805             ret = av_read_packet(s, &s->cur_pkt);
806             if (ret < 0) {
807                 if (ret == -EAGAIN)
808                     return ret;
809                 /* return the last frames, if any */
810                 for(i = 0; i < s->nb_streams; i++) {
811                     st = s->streams[i];
812                     if (st->parser && st->need_parsing) {
813                         av_parser_parse(st->parser, st->codec,
814                                         &pkt->data, &pkt->size,
815                                         NULL, 0,
816                                         AV_NOPTS_VALUE, AV_NOPTS_VALUE);
817                         if (pkt->size)
818                             goto got_packet;
819                     }
820                 }
821                 /* no more packets: really terminates parsing */
822                 return ret;
823             }
824
825             st = s->streams[s->cur_pkt.stream_index];
826             if(st->codec->debug & FF_DEBUG_PTS)
827                 av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%lld, dts=%lld, size=%d\n",
828                     s->cur_pkt.stream_index,
829                     s->cur_pkt.pts,
830                     s->cur_pkt.dts,
831                     s->cur_pkt.size);
832
833             s->cur_st = st;
834             s->cur_ptr = s->cur_pkt.data;
835             s->cur_len = s->cur_pkt.size;
836             if (st->need_parsing && !st->parser) {
837                 st->parser = av_parser_init(st->codec->codec_id);
838                 if (!st->parser) {
839                     /* no parser available : just output the raw packets */
840                     st->need_parsing = 0;
841                 }else if(st->need_parsing == 2){
842                     st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
843                 }
844             }
845         }
846     }
847     if(st->codec->debug & FF_DEBUG_PTS)
848         av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%lld, dts=%lld, size=%d\n",
849             pkt->stream_index,
850             pkt->pts,
851             pkt->dts,
852             pkt->size);
853
854     return 0;
855 }
856
857 /**
858  * Return the next frame of a stream.
859  *
860  * The returned packet is valid
861  * until the next av_read_frame() or until av_close_input_file() and
862  * must be freed with av_free_packet. For video, the packet contains
863  * exactly one frame. For audio, it contains an integer number of
864  * frames if each frame has a known fixed size (e.g. PCM or ADPCM
865  * data). If the audio frames have a variable size (e.g. MPEG audio),
866  * then it contains one frame.
867  *
868  * pkt->pts, pkt->dts and pkt->duration are always set to correct
869  * values in AV_TIME_BASE unit (and guessed if the format cannot
870  * provided them). pkt->pts can be AV_NOPTS_VALUE if the video format
871  * has B frames, so it is better to rely on pkt->dts if you do not
872  * decompress the payload.
873  *
874  * @return 0 if OK, < 0 if error or end of file.
875  */
876 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
877 {
878     AVPacketList *pktl;
879     int eof=0;
880     const int genpts= s->flags & AVFMT_FLAG_GENPTS;
881
882     for(;;){
883         pktl = s->packet_buffer;
884         if (pktl) {
885             AVPacket *next_pkt= &pktl->pkt;
886
887             if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
888                 while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
889                     if(   pktl->pkt.stream_index == next_pkt->stream_index
890                        && next_pkt->dts < pktl->pkt.dts
891                        && pktl->pkt.pts != pktl->pkt.dts //not b frame
892                        /*&& pktl->pkt.dts != AV_NOPTS_VALUE*/){
893                         next_pkt->pts= pktl->pkt.dts;
894                     }
895                     pktl= pktl->next;
896                 }
897                 pktl = s->packet_buffer;
898             }
899
900             if(   next_pkt->pts != AV_NOPTS_VALUE
901                || next_pkt->dts == AV_NOPTS_VALUE
902                || !genpts || eof){
903                 /* read packet from packet buffer, if there is data */
904                 *pkt = *next_pkt;
905                 s->packet_buffer = pktl->next;
906                 av_free(pktl);
907                 return 0;
908             }
909         }
910         if(genpts){
911             AVPacketList **plast_pktl= &s->packet_buffer;
912             int ret= av_read_frame_internal(s, pkt);
913             if(ret<0){
914                 if(pktl && ret != -EAGAIN){
915                     eof=1;
916                     continue;
917                 }else
918                     return ret;
919             }
920
921             /* duplicate the packet */
922             if (av_dup_packet(pkt) < 0)
923                 return AVERROR_NOMEM;
924
925             while(*plast_pktl) plast_pktl= &(*plast_pktl)->next; //FIXME maybe maintain pointer to the last?
926
927             pktl = av_mallocz(sizeof(AVPacketList));
928             if (!pktl)
929                 return AVERROR_NOMEM;
930
931             /* add the packet in the buffered packet list */
932             *plast_pktl = pktl;
933             pktl->pkt= *pkt;
934         }else{
935             assert(!s->packet_buffer);
936             return av_read_frame_internal(s, pkt);
937         }
938     }
939 }
940
941 /* XXX: suppress the packet queue */
942 static void flush_packet_queue(AVFormatContext *s)
943 {
944     AVPacketList *pktl;
945
946     for(;;) {
947         pktl = s->packet_buffer;
948         if (!pktl)
949             break;
950         s->packet_buffer = pktl->next;
951         av_free_packet(&pktl->pkt);
952         av_free(pktl);
953     }
954 }
955
956 /*******************************************************/
957 /* seek support */
958
959 int av_find_default_stream_index(AVFormatContext *s)
960 {
961     int i;
962     AVStream *st;
963
964     if (s->nb_streams <= 0)
965         return -1;
966     for(i = 0; i < s->nb_streams; i++) {
967         st = s->streams[i];
968         if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
969             return i;
970         }
971     }
972     return 0;
973 }
974
975 /**
976  * Flush the frame reader.
977  */
978 static void av_read_frame_flush(AVFormatContext *s)
979 {
980     AVStream *st;
981     int i;
982
983     flush_packet_queue(s);
984
985     /* free previous packet */
986     if (s->cur_st) {
987         if (s->cur_st->parser)
988             av_free_packet(&s->cur_pkt);
989         s->cur_st = NULL;
990     }
991     /* fail safe */
992     s->cur_ptr = NULL;
993     s->cur_len = 0;
994
995     /* for each stream, reset read state */
996     for(i = 0; i < s->nb_streams; i++) {
997         st = s->streams[i];
998
999         if (st->parser) {
1000             av_parser_close(st->parser);
1001             st->parser = NULL;
1002         }
1003         st->last_IP_pts = AV_NOPTS_VALUE;
1004         st->cur_dts = 0; /* we set the current DTS to an unspecified origin */
1005     }
1006 }
1007
1008 /**
1009  * Updates cur_dts of all streams based on given timestamp and AVStream.
1010  *
1011  * Stream ref_st unchanged, others set cur_dts in their native timebase
1012  * only needed for timestamp wrapping or if (dts not set and pts!=dts)
1013  * @param timestamp new dts expressed in time_base of param ref_st
1014  * @param ref_st reference stream giving time_base of param timestamp
1015  */
1016 void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1017     int i;
1018
1019     for(i = 0; i < s->nb_streams; i++) {
1020         AVStream *st = s->streams[i];
1021
1022         st->cur_dts = av_rescale(timestamp,
1023                                  st->time_base.den * (int64_t)ref_st->time_base.num,
1024                                  st->time_base.num * (int64_t)ref_st->time_base.den);
1025     }
1026 }
1027
1028 /**
1029  * Add a index entry into a sorted list updateing if it is already there.
1030  *
1031  * @param timestamp timestamp in the timebase of the given stream
1032  */
1033 int av_add_index_entry(AVStream *st,
1034                             int64_t pos, int64_t timestamp, int size, int distance, int flags)
1035 {
1036     AVIndexEntry *entries, *ie;
1037     int index;
1038
1039     if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1040         return -1;
1041
1042     entries = av_fast_realloc(st->index_entries,
1043                               &st->index_entries_allocated_size,
1044                               (st->nb_index_entries + 1) *
1045                               sizeof(AVIndexEntry));
1046     if(!entries)
1047         return -1;
1048
1049     st->index_entries= entries;
1050
1051     index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
1052
1053     if(index<0){
1054         index= st->nb_index_entries++;
1055         ie= &entries[index];
1056         assert(index==0 || ie[-1].timestamp < timestamp);
1057     }else{
1058         ie= &entries[index];
1059         if(ie->timestamp != timestamp){
1060             if(ie->timestamp <= timestamp)
1061                 return -1;
1062             memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
1063             st->nb_index_entries++;
1064         }else if(ie->pos == pos && distance < ie->min_distance) //dont reduce the distance
1065             distance= ie->min_distance;
1066     }
1067
1068     ie->pos = pos;
1069     ie->timestamp = timestamp;
1070     ie->min_distance= distance;
1071     ie->size= size;
1072     ie->flags = flags;
1073
1074     return index;
1075 }
1076
1077 /**
1078  * build an index for raw streams using a parser.
1079  */
1080 static void av_build_index_raw(AVFormatContext *s)
1081 {
1082     AVPacket pkt1, *pkt = &pkt1;
1083     int ret;
1084     AVStream *st;
1085
1086     st = s->streams[0];
1087     av_read_frame_flush(s);
1088     url_fseek(&s->pb, s->data_offset, SEEK_SET);
1089
1090     for(;;) {
1091         ret = av_read_frame(s, pkt);
1092         if (ret < 0)
1093             break;
1094         if (pkt->stream_index == 0 && st->parser &&
1095             (pkt->flags & PKT_FLAG_KEY)) {
1096             av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
1097                             0, 0, AVINDEX_KEYFRAME);
1098         }
1099         av_free_packet(pkt);
1100     }
1101 }
1102
1103 /**
1104  * Returns TRUE if we deal with a raw stream.
1105  *
1106  * Raw codec data and parsing needed.
1107  */
1108 static int is_raw_stream(AVFormatContext *s)
1109 {
1110     AVStream *st;
1111
1112     if (s->nb_streams != 1)
1113         return 0;
1114     st = s->streams[0];
1115     if (!st->need_parsing)
1116         return 0;
1117     return 1;
1118 }
1119
1120 /**
1121  * Gets the index for a specific timestamp.
1122  * @param flags if AVSEEK_FLAG_BACKWARD then the returned index will correspond to
1123  *                 the timestamp which is <= the requested one, if backward is 0
1124  *                 then it will be >=
1125  *              if AVSEEK_FLAG_ANY seek to any frame, only keyframes otherwise
1126  * @return < 0 if no such timestamp could be found
1127  */
1128 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1129                               int flags)
1130 {
1131     AVIndexEntry *entries= st->index_entries;
1132     int nb_entries= st->nb_index_entries;
1133     int a, b, m;
1134     int64_t timestamp;
1135
1136     a = - 1;
1137     b = nb_entries;
1138
1139     while (b - a > 1) {
1140         m = (a + b) >> 1;
1141         timestamp = entries[m].timestamp;
1142         if(timestamp >= wanted_timestamp)
1143             b = m;
1144         if(timestamp <= wanted_timestamp)
1145             a = m;
1146     }
1147     m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1148
1149     if(!(flags & AVSEEK_FLAG_ANY)){
1150         while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1151             m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1152         }
1153     }
1154
1155     if(m == nb_entries)
1156         return -1;
1157     return  m;
1158 }
1159
1160 #define DEBUG_SEEK
1161
1162 /**
1163  * Does a binary search using av_index_search_timestamp() and AVCodec.read_timestamp().
1164  * this isnt supposed to be called directly by a user application, but by demuxers
1165  * @param target_ts target timestamp in the time base of the given stream
1166  * @param stream_index stream number
1167  */
1168 int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1169     AVInputFormat *avif= s->iformat;
1170     int64_t pos_min, pos_max, pos, pos_limit;
1171     int64_t ts_min, ts_max, ts;
1172     int64_t start_pos, filesize;
1173     int index, no_change;
1174     AVStream *st;
1175
1176     if (stream_index < 0)
1177         return -1;
1178
1179 #ifdef DEBUG_SEEK
1180     av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1181 #endif
1182
1183     ts_max=
1184     ts_min= AV_NOPTS_VALUE;
1185     pos_limit= -1; //gcc falsely says it may be uninitalized
1186
1187     st= s->streams[stream_index];
1188     if(st->index_entries){
1189         AVIndexEntry *e;
1190
1191         index= av_index_search_timestamp(st, target_ts, flags | AVSEEK_FLAG_BACKWARD); //FIXME whole func must be checked for non keyframe entries in index case, especially read_timestamp()
1192         index= FFMAX(index, 0);
1193         e= &st->index_entries[index];
1194
1195         if(e->timestamp <= target_ts || e->pos == e->min_distance){
1196             pos_min= e->pos;
1197             ts_min= e->timestamp;
1198 #ifdef DEBUG_SEEK
1199         av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1200                pos_min,ts_min);
1201 #endif
1202         }else{
1203             assert(index==0);
1204         }
1205
1206         index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1207         assert(index < st->nb_index_entries);
1208         if(index >= 0){
1209             e= &st->index_entries[index];
1210             assert(e->timestamp >= target_ts);
1211             pos_max= e->pos;
1212             ts_max= e->timestamp;
1213             pos_limit= pos_max - e->min_distance;
1214 #ifdef DEBUG_SEEK
1215         av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1216                pos_max,pos_limit, ts_max);
1217 #endif
1218         }
1219     }
1220
1221     if(ts_min == AV_NOPTS_VALUE){
1222         pos_min = s->data_offset;
1223         ts_min = avif->read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1224         if (ts_min == AV_NOPTS_VALUE)
1225             return -1;
1226     }
1227
1228     if(ts_max == AV_NOPTS_VALUE){
1229         int step= 1024;
1230         filesize = url_fsize(&s->pb);
1231         pos_max = filesize - 1;
1232         do{
1233             pos_max -= step;
1234             ts_max = avif->read_timestamp(s, stream_index, &pos_max, pos_max + step);
1235             step += step;
1236         }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1237         if (ts_max == AV_NOPTS_VALUE)
1238             return -1;
1239
1240         for(;;){
1241             int64_t tmp_pos= pos_max + 1;
1242             int64_t tmp_ts= avif->read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1243             if(tmp_ts == AV_NOPTS_VALUE)
1244                 break;
1245             ts_max= tmp_ts;
1246             pos_max= tmp_pos;
1247             if(tmp_pos >= filesize)
1248                 break;
1249         }
1250         pos_limit= pos_max;
1251     }
1252
1253     if(ts_min > ts_max){
1254         return -1;
1255     }else if(ts_min == ts_max){
1256         pos_limit= pos_min;
1257     }
1258
1259     no_change=0;
1260     while (pos_min < pos_limit) {
1261 #ifdef DEBUG_SEEK
1262         av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1263                pos_min, pos_max,
1264                ts_min, ts_max);
1265 #endif
1266         assert(pos_limit <= pos_max);
1267
1268         if(no_change==0){
1269             int64_t approximate_keyframe_distance= pos_max - pos_limit;
1270             // interpolate position (better than dichotomy)
1271             pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1272                 + pos_min - approximate_keyframe_distance;
1273         }else if(no_change==1){
1274             // bisection, if interpolation failed to change min or max pos last time
1275             pos = (pos_min + pos_limit)>>1;
1276         }else{
1277             // linear search if bisection failed, can only happen if there are very few or no keframes between min/max
1278             pos=pos_min;
1279         }
1280         if(pos <= pos_min)
1281             pos= pos_min + 1;
1282         else if(pos > pos_limit)
1283             pos= pos_limit;
1284         start_pos= pos;
1285
1286         ts = avif->read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1287         if(pos == pos_max)
1288             no_change++;
1289         else
1290             no_change=0;
1291 #ifdef DEBUG_SEEK
1292 av_log(s, AV_LOG_DEBUG, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64" target:%"PRId64" limit:%"PRId64" start:%"PRId64" noc:%d\n", pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts, pos_limit, start_pos, no_change);
1293 #endif
1294         assert(ts != AV_NOPTS_VALUE);
1295         if (target_ts <= ts) {
1296             pos_limit = start_pos - 1;
1297             pos_max = pos;
1298             ts_max = ts;
1299         }
1300         if (target_ts >= ts) {
1301             pos_min = pos;
1302             ts_min = ts;
1303         }
1304     }
1305
1306     pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1307     ts  = (flags & AVSEEK_FLAG_BACKWARD) ?  ts_min :  ts_max;
1308 #ifdef DEBUG_SEEK
1309     pos_min = pos;
1310     ts_min = avif->read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1311     pos_min++;
1312     ts_max = avif->read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1313     av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1314            pos, ts_min, target_ts, ts_max);
1315 #endif
1316     /* do the seek */
1317     url_fseek(&s->pb, pos, SEEK_SET);
1318
1319     av_update_cur_dts(s, st, ts);
1320
1321     return 0;
1322 }
1323
1324 static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1325     int64_t pos_min, pos_max;
1326 #if 0
1327     AVStream *st;
1328
1329     if (stream_index < 0)
1330         return -1;
1331
1332     st= s->streams[stream_index];
1333 #endif
1334
1335     pos_min = s->data_offset;
1336     pos_max = url_fsize(&s->pb) - 1;
1337
1338     if     (pos < pos_min) pos= pos_min;
1339     else if(pos > pos_max) pos= pos_max;
1340
1341     url_fseek(&s->pb, pos, SEEK_SET);
1342
1343 #if 0
1344     av_update_cur_dts(s, st, ts);
1345 #endif
1346     return 0;
1347 }
1348
1349 static int av_seek_frame_generic(AVFormatContext *s,
1350                                  int stream_index, int64_t timestamp, int flags)
1351 {
1352     int index;
1353     AVStream *st;
1354     AVIndexEntry *ie;
1355
1356     if (!s->index_built) {
1357         if (is_raw_stream(s)) {
1358             av_build_index_raw(s);
1359         } else {
1360             return -1;
1361         }
1362         s->index_built = 1;
1363     }
1364
1365     st = s->streams[stream_index];
1366     index = av_index_search_timestamp(st, timestamp, flags);
1367     if (index < 0)
1368         return -1;
1369
1370     /* now we have found the index, we can seek */
1371     ie = &st->index_entries[index];
1372     av_read_frame_flush(s);
1373     url_fseek(&s->pb, ie->pos, SEEK_SET);
1374
1375     av_update_cur_dts(s, st, ie->timestamp);
1376
1377     return 0;
1378 }
1379
1380 /**
1381  * Seek to the key frame at timestamp.
1382  * 'timestamp' in 'stream_index'.
1383  * @param stream_index If stream_index is (-1), a default
1384  * stream is selected, and timestamp is automatically converted
1385  * from AV_TIME_BASE units to the stream specific time_base.
1386  * @param timestamp timestamp in AVStream.time_base units
1387  *        or if there is no stream specified then in AV_TIME_BASE units
1388  * @param flags flags which select direction and seeking mode
1389  * @return >= 0 on success
1390  */
1391 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1392 {
1393     int ret;
1394     AVStream *st;
1395
1396     av_read_frame_flush(s);
1397
1398     if(flags & AVSEEK_FLAG_BYTE)
1399         return av_seek_frame_byte(s, stream_index, timestamp, flags);
1400
1401     if(stream_index < 0){
1402         stream_index= av_find_default_stream_index(s);
1403         if(stream_index < 0)
1404             return -1;
1405
1406         st= s->streams[stream_index];
1407        /* timestamp for default must be expressed in AV_TIME_BASE units */
1408         timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1409     }
1410     st= s->streams[stream_index];
1411
1412     /* first, we try the format specific seek */
1413     if (s->iformat->read_seek)
1414         ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1415     else
1416         ret = -1;
1417     if (ret >= 0) {
1418         return 0;
1419     }
1420
1421     if(s->iformat->read_timestamp)
1422         return av_seek_frame_binary(s, stream_index, timestamp, flags);
1423     else
1424         return av_seek_frame_generic(s, stream_index, timestamp, flags);
1425 }
1426
1427 /*******************************************************/
1428
1429 /**
1430  * Returns TRUE if the stream has accurate timings in any stream.
1431  *
1432  * @return TRUE if the stream has accurate timings for at least one component.
1433  */
1434 static int av_has_timings(AVFormatContext *ic)
1435 {
1436     int i;
1437     AVStream *st;
1438
1439     for(i = 0;i < ic->nb_streams; i++) {
1440         st = ic->streams[i];
1441         if (st->start_time != AV_NOPTS_VALUE &&
1442             st->duration != AV_NOPTS_VALUE)
1443             return 1;
1444     }
1445     return 0;
1446 }
1447
1448 /**
1449  * Estimate the stream timings from the one of each components.
1450  *
1451  * Also computes the global bitrate if possible.
1452  */
1453 static void av_update_stream_timings(AVFormatContext *ic)
1454 {
1455     int64_t start_time, start_time1, end_time, end_time1;
1456     int i;
1457     AVStream *st;
1458
1459     start_time = MAXINT64;
1460     end_time = MININT64;
1461     for(i = 0;i < ic->nb_streams; i++) {
1462         st = ic->streams[i];
1463         if (st->start_time != AV_NOPTS_VALUE) {
1464             start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1465             if (start_time1 < start_time)
1466                 start_time = start_time1;
1467             if (st->duration != AV_NOPTS_VALUE) {
1468                 end_time1 = start_time1
1469                           + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1470                 if (end_time1 > end_time)
1471                     end_time = end_time1;
1472             }
1473         }
1474     }
1475     if (start_time != MAXINT64) {
1476         ic->start_time = start_time;
1477         if (end_time != MININT64) {
1478             ic->duration = end_time - start_time;
1479             if (ic->file_size > 0) {
1480                 /* compute the bit rate */
1481                 ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1482                     (double)ic->duration;
1483             }
1484         }
1485     }
1486
1487 }
1488
1489 static void fill_all_stream_timings(AVFormatContext *ic)
1490 {
1491     int i;
1492     AVStream *st;
1493
1494     av_update_stream_timings(ic);
1495     for(i = 0;i < ic->nb_streams; i++) {
1496         st = ic->streams[i];
1497         if (st->start_time == AV_NOPTS_VALUE) {
1498             if(ic->start_time != AV_NOPTS_VALUE)
1499                 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1500             if(ic->duration != AV_NOPTS_VALUE)
1501                 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1502         }
1503     }
1504 }
1505
1506 static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1507 {
1508     int64_t filesize, duration;
1509     int bit_rate, i;
1510     AVStream *st;
1511
1512     /* if bit_rate is already set, we believe it */
1513     if (ic->bit_rate == 0) {
1514         bit_rate = 0;
1515         for(i=0;i<ic->nb_streams;i++) {
1516             st = ic->streams[i];
1517             bit_rate += st->codec->bit_rate;
1518         }
1519         ic->bit_rate = bit_rate;
1520     }
1521
1522     /* if duration is already set, we believe it */
1523     if (ic->duration == AV_NOPTS_VALUE &&
1524         ic->bit_rate != 0 &&
1525         ic->file_size != 0)  {
1526         filesize = ic->file_size;
1527         if (filesize > 0) {
1528             for(i = 0; i < ic->nb_streams; i++) {
1529                 st = ic->streams[i];
1530                 duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1531                 if (st->start_time == AV_NOPTS_VALUE ||
1532                     st->duration == AV_NOPTS_VALUE) {
1533                     st->start_time = 0;
1534                     st->duration = duration;
1535                 }
1536             }
1537         }
1538     }
1539 }
1540
1541 #define DURATION_MAX_READ_SIZE 250000
1542
1543 /* only usable for MPEG-PS streams */
1544 static void av_estimate_timings_from_pts(AVFormatContext *ic)
1545 {
1546     AVPacket pkt1, *pkt = &pkt1;
1547     AVStream *st;
1548     int read_size, i, ret;
1549     int64_t end_time;
1550     int64_t filesize, offset, duration;
1551
1552     /* free previous packet */
1553     if (ic->cur_st && ic->cur_st->parser)
1554         av_free_packet(&ic->cur_pkt);
1555     ic->cur_st = NULL;
1556
1557     /* flush packet queue */
1558     flush_packet_queue(ic);
1559
1560     for(i=0;i<ic->nb_streams;i++) {
1561         st = ic->streams[i];
1562         if (st->parser) {
1563             av_parser_close(st->parser);
1564             st->parser= NULL;
1565         }
1566     }
1567
1568     /* we read the first packets to get the first PTS (not fully
1569        accurate, but it is enough now) */
1570     url_fseek(&ic->pb, 0, SEEK_SET);
1571     read_size = 0;
1572     for(;;) {
1573         if (read_size >= DURATION_MAX_READ_SIZE)
1574             break;
1575         /* if all info is available, we can stop */
1576         for(i = 0;i < ic->nb_streams; i++) {
1577             st = ic->streams[i];
1578             if (st->start_time == AV_NOPTS_VALUE)
1579                 break;
1580         }
1581         if (i == ic->nb_streams)
1582             break;
1583
1584         ret = av_read_packet(ic, pkt);
1585         if (ret != 0)
1586             break;
1587         read_size += pkt->size;
1588         st = ic->streams[pkt->stream_index];
1589         if (pkt->pts != AV_NOPTS_VALUE) {
1590             if (st->start_time == AV_NOPTS_VALUE)
1591                 st->start_time = pkt->pts;
1592         }
1593         av_free_packet(pkt);
1594     }
1595
1596     /* estimate the end time (duration) */
1597     /* XXX: may need to support wrapping */
1598     filesize = ic->file_size;
1599     offset = filesize - DURATION_MAX_READ_SIZE;
1600     if (offset < 0)
1601         offset = 0;
1602
1603     url_fseek(&ic->pb, offset, SEEK_SET);
1604     read_size = 0;
1605     for(;;) {
1606         if (read_size >= DURATION_MAX_READ_SIZE)
1607             break;
1608         /* if all info is available, we can stop */
1609         for(i = 0;i < ic->nb_streams; i++) {
1610             st = ic->streams[i];
1611             if (st->duration == AV_NOPTS_VALUE)
1612                 break;
1613         }
1614         if (i == ic->nb_streams)
1615             break;
1616
1617         ret = av_read_packet(ic, pkt);
1618         if (ret != 0)
1619             break;
1620         read_size += pkt->size;
1621         st = ic->streams[pkt->stream_index];
1622         if (pkt->pts != AV_NOPTS_VALUE) {
1623             end_time = pkt->pts;
1624             duration = end_time - st->start_time;
1625             if (duration > 0) {
1626                 if (st->duration == AV_NOPTS_VALUE ||
1627                     st->duration < duration)
1628                     st->duration = duration;
1629             }
1630         }
1631         av_free_packet(pkt);
1632     }
1633
1634     fill_all_stream_timings(ic);
1635
1636     url_fseek(&ic->pb, 0, SEEK_SET);
1637 }
1638
1639 static void av_estimate_timings(AVFormatContext *ic)
1640 {
1641     int64_t file_size;
1642
1643     /* get the file size, if possible */
1644     if (ic->iformat->flags & AVFMT_NOFILE) {
1645         file_size = 0;
1646     } else {
1647         file_size = url_fsize(&ic->pb);
1648         if (file_size < 0)
1649             file_size = 0;
1650     }
1651     ic->file_size = file_size;
1652
1653     if ((!strcmp(ic->iformat->name, "mpeg") ||
1654          !strcmp(ic->iformat->name, "mpegts")) &&
1655         file_size && !ic->pb.is_streamed) {
1656         /* get accurate estimate from the PTSes */
1657         av_estimate_timings_from_pts(ic);
1658     } else if (av_has_timings(ic)) {
1659         /* at least one components has timings - we use them for all
1660            the components */
1661         fill_all_stream_timings(ic);
1662     } else {
1663         /* less precise: use bit rate info */
1664         av_estimate_timings_from_bit_rate(ic);
1665     }
1666     av_update_stream_timings(ic);
1667
1668 #if 0
1669     {
1670         int i;
1671         AVStream *st;
1672         for(i = 0;i < ic->nb_streams; i++) {
1673             st = ic->streams[i];
1674         printf("%d: start_time: %0.3f duration: %0.3f\n",
1675                i, (double)st->start_time / AV_TIME_BASE,
1676                (double)st->duration / AV_TIME_BASE);
1677         }
1678         printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1679                (double)ic->start_time / AV_TIME_BASE,
1680                (double)ic->duration / AV_TIME_BASE,
1681                ic->bit_rate / 1000);
1682     }
1683 #endif
1684 }
1685
1686 static int has_codec_parameters(AVCodecContext *enc)
1687 {
1688     int val;
1689     switch(enc->codec_type) {
1690     case CODEC_TYPE_AUDIO:
1691         val = enc->sample_rate;
1692         break;
1693     case CODEC_TYPE_VIDEO:
1694         val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
1695         break;
1696     default:
1697         val = 1;
1698         break;
1699     }
1700     return (val != 0);
1701 }
1702
1703 static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1704 {
1705     int16_t *samples;
1706     AVCodec *codec;
1707     int got_picture, ret=0;
1708     AVFrame picture;
1709
1710   if(!st->codec->codec){
1711     codec = avcodec_find_decoder(st->codec->codec_id);
1712     if (!codec)
1713         return -1;
1714     ret = avcodec_open(st->codec, codec);
1715     if (ret < 0)
1716         return ret;
1717   }
1718
1719   if(!has_codec_parameters(st->codec)){
1720     switch(st->codec->codec_type) {
1721     case CODEC_TYPE_VIDEO:
1722         ret = avcodec_decode_video(st->codec, &picture,
1723                                    &got_picture, (uint8_t *)data, size);
1724         break;
1725     case CODEC_TYPE_AUDIO:
1726         samples = av_malloc(AVCODEC_MAX_AUDIO_FRAME_SIZE);
1727         if (!samples)
1728             goto fail;
1729         ret = avcodec_decode_audio(st->codec, samples,
1730                                    &got_picture, (uint8_t *)data, size);
1731         av_free(samples);
1732         break;
1733     default:
1734         break;
1735     }
1736   }
1737  fail:
1738     return ret;
1739 }
1740
1741 /* absolute maximum size we read until we abort */
1742 #define MAX_READ_SIZE        5000000
1743
1744 /* maximum duration until we stop analysing the stream */
1745 #define MAX_STREAM_DURATION  ((int)(AV_TIME_BASE * 3.0))
1746
1747 /**
1748  * Read the beginning of a media file to get stream information. This
1749  * is useful for file formats with no headers such as MPEG. This
1750  * function also compute the real frame rate in case of mpeg2 repeat
1751  * frame mode.
1752  *
1753  * @param ic media file handle
1754  * @return >=0 if OK. AVERROR_xxx if error.
1755  * @todo let user decide somehow what information is needed so we dont waste time geting stuff the user doesnt need
1756  */
1757 int av_find_stream_info(AVFormatContext *ic)
1758 {
1759     int i, count, ret, read_size, j;
1760     AVStream *st;
1761     AVPacket pkt1, *pkt;
1762     AVPacketList *pktl=NULL, **ppktl;
1763     int64_t last_dts[MAX_STREAMS];
1764     int64_t duration_sum[MAX_STREAMS];
1765     int duration_count[MAX_STREAMS]={0};
1766
1767     for(i=0;i<ic->nb_streams;i++) {
1768         st = ic->streams[i];
1769         if(st->codec->codec_type == CODEC_TYPE_VIDEO){
1770 /*            if(!st->time_base.num)
1771                 st->time_base= */
1772             if(!st->codec->time_base.num)
1773                 st->codec->time_base= st->time_base;
1774         }
1775         //only for the split stuff
1776         if (!st->parser) {
1777             st->parser = av_parser_init(st->codec->codec_id);
1778             if(st->need_parsing == 2 && st->parser){
1779                 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1780             }
1781         }
1782     }
1783
1784     for(i=0;i<MAX_STREAMS;i++){
1785         last_dts[i]= AV_NOPTS_VALUE;
1786         duration_sum[i]= INT64_MAX;
1787     }
1788
1789     count = 0;
1790     read_size = 0;
1791     ppktl = &ic->packet_buffer;
1792     for(;;) {
1793         /* check if one codec still needs to be handled */
1794         for(i=0;i<ic->nb_streams;i++) {
1795             st = ic->streams[i];
1796             if (!has_codec_parameters(st->codec))
1797                 break;
1798             /* variable fps and no guess at the real fps */
1799             if(   st->codec->time_base.den >= 101LL*st->codec->time_base.num
1800                && duration_count[i]<20 && st->codec->codec_type == CODEC_TYPE_VIDEO)
1801                 break;
1802             if(st->parser && st->parser->parser->split && !st->codec->extradata)
1803                 break;
1804         }
1805         if (i == ic->nb_streams) {
1806             /* NOTE: if the format has no header, then we need to read
1807                some packets to get most of the streams, so we cannot
1808                stop here */
1809             if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
1810                 /* if we found the info for all the codecs, we can stop */
1811                 ret = count;
1812                 break;
1813             }
1814         } else {
1815             /* we did not get all the codec info, but we read too much data */
1816             if (read_size >= MAX_READ_SIZE) {
1817                 ret = count;
1818                 break;
1819             }
1820         }
1821
1822         /* NOTE: a new stream can be added there if no header in file
1823            (AVFMTCTX_NOHEADER) */
1824         ret = av_read_frame_internal(ic, &pkt1);
1825         if (ret < 0) {
1826             /* EOF or error */
1827             ret = -1; /* we could not have all the codec parameters before EOF */
1828             for(i=0;i<ic->nb_streams;i++) {
1829                 st = ic->streams[i];
1830                 if (!has_codec_parameters(st->codec)){
1831                     char buf[256];
1832                     avcodec_string(buf, sizeof(buf), st->codec, 0);
1833                     av_log(ic, AV_LOG_INFO, "Could not find codec parameters (%s)\n", buf);
1834                 } else {
1835                     ret = 0;
1836                 }
1837             }
1838             break;
1839         }
1840
1841         pktl = av_mallocz(sizeof(AVPacketList));
1842         if (!pktl) {
1843             ret = AVERROR_NOMEM;
1844             break;
1845         }
1846
1847         /* add the packet in the buffered packet list */
1848         *ppktl = pktl;
1849         ppktl = &pktl->next;
1850
1851         pkt = &pktl->pkt;
1852         *pkt = pkt1;
1853
1854         /* duplicate the packet */
1855         if (av_dup_packet(pkt) < 0) {
1856                 ret = AVERROR_NOMEM;
1857                 break;
1858         }
1859
1860         read_size += pkt->size;
1861
1862         st = ic->streams[pkt->stream_index];
1863         st->codec_info_duration += pkt->duration;
1864         if (pkt->duration != 0)
1865             st->codec_info_nb_frames++;
1866
1867         {
1868             int index= pkt->stream_index;
1869             int64_t last= last_dts[index];
1870             int64_t duration= pkt->dts - last;
1871
1872             if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
1873                 if(duration*duration_count[index]*10/9 < duration_sum[index]){
1874                     duration_sum[index]= duration;
1875                     duration_count[index]=1;
1876                 }else{
1877                     int factor= av_rescale(duration, duration_count[index], duration_sum[index]);
1878                     duration_sum[index] += duration;
1879                     duration_count[index]+= factor;
1880                 }
1881                 if(st->codec_info_nb_frames == 0 && 0)
1882                     st->codec_info_duration += duration;
1883             }
1884             last_dts[pkt->stream_index]= pkt->dts;
1885         }
1886         if(st->parser && st->parser->parser->split && !st->codec->extradata){
1887             int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
1888             if(i){
1889                 st->codec->extradata_size= i;
1890                 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
1891                 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
1892                 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
1893             }
1894         }
1895
1896         /* if still no information, we try to open the codec and to
1897            decompress the frame. We try to avoid that in most cases as
1898            it takes longer and uses more memory. For MPEG4, we need to
1899            decompress for Quicktime. */
1900         if (!has_codec_parameters(st->codec) /*&&
1901             (st->codec->codec_id == CODEC_ID_FLV1 ||
1902              st->codec->codec_id == CODEC_ID_H264 ||
1903              st->codec->codec_id == CODEC_ID_H263 ||
1904              st->codec->codec_id == CODEC_ID_H261 ||
1905              st->codec->codec_id == CODEC_ID_VORBIS ||
1906              st->codec->codec_id == CODEC_ID_MJPEG ||
1907              st->codec->codec_id == CODEC_ID_PNG ||
1908              st->codec->codec_id == CODEC_ID_PAM ||
1909              st->codec->codec_id == CODEC_ID_PGM ||
1910              st->codec->codec_id == CODEC_ID_PGMYUV ||
1911              st->codec->codec_id == CODEC_ID_PBM ||
1912              st->codec->codec_id == CODEC_ID_PPM ||
1913              st->codec->codec_id == CODEC_ID_SHORTEN ||
1914              (st->codec->codec_id == CODEC_ID_MPEG4 && !st->need_parsing))*/)
1915             try_decode_frame(st, pkt->data, pkt->size);
1916
1917         if (av_rescale_q(st->codec_info_duration, st->time_base, AV_TIME_BASE_Q) >= MAX_STREAM_DURATION) {
1918             break;
1919         }
1920         count++;
1921     }
1922
1923     // close codecs which where opened in try_decode_frame()
1924     for(i=0;i<ic->nb_streams;i++) {
1925         st = ic->streams[i];
1926         if(st->codec->codec)
1927             avcodec_close(st->codec);
1928     }
1929     for(i=0;i<ic->nb_streams;i++) {
1930         st = ic->streams[i];
1931         if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1932             if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_sample)
1933                 st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
1934
1935             if(duration_count[i] && st->codec->time_base.num*101LL <= st->codec->time_base.den &&
1936                st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den){
1937                 int64_t num, den, error, best_error;
1938
1939                 num= st->time_base.den*duration_count[i];
1940                 den= st->time_base.num*duration_sum[i];
1941
1942                 best_error= INT64_MAX;
1943                 for(j=1; j<60*12; j++){
1944                     error= ABS(1001*12*num - 1001*j*den);
1945                     if(error < best_error){
1946                         best_error= error;
1947                         av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, j, 12, INT_MAX);
1948                     }
1949                 }
1950                 for(j=24; j<=30; j+=6){
1951                     error= ABS(1001*12*num - 1000*12*j*den);
1952                     if(error < best_error){
1953                         best_error= error;
1954                         av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, j*1000, 1001, INT_MAX);
1955                     }
1956                 }
1957             }
1958
1959             /* set real frame rate info */
1960             /* compute the real frame rate for telecine */
1961             if ((st->codec->codec_id == CODEC_ID_MPEG1VIDEO ||
1962                  st->codec->codec_id == CODEC_ID_MPEG2VIDEO) &&
1963                 st->codec->sub_id == 2) {
1964                 if (st->codec_info_nb_frames >= 20) {
1965                     float coded_frame_rate, est_frame_rate;
1966                     est_frame_rate = ((double)st->codec_info_nb_frames * AV_TIME_BASE) /
1967                         (double)st->codec_info_duration ;
1968                     coded_frame_rate = 1.0/av_q2d(st->codec->time_base);
1969 #if 0
1970                     printf("telecine: coded_frame_rate=%0.3f est_frame_rate=%0.3f\n",
1971                            coded_frame_rate, est_frame_rate);
1972 #endif
1973                     /* if we detect that it could be a telecine, we
1974                        signal it. It would be better to do it at a
1975                        higher level as it can change in a film */
1976                     if (coded_frame_rate >= 24.97 &&
1977                         (est_frame_rate >= 23.5 && est_frame_rate < 24.5)) {
1978                         st->r_frame_rate = (AVRational){24000, 1001};
1979                     }
1980                 }
1981             }
1982             /* if no real frame rate, use the codec one */
1983             if (!st->r_frame_rate.num){
1984                 st->r_frame_rate.num = st->codec->time_base.den;
1985                 st->r_frame_rate.den = st->codec->time_base.num;
1986             }
1987         }
1988     }
1989
1990     av_estimate_timings(ic);
1991 #if 0
1992     /* correct DTS for b frame streams with no timestamps */
1993     for(i=0;i<ic->nb_streams;i++) {
1994         st = ic->streams[i];
1995         if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1996             if(b-frames){
1997                 ppktl = &ic->packet_buffer;
1998                 while(ppkt1){
1999                     if(ppkt1->stream_index != i)
2000                         continue;
2001                     if(ppkt1->pkt->dts < 0)
2002                         break;
2003                     if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2004                         break;
2005                     ppkt1->pkt->dts -= delta;
2006                     ppkt1= ppkt1->next;
2007                 }
2008                 if(ppkt1)
2009                     continue;
2010                 st->cur_dts -= delta;
2011             }
2012         }
2013     }
2014 #endif
2015     return ret;
2016 }
2017
2018 /*******************************************************/
2019
2020 /**
2021  * start playing a network based stream (e.g. RTSP stream) at the
2022  * current position
2023  */
2024 int av_read_play(AVFormatContext *s)
2025 {
2026     if (!s->iformat->read_play)
2027         return AVERROR_NOTSUPP;
2028     return s->iformat->read_play(s);
2029 }
2030
2031 /**
2032  * Pause a network based stream (e.g. RTSP stream).
2033  *
2034  * Use av_read_play() to resume it.
2035  */
2036 int av_read_pause(AVFormatContext *s)
2037 {
2038     if (!s->iformat->read_pause)
2039         return AVERROR_NOTSUPP;
2040     return s->iformat->read_pause(s);
2041 }
2042
2043 /**
2044  * Close a media file (but not its codecs).
2045  *
2046  * @param s media file handle
2047  */
2048 void av_close_input_file(AVFormatContext *s)
2049 {
2050     int i, must_open_file;
2051     AVStream *st;
2052
2053     /* free previous packet */
2054     if (s->cur_st && s->cur_st->parser)
2055         av_free_packet(&s->cur_pkt);
2056
2057     if (s->iformat->read_close)
2058         s->iformat->read_close(s);
2059     for(i=0;i<s->nb_streams;i++) {
2060         /* free all data in a stream component */
2061         st = s->streams[i];
2062         if (st->parser) {
2063             av_parser_close(st->parser);
2064         }
2065         av_free(st->index_entries);
2066         av_free(st->codec->extradata);
2067         av_free(st->codec);
2068         av_free(st);
2069     }
2070     flush_packet_queue(s);
2071     must_open_file = 1;
2072     if (s->iformat->flags & AVFMT_NOFILE) {
2073         must_open_file = 0;
2074     }
2075     if (must_open_file) {
2076         url_fclose(&s->pb);
2077     }
2078     av_freep(&s->priv_data);
2079     av_free(s);
2080 }
2081
2082 /**
2083  * Add a new stream to a media file.
2084  *
2085  * Can only be called in the read_header() function. If the flag
2086  * AVFMTCTX_NOHEADER is in the format context, then new streams
2087  * can be added in read_packet too.
2088  *
2089  * @param s media file handle
2090  * @param id file format dependent stream id
2091  */
2092 AVStream *av_new_stream(AVFormatContext *s, int id)
2093 {
2094     AVStream *st;
2095     int i;
2096
2097     if (s->nb_streams >= MAX_STREAMS)
2098         return NULL;
2099
2100     st = av_mallocz(sizeof(AVStream));
2101     if (!st)
2102         return NULL;
2103
2104     st->codec= avcodec_alloc_context();
2105     if (s->iformat) {
2106         /* no default bitrate if decoding */
2107         st->codec->bit_rate = 0;
2108     }
2109     st->index = s->nb_streams;
2110     st->id = id;
2111     st->start_time = AV_NOPTS_VALUE;
2112     st->duration = AV_NOPTS_VALUE;
2113     st->cur_dts = AV_NOPTS_VALUE;
2114
2115     /* default pts settings is MPEG like */
2116     av_set_pts_info(st, 33, 1, 90000);
2117     st->last_IP_pts = AV_NOPTS_VALUE;
2118     for(i=0; i<MAX_REORDER_DELAY+1; i++)
2119         st->pts_buffer[i]= AV_NOPTS_VALUE;
2120
2121     s->streams[s->nb_streams++] = st;
2122     return st;
2123 }
2124
2125 /************************************************************/
2126 /* output media file */
2127
2128 int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2129 {
2130     int ret;
2131
2132     if (s->oformat->priv_data_size > 0) {
2133         s->priv_data = av_mallocz(s->oformat->priv_data_size);
2134         if (!s->priv_data)
2135             return AVERROR_NOMEM;
2136     } else
2137         s->priv_data = NULL;
2138
2139     if (s->oformat->set_parameters) {
2140         ret = s->oformat->set_parameters(s, ap);
2141         if (ret < 0)
2142             return ret;
2143     }
2144     return 0;
2145 }
2146
2147 /**
2148  * allocate the stream private data and write the stream header to an
2149  * output media file
2150  *
2151  * @param s media file handle
2152  * @return 0 if OK. AVERROR_xxx if error.
2153  */
2154 int av_write_header(AVFormatContext *s)
2155 {
2156     int ret, i;
2157     AVStream *st;
2158
2159     // some sanity checks
2160     for(i=0;i<s->nb_streams;i++) {
2161         st = s->streams[i];
2162
2163         switch (st->codec->codec_type) {
2164         case CODEC_TYPE_AUDIO:
2165             if(st->codec->sample_rate<=0){
2166                 av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2167                 return -1;
2168             }
2169             break;
2170         case CODEC_TYPE_VIDEO:
2171             if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2172                 av_log(s, AV_LOG_ERROR, "time base not set\n");
2173                 return -1;
2174             }
2175             if(st->codec->width<=0 || st->codec->height<=0){
2176                 av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2177                 return -1;
2178             }
2179             break;
2180         }
2181     }
2182
2183     if(s->oformat->write_header){
2184         ret = s->oformat->write_header(s);
2185         if (ret < 0)
2186             return ret;
2187     }
2188
2189     /* init PTS generation */
2190     for(i=0;i<s->nb_streams;i++) {
2191         int64_t den = AV_NOPTS_VALUE;
2192         st = s->streams[i];
2193
2194         switch (st->codec->codec_type) {
2195         case CODEC_TYPE_AUDIO:
2196             den = (int64_t)st->time_base.num * st->codec->sample_rate;
2197             break;
2198         case CODEC_TYPE_VIDEO:
2199             den = (int64_t)st->time_base.num * st->codec->time_base.den;
2200             break;
2201         default:
2202             break;
2203         }
2204         if (den != AV_NOPTS_VALUE) {
2205             if (den <= 0)
2206                 return AVERROR_INVALIDDATA;
2207             av_frac_init(&st->pts, 0, 0, den);
2208         }
2209     }
2210     return 0;
2211 }
2212
2213 //FIXME merge with compute_pkt_fields
2214 static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
2215     int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2216     int num, den, frame_size, i;
2217
2218 //    av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts:%lld dts:%lld cur_dts:%lld b:%d size:%d st:%d\n", pkt->pts, pkt->dts, st->cur_dts, delay, pkt->size, pkt->stream_index);
2219
2220 /*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2221         return -1;*/
2222
2223     /* duration field */
2224     if (pkt->duration == 0) {
2225         compute_frame_duration(&num, &den, st, NULL, pkt);
2226         if (den && num) {
2227             pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
2228         }
2229     }
2230
2231     //XXX/FIXME this is a temporary hack until all encoders output pts
2232     if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2233         pkt->dts=
2234 //        pkt->pts= st->cur_dts;
2235         pkt->pts= st->pts.val;
2236     }
2237
2238     //calculate dts from pts
2239     if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE){
2240         st->pts_buffer[0]= pkt->pts;
2241         for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2242             st->pts_buffer[i]= (i-delay-1) * pkt->duration;
2243         for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2244             SWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2245
2246         pkt->dts= st->pts_buffer[0];
2247     }
2248
2249     if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2250         av_log(NULL, AV_LOG_ERROR, "error, non monotone timestamps %"PRId64" >= %"PRId64"\n", st->cur_dts, pkt->dts);
2251         return -1;
2252     }
2253     if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2254         av_log(NULL, AV_LOG_ERROR, "error, pts < dts\n");
2255         return -1;
2256     }
2257
2258 //    av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%lld dts2:%lld\n", pkt->pts, pkt->dts);
2259     st->cur_dts= pkt->dts;
2260     st->pts.val= pkt->dts;
2261
2262     /* update pts */
2263     switch (st->codec->codec_type) {
2264     case CODEC_TYPE_AUDIO:
2265         frame_size = get_audio_frame_size(st->codec, pkt->size);
2266
2267         /* HACK/FIXME, we skip the initial 0-size packets as they are most likely equal to the encoder delay,
2268            but it would be better if we had the real timestamps from the encoder */
2269         if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2270             av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2271         }
2272         break;
2273     case CODEC_TYPE_VIDEO:
2274         av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2275         break;
2276     default:
2277         break;
2278     }
2279     return 0;
2280 }
2281
2282 static void truncate_ts(AVStream *st, AVPacket *pkt){
2283     int64_t pts_mask = (2LL << (st->pts_wrap_bits-1)) - 1;
2284
2285 //    if(pkt->dts < 0)
2286 //        pkt->dts= 0;  //this happens for low_delay=0 and b frames, FIXME, needs further invstigation about what we should do here
2287
2288     pkt->pts &= pts_mask;
2289     pkt->dts &= pts_mask;
2290 }
2291
2292 /**
2293  * Write a packet to an output media file.
2294  *
2295  * The packet shall contain one audio or video frame.
2296  *
2297  * @param s media file handle
2298  * @param pkt the packet, which contains the stream_index, buf/buf_size, dts/pts, ...
2299  * @return < 0 if error, = 0 if OK, 1 if end of stream wanted.
2300  */
2301 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2302 {
2303     int ret;
2304
2305     ret=compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2306     if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2307         return ret;
2308
2309     truncate_ts(s->streams[pkt->stream_index], pkt);
2310
2311     ret= s->oformat->write_packet(s, pkt);
2312     if(!ret)
2313         ret= url_ferror(&s->pb);
2314     return ret;
2315 }
2316
2317 /**
2318  * Interleave a packet per DTS in an output media file.
2319  *
2320  * Packets with pkt->destruct == av_destruct_packet will be freed inside this function,
2321  * so they cannot be used after it, note calling av_free_packet() on them is still safe.
2322  *
2323  * @param s media file handle
2324  * @param out the interleaved packet will be output here
2325  * @param in the input packet
2326  * @param flush 1 if no further packets are available as input and all
2327  *              remaining packets should be output
2328  * @return 1 if a packet was output, 0 if no packet could be output,
2329  *         < 0 if an error occured
2330  */
2331 int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2332     AVPacketList *pktl, **next_point, *this_pktl;
2333     int stream_count=0;
2334     int streams[MAX_STREAMS];
2335
2336     if(pkt){
2337         AVStream *st= s->streams[ pkt->stream_index];
2338
2339 //        assert(pkt->destruct != av_destruct_packet); //FIXME
2340
2341         this_pktl = av_mallocz(sizeof(AVPacketList));
2342         this_pktl->pkt= *pkt;
2343         if(pkt->destruct == av_destruct_packet)
2344             pkt->destruct= NULL; // non shared -> must keep original from being freed
2345         else
2346             av_dup_packet(&this_pktl->pkt);  //shared -> must dup
2347
2348         next_point = &s->packet_buffer;
2349         while(*next_point){
2350             AVStream *st2= s->streams[ (*next_point)->pkt.stream_index];
2351             int64_t left=  st2->time_base.num * (int64_t)st ->time_base.den;
2352             int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2353             if((*next_point)->pkt.dts * left > pkt->dts * right) //FIXME this can overflow
2354                 break;
2355             next_point= &(*next_point)->next;
2356         }
2357         this_pktl->next= *next_point;
2358         *next_point= this_pktl;
2359     }
2360
2361     memset(streams, 0, sizeof(streams));
2362     pktl= s->packet_buffer;
2363     while(pktl){
2364 //av_log(s, AV_LOG_DEBUG, "show st:%d dts:%lld\n", pktl->pkt.stream_index, pktl->pkt.dts);
2365         if(streams[ pktl->pkt.stream_index ] == 0)
2366             stream_count++;
2367         streams[ pktl->pkt.stream_index ]++;
2368         pktl= pktl->next;
2369     }
2370
2371     if(s->nb_streams == stream_count || (flush && stream_count)){
2372         pktl= s->packet_buffer;
2373         *out= pktl->pkt;
2374
2375         s->packet_buffer= pktl->next;
2376         av_freep(&pktl);
2377         return 1;
2378     }else{
2379         av_init_packet(out);
2380         return 0;
2381     }
2382 }
2383
2384 /**
2385  * Interleaves a AVPacket correctly so it can be muxed.
2386  * @param out the interleaved packet will be output here
2387  * @param in the input packet
2388  * @param flush 1 if no further packets are available as input and all
2389  *              remaining packets should be output
2390  * @return 1 if a packet was output, 0 if no packet could be output,
2391  *         < 0 if an error occured
2392  */
2393 static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2394     if(s->oformat->interleave_packet)
2395         return s->oformat->interleave_packet(s, out, in, flush);
2396     else
2397         return av_interleave_packet_per_dts(s, out, in, flush);
2398 }
2399
2400 /**
2401  * Writes a packet to an output media file ensuring correct interleaving.
2402  *
2403  * The packet must contain one audio or video frame.
2404  * If the packets are already correctly interleaved the application should
2405  * call av_write_frame() instead as its slightly faster, its also important
2406  * to keep in mind that completly non interleaved input will need huge amounts
2407  * of memory to interleave with this, so its prefereable to interleave at the
2408  * demuxer level
2409  *
2410  * @param s media file handle
2411  * @param pkt the packet, which contains the stream_index, buf/buf_size, dts/pts, ...
2412  * @return < 0 if error, = 0 if OK, 1 if end of stream wanted.
2413  */
2414 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2415     AVStream *st= s->streams[ pkt->stream_index];
2416
2417     //FIXME/XXX/HACK drop zero sized packets
2418     if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2419         return 0;
2420
2421 //av_log(NULL, AV_LOG_DEBUG, "av_interleaved_write_frame %d %Ld %Ld\n", pkt->size, pkt->dts, pkt->pts);
2422     if(compute_pkt_fields2(st, pkt) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2423         return -1;
2424
2425     if(pkt->dts == AV_NOPTS_VALUE)
2426         return -1;
2427
2428     for(;;){
2429         AVPacket opkt;
2430         int ret= av_interleave_packet(s, &opkt, pkt, 0);
2431         if(ret<=0) //FIXME cleanup needed for ret<0 ?
2432             return ret;
2433
2434         truncate_ts(s->streams[opkt.stream_index], &opkt);
2435         ret= s->oformat->write_packet(s, &opkt);
2436
2437         av_free_packet(&opkt);
2438         pkt= NULL;
2439
2440         if(ret<0)
2441             return ret;
2442         if(url_ferror(&s->pb))
2443             return url_ferror(&s->pb);
2444     }
2445 }
2446
2447 /**
2448  * @brief Write the stream trailer to an output media file and
2449  *        free the file private data.
2450  *
2451  * @param s media file handle
2452  * @return 0 if OK. AVERROR_xxx if error.
2453  */
2454 int av_write_trailer(AVFormatContext *s)
2455 {
2456     int ret, i;
2457
2458     for(;;){
2459         AVPacket pkt;
2460         ret= av_interleave_packet(s, &pkt, NULL, 1);
2461         if(ret<0) //FIXME cleanup needed for ret<0 ?
2462             goto fail;
2463         if(!ret)
2464             break;
2465
2466         truncate_ts(s->streams[pkt.stream_index], &pkt);
2467         ret= s->oformat->write_packet(s, &pkt);
2468
2469         av_free_packet(&pkt);
2470
2471         if(ret<0)
2472             goto fail;
2473         if(url_ferror(&s->pb))
2474             goto fail;
2475     }
2476
2477     if(s->oformat->write_trailer)
2478         ret = s->oformat->write_trailer(s);
2479 fail:
2480     if(ret == 0)
2481        ret=url_ferror(&s->pb);
2482     for(i=0;i<s->nb_streams;i++)
2483         av_freep(&s->streams[i]->priv_data);
2484     av_freep(&s->priv_data);
2485     return ret;
2486 }
2487
2488 /* "user interface" functions */
2489
2490 void dump_format(AVFormatContext *ic,
2491                  int index,
2492                  const char *url,
2493                  int is_output)
2494 {
2495     int i, flags;
2496     char buf[256];
2497
2498     av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
2499             is_output ? "Output" : "Input",
2500             index,
2501             is_output ? ic->oformat->name : ic->iformat->name,
2502             is_output ? "to" : "from", url);
2503     if (!is_output) {
2504         av_log(NULL, AV_LOG_INFO, "  Duration: ");
2505         if (ic->duration != AV_NOPTS_VALUE) {
2506             int hours, mins, secs, us;
2507             secs = ic->duration / AV_TIME_BASE;
2508             us = ic->duration % AV_TIME_BASE;
2509             mins = secs / 60;
2510             secs %= 60;
2511             hours = mins / 60;
2512             mins %= 60;
2513             av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%01d", hours, mins, secs,
2514                    (10 * us) / AV_TIME_BASE);
2515         } else {
2516             av_log(NULL, AV_LOG_INFO, "N/A");
2517         }
2518         if (ic->start_time != AV_NOPTS_VALUE) {
2519             int secs, us;
2520             av_log(NULL, AV_LOG_INFO, ", start: ");
2521             secs = ic->start_time / AV_TIME_BASE;
2522             us = ic->start_time % AV_TIME_BASE;
2523             av_log(NULL, AV_LOG_INFO, "%d.%06d",
2524                    secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
2525         }
2526         av_log(NULL, AV_LOG_INFO, ", bitrate: ");
2527         if (ic->bit_rate) {
2528             av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
2529         } else {
2530             av_log(NULL, AV_LOG_INFO, "N/A");
2531         }
2532         av_log(NULL, AV_LOG_INFO, "\n");
2533     }
2534     for(i=0;i<ic->nb_streams;i++) {
2535         AVStream *st = ic->streams[i];
2536         int g= ff_gcd(st->time_base.num, st->time_base.den);
2537         avcodec_string(buf, sizeof(buf), st->codec, is_output);
2538         av_log(NULL, AV_LOG_INFO, "  Stream #%d.%d", index, i);
2539         /* the pid is an important information, so we display it */
2540         /* XXX: add a generic system */
2541         if (is_output)
2542             flags = ic->oformat->flags;
2543         else
2544             flags = ic->iformat->flags;
2545         if (flags & AVFMT_SHOW_IDS) {
2546             av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
2547         }
2548         if (strlen(st->language) > 0) {
2549             av_log(NULL, AV_LOG_INFO, "(%s)", st->language);
2550         }
2551         av_log(NULL, AV_LOG_DEBUG, ", %d/%d", st->time_base.num/g, st->time_base.den/g);
2552         av_log(NULL, AV_LOG_INFO, ": %s", buf);
2553         if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2554             if(st->r_frame_rate.den && st->r_frame_rate.num)
2555                 av_log(NULL, AV_LOG_INFO, ", %5.2f fps(r)", av_q2d(st->r_frame_rate));
2556 /*            else if(st->time_base.den && st->time_base.num)
2557                 av_log(NULL, AV_LOG_INFO, ", %5.2f fps(m)", 1/av_q2d(st->time_base));*/
2558             else
2559                 av_log(NULL, AV_LOG_INFO, ", %5.2f fps(c)", 1/av_q2d(st->codec->time_base));
2560         }
2561         av_log(NULL, AV_LOG_INFO, "\n");
2562     }
2563 }
2564
2565 typedef struct {
2566     const char *abv;
2567     int width, height;
2568     int frame_rate, frame_rate_base;
2569 } AbvEntry;
2570
2571 static AbvEntry frame_abvs[] = {
2572     { "ntsc",      720, 480, 30000, 1001 },
2573     { "pal",       720, 576,    25,    1 },
2574     { "qntsc",     352, 240, 30000, 1001 }, /* VCD compliant ntsc */
2575     { "qpal",      352, 288,    25,    1 }, /* VCD compliant pal */
2576     { "sntsc",     640, 480, 30000, 1001 }, /* square pixel ntsc */
2577     { "spal",      768, 576,    25,    1 }, /* square pixel pal */
2578     { "film",      352, 240,    24,    1 },
2579     { "ntsc-film", 352, 240, 24000, 1001 },
2580     { "sqcif",     128,  96,     0,    0 },
2581     { "qcif",      176, 144,     0,    0 },
2582     { "cif",       352, 288,     0,    0 },
2583     { "4cif",      704, 576,     0,    0 },
2584 };
2585
2586 /**
2587  * parses width and height out of string str.
2588  */
2589 int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2590 {
2591     int i;
2592     int n = sizeof(frame_abvs) / sizeof(AbvEntry);
2593     const char *p;
2594     int frame_width = 0, frame_height = 0;
2595
2596     for(i=0;i<n;i++) {
2597         if (!strcmp(frame_abvs[i].abv, str)) {
2598             frame_width = frame_abvs[i].width;
2599             frame_height = frame_abvs[i].height;
2600             break;
2601         }
2602     }
2603     if (i == n) {
2604         p = str;
2605         frame_width = strtol(p, (char **)&p, 10);
2606         if (*p)
2607             p++;
2608         frame_height = strtol(p, (char **)&p, 10);
2609     }
2610     if (frame_width <= 0 || frame_height <= 0)
2611         return -1;
2612     *width_ptr = frame_width;
2613     *height_ptr = frame_height;
2614     return 0;
2615 }
2616
2617 /**
2618  * Converts frame rate from string to a fraction.
2619  *
2620  * First we try to get an exact integer or fractional frame rate.
2621  * If this fails we convert the frame rate to a double and return
2622  * an approximate fraction using the DEFAULT_FRAME_RATE_BASE.
2623  */
2624 int parse_frame_rate(int *frame_rate, int *frame_rate_base, const char *arg)
2625 {
2626     int i;
2627     char* cp;
2628
2629     /* First, we check our abbreviation table */
2630     for (i = 0; i < sizeof(frame_abvs)/sizeof(*frame_abvs); ++i)
2631          if (!strcmp(frame_abvs[i].abv, arg)) {
2632              *frame_rate = frame_abvs[i].frame_rate;
2633              *frame_rate_base = frame_abvs[i].frame_rate_base;
2634              return 0;
2635          }
2636
2637     /* Then, we try to parse it as fraction */
2638     cp = strchr(arg, '/');
2639     if (!cp)
2640         cp = strchr(arg, ':');
2641     if (cp) {
2642         char* cpp;
2643         *frame_rate = strtol(arg, &cpp, 10);
2644         if (cpp != arg || cpp == cp)
2645             *frame_rate_base = strtol(cp+1, &cpp, 10);
2646         else
2647            *frame_rate = 0;
2648     }
2649     else {
2650         /* Finally we give up and parse it as double */
2651         AVRational time_base = av_d2q(strtod(arg, 0), DEFAULT_FRAME_RATE_BASE);
2652         *frame_rate_base = time_base.den;
2653         *frame_rate = time_base.num;
2654     }
2655     if (!*frame_rate || !*frame_rate_base)
2656         return -1;
2657     else
2658         return 0;
2659 }
2660
2661 /**
2662  * Converts date string to number of seconds since Jan 1st, 1970.
2663  *
2664  * @code
2665  * Syntax:
2666  * - If not a duration:
2667  *  [{YYYY-MM-DD|YYYYMMDD}]{T| }{HH[:MM[:SS[.m...]]][Z]|HH[MM[SS[.m...]]][Z]}
2668  * Time is localtime unless Z is suffixed to the end. In this case GMT
2669  * Return the date in micro seconds since 1970
2670  *
2671  * - If a duration:
2672  *  HH[:MM[:SS[.m...]]]
2673  *  S+[.m...]
2674  * @endcode
2675  */
2676 #ifndef CONFIG_WINCE
2677 int64_t parse_date(const char *datestr, int duration)
2678 {
2679     const char *p;
2680     int64_t t;
2681     struct tm dt;
2682     int i;
2683     static const char *date_fmt[] = {
2684         "%Y-%m-%d",
2685         "%Y%m%d",
2686     };
2687     static const char *time_fmt[] = {
2688         "%H:%M:%S",
2689         "%H%M%S",
2690     };
2691     const char *q;
2692     int is_utc, len;
2693     char lastch;
2694     int negative = 0;
2695
2696 #undef time
2697     time_t now = time(0);
2698
2699     len = strlen(datestr);
2700     if (len > 0)
2701         lastch = datestr[len - 1];
2702     else
2703         lastch = '\0';
2704     is_utc = (lastch == 'z' || lastch == 'Z');
2705
2706     memset(&dt, 0, sizeof(dt));
2707
2708     p = datestr;
2709     q = NULL;
2710     if (!duration) {
2711         for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
2712             q = small_strptime(p, date_fmt[i], &dt);
2713             if (q) {
2714                 break;
2715             }
2716         }
2717
2718         if (!q) {
2719             if (is_utc) {
2720                 dt = *gmtime(&now);
2721             } else {
2722                 dt = *localtime(&now);
2723             }
2724             dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
2725         } else {
2726             p = q;
2727         }
2728
2729         if (*p == 'T' || *p == 't' || *p == ' ')
2730             p++;
2731
2732         for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
2733             q = small_strptime(p, time_fmt[i], &dt);
2734             if (q) {
2735                 break;
2736             }
2737         }
2738     } else {
2739         if (p[0] == '-') {
2740             negative = 1;
2741             ++p;
2742         }
2743         q = small_strptime(p, time_fmt[0], &dt);
2744         if (!q) {
2745             dt.tm_sec = strtol(p, (char **)&q, 10);
2746             dt.tm_min = 0;
2747             dt.tm_hour = 0;
2748         }
2749     }
2750
2751     /* Now we have all the fields that we can get */
2752     if (!q) {
2753         if (duration)
2754             return 0;
2755         else
2756             return now * int64_t_C(1000000);
2757     }
2758
2759     if (duration) {
2760         t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2761     } else {
2762         dt.tm_isdst = -1;       /* unknown */
2763         if (is_utc) {
2764             t = mktimegm(&dt);
2765         } else {
2766             t = mktime(&dt);
2767         }
2768     }
2769
2770     t *= 1000000;
2771
2772     if (*q == '.') {
2773         int val, n;
2774         q++;
2775         for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
2776             if (!isdigit(*q))
2777                 break;
2778             val += n * (*q - '0');
2779         }
2780         t += val;
2781     }
2782     return negative ? -t : t;
2783 }
2784 #endif /* CONFIG_WINCE */
2785
2786 /**
2787  * Attempts to find a specific tag in a URL.
2788  *
2789  * syntax: '?tag1=val1&tag2=val2...'. Little URL decoding is done.
2790  * Return 1 if found.
2791  */
2792 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
2793 {
2794     const char *p;
2795     char tag[128], *q;
2796
2797     p = info;
2798     if (*p == '?')
2799         p++;
2800     for(;;) {
2801         q = tag;
2802         while (*p != '\0' && *p != '=' && *p != '&') {
2803             if ((q - tag) < sizeof(tag) - 1)
2804                 *q++ = *p;
2805             p++;
2806         }
2807         *q = '\0';
2808         q = arg;
2809         if (*p == '=') {
2810             p++;
2811             while (*p != '&' && *p != '\0') {
2812                 if ((q - arg) < arg_size - 1) {
2813                     if (*p == '+')
2814                         *q++ = ' ';
2815                     else
2816                         *q++ = *p;
2817                 }
2818                 p++;
2819             }
2820             *q = '\0';
2821         }
2822         if (!strcmp(tag, tag1))
2823             return 1;
2824         if (*p != '&')
2825             break;
2826         p++;
2827     }
2828     return 0;
2829 }
2830
2831 /**
2832  * Returns in 'buf' the path with '%d' replaced by number.
2833
2834  * Also handles the '%0nd' format where 'n' is the total number
2835  * of digits and '%%'.
2836  *
2837  * @param buf destination buffer
2838  * @param buf_size destination buffer size
2839  * @param path numbered sequence string
2840  * @number frame number
2841  * @return 0 if OK, -1 if format error.
2842  */
2843 int av_get_frame_filename(char *buf, int buf_size,
2844                           const char *path, int number)
2845 {
2846     const char *p;
2847     char *q, buf1[20], c;
2848     int nd, len, percentd_found;
2849
2850     q = buf;
2851     p = path;
2852     percentd_found = 0;
2853     for(;;) {
2854         c = *p++;
2855         if (c == '\0')
2856             break;
2857         if (c == '%') {
2858             do {
2859                 nd = 0;
2860                 while (isdigit(*p)) {
2861                     nd = nd * 10 + *p++ - '0';
2862                 }
2863                 c = *p++;
2864             } while (isdigit(c));
2865
2866             switch(c) {
2867             case '%':
2868                 goto addchar;
2869             case 'd':
2870                 if (percentd_found)
2871                     goto fail;
2872                 percentd_found = 1;
2873                 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
2874                 len = strlen(buf1);
2875                 if ((q - buf + len) > buf_size - 1)
2876                     goto fail;
2877                 memcpy(q, buf1, len);
2878                 q += len;
2879                 break;
2880             default:
2881                 goto fail;
2882             }
2883         } else {
2884         addchar:
2885             if ((q - buf) < buf_size - 1)
2886                 *q++ = c;
2887         }
2888     }
2889     if (!percentd_found)
2890         goto fail;
2891     *q = '\0';
2892     return 0;
2893  fail:
2894     *q = '\0';
2895     return -1;
2896 }
2897
2898 /**
2899  * Print  nice hexa dump of a buffer
2900  * @param f stream for output
2901  * @param buf buffer
2902  * @param size buffer size
2903  */
2904 void av_hex_dump(FILE *f, uint8_t *buf, int size)
2905 {
2906     int len, i, j, c;
2907
2908     for(i=0;i<size;i+=16) {
2909         len = size - i;
2910         if (len > 16)
2911             len = 16;
2912         fprintf(f, "%08x ", i);
2913         for(j=0;j<16;j++) {
2914             if (j < len)
2915                 fprintf(f, " %02x", buf[i+j]);
2916             else
2917                 fprintf(f, "   ");
2918         }
2919         fprintf(f, " ");
2920         for(j=0;j<len;j++) {
2921             c = buf[i+j];
2922             if (c < ' ' || c > '~')
2923                 c = '.';
2924             fprintf(f, "%c", c);
2925         }
2926         fprintf(f, "\n");
2927     }
2928 }
2929
2930 /**
2931  * Print on 'f' a nice dump of a packet
2932  * @param f stream for output
2933  * @param pkt packet to dump
2934  * @param dump_payload true if the payload must be displayed too
2935  */
2936  //FIXME needs to know the time_base
2937 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
2938 {
2939     fprintf(f, "stream #%d:\n", pkt->stream_index);
2940     fprintf(f, "  keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
2941     fprintf(f, "  duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
2942     /* DTS is _always_ valid after av_read_frame() */
2943     fprintf(f, "  dts=");
2944     if (pkt->dts == AV_NOPTS_VALUE)
2945         fprintf(f, "N/A");
2946     else
2947         fprintf(f, "%0.3f", (double)pkt->dts / AV_TIME_BASE);
2948     /* PTS may be not known if B frames are present */
2949     fprintf(f, "  pts=");
2950     if (pkt->pts == AV_NOPTS_VALUE)
2951         fprintf(f, "N/A");
2952     else
2953         fprintf(f, "%0.3f", (double)pkt->pts / AV_TIME_BASE);
2954     fprintf(f, "\n");
2955     fprintf(f, "  size=%d\n", pkt->size);
2956     if (dump_payload)
2957         av_hex_dump(f, pkt->data, pkt->size);
2958 }
2959
2960 void url_split(char *proto, int proto_size,
2961                char *authorization, int authorization_size,
2962                char *hostname, int hostname_size,
2963                int *port_ptr,
2964                char *path, int path_size,
2965                const char *url)
2966 {
2967     const char *p;
2968     char *q;
2969     int port;
2970
2971     port = -1;
2972
2973     p = url;
2974     q = proto;
2975     while (*p != ':' && *p != '\0') {
2976         if ((q - proto) < proto_size - 1)
2977             *q++ = *p;
2978         p++;
2979     }
2980     if (proto_size > 0)
2981         *q = '\0';
2982     if (authorization_size > 0)
2983         authorization[0] = '\0';
2984     if (*p == '\0') {
2985         if (proto_size > 0)
2986             proto[0] = '\0';
2987         if (hostname_size > 0)
2988             hostname[0] = '\0';
2989         p = url;
2990     } else {
2991         char *at,*slash; // PETR: position of '@' character and '/' character
2992
2993         p++;
2994         if (*p == '/')
2995             p++;
2996         if (*p == '/')
2997             p++;
2998         at = strchr(p,'@'); // PETR: get the position of '@'
2999         slash = strchr(p,'/');  // PETR: get position of '/' - end of hostname
3000         if (at && slash && at > slash) at = NULL; // PETR: not interested in '@' behind '/'
3001
3002         q = at ? authorization : hostname;  // PETR: if '@' exists starting with auth.
3003
3004          while ((at || *p != ':') && *p != '/' && *p != '?' && *p != '\0') { // PETR:
3005             if (*p == '@') {    // PETR: passed '@'
3006               if (authorization_size > 0)
3007                   *q = '\0';
3008               q = hostname;
3009               at = NULL;
3010             } else if (!at) {   // PETR: hostname
3011               if ((q - hostname) < hostname_size - 1)
3012                   *q++ = *p;
3013             } else {
3014               if ((q - authorization) < authorization_size - 1)
3015                 *q++ = *p;
3016             }
3017             p++;
3018         }
3019         if (hostname_size > 0)
3020             *q = '\0';
3021         if (*p == ':') {
3022             p++;
3023             port = strtoul(p, (char **)&p, 10);
3024         }
3025     }
3026     if (port_ptr)
3027         *port_ptr = port;
3028     pstrcpy(path, path_size, p);
3029 }
3030
3031 /**
3032  * Set the pts for a given stream.
3033  *
3034  * @param s stream
3035  * @param pts_wrap_bits number of bits effectively used by the pts
3036  *        (used for wrap control, 33 is the value for MPEG)
3037  * @param pts_num numerator to convert to seconds (MPEG: 1)
3038  * @param pts_den denominator to convert to seconds (MPEG: 90000)
3039  */
3040 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3041                      int pts_num, int pts_den)
3042 {
3043     s->pts_wrap_bits = pts_wrap_bits;
3044     s->time_base.num = pts_num;
3045     s->time_base.den = pts_den;
3046 }
3047
3048 /* fraction handling */
3049
3050 /**
3051  * f = val + (num / den) + 0.5.
3052  *
3053  * 'num' is normalized so that it is such as 0 <= num < den.
3054  *
3055  * @param f fractional number
3056  * @param val integer value
3057  * @param num must be >= 0
3058  * @param den must be >= 1
3059  */
3060 static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
3061 {
3062     num += (den >> 1);
3063     if (num >= den) {
3064         val += num / den;
3065         num = num % den;
3066     }
3067     f->val = val;
3068     f->num = num;
3069     f->den = den;
3070 }
3071
3072 /**
3073  * Set f to (val + 0.5).
3074  */
3075 static void av_frac_set(AVFrac *f, int64_t val)
3076 {
3077     f->val = val;
3078     f->num = f->den >> 1;
3079 }
3080
3081 /**
3082  * Fractionnal addition to f: f = f + (incr / f->den).
3083  *
3084  * @param f fractional number
3085  * @param incr increment, can be positive or negative
3086  */
3087 static void av_frac_add(AVFrac *f, int64_t incr)
3088 {
3089     int64_t num, den;
3090
3091     num = f->num + incr;
3092     den = f->den;
3093     if (num < 0) {
3094         f->val += num / den;
3095         num = num % den;
3096         if (num < 0) {
3097             num += den;
3098             f->val--;
3099         }
3100     } else if (num >= den) {
3101         f->val += num / den;
3102         num = num % den;
3103     }
3104     f->num = num;
3105 }
3106
3107 /**
3108  * register a new image format
3109  * @param img_fmt Image format descriptor
3110  */
3111 void av_register_image_format(AVImageFormat *img_fmt)
3112 {
3113     AVImageFormat **p;
3114
3115     p = &first_image_format;
3116     while (*p != NULL) p = &(*p)->next;
3117     *p = img_fmt;
3118     img_fmt->next = NULL;
3119 }
3120
3121 /**
3122  * Guesses image format based on data in the image.
3123  */
3124 AVImageFormat *av_probe_image_format(AVProbeData *pd)
3125 {
3126     AVImageFormat *fmt1, *fmt;
3127     int score, score_max;
3128
3129     fmt = NULL;
3130     score_max = 0;
3131     for(fmt1 = first_image_format; fmt1 != NULL; fmt1 = fmt1->next) {
3132         if (fmt1->img_probe) {
3133             score = fmt1->img_probe(pd);
3134             if (score > score_max) {
3135                 score_max = score;
3136                 fmt = fmt1;
3137             }
3138         }
3139     }
3140     return fmt;
3141 }
3142
3143 /**
3144  * Guesses image format based on file name extensions.
3145  */
3146 AVImageFormat *guess_image_format(const char *filename)
3147 {
3148     AVImageFormat *fmt1;
3149
3150     for(fmt1 = first_image_format; fmt1 != NULL; fmt1 = fmt1->next) {
3151         if (fmt1->extensions && match_ext(filename, fmt1->extensions))
3152             return fmt1;
3153     }
3154     return NULL;
3155 }
3156
3157 /**
3158  * Read an image from a stream.
3159  * @param gb byte stream containing the image
3160  * @param fmt image format, NULL if probing is required
3161  */
3162 int av_read_image(ByteIOContext *pb, const char *filename,
3163                   AVImageFormat *fmt,
3164                   int (*alloc_cb)(void *, AVImageInfo *info), void *opaque)
3165 {
3166     uint8_t buf[PROBE_BUF_MIN];
3167     AVProbeData probe_data, *pd = &probe_data;
3168     offset_t pos;
3169     int ret;
3170
3171     if (!fmt) {
3172         pd->filename = filename;
3173         pd->buf = buf;
3174         pos = url_ftell(pb);
3175         pd->buf_size = get_buffer(pb, buf, PROBE_BUF_MIN);
3176         url_fseek(pb, pos, SEEK_SET);
3177         fmt = av_probe_image_format(pd);
3178     }
3179     if (!fmt)
3180         return AVERROR_NOFMT;
3181     ret = fmt->img_read(pb, alloc_cb, opaque);
3182     return ret;
3183 }
3184
3185 /**
3186  * Write an image to a stream.
3187  * @param pb byte stream for the image output
3188  * @param fmt image format
3189  * @param img image data and informations
3190  */
3191 int av_write_image(ByteIOContext *pb, AVImageFormat *fmt, AVImageInfo *img)
3192 {
3193     return fmt->img_write(pb, img);
3194 }
3195