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