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