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