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

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