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