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