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