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