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