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