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->start_time == AV_NOPTS_VALUE ||
1464                     st->duration == AV_NOPTS_VALUE) {
1465                     st->start_time = 0;
1466                     st->duration = duration;
1467                 }
1468             }
1469         }
1470     }
1471 }
1472
1473 #define DURATION_MAX_READ_SIZE 250000
1474
1475 /* only usable for MPEG-PS streams */
1476 static void av_estimate_timings_from_pts(AVFormatContext *ic, offset_t old_offset)
1477 {
1478     AVPacket pkt1, *pkt = &pkt1;
1479     AVStream *st;
1480     int read_size, i, ret;
1481     int64_t end_time;
1482     int64_t filesize, offset, duration;
1483
1484     /* free previous packet */
1485     if (ic->cur_st && ic->cur_st->parser)
1486         av_free_packet(&ic->cur_pkt);
1487     ic->cur_st = NULL;
1488
1489     /* flush packet queue */
1490     flush_packet_queue(ic);
1491
1492     for(i=0;i<ic->nb_streams;i++) {
1493         st = ic->streams[i];
1494         if (st->parser) {
1495             av_parser_close(st->parser);
1496             st->parser= NULL;
1497         }
1498     }
1499
1500     /* we read the first packets to get the first PTS (not fully
1501        accurate, but it is enough now) */
1502     url_fseek(&ic->pb, 0, SEEK_SET);
1503     read_size = 0;
1504     for(;;) {
1505         if (read_size >= DURATION_MAX_READ_SIZE)
1506             break;
1507         /* if all info is available, we can stop */
1508         for(i = 0;i < ic->nb_streams; i++) {
1509             st = ic->streams[i];
1510             if (st->start_time == AV_NOPTS_VALUE)
1511                 break;
1512         }
1513         if (i == ic->nb_streams)
1514             break;
1515
1516         ret = av_read_packet(ic, pkt);
1517         if (ret != 0)
1518             break;
1519         read_size += pkt->size;
1520         st = ic->streams[pkt->stream_index];
1521         if (pkt->pts != AV_NOPTS_VALUE) {
1522             if (st->start_time == AV_NOPTS_VALUE)
1523                 st->start_time = pkt->pts;
1524         }
1525         av_free_packet(pkt);
1526     }
1527
1528     /* estimate the end time (duration) */
1529     /* XXX: may need to support wrapping */
1530     filesize = ic->file_size;
1531     offset = filesize - DURATION_MAX_READ_SIZE;
1532     if (offset < 0)
1533         offset = 0;
1534
1535     url_fseek(&ic->pb, offset, SEEK_SET);
1536     read_size = 0;
1537     for(;;) {
1538         if (read_size >= DURATION_MAX_READ_SIZE)
1539             break;
1540
1541         ret = av_read_packet(ic, pkt);
1542         if (ret != 0)
1543             break;
1544         read_size += pkt->size;
1545         st = ic->streams[pkt->stream_index];
1546         if (pkt->pts != AV_NOPTS_VALUE &&
1547             st->start_time != AV_NOPTS_VALUE) {
1548             end_time = pkt->pts;
1549             duration = end_time - st->start_time;
1550             if (duration > 0) {
1551                 if (st->duration == AV_NOPTS_VALUE ||
1552                     st->duration < duration)
1553                     st->duration = duration;
1554             }
1555         }
1556         av_free_packet(pkt);
1557     }
1558
1559     fill_all_stream_timings(ic);
1560
1561     url_fseek(&ic->pb, old_offset, SEEK_SET);
1562     for(i=0; i<ic->nb_streams; i++){
1563         st= ic->streams[i];
1564         st->cur_dts= st->first_dts;
1565     }
1566 }
1567
1568 static void av_estimate_timings(AVFormatContext *ic, offset_t old_offset)
1569 {
1570     int64_t file_size;
1571
1572     /* get the file size, if possible */
1573     if (ic->iformat->flags & AVFMT_NOFILE) {
1574         file_size = 0;
1575     } else {
1576         file_size = url_fsize(&ic->pb);
1577         if (file_size < 0)
1578             file_size = 0;
1579     }
1580     ic->file_size = file_size;
1581
1582     if ((!strcmp(ic->iformat->name, "mpeg") ||
1583          !strcmp(ic->iformat->name, "mpegts")) &&
1584         file_size && !ic->pb.is_streamed) {
1585         /* get accurate estimate from the PTSes */
1586         av_estimate_timings_from_pts(ic, old_offset);
1587     } else if (av_has_timings(ic)) {
1588         /* at least one components has timings - we use them for all
1589            the components */
1590         fill_all_stream_timings(ic);
1591     } else {
1592         /* less precise: use bit rate info */
1593         av_estimate_timings_from_bit_rate(ic);
1594     }
1595     av_update_stream_timings(ic);
1596
1597 #if 0
1598     {
1599         int i;
1600         AVStream *st;
1601         for(i = 0;i < ic->nb_streams; i++) {
1602             st = ic->streams[i];
1603         printf("%d: start_time: %0.3f duration: %0.3f\n",
1604                i, (double)st->start_time / AV_TIME_BASE,
1605                (double)st->duration / AV_TIME_BASE);
1606         }
1607         printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1608                (double)ic->start_time / AV_TIME_BASE,
1609                (double)ic->duration / AV_TIME_BASE,
1610                ic->bit_rate / 1000);
1611     }
1612 #endif
1613 }
1614
1615 static int has_codec_parameters(AVCodecContext *enc)
1616 {
1617     int val;
1618     switch(enc->codec_type) {
1619     case CODEC_TYPE_AUDIO:
1620         val = enc->sample_rate;
1621         break;
1622     case CODEC_TYPE_VIDEO:
1623         val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
1624         break;
1625     default:
1626         val = 1;
1627         break;
1628     }
1629     return (val != 0);
1630 }
1631
1632 static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1633 {
1634     int16_t *samples;
1635     AVCodec *codec;
1636     int got_picture, data_size, ret=0;
1637     AVFrame picture;
1638
1639   if(!st->codec->codec){
1640     codec = avcodec_find_decoder(st->codec->codec_id);
1641     if (!codec)
1642         return -1;
1643     ret = avcodec_open(st->codec, codec);
1644     if (ret < 0)
1645         return ret;
1646   }
1647
1648   if(!has_codec_parameters(st->codec)){
1649     switch(st->codec->codec_type) {
1650     case CODEC_TYPE_VIDEO:
1651         ret = avcodec_decode_video(st->codec, &picture,
1652                                    &got_picture, (uint8_t *)data, size);
1653         break;
1654     case CODEC_TYPE_AUDIO:
1655         data_size = FFMAX(size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
1656         samples = av_malloc(data_size);
1657         if (!samples)
1658             goto fail;
1659         ret = avcodec_decode_audio2(st->codec, samples,
1660                                     &data_size, (uint8_t *)data, size);
1661         av_free(samples);
1662         break;
1663     default:
1664         break;
1665     }
1666   }
1667  fail:
1668     return ret;
1669 }
1670
1671 static int set_codec_from_probe_data(AVStream *st, AVProbeData *pd, int score)
1672 {
1673     AVInputFormat *fmt;
1674     fmt = av_probe_input_format2(pd, 1, &score);
1675
1676     if (fmt) {
1677         if (strncmp(fmt->name, "mp3", 3) == 0)
1678             st->codec->codec_id = CODEC_ID_MP3;
1679         else if (strncmp(fmt->name, "ac3", 3) == 0)
1680             st->codec->codec_id = CODEC_ID_AC3;
1681     }
1682     return !!fmt;
1683 }
1684
1685 unsigned int codec_get_tag(const AVCodecTag *tags, int id)
1686 {
1687     while (tags->id != CODEC_ID_NONE) {
1688         if (tags->id == id)
1689             return tags->tag;
1690         tags++;
1691     }
1692     return 0;
1693 }
1694
1695 enum CodecID codec_get_id(const AVCodecTag *tags, unsigned int tag)
1696 {
1697     int i;
1698     for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
1699         if(tag == tags[i].tag)
1700             return tags[i].id;
1701     }
1702     for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
1703         if(   toupper((tag >> 0)&0xFF) == toupper((tags[i].tag >> 0)&0xFF)
1704            && toupper((tag >> 8)&0xFF) == toupper((tags[i].tag >> 8)&0xFF)
1705            && toupper((tag >>16)&0xFF) == toupper((tags[i].tag >>16)&0xFF)
1706            && toupper((tag >>24)&0xFF) == toupper((tags[i].tag >>24)&0xFF))
1707             return tags[i].id;
1708     }
1709     return CODEC_ID_NONE;
1710 }
1711
1712 unsigned int av_codec_get_tag(const AVCodecTag *tags[4], enum CodecID id)
1713 {
1714     int i;
1715     for(i=0; tags && tags[i]; i++){
1716         int tag= codec_get_tag(tags[i], id);
1717         if(tag) return tag;
1718     }
1719     return 0;
1720 }
1721
1722 enum CodecID av_codec_get_id(const AVCodecTag *tags[4], unsigned int tag)
1723 {
1724     int i;
1725     for(i=0; tags && tags[i]; i++){
1726         enum CodecID id= codec_get_id(tags[i], tag);
1727         if(id!=CODEC_ID_NONE) return id;
1728     }
1729     return CODEC_ID_NONE;
1730 }
1731
1732 /* absolute maximum size we read until we abort */
1733 #define MAX_READ_SIZE        5000000
1734
1735 #define MAX_STD_TIMEBASES (60*12+5)
1736 static int get_std_framerate(int i){
1737     if(i<60*12) return i*1001;
1738     else        return ((int[]){24,30,60,12,15})[i-60*12]*1000*12;
1739 }
1740
1741 int av_find_stream_info(AVFormatContext *ic)
1742 {
1743     int i, count, ret, read_size, j;
1744     AVStream *st;
1745     AVPacket pkt1, *pkt;
1746     int64_t last_dts[MAX_STREAMS];
1747     int duration_count[MAX_STREAMS]={0};
1748     double (*duration_error)[MAX_STD_TIMEBASES];
1749     offset_t old_offset = url_ftell(&ic->pb);
1750     int64_t codec_info_duration[MAX_STREAMS]={0};
1751     int codec_info_nb_frames[MAX_STREAMS]={0};
1752     AVProbeData probe_data[MAX_STREAMS];
1753     int codec_identified[MAX_STREAMS]={0};
1754
1755     duration_error = av_mallocz(MAX_STREAMS * sizeof(*duration_error));
1756     if (!duration_error) return AVERROR(ENOMEM);
1757
1758     for(i=0;i<ic->nb_streams;i++) {
1759         st = ic->streams[i];
1760         if(st->codec->codec_type == CODEC_TYPE_VIDEO){
1761 /*            if(!st->time_base.num)
1762                 st->time_base= */
1763             if(!st->codec->time_base.num)
1764                 st->codec->time_base= st->time_base;
1765         }
1766         //only for the split stuff
1767         if (!st->parser) {
1768             st->parser = av_parser_init(st->codec->codec_id);
1769             if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
1770                 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1771             }
1772         }
1773     }
1774
1775     for(i=0;i<MAX_STREAMS;i++){
1776         last_dts[i]= AV_NOPTS_VALUE;
1777     }
1778
1779     memset(probe_data, 0, sizeof(probe_data));
1780     count = 0;
1781     read_size = 0;
1782     for(;;) {
1783         /* check if one codec still needs to be handled */
1784         for(i=0;i<ic->nb_streams;i++) {
1785             st = ic->streams[i];
1786             if (!has_codec_parameters(st->codec))
1787                 break;
1788             /* variable fps and no guess at the real fps */
1789             if(   (st->codec->time_base.den >= 101LL*st->codec->time_base.num || st->codec->codec_id == CODEC_ID_MPEG2VIDEO)
1790                && duration_count[i]<20 && st->codec->codec_type == CODEC_TYPE_VIDEO)
1791                 break;
1792             if(st->parser && st->parser->parser->split && !st->codec->extradata)
1793                 break;
1794             if (st->codec->codec_type == CODEC_TYPE_AUDIO &&
1795                 st->codec->codec_id == CODEC_ID_NONE)
1796                 break;
1797             if(st->first_dts == AV_NOPTS_VALUE)
1798                 break;
1799         }
1800         if (i == ic->nb_streams) {
1801             /* NOTE: if the format has no header, then we need to read
1802                some packets to get most of the streams, so we cannot
1803                stop here */
1804             if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
1805                 /* if we found the info for all the codecs, we can stop */
1806                 ret = count;
1807                 break;
1808             }
1809         }
1810         /* we did not get all the codec info, but we read too much data */
1811         if (read_size >= MAX_READ_SIZE) {
1812             ret = count;
1813             break;
1814         }
1815
1816         /* NOTE: a new stream can be added there if no header in file
1817            (AVFMTCTX_NOHEADER) */
1818         ret = av_read_frame_internal(ic, &pkt1);
1819         if (ret < 0) {
1820             /* EOF or error */
1821             ret = -1; /* we could not have all the codec parameters before EOF */
1822             for(i=0;i<ic->nb_streams;i++) {
1823                 st = ic->streams[i];
1824                 if (!has_codec_parameters(st->codec)){
1825                     char buf[256];
1826                     avcodec_string(buf, sizeof(buf), st->codec, 0);
1827                     av_log(ic, AV_LOG_INFO, "Could not find codec parameters (%s)\n", buf);
1828                 } else {
1829                     ret = 0;
1830                 }
1831             }
1832             break;
1833         }
1834
1835         pkt= add_to_pktbuf(ic, &pkt1);
1836         if(av_dup_packet(pkt) < 0)
1837             return AVERROR(ENOMEM);
1838
1839         read_size += pkt->size;
1840
1841         st = ic->streams[pkt->stream_index];
1842         if(codec_info_nb_frames[st->index]>1)
1843             codec_info_duration[st->index] += pkt->duration;
1844         if (pkt->duration != 0)
1845             codec_info_nb_frames[st->index]++;
1846
1847         {
1848             int index= pkt->stream_index;
1849             int64_t last= last_dts[index];
1850             int64_t duration= pkt->dts - last;
1851
1852             if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
1853                 double dur= duration * av_q2d(st->time_base);
1854
1855 //                if(st->codec->codec_type == CODEC_TYPE_VIDEO)
1856 //                    av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
1857                 if(duration_count[index] < 2)
1858                     memset(duration_error, 0, MAX_STREAMS * sizeof(*duration_error));
1859                 for(i=1; i<MAX_STD_TIMEBASES; i++){
1860                     int framerate= get_std_framerate(i);
1861                     int ticks= lrintf(dur*framerate/(1001*12));
1862                     double error= dur - ticks*1001*12/(double)framerate;
1863                     duration_error[index][i] += error*error;
1864                 }
1865                 duration_count[index]++;
1866             }
1867             if(last == AV_NOPTS_VALUE || duration_count[index]<=1)
1868                 last_dts[pkt->stream_index]= pkt->dts;
1869
1870             if (st->codec->codec_id == CODEC_ID_NONE) {
1871                 AVProbeData *pd = &(probe_data[st->index]);
1872                 pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size);
1873                 memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
1874                 pd->buf_size += pkt->size;
1875             }
1876         }
1877         if(st->parser && st->parser->parser->split && !st->codec->extradata){
1878             int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
1879             if(i){
1880                 st->codec->extradata_size= i;
1881                 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
1882                 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
1883                 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
1884             }
1885         }
1886
1887         /* if still no information, we try to open the codec and to
1888            decompress the frame. We try to avoid that in most cases as
1889            it takes longer and uses more memory. For MPEG4, we need to
1890            decompress for Quicktime. */
1891         if (!has_codec_parameters(st->codec) /*&&
1892             (st->codec->codec_id == CODEC_ID_FLV1 ||
1893              st->codec->codec_id == CODEC_ID_H264 ||
1894              st->codec->codec_id == CODEC_ID_H263 ||
1895              st->codec->codec_id == CODEC_ID_H261 ||
1896              st->codec->codec_id == CODEC_ID_VORBIS ||
1897              st->codec->codec_id == CODEC_ID_MJPEG ||
1898              st->codec->codec_id == CODEC_ID_PNG ||
1899              st->codec->codec_id == CODEC_ID_PAM ||
1900              st->codec->codec_id == CODEC_ID_PGM ||
1901              st->codec->codec_id == CODEC_ID_PGMYUV ||
1902              st->codec->codec_id == CODEC_ID_PBM ||
1903              st->codec->codec_id == CODEC_ID_PPM ||
1904              st->codec->codec_id == CODEC_ID_SHORTEN ||
1905              (st->codec->codec_id == CODEC_ID_MPEG4 && !st->need_parsing))*/)
1906             try_decode_frame(st, pkt->data, pkt->size);
1907
1908         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) {
1909             break;
1910         }
1911         count++;
1912     }
1913
1914     // close codecs which where opened in try_decode_frame()
1915     for(i=0;i<ic->nb_streams;i++) {
1916         st = ic->streams[i];
1917         if(st->codec->codec)
1918             avcodec_close(st->codec);
1919     }
1920     for(i=0;i<ic->nb_streams;i++) {
1921         st = ic->streams[i];
1922         if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1923             if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_sample)
1924                 st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
1925
1926             if(duration_count[i]
1927                && (st->codec->time_base.num*101LL <= st->codec->time_base.den || st->codec->codec_id == CODEC_ID_MPEG2VIDEO) /*&&
1928                //FIXME we should not special case mpeg2, but this needs testing with non mpeg2 ...
1929                st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den*/){
1930                 double best_error= 2*av_q2d(st->time_base);
1931                 best_error= best_error*best_error*duration_count[i]*1000*12*30;
1932
1933                 for(j=1; j<MAX_STD_TIMEBASES; j++){
1934                     double error= duration_error[i][j] * get_std_framerate(j);
1935 //                    if(st->codec->codec_type == CODEC_TYPE_VIDEO)
1936 //                        av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
1937                     if(error < best_error){
1938                         best_error= error;
1939                         av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, get_std_framerate(j), 12*1001, INT_MAX);
1940                     }
1941                 }
1942             }
1943
1944             if (!st->r_frame_rate.num){
1945                 if(    st->codec->time_base.den * (int64_t)st->time_base.num
1946                     <= st->codec->time_base.num * (int64_t)st->time_base.den){
1947                     st->r_frame_rate.num = st->codec->time_base.den;
1948                     st->r_frame_rate.den = st->codec->time_base.num;
1949                 }else{
1950                     st->r_frame_rate.num = st->time_base.den;
1951                     st->r_frame_rate.den = st->time_base.num;
1952                 }
1953             }
1954         }else if(st->codec->codec_type == CODEC_TYPE_AUDIO) {
1955             if (st->codec->codec_id == CODEC_ID_NONE && probe_data[st->index].buf_size > 0) {
1956                 codec_identified[st->index] = set_codec_from_probe_data(st, &(probe_data[st->index]), 1);
1957                 if (codec_identified[st->index]) {
1958                     st->need_parsing = AVSTREAM_PARSE_FULL;
1959                 }
1960             }
1961             if(!st->codec->bits_per_sample)
1962                 st->codec->bits_per_sample= av_get_bits_per_sample(st->codec->codec_id);
1963         }
1964     }
1965
1966     av_estimate_timings(ic, old_offset);
1967
1968     for(i=0;i<ic->nb_streams;i++) {
1969         st = ic->streams[i];
1970         if (codec_identified[st->index])
1971             break;
1972     }
1973     //FIXME this is a mess
1974     if(i!=ic->nb_streams){
1975         av_read_frame_flush(ic);
1976         for(i=0;i<ic->nb_streams;i++) {
1977             st = ic->streams[i];
1978             if (codec_identified[st->index]) {
1979                 av_seek_frame(ic, st->index, 0.0, 0);
1980             }
1981             st->cur_dts= st->first_dts;
1982         }
1983         url_fseek(&ic->pb, ic->data_offset, SEEK_SET);
1984     }
1985
1986 #if 0
1987     /* correct DTS for b frame streams with no timestamps */
1988     for(i=0;i<ic->nb_streams;i++) {
1989         st = ic->streams[i];
1990         if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1991             if(b-frames){
1992                 ppktl = &ic->packet_buffer;
1993                 while(ppkt1){
1994                     if(ppkt1->stream_index != i)
1995                         continue;
1996                     if(ppkt1->pkt->dts < 0)
1997                         break;
1998                     if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
1999                         break;
2000                     ppkt1->pkt->dts -= delta;
2001                     ppkt1= ppkt1->next;
2002                 }
2003                 if(ppkt1)
2004                     continue;
2005                 st->cur_dts -= delta;
2006             }
2007         }
2008     }
2009 #endif
2010
2011     av_free(duration_error);
2012     for(i=0;i<MAX_STREAMS;i++){
2013         av_freep(&(probe_data[i].buf));
2014     }
2015
2016     return ret;
2017 }
2018
2019 /*******************************************************/
2020
2021 int av_read_play(AVFormatContext *s)
2022 {
2023     if (!s->iformat->read_play)
2024         return AVERROR(ENOSYS);
2025     return s->iformat->read_play(s);
2026 }
2027
2028 int av_read_pause(AVFormatContext *s)
2029 {
2030     if (!s->iformat->read_pause)
2031         return AVERROR(ENOSYS);
2032     return s->iformat->read_pause(s);
2033 }
2034
2035 void av_close_input_file(AVFormatContext *s)
2036 {
2037     int i, must_open_file;
2038     AVStream *st;
2039
2040     /* free previous packet */
2041     if (s->cur_st && s->cur_st->parser)
2042         av_free_packet(&s->cur_pkt);
2043
2044     if (s->iformat->read_close)
2045         s->iformat->read_close(s);
2046     for(i=0;i<s->nb_streams;i++) {
2047         /* free all data in a stream component */
2048         st = s->streams[i];
2049         if (st->parser) {
2050             av_parser_close(st->parser);
2051         }
2052         av_free(st->index_entries);
2053         av_free(st->codec->extradata);
2054         av_free(st->codec);
2055         av_free(st);
2056     }
2057     flush_packet_queue(s);
2058     must_open_file = 1;
2059     if (s->iformat->flags & AVFMT_NOFILE) {
2060         must_open_file = 0;
2061     }
2062     if (must_open_file) {
2063         url_fclose(&s->pb);
2064     }
2065     av_freep(&s->priv_data);
2066     av_free(s);
2067 }
2068
2069 AVStream *av_new_stream(AVFormatContext *s, int id)
2070 {
2071     AVStream *st;
2072     int i;
2073
2074     if (s->nb_streams >= MAX_STREAMS)
2075         return NULL;
2076
2077     st = av_mallocz(sizeof(AVStream));
2078     if (!st)
2079         return NULL;
2080
2081     st->codec= avcodec_alloc_context();
2082     if (s->iformat) {
2083         /* no default bitrate if decoding */
2084         st->codec->bit_rate = 0;
2085     }
2086     st->index = s->nb_streams;
2087     st->id = id;
2088     st->start_time = AV_NOPTS_VALUE;
2089     st->duration = AV_NOPTS_VALUE;
2090     st->cur_dts = AV_NOPTS_VALUE;
2091     st->first_dts = AV_NOPTS_VALUE;
2092
2093     /* default pts settings is MPEG like */
2094     av_set_pts_info(st, 33, 1, 90000);
2095     st->last_IP_pts = AV_NOPTS_VALUE;
2096     for(i=0; i<MAX_REORDER_DELAY+1; i++)
2097         st->pts_buffer[i]= AV_NOPTS_VALUE;
2098
2099     s->streams[s->nb_streams++] = st;
2100     return st;
2101 }
2102
2103 /************************************************************/
2104 /* output media file */
2105
2106 int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2107 {
2108     int ret;
2109
2110     if (s->oformat->priv_data_size > 0) {
2111         s->priv_data = av_mallocz(s->oformat->priv_data_size);
2112         if (!s->priv_data)
2113             return AVERROR(ENOMEM);
2114     } else
2115         s->priv_data = NULL;
2116
2117     if (s->oformat->set_parameters) {
2118         ret = s->oformat->set_parameters(s, ap);
2119         if (ret < 0)
2120             return ret;
2121     }
2122     return 0;
2123 }
2124
2125 int av_write_header(AVFormatContext *s)
2126 {
2127     int ret, i;
2128     AVStream *st;
2129
2130     // some sanity checks
2131     for(i=0;i<s->nb_streams;i++) {
2132         st = s->streams[i];
2133
2134         switch (st->codec->codec_type) {
2135         case CODEC_TYPE_AUDIO:
2136             if(st->codec->sample_rate<=0){
2137                 av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2138                 return -1;
2139             }
2140             break;
2141         case CODEC_TYPE_VIDEO:
2142             if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2143                 av_log(s, AV_LOG_ERROR, "time base not set\n");
2144                 return -1;
2145             }
2146             if(st->codec->width<=0 || st->codec->height<=0){
2147                 av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2148                 return -1;
2149             }
2150             break;
2151         }
2152
2153         if(s->oformat->codec_tag){
2154             if(st->codec->codec_tag){
2155                 //FIXME
2156                 //check that tag + id is in the table
2157                 //if neither is in the table -> ok
2158                 //if tag is in the table with another id -> FAIL
2159                 //if id is in the table with another tag -> FAIL unless strict < ?
2160             }else
2161                 st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2162         }
2163     }
2164
2165     if (!s->priv_data && s->oformat->priv_data_size > 0) {
2166         s->priv_data = av_mallocz(s->oformat->priv_data_size);
2167         if (!s->priv_data)
2168             return AVERROR(ENOMEM);
2169     }
2170
2171     if(s->oformat->write_header){
2172         ret = s->oformat->write_header(s);
2173         if (ret < 0)
2174             return ret;
2175     }
2176
2177     /* init PTS generation */
2178     for(i=0;i<s->nb_streams;i++) {
2179         int64_t den = AV_NOPTS_VALUE;
2180         st = s->streams[i];
2181
2182         switch (st->codec->codec_type) {
2183         case CODEC_TYPE_AUDIO:
2184             den = (int64_t)st->time_base.num * st->codec->sample_rate;
2185             break;
2186         case CODEC_TYPE_VIDEO:
2187             den = (int64_t)st->time_base.num * st->codec->time_base.den;
2188             break;
2189         default:
2190             break;
2191         }
2192         if (den != AV_NOPTS_VALUE) {
2193             if (den <= 0)
2194                 return AVERROR_INVALIDDATA;
2195             av_frac_init(&st->pts, 0, 0, den);
2196         }
2197     }
2198     return 0;
2199 }
2200
2201 //FIXME merge with compute_pkt_fields
2202 static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
2203     int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2204     int num, den, frame_size, i;
2205
2206 //    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);
2207
2208 /*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2209         return -1;*/
2210
2211     /* duration field */
2212     if (pkt->duration == 0) {
2213         compute_frame_duration(&num, &den, st, NULL, pkt);
2214         if (den && num) {
2215             pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
2216         }
2217     }
2218
2219     //XXX/FIXME this is a temporary hack until all encoders output pts
2220     if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2221         pkt->dts=
2222 //        pkt->pts= st->cur_dts;
2223         pkt->pts= st->pts.val;
2224     }
2225
2226     //calculate dts from pts
2227     if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE){
2228         st->pts_buffer[0]= pkt->pts;
2229         for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2230             st->pts_buffer[i]= (i-delay-1) * pkt->duration;
2231         for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2232             FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2233
2234         pkt->dts= st->pts_buffer[0];
2235     }
2236
2237     if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2238         av_log(NULL, AV_LOG_ERROR, "error, non monotone timestamps %"PRId64" >= %"PRId64"\n", st->cur_dts, pkt->dts);
2239         return -1;
2240     }
2241     if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2242         av_log(NULL, AV_LOG_ERROR, "error, pts < dts\n");
2243         return -1;
2244     }
2245
2246 //    av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2247     st->cur_dts= pkt->dts;
2248     st->pts.val= pkt->dts;
2249
2250     /* update pts */
2251     switch (st->codec->codec_type) {
2252     case CODEC_TYPE_AUDIO:
2253         frame_size = get_audio_frame_size(st->codec, pkt->size);
2254
2255         /* HACK/FIXME, we skip the initial 0-size packets as they are most likely equal to the encoder delay,
2256            but it would be better if we had the real timestamps from the encoder */
2257         if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2258             av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2259         }
2260         break;
2261     case CODEC_TYPE_VIDEO:
2262         av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2263         break;
2264     default:
2265         break;
2266     }
2267     return 0;
2268 }
2269
2270 static void truncate_ts(AVStream *st, AVPacket *pkt){
2271     int64_t pts_mask = (2LL << (st->pts_wrap_bits-1)) - 1;
2272
2273 //    if(pkt->dts < 0)
2274 //        pkt->dts= 0;  //this happens for low_delay=0 and b frames, FIXME, needs further invstigation about what we should do here
2275
2276     if (pkt->pts != AV_NOPTS_VALUE)
2277         pkt->pts &= pts_mask;
2278     if (pkt->dts != AV_NOPTS_VALUE)
2279         pkt->dts &= pts_mask;
2280 }
2281
2282 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2283 {
2284     int ret;
2285
2286     ret=compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2287     if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2288         return ret;
2289
2290     truncate_ts(s->streams[pkt->stream_index], pkt);
2291
2292     ret= s->oformat->write_packet(s, pkt);
2293     if(!ret)
2294         ret= url_ferror(&s->pb);
2295     return ret;
2296 }
2297
2298 int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2299     AVPacketList *pktl, **next_point, *this_pktl;
2300     int stream_count=0;
2301     int streams[MAX_STREAMS];
2302
2303     if(pkt){
2304         AVStream *st= s->streams[ pkt->stream_index];
2305
2306 //        assert(pkt->destruct != av_destruct_packet); //FIXME
2307
2308         this_pktl = av_mallocz(sizeof(AVPacketList));
2309         this_pktl->pkt= *pkt;
2310         if(pkt->destruct == av_destruct_packet)
2311             pkt->destruct= NULL; // non shared -> must keep original from being freed
2312         else
2313             av_dup_packet(&this_pktl->pkt);  //shared -> must dup
2314
2315         next_point = &s->packet_buffer;
2316         while(*next_point){
2317             AVStream *st2= s->streams[ (*next_point)->pkt.stream_index];
2318             int64_t left=  st2->time_base.num * (int64_t)st ->time_base.den;
2319             int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2320             if((*next_point)->pkt.dts * left > pkt->dts * right) //FIXME this can overflow
2321                 break;
2322             next_point= &(*next_point)->next;
2323         }
2324         this_pktl->next= *next_point;
2325         *next_point= this_pktl;
2326     }
2327
2328     memset(streams, 0, sizeof(streams));
2329     pktl= s->packet_buffer;
2330     while(pktl){
2331 //av_log(s, AV_LOG_DEBUG, "show st:%d dts:%"PRId64"\n", pktl->pkt.stream_index, pktl->pkt.dts);
2332         if(streams[ pktl->pkt.stream_index ] == 0)
2333             stream_count++;
2334         streams[ pktl->pkt.stream_index ]++;
2335         pktl= pktl->next;
2336     }
2337
2338     if(s->nb_streams == stream_count || (flush && stream_count)){
2339         pktl= s->packet_buffer;
2340         *out= pktl->pkt;
2341
2342         s->packet_buffer= pktl->next;
2343         av_freep(&pktl);
2344         return 1;
2345     }else{
2346         av_init_packet(out);
2347         return 0;
2348     }
2349 }
2350
2351 /**
2352  * Interleaves a AVPacket correctly so it can be muxed.
2353  * @param out the interleaved packet will be output here
2354  * @param in the input packet
2355  * @param flush 1 if no further packets are available as input and all
2356  *              remaining packets should be output
2357  * @return 1 if a packet was output, 0 if no packet could be output,
2358  *         < 0 if an error occured
2359  */
2360 static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2361     if(s->oformat->interleave_packet)
2362         return s->oformat->interleave_packet(s, out, in, flush);
2363     else
2364         return av_interleave_packet_per_dts(s, out, in, flush);
2365 }
2366
2367 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2368     AVStream *st= s->streams[ pkt->stream_index];
2369
2370     //FIXME/XXX/HACK drop zero sized packets
2371     if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2372         return 0;
2373
2374 //av_log(NULL, AV_LOG_DEBUG, "av_interleaved_write_frame %d %"PRId64" %"PRId64"\n", pkt->size, pkt->dts, pkt->pts);
2375     if(compute_pkt_fields2(st, pkt) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2376         return -1;
2377
2378     if(pkt->dts == AV_NOPTS_VALUE)
2379         return -1;
2380
2381     for(;;){
2382         AVPacket opkt;
2383         int ret= av_interleave_packet(s, &opkt, pkt, 0);
2384         if(ret<=0) //FIXME cleanup needed for ret<0 ?
2385             return ret;
2386
2387         truncate_ts(s->streams[opkt.stream_index], &opkt);
2388         ret= s->oformat->write_packet(s, &opkt);
2389
2390         av_free_packet(&opkt);
2391         pkt= NULL;
2392
2393         if(ret<0)
2394             return ret;
2395         if(url_ferror(&s->pb))
2396             return url_ferror(&s->pb);
2397     }
2398 }
2399
2400 int av_write_trailer(AVFormatContext *s)
2401 {
2402     int ret, i;
2403
2404     for(;;){
2405         AVPacket pkt;
2406         ret= av_interleave_packet(s, &pkt, NULL, 1);
2407         if(ret<0) //FIXME cleanup needed for ret<0 ?
2408             goto fail;
2409         if(!ret)
2410             break;
2411
2412         truncate_ts(s->streams[pkt.stream_index], &pkt);
2413         ret= s->oformat->write_packet(s, &pkt);
2414
2415         av_free_packet(&pkt);
2416
2417         if(ret<0)
2418             goto fail;
2419         if(url_ferror(&s->pb))
2420             goto fail;
2421     }
2422
2423     if(s->oformat->write_trailer)
2424         ret = s->oformat->write_trailer(s);
2425 fail:
2426     if(ret == 0)
2427        ret=url_ferror(&s->pb);
2428     for(i=0;i<s->nb_streams;i++)
2429         av_freep(&s->streams[i]->priv_data);
2430     av_freep(&s->priv_data);
2431     return ret;
2432 }
2433
2434 /* "user interface" functions */
2435
2436 void dump_format(AVFormatContext *ic,
2437                  int index,
2438                  const char *url,
2439                  int is_output)
2440 {
2441     int i, flags;
2442     char buf[256];
2443
2444     av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
2445             is_output ? "Output" : "Input",
2446             index,
2447             is_output ? ic->oformat->name : ic->iformat->name,
2448             is_output ? "to" : "from", url);
2449     if (!is_output) {
2450         av_log(NULL, AV_LOG_INFO, "  Duration: ");
2451         if (ic->duration != AV_NOPTS_VALUE) {
2452             int hours, mins, secs, us;
2453             secs = ic->duration / AV_TIME_BASE;
2454             us = ic->duration % AV_TIME_BASE;
2455             mins = secs / 60;
2456             secs %= 60;
2457             hours = mins / 60;
2458             mins %= 60;
2459             av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%01d", hours, mins, secs,
2460                    (10 * us) / AV_TIME_BASE);
2461         } else {
2462             av_log(NULL, AV_LOG_INFO, "N/A");
2463         }
2464         if (ic->start_time != AV_NOPTS_VALUE) {
2465             int secs, us;
2466             av_log(NULL, AV_LOG_INFO, ", start: ");
2467             secs = ic->start_time / AV_TIME_BASE;
2468             us = ic->start_time % AV_TIME_BASE;
2469             av_log(NULL, AV_LOG_INFO, "%d.%06d",
2470                    secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
2471         }
2472         av_log(NULL, AV_LOG_INFO, ", bitrate: ");
2473         if (ic->bit_rate) {
2474             av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
2475         } else {
2476             av_log(NULL, AV_LOG_INFO, "N/A");
2477         }
2478         av_log(NULL, AV_LOG_INFO, "\n");
2479     }
2480     for(i=0;i<ic->nb_streams;i++) {
2481         AVStream *st = ic->streams[i];
2482         int g= ff_gcd(st->time_base.num, st->time_base.den);
2483         avcodec_string(buf, sizeof(buf), st->codec, is_output);
2484         av_log(NULL, AV_LOG_INFO, "  Stream #%d.%d", index, i);
2485         /* the pid is an important information, so we display it */
2486         /* XXX: add a generic system */
2487         if (is_output)
2488             flags = ic->oformat->flags;
2489         else
2490             flags = ic->iformat->flags;
2491         if (flags & AVFMT_SHOW_IDS) {
2492             av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
2493         }
2494         if (strlen(st->language) > 0) {
2495             av_log(NULL, AV_LOG_INFO, "(%s)", st->language);
2496         }
2497         av_log(NULL, AV_LOG_DEBUG, ", %d/%d", st->time_base.num/g, st->time_base.den/g);
2498         av_log(NULL, AV_LOG_INFO, ": %s", buf);
2499         if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2500             if(st->r_frame_rate.den && st->r_frame_rate.num)
2501                 av_log(NULL, AV_LOG_INFO, ", %5.2f fps(r)", av_q2d(st->r_frame_rate));
2502 /*            else if(st->time_base.den && st->time_base.num)
2503                 av_log(NULL, AV_LOG_INFO, ", %5.2f fps(m)", 1/av_q2d(st->time_base));*/
2504             else
2505                 av_log(NULL, AV_LOG_INFO, ", %5.2f fps(c)", 1/av_q2d(st->codec->time_base));
2506         }
2507         av_log(NULL, AV_LOG_INFO, "\n");
2508     }
2509 }
2510
2511 int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2512 {
2513     return av_parse_video_frame_size(width_ptr, height_ptr, str);
2514 }
2515
2516 int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
2517 {
2518     AVRational frame_rate;
2519     int ret = av_parse_video_frame_rate(&frame_rate, arg);
2520     *frame_rate_num= frame_rate.num;
2521     *frame_rate_den= frame_rate.den;
2522     return ret;
2523 }
2524
2525 /**
2526  * gets the current time in micro seconds.
2527  */
2528 int64_t av_gettime(void)
2529 {
2530     struct timeval tv;
2531     gettimeofday(&tv,NULL);
2532     return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
2533 }
2534
2535 int64_t parse_date(const char *datestr, int duration)
2536 {
2537     const char *p;
2538     int64_t t;
2539     struct tm dt;
2540     int i;
2541     static const char *date_fmt[] = {
2542         "%Y-%m-%d",
2543         "%Y%m%d",
2544     };
2545     static const char *time_fmt[] = {
2546         "%H:%M:%S",
2547         "%H%M%S",
2548     };
2549     const char *q;
2550     int is_utc, len;
2551     char lastch;
2552     int negative = 0;
2553
2554 #undef time
2555     time_t now = time(0);
2556
2557     len = strlen(datestr);
2558     if (len > 0)
2559         lastch = datestr[len - 1];
2560     else
2561         lastch = '\0';
2562     is_utc = (lastch == 'z' || lastch == 'Z');
2563
2564     memset(&dt, 0, sizeof(dt));
2565
2566     p = datestr;
2567     q = NULL;
2568     if (!duration) {
2569         for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
2570             q = small_strptime(p, date_fmt[i], &dt);
2571             if (q) {
2572                 break;
2573             }
2574         }
2575
2576         if (!q) {
2577             if (is_utc) {
2578                 dt = *gmtime(&now);
2579             } else {
2580                 dt = *localtime(&now);
2581             }
2582             dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
2583         } else {
2584             p = q;
2585         }
2586
2587         if (*p == 'T' || *p == 't' || *p == ' ')
2588             p++;
2589
2590         for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
2591             q = small_strptime(p, time_fmt[i], &dt);
2592             if (q) {
2593                 break;
2594             }
2595         }
2596     } else {
2597         if (p[0] == '-') {
2598             negative = 1;
2599             ++p;
2600         }
2601         q = small_strptime(p, time_fmt[0], &dt);
2602         if (!q) {
2603             dt.tm_sec = strtol(p, (char **)&q, 10);
2604             dt.tm_min = 0;
2605             dt.tm_hour = 0;
2606         }
2607     }
2608
2609     /* Now we have all the fields that we can get */
2610     if (!q) {
2611         if (duration)
2612             return 0;
2613         else
2614             return now * INT64_C(1000000);
2615     }
2616
2617     if (duration) {
2618         t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2619     } else {
2620         dt.tm_isdst = -1;       /* unknown */
2621         if (is_utc) {
2622             t = mktimegm(&dt);
2623         } else {
2624             t = mktime(&dt);
2625         }
2626     }
2627
2628     t *= 1000000;
2629
2630     if (*q == '.') {
2631         int val, n;
2632         q++;
2633         for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
2634             if (!isdigit(*q))
2635                 break;
2636             val += n * (*q - '0');
2637         }
2638         t += val;
2639     }
2640     return negative ? -t : t;
2641 }
2642
2643 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
2644 {
2645     const char *p;
2646     char tag[128], *q;
2647
2648     p = info;
2649     if (*p == '?')
2650         p++;
2651     for(;;) {
2652         q = tag;
2653         while (*p != '\0' && *p != '=' && *p != '&') {
2654             if ((q - tag) < sizeof(tag) - 1)
2655                 *q++ = *p;
2656             p++;
2657         }
2658         *q = '\0';
2659         q = arg;
2660         if (*p == '=') {
2661             p++;
2662             while (*p != '&' && *p != '\0') {
2663                 if ((q - arg) < arg_size - 1) {
2664                     if (*p == '+')
2665                         *q++ = ' ';
2666                     else
2667                         *q++ = *p;
2668                 }
2669                 p++;
2670             }
2671             *q = '\0';
2672         }
2673         if (!strcmp(tag, tag1))
2674             return 1;
2675         if (*p != '&')
2676             break;
2677         p++;
2678     }
2679     return 0;
2680 }
2681
2682 int av_get_frame_filename(char *buf, int buf_size,
2683                           const char *path, int number)
2684 {
2685     const char *p;
2686     char *q, buf1[20], c;
2687     int nd, len, percentd_found;
2688
2689     q = buf;
2690     p = path;
2691     percentd_found = 0;
2692     for(;;) {
2693         c = *p++;
2694         if (c == '\0')
2695             break;
2696         if (c == '%') {
2697             do {
2698                 nd = 0;
2699                 while (isdigit(*p)) {
2700                     nd = nd * 10 + *p++ - '0';
2701                 }
2702                 c = *p++;
2703             } while (isdigit(c));
2704
2705             switch(c) {
2706             case '%':
2707                 goto addchar;
2708             case 'd':
2709                 if (percentd_found)
2710                     goto fail;
2711                 percentd_found = 1;
2712                 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
2713                 len = strlen(buf1);
2714                 if ((q - buf + len) > buf_size - 1)
2715                     goto fail;
2716                 memcpy(q, buf1, len);
2717                 q += len;
2718                 break;
2719             default:
2720                 goto fail;
2721             }
2722         } else {
2723         addchar:
2724             if ((q - buf) < buf_size - 1)
2725                 *q++ = c;
2726         }
2727     }
2728     if (!percentd_found)
2729         goto fail;
2730     *q = '\0';
2731     return 0;
2732  fail:
2733     *q = '\0';
2734     return -1;
2735 }
2736
2737 static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
2738 {
2739     int len, i, j, c;
2740 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
2741
2742     for(i=0;i<size;i+=16) {
2743         len = size - i;
2744         if (len > 16)
2745             len = 16;
2746         PRINT("%08x ", i);
2747         for(j=0;j<16;j++) {
2748             if (j < len)
2749                 PRINT(" %02x", buf[i+j]);
2750             else
2751                 PRINT("   ");
2752         }
2753         PRINT(" ");
2754         for(j=0;j<len;j++) {
2755             c = buf[i+j];
2756             if (c < ' ' || c > '~')
2757                 c = '.';
2758             PRINT("%c", c);
2759         }
2760         PRINT("\n");
2761     }
2762 #undef PRINT
2763 }
2764
2765 void av_hex_dump(FILE *f, uint8_t *buf, int size)
2766 {
2767     hex_dump_internal(NULL, f, 0, buf, size);
2768 }
2769
2770 void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
2771 {
2772     hex_dump_internal(avcl, NULL, level, buf, size);
2773 }
2774
2775  //FIXME needs to know the time_base
2776 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload)
2777 {
2778 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
2779     PRINT("stream #%d:\n", pkt->stream_index);
2780     PRINT("  keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
2781     PRINT("  duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
2782     /* DTS is _always_ valid after av_read_frame() */
2783     PRINT("  dts=");
2784     if (pkt->dts == AV_NOPTS_VALUE)
2785         PRINT("N/A");
2786     else
2787         PRINT("%0.3f", (double)pkt->dts / AV_TIME_BASE);
2788     /* PTS may be not known if B frames are present */
2789     PRINT("  pts=");
2790     if (pkt->pts == AV_NOPTS_VALUE)
2791         PRINT("N/A");
2792     else
2793         PRINT("%0.3f", (double)pkt->pts / AV_TIME_BASE);
2794     PRINT("\n");
2795     PRINT("  size=%d\n", pkt->size);
2796 #undef PRINT
2797     if (dump_payload)
2798         av_hex_dump(f, pkt->data, pkt->size);
2799 }
2800
2801 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
2802 {
2803     pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
2804 }
2805
2806 void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
2807 {
2808     pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
2809 }
2810
2811 void url_split(char *proto, int proto_size,
2812                char *authorization, int authorization_size,
2813                char *hostname, int hostname_size,
2814                int *port_ptr,
2815                char *path, int path_size,
2816                const char *url)
2817 {
2818     const char *p;
2819     char *q;
2820     int port;
2821
2822     port = -1;
2823
2824     p = url;
2825     q = proto;
2826     while (*p != ':' && *p != '\0') {
2827         if ((q - proto) < proto_size - 1)
2828             *q++ = *p;
2829         p++;
2830     }
2831     if (proto_size > 0)
2832         *q = '\0';
2833     if (authorization_size > 0)
2834         authorization[0] = '\0';
2835     if (*p == '\0') {
2836         if (proto_size > 0)
2837             proto[0] = '\0';
2838         if (hostname_size > 0)
2839             hostname[0] = '\0';
2840         p = url;
2841     } else {
2842         char *at,*slash; // PETR: position of '@' character and '/' character
2843
2844         p++;
2845         if (*p == '/')
2846             p++;
2847         if (*p == '/')
2848             p++;
2849         at = strchr(p,'@'); // PETR: get the position of '@'
2850         slash = strchr(p,'/');  // PETR: get position of '/' - end of hostname
2851         if (at && slash && at > slash) at = NULL; // PETR: not interested in '@' behind '/'
2852
2853         q = at ? authorization : hostname;  // PETR: if '@' exists starting with auth.
2854
2855          while ((at || *p != ':') && *p != '/' && *p != '?' && *p != '\0') { // PETR:
2856             if (*p == '@') {    // PETR: passed '@'
2857               if (authorization_size > 0)
2858                   *q = '\0';
2859               q = hostname;
2860               at = NULL;
2861             } else if (!at) {   // PETR: hostname
2862               if ((q - hostname) < hostname_size - 1)
2863                   *q++ = *p;
2864             } else {
2865               if ((q - authorization) < authorization_size - 1)
2866                 *q++ = *p;
2867             }
2868             p++;
2869         }
2870         if (hostname_size > 0)
2871             *q = '\0';
2872         if (*p == ':') {
2873             p++;
2874             port = strtoul(p, (char **)&p, 10);
2875         }
2876     }
2877     if (port_ptr)
2878         *port_ptr = port;
2879     av_strlcpy(path, p, path_size);
2880 }
2881
2882 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
2883                      int pts_num, int pts_den)
2884 {
2885     s->pts_wrap_bits = pts_wrap_bits;
2886     s->time_base.num = pts_num;
2887     s->time_base.den = pts_den;
2888 }
2889
2890 /* fraction handling */
2891
2892 /**
2893  * f = val + (num / den) + 0.5.
2894  *
2895  * 'num' is normalized so that it is such as 0 <= num < den.
2896  *
2897  * @param f fractional number
2898  * @param val integer value
2899  * @param num must be >= 0
2900  * @param den must be >= 1
2901  */
2902 static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
2903 {
2904     num += (den >> 1);
2905     if (num >= den) {
2906         val += num / den;
2907         num = num % den;
2908     }
2909     f->val = val;
2910     f->num = num;
2911     f->den = den;
2912 }
2913
2914 /**
2915  * Fractionnal addition to f: f = f + (incr / f->den).
2916  *
2917  * @param f fractional number
2918  * @param incr increment, can be positive or negative
2919  */
2920 static void av_frac_add(AVFrac *f, int64_t incr)
2921 {
2922     int64_t num, den;
2923
2924     num = f->num + incr;
2925     den = f->den;
2926     if (num < 0) {
2927         f->val += num / den;
2928         num = num % den;
2929         if (num < 0) {
2930             num += den;
2931             f->val--;
2932         }
2933     } else if (num >= den) {
2934         f->val += num / den;
2935         num = num % den;
2936     }
2937     f->num = num;
2938 }