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