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