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

   1 /*
   2  * various utility functions for use within Libav
   3  * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
   4  *
   5  * This file is part of Libav.
   6  *
   7  * Libav 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  * Libav 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 Libav; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 /* #define DEBUG */
  23
  24 #include "avformat.h"
  25 #include "avio_internal.h"
  26 #include "internal.h"
  27 #include "libavcodec/internal.h"
  28 #include "libavcodec/bytestream.h"
  29 #include "libavutil/opt.h"
  30 #include "libavutil/dict.h"
  31 #include "libavutil/pixdesc.h"
  32 #include "metadata.h"
  33 #include "id3v2.h"
  34 #include "libavutil/avstring.h"
  35 #include "libavutil/mathematics.h"
  36 #include "libavutil/parseutils.h"
  37 #include "riff.h"
  38 #include "audiointerleave.h"
  39 #include "url.h"
  40 #include <sys/time.h>
  41 #include <time.h>
  42 #include <stdarg.h>
  43 #if CONFIG_NETWORK
  44 #include "network.h"
  45 #endif
  46
  47 #undef NDEBUG
  48 #include <assert.h>
  49
  50 /**
  51  * @file
  52  * various utility functions for use within Libav
  53  */
  54
  55 unsigned avformat_version(void)
  56 {
  57     return LIBAVFORMAT_VERSION_INT;
  58 }
  59
  60 const char *avformat_configuration(void)
  61 {
  62     return LIBAV_CONFIGURATION;
  63 }
  64
  65 const char *avformat_license(void)
  66 {
  67 #define LICENSE_PREFIX "libavformat license: "
  68     return LICENSE_PREFIX LIBAV_LICENSE + sizeof(LICENSE_PREFIX) - 1;
  69 }
  70
  71 /* fraction handling */
  72
  73 /**
  74  * f = val + (num / den) + 0.5.
  75  *
  76  * 'num' is normalized so that it is such as 0 <= num < den.
  77  *
  78  * @param f fractional number
  79  * @param val integer value
  80  * @param num must be >= 0
  81  * @param den must be >= 1
  82  */
  83 static void frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
  84 {
  85     num += (den >> 1);
  86     if (num >= den) {
  87         val += num / den;
  88         num = num % den;
  89     }
  90     f->val = val;
  91     f->num = num;
  92     f->den = den;
  93 }
  94
  95 /**
  96  * Fractional addition to f: f = f + (incr / f->den).
  97  *
  98  * @param f fractional number
  99  * @param incr increment, can be positive or negative
 100  */
 101 static void frac_add(AVFrac *f, int64_t incr)
 102 {
 103     int64_t num, den;
 104
 105     num = f->num + incr;
 106     den = f->den;
 107     if (num < 0) {
 108         f->val += num / den;
 109         num = num % den;
 110         if (num < 0) {
 111             num += den;
 112             f->val--;
 113         }
 114     } else if (num >= den) {
 115         f->val += num / den;
 116         num = num % den;
 117     }
 118     f->num = num;
 119 }
 120
 121 /** head of registered input format linked list */
 122 static AVInputFormat *first_iformat = NULL;
 123 /** head of registered output format linked list */
 124 static AVOutputFormat *first_oformat = NULL;
 125
 126 AVInputFormat  *av_iformat_next(AVInputFormat  *f)
 127 {
 128     if(f) return f->next;
 129     else  return first_iformat;
 130 }
 131
 132 AVOutputFormat *av_oformat_next(AVOutputFormat *f)
 133 {
 134     if(f) return f->next;
 135     else  return first_oformat;
 136 }
 137
 138 void av_register_input_format(AVInputFormat *format)
 139 {
 140     AVInputFormat **p;
 141     p = &first_iformat;
 142     while (*p != NULL) p = &(*p)->next;
 143     *p = format;
 144     format->next = NULL;
 145 }
 146
 147 void av_register_output_format(AVOutputFormat *format)
 148 {
 149     AVOutputFormat **p;
 150     p = &first_oformat;
 151     while (*p != NULL) p = &(*p)->next;
 152     *p = format;
 153     format->next = NULL;
 154 }
 155
 156 int av_match_ext(const char *filename, const char *extensions)
 157 {
 158     const char *ext, *p;
 159     char ext1[32], *q;
 160
 161     if(!filename)
 162         return 0;
 163
 164     ext = strrchr(filename, '.');
 165     if (ext) {
 166         ext++;
 167         p = extensions;
 168         for(;;) {
 169             q = ext1;
 170             while (*p != '\0' && *p != ',' && q-ext1<sizeof(ext1)-1)
 171                 *q++ = *p++;
 172             *q = '\0';
 173             if (!av_strcasecmp(ext1, ext))
 174                 return 1;
 175             if (*p == '\0')
 176                 break;
 177             p++;
 178         }
 179     }
 180     return 0;
 181 }
 182
 183 static int match_format(const char *name, const char *names)
 184 {
 185     const char *p;
 186     int len, namelen;
 187
 188     if (!name || !names)
 189         return 0;
 190
 191     namelen = strlen(name);
 192     while ((p = strchr(names, ','))) {
 193         len = FFMAX(p - names, namelen);
 194         if (!av_strncasecmp(name, names, len))
 195             return 1;
 196         names = p+1;
 197     }
 198     return !av_strcasecmp(name, names);
 199 }
 200
 201 AVOutputFormat *av_guess_format(const char *short_name, const char *filename,
 202                                 const char *mime_type)
 203 {
 204     AVOutputFormat *fmt = NULL, *fmt_found;
 205     int score_max, score;
 206
 207     /* specific test for image sequences */
 208 #if CONFIG_IMAGE2_MUXER
 209     if (!short_name && filename &&
 210         av_filename_number_test(filename) &&
 211         ff_guess_image2_codec(filename) != CODEC_ID_NONE) {
 212         return av_guess_format("image2", NULL, NULL);
 213     }
 214 #endif
 215     /* Find the proper file type. */
 216     fmt_found = NULL;
 217     score_max = 0;
 218     while ((fmt = av_oformat_next(fmt))) {
 219         score = 0;
 220         if (fmt->name && short_name && !strcmp(fmt->name, short_name))
 221             score += 100;
 222         if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
 223             score += 10;
 224         if (filename && fmt->extensions &&
 225             av_match_ext(filename, fmt->extensions)) {
 226             score += 5;
 227         }
 228         if (score > score_max) {
 229             score_max = score;
 230             fmt_found = fmt;
 231         }
 232     }
 233     return fmt_found;
 234 }
 235
 236 enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
 237                             const char *filename, const char *mime_type, enum AVMediaType type){
 238     if(type == AVMEDIA_TYPE_VIDEO){
 239         enum CodecID codec_id= CODEC_ID_NONE;
 240
 241 #if CONFIG_IMAGE2_MUXER
 242         if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
 243             codec_id= ff_guess_image2_codec(filename);
 244         }
 245 #endif
 246         if(codec_id == CODEC_ID_NONE)
 247             codec_id= fmt->video_codec;
 248         return codec_id;
 249     }else if(type == AVMEDIA_TYPE_AUDIO)
 250         return fmt->audio_codec;
 251     else if (type == AVMEDIA_TYPE_SUBTITLE)
 252         return fmt->subtitle_codec;
 253     else
 254         return CODEC_ID_NONE;
 255 }
 256
 257 AVInputFormat *av_find_input_format(const char *short_name)
 258 {
 259     AVInputFormat *fmt = NULL;
 260     while ((fmt = av_iformat_next(fmt))) {
 261         if (match_format(short_name, fmt->name))
 262             return fmt;
 263     }
 264     return NULL;
 265 }
 266
 267
 268 int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
 269 {
 270     int ret= av_new_packet(pkt, size);
 271
 272     if(ret<0)
 273         return ret;
 274
 275     pkt->pos= avio_tell(s);
 276
 277     ret= avio_read(s, pkt->data, size);
 278     if(ret<=0)
 279         av_free_packet(pkt);
 280     else
 281         av_shrink_packet(pkt, ret);
 282
 283     return ret;
 284 }
 285
 286 int av_append_packet(AVIOContext *s, AVPacket *pkt, int size)
 287 {
 288     int ret;
 289     int old_size;
 290     if (!pkt->size)
 291         return av_get_packet(s, pkt, size);
 292     old_size = pkt->size;
 293     ret = av_grow_packet(pkt, size);
 294     if (ret < 0)
 295         return ret;
 296     ret = avio_read(s, pkt->data + old_size, size);
 297     av_shrink_packet(pkt, old_size + FFMAX(ret, 0));
 298     return ret;
 299 }
 300
 301
 302 int av_filename_number_test(const char *filename)
 303 {
 304     char buf[1024];
 305     return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
 306 }
 307
 308 AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
 309 {
 310     AVProbeData lpd = *pd;
 311     AVInputFormat *fmt1 = NULL, *fmt;
 312     int score, id3 = 0;
 313
 314     if (lpd.buf_size > 10 && ff_id3v2_match(lpd.buf, ID3v2_DEFAULT_MAGIC)) {
 315         int id3len = ff_id3v2_tag_len(lpd.buf);
 316         if (lpd.buf_size > id3len + 16) {
 317             lpd.buf += id3len;
 318             lpd.buf_size -= id3len;
 319         }
 320         id3 = 1;
 321     }
 322
 323     fmt = NULL;
 324     while ((fmt1 = av_iformat_next(fmt1))) {
 325         if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
 326             continue;
 327         score = 0;
 328         if (fmt1->read_probe) {
 329             score = fmt1->read_probe(&lpd);
 330         } else if (fmt1->extensions) {
 331             if (av_match_ext(lpd.filename, fmt1->extensions)) {
 332                 score = 50;
 333             }
 334         }
 335         if (score > *score_max) {
 336             *score_max = score;
 337             fmt = fmt1;
 338         }else if (score == *score_max)
 339             fmt = NULL;
 340     }
 341
 342     /* a hack for files with huge id3v2 tags -- try to guess by file extension. */
 343     if (!fmt && is_opened && *score_max < AVPROBE_SCORE_MAX/4) {
 344         while ((fmt = av_iformat_next(fmt)))
 345             if (fmt->extensions && av_match_ext(lpd.filename, fmt->extensions)) {
 346                 *score_max = AVPROBE_SCORE_MAX/4;
 347                 break;
 348             }
 349     }
 350
 351     if (!fmt && id3 && *score_max < AVPROBE_SCORE_MAX/4-1) {
 352         while ((fmt = av_iformat_next(fmt)))
 353             if (fmt->extensions && av_match_ext("mp3", fmt->extensions)) {
 354                 *score_max = AVPROBE_SCORE_MAX/4-1;
 355                 break;
 356             }
 357     }
 358
 359     return fmt;
 360 }
 361
 362 AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
 363     int score=0;
 364     return av_probe_input_format2(pd, is_opened, &score);
 365 }
 366
 367 static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st, AVProbeData *pd, int score)
 368 {
 369     static const struct {
 370         const char *name; enum CodecID id; enum AVMediaType type;
 371     } fmt_id_type[] = {
 372         { "aac"      , CODEC_ID_AAC       , AVMEDIA_TYPE_AUDIO },
 373         { "ac3"      , CODEC_ID_AC3       , AVMEDIA_TYPE_AUDIO },
 374         { "dts"      , CODEC_ID_DTS       , AVMEDIA_TYPE_AUDIO },
 375         { "eac3"     , CODEC_ID_EAC3      , AVMEDIA_TYPE_AUDIO },
 376         { "h264"     , CODEC_ID_H264      , AVMEDIA_TYPE_VIDEO },
 377         { "m4v"      , CODEC_ID_MPEG4     , AVMEDIA_TYPE_VIDEO },
 378         { "mp3"      , CODEC_ID_MP3       , AVMEDIA_TYPE_AUDIO },
 379         { "mpegvideo", CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
 380         { 0 }
 381     };
 382     AVInputFormat *fmt = av_probe_input_format2(pd, 1, &score);
 383
 384     if (fmt) {
 385         int i;
 386         av_log(s, AV_LOG_DEBUG, "Probe with size=%d, packets=%d detected %s with score=%d\n",
 387                pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets, fmt->name, score);
 388         for (i = 0; fmt_id_type[i].name; i++) {
 389             if (!strcmp(fmt->name, fmt_id_type[i].name)) {
 390                 st->codec->codec_id   = fmt_id_type[i].id;
 391                 st->codec->codec_type = fmt_id_type[i].type;
 392                 break;
 393             }
 394         }
 395     }
 396     return !!fmt;
 397 }
 398
 399 /************************************************************/
 400 /* input media file */
 401
 402 #if FF_API_FORMAT_PARAMETERS
 403 static AVDictionary *convert_format_parameters(AVFormatParameters *ap)
 404 {
 405     char buf[1024];
 406     AVDictionary *opts = NULL;
 407
 408     if (!ap)
 409         return NULL;
 410
 411     if (ap->time_base.num) {
 412         snprintf(buf, sizeof(buf), "%d/%d", ap->time_base.den, ap->time_base.num);
 413         av_dict_set(&opts, "framerate", buf, 0);
 414     }
 415     if (ap->sample_rate) {
 416         snprintf(buf, sizeof(buf), "%d", ap->sample_rate);
 417         av_dict_set(&opts, "sample_rate", buf, 0);
 418     }
 419     if (ap->channels) {
 420         snprintf(buf, sizeof(buf), "%d", ap->channels);
 421         av_dict_set(&opts, "channels", buf, 0);
 422     }
 423     if (ap->width || ap->height) {
 424         snprintf(buf, sizeof(buf), "%dx%d", ap->width, ap->height);
 425         av_dict_set(&opts, "video_size", buf, 0);
 426     }
 427     if (ap->pix_fmt != PIX_FMT_NONE) {
 428         av_dict_set(&opts, "pixel_format", av_get_pix_fmt_name(ap->pix_fmt), 0);
 429     }
 430     if (ap->channel) {
 431         snprintf(buf, sizeof(buf), "%d", ap->channel);
 432         av_dict_set(&opts, "channel", buf, 0);
 433     }
 434     if (ap->standard) {
 435         av_dict_set(&opts, "standard", ap->standard, 0);
 436     }
 437     if (ap->mpeg2ts_compute_pcr) {
 438         av_dict_set(&opts, "mpeg2ts_compute_pcr", "1", 0);
 439     }
 440     if (ap->initial_pause) {
 441         av_dict_set(&opts, "initial_pause", "1", 0);
 442     }
 443     return opts;
 444 }
 445
 446 /**
 447  * Open a media file from an IO stream. 'fmt' must be specified.
 448  */
 449 int av_open_input_stream(AVFormatContext **ic_ptr,
 450                          AVIOContext *pb, const char *filename,
 451                          AVInputFormat *fmt, AVFormatParameters *ap)
 452 {
 453     int err;
 454     AVDictionary *opts;
 455     AVFormatContext *ic;
 456     AVFormatParameters default_ap;
 457
 458     if(!ap){
 459         ap=&default_ap;
 460         memset(ap, 0, sizeof(default_ap));
 461     }
 462     opts = convert_format_parameters(ap);
 463
 464     if(!ap->prealloced_context)
 465         ic = avformat_alloc_context();
 466     else
 467         ic = *ic_ptr;
 468     if (!ic) {
 469         err = AVERROR(ENOMEM);
 470         goto fail;
 471     }
 472     if (pb && fmt && fmt->flags & AVFMT_NOFILE)
 473         av_log(ic, AV_LOG_WARNING, "Custom AVIOContext makes no sense and "
 474                                    "will be ignored with AVFMT_NOFILE format.\n");
 475     else
 476         ic->pb = pb;
 477
 478     if ((err = avformat_open_input(&ic, filename, fmt, &opts)) < 0)
 479         goto fail;
 480     ic->pb = ic->pb ? ic->pb : pb; // don't leak custom pb if it wasn't set above
 481
 482 fail:
 483     *ic_ptr = ic;
 484     av_dict_free(&opts);
 485     return err;
 486 }
 487 #endif
 488
 489 /** size of probe buffer, for guessing file type from file contents */
 490 #define PROBE_BUF_MIN 2048
 491 #define PROBE_BUF_MAX (1<<20)
 492
 493 int av_probe_input_buffer(AVIOContext *pb, AVInputFormat **fmt,
 494                           const char *filename, void *logctx,
 495                           unsigned int offset, unsigned int max_probe_size)
 496 {
 497     AVProbeData pd = { filename ? filename : "", NULL, -offset };
 498     unsigned char *buf = NULL;
 499     int ret = 0, probe_size;
 500
 501     if (!max_probe_size) {
 502         max_probe_size = PROBE_BUF_MAX;
 503     } else if (max_probe_size > PROBE_BUF_MAX) {
 504         max_probe_size = PROBE_BUF_MAX;
 505     } else if (max_probe_size < PROBE_BUF_MIN) {
 506         return AVERROR(EINVAL);
 507     }
 508
 509     if (offset >= max_probe_size) {
 510         return AVERROR(EINVAL);
 511     }
 512
 513     for(probe_size= PROBE_BUF_MIN; probe_size<=max_probe_size && !*fmt;
 514         probe_size = FFMIN(probe_size<<1, FFMAX(max_probe_size, probe_size+1))) {
 515         int score = probe_size < max_probe_size ? AVPROBE_SCORE_MAX/4 : 0;
 516         int buf_offset = (probe_size == PROBE_BUF_MIN) ? 0 : probe_size>>1;
 517
 518         if (probe_size < offset) {
 519             continue;
 520         }
 521
 522         /* read probe data */
 523         buf = av_realloc(buf, probe_size + AVPROBE_PADDING_SIZE);
 524         if ((ret = avio_read(pb, buf + buf_offset, probe_size - buf_offset)) < 0) {
 525             /* fail if error was not end of file, otherwise, lower score */
 526             if (ret != AVERROR_EOF) {
 527                 av_free(buf);
 528                 return ret;
 529             }
 530             score = 0;
 531             ret = 0;            /* error was end of file, nothing read */
 532         }
 533         pd.buf_size += ret;
 534         pd.buf = &buf[offset];
 535
 536         memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE);
 537
 538         /* guess file format */
 539         *fmt = av_probe_input_format2(&pd, 1, &score);
 540         if(*fmt){
 541             if(score <= AVPROBE_SCORE_MAX/4){ //this can only be true in the last iteration
 542                 av_log(logctx, AV_LOG_WARNING, "Format detected only with low score of %d, misdetection possible!\n", score);
 543             }else
 544                 av_log(logctx, AV_LOG_DEBUG, "Probed with size=%d and score=%d\n", probe_size, score);
 545         }
 546     }
 547
 548     if (!*fmt) {
 549         av_free(buf);
 550         return AVERROR_INVALIDDATA;
 551     }
 552
 553     /* rewind. reuse probe buffer to avoid seeking */
 554     if ((ret = ffio_rewind_with_probe_data(pb, buf, pd.buf_size)) < 0)
 555         av_free(buf);
 556
 557     return ret;
 558 }
 559
 560 #if FF_API_FORMAT_PARAMETERS
 561 int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
 562                        AVInputFormat *fmt,
 563                        int buf_size,
 564                        AVFormatParameters *ap)
 565 {
 566     int err;
 567     AVDictionary *opts = convert_format_parameters(ap);
 568
 569     if (!ap || !ap->prealloced_context)
 570         *ic_ptr = NULL;
 571
 572     err = avformat_open_input(ic_ptr, filename, fmt, &opts);
 573
 574     av_dict_free(&opts);
 575     return err;
 576 }
 577 #endif
 578
 579 /* open input file and probe the format if necessary */
 580 static int init_input(AVFormatContext *s, const char *filename, AVDictionary **options)
 581 {
 582     int ret;
 583     AVProbeData pd = {filename, NULL, 0};
 584
 585     if (s->pb) {
 586         s->flags |= AVFMT_FLAG_CUSTOM_IO;
 587         if (!s->iformat)
 588             return av_probe_input_buffer(s->pb, &s->iformat, filename, s, 0, 0);
 589         else if (s->iformat->flags & AVFMT_NOFILE)
 590             return AVERROR(EINVAL);
 591         return 0;
 592     }
 593
 594     if ( (s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
 595         (!s->iformat && (s->iformat = av_probe_input_format(&pd, 0))))
 596         return 0;
 597
 598     if ((ret = avio_open2(&s->pb, filename, AVIO_FLAG_READ,
 599                           &s->interrupt_callback, options)) < 0)
 600         return ret;
 601     if (s->iformat)
 602         return 0;
 603     return av_probe_input_buffer(s->pb, &s->iformat, filename, s, 0, 0);
 604 }
 605
 606 int avformat_open_input(AVFormatContext **ps, const char *filename, AVInputFormat *fmt, AVDictionary **options)
 607 {
 608     AVFormatContext *s = *ps;
 609     int ret = 0;
 610     AVFormatParameters ap = { { 0 } };
 611     AVDictionary *tmp = NULL;
 612
 613     if (!s && !(s = avformat_alloc_context()))
 614         return AVERROR(ENOMEM);
 615     if (fmt)
 616         s->iformat = fmt;
 617
 618     if (options)
 619         av_dict_copy(&tmp, *options, 0);
 620
 621     if ((ret = av_opt_set_dict(s, &tmp)) < 0)
 622         goto fail;
 623
 624     if ((ret = init_input(s, filename, &tmp)) < 0)
 625         goto fail;
 626
 627     /* check filename in case an image number is expected */
 628     if (s->iformat->flags & AVFMT_NEEDNUMBER) {
 629         if (!av_filename_number_test(filename)) {
 630             ret = AVERROR(EINVAL);
 631             goto fail;
 632         }
 633     }
 634
 635     s->duration = s->start_time = AV_NOPTS_VALUE;
 636     av_strlcpy(s->filename, filename, sizeof(s->filename));
 637
 638     /* allocate private data */
 639     if (s->iformat->priv_data_size > 0) {
 640         if (!(s->priv_data = av_mallocz(s->iformat->priv_data_size))) {
 641             ret = AVERROR(ENOMEM);
 642             goto fail;
 643         }
 644         if (s->iformat->priv_class) {
 645             *(const AVClass**)s->priv_data = s->iformat->priv_class;
 646             av_opt_set_defaults(s->priv_data);
 647             if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
 648                 goto fail;
 649         }
 650     }
 651
 652     /* e.g. AVFMT_NOFILE formats will not have a AVIOContext */
 653     if (s->pb)
 654         ff_id3v2_read(s, ID3v2_DEFAULT_MAGIC);
 655
 656     if (s->iformat->read_header)
 657         if ((ret = s->iformat->read_header(s, &ap)) < 0)
 658             goto fail;
 659
 660     if (s->pb && !s->data_offset)
 661         s->data_offset = avio_tell(s->pb);
 662
 663     s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
 664
 665     if (options) {
 666         av_dict_free(options);
 667         *options = tmp;
 668     }
 669     *ps = s;
 670     return 0;
 671
 672 fail:
 673     av_dict_free(&tmp);
 674     if (s->pb && !(s->flags & AVFMT_FLAG_CUSTOM_IO))
 675         avio_close(s->pb);
 676     avformat_free_context(s);
 677     *ps = NULL;
 678     return ret;
 679 }
 680
 681 /*******************************************************/
 682
 683 static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
 684                                AVPacketList **plast_pktl){
 685     AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
 686     if (!pktl)
 687         return NULL;
 688
 689     if (*packet_buffer)
 690         (*plast_pktl)->next = pktl;
 691     else
 692         *packet_buffer = pktl;
 693
 694     /* add the packet in the buffered packet list */
 695     *plast_pktl = pktl;
 696     pktl->pkt= *pkt;
 697     return &pktl->pkt;
 698 }
 699
 700 int av_read_packet(AVFormatContext *s, AVPacket *pkt)
 701 {
 702     int ret, i;
 703     AVStream *st;
 704
 705     for(;;){
 706         AVPacketList *pktl = s->raw_packet_buffer;
 707
 708         if (pktl) {
 709             *pkt = pktl->pkt;
 710             if(s->streams[pkt->stream_index]->codec->codec_id != CODEC_ID_PROBE ||
 711                !s->streams[pkt->stream_index]->probe_packets ||
 712                s->raw_packet_buffer_remaining_size < pkt->size){
 713                 AVProbeData *pd = &s->streams[pkt->stream_index]->probe_data;
 714                 av_freep(&pd->buf);
 715                 pd->buf_size = 0;
 716                 s->raw_packet_buffer = pktl->next;
 717                 s->raw_packet_buffer_remaining_size += pkt->size;
 718                 av_free(pktl);
 719                 return 0;
 720             }
 721         }
 722
 723         av_init_packet(pkt);
 724         ret= s->iformat->read_packet(s, pkt);
 725         if (ret < 0) {
 726             if (!pktl || ret == AVERROR(EAGAIN))
 727                 return ret;
 728             for (i = 0; i < s->nb_streams; i++)
 729                 s->streams[i]->probe_packets = 0;
 730             continue;
 731         }
 732
 733         if ((s->flags & AVFMT_FLAG_DISCARD_CORRUPT) &&
 734             (pkt->flags & AV_PKT_FLAG_CORRUPT)) {
 735             av_log(s, AV_LOG_WARNING,
 736                    "Dropped corrupted packet (stream = %d)\n",
 737                    pkt->stream_index);
 738             av_free_packet(pkt);
 739             continue;
 740         }
 741
 742         st= s->streams[pkt->stream_index];
 743
 744         switch(st->codec->codec_type){
 745         case AVMEDIA_TYPE_VIDEO:
 746             if(s->video_codec_id)   st->codec->codec_id= s->video_codec_id;
 747             break;
 748         case AVMEDIA_TYPE_AUDIO:
 749             if(s->audio_codec_id)   st->codec->codec_id= s->audio_codec_id;
 750             break;
 751         case AVMEDIA_TYPE_SUBTITLE:
 752             if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
 753             break;
 754         }
 755
 756         if(!pktl && (st->codec->codec_id != CODEC_ID_PROBE ||
 757                      !st->probe_packets))
 758             return ret;
 759
 760         add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
 761         s->raw_packet_buffer_remaining_size -= pkt->size;
 762
 763         if(st->codec->codec_id == CODEC_ID_PROBE){
 764             AVProbeData *pd = &st->probe_data;
 765             av_log(s, AV_LOG_DEBUG, "probing stream %d\n", st->index);
 766             --st->probe_packets;
 767
 768             pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
 769             memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
 770             pd->buf_size += pkt->size;
 771             memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
 772
 773             if(av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)){
 774                 //FIXME we do not reduce score to 0 for the case of running out of buffer space in bytes
 775                 set_codec_from_probe_data(s, st, pd, st->probe_packets > 0 ? AVPROBE_SCORE_MAX/4 : 0);
 776                 if(st->codec->codec_id != CODEC_ID_PROBE){
 777                     pd->buf_size=0;
 778                     av_freep(&pd->buf);
 779                     av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
 780                 }
 781             }
 782         }
 783     }
 784 }
 785
 786 /**********************************************************/
 787
 788 /**
 789  * Get the number of samples of an audio frame. Return -1 on error.
 790  */
 791 static int get_audio_frame_size(AVCodecContext *enc, int size)
 792 {
 793     int frame_size;
 794
 795     if(enc->codec_id == CODEC_ID_VORBIS)
 796         return -1;
 797
 798     if (enc->frame_size <= 1) {
 799         int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
 800
 801         if (bits_per_sample) {
 802             if (enc->channels == 0)
 803                 return -1;
 804             frame_size = (size << 3) / (bits_per_sample * enc->channels);
 805         } else {
 806             /* used for example by ADPCM codecs */
 807             if (enc->bit_rate == 0)
 808                 return -1;
 809             frame_size = ((int64_t)size * 8 * enc->sample_rate) / enc->bit_rate;
 810         }
 811     } else {
 812         frame_size = enc->frame_size;
 813     }
 814     return frame_size;
 815 }
 816
 817
 818 /**
 819  * Return the frame duration in seconds. Return 0 if not available.
 820  */
 821 static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
 822                                    AVCodecParserContext *pc, AVPacket *pkt)
 823 {
 824     int frame_size;
 825
 826     *pnum = 0;
 827     *pden = 0;
 828     switch(st->codec->codec_type) {
 829     case AVMEDIA_TYPE_VIDEO:
 830         if (st->r_frame_rate.num) {
 831             *pnum = st->r_frame_rate.den;
 832             *pden = st->r_frame_rate.num;
 833         } else if(st->time_base.num*1000LL > st->time_base.den) {
 834             *pnum = st->time_base.num;
 835             *pden = st->time_base.den;
 836         }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
 837             *pnum = st->codec->time_base.num;
 838             *pden = st->codec->time_base.den;
 839             if (pc && pc->repeat_pict) {
 840                 *pnum = (*pnum) * (1 + pc->repeat_pict);
 841             }
 842             //If this codec can be interlaced or progressive then we need a parser to compute duration of a packet
 843             //Thus if we have no parser in such case leave duration undefined.
 844             if(st->codec->ticks_per_frame>1 && !pc){
 845                 *pnum = *pden = 0;
 846             }
 847         }
 848         break;
 849     case AVMEDIA_TYPE_AUDIO:
 850         frame_size = get_audio_frame_size(st->codec, pkt->size);
 851         if (frame_size <= 0 || st->codec->sample_rate <= 0)
 852             break;
 853         *pnum = frame_size;
 854         *pden = st->codec->sample_rate;
 855         break;
 856     default:
 857         break;
 858     }
 859 }
 860
 861 static int is_intra_only(AVCodecContext *enc){
 862     if(enc->codec_type == AVMEDIA_TYPE_AUDIO){
 863         return 1;
 864     }else if(enc->codec_type == AVMEDIA_TYPE_VIDEO){
 865         switch(enc->codec_id){
 866         case CODEC_ID_MJPEG:
 867         case CODEC_ID_MJPEGB:
 868         case CODEC_ID_LJPEG:
 869         case CODEC_ID_PRORES:
 870         case CODEC_ID_RAWVIDEO:
 871         case CODEC_ID_DVVIDEO:
 872         case CODEC_ID_HUFFYUV:
 873         case CODEC_ID_FFVHUFF:
 874         case CODEC_ID_ASV1:
 875         case CODEC_ID_ASV2:
 876         case CODEC_ID_VCR1:
 877         case CODEC_ID_DNXHD:
 878         case CODEC_ID_JPEG2000:
 879             return 1;
 880         default: break;
 881         }
 882     }
 883     return 0;
 884 }
 885
 886 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
 887                                       int64_t dts, int64_t pts)
 888 {
 889     AVStream *st= s->streams[stream_index];
 890     AVPacketList *pktl= s->packet_buffer;
 891
 892     if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE)
 893         return;
 894
 895     st->first_dts= dts - st->cur_dts;
 896     st->cur_dts= dts;
 897
 898     for(; pktl; pktl= pktl->next){
 899         if(pktl->pkt.stream_index != stream_index)
 900             continue;
 901         //FIXME think more about this check
 902         if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
 903             pktl->pkt.pts += st->first_dts;
 904
 905         if(pktl->pkt.dts != AV_NOPTS_VALUE)
 906             pktl->pkt.dts += st->first_dts;
 907
 908         if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
 909             st->start_time= pktl->pkt.pts;
 910     }
 911     if (st->start_time == AV_NOPTS_VALUE)
 912         st->start_time = pts;
 913 }
 914
 915 static void update_initial_durations(AVFormatContext *s, AVStream *st, AVPacket *pkt)
 916 {
 917     AVPacketList *pktl= s->packet_buffer;
 918     int64_t cur_dts= 0;
 919
 920     if(st->first_dts != AV_NOPTS_VALUE){
 921         cur_dts= st->first_dts;
 922         for(; pktl; pktl= pktl->next){
 923             if(pktl->pkt.stream_index == pkt->stream_index){
 924                 if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
 925                     break;
 926                 cur_dts -= pkt->duration;
 927             }
 928         }
 929         pktl= s->packet_buffer;
 930         st->first_dts = cur_dts;
 931     }else if(st->cur_dts)
 932         return;
 933
 934     for(; pktl; pktl= pktl->next){
 935         if(pktl->pkt.stream_index != pkt->stream_index)
 936             continue;
 937         if(pktl->pkt.pts == pktl->pkt.dts && pktl->pkt.dts == AV_NOPTS_VALUE
 938            && !pktl->pkt.duration){
 939             pktl->pkt.dts= cur_dts;
 940             if(!st->codec->has_b_frames)
 941                 pktl->pkt.pts= cur_dts;
 942             cur_dts += pkt->duration;
 943             pktl->pkt.duration= pkt->duration;
 944         }else
 945             break;
 946     }
 947     if(st->first_dts == AV_NOPTS_VALUE)
 948         st->cur_dts= cur_dts;
 949 }
 950
 951 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
 952                                AVCodecParserContext *pc, AVPacket *pkt)
 953 {
 954     int num, den, presentation_delayed, delay, i;
 955     int64_t offset;
 956
 957     if (s->flags & AVFMT_FLAG_NOFILLIN)
 958         return;
 959
 960     if((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
 961         pkt->dts= AV_NOPTS_VALUE;
 962
 963     if (st->codec->codec_id != CODEC_ID_H264 && pc && pc->pict_type == AV_PICTURE_TYPE_B)
 964         //FIXME Set low_delay = 0 when has_b_frames = 1
 965         st->codec->has_b_frames = 1;
 966
 967     /* do we have a video B-frame ? */
 968     delay= st->codec->has_b_frames;
 969     presentation_delayed = 0;
 970
 971     /* XXX: need has_b_frame, but cannot get it if the codec is
 972         not initialized */
 973     if (delay &&
 974         pc && pc->pict_type != AV_PICTURE_TYPE_B)
 975         presentation_delayed = 1;
 976
 977     if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
 978        /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
 979         pkt->dts -= 1LL<<st->pts_wrap_bits;
 980     }
 981
 982     // some mpeg2 in mpeg-ps lack dts (issue171 / input_file.mpg)
 983     // we take the conservative approach and discard both
 984     // Note, if this is misbehaving for a H.264 file then possibly presentation_delayed is not set correctly.
 985     if(delay==1 && pkt->dts == pkt->pts && pkt->dts != AV_NOPTS_VALUE && presentation_delayed){
 986         av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination\n");
 987         pkt->dts= pkt->pts= AV_NOPTS_VALUE;
 988     }
 989
 990     if (pkt->duration == 0) {
 991         compute_frame_duration(&num, &den, st, pc, pkt);
 992         if (den && num) {
 993             pkt->duration = av_rescale_rnd(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num, AV_ROUND_DOWN);
 994
 995             if(pkt->duration != 0 && s->packet_buffer)
 996                 update_initial_durations(s, st, pkt);
 997         }
 998     }
 999
1000     /* correct timestamps with byte offset if demuxers only have timestamps
1001        on packet boundaries */
1002     if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
1003         /* this will estimate bitrate based on this frame's duration and size */
1004         offset = av_rescale(pc->offset, pkt->duration, pkt->size);
1005         if(pkt->pts != AV_NOPTS_VALUE)
1006             pkt->pts += offset;
1007         if(pkt->dts != AV_NOPTS_VALUE)
1008             pkt->dts += offset;
1009     }
1010
1011     if (pc && pc->dts_sync_point >= 0) {
1012         // we have synchronization info from the parser
1013         int64_t den = st->codec->time_base.den * (int64_t) st->time_base.num;
1014         if (den > 0) {
1015             int64_t num = st->codec->time_base.num * (int64_t) st->time_base.den;
1016             if (pkt->dts != AV_NOPTS_VALUE) {
1017                 // got DTS from the stream, update reference timestamp
1018                 st->reference_dts = pkt->dts - pc->dts_ref_dts_delta * num / den;
1019                 pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
1020             } else if (st->reference_dts != AV_NOPTS_VALUE) {
1021                 // compute DTS based on reference timestamp
1022                 pkt->dts = st->reference_dts + pc->dts_ref_dts_delta * num / den;
1023                 pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
1024             }
1025             if (pc->dts_sync_point > 0)
1026                 st->reference_dts = pkt->dts; // new reference
1027         }
1028     }
1029
1030     /* This may be redundant, but it should not hurt. */
1031     if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
1032         presentation_delayed = 1;
1033
1034 //    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);
1035     /* interpolate PTS and DTS if they are not present */
1036     //We skip H264 currently because delay and has_b_frames are not reliably set
1037     if((delay==0 || (delay==1 && pc)) && st->codec->codec_id != CODEC_ID_H264){
1038         if (presentation_delayed) {
1039             /* DTS = decompression timestamp */
1040             /* PTS = presentation timestamp */
1041             if (pkt->dts == AV_NOPTS_VALUE)
1042                 pkt->dts = st->last_IP_pts;
1043             update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
1044             if (pkt->dts == AV_NOPTS_VALUE)
1045                 pkt->dts = st->cur_dts;
1046
1047             /* this is tricky: the dts must be incremented by the duration
1048             of the frame we are displaying, i.e. the last I- or P-frame */
1049             if (st->last_IP_duration == 0)
1050                 st->last_IP_duration = pkt->duration;
1051             if(pkt->dts != AV_NOPTS_VALUE)
1052                 st->cur_dts = pkt->dts + st->last_IP_duration;
1053             st->last_IP_duration  = pkt->duration;
1054             st->last_IP_pts= pkt->pts;
1055             /* cannot compute PTS if not present (we can compute it only
1056             by knowing the future */
1057         } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
1058             if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
1059                 int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
1060                 int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
1061                 if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
1062                     pkt->pts += pkt->duration;
1063     //                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);
1064                 }
1065             }
1066
1067             /* presentation is not delayed : PTS and DTS are the same */
1068             if(pkt->pts == AV_NOPTS_VALUE)
1069                 pkt->pts = pkt->dts;
1070             update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
1071             if(pkt->pts == AV_NOPTS_VALUE)
1072                 pkt->pts = st->cur_dts;
1073             pkt->dts = pkt->pts;
1074             if(pkt->pts != AV_NOPTS_VALUE)
1075                 st->cur_dts = pkt->pts + pkt->duration;
1076         }
1077     }
1078
1079     if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
1080         st->pts_buffer[0]= pkt->pts;
1081         for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
1082             FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
1083         if(pkt->dts == AV_NOPTS_VALUE)
1084             pkt->dts= st->pts_buffer[0];
1085         if(st->codec->codec_id == CODEC_ID_H264){ // we skipped it above so we try here
1086             update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
1087         }
1088         if(pkt->dts > st->cur_dts)
1089             st->cur_dts = pkt->dts;
1090     }
1091
1092 //    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);
1093
1094     /* update flags */
1095     if(is_intra_only(st->codec))
1096         pkt->flags |= AV_PKT_FLAG_KEY;
1097     else if (pc) {
1098         pkt->flags = 0;
1099         /* keyframe computation */
1100         if (pc->key_frame == 1)
1101             pkt->flags |= AV_PKT_FLAG_KEY;
1102         else if (pc->key_frame == -1 && pc->pict_type == AV_PICTURE_TYPE_I)
1103             pkt->flags |= AV_PKT_FLAG_KEY;
1104     }
1105     if (pc)
1106         pkt->convergence_duration = pc->convergence_duration;
1107 }
1108
1109
1110 static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1111 {
1112     AVStream *st;
1113     int len, ret, i;
1114
1115     av_init_packet(pkt);
1116
1117     for(;;) {
1118         /* select current input stream component */
1119         st = s->cur_st;
1120         if (st) {
1121             if (!st->need_parsing || !st->parser) {
1122                 /* no parsing needed: we just output the packet as is */
1123                 /* raw data support */
1124                 *pkt = st->cur_pkt; st->cur_pkt.data= NULL;
1125                 compute_pkt_fields(s, st, NULL, pkt);
1126                 s->cur_st = NULL;
1127                 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1128                     (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1129                     ff_reduce_index(s, st->index);
1130                     av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1131                 }
1132                 break;
1133             } else if (st->cur_len > 0 && st->discard < AVDISCARD_ALL) {
1134                 len = av_parser_parse2(st->parser, st->codec, &pkt->data, &pkt->size,
1135                                        st->cur_ptr, st->cur_len,
1136                                        st->cur_pkt.pts, st->cur_pkt.dts,
1137                                        st->cur_pkt.pos);
1138                 st->cur_pkt.pts = AV_NOPTS_VALUE;
1139                 st->cur_pkt.dts = AV_NOPTS_VALUE;
1140                 /* increment read pointer */
1141                 st->cur_ptr += len;
1142                 st->cur_len -= len;
1143
1144                 /* return packet if any */
1145                 if (pkt->size) {
1146                 got_packet:
1147                     pkt->duration = 0;
1148                     pkt->stream_index = st->index;
1149                     pkt->pts = st->parser->pts;
1150                     pkt->dts = st->parser->dts;
1151                     pkt->pos = st->parser->pos;
1152                     if(pkt->data == st->cur_pkt.data && pkt->size == st->cur_pkt.size){
1153                         s->cur_st = NULL;
1154                         pkt->destruct= st->cur_pkt.destruct;
1155                         st->cur_pkt.destruct= NULL;
1156                         st->cur_pkt.data    = NULL;
1157                         assert(st->cur_len == 0);
1158                     }else{
1159                         pkt->destruct = NULL;
1160                     }
1161                     compute_pkt_fields(s, st, st->parser, pkt);
1162
1163                     if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY){
1164                         ff_reduce_index(s, st->index);
1165                         av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
1166                                            0, 0, AVINDEX_KEYFRAME);
1167                     }
1168
1169                     break;
1170                 }
1171             } else {
1172                 /* free packet */
1173                 av_free_packet(&st->cur_pkt);
1174                 s->cur_st = NULL;
1175             }
1176         } else {
1177             AVPacket cur_pkt;
1178             /* read next packet */
1179             ret = av_read_packet(s, &cur_pkt);
1180             if (ret < 0) {
1181                 if (ret == AVERROR(EAGAIN))
1182                     return ret;
1183                 /* return the last frames, if any */
1184                 for(i = 0; i < s->nb_streams; i++) {
1185                     st = s->streams[i];
1186                     if (st->parser && st->need_parsing) {
1187                         av_parser_parse2(st->parser, st->codec,
1188                                         &pkt->data, &pkt->size,
1189                                         NULL, 0,
1190                                         AV_NOPTS_VALUE, AV_NOPTS_VALUE,
1191                                         AV_NOPTS_VALUE);
1192                         if (pkt->size)
1193                             goto got_packet;
1194                     }
1195                 }
1196                 /* no more packets: really terminate parsing */
1197                 return ret;
1198             }
1199             st = s->streams[cur_pkt.stream_index];
1200             st->cur_pkt= cur_pkt;
1201
1202             if(st->cur_pkt.pts != AV_NOPTS_VALUE &&
1203                st->cur_pkt.dts != AV_NOPTS_VALUE &&
1204                st->cur_pkt.pts < st->cur_pkt.dts){
1205                 av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
1206                     st->cur_pkt.stream_index,
1207                     st->cur_pkt.pts,
1208                     st->cur_pkt.dts,
1209                     st->cur_pkt.size);
1210 //                av_free_packet(&st->cur_pkt);
1211 //                return -1;
1212             }
1213
1214             if(s->debug & FF_FDEBUG_TS)
1215                 av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1216                     st->cur_pkt.stream_index,
1217                     st->cur_pkt.pts,
1218                     st->cur_pkt.dts,
1219                     st->cur_pkt.size,
1220                     st->cur_pkt.duration,
1221                     st->cur_pkt.flags);
1222
1223             s->cur_st = st;
1224             st->cur_ptr = st->cur_pkt.data;
1225             st->cur_len = st->cur_pkt.size;
1226             if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1227                 st->parser = av_parser_init(st->codec->codec_id);
1228                 if (!st->parser) {
1229                     /* no parser available: just output the raw packets */
1230                     st->need_parsing = AVSTREAM_PARSE_NONE;
1231                 }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
1232                     st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1233                 }else if(st->need_parsing == AVSTREAM_PARSE_FULL_ONCE){
1234                     st->parser->flags |= PARSER_FLAG_ONCE;
1235                 }
1236             }
1237         }
1238     }
1239     if(s->debug & FF_FDEBUG_TS)
1240         av_log(s, AV_LOG_DEBUG, "read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1241             pkt->stream_index,
1242             pkt->pts,
1243             pkt->dts,
1244             pkt->size,
1245             pkt->duration,
1246             pkt->flags);
1247
1248     return 0;
1249 }
1250
1251 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1252 {
1253     AVPacketList *pktl;
1254     int eof=0;
1255     const int genpts= s->flags & AVFMT_FLAG_GENPTS;
1256
1257     for(;;){
1258         pktl = s->packet_buffer;
1259         if (pktl) {
1260             AVPacket *next_pkt= &pktl->pkt;
1261
1262             if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
1263                 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1264                 while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
1265                     if(   pktl->pkt.stream_index == next_pkt->stream_index
1266                        && (0 > av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)))
1267                        && av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) { //not b frame
1268                         next_pkt->pts= pktl->pkt.dts;
1269                     }
1270                     pktl= pktl->next;
1271                 }
1272                 pktl = s->packet_buffer;
1273             }
1274
1275             if(   next_pkt->pts != AV_NOPTS_VALUE
1276                || next_pkt->dts == AV_NOPTS_VALUE
1277                || !genpts || eof){
1278                 /* read packet from packet buffer, if there is data */
1279                 *pkt = *next_pkt;
1280                 s->packet_buffer = pktl->next;
1281                 av_free(pktl);
1282                 return 0;
1283             }
1284         }
1285         if(genpts){
1286             int ret= read_frame_internal(s, pkt);
1287             if(ret<0){
1288                 if(pktl && ret != AVERROR(EAGAIN)){
1289                     eof=1;
1290                     continue;
1291                 }else
1292                     return ret;
1293             }
1294
1295             if(av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1296                                            &s->packet_buffer_end)) < 0)
1297                 return AVERROR(ENOMEM);
1298         }else{
1299             assert(!s->packet_buffer);
1300             return read_frame_internal(s, pkt);
1301         }
1302     }
1303 }
1304
1305 /* XXX: suppress the packet queue */
1306 static void flush_packet_queue(AVFormatContext *s)
1307 {
1308     AVPacketList *pktl;
1309
1310     for(;;) {
1311         pktl = s->packet_buffer;
1312         if (!pktl)
1313             break;
1314         s->packet_buffer = pktl->next;
1315         av_free_packet(&pktl->pkt);
1316         av_free(pktl);
1317     }
1318     while(s->raw_packet_buffer){
1319         pktl = s->raw_packet_buffer;
1320         s->raw_packet_buffer = pktl->next;
1321         av_free_packet(&pktl->pkt);
1322         av_free(pktl);
1323     }
1324     s->packet_buffer_end=
1325     s->raw_packet_buffer_end= NULL;
1326     s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1327 }
1328
1329 /*******************************************************/
1330 /* seek support */
1331
1332 int av_find_default_stream_index(AVFormatContext *s)
1333 {
1334     int first_audio_index = -1;
1335     int i;
1336     AVStream *st;
1337
1338     if (s->nb_streams <= 0)
1339         return -1;
1340     for(i = 0; i < s->nb_streams; i++) {
1341         st = s->streams[i];
1342         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1343             return i;
1344         }
1345         if (first_audio_index < 0 && st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1346             first_audio_index = i;
1347     }
1348     return first_audio_index >= 0 ? first_audio_index : 0;
1349 }
1350
1351 /**
1352  * Flush the frame reader.
1353  */
1354 void ff_read_frame_flush(AVFormatContext *s)
1355 {
1356     AVStream *st;
1357     int i, j;
1358
1359     flush_packet_queue(s);
1360
1361     s->cur_st = NULL;
1362
1363     /* for each stream, reset read state */
1364     for(i = 0; i < s->nb_streams; i++) {
1365         st = s->streams[i];
1366
1367         if (st->parser) {
1368             av_parser_close(st->parser);
1369             st->parser = NULL;
1370             av_free_packet(&st->cur_pkt);
1371         }
1372         st->last_IP_pts = AV_NOPTS_VALUE;
1373         st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1374         st->reference_dts = AV_NOPTS_VALUE;
1375         /* fail safe */
1376         st->cur_ptr = NULL;
1377         st->cur_len = 0;
1378
1379         st->probe_packets = MAX_PROBE_PACKETS;
1380
1381         for(j=0; j<MAX_REORDER_DELAY+1; j++)
1382             st->pts_buffer[j]= AV_NOPTS_VALUE;
1383     }
1384 }
1385
1386 #if FF_API_SEEK_PUBLIC
1387 void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1388 {
1389     ff_update_cur_dts(s, ref_st, timestamp);
1390 }
1391 #endif
1392
1393 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1394 {
1395     int i;
1396
1397     for(i = 0; i < s->nb_streams; i++) {
1398         AVStream *st = s->streams[i];
1399
1400         st->cur_dts = av_rescale(timestamp,
1401                                  st->time_base.den * (int64_t)ref_st->time_base.num,
1402                                  st->time_base.num * (int64_t)ref_st->time_base.den);
1403     }
1404 }
1405
1406 void ff_reduce_index(AVFormatContext *s, int stream_index)
1407 {
1408     AVStream *st= s->streams[stream_index];
1409     unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1410
1411     if((unsigned)st->nb_index_entries >= max_entries){
1412         int i;
1413         for(i=0; 2*i<st->nb_index_entries; i++)
1414             st->index_entries[i]= st->index_entries[2*i];
1415         st->nb_index_entries= i;
1416     }
1417 }
1418
1419 int ff_add_index_entry(AVIndexEntry **index_entries,
1420                        int *nb_index_entries,
1421                        unsigned int *index_entries_allocated_size,
1422                        int64_t pos, int64_t timestamp, int size, int distance, int flags)
1423 {
1424     AVIndexEntry *entries, *ie;
1425     int index;
1426
1427     if((unsigned)*nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1428         return -1;
1429
1430     entries = av_fast_realloc(*index_entries,
1431                               index_entries_allocated_size,
1432                               (*nb_index_entries + 1) *
1433                               sizeof(AVIndexEntry));
1434     if(!entries)
1435         return -1;
1436
1437     *index_entries= entries;
1438
1439     index= ff_index_search_timestamp(*index_entries, *nb_index_entries, timestamp, AVSEEK_FLAG_ANY);
1440
1441     if(index<0){
1442         index= (*nb_index_entries)++;
1443         ie= &entries[index];
1444         assert(index==0 || ie[-1].timestamp < timestamp);
1445     }else{
1446         ie= &entries[index];
1447         if(ie->timestamp != timestamp){
1448             if(ie->timestamp <= timestamp)
1449                 return -1;
1450             memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(*nb_index_entries - index));
1451             (*nb_index_entries)++;
1452         }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1453             distance= ie->min_distance;
1454     }
1455
1456     ie->pos = pos;
1457     ie->timestamp = timestamp;
1458     ie->min_distance= distance;
1459     ie->size= size;
1460     ie->flags = flags;
1461
1462     return index;
1463 }
1464
1465 int av_add_index_entry(AVStream *st,
1466                        int64_t pos, int64_t timestamp, int size, int distance, int flags)
1467 {
1468     return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1469                               &st->index_entries_allocated_size, pos,
1470                               timestamp, size, distance, flags);
1471 }
1472
1473 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1474                               int64_t wanted_timestamp, int flags)
1475 {
1476     int a, b, m;
1477     int64_t timestamp;
1478
1479     a = - 1;
1480     b = nb_entries;
1481
1482     //optimize appending index entries at the end
1483     if(b && entries[b-1].timestamp < wanted_timestamp)
1484         a= b-1;
1485
1486     while (b - a > 1) {
1487         m = (a + b) >> 1;
1488         timestamp = entries[m].timestamp;
1489         if(timestamp >= wanted_timestamp)
1490             b = m;
1491         if(timestamp <= wanted_timestamp)
1492             a = m;
1493     }
1494     m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1495
1496     if(!(flags & AVSEEK_FLAG_ANY)){
1497         while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1498             m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1499         }
1500     }
1501
1502     if(m == nb_entries)
1503         return -1;
1504     return  m;
1505 }
1506
1507 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1508                               int flags)
1509 {
1510     return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
1511                                      wanted_timestamp, flags);
1512 }
1513
1514 #if FF_API_SEEK_PUBLIC
1515 int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1516     return ff_seek_frame_binary(s, stream_index, target_ts, flags);
1517 }
1518 #endif
1519
1520 int ff_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags)
1521 {
1522     AVInputFormat *avif= s->iformat;
1523     int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1524     int64_t ts_min, ts_max, ts;
1525     int index;
1526     int64_t ret;
1527     AVStream *st;
1528
1529     if (stream_index < 0)
1530         return -1;
1531
1532     av_dlog(s, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1533
1534     ts_max=
1535     ts_min= AV_NOPTS_VALUE;
1536     pos_limit= -1; //gcc falsely says it may be uninitialized
1537
1538     st= s->streams[stream_index];
1539     if(st->index_entries){
1540         AVIndexEntry *e;
1541
1542         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()
1543         index= FFMAX(index, 0);
1544         e= &st->index_entries[index];
1545
1546         if(e->timestamp <= target_ts || e->pos == e->min_distance){
1547             pos_min= e->pos;
1548             ts_min= e->timestamp;
1549             av_dlog(s, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1550                     pos_min,ts_min);
1551         }else{
1552             assert(index==0);
1553         }
1554
1555         index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1556         assert(index < st->nb_index_entries);
1557         if(index >= 0){
1558             e= &st->index_entries[index];
1559             assert(e->timestamp >= target_ts);
1560             pos_max= e->pos;
1561             ts_max= e->timestamp;
1562             pos_limit= pos_max - e->min_distance;
1563             av_dlog(s, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1564                     pos_max,pos_limit, ts_max);
1565         }
1566     }
1567
1568     pos= ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1569     if(pos<0)
1570         return -1;
1571
1572     /* do the seek */
1573     if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
1574         return ret;
1575
1576     ff_update_cur_dts(s, st, ts);
1577
1578     return 0;
1579 }
1580
1581 #if FF_API_SEEK_PUBLIC
1582 int64_t av_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
1583                       int64_t pos_min, int64_t pos_max, int64_t pos_limit,
1584                       int64_t ts_min, int64_t ts_max, int flags, int64_t *ts_ret,
1585                       int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1586 {
1587     return ff_gen_search(s, stream_index, target_ts, pos_min, pos_max,
1588                          pos_limit, ts_min, ts_max, flags, ts_ret,
1589                          read_timestamp);
1590 }
1591 #endif
1592
1593 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
1594                       int64_t pos_min, int64_t pos_max, int64_t pos_limit,
1595                       int64_t ts_min, int64_t ts_max, int flags, int64_t *ts_ret,
1596                       int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1597 {
1598     int64_t pos, ts;
1599     int64_t start_pos, filesize;
1600     int no_change;
1601
1602     av_dlog(s, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1603
1604     if(ts_min == AV_NOPTS_VALUE){
1605         pos_min = s->data_offset;
1606         ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1607         if (ts_min == AV_NOPTS_VALUE)
1608             return -1;
1609     }
1610
1611     if(ts_max == AV_NOPTS_VALUE){
1612         int step= 1024;
1613         filesize = avio_size(s->pb);
1614         pos_max = filesize - 1;
1615         do{
1616             pos_max -= step;
1617             ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1618             step += step;
1619         }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1620         if (ts_max == AV_NOPTS_VALUE)
1621             return -1;
1622
1623         for(;;){
1624             int64_t tmp_pos= pos_max + 1;
1625             int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1626             if(tmp_ts == AV_NOPTS_VALUE)
1627                 break;
1628             ts_max= tmp_ts;
1629             pos_max= tmp_pos;
1630             if(tmp_pos >= filesize)
1631                 break;
1632         }
1633         pos_limit= pos_max;
1634     }
1635
1636     if(ts_min > ts_max){
1637         return -1;
1638     }else if(ts_min == ts_max){
1639         pos_limit= pos_min;
1640     }
1641
1642     no_change=0;
1643     while (pos_min < pos_limit) {
1644         av_dlog(s, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1645                 pos_min, pos_max, ts_min, ts_max);
1646         assert(pos_limit <= pos_max);
1647
1648         if(no_change==0){
1649             int64_t approximate_keyframe_distance= pos_max - pos_limit;
1650             // interpolate position (better than dichotomy)
1651             pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1652                 + pos_min - approximate_keyframe_distance;
1653         }else if(no_change==1){
1654             // bisection, if interpolation failed to change min or max pos last time
1655             pos = (pos_min + pos_limit)>>1;
1656         }else{
1657             /* linear search if bisection failed, can only happen if there
1658                are very few or no keyframes between min/max */
1659             pos=pos_min;
1660         }
1661         if(pos <= pos_min)
1662             pos= pos_min + 1;
1663         else if(pos > pos_limit)
1664             pos= pos_limit;
1665         start_pos= pos;
1666
1667         ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1668         if(pos == pos_max)
1669             no_change++;
1670         else
1671             no_change=0;
1672         av_dlog(s, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64" target:%"PRId64" limit:%"PRId64" start:%"PRId64" noc:%d\n",
1673                 pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts,
1674                 pos_limit, start_pos, no_change);
1675         if(ts == AV_NOPTS_VALUE){
1676             av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1677             return -1;
1678         }
1679         assert(ts != AV_NOPTS_VALUE);
1680         if (target_ts <= ts) {
1681             pos_limit = start_pos - 1;
1682             pos_max = pos;
1683             ts_max = ts;
1684         }
1685         if (target_ts >= ts) {
1686             pos_min = pos;
1687             ts_min = ts;
1688         }
1689     }
1690
1691     pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1692     ts  = (flags & AVSEEK_FLAG_BACKWARD) ?  ts_min :  ts_max;
1693     pos_min = pos;
1694     ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1695     pos_min++;
1696     ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1697     av_dlog(s, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1698             pos, ts_min, target_ts, ts_max);
1699     *ts_ret= ts;
1700     return pos;
1701 }
1702
1703 static int seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1704     int64_t pos_min, pos_max;
1705 #if 0
1706     AVStream *st;
1707
1708     if (stream_index < 0)
1709         return -1;
1710
1711     st= s->streams[stream_index];
1712 #endif
1713
1714     pos_min = s->data_offset;
1715     pos_max = avio_size(s->pb) - 1;
1716
1717     if     (pos < pos_min) pos= pos_min;
1718     else if(pos > pos_max) pos= pos_max;
1719
1720     avio_seek(s->pb, pos, SEEK_SET);
1721
1722 #if 0
1723     av_update_cur_dts(s, st, ts);
1724 #endif
1725     return 0;
1726 }
1727
1728 static int seek_frame_generic(AVFormatContext *s,
1729                                  int stream_index, int64_t timestamp, int flags)
1730 {
1731     int index;
1732     int64_t ret;
1733     AVStream *st;
1734     AVIndexEntry *ie;
1735
1736     st = s->streams[stream_index];
1737
1738     index = av_index_search_timestamp(st, timestamp, flags);
1739
1740     if(index < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
1741         return -1;
1742
1743     if(index < 0 || index==st->nb_index_entries-1){
1744         AVPacket pkt;
1745
1746         if(st->nb_index_entries){
1747             assert(st->index_entries);
1748             ie= &st->index_entries[st->nb_index_entries-1];
1749             if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1750                 return ret;
1751             ff_update_cur_dts(s, st, ie->timestamp);
1752         }else{
1753             if ((ret = avio_seek(s->pb, s->data_offset, SEEK_SET)) < 0)
1754                 return ret;
1755         }
1756         for (;;) {
1757             int read_status;
1758             do{
1759                 read_status = av_read_frame(s, &pkt);
1760             } while (read_status == AVERROR(EAGAIN));
1761             if (read_status < 0)
1762                 break;
1763             av_free_packet(&pkt);
1764             if(stream_index == pkt.stream_index){
1765                 if((pkt.flags & AV_PKT_FLAG_KEY) && pkt.dts > timestamp)
1766                     break;
1767             }
1768         }
1769         index = av_index_search_timestamp(st, timestamp, flags);
1770     }
1771     if (index < 0)
1772         return -1;
1773
1774     ff_read_frame_flush(s);
1775     if (s->iformat->read_seek){
1776         if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1777             return 0;
1778     }
1779     ie = &st->index_entries[index];
1780     if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1781         return ret;
1782     ff_update_cur_dts(s, st, ie->timestamp);
1783
1784     return 0;
1785 }
1786
1787 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1788 {
1789     int ret;
1790     AVStream *st;
1791
1792     if (flags & AVSEEK_FLAG_BYTE) {
1793         if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
1794             return -1;
1795         ff_read_frame_flush(s);
1796         return seek_frame_byte(s, stream_index, timestamp, flags);
1797     }
1798
1799     if(stream_index < 0){
1800         stream_index= av_find_default_stream_index(s);
1801         if(stream_index < 0)
1802             return -1;
1803
1804         st= s->streams[stream_index];
1805         /* timestamp for default must be expressed in AV_TIME_BASE units */
1806         timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1807     }
1808
1809     /* first, we try the format specific seek */
1810     if (s->iformat->read_seek) {
1811         ff_read_frame_flush(s);
1812         ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1813     } else
1814         ret = -1;
1815     if (ret >= 0) {
1816         return 0;
1817     }
1818
1819     if (s->iformat->read_timestamp && !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
1820         ff_read_frame_flush(s);
1821         return ff_seek_frame_binary(s, stream_index, timestamp, flags);
1822     } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
1823         ff_read_frame_flush(s);
1824         return seek_frame_generic(s, stream_index, timestamp, flags);
1825     }
1826     else
1827         return -1;
1828 }
1829
1830 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
1831 {
1832     if(min_ts > ts || max_ts < ts)
1833         return -1;
1834
1835     if (s->iformat->read_seek2) {
1836         ff_read_frame_flush(s);
1837         return s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
1838     }
1839
1840     if(s->iformat->read_timestamp){
1841         //try to seek via read_timestamp()
1842     }
1843
1844     //Fallback to old API if new is not implemented but old is
1845     //Note the old has somewat different sematics
1846     if(s->iformat->read_seek || 1)
1847         return av_seek_frame(s, stream_index, ts, flags | (ts - min_ts > (uint64_t)(max_ts - ts) ? AVSEEK_FLAG_BACKWARD : 0));
1848
1849     // try some generic seek like seek_frame_generic() but with new ts semantics
1850 }
1851
1852 /*******************************************************/
1853
1854 /**
1855  * Return TRUE if the stream has accurate duration in any stream.
1856  *
1857  * @return TRUE if the stream has accurate duration for at least one component.
1858  */
1859 static int has_duration(AVFormatContext *ic)
1860 {
1861     int i;
1862     AVStream *st;
1863
1864     for(i = 0;i < ic->nb_streams; i++) {
1865         st = ic->streams[i];
1866         if (st->duration != AV_NOPTS_VALUE)
1867             return 1;
1868     }
1869     return 0;
1870 }
1871
1872 /**
1873  * Estimate the stream timings from the one of each components.
1874  *
1875  * Also computes the global bitrate if possible.
1876  */
1877 static void update_stream_timings(AVFormatContext *ic)
1878 {
1879     int64_t start_time, start_time1, end_time, end_time1;
1880     int64_t duration, duration1, filesize;
1881     int i;
1882     AVStream *st;
1883
1884     start_time = INT64_MAX;
1885     end_time = INT64_MIN;
1886     duration = INT64_MIN;
1887     for(i = 0;i < ic->nb_streams; i++) {
1888         st = ic->streams[i];
1889         if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
1890             start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1891             start_time = FFMIN(start_time, start_time1);
1892             if (st->duration != AV_NOPTS_VALUE) {
1893                 end_time1 = start_time1
1894                           + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1895                 end_time = FFMAX(end_time, end_time1);
1896             }
1897         }
1898         if (st->duration != AV_NOPTS_VALUE) {
1899             duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1900             duration = FFMAX(duration, duration1);
1901         }
1902     }
1903     if (start_time != INT64_MAX) {
1904         ic->start_time = start_time;
1905         if (end_time != INT64_MIN)
1906             duration = FFMAX(duration, end_time - start_time);
1907     }
1908     if (duration != INT64_MIN) {
1909         ic->duration = duration;
1910         if (ic->pb && (filesize = avio_size(ic->pb)) > 0) {
1911             /* compute the bitrate */
1912             ic->bit_rate = (double)filesize * 8.0 * AV_TIME_BASE /
1913                 (double)ic->duration;
1914         }
1915     }
1916 }
1917
1918 static void fill_all_stream_timings(AVFormatContext *ic)
1919 {
1920     int i;
1921     AVStream *st;
1922
1923     update_stream_timings(ic);
1924     for(i = 0;i < ic->nb_streams; i++) {
1925         st = ic->streams[i];
1926         if (st->start_time == AV_NOPTS_VALUE) {
1927             if(ic->start_time != AV_NOPTS_VALUE)
1928                 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1929             if(ic->duration != AV_NOPTS_VALUE)
1930                 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1931         }
1932     }
1933 }
1934
1935 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
1936 {
1937     int64_t filesize, duration;
1938     int bit_rate, i;
1939     AVStream *st;
1940
1941     /* if bit_rate is already set, we believe it */
1942     if (ic->bit_rate <= 0) {
1943         bit_rate = 0;
1944         for(i=0;i<ic->nb_streams;i++) {
1945             st = ic->streams[i];
1946             if (st->codec->bit_rate > 0)
1947             bit_rate += st->codec->bit_rate;
1948         }
1949         ic->bit_rate = bit_rate;
1950     }
1951
1952     /* if duration is already set, we believe it */
1953     if (ic->duration == AV_NOPTS_VALUE &&
1954         ic->bit_rate != 0) {
1955         filesize = ic->pb ? avio_size(ic->pb) : 0;
1956         if (filesize > 0) {
1957             for(i = 0; i < ic->nb_streams; i++) {
1958                 st = ic->streams[i];
1959                 duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1960                 if (st->duration == AV_NOPTS_VALUE)
1961                     st->duration = duration;
1962             }
1963         }
1964     }
1965 }
1966
1967 #define DURATION_MAX_READ_SIZE 250000
1968 #define DURATION_MAX_RETRY 3
1969
1970 /* only usable for MPEG-PS streams */
1971 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
1972 {
1973     AVPacket pkt1, *pkt = &pkt1;
1974     AVStream *st;
1975     int read_size, i, ret;
1976     int64_t end_time;
1977     int64_t filesize, offset, duration;
1978     int retry=0;
1979
1980     ic->cur_st = NULL;
1981
1982     /* flush packet queue */
1983     flush_packet_queue(ic);
1984
1985     for (i=0; i<ic->nb_streams; i++) {
1986         st = ic->streams[i];
1987         if (st->start_time == AV_NOPTS_VALUE && st->first_dts == AV_NOPTS_VALUE)
1988             av_log(st->codec, AV_LOG_WARNING, "start time is not set in estimate_timings_from_pts\n");
1989
1990         if (st->parser) {
1991             av_parser_close(st->parser);
1992             st->parser= NULL;
1993             av_free_packet(&st->cur_pkt);
1994         }
1995     }
1996
1997     /* estimate the end time (duration) */
1998     /* XXX: may need to support wrapping */
1999     filesize = ic->pb ? avio_size(ic->pb) : 0;
2000     end_time = AV_NOPTS_VALUE;
2001     do{
2002         offset = filesize - (DURATION_MAX_READ_SIZE<<retry);
2003         if (offset < 0)
2004             offset = 0;
2005
2006         avio_seek(ic->pb, offset, SEEK_SET);
2007         read_size = 0;
2008         for(;;) {
2009             if (read_size >= DURATION_MAX_READ_SIZE<<(FFMAX(retry-1,0)))
2010                 break;
2011
2012             do {
2013                 ret = av_read_packet(ic, pkt);
2014             } while(ret == AVERROR(EAGAIN));
2015             if (ret != 0)
2016                 break;
2017             read_size += pkt->size;
2018             st = ic->streams[pkt->stream_index];
2019             if (pkt->pts != AV_NOPTS_VALUE &&
2020                 (st->start_time != AV_NOPTS_VALUE ||
2021                  st->first_dts  != AV_NOPTS_VALUE)) {
2022                 duration = end_time = pkt->pts;
2023                 if (st->start_time != AV_NOPTS_VALUE)
2024                     duration -= st->start_time;
2025                 else
2026                     duration -= st->first_dts;
2027                 if (duration < 0)
2028                     duration += 1LL<<st->pts_wrap_bits;
2029                 if (duration > 0) {
2030                     if (st->duration == AV_NOPTS_VALUE || st->duration < duration)
2031                         st->duration = duration;
2032                 }
2033             }
2034             av_free_packet(pkt);
2035         }
2036     }while(   end_time==AV_NOPTS_VALUE
2037            && filesize > (DURATION_MAX_READ_SIZE<<retry)
2038            && ++retry <= DURATION_MAX_RETRY);
2039
2040     fill_all_stream_timings(ic);
2041
2042     avio_seek(ic->pb, old_offset, SEEK_SET);
2043     for (i=0; i<ic->nb_streams; i++) {
2044         st= ic->streams[i];
2045         st->cur_dts= st->first_dts;
2046         st->last_IP_pts = AV_NOPTS_VALUE;
2047         st->reference_dts = AV_NOPTS_VALUE;
2048     }
2049 }
2050
2051 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2052 {
2053     int64_t file_size;
2054
2055     /* get the file size, if possible */
2056     if (ic->iformat->flags & AVFMT_NOFILE) {
2057         file_size = 0;
2058     } else {
2059         file_size = avio_size(ic->pb);
2060         file_size = FFMAX(0, file_size);
2061     }
2062
2063     if ((!strcmp(ic->iformat->name, "mpeg") ||
2064          !strcmp(ic->iformat->name, "mpegts")) &&
2065         file_size && ic->pb->seekable) {
2066         /* get accurate estimate from the PTSes */
2067         estimate_timings_from_pts(ic, old_offset);
2068     } else if (has_duration(ic)) {
2069         /* at least one component has timings - we use them for all
2070            the components */
2071         fill_all_stream_timings(ic);
2072     } else {
2073         av_log(ic, AV_LOG_WARNING, "Estimating duration from bitrate, this may be inaccurate\n");
2074         /* less precise: use bitrate info */
2075         estimate_timings_from_bit_rate(ic);
2076     }
2077     update_stream_timings(ic);
2078
2079     {
2080         int i;
2081         AVStream av_unused *st;
2082         for(i = 0;i < ic->nb_streams; i++) {
2083             st = ic->streams[i];
2084             av_dlog(ic, "%d: start_time: %0.3f duration: %0.3f\n", i,
2085                     (double) st->start_time / AV_TIME_BASE,
2086                     (double) st->duration   / AV_TIME_BASE);
2087         }
2088         av_dlog(ic, "stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2089                 (double) ic->start_time / AV_TIME_BASE,
2090                 (double) ic->duration   / AV_TIME_BASE,
2091                 ic->bit_rate / 1000);
2092     }
2093 }
2094
2095 static int has_codec_parameters(AVCodecContext *avctx)
2096 {
2097     int val;
2098     switch (avctx->codec_type) {
2099     case AVMEDIA_TYPE_AUDIO:
2100         val = avctx->sample_rate && avctx->channels && avctx->sample_fmt != AV_SAMPLE_FMT_NONE;
2101         if (!avctx->frame_size &&
2102             (avctx->codec_id == CODEC_ID_VORBIS ||
2103              avctx->codec_id == CODEC_ID_AAC ||
2104              avctx->codec_id == CODEC_ID_MP1 ||
2105              avctx->codec_id == CODEC_ID_MP2 ||
2106              avctx->codec_id == CODEC_ID_MP3 ||
2107              avctx->codec_id == CODEC_ID_CELT))
2108             return 0;
2109         break;
2110     case AVMEDIA_TYPE_VIDEO:
2111         val = avctx->width && avctx->pix_fmt != PIX_FMT_NONE;
2112         break;
2113     default:
2114         val = 1;
2115         break;
2116     }
2117     return avctx->codec_id != CODEC_ID_NONE && val != 0;
2118 }
2119
2120 static int has_decode_delay_been_guessed(AVStream *st)
2121 {
2122     return st->codec->codec_id != CODEC_ID_H264 ||
2123         st->info->nb_decoded_frames >= 6;
2124 }
2125
2126 static int try_decode_frame(AVStream *st, AVPacket *avpkt, AVDictionary **options)
2127 {
2128     AVCodec *codec;
2129     int got_picture, ret = 0;
2130     AVFrame picture;
2131     AVPacket pkt = *avpkt;
2132
2133     if(!st->codec->codec){
2134         codec = avcodec_find_decoder(st->codec->codec_id);
2135         if (!codec)
2136             return -1;
2137         ret = avcodec_open2(st->codec, codec, options);
2138         if (ret < 0)
2139             return ret;
2140     }
2141
2142     while (pkt.size > 0 && ret >= 0 &&
2143            (!has_codec_parameters(st->codec)  ||
2144            !has_decode_delay_been_guessed(st) ||
2145            (!st->codec_info_nb_frames && st->codec->codec->capabilities & CODEC_CAP_CHANNEL_CONF))) {
2146         got_picture = 0;
2147         avcodec_get_frame_defaults(&picture);
2148         switch(st->codec->codec_type) {
2149         case AVMEDIA_TYPE_VIDEO:
2150             ret = avcodec_decode_video2(st->codec, &picture,
2151                                         &got_picture, &pkt);
2152             break;
2153         case AVMEDIA_TYPE_AUDIO:
2154             ret = avcodec_decode_audio4(st->codec, &picture, &got_picture, &pkt);
2155             break;
2156         default:
2157             break;
2158         }
2159         if (ret >= 0) {
2160             if (got_picture)
2161                 st->info->nb_decoded_frames++;
2162             pkt.data += ret;
2163             pkt.size -= ret;
2164         }
2165     }
2166     return ret;
2167 }
2168
2169 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum CodecID id)
2170 {
2171     while (tags->id != CODEC_ID_NONE) {
2172         if (tags->id == id)
2173             return tags->tag;
2174         tags++;
2175     }
2176     return 0;
2177 }
2178
2179 enum CodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2180 {
2181     int i;
2182     for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
2183         if(tag == tags[i].tag)
2184             return tags[i].id;
2185     }
2186     for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
2187         if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
2188             return tags[i].id;
2189     }
2190     return CODEC_ID_NONE;
2191 }
2192
2193 unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum CodecID id)
2194 {
2195     int i;
2196     for(i=0; tags && tags[i]; i++){
2197         int tag= ff_codec_get_tag(tags[i], id);
2198         if(tag) return tag;
2199     }
2200     return 0;
2201 }
2202
2203 enum CodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
2204 {
2205     int i;
2206     for(i=0; tags && tags[i]; i++){
2207         enum CodecID id= ff_codec_get_id(tags[i], tag);
2208         if(id!=CODEC_ID_NONE) return id;
2209     }
2210     return CODEC_ID_NONE;
2211 }
2212
2213 static void compute_chapters_end(AVFormatContext *s)
2214 {
2215     unsigned int i, j;
2216     int64_t max_time = s->duration + ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
2217
2218     for (i = 0; i < s->nb_chapters; i++)
2219         if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2220             AVChapter *ch = s->chapters[i];
2221             int64_t   end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q, ch->time_base)
2222                                      : INT64_MAX;
2223
2224             for (j = 0; j < s->nb_chapters; j++) {
2225                 AVChapter *ch1 = s->chapters[j];
2226                 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base, ch->time_base);
2227                 if (j != i && next_start > ch->start && next_start < end)
2228                     end = next_start;
2229             }
2230             ch->end = (end == INT64_MAX) ? ch->start : end;
2231         }
2232 }
2233
2234 static int get_std_framerate(int i){
2235     if(i<60*12) return i*1001;
2236     else        return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
2237 }
2238
2239 /*
2240  * Is the time base unreliable.
2241  * This is a heuristic to balance between quick acceptance of the values in
2242  * the headers vs. some extra checks.
2243  * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2244  * MPEG-2 commonly misuses field repeat flags to store different framerates.
2245  * And there are "variable" fps files this needs to detect as well.
2246  */
2247 static int tb_unreliable(AVCodecContext *c){
2248     if(   c->time_base.den >= 101L*c->time_base.num
2249        || c->time_base.den <    5L*c->time_base.num
2250 /*       || c->codec_tag == AV_RL32("DIVX")
2251        || c->codec_tag == AV_RL32("XVID")*/
2252        || c->codec_id == CODEC_ID_MPEG2VIDEO
2253        || c->codec_id == CODEC_ID_H264
2254        )
2255         return 1;
2256     return 0;
2257 }
2258
2259 #if FF_API_FORMAT_PARAMETERS
2260 int av_find_stream_info(AVFormatContext *ic)
2261 {
2262     return avformat_find_stream_info(ic, NULL);
2263 }
2264 #endif
2265
2266 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
2267 {
2268     int i, count, ret, read_size, j;
2269     AVStream *st;
2270     AVPacket pkt1, *pkt;
2271     AVDictionary *one_thread_opt = NULL;
2272     int64_t old_offset = avio_tell(ic->pb);
2273     int orig_nb_streams = ic->nb_streams;        // new streams might appear, no options for those
2274
2275     /* this function doesn't flush the decoders, so force thread count
2276      * to 1 to fix behavior when thread count > number of frames in the file */
2277     av_dict_set(&one_thread_opt, "threads", "1", 0);
2278
2279     for(i=0;i<ic->nb_streams;i++) {
2280         AVCodec *codec;
2281         st = ic->streams[i];
2282
2283         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2284             st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2285 /*            if(!st->time_base.num)
2286                 st->time_base= */
2287             if(!st->codec->time_base.num)
2288                 st->codec->time_base= st->time_base;
2289         }
2290         //only for the split stuff
2291         if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
2292             st->parser = av_parser_init(st->codec->codec_id);
2293             if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
2294                 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2295             }
2296         }
2297         assert(!st->codec->codec);
2298         codec = avcodec_find_decoder(st->codec->codec_id);
2299
2300         /* this function doesn't flush the decoders, so force thread count
2301          * to 1 to fix behavior when thread count > number of frames in the file */
2302         if (options)
2303             av_dict_set(&options[i], "threads", "1", 0);
2304
2305         /* Ensure that subtitle_header is properly set. */
2306         if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
2307             && codec && !st->codec->codec)
2308             avcodec_open2(st->codec, codec, options ? &options[i] : &one_thread_opt);
2309
2310         //try to just open decoders, in case this is enough to get parameters
2311         if(!has_codec_parameters(st->codec)){
2312             if (codec && !st->codec->codec)
2313                 avcodec_open2(st->codec, codec, options ? &options[i]
2314                               : &one_thread_opt);
2315         }
2316     }
2317
2318     for (i=0; i<ic->nb_streams; i++) {
2319         ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
2320     }
2321
2322     count = 0;
2323     read_size = 0;
2324     for(;;) {
2325         if (ff_check_interrupt(&ic->interrupt_callback)){
2326             ret= AVERROR_EXIT;
2327             av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2328             break;
2329         }
2330
2331         /* check if one codec still needs to be handled */
2332         for(i=0;i<ic->nb_streams;i++) {
2333             int fps_analyze_framecount = 20;
2334
2335             st = ic->streams[i];
2336             if (!has_codec_parameters(st->codec))
2337                 break;
2338             /* if the timebase is coarse (like the usual millisecond precision
2339                of mkv), we need to analyze more frames to reliably arrive at
2340                the correct fps */
2341             if (av_q2d(st->time_base) > 0.0005)
2342                 fps_analyze_framecount *= 2;
2343             if (ic->fps_probe_size >= 0)
2344                 fps_analyze_framecount = ic->fps_probe_size;
2345             /* variable fps and no guess at the real fps */
2346             if(   tb_unreliable(st->codec) && !(st->r_frame_rate.num && st->avg_frame_rate.num)
2347                && st->info->duration_count < fps_analyze_framecount
2348                && st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2349                 break;
2350             if(st->parser && st->parser->parser->split && !st->codec->extradata)
2351                 break;
2352             if(st->first_dts == AV_NOPTS_VALUE)
2353                 break;
2354         }
2355         if (i == ic->nb_streams) {
2356             /* NOTE: if the format has no header, then we need to read
2357                some packets to get most of the streams, so we cannot
2358                stop here */
2359             if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2360                 /* if we found the info for all the codecs, we can stop */
2361                 ret = count;
2362                 av_log(ic, AV_LOG_DEBUG, "All info found\n");
2363                 break;
2364             }
2365         }
2366         /* we did not get all the codec info, but we read too much data */
2367         if (read_size >= ic->probesize) {
2368             ret = count;
2369             av_log(ic, AV_LOG_DEBUG, "Probe buffer size limit %d reached\n", ic->probesize);
2370             break;
2371         }
2372
2373         /* NOTE: a new stream can be added there if no header in file
2374            (AVFMTCTX_NOHEADER) */
2375         ret = read_frame_internal(ic, &pkt1);
2376         if (ret == AVERROR(EAGAIN))
2377             continue;
2378
2379         if (ret < 0) {
2380             /* EOF or error */
2381             ret = -1; /* we could not have all the codec parameters before EOF */
2382             for(i=0;i<ic->nb_streams;i++) {
2383                 st = ic->streams[i];
2384                 if (!has_codec_parameters(st->codec)){
2385                     char buf[256];
2386                     avcodec_string(buf, sizeof(buf), st->codec, 0);
2387                     av_log(ic, AV_LOG_WARNING, "Could not find codec parameters (%s)\n", buf);
2388                 } else {
2389                     ret = 0;
2390                 }
2391             }
2392             break;
2393         }
2394
2395         pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2396         if ((ret = av_dup_packet(pkt)) < 0)
2397             goto find_stream_info_err;
2398
2399         read_size += pkt->size;
2400
2401         st = ic->streams[pkt->stream_index];
2402         if (st->codec_info_nb_frames>1) {
2403             if (st->time_base.den > 0 && av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q) >= ic->max_analyze_duration) {
2404                 av_log(ic, AV_LOG_WARNING, "max_analyze_duration reached\n");
2405                 break;
2406             }
2407             st->info->codec_info_duration += pkt->duration;
2408         }
2409         {
2410             int64_t last = st->info->last_dts;
2411
2412             if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && pkt->dts > last){
2413                 int64_t duration= pkt->dts - last;
2414                 double dur= duration * av_q2d(st->time_base);
2415
2416 //                if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2417 //                    av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
2418                 if (st->info->duration_count < 2)
2419                     memset(st->info->duration_error, 0, sizeof(st->info->duration_error));
2420                 for (i=1; i<FF_ARRAY_ELEMS(st->info->duration_error); i++) {
2421                     int framerate= get_std_framerate(i);
2422                     int ticks= lrintf(dur*framerate/(1001*12));
2423                     double error = dur - (double)ticks*1001*12 / framerate;
2424                     st->info->duration_error[i] += error*error;
2425                 }
2426                 st->info->duration_count++;
2427                 // ignore the first 4 values, they might have some random jitter
2428                 if (st->info->duration_count > 3)
2429                     st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2430             }
2431             if (last == AV_NOPTS_VALUE || st->info->duration_count <= 1)
2432                 st->info->last_dts = pkt->dts;
2433         }
2434         if(st->parser && st->parser->parser->split && !st->codec->extradata){
2435             int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2436             if(i){
2437                 st->codec->extradata_size= i;
2438                 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2439                 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2440                 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2441             }
2442         }
2443
2444         /* if still no information, we try to open the codec and to
2445            decompress the frame. We try to avoid that in most cases as
2446            it takes longer and uses more memory. For MPEG-4, we need to
2447            decompress for QuickTime.
2448
2449            If CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
2450            least one frame of codec data, this makes sure the codec initializes
2451            the channel configuration and does not only trust the values from the container.
2452         */
2453         try_decode_frame(st, pkt, (options && i < orig_nb_streams )? &options[i]
2454                          : &one_thread_opt);
2455
2456         st->codec_info_nb_frames++;
2457         count++;
2458     }
2459
2460     // close codecs which were opened in try_decode_frame()
2461     for(i=0;i<ic->nb_streams;i++) {
2462         st = ic->streams[i];
2463         if(st->codec->codec)
2464             avcodec_close(st->codec);
2465     }
2466     for(i=0;i<ic->nb_streams;i++) {
2467         st = ic->streams[i];
2468         if (st->codec_info_nb_frames>2 && !st->avg_frame_rate.num && st->info->codec_info_duration)
2469             av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2470                      (st->codec_info_nb_frames-2)*(int64_t)st->time_base.den,
2471                       st->info->codec_info_duration*(int64_t)st->time_base.num, 60000);
2472         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2473             // the check for tb_unreliable() is not completely correct, since this is not about handling
2474             // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2475             // ipmovie.c produces.
2476             if (tb_unreliable(st->codec) && st->info->duration_count > 15 && st->info->duration_gcd > 1 && !st->r_frame_rate.num)
2477                 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, st->time_base.den, st->time_base.num * st->info->duration_gcd, INT_MAX);
2478             if (st->info->duration_count && !st->r_frame_rate.num
2479                && tb_unreliable(st->codec) /*&&
2480                //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2481                st->time_base.num*duration_sum[i]/st->info->duration_count*101LL > st->time_base.den*/){
2482                 int num = 0;
2483                 double best_error= 2*av_q2d(st->time_base);
2484                 best_error = best_error*best_error*st->info->duration_count*1000*12*30;
2485
2486                 for (j=1; j<FF_ARRAY_ELEMS(st->info->duration_error); j++) {
2487                     double error = st->info->duration_error[j] * get_std_framerate(j);
2488 //                    if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2489 //                        av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
2490                     if(error < best_error){
2491                         best_error= error;
2492                         num = get_std_framerate(j);
2493                     }
2494                 }
2495                 // do not increase frame rate by more than 1 % in order to match a standard rate.
2496                 if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
2497                     av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2498             }
2499
2500             if (!st->r_frame_rate.num){
2501                 if(    st->codec->time_base.den * (int64_t)st->time_base.num
2502                     <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
2503                     st->r_frame_rate.num = st->codec->time_base.den;
2504                     st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
2505                 }else{
2506                     st->r_frame_rate.num = st->time_base.den;
2507                     st->r_frame_rate.den = st->time_base.num;
2508                 }
2509             }
2510         }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2511             if(!st->codec->bits_per_coded_sample)
2512                 st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2513             // set stream disposition based on audio service type
2514             switch (st->codec->audio_service_type) {
2515             case AV_AUDIO_SERVICE_TYPE_EFFECTS:
2516                 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;    break;
2517             case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
2518                 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;  break;
2519             case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
2520                 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED; break;
2521             case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
2522                 st->disposition = AV_DISPOSITION_COMMENT;          break;
2523             case AV_AUDIO_SERVICE_TYPE_KARAOKE:
2524                 st->disposition = AV_DISPOSITION_KARAOKE;          break;
2525             }
2526         }
2527     }
2528
2529     estimate_timings(ic, old_offset);
2530
2531     compute_chapters_end(ic);
2532
2533 #if 0
2534     /* correct DTS for B-frame streams with no timestamps */
2535     for(i=0;i<ic->nb_streams;i++) {
2536         st = ic->streams[i];
2537         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2538             if(b-frames){
2539                 ppktl = &ic->packet_buffer;
2540                 while(ppkt1){
2541                     if(ppkt1->stream_index != i)
2542                         continue;
2543                     if(ppkt1->pkt->dts < 0)
2544                         break;
2545                     if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2546                         break;
2547                     ppkt1->pkt->dts -= delta;
2548                     ppkt1= ppkt1->next;
2549                 }
2550                 if(ppkt1)
2551                     continue;
2552                 st->cur_dts -= delta;
2553             }
2554         }
2555     }
2556 #endif
2557
2558  find_stream_info_err:
2559     for (i=0; i < ic->nb_streams; i++) {
2560         if (ic->streams[i]->codec)
2561             ic->streams[i]->codec->thread_count = 0;
2562         av_freep(&ic->streams[i]->info);
2563     }
2564     av_dict_free(&one_thread_opt);
2565     return ret;
2566 }
2567
2568 static AVProgram *find_program_from_stream(AVFormatContext *ic, int s)
2569 {
2570     int i, j;
2571
2572     for (i = 0; i < ic->nb_programs; i++)
2573         for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
2574             if (ic->programs[i]->stream_index[j] == s)
2575                 return ic->programs[i];
2576     return NULL;
2577 }
2578
2579 int av_find_best_stream(AVFormatContext *ic,
2580                         enum AVMediaType type,
2581                         int wanted_stream_nb,
2582                         int related_stream,
2583                         AVCodec **decoder_ret,
2584                         int flags)
2585 {
2586     int i, nb_streams = ic->nb_streams;
2587     int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1;
2588     unsigned *program = NULL;
2589     AVCodec *decoder = NULL, *best_decoder = NULL;
2590
2591     if (related_stream >= 0 && wanted_stream_nb < 0) {
2592         AVProgram *p = find_program_from_stream(ic, related_stream);
2593         if (p) {
2594             program = p->stream_index;
2595             nb_streams = p->nb_stream_indexes;
2596         }
2597     }
2598     for (i = 0; i < nb_streams; i++) {
2599         int real_stream_index = program ? program[i] : i;
2600         AVStream *st = ic->streams[real_stream_index];
2601         AVCodecContext *avctx = st->codec;
2602         if (avctx->codec_type != type)
2603             continue;
2604         if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
2605             continue;
2606         if (st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED|AV_DISPOSITION_VISUAL_IMPAIRED))
2607             continue;
2608         if (decoder_ret) {
2609             decoder = avcodec_find_decoder(st->codec->codec_id);
2610             if (!decoder) {
2611                 if (ret < 0)
2612                     ret = AVERROR_DECODER_NOT_FOUND;
2613                 continue;
2614             }
2615         }
2616         if (best_count >= st->codec_info_nb_frames)
2617             continue;
2618         best_count = st->codec_info_nb_frames;
2619         ret = real_stream_index;
2620         best_decoder = decoder;
2621         if (program && i == nb_streams - 1 && ret < 0) {
2622             program = NULL;
2623             nb_streams = ic->nb_streams;
2624             i = 0; /* no related stream found, try again with everything */
2625         }
2626     }
2627     if (decoder_ret)
2628         *decoder_ret = best_decoder;
2629     return ret;
2630 }
2631
2632 /*******************************************************/
2633
2634 int av_read_play(AVFormatContext *s)
2635 {
2636     if (s->iformat->read_play)
2637         return s->iformat->read_play(s);
2638     if (s->pb)
2639         return avio_pause(s->pb, 0);
2640     return AVERROR(ENOSYS);
2641 }
2642
2643 int av_read_pause(AVFormatContext *s)
2644 {
2645     if (s->iformat->read_pause)
2646         return s->iformat->read_pause(s);
2647     if (s->pb)
2648         return avio_pause(s->pb, 1);
2649     return AVERROR(ENOSYS);
2650 }
2651
2652 #if FF_API_FORMAT_PARAMETERS
2653 void av_close_input_stream(AVFormatContext *s)
2654 {
2655     flush_packet_queue(s);
2656     if (s->iformat->read_close)
2657         s->iformat->read_close(s);
2658     avformat_free_context(s);
2659 }
2660 #endif
2661
2662 void avformat_free_context(AVFormatContext *s)
2663 {
2664     int i;
2665     AVStream *st;
2666
2667     av_opt_free(s);
2668     if (s->iformat && s->iformat->priv_class && s->priv_data)
2669         av_opt_free(s->priv_data);
2670
2671     for(i=0;i<s->nb_streams;i++) {
2672         /* free all data in a stream component */
2673         st = s->streams[i];
2674         if (st->parser) {
2675             av_parser_close(st->parser);
2676             av_free_packet(&st->cur_pkt);
2677         }
2678         av_dict_free(&st->metadata);
2679         av_free(st->index_entries);
2680         av_free(st->codec->extradata);
2681         av_free(st->codec->subtitle_header);
2682         av_free(st->codec);
2683         av_free(st->priv_data);
2684         av_free(st->info);
2685         av_free(st);
2686     }
2687     for(i=s->nb_programs-1; i>=0; i--) {
2688         av_dict_free(&s->programs[i]->metadata);
2689         av_freep(&s->programs[i]->stream_index);
2690         av_freep(&s->programs[i]);
2691     }
2692     av_freep(&s->programs);
2693     av_freep(&s->priv_data);
2694     while(s->nb_chapters--) {
2695         av_dict_free(&s->chapters[s->nb_chapters]->metadata);
2696         av_free(s->chapters[s->nb_chapters]);
2697     }
2698     av_freep(&s->chapters);
2699     av_dict_free(&s->metadata);
2700     av_freep(&s->streams);
2701     av_free(s);
2702 }
2703
2704 #if FF_API_CLOSE_INPUT_FILE
2705 void av_close_input_file(AVFormatContext *s)
2706 {
2707     avformat_close_input(&s);
2708 }
2709 #endif
2710
2711 void avformat_close_input(AVFormatContext **ps)
2712 {
2713     AVFormatContext *s = *ps;
2714     AVIOContext *pb = (s->iformat->flags & AVFMT_NOFILE) || (s->flags & AVFMT_FLAG_CUSTOM_IO) ?
2715                        NULL : s->pb;
2716     flush_packet_queue(s);
2717     if (s->iformat->read_close)
2718         s->iformat->read_close(s);
2719     avformat_free_context(s);
2720     *ps = NULL;
2721     if (pb)
2722         avio_close(pb);
2723 }
2724
2725 #if FF_API_NEW_STREAM
2726 AVStream *av_new_stream(AVFormatContext *s, int id)
2727 {
2728     AVStream *st = avformat_new_stream(s, NULL);
2729     if (st)
2730         st->id = id;
2731     return st;
2732 }
2733 #endif
2734
2735 AVStream *avformat_new_stream(AVFormatContext *s, AVCodec *c)
2736 {
2737     AVStream *st;
2738     int i;
2739     AVStream **streams;
2740
2741     if (s->nb_streams >= INT_MAX/sizeof(*streams))
2742         return NULL;
2743     streams = av_realloc(s->streams, (s->nb_streams + 1) * sizeof(*streams));
2744     if (!streams)
2745         return NULL;
2746     s->streams = streams;
2747
2748     st = av_mallocz(sizeof(AVStream));
2749     if (!st)
2750         return NULL;
2751     if (!(st->info = av_mallocz(sizeof(*st->info)))) {
2752         av_free(st);
2753         return NULL;
2754     }
2755
2756     st->codec = avcodec_alloc_context3(c);
2757     if (s->iformat) {
2758         /* no default bitrate if decoding */
2759         st->codec->bit_rate = 0;
2760     }
2761     st->index = s->nb_streams;
2762     st->start_time = AV_NOPTS_VALUE;
2763     st->duration = AV_NOPTS_VALUE;
2764         /* we set the current DTS to 0 so that formats without any timestamps
2765            but durations get some timestamps, formats with some unknown
2766            timestamps have their first few packets buffered and the
2767            timestamps corrected before they are returned to the user */
2768     st->cur_dts = 0;
2769     st->first_dts = AV_NOPTS_VALUE;
2770     st->probe_packets = MAX_PROBE_PACKETS;
2771
2772     /* default pts setting is MPEG-like */
2773     avpriv_set_pts_info(st, 33, 1, 90000);
2774     st->last_IP_pts = AV_NOPTS_VALUE;
2775     for(i=0; i<MAX_REORDER_DELAY+1; i++)
2776         st->pts_buffer[i]= AV_NOPTS_VALUE;
2777     st->reference_dts = AV_NOPTS_VALUE;
2778
2779     st->sample_aspect_ratio = (AVRational){0,1};
2780
2781     s->streams[s->nb_streams++] = st;
2782     return st;
2783 }
2784
2785 AVProgram *av_new_program(AVFormatContext *ac, int id)
2786 {
2787     AVProgram *program=NULL;
2788     int i;
2789
2790     av_dlog(ac, "new_program: id=0x%04x\n", id);
2791
2792     for(i=0; i<ac->nb_programs; i++)
2793         if(ac->programs[i]->id == id)
2794             program = ac->programs[i];
2795
2796     if(!program){
2797         program = av_mallocz(sizeof(AVProgram));
2798         if (!program)
2799             return NULL;
2800         dynarray_add(&ac->programs, &ac->nb_programs, program);
2801         program->discard = AVDISCARD_NONE;
2802     }
2803     program->id = id;
2804
2805     return program;
2806 }
2807
2808 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2809 {
2810     AVChapter *chapter = NULL;
2811     int i;
2812
2813     for(i=0; i<s->nb_chapters; i++)
2814         if(s->chapters[i]->id == id)
2815             chapter = s->chapters[i];
2816
2817     if(!chapter){
2818         chapter= av_mallocz(sizeof(AVChapter));
2819         if(!chapter)
2820             return NULL;
2821         dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2822     }
2823     av_dict_set(&chapter->metadata, "title", title, 0);
2824     chapter->id    = id;
2825     chapter->time_base= time_base;
2826     chapter->start = start;
2827     chapter->end   = end;
2828
2829     return chapter;
2830 }
2831
2832 /************************************************************/
2833 /* output media file */
2834
2835 #if FF_API_FORMAT_PARAMETERS
2836 int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2837 {
2838     int ret;
2839
2840     if (s->oformat->priv_data_size > 0) {
2841         s->priv_data = av_mallocz(s->oformat->priv_data_size);
2842         if (!s->priv_data)
2843             return AVERROR(ENOMEM);
2844         if (s->oformat->priv_class) {
2845             *(const AVClass**)s->priv_data= s->oformat->priv_class;
2846             av_opt_set_defaults(s->priv_data);
2847         }
2848     } else
2849         s->priv_data = NULL;
2850
2851     if (s->oformat->set_parameters) {
2852         ret = s->oformat->set_parameters(s, ap);
2853         if (ret < 0)
2854             return ret;
2855     }
2856     return 0;
2857 }
2858 #endif
2859
2860 static int validate_codec_tag(AVFormatContext *s, AVStream *st)
2861 {
2862     const AVCodecTag *avctag;
2863     int n;
2864     enum CodecID id = CODEC_ID_NONE;
2865     unsigned int tag = 0;
2866
2867     /**
2868      * Check that tag + id is in the table
2869      * If neither is in the table -> OK
2870      * If tag is in the table with another id -> FAIL
2871      * If id is in the table with another tag -> FAIL unless strict < normal
2872      */
2873     for (n = 0; s->oformat->codec_tag[n]; n++) {
2874         avctag = s->oformat->codec_tag[n];
2875         while (avctag->id != CODEC_ID_NONE) {
2876             if (avpriv_toupper4(avctag->tag) == avpriv_toupper4(st->codec->codec_tag)) {
2877                 id = avctag->id;
2878                 if (id == st->codec->codec_id)
2879                     return 1;
2880             }
2881             if (avctag->id == st->codec->codec_id)
2882                 tag = avctag->tag;
2883             avctag++;
2884         }
2885     }
2886     if (id != CODEC_ID_NONE)
2887         return 0;
2888     if (tag && (st->codec->strict_std_compliance >= FF_COMPLIANCE_NORMAL))
2889         return 0;
2890     return 1;
2891 }
2892
2893 #if FF_API_FORMAT_PARAMETERS
2894 int av_write_header(AVFormatContext *s)
2895 {
2896     return avformat_write_header(s, NULL);
2897 }
2898 #endif
2899
2900 int avformat_write_header(AVFormatContext *s, AVDictionary **options)
2901 {
2902     int ret = 0, i;
2903     AVStream *st;
2904     AVDictionary *tmp = NULL;
2905
2906     if (options)
2907         av_dict_copy(&tmp, *options, 0);
2908     if ((ret = av_opt_set_dict(s, &tmp)) < 0)
2909         goto fail;
2910
2911     // some sanity checks
2912     if (s->nb_streams == 0 && !(s->oformat->flags & AVFMT_NOSTREAMS)) {
2913         av_log(s, AV_LOG_ERROR, "no streams\n");
2914         ret = AVERROR(EINVAL);
2915         goto fail;
2916     }
2917
2918     for(i=0;i<s->nb_streams;i++) {
2919         st = s->streams[i];
2920
2921         switch (st->codec->codec_type) {
2922         case AVMEDIA_TYPE_AUDIO:
2923             if(st->codec->sample_rate<=0){
2924                 av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2925                 ret = AVERROR(EINVAL);
2926                 goto fail;
2927             }
2928             if(!st->codec->block_align)
2929                 st->codec->block_align = st->codec->channels *
2930                     av_get_bits_per_sample(st->codec->codec_id) >> 3;
2931             break;
2932         case AVMEDIA_TYPE_VIDEO:
2933             if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2934                 av_log(s, AV_LOG_ERROR, "time base not set\n");
2935                 ret = AVERROR(EINVAL);
2936                 goto fail;
2937             }
2938             if((st->codec->width<=0 || st->codec->height<=0) && !(s->oformat->flags & AVFMT_NODIMENSIONS)){
2939                 av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2940                 ret = AVERROR(EINVAL);
2941                 goto fail;
2942             }
2943             if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)){
2944                 av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between encoder and muxer layer\n");
2945                 ret = AVERROR(EINVAL);
2946                 goto fail;
2947             }
2948             break;
2949         }
2950
2951         if(s->oformat->codec_tag){
2952             if(st->codec->codec_tag && st->codec->codec_id == CODEC_ID_RAWVIDEO && av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id) == 0 && !validate_codec_tag(s, st)){
2953                 //the current rawvideo encoding system ends up setting the wrong codec_tag for avi, we override it here
2954                 st->codec->codec_tag= 0;
2955             }
2956             if(st->codec->codec_tag){
2957                 if (!validate_codec_tag(s, st)) {
2958                     char tagbuf[32];
2959                     av_get_codec_tag_string(tagbuf, sizeof(tagbuf), st->codec->codec_tag);
2960                     av_log(s, AV_LOG_ERROR,
2961                            "Tag %s/0x%08x incompatible with output codec id '%d'\n",
2962                            tagbuf, st->codec->codec_tag, st->codec->codec_id);
2963                     ret = AVERROR_INVALIDDATA;
2964                     goto fail;
2965                 }
2966             }else
2967                 st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2968         }
2969
2970         if(s->oformat->flags & AVFMT_GLOBALHEADER &&
2971             !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
2972           av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
2973     }
2974
2975     if (!s->priv_data && s->oformat->priv_data_size > 0) {
2976         s->priv_data = av_mallocz(s->oformat->priv_data_size);
2977         if (!s->priv_data) {
2978             ret = AVERROR(ENOMEM);
2979             goto fail;
2980         }
2981         if (s->oformat->priv_class) {
2982             *(const AVClass**)s->priv_data= s->oformat->priv_class;
2983             av_opt_set_defaults(s->priv_data);
2984             if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
2985                 goto fail;
2986         }
2987     }
2988
2989     /* set muxer identification string */
2990     if (s->nb_streams && !(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
2991         av_dict_set(&s->metadata, "encoder", LIBAVFORMAT_IDENT, 0);
2992     }
2993
2994     if(s->oformat->write_header){
2995         ret = s->oformat->write_header(s);
2996         if (ret < 0)
2997             goto fail;
2998     }
2999
3000     /* init PTS generation */
3001     for(i=0;i<s->nb_streams;i++) {
3002         int64_t den = AV_NOPTS_VALUE;
3003         st = s->streams[i];
3004
3005         switch (st->codec->codec_type) {
3006         case AVMEDIA_TYPE_AUDIO:
3007             den = (int64_t)st->time_base.num * st->codec->sample_rate;
3008             break;
3009         case AVMEDIA_TYPE_VIDEO:
3010             den = (int64_t)st->time_base.num * st->codec->time_base.den;
3011             break;
3012         default:
3013             break;
3014         }
3015         if (den != AV_NOPTS_VALUE) {
3016             if (den <= 0) {
3017                 ret = AVERROR_INVALIDDATA;
3018                 goto fail;
3019             }
3020             frac_init(&st->pts, 0, 0, den);
3021         }
3022     }
3023
3024     if (options) {
3025         av_dict_free(options);
3026         *options = tmp;
3027     }
3028     return 0;
3029 fail:
3030     av_dict_free(&tmp);
3031     return ret;
3032 }
3033
3034 //FIXME merge with compute_pkt_fields
3035 static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt){
3036     int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
3037     int num, den, frame_size, i;
3038
3039     av_dlog(s, "compute_pkt_fields2: pts:%"PRId64" dts:%"PRId64" cur_dts:%"PRId64" b:%d size:%d st:%d\n",
3040             pkt->pts, pkt->dts, st->cur_dts, delay, pkt->size, pkt->stream_index);
3041
3042 /*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
3043         return AVERROR(EINVAL);*/
3044
3045     /* duration field */
3046     if (pkt->duration == 0) {
3047         compute_frame_duration(&num, &den, st, NULL, pkt);
3048         if (den && num) {
3049             pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
3050         }
3051     }
3052
3053     if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
3054         pkt->pts= pkt->dts;
3055
3056     //XXX/FIXME this is a temporary hack until all encoders output pts
3057     if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
3058         pkt->dts=
3059 //        pkt->pts= st->cur_dts;
3060         pkt->pts= st->pts.val;
3061     }
3062
3063     //calculate dts from pts
3064     if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
3065         st->pts_buffer[0]= pkt->pts;
3066         for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
3067             st->pts_buffer[i]= pkt->pts + (i-delay-1) * pkt->duration;
3068         for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
3069             FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
3070
3071         pkt->dts= st->pts_buffer[0];
3072     }
3073
3074     if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
3075         av_log(s, AV_LOG_ERROR,
3076                "Application provided invalid, non monotonically increasing dts to muxer in stream %d: %"PRId64" >= %"PRId64"\n",
3077                st->index, st->cur_dts, pkt->dts);
3078         return AVERROR(EINVAL);
3079     }
3080     if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
3081         av_log(s, AV_LOG_ERROR, "pts < dts in stream %d\n", st->index);
3082         return AVERROR(EINVAL);
3083     }
3084
3085 //    av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
3086     st->cur_dts= pkt->dts;
3087     st->pts.val= pkt->dts;
3088
3089     /* update pts */
3090     switch (st->codec->codec_type) {
3091     case AVMEDIA_TYPE_AUDIO:
3092         frame_size = get_audio_frame_size(st->codec, pkt->size);
3093
3094         /* HACK/FIXME, we skip the initial 0 size packets as they are most
3095            likely equal to the encoder delay, but it would be better if we
3096            had the real timestamps from the encoder */
3097         if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
3098             frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
3099         }
3100         break;
3101     case AVMEDIA_TYPE_VIDEO:
3102         frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
3103         break;
3104     default:
3105         break;
3106     }
3107     return 0;
3108 }
3109
3110 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
3111 {
3112     int ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt);
3113
3114     if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3115         return ret;
3116
3117     ret= s->oformat->write_packet(s, pkt);
3118
3119     if (ret >= 0)
3120         s->streams[pkt->stream_index]->nb_frames++;
3121     return ret;
3122 }
3123
3124 void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
3125                               int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
3126 {
3127     AVPacketList **next_point, *this_pktl;
3128
3129     this_pktl = av_mallocz(sizeof(AVPacketList));
3130     this_pktl->pkt= *pkt;
3131     pkt->destruct= NULL;             // do not free original but only the copy
3132     av_dup_packet(&this_pktl->pkt);  // duplicate the packet if it uses non-alloced memory
3133
3134     if(s->streams[pkt->stream_index]->last_in_packet_buffer){
3135         next_point = &(s->streams[pkt->stream_index]->last_in_packet_buffer->next);
3136     }else
3137         next_point = &s->packet_buffer;
3138
3139     if(*next_point){
3140         if(compare(s, &s->packet_buffer_end->pkt, pkt)){
3141             while(!compare(s, &(*next_point)->pkt, pkt)){
3142                 next_point= &(*next_point)->next;
3143             }
3144             goto next_non_null;
3145         }else{
3146             next_point = &(s->packet_buffer_end->next);
3147         }
3148     }
3149     assert(!*next_point);
3150
3151     s->packet_buffer_end= this_pktl;
3152 next_non_null:
3153
3154     this_pktl->next= *next_point;
3155
3156     s->streams[pkt->stream_index]->last_in_packet_buffer=
3157     *next_point= this_pktl;
3158 }
3159
3160 static int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
3161 {
3162     AVStream *st = s->streams[ pkt ->stream_index];
3163     AVStream *st2= s->streams[ next->stream_index];
3164     int comp = av_compare_ts(next->dts, st2->time_base, pkt->dts,
3165                              st->time_base);
3166
3167     if (comp == 0)
3168         return pkt->stream_index < next->stream_index;
3169     return comp > 0;
3170 }
3171
3172 int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
3173     AVPacketList *pktl;
3174     int stream_count=0;
3175     int i;
3176
3177     if(pkt){
3178         ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
3179     }
3180
3181     for(i=0; i < s->nb_streams; i++)
3182         stream_count+= !!s->streams[i]->last_in_packet_buffer;
3183
3184     if(stream_count && (s->nb_streams == stream_count || flush)){
3185         pktl= s->packet_buffer;
3186         *out= pktl->pkt;
3187
3188         s->packet_buffer= pktl->next;
3189         if(!s->packet_buffer)
3190             s->packet_buffer_end= NULL;
3191
3192         if(s->streams[out->stream_index]->last_in_packet_buffer == pktl)
3193             s->streams[out->stream_index]->last_in_packet_buffer= NULL;
3194         av_freep(&pktl);
3195         return 1;
3196     }else{
3197         av_init_packet(out);
3198         return 0;
3199     }
3200 }
3201
3202 /**
3203  * Interleave an AVPacket correctly so it can be muxed.
3204  * @param out the interleaved packet will be output here
3205  * @param in the input packet
3206  * @param flush 1 if no further packets are available as input and all
3207  *              remaining packets should be output
3208  * @return 1 if a packet was output, 0 if no packet could be output,
3209  *         < 0 if an error occurred
3210  */
3211 static int interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
3212     if(s->oformat->interleave_packet)
3213         return s->oformat->interleave_packet(s, out, in, flush);
3214     else
3215         return av_interleave_packet_per_dts(s, out, in, flush);
3216 }
3217
3218 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
3219     AVStream *st= s->streams[ pkt->stream_index];
3220     int ret;
3221
3222     //FIXME/XXX/HACK drop zero sized packets
3223     if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO && pkt->size==0)
3224         return 0;
3225
3226     av_dlog(s, "av_interleaved_write_frame size:%d dts:%"PRId64" pts:%"PRId64"\n",
3227             pkt->size, pkt->dts, pkt->pts);
3228     if((ret = compute_pkt_fields2(s, st, pkt)) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3229         return ret;
3230
3231     if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3232         return AVERROR(EINVAL);
3233
3234     for(;;){
3235         AVPacket opkt;
3236         int ret= interleave_packet(s, &opkt, pkt, 0);
3237         if(ret<=0) //FIXME cleanup needed for ret<0 ?
3238             return ret;
3239
3240         ret= s->oformat->write_packet(s, &opkt);
3241         if (ret >= 0)
3242             s->streams[opkt.stream_index]->nb_frames++;
3243
3244         av_free_packet(&opkt);
3245         pkt= NULL;
3246
3247         if(ret<0)
3248             return ret;
3249     }
3250 }
3251
3252 int av_write_trailer(AVFormatContext *s)
3253 {
3254     int ret, i;
3255
3256     for(;;){
3257         AVPacket pkt;
3258         ret= interleave_packet(s, &pkt, NULL, 1);
3259         if(ret<0) //FIXME cleanup needed for ret<0 ?
3260             goto fail;
3261         if(!ret)
3262             break;
3263
3264         ret= s->oformat->write_packet(s, &pkt);
3265         if (ret >= 0)
3266             s->streams[pkt.stream_index]->nb_frames++;
3267
3268         av_free_packet(&pkt);
3269
3270         if(ret<0)
3271             goto fail;
3272     }
3273
3274     if(s->oformat->write_trailer)
3275         ret = s->oformat->write_trailer(s);
3276 fail:
3277     for(i=0;i<s->nb_streams;i++) {
3278         av_freep(&s->streams[i]->priv_data);
3279         av_freep(&s->streams[i]->index_entries);
3280     }
3281     if (s->oformat->priv_class)
3282         av_opt_free(s->priv_data);
3283     av_freep(&s->priv_data);
3284     return ret;
3285 }
3286
3287 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
3288 {
3289     int i, j;
3290     AVProgram *program=NULL;
3291     void *tmp;
3292
3293     if (idx >= ac->nb_streams) {
3294         av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3295         return;
3296     }
3297
3298     for(i=0; i<ac->nb_programs; i++){
3299         if(ac->programs[i]->id != progid)
3300             continue;
3301         program = ac->programs[i];
3302         for(j=0; j<program->nb_stream_indexes; j++)
3303             if(program->stream_index[j] == idx)
3304                 return;
3305
3306         tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
3307         if(!tmp)
3308             return;
3309         program->stream_index = tmp;
3310         program->stream_index[program->nb_stream_indexes++] = idx;
3311         return;
3312     }
3313 }
3314
3315 static void print_fps(double d, const char *postfix){
3316     uint64_t v= lrintf(d*100);
3317     if     (v% 100      ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3318     else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3319     else                  av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
3320 }
3321
3322 static void dump_metadata(void *ctx, AVDictionary *m, const char *indent)
3323 {
3324     if(m && !(m->count == 1 && av_dict_get(m, "language", NULL, 0))){
3325         AVDictionaryEntry *tag=NULL;
3326
3327         av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3328         while((tag=av_dict_get(m, "", tag, AV_DICT_IGNORE_SUFFIX))) {
3329             if(strcmp("language", tag->key))
3330                 av_log(ctx, AV_LOG_INFO, "%s  %-16s: %s\n", indent, tag->key, tag->value);
3331         }
3332     }
3333 }
3334
3335 /* "user interface" functions */
3336 static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
3337 {
3338     char buf[256];
3339     int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
3340     AVStream *st = ic->streams[i];
3341     int g = av_gcd(st->time_base.num, st->time_base.den);
3342     AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL, 0);
3343     avcodec_string(buf, sizeof(buf), st->codec, is_output);
3344     av_log(NULL, AV_LOG_INFO, "    Stream #%d.%d", index, i);
3345     /* the pid is an important information, so we display it */
3346     /* XXX: add a generic system */
3347     if (flags & AVFMT_SHOW_IDS)
3348         av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
3349     if (lang)
3350         av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
3351     av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames, st->time_base.num/g, st->time_base.den/g);
3352     av_log(NULL, AV_LOG_INFO, ": %s", buf);
3353     if (st->sample_aspect_ratio.num && // default
3354         av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
3355         AVRational display_aspect_ratio;
3356         av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
3357                   st->codec->width*st->sample_aspect_ratio.num,
3358                   st->codec->height*st->sample_aspect_ratio.den,
3359                   1024*1024);
3360         av_log(NULL, AV_LOG_INFO, ", PAR %d:%d DAR %d:%d",
3361                  st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3362                  display_aspect_ratio.num, display_aspect_ratio.den);
3363     }
3364     if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
3365         if(st->avg_frame_rate.den && st->avg_frame_rate.num)
3366             print_fps(av_q2d(st->avg_frame_rate), "fps");
3367         if(st->r_frame_rate.den && st->r_frame_rate.num)
3368             print_fps(av_q2d(st->r_frame_rate), "tbr");
3369         if(st->time_base.den && st->time_base.num)
3370             print_fps(1/av_q2d(st->time_base), "tbn");
3371         if(st->codec->time_base.den && st->codec->time_base.num)
3372             print_fps(1/av_q2d(st->codec->time_base), "tbc");
3373     }
3374     if (st->disposition & AV_DISPOSITION_DEFAULT)
3375         av_log(NULL, AV_LOG_INFO, " (default)");
3376     if (st->disposition & AV_DISPOSITION_DUB)
3377         av_log(NULL, AV_LOG_INFO, " (dub)");
3378     if (st->disposition & AV_DISPOSITION_ORIGINAL)
3379         av_log(NULL, AV_LOG_INFO, " (original)");
3380     if (st->disposition & AV_DISPOSITION_COMMENT)
3381         av_log(NULL, AV_LOG_INFO, " (comment)");
3382     if (st->disposition & AV_DISPOSITION_LYRICS)
3383         av_log(NULL, AV_LOG_INFO, " (lyrics)");
3384     if (st->disposition & AV_DISPOSITION_KARAOKE)
3385         av_log(NULL, AV_LOG_INFO, " (karaoke)");
3386     if (st->disposition & AV_DISPOSITION_FORCED)
3387         av_log(NULL, AV_LOG_INFO, " (forced)");
3388     if (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED)
3389         av_log(NULL, AV_LOG_INFO, " (hearing impaired)");
3390     if (st->disposition & AV_DISPOSITION_VISUAL_IMPAIRED)
3391         av_log(NULL, AV_LOG_INFO, " (visual impaired)");
3392     if (st->disposition & AV_DISPOSITION_CLEAN_EFFECTS)
3393         av_log(NULL, AV_LOG_INFO, " (clean effects)");
3394     av_log(NULL, AV_LOG_INFO, "\n");
3395     dump_metadata(NULL, st->metadata, "    ");
3396 }
3397
3398 #if FF_API_DUMP_FORMAT
3399 void dump_format(AVFormatContext *ic,
3400                  int index,
3401                  const char *url,
3402                  int is_output)
3403 {
3404     av_dump_format(ic, index, url, is_output);
3405 }
3406 #endif
3407
3408 void av_dump_format(AVFormatContext *ic,
3409                     int index,
3410                     const char *url,
3411                     int is_output)
3412 {
3413     int i;
3414     uint8_t *printed = ic->nb_streams ? av_mallocz(ic->nb_streams) : NULL;
3415     if (ic->nb_streams && !printed)
3416         return;
3417
3418     av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3419             is_output ? "Output" : "Input",
3420             index,
3421             is_output ? ic->oformat->name : ic->iformat->name,
3422             is_output ? "to" : "from", url);
3423     dump_metadata(NULL, ic->metadata, "  ");
3424     if (!is_output) {
3425         av_log(NULL, AV_LOG_INFO, "  Duration: ");
3426         if (ic->duration != AV_NOPTS_VALUE) {
3427             int hours, mins, secs, us;
3428             secs = ic->duration / AV_TIME_BASE;
3429             us = ic->duration % AV_TIME_BASE;
3430             mins = secs / 60;
3431             secs %= 60;
3432             hours = mins / 60;
3433             mins %= 60;
3434             av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3435                    (100 * us) / AV_TIME_BASE);
3436         } else {
3437             av_log(NULL, AV_LOG_INFO, "N/A");
3438         }
3439         if (ic->start_time != AV_NOPTS_VALUE) {
3440             int secs, us;
3441             av_log(NULL, AV_LOG_INFO, ", start: ");
3442             secs = ic->start_time / AV_TIME_BASE;
3443             us = abs(ic->start_time % AV_TIME_BASE);
3444             av_log(NULL, AV_LOG_INFO, "%d.%06d",
3445                    secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
3446         }
3447         av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3448         if (ic->bit_rate) {
3449             av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
3450         } else {
3451             av_log(NULL, AV_LOG_INFO, "N/A");
3452         }
3453         av_log(NULL, AV_LOG_INFO, "\n");
3454     }
3455     for (i = 0; i < ic->nb_chapters; i++) {
3456         AVChapter *ch = ic->chapters[i];
3457         av_log(NULL, AV_LOG_INFO, "    Chapter #%d.%d: ", index, i);
3458         av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
3459         av_log(NULL, AV_LOG_INFO, "end %f\n",   ch->end   * av_q2d(ch->time_base));
3460
3461         dump_metadata(NULL, ch->metadata, "    ");
3462     }
3463     if(ic->nb_programs) {
3464         int j, k, total = 0;
3465         for(j=0; j<ic->nb_programs; j++) {
3466             AVDictionaryEntry *name = av_dict_get(ic->programs[j]->metadata,
3467                                                   "name", NULL, 0);
3468             av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
3469                    name ? name->value : "");
3470             dump_metadata(NULL, ic->programs[j]->metadata, "    ");
3471             for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3472                 dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3473                 printed[ic->programs[j]->stream_index[k]] = 1;
3474             }
3475             total += ic->programs[j]->nb_stream_indexes;
3476         }
3477         if (total < ic->nb_streams)
3478             av_log(NULL, AV_LOG_INFO, "  No Program\n");
3479     }
3480     for(i=0;i<ic->nb_streams;i++)
3481         if (!printed[i])
3482             dump_stream_format(ic, i, index, is_output);
3483
3484     av_free(printed);
3485 }
3486
3487 int64_t av_gettime(void)
3488 {
3489     struct timeval tv;
3490     gettimeofday(&tv,NULL);
3491     return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
3492 }
3493
3494 uint64_t ff_ntp_time(void)
3495 {
3496   return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3497 }
3498
3499 #if FF_API_PARSE_DATE
3500 #include "libavutil/parseutils.h"
3501
3502 int64_t parse_date(const char *timestr, int duration)
3503 {
3504     int64_t timeval;
3505     av_parse_time(&timeval, timestr, duration);
3506     return timeval;
3507 }
3508 #endif
3509
3510 #if FF_API_FIND_INFO_TAG
3511 #include "libavutil/parseutils.h"
3512
3513 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
3514 {
3515     return av_find_info_tag(arg, arg_size, tag1, info);
3516 }
3517 #endif
3518
3519 int av_get_frame_filename(char *buf, int buf_size,
3520                           const char *path, int number)
3521 {
3522     const char *p;
3523     char *q, buf1[20], c;
3524     int nd, len, percentd_found;
3525
3526     q = buf;
3527     p = path;
3528     percentd_found = 0;
3529     for(;;) {
3530         c = *p++;
3531         if (c == '\0')
3532             break;
3533         if (c == '%') {
3534             do {
3535                 nd = 0;
3536                 while (isdigit(*p)) {
3537                     nd = nd * 10 + *p++ - '0';
3538                 }
3539                 c = *p++;
3540             } while (isdigit(c));
3541
3542             switch(c) {
3543             case '%':
3544                 goto addchar;
3545             case 'd':
3546                 if (percentd_found)
3547                     goto fail;
3548                 percentd_found = 1;
3549                 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3550                 len = strlen(buf1);
3551                 if ((q - buf + len) > buf_size - 1)
3552                     goto fail;
3553                 memcpy(q, buf1, len);
3554                 q += len;
3555                 break;
3556             default:
3557                 goto fail;
3558             }
3559         } else {
3560         addchar:
3561             if ((q - buf) < buf_size - 1)
3562                 *q++ = c;
3563         }
3564     }
3565     if (!percentd_found)
3566         goto fail;
3567     *q = '\0';
3568     return 0;
3569  fail:
3570     *q = '\0';
3571     return -1;
3572 }
3573
3574 static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3575 {
3576     int len, i, j, c;
3577 #undef fprintf
3578 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3579
3580     for(i=0;i<size;i+=16) {
3581         len = size - i;
3582         if (len > 16)
3583             len = 16;
3584         PRINT("%08x ", i);
3585         for(j=0;j<16;j++) {
3586             if (j < len)
3587                 PRINT(" %02x", buf[i+j]);
3588             else
3589                 PRINT("   ");
3590         }
3591         PRINT(" ");
3592         for(j=0;j<len;j++) {
3593             c = buf[i+j];
3594             if (c < ' ' || c > '~')
3595                 c = '.';
3596             PRINT("%c", c);
3597         }
3598         PRINT("\n");
3599     }
3600 #undef PRINT
3601 }
3602
3603 void av_hex_dump(FILE *f, uint8_t *buf, int size)
3604 {
3605     hex_dump_internal(NULL, f, 0, buf, size);
3606 }
3607
3608 void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3609 {
3610     hex_dump_internal(avcl, NULL, level, buf, size);
3611 }
3612
3613 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload, AVRational time_base)
3614 {
3615 #undef fprintf
3616 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3617     PRINT("stream #%d:\n", pkt->stream_index);
3618     PRINT("  keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
3619     PRINT("  duration=%0.3f\n", pkt->duration * av_q2d(time_base));
3620     /* DTS is _always_ valid after av_read_frame() */
3621     PRINT("  dts=");
3622     if (pkt->dts == AV_NOPTS_VALUE)
3623         PRINT("N/A");
3624     else
3625         PRINT("%0.3f", pkt->dts * av_q2d(time_base));
3626     /* PTS may not be known if B-frames are present. */
3627     PRINT("  pts=");
3628     if (pkt->pts == AV_NOPTS_VALUE)
3629         PRINT("N/A");
3630     else
3631         PRINT("%0.3f", pkt->pts * av_q2d(time_base));
3632     PRINT("\n");
3633     PRINT("  size=%d\n", pkt->size);
3634 #undef PRINT
3635     if (dump_payload)
3636         av_hex_dump(f, pkt->data, pkt->size);
3637 }
3638
3639 #if FF_API_PKT_DUMP
3640 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3641 {
3642     AVRational tb = { 1, AV_TIME_BASE };
3643     pkt_dump_internal(NULL, f, 0, pkt, dump_payload, tb);
3644 }
3645 #endif
3646
3647 void av_pkt_dump2(FILE *f, AVPacket *pkt, int dump_payload, AVStream *st)
3648 {
3649     pkt_dump_internal(NULL, f, 0, pkt, dump_payload, st->time_base);
3650 }
3651
3652 #if FF_API_PKT_DUMP
3653 void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3654 {
3655     AVRational tb = { 1, AV_TIME_BASE };
3656     pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, tb);
3657 }
3658 #endif
3659
3660 void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload,
3661                       AVStream *st)
3662 {
3663     pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, st->time_base);
3664 }
3665
3666 void av_url_split(char *proto, int proto_size,
3667                   char *authorization, int authorization_size,
3668                   char *hostname, int hostname_size,
3669                   int *port_ptr,
3670                   char *path, int path_size,
3671                   const char *url)
3672 {
3673     const char *p, *ls, *at, *col, *brk;
3674
3675     if (port_ptr)               *port_ptr = -1;
3676     if (proto_size > 0)         proto[0] = 0;
3677     if (authorization_size > 0) authorization[0] = 0;
3678     if (hostname_size > 0)      hostname[0] = 0;
3679     if (path_size > 0)          path[0] = 0;
3680
3681     /* parse protocol */
3682     if ((p = strchr(url, ':'))) {
3683         av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3684         p++; /* skip ':' */
3685         if (*p == '/') p++;
3686         if (*p == '/') p++;
3687     } else {
3688         /* no protocol means plain filename */
3689         av_strlcpy(path, url, path_size);
3690         return;
3691     }
3692
3693     /* separate path from hostname */
3694     ls = strchr(p, '/');
3695     if(!ls)
3696         ls = strchr(p, '?');
3697     if(ls)
3698         av_strlcpy(path, ls, path_size);
3699     else
3700         ls = &p[strlen(p)]; // XXX
3701
3702     /* the rest is hostname, use that to parse auth/port */
3703     if (ls != p) {
3704         /* authorization (user[:pass]@hostname) */
3705         if ((at = strchr(p, '@')) && at < ls) {
3706             av_strlcpy(authorization, p,
3707                        FFMIN(authorization_size, at + 1 - p));
3708             p = at + 1; /* skip '@' */
3709         }
3710
3711         if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3712             /* [host]:port */
3713             av_strlcpy(hostname, p + 1,
3714                        FFMIN(hostname_size, brk - p));
3715             if (brk[1] == ':' && port_ptr)
3716                 *port_ptr = atoi(brk + 2);
3717         } else if ((col = strchr(p, ':')) && col < ls) {
3718             av_strlcpy(hostname, p,
3719                        FFMIN(col + 1 - p, hostname_size));
3720             if (port_ptr) *port_ptr = atoi(col + 1);
3721         } else
3722             av_strlcpy(hostname, p,
3723                        FFMIN(ls + 1 - p, hostname_size));
3724     }
3725 }
3726
3727 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3728 {
3729     int i;
3730     static const char hex_table_uc[16] = { '0', '1', '2', '3',
3731                                            '4', '5', '6', '7',
3732                                            '8', '9', 'A', 'B',
3733                                            'C', 'D', 'E', 'F' };
3734     static const char hex_table_lc[16] = { '0', '1', '2', '3',
3735                                            '4', '5', '6', '7',
3736                                            '8', '9', 'a', 'b',
3737                                            'c', 'd', 'e', 'f' };
3738     const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3739
3740     for(i = 0; i < s; i++) {
3741         buff[i * 2]     = hex_table[src[i] >> 4];
3742         buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3743     }
3744
3745     return buff;
3746 }
3747
3748 int ff_hex_to_data(uint8_t *data, const char *p)
3749 {
3750     int c, len, v;
3751
3752     len = 0;
3753     v = 1;
3754     for (;;) {
3755         p += strspn(p, SPACE_CHARS);
3756         if (*p == '\0')
3757             break;
3758         c = toupper((unsigned char) *p++);
3759         if (c >= '0' && c <= '9')
3760             c = c - '0';
3761         else if (c >= 'A' && c <= 'F')
3762             c = c - 'A' + 10;
3763         else
3764             break;
3765         v = (v << 4) | c;
3766         if (v & 0x100) {
3767             if (data)
3768                 data[len] = v;
3769             len++;
3770             v = 1;
3771         }
3772     }
3773     return len;
3774 }
3775
3776 #if FF_API_SET_PTS_INFO
3777 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3778                      unsigned int pts_num, unsigned int pts_den)
3779 {
3780     avpriv_set_pts_info(s, pts_wrap_bits, pts_num, pts_den);
3781 }
3782 #endif
3783
3784 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
3785                          unsigned int pts_num, unsigned int pts_den)
3786 {
3787     AVRational new_tb;
3788     if(av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)){
3789         if(new_tb.num != pts_num)
3790             av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/new_tb.num);
3791     }else
3792         av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3793
3794     if(new_tb.num <= 0 || new_tb.den <= 0) {
3795         av_log(NULL, AV_LOG_ERROR, "Ignoring attempt to set invalid timebase for st:%d\n", s->index);
3796         return;
3797     }
3798     s->time_base = new_tb;
3799     s->pts_wrap_bits = pts_wrap_bits;
3800 }
3801
3802 int ff_url_join(char *str, int size, const char *proto,
3803                 const char *authorization, const char *hostname,
3804                 int port, const char *fmt, ...)
3805 {
3806 #if CONFIG_NETWORK
3807     struct addrinfo hints, *ai;
3808 #endif
3809
3810     str[0] = '\0';
3811     if (proto)
3812         av_strlcatf(str, size, "%s://", proto);
3813     if (authorization && authorization[0])
3814         av_strlcatf(str, size, "%s@", authorization);
3815 #if CONFIG_NETWORK && defined(AF_INET6)
3816     /* Determine if hostname is a numerical IPv6 address,
3817      * properly escape it within [] in that case. */
3818     memset(&hints, 0, sizeof(hints));
3819     hints.ai_flags = AI_NUMERICHOST;
3820     if (!getaddrinfo(hostname, NULL, &hints, &ai)) {
3821         if (ai->ai_family == AF_INET6) {
3822             av_strlcat(str, "[", size);
3823             av_strlcat(str, hostname, size);
3824             av_strlcat(str, "]", size);
3825         } else {
3826             av_strlcat(str, hostname, size);
3827         }
3828         freeaddrinfo(ai);
3829     } else
3830 #endif
3831         /* Not an IPv6 address, just output the plain string. */
3832         av_strlcat(str, hostname, size);
3833
3834     if (port >= 0)
3835         av_strlcatf(str, size, ":%d", port);
3836     if (fmt) {
3837         va_list vl;
3838         int len = strlen(str);
3839
3840         va_start(vl, fmt);
3841         vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);
3842         va_end(vl);
3843     }
3844     return strlen(str);
3845 }
3846
3847 int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
3848                      AVFormatContext *src)
3849 {
3850     AVPacket local_pkt;
3851
3852     local_pkt = *pkt;
3853     local_pkt.stream_index = dst_stream;
3854     if (pkt->pts != AV_NOPTS_VALUE)
3855         local_pkt.pts = av_rescale_q(pkt->pts,
3856                                      src->streams[pkt->stream_index]->time_base,
3857                                      dst->streams[dst_stream]->time_base);
3858     if (pkt->dts != AV_NOPTS_VALUE)
3859         local_pkt.dts = av_rescale_q(pkt->dts,
3860                                      src->streams[pkt->stream_index]->time_base,
3861                                      dst->streams[dst_stream]->time_base);
3862     return av_write_frame(dst, &local_pkt);
3863 }
3864
3865 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
3866                         void *context)
3867 {
3868     const char *ptr = str;
3869
3870     /* Parse key=value pairs. */
3871     for (;;) {
3872         const char *key;
3873         char *dest = NULL, *dest_end;
3874         int key_len, dest_len = 0;
3875
3876         /* Skip whitespace and potential commas. */
3877         while (*ptr && (isspace(*ptr) || *ptr == ','))
3878             ptr++;
3879         if (!*ptr)
3880             break;
3881
3882         key = ptr;
3883
3884         if (!(ptr = strchr(key, '=')))
3885             break;
3886         ptr++;
3887         key_len = ptr - key;
3888
3889         callback_get_buf(context, key, key_len, &dest, &dest_len);
3890         dest_end = dest + dest_len - 1;
3891
3892         if (*ptr == '\"') {
3893             ptr++;
3894             while (*ptr && *ptr != '\"') {
3895                 if (*ptr == '\\') {
3896                     if (!ptr[1])
3897                         break;
3898                     if (dest && dest < dest_end)
3899                         *dest++ = ptr[1];
3900                     ptr += 2;
3901                 } else {
3902                     if (dest && dest < dest_end)
3903                         *dest++ = *ptr;
3904                     ptr++;
3905                 }
3906             }
3907             if (*ptr == '\"')
3908                 ptr++;
3909         } else {
3910             for (; *ptr && !(isspace(*ptr) || *ptr == ','); ptr++)
3911                 if (dest && dest < dest_end)
3912                     *dest++ = *ptr;
3913         }
3914         if (dest)
3915             *dest = 0;
3916     }
3917 }
3918
3919 int ff_find_stream_index(AVFormatContext *s, int id)
3920 {
3921     int i;
3922     for (i = 0; i < s->nb_streams; i++) {
3923         if (s->streams[i]->id == id)
3924             return i;
3925     }
3926     return -1;
3927 }
3928
3929 void ff_make_absolute_url(char *buf, int size, const char *base,
3930                           const char *rel)
3931 {
3932     char *sep;
3933     /* Absolute path, relative to the current server */
3934     if (base && strstr(base, "://") && rel[0] == '/') {
3935         if (base != buf)
3936             av_strlcpy(buf, base, size);
3937         sep = strstr(buf, "://");
3938         if (sep) {
3939             sep += 3;
3940             sep = strchr(sep, '/');
3941             if (sep)
3942                 *sep = '\0';
3943         }
3944         av_strlcat(buf, rel, size);
3945         return;
3946     }
3947     /* If rel actually is an absolute url, just copy it */
3948     if (!base || strstr(rel, "://") || rel[0] == '/') {
3949         av_strlcpy(buf, rel, size);
3950         return;
3951     }
3952     if (base != buf)
3953         av_strlcpy(buf, base, size);
3954     /* Remove the file name from the base url */
3955     sep = strrchr(buf, '/');
3956     if (sep)
3957         sep[1] = '\0';
3958     else
3959         buf[0] = '\0';
3960     while (av_strstart(rel, "../", NULL) && sep) {
3961         /* Remove the path delimiter at the end */
3962         sep[0] = '\0';
3963         sep = strrchr(buf, '/');
3964         /* If the next directory name to pop off is "..", break here */
3965         if (!strcmp(sep ? &sep[1] : buf, "..")) {
3966             /* Readd the slash we just removed */
3967             av_strlcat(buf, "/", size);
3968             break;
3969         }
3970         /* Cut off the directory name */
3971         if (sep)
3972             sep[1] = '\0';
3973         else
3974             buf[0] = '\0';
3975         rel += 3;
3976     }
3977     av_strlcat(buf, rel, size);
3978 }
3979
3980 int64_t ff_iso8601_to_unix_time(const char *datestr)
3981 {
3982 #if HAVE_STRPTIME
3983     struct tm time1 = {0}, time2 = {0};
3984     char *ret1, *ret2;
3985     ret1 = strptime(datestr, "%Y - %m - %d %T", &time1);
3986     ret2 = strptime(datestr, "%Y - %m - %dT%T", &time2);
3987     if (ret2 && !ret1)
3988         return av_timegm(&time2);
3989     else
3990         return av_timegm(&time1);
3991 #else
3992     av_log(NULL, AV_LOG_WARNING, "strptime() unavailable on this system, cannot convert "
3993                                  "the date string.\n");
3994     return 0;
3995 #endif
3996 }
3997
3998 int avformat_query_codec(AVOutputFormat *ofmt, enum CodecID codec_id, int std_compliance)
3999 {
4000     if (ofmt) {
4001         if (ofmt->query_codec)
4002             return ofmt->query_codec(codec_id, std_compliance);
4003         else if (ofmt->codec_tag)
4004             return !!av_codec_get_tag(ofmt->codec_tag, codec_id);
4005         else if (codec_id == ofmt->video_codec || codec_id == ofmt->audio_codec ||
4006                  codec_id == ofmt->subtitle_codec)
4007             return 1;
4008     }
4009     return AVERROR_PATCHWELCOME;
4010 }
4011
4012 int avformat_network_init(void)
4013 {
4014 #if CONFIG_NETWORK
4015     int ret;
4016     ff_network_inited_globally = 1;
4017     if ((ret = ff_network_init()) < 0)
4018         return ret;
4019     ff_tls_init();
4020 #endif
4021     return 0;
4022 }
4023
4024 int avformat_network_deinit(void)
4025 {
4026 #if CONFIG_NETWORK
4027     ff_network_close();
4028     ff_tls_deinit();
4029 #endif
4030     return 0;
4031 }
4032
4033 int ff_add_param_change(AVPacket *pkt, int32_t channels,
4034                         uint64_t channel_layout, int32_t sample_rate,
4035                         int32_t width, int32_t height)
4036 {
4037     uint32_t flags = 0;
4038     int size = 4;
4039     uint8_t *data;
4040     if (!pkt)
4041         return AVERROR(EINVAL);
4042     if (channels) {
4043         size += 4;
4044         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
4045     }
4046     if (channel_layout) {
4047         size += 8;
4048         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
4049     }
4050     if (sample_rate) {
4051         size += 4;
4052         flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
4053     }
4054     if (width || height) {
4055         size += 8;
4056         flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
4057     }
4058     data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
4059     if (!data)
4060         return AVERROR(ENOMEM);
4061     bytestream_put_le32(&data, flags);
4062     if (channels)
4063         bytestream_put_le32(&data, channels);
4064     if (channel_layout)
4065         bytestream_put_le64(&data, channel_layout);
4066     if (sample_rate)
4067         bytestream_put_le32(&data, sample_rate);
4068     if (width || height) {
4069         bytestream_put_le32(&data, width);
4070         bytestream_put_le32(&data, height);
4071     }
4072     return 0;
4073 }