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