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