Export data_to_hex() as private API in lavf, rename to ff_data_to_hex() and
[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 "internal.h"
23 #include "libavcodec/opt.h"
24 #include "libavutil/avstring.h"
25 #include "riff.h"
26 #include <sys/time.h>
27 #include <time.h>
28 #include <strings.h>
29
30 #undef NDEBUG
31 #include <assert.h>
32
33 /**
34  * @file libavformat/utils.c
35  * various utility functions for use within FFmpeg
36  */
37
38 unsigned avformat_version(void)
39 {
40     return LIBAVFORMAT_VERSION_INT;
41 }
42
43 /* fraction handling */
44
45 /**
46  * f = val + (num / den) + 0.5.
47  *
48  * 'num' is normalized so that it is such as 0 <= num < den.
49  *
50  * @param f fractional number
51  * @param val integer value
52  * @param num must be >= 0
53  * @param den must be >= 1
54  */
55 static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
56 {
57     num += (den >> 1);
58     if (num >= den) {
59         val += num / den;
60         num = num % den;
61     }
62     f->val = val;
63     f->num = num;
64     f->den = den;
65 }
66
67 /**
68  * Fractional addition to f: f = f + (incr / f->den).
69  *
70  * @param f fractional number
71  * @param incr increment, can be positive or negative
72  */
73 static void av_frac_add(AVFrac *f, int64_t incr)
74 {
75     int64_t num, den;
76
77     num = f->num + incr;
78     den = f->den;
79     if (num < 0) {
80         f->val += num / den;
81         num = num % den;
82         if (num < 0) {
83             num += den;
84             f->val--;
85         }
86     } else if (num >= den) {
87         f->val += num / den;
88         num = num % den;
89     }
90     f->num = num;
91 }
92
93 /** head of registered input format linked list */
94 AVInputFormat *first_iformat = NULL;
95 /** head of registered output format linked list */
96 AVOutputFormat *first_oformat = NULL;
97
98 AVInputFormat  *av_iformat_next(AVInputFormat  *f)
99 {
100     if(f) return f->next;
101     else  return first_iformat;
102 }
103
104 AVOutputFormat *av_oformat_next(AVOutputFormat *f)
105 {
106     if(f) return f->next;
107     else  return first_oformat;
108 }
109
110 void av_register_input_format(AVInputFormat *format)
111 {
112     AVInputFormat **p;
113     p = &first_iformat;
114     while (*p != NULL) p = &(*p)->next;
115     *p = format;
116     format->next = NULL;
117 }
118
119 void av_register_output_format(AVOutputFormat *format)
120 {
121     AVOutputFormat **p;
122     p = &first_oformat;
123     while (*p != NULL) p = &(*p)->next;
124     *p = format;
125     format->next = NULL;
126 }
127
128 int match_ext(const char *filename, const char *extensions)
129 {
130     const char *ext, *p;
131     char ext1[32], *q;
132
133     if(!filename)
134         return 0;
135
136     ext = strrchr(filename, '.');
137     if (ext) {
138         ext++;
139         p = extensions;
140         for(;;) {
141             q = ext1;
142             while (*p != '\0' && *p != ',' && q-ext1<sizeof(ext1)-1)
143                 *q++ = *p++;
144             *q = '\0';
145             if (!strcasecmp(ext1, ext))
146                 return 1;
147             if (*p == '\0')
148                 break;
149             p++;
150         }
151     }
152     return 0;
153 }
154
155 AVOutputFormat *guess_format(const char *short_name, const char *filename,
156                              const char *mime_type)
157 {
158     AVOutputFormat *fmt, *fmt_found;
159     int score_max, score;
160
161     /* specific test for image sequences */
162 #ifdef CONFIG_IMAGE2_MUXER
163     if (!short_name && filename &&
164         av_filename_number_test(filename) &&
165         av_guess_image2_codec(filename) != CODEC_ID_NONE) {
166         return guess_format("image2", NULL, NULL);
167     }
168 #endif
169     /* Find the proper file type. */
170     fmt_found = NULL;
171     score_max = 0;
172     fmt = first_oformat;
173     while (fmt != NULL) {
174         score = 0;
175         if (fmt->name && short_name && !strcmp(fmt->name, short_name))
176             score += 100;
177         if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
178             score += 10;
179         if (filename && fmt->extensions &&
180             match_ext(filename, fmt->extensions)) {
181             score += 5;
182         }
183         if (score > score_max) {
184             score_max = score;
185             fmt_found = fmt;
186         }
187         fmt = fmt->next;
188     }
189     return fmt_found;
190 }
191
192 AVOutputFormat *guess_stream_format(const char *short_name, const char *filename,
193                              const char *mime_type)
194 {
195     AVOutputFormat *fmt = guess_format(short_name, filename, mime_type);
196
197     if (fmt) {
198         AVOutputFormat *stream_fmt;
199         char stream_format_name[64];
200
201         snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
202         stream_fmt = guess_format(stream_format_name, NULL, NULL);
203
204         if (stream_fmt)
205             fmt = stream_fmt;
206     }
207
208     return fmt;
209 }
210
211 enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
212                             const char *filename, const char *mime_type, enum CodecType type){
213     if(type == CODEC_TYPE_VIDEO){
214         enum CodecID codec_id= CODEC_ID_NONE;
215
216 #ifdef CONFIG_IMAGE2_MUXER
217         if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
218             codec_id= av_guess_image2_codec(filename);
219         }
220 #endif
221         if(codec_id == CODEC_ID_NONE)
222             codec_id= fmt->video_codec;
223         return codec_id;
224     }else if(type == CODEC_TYPE_AUDIO)
225         return fmt->audio_codec;
226     else
227         return CODEC_ID_NONE;
228 }
229
230 AVInputFormat *av_find_input_format(const char *short_name)
231 {
232     AVInputFormat *fmt;
233     for(fmt = first_iformat; fmt != NULL; fmt = fmt->next) {
234         if (!strcmp(fmt->name, short_name))
235             return fmt;
236     }
237     return NULL;
238 }
239
240 /* memory handling */
241
242 void av_destruct_packet(AVPacket *pkt)
243 {
244     av_free(pkt->data);
245     pkt->data = NULL; pkt->size = 0;
246 }
247
248 void av_init_packet(AVPacket *pkt)
249 {
250     pkt->pts   = AV_NOPTS_VALUE;
251     pkt->dts   = AV_NOPTS_VALUE;
252     pkt->pos   = -1;
253     pkt->duration = 0;
254     pkt->flags = 0;
255     pkt->stream_index = 0;
256     pkt->destruct= av_destruct_packet_nofree;
257 }
258
259 int av_new_packet(AVPacket *pkt, int size)
260 {
261     uint8_t *data;
262     if((unsigned)size > (unsigned)size + FF_INPUT_BUFFER_PADDING_SIZE)
263         return AVERROR(ENOMEM);
264     data = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
265     if (!data)
266         return AVERROR(ENOMEM);
267     memset(data + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
268
269     av_init_packet(pkt);
270     pkt->data = data;
271     pkt->size = size;
272     pkt->destruct = av_destruct_packet;
273     return 0;
274 }
275
276 int av_get_packet(ByteIOContext *s, AVPacket *pkt, int size)
277 {
278     int ret= av_new_packet(pkt, size);
279
280     if(ret<0)
281         return ret;
282
283     pkt->pos= url_ftell(s);
284
285     ret= get_buffer(s, pkt->data, size);
286     if(ret<=0)
287         av_free_packet(pkt);
288     else
289         pkt->size= ret;
290
291     return ret;
292 }
293
294 int av_dup_packet(AVPacket *pkt)
295 {
296     if (pkt->destruct != av_destruct_packet) {
297         uint8_t *data;
298         /* We duplicate the packet and don't forget to add the padding again. */
299         if((unsigned)pkt->size > (unsigned)pkt->size + FF_INPUT_BUFFER_PADDING_SIZE)
300             return AVERROR(ENOMEM);
301         data = av_malloc(pkt->size + FF_INPUT_BUFFER_PADDING_SIZE);
302         if (!data) {
303             return AVERROR(ENOMEM);
304         }
305         memcpy(data, pkt->data, pkt->size);
306         memset(data + pkt->size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
307         pkt->data = data;
308         pkt->destruct = av_destruct_packet;
309     }
310     return 0;
311 }
312
313 int av_filename_number_test(const char *filename)
314 {
315     char buf[1024];
316     return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
317 }
318
319 static AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
320 {
321     AVInputFormat *fmt1, *fmt;
322     int score;
323
324     fmt = NULL;
325     for(fmt1 = first_iformat; fmt1 != NULL; fmt1 = fmt1->next) {
326         if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
327             continue;
328         score = 0;
329         if (fmt1->read_probe) {
330             score = fmt1->read_probe(pd);
331         } else if (fmt1->extensions) {
332             if (match_ext(pd->filename, fmt1->extensions)) {
333                 score = 50;
334             }
335         }
336         if (score > *score_max) {
337             *score_max = score;
338             fmt = fmt1;
339         }else if (score == *score_max)
340             fmt = NULL;
341     }
342     return fmt;
343 }
344
345 AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
346     int score=0;
347     return av_probe_input_format2(pd, is_opened, &score);
348 }
349
350 static int set_codec_from_probe_data(AVStream *st, AVProbeData *pd, int score)
351 {
352     AVInputFormat *fmt;
353     fmt = av_probe_input_format2(pd, 1, &score);
354
355     if (fmt) {
356         if (!strcmp(fmt->name, "mp3")) {
357             st->codec->codec_id = CODEC_ID_MP3;
358             st->codec->codec_type = CODEC_TYPE_AUDIO;
359         } else if (!strcmp(fmt->name, "ac3")) {
360             st->codec->codec_id = CODEC_ID_AC3;
361             st->codec->codec_type = CODEC_TYPE_AUDIO;
362         } else if (!strcmp(fmt->name, "mpegvideo")) {
363             st->codec->codec_id = CODEC_ID_MPEG2VIDEO;
364             st->codec->codec_type = CODEC_TYPE_VIDEO;
365         } else if (!strcmp(fmt->name, "h264")) {
366             st->codec->codec_id = CODEC_ID_H264;
367             st->codec->codec_type = CODEC_TYPE_VIDEO;
368         }
369     }
370     return !!fmt;
371 }
372
373 /************************************************************/
374 /* input media file */
375
376 /**
377  * Open a media file from an IO stream. 'fmt' must be specified.
378  */
379 static const char* format_to_name(void* ptr)
380 {
381     AVFormatContext* fc = (AVFormatContext*) ptr;
382     if(fc->iformat) return fc->iformat->name;
383     else if(fc->oformat) return fc->oformat->name;
384     else return "NULL";
385 }
386
387 #define OFFSET(x) offsetof(AVFormatContext,x)
388 #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
389 //these names are too long to be readable
390 #define E AV_OPT_FLAG_ENCODING_PARAM
391 #define D AV_OPT_FLAG_DECODING_PARAM
392
393 static const AVOption options[]={
394 {"probesize", NULL, OFFSET(probesize), FF_OPT_TYPE_INT, 32000, 32, INT_MAX, D}, /* 32000 from mpegts.c: 1.0 second at 24Mbit/s */
395 {"muxrate", "set mux rate", OFFSET(mux_rate), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
396 {"packetsize", "set packet size", OFFSET(packet_size), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
397 {"fflags", NULL, OFFSET(flags), FF_OPT_TYPE_FLAGS, DEFAULT, INT_MIN, INT_MAX, D|E, "fflags"},
398 {"ignidx", "ignore index", 0, FF_OPT_TYPE_CONST, AVFMT_FLAG_IGNIDX, INT_MIN, INT_MAX, D, "fflags"},
399 {"genpts", "generate pts", 0, FF_OPT_TYPE_CONST, AVFMT_FLAG_GENPTS, INT_MIN, INT_MAX, D, "fflags"},
400 {"track", " set the track number", OFFSET(track), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
401 {"year", "set the year", OFFSET(year), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, E},
402 {"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},
403 {"cryptokey", "decryption key", OFFSET(key), FF_OPT_TYPE_BINARY, 0, 0, 0, D},
404 {"indexmem", "max memory used for timestamp index (per stream)", OFFSET(max_index_size), FF_OPT_TYPE_INT, 1<<20, 0, INT_MAX, D},
405 {"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 */
406 {"fdebug", "print specific debug info", OFFSET(debug), FF_OPT_TYPE_FLAGS, DEFAULT, 0, INT_MAX, E|D, "fdebug"},
407 {"ts", NULL, 0, FF_OPT_TYPE_CONST, FF_FDEBUG_TS, INT_MIN, INT_MAX, E|D, "fdebug"},
408 {NULL},
409 };
410
411 #undef E
412 #undef D
413 #undef DEFAULT
414
415 static const AVClass av_format_context_class = { "AVFormatContext", format_to_name, options };
416
417 static void avformat_get_context_defaults(AVFormatContext *s)
418 {
419     memset(s, 0, sizeof(AVFormatContext));
420
421     s->av_class = &av_format_context_class;
422
423     av_opt_set_defaults(s);
424 }
425
426 AVFormatContext *av_alloc_format_context(void)
427 {
428     AVFormatContext *ic;
429     ic = av_malloc(sizeof(AVFormatContext));
430     if (!ic) return ic;
431     avformat_get_context_defaults(ic);
432     ic->av_class = &av_format_context_class;
433     return ic;
434 }
435
436 int av_open_input_stream(AVFormatContext **ic_ptr,
437                          ByteIOContext *pb, const char *filename,
438                          AVInputFormat *fmt, AVFormatParameters *ap)
439 {
440     int err;
441     AVFormatContext *ic;
442     AVFormatParameters default_ap;
443
444     if(!ap){
445         ap=&default_ap;
446         memset(ap, 0, sizeof(default_ap));
447     }
448
449     if(!ap->prealloced_context)
450         ic = av_alloc_format_context();
451     else
452         ic = *ic_ptr;
453     if (!ic) {
454         err = AVERROR(ENOMEM);
455         goto fail;
456     }
457     ic->iformat = fmt;
458     ic->pb = pb;
459     ic->duration = AV_NOPTS_VALUE;
460     ic->start_time = AV_NOPTS_VALUE;
461     av_strlcpy(ic->filename, filename, sizeof(ic->filename));
462
463     /* allocate private data */
464     if (fmt->priv_data_size > 0) {
465         ic->priv_data = av_mallocz(fmt->priv_data_size);
466         if (!ic->priv_data) {
467             err = AVERROR(ENOMEM);
468             goto fail;
469         }
470     } else {
471         ic->priv_data = NULL;
472     }
473
474     if (ic->iformat->read_header) {
475         err = ic->iformat->read_header(ic, ap);
476         if (err < 0)
477             goto fail;
478     }
479
480     if (pb && !ic->data_offset)
481         ic->data_offset = url_ftell(ic->pb);
482
483     *ic_ptr = ic;
484     return 0;
485  fail:
486     if (ic) {
487         int i;
488         av_freep(&ic->priv_data);
489         for(i=0;i<ic->nb_streams;i++) {
490             AVStream *st = ic->streams[i];
491             if (st) {
492                 av_free(st->priv_data);
493                 av_free(st->codec->extradata);
494             }
495             av_free(st);
496         }
497     }
498     av_free(ic);
499     *ic_ptr = NULL;
500     return err;
501 }
502
503 /** size of probe buffer, for guessing file type from file contents */
504 #define PROBE_BUF_MIN 2048
505 #define PROBE_BUF_MAX (1<<20)
506
507 int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
508                        AVInputFormat *fmt,
509                        int buf_size,
510                        AVFormatParameters *ap)
511 {
512     int err, probe_size;
513     AVProbeData probe_data, *pd = &probe_data;
514     ByteIOContext *pb = NULL;
515
516     pd->filename = "";
517     if (filename)
518         pd->filename = filename;
519     pd->buf = NULL;
520     pd->buf_size = 0;
521
522     if (!fmt) {
523         /* guess format if no file can be opened */
524         fmt = av_probe_input_format(pd, 0);
525     }
526
527     /* Do not open file if the format does not need it. XXX: specific
528        hack needed to handle RTSP/TCP */
529     if (!fmt || !(fmt->flags & AVFMT_NOFILE)) {
530         /* if no file needed do not try to open one */
531         if ((err=url_fopen(&pb, filename, URL_RDONLY)) < 0) {
532             goto fail;
533         }
534         if (buf_size > 0) {
535             url_setbufsize(pb, buf_size);
536         }
537
538         for(probe_size= PROBE_BUF_MIN; probe_size<=PROBE_BUF_MAX && !fmt; probe_size<<=1){
539             int score= probe_size < PROBE_BUF_MAX ? AVPROBE_SCORE_MAX/4 : 0;
540             /* read probe data */
541             pd->buf= av_realloc(pd->buf, probe_size + AVPROBE_PADDING_SIZE);
542             pd->buf_size = get_buffer(pb, pd->buf, probe_size);
543             memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
544             if (url_fseek(pb, 0, SEEK_SET) < 0) {
545                 url_fclose(pb);
546                 if (url_fopen(&pb, filename, URL_RDONLY) < 0) {
547                     pb = NULL;
548                     err = AVERROR(EIO);
549                     goto fail;
550                 }
551             }
552             /* guess file format */
553             fmt = av_probe_input_format2(pd, 1, &score);
554         }
555         av_freep(&pd->buf);
556     }
557
558     /* if still no format found, error */
559     if (!fmt) {
560         err = AVERROR_NOFMT;
561         goto fail;
562     }
563
564     /* check filename in case an image number is expected */
565     if (fmt->flags & AVFMT_NEEDNUMBER) {
566         if (!av_filename_number_test(filename)) {
567             err = AVERROR_NUMEXPECTED;
568             goto fail;
569         }
570     }
571     err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
572     if (err)
573         goto fail;
574     return 0;
575  fail:
576     av_freep(&pd->buf);
577     if (pb)
578         url_fclose(pb);
579     *ic_ptr = NULL;
580     return err;
581
582 }
583
584 /*******************************************************/
585
586 static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
587                                AVPacketList **plast_pktl){
588     AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
589     if (!pktl)
590         return NULL;
591
592     if (*packet_buffer)
593         (*plast_pktl)->next = pktl;
594     else
595         *packet_buffer = pktl;
596
597     /* add the packet in the buffered packet list */
598     *plast_pktl = pktl;
599     pktl->pkt= *pkt;
600     return &pktl->pkt;
601 }
602
603 int av_read_packet(AVFormatContext *s, AVPacket *pkt)
604 {
605     int ret;
606     AVStream *st;
607
608     for(;;){
609         AVPacketList *pktl = s->raw_packet_buffer;
610
611         if (pktl) {
612             *pkt = pktl->pkt;
613             if(s->streams[pkt->stream_index]->codec->codec_id != CODEC_ID_PROBE){
614                 s->raw_packet_buffer = pktl->next;
615                 av_free(pktl);
616                 return 0;
617             }
618         }
619
620         av_init_packet(pkt);
621         ret= s->iformat->read_packet(s, pkt);
622         if (ret < 0)
623             return ret;
624         st= s->streams[pkt->stream_index];
625
626         switch(st->codec->codec_type){
627         case CODEC_TYPE_VIDEO:
628             if(s->video_codec_id)   st->codec->codec_id= s->video_codec_id;
629             break;
630         case CODEC_TYPE_AUDIO:
631             if(s->audio_codec_id)   st->codec->codec_id= s->audio_codec_id;
632             break;
633         case CODEC_TYPE_SUBTITLE:
634             if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
635             break;
636         }
637
638         if(!pktl && st->codec->codec_id!=CODEC_ID_PROBE)
639             return ret;
640
641         add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
642
643         if(st->codec->codec_id == CODEC_ID_PROBE){
644             AVProbeData *pd = &st->probe_data;
645
646             pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
647             memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
648             pd->buf_size += pkt->size;
649             memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
650
651             if(av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)){
652                 set_codec_from_probe_data(st, pd, 1);
653                 if(st->codec->codec_id != CODEC_ID_PROBE){
654                     pd->buf_size=0;
655                     av_freep(&pd->buf);
656                 }
657             }
658         }
659     }
660 }
661
662 /**********************************************************/
663
664 /**
665  * Get the number of samples of an audio frame. Return -1 on error.
666  */
667 static int get_audio_frame_size(AVCodecContext *enc, int size)
668 {
669     int frame_size;
670
671     if(enc->codec_id == CODEC_ID_VORBIS)
672         return -1;
673
674     if (enc->frame_size <= 1) {
675         int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
676
677         if (bits_per_sample) {
678             if (enc->channels == 0)
679                 return -1;
680             frame_size = (size << 3) / (bits_per_sample * enc->channels);
681         } else {
682             /* used for example by ADPCM codecs */
683             if (enc->bit_rate == 0)
684                 return -1;
685             frame_size = (size * 8 * enc->sample_rate) / enc->bit_rate;
686         }
687     } else {
688         frame_size = enc->frame_size;
689     }
690     return frame_size;
691 }
692
693
694 /**
695  * Return the frame duration in seconds. Return 0 if not available.
696  */
697 static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
698                                    AVCodecParserContext *pc, AVPacket *pkt)
699 {
700     int frame_size;
701
702     *pnum = 0;
703     *pden = 0;
704     switch(st->codec->codec_type) {
705     case CODEC_TYPE_VIDEO:
706         if(st->time_base.num*1000LL > st->time_base.den){
707             *pnum = st->time_base.num;
708             *pden = st->time_base.den;
709         }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
710             *pnum = st->codec->time_base.num;
711             *pden = st->codec->time_base.den;
712             if (pc && pc->repeat_pict) {
713                 *pden *= 2;
714                 *pnum = (*pnum) * (2 + pc->repeat_pict);
715             }
716         }
717         break;
718     case CODEC_TYPE_AUDIO:
719         frame_size = get_audio_frame_size(st->codec, pkt->size);
720         if (frame_size < 0)
721             break;
722         *pnum = frame_size;
723         *pden = st->codec->sample_rate;
724         break;
725     default:
726         break;
727     }
728 }
729
730 static int is_intra_only(AVCodecContext *enc){
731     if(enc->codec_type == CODEC_TYPE_AUDIO){
732         return 1;
733     }else if(enc->codec_type == CODEC_TYPE_VIDEO){
734         switch(enc->codec_id){
735         case CODEC_ID_MJPEG:
736         case CODEC_ID_MJPEGB:
737         case CODEC_ID_LJPEG:
738         case CODEC_ID_RAWVIDEO:
739         case CODEC_ID_DVVIDEO:
740         case CODEC_ID_HUFFYUV:
741         case CODEC_ID_FFVHUFF:
742         case CODEC_ID_ASV1:
743         case CODEC_ID_ASV2:
744         case CODEC_ID_VCR1:
745             return 1;
746         default: break;
747         }
748     }
749     return 0;
750 }
751
752 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
753                                       int64_t dts, int64_t pts)
754 {
755     AVStream *st= s->streams[stream_index];
756     AVPacketList *pktl= s->packet_buffer;
757
758     if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE)
759         return;
760
761     st->first_dts= dts - st->cur_dts;
762     st->cur_dts= dts;
763
764     for(; pktl; pktl= pktl->next){
765         if(pktl->pkt.stream_index != stream_index)
766             continue;
767         //FIXME think more about this check
768         if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
769             pktl->pkt.pts += st->first_dts;
770
771         if(pktl->pkt.dts != AV_NOPTS_VALUE)
772             pktl->pkt.dts += st->first_dts;
773
774         if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
775             st->start_time= pktl->pkt.pts;
776     }
777     if (st->start_time == AV_NOPTS_VALUE)
778         st->start_time = pts;
779 }
780
781 static void update_initial_durations(AVFormatContext *s, AVStream *st, AVPacket *pkt)
782 {
783     AVPacketList *pktl= s->packet_buffer;
784     int64_t cur_dts= 0;
785
786     if(st->first_dts != AV_NOPTS_VALUE){
787         cur_dts= st->first_dts;
788         for(; pktl; pktl= pktl->next){
789             if(pktl->pkt.stream_index == pkt->stream_index){
790                 if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
791                     break;
792                 cur_dts -= pkt->duration;
793             }
794         }
795         pktl= s->packet_buffer;
796         st->first_dts = cur_dts;
797     }else if(st->cur_dts)
798         return;
799
800     for(; pktl; pktl= pktl->next){
801         if(pktl->pkt.stream_index != pkt->stream_index)
802             continue;
803         if(pktl->pkt.pts == pktl->pkt.dts && pktl->pkt.dts == AV_NOPTS_VALUE
804            && !pktl->pkt.duration){
805             pktl->pkt.dts= cur_dts;
806             if(!st->codec->has_b_frames)
807                 pktl->pkt.pts= cur_dts;
808             cur_dts += pkt->duration;
809             pktl->pkt.duration= pkt->duration;
810         }else
811             break;
812     }
813     if(st->first_dts == AV_NOPTS_VALUE)
814         st->cur_dts= cur_dts;
815 }
816
817 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
818                                AVCodecParserContext *pc, AVPacket *pkt)
819 {
820     int num, den, presentation_delayed, delay, i;
821     int64_t offset;
822
823     if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
824        /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
825         pkt->dts -= 1LL<<st->pts_wrap_bits;
826     }
827
828     if (pkt->duration == 0) {
829         compute_frame_duration(&num, &den, st, pc, pkt);
830         if (den && num) {
831             pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
832
833             if(pkt->duration != 0 && s->packet_buffer)
834                 update_initial_durations(s, st, pkt);
835         }
836     }
837
838     /* correct timestamps with byte offset if demuxers only have timestamps
839        on packet boundaries */
840     if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
841         /* this will estimate bitrate based on this frame's duration and size */
842         offset = av_rescale(pc->offset, pkt->duration, pkt->size);
843         if(pkt->pts != AV_NOPTS_VALUE)
844             pkt->pts += offset;
845         if(pkt->dts != AV_NOPTS_VALUE)
846             pkt->dts += offset;
847     }
848
849     /* do we have a video B-frame ? */
850     delay= st->codec->has_b_frames;
851     presentation_delayed = 0;
852     /* XXX: need has_b_frame, but cannot get it if the codec is
853         not initialized */
854     if (delay &&
855         pc && pc->pict_type != FF_B_TYPE)
856         presentation_delayed = 1;
857     /* This may be redundant, but it should not hurt. */
858     if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
859         presentation_delayed = 1;
860
861 //    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);
862     /* interpolate PTS and DTS if they are not present */
863     if(delay==0 || (delay==1 && pc)){
864         if (presentation_delayed) {
865             /* DTS = decompression timestamp */
866             /* PTS = presentation timestamp */
867             if (pkt->dts == AV_NOPTS_VALUE)
868                 pkt->dts = st->last_IP_pts;
869             update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
870             if (pkt->dts == AV_NOPTS_VALUE)
871                 pkt->dts = st->cur_dts;
872
873             /* this is tricky: the dts must be incremented by the duration
874             of the frame we are displaying, i.e. the last I- or P-frame */
875             if (st->last_IP_duration == 0)
876                 st->last_IP_duration = pkt->duration;
877             if(pkt->dts != AV_NOPTS_VALUE)
878                 st->cur_dts = pkt->dts + st->last_IP_duration;
879             st->last_IP_duration  = pkt->duration;
880             st->last_IP_pts= pkt->pts;
881             /* cannot compute PTS if not present (we can compute it only
882             by knowing the future */
883         } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
884             if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
885                 int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
886                 int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
887                 if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
888                     pkt->pts += pkt->duration;
889     //                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);
890                 }
891             }
892
893             /* presentation is not delayed : PTS and DTS are the same */
894             if(pkt->pts == AV_NOPTS_VALUE)
895                 pkt->pts = pkt->dts;
896             update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
897             if(pkt->pts == AV_NOPTS_VALUE)
898                 pkt->pts = st->cur_dts;
899             pkt->dts = pkt->pts;
900             if(pkt->pts != AV_NOPTS_VALUE)
901                 st->cur_dts = pkt->pts + pkt->duration;
902         }
903     }
904
905     if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
906         st->pts_buffer[0]= pkt->pts;
907         for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
908             FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
909         if(pkt->dts == AV_NOPTS_VALUE)
910             pkt->dts= st->pts_buffer[0];
911         if(delay>1){
912             update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
913         }
914         if(pkt->dts > st->cur_dts)
915             st->cur_dts = pkt->dts;
916     }
917
918 //    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);
919
920     /* update flags */
921     if(is_intra_only(st->codec))
922         pkt->flags |= PKT_FLAG_KEY;
923     else if (pc) {
924         pkt->flags = 0;
925         /* keyframe computation */
926             if (pc->pict_type == FF_I_TYPE)
927                 pkt->flags |= PKT_FLAG_KEY;
928     }
929 }
930
931 void av_destruct_packet_nofree(AVPacket *pkt)
932 {
933     pkt->data = NULL; pkt->size = 0;
934 }
935
936 static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
937 {
938     AVStream *st;
939     int len, ret, i;
940
941     av_init_packet(pkt);
942
943     for(;;) {
944         /* select current input stream component */
945         st = s->cur_st;
946         if (st) {
947             if (!st->need_parsing || !st->parser) {
948                 /* no parsing needed: we just output the packet as is */
949                 /* raw data support */
950                 *pkt = s->cur_pkt;
951                 compute_pkt_fields(s, st, NULL, pkt);
952                 s->cur_st = NULL;
953                 break;
954             } else if (s->cur_len > 0 && st->discard < AVDISCARD_ALL) {
955                 len = av_parser_parse(st->parser, st->codec, &pkt->data, &pkt->size,
956                                       s->cur_ptr, s->cur_len,
957                                       s->cur_pkt.pts, s->cur_pkt.dts);
958                 s->cur_pkt.pts = AV_NOPTS_VALUE;
959                 s->cur_pkt.dts = AV_NOPTS_VALUE;
960                 /* increment read pointer */
961                 s->cur_ptr += len;
962                 s->cur_len -= len;
963
964                 /* return packet if any */
965                 if (pkt->size) {
966                 got_packet:
967                     pkt->pos = s->cur_pkt.pos;              // Isn't quite accurate but close.
968                     pkt->duration = 0;
969                     pkt->stream_index = st->index;
970                     pkt->pts = st->parser->pts;
971                     pkt->dts = st->parser->dts;
972                     pkt->destruct = av_destruct_packet_nofree;
973                     compute_pkt_fields(s, st, st->parser, pkt);
974
975                     if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & PKT_FLAG_KEY){
976                         ff_reduce_index(s, st->index);
977                         av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
978                                            0, 0, AVINDEX_KEYFRAME);
979                     }
980
981                     break;
982                 }
983             } else {
984                 /* free packet */
985                 av_free_packet(&s->cur_pkt);
986                 s->cur_st = NULL;
987             }
988         } else {
989             /* read next packet */
990             ret = av_read_packet(s, &s->cur_pkt);
991             if (ret < 0) {
992                 if (ret == AVERROR(EAGAIN))
993                     return ret;
994                 /* return the last frames, if any */
995                 for(i = 0; i < s->nb_streams; i++) {
996                     st = s->streams[i];
997                     if (st->parser && st->need_parsing) {
998                         av_parser_parse(st->parser, st->codec,
999                                         &pkt->data, &pkt->size,
1000                                         NULL, 0,
1001                                         AV_NOPTS_VALUE, AV_NOPTS_VALUE);
1002                         if (pkt->size)
1003                             goto got_packet;
1004                     }
1005                 }
1006                 /* no more packets: really terminate parsing */
1007                 return ret;
1008             }
1009
1010             if(s->cur_pkt.pts != AV_NOPTS_VALUE &&
1011                s->cur_pkt.dts != AV_NOPTS_VALUE &&
1012                s->cur_pkt.pts < s->cur_pkt.dts){
1013                 av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
1014                     s->cur_pkt.stream_index,
1015                     s->cur_pkt.pts,
1016                     s->cur_pkt.dts,
1017                     s->cur_pkt.size);
1018 //                av_free_packet(&s->cur_pkt);
1019 //                return -1;
1020             }
1021
1022             st = s->streams[s->cur_pkt.stream_index];
1023             if(s->debug & FF_FDEBUG_TS)
1024                 av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d,  flags=%d\n",
1025                     s->cur_pkt.stream_index,
1026                     s->cur_pkt.pts,
1027                     s->cur_pkt.dts,
1028                     s->cur_pkt.size,
1029                     s->cur_pkt.flags);
1030
1031             s->cur_st = st;
1032             s->cur_ptr = s->cur_pkt.data;
1033             s->cur_len = s->cur_pkt.size;
1034             if (st->need_parsing && !st->parser) {
1035                 st->parser = av_parser_init(st->codec->codec_id);
1036                 if (!st->parser) {
1037                     /* no parser available: just output the raw packets */
1038                     st->need_parsing = AVSTREAM_PARSE_NONE;
1039                 }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
1040                     st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1041                 }
1042                 if(st->parser && (s->iformat->flags & AVFMT_GENERIC_INDEX)){
1043                     st->parser->next_frame_offset=
1044                     st->parser->cur_offset= s->cur_pkt.pos;
1045                 }
1046             }
1047         }
1048     }
1049     if(s->debug & FF_FDEBUG_TS)
1050         av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, flags=%d\n",
1051             pkt->stream_index,
1052             pkt->pts,
1053             pkt->dts,
1054             pkt->size,
1055             pkt->flags);
1056
1057     return 0;
1058 }
1059
1060 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1061 {
1062     AVPacketList *pktl;
1063     int eof=0;
1064     const int genpts= s->flags & AVFMT_FLAG_GENPTS;
1065
1066     for(;;){
1067         pktl = s->packet_buffer;
1068         if (pktl) {
1069             AVPacket *next_pkt= &pktl->pkt;
1070
1071             if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
1072                 while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
1073                     if(   pktl->pkt.stream_index == next_pkt->stream_index
1074                        && next_pkt->dts < pktl->pkt.dts
1075                        && pktl->pkt.pts != pktl->pkt.dts //not b frame
1076                        /*&& pktl->pkt.dts != AV_NOPTS_VALUE*/){
1077                         next_pkt->pts= pktl->pkt.dts;
1078                     }
1079                     pktl= pktl->next;
1080                 }
1081                 pktl = s->packet_buffer;
1082             }
1083
1084             if(   next_pkt->pts != AV_NOPTS_VALUE
1085                || next_pkt->dts == AV_NOPTS_VALUE
1086                || !genpts || eof){
1087                 /* read packet from packet buffer, if there is data */
1088                 *pkt = *next_pkt;
1089                 s->packet_buffer = pktl->next;
1090                 av_free(pktl);
1091                 return 0;
1092             }
1093         }
1094         if(genpts){
1095             int ret= av_read_frame_internal(s, pkt);
1096             if(ret<0){
1097                 if(pktl && ret != AVERROR(EAGAIN)){
1098                     eof=1;
1099                     continue;
1100                 }else
1101                     return ret;
1102             }
1103
1104             if(av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1105                                            &s->packet_buffer_end)) < 0)
1106                 return AVERROR(ENOMEM);
1107         }else{
1108             assert(!s->packet_buffer);
1109             return av_read_frame_internal(s, pkt);
1110         }
1111     }
1112 }
1113
1114 /* XXX: suppress the packet queue */
1115 static void flush_packet_queue(AVFormatContext *s)
1116 {
1117     AVPacketList *pktl;
1118
1119     for(;;) {
1120         pktl = s->packet_buffer;
1121         if (!pktl)
1122             break;
1123         s->packet_buffer = pktl->next;
1124         av_free_packet(&pktl->pkt);
1125         av_free(pktl);
1126     }
1127 }
1128
1129 /*******************************************************/
1130 /* seek support */
1131
1132 int av_find_default_stream_index(AVFormatContext *s)
1133 {
1134     int first_audio_index = -1;
1135     int i;
1136     AVStream *st;
1137
1138     if (s->nb_streams <= 0)
1139         return -1;
1140     for(i = 0; i < s->nb_streams; i++) {
1141         st = s->streams[i];
1142         if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1143             return i;
1144         }
1145         if (first_audio_index < 0 && st->codec->codec_type == CODEC_TYPE_AUDIO)
1146             first_audio_index = i;
1147     }
1148     return first_audio_index >= 0 ? first_audio_index : 0;
1149 }
1150
1151 /**
1152  * Flush the frame reader.
1153  */
1154 static void av_read_frame_flush(AVFormatContext *s)
1155 {
1156     AVStream *st;
1157     int i;
1158
1159     flush_packet_queue(s);
1160
1161     /* free previous packet */
1162     if (s->cur_st) {
1163         if (s->cur_st->parser)
1164             av_free_packet(&s->cur_pkt);
1165         s->cur_st = NULL;
1166     }
1167     /* fail safe */
1168     s->cur_ptr = NULL;
1169     s->cur_len = 0;
1170
1171     /* for each stream, reset read state */
1172     for(i = 0; i < s->nb_streams; i++) {
1173         st = s->streams[i];
1174
1175         if (st->parser) {
1176             av_parser_close(st->parser);
1177             st->parser = NULL;
1178         }
1179         st->last_IP_pts = AV_NOPTS_VALUE;
1180         st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1181     }
1182 }
1183
1184 void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1185     int i;
1186
1187     for(i = 0; i < s->nb_streams; i++) {
1188         AVStream *st = s->streams[i];
1189
1190         st->cur_dts = av_rescale(timestamp,
1191                                  st->time_base.den * (int64_t)ref_st->time_base.num,
1192                                  st->time_base.num * (int64_t)ref_st->time_base.den);
1193     }
1194 }
1195
1196 void ff_reduce_index(AVFormatContext *s, int stream_index)
1197 {
1198     AVStream *st= s->streams[stream_index];
1199     unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1200
1201     if((unsigned)st->nb_index_entries >= max_entries){
1202         int i;
1203         for(i=0; 2*i<st->nb_index_entries; i++)
1204             st->index_entries[i]= st->index_entries[2*i];
1205         st->nb_index_entries= i;
1206     }
1207 }
1208
1209 int av_add_index_entry(AVStream *st,
1210                             int64_t pos, int64_t timestamp, int size, int distance, int flags)
1211 {
1212     AVIndexEntry *entries, *ie;
1213     int index;
1214
1215     if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1216         return -1;
1217
1218     entries = av_fast_realloc(st->index_entries,
1219                               &st->index_entries_allocated_size,
1220                               (st->nb_index_entries + 1) *
1221                               sizeof(AVIndexEntry));
1222     if(!entries)
1223         return -1;
1224
1225     st->index_entries= entries;
1226
1227     index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
1228
1229     if(index<0){
1230         index= st->nb_index_entries++;
1231         ie= &entries[index];
1232         assert(index==0 || ie[-1].timestamp < timestamp);
1233     }else{
1234         ie= &entries[index];
1235         if(ie->timestamp != timestamp){
1236             if(ie->timestamp <= timestamp)
1237                 return -1;
1238             memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
1239             st->nb_index_entries++;
1240         }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1241             distance= ie->min_distance;
1242     }
1243
1244     ie->pos = pos;
1245     ie->timestamp = timestamp;
1246     ie->min_distance= distance;
1247     ie->size= size;
1248     ie->flags = flags;
1249
1250     return index;
1251 }
1252
1253 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1254                               int flags)
1255 {
1256     AVIndexEntry *entries= st->index_entries;
1257     int nb_entries= st->nb_index_entries;
1258     int a, b, m;
1259     int64_t timestamp;
1260
1261     a = - 1;
1262     b = nb_entries;
1263
1264     while (b - a > 1) {
1265         m = (a + b) >> 1;
1266         timestamp = entries[m].timestamp;
1267         if(timestamp >= wanted_timestamp)
1268             b = m;
1269         if(timestamp <= wanted_timestamp)
1270             a = m;
1271     }
1272     m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1273
1274     if(!(flags & AVSEEK_FLAG_ANY)){
1275         while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1276             m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1277         }
1278     }
1279
1280     if(m == nb_entries)
1281         return -1;
1282     return  m;
1283 }
1284
1285 #define DEBUG_SEEK
1286
1287 int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1288     AVInputFormat *avif= s->iformat;
1289     int64_t pos_min, pos_max, pos, pos_limit;
1290     int64_t ts_min, ts_max, ts;
1291     int index;
1292     AVStream *st;
1293
1294     if (stream_index < 0)
1295         return -1;
1296
1297 #ifdef DEBUG_SEEK
1298     av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1299 #endif
1300
1301     ts_max=
1302     ts_min= AV_NOPTS_VALUE;
1303     pos_limit= -1; //gcc falsely says it may be uninitialized
1304
1305     st= s->streams[stream_index];
1306     if(st->index_entries){
1307         AVIndexEntry *e;
1308
1309         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()
1310         index= FFMAX(index, 0);
1311         e= &st->index_entries[index];
1312
1313         if(e->timestamp <= target_ts || e->pos == e->min_distance){
1314             pos_min= e->pos;
1315             ts_min= e->timestamp;
1316 #ifdef DEBUG_SEEK
1317         av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1318                pos_min,ts_min);
1319 #endif
1320         }else{
1321             assert(index==0);
1322         }
1323
1324         index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1325         assert(index < st->nb_index_entries);
1326         if(index >= 0){
1327             e= &st->index_entries[index];
1328             assert(e->timestamp >= target_ts);
1329             pos_max= e->pos;
1330             ts_max= e->timestamp;
1331             pos_limit= pos_max - e->min_distance;
1332 #ifdef DEBUG_SEEK
1333         av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1334                pos_max,pos_limit, ts_max);
1335 #endif
1336         }
1337     }
1338
1339     pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1340     if(pos<0)
1341         return -1;
1342
1343     /* do the seek */
1344     url_fseek(s->pb, pos, SEEK_SET);
1345
1346     av_update_cur_dts(s, st, ts);
1347
1348     return 0;
1349 }
1350
1351 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 )){
1352     int64_t pos, ts;
1353     int64_t start_pos, filesize;
1354     int no_change;
1355
1356 #ifdef DEBUG_SEEK
1357     av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1358 #endif
1359
1360     if(ts_min == AV_NOPTS_VALUE){
1361         pos_min = s->data_offset;
1362         ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1363         if (ts_min == AV_NOPTS_VALUE)
1364             return -1;
1365     }
1366
1367     if(ts_max == AV_NOPTS_VALUE){
1368         int step= 1024;
1369         filesize = url_fsize(s->pb);
1370         pos_max = filesize - 1;
1371         do{
1372             pos_max -= step;
1373             ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1374             step += step;
1375         }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1376         if (ts_max == AV_NOPTS_VALUE)
1377             return -1;
1378
1379         for(;;){
1380             int64_t tmp_pos= pos_max + 1;
1381             int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1382             if(tmp_ts == AV_NOPTS_VALUE)
1383                 break;
1384             ts_max= tmp_ts;
1385             pos_max= tmp_pos;
1386             if(tmp_pos >= filesize)
1387                 break;
1388         }
1389         pos_limit= pos_max;
1390     }
1391
1392     if(ts_min > ts_max){
1393         return -1;
1394     }else if(ts_min == ts_max){
1395         pos_limit= pos_min;
1396     }
1397
1398     no_change=0;
1399     while (pos_min < pos_limit) {
1400 #ifdef DEBUG_SEEK
1401         av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1402                pos_min, pos_max,
1403                ts_min, ts_max);
1404 #endif
1405         assert(pos_limit <= pos_max);
1406
1407         if(no_change==0){
1408             int64_t approximate_keyframe_distance= pos_max - pos_limit;
1409             // interpolate position (better than dichotomy)
1410             pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1411                 + pos_min - approximate_keyframe_distance;
1412         }else if(no_change==1){
1413             // bisection, if interpolation failed to change min or max pos last time
1414             pos = (pos_min + pos_limit)>>1;
1415         }else{
1416             /* linear search if bisection failed, can only happen if there
1417                are very few or no keyframes between min/max */
1418             pos=pos_min;
1419         }
1420         if(pos <= pos_min)
1421             pos= pos_min + 1;
1422         else if(pos > pos_limit)
1423             pos= pos_limit;
1424         start_pos= pos;
1425
1426         ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1427         if(pos == pos_max)
1428             no_change++;
1429         else
1430             no_change=0;
1431 #ifdef DEBUG_SEEK
1432 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);
1433 #endif
1434         if(ts == AV_NOPTS_VALUE){
1435             av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1436             return -1;
1437         }
1438         assert(ts != AV_NOPTS_VALUE);
1439         if (target_ts <= ts) {
1440             pos_limit = start_pos - 1;
1441             pos_max = pos;
1442             ts_max = ts;
1443         }
1444         if (target_ts >= ts) {
1445             pos_min = pos;
1446             ts_min = ts;
1447         }
1448     }
1449
1450     pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1451     ts  = (flags & AVSEEK_FLAG_BACKWARD) ?  ts_min :  ts_max;
1452 #ifdef DEBUG_SEEK
1453     pos_min = pos;
1454     ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1455     pos_min++;
1456     ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1457     av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1458            pos, ts_min, target_ts, ts_max);
1459 #endif
1460     *ts_ret= ts;
1461     return pos;
1462 }
1463
1464 static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1465     int64_t pos_min, pos_max;
1466 #if 0
1467     AVStream *st;
1468
1469     if (stream_index < 0)
1470         return -1;
1471
1472     st= s->streams[stream_index];
1473 #endif
1474
1475     pos_min = s->data_offset;
1476     pos_max = url_fsize(s->pb) - 1;
1477
1478     if     (pos < pos_min) pos= pos_min;
1479     else if(pos > pos_max) pos= pos_max;
1480
1481     url_fseek(s->pb, pos, SEEK_SET);
1482
1483 #if 0
1484     av_update_cur_dts(s, st, ts);
1485 #endif
1486     return 0;
1487 }
1488
1489 static int av_seek_frame_generic(AVFormatContext *s,
1490                                  int stream_index, int64_t timestamp, int flags)
1491 {
1492     int index, ret;
1493     AVStream *st;
1494     AVIndexEntry *ie;
1495
1496     st = s->streams[stream_index];
1497
1498     index = av_index_search_timestamp(st, timestamp, flags);
1499
1500     if(index < 0 || index==st->nb_index_entries-1){
1501         int i;
1502         AVPacket pkt;
1503
1504         if(st->nb_index_entries){
1505             assert(st->index_entries);
1506             ie= &st->index_entries[st->nb_index_entries-1];
1507             if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
1508                 return ret;
1509             av_update_cur_dts(s, st, ie->timestamp);
1510         }else{
1511             if ((ret = url_fseek(s->pb, 0, SEEK_SET)) < 0)
1512                 return ret;
1513         }
1514         for(i=0;; i++) {
1515             int ret = av_read_frame(s, &pkt);
1516             if(ret<0)
1517                 break;
1518             av_free_packet(&pkt);
1519             if(stream_index == pkt.stream_index){
1520                 if((pkt.flags & PKT_FLAG_KEY) && pkt.dts > timestamp)
1521                     break;
1522             }
1523         }
1524         index = av_index_search_timestamp(st, timestamp, flags);
1525     }
1526     if (index < 0)
1527         return -1;
1528
1529     av_read_frame_flush(s);
1530     if (s->iformat->read_seek){
1531         if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1532             return 0;
1533     }
1534     ie = &st->index_entries[index];
1535     if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
1536         return ret;
1537     av_update_cur_dts(s, st, ie->timestamp);
1538
1539     return 0;
1540 }
1541
1542 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1543 {
1544     int ret;
1545     AVStream *st;
1546
1547     av_read_frame_flush(s);
1548
1549     if(flags & AVSEEK_FLAG_BYTE)
1550         return av_seek_frame_byte(s, stream_index, timestamp, flags);
1551
1552     if(stream_index < 0){
1553         stream_index= av_find_default_stream_index(s);
1554         if(stream_index < 0)
1555             return -1;
1556
1557         st= s->streams[stream_index];
1558        /* timestamp for default must be expressed in AV_TIME_BASE units */
1559         timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1560     }
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 static void digit_to_char(char *dst, uint8_t src)
3217 {
3218     if (src < 10) {
3219         *dst = '0' + src;
3220     } else {
3221         *dst = 'A' + src - 10;
3222     }
3223 }
3224
3225 char *ff_data_to_hex(char *buff, const uint8_t *src, int s)
3226 {
3227     int i;
3228
3229     for(i = 0; i < s; i++) {
3230         digit_to_char(buff + 2 * i, src[i] >> 4);
3231         digit_to_char(buff + 2 * i + 1, src[i] & 0xF);
3232     }
3233
3234     return buff;
3235 }
3236
3237 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3238                      int pts_num, int pts_den)
3239 {
3240     unsigned int gcd= ff_gcd(pts_num, pts_den);
3241     s->pts_wrap_bits = pts_wrap_bits;
3242     s->time_base.num = pts_num/gcd;
3243     s->time_base.den = pts_den/gcd;
3244
3245     if(gcd>1)
3246         av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, gcd);
3247 }