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