git.sesse.net Git - ffmpeg/blob - ffserver.c

   1 /*
   2  * Multiple format streaming server
   3  * Copyright (c) 2000,2001 Gerard Lantau.
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program 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
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18  */
  19 #include <stdarg.h>
  20 #include <stdlib.h>
  21 #include <stdio.h>
  22 #include <string.h>
  23 #include <netinet/in.h>
  24 #include <unistd.h>
  25 #include <fcntl.h>
  26 #include <sys/ioctl.h>
  27 #include <sys/poll.h>
  28 #include <errno.h>
  29 #include <sys/time.h>
  30 #include <time.h>
  31 #include <getopt.h>
  32 #include <sys/types.h>
  33 #include <sys/socket.h>
  34 #include <arpa/inet.h>
  35 #include <netdb.h>
  36 #include <ctype.h>
  37 #include <signal.h>
  38 #include <assert.h>
  39
  40 #include "bswap.h" // needed for the bitstream writer in common.h which is included in avformat.h
  41 #include "avformat.h"
  42
  43 /* maximum number of simultaneous HTTP connections */
  44 #define HTTP_MAX_CONNECTIONS 2000
  45
  46 enum HTTPState {
  47     HTTPSTATE_WAIT_REQUEST,
  48     HTTPSTATE_SEND_HEADER,
  49     HTTPSTATE_SEND_DATA_HEADER,
  50     HTTPSTATE_SEND_DATA,
  51     HTTPSTATE_SEND_DATA_TRAILER,
  52     HTTPSTATE_RECEIVE_DATA,
  53     HTTPSTATE_WAIT_FEED,
  54 };
  55
  56 const char *http_state[] = {
  57     "WAIT_REQUEST",
  58     "SEND_HEADER",
  59     "SEND_DATA_HEADER",
  60     "SEND_DATA",
  61     "SEND_DATA_TRAILER",
  62     "RECEIVE_DATA",
  63     "WAIT_FEED",
  64 };
  65
  66 #define IOBUFFER_MAX_SIZE 16384
  67
  68 /* coef for exponential mean for bitrate estimation in statistics */
  69 #define AVG_COEF 0.9
  70
  71 /* timeouts are in ms */
  72 #define REQUEST_TIMEOUT (15 * 1000)
  73 #define SYNC_TIMEOUT (10 * 1000)
  74
  75 /* context associated with one connection */
  76 typedef struct HTTPContext {
  77     enum HTTPState state;
  78     int fd; /* socket file descriptor */
  79     struct sockaddr_in from_addr; /* origin */
  80     struct pollfd *poll_entry; /* used when polling */
  81     long timeout;
  82     UINT8 buffer[IOBUFFER_MAX_SIZE];
  83     UINT8 *buffer_ptr, *buffer_end;
  84     int http_error;
  85     struct HTTPContext *next;
  86     int got_key_frame[MAX_STREAMS]; /* for each type */
  87     INT64 data_count;
  88     /* feed input */
  89     int feed_fd;
  90     /* input format handling */
  91     AVFormatContext *fmt_in;
  92     /* output format handling */
  93     struct FFStream *stream;
  94     AVFormatContext fmt_ctx;
  95     int last_packet_sent; /* true if last data packet was sent */
  96 } HTTPContext;
  97
  98 /* each generated stream is described here */
  99 enum StreamType {
 100     STREAM_TYPE_LIVE,
 101     STREAM_TYPE_STATUS,
 102 };
 103
 104 /* description of each stream of the ffserver.conf file */
 105 typedef struct FFStream {
 106     enum StreamType stream_type;
 107     char filename[1024];     /* stream filename */
 108     struct FFStream *feed;
 109     AVFormat *fmt;
 110     int nb_streams;
 111     AVStream *streams[MAX_STREAMS];
 112     int feed_streams[MAX_STREAMS]; /* index of streams in the feed */
 113     char feed_filename[1024]; /* file name of the feed storage, or
 114                                  input file name for a stream */
 115     struct FFStream *next;
 116     /* feed specific */
 117     int feed_opened;     /* true if someone if writing to feed */
 118     int is_feed;         /* true if it is a feed */
 119     INT64 feed_max_size;      /* maximum storage size */
 120     INT64 feed_write_index;   /* current write position in feed (it wraps round) */
 121     INT64 feed_size;          /* current size of feed */
 122     struct FFStream *next_feed;
 123 } FFStream;
 124
 125 typedef struct FeedData {
 126     long long data_count;
 127     float avg_frame_size;   /* frame size averraged over last frames with exponential mean */
 128 } FeedData;
 129
 130 struct sockaddr_in my_addr;
 131 char logfilename[1024];
 132 HTTPContext *first_http_ctx;
 133 FFStream *first_feed;   /* contains only feeds */
 134 FFStream *first_stream; /* contains all streams, including feeds */
 135
 136 static int handle_http(HTTPContext *c, long cur_time);
 137 static int http_parse_request(HTTPContext *c);
 138 static int http_send_data(HTTPContext *c);
 139 static void compute_stats(HTTPContext *c);
 140 static int open_input_stream(HTTPContext *c, const char *info);
 141 static int http_start_receive_data(HTTPContext *c);
 142 static int http_receive_data(HTTPContext *c);
 143
 144 int nb_max_connections;
 145 int nb_connections;
 146
 147 static long gettime_ms(void)
 148 {
 149     struct timeval tv;
 150
 151     gettimeofday(&tv,NULL);
 152     return (long long)tv.tv_sec * 1000 + (tv.tv_usec / 1000);
 153 }
 154
 155 static FILE *logfile = NULL;
 156
 157 static void http_log(char *fmt, ...)
 158 {
 159     va_list ap;
 160     va_start(ap, fmt);
 161
 162     if (logfile)
 163         vfprintf(logfile, fmt, ap);
 164     va_end(ap);
 165 }
 166
 167 /* main loop of the http server */
 168 static int http_server(struct sockaddr_in my_addr)
 169 {
 170     int server_fd, tmp, ret;
 171     struct sockaddr_in from_addr;
 172     struct pollfd poll_table[HTTP_MAX_CONNECTIONS + 1], *poll_entry;
 173     HTTPContext *c, **cp;
 174     long cur_time;
 175
 176     server_fd = socket(AF_INET,SOCK_STREAM,0);
 177     if (server_fd < 0) {
 178         perror ("socket");
 179         return -1;
 180     }
 181
 182     tmp = 1;
 183     setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &tmp, sizeof(tmp));
 184
 185     if (bind (server_fd, (struct sockaddr *) &my_addr, sizeof (my_addr)) < 0) {
 186         perror ("bind");
 187         close(server_fd);
 188         return -1;
 189     }
 190
 191     if (listen (server_fd, 5) < 0) {
 192         perror ("listen");
 193         close(server_fd);
 194         return -1;
 195     }
 196
 197     http_log("ffserver started.\n");
 198
 199     fcntl(server_fd, F_SETFL, O_NONBLOCK);
 200     first_http_ctx = NULL;
 201     nb_connections = 0;
 202     first_http_ctx = NULL;
 203     for(;;) {
 204         poll_entry = poll_table;
 205         poll_entry->fd = server_fd;
 206         poll_entry->events = POLLIN;
 207         poll_entry++;
 208
 209         /* wait for events on each HTTP handle */
 210         c = first_http_ctx;
 211         while (c != NULL) {
 212             int fd;
 213             fd = c->fd;
 214             switch(c->state) {
 215             case HTTPSTATE_WAIT_REQUEST:
 216                 c->poll_entry = poll_entry;
 217                 poll_entry->fd = fd;
 218                 poll_entry->events = POLLIN;
 219                 poll_entry++;
 220                 break;
 221             case HTTPSTATE_SEND_HEADER:
 222             case HTTPSTATE_SEND_DATA_HEADER:
 223             case HTTPSTATE_SEND_DATA:
 224             case HTTPSTATE_SEND_DATA_TRAILER:
 225                 c->poll_entry = poll_entry;
 226                 poll_entry->fd = fd;
 227                 poll_entry->events = POLLOUT;
 228                 poll_entry++;
 229                 break;
 230             case HTTPSTATE_RECEIVE_DATA:
 231                 c->poll_entry = poll_entry;
 232                 poll_entry->fd = fd;
 233                 poll_entry->events = POLLIN;
 234                 poll_entry++;
 235                 break;
 236             case HTTPSTATE_WAIT_FEED:
 237                 /* need to catch errors */
 238                 c->poll_entry = poll_entry;
 239                 poll_entry->fd = fd;
 240                 poll_entry->events = 0;
 241                 poll_entry++;
 242                 break;
 243             default:
 244                 c->poll_entry = NULL;
 245                 break;
 246             }
 247             c = c->next;
 248         }
 249
 250         /* wait for an event on one connection. We poll at least every
 251            second to handle timeouts */
 252         do {
 253             ret = poll(poll_table, poll_entry - poll_table, 1000);
 254         } while (ret == -1);
 255
 256         cur_time = gettime_ms();
 257
 258         /* now handle the events */
 259
 260         cp = &first_http_ctx;
 261         while ((*cp) != NULL) {
 262             c = *cp;
 263             if (handle_http (c, cur_time) < 0) {
 264                 /* close and free the connection */
 265                 close(c->fd);
 266                 if (c->fmt_in)
 267                     av_close_input_file(c->fmt_in);
 268                 *cp = c->next;
 269                 free(c);
 270                 nb_connections--;
 271             } else {
 272                 cp = &c->next;
 273             }
 274         }
 275
 276         /* new connection request ? */
 277         poll_entry = poll_table;
 278         if (poll_entry->revents & POLLIN) {
 279             int fd, len;
 280
 281             len = sizeof(from_addr);
 282             fd = accept(server_fd, (struct sockaddr *)&from_addr,
 283                         &len);
 284             if (fd >= 0) {
 285                 fcntl(fd, F_SETFL, O_NONBLOCK);
 286                 /* XXX: should output a warning page when coming
 287                    close to the connection limit */
 288                 if (nb_connections >= nb_max_connections) {
 289                     close(fd);
 290                 } else {
 291                     /* add a new connection */
 292                     c = av_mallocz(sizeof(HTTPContext));
 293                     c->next = first_http_ctx;
 294                     first_http_ctx = c;
 295                     c->fd = fd;
 296                     c->poll_entry = NULL;
 297                     c->from_addr = from_addr;
 298                     c->state = HTTPSTATE_WAIT_REQUEST;
 299                     c->buffer_ptr = c->buffer;
 300                     c->buffer_end = c->buffer + IOBUFFER_MAX_SIZE;
 301                     c->timeout = cur_time + REQUEST_TIMEOUT;
 302                     nb_connections++;
 303                 }
 304             }
 305         }
 306         poll_entry++;
 307     }
 308 }
 309
 310 static int handle_http(HTTPContext *c, long cur_time)
 311 {
 312     int len;
 313
 314     switch(c->state) {
 315     case HTTPSTATE_WAIT_REQUEST:
 316         /* timeout ? */
 317         if ((c->timeout - cur_time) < 0)
 318             return -1;
 319         if (c->poll_entry->revents & (POLLERR | POLLHUP))
 320             return -1;
 321
 322         /* no need to read if no events */
 323         if (!(c->poll_entry->revents & POLLIN))
 324             return 0;
 325         /* read the data */
 326         len = read(c->fd, c->buffer_ptr, c->buffer_end - c->buffer_ptr);
 327         if (len < 0) {
 328             if (errno != EAGAIN && errno != EINTR)
 329                 return -1;
 330         } else if (len == 0) {
 331             return -1;
 332         } else {
 333             /* search for end of request. XXX: not fully correct since garbage could come after the end */
 334             UINT8 *ptr;
 335             c->buffer_ptr += len;
 336             ptr = c->buffer_ptr;
 337             if ((ptr >= c->buffer + 2 && !memcmp(ptr-2, "\n\n", 2)) ||
 338                 (ptr >= c->buffer + 4 && !memcmp(ptr-4, "\r\n\r\n", 4))) {
 339                 /* request found : parse it and reply */
 340                 if (http_parse_request(c) < 0)
 341                     return -1;
 342             } else if (ptr >= c->buffer_end) {
 343                 /* request too long: cannot do anything */
 344                 return -1;
 345             }
 346         }
 347         break;
 348
 349     case HTTPSTATE_SEND_HEADER:
 350         if (c->poll_entry->revents & (POLLERR | POLLHUP))
 351             return -1;
 352
 353         /* no need to read if no events */
 354         if (!(c->poll_entry->revents & POLLOUT))
 355             return 0;
 356         len = write(c->fd, c->buffer_ptr, c->buffer_end - c->buffer_ptr);
 357         if (len < 0) {
 358             if (errno != EAGAIN && errno != EINTR) {
 359                 /* error : close connection */
 360                 return -1;
 361             }
 362         } else {
 363             c->buffer_ptr += len;
 364             if (c->buffer_ptr >= c->buffer_end) {
 365                 /* if error, exit */
 366                 if (c->http_error)
 367                     return -1;
 368                 /* all the buffer was send : synchronize to the incoming stream */
 369                 c->state = HTTPSTATE_SEND_DATA_HEADER;
 370                 c->buffer_ptr = c->buffer_end = c->buffer;
 371             }
 372         }
 373         break;
 374
 375     case HTTPSTATE_SEND_DATA:
 376     case HTTPSTATE_SEND_DATA_HEADER:
 377     case HTTPSTATE_SEND_DATA_TRAILER:
 378         /* no need to read if no events */
 379         if (c->poll_entry->revents & (POLLERR | POLLHUP))
 380             return -1;
 381
 382         if (!(c->poll_entry->revents & POLLOUT))
 383             return 0;
 384         if (http_send_data(c) < 0)
 385             return -1;
 386         break;
 387     case HTTPSTATE_RECEIVE_DATA:
 388         /* no need to read if no events */
 389         if (c->poll_entry->revents & (POLLERR | POLLHUP))
 390             return -1;
 391         if (!(c->poll_entry->revents & POLLIN))
 392             return 0;
 393         if (http_receive_data(c) < 0)
 394             return -1;
 395         break;
 396     case HTTPSTATE_WAIT_FEED:
 397         /* no need to read if no events */
 398         if (c->poll_entry->revents & (POLLERR | POLLHUP))
 399             return -1;
 400
 401         /* nothing to do, we'll be waken up by incoming feed packets */
 402         break;
 403     default:
 404         return -1;
 405     }
 406     return 0;
 407 }
 408
 409 /* parse http request and prepare header */
 410 static int http_parse_request(HTTPContext *c)
 411 {
 412     char *p;
 413     int post;
 414     char cmd[32];
 415     char info[1024], *filename;
 416     char url[1024], *q;
 417     char protocol[32];
 418     char msg[1024];
 419     const char *mime_type;
 420     FFStream *stream;
 421
 422     p = c->buffer;
 423     q = cmd;
 424     while (!isspace(*p) && *p != '\0') {
 425         if ((q - cmd) < sizeof(cmd) - 1)
 426             *q++ = *p;
 427         p++;
 428     }
 429     *q = '\0';
 430     if (!strcmp(cmd, "GET"))
 431         post = 0;
 432     else if (!strcmp(cmd, "POST"))
 433         post = 1;
 434     else
 435         return -1;
 436
 437     while (isspace(*p)) p++;
 438     q = url;
 439     while (!isspace(*p) && *p != '\0') {
 440         if ((q - url) < sizeof(url) - 1)
 441             *q++ = *p;
 442         p++;
 443     }
 444     *q = '\0';
 445
 446     while (isspace(*p)) p++;
 447     q = protocol;
 448     while (!isspace(*p) && *p != '\0') {
 449         if ((q - protocol) < sizeof(protocol) - 1)
 450             *q++ = *p;
 451         p++;
 452     }
 453     *q = '\0';
 454     if (strcmp(protocol, "HTTP/1.0") && strcmp(protocol, "HTTP/1.1"))
 455         return -1;
 456
 457     /* find the filename and the optional info string in the request */
 458     p = url;
 459     if (*p == '/')
 460         p++;
 461     filename = p;
 462     p = strchr(p, '?');
 463     if (p) {
 464         strcpy(info, p);
 465         *p = '\0';
 466     } else {
 467         info[0] = '\0';
 468     }
 469
 470     stream = first_stream;
 471     while (stream != NULL) {
 472         if (!strcmp(stream->filename, filename))
 473             break;
 474         stream = stream->next;
 475     }
 476     if (stream == NULL) {
 477         sprintf(msg, "File '%s' not found", url);
 478         goto send_error;
 479     }
 480     c->stream = stream;
 481
 482     /* should do it after so that the size can be computed */
 483     {
 484         char buf1[32], buf2[32], *p;
 485         time_t ti;
 486         /* XXX: reentrant function ? */
 487         p = inet_ntoa(c->from_addr.sin_addr);
 488         strcpy(buf1, p);
 489         ti = time(NULL);
 490         p = ctime(&ti);
 491         strcpy(buf2, p);
 492         p = buf2 + strlen(p) - 1;
 493         if (*p == '\n')
 494             *p = '\0';
 495         http_log("%s - - [%s] \"%s %s %s\" %d %d\n",
 496                  buf1, buf2, cmd, url, protocol, 200, 1024);
 497     }
 498
 499     /* XXX: add there authenticate and IP match */
 500
 501     if (post) {
 502         /* if post, it means a feed is being sent */
 503         if (!stream->is_feed) {
 504             sprintf(msg, "POST command not handled");
 505             goto send_error;
 506         }
 507         if (http_start_receive_data(c) < 0) {
 508             sprintf(msg, "could not open feed");
 509             goto send_error;
 510         }
 511         c->http_error = 0;
 512         c->state = HTTPSTATE_RECEIVE_DATA;
 513         return 0;
 514     }
 515
 516     if (c->stream->stream_type == STREAM_TYPE_STATUS)
 517         goto send_stats;
 518
 519     /* open input stream */
 520     if (open_input_stream(c, info) < 0) {
 521         sprintf(msg, "Input stream corresponding to '%s' not found", url);
 522         goto send_error;
 523     }
 524
 525     /* prepare http header */
 526     q = c->buffer;
 527     q += sprintf(q, "HTTP/1.0 200 OK\r\n");
 528     mime_type = c->stream->fmt->mime_type;
 529     if (!mime_type)
 530         mime_type = "application/x-octet_stream";
 531     q += sprintf(q, "Content-type: %s\r\n", mime_type);
 532     q += sprintf(q, "Pragma: no-cache\r\n");
 533
 534     /* for asf, we need extra headers */
 535     if (!strcmp(c->stream->fmt->name,"asf")) {
 536         q += sprintf(q, "Pragma: features=broadcast\r\n");
 537     }
 538     q += sprintf(q, "\r\n");
 539
 540     /* prepare output buffer */
 541     c->http_error = 0;
 542     c->buffer_ptr = c->buffer;
 543     c->buffer_end = q;
 544     c->state = HTTPSTATE_SEND_HEADER;
 545     return 0;
 546  send_error:
 547     c->http_error = 404;
 548     q = c->buffer;
 549     q += sprintf(q, "HTTP/1.0 404 Not Found\r\n");
 550     q += sprintf(q, "Content-type: %s\r\n", "text/html");
 551     q += sprintf(q, "\r\n");
 552     q += sprintf(q, "<HTML>\n");
 553     q += sprintf(q, "<HEAD><TITLE>404 Not Found</TITLE></HEAD>\n");
 554     q += sprintf(q, "<BODY>%s</BODY>\n", msg);
 555     q += sprintf(q, "</HTML>\n");
 556
 557     /* prepare output buffer */
 558     c->buffer_ptr = c->buffer;
 559     c->buffer_end = q;
 560     c->state = HTTPSTATE_SEND_HEADER;
 561     return 0;
 562  send_stats:
 563     compute_stats(c);
 564     c->http_error = 200; /* horrible : we use this value to avoid
 565                             going to the send data state */
 566     c->state = HTTPSTATE_SEND_HEADER;
 567     return 0;
 568 }
 569
 570 static void compute_stats(HTTPContext *c)
 571 {
 572     HTTPContext *c1;
 573     FFStream *stream;
 574     char *q, *p;
 575     time_t ti;
 576     int i;
 577
 578     q = c->buffer;
 579     q += sprintf(q, "HTTP/1.0 200 OK\r\n");
 580     q += sprintf(q, "Content-type: %s\r\n", "text/html");
 581     q += sprintf(q, "Pragma: no-cache\r\n");
 582     q += sprintf(q, "\r\n");
 583
 584     q += sprintf(q, "<HEAD><TITLE>FFServer Status</TITLE></HEAD>\n<BODY>");
 585     q += sprintf(q, "<H1>FFServer Status</H1>\n");
 586     /* format status */
 587     q += sprintf(q, "<H1>Available Streams</H1>\n");
 588     q += sprintf(q, "<TABLE>\n");
 589     q += sprintf(q, "<TR><TD>Path<TD>Format<TD>Bit rate (kbits/s)<TD>Video<TD>Audio<TD>Feed\n");
 590     stream = first_stream;
 591     while (stream != NULL) {
 592         q += sprintf(q, "<TR><TD><A HREF=\"/%s\">%s</A> ",
 593                      stream->filename, stream->filename);
 594         switch(stream->stream_type) {
 595         case STREAM_TYPE_LIVE:
 596             {
 597                 int audio_bit_rate = 0;
 598                 int video_bit_rate = 0;
 599
 600                 for(i=0;i<stream->nb_streams;i++) {
 601                     AVStream *st = stream->streams[i];
 602                     switch(st->codec.codec_type) {
 603                     case CODEC_TYPE_AUDIO:
 604                         audio_bit_rate += st->codec.bit_rate;
 605                         break;
 606                     case CODEC_TYPE_VIDEO:
 607                         video_bit_rate += st->codec.bit_rate;
 608                         break;
 609                     }
 610                 }
 611                 q += sprintf(q, "<TD> %s <TD> %d <TD> %d <TD> %d",
 612                              stream->fmt->name,
 613                              (audio_bit_rate + video_bit_rate) / 1000,
 614                              video_bit_rate / 1000, audio_bit_rate / 1000);
 615                 if (stream->feed) {
 616                     q += sprintf(q, "<TD>%s", stream->feed->filename);
 617                 } else {
 618                     q += sprintf(q, "<TD>%s", stream->feed_filename);
 619                 }
 620                 q += sprintf(q, "\n");
 621             }
 622             break;
 623         default:
 624             q += sprintf(q, "<TD> - <TD> - <TD> - <TD> -\n");
 625             break;
 626         }
 627         stream = stream->next;
 628     }
 629     q += sprintf(q, "</TABLE>\n");
 630
 631 #if 0
 632     {
 633         float avg;
 634         AVCodecContext *enc;
 635         char buf[1024];
 636
 637         /* feed status */
 638         stream = first_feed;
 639         while (stream != NULL) {
 640             q += sprintf(q, "<H1>Feed '%s'</H1>\n", stream->filename);
 641             q += sprintf(q, "<TABLE>\n");
 642             q += sprintf(q, "<TR><TD>Parameters<TD>Frame count<TD>Size<TD>Avg bitrate (kbits/s)\n");
 643             for(i=0;i<stream->nb_streams;i++) {
 644                 AVStream *st = stream->streams[i];
 645                 FeedData *fdata = st->priv_data;
 646                 enc = &st->codec;
 647
 648                 avcodec_string(buf, sizeof(buf), enc);
 649                 avg = fdata->avg_frame_size * (float)enc->rate * 8.0;
 650                 if (enc->codec->type == CODEC_TYPE_AUDIO && enc->frame_size > 0)
 651                     avg /= enc->frame_size;
 652                 q += sprintf(q, "<TR><TD>%s <TD> %d <TD> %Ld <TD> %0.1f\n",
 653                              buf, enc->frame_number, fdata->data_count, avg / 1000.0);
 654             }
 655             q += sprintf(q, "</TABLE>\n");
 656             stream = stream->next_feed;
 657         }
 658     }
 659 #endif
 660
 661     /* connection status */
 662     q += sprintf(q, "<H1>Connection Status</H1>\n");
 663
 664     q += sprintf(q, "Number of connections: %d / %d<BR>\n",
 665                  nb_connections, nb_max_connections);
 666
 667     q += sprintf(q, "<TABLE>\n");
 668     q += sprintf(q, "<TR><TD>#<TD>File<TD>IP<TD>State<TD>Size\n");
 669     c1 = first_http_ctx;
 670     i = 0;
 671     while (c1 != NULL) {
 672         i++;
 673         p = inet_ntoa(c1->from_addr.sin_addr);
 674         q += sprintf(q, "<TR><TD><B>%d</B><TD>%s%s <TD> %s <TD> %s <TD> %Ld\n",
 675                      i, c1->stream->filename,
 676                      c1->state == HTTPSTATE_RECEIVE_DATA ? "(input)" : "",
 677                      p,
 678                      http_state[c1->state],
 679                      c1->data_count);
 680         c1 = c1->next;
 681     }
 682     q += sprintf(q, "</TABLE>\n");
 683
 684     /* date */
 685     ti = time(NULL);
 686     p = ctime(&ti);
 687     q += sprintf(q, "<HR>Generated at %s", p);
 688     q += sprintf(q, "</BODY>\n</HTML>\n");
 689
 690     c->buffer_ptr = c->buffer;
 691     c->buffer_end = q;
 692 }
 693
 694
 695 static void http_write_packet(void *opaque,
 696                               unsigned char *buf, int size)
 697 {
 698     HTTPContext *c = opaque;
 699     if (size > IOBUFFER_MAX_SIZE)
 700         abort();
 701     memcpy(c->buffer, buf, size);
 702     c->buffer_ptr = c->buffer;
 703     c->buffer_end = c->buffer + size;
 704 }
 705
 706 static int open_input_stream(HTTPContext *c, const char *info)
 707 {
 708     char buf[128];
 709     char input_filename[1024];
 710     AVFormatContext *s;
 711     int buf_size;
 712     INT64 stream_pos;
 713
 714     /* find file name */
 715     if (c->stream->feed) {
 716         strcpy(input_filename, c->stream->feed->feed_filename);
 717         buf_size = FFM_PACKET_SIZE;
 718         /* compute position (absolute time) */
 719         if (find_info_tag(buf, sizeof(buf), "date", info)) {
 720             stream_pos = parse_date(buf, 0);
 721         } else {
 722             stream_pos = gettime();
 723         }
 724     } else {
 725         strcpy(input_filename, c->stream->feed_filename);
 726         buf_size = 0;
 727         /* compute position (relative time) */
 728         if (find_info_tag(buf, sizeof(buf), "date", info)) {
 729             stream_pos = parse_date(buf, 1);
 730         } else {
 731             stream_pos = 0;
 732         }
 733     }
 734     if (input_filename[0] == '\0')
 735         return -1;
 736
 737     /* open stream */
 738     s = av_open_input_file(input_filename, NULL, buf_size, NULL);
 739     if (!s)
 740         return -1;
 741     c->fmt_in = s;
 742
 743     if (c->fmt_in->format->read_seek) {
 744         c->fmt_in->format->read_seek(c->fmt_in, stream_pos);
 745     }
 746
 747     //    printf("stream %s opened pos=%0.6f\n", input_filename, stream_pos / 1000000.0);
 748     return 0;
 749 }
 750
 751 static int http_prepare_data(HTTPContext *c)
 752 {
 753     int i;
 754
 755     switch(c->state) {
 756     case HTTPSTATE_SEND_DATA_HEADER:
 757         memset(&c->fmt_ctx, 0, sizeof(c->fmt_ctx));
 758         if (c->stream->feed) {
 759             /* open output stream by using specified codecs */
 760             c->fmt_ctx.format = c->stream->fmt;
 761             c->fmt_ctx.nb_streams = c->stream->nb_streams;
 762             for(i=0;i<c->fmt_ctx.nb_streams;i++) {
 763                 AVStream *st;
 764                 st = av_mallocz(sizeof(AVStream));
 765                 c->fmt_ctx.streams[i] = st;
 766                 memcpy(st, c->stream->streams[i], sizeof(AVStream));
 767                 st->codec.frame_number = 0; /* XXX: should be done in
 768                                                AVStream, not in codec */
 769                 c->got_key_frame[i] = 0;
 770             }
 771         } else {
 772             /* open output stream by using codecs in specified file */
 773             c->fmt_ctx.format = c->stream->fmt;
 774             c->fmt_ctx.nb_streams = c->fmt_in->nb_streams;
 775             for(i=0;i<c->fmt_ctx.nb_streams;i++) {
 776                 AVStream *st;
 777                 st = av_mallocz(sizeof(AVStream));
 778                 c->fmt_ctx.streams[i] = st;
 779                 memcpy(st, c->fmt_in->streams[i], sizeof(AVStream));
 780                 st->codec.frame_number = 0; /* XXX: should be done in
 781                                                AVStream, not in codec */
 782                 c->got_key_frame[i] = 0;
 783             }
 784         }
 785         init_put_byte(&c->fmt_ctx.pb, c->buffer, IOBUFFER_MAX_SIZE,
 786                       1, c, NULL, http_write_packet, NULL);
 787         c->fmt_ctx.pb.is_streamed = 1;
 788         /* prepare header */
 789         c->fmt_ctx.format->write_header(&c->fmt_ctx);
 790         c->state = HTTPSTATE_SEND_DATA;
 791         c->last_packet_sent = 0;
 792         break;
 793     case HTTPSTATE_SEND_DATA:
 794         /* find a new packet */
 795 #if 0
 796         fifo_total_size = http_fifo_write_count - c->last_http_fifo_write_count;
 797         if (fifo_total_size >= ((3 * FIFO_MAX_SIZE) / 4)) {
 798             /* overflow : resync. We suppose that wptr is at this
 799                point a pointer to a valid packet */
 800             c->rptr = http_fifo.wptr;
 801             for(i=0;i<c->fmt_ctx.nb_streams;i++) {
 802                 c->got_key_frame[i] = 0;
 803             }
 804         }
 805
 806         start_rptr = c->rptr;
 807         if (fifo_read(&http_fifo, (UINT8 *)&hdr, sizeof(hdr), &c->rptr) < 0)
 808             return 0;
 809         payload_size = ntohs(hdr.payload_size);
 810         payload = malloc(payload_size);
 811         if (fifo_read(&http_fifo, payload, payload_size, &c->rptr) < 0) {
 812             /* cannot read all the payload */
 813             free(payload);
 814             c->rptr = start_rptr;
 815             return 0;
 816         }
 817
 818         c->last_http_fifo_write_count = http_fifo_write_count -
 819             fifo_size(&http_fifo, c->rptr);
 820
 821         if (c->stream->stream_type != STREAM_TYPE_MASTER) {
 822             /* test if the packet can be handled by this format */
 823             ret = 0;
 824             for(i=0;i<c->fmt_ctx.nb_streams;i++) {
 825                 AVStream *st = c->fmt_ctx.streams[i];
 826                 if (test_header(&hdr, &st->codec)) {
 827                     /* only begin sending when got a key frame */
 828                     if (st->codec.key_frame)
 829                         c->got_key_frame[i] = 1;
 830                     if (c->got_key_frame[i]) {
 831                         ret = c->fmt_ctx.format->write_packet(&c->fmt_ctx, i,
 832                                                                    payload, payload_size);
 833                     }
 834                     break;
 835                 }
 836             }
 837             if (ret) {
 838                 /* must send trailer now */
 839                 c->state = HTTPSTATE_SEND_DATA_TRAILER;
 840             }
 841         } else {
 842             /* master case : send everything */
 843             char *q;
 844             q = c->buffer;
 845             memcpy(q, &hdr, sizeof(hdr));
 846             q += sizeof(hdr);
 847             memcpy(q, payload, payload_size);
 848             q += payload_size;
 849             c->buffer_ptr = c->buffer;
 850             c->buffer_end = q;
 851         }
 852         free(payload);
 853 #endif
 854         {
 855             AVPacket pkt;
 856
 857             /* read a packet from the input stream */
 858             if (c->stream->feed) {
 859                 ffm_set_write_index(c->fmt_in,
 860                                     c->stream->feed->feed_write_index,
 861                                     c->stream->feed->feed_size);
 862             }
 863             if (av_read_packet(c->fmt_in, &pkt) < 0) {
 864                 if (c->stream->feed && c->stream->feed->feed_opened) {
 865                     /* if coming from feed, it means we reached the end of the
 866                        ffm file, so must wait for more data */
 867                     c->state = HTTPSTATE_WAIT_FEED;
 868                     return 1; /* state changed */
 869                 } else {
 870                     /* must send trailer now because eof or error */
 871                     c->state = HTTPSTATE_SEND_DATA_TRAILER;
 872                 }
 873             } else {
 874                 /* send it to the appropriate stream */
 875                 if (c->stream->feed) {
 876                     /* if coming from a feed, select the right stream */
 877                     for(i=0;i<c->stream->nb_streams;i++) {
 878                         if (c->stream->feed_streams[i] == pkt.stream_index) {
 879                             pkt.stream_index = i;
 880                             goto send_it;
 881                         }
 882                     }
 883                 } else {
 884                 send_it:
 885                     if (av_write_packet(&c->fmt_ctx, &pkt, 0))
 886                         c->state = HTTPSTATE_SEND_DATA_TRAILER;
 887                 }
 888
 889                 av_free_packet(&pkt);
 890             }
 891         }
 892         break;
 893     default:
 894     case HTTPSTATE_SEND_DATA_TRAILER:
 895         /* last packet test ? */
 896         if (c->last_packet_sent)
 897             return -1;
 898         /* prepare header */
 899         c->fmt_ctx.format->write_trailer(&c->fmt_ctx);
 900         c->last_packet_sent = 1;
 901         break;
 902     }
 903     return 0;
 904 }
 905
 906 /* should convert the format at the same time */
 907 static int http_send_data(HTTPContext *c)
 908 {
 909     int len, ret;
 910
 911     while (c->buffer_ptr >= c->buffer_end) {
 912         ret = http_prepare_data(c);
 913         if (ret < 0)
 914             return -1;
 915         else if (ret == 0) {
 916             break;
 917         } else {
 918             /* state change requested */
 919             return 0;
 920         }
 921     }
 922
 923     len = write(c->fd, c->buffer_ptr, c->buffer_end - c->buffer_ptr);
 924     if (len < 0) {
 925         if (errno != EAGAIN && errno != EINTR) {
 926             /* error : close connection */
 927             return -1;
 928         }
 929     } else {
 930         c->buffer_ptr += len;
 931         c->data_count += len;
 932     }
 933     return 0;
 934 }
 935
 936 static int http_start_receive_data(HTTPContext *c)
 937 {
 938     int fd;
 939
 940     if (c->stream->feed_opened)
 941         return -1;
 942
 943     /* open feed */
 944     fd = open(c->stream->feed_filename, O_RDWR);
 945     if (fd < 0)
 946         return -1;
 947     c->feed_fd = fd;
 948
 949     c->stream->feed_write_index = ffm_read_write_index(fd);
 950     c->stream->feed_size = lseek(fd, 0, SEEK_END);
 951     lseek(fd, 0, SEEK_SET);
 952
 953     /* init buffer input */
 954     c->buffer_ptr = c->buffer;
 955     c->buffer_end = c->buffer + FFM_PACKET_SIZE;
 956     c->stream->feed_opened = 1;
 957     return 0;
 958 }
 959
 960 static int http_receive_data(HTTPContext *c)
 961 {
 962     int len;
 963     HTTPContext *c1;
 964
 965     if (c->buffer_ptr >= c->buffer_end) {
 966         /* a packet has been received : write it in the store, except
 967            if header */
 968         if (c->data_count > FFM_PACKET_SIZE) {
 969             FFStream *feed = c->stream;
 970
 971             //            printf("writing pos=0x%Lx size=0x%Lx\n", feed->feed_write_index, feed->feed_size);
 972             /* XXX: use llseek or url_seek */
 973             lseek(c->feed_fd, feed->feed_write_index, SEEK_SET);
 974             write(c->feed_fd, c->buffer, FFM_PACKET_SIZE);
 975
 976             feed->feed_write_index += FFM_PACKET_SIZE;
 977             /* update file size */
 978             if (feed->feed_write_index > c->stream->feed_size)
 979                 feed->feed_size = feed->feed_write_index;
 980
 981             /* handle wrap around if max file size reached */
 982             if (feed->feed_write_index >= c->stream->feed_max_size)
 983                 feed->feed_write_index = FFM_PACKET_SIZE;
 984
 985             /* write index */
 986             ffm_write_write_index(c->feed_fd, feed->feed_write_index);
 987
 988             /* wake up any waiting connections */
 989             for(c1 = first_http_ctx; c1 != NULL; c1 = c1->next) {
 990                 if (c1->state == HTTPSTATE_WAIT_FEED &&
 991                     c1->stream->feed == c->stream->feed) {
 992                     c1->state = HTTPSTATE_SEND_DATA;
 993                 }
 994             }
 995         }
 996         c->buffer_ptr = c->buffer;
 997     }
 998
 999     len = read(c->fd, c->buffer_ptr, c->buffer_end - c->buffer_ptr);
1000     if (len < 0) {
1001         if (errno != EAGAIN && errno != EINTR) {
1002             /* error : close connection */
1003             goto fail;
1004         }
1005     } else if (len == 0) {
1006         /* end of connection : close it */
1007         goto fail;
1008     } else {
1009         c->buffer_ptr += len;
1010         c->data_count += len;
1011     }
1012     return 0;
1013  fail:
1014     c->stream->feed_opened = 0;
1015     close(c->feed_fd);
1016     return -1;
1017 }
1018
1019 /* return the stream number in the feed */
1020 int add_av_stream(FFStream *feed,
1021                   AVStream *st)
1022 {
1023     AVStream *fst;
1024     AVCodecContext *av, *av1;
1025     int i;
1026
1027     av = &st->codec;
1028     for(i=0;i<feed->nb_streams;i++) {
1029         st = feed->streams[i];
1030         av1 = &st->codec;
1031         if (av1->codec == av->codec &&
1032             av1->bit_rate == av->bit_rate) {
1033
1034             switch(av->codec_type) {
1035             case CODEC_TYPE_AUDIO:
1036                 if (av1->channels == av->channels &&
1037                     av1->sample_rate == av->sample_rate)
1038                     goto found;
1039                 break;
1040             case CODEC_TYPE_VIDEO:
1041                 if (av1->width == av->width &&
1042                     av1->height == av->height &&
1043                     av1->frame_rate == av->frame_rate &&
1044                     av1->gop_size == av->gop_size)
1045                     goto found;
1046                 break;
1047             }
1048         }
1049     }
1050
1051     fst = av_mallocz(sizeof(AVStream));
1052     if (!fst)
1053         return -1;
1054     fst->priv_data = av_mallocz(sizeof(FeedData));
1055     memcpy(&fst->codec, av, sizeof(AVCodecContext));
1056     feed->streams[feed->nb_streams++] = fst;
1057     return feed->nb_streams - 1;
1058  found:
1059     return i;
1060 }
1061
1062 /* compute the needed AVStream for each feed */
1063 void build_feed_streams(void)
1064 {
1065     FFStream *stream, *feed;
1066     int i;
1067
1068     /* gather all streams */
1069     for(stream = first_stream; stream != NULL; stream = stream->next) {
1070         feed = stream->feed;
1071         if (feed) {
1072             if (!stream->is_feed) {
1073                 for(i=0;i<stream->nb_streams;i++) {
1074                     stream->feed_streams[i] = add_av_stream(feed, stream->streams[i]);
1075                 }
1076             } else {
1077                 for(i=0;i<stream->nb_streams;i++) {
1078                     stream->feed_streams[i] = i;
1079                 }
1080             }
1081         }
1082     }
1083
1084     /* create feed files if needed */
1085     for(feed = first_feed; feed != NULL; feed = feed->next_feed) {
1086         int fd;
1087
1088         if (!url_exist(feed->feed_filename)) {
1089             AVFormatContext s1, *s = &s1;
1090
1091             /* only write the header of the ffm file */
1092             if (url_fopen(&s->pb, feed->feed_filename, URL_WRONLY) < 0) {
1093                 fprintf(stderr, "Could not open output feed file '%s'\n",
1094                         feed->feed_filename);
1095                 exit(1);
1096             }
1097             s->format = feed->fmt;
1098             s->nb_streams = feed->nb_streams;
1099             for(i=0;i<s->nb_streams;i++) {
1100                 AVStream *st;
1101                 st = feed->streams[i];
1102                 s->streams[i] = st;
1103             }
1104             s->format->write_header(s);
1105
1106             url_fclose(&s->pb);
1107         }
1108         /* get feed size and write index */
1109         fd = open(feed->feed_filename, O_RDONLY);
1110         if (fd < 0) {
1111             fprintf(stderr, "Could not open output feed file '%s'\n",
1112                     feed->feed_filename);
1113             exit(1);
1114         }
1115
1116         feed->feed_write_index = ffm_read_write_index(fd);
1117         feed->feed_size = lseek(fd, 0, SEEK_END);
1118         /* ensure that we do not wrap before the end of file */
1119         if (feed->feed_max_size < feed->feed_size)
1120             feed->feed_max_size = feed->feed_size;
1121
1122         close(fd);
1123     }
1124 }
1125
1126 static void get_arg(char *buf, int buf_size, const char **pp)
1127 {
1128     const char *p;
1129     char *q;
1130     int quote;
1131
1132     p = *pp;
1133     while (isspace(*p)) p++;
1134     q = buf;
1135     quote = 0;
1136     if (*p == '\"' || *p == '\'')
1137         quote = *p++;
1138     for(;;) {
1139         if (quote) {
1140             if (*p == quote)
1141                 break;
1142         } else {
1143             if (isspace(*p))
1144                 break;
1145         }
1146         if (*p == '\0')
1147             break;
1148         if ((q - buf) < buf_size - 1)
1149             *q++ = *p;
1150         p++;
1151     }
1152     *q = '\0';
1153     if (quote && *p == quote)
1154         p++;
1155     *pp = p;
1156 }
1157
1158 /* add a codec and set the default parameters */
1159 void add_codec(FFStream *stream, AVCodecContext *av)
1160 {
1161     AVStream *st;
1162
1163     /* compute default parameters */
1164     switch(av->codec_type) {
1165     case CODEC_TYPE_AUDIO:
1166         if (av->bit_rate == 0)
1167             av->bit_rate = 64000;
1168         if (av->sample_rate == 0)
1169             av->sample_rate = 22050;
1170         if (av->channels == 0)
1171             av->channels = 1;
1172         break;
1173     case CODEC_TYPE_VIDEO:
1174         if (av->bit_rate == 0)
1175             av->bit_rate = 64000;
1176         if (av->frame_rate == 0)
1177             av->frame_rate = 5 * FRAME_RATE_BASE;
1178         if (av->width == 0 || av->height == 0) {
1179             av->width = 160;
1180             av->height = 128;
1181         }
1182         av->bit_rate_tolerance= 128000;
1183         av->qmin= 5;
1184         av->qmax= 31;
1185         av->qcompress= 0.5;
1186         av->qblur= 0.5;
1187         av->max_qdiff= 3;
1188
1189         break;
1190     }
1191
1192     st = av_mallocz(sizeof(AVStream));
1193     if (!st)
1194         return;
1195     stream->streams[stream->nb_streams++] = st;
1196     memcpy(&st->codec, av, sizeof(AVCodecContext));
1197 }
1198
1199 int parse_ffconfig(const char *filename)
1200 {
1201     FILE *f;
1202     char line[1024];
1203     char cmd[64];
1204     char arg[1024];
1205     const char *p;
1206     int val, errors, line_num;
1207     FFStream **last_stream, *stream;
1208     FFStream **last_feed, *feed;
1209     AVCodecContext audio_enc, video_enc;
1210     int audio_id, video_id;
1211
1212     f = fopen(filename, "r");
1213     if (!f) {
1214         perror(filename);
1215         return -1;
1216     }
1217
1218     errors = 0;
1219     line_num = 0;
1220     first_stream = NULL;
1221     last_stream = &first_stream;
1222     first_feed = NULL;
1223     last_feed = &first_feed;
1224     stream = NULL;
1225     feed = NULL;
1226     audio_id = CODEC_ID_NONE;
1227     video_id = CODEC_ID_NONE;
1228     for(;;) {
1229         if (fgets(line, sizeof(line), f) == NULL)
1230             break;
1231         line_num++;
1232         p = line;
1233         while (isspace(*p))
1234             p++;
1235         if (*p == '\0' || *p == '#')
1236             continue;
1237
1238         get_arg(cmd, sizeof(cmd), &p);
1239
1240         if (!strcasecmp(cmd, "Port")) {
1241             get_arg(arg, sizeof(arg), &p);
1242             my_addr.sin_port = htons (atoi(arg));
1243         } else if (!strcasecmp(cmd, "BindAddress")) {
1244             get_arg(arg, sizeof(arg), &p);
1245             if (!inet_aton(arg, &my_addr.sin_addr)) {
1246                 fprintf(stderr, "%s:%d: Invalid IP address: %s\n",
1247                         filename, line_num, arg);
1248                 errors++;
1249             }
1250         } else if (!strcasecmp(cmd, "MaxClients")) {
1251             get_arg(arg, sizeof(arg), &p);
1252             val = atoi(arg);
1253             if (val < 1 || val > HTTP_MAX_CONNECTIONS) {
1254                 fprintf(stderr, "%s:%d: Invalid MaxClients: %s\n",
1255                         filename, line_num, arg);
1256                 errors++;
1257             } else {
1258                 nb_max_connections = val;
1259             }
1260         } else if (!strcasecmp(cmd, "CustomLog")) {
1261             get_arg(logfilename, sizeof(logfilename), &p);
1262         } else if (!strcasecmp(cmd, "<Feed")) {
1263             /*********************************************/
1264             /* Feed related options */
1265             char *q;
1266             if (stream || feed) {
1267                 fprintf(stderr, "%s:%d: Already in a tag\n",
1268                         filename, line_num);
1269             } else {
1270                 feed = av_mallocz(sizeof(FFStream));
1271                 /* add in stream list */
1272                 *last_stream = feed;
1273                 last_stream = &feed->next;
1274                 /* add in feed list */
1275                 *last_feed = feed;
1276                 last_feed = &feed->next_feed;
1277
1278                 get_arg(feed->filename, sizeof(feed->filename), &p);
1279                 q = strrchr(feed->filename, '>');
1280                 if (*q)
1281                     *q = '\0';
1282                 feed->fmt = guess_format("ffm", NULL, NULL);
1283                 /* defaut feed file */
1284                 snprintf(feed->feed_filename, sizeof(feed->feed_filename),
1285                          "/tmp/%s.ffm", feed->filename);
1286                 feed->feed_max_size = 5 * 1024 * 1024;
1287                 feed->is_feed = 1;
1288                 feed->feed = feed; /* self feeding :-) */
1289             }
1290         } else if (!strcasecmp(cmd, "File")) {
1291             if (feed) {
1292                 get_arg(feed->feed_filename, sizeof(feed->feed_filename), &p);
1293             } else if (stream) {
1294                 get_arg(stream->feed_filename, sizeof(stream->feed_filename), &p);
1295             }
1296         } else if (!strcasecmp(cmd, "FileMaxSize")) {
1297             if (feed) {
1298                 const char *p1;
1299                 double fsize;
1300
1301                 get_arg(arg, sizeof(arg), &p);
1302                 p1 = arg;
1303                 fsize = strtod(p1, (char **)&p1);
1304                 switch(toupper(*p1)) {
1305                 case 'K':
1306                     fsize *= 1024;
1307                     break;
1308                 case 'M':
1309                     fsize *= 1024 * 1024;
1310                     break;
1311                 case 'G':
1312                     fsize *= 1024 * 1024 * 1024;
1313                     break;
1314                 }
1315                 feed->feed_max_size = (INT64)fsize;
1316             }
1317         } else if (!strcasecmp(cmd, "</Feed>")) {
1318             if (!feed) {
1319                 fprintf(stderr, "%s:%d: No corresponding <Feed> for </Feed>\n",
1320                         filename, line_num);
1321                 errors++;
1322             }
1323             feed = NULL;
1324         } else if (!strcasecmp(cmd, "<Stream")) {
1325             /*********************************************/
1326             /* Stream related options */
1327             char *q;
1328             if (stream || feed) {
1329                 fprintf(stderr, "%s:%d: Already in a tag\n",
1330                         filename, line_num);
1331             } else {
1332                 stream = av_mallocz(sizeof(FFStream));
1333                 *last_stream = stream;
1334                 last_stream = &stream->next;
1335
1336                 get_arg(stream->filename, sizeof(stream->filename), &p);
1337                 q = strrchr(stream->filename, '>');
1338                 if (*q)
1339                     *q = '\0';
1340                 stream->fmt = guess_format(NULL, stream->filename, NULL);
1341                 memset(&audio_enc, 0, sizeof(AVCodecContext));
1342                 memset(&video_enc, 0, sizeof(AVCodecContext));
1343                 audio_id = CODEC_ID_NONE;
1344                 video_id = CODEC_ID_NONE;
1345                 if (stream->fmt) {
1346                     audio_id = stream->fmt->audio_codec;
1347                     video_id = stream->fmt->video_codec;
1348                 }
1349             }
1350         } else if (!strcasecmp(cmd, "Feed")) {
1351             get_arg(arg, sizeof(arg), &p);
1352             if (stream) {
1353                 FFStream *sfeed;
1354
1355                 sfeed = first_feed;
1356                 while (sfeed != NULL) {
1357                     if (!strcmp(sfeed->filename, arg))
1358                         break;
1359                     sfeed = sfeed->next_feed;
1360                 }
1361                 if (!sfeed) {
1362                     fprintf(stderr, "%s:%d: feed '%s' not defined\n",
1363                             filename, line_num, arg);
1364                 } else {
1365                     stream->feed = sfeed;
1366                 }
1367             }
1368         } else if (!strcasecmp(cmd, "Format")) {
1369             get_arg(arg, sizeof(arg), &p);
1370             if (!strcmp(arg, "status")) {
1371                 stream->stream_type = STREAM_TYPE_STATUS;
1372                 stream->fmt = NULL;
1373             } else {
1374                 stream->stream_type = STREAM_TYPE_LIVE;
1375                 /* jpeg cannot be used here, so use single frame jpeg */
1376                 if (!strcmp(arg, "jpeg"))
1377                     strcpy(arg, "singlejpeg");
1378                 stream->fmt = guess_format(arg, NULL, NULL);
1379                 if (!stream->fmt) {
1380                     fprintf(stderr, "%s:%d: Unknown Format: %s\n",
1381                             filename, line_num, arg);
1382                     errors++;
1383                 }
1384             }
1385             if (stream->fmt) {
1386                 audio_id = stream->fmt->audio_codec;
1387                 video_id = stream->fmt->video_codec;
1388             }
1389         } else if (!strcasecmp(cmd, "AudioBitRate")) {
1390             get_arg(arg, sizeof(arg), &p);
1391             if (stream) {
1392                 audio_enc.bit_rate = atoi(arg) * 1000;
1393             }
1394         } else if (!strcasecmp(cmd, "AudioChannels")) {
1395             get_arg(arg, sizeof(arg), &p);
1396             if (stream) {
1397                 audio_enc.channels = atoi(arg);
1398             }
1399         } else if (!strcasecmp(cmd, "AudioSampleRate")) {
1400             get_arg(arg, sizeof(arg), &p);
1401             if (stream) {
1402                 audio_enc.sample_rate = atoi(arg);
1403             }
1404         } else if (!strcasecmp(cmd, "VideoBitRate")) {
1405             get_arg(arg, sizeof(arg), &p);
1406             if (stream) {
1407                 video_enc.bit_rate = atoi(arg) * 1000;
1408             }
1409         } else if (!strcasecmp(cmd, "VideoSize")) {
1410             get_arg(arg, sizeof(arg), &p);
1411             if (stream) {
1412                 parse_image_size(&video_enc.width, &video_enc.height, arg);
1413                 if ((video_enc.width % 16) != 0 ||
1414                     (video_enc.height % 16) != 0) {
1415                     fprintf(stderr, "%s:%d: Image size must be a multiple of 16\n",
1416                             filename, line_num);
1417                     errors++;
1418                 }
1419             }
1420         } else if (!strcasecmp(cmd, "VideoFrameRate")) {
1421             get_arg(arg, sizeof(arg), &p);
1422             if (stream) {
1423                 video_enc.frame_rate = (int)(strtod(arg, NULL) * FRAME_RATE_BASE);
1424             }
1425         } else if (!strcasecmp(cmd, "VideoGopSize")) {
1426             get_arg(arg, sizeof(arg), &p);
1427             if (stream) {
1428                 video_enc.gop_size = atoi(arg);
1429             }
1430         } else if (!strcasecmp(cmd, "VideoIntraOnly")) {
1431             if (stream) {
1432                 video_enc.gop_size = 1;
1433             }
1434         } else if (!strcasecmp(cmd, "NoVideo")) {
1435             video_id = CODEC_ID_NONE;
1436         } else if (!strcasecmp(cmd, "NoAudio")) {
1437             audio_id = CODEC_ID_NONE;
1438         } else if (!strcasecmp(cmd, "</Stream>")) {
1439             if (!stream) {
1440                 fprintf(stderr, "%s:%d: No corresponding <Stream> for </Stream>\n",
1441                         filename, line_num);
1442                 errors++;
1443             }
1444             if (stream->feed && stream->fmt && strcmp(stream->fmt->name, "ffm") != 0) {
1445                 if (audio_id != CODEC_ID_NONE) {
1446                     audio_enc.codec_type = CODEC_TYPE_AUDIO;
1447                     audio_enc.codec_id = audio_id;
1448                     add_codec(stream, &audio_enc);
1449                 }
1450                 if (video_id != CODEC_ID_NONE) {
1451                     video_enc.codec_type = CODEC_TYPE_VIDEO;
1452                     video_enc.codec_id = video_id;
1453                     add_codec(stream, &video_enc);
1454                 }
1455             }
1456             stream = NULL;
1457         } else {
1458             fprintf(stderr, "%s:%d: Incorrect keyword: '%s'\n",
1459                     filename, line_num, cmd);
1460             errors++;
1461         }
1462     }
1463
1464     fclose(f);
1465     if (errors)
1466         return -1;
1467     else
1468         return 0;
1469 }
1470
1471
1472 void *http_server_thread(void *arg)
1473 {
1474     http_server(my_addr);
1475     return NULL;
1476 }
1477
1478 #if 0
1479 static void write_packet(FFCodec *ffenc,
1480                          UINT8 *buf, int size)
1481 {
1482     PacketHeader hdr;
1483     AVCodecContext *enc = &ffenc->enc;
1484     UINT8 *wptr;
1485     mk_header(&hdr, enc, size);
1486     wptr = http_fifo.wptr;
1487     fifo_write(&http_fifo, (UINT8 *)&hdr, sizeof(hdr), &wptr);
1488     fifo_write(&http_fifo, buf, size, &wptr);
1489     /* atomic modification of wptr */
1490     http_fifo.wptr = wptr;
1491     ffenc->data_count += size;
1492     ffenc->avg_frame_size = ffenc->avg_frame_size * AVG_COEF + size * (1.0 - AVG_COEF);
1493 }
1494 #endif
1495
1496 void help(void)
1497 {
1498     printf("ffserver version " FFMPEG_VERSION ", Copyright (c) 2000,2001 Gerard Lantau\n"
1499            "usage: ffserver [-L] [-h] [-f configfile]\n"
1500            "Hyper fast multi format Audio/Video streaming server\n"
1501            "\n"
1502            "-L            : print the LICENCE\n"
1503            "-h            : this help\n"
1504            "-f configfile : use configfile instead of /etc/ffserver.conf\n"
1505            );
1506 }
1507
1508 void licence(void)
1509 {
1510     printf(
1511     "ffserver version " FFMPEG_VERSION "\n"
1512     "Copyright (c) 2000,2001 Gerard Lantau\n"
1513     "This program is free software; you can redistribute it and/or modify\n"
1514     "it under the terms of the GNU General Public License as published by\n"
1515     "the Free Software Foundation; either version 2 of the License, or\n"
1516     "(at your option) any later version.\n"
1517     "\n"
1518     "This program is distributed in the hope that it will be useful,\n"
1519     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
1520     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
1521     "GNU General Public License for more details.\n"
1522     "\n"
1523     "You should have received a copy of the GNU General Public License\n"
1524     "along with this program; if not, write to the Free Software\n"
1525     "Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.\n"
1526     );
1527 }
1528
1529 int main(int argc, char **argv)
1530 {
1531     const char *config_filename;
1532     int c;
1533
1534     register_all();
1535
1536     config_filename = "/etc/ffserver.conf";
1537
1538     for(;;) {
1539         c = getopt_long_only(argc, argv, "Lh?f:", NULL, NULL);
1540         if (c == -1)
1541             break;
1542         switch(c) {
1543         case 'L':
1544             licence();
1545             exit(1);
1546         case '?':
1547         case 'h':
1548             help();
1549             exit(1);
1550         case 'f':
1551             config_filename = optarg;
1552             break;
1553         default:
1554             exit(2);
1555         }
1556     }
1557
1558     /* address on which the server will handle connections */
1559     my_addr.sin_family = AF_INET;
1560     my_addr.sin_port = htons (8080);
1561     my_addr.sin_addr.s_addr = htonl (INADDR_ANY);
1562     nb_max_connections = 5;
1563     first_stream = NULL;
1564     logfilename[0] = '\0';
1565
1566     if (parse_ffconfig(config_filename) < 0) {
1567         fprintf(stderr, "Incorrect config file - exiting.\n");
1568         exit(1);
1569     }
1570
1571     build_feed_streams();
1572
1573     /* signal init */
1574     signal(SIGPIPE, SIG_IGN);
1575
1576     /* open log file if needed */
1577     if (logfilename[0] != '\0') {
1578         if (!strcmp(logfilename, "-"))
1579             logfile = stdout;
1580         else
1581             logfile = fopen(logfilename, "w");
1582     }
1583
1584     if (http_server(my_addr) < 0) {
1585         fprintf(stderr, "Could start http server\n");
1586         exit(1);
1587     }
1588
1589     return 0;
1590 }