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

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