libavformat/utils.c

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