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