git.sesse.net Git - ffmpeg/blob - libavformat/utils.c

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