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             if (ic->fps_probe_size >= 0)
2276                 fps_analyze_framecount = ic->fps_probe_size;
2277             /* variable fps and no guess at the real fps */
2278             if(   tb_unreliable(st->codec) && !(st->r_frame_rate.num && st->avg_frame_rate.num)
2279                && st->info->duration_count < fps_analyze_framecount
2280                && st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2281                 break;
2282             if(st->parser && st->parser->parser->split && !st->codec->extradata)
2283                 break;
2284             if(st->first_dts == AV_NOPTS_VALUE)
2285                 break;
2286         }
2287         if (i == ic->nb_streams) {
2288             /* NOTE: if the format has no header, then we need to read
2289                some packets to get most of the streams, so we cannot
2290                stop here */
2291             if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2292                 /* if we found the info for all the codecs, we can stop */
2293                 ret = count;
2294                 av_log(ic, AV_LOG_DEBUG, "All info found\n");
2295                 break;
2296             }
2297         }
2298         /* we did not get all the codec info, but we read too much data */
2299         if (read_size >= ic->probesize) {
2300             ret = count;
2301             av_log(ic, AV_LOG_DEBUG, "Probe buffer size limit %d reached\n", ic->probesize);
2302             break;
2303         }
2304
2305         /* NOTE: a new stream can be added there if no header in file
2306            (AVFMTCTX_NOHEADER) */
2307         ret = av_read_frame_internal(ic, &pkt1);
2308         if (ret < 0 && ret != AVERROR(EAGAIN)) {
2309             /* EOF or error */
2310             ret = -1; /* we could not have all the codec parameters before EOF */
2311             for(i=0;i<ic->nb_streams;i++) {
2312                 st = ic->streams[i];
2313                 if (!has_codec_parameters(st->codec)){
2314                     char buf[256];
2315                     avcodec_string(buf, sizeof(buf), st->codec, 0);
2316                     av_log(ic, AV_LOG_WARNING, "Could not find codec parameters (%s)\n", buf);
2317                 } else {
2318                     ret = 0;
2319                 }
2320             }
2321             break;
2322         }
2323
2324         if (ret == AVERROR(EAGAIN))
2325             continue;
2326
2327         pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2328         if ((ret = av_dup_packet(pkt)) < 0)
2329             goto find_stream_info_err;
2330
2331         read_size += pkt->size;
2332
2333         st = ic->streams[pkt->stream_index];
2334         if (st->codec_info_nb_frames>1) {
2335             int64_t t;
2336             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) {
2337                 av_log(ic, AV_LOG_WARNING, "max_analyze_duration %d reached at %Ld\n", ic->max_analyze_duration, t);
2338                 break;
2339             }
2340             st->info->codec_info_duration += pkt->duration;
2341         }
2342         {
2343             int64_t last = st->info->last_dts;
2344             int64_t duration= pkt->dts - last;
2345
2346             if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
2347                 double dur= duration * av_q2d(st->time_base);
2348
2349 //                if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2350 //                    av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
2351                 if (st->info->duration_count < 2)
2352                     memset(st->info->duration_error, 0, sizeof(st->info->duration_error));
2353                 for (i=1; i<FF_ARRAY_ELEMS(st->info->duration_error); i++) {
2354                     int framerate= get_std_framerate(i);
2355                     int ticks= lrintf(dur*framerate/(1001*12));
2356                     double error= dur - ticks*1001*12/(double)framerate;
2357                     st->info->duration_error[i] += error*error;
2358                 }
2359                 st->info->duration_count++;
2360                 // ignore the first 4 values, they might have some random jitter
2361                 if (st->info->duration_count > 3)
2362                     st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2363             }
2364             if (last == AV_NOPTS_VALUE || st->info->duration_count <= 1)
2365                 st->info->last_dts = pkt->dts;
2366         }
2367         if(st->parser && st->parser->parser->split && !st->codec->extradata){
2368             int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2369             if(i){
2370                 st->codec->extradata_size= i;
2371                 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2372                 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2373                 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2374             }
2375         }
2376
2377         /* if still no information, we try to open the codec and to
2378            decompress the frame. We try to avoid that in most cases as
2379            it takes longer and uses more memory. For MPEG-4, we need to
2380            decompress for QuickTime. */
2381         if (!has_codec_parameters(st->codec) || !has_decode_delay_been_guessed(st))
2382             try_decode_frame(st, pkt);
2383
2384         st->codec_info_nb_frames++;
2385         count++;
2386     }
2387
2388     // close codecs which were opened in try_decode_frame()
2389     for(i=0;i<ic->nb_streams;i++) {
2390         st = ic->streams[i];
2391         if(st->codec->codec)
2392             avcodec_close(st->codec);
2393     }
2394     for(i=0;i<ic->nb_streams;i++) {
2395         st = ic->streams[i];
2396         if (st->codec_info_nb_frames>2 && !st->avg_frame_rate.num && st->info->codec_info_duration)
2397             av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2398                      (st->codec_info_nb_frames-2)*(int64_t)st->time_base.den,
2399                       st->info->codec_info_duration*(int64_t)st->time_base.num, 60000);
2400         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2401             if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample){
2402                 uint32_t tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2403                 if(ff_find_pix_fmt(ff_raw_pix_fmt_tags, tag) == st->codec->pix_fmt)
2404                     st->codec->codec_tag= tag;
2405             }
2406
2407             // the check for tb_unreliable() is not completely correct, since this is not about handling
2408             // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2409             // ipmovie.c produces.
2410             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)
2411                 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);
2412             if (st->info->duration_count && !st->r_frame_rate.num
2413                && tb_unreliable(st->codec) /*&&
2414                //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2415                st->time_base.num*duration_sum[i]/st->info->duration_count*101LL > st->time_base.den*/){
2416                 int num = 0;
2417                 double best_error= 2*av_q2d(st->time_base);
2418                 best_error = best_error*best_error*st->info->duration_count*1000*12*30;
2419
2420                 for (j=1; j<FF_ARRAY_ELEMS(st->info->duration_error); j++) {
2421                     double error = st->info->duration_error[j] * get_std_framerate(j);
2422 //                    if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2423 //                        av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
2424                     if(error < best_error){
2425                         best_error= error;
2426                         num = get_std_framerate(j);
2427                     }
2428                 }
2429                 // do not increase frame rate by more than 1 % in order to match a standard rate.
2430                 if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
2431                     av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2432             }
2433
2434             if (!st->r_frame_rate.num){
2435                 if(    st->codec->time_base.den * (int64_t)st->time_base.num
2436                     <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
2437                     st->r_frame_rate.num = st->codec->time_base.den;
2438                     st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
2439                 }else{
2440                     st->r_frame_rate.num = st->time_base.den;
2441                     st->r_frame_rate.den = st->time_base.num;
2442                 }
2443             }
2444         }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2445             if(!st->codec->bits_per_coded_sample)
2446                 st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2447             // set stream disposition based on audio service type
2448             switch (st->codec->audio_service_type) {
2449             case AV_AUDIO_SERVICE_TYPE_EFFECTS:
2450                 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;    break;
2451             case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
2452                 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;  break;
2453             case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
2454                 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED; break;
2455             case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
2456                 st->disposition = AV_DISPOSITION_COMMENT;          break;
2457             case AV_AUDIO_SERVICE_TYPE_KARAOKE:
2458                 st->disposition = AV_DISPOSITION_KARAOKE;          break;
2459             }
2460         }
2461     }
2462
2463     av_estimate_timings(ic, old_offset);
2464
2465     compute_chapters_end(ic);
2466
2467 #if 0
2468     /* correct DTS for B-frame streams with no timestamps */
2469     for(i=0;i<ic->nb_streams;i++) {
2470         st = ic->streams[i];
2471         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2472             if(b-frames){
2473                 ppktl = &ic->packet_buffer;
2474                 while(ppkt1){
2475                     if(ppkt1->stream_index != i)
2476                         continue;
2477                     if(ppkt1->pkt->dts < 0)
2478                         break;
2479                     if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2480                         break;
2481                     ppkt1->pkt->dts -= delta;
2482                     ppkt1= ppkt1->next;
2483                 }
2484                 if(ppkt1)
2485                     continue;
2486                 st->cur_dts -= delta;
2487             }
2488         }
2489     }
2490 #endif
2491
2492  find_stream_info_err:
2493     for (i=0; i < ic->nb_streams; i++)
2494         av_freep(&ic->streams[i]->info);
2495     return ret;
2496 }
2497
2498 static AVProgram *find_program_from_stream(AVFormatContext *ic, int s)
2499 {
2500     int i, j;
2501
2502     for (i = 0; i < ic->nb_programs; i++)
2503         for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
2504             if (ic->programs[i]->stream_index[j] == s)
2505                 return ic->programs[i];
2506     return NULL;
2507 }
2508
2509 int av_find_best_stream(AVFormatContext *ic,
2510                         enum AVMediaType type,
2511                         int wanted_stream_nb,
2512                         int related_stream,
2513                         AVCodec **decoder_ret,
2514                         int flags)
2515 {
2516     int i, nb_streams = ic->nb_streams;
2517     int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1;
2518     unsigned *program = NULL;
2519     AVCodec *decoder = NULL, *best_decoder = NULL;
2520
2521     if (related_stream >= 0 && wanted_stream_nb < 0) {
2522         AVProgram *p = find_program_from_stream(ic, related_stream);
2523         if (p) {
2524             program = p->stream_index;
2525             nb_streams = p->nb_stream_indexes;
2526         }
2527     }
2528     for (i = 0; i < nb_streams; i++) {
2529         int real_stream_index = program ? program[i] : i;
2530         AVStream *st = ic->streams[real_stream_index];
2531         AVCodecContext *avctx = st->codec;
2532         if (avctx->codec_type != type)
2533             continue;
2534         if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
2535             continue;
2536         if (st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED|AV_DISPOSITION_VISUAL_IMPAIRED))
2537             continue;
2538         if (decoder_ret) {
2539             decoder = avcodec_find_decoder(st->codec->codec_id);
2540             if (!decoder) {
2541                 if (ret < 0)
2542                     ret = AVERROR_DECODER_NOT_FOUND;
2543                 continue;
2544             }
2545         }
2546         if (best_count >= st->codec_info_nb_frames)
2547             continue;
2548         best_count = st->codec_info_nb_frames;
2549         ret = real_stream_index;
2550         best_decoder = decoder;
2551         if (program && i == nb_streams - 1 && ret < 0) {
2552             program = NULL;
2553             nb_streams = ic->nb_streams;
2554             i = 0; /* no related stream found, try again with everything */
2555         }
2556     }
2557     if (decoder_ret)
2558         *decoder_ret = best_decoder;
2559     return ret;
2560 }
2561
2562 /*******************************************************/
2563
2564 int av_read_play(AVFormatContext *s)
2565 {
2566     if (s->iformat->read_play)
2567         return s->iformat->read_play(s);
2568     if (s->pb)
2569         return avio_pause(s->pb, 0);
2570     return AVERROR(ENOSYS);
2571 }
2572
2573 int av_read_pause(AVFormatContext *s)
2574 {
2575     if (s->iformat->read_pause)
2576         return s->iformat->read_pause(s);
2577     if (s->pb)
2578         return avio_pause(s->pb, 1);
2579     return AVERROR(ENOSYS);
2580 }
2581
2582 void av_close_input_stream(AVFormatContext *s)
2583 {
2584     flush_packet_queue(s);
2585     if (s->iformat->read_close)
2586         s->iformat->read_close(s);
2587     avformat_free_context(s);
2588 }
2589
2590 void avformat_free_context(AVFormatContext *s)
2591 {
2592     int i;
2593     AVStream *st;
2594
2595     for(i=0;i<s->nb_streams;i++) {
2596         /* free all data in a stream component */
2597         st = s->streams[i];
2598         if (st->parser) {
2599             av_parser_close(st->parser);
2600             av_free_packet(&st->cur_pkt);
2601         }
2602         av_metadata_free(&st->metadata);
2603         av_free(st->index_entries);
2604         av_free(st->codec->extradata);
2605         av_free(st->codec->subtitle_header);
2606         av_free(st->codec);
2607         av_free(st->priv_data);
2608         av_free(st->info);
2609         av_free(st);
2610     }
2611     for(i=s->nb_programs-1; i>=0; i--) {
2612         av_metadata_free(&s->programs[i]->metadata);
2613         av_freep(&s->programs[i]->stream_index);
2614         av_freep(&s->programs[i]);
2615     }
2616     av_freep(&s->programs);
2617     av_freep(&s->priv_data);
2618     while(s->nb_chapters--) {
2619         av_metadata_free(&s->chapters[s->nb_chapters]->metadata);
2620         av_free(s->chapters[s->nb_chapters]);
2621     }
2622     av_freep(&s->chapters);
2623     av_metadata_free(&s->metadata);
2624     av_freep(&s->key);
2625     av_freep(&s->streams);
2626     av_free(s);
2627 }
2628
2629 void av_close_input_file(AVFormatContext *s)
2630 {
2631     AVIOContext *pb = s->iformat->flags & AVFMT_NOFILE ? NULL : s->pb;
2632     av_close_input_stream(s);
2633     if (pb)
2634         avio_close(pb);
2635 }
2636
2637 AVStream *av_new_stream(AVFormatContext *s, int id)
2638 {
2639     AVStream *st;
2640     int i;
2641     AVStream **streams;
2642
2643     if (s->nb_streams >= INT_MAX/sizeof(*streams))
2644         return NULL;
2645     streams = av_realloc(s->streams, (s->nb_streams + 1) * sizeof(*streams));
2646     if (!streams)
2647         return NULL;
2648     s->streams = streams;
2649
2650     st = av_mallocz(sizeof(AVStream));
2651     if (!st)
2652         return NULL;
2653     if (!(st->info = av_mallocz(sizeof(*st->info)))) {
2654         av_free(st);
2655         return NULL;
2656     }
2657
2658     st->codec= avcodec_alloc_context();
2659     if (s->iformat) {
2660         /* no default bitrate if decoding */
2661         st->codec->bit_rate = 0;
2662     }
2663     st->index = s->nb_streams;
2664     st->id = id;
2665     st->start_time = AV_NOPTS_VALUE;
2666     st->duration = AV_NOPTS_VALUE;
2667         /* we set the current DTS to 0 so that formats without any timestamps
2668            but durations get some timestamps, formats with some unknown
2669            timestamps have their first few packets buffered and the
2670            timestamps corrected before they are returned to the user */
2671     st->cur_dts = 0;
2672     st->first_dts = AV_NOPTS_VALUE;
2673     st->probe_packets = MAX_PROBE_PACKETS;
2674
2675     /* default pts setting is MPEG-like */
2676     av_set_pts_info(st, 33, 1, 90000);
2677     st->last_IP_pts = AV_NOPTS_VALUE;
2678     for(i=0; i<MAX_REORDER_DELAY+1; i++)
2679         st->pts_buffer[i]= AV_NOPTS_VALUE;
2680     st->reference_dts = AV_NOPTS_VALUE;
2681
2682     st->sample_aspect_ratio = (AVRational){0,1};
2683
2684     s->streams[s->nb_streams++] = st;
2685     return st;
2686 }
2687
2688 AVProgram *av_new_program(AVFormatContext *ac, int id)
2689 {
2690     AVProgram *program=NULL;
2691     int i;
2692
2693 #ifdef DEBUG_SI
2694     av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2695 #endif
2696
2697     for(i=0; i<ac->nb_programs; i++)
2698         if(ac->programs[i]->id == id)
2699             program = ac->programs[i];
2700
2701     if(!program){
2702         program = av_mallocz(sizeof(AVProgram));
2703         if (!program)
2704             return NULL;
2705         dynarray_add(&ac->programs, &ac->nb_programs, program);
2706         program->discard = AVDISCARD_NONE;
2707     }
2708     program->id = id;
2709
2710     return program;
2711 }
2712
2713 AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2714 {
2715     AVChapter *chapter = NULL;
2716     int i;
2717
2718     for(i=0; i<s->nb_chapters; i++)
2719         if(s->chapters[i]->id == id)
2720             chapter = s->chapters[i];
2721
2722     if(!chapter){
2723         chapter= av_mallocz(sizeof(AVChapter));
2724         if(!chapter)
2725             return NULL;
2726         dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2727     }
2728     av_metadata_set2(&chapter->metadata, "title", title, 0);
2729     chapter->id    = id;
2730     chapter->time_base= time_base;
2731     chapter->start = start;
2732     chapter->end   = end;
2733
2734     return chapter;
2735 }
2736
2737 /************************************************************/
2738 /* output media file */
2739
2740 int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2741 {
2742     if (s->oformat->priv_data_size > 0) {
2743         s->priv_data = av_mallocz(s->oformat->priv_data_size);
2744         if (!s->priv_data)
2745             return AVERROR(ENOMEM);
2746         if (s->oformat->priv_class) {
2747             *(const AVClass**)s->priv_data= s->oformat->priv_class;
2748             av_opt_set_defaults(s->priv_data);
2749         }
2750     } else
2751         s->priv_data = NULL;
2752
2753     return 0;
2754 }
2755
2756 int avformat_alloc_output_context2(AVFormatContext **avctx, AVOutputFormat *oformat,
2757                                    const char *format, const char *filename)
2758 {
2759     AVFormatContext *s = avformat_alloc_context();
2760     int ret = 0;
2761
2762     *avctx = NULL;
2763     if (!s)
2764         goto nomem;
2765
2766     if (!oformat) {
2767         if (format) {
2768             oformat = av_guess_format(format, NULL, NULL);
2769             if (!oformat) {
2770                 av_log(s, AV_LOG_ERROR, "Requested output format '%s' is not a suitable output format\n", format);
2771                 ret = AVERROR(EINVAL);
2772                 goto error;
2773             }
2774         } else {
2775             oformat = av_guess_format(NULL, filename, NULL);
2776             if (!oformat) {
2777                 ret = AVERROR(EINVAL);
2778                 av_log(s, AV_LOG_ERROR, "Unable to find a suitable output format for '%s'\n",
2779                        filename);
2780                 goto error;
2781             }
2782         }
2783     }
2784
2785     s->oformat = oformat;
2786     if (s->oformat->priv_data_size > 0) {
2787         s->priv_data = av_mallocz(s->oformat->priv_data_size);
2788         if (!s->priv_data)
2789             goto nomem;
2790         if (s->oformat->priv_class) {
2791             *(const AVClass**)s->priv_data= s->oformat->priv_class;
2792             av_opt_set_defaults(s->priv_data);
2793         }
2794     } else
2795         s->priv_data = NULL;
2796
2797     if (filename)
2798         av_strlcpy(s->filename, filename, sizeof(s->filename));
2799     *avctx = s;
2800     return 0;
2801 nomem:
2802     av_log(s, AV_LOG_ERROR, "Out of memory\n");
2803     ret = AVERROR(ENOMEM);
2804 error:
2805     avformat_free_context(s);
2806     return ret;
2807 }
2808
2809 #if FF_API_ALLOC_OUTPUT_CONTEXT
2810 AVFormatContext *avformat_alloc_output_context(const char *format,
2811                                                AVOutputFormat *oformat, const char *filename)
2812 {
2813     AVFormatContext *avctx;
2814     int ret = avformat_alloc_output_context2(&avctx, oformat, format, filename);
2815     return ret < 0 ? NULL : avctx;
2816 }
2817 #endif
2818
2819 static int validate_codec_tag(AVFormatContext *s, AVStream *st)
2820 {
2821     const AVCodecTag *avctag;
2822     int n;
2823     enum CodecID id = CODEC_ID_NONE;
2824     unsigned int tag = 0;
2825
2826     /**
2827      * Check that tag + id is in the table
2828      * If neither is in the table -> OK
2829      * If tag is in the table with another id -> FAIL
2830      * If id is in the table with another tag -> FAIL unless strict < normal
2831      */
2832     for (n = 0; s->oformat->codec_tag[n]; n++) {
2833         avctag = s->oformat->codec_tag[n];
2834         while (avctag->id != CODEC_ID_NONE) {
2835             if (ff_toupper4(avctag->tag) == ff_toupper4(st->codec->codec_tag)) {
2836                 id = avctag->id;
2837                 if (id == st->codec->codec_id)
2838                     return 1;
2839             }
2840             if (avctag->id == st->codec->codec_id)
2841                 tag = avctag->tag;
2842             avctag++;
2843         }
2844     }
2845     if (id != CODEC_ID_NONE)
2846         return 0;
2847     if (tag && (st->codec->strict_std_compliance >= FF_COMPLIANCE_NORMAL))
2848         return 0;
2849     return 1;
2850 }
2851
2852 int av_write_header(AVFormatContext *s)
2853 {
2854     int ret, i;
2855     AVStream *st;
2856
2857     // some sanity checks
2858     if (s->nb_streams == 0 && !(s->oformat->flags & AVFMT_NOSTREAMS)) {
2859         av_log(s, AV_LOG_ERROR, "no streams\n");
2860         return AVERROR(EINVAL);
2861     }
2862
2863     for(i=0;i<s->nb_streams;i++) {
2864         st = s->streams[i];
2865
2866         switch (st->codec->codec_type) {
2867         case AVMEDIA_TYPE_AUDIO:
2868             if(st->codec->sample_rate<=0){
2869                 av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2870                 return AVERROR(EINVAL);
2871             }
2872             if(!st->codec->block_align)
2873                 st->codec->block_align = st->codec->channels *
2874                     av_get_bits_per_sample(st->codec->codec_id) >> 3;
2875             break;
2876         case AVMEDIA_TYPE_VIDEO:
2877             if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2878                 av_log(s, AV_LOG_ERROR, "time base not set\n");
2879                 return AVERROR(EINVAL);
2880             }
2881             if((st->codec->width<=0 || st->codec->height<=0) && !(s->oformat->flags & AVFMT_NODIMENSIONS)){
2882                 av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2883                 return AVERROR(EINVAL);
2884             }
2885             if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)){
2886                 av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between encoder and muxer layer\n");
2887                 return AVERROR(EINVAL);
2888             }
2889             break;
2890         }
2891
2892         if(s->oformat->codec_tag){
2893             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)){
2894                 //the current rawvideo encoding system ends up setting the wrong codec_tag for avi, we override it here
2895                 st->codec->codec_tag= 0;
2896             }
2897             if(st->codec->codec_tag){
2898                 if (!validate_codec_tag(s, st)) {
2899                     char tagbuf[32];
2900                     av_get_codec_tag_string(tagbuf, sizeof(tagbuf), st->codec->codec_tag);
2901                     av_log(s, AV_LOG_ERROR,
2902                            "Tag %s/0x%08x incompatible with output codec id '%d'\n",
2903                            tagbuf, st->codec->codec_tag, st->codec->codec_id);
2904                     return AVERROR_INVALIDDATA;
2905                 }
2906             }else
2907                 st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2908         }
2909
2910         if(s->oformat->flags & AVFMT_GLOBALHEADER &&
2911             !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
2912           av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
2913     }
2914
2915     if (!s->priv_data && s->oformat->priv_data_size > 0) {
2916         s->priv_data = av_mallocz(s->oformat->priv_data_size);
2917         if (!s->priv_data)
2918             return AVERROR(ENOMEM);
2919     }
2920
2921     /* set muxer identification string */
2922     if (s->nb_streams && !(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
2923         av_metadata_set2(&s->metadata, "encoder", LIBAVFORMAT_IDENT, 0);
2924     }
2925
2926     if(s->oformat->write_header){
2927         ret = s->oformat->write_header(s);
2928         if (ret < 0)
2929             return ret;
2930     }
2931
2932     /* init PTS generation */
2933     for(i=0;i<s->nb_streams;i++) {
2934         int64_t den = AV_NOPTS_VALUE;
2935         st = s->streams[i];
2936
2937         switch (st->codec->codec_type) {
2938         case AVMEDIA_TYPE_AUDIO:
2939             den = (int64_t)st->time_base.num * st->codec->sample_rate;
2940             break;
2941         case AVMEDIA_TYPE_VIDEO:
2942             den = (int64_t)st->time_base.num * st->codec->time_base.den;
2943             break;
2944         default:
2945             break;
2946         }
2947         if (den != AV_NOPTS_VALUE) {
2948             if (den <= 0)
2949                 return AVERROR_INVALIDDATA;
2950             av_frac_init(&st->pts, 0, 0, den);
2951         }
2952     }
2953     return 0;
2954 }
2955
2956 //FIXME merge with compute_pkt_fields
2957 static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt){
2958     int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2959     int num, den, frame_size, i;
2960
2961     av_dlog(s, "compute_pkt_fields2: pts:%"PRId64" dts:%"PRId64" cur_dts:%"PRId64" b:%d size:%d st:%d\n",
2962             pkt->pts, pkt->dts, st->cur_dts, delay, pkt->size, pkt->stream_index);
2963
2964 /*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2965         return AVERROR(EINVAL);*/
2966
2967     /* duration field */
2968     if (pkt->duration == 0) {
2969         compute_frame_duration(&num, &den, st, NULL, pkt);
2970         if (den && num) {
2971             pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
2972         }
2973     }
2974
2975     if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
2976         pkt->pts= pkt->dts;
2977
2978     //XXX/FIXME this is a temporary hack until all encoders output pts
2979     if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2980         pkt->dts=
2981 //        pkt->pts= st->cur_dts;
2982         pkt->pts= st->pts.val;
2983     }
2984
2985     //calculate dts from pts
2986     if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
2987         st->pts_buffer[0]= pkt->pts;
2988         for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2989             st->pts_buffer[i]= pkt->pts + (i-delay-1) * pkt->duration;
2990         for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2991             FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2992
2993         pkt->dts= st->pts_buffer[0];
2994     }
2995
2996     if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && ((!(s->oformat->flags & AVFMT_TS_NONSTRICT) && st->cur_dts >= pkt->dts) || st->cur_dts > pkt->dts)){
2997         av_log(s, AV_LOG_ERROR,
2998                "Application provided invalid, non monotonically increasing dts to muxer in stream %d: %"PRId64" >= %"PRId64"\n",
2999                st->index, st->cur_dts, pkt->dts);
3000         return AVERROR(EINVAL);
3001     }
3002     if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
3003         av_log(s, AV_LOG_ERROR, "pts < dts in stream %d\n", st->index);
3004         return AVERROR(EINVAL);
3005     }
3006
3007 //    av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
3008     st->cur_dts= pkt->dts;
3009     st->pts.val= pkt->dts;
3010
3011     /* update pts */
3012     switch (st->codec->codec_type) {
3013     case AVMEDIA_TYPE_AUDIO:
3014         frame_size = get_audio_frame_size(st->codec, pkt->size);
3015
3016         /* HACK/FIXME, we skip the initial 0 size packets as they are most
3017            likely equal to the encoder delay, but it would be better if we
3018            had the real timestamps from the encoder */
3019         if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
3020             av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
3021         }
3022         break;
3023     case AVMEDIA_TYPE_VIDEO:
3024         av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
3025         break;
3026     default:
3027         break;
3028     }
3029     return 0;
3030 }
3031
3032 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
3033 {
3034     int ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt);
3035
3036     if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3037         return ret;
3038
3039     ret= s->oformat->write_packet(s, pkt);
3040     if(!ret)
3041         ret= url_ferror(s->pb);
3042     return ret;
3043 }
3044
3045 void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
3046                               int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
3047 {
3048     AVPacketList **next_point, *this_pktl;
3049
3050     this_pktl = av_mallocz(sizeof(AVPacketList));
3051     this_pktl->pkt= *pkt;
3052     pkt->destruct= NULL;             // do not free original but only the copy
3053     av_dup_packet(&this_pktl->pkt);  // duplicate the packet if it uses non-alloced memory
3054
3055     if(s->streams[pkt->stream_index]->last_in_packet_buffer){
3056         next_point = &(s->streams[pkt->stream_index]->last_in_packet_buffer->next);
3057     }else
3058         next_point = &s->packet_buffer;
3059
3060     if(*next_point){
3061         if(compare(s, &s->packet_buffer_end->pkt, pkt)){
3062             while(!compare(s, &(*next_point)->pkt, pkt)){
3063                 next_point= &(*next_point)->next;
3064             }
3065             goto next_non_null;
3066         }else{
3067             next_point = &(s->packet_buffer_end->next);
3068         }
3069     }
3070     assert(!*next_point);
3071
3072     s->packet_buffer_end= this_pktl;
3073 next_non_null:
3074
3075     this_pktl->next= *next_point;
3076
3077     s->streams[pkt->stream_index]->last_in_packet_buffer=
3078     *next_point= this_pktl;
3079 }
3080
3081 static int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
3082 {
3083     AVStream *st = s->streams[ pkt ->stream_index];
3084     AVStream *st2= s->streams[ next->stream_index];
3085     int comp = av_compare_ts(next->dts, st2->time_base, pkt->dts,
3086                              st->time_base);
3087
3088     if (comp == 0)
3089         return pkt->stream_index < next->stream_index;
3090     return comp > 0;
3091 }
3092
3093 int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
3094     AVPacketList *pktl;
3095     int stream_count=0;
3096     int i;
3097
3098     if(pkt){
3099         ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
3100     }
3101
3102     for(i=0; i < s->nb_streams; i++)
3103         stream_count+= !!s->streams[i]->last_in_packet_buffer;
3104
3105     if(stream_count && (s->nb_streams == stream_count || flush)){
3106         pktl= s->packet_buffer;
3107         *out= pktl->pkt;
3108
3109         s->packet_buffer= pktl->next;
3110         if(!s->packet_buffer)
3111             s->packet_buffer_end= NULL;
3112
3113         if(s->streams[out->stream_index]->last_in_packet_buffer == pktl)
3114             s->streams[out->stream_index]->last_in_packet_buffer= NULL;
3115         av_freep(&pktl);
3116         return 1;
3117     }else{
3118         av_init_packet(out);
3119         return 0;
3120     }
3121 }
3122
3123 /**
3124  * Interleave an AVPacket correctly so it can be muxed.
3125  * @param out the interleaved packet will be output here
3126  * @param in the input packet
3127  * @param flush 1 if no further packets are available as input and all
3128  *              remaining packets should be output
3129  * @return 1 if a packet was output, 0 if no packet could be output,
3130  *         < 0 if an error occurred
3131  */
3132 static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
3133     if(s->oformat->interleave_packet)
3134         return s->oformat->interleave_packet(s, out, in, flush);
3135     else
3136         return av_interleave_packet_per_dts(s, out, in, flush);
3137 }
3138
3139 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
3140     AVStream *st= s->streams[ pkt->stream_index];
3141     int ret;
3142
3143     //FIXME/XXX/HACK drop zero sized packets
3144     if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO && pkt->size==0)
3145         return 0;
3146
3147     av_dlog(s, "av_interleaved_write_frame size:%d dts:%"PRId64" pts:%"PRId64"\n",
3148             pkt->size, pkt->dts, pkt->pts);
3149     if((ret = compute_pkt_fields2(s, st, pkt)) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3150         return ret;
3151
3152     if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3153         return AVERROR(EINVAL);
3154
3155     for(;;){
3156         AVPacket opkt;
3157         int ret= av_interleave_packet(s, &opkt, pkt, 0);
3158         if(ret<=0) //FIXME cleanup needed for ret<0 ?
3159             return ret;
3160
3161         ret= s->oformat->write_packet(s, &opkt);
3162
3163         av_free_packet(&opkt);
3164         pkt= NULL;
3165
3166         if(ret<0)
3167             return ret;
3168         if(url_ferror(s->pb))
3169             return url_ferror(s->pb);
3170     }
3171 }
3172
3173 int av_write_trailer(AVFormatContext *s)
3174 {
3175     int ret, i;
3176
3177     for(;;){
3178         AVPacket pkt;
3179         ret= av_interleave_packet(s, &pkt, NULL, 1);
3180         if(ret<0) //FIXME cleanup needed for ret<0 ?
3181             goto fail;
3182         if(!ret)
3183             break;
3184
3185         ret= s->oformat->write_packet(s, &pkt);
3186
3187         av_free_packet(&pkt);
3188
3189         if(ret<0)
3190             goto fail;
3191         if(url_ferror(s->pb))
3192             goto fail;
3193     }
3194
3195     if(s->oformat->write_trailer)
3196         ret = s->oformat->write_trailer(s);
3197 fail:
3198     if(ret == 0)
3199        ret=url_ferror(s->pb);
3200     for(i=0;i<s->nb_streams;i++) {
3201         av_freep(&s->streams[i]->priv_data);
3202         av_freep(&s->streams[i]->index_entries);
3203     }
3204     av_freep(&s->priv_data);
3205     return ret;
3206 }
3207
3208 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
3209 {
3210     int i, j;
3211     AVProgram *program=NULL;
3212     void *tmp;
3213
3214     if (idx >= ac->nb_streams) {
3215         av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3216         return;
3217     }
3218
3219     for(i=0; i<ac->nb_programs; i++){
3220         if(ac->programs[i]->id != progid)
3221             continue;
3222         program = ac->programs[i];
3223         for(j=0; j<program->nb_stream_indexes; j++)
3224             if(program->stream_index[j] == idx)
3225                 return;
3226
3227         tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
3228         if(!tmp)
3229             return;
3230         program->stream_index = tmp;
3231         program->stream_index[program->nb_stream_indexes++] = idx;
3232         return;
3233     }
3234 }
3235
3236 static void print_fps(double d, const char *postfix){
3237     uint64_t v= lrintf(d*100);
3238     if     (v% 100      ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3239     else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3240     else                  av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
3241 }
3242
3243 static void dump_metadata(void *ctx, AVMetadata *m, const char *indent)
3244 {
3245     if(m && !(m->count == 1 && av_metadata_get(m, "language", NULL, 0))){
3246         AVMetadataTag *tag=NULL;
3247
3248         av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3249         while((tag=av_metadata_get(m, "", tag, AV_METADATA_IGNORE_SUFFIX))) {
3250             if(strcmp("language", tag->key))
3251                 av_log(ctx, AV_LOG_INFO, "%s  %-16s: %s\n", indent, tag->key, tag->value);
3252         }
3253     }
3254 }
3255
3256 /* "user interface" functions */
3257 static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
3258 {
3259     char buf[256];
3260     int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
3261     AVStream *st = ic->streams[i];
3262     int g = av_gcd(st->time_base.num, st->time_base.den);
3263     AVMetadataTag *lang = av_metadata_get(st->metadata, "language", NULL, 0);
3264     avcodec_string(buf, sizeof(buf), st->codec, is_output);
3265     av_log(NULL, AV_LOG_INFO, "    Stream #%d.%d", index, i);
3266     /* the pid is an important information, so we display it */
3267     /* XXX: add a generic system */
3268     if (flags & AVFMT_SHOW_IDS)
3269         av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
3270     if (lang)
3271         av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
3272     av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames, st->time_base.num/g, st->time_base.den/g);
3273     av_log(NULL, AV_LOG_INFO, ": %s", buf);
3274     if (st->sample_aspect_ratio.num && // default
3275         av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
3276         AVRational display_aspect_ratio;
3277         av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
3278                   st->codec->width*st->sample_aspect_ratio.num,
3279                   st->codec->height*st->sample_aspect_ratio.den,
3280                   1024*1024);
3281         av_log(NULL, AV_LOG_INFO, ", PAR %d:%d DAR %d:%d",
3282                  st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3283                  display_aspect_ratio.num, display_aspect_ratio.den);
3284     }
3285     if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
3286         if(st->avg_frame_rate.den && st->avg_frame_rate.num)
3287             print_fps(av_q2d(st->avg_frame_rate), "fps");
3288         if(st->r_frame_rate.den && st->r_frame_rate.num)
3289             print_fps(av_q2d(st->r_frame_rate), "tbr");
3290         if(st->time_base.den && st->time_base.num)
3291             print_fps(1/av_q2d(st->time_base), "tbn");
3292         if(st->codec->time_base.den && st->codec->time_base.num)
3293             print_fps(1/av_q2d(st->codec->time_base), "tbc");
3294     }
3295     if (st->disposition & AV_DISPOSITION_DEFAULT)
3296         av_log(NULL, AV_LOG_INFO, " (default)");
3297     if (st->disposition & AV_DISPOSITION_DUB)
3298         av_log(NULL, AV_LOG_INFO, " (dub)");
3299     if (st->disposition & AV_DISPOSITION_ORIGINAL)
3300         av_log(NULL, AV_LOG_INFO, " (original)");
3301     if (st->disposition & AV_DISPOSITION_COMMENT)
3302         av_log(NULL, AV_LOG_INFO, " (comment)");
3303     if (st->disposition & AV_DISPOSITION_LYRICS)
3304         av_log(NULL, AV_LOG_INFO, " (lyrics)");
3305     if (st->disposition & AV_DISPOSITION_KARAOKE)
3306         av_log(NULL, AV_LOG_INFO, " (karaoke)");
3307     if (st->disposition & AV_DISPOSITION_FORCED)
3308         av_log(NULL, AV_LOG_INFO, " (forced)");
3309     if (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED)
3310         av_log(NULL, AV_LOG_INFO, " (hearing impaired)");
3311     if (st->disposition & AV_DISPOSITION_VISUAL_IMPAIRED)
3312         av_log(NULL, AV_LOG_INFO, " (visual impaired)");
3313     if (st->disposition & AV_DISPOSITION_CLEAN_EFFECTS)
3314         av_log(NULL, AV_LOG_INFO, " (clean effects)");
3315     av_log(NULL, AV_LOG_INFO, "\n");
3316     dump_metadata(NULL, st->metadata, "    ");
3317 }
3318
3319 #if FF_API_DUMP_FORMAT
3320 void dump_format(AVFormatContext *ic,
3321                  int index,
3322                  const char *url,
3323                  int is_output)
3324 {
3325     av_dump_format(ic, index, url, is_output);
3326 }
3327 #endif
3328
3329 void av_dump_format(AVFormatContext *ic,
3330                     int index,
3331                     const char *url,
3332                     int is_output)
3333 {
3334     int i;
3335     uint8_t *printed = av_mallocz(ic->nb_streams);
3336     if (ic->nb_streams && !printed)
3337         return;
3338
3339     av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3340             is_output ? "Output" : "Input",
3341             index,
3342             is_output ? ic->oformat->name : ic->iformat->name,
3343             is_output ? "to" : "from", url);
3344     dump_metadata(NULL, ic->metadata, "  ");
3345     if (!is_output) {
3346         av_log(NULL, AV_LOG_INFO, "  Duration: ");
3347         if (ic->duration != AV_NOPTS_VALUE) {
3348             int hours, mins, secs, us;
3349             secs = ic->duration / AV_TIME_BASE;
3350             us = ic->duration % AV_TIME_BASE;
3351             mins = secs / 60;
3352             secs %= 60;
3353             hours = mins / 60;
3354             mins %= 60;
3355             av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3356                    (100 * us) / AV_TIME_BASE);
3357         } else {
3358             av_log(NULL, AV_LOG_INFO, "N/A");
3359         }
3360         if (ic->start_time != AV_NOPTS_VALUE) {
3361             int secs, us;
3362             av_log(NULL, AV_LOG_INFO, ", start: ");
3363             secs = ic->start_time / AV_TIME_BASE;
3364             us = abs(ic->start_time % AV_TIME_BASE);
3365             av_log(NULL, AV_LOG_INFO, "%d.%06d",
3366                    secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
3367         }
3368         av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3369         if (ic->bit_rate) {
3370             av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
3371         } else {
3372             av_log(NULL, AV_LOG_INFO, "N/A");
3373         }
3374         av_log(NULL, AV_LOG_INFO, "\n");
3375     }
3376     for (i = 0; i < ic->nb_chapters; i++) {
3377         AVChapter *ch = ic->chapters[i];
3378         av_log(NULL, AV_LOG_INFO, "    Chapter #%d.%d: ", index, i);
3379         av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
3380         av_log(NULL, AV_LOG_INFO, "end %f\n",   ch->end   * av_q2d(ch->time_base));
3381
3382         dump_metadata(NULL, ch->metadata, "    ");
3383     }
3384     if(ic->nb_programs) {
3385         int j, k, total = 0;
3386         for(j=0; j<ic->nb_programs; j++) {
3387             AVMetadataTag *name = av_metadata_get(ic->programs[j]->metadata,
3388                                                   "name", NULL, 0);
3389             av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
3390                    name ? name->value : "");
3391             dump_metadata(NULL, ic->programs[j]->metadata, "    ");
3392             for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3393                 dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3394                 printed[ic->programs[j]->stream_index[k]] = 1;
3395             }
3396             total += ic->programs[j]->nb_stream_indexes;
3397         }
3398         if (total < ic->nb_streams)
3399             av_log(NULL, AV_LOG_INFO, "  No Program\n");
3400     }
3401     for(i=0;i<ic->nb_streams;i++)
3402         if (!printed[i])
3403             dump_stream_format(ic, i, index, is_output);
3404
3405     av_free(printed);
3406 }
3407
3408 int64_t av_gettime(void)
3409 {
3410     struct timeval tv;
3411     gettimeofday(&tv,NULL);
3412     return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
3413 }
3414
3415 uint64_t ff_ntp_time(void)
3416 {
3417   return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3418 }
3419
3420 #if FF_API_PARSE_DATE
3421 #include "libavutil/parseutils.h"
3422
3423 int64_t parse_date(const char *timestr, int duration)
3424 {
3425     int64_t timeval;
3426     av_parse_time(&timeval, timestr, duration);
3427     return timeval;
3428 }
3429 #endif
3430
3431 #if FF_API_FIND_INFO_TAG
3432 #include "libavutil/parseutils.h"
3433
3434 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
3435 {
3436     return av_find_info_tag(arg, arg_size, tag1, info);
3437 }
3438 #endif
3439
3440 int av_get_frame_filename(char *buf, int buf_size,
3441                           const char *path, int number)
3442 {
3443     const char *p;
3444     char *q, buf1[20], c;
3445     int nd, len, percentd_found;
3446
3447     q = buf;
3448     p = path;
3449     percentd_found = 0;
3450     for(;;) {
3451         c = *p++;
3452         if (c == '\0')
3453             break;
3454         if (c == '%') {
3455             do {
3456                 nd = 0;
3457                 while (isdigit(*p)) {
3458                     nd = nd * 10 + *p++ - '0';
3459                 }
3460                 c = *p++;
3461             } while (isdigit(c));
3462
3463             switch(c) {
3464             case '%':
3465                 goto addchar;
3466             case 'd':
3467                 if (percentd_found)
3468                     goto fail;
3469                 percentd_found = 1;
3470                 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3471                 len = strlen(buf1);
3472                 if ((q - buf + len) > buf_size - 1)
3473                     goto fail;
3474                 memcpy(q, buf1, len);
3475                 q += len;
3476                 break;
3477             default:
3478                 goto fail;
3479             }
3480         } else {
3481         addchar:
3482             if ((q - buf) < buf_size - 1)
3483                 *q++ = c;
3484         }
3485     }
3486     if (!percentd_found)
3487         goto fail;
3488     *q = '\0';
3489     return 0;
3490  fail:
3491     *q = '\0';
3492     return -1;
3493 }
3494
3495 static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3496 {
3497     int len, i, j, c;
3498 #undef fprintf
3499 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3500
3501     for(i=0;i<size;i+=16) {
3502         len = size - i;
3503         if (len > 16)
3504             len = 16;
3505         PRINT("%08x ", i);
3506         for(j=0;j<16;j++) {
3507             if (j < len)
3508                 PRINT(" %02x", buf[i+j]);
3509             else
3510                 PRINT("   ");
3511         }
3512         PRINT(" ");
3513         for(j=0;j<len;j++) {
3514             c = buf[i+j];
3515             if (c < ' ' || c > '~')
3516                 c = '.';
3517             PRINT("%c", c);
3518         }
3519         PRINT("\n");
3520     }
3521 #undef PRINT
3522 }
3523
3524 void av_hex_dump(FILE *f, uint8_t *buf, int size)
3525 {
3526     hex_dump_internal(NULL, f, 0, buf, size);
3527 }
3528
3529 void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3530 {
3531     hex_dump_internal(avcl, NULL, level, buf, size);
3532 }
3533
3534 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload, AVRational time_base)
3535 {
3536 #undef fprintf
3537 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3538     PRINT("stream #%d:\n", pkt->stream_index);
3539     PRINT("  keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
3540     PRINT("  duration=%0.3f\n", pkt->duration * av_q2d(time_base));
3541     /* DTS is _always_ valid after av_read_frame() */
3542     PRINT("  dts=");
3543     if (pkt->dts == AV_NOPTS_VALUE)
3544         PRINT("N/A");
3545     else
3546         PRINT("%0.3f", pkt->dts * av_q2d(time_base));
3547     /* PTS may not be known if B-frames are present. */
3548     PRINT("  pts=");
3549     if (pkt->pts == AV_NOPTS_VALUE)
3550         PRINT("N/A");
3551     else
3552         PRINT("%0.3f", pkt->pts * av_q2d(time_base));
3553     PRINT("\n");
3554     PRINT("  size=%d\n", pkt->size);
3555 #undef PRINT
3556     if (dump_payload)
3557         av_hex_dump(f, pkt->data, pkt->size);
3558 }
3559
3560 #if FF_API_PKT_DUMP
3561 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3562 {
3563     AVRational tb = { 1, AV_TIME_BASE };
3564     pkt_dump_internal(NULL, f, 0, pkt, dump_payload, tb);
3565 }
3566 #endif
3567
3568 void av_pkt_dump2(FILE *f, AVPacket *pkt, int dump_payload, AVStream *st)
3569 {
3570     pkt_dump_internal(NULL, f, 0, pkt, dump_payload, st->time_base);
3571 }
3572
3573 #if FF_API_PKT_DUMP
3574 void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3575 {
3576     AVRational tb = { 1, AV_TIME_BASE };
3577     pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, tb);
3578 }
3579 #endif
3580
3581 void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload,
3582                       AVStream *st)
3583 {
3584     pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, st->time_base);
3585 }
3586
3587 void av_url_split(char *proto, int proto_size,
3588                   char *authorization, int authorization_size,
3589                   char *hostname, int hostname_size,
3590                   int *port_ptr,
3591                   char *path, int path_size,
3592                   const char *url)
3593 {
3594     const char *p, *ls, *at, *col, *brk;
3595
3596     if (port_ptr)               *port_ptr = -1;
3597     if (proto_size > 0)         proto[0] = 0;
3598     if (authorization_size > 0) authorization[0] = 0;
3599     if (hostname_size > 0)      hostname[0] = 0;
3600     if (path_size > 0)          path[0] = 0;
3601
3602     /* parse protocol */
3603     if ((p = strchr(url, ':'))) {
3604         av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3605         p++; /* skip ':' */
3606         if (*p == '/') p++;
3607         if (*p == '/') p++;
3608     } else {
3609         /* no protocol means plain filename */
3610         av_strlcpy(path, url, path_size);
3611         return;
3612     }
3613
3614     /* separate path from hostname */
3615     ls = strchr(p, '/');
3616     if(!ls)
3617         ls = strchr(p, '?');
3618     if(ls)
3619         av_strlcpy(path, ls, path_size);
3620     else
3621         ls = &p[strlen(p)]; // XXX
3622
3623     /* the rest is hostname, use that to parse auth/port */
3624     if (ls != p) {
3625         /* authorization (user[:pass]@hostname) */
3626         if ((at = strchr(p, '@')) && at < ls) {
3627             av_strlcpy(authorization, p,
3628                        FFMIN(authorization_size, at + 1 - p));
3629             p = at + 1; /* skip '@' */
3630         }
3631
3632         if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3633             /* [host]:port */
3634             av_strlcpy(hostname, p + 1,
3635                        FFMIN(hostname_size, brk - p));
3636             if (brk[1] == ':' && port_ptr)
3637                 *port_ptr = atoi(brk + 2);
3638         } else if ((col = strchr(p, ':')) && col < ls) {
3639             av_strlcpy(hostname, p,
3640                        FFMIN(col + 1 - p, hostname_size));
3641             if (port_ptr) *port_ptr = atoi(col + 1);
3642         } else
3643             av_strlcpy(hostname, p,
3644                        FFMIN(ls + 1 - p, hostname_size));
3645     }
3646 }
3647
3648 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3649 {
3650     int i;
3651     static const char hex_table_uc[16] = { '0', '1', '2', '3',
3652                                            '4', '5', '6', '7',
3653                                            '8', '9', 'A', 'B',
3654                                            'C', 'D', 'E', 'F' };
3655     static const char hex_table_lc[16] = { '0', '1', '2', '3',
3656                                            '4', '5', '6', '7',
3657                                            '8', '9', 'a', 'b',
3658                                            'c', 'd', 'e', 'f' };
3659     const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3660
3661     for(i = 0; i < s; i++) {
3662         buff[i * 2]     = hex_table[src[i] >> 4];
3663         buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3664     }
3665
3666     return buff;
3667 }
3668
3669 int ff_hex_to_data(uint8_t *data, const char *p)
3670 {
3671     int c, len, v;
3672
3673     len = 0;
3674     v = 1;
3675     for (;;) {
3676         p += strspn(p, SPACE_CHARS);
3677         if (*p == '\0')
3678             break;
3679         c = toupper((unsigned char) *p++);
3680         if (c >= '0' && c <= '9')
3681             c = c - '0';
3682         else if (c >= 'A' && c <= 'F')
3683             c = c - 'A' + 10;
3684         else
3685             break;
3686         v = (v << 4) | c;
3687         if (v & 0x100) {
3688             if (data)
3689                 data[len] = v;
3690             len++;
3691             v = 1;
3692         }
3693     }
3694     return len;
3695 }
3696
3697 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3698                      unsigned int pts_num, unsigned int pts_den)
3699 {
3700     AVRational new_tb;
3701     if(av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)){
3702         if(new_tb.num != pts_num)
3703             av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/new_tb.num);
3704     }else
3705         av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3706
3707     if(new_tb.num <= 0 || new_tb.den <= 0) {
3708         av_log(NULL, AV_LOG_ERROR, "Ignoring attempt to set invalid timebase for st:%d\n", s->index);
3709         return;
3710     }
3711     s->time_base = new_tb;
3712     s->pts_wrap_bits = pts_wrap_bits;
3713 }
3714
3715 int ff_url_join(char *str, int size, const char *proto,
3716                 const char *authorization, const char *hostname,
3717                 int port, const char *fmt, ...)
3718 {
3719 #if CONFIG_NETWORK
3720     struct addrinfo hints, *ai;
3721 #endif
3722
3723     str[0] = '\0';
3724     if (proto)
3725         av_strlcatf(str, size, "%s://", proto);
3726     if (authorization && authorization[0])
3727         av_strlcatf(str, size, "%s@", authorization);
3728 #if CONFIG_NETWORK && defined(AF_INET6)
3729     /* Determine if hostname is a numerical IPv6 address,
3730      * properly escape it within [] in that case. */
3731     memset(&hints, 0, sizeof(hints));
3732     hints.ai_flags = AI_NUMERICHOST;
3733     if (!getaddrinfo(hostname, NULL, &hints, &ai)) {
3734         if (ai->ai_family == AF_INET6) {
3735             av_strlcat(str, "[", size);
3736             av_strlcat(str, hostname, size);
3737             av_strlcat(str, "]", size);
3738         } else {
3739             av_strlcat(str, hostname, size);
3740         }
3741         freeaddrinfo(ai);
3742     } else
3743 #endif
3744         /* Not an IPv6 address, just output the plain string. */
3745         av_strlcat(str, hostname, size);
3746
3747     if (port >= 0)
3748         av_strlcatf(str, size, ":%d", port);
3749     if (fmt) {
3750         va_list vl;
3751         int len = strlen(str);
3752
3753         va_start(vl, fmt);
3754         vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);
3755         va_end(vl);
3756     }
3757     return strlen(str);
3758 }
3759
3760 int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
3761                      AVFormatContext *src)
3762 {
3763     AVPacket local_pkt;
3764
3765     local_pkt = *pkt;
3766     local_pkt.stream_index = dst_stream;
3767     if (pkt->pts != AV_NOPTS_VALUE)
3768         local_pkt.pts = av_rescale_q(pkt->pts,
3769                                      src->streams[pkt->stream_index]->time_base,
3770                                      dst->streams[dst_stream]->time_base);
3771     if (pkt->dts != AV_NOPTS_VALUE)
3772         local_pkt.dts = av_rescale_q(pkt->dts,
3773                                      src->streams[pkt->stream_index]->time_base,
3774                                      dst->streams[dst_stream]->time_base);
3775     return av_write_frame(dst, &local_pkt);
3776 }
3777
3778 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
3779                         void *context)
3780 {
3781     const char *ptr = str;
3782
3783     /* Parse key=value pairs. */
3784     for (;;) {
3785         const char *key;
3786         char *dest = NULL, *dest_end;
3787         int key_len, dest_len = 0;
3788
3789         /* Skip whitespace and potential commas. */
3790         while (*ptr && (isspace(*ptr) || *ptr == ','))
3791             ptr++;
3792         if (!*ptr)
3793             break;
3794
3795         key = ptr;
3796
3797         if (!(ptr = strchr(key, '=')))
3798             break;
3799         ptr++;
3800         key_len = ptr - key;
3801
3802         callback_get_buf(context, key, key_len, &dest, &dest_len);
3803         dest_end = dest + dest_len - 1;
3804
3805         if (*ptr == '\"') {
3806             ptr++;
3807             while (*ptr && *ptr != '\"') {
3808                 if (*ptr == '\\') {
3809                     if (!ptr[1])
3810                         break;
3811                     if (dest && dest < dest_end)
3812                         *dest++ = ptr[1];
3813                     ptr += 2;
3814                 } else {
3815                     if (dest && dest < dest_end)
3816                         *dest++ = *ptr;
3817                     ptr++;
3818                 }
3819             }
3820             if (*ptr == '\"')
3821                 ptr++;
3822         } else {
3823             for (; *ptr && !(isspace(*ptr) || *ptr == ','); ptr++)
3824                 if (dest && dest < dest_end)
3825                     *dest++ = *ptr;
3826         }
3827         if (dest)
3828             *dest = 0;
3829     }
3830 }
3831
3832 int ff_find_stream_index(AVFormatContext *s, int id)
3833 {
3834     int i;
3835     for (i = 0; i < s->nb_streams; i++) {
3836         if (s->streams[i]->id == id)
3837             return i;
3838     }
3839     return -1;
3840 }
3841
3842 void ff_make_absolute_url(char *buf, int size, const char *base,
3843                           const char *rel)
3844 {
3845     char *sep;
3846     /* Absolute path, relative to the current server */
3847     if (base && strstr(base, "://") && rel[0] == '/') {
3848         if (base != buf)
3849             av_strlcpy(buf, base, size);
3850         sep = strstr(buf, "://");
3851         if (sep) {
3852             sep += 3;
3853             sep = strchr(sep, '/');
3854             if (sep)
3855                 *sep = '\0';
3856         }
3857         av_strlcat(buf, rel, size);
3858         return;
3859     }
3860     /* If rel actually is an absolute url, just copy it */
3861     if (!base || strstr(rel, "://") || rel[0] == '/') {
3862         av_strlcpy(buf, rel, size);
3863         return;
3864     }
3865     if (base != buf)
3866         av_strlcpy(buf, base, size);
3867     /* Remove the file name from the base url */
3868     sep = strrchr(buf, '/');
3869     if (sep)
3870         sep[1] = '\0';
3871     else
3872         buf[0] = '\0';
3873     while (av_strstart(rel, "../", NULL) && sep) {
3874         /* Remove the path delimiter at the end */
3875         sep[0] = '\0';
3876         sep = strrchr(buf, '/');
3877         /* If the next directory name to pop off is "..", break here */
3878         if (!strcmp(sep ? &sep[1] : buf, "..")) {
3879             /* Readd the slash we just removed */
3880             av_strlcat(buf, "/", size);
3881             break;
3882         }
3883         /* Cut off the directory name */
3884         if (sep)
3885             sep[1] = '\0';
3886         else
3887             buf[0] = '\0';
3888         rel += 3;
3889     }
3890     av_strlcat(buf, rel, size);
3891 }