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 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->need_parsing || !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 && st->need_parsing) {
 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 != MININT64) {
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=0;
1679     AVFrame picture;
1680
1681   if(!st->codec.codec){
1682     codec = avcodec_find_decoder(st->codec.codec_id);
1683     if (!codec)
1684         return -1;
1685     ret = avcodec_open(&st->codec, codec);
1686     if (ret < 0)
1687         return ret;
1688   }
1689
1690   if(!has_codec_parameters(&st->codec)){
1691     switch(st->codec.codec_type) {
1692     case CODEC_TYPE_VIDEO:
1693         ret = avcodec_decode_video(&st->codec, &picture,
1694                                    &got_picture, (uint8_t *)data, size);
1695         break;
1696     case CODEC_TYPE_AUDIO:
1697         samples = av_malloc(AVCODEC_MAX_AUDIO_FRAME_SIZE);
1698         if (!samples)
1699             goto fail;
1700         ret = avcodec_decode_audio(&st->codec, samples,
1701                                    &got_picture, (uint8_t *)data, size);
1702         av_free(samples);
1703         break;
1704     default:
1705         break;
1706     }
1707   }
1708  fail:
1709     return ret;
1710 }
1711
1712 /* absolute maximum size we read until we abort */
1713 #define MAX_READ_SIZE        5000000
1714
1715 /* maximum duration until we stop analysing the stream */
1716 #define MAX_STREAM_DURATION  ((int)(AV_TIME_BASE * 1.0))
1717
1718 /**
1719  * Read the beginning of a media file to get stream information. This
1720  * is useful for file formats with no headers such as MPEG. This
1721  * function also compute the real frame rate in case of mpeg2 repeat
1722  * frame mode.
1723  *
1724  * @param ic media file handle
1725  * @return >=0 if OK. AVERROR_xxx if error.
1726  * @todo let user decide somehow what information is needed so we dont waste time geting stuff the user doesnt need
1727  */
1728 int av_find_stream_info(AVFormatContext *ic)
1729 {
1730     int i, count, ret, read_size;
1731     AVStream *st;
1732     AVPacket pkt1, *pkt;
1733     AVPacketList *pktl=NULL, **ppktl;
1734     int64_t last_dts[MAX_STREAMS];
1735     int64_t duration_sum[MAX_STREAMS];
1736     int duration_count[MAX_STREAMS]={0};
1737
1738     for(i=0;i<ic->nb_streams;i++) {
1739         st = ic->streams[i];
1740         if(st->codec.codec_type == CODEC_TYPE_VIDEO){
1741 /*            if(!st->time_base.num)
1742                 st->time_base= */
1743             if(!st->codec.time_base.num)
1744                 st->codec.time_base= st->time_base;
1745         }
1746         //only for the split stuff
1747         if (!st->parser) {
1748             st->parser = av_parser_init(st->codec.codec_id);
1749         }
1750     }
1751
1752     for(i=0;i<MAX_STREAMS;i++){
1753         last_dts[i]= AV_NOPTS_VALUE;
1754         duration_sum[i]= INT64_MAX;
1755     }
1756
1757     count = 0;
1758     read_size = 0;
1759     ppktl = &ic->packet_buffer;
1760     for(;;) {
1761         /* check if one codec still needs to be handled */
1762         for(i=0;i<ic->nb_streams;i++) {
1763             st = ic->streams[i];
1764             if (!has_codec_parameters(&st->codec))
1765                 break;
1766             /* variable fps and no guess at the real fps */
1767             if(   st->codec.time_base.den >= 1000LL*st->codec.time_base.num
1768                && duration_count[i]<20 && st->codec.codec_type == CODEC_TYPE_VIDEO)
1769                 break;
1770             if(st->parser && st->parser->parser->split && !st->codec.extradata)
1771                 break;
1772         }
1773         if (i == ic->nb_streams) {
1774             /* NOTE: if the format has no header, then we need to read
1775                some packets to get most of the streams, so we cannot
1776                stop here */
1777             if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
1778                 /* if we found the info for all the codecs, we can stop */
1779                 ret = count;
1780                 break;
1781             }
1782         } else {
1783             /* we did not get all the codec info, but we read too much data */
1784             if (read_size >= MAX_READ_SIZE) {
1785                 ret = count;
1786                 break;
1787             }
1788         }
1789
1790         /* NOTE: a new stream can be added there if no header in file
1791            (AVFMTCTX_NOHEADER) */
1792         ret = av_read_frame_internal(ic, &pkt1);
1793         if (ret < 0) {
1794             /* EOF or error */
1795             ret = -1; /* we could not have all the codec parameters before EOF */
1796             for(i=0;i<ic->nb_streams;i++) {
1797                 st = ic->streams[i];
1798                 if (!has_codec_parameters(&st->codec))
1799                     break;
1800             }
1801             if (i == ic->nb_streams)
1802                 ret = 0;
1803             break;
1804         }
1805
1806         pktl = av_mallocz(sizeof(AVPacketList));
1807         if (!pktl) {
1808             ret = AVERROR_NOMEM;
1809             break;
1810         }
1811
1812         /* add the packet in the buffered packet list */
1813         *ppktl = pktl;
1814         ppktl = &pktl->next;
1815
1816         pkt = &pktl->pkt;
1817         *pkt = pkt1;
1818
1819         /* duplicate the packet */
1820         if (av_dup_packet(pkt) < 0) {
1821                 ret = AVERROR_NOMEM;
1822                 break;
1823         }
1824
1825         read_size += pkt->size;
1826
1827         st = ic->streams[pkt->stream_index];
1828         st->codec_info_duration += pkt->duration;
1829         if (pkt->duration != 0)
1830             st->codec_info_nb_frames++;
1831
1832         {
1833             int index= pkt->stream_index;
1834             int64_t last= last_dts[index];
1835             int64_t duration= pkt->dts - last;
1836
1837             if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
1838                 if(duration*duration_count[index]*10/9 < duration_sum[index]){
1839                     duration_sum[index]= duration;
1840                     duration_count[index]=1;
1841                 }else{
1842                     int factor= av_rescale(duration, duration_count[index], duration_sum[index]);
1843                     duration_sum[index] += duration;
1844                     duration_count[index]+= factor;
1845                 }
1846                 if(st->codec_info_nb_frames == 0 && 0)
1847                     st->codec_info_duration += duration;
1848             }
1849             last_dts[pkt->stream_index]= pkt->dts;
1850         }
1851         if(st->parser && st->parser->parser->split && !st->codec.extradata){
1852             int i= st->parser->parser->split(&st->codec, pkt->data, pkt->size);
1853             if(i){
1854                 st->codec.extradata_size= i;
1855                 st->codec.extradata= av_malloc(st->codec.extradata_size);
1856                 memcpy(st->codec.extradata, pkt->data, st->codec.extradata_size);
1857             }
1858         }
1859
1860         /* if still no information, we try to open the codec and to
1861            decompress the frame. We try to avoid that in most cases as
1862            it takes longer and uses more memory. For MPEG4, we need to
1863            decompress for Quicktime. */
1864         if (!has_codec_parameters(&st->codec) /*&&
1865             (st->codec.codec_id == CODEC_ID_FLV1 ||
1866              st->codec.codec_id == CODEC_ID_H264 ||
1867              st->codec.codec_id == CODEC_ID_H263 ||
1868              st->codec.codec_id == CODEC_ID_H261 ||
1869              st->codec.codec_id == CODEC_ID_VORBIS ||
1870              st->codec.codec_id == CODEC_ID_MJPEG ||
1871              st->codec.codec_id == CODEC_ID_PNG ||
1872              st->codec.codec_id == CODEC_ID_PAM ||
1873              st->codec.codec_id == CODEC_ID_PGM ||
1874              st->codec.codec_id == CODEC_ID_PGMYUV ||
1875              st->codec.codec_id == CODEC_ID_PBM ||
1876              st->codec.codec_id == CODEC_ID_PPM ||
1877              st->codec.codec_id == CODEC_ID_SHORTEN ||
1878              (st->codec.codec_id == CODEC_ID_MPEG4 && !st->need_parsing))*/)
1879             try_decode_frame(st, pkt->data, pkt->size);
1880
1881         if (av_rescale_q(st->codec_info_duration, st->time_base, AV_TIME_BASE_Q) >= MAX_STREAM_DURATION) {
1882             break;
1883         }
1884         count++;
1885     }
1886
1887     // close codecs which where opened in try_decode_frame()
1888     for(i=0;i<ic->nb_streams;i++) {
1889         st = ic->streams[i];
1890         if(st->codec.codec)
1891             avcodec_close(&st->codec);
1892     }
1893     for(i=0;i<ic->nb_streams;i++) {
1894         st = ic->streams[i];
1895         if (st->codec.codec_type == CODEC_TYPE_VIDEO) {
1896             if(st->codec.codec_id == CODEC_ID_RAWVIDEO && !st->codec.codec_tag && !st->codec.bits_per_sample)
1897                 st->codec.codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec.pix_fmt);
1898
1899             if(duration_count[i] && st->codec.time_base.num*1000LL <= st->codec.time_base.den &&
1900                st->time_base.num*duration_sum[i]/duration_count[i]*1000LL > st->time_base.den){
1901                 AVRational fps1;
1902                 int64_t num, den;
1903
1904                 num= st->time_base.den*duration_count[i];
1905                 den= st->time_base.num*duration_sum[i];
1906
1907                 av_reduce(&fps1.num, &fps1.den, num*1001, den*1000, FFMAX(st->time_base.den, st->time_base.num)/4);
1908                 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, den, FFMAX(st->time_base.den, st->time_base.num)/4);
1909                 if(fps1.num < st->r_frame_rate.num && fps1.den == 1 && (fps1.num==24 || fps1.num==30)){ //FIXME better decission
1910                     st->r_frame_rate.num= fps1.num*1000;
1911                     st->r_frame_rate.den= fps1.den*1001;
1912                 }
1913             }
1914
1915             /* set real frame rate info */
1916             /* compute the real frame rate for telecine */
1917             if ((st->codec.codec_id == CODEC_ID_MPEG1VIDEO ||
1918                  st->codec.codec_id == CODEC_ID_MPEG2VIDEO) &&
1919                 st->codec.sub_id == 2) {
1920                 if (st->codec_info_nb_frames >= 20) {
1921                     float coded_frame_rate, est_frame_rate;
1922                     est_frame_rate = ((double)st->codec_info_nb_frames * AV_TIME_BASE) /
1923                         (double)st->codec_info_duration ;
1924                     coded_frame_rate = 1.0/av_q2d(st->codec.time_base);
1925 #if 0
1926                     printf("telecine: coded_frame_rate=%0.3f est_frame_rate=%0.3f\n",
1927                            coded_frame_rate, est_frame_rate);
1928 #endif
1929                     /* if we detect that it could be a telecine, we
1930                        signal it. It would be better to do it at a
1931                        higher level as it can change in a film */
1932                     if (coded_frame_rate >= 24.97 &&
1933                         (est_frame_rate >= 23.5 && est_frame_rate < 24.5)) {
1934                         st->r_frame_rate = (AVRational){24000, 1001};
1935                     }
1936                 }
1937             }
1938             /* if no real frame rate, use the codec one */
1939             if (!st->r_frame_rate.num){
1940                 st->r_frame_rate.num = st->codec.time_base.den;
1941                 st->r_frame_rate.den = st->codec.time_base.num;
1942             }
1943         }
1944     }
1945
1946     av_estimate_timings(ic);
1947 #if 0
1948     /* correct DTS for b frame streams with no timestamps */
1949     for(i=0;i<ic->nb_streams;i++) {
1950         st = ic->streams[i];
1951         if (st->codec.codec_type == CODEC_TYPE_VIDEO) {
1952             if(b-frames){
1953                 ppktl = &ic->packet_buffer;
1954                 while(ppkt1){
1955                     if(ppkt1->stream_index != i)
1956                         continue;
1957                     if(ppkt1->pkt->dts < 0)
1958                         break;
1959                     if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
1960                         break;
1961                     ppkt1->pkt->dts -= delta;
1962                     ppkt1= ppkt1->next;
1963                 }
1964                 if(ppkt1)
1965                     continue;
1966                 st->cur_dts -= delta;
1967             }
1968         }
1969     }
1970 #endif
1971     return ret;
1972 }
1973
1974 /*******************************************************/
1975
1976 /**
1977  * start playing a network based stream (e.g. RTSP stream) at the
1978  * current position
1979  */
1980 int av_read_play(AVFormatContext *s)
1981 {
1982     if (!s->iformat->read_play)
1983         return AVERROR_NOTSUPP;
1984     return s->iformat->read_play(s);
1985 }
1986
1987 /**
1988  * pause a network based stream (e.g. RTSP stream). Use av_read_play()
1989  * to resume it.
1990  */
1991 int av_read_pause(AVFormatContext *s)
1992 {
1993     if (!s->iformat->read_pause)
1994         return AVERROR_NOTSUPP;
1995     return s->iformat->read_pause(s);
1996 }
1997
1998 /**
1999  * Close a media file (but not its codecs)
2000  *
2001  * @param s media file handle
2002  */
2003 void av_close_input_file(AVFormatContext *s)
2004 {
2005     int i, must_open_file;
2006     AVStream *st;
2007
2008     /* free previous packet */
2009     if (s->cur_st && s->cur_st->parser)
2010         av_free_packet(&s->cur_pkt);
2011
2012     if (s->iformat->read_close)
2013         s->iformat->read_close(s);
2014     for(i=0;i<s->nb_streams;i++) {
2015         /* free all data in a stream component */
2016         st = s->streams[i];
2017         if (st->parser) {
2018             av_parser_close(st->parser);
2019         }
2020         av_free(st->index_entries);
2021         av_free(st);
2022     }
2023     flush_packet_queue(s);
2024     must_open_file = 1;
2025     if (s->iformat->flags & AVFMT_NOFILE) {
2026         must_open_file = 0;
2027     }
2028     if (must_open_file) {
2029         url_fclose(&s->pb);
2030     }
2031     av_freep(&s->priv_data);
2032     av_free(s);
2033 }
2034
2035 /**
2036  * Add a new stream to a media file. Can only be called in the
2037  * read_header function. If the flag AVFMTCTX_NOHEADER is in the
2038  * format context, then new streams can be added in read_packet too.
2039  *
2040  *
2041  * @param s media file handle
2042  * @param id file format dependent stream id
2043  */
2044 AVStream *av_new_stream(AVFormatContext *s, int id)
2045 {
2046     AVStream *st;
2047
2048     if (s->nb_streams >= MAX_STREAMS)
2049         return NULL;
2050
2051     st = av_mallocz(sizeof(AVStream));
2052     if (!st)
2053         return NULL;
2054     avcodec_get_context_defaults(&st->codec);
2055     if (s->iformat) {
2056         /* no default bitrate if decoding */
2057         st->codec.bit_rate = 0;
2058     }
2059     st->index = s->nb_streams;
2060     st->id = id;
2061     st->start_time = AV_NOPTS_VALUE;
2062     st->duration = AV_NOPTS_VALUE;
2063     st->cur_dts = AV_NOPTS_VALUE;
2064
2065     /* default pts settings is MPEG like */
2066     av_set_pts_info(st, 33, 1, 90000);
2067     st->last_IP_pts = AV_NOPTS_VALUE;
2068
2069     s->streams[s->nb_streams++] = st;
2070     return st;
2071 }
2072
2073 /************************************************************/
2074 /* output media file */
2075
2076 int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2077 {
2078     int ret;
2079
2080     if (s->oformat->priv_data_size > 0) {
2081         s->priv_data = av_mallocz(s->oformat->priv_data_size);
2082         if (!s->priv_data)
2083             return AVERROR_NOMEM;
2084     } else
2085         s->priv_data = NULL;
2086
2087     if (s->oformat->set_parameters) {
2088         ret = s->oformat->set_parameters(s, ap);
2089         if (ret < 0)
2090             return ret;
2091     }
2092     return 0;
2093 }
2094
2095 /**
2096  * allocate the stream private data and write the stream header to an
2097  * output media file
2098  *
2099  * @param s media file handle
2100  * @return 0 if OK. AVERROR_xxx if error.
2101  */
2102 int av_write_header(AVFormatContext *s)
2103 {
2104     int ret, i;
2105     AVStream *st;
2106
2107     ret = s->oformat->write_header(s);
2108     if (ret < 0)
2109         return ret;
2110
2111     /* init PTS generation */
2112     for(i=0;i<s->nb_streams;i++) {
2113         st = s->streams[i];
2114
2115         switch (st->codec.codec_type) {
2116         case CODEC_TYPE_AUDIO:
2117             av_frac_init(&st->pts, 0, 0,
2118                          (int64_t)st->time_base.num * st->codec.sample_rate);
2119             break;
2120         case CODEC_TYPE_VIDEO:
2121             av_frac_init(&st->pts, 0, 0,
2122                          (int64_t)st->time_base.num * st->codec.time_base.den);
2123             break;
2124         default:
2125             break;
2126         }
2127     }
2128     return 0;
2129 }
2130
2131 //FIXME merge with compute_pkt_fields
2132 static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
2133     int b_frames = FFMAX(st->codec.has_b_frames, st->codec.max_b_frames);
2134     int num, den, frame_size;
2135
2136 //    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);
2137
2138 /*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2139         return -1;*/
2140
2141     /* duration field */
2142     if (pkt->duration == 0) {
2143         compute_frame_duration(&num, &den, st, NULL, pkt);
2144         if (den && num) {
2145             pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
2146         }
2147     }
2148
2149     //XXX/FIXME this is a temporary hack until all encoders output pts
2150     if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !b_frames){
2151         pkt->dts=
2152 //        pkt->pts= st->cur_dts;
2153         pkt->pts= st->pts.val;
2154     }
2155
2156     //calculate dts from pts
2157     if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE){
2158         if(b_frames){
2159             if(st->last_IP_pts == AV_NOPTS_VALUE){
2160                 st->last_IP_pts= -pkt->duration;
2161             }
2162             if(st->last_IP_pts < pkt->pts){
2163                 pkt->dts= st->last_IP_pts;
2164                 st->last_IP_pts= pkt->pts;
2165             }else
2166                 pkt->dts= pkt->pts;
2167         }else
2168             pkt->dts= pkt->pts;
2169     }
2170
2171     if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2172         av_log(NULL, AV_LOG_ERROR, "error, non monotone timestamps %Ld >= %Ld\n", st->cur_dts, pkt->dts);
2173         return -1;
2174     }
2175     if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2176         av_log(NULL, AV_LOG_ERROR, "error, pts < dts\n");
2177         return -1;
2178     }
2179
2180 //    av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%lld dts2:%lld\n", pkt->pts, pkt->dts);
2181     st->cur_dts= pkt->dts;
2182     st->pts.val= pkt->dts;
2183
2184     /* update pts */
2185     switch (st->codec.codec_type) {
2186     case CODEC_TYPE_AUDIO:
2187         frame_size = get_audio_frame_size(&st->codec, pkt->size);
2188
2189         /* HACK/FIXME, we skip the initial 0-size packets as they are most likely equal to the encoder delay,
2190            but it would be better if we had the real timestamps from the encoder */
2191         if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2192             av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2193         }
2194         break;
2195     case CODEC_TYPE_VIDEO:
2196         av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec.time_base.num);
2197         break;
2198     default:
2199         break;
2200     }
2201     return 0;
2202 }
2203
2204 static void truncate_ts(AVStream *st, AVPacket *pkt){
2205     int64_t pts_mask = (2LL << (st->pts_wrap_bits-1)) - 1;
2206
2207 //    if(pkt->dts < 0)
2208 //        pkt->dts= 0;  //this happens for low_delay=0 and b frames, FIXME, needs further invstigation about what we should do here
2209
2210     pkt->pts &= pts_mask;
2211     pkt->dts &= pts_mask;
2212 }
2213
2214 /**
2215  * Write a packet to an output media file. The packet shall contain
2216  * one audio or video frame.
2217  *
2218  * @param s media file handle
2219  * @param pkt the packet, which contains the stream_index, buf/buf_size, dts/pts, ...
2220  * @return < 0 if error, = 0 if OK, 1 if end of stream wanted.
2221  */
2222 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2223 {
2224     int ret;
2225
2226     ret=compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2227     if(ret<0)
2228         return ret;
2229
2230     truncate_ts(s->streams[pkt->stream_index], pkt);
2231
2232     ret= s->oformat->write_packet(s, pkt);
2233     if(!ret)
2234         ret= url_ferror(&s->pb);
2235     return ret;
2236 }
2237
2238 /**
2239  * interleave_packet implementation which will interleave per DTS.
2240  */
2241 static int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2242     AVPacketList *pktl, **next_point, *this_pktl;
2243     int stream_count=0;
2244     int streams[MAX_STREAMS];
2245
2246     if(pkt){
2247         AVStream *st= s->streams[ pkt->stream_index];
2248
2249         assert(pkt->destruct != av_destruct_packet); //FIXME
2250
2251         this_pktl = av_mallocz(sizeof(AVPacketList));
2252         this_pktl->pkt= *pkt;
2253         av_dup_packet(&this_pktl->pkt);
2254
2255         next_point = &s->packet_buffer;
2256         while(*next_point){
2257             AVStream *st2= s->streams[ (*next_point)->pkt.stream_index];
2258             int64_t left=  st2->time_base.num * (int64_t)st ->time_base.den;
2259             int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2260             if((*next_point)->pkt.dts * left > pkt->dts * right) //FIXME this can overflow
2261                 break;
2262             next_point= &(*next_point)->next;
2263         }
2264         this_pktl->next= *next_point;
2265         *next_point= this_pktl;
2266     }
2267
2268     memset(streams, 0, sizeof(streams));
2269     pktl= s->packet_buffer;
2270     while(pktl){
2271 //av_log(s, AV_LOG_DEBUG, "show st:%d dts:%lld\n", pktl->pkt.stream_index, pktl->pkt.dts);
2272         if(streams[ pktl->pkt.stream_index ] == 0)
2273             stream_count++;
2274         streams[ pktl->pkt.stream_index ]++;
2275         pktl= pktl->next;
2276     }
2277
2278     if(s->nb_streams == stream_count || (flush && stream_count)){
2279         pktl= s->packet_buffer;
2280         *out= pktl->pkt;
2281
2282         s->packet_buffer= pktl->next;
2283         av_freep(&pktl);
2284         return 1;
2285     }else{
2286         av_init_packet(out);
2287         return 0;
2288     }
2289 }
2290
2291 /**
2292  * Interleaves a AVPacket correctly so it can be muxed.
2293  * @param out the interleaved packet will be output here
2294  * @param in the input packet
2295  * @param flush 1 if no further packets are available as input and all
2296  *              remaining packets should be output
2297  * @return 1 if a packet was output, 0 if no packet could be output,
2298  *         < 0 if an error occured
2299  */
2300 static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2301     if(s->oformat->interleave_packet)
2302         return s->oformat->interleave_packet(s, out, in, flush);
2303     else
2304         return av_interleave_packet_per_dts(s, out, in, flush);
2305 }
2306
2307 /**
2308  * Writes a packet to an output media file ensuring correct interleaving.
2309  * The packet shall contain one audio or video frame.
2310  * If the packets are already correctly interleaved the application should
2311  * call av_write_frame() instead as its slightly faster, its also important
2312  * to keep in mind that completly non interleaved input will need huge amounts
2313  * of memory to interleave with this, so its prefereable to interleave at the
2314  * demuxer level
2315  *
2316  * @param s media file handle
2317  * @param pkt the packet, which contains the stream_index, buf/buf_size, dts/pts, ...
2318  * @return < 0 if error, = 0 if OK, 1 if end of stream wanted.
2319  */
2320 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2321     AVStream *st= s->streams[ pkt->stream_index];
2322
2323     //FIXME/XXX/HACK drop zero sized packets
2324     if(st->codec.codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2325         return 0;
2326
2327 //av_log(NULL, AV_LOG_DEBUG, "av_interleaved_write_frame %d %Ld %Ld\n", pkt->size, pkt->dts, pkt->pts);
2328     if(compute_pkt_fields2(st, pkt) < 0)
2329         return -1;
2330
2331     if(pkt->dts == AV_NOPTS_VALUE)
2332         return -1;
2333
2334     for(;;){
2335         AVPacket opkt;
2336         int ret= av_interleave_packet(s, &opkt, pkt, 0);
2337         if(ret<=0) //FIXME cleanup needed for ret<0 ?
2338             return ret;
2339
2340         truncate_ts(s->streams[opkt.stream_index], &opkt);
2341         ret= s->oformat->write_packet(s, &opkt);
2342
2343         av_free_packet(&opkt);
2344         pkt= NULL;
2345
2346         if(ret<0)
2347             return ret;
2348         if(url_ferror(&s->pb))
2349             return url_ferror(&s->pb);
2350     }
2351 }
2352
2353 /**
2354  * write the stream trailer to an output media file and and free the
2355  * file private data.
2356  *
2357  * @param s media file handle
2358  * @return 0 if OK. AVERROR_xxx if error.  */
2359 int av_write_trailer(AVFormatContext *s)
2360 {
2361     int ret, i;
2362
2363     for(;;){
2364         AVPacket pkt;
2365         ret= av_interleave_packet(s, &pkt, NULL, 1);
2366         if(ret<0) //FIXME cleanup needed for ret<0 ?
2367             goto fail;
2368         if(!ret)
2369             break;
2370
2371         truncate_ts(s->streams[pkt.stream_index], &pkt);
2372         ret= s->oformat->write_packet(s, &pkt);
2373
2374         av_free_packet(&pkt);
2375
2376         if(ret<0)
2377             goto fail;
2378         if(url_ferror(&s->pb))
2379             goto fail;
2380     }
2381
2382     ret = s->oformat->write_trailer(s);
2383 fail:
2384     if(ret == 0)
2385        ret=url_ferror(&s->pb);
2386     for(i=0;i<s->nb_streams;i++)
2387         av_freep(&s->streams[i]->priv_data);
2388     av_freep(&s->priv_data);
2389     return ret;
2390 }
2391
2392 /* "user interface" functions */
2393
2394 void dump_format(AVFormatContext *ic,
2395                  int index,
2396                  const char *url,
2397                  int is_output)
2398 {
2399     int i, flags;
2400     char buf[256];
2401
2402     av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
2403             is_output ? "Output" : "Input",
2404             index,
2405             is_output ? ic->oformat->name : ic->iformat->name,
2406             is_output ? "to" : "from", url);
2407     if (!is_output) {
2408         av_log(NULL, AV_LOG_INFO, "  Duration: ");
2409         if (ic->duration != AV_NOPTS_VALUE) {
2410             int hours, mins, secs, us;
2411             secs = ic->duration / AV_TIME_BASE;
2412             us = ic->duration % AV_TIME_BASE;
2413             mins = secs / 60;
2414             secs %= 60;
2415             hours = mins / 60;
2416             mins %= 60;
2417             av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%01d", hours, mins, secs,
2418                    (10 * us) / AV_TIME_BASE);
2419         } else {
2420             av_log(NULL, AV_LOG_INFO, "N/A");
2421         }
2422         if (ic->start_time != AV_NOPTS_VALUE) {
2423             int secs, us;
2424             av_log(NULL, AV_LOG_INFO, ", start: ");
2425             secs = ic->start_time / AV_TIME_BASE;
2426             us = ic->start_time % AV_TIME_BASE;
2427             av_log(NULL, AV_LOG_INFO, "%d.%06d",
2428                    secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
2429         }
2430         av_log(NULL, AV_LOG_INFO, ", bitrate: ");
2431         if (ic->bit_rate) {
2432             av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
2433         } else {
2434             av_log(NULL, AV_LOG_INFO, "N/A");
2435         }
2436         av_log(NULL, AV_LOG_INFO, "\n");
2437     }
2438     for(i=0;i<ic->nb_streams;i++) {
2439         AVStream *st = ic->streams[i];
2440         avcodec_string(buf, sizeof(buf), &st->codec, is_output);
2441         av_log(NULL, AV_LOG_INFO, "  Stream #%d.%d", index, i);
2442         /* the pid is an important information, so we display it */
2443         /* XXX: add a generic system */
2444         if (is_output)
2445             flags = ic->oformat->flags;
2446         else
2447             flags = ic->iformat->flags;
2448         if (flags & AVFMT_SHOW_IDS) {
2449             av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
2450         }
2451         av_log(NULL, AV_LOG_INFO, ": %s\n", buf);
2452     }
2453 }
2454
2455 typedef struct {
2456     const char *abv;
2457     int width, height;
2458     int frame_rate, frame_rate_base;
2459 } AbvEntry;
2460
2461 static AbvEntry frame_abvs[] = {
2462     { "ntsc",      720, 480, 30000, 1001 },
2463     { "pal",       720, 576,    25,    1 },
2464     { "qntsc",     352, 240, 30000, 1001 }, /* VCD compliant ntsc */
2465     { "qpal",      352, 288,    25,    1 }, /* VCD compliant pal */
2466     { "sntsc",     640, 480, 30000, 1001 }, /* square pixel ntsc */
2467     { "spal",      768, 576,    25,    1 }, /* square pixel pal */
2468     { "film",      352, 240,    24,    1 },
2469     { "ntsc-film", 352, 240, 24000, 1001 },
2470     { "sqcif",     128,  96,     0,    0 },
2471     { "qcif",      176, 144,     0,    0 },
2472     { "cif",       352, 288,     0,    0 },
2473     { "4cif",      704, 576,     0,    0 },
2474 };
2475
2476 int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2477 {
2478     int i;
2479     int n = sizeof(frame_abvs) / sizeof(AbvEntry);
2480     const char *p;
2481     int frame_width = 0, frame_height = 0;
2482
2483     for(i=0;i<n;i++) {
2484         if (!strcmp(frame_abvs[i].abv, str)) {
2485             frame_width = frame_abvs[i].width;
2486             frame_height = frame_abvs[i].height;
2487             break;
2488         }
2489     }
2490     if (i == n) {
2491         p = str;
2492         frame_width = strtol(p, (char **)&p, 10);
2493         if (*p)
2494             p++;
2495         frame_height = strtol(p, (char **)&p, 10);
2496     }
2497     if (frame_width <= 0 || frame_height <= 0)
2498         return -1;
2499     *width_ptr = frame_width;
2500     *height_ptr = frame_height;
2501     return 0;
2502 }
2503
2504 int parse_frame_rate(int *frame_rate, int *frame_rate_base, const char *arg)
2505 {
2506     int i;
2507     char* cp;
2508
2509     /* First, we check our abbreviation table */
2510     for (i = 0; i < sizeof(frame_abvs)/sizeof(*frame_abvs); ++i)
2511          if (!strcmp(frame_abvs[i].abv, arg)) {
2512              *frame_rate = frame_abvs[i].frame_rate;
2513              *frame_rate_base = frame_abvs[i].frame_rate_base;
2514              return 0;
2515          }
2516
2517     /* Then, we try to parse it as fraction */
2518     cp = strchr(arg, '/');
2519     if (!cp)
2520         cp = strchr(arg, ':');
2521     if (cp) {
2522         char* cpp;
2523         *frame_rate = strtol(arg, &cpp, 10);
2524         if (cpp != arg || cpp == cp)
2525             *frame_rate_base = strtol(cp+1, &cpp, 10);
2526         else
2527            *frame_rate = 0;
2528     }
2529     else {
2530         /* Finally we give up and parse it as double */
2531         *frame_rate_base = DEFAULT_FRAME_RATE_BASE; //FIXME use av_d2q()
2532         *frame_rate = (int)(strtod(arg, 0) * (*frame_rate_base) + 0.5);
2533     }
2534     if (!*frame_rate || !*frame_rate_base)
2535         return -1;
2536     else
2537         return 0;
2538 }
2539
2540 /* Syntax:
2541  * - If not a duration:
2542  *  [{YYYY-MM-DD|YYYYMMDD}]{T| }{HH[:MM[:SS[.m...]]][Z]|HH[MM[SS[.m...]]][Z]}
2543  * Time is localtime unless Z is suffixed to the end. In this case GMT
2544  * Return the date in micro seconds since 1970
2545  * - If duration:
2546  *  HH[:MM[:SS[.m...]]]
2547  *  S+[.m...]
2548  */
2549 int64_t parse_date(const char *datestr, int duration)
2550 {
2551     const char *p;
2552     int64_t t;
2553     struct tm dt;
2554     int i;
2555     static const char *date_fmt[] = {
2556         "%Y-%m-%d",
2557         "%Y%m%d",
2558     };
2559     static const char *time_fmt[] = {
2560         "%H:%M:%S",
2561         "%H%M%S",
2562     };
2563     const char *q;
2564     int is_utc, len;
2565     char lastch;
2566     int negative = 0;
2567
2568 #undef time
2569     time_t now = time(0);
2570
2571     len = strlen(datestr);
2572     if (len > 0)
2573         lastch = datestr[len - 1];
2574     else
2575         lastch = '\0';
2576     is_utc = (lastch == 'z' || lastch == 'Z');
2577
2578     memset(&dt, 0, sizeof(dt));
2579
2580     p = datestr;
2581     q = NULL;
2582     if (!duration) {
2583         for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
2584             q = small_strptime(p, date_fmt[i], &dt);
2585             if (q) {
2586                 break;
2587             }
2588         }
2589
2590         if (!q) {
2591             if (is_utc) {
2592                 dt = *gmtime(&now);
2593             } else {
2594                 dt = *localtime(&now);
2595             }
2596             dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
2597         } else {
2598             p = q;
2599         }
2600
2601         if (*p == 'T' || *p == 't' || *p == ' ')
2602             p++;
2603
2604         for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
2605             q = small_strptime(p, time_fmt[i], &dt);
2606             if (q) {
2607                 break;
2608             }
2609         }
2610     } else {
2611         if (p[0] == '-') {
2612             negative = 1;
2613             ++p;
2614         }
2615         q = small_strptime(p, time_fmt[0], &dt);
2616         if (!q) {
2617             dt.tm_sec = strtol(p, (char **)&q, 10);
2618             dt.tm_min = 0;
2619             dt.tm_hour = 0;
2620         }
2621     }
2622
2623     /* Now we have all the fields that we can get */
2624     if (!q) {
2625         if (duration)
2626             return 0;
2627         else
2628             return now * int64_t_C(1000000);
2629     }
2630
2631     if (duration) {
2632         t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2633     } else {
2634         dt.tm_isdst = -1;       /* unknown */
2635         if (is_utc) {
2636             t = mktimegm(&dt);
2637         } else {
2638             t = mktime(&dt);
2639         }
2640     }
2641
2642     t *= 1000000;
2643
2644     if (*q == '.') {
2645         int val, n;
2646         q++;
2647         for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
2648             if (!isdigit(*q))
2649                 break;
2650             val += n * (*q - '0');
2651         }
2652         t += val;
2653     }
2654     return negative ? -t : t;
2655 }
2656
2657 /* syntax: '?tag1=val1&tag2=val2...'. Little URL decoding is done. Return
2658    1 if found */
2659 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
2660 {
2661     const char *p;
2662     char tag[128], *q;
2663
2664     p = info;
2665     if (*p == '?')
2666         p++;
2667     for(;;) {
2668         q = tag;
2669         while (*p != '\0' && *p != '=' && *p != '&') {
2670             if ((q - tag) < sizeof(tag) - 1)
2671                 *q++ = *p;
2672             p++;
2673         }
2674         *q = '\0';
2675         q = arg;
2676         if (*p == '=') {
2677             p++;
2678             while (*p != '&' && *p != '\0') {
2679                 if ((q - arg) < arg_size - 1) {
2680                     if (*p == '+')
2681                         *q++ = ' ';
2682                     else
2683                         *q++ = *p;
2684                 }
2685                 p++;
2686             }
2687             *q = '\0';
2688         }
2689         if (!strcmp(tag, tag1))
2690             return 1;
2691         if (*p != '&')
2692             break;
2693         p++;
2694     }
2695     return 0;
2696 }
2697
2698 /* Return in 'buf' the path with '%d' replaced by number. Also handles
2699    the '%0nd' format where 'n' is the total number of digits and
2700    '%%'. Return 0 if OK, and -1 if format error */
2701 int get_frame_filename(char *buf, int buf_size,
2702                        const char *path, int number)
2703 {
2704     const char *p;
2705     char *q, buf1[20], c;
2706     int nd, len, percentd_found;
2707
2708     q = buf;
2709     p = path;
2710     percentd_found = 0;
2711     for(;;) {
2712         c = *p++;
2713         if (c == '\0')
2714             break;
2715         if (c == '%') {
2716             do {
2717                 nd = 0;
2718                 while (isdigit(*p)) {
2719                     nd = nd * 10 + *p++ - '0';
2720                 }
2721                 c = *p++;
2722             } while (isdigit(c));
2723
2724             switch(c) {
2725             case '%':
2726                 goto addchar;
2727             case 'd':
2728                 if (percentd_found)
2729                     goto fail;
2730                 percentd_found = 1;
2731                 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
2732                 len = strlen(buf1);
2733                 if ((q - buf + len) > buf_size - 1)
2734                     goto fail;
2735                 memcpy(q, buf1, len);
2736                 q += len;
2737                 break;
2738             default:
2739                 goto fail;
2740             }
2741         } else {
2742         addchar:
2743             if ((q - buf) < buf_size - 1)
2744                 *q++ = c;
2745         }
2746     }
2747     if (!percentd_found)
2748         goto fail;
2749     *q = '\0';
2750     return 0;
2751  fail:
2752     *q = '\0';
2753     return -1;
2754 }
2755
2756 /**
2757  * Print  nice hexa dump of a buffer
2758  * @param f stream for output
2759  * @param buf buffer
2760  * @param size buffer size
2761  */
2762 void av_hex_dump(FILE *f, uint8_t *buf, int size)
2763 {
2764     int len, i, j, c;
2765
2766     for(i=0;i<size;i+=16) {
2767         len = size - i;
2768         if (len > 16)
2769             len = 16;
2770         fprintf(f, "%08x ", i);
2771         for(j=0;j<16;j++) {
2772             if (j < len)
2773                 fprintf(f, " %02x", buf[i+j]);
2774             else
2775                 fprintf(f, "   ");
2776         }
2777         fprintf(f, " ");
2778         for(j=0;j<len;j++) {
2779             c = buf[i+j];
2780             if (c < ' ' || c > '~')
2781                 c = '.';
2782             fprintf(f, "%c", c);
2783         }
2784         fprintf(f, "\n");
2785     }
2786 }
2787
2788 /**
2789  * Print on 'f' a nice dump of a packet
2790  * @param f stream for output
2791  * @param pkt packet to dump
2792  * @param dump_payload true if the payload must be displayed too
2793  */
2794  //FIXME needs to know the time_base
2795 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
2796 {
2797     fprintf(f, "stream #%d:\n", pkt->stream_index);
2798     fprintf(f, "  keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
2799     fprintf(f, "  duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
2800     /* DTS is _always_ valid after av_read_frame() */
2801     fprintf(f, "  dts=");
2802     if (pkt->dts == AV_NOPTS_VALUE)
2803         fprintf(f, "N/A");
2804     else
2805         fprintf(f, "%0.3f", (double)pkt->dts / AV_TIME_BASE);
2806     /* PTS may be not known if B frames are present */
2807     fprintf(f, "  pts=");
2808     if (pkt->pts == AV_NOPTS_VALUE)
2809         fprintf(f, "N/A");
2810     else
2811         fprintf(f, "%0.3f", (double)pkt->pts / AV_TIME_BASE);
2812     fprintf(f, "\n");
2813     fprintf(f, "  size=%d\n", pkt->size);
2814     if (dump_payload)
2815         av_hex_dump(f, pkt->data, pkt->size);
2816 }
2817
2818 void url_split(char *proto, int proto_size,
2819                char *authorization, int authorization_size,
2820                char *hostname, int hostname_size,
2821                int *port_ptr,
2822                char *path, int path_size,
2823                const char *url)
2824 {
2825     const char *p;
2826     char *q;
2827     int port;
2828
2829     port = -1;
2830
2831     p = url;
2832     q = proto;
2833     while (*p != ':' && *p != '\0') {
2834         if ((q - proto) < proto_size - 1)
2835             *q++ = *p;
2836         p++;
2837     }
2838     if (proto_size > 0)
2839         *q = '\0';
2840     if (authorization_size > 0)
2841         authorization[0] = '\0';
2842     if (*p == '\0') {
2843         if (proto_size > 0)
2844             proto[0] = '\0';
2845         if (hostname_size > 0)
2846             hostname[0] = '\0';
2847         p = url;
2848     } else {
2849         char *at,*slash; // PETR: position of '@' character and '/' character
2850
2851         p++;
2852         if (*p == '/')
2853             p++;
2854         if (*p == '/')
2855             p++;
2856         at = strchr(p,'@'); // PETR: get the position of '@'
2857         slash = strchr(p,'/');  // PETR: get position of '/' - end of hostname
2858         if (at && slash && at > slash) at = NULL; // PETR: not interested in '@' behind '/'
2859
2860         q = at ? authorization : hostname;  // PETR: if '@' exists starting with auth.
2861
2862          while ((at || *p != ':') && *p != '/' && *p != '?' && *p != '\0') { // PETR:
2863             if (*p == '@') {    // PETR: passed '@'
2864               if (authorization_size > 0)
2865                   *q = '\0';
2866               q = hostname;
2867               at = NULL;
2868             } else if (!at) {   // PETR: hostname
2869               if ((q - hostname) < hostname_size - 1)
2870                   *q++ = *p;
2871             } else {
2872               if ((q - authorization) < authorization_size - 1)
2873                 *q++ = *p;
2874             }
2875             p++;
2876         }
2877         if (hostname_size > 0)
2878             *q = '\0';
2879         if (*p == ':') {
2880             p++;
2881             port = strtoul(p, (char **)&p, 10);
2882         }
2883     }
2884     if (port_ptr)
2885         *port_ptr = port;
2886     pstrcpy(path, path_size, p);
2887 }
2888
2889 /**
2890  * Set the pts for a given stream
2891  * @param s stream
2892  * @param pts_wrap_bits number of bits effectively used by the pts
2893  *        (used for wrap control, 33 is the value for MPEG)
2894  * @param pts_num numerator to convert to seconds (MPEG: 1)
2895  * @param pts_den denominator to convert to seconds (MPEG: 90000)
2896  */
2897 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
2898                      int pts_num, int pts_den)
2899 {
2900     s->pts_wrap_bits = pts_wrap_bits;
2901     s->time_base.num = pts_num;
2902     s->time_base.den = pts_den;
2903 }
2904
2905 /* fraction handling */
2906
2907 /**
2908  * f = val + (num / den) + 0.5. 'num' is normalized so that it is such
2909  * as 0 <= num < den.
2910  *
2911  * @param f fractional number
2912  * @param val integer value
2913  * @param num must be >= 0
2914  * @param den must be >= 1
2915  */
2916 void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
2917 {
2918     num += (den >> 1);
2919     if (num >= den) {
2920         val += num / den;
2921         num = num % den;
2922     }
2923     f->val = val;
2924     f->num = num;
2925     f->den = den;
2926 }
2927
2928 /* set f to (val + 0.5) */
2929 void av_frac_set(AVFrac *f, int64_t val)
2930 {
2931     f->val = val;
2932     f->num = f->den >> 1;
2933 }
2934
2935 /**
2936  * Fractionnal addition to f: f = f + (incr / f->den)
2937  *
2938  * @param f fractional number
2939  * @param incr increment, can be positive or negative
2940  */
2941 void av_frac_add(AVFrac *f, int64_t incr)
2942 {
2943     int64_t num, den;
2944
2945     num = f->num + incr;
2946     den = f->den;
2947     if (num < 0) {
2948         f->val += num / den;
2949         num = num % den;
2950         if (num < 0) {
2951             num += den;
2952             f->val--;
2953         }
2954     } else if (num >= den) {
2955         f->val += num / den;
2956         num = num % den;
2957     }
2958     f->num = num;
2959 }
2960
2961 /**
2962  * register a new image format
2963  * @param img_fmt Image format descriptor
2964  */
2965 void av_register_image_format(AVImageFormat *img_fmt)
2966 {
2967     AVImageFormat **p;
2968
2969     p = &first_image_format;
2970     while (*p != NULL) p = &(*p)->next;
2971     *p = img_fmt;
2972     img_fmt->next = NULL;
2973 }
2974
2975 /* guess image format */
2976 AVImageFormat *av_probe_image_format(AVProbeData *pd)
2977 {
2978     AVImageFormat *fmt1, *fmt;
2979     int score, score_max;
2980
2981     fmt = NULL;
2982     score_max = 0;
2983     for(fmt1 = first_image_format; fmt1 != NULL; fmt1 = fmt1->next) {
2984         if (fmt1->img_probe) {
2985             score = fmt1->img_probe(pd);
2986             if (score > score_max) {
2987                 score_max = score;
2988                 fmt = fmt1;
2989             }
2990         }
2991     }
2992     return fmt;
2993 }
2994
2995 AVImageFormat *guess_image_format(const char *filename)
2996 {
2997     AVImageFormat *fmt1;
2998
2999     for(fmt1 = first_image_format; fmt1 != NULL; fmt1 = fmt1->next) {
3000         if (fmt1->extensions && match_ext(filename, fmt1->extensions))
3001             return fmt1;
3002     }
3003     return NULL;
3004 }
3005
3006 /**
3007  * Read an image from a stream.
3008  * @param gb byte stream containing the image
3009  * @param fmt image format, NULL if probing is required
3010  */
3011 int av_read_image(ByteIOContext *pb, const char *filename,
3012                   AVImageFormat *fmt,
3013                   int (*alloc_cb)(void *, AVImageInfo *info), void *opaque)
3014 {
3015     char buf[PROBE_BUF_SIZE];
3016     AVProbeData probe_data, *pd = &probe_data;
3017     offset_t pos;
3018     int ret;
3019
3020     if (!fmt) {
3021         pd->filename = filename;
3022         pd->buf = buf;
3023         pos = url_ftell(pb);
3024         pd->buf_size = get_buffer(pb, buf, PROBE_BUF_SIZE);
3025         url_fseek(pb, pos, SEEK_SET);
3026         fmt = av_probe_image_format(pd);
3027     }
3028     if (!fmt)
3029         return AVERROR_NOFMT;
3030     ret = fmt->img_read(pb, alloc_cb, opaque);
3031     return ret;
3032 }
3033
3034 /**
3035  * Write an image to a stream.
3036  * @param pb byte stream for the image output
3037  * @param fmt image format
3038  * @param img image data and informations
3039  */
3040 int av_write_image(ByteIOContext *pb, AVImageFormat *fmt, AVImageInfo *img)
3041 {
3042     return fmt->img_write(pb, img);
3043 }
3044