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