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

   1 /*
   2  * Various utilities for ffmpeg system
   3  * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18  */
  19 #include "avformat.h"
  20
  21 #undef NDEBUG
  22 #include <assert.h>
  23
  24 AVInputFormat *first_iformat;
  25 AVOutputFormat *first_oformat;
  26 AVImageFormat *first_image_format;
  27
  28 void av_register_input_format(AVInputFormat *format)
  29 {
  30     AVInputFormat **p;
  31     p = &first_iformat;
  32     while (*p != NULL) p = &(*p)->next;
  33     *p = format;
  34     format->next = NULL;
  35 }
  36
  37 void av_register_output_format(AVOutputFormat *format)
  38 {
  39     AVOutputFormat **p;
  40     p = &first_oformat;
  41     while (*p != NULL) p = &(*p)->next;
  42     *p = format;
  43     format->next = NULL;
  44 }
  45
  46 int match_ext(const char *filename, const char *extensions)
  47 {
  48     const char *ext, *p;
  49     char ext1[32], *q;
  50
  51     ext = strrchr(filename, '.');
  52     if (ext) {
  53         ext++;
  54         p = extensions;
  55         for(;;) {
  56             q = ext1;
  57             while (*p != '\0' && *p != ',')
  58                 *q++ = *p++;
  59             *q = '\0';
  60             if (!strcasecmp(ext1, ext))
  61                 return 1;
  62             if (*p == '\0')
  63                 break;
  64             p++;
  65         }
  66     }
  67     return 0;
  68 }
  69
  70 AVOutputFormat *guess_format(const char *short_name, const char *filename,
  71                              const char *mime_type)
  72 {
  73     AVOutputFormat *fmt, *fmt_found;
  74     int score_max, score;
  75
  76     /* specific test for image sequences */
  77     if (!short_name && filename &&
  78         filename_number_test(filename) >= 0 &&
  79         guess_image_format(filename)) {
  80         return guess_format("image", NULL, NULL);
  81     }
  82
  83     /* find the proper file type */
  84     fmt_found = NULL;
  85     score_max = 0;
  86     fmt = first_oformat;
  87     while (fmt != NULL) {
  88         score = 0;
  89         if (fmt->name && short_name && !strcmp(fmt->name, short_name))
  90             score += 100;
  91         if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
  92             score += 10;
  93         if (filename && fmt->extensions &&
  94             match_ext(filename, fmt->extensions)) {
  95             score += 5;
  96         }
  97         if (score > score_max) {
  98             score_max = score;
  99             fmt_found = fmt;
 100         }
 101         fmt = fmt->next;
 102     }
 103     return fmt_found;
 104 }
 105
 106 AVOutputFormat *guess_stream_format(const char *short_name, const char *filename,
 107                              const char *mime_type)
 108 {
 109     AVOutputFormat *fmt = guess_format(short_name, filename, mime_type);
 110
 111     if (fmt) {
 112         AVOutputFormat *stream_fmt;
 113         char stream_format_name[64];
 114
 115         snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
 116         stream_fmt = guess_format(stream_format_name, NULL, NULL);
 117
 118         if (stream_fmt)
 119             fmt = stream_fmt;
 120     }
 121
 122     return fmt;
 123 }
 124
 125 AVInputFormat *av_find_input_format(const char *short_name)
 126 {
 127     AVInputFormat *fmt;
 128     for(fmt = first_iformat; fmt != NULL; fmt = fmt->next) {
 129         if (!strcmp(fmt->name, short_name))
 130             return fmt;
 131     }
 132     return NULL;
 133 }
 134
 135 /* memory handling */
 136
 137 /**
 138  * Default packet destructor
 139  */
 140 static void av_destruct_packet(AVPacket *pkt)
 141 {
 142     av_free(pkt->data);
 143     pkt->data = NULL; pkt->size = 0;
 144 }
 145
 146 /**
 147  * Allocate the payload of a packet and intialized its fields to default values.
 148  *
 149  * @param pkt packet
 150  * @param size wanted payload size
 151  * @return 0 if OK. AVERROR_xxx otherwise.
 152  */
 153 int av_new_packet(AVPacket *pkt, int size)
 154 {
 155     void *data = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
 156     if (!data)
 157         return AVERROR_NOMEM;
 158     memset(data + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
 159
 160     av_init_packet(pkt);
 161     pkt->data = data;
 162     pkt->size = size;
 163     pkt->destruct = av_destruct_packet;
 164     return 0;
 165 }
 166
 167 /* This is a hack - the packet memory allocation stuff is broken. The
 168    packet is allocated if it was not really allocated */
 169 int av_dup_packet(AVPacket *pkt)
 170 {
 171     if (pkt->destruct != av_destruct_packet) {
 172         uint8_t *data;
 173         /* we duplicate the packet and don't forget to put the padding
 174            again */
 175         data = av_malloc(pkt->size + FF_INPUT_BUFFER_PADDING_SIZE);
 176         if (!data) {
 177             return AVERROR_NOMEM;
 178         }
 179         memcpy(data, pkt->data, pkt->size);
 180         memset(data + pkt->size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
 181         pkt->data = data;
 182         pkt->destruct = av_destruct_packet;
 183     }
 184     return 0;
 185 }
 186
 187 /* fifo handling */
 188
 189 int fifo_init(FifoBuffer *f, int size)
 190 {
 191     f->buffer = av_malloc(size);
 192     if (!f->buffer)
 193         return -1;
 194     f->end = f->buffer + size;
 195     f->wptr = f->rptr = f->buffer;
 196     return 0;
 197 }
 198
 199 void fifo_free(FifoBuffer *f)
 200 {
 201     av_free(f->buffer);
 202 }
 203
 204 int fifo_size(FifoBuffer *f, uint8_t *rptr)
 205 {
 206     int size;
 207
 208     if (f->wptr >= rptr) {
 209         size = f->wptr - rptr;
 210     } else {
 211         size = (f->end - rptr) + (f->wptr - f->buffer);
 212     }
 213     return size;
 214 }
 215
 216 /* get data from the fifo (return -1 if not enough data) */
 217 int fifo_read(FifoBuffer *f, uint8_t *buf, int buf_size, uint8_t **rptr_ptr)
 218 {
 219     uint8_t *rptr = *rptr_ptr;
 220     int size, len;
 221
 222     if (f->wptr >= rptr) {
 223         size = f->wptr - rptr;
 224     } else {
 225         size = (f->end - rptr) + (f->wptr - f->buffer);
 226     }
 227
 228     if (size < buf_size)
 229         return -1;
 230     while (buf_size > 0) {
 231         len = f->end - rptr;
 232         if (len > buf_size)
 233             len = buf_size;
 234         memcpy(buf, rptr, len);
 235         buf += len;
 236         rptr += len;
 237         if (rptr >= f->end)
 238             rptr = f->buffer;
 239         buf_size -= len;
 240     }
 241     *rptr_ptr = rptr;
 242     return 0;
 243 }
 244
 245 void fifo_write(FifoBuffer *f, uint8_t *buf, int size, uint8_t **wptr_ptr)
 246 {
 247     int len;
 248     uint8_t *wptr;
 249     wptr = *wptr_ptr;
 250     while (size > 0) {
 251         len = f->end - wptr;
 252         if (len > size)
 253             len = size;
 254         memcpy(wptr, buf, len);
 255         wptr += len;
 256         if (wptr >= f->end)
 257             wptr = f->buffer;
 258         buf += len;
 259         size -= len;
 260     }
 261     *wptr_ptr = wptr;
 262 }
 263
 264 int filename_number_test(const char *filename)
 265 {
 266     char buf[1024];
 267     return get_frame_filename(buf, sizeof(buf), filename, 1);
 268 }
 269
 270 /* guess file format */
 271 AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened)
 272 {
 273     AVInputFormat *fmt1, *fmt;
 274     int score, score_max;
 275
 276     fmt = NULL;
 277     score_max = 0;
 278     for(fmt1 = first_iformat; fmt1 != NULL; fmt1 = fmt1->next) {
 279         if (!is_opened && !(fmt1->flags & AVFMT_NOFILE))
 280             continue;
 281         score = 0;
 282         if (fmt1->read_probe) {
 283             score = fmt1->read_probe(pd);
 284         } else if (fmt1->extensions) {
 285             if (match_ext(pd->filename, fmt1->extensions)) {
 286                 score = 50;
 287             }
 288         }
 289         if (score > score_max) {
 290             score_max = score;
 291             fmt = fmt1;
 292         }
 293     }
 294     return fmt;
 295 }
 296
 297 /************************************************************/
 298 /* input media file */
 299
 300 /**
 301  * open a media file from an IO stream. 'fmt' must be specified.
 302  */
 303
 304 static const char* format_to_name(void* ptr)
 305 {
 306     AVFormatContext* fc = (AVFormatContext*) ptr;
 307     if(fc->iformat) return fc->iformat->name;
 308     else if(fc->oformat) return fc->oformat->name;
 309     else return "NULL";
 310 }
 311
 312 static const AVClass av_format_context_class = { "AVFormatContext", format_to_name };
 313
 314 AVFormatContext *av_alloc_format_context(void)
 315 {
 316     AVFormatContext *ic;
 317     ic = av_mallocz(sizeof(AVFormatContext));
 318     if (!ic) return ic;
 319     ic->av_class = &av_format_context_class;
 320     return ic;
 321 }
 322
 323 int av_open_input_stream(AVFormatContext **ic_ptr,
 324                          ByteIOContext *pb, const char *filename,
 325                          AVInputFormat *fmt, AVFormatParameters *ap)
 326 {
 327     int err;
 328     AVFormatContext *ic;
 329
 330     ic = av_alloc_format_context();
 331     if (!ic) {
 332         err = AVERROR_NOMEM;
 333         goto fail;
 334     }
 335     ic->iformat = fmt;
 336     if (pb)
 337         ic->pb = *pb;
 338     ic->duration = AV_NOPTS_VALUE;
 339     ic->start_time = AV_NOPTS_VALUE;
 340     pstrcpy(ic->filename, sizeof(ic->filename), filename);
 341
 342     /* allocate private data */
 343     if (fmt->priv_data_size > 0) {
 344         ic->priv_data = av_mallocz(fmt->priv_data_size);
 345         if (!ic->priv_data) {
 346             err = AVERROR_NOMEM;
 347             goto fail;
 348         }
 349     } else {
 350         ic->priv_data = NULL;
 351     }
 352
 353     /* default pts settings is MPEG like */
 354     av_set_pts_info(ic, 33, 1, 90000);
 355     ic->last_pkt_pts = AV_NOPTS_VALUE;
 356     ic->last_pkt_dts = AV_NOPTS_VALUE;
 357     ic->last_pkt_stream_pts = AV_NOPTS_VALUE;
 358     ic->last_pkt_stream_dts = AV_NOPTS_VALUE;
 359
 360     err = ic->iformat->read_header(ic, ap);
 361     if (err < 0)
 362         goto fail;
 363
 364     if (pb)
 365         ic->data_offset = url_ftell(&ic->pb);
 366
 367     *ic_ptr = ic;
 368     return 0;
 369  fail:
 370     if (ic) {
 371         av_freep(&ic->priv_data);
 372     }
 373     av_free(ic);
 374     *ic_ptr = NULL;
 375     return err;
 376 }
 377
 378 #define PROBE_BUF_SIZE 2048
 379
 380 /**
 381  * Open a media file as input. The codec are not opened. Only the file
 382  * header (if present) is read.
 383  *
 384  * @param ic_ptr the opened media file handle is put here
 385  * @param filename filename to open.
 386  * @param fmt if non NULL, force the file format to use
 387  * @param buf_size optional buffer size (zero if default is OK)
 388  * @param ap additionnal parameters needed when opening the file (NULL if default)
 389  * @return 0 if OK. AVERROR_xxx otherwise.
 390  */
 391 int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
 392                        AVInputFormat *fmt,
 393                        int buf_size,
 394                        AVFormatParameters *ap)
 395 {
 396     int err, must_open_file, file_opened;
 397     uint8_t buf[PROBE_BUF_SIZE];
 398     AVProbeData probe_data, *pd = &probe_data;
 399     ByteIOContext pb1, *pb = &pb1;
 400
 401     file_opened = 0;
 402     pd->filename = "";
 403     if (filename)
 404         pd->filename = filename;
 405     pd->buf = buf;
 406     pd->buf_size = 0;
 407
 408     if (!fmt) {
 409         /* guess format if no file can be opened  */
 410         fmt = av_probe_input_format(pd, 0);
 411     }
 412
 413     /* do not open file if the format does not need it. XXX: specific
 414        hack needed to handle RTSP/TCP */
 415     must_open_file = 1;
 416     if (fmt && (fmt->flags & AVFMT_NOFILE)) {
 417         must_open_file = 0;
 418     }
 419
 420     if (!fmt || must_open_file) {
 421         /* if no file needed do not try to open one */
 422         if (url_fopen(pb, filename, URL_RDONLY) < 0) {
 423             err = AVERROR_IO;
 424             goto fail;
 425         }
 426         file_opened = 1;
 427         if (buf_size > 0) {
 428             url_setbufsize(pb, buf_size);
 429         }
 430         if (!fmt) {
 431             /* read probe data */
 432             pd->buf_size = get_buffer(pb, buf, PROBE_BUF_SIZE);
 433             url_fseek(pb, 0, SEEK_SET);
 434         }
 435     }
 436
 437     /* guess file format */
 438     if (!fmt) {
 439         fmt = av_probe_input_format(pd, 1);
 440     }
 441
 442     /* if still no format found, error */
 443     if (!fmt) {
 444         err = AVERROR_NOFMT;
 445         goto fail;
 446     }
 447
 448     /* XXX: suppress this hack for redirectors */
 449 #ifdef CONFIG_NETWORK
 450     if (fmt == &redir_demux) {
 451         err = redir_open(ic_ptr, pb);
 452         url_fclose(pb);
 453         return err;
 454     }
 455 #endif
 456
 457     /* check filename in case of an image number is expected */
 458     if (fmt->flags & AVFMT_NEEDNUMBER) {
 459         if (filename_number_test(filename) < 0) {
 460             err = AVERROR_NUMEXPECTED;
 461             goto fail;
 462         }
 463     }
 464     err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
 465     if (err)
 466         goto fail;
 467     return 0;
 468  fail:
 469     if (file_opened)
 470         url_fclose(pb);
 471     *ic_ptr = NULL;
 472     return err;
 473
 474 }
 475
 476 /*******************************************************/
 477
 478 /**
 479  * Read a transport packet from a media file. This function is
 480  * absolete and should never be used. Use av_read_frame() instead.
 481  *
 482  * @param s media file handle
 483  * @param pkt is filled
 484  * @return 0 if OK. AVERROR_xxx if error.
 485  */
 486 int av_read_packet(AVFormatContext *s, AVPacket *pkt)
 487 {
 488     return s->iformat->read_packet(s, pkt);
 489 }
 490
 491 /**********************************************************/
 492
 493 /* convert the packet time stamp units and handle wrapping. The
 494    wrapping is handled by considering the next PTS/DTS as a delta to
 495    the previous value. We handle the delta as a fraction to avoid any
 496    rounding errors. */
 497 static inline int64_t convert_timestamp_units(AVFormatContext *s,
 498                                         int64_t *plast_pkt_pts,
 499                                         int *plast_pkt_pts_frac,
 500                                         int64_t *plast_pkt_stream_pts,
 501                                         int64_t pts)
 502 {
 503     int64_t stream_pts;
 504     int64_t delta_pts;
 505     int shift, pts_frac;
 506
 507     if (pts != AV_NOPTS_VALUE) {
 508         stream_pts = pts;
 509         if (*plast_pkt_stream_pts != AV_NOPTS_VALUE) {
 510             shift = 64 - s->pts_wrap_bits;
 511             delta_pts = ((stream_pts - *plast_pkt_stream_pts) << shift) >> shift;
 512             /* XXX: overflow possible but very unlikely as it is a delta */
 513             delta_pts = delta_pts * AV_TIME_BASE * s->pts_num;
 514             pts = *plast_pkt_pts + (delta_pts / s->pts_den);
 515             pts_frac = *plast_pkt_pts_frac + (delta_pts % s->pts_den);
 516             if (pts_frac >= s->pts_den) {
 517                 pts_frac -= s->pts_den;
 518                 pts++;
 519             }
 520         } else {
 521             /* no previous pts, so no wrapping possible */
 522             pts = (int64_t)(((double)stream_pts * AV_TIME_BASE * s->pts_num) /
 523                             (double)s->pts_den);
 524             pts_frac = 0;
 525         }
 526         *plast_pkt_stream_pts = stream_pts;
 527         *plast_pkt_pts = pts;
 528         *plast_pkt_pts_frac = pts_frac;
 529     }
 530     return pts;
 531 }
 532
 533 /* get the number of samples of an audio frame. Return (-1) if error */
 534 static int get_audio_frame_size(AVCodecContext *enc, int size)
 535 {
 536     int frame_size;
 537
 538     if (enc->frame_size <= 1) {
 539         /* specific hack for pcm codecs because no frame size is
 540            provided */
 541         switch(enc->codec_id) {
 542         case CODEC_ID_PCM_S16LE:
 543         case CODEC_ID_PCM_S16BE:
 544         case CODEC_ID_PCM_U16LE:
 545         case CODEC_ID_PCM_U16BE:
 546             if (enc->channels == 0)
 547                 return -1;
 548             frame_size = size / (2 * enc->channels);
 549             break;
 550         case CODEC_ID_PCM_S8:
 551         case CODEC_ID_PCM_U8:
 552         case CODEC_ID_PCM_MULAW:
 553         case CODEC_ID_PCM_ALAW:
 554             if (enc->channels == 0)
 555                 return -1;
 556             frame_size = size / (enc->channels);
 557             break;
 558         default:
 559             /* used for example by ADPCM codecs */
 560             if (enc->bit_rate == 0)
 561                 return -1;
 562             frame_size = (size * 8 * enc->sample_rate) / enc->bit_rate;
 563             break;
 564         }
 565     } else {
 566         frame_size = enc->frame_size;
 567     }
 568     return frame_size;
 569 }
 570
 571
 572 /* return the frame duration in seconds, return 0 if not available */
 573 static void compute_frame_duration(int *pnum, int *pden,
 574                                    AVFormatContext *s, AVStream *st,
 575                                    AVCodecParserContext *pc, AVPacket *pkt)
 576 {
 577     int frame_size;
 578
 579     *pnum = 0;
 580     *pden = 0;
 581     switch(st->codec.codec_type) {
 582     case CODEC_TYPE_VIDEO:
 583         *pnum = st->codec.frame_rate_base;
 584         *pden = st->codec.frame_rate;
 585         if (pc && pc->repeat_pict) {
 586             *pden *= 2;
 587             *pnum = (*pnum) * (2 + pc->repeat_pict);
 588         }
 589         break;
 590     case CODEC_TYPE_AUDIO:
 591         frame_size = get_audio_frame_size(&st->codec, pkt->size);
 592         if (frame_size < 0)
 593             break;
 594         *pnum = frame_size;
 595         *pden = st->codec.sample_rate;
 596         break;
 597     default:
 598         break;
 599     }
 600 }
 601
 602 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
 603                                AVCodecParserContext *pc, AVPacket *pkt)
 604 {
 605     int num, den, presentation_delayed;
 606
 607     if (pkt->duration == 0) {
 608         compute_frame_duration(&num, &den, s, st, pc, pkt);
 609         if (den && num) {
 610             pkt->duration = (num * (int64_t)AV_TIME_BASE) / den;
 611         }
 612     }
 613
 614     /* do we have a video B frame ? */
 615     presentation_delayed = 0;
 616     if (st->codec.codec_type == CODEC_TYPE_VIDEO) {
 617         /* XXX: need has_b_frame, but cannot get it if the codec is
 618            not initialized */
 619         if ((st->codec.codec_id == CODEC_ID_MPEG1VIDEO ||
 620              st->codec.codec_id == CODEC_ID_MPEG2VIDEO ||
 621              st->codec.codec_id == CODEC_ID_MPEG4 ||
 622              st->codec.codec_id == CODEC_ID_H264) &&
 623             pc && pc->pict_type != FF_B_TYPE)
 624             presentation_delayed = 1;
 625     }
 626
 627     /* interpolate PTS and DTS if they are not present */
 628     if (presentation_delayed) {
 629         /* DTS = decompression time stamp */
 630         /* PTS = presentation time stamp */
 631         if (pkt->dts == AV_NOPTS_VALUE) {
 632             pkt->dts = st->cur_dts;
 633         } else {
 634             st->cur_dts = pkt->dts;
 635         }
 636         /* this is tricky: the dts must be incremented by the duration
 637            of the frame we are displaying, i.e. the last I or P frame */
 638         if (st->last_IP_duration == 0)
 639             st->cur_dts += pkt->duration;
 640         else
 641             st->cur_dts += st->last_IP_duration;
 642         st->last_IP_duration  = pkt->duration;
 643         /* cannot compute PTS if not present (we can compute it only
 644            by knowing the futur */
 645     } else {
 646         /* presentation is not delayed : PTS and DTS are the same */
 647         if (pkt->pts == AV_NOPTS_VALUE) {
 648             if (pkt->dts == AV_NOPTS_VALUE) {
 649                 pkt->pts = st->cur_dts;
 650                 pkt->dts = st->cur_dts;
 651             }
 652             else {
 653                 st->cur_dts = pkt->dts;
 654                 pkt->pts = pkt->dts;
 655             }
 656         } else {
 657             st->cur_dts = pkt->pts;
 658             pkt->dts = pkt->pts;
 659         }
 660         st->cur_dts += pkt->duration;
 661     }
 662
 663     /* update flags */
 664     if (pc) {
 665         pkt->flags = 0;
 666         /* key frame computation */
 667         switch(st->codec.codec_type) {
 668         case CODEC_TYPE_VIDEO:
 669             if (pc->pict_type == FF_I_TYPE)
 670                 pkt->flags |= PKT_FLAG_KEY;
 671             break;
 672         case CODEC_TYPE_AUDIO:
 673             pkt->flags |= PKT_FLAG_KEY;
 674             break;
 675         default:
 676             break;
 677         }
 678     }
 679
 680 }
 681
 682 static void av_destruct_packet_nofree(AVPacket *pkt)
 683 {
 684     pkt->data = NULL; pkt->size = 0;
 685 }
 686
 687 static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
 688 {
 689     AVStream *st;
 690     int len, ret, i;
 691
 692     for(;;) {
 693         /* select current input stream component */
 694         st = s->cur_st;
 695         if (st) {
 696             if (!st->parser) {
 697                 /* no parsing needed: we just output the packet as is */
 698                 /* raw data support */
 699                 *pkt = s->cur_pkt;
 700                 compute_pkt_fields(s, st, NULL, pkt);
 701                 s->cur_st = NULL;
 702                 return 0;
 703             } else if (s->cur_len > 0) {
 704                 len = av_parser_parse(st->parser, &st->codec, &pkt->data, &pkt->size,
 705                                       s->cur_ptr, s->cur_len,
 706                                       s->cur_pkt.pts, s->cur_pkt.dts);
 707                 s->cur_pkt.pts = AV_NOPTS_VALUE;
 708                 s->cur_pkt.dts = AV_NOPTS_VALUE;
 709                 /* increment read pointer */
 710                 s->cur_ptr += len;
 711                 s->cur_len -= len;
 712
 713                 /* return packet if any */
 714                 if (pkt->size) {
 715                 got_packet:
 716                     pkt->duration = 0;
 717                     pkt->stream_index = st->index;
 718                     pkt->pts = st->parser->pts;
 719                     pkt->dts = st->parser->dts;
 720                     pkt->destruct = av_destruct_packet_nofree;
 721                     compute_pkt_fields(s, st, st->parser, pkt);
 722                     return 0;
 723                 }
 724             } else {
 725                 /* free packet */
 726                 av_free_packet(&s->cur_pkt);
 727                 s->cur_st = NULL;
 728             }
 729         } else {
 730             /* read next packet */
 731             ret = av_read_packet(s, &s->cur_pkt);
 732             if (ret < 0) {
 733                 if (ret == -EAGAIN)
 734                     return ret;
 735                 /* return the last frames, if any */
 736                 for(i = 0; i < s->nb_streams; i++) {
 737                     st = s->streams[i];
 738                     if (st->parser) {
 739                         av_parser_parse(st->parser, &st->codec,
 740                                         &pkt->data, &pkt->size,
 741                                         NULL, 0,
 742                                         AV_NOPTS_VALUE, AV_NOPTS_VALUE);
 743                         if (pkt->size)
 744                             goto got_packet;
 745                     }
 746                 }
 747                 /* no more packets: really terminates parsing */
 748                 return ret;
 749             }
 750
 751             /* convert the packet time stamp units and handle wrapping */
 752             s->cur_pkt.pts = convert_timestamp_units(s,
 753                                                &s->last_pkt_pts, &s->last_pkt_pts_frac,
 754                                                &s->last_pkt_stream_pts,
 755                                                s->cur_pkt.pts);
 756             s->cur_pkt.dts = convert_timestamp_units(s,
 757                                                &s->last_pkt_dts,  &s->last_pkt_dts_frac,
 758                                                &s->last_pkt_stream_dts,
 759                                                s->cur_pkt.dts);
 760 #if 0
 761             if (s->cur_pkt.stream_index == 0) {
 762                 if (s->cur_pkt.pts != AV_NOPTS_VALUE)
 763                     printf("PACKET pts=%0.3f\n",
 764                            (double)s->cur_pkt.pts / AV_TIME_BASE);
 765                 if (s->cur_pkt.dts != AV_NOPTS_VALUE)
 766                     printf("PACKET dts=%0.3f\n",
 767                            (double)s->cur_pkt.dts / AV_TIME_BASE);
 768             }
 769 #endif
 770
 771             /* duration field */
 772             if (s->cur_pkt.duration != 0) {
 773                 s->cur_pkt.duration = ((int64_t)s->cur_pkt.duration * AV_TIME_BASE * s->pts_num) /
 774                     s->pts_den;
 775             }
 776
 777             st = s->streams[s->cur_pkt.stream_index];
 778             s->cur_st = st;
 779             s->cur_ptr = s->cur_pkt.data;
 780             s->cur_len = s->cur_pkt.size;
 781             if (st->need_parsing && !st->parser) {
 782                 st->parser = av_parser_init(st->codec.codec_id);
 783                 if (!st->parser) {
 784                     /* no parser available : just output the raw packets */
 785                     st->need_parsing = 0;
 786                 }
 787             }
 788         }
 789     }
 790 }
 791
 792 /**
 793  * Return the next frame of a stream. The returned packet is valid
 794  * until the next av_read_frame() or until av_close_input_file() and
 795  * must be freed with av_free_packet. For video, the packet contains
 796  * exactly one frame. For audio, it contains an integer number of
 797  * frames if each frame has a known fixed size (e.g. PCM or ADPCM
 798  * data). If the audio frames have a variable size (e.g. MPEG audio),
 799  * then it contains one frame.
 800  *
 801  * pkt->pts, pkt->dts and pkt->duration are always set to correct
 802  * values in AV_TIME_BASE unit (and guessed if the format cannot
 803  * provided them). pkt->pts can be AV_NOPTS_VALUE if the video format
 804  * has B frames, so it is better to rely on pkt->dts if you do not
 805  * decompress the payload.
 806  *
 807  * Return 0 if OK, < 0 if error or end of file.
 808  */
 809 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
 810 {
 811     AVPacketList *pktl;
 812
 813     pktl = s->packet_buffer;
 814     if (pktl) {
 815         /* read packet from packet buffer, if there is data */
 816         *pkt = pktl->pkt;
 817         s->packet_buffer = pktl->next;
 818         av_free(pktl);
 819         return 0;
 820     } else {
 821         return av_read_frame_internal(s, pkt);
 822     }
 823 }
 824
 825 /* XXX: suppress the packet queue */
 826 static void flush_packet_queue(AVFormatContext *s)
 827 {
 828     AVPacketList *pktl;
 829
 830     for(;;) {
 831         pktl = s->packet_buffer;
 832         if (!pktl)
 833             break;
 834         s->packet_buffer = pktl->next;
 835         av_free_packet(&pktl->pkt);
 836         av_free(pktl);
 837     }
 838 }
 839
 840 /*******************************************************/
 841 /* seek support */
 842
 843 int av_find_default_stream_index(AVFormatContext *s)
 844 {
 845     int i;
 846     AVStream *st;
 847
 848     if (s->nb_streams <= 0)
 849         return -1;
 850     for(i = 0; i < s->nb_streams; i++) {
 851         st = s->streams[i];
 852         if (st->codec.codec_type == CODEC_TYPE_VIDEO) {
 853             return i;
 854         }
 855     }
 856     return 0;
 857 }
 858
 859 /* flush the frame reader */
 860 static void av_read_frame_flush(AVFormatContext *s)
 861 {
 862     AVStream *st;
 863     int i;
 864
 865     flush_packet_queue(s);
 866
 867     /* free previous packet */
 868     if (s->cur_st) {
 869         if (s->cur_st->parser)
 870             av_free_packet(&s->cur_pkt);
 871         s->cur_st = NULL;
 872     }
 873     /* fail safe */
 874     s->cur_ptr = NULL;
 875     s->cur_len = 0;
 876
 877     /* for each stream, reset read state */
 878     for(i = 0; i < s->nb_streams; i++) {
 879         st = s->streams[i];
 880
 881         if (st->parser) {
 882             av_parser_close(st->parser);
 883             st->parser = NULL;
 884         }
 885         st->cur_dts = 0; /* we set the current DTS to an unspecified origin */
 886     }
 887 }
 888
 889 /* add a index entry into a sorted list updateing if it is already there */
 890 int av_add_index_entry(AVStream *st,
 891                             int64_t pos, int64_t timestamp, int distance, int flags)
 892 {
 893     AVIndexEntry *entries, *ie;
 894     int index;
 895
 896     entries = av_fast_realloc(st->index_entries,
 897                               &st->index_entries_allocated_size,
 898                               (st->nb_index_entries + 1) *
 899                               sizeof(AVIndexEntry));
 900     st->index_entries= entries;
 901
 902     if(st->nb_index_entries){
 903         index= av_index_search_timestamp(st, timestamp);
 904         ie= &entries[index];
 905
 906         if(ie->timestamp != timestamp){
 907             if(ie->timestamp < timestamp){
 908                 index++; //index points to next instead of previous entry, maybe nonexistant
 909                 ie= &st->index_entries[index];
 910             }else
 911                 assert(index==0);
 912
 913             if(index != st->nb_index_entries){
 914                 assert(index < st->nb_index_entries);
 915                 memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
 916             }
 917             st->nb_index_entries++;
 918         }
 919     }else{
 920         index= st->nb_index_entries++;
 921         ie= &entries[index];
 922     }
 923
 924     ie->pos = pos;
 925     ie->timestamp = timestamp;
 926     ie->min_distance= distance;
 927     ie->flags = flags;
 928
 929     return index;
 930 }
 931
 932 /* build an index for raw streams using a parser */
 933 static void av_build_index_raw(AVFormatContext *s)
 934 {
 935     AVPacket pkt1, *pkt = &pkt1;
 936     int ret;
 937     AVStream *st;
 938
 939     st = s->streams[0];
 940     av_read_frame_flush(s);
 941     url_fseek(&s->pb, s->data_offset, SEEK_SET);
 942
 943     for(;;) {
 944         ret = av_read_frame(s, pkt);
 945         if (ret < 0)
 946             break;
 947         if (pkt->stream_index == 0 && st->parser &&
 948             (pkt->flags & PKT_FLAG_KEY)) {
 949             av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
 950                             0, AVINDEX_KEYFRAME);
 951         }
 952         av_free_packet(pkt);
 953     }
 954 }
 955
 956 /* return TRUE if we deal with a raw stream (raw codec data and
 957    parsing needed) */
 958 static int is_raw_stream(AVFormatContext *s)
 959 {
 960     AVStream *st;
 961
 962     if (s->nb_streams != 1)
 963         return 0;
 964     st = s->streams[0];
 965     if (!st->need_parsing)
 966         return 0;
 967     return 1;
 968 }
 969
 970 /* return the largest index entry whose timestamp is <=
 971    wanted_timestamp */
 972 int av_index_search_timestamp(AVStream *st, int wanted_timestamp)
 973 {
 974     AVIndexEntry *entries= st->index_entries;
 975     int nb_entries= st->nb_index_entries;
 976     int a, b, m;
 977     int64_t timestamp;
 978
 979     if (nb_entries <= 0)
 980         return -1;
 981
 982     a = 0;
 983     b = nb_entries - 1;
 984
 985     while (a < b) {
 986         m = (a + b + 1) >> 1;
 987         timestamp = entries[m].timestamp;
 988         if (timestamp > wanted_timestamp) {
 989             b = m - 1;
 990         } else {
 991             a = m;
 992         }
 993     }
 994     return a;
 995 }
 996
 997 static int av_seek_frame_generic(AVFormatContext *s,
 998                                  int stream_index, int64_t timestamp)
 999 {
1000     int index;
1001     AVStream *st;
1002     AVIndexEntry *ie;
1003
1004     if (!s->index_built) {
1005         if (is_raw_stream(s)) {
1006             av_build_index_raw(s);
1007         } else {
1008             return -1;
1009         }
1010         s->index_built = 1;
1011     }
1012
1013     if (stream_index < 0)
1014         stream_index = 0;
1015     st = s->streams[stream_index];
1016     index = av_index_search_timestamp(st, timestamp);
1017     if (index < 0)
1018         return -1;
1019
1020     /* now we have found the index, we can seek */
1021     ie = &st->index_entries[index];
1022     av_read_frame_flush(s);
1023     url_fseek(&s->pb, ie->pos, SEEK_SET);
1024     st->cur_dts = ie->timestamp;
1025     return 0;
1026 }
1027
1028 /**
1029  * Seek to the key frame just before the frame at timestamp
1030  * 'timestamp' in 'stream_index'. If stream_index is (-1), a default
1031  * stream is selected
1032  */
1033 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp)
1034 {
1035     int ret;
1036
1037     av_read_frame_flush(s);
1038
1039     /* first, we try the format specific seek */
1040     if (s->iformat->read_seek)
1041         ret = s->iformat->read_seek(s, stream_index, timestamp);
1042     else
1043         ret = -1;
1044     if (ret >= 0) {
1045         return 0;
1046     }
1047
1048     return av_seek_frame_generic(s, stream_index, timestamp);
1049 }
1050
1051 /*******************************************************/
1052
1053 /* return TRUE if the stream has accurate timings for at least one component */
1054 static int av_has_timings(AVFormatContext *ic)
1055 {
1056     int i;
1057     AVStream *st;
1058
1059     for(i = 0;i < ic->nb_streams; i++) {
1060         st = ic->streams[i];
1061         if (st->start_time != AV_NOPTS_VALUE &&
1062             st->duration != AV_NOPTS_VALUE)
1063             return 1;
1064     }
1065     return 0;
1066 }
1067
1068 /* estimate the stream timings from the one of each components. Also
1069    compute the global bitrate if possible */
1070 static void av_update_stream_timings(AVFormatContext *ic)
1071 {
1072     int64_t start_time, end_time, end_time1;
1073     int i;
1074     AVStream *st;
1075
1076     start_time = MAXINT64;
1077     end_time = MININT64;
1078     for(i = 0;i < ic->nb_streams; i++) {
1079         st = ic->streams[i];
1080         if (st->start_time != AV_NOPTS_VALUE) {
1081             if (st->start_time < start_time)
1082                 start_time = st->start_time;
1083             if (st->duration != AV_NOPTS_VALUE) {
1084                 end_time1 = st->start_time + st->duration;
1085                 if (end_time1 > end_time)
1086                     end_time = end_time1;
1087             }
1088         }
1089     }
1090     if (start_time != MAXINT64) {
1091         ic->start_time = start_time;
1092         if (end_time != MAXINT64) {
1093             ic->duration = end_time - start_time;
1094             if (ic->file_size > 0) {
1095                 /* compute the bit rate */
1096                 ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1097                     (double)ic->duration;
1098             }
1099         }
1100     }
1101
1102 }
1103
1104 static void fill_all_stream_timings(AVFormatContext *ic)
1105 {
1106     int i;
1107     AVStream *st;
1108
1109     av_update_stream_timings(ic);
1110     for(i = 0;i < ic->nb_streams; i++) {
1111         st = ic->streams[i];
1112         if (st->start_time == AV_NOPTS_VALUE) {
1113             st->start_time = ic->start_time;
1114             st->duration = ic->duration;
1115         }
1116     }
1117 }
1118
1119 static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1120 {
1121     int64_t filesize, duration;
1122     int bit_rate, i;
1123     AVStream *st;
1124
1125     /* if bit_rate is already set, we believe it */
1126     if (ic->bit_rate == 0) {
1127         bit_rate = 0;
1128         for(i=0;i<ic->nb_streams;i++) {
1129             st = ic->streams[i];
1130             bit_rate += st->codec.bit_rate;
1131         }
1132         ic->bit_rate = bit_rate;
1133     }
1134
1135     /* if duration is already set, we believe it */
1136     if (ic->duration == AV_NOPTS_VALUE &&
1137         ic->bit_rate != 0 &&
1138         ic->file_size != 0)  {
1139         filesize = ic->file_size;
1140         if (filesize > 0) {
1141             duration = (int64_t)((8 * AV_TIME_BASE * (double)filesize) / (double)ic->bit_rate);
1142             for(i = 0; i < ic->nb_streams; i++) {
1143                 st = ic->streams[i];
1144                 if (st->start_time == AV_NOPTS_VALUE ||
1145                     st->duration == AV_NOPTS_VALUE) {
1146                     st->start_time = 0;
1147                     st->duration = duration;
1148                 }
1149             }
1150         }
1151     }
1152 }
1153
1154 #define DURATION_MAX_READ_SIZE 250000
1155
1156 /* only usable for MPEG-PS streams */
1157 static void av_estimate_timings_from_pts(AVFormatContext *ic)
1158 {
1159     AVPacket pkt1, *pkt = &pkt1;
1160     AVStream *st;
1161     int read_size, i, ret;
1162     int64_t start_time, end_time, end_time1;
1163     int64_t filesize, offset, duration;
1164
1165     /* free previous packet */
1166     if (ic->cur_st && ic->cur_st->parser)
1167         av_free_packet(&ic->cur_pkt);
1168     ic->cur_st = NULL;
1169
1170     /* flush packet queue */
1171     flush_packet_queue(ic);
1172
1173
1174     /* we read the first packets to get the first PTS (not fully
1175        accurate, but it is enough now) */
1176     url_fseek(&ic->pb, 0, SEEK_SET);
1177     read_size = 0;
1178     for(;;) {
1179         if (read_size >= DURATION_MAX_READ_SIZE)
1180             break;
1181         /* if all info is available, we can stop */
1182         for(i = 0;i < ic->nb_streams; i++) {
1183             st = ic->streams[i];
1184             if (st->start_time == AV_NOPTS_VALUE)
1185                 break;
1186         }
1187         if (i == ic->nb_streams)
1188             break;
1189
1190         ret = av_read_packet(ic, pkt);
1191         if (ret != 0)
1192             break;
1193         read_size += pkt->size;
1194         st = ic->streams[pkt->stream_index];
1195         if (pkt->pts != AV_NOPTS_VALUE) {
1196             if (st->start_time == AV_NOPTS_VALUE)
1197                 st->start_time = (int64_t)((double)pkt->pts * ic->pts_num * (double)AV_TIME_BASE / ic->pts_den);
1198         }
1199         av_free_packet(pkt);
1200     }
1201
1202     /* we compute the minimum start_time and use it as default */
1203     start_time = MAXINT64;
1204     for(i = 0; i < ic->nb_streams; i++) {
1205         st = ic->streams[i];
1206         if (st->start_time != AV_NOPTS_VALUE &&
1207             st->start_time < start_time)
1208             start_time = st->start_time;
1209     }
1210     if (start_time != MAXINT64)
1211         ic->start_time = start_time;
1212
1213     /* estimate the end time (duration) */
1214     /* XXX: may need to support wrapping */
1215     filesize = ic->file_size;
1216     offset = filesize - DURATION_MAX_READ_SIZE;
1217     if (offset < 0)
1218         offset = 0;
1219
1220     url_fseek(&ic->pb, offset, SEEK_SET);
1221     read_size = 0;
1222     for(;;) {
1223         if (read_size >= DURATION_MAX_READ_SIZE)
1224             break;
1225         /* if all info is available, we can stop */
1226         for(i = 0;i < ic->nb_streams; i++) {
1227             st = ic->streams[i];
1228             if (st->duration == AV_NOPTS_VALUE)
1229                 break;
1230         }
1231         if (i == ic->nb_streams)
1232             break;
1233
1234         ret = av_read_packet(ic, pkt);
1235         if (ret != 0)
1236             break;
1237         read_size += pkt->size;
1238         st = ic->streams[pkt->stream_index];
1239         if (pkt->pts != AV_NOPTS_VALUE) {
1240             end_time = (int64_t)((double)pkt->pts * ic->pts_num * (double)AV_TIME_BASE / ic->pts_den);
1241             duration = end_time - st->start_time;
1242             if (duration > 0) {
1243                 if (st->duration == AV_NOPTS_VALUE ||
1244                     st->duration < duration)
1245                     st->duration = duration;
1246             }
1247         }
1248         av_free_packet(pkt);
1249     }
1250
1251     /* estimate total duration */
1252     end_time = MININT64;
1253     for(i = 0;i < ic->nb_streams; i++) {
1254         st = ic->streams[i];
1255         if (st->duration != AV_NOPTS_VALUE) {
1256             end_time1 = st->start_time + st->duration;
1257             if (end_time1 > end_time)
1258                 end_time = end_time1;
1259         }
1260     }
1261
1262     /* update start_time (new stream may have been created, so we do
1263        it at the end */
1264     if (ic->start_time != AV_NOPTS_VALUE) {
1265         for(i = 0; i < ic->nb_streams; i++) {
1266             st = ic->streams[i];
1267             if (st->start_time == AV_NOPTS_VALUE)
1268                 st->start_time = ic->start_time;
1269         }
1270     }
1271
1272     if (end_time != MININT64) {
1273         /* put dummy values for duration if needed */
1274         for(i = 0;i < ic->nb_streams; i++) {
1275             st = ic->streams[i];
1276             if (st->duration == AV_NOPTS_VALUE &&
1277                 st->start_time != AV_NOPTS_VALUE)
1278                 st->duration = end_time - st->start_time;
1279         }
1280         ic->duration = end_time - ic->start_time;
1281     }
1282
1283     url_fseek(&ic->pb, 0, SEEK_SET);
1284 }
1285
1286 static void av_estimate_timings(AVFormatContext *ic)
1287 {
1288     URLContext *h;
1289     int64_t file_size;
1290
1291     /* get the file size, if possible */
1292     if (ic->iformat->flags & AVFMT_NOFILE) {
1293         file_size = 0;
1294     } else {
1295         h = url_fileno(&ic->pb);
1296         file_size = url_filesize(h);
1297         if (file_size < 0)
1298             file_size = 0;
1299     }
1300     ic->file_size = file_size;
1301
1302     if (ic->iformat == &mpegps_demux) {
1303         /* get accurate estimate from the PTSes */
1304         av_estimate_timings_from_pts(ic);
1305     } else if (av_has_timings(ic)) {
1306         /* at least one components has timings - we use them for all
1307            the components */
1308         fill_all_stream_timings(ic);
1309     } else {
1310         /* less precise: use bit rate info */
1311         av_estimate_timings_from_bit_rate(ic);
1312     }
1313     av_update_stream_timings(ic);
1314
1315 #if 0
1316     {
1317         int i;
1318         AVStream *st;
1319         for(i = 0;i < ic->nb_streams; i++) {
1320             st = ic->streams[i];
1321         printf("%d: start_time: %0.3f duration: %0.3f\n",
1322                i, (double)st->start_time / AV_TIME_BASE,
1323                (double)st->duration / AV_TIME_BASE);
1324         }
1325         printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1326                (double)ic->start_time / AV_TIME_BASE,
1327                (double)ic->duration / AV_TIME_BASE,
1328                ic->bit_rate / 1000);
1329     }
1330 #endif
1331 }
1332
1333 static int has_codec_parameters(AVCodecContext *enc)
1334 {
1335     int val;
1336     switch(enc->codec_type) {
1337     case CODEC_TYPE_AUDIO:
1338         val = enc->sample_rate;
1339         break;
1340     case CODEC_TYPE_VIDEO:
1341         val = enc->width;
1342         break;
1343     default:
1344         val = 1;
1345         break;
1346     }
1347     return (val != 0);
1348 }
1349
1350 static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1351 {
1352     int16_t *samples;
1353     AVCodec *codec;
1354     int got_picture, ret;
1355     AVFrame picture;
1356
1357     codec = avcodec_find_decoder(st->codec.codec_id);
1358     if (!codec)
1359         return -1;
1360     ret = avcodec_open(&st->codec, codec);
1361     if (ret < 0)
1362         return ret;
1363     switch(st->codec.codec_type) {
1364     case CODEC_TYPE_VIDEO:
1365         ret = avcodec_decode_video(&st->codec, &picture,
1366                                    &got_picture, (uint8_t *)data, size);
1367         break;
1368     case CODEC_TYPE_AUDIO:
1369         samples = av_malloc(AVCODEC_MAX_AUDIO_FRAME_SIZE);
1370         if (!samples)
1371             goto fail;
1372         ret = avcodec_decode_audio(&st->codec, samples,
1373                                    &got_picture, (uint8_t *)data, size);
1374         av_free(samples);
1375         break;
1376     default:
1377         break;
1378     }
1379  fail:
1380     avcodec_close(&st->codec);
1381     return ret;
1382 }
1383
1384 /* absolute maximum size we read until we abort */
1385 #define MAX_READ_SIZE        5000000
1386
1387 /* maximum duration until we stop analysing the stream */
1388 #define MAX_STREAM_DURATION  ((int)(AV_TIME_BASE * 1.0))
1389
1390 /**
1391  * Read the beginning of a media file to get stream information. This
1392  * is useful for file formats with no headers such as MPEG. This
1393  * function also compute the real frame rate in case of mpeg2 repeat
1394  * frame mode.
1395  *
1396  * @param ic media file handle
1397  * @return >=0 if OK. AVERROR_xxx if error.
1398  */
1399 int av_find_stream_info(AVFormatContext *ic)
1400 {
1401     int i, count, ret, read_size;
1402     AVStream *st;
1403     AVPacket pkt1, *pkt;
1404     AVPacketList *pktl=NULL, **ppktl;
1405
1406     count = 0;
1407     read_size = 0;
1408     ppktl = &ic->packet_buffer;
1409     for(;;) {
1410         /* check if one codec still needs to be handled */
1411         for(i=0;i<ic->nb_streams;i++) {
1412             st = ic->streams[i];
1413             if (!has_codec_parameters(&st->codec))
1414                 break;
1415         }
1416         if (i == ic->nb_streams) {
1417             /* NOTE: if the format has no header, then we need to read
1418                some packets to get most of the streams, so we cannot
1419                stop here */
1420             if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
1421                 /* if we found the info for all the codecs, we can stop */
1422                 ret = count;
1423                 break;
1424             }
1425         } else {
1426             /* we did not get all the codec info, but we read too much data */
1427             if (read_size >= MAX_READ_SIZE) {
1428                 ret = count;
1429                 break;
1430             }
1431         }
1432
1433         /* NOTE: a new stream can be added there if no header in file
1434            (AVFMTCTX_NOHEADER) */
1435         ret = av_read_frame_internal(ic, &pkt1);
1436         if (ret < 0) {
1437             /* EOF or error */
1438             ret = -1; /* we could not have all the codec parameters before EOF */
1439             if ((ic->ctx_flags & AVFMTCTX_NOHEADER) &&
1440                 i == ic->nb_streams)
1441                 ret = 0;
1442             break;
1443         }
1444
1445         pktl = av_mallocz(sizeof(AVPacketList));
1446         if (!pktl) {
1447             ret = AVERROR_NOMEM;
1448             break;
1449         }
1450
1451         /* add the packet in the buffered packet list */
1452         *ppktl = pktl;
1453         ppktl = &pktl->next;
1454
1455         pkt = &pktl->pkt;
1456         *pkt = pkt1;
1457
1458         /* duplicate the packet */
1459         if (av_dup_packet(pkt) < 0) {
1460                 ret = AVERROR_NOMEM;
1461                 break;
1462         }
1463
1464         read_size += pkt->size;
1465
1466         st = ic->streams[pkt->stream_index];
1467         st->codec_info_duration += pkt->duration;
1468         if (pkt->duration != 0)
1469             st->codec_info_nb_frames++;
1470
1471         /* if still no information, we try to open the codec and to
1472            decompress the frame. We try to avoid that in most cases as
1473            it takes longer and uses more memory. For MPEG4, we need to
1474            decompress for Quicktime. */
1475         if (!has_codec_parameters(&st->codec) &&
1476             (st->codec.codec_id == CODEC_ID_FLV1 ||
1477              st->codec.codec_id == CODEC_ID_H264 ||
1478              st->codec.codec_id == CODEC_ID_H263 ||
1479              (st->codec.codec_id == CODEC_ID_MPEG4 && !st->need_parsing)))
1480             try_decode_frame(st, pkt->data, pkt->size);
1481
1482         if (st->codec_info_duration >= MAX_STREAM_DURATION) {
1483             break;
1484         }
1485         count++;
1486     }
1487
1488     /* set real frame rate info */
1489     for(i=0;i<ic->nb_streams;i++) {
1490         st = ic->streams[i];
1491         if (st->codec.codec_type == CODEC_TYPE_VIDEO) {
1492             /* compute the real frame rate for telecine */
1493             if ((st->codec.codec_id == CODEC_ID_MPEG1VIDEO ||
1494                  st->codec.codec_id == CODEC_ID_MPEG2VIDEO) &&
1495                 st->codec.sub_id == 2) {
1496                 if (st->codec_info_nb_frames >= 20) {
1497                     float coded_frame_rate, est_frame_rate;
1498                     est_frame_rate = ((double)st->codec_info_nb_frames * AV_TIME_BASE) /
1499                         (double)st->codec_info_duration ;
1500                     coded_frame_rate = (double)st->codec.frame_rate /
1501                         (double)st->codec.frame_rate_base;
1502 #if 0
1503                     printf("telecine: coded_frame_rate=%0.3f est_frame_rate=%0.3f\n",
1504                            coded_frame_rate, est_frame_rate);
1505 #endif
1506                     /* if we detect that it could be a telecine, we
1507                        signal it. It would be better to do it at a
1508                        higher level as it can change in a film */
1509                     if (coded_frame_rate >= 24.97 &&
1510                         (est_frame_rate >= 23.5 && est_frame_rate < 24.5)) {
1511                         st->r_frame_rate = 24024;
1512                         st->r_frame_rate_base = 1001;
1513                     }
1514                 }
1515             }
1516             /* if no real frame rate, use the codec one */
1517             if (!st->r_frame_rate){
1518                 st->r_frame_rate      = st->codec.frame_rate;
1519                 st->r_frame_rate_base = st->codec.frame_rate_base;
1520             }
1521         }
1522     }
1523
1524     av_estimate_timings(ic);
1525     return ret;
1526 }
1527
1528 /*******************************************************/
1529
1530 /**
1531  * start playing a network based stream (e.g. RTSP stream) at the
1532  * current position
1533  */
1534 int av_read_play(AVFormatContext *s)
1535 {
1536     if (!s->iformat->read_play)
1537         return AVERROR_NOTSUPP;
1538     return s->iformat->read_play(s);
1539 }
1540
1541 /**
1542  * pause a network based stream (e.g. RTSP stream). Use av_read_play()
1543  * to resume it.
1544  */
1545 int av_read_pause(AVFormatContext *s)
1546 {
1547     if (!s->iformat->read_pause)
1548         return AVERROR_NOTSUPP;
1549     return s->iformat->read_pause(s);
1550 }
1551
1552 /**
1553  * Close a media file (but not its codecs)
1554  *
1555  * @param s media file handle
1556  */
1557 void av_close_input_file(AVFormatContext *s)
1558 {
1559     int i, must_open_file;
1560     AVStream *st;
1561
1562     /* free previous packet */
1563     if (s->cur_st && s->cur_st->parser)
1564         av_free_packet(&s->cur_pkt);
1565
1566     if (s->iformat->read_close)
1567         s->iformat->read_close(s);
1568     for(i=0;i<s->nb_streams;i++) {
1569         /* free all data in a stream component */
1570         st = s->streams[i];
1571         if (st->parser) {
1572             av_parser_close(st->parser);
1573         }
1574         av_free(st->index_entries);
1575         av_free(st);
1576     }
1577     flush_packet_queue(s);
1578     must_open_file = 1;
1579     if (s->iformat->flags & AVFMT_NOFILE) {
1580         must_open_file = 0;
1581     }
1582     if (must_open_file) {
1583         url_fclose(&s->pb);
1584     }
1585     av_freep(&s->priv_data);
1586     av_free(s);
1587 }
1588
1589 /**
1590  * Add a new stream to a media file. Can only be called in the
1591  * read_header function. If the flag AVFMTCTX_NOHEADER is in the
1592  * format context, then new streams can be added in read_packet too.
1593  *
1594  *
1595  * @param s media file handle
1596  * @param id file format dependent stream id
1597  */
1598 AVStream *av_new_stream(AVFormatContext *s, int id)
1599 {
1600     AVStream *st;
1601
1602     if (s->nb_streams >= MAX_STREAMS)
1603         return NULL;
1604
1605     st = av_mallocz(sizeof(AVStream));
1606     if (!st)
1607         return NULL;
1608     avcodec_get_context_defaults(&st->codec);
1609     if (s->iformat) {
1610         /* no default bitrate if decoding */
1611         st->codec.bit_rate = 0;
1612     }
1613     st->index = s->nb_streams;
1614     st->id = id;
1615     st->start_time = AV_NOPTS_VALUE;
1616     st->duration = AV_NOPTS_VALUE;
1617     s->streams[s->nb_streams++] = st;
1618     return st;
1619 }
1620
1621 /************************************************************/
1622 /* output media file */
1623
1624 int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
1625 {
1626     int ret;
1627
1628     if (s->oformat->priv_data_size > 0) {
1629         s->priv_data = av_mallocz(s->oformat->priv_data_size);
1630         if (!s->priv_data)
1631             return AVERROR_NOMEM;
1632     } else
1633         s->priv_data = NULL;
1634
1635     if (s->oformat->set_parameters) {
1636         ret = s->oformat->set_parameters(s, ap);
1637         if (ret < 0)
1638             return ret;
1639     }
1640     return 0;
1641 }
1642
1643 /**
1644  * allocate the stream private data and write the stream header to an
1645  * output media file
1646  *
1647  * @param s media file handle
1648  * @return 0 if OK. AVERROR_xxx if error.
1649  */
1650 int av_write_header(AVFormatContext *s)
1651 {
1652     int ret, i;
1653     AVStream *st;
1654
1655     /* default pts settings is MPEG like */
1656     av_set_pts_info(s, 33, 1, 90000);
1657     ret = s->oformat->write_header(s);
1658     if (ret < 0)
1659         return ret;
1660
1661     /* init PTS generation */
1662     for(i=0;i<s->nb_streams;i++) {
1663         st = s->streams[i];
1664
1665         switch (st->codec.codec_type) {
1666         case CODEC_TYPE_AUDIO:
1667             av_frac_init(&st->pts, 0, 0,
1668                          (int64_t)s->pts_num * st->codec.sample_rate);
1669             break;
1670         case CODEC_TYPE_VIDEO:
1671             av_frac_init(&st->pts, 0, 0,
1672                          (int64_t)s->pts_num * st->codec.frame_rate);
1673             break;
1674         default:
1675             break;
1676         }
1677     }
1678     return 0;
1679 }
1680
1681 /**
1682  * Write a packet to an output media file. The packet shall contain
1683  * one audio or video frame.
1684  *
1685  * @param s media file handle
1686  * @param stream_index stream index
1687  * @param buf buffer containing the frame data
1688  * @param size size of buffer
1689  * @return < 0 if error, = 0 if OK, 1 if end of stream wanted.
1690  */
1691 int av_write_frame(AVFormatContext *s, int stream_index, const uint8_t *buf,
1692                    int size)
1693 {
1694     AVStream *st;
1695     int64_t pts_mask;
1696     int ret, frame_size;
1697
1698     st = s->streams[stream_index];
1699     pts_mask = (1LL << s->pts_wrap_bits) - 1;
1700     ret = s->oformat->write_packet(s, stream_index, buf, size,
1701                                    st->pts.val & pts_mask);
1702     if (ret < 0)
1703         return ret;
1704
1705     /* update pts */
1706     switch (st->codec.codec_type) {
1707     case CODEC_TYPE_AUDIO:
1708         frame_size = get_audio_frame_size(&st->codec, size);
1709         if (frame_size >= 0) {
1710             av_frac_add(&st->pts,
1711                         (int64_t)s->pts_den * frame_size);
1712         }
1713         break;
1714     case CODEC_TYPE_VIDEO:
1715         av_frac_add(&st->pts,
1716                     (int64_t)s->pts_den * st->codec.frame_rate_base);
1717         break;
1718     default:
1719         break;
1720     }
1721     return ret;
1722 }
1723
1724 /**
1725  * write the stream trailer to an output media file and and free the
1726  * file private data.
1727  *
1728  * @param s media file handle
1729  * @return 0 if OK. AVERROR_xxx if error.  */
1730 int av_write_trailer(AVFormatContext *s)
1731 {
1732     int ret;
1733     ret = s->oformat->write_trailer(s);
1734     av_freep(&s->priv_data);
1735     return ret;
1736 }
1737
1738 /* "user interface" functions */
1739
1740 void dump_format(AVFormatContext *ic,
1741                  int index,
1742                  const char *url,
1743                  int is_output)
1744 {
1745     int i, flags;
1746     char buf[256];
1747
1748     av_log(NULL, AV_LOG_DEBUG, "%s #%d, %s, %s '%s':\n",
1749             is_output ? "Output" : "Input",
1750             index,
1751             is_output ? ic->oformat->name : ic->iformat->name,
1752             is_output ? "to" : "from", url);
1753     if (!is_output) {
1754         av_log(NULL, AV_LOG_DEBUG, "  Duration: ");
1755         if (ic->duration != AV_NOPTS_VALUE) {
1756             int hours, mins, secs, us;
1757             secs = ic->duration / AV_TIME_BASE;
1758             us = ic->duration % AV_TIME_BASE;
1759             mins = secs / 60;
1760             secs %= 60;
1761             hours = mins / 60;
1762             mins %= 60;
1763             av_log(NULL, AV_LOG_DEBUG, "%02d:%02d:%02d.%01d", hours, mins, secs,
1764                    (10 * us) / AV_TIME_BASE);
1765         } else {
1766             av_log(NULL, AV_LOG_DEBUG, "N/A");
1767         }
1768         av_log(NULL, AV_LOG_DEBUG, ", bitrate: ");
1769         if (ic->bit_rate) {
1770             av_log(NULL, AV_LOG_DEBUG,"%d kb/s", ic->bit_rate / 1000);
1771         } else {
1772             av_log(NULL, AV_LOG_DEBUG, "N/A");
1773         }
1774         av_log(NULL, AV_LOG_DEBUG, "\n");
1775     }
1776     for(i=0;i<ic->nb_streams;i++) {
1777         AVStream *st = ic->streams[i];
1778         avcodec_string(buf, sizeof(buf), &st->codec, is_output);
1779         av_log(NULL, AV_LOG_DEBUG, "  Stream #%d.%d", index, i);
1780         /* the pid is an important information, so we display it */
1781         /* XXX: add a generic system */
1782         if (is_output)
1783             flags = ic->oformat->flags;
1784         else
1785             flags = ic->iformat->flags;
1786         if (flags & AVFMT_SHOW_IDS) {
1787             av_log(NULL, AV_LOG_DEBUG, "[0x%x]", st->id);
1788         }
1789         av_log(NULL, AV_LOG_DEBUG, ": %s\n", buf);
1790     }
1791 }
1792
1793 typedef struct {
1794     const char *abv;
1795     int width, height;
1796     int frame_rate, frame_rate_base;
1797 } AbvEntry;
1798
1799 static AbvEntry frame_abvs[] = {
1800     { "ntsc",      720, 480, 30000, 1001 },
1801     { "pal",       720, 576,    25,    1 },
1802     { "qntsc",     352, 240, 30000, 1001 }, /* VCD compliant ntsc */
1803     { "qpal",      352, 288,    25,    1 }, /* VCD compliant pal */
1804     { "sntsc",     640, 480, 30000, 1001 }, /* square pixel ntsc */
1805     { "spal",      768, 576,    25,    1 }, /* square pixel pal */
1806     { "film",      352, 240,    24,    1 },
1807     { "ntsc-film", 352, 240, 24000, 1001 },
1808     { "sqcif",     128,  96,     0,    0 },
1809     { "qcif",      176, 144,     0,    0 },
1810     { "cif",       352, 288,     0,    0 },
1811     { "4cif",      704, 576,     0,    0 },
1812 };
1813
1814 int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
1815 {
1816     int i;
1817     int n = sizeof(frame_abvs) / sizeof(AbvEntry);
1818     const char *p;
1819     int frame_width = 0, frame_height = 0;
1820
1821     for(i=0;i<n;i++) {
1822         if (!strcmp(frame_abvs[i].abv, str)) {
1823             frame_width = frame_abvs[i].width;
1824             frame_height = frame_abvs[i].height;
1825             break;
1826         }
1827     }
1828     if (i == n) {
1829         p = str;
1830         frame_width = strtol(p, (char **)&p, 10);
1831         if (*p)
1832             p++;
1833         frame_height = strtol(p, (char **)&p, 10);
1834     }
1835     if (frame_width <= 0 || frame_height <= 0)
1836         return -1;
1837     *width_ptr = frame_width;
1838     *height_ptr = frame_height;
1839     return 0;
1840 }
1841
1842 int parse_frame_rate(int *frame_rate, int *frame_rate_base, const char *arg)
1843 {
1844     int i;
1845     char* cp;
1846
1847     /* First, we check our abbreviation table */
1848     for (i = 0; i < sizeof(frame_abvs)/sizeof(*frame_abvs); ++i)
1849          if (!strcmp(frame_abvs[i].abv, arg)) {
1850              *frame_rate = frame_abvs[i].frame_rate;
1851              *frame_rate_base = frame_abvs[i].frame_rate_base;
1852              return 0;
1853          }
1854
1855     /* Then, we try to parse it as fraction */
1856     cp = strchr(arg, '/');
1857     if (cp) {
1858         char* cpp;
1859         *frame_rate = strtol(arg, &cpp, 10);
1860         if (cpp != arg || cpp == cp)
1861             *frame_rate_base = strtol(cp+1, &cpp, 10);
1862         else
1863            *frame_rate = 0;
1864     }
1865     else {
1866         /* Finally we give up and parse it as double */
1867         *frame_rate_base = DEFAULT_FRAME_RATE_BASE;
1868         *frame_rate = (int)(strtod(arg, 0) * (*frame_rate_base) + 0.5);
1869     }
1870     if (!*frame_rate || !*frame_rate_base)
1871         return -1;
1872     else
1873         return 0;
1874 }
1875
1876 /* Syntax:
1877  * - If not a duration:
1878  *  [{YYYY-MM-DD|YYYYMMDD}]{T| }{HH[:MM[:SS[.m...]]][Z]|HH[MM[SS[.m...]]][Z]}
1879  * Time is localtime unless Z is suffixed to the end. In this case GMT
1880  * Return the date in micro seconds since 1970
1881  * - If duration:
1882  *  HH[:MM[:SS[.m...]]]
1883  *  S+[.m...]
1884  */
1885 int64_t parse_date(const char *datestr, int duration)
1886 {
1887     const char *p;
1888     int64_t t;
1889     struct tm dt;
1890     int i;
1891     static const char *date_fmt[] = {
1892         "%Y-%m-%d",
1893         "%Y%m%d",
1894     };
1895     static const char *time_fmt[] = {
1896         "%H:%M:%S",
1897         "%H%M%S",
1898     };
1899     const char *q;
1900     int is_utc, len;
1901     char lastch;
1902     time_t now = time(0);
1903
1904     len = strlen(datestr);
1905     if (len > 0)
1906         lastch = datestr[len - 1];
1907     else
1908         lastch = '\0';
1909     is_utc = (lastch == 'z' || lastch == 'Z');
1910
1911     memset(&dt, 0, sizeof(dt));
1912
1913     p = datestr;
1914     q = NULL;
1915     if (!duration) {
1916         for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
1917             q = small_strptime(p, date_fmt[i], &dt);
1918             if (q) {
1919                 break;
1920             }
1921         }
1922
1923         if (!q) {
1924             if (is_utc) {
1925                 dt = *gmtime(&now);
1926             } else {
1927                 dt = *localtime(&now);
1928             }
1929             dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
1930         } else {
1931             p = q;
1932         }
1933
1934         if (*p == 'T' || *p == 't' || *p == ' ')
1935             p++;
1936
1937         for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
1938             q = small_strptime(p, time_fmt[i], &dt);
1939             if (q) {
1940                 break;
1941             }
1942         }
1943     } else {
1944         q = small_strptime(p, time_fmt[0], &dt);
1945         if (!q) {
1946             dt.tm_sec = strtol(p, (char **)&q, 10);
1947             dt.tm_min = 0;
1948             dt.tm_hour = 0;
1949         }
1950     }
1951
1952     /* Now we have all the fields that we can get */
1953     if (!q) {
1954         if (duration)
1955             return 0;
1956         else
1957             return now * int64_t_C(1000000);
1958     }
1959
1960     if (duration) {
1961         t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
1962     } else {
1963         dt.tm_isdst = -1;       /* unknown */
1964         if (is_utc) {
1965             t = mktimegm(&dt);
1966         } else {
1967             t = mktime(&dt);
1968         }
1969     }
1970
1971     t *= 1000000;
1972
1973     if (*q == '.') {
1974         int val, n;
1975         q++;
1976         for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
1977             if (!isdigit(*q))
1978                 break;
1979             val += n * (*q - '0');
1980         }
1981         t += val;
1982     }
1983     return t;
1984 }
1985
1986 /* syntax: '?tag1=val1&tag2=val2...'. Little URL decoding is done. Return
1987    1 if found */
1988 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
1989 {
1990     const char *p;
1991     char tag[128], *q;
1992
1993     p = info;
1994     if (*p == '?')
1995         p++;
1996     for(;;) {
1997         q = tag;
1998         while (*p != '\0' && *p != '=' && *p != '&') {
1999             if ((q - tag) < sizeof(tag) - 1)
2000                 *q++ = *p;
2001             p++;
2002         }
2003         *q = '\0';
2004         q = arg;
2005         if (*p == '=') {
2006             p++;
2007             while (*p != '&' && *p != '\0') {
2008                 if ((q - arg) < arg_size - 1) {
2009                     if (*p == '+')
2010                         *q++ = ' ';
2011                     else
2012                         *q++ = *p;
2013                 }
2014                 p++;
2015             }
2016             *q = '\0';
2017         }
2018         if (!strcmp(tag, tag1))
2019             return 1;
2020         if (*p != '&')
2021             break;
2022         p++;
2023     }
2024     return 0;
2025 }
2026
2027 /* Return in 'buf' the path with '%d' replaced by number. Also handles
2028    the '%0nd' format where 'n' is the total number of digits and
2029    '%%'. Return 0 if OK, and -1 if format error */
2030 int get_frame_filename(char *buf, int buf_size,
2031                        const char *path, int number)
2032 {
2033     const char *p;
2034     char *q, buf1[20], c;
2035     int nd, len, percentd_found;
2036
2037     q = buf;
2038     p = path;
2039     percentd_found = 0;
2040     for(;;) {
2041         c = *p++;
2042         if (c == '\0')
2043             break;
2044         if (c == '%') {
2045             do {
2046                 nd = 0;
2047                 while (isdigit(*p)) {
2048                     nd = nd * 10 + *p++ - '0';
2049                 }
2050                 c = *p++;
2051             } while (isdigit(c));
2052
2053             switch(c) {
2054             case '%':
2055                 goto addchar;
2056             case 'd':
2057                 if (percentd_found)
2058                     goto fail;
2059                 percentd_found = 1;
2060                 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
2061                 len = strlen(buf1);
2062                 if ((q - buf + len) > buf_size - 1)
2063                     goto fail;
2064                 memcpy(q, buf1, len);
2065                 q += len;
2066                 break;
2067             default:
2068                 goto fail;
2069             }
2070         } else {
2071         addchar:
2072             if ((q - buf) < buf_size - 1)
2073                 *q++ = c;
2074         }
2075     }
2076     if (!percentd_found)
2077         goto fail;
2078     *q = '\0';
2079     return 0;
2080  fail:
2081     *q = '\0';
2082     return -1;
2083 }
2084
2085 /**
2086  * Print  nice hexa dump of a buffer
2087  * @param f stream for output
2088  * @param buf buffer
2089  * @param size buffer size
2090  */
2091 void av_hex_dump(FILE *f, uint8_t *buf, int size)
2092 {
2093     int len, i, j, c;
2094
2095     for(i=0;i<size;i+=16) {
2096         len = size - i;
2097         if (len > 16)
2098             len = 16;
2099         fprintf(f, "%08x ", i);
2100         for(j=0;j<16;j++) {
2101             if (j < len)
2102                 fprintf(f, " %02x", buf[i+j]);
2103             else
2104                 fprintf(f, "   ");
2105         }
2106         fprintf(f, " ");
2107         for(j=0;j<len;j++) {
2108             c = buf[i+j];
2109             if (c < ' ' || c > '~')
2110                 c = '.';
2111             fprintf(f, "%c", c);
2112         }
2113         fprintf(f, "\n");
2114     }
2115 }
2116
2117 /**
2118  * Print on 'f' a nice dump of a packet
2119  * @param f stream for output
2120  * @param pkt packet to dump
2121  * @param dump_payload true if the payload must be displayed too
2122  */
2123 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
2124 {
2125     fprintf(f, "stream #%d:\n", pkt->stream_index);
2126     fprintf(f, "  keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
2127     fprintf(f, "  duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
2128     /* DTS is _always_ valid after av_read_frame() */
2129     fprintf(f, "  dts=");
2130     if (pkt->dts == AV_NOPTS_VALUE)
2131         fprintf(f, "N/A");
2132     else
2133         fprintf(f, "%0.3f", (double)pkt->dts / AV_TIME_BASE);
2134     /* PTS may be not known if B frames are present */
2135     fprintf(f, "  pts=");
2136     if (pkt->pts == AV_NOPTS_VALUE)
2137         fprintf(f, "N/A");
2138     else
2139         fprintf(f, "%0.3f", (double)pkt->pts / AV_TIME_BASE);
2140     fprintf(f, "\n");
2141     fprintf(f, "  size=%d\n", pkt->size);
2142     if (dump_payload)
2143         av_hex_dump(f, pkt->data, pkt->size);
2144 }
2145
2146 void url_split(char *proto, int proto_size,
2147                char *hostname, int hostname_size,
2148                int *port_ptr,
2149                char *path, int path_size,
2150                const char *url)
2151 {
2152     const char *p;
2153     char *q;
2154     int port;
2155
2156     port = -1;
2157
2158     p = url;
2159     q = proto;
2160     while (*p != ':' && *p != '\0') {
2161         if ((q - proto) < proto_size - 1)
2162             *q++ = *p;
2163         p++;
2164     }
2165     if (proto_size > 0)
2166         *q = '\0';
2167     if (*p == '\0') {
2168         if (proto_size > 0)
2169             proto[0] = '\0';
2170         if (hostname_size > 0)
2171             hostname[0] = '\0';
2172         p = url;
2173     } else {
2174         p++;
2175         if (*p == '/')
2176             p++;
2177         if (*p == '/')
2178             p++;
2179         q = hostname;
2180         while (*p != ':' && *p != '/' && *p != '?' && *p != '\0') {
2181             if ((q - hostname) < hostname_size - 1)
2182                 *q++ = *p;
2183             p++;
2184         }
2185         if (hostname_size > 0)
2186             *q = '\0';
2187         if (*p == ':') {
2188             p++;
2189             port = strtoul(p, (char **)&p, 10);
2190         }
2191     }
2192     if (port_ptr)
2193         *port_ptr = port;
2194     pstrcpy(path, path_size, p);
2195 }
2196
2197 /**
2198  * Set the pts for a given stream
2199  * @param s stream
2200  * @param pts_wrap_bits number of bits effectively used by the pts
2201  *        (used for wrap control, 33 is the value for MPEG)
2202  * @param pts_num numerator to convert to seconds (MPEG: 1)
2203  * @param pts_den denominator to convert to seconds (MPEG: 90000)
2204  */
2205 void av_set_pts_info(AVFormatContext *s, int pts_wrap_bits,
2206                      int pts_num, int pts_den)
2207 {
2208     s->pts_wrap_bits = pts_wrap_bits;
2209     s->pts_num = pts_num;
2210     s->pts_den = pts_den;
2211 }
2212
2213 /* fraction handling */
2214
2215 /**
2216  * f = val + (num / den) + 0.5. 'num' is normalized so that it is such
2217  * as 0 <= num < den.
2218  *
2219  * @param f fractional number
2220  * @param val integer value
2221  * @param num must be >= 0
2222  * @param den must be >= 1
2223  */
2224 void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
2225 {
2226     num += (den >> 1);
2227     if (num >= den) {
2228         val += num / den;
2229         num = num % den;
2230     }
2231     f->val = val;
2232     f->num = num;
2233     f->den = den;
2234 }
2235
2236 /* set f to (val + 0.5) */
2237 void av_frac_set(AVFrac *f, int64_t val)
2238 {
2239     f->val = val;
2240     f->num = f->den >> 1;
2241 }
2242
2243 /**
2244  * Fractionnal addition to f: f = f + (incr / f->den)
2245  *
2246  * @param f fractional number
2247  * @param incr increment, can be positive or negative
2248  */
2249 void av_frac_add(AVFrac *f, int64_t incr)
2250 {
2251     int64_t num, den;
2252
2253     num = f->num + incr;
2254     den = f->den;
2255     if (num < 0) {
2256         f->val += num / den;
2257         num = num % den;
2258         if (num < 0) {
2259             num += den;
2260             f->val--;
2261         }
2262     } else if (num >= den) {
2263         f->val += num / den;
2264         num = num % den;
2265     }
2266     f->num = num;
2267 }
2268
2269 /**
2270  * register a new image format
2271  * @param img_fmt Image format descriptor
2272  */
2273 void av_register_image_format(AVImageFormat *img_fmt)
2274 {
2275     AVImageFormat **p;
2276
2277     p = &first_image_format;
2278     while (*p != NULL) p = &(*p)->next;
2279     *p = img_fmt;
2280     img_fmt->next = NULL;
2281 }
2282
2283 /* guess image format */
2284 AVImageFormat *av_probe_image_format(AVProbeData *pd)
2285 {
2286     AVImageFormat *fmt1, *fmt;
2287     int score, score_max;
2288
2289     fmt = NULL;
2290     score_max = 0;
2291     for(fmt1 = first_image_format; fmt1 != NULL; fmt1 = fmt1->next) {
2292         if (fmt1->img_probe) {
2293             score = fmt1->img_probe(pd);
2294             if (score > score_max) {
2295                 score_max = score;
2296                 fmt = fmt1;
2297             }
2298         }
2299     }
2300     return fmt;
2301 }
2302
2303 AVImageFormat *guess_image_format(const char *filename)
2304 {
2305     AVImageFormat *fmt1;
2306
2307     for(fmt1 = first_image_format; fmt1 != NULL; fmt1 = fmt1->next) {
2308         if (fmt1->extensions && match_ext(filename, fmt1->extensions))
2309             return fmt1;
2310     }
2311     return NULL;
2312 }
2313
2314 /**
2315  * Read an image from a stream.
2316  * @param gb byte stream containing the image
2317  * @param fmt image format, NULL if probing is required
2318  */
2319 int av_read_image(ByteIOContext *pb, const char *filename,
2320                   AVImageFormat *fmt,
2321                   int (*alloc_cb)(void *, AVImageInfo *info), void *opaque)
2322 {
2323     char buf[PROBE_BUF_SIZE];
2324     AVProbeData probe_data, *pd = &probe_data;
2325     offset_t pos;
2326     int ret;
2327
2328     if (!fmt) {
2329         pd->filename = filename;
2330         pd->buf = buf;
2331         pos = url_ftell(pb);
2332         pd->buf_size = get_buffer(pb, buf, PROBE_BUF_SIZE);
2333         url_fseek(pb, pos, SEEK_SET);
2334         fmt = av_probe_image_format(pd);
2335     }
2336     if (!fmt)
2337         return AVERROR_NOFMT;
2338     ret = fmt->img_read(pb, alloc_cb, opaque);
2339     return ret;
2340 }
2341
2342 /**
2343  * Write an image to a stream.
2344  * @param pb byte stream for the image output
2345  * @param fmt image format
2346  * @param img image data and informations
2347  */
2348 int av_write_image(ByteIOContext *pb, AVImageFormat *fmt, AVImageInfo *img)
2349 {
2350     return fmt->img_write(pb, img);
2351 }
2352