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