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