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