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

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