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

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