git.sesse.net Git - ffmpeg/blob - libavformat/utils.c

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