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