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, 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) {
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     if (start_time != INT64_MAX) {
2067         ic->start_time = start_time;
2068         if (end_time != INT64_MIN)
2069             duration = FFMAX(duration, end_time - start_time);
2070     }
2071     if (duration != INT64_MIN && ic->duration == AV_NOPTS_VALUE) {
2072         ic->duration = duration;
2073     }
2074         if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration != AV_NOPTS_VALUE) {
2075             /* compute the bitrate */
2076             ic->bit_rate = (double)filesize * 8.0 * AV_TIME_BASE /
2077                 (double)ic->duration;
2078         }
2079 }
2080
2081 static void fill_all_stream_timings(AVFormatContext *ic)
2082 {
2083     int i;
2084     AVStream *st;
2085
2086     update_stream_timings(ic);
2087     for(i = 0;i < ic->nb_streams; i++) {
2088         st = ic->streams[i];
2089         if (st->start_time == AV_NOPTS_VALUE) {
2090             if(ic->start_time != AV_NOPTS_VALUE)
2091                 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
2092             if(ic->duration != AV_NOPTS_VALUE)
2093                 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
2094         }
2095     }
2096 }
2097
2098 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
2099 {
2100     int64_t filesize, duration;
2101     int bit_rate, i;
2102     AVStream *st;
2103
2104     /* if bit_rate is already set, we believe it */
2105     if (ic->bit_rate <= 0) {
2106         bit_rate = 0;
2107         for(i=0;i<ic->nb_streams;i++) {
2108             st = ic->streams[i];
2109             if (st->codec->bit_rate > 0)
2110             bit_rate += st->codec->bit_rate;
2111         }
2112         ic->bit_rate = bit_rate;
2113     }
2114
2115     /* if duration is already set, we believe it */
2116     if (ic->duration == AV_NOPTS_VALUE &&
2117         ic->bit_rate != 0) {
2118         filesize = ic->pb ? avio_size(ic->pb) : 0;
2119         if (filesize > 0) {
2120             for(i = 0; i < ic->nb_streams; i++) {
2121                 st = ic->streams[i];
2122                 duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
2123                 if (st->duration == AV_NOPTS_VALUE)
2124                     st->duration = duration;
2125             }
2126         }
2127     }
2128 }
2129
2130 #define DURATION_MAX_READ_SIZE 250000
2131 #define DURATION_MAX_RETRY 3
2132
2133 /* only usable for MPEG-PS streams */
2134 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2135 {
2136     AVPacket pkt1, *pkt = &pkt1;
2137     AVStream *st;
2138     int read_size, i, ret;
2139     int64_t end_time;
2140     int64_t filesize, offset, duration;
2141     int retry=0;
2142
2143     /* flush packet queue */
2144     flush_packet_queue(ic);
2145
2146     for (i=0; i<ic->nb_streams; i++) {
2147         st = ic->streams[i];
2148         if (st->start_time == AV_NOPTS_VALUE && st->first_dts == AV_NOPTS_VALUE)
2149             av_log(st->codec, AV_LOG_WARNING, "start time is not set in estimate_timings_from_pts\n");
2150
2151         if (st->parser) {
2152             av_parser_close(st->parser);
2153             st->parser= NULL;
2154         }
2155     }
2156
2157     /* estimate the end time (duration) */
2158     /* XXX: may need to support wrapping */
2159     filesize = ic->pb ? avio_size(ic->pb) : 0;
2160     end_time = AV_NOPTS_VALUE;
2161     do{
2162         offset = filesize - (DURATION_MAX_READ_SIZE<<retry);
2163         if (offset < 0)
2164             offset = 0;
2165
2166         avio_seek(ic->pb, offset, SEEK_SET);
2167         read_size = 0;
2168         for(;;) {
2169             if (read_size >= DURATION_MAX_READ_SIZE<<(FFMAX(retry-1,0)))
2170                 break;
2171
2172             do {
2173                 ret = ff_read_packet(ic, pkt);
2174             } while(ret == AVERROR(EAGAIN));
2175             if (ret != 0)
2176                 break;
2177             read_size += pkt->size;
2178             st = ic->streams[pkt->stream_index];
2179             if (pkt->pts != AV_NOPTS_VALUE &&
2180                 (st->start_time != AV_NOPTS_VALUE ||
2181                  st->first_dts  != AV_NOPTS_VALUE)) {
2182                 duration = end_time = pkt->pts;
2183                 if (st->start_time != AV_NOPTS_VALUE)
2184                     duration -= st->start_time;
2185                 else
2186                     duration -= st->first_dts;
2187                 if (duration < 0)
2188                     duration += 1LL<<st->pts_wrap_bits;
2189                 if (duration > 0) {
2190                     if (st->duration == AV_NOPTS_VALUE || st->duration < duration)
2191                         st->duration = duration;
2192                 }
2193             }
2194             av_free_packet(pkt);
2195         }
2196     }while(   end_time==AV_NOPTS_VALUE
2197            && filesize > (DURATION_MAX_READ_SIZE<<retry)
2198            && ++retry <= DURATION_MAX_RETRY);
2199
2200     fill_all_stream_timings(ic);
2201
2202     avio_seek(ic->pb, old_offset, SEEK_SET);
2203     for (i=0; i<ic->nb_streams; i++) {
2204         st= ic->streams[i];
2205         st->cur_dts= st->first_dts;
2206         st->last_IP_pts = AV_NOPTS_VALUE;
2207         st->reference_dts = AV_NOPTS_VALUE;
2208     }
2209 }
2210
2211 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2212 {
2213     int64_t file_size;
2214
2215     /* get the file size, if possible */
2216     if (ic->iformat->flags & AVFMT_NOFILE) {
2217         file_size = 0;
2218     } else {
2219         file_size = avio_size(ic->pb);
2220         file_size = FFMAX(0, file_size);
2221     }
2222
2223     if ((!strcmp(ic->iformat->name, "mpeg") ||
2224          !strcmp(ic->iformat->name, "mpegts")) &&
2225         file_size && ic->pb->seekable) {
2226         /* get accurate estimate from the PTSes */
2227         estimate_timings_from_pts(ic, old_offset);
2228     } else if (has_duration(ic)) {
2229         /* at least one component has timings - we use them for all
2230            the components */
2231         fill_all_stream_timings(ic);
2232     } else {
2233         av_log(ic, AV_LOG_WARNING, "Estimating duration from bitrate, this may be inaccurate\n");
2234         /* less precise: use bitrate info */
2235         estimate_timings_from_bit_rate(ic);
2236     }
2237     update_stream_timings(ic);
2238
2239     {
2240         int i;
2241         AVStream av_unused *st;
2242         for(i = 0;i < ic->nb_streams; i++) {
2243             st = ic->streams[i];
2244             av_dlog(ic, "%d: start_time: %0.3f duration: %0.3f\n", i,
2245                     (double) st->start_time / AV_TIME_BASE,
2246                     (double) st->duration   / AV_TIME_BASE);
2247         }
2248         av_dlog(ic, "stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2249                 (double) ic->start_time / AV_TIME_BASE,
2250                 (double) ic->duration   / AV_TIME_BASE,
2251                 ic->bit_rate / 1000);
2252     }
2253 }
2254
2255 static int has_codec_parameters(AVStream *st)
2256 {
2257     AVCodecContext *avctx = st->codec;
2258     int val;
2259     switch (avctx->codec_type) {
2260     case AVMEDIA_TYPE_AUDIO:
2261         val = avctx->sample_rate && avctx->channels;
2262         if (!avctx->frame_size && determinable_frame_size(avctx))
2263             return 0;
2264         if (st->info->found_decoder >= 0 && avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
2265             return 0;
2266         break;
2267     case AVMEDIA_TYPE_VIDEO:
2268         val = avctx->width;
2269         if (st->info->found_decoder >= 0 && avctx->pix_fmt == PIX_FMT_NONE)
2270             return 0;
2271         break;
2272     case AVMEDIA_TYPE_DATA:
2273         if(avctx->codec_id == CODEC_ID_NONE) return 1;
2274     default:
2275         val = 1;
2276         break;
2277     }
2278     return avctx->codec_id != CODEC_ID_NONE && val != 0;
2279 }
2280
2281 static int has_decode_delay_been_guessed(AVStream *st)
2282 {
2283     return st->codec->codec_id != CODEC_ID_H264 ||
2284         st->info->nb_decoded_frames >= 6;
2285 }
2286
2287 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
2288 static int try_decode_frame(AVStream *st, AVPacket *avpkt, AVDictionary **options)
2289 {
2290     AVCodec *codec;
2291     int got_picture = 1, ret = 0;
2292     AVFrame picture;
2293     AVPacket pkt = *avpkt;
2294
2295     if (!avcodec_is_open(st->codec) && !st->info->found_decoder) {
2296         AVDictionary *thread_opt = NULL;
2297
2298         codec = st->codec->codec ? st->codec->codec :
2299                                    avcodec_find_decoder(st->codec->codec_id);
2300
2301         if (!codec) {
2302             st->info->found_decoder = -1;
2303             return -1;
2304         }
2305
2306         /* force thread count to 1 since the h264 decoder will not extract SPS
2307          *  and PPS to extradata during multi-threaded decoding */
2308         av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
2309         ret = avcodec_open2(st->codec, codec, options ? options : &thread_opt);
2310         if (!options)
2311             av_dict_free(&thread_opt);
2312         if (ret < 0) {
2313             st->info->found_decoder = -1;
2314             return ret;
2315         }
2316         st->info->found_decoder = 1;
2317     } else if (!st->info->found_decoder)
2318         st->info->found_decoder = 1;
2319
2320     if (st->info->found_decoder < 0)
2321         return -1;
2322
2323     while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
2324            ret >= 0 &&
2325            (!has_codec_parameters(st)         ||
2326            !has_decode_delay_been_guessed(st) ||
2327            (!st->codec_info_nb_frames && st->codec->codec->capabilities & CODEC_CAP_CHANNEL_CONF))) {
2328         got_picture = 0;
2329         avcodec_get_frame_defaults(&picture);
2330         switch(st->codec->codec_type) {
2331         case AVMEDIA_TYPE_VIDEO:
2332             ret = avcodec_decode_video2(st->codec, &picture,
2333                                         &got_picture, &pkt);
2334             break;
2335         case AVMEDIA_TYPE_AUDIO:
2336             ret = avcodec_decode_audio4(st->codec, &picture, &got_picture, &pkt);
2337             break;
2338         default:
2339             break;
2340         }
2341         if (ret >= 0) {
2342             if (got_picture)
2343                 st->info->nb_decoded_frames++;
2344             pkt.data += ret;
2345             pkt.size -= ret;
2346             ret       = got_picture;
2347         }
2348     }
2349     if(!pkt.data && !got_picture)
2350         return -1;
2351     return ret;
2352 }
2353
2354 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum CodecID id)
2355 {
2356     while (tags->id != CODEC_ID_NONE) {
2357         if (tags->id == id)
2358             return tags->tag;
2359         tags++;
2360     }
2361     return 0;
2362 }
2363
2364 enum CodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2365 {
2366     int i;
2367     for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
2368         if(tag == tags[i].tag)
2369             return tags[i].id;
2370     }
2371     for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
2372         if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
2373             return tags[i].id;
2374     }
2375     return CODEC_ID_NONE;
2376 }
2377
2378 unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum CodecID id)
2379 {
2380     int i;
2381     for(i=0; tags && tags[i]; i++){
2382         int tag= ff_codec_get_tag(tags[i], id);
2383         if(tag) return tag;
2384     }
2385     return 0;
2386 }
2387
2388 enum CodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
2389 {
2390     int i;
2391     for(i=0; tags && tags[i]; i++){
2392         enum CodecID id= ff_codec_get_id(tags[i], tag);
2393         if(id!=CODEC_ID_NONE) return id;
2394     }
2395     return CODEC_ID_NONE;
2396 }
2397
2398 static void compute_chapters_end(AVFormatContext *s)
2399 {
2400     unsigned int i, j;
2401     int64_t max_time = s->duration + ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
2402
2403     for (i = 0; i < s->nb_chapters; i++)
2404         if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2405             AVChapter *ch = s->chapters[i];
2406             int64_t   end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q, ch->time_base)
2407                                      : INT64_MAX;
2408
2409             for (j = 0; j < s->nb_chapters; j++) {
2410                 AVChapter *ch1 = s->chapters[j];
2411                 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base, ch->time_base);
2412                 if (j != i && next_start > ch->start && next_start < end)
2413                     end = next_start;
2414             }
2415             ch->end = (end == INT64_MAX) ? ch->start : end;
2416         }
2417 }
2418
2419 static int get_std_framerate(int i){
2420     if(i<60*12) return i*1001;
2421     else        return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
2422 }
2423
2424 /*
2425  * Is the time base unreliable.
2426  * This is a heuristic to balance between quick acceptance of the values in
2427  * the headers vs. some extra checks.
2428  * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2429  * MPEG-2 commonly misuses field repeat flags to store different framerates.
2430  * And there are "variable" fps files this needs to detect as well.
2431  */
2432 static int tb_unreliable(AVCodecContext *c){
2433     if(   c->time_base.den >= 101L*c->time_base.num
2434        || c->time_base.den <    5L*c->time_base.num
2435 /*       || c->codec_tag == AV_RL32("DIVX")
2436        || c->codec_tag == AV_RL32("XVID")*/
2437        || c->codec_id == CODEC_ID_MPEG2VIDEO
2438        || c->codec_id == CODEC_ID_H264
2439        )
2440         return 1;
2441     return 0;
2442 }
2443
2444 #if FF_API_FORMAT_PARAMETERS
2445 int av_find_stream_info(AVFormatContext *ic)
2446 {
2447     return avformat_find_stream_info(ic, NULL);
2448 }
2449 #endif
2450
2451 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
2452 {
2453     int i, count, ret, read_size, j;
2454     AVStream *st;
2455     AVPacket pkt1, *pkt;
2456     int64_t old_offset = avio_tell(ic->pb);
2457     int orig_nb_streams = ic->nb_streams;        // new streams might appear, no options for those
2458     int flush_codecs = 1;
2459
2460     if(ic->pb)
2461         av_log(ic, AV_LOG_DEBUG, "File position before avformat_find_stream_info() is %"PRId64"\n", avio_tell(ic->pb));
2462
2463     for(i=0;i<ic->nb_streams;i++) {
2464         AVCodec *codec;
2465         AVDictionary *thread_opt = NULL;
2466         st = ic->streams[i];
2467
2468         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2469             st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2470 /*            if(!st->time_base.num)
2471                 st->time_base= */
2472             if(!st->codec->time_base.num)
2473                 st->codec->time_base= st->time_base;
2474         }
2475         //only for the split stuff
2476         if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
2477             st->parser = av_parser_init(st->codec->codec_id);
2478             if(st->parser){
2479                 if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
2480                     st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2481                 } else if(st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
2482                     st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
2483                 }
2484             } else if (st->need_parsing) {
2485                 av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
2486                        "%s, packets or times may be invalid.\n",
2487                        avcodec_get_name(st->codec->codec_id));
2488             }
2489         }
2490         codec = st->codec->codec ? st->codec->codec :
2491                                    avcodec_find_decoder(st->codec->codec_id);
2492
2493         /* force thread count to 1 since the h264 decoder will not extract SPS
2494          *  and PPS to extradata during multi-threaded decoding */
2495         av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
2496
2497         /* Ensure that subtitle_header is properly set. */
2498         if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
2499             && codec && !st->codec->codec)
2500             avcodec_open2(st->codec, codec, options ? &options[i]
2501                               : &thread_opt);
2502
2503         //try to just open decoders, in case this is enough to get parameters
2504         if (!has_codec_parameters(st)) {
2505             if (codec && !st->codec->codec)
2506                 avcodec_open2(st->codec, codec, options ? &options[i]
2507                               : &thread_opt);
2508         }
2509         if (!options)
2510             av_dict_free(&thread_opt);
2511     }
2512
2513     for (i=0; i<ic->nb_streams; i++) {
2514         ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
2515     }
2516
2517     count = 0;
2518     read_size = 0;
2519     for(;;) {
2520         if (ff_check_interrupt(&ic->interrupt_callback)){
2521             ret= AVERROR_EXIT;
2522             av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2523             break;
2524         }
2525
2526         /* check if one codec still needs to be handled */
2527         for(i=0;i<ic->nb_streams;i++) {
2528             int fps_analyze_framecount = 20;
2529
2530             st = ic->streams[i];
2531             if (!has_codec_parameters(st))
2532                 break;
2533             /* if the timebase is coarse (like the usual millisecond precision
2534                of mkv), we need to analyze more frames to reliably arrive at
2535                the correct fps */
2536             if (av_q2d(st->time_base) > 0.0005)
2537                 fps_analyze_framecount *= 2;
2538             if (ic->fps_probe_size >= 0)
2539                 fps_analyze_framecount = ic->fps_probe_size;
2540             /* variable fps and no guess at the real fps */
2541             if(   tb_unreliable(st->codec) && !(st->r_frame_rate.num && st->avg_frame_rate.num)
2542                && st->info->duration_count < fps_analyze_framecount
2543                && st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2544                 break;
2545             if(st->parser && st->parser->parser->split && !st->codec->extradata)
2546                 break;
2547             if (st->first_dts == AV_NOPTS_VALUE &&
2548                 (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2549                  st->codec->codec_type == AVMEDIA_TYPE_AUDIO))
2550                 break;
2551         }
2552         if (i == ic->nb_streams) {
2553             /* NOTE: if the format has no header, then we need to read
2554                some packets to get most of the streams, so we cannot
2555                stop here */
2556             if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2557                 /* if we found the info for all the codecs, we can stop */
2558                 ret = count;
2559                 av_log(ic, AV_LOG_DEBUG, "All info found\n");
2560                 flush_codecs = 0;
2561                 break;
2562             }
2563         }
2564         /* we did not get all the codec info, but we read too much data */
2565         if (read_size >= ic->probesize) {
2566             ret = count;
2567             av_log(ic, AV_LOG_DEBUG, "Probe buffer size limit %d reached\n", ic->probesize);
2568             for (i = 0; i < ic->nb_streams; i++)
2569                 if (!ic->streams[i]->r_frame_rate.num &&
2570                     ic->streams[i]->info->duration_count <= 1)
2571                     av_log(ic, AV_LOG_WARNING,
2572                            "Stream #%d: not enough frames to estimate rate; "
2573                            "consider increasing probesize\n", i);
2574             break;
2575         }
2576
2577         /* NOTE: a new stream can be added there if no header in file
2578            (AVFMTCTX_NOHEADER) */
2579         ret = read_frame_internal(ic, &pkt1);
2580         if (ret == AVERROR(EAGAIN))
2581             continue;
2582
2583         if (ret < 0) {
2584             /* EOF or error*/
2585             break;
2586         }
2587
2588         pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2589         if ((ret = av_dup_packet(pkt)) < 0)
2590             goto find_stream_info_err;
2591
2592         read_size += pkt->size;
2593
2594         st = ic->streams[pkt->stream_index];
2595         if (st->codec_info_nb_frames>1) {
2596             int64_t t=0;
2597             if (st->time_base.den > 0)
2598                 t = av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
2599             if (st->avg_frame_rate.num > 0)
2600                 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));
2601
2602             if (t >= ic->max_analyze_duration) {
2603                 av_log(ic, AV_LOG_WARNING, "max_analyze_duration %d reached at %"PRId64"\n", ic->max_analyze_duration, t);
2604                 break;
2605             }
2606             st->info->codec_info_duration += pkt->duration;
2607         }
2608         {
2609             int64_t last = st->info->last_dts;
2610
2611             if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && pkt->dts > last){
2612                 double dts= (is_relative(pkt->dts) ?  pkt->dts - RELATIVE_TS_BASE : pkt->dts) * av_q2d(st->time_base);
2613                 int64_t duration= pkt->dts - last;
2614
2615 //                 if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2616 //                     av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
2617                 for (i=1; i<FF_ARRAY_ELEMS(st->info->duration_error[0][0]); i++) {
2618                     int framerate= get_std_framerate(i);
2619                     double sdts= dts*framerate/(1001*12);
2620                     for(j=0; j<2; j++){
2621                         int ticks= lrintf(sdts+j*0.5);
2622                         double error= sdts - ticks + j*0.5;
2623                         st->info->duration_error[j][0][i] += error;
2624                         st->info->duration_error[j][1][i] += error*error;
2625                     }
2626                 }
2627                 st->info->duration_count++;
2628                 // ignore the first 4 values, they might have some random jitter
2629                 if (st->info->duration_count > 3)
2630                     st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2631             }
2632             if (last == AV_NOPTS_VALUE || st->info->duration_count <= 1)
2633                 st->info->last_dts = pkt->dts;
2634         }
2635         if(st->parser && st->parser->parser->split && !st->codec->extradata){
2636             int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2637             if (i > 0 && i < FF_MAX_EXTRADATA_SIZE) {
2638                 st->codec->extradata_size= i;
2639                 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2640                 if (!st->codec->extradata)
2641                     return AVERROR(ENOMEM);
2642                 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2643                 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2644             }
2645         }
2646
2647         /* if still no information, we try to open the codec and to
2648            decompress the frame. We try to avoid that in most cases as
2649            it takes longer and uses more memory. For MPEG-4, we need to
2650            decompress for QuickTime.
2651
2652            If CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
2653            least one frame of codec data, this makes sure the codec initializes
2654            the channel configuration and does not only trust the values from the container.
2655         */
2656         try_decode_frame(st, pkt, (options && i < orig_nb_streams ) ? &options[i] : NULL);
2657
2658         st->codec_info_nb_frames++;
2659         count++;
2660     }
2661
2662     if (flush_codecs) {
2663         AVPacket empty_pkt = { 0 };
2664         int err = 0;
2665         av_init_packet(&empty_pkt);
2666
2667         ret = -1; /* we could not have all the codec parameters before EOF */
2668         for(i=0;i<ic->nb_streams;i++) {
2669             st = ic->streams[i];
2670
2671             /* flush the decoders */
2672             if (st->info->found_decoder == 1) {
2673                 do {
2674                     err = try_decode_frame(st, &empty_pkt,
2675                                             (options && i < orig_nb_streams) ?
2676                                             &options[i] : NULL);
2677                 } while (err > 0 && !has_codec_parameters(st));
2678
2679                 if (err < 0) {
2680                     av_log(ic, AV_LOG_INFO,
2681                         "decoding for stream %d failed\n", st->index);
2682                 }
2683             }
2684
2685             if (!has_codec_parameters(st)){
2686                 char buf[256];
2687                 avcodec_string(buf, sizeof(buf), st->codec, 0);
2688                 av_log(ic, AV_LOG_WARNING,
2689                        "Could not find codec parameters (%s)\n", buf);
2690             } else {
2691                 ret = 0;
2692             }
2693         }
2694     }
2695
2696     // close codecs which were opened in try_decode_frame()
2697     for(i=0;i<ic->nb_streams;i++) {
2698         st = ic->streams[i];
2699         avcodec_close(st->codec);
2700     }
2701     for(i=0;i<ic->nb_streams;i++) {
2702         st = ic->streams[i];
2703         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2704             if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample){
2705                 uint32_t tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2706                 if(ff_find_pix_fmt(ff_raw_pix_fmt_tags, tag) == st->codec->pix_fmt)
2707                     st->codec->codec_tag= tag;
2708             }
2709
2710             if (st->codec_info_nb_frames>2 && !st->avg_frame_rate.num && st->info->codec_info_duration)
2711                 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2712                           (st->codec_info_nb_frames-2)*(int64_t)st->time_base.den,
2713                           st->info->codec_info_duration*(int64_t)st->time_base.num, 60000);
2714             // the check for tb_unreliable() is not completely correct, since this is not about handling
2715             // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2716             // ipmovie.c produces.
2717             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)
2718                 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);
2719             if (st->info->duration_count && !st->r_frame_rate.num
2720                && tb_unreliable(st->codec) /*&&
2721                //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2722                st->time_base.num*duration_sum[i]/st->info->duration_count*101LL > st->time_base.den*/){
2723                 int num = 0;
2724                 double best_error= 0.01;
2725
2726                 for (j=1; j<FF_ARRAY_ELEMS(st->info->duration_error[0][0]); j++) {
2727                     int k;
2728
2729                     if(st->info->codec_info_duration && st->info->codec_info_duration*av_q2d(st->time_base) < (1001*12.0)/get_std_framerate(j))
2730                         continue;
2731                     if(!st->info->codec_info_duration && 1.0 < (1001*12.0)/get_std_framerate(j))
2732                         continue;
2733                     for(k=0; k<2; k++){
2734                         int n= st->info->duration_count;
2735                         double a= st->info->duration_error[k][0][j] / n;
2736                         double error= st->info->duration_error[k][1][j]/n - a*a;
2737
2738                         if(error < best_error && best_error> 0.000000001){
2739                             best_error= error;
2740                             num = get_std_framerate(j);
2741                         }
2742                         if(error < 0.02)
2743                             av_log(NULL, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
2744                     }
2745                 }
2746                 // do not increase frame rate by more than 1 % in order to match a standard rate.
2747                 if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
2748                     av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2749             }
2750
2751             if (!st->r_frame_rate.num){
2752                 if(    st->codec->time_base.den * (int64_t)st->time_base.num
2753                     <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
2754                     st->r_frame_rate.num = st->codec->time_base.den;
2755                     st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
2756                 }else{
2757                     st->r_frame_rate.num = st->time_base.den;
2758                     st->r_frame_rate.den = st->time_base.num;
2759                 }
2760             }
2761         }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2762             if(!st->codec->bits_per_coded_sample)
2763                 st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2764             // set stream disposition based on audio service type
2765             switch (st->codec->audio_service_type) {
2766             case AV_AUDIO_SERVICE_TYPE_EFFECTS:
2767                 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;    break;
2768             case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
2769                 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;  break;
2770             case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
2771                 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED; break;
2772             case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
2773                 st->disposition = AV_DISPOSITION_COMMENT;          break;
2774             case AV_AUDIO_SERVICE_TYPE_KARAOKE:
2775                 st->disposition = AV_DISPOSITION_KARAOKE;          break;
2776             }
2777         }
2778     }
2779
2780     estimate_timings(ic, old_offset);
2781
2782     compute_chapters_end(ic);
2783
2784  find_stream_info_err:
2785     for (i=0; i < ic->nb_streams; i++) {
2786         if (ic->streams[i]->codec)
2787             ic->streams[i]->codec->thread_count = 0;
2788         av_freep(&ic->streams[i]->info);
2789     }
2790     if(ic->pb)
2791         av_log(ic, AV_LOG_DEBUG, "File position after avformat_find_stream_info() is %"PRId64"\n", avio_tell(ic->pb));
2792     return ret;
2793 }
2794
2795 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
2796 {
2797     int i, j;
2798
2799     for (i = 0; i < ic->nb_programs; i++) {
2800         if (ic->programs[i] == last) {
2801             last = NULL;
2802         } else {
2803             if (!last)
2804                 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
2805                     if (ic->programs[i]->stream_index[j] == s)
2806                         return ic->programs[i];
2807         }
2808     }
2809     return NULL;
2810 }
2811
2812 int av_find_best_stream(AVFormatContext *ic,
2813                         enum AVMediaType type,
2814                         int wanted_stream_nb,
2815                         int related_stream,
2816                         AVCodec **decoder_ret,
2817                         int flags)
2818 {
2819     int i, nb_streams = ic->nb_streams;
2820     int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1;
2821     unsigned *program = NULL;
2822     AVCodec *decoder = NULL, *best_decoder = NULL;
2823
2824     if (related_stream >= 0 && wanted_stream_nb < 0) {
2825         AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
2826         if (p) {
2827             program = p->stream_index;
2828             nb_streams = p->nb_stream_indexes;
2829         }
2830     }
2831     for (i = 0; i < nb_streams; i++) {
2832         int real_stream_index = program ? program[i] : i;
2833         AVStream *st = ic->streams[real_stream_index];
2834         AVCodecContext *avctx = st->codec;
2835         if (avctx->codec_type != type)
2836             continue;
2837         if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
2838             continue;
2839         if (st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED|AV_DISPOSITION_VISUAL_IMPAIRED))
2840             continue;
2841         if (decoder_ret) {
2842             decoder = avcodec_find_decoder(st->codec->codec_id);
2843             if (!decoder) {
2844                 if (ret < 0)
2845                     ret = AVERROR_DECODER_NOT_FOUND;
2846                 continue;
2847             }
2848         }
2849         if (best_count >= st->codec_info_nb_frames)
2850             continue;
2851         best_count = st->codec_info_nb_frames;
2852         ret = real_stream_index;
2853         best_decoder = decoder;
2854         if (program && i == nb_streams - 1 && ret < 0) {
2855             program = NULL;
2856             nb_streams = ic->nb_streams;
2857             i = 0; /* no related stream found, try again with everything */
2858         }
2859     }
2860     if (decoder_ret)
2861         *decoder_ret = best_decoder;
2862     return ret;
2863 }
2864
2865 /*******************************************************/
2866
2867 int av_read_play(AVFormatContext *s)
2868 {
2869     if (s->iformat->read_play)
2870         return s->iformat->read_play(s);
2871     if (s->pb)
2872         return avio_pause(s->pb, 0);
2873     return AVERROR(ENOSYS);
2874 }
2875
2876 int av_read_pause(AVFormatContext *s)
2877 {
2878     if (s->iformat->read_pause)
2879         return s->iformat->read_pause(s);
2880     if (s->pb)
2881         return avio_pause(s->pb, 1);
2882     return AVERROR(ENOSYS);
2883 }
2884
2885 void avformat_free_context(AVFormatContext *s)
2886 {
2887     int i;
2888     AVStream *st;
2889
2890     av_opt_free(s);
2891     if (s->iformat && s->iformat->priv_class && s->priv_data)
2892         av_opt_free(s->priv_data);
2893
2894     for(i=0;i<s->nb_streams;i++) {
2895         /* free all data in a stream component */
2896         st = s->streams[i];
2897         if (st->parser) {
2898             av_parser_close(st->parser);
2899         }
2900         if (st->attached_pic.data)
2901             av_free_packet(&st->attached_pic);
2902         av_dict_free(&st->metadata);
2903         av_freep(&st->index_entries);
2904         av_freep(&st->codec->extradata);
2905         av_freep(&st->codec->subtitle_header);
2906         av_freep(&st->codec);
2907         av_freep(&st->priv_data);
2908         av_freep(&st->info);
2909         av_freep(&st);
2910     }
2911     for(i=s->nb_programs-1; i>=0; i--) {
2912         av_dict_free(&s->programs[i]->metadata);
2913         av_freep(&s->programs[i]->stream_index);
2914         av_freep(&s->programs[i]);
2915     }
2916     av_freep(&s->programs);
2917     av_freep(&s->priv_data);
2918     while(s->nb_chapters--) {
2919         av_dict_free(&s->chapters[s->nb_chapters]->metadata);
2920         av_freep(&s->chapters[s->nb_chapters]);
2921     }
2922     av_freep(&s->chapters);
2923     av_dict_free(&s->metadata);
2924     av_freep(&s->streams);
2925     av_free(s);
2926 }
2927
2928 #if FF_API_CLOSE_INPUT_FILE
2929 void av_close_input_file(AVFormatContext *s)
2930 {
2931     avformat_close_input(&s);
2932 }
2933 #endif
2934
2935 void avformat_close_input(AVFormatContext **ps)
2936 {
2937     AVFormatContext *s = *ps;
2938     AVIOContext *pb = (s->iformat && (s->iformat->flags & AVFMT_NOFILE)) || (s->flags & AVFMT_FLAG_CUSTOM_IO) ?
2939                        NULL : s->pb;
2940     flush_packet_queue(s);
2941     if (s->iformat && (s->iformat->read_close))
2942         s->iformat->read_close(s);
2943     avformat_free_context(s);
2944     *ps = NULL;
2945     if (pb)
2946         avio_close(pb);
2947 }
2948
2949 #if FF_API_NEW_STREAM
2950 AVStream *av_new_stream(AVFormatContext *s, int id)
2951 {
2952     AVStream *st = avformat_new_stream(s, NULL);
2953     if (st)
2954         st->id = id;
2955     return st;
2956 }
2957 #endif
2958
2959 AVStream *avformat_new_stream(AVFormatContext *s, AVCodec *c)
2960 {
2961     AVStream *st;
2962     int i;
2963     AVStream **streams;
2964
2965     if (s->nb_streams >= INT_MAX/sizeof(*streams))
2966         return NULL;
2967     streams = av_realloc(s->streams, (s->nb_streams + 1) * sizeof(*streams));
2968     if (!streams)
2969         return NULL;
2970     s->streams = streams;
2971
2972     st = av_mallocz(sizeof(AVStream));
2973     if (!st)
2974         return NULL;
2975     if (!(st->info = av_mallocz(sizeof(*st->info)))) {
2976         av_free(st);
2977         return NULL;
2978     }
2979     st->info->last_dts = AV_NOPTS_VALUE;
2980
2981     st->codec = avcodec_alloc_context3(c);
2982     if (s->iformat) {
2983         /* no default bitrate if decoding */
2984         st->codec->bit_rate = 0;
2985     }
2986     st->index = s->nb_streams;
2987     st->start_time = AV_NOPTS_VALUE;
2988     st->duration = AV_NOPTS_VALUE;
2989         /* we set the current DTS to 0 so that formats without any timestamps
2990            but durations get some timestamps, formats with some unknown
2991            timestamps have their first few packets buffered and the
2992            timestamps corrected before they are returned to the user */
2993     st->cur_dts = s->iformat ? RELATIVE_TS_BASE : 0;
2994     st->first_dts = AV_NOPTS_VALUE;
2995     st->probe_packets = MAX_PROBE_PACKETS;
2996
2997     /* default pts setting is MPEG-like */
2998     avpriv_set_pts_info(st, 33, 1, 90000);
2999     st->last_IP_pts = AV_NOPTS_VALUE;
3000     for(i=0; i<MAX_REORDER_DELAY+1; i++)
3001         st->pts_buffer[i]= AV_NOPTS_VALUE;
3002     st->reference_dts = AV_NOPTS_VALUE;
3003
3004     st->sample_aspect_ratio = (AVRational){0,1};
3005
3006     s->streams[s->nb_streams++] = st;
3007     return st;
3008 }
3009
3010 AVProgram *av_new_program(AVFormatContext *ac, int id)
3011 {
3012     AVProgram *program=NULL;
3013     int i;
3014
3015     av_dlog(ac, "new_program: id=0x%04x\n", id);
3016
3017     for(i=0; i<ac->nb_programs; i++)
3018         if(ac->programs[i]->id == id)
3019             program = ac->programs[i];
3020
3021     if(!program){
3022         program = av_mallocz(sizeof(AVProgram));
3023         if (!program)
3024             return NULL;
3025         dynarray_add(&ac->programs, &ac->nb_programs, program);
3026         program->discard = AVDISCARD_NONE;
3027     }
3028     program->id = id;
3029
3030     return program;
3031 }
3032
3033 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
3034 {
3035     AVChapter *chapter = NULL;
3036     int i;
3037
3038     for(i=0; i<s->nb_chapters; i++)
3039         if(s->chapters[i]->id == id)
3040             chapter = s->chapters[i];
3041
3042     if(!chapter){
3043         chapter= av_mallocz(sizeof(AVChapter));
3044         if(!chapter)
3045             return NULL;
3046         dynarray_add(&s->chapters, &s->nb_chapters, chapter);
3047     }
3048     av_dict_set(&chapter->metadata, "title", title, 0);
3049     chapter->id    = id;
3050     chapter->time_base= time_base;
3051     chapter->start = start;
3052     chapter->end   = end;
3053
3054     return chapter;
3055 }
3056
3057 /************************************************************/
3058 /* output media file */
3059
3060 int avformat_alloc_output_context2(AVFormatContext **avctx, AVOutputFormat *oformat,
3061                                    const char *format, const char *filename)
3062 {
3063     AVFormatContext *s = avformat_alloc_context();
3064     int ret = 0;
3065
3066     *avctx = NULL;
3067     if (!s)
3068         goto nomem;
3069
3070     if (!oformat) {
3071         if (format) {
3072             oformat = av_guess_format(format, NULL, NULL);
3073             if (!oformat) {
3074                 av_log(s, AV_LOG_ERROR, "Requested output format '%s' is not a suitable output format\n", format);
3075                 ret = AVERROR(EINVAL);
3076                 goto error;
3077             }
3078         } else {
3079             oformat = av_guess_format(NULL, filename, NULL);
3080             if (!oformat) {
3081                 ret = AVERROR(EINVAL);
3082                 av_log(s, AV_LOG_ERROR, "Unable to find a suitable output format for '%s'\n",
3083                        filename);
3084                 goto error;
3085             }
3086         }
3087     }
3088
3089     s->oformat = oformat;
3090     if (s->oformat->priv_data_size > 0) {
3091         s->priv_data = av_mallocz(s->oformat->priv_data_size);
3092         if (!s->priv_data)
3093             goto nomem;
3094         if (s->oformat->priv_class) {
3095             *(const AVClass**)s->priv_data= s->oformat->priv_class;
3096             av_opt_set_defaults(s->priv_data);
3097         }
3098     } else
3099         s->priv_data = NULL;
3100
3101     if (filename)
3102         av_strlcpy(s->filename, filename, sizeof(s->filename));
3103     *avctx = s;
3104     return 0;
3105 nomem:
3106     av_log(s, AV_LOG_ERROR, "Out of memory\n");
3107     ret = AVERROR(ENOMEM);
3108 error:
3109     avformat_free_context(s);
3110     return ret;
3111 }
3112
3113 #if FF_API_ALLOC_OUTPUT_CONTEXT
3114 AVFormatContext *avformat_alloc_output_context(const char *format,
3115                                                AVOutputFormat *oformat, const char *filename)
3116 {
3117     AVFormatContext *avctx;
3118     int ret = avformat_alloc_output_context2(&avctx, oformat, format, filename);
3119     return ret < 0 ? NULL : avctx;
3120 }
3121 #endif
3122
3123 static int validate_codec_tag(AVFormatContext *s, AVStream *st)
3124 {
3125     const AVCodecTag *avctag;
3126     int n;
3127     enum CodecID id = CODEC_ID_NONE;
3128     unsigned int tag = 0;
3129
3130     /**
3131      * Check that tag + id is in the table
3132      * If neither is in the table -> OK
3133      * If tag is in the table with another id -> FAIL
3134      * If id is in the table with another tag -> FAIL unless strict < normal
3135      */
3136     for (n = 0; s->oformat->codec_tag[n]; n++) {
3137         avctag = s->oformat->codec_tag[n];
3138         while (avctag->id != CODEC_ID_NONE) {
3139             if (avpriv_toupper4(avctag->tag) == avpriv_toupper4(st->codec->codec_tag)) {
3140                 id = avctag->id;
3141                 if (id == st->codec->codec_id)
3142                     return 1;
3143             }
3144             if (avctag->id == st->codec->codec_id)
3145                 tag = avctag->tag;
3146             avctag++;
3147         }
3148     }
3149     if (id != CODEC_ID_NONE)
3150         return 0;
3151     if (tag && (st->codec->strict_std_compliance >= FF_COMPLIANCE_NORMAL))
3152         return 0;
3153     return 1;
3154 }
3155
3156 int avformat_write_header(AVFormatContext *s, AVDictionary **options)
3157 {
3158     int ret = 0, i;
3159     AVStream *st;
3160     AVDictionary *tmp = NULL;
3161
3162     if (options)
3163         av_dict_copy(&tmp, *options, 0);
3164     if ((ret = av_opt_set_dict(s, &tmp)) < 0)
3165         goto fail;
3166     if (s->priv_data && s->oformat->priv_class && *(const AVClass**)s->priv_data==s->oformat->priv_class &&
3167         (ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
3168         goto fail;
3169
3170     // some sanity checks
3171     if (s->nb_streams == 0 && !(s->oformat->flags & AVFMT_NOSTREAMS)) {
3172         av_log(s, AV_LOG_ERROR, "no streams\n");
3173         ret = AVERROR(EINVAL);
3174         goto fail;
3175     }
3176
3177     for(i=0;i<s->nb_streams;i++) {
3178         st = s->streams[i];
3179
3180         switch (st->codec->codec_type) {
3181         case AVMEDIA_TYPE_AUDIO:
3182             if(st->codec->sample_rate<=0){
3183                 av_log(s, AV_LOG_ERROR, "sample rate not set\n");
3184                 ret = AVERROR(EINVAL);
3185                 goto fail;
3186             }
3187             if(!st->codec->block_align)
3188                 st->codec->block_align = st->codec->channels *
3189                     av_get_bits_per_sample(st->codec->codec_id) >> 3;
3190             break;
3191         case AVMEDIA_TYPE_VIDEO:
3192             if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
3193                 av_log(s, AV_LOG_ERROR, "time base not set\n");
3194                 ret = AVERROR(EINVAL);
3195                 goto fail;
3196             }
3197             if((st->codec->width<=0 || st->codec->height<=0) && !(s->oformat->flags & AVFMT_NODIMENSIONS)){
3198                 av_log(s, AV_LOG_ERROR, "dimensions not set\n");
3199                 ret = AVERROR(EINVAL);
3200                 goto fail;
3201             }
3202             if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)
3203                && FFABS(av_q2d(st->sample_aspect_ratio) - av_q2d(st->codec->sample_aspect_ratio)) > 0.004*av_q2d(st->sample_aspect_ratio)
3204             ){
3205                 av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between muxer "
3206                        "(%d/%d) and encoder layer (%d/%d)\n",
3207                        st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3208                        st->codec->sample_aspect_ratio.num,
3209                        st->codec->sample_aspect_ratio.den);
3210                 ret = AVERROR(EINVAL);
3211                 goto fail;
3212             }
3213             break;
3214         }
3215
3216         if(s->oformat->codec_tag){
3217             if(   st->codec->codec_tag
3218                && st->codec->codec_id == CODEC_ID_RAWVIDEO
3219                && (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', ' '))
3220                && !validate_codec_tag(s, st)){
3221                 //the current rawvideo encoding system ends up setting the wrong codec_tag for avi/mov, we override it here
3222                 st->codec->codec_tag= 0;
3223             }
3224             if(st->codec->codec_tag){
3225                 if (!validate_codec_tag(s, st)) {
3226                     char tagbuf[32], cortag[32];
3227                     av_get_codec_tag_string(tagbuf, sizeof(tagbuf), st->codec->codec_tag);
3228                     av_get_codec_tag_string(cortag, sizeof(cortag), av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id));
3229                     av_log(s, AV_LOG_ERROR,
3230                            "Tag %s/0x%08x incompatible with output codec id '%d' (%s)\n",
3231                            tagbuf, st->codec->codec_tag, st->codec->codec_id, cortag);
3232                     ret = AVERROR_INVALIDDATA;
3233                     goto fail;
3234                 }
3235             }else
3236                 st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
3237         }
3238
3239         if(s->oformat->flags & AVFMT_GLOBALHEADER &&
3240             !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
3241           av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
3242     }
3243
3244     if (!s->priv_data && s->oformat->priv_data_size > 0) {
3245         s->priv_data = av_mallocz(s->oformat->priv_data_size);
3246         if (!s->priv_data) {
3247             ret = AVERROR(ENOMEM);
3248             goto fail;
3249         }
3250         if (s->oformat->priv_class) {
3251             *(const AVClass**)s->priv_data= s->oformat->priv_class;
3252             av_opt_set_defaults(s->priv_data);
3253             if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
3254                 goto fail;
3255         }
3256     }
3257
3258     /* set muxer identification string */
3259     if (s->nb_streams && !(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
3260         av_dict_set(&s->metadata, "encoder", LIBAVFORMAT_IDENT, 0);
3261     }
3262
3263     if(s->oformat->write_header){
3264         ret = s->oformat->write_header(s);
3265         if (ret < 0)
3266             goto fail;
3267     }
3268
3269     /* init PTS generation */
3270     for(i=0;i<s->nb_streams;i++) {
3271         int64_t den = AV_NOPTS_VALUE;
3272         st = s->streams[i];
3273
3274         switch (st->codec->codec_type) {
3275         case AVMEDIA_TYPE_AUDIO:
3276             den = (int64_t)st->time_base.num * st->codec->sample_rate;
3277             break;
3278         case AVMEDIA_TYPE_VIDEO:
3279             den = (int64_t)st->time_base.num * st->codec->time_base.den;
3280             break;
3281         default:
3282             break;
3283         }
3284         if (den != AV_NOPTS_VALUE) {
3285             if (den <= 0) {
3286                 ret = AVERROR_INVALIDDATA;
3287                 goto fail;
3288             }
3289             frac_init(&st->pts, 0, 0, den);
3290         }
3291     }
3292
3293     if (options) {
3294         av_dict_free(options);
3295         *options = tmp;
3296     }
3297     return 0;
3298 fail:
3299     av_dict_free(&tmp);
3300     return ret;
3301 }
3302
3303 //FIXME merge with compute_pkt_fields
3304 static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt){
3305     int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
3306     int num, den, frame_size, i;
3307
3308     av_dlog(s, "compute_pkt_fields2: pts:%s dts:%s cur_dts:%s b:%d size:%d st:%d\n",
3309             av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts), delay, pkt->size, pkt->stream_index);
3310
3311     /* duration field */
3312     if (pkt->duration == 0) {
3313         compute_frame_duration(&num, &den, st, NULL, pkt);
3314         if (den && num) {
3315             pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
3316         }
3317     }
3318
3319     if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
3320         pkt->pts= pkt->dts;
3321
3322     //XXX/FIXME this is a temporary hack until all encoders output pts
3323     if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
3324         static int warned;
3325         if (!warned) {
3326             av_log(s, AV_LOG_WARNING, "Encoder did not produce proper pts, making some up.\n");
3327             warned = 1;
3328         }
3329         pkt->dts=
3330 //        pkt->pts= st->cur_dts;
3331         pkt->pts= st->pts.val;
3332     }
3333
3334     //calculate dts from pts
3335     if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
3336         st->pts_buffer[0]= pkt->pts;
3337         for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
3338             st->pts_buffer[i]= pkt->pts + (i-delay-1) * pkt->duration;
3339         for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
3340             FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
3341
3342         pkt->dts= st->pts_buffer[0];
3343     }
3344
3345     if (st->cur_dts && st->cur_dts != AV_NOPTS_VALUE &&
3346         ((!(s->oformat->flags & AVFMT_TS_NONSTRICT) &&
3347           st->cur_dts >= pkt->dts) || st->cur_dts > pkt->dts)) {
3348         av_log(s, AV_LOG_ERROR,
3349                "Application provided invalid, non monotonically increasing dts to muxer in stream %d: %s >= %s\n",
3350                st->index, av_ts2str(st->cur_dts), av_ts2str(pkt->dts));
3351         return AVERROR(EINVAL);
3352     }
3353     if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
3354         av_log(s, AV_LOG_ERROR, "pts (%s) < dts (%s) in stream %d\n",
3355                av_ts2str(pkt->pts), av_ts2str(pkt->dts), st->index);
3356         return AVERROR(EINVAL);
3357     }
3358
3359 //    av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%s dts2:%s\n", av_ts2str(pkt->pts), av_ts2str(pkt->dts));
3360     st->cur_dts= pkt->dts;
3361     st->pts.val= pkt->dts;
3362
3363     /* update pts */
3364     switch (st->codec->codec_type) {
3365     case AVMEDIA_TYPE_AUDIO:
3366         frame_size = get_audio_frame_size(st->codec, pkt->size, 1);
3367
3368         /* HACK/FIXME, we skip the initial 0 size packets as they are most
3369            likely equal to the encoder delay, but it would be better if we
3370            had the real timestamps from the encoder */
3371         if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
3372             frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
3373         }
3374         break;
3375     case AVMEDIA_TYPE_VIDEO:
3376         frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
3377         break;
3378     default:
3379         break;
3380     }
3381     return 0;
3382 }
3383
3384 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
3385 {
3386     int ret;
3387
3388     if (!pkt) {
3389         if (s->oformat->flags & AVFMT_ALLOW_FLUSH)
3390             return s->oformat->write_packet(s, pkt);
3391         return 1;
3392     }
3393
3394     ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt);
3395
3396     if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3397         return ret;
3398
3399     ret= s->oformat->write_packet(s, pkt);
3400
3401     if (ret >= 0)
3402         s->streams[pkt->stream_index]->nb_frames++;
3403     return ret;
3404 }
3405
3406 #define CHUNK_START 0x1000
3407
3408 int ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
3409                               int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
3410 {
3411     AVPacketList **next_point, *this_pktl;
3412     AVStream *st= s->streams[pkt->stream_index];
3413     int chunked= s->max_chunk_size || s->max_chunk_duration;
3414
3415     this_pktl = av_mallocz(sizeof(AVPacketList));
3416     if (!this_pktl)
3417         return AVERROR(ENOMEM);
3418     this_pktl->pkt= *pkt;
3419     pkt->destruct= NULL;             // do not free original but only the copy
3420     av_dup_packet(&this_pktl->pkt);  // duplicate the packet if it uses non-alloced memory
3421
3422     if(s->streams[pkt->stream_index]->last_in_packet_buffer){
3423         next_point = &(st->last_in_packet_buffer->next);
3424     }else{
3425         next_point = &s->packet_buffer;
3426     }
3427
3428     if(*next_point){
3429         if(chunked){
3430             uint64_t max= av_rescale_q(s->max_chunk_duration, AV_TIME_BASE_Q, st->time_base);
3431             if(   st->interleaver_chunk_size     + pkt->size     <= s->max_chunk_size-1U
3432                && st->interleaver_chunk_duration + pkt->duration <= max-1U){
3433                 st->interleaver_chunk_size     += pkt->size;
3434                 st->interleaver_chunk_duration += pkt->duration;
3435                 goto next_non_null;
3436             }else{
3437                 st->interleaver_chunk_size     =
3438                 st->interleaver_chunk_duration = 0;
3439                 this_pktl->pkt.flags |= CHUNK_START;
3440             }
3441         }
3442
3443         if(compare(s, &s->packet_buffer_end->pkt, pkt)){
3444             while(   *next_point
3445                   && ((chunked && !((*next_point)->pkt.flags&CHUNK_START))
3446                       || !compare(s, &(*next_point)->pkt, pkt))){
3447                 next_point= &(*next_point)->next;
3448             }
3449             if(*next_point)
3450                 goto next_non_null;
3451         }else{
3452             next_point = &(s->packet_buffer_end->next);
3453         }
3454     }
3455     assert(!*next_point);
3456
3457     s->packet_buffer_end= this_pktl;
3458 next_non_null:
3459
3460     this_pktl->next= *next_point;
3461
3462     s->streams[pkt->stream_index]->last_in_packet_buffer=
3463     *next_point= this_pktl;
3464     return 0;
3465 }
3466
3467 static int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
3468 {
3469     AVStream *st = s->streams[ pkt ->stream_index];
3470     AVStream *st2= s->streams[ next->stream_index];
3471     int comp = av_compare_ts(next->dts, st2->time_base, pkt->dts,
3472                              st->time_base);
3473     if(s->audio_preload && ((st->codec->codec_type == AVMEDIA_TYPE_AUDIO) != (st2->codec->codec_type == AVMEDIA_TYPE_AUDIO))){
3474         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);
3475         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);
3476         if(ts == ts2){
3477             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
3478                -( 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;
3479             ts2=0;
3480         }
3481         comp= (ts>ts2) - (ts<ts2);
3482     }
3483
3484     if (comp == 0)
3485         return pkt->stream_index < next->stream_index;
3486     return comp > 0;
3487 }
3488
3489 int ff_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out,
3490                                  AVPacket *pkt, int flush)
3491 {
3492     AVPacketList *pktl;
3493     int stream_count=0, noninterleaved_count=0;
3494     int64_t delta_dts_max = 0;
3495     int i, ret;
3496
3497     if(pkt){
3498         ret = ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
3499         if (ret < 0)
3500             return ret;
3501     }
3502
3503     for(i=0; i < s->nb_streams; i++) {
3504         if (s->streams[i]->last_in_packet_buffer) {
3505             ++stream_count;
3506         } else if(s->streams[i]->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3507             ++noninterleaved_count;
3508         }
3509     }
3510
3511     if (s->nb_streams == stream_count) {
3512         flush = 1;
3513     } else if (!flush){
3514         for(i=0; i < s->nb_streams; i++) {
3515             if (s->streams[i]->last_in_packet_buffer) {
3516                 int64_t delta_dts =
3517                     av_rescale_q(s->streams[i]->last_in_packet_buffer->pkt.dts,
3518                                 s->streams[i]->time_base,
3519                                 AV_TIME_BASE_Q) -
3520                     av_rescale_q(s->packet_buffer->pkt.dts,
3521                                 s->streams[s->packet_buffer->pkt.stream_index]->time_base,
3522                                 AV_TIME_BASE_Q);
3523                 delta_dts_max= FFMAX(delta_dts_max, delta_dts);
3524             }
3525         }
3526         if(s->nb_streams == stream_count+noninterleaved_count &&
3527            delta_dts_max > 20*AV_TIME_BASE) {
3528             av_log(s, AV_LOG_DEBUG, "flushing with %d noninterleaved\n", noninterleaved_count);
3529             flush = 1;
3530         }
3531     }
3532     if(stream_count && flush){
3533         pktl= s->packet_buffer;
3534         *out= pktl->pkt;
3535
3536         s->packet_buffer= pktl->next;
3537         if(!s->packet_buffer)
3538             s->packet_buffer_end= NULL;
3539
3540         if(s->streams[out->stream_index]->last_in_packet_buffer == pktl)
3541             s->streams[out->stream_index]->last_in_packet_buffer= NULL;
3542         av_freep(&pktl);
3543         return 1;
3544     }else{
3545         av_init_packet(out);
3546         return 0;
3547     }
3548 }
3549
3550 #if FF_API_INTERLEAVE_PACKET
3551 int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out,
3552                                  AVPacket *pkt, int flush)
3553 {
3554     return ff_interleave_packet_per_dts(s, out, pkt, flush);
3555 }
3556 #endif
3557
3558 /**
3559  * Interleave an AVPacket correctly so it can be muxed.
3560  * @param out the interleaved packet will be output here
3561  * @param in the input packet
3562  * @param flush 1 if no further packets are available as input and all
3563  *              remaining packets should be output
3564  * @return 1 if a packet was output, 0 if no packet could be output,
3565  *         < 0 if an error occurred
3566  */
3567 static int interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
3568     if (s->oformat->interleave_packet) {
3569         int ret = s->oformat->interleave_packet(s, out, in, flush);
3570         if (in)
3571             av_free_packet(in);
3572         return ret;
3573     } else
3574         return ff_interleave_packet_per_dts(s, out, in, flush);
3575 }
3576
3577 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
3578     int ret, flush = 0;
3579
3580     if (pkt) {
3581         AVStream *st= s->streams[ pkt->stream_index];
3582
3583         //FIXME/XXX/HACK drop zero sized packets
3584         if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO && pkt->size==0)
3585             return 0;
3586
3587         av_dlog(s, "av_interleaved_write_frame size:%d dts:%s pts:%s\n",
3588                 pkt->size, av_ts2str(pkt->dts), av_ts2str(pkt->pts));
3589         if((ret = compute_pkt_fields2(s, st, pkt)) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3590             return ret;
3591
3592         if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3593             return AVERROR(EINVAL);
3594     } else {
3595         av_dlog(s, "av_interleaved_write_frame FLUSH\n");
3596         flush = 1;
3597     }
3598
3599     for(;;){
3600         AVPacket opkt;
3601         int ret= interleave_packet(s, &opkt, pkt, flush);
3602         if(ret<=0) //FIXME cleanup needed for ret<0 ?
3603             return ret;
3604
3605         ret= s->oformat->write_packet(s, &opkt);
3606         if (ret >= 0)
3607             s->streams[opkt.stream_index]->nb_frames++;
3608
3609         av_free_packet(&opkt);
3610         pkt= NULL;
3611
3612         if(ret<0)
3613             return ret;
3614         if(s->pb && s->pb->error)
3615             return s->pb->error;
3616     }
3617 }
3618
3619 int av_write_trailer(AVFormatContext *s)
3620 {
3621     int ret, i;
3622
3623     for(;;){
3624         AVPacket pkt;
3625         ret= interleave_packet(s, &pkt, NULL, 1);
3626         if(ret<0) //FIXME cleanup needed for ret<0 ?
3627             goto fail;
3628         if(!ret)
3629             break;
3630
3631         ret= s->oformat->write_packet(s, &pkt);
3632         if (ret >= 0)
3633             s->streams[pkt.stream_index]->nb_frames++;
3634
3635         av_free_packet(&pkt);
3636
3637         if(ret<0)
3638             goto fail;
3639         if(s->pb && s->pb->error)
3640             goto fail;
3641     }
3642
3643     if(s->oformat->write_trailer)
3644         ret = s->oformat->write_trailer(s);
3645 fail:
3646     if (s->pb)
3647        avio_flush(s->pb);
3648     if(ret == 0)
3649        ret = s->pb ? s->pb->error : 0;
3650     for(i=0;i<s->nb_streams;i++) {
3651         av_freep(&s->streams[i]->priv_data);
3652         av_freep(&s->streams[i]->index_entries);
3653     }
3654     if (s->oformat->priv_class)
3655         av_opt_free(s->priv_data);
3656     av_freep(&s->priv_data);
3657     return ret;
3658 }
3659
3660 int av_get_output_timestamp(struct AVFormatContext *s, int stream,
3661                             int64_t *dts, int64_t *wall)
3662 {
3663     if (!s->oformat || !s->oformat->get_output_timestamp)
3664         return AVERROR(ENOSYS);
3665     s->oformat->get_output_timestamp(s, stream, dts, wall);
3666     return 0;
3667 }
3668
3669 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
3670 {
3671     int i, j;
3672     AVProgram *program=NULL;
3673     void *tmp;
3674
3675     if (idx >= ac->nb_streams) {
3676         av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3677         return;
3678     }
3679
3680     for(i=0; i<ac->nb_programs; i++){
3681         if(ac->programs[i]->id != progid)
3682             continue;
3683         program = ac->programs[i];
3684         for(j=0; j<program->nb_stream_indexes; j++)
3685             if(program->stream_index[j] == idx)
3686                 return;
3687
3688         tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
3689         if(!tmp)
3690             return;
3691         program->stream_index = tmp;
3692         program->stream_index[program->nb_stream_indexes++] = idx;
3693         return;
3694     }
3695 }
3696
3697 static void print_fps(double d, const char *postfix){
3698     uint64_t v= lrintf(d*100);
3699     if     (v% 100      ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3700     else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3701     else                  av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
3702 }
3703
3704 static void dump_metadata(void *ctx, AVDictionary *m, const char *indent)
3705 {
3706     if(m && !(m->count == 1 && av_dict_get(m, "language", NULL, 0))){
3707         AVDictionaryEntry *tag=NULL;
3708
3709         av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3710         while((tag=av_dict_get(m, "", tag, AV_DICT_IGNORE_SUFFIX))) {
3711             if(strcmp("language", tag->key)){
3712                 const char *p = tag->value;
3713                 av_log(ctx, AV_LOG_INFO, "%s  %-16s: ", indent, tag->key);
3714                 while(*p) {
3715                     char tmp[256];
3716                     size_t len = strcspn(p, "\xd\xa");
3717                     av_strlcpy(tmp, p, FFMIN(sizeof(tmp), len+1));
3718                     av_log(ctx, AV_LOG_INFO, "%s", tmp);
3719                     p += len;
3720                     if (*p == 0xd) av_log(ctx, AV_LOG_INFO, " ");
3721                     if (*p == 0xa) av_log(ctx, AV_LOG_INFO, "\n%s  %-16s: ", indent, "");
3722                     if (*p) p++;
3723                 }
3724                 av_log(ctx, AV_LOG_INFO, "\n");
3725             }
3726         }
3727     }
3728 }
3729
3730 /* "user interface" functions */
3731 static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
3732 {
3733     char buf[256];
3734     int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
3735     AVStream *st = ic->streams[i];
3736     int g = av_gcd(st->time_base.num, st->time_base.den);
3737     AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL, 0);
3738     avcodec_string(buf, sizeof(buf), st->codec, is_output);
3739     av_log(NULL, AV_LOG_INFO, "    Stream #%d:%d", index, i);
3740     /* the pid is an important information, so we display it */
3741     /* XXX: add a generic system */
3742     if (flags & AVFMT_SHOW_IDS)
3743         av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
3744     if (lang)
3745         av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
3746     av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames, st->time_base.num/g, st->time_base.den/g);
3747     av_log(NULL, AV_LOG_INFO, ": %s", buf);
3748     if (st->sample_aspect_ratio.num && // default
3749         av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
3750         AVRational display_aspect_ratio;
3751         av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
3752                   st->codec->width*st->sample_aspect_ratio.num,
3753                   st->codec->height*st->sample_aspect_ratio.den,
3754                   1024*1024);
3755         av_log(NULL, AV_LOG_INFO, ", SAR %d:%d DAR %d:%d",
3756                  st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3757                  display_aspect_ratio.num, display_aspect_ratio.den);
3758     }
3759     if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
3760         if(st->avg_frame_rate.den && st->avg_frame_rate.num)
3761             print_fps(av_q2d(st->avg_frame_rate), "fps");
3762         if(st->r_frame_rate.den && st->r_frame_rate.num)
3763             print_fps(av_q2d(st->r_frame_rate), "tbr");
3764         if(st->time_base.den && st->time_base.num)
3765             print_fps(1/av_q2d(st->time_base), "tbn");
3766         if(st->codec->time_base.den && st->codec->time_base.num)
3767             print_fps(1/av_q2d(st->codec->time_base), "tbc");
3768     }
3769     if (st->disposition & AV_DISPOSITION_DEFAULT)
3770         av_log(NULL, AV_LOG_INFO, " (default)");
3771     if (st->disposition & AV_DISPOSITION_DUB)
3772         av_log(NULL, AV_LOG_INFO, " (dub)");
3773     if (st->disposition & AV_DISPOSITION_ORIGINAL)
3774         av_log(NULL, AV_LOG_INFO, " (original)");
3775     if (st->disposition & AV_DISPOSITION_COMMENT)
3776         av_log(NULL, AV_LOG_INFO, " (comment)");
3777     if (st->disposition & AV_DISPOSITION_LYRICS)
3778         av_log(NULL, AV_LOG_INFO, " (lyrics)");
3779     if (st->disposition & AV_DISPOSITION_KARAOKE)
3780         av_log(NULL, AV_LOG_INFO, " (karaoke)");
3781     if (st->disposition & AV_DISPOSITION_FORCED)
3782         av_log(NULL, AV_LOG_INFO, " (forced)");
3783     if (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED)
3784         av_log(NULL, AV_LOG_INFO, " (hearing impaired)");
3785     if (st->disposition & AV_DISPOSITION_VISUAL_IMPAIRED)
3786         av_log(NULL, AV_LOG_INFO, " (visual impaired)");
3787     if (st->disposition & AV_DISPOSITION_CLEAN_EFFECTS)
3788         av_log(NULL, AV_LOG_INFO, " (clean effects)");
3789     av_log(NULL, AV_LOG_INFO, "\n");
3790     dump_metadata(NULL, st->metadata, "    ");
3791 }
3792
3793 void av_dump_format(AVFormatContext *ic,
3794                     int index,
3795                     const char *url,
3796                     int is_output)
3797 {
3798     int i;
3799     uint8_t *printed = ic->nb_streams ? av_mallocz(ic->nb_streams) : NULL;
3800     if (ic->nb_streams && !printed)
3801         return;
3802
3803     av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3804             is_output ? "Output" : "Input",
3805             index,
3806             is_output ? ic->oformat->name : ic->iformat->name,
3807             is_output ? "to" : "from", url);
3808     dump_metadata(NULL, ic->metadata, "  ");
3809     if (!is_output) {
3810         av_log(NULL, AV_LOG_INFO, "  Duration: ");
3811         if (ic->duration != AV_NOPTS_VALUE) {
3812             int hours, mins, secs, us;
3813             secs = ic->duration / AV_TIME_BASE;
3814             us = ic->duration % AV_TIME_BASE;
3815             mins = secs / 60;
3816             secs %= 60;
3817             hours = mins / 60;
3818             mins %= 60;
3819             av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3820                    (100 * us) / AV_TIME_BASE);
3821         } else {
3822             av_log(NULL, AV_LOG_INFO, "N/A");
3823         }
3824         if (ic->start_time != AV_NOPTS_VALUE) {
3825             int secs, us;
3826             av_log(NULL, AV_LOG_INFO, ", start: ");
3827             secs = ic->start_time / AV_TIME_BASE;
3828             us = abs(ic->start_time % AV_TIME_BASE);
3829             av_log(NULL, AV_LOG_INFO, "%d.%06d",
3830                    secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
3831         }
3832         av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3833         if (ic->bit_rate) {
3834             av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
3835         } else {
3836             av_log(NULL, AV_LOG_INFO, "N/A");
3837         }
3838         av_log(NULL, AV_LOG_INFO, "\n");
3839     }
3840     for (i = 0; i < ic->nb_chapters; i++) {
3841         AVChapter *ch = ic->chapters[i];
3842         av_log(NULL, AV_LOG_INFO, "    Chapter #%d.%d: ", index, i);
3843         av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
3844         av_log(NULL, AV_LOG_INFO, "end %f\n",   ch->end   * av_q2d(ch->time_base));
3845
3846         dump_metadata(NULL, ch->metadata, "    ");
3847     }
3848     if(ic->nb_programs) {
3849         int j, k, total = 0;
3850         for(j=0; j<ic->nb_programs; j++) {
3851             AVDictionaryEntry *name = av_dict_get(ic->programs[j]->metadata,
3852                                                   "name", NULL, 0);
3853             av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
3854                    name ? name->value : "");
3855             dump_metadata(NULL, ic->programs[j]->metadata, "    ");
3856             for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3857                 dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3858                 printed[ic->programs[j]->stream_index[k]] = 1;
3859             }
3860             total += ic->programs[j]->nb_stream_indexes;
3861         }
3862         if (total < ic->nb_streams)
3863             av_log(NULL, AV_LOG_INFO, "  No Program\n");
3864     }
3865     for(i=0;i<ic->nb_streams;i++)
3866         if (!printed[i])
3867             dump_stream_format(ic, i, index, is_output);
3868
3869     av_free(printed);
3870 }
3871
3872 int64_t av_gettime(void)
3873 {
3874     struct timeval tv;
3875     gettimeofday(&tv,NULL);
3876     return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
3877 }
3878
3879 uint64_t ff_ntp_time(void)
3880 {
3881   return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3882 }
3883
3884 int av_get_frame_filename(char *buf, int buf_size,
3885                           const char *path, int number)
3886 {
3887     const char *p;
3888     char *q, buf1[20], c;
3889     int nd, len, percentd_found;
3890
3891     q = buf;
3892     p = path;
3893     percentd_found = 0;
3894     for(;;) {
3895         c = *p++;
3896         if (c == '\0')
3897             break;
3898         if (c == '%') {
3899             do {
3900                 nd = 0;
3901                 while (isdigit(*p)) {
3902                     nd = nd * 10 + *p++ - '0';
3903                 }
3904                 c = *p++;
3905             } while (isdigit(c));
3906
3907             switch(c) {
3908             case '%':
3909                 goto addchar;
3910             case 'd':
3911                 if (percentd_found)
3912                     goto fail;
3913                 percentd_found = 1;
3914                 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3915                 len = strlen(buf1);
3916                 if ((q - buf + len) > buf_size - 1)
3917                     goto fail;
3918                 memcpy(q, buf1, len);
3919                 q += len;
3920                 break;
3921             default:
3922                 goto fail;
3923             }
3924         } else {
3925         addchar:
3926             if ((q - buf) < buf_size - 1)
3927                 *q++ = c;
3928         }
3929     }
3930     if (!percentd_found)
3931         goto fail;
3932     *q = '\0';
3933     return 0;
3934  fail:
3935     *q = '\0';
3936     return -1;
3937 }
3938
3939 static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3940 {
3941     int len, i, j, c;
3942 #undef fprintf
3943 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3944
3945     for(i=0;i<size;i+=16) {
3946         len = size - i;
3947         if (len > 16)
3948             len = 16;
3949         PRINT("%08x ", i);
3950         for(j=0;j<16;j++) {
3951             if (j < len)
3952                 PRINT(" %02x", buf[i+j]);
3953             else
3954                 PRINT("   ");
3955         }
3956         PRINT(" ");
3957         for(j=0;j<len;j++) {
3958             c = buf[i+j];
3959             if (c < ' ' || c > '~')
3960                 c = '.';
3961             PRINT("%c", c);
3962         }
3963         PRINT("\n");
3964     }
3965 #undef PRINT
3966 }
3967
3968 void av_hex_dump(FILE *f, uint8_t *buf, int size)
3969 {
3970     hex_dump_internal(NULL, f, 0, buf, size);
3971 }
3972
3973 void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3974 {
3975     hex_dump_internal(avcl, NULL, level, buf, size);
3976 }
3977
3978 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload, AVRational time_base)
3979 {
3980 #undef fprintf
3981 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3982     PRINT("stream #%d:\n", pkt->stream_index);
3983     PRINT("  keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
3984     PRINT("  duration=%0.3f\n", pkt->duration * av_q2d(time_base));
3985     /* DTS is _always_ valid after av_read_frame() */
3986     PRINT("  dts=");
3987     if (pkt->dts == AV_NOPTS_VALUE)
3988         PRINT("N/A");
3989     else
3990         PRINT("%0.3f", pkt->dts * av_q2d(time_base));
3991     /* PTS may not be known if B-frames are present. */
3992     PRINT("  pts=");
3993     if (pkt->pts == AV_NOPTS_VALUE)
3994         PRINT("N/A");
3995     else
3996         PRINT("%0.3f", pkt->pts * av_q2d(time_base));
3997     PRINT("\n");
3998     PRINT("  size=%d\n", pkt->size);
3999 #undef PRINT
4000     if (dump_payload)
4001         av_hex_dump(f, pkt->data, pkt->size);
4002 }
4003
4004 #if FF_API_PKT_DUMP
4005 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
4006 {
4007     AVRational tb = { 1, AV_TIME_BASE };
4008     pkt_dump_internal(NULL, f, 0, pkt, dump_payload, tb);
4009 }
4010 #endif
4011
4012 void av_pkt_dump2(FILE *f, AVPacket *pkt, int dump_payload, AVStream *st)
4013 {
4014     pkt_dump_internal(NULL, f, 0, pkt, dump_payload, st->time_base);
4015 }
4016
4017 #if FF_API_PKT_DUMP
4018 void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
4019 {
4020     AVRational tb = { 1, AV_TIME_BASE };
4021     pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, tb);
4022 }
4023 #endif
4024
4025 void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload,
4026                       AVStream *st)
4027 {
4028     pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, st->time_base);
4029 }
4030
4031 void av_url_split(char *proto, int proto_size,
4032                   char *authorization, int authorization_size,
4033                   char *hostname, int hostname_size,
4034                   int *port_ptr,
4035                   char *path, int path_size,
4036                   const char *url)
4037 {
4038     const char *p, *ls, *at, *col, *brk;
4039
4040     if (port_ptr)               *port_ptr = -1;
4041     if (proto_size > 0)         proto[0] = 0;
4042     if (authorization_size > 0) authorization[0] = 0;
4043     if (hostname_size > 0)      hostname[0] = 0;
4044     if (path_size > 0)          path[0] = 0;
4045
4046     /* parse protocol */
4047     if ((p = strchr(url, ':'))) {
4048         av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
4049         p++; /* skip ':' */
4050         if (*p == '/') p++;
4051         if (*p == '/') p++;
4052     } else {
4053         /* no protocol means plain filename */
4054         av_strlcpy(path, url, path_size);
4055         return;
4056     }
4057
4058     /* separate path from hostname */
4059     ls = strchr(p, '/');
4060     if(!ls)
4061         ls = strchr(p, '?');
4062     if(ls)
4063         av_strlcpy(path, ls, path_size);
4064     else
4065         ls = &p[strlen(p)]; // XXX
4066
4067     /* the rest is hostname, use that to parse auth/port */
4068     if (ls != p) {
4069         /* authorization (user[:pass]@hostname) */
4070         if ((at = strchr(p, '@')) && at < ls) {
4071             av_strlcpy(authorization, p,
4072                        FFMIN(authorization_size, at + 1 - p));
4073             p = at + 1; /* skip '@' */
4074         }
4075
4076         if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
4077             /* [host]:port */
4078             av_strlcpy(hostname, p + 1,
4079                        FFMIN(hostname_size, brk - p));
4080             if (brk[1] == ':' && port_ptr)
4081                 *port_ptr = atoi(brk + 2);
4082         } else if ((col = strchr(p, ':')) && col < ls) {
4083             av_strlcpy(hostname, p,
4084                        FFMIN(col + 1 - p, hostname_size));
4085             if (port_ptr) *port_ptr = atoi(col + 1);
4086         } else
4087             av_strlcpy(hostname, p,
4088                        FFMIN(ls + 1 - p, hostname_size));
4089     }
4090 }
4091
4092 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
4093 {
4094     int i;
4095     static const char hex_table_uc[16] = { '0', '1', '2', '3',
4096                                            '4', '5', '6', '7',
4097                                            '8', '9', 'A', 'B',
4098                                            'C', 'D', 'E', 'F' };
4099     static const char hex_table_lc[16] = { '0', '1', '2', '3',
4100                                            '4', '5', '6', '7',
4101                                            '8', '9', 'a', 'b',
4102                                            'c', 'd', 'e', 'f' };
4103     const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
4104
4105     for(i = 0; i < s; i++) {
4106         buff[i * 2]     = hex_table[src[i] >> 4];
4107         buff[i * 2 + 1] = hex_table[src[i] & 0xF];
4108     }
4109
4110     return buff;
4111 }
4112
4113 int ff_hex_to_data(uint8_t *data, const char *p)
4114 {
4115     int c, len, v;
4116
4117     len = 0;
4118     v = 1;
4119     for (;;) {
4120         p += strspn(p, SPACE_CHARS);
4121         if (*p == '\0')
4122             break;
4123         c = toupper((unsigned char) *p++);
4124         if (c >= '0' && c <= '9')
4125             c = c - '0';
4126         else if (c >= 'A' && c <= 'F')
4127             c = c - 'A' + 10;
4128         else
4129             break;
4130         v = (v << 4) | c;
4131         if (v & 0x100) {
4132             if (data)
4133                 data[len] = v;
4134             len++;
4135             v = 1;
4136         }
4137     }
4138     return len;
4139 }
4140
4141 #if FF_API_SET_PTS_INFO
4142 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
4143                      unsigned int pts_num, unsigned int pts_den)
4144 {
4145     avpriv_set_pts_info(s, pts_wrap_bits, pts_num, pts_den);
4146 }
4147 #endif
4148
4149 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
4150                          unsigned int pts_num, unsigned int pts_den)
4151 {
4152     AVRational new_tb;
4153     if(av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)){
4154         if(new_tb.num != pts_num)
4155             av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/new_tb.num);
4156     }else
4157         av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
4158
4159     if(new_tb.num <= 0 || new_tb.den <= 0) {
4160         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);
4161         return;
4162     }
4163     s->time_base = new_tb;
4164     s->pts_wrap_bits = pts_wrap_bits;
4165 }
4166
4167 int ff_url_join(char *str, int size, const char *proto,
4168                 const char *authorization, const char *hostname,
4169                 int port, const char *fmt, ...)
4170 {
4171 #if CONFIG_NETWORK
4172     struct addrinfo hints = { 0 }, *ai;
4173 #endif
4174
4175     str[0] = '\0';
4176     if (proto)
4177         av_strlcatf(str, size, "%s://", proto);
4178     if (authorization && authorization[0])
4179         av_strlcatf(str, size, "%s@", authorization);
4180 #if CONFIG_NETWORK && defined(AF_INET6)
4181     /* Determine if hostname is a numerical IPv6 address,
4182      * properly escape it within [] in that case. */
4183     hints.ai_flags = AI_NUMERICHOST;
4184     if (!getaddrinfo(hostname, NULL, &hints, &ai)) {
4185         if (ai->ai_family == AF_INET6) {
4186             av_strlcat(str, "[", size);
4187             av_strlcat(str, hostname, size);
4188             av_strlcat(str, "]", size);
4189         } else {
4190             av_strlcat(str, hostname, size);
4191         }
4192         freeaddrinfo(ai);
4193     } else
4194 #endif
4195         /* Not an IPv6 address, just output the plain string. */
4196         av_strlcat(str, hostname, size);
4197
4198     if (port >= 0)
4199         av_strlcatf(str, size, ":%d", port);
4200     if (fmt) {
4201         va_list vl;
4202         int len = strlen(str);
4203
4204         va_start(vl, fmt);
4205         vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);
4206         va_end(vl);
4207     }
4208     return strlen(str);
4209 }
4210
4211 int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
4212                      AVFormatContext *src)
4213 {
4214     AVPacket local_pkt;
4215
4216     local_pkt = *pkt;
4217     local_pkt.stream_index = dst_stream;
4218     if (pkt->pts != AV_NOPTS_VALUE)
4219         local_pkt.pts = av_rescale_q(pkt->pts,
4220                                      src->streams[pkt->stream_index]->time_base,
4221                                      dst->streams[dst_stream]->time_base);
4222     if (pkt->dts != AV_NOPTS_VALUE)
4223         local_pkt.dts = av_rescale_q(pkt->dts,
4224                                      src->streams[pkt->stream_index]->time_base,
4225                                      dst->streams[dst_stream]->time_base);
4226     return av_write_frame(dst, &local_pkt);
4227 }
4228
4229 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
4230                         void *context)
4231 {
4232     const char *ptr = str;
4233
4234     /* Parse key=value pairs. */
4235     for (;;) {
4236         const char *key;
4237         char *dest = NULL, *dest_end;
4238         int key_len, dest_len = 0;
4239
4240         /* Skip whitespace and potential commas. */
4241         while (*ptr && (isspace(*ptr) || *ptr == ','))
4242             ptr++;
4243         if (!*ptr)
4244             break;
4245
4246         key = ptr;
4247
4248         if (!(ptr = strchr(key, '=')))
4249             break;
4250         ptr++;
4251         key_len = ptr - key;
4252
4253         callback_get_buf(context, key, key_len, &dest, &dest_len);
4254         dest_end = dest + dest_len - 1;
4255
4256         if (*ptr == '\"') {
4257             ptr++;
4258             while (*ptr && *ptr != '\"') {
4259                 if (*ptr == '\\') {
4260                     if (!ptr[1])
4261                         break;
4262                     if (dest && dest < dest_end)
4263                         *dest++ = ptr[1];
4264                     ptr += 2;
4265                 } else {
4266                     if (dest && dest < dest_end)
4267                         *dest++ = *ptr;
4268                     ptr++;
4269                 }
4270             }
4271             if (*ptr == '\"')
4272                 ptr++;
4273         } else {
4274             for (; *ptr && !(isspace(*ptr) || *ptr == ','); ptr++)
4275                 if (dest && dest < dest_end)
4276                     *dest++ = *ptr;
4277         }
4278         if (dest)
4279             *dest = 0;
4280     }
4281 }
4282
4283 int ff_find_stream_index(AVFormatContext *s, int id)
4284 {
4285     int i;
4286     for (i = 0; i < s->nb_streams; i++) {
4287         if (s->streams[i]->id == id)
4288             return i;
4289     }
4290     return -1;
4291 }
4292
4293 void ff_make_absolute_url(char *buf, int size, const char *base,
4294                           const char *rel)
4295 {
4296     char *sep;
4297     /* Absolute path, relative to the current server */
4298     if (base && strstr(base, "://") && rel[0] == '/') {
4299         if (base != buf)
4300             av_strlcpy(buf, base, size);
4301         sep = strstr(buf, "://");
4302         if (sep) {
4303             sep += 3;
4304             sep = strchr(sep, '/');
4305             if (sep)
4306                 *sep = '\0';
4307         }
4308         av_strlcat(buf, rel, size);
4309         return;
4310     }
4311     /* If rel actually is an absolute url, just copy it */
4312     if (!base || strstr(rel, "://") || rel[0] == '/') {
4313         av_strlcpy(buf, rel, size);
4314         return;
4315     }
4316     if (base != buf)
4317         av_strlcpy(buf, base, size);
4318     /* Remove the file name from the base url */
4319     sep = strrchr(buf, '/');
4320     if (sep)
4321         sep[1] = '\0';
4322     else
4323         buf[0] = '\0';
4324     while (av_strstart(rel, "../", NULL) && sep) {
4325         /* Remove the path delimiter at the end */
4326         sep[0] = '\0';
4327         sep = strrchr(buf, '/');
4328         /* If the next directory name to pop off is "..", break here */
4329         if (!strcmp(sep ? &sep[1] : buf, "..")) {
4330             /* Readd the slash we just removed */
4331             av_strlcat(buf, "/", size);
4332             break;
4333         }
4334         /* Cut off the directory name */
4335         if (sep)
4336             sep[1] = '\0';
4337         else
4338             buf[0] = '\0';
4339         rel += 3;
4340     }
4341     av_strlcat(buf, rel, size);
4342 }
4343
4344 int64_t ff_iso8601_to_unix_time(const char *datestr)
4345 {
4346 #if HAVE_STRPTIME
4347     struct tm time1 = {0}, time2 = {0};
4348     char *ret1, *ret2;
4349     ret1 = strptime(datestr, "%Y - %m - %d %T", &time1);
4350     ret2 = strptime(datestr, "%Y - %m - %dT%T", &time2);
4351     if (ret2 && !ret1)
4352         return av_timegm(&time2);
4353     else
4354         return av_timegm(&time1);
4355 #else
4356     av_log(NULL, AV_LOG_WARNING, "strptime() unavailable on this system, cannot convert "
4357                                  "the date string.\n");
4358     return 0;
4359 #endif
4360 }
4361
4362 int avformat_query_codec(AVOutputFormat *ofmt, enum CodecID codec_id, int std_compliance)
4363 {
4364     if (ofmt) {
4365         if (ofmt->query_codec)
4366             return ofmt->query_codec(codec_id, std_compliance);
4367         else if (ofmt->codec_tag)
4368             return !!av_codec_get_tag(ofmt->codec_tag, codec_id);
4369         else if (codec_id == ofmt->video_codec || codec_id == ofmt->audio_codec ||
4370                  codec_id == ofmt->subtitle_codec)
4371             return 1;
4372     }
4373     return AVERROR_PATCHWELCOME;
4374 }
4375
4376 int avformat_network_init(void)
4377 {
4378 #if CONFIG_NETWORK
4379     int ret;
4380     ff_network_inited_globally = 1;
4381     if ((ret = ff_network_init()) < 0)
4382         return ret;
4383     ff_tls_init();
4384 #endif
4385     return 0;
4386 }
4387
4388 int avformat_network_deinit(void)
4389 {
4390 #if CONFIG_NETWORK
4391     ff_network_close();
4392     ff_tls_deinit();
4393 #endif
4394     return 0;
4395 }
4396
4397 int ff_add_param_change(AVPacket *pkt, int32_t channels,
4398                         uint64_t channel_layout, int32_t sample_rate,
4399                         int32_t width, int32_t height)
4400 {
4401     uint32_t flags = 0;
4402     int size = 4;
4403     uint8_t *data;
4404     if (!pkt)
4405         return AVERROR(EINVAL);
4406     if (channels) {
4407         size += 4;
4408         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
4409     }
4410     if (channel_layout) {
4411         size += 8;
4412         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
4413     }
4414     if (sample_rate) {
4415         size += 4;
4416         flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
4417     }
4418     if (width || height) {
4419         size += 8;
4420         flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
4421     }
4422     data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
4423     if (!data)
4424         return AVERROR(ENOMEM);
4425     bytestream_put_le32(&data, flags);
4426     if (channels)
4427         bytestream_put_le32(&data, channels);
4428     if (channel_layout)
4429         bytestream_put_le64(&data, channel_layout);
4430     if (sample_rate)
4431         bytestream_put_le32(&data, sample_rate);
4432     if (width || height) {
4433         bytestream_put_le32(&data, width);
4434         bytestream_put_le32(&data, height);
4435     }
4436     return 0;
4437 }
4438
4439 const struct AVCodecTag *avformat_get_riff_video_tags(void)
4440 {
4441     return ff_codec_bmp_tags;
4442 }
4443 const struct AVCodecTag *avformat_get_riff_audio_tags(void)
4444 {
4445     return ff_codec_wav_tags;
4446 }
4447
4448 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
4449 {
4450     AVRational undef = {0, 1};
4451     AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
4452     AVRational codec_sample_aspect_ratio  = stream && stream->codec ? stream->codec->sample_aspect_ratio : undef;
4453     AVRational frame_sample_aspect_ratio  = frame  ? frame->sample_aspect_ratio  : codec_sample_aspect_ratio;
4454
4455     av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
4456                stream_sample_aspect_ratio.num,  stream_sample_aspect_ratio.den, INT_MAX);
4457     if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
4458         stream_sample_aspect_ratio = undef;
4459
4460     av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
4461                frame_sample_aspect_ratio.num,  frame_sample_aspect_ratio.den, INT_MAX);
4462     if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
4463         frame_sample_aspect_ratio = undef;
4464
4465     if (stream_sample_aspect_ratio.num)
4466         return stream_sample_aspect_ratio;
4467     else
4468         return frame_sample_aspect_ratio;
4469 }