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