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

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