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