git.sesse.net Git - ffmpeg/blob - libavformat/utils.c

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