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