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