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

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