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