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