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

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