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 #include <ctype.h>
  21 #ifdef CONFIG_WIN32
  22 #define strcasecmp _stricmp
  23 #include <sys/types.h>
  24 #include <sys/timeb.h>
  25 #elif defined(CONFIG_OS2)
  26 #include <string.h>
  27 #define strcasecmp stricmp
  28 #include <sys/time.h>
  29 #else
  30 #include <unistd.h>
  31 #include <fcntl.h>
  32 #include <sys/time.h>
  33 #endif
  34 #include <time.h>
  35
  36 #ifndef HAVE_STRPTIME
  37 #include "strptime.h"
  38 #endif
  39
  40 AVInputFormat *first_iformat;
  41 AVOutputFormat *first_oformat;
  42 AVImageFormat *first_image_format;
  43
  44 void av_register_input_format(AVInputFormat *format)
  45 {
  46     AVInputFormat **p;
  47     p = &first_iformat;
  48     while (*p != NULL) p = &(*p)->next;
  49     *p = format;
  50     format->next = NULL;
  51 }
  52
  53 void av_register_output_format(AVOutputFormat *format)
  54 {
  55     AVOutputFormat **p;
  56     p = &first_oformat;
  57     while (*p != NULL) p = &(*p)->next;
  58     *p = format;
  59     format->next = NULL;
  60 }
  61
  62 int match_ext(const char *filename, const char *extensions)
  63 {
  64     const char *ext, *p;
  65     char ext1[32], *q;
  66
  67     ext = strrchr(filename, '.');
  68     if (ext) {
  69         ext++;
  70         p = extensions;
  71         for(;;) {
  72             q = ext1;
  73             while (*p != '\0' && *p != ',')
  74                 *q++ = *p++;
  75             *q = '\0';
  76             if (!strcasecmp(ext1, ext))
  77                 return 1;
  78             if (*p == '\0')
  79                 break;
  80             p++;
  81         }
  82     }
  83     return 0;
  84 }
  85
  86 AVOutputFormat *guess_format(const char *short_name, const char *filename,
  87                              const char *mime_type)
  88 {
  89     AVOutputFormat *fmt, *fmt_found;
  90     int score_max, score;
  91
  92     /* specific test for image sequences */
  93     if (!short_name && filename &&
  94         filename_number_test(filename) >= 0 &&
  95         guess_image_format(filename)) {
  96         return guess_format("image", NULL, NULL);
  97     }
  98
  99     /* find the proper file type */
 100     fmt_found = NULL;
 101     score_max = 0;
 102     fmt = first_oformat;
 103     while (fmt != NULL) {
 104         score = 0;
 105         if (fmt->name && short_name && !strcmp(fmt->name, short_name))
 106             score += 100;
 107         if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
 108             score += 10;
 109         if (filename && fmt->extensions &&
 110             match_ext(filename, fmt->extensions)) {
 111             score += 5;
 112         }
 113         if (score > score_max) {
 114             score_max = score;
 115             fmt_found = fmt;
 116         }
 117         fmt = fmt->next;
 118     }
 119     return fmt_found;
 120 }
 121
 122 AVOutputFormat *guess_stream_format(const char *short_name, const char *filename,
 123                              const char *mime_type)
 124 {
 125     AVOutputFormat *fmt = guess_format(short_name, filename, mime_type);
 126
 127     if (fmt) {
 128         AVOutputFormat *stream_fmt;
 129         char stream_format_name[64];
 130
 131         snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
 132         stream_fmt = guess_format(stream_format_name, NULL, NULL);
 133
 134         if (stream_fmt)
 135             fmt = stream_fmt;
 136     }
 137
 138     return fmt;
 139 }
 140
 141 AVInputFormat *av_find_input_format(const char *short_name)
 142 {
 143     AVInputFormat *fmt;
 144     for(fmt = first_iformat; fmt != NULL; fmt = fmt->next) {
 145         if (!strcmp(fmt->name, short_name))
 146             return fmt;
 147     }
 148     return NULL;
 149 }
 150
 151 /* memory handling */
 152
 153 /**
 154  * Default packet destructor
 155  */
 156 static void av_destruct_packet(AVPacket *pkt)
 157 {
 158     av_free(pkt->data);
 159     pkt->data = NULL; pkt->size = 0;
 160 }
 161
 162 /**
 163  * Allocate the payload of a packet and intialized its fields to default values.
 164  *
 165  * @param pkt packet
 166  * @param size wanted payload size
 167  * @return 0 if OK. AVERROR_xxx otherwise.
 168  */
 169 int av_new_packet(AVPacket *pkt, int size)
 170 {
 171     void *data = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
 172     if (!data)
 173         return AVERROR_NOMEM;
 174     memset(data + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
 175
 176     av_init_packet(pkt);
 177     pkt->data = data;
 178     pkt->size = size;
 179     pkt->destruct = av_destruct_packet;
 180     return 0;
 181 }
 182
 183 /* fifo handling */
 184
 185 int fifo_init(FifoBuffer *f, int size)
 186 {
 187     f->buffer = av_malloc(size);
 188     if (!f->buffer)
 189         return -1;
 190     f->end = f->buffer + size;
 191     f->wptr = f->rptr = f->buffer;
 192     return 0;
 193 }
 194
 195 void fifo_free(FifoBuffer *f)
 196 {
 197     av_free(f->buffer);
 198 }
 199
 200 int fifo_size(FifoBuffer *f, uint8_t *rptr)
 201 {
 202     int size;
 203
 204     if (f->wptr >= rptr) {
 205         size = f->wptr - rptr;
 206     } else {
 207         size = (f->end - rptr) + (f->wptr - f->buffer);
 208     }
 209     return size;
 210 }
 211
 212 /* get data from the fifo (return -1 if not enough data) */
 213 int fifo_read(FifoBuffer *f, uint8_t *buf, int buf_size, uint8_t **rptr_ptr)
 214 {
 215     uint8_t *rptr = *rptr_ptr;
 216     int size, len;
 217
 218     if (f->wptr >= rptr) {
 219         size = f->wptr - rptr;
 220     } else {
 221         size = (f->end - rptr) + (f->wptr - f->buffer);
 222     }
 223
 224     if (size < buf_size)
 225         return -1;
 226     while (buf_size > 0) {
 227         len = f->end - rptr;
 228         if (len > buf_size)
 229             len = buf_size;
 230         memcpy(buf, rptr, len);
 231         buf += len;
 232         rptr += len;
 233         if (rptr >= f->end)
 234             rptr = f->buffer;
 235         buf_size -= len;
 236     }
 237     *rptr_ptr = rptr;
 238     return 0;
 239 }
 240
 241 void fifo_write(FifoBuffer *f, uint8_t *buf, int size, uint8_t **wptr_ptr)
 242 {
 243     int len;
 244     uint8_t *wptr;
 245     wptr = *wptr_ptr;
 246     while (size > 0) {
 247         len = f->end - wptr;
 248         if (len > size)
 249             len = size;
 250         memcpy(wptr, buf, len);
 251         wptr += len;
 252         if (wptr >= f->end)
 253             wptr = f->buffer;
 254         buf += len;
 255         size -= len;
 256     }
 257     *wptr_ptr = wptr;
 258 }
 259
 260 int filename_number_test(const char *filename)
 261 {
 262     char buf[1024];
 263     return get_frame_filename(buf, sizeof(buf), filename, 1);
 264 }
 265
 266 /* guess file format */
 267 AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened)
 268 {
 269     AVInputFormat *fmt1, *fmt;
 270     int score, score_max;
 271
 272     fmt = NULL;
 273     score_max = 0;
 274     for(fmt1 = first_iformat; fmt1 != NULL; fmt1 = fmt1->next) {
 275         if (!is_opened && !(fmt1->flags & AVFMT_NOFILE))
 276             continue;
 277         score = 0;
 278         if (fmt1->read_probe) {
 279             score = fmt1->read_probe(pd);
 280         } else if (fmt1->extensions) {
 281             if (match_ext(pd->filename, fmt1->extensions)) {
 282                 score = 50;
 283             }
 284         }
 285         if (score > score_max) {
 286             score_max = score;
 287             fmt = fmt1;
 288         }
 289     }
 290     return fmt;
 291 }
 292
 293 /************************************************************/
 294 /* input media file */
 295
 296 #define PROBE_BUF_SIZE 2048
 297
 298 /**
 299  * Open a media file as input. The codec are not opened. Only the file
 300  * header (if present) is read.
 301  *
 302  * @param ic_ptr the opened media file handle is put here
 303  * @param filename filename to open.
 304  * @param fmt if non NULL, force the file format to use
 305  * @param buf_size optional buffer size (zero if default is OK)
 306  * @param ap additionnal parameters needed when opening the file (NULL if default)
 307  * @return 0 if OK. AVERROR_xxx otherwise.
 308  */
 309 int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
 310                        AVInputFormat *fmt,
 311                        int buf_size,
 312                        AVFormatParameters *ap)
 313 {
 314     AVFormatContext *ic = NULL;
 315     int err;
 316     char buf[PROBE_BUF_SIZE];
 317     AVProbeData probe_data, *pd = &probe_data;
 318
 319     ic = av_mallocz(sizeof(AVFormatContext));
 320     if (!ic) {
 321         err = AVERROR_NOMEM;
 322         goto fail;
 323     }
 324     pstrcpy(ic->filename, sizeof(ic->filename), filename);
 325     pd->filename = ic->filename;
 326     pd->buf = buf;
 327     pd->buf_size = 0;
 328
 329     if (!fmt) {
 330         /* guess format if no file can be opened  */
 331         fmt = av_probe_input_format(pd, 0);
 332     }
 333
 334     if (!fmt || !(fmt->flags & AVFMT_NOFILE)) {
 335         /* if no file needed do not try to open one */
 336         if (url_fopen(&ic->pb, filename, URL_RDONLY) < 0) {
 337             err = AVERROR_IO;
 338             goto fail;
 339         }
 340         if (buf_size > 0) {
 341             url_setbufsize(&ic->pb, buf_size);
 342         }
 343         if (!fmt) {
 344             /* read probe data */
 345             pd->buf_size = get_buffer(&ic->pb, buf, PROBE_BUF_SIZE);
 346             url_fseek(&ic->pb, 0, SEEK_SET);
 347         }
 348     }
 349
 350     /* guess file format */
 351     if (!fmt) {
 352         fmt = av_probe_input_format(pd, 1);
 353     }
 354
 355     /* if still no format found, error */
 356     if (!fmt) {
 357         err = AVERROR_NOFMT;
 358         goto fail1;
 359     }
 360
 361     /* XXX: suppress this hack for redirectors */
 362 #ifdef CONFIG_NETWORK
 363     if (fmt == &redir_demux) {
 364         err = redir_open(ic_ptr, &ic->pb);
 365         url_fclose(&ic->pb);
 366         av_free(ic);
 367         return err;
 368     }
 369 #endif
 370
 371     ic->iformat = fmt;
 372
 373     /* check filename in case of an image number is expected */
 374     if (ic->iformat->flags & AVFMT_NEEDNUMBER) {
 375         if (filename_number_test(ic->filename) < 0) {
 376             err = AVERROR_NUMEXPECTED;
 377             goto fail1;
 378         }
 379     }
 380
 381     /* allocate private data */
 382     if (fmt->priv_data_size > 0) {
 383         ic->priv_data = av_mallocz(fmt->priv_data_size);
 384         if (!ic->priv_data) {
 385             err = AVERROR_NOMEM;
 386         goto fail1;
 387         }
 388     } else
 389         ic->priv_data = NULL;
 390
 391     /* default pts settings is MPEG like */
 392     av_set_pts_info(ic, 33, 1, 90000);
 393
 394     err = ic->iformat->read_header(ic, ap);
 395     if (err < 0)
 396         goto fail1;
 397     *ic_ptr = ic;
 398     return 0;
 399  fail1:
 400     if (!fmt || !(fmt->flags & AVFMT_NOFILE)) {
 401         url_fclose(&ic->pb);
 402     }
 403  fail:
 404     if (ic) {
 405         av_freep(&ic->priv_data);
 406     }
 407     av_free(ic);
 408     *ic_ptr = NULL;
 409     return err;
 410 }
 411
 412 /**
 413  * Read a packet from a media file
 414  * @param s media file handle
 415  * @param pkt is filled
 416  * @return 0 if OK. AVERROR_xxx if error.
 417  */
 418 int av_read_packet(AVFormatContext *s, AVPacket *pkt)
 419 {
 420     AVPacketList *pktl;
 421
 422     pktl = s->packet_buffer;
 423     if (pktl) {
 424         /* read packet from packet buffer, if there is data */
 425         *pkt = pktl->pkt;
 426         s->packet_buffer = pktl->next;
 427         av_free(pktl);
 428         return 0;
 429     } else {
 430         return s->iformat->read_packet(s, pkt);
 431     }
 432 }
 433
 434 /* state for codec information */
 435 #define CSTATE_NOTFOUND    0
 436 #define CSTATE_DECODING    1
 437 #define CSTATE_FOUND       2
 438
 439 static int has_codec_parameters(AVCodecContext *enc)
 440 {
 441     int val;
 442     switch(enc->codec_type) {
 443     case CODEC_TYPE_AUDIO:
 444         val = enc->sample_rate;
 445         break;
 446     case CODEC_TYPE_VIDEO:
 447         val = enc->width;
 448         break;
 449     default:
 450         val = 1;
 451         break;
 452     }
 453     return (val != 0);
 454 }
 455
 456 /**
 457  * Read the beginning of a media file to get stream information. This
 458  * is useful for file formats with no headers such as MPEG. This
 459  * function also compute the real frame rate in case of mpeg2 repeat
 460  * frame mode.
 461  *
 462  * @param ic media file handle
 463  * @return >=0 if OK. AVERROR_xxx if error.
 464  */
 465 int av_find_stream_info(AVFormatContext *ic)
 466 {
 467     int i, count, ret, got_picture, size, read_size;
 468     AVCodec *codec;
 469     AVStream *st;
 470     AVPacket *pkt;
 471     AVFrame picture;
 472     AVPacketList *pktl=NULL, **ppktl;
 473     short samples[AVCODEC_MAX_AUDIO_FRAME_SIZE / 2];
 474     uint8_t *ptr;
 475     int min_read_size, max_read_size;
 476
 477     /* typical mpeg ts rate is 40 Mbits. DVD rate is about 10
 478        Mbits. We read at most 0.2 second of file to find all streams */
 479
 480     /* XXX: base it on stream bitrate when possible */
 481     if (ic->iformat == &mpegts_demux) {
 482         /* maximum number of bytes we accept to read to find all the streams
 483            in a file */
 484         min_read_size = 6000000;
 485     } else {
 486         min_read_size = 250000;
 487     }
 488     /* max read size is 2 seconds of video max */
 489     max_read_size = min_read_size * 10;
 490
 491     /* set initial codec state */
 492     for(i=0;i<ic->nb_streams;i++) {
 493         st = ic->streams[i];
 494         if (has_codec_parameters(&st->codec))
 495             st->codec_info_state = CSTATE_FOUND;
 496         else
 497             st->codec_info_state = CSTATE_NOTFOUND;
 498         st->codec_info_nb_repeat_frames = 0;
 499         st->codec_info_nb_real_frames = 0;
 500     }
 501
 502     count = 0;
 503     read_size = 0;
 504     ppktl = &ic->packet_buffer;
 505     for(;;) {
 506         /* check if one codec still needs to be handled */
 507         for(i=0;i<ic->nb_streams;i++) {
 508             st = ic->streams[i];
 509             if (st->codec_info_state != CSTATE_FOUND)
 510                 break;
 511         }
 512         if (i == ic->nb_streams) {
 513             /* NOTE: if the format has no header, then we need to read
 514                some packets to get most of the streams, so we cannot
 515                stop here */
 516             if (!(ic->iformat->flags & AVFMT_NOHEADER) ||
 517                 read_size >= min_read_size) {
 518                 /* if we found the info for all the codecs, we can stop */
 519                 ret = count;
 520                 break;
 521             }
 522         } else {
 523             /* we did not get all the codec info, but we read too much data */
 524             if (read_size >= max_read_size) {
 525                 ret = count;
 526                 break;
 527             }
 528         }
 529
 530         pktl = av_mallocz(sizeof(AVPacketList));
 531         if (!pktl) {
 532             ret = AVERROR_NOMEM;
 533             break;
 534         }
 535
 536         /* add the packet in the buffered packet list */
 537         *ppktl = pktl;
 538         ppktl = &pktl->next;
 539
 540         /* NOTE: a new stream can be added there if no header in file
 541            (AVFMT_NOHEADER) */
 542         pkt = &pktl->pkt;
 543         if (ic->iformat->read_packet(ic, pkt) < 0) {
 544             /* EOF or error */
 545             ret = -1; /* we could not have all the codec parameters before EOF */
 546             if ((ic->iformat->flags & AVFMT_NOHEADER) &&
 547                 i == ic->nb_streams)
 548                 ret = 0;
 549             break;
 550         }
 551         read_size += pkt->size;
 552
 553         /* open new codecs */
 554         for(i=0;i<ic->nb_streams;i++) {
 555             st = ic->streams[i];
 556             if (st->codec_info_state == CSTATE_NOTFOUND) {
 557                 /* set to found in case of error */
 558                 st->codec_info_state = CSTATE_FOUND;
 559                 codec = avcodec_find_decoder(st->codec.codec_id);
 560                 if (codec) {
 561                     if(codec->capabilities & CODEC_CAP_TRUNCATED)
 562                         st->codec.flags |= CODEC_FLAG_TRUNCATED;
 563
 564                     ret = avcodec_open(&st->codec, codec);
 565                     if (ret >= 0)
 566                         st->codec_info_state = CSTATE_DECODING;
 567                 }
 568             }
 569         }
 570
 571         st = ic->streams[pkt->stream_index];
 572         if (st->codec_info_state == CSTATE_DECODING) {
 573             /* decode the data and update codec parameters */
 574             ptr = pkt->data;
 575             size = pkt->size;
 576             while (size > 0) {
 577                 switch(st->codec.codec_type) {
 578                 case CODEC_TYPE_VIDEO:
 579                     ret = avcodec_decode_video(&st->codec, &picture,
 580                                                &got_picture, ptr, size);
 581                     break;
 582                 case CODEC_TYPE_AUDIO:
 583                     ret = avcodec_decode_audio(&st->codec, samples,
 584                                                &got_picture, ptr, size);
 585                     break;
 586                 default:
 587                     ret = -1;
 588                     break;
 589                 }
 590                 if (ret < 0) {
 591                     /* if error, simply ignore because another packet
 592                        may be OK */
 593                     break;
 594                 }
 595                 if (got_picture) {
 596                     /* we got the parameters - now we can stop
 597                        examining this stream */
 598                     /* XXX: add a codec info so that we can decide if
 599                        the codec can repeat frames */
 600                     if (st->codec.codec_id == CODEC_ID_MPEG1VIDEO &&
 601                         ic->iformat != &mpegts_demux &&
 602                         st->codec.sub_id == 2) {
 603                         /* for mpeg2 video, we want to know the real
 604                            frame rate, so we decode 40 frames. In mpeg
 605                            TS case we do not do it because it would be
 606                            too long */
 607                         st->codec_info_nb_real_frames++;
 608                         st->codec_info_nb_repeat_frames += st->codec.coded_frame->repeat_pict;
 609 #if 0
 610                         /* XXX: testing */
 611                         if ((st->codec_info_nb_real_frames % 24) == 23) {
 612                             st->codec_info_nb_repeat_frames += 2;
 613                         }
 614 #endif
 615                         /* stop after 40 frames */
 616                         if (st->codec_info_nb_real_frames >= 40) {
 617                             av_reduce(
 618                                 &st->r_frame_rate,
 619                                 &st->r_frame_rate_base,
 620                                 (int64_t)st->codec.frame_rate * st->codec_info_nb_real_frames,
 621                                 (st->codec_info_nb_real_frames + (st->codec_info_nb_repeat_frames >> 1)) * st->codec.frame_rate_base,
 622                                 1<<30);
 623                             goto close_codec;
 624                         }
 625                     } else {
 626                     close_codec:
 627                         st->codec_info_state = CSTATE_FOUND;
 628                         avcodec_close(&st->codec);
 629                         break;
 630                     }
 631                 }
 632                 ptr += ret;
 633                 size -= ret;
 634             }
 635         }
 636         count++;
 637     }
 638
 639     /* close each codec if there are opened */
 640     for(i=0;i<ic->nb_streams;i++) {
 641         st = ic->streams[i];
 642         if (st->codec_info_state == CSTATE_DECODING)
 643             avcodec_close(&st->codec);
 644     }
 645
 646     /* set real frame rate info */
 647     for(i=0;i<ic->nb_streams;i++) {
 648         st = ic->streams[i];
 649         if (st->codec.codec_type == CODEC_TYPE_VIDEO) {
 650             if (!st->r_frame_rate){
 651                 st->r_frame_rate      = st->codec.frame_rate;
 652                 st->r_frame_rate_base = st->codec.frame_rate_base;
 653             }
 654         }
 655     }
 656
 657     return ret;
 658 }
 659
 660 /**
 661  * Close a media file (but not its codecs)
 662  *
 663  * @param s media file handle
 664  */
 665 void av_close_input_file(AVFormatContext *s)
 666 {
 667     int i;
 668
 669     if (s->iformat->read_close)
 670         s->iformat->read_close(s);
 671     for(i=0;i<s->nb_streams;i++) {
 672         av_free(s->streams[i]);
 673     }
 674     if (s->packet_buffer) {
 675         AVPacketList *p, *p1;
 676         p = s->packet_buffer;
 677         while (p != NULL) {
 678             p1 = p->next;
 679             av_free_packet(&p->pkt);
 680             av_free(p);
 681             p = p1;
 682         }
 683         s->packet_buffer = NULL;
 684     }
 685     if (!(s->iformat->flags & AVFMT_NOFILE)) {
 686         url_fclose(&s->pb);
 687     }
 688     av_freep(&s->priv_data);
 689     av_free(s);
 690 }
 691
 692 /**
 693  * Add a new stream to a media file. Can only be called in the
 694  * read_header function. If the flag AVFMT_NOHEADER is in the format
 695  * description, then new streams can be added in read_packet too.
 696  *
 697  *
 698  * @param s media file handle
 699  * @param id file format dependent stream id
 700  */
 701 AVStream *av_new_stream(AVFormatContext *s, int id)
 702 {
 703     AVStream *st;
 704
 705     if (s->nb_streams >= MAX_STREAMS)
 706         return NULL;
 707
 708     st = av_mallocz(sizeof(AVStream));
 709     if (!st)
 710         return NULL;
 711     avcodec_get_context_defaults(&st->codec);
 712
 713     st->index = s->nb_streams;
 714     st->id = id;
 715     s->streams[s->nb_streams++] = st;
 716     return st;
 717 }
 718
 719 /************************************************************/
 720 /* output media file */
 721
 722 int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
 723 {
 724     int ret;
 725
 726     if (s->oformat->priv_data_size > 0) {
 727         s->priv_data = av_mallocz(s->oformat->priv_data_size);
 728         if (!s->priv_data)
 729             return AVERROR_NOMEM;
 730     } else
 731         s->priv_data = NULL;
 732
 733     if (s->oformat->set_parameters) {
 734         ret = s->oformat->set_parameters(s, ap);
 735         if (ret < 0)
 736             return ret;
 737     }
 738     return 0;
 739 }
 740
 741 /**
 742  * allocate the stream private data and write the stream header to an
 743  * output media file
 744  *
 745  * @param s media file handle
 746  * @return 0 if OK. AVERROR_xxx if error.
 747  */
 748 int av_write_header(AVFormatContext *s)
 749 {
 750     int ret, i;
 751     AVStream *st;
 752
 753     /* default pts settings is MPEG like */
 754     av_set_pts_info(s, 33, 1, 90000);
 755     ret = s->oformat->write_header(s);
 756     if (ret < 0)
 757         return ret;
 758
 759     /* init PTS generation */
 760     for(i=0;i<s->nb_streams;i++) {
 761         st = s->streams[i];
 762
 763         switch (st->codec.codec_type) {
 764         case CODEC_TYPE_AUDIO:
 765             av_frac_init(&st->pts, 0, 0,
 766                          (int64_t)s->pts_num * st->codec.sample_rate);
 767             break;
 768         case CODEC_TYPE_VIDEO:
 769             av_frac_init(&st->pts, 0, 0,
 770                          (int64_t)s->pts_num * st->codec.frame_rate);
 771             break;
 772         default:
 773             break;
 774         }
 775     }
 776     return 0;
 777 }
 778
 779 /**
 780  * Write a packet to an output media file. The packet shall contain
 781  * one audio or video frame.
 782  *
 783  * @param s media file handle
 784  * @param stream_index stream index
 785  * @param buf buffer containing the frame data
 786  * @param size size of buffer
 787  * @return < 0 if error, = 0 if OK, 1 if end of stream wanted.
 788  */
 789 int av_write_frame(AVFormatContext *s, int stream_index, const uint8_t *buf,
 790                    int size)
 791 {
 792     AVStream *st;
 793     int64_t pts_mask;
 794     int ret, frame_size;
 795
 796     st = s->streams[stream_index];
 797     pts_mask = (1LL << s->pts_wrap_bits) - 1;
 798     ret = s->oformat->write_packet(s, stream_index, (uint8_t *)buf, size,
 799                                    st->pts.val & pts_mask);
 800     if (ret < 0)
 801         return ret;
 802
 803     /* update pts */
 804     switch (st->codec.codec_type) {
 805     case CODEC_TYPE_AUDIO:
 806         if (st->codec.frame_size <= 1) {
 807             frame_size = size / st->codec.channels;
 808             /* specific hack for pcm codecs because no frame size is provided */
 809             switch(st->codec.codec_id) {
 810             case CODEC_ID_PCM_S16LE:
 811             case CODEC_ID_PCM_S16BE:
 812             case CODEC_ID_PCM_U16LE:
 813             case CODEC_ID_PCM_U16BE:
 814                 frame_size >>= 1;
 815                 break;
 816             default:
 817                 break;
 818             }
 819         } else {
 820             frame_size = st->codec.frame_size;
 821         }
 822         av_frac_add(&st->pts,
 823                     (int64_t)s->pts_den * frame_size);
 824         break;
 825     case CODEC_TYPE_VIDEO:
 826         av_frac_add(&st->pts,
 827                     (int64_t)s->pts_den * st->codec.frame_rate_base);
 828         break;
 829     default:
 830         break;
 831     }
 832     return ret;
 833 }
 834
 835 /**
 836  * write the stream trailer to an output media file and and free the
 837  * file private data.
 838  *
 839  * @param s media file handle
 840  * @return 0 if OK. AVERROR_xxx if error.  */
 841 int av_write_trailer(AVFormatContext *s)
 842 {
 843     int ret;
 844     ret = s->oformat->write_trailer(s);
 845     av_freep(&s->priv_data);
 846     return ret;
 847 }
 848
 849 /* "user interface" functions */
 850
 851 void dump_format(AVFormatContext *ic,
 852                  int index,
 853                  const char *url,
 854                  int is_output)
 855 {
 856     int i, flags;
 857     char buf[256];
 858
 859     fprintf(stderr, "%s #%d, %s, %s '%s':\n",
 860             is_output ? "Output" : "Input",
 861             index,
 862             is_output ? ic->oformat->name : ic->iformat->name,
 863             is_output ? "to" : "from", url);
 864     for(i=0;i<ic->nb_streams;i++) {
 865         AVStream *st = ic->streams[i];
 866         avcodec_string(buf, sizeof(buf), &st->codec, is_output);
 867         fprintf(stderr, "  Stream #%d.%d", index, i);
 868         /* the pid is an important information, so we display it */
 869         /* XXX: add a generic system */
 870         if (is_output)
 871             flags = ic->oformat->flags;
 872         else
 873             flags = ic->iformat->flags;
 874         if (flags & AVFMT_SHOW_IDS) {
 875             fprintf(stderr, "[0x%x]", st->id);
 876         }
 877         fprintf(stderr, ": %s\n", buf);
 878     }
 879 }
 880
 881 typedef struct {
 882     const char *str;
 883     int width, height;
 884 } SizeEntry;
 885
 886 static SizeEntry sizes[] = {
 887     { "sqcif", 128, 96 },
 888     { "qcif", 176, 144 },
 889     { "cif", 352, 288 },
 890     { "4cif", 704, 576 },
 891 };
 892
 893 int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
 894 {
 895     int i;
 896     int n = sizeof(sizes) / sizeof(SizeEntry);
 897     const char *p;
 898     int frame_width = 0, frame_height = 0;
 899
 900     for(i=0;i<n;i++) {
 901         if (!strcmp(sizes[i].str, str)) {
 902             frame_width = sizes[i].width;
 903             frame_height = sizes[i].height;
 904             break;
 905         }
 906     }
 907     if (i == n) {
 908         p = str;
 909         frame_width = strtol(p, (char **)&p, 10);
 910         if (*p)
 911             p++;
 912         frame_height = strtol(p, (char **)&p, 10);
 913     }
 914     if (frame_width <= 0 || frame_height <= 0)
 915         return -1;
 916     *width_ptr = frame_width;
 917     *height_ptr = frame_height;
 918     return 0;
 919 }
 920
 921 int64_t av_gettime(void)
 922 {
 923 #ifdef CONFIG_WIN32
 924     struct _timeb tb;
 925     _ftime(&tb);
 926     return ((int64_t)tb.time * int64_t_C(1000) + (int64_t)tb.millitm) * int64_t_C(1000);
 927 #else
 928     struct timeval tv;
 929     gettimeofday(&tv,NULL);
 930     return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
 931 #endif
 932 }
 933
 934 static time_t mktimegm(struct tm *tm)
 935 {
 936     time_t t;
 937
 938     int y = tm->tm_year + 1900, m = tm->tm_mon + 1, d = tm->tm_mday;
 939
 940     if (m < 3) {
 941         m += 12;
 942         y--;
 943     }
 944
 945     t = 86400 *
 946         (d + (153 * m - 457) / 5 + 365 * y + y / 4 - y / 100 + y / 400 - 719469);
 947
 948     t += 3600 * tm->tm_hour + 60 * tm->tm_min + tm->tm_sec;
 949
 950     return t;
 951 }
 952
 953 /* Syntax:
 954  * - If not a duration:
 955  *  [{YYYY-MM-DD|YYYYMMDD}]{T| }{HH[:MM[:SS[.m...]]][Z]|HH[MM[SS[.m...]]][Z]}
 956  * Time is localtime unless Z is suffixed to the end. In this case GMT
 957  * Return the date in micro seconds since 1970
 958  * - If duration:
 959  *  HH[:MM[:SS[.m...]]]
 960  *  S+[.m...]
 961  */
 962 int64_t parse_date(const char *datestr, int duration)
 963 {
 964     const char *p;
 965     int64_t t;
 966     struct tm dt;
 967     int i;
 968     static const char *date_fmt[] = {
 969         "%Y-%m-%d",
 970         "%Y%m%d",
 971     };
 972     static const char *time_fmt[] = {
 973         "%H:%M:%S",
 974         "%H%M%S",
 975     };
 976     const char *q;
 977     int is_utc, len;
 978     char lastch;
 979     time_t now = time(0);
 980
 981     len = strlen(datestr);
 982     if (len > 0)
 983         lastch = datestr[len - 1];
 984     else
 985         lastch = '\0';
 986     is_utc = (lastch == 'z' || lastch == 'Z');
 987
 988     memset(&dt, 0, sizeof(dt));
 989
 990     p = datestr;
 991     q = NULL;
 992     if (!duration) {
 993         for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
 994             q = strptime(p, date_fmt[i], &dt);
 995             if (q) {
 996                 break;
 997             }
 998         }
 999
1000         if (!q) {
1001             if (is_utc) {
1002                 dt = *gmtime(&now);
1003             } else {
1004                 dt = *localtime(&now);
1005             }
1006             dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
1007         } else {
1008             p = q;
1009         }
1010
1011         if (*p == 'T' || *p == 't' || *p == ' ')
1012             p++;
1013
1014         for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
1015             q = strptime(p, time_fmt[i], &dt);
1016             if (q) {
1017                 break;
1018             }
1019         }
1020     } else {
1021         q = strptime(p, time_fmt[0], &dt);
1022         if (!q) {
1023             dt.tm_sec = strtol(p, (char **)&q, 10);
1024             dt.tm_min = 0;
1025             dt.tm_hour = 0;
1026         }
1027     }
1028
1029     /* Now we have all the fields that we can get */
1030     if (!q) {
1031         if (duration)
1032             return 0;
1033         else
1034             return now * int64_t_C(1000000);
1035     }
1036
1037     if (duration) {
1038         t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
1039     } else {
1040         dt.tm_isdst = -1;       /* unknown */
1041         if (is_utc) {
1042             t = mktimegm(&dt);
1043         } else {
1044             t = mktime(&dt);
1045         }
1046     }
1047
1048     t *= 1000000;
1049
1050     if (*q == '.') {
1051         int val, n;
1052         q++;
1053         for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
1054             if (!isdigit(*q))
1055                 break;
1056             val += n * (*q - '0');
1057         }
1058         t += val;
1059     }
1060     return t;
1061 }
1062
1063 /* syntax: '?tag1=val1&tag2=val2...'. Little URL decoding is done. Return
1064    1 if found */
1065 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
1066 {
1067     const char *p;
1068     char tag[128], *q;
1069
1070     p = info;
1071     if (*p == '?')
1072         p++;
1073     for(;;) {
1074         q = tag;
1075         while (*p != '\0' && *p != '=' && *p != '&') {
1076             if ((q - tag) < sizeof(tag) - 1)
1077                 *q++ = *p;
1078             p++;
1079         }
1080         *q = '\0';
1081         q = arg;
1082         if (*p == '=') {
1083             p++;
1084             while (*p != '&' && *p != '\0') {
1085                 if ((q - arg) < arg_size - 1) {
1086                     if (*p == '+')
1087                         *q++ = ' ';
1088                     else
1089                         *q++ = *p;
1090                 }
1091                 p++;
1092             }
1093             *q = '\0';
1094         }
1095         if (!strcmp(tag, tag1))
1096             return 1;
1097         if (*p != '&')
1098             break;
1099         p++;
1100     }
1101     return 0;
1102 }
1103
1104 /* Return in 'buf' the path with '%d' replaced by number. Also handles
1105    the '%0nd' format where 'n' is the total number of digits and
1106    '%%'. Return 0 if OK, and -1 if format error */
1107 int get_frame_filename(char *buf, int buf_size,
1108                        const char *path, int number)
1109 {
1110     const char *p;
1111     char *q, buf1[20];
1112     int nd, len, c, percentd_found;
1113
1114     q = buf;
1115     p = path;
1116     percentd_found = 0;
1117     for(;;) {
1118         c = *p++;
1119         if (c == '\0')
1120             break;
1121         if (c == '%') {
1122             do {
1123                 nd = 0;
1124                 while (isdigit(*p)) {
1125                     nd = nd * 10 + *p++ - '0';
1126                 }
1127                 c = *p++;
1128                 if (c == '*' && nd > 0) {
1129                     // The nd field is actually the modulus
1130                     number = number % nd;
1131                     c = *p++;
1132                     nd = 0;
1133                 }
1134             } while (isdigit(c));
1135
1136             switch(c) {
1137             case '%':
1138                 goto addchar;
1139             case 'd':
1140                 if (percentd_found)
1141                     goto fail;
1142                 percentd_found = 1;
1143                 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
1144                 len = strlen(buf1);
1145                 if ((q - buf + len) > buf_size - 1)
1146                     goto fail;
1147                 memcpy(q, buf1, len);
1148                 q += len;
1149                 break;
1150             default:
1151                 goto fail;
1152             }
1153         } else {
1154         addchar:
1155             if ((q - buf) < buf_size - 1)
1156                 *q++ = c;
1157         }
1158     }
1159     if (!percentd_found)
1160         goto fail;
1161     *q = '\0';
1162     return 0;
1163  fail:
1164     *q = '\0';
1165     return -1;
1166 }
1167
1168 /**
1169  *
1170  * Print on stdout a nice hexa dump of a buffer
1171  * @param buf buffer
1172  * @param size buffer size
1173  */
1174 void av_hex_dump(uint8_t *buf, int size)
1175 {
1176     int len, i, j, c;
1177
1178     for(i=0;i<size;i+=16) {
1179         len = size - i;
1180         if (len > 16)
1181             len = 16;
1182         printf("%08x ", i);
1183         for(j=0;j<16;j++) {
1184             if (j < len)
1185                 printf(" %02x", buf[i+j]);
1186             else
1187                 printf("   ");
1188         }
1189         printf(" ");
1190         for(j=0;j<len;j++) {
1191             c = buf[i+j];
1192             if (c < ' ' || c > '~')
1193                 c = '.';
1194             printf("%c", c);
1195         }
1196         printf("\n");
1197     }
1198 }
1199
1200 void url_split(char *proto, int proto_size,
1201                char *hostname, int hostname_size,
1202                int *port_ptr,
1203                char *path, int path_size,
1204                const char *url)
1205 {
1206     const char *p;
1207     char *q;
1208     int port;
1209
1210     port = -1;
1211
1212     p = url;
1213     q = proto;
1214     while (*p != ':' && *p != '\0') {
1215         if ((q - proto) < proto_size - 1)
1216             *q++ = *p;
1217         p++;
1218     }
1219     if (proto_size > 0)
1220         *q = '\0';
1221     if (*p == '\0') {
1222         if (proto_size > 0)
1223             proto[0] = '\0';
1224         if (hostname_size > 0)
1225             hostname[0] = '\0';
1226         p = url;
1227     } else {
1228         p++;
1229         if (*p == '/')
1230             p++;
1231         if (*p == '/')
1232             p++;
1233         q = hostname;
1234         while (*p != ':' && *p != '/' && *p != '?' && *p != '\0') {
1235             if ((q - hostname) < hostname_size - 1)
1236                 *q++ = *p;
1237             p++;
1238         }
1239         if (hostname_size > 0)
1240             *q = '\0';
1241         if (*p == ':') {
1242             p++;
1243             port = strtoul(p, (char **)&p, 10);
1244         }
1245     }
1246     if (port_ptr)
1247         *port_ptr = port;
1248     pstrcpy(path, path_size, p);
1249 }
1250
1251 /**
1252  * Set the pts for a given stream
1253  * @param s stream
1254  * @param pts_wrap_bits number of bits effectively used by the pts
1255  *        (used for wrap control, 33 is the value for MPEG)
1256  * @param pts_num numerator to convert to seconds (MPEG: 1)
1257  * @param pts_den denominator to convert to seconds (MPEG: 90000)
1258  */
1259 void av_set_pts_info(AVFormatContext *s, int pts_wrap_bits,
1260                      int pts_num, int pts_den)
1261 {
1262     s->pts_wrap_bits = pts_wrap_bits;
1263     s->pts_num = pts_num;
1264     s->pts_den = pts_den;
1265 }
1266
1267 /* fraction handling */
1268
1269 /**
1270  * f = val + (num / den) + 0.5. 'num' is normalized so that it is such
1271  * as 0 <= num < den.
1272  *
1273  * @param f fractional number
1274  * @param val integer value
1275  * @param num must be >= 0
1276  * @param den must be >= 1
1277  */
1278 void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
1279 {
1280     num += (den >> 1);
1281     if (num >= den) {
1282         val += num / den;
1283         num = num % den;
1284     }
1285     f->val = val;
1286     f->num = num;
1287     f->den = den;
1288 }
1289
1290 /* set f to (val + 0.5) */
1291 void av_frac_set(AVFrac *f, int64_t val)
1292 {
1293     f->val = val;
1294     f->num = f->den >> 1;
1295 }
1296
1297 /**
1298  * Fractionnal addition to f: f = f + (incr / f->den)
1299  *
1300  * @param f fractional number
1301  * @param incr increment, can be positive or negative
1302  */
1303 void av_frac_add(AVFrac *f, int64_t incr)
1304 {
1305     int64_t num, den;
1306
1307     num = f->num + incr;
1308     den = f->den;
1309     if (num < 0) {
1310         f->val += num / den;
1311         num = num % den;
1312         if (num < 0) {
1313             num += den;
1314             f->val--;
1315         }
1316     } else if (num >= den) {
1317         f->val += num / den;
1318         num = num % den;
1319     }
1320     f->num = num;
1321 }
1322
1323 /**
1324  * register a new image format
1325  * @param img_fmt Image format descriptor
1326  */
1327 void av_register_image_format(AVImageFormat *img_fmt)
1328 {
1329     AVImageFormat **p;
1330
1331     p = &first_image_format;
1332     while (*p != NULL) p = &(*p)->next;
1333     *p = img_fmt;
1334     img_fmt->next = NULL;
1335 }
1336
1337 /* guess image format */
1338 AVImageFormat *av_probe_image_format(AVProbeData *pd)
1339 {
1340     AVImageFormat *fmt1, *fmt;
1341     int score, score_max;
1342
1343     fmt = NULL;
1344     score_max = 0;
1345     for(fmt1 = first_image_format; fmt1 != NULL; fmt1 = fmt1->next) {
1346         if (fmt1->img_probe) {
1347             score = fmt1->img_probe(pd);
1348             if (score > score_max) {
1349                 score_max = score;
1350                 fmt = fmt1;
1351             }
1352         }
1353     }
1354     return fmt;
1355 }
1356
1357 AVImageFormat *guess_image_format(const char *filename)
1358 {
1359     AVImageFormat *fmt1;
1360
1361     for(fmt1 = first_image_format; fmt1 != NULL; fmt1 = fmt1->next) {
1362         if (fmt1->extensions && match_ext(filename, fmt1->extensions))
1363             return fmt1;
1364     }
1365     return NULL;
1366 }
1367
1368 /**
1369  * Read an image from a stream.
1370  * @param gb byte stream containing the image
1371  * @param fmt image format, NULL if probing is required
1372  */
1373 int av_read_image(ByteIOContext *pb, const char *filename,
1374                   AVImageFormat *fmt,
1375                   int (*alloc_cb)(void *, AVImageInfo *info), void *opaque)
1376 {
1377     char buf[PROBE_BUF_SIZE];
1378     AVProbeData probe_data, *pd = &probe_data;
1379     offset_t pos;
1380     int ret;
1381
1382     if (!fmt) {
1383         pd->filename = filename;
1384         pd->buf = buf;
1385         pos = url_ftell(pb);
1386         pd->buf_size = get_buffer(pb, buf, PROBE_BUF_SIZE);
1387         url_fseek(pb, pos, SEEK_SET);
1388         fmt = av_probe_image_format(pd);
1389     }
1390     if (!fmt)
1391         return AVERROR_NOFMT;
1392     ret = fmt->img_read(pb, alloc_cb, opaque);
1393     return ret;
1394 }
1395
1396 /**
1397  * Write an image to a stream.
1398  * @param pb byte stream for the image output
1399  * @param fmt image format
1400  * @param img image data and informations
1401  */
1402 int av_write_image(ByteIOContext *pb, AVImageFormat *fmt, AVImageInfo *img)
1403 {
1404     return fmt->img_write(pb, img);
1405 }
1406