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