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