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

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