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