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

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