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