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