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->frame_size <= 1) {
 705         int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
 706
 707         if (bits_per_sample) {
 708             if (enc->channels == 0)
 709                 return -1;
 710             frame_size = (size << 3) / (bits_per_sample * enc->channels);
 711         } else {
 712             /* used for example by ADPCM codecs */
 713             if (enc->bit_rate == 0)
 714                 return -1;
 715             frame_size = ((int64_t)size * 8 * enc->sample_rate) / enc->bit_rate;
 716         }
 717     } else {
 718         frame_size = enc->frame_size;
 719     }
 720     return frame_size;
 721 }
 722
 723
 724 /**
 725  * Return the frame duration in seconds. Return 0 if not available.
 726  */
 727 static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
 728                                    AVCodecParserContext *pc, AVPacket *pkt)
 729 {
 730     int frame_size;
 731
 732     *pnum = 0;
 733     *pden = 0;
 734     switch(st->codec->codec_type) {
 735     case AVMEDIA_TYPE_VIDEO:
 736         if (st->r_frame_rate.num) {
 737             *pnum = st->r_frame_rate.den;
 738             *pden = st->r_frame_rate.num;
 739         } else if(st->time_base.num*1000LL > st->time_base.den) {
 740             *pnum = st->time_base.num;
 741             *pden = st->time_base.den;
 742         }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
 743             *pnum = st->codec->time_base.num;
 744             *pden = st->codec->time_base.den;
 745             if (pc && pc->repeat_pict) {
 746                 *pnum = (*pnum) * (1 + pc->repeat_pict);
 747             }
 748             //If this codec can be interlaced or progressive then we need a parser to compute duration of a packet
 749             //Thus if we have no parser in such case leave duration undefined.
 750             if(st->codec->ticks_per_frame>1 && !pc){
 751                 *pnum = *pden = 0;
 752             }
 753         }
 754         break;
 755     case AVMEDIA_TYPE_AUDIO:
 756         frame_size = get_audio_frame_size(st->codec, pkt->size);
 757         if (frame_size <= 0 || st->codec->sample_rate <= 0)
 758             break;
 759         *pnum = frame_size;
 760         *pden = st->codec->sample_rate;
 761         break;
 762     default:
 763         break;
 764     }
 765 }
 766
 767 static int is_intra_only(AVCodecContext *enc){
 768     if(enc->codec_type == AVMEDIA_TYPE_AUDIO){
 769         return 1;
 770     }else if(enc->codec_type == AVMEDIA_TYPE_VIDEO){
 771         switch(enc->codec_id){
 772         case CODEC_ID_MJPEG:
 773         case CODEC_ID_MJPEGB:
 774         case CODEC_ID_LJPEG:
 775         case CODEC_ID_PRORES:
 776         case CODEC_ID_RAWVIDEO:
 777         case CODEC_ID_DVVIDEO:
 778         case CODEC_ID_HUFFYUV:
 779         case CODEC_ID_FFVHUFF:
 780         case CODEC_ID_ASV1:
 781         case CODEC_ID_ASV2:
 782         case CODEC_ID_VCR1:
 783         case CODEC_ID_DNXHD:
 784         case CODEC_ID_JPEG2000:
 785             return 1;
 786         default: break;
 787         }
 788     }
 789     return 0;
 790 }
 791
 792 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
 793                                       int64_t dts, int64_t pts)
 794 {
 795     AVStream *st= s->streams[stream_index];
 796     AVPacketList *pktl= s->packet_buffer;
 797
 798     if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE)
 799         return;
 800
 801     st->first_dts= dts - st->cur_dts;
 802     st->cur_dts= dts;
 803
 804     for(; pktl; pktl= pktl->next){
 805         if(pktl->pkt.stream_index != stream_index)
 806             continue;
 807         //FIXME think more about this check
 808         if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
 809             pktl->pkt.pts += st->first_dts;
 810
 811         if(pktl->pkt.dts != AV_NOPTS_VALUE)
 812             pktl->pkt.dts += st->first_dts;
 813
 814         if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
 815             st->start_time= pktl->pkt.pts;
 816     }
 817     if (st->start_time == AV_NOPTS_VALUE)
 818         st->start_time = pts;
 819 }
 820
 821 static void update_initial_durations(AVFormatContext *s, AVStream *st, AVPacket *pkt)
 822 {
 823     AVPacketList *pktl= s->packet_buffer;
 824     int64_t cur_dts= 0;
 825
 826     if(st->first_dts != AV_NOPTS_VALUE){
 827         cur_dts= st->first_dts;
 828         for(; pktl; pktl= pktl->next){
 829             if(pktl->pkt.stream_index == pkt->stream_index){
 830                 if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
 831                     break;
 832                 cur_dts -= pkt->duration;
 833             }
 834         }
 835         pktl= s->packet_buffer;
 836         st->first_dts = cur_dts;
 837     }else if(st->cur_dts)
 838         return;
 839
 840     for(; pktl; pktl= pktl->next){
 841         if(pktl->pkt.stream_index != pkt->stream_index)
 842             continue;
 843         if(pktl->pkt.pts == pktl->pkt.dts && pktl->pkt.dts == AV_NOPTS_VALUE
 844            && !pktl->pkt.duration){
 845             pktl->pkt.dts= cur_dts;
 846             if(!st->codec->has_b_frames)
 847                 pktl->pkt.pts= cur_dts;
 848             cur_dts += pkt->duration;
 849             pktl->pkt.duration= pkt->duration;
 850         }else
 851             break;
 852     }
 853     if(st->first_dts == AV_NOPTS_VALUE)
 854         st->cur_dts= cur_dts;
 855 }
 856
 857 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
 858                                AVCodecParserContext *pc, AVPacket *pkt)
 859 {
 860     int num, den, presentation_delayed, delay, i;
 861     int64_t offset;
 862
 863     if (s->flags & AVFMT_FLAG_NOFILLIN)
 864         return;
 865
 866     if((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
 867         pkt->dts= AV_NOPTS_VALUE;
 868
 869     /* do we have a video B-frame ? */
 870     delay= st->codec->has_b_frames;
 871     presentation_delayed = 0;
 872
 873     /* XXX: need has_b_frame, but cannot get it if the codec is
 874         not initialized */
 875     if (delay &&
 876         pc && pc->pict_type != AV_PICTURE_TYPE_B)
 877         presentation_delayed = 1;
 878
 879     if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
 880        /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
 881         pkt->dts -= 1LL<<st->pts_wrap_bits;
 882     }
 883
 884     // some mpeg2 in mpeg-ps lack dts (issue171 / input_file.mpg)
 885     // we take the conservative approach and discard both
 886     // Note, if this is misbehaving for a H.264 file then possibly presentation_delayed is not set correctly.
 887     if(delay==1 && pkt->dts == pkt->pts && pkt->dts != AV_NOPTS_VALUE && presentation_delayed){
 888         av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination\n");
 889         pkt->dts= pkt->pts= AV_NOPTS_VALUE;
 890     }
 891
 892     if (pkt->duration == 0) {
 893         compute_frame_duration(&num, &den, st, pc, pkt);
 894         if (den && num) {
 895             pkt->duration = av_rescale_rnd(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num, AV_ROUND_DOWN);
 896
 897             if(pkt->duration != 0 && s->packet_buffer)
 898                 update_initial_durations(s, st, pkt);
 899         }
 900     }
 901
 902     /* correct timestamps with byte offset if demuxers only have timestamps
 903        on packet boundaries */
 904     if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
 905         /* this will estimate bitrate based on this frame's duration and size */
 906         offset = av_rescale(pc->offset, pkt->duration, pkt->size);
 907         if(pkt->pts != AV_NOPTS_VALUE)
 908             pkt->pts += offset;
 909         if(pkt->dts != AV_NOPTS_VALUE)
 910             pkt->dts += offset;
 911     }
 912
 913     if (pc && pc->dts_sync_point >= 0) {
 914         // we have synchronization info from the parser
 915         int64_t den = st->codec->time_base.den * (int64_t) st->time_base.num;
 916         if (den > 0) {
 917             int64_t num = st->codec->time_base.num * (int64_t) st->time_base.den;
 918             if (pkt->dts != AV_NOPTS_VALUE) {
 919                 // got DTS from the stream, update reference timestamp
 920                 st->reference_dts = pkt->dts - pc->dts_ref_dts_delta * num / den;
 921                 pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
 922             } else if (st->reference_dts != AV_NOPTS_VALUE) {
 923                 // compute DTS based on reference timestamp
 924                 pkt->dts = st->reference_dts + pc->dts_ref_dts_delta * num / den;
 925                 pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
 926             }
 927             if (pc->dts_sync_point > 0)
 928                 st->reference_dts = pkt->dts; // new reference
 929         }
 930     }
 931
 932     /* This may be redundant, but it should not hurt. */
 933     if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
 934         presentation_delayed = 1;
 935
 936 //    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);
 937     /* interpolate PTS and DTS if they are not present */
 938     //We skip H264 currently because delay and has_b_frames are not reliably set
 939     if((delay==0 || (delay==1 && pc)) && st->codec->codec_id != CODEC_ID_H264){
 940         if (presentation_delayed) {
 941             /* DTS = decompression timestamp */
 942             /* PTS = presentation timestamp */
 943             if (pkt->dts == AV_NOPTS_VALUE)
 944                 pkt->dts = st->last_IP_pts;
 945             update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
 946             if (pkt->dts == AV_NOPTS_VALUE)
 947                 pkt->dts = st->cur_dts;
 948
 949             /* this is tricky: the dts must be incremented by the duration
 950             of the frame we are displaying, i.e. the last I- or P-frame */
 951             if (st->last_IP_duration == 0)
 952                 st->last_IP_duration = pkt->duration;
 953             if(pkt->dts != AV_NOPTS_VALUE)
 954                 st->cur_dts = pkt->dts + st->last_IP_duration;
 955             st->last_IP_duration  = pkt->duration;
 956             st->last_IP_pts= pkt->pts;
 957             /* cannot compute PTS if not present (we can compute it only
 958             by knowing the future */
 959         } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
 960             if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
 961                 int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
 962                 int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
 963                 if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
 964                     pkt->pts += pkt->duration;
 965     //                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);
 966                 }
 967             }
 968
 969             /* presentation is not delayed : PTS and DTS are the same */
 970             if(pkt->pts == AV_NOPTS_VALUE)
 971                 pkt->pts = pkt->dts;
 972             update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
 973             if(pkt->pts == AV_NOPTS_VALUE)
 974                 pkt->pts = st->cur_dts;
 975             pkt->dts = pkt->pts;
 976             if(pkt->pts != AV_NOPTS_VALUE)
 977                 st->cur_dts = pkt->pts + pkt->duration;
 978         }
 979     }
 980
 981     if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
 982         st->pts_buffer[0]= pkt->pts;
 983         for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
 984             FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
 985         if(pkt->dts == AV_NOPTS_VALUE)
 986             pkt->dts= st->pts_buffer[0];
 987         if(st->codec->codec_id == CODEC_ID_H264){ // we skipped it above so we try here
 988             update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
 989         }
 990         if(pkt->dts > st->cur_dts)
 991             st->cur_dts = pkt->dts;
 992     }
 993
 994 //    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);
 995
 996     /* update flags */
 997     if(is_intra_only(st->codec))
 998         pkt->flags |= AV_PKT_FLAG_KEY;
 999     if (pc)
1000         pkt->convergence_duration = pc->convergence_duration;
1001 }
1002
1003 static void free_packet_buffer(AVPacketList **pkt_buf, AVPacketList **pkt_buf_end)
1004 {
1005     while (*pkt_buf) {
1006         AVPacketList *pktl = *pkt_buf;
1007         *pkt_buf = pktl->next;
1008         av_free_packet(&pktl->pkt);
1009         av_freep(&pktl);
1010     }
1011     *pkt_buf_end = NULL;
1012 }
1013
1014 static int read_from_packet_buffer(AVPacketList **pkt_buffer,
1015                                    AVPacketList **pkt_buffer_end,
1016                                    AVPacket      *pkt)
1017 {
1018     AVPacketList *pktl;
1019     av_assert0(*pkt_buffer);
1020     pktl = *pkt_buffer;
1021     *pkt = pktl->pkt;
1022     *pkt_buffer = pktl->next;
1023     if (!pktl->next)
1024         *pkt_buffer_end = NULL;
1025     av_freep(&pktl);
1026     return 0;
1027 }
1028
1029
1030 static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1031 {
1032     AVStream *st;
1033     int len, ret, i;
1034
1035     av_init_packet(pkt);
1036
1037     for(;;) {
1038         /* select current input stream component */
1039         st = s->cur_st;
1040         if (st) {
1041             if (!st->need_parsing || !st->parser) {
1042                 /* no parsing needed: we just output the packet as is */
1043                 /* raw data support */
1044                 *pkt = st->cur_pkt; st->cur_pkt.data= NULL;
1045                 compute_pkt_fields(s, st, NULL, pkt);
1046                 s->cur_st = NULL;
1047                 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1048                     (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1049                     ff_reduce_index(s, st->index);
1050                     av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1051                 }
1052                 break;
1053             } else if (st->cur_len > 0 && st->discard < AVDISCARD_ALL) {
1054                 len = av_parser_parse2(st->parser, st->codec, &pkt->data, &pkt->size,
1055                                        st->cur_ptr, st->cur_len,
1056                                        st->cur_pkt.pts, st->cur_pkt.dts,
1057                                        st->cur_pkt.pos);
1058                 st->cur_pkt.pts = AV_NOPTS_VALUE;
1059                 st->cur_pkt.dts = AV_NOPTS_VALUE;
1060                 /* increment read pointer */
1061                 st->cur_ptr += len;
1062                 st->cur_len -= len;
1063
1064                 /* return packet if any */
1065                 if (pkt->size) {
1066                 got_packet:
1067                     pkt->duration = 0;
1068                     if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1069                         if (st->codec->sample_rate > 0) {
1070                             pkt->duration = av_rescale_q_rnd(st->parser->duration,
1071                                                              (AVRational){ 1, st->codec->sample_rate },
1072                                                              st->time_base,
1073                                                              AV_ROUND_DOWN);
1074                         }
1075                     } else if (st->codec->time_base.num != 0 &&
1076                                st->codec->time_base.den != 0) {
1077                         pkt->duration = av_rescale_q_rnd(st->parser->duration,
1078                                                          st->codec->time_base,
1079                                                          st->time_base,
1080                                                          AV_ROUND_DOWN);
1081                     }
1082                     pkt->stream_index = st->index;
1083                     pkt->pts = st->parser->pts;
1084                     pkt->dts = st->parser->dts;
1085                     pkt->pos = st->parser->pos;
1086                     if (st->parser->key_frame == 1 ||
1087                         (st->parser->key_frame == -1 &&
1088                          st->parser->pict_type == AV_PICTURE_TYPE_I))
1089                         pkt->flags |= AV_PKT_FLAG_KEY;
1090                     if(pkt->data == st->cur_pkt.data && pkt->size == st->cur_pkt.size){
1091                         s->cur_st = NULL;
1092                         pkt->destruct= st->cur_pkt.destruct;
1093                         st->cur_pkt.destruct= NULL;
1094                         st->cur_pkt.data    = NULL;
1095                         assert(st->cur_len == 0);
1096                     }else{
1097                         pkt->destruct = NULL;
1098                     }
1099                     compute_pkt_fields(s, st, st->parser, pkt);
1100
1101                     if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY){
1102                         ff_reduce_index(s, st->index);
1103                         av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
1104                                            0, 0, AVINDEX_KEYFRAME);
1105                     }
1106
1107                     break;
1108                 }
1109             } else {
1110                 /* free packet */
1111                 av_free_packet(&st->cur_pkt);
1112                 s->cur_st = NULL;
1113             }
1114         } else {
1115             AVPacket cur_pkt;
1116             /* read next packet */
1117             ret = av_read_packet(s, &cur_pkt);
1118             if (ret < 0) {
1119                 if (ret == AVERROR(EAGAIN))
1120                     return ret;
1121                 /* return the last frames, if any */
1122                 for(i = 0; i < s->nb_streams; i++) {
1123                     st = s->streams[i];
1124                     if (st->parser && st->need_parsing) {
1125                         av_parser_parse2(st->parser, st->codec,
1126                                         &pkt->data, &pkt->size,
1127                                         NULL, 0,
1128                                         AV_NOPTS_VALUE, AV_NOPTS_VALUE,
1129                                         AV_NOPTS_VALUE);
1130                         if (pkt->size)
1131                             goto got_packet;
1132                     }
1133                 }
1134                 /* no more packets: really terminate parsing */
1135                 return ret;
1136             }
1137             st = s->streams[cur_pkt.stream_index];
1138             st->cur_pkt= cur_pkt;
1139
1140             if(st->cur_pkt.pts != AV_NOPTS_VALUE &&
1141                st->cur_pkt.dts != AV_NOPTS_VALUE &&
1142                st->cur_pkt.pts < st->cur_pkt.dts){
1143                 av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
1144                     st->cur_pkt.stream_index,
1145                     st->cur_pkt.pts,
1146                     st->cur_pkt.dts,
1147                     st->cur_pkt.size);
1148 //                av_free_packet(&st->cur_pkt);
1149 //                return -1;
1150             }
1151
1152             if(s->debug & FF_FDEBUG_TS)
1153                 av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1154                     st->cur_pkt.stream_index,
1155                     st->cur_pkt.pts,
1156                     st->cur_pkt.dts,
1157                     st->cur_pkt.size,
1158                     st->cur_pkt.duration,
1159                     st->cur_pkt.flags);
1160
1161             s->cur_st = st;
1162             st->cur_ptr = st->cur_pkt.data;
1163             st->cur_len = st->cur_pkt.size;
1164             if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1165                 st->parser = av_parser_init(st->codec->codec_id);
1166                 if (!st->parser) {
1167                     /* no parser available: just output the raw packets */
1168                     st->need_parsing = AVSTREAM_PARSE_NONE;
1169                 }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
1170                     st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1171                 }else if(st->need_parsing == AVSTREAM_PARSE_FULL_ONCE){
1172                     st->parser->flags |= PARSER_FLAG_ONCE;
1173                 }
1174             }
1175         }
1176     }
1177     if(s->debug & FF_FDEBUG_TS)
1178         av_log(s, AV_LOG_DEBUG, "read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1179             pkt->stream_index,
1180             pkt->pts,
1181             pkt->dts,
1182             pkt->size,
1183             pkt->duration,
1184             pkt->flags);
1185
1186     return 0;
1187 }
1188
1189 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1190 {
1191     const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1192     int          eof = 0;
1193
1194     if (!genpts)
1195         return s->packet_buffer ? read_from_packet_buffer(&s->packet_buffer,
1196                                                           &s->packet_buffer_end,
1197                                                           pkt) :
1198                                   read_frame_internal(s, pkt);
1199
1200     for (;;) {
1201         int ret;
1202         AVPacketList *pktl = s->packet_buffer;
1203
1204         if (pktl) {
1205             AVPacket *next_pkt = &pktl->pkt;
1206
1207             if (next_pkt->dts != AV_NOPTS_VALUE) {
1208                 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1209                 while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1210                     if (pktl->pkt.stream_index == next_pkt->stream_index &&
1211                         (av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)) < 0) &&
1212                          av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) { //not b frame
1213                         next_pkt->pts = pktl->pkt.dts;
1214                     }
1215                     pktl = pktl->next;
1216                 }
1217                 pktl = s->packet_buffer;
1218             }
1219
1220             /* read packet from packet buffer, if there is data */
1221             if (!(next_pkt->pts == AV_NOPTS_VALUE &&
1222                   next_pkt->dts != AV_NOPTS_VALUE && !eof))
1223                 return read_from_packet_buffer(&s->packet_buffer,
1224                                                &s->packet_buffer_end, pkt);
1225         }
1226
1227         ret = read_frame_internal(s, pkt);
1228         if (ret < 0) {
1229             if (pktl && ret != AVERROR(EAGAIN)) {
1230                 eof = 1;
1231                 continue;
1232             } else
1233                 return ret;
1234         }
1235
1236         if (av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1237                           &s->packet_buffer_end)) < 0)
1238             return AVERROR(ENOMEM);
1239     }
1240 }
1241
1242 /* XXX: suppress the packet queue */
1243 static void flush_packet_queue(AVFormatContext *s)
1244 {
1245     free_packet_buffer(&s->packet_buffer,     &s->packet_buffer_end);
1246     free_packet_buffer(&s->raw_packet_buffer, &s->raw_packet_buffer_end);
1247
1248     s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1249 }
1250
1251 /*******************************************************/
1252 /* seek support */
1253
1254 int av_find_default_stream_index(AVFormatContext *s)
1255 {
1256     int first_audio_index = -1;
1257     int i;
1258     AVStream *st;
1259
1260     if (s->nb_streams <= 0)
1261         return -1;
1262     for(i = 0; i < s->nb_streams; i++) {
1263         st = s->streams[i];
1264         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1265             return i;
1266         }
1267         if (first_audio_index < 0 && st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1268             first_audio_index = i;
1269     }
1270     return first_audio_index >= 0 ? first_audio_index : 0;
1271 }
1272
1273 /**
1274  * Flush the frame reader.
1275  */
1276 void ff_read_frame_flush(AVFormatContext *s)
1277 {
1278     AVStream *st;
1279     int i, j;
1280
1281     flush_packet_queue(s);
1282
1283     s->cur_st = NULL;
1284
1285     /* for each stream, reset read state */
1286     for(i = 0; i < s->nb_streams; i++) {
1287         st = s->streams[i];
1288
1289         if (st->parser) {
1290             av_parser_close(st->parser);
1291             st->parser = NULL;
1292             av_free_packet(&st->cur_pkt);
1293         }
1294         st->last_IP_pts = AV_NOPTS_VALUE;
1295         st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1296         st->reference_dts = AV_NOPTS_VALUE;
1297         /* fail safe */
1298         st->cur_ptr = NULL;
1299         st->cur_len = 0;
1300
1301         st->probe_packets = MAX_PROBE_PACKETS;
1302
1303         for(j=0; j<MAX_REORDER_DELAY+1; j++)
1304             st->pts_buffer[j]= AV_NOPTS_VALUE;
1305     }
1306 }
1307
1308 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1309 {
1310     int i;
1311
1312     for(i = 0; i < s->nb_streams; i++) {
1313         AVStream *st = s->streams[i];
1314
1315         st->cur_dts = av_rescale(timestamp,
1316                                  st->time_base.den * (int64_t)ref_st->time_base.num,
1317                                  st->time_base.num * (int64_t)ref_st->time_base.den);
1318     }
1319 }
1320
1321 void ff_reduce_index(AVFormatContext *s, int stream_index)
1322 {
1323     AVStream *st= s->streams[stream_index];
1324     unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1325
1326     if((unsigned)st->nb_index_entries >= max_entries){
1327         int i;
1328         for(i=0; 2*i<st->nb_index_entries; i++)
1329             st->index_entries[i]= st->index_entries[2*i];
1330         st->nb_index_entries= i;
1331     }
1332 }
1333
1334 int ff_add_index_entry(AVIndexEntry **index_entries,
1335                        int *nb_index_entries,
1336                        unsigned int *index_entries_allocated_size,
1337                        int64_t pos, int64_t timestamp, int size, int distance, int flags)
1338 {
1339     AVIndexEntry *entries, *ie;
1340     int index;
1341
1342     if((unsigned)*nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1343         return -1;
1344
1345     entries = av_fast_realloc(*index_entries,
1346                               index_entries_allocated_size,
1347                               (*nb_index_entries + 1) *
1348                               sizeof(AVIndexEntry));
1349     if(!entries)
1350         return -1;
1351
1352     *index_entries= entries;
1353
1354     index= ff_index_search_timestamp(*index_entries, *nb_index_entries, timestamp, AVSEEK_FLAG_ANY);
1355
1356     if(index<0){
1357         index= (*nb_index_entries)++;
1358         ie= &entries[index];
1359         assert(index==0 || ie[-1].timestamp < timestamp);
1360     }else{
1361         ie= &entries[index];
1362         if(ie->timestamp != timestamp){
1363             if(ie->timestamp <= timestamp)
1364                 return -1;
1365             memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(*nb_index_entries - index));
1366             (*nb_index_entries)++;
1367         }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1368             distance= ie->min_distance;
1369     }
1370
1371     ie->pos = pos;
1372     ie->timestamp = timestamp;
1373     ie->min_distance= distance;
1374     ie->size= size;
1375     ie->flags = flags;
1376
1377     return index;
1378 }
1379
1380 int av_add_index_entry(AVStream *st,
1381                        int64_t pos, int64_t timestamp, int size, int distance, int flags)
1382 {
1383     return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1384                               &st->index_entries_allocated_size, pos,
1385                               timestamp, size, distance, flags);
1386 }
1387
1388 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1389                               int64_t wanted_timestamp, int flags)
1390 {
1391     int a, b, m;
1392     int64_t timestamp;
1393
1394     a = - 1;
1395     b = nb_entries;
1396
1397     //optimize appending index entries at the end
1398     if(b && entries[b-1].timestamp < wanted_timestamp)
1399         a= b-1;
1400
1401     while (b - a > 1) {
1402         m = (a + b) >> 1;
1403         timestamp = entries[m].timestamp;
1404         if(timestamp >= wanted_timestamp)
1405             b = m;
1406         if(timestamp <= wanted_timestamp)
1407             a = m;
1408     }
1409     m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1410
1411     if(!(flags & AVSEEK_FLAG_ANY)){
1412         while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1413             m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1414         }
1415     }
1416
1417     if(m == nb_entries)
1418         return -1;
1419     return  m;
1420 }
1421
1422 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1423                               int flags)
1424 {
1425     return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
1426                                      wanted_timestamp, flags);
1427 }
1428
1429 int ff_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags)
1430 {
1431     AVInputFormat *avif= s->iformat;
1432     int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1433     int64_t ts_min, ts_max, ts;
1434     int index;
1435     int64_t ret;
1436     AVStream *st;
1437
1438     if (stream_index < 0)
1439         return -1;
1440
1441     av_dlog(s, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1442
1443     ts_max=
1444     ts_min= AV_NOPTS_VALUE;
1445     pos_limit= -1; //gcc falsely says it may be uninitialized
1446
1447     st= s->streams[stream_index];
1448     if(st->index_entries){
1449         AVIndexEntry *e;
1450
1451         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()
1452         index= FFMAX(index, 0);
1453         e= &st->index_entries[index];
1454
1455         if(e->timestamp <= target_ts || e->pos == e->min_distance){
1456             pos_min= e->pos;
1457             ts_min= e->timestamp;
1458             av_dlog(s, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1459                     pos_min,ts_min);
1460         }else{
1461             assert(index==0);
1462         }
1463
1464         index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1465         assert(index < st->nb_index_entries);
1466         if(index >= 0){
1467             e= &st->index_entries[index];
1468             assert(e->timestamp >= target_ts);
1469             pos_max= e->pos;
1470             ts_max= e->timestamp;
1471             pos_limit= pos_max - e->min_distance;
1472             av_dlog(s, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1473                     pos_max,pos_limit, ts_max);
1474         }
1475     }
1476
1477     pos= ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1478     if(pos<0)
1479         return -1;
1480
1481     /* do the seek */
1482     if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
1483         return ret;
1484
1485     ff_update_cur_dts(s, st, ts);
1486
1487     return 0;
1488 }
1489
1490 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
1491                       int64_t pos_min, int64_t pos_max, int64_t pos_limit,
1492                       int64_t ts_min, int64_t ts_max, int flags, int64_t *ts_ret,
1493                       int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1494 {
1495     int64_t pos, ts;
1496     int64_t start_pos, filesize;
1497     int no_change;
1498
1499     av_dlog(s, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1500
1501     if(ts_min == AV_NOPTS_VALUE){
1502         pos_min = s->data_offset;
1503         ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1504         if (ts_min == AV_NOPTS_VALUE)
1505             return -1;
1506     }
1507
1508     if(ts_max == AV_NOPTS_VALUE){
1509         int step= 1024;
1510         filesize = avio_size(s->pb);
1511         pos_max = filesize - 1;
1512         do{
1513             pos_max -= step;
1514             ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1515             step += step;
1516         }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1517         if (ts_max == AV_NOPTS_VALUE)
1518             return -1;
1519
1520         for(;;){
1521             int64_t tmp_pos= pos_max + 1;
1522             int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1523             if(tmp_ts == AV_NOPTS_VALUE)
1524                 break;
1525             ts_max= tmp_ts;
1526             pos_max= tmp_pos;
1527             if(tmp_pos >= filesize)
1528                 break;
1529         }
1530         pos_limit= pos_max;
1531     }
1532
1533     if(ts_min > ts_max){
1534         return -1;
1535     }else if(ts_min == ts_max){
1536         pos_limit= pos_min;
1537     }
1538
1539     no_change=0;
1540     while (pos_min < pos_limit) {
1541         av_dlog(s, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1542                 pos_min, pos_max, ts_min, ts_max);
1543         assert(pos_limit <= pos_max);
1544
1545         if(no_change==0){
1546             int64_t approximate_keyframe_distance= pos_max - pos_limit;
1547             // interpolate position (better than dichotomy)
1548             pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1549                 + pos_min - approximate_keyframe_distance;
1550         }else if(no_change==1){
1551             // bisection, if interpolation failed to change min or max pos last time
1552             pos = (pos_min + pos_limit)>>1;
1553         }else{
1554             /* linear search if bisection failed, can only happen if there
1555                are very few or no keyframes between min/max */
1556             pos=pos_min;
1557         }
1558         if(pos <= pos_min)
1559             pos= pos_min + 1;
1560         else if(pos > pos_limit)
1561             pos= pos_limit;
1562         start_pos= pos;
1563
1564         ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1565         if(pos == pos_max)
1566             no_change++;
1567         else
1568             no_change=0;
1569         av_dlog(s, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64" target:%"PRId64" limit:%"PRId64" start:%"PRId64" noc:%d\n",
1570                 pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts,
1571                 pos_limit, start_pos, no_change);
1572         if(ts == AV_NOPTS_VALUE){
1573             av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1574             return -1;
1575         }
1576         assert(ts != AV_NOPTS_VALUE);
1577         if (target_ts <= ts) {
1578             pos_limit = start_pos - 1;
1579             pos_max = pos;
1580             ts_max = ts;
1581         }
1582         if (target_ts >= ts) {
1583             pos_min = pos;
1584             ts_min = ts;
1585         }
1586     }
1587
1588     pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1589     ts  = (flags & AVSEEK_FLAG_BACKWARD) ?  ts_min :  ts_max;
1590     pos_min = pos;
1591     ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1592     pos_min++;
1593     ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1594     av_dlog(s, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1595             pos, ts_min, target_ts, ts_max);
1596     *ts_ret= ts;
1597     return pos;
1598 }
1599
1600 static int seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1601     int64_t pos_min, pos_max;
1602 #if 0
1603     AVStream *st;
1604
1605     if (stream_index < 0)
1606         return -1;
1607
1608     st= s->streams[stream_index];
1609 #endif
1610
1611     pos_min = s->data_offset;
1612     pos_max = avio_size(s->pb) - 1;
1613
1614     if     (pos < pos_min) pos= pos_min;
1615     else if(pos > pos_max) pos= pos_max;
1616
1617     avio_seek(s->pb, pos, SEEK_SET);
1618
1619 #if 0
1620     av_update_cur_dts(s, st, ts);
1621 #endif
1622     return 0;
1623 }
1624
1625 static int seek_frame_generic(AVFormatContext *s,
1626                                  int stream_index, int64_t timestamp, int flags)
1627 {
1628     int index;
1629     int64_t ret;
1630     AVStream *st;
1631     AVIndexEntry *ie;
1632
1633     st = s->streams[stream_index];
1634
1635     index = av_index_search_timestamp(st, timestamp, flags);
1636
1637     if(index < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
1638         return -1;
1639
1640     if(index < 0 || index==st->nb_index_entries-1){
1641         AVPacket pkt;
1642
1643         if(st->nb_index_entries){
1644             assert(st->index_entries);
1645             ie= &st->index_entries[st->nb_index_entries-1];
1646             if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1647                 return ret;
1648             ff_update_cur_dts(s, st, ie->timestamp);
1649         }else{
1650             if ((ret = avio_seek(s->pb, s->data_offset, SEEK_SET)) < 0)
1651                 return ret;
1652         }
1653         for (;;) {
1654             int read_status;
1655             do{
1656                 read_status = av_read_frame(s, &pkt);
1657             } while (read_status == AVERROR(EAGAIN));
1658             if (read_status < 0)
1659                 break;
1660             av_free_packet(&pkt);
1661             if(stream_index == pkt.stream_index){
1662                 if((pkt.flags & AV_PKT_FLAG_KEY) && pkt.dts > timestamp)
1663                     break;
1664             }
1665         }
1666         index = av_index_search_timestamp(st, timestamp, flags);
1667     }
1668     if (index < 0)
1669         return -1;
1670
1671     ff_read_frame_flush(s);
1672     if (s->iformat->read_seek){
1673         if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1674             return 0;
1675     }
1676     ie = &st->index_entries[index];
1677     if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1678         return ret;
1679     ff_update_cur_dts(s, st, ie->timestamp);
1680
1681     return 0;
1682 }
1683
1684 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1685 {
1686     int ret;
1687     AVStream *st;
1688
1689     if (flags & AVSEEK_FLAG_BYTE) {
1690         if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
1691             return -1;
1692         ff_read_frame_flush(s);
1693         return seek_frame_byte(s, stream_index, timestamp, flags);
1694     }
1695
1696     if(stream_index < 0){
1697         stream_index= av_find_default_stream_index(s);
1698         if(stream_index < 0)
1699             return -1;
1700
1701         st= s->streams[stream_index];
1702         /* timestamp for default must be expressed in AV_TIME_BASE units */
1703         timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1704     }
1705
1706     /* first, we try the format specific seek */
1707     if (s->iformat->read_seek) {
1708         ff_read_frame_flush(s);
1709         ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1710     } else
1711         ret = -1;
1712     if (ret >= 0) {
1713         return 0;
1714     }
1715
1716     if (s->iformat->read_timestamp && !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
1717         ff_read_frame_flush(s);
1718         return ff_seek_frame_binary(s, stream_index, timestamp, flags);
1719     } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
1720         ff_read_frame_flush(s);
1721         return seek_frame_generic(s, stream_index, timestamp, flags);
1722     }
1723     else
1724         return -1;
1725 }
1726
1727 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
1728 {
1729     if(min_ts > ts || max_ts < ts)
1730         return -1;
1731
1732     if (s->iformat->read_seek2) {
1733         ff_read_frame_flush(s);
1734         return s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
1735     }
1736
1737     if(s->iformat->read_timestamp){
1738         //try to seek via read_timestamp()
1739     }
1740
1741     //Fallback to old API if new is not implemented but old is
1742     //Note the old has somewat different sematics
1743     if(s->iformat->read_seek || 1)
1744         return av_seek_frame(s, stream_index, ts, flags | (ts - min_ts > (uint64_t)(max_ts - ts) ? AVSEEK_FLAG_BACKWARD : 0));
1745
1746     // try some generic seek like seek_frame_generic() but with new ts semantics
1747 }
1748
1749 /*******************************************************/
1750
1751 /**
1752  * Return TRUE if the stream has accurate duration in any stream.
1753  *
1754  * @return TRUE if the stream has accurate duration for at least one component.
1755  */
1756 static int has_duration(AVFormatContext *ic)
1757 {
1758     int i;
1759     AVStream *st;
1760
1761     for(i = 0;i < ic->nb_streams; i++) {
1762         st = ic->streams[i];
1763         if (st->duration != AV_NOPTS_VALUE)
1764             return 1;
1765     }
1766     return 0;
1767 }
1768
1769 /**
1770  * Estimate the stream timings from the one of each components.
1771  *
1772  * Also computes the global bitrate if possible.
1773  */
1774 static void update_stream_timings(AVFormatContext *ic)
1775 {
1776     int64_t start_time, start_time1, end_time, end_time1;
1777     int64_t duration, duration1, filesize;
1778     int i;
1779     AVStream *st;
1780
1781     start_time = INT64_MAX;
1782     end_time = INT64_MIN;
1783     duration = INT64_MIN;
1784     for(i = 0;i < ic->nb_streams; i++) {
1785         st = ic->streams[i];
1786         if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
1787             start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1788             start_time = FFMIN(start_time, start_time1);
1789             if (st->duration != AV_NOPTS_VALUE) {
1790                 end_time1 = start_time1
1791                           + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1792                 end_time = FFMAX(end_time, end_time1);
1793             }
1794         }
1795         if (st->duration != AV_NOPTS_VALUE) {
1796             duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1797             duration = FFMAX(duration, duration1);
1798         }
1799     }
1800     if (start_time != INT64_MAX) {
1801         ic->start_time = start_time;
1802         if (end_time != INT64_MIN)
1803             duration = FFMAX(duration, end_time - start_time);
1804     }
1805     if (duration != INT64_MIN) {
1806         ic->duration = duration;
1807         if (ic->pb && (filesize = avio_size(ic->pb)) > 0) {
1808             /* compute the bitrate */
1809             ic->bit_rate = (double)filesize * 8.0 * AV_TIME_BASE /
1810                 (double)ic->duration;
1811         }
1812     }
1813 }
1814
1815 static void fill_all_stream_timings(AVFormatContext *ic)
1816 {
1817     int i;
1818     AVStream *st;
1819
1820     update_stream_timings(ic);
1821     for(i = 0;i < ic->nb_streams; i++) {
1822         st = ic->streams[i];
1823         if (st->start_time == AV_NOPTS_VALUE) {
1824             if(ic->start_time != AV_NOPTS_VALUE)
1825                 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1826             if(ic->duration != AV_NOPTS_VALUE)
1827                 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1828         }
1829     }
1830 }
1831
1832 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
1833 {
1834     int64_t filesize, duration;
1835     int bit_rate, i;
1836     AVStream *st;
1837
1838     /* if bit_rate is already set, we believe it */
1839     if (ic->bit_rate <= 0) {
1840         bit_rate = 0;
1841         for(i=0;i<ic->nb_streams;i++) {
1842             st = ic->streams[i];
1843             if (st->codec->bit_rate > 0)
1844             bit_rate += st->codec->bit_rate;
1845         }
1846         ic->bit_rate = bit_rate;
1847     }
1848
1849     /* if duration is already set, we believe it */
1850     if (ic->duration == AV_NOPTS_VALUE &&
1851         ic->bit_rate != 0) {
1852         filesize = ic->pb ? avio_size(ic->pb) : 0;
1853         if (filesize > 0) {
1854             for(i = 0; i < ic->nb_streams; i++) {
1855                 st = ic->streams[i];
1856                 duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1857                 if (st->duration == AV_NOPTS_VALUE)
1858                     st->duration = duration;
1859             }
1860         }
1861     }
1862 }
1863
1864 #define DURATION_MAX_READ_SIZE 250000
1865 #define DURATION_MAX_RETRY 3
1866
1867 /* only usable for MPEG-PS streams */
1868 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
1869 {
1870     AVPacket pkt1, *pkt = &pkt1;
1871     AVStream *st;
1872     int read_size, i, ret;
1873     int64_t end_time;
1874     int64_t filesize, offset, duration;
1875     int retry=0;
1876
1877     ic->cur_st = NULL;
1878
1879     /* flush packet queue */
1880     flush_packet_queue(ic);
1881
1882     for (i=0; i<ic->nb_streams; i++) {
1883         st = ic->streams[i];
1884         if (st->start_time == AV_NOPTS_VALUE && st->first_dts == AV_NOPTS_VALUE)
1885             av_log(st->codec, AV_LOG_WARNING, "start time is not set in estimate_timings_from_pts\n");
1886
1887         if (st->parser) {
1888             av_parser_close(st->parser);
1889             st->parser= NULL;
1890             av_free_packet(&st->cur_pkt);
1891         }
1892     }
1893
1894     /* estimate the end time (duration) */
1895     /* XXX: may need to support wrapping */
1896     filesize = ic->pb ? avio_size(ic->pb) : 0;
1897     end_time = AV_NOPTS_VALUE;
1898     do{
1899         offset = filesize - (DURATION_MAX_READ_SIZE<<retry);
1900         if (offset < 0)
1901             offset = 0;
1902
1903         avio_seek(ic->pb, offset, SEEK_SET);
1904         read_size = 0;
1905         for(;;) {
1906             if (read_size >= DURATION_MAX_READ_SIZE<<(FFMAX(retry-1,0)))
1907                 break;
1908
1909             do {
1910                 ret = av_read_packet(ic, pkt);
1911             } while(ret == AVERROR(EAGAIN));
1912             if (ret != 0)
1913                 break;
1914             read_size += pkt->size;
1915             st = ic->streams[pkt->stream_index];
1916             if (pkt->pts != AV_NOPTS_VALUE &&
1917                 (st->start_time != AV_NOPTS_VALUE ||
1918                  st->first_dts  != AV_NOPTS_VALUE)) {
1919                 duration = end_time = pkt->pts;
1920                 if (st->start_time != AV_NOPTS_VALUE)
1921                     duration -= st->start_time;
1922                 else
1923                     duration -= st->first_dts;
1924                 if (duration < 0)
1925                     duration += 1LL<<st->pts_wrap_bits;
1926                 if (duration > 0) {
1927                     if (st->duration == AV_NOPTS_VALUE || st->duration < duration)
1928                         st->duration = duration;
1929                 }
1930             }
1931             av_free_packet(pkt);
1932         }
1933     }while(   end_time==AV_NOPTS_VALUE
1934            && filesize > (DURATION_MAX_READ_SIZE<<retry)
1935            && ++retry <= DURATION_MAX_RETRY);
1936
1937     fill_all_stream_timings(ic);
1938
1939     avio_seek(ic->pb, old_offset, SEEK_SET);
1940     for (i=0; i<ic->nb_streams; i++) {
1941         st= ic->streams[i];
1942         st->cur_dts= st->first_dts;
1943         st->last_IP_pts = AV_NOPTS_VALUE;
1944         st->reference_dts = AV_NOPTS_VALUE;
1945     }
1946 }
1947
1948 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
1949 {
1950     int64_t file_size;
1951
1952     /* get the file size, if possible */
1953     if (ic->iformat->flags & AVFMT_NOFILE) {
1954         file_size = 0;
1955     } else {
1956         file_size = avio_size(ic->pb);
1957         file_size = FFMAX(0, file_size);
1958     }
1959
1960     if ((!strcmp(ic->iformat->name, "mpeg") ||
1961          !strcmp(ic->iformat->name, "mpegts")) &&
1962         file_size && ic->pb->seekable) {
1963         /* get accurate estimate from the PTSes */
1964         estimate_timings_from_pts(ic, old_offset);
1965     } else if (has_duration(ic)) {
1966         /* at least one component has timings - we use them for all
1967            the components */
1968         fill_all_stream_timings(ic);
1969     } else {
1970         av_log(ic, AV_LOG_WARNING, "Estimating duration from bitrate, this may be inaccurate\n");
1971         /* less precise: use bitrate info */
1972         estimate_timings_from_bit_rate(ic);
1973     }
1974     update_stream_timings(ic);
1975
1976     {
1977         int i;
1978         AVStream av_unused *st;
1979         for(i = 0;i < ic->nb_streams; i++) {
1980             st = ic->streams[i];
1981             av_dlog(ic, "%d: start_time: %0.3f duration: %0.3f\n", i,
1982                     (double) st->start_time / AV_TIME_BASE,
1983                     (double) st->duration   / AV_TIME_BASE);
1984         }
1985         av_dlog(ic, "stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1986                 (double) ic->start_time / AV_TIME_BASE,
1987                 (double) ic->duration   / AV_TIME_BASE,
1988                 ic->bit_rate / 1000);
1989     }
1990 }
1991
1992 static int has_codec_parameters(AVCodecContext *avctx)
1993 {
1994     int val;
1995     switch (avctx->codec_type) {
1996     case AVMEDIA_TYPE_AUDIO:
1997         val = avctx->sample_rate && avctx->channels && avctx->sample_fmt != AV_SAMPLE_FMT_NONE;
1998         if (!avctx->frame_size &&
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 }