git.sesse.net Git - ffmpeg/blob - libavformat/utils.c

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