git.sesse.net Git - ffmpeg/blob - libavformat/utils.c

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