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