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