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