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