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

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