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