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