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