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