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