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