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