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 #include "avformat.h"
  22 #include "internal.h"
  23 #include "libavcodec/internal.h"
  24 #include "libavutil/opt.h"
  25 #include "metadata.h"
  26 #include "id3v2.h"
  27 #include "libavutil/avstring.h"
  28 #include "riff.h"
  29 #include "audiointerleave.h"
  30 #include <sys/time.h>
  31 #include <time.h>
  32 #include <strings.h>
  33 #include <stdarg.h>
  34 #if CONFIG_NETWORK
  35 #include "network.h"
  36 #endif
  37
  38 #undef NDEBUG
  39 #include <assert.h>
  40
  41 /**
  42  * @file
  43  * various utility functions for use within FFmpeg
  44  */
  45
  46 unsigned avformat_version(void)
  47 {
  48     return LIBAVFORMAT_VERSION_INT;
  49 }
  50
  51 const char *avformat_configuration(void)
  52 {
  53     return FFMPEG_CONFIGURATION;
  54 }
  55
  56 const char *avformat_license(void)
  57 {
  58 #define LICENSE_PREFIX "libavformat license: "
  59     return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;
  60 }
  61
  62 /* fraction handling */
  63
  64 /**
  65  * f = val + (num / den) + 0.5.
  66  *
  67  * 'num' is normalized so that it is such as 0 <= num < den.
  68  *
  69  * @param f fractional number
  70  * @param val integer value
  71  * @param num must be >= 0
  72  * @param den must be >= 1
  73  */
  74 static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
  75 {
  76     num += (den >> 1);
  77     if (num >= den) {
  78         val += num / den;
  79         num = num % den;
  80     }
  81     f->val = val;
  82     f->num = num;
  83     f->den = den;
  84 }
  85
  86 /**
  87  * Fractional addition to f: f = f + (incr / f->den).
  88  *
  89  * @param f fractional number
  90  * @param incr increment, can be positive or negative
  91  */
  92 static void av_frac_add(AVFrac *f, int64_t incr)
  93 {
  94     int64_t num, den;
  95
  96     num = f->num + incr;
  97     den = f->den;
  98     if (num < 0) {
  99         f->val += num / den;
 100         num = num % den;
 101         if (num < 0) {
 102             num += den;
 103             f->val--;
 104         }
 105     } else if (num >= den) {
 106         f->val += num / den;
 107         num = num % den;
 108     }
 109     f->num = num;
 110 }
 111
 112 /** head of registered input format linked list */
 113 #if !FF_API_FIRST_FORMAT
 114 static
 115 #endif
 116 AVInputFormat *first_iformat = NULL;
 117 /** head of registered output format linked list */
 118 #if !FF_API_FIRST_FORMAT
 119 static
 120 #endif
 121 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 #if FF_API_GUESS_FORMAT
 199 AVOutputFormat *guess_format(const char *short_name, const char *filename,
 200                              const char *mime_type)
 201 {
 202     return av_guess_format(short_name, filename, mime_type);
 203 }
 204 #endif
 205
 206 AVOutputFormat *av_guess_format(const char *short_name, const char *filename,
 207                                 const char *mime_type)
 208 {
 209     AVOutputFormat *fmt = NULL, *fmt_found;
 210     int score_max, score;
 211
 212     /* specific test for image sequences */
 213 #if CONFIG_IMAGE2_MUXER
 214     if (!short_name && filename &&
 215         av_filename_number_test(filename) &&
 216         av_guess_image2_codec(filename) != CODEC_ID_NONE) {
 217         return av_guess_format("image2", NULL, NULL);
 218     }
 219 #endif
 220     /* Find the proper file type. */
 221     fmt_found = NULL;
 222     score_max = 0;
 223     while ((fmt = av_oformat_next(fmt))) {
 224         score = 0;
 225         if (fmt->name && short_name && !strcmp(fmt->name, short_name))
 226             score += 100;
 227         if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
 228             score += 10;
 229         if (filename && fmt->extensions &&
 230             av_match_ext(filename, fmt->extensions)) {
 231             score += 5;
 232         }
 233         if (score > score_max) {
 234             score_max = score;
 235             fmt_found = fmt;
 236         }
 237     }
 238     return fmt_found;
 239 }
 240
 241 #if FF_API_GUESS_FORMAT
 242 AVOutputFormat *guess_stream_format(const char *short_name, const char *filename,
 243                              const char *mime_type)
 244 {
 245     AVOutputFormat *fmt = av_guess_format(short_name, filename, mime_type);
 246
 247     if (fmt) {
 248         AVOutputFormat *stream_fmt;
 249         char stream_format_name[64];
 250
 251         snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
 252         stream_fmt = av_guess_format(stream_format_name, NULL, NULL);
 253
 254         if (stream_fmt)
 255             fmt = stream_fmt;
 256     }
 257
 258     return fmt;
 259 }
 260 #endif
 261
 262 enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
 263                             const char *filename, const char *mime_type, enum AVMediaType type){
 264     if(type == AVMEDIA_TYPE_VIDEO){
 265         enum CodecID codec_id= CODEC_ID_NONE;
 266
 267 #if CONFIG_IMAGE2_MUXER
 268         if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
 269             codec_id= av_guess_image2_codec(filename);
 270         }
 271 #endif
 272         if(codec_id == CODEC_ID_NONE)
 273             codec_id= fmt->video_codec;
 274         return codec_id;
 275     }else if(type == AVMEDIA_TYPE_AUDIO)
 276         return fmt->audio_codec;
 277     else if (type == AVMEDIA_TYPE_SUBTITLE)
 278         return fmt->subtitle_codec;
 279     else
 280         return CODEC_ID_NONE;
 281 }
 282
 283 AVInputFormat *av_find_input_format(const char *short_name)
 284 {
 285     AVInputFormat *fmt = NULL;
 286     while ((fmt = av_iformat_next(fmt))) {
 287         if (match_format(short_name, fmt->name))
 288             return fmt;
 289     }
 290     return NULL;
 291 }
 292
 293 #if FF_API_SYMVER && CONFIG_SHARED && HAVE_SYMVER
 294 FF_SYMVER(void, av_destruct_packet_nofree, (AVPacket *pkt), "LIBAVFORMAT_52")
 295 {
 296     av_destruct_packet_nofree(pkt);
 297 }
 298
 299 FF_SYMVER(void, av_destruct_packet, (AVPacket *pkt), "LIBAVFORMAT_52")
 300 {
 301     av_destruct_packet(pkt);
 302 }
 303
 304 FF_SYMVER(int, av_new_packet, (AVPacket *pkt, int size), "LIBAVFORMAT_52")
 305 {
 306     return av_new_packet(pkt, size);
 307 }
 308
 309 FF_SYMVER(int, av_dup_packet, (AVPacket *pkt), "LIBAVFORMAT_52")
 310 {
 311     return av_dup_packet(pkt);
 312 }
 313
 314 FF_SYMVER(void, av_free_packet, (AVPacket *pkt), "LIBAVFORMAT_52")
 315 {
 316     av_free_packet(pkt);
 317 }
 318
 319 FF_SYMVER(void, av_init_packet, (AVPacket *pkt), "LIBAVFORMAT_52")
 320 {
 321     av_log(NULL, AV_LOG_WARNING, "Diverting av_*_packet function calls to libavcodec. Recompile to improve performance\n");
 322     av_init_packet(pkt);
 323 }
 324 #endif
 325
 326 int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
 327 {
 328     int ret= av_new_packet(pkt, size);
 329
 330     if(ret<0)
 331         return ret;
 332
 333     pkt->pos= url_ftell(s);
 334
 335     ret= avio_read(s, pkt->data, size);
 336     if(ret<=0)
 337         av_free_packet(pkt);
 338     else
 339         av_shrink_packet(pkt, ret);
 340
 341     return ret;
 342 }
 343
 344 int av_append_packet(AVIOContext *s, AVPacket *pkt, int size)
 345 {
 346     int ret;
 347     int old_size;
 348     if (!pkt->size)
 349         return av_get_packet(s, pkt, size);
 350     old_size = pkt->size;
 351     ret = av_grow_packet(pkt, size);
 352     if (ret < 0)
 353         return ret;
 354     ret = avio_read(s, pkt->data + old_size, size);
 355     av_shrink_packet(pkt, old_size + FFMAX(ret, 0));
 356     return ret;
 357 }
 358
 359
 360 int av_filename_number_test(const char *filename)
 361 {
 362     char buf[1024];
 363     return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
 364 }
 365
 366 AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
 367 {
 368     AVProbeData lpd = *pd;
 369     AVInputFormat *fmt1 = NULL, *fmt;
 370     int score;
 371
 372     if (lpd.buf_size > 10 && ff_id3v2_match(lpd.buf, ID3v2_DEFAULT_MAGIC)) {
 373         int id3len = ff_id3v2_tag_len(lpd.buf);
 374         if (lpd.buf_size > id3len + 16) {
 375             lpd.buf += id3len;
 376             lpd.buf_size -= id3len;
 377         }
 378     }
 379
 380     fmt = NULL;
 381     while ((fmt1 = av_iformat_next(fmt1))) {
 382         if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
 383             continue;
 384         score = 0;
 385         if (fmt1->read_probe) {
 386             score = fmt1->read_probe(&lpd);
 387         } else if (fmt1->extensions) {
 388             if (av_match_ext(lpd.filename, fmt1->extensions)) {
 389                 score = 50;
 390             }
 391         }
 392         if (score > *score_max) {
 393             *score_max = score;
 394             fmt = fmt1;
 395         }else if (score == *score_max)
 396             fmt = NULL;
 397     }
 398     return fmt;
 399 }
 400
 401 AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
 402     int score=0;
 403     return av_probe_input_format2(pd, is_opened, &score);
 404 }
 405
 406 static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st, AVProbeData *pd, int score)
 407 {
 408     static const struct {
 409         const char *name; enum CodecID id; enum AVMediaType type;
 410     } fmt_id_type[] = {
 411         { "aac"      , CODEC_ID_AAC       , AVMEDIA_TYPE_AUDIO },
 412         { "ac3"      , CODEC_ID_AC3       , AVMEDIA_TYPE_AUDIO },
 413         { "dts"      , CODEC_ID_DTS       , AVMEDIA_TYPE_AUDIO },
 414         { "eac3"     , CODEC_ID_EAC3      , AVMEDIA_TYPE_AUDIO },
 415         { "h264"     , CODEC_ID_H264      , AVMEDIA_TYPE_VIDEO },
 416         { "m4v"      , CODEC_ID_MPEG4     , AVMEDIA_TYPE_VIDEO },
 417         { "mp3"      , CODEC_ID_MP3       , AVMEDIA_TYPE_AUDIO },
 418         { "mpegvideo", CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
 419         { 0 }
 420     };
 421     AVInputFormat *fmt = av_probe_input_format2(pd, 1, &score);
 422
 423     if (fmt) {
 424         int i;
 425         av_log(s, AV_LOG_DEBUG, "Probe with size=%d, packets=%d detected %s with score=%d\n",
 426                pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets, fmt->name, score);
 427         for (i = 0; fmt_id_type[i].name; i++) {
 428             if (!strcmp(fmt->name, fmt_id_type[i].name)) {
 429                 st->codec->codec_id   = fmt_id_type[i].id;
 430                 st->codec->codec_type = fmt_id_type[i].type;
 431                 break;
 432             }
 433         }
 434     }
 435     return !!fmt;
 436 }
 437
 438 /************************************************************/
 439 /* input media file */
 440
 441 /**
 442  * Open a media file from an IO stream. 'fmt' must be specified.
 443  */
 444 int av_open_input_stream(AVFormatContext **ic_ptr,
 445                          AVIOContext *pb, const char *filename,
 446                          AVInputFormat *fmt, AVFormatParameters *ap)
 447 {
 448     int err;
 449     AVFormatContext *ic;
 450     AVFormatParameters default_ap;
 451
 452     if(!ap){
 453         ap=&default_ap;
 454         memset(ap, 0, sizeof(default_ap));
 455     }
 456
 457     if(!ap->prealloced_context)
 458         ic = avformat_alloc_context();
 459     else
 460         ic = *ic_ptr;
 461     if (!ic) {
 462         err = AVERROR(ENOMEM);
 463         goto fail;
 464     }
 465     ic->iformat = fmt;
 466     ic->pb = pb;
 467     ic->duration = AV_NOPTS_VALUE;
 468     ic->start_time = AV_NOPTS_VALUE;
 469     av_strlcpy(ic->filename, filename, sizeof(ic->filename));
 470
 471     /* allocate private data */
 472     if (fmt->priv_data_size > 0) {
 473         ic->priv_data = av_mallocz(fmt->priv_data_size);
 474         if (!ic->priv_data) {
 475             err = AVERROR(ENOMEM);
 476             goto fail;
 477         }
 478     } else {
 479         ic->priv_data = NULL;
 480     }
 481
 482     // e.g. AVFMT_NOFILE formats will not have a AVIOContext
 483     if (ic->pb)
 484         ff_id3v2_read(ic, ID3v2_DEFAULT_MAGIC);
 485
 486     if (ic->iformat->read_header) {
 487         err = ic->iformat->read_header(ic, ap);
 488         if (err < 0)
 489             goto fail;
 490     }
 491
 492     if (pb && !ic->data_offset)
 493         ic->data_offset = url_ftell(ic->pb);
 494
 495 #if FF_API_OLD_METADATA
 496     ff_metadata_demux_compat(ic);
 497 #endif
 498
 499     ic->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
 500
 501     *ic_ptr = ic;
 502     return 0;
 503  fail:
 504     if (ic) {
 505         int i;
 506         av_freep(&ic->priv_data);
 507         for(i=0;i<ic->nb_streams;i++) {
 508             AVStream *st = ic->streams[i];
 509             if (st) {
 510                 av_free(st->priv_data);
 511                 av_free(st->codec->extradata);
 512                 av_free(st->codec);
 513                 av_free(st->info);
 514             }
 515             av_free(st);
 516         }
 517     }
 518     av_free(ic);
 519     *ic_ptr = NULL;
 520     return err;
 521 }
 522
 523 /** size of probe buffer, for guessing file type from file contents */
 524 #define PROBE_BUF_MIN 2048
 525 #define PROBE_BUF_MAX (1<<20)
 526
 527 int av_probe_input_buffer(AVIOContext *pb, AVInputFormat **fmt,
 528                           const char *filename, void *logctx,
 529                           unsigned int offset, unsigned int max_probe_size)
 530 {
 531     AVProbeData pd = { filename ? filename : "", NULL, -offset };
 532     unsigned char *buf = NULL;
 533     int ret = 0, probe_size;
 534
 535     if (!max_probe_size) {
 536         max_probe_size = PROBE_BUF_MAX;
 537     } else if (max_probe_size > PROBE_BUF_MAX) {
 538         max_probe_size = PROBE_BUF_MAX;
 539     } else if (max_probe_size < PROBE_BUF_MIN) {
 540         return AVERROR(EINVAL);
 541     }
 542
 543     if (offset >= max_probe_size) {
 544         return AVERROR(EINVAL);
 545     }
 546
 547     for(probe_size= PROBE_BUF_MIN; probe_size<=max_probe_size && !*fmt && ret >= 0;
 548         probe_size = FFMIN(probe_size<<1, FFMAX(max_probe_size, probe_size+1))) {
 549         int ret, score = probe_size < max_probe_size ? AVPROBE_SCORE_MAX/4 : 0;
 550         int buf_offset = (probe_size == PROBE_BUF_MIN) ? 0 : probe_size>>1;
 551
 552         if (probe_size < offset) {
 553             continue;
 554         }
 555
 556         /* read probe data */
 557         buf = av_realloc(buf, probe_size + AVPROBE_PADDING_SIZE);
 558         if ((ret = avio_read(pb, buf + buf_offset, probe_size - buf_offset)) < 0) {
 559             /* fail if error was not end of file, otherwise, lower score */
 560             if (ret != AVERROR_EOF) {
 561                 av_free(buf);
 562                 return ret;
 563             }
 564             score = 0;
 565             ret = 0;            /* error was end of file, nothing read */
 566         }
 567         pd.buf_size += ret;
 568         pd.buf = &buf[offset];
 569
 570         memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE);
 571
 572         /* guess file format */
 573         *fmt = av_probe_input_format2(&pd, 1, &score);
 574         if(*fmt){
 575             if(score <= AVPROBE_SCORE_MAX/4){ //this can only be true in the last iteration
 576                 av_log(logctx, AV_LOG_WARNING, "Format detected only with low score of %d, misdetection possible!\n", score);
 577             }else
 578                 av_log(logctx, AV_LOG_DEBUG, "Probed with size=%d and score=%d\n", probe_size, score);
 579         }
 580     }
 581
 582     if (!*fmt) {
 583         av_free(buf);
 584         return AVERROR_INVALIDDATA;
 585     }
 586
 587     /* rewind. reuse probe buffer to avoid seeking */
 588     if ((ret = ff_rewind_with_probe_data(pb, buf, pd.buf_size)) < 0)
 589         av_free(buf);
 590
 591     return ret;
 592 }
 593
 594 int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
 595                        AVInputFormat *fmt,
 596                        int buf_size,
 597                        AVFormatParameters *ap)
 598 {
 599     int err;
 600     AVProbeData probe_data, *pd = &probe_data;
 601     AVIOContext *pb = NULL;
 602     void *logctx= ap && ap->prealloced_context ? *ic_ptr : NULL;
 603
 604     pd->filename = "";
 605     if (filename)
 606         pd->filename = filename;
 607     pd->buf = NULL;
 608     pd->buf_size = 0;
 609
 610     if (!fmt) {
 611         /* guess format if no file can be opened */
 612         fmt = av_probe_input_format(pd, 0);
 613     }
 614
 615     /* Do not open file if the format does not need it. XXX: specific
 616        hack needed to handle RTSP/TCP */
 617     if (!fmt || !(fmt->flags & AVFMT_NOFILE)) {
 618         /* if no file needed do not try to open one */
 619         if ((err=avio_open(&pb, filename, URL_RDONLY)) < 0) {
 620             goto fail;
 621         }
 622         if (buf_size > 0) {
 623             url_setbufsize(pb, buf_size);
 624         }
 625         if (!fmt && (err = av_probe_input_buffer(pb, &fmt, filename, logctx, 0, logctx ? (*ic_ptr)->probesize : 0)) < 0) {
 626             goto fail;
 627         }
 628     }
 629
 630     /* if still no format found, error */
 631     if (!fmt) {
 632         err = AVERROR_INVALIDDATA;
 633         goto fail;
 634     }
 635
 636     /* check filename in case an image number is expected */
 637     if (fmt->flags & AVFMT_NEEDNUMBER) {
 638         if (!av_filename_number_test(filename)) {
 639             err = AVERROR_NUMEXPECTED;
 640             goto fail;
 641         }
 642     }
 643     err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
 644     if (err)
 645         goto fail;
 646     return 0;
 647  fail:
 648     av_freep(&pd->buf);
 649     if (pb)
 650         avio_close(pb);
 651     if (ap && ap->prealloced_context)
 652         av_free(*ic_ptr);
 653     *ic_ptr = NULL;
 654     return err;
 655
 656 }
 657
 658 /*******************************************************/
 659
 660 static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
 661                                AVPacketList **plast_pktl){
 662     AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
 663     if (!pktl)
 664         return NULL;
 665
 666     if (*packet_buffer)
 667         (*plast_pktl)->next = pktl;
 668     else
 669         *packet_buffer = pktl;
 670
 671     /* add the packet in the buffered packet list */
 672     *plast_pktl = pktl;
 673     pktl->pkt= *pkt;
 674     return &pktl->pkt;
 675 }
 676
 677 int av_read_packet(AVFormatContext *s, AVPacket *pkt)
 678 {
 679     int ret, i;
 680     AVStream *st;
 681
 682     for(;;){
 683         AVPacketList *pktl = s->raw_packet_buffer;
 684
 685         if (pktl) {
 686             *pkt = pktl->pkt;
 687             if(s->streams[pkt->stream_index]->codec->codec_id != CODEC_ID_PROBE ||
 688                !s->streams[pkt->stream_index]->probe_packets ||
 689                s->raw_packet_buffer_remaining_size < pkt->size){
 690                 AVProbeData *pd = &s->streams[pkt->stream_index]->probe_data;
 691                 av_freep(&pd->buf);
 692                 pd->buf_size = 0;
 693                 s->raw_packet_buffer = pktl->next;
 694                 s->raw_packet_buffer_remaining_size += pkt->size;
 695                 av_free(pktl);
 696                 return 0;
 697             }
 698         }
 699
 700         av_init_packet(pkt);
 701         ret= s->iformat->read_packet(s, pkt);
 702         if (ret < 0) {
 703             if (!pktl || ret == AVERROR(EAGAIN))
 704                 return ret;
 705             for (i = 0; i < s->nb_streams; i++)
 706                 s->streams[i]->probe_packets = 0;
 707             continue;
 708         }
 709         st= s->streams[pkt->stream_index];
 710
 711         switch(st->codec->codec_type){
 712         case AVMEDIA_TYPE_VIDEO:
 713             if(s->video_codec_id)   st->codec->codec_id= s->video_codec_id;
 714             break;
 715         case AVMEDIA_TYPE_AUDIO:
 716             if(s->audio_codec_id)   st->codec->codec_id= s->audio_codec_id;
 717             break;
 718         case AVMEDIA_TYPE_SUBTITLE:
 719             if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
 720             break;
 721         }
 722
 723         if(!pktl && (st->codec->codec_id != CODEC_ID_PROBE ||
 724                      !st->probe_packets))
 725             return ret;
 726
 727         add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
 728         s->raw_packet_buffer_remaining_size -= pkt->size;
 729
 730         if(st->codec->codec_id == CODEC_ID_PROBE){
 731             AVProbeData *pd = &st->probe_data;
 732             av_log(s, AV_LOG_DEBUG, "probing stream %d\n", st->index);
 733             --st->probe_packets;
 734
 735             pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
 736             memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
 737             pd->buf_size += pkt->size;
 738             memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
 739
 740             if(av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)){
 741                 //FIXME we dont reduce score to 0 for the case of running out of buffer space in bytes
 742                 set_codec_from_probe_data(s, st, pd, st->probe_packets > 0 ? AVPROBE_SCORE_MAX/4 : 0);
 743                 if(st->codec->codec_id != CODEC_ID_PROBE){
 744                     pd->buf_size=0;
 745                     av_freep(&pd->buf);
 746                     av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
 747                 }
 748             }
 749         }
 750     }
 751 }
 752
 753 /**********************************************************/
 754
 755 /**
 756  * Get the number of samples of an audio frame. Return -1 on error.
 757  */
 758 static int get_audio_frame_size(AVCodecContext *enc, int size)
 759 {
 760     int frame_size;
 761
 762     if(enc->codec_id == CODEC_ID_VORBIS)
 763         return -1;
 764
 765     if (enc->frame_size <= 1) {
 766         int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
 767
 768         if (bits_per_sample) {
 769             if (enc->channels == 0)
 770                 return -1;
 771             frame_size = (size << 3) / (bits_per_sample * enc->channels);
 772         } else {
 773             /* used for example by ADPCM codecs */
 774             if (enc->bit_rate == 0)
 775                 return -1;
 776             frame_size = ((int64_t)size * 8 * enc->sample_rate) / enc->bit_rate;
 777         }
 778     } else {
 779         frame_size = enc->frame_size;
 780     }
 781     return frame_size;
 782 }
 783
 784
 785 /**
 786  * Return the frame duration in seconds. Return 0 if not available.
 787  */
 788 static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
 789                                    AVCodecParserContext *pc, AVPacket *pkt)
 790 {
 791     int frame_size;
 792
 793     *pnum = 0;
 794     *pden = 0;
 795     switch(st->codec->codec_type) {
 796     case AVMEDIA_TYPE_VIDEO:
 797         if(st->time_base.num*1000LL > st->time_base.den){
 798             *pnum = st->time_base.num;
 799             *pden = st->time_base.den;
 800         }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
 801             *pnum = st->codec->time_base.num;
 802             *pden = st->codec->time_base.den;
 803             if (pc && pc->repeat_pict) {
 804                 *pnum = (*pnum) * (1 + pc->repeat_pict);
 805             }
 806             //If this codec can be interlaced or progressive then we need a parser to compute duration of a packet
 807             //Thus if we have no parser in such case leave duration undefined.
 808             if(st->codec->ticks_per_frame>1 && !pc){
 809                 *pnum = *pden = 0;
 810             }
 811         }
 812         break;
 813     case AVMEDIA_TYPE_AUDIO:
 814         frame_size = get_audio_frame_size(st->codec, pkt->size);
 815         if (frame_size <= 0 || st->codec->sample_rate <= 0)
 816             break;
 817         *pnum = frame_size;
 818         *pden = st->codec->sample_rate;
 819         break;
 820     default:
 821         break;
 822     }
 823 }
 824
 825 static int is_intra_only(AVCodecContext *enc){
 826     if(enc->codec_type == AVMEDIA_TYPE_AUDIO){
 827         return 1;
 828     }else if(enc->codec_type == AVMEDIA_TYPE_VIDEO){
 829         switch(enc->codec_id){
 830         case CODEC_ID_MJPEG:
 831         case CODEC_ID_MJPEGB:
 832         case CODEC_ID_LJPEG:
 833         case CODEC_ID_RAWVIDEO:
 834         case CODEC_ID_DVVIDEO:
 835         case CODEC_ID_HUFFYUV:
 836         case CODEC_ID_FFVHUFF:
 837         case CODEC_ID_ASV1:
 838         case CODEC_ID_ASV2:
 839         case CODEC_ID_VCR1:
 840         case CODEC_ID_DNXHD:
 841         case CODEC_ID_JPEG2000:
 842             return 1;
 843         default: break;
 844         }
 845     }
 846     return 0;
 847 }
 848
 849 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
 850                                       int64_t dts, int64_t pts)
 851 {
 852     AVStream *st= s->streams[stream_index];
 853     AVPacketList *pktl= s->packet_buffer;
 854
 855     if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE)
 856         return;
 857
 858     st->first_dts= dts - st->cur_dts;
 859     st->cur_dts= dts;
 860
 861     for(; pktl; pktl= pktl->next){
 862         if(pktl->pkt.stream_index != stream_index)
 863             continue;
 864         //FIXME think more about this check
 865         if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
 866             pktl->pkt.pts += st->first_dts;
 867
 868         if(pktl->pkt.dts != AV_NOPTS_VALUE)
 869             pktl->pkt.dts += st->first_dts;
 870
 871         if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
 872             st->start_time= pktl->pkt.pts;
 873     }
 874     if (st->start_time == AV_NOPTS_VALUE)
 875         st->start_time = pts;
 876 }
 877
 878 static void update_initial_durations(AVFormatContext *s, AVStream *st, AVPacket *pkt)
 879 {
 880     AVPacketList *pktl= s->packet_buffer;
 881     int64_t cur_dts= 0;
 882
 883     if(st->first_dts != AV_NOPTS_VALUE){
 884         cur_dts= st->first_dts;
 885         for(; pktl; pktl= pktl->next){
 886             if(pktl->pkt.stream_index == pkt->stream_index){
 887                 if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
 888                     break;
 889                 cur_dts -= pkt->duration;
 890             }
 891         }
 892         pktl= s->packet_buffer;
 893         st->first_dts = cur_dts;
 894     }else if(st->cur_dts)
 895         return;
 896
 897     for(; pktl; pktl= pktl->next){
 898         if(pktl->pkt.stream_index != pkt->stream_index)
 899             continue;
 900         if(pktl->pkt.pts == pktl->pkt.dts && pktl->pkt.dts == AV_NOPTS_VALUE
 901            && !pktl->pkt.duration){
 902             pktl->pkt.dts= cur_dts;
 903             if(!st->codec->has_b_frames)
 904                 pktl->pkt.pts= cur_dts;
 905             cur_dts += pkt->duration;
 906             pktl->pkt.duration= pkt->duration;
 907         }else
 908             break;
 909     }
 910     if(st->first_dts == AV_NOPTS_VALUE)
 911         st->cur_dts= cur_dts;
 912 }
 913
 914 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
 915                                AVCodecParserContext *pc, AVPacket *pkt)
 916 {
 917     int num, den, presentation_delayed, delay, i;
 918     int64_t offset;
 919
 920     if (s->flags & AVFMT_FLAG_NOFILLIN)
 921         return;
 922
 923     if((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
 924         pkt->dts= AV_NOPTS_VALUE;
 925
 926     if (st->codec->codec_id != CODEC_ID_H264 && pc && pc->pict_type == FF_B_TYPE)
 927         //FIXME Set low_delay = 0 when has_b_frames = 1
 928         st->codec->has_b_frames = 1;
 929
 930     /* do we have a video B-frame ? */
 931     delay= st->codec->has_b_frames;
 932     presentation_delayed = 0;
 933
 934     // ignore delay caused by frame threading so that the mpeg2-without-dts
 935     // warning will not trigger
 936     if (delay && st->codec->active_thread_type&FF_THREAD_FRAME)
 937         delay -= st->codec->thread_count-1;
 938
 939     /* XXX: need has_b_frame, but cannot get it if the codec is
 940         not initialized */
 941     if (delay &&
 942         pc && pc->pict_type != FF_B_TYPE)
 943         presentation_delayed = 1;
 944
 945     if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
 946        /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
 947         pkt->dts -= 1LL<<st->pts_wrap_bits;
 948     }
 949
 950     // some mpeg2 in mpeg-ps lack dts (issue171 / input_file.mpg)
 951     // we take the conservative approach and discard both
 952     // Note, if this is misbehaving for a H.264 file then possibly presentation_delayed is not set correctly.
 953     if(delay==1 && pkt->dts == pkt->pts && pkt->dts != AV_NOPTS_VALUE && presentation_delayed){
 954         av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination\n");
 955         pkt->dts= pkt->pts= AV_NOPTS_VALUE;
 956     }
 957
 958     if (pkt->duration == 0) {
 959         compute_frame_duration(&num, &den, st, pc, pkt);
 960         if (den && num) {
 961             pkt->duration = av_rescale_rnd(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num, AV_ROUND_DOWN);
 962
 963             if(pkt->duration != 0 && s->packet_buffer)
 964                 update_initial_durations(s, st, pkt);
 965         }
 966     }
 967
 968     /* correct timestamps with byte offset if demuxers only have timestamps
 969        on packet boundaries */
 970     if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
 971         /* this will estimate bitrate based on this frame's duration and size */
 972         offset = av_rescale(pc->offset, pkt->duration, pkt->size);
 973         if(pkt->pts != AV_NOPTS_VALUE)
 974             pkt->pts += offset;
 975         if(pkt->dts != AV_NOPTS_VALUE)
 976             pkt->dts += offset;
 977     }
 978
 979     if (pc && pc->dts_sync_point >= 0) {
 980         // we have synchronization info from the parser
 981         int64_t den = st->codec->time_base.den * (int64_t) st->time_base.num;
 982         if (den > 0) {
 983             int64_t num = st->codec->time_base.num * (int64_t) st->time_base.den;
 984             if (pkt->dts != AV_NOPTS_VALUE) {
 985                 // got DTS from the stream, update reference timestamp
 986                 st->reference_dts = pkt->dts - pc->dts_ref_dts_delta * num / den;
 987                 pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
 988             } else if (st->reference_dts != AV_NOPTS_VALUE) {
 989                 // compute DTS based on reference timestamp
 990                 pkt->dts = st->reference_dts + pc->dts_ref_dts_delta * num / den;
 991                 pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
 992             }
 993             if (pc->dts_sync_point > 0)
 994                 st->reference_dts = pkt->dts; // new reference
 995         }
 996     }
 997
 998     /* This may be redundant, but it should not hurt. */
 999     if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
1000         presentation_delayed = 1;
1001
1002 //    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);
1003     /* interpolate PTS and DTS if they are not present */
1004     //We skip H264 currently because delay and has_b_frames are not reliably set
1005     if((delay==0 || (delay==1 && pc)) && st->codec->codec_id != CODEC_ID_H264){
1006         if (presentation_delayed) {
1007             /* DTS = decompression timestamp */
1008             /* PTS = presentation timestamp */
1009             if (pkt->dts == AV_NOPTS_VALUE)
1010                 pkt->dts = st->last_IP_pts;
1011             update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
1012             if (pkt->dts == AV_NOPTS_VALUE)
1013                 pkt->dts = st->cur_dts;
1014
1015             /* this is tricky: the dts must be incremented by the duration
1016             of the frame we are displaying, i.e. the last I- or P-frame */
1017             if (st->last_IP_duration == 0)
1018                 st->last_IP_duration = pkt->duration;
1019             if(pkt->dts != AV_NOPTS_VALUE)
1020                 st->cur_dts = pkt->dts + st->last_IP_duration;
1021             st->last_IP_duration  = pkt->duration;
1022             st->last_IP_pts= pkt->pts;
1023             /* cannot compute PTS if not present (we can compute it only
1024             by knowing the future */
1025         } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
1026             if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
1027                 int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
1028                 int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
1029                 if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
1030                     pkt->pts += pkt->duration;
1031     //                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);
1032                 }
1033             }
1034
1035             /* presentation is not delayed : PTS and DTS are the same */
1036             if(pkt->pts == AV_NOPTS_VALUE)
1037                 pkt->pts = pkt->dts;
1038             update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
1039             if(pkt->pts == AV_NOPTS_VALUE)
1040                 pkt->pts = st->cur_dts;
1041             pkt->dts = pkt->pts;
1042             if(pkt->pts != AV_NOPTS_VALUE)
1043                 st->cur_dts = pkt->pts + pkt->duration;
1044         }
1045     }
1046
1047     if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
1048         st->pts_buffer[0]= pkt->pts;
1049         for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
1050             FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
1051         if(pkt->dts == AV_NOPTS_VALUE)
1052             pkt->dts= st->pts_buffer[0];
1053         if(st->codec->codec_id == CODEC_ID_H264){ //we skiped it above so we try here
1054             update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
1055         }
1056         if(pkt->dts > st->cur_dts)
1057             st->cur_dts = pkt->dts;
1058     }
1059
1060 //    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);
1061
1062     /* update flags */
1063     if(is_intra_only(st->codec))
1064         pkt->flags |= AV_PKT_FLAG_KEY;
1065     else if (pc) {
1066         pkt->flags = 0;
1067         /* keyframe computation */
1068         if (pc->key_frame == 1)
1069             pkt->flags |= AV_PKT_FLAG_KEY;
1070         else if (pc->key_frame == -1 && pc->pict_type == FF_I_TYPE)
1071             pkt->flags |= AV_PKT_FLAG_KEY;
1072     }
1073     if (pc)
1074         pkt->convergence_duration = pc->convergence_duration;
1075 }
1076
1077
1078 static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1079 {
1080     AVStream *st;
1081     int len, ret, i;
1082
1083     av_init_packet(pkt);
1084
1085     for(;;) {
1086         /* select current input stream component */
1087         st = s->cur_st;
1088         if (st) {
1089             if (!st->need_parsing || !st->parser) {
1090                 /* no parsing needed: we just output the packet as is */
1091                 /* raw data support */
1092                 *pkt = st->cur_pkt; st->cur_pkt.data= NULL;
1093                 compute_pkt_fields(s, st, NULL, pkt);
1094                 s->cur_st = NULL;
1095                 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1096                     (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1097                     ff_reduce_index(s, st->index);
1098                     av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1099                 }
1100                 break;
1101             } else if (st->cur_len > 0 && st->discard < AVDISCARD_ALL) {
1102                 len = av_parser_parse2(st->parser, st->codec, &pkt->data, &pkt->size,
1103                                        st->cur_ptr, st->cur_len,
1104                                        st->cur_pkt.pts, st->cur_pkt.dts,
1105                                        st->cur_pkt.pos);
1106                 st->cur_pkt.pts = AV_NOPTS_VALUE;
1107                 st->cur_pkt.dts = AV_NOPTS_VALUE;
1108                 /* increment read pointer */
1109                 st->cur_ptr += len;
1110                 st->cur_len -= len;
1111
1112                 /* return packet if any */
1113                 if (pkt->size) {
1114                 got_packet:
1115                     pkt->duration = 0;
1116                     pkt->stream_index = st->index;
1117                     pkt->pts = st->parser->pts;
1118                     pkt->dts = st->parser->dts;
1119                     pkt->pos = st->parser->pos;
1120                     if(pkt->data == st->cur_pkt.data && pkt->size == st->cur_pkt.size){
1121                         s->cur_st = NULL;
1122                         pkt->destruct= st->cur_pkt.destruct;
1123                         st->cur_pkt.destruct= NULL;
1124                         st->cur_pkt.data    = NULL;
1125                         assert(st->cur_len == 0);
1126                     }else{
1127                     pkt->destruct = NULL;
1128                     }
1129                     compute_pkt_fields(s, st, st->parser, pkt);
1130
1131                     if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY){
1132                         ff_reduce_index(s, st->index);
1133                         av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
1134                                            0, 0, AVINDEX_KEYFRAME);
1135                     }
1136
1137                     break;
1138                 }
1139             } else {
1140                 /* free packet */
1141                 av_free_packet(&st->cur_pkt);
1142                 s->cur_st = NULL;
1143             }
1144         } else {
1145             AVPacket cur_pkt;
1146             /* read next packet */
1147             ret = av_read_packet(s, &cur_pkt);
1148             if (ret < 0) {
1149                 if (ret == AVERROR(EAGAIN))
1150                     return ret;
1151                 /* return the last frames, if any */
1152                 for(i = 0; i < s->nb_streams; i++) {
1153                     st = s->streams[i];
1154                     if (st->parser && st->need_parsing) {
1155                         av_parser_parse2(st->parser, st->codec,
1156                                         &pkt->data, &pkt->size,
1157                                         NULL, 0,
1158                                         AV_NOPTS_VALUE, AV_NOPTS_VALUE,
1159                                         AV_NOPTS_VALUE);
1160                         if (pkt->size)
1161                             goto got_packet;
1162                     }
1163                 }
1164                 /* no more packets: really terminate parsing */
1165                 return ret;
1166             }
1167             st = s->streams[cur_pkt.stream_index];
1168             st->cur_pkt= cur_pkt;
1169
1170             if(st->cur_pkt.pts != AV_NOPTS_VALUE &&
1171                st->cur_pkt.dts != AV_NOPTS_VALUE &&
1172                st->cur_pkt.pts < st->cur_pkt.dts){
1173                 av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
1174                     st->cur_pkt.stream_index,
1175                     st->cur_pkt.pts,
1176                     st->cur_pkt.dts,
1177                     st->cur_pkt.size);
1178 //                av_free_packet(&st->cur_pkt);
1179 //                return -1;
1180             }
1181
1182             if(s->debug & FF_FDEBUG_TS)
1183                 av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1184                     st->cur_pkt.stream_index,
1185                     st->cur_pkt.pts,
1186                     st->cur_pkt.dts,
1187                     st->cur_pkt.size,
1188                     st->cur_pkt.duration,
1189                     st->cur_pkt.flags);
1190
1191             s->cur_st = st;
1192             st->cur_ptr = st->cur_pkt.data;
1193             st->cur_len = st->cur_pkt.size;
1194             if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1195                 st->parser = av_parser_init(st->codec->codec_id);
1196                 if (!st->parser) {
1197                     /* no parser available: just output the raw packets */
1198                     st->need_parsing = AVSTREAM_PARSE_NONE;
1199                 }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
1200                     st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1201                 }else if(st->need_parsing == AVSTREAM_PARSE_FULL_ONCE){
1202                     st->parser->flags |= PARSER_FLAG_ONCE;
1203                 }
1204             }
1205         }
1206     }
1207     if(s->debug & FF_FDEBUG_TS)
1208         av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1209             pkt->stream_index,
1210             pkt->pts,
1211             pkt->dts,
1212             pkt->size,
1213             pkt->duration,
1214             pkt->flags);
1215
1216     return 0;
1217 }
1218
1219 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1220 {
1221     AVPacketList *pktl;
1222     int eof=0;
1223     const int genpts= s->flags & AVFMT_FLAG_GENPTS;
1224
1225     for(;;){
1226         pktl = s->packet_buffer;
1227         if (pktl) {
1228             AVPacket *next_pkt= &pktl->pkt;
1229
1230             if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
1231                 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1232                 while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
1233                     if(   pktl->pkt.stream_index == next_pkt->stream_index
1234                        && (0 > av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)))
1235                        && av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) { //not b frame
1236                         next_pkt->pts= pktl->pkt.dts;
1237                     }
1238                     pktl= pktl->next;
1239                 }
1240                 pktl = s->packet_buffer;
1241             }
1242
1243             if(   next_pkt->pts != AV_NOPTS_VALUE
1244                || next_pkt->dts == AV_NOPTS_VALUE
1245                || !genpts || eof){
1246                 /* read packet from packet buffer, if there is data */
1247                 *pkt = *next_pkt;
1248                 s->packet_buffer = pktl->next;
1249                 av_free(pktl);
1250                 return 0;
1251             }
1252         }
1253         if(genpts){
1254             int ret= av_read_frame_internal(s, pkt);
1255             if(ret<0){
1256                 if(pktl && ret != AVERROR(EAGAIN)){
1257                     eof=1;
1258                     continue;
1259                 }else
1260                     return ret;
1261             }
1262
1263             if(av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1264                                            &s->packet_buffer_end)) < 0)
1265                 return AVERROR(ENOMEM);
1266         }else{
1267             assert(!s->packet_buffer);
1268             return av_read_frame_internal(s, pkt);
1269         }
1270     }
1271 }
1272
1273 /* XXX: suppress the packet queue */
1274 static void flush_packet_queue(AVFormatContext *s)
1275 {
1276     AVPacketList *pktl;
1277
1278     for(;;) {
1279         pktl = s->packet_buffer;
1280         if (!pktl)
1281             break;
1282         s->packet_buffer = pktl->next;
1283         av_free_packet(&pktl->pkt);
1284         av_free(pktl);
1285     }
1286     while(s->raw_packet_buffer){
1287         pktl = s->raw_packet_buffer;
1288         s->raw_packet_buffer = pktl->next;
1289         av_free_packet(&pktl->pkt);
1290         av_free(pktl);
1291     }
1292     s->packet_buffer_end=
1293     s->raw_packet_buffer_end= NULL;
1294     s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1295 }
1296
1297 /*******************************************************/
1298 /* seek support */
1299
1300 int av_find_default_stream_index(AVFormatContext *s)
1301 {
1302     int first_audio_index = -1;
1303     int i;
1304     AVStream *st;
1305
1306     if (s->nb_streams <= 0)
1307         return -1;
1308     for(i = 0; i < s->nb_streams; i++) {
1309         st = s->streams[i];
1310         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1311             return i;
1312         }
1313         if (first_audio_index < 0 && st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1314             first_audio_index = i;
1315     }
1316     return first_audio_index >= 0 ? first_audio_index : 0;
1317 }
1318
1319 /**
1320  * Flush the frame reader.
1321  */
1322 void ff_read_frame_flush(AVFormatContext *s)
1323 {
1324     AVStream *st;
1325     int i, j;
1326
1327     flush_packet_queue(s);
1328
1329     s->cur_st = NULL;
1330
1331     /* for each stream, reset read state */
1332     for(i = 0; i < s->nb_streams; i++) {
1333         st = s->streams[i];
1334
1335         if (st->parser) {
1336             av_parser_close(st->parser);
1337             st->parser = NULL;
1338             av_free_packet(&st->cur_pkt);
1339         }
1340         st->last_IP_pts = AV_NOPTS_VALUE;
1341         st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1342         st->reference_dts = AV_NOPTS_VALUE;
1343         /* fail safe */
1344         st->cur_ptr = NULL;
1345         st->cur_len = 0;
1346
1347         st->probe_packets = MAX_PROBE_PACKETS;
1348
1349         for(j=0; j<MAX_REORDER_DELAY+1; j++)
1350             st->pts_buffer[j]= AV_NOPTS_VALUE;
1351     }
1352 }
1353
1354 void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1355     int i;
1356
1357     for(i = 0; i < s->nb_streams; i++) {
1358         AVStream *st = s->streams[i];
1359
1360         st->cur_dts = av_rescale(timestamp,
1361                                  st->time_base.den * (int64_t)ref_st->time_base.num,
1362                                  st->time_base.num * (int64_t)ref_st->time_base.den);
1363     }
1364 }
1365
1366 void ff_reduce_index(AVFormatContext *s, int stream_index)
1367 {
1368     AVStream *st= s->streams[stream_index];
1369     unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1370
1371     if((unsigned)st->nb_index_entries >= max_entries){
1372         int i;
1373         for(i=0; 2*i<st->nb_index_entries; i++)
1374             st->index_entries[i]= st->index_entries[2*i];
1375         st->nb_index_entries= i;
1376     }
1377 }
1378
1379 int ff_add_index_entry(AVIndexEntry **index_entries,
1380                        int *nb_index_entries,
1381                        unsigned int *index_entries_allocated_size,
1382                        int64_t pos, int64_t timestamp, int size, int distance, int flags)
1383 {
1384     AVIndexEntry *entries, *ie;
1385     int index;
1386
1387     if((unsigned)*nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1388         return -1;
1389
1390     entries = av_fast_realloc(*index_entries,
1391                               index_entries_allocated_size,
1392                               (*nb_index_entries + 1) *
1393                               sizeof(AVIndexEntry));
1394     if(!entries)
1395         return -1;
1396
1397     *index_entries= entries;
1398
1399     index= ff_index_search_timestamp(*index_entries, *nb_index_entries, timestamp, AVSEEK_FLAG_ANY);
1400
1401     if(index<0){
1402         index= (*nb_index_entries)++;
1403         ie= &entries[index];
1404         assert(index==0 || ie[-1].timestamp < timestamp);
1405     }else{
1406         ie= &entries[index];
1407         if(ie->timestamp != timestamp){
1408             if(ie->timestamp <= timestamp)
1409                 return -1;
1410             memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(*nb_index_entries - index));
1411             (*nb_index_entries)++;
1412         }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1413             distance= ie->min_distance;
1414     }
1415
1416     ie->pos = pos;
1417     ie->timestamp = timestamp;
1418     ie->min_distance= distance;
1419     ie->size= size;
1420     ie->flags = flags;
1421
1422     return index;
1423 }
1424
1425 int av_add_index_entry(AVStream *st,
1426                        int64_t pos, int64_t timestamp, int size, int distance, int flags)
1427 {
1428     return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1429                               &st->index_entries_allocated_size, pos,
1430                               timestamp, size, distance, flags);
1431 }
1432
1433 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1434                               int64_t wanted_timestamp, int flags)
1435 {
1436     int a, b, m;
1437     int64_t timestamp;
1438
1439     a = - 1;
1440     b = nb_entries;
1441
1442     //optimize appending index entries at the end
1443     if(b && entries[b-1].timestamp < wanted_timestamp)
1444         a= b-1;
1445
1446     while (b - a > 1) {
1447         m = (a + b) >> 1;
1448         timestamp = entries[m].timestamp;
1449         if(timestamp >= wanted_timestamp)
1450             b = m;
1451         if(timestamp <= wanted_timestamp)
1452             a = m;
1453     }
1454     m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1455
1456     if(!(flags & AVSEEK_FLAG_ANY)){
1457         while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1458             m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1459         }
1460     }
1461
1462     if(m == nb_entries)
1463         return -1;
1464     return  m;
1465 }
1466
1467 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1468                               int flags)
1469 {
1470     return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
1471                                      wanted_timestamp, flags);
1472 }
1473
1474 #define DEBUG_SEEK
1475
1476 int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1477     AVInputFormat *avif= s->iformat;
1478     int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1479     int64_t ts_min, ts_max, ts;
1480     int index;
1481     int64_t ret;
1482     AVStream *st;
1483
1484     if (stream_index < 0)
1485         return -1;
1486
1487 #ifdef DEBUG_SEEK
1488     av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1489 #endif
1490
1491     ts_max=
1492     ts_min= AV_NOPTS_VALUE;
1493     pos_limit= -1; //gcc falsely says it may be uninitialized
1494
1495     st= s->streams[stream_index];
1496     if(st->index_entries){
1497         AVIndexEntry *e;
1498
1499         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()
1500         index= FFMAX(index, 0);
1501         e= &st->index_entries[index];
1502
1503         if(e->timestamp <= target_ts || e->pos == e->min_distance){
1504             pos_min= e->pos;
1505             ts_min= e->timestamp;
1506 #ifdef DEBUG_SEEK
1507             av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1508                    pos_min,ts_min);
1509 #endif
1510         }else{
1511             assert(index==0);
1512         }
1513
1514         index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1515         assert(index < st->nb_index_entries);
1516         if(index >= 0){
1517             e= &st->index_entries[index];
1518             assert(e->timestamp >= target_ts);
1519             pos_max= e->pos;
1520             ts_max= e->timestamp;
1521             pos_limit= pos_max - e->min_distance;
1522 #ifdef DEBUG_SEEK
1523             av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1524                    pos_max,pos_limit, ts_max);
1525 #endif
1526         }
1527     }
1528
1529     pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1530     if(pos<0)
1531         return -1;
1532
1533     /* do the seek */
1534     if ((ret = url_fseek(s->pb, pos, SEEK_SET)) < 0)
1535         return ret;
1536
1537     av_update_cur_dts(s, st, ts);
1538
1539     return 0;
1540 }
1541
1542 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 )){
1543     int64_t pos, ts;
1544     int64_t start_pos, filesize;
1545     int no_change;
1546
1547 #ifdef DEBUG_SEEK
1548     av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1549 #endif
1550
1551     if(ts_min == AV_NOPTS_VALUE){
1552         pos_min = s->data_offset;
1553         ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1554         if (ts_min == AV_NOPTS_VALUE)
1555             return -1;
1556     }
1557
1558     if(ts_max == AV_NOPTS_VALUE){
1559         int step= 1024;
1560         filesize = url_fsize(s->pb);
1561         pos_max = filesize - 1;
1562         do{
1563             pos_max -= step;
1564             ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1565             step += step;
1566         }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1567         if (ts_max == AV_NOPTS_VALUE)
1568             return -1;
1569
1570         for(;;){
1571             int64_t tmp_pos= pos_max + 1;
1572             int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1573             if(tmp_ts == AV_NOPTS_VALUE)
1574                 break;
1575             ts_max= tmp_ts;
1576             pos_max= tmp_pos;
1577             if(tmp_pos >= filesize)
1578                 break;
1579         }
1580         pos_limit= pos_max;
1581     }
1582
1583     if(ts_min > ts_max){
1584         return -1;
1585     }else if(ts_min == ts_max){
1586         pos_limit= pos_min;
1587     }
1588
1589     no_change=0;
1590     while (pos_min < pos_limit) {
1591 #ifdef DEBUG_SEEK
1592         av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1593                pos_min, pos_max,
1594                ts_min, ts_max);
1595 #endif
1596         assert(pos_limit <= pos_max);
1597
1598         if(no_change==0){
1599             int64_t approximate_keyframe_distance= pos_max - pos_limit;
1600             // interpolate position (better than dichotomy)
1601             pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1602                 + pos_min - approximate_keyframe_distance;
1603         }else if(no_change==1){
1604             // bisection, if interpolation failed to change min or max pos last time
1605             pos = (pos_min + pos_limit)>>1;
1606         }else{
1607             /* linear search if bisection failed, can only happen if there
1608                are very few or no keyframes between min/max */
1609             pos=pos_min;
1610         }
1611         if(pos <= pos_min)
1612             pos= pos_min + 1;
1613         else if(pos > pos_limit)
1614             pos= pos_limit;
1615         start_pos= pos;
1616
1617         ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1618         if(pos == pos_max)
1619             no_change++;
1620         else
1621             no_change=0;
1622 #ifdef DEBUG_SEEK
1623         av_log(s, AV_LOG_DEBUG, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64" target:%"PRId64" limit:%"PRId64" start:%"PRId64" noc:%d\n",
1624                pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts, pos_limit,
1625                start_pos, no_change);
1626 #endif
1627         if(ts == AV_NOPTS_VALUE){
1628             av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1629             return -1;
1630         }
1631         assert(ts != AV_NOPTS_VALUE);
1632         if (target_ts <= ts) {
1633             pos_limit = start_pos - 1;
1634             pos_max = pos;
1635             ts_max = ts;
1636         }
1637         if (target_ts >= ts) {
1638             pos_min = pos;
1639             ts_min = ts;
1640         }
1641     }
1642
1643     pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1644     ts  = (flags & AVSEEK_FLAG_BACKWARD) ?  ts_min :  ts_max;
1645 #ifdef DEBUG_SEEK
1646     pos_min = pos;
1647     ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1648     pos_min++;
1649     ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1650     av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1651            pos, ts_min, target_ts, ts_max);
1652 #endif
1653     *ts_ret= ts;
1654     return pos;
1655 }
1656
1657 static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1658     int64_t pos_min, pos_max;
1659 #if 0
1660     AVStream *st;
1661
1662     if (stream_index < 0)
1663         return -1;
1664
1665     st= s->streams[stream_index];
1666 #endif
1667
1668     pos_min = s->data_offset;
1669     pos_max = url_fsize(s->pb) - 1;
1670
1671     if     (pos < pos_min) pos= pos_min;
1672     else if(pos > pos_max) pos= pos_max;
1673
1674     url_fseek(s->pb, pos, SEEK_SET);
1675
1676 #if 0
1677     av_update_cur_dts(s, st, ts);
1678 #endif
1679     return 0;
1680 }
1681
1682 static int av_seek_frame_generic(AVFormatContext *s,
1683                                  int stream_index, int64_t timestamp, int flags)
1684 {
1685     int index;
1686     int64_t ret;
1687     AVStream *st;
1688     AVIndexEntry *ie;
1689
1690     st = s->streams[stream_index];
1691
1692     index = av_index_search_timestamp(st, timestamp, flags);
1693
1694     if(index < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
1695         return -1;
1696
1697     if(index < 0 || index==st->nb_index_entries-1){
1698         int i;
1699         AVPacket pkt;
1700
1701         if(st->nb_index_entries){
1702             assert(st->index_entries);
1703             ie= &st->index_entries[st->nb_index_entries-1];
1704             if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
1705                 return ret;
1706             av_update_cur_dts(s, st, ie->timestamp);
1707         }else{
1708             if ((ret = url_fseek(s->pb, s->data_offset, SEEK_SET)) < 0)
1709                 return ret;
1710         }
1711         for(i=0;; i++) {
1712             int ret;
1713             do{
1714                 ret = av_read_frame(s, &pkt);
1715             }while(ret == AVERROR(EAGAIN));
1716             if(ret<0)
1717                 break;
1718             av_free_packet(&pkt);
1719             if(stream_index == pkt.stream_index){
1720                 if((pkt.flags & AV_PKT_FLAG_KEY) && pkt.dts > timestamp)
1721                     break;
1722             }
1723         }
1724         index = av_index_search_timestamp(st, timestamp, flags);
1725     }
1726     if (index < 0)
1727         return -1;
1728
1729     ff_read_frame_flush(s);
1730     if (s->iformat->read_seek){
1731         if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1732             return 0;
1733     }
1734     ie = &st->index_entries[index];
1735     if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
1736         return ret;
1737     av_update_cur_dts(s, st, ie->timestamp);
1738
1739     return 0;
1740 }
1741
1742 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1743 {
1744     int ret;
1745     AVStream *st;
1746
1747     ff_read_frame_flush(s);
1748
1749     if(flags & AVSEEK_FLAG_BYTE)
1750         return av_seek_frame_byte(s, stream_index, timestamp, flags);
1751
1752     if(stream_index < 0){
1753         stream_index= av_find_default_stream_index(s);
1754         if(stream_index < 0)
1755             return -1;
1756
1757         st= s->streams[stream_index];
1758        /* timestamp for default must be expressed in AV_TIME_BASE units */
1759         timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1760     }
1761
1762     /* first, we try the format specific seek */
1763     if (s->iformat->read_seek)
1764         ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1765     else
1766         ret = -1;
1767     if (ret >= 0) {
1768         return 0;
1769     }
1770
1771     if(s->iformat->read_timestamp)
1772         return av_seek_frame_binary(s, stream_index, timestamp, flags);
1773     else
1774         return av_seek_frame_generic(s, stream_index, timestamp, flags);
1775 }
1776
1777 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
1778 {
1779     if(min_ts > ts || max_ts < ts)
1780         return -1;
1781
1782     ff_read_frame_flush(s);
1783
1784     if (s->iformat->read_seek2)
1785         return s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
1786
1787     if(s->iformat->read_timestamp){
1788         //try to seek via read_timestamp()
1789     }
1790
1791     //Fallback to old API if new is not implemented but old is
1792     //Note the old has somewat different sematics
1793     if(s->iformat->read_seek || 1)
1794         return av_seek_frame(s, stream_index, ts, flags | (ts - min_ts > (uint64_t)(max_ts - ts) ? AVSEEK_FLAG_BACKWARD : 0));
1795
1796     // try some generic seek like av_seek_frame_generic() but with new ts semantics
1797 }
1798
1799 /*******************************************************/
1800
1801 /**
1802  * Return TRUE if the stream has accurate duration in any stream.
1803  *
1804  * @return TRUE if the stream has accurate duration for at least one component.
1805  */
1806 static int av_has_duration(AVFormatContext *ic)
1807 {
1808     int i;
1809     AVStream *st;
1810
1811     for(i = 0;i < ic->nb_streams; i++) {
1812         st = ic->streams[i];
1813         if (st->duration != AV_NOPTS_VALUE)
1814             return 1;
1815     }
1816     return 0;
1817 }
1818
1819 /**
1820  * Estimate the stream timings from the one of each components.
1821  *
1822  * Also computes the global bitrate if possible.
1823  */
1824 static void av_update_stream_timings(AVFormatContext *ic)
1825 {
1826     int64_t start_time, start_time1, end_time, end_time1;
1827     int64_t duration, duration1;
1828     int i;
1829     AVStream *st;
1830
1831     start_time = INT64_MAX;
1832     end_time = INT64_MIN;
1833     duration = INT64_MIN;
1834     for(i = 0;i < ic->nb_streams; i++) {
1835         st = ic->streams[i];
1836         if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
1837             start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1838             if (start_time1 < start_time)
1839                 start_time = start_time1;
1840             if (st->duration != AV_NOPTS_VALUE) {
1841                 end_time1 = start_time1
1842                           + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1843                 if (end_time1 > end_time)
1844                     end_time = end_time1;
1845             }
1846         }
1847         if (st->duration != AV_NOPTS_VALUE) {
1848             duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1849             if (duration1 > duration)
1850                 duration = duration1;
1851         }
1852     }
1853     if (start_time != INT64_MAX) {
1854         ic->start_time = start_time;
1855         if (end_time != INT64_MIN) {
1856             if (end_time - start_time > duration)
1857                 duration = end_time - start_time;
1858         }
1859     }
1860     if (duration != INT64_MIN) {
1861         ic->duration = duration;
1862         if (ic->file_size > 0) {
1863             /* compute the bitrate */
1864             ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1865                 (double)ic->duration;
1866         }
1867     }
1868 }
1869
1870 static void fill_all_stream_timings(AVFormatContext *ic)
1871 {
1872     int i;
1873     AVStream *st;
1874
1875     av_update_stream_timings(ic);
1876     for(i = 0;i < ic->nb_streams; i++) {
1877         st = ic->streams[i];
1878         if (st->start_time == AV_NOPTS_VALUE) {
1879             if(ic->start_time != AV_NOPTS_VALUE)
1880                 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1881             if(ic->duration != AV_NOPTS_VALUE)
1882                 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1883         }
1884     }
1885 }
1886
1887 static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1888 {
1889     int64_t filesize, duration;
1890     int bit_rate, i;
1891     AVStream *st;
1892
1893     /* if bit_rate is already set, we believe it */
1894     if (ic->bit_rate <= 0) {
1895         bit_rate = 0;
1896         for(i=0;i<ic->nb_streams;i++) {
1897             st = ic->streams[i];
1898             if (st->codec->bit_rate > 0)
1899             bit_rate += st->codec->bit_rate;
1900         }
1901         ic->bit_rate = bit_rate;
1902     }
1903
1904     /* if duration is already set, we believe it */
1905     if (ic->duration == AV_NOPTS_VALUE &&
1906         ic->bit_rate != 0 &&
1907         ic->file_size != 0)  {
1908         filesize = ic->file_size;
1909         if (filesize > 0) {
1910             for(i = 0; i < ic->nb_streams; i++) {
1911                 st = ic->streams[i];
1912                 duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1913                 if (st->duration == AV_NOPTS_VALUE)
1914                     st->duration = duration;
1915             }
1916         }
1917     }
1918 }
1919
1920 #define DURATION_MAX_READ_SIZE 250000
1921 #define DURATION_MAX_RETRY 3
1922
1923 /* only usable for MPEG-PS streams */
1924 static void av_estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
1925 {
1926     AVPacket pkt1, *pkt = &pkt1;
1927     AVStream *st;
1928     int read_size, i, ret;
1929     int64_t end_time;
1930     int64_t filesize, offset, duration;
1931     int retry=0;
1932
1933     ic->cur_st = NULL;
1934
1935     /* flush packet queue */
1936     flush_packet_queue(ic);
1937
1938     for (i=0; i<ic->nb_streams; i++) {
1939         st = ic->streams[i];
1940         if (st->start_time == AV_NOPTS_VALUE && st->first_dts == AV_NOPTS_VALUE)
1941             av_log(st->codec, AV_LOG_WARNING, "start time is not set in av_estimate_timings_from_pts\n");
1942
1943         if (st->parser) {
1944             av_parser_close(st->parser);
1945             st->parser= NULL;
1946             av_free_packet(&st->cur_pkt);
1947         }
1948     }
1949
1950     /* estimate the end time (duration) */
1951     /* XXX: may need to support wrapping */
1952     filesize = ic->file_size;
1953     end_time = AV_NOPTS_VALUE;
1954     do{
1955     offset = filesize - (DURATION_MAX_READ_SIZE<<retry);
1956     if (offset < 0)
1957         offset = 0;
1958
1959     url_fseek(ic->pb, offset, SEEK_SET);
1960     read_size = 0;
1961     for(;;) {
1962         if (read_size >= DURATION_MAX_READ_SIZE<<(FFMAX(retry-1,0)))
1963             break;
1964
1965         do{
1966             ret = av_read_packet(ic, pkt);
1967         }while(ret == AVERROR(EAGAIN));
1968         if (ret != 0)
1969             break;
1970         read_size += pkt->size;
1971         st = ic->streams[pkt->stream_index];
1972         if (pkt->pts != AV_NOPTS_VALUE &&
1973             (st->start_time != AV_NOPTS_VALUE ||
1974              st->first_dts  != AV_NOPTS_VALUE)) {
1975             duration = end_time = pkt->pts;
1976             if (st->start_time != AV_NOPTS_VALUE)  duration -= st->start_time;
1977             else                                   duration -= st->first_dts;
1978             if (duration < 0)
1979                 duration += 1LL<<st->pts_wrap_bits;
1980             if (duration > 0) {
1981                 if (st->duration == AV_NOPTS_VALUE ||
1982                     st->duration < duration)
1983                     st->duration = duration;
1984             }
1985         }
1986         av_free_packet(pkt);
1987     }
1988     }while(   end_time==AV_NOPTS_VALUE
1989            && filesize > (DURATION_MAX_READ_SIZE<<retry)
1990            && ++retry <= DURATION_MAX_RETRY);
1991
1992     fill_all_stream_timings(ic);
1993
1994     url_fseek(ic->pb, old_offset, SEEK_SET);
1995     for (i=0; i<ic->nb_streams; i++) {
1996         st= ic->streams[i];
1997         st->cur_dts= st->first_dts;
1998         st->last_IP_pts = AV_NOPTS_VALUE;
1999     }
2000 }
2001
2002 static void av_estimate_timings(AVFormatContext *ic, int64_t old_offset)
2003 {
2004     int64_t file_size;
2005
2006     /* get the file size, if possible */
2007     if (ic->iformat->flags & AVFMT_NOFILE) {
2008         file_size = 0;
2009     } else {
2010         file_size = url_fsize(ic->pb);
2011         if (file_size < 0)
2012             file_size = 0;
2013     }
2014     ic->file_size = file_size;
2015
2016     if ((!strcmp(ic->iformat->name, "mpeg") ||
2017          !strcmp(ic->iformat->name, "mpegts")) &&
2018         file_size && !url_is_streamed(ic->pb)) {
2019         /* get accurate estimate from the PTSes */
2020         av_estimate_timings_from_pts(ic, old_offset);
2021     } else if (av_has_duration(ic)) {
2022         /* at least one component has timings - we use them for all
2023            the components */
2024         fill_all_stream_timings(ic);
2025     } else {
2026         av_log(ic, AV_LOG_WARNING, "Estimating duration from bitrate, this may be inaccurate\n");
2027         /* less precise: use bitrate info */
2028         av_estimate_timings_from_bit_rate(ic);
2029     }
2030     av_update_stream_timings(ic);
2031
2032 #if 0
2033     {
2034         int i;
2035         AVStream *st;
2036         for(i = 0;i < ic->nb_streams; i++) {
2037             st = ic->streams[i];
2038         printf("%d: start_time: %0.3f duration: %0.3f\n",
2039                i, (double)st->start_time / AV_TIME_BASE,
2040                (double)st->duration / AV_TIME_BASE);
2041         }
2042         printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2043                (double)ic->start_time / AV_TIME_BASE,
2044                (double)ic->duration / AV_TIME_BASE,
2045                ic->bit_rate / 1000);
2046     }
2047 #endif
2048 }
2049
2050 static int has_codec_parameters(AVCodecContext *enc)
2051 {
2052     int val;
2053     switch(enc->codec_type) {
2054     case AVMEDIA_TYPE_AUDIO:
2055         val = enc->sample_rate && enc->channels && enc->sample_fmt != AV_SAMPLE_FMT_NONE;
2056         if(!enc->frame_size &&
2057            (enc->codec_id == CODEC_ID_VORBIS ||
2058             enc->codec_id == CODEC_ID_AAC ||
2059             enc->codec_id == CODEC_ID_MP1 ||
2060             enc->codec_id == CODEC_ID_MP2 ||
2061             enc->codec_id == CODEC_ID_MP3 ||
2062             enc->codec_id == CODEC_ID_SPEEX))
2063             return 0;
2064         break;
2065     case AVMEDIA_TYPE_VIDEO:
2066         val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
2067         break;
2068     default:
2069         val = 1;
2070         break;
2071     }
2072     return enc->codec_id != CODEC_ID_NONE && val != 0;
2073 }
2074
2075 static int has_decode_delay_been_guessed(AVStream *st)
2076 {
2077     return st->codec->codec_id != CODEC_ID_H264 ||
2078         st->codec_info_nb_frames >= 6 + st->codec->has_b_frames;
2079 }
2080
2081 static int try_decode_frame(AVStream *st, AVPacket *avpkt)
2082 {
2083     int16_t *samples;
2084     AVCodec *codec;
2085     int got_picture, data_size, ret=0;
2086     AVFrame picture;
2087
2088     if(!st->codec->codec){
2089         codec = avcodec_find_decoder(st->codec->codec_id);
2090         if (!codec)
2091             return -1;
2092         ret = avcodec_open(st->codec, codec);
2093         if (ret < 0)
2094             return ret;
2095     }
2096
2097     if(!has_codec_parameters(st->codec) || !has_decode_delay_been_guessed(st)){
2098         switch(st->codec->codec_type) {
2099         case AVMEDIA_TYPE_VIDEO:
2100             avcodec_get_frame_defaults(&picture);
2101             ret = avcodec_decode_video2(st->codec, &picture,
2102                                         &got_picture, avpkt);
2103             break;
2104         case AVMEDIA_TYPE_AUDIO:
2105             data_size = FFMAX(avpkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
2106             samples = av_malloc(data_size);
2107             if (!samples)
2108                 goto fail;
2109             ret = avcodec_decode_audio3(st->codec, samples,
2110                                         &data_size, avpkt);
2111             av_free(samples);
2112             break;
2113         default:
2114             break;
2115         }
2116     }
2117  fail:
2118     return ret;
2119 }
2120
2121 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum CodecID id)
2122 {
2123     while (tags->id != CODEC_ID_NONE) {
2124         if (tags->id == id)
2125             return tags->tag;
2126         tags++;
2127     }
2128     return 0;
2129 }
2130
2131 enum CodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2132 {
2133     int i;
2134     for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
2135         if(tag == tags[i].tag)
2136             return tags[i].id;
2137     }
2138     for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
2139         if (ff_toupper4(tag) == ff_toupper4(tags[i].tag))
2140             return tags[i].id;
2141     }
2142     return CODEC_ID_NONE;
2143 }
2144
2145 unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum CodecID id)
2146 {
2147     int i;
2148     for(i=0; tags && tags[i]; i++){
2149         int tag= ff_codec_get_tag(tags[i], id);
2150         if(tag) return tag;
2151     }
2152     return 0;
2153 }
2154
2155 enum CodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
2156 {
2157     int i;
2158     for(i=0; tags && tags[i]; i++){
2159         enum CodecID id= ff_codec_get_id(tags[i], tag);
2160         if(id!=CODEC_ID_NONE) return id;
2161     }
2162     return CODEC_ID_NONE;
2163 }
2164
2165 static void compute_chapters_end(AVFormatContext *s)
2166 {
2167     unsigned int i;
2168
2169     for (i=0; i+1<s->nb_chapters; i++)
2170         if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2171             assert(s->chapters[i]->start <= s->chapters[i+1]->start);
2172             assert(!av_cmp_q(s->chapters[i]->time_base, s->chapters[i+1]->time_base));
2173             s->chapters[i]->end = s->chapters[i+1]->start;
2174         }
2175
2176     if (s->nb_chapters && s->chapters[i]->end == AV_NOPTS_VALUE) {
2177         assert(s->start_time != AV_NOPTS_VALUE);
2178         assert(s->duration > 0);
2179         s->chapters[i]->end = av_rescale_q(s->start_time + s->duration,
2180                                            AV_TIME_BASE_Q,
2181                                            s->chapters[i]->time_base);
2182     }
2183 }
2184
2185 static int get_std_framerate(int i){
2186     if(i<60*12) return i*1001;
2187     else        return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
2188 }
2189
2190 /*
2191  * Is the time base unreliable.
2192  * This is a heuristic to balance between quick acceptance of the values in
2193  * the headers vs. some extra checks.
2194  * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2195  * MPEG-2 commonly misuses field repeat flags to store different framerates.
2196  * And there are "variable" fps files this needs to detect as well.
2197  */
2198 static int tb_unreliable(AVCodecContext *c){
2199     if(   c->time_base.den >= 101L*c->time_base.num
2200        || c->time_base.den <    5L*c->time_base.num
2201 /*       || c->codec_tag == AV_RL32("DIVX")
2202        || c->codec_tag == AV_RL32("XVID")*/
2203        || c->codec_id == CODEC_ID_MPEG2VIDEO
2204        || c->codec_id == CODEC_ID_H264
2205        )
2206         return 1;
2207     return 0;
2208 }
2209
2210 int av_find_stream_info(AVFormatContext *ic)
2211 {
2212     int i, count, ret, read_size, j;
2213     AVStream *st;
2214     AVPacket pkt1, *pkt;
2215     int64_t old_offset = url_ftell(ic->pb);
2216
2217     for(i=0;i<ic->nb_streams;i++) {
2218         AVCodec *codec;
2219         st = ic->streams[i];
2220         if (st->codec->codec_id == CODEC_ID_AAC) {
2221             st->codec->sample_rate = 0;
2222             st->codec->frame_size = 0;
2223             st->codec->channels = 0;
2224         }
2225         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2226             st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2227 /*            if(!st->time_base.num)
2228                 st->time_base= */
2229             if(!st->codec->time_base.num)
2230                 st->codec->time_base= st->time_base;
2231         }
2232         //only for the split stuff
2233         if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
2234             st->parser = av_parser_init(st->codec->codec_id);
2235             if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
2236                 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2237             }
2238         }
2239         assert(!st->codec->codec);
2240         codec = avcodec_find_decoder(st->codec->codec_id);
2241
2242         /* Force decoding of at least one frame of codec data
2243          * this makes sure the codec initializes the channel configuration
2244          * and does not trust the values from the container.
2245          */
2246         if (codec && codec->capabilities & CODEC_CAP_CHANNEL_CONF)
2247             st->codec->channels = 0;
2248
2249         /* Ensure that subtitle_header is properly set. */
2250         if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
2251             && codec && !st->codec->codec)
2252             avcodec_open(st->codec, codec);
2253
2254         //try to just open decoders, in case this is enough to get parameters
2255         if(!has_codec_parameters(st->codec)){
2256             if (codec && !st->codec->codec)
2257                 avcodec_open(st->codec, codec);
2258         }
2259     }
2260
2261     for (i=0; i<ic->nb_streams; i++) {
2262         ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
2263     }
2264
2265     count = 0;
2266     read_size = 0;
2267     for(;;) {
2268         if(url_interrupt_cb()){
2269             ret= AVERROR(EINTR);
2270             av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2271             break;
2272         }
2273
2274         /* check if one codec still needs to be handled */
2275         for(i=0;i<ic->nb_streams;i++) {
2276             st = ic->streams[i];
2277             if (!has_codec_parameters(st->codec))
2278                 break;
2279             /* variable fps and no guess at the real fps */
2280             if(   tb_unreliable(st->codec) && !(st->r_frame_rate.num && st->avg_frame_rate.num)
2281                && st->info->duration_count<20 && st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2282                 break;
2283             if(st->parser && st->parser->parser->split && !st->codec->extradata)
2284                 break;
2285             if(st->first_dts == AV_NOPTS_VALUE)
2286                 break;
2287         }
2288         if (i == ic->nb_streams) {
2289             /* NOTE: if the format has no header, then we need to read
2290                some packets to get most of the streams, so we cannot
2291                stop here */
2292             if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2293                 /* if we found the info for all the codecs, we can stop */
2294                 ret = count;
2295                 av_log(ic, AV_LOG_DEBUG, "All info found\n");
2296                 break;
2297             }
2298         }
2299         /* we did not get all the codec info, but we read too much data */
2300         if (read_size >= ic->probesize) {
2301             ret = count;
2302             av_log(ic, AV_LOG_DEBUG, "Probe buffer size limit %d reached\n", ic->probesize);
2303             break;
2304         }
2305
2306         /* NOTE: a new stream can be added there if no header in file
2307            (AVFMTCTX_NOHEADER) */
2308         ret = av_read_frame_internal(ic, &pkt1);
2309         if (ret < 0 && ret != AVERROR(EAGAIN)) {
2310             /* EOF or error */
2311             ret = -1; /* we could not have all the codec parameters before EOF */
2312             for(i=0;i<ic->nb_streams;i++) {
2313                 st = ic->streams[i];
2314                 if (!has_codec_parameters(st->codec)){
2315                     char buf[256];
2316                     avcodec_string(buf, sizeof(buf), st->codec, 0);
2317                     av_log(ic, AV_LOG_WARNING, "Could not find codec parameters (%s)\n", buf);
2318                 } else {
2319                     ret = 0;
2320                 }
2321             }
2322             break;
2323         }
2324
2325         if (ret == AVERROR(EAGAIN))
2326             continue;
2327
2328         pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2329         if ((ret = av_dup_packet(pkt)) < 0)
2330             goto find_stream_info_err;
2331
2332         read_size += pkt->size;
2333
2334         st = ic->streams[pkt->stream_index];
2335         if (st->codec_info_nb_frames>1) {
2336             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) {
2337                 av_log(ic, AV_LOG_WARNING, "max_analyze_duration reached\n");
2338                 break;
2339             }
2340             st->info->codec_info_duration += pkt->duration;
2341         }
2342         {
2343             int64_t last = st->info->last_dts;
2344             int64_t duration= pkt->dts - last;
2345
2346             if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
2347                 double dur= duration * av_q2d(st->time_base);
2348
2349 //                if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2350 //                    av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
2351                 if (st->info->duration_count < 2)
2352                     memset(st->info->duration_error, 0, sizeof(st->info->duration_error));
2353                 for (i=1; i<FF_ARRAY_ELEMS(st->info->duration_error); i++) {
2354                     int framerate= get_std_framerate(i);
2355                     int ticks= lrintf(dur*framerate/(1001*12));
2356                     double error= dur - ticks*1001*12/(double)framerate;
2357                     st->info->duration_error[i] += error*error;
2358                 }
2359                 st->info->duration_count++;
2360                 // ignore the first 4 values, they might have some random jitter
2361                 if (st->info->duration_count > 3)
2362                     st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2363             }
2364             if (last == AV_NOPTS_VALUE || st->info->duration_count <= 1)
2365                 st->info->last_dts = pkt->dts;
2366         }
2367         if(st->parser && st->parser->parser->split && !st->codec->extradata){
2368             int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2369             if(i){
2370                 st->codec->extradata_size= i;
2371                 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2372                 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2373                 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2374             }
2375         }
2376
2377         /* if still no information, we try to open the codec and to
2378            decompress the frame. We try to avoid that in most cases as
2379            it takes longer and uses more memory. For MPEG-4, we need to
2380            decompress for QuickTime. */
2381         if (!has_codec_parameters(st->codec) || !has_decode_delay_been_guessed(st))
2382             try_decode_frame(st, pkt);
2383
2384         st->codec_info_nb_frames++;
2385         count++;
2386     }
2387
2388     // close codecs which were opened in try_decode_frame()
2389     for(i=0;i<ic->nb_streams;i++) {
2390         st = ic->streams[i];
2391         if(st->codec->codec)
2392             avcodec_close(st->codec);
2393     }
2394     for(i=0;i<ic->nb_streams;i++) {
2395         st = ic->streams[i];
2396         if (st->codec_info_nb_frames>2 && !st->avg_frame_rate.num && st->info->codec_info_duration)
2397             av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2398                      (st->codec_info_nb_frames-2)*(int64_t)st->time_base.den,
2399                       st->info->codec_info_duration*(int64_t)st->time_base.num, 60000);
2400         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2401             if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample)
2402                 st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2403
2404             // the check for tb_unreliable() is not completely correct, since this is not about handling
2405             // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2406             // ipmovie.c produces.
2407             if (tb_unreliable(st->codec) && st->info->duration_count > 15 && st->info->duration_gcd > 1 && !st->r_frame_rate.num)
2408                 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);
2409             if (st->info->duration_count && !st->r_frame_rate.num
2410                && tb_unreliable(st->codec) /*&&
2411                //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2412                st->time_base.num*duration_sum[i]/st->info->duration_count*101LL > st->time_base.den*/){
2413                 int num = 0;
2414                 double best_error= 2*av_q2d(st->time_base);
2415                 best_error = best_error*best_error*st->info->duration_count*1000*12*30;
2416
2417                 for (j=1; j<FF_ARRAY_ELEMS(st->info->duration_error); j++) {
2418                     double error = st->info->duration_error[j] * get_std_framerate(j);
2419 //                    if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2420 //                        av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
2421                     if(error < best_error){
2422                         best_error= error;
2423                         num = get_std_framerate(j);
2424                     }
2425                 }
2426                 // do not increase frame rate by more than 1 % in order to match a standard rate.
2427                 if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
2428                     av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2429             }
2430
2431             if (!st->r_frame_rate.num){
2432                 if(    st->codec->time_base.den * (int64_t)st->time_base.num
2433                     <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
2434                     st->r_frame_rate.num = st->codec->time_base.den;
2435                     st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
2436                 }else{
2437                     st->r_frame_rate.num = st->time_base.den;
2438                     st->r_frame_rate.den = st->time_base.num;
2439                 }
2440             }
2441         }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2442             if(!st->codec->bits_per_coded_sample)
2443                 st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
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, stream_number = 0;
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         AVStream *st = ic->streams[program ? program[i] : i];
2514         AVCodecContext *avctx = st->codec;
2515         if (avctx->codec_type != type)
2516             continue;
2517         if (wanted_stream_nb >= 0 && stream_number++ != wanted_stream_nb)
2518             continue;
2519         if (st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED|AV_DISPOSITION_VISUAL_IMPAIRED))
2520             continue;
2521         if (decoder_ret) {
2522             decoder = avcodec_find_decoder(ic->streams[i]->codec->codec_id);
2523             if (!decoder) {
2524                 if (ret < 0)
2525                     ret = AVERROR_DECODER_NOT_FOUND;
2526                 continue;
2527             }
2528         }
2529         if (best_count >= st->codec_info_nb_frames)
2530             continue;
2531         best_count = st->codec_info_nb_frames;
2532         ret = program ? program[i] : i;
2533         best_decoder = decoder;
2534         if (program && i == nb_streams - 1 && ret < 0) {
2535             program = NULL;
2536             nb_streams = ic->nb_streams;
2537             i = 0; /* no related stream found, try again with everything */
2538         }
2539     }
2540     if (decoder_ret)
2541         *decoder_ret = best_decoder;
2542     return ret;
2543 }
2544
2545 /*******************************************************/
2546
2547 int av_read_play(AVFormatContext *s)
2548 {
2549     if (s->iformat->read_play)
2550         return s->iformat->read_play(s);
2551     if (s->pb)
2552         return av_url_read_fpause(s->pb, 0);
2553     return AVERROR(ENOSYS);
2554 }
2555
2556 int av_read_pause(AVFormatContext *s)
2557 {
2558     if (s->iformat->read_pause)
2559         return s->iformat->read_pause(s);
2560     if (s->pb)
2561         return av_url_read_fpause(s->pb, 1);
2562     return AVERROR(ENOSYS);
2563 }
2564
2565 void av_close_input_stream(AVFormatContext *s)
2566 {
2567     flush_packet_queue(s);
2568     if (s->iformat->read_close)
2569         s->iformat->read_close(s);
2570     avformat_free_context(s);
2571 }
2572
2573 void avformat_free_context(AVFormatContext *s)
2574 {
2575     int i;
2576     AVStream *st;
2577
2578     for(i=0;i<s->nb_streams;i++) {
2579         /* free all data in a stream component */
2580         st = s->streams[i];
2581         if (st->parser) {
2582             av_parser_close(st->parser);
2583             av_free_packet(&st->cur_pkt);
2584         }
2585         av_metadata_free(&st->metadata);
2586         av_free(st->index_entries);
2587         av_free(st->codec->extradata);
2588         av_free(st->codec->subtitle_header);
2589         av_free(st->codec);
2590 #if FF_API_OLD_METADATA
2591         av_free(st->filename);
2592 #endif
2593         av_free(st->priv_data);
2594         av_free(st->info);
2595         av_free(st);
2596     }
2597     for(i=s->nb_programs-1; i>=0; i--) {
2598 #if FF_API_OLD_METADATA
2599         av_freep(&s->programs[i]->provider_name);
2600         av_freep(&s->programs[i]->name);
2601 #endif
2602         av_metadata_free(&s->programs[i]->metadata);
2603         av_freep(&s->programs[i]->stream_index);
2604         av_freep(&s->programs[i]);
2605     }
2606     av_freep(&s->programs);
2607     av_freep(&s->priv_data);
2608     while(s->nb_chapters--) {
2609 #if FF_API_OLD_METADATA
2610         av_free(s->chapters[s->nb_chapters]->title);
2611 #endif
2612         av_metadata_free(&s->chapters[s->nb_chapters]->metadata);
2613         av_free(s->chapters[s->nb_chapters]);
2614     }
2615     av_freep(&s->chapters);
2616     av_metadata_free(&s->metadata);
2617     av_freep(&s->key);
2618     av_free(s);
2619 }
2620
2621 void av_close_input_file(AVFormatContext *s)
2622 {
2623     AVIOContext *pb = s->iformat->flags & AVFMT_NOFILE ? NULL : s->pb;
2624     av_close_input_stream(s);
2625     if (pb)
2626         avio_close(pb);
2627 }
2628
2629 AVStream *av_new_stream(AVFormatContext *s, int id)
2630 {
2631     AVStream *st;
2632     int i;
2633
2634 #if FF_API_MAX_STREAMS
2635     if (s->nb_streams >= MAX_STREAMS){
2636         av_log(s, AV_LOG_ERROR, "Too many streams\n");
2637         return NULL;
2638     }
2639 #else
2640     AVStream **streams;
2641
2642     if (s->nb_streams >= INT_MAX/sizeof(*streams))
2643         return NULL;
2644     streams = av_realloc(s->streams, (s->nb_streams + 1) * sizeof(*streams));
2645     if (!streams)
2646         return NULL;
2647     s->streams = streams;
2648 #endif
2649
2650     st = av_mallocz(sizeof(AVStream));
2651     if (!st)
2652         return NULL;
2653     if (!(st->info = av_mallocz(sizeof(*st->info)))) {
2654         av_free(st);
2655         return NULL;
2656     }
2657
2658     st->codec= avcodec_alloc_context();
2659     if (s->iformat) {
2660         /* no default bitrate if decoding */
2661         st->codec->bit_rate = 0;
2662     }
2663     st->index = s->nb_streams;
2664     st->id = id;
2665     st->start_time = AV_NOPTS_VALUE;
2666     st->duration = AV_NOPTS_VALUE;
2667         /* we set the current DTS to 0 so that formats without any timestamps
2668            but durations get some timestamps, formats with some unknown
2669            timestamps have their first few packets buffered and the
2670            timestamps corrected before they are returned to the user */
2671     st->cur_dts = 0;
2672     st->first_dts = AV_NOPTS_VALUE;
2673     st->probe_packets = MAX_PROBE_PACKETS;
2674
2675     /* default pts setting is MPEG-like */
2676     av_set_pts_info(st, 33, 1, 90000);
2677     st->last_IP_pts = AV_NOPTS_VALUE;
2678     for(i=0; i<MAX_REORDER_DELAY+1; i++)
2679         st->pts_buffer[i]= AV_NOPTS_VALUE;
2680     st->reference_dts = AV_NOPTS_VALUE;
2681
2682     st->sample_aspect_ratio = (AVRational){0,1};
2683
2684     s->streams[s->nb_streams++] = st;
2685     return st;
2686 }
2687
2688 AVProgram *av_new_program(AVFormatContext *ac, int id)
2689 {
2690     AVProgram *program=NULL;
2691     int i;
2692
2693 #ifdef DEBUG_SI
2694     av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2695 #endif
2696
2697     for(i=0; i<ac->nb_programs; i++)
2698         if(ac->programs[i]->id == id)
2699             program = ac->programs[i];
2700
2701     if(!program){
2702         program = av_mallocz(sizeof(AVProgram));
2703         if (!program)
2704             return NULL;
2705         dynarray_add(&ac->programs, &ac->nb_programs, program);
2706         program->discard = AVDISCARD_NONE;
2707     }
2708     program->id = id;
2709
2710     return program;
2711 }
2712
2713 AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2714 {
2715     AVChapter *chapter = NULL;
2716     int i;
2717
2718     for(i=0; i<s->nb_chapters; i++)
2719         if(s->chapters[i]->id == id)
2720             chapter = s->chapters[i];
2721
2722     if(!chapter){
2723         chapter= av_mallocz(sizeof(AVChapter));
2724         if(!chapter)
2725             return NULL;
2726         dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2727     }
2728 #if FF_API_OLD_METADATA
2729     av_free(chapter->title);
2730 #endif
2731     av_metadata_set2(&chapter->metadata, "title", title, 0);
2732     chapter->id    = id;
2733     chapter->time_base= time_base;
2734     chapter->start = start;
2735     chapter->end   = end;
2736
2737     return chapter;
2738 }
2739
2740 /************************************************************/
2741 /* output media file */
2742
2743 int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2744 {
2745     int ret;
2746
2747     if (s->oformat->priv_data_size > 0) {
2748         s->priv_data = av_mallocz(s->oformat->priv_data_size);
2749         if (!s->priv_data)
2750             return AVERROR(ENOMEM);
2751         if (s->oformat->priv_class) {
2752             *(const AVClass**)s->priv_data= s->oformat->priv_class;
2753             av_opt_set_defaults(s->priv_data);
2754         }
2755     } else
2756         s->priv_data = NULL;
2757
2758     if (s->oformat->set_parameters) {
2759         ret = s->oformat->set_parameters(s, ap);
2760         if (ret < 0)
2761             return ret;
2762     }
2763     return 0;
2764 }
2765
2766 static int validate_codec_tag(AVFormatContext *s, AVStream *st)
2767 {
2768     const AVCodecTag *avctag;
2769     int n;
2770     enum CodecID id = CODEC_ID_NONE;
2771     unsigned int tag = 0;
2772
2773     /**
2774      * Check that tag + id is in the table
2775      * If neither is in the table -> OK
2776      * If tag is in the table with another id -> FAIL
2777      * If id is in the table with another tag -> FAIL unless strict < normal
2778      */
2779     for (n = 0; s->oformat->codec_tag[n]; n++) {
2780         avctag = s->oformat->codec_tag[n];
2781         while (avctag->id != CODEC_ID_NONE) {
2782             if (ff_toupper4(avctag->tag) == ff_toupper4(st->codec->codec_tag)) {
2783                 id = avctag->id;
2784                 if (id == st->codec->codec_id)
2785                     return 1;
2786             }
2787             if (avctag->id == st->codec->codec_id)
2788                 tag = avctag->tag;
2789             avctag++;
2790         }
2791     }
2792     if (id != CODEC_ID_NONE)
2793         return 0;
2794     if (tag && (st->codec->strict_std_compliance >= FF_COMPLIANCE_NORMAL))
2795         return 0;
2796     return 1;
2797 }
2798
2799 int av_write_header(AVFormatContext *s)
2800 {
2801     int ret, i;
2802     AVStream *st;
2803
2804     // some sanity checks
2805     if (s->nb_streams == 0 && !(s->oformat->flags & AVFMT_NOSTREAMS)) {
2806         av_log(s, AV_LOG_ERROR, "no streams\n");
2807         return AVERROR(EINVAL);
2808     }
2809
2810     for(i=0;i<s->nb_streams;i++) {
2811         st = s->streams[i];
2812
2813         switch (st->codec->codec_type) {
2814         case AVMEDIA_TYPE_AUDIO:
2815             if(st->codec->sample_rate<=0){
2816                 av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2817                 return AVERROR(EINVAL);
2818             }
2819             if(!st->codec->block_align)
2820                 st->codec->block_align = st->codec->channels *
2821                     av_get_bits_per_sample(st->codec->codec_id) >> 3;
2822             break;
2823         case AVMEDIA_TYPE_VIDEO:
2824             if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2825                 av_log(s, AV_LOG_ERROR, "time base not set\n");
2826                 return AVERROR(EINVAL);
2827             }
2828             if((st->codec->width<=0 || st->codec->height<=0) && !(s->oformat->flags & AVFMT_NODIMENSIONS)){
2829                 av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2830                 return AVERROR(EINVAL);
2831             }
2832             if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)){
2833                 av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between encoder and muxer layer\n");
2834                 return AVERROR(EINVAL);
2835             }
2836             break;
2837         }
2838
2839         if(s->oformat->codec_tag){
2840             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)){
2841                 //the current rawvideo encoding system ends up setting the wrong codec_tag for avi, we override it here
2842                 st->codec->codec_tag= 0;
2843             }
2844             if(st->codec->codec_tag){
2845                 if (!validate_codec_tag(s, st)) {
2846                     char tagbuf[32];
2847                     av_get_codec_tag_string(tagbuf, sizeof(tagbuf), st->codec->codec_tag);
2848                     av_log(s, AV_LOG_ERROR,
2849                            "Tag %s/0x%08x incompatible with output codec id '%d'\n",
2850                            tagbuf, st->codec->codec_tag, st->codec->codec_id);
2851                     return AVERROR_INVALIDDATA;
2852                 }
2853             }else
2854                 st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2855         }
2856
2857         if(s->oformat->flags & AVFMT_GLOBALHEADER &&
2858             !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
2859           av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
2860     }
2861
2862     if (!s->priv_data && s->oformat->priv_data_size > 0) {
2863         s->priv_data = av_mallocz(s->oformat->priv_data_size);
2864         if (!s->priv_data)
2865             return AVERROR(ENOMEM);
2866     }
2867
2868 #if FF_API_OLD_METADATA
2869     ff_metadata_mux_compat(s);
2870 #endif
2871
2872     /* set muxer identification string */
2873     if (s->nb_streams && !(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
2874         av_metadata_set2(&s->metadata, "encoder", LIBAVFORMAT_IDENT, 0);
2875     }
2876
2877     if(s->oformat->write_header){
2878         ret = s->oformat->write_header(s);
2879         if (ret < 0)
2880             return ret;
2881     }
2882
2883     /* init PTS generation */
2884     for(i=0;i<s->nb_streams;i++) {
2885         int64_t den = AV_NOPTS_VALUE;
2886         st = s->streams[i];
2887
2888         switch (st->codec->codec_type) {
2889         case AVMEDIA_TYPE_AUDIO:
2890             den = (int64_t)st->time_base.num * st->codec->sample_rate;
2891             break;
2892         case AVMEDIA_TYPE_VIDEO:
2893             den = (int64_t)st->time_base.num * st->codec->time_base.den;
2894             break;
2895         default:
2896             break;
2897         }
2898         if (den != AV_NOPTS_VALUE) {
2899             if (den <= 0)
2900                 return AVERROR_INVALIDDATA;
2901             av_frac_init(&st->pts, 0, 0, den);
2902         }
2903     }
2904     return 0;
2905 }
2906
2907 //FIXME merge with compute_pkt_fields
2908 static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt){
2909     int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2910     int num, den, frame_size, i;
2911
2912 //    av_log(s, AV_LOG_DEBUG, "av_write_frame: pts:%"PRId64" dts:%"PRId64" cur_dts:%"PRId64" b:%d size:%d st:%d\n", pkt->pts, pkt->dts, st->cur_dts, delay, pkt->size, pkt->stream_index);
2913
2914 /*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2915         return -1;*/
2916
2917     /* duration field */
2918     if (pkt->duration == 0) {
2919         compute_frame_duration(&num, &den, st, NULL, pkt);
2920         if (den && num) {
2921             pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
2922         }
2923     }
2924
2925     if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
2926         pkt->pts= pkt->dts;
2927
2928     //XXX/FIXME this is a temporary hack until all encoders output pts
2929     if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2930         pkt->dts=
2931 //        pkt->pts= st->cur_dts;
2932         pkt->pts= st->pts.val;
2933     }
2934
2935     //calculate dts from pts
2936     if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
2937         st->pts_buffer[0]= pkt->pts;
2938         for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2939             st->pts_buffer[i]= pkt->pts + (i-delay-1) * pkt->duration;
2940         for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2941             FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2942
2943         pkt->dts= st->pts_buffer[0];
2944     }
2945
2946     if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2947         av_log(s, AV_LOG_ERROR,
2948                "Application provided invalid, non monotonically increasing dts to muxer in stream %d: %"PRId64" >= %"PRId64"\n",
2949                st->index, st->cur_dts, pkt->dts);
2950         return -1;
2951     }
2952     if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2953         av_log(s, AV_LOG_ERROR, "pts < dts in stream %d\n", st->index);
2954         return -1;
2955     }
2956
2957 //    av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2958     st->cur_dts= pkt->dts;
2959     st->pts.val= pkt->dts;
2960
2961     /* update pts */
2962     switch (st->codec->codec_type) {
2963     case AVMEDIA_TYPE_AUDIO:
2964         frame_size = get_audio_frame_size(st->codec, pkt->size);
2965
2966         /* HACK/FIXME, we skip the initial 0 size packets as they are most
2967            likely equal to the encoder delay, but it would be better if we
2968            had the real timestamps from the encoder */
2969         if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2970             av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2971         }
2972         break;
2973     case AVMEDIA_TYPE_VIDEO:
2974         av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2975         break;
2976     default:
2977         break;
2978     }
2979     return 0;
2980 }
2981
2982 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2983 {
2984     int ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt);
2985
2986     if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2987         return ret;
2988
2989     ret= s->oformat->write_packet(s, pkt);
2990     if(!ret)
2991         ret= url_ferror(s->pb);
2992     return ret;
2993 }
2994
2995 void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
2996                               int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
2997 {
2998     AVPacketList **next_point, *this_pktl;
2999
3000     this_pktl = av_mallocz(sizeof(AVPacketList));
3001     this_pktl->pkt= *pkt;
3002     pkt->destruct= NULL;             // do not free original but only the copy
3003     av_dup_packet(&this_pktl->pkt);  // duplicate the packet if it uses non-alloced memory
3004
3005     if(s->streams[pkt->stream_index]->last_in_packet_buffer){
3006         next_point = &(s->streams[pkt->stream_index]->last_in_packet_buffer->next);
3007     }else
3008         next_point = &s->packet_buffer;
3009
3010     if(*next_point){
3011         if(compare(s, &s->packet_buffer_end->pkt, pkt)){
3012             while(!compare(s, &(*next_point)->pkt, pkt)){
3013                 next_point= &(*next_point)->next;
3014             }
3015             goto next_non_null;
3016         }else{
3017             next_point = &(s->packet_buffer_end->next);
3018         }
3019     }
3020     assert(!*next_point);
3021
3022     s->packet_buffer_end= this_pktl;
3023 next_non_null:
3024
3025     this_pktl->next= *next_point;
3026
3027     s->streams[pkt->stream_index]->last_in_packet_buffer=
3028     *next_point= this_pktl;
3029 }
3030
3031 static int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
3032 {
3033     AVStream *st = s->streams[ pkt ->stream_index];
3034     AVStream *st2= s->streams[ next->stream_index];
3035     int64_t a= st2->time_base.num * (int64_t)st ->time_base.den;
3036     int64_t b= st ->time_base.num * (int64_t)st2->time_base.den;
3037     return av_rescale_rnd(pkt->dts, b, a, AV_ROUND_DOWN) < next->dts;
3038 }
3039
3040 int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
3041     AVPacketList *pktl;
3042     int stream_count=0;
3043     int i;
3044
3045     if(pkt){
3046         ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
3047     }
3048
3049     for(i=0; i < s->nb_streams; i++)
3050         stream_count+= !!s->streams[i]->last_in_packet_buffer;
3051
3052     if(stream_count && (s->nb_streams == stream_count || flush)){
3053         pktl= s->packet_buffer;
3054         *out= pktl->pkt;
3055
3056         s->packet_buffer= pktl->next;
3057         if(!s->packet_buffer)
3058             s->packet_buffer_end= NULL;
3059
3060         if(s->streams[out->stream_index]->last_in_packet_buffer == pktl)
3061             s->streams[out->stream_index]->last_in_packet_buffer= NULL;
3062         av_freep(&pktl);
3063         return 1;
3064     }else{
3065         av_init_packet(out);
3066         return 0;
3067     }
3068 }
3069
3070 /**
3071  * Interleave an AVPacket correctly so it can be muxed.
3072  * @param out the interleaved packet will be output here
3073  * @param in the input packet
3074  * @param flush 1 if no further packets are available as input and all
3075  *              remaining packets should be output
3076  * @return 1 if a packet was output, 0 if no packet could be output,
3077  *         < 0 if an error occurred
3078  */
3079 static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
3080     if(s->oformat->interleave_packet)
3081         return s->oformat->interleave_packet(s, out, in, flush);
3082     else
3083         return av_interleave_packet_per_dts(s, out, in, flush);
3084 }
3085
3086 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
3087     AVStream *st= s->streams[ pkt->stream_index];
3088
3089     //FIXME/XXX/HACK drop zero sized packets
3090     if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO && pkt->size==0)
3091         return 0;
3092
3093 //av_log(NULL, AV_LOG_DEBUG, "av_interleaved_write_frame %d %"PRId64" %"PRId64"\n", pkt->size, pkt->dts, pkt->pts);
3094     if(compute_pkt_fields2(s, st, pkt) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3095         return -1;
3096
3097     if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3098         return -1;
3099
3100     for(;;){
3101         AVPacket opkt;
3102         int ret= av_interleave_packet(s, &opkt, pkt, 0);
3103         if(ret<=0) //FIXME cleanup needed for ret<0 ?
3104             return ret;
3105
3106         ret= s->oformat->write_packet(s, &opkt);
3107
3108         av_free_packet(&opkt);
3109         pkt= NULL;
3110
3111         if(ret<0)
3112             return ret;
3113         if(url_ferror(s->pb))
3114             return url_ferror(s->pb);
3115     }
3116 }
3117
3118 int av_write_trailer(AVFormatContext *s)
3119 {
3120     int ret, i;
3121
3122     for(;;){
3123         AVPacket pkt;
3124         ret= av_interleave_packet(s, &pkt, NULL, 1);
3125         if(ret<0) //FIXME cleanup needed for ret<0 ?
3126             goto fail;
3127         if(!ret)
3128             break;
3129
3130         ret= s->oformat->write_packet(s, &pkt);
3131
3132         av_free_packet(&pkt);
3133
3134         if(ret<0)
3135             goto fail;
3136         if(url_ferror(s->pb))
3137             goto fail;
3138     }
3139
3140     if(s->oformat->write_trailer)
3141         ret = s->oformat->write_trailer(s);
3142 fail:
3143     if(ret == 0)
3144        ret=url_ferror(s->pb);
3145     for(i=0;i<s->nb_streams;i++) {
3146         av_freep(&s->streams[i]->priv_data);
3147         av_freep(&s->streams[i]->index_entries);
3148     }
3149     av_freep(&s->priv_data);
3150     return ret;
3151 }
3152
3153 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
3154 {
3155     int i, j;
3156     AVProgram *program=NULL;
3157     void *tmp;
3158
3159     if (idx >= ac->nb_streams) {
3160         av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3161         return;
3162     }
3163
3164     for(i=0; i<ac->nb_programs; i++){
3165         if(ac->programs[i]->id != progid)
3166             continue;
3167         program = ac->programs[i];
3168         for(j=0; j<program->nb_stream_indexes; j++)
3169             if(program->stream_index[j] == idx)
3170                 return;
3171
3172         tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
3173         if(!tmp)
3174             return;
3175         program->stream_index = tmp;
3176         program->stream_index[program->nb_stream_indexes++] = idx;
3177         return;
3178     }
3179 }
3180
3181 static void print_fps(double d, const char *postfix){
3182     uint64_t v= lrintf(d*100);
3183     if     (v% 100      ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3184     else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3185     else                  av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
3186 }
3187
3188 static void dump_metadata(void *ctx, AVMetadata *m, const char *indent)
3189 {
3190     if(m && !(m->count == 1 && av_metadata_get(m, "language", NULL, 0))){
3191         AVMetadataTag *tag=NULL;
3192
3193         av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3194         while((tag=av_metadata_get(m, "", tag, AV_METADATA_IGNORE_SUFFIX))) {
3195             if(strcmp("language", tag->key))
3196                 av_log(ctx, AV_LOG_INFO, "%s  %-16s: %s\n", indent, tag->key, tag->value);
3197         }
3198     }
3199 }
3200
3201 /* "user interface" functions */
3202 static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
3203 {
3204     char buf[256];
3205     int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
3206     AVStream *st = ic->streams[i];
3207     int g = av_gcd(st->time_base.num, st->time_base.den);
3208     AVMetadataTag *lang = av_metadata_get(st->metadata, "language", NULL, 0);
3209     avcodec_string(buf, sizeof(buf), st->codec, is_output);
3210     av_log(NULL, AV_LOG_INFO, "    Stream #%d.%d", index, i);
3211     /* the pid is an important information, so we display it */
3212     /* XXX: add a generic system */
3213     if (flags & AVFMT_SHOW_IDS)
3214         av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
3215     if (lang)
3216         av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
3217     av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames, st->time_base.num/g, st->time_base.den/g);
3218     av_log(NULL, AV_LOG_INFO, ": %s", buf);
3219     if (st->sample_aspect_ratio.num && // default
3220         av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
3221         AVRational display_aspect_ratio;
3222         av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
3223                   st->codec->width*st->sample_aspect_ratio.num,
3224                   st->codec->height*st->sample_aspect_ratio.den,
3225                   1024*1024);
3226         av_log(NULL, AV_LOG_INFO, ", PAR %d:%d DAR %d:%d",
3227                  st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3228                  display_aspect_ratio.num, display_aspect_ratio.den);
3229     }
3230     if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
3231         if(st->avg_frame_rate.den && st->avg_frame_rate.num)
3232             print_fps(av_q2d(st->avg_frame_rate), "fps");
3233         if(st->r_frame_rate.den && st->r_frame_rate.num)
3234             print_fps(av_q2d(st->r_frame_rate), "tbr");
3235         if(st->time_base.den && st->time_base.num)
3236             print_fps(1/av_q2d(st->time_base), "tbn");
3237         if(st->codec->time_base.den && st->codec->time_base.num)
3238             print_fps(1/av_q2d(st->codec->time_base), "tbc");
3239     }
3240     if (st->disposition & AV_DISPOSITION_DEFAULT)
3241         av_log(NULL, AV_LOG_INFO, " (default)");
3242     if (st->disposition & AV_DISPOSITION_DUB)
3243         av_log(NULL, AV_LOG_INFO, " (dub)");
3244     if (st->disposition & AV_DISPOSITION_ORIGINAL)
3245         av_log(NULL, AV_LOG_INFO, " (original)");
3246     if (st->disposition & AV_DISPOSITION_COMMENT)
3247         av_log(NULL, AV_LOG_INFO, " (comment)");
3248     if (st->disposition & AV_DISPOSITION_LYRICS)
3249         av_log(NULL, AV_LOG_INFO, " (lyrics)");
3250     if (st->disposition & AV_DISPOSITION_KARAOKE)
3251         av_log(NULL, AV_LOG_INFO, " (karaoke)");
3252     if (st->disposition & AV_DISPOSITION_FORCED)
3253         av_log(NULL, AV_LOG_INFO, " (forced)");
3254     if (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED)
3255         av_log(NULL, AV_LOG_INFO, " (hearing impaired)");
3256     if (st->disposition & AV_DISPOSITION_VISUAL_IMPAIRED)
3257         av_log(NULL, AV_LOG_INFO, " (visual impaired)");
3258     if (st->disposition & AV_DISPOSITION_CLEAN_EFFECTS)
3259         av_log(NULL, AV_LOG_INFO, " (clean effects)");
3260     av_log(NULL, AV_LOG_INFO, "\n");
3261     dump_metadata(NULL, st->metadata, "    ");
3262 }
3263
3264 #if FF_API_DUMP_FORMAT
3265 void dump_format(AVFormatContext *ic,
3266                  int index,
3267                  const char *url,
3268                  int is_output)
3269 {
3270     av_dump_format(ic, index, url, is_output);
3271 }
3272 #endif
3273
3274 void av_dump_format(AVFormatContext *ic,
3275                     int index,
3276                     const char *url,
3277                     int is_output)
3278 {
3279     int i;
3280     uint8_t *printed = av_mallocz(ic->nb_streams);
3281     if (ic->nb_streams && !printed)
3282         return;
3283
3284     av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3285             is_output ? "Output" : "Input",
3286             index,
3287             is_output ? ic->oformat->name : ic->iformat->name,
3288             is_output ? "to" : "from", url);
3289     dump_metadata(NULL, ic->metadata, "  ");
3290     if (!is_output) {
3291         av_log(NULL, AV_LOG_INFO, "  Duration: ");
3292         if (ic->duration != AV_NOPTS_VALUE) {
3293             int hours, mins, secs, us;
3294             secs = ic->duration / AV_TIME_BASE;
3295             us = ic->duration % AV_TIME_BASE;
3296             mins = secs / 60;
3297             secs %= 60;
3298             hours = mins / 60;
3299             mins %= 60;
3300             av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3301                    (100 * us) / AV_TIME_BASE);
3302         } else {
3303             av_log(NULL, AV_LOG_INFO, "N/A");
3304         }
3305         if (ic->start_time != AV_NOPTS_VALUE) {
3306             int secs, us;
3307             av_log(NULL, AV_LOG_INFO, ", start: ");
3308             secs = ic->start_time / AV_TIME_BASE;
3309             us = abs(ic->start_time % AV_TIME_BASE);
3310             av_log(NULL, AV_LOG_INFO, "%d.%06d",
3311                    secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
3312         }
3313         av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3314         if (ic->bit_rate) {
3315             av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
3316         } else {
3317             av_log(NULL, AV_LOG_INFO, "N/A");
3318         }
3319         av_log(NULL, AV_LOG_INFO, "\n");
3320     }
3321     for (i = 0; i < ic->nb_chapters; i++) {
3322         AVChapter *ch = ic->chapters[i];
3323         av_log(NULL, AV_LOG_INFO, "    Chapter #%d.%d: ", index, i);
3324         av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
3325         av_log(NULL, AV_LOG_INFO, "end %f\n",   ch->end   * av_q2d(ch->time_base));
3326
3327         dump_metadata(NULL, ch->metadata, "    ");
3328     }
3329     if(ic->nb_programs) {
3330         int j, k, total = 0;
3331         for(j=0; j<ic->nb_programs; j++) {
3332             AVMetadataTag *name = av_metadata_get(ic->programs[j]->metadata,
3333                                                   "name", NULL, 0);
3334             av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
3335                    name ? name->value : "");
3336             dump_metadata(NULL, ic->programs[j]->metadata, "    ");
3337             for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3338                 dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3339                 printed[ic->programs[j]->stream_index[k]] = 1;
3340             }
3341             total += ic->programs[j]->nb_stream_indexes;
3342         }
3343         if (total < ic->nb_streams)
3344             av_log(NULL, AV_LOG_INFO, "  No Program\n");
3345     }
3346     for(i=0;i<ic->nb_streams;i++)
3347         if (!printed[i])
3348             dump_stream_format(ic, i, index, is_output);
3349
3350     av_free(printed);
3351 }
3352
3353 #if FF_API_PARSE_FRAME_PARAM
3354 #include "libavutil/parseutils.h"
3355
3356 int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
3357 {
3358     return av_parse_video_size(width_ptr, height_ptr, str);
3359 }
3360
3361 int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
3362 {
3363     AVRational frame_rate;
3364     int ret = av_parse_video_rate(&frame_rate, arg);
3365     *frame_rate_num= frame_rate.num;
3366     *frame_rate_den= frame_rate.den;
3367     return ret;
3368 }
3369 #endif
3370
3371 int64_t av_gettime(void)
3372 {
3373     struct timeval tv;
3374     gettimeofday(&tv,NULL);
3375     return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
3376 }
3377
3378 uint64_t ff_ntp_time(void)
3379 {
3380   return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3381 }
3382
3383 #if FF_API_PARSE_DATE
3384 #include "libavutil/parseutils.h"
3385
3386 int64_t parse_date(const char *timestr, int duration)
3387 {
3388     int64_t timeval;
3389     av_parse_time(&timeval, timestr, duration);
3390     return timeval;
3391 }
3392 #endif
3393
3394 #if FF_API_FIND_INFO_TAG
3395 #include "libavutil/parseutils.h"
3396
3397 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
3398 {
3399     return av_find_info_tag(arg, arg_size, tag1, info);
3400 }
3401 #endif
3402
3403 int av_get_frame_filename(char *buf, int buf_size,
3404                           const char *path, int number)
3405 {
3406     const char *p;
3407     char *q, buf1[20], c;
3408     int nd, len, percentd_found;
3409
3410     q = buf;
3411     p = path;
3412     percentd_found = 0;
3413     for(;;) {
3414         c = *p++;
3415         if (c == '\0')
3416             break;
3417         if (c == '%') {
3418             do {
3419                 nd = 0;
3420                 while (isdigit(*p)) {
3421                     nd = nd * 10 + *p++ - '0';
3422                 }
3423                 c = *p++;
3424             } while (isdigit(c));
3425
3426             switch(c) {
3427             case '%':
3428                 goto addchar;
3429             case 'd':
3430                 if (percentd_found)
3431                     goto fail;
3432                 percentd_found = 1;
3433                 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3434                 len = strlen(buf1);
3435                 if ((q - buf + len) > buf_size - 1)
3436                     goto fail;
3437                 memcpy(q, buf1, len);
3438                 q += len;
3439                 break;
3440             default:
3441                 goto fail;
3442             }
3443         } else {
3444         addchar:
3445             if ((q - buf) < buf_size - 1)
3446                 *q++ = c;
3447         }
3448     }
3449     if (!percentd_found)
3450         goto fail;
3451     *q = '\0';
3452     return 0;
3453  fail:
3454     *q = '\0';
3455     return -1;
3456 }
3457
3458 static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3459 {
3460     int len, i, j, c;
3461 #undef fprintf
3462 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3463
3464     for(i=0;i<size;i+=16) {
3465         len = size - i;
3466         if (len > 16)
3467             len = 16;
3468         PRINT("%08x ", i);
3469         for(j=0;j<16;j++) {
3470             if (j < len)
3471                 PRINT(" %02x", buf[i+j]);
3472             else
3473                 PRINT("   ");
3474         }
3475         PRINT(" ");
3476         for(j=0;j<len;j++) {
3477             c = buf[i+j];
3478             if (c < ' ' || c > '~')
3479                 c = '.';
3480             PRINT("%c", c);
3481         }
3482         PRINT("\n");
3483     }
3484 #undef PRINT
3485 }
3486
3487 void av_hex_dump(FILE *f, uint8_t *buf, int size)
3488 {
3489     hex_dump_internal(NULL, f, 0, buf, size);
3490 }
3491
3492 void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3493 {
3494     hex_dump_internal(avcl, NULL, level, buf, size);
3495 }
3496
3497  //FIXME needs to know the time_base
3498 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload)
3499 {
3500 #undef fprintf
3501 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3502     PRINT("stream #%d:\n", pkt->stream_index);
3503     PRINT("  keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
3504     PRINT("  duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
3505     /* DTS is _always_ valid after av_read_frame() */
3506     PRINT("  dts=");
3507     if (pkt->dts == AV_NOPTS_VALUE)
3508         PRINT("N/A");
3509     else
3510         PRINT("%0.3f", (double)pkt->dts / AV_TIME_BASE);
3511     /* PTS may not be known if B-frames are present. */
3512     PRINT("  pts=");
3513     if (pkt->pts == AV_NOPTS_VALUE)
3514         PRINT("N/A");
3515     else
3516         PRINT("%0.3f", (double)pkt->pts / AV_TIME_BASE);
3517     PRINT("\n");
3518     PRINT("  size=%d\n", pkt->size);
3519 #undef PRINT
3520     if (dump_payload)
3521         av_hex_dump(f, pkt->data, pkt->size);
3522 }
3523
3524 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3525 {
3526     pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
3527 }
3528
3529 void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3530 {
3531     pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
3532 }
3533
3534 #if FF_API_URL_SPLIT
3535 attribute_deprecated
3536 void ff_url_split(char *proto, int proto_size,
3537                   char *authorization, int authorization_size,
3538                   char *hostname, int hostname_size,
3539                   int *port_ptr,
3540                   char *path, int path_size,
3541                   const char *url)
3542 {
3543     av_url_split(proto, proto_size,
3544                  authorization, authorization_size,
3545                  hostname, hostname_size,
3546                  port_ptr,
3547                  path, path_size,
3548                  url);
3549 }
3550 #endif
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 }