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

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