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

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