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

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