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         AVDictionary *thread_opt = NULL;
2248
2249         codec = avcodec_find_decoder(st->codec->codec_id);
2250         if (!codec)
2251             return -1;
2252
2253         /* force thread count to 1 since the h264 decoder will not extract SPS
2254          *  and PPS to extradata during multi-threaded decoding */
2255         av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
2256         ret = avcodec_open2(st->codec, codec, options ? options : &thread_opt);
2257         if (!options)
2258             av_dict_free(&thread_opt);
2259         if (ret < 0)
2260             return ret;
2261     }
2262
2263     while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
2264            ret >= 0 &&
2265            (!has_codec_parameters(st->codec)  ||
2266            !has_decode_delay_been_guessed(st) ||
2267            (!st->codec_info_nb_frames && st->codec->codec->capabilities & CODEC_CAP_CHANNEL_CONF))) {
2268         got_picture = 0;
2269         avcodec_get_frame_defaults(&picture);
2270         switch(st->codec->codec_type) {
2271         case AVMEDIA_TYPE_VIDEO:
2272             ret = avcodec_decode_video2(st->codec, &picture,
2273                                         &got_picture, &pkt);
2274             break;
2275         case AVMEDIA_TYPE_AUDIO:
2276             ret = avcodec_decode_audio4(st->codec, &picture, &got_picture, &pkt);
2277             break;
2278         default:
2279             break;
2280         }
2281         if (ret >= 0) {
2282             if (got_picture)
2283                 st->info->nb_decoded_frames++;
2284             pkt.data += ret;
2285             pkt.size -= ret;
2286         }
2287     }
2288     if(!pkt.data && !got_picture)
2289         return -1;
2290     return ret;
2291 }
2292
2293 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum CodecID id)
2294 {
2295     while (tags->id != CODEC_ID_NONE) {
2296         if (tags->id == id)
2297             return tags->tag;
2298         tags++;
2299     }
2300     return 0;
2301 }
2302
2303 enum CodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2304 {
2305     int i;
2306     for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
2307         if(tag == tags[i].tag)
2308             return tags[i].id;
2309     }
2310     for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
2311         if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
2312             return tags[i].id;
2313     }
2314     return CODEC_ID_NONE;
2315 }
2316
2317 unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum CodecID id)
2318 {
2319     int i;
2320     for(i=0; tags && tags[i]; i++){
2321         int tag= ff_codec_get_tag(tags[i], id);
2322         if(tag) return tag;
2323     }
2324     return 0;
2325 }
2326
2327 enum CodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
2328 {
2329     int i;
2330     for(i=0; tags && tags[i]; i++){
2331         enum CodecID id= ff_codec_get_id(tags[i], tag);
2332         if(id!=CODEC_ID_NONE) return id;
2333     }
2334     return CODEC_ID_NONE;
2335 }
2336
2337 static void compute_chapters_end(AVFormatContext *s)
2338 {
2339     unsigned int i, j;
2340     int64_t max_time = s->duration + ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
2341
2342     for (i = 0; i < s->nb_chapters; i++)
2343         if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2344             AVChapter *ch = s->chapters[i];
2345             int64_t   end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q, ch->time_base)
2346                                      : INT64_MAX;
2347
2348             for (j = 0; j < s->nb_chapters; j++) {
2349                 AVChapter *ch1 = s->chapters[j];
2350                 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base, ch->time_base);
2351                 if (j != i && next_start > ch->start && next_start < end)
2352                     end = next_start;
2353             }
2354             ch->end = (end == INT64_MAX) ? ch->start : end;
2355         }
2356 }
2357
2358 static int get_std_framerate(int i){
2359     if(i<60*12) return i*1001;
2360     else        return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
2361 }
2362
2363 /*
2364  * Is the time base unreliable.
2365  * This is a heuristic to balance between quick acceptance of the values in
2366  * the headers vs. some extra checks.
2367  * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2368  * MPEG-2 commonly misuses field repeat flags to store different framerates.
2369  * And there are "variable" fps files this needs to detect as well.
2370  */
2371 static int tb_unreliable(AVCodecContext *c){
2372     if(   c->time_base.den >= 101L*c->time_base.num
2373        || c->time_base.den <    5L*c->time_base.num
2374 /*       || c->codec_tag == AV_RL32("DIVX")
2375        || c->codec_tag == AV_RL32("XVID")*/
2376        || c->codec_id == CODEC_ID_MPEG2VIDEO
2377        || c->codec_id == CODEC_ID_H264
2378        )
2379         return 1;
2380     return 0;
2381 }
2382
2383 #if FF_API_FORMAT_PARAMETERS
2384 int av_find_stream_info(AVFormatContext *ic)
2385 {
2386     return avformat_find_stream_info(ic, NULL);
2387 }
2388 #endif
2389
2390 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
2391 {
2392     int i, count, ret, read_size, j;
2393     AVStream *st;
2394     AVPacket pkt1, *pkt;
2395     int64_t old_offset = avio_tell(ic->pb);
2396     int orig_nb_streams = ic->nb_streams;        // new streams might appear, no options for those
2397     int flush_codecs = 1;
2398
2399     for(i=0;i<ic->nb_streams;i++) {
2400         AVCodec *codec;
2401         AVDictionary *thread_opt = NULL;
2402         st = ic->streams[i];
2403
2404         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2405             st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2406 /*            if(!st->time_base.num)
2407                 st->time_base= */
2408             if(!st->codec->time_base.num)
2409                 st->codec->time_base= st->time_base;
2410         }
2411         //only for the split stuff
2412         if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
2413             st->parser = av_parser_init(st->codec->codec_id);
2414             if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
2415                 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2416             }
2417         }
2418         assert(!st->codec->codec);
2419         codec = avcodec_find_decoder(st->codec->codec_id);
2420
2421         /* force thread count to 1 since the h264 decoder will not extract SPS
2422          *  and PPS to extradata during multi-threaded decoding */
2423         av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
2424
2425         /* Ensure that subtitle_header is properly set. */
2426         if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
2427             && codec && !st->codec->codec)
2428             avcodec_open2(st->codec, codec, options ? &options[i]
2429                               : &thread_opt);
2430
2431         //try to just open decoders, in case this is enough to get parameters
2432         if(!has_codec_parameters(st->codec)){
2433             if (codec && !st->codec->codec)
2434                 avcodec_open2(st->codec, codec, options ? &options[i]
2435                               : &thread_opt);
2436         }
2437         if (!options)
2438             av_dict_free(&thread_opt);
2439     }
2440
2441     for (i=0; i<ic->nb_streams; i++) {
2442         ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
2443     }
2444
2445     count = 0;
2446     read_size = 0;
2447     for(;;) {
2448         if (ff_check_interrupt(&ic->interrupt_callback)){
2449             ret= AVERROR_EXIT;
2450             av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2451             break;
2452         }
2453
2454         /* check if one codec still needs to be handled */
2455         for(i=0;i<ic->nb_streams;i++) {
2456             int fps_analyze_framecount = 20;
2457
2458             st = ic->streams[i];
2459             if (!has_codec_parameters(st->codec))
2460                 break;
2461             /* if the timebase is coarse (like the usual millisecond precision
2462                of mkv), we need to analyze more frames to reliably arrive at
2463                the correct fps */
2464             if (av_q2d(st->time_base) > 0.0005)
2465                 fps_analyze_framecount *= 2;
2466             if (ic->fps_probe_size >= 0)
2467                 fps_analyze_framecount = ic->fps_probe_size;
2468             /* variable fps and no guess at the real fps */
2469             if(   tb_unreliable(st->codec) && !(st->r_frame_rate.num && st->avg_frame_rate.num)
2470                && st->info->duration_count < fps_analyze_framecount
2471                && st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2472                 break;
2473             if(st->parser && st->parser->parser->split && !st->codec->extradata)
2474                 break;
2475             if(st->first_dts == AV_NOPTS_VALUE && (st->codec->codec_type == AVMEDIA_TYPE_VIDEO || st->codec->codec_type == AVMEDIA_TYPE_AUDIO))
2476                 break;
2477         }
2478         if (i == ic->nb_streams) {
2479             /* NOTE: if the format has no header, then we need to read
2480                some packets to get most of the streams, so we cannot
2481                stop here */
2482             if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2483                 /* if we found the info for all the codecs, we can stop */
2484                 ret = count;
2485                 av_log(ic, AV_LOG_DEBUG, "All info found\n");
2486                 flush_codecs = 0;
2487                 break;
2488             }
2489         }
2490         /* we did not get all the codec info, but we read too much data */
2491         if (read_size >= ic->probesize) {
2492             ret = count;
2493             av_log(ic, AV_LOG_DEBUG, "Probe buffer size limit %d reached\n", ic->probesize);
2494             break;
2495         }
2496
2497         /* NOTE: a new stream can be added there if no header in file
2498            (AVFMTCTX_NOHEADER) */
2499         ret = read_frame_internal(ic, &pkt1);
2500         if (ret == AVERROR(EAGAIN))
2501             continue;
2502
2503         if (ret < 0) {
2504             /* EOF or error*/
2505             break;
2506         }
2507
2508         pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2509         if ((ret = av_dup_packet(pkt)) < 0)
2510             goto find_stream_info_err;
2511
2512         read_size += pkt->size;
2513
2514         st = ic->streams[pkt->stream_index];
2515         if (st->codec_info_nb_frames>1) {
2516             int64_t t=0;
2517             if (st->time_base.den > 0)
2518                 t = av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
2519             if (st->avg_frame_rate.num > 0)
2520                 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));
2521
2522             if (t >= ic->max_analyze_duration) {
2523                 av_log(ic, AV_LOG_WARNING, "max_analyze_duration %d reached at %"PRId64"\n", ic->max_analyze_duration, t);
2524                 break;
2525             }
2526             st->info->codec_info_duration += pkt->duration;
2527         }
2528         {
2529             int64_t last = st->info->last_dts;
2530
2531             if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && pkt->dts > last){
2532                 double dts= pkt->dts * av_q2d(st->time_base);
2533                 int64_t duration= pkt->dts - last;
2534
2535 //                 if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2536 //                     av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
2537                 for (i=1; i<FF_ARRAY_ELEMS(st->info->duration_error[0][0]); i++) {
2538                     int framerate= get_std_framerate(i);
2539                     double sdts= dts*framerate/(1001*12);
2540                     for(j=0; j<2; j++){
2541                         int ticks= lrintf(sdts+j*0.5);
2542                         double error= sdts - ticks + j*0.5;
2543                         st->info->duration_error[j][0][i] += error;
2544                         st->info->duration_error[j][1][i] += error*error;
2545                     }
2546                 }
2547                 st->info->duration_count++;
2548                 // ignore the first 4 values, they might have some random jitter
2549                 if (st->info->duration_count > 3)
2550                     st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2551             }
2552             if (last == AV_NOPTS_VALUE || st->info->duration_count <= 1)
2553                 st->info->last_dts = pkt->dts;
2554         }
2555         if(st->parser && st->parser->parser->split && !st->codec->extradata){
2556             int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2557             if (i > 0 && i < FF_MAX_EXTRADATA_SIZE) {
2558                 st->codec->extradata_size= i;
2559                 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2560                 if (!st->codec->extradata)
2561                     return AVERROR(ENOMEM);
2562                 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2563                 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2564             }
2565         }
2566
2567         /* if still no information, we try to open the codec and to
2568            decompress the frame. We try to avoid that in most cases as
2569            it takes longer and uses more memory. For MPEG-4, we need to
2570            decompress for QuickTime.
2571
2572            If CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
2573            least one frame of codec data, this makes sure the codec initializes
2574            the channel configuration and does not only trust the values from the container.
2575         */
2576         try_decode_frame(st, pkt, (options && i < orig_nb_streams ) ? &options[i] : NULL);
2577
2578         st->codec_info_nb_frames++;
2579         count++;
2580     }
2581
2582     if (flush_codecs) {
2583         AVPacket empty_pkt = { 0 };
2584         int err;
2585         av_init_packet(&empty_pkt);
2586
2587         ret = -1; /* we could not have all the codec parameters before EOF */
2588         for(i=0;i<ic->nb_streams;i++) {
2589             st = ic->streams[i];
2590
2591             /* flush the decoders */
2592             while ((err = try_decode_frame(st, &empty_pkt,
2593                                            (options && i < orig_nb_streams) ?
2594                                             &options[i] : NULL)) >= 0)
2595                 if (has_codec_parameters(st->codec))
2596                     break;
2597
2598             if (!has_codec_parameters(st->codec)){
2599                 char buf[256];
2600                 avcodec_string(buf, sizeof(buf), st->codec, 0);
2601                 av_log(ic, AV_LOG_WARNING, "Could not find codec parameters (%s)\n", buf);
2602             } else {
2603                 ret = 0;
2604             }
2605         }
2606     }
2607
2608     // close codecs which were opened in try_decode_frame()
2609     for(i=0;i<ic->nb_streams;i++) {
2610         st = ic->streams[i];
2611         if(st->codec->codec)
2612             avcodec_close(st->codec);
2613     }
2614     for(i=0;i<ic->nb_streams;i++) {
2615         st = ic->streams[i];
2616         if (st->codec_info_nb_frames>2 && !st->avg_frame_rate.num && st->info->codec_info_duration)
2617             av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2618                      (st->codec_info_nb_frames-2)*(int64_t)st->time_base.den,
2619                       st->info->codec_info_duration*(int64_t)st->time_base.num, 60000);
2620         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2621             if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample){
2622                 uint32_t tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2623                 if(ff_find_pix_fmt(ff_raw_pix_fmt_tags, tag) == st->codec->pix_fmt)
2624                     st->codec->codec_tag= tag;
2625             }
2626
2627             // the check for tb_unreliable() is not completely correct, since this is not about handling
2628             // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2629             // ipmovie.c produces.
2630             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)
2631                 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);
2632             if (st->info->duration_count && !st->r_frame_rate.num
2633                && tb_unreliable(st->codec) /*&&
2634                //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2635                st->time_base.num*duration_sum[i]/st->info->duration_count*101LL > st->time_base.den*/){
2636                 int num = 0;
2637                 double best_error= 0.01;
2638
2639                 for (j=1; j<FF_ARRAY_ELEMS(st->info->duration_error[0][0]); j++) {
2640                     int k;
2641
2642                     if(st->info->codec_info_duration && st->info->codec_info_duration*av_q2d(st->time_base) < (1001*12.0)/get_std_framerate(j))
2643                         continue;
2644                     if(!st->info->codec_info_duration && 1.0 < (1001*12.0)/get_std_framerate(j))
2645                         continue;
2646                     for(k=0; k<2; k++){
2647                         int n= st->info->duration_count;
2648                         double a= st->info->duration_error[k][0][j] / n;
2649                         double error= st->info->duration_error[k][1][j]/n - a*a;
2650
2651                         if(error < best_error && best_error> 0.000000001){
2652                             best_error= error;
2653                             num = get_std_framerate(j);
2654                         }
2655                         if(error < 0.02)
2656                             av_log(NULL, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
2657                     }
2658                 }
2659                 // do not increase frame rate by more than 1 % in order to match a standard rate.
2660                 if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
2661                     av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2662             }
2663
2664             if (!st->r_frame_rate.num){
2665                 if(    st->codec->time_base.den * (int64_t)st->time_base.num
2666                     <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
2667                     st->r_frame_rate.num = st->codec->time_base.den;
2668                     st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
2669                 }else{
2670                     st->r_frame_rate.num = st->time_base.den;
2671                     st->r_frame_rate.den = st->time_base.num;
2672                 }
2673             }
2674         }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2675             if(!st->codec->bits_per_coded_sample)
2676                 st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2677             // set stream disposition based on audio service type
2678             switch (st->codec->audio_service_type) {
2679             case AV_AUDIO_SERVICE_TYPE_EFFECTS:
2680                 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;    break;
2681             case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
2682                 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;  break;
2683             case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
2684                 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED; break;
2685             case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
2686                 st->disposition = AV_DISPOSITION_COMMENT;          break;
2687             case AV_AUDIO_SERVICE_TYPE_KARAOKE:
2688                 st->disposition = AV_DISPOSITION_KARAOKE;          break;
2689             }
2690         }
2691     }
2692
2693     estimate_timings(ic, old_offset);
2694
2695     compute_chapters_end(ic);
2696
2697 #if 0
2698     /* correct DTS for B-frame streams with no timestamps */
2699     for(i=0;i<ic->nb_streams;i++) {
2700         st = ic->streams[i];
2701         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2702             if(b-frames){
2703                 ppktl = &ic->packet_buffer;
2704                 while(ppkt1){
2705                     if(ppkt1->stream_index != i)
2706                         continue;
2707                     if(ppkt1->pkt->dts < 0)
2708                         break;
2709                     if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2710                         break;
2711                     ppkt1->pkt->dts -= delta;
2712                     ppkt1= ppkt1->next;
2713                 }
2714                 if(ppkt1)
2715                     continue;
2716                 st->cur_dts -= delta;
2717             }
2718         }
2719     }
2720 #endif
2721
2722  find_stream_info_err:
2723     for (i=0; i < ic->nb_streams; i++) {
2724         if (ic->streams[i]->codec)
2725             ic->streams[i]->codec->thread_count = 0;
2726         av_freep(&ic->streams[i]->info);
2727     }
2728     return ret;
2729 }
2730
2731 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
2732 {
2733     int i, j;
2734
2735     for (i = 0; i < ic->nb_programs; i++) {
2736         if (ic->programs[i] == last) {
2737             last = NULL;
2738         } else {
2739             if (!last)
2740                 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
2741                     if (ic->programs[i]->stream_index[j] == s)
2742                         return ic->programs[i];
2743         }
2744     }
2745     return NULL;
2746 }
2747
2748 int av_find_best_stream(AVFormatContext *ic,
2749                         enum AVMediaType type,
2750                         int wanted_stream_nb,
2751                         int related_stream,
2752                         AVCodec **decoder_ret,
2753                         int flags)
2754 {
2755     int i, nb_streams = ic->nb_streams;
2756     int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1;
2757     unsigned *program = NULL;
2758     AVCodec *decoder = NULL, *best_decoder = NULL;
2759
2760     if (related_stream >= 0 && wanted_stream_nb < 0) {
2761         AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
2762         if (p) {
2763             program = p->stream_index;
2764             nb_streams = p->nb_stream_indexes;
2765         }
2766     }
2767     for (i = 0; i < nb_streams; i++) {
2768         int real_stream_index = program ? program[i] : i;
2769         AVStream *st = ic->streams[real_stream_index];
2770         AVCodecContext *avctx = st->codec;
2771         if (avctx->codec_type != type)
2772             continue;
2773         if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
2774             continue;
2775         if (st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED|AV_DISPOSITION_VISUAL_IMPAIRED))
2776             continue;
2777         if (decoder_ret) {
2778             decoder = avcodec_find_decoder(st->codec->codec_id);
2779             if (!decoder) {
2780                 if (ret < 0)
2781                     ret = AVERROR_DECODER_NOT_FOUND;
2782                 continue;
2783             }
2784         }
2785         if (best_count >= st->codec_info_nb_frames)
2786             continue;
2787         best_count = st->codec_info_nb_frames;
2788         ret = real_stream_index;
2789         best_decoder = decoder;
2790         if (program && i == nb_streams - 1 && ret < 0) {
2791             program = NULL;
2792             nb_streams = ic->nb_streams;
2793             i = 0; /* no related stream found, try again with everything */
2794         }
2795     }
2796     if (decoder_ret)
2797         *decoder_ret = best_decoder;
2798     return ret;
2799 }
2800
2801 /*******************************************************/
2802
2803 int av_read_play(AVFormatContext *s)
2804 {
2805     if (s->iformat->read_play)
2806         return s->iformat->read_play(s);
2807     if (s->pb)
2808         return avio_pause(s->pb, 0);
2809     return AVERROR(ENOSYS);
2810 }
2811
2812 int av_read_pause(AVFormatContext *s)
2813 {
2814     if (s->iformat->read_pause)
2815         return s->iformat->read_pause(s);
2816     if (s->pb)
2817         return avio_pause(s->pb, 1);
2818     return AVERROR(ENOSYS);
2819 }
2820
2821 #if FF_API_FORMAT_PARAMETERS
2822 void av_close_input_stream(AVFormatContext *s)
2823 {
2824     flush_packet_queue(s);
2825     if (s->iformat->read_close)
2826         s->iformat->read_close(s);
2827     avformat_free_context(s);
2828 }
2829 #endif
2830
2831 void avformat_free_context(AVFormatContext *s)
2832 {
2833     int i;
2834     AVStream *st;
2835
2836     av_opt_free(s);
2837     if (s->iformat && s->iformat->priv_class && s->priv_data)
2838         av_opt_free(s->priv_data);
2839
2840     for(i=0;i<s->nb_streams;i++) {
2841         /* free all data in a stream component */
2842         st = s->streams[i];
2843         if (st->parser) {
2844             av_parser_close(st->parser);
2845             av_free_packet(&st->cur_pkt);
2846         }
2847         av_dict_free(&st->metadata);
2848         av_freep(&st->index_entries);
2849         av_freep(&st->codec->extradata);
2850         av_freep(&st->codec->subtitle_header);
2851         av_freep(&st->codec);
2852         av_freep(&st->priv_data);
2853         av_freep(&st->info);
2854         av_freep(&st);
2855     }
2856     for(i=s->nb_programs-1; i>=0; i--) {
2857         av_dict_free(&s->programs[i]->metadata);
2858         av_freep(&s->programs[i]->stream_index);
2859         av_freep(&s->programs[i]);
2860     }
2861     av_freep(&s->programs);
2862     av_freep(&s->priv_data);
2863     while(s->nb_chapters--) {
2864         av_dict_free(&s->chapters[s->nb_chapters]->metadata);
2865         av_freep(&s->chapters[s->nb_chapters]);
2866     }
2867     av_freep(&s->chapters);
2868     av_dict_free(&s->metadata);
2869     av_freep(&s->streams);
2870     av_free(s);
2871 }
2872
2873 #if FF_API_CLOSE_INPUT_FILE
2874 void av_close_input_file(AVFormatContext *s)
2875 {
2876     avformat_close_input(&s);
2877 }
2878 #endif
2879
2880 void avformat_close_input(AVFormatContext **ps)
2881 {
2882     AVFormatContext *s = *ps;
2883     AVIOContext *pb = (s->iformat && (s->iformat->flags & AVFMT_NOFILE)) || (s->flags & AVFMT_FLAG_CUSTOM_IO) ?
2884                        NULL : s->pb;
2885     flush_packet_queue(s);
2886     if (s->iformat && (s->iformat->read_close))
2887         s->iformat->read_close(s);
2888     avformat_free_context(s);
2889     *ps = NULL;
2890     if (pb)
2891         avio_close(pb);
2892 }
2893
2894 #if FF_API_NEW_STREAM
2895 AVStream *av_new_stream(AVFormatContext *s, int id)
2896 {
2897     AVStream *st = avformat_new_stream(s, NULL);
2898     if (st)
2899         st->id = id;
2900     return st;
2901 }
2902 #endif
2903
2904 AVStream *avformat_new_stream(AVFormatContext *s, AVCodec *c)
2905 {
2906     AVStream *st;
2907     int i;
2908     AVStream **streams;
2909
2910     if (s->nb_streams >= INT_MAX/sizeof(*streams))
2911         return NULL;
2912     streams = av_realloc(s->streams, (s->nb_streams + 1) * sizeof(*streams));
2913     if (!streams)
2914         return NULL;
2915     s->streams = streams;
2916
2917     st = av_mallocz(sizeof(AVStream));
2918     if (!st)
2919         return NULL;
2920     if (!(st->info = av_mallocz(sizeof(*st->info)))) {
2921         av_free(st);
2922         return NULL;
2923     }
2924
2925     st->codec = avcodec_alloc_context3(c);
2926     if (s->iformat) {
2927         /* no default bitrate if decoding */
2928         st->codec->bit_rate = 0;
2929     }
2930     st->index = s->nb_streams;
2931     st->start_time = AV_NOPTS_VALUE;
2932     st->duration = AV_NOPTS_VALUE;
2933         /* we set the current DTS to 0 so that formats without any timestamps
2934            but durations get some timestamps, formats with some unknown
2935            timestamps have their first few packets buffered and the
2936            timestamps corrected before they are returned to the user */
2937     st->cur_dts = 0;
2938     st->first_dts = AV_NOPTS_VALUE;
2939     st->probe_packets = MAX_PROBE_PACKETS;
2940
2941     /* default pts setting is MPEG-like */
2942     avpriv_set_pts_info(st, 33, 1, 90000);
2943     st->last_IP_pts = AV_NOPTS_VALUE;
2944     for(i=0; i<MAX_REORDER_DELAY+1; i++)
2945         st->pts_buffer[i]= AV_NOPTS_VALUE;
2946     st->reference_dts = AV_NOPTS_VALUE;
2947
2948     st->sample_aspect_ratio = (AVRational){0,1};
2949
2950     s->streams[s->nb_streams++] = st;
2951     return st;
2952 }
2953
2954 AVProgram *av_new_program(AVFormatContext *ac, int id)
2955 {
2956     AVProgram *program=NULL;
2957     int i;
2958
2959     av_dlog(ac, "new_program: id=0x%04x\n", id);
2960
2961     for(i=0; i<ac->nb_programs; i++)
2962         if(ac->programs[i]->id == id)
2963             program = ac->programs[i];
2964
2965     if(!program){
2966         program = av_mallocz(sizeof(AVProgram));
2967         if (!program)
2968             return NULL;
2969         dynarray_add(&ac->programs, &ac->nb_programs, program);
2970         program->discard = AVDISCARD_NONE;
2971     }
2972     program->id = id;
2973
2974     return program;
2975 }
2976
2977 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2978 {
2979     AVChapter *chapter = NULL;
2980     int i;
2981
2982     for(i=0; i<s->nb_chapters; i++)
2983         if(s->chapters[i]->id == id)
2984             chapter = s->chapters[i];
2985
2986     if(!chapter){
2987         chapter= av_mallocz(sizeof(AVChapter));
2988         if(!chapter)
2989             return NULL;
2990         dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2991     }
2992     av_dict_set(&chapter->metadata, "title", title, 0);
2993     chapter->id    = id;
2994     chapter->time_base= time_base;
2995     chapter->start = start;
2996     chapter->end   = end;
2997
2998     return chapter;
2999 }
3000
3001 /************************************************************/
3002 /* output media file */
3003
3004 #if FF_API_FORMAT_PARAMETERS
3005 int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
3006 {
3007     if (s->oformat->priv_data_size > 0) {
3008         s->priv_data = av_mallocz(s->oformat->priv_data_size);
3009         if (!s->priv_data)
3010             return AVERROR(ENOMEM);
3011         if (s->oformat->priv_class) {
3012             *(const AVClass**)s->priv_data= s->oformat->priv_class;
3013             av_opt_set_defaults(s->priv_data);
3014         }
3015     } else
3016         s->priv_data = NULL;
3017
3018     return 0;
3019 }
3020 #endif
3021
3022 int avformat_alloc_output_context2(AVFormatContext **avctx, AVOutputFormat *oformat,
3023                                    const char *format, const char *filename)
3024 {
3025     AVFormatContext *s = avformat_alloc_context();
3026     int ret = 0;
3027
3028     *avctx = NULL;
3029     if (!s)
3030         goto nomem;
3031
3032     if (!oformat) {
3033         if (format) {
3034             oformat = av_guess_format(format, NULL, NULL);
3035             if (!oformat) {
3036                 av_log(s, AV_LOG_ERROR, "Requested output format '%s' is not a suitable output format\n", format);
3037                 ret = AVERROR(EINVAL);
3038                 goto error;
3039             }
3040         } else {
3041             oformat = av_guess_format(NULL, filename, NULL);
3042             if (!oformat) {
3043                 ret = AVERROR(EINVAL);
3044                 av_log(s, AV_LOG_ERROR, "Unable to find a suitable output format for '%s'\n",
3045                        filename);
3046                 goto error;
3047             }
3048         }
3049     }
3050
3051     s->oformat = oformat;
3052     if (s->oformat->priv_data_size > 0) {
3053         s->priv_data = av_mallocz(s->oformat->priv_data_size);
3054         if (!s->priv_data)
3055             goto nomem;
3056         if (s->oformat->priv_class) {
3057             *(const AVClass**)s->priv_data= s->oformat->priv_class;
3058             av_opt_set_defaults(s->priv_data);
3059         }
3060     } else
3061         s->priv_data = NULL;
3062
3063     if (filename)
3064         av_strlcpy(s->filename, filename, sizeof(s->filename));
3065     *avctx = s;
3066     return 0;
3067 nomem:
3068     av_log(s, AV_LOG_ERROR, "Out of memory\n");
3069     ret = AVERROR(ENOMEM);
3070 error:
3071     avformat_free_context(s);
3072     return ret;
3073 }
3074
3075 #if FF_API_ALLOC_OUTPUT_CONTEXT
3076 AVFormatContext *avformat_alloc_output_context(const char *format,
3077                                                AVOutputFormat *oformat, const char *filename)
3078 {
3079     AVFormatContext *avctx;
3080     int ret = avformat_alloc_output_context2(&avctx, oformat, format, filename);
3081     return ret < 0 ? NULL : avctx;
3082 }
3083 #endif
3084
3085 static int validate_codec_tag(AVFormatContext *s, AVStream *st)
3086 {
3087     const AVCodecTag *avctag;
3088     int n;
3089     enum CodecID id = CODEC_ID_NONE;
3090     unsigned int tag = 0;
3091
3092     /**
3093      * Check that tag + id is in the table
3094      * If neither is in the table -> OK
3095      * If tag is in the table with another id -> FAIL
3096      * If id is in the table with another tag -> FAIL unless strict < normal
3097      */
3098     for (n = 0; s->oformat->codec_tag[n]; n++) {
3099         avctag = s->oformat->codec_tag[n];
3100         while (avctag->id != CODEC_ID_NONE) {
3101             if (avpriv_toupper4(avctag->tag) == avpriv_toupper4(st->codec->codec_tag)) {
3102                 id = avctag->id;
3103                 if (id == st->codec->codec_id)
3104                     return 1;
3105             }
3106             if (avctag->id == st->codec->codec_id)
3107                 tag = avctag->tag;
3108             avctag++;
3109         }
3110     }
3111     if (id != CODEC_ID_NONE)
3112         return 0;
3113     if (tag && (st->codec->strict_std_compliance >= FF_COMPLIANCE_NORMAL))
3114         return 0;
3115     return 1;
3116 }
3117
3118 #if FF_API_FORMAT_PARAMETERS
3119 int av_write_header(AVFormatContext *s)
3120 {
3121     return avformat_write_header(s, NULL);
3122 }
3123 #endif
3124
3125 int avformat_write_header(AVFormatContext *s, AVDictionary **options)
3126 {
3127     int ret = 0, i;
3128     AVStream *st;
3129     AVDictionary *tmp = NULL;
3130
3131     if (options)
3132         av_dict_copy(&tmp, *options, 0);
3133     if ((ret = av_opt_set_dict(s, &tmp)) < 0)
3134         goto fail;
3135     if (s->priv_data && s->oformat->priv_class && *(const AVClass**)s->priv_data==s->oformat->priv_class &&
3136         (ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
3137         goto fail;
3138
3139     // some sanity checks
3140     if (s->nb_streams == 0 && !(s->oformat->flags & AVFMT_NOSTREAMS)) {
3141         av_log(s, AV_LOG_ERROR, "no streams\n");
3142         ret = AVERROR(EINVAL);
3143         goto fail;
3144     }
3145
3146     for(i=0;i<s->nb_streams;i++) {
3147         st = s->streams[i];
3148
3149         switch (st->codec->codec_type) {
3150         case AVMEDIA_TYPE_AUDIO:
3151             if(st->codec->sample_rate<=0){
3152                 av_log(s, AV_LOG_ERROR, "sample rate not set\n");
3153                 ret = AVERROR(EINVAL);
3154                 goto fail;
3155             }
3156             if(!st->codec->block_align)
3157                 st->codec->block_align = st->codec->channels *
3158                     av_get_bits_per_sample(st->codec->codec_id) >> 3;
3159             break;
3160         case AVMEDIA_TYPE_VIDEO:
3161             if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
3162                 av_log(s, AV_LOG_ERROR, "time base not set\n");
3163                 ret = AVERROR(EINVAL);
3164                 goto fail;
3165             }
3166             if((st->codec->width<=0 || st->codec->height<=0) && !(s->oformat->flags & AVFMT_NODIMENSIONS)){
3167                 av_log(s, AV_LOG_ERROR, "dimensions not set\n");
3168                 ret = AVERROR(EINVAL);
3169                 goto fail;
3170             }
3171             if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)
3172                && FFABS(av_q2d(st->sample_aspect_ratio) - av_q2d(st->codec->sample_aspect_ratio)) > 0.004*av_q2d(st->sample_aspect_ratio)
3173             ){
3174                 av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between encoder and muxer layer\n");
3175                 ret = AVERROR(EINVAL);
3176                 goto fail;
3177             }
3178             break;
3179         }
3180
3181         if(s->oformat->codec_tag){
3182             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)){
3183                 //the current rawvideo encoding system ends up setting the wrong codec_tag for avi, we override it here
3184                 st->codec->codec_tag= 0;
3185             }
3186             if(st->codec->codec_tag){
3187                 if (!validate_codec_tag(s, st)) {
3188                     char tagbuf[32];
3189                     av_get_codec_tag_string(tagbuf, sizeof(tagbuf), st->codec->codec_tag);
3190                     av_log(s, AV_LOG_ERROR,
3191                            "Tag %s/0x%08x incompatible with output codec id '%d'\n",
3192                            tagbuf, st->codec->codec_tag, st->codec->codec_id);
3193                     ret = AVERROR_INVALIDDATA;
3194                     goto fail;
3195                 }
3196             }else
3197                 st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
3198         }
3199
3200         if(s->oformat->flags & AVFMT_GLOBALHEADER &&
3201             !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
3202           av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
3203     }
3204
3205     if (!s->priv_data && s->oformat->priv_data_size > 0) {
3206         s->priv_data = av_mallocz(s->oformat->priv_data_size);
3207         if (!s->priv_data) {
3208             ret = AVERROR(ENOMEM);
3209             goto fail;
3210         }
3211         if (s->oformat->priv_class) {
3212             *(const AVClass**)s->priv_data= s->oformat->priv_class;
3213             av_opt_set_defaults(s->priv_data);
3214             if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
3215                 goto fail;
3216         }
3217     }
3218
3219     /* set muxer identification string */
3220     if (s->nb_streams && !(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
3221         av_dict_set(&s->metadata, "encoder", LIBAVFORMAT_IDENT, 0);
3222     }
3223
3224     if(s->oformat->write_header){
3225         ret = s->oformat->write_header(s);
3226         if (ret < 0)
3227             goto fail;
3228     }
3229
3230     /* init PTS generation */
3231     for(i=0;i<s->nb_streams;i++) {
3232         int64_t den = AV_NOPTS_VALUE;
3233         st = s->streams[i];
3234
3235         switch (st->codec->codec_type) {
3236         case AVMEDIA_TYPE_AUDIO:
3237             den = (int64_t)st->time_base.num * st->codec->sample_rate;
3238             break;
3239         case AVMEDIA_TYPE_VIDEO:
3240             den = (int64_t)st->time_base.num * st->codec->time_base.den;
3241             break;
3242         default:
3243             break;
3244         }
3245         if (den != AV_NOPTS_VALUE) {
3246             if (den <= 0) {
3247                 ret = AVERROR_INVALIDDATA;
3248                 goto fail;
3249             }
3250             frac_init(&st->pts, 0, 0, den);
3251         }
3252     }
3253
3254     if (options) {
3255         av_dict_free(options);
3256         *options = tmp;
3257     }
3258     return 0;
3259 fail:
3260     av_dict_free(&tmp);
3261     return ret;
3262 }
3263
3264 //FIXME merge with compute_pkt_fields
3265 static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt){
3266     int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
3267     int num, den, frame_size, i;
3268
3269     av_dlog(s, "compute_pkt_fields2: pts:%"PRId64" dts:%"PRId64" cur_dts:%"PRId64" b:%d size:%d st:%d\n",
3270             pkt->pts, pkt->dts, st->cur_dts, delay, pkt->size, pkt->stream_index);
3271
3272     /* duration field */
3273     if (pkt->duration == 0) {
3274         compute_frame_duration(&num, &den, st, NULL, pkt);
3275         if (den && num) {
3276             pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
3277         }
3278     }
3279
3280     if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
3281         pkt->pts= pkt->dts;
3282
3283     //XXX/FIXME this is a temporary hack until all encoders output pts
3284     if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
3285         pkt->dts=
3286 //        pkt->pts= st->cur_dts;
3287         pkt->pts= st->pts.val;
3288     }
3289
3290     //calculate dts from pts
3291     if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
3292         st->pts_buffer[0]= pkt->pts;
3293         for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
3294             st->pts_buffer[i]= pkt->pts + (i-delay-1) * pkt->duration;
3295         for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
3296             FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
3297
3298         pkt->dts= st->pts_buffer[0];
3299     }
3300
3301     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)){
3302         av_log(s, AV_LOG_ERROR,
3303                "Application provided invalid, non monotonically increasing dts to muxer in stream %d: %"PRId64" >= %"PRId64"\n",
3304                st->index, st->cur_dts, pkt->dts);
3305         return AVERROR(EINVAL);
3306     }
3307     if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
3308         av_log(s, AV_LOG_ERROR, "pts < dts in stream %d\n", st->index);
3309         return AVERROR(EINVAL);
3310     }
3311
3312 //    av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
3313     st->cur_dts= pkt->dts;
3314     st->pts.val= pkt->dts;
3315
3316     /* update pts */
3317     switch (st->codec->codec_type) {
3318     case AVMEDIA_TYPE_AUDIO:
3319         frame_size = get_audio_frame_size(st->codec, pkt->size);
3320
3321         /* HACK/FIXME, we skip the initial 0 size packets as they are most
3322            likely equal to the encoder delay, but it would be better if we
3323            had the real timestamps from the encoder */
3324         if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
3325             frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
3326         }
3327         break;
3328     case AVMEDIA_TYPE_VIDEO:
3329         frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
3330         break;
3331     default:
3332         break;
3333     }
3334     return 0;
3335 }
3336
3337 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
3338 {
3339     int ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt);
3340
3341     if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3342         return ret;
3343
3344     ret= s->oformat->write_packet(s, pkt);
3345
3346     if (ret >= 0)
3347         s->streams[pkt->stream_index]->nb_frames++;
3348     return ret;
3349 }
3350
3351 #define CHUNK_START 0x1000
3352
3353 int ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
3354                               int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
3355 {
3356     AVPacketList **next_point, *this_pktl;
3357     AVStream *st= s->streams[pkt->stream_index];
3358     int chunked= s->max_chunk_size || s->max_chunk_duration;
3359
3360     this_pktl = av_mallocz(sizeof(AVPacketList));
3361     if (!this_pktl)
3362         return AVERROR(ENOMEM);
3363     this_pktl->pkt= *pkt;
3364     pkt->destruct= NULL;             // do not free original but only the copy
3365     av_dup_packet(&this_pktl->pkt);  // duplicate the packet if it uses non-alloced memory
3366
3367     if(s->streams[pkt->stream_index]->last_in_packet_buffer){
3368         next_point = &(st->last_in_packet_buffer->next);
3369     }else{
3370         next_point = &s->packet_buffer;
3371     }
3372
3373     if(*next_point){
3374         if(chunked){
3375             uint64_t max= av_rescale_q(s->max_chunk_duration, AV_TIME_BASE_Q, st->time_base);
3376             if(   st->interleaver_chunk_size     + pkt->size     <= s->max_chunk_size-1U
3377                && st->interleaver_chunk_duration + pkt->duration <= max-1U){
3378                 st->interleaver_chunk_size     += pkt->size;
3379                 st->interleaver_chunk_duration += pkt->duration;
3380                 goto next_non_null;
3381             }else{
3382                 st->interleaver_chunk_size     =
3383                 st->interleaver_chunk_duration = 0;
3384                 this_pktl->pkt.flags |= CHUNK_START;
3385             }
3386         }
3387
3388         if(compare(s, &s->packet_buffer_end->pkt, pkt)){
3389             while(   *next_point
3390                   && ((chunked && !((*next_point)->pkt.flags&CHUNK_START))
3391                       || !compare(s, &(*next_point)->pkt, pkt))){
3392                 next_point= &(*next_point)->next;
3393             }
3394             if(*next_point)
3395                 goto next_non_null;
3396         }else{
3397             next_point = &(s->packet_buffer_end->next);
3398         }
3399     }
3400     assert(!*next_point);
3401
3402     s->packet_buffer_end= this_pktl;
3403 next_non_null:
3404
3405     this_pktl->next= *next_point;
3406
3407     s->streams[pkt->stream_index]->last_in_packet_buffer=
3408     *next_point= this_pktl;
3409     return 0;
3410 }
3411
3412 static int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
3413 {
3414     AVStream *st = s->streams[ pkt ->stream_index];
3415     AVStream *st2= s->streams[ next->stream_index];
3416     int comp = av_compare_ts(next->dts, st2->time_base, pkt->dts,
3417                              st->time_base);
3418     if(s->audio_preload && ((st->codec->codec_type == AVMEDIA_TYPE_AUDIO) != (st2->codec->codec_type == AVMEDIA_TYPE_AUDIO))){
3419         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);
3420         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);
3421         if(ts == ts2){
3422             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
3423                -( 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;
3424             ts2=0;
3425         }
3426         comp= (ts>ts2) - (ts<ts2);
3427     }
3428
3429     if (comp == 0)
3430         return pkt->stream_index < next->stream_index;
3431     return comp > 0;
3432 }
3433
3434 int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
3435     AVPacketList *pktl;
3436     int stream_count=0, noninterleaved_count=0;
3437     int64_t delta_dts_max = 0;
3438     int i, ret;
3439
3440     if(pkt){
3441         ret = ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
3442         if (ret < 0)
3443             return ret;
3444     }
3445
3446     for(i=0; i < s->nb_streams; i++) {
3447         if (s->streams[i]->last_in_packet_buffer) {
3448             ++stream_count;
3449         } else if(s->streams[i]->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3450             ++noninterleaved_count;
3451         }
3452     }
3453
3454     if (s->nb_streams == stream_count) {
3455         flush = 1;
3456     } else if (!flush){
3457         for(i=0; i < s->nb_streams; i++) {
3458             if (s->streams[i]->last_in_packet_buffer) {
3459                 int64_t delta_dts =
3460                     av_rescale_q(s->streams[i]->last_in_packet_buffer->pkt.dts,
3461                                 s->streams[i]->time_base,
3462                                 AV_TIME_BASE_Q) -
3463                     av_rescale_q(s->packet_buffer->pkt.dts,
3464                                 s->streams[s->packet_buffer->pkt.stream_index]->time_base,
3465                                 AV_TIME_BASE_Q);
3466                 delta_dts_max= FFMAX(delta_dts_max, delta_dts);
3467             }
3468         }
3469         if(s->nb_streams == stream_count+noninterleaved_count &&
3470            delta_dts_max > 20*AV_TIME_BASE) {
3471             av_log(s, AV_LOG_DEBUG, "flushing with %d noninterleaved\n", noninterleaved_count);
3472             flush = 1;
3473         }
3474     }
3475     if(stream_count && flush){
3476         pktl= s->packet_buffer;
3477         *out= pktl->pkt;
3478
3479         s->packet_buffer= pktl->next;
3480         if(!s->packet_buffer)
3481             s->packet_buffer_end= NULL;
3482
3483         if(s->streams[out->stream_index]->last_in_packet_buffer == pktl)
3484             s->streams[out->stream_index]->last_in_packet_buffer= NULL;
3485         av_freep(&pktl);
3486         return 1;
3487     }else{
3488         av_init_packet(out);
3489         return 0;
3490     }
3491 }
3492
3493 /**
3494  * Interleave an AVPacket correctly so it can be muxed.
3495  * @param out the interleaved packet will be output here
3496  * @param in the input packet
3497  * @param flush 1 if no further packets are available as input and all
3498  *              remaining packets should be output
3499  * @return 1 if a packet was output, 0 if no packet could be output,
3500  *         < 0 if an error occurred
3501  */
3502 static int interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
3503     if (s->oformat->interleave_packet) {
3504         int ret = s->oformat->interleave_packet(s, out, in, flush);
3505         if (in)
3506             av_free_packet(in);
3507         return ret;
3508     } else
3509         return av_interleave_packet_per_dts(s, out, in, flush);
3510 }
3511
3512 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
3513     AVStream *st= s->streams[ pkt->stream_index];
3514     int ret;
3515
3516     //FIXME/XXX/HACK drop zero sized packets
3517     if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO && pkt->size==0)
3518         return 0;
3519
3520     av_dlog(s, "av_interleaved_write_frame size:%d dts:%"PRId64" pts:%"PRId64"\n",
3521             pkt->size, pkt->dts, pkt->pts);
3522     if((ret = compute_pkt_fields2(s, st, pkt)) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3523         return ret;
3524
3525     if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3526         return AVERROR(EINVAL);
3527
3528     for(;;){
3529         AVPacket opkt;
3530         int ret= interleave_packet(s, &opkt, pkt, 0);
3531         if(ret<=0) //FIXME cleanup needed for ret<0 ?
3532             return ret;
3533
3534         ret= s->oformat->write_packet(s, &opkt);
3535         if (ret >= 0)
3536             s->streams[opkt.stream_index]->nb_frames++;
3537
3538         av_free_packet(&opkt);
3539         pkt= NULL;
3540
3541         if(ret<0)
3542             return ret;
3543         if(s->pb && s->pb->error)
3544             return s->pb->error;
3545     }
3546 }
3547
3548 int av_write_trailer(AVFormatContext *s)
3549 {
3550     int ret, i;
3551
3552     for(;;){
3553         AVPacket pkt;
3554         ret= interleave_packet(s, &pkt, NULL, 1);
3555         if(ret<0) //FIXME cleanup needed for ret<0 ?
3556             goto fail;
3557         if(!ret)
3558             break;
3559
3560         ret= s->oformat->write_packet(s, &pkt);
3561         if (ret >= 0)
3562             s->streams[pkt.stream_index]->nb_frames++;
3563
3564         av_free_packet(&pkt);
3565
3566         if(ret<0)
3567             goto fail;
3568         if(s->pb && s->pb->error)
3569             goto fail;
3570     }
3571
3572     if(s->oformat->write_trailer)
3573         ret = s->oformat->write_trailer(s);
3574 fail:
3575     if(ret == 0)
3576        ret = s->pb ? s->pb->error : 0;
3577     for(i=0;i<s->nb_streams;i++) {
3578         av_freep(&s->streams[i]->priv_data);
3579         av_freep(&s->streams[i]->index_entries);
3580     }
3581     if (s->oformat->priv_class)
3582         av_opt_free(s->priv_data);
3583     av_freep(&s->priv_data);
3584     return ret;
3585 }
3586
3587 int av_get_output_timestamp(struct AVFormatContext *s, int stream,
3588                             int64_t *dts, int64_t *wall)
3589 {
3590     if (!s->oformat || !s->oformat->get_output_timestamp)
3591         return AVERROR(ENOSYS);
3592     s->oformat->get_output_timestamp(s, stream, dts, wall);
3593     return 0;
3594 }
3595
3596 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
3597 {
3598     int i, j;
3599     AVProgram *program=NULL;
3600     void *tmp;
3601
3602     if (idx >= ac->nb_streams) {
3603         av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3604         return;
3605     }
3606
3607     for(i=0; i<ac->nb_programs; i++){
3608         if(ac->programs[i]->id != progid)
3609             continue;
3610         program = ac->programs[i];
3611         for(j=0; j<program->nb_stream_indexes; j++)
3612             if(program->stream_index[j] == idx)
3613                 return;
3614
3615         tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
3616         if(!tmp)
3617             return;
3618         program->stream_index = tmp;
3619         program->stream_index[program->nb_stream_indexes++] = idx;
3620         return;
3621     }
3622 }
3623
3624 static void print_fps(double d, const char *postfix){
3625     uint64_t v= lrintf(d*100);
3626     if     (v% 100      ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3627     else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3628     else                  av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
3629 }
3630
3631 static void dump_metadata(void *ctx, AVDictionary *m, const char *indent)
3632 {
3633     if(m && !(m->count == 1 && av_dict_get(m, "language", NULL, 0))){
3634         AVDictionaryEntry *tag=NULL;
3635
3636         av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3637         while((tag=av_dict_get(m, "", tag, AV_DICT_IGNORE_SUFFIX))) {
3638             if(strcmp("language", tag->key)){
3639                 char tmp[256];
3640                 int i;
3641                 av_strlcpy(tmp, tag->value, sizeof(tmp));
3642                 for(i=0; i<strlen(tmp); i++) if(tmp[i]==0xd) tmp[i]=' ';
3643                 av_log(ctx, AV_LOG_INFO, "%s  %-16s: %s\n", indent, tag->key, tmp);
3644             }
3645         }
3646     }
3647 }
3648
3649 /* "user interface" functions */
3650 static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
3651 {
3652     char buf[256];
3653     int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
3654     AVStream *st = ic->streams[i];
3655     int g = av_gcd(st->time_base.num, st->time_base.den);
3656     AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL, 0);
3657     avcodec_string(buf, sizeof(buf), st->codec, is_output);
3658     av_log(NULL, AV_LOG_INFO, "    Stream #%d:%d", index, i);
3659     /* the pid is an important information, so we display it */
3660     /* XXX: add a generic system */
3661     if (flags & AVFMT_SHOW_IDS)
3662         av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
3663     if (lang)
3664         av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
3665     av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames, st->time_base.num/g, st->time_base.den/g);
3666     av_log(NULL, AV_LOG_INFO, ": %s", buf);
3667     if (st->sample_aspect_ratio.num && // default
3668         av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
3669         AVRational display_aspect_ratio;
3670         av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
3671                   st->codec->width*st->sample_aspect_ratio.num,
3672                   st->codec->height*st->sample_aspect_ratio.den,
3673                   1024*1024);
3674         av_log(NULL, AV_LOG_INFO, ", SAR %d:%d DAR %d:%d",
3675                  st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3676                  display_aspect_ratio.num, display_aspect_ratio.den);
3677     }
3678     if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
3679         if(st->avg_frame_rate.den && st->avg_frame_rate.num)
3680             print_fps(av_q2d(st->avg_frame_rate), "fps");
3681         if(st->r_frame_rate.den && st->r_frame_rate.num)
3682             print_fps(av_q2d(st->r_frame_rate), "tbr");
3683         if(st->time_base.den && st->time_base.num)
3684             print_fps(1/av_q2d(st->time_base), "tbn");
3685         if(st->codec->time_base.den && st->codec->time_base.num)
3686             print_fps(1/av_q2d(st->codec->time_base), "tbc");
3687     }
3688     if (st->disposition & AV_DISPOSITION_DEFAULT)
3689         av_log(NULL, AV_LOG_INFO, " (default)");
3690     if (st->disposition & AV_DISPOSITION_DUB)
3691         av_log(NULL, AV_LOG_INFO, " (dub)");
3692     if (st->disposition & AV_DISPOSITION_ORIGINAL)
3693         av_log(NULL, AV_LOG_INFO, " (original)");
3694     if (st->disposition & AV_DISPOSITION_COMMENT)
3695         av_log(NULL, AV_LOG_INFO, " (comment)");
3696     if (st->disposition & AV_DISPOSITION_LYRICS)
3697         av_log(NULL, AV_LOG_INFO, " (lyrics)");
3698     if (st->disposition & AV_DISPOSITION_KARAOKE)
3699         av_log(NULL, AV_LOG_INFO, " (karaoke)");
3700     if (st->disposition & AV_DISPOSITION_FORCED)
3701         av_log(NULL, AV_LOG_INFO, " (forced)");
3702     if (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED)
3703         av_log(NULL, AV_LOG_INFO, " (hearing impaired)");
3704     if (st->disposition & AV_DISPOSITION_VISUAL_IMPAIRED)
3705         av_log(NULL, AV_LOG_INFO, " (visual impaired)");
3706     if (st->disposition & AV_DISPOSITION_CLEAN_EFFECTS)
3707         av_log(NULL, AV_LOG_INFO, " (clean effects)");
3708     av_log(NULL, AV_LOG_INFO, "\n");
3709     dump_metadata(NULL, st->metadata, "    ");
3710 }
3711
3712 #if FF_API_DUMP_FORMAT
3713 void dump_format(AVFormatContext *ic,
3714                  int index,
3715                  const char *url,
3716                  int is_output)
3717 {
3718     av_dump_format(ic, index, url, is_output);
3719 }
3720 #endif
3721
3722 void av_dump_format(AVFormatContext *ic,
3723                     int index,
3724                     const char *url,
3725                     int is_output)
3726 {
3727     int i;
3728     uint8_t *printed = ic->nb_streams ? av_mallocz(ic->nb_streams) : NULL;
3729     if (ic->nb_streams && !printed)
3730         return;
3731
3732     av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3733             is_output ? "Output" : "Input",
3734             index,
3735             is_output ? ic->oformat->name : ic->iformat->name,
3736             is_output ? "to" : "from", url);
3737     dump_metadata(NULL, ic->metadata, "  ");
3738     if (!is_output) {
3739         av_log(NULL, AV_LOG_INFO, "  Duration: ");
3740         if (ic->duration != AV_NOPTS_VALUE) {
3741             int hours, mins, secs, us;
3742             secs = ic->duration / AV_TIME_BASE;
3743             us = ic->duration % AV_TIME_BASE;
3744             mins = secs / 60;
3745             secs %= 60;
3746             hours = mins / 60;
3747             mins %= 60;
3748             av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3749                    (100 * us) / AV_TIME_BASE);
3750         } else {
3751             av_log(NULL, AV_LOG_INFO, "N/A");
3752         }
3753         if (ic->start_time != AV_NOPTS_VALUE) {
3754             int secs, us;
3755             av_log(NULL, AV_LOG_INFO, ", start: ");
3756             secs = ic->start_time / AV_TIME_BASE;
3757             us = abs(ic->start_time % AV_TIME_BASE);
3758             av_log(NULL, AV_LOG_INFO, "%d.%06d",
3759                    secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
3760         }
3761         av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3762         if (ic->bit_rate) {
3763             av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
3764         } else {
3765             av_log(NULL, AV_LOG_INFO, "N/A");
3766         }
3767         av_log(NULL, AV_LOG_INFO, "\n");
3768     }
3769     for (i = 0; i < ic->nb_chapters; i++) {
3770         AVChapter *ch = ic->chapters[i];
3771         av_log(NULL, AV_LOG_INFO, "    Chapter #%d.%d: ", index, i);
3772         av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
3773         av_log(NULL, AV_LOG_INFO, "end %f\n",   ch->end   * av_q2d(ch->time_base));
3774
3775         dump_metadata(NULL, ch->metadata, "    ");
3776     }
3777     if(ic->nb_programs) {
3778         int j, k, total = 0;
3779         for(j=0; j<ic->nb_programs; j++) {
3780             AVDictionaryEntry *name = av_dict_get(ic->programs[j]->metadata,
3781                                                   "name", NULL, 0);
3782             av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
3783                    name ? name->value : "");
3784             dump_metadata(NULL, ic->programs[j]->metadata, "    ");
3785             for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3786                 dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3787                 printed[ic->programs[j]->stream_index[k]] = 1;
3788             }
3789             total += ic->programs[j]->nb_stream_indexes;
3790         }
3791         if (total < ic->nb_streams)
3792             av_log(NULL, AV_LOG_INFO, "  No Program\n");
3793     }
3794     for(i=0;i<ic->nb_streams;i++)
3795         if (!printed[i])
3796             dump_stream_format(ic, i, index, is_output);
3797
3798     av_free(printed);
3799 }
3800
3801 int64_t av_gettime(void)
3802 {
3803     struct timeval tv;
3804     gettimeofday(&tv,NULL);
3805     return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
3806 }
3807
3808 uint64_t ff_ntp_time(void)
3809 {
3810   return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3811 }
3812
3813 #if FF_API_PARSE_DATE
3814 #include "libavutil/parseutils.h"
3815
3816 int64_t parse_date(const char *timestr, int duration)
3817 {
3818     int64_t timeval;
3819     av_parse_time(&timeval, timestr, duration);
3820     return timeval;
3821 }
3822 #endif
3823
3824 #if FF_API_FIND_INFO_TAG
3825 #include "libavutil/parseutils.h"
3826
3827 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
3828 {
3829     return av_find_info_tag(arg, arg_size, tag1, info);
3830 }
3831 #endif
3832
3833 int av_get_frame_filename(char *buf, int buf_size,
3834                           const char *path, int number)
3835 {
3836     const char *p;
3837     char *q, buf1[20], c;
3838     int nd, len, percentd_found;
3839
3840     q = buf;
3841     p = path;
3842     percentd_found = 0;
3843     for(;;) {
3844         c = *p++;
3845         if (c == '\0')
3846             break;
3847         if (c == '%') {
3848             do {
3849                 nd = 0;
3850                 while (isdigit(*p)) {
3851                     nd = nd * 10 + *p++ - '0';
3852                 }
3853                 c = *p++;
3854             } while (isdigit(c));
3855
3856             switch(c) {
3857             case '%':
3858                 goto addchar;
3859             case 'd':
3860                 if (percentd_found)
3861                     goto fail;
3862                 percentd_found = 1;
3863                 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3864                 len = strlen(buf1);
3865                 if ((q - buf + len) > buf_size - 1)
3866                     goto fail;
3867                 memcpy(q, buf1, len);
3868                 q += len;
3869                 break;
3870             default:
3871                 goto fail;
3872             }
3873         } else {
3874         addchar:
3875             if ((q - buf) < buf_size - 1)
3876                 *q++ = c;
3877         }
3878     }
3879     if (!percentd_found)
3880         goto fail;
3881     *q = '\0';
3882     return 0;
3883  fail:
3884     *q = '\0';
3885     return -1;
3886 }
3887
3888 static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3889 {
3890     int len, i, j, c;
3891 #undef fprintf
3892 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3893
3894     for(i=0;i<size;i+=16) {
3895         len = size - i;
3896         if (len > 16)
3897             len = 16;
3898         PRINT("%08x ", i);
3899         for(j=0;j<16;j++) {
3900             if (j < len)
3901                 PRINT(" %02x", buf[i+j]);
3902             else
3903                 PRINT("   ");
3904         }
3905         PRINT(" ");
3906         for(j=0;j<len;j++) {
3907             c = buf[i+j];
3908             if (c < ' ' || c > '~')
3909                 c = '.';
3910             PRINT("%c", c);
3911         }
3912         PRINT("\n");
3913     }
3914 #undef PRINT
3915 }
3916
3917 void av_hex_dump(FILE *f, uint8_t *buf, int size)
3918 {
3919     hex_dump_internal(NULL, f, 0, buf, size);
3920 }
3921
3922 void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3923 {
3924     hex_dump_internal(avcl, NULL, level, buf, size);
3925 }
3926
3927 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload, AVRational time_base)
3928 {
3929 #undef fprintf
3930 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3931     PRINT("stream #%d:\n", pkt->stream_index);
3932     PRINT("  keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
3933     PRINT("  duration=%0.3f\n", pkt->duration * av_q2d(time_base));
3934     /* DTS is _always_ valid after av_read_frame() */
3935     PRINT("  dts=");
3936     if (pkt->dts == AV_NOPTS_VALUE)
3937         PRINT("N/A");
3938     else
3939         PRINT("%0.3f", pkt->dts * av_q2d(time_base));
3940     /* PTS may not be known if B-frames are present. */
3941     PRINT("  pts=");
3942     if (pkt->pts == AV_NOPTS_VALUE)
3943         PRINT("N/A");
3944     else
3945         PRINT("%0.3f", pkt->pts * av_q2d(time_base));
3946     PRINT("\n");
3947     PRINT("  size=%d\n", pkt->size);
3948 #undef PRINT
3949     if (dump_payload)
3950         av_hex_dump(f, pkt->data, pkt->size);
3951 }
3952
3953 #if FF_API_PKT_DUMP
3954 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3955 {
3956     AVRational tb = { 1, AV_TIME_BASE };
3957     pkt_dump_internal(NULL, f, 0, pkt, dump_payload, tb);
3958 }
3959 #endif
3960
3961 void av_pkt_dump2(FILE *f, AVPacket *pkt, int dump_payload, AVStream *st)
3962 {
3963     pkt_dump_internal(NULL, f, 0, pkt, dump_payload, st->time_base);
3964 }
3965
3966 #if FF_API_PKT_DUMP
3967 void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3968 {
3969     AVRational tb = { 1, AV_TIME_BASE };
3970     pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, tb);
3971 }
3972 #endif
3973
3974 void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload,
3975                       AVStream *st)
3976 {
3977     pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, st->time_base);
3978 }
3979
3980 void av_url_split(char *proto, int proto_size,
3981                   char *authorization, int authorization_size,
3982                   char *hostname, int hostname_size,
3983                   int *port_ptr,
3984                   char *path, int path_size,
3985                   const char *url)
3986 {
3987     const char *p, *ls, *at, *col, *brk;
3988
3989     if (port_ptr)               *port_ptr = -1;
3990     if (proto_size > 0)         proto[0] = 0;
3991     if (authorization_size > 0) authorization[0] = 0;
3992     if (hostname_size > 0)      hostname[0] = 0;
3993     if (path_size > 0)          path[0] = 0;
3994
3995     /* parse protocol */
3996     if ((p = strchr(url, ':'))) {
3997         av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3998         p++; /* skip ':' */
3999         if (*p == '/') p++;
4000         if (*p == '/') p++;
4001     } else {
4002         /* no protocol means plain filename */
4003         av_strlcpy(path, url, path_size);
4004         return;
4005     }
4006
4007     /* separate path from hostname */
4008     ls = strchr(p, '/');
4009     if(!ls)
4010         ls = strchr(p, '?');
4011     if(ls)
4012         av_strlcpy(path, ls, path_size);
4013     else
4014         ls = &p[strlen(p)]; // XXX
4015
4016     /* the rest is hostname, use that to parse auth/port */
4017     if (ls != p) {
4018         /* authorization (user[:pass]@hostname) */
4019         if ((at = strchr(p, '@')) && at < ls) {
4020             av_strlcpy(authorization, p,
4021                        FFMIN(authorization_size, at + 1 - p));
4022             p = at + 1; /* skip '@' */
4023         }
4024
4025         if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
4026             /* [host]:port */
4027             av_strlcpy(hostname, p + 1,
4028                        FFMIN(hostname_size, brk - p));
4029             if (brk[1] == ':' && port_ptr)
4030                 *port_ptr = atoi(brk + 2);
4031         } else if ((col = strchr(p, ':')) && col < ls) {
4032             av_strlcpy(hostname, p,
4033                        FFMIN(col + 1 - p, hostname_size));
4034             if (port_ptr) *port_ptr = atoi(col + 1);
4035         } else
4036             av_strlcpy(hostname, p,
4037                        FFMIN(ls + 1 - p, hostname_size));
4038     }
4039 }
4040
4041 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
4042 {
4043     int i;
4044     static const char hex_table_uc[16] = { '0', '1', '2', '3',
4045                                            '4', '5', '6', '7',
4046                                            '8', '9', 'A', 'B',
4047                                            'C', 'D', 'E', 'F' };
4048     static const char hex_table_lc[16] = { '0', '1', '2', '3',
4049                                            '4', '5', '6', '7',
4050                                            '8', '9', 'a', 'b',
4051                                            'c', 'd', 'e', 'f' };
4052     const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
4053
4054     for(i = 0; i < s; i++) {
4055         buff[i * 2]     = hex_table[src[i] >> 4];
4056         buff[i * 2 + 1] = hex_table[src[i] & 0xF];
4057     }
4058
4059     return buff;
4060 }
4061
4062 int ff_hex_to_data(uint8_t *data, const char *p)
4063 {
4064     int c, len, v;
4065
4066     len = 0;
4067     v = 1;
4068     for (;;) {
4069         p += strspn(p, SPACE_CHARS);
4070         if (*p == '\0')
4071             break;
4072         c = toupper((unsigned char) *p++);
4073         if (c >= '0' && c <= '9')
4074             c = c - '0';
4075         else if (c >= 'A' && c <= 'F')
4076             c = c - 'A' + 10;
4077         else
4078             break;
4079         v = (v << 4) | c;
4080         if (v & 0x100) {
4081             if (data)
4082                 data[len] = v;
4083             len++;
4084             v = 1;
4085         }
4086     }
4087     return len;
4088 }
4089
4090 #if FF_API_SET_PTS_INFO
4091 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
4092                      unsigned int pts_num, unsigned int pts_den)
4093 {
4094     avpriv_set_pts_info(s, pts_wrap_bits, pts_num, pts_den);
4095 }
4096 #endif
4097
4098 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
4099                          unsigned int pts_num, unsigned int pts_den)
4100 {
4101     AVRational new_tb;
4102     if(av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)){
4103         if(new_tb.num != pts_num)
4104             av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/new_tb.num);
4105     }else
4106         av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
4107
4108     if(new_tb.num <= 0 || new_tb.den <= 0) {
4109         av_log(NULL, AV_LOG_ERROR, "Ignoring attempt to set invalid timebase for st:%d\n", s->index);
4110         return;
4111     }
4112     s->time_base = new_tb;
4113     s->pts_wrap_bits = pts_wrap_bits;
4114 }
4115
4116 int ff_url_join(char *str, int size, const char *proto,
4117                 const char *authorization, const char *hostname,
4118                 int port, const char *fmt, ...)
4119 {
4120 #if CONFIG_NETWORK
4121     struct addrinfo hints, *ai;
4122 #endif
4123
4124     str[0] = '\0';
4125     if (proto)
4126         av_strlcatf(str, size, "%s://", proto);
4127     if (authorization && authorization[0])
4128         av_strlcatf(str, size, "%s@", authorization);
4129 #if CONFIG_NETWORK && defined(AF_INET6)
4130     /* Determine if hostname is a numerical IPv6 address,
4131      * properly escape it within [] in that case. */
4132     memset(&hints, 0, sizeof(hints));
4133     hints.ai_flags = AI_NUMERICHOST;
4134     if (!getaddrinfo(hostname, NULL, &hints, &ai)) {
4135         if (ai->ai_family == AF_INET6) {
4136             av_strlcat(str, "[", size);
4137             av_strlcat(str, hostname, size);
4138             av_strlcat(str, "]", size);
4139         } else {
4140             av_strlcat(str, hostname, size);
4141         }
4142         freeaddrinfo(ai);
4143     } else
4144 #endif
4145         /* Not an IPv6 address, just output the plain string. */
4146         av_strlcat(str, hostname, size);
4147
4148     if (port >= 0)
4149         av_strlcatf(str, size, ":%d", port);
4150     if (fmt) {
4151         va_list vl;
4152         int len = strlen(str);
4153
4154         va_start(vl, fmt);
4155         vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);
4156         va_end(vl);
4157     }
4158     return strlen(str);
4159 }
4160
4161 int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
4162                      AVFormatContext *src)
4163 {
4164     AVPacket local_pkt;
4165
4166     local_pkt = *pkt;
4167     local_pkt.stream_index = dst_stream;
4168     if (pkt->pts != AV_NOPTS_VALUE)
4169         local_pkt.pts = av_rescale_q(pkt->pts,
4170                                      src->streams[pkt->stream_index]->time_base,
4171                                      dst->streams[dst_stream]->time_base);
4172     if (pkt->dts != AV_NOPTS_VALUE)
4173         local_pkt.dts = av_rescale_q(pkt->dts,
4174                                      src->streams[pkt->stream_index]->time_base,
4175                                      dst->streams[dst_stream]->time_base);
4176     return av_write_frame(dst, &local_pkt);
4177 }
4178
4179 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
4180                         void *context)
4181 {
4182     const char *ptr = str;
4183
4184     /* Parse key=value pairs. */
4185     for (;;) {
4186         const char *key;
4187         char *dest = NULL, *dest_end;
4188         int key_len, dest_len = 0;
4189
4190         /* Skip whitespace and potential commas. */
4191         while (*ptr && (isspace(*ptr) || *ptr == ','))
4192             ptr++;
4193         if (!*ptr)
4194             break;
4195
4196         key = ptr;
4197
4198         if (!(ptr = strchr(key, '=')))
4199             break;
4200         ptr++;
4201         key_len = ptr - key;
4202
4203         callback_get_buf(context, key, key_len, &dest, &dest_len);
4204         dest_end = dest + dest_len - 1;
4205
4206         if (*ptr == '\"') {
4207             ptr++;
4208             while (*ptr && *ptr != '\"') {
4209                 if (*ptr == '\\') {
4210                     if (!ptr[1])
4211                         break;
4212                     if (dest && dest < dest_end)
4213                         *dest++ = ptr[1];
4214                     ptr += 2;
4215                 } else {
4216                     if (dest && dest < dest_end)
4217                         *dest++ = *ptr;
4218                     ptr++;
4219                 }
4220             }
4221             if (*ptr == '\"')
4222                 ptr++;
4223         } else {
4224             for (; *ptr && !(isspace(*ptr) || *ptr == ','); ptr++)
4225                 if (dest && dest < dest_end)
4226                     *dest++ = *ptr;
4227         }
4228         if (dest)
4229             *dest = 0;
4230     }
4231 }
4232
4233 int ff_find_stream_index(AVFormatContext *s, int id)
4234 {
4235     int i;
4236     for (i = 0; i < s->nb_streams; i++) {
4237         if (s->streams[i]->id == id)
4238             return i;
4239     }
4240     return -1;
4241 }
4242
4243 void ff_make_absolute_url(char *buf, int size, const char *base,
4244                           const char *rel)
4245 {
4246     char *sep;
4247     /* Absolute path, relative to the current server */
4248     if (base && strstr(base, "://") && rel[0] == '/') {
4249         if (base != buf)
4250             av_strlcpy(buf, base, size);
4251         sep = strstr(buf, "://");
4252         if (sep) {
4253             sep += 3;
4254             sep = strchr(sep, '/');
4255             if (sep)
4256                 *sep = '\0';
4257         }
4258         av_strlcat(buf, rel, size);
4259         return;
4260     }
4261     /* If rel actually is an absolute url, just copy it */
4262     if (!base || strstr(rel, "://") || rel[0] == '/') {
4263         av_strlcpy(buf, rel, size);
4264         return;
4265     }
4266     if (base != buf)
4267         av_strlcpy(buf, base, size);
4268     /* Remove the file name from the base url */
4269     sep = strrchr(buf, '/');
4270     if (sep)
4271         sep[1] = '\0';
4272     else
4273         buf[0] = '\0';
4274     while (av_strstart(rel, "../", NULL) && sep) {
4275         /* Remove the path delimiter at the end */
4276         sep[0] = '\0';
4277         sep = strrchr(buf, '/');
4278         /* If the next directory name to pop off is "..", break here */
4279         if (!strcmp(sep ? &sep[1] : buf, "..")) {
4280             /* Readd the slash we just removed */
4281             av_strlcat(buf, "/", size);
4282             break;
4283         }
4284         /* Cut off the directory name */
4285         if (sep)
4286             sep[1] = '\0';
4287         else
4288             buf[0] = '\0';
4289         rel += 3;
4290     }
4291     av_strlcat(buf, rel, size);
4292 }
4293
4294 int64_t ff_iso8601_to_unix_time(const char *datestr)
4295 {
4296 #if HAVE_STRPTIME
4297     struct tm time1 = {0}, time2 = {0};
4298     char *ret1, *ret2;
4299     ret1 = strptime(datestr, "%Y - %m - %d %T", &time1);
4300     ret2 = strptime(datestr, "%Y - %m - %dT%T", &time2);
4301     if (ret2 && !ret1)
4302         return av_timegm(&time2);
4303     else
4304         return av_timegm(&time1);
4305 #else
4306     av_log(NULL, AV_LOG_WARNING, "strptime() unavailable on this system, cannot convert "
4307                                  "the date string.\n");
4308     return 0;
4309 #endif
4310 }
4311
4312 int avformat_query_codec(AVOutputFormat *ofmt, enum CodecID codec_id, int std_compliance)
4313 {
4314     if (ofmt) {
4315         if (ofmt->query_codec)
4316             return ofmt->query_codec(codec_id, std_compliance);
4317         else if (ofmt->codec_tag)
4318             return !!av_codec_get_tag(ofmt->codec_tag, codec_id);
4319         else if (codec_id == ofmt->video_codec || codec_id == ofmt->audio_codec ||
4320                  codec_id == ofmt->subtitle_codec)
4321             return 1;
4322     }
4323     return AVERROR_PATCHWELCOME;
4324 }
4325
4326 int avformat_network_init(void)
4327 {
4328 #if CONFIG_NETWORK
4329     int ret;
4330     ff_network_inited_globally = 1;
4331     if ((ret = ff_network_init()) < 0)
4332         return ret;
4333     ff_tls_init();
4334 #endif
4335     return 0;
4336 }
4337
4338 int avformat_network_deinit(void)
4339 {
4340 #if CONFIG_NETWORK
4341     ff_network_close();
4342     ff_tls_deinit();
4343 #endif
4344     return 0;
4345 }
4346
4347 int ff_add_param_change(AVPacket *pkt, int32_t channels,
4348                         uint64_t channel_layout, int32_t sample_rate,
4349                         int32_t width, int32_t height)
4350 {
4351     uint32_t flags = 0;
4352     int size = 4;
4353     uint8_t *data;
4354     if (!pkt)
4355         return AVERROR(EINVAL);
4356     if (channels) {
4357         size += 4;
4358         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
4359     }
4360     if (channel_layout) {
4361         size += 8;
4362         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
4363     }
4364     if (sample_rate) {
4365         size += 4;
4366         flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
4367     }
4368     if (width || height) {
4369         size += 8;
4370         flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
4371     }
4372     data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
4373     if (!data)
4374         return AVERROR(ENOMEM);
4375     bytestream_put_le32(&data, flags);
4376     if (channels)
4377         bytestream_put_le32(&data, channels);
4378     if (channel_layout)
4379         bytestream_put_le64(&data, channel_layout);
4380     if (sample_rate)
4381         bytestream_put_le32(&data, sample_rate);
4382     if (width || height) {
4383         bytestream_put_le32(&data, width);
4384         bytestream_put_le32(&data, height);
4385     }
4386     return 0;
4387 }