libavformat/utils.c

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