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