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