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