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