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

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