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 int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1425     AVInputFormat *avif= s->iformat;
1426     int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1427     int64_t ts_min, ts_max, ts;
1428     int index;
1429     int64_t ret;
1430     AVStream *st;
1431
1432     if (stream_index < 0)
1433         return -1;
1434
1435     av_dlog(s, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1436
1437     ts_max=
1438     ts_min= AV_NOPTS_VALUE;
1439     pos_limit= -1; //gcc falsely says it may be uninitialized
1440
1441     st= s->streams[stream_index];
1442     if(st->index_entries){
1443         AVIndexEntry *e;
1444
1445         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()
1446         index= FFMAX(index, 0);
1447         e= &st->index_entries[index];
1448
1449         if(e->timestamp <= target_ts || e->pos == e->min_distance){
1450             pos_min= e->pos;
1451             ts_min= e->timestamp;
1452             av_dlog(s, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1453                     pos_min,ts_min);
1454         }else{
1455             assert(index==0);
1456         }
1457
1458         index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1459         assert(index < st->nb_index_entries);
1460         if(index >= 0){
1461             e= &st->index_entries[index];
1462             assert(e->timestamp >= target_ts);
1463             pos_max= e->pos;
1464             ts_max= e->timestamp;
1465             pos_limit= pos_max - e->min_distance;
1466             av_dlog(s, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1467                     pos_max,pos_limit, ts_max);
1468         }
1469     }
1470
1471     pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1472     if(pos<0)
1473         return -1;
1474
1475     /* do the seek */
1476     if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
1477         return ret;
1478
1479     av_update_cur_dts(s, st, ts);
1480
1481     return 0;
1482 }
1483
1484 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 )){
1485     int64_t pos, ts;
1486     int64_t start_pos, filesize;
1487     int no_change;
1488
1489     av_dlog(s, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1490
1491     if(ts_min == AV_NOPTS_VALUE){
1492         pos_min = s->data_offset;
1493         ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1494         if (ts_min == AV_NOPTS_VALUE)
1495             return -1;
1496     }
1497
1498     if(ts_max == AV_NOPTS_VALUE){
1499         int step= 1024;
1500         filesize = avio_size(s->pb);
1501         pos_max = filesize - 1;
1502         do{
1503             pos_max -= step;
1504             ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1505             step += step;
1506         }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1507         if (ts_max == AV_NOPTS_VALUE)
1508             return -1;
1509
1510         for(;;){
1511             int64_t tmp_pos= pos_max + 1;
1512             int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1513             if(tmp_ts == AV_NOPTS_VALUE)
1514                 break;
1515             ts_max= tmp_ts;
1516             pos_max= tmp_pos;
1517             if(tmp_pos >= filesize)
1518                 break;
1519         }
1520         pos_limit= pos_max;
1521     }
1522
1523     if(ts_min > ts_max){
1524         return -1;
1525     }else if(ts_min == ts_max){
1526         pos_limit= pos_min;
1527     }
1528
1529     no_change=0;
1530     while (pos_min < pos_limit) {
1531         av_dlog(s, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1532                 pos_min, pos_max, ts_min, ts_max);
1533         assert(pos_limit <= pos_max);
1534
1535         if(no_change==0){
1536             int64_t approximate_keyframe_distance= pos_max - pos_limit;
1537             // interpolate position (better than dichotomy)
1538             pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1539                 + pos_min - approximate_keyframe_distance;
1540         }else if(no_change==1){
1541             // bisection, if interpolation failed to change min or max pos last time
1542             pos = (pos_min + pos_limit)>>1;
1543         }else{
1544             /* linear search if bisection failed, can only happen if there
1545                are very few or no keyframes between min/max */
1546             pos=pos_min;
1547         }
1548         if(pos <= pos_min)
1549             pos= pos_min + 1;
1550         else if(pos > pos_limit)
1551             pos= pos_limit;
1552         start_pos= pos;
1553
1554         ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1555         if(pos == pos_max)
1556             no_change++;
1557         else
1558             no_change=0;
1559         av_dlog(s, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64" target:%"PRId64" limit:%"PRId64" start:%"PRId64" noc:%d\n",
1560                 pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts,
1561                 pos_limit, start_pos, no_change);
1562         if(ts == AV_NOPTS_VALUE){
1563             av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1564             return -1;
1565         }
1566         assert(ts != AV_NOPTS_VALUE);
1567         if (target_ts <= ts) {
1568             pos_limit = start_pos - 1;
1569             pos_max = pos;
1570             ts_max = ts;
1571         }
1572         if (target_ts >= ts) {
1573             pos_min = pos;
1574             ts_min = ts;
1575         }
1576     }
1577
1578     pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1579     ts  = (flags & AVSEEK_FLAG_BACKWARD) ?  ts_min :  ts_max;
1580 #if 1
1581     pos_min = pos;
1582     ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1583     pos_min++;
1584     ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1585     av_dlog(s, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1586             pos, ts_min, target_ts, ts_max);
1587 #endif
1588     *ts_ret= ts;
1589     return pos;
1590 }
1591
1592 static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1593     int64_t pos_min, pos_max;
1594 #if 0
1595     AVStream *st;
1596
1597     if (stream_index < 0)
1598         return -1;
1599
1600     st= s->streams[stream_index];
1601 #endif
1602
1603     pos_min = s->data_offset;
1604     pos_max = avio_size(s->pb) - 1;
1605
1606     if     (pos < pos_min) pos= pos_min;
1607     else if(pos > pos_max) pos= pos_max;
1608
1609     avio_seek(s->pb, pos, SEEK_SET);
1610
1611 #if 0
1612     av_update_cur_dts(s, st, ts);
1613 #endif
1614     return 0;
1615 }
1616
1617 static int av_seek_frame_generic(AVFormatContext *s,
1618                                  int stream_index, int64_t timestamp, int flags)
1619 {
1620     int index;
1621     int64_t ret;
1622     AVStream *st;
1623     AVIndexEntry *ie;
1624
1625     st = s->streams[stream_index];
1626
1627     index = av_index_search_timestamp(st, timestamp, flags);
1628
1629     if(index < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
1630         return -1;
1631
1632     if(index < 0 || index==st->nb_index_entries-1){
1633         int i;
1634         AVPacket pkt;
1635
1636         if(st->nb_index_entries){
1637             assert(st->index_entries);
1638             ie= &st->index_entries[st->nb_index_entries-1];
1639             if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1640                 return ret;
1641             av_update_cur_dts(s, st, ie->timestamp);
1642         }else{
1643             if ((ret = avio_seek(s->pb, s->data_offset, SEEK_SET)) < 0)
1644                 return ret;
1645         }
1646         for(i=0;; i++) {
1647             int ret;
1648             do{
1649                 ret = av_read_frame(s, &pkt);
1650             }while(ret == AVERROR(EAGAIN));
1651             if(ret<0)
1652                 break;
1653             av_free_packet(&pkt);
1654             if(stream_index == pkt.stream_index){
1655                 if((pkt.flags & AV_PKT_FLAG_KEY) && pkt.dts > timestamp)
1656                     break;
1657             }
1658         }
1659         index = av_index_search_timestamp(st, timestamp, flags);
1660     }
1661     if (index < 0)
1662         return -1;
1663
1664     ff_read_frame_flush(s);
1665     if (s->iformat->read_seek){
1666         if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1667             return 0;
1668     }
1669     ie = &st->index_entries[index];
1670     if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1671         return ret;
1672     av_update_cur_dts(s, st, ie->timestamp);
1673
1674     return 0;
1675 }
1676
1677 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1678 {
1679     int ret;
1680     AVStream *st;
1681
1682     ff_read_frame_flush(s);
1683
1684     if(flags & AVSEEK_FLAG_BYTE)
1685         return av_seek_frame_byte(s, stream_index, timestamp, flags);
1686
1687     if(stream_index < 0){
1688         stream_index= av_find_default_stream_index(s);
1689         if(stream_index < 0)
1690             return -1;
1691
1692         st= s->streams[stream_index];
1693        /* timestamp for default must be expressed in AV_TIME_BASE units */
1694         timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1695     }
1696
1697     /* first, we try the format specific seek */
1698     if (s->iformat->read_seek)
1699         ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1700     else
1701         ret = -1;
1702     if (ret >= 0) {
1703         return 0;
1704     }
1705
1706     if(s->iformat->read_timestamp && !(s->iformat->flags & AVFMT_NOBINSEARCH))
1707         return av_seek_frame_binary(s, stream_index, timestamp, flags);
1708     else if (!(s->iformat->flags & AVFMT_NOGENSEARCH))
1709         return av_seek_frame_generic(s, stream_index, timestamp, flags);
1710     else
1711         return -1;
1712 }
1713
1714 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
1715 {
1716     if(min_ts > ts || max_ts < ts)
1717         return -1;
1718
1719     ff_read_frame_flush(s);
1720
1721     if (s->iformat->read_seek2)
1722         return s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
1723
1724     if(s->iformat->read_timestamp){
1725         //try to seek via read_timestamp()
1726     }
1727
1728     //Fallback to old API if new is not implemented but old is
1729     //Note the old has somewat different sematics
1730     if(s->iformat->read_seek || 1)
1731         return av_seek_frame(s, stream_index, ts, flags | (ts - min_ts > (uint64_t)(max_ts - ts) ? AVSEEK_FLAG_BACKWARD : 0));
1732
1733     // try some generic seek like av_seek_frame_generic() but with new ts semantics
1734 }
1735
1736 /*******************************************************/
1737
1738 /**
1739  * Return TRUE if the stream has accurate duration in any stream.
1740  *
1741  * @return TRUE if the stream has accurate duration for at least one component.
1742  */
1743 static int av_has_duration(AVFormatContext *ic)
1744 {
1745     int i;
1746     AVStream *st;
1747
1748     for(i = 0;i < ic->nb_streams; i++) {
1749         st = ic->streams[i];
1750         if (st->duration != AV_NOPTS_VALUE)
1751             return 1;
1752     }
1753     return 0;
1754 }
1755
1756 /**
1757  * Estimate the stream timings from the one of each components.
1758  *
1759  * Also computes the global bitrate if possible.
1760  */
1761 static void av_update_stream_timings(AVFormatContext *ic)
1762 {
1763     int64_t start_time, start_time1, end_time, end_time1;
1764     int64_t duration, duration1;
1765     int i;
1766     AVStream *st;
1767
1768     start_time = INT64_MAX;
1769     end_time = INT64_MIN;
1770     duration = INT64_MIN;
1771     for(i = 0;i < ic->nb_streams; i++) {
1772         st = ic->streams[i];
1773         if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
1774             start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1775             if (start_time1 < start_time)
1776                 start_time = start_time1;
1777             if (st->duration != AV_NOPTS_VALUE) {
1778                 end_time1 = start_time1
1779                           + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1780                 if (end_time1 > end_time)
1781                     end_time = end_time1;
1782             }
1783         }
1784         if (st->duration != AV_NOPTS_VALUE) {
1785             duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1786             if (duration1 > duration)
1787                 duration = duration1;
1788         }
1789     }
1790     if (start_time != INT64_MAX) {
1791         ic->start_time = start_time;
1792         if (end_time != INT64_MIN) {
1793             if (end_time - start_time > duration)
1794                 duration = end_time - start_time;
1795         }
1796     }
1797     if (duration != INT64_MIN) {
1798         ic->duration = duration;
1799         if (ic->file_size > 0) {
1800             /* compute the bitrate */
1801             ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1802                 (double)ic->duration;
1803         }
1804     }
1805 }
1806
1807 static void fill_all_stream_timings(AVFormatContext *ic)
1808 {
1809     int i;
1810     AVStream *st;
1811
1812     av_update_stream_timings(ic);
1813     for(i = 0;i < ic->nb_streams; i++) {
1814         st = ic->streams[i];
1815         if (st->start_time == AV_NOPTS_VALUE) {
1816             if(ic->start_time != AV_NOPTS_VALUE)
1817                 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1818             if(ic->duration != AV_NOPTS_VALUE)
1819                 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1820         }
1821     }
1822 }
1823
1824 static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1825 {
1826     int64_t filesize, duration;
1827     int bit_rate, i;
1828     AVStream *st;
1829
1830     /* if bit_rate is already set, we believe it */
1831     if (ic->bit_rate <= 0) {
1832         bit_rate = 0;
1833         for(i=0;i<ic->nb_streams;i++) {
1834             st = ic->streams[i];
1835             if (st->codec->bit_rate > 0)
1836             bit_rate += st->codec->bit_rate;
1837         }
1838         ic->bit_rate = bit_rate;
1839     }
1840
1841     /* if duration is already set, we believe it */
1842     if (ic->duration == AV_NOPTS_VALUE &&
1843         ic->bit_rate != 0 &&
1844         ic->file_size != 0)  {
1845         filesize = ic->file_size;
1846         if (filesize > 0) {
1847             for(i = 0; i < ic->nb_streams; i++) {
1848                 st = ic->streams[i];
1849                 duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1850                 if (st->duration == AV_NOPTS_VALUE)
1851                     st->duration = duration;
1852             }
1853         }
1854     }
1855 }
1856
1857 #define DURATION_MAX_READ_SIZE 250000
1858 #define DURATION_MAX_RETRY 3
1859
1860 /* only usable for MPEG-PS streams */
1861 static void av_estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
1862 {
1863     AVPacket pkt1, *pkt = &pkt1;
1864     AVStream *st;
1865     int read_size, i, ret;
1866     int64_t end_time;
1867     int64_t filesize, offset, duration;
1868     int retry=0;
1869
1870     ic->cur_st = NULL;
1871
1872     /* flush packet queue */
1873     flush_packet_queue(ic);
1874
1875     for (i=0; i<ic->nb_streams; i++) {
1876         st = ic->streams[i];
1877         if (st->start_time == AV_NOPTS_VALUE && st->first_dts == AV_NOPTS_VALUE)
1878             av_log(st->codec, AV_LOG_WARNING, "start time is not set in av_estimate_timings_from_pts\n");
1879
1880         if (st->parser) {
1881             av_parser_close(st->parser);
1882             st->parser= NULL;
1883             av_free_packet(&st->cur_pkt);
1884         }
1885     }
1886
1887     /* estimate the end time (duration) */
1888     /* XXX: may need to support wrapping */
1889     filesize = ic->file_size;
1890     end_time = AV_NOPTS_VALUE;
1891     do{
1892     offset = filesize - (DURATION_MAX_READ_SIZE<<retry);
1893     if (offset < 0)
1894         offset = 0;
1895
1896     avio_seek(ic->pb, offset, SEEK_SET);
1897     read_size = 0;
1898     for(;;) {
1899         if (read_size >= DURATION_MAX_READ_SIZE<<(FFMAX(retry-1,0)))
1900             break;
1901
1902         do{
1903             ret = av_read_packet(ic, pkt);
1904         }while(ret == AVERROR(EAGAIN));
1905         if (ret != 0)
1906             break;
1907         read_size += pkt->size;
1908         st = ic->streams[pkt->stream_index];
1909         if (pkt->pts != AV_NOPTS_VALUE &&
1910             (st->start_time != AV_NOPTS_VALUE ||
1911              st->first_dts  != AV_NOPTS_VALUE)) {
1912             duration = end_time = pkt->pts;
1913             if (st->start_time != AV_NOPTS_VALUE)  duration -= st->start_time;
1914             else                                   duration -= st->first_dts;
1915             if (duration < 0)
1916                 duration += 1LL<<st->pts_wrap_bits;
1917             if (duration > 0) {
1918                 if (st->duration == AV_NOPTS_VALUE ||
1919                     st->duration < duration)
1920                     st->duration = duration;
1921             }
1922         }
1923         av_free_packet(pkt);
1924     }
1925     }while(   end_time==AV_NOPTS_VALUE
1926            && filesize > (DURATION_MAX_READ_SIZE<<retry)
1927            && ++retry <= DURATION_MAX_RETRY);
1928
1929     fill_all_stream_timings(ic);
1930
1931     avio_seek(ic->pb, old_offset, SEEK_SET);
1932     for (i=0; i<ic->nb_streams; i++) {
1933         st= ic->streams[i];
1934         st->cur_dts= st->first_dts;
1935         st->last_IP_pts = AV_NOPTS_VALUE;
1936     }
1937 }
1938
1939 static void av_estimate_timings(AVFormatContext *ic, int64_t old_offset)
1940 {
1941     int64_t file_size;
1942
1943     /* get the file size, if possible */
1944     if (ic->iformat->flags & AVFMT_NOFILE) {
1945         file_size = 0;
1946     } else {
1947         file_size = avio_size(ic->pb);
1948         if (file_size < 0)
1949             file_size = 0;
1950     }
1951     ic->file_size = file_size;
1952
1953     if ((!strcmp(ic->iformat->name, "mpeg") ||
1954          !strcmp(ic->iformat->name, "mpegts")) &&
1955         file_size && ic->pb->seekable) {
1956         /* get accurate estimate from the PTSes */
1957         av_estimate_timings_from_pts(ic, old_offset);
1958     } else if (av_has_duration(ic)) {
1959         /* at least one component has timings - we use them for all
1960            the components */
1961         fill_all_stream_timings(ic);
1962     } else {
1963         av_log(ic, AV_LOG_WARNING, "Estimating duration from bitrate, this may be inaccurate\n");
1964         /* less precise: use bitrate info */
1965         av_estimate_timings_from_bit_rate(ic);
1966     }
1967     av_update_stream_timings(ic);
1968
1969     {
1970         int i;
1971         AVStream av_unused *st;
1972         for(i = 0;i < ic->nb_streams; i++) {
1973             st = ic->streams[i];
1974             av_dlog(ic, "%d: start_time: %0.3f duration: %0.3f\n", i,
1975                     (double) st->start_time / AV_TIME_BASE,
1976                     (double) st->duration   / AV_TIME_BASE);
1977         }
1978         av_dlog(ic, "stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1979                 (double) ic->start_time / AV_TIME_BASE,
1980                 (double) ic->duration   / AV_TIME_BASE,
1981                 ic->bit_rate / 1000);
1982     }
1983 }
1984
1985 static int has_codec_parameters(AVCodecContext *enc)
1986 {
1987     int val;
1988     switch(enc->codec_type) {
1989     case AVMEDIA_TYPE_AUDIO:
1990         val = enc->sample_rate && enc->channels && enc->sample_fmt != AV_SAMPLE_FMT_NONE;
1991         if(!enc->frame_size &&
1992            (enc->codec_id == CODEC_ID_VORBIS ||
1993             enc->codec_id == CODEC_ID_AAC ||
1994             enc->codec_id == CODEC_ID_MP1 ||
1995             enc->codec_id == CODEC_ID_MP2 ||
1996             enc->codec_id == CODEC_ID_MP3 ||
1997             enc->codec_id == CODEC_ID_SPEEX))
1998             return 0;
1999         break;
2000     case AVMEDIA_TYPE_VIDEO:
2001         val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
2002         break;
2003     default:
2004         val = 1;
2005         break;
2006     }
2007     return enc->codec_id != CODEC_ID_NONE && val != 0;
2008 }
2009
2010 static int has_decode_delay_been_guessed(AVStream *st)
2011 {
2012     return st->codec->codec_id != CODEC_ID_H264 ||
2013         st->codec_info_nb_frames >= 6 + st->codec->has_b_frames;
2014 }
2015
2016 static int try_decode_frame(AVStream *st, AVPacket *avpkt)
2017 {
2018     int16_t *samples;
2019     AVCodec *codec;
2020     int got_picture, data_size, ret=0;
2021     AVFrame picture;
2022
2023     if(!st->codec->codec){
2024         codec = avcodec_find_decoder(st->codec->codec_id);
2025         if (!codec)
2026             return -1;
2027         ret = avcodec_open(st->codec, codec);
2028         if (ret < 0)
2029             return ret;
2030     }
2031
2032     if(!has_codec_parameters(st->codec) || !has_decode_delay_been_guessed(st)){
2033         switch(st->codec->codec_type) {
2034         case AVMEDIA_TYPE_VIDEO:
2035             avcodec_get_frame_defaults(&picture);
2036             ret = avcodec_decode_video2(st->codec, &picture,
2037                                         &got_picture, avpkt);
2038             break;
2039         case AVMEDIA_TYPE_AUDIO:
2040             data_size = FFMAX(avpkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
2041             samples = av_malloc(data_size);
2042             if (!samples)
2043                 goto fail;
2044             ret = avcodec_decode_audio3(st->codec, samples,
2045                                         &data_size, avpkt);
2046             av_free(samples);
2047             break;
2048         default:
2049             break;
2050         }
2051     }
2052  fail:
2053     return ret;
2054 }
2055
2056 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum CodecID id)
2057 {
2058     while (tags->id != CODEC_ID_NONE) {
2059         if (tags->id == id)
2060             return tags->tag;
2061         tags++;
2062     }
2063     return 0;
2064 }
2065
2066 enum CodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2067 {
2068     int i;
2069     for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
2070         if(tag == tags[i].tag)
2071             return tags[i].id;
2072     }
2073     for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
2074         if (ff_toupper4(tag) == ff_toupper4(tags[i].tag))
2075             return tags[i].id;
2076     }
2077     return CODEC_ID_NONE;
2078 }
2079
2080 unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum CodecID id)
2081 {
2082     int i;
2083     for(i=0; tags && tags[i]; i++){
2084         int tag= ff_codec_get_tag(tags[i], id);
2085         if(tag) return tag;
2086     }
2087     return 0;
2088 }
2089
2090 enum CodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
2091 {
2092     int i;
2093     for(i=0; tags && tags[i]; i++){
2094         enum CodecID id= ff_codec_get_id(tags[i], tag);
2095         if(id!=CODEC_ID_NONE) return id;
2096     }
2097     return CODEC_ID_NONE;
2098 }
2099
2100 static void compute_chapters_end(AVFormatContext *s)
2101 {
2102     unsigned int i, j;
2103     int64_t max_time = s->duration + ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
2104
2105     for (i = 0; i < s->nb_chapters; i++)
2106         if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2107             AVChapter *ch = s->chapters[i];
2108             int64_t   end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q, ch->time_base)
2109                                      : INT64_MAX;
2110
2111             for (j = 0; j < s->nb_chapters; j++) {
2112                 AVChapter *ch1 = s->chapters[j];
2113                 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base, ch->time_base);
2114                 if (j != i && next_start > ch->start && next_start < end)
2115                     end = next_start;
2116             }
2117             ch->end = (end == INT64_MAX) ? ch->start : end;
2118         }
2119 }
2120
2121 static int get_std_framerate(int i){
2122     if(i<60*12) return i*1001;
2123     else        return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
2124 }
2125
2126 /*
2127  * Is the time base unreliable.
2128  * This is a heuristic to balance between quick acceptance of the values in
2129  * the headers vs. some extra checks.
2130  * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2131  * MPEG-2 commonly misuses field repeat flags to store different framerates.
2132  * And there are "variable" fps files this needs to detect as well.
2133  */
2134 static int tb_unreliable(AVCodecContext *c){
2135     if(   c->time_base.den >= 101L*c->time_base.num
2136        || c->time_base.den <    5L*c->time_base.num
2137 /*       || c->codec_tag == AV_RL32("DIVX")
2138        || c->codec_tag == AV_RL32("XVID")*/
2139        || c->codec_id == CODEC_ID_MPEG2VIDEO
2140        || c->codec_id == CODEC_ID_H264
2141        )
2142         return 1;
2143     return 0;
2144 }
2145
2146 int av_find_stream_info(AVFormatContext *ic)
2147 {
2148     int i, count, ret, read_size, j;
2149     AVStream *st;
2150     AVPacket pkt1, *pkt;
2151     int64_t old_offset = avio_tell(ic->pb);
2152
2153     for(i=0;i<ic->nb_streams;i++) {
2154         AVCodec *codec;
2155         st = ic->streams[i];
2156         if (st->codec->codec_id == CODEC_ID_AAC) {
2157             st->codec->sample_rate = 0;
2158             st->codec->frame_size = 0;
2159             st->codec->channels = 0;
2160         }
2161         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2162             st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2163 /*            if(!st->time_base.num)
2164                 st->time_base= */
2165             if(!st->codec->time_base.num)
2166                 st->codec->time_base= st->time_base;
2167         }
2168         //only for the split stuff
2169         if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
2170             st->parser = av_parser_init(st->codec->codec_id);
2171             if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
2172                 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2173             }
2174         }
2175         assert(!st->codec->codec);
2176         codec = avcodec_find_decoder(st->codec->codec_id);
2177
2178         /* Force decoding of at least one frame of codec data
2179          * this makes sure the codec initializes the channel configuration
2180          * and does not trust the values from the container.
2181          */
2182         if (codec && codec->capabilities & CODEC_CAP_CHANNEL_CONF)
2183             st->codec->channels = 0;
2184
2185         /* Ensure that subtitle_header is properly set. */
2186         if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
2187             && codec && !st->codec->codec)
2188             avcodec_open(st->codec, codec);
2189
2190         //try to just open decoders, in case this is enough to get parameters
2191         if(!has_codec_parameters(st->codec)){
2192             if (codec && !st->codec->codec)
2193                 avcodec_open(st->codec, codec);
2194         }
2195     }
2196
2197     for (i=0; i<ic->nb_streams; i++) {
2198         ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
2199     }
2200
2201     count = 0;
2202     read_size = 0;
2203     for(;;) {
2204         if(url_interrupt_cb()){
2205             ret= AVERROR_EXIT;
2206             av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2207             break;
2208         }
2209
2210         /* check if one codec still needs to be handled */
2211         for(i=0;i<ic->nb_streams;i++) {
2212             int fps_analyze_framecount = 20;
2213
2214             st = ic->streams[i];
2215             if (!has_codec_parameters(st->codec))
2216                 break;
2217             /* if the timebase is coarse (like the usual millisecond precision
2218                of mkv), we need to analyze more frames to reliably arrive at
2219                the correct fps */
2220             if (av_q2d(st->time_base) > 0.0005)
2221                 fps_analyze_framecount *= 2;
2222             if (ic->fps_probe_size >= 0)
2223                 fps_analyze_framecount = ic->fps_probe_size;
2224             /* variable fps and no guess at the real fps */
2225             if(   tb_unreliable(st->codec) && !(st->r_frame_rate.num && st->avg_frame_rate.num)
2226                && st->info->duration_count < fps_analyze_framecount
2227                && st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2228                 break;
2229             if(st->parser && st->parser->parser->split && !st->codec->extradata)
2230                 break;
2231             if(st->first_dts == AV_NOPTS_VALUE)
2232                 break;
2233         }
2234         if (i == ic->nb_streams) {
2235             /* NOTE: if the format has no header, then we need to read
2236                some packets to get most of the streams, so we cannot
2237                stop here */
2238             if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2239                 /* if we found the info for all the codecs, we can stop */
2240                 ret = count;
2241                 av_log(ic, AV_LOG_DEBUG, "All info found\n");
2242                 break;
2243             }
2244         }
2245         /* we did not get all the codec info, but we read too much data */
2246         if (read_size >= ic->probesize) {
2247             ret = count;
2248             av_log(ic, AV_LOG_DEBUG, "Probe buffer size limit %d reached\n", ic->probesize);
2249             break;
2250         }
2251
2252         /* NOTE: a new stream can be added there if no header in file
2253            (AVFMTCTX_NOHEADER) */
2254         ret = av_read_frame_internal(ic, &pkt1);
2255         if (ret < 0 && ret != AVERROR(EAGAIN)) {
2256             /* EOF or error */
2257             ret = -1; /* we could not have all the codec parameters before EOF */
2258             for(i=0;i<ic->nb_streams;i++) {
2259                 st = ic->streams[i];
2260                 if (!has_codec_parameters(st->codec)){
2261                     char buf[256];
2262                     avcodec_string(buf, sizeof(buf), st->codec, 0);
2263                     av_log(ic, AV_LOG_WARNING, "Could not find codec parameters (%s)\n", buf);
2264                 } else {
2265                     ret = 0;
2266                 }
2267             }
2268             break;
2269         }
2270
2271         if (ret == AVERROR(EAGAIN))
2272             continue;
2273
2274         pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2275         if ((ret = av_dup_packet(pkt)) < 0)
2276             goto find_stream_info_err;
2277
2278         read_size += pkt->size;
2279
2280         st = ic->streams[pkt->stream_index];
2281         if (st->codec_info_nb_frames>1) {
2282             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) {
2283                 av_log(ic, AV_LOG_WARNING, "max_analyze_duration reached\n");
2284                 break;
2285             }
2286             st->info->codec_info_duration += pkt->duration;
2287         }
2288         {
2289             int64_t last = st->info->last_dts;
2290             int64_t duration= pkt->dts - last;
2291
2292             if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
2293                 double dur= duration * av_q2d(st->time_base);
2294
2295 //                if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2296 //                    av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
2297                 if (st->info->duration_count < 2)
2298                     memset(st->info->duration_error, 0, sizeof(st->info->duration_error));
2299                 for (i=1; i<FF_ARRAY_ELEMS(st->info->duration_error); i++) {
2300                     int framerate= get_std_framerate(i);
2301                     int ticks= lrintf(dur*framerate/(1001*12));
2302                     double error= dur - ticks*1001*12/(double)framerate;
2303                     st->info->duration_error[i] += error*error;
2304                 }
2305                 st->info->duration_count++;
2306                 // ignore the first 4 values, they might have some random jitter
2307                 if (st->info->duration_count > 3)
2308                     st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2309             }
2310             if (last == AV_NOPTS_VALUE || st->info->duration_count <= 1)
2311                 st->info->last_dts = pkt->dts;
2312         }
2313         if(st->parser && st->parser->parser->split && !st->codec->extradata){
2314             int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2315             if(i){
2316                 st->codec->extradata_size= i;
2317                 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2318                 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2319                 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2320             }
2321         }
2322
2323         /* if still no information, we try to open the codec and to
2324            decompress the frame. We try to avoid that in most cases as
2325            it takes longer and uses more memory. For MPEG-4, we need to
2326            decompress for QuickTime. */
2327         if (!has_codec_parameters(st->codec) || !has_decode_delay_been_guessed(st))
2328             try_decode_frame(st, pkt);
2329
2330         st->codec_info_nb_frames++;
2331         count++;
2332     }
2333
2334     // close codecs which were opened in try_decode_frame()
2335     for(i=0;i<ic->nb_streams;i++) {
2336         st = ic->streams[i];
2337         if(st->codec->codec)
2338             avcodec_close(st->codec);
2339     }
2340     for(i=0;i<ic->nb_streams;i++) {
2341         st = ic->streams[i];
2342         if (st->codec_info_nb_frames>2 && !st->avg_frame_rate.num && st->info->codec_info_duration)
2343             av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2344                      (st->codec_info_nb_frames-2)*(int64_t)st->time_base.den,
2345                       st->info->codec_info_duration*(int64_t)st->time_base.num, 60000);
2346         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2347             if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample)
2348                 st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2349
2350             // the check for tb_unreliable() is not completely correct, since this is not about handling
2351             // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2352             // ipmovie.c produces.
2353             if (tb_unreliable(st->codec) && st->info->duration_count > 15 && st->info->duration_gcd > 1 && !st->r_frame_rate.num)
2354                 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);
2355             if (st->info->duration_count && !st->r_frame_rate.num
2356                && tb_unreliable(st->codec) /*&&
2357                //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2358                st->time_base.num*duration_sum[i]/st->info->duration_count*101LL > st->time_base.den*/){
2359                 int num = 0;
2360                 double best_error= 2*av_q2d(st->time_base);
2361                 best_error = best_error*best_error*st->info->duration_count*1000*12*30;
2362
2363                 for (j=1; j<FF_ARRAY_ELEMS(st->info->duration_error); j++) {
2364                     double error = st->info->duration_error[j] * get_std_framerate(j);
2365 //                    if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2366 //                        av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
2367                     if(error < best_error){
2368                         best_error= error;
2369                         num = get_std_framerate(j);
2370                     }
2371                 }
2372                 // do not increase frame rate by more than 1 % in order to match a standard rate.
2373                 if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
2374                     av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2375             }
2376
2377             if (!st->r_frame_rate.num){
2378                 if(    st->codec->time_base.den * (int64_t)st->time_base.num
2379                     <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
2380                     st->r_frame_rate.num = st->codec->time_base.den;
2381                     st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
2382                 }else{
2383                     st->r_frame_rate.num = st->time_base.den;
2384                     st->r_frame_rate.den = st->time_base.num;
2385                 }
2386             }
2387         }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2388             if(!st->codec->bits_per_coded_sample)
2389                 st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2390             // set stream disposition based on audio service type
2391             switch (st->codec->audio_service_type) {
2392             case AV_AUDIO_SERVICE_TYPE_EFFECTS:
2393                 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;    break;
2394             case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
2395                 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;  break;
2396             case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
2397                 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED; break;
2398             case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
2399                 st->disposition = AV_DISPOSITION_COMMENT;          break;
2400             case AV_AUDIO_SERVICE_TYPE_KARAOKE:
2401                 st->disposition = AV_DISPOSITION_KARAOKE;          break;
2402             }
2403         }
2404     }
2405
2406     av_estimate_timings(ic, old_offset);
2407
2408     compute_chapters_end(ic);
2409
2410 #if 0
2411     /* correct DTS for B-frame streams with no timestamps */
2412     for(i=0;i<ic->nb_streams;i++) {
2413         st = ic->streams[i];
2414         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2415             if(b-frames){
2416                 ppktl = &ic->packet_buffer;
2417                 while(ppkt1){
2418                     if(ppkt1->stream_index != i)
2419                         continue;
2420                     if(ppkt1->pkt->dts < 0)
2421                         break;
2422                     if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2423                         break;
2424                     ppkt1->pkt->dts -= delta;
2425                     ppkt1= ppkt1->next;
2426                 }
2427                 if(ppkt1)
2428                     continue;
2429                 st->cur_dts -= delta;
2430             }
2431         }
2432     }
2433 #endif
2434
2435  find_stream_info_err:
2436     for (i=0; i < ic->nb_streams; i++)
2437         av_freep(&ic->streams[i]->info);
2438     return ret;
2439 }
2440
2441 static AVProgram *find_program_from_stream(AVFormatContext *ic, int s)
2442 {
2443     int i, j;
2444
2445     for (i = 0; i < ic->nb_programs; i++)
2446         for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
2447             if (ic->programs[i]->stream_index[j] == s)
2448                 return ic->programs[i];
2449     return NULL;
2450 }
2451
2452 int av_find_best_stream(AVFormatContext *ic,
2453                         enum AVMediaType type,
2454                         int wanted_stream_nb,
2455                         int related_stream,
2456                         AVCodec **decoder_ret,
2457                         int flags)
2458 {
2459     int i, nb_streams = ic->nb_streams;
2460     int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1;
2461     unsigned *program = NULL;
2462     AVCodec *decoder = NULL, *best_decoder = NULL;
2463
2464     if (related_stream >= 0 && wanted_stream_nb < 0) {
2465         AVProgram *p = find_program_from_stream(ic, related_stream);
2466         if (p) {
2467             program = p->stream_index;
2468             nb_streams = p->nb_stream_indexes;
2469         }
2470     }
2471     for (i = 0; i < nb_streams; i++) {
2472         int real_stream_index = program ? program[i] : i;
2473         AVStream *st = ic->streams[real_stream_index];
2474         AVCodecContext *avctx = st->codec;
2475         if (avctx->codec_type != type)
2476             continue;
2477         if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
2478             continue;
2479         if (st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED|AV_DISPOSITION_VISUAL_IMPAIRED))
2480             continue;
2481         if (decoder_ret) {
2482             decoder = avcodec_find_decoder(st->codec->codec_id);
2483             if (!decoder) {
2484                 if (ret < 0)
2485                     ret = AVERROR_DECODER_NOT_FOUND;
2486                 continue;
2487             }
2488         }
2489         if (best_count >= st->codec_info_nb_frames)
2490             continue;
2491         best_count = st->codec_info_nb_frames;
2492         ret = real_stream_index;
2493         best_decoder = decoder;
2494         if (program && i == nb_streams - 1 && ret < 0) {
2495             program = NULL;
2496             nb_streams = ic->nb_streams;
2497             i = 0; /* no related stream found, try again with everything */
2498         }
2499     }
2500     if (decoder_ret)
2501         *decoder_ret = best_decoder;
2502     return ret;
2503 }
2504
2505 /*******************************************************/
2506
2507 int av_read_play(AVFormatContext *s)
2508 {
2509     if (s->iformat->read_play)
2510         return s->iformat->read_play(s);
2511     if (s->pb)
2512         return avio_pause(s->pb, 0);
2513     return AVERROR(ENOSYS);
2514 }
2515
2516 int av_read_pause(AVFormatContext *s)
2517 {
2518     if (s->iformat->read_pause)
2519         return s->iformat->read_pause(s);
2520     if (s->pb)
2521         return avio_pause(s->pb, 1);
2522     return AVERROR(ENOSYS);
2523 }
2524
2525 void av_close_input_stream(AVFormatContext *s)
2526 {
2527     flush_packet_queue(s);
2528     if (s->iformat->read_close)
2529         s->iformat->read_close(s);
2530     avformat_free_context(s);
2531 }
2532
2533 void avformat_free_context(AVFormatContext *s)
2534 {
2535     int i;
2536     AVStream *st;
2537
2538     av_opt_free(s);
2539     if (s->iformat && s->iformat->priv_class && s->priv_data)
2540         av_opt_free(s->priv_data);
2541
2542     for(i=0;i<s->nb_streams;i++) {
2543         /* free all data in a stream component */
2544         st = s->streams[i];
2545         if (st->parser) {
2546             av_parser_close(st->parser);
2547             av_free_packet(&st->cur_pkt);
2548         }
2549         av_dict_free(&st->metadata);
2550         av_free(st->index_entries);
2551         av_free(st->codec->extradata);
2552         av_free(st->codec->subtitle_header);
2553         av_free(st->codec);
2554         av_free(st->priv_data);
2555         av_free(st->info);
2556         av_free(st);
2557     }
2558     for(i=s->nb_programs-1; i>=0; i--) {
2559         av_dict_free(&s->programs[i]->metadata);
2560         av_freep(&s->programs[i]->stream_index);
2561         av_freep(&s->programs[i]);
2562     }
2563     av_freep(&s->programs);
2564     av_freep(&s->priv_data);
2565     while(s->nb_chapters--) {
2566         av_dict_free(&s->chapters[s->nb_chapters]->metadata);
2567         av_free(s->chapters[s->nb_chapters]);
2568     }
2569     av_freep(&s->chapters);
2570     av_dict_free(&s->metadata);
2571     av_freep(&s->streams);
2572     av_free(s);
2573 }
2574
2575 void av_close_input_file(AVFormatContext *s)
2576 {
2577     AVIOContext *pb = s->iformat->flags & AVFMT_NOFILE ? NULL : s->pb;
2578     av_close_input_stream(s);
2579     if (pb)
2580         avio_close(pb);
2581 }
2582
2583 AVStream *av_new_stream(AVFormatContext *s, int id)
2584 {
2585     AVStream *st;
2586     int i;
2587     AVStream **streams;
2588
2589     if (s->nb_streams >= INT_MAX/sizeof(*streams))
2590         return NULL;
2591     streams = av_realloc(s->streams, (s->nb_streams + 1) * sizeof(*streams));
2592     if (!streams)
2593         return NULL;
2594     s->streams = streams;
2595
2596     st = av_mallocz(sizeof(AVStream));
2597     if (!st)
2598         return NULL;
2599     if (!(st->info = av_mallocz(sizeof(*st->info)))) {
2600         av_free(st);
2601         return NULL;
2602     }
2603
2604     st->codec= avcodec_alloc_context();
2605     if (s->iformat) {
2606         /* no default bitrate if decoding */
2607         st->codec->bit_rate = 0;
2608     }
2609     st->index = s->nb_streams;
2610     st->id = id;
2611     st->start_time = AV_NOPTS_VALUE;
2612     st->duration = AV_NOPTS_VALUE;
2613         /* we set the current DTS to 0 so that formats without any timestamps
2614            but durations get some timestamps, formats with some unknown
2615            timestamps have their first few packets buffered and the
2616            timestamps corrected before they are returned to the user */
2617     st->cur_dts = 0;
2618     st->first_dts = AV_NOPTS_VALUE;
2619     st->probe_packets = MAX_PROBE_PACKETS;
2620
2621     /* default pts setting is MPEG-like */
2622     av_set_pts_info(st, 33, 1, 90000);
2623     st->last_IP_pts = AV_NOPTS_VALUE;
2624     for(i=0; i<MAX_REORDER_DELAY+1; i++)
2625         st->pts_buffer[i]= AV_NOPTS_VALUE;
2626     st->reference_dts = AV_NOPTS_VALUE;
2627
2628     st->sample_aspect_ratio = (AVRational){0,1};
2629
2630     s->streams[s->nb_streams++] = st;
2631     return st;
2632 }
2633
2634 AVProgram *av_new_program(AVFormatContext *ac, int id)
2635 {
2636     AVProgram *program=NULL;
2637     int i;
2638
2639     av_dlog(ac, "new_program: id=0x%04x\n", id);
2640
2641     for(i=0; i<ac->nb_programs; i++)
2642         if(ac->programs[i]->id == id)
2643             program = ac->programs[i];
2644
2645     if(!program){
2646         program = av_mallocz(sizeof(AVProgram));
2647         if (!program)
2648             return NULL;
2649         dynarray_add(&ac->programs, &ac->nb_programs, program);
2650         program->discard = AVDISCARD_NONE;
2651     }
2652     program->id = id;
2653
2654     return program;
2655 }
2656
2657 AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2658 {
2659     AVChapter *chapter = NULL;
2660     int i;
2661
2662     for(i=0; i<s->nb_chapters; i++)
2663         if(s->chapters[i]->id == id)
2664             chapter = s->chapters[i];
2665
2666     if(!chapter){
2667         chapter= av_mallocz(sizeof(AVChapter));
2668         if(!chapter)
2669             return NULL;
2670         dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2671     }
2672     av_dict_set(&chapter->metadata, "title", title, 0);
2673     chapter->id    = id;
2674     chapter->time_base= time_base;
2675     chapter->start = start;
2676     chapter->end   = end;
2677
2678     return chapter;
2679 }
2680
2681 /************************************************************/
2682 /* output media file */
2683
2684 int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2685 {
2686     int ret;
2687
2688     if (s->oformat->priv_data_size > 0) {
2689         s->priv_data = av_mallocz(s->oformat->priv_data_size);
2690         if (!s->priv_data)
2691             return AVERROR(ENOMEM);
2692         if (s->oformat->priv_class) {
2693             *(const AVClass**)s->priv_data= s->oformat->priv_class;
2694             av_opt_set_defaults(s->priv_data);
2695         }
2696     } else
2697         s->priv_data = NULL;
2698
2699     if (s->oformat->set_parameters) {
2700         ret = s->oformat->set_parameters(s, ap);
2701         if (ret < 0)
2702             return ret;
2703     }
2704     return 0;
2705 }
2706
2707 static int validate_codec_tag(AVFormatContext *s, AVStream *st)
2708 {
2709     const AVCodecTag *avctag;
2710     int n;
2711     enum CodecID id = CODEC_ID_NONE;
2712     unsigned int tag = 0;
2713
2714     /**
2715      * Check that tag + id is in the table
2716      * If neither is in the table -> OK
2717      * If tag is in the table with another id -> FAIL
2718      * If id is in the table with another tag -> FAIL unless strict < normal
2719      */
2720     for (n = 0; s->oformat->codec_tag[n]; n++) {
2721         avctag = s->oformat->codec_tag[n];
2722         while (avctag->id != CODEC_ID_NONE) {
2723             if (ff_toupper4(avctag->tag) == ff_toupper4(st->codec->codec_tag)) {
2724                 id = avctag->id;
2725                 if (id == st->codec->codec_id)
2726                     return 1;
2727             }
2728             if (avctag->id == st->codec->codec_id)
2729                 tag = avctag->tag;
2730             avctag++;
2731         }
2732     }
2733     if (id != CODEC_ID_NONE)
2734         return 0;
2735     if (tag && (st->codec->strict_std_compliance >= FF_COMPLIANCE_NORMAL))
2736         return 0;
2737     return 1;
2738 }
2739
2740 int av_write_header(AVFormatContext *s)
2741 {
2742     int ret, i;
2743     AVStream *st;
2744
2745     // some sanity checks
2746     if (s->nb_streams == 0 && !(s->oformat->flags & AVFMT_NOSTREAMS)) {
2747         av_log(s, AV_LOG_ERROR, "no streams\n");
2748         return AVERROR(EINVAL);
2749     }
2750
2751     for(i=0;i<s->nb_streams;i++) {
2752         st = s->streams[i];
2753
2754         switch (st->codec->codec_type) {
2755         case AVMEDIA_TYPE_AUDIO:
2756             if(st->codec->sample_rate<=0){
2757                 av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2758                 return AVERROR(EINVAL);
2759             }
2760             if(!st->codec->block_align)
2761                 st->codec->block_align = st->codec->channels *
2762                     av_get_bits_per_sample(st->codec->codec_id) >> 3;
2763             break;
2764         case AVMEDIA_TYPE_VIDEO:
2765             if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2766                 av_log(s, AV_LOG_ERROR, "time base not set\n");
2767                 return AVERROR(EINVAL);
2768             }
2769             if((st->codec->width<=0 || st->codec->height<=0) && !(s->oformat->flags & AVFMT_NODIMENSIONS)){
2770                 av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2771                 return AVERROR(EINVAL);
2772             }
2773             if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)){
2774                 av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between encoder and muxer layer\n");
2775                 return AVERROR(EINVAL);
2776             }
2777             break;
2778         }
2779
2780         if(s->oformat->codec_tag){
2781             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)){
2782                 //the current rawvideo encoding system ends up setting the wrong codec_tag for avi, we override it here
2783                 st->codec->codec_tag= 0;
2784             }
2785             if(st->codec->codec_tag){
2786                 if (!validate_codec_tag(s, st)) {
2787                     char tagbuf[32];
2788                     av_get_codec_tag_string(tagbuf, sizeof(tagbuf), st->codec->codec_tag);
2789                     av_log(s, AV_LOG_ERROR,
2790                            "Tag %s/0x%08x incompatible with output codec id '%d'\n",
2791                            tagbuf, st->codec->codec_tag, st->codec->codec_id);
2792                     return AVERROR_INVALIDDATA;
2793                 }
2794             }else
2795                 st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2796         }
2797
2798         if(s->oformat->flags & AVFMT_GLOBALHEADER &&
2799             !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
2800           av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
2801     }
2802
2803     if (!s->priv_data && s->oformat->priv_data_size > 0) {
2804         s->priv_data = av_mallocz(s->oformat->priv_data_size);
2805         if (!s->priv_data)
2806             return AVERROR(ENOMEM);
2807     }
2808
2809     /* set muxer identification string */
2810     if (s->nb_streams && !(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
2811         av_dict_set(&s->metadata, "encoder", LIBAVFORMAT_IDENT, 0);
2812     }
2813
2814     if(s->oformat->write_header){
2815         ret = s->oformat->write_header(s);
2816         if (ret < 0)
2817             return ret;
2818     }
2819
2820     /* init PTS generation */
2821     for(i=0;i<s->nb_streams;i++) {
2822         int64_t den = AV_NOPTS_VALUE;
2823         st = s->streams[i];
2824
2825         switch (st->codec->codec_type) {
2826         case AVMEDIA_TYPE_AUDIO:
2827             den = (int64_t)st->time_base.num * st->codec->sample_rate;
2828             break;
2829         case AVMEDIA_TYPE_VIDEO:
2830             den = (int64_t)st->time_base.num * st->codec->time_base.den;
2831             break;
2832         default:
2833             break;
2834         }
2835         if (den != AV_NOPTS_VALUE) {
2836             if (den <= 0)
2837                 return AVERROR_INVALIDDATA;
2838             av_frac_init(&st->pts, 0, 0, den);
2839         }
2840     }
2841     return 0;
2842 }
2843
2844 //FIXME merge with compute_pkt_fields
2845 static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt){
2846     int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2847     int num, den, frame_size, i;
2848
2849     av_dlog(s, "compute_pkt_fields2: pts:%"PRId64" dts:%"PRId64" cur_dts:%"PRId64" b:%d size:%d st:%d\n",
2850             pkt->pts, pkt->dts, st->cur_dts, delay, pkt->size, pkt->stream_index);
2851
2852 /*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2853         return AVERROR(EINVAL);*/
2854
2855     /* duration field */
2856     if (pkt->duration == 0) {
2857         compute_frame_duration(&num, &den, st, NULL, pkt);
2858         if (den && num) {
2859             pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
2860         }
2861     }
2862
2863     if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
2864         pkt->pts= pkt->dts;
2865
2866     //XXX/FIXME this is a temporary hack until all encoders output pts
2867     if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2868         pkt->dts=
2869 //        pkt->pts= st->cur_dts;
2870         pkt->pts= st->pts.val;
2871     }
2872
2873     //calculate dts from pts
2874     if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
2875         st->pts_buffer[0]= pkt->pts;
2876         for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2877             st->pts_buffer[i]= pkt->pts + (i-delay-1) * pkt->duration;
2878         for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2879             FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2880
2881         pkt->dts= st->pts_buffer[0];
2882     }
2883
2884     if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2885         av_log(s, AV_LOG_ERROR,
2886                "Application provided invalid, non monotonically increasing dts to muxer in stream %d: %"PRId64" >= %"PRId64"\n",
2887                st->index, st->cur_dts, pkt->dts);
2888         return AVERROR(EINVAL);
2889     }
2890     if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2891         av_log(s, AV_LOG_ERROR, "pts < dts in stream %d\n", st->index);
2892         return AVERROR(EINVAL);
2893     }
2894
2895 //    av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2896     st->cur_dts= pkt->dts;
2897     st->pts.val= pkt->dts;
2898
2899     /* update pts */
2900     switch (st->codec->codec_type) {
2901     case AVMEDIA_TYPE_AUDIO:
2902         frame_size = get_audio_frame_size(st->codec, pkt->size);
2903
2904         /* HACK/FIXME, we skip the initial 0 size packets as they are most
2905            likely equal to the encoder delay, but it would be better if we
2906            had the real timestamps from the encoder */
2907         if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2908             av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2909         }
2910         break;
2911     case AVMEDIA_TYPE_VIDEO:
2912         av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2913         break;
2914     default:
2915         break;
2916     }
2917     return 0;
2918 }
2919
2920 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2921 {
2922     int ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt);
2923
2924     if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2925         return ret;
2926
2927     ret= s->oformat->write_packet(s, pkt);
2928     return ret;
2929 }
2930
2931 void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
2932                               int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
2933 {
2934     AVPacketList **next_point, *this_pktl;
2935
2936     this_pktl = av_mallocz(sizeof(AVPacketList));
2937     this_pktl->pkt= *pkt;
2938     pkt->destruct= NULL;             // do not free original but only the copy
2939     av_dup_packet(&this_pktl->pkt);  // duplicate the packet if it uses non-alloced memory
2940
2941     if(s->streams[pkt->stream_index]->last_in_packet_buffer){
2942         next_point = &(s->streams[pkt->stream_index]->last_in_packet_buffer->next);
2943     }else
2944         next_point = &s->packet_buffer;
2945
2946     if(*next_point){
2947         if(compare(s, &s->packet_buffer_end->pkt, pkt)){
2948             while(!compare(s, &(*next_point)->pkt, pkt)){
2949                 next_point= &(*next_point)->next;
2950             }
2951             goto next_non_null;
2952         }else{
2953             next_point = &(s->packet_buffer_end->next);
2954         }
2955     }
2956     assert(!*next_point);
2957
2958     s->packet_buffer_end= this_pktl;
2959 next_non_null:
2960
2961     this_pktl->next= *next_point;
2962
2963     s->streams[pkt->stream_index]->last_in_packet_buffer=
2964     *next_point= this_pktl;
2965 }
2966
2967 static int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
2968 {
2969     AVStream *st = s->streams[ pkt ->stream_index];
2970     AVStream *st2= s->streams[ next->stream_index];
2971     int comp = av_compare_ts(next->dts, st2->time_base, pkt->dts,
2972                              st->time_base);
2973
2974     if (comp == 0)
2975         return pkt->stream_index < next->stream_index;
2976     return comp > 0;
2977 }
2978
2979 int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2980     AVPacketList *pktl;
2981     int stream_count=0;
2982     int i;
2983
2984     if(pkt){
2985         ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
2986     }
2987
2988     for(i=0; i < s->nb_streams; i++)
2989         stream_count+= !!s->streams[i]->last_in_packet_buffer;
2990
2991     if(stream_count && (s->nb_streams == stream_count || flush)){
2992         pktl= s->packet_buffer;
2993         *out= pktl->pkt;
2994
2995         s->packet_buffer= pktl->next;
2996         if(!s->packet_buffer)
2997             s->packet_buffer_end= NULL;
2998
2999         if(s->streams[out->stream_index]->last_in_packet_buffer == pktl)
3000             s->streams[out->stream_index]->last_in_packet_buffer= NULL;
3001         av_freep(&pktl);
3002         return 1;
3003     }else{
3004         av_init_packet(out);
3005         return 0;
3006     }
3007 }
3008
3009 /**
3010  * Interleave an AVPacket correctly so it can be muxed.
3011  * @param out the interleaved packet will be output here
3012  * @param in the input packet
3013  * @param flush 1 if no further packets are available as input and all
3014  *              remaining packets should be output
3015  * @return 1 if a packet was output, 0 if no packet could be output,
3016  *         < 0 if an error occurred
3017  */
3018 static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
3019     if(s->oformat->interleave_packet)
3020         return s->oformat->interleave_packet(s, out, in, flush);
3021     else
3022         return av_interleave_packet_per_dts(s, out, in, flush);
3023 }
3024
3025 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
3026     AVStream *st= s->streams[ pkt->stream_index];
3027     int ret;
3028
3029     //FIXME/XXX/HACK drop zero sized packets
3030     if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO && pkt->size==0)
3031         return 0;
3032
3033     av_dlog(s, "av_interleaved_write_frame size:%d dts:%"PRId64" pts:%"PRId64"\n",
3034             pkt->size, pkt->dts, pkt->pts);
3035     if((ret = compute_pkt_fields2(s, st, pkt)) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3036         return ret;
3037
3038     if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3039         return AVERROR(EINVAL);
3040
3041     for(;;){
3042         AVPacket opkt;
3043         int ret= av_interleave_packet(s, &opkt, pkt, 0);
3044         if(ret<=0) //FIXME cleanup needed for ret<0 ?
3045             return ret;
3046
3047         ret= s->oformat->write_packet(s, &opkt);
3048
3049         av_free_packet(&opkt);
3050         pkt= NULL;
3051
3052         if(ret<0)
3053             return ret;
3054     }
3055 }
3056
3057 int av_write_trailer(AVFormatContext *s)
3058 {
3059     int ret, i;
3060
3061     for(;;){
3062         AVPacket pkt;
3063         ret= av_interleave_packet(s, &pkt, NULL, 1);
3064         if(ret<0) //FIXME cleanup needed for ret<0 ?
3065             goto fail;
3066         if(!ret)
3067             break;
3068
3069         ret= s->oformat->write_packet(s, &pkt);
3070
3071         av_free_packet(&pkt);
3072
3073         if(ret<0)
3074             goto fail;
3075     }
3076
3077     if(s->oformat->write_trailer)
3078         ret = s->oformat->write_trailer(s);
3079 fail:
3080     for(i=0;i<s->nb_streams;i++) {
3081         av_freep(&s->streams[i]->priv_data);
3082         av_freep(&s->streams[i]->index_entries);
3083     }
3084     if (s->iformat && s->iformat->priv_class)
3085         av_opt_free(s->priv_data);
3086     av_freep(&s->priv_data);
3087     return ret;
3088 }
3089
3090 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
3091 {
3092     int i, j;
3093     AVProgram *program=NULL;
3094     void *tmp;
3095
3096     if (idx >= ac->nb_streams) {
3097         av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3098         return;
3099     }
3100
3101     for(i=0; i<ac->nb_programs; i++){
3102         if(ac->programs[i]->id != progid)
3103             continue;
3104         program = ac->programs[i];
3105         for(j=0; j<program->nb_stream_indexes; j++)
3106             if(program->stream_index[j] == idx)
3107                 return;
3108
3109         tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
3110         if(!tmp)
3111             return;
3112         program->stream_index = tmp;
3113         program->stream_index[program->nb_stream_indexes++] = idx;
3114         return;
3115     }
3116 }
3117
3118 static void print_fps(double d, const char *postfix){
3119     uint64_t v= lrintf(d*100);
3120     if     (v% 100      ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3121     else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3122     else                  av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
3123 }
3124
3125 static void dump_metadata(void *ctx, AVDictionary *m, const char *indent)
3126 {
3127     if(m && !(m->count == 1 && av_dict_get(m, "language", NULL, 0))){
3128         AVDictionaryEntry *tag=NULL;
3129
3130         av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3131         while((tag=av_dict_get(m, "", tag, AV_DICT_IGNORE_SUFFIX))) {
3132             if(strcmp("language", tag->key))
3133                 av_log(ctx, AV_LOG_INFO, "%s  %-16s: %s\n", indent, tag->key, tag->value);
3134         }
3135     }
3136 }
3137
3138 /* "user interface" functions */
3139 static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
3140 {
3141     char buf[256];
3142     int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
3143     AVStream *st = ic->streams[i];
3144     int g = av_gcd(st->time_base.num, st->time_base.den);
3145     AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL, 0);
3146     avcodec_string(buf, sizeof(buf), st->codec, is_output);
3147     av_log(NULL, AV_LOG_INFO, "    Stream #%d.%d", index, i);
3148     /* the pid is an important information, so we display it */
3149     /* XXX: add a generic system */
3150     if (flags & AVFMT_SHOW_IDS)
3151         av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
3152     if (lang)
3153         av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
3154     av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames, st->time_base.num/g, st->time_base.den/g);
3155     av_log(NULL, AV_LOG_INFO, ": %s", buf);
3156     if (st->sample_aspect_ratio.num && // default
3157         av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
3158         AVRational display_aspect_ratio;
3159         av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
3160                   st->codec->width*st->sample_aspect_ratio.num,
3161                   st->codec->height*st->sample_aspect_ratio.den,
3162                   1024*1024);
3163         av_log(NULL, AV_LOG_INFO, ", PAR %d:%d DAR %d:%d",
3164                  st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3165                  display_aspect_ratio.num, display_aspect_ratio.den);
3166     }
3167     if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
3168         if(st->avg_frame_rate.den && st->avg_frame_rate.num)
3169             print_fps(av_q2d(st->avg_frame_rate), "fps");
3170         if(st->r_frame_rate.den && st->r_frame_rate.num)
3171             print_fps(av_q2d(st->r_frame_rate), "tbr");
3172         if(st->time_base.den && st->time_base.num)
3173             print_fps(1/av_q2d(st->time_base), "tbn");
3174         if(st->codec->time_base.den && st->codec->time_base.num)
3175             print_fps(1/av_q2d(st->codec->time_base), "tbc");
3176     }
3177     if (st->disposition & AV_DISPOSITION_DEFAULT)
3178         av_log(NULL, AV_LOG_INFO, " (default)");
3179     if (st->disposition & AV_DISPOSITION_DUB)
3180         av_log(NULL, AV_LOG_INFO, " (dub)");
3181     if (st->disposition & AV_DISPOSITION_ORIGINAL)
3182         av_log(NULL, AV_LOG_INFO, " (original)");
3183     if (st->disposition & AV_DISPOSITION_COMMENT)
3184         av_log(NULL, AV_LOG_INFO, " (comment)");
3185     if (st->disposition & AV_DISPOSITION_LYRICS)
3186         av_log(NULL, AV_LOG_INFO, " (lyrics)");
3187     if (st->disposition & AV_DISPOSITION_KARAOKE)
3188         av_log(NULL, AV_LOG_INFO, " (karaoke)");
3189     if (st->disposition & AV_DISPOSITION_FORCED)
3190         av_log(NULL, AV_LOG_INFO, " (forced)");
3191     if (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED)
3192         av_log(NULL, AV_LOG_INFO, " (hearing impaired)");
3193     if (st->disposition & AV_DISPOSITION_VISUAL_IMPAIRED)
3194         av_log(NULL, AV_LOG_INFO, " (visual impaired)");
3195     if (st->disposition & AV_DISPOSITION_CLEAN_EFFECTS)
3196         av_log(NULL, AV_LOG_INFO, " (clean effects)");
3197     av_log(NULL, AV_LOG_INFO, "\n");
3198     dump_metadata(NULL, st->metadata, "    ");
3199 }
3200
3201 #if FF_API_DUMP_FORMAT
3202 void dump_format(AVFormatContext *ic,
3203                  int index,
3204                  const char *url,
3205                  int is_output)
3206 {
3207     av_dump_format(ic, index, url, is_output);
3208 }
3209 #endif
3210
3211 void av_dump_format(AVFormatContext *ic,
3212                     int index,
3213                     const char *url,
3214                     int is_output)
3215 {
3216     int i;
3217     uint8_t *printed = av_mallocz(ic->nb_streams);
3218     if (ic->nb_streams && !printed)
3219         return;
3220
3221     av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3222             is_output ? "Output" : "Input",
3223             index,
3224             is_output ? ic->oformat->name : ic->iformat->name,
3225             is_output ? "to" : "from", url);
3226     dump_metadata(NULL, ic->metadata, "  ");
3227     if (!is_output) {
3228         av_log(NULL, AV_LOG_INFO, "  Duration: ");
3229         if (ic->duration != AV_NOPTS_VALUE) {
3230             int hours, mins, secs, us;
3231             secs = ic->duration / AV_TIME_BASE;
3232             us = ic->duration % AV_TIME_BASE;
3233             mins = secs / 60;
3234             secs %= 60;
3235             hours = mins / 60;
3236             mins %= 60;
3237             av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3238                    (100 * us) / AV_TIME_BASE);
3239         } else {
3240             av_log(NULL, AV_LOG_INFO, "N/A");
3241         }
3242         if (ic->start_time != AV_NOPTS_VALUE) {
3243             int secs, us;
3244             av_log(NULL, AV_LOG_INFO, ", start: ");
3245             secs = ic->start_time / AV_TIME_BASE;
3246             us = abs(ic->start_time % AV_TIME_BASE);
3247             av_log(NULL, AV_LOG_INFO, "%d.%06d",
3248                    secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
3249         }
3250         av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3251         if (ic->bit_rate) {
3252             av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
3253         } else {
3254             av_log(NULL, AV_LOG_INFO, "N/A");
3255         }
3256         av_log(NULL, AV_LOG_INFO, "\n");
3257     }
3258     for (i = 0; i < ic->nb_chapters; i++) {
3259         AVChapter *ch = ic->chapters[i];
3260         av_log(NULL, AV_LOG_INFO, "    Chapter #%d.%d: ", index, i);
3261         av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
3262         av_log(NULL, AV_LOG_INFO, "end %f\n",   ch->end   * av_q2d(ch->time_base));
3263
3264         dump_metadata(NULL, ch->metadata, "    ");
3265     }
3266     if(ic->nb_programs) {
3267         int j, k, total = 0;
3268         for(j=0; j<ic->nb_programs; j++) {
3269             AVDictionaryEntry *name = av_dict_get(ic->programs[j]->metadata,
3270                                                   "name", NULL, 0);
3271             av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
3272                    name ? name->value : "");
3273             dump_metadata(NULL, ic->programs[j]->metadata, "    ");
3274             for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3275                 dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3276                 printed[ic->programs[j]->stream_index[k]] = 1;
3277             }
3278             total += ic->programs[j]->nb_stream_indexes;
3279         }
3280         if (total < ic->nb_streams)
3281             av_log(NULL, AV_LOG_INFO, "  No Program\n");
3282     }
3283     for(i=0;i<ic->nb_streams;i++)
3284         if (!printed[i])
3285             dump_stream_format(ic, i, index, is_output);
3286
3287     av_free(printed);
3288 }
3289
3290 int64_t av_gettime(void)
3291 {
3292     struct timeval tv;
3293     gettimeofday(&tv,NULL);
3294     return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
3295 }
3296
3297 uint64_t ff_ntp_time(void)
3298 {
3299   return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3300 }
3301
3302 #if FF_API_PARSE_DATE
3303 #include "libavutil/parseutils.h"
3304
3305 int64_t parse_date(const char *timestr, int duration)
3306 {
3307     int64_t timeval;
3308     av_parse_time(&timeval, timestr, duration);
3309     return timeval;
3310 }
3311 #endif
3312
3313 #if FF_API_FIND_INFO_TAG
3314 #include "libavutil/parseutils.h"
3315
3316 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
3317 {
3318     return av_find_info_tag(arg, arg_size, tag1, info);
3319 }
3320 #endif
3321
3322 int av_get_frame_filename(char *buf, int buf_size,
3323                           const char *path, int number)
3324 {
3325     const char *p;
3326     char *q, buf1[20], c;
3327     int nd, len, percentd_found;
3328
3329     q = buf;
3330     p = path;
3331     percentd_found = 0;
3332     for(;;) {
3333         c = *p++;
3334         if (c == '\0')
3335             break;
3336         if (c == '%') {
3337             do {
3338                 nd = 0;
3339                 while (isdigit(*p)) {
3340                     nd = nd * 10 + *p++ - '0';
3341                 }
3342                 c = *p++;
3343             } while (isdigit(c));
3344
3345             switch(c) {
3346             case '%':
3347                 goto addchar;
3348             case 'd':
3349                 if (percentd_found)
3350                     goto fail;
3351                 percentd_found = 1;
3352                 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3353                 len = strlen(buf1);
3354                 if ((q - buf + len) > buf_size - 1)
3355                     goto fail;
3356                 memcpy(q, buf1, len);
3357                 q += len;
3358                 break;
3359             default:
3360                 goto fail;
3361             }
3362         } else {
3363         addchar:
3364             if ((q - buf) < buf_size - 1)
3365                 *q++ = c;
3366         }
3367     }
3368     if (!percentd_found)
3369         goto fail;
3370     *q = '\0';
3371     return 0;
3372  fail:
3373     *q = '\0';
3374     return -1;
3375 }
3376
3377 static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3378 {
3379     int len, i, j, c;
3380 #undef fprintf
3381 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3382
3383     for(i=0;i<size;i+=16) {
3384         len = size - i;
3385         if (len > 16)
3386             len = 16;
3387         PRINT("%08x ", i);
3388         for(j=0;j<16;j++) {
3389             if (j < len)
3390                 PRINT(" %02x", buf[i+j]);
3391             else
3392                 PRINT("   ");
3393         }
3394         PRINT(" ");
3395         for(j=0;j<len;j++) {
3396             c = buf[i+j];
3397             if (c < ' ' || c > '~')
3398                 c = '.';
3399             PRINT("%c", c);
3400         }
3401         PRINT("\n");
3402     }
3403 #undef PRINT
3404 }
3405
3406 void av_hex_dump(FILE *f, uint8_t *buf, int size)
3407 {
3408     hex_dump_internal(NULL, f, 0, buf, size);
3409 }
3410
3411 void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3412 {
3413     hex_dump_internal(avcl, NULL, level, buf, size);
3414 }
3415
3416 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload, AVRational time_base)
3417 {
3418 #undef fprintf
3419 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3420     PRINT("stream #%d:\n", pkt->stream_index);
3421     PRINT("  keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
3422     PRINT("  duration=%0.3f\n", pkt->duration * av_q2d(time_base));
3423     /* DTS is _always_ valid after av_read_frame() */
3424     PRINT("  dts=");
3425     if (pkt->dts == AV_NOPTS_VALUE)
3426         PRINT("N/A");
3427     else
3428         PRINT("%0.3f", pkt->dts * av_q2d(time_base));
3429     /* PTS may not be known if B-frames are present. */
3430     PRINT("  pts=");
3431     if (pkt->pts == AV_NOPTS_VALUE)
3432         PRINT("N/A");
3433     else
3434         PRINT("%0.3f", pkt->pts * av_q2d(time_base));
3435     PRINT("\n");
3436     PRINT("  size=%d\n", pkt->size);
3437 #undef PRINT
3438     if (dump_payload)
3439         av_hex_dump(f, pkt->data, pkt->size);
3440 }
3441
3442 #if FF_API_PKT_DUMP
3443 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3444 {
3445     AVRational tb = { 1, AV_TIME_BASE };
3446     pkt_dump_internal(NULL, f, 0, pkt, dump_payload, tb);
3447 }
3448 #endif
3449
3450 void av_pkt_dump2(FILE *f, AVPacket *pkt, int dump_payload, AVStream *st)
3451 {
3452     pkt_dump_internal(NULL, f, 0, pkt, dump_payload, st->time_base);
3453 }
3454
3455 #if FF_API_PKT_DUMP
3456 void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3457 {
3458     AVRational tb = { 1, AV_TIME_BASE };
3459     pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, tb);
3460 }
3461 #endif
3462
3463 void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload,
3464                       AVStream *st)
3465 {
3466     pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, st->time_base);
3467 }
3468
3469 void av_url_split(char *proto, int proto_size,
3470                   char *authorization, int authorization_size,
3471                   char *hostname, int hostname_size,
3472                   int *port_ptr,
3473                   char *path, int path_size,
3474                   const char *url)
3475 {
3476     const char *p, *ls, *at, *col, *brk;
3477
3478     if (port_ptr)               *port_ptr = -1;
3479     if (proto_size > 0)         proto[0] = 0;
3480     if (authorization_size > 0) authorization[0] = 0;
3481     if (hostname_size > 0)      hostname[0] = 0;
3482     if (path_size > 0)          path[0] = 0;
3483
3484     /* parse protocol */
3485     if ((p = strchr(url, ':'))) {
3486         av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3487         p++; /* skip ':' */
3488         if (*p == '/') p++;
3489         if (*p == '/') p++;
3490     } else {
3491         /* no protocol means plain filename */
3492         av_strlcpy(path, url, path_size);
3493         return;
3494     }
3495
3496     /* separate path from hostname */
3497     ls = strchr(p, '/');
3498     if(!ls)
3499         ls = strchr(p, '?');
3500     if(ls)
3501         av_strlcpy(path, ls, path_size);
3502     else
3503         ls = &p[strlen(p)]; // XXX
3504
3505     /* the rest is hostname, use that to parse auth/port */
3506     if (ls != p) {
3507         /* authorization (user[:pass]@hostname) */
3508         if ((at = strchr(p, '@')) && at < ls) {
3509             av_strlcpy(authorization, p,
3510                        FFMIN(authorization_size, at + 1 - p));
3511             p = at + 1; /* skip '@' */
3512         }
3513
3514         if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3515             /* [host]:port */
3516             av_strlcpy(hostname, p + 1,
3517                        FFMIN(hostname_size, brk - p));
3518             if (brk[1] == ':' && port_ptr)
3519                 *port_ptr = atoi(brk + 2);
3520         } else if ((col = strchr(p, ':')) && col < ls) {
3521             av_strlcpy(hostname, p,
3522                        FFMIN(col + 1 - p, hostname_size));
3523             if (port_ptr) *port_ptr = atoi(col + 1);
3524         } else
3525             av_strlcpy(hostname, p,
3526                        FFMIN(ls + 1 - p, hostname_size));
3527     }
3528 }
3529
3530 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3531 {
3532     int i;
3533     static const char hex_table_uc[16] = { '0', '1', '2', '3',
3534                                            '4', '5', '6', '7',
3535                                            '8', '9', 'A', 'B',
3536                                            'C', 'D', 'E', 'F' };
3537     static const char hex_table_lc[16] = { '0', '1', '2', '3',
3538                                            '4', '5', '6', '7',
3539                                            '8', '9', 'a', 'b',
3540                                            'c', 'd', 'e', 'f' };
3541     const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3542
3543     for(i = 0; i < s; i++) {
3544         buff[i * 2]     = hex_table[src[i] >> 4];
3545         buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3546     }
3547
3548     return buff;
3549 }
3550
3551 int ff_hex_to_data(uint8_t *data, const char *p)
3552 {
3553     int c, len, v;
3554
3555     len = 0;
3556     v = 1;
3557     for (;;) {
3558         p += strspn(p, SPACE_CHARS);
3559         if (*p == '\0')
3560             break;
3561         c = toupper((unsigned char) *p++);
3562         if (c >= '0' && c <= '9')
3563             c = c - '0';
3564         else if (c >= 'A' && c <= 'F')
3565             c = c - 'A' + 10;
3566         else
3567             break;
3568         v = (v << 4) | c;
3569         if (v & 0x100) {
3570             if (data)
3571                 data[len] = v;
3572             len++;
3573             v = 1;
3574         }
3575     }
3576     return len;
3577 }
3578
3579 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3580                      unsigned int pts_num, unsigned int pts_den)
3581 {
3582     AVRational new_tb;
3583     if(av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)){
3584         if(new_tb.num != pts_num)
3585             av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/new_tb.num);
3586     }else
3587         av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3588
3589     if(new_tb.num <= 0 || new_tb.den <= 0) {
3590         av_log(NULL, AV_LOG_ERROR, "Ignoring attempt to set invalid timebase for st:%d\n", s->index);
3591         return;
3592     }
3593     s->time_base = new_tb;
3594     s->pts_wrap_bits = pts_wrap_bits;
3595 }
3596
3597 int ff_url_join(char *str, int size, const char *proto,
3598                 const char *authorization, const char *hostname,
3599                 int port, const char *fmt, ...)
3600 {
3601 #if CONFIG_NETWORK
3602     struct addrinfo hints, *ai;
3603 #endif
3604
3605     str[0] = '\0';
3606     if (proto)
3607         av_strlcatf(str, size, "%s://", proto);
3608     if (authorization && authorization[0])
3609         av_strlcatf(str, size, "%s@", authorization);
3610 #if CONFIG_NETWORK && defined(AF_INET6)
3611     /* Determine if hostname is a numerical IPv6 address,
3612      * properly escape it within [] in that case. */
3613     memset(&hints, 0, sizeof(hints));
3614     hints.ai_flags = AI_NUMERICHOST;
3615     if (!getaddrinfo(hostname, NULL, &hints, &ai)) {
3616         if (ai->ai_family == AF_INET6) {
3617             av_strlcat(str, "[", size);
3618             av_strlcat(str, hostname, size);
3619             av_strlcat(str, "]", size);
3620         } else {
3621             av_strlcat(str, hostname, size);
3622         }
3623         freeaddrinfo(ai);
3624     } else
3625 #endif
3626         /* Not an IPv6 address, just output the plain string. */
3627         av_strlcat(str, hostname, size);
3628
3629     if (port >= 0)
3630         av_strlcatf(str, size, ":%d", port);
3631     if (fmt) {
3632         va_list vl;
3633         int len = strlen(str);
3634
3635         va_start(vl, fmt);
3636         vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);
3637         va_end(vl);
3638     }
3639     return strlen(str);
3640 }
3641
3642 int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
3643                      AVFormatContext *src)
3644 {
3645     AVPacket local_pkt;
3646
3647     local_pkt = *pkt;
3648     local_pkt.stream_index = dst_stream;
3649     if (pkt->pts != AV_NOPTS_VALUE)
3650         local_pkt.pts = av_rescale_q(pkt->pts,
3651                                      src->streams[pkt->stream_index]->time_base,
3652                                      dst->streams[dst_stream]->time_base);
3653     if (pkt->dts != AV_NOPTS_VALUE)
3654         local_pkt.dts = av_rescale_q(pkt->dts,
3655                                      src->streams[pkt->stream_index]->time_base,
3656                                      dst->streams[dst_stream]->time_base);
3657     return av_write_frame(dst, &local_pkt);
3658 }
3659
3660 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
3661                         void *context)
3662 {
3663     const char *ptr = str;
3664
3665     /* Parse key=value pairs. */
3666     for (;;) {
3667         const char *key;
3668         char *dest = NULL, *dest_end;
3669         int key_len, dest_len = 0;
3670
3671         /* Skip whitespace and potential commas. */
3672         while (*ptr && (isspace(*ptr) || *ptr == ','))
3673             ptr++;
3674         if (!*ptr)
3675             break;
3676
3677         key = ptr;
3678
3679         if (!(ptr = strchr(key, '=')))
3680             break;
3681         ptr++;
3682         key_len = ptr - key;
3683
3684         callback_get_buf(context, key, key_len, &dest, &dest_len);
3685         dest_end = dest + dest_len - 1;
3686
3687         if (*ptr == '\"') {
3688             ptr++;
3689             while (*ptr && *ptr != '\"') {
3690                 if (*ptr == '\\') {
3691                     if (!ptr[1])
3692                         break;
3693                     if (dest && dest < dest_end)
3694                         *dest++ = ptr[1];
3695                     ptr += 2;
3696                 } else {
3697                     if (dest && dest < dest_end)
3698                         *dest++ = *ptr;
3699                     ptr++;
3700                 }
3701             }
3702             if (*ptr == '\"')
3703                 ptr++;
3704         } else {
3705             for (; *ptr && !(isspace(*ptr) || *ptr == ','); ptr++)
3706                 if (dest && dest < dest_end)
3707                     *dest++ = *ptr;
3708         }
3709         if (dest)
3710             *dest = 0;
3711     }
3712 }
3713
3714 int ff_find_stream_index(AVFormatContext *s, int id)
3715 {
3716     int i;
3717     for (i = 0; i < s->nb_streams; i++) {
3718         if (s->streams[i]->id == id)
3719             return i;
3720     }
3721     return -1;
3722 }
3723
3724 void ff_make_absolute_url(char *buf, int size, const char *base,
3725                           const char *rel)
3726 {
3727     char *sep;
3728     /* Absolute path, relative to the current server */
3729     if (base && strstr(base, "://") && rel[0] == '/') {
3730         if (base != buf)
3731             av_strlcpy(buf, base, size);
3732         sep = strstr(buf, "://");
3733         if (sep) {
3734             sep += 3;
3735             sep = strchr(sep, '/');
3736             if (sep)
3737                 *sep = '\0';
3738         }
3739         av_strlcat(buf, rel, size);
3740         return;
3741     }
3742     /* If rel actually is an absolute url, just copy it */
3743     if (!base || strstr(rel, "://") || rel[0] == '/') {
3744         av_strlcpy(buf, rel, size);
3745         return;
3746     }
3747     if (base != buf)
3748         av_strlcpy(buf, base, size);
3749     /* Remove the file name from the base url */
3750     sep = strrchr(buf, '/');
3751     if (sep)
3752         sep[1] = '\0';
3753     else
3754         buf[0] = '\0';
3755     while (av_strstart(rel, "../", NULL) && sep) {
3756         /* Remove the path delimiter at the end */
3757         sep[0] = '\0';
3758         sep = strrchr(buf, '/');
3759         /* If the next directory name to pop off is "..", break here */
3760         if (!strcmp(sep ? &sep[1] : buf, "..")) {
3761             /* Readd the slash we just removed */
3762             av_strlcat(buf, "/", size);
3763             break;
3764         }
3765         /* Cut off the directory name */
3766         if (sep)
3767             sep[1] = '\0';
3768         else
3769             buf[0] = '\0';
3770         rel += 3;
3771     }
3772     av_strlcat(buf, rel, size);
3773 }