license/copyright change - fixed header mess
[ffmpeg.git] / ffserver.c
1 /*
2  * Multiple format streaming server
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 #define HAVE_AV_CONFIG_H
20 #include "avformat.h"
21
22 #include <stdarg.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
39 /* maximum number of simultaneous HTTP connections */
40 #define HTTP_MAX_CONNECTIONS 2000
41
42 enum HTTPState {
43     HTTPSTATE_WAIT_REQUEST,
44     HTTPSTATE_SEND_HEADER,
45     HTTPSTATE_SEND_DATA_HEADER,
46     HTTPSTATE_SEND_DATA,
47     HTTPSTATE_SEND_DATA_TRAILER,
48     HTTPSTATE_RECEIVE_DATA,
49     HTTPSTATE_WAIT_FEED,
50 };
51
52 const char *http_state[] = {
53     "WAIT_REQUEST",
54     "SEND_HEADER",
55     "SEND_DATA_HEADER",
56     "SEND_DATA",
57     "SEND_DATA_TRAILER",
58     "RECEIVE_DATA",
59     "WAIT_FEED",
60 };
61
62 #define IOBUFFER_MAX_SIZE 32768
63 #define PACKET_MAX_SIZE 16384
64
65 /* coef for exponential mean for bitrate estimation in statistics */
66 #define AVG_COEF 0.9
67
68 /* timeouts are in ms */
69 #define REQUEST_TIMEOUT (15 * 1000)
70 #define SYNC_TIMEOUT (10 * 1000)
71
72 /* context associated with one connection */
73 typedef struct HTTPContext {
74     enum HTTPState state;
75     int fd; /* socket file descriptor */
76     struct sockaddr_in from_addr; /* origin */
77     struct pollfd *poll_entry; /* used when polling */
78     long timeout;
79     UINT8 *buffer_ptr, *buffer_end;
80     int http_error;
81     struct HTTPContext *next;
82     int got_key_frame; /* stream 0 => 1, stream 1 => 2, stream 2=> 4 */
83     INT64 data_count;
84     /* feed input */
85     int feed_fd;
86     /* input format handling */
87     AVFormatContext *fmt_in;
88     /* output format handling */
89     struct FFStream *stream;
90     AVFormatContext fmt_ctx;
91     int last_packet_sent; /* true if last data packet was sent */
92     int suppress_log;
93     int bandwidth;
94     time_t start_time;
95     char protocol[16];
96     char method[16];
97     char url[128];
98     UINT8 buffer[IOBUFFER_MAX_SIZE];
99     UINT8 pbuffer[PACKET_MAX_SIZE];
100 } HTTPContext;
101
102 /* each generated stream is described here */
103 enum StreamType {
104     STREAM_TYPE_LIVE,
105     STREAM_TYPE_STATUS,
106 };
107
108 /* description of each stream of the ffserver.conf file */
109 typedef struct FFStream {
110     enum StreamType stream_type;
111     char filename[1024];     /* stream filename */
112     struct FFStream *feed;
113     AVOutputFormat *fmt;
114     int nb_streams;
115     int prebuffer;      /* Number of millseconds early to start */
116     time_t max_time;
117     int send_on_key;
118     AVStream *streams[MAX_STREAMS];
119     int feed_streams[MAX_STREAMS]; /* index of streams in the feed */
120     char feed_filename[1024]; /* file name of the feed storage, or
121                                  input file name for a stream */
122     struct FFStream *next;
123     /* feed specific */
124     int feed_opened;     /* true if someone if writing to feed */
125     int is_feed;         /* true if it is a feed */
126     int conns_served;
127     INT64 bytes_served;
128     INT64 feed_max_size;      /* maximum storage size */
129     INT64 feed_write_index;   /* current write position in feed (it wraps round) */
130     INT64 feed_size;          /* current size of feed */
131     struct FFStream *next_feed;
132 } FFStream;
133
134 typedef struct FeedData {
135     long long data_count;
136     float avg_frame_size;   /* frame size averraged over last frames with exponential mean */
137 } FeedData;
138
139 struct sockaddr_in my_addr;
140 char logfilename[1024];
141 HTTPContext *first_http_ctx;
142 FFStream *first_feed;   /* contains only feeds */
143 FFStream *first_stream; /* contains all streams, including feeds */
144
145 static int handle_http(HTTPContext *c, long cur_time);
146 static int http_parse_request(HTTPContext *c);
147 static int http_send_data(HTTPContext *c);
148 static void compute_stats(HTTPContext *c);
149 static int open_input_stream(HTTPContext *c, const char *info);
150 static int http_start_receive_data(HTTPContext *c);
151 static int http_receive_data(HTTPContext *c);
152
153 int nb_max_connections;
154 int nb_connections;
155
156 int nb_max_bandwidth;
157 int nb_bandwidth;
158
159 static long gettime_ms(void)
160 {
161     struct timeval tv;
162
163     gettimeofday(&tv,NULL);
164     return (long long)tv.tv_sec * 1000 + (tv.tv_usec / 1000);
165 }
166
167 static FILE *logfile = NULL;
168
169 static void http_log(char *fmt, ...)
170 {
171     va_list ap;
172     va_start(ap, fmt);
173     
174     if (logfile) {
175         vfprintf(logfile, fmt, ap);
176         fflush(logfile);
177     }
178     va_end(ap);
179 }
180
181 static void log_connection(HTTPContext *c)
182 {
183     char buf1[32], buf2[32], *p;
184     time_t ti;
185
186     if (c->suppress_log) 
187         return;
188
189     /* XXX: reentrant function ? */
190     p = inet_ntoa(c->from_addr.sin_addr);
191     strcpy(buf1, p);
192     ti = time(NULL);
193     p = ctime(&ti);
194     strcpy(buf2, p);
195     p = buf2 + strlen(p) - 1;
196     if (*p == '\n')
197         *p = '\0';
198     http_log("%s - - [%s] \"%s %s %s\" %d %lld\n", 
199              buf1, buf2, c->method, c->url, c->protocol, (c->http_error ? c->http_error : 200), c->data_count);
200 }
201
202 /* main loop of the http server */
203 static int http_server(struct sockaddr_in my_addr)
204 {
205     int server_fd, tmp, ret;
206     struct sockaddr_in from_addr;
207     struct pollfd poll_table[HTTP_MAX_CONNECTIONS + 1], *poll_entry;
208     HTTPContext *c, **cp;
209     long cur_time;
210
211     server_fd = socket(AF_INET,SOCK_STREAM,0);
212     if (server_fd < 0) {
213         perror ("socket");
214         return -1;
215     }
216         
217     tmp = 1;
218     setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &tmp, sizeof(tmp));
219
220     if (bind (server_fd, (struct sockaddr *) &my_addr, sizeof (my_addr)) < 0) {
221         perror ("bind");
222         close(server_fd);
223         return -1;
224     }
225   
226     if (listen (server_fd, 5) < 0) {
227         perror ("listen");
228         close(server_fd);
229         return -1;
230     }
231
232     http_log("ffserver started.\n");
233
234     fcntl(server_fd, F_SETFL, O_NONBLOCK);
235     first_http_ctx = NULL;
236     nb_connections = 0;
237     first_http_ctx = NULL;
238     for(;;) {
239         poll_entry = poll_table;
240         poll_entry->fd = server_fd;
241         poll_entry->events = POLLIN;
242         poll_entry++;
243
244         /* wait for events on each HTTP handle */
245         c = first_http_ctx;
246         while (c != NULL) {
247             int fd;
248             fd = c->fd;
249             switch(c->state) {
250             case HTTPSTATE_WAIT_REQUEST:
251                 c->poll_entry = poll_entry;
252                 poll_entry->fd = fd;
253                 poll_entry->events = POLLIN;
254                 poll_entry++;
255                 break;
256             case HTTPSTATE_SEND_HEADER:
257             case HTTPSTATE_SEND_DATA_HEADER:
258             case HTTPSTATE_SEND_DATA:
259             case HTTPSTATE_SEND_DATA_TRAILER:
260                 c->poll_entry = poll_entry;
261                 poll_entry->fd = fd;
262                 poll_entry->events = POLLOUT;
263                 poll_entry++;
264                 break;
265             case HTTPSTATE_RECEIVE_DATA:
266                 c->poll_entry = poll_entry;
267                 poll_entry->fd = fd;
268                 poll_entry->events = POLLIN;
269                 poll_entry++;
270                 break;
271             case HTTPSTATE_WAIT_FEED:
272                 /* need to catch errors */
273                 c->poll_entry = poll_entry;
274                 poll_entry->fd = fd;
275                 poll_entry->events = POLLIN;/* Maybe this will work */
276                 poll_entry++;
277                 break;
278             default:
279                 c->poll_entry = NULL;
280                 break;
281             }
282             c = c->next;
283         }
284
285         /* wait for an event on one connection. We poll at least every
286            second to handle timeouts */
287         do {
288             ret = poll(poll_table, poll_entry - poll_table, 1000);
289         } while (ret == -1);
290         
291         cur_time = gettime_ms();
292
293         /* now handle the events */
294
295         cp = &first_http_ctx;
296         while ((*cp) != NULL) {
297             c = *cp;
298             if (handle_http (c, cur_time) < 0) {
299                 /* close and free the connection */
300                 log_connection(c);
301                 close(c->fd);
302                 if (c->fmt_in)
303                     av_close_input_file(c->fmt_in);
304                 *cp = c->next;
305                 nb_bandwidth -= c->bandwidth;
306                 av_free(c);
307                 nb_connections--;
308             } else {
309                 cp = &c->next;
310             }
311         }
312
313         /* new connection request ? */
314         poll_entry = poll_table;
315         if (poll_entry->revents & POLLIN) {
316             int fd, len;
317
318             len = sizeof(from_addr);
319             fd = accept(server_fd, (struct sockaddr *)&from_addr, 
320                         &len);
321             if (fd >= 0) {
322                 fcntl(fd, F_SETFL, O_NONBLOCK);
323                 /* XXX: should output a warning page when coming
324                    close to the connection limit */
325                 if (nb_connections >= nb_max_connections) {
326                     close(fd);
327                 } else {
328                     /* add a new connection */
329                     c = av_mallocz(sizeof(HTTPContext));
330                     c->next = first_http_ctx;
331                     first_http_ctx = c;
332                     c->fd = fd;
333                     c->poll_entry = NULL;
334                     c->from_addr = from_addr;
335                     c->state = HTTPSTATE_WAIT_REQUEST;
336                     c->buffer_ptr = c->buffer;
337                     c->buffer_end = c->buffer + IOBUFFER_MAX_SIZE;
338                     c->timeout = cur_time + REQUEST_TIMEOUT;
339                     nb_connections++;
340                 }
341             }
342         }
343         poll_entry++;
344     }
345 }
346
347 static int handle_http(HTTPContext *c, long cur_time)
348 {
349     int len;
350     
351     switch(c->state) {
352     case HTTPSTATE_WAIT_REQUEST:
353         /* timeout ? */
354         if ((c->timeout - cur_time) < 0)
355             return -1;
356         if (c->poll_entry->revents & (POLLERR | POLLHUP))
357             return -1;
358
359         /* no need to read if no events */
360         if (!(c->poll_entry->revents & POLLIN))
361             return 0;
362         /* read the data */
363         len = read(c->fd, c->buffer_ptr, c->buffer_end - c->buffer_ptr);
364         if (len < 0) {
365             if (errno != EAGAIN && errno != EINTR)
366                 return -1;
367         } else if (len == 0) {
368             return -1;
369         } else {
370             /* search for end of request. XXX: not fully correct since garbage could come after the end */
371             UINT8 *ptr;
372             c->buffer_ptr += len;
373             ptr = c->buffer_ptr;
374             if ((ptr >= c->buffer + 2 && !memcmp(ptr-2, "\n\n", 2)) ||
375                 (ptr >= c->buffer + 4 && !memcmp(ptr-4, "\r\n\r\n", 4))) {
376                 /* request found : parse it and reply */
377                 if (http_parse_request(c) < 0)
378                     return -1;
379             } else if (ptr >= c->buffer_end) {
380                 /* request too long: cannot do anything */
381                 return -1;
382             }
383         }
384         break;
385
386     case HTTPSTATE_SEND_HEADER:
387         if (c->poll_entry->revents & (POLLERR | POLLHUP))
388             return -1;
389
390         /* no need to read if no events */
391         if (!(c->poll_entry->revents & POLLOUT))
392             return 0;
393         len = write(c->fd, c->buffer_ptr, c->buffer_end - c->buffer_ptr);
394         if (len < 0) {
395             if (errno != EAGAIN && errno != EINTR) {
396                 /* error : close connection */
397                 return -1;
398             }
399         } else {
400             c->buffer_ptr += len;
401             if (c->stream)
402                 c->stream->bytes_served += len;
403             c->data_count += len;
404             if (c->buffer_ptr >= c->buffer_end) {
405                 /* if error, exit */
406                 if (c->http_error)
407                     return -1;
408                 /* all the buffer was send : synchronize to the incoming stream */
409                 c->state = HTTPSTATE_SEND_DATA_HEADER;
410                 c->buffer_ptr = c->buffer_end = c->buffer;
411             }
412         }
413         break;
414
415     case HTTPSTATE_SEND_DATA:
416     case HTTPSTATE_SEND_DATA_HEADER:
417     case HTTPSTATE_SEND_DATA_TRAILER:
418         /* no need to read if no events */
419         if (c->poll_entry->revents & (POLLERR | POLLHUP))
420             return -1;
421         
422         if (!(c->poll_entry->revents & POLLOUT))
423             return 0;
424         if (http_send_data(c) < 0)
425             return -1;
426         break;
427     case HTTPSTATE_RECEIVE_DATA:
428         /* no need to read if no events */
429         if (c->poll_entry->revents & (POLLERR | POLLHUP))
430             return -1;
431         if (!(c->poll_entry->revents & POLLIN))
432             return 0;
433         if (http_receive_data(c) < 0)
434             return -1;
435         break;
436     case HTTPSTATE_WAIT_FEED:
437         /* no need to read if no events */
438         if (c->poll_entry->revents & (POLLIN | POLLERR | POLLHUP))
439             return -1;
440
441         /* nothing to do, we'll be waken up by incoming feed packets */
442         break;
443     default:
444         return -1;
445     }
446     return 0;
447 }
448
449
450 /* parse http request and prepare header */
451 static int http_parse_request(HTTPContext *c)
452 {
453     char *p;
454     int post;
455     int doing_asx;
456     int doing_ram;
457     char cmd[32];
458     char info[1024], *filename;
459     char url[1024], *q;
460     char protocol[32];
461     char msg[1024];
462     const char *mime_type;
463     FFStream *stream;
464     int i;
465
466     p = c->buffer;
467     q = cmd;
468     while (!isspace(*p) && *p != '\0') {
469         if ((q - cmd) < sizeof(cmd) - 1)
470             *q++ = *p;
471         p++;
472     }
473     *q = '\0';
474
475     pstrcpy(c->method, sizeof(c->method), cmd);
476
477     if (!strcmp(cmd, "GET"))
478         post = 0;
479     else if (!strcmp(cmd, "POST"))
480         post = 1;
481     else
482         return -1;
483
484     while (isspace(*p)) p++;
485     q = url;
486     while (!isspace(*p) && *p != '\0') {
487         if ((q - url) < sizeof(url) - 1)
488             *q++ = *p;
489         p++;
490     }
491     *q = '\0';
492
493     pstrcpy(c->url, sizeof(c->url), url);
494
495     while (isspace(*p)) p++;
496     q = protocol;
497     while (!isspace(*p) && *p != '\0') {
498         if ((q - protocol) < sizeof(protocol) - 1)
499             *q++ = *p;
500         p++;
501     }
502     *q = '\0';
503     if (strcmp(protocol, "HTTP/1.0") && strcmp(protocol, "HTTP/1.1"))
504         return -1;
505
506     pstrcpy(c->protocol, sizeof(c->protocol), protocol);
507     
508     /* find the filename and the optional info string in the request */
509     p = url;
510     if (*p == '/')
511         p++;
512     filename = p;
513     p = strchr(p, '?');
514     if (p) {
515         pstrcpy(info, sizeof(info), p);
516         *p = '\0';
517     } else {
518         info[0] = '\0';
519     }
520
521     if (strlen(filename) > 4 && strcmp(".asx", filename + strlen(filename) - 4) == 0) {
522         doing_asx = 1;
523         filename[strlen(filename)-1] = 'f';
524     } else {
525         doing_asx = 0;
526     }
527
528     if (strlen(filename) > 4 && 
529         (strcmp(".rpm", filename + strlen(filename) - 4) == 0 ||
530          strcmp(".ram", filename + strlen(filename) - 4) == 0)) {
531         doing_ram = 1;
532         strcpy(filename + strlen(filename)-2, "m");
533     } else {
534         doing_ram = 0;
535     }
536
537     stream = first_stream;
538     while (stream != NULL) {
539         if (!strcmp(stream->filename, filename))
540             break;
541         stream = stream->next;
542     }
543     if (stream == NULL) {
544         sprintf(msg, "File '%s' not found", url);
545         goto send_error;
546     }
547
548     if (post == 0 && stream->stream_type == STREAM_TYPE_LIVE) {
549         /* See if we meet the bandwidth requirements */
550         for(i=0;i<stream->nb_streams;i++) {
551             AVStream *st = stream->streams[i];
552             switch(st->codec.codec_type) {
553             case CODEC_TYPE_AUDIO:
554                 c->bandwidth += st->codec.bit_rate;
555                 break;
556             case CODEC_TYPE_VIDEO:
557                 c->bandwidth += st->codec.bit_rate;
558                 break;
559             default:
560                 av_abort();
561             }
562         }
563     }
564
565     c->bandwidth /= 1000;
566     nb_bandwidth += c->bandwidth;
567
568     if (post == 0 && nb_max_bandwidth < nb_bandwidth) {
569         c->http_error = 200;
570         q = c->buffer;
571         q += sprintf(q, "HTTP/1.0 200 Server too busy\r\n");
572         q += sprintf(q, "Content-type: text/html\r\n");
573         q += sprintf(q, "\r\n");
574         q += sprintf(q, "<html><head><title>Too busy</title></head><body>\r\n");
575         q += sprintf(q, "The server is too busy to serve your request at this time.<p>\r\n");
576         q += sprintf(q, "The bandwidth being served (including your stream) is %dkbit/sec, and this exceeds the limit of %dkbit/sec\r\n",
577             nb_bandwidth, nb_max_bandwidth);
578         q += sprintf(q, "</body></html>\r\n");
579
580         /* prepare output buffer */
581         c->buffer_ptr = c->buffer;
582         c->buffer_end = q;
583         c->state = HTTPSTATE_SEND_HEADER;
584         return 0;
585     }
586     
587     if (doing_asx || doing_ram) {
588         char *hostinfo = 0;
589         
590         for (p = c->buffer; *p && *p != '\r' && *p != '\n'; ) {
591             if (strncasecmp(p, "Host:", 5) == 0) {
592                 hostinfo = p + 5;
593                 break;
594             }
595             p = strchr(p, '\n');
596             if (!p)
597                 break;
598
599             p++;
600         }
601
602         if (hostinfo) {
603             char *eoh;
604             char hostbuf[260];
605
606             while (isspace(*hostinfo))
607                 hostinfo++;
608
609             eoh = strchr(hostinfo, '\n');
610             if (eoh) {
611                 if (eoh[-1] == '\r')
612                     eoh--;
613
614                 if (eoh - hostinfo < sizeof(hostbuf) - 1) {
615                     memcpy(hostbuf, hostinfo, eoh - hostinfo);
616                     hostbuf[eoh - hostinfo] = 0;
617
618                     c->http_error = 200;
619                     q = c->buffer;
620                     if (doing_asx) {
621                         q += sprintf(q, "HTTP/1.0 200 ASX Follows\r\n");
622                         q += sprintf(q, "Content-type: video/x-ms-asf\r\n");
623                         q += sprintf(q, "\r\n");
624                         q += sprintf(q, "<ASX Version=\"3\">\r\n");
625                         q += sprintf(q, "<!-- Autogenerated by ffserver -->\r\n");
626                         q += sprintf(q, "<ENTRY><REF HREF=\"http://%s/%s%s\"/></ENTRY>\r\n", 
627                                 hostbuf, filename, info);
628                         q += sprintf(q, "</ASX>\r\n");
629                     } else if (doing_ram) {
630                         q += sprintf(q, "HTTP/1.0 200 RAM Follows\r\n");
631                         q += sprintf(q, "Content-type: audio/x-pn-realaudio\r\n");
632                         q += sprintf(q, "\r\n");
633                         q += sprintf(q, "# Autogenerated by ffserver\r\n");
634                         q += sprintf(q, "http://%s/%s%s\r\n", 
635                                 hostbuf, filename, info);
636                     } else
637                         av_abort();
638
639                     /* prepare output buffer */
640                     c->buffer_ptr = c->buffer;
641                     c->buffer_end = q;
642                     c->state = HTTPSTATE_SEND_HEADER;
643                     return 0;
644                 }
645             }
646         }
647
648         sprintf(msg, "ASX/RAM file not handled");
649         goto send_error;
650     }
651
652     c->stream = stream;
653     stream->conns_served++;
654
655     /* XXX: add there authenticate and IP match */
656
657     if (post) {
658         /* if post, it means a feed is being sent */
659         if (!stream->is_feed) {
660             /* However it might be a status report from WMP! Lets log the data
661              * as it might come in handy one day
662              */
663             char *logline = 0;
664             
665             for (p = c->buffer; *p && *p != '\r' && *p != '\n'; ) {
666                 if (strncasecmp(p, "Pragma: log-line=", 17) == 0) {
667                     logline = p;
668                     break;
669                 }
670                 p = strchr(p, '\n');
671                 if (!p)
672                     break;
673
674                 p++;
675             }
676
677             if (logline) {
678                 char *eol = strchr(logline, '\n');
679
680                 logline += 17;
681
682                 if (eol) {
683                     if (eol[-1] == '\r')
684                         eol--;
685                     http_log("%.*s\n", eol - logline, logline);
686                     c->suppress_log = 1;
687                 }
688             }
689             
690             sprintf(msg, "POST command not handled");
691             goto send_error;
692         }
693         if (http_start_receive_data(c) < 0) {
694             sprintf(msg, "could not open feed");
695             goto send_error;
696         }
697         c->http_error = 0;
698         c->state = HTTPSTATE_RECEIVE_DATA;
699         return 0;
700     }
701
702     if (c->stream->stream_type == STREAM_TYPE_STATUS)
703         goto send_stats;
704
705     /* open input stream */
706     if (open_input_stream(c, info) < 0) {
707         sprintf(msg, "Input stream corresponding to '%s' not found", url);
708         goto send_error;
709     }
710
711     /* prepare http header */
712     q = c->buffer;
713     q += sprintf(q, "HTTP/1.0 200 OK\r\n");
714     mime_type = c->stream->fmt->mime_type;
715     if (!mime_type)
716         mime_type = "application/x-octet_stream";
717     q += sprintf(q, "Pragma: no-cache\r\n");
718
719     /* for asf, we need extra headers */
720     if (!strcmp(c->stream->fmt->name,"asf")) {
721         q += sprintf(q, "Server: Cougar 4.1.0.3923\r\nCache-Control: no-cache\r\nPragma: client-id=1234\r\nPragma: features=\"broadcast\"\r\n");
722         /* mime_type = "application/octet-stream"; */
723         /* video/x-ms-asf seems better -- netscape doesn't crash any more! */
724         mime_type = "video/x-ms-asf";
725     }
726     q += sprintf(q, "Content-Type: %s\r\n", mime_type);
727     q += sprintf(q, "\r\n");
728     
729     /* prepare output buffer */
730     c->http_error = 0;
731     c->buffer_ptr = c->buffer;
732     c->buffer_end = q;
733     c->state = HTTPSTATE_SEND_HEADER;
734     return 0;
735  send_error:
736     c->http_error = 404;
737     q = c->buffer;
738     q += sprintf(q, "HTTP/1.0 404 Not Found\r\n");
739     q += sprintf(q, "Content-type: %s\r\n", "text/html");
740     q += sprintf(q, "\r\n");
741     q += sprintf(q, "<HTML>\n");
742     q += sprintf(q, "<HEAD><TITLE>404 Not Found</TITLE></HEAD>\n");
743     q += sprintf(q, "<BODY>%s</BODY>\n", msg);
744     q += sprintf(q, "</HTML>\n");
745
746     /* prepare output buffer */
747     c->buffer_ptr = c->buffer;
748     c->buffer_end = q;
749     c->state = HTTPSTATE_SEND_HEADER;
750     return 0;
751  send_stats:
752     compute_stats(c);
753     c->http_error = 200; /* horrible : we use this value to avoid
754                             going to the send data state */
755     c->state = HTTPSTATE_SEND_HEADER;
756     return 0;
757 }
758
759 static void compute_stats(HTTPContext *c)
760 {
761     HTTPContext *c1;
762     FFStream *stream;
763     char *q, *p;
764     time_t ti;
765     int i;
766
767     q = c->buffer;
768     q += sprintf(q, "HTTP/1.0 200 OK\r\n");
769     q += sprintf(q, "Content-type: %s\r\n", "text/html");
770     q += sprintf(q, "Pragma: no-cache\r\n");
771     q += sprintf(q, "\r\n");
772     
773     q += sprintf(q, "<HEAD><TITLE>FFServer Status</TITLE></HEAD>\n<BODY>");
774     q += sprintf(q, "<H1>FFServer Status</H1>\n");
775     /* format status */
776     q += sprintf(q, "<H2>Available Streams</H2>\n");
777     q += sprintf(q, "<TABLE cellspacing=0 cellpadding=4>\n");
778     q += sprintf(q, "<TR><Th valign=top>Path<th align=left>Served<br>Conns<Th><br>kbytes<Th valign=top>Format<Th>Bit rate<br>kbits/s<Th align=left>Video<br>kbits/s<th><br>Codec<Th align=left>Audio<br>kbits/s<th><br>Codec<Th align=left valign=top>Feed\n");
779     stream = first_stream;
780     while (stream != NULL) {
781         char sfilename[1024];
782         char *eosf;
783
784         if (stream->feed != stream) {
785             pstrcpy(sfilename, sizeof(sfilename) - 1, stream->filename);
786             eosf = sfilename + strlen(sfilename);
787             if (eosf - sfilename >= 4) {
788                 if (strcmp(eosf - 4, ".asf") == 0) {
789                     strcpy(eosf - 4, ".asx");
790                 } else if (strcmp(eosf - 3, ".rm") == 0) {
791                     strcpy(eosf - 3, ".ram");
792                 }
793             }
794             
795             q += sprintf(q, "<TR><TD><A HREF=\"/%s\">%s</A> ", 
796                          sfilename, stream->filename);
797             q += sprintf(q, "<td align=right> %d <td align=right> %lld",
798                         stream->conns_served, stream->bytes_served / 1000);
799             switch(stream->stream_type) {
800             case STREAM_TYPE_LIVE:
801                 {
802                     int audio_bit_rate = 0;
803                     int video_bit_rate = 0;
804                     char *audio_codec_name = "";
805                     char *video_codec_name = "";
806                     char *audio_codec_name_extra = "";
807                     char *video_codec_name_extra = "";
808
809                     for(i=0;i<stream->nb_streams;i++) {
810                         AVStream *st = stream->streams[i];
811                         AVCodec *codec = avcodec_find_encoder(st->codec.codec_id);
812                         switch(st->codec.codec_type) {
813                         case CODEC_TYPE_AUDIO:
814                             audio_bit_rate += st->codec.bit_rate;
815                             if (codec) {
816                                 if (*audio_codec_name)
817                                     audio_codec_name_extra = "...";
818                                 audio_codec_name = codec->name;
819                             }
820                             break;
821                         case CODEC_TYPE_VIDEO:
822                             video_bit_rate += st->codec.bit_rate;
823                             if (codec) {
824                                 if (*video_codec_name)
825                                     video_codec_name_extra = "...";
826                                 video_codec_name = codec->name;
827                             }
828                             break;
829                         default:
830                             av_abort();
831                         }
832                     }
833                     q += sprintf(q, "<TD align=center> %s <TD align=right> %d <TD align=right> %d <TD> %s %s <TD align=right> %d <TD> %s %s", 
834                                  stream->fmt->name,
835                                  (audio_bit_rate + video_bit_rate) / 1000,
836                                  video_bit_rate / 1000, video_codec_name, video_codec_name_extra,
837                                  audio_bit_rate / 1000, audio_codec_name, audio_codec_name_extra);
838                     if (stream->feed) {
839                         q += sprintf(q, "<TD>%s", stream->feed->filename);
840                     } else {
841                         q += sprintf(q, "<TD>%s", stream->feed_filename);
842                     }
843                     q += sprintf(q, "\n");
844                 }
845                 break;
846             default:
847                 q += sprintf(q, "<TD align=center> - <TD align=right> - <TD align=right> - <td><td align=right> - <TD>\n");
848                 break;
849             }
850         }
851         stream = stream->next;
852     }
853     q += sprintf(q, "</TABLE>\n");
854
855     stream = first_stream;
856     while (stream != NULL) {
857         if (stream->feed == stream) {
858             q += sprintf(q, "<h2>Feed %s</h2>", stream->filename);
859             q += sprintf(q, "<table cellspacing=0 cellpadding=4><tr><th>Stream<th>type<th>kbits/s<th align=left>codec<th align=left>Parameters\n");
860
861             for (i = 0; i < stream->nb_streams; i++) {
862                 AVStream *st = stream->streams[i];
863                 AVCodec *codec = avcodec_find_encoder(st->codec.codec_id);
864                 char *type = "unknown";
865                 char parameters[64];
866
867                 parameters[0] = 0;
868
869                 switch(st->codec.codec_type) {
870                 case CODEC_TYPE_AUDIO:
871                     type = "audio";
872                     break;
873                 case CODEC_TYPE_VIDEO:
874                     type = "video";
875                     sprintf(parameters, "%dx%d, q=%d-%d", st->codec.width, st->codec.height,
876                                 st->codec.qmin, st->codec.qmax);
877                     break;
878                 default:
879                     av_abort();
880                 }
881                 q += sprintf(q, "<tr><td align=right>%d<td>%s<td align=right>%d<td>%s<td>%s\n",
882                         i, type, st->codec.bit_rate/1000, codec ? codec->name : "", parameters);
883             }
884             q += sprintf(q, "</table>\n");
885
886         }       
887         stream = stream->next;
888     }
889     
890 #if 0
891     {
892         float avg;
893         AVCodecContext *enc;
894         char buf[1024];
895         
896         /* feed status */
897         stream = first_feed;
898         while (stream != NULL) {
899             q += sprintf(q, "<H1>Feed '%s'</H1>\n", stream->filename);
900             q += sprintf(q, "<TABLE>\n");
901             q += sprintf(q, "<TR><TD>Parameters<TD>Frame count<TD>Size<TD>Avg bitrate (kbits/s)\n");
902             for(i=0;i<stream->nb_streams;i++) {
903                 AVStream *st = stream->streams[i];
904                 FeedData *fdata = st->priv_data;
905                 enc = &st->codec;
906             
907                 avcodec_string(buf, sizeof(buf), enc);
908                 avg = fdata->avg_frame_size * (float)enc->rate * 8.0;
909                 if (enc->codec->type == CODEC_TYPE_AUDIO && enc->frame_size > 0)
910                     avg /= enc->frame_size;
911                 q += sprintf(q, "<TR><TD>%s <TD> %d <TD> %Ld <TD> %0.1f\n", 
912                              buf, enc->frame_number, fdata->data_count, avg / 1000.0);
913             }
914             q += sprintf(q, "</TABLE>\n");
915             stream = stream->next_feed;
916         }
917     }
918 #endif
919
920     /* connection status */
921     q += sprintf(q, "<H2>Connection Status</H2>\n");
922
923     q += sprintf(q, "Number of connections: %d / %d<BR>\n",
924                  nb_connections, nb_max_connections);
925
926     q += sprintf(q, "Bandwidth in use: %dk / %dk<BR>\n",
927                  nb_bandwidth, nb_max_bandwidth);
928
929     q += sprintf(q, "<TABLE>\n");
930     q += sprintf(q, "<TR><TD>#<TD>File<TD>IP<TD>State<TD>Size\n");
931     c1 = first_http_ctx;
932     i = 0;
933     while (c1 != NULL && q < (char *) c->buffer + sizeof(c->buffer) - 2048) {
934         i++;
935         p = inet_ntoa(c1->from_addr.sin_addr);
936         q += sprintf(q, "<TR><TD><B>%d</B><TD>%s%s <TD> %s <TD> %s <TD> %Ld\n", 
937                      i, c1->stream->filename, 
938                      c1->state == HTTPSTATE_RECEIVE_DATA ? "(input)" : "",
939                      p, 
940                      http_state[c1->state],
941                      c1->data_count);
942         c1 = c1->next;
943     }
944     q += sprintf(q, "</TABLE>\n");
945     
946     /* date */
947     ti = time(NULL);
948     p = ctime(&ti);
949     q += sprintf(q, "<HR size=1 noshade>Generated at %s", p);
950     q += sprintf(q, "</BODY>\n</HTML>\n");
951
952     c->buffer_ptr = c->buffer;
953     c->buffer_end = q;
954 }
955
956
957 static void http_write_packet(void *opaque, 
958                               unsigned char *buf, int size)
959 {
960     HTTPContext *c = opaque;
961
962     if (c->buffer_ptr == c->buffer_end || !c->buffer_ptr)
963         c->buffer_ptr = c->buffer_end = c->buffer;
964
965     if (c->buffer_end - c->buffer + size > IOBUFFER_MAX_SIZE)
966         av_abort();
967
968     memcpy(c->buffer_end, buf, size);
969     c->buffer_end += size;
970 }
971
972 static int open_input_stream(HTTPContext *c, const char *info)
973 {
974     char buf[128];
975     char input_filename[1024];
976     AVFormatContext *s;
977     int buf_size;
978     INT64 stream_pos;
979
980     /* find file name */
981     if (c->stream->feed) {
982         strcpy(input_filename, c->stream->feed->feed_filename);
983         buf_size = FFM_PACKET_SIZE;
984         /* compute position (absolute time) */
985         if (find_info_tag(buf, sizeof(buf), "date", info)) {
986             stream_pos = parse_date(buf, 0);
987         } else if (find_info_tag(buf, sizeof(buf), "buffer", info)) {
988             int prebuffer = strtol(buf, 0, 10);
989             stream_pos = gettime() - prebuffer * 1000000;
990         } else {
991             stream_pos = gettime() - c->stream->prebuffer * 1000;
992         }
993     } else {
994         strcpy(input_filename, c->stream->feed_filename);
995         buf_size = 0;
996         /* compute position (relative time) */
997         if (find_info_tag(buf, sizeof(buf), "date", info)) {
998             stream_pos = parse_date(buf, 1);
999         } else {
1000             stream_pos = 0;
1001         }
1002     }
1003     if (input_filename[0] == '\0')
1004         return -1;
1005
1006     /* open stream */
1007     if (av_open_input_file(&s, input_filename, NULL, buf_size, NULL) < 0)
1008         return -1;
1009     c->fmt_in = s;
1010
1011     if (c->fmt_in->iformat->read_seek) {
1012         c->fmt_in->iformat->read_seek(c->fmt_in, stream_pos);
1013     }
1014     
1015     //    printf("stream %s opened pos=%0.6f\n", input_filename, stream_pos / 1000000.0);
1016     return 0;
1017 }
1018
1019 static int http_prepare_data(HTTPContext *c)
1020 {
1021     int i;
1022
1023     switch(c->state) {
1024     case HTTPSTATE_SEND_DATA_HEADER:
1025         memset(&c->fmt_ctx, 0, sizeof(c->fmt_ctx));
1026         if (c->stream->feed) {
1027             /* open output stream by using specified codecs */
1028             c->fmt_ctx.oformat = c->stream->fmt;
1029             c->fmt_ctx.nb_streams = c->stream->nb_streams;
1030             for(i=0;i<c->fmt_ctx.nb_streams;i++) {
1031                 AVStream *st;
1032                 st = av_mallocz(sizeof(AVStream));
1033                 c->fmt_ctx.streams[i] = st;
1034                 if (c->stream->feed == c->stream)
1035                     memcpy(st, c->stream->streams[i], sizeof(AVStream));
1036                 else
1037                     memcpy(st, c->stream->feed->streams[c->stream->feed_streams[i]], sizeof(AVStream));
1038
1039                 st->codec.frame_number = 0; /* XXX: should be done in
1040                                                AVStream, not in codec */
1041             }
1042             c->got_key_frame = 0;
1043         } else {
1044             /* open output stream by using codecs in specified file */
1045             c->fmt_ctx.oformat = c->stream->fmt;
1046             c->fmt_ctx.nb_streams = c->fmt_in->nb_streams;
1047             for(i=0;i<c->fmt_ctx.nb_streams;i++) {
1048                 AVStream *st;
1049                 st = av_mallocz(sizeof(AVStream));
1050                 c->fmt_ctx.streams[i] = st;
1051                 memcpy(st, c->fmt_in->streams[i], sizeof(AVStream));
1052                 st->codec.frame_number = 0; /* XXX: should be done in
1053                                                AVStream, not in codec */
1054             }
1055             c->got_key_frame = 0;
1056         }
1057         init_put_byte(&c->fmt_ctx.pb, c->pbuffer, PACKET_MAX_SIZE,
1058                       1, c, NULL, http_write_packet, NULL);
1059         c->fmt_ctx.pb.is_streamed = 1;
1060         /* prepare header */
1061         av_write_header(&c->fmt_ctx);
1062         c->state = HTTPSTATE_SEND_DATA;
1063         c->last_packet_sent = 0;
1064         break;
1065     case HTTPSTATE_SEND_DATA:
1066         /* find a new packet */
1067 #if 0
1068         fifo_total_size = http_fifo_write_count - c->last_http_fifo_write_count;
1069         if (fifo_total_size >= ((3 * FIFO_MAX_SIZE) / 4)) {
1070             /* overflow : resync. We suppose that wptr is at this
1071                point a pointer to a valid packet */
1072             c->rptr = http_fifo.wptr;
1073             c->got_key_frame = 0;
1074         }
1075         
1076         start_rptr = c->rptr;
1077         if (fifo_read(&http_fifo, (UINT8 *)&hdr, sizeof(hdr), &c->rptr) < 0)
1078             return 0;
1079         payload_size = ntohs(hdr.payload_size);
1080         payload = av_malloc(payload_size);
1081         if (fifo_read(&http_fifo, payload, payload_size, &c->rptr) < 0) {
1082             /* cannot read all the payload */
1083             av_free(payload);
1084             c->rptr = start_rptr;
1085             return 0;
1086         }
1087         
1088         c->last_http_fifo_write_count = http_fifo_write_count - 
1089             fifo_size(&http_fifo, c->rptr);
1090         
1091         if (c->stream->stream_type != STREAM_TYPE_MASTER) {
1092             /* test if the packet can be handled by this format */
1093             ret = 0;
1094             for(i=0;i<c->fmt_ctx.nb_streams;i++) {
1095                 AVStream *st = c->fmt_ctx.streams[i];
1096                 if (test_header(&hdr, &st->codec)) {
1097                     /* only begin sending when got a key frame */
1098                     if (st->codec.key_frame)
1099                         c->got_key_frame |= 1 << i;
1100                     if (c->got_key_frame & (1 << i)) {
1101                         ret = c->fmt_ctx.format->write_packet(&c->fmt_ctx, i,
1102                                                                    payload, payload_size);
1103                     }
1104                     break;
1105                 }
1106             }
1107             if (ret) {
1108                 /* must send trailer now */
1109                 c->state = HTTPSTATE_SEND_DATA_TRAILER;
1110             }
1111         } else {
1112             /* master case : send everything */
1113             char *q;
1114             q = c->buffer;
1115             memcpy(q, &hdr, sizeof(hdr));
1116             q += sizeof(hdr);
1117             memcpy(q, payload, payload_size);
1118             q += payload_size;
1119             c->buffer_ptr = c->buffer;
1120             c->buffer_end = q;
1121         }
1122         av_free(payload);
1123 #endif
1124         {
1125             AVPacket pkt;
1126
1127             /* read a packet from the input stream */
1128             if (c->stream->feed) {
1129                 ffm_set_write_index(c->fmt_in, 
1130                                     c->stream->feed->feed_write_index,
1131                                     c->stream->feed->feed_size);
1132             }
1133
1134             if (c->stream->max_time && 
1135                 c->stream->max_time + c->start_time > time(0)) {
1136                 /* We have timed out */
1137                 c->state = HTTPSTATE_SEND_DATA_TRAILER;
1138             } else if (av_read_packet(c->fmt_in, &pkt) < 0) {
1139                 if (c->stream->feed && c->stream->feed->feed_opened) {
1140                     /* if coming from feed, it means we reached the end of the
1141                        ffm file, so must wait for more data */
1142                     c->state = HTTPSTATE_WAIT_FEED;
1143                     return 1; /* state changed */
1144                 } else {
1145                     /* must send trailer now because eof or error */
1146                     c->state = HTTPSTATE_SEND_DATA_TRAILER;
1147                 }
1148             } else {
1149                 /* send it to the appropriate stream */
1150                 if (c->stream->feed) {
1151                     /* if coming from a feed, select the right stream */
1152                     for(i=0;i<c->stream->nb_streams;i++) {
1153                         if (c->stream->feed_streams[i] == pkt.stream_index) {
1154                             pkt.stream_index = i;
1155                             if (pkt.flags & PKT_FLAG_KEY) {
1156                                 c->got_key_frame |= 1 << i;
1157                             }
1158                             /* See if we have all the key frames, then 
1159                              * we start to send. This logic is not quite
1160                              * right, but it works for the case of a 
1161                              * single video stream with one or more
1162                              * audio streams (for which every frame is 
1163                              * typically a key frame). 
1164                              */
1165                             if (!c->stream->send_on_key || ((c->got_key_frame + 1) >> c->stream->nb_streams)) {
1166                                 goto send_it;
1167                             }
1168                         }
1169                     }
1170                 } else {
1171                     AVCodecContext *codec;
1172                 send_it:
1173                     /* Fudge here */
1174                     codec = &c->fmt_ctx.streams[pkt.stream_index]->codec;
1175
1176                     codec->key_frame = ((pkt.flags & PKT_FLAG_KEY) != 0);
1177
1178 #ifdef PJSG
1179                     if (codec->codec_type == CODEC_TYPE_AUDIO) {
1180                         codec->frame_size = (codec->sample_rate * pkt.duration + 500000) / 1000000;
1181                         /* printf("Calculated size %d, from sr %d, duration %d\n", codec->frame_size, codec->sample_rate, pkt.duration); */
1182                     }
1183 #endif
1184
1185                     if (av_write_packet(&c->fmt_ctx, &pkt, 0))
1186                         c->state = HTTPSTATE_SEND_DATA_TRAILER;
1187
1188                     codec->frame_number++;
1189                 }
1190
1191                 av_free_packet(&pkt);
1192             }
1193         }
1194         break;
1195     default:
1196     case HTTPSTATE_SEND_DATA_TRAILER:
1197         /* last packet test ? */
1198         if (c->last_packet_sent)
1199             return -1;
1200         /* prepare header */
1201         av_write_trailer(&c->fmt_ctx);
1202         c->last_packet_sent = 1;
1203         break;
1204     }
1205     return 0;
1206 }
1207
1208 /* should convert the format at the same time */
1209 static int http_send_data(HTTPContext *c)
1210 {
1211     int len, ret;
1212
1213     while (c->buffer_ptr >= c->buffer_end) {
1214         ret = http_prepare_data(c);
1215         if (ret < 0)
1216             return -1;
1217         else if (ret == 0) {
1218             continue;
1219         } else {
1220             /* state change requested */
1221             return 0;
1222         }
1223     }
1224
1225     if (c->buffer_end > c->buffer_ptr) {
1226         len = write(c->fd, c->buffer_ptr, c->buffer_end - c->buffer_ptr);
1227         if (len < 0) {
1228             if (errno != EAGAIN && errno != EINTR) {
1229                 /* error : close connection */
1230                 return -1;
1231             }
1232         } else {
1233             c->buffer_ptr += len;
1234             c->data_count += len;
1235             if (c->stream)
1236                 c->stream->bytes_served += len;
1237         }
1238     }
1239     return 0;
1240 }
1241
1242 static int http_start_receive_data(HTTPContext *c)
1243 {
1244     int fd;
1245
1246     if (c->stream->feed_opened)
1247         return -1;
1248
1249     /* open feed */
1250     fd = open(c->stream->feed_filename, O_RDWR);
1251     if (fd < 0)
1252         return -1;
1253     c->feed_fd = fd;
1254     
1255     c->stream->feed_write_index = ffm_read_write_index(fd);
1256     c->stream->feed_size = lseek(fd, 0, SEEK_END);
1257     lseek(fd, 0, SEEK_SET);
1258
1259     /* init buffer input */
1260     c->buffer_ptr = c->buffer;
1261     c->buffer_end = c->buffer + FFM_PACKET_SIZE;
1262     c->stream->feed_opened = 1;
1263     return 0;
1264 }
1265     
1266 static int http_receive_data(HTTPContext *c)
1267 {
1268     HTTPContext *c1;
1269
1270     if (c->buffer_end > c->buffer_ptr) {
1271         int len;
1272
1273         len = read(c->fd, c->buffer_ptr, c->buffer_end - c->buffer_ptr);
1274         if (len < 0) {
1275             if (errno != EAGAIN && errno != EINTR) {
1276                 /* error : close connection */
1277                 goto fail;
1278             }
1279         } else if (len == 0) {
1280             /* end of connection : close it */
1281             goto fail;
1282         } else {
1283             c->buffer_ptr += len;
1284             c->data_count += len;
1285         }
1286     }
1287
1288     if (c->buffer_ptr >= c->buffer_end) {
1289         FFStream *feed = c->stream;
1290         /* a packet has been received : write it in the store, except
1291            if header */
1292         if (c->data_count > FFM_PACKET_SIZE) {
1293             
1294             //            printf("writing pos=0x%Lx size=0x%Lx\n", feed->feed_write_index, feed->feed_size);
1295             /* XXX: use llseek or url_seek */
1296             lseek(c->feed_fd, feed->feed_write_index, SEEK_SET);
1297             write(c->feed_fd, c->buffer, FFM_PACKET_SIZE);
1298             
1299             feed->feed_write_index += FFM_PACKET_SIZE;
1300             /* update file size */
1301             if (feed->feed_write_index > c->stream->feed_size)
1302                 feed->feed_size = feed->feed_write_index;
1303
1304             /* handle wrap around if max file size reached */
1305             if (feed->feed_write_index >= c->stream->feed_max_size)
1306                 feed->feed_write_index = FFM_PACKET_SIZE;
1307
1308             /* write index */
1309             ffm_write_write_index(c->feed_fd, feed->feed_write_index);
1310
1311             /* wake up any waiting connections */
1312             for(c1 = first_http_ctx; c1 != NULL; c1 = c1->next) {
1313                 if (c1->state == HTTPSTATE_WAIT_FEED && 
1314                     c1->stream->feed == c->stream->feed) {
1315                     c1->state = HTTPSTATE_SEND_DATA;
1316                 }
1317             }
1318         } else {
1319             /* We have a header in our hands that contains useful data */
1320             AVFormatContext s;
1321             AVInputFormat *fmt_in;
1322             ByteIOContext *pb = &s.pb;
1323             int i;
1324
1325             memset(&s, 0, sizeof(s));
1326
1327             url_open_buf(pb, c->buffer, c->buffer_end - c->buffer, URL_RDONLY);
1328             pb->buf_end = c->buffer_end;        /* ?? */
1329             pb->is_streamed = 1;
1330
1331             /* use feed output format name to find corresponding input format */
1332             fmt_in = av_find_input_format(feed->fmt->name);
1333             if (!fmt_in)
1334                 goto fail;
1335
1336             s.priv_data = av_mallocz(fmt_in->priv_data_size);
1337             if (!s.priv_data)
1338                 goto fail;
1339
1340             if (fmt_in->read_header(&s, 0) < 0) {
1341                 av_freep(&s.priv_data);
1342                 goto fail;
1343             }
1344
1345             /* Now we have the actual streams */
1346             if (s.nb_streams != feed->nb_streams) {
1347                 av_freep(&s.priv_data);
1348                 goto fail;
1349             }
1350             for (i = 0; i < s.nb_streams; i++) {
1351                 memcpy(&feed->streams[i]->codec, 
1352                        &s.streams[i]->codec, sizeof(AVCodecContext));
1353             } 
1354             av_freep(&s.priv_data);
1355         }
1356         c->buffer_ptr = c->buffer;
1357     }
1358
1359     return 0;
1360  fail:
1361     c->stream->feed_opened = 0;
1362     close(c->feed_fd);
1363     return -1;
1364 }
1365
1366 /* return the stream number in the feed */
1367 int add_av_stream(FFStream *feed,
1368                   AVStream *st)
1369 {
1370     AVStream *fst;
1371     AVCodecContext *av, *av1;
1372     int i;
1373
1374     av = &st->codec;
1375     for(i=0;i<feed->nb_streams;i++) {
1376         st = feed->streams[i];
1377         av1 = &st->codec;
1378         if (av1->codec_id == av->codec_id &&
1379             av1->codec_type == av->codec_type &&
1380             av1->bit_rate == av->bit_rate) {
1381
1382             switch(av->codec_type) {
1383             case CODEC_TYPE_AUDIO:
1384                 if (av1->channels == av->channels &&
1385                     av1->sample_rate == av->sample_rate)
1386                     goto found;
1387                 break;
1388             case CODEC_TYPE_VIDEO:
1389                 if (av1->width == av->width &&
1390                     av1->height == av->height &&
1391                     av1->frame_rate == av->frame_rate &&
1392                     av1->gop_size == av->gop_size)
1393                     goto found;
1394                 break;
1395             default:
1396                 av_abort();
1397             }
1398         }
1399     }
1400     
1401     fst = av_mallocz(sizeof(AVStream));
1402     if (!fst)
1403         return -1;
1404     fst->priv_data = av_mallocz(sizeof(FeedData));
1405     memcpy(&fst->codec, av, sizeof(AVCodecContext));
1406     feed->streams[feed->nb_streams++] = fst;
1407     return feed->nb_streams - 1;
1408  found:
1409     return i;
1410 }
1411
1412 /* compute the needed AVStream for each feed */
1413 void build_feed_streams(void)
1414 {
1415     FFStream *stream, *feed;
1416     int i;
1417
1418     /* gather all streams */
1419     for(stream = first_stream; stream != NULL; stream = stream->next) {
1420         feed = stream->feed;
1421         if (feed) {
1422             if (!stream->is_feed) {
1423                 for(i=0;i<stream->nb_streams;i++) {
1424                     stream->feed_streams[i] = add_av_stream(feed, stream->streams[i]);
1425                 }
1426             } else {
1427                 for(i=0;i<stream->nb_streams;i++) {
1428                     stream->feed_streams[i] = i;
1429                 }
1430             }
1431         }
1432     }
1433
1434     /* create feed files if needed */
1435     for(feed = first_feed; feed != NULL; feed = feed->next_feed) {
1436         int fd;
1437
1438         if (!url_exist(feed->feed_filename)) {
1439             AVFormatContext s1, *s = &s1;
1440
1441             /* only write the header of the ffm file */
1442             if (url_fopen(&s->pb, feed->feed_filename, URL_WRONLY) < 0) {
1443                 fprintf(stderr, "Could not open output feed file '%s'\n",
1444                         feed->feed_filename);
1445                 exit(1);
1446             }
1447             s->oformat = feed->fmt;
1448             s->nb_streams = feed->nb_streams;
1449             for(i=0;i<s->nb_streams;i++) {
1450                 AVStream *st;
1451                 st = feed->streams[i];
1452                 s->streams[i] = st;
1453             }
1454             av_write_header(s);
1455             /* XXX: need better api */
1456             av_freep(&s->priv_data);
1457             url_fclose(&s->pb);
1458         }
1459         /* get feed size and write index */
1460         fd = open(feed->feed_filename, O_RDONLY);
1461         if (fd < 0) {
1462             fprintf(stderr, "Could not open output feed file '%s'\n",
1463                     feed->feed_filename);
1464             exit(1);
1465         }
1466
1467         feed->feed_write_index = ffm_read_write_index(fd);
1468         feed->feed_size = lseek(fd, 0, SEEK_END);
1469         /* ensure that we do not wrap before the end of file */
1470         if (feed->feed_max_size < feed->feed_size)
1471             feed->feed_max_size = feed->feed_size;
1472
1473         close(fd);
1474     }
1475 }
1476
1477 static void get_arg(char *buf, int buf_size, const char **pp)
1478 {
1479     const char *p;
1480     char *q;
1481     int quote;
1482
1483     p = *pp;
1484     while (isspace(*p)) p++;
1485     q = buf;
1486     quote = 0;
1487     if (*p == '\"' || *p == '\'')
1488         quote = *p++;
1489     for(;;) {
1490         if (quote) {
1491             if (*p == quote)
1492                 break;
1493         } else {
1494             if (isspace(*p))
1495                 break;
1496         }
1497         if (*p == '\0')
1498             break;
1499         if ((q - buf) < buf_size - 1)
1500             *q++ = *p;
1501         p++;
1502     }
1503     *q = '\0';
1504     if (quote && *p == quote)
1505         p++;
1506     *pp = p;
1507 }
1508
1509 /* add a codec and set the default parameters */
1510 void add_codec(FFStream *stream, AVCodecContext *av)
1511 {
1512     AVStream *st;
1513
1514     /* compute default parameters */
1515     switch(av->codec_type) {
1516     case CODEC_TYPE_AUDIO:
1517         if (av->bit_rate == 0)
1518             av->bit_rate = 64000;
1519         if (av->sample_rate == 0)
1520             av->sample_rate = 22050;
1521         if (av->channels == 0)
1522             av->channels = 1;
1523         break;
1524     case CODEC_TYPE_VIDEO:
1525         if (av->bit_rate == 0)
1526             av->bit_rate = 64000;
1527         if (av->frame_rate == 0)
1528             av->frame_rate = 5 * FRAME_RATE_BASE;
1529         if (av->width == 0 || av->height == 0) {
1530             av->width = 160;
1531             av->height = 128;
1532         }
1533         /* Bitrate tolerance is less for streaming */
1534         if (av->bit_rate_tolerance == 0)
1535             av->bit_rate_tolerance = av->bit_rate / 4;
1536         if (av->qmin == 0)
1537             av->qmin = 3;
1538         if (av->qmax == 0)
1539             av->qmax = 31;
1540         if (av->max_qdiff == 0)
1541             av->max_qdiff = 3;
1542         av->qcompress = 0.5;
1543         av->qblur = 0.5;
1544
1545         break;
1546     default:
1547         av_abort();
1548     }
1549
1550     st = av_mallocz(sizeof(AVStream));
1551     if (!st)
1552         return;
1553     stream->streams[stream->nb_streams++] = st;
1554     memcpy(&st->codec, av, sizeof(AVCodecContext));
1555 }
1556
1557 int opt_audio_codec(const char *arg)
1558 {
1559     AVCodec *p;
1560
1561     p = first_avcodec;
1562     while (p) {
1563         if (!strcmp(p->name, arg) && p->type == CODEC_TYPE_AUDIO)
1564             break;
1565         p = p->next;
1566     }
1567     if (p == NULL) {
1568         return CODEC_ID_NONE;
1569     }
1570
1571     return p->id;
1572 }
1573
1574 int opt_video_codec(const char *arg)
1575 {
1576     AVCodec *p;
1577
1578     p = first_avcodec;
1579     while (p) {
1580         if (!strcmp(p->name, arg) && p->type == CODEC_TYPE_VIDEO)
1581             break;
1582         p = p->next;
1583     }
1584     if (p == NULL) {
1585         return CODEC_ID_NONE;
1586     }
1587
1588     return p->id;
1589 }
1590
1591 int parse_ffconfig(const char *filename)
1592 {
1593     FILE *f;
1594     char line[1024];
1595     char cmd[64];
1596     char arg[1024];
1597     const char *p;
1598     int val, errors, line_num;
1599     FFStream **last_stream, *stream;
1600     FFStream **last_feed, *feed;
1601     AVCodecContext audio_enc, video_enc;
1602     int audio_id, video_id;
1603
1604     f = fopen(filename, "r");
1605     if (!f) {
1606         perror(filename);
1607         return -1;
1608     }
1609     
1610     errors = 0;
1611     line_num = 0;
1612     first_stream = NULL;
1613     last_stream = &first_stream;
1614     first_feed = NULL;
1615     last_feed = &first_feed;
1616     stream = NULL;
1617     feed = NULL;
1618     audio_id = CODEC_ID_NONE;
1619     video_id = CODEC_ID_NONE;
1620     for(;;) {
1621         if (fgets(line, sizeof(line), f) == NULL)
1622             break;
1623         line_num++;
1624         p = line;
1625         while (isspace(*p)) 
1626             p++;
1627         if (*p == '\0' || *p == '#')
1628             continue;
1629
1630         get_arg(cmd, sizeof(cmd), &p);
1631         
1632         if (!strcasecmp(cmd, "Port")) {
1633             get_arg(arg, sizeof(arg), &p);
1634             my_addr.sin_port = htons (atoi(arg));
1635         } else if (!strcasecmp(cmd, "BindAddress")) {
1636             get_arg(arg, sizeof(arg), &p);
1637             if (!inet_aton(arg, &my_addr.sin_addr)) {
1638                 fprintf(stderr, "%s:%d: Invalid IP address: %s\n", 
1639                         filename, line_num, arg);
1640                 errors++;
1641             }
1642         } else if (!strcasecmp(cmd, "MaxClients")) {
1643             get_arg(arg, sizeof(arg), &p);
1644             val = atoi(arg);
1645             if (val < 1 || val > HTTP_MAX_CONNECTIONS) {
1646                 fprintf(stderr, "%s:%d: Invalid MaxClients: %s\n", 
1647                         filename, line_num, arg);
1648                 errors++;
1649             } else {
1650                 nb_max_connections = val;
1651             }
1652         } else if (!strcasecmp(cmd, "MaxBandwidth")) {
1653             get_arg(arg, sizeof(arg), &p);
1654             val = atoi(arg);
1655             if (val < 10 || val > 100000) {
1656                 fprintf(stderr, "%s:%d: Invalid MaxBandwidth: %s\n", 
1657                         filename, line_num, arg);
1658                 errors++;
1659             } else {
1660                 nb_max_bandwidth = val;
1661             }
1662         } else if (!strcasecmp(cmd, "CustomLog")) {
1663             get_arg(logfilename, sizeof(logfilename), &p);
1664         } else if (!strcasecmp(cmd, "<Feed")) {
1665             /*********************************************/
1666             /* Feed related options */
1667             char *q;
1668             if (stream || feed) {
1669                 fprintf(stderr, "%s:%d: Already in a tag\n",
1670                         filename, line_num);
1671             } else {
1672                 feed = av_mallocz(sizeof(FFStream));
1673                 /* add in stream list */
1674                 *last_stream = feed;
1675                 last_stream = &feed->next;
1676                 /* add in feed list */
1677                 *last_feed = feed;
1678                 last_feed = &feed->next_feed;
1679                 
1680                 get_arg(feed->filename, sizeof(feed->filename), &p);
1681                 q = strrchr(feed->filename, '>');
1682                 if (*q)
1683                     *q = '\0';
1684                 feed->fmt = guess_format("ffm", NULL, NULL);
1685                 /* defaut feed file */
1686                 snprintf(feed->feed_filename, sizeof(feed->feed_filename),
1687                          "/tmp/%s.ffm", feed->filename);
1688                 feed->feed_max_size = 5 * 1024 * 1024;
1689                 feed->is_feed = 1;
1690                 feed->feed = feed; /* self feeding :-) */
1691             }
1692         } else if (!strcasecmp(cmd, "File")) {
1693             if (feed) {
1694                 get_arg(feed->feed_filename, sizeof(feed->feed_filename), &p);
1695             } else if (stream) {
1696                 get_arg(stream->feed_filename, sizeof(stream->feed_filename), &p);
1697             }
1698         } else if (!strcasecmp(cmd, "FileMaxSize")) {
1699             if (feed) {
1700                 const char *p1;
1701                 double fsize;
1702
1703                 get_arg(arg, sizeof(arg), &p);
1704                 p1 = arg;
1705                 fsize = strtod(p1, (char **)&p1);
1706                 switch(toupper(*p1)) {
1707                 case 'K':
1708                     fsize *= 1024;
1709                     break;
1710                 case 'M':
1711                     fsize *= 1024 * 1024;
1712                     break;
1713                 case 'G':
1714                     fsize *= 1024 * 1024 * 1024;
1715                     break;
1716                 }
1717                 feed->feed_max_size = (INT64)fsize;
1718             }
1719         } else if (!strcasecmp(cmd, "</Feed>")) {
1720             if (!feed) {
1721                 fprintf(stderr, "%s:%d: No corresponding <Feed> for </Feed>\n",
1722                         filename, line_num);
1723                 errors++;
1724             } else {
1725                 /* Make sure that we start out clean */
1726                 if (unlink(feed->feed_filename) < 0 
1727                     && errno != ENOENT) {
1728                     fprintf(stderr, "%s:%d: Unable to clean old feed file '%s': %s\n",
1729                         filename, line_num, feed->feed_filename, strerror(errno));
1730                     errors++;
1731                 }
1732             }
1733             feed = NULL;
1734         } else if (!strcasecmp(cmd, "<Stream")) {
1735             /*********************************************/
1736             /* Stream related options */
1737             char *q;
1738             if (stream || feed) {
1739                 fprintf(stderr, "%s:%d: Already in a tag\n",
1740                         filename, line_num);
1741             } else {
1742                 stream = av_mallocz(sizeof(FFStream));
1743                 *last_stream = stream;
1744                 last_stream = &stream->next;
1745
1746                 get_arg(stream->filename, sizeof(stream->filename), &p);
1747                 q = strrchr(stream->filename, '>');
1748                 if (*q)
1749                     *q = '\0';
1750                 stream->fmt = guess_format(NULL, stream->filename, NULL);
1751                 memset(&audio_enc, 0, sizeof(AVCodecContext));
1752                 memset(&video_enc, 0, sizeof(AVCodecContext));
1753                 audio_id = CODEC_ID_NONE;
1754                 video_id = CODEC_ID_NONE;
1755                 if (stream->fmt) {
1756                     audio_id = stream->fmt->audio_codec;
1757                     video_id = stream->fmt->video_codec;
1758                 }
1759             }
1760         } else if (!strcasecmp(cmd, "Feed")) {
1761             get_arg(arg, sizeof(arg), &p);
1762             if (stream) {
1763                 FFStream *sfeed;
1764                 
1765                 sfeed = first_feed;
1766                 while (sfeed != NULL) {
1767                     if (!strcmp(sfeed->filename, arg))
1768                         break;
1769                     sfeed = sfeed->next_feed;
1770                 }
1771                 if (!sfeed) {
1772                     fprintf(stderr, "%s:%d: feed '%s' not defined\n",
1773                             filename, line_num, arg);
1774                 } else {
1775                     stream->feed = sfeed;
1776                 }
1777             }
1778         } else if (!strcasecmp(cmd, "Format")) {
1779             get_arg(arg, sizeof(arg), &p);
1780             if (!strcmp(arg, "status")) {
1781                 stream->stream_type = STREAM_TYPE_STATUS;
1782                 stream->fmt = NULL;
1783             } else {
1784                 stream->stream_type = STREAM_TYPE_LIVE;
1785                 /* jpeg cannot be used here, so use single frame jpeg */
1786                 if (!strcmp(arg, "jpeg"))
1787                     strcpy(arg, "singlejpeg");
1788                 stream->fmt = guess_format(arg, NULL, NULL);
1789                 if (!stream->fmt) {
1790                     fprintf(stderr, "%s:%d: Unknown Format: %s\n", 
1791                             filename, line_num, arg);
1792                     errors++;
1793                 }
1794             }
1795             if (stream->fmt) {
1796                 audio_id = stream->fmt->audio_codec;
1797                 video_id = stream->fmt->video_codec;
1798             }
1799         } else if (!strcasecmp(cmd, "Preroll")) {
1800             get_arg(arg, sizeof(arg), &p);
1801             if (stream) {
1802                 stream->prebuffer = atoi(arg) * 1000;
1803             }
1804         } else if (!strcasecmp(cmd, "StartSendOnKey")) {
1805             if (stream) {
1806                 stream->send_on_key = 1;
1807             }
1808         } else if (!strcasecmp(cmd, "AudioCodec")) {
1809             get_arg(arg, sizeof(arg), &p);
1810             audio_id = opt_audio_codec(arg);
1811             if (audio_id == CODEC_ID_NONE) {
1812                 fprintf(stderr, "%s:%d: Unknown AudioCodec: %s\n", 
1813                         filename, line_num, arg);
1814                 errors++;
1815             }
1816         } else if (!strcasecmp(cmd, "VideoCodec")) {
1817             get_arg(arg, sizeof(arg), &p);
1818             video_id = opt_video_codec(arg);
1819             if (video_id == CODEC_ID_NONE) {
1820                 fprintf(stderr, "%s:%d: Unknown VideoCodec: %s\n", 
1821                         filename, line_num, arg);
1822                 errors++;
1823             }
1824         } else if (!strcasecmp(cmd, "MaxTime")) {
1825             get_arg(arg, sizeof(arg), &p);
1826             if (stream) {
1827                 stream->max_time = atoi(arg);
1828             }
1829         } else if (!strcasecmp(cmd, "AudioBitRate")) {
1830             get_arg(arg, sizeof(arg), &p);
1831             if (stream) {
1832                 audio_enc.bit_rate = atoi(arg) * 1000;
1833             }
1834         } else if (!strcasecmp(cmd, "AudioChannels")) {
1835             get_arg(arg, sizeof(arg), &p);
1836             if (stream) {
1837                 audio_enc.channels = atoi(arg);
1838             }
1839         } else if (!strcasecmp(cmd, "AudioSampleRate")) {
1840             get_arg(arg, sizeof(arg), &p);
1841             if (stream) {
1842                 audio_enc.sample_rate = atoi(arg);
1843             }
1844         } else if (!strcasecmp(cmd, "VideoBitRate")) {
1845             get_arg(arg, sizeof(arg), &p);
1846             if (stream) {
1847                 video_enc.bit_rate = atoi(arg) * 1000;
1848             }
1849         } else if (!strcasecmp(cmd, "VideoSize")) {
1850             get_arg(arg, sizeof(arg), &p);
1851             if (stream) {
1852                 parse_image_size(&video_enc.width, &video_enc.height, arg);
1853                 if ((video_enc.width % 16) != 0 ||
1854                     (video_enc.height % 16) != 0) {
1855                     fprintf(stderr, "%s:%d: Image size must be a multiple of 16\n",
1856                             filename, line_num);
1857                     errors++;
1858                 }
1859             }
1860         } else if (!strcasecmp(cmd, "VideoFrameRate")) {
1861             get_arg(arg, sizeof(arg), &p);
1862             if (stream) {
1863                 video_enc.frame_rate = (int)(strtod(arg, NULL) * FRAME_RATE_BASE);
1864             }
1865         } else if (!strcasecmp(cmd, "VideoGopSize")) {
1866             get_arg(arg, sizeof(arg), &p);
1867             if (stream) {
1868                 video_enc.gop_size = atoi(arg);
1869             }
1870         } else if (!strcasecmp(cmd, "VideoIntraOnly")) {
1871             if (stream) {
1872                 video_enc.gop_size = 1;
1873             }
1874         } else if (!strcasecmp(cmd, "VideoHighQuality")) {
1875             if (stream) {
1876                 video_enc.flags |= CODEC_FLAG_HQ;
1877             }
1878         } else if (!strcasecmp(cmd, "VideoQDiff")) {
1879             if (stream) {
1880                 video_enc.max_qdiff = atoi(arg);
1881                 if (video_enc.max_qdiff < 1 || video_enc.max_qdiff > 31) {
1882                     fprintf(stderr, "%s:%d: VideoQDiff out of range\n",
1883                             filename, line_num);
1884                     errors++;
1885                 }
1886             }
1887         } else if (!strcasecmp(cmd, "VideoQMax")) {
1888             if (stream) {
1889                 video_enc.qmax = atoi(arg);
1890                 if (video_enc.qmax < 1 || video_enc.qmax > 31) {
1891                     fprintf(stderr, "%s:%d: VideoQMax out of range\n",
1892                             filename, line_num);
1893                     errors++;
1894                 }
1895             }
1896         } else if (!strcasecmp(cmd, "VideoQMin")) {
1897             if (stream) {
1898                 video_enc.qmin = atoi(arg);
1899                 if (video_enc.qmin < 1 || video_enc.qmin > 31) {
1900                     fprintf(stderr, "%s:%d: VideoQMin out of range\n",
1901                             filename, line_num);
1902                     errors++;
1903                 }
1904             }
1905         } else if (!strcasecmp(cmd, "NoVideo")) {
1906             video_id = CODEC_ID_NONE;
1907         } else if (!strcasecmp(cmd, "NoAudio")) {
1908             audio_id = CODEC_ID_NONE;
1909         } else if (!strcasecmp(cmd, "</Stream>")) {
1910             if (!stream) {
1911                 fprintf(stderr, "%s:%d: No corresponding <Stream> for </Stream>\n",
1912                         filename, line_num);
1913                 errors++;
1914             }
1915             if (stream->feed && stream->fmt && strcmp(stream->fmt->name, "ffm") != 0) {
1916                 if (audio_id != CODEC_ID_NONE) {
1917                     audio_enc.codec_type = CODEC_TYPE_AUDIO;
1918                     audio_enc.codec_id = audio_id;
1919                     add_codec(stream, &audio_enc);
1920                 }
1921                 if (video_id != CODEC_ID_NONE) {
1922                     video_enc.codec_type = CODEC_TYPE_VIDEO;
1923                     video_enc.codec_id = video_id;
1924                     add_codec(stream, &video_enc);
1925                 }
1926             }
1927             stream = NULL;
1928         } else {
1929             fprintf(stderr, "%s:%d: Incorrect keyword: '%s'\n", 
1930                     filename, line_num, cmd);
1931             errors++;
1932         }
1933     }
1934
1935     fclose(f);
1936     if (errors)
1937         return -1;
1938     else
1939         return 0;
1940 }
1941
1942
1943 void *http_server_thread(void *arg)
1944 {
1945     http_server(my_addr);
1946     return NULL;
1947 }
1948
1949 #if 0
1950 static void write_packet(FFCodec *ffenc,
1951                          UINT8 *buf, int size)
1952 {
1953     PacketHeader hdr;
1954     AVCodecContext *enc = &ffenc->enc;
1955     UINT8 *wptr;
1956     mk_header(&hdr, enc, size);
1957     wptr = http_fifo.wptr;
1958     fifo_write(&http_fifo, (UINT8 *)&hdr, sizeof(hdr), &wptr);
1959     fifo_write(&http_fifo, buf, size, &wptr);
1960     /* atomic modification of wptr */
1961     http_fifo.wptr = wptr;
1962     ffenc->data_count += size;
1963     ffenc->avg_frame_size = ffenc->avg_frame_size * AVG_COEF + size * (1.0 - AVG_COEF);
1964 }
1965 #endif
1966
1967 void help(void)
1968 {
1969     printf("ffserver version " FFMPEG_VERSION ", Copyright (c) 2000, 2001, 2002 Fabrice Bellard\n"
1970            "usage: ffserver [-L] [-h] [-f configfile]\n"
1971            "Hyper fast multi format Audio/Video streaming server\n"
1972            "\n"
1973            "-L            : print the LICENCE\n"
1974            "-h            : this help\n"
1975            "-f configfile : use configfile instead of /etc/ffserver.conf\n"
1976            );
1977 }
1978
1979 void licence(void)
1980 {
1981     printf(
1982     "ffserver version " FFMPEG_VERSION "\n"
1983     "Copyright (c) 2000, 2001, 2002 Fabrice Bellard\n"
1984     "This library is free software; you can redistribute it and/or\n"
1985     "modify it under the terms of the GNU Lesser General Public\n"
1986     "License as published by the Free Software Foundation; either\n"
1987     "version 2 of the License, or (at your option) any later version.\n"
1988     "\n"
1989     "This library is distributed in the hope that it will be useful,\n"
1990     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
1991     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n"
1992     "Lesser General Public License for more details.\n"
1993     "\n"
1994     "You should have received a copy of the GNU Lesser General Public\n"
1995     "License along with this library; if not, write to the Free Software\n"
1996     "Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA\n"
1997     );
1998 }
1999
2000 int main(int argc, char **argv)
2001 {
2002     const char *config_filename;
2003     int c;
2004
2005     register_all();
2006
2007     config_filename = "/etc/ffserver.conf";
2008
2009     for(;;) {
2010         c = getopt_long_only(argc, argv, "Lh?f:", NULL, NULL);
2011         if (c == -1)
2012             break;
2013         switch(c) {
2014         case 'L':
2015             licence();
2016             exit(1);
2017         case '?':
2018         case 'h':
2019             help();
2020             exit(1);
2021         case 'f':
2022             config_filename = optarg;
2023             break;
2024         default:
2025             exit(2);
2026         }
2027     }
2028
2029     /* address on which the server will handle connections */
2030     my_addr.sin_family = AF_INET;
2031     my_addr.sin_port = htons (8080);
2032     my_addr.sin_addr.s_addr = htonl (INADDR_ANY);
2033     nb_max_connections = 5;
2034     nb_max_bandwidth = 1000;
2035     first_stream = NULL;
2036     logfilename[0] = '\0';
2037
2038     if (parse_ffconfig(config_filename) < 0) {
2039         fprintf(stderr, "Incorrect config file - exiting.\n");
2040         exit(1);
2041     }
2042
2043     build_feed_streams();
2044
2045     /* signal init */
2046     signal(SIGPIPE, SIG_IGN);
2047
2048     /* open log file if needed */
2049     if (logfilename[0] != '\0') {
2050         if (!strcmp(logfilename, "-"))
2051             logfile = stdout;
2052         else
2053             logfile = fopen(logfilename, "w");
2054     }
2055
2056     if (http_server(my_addr) < 0) {
2057         fprintf(stderr, "Could not start http server\n");
2058         exit(1);
2059     }
2060
2061     return 0;
2062 }