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

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