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