git.sesse.net Git - ffmpeg/blob - libavformat/utils.c

   1 /*
   2  * various utility functions for use within FFmpeg
   3  * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
   4  *
   5  * This file is part of FFmpeg.
   6  *
   7  * FFmpeg is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * FFmpeg is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with FFmpeg; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21 #include "avformat.h"
  22 #include "internal.h"
  23 #include "libavcodec/opt.h"
  24 #include "metadata.h"
  25 #include "libavutil/avstring.h"
  26 #include "riff.h"
  27 #include <sys/time.h>
  28 #include <time.h>
  29 #include <strings.h>
  30
  31 #undef NDEBUG
  32 #include <assert.h>
  33
  34 /**
  35  * @file libavformat/utils.c
  36  * various utility functions for use within FFmpeg
  37  */
  38
  39 unsigned avformat_version(void)
  40 {
  41     return LIBAVFORMAT_VERSION_INT;
  42 }
  43
  44 const char * avformat_configuration(void)
  45 {
  46     return FFMPEG_CONFIGURATION;
  47 }
  48
  49 const char * avformat_license(void)
  50 {
  51 #define LICENSE_PREFIX "libavformat license: "
  52     return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;
  53 }
  54
  55 /* fraction handling */
  56
  57 /**
  58  * f = val + (num / den) + 0.5.
  59  *
  60  * 'num' is normalized so that it is such as 0 <= num < den.
  61  *
  62  * @param f fractional number
  63  * @param val integer value
  64  * @param num must be >= 0
  65  * @param den must be >= 1
  66  */
  67 static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
  68 {
  69     num += (den >> 1);
  70     if (num >= den) {
  71         val += num / den;
  72         num = num % den;
  73     }
  74     f->val = val;
  75     f->num = num;
  76     f->den = den;
  77 }
  78
  79 /**
  80  * Fractional addition to f: f = f + (incr / f->den).
  81  *
  82  * @param f fractional number
  83  * @param incr increment, can be positive or negative
  84  */
  85 static void av_frac_add(AVFrac *f, int64_t incr)
  86 {
  87     int64_t num, den;
  88
  89     num = f->num + incr;
  90     den = f->den;
  91     if (num < 0) {
  92         f->val += num / den;
  93         num = num % den;
  94         if (num < 0) {
  95             num += den;
  96             f->val--;
  97         }
  98     } else if (num >= den) {
  99         f->val += num / den;
 100         num = num % den;
 101     }
 102     f->num = num;
 103 }
 104
 105 /** head of registered input format linked list */
 106 AVInputFormat *first_iformat = NULL;
 107 /** head of registered output format linked list */
 108 AVOutputFormat *first_oformat = NULL;
 109
 110 AVInputFormat  *av_iformat_next(AVInputFormat  *f)
 111 {
 112     if(f) return f->next;
 113     else  return first_iformat;
 114 }
 115
 116 AVOutputFormat *av_oformat_next(AVOutputFormat *f)
 117 {
 118     if(f) return f->next;
 119     else  return first_oformat;
 120 }
 121
 122 void av_register_input_format(AVInputFormat *format)
 123 {
 124     AVInputFormat **p;
 125     p = &first_iformat;
 126     while (*p != NULL) p = &(*p)->next;
 127     *p = format;
 128     format->next = NULL;
 129 }
 130
 131 void av_register_output_format(AVOutputFormat *format)
 132 {
 133     AVOutputFormat **p;
 134     p = &first_oformat;
 135     while (*p != NULL) p = &(*p)->next;
 136     *p = format;
 137     format->next = NULL;
 138 }
 139
 140 int match_ext(const char *filename, const char *extensions)
 141 {
 142     const char *ext, *p;
 143     char ext1[32], *q;
 144
 145     if(!filename)
 146         return 0;
 147
 148     ext = strrchr(filename, '.');
 149     if (ext) {
 150         ext++;
 151         p = extensions;
 152         for(;;) {
 153             q = ext1;
 154             while (*p != '\0' && *p != ',' && q-ext1<sizeof(ext1)-1)
 155                 *q++ = *p++;
 156             *q = '\0';
 157             if (!strcasecmp(ext1, ext))
 158                 return 1;
 159             if (*p == '\0')
 160                 break;
 161             p++;
 162         }
 163     }
 164     return 0;
 165 }
 166
 167 static int match_format(const char *name, const char *names)
 168 {
 169     const char *p;
 170     int len, namelen;
 171
 172     if (!name || !names)
 173         return 0;
 174
 175     namelen = strlen(name);
 176     while ((p = strchr(names, ','))) {
 177         len = FFMAX(p - names, namelen);
 178         if (!strncasecmp(name, names, len))
 179             return 1;
 180         names = p+1;
 181     }
 182     return !strcasecmp(name, names);
 183 }
 184
 185 AVOutputFormat *guess_format(const char *short_name, const char *filename,
 186                              const char *mime_type)
 187 {
 188     AVOutputFormat *fmt, *fmt_found;
 189     int score_max, score;
 190
 191     /* specific test for image sequences */
 192 #if CONFIG_IMAGE2_MUXER
 193     if (!short_name && filename &&
 194         av_filename_number_test(filename) &&
 195         av_guess_image2_codec(filename) != CODEC_ID_NONE) {
 196         return guess_format("image2", NULL, NULL);
 197     }
 198 #endif
 199     /* Find the proper file type. */
 200     fmt_found = NULL;
 201     score_max = 0;
 202     fmt = first_oformat;
 203     while (fmt != NULL) {
 204         score = 0;
 205         if (fmt->name && short_name && !strcmp(fmt->name, short_name))
 206             score += 100;
 207         if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
 208             score += 10;
 209         if (filename && fmt->extensions &&
 210             match_ext(filename, fmt->extensions)) {
 211             score += 5;
 212         }
 213         if (score > score_max) {
 214             score_max = score;
 215             fmt_found = fmt;
 216         }
 217         fmt = fmt->next;
 218     }
 219     return fmt_found;
 220 }
 221
 222 AVOutputFormat *guess_stream_format(const char *short_name, const char *filename,
 223                              const char *mime_type)
 224 {
 225     AVOutputFormat *fmt = guess_format(short_name, filename, mime_type);
 226
 227     if (fmt) {
 228         AVOutputFormat *stream_fmt;
 229         char stream_format_name[64];
 230
 231         snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
 232         stream_fmt = guess_format(stream_format_name, NULL, NULL);
 233
 234         if (stream_fmt)
 235             fmt = stream_fmt;
 236     }
 237
 238     return fmt;
 239 }
 240
 241 enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
 242                             const char *filename, const char *mime_type, enum CodecType type){
 243     if(type == CODEC_TYPE_VIDEO){
 244         enum CodecID codec_id= CODEC_ID_NONE;
 245
 246 #if CONFIG_IMAGE2_MUXER
 247         if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
 248             codec_id= av_guess_image2_codec(filename);
 249         }
 250 #endif
 251         if(codec_id == CODEC_ID_NONE)
 252             codec_id= fmt->video_codec;
 253         return codec_id;
 254     }else if(type == CODEC_TYPE_AUDIO)
 255         return fmt->audio_codec;
 256     else
 257         return CODEC_ID_NONE;
 258 }
 259
 260 AVInputFormat *av_find_input_format(const char *short_name)
 261 {
 262     AVInputFormat *fmt;
 263     for(fmt = first_iformat; fmt != NULL; fmt = fmt->next) {
 264         if (match_format(short_name, fmt->name))
 265             return fmt;
 266     }
 267     return NULL;
 268 }
 269
 270 /* memory handling */
 271
 272
 273 int av_get_packet(ByteIOContext *s, AVPacket *pkt, int size)
 274 {
 275     int ret= av_new_packet(pkt, size);
 276
 277     if(ret<0)
 278         return ret;
 279
 280     pkt->pos= url_ftell(s);
 281
 282     ret= get_buffer(s, pkt->data, size);
 283     if(ret<=0)
 284         av_free_packet(pkt);
 285     else
 286         av_shrink_packet(pkt, ret);
 287
 288     return ret;
 289 }
 290
 291
 292 int av_filename_number_test(const char *filename)
 293 {
 294     char buf[1024];
 295     return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
 296 }
 297
 298 static AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
 299 {
 300     AVInputFormat *fmt1, *fmt;
 301     int score;
 302
 303     fmt = NULL;
 304     for(fmt1 = first_iformat; fmt1 != NULL; fmt1 = fmt1->next) {
 305         if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
 306             continue;
 307         score = 0;
 308         if (fmt1->read_probe) {
 309             score = fmt1->read_probe(pd);
 310         } else if (fmt1->extensions) {
 311             if (match_ext(pd->filename, fmt1->extensions)) {
 312                 score = 50;
 313             }
 314         }
 315         if (score > *score_max) {
 316             *score_max = score;
 317             fmt = fmt1;
 318         }else if (score == *score_max)
 319             fmt = NULL;
 320     }
 321     return fmt;
 322 }
 323
 324 AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
 325     int score=0;
 326     return av_probe_input_format2(pd, is_opened, &score);
 327 }
 328
 329 static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st, AVProbeData *pd, int score)
 330 {
 331     AVInputFormat *fmt;
 332     fmt = av_probe_input_format2(pd, 1, &score);
 333
 334     if (fmt) {
 335         av_log(s, AV_LOG_DEBUG, "Probe with size=%d, packets=%d detected %s with score=%d\n",
 336                pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets, fmt->name, score);
 337         if (!strcmp(fmt->name, "mp3")) {
 338             st->codec->codec_id = CODEC_ID_MP3;
 339             st->codec->codec_type = CODEC_TYPE_AUDIO;
 340         } else if (!strcmp(fmt->name, "ac3")) {
 341             st->codec->codec_id = CODEC_ID_AC3;
 342             st->codec->codec_type = CODEC_TYPE_AUDIO;
 343         } else if (!strcmp(fmt->name, "eac3")) {
 344             st->codec->codec_id = CODEC_ID_EAC3;
 345             st->codec->codec_type = CODEC_TYPE_AUDIO;
 346         } else if (!strcmp(fmt->name, "mpegvideo")) {
 347             st->codec->codec_id = CODEC_ID_MPEG2VIDEO;
 348             st->codec->codec_type = CODEC_TYPE_VIDEO;
 349         } else if (!strcmp(fmt->name, "m4v")) {
 350             st->codec->codec_id = CODEC_ID_MPEG4;
 351             st->codec->codec_type = CODEC_TYPE_VIDEO;
 352         } else if (!strcmp(fmt->name, "h264")) {
 353             st->codec->codec_id = CODEC_ID_H264;
 354             st->codec->codec_type = CODEC_TYPE_VIDEO;
 355         } else if (!strcmp(fmt->name, "dts")) {
 356             st->codec->codec_id = CODEC_ID_DTS;
 357             st->codec->codec_type = CODEC_TYPE_AUDIO;
 358         }
 359     }
 360     return !!fmt;
 361 }
 362
 363 /************************************************************/
 364 /* input media file */
 365
 366 /**
 367  * Open a media file from an IO stream. 'fmt' must be specified.
 368  */
 369 int av_open_input_stream(AVFormatContext **ic_ptr,
 370                          ByteIOContext *pb, const char *filename,
 371                          AVInputFormat *fmt, AVFormatParameters *ap)
 372 {
 373     int err;
 374     AVFormatContext *ic;
 375     AVFormatParameters default_ap;
 376
 377     if(!ap){
 378         ap=&default_ap;
 379         memset(ap, 0, sizeof(default_ap));
 380     }
 381
 382     if(!ap->prealloced_context)
 383         ic = avformat_alloc_context();
 384     else
 385         ic = *ic_ptr;
 386     if (!ic) {
 387         err = AVERROR(ENOMEM);
 388         goto fail;
 389     }
 390     ic->iformat = fmt;
 391     ic->pb = pb;
 392     ic->duration = AV_NOPTS_VALUE;
 393     ic->start_time = AV_NOPTS_VALUE;
 394     av_strlcpy(ic->filename, filename, sizeof(ic->filename));
 395
 396     /* allocate private data */
 397     if (fmt->priv_data_size > 0) {
 398         ic->priv_data = av_mallocz(fmt->priv_data_size);
 399         if (!ic->priv_data) {
 400             err = AVERROR(ENOMEM);
 401             goto fail;
 402         }
 403     } else {
 404         ic->priv_data = NULL;
 405     }
 406
 407     if (ic->iformat->read_header) {
 408         err = ic->iformat->read_header(ic, ap);
 409         if (err < 0)
 410             goto fail;
 411     }
 412
 413     if (pb && !ic->data_offset)
 414         ic->data_offset = url_ftell(ic->pb);
 415
 416 #if LIBAVFORMAT_VERSION_MAJOR < 53
 417     ff_metadata_demux_compat(ic);
 418 #endif
 419
 420     ic->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
 421
 422     *ic_ptr = ic;
 423     return 0;
 424  fail:
 425     if (ic) {
 426         int i;
 427         av_freep(&ic->priv_data);
 428         for(i=0;i<ic->nb_streams;i++) {
 429             AVStream *st = ic->streams[i];
 430             if (st) {
 431                 av_free(st->priv_data);
 432                 av_free(st->codec->extradata);
 433             }
 434             av_free(st);
 435         }
 436     }
 437     av_free(ic);
 438     *ic_ptr = NULL;
 439     return err;
 440 }
 441
 442 /** size of probe buffer, for guessing file type from file contents */
 443 #define PROBE_BUF_MIN 2048
 444 #define PROBE_BUF_MAX (1<<20)
 445
 446 int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
 447                        AVInputFormat *fmt,
 448                        int buf_size,
 449                        AVFormatParameters *ap)
 450 {
 451     int err, probe_size;
 452     AVProbeData probe_data, *pd = &probe_data;
 453     ByteIOContext *pb = NULL;
 454     void *logctx= ap && ap->prealloced_context ? *ic_ptr : NULL;
 455
 456     pd->filename = "";
 457     if (filename)
 458         pd->filename = filename;
 459     pd->buf = NULL;
 460     pd->buf_size = 0;
 461
 462     if (!fmt) {
 463         /* guess format if no file can be opened */
 464         fmt = av_probe_input_format(pd, 0);
 465     }
 466
 467     /* Do not open file if the format does not need it. XXX: specific
 468        hack needed to handle RTSP/TCP */
 469     if (!fmt || !(fmt->flags & AVFMT_NOFILE)) {
 470         /* if no file needed do not try to open one */
 471         if ((err=url_fopen(&pb, filename, URL_RDONLY)) < 0) {
 472             goto fail;
 473         }
 474         if (buf_size > 0) {
 475             url_setbufsize(pb, buf_size);
 476         }
 477
 478         for(probe_size= PROBE_BUF_MIN; probe_size<=PROBE_BUF_MAX && !fmt; probe_size<<=1){
 479             int score= probe_size < PROBE_BUF_MAX ? AVPROBE_SCORE_MAX/4 : 0;
 480             /* read probe data */
 481             pd->buf= av_realloc(pd->buf, probe_size + AVPROBE_PADDING_SIZE);
 482             pd->buf_size = get_buffer(pb, pd->buf, probe_size);
 483
 484             if ((int)pd->buf_size < 0) {
 485                 err = pd->buf_size;
 486                 goto fail;
 487             }
 488
 489             memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
 490             if (url_fseek(pb, 0, SEEK_SET) < 0) {
 491                 url_fclose(pb);
 492                 if (url_fopen(&pb, filename, URL_RDONLY) < 0) {
 493                     pb = NULL;
 494                     err = AVERROR(EIO);
 495                     goto fail;
 496                 }
 497             }
 498             /* guess file format */
 499             fmt = av_probe_input_format2(pd, 1, &score);
 500             if(fmt){
 501                 if(score <= AVPROBE_SCORE_MAX/4){ //this can only be true in the last iteration
 502                     av_log(logctx, AV_LOG_WARNING, "Format detected only with low score of %d, misdetection possible!\n", score);
 503                 }else
 504                     av_log(logctx, AV_LOG_DEBUG, "Probed with size=%d and score=%d\n", probe_size, score);
 505             }
 506         }
 507         av_freep(&pd->buf);
 508     }
 509
 510     /* if still no format found, error */
 511     if (!fmt) {
 512         err = AVERROR_NOFMT;
 513         goto fail;
 514     }
 515
 516     /* check filename in case an image number is expected */
 517     if (fmt->flags & AVFMT_NEEDNUMBER) {
 518         if (!av_filename_number_test(filename)) {
 519             err = AVERROR_NUMEXPECTED;
 520             goto fail;
 521         }
 522     }
 523     err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
 524     if (err)
 525         goto fail;
 526     return 0;
 527  fail:
 528     av_freep(&pd->buf);
 529     if (pb)
 530         url_fclose(pb);
 531     if (ap && ap->prealloced_context)
 532         av_free(*ic_ptr);
 533     *ic_ptr = NULL;
 534     return err;
 535
 536 }
 537
 538 /*******************************************************/
 539
 540 static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
 541                                AVPacketList **plast_pktl){
 542     AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
 543     if (!pktl)
 544         return NULL;
 545
 546     if (*packet_buffer)
 547         (*plast_pktl)->next = pktl;
 548     else
 549         *packet_buffer = pktl;
 550
 551     /* add the packet in the buffered packet list */
 552     *plast_pktl = pktl;
 553     pktl->pkt= *pkt;
 554     return &pktl->pkt;
 555 }
 556
 557 int av_read_packet(AVFormatContext *s, AVPacket *pkt)
 558 {
 559     int ret, i;
 560     AVStream *st;
 561
 562     for(;;){
 563         AVPacketList *pktl = s->raw_packet_buffer;
 564
 565         if (pktl) {
 566             *pkt = pktl->pkt;
 567             if(s->streams[pkt->stream_index]->codec->codec_id != CODEC_ID_PROBE ||
 568                !s->streams[pkt->stream_index]->probe_packets ||
 569                s->raw_packet_buffer_remaining_size < pkt->size){
 570                 AVProbeData *pd = &s->streams[pkt->stream_index]->probe_data;
 571                 av_freep(&pd->buf);
 572                 pd->buf_size = 0;
 573                 s->raw_packet_buffer = pktl->next;
 574                 s->raw_packet_buffer_remaining_size += pkt->size;
 575                 av_free(pktl);
 576                 return 0;
 577             }
 578         }
 579
 580         av_init_packet(pkt);
 581         ret= s->iformat->read_packet(s, pkt);
 582         if (ret < 0) {
 583             if (!pktl || ret == AVERROR(EAGAIN))
 584                 return ret;
 585             for (i = 0; i < s->nb_streams; i++)
 586                 s->streams[i]->probe_packets = 0;
 587             continue;
 588         }
 589         st= s->streams[pkt->stream_index];
 590
 591         switch(st->codec->codec_type){
 592         case CODEC_TYPE_VIDEO:
 593             if(s->video_codec_id)   st->codec->codec_id= s->video_codec_id;
 594             break;
 595         case CODEC_TYPE_AUDIO:
 596             if(s->audio_codec_id)   st->codec->codec_id= s->audio_codec_id;
 597             break;
 598         case CODEC_TYPE_SUBTITLE:
 599             if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
 600             break;
 601         }
 602
 603         if(!pktl && (st->codec->codec_id != CODEC_ID_PROBE ||
 604                      !st->probe_packets))
 605             return ret;
 606
 607         add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
 608         s->raw_packet_buffer_remaining_size -= pkt->size;
 609
 610         if(st->codec->codec_id == CODEC_ID_PROBE){
 611             AVProbeData *pd = &st->probe_data;
 612
 613             --st->probe_packets;
 614
 615             pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
 616             memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
 617             pd->buf_size += pkt->size;
 618             memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
 619
 620             if(av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)){
 621                 set_codec_from_probe_data(s, st, pd, 1);
 622                 if(st->codec->codec_id != CODEC_ID_PROBE){
 623                     pd->buf_size=0;
 624                     av_freep(&pd->buf);
 625                 }
 626             }
 627         }
 628     }
 629 }
 630
 631 /**********************************************************/
 632
 633 /**
 634  * Get the number of samples of an audio frame. Return -1 on error.
 635  */
 636 static int get_audio_frame_size(AVCodecContext *enc, int size)
 637 {
 638     int frame_size;
 639
 640     if(enc->codec_id == CODEC_ID_VORBIS)
 641         return -1;
 642
 643     if (enc->frame_size <= 1) {
 644         int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
 645
 646         if (bits_per_sample) {
 647             if (enc->channels == 0)
 648                 return -1;
 649             frame_size = (size << 3) / (bits_per_sample * enc->channels);
 650         } else {
 651             /* used for example by ADPCM codecs */
 652             if (enc->bit_rate == 0)
 653                 return -1;
 654             frame_size = ((int64_t)size * 8 * enc->sample_rate) / enc->bit_rate;
 655         }
 656     } else {
 657         frame_size = enc->frame_size;
 658     }
 659     return frame_size;
 660 }
 661
 662
 663 /**
 664  * Return the frame duration in seconds. Return 0 if not available.
 665  */
 666 static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
 667                                    AVCodecParserContext *pc, AVPacket *pkt)
 668 {
 669     int frame_size;
 670
 671     *pnum = 0;
 672     *pden = 0;
 673     switch(st->codec->codec_type) {
 674     case CODEC_TYPE_VIDEO:
 675         if(st->time_base.num*1000LL > st->time_base.den){
 676             *pnum = st->time_base.num;
 677             *pden = st->time_base.den;
 678         }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
 679             *pnum = st->codec->time_base.num;
 680             *pden = st->codec->time_base.den;
 681             if (pc && pc->repeat_pict) {
 682                 *pnum = (*pnum) * (1 + pc->repeat_pict);
 683             }
 684         }
 685         break;
 686     case CODEC_TYPE_AUDIO:
 687         frame_size = get_audio_frame_size(st->codec, pkt->size);
 688         if (frame_size < 0)
 689             break;
 690         *pnum = frame_size;
 691         *pden = st->codec->sample_rate;
 692         break;
 693     default:
 694         break;
 695     }
 696 }
 697
 698 static int is_intra_only(AVCodecContext *enc){
 699     if(enc->codec_type == CODEC_TYPE_AUDIO){
 700         return 1;
 701     }else if(enc->codec_type == CODEC_TYPE_VIDEO){
 702         switch(enc->codec_id){
 703         case CODEC_ID_MJPEG:
 704         case CODEC_ID_MJPEGB:
 705         case CODEC_ID_LJPEG:
 706         case CODEC_ID_RAWVIDEO:
 707         case CODEC_ID_DVVIDEO:
 708         case CODEC_ID_HUFFYUV:
 709         case CODEC_ID_FFVHUFF:
 710         case CODEC_ID_ASV1:
 711         case CODEC_ID_ASV2:
 712         case CODEC_ID_VCR1:
 713         case CODEC_ID_DNXHD:
 714         case CODEC_ID_JPEG2000:
 715             return 1;
 716         default: break;
 717         }
 718     }
 719     return 0;
 720 }
 721
 722 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
 723                                       int64_t dts, int64_t pts)
 724 {
 725     AVStream *st= s->streams[stream_index];
 726     AVPacketList *pktl= s->packet_buffer;
 727
 728     if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE)
 729         return;
 730
 731     st->first_dts= dts - st->cur_dts;
 732     st->cur_dts= dts;
 733
 734     for(; pktl; pktl= pktl->next){
 735         if(pktl->pkt.stream_index != stream_index)
 736             continue;
 737         //FIXME think more about this check
 738         if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
 739             pktl->pkt.pts += st->first_dts;
 740
 741         if(pktl->pkt.dts != AV_NOPTS_VALUE)
 742             pktl->pkt.dts += st->first_dts;
 743
 744         if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
 745             st->start_time= pktl->pkt.pts;
 746     }
 747     if (st->start_time == AV_NOPTS_VALUE)
 748         st->start_time = pts;
 749 }
 750
 751 static void update_initial_durations(AVFormatContext *s, AVStream *st, AVPacket *pkt)
 752 {
 753     AVPacketList *pktl= s->packet_buffer;
 754     int64_t cur_dts= 0;
 755
 756     if(st->first_dts != AV_NOPTS_VALUE){
 757         cur_dts= st->first_dts;
 758         for(; pktl; pktl= pktl->next){
 759             if(pktl->pkt.stream_index == pkt->stream_index){
 760                 if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
 761                     break;
 762                 cur_dts -= pkt->duration;
 763             }
 764         }
 765         pktl= s->packet_buffer;
 766         st->first_dts = cur_dts;
 767     }else if(st->cur_dts)
 768         return;
 769
 770     for(; pktl; pktl= pktl->next){
 771         if(pktl->pkt.stream_index != pkt->stream_index)
 772             continue;
 773         if(pktl->pkt.pts == pktl->pkt.dts && pktl->pkt.dts == AV_NOPTS_VALUE
 774            && !pktl->pkt.duration){
 775             pktl->pkt.dts= cur_dts;
 776             if(!st->codec->has_b_frames)
 777                 pktl->pkt.pts= cur_dts;
 778             cur_dts += pkt->duration;
 779             pktl->pkt.duration= pkt->duration;
 780         }else
 781             break;
 782     }
 783     if(st->first_dts == AV_NOPTS_VALUE)
 784         st->cur_dts= cur_dts;
 785 }
 786
 787 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
 788                                AVCodecParserContext *pc, AVPacket *pkt)
 789 {
 790     int num, den, presentation_delayed, delay, i;
 791     int64_t offset;
 792
 793     if (st->codec->codec_id != CODEC_ID_H264 && pc && pc->pict_type == FF_B_TYPE)
 794         //FIXME Set low_delay = 0 when has_b_frames = 1
 795         st->codec->has_b_frames = 1;
 796
 797     /* do we have a video B-frame ? */
 798     delay= st->codec->has_b_frames;
 799     presentation_delayed = 0;
 800     /* XXX: need has_b_frame, but cannot get it if the codec is
 801         not initialized */
 802     if (delay &&
 803         pc && pc->pict_type != FF_B_TYPE)
 804         presentation_delayed = 1;
 805
 806     if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
 807        /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
 808         pkt->dts -= 1LL<<st->pts_wrap_bits;
 809     }
 810
 811     // some mpeg2 in mpeg-ps lack dts (issue171 / input_file.mpg)
 812     // we take the conservative approach and discard both
 813     // Note, if this is misbehaving for a H.264 file then possibly presentation_delayed is not set correctly.
 814     if(delay==1 && pkt->dts == pkt->pts && pkt->dts != AV_NOPTS_VALUE && presentation_delayed){
 815         av_log(s, AV_LOG_WARNING, "invalid dts/pts combination\n");
 816         pkt->dts= pkt->pts= AV_NOPTS_VALUE;
 817     }
 818
 819     if (pkt->duration == 0) {
 820         compute_frame_duration(&num, &den, st, pc, pkt);
 821         if (den && num) {
 822             pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
 823
 824             if(pkt->duration != 0 && s->packet_buffer)
 825                 update_initial_durations(s, st, pkt);
 826         }
 827     }
 828
 829     /* correct timestamps with byte offset if demuxers only have timestamps
 830        on packet boundaries */
 831     if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
 832         /* this will estimate bitrate based on this frame's duration and size */
 833         offset = av_rescale(pc->offset, pkt->duration, pkt->size);
 834         if(pkt->pts != AV_NOPTS_VALUE)
 835             pkt->pts += offset;
 836         if(pkt->dts != AV_NOPTS_VALUE)
 837             pkt->dts += offset;
 838     }
 839
 840     if (pc && pc->dts_sync_point >= 0) {
 841         // we have synchronization info from the parser
 842         int64_t den = st->codec->time_base.den * (int64_t) st->time_base.num;
 843         if (den > 0) {
 844             int64_t num = st->codec->time_base.num * (int64_t) st->time_base.den;
 845             if (pkt->dts != AV_NOPTS_VALUE) {
 846                 // got DTS from the stream, update reference timestamp
 847                 st->reference_dts = pkt->dts - pc->dts_ref_dts_delta * num / den;
 848                 pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
 849             } else if (st->reference_dts != AV_NOPTS_VALUE) {
 850                 // compute DTS based on reference timestamp
 851                 pkt->dts = st->reference_dts + pc->dts_ref_dts_delta * num / den;
 852                 pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
 853             }
 854             if (pc->dts_sync_point > 0)
 855                 st->reference_dts = pkt->dts; // new reference
 856         }
 857     }
 858
 859     /* This may be redundant, but it should not hurt. */
 860     if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
 861         presentation_delayed = 1;
 862
 863 //    av_log(NULL, AV_LOG_DEBUG, "IN delayed:%d pts:%"PRId64", dts:%"PRId64" cur_dts:%"PRId64" st:%d pc:%p\n", presentation_delayed, pkt->pts, pkt->dts, st->cur_dts, pkt->stream_index, pc);
 864     /* interpolate PTS and DTS if they are not present */
 865     //We skip H264 currently because delay and has_b_frames are not reliably set
 866     if((delay==0 || (delay==1 && pc)) && st->codec->codec_id != CODEC_ID_H264){
 867         if (presentation_delayed) {
 868             /* DTS = decompression timestamp */
 869             /* PTS = presentation timestamp */
 870             if (pkt->dts == AV_NOPTS_VALUE)
 871                 pkt->dts = st->last_IP_pts;
 872             update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
 873             if (pkt->dts == AV_NOPTS_VALUE)
 874                 pkt->dts = st->cur_dts;
 875
 876             /* this is tricky: the dts must be incremented by the duration
 877             of the frame we are displaying, i.e. the last I- or P-frame */
 878             if (st->last_IP_duration == 0)
 879                 st->last_IP_duration = pkt->duration;
 880             if(pkt->dts != AV_NOPTS_VALUE)
 881                 st->cur_dts = pkt->dts + st->last_IP_duration;
 882             st->last_IP_duration  = pkt->duration;
 883             st->last_IP_pts= pkt->pts;
 884             /* cannot compute PTS if not present (we can compute it only
 885             by knowing the future */
 886         } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
 887             if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
 888                 int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
 889                 int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
 890                 if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
 891                     pkt->pts += pkt->duration;
 892     //                av_log(NULL, AV_LOG_DEBUG, "id:%d old:%"PRId64" new:%"PRId64" dur:%d cur:%"PRId64" size:%d\n", pkt->stream_index, old_diff, new_diff, pkt->duration, st->cur_dts, pkt->size);
 893                 }
 894             }
 895
 896             /* presentation is not delayed : PTS and DTS are the same */
 897             if(pkt->pts == AV_NOPTS_VALUE)
 898                 pkt->pts = pkt->dts;
 899             update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
 900             if(pkt->pts == AV_NOPTS_VALUE)
 901                 pkt->pts = st->cur_dts;
 902             pkt->dts = pkt->pts;
 903             if(pkt->pts != AV_NOPTS_VALUE)
 904                 st->cur_dts = pkt->pts + pkt->duration;
 905         }
 906     }
 907
 908     if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
 909         st->pts_buffer[0]= pkt->pts;
 910         for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
 911             FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
 912         if(pkt->dts == AV_NOPTS_VALUE)
 913             pkt->dts= st->pts_buffer[0];
 914         if(st->codec->codec_id == CODEC_ID_H264){ //we skiped it above so we try here
 915             update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
 916         }
 917         if(pkt->dts > st->cur_dts)
 918             st->cur_dts = pkt->dts;
 919     }
 920
 921 //    av_log(NULL, AV_LOG_ERROR, "OUTdelayed:%d/%d pts:%"PRId64", dts:%"PRId64" cur_dts:%"PRId64"\n", presentation_delayed, delay, pkt->pts, pkt->dts, st->cur_dts);
 922
 923     /* update flags */
 924     if(is_intra_only(st->codec))
 925         pkt->flags |= PKT_FLAG_KEY;
 926     else if (pc) {
 927         pkt->flags = 0;
 928         /* keyframe computation */
 929         if (pc->key_frame == 1)
 930             pkt->flags |= PKT_FLAG_KEY;
 931         else if (pc->key_frame == -1 && pc->pict_type == FF_I_TYPE)
 932             pkt->flags |= PKT_FLAG_KEY;
 933     }
 934     if (pc)
 935         pkt->convergence_duration = pc->convergence_duration;
 936 }
 937
 938
 939 static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
 940 {
 941     AVStream *st;
 942     int len, ret, i;
 943
 944     av_init_packet(pkt);
 945
 946     for(;;) {
 947         /* select current input stream component */
 948         st = s->cur_st;
 949         if (st) {
 950             if (!st->need_parsing || !st->parser) {
 951                 /* no parsing needed: we just output the packet as is */
 952                 /* raw data support */
 953                 *pkt = st->cur_pkt; st->cur_pkt.data= NULL;
 954                 compute_pkt_fields(s, st, NULL, pkt);
 955                 s->cur_st = NULL;
 956                 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
 957                     (pkt->flags & PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
 958                     ff_reduce_index(s, st->index);
 959                     av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
 960                 }
 961                 break;
 962             } else if (st->cur_len > 0 && st->discard < AVDISCARD_ALL) {
 963                 len = av_parser_parse2(st->parser, st->codec, &pkt->data, &pkt->size,
 964                                        st->cur_ptr, st->cur_len,
 965                                        st->cur_pkt.pts, st->cur_pkt.dts,
 966                                        st->cur_pkt.pos);
 967                 st->cur_pkt.pts = AV_NOPTS_VALUE;
 968                 st->cur_pkt.dts = AV_NOPTS_VALUE;
 969                 /* increment read pointer */
 970                 st->cur_ptr += len;
 971                 st->cur_len -= len;
 972
 973                 /* return packet if any */
 974                 if (pkt->size) {
 975                 got_packet:
 976                     pkt->duration = 0;
 977                     pkt->stream_index = st->index;
 978                     pkt->pts = st->parser->pts;
 979                     pkt->dts = st->parser->dts;
 980                     pkt->pos = st->parser->pos;
 981                     pkt->destruct = NULL;
 982                     compute_pkt_fields(s, st, st->parser, pkt);
 983
 984                     if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & PKT_FLAG_KEY){
 985                         ff_reduce_index(s, st->index);
 986                         av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
 987                                            0, 0, AVINDEX_KEYFRAME);
 988                     }
 989
 990                     break;
 991                 }
 992             } else {
 993                 /* free packet */
 994                 av_free_packet(&st->cur_pkt);
 995                 s->cur_st = NULL;
 996             }
 997         } else {
 998             AVPacket cur_pkt;
 999             /* read next packet */
1000             ret = av_read_packet(s, &cur_pkt);
1001             if (ret < 0) {
1002                 if (ret == AVERROR(EAGAIN))
1003                     return ret;
1004                 /* return the last frames, if any */
1005                 for(i = 0; i < s->nb_streams; i++) {
1006                     st = s->streams[i];
1007                     if (st->parser && st->need_parsing) {
1008                         av_parser_parse2(st->parser, st->codec,
1009                                         &pkt->data, &pkt->size,
1010                                         NULL, 0,
1011                                         AV_NOPTS_VALUE, AV_NOPTS_VALUE,
1012                                         AV_NOPTS_VALUE);
1013                         if (pkt->size)
1014                             goto got_packet;
1015                     }
1016                 }
1017                 /* no more packets: really terminate parsing */
1018                 return ret;
1019             }
1020             st = s->streams[cur_pkt.stream_index];
1021             st->cur_pkt= cur_pkt;
1022
1023             if(st->cur_pkt.pts != AV_NOPTS_VALUE &&
1024                st->cur_pkt.dts != AV_NOPTS_VALUE &&
1025                st->cur_pkt.pts < st->cur_pkt.dts){
1026                 av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
1027                     st->cur_pkt.stream_index,
1028                     st->cur_pkt.pts,
1029                     st->cur_pkt.dts,
1030                     st->cur_pkt.size);
1031 //                av_free_packet(&st->cur_pkt);
1032 //                return -1;
1033             }
1034
1035             if(s->debug & FF_FDEBUG_TS)
1036                 av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1037                     st->cur_pkt.stream_index,
1038                     st->cur_pkt.pts,
1039                     st->cur_pkt.dts,
1040                     st->cur_pkt.size,
1041                     st->cur_pkt.duration,
1042                     st->cur_pkt.flags);
1043
1044             s->cur_st = st;
1045             st->cur_ptr = st->cur_pkt.data;
1046             st->cur_len = st->cur_pkt.size;
1047             if (st->need_parsing && !st->parser) {
1048                 st->parser = av_parser_init(st->codec->codec_id);
1049                 if (!st->parser) {
1050                     /* no parser available: just output the raw packets */
1051                     st->need_parsing = AVSTREAM_PARSE_NONE;
1052                 }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
1053                     st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1054                 }
1055                 if(st->parser && (s->iformat->flags & AVFMT_GENERIC_INDEX)){
1056                     st->parser->next_frame_offset=
1057                     st->parser->cur_offset= st->cur_pkt.pos;
1058                 }
1059             }
1060         }
1061     }
1062     if(s->debug & FF_FDEBUG_TS)
1063         av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1064             pkt->stream_index,
1065             pkt->pts,
1066             pkt->dts,
1067             pkt->size,
1068             pkt->duration,
1069             pkt->flags);
1070
1071     return 0;
1072 }
1073
1074 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1075 {
1076     AVPacketList *pktl;
1077     int eof=0;
1078     const int genpts= s->flags & AVFMT_FLAG_GENPTS;
1079
1080     for(;;){
1081         pktl = s->packet_buffer;
1082         if (pktl) {
1083             AVPacket *next_pkt= &pktl->pkt;
1084
1085             if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
1086                 while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
1087                     if(   pktl->pkt.stream_index == next_pkt->stream_index
1088                        && next_pkt->dts < pktl->pkt.dts
1089                        && pktl->pkt.pts != pktl->pkt.dts //not b frame
1090                        /*&& pktl->pkt.dts != AV_NOPTS_VALUE*/){
1091                         next_pkt->pts= pktl->pkt.dts;
1092                     }
1093                     pktl= pktl->next;
1094                 }
1095                 pktl = s->packet_buffer;
1096             }
1097
1098             if(   next_pkt->pts != AV_NOPTS_VALUE
1099                || next_pkt->dts == AV_NOPTS_VALUE
1100                || !genpts || eof){
1101                 /* read packet from packet buffer, if there is data */
1102                 *pkt = *next_pkt;
1103                 s->packet_buffer = pktl->next;
1104                 av_free(pktl);
1105                 return 0;
1106             }
1107         }
1108         if(genpts){
1109             int ret= av_read_frame_internal(s, pkt);
1110             if(ret<0){
1111                 if(pktl && ret != AVERROR(EAGAIN)){
1112                     eof=1;
1113                     continue;
1114                 }else
1115                     return ret;
1116             }
1117
1118             if(av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1119                                            &s->packet_buffer_end)) < 0)
1120                 return AVERROR(ENOMEM);
1121         }else{
1122             assert(!s->packet_buffer);
1123             return av_read_frame_internal(s, pkt);
1124         }
1125     }
1126 }
1127
1128 /* XXX: suppress the packet queue */
1129 static void flush_packet_queue(AVFormatContext *s)
1130 {
1131     AVPacketList *pktl;
1132
1133     for(;;) {
1134         pktl = s->packet_buffer;
1135         if (!pktl)
1136             break;
1137         s->packet_buffer = pktl->next;
1138         av_free_packet(&pktl->pkt);
1139         av_free(pktl);
1140     }
1141     while(s->raw_packet_buffer){
1142         pktl = s->raw_packet_buffer;
1143         s->raw_packet_buffer = pktl->next;
1144         av_free_packet(&pktl->pkt);
1145         av_free(pktl);
1146     }
1147     s->packet_buffer_end=
1148     s->raw_packet_buffer_end= NULL;
1149     s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1150 }
1151
1152 /*******************************************************/
1153 /* seek support */
1154
1155 int av_find_default_stream_index(AVFormatContext *s)
1156 {
1157     int first_audio_index = -1;
1158     int i;
1159     AVStream *st;
1160
1161     if (s->nb_streams <= 0)
1162         return -1;
1163     for(i = 0; i < s->nb_streams; i++) {
1164         st = s->streams[i];
1165         if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1166             return i;
1167         }
1168         if (first_audio_index < 0 && st->codec->codec_type == CODEC_TYPE_AUDIO)
1169             first_audio_index = i;
1170     }
1171     return first_audio_index >= 0 ? first_audio_index : 0;
1172 }
1173
1174 /**
1175  * Flush the frame reader.
1176  */
1177 void av_read_frame_flush(AVFormatContext *s)
1178 {
1179     AVStream *st;
1180     int i, j;
1181
1182     flush_packet_queue(s);
1183
1184     s->cur_st = NULL;
1185
1186     /* for each stream, reset read state */
1187     for(i = 0; i < s->nb_streams; i++) {
1188         st = s->streams[i];
1189
1190         if (st->parser) {
1191             av_parser_close(st->parser);
1192             st->parser = NULL;
1193             av_free_packet(&st->cur_pkt);
1194         }
1195         st->last_IP_pts = AV_NOPTS_VALUE;
1196         st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1197         st->reference_dts = AV_NOPTS_VALUE;
1198         /* fail safe */
1199         st->cur_ptr = NULL;
1200         st->cur_len = 0;
1201
1202         st->probe_packets = MAX_PROBE_PACKETS;
1203
1204         for(j=0; j<MAX_REORDER_DELAY+1; j++)
1205             st->pts_buffer[j]= AV_NOPTS_VALUE;
1206     }
1207 }
1208
1209 void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1210     int i;
1211
1212     for(i = 0; i < s->nb_streams; i++) {
1213         AVStream *st = s->streams[i];
1214
1215         st->cur_dts = av_rescale(timestamp,
1216                                  st->time_base.den * (int64_t)ref_st->time_base.num,
1217                                  st->time_base.num * (int64_t)ref_st->time_base.den);
1218     }
1219 }
1220
1221 void ff_reduce_index(AVFormatContext *s, int stream_index)
1222 {
1223     AVStream *st= s->streams[stream_index];
1224     unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1225
1226     if((unsigned)st->nb_index_entries >= max_entries){
1227         int i;
1228         for(i=0; 2*i<st->nb_index_entries; i++)
1229             st->index_entries[i]= st->index_entries[2*i];
1230         st->nb_index_entries= i;
1231     }
1232 }
1233
1234 int av_add_index_entry(AVStream *st,
1235                             int64_t pos, int64_t timestamp, int size, int distance, int flags)
1236 {
1237     AVIndexEntry *entries, *ie;
1238     int index;
1239
1240     if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1241         return -1;
1242
1243     entries = av_fast_realloc(st->index_entries,
1244                               &st->index_entries_allocated_size,
1245                               (st->nb_index_entries + 1) *
1246                               sizeof(AVIndexEntry));
1247     if(!entries)
1248         return -1;
1249
1250     st->index_entries= entries;
1251
1252     index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
1253
1254     if(index<0){
1255         index= st->nb_index_entries++;
1256         ie= &entries[index];
1257         assert(index==0 || ie[-1].timestamp < timestamp);
1258     }else{
1259         ie= &entries[index];
1260         if(ie->timestamp != timestamp){
1261             if(ie->timestamp <= timestamp)
1262                 return -1;
1263             memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
1264             st->nb_index_entries++;
1265         }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1266             distance= ie->min_distance;
1267     }
1268
1269     ie->pos = pos;
1270     ie->timestamp = timestamp;
1271     ie->min_distance= distance;
1272     ie->size= size;
1273     ie->flags = flags;
1274
1275     return index;
1276 }
1277
1278 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1279                               int flags)
1280 {
1281     AVIndexEntry *entries= st->index_entries;
1282     int nb_entries= st->nb_index_entries;
1283     int a, b, m;
1284     int64_t timestamp;
1285
1286     a = - 1;
1287     b = nb_entries;
1288
1289     while (b - a > 1) {
1290         m = (a + b) >> 1;
1291         timestamp = entries[m].timestamp;
1292         if(timestamp >= wanted_timestamp)
1293             b = m;
1294         if(timestamp <= wanted_timestamp)
1295             a = m;
1296     }
1297     m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1298
1299     if(!(flags & AVSEEK_FLAG_ANY)){
1300         while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1301             m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1302         }
1303     }
1304
1305     if(m == nb_entries)
1306         return -1;
1307     return  m;
1308 }
1309
1310 #define DEBUG_SEEK
1311
1312 int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1313     AVInputFormat *avif= s->iformat;
1314     int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1315     int64_t ts_min, ts_max, ts;
1316     int index;
1317     int64_t ret;
1318     AVStream *st;
1319
1320     if (stream_index < 0)
1321         return -1;
1322
1323 #ifdef DEBUG_SEEK
1324     av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1325 #endif
1326
1327     ts_max=
1328     ts_min= AV_NOPTS_VALUE;
1329     pos_limit= -1; //gcc falsely says it may be uninitialized
1330
1331     st= s->streams[stream_index];
1332     if(st->index_entries){
1333         AVIndexEntry *e;
1334
1335         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()
1336         index= FFMAX(index, 0);
1337         e= &st->index_entries[index];
1338
1339         if(e->timestamp <= target_ts || e->pos == e->min_distance){
1340             pos_min= e->pos;
1341             ts_min= e->timestamp;
1342 #ifdef DEBUG_SEEK
1343             av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1344                    pos_min,ts_min);
1345 #endif
1346         }else{
1347             assert(index==0);
1348         }
1349
1350         index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1351         assert(index < st->nb_index_entries);
1352         if(index >= 0){
1353             e= &st->index_entries[index];
1354             assert(e->timestamp >= target_ts);
1355             pos_max= e->pos;
1356             ts_max= e->timestamp;
1357             pos_limit= pos_max - e->min_distance;
1358 #ifdef DEBUG_SEEK
1359             av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1360                    pos_max,pos_limit, ts_max);
1361 #endif
1362         }
1363     }
1364
1365     pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1366     if(pos<0)
1367         return -1;
1368
1369     /* do the seek */
1370     if ((ret = url_fseek(s->pb, pos, SEEK_SET)) < 0)
1371         return ret;
1372
1373     av_update_cur_dts(s, st, ts);
1374
1375     return 0;
1376 }
1377
1378 int64_t av_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts, int64_t pos_min, int64_t pos_max, int64_t pos_limit, int64_t ts_min, int64_t ts_max, int flags, int64_t *ts_ret, int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t )){
1379     int64_t pos, ts;
1380     int64_t start_pos, filesize;
1381     int no_change;
1382
1383 #ifdef DEBUG_SEEK
1384     av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1385 #endif
1386
1387     if(ts_min == AV_NOPTS_VALUE){
1388         pos_min = s->data_offset;
1389         ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1390         if (ts_min == AV_NOPTS_VALUE)
1391             return -1;
1392     }
1393
1394     if(ts_max == AV_NOPTS_VALUE){
1395         int step= 1024;
1396         filesize = url_fsize(s->pb);
1397         pos_max = filesize - 1;
1398         do{
1399             pos_max -= step;
1400             ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1401             step += step;
1402         }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1403         if (ts_max == AV_NOPTS_VALUE)
1404             return -1;
1405
1406         for(;;){
1407             int64_t tmp_pos= pos_max + 1;
1408             int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1409             if(tmp_ts == AV_NOPTS_VALUE)
1410                 break;
1411             ts_max= tmp_ts;
1412             pos_max= tmp_pos;
1413             if(tmp_pos >= filesize)
1414                 break;
1415         }
1416         pos_limit= pos_max;
1417     }
1418
1419     if(ts_min > ts_max){
1420         return -1;
1421     }else if(ts_min == ts_max){
1422         pos_limit= pos_min;
1423     }
1424
1425     no_change=0;
1426     while (pos_min < pos_limit) {
1427 #ifdef DEBUG_SEEK
1428         av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1429                pos_min, pos_max,
1430                ts_min, ts_max);
1431 #endif
1432         assert(pos_limit <= pos_max);
1433
1434         if(no_change==0){
1435             int64_t approximate_keyframe_distance= pos_max - pos_limit;
1436             // interpolate position (better than dichotomy)
1437             pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1438                 + pos_min - approximate_keyframe_distance;
1439         }else if(no_change==1){
1440             // bisection, if interpolation failed to change min or max pos last time
1441             pos = (pos_min + pos_limit)>>1;
1442         }else{
1443             /* linear search if bisection failed, can only happen if there
1444                are very few or no keyframes between min/max */
1445             pos=pos_min;
1446         }
1447         if(pos <= pos_min)
1448             pos= pos_min + 1;
1449         else if(pos > pos_limit)
1450             pos= pos_limit;
1451         start_pos= pos;
1452
1453         ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1454         if(pos == pos_max)
1455             no_change++;
1456         else
1457             no_change=0;
1458 #ifdef DEBUG_SEEK
1459         av_log(s, AV_LOG_DEBUG, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64" target:%"PRId64" limit:%"PRId64" start:%"PRId64" noc:%d\n",
1460                pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts, pos_limit,
1461                start_pos, no_change);
1462 #endif
1463         if(ts == AV_NOPTS_VALUE){
1464             av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1465             return -1;
1466         }
1467         assert(ts != AV_NOPTS_VALUE);
1468         if (target_ts <= ts) {
1469             pos_limit = start_pos - 1;
1470             pos_max = pos;
1471             ts_max = ts;
1472         }
1473         if (target_ts >= ts) {
1474             pos_min = pos;
1475             ts_min = ts;
1476         }
1477     }
1478
1479     pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1480     ts  = (flags & AVSEEK_FLAG_BACKWARD) ?  ts_min :  ts_max;
1481 #ifdef DEBUG_SEEK
1482     pos_min = pos;
1483     ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1484     pos_min++;
1485     ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1486     av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1487            pos, ts_min, target_ts, ts_max);
1488 #endif
1489     *ts_ret= ts;
1490     return pos;
1491 }
1492
1493 static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1494     int64_t pos_min, pos_max;
1495 #if 0
1496     AVStream *st;
1497
1498     if (stream_index < 0)
1499         return -1;
1500
1501     st= s->streams[stream_index];
1502 #endif
1503
1504     pos_min = s->data_offset;
1505     pos_max = url_fsize(s->pb) - 1;
1506
1507     if     (pos < pos_min) pos= pos_min;
1508     else if(pos > pos_max) pos= pos_max;
1509
1510     url_fseek(s->pb, pos, SEEK_SET);
1511
1512 #if 0
1513     av_update_cur_dts(s, st, ts);
1514 #endif
1515     return 0;
1516 }
1517
1518 static int av_seek_frame_generic(AVFormatContext *s,
1519                                  int stream_index, int64_t timestamp, int flags)
1520 {
1521     int index;
1522     int64_t ret;
1523     AVStream *st;
1524     AVIndexEntry *ie;
1525
1526     st = s->streams[stream_index];
1527
1528     index = av_index_search_timestamp(st, timestamp, flags);
1529
1530     if(index < 0 || index==st->nb_index_entries-1){
1531         int i;
1532         AVPacket pkt;
1533
1534         if(st->nb_index_entries){
1535             assert(st->index_entries);
1536             ie= &st->index_entries[st->nb_index_entries-1];
1537             if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
1538                 return ret;
1539             av_update_cur_dts(s, st, ie->timestamp);
1540         }else{
1541             if ((ret = url_fseek(s->pb, s->data_offset, SEEK_SET)) < 0)
1542                 return ret;
1543         }
1544         for(i=0;; i++) {
1545             int ret;
1546             do{
1547                 ret = av_read_frame(s, &pkt);
1548             }while(ret == AVERROR(EAGAIN));
1549             if(ret<0)
1550                 break;
1551             av_free_packet(&pkt);
1552             if(stream_index == pkt.stream_index){
1553                 if((pkt.flags & PKT_FLAG_KEY) && pkt.dts > timestamp)
1554                     break;
1555             }
1556         }
1557         index = av_index_search_timestamp(st, timestamp, flags);
1558     }
1559     if (index < 0)
1560         return -1;
1561
1562     av_read_frame_flush(s);
1563     if (s->iformat->read_seek){
1564         if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1565             return 0;
1566     }
1567     ie = &st->index_entries[index];
1568     if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
1569         return ret;
1570     av_update_cur_dts(s, st, ie->timestamp);
1571
1572     return 0;
1573 }
1574
1575 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1576 {
1577     int ret;
1578     AVStream *st;
1579
1580     av_read_frame_flush(s);
1581
1582     if(flags & AVSEEK_FLAG_BYTE)
1583         return av_seek_frame_byte(s, stream_index, timestamp, flags);
1584
1585     if(stream_index < 0){
1586         stream_index= av_find_default_stream_index(s);
1587         if(stream_index < 0)
1588             return -1;
1589
1590         st= s->streams[stream_index];
1591        /* timestamp for default must be expressed in AV_TIME_BASE units */
1592         timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1593     }
1594
1595     /* first, we try the format specific seek */
1596     if (s->iformat->read_seek)
1597         ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1598     else
1599         ret = -1;
1600     if (ret >= 0) {
1601         return 0;
1602     }
1603
1604     if(s->iformat->read_timestamp)
1605         return av_seek_frame_binary(s, stream_index, timestamp, flags);
1606     else
1607         return av_seek_frame_generic(s, stream_index, timestamp, flags);
1608 }
1609
1610 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
1611 {
1612     if(min_ts > ts || max_ts < ts)
1613         return -1;
1614
1615     av_read_frame_flush(s);
1616
1617     if (s->iformat->read_seek2)
1618         return s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
1619
1620     if(s->iformat->read_timestamp){
1621         //try to seek via read_timestamp()
1622     }
1623
1624     //Fallback to old API if new is not implemented but old is
1625     //Note the old has somewat different sematics
1626     if(s->iformat->read_seek || 1)
1627         return av_seek_frame(s, stream_index, ts, flags | (ts - min_ts > (uint64_t)(max_ts - ts) ? AVSEEK_FLAG_BACKWARD : 0));
1628
1629     // try some generic seek like av_seek_frame_generic() but with new ts semantics
1630 }
1631
1632 /*******************************************************/
1633
1634 /**
1635  * Returns TRUE if the stream has accurate duration in any stream.
1636  *
1637  * @return TRUE if the stream has accurate duration for at least one component.
1638  */
1639 static int av_has_duration(AVFormatContext *ic)
1640 {
1641     int i;
1642     AVStream *st;
1643
1644     for(i = 0;i < ic->nb_streams; i++) {
1645         st = ic->streams[i];
1646         if (st->duration != AV_NOPTS_VALUE)
1647             return 1;
1648     }
1649     return 0;
1650 }
1651
1652 /**
1653  * Estimate the stream timings from the one of each components.
1654  *
1655  * Also computes the global bitrate if possible.
1656  */
1657 static void av_update_stream_timings(AVFormatContext *ic)
1658 {
1659     int64_t start_time, start_time1, end_time, end_time1;
1660     int64_t duration, duration1;
1661     int i;
1662     AVStream *st;
1663
1664     start_time = INT64_MAX;
1665     end_time = INT64_MIN;
1666     duration = INT64_MIN;
1667     for(i = 0;i < ic->nb_streams; i++) {
1668         st = ic->streams[i];
1669         if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
1670             start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1671             if (start_time1 < start_time)
1672                 start_time = start_time1;
1673             if (st->duration != AV_NOPTS_VALUE) {
1674                 end_time1 = start_time1
1675                           + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1676                 if (end_time1 > end_time)
1677                     end_time = end_time1;
1678             }
1679         }
1680         if (st->duration != AV_NOPTS_VALUE) {
1681             duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1682             if (duration1 > duration)
1683                 duration = duration1;
1684         }
1685     }
1686     if (start_time != INT64_MAX) {
1687         ic->start_time = start_time;
1688         if (end_time != INT64_MIN) {
1689             if (end_time - start_time > duration)
1690                 duration = end_time - start_time;
1691         }
1692     }
1693     if (duration != INT64_MIN) {
1694         ic->duration = duration;
1695         if (ic->file_size > 0) {
1696             /* compute the bitrate */
1697             ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1698                 (double)ic->duration;
1699         }
1700     }
1701 }
1702
1703 static void fill_all_stream_timings(AVFormatContext *ic)
1704 {
1705     int i;
1706     AVStream *st;
1707
1708     av_update_stream_timings(ic);
1709     for(i = 0;i < ic->nb_streams; i++) {
1710         st = ic->streams[i];
1711         if (st->start_time == AV_NOPTS_VALUE) {
1712             if(ic->start_time != AV_NOPTS_VALUE)
1713                 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1714             if(ic->duration != AV_NOPTS_VALUE)
1715                 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1716         }
1717     }
1718 }
1719
1720 static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1721 {
1722     int64_t filesize, duration;
1723     int bit_rate, i;
1724     AVStream *st;
1725
1726     /* if bit_rate is already set, we believe it */
1727     if (ic->bit_rate == 0) {
1728         bit_rate = 0;
1729         for(i=0;i<ic->nb_streams;i++) {
1730             st = ic->streams[i];
1731             bit_rate += st->codec->bit_rate;
1732         }
1733         ic->bit_rate = bit_rate;
1734     }
1735
1736     /* if duration is already set, we believe it */
1737     if (ic->duration == AV_NOPTS_VALUE &&
1738         ic->bit_rate != 0 &&
1739         ic->file_size != 0)  {
1740         filesize = ic->file_size;
1741         if (filesize > 0) {
1742             for(i = 0; i < ic->nb_streams; i++) {
1743                 st = ic->streams[i];
1744                 duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1745                 if (st->duration == AV_NOPTS_VALUE)
1746                     st->duration = duration;
1747             }
1748         }
1749     }
1750 }
1751
1752 #define DURATION_MAX_READ_SIZE 250000
1753
1754 /* only usable for MPEG-PS streams */
1755 static void av_estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
1756 {
1757     AVPacket pkt1, *pkt = &pkt1;
1758     AVStream *st;
1759     int read_size, i, ret;
1760     int64_t end_time;
1761     int64_t filesize, offset, duration;
1762
1763     ic->cur_st = NULL;
1764
1765     /* flush packet queue */
1766     flush_packet_queue(ic);
1767
1768     for(i=0;i<ic->nb_streams;i++) {
1769         st = ic->streams[i];
1770         if (st->parser) {
1771             av_parser_close(st->parser);
1772             st->parser= NULL;
1773             av_free_packet(&st->cur_pkt);
1774         }
1775     }
1776
1777     /* we read the first packets to get the first PTS (not fully
1778        accurate, but it is enough now) */
1779     url_fseek(ic->pb, 0, SEEK_SET);
1780     read_size = 0;
1781     for(;;) {
1782         if (read_size >= DURATION_MAX_READ_SIZE)
1783             break;
1784         /* if all info is available, we can stop */
1785         for(i = 0;i < ic->nb_streams; i++) {
1786             st = ic->streams[i];
1787             if (st->start_time == AV_NOPTS_VALUE)
1788                 break;
1789         }
1790         if (i == ic->nb_streams)
1791             break;
1792
1793         do{
1794             ret = av_read_packet(ic, pkt);
1795         }while(ret == AVERROR(EAGAIN));
1796         if (ret != 0)
1797             break;
1798         read_size += pkt->size;
1799         st = ic->streams[pkt->stream_index];
1800         if (pkt->pts != AV_NOPTS_VALUE) {
1801             if (st->start_time == AV_NOPTS_VALUE)
1802                 st->start_time = pkt->pts;
1803         }
1804         av_free_packet(pkt);
1805     }
1806
1807     /* estimate the end time (duration) */
1808     /* XXX: may need to support wrapping */
1809     filesize = ic->file_size;
1810     offset = filesize - DURATION_MAX_READ_SIZE;
1811     if (offset < 0)
1812         offset = 0;
1813
1814     url_fseek(ic->pb, offset, SEEK_SET);
1815     read_size = 0;
1816     for(;;) {
1817         if (read_size >= DURATION_MAX_READ_SIZE)
1818             break;
1819
1820         do{
1821             ret = av_read_packet(ic, pkt);
1822         }while(ret == AVERROR(EAGAIN));
1823         if (ret != 0)
1824             break;
1825         read_size += pkt->size;
1826         st = ic->streams[pkt->stream_index];
1827         if (pkt->pts != AV_NOPTS_VALUE &&
1828             st->start_time != AV_NOPTS_VALUE) {
1829             end_time = pkt->pts;
1830             duration = end_time - st->start_time;
1831             if (duration > 0) {
1832                 if (st->duration == AV_NOPTS_VALUE ||
1833                     st->duration < duration)
1834                     st->duration = duration;
1835             }
1836         }
1837         av_free_packet(pkt);
1838     }
1839
1840     fill_all_stream_timings(ic);
1841
1842     url_fseek(ic->pb, old_offset, SEEK_SET);
1843     for(i=0; i<ic->nb_streams; i++){
1844         st= ic->streams[i];
1845         st->cur_dts= st->first_dts;
1846         st->last_IP_pts = AV_NOPTS_VALUE;
1847     }
1848 }
1849
1850 static void av_estimate_timings(AVFormatContext *ic, int64_t old_offset)
1851 {
1852     int64_t file_size;
1853
1854     /* get the file size, if possible */
1855     if (ic->iformat->flags & AVFMT_NOFILE) {
1856         file_size = 0;
1857     } else {
1858         file_size = url_fsize(ic->pb);
1859         if (file_size < 0)
1860             file_size = 0;
1861     }
1862     ic->file_size = file_size;
1863
1864     if ((!strcmp(ic->iformat->name, "mpeg") ||
1865          !strcmp(ic->iformat->name, "mpegts")) &&
1866         file_size && !url_is_streamed(ic->pb)) {
1867         /* get accurate estimate from the PTSes */
1868         av_estimate_timings_from_pts(ic, old_offset);
1869     } else if (av_has_duration(ic)) {
1870         /* at least one component has timings - we use them for all
1871            the components */
1872         fill_all_stream_timings(ic);
1873     } else {
1874         av_log(ic, AV_LOG_WARNING, "Estimating duration from bitrate, this may be inaccurate\n");
1875         /* less precise: use bitrate info */
1876         av_estimate_timings_from_bit_rate(ic);
1877     }
1878     av_update_stream_timings(ic);
1879
1880 #if 0
1881     {
1882         int i;
1883         AVStream *st;
1884         for(i = 0;i < ic->nb_streams; i++) {
1885             st = ic->streams[i];
1886         printf("%d: start_time: %0.3f duration: %0.3f\n",
1887                i, (double)st->start_time / AV_TIME_BASE,
1888                (double)st->duration / AV_TIME_BASE);
1889         }
1890         printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1891                (double)ic->start_time / AV_TIME_BASE,
1892                (double)ic->duration / AV_TIME_BASE,
1893                ic->bit_rate / 1000);
1894     }
1895 #endif
1896 }
1897
1898 static int has_codec_parameters(AVCodecContext *enc)
1899 {
1900     int val;
1901     switch(enc->codec_type) {
1902     case CODEC_TYPE_AUDIO:
1903         val = enc->sample_rate && enc->channels && enc->sample_fmt != SAMPLE_FMT_NONE;
1904         if(!enc->frame_size &&
1905            (enc->codec_id == CODEC_ID_VORBIS ||
1906             enc->codec_id == CODEC_ID_AAC ||
1907             enc->codec_id == CODEC_ID_MP3 ||
1908             enc->codec_id == CODEC_ID_SPEEX))
1909             return 0;
1910         break;
1911     case CODEC_TYPE_VIDEO:
1912         val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
1913         break;
1914     default:
1915         val = 1;
1916         break;
1917     }
1918     return enc->codec_id != CODEC_ID_NONE && val != 0;
1919 }
1920
1921 static int try_decode_frame(AVStream *st, AVPacket *avpkt)
1922 {
1923     int16_t *samples;
1924     AVCodec *codec;
1925     int got_picture, data_size, ret=0;
1926     AVFrame picture;
1927
1928     if(!st->codec->codec){
1929         codec = avcodec_find_decoder(st->codec->codec_id);
1930         if (!codec)
1931             return -1;
1932         ret = avcodec_open(st->codec, codec);
1933         if (ret < 0)
1934             return ret;
1935     }
1936
1937     if(!has_codec_parameters(st->codec)){
1938         switch(st->codec->codec_type) {
1939         case CODEC_TYPE_VIDEO:
1940             avcodec_get_frame_defaults(&picture);
1941             ret = avcodec_decode_video2(st->codec, &picture,
1942                                         &got_picture, avpkt);
1943             break;
1944         case CODEC_TYPE_AUDIO:
1945             data_size = FFMAX(avpkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
1946             samples = av_malloc(data_size);
1947             if (!samples)
1948                 goto fail;
1949             ret = avcodec_decode_audio3(st->codec, samples,
1950                                         &data_size, avpkt);
1951             av_free(samples);
1952             break;
1953         default:
1954             break;
1955         }
1956     }
1957  fail:
1958     return ret;
1959 }
1960
1961 unsigned int ff_codec_get_tag(const AVCodecTag *tags, int id)
1962 {
1963     while (tags->id != CODEC_ID_NONE) {
1964         if (tags->id == id)
1965             return tags->tag;
1966         tags++;
1967     }
1968     return 0;
1969 }
1970
1971 enum CodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
1972 {
1973     int i;
1974     for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
1975         if(tag == tags[i].tag)
1976             return tags[i].id;
1977     }
1978     for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
1979         if(   toupper((tag >> 0)&0xFF) == toupper((tags[i].tag >> 0)&0xFF)
1980            && toupper((tag >> 8)&0xFF) == toupper((tags[i].tag >> 8)&0xFF)
1981            && toupper((tag >>16)&0xFF) == toupper((tags[i].tag >>16)&0xFF)
1982            && toupper((tag >>24)&0xFF) == toupper((tags[i].tag >>24)&0xFF))
1983             return tags[i].id;
1984     }
1985     return CODEC_ID_NONE;
1986 }
1987
1988 unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum CodecID id)
1989 {
1990     int i;
1991     for(i=0; tags && tags[i]; i++){
1992         int tag= ff_codec_get_tag(tags[i], id);
1993         if(tag) return tag;
1994     }
1995     return 0;
1996 }
1997
1998 enum CodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
1999 {
2000     int i;
2001     for(i=0; tags && tags[i]; i++){
2002         enum CodecID id= ff_codec_get_id(tags[i], tag);
2003         if(id!=CODEC_ID_NONE) return id;
2004     }
2005     return CODEC_ID_NONE;
2006 }
2007
2008 static void compute_chapters_end(AVFormatContext *s)
2009 {
2010     unsigned int i;
2011
2012     for (i=0; i+1<s->nb_chapters; i++)
2013         if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2014             assert(s->chapters[i]->start <= s->chapters[i+1]->start);
2015             assert(!av_cmp_q(s->chapters[i]->time_base, s->chapters[i+1]->time_base));
2016             s->chapters[i]->end = s->chapters[i+1]->start;
2017         }
2018
2019     if (s->nb_chapters && s->chapters[i]->end == AV_NOPTS_VALUE) {
2020         assert(s->start_time != AV_NOPTS_VALUE);
2021         assert(s->duration > 0);
2022         s->chapters[i]->end = av_rescale_q(s->start_time + s->duration,
2023                                            AV_TIME_BASE_Q,
2024                                            s->chapters[i]->time_base);
2025     }
2026 }
2027
2028 #define MAX_STD_TIMEBASES (60*12+5)
2029 static int get_std_framerate(int i){
2030     if(i<60*12) return i*1001;
2031     else        return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
2032 }
2033
2034 /*
2035  * Is the time base unreliable.
2036  * This is a heuristic to balance between quick acceptance of the values in
2037  * the headers vs. some extra checks.
2038  * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2039  * MPEG-2 commonly misuses field repeat flags to store different framerates.
2040  * And there are "variable" fps files this needs to detect as well.
2041  */
2042 static int tb_unreliable(AVCodecContext *c){
2043     if(   c->time_base.den >= 101L*c->time_base.num
2044        || c->time_base.den <    5L*c->time_base.num
2045 /*       || c->codec_tag == AV_RL32("DIVX")
2046        || c->codec_tag == AV_RL32("XVID")*/
2047        || c->codec_id == CODEC_ID_MPEG2VIDEO
2048        || c->codec_id == CODEC_ID_H264
2049        )
2050         return 1;
2051     return 0;
2052 }
2053
2054 int av_find_stream_info(AVFormatContext *ic)
2055 {
2056     int i, count, ret, read_size, j;
2057     AVStream *st;
2058     AVPacket pkt1, *pkt;
2059     int64_t last_dts[MAX_STREAMS];
2060     int64_t duration_gcd[MAX_STREAMS]={0};
2061     int duration_count[MAX_STREAMS]={0};
2062     double (*duration_error)[MAX_STD_TIMEBASES];
2063     int64_t old_offset = url_ftell(ic->pb);
2064     int64_t codec_info_duration[MAX_STREAMS]={0};
2065     int codec_info_nb_frames[MAX_STREAMS]={0};
2066
2067     duration_error = av_mallocz(MAX_STREAMS * sizeof(*duration_error));
2068     if (!duration_error) return AVERROR(ENOMEM);
2069
2070     for(i=0;i<ic->nb_streams;i++) {
2071         st = ic->streams[i];
2072         if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2073 /*            if(!st->time_base.num)
2074                 st->time_base= */
2075             if(!st->codec->time_base.num)
2076                 st->codec->time_base= st->time_base;
2077         }
2078         //only for the split stuff
2079         if (!st->parser) {
2080             st->parser = av_parser_init(st->codec->codec_id);
2081             if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
2082                 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2083             }
2084         }
2085     }
2086
2087     for(i=0;i<MAX_STREAMS;i++){
2088         last_dts[i]= AV_NOPTS_VALUE;
2089     }
2090
2091     count = 0;
2092     read_size = 0;
2093     for(;;) {
2094         if(url_interrupt_cb()){
2095             ret= AVERROR(EINTR);
2096             av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2097             break;
2098         }
2099
2100         /* check if one codec still needs to be handled */
2101         for(i=0;i<ic->nb_streams;i++) {
2102             st = ic->streams[i];
2103             if (!has_codec_parameters(st->codec))
2104                 break;
2105             /* variable fps and no guess at the real fps */
2106             if(   tb_unreliable(st->codec)
2107                && duration_count[i]<20 && st->codec->codec_type == CODEC_TYPE_VIDEO)
2108                 break;
2109             if(st->parser && st->parser->parser->split && !st->codec->extradata)
2110                 break;
2111             if(st->first_dts == AV_NOPTS_VALUE)
2112                 break;
2113         }
2114         if (i == ic->nb_streams) {
2115             /* NOTE: if the format has no header, then we need to read
2116                some packets to get most of the streams, so we cannot
2117                stop here */
2118             if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2119                 /* if we found the info for all the codecs, we can stop */
2120                 ret = count;
2121                 av_log(ic, AV_LOG_DEBUG, "All info found\n");
2122                 break;
2123             }
2124         }
2125         /* we did not get all the codec info, but we read too much data */
2126         if (read_size >= ic->probesize) {
2127             ret = count;
2128             av_log(ic, AV_LOG_WARNING, "MAX_READ_SIZE:%d reached\n", ic->probesize);
2129             break;
2130         }
2131
2132         /* NOTE: a new stream can be added there if no header in file
2133            (AVFMTCTX_NOHEADER) */
2134         ret = av_read_frame_internal(ic, &pkt1);
2135         if(ret == AVERROR(EAGAIN))
2136             continue;
2137         if (ret < 0) {
2138             /* EOF or error */
2139             ret = -1; /* we could not have all the codec parameters before EOF */
2140             for(i=0;i<ic->nb_streams;i++) {
2141                 st = ic->streams[i];
2142                 if (!has_codec_parameters(st->codec)){
2143                     char buf[256];
2144                     avcodec_string(buf, sizeof(buf), st->codec, 0);
2145                     av_log(ic, AV_LOG_WARNING, "Could not find codec parameters (%s)\n", buf);
2146                 } else {
2147                     ret = 0;
2148                 }
2149             }
2150             break;
2151         }
2152
2153         pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2154         if(av_dup_packet(pkt) < 0) {
2155             av_free(duration_error);
2156             return AVERROR(ENOMEM);
2157         }
2158
2159         read_size += pkt->size;
2160
2161         st = ic->streams[pkt->stream_index];
2162         if(codec_info_nb_frames[st->index]>1) {
2163             if (st->time_base.den > 0 && av_rescale_q(codec_info_duration[st->index], st->time_base, AV_TIME_BASE_Q) >= ic->max_analyze_duration){
2164                 av_log(ic, AV_LOG_WARNING, "max_analyze_duration reached\n");
2165                 break;
2166             }
2167             codec_info_duration[st->index] += pkt->duration;
2168         }
2169         if (pkt->duration != 0)
2170             codec_info_nb_frames[st->index]++;
2171
2172         {
2173             int index= pkt->stream_index;
2174             int64_t last= last_dts[index];
2175             int64_t duration= pkt->dts - last;
2176
2177             if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
2178                 double dur= duration * av_q2d(st->time_base);
2179
2180 //                if(st->codec->codec_type == CODEC_TYPE_VIDEO)
2181 //                    av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
2182                 if(duration_count[index] < 2)
2183                     memset(duration_error[index], 0, sizeof(*duration_error));
2184                 for(i=1; i<MAX_STD_TIMEBASES; i++){
2185                     int framerate= get_std_framerate(i);
2186                     int ticks= lrintf(dur*framerate/(1001*12));
2187                     double error= dur - ticks*1001*12/(double)framerate;
2188                     duration_error[index][i] += error*error;
2189                 }
2190                 duration_count[index]++;
2191                 // ignore the first 4 values, they might have some random jitter
2192                 if (duration_count[index] > 3)
2193                     duration_gcd[index] = av_gcd(duration_gcd[index], duration);
2194             }
2195             if(last == AV_NOPTS_VALUE || duration_count[index]<=1)
2196                 last_dts[pkt->stream_index]= pkt->dts;
2197         }
2198         if(st->parser && st->parser->parser->split && !st->codec->extradata){
2199             int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2200             if(i){
2201                 st->codec->extradata_size= i;
2202                 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2203                 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2204                 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2205             }
2206         }
2207
2208         /* if still no information, we try to open the codec and to
2209            decompress the frame. We try to avoid that in most cases as
2210            it takes longer and uses more memory. For MPEG-4, we need to
2211            decompress for QuickTime. */
2212         if (!has_codec_parameters(st->codec))
2213             try_decode_frame(st, pkt);
2214
2215         count++;
2216     }
2217
2218     // close codecs which were opened in try_decode_frame()
2219     for(i=0;i<ic->nb_streams;i++) {
2220         st = ic->streams[i];
2221         if(st->codec->codec)
2222             avcodec_close(st->codec);
2223     }
2224     for(i=0;i<ic->nb_streams;i++) {
2225         st = ic->streams[i];
2226         if(codec_info_nb_frames[i]>2)
2227             av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2228                      (codec_info_nb_frames[i]-2)*(int64_t)st->time_base.den,
2229                       codec_info_duration[i]    *(int64_t)st->time_base.num, 60000);
2230         if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2231             if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample)
2232                 st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2233
2234             // the check for tb_unreliable() is not completely correct, since this is not about handling
2235             // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2236             // ipmovie.c produces.
2237             if (tb_unreliable(st->codec) && duration_count[i] > 15 && duration_gcd[i] > 1)
2238                 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, st->time_base.den, st->time_base.num * duration_gcd[i], INT_MAX);
2239             if(duration_count[i]
2240                && tb_unreliable(st->codec) /*&&
2241                //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2242                st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den*/){
2243                 int num = 0;
2244                 double best_error= 2*av_q2d(st->time_base);
2245                 best_error= best_error*best_error*duration_count[i]*1000*12*30;
2246
2247                 for(j=1; j<MAX_STD_TIMEBASES; j++){
2248                     double error= duration_error[i][j] * get_std_framerate(j);
2249 //                    if(st->codec->codec_type == CODEC_TYPE_VIDEO)
2250 //                        av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
2251                     if(error < best_error){
2252                         best_error= error;
2253                         num = get_std_framerate(j);
2254                     }
2255                 }
2256                 // do not increase frame rate by more than 1 % in order to match a standard rate.
2257                 if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
2258                     av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2259             }
2260
2261             if (!st->r_frame_rate.num){
2262                 if(    st->codec->time_base.den * (int64_t)st->time_base.num
2263                     <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
2264                     st->r_frame_rate.num = st->codec->time_base.den;
2265                     st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
2266                 }else{
2267                     st->r_frame_rate.num = st->time_base.den;
2268                     st->r_frame_rate.den = st->time_base.num;
2269                 }
2270             }
2271         }else if(st->codec->codec_type == CODEC_TYPE_AUDIO) {
2272             if(!st->codec->bits_per_coded_sample)
2273                 st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2274         }
2275     }
2276
2277     av_estimate_timings(ic, old_offset);
2278
2279     compute_chapters_end(ic);
2280
2281 #if 0
2282     /* correct DTS for B-frame streams with no timestamps */
2283     for(i=0;i<ic->nb_streams;i++) {
2284         st = ic->streams[i];
2285         if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2286             if(b-frames){
2287                 ppktl = &ic->packet_buffer;
2288                 while(ppkt1){
2289                     if(ppkt1->stream_index != i)
2290                         continue;
2291                     if(ppkt1->pkt->dts < 0)
2292                         break;
2293                     if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2294                         break;
2295                     ppkt1->pkt->dts -= delta;
2296                     ppkt1= ppkt1->next;
2297                 }
2298                 if(ppkt1)
2299                     continue;
2300                 st->cur_dts -= delta;
2301             }
2302         }
2303     }
2304 #endif
2305
2306     av_free(duration_error);
2307
2308     return ret;
2309 }
2310
2311 /*******************************************************/
2312
2313 int av_read_play(AVFormatContext *s)
2314 {
2315     if (s->iformat->read_play)
2316         return s->iformat->read_play(s);
2317     if (s->pb)
2318         return av_url_read_fpause(s->pb, 0);
2319     return AVERROR(ENOSYS);
2320 }
2321
2322 int av_read_pause(AVFormatContext *s)
2323 {
2324     if (s->iformat->read_pause)
2325         return s->iformat->read_pause(s);
2326     if (s->pb)
2327         return av_url_read_fpause(s->pb, 1);
2328     return AVERROR(ENOSYS);
2329 }
2330
2331 void av_close_input_stream(AVFormatContext *s)
2332 {
2333     int i;
2334     AVStream *st;
2335
2336     if (s->iformat->read_close)
2337         s->iformat->read_close(s);
2338     for(i=0;i<s->nb_streams;i++) {
2339         /* free all data in a stream component */
2340         st = s->streams[i];
2341         if (st->parser) {
2342             av_parser_close(st->parser);
2343             av_free_packet(&st->cur_pkt);
2344         }
2345         av_metadata_free(&st->metadata);
2346         av_free(st->index_entries);
2347         av_free(st->codec->extradata);
2348         av_free(st->codec);
2349 #if LIBAVFORMAT_VERSION_INT < (53<<16)
2350         av_free(st->filename);
2351 #endif
2352         av_free(st->priv_data);
2353         av_free(st);
2354     }
2355     for(i=s->nb_programs-1; i>=0; i--) {
2356 #if LIBAVFORMAT_VERSION_INT < (53<<16)
2357         av_freep(&s->programs[i]->provider_name);
2358         av_freep(&s->programs[i]->name);
2359 #endif
2360         av_metadata_free(&s->programs[i]->metadata);
2361         av_freep(&s->programs[i]->stream_index);
2362         av_freep(&s->programs[i]);
2363     }
2364     av_freep(&s->programs);
2365     flush_packet_queue(s);
2366     av_freep(&s->priv_data);
2367     while(s->nb_chapters--) {
2368 #if LIBAVFORMAT_VERSION_INT < (53<<16)
2369         av_free(s->chapters[s->nb_chapters]->title);
2370 #endif
2371         av_metadata_free(&s->chapters[s->nb_chapters]->metadata);
2372         av_free(s->chapters[s->nb_chapters]);
2373     }
2374     av_freep(&s->chapters);
2375     av_metadata_free(&s->metadata);
2376     av_free(s);
2377 }
2378
2379 void av_close_input_file(AVFormatContext *s)
2380 {
2381     ByteIOContext *pb = s->iformat->flags & AVFMT_NOFILE ? NULL : s->pb;
2382     av_close_input_stream(s);
2383     if (pb)
2384         url_fclose(pb);
2385 }
2386
2387 AVStream *av_new_stream(AVFormatContext *s, int id)
2388 {
2389     AVStream *st;
2390     int i;
2391
2392     if (s->nb_streams >= MAX_STREAMS)
2393         return NULL;
2394
2395     st = av_mallocz(sizeof(AVStream));
2396     if (!st)
2397         return NULL;
2398
2399     st->codec= avcodec_alloc_context();
2400     if (s->iformat) {
2401         /* no default bitrate if decoding */
2402         st->codec->bit_rate = 0;
2403     }
2404     st->index = s->nb_streams;
2405     st->id = id;
2406     st->start_time = AV_NOPTS_VALUE;
2407     st->duration = AV_NOPTS_VALUE;
2408         /* we set the current DTS to 0 so that formats without any timestamps
2409            but durations get some timestamps, formats with some unknown
2410            timestamps have their first few packets buffered and the
2411            timestamps corrected before they are returned to the user */
2412     st->cur_dts = 0;
2413     st->first_dts = AV_NOPTS_VALUE;
2414     st->probe_packets = MAX_PROBE_PACKETS;
2415
2416     /* default pts setting is MPEG-like */
2417     av_set_pts_info(st, 33, 1, 90000);
2418     st->last_IP_pts = AV_NOPTS_VALUE;
2419     for(i=0; i<MAX_REORDER_DELAY+1; i++)
2420         st->pts_buffer[i]= AV_NOPTS_VALUE;
2421     st->reference_dts = AV_NOPTS_VALUE;
2422
2423     st->sample_aspect_ratio = (AVRational){0,1};
2424
2425     s->streams[s->nb_streams++] = st;
2426     return st;
2427 }
2428
2429 AVProgram *av_new_program(AVFormatContext *ac, int id)
2430 {
2431     AVProgram *program=NULL;
2432     int i;
2433
2434 #ifdef DEBUG_SI
2435     av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2436 #endif
2437
2438     for(i=0; i<ac->nb_programs; i++)
2439         if(ac->programs[i]->id == id)
2440             program = ac->programs[i];
2441
2442     if(!program){
2443         program = av_mallocz(sizeof(AVProgram));
2444         if (!program)
2445             return NULL;
2446         dynarray_add(&ac->programs, &ac->nb_programs, program);
2447         program->discard = AVDISCARD_NONE;
2448     }
2449     program->id = id;
2450
2451     return program;
2452 }
2453
2454 AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2455 {
2456     AVChapter *chapter = NULL;
2457     int i;
2458
2459     for(i=0; i<s->nb_chapters; i++)
2460         if(s->chapters[i]->id == id)
2461             chapter = s->chapters[i];
2462
2463     if(!chapter){
2464         chapter= av_mallocz(sizeof(AVChapter));
2465         if(!chapter)
2466             return NULL;
2467         dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2468     }
2469 #if LIBAVFORMAT_VERSION_INT < (53<<16)
2470     av_free(chapter->title);
2471 #endif
2472     av_metadata_set(&chapter->metadata, "title", title);
2473     chapter->id    = id;
2474     chapter->time_base= time_base;
2475     chapter->start = start;
2476     chapter->end   = end;
2477
2478     return chapter;
2479 }
2480
2481 /************************************************************/
2482 /* output media file */
2483
2484 int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2485 {
2486     int ret;
2487
2488     if (s->oformat->priv_data_size > 0) {
2489         s->priv_data = av_mallocz(s->oformat->priv_data_size);
2490         if (!s->priv_data)
2491             return AVERROR(ENOMEM);
2492     } else
2493         s->priv_data = NULL;
2494
2495     if (s->oformat->set_parameters) {
2496         ret = s->oformat->set_parameters(s, ap);
2497         if (ret < 0)
2498             return ret;
2499     }
2500     return 0;
2501 }
2502
2503 int av_write_header(AVFormatContext *s)
2504 {
2505     int ret, i;
2506     AVStream *st;
2507
2508     // some sanity checks
2509     for(i=0;i<s->nb_streams;i++) {
2510         st = s->streams[i];
2511
2512         switch (st->codec->codec_type) {
2513         case CODEC_TYPE_AUDIO:
2514             if(st->codec->sample_rate<=0){
2515                 av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2516                 return -1;
2517             }
2518             if(!st->codec->block_align)
2519                 st->codec->block_align = st->codec->channels *
2520                     av_get_bits_per_sample(st->codec->codec_id) >> 3;
2521             break;
2522         case CODEC_TYPE_VIDEO:
2523             if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2524                 av_log(s, AV_LOG_ERROR, "time base not set\n");
2525                 return -1;
2526             }
2527             if(st->codec->width<=0 || st->codec->height<=0){
2528                 av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2529                 return -1;
2530             }
2531             if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)){
2532                 av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between encoder and muxer layer\n");
2533                 return -1;
2534             }
2535             break;
2536         }
2537
2538         if(s->oformat->codec_tag){
2539             if(st->codec->codec_tag){
2540                 //FIXME
2541                 //check that tag + id is in the table
2542                 //if neither is in the table -> OK
2543                 //if tag is in the table with another id -> FAIL
2544                 //if id is in the table with another tag -> FAIL unless strict < ?
2545             }else
2546                 st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2547         }
2548
2549         if(s->oformat->flags & AVFMT_GLOBALHEADER &&
2550             !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
2551           av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
2552     }
2553
2554     if (!s->priv_data && s->oformat->priv_data_size > 0) {
2555         s->priv_data = av_mallocz(s->oformat->priv_data_size);
2556         if (!s->priv_data)
2557             return AVERROR(ENOMEM);
2558     }
2559
2560 #if LIBAVFORMAT_VERSION_MAJOR < 53
2561     ff_metadata_mux_compat(s);
2562 #endif
2563
2564     if(s->oformat->write_header){
2565         ret = s->oformat->write_header(s);
2566         if (ret < 0)
2567             return ret;
2568     }
2569
2570     /* init PTS generation */
2571     for(i=0;i<s->nb_streams;i++) {
2572         int64_t den = AV_NOPTS_VALUE;
2573         st = s->streams[i];
2574
2575         switch (st->codec->codec_type) {
2576         case CODEC_TYPE_AUDIO:
2577             den = (int64_t)st->time_base.num * st->codec->sample_rate;
2578             break;
2579         case CODEC_TYPE_VIDEO:
2580             den = (int64_t)st->time_base.num * st->codec->time_base.den;
2581             break;
2582         default:
2583             break;
2584         }
2585         if (den != AV_NOPTS_VALUE) {
2586             if (den <= 0)
2587                 return AVERROR_INVALIDDATA;
2588             av_frac_init(&st->pts, 0, 0, den);
2589         }
2590     }
2591     return 0;
2592 }
2593
2594 //FIXME merge with compute_pkt_fields
2595 static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt){
2596     int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2597     int num, den, frame_size, i;
2598
2599 //    av_log(s, AV_LOG_DEBUG, "av_write_frame: pts:%"PRId64" dts:%"PRId64" cur_dts:%"PRId64" b:%d size:%d st:%d\n", pkt->pts, pkt->dts, st->cur_dts, delay, pkt->size, pkt->stream_index);
2600
2601 /*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2602         return -1;*/
2603
2604     /* duration field */
2605     if (pkt->duration == 0) {
2606         compute_frame_duration(&num, &den, st, NULL, pkt);
2607         if (den && num) {
2608             pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
2609         }
2610     }
2611
2612     if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
2613         pkt->pts= pkt->dts;
2614
2615     //XXX/FIXME this is a temporary hack until all encoders output pts
2616     if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2617         pkt->dts=
2618 //        pkt->pts= st->cur_dts;
2619         pkt->pts= st->pts.val;
2620     }
2621
2622     //calculate dts from pts
2623     if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
2624         st->pts_buffer[0]= pkt->pts;
2625         for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2626             st->pts_buffer[i]= (i-delay-1) * pkt->duration;
2627         for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2628             FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2629
2630         pkt->dts= st->pts_buffer[0];
2631     }
2632
2633     if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2634         av_log(s, AV_LOG_ERROR,
2635                "st:%d error, non monotone timestamps %"PRId64" >= %"PRId64"\n",
2636                st->index, st->cur_dts, pkt->dts);
2637         return -1;
2638     }
2639     if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2640         av_log(s, AV_LOG_ERROR, "st:%d error, pts < dts\n", st->index);
2641         return -1;
2642     }
2643
2644 //    av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2645     st->cur_dts= pkt->dts;
2646     st->pts.val= pkt->dts;
2647
2648     /* update pts */
2649     switch (st->codec->codec_type) {
2650     case CODEC_TYPE_AUDIO:
2651         frame_size = get_audio_frame_size(st->codec, pkt->size);
2652
2653         /* HACK/FIXME, we skip the initial 0 size packets as they are most
2654            likely equal to the encoder delay, but it would be better if we
2655            had the real timestamps from the encoder */
2656         if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2657             av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2658         }
2659         break;
2660     case CODEC_TYPE_VIDEO:
2661         av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2662         break;
2663     default:
2664         break;
2665     }
2666     return 0;
2667 }
2668
2669 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2670 {
2671     int ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt);
2672
2673     if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2674         return ret;
2675
2676     ret= s->oformat->write_packet(s, pkt);
2677     if(!ret)
2678         ret= url_ferror(s->pb);
2679     return ret;
2680 }
2681
2682 void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
2683                               int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
2684 {
2685     AVPacketList **next_point, *this_pktl;
2686
2687     this_pktl = av_mallocz(sizeof(AVPacketList));
2688     this_pktl->pkt= *pkt;
2689     pkt->destruct= NULL;             // do not free original but only the copy
2690     av_dup_packet(&this_pktl->pkt);  // duplicate the packet if it uses non-alloced memory
2691
2692     if(s->streams[pkt->stream_index]->last_in_packet_buffer){
2693         next_point = &(s->streams[pkt->stream_index]->last_in_packet_buffer->next);
2694     }else
2695         next_point = &s->packet_buffer;
2696
2697     if(*next_point){
2698         if(compare(s, &s->packet_buffer_end->pkt, pkt)){
2699             while(!compare(s, &(*next_point)->pkt, pkt)){
2700                 next_point= &(*next_point)->next;
2701             }
2702             goto next_non_null;
2703         }else{
2704             next_point = &(s->packet_buffer_end->next);
2705         }
2706     }
2707     assert(!*next_point);
2708
2709     s->packet_buffer_end= this_pktl;
2710 next_non_null:
2711
2712     this_pktl->next= *next_point;
2713
2714     s->streams[pkt->stream_index]->last_in_packet_buffer=
2715     *next_point= this_pktl;
2716 }
2717
2718 int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
2719 {
2720     AVStream *st = s->streams[ pkt ->stream_index];
2721     AVStream *st2= s->streams[ next->stream_index];
2722     int64_t left = st2->time_base.num * (int64_t)st ->time_base.den;
2723     int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2724
2725     if (pkt->dts == AV_NOPTS_VALUE)
2726         return 0;
2727
2728     return next->dts * left > pkt->dts * right; //FIXME this can overflow
2729 }
2730
2731 int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2732     AVPacketList *pktl;
2733     int stream_count=0;
2734     int i;
2735
2736     if(pkt){
2737         ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
2738     }
2739
2740     for(i=0; i < s->nb_streams; i++)
2741         stream_count+= !!s->streams[i]->last_in_packet_buffer;
2742
2743     if(stream_count && (s->nb_streams == stream_count || flush)){
2744         pktl= s->packet_buffer;
2745         *out= pktl->pkt;
2746
2747         s->packet_buffer= pktl->next;
2748         if(!s->packet_buffer)
2749             s->packet_buffer_end= NULL;
2750
2751         if(s->streams[out->stream_index]->last_in_packet_buffer == pktl)
2752             s->streams[out->stream_index]->last_in_packet_buffer= NULL;
2753         av_freep(&pktl);
2754         return 1;
2755     }else{
2756         av_init_packet(out);
2757         return 0;
2758     }
2759 }
2760
2761 /**
2762  * Interleaves an AVPacket correctly so it can be muxed.
2763  * @param out the interleaved packet will be output here
2764  * @param in the input packet
2765  * @param flush 1 if no further packets are available as input and all
2766  *              remaining packets should be output
2767  * @return 1 if a packet was output, 0 if no packet could be output,
2768  *         < 0 if an error occurred
2769  */
2770 static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2771     if(s->oformat->interleave_packet)
2772         return s->oformat->interleave_packet(s, out, in, flush);
2773     else
2774         return av_interleave_packet_per_dts(s, out, in, flush);
2775 }
2776
2777 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2778     AVStream *st= s->streams[ pkt->stream_index];
2779
2780     //FIXME/XXX/HACK drop zero sized packets
2781     if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2782         return 0;
2783
2784 //av_log(NULL, AV_LOG_DEBUG, "av_interleaved_write_frame %d %"PRId64" %"PRId64"\n", pkt->size, pkt->dts, pkt->pts);
2785     if(compute_pkt_fields2(s, st, pkt) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2786         return -1;
2787
2788     if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2789         return -1;
2790
2791     for(;;){
2792         AVPacket opkt;
2793         int ret= av_interleave_packet(s, &opkt, pkt, 0);
2794         if(ret<=0) //FIXME cleanup needed for ret<0 ?
2795             return ret;
2796
2797         ret= s->oformat->write_packet(s, &opkt);
2798
2799         av_free_packet(&opkt);
2800         pkt= NULL;
2801
2802         if(ret<0)
2803             return ret;
2804         if(url_ferror(s->pb))
2805             return url_ferror(s->pb);
2806     }
2807 }
2808
2809 int av_write_trailer(AVFormatContext *s)
2810 {
2811     int ret, i;
2812
2813     for(;;){
2814         AVPacket pkt;
2815         ret= av_interleave_packet(s, &pkt, NULL, 1);
2816         if(ret<0) //FIXME cleanup needed for ret<0 ?
2817             goto fail;
2818         if(!ret)
2819             break;
2820
2821         ret= s->oformat->write_packet(s, &pkt);
2822
2823         av_free_packet(&pkt);
2824
2825         if(ret<0)
2826             goto fail;
2827         if(url_ferror(s->pb))
2828             goto fail;
2829     }
2830
2831     if(s->oformat->write_trailer)
2832         ret = s->oformat->write_trailer(s);
2833 fail:
2834     if(ret == 0)
2835        ret=url_ferror(s->pb);
2836     for(i=0;i<s->nb_streams;i++)
2837         av_freep(&s->streams[i]->priv_data);
2838     av_freep(&s->priv_data);
2839     return ret;
2840 }
2841
2842 void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
2843 {
2844     int i, j;
2845     AVProgram *program=NULL;
2846     void *tmp;
2847
2848     if (idx >= ac->nb_streams) {
2849         av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
2850         return;
2851     }
2852
2853     for(i=0; i<ac->nb_programs; i++){
2854         if(ac->programs[i]->id != progid)
2855             continue;
2856         program = ac->programs[i];
2857         for(j=0; j<program->nb_stream_indexes; j++)
2858             if(program->stream_index[j] == idx)
2859                 return;
2860
2861         tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
2862         if(!tmp)
2863             return;
2864         program->stream_index = tmp;
2865         program->stream_index[program->nb_stream_indexes++] = idx;
2866         return;
2867     }
2868 }
2869
2870 static void print_fps(double d, const char *postfix){
2871     uint64_t v= lrintf(d*100);
2872     if     (v% 100      ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
2873     else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
2874     else                  av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
2875 }
2876
2877 /* "user interface" functions */
2878 static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
2879 {
2880     char buf[256];
2881     int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
2882     AVStream *st = ic->streams[i];
2883     int g = av_gcd(st->time_base.num, st->time_base.den);
2884     AVMetadataTag *lang = av_metadata_get(st->metadata, "language", NULL, 0);
2885     avcodec_string(buf, sizeof(buf), st->codec, is_output);
2886     av_log(NULL, AV_LOG_INFO, "    Stream #%d.%d", index, i);
2887     /* the pid is an important information, so we display it */
2888     /* XXX: add a generic system */
2889     if (flags & AVFMT_SHOW_IDS)
2890         av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
2891     if (lang)
2892         av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
2893     av_log(NULL, AV_LOG_DEBUG, ", %d/%d", st->time_base.num/g, st->time_base.den/g);
2894     av_log(NULL, AV_LOG_INFO, ": %s", buf);
2895     if (st->sample_aspect_ratio.num && // default
2896         av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
2897         AVRational display_aspect_ratio;
2898         av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
2899                   st->codec->width*st->sample_aspect_ratio.num,
2900                   st->codec->height*st->sample_aspect_ratio.den,
2901                   1024*1024);
2902         av_log(NULL, AV_LOG_INFO, ", PAR %d:%d DAR %d:%d",
2903                  st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
2904                  display_aspect_ratio.num, display_aspect_ratio.den);
2905     }
2906     if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2907         if(st->avg_frame_rate.den && st->avg_frame_rate.num)
2908             print_fps(av_q2d(st->avg_frame_rate), "fps");
2909         if(st->r_frame_rate.den && st->r_frame_rate.num)
2910             print_fps(av_q2d(st->r_frame_rate), "tbr");
2911         if(st->time_base.den && st->time_base.num)
2912             print_fps(1/av_q2d(st->time_base), "tbn");
2913         if(st->codec->time_base.den && st->codec->time_base.num)
2914             print_fps(1/av_q2d(st->codec->time_base), "tbc");
2915     }
2916     av_log(NULL, AV_LOG_INFO, "\n");
2917 }
2918
2919 void dump_format(AVFormatContext *ic,
2920                  int index,
2921                  const char *url,
2922                  int is_output)
2923 {
2924     int i;
2925     uint8_t *printed = av_mallocz(ic->nb_streams);
2926     if (ic->nb_streams && !printed)
2927         return;
2928
2929     av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
2930             is_output ? "Output" : "Input",
2931             index,
2932             is_output ? ic->oformat->name : ic->iformat->name,
2933             is_output ? "to" : "from", url);
2934     if (!is_output) {
2935         av_log(NULL, AV_LOG_INFO, "  Duration: ");
2936         if (ic->duration != AV_NOPTS_VALUE) {
2937             int hours, mins, secs, us;
2938             secs = ic->duration / AV_TIME_BASE;
2939             us = ic->duration % AV_TIME_BASE;
2940             mins = secs / 60;
2941             secs %= 60;
2942             hours = mins / 60;
2943             mins %= 60;
2944             av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
2945                    (100 * us) / AV_TIME_BASE);
2946         } else {
2947             av_log(NULL, AV_LOG_INFO, "N/A");
2948         }
2949         if (ic->start_time != AV_NOPTS_VALUE) {
2950             int secs, us;
2951             av_log(NULL, AV_LOG_INFO, ", start: ");
2952             secs = ic->start_time / AV_TIME_BASE;
2953             us = ic->start_time % AV_TIME_BASE;
2954             av_log(NULL, AV_LOG_INFO, "%d.%06d",
2955                    secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
2956         }
2957         av_log(NULL, AV_LOG_INFO, ", bitrate: ");
2958         if (ic->bit_rate) {
2959             av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
2960         } else {
2961             av_log(NULL, AV_LOG_INFO, "N/A");
2962         }
2963         av_log(NULL, AV_LOG_INFO, "\n");
2964     }
2965     if(ic->nb_programs) {
2966         int j, k, total = 0;
2967         for(j=0; j<ic->nb_programs; j++) {
2968             AVMetadataTag *name = av_metadata_get(ic->programs[j]->metadata,
2969                                                   "name", NULL, 0);
2970             av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
2971                    name ? name->value : "");
2972             for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
2973                 dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
2974                 printed[ic->programs[j]->stream_index[k]] = 1;
2975             }
2976             total += ic->programs[j]->nb_stream_indexes;
2977         }
2978         if (total < ic->nb_streams)
2979             av_log(NULL, AV_LOG_INFO, "  No Program\n");
2980     }
2981     for(i=0;i<ic->nb_streams;i++)
2982         if (!printed[i])
2983             dump_stream_format(ic, i, index, is_output);
2984
2985     if (ic->metadata) {
2986         AVMetadataTag *tag=NULL;
2987         av_log(NULL, AV_LOG_INFO, "  Metadata\n");
2988         while((tag=av_metadata_get(ic->metadata, "", tag, AV_METADATA_IGNORE_SUFFIX))) {
2989             av_log(NULL, AV_LOG_INFO, "    %-16s: %s\n", tag->key, tag->value);
2990         }
2991     }
2992     av_free(printed);
2993 }
2994
2995 #if LIBAVFORMAT_VERSION_MAJOR < 53
2996 int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2997 {
2998     return av_parse_video_frame_size(width_ptr, height_ptr, str);
2999 }
3000
3001 int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
3002 {
3003     AVRational frame_rate;
3004     int ret = av_parse_video_frame_rate(&frame_rate, arg);
3005     *frame_rate_num= frame_rate.num;
3006     *frame_rate_den= frame_rate.den;
3007     return ret;
3008 }
3009 #endif
3010
3011 int64_t av_gettime(void)
3012 {
3013     struct timeval tv;
3014     gettimeofday(&tv,NULL);
3015     return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
3016 }
3017
3018 int64_t parse_date(const char *datestr, int duration)
3019 {
3020     const char *p;
3021     int64_t t;
3022     struct tm dt;
3023     int i;
3024     static const char * const date_fmt[] = {
3025         "%Y-%m-%d",
3026         "%Y%m%d",
3027     };
3028     static const char * const time_fmt[] = {
3029         "%H:%M:%S",
3030         "%H%M%S",
3031     };
3032     const char *q;
3033     int is_utc, len;
3034     char lastch;
3035     int negative = 0;
3036
3037 #undef time
3038     time_t now = time(0);
3039
3040     len = strlen(datestr);
3041     if (len > 0)
3042         lastch = datestr[len - 1];
3043     else
3044         lastch = '\0';
3045     is_utc = (lastch == 'z' || lastch == 'Z');
3046
3047     memset(&dt, 0, sizeof(dt));
3048
3049     p = datestr;
3050     q = NULL;
3051     if (!duration) {
3052         if (!strncasecmp(datestr, "now", len))
3053             return (int64_t) now * 1000000;
3054
3055         /* parse the year-month-day part */
3056         for (i = 0; i < FF_ARRAY_ELEMS(date_fmt); i++) {
3057             q = small_strptime(p, date_fmt[i], &dt);
3058             if (q) {
3059                 break;
3060             }
3061         }
3062
3063         /* if the year-month-day part is missing, then take the
3064          * current year-month-day time */
3065         if (!q) {
3066             if (is_utc) {
3067                 dt = *gmtime(&now);
3068             } else {
3069                 dt = *localtime(&now);
3070             }
3071             dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
3072         } else {
3073             p = q;
3074         }
3075
3076         if (*p == 'T' || *p == 't' || *p == ' ')
3077             p++;
3078
3079         /* parse the hour-minute-second part */
3080         for (i = 0; i < FF_ARRAY_ELEMS(time_fmt); i++) {
3081             q = small_strptime(p, time_fmt[i], &dt);
3082             if (q) {
3083                 break;
3084             }
3085         }
3086     } else {
3087         /* parse datestr as a duration */
3088         if (p[0] == '-') {
3089             negative = 1;
3090             ++p;
3091         }
3092         /* parse datestr as HH:MM:SS */
3093         q = small_strptime(p, time_fmt[0], &dt);
3094         if (!q) {
3095             /* parse datestr as S+ */
3096             dt.tm_sec = strtol(p, (char **)&q, 10);
3097             if (q == p)
3098                 /* the parsing didn't succeed */
3099                 return INT64_MIN;
3100             dt.tm_min = 0;
3101             dt.tm_hour = 0;
3102         }
3103     }
3104
3105     /* Now we have all the fields that we can get */
3106     if (!q) {
3107         return INT64_MIN;
3108     }
3109
3110     if (duration) {
3111         t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
3112     } else {
3113         dt.tm_isdst = -1;       /* unknown */
3114         if (is_utc) {
3115             t = mktimegm(&dt);
3116         } else {
3117             t = mktime(&dt);
3118         }
3119     }
3120
3121     t *= 1000000;
3122
3123     /* parse the .m... part */
3124     if (*q == '.') {
3125         int val, n;
3126         q++;
3127         for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
3128             if (!isdigit(*q))
3129                 break;
3130             val += n * (*q - '0');
3131         }
3132         t += val;
3133     }
3134     return negative ? -t : t;
3135 }
3136
3137 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
3138 {
3139     const char *p;
3140     char tag[128], *q;
3141
3142     p = info;
3143     if (*p == '?')
3144         p++;
3145     for(;;) {
3146         q = tag;
3147         while (*p != '\0' && *p != '=' && *p != '&') {
3148             if ((q - tag) < sizeof(tag) - 1)
3149                 *q++ = *p;
3150             p++;
3151         }
3152         *q = '\0';
3153         q = arg;
3154         if (*p == '=') {
3155             p++;
3156             while (*p != '&' && *p != '\0') {
3157                 if ((q - arg) < arg_size - 1) {
3158                     if (*p == '+')
3159                         *q++ = ' ';
3160                     else
3161                         *q++ = *p;
3162                 }
3163                 p++;
3164             }
3165             *q = '\0';
3166         }
3167         if (!strcmp(tag, tag1))
3168             return 1;
3169         if (*p != '&')
3170             break;
3171         p++;
3172     }
3173     return 0;
3174 }
3175
3176 int av_get_frame_filename(char *buf, int buf_size,
3177                           const char *path, int number)
3178 {
3179     const char *p;
3180     char *q, buf1[20], c;
3181     int nd, len, percentd_found;
3182
3183     q = buf;
3184     p = path;
3185     percentd_found = 0;
3186     for(;;) {
3187         c = *p++;
3188         if (c == '\0')
3189             break;
3190         if (c == '%') {
3191             do {
3192                 nd = 0;
3193                 while (isdigit(*p)) {
3194                     nd = nd * 10 + *p++ - '0';
3195                 }
3196                 c = *p++;
3197             } while (isdigit(c));
3198
3199             switch(c) {
3200             case '%':
3201                 goto addchar;
3202             case 'd':
3203                 if (percentd_found)
3204                     goto fail;
3205                 percentd_found = 1;
3206                 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3207                 len = strlen(buf1);
3208                 if ((q - buf + len) > buf_size - 1)
3209                     goto fail;
3210                 memcpy(q, buf1, len);
3211                 q += len;
3212                 break;
3213             default:
3214                 goto fail;
3215             }
3216         } else {
3217         addchar:
3218             if ((q - buf) < buf_size - 1)
3219                 *q++ = c;
3220         }
3221     }
3222     if (!percentd_found)
3223         goto fail;
3224     *q = '\0';
3225     return 0;
3226  fail:
3227     *q = '\0';
3228     return -1;
3229 }
3230
3231 static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3232 {
3233     int len, i, j, c;
3234 #undef fprintf
3235 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3236
3237     for(i=0;i<size;i+=16) {
3238         len = size - i;
3239         if (len > 16)
3240             len = 16;
3241         PRINT("%08x ", i);
3242         for(j=0;j<16;j++) {
3243             if (j < len)
3244                 PRINT(" %02x", buf[i+j]);
3245             else
3246                 PRINT("   ");
3247         }
3248         PRINT(" ");
3249         for(j=0;j<len;j++) {
3250             c = buf[i+j];
3251             if (c < ' ' || c > '~')
3252                 c = '.';
3253             PRINT("%c", c);
3254         }
3255         PRINT("\n");
3256     }
3257 #undef PRINT
3258 }
3259
3260 void av_hex_dump(FILE *f, uint8_t *buf, int size)
3261 {
3262     hex_dump_internal(NULL, f, 0, buf, size);
3263 }
3264
3265 void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3266 {
3267     hex_dump_internal(avcl, NULL, level, buf, size);
3268 }
3269
3270  //FIXME needs to know the time_base
3271 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload)
3272 {
3273 #undef fprintf
3274 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3275     PRINT("stream #%d:\n", pkt->stream_index);
3276     PRINT("  keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
3277     PRINT("  duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
3278     /* DTS is _always_ valid after av_read_frame() */
3279     PRINT("  dts=");
3280     if (pkt->dts == AV_NOPTS_VALUE)
3281         PRINT("N/A");
3282     else
3283         PRINT("%0.3f", (double)pkt->dts / AV_TIME_BASE);
3284     /* PTS may not be known if B-frames are present. */
3285     PRINT("  pts=");
3286     if (pkt->pts == AV_NOPTS_VALUE)
3287         PRINT("N/A");
3288     else
3289         PRINT("%0.3f", (double)pkt->pts / AV_TIME_BASE);
3290     PRINT("\n");
3291     PRINT("  size=%d\n", pkt->size);
3292 #undef PRINT
3293     if (dump_payload)
3294         av_hex_dump(f, pkt->data, pkt->size);
3295 }
3296
3297 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3298 {
3299     pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
3300 }
3301
3302 void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3303 {
3304     pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
3305 }
3306
3307 void url_split(char *proto, int proto_size,
3308                char *authorization, int authorization_size,
3309                char *hostname, int hostname_size,
3310                int *port_ptr,
3311                char *path, int path_size,
3312                const char *url)
3313 {
3314     const char *p, *ls, *at, *col, *brk;
3315
3316     if (port_ptr)               *port_ptr = -1;
3317     if (proto_size > 0)         proto[0] = 0;
3318     if (authorization_size > 0) authorization[0] = 0;
3319     if (hostname_size > 0)      hostname[0] = 0;
3320     if (path_size > 0)          path[0] = 0;
3321
3322     /* parse protocol */
3323     if ((p = strchr(url, ':'))) {
3324         av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3325         p++; /* skip ':' */
3326         if (*p == '/') p++;
3327         if (*p == '/') p++;
3328     } else {
3329         /* no protocol means plain filename */
3330         av_strlcpy(path, url, path_size);
3331         return;
3332     }
3333
3334     /* separate path from hostname */
3335     ls = strchr(p, '/');
3336     if(!ls)
3337         ls = strchr(p, '?');
3338     if(ls)
3339         av_strlcpy(path, ls, path_size);
3340     else
3341         ls = &p[strlen(p)]; // XXX
3342
3343     /* the rest is hostname, use that to parse auth/port */
3344     if (ls != p) {
3345         /* authorization (user[:pass]@hostname) */
3346         if ((at = strchr(p, '@')) && at < ls) {
3347             av_strlcpy(authorization, p,
3348                        FFMIN(authorization_size, at + 1 - p));
3349             p = at + 1; /* skip '@' */
3350         }
3351
3352         if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3353             /* [host]:port */
3354             av_strlcpy(hostname, p + 1,
3355                        FFMIN(hostname_size, brk - p));
3356             if (brk[1] == ':' && port_ptr)
3357                 *port_ptr = atoi(brk + 2);
3358         } else if ((col = strchr(p, ':')) && col < ls) {
3359             av_strlcpy(hostname, p,
3360                        FFMIN(col + 1 - p, hostname_size));
3361             if (port_ptr) *port_ptr = atoi(col + 1);
3362         } else
3363             av_strlcpy(hostname, p,
3364                        FFMIN(ls + 1 - p, hostname_size));
3365     }
3366 }
3367
3368 char *ff_data_to_hex(char *buff, const uint8_t *src, int s)
3369 {
3370     int i;
3371     static const char hex_table[16] = { '0', '1', '2', '3',
3372                                         '4', '5', '6', '7',
3373                                         '8', '9', 'A', 'B',
3374                                         'C', 'D', 'E', 'F' };
3375
3376     for(i = 0; i < s; i++) {
3377         buff[i * 2]     = hex_table[src[i] >> 4];
3378         buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3379     }
3380
3381     return buff;
3382 }
3383
3384 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3385                      unsigned int pts_num, unsigned int pts_den)
3386 {
3387     s->pts_wrap_bits = pts_wrap_bits;
3388
3389     if(av_reduce(&s->time_base.num, &s->time_base.den, pts_num, pts_den, INT_MAX)){
3390         if(s->time_base.num != pts_num)
3391             av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/s->time_base.num);
3392     }else
3393         av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3394
3395     if(!s->time_base.num || !s->time_base.den)
3396         s->time_base.num= s->time_base.den= 0;
3397 }