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