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