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