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