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