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