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