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