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