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