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

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