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         return s->oformat->interleave_packet(s, out, in, flush);
3497     else
3498         return av_interleave_packet_per_dts(s, out, in, flush);
3499 }
3500
3501 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
3502     AVStream *st= s->streams[ pkt->stream_index];
3503     int ret;
3504
3505     //FIXME/XXX/HACK drop zero sized packets
3506     if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO && pkt->size==0)
3507         return 0;
3508
3509     av_dlog(s, "av_interleaved_write_frame size:%d dts:%"PRId64" pts:%"PRId64"\n",
3510             pkt->size, pkt->dts, pkt->pts);
3511     if((ret = compute_pkt_fields2(s, st, pkt)) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3512         return ret;
3513
3514     if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3515         return AVERROR(EINVAL);
3516
3517     for(;;){
3518         AVPacket opkt;
3519         int ret= interleave_packet(s, &opkt, pkt, 0);
3520         if(ret<=0) //FIXME cleanup needed for ret<0 ?
3521             return ret;
3522
3523         ret= s->oformat->write_packet(s, &opkt);
3524         if (ret >= 0)
3525             s->streams[opkt.stream_index]->nb_frames++;
3526
3527         av_free_packet(&opkt);
3528         pkt= NULL;
3529
3530         if(ret<0)
3531             return ret;
3532         if(s->pb && s->pb->error)
3533             return s->pb->error;
3534     }
3535 }
3536
3537 int av_write_trailer(AVFormatContext *s)
3538 {
3539     int ret, i;
3540
3541     for(;;){
3542         AVPacket pkt;
3543         ret= interleave_packet(s, &pkt, NULL, 1);
3544         if(ret<0) //FIXME cleanup needed for ret<0 ?
3545             goto fail;
3546         if(!ret)
3547             break;
3548
3549         ret= s->oformat->write_packet(s, &pkt);
3550         if (ret >= 0)
3551             s->streams[pkt.stream_index]->nb_frames++;
3552
3553         av_free_packet(&pkt);
3554
3555         if(ret<0)
3556             goto fail;
3557         if(s->pb && s->pb->error)
3558             goto fail;
3559     }
3560
3561     if(s->oformat->write_trailer)
3562         ret = s->oformat->write_trailer(s);
3563 fail:
3564     if(ret == 0)
3565        ret = s->pb ? s->pb->error : 0;
3566     for(i=0;i<s->nb_streams;i++) {
3567         av_freep(&s->streams[i]->priv_data);
3568         av_freep(&s->streams[i]->index_entries);
3569     }
3570     if (s->oformat->priv_class)
3571         av_opt_free(s->priv_data);
3572     av_freep(&s->priv_data);
3573     return ret;
3574 }
3575
3576 int av_get_output_timestamp(struct AVFormatContext *s, int stream,
3577                             int64_t *dts, int64_t *wall)
3578 {
3579     if (!s->oformat || !s->oformat->get_output_timestamp)
3580         return AVERROR(ENOSYS);
3581     s->oformat->get_output_timestamp(s, stream, dts, wall);
3582     return 0;
3583 }
3584
3585 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
3586 {
3587     int i, j;
3588     AVProgram *program=NULL;
3589     void *tmp;
3590
3591     if (idx >= ac->nb_streams) {
3592         av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3593         return;
3594     }
3595
3596     for(i=0; i<ac->nb_programs; i++){
3597         if(ac->programs[i]->id != progid)
3598             continue;
3599         program = ac->programs[i];
3600         for(j=0; j<program->nb_stream_indexes; j++)
3601             if(program->stream_index[j] == idx)
3602                 return;
3603
3604         tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
3605         if(!tmp)
3606             return;
3607         program->stream_index = tmp;
3608         program->stream_index[program->nb_stream_indexes++] = idx;
3609         return;
3610     }
3611 }
3612
3613 static void print_fps(double d, const char *postfix){
3614     uint64_t v= lrintf(d*100);
3615     if     (v% 100      ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3616     else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3617     else                  av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
3618 }
3619
3620 static void dump_metadata(void *ctx, AVDictionary *m, const char *indent)
3621 {
3622     if(m && !(m->count == 1 && av_dict_get(m, "language", NULL, 0))){
3623         AVDictionaryEntry *tag=NULL;
3624
3625         av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3626         while((tag=av_dict_get(m, "", tag, AV_DICT_IGNORE_SUFFIX))) {
3627             if(strcmp("language", tag->key)){
3628                 char tmp[256];
3629                 int i;
3630                 av_strlcpy(tmp, tag->value, sizeof(tmp));
3631                 for(i=0; i<strlen(tmp); i++) if(tmp[i]==0xd) tmp[i]=' ';
3632                 av_log(ctx, AV_LOG_INFO, "%s  %-16s: %s\n", indent, tag->key, tmp);
3633             }
3634         }
3635     }
3636 }
3637
3638 /* "user interface" functions */
3639 static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
3640 {
3641     char buf[256];
3642     int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
3643     AVStream *st = ic->streams[i];
3644     int g = av_gcd(st->time_base.num, st->time_base.den);
3645     AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL, 0);
3646     avcodec_string(buf, sizeof(buf), st->codec, is_output);
3647     av_log(NULL, AV_LOG_INFO, "    Stream #%d:%d", index, i);
3648     /* the pid is an important information, so we display it */
3649     /* XXX: add a generic system */
3650     if (flags & AVFMT_SHOW_IDS)
3651         av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
3652     if (lang)
3653         av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
3654     av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames, st->time_base.num/g, st->time_base.den/g);
3655     av_log(NULL, AV_LOG_INFO, ": %s", buf);
3656     if (st->sample_aspect_ratio.num && // default
3657         av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
3658         AVRational display_aspect_ratio;
3659         av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
3660                   st->codec->width*st->sample_aspect_ratio.num,
3661                   st->codec->height*st->sample_aspect_ratio.den,
3662                   1024*1024);
3663         av_log(NULL, AV_LOG_INFO, ", SAR %d:%d DAR %d:%d",
3664                  st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3665                  display_aspect_ratio.num, display_aspect_ratio.den);
3666     }
3667     if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
3668         if(st->avg_frame_rate.den && st->avg_frame_rate.num)
3669             print_fps(av_q2d(st->avg_frame_rate), "fps");
3670         if(st->r_frame_rate.den && st->r_frame_rate.num)
3671             print_fps(av_q2d(st->r_frame_rate), "tbr");
3672         if(st->time_base.den && st->time_base.num)
3673             print_fps(1/av_q2d(st->time_base), "tbn");
3674         if(st->codec->time_base.den && st->codec->time_base.num)
3675             print_fps(1/av_q2d(st->codec->time_base), "tbc");
3676     }
3677     if (st->disposition & AV_DISPOSITION_DEFAULT)
3678         av_log(NULL, AV_LOG_INFO, " (default)");
3679     if (st->disposition & AV_DISPOSITION_DUB)
3680         av_log(NULL, AV_LOG_INFO, " (dub)");
3681     if (st->disposition & AV_DISPOSITION_ORIGINAL)
3682         av_log(NULL, AV_LOG_INFO, " (original)");
3683     if (st->disposition & AV_DISPOSITION_COMMENT)
3684         av_log(NULL, AV_LOG_INFO, " (comment)");
3685     if (st->disposition & AV_DISPOSITION_LYRICS)
3686         av_log(NULL, AV_LOG_INFO, " (lyrics)");
3687     if (st->disposition & AV_DISPOSITION_KARAOKE)
3688         av_log(NULL, AV_LOG_INFO, " (karaoke)");
3689     if (st->disposition & AV_DISPOSITION_FORCED)
3690         av_log(NULL, AV_LOG_INFO, " (forced)");
3691     if (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED)
3692         av_log(NULL, AV_LOG_INFO, " (hearing impaired)");
3693     if (st->disposition & AV_DISPOSITION_VISUAL_IMPAIRED)
3694         av_log(NULL, AV_LOG_INFO, " (visual impaired)");
3695     if (st->disposition & AV_DISPOSITION_CLEAN_EFFECTS)
3696         av_log(NULL, AV_LOG_INFO, " (clean effects)");
3697     av_log(NULL, AV_LOG_INFO, "\n");
3698     dump_metadata(NULL, st->metadata, "    ");
3699 }
3700
3701 #if FF_API_DUMP_FORMAT
3702 void dump_format(AVFormatContext *ic,
3703                  int index,
3704                  const char *url,
3705                  int is_output)
3706 {
3707     av_dump_format(ic, index, url, is_output);
3708 }
3709 #endif
3710
3711 void av_dump_format(AVFormatContext *ic,
3712                     int index,
3713                     const char *url,
3714                     int is_output)
3715 {
3716     int i;
3717     uint8_t *printed = ic->nb_streams ? av_mallocz(ic->nb_streams) : NULL;
3718     if (ic->nb_streams && !printed)
3719         return;
3720
3721     av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3722             is_output ? "Output" : "Input",
3723             index,
3724             is_output ? ic->oformat->name : ic->iformat->name,
3725             is_output ? "to" : "from", url);
3726     dump_metadata(NULL, ic->metadata, "  ");
3727     if (!is_output) {
3728         av_log(NULL, AV_LOG_INFO, "  Duration: ");
3729         if (ic->duration != AV_NOPTS_VALUE) {
3730             int hours, mins, secs, us;
3731             secs = ic->duration / AV_TIME_BASE;
3732             us = ic->duration % AV_TIME_BASE;
3733             mins = secs / 60;
3734             secs %= 60;
3735             hours = mins / 60;
3736             mins %= 60;
3737             av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3738                    (100 * us) / AV_TIME_BASE);
3739         } else {
3740             av_log(NULL, AV_LOG_INFO, "N/A");
3741         }
3742         if (ic->start_time != AV_NOPTS_VALUE) {
3743             int secs, us;
3744             av_log(NULL, AV_LOG_INFO, ", start: ");
3745             secs = ic->start_time / AV_TIME_BASE;
3746             us = abs(ic->start_time % AV_TIME_BASE);
3747             av_log(NULL, AV_LOG_INFO, "%d.%06d",
3748                    secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
3749         }
3750         av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3751         if (ic->bit_rate) {
3752             av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
3753         } else {
3754             av_log(NULL, AV_LOG_INFO, "N/A");
3755         }
3756         av_log(NULL, AV_LOG_INFO, "\n");
3757     }
3758     for (i = 0; i < ic->nb_chapters; i++) {
3759         AVChapter *ch = ic->chapters[i];
3760         av_log(NULL, AV_LOG_INFO, "    Chapter #%d.%d: ", index, i);
3761         av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
3762         av_log(NULL, AV_LOG_INFO, "end %f\n",   ch->end   * av_q2d(ch->time_base));
3763
3764         dump_metadata(NULL, ch->metadata, "    ");
3765     }
3766     if(ic->nb_programs) {
3767         int j, k, total = 0;
3768         for(j=0; j<ic->nb_programs; j++) {
3769             AVDictionaryEntry *name = av_dict_get(ic->programs[j]->metadata,
3770                                                   "name", NULL, 0);
3771             av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
3772                    name ? name->value : "");
3773             dump_metadata(NULL, ic->programs[j]->metadata, "    ");
3774             for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3775                 dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3776                 printed[ic->programs[j]->stream_index[k]] = 1;
3777             }
3778             total += ic->programs[j]->nb_stream_indexes;
3779         }
3780         if (total < ic->nb_streams)
3781             av_log(NULL, AV_LOG_INFO, "  No Program\n");
3782     }
3783     for(i=0;i<ic->nb_streams;i++)
3784         if (!printed[i])
3785             dump_stream_format(ic, i, index, is_output);
3786
3787     av_free(printed);
3788 }
3789
3790 int64_t av_gettime(void)
3791 {
3792     struct timeval tv;
3793     gettimeofday(&tv,NULL);
3794     return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
3795 }
3796
3797 uint64_t ff_ntp_time(void)
3798 {
3799   return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3800 }
3801
3802 #if FF_API_PARSE_DATE
3803 #include "libavutil/parseutils.h"
3804
3805 int64_t parse_date(const char *timestr, int duration)
3806 {
3807     int64_t timeval;
3808     av_parse_time(&timeval, timestr, duration);
3809     return timeval;
3810 }
3811 #endif
3812
3813 #if FF_API_FIND_INFO_TAG
3814 #include "libavutil/parseutils.h"
3815
3816 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
3817 {
3818     return av_find_info_tag(arg, arg_size, tag1, info);
3819 }
3820 #endif
3821
3822 int av_get_frame_filename(char *buf, int buf_size,
3823                           const char *path, int number)
3824 {
3825     const char *p;
3826     char *q, buf1[20], c;
3827     int nd, len, percentd_found;
3828
3829     q = buf;
3830     p = path;
3831     percentd_found = 0;
3832     for(;;) {
3833         c = *p++;
3834         if (c == '\0')
3835             break;
3836         if (c == '%') {
3837             do {
3838                 nd = 0;
3839                 while (isdigit(*p)) {
3840                     nd = nd * 10 + *p++ - '0';
3841                 }
3842                 c = *p++;
3843             } while (isdigit(c));
3844
3845             switch(c) {
3846             case '%':
3847                 goto addchar;
3848             case 'd':
3849                 if (percentd_found)
3850                     goto fail;
3851                 percentd_found = 1;
3852                 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3853                 len = strlen(buf1);
3854                 if ((q - buf + len) > buf_size - 1)
3855                     goto fail;
3856                 memcpy(q, buf1, len);
3857                 q += len;
3858                 break;
3859             default:
3860                 goto fail;
3861             }
3862         } else {
3863         addchar:
3864             if ((q - buf) < buf_size - 1)
3865                 *q++ = c;
3866         }
3867     }
3868     if (!percentd_found)
3869         goto fail;
3870     *q = '\0';
3871     return 0;
3872  fail:
3873     *q = '\0';
3874     return -1;
3875 }
3876
3877 static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3878 {
3879     int len, i, j, c;
3880 #undef fprintf
3881 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3882
3883     for(i=0;i<size;i+=16) {
3884         len = size - i;
3885         if (len > 16)
3886             len = 16;
3887         PRINT("%08x ", i);
3888         for(j=0;j<16;j++) {
3889             if (j < len)
3890                 PRINT(" %02x", buf[i+j]);
3891             else
3892                 PRINT("   ");
3893         }
3894         PRINT(" ");
3895         for(j=0;j<len;j++) {
3896             c = buf[i+j];
3897             if (c < ' ' || c > '~')
3898                 c = '.';
3899             PRINT("%c", c);
3900         }
3901         PRINT("\n");
3902     }
3903 #undef PRINT
3904 }
3905
3906 void av_hex_dump(FILE *f, uint8_t *buf, int size)
3907 {
3908     hex_dump_internal(NULL, f, 0, buf, size);
3909 }
3910
3911 void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3912 {
3913     hex_dump_internal(avcl, NULL, level, buf, size);
3914 }
3915
3916 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload, AVRational time_base)
3917 {
3918 #undef fprintf
3919 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3920     PRINT("stream #%d:\n", pkt->stream_index);
3921     PRINT("  keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
3922     PRINT("  duration=%0.3f\n", pkt->duration * av_q2d(time_base));
3923     /* DTS is _always_ valid after av_read_frame() */
3924     PRINT("  dts=");
3925     if (pkt->dts == AV_NOPTS_VALUE)
3926         PRINT("N/A");
3927     else
3928         PRINT("%0.3f", pkt->dts * av_q2d(time_base));
3929     /* PTS may not be known if B-frames are present. */
3930     PRINT("  pts=");
3931     if (pkt->pts == AV_NOPTS_VALUE)
3932         PRINT("N/A");
3933     else
3934         PRINT("%0.3f", pkt->pts * av_q2d(time_base));
3935     PRINT("\n");
3936     PRINT("  size=%d\n", pkt->size);
3937 #undef PRINT
3938     if (dump_payload)
3939         av_hex_dump(f, pkt->data, pkt->size);
3940 }
3941
3942 #if FF_API_PKT_DUMP
3943 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3944 {
3945     AVRational tb = { 1, AV_TIME_BASE };
3946     pkt_dump_internal(NULL, f, 0, pkt, dump_payload, tb);
3947 }
3948 #endif
3949
3950 void av_pkt_dump2(FILE *f, AVPacket *pkt, int dump_payload, AVStream *st)
3951 {
3952     pkt_dump_internal(NULL, f, 0, pkt, dump_payload, st->time_base);
3953 }
3954
3955 #if FF_API_PKT_DUMP
3956 void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3957 {
3958     AVRational tb = { 1, AV_TIME_BASE };
3959     pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, tb);
3960 }
3961 #endif
3962
3963 void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload,
3964                       AVStream *st)
3965 {
3966     pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, st->time_base);
3967 }
3968
3969 void av_url_split(char *proto, int proto_size,
3970                   char *authorization, int authorization_size,
3971                   char *hostname, int hostname_size,
3972                   int *port_ptr,
3973                   char *path, int path_size,
3974                   const char *url)
3975 {
3976     const char *p, *ls, *at, *col, *brk;
3977
3978     if (port_ptr)               *port_ptr = -1;
3979     if (proto_size > 0)         proto[0] = 0;
3980     if (authorization_size > 0) authorization[0] = 0;
3981     if (hostname_size > 0)      hostname[0] = 0;
3982     if (path_size > 0)          path[0] = 0;
3983
3984     /* parse protocol */
3985     if ((p = strchr(url, ':'))) {
3986         av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3987         p++; /* skip ':' */
3988         if (*p == '/') p++;
3989         if (*p == '/') p++;
3990     } else {
3991         /* no protocol means plain filename */
3992         av_strlcpy(path, url, path_size);
3993         return;
3994     }
3995
3996     /* separate path from hostname */
3997     ls = strchr(p, '/');
3998     if(!ls)
3999         ls = strchr(p, '?');
4000     if(ls)
4001         av_strlcpy(path, ls, path_size);
4002     else
4003         ls = &p[strlen(p)]; // XXX
4004
4005     /* the rest is hostname, use that to parse auth/port */
4006     if (ls != p) {
4007         /* authorization (user[:pass]@hostname) */
4008         if ((at = strchr(p, '@')) && at < ls) {
4009             av_strlcpy(authorization, p,
4010                        FFMIN(authorization_size, at + 1 - p));
4011             p = at + 1; /* skip '@' */
4012         }
4013
4014         if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
4015             /* [host]:port */
4016             av_strlcpy(hostname, p + 1,
4017                        FFMIN(hostname_size, brk - p));
4018             if (brk[1] == ':' && port_ptr)
4019                 *port_ptr = atoi(brk + 2);
4020         } else if ((col = strchr(p, ':')) && col < ls) {
4021             av_strlcpy(hostname, p,
4022                        FFMIN(col + 1 - p, hostname_size));
4023             if (port_ptr) *port_ptr = atoi(col + 1);
4024         } else
4025             av_strlcpy(hostname, p,
4026                        FFMIN(ls + 1 - p, hostname_size));
4027     }
4028 }
4029
4030 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
4031 {
4032     int i;
4033     static const char hex_table_uc[16] = { '0', '1', '2', '3',
4034                                            '4', '5', '6', '7',
4035                                            '8', '9', 'A', 'B',
4036                                            'C', 'D', 'E', 'F' };
4037     static const char hex_table_lc[16] = { '0', '1', '2', '3',
4038                                            '4', '5', '6', '7',
4039                                            '8', '9', 'a', 'b',
4040                                            'c', 'd', 'e', 'f' };
4041     const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
4042
4043     for(i = 0; i < s; i++) {
4044         buff[i * 2]     = hex_table[src[i] >> 4];
4045         buff[i * 2 + 1] = hex_table[src[i] & 0xF];
4046     }
4047
4048     return buff;
4049 }
4050
4051 int ff_hex_to_data(uint8_t *data, const char *p)
4052 {
4053     int c, len, v;
4054
4055     len = 0;
4056     v = 1;
4057     for (;;) {
4058         p += strspn(p, SPACE_CHARS);
4059         if (*p == '\0')
4060             break;
4061         c = toupper((unsigned char) *p++);
4062         if (c >= '0' && c <= '9')
4063             c = c - '0';
4064         else if (c >= 'A' && c <= 'F')
4065             c = c - 'A' + 10;
4066         else
4067             break;
4068         v = (v << 4) | c;
4069         if (v & 0x100) {
4070             if (data)
4071                 data[len] = v;
4072             len++;
4073             v = 1;
4074         }
4075     }
4076     return len;
4077 }
4078
4079 #if FF_API_SET_PTS_INFO
4080 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
4081                      unsigned int pts_num, unsigned int pts_den)
4082 {
4083     avpriv_set_pts_info(s, pts_wrap_bits, pts_num, pts_den);
4084 }
4085 #endif
4086
4087 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
4088                          unsigned int pts_num, unsigned int pts_den)
4089 {
4090     AVRational new_tb;
4091     if(av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)){
4092         if(new_tb.num != pts_num)
4093             av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/new_tb.num);
4094     }else
4095         av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
4096
4097     if(new_tb.num <= 0 || new_tb.den <= 0) {
4098         av_log(NULL, AV_LOG_ERROR, "Ignoring attempt to set invalid timebase for st:%d\n", s->index);
4099         return;
4100     }
4101     s->time_base = new_tb;
4102     s->pts_wrap_bits = pts_wrap_bits;
4103 }
4104
4105 int ff_url_join(char *str, int size, const char *proto,
4106                 const char *authorization, const char *hostname,
4107                 int port, const char *fmt, ...)
4108 {
4109 #if CONFIG_NETWORK
4110     struct addrinfo hints, *ai;
4111 #endif
4112
4113     str[0] = '\0';
4114     if (proto)
4115         av_strlcatf(str, size, "%s://", proto);
4116     if (authorization && authorization[0])
4117         av_strlcatf(str, size, "%s@", authorization);
4118 #if CONFIG_NETWORK && defined(AF_INET6)
4119     /* Determine if hostname is a numerical IPv6 address,
4120      * properly escape it within [] in that case. */
4121     memset(&hints, 0, sizeof(hints));
4122     hints.ai_flags = AI_NUMERICHOST;
4123     if (!getaddrinfo(hostname, NULL, &hints, &ai)) {
4124         if (ai->ai_family == AF_INET6) {
4125             av_strlcat(str, "[", size);
4126             av_strlcat(str, hostname, size);
4127             av_strlcat(str, "]", size);
4128         } else {
4129             av_strlcat(str, hostname, size);
4130         }
4131         freeaddrinfo(ai);
4132     } else
4133 #endif
4134         /* Not an IPv6 address, just output the plain string. */
4135         av_strlcat(str, hostname, size);
4136
4137     if (port >= 0)
4138         av_strlcatf(str, size, ":%d", port);
4139     if (fmt) {
4140         va_list vl;
4141         int len = strlen(str);
4142
4143         va_start(vl, fmt);
4144         vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);
4145         va_end(vl);
4146     }
4147     return strlen(str);
4148 }
4149
4150 int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
4151                      AVFormatContext *src)
4152 {
4153     AVPacket local_pkt;
4154
4155     local_pkt = *pkt;
4156     local_pkt.stream_index = dst_stream;
4157     if (pkt->pts != AV_NOPTS_VALUE)
4158         local_pkt.pts = av_rescale_q(pkt->pts,
4159                                      src->streams[pkt->stream_index]->time_base,
4160                                      dst->streams[dst_stream]->time_base);
4161     if (pkt->dts != AV_NOPTS_VALUE)
4162         local_pkt.dts = av_rescale_q(pkt->dts,
4163                                      src->streams[pkt->stream_index]->time_base,
4164                                      dst->streams[dst_stream]->time_base);
4165     return av_write_frame(dst, &local_pkt);
4166 }
4167
4168 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
4169                         void *context)
4170 {
4171     const char *ptr = str;
4172
4173     /* Parse key=value pairs. */
4174     for (;;) {
4175         const char *key;
4176         char *dest = NULL, *dest_end;
4177         int key_len, dest_len = 0;
4178
4179         /* Skip whitespace and potential commas. */
4180         while (*ptr && (isspace(*ptr) || *ptr == ','))
4181             ptr++;
4182         if (!*ptr)
4183             break;
4184
4185         key = ptr;
4186
4187         if (!(ptr = strchr(key, '=')))
4188             break;
4189         ptr++;
4190         key_len = ptr - key;
4191
4192         callback_get_buf(context, key, key_len, &dest, &dest_len);
4193         dest_end = dest + dest_len - 1;
4194
4195         if (*ptr == '\"') {
4196             ptr++;
4197             while (*ptr && *ptr != '\"') {
4198                 if (*ptr == '\\') {
4199                     if (!ptr[1])
4200                         break;
4201                     if (dest && dest < dest_end)
4202                         *dest++ = ptr[1];
4203                     ptr += 2;
4204                 } else {
4205                     if (dest && dest < dest_end)
4206                         *dest++ = *ptr;
4207                     ptr++;
4208                 }
4209             }
4210             if (*ptr == '\"')
4211                 ptr++;
4212         } else {
4213             for (; *ptr && !(isspace(*ptr) || *ptr == ','); ptr++)
4214                 if (dest && dest < dest_end)
4215                     *dest++ = *ptr;
4216         }
4217         if (dest)
4218             *dest = 0;
4219     }
4220 }
4221
4222 int ff_find_stream_index(AVFormatContext *s, int id)
4223 {
4224     int i;
4225     for (i = 0; i < s->nb_streams; i++) {
4226         if (s->streams[i]->id == id)
4227             return i;
4228     }
4229     return -1;
4230 }
4231
4232 void ff_make_absolute_url(char *buf, int size, const char *base,
4233                           const char *rel)
4234 {
4235     char *sep;
4236     /* Absolute path, relative to the current server */
4237     if (base && strstr(base, "://") && rel[0] == '/') {
4238         if (base != buf)
4239             av_strlcpy(buf, base, size);
4240         sep = strstr(buf, "://");
4241         if (sep) {
4242             sep += 3;
4243             sep = strchr(sep, '/');
4244             if (sep)
4245                 *sep = '\0';
4246         }
4247         av_strlcat(buf, rel, size);
4248         return;
4249     }
4250     /* If rel actually is an absolute url, just copy it */
4251     if (!base || strstr(rel, "://") || rel[0] == '/') {
4252         av_strlcpy(buf, rel, size);
4253         return;
4254     }
4255     if (base != buf)
4256         av_strlcpy(buf, base, size);
4257     /* Remove the file name from the base url */
4258     sep = strrchr(buf, '/');
4259     if (sep)
4260         sep[1] = '\0';
4261     else
4262         buf[0] = '\0';
4263     while (av_strstart(rel, "../", NULL) && sep) {
4264         /* Remove the path delimiter at the end */
4265         sep[0] = '\0';
4266         sep = strrchr(buf, '/');
4267         /* If the next directory name to pop off is "..", break here */
4268         if (!strcmp(sep ? &sep[1] : buf, "..")) {
4269             /* Readd the slash we just removed */
4270             av_strlcat(buf, "/", size);
4271             break;
4272         }
4273         /* Cut off the directory name */
4274         if (sep)
4275             sep[1] = '\0';
4276         else
4277             buf[0] = '\0';
4278         rel += 3;
4279     }
4280     av_strlcat(buf, rel, size);
4281 }
4282
4283 int64_t ff_iso8601_to_unix_time(const char *datestr)
4284 {
4285 #if HAVE_STRPTIME
4286     struct tm time1 = {0}, time2 = {0};
4287     char *ret1, *ret2;
4288     ret1 = strptime(datestr, "%Y - %m - %d %T", &time1);
4289     ret2 = strptime(datestr, "%Y - %m - %dT%T", &time2);
4290     if (ret2 && !ret1)
4291         return av_timegm(&time2);
4292     else
4293         return av_timegm(&time1);
4294 #else
4295     av_log(NULL, AV_LOG_WARNING, "strptime() unavailable on this system, cannot convert "
4296                                  "the date string.\n");
4297     return 0;
4298 #endif
4299 }
4300
4301 int avformat_query_codec(AVOutputFormat *ofmt, enum CodecID codec_id, int std_compliance)
4302 {
4303     if (ofmt) {
4304         if (ofmt->query_codec)
4305             return ofmt->query_codec(codec_id, std_compliance);
4306         else if (ofmt->codec_tag)
4307             return !!av_codec_get_tag(ofmt->codec_tag, codec_id);
4308         else if (codec_id == ofmt->video_codec || codec_id == ofmt->audio_codec ||
4309                  codec_id == ofmt->subtitle_codec)
4310             return 1;
4311     }
4312     return AVERROR_PATCHWELCOME;
4313 }
4314
4315 int avformat_network_init(void)
4316 {
4317 #if CONFIG_NETWORK
4318     int ret;
4319     ff_network_inited_globally = 1;
4320     if ((ret = ff_network_init()) < 0)
4321         return ret;
4322     ff_tls_init();
4323 #endif
4324     return 0;
4325 }
4326
4327 int avformat_network_deinit(void)
4328 {
4329 #if CONFIG_NETWORK
4330     ff_network_close();
4331     ff_tls_deinit();
4332 #endif
4333     return 0;
4334 }
4335
4336 int ff_add_param_change(AVPacket *pkt, int32_t channels,
4337                         uint64_t channel_layout, int32_t sample_rate,
4338                         int32_t width, int32_t height)
4339 {
4340     uint32_t flags = 0;
4341     int size = 4;
4342     uint8_t *data;
4343     if (!pkt)
4344         return AVERROR(EINVAL);
4345     if (channels) {
4346         size += 4;
4347         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
4348     }
4349     if (channel_layout) {
4350         size += 8;
4351         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
4352     }
4353     if (sample_rate) {
4354         size += 4;
4355         flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
4356     }
4357     if (width || height) {
4358         size += 8;
4359         flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
4360     }
4361     data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
4362     if (!data)
4363         return AVERROR(ENOMEM);
4364     bytestream_put_le32(&data, flags);
4365     if (channels)
4366         bytestream_put_le32(&data, channels);
4367     if (channel_layout)
4368         bytestream_put_le64(&data, channel_layout);
4369     if (sample_rate)
4370         bytestream_put_le32(&data, sample_rate);
4371     if (width || height) {
4372         bytestream_put_le32(&data, width);
4373         bytestream_put_le32(&data, height);
4374     }
4375     return 0;
4376 }