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

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