开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 流媒体/Mpeg4/MP4 > 查看源码
ffserver.c
资源名称：ffmpeg-0.3.4.tar.gz　[点击查看]
上传用户：jxp0626
上传日期：2007-01-08
资源大小：102k
文件大小：49k
源码类别：

流媒体/Mpeg4/MP4

开发平台：

Unix_Linux

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 <linux/videodev.h>
  25. #include <linux/soundcard.h>
  26. #include <unistd.h>
  27. #include <fcntl.h>
  28. #include <sys/ioctl.h>
  29. #include <sys/mman.h>
  30. #include <sys/poll.h>
  31. #include <errno.h>
  32. #include <sys/time.h>
  33. #include <getopt.h>
  34. #include <sys/socket.h>
  35. #include <arpa/inet.h>
  36. #include <netdb.h>
  37. #include <ctype.h>
  38. #include <pthread.h>
  39. #include <signal.h>
  41. #include "mpegenc.h"
  43. /* maximum number of simultaneous HTTP connections */
  44. #define HTTP_MAX_CONNECTIONS 2000
  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. };
  54. enum MasterState {
  55.     MASTERSTATE_RECEIVE_HEADER,
  56.     MASTERSTATE_RECEIVE_DATA,
  57. };
  58.     
  59. #define IOBUFFER_MAX_SIZE 16384
  60. #define FIFO_MAX_SIZE (1024*1024)
  62. /* coef for exponential mean for bitrate estimation in statistics */
  63. #define AVG_COEF 0.9
  65. /* timeouts are in ms */
  66. #define REQUEST_TIMEOUT (15 * 1000)
  67. #define SYNC_TIMEOUT (10 * 1000)
  68. #define MASTER_CONNECT_TIMEOUT (10 * 1000)
  70. typedef struct HTTPContext {
  71.     enum HTTPState state;
  72.     int fd; /* socket file descriptor */
  73.     struct sockaddr_in from_addr; /* origin */
  74.     struct pollfd *poll_entry; /* used when polling */
  75.     long timeout;
  76.     UINT8 buffer[IOBUFFER_MAX_SIZE];
  77.     UINT8 *buffer_ptr, *buffer_end;
  78.     int http_error;
  79.     struct HTTPContext *next;
  80.     UINT8 *rptr; /* read pointer in the fifo */
  81.     int got_key_frame[2]; /* for each type */
  82.     long long data_count;
  83.     long long last_http_fifo_write_count; /* used to monitor overflow in the fifo */
  84.     /* format handling */
  85.     struct FFStream *stream;
  86.     AVFormatContext fmt_ctx;
  87.     int last_packet_sent; /* true if last data packet was sent */
  88. } HTTPContext;
  90. /* each generated stream is described here */
  91. enum StreamType {
  92.     STREAM_TYPE_LIVE,
  93.     STREAM_TYPE_MASTER,
  94.     STREAM_TYPE_STATUS,
  95. };
  97. typedef struct FFStream {
  98.     enum StreamType stream_type;
  99.     char filename[1024];
  100.     AVFormat *fmt;
  101.     AVEncodeContext *audio_enc;
  102.     AVEncodeContext *video_enc;
  103.     struct FFStream *next;
  104. } FFStream;
  106. typedef struct FifoBuffer {
  107.     UINT8 *buffer;
  108.     UINT8 *rptr, *wptr, *end;
  109. } FifoBuffer;
  111. /* each codec is here */
  112. typedef struct FFCodec {
  113.     struct FFCodec *next;
  114.     FifoBuffer fifo;     /* for compression: one audio fifo per codec */
  115.     ReSampleContext resample; /* for audio resampling */
  116.     long long data_count;
  117.     float avg_frame_size;   /* frame size averraged over last frames with exponential mean */
  118.     AVEncodeContext enc;
  119. } FFCodec;
  121. /* packet header */
  122. typedef struct {
  123.     UINT8 codec_type;
  124.     UINT8 codec_id;
  125.     UINT8 data[4];
  126.     UINT16 bit_rate;
  127.     UINT16 payload_size;
  128. } PacketHeader;
  130. struct sockaddr_in my_addr;
  131. char logfilename[1024];
  132. HTTPContext *first_http_ctx;
  133. FFStream *first_stream;
  134. FFCodec *first_codec;
  136. /* master state */
  137. char master_url[1024];
  138. enum MasterState master_state;
  139. UINT8 *master_wptr;
  140. int master_count;
  142. long long http_fifo_write_count;
  143. static FifoBuffer http_fifo;
  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 int master_receive(int fd);
  149. static void compute_stats(HTTPContext *c);
  151. int nb_max_connections;
  152. int nb_connections;
  154. /* fifo handling */
  155. int fifo_init(FifoBuffer *f, int size)
  156. {
  157.     f->buffer = malloc(size);
  158.     if (!f->buffer)
  159.         return -1;
  160.     f->end = f->buffer + size;
  161.     f->wptr = f->rptr = f->buffer;
  162.     return 0;
  163. }
  165. static int fifo_size(FifoBuffer *f, UINT8 *rptr)
  166. {
  167.     int size;
  169.     if (f->wptr >= rptr) {
  170.         size = f->wptr - rptr;
  171.     } else {
  172.         size = (f->end - rptr) + (f->wptr - f->buffer);
  173.     }
  174.     return size;
  175. }
  177. /* get data from the fifo (return -1 if not enough data) */
  178. static int fifo_read(FifoBuffer *f, UINT8 *buf, int buf_size, UINT8 **rptr_ptr)
  179. {
  180.     UINT8 *rptr = *rptr_ptr;
  181.     int size, len;
  183.     if (f->wptr >= rptr) {
  184.         size = f->wptr - rptr;
  185.     } else {
  186.         size = (f->end - rptr) + (f->wptr - f->buffer);
  187.     }
  188.     
  189.     if (size < buf_size)
  190.         return -1;
  191.     while (buf_size > 0) {
  192.         len = f->end - rptr;
  193.         if (len > buf_size)
  194.             len = buf_size;
  195.         memcpy(buf, rptr, len);
  196.         buf += len;
  197.         rptr += len;
  198.         if (rptr >= f->end)
  199.             rptr = f->buffer;
  200.         buf_size -= len;
  201.     }
  202.     *rptr_ptr = rptr;
  203.     return 0;
  204. }
  206. static void fifo_write(FifoBuffer *f, UINT8 *buf, int size, UINT8 **wptr_ptr)
  207. {
  208.     int len;
  209.     UINT8 *wptr;
  210.     wptr = *wptr_ptr;
  211.     while (size > 0) {
  212.         len = f->end - wptr;
  213.         if (len > size)
  214.             len = size;
  215.         memcpy(wptr, buf, len);
  216.         wptr += len;
  217.         if (wptr >= f->end)
  218.             wptr = f->buffer;
  219.         buf += len;
  220.         size -= len;
  221.     }
  222.     *wptr_ptr = wptr;
  223. }
  225. static long gettime_ms(void)
  226. {
  227.     struct timeval tv;
  229.     gettimeofday(&tv,NULL);
  230.     return (long long)tv.tv_sec * 1000 + (tv.tv_usec / 1000);
  231. }
  233. static FILE *logfile = NULL;
  235. static void http_log(char *fmt, ...)
  236. {
  237.     va_list ap;
  238.     va_start(ap, fmt);
  239.     
  240.     if (logfile)
  241.         vfprintf(logfile, fmt, ap);
  242.     va_end(ap);
  243. }
  246. /* connect to url 'url' and return the connected socket ready to read data */
  247. static int url_get(const char *url)
  248. {
  249.     struct sockaddr_in dest_addr;
  250.     struct hostent *h;
  251.     int s, port, size, line_size, len;
  252.     char hostname[1024], *q;
  253.     const char *p, *path;
  254.     char req[1024];
  255.     unsigned char ch;
  257.     if (!strstart(url, "http://", &p))
  258.         return -1;
  259.     q = hostname;
  260.     while (*p != ':' && *p != '' && *p != '/') {
  261.         if ((q - hostname) < (sizeof(hostname) - 1))
  262.             *q++ = *p;
  263.         p++;
  264.     }
  265.     port = 80;
  266.     if (*p == ':') {
  267.         p++;
  268.         port = strtol(p, (char **)&p, 10);
  269.     }
  270.     path = p;
  271.         
  272.     dest_addr.sin_family = AF_INET;
  273.     dest_addr.sin_port = htons(port);
  275.     if (!inet_aton(hostname, &dest_addr.sin_addr)) {
  276. if ((h = gethostbyname(hostname)) == NULL)
  277.     return -1;
  278. memcpy(&dest_addr.sin_addr, h->h_addr, sizeof(dest_addr.sin_addr));
  279.     }
  281.     s=socket(AF_INET, SOCK_STREAM, 0);
  282.     if (s < 0) 
  283.         return -1;
  285.     if (connect(s, (struct sockaddr *)&dest_addr, sizeof(dest_addr)) < 0) {
  286.     fail:
  287. close(s);
  288. return -1;
  289.     }
  290.     
  291.     /* send http request */
  292.     snprintf(req, sizeof(req), "GET %s HTTP/1.0rnrn", path);
  293.     p = req;
  294.     size = strlen(req);
  295.     while (size > 0) {
  296.         len = write(s, p, size);
  297.         if (len == -1) {
  298.             if (errno != EAGAIN && errno != EINTR)
  299.                 goto fail;
  300.         } else {
  301.             size -= len;
  302.             p += len;
  303.         }
  304.     }
  305.     
  306.     /* receive answer */
  307.     line_size = 0;
  308.     for(;;) {
  309.         len = read(s, &ch, 1);
  310.         if (len == -1) {
  311.             if (errno != EAGAIN && errno != EINTR)
  312.                 goto fail;
  313.         } else if (len == 0) {
  314.             goto fail;
  315.         } else {
  316.             if (ch == 'n') {
  317.                 if (line_size == 0)
  318.                     break;
  319.                 line_size = 0;
  320.             } else if (ch != 'r') {
  321.                 line_size++;
  322.             }
  323.         }
  324.     }
  326.     return s;
  327. }
  329. /* Each request is served by reading the input FIFO and by adding the
  330.    right format headers */
  331. static int http_server(struct sockaddr_in my_addr)
  332. {
  333.     int server_fd, tmp, ret;
  334.     struct sockaddr_in from_addr;
  335.     struct pollfd poll_table[HTTP_MAX_CONNECTIONS + 1], *poll_entry;
  336.     HTTPContext *c, **cp;
  337.     long cur_time;
  338.     int master_fd, master_timeout;
  340.     /* will try to connect to master as soon as possible */
  341.     master_fd = -1;
  342.     master_timeout = gettime_ms();
  344.     server_fd = socket(AF_INET,SOCK_STREAM,0);
  345.     if (server_fd < 0) {
  346.         perror ("socket");
  347.         return -1;
  348.     }
  349.         
  350.     tmp = 1;
  351.     setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &tmp, sizeof(tmp));
  353.     if (bind (server_fd, (struct sockaddr *) &my_addr, sizeof (my_addr)) < 0) {
  354.         perror ("bind");
  355.         close(server_fd);
  356.         return -1;
  357.     }
  358.   
  359.     if (listen (server_fd, 5) < 0) {
  360.         perror ("listen");
  361.         close(server_fd);
  362.         return -1;
  363.     }
  365.     http_log("ffserver started.n");
  367.     fcntl(server_fd, F_SETFL, O_NONBLOCK);
  368.     first_http_ctx = NULL;
  369.     nb_connections = 0;
  370.     first_http_ctx = NULL;
  371.     for(;;) {
  372.         poll_entry = poll_table;
  373.         poll_entry->fd = server_fd;
  374.         poll_entry->events = POLLIN;
  375.         poll_entry++;
  377.         if (master_fd >= 0) {
  378.             poll_entry->fd = master_fd;
  379.             poll_entry->events = POLLIN;
  380.             poll_entry++;
  381.         }
  383.         /* wait for events on each HTTP handle */
  384.         c = first_http_ctx;
  385.         while (c != NULL) {
  386.             int fd;
  387.             fd = c->fd;
  388.             switch(c->state) {
  389.             case HTTPSTATE_WAIT_REQUEST:
  390.                 c->poll_entry = poll_entry;
  391.                 poll_entry->fd = fd;
  392.                 poll_entry->events = POLLIN;
  393.                 poll_entry++;
  394.                 break;
  395.             case HTTPSTATE_SEND_HEADER:
  396.             case HTTPSTATE_SEND_DATA_HEADER:
  397.             case HTTPSTATE_SEND_DATA:
  398.             case HTTPSTATE_SEND_DATA_TRAILER:
  399.                 c->poll_entry = poll_entry;
  400.                 poll_entry->fd = fd;
  401.                 poll_entry->events = POLLOUT;
  402.                 poll_entry++;
  403.                 break;
  404.             default:
  405.                 c->poll_entry = NULL;
  406.                 break;
  407.             }
  408.             c = c->next;
  409.         }
  411.         /* wait for an event on one connection. We poll at least every
  412.            second to handle timeouts */
  413.         do {
  414.             ret = poll(poll_table, poll_entry - poll_table, 1000);
  415.         } while (ret == -1);
  416.         
  417.         cur_time = gettime_ms();
  419.         /* now handle the events */
  421.         cp = &first_http_ctx;
  422.         while ((*cp) != NULL) {
  423.             c = *cp;
  424.             if (handle_http (c, cur_time) < 0) {
  425.                 /* close and free the connection */
  426.                 close(c->fd);
  427.                 *cp = c->next;
  428.                 free(c);
  429.                 nb_connections--;
  430.             } else {
  431.                 cp = &c->next;
  432.             }
  433.         }
  435.         /* new connection request ? */
  436.         poll_entry = poll_table;
  437.         if (poll_entry->revents & POLLIN) {
  438.             int fd, len;
  440.             len = sizeof(from_addr);
  441.             fd = accept(server_fd, &from_addr, &len);
  442.             if (fd >= 0) {
  443.                 fcntl(fd, F_SETFL, O_NONBLOCK);
  444.                 /* XXX: should output a warning page when comming
  445.                    close to the connection limit */
  446.                 if (nb_connections >= nb_max_connections) {
  447.                     close(fd);
  448.                 } else {
  449.                     /* add a new connection */
  450.                     c = malloc(sizeof(HTTPContext));
  451.                     memset(c, 0, sizeof(*c));
  452.                     c->next = first_http_ctx;
  453.                     first_http_ctx = c;
  454.                     c->fd = fd;
  455.                     c->poll_entry = NULL;
  456.                     c->from_addr = from_addr;
  457.                     c->state = HTTPSTATE_WAIT_REQUEST;
  458.                     c->buffer_ptr = c->buffer;
  459.                     c->buffer_end = c->buffer + IOBUFFER_MAX_SIZE;
  460.                     c->timeout = cur_time + REQUEST_TIMEOUT;
  461.                     nb_connections++;
  462.                 }
  463.             }
  464.         }
  465.         poll_entry++;
  467.         /* master events */
  468.         if (poll_entry->revents & POLLIN) {
  469.             if (master_receive(master_fd) < 0) {
  470.                 close(master_fd);
  471.                 master_fd = -1;
  472.             }
  473.         }
  475.         /* master (re)connection handling */
  476.         if (master_url[0] != '' && 
  477.             master_fd < 0 && (master_timeout - cur_time) <= 0) {
  478.             master_fd = url_get(master_url);
  479.             if (master_fd < 0) {
  480.                 master_timeout = gettime_ms() + MASTER_CONNECT_TIMEOUT;
  481.                 http_log("Connection to master: '%s' failedn", master_url);
  482.             } else {
  483.                 fcntl(master_fd, F_SETFL, O_NONBLOCK);
  484.                 master_state = MASTERSTATE_RECEIVE_HEADER;
  485.                 master_count = sizeof(PacketHeader);
  486.                 master_wptr = http_fifo.wptr;
  487.             }
  488.         }
  489.     }
  490. }
  492. static int handle_http(HTTPContext *c, long cur_time)
  493. {
  494.     int len;
  495.     
  496.     switch(c->state) {
  497.     case HTTPSTATE_WAIT_REQUEST:
  498.         /* timeout ? */
  499.         if ((c->timeout - cur_time) < 0)
  500.             return -1;
  501.         if (c->poll_entry->revents & (POLLERR | POLLHUP))
  502.             return -1;
  504.         /* no need to read if no events */
  505.         if (!(c->poll_entry->revents & POLLIN))
  506.             return 0;
  507.         /* read the data */
  508.         len = read(c->fd, c->buffer_ptr, c->buffer_end - c->buffer_ptr);
  509.         if (len < 0) {
  510.             if (errno != EAGAIN && errno != EINTR)
  511.                 return -1;
  512.         } else if (len == 0) {
  513.             return -1;
  514.         } else {
  515.             /* search for end of request. XXX: not fully correct since garbage could come after the end */
  516.             UINT8 *ptr;
  517.             c->buffer_ptr += len;
  518.             ptr = c->buffer_ptr;
  519.             if ((ptr >= c->buffer + 2 && !memcmp(ptr-2, "nn", 2)) ||
  520.                 (ptr >= c->buffer + 4 && !memcmp(ptr-4, "rnrn", 4))) {
  521.                 /* request found : parse it and reply */
  522.                 if (http_parse_request(c) < 0)
  523.                     return -1;
  524.             } else if (ptr >= c->buffer_end) {
  525.                 /* request too long: cannot do anything */
  526.                 return -1;
  527.             }
  528.         }
  529.         break;
  531.     case HTTPSTATE_SEND_HEADER:
  532.         if (c->poll_entry->revents & (POLLERR | POLLHUP))
  533.             return -1;
  535.         /* no need to read if no events */
  536.         if (!(c->poll_entry->revents & POLLOUT))
  537.             return 0;
  538.         len = write(c->fd, c->buffer_ptr, c->buffer_end - c->buffer_ptr);
  539.         if (len < 0) {
  540.             if (errno != EAGAIN && errno != EINTR) {
  541.                 /* error : close connection */
  542.                 return -1;
  543.             }
  544.         } else {
  545.             c->buffer_ptr += len;
  546.             if (c->buffer_ptr >= c->buffer_end) {
  547.                 /* if error, exit */
  548.                 if (c->http_error)
  549.                     return -1;
  550.                 /* all the buffer was send : synchronize to the incoming stream */
  551.                 c->state = HTTPSTATE_SEND_DATA_HEADER;
  552.                 c->buffer_ptr = c->buffer_end = c->buffer;
  553.             }
  554.         }
  555.         break;
  557.     case HTTPSTATE_SEND_DATA:
  558.     case HTTPSTATE_SEND_DATA_HEADER:
  559.     case HTTPSTATE_SEND_DATA_TRAILER:
  560.         /* no need to read if no events */
  561.         if (c->poll_entry->revents & (POLLERR | POLLHUP))
  562.             return -1;
  563.         
  564.         if (!(c->poll_entry->revents & POLLOUT))
  565.             return 0;
  566.         if (http_send_data(c) < 0)
  567.             return -1;
  568.         break;
  569.     default:
  570.         return -1;
  571.     }
  572.     return 0;
  573. }
  575. /* parse http request and prepare header */
  576. static int http_parse_request(HTTPContext *c)
  577. {
  578.     const char *p;
  579.     char cmd[32];
  580.     char url[1024], *q;
  581.     char protocol[32];
  582.     char msg[1024];
  583.     char *mime_type;
  584.     FFStream *stream;
  586.     p = c->buffer;
  587.     q = cmd;
  588.     while (!isspace(*p) && *p != '') {
  589.         if ((q - cmd) < sizeof(cmd) - 1)
  590.             *q++ = *p;
  591.         p++;
  592.     }
  593.     *q = '';
  594.     if (strcmp(cmd, "GET"))
  595.         return -1;
  597.     while (isspace(*p)) p++;
  598.     q = url;
  599.     while (!isspace(*p) && *p != '') {
  600.         if ((q - url) < sizeof(url) - 1)
  601.             *q++ = *p;
  602.         p++;
  603.     }
  604.     *q = '';
  606.     while (isspace(*p)) p++;
  607.     q = protocol;
  608.     while (!isspace(*p) && *p != '') {
  609.         if ((q - protocol) < sizeof(protocol) - 1)
  610.             *q++ = *p;
  611.         p++;
  612.     }
  613.     *q = '';
  614.     if (strcmp(protocol, "HTTP/1.0") && strcmp(protocol, "HTTP/1.1"))
  615.         return -1;
  616.     
  617.     /* find the filename in the request */
  618.     p = url;
  619.     if (*p == '/')
  620.         p++;
  622.     stream = first_stream;
  623.     while (stream != NULL) {
  624.         if (!strcmp(stream->filename, p))
  625.             break;
  626.         stream = stream->next;
  627.     }
  628.     if (stream == NULL) {
  629.         sprintf(msg, "File '%s' not found", url);
  630.         goto send_error;
  631.     }
  632.     c->stream = stream;
  633.     
  634.     /* should do it after so that the size can be computed */
  635.     {
  636.         char buf1[32], buf2[32], *p;
  637.         time_t ti;
  638.         /* XXX: reentrant function ? */
  639.         p = inet_ntoa(c->from_addr.sin_addr);
  640.         strcpy(buf1, p);
  641.         ti = time(NULL);
  642.         p = ctime(&ti);
  643.         strcpy(buf2, p);
  644.         p = buf2 + strlen(p) - 1;
  645.         if (*p == 'n')
  646.             *p = '';
  647.         http_log("%s - - [%s] "%s %s %s" %d %dn", 
  648.                  buf1, buf2, cmd, url, protocol, 200, 1024);
  649.     }
  651.     if (c->stream->stream_type == STREAM_TYPE_STATUS)
  652.         goto send_stats;
  654.     /* prepare http header */
  655.     q = c->buffer;
  656.     q += sprintf(q, "HTTP/1.0 200 OKrn");
  657.     mime_type = c->stream->fmt->mime_type;
  658.     if (!mime_type)
  659.         mime_type = "application/x-octet_stream";
  660.     q += sprintf(q, "Content-type: %srn", mime_type);
  661.     q += sprintf(q, "Pragma: no-cachern");
  662.     /* for asf, we need extra headers */
  663.     if (!strcmp(c->stream->fmt->name,"asf")) {
  664.         q += sprintf(q, "Pragma: features=broadcastrn");
  665.     }
  666.     q += sprintf(q, "rn");
  668.     /* prepare output buffer */
  669.     c->http_error = 0;
  670.     c->buffer_ptr = c->buffer;
  671.     c->buffer_end = q;
  672.     c->state = HTTPSTATE_SEND_HEADER;
  673.     return 0;
  674.  send_error:
  675.     c->http_error = 404;
  676.     q = c->buffer;
  677.     q += sprintf(q, "HTTP/1.0 404 Not Foundrn");
  678.     q += sprintf(q, "Content-type: %srn", "text/html");
  679.     q += sprintf(q, "rn");
  680.     q += sprintf(q, "<HTML>n");
  681.     q += sprintf(q, "<HEAD><TITLE>404 Not Found</TITLE></HEAD>n");
  682.     q += sprintf(q, "<BODY>%s</BODY>n", msg);
  683.     q += sprintf(q, "</HTML>n");
  685.     /* prepare output buffer */
  686.     c->buffer_ptr = c->buffer;
  687.     c->buffer_end = q;
  688.     c->state = HTTPSTATE_SEND_HEADER;
  689.     return 0;
  690.  send_stats:
  691.     compute_stats(c);
  692.     c->http_error = 200; /* horrible : we use this value to avoid
  693.                             going to the send data state */
  694.     c->state = HTTPSTATE_SEND_HEADER;
  695.     return 0;
  696. }
  698. static void compute_stats(HTTPContext *c)
  699. {
  700.     AVEncodeContext *enc;
  701.     HTTPContext *c1;
  702.     FFCodec *ffenc;
  703.     FFStream *stream;
  704.     float avg;
  705.     char buf[1024], *q, *p;
  706.     time_t ti;
  707.     int i;
  709.     q = c->buffer;
  710.     q += sprintf(q, "HTTP/1.0 200 OKrn");
  711.     q += sprintf(q, "Content-type: %srn", "text/html");
  712.     q += sprintf(q, "Pragma: no-cachern");
  713.     q += sprintf(q, "rn");
  714.     
  715.     q += sprintf(q, "<HEAD><TITLE>FFServer Status</TITLE></HEAD>n<BODY>");
  716.     q += sprintf(q, "<H1>FFServer Status</H1>n");
  717.     /* format status */
  718.     q += sprintf(q, "<H1>Available Streams</H1>n");
  719.     q += sprintf(q, "<TABLE>n");
  720.     q += sprintf(q, "<TR><TD>Path<TD>Format<TD>Bit rate (kbits/s)<TD>Video<TD>Audion");
  721.     stream = first_stream;
  722.     while (stream != NULL) {
  723.         q += sprintf(q, "<TR><TD><A HREF="/%s">%s</A> ", 
  724.                      stream->filename, stream->filename);
  725.         switch(stream->stream_type) {
  726.         case STREAM_TYPE_LIVE:
  727.             {
  728.                 int audio_bit_rate = 0;
  729.                 int video_bit_rate = 0;
  730.                 if (stream->audio_enc)
  731.                     audio_bit_rate = stream->audio_enc->bit_rate;
  732.                 if (stream->video_enc)
  733.                     video_bit_rate = stream->video_enc->bit_rate;
  734.                 
  735.                 q += sprintf(q, "<TD> %s <TD> %d <TD> %d <TD> %dn", 
  736.                              stream->fmt->name,
  737.                              (audio_bit_rate + video_bit_rate) / 1000,
  738.                              video_bit_rate / 1000, audio_bit_rate / 1000);
  739.             }
  740.             break;
  741.         case STREAM_TYPE_MASTER:
  742.             q += sprintf(q, "<TD> %s <TD> - <TD> - <TD> -n",
  743.                          "master");
  744.             break;
  745.         default:
  746.             q += sprintf(q, "<TD> - <TD> - <TD> - <TD> -n");
  747.             break;
  748.         }
  749.         stream = stream->next;
  750.     }
  751.     q += sprintf(q, "</TABLE>n");
  752.     
  753.     /* codec status */
  754.     q += sprintf(q, "<H1>Codec Status</H1>n");
  755.     q += sprintf(q, "<TABLE>n");
  756.     q += sprintf(q, "<TR><TD>Parameters<TD>Frame count<TD>Size<TD>Avg bitrate (kbits/s)n");
  757.     ffenc = first_codec;
  758.     while (ffenc != NULL) {
  759.         enc = &ffenc->enc;
  760.         avencoder_string(buf, sizeof(buf), enc);
  761.         avg = ffenc->avg_frame_size * (float)enc->rate * 8.0;
  762.         if (enc->codec->type == CODEC_TYPE_AUDIO && enc->frame_size > 0)
  763.             avg /= enc->frame_size;
  764.         q += sprintf(q, "<TR><TD>%s <TD> %d <TD> %Ld <TD> %0.1fn", 
  765.                      buf, enc->frame_number, ffenc->data_count, avg / 1000.0);
  766.         ffenc = ffenc->next;
  767.     }
  768.     q += sprintf(q, "</TABLE>n");
  770.     /* exclude the stat connection */
  771.     q += sprintf(q, "Number of connections: %d / %d<BR>n",
  772.                  nb_connections, nb_max_connections);
  774.     /* connection status */
  775.     q += sprintf(q, "<H1>Connection Status</H1>n");
  776.     q += sprintf(q, "<TABLE>n");
  777.     q += sprintf(q, "<TR><TD>#<TD>File<TD>IP<TD>Sizen");
  778.     c1 = first_http_ctx;
  779.     i = 0;
  780.     while (c1 != NULL) {
  781.         i++;
  782.         p = inet_ntoa(c1->from_addr.sin_addr);
  783.         q += sprintf(q, "<TR><TD><B>%d</B><TD>%s <TD> %s <TD> %Ldn", 
  784.                      i, c1->stream->filename, p, c1->data_count);
  785.         c1 = c1->next;
  786.     }
  787.     q += sprintf(q, "</TABLE>n");
  788.     
  789.     /* date */
  790.     ti = time(NULL);
  791.     p = ctime(&ti);
  792.     q += sprintf(q, "<HR>Generated at %s", p);
  793.     q += sprintf(q, "</BODY>n</HTML>n");
  795.     c->buffer_ptr = c->buffer;
  796.     c->buffer_end = q;
  797. }
  800. static void http_write_packet(void *opaque, 
  801.                               unsigned char *buf, int size)
  802. {
  803.     HTTPContext *c = opaque;
  804.     if (size > IOBUFFER_MAX_SIZE)
  805.         abort();
  806.     memcpy(c->buffer, buf, size);
  807.     c->buffer_ptr = c->buffer;
  808.     c->buffer_end = c->buffer + size;
  809. }
  811. /* this headers are used to identify a packet for a given codec */
  812. void mk_header(PacketHeader *h, AVEncodeContext *c, int payload_size)
  813. {
  814.     h->codec_type = c->codec->type;
  815.     h->codec_id = c->codec->id;
  816.     h->bit_rate = htons(c->bit_rate / 1000);
  817.     switch(c->codec->type) {
  818.     case CODEC_TYPE_VIDEO:
  819.         h->data[0] = c->rate;
  820.         h->data[1] = c->width / 16;
  821.         h->data[2] = c->height / 16;
  822.         break;
  823.     case CODEC_TYPE_AUDIO:
  824.         h->data[0] = c->rate / 1000;
  825.         h->data[1] = c->channels;
  826.         h->data[2] = 0;
  827.         break;
  828.     }
  829.     h->data[3] = c->key_frame;
  830.     h->payload_size = htons(payload_size);
  831. }
  833. int test_header(PacketHeader *h, AVEncodeContext *c)
  834. {
  835.     if (!c)
  836.         return 0;
  838.     if (h->codec_type == c->codec->type &&
  839.         h->codec_id == c->codec->id &&
  840.         h->bit_rate == htons(c->bit_rate / 1000)) {
  842.         switch(c->codec->type) {
  843.         case CODEC_TYPE_VIDEO:
  844.             if (h->data[0] == c->rate &&
  845.                 h->data[1] == (c->width / 16) &&
  846.                 h->data[2] == (c->height / 16))
  847.                 goto found;
  848.             break;
  849.         case CODEC_TYPE_AUDIO:
  850.             if (h->data[0] == (c->rate / 1000) &&
  851.                 (h->data[1] == c->channels))
  852.                 goto found;
  853.             break;
  854.         }
  855.     }
  856.     return 0;
  857.  found:
  858.     c->frame_number++;
  859.     c->key_frame = h->data[3];
  860.     return 1;
  861. }
  863. static int http_prepare_data(HTTPContext *c)
  864. {
  865.     PacketHeader hdr;
  866.     UINT8 *start_rptr, *payload;
  867.     int payload_size, ret;
  868.     long long fifo_total_size;
  870.     switch(c->state) {
  871.     case HTTPSTATE_SEND_DATA_HEADER:
  872.         if (c->stream->stream_type != STREAM_TYPE_MASTER) {            
  873.             memset(&c->fmt_ctx, 0, sizeof(c->fmt_ctx));
  874.             c->fmt_ctx.format = c->stream->fmt;
  875.             if (c->fmt_ctx.format->audio_codec != CODEC_ID_NONE) {
  876.                 /* create a fake new codec instance */
  877.                 c->fmt_ctx.audio_enc = malloc(sizeof(AVEncodeContext));
  878.                 memcpy(c->fmt_ctx.audio_enc, c->stream->audio_enc, 
  879.                        sizeof(AVEncodeContext));
  880.                 c->fmt_ctx.audio_enc->frame_number = 0;
  881.             }
  882.             if (c->fmt_ctx.format->video_codec != CODEC_ID_NONE) {
  883.                 c->fmt_ctx.video_enc = malloc(sizeof(AVEncodeContext));
  884.                 memcpy(c->fmt_ctx.video_enc, c->stream->video_enc, 
  885.                        sizeof(AVEncodeContext));
  886.                 c->fmt_ctx.video_enc->frame_number = 0;
  887.             }
  888.             init_put_byte(&c->fmt_ctx.pb, c->buffer, IOBUFFER_MAX_SIZE,
  889.                           c, http_write_packet, NULL);
  890.             c->fmt_ctx.is_streamed = 1;
  891.             c->got_key_frame[0] = 0;
  892.             c->got_key_frame[1] = 0;
  893.             /* prepare header */
  894.             c->fmt_ctx.format->write_header(&c->fmt_ctx);
  895.         }
  896.         c->state = HTTPSTATE_SEND_DATA;
  897.         c->last_packet_sent = 0;
  898.         c->rptr = http_fifo.wptr;
  899.         c->last_http_fifo_write_count = http_fifo_write_count;
  900.         break;
  901.     case HTTPSTATE_SEND_DATA:
  902.         /* find a new packet */
  903.         fifo_total_size = http_fifo_write_count - c->last_http_fifo_write_count;
  904.         if (fifo_total_size >= ((3 * FIFO_MAX_SIZE) / 4)) {
  905.             /* overflow : resync. We suppose that wptr is at this
  906.                point a pointer to a valid packet */
  907.             c->rptr = http_fifo.wptr;
  908.             c->got_key_frame[0] = 0;
  909.             c->got_key_frame[1] = 0;
  910.         }
  911.         
  912.         start_rptr = c->rptr;
  913.         if (fifo_read(&http_fifo, (UINT8 *)&hdr, sizeof(hdr), &c->rptr) < 0)
  914.             return 0;
  915.         payload_size = ntohs(hdr.payload_size);
  916.         payload = malloc(payload_size);
  917.         if (fifo_read(&http_fifo, payload, payload_size, &c->rptr) < 0) {
  918.             /* cannot read all the payload */
  919.             free(payload);
  920.             c->rptr = start_rptr;
  921.             return 0;
  922.         }
  923.         
  924.         c->last_http_fifo_write_count = http_fifo_write_count - 
  925.             fifo_size(&http_fifo, c->rptr);
  926.         
  927.         if (c->stream->stream_type != STREAM_TYPE_MASTER) {
  928.             /* test if the packet can be handled by this format */
  929.             ret = 0;
  930.             if (test_header(&hdr, c->fmt_ctx.audio_enc)) {
  931.                 /* only begin sending when got a key frame */
  932.                 if (c->fmt_ctx.audio_enc->key_frame)
  933.                     c->got_key_frame[1] = 1;
  934.                 if (c->got_key_frame[1]) {
  935.                     ret = c->fmt_ctx.format->write_audio_frame(&c->fmt_ctx, 
  936.                                                                payload, payload_size);
  937.                 }
  938.             } else if (test_header(&hdr, c->fmt_ctx.video_enc)) {
  939.                 if (c->fmt_ctx.video_enc->key_frame)
  940.                     c->got_key_frame[0] = 1;
  941.                 if (c->got_key_frame[0]) {
  942.                     ret = c->fmt_ctx.format->write_video_picture(&c->fmt_ctx, 
  943.                                                                  payload, payload_size);
  944.                 }
  945.             }
  946.             if (ret) {
  947.                 /* must send trailer now */
  948.                 c->state = HTTPSTATE_SEND_DATA_TRAILER;
  949.             }
  950.         } else {
  951.             /* master case : send everything */
  952.             char *q;
  953.             q = c->buffer;
  954.             memcpy(q, &hdr, sizeof(hdr));
  955.             q += sizeof(hdr);
  956.             memcpy(q, payload, payload_size);
  957.             q += payload_size;
  958.             c->buffer_ptr = c->buffer;
  959.             c->buffer_end = q;
  960.         }
  961.         free(payload);
  962.         break;
  963.     default:
  964.     case HTTPSTATE_SEND_DATA_TRAILER:
  965.         /* last packet test ? */
  966.         if (c->last_packet_sent)
  967.             return -1;
  968.         /* prepare header */
  969.         c->fmt_ctx.format->write_trailer(&c->fmt_ctx);
  970.         c->last_packet_sent = 1;
  971.         break;
  972.     }
  973.     return 0;
  974. }
  977. /* should convert the format at the same time */
  978. static int http_send_data(HTTPContext *c)
  979. {
  980.     int len;
  982.     while (c->buffer_ptr >= c->buffer_end) {
  983.         if (http_prepare_data(c) < 0)
  984.             return -1;
  985.     }
  987.     len = write(c->fd, c->buffer_ptr, c->buffer_end - c->buffer_ptr);
  988.     if (len < 0) {
  989.         if (errno != EAGAIN && errno != EINTR) {
  990.             /* error : close connection */
  991.             return -1;
  992.         }
  993.     } else {
  994.         c->buffer_ptr += len;
  995.         c->data_count += len;
  996.     }
  997.     return 0;
  998. }
  1000. static int master_receive(int fd)
  1001. {
  1002.     int len, size;
  1003.     FifoBuffer *f = &http_fifo;
  1004.     UINT8 *rptr;
  1006.     size = f->end - f->wptr;
  1007.     if (size > master_count)
  1008.         size = master_count;
  1009.     len = read(fd, f->wptr, size);
  1010.     if (len == -1) {
  1011.         if (errno != EAGAIN && errno != EINTR) 
  1012.             return -1;
  1013.     } else if (len == 0) {
  1014.         return -1;
  1015.     } else {
  1016.         master_wptr += len;
  1017.         if (master_wptr >= f->end)
  1018.             master_wptr = f->buffer;
  1019.         master_count -= len;
  1020.         if (master_count == 0) {
  1021.             if (master_state == MASTERSTATE_RECEIVE_HEADER) {
  1022.                 /* XXX: use generic fifo read to extract packet header */
  1023.                 rptr = master_wptr;
  1024.                 if (rptr == f->buffer)
  1025.                     rptr = f->end - 1;
  1026.                 else
  1027.                     rptr--;
  1028.                 master_count = *rptr;
  1029.                 if (rptr == f->buffer)
  1030.                     rptr = f->end - 1;
  1031.                 else
  1032.                     rptr--;
  1033.                 master_count |= *rptr << 8;
  1034.                 master_state = MASTERSTATE_RECEIVE_DATA;
  1035.             } else {
  1036.                 /* update fifo wptr */
  1037.                 f->wptr = master_wptr;
  1038.                 master_state = MASTERSTATE_RECEIVE_HEADER;
  1039.             }
  1040.         }
  1041.     }
  1042.     return 0;
  1043. }
  1045. static void get_arg(char *buf, int buf_size, const char **pp)
  1046. {
  1047.     const char *p;
  1048.     char *q;
  1050.     p = *pp;
  1051.     while (isspace(*p)) p++;
  1052.     q = buf;
  1053.     while (!isspace(*p) && *p != '') {
  1054.         if ((q - buf) < buf_size - 1)
  1055.             *q++ = *p;
  1056.         p++;
  1057.     }
  1058.     *q = '';
  1059.     *pp = p;
  1060. }
  1062. /* add a codec and check if it does not already exists */
  1063. AVEncodeContext *add_codec(int codec_id,
  1064.                            AVEncodeContext *av)
  1065. {
  1066.     AVEncoder *codec;
  1067.     FFCodec *ctx, **pctx;
  1068.     AVEncodeContext *av1;
  1070.     codec = avencoder_find(codec_id);
  1071.     if (!codec)
  1072.         return NULL;
  1074.     /* compute default parameters */
  1075.     av->codec = codec;
  1076.     switch(codec->type) {
  1077.     case CODEC_TYPE_AUDIO:
  1078.         if (av->bit_rate == 0)
  1079.             av->bit_rate = 64000;
  1080.         if (av->rate == 0)
  1081.             av->rate = 22050;
  1082.         if (av->channels == 0)
  1083.             av->channels = 1;
  1084.         break;
  1085.     case CODEC_TYPE_VIDEO:
  1086.         if (av->bit_rate == 0)
  1087.             av->bit_rate = 64000;
  1088.         if (av->rate == 0)
  1089.             av->rate = 5;
  1090.         if (av->width == 0 || av->height == 0) {
  1091.             av->width = 160;
  1092.             av->height = 128;
  1093.         }
  1094.         break;
  1095.     }
  1097.     /* find if the codec already exists */
  1098.     pctx = &first_codec;
  1099.     while (*pctx != NULL) {
  1100.         av1 = &(*pctx)->enc;
  1101.         if (av1->codec == av->codec &&
  1102.             av1->bit_rate == av->bit_rate &&
  1103.             av1->rate == av->rate) {
  1105.             switch(av->codec->type) {
  1106.             case CODEC_TYPE_AUDIO:
  1107.                 if (av1->channels == av->channels)
  1108.                     goto found;
  1109.                 break;
  1110.             case CODEC_TYPE_VIDEO:
  1111.                 if (av1->width == av->width &&
  1112.                     av1->height == av->height &&
  1113.                     av1->gop_size == av->gop_size)
  1114.                     goto found;
  1115.                 break;
  1116.             }
  1117.         }
  1118.         pctx = &(*pctx)->next;
  1119.     }
  1121.     ctx = malloc(sizeof(FFCodec));
  1122.     if (!ctx)
  1123.         return NULL;
  1124.     memset(ctx, 0, sizeof(FFCodec));
  1125.     *pctx = ctx;
  1126.     
  1127.     memcpy(&ctx->enc, av, sizeof(AVEncodeContext));
  1128.     return &ctx->enc;
  1129.  found:
  1130.     ctx = *pctx;
  1131.     return &ctx->enc;
  1132. }
  1134. int parse_ffconfig(const char *filename)
  1135. {
  1136.     FILE *f;
  1137.     char line[1024];
  1138.     char cmd[64];
  1139.     char arg[1024];
  1140.     const char *p;
  1141.     int val, errors, line_num;
  1142.     FFStream **last_stream, *stream;
  1143.     AVEncodeContext audio_enc, video_enc;
  1145.     f = fopen(filename, "r");
  1146.     if (!f) {
  1147.         perror(filename);
  1148.         return -1;
  1149.     }
  1150.     
  1151.     errors = 0;
  1152.     line_num = 0;
  1153.     first_stream = NULL;
  1154.     first_codec = NULL;
  1155.     last_stream = &first_stream;
  1156.     stream = NULL;
  1157.     for(;;) {
  1158.         if (fgets(line, sizeof(line), f) == NULL)
  1159.             break;
  1160.         line_num++;
  1161.         p = line;
  1162.         while (isspace(*p)) 
  1163.             p++;
  1164.         if (*p == '' || *p == '#')
  1165.             continue;
  1167.         get_arg(cmd, sizeof(cmd), &p);
  1168.         
  1169.         if (!strcasecmp(cmd, "Port")) {
  1170.             get_arg(arg, sizeof(arg), &p);
  1171.             my_addr.sin_port = htons (atoi(arg));
  1172.         } else if (!strcasecmp(cmd, "BindAddress")) {
  1173.             get_arg(arg, sizeof(arg), &p);
  1174.             if (!inet_aton(arg, &my_addr.sin_addr)) {
  1175.                 fprintf(stderr, "%s:%d: Invalid IP address: %sn", 
  1176.                         filename, line_num, arg);
  1177.                 errors++;
  1178.             }
  1179.         } else if (!strcasecmp(cmd, "MasterServer")) {
  1180.             get_arg(master_url, sizeof(master_url), &p);
  1181.             if (!strstart(master_url, "http://", NULL)) {
  1182.                 fprintf(stderr, "%s:%d: Invalid URL for master server: %sn", 
  1183.                         filename, line_num, master_url);
  1184.                 errors++;
  1185.             }
  1186.         } else if (!strcasecmp(cmd, "AudioDevice")) {
  1187.             get_arg(arg, sizeof(arg), &p);
  1188.             audio_device = strdup(arg);
  1189.         } else if (!strcasecmp(cmd, "VideoDevice")) {
  1190.             get_arg(arg, sizeof(arg), &p);
  1191.             v4l_device = strdup(arg);
  1192.         } else if (!strcasecmp(cmd, "MaxClients")) {
  1193.             get_arg(arg, sizeof(arg), &p);
  1194.             val = atoi(arg);
  1195.             if (val < 1 || val > HTTP_MAX_CONNECTIONS) {
  1196.                 fprintf(stderr, "%s:%d: Invalid MaxClients: %sn", 
  1197.                         filename, line_num, arg);
  1198.                 errors++;
  1199.             } else {
  1200.                 nb_max_connections = val;
  1201.             }
  1202.         } else if (!strcasecmp(cmd, "CustomLog")) {
  1203.             get_arg(logfilename, sizeof(logfilename), &p);
  1204.         } else if (!strcasecmp(cmd, "<Stream")) {
  1205.             char *q;
  1206.             if (stream) {
  1207.                 fprintf(stderr, "%s:%d: Already in a stream tagn",
  1208.                         filename, line_num);
  1209.             } else {
  1210.                 stream = malloc(sizeof(FFStream));
  1211.                 memset(stream, 0, sizeof(FFStream));
  1212.                 *last_stream = stream;
  1213.                 last_stream = &stream->next;
  1215.                 get_arg(stream->filename, sizeof(stream->filename), &p);
  1216.                 q = strrchr(stream->filename, '>');
  1217.                 if (*q)
  1218.                     *q = '';
  1219.                 stream->fmt = guess_format(NULL, stream->filename, NULL);
  1220.                 memset(&audio_enc, 0, sizeof(AVEncodeContext));
  1221.                 memset(&video_enc, 0, sizeof(AVEncodeContext));
  1222.             }
  1223.         } else if (!strcasecmp(cmd, "Format")) {
  1224.             get_arg(arg, sizeof(arg), &p);
  1225.             if (!strcmp(arg, "master")) {
  1226.                 stream->stream_type = STREAM_TYPE_MASTER;
  1227.                 stream->fmt = NULL;
  1228.             } else if (!strcmp(arg, "status")) {
  1229.                 stream->stream_type = STREAM_TYPE_STATUS;
  1230.                 stream->fmt = NULL;
  1231.             } else {
  1232.                 stream->stream_type = STREAM_TYPE_LIVE;
  1233.                 stream->fmt = guess_format(arg, NULL, NULL);
  1234.                 if (!stream->fmt) {
  1235.                     fprintf(stderr, "%s:%d: Unknown Format: %sn", 
  1236.                             filename, line_num, arg);
  1237.                     errors++;
  1238.                 }
  1239.             }
  1240.         } else if (!strcasecmp(cmd, "AudioBitRate")) {
  1241.             get_arg(arg, sizeof(arg), &p);
  1242.             if (stream) {
  1243.                 audio_enc.bit_rate = atoi(arg) * 1000;
  1244.             }
  1245.         } else if (!strcasecmp(cmd, "AudioChannels")) {
  1246.             get_arg(arg, sizeof(arg), &p);
  1247.             if (stream) {
  1248.                 audio_enc.channels = atoi(arg);
  1249.             }
  1250.         } else if (!strcasecmp(cmd, "AudioSampleRate")) {
  1251.             get_arg(arg, sizeof(arg), &p);
  1252.             if (stream) {
  1253.                 audio_enc.rate = atoi(arg);
  1254.             }
  1255.         } else if (!strcasecmp(cmd, "VideoBitRate")) {
  1256.             get_arg(arg, sizeof(arg), &p);
  1257.             if (stream) {
  1258.                 video_enc.bit_rate = atoi(arg) * 1000;
  1259.             }
  1260.         } else if (!strcasecmp(cmd, "VideoFrameRate")) {
  1261.             get_arg(arg, sizeof(arg), &p);
  1262.             if (stream) {
  1263.                 video_enc.rate = atoi(arg);
  1264.             }
  1265.         } else if (!strcasecmp(cmd, "VideoGopSize")) {
  1266.             get_arg(arg, sizeof(arg), &p);
  1267.             if (stream) {
  1268.                 video_enc.gop_size = atoi(arg);
  1269.             }
  1270.         } else if (!strcasecmp(cmd, "VideoIntraOnly")) {
  1271.             if (stream) {
  1272.                 video_enc.gop_size = 1;
  1273.             }
  1274.         } else if (!strcasecmp(cmd, "</Stream>")) {
  1275.             if (!stream) {
  1276.                 fprintf(stderr, "%s:%d: No corresponding <Stream> for </Stream>n",
  1277.                         filename, line_num);
  1278.                 errors++;
  1279.             }
  1280.             if (stream->fmt) {
  1281.                 if (stream->fmt->audio_codec != CODEC_ID_NONE) {
  1282.                     stream->audio_enc = add_codec(stream->fmt->audio_codec,
  1283.                                                   &audio_enc);
  1284.                 }
  1285.                 
  1286.                 if (stream->fmt->video_codec != CODEC_ID_NONE)
  1287.                     stream->video_enc = add_codec(stream->fmt->video_codec,
  1288.                                                   &video_enc);
  1289.             }
  1290.             stream = NULL;
  1291.         } else {
  1292.             fprintf(stderr, "%s:%d: Incorrect keyword: '%s'n", 
  1293.                     filename, line_num, cmd);
  1294.             errors++;
  1295.         }
  1296.     }
  1298.     fclose(f);
  1299.     if (errors)
  1300.         return -1;
  1301.     else
  1302.         return 0;
  1303. }
  1306. void *http_server_thread(void *arg)
  1307. {
  1308.     http_server(my_addr);
  1309.     return NULL;
  1310. }
  1312. static void write_packet(FFCodec *ffenc,
  1313.                          UINT8 *buf, int size)
  1314. {
  1315.     PacketHeader hdr;
  1316.     AVEncodeContext *enc = &ffenc->enc;
  1317.     UINT8 *wptr;
  1318.     mk_header(&hdr, enc, size);
  1319.     wptr = http_fifo.wptr;
  1320.     fifo_write(&http_fifo, (UINT8 *)&hdr, sizeof(hdr), &wptr);
  1321.     fifo_write(&http_fifo, buf, size, &wptr);
  1322.     /* atomic modification of wptr */
  1323.     http_fifo.wptr = wptr;
  1324.     ffenc->data_count += size;
  1325.     ffenc->avg_frame_size = ffenc->avg_frame_size * AVG_COEF + size * (1.0 - AVG_COEF);
  1326. }
  1328. #define AUDIO_FIFO_SIZE 8192
  1330. int av_grab(void)
  1331. {
  1332.     UINT8 audio_buf[AUDIO_FIFO_SIZE/2];
  1333.     UINT8 audio_buf1[AUDIO_FIFO_SIZE/2];
  1334.     UINT8 audio_out[AUDIO_FIFO_SIZE/2];
  1335.     UINT8 video_buffer[128*1024];
  1336.     char buf[256];
  1337.     short *samples;
  1338.     int ret;
  1339.     int audio_fd;
  1340.     FFCodec *ffenc;
  1341.     AVEncodeContext *enc;
  1342.     int frame_size, frame_bytes;
  1343.     int use_audio, use_video;
  1344.     int frame_rate, sample_rate, channels;
  1345.     int width, height, frame_number;
  1346.     UINT8 *picture[3];
  1348.     use_audio = 0;
  1349.     use_video = 0;
  1350.     frame_rate = 0;
  1351.     sample_rate = 0;
  1352.     frame_size = 0;
  1353.     channels = 1;
  1354.     width = 0;
  1355.     height = 0;
  1356.     frame_number = 0;
  1357.     ffenc = first_codec;
  1358.     while (ffenc != NULL) {
  1359.         enc = &ffenc->enc;
  1360.         avencoder_string(buf, sizeof(buf), enc);
  1361.         fprintf(stderr, "  %sn", buf);
  1362.         if (avencoder_open(enc, enc->codec) < 0) {
  1363.             fprintf(stderr, "Incorrect encode parametersn");
  1364.             return -1;
  1365.         }
  1366.         switch(enc->codec->type) {
  1367.         case CODEC_TYPE_AUDIO:
  1368.             use_audio = 1;
  1369.             if (enc->rate > sample_rate)
  1370.                 sample_rate = enc->rate;
  1371.             if (enc->frame_size > frame_size)
  1372.                 frame_size = enc->frame_size;
  1373.             if (enc->channels > channels)
  1374.                 channels = enc->channels;
  1375.             fifo_init(&ffenc->fifo, AUDIO_FIFO_SIZE);
  1376.             break;
  1377.         case CODEC_TYPE_VIDEO:
  1378.             use_video = 1;
  1379.             if (enc->rate > frame_rate)
  1380.                 frame_rate = enc->rate;
  1381.             if (enc->width > width)
  1382.                 width = enc->width;
  1383.             if (enc->height > height)
  1384.                 height = enc->height;
  1385.             break;
  1386.         }
  1387.         ffenc = ffenc->next;
  1388.     }
  1390.     /* audio */
  1391.     samples = NULL;
  1392.     audio_fd = -1;
  1393.     if (use_audio) {
  1394.         printf("Audio sampling: %d Hz, %sn", 
  1395.                sample_rate, channels == 2 ? "stereo" : "mono");
  1396.         audio_fd = audio_open(sample_rate, channels);
  1397.         if (audio_fd < 0) {
  1398.             fprintf(stderr, "Could not open audio devicen");
  1399.             exit(1);
  1400.         }
  1401.     }
  1402.     
  1403.     ffenc = first_codec;
  1404.     while (ffenc != NULL) {
  1405.         enc = &ffenc->enc;
  1406.         if (enc->codec->type == CODEC_TYPE_AUDIO &&
  1407.             (enc->channels != channels ||
  1408.              enc->rate != sample_rate)) {
  1409.             audio_resample_init(&ffenc->resample, enc->channels, channels,
  1410.                                 enc->rate, sample_rate);
  1411.         }
  1412.         ffenc = ffenc->next;
  1413.     }
  1415.     /* video */
  1416.     if (use_video) {
  1417.         printf("Video sampling: %dx%d, %d fpsn", 
  1418.                width, height, frame_rate);
  1419.         ret = v4l_init(frame_rate, width, height);
  1420.         if (ret < 0) {
  1421.             fprintf(stderr,"Could not init video 4 linux capturen");
  1422.             exit(1);
  1423.         }
  1424.     }
  1426.     for(;;) {
  1427.         /* read & compress audio frames */
  1428.         if (use_audio) {
  1429.             int ret, nb_samples, nb_samples_out;
  1430.             UINT8 *buftmp;
  1432.             for(;;) {
  1433.                 ret = read(audio_fd, audio_buf, AUDIO_FIFO_SIZE/2);
  1434.                 if (ret <= 0)
  1435.                     break;
  1436.                 /* fill each codec fifo by doing the right sample
  1437.                    rate conversion. This is not optimal because we
  1438.                    do too much work, but it is easy to do */
  1439.                 nb_samples = ret / (channels * 2);
  1440.                 ffenc = first_codec;
  1441.                 while (ffenc != NULL) {
  1442.                     enc = &ffenc->enc;
  1443.                     if (enc->codec->type == CODEC_TYPE_AUDIO) {
  1444.                         /* rate & stereo convertion */
  1445.                         if (enc->channels == channels &&
  1446.                             enc->rate == sample_rate) {
  1447.                             buftmp = audio_buf;
  1448.                             nb_samples_out = nb_samples;
  1449.                         } else {
  1450.                             buftmp = audio_buf1;
  1451.                             nb_samples_out = audio_resample(&ffenc->resample, 
  1452.                                                             (short *)buftmp, (short *)audio_buf,
  1453.                                                             nb_samples);
  1454.                             
  1455.                         }
  1456.                         fifo_write(&ffenc->fifo, buftmp, nb_samples_out * enc->channels * 2, 
  1457.                                    &ffenc->fifo.wptr);
  1458.                     }
  1459.                     ffenc = ffenc->next;
  1460.                 }
  1461.                 
  1462.                 /* compress as many frame as possible with each audio codec */
  1463.                 ffenc = first_codec;
  1464.                 while (ffenc != NULL) {
  1465.                     enc = &ffenc->enc;
  1466.                     if (enc->codec->type == CODEC_TYPE_AUDIO) {
  1467.                         frame_bytes = enc->frame_size * 2 * enc->channels;
  1468.                         
  1469.                         while (fifo_read(&ffenc->fifo, audio_buf, frame_bytes, &ffenc->fifo.rptr) == 0) {
  1470.                             ret = avencoder_encode(enc,
  1471.                                                    audio_out, sizeof(audio_out), audio_buf);
  1472.                             write_packet(ffenc, audio_out, ret);
  1473.                         }
  1474.                     }
  1475.                     ffenc = ffenc->next;
  1476.                 }
  1477.             }
  1478.         }
  1480.         if (use_video) {
  1481.             ret = v4l_read_picture (picture, width, height, 
  1482.                                     frame_number);
  1483.             if (ret < 0)
  1484.                 break;
  1485.             ffenc = first_codec;
  1486.             while (ffenc != NULL) {
  1487.                 enc = &ffenc->enc;
  1488.                 if (enc->codec->type == CODEC_TYPE_VIDEO) {
  1489.                     int n1, n2;
  1490.                     /* feed each codec with its requested frame rate */
  1491.                     n1 = (frame_number * enc->rate) / frame_rate;
  1492.                     n2 = ((frame_number + 1) * enc->rate) / frame_rate;
  1493.                     if (n2 > n1) {
  1494.                         ret = avencoder_encode(enc, video_buffer, sizeof(video_buffer), picture);
  1495.                         write_packet(ffenc, video_buffer, ret);
  1496.                     }
  1497.                 }
  1498.                 ffenc = ffenc->next;
  1499.             }
  1500.             frame_number++;
  1501.         }
  1502.     }
  1503.     
  1504.     ffenc = first_codec;
  1505.     while (ffenc != NULL) {
  1506.         enc = &ffenc->enc;
  1507.         avencoder_close(enc);
  1508.         ffenc = ffenc->next;
  1509.     }
  1510.     close(audio_fd);
  1511.     return 0;
  1512. }
  1515. void help(void)
  1516. {
  1517.     printf("ffserver version " FFMPEG_VERSION ", Copyright (c) 2000,2001 Gerard Lantaun"
  1518.            "usage: ffserver [-L] [-h] [-f configfile]n"
  1519.            "Hyper fast multi format Audio/Video streaming servern"
  1520.            "n"
  1521.            "-L            : print the LICENCEn"
  1522.            "-h            : this helpn"
  1523.            "-f configfile : use configfile instead of /etc/ffserver.confn"
  1524.            );
  1525. }
  1527. void licence(void)
  1528. {
  1529.     printf(
  1530.     "ffserver version " FFMPEG_VERSION "n"
  1531.     "Copyright (c) 2000,2001 Gerard Lantaun"
  1532.     "This program is free software; you can redistribute it and/or modifyn"
  1533.     "it under the terms of the GNU General Public License as published byn"
  1534.     "the Free Software Foundation; either version 2 of the License, orn"
  1535.     "(at your option) any later version.n"
  1536.     "n"
  1537.     "This program is distributed in the hope that it will be useful,n"
  1538.     "but WITHOUT ANY WARRANTY; without even the implied warranty ofn"
  1539.     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See then"
  1540.     "GNU General Public License for more details.n"
  1541.     "n"
  1542.     "You should have received a copy of the GNU General Public Licensen"
  1543.     "along with this program; if not, write to the Free Softwaren"
  1544.     "Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.n"
  1545.     );
  1546. }
  1548. int main(int argc, char **argv)
  1549. {
  1550.     pthread_t http_server_tid;
  1551.     const char *config_filename;
  1552.     int c;
  1554.     /* codecs */
  1555.     register_avencoder(&ac3_encoder);
  1556.     register_avencoder(&mp2_encoder);
  1557.     register_avencoder(&mpeg1video_encoder);
  1558.     register_avencoder(&h263_encoder);
  1559.     register_avencoder(&rv10_encoder);
  1560.     register_avencoder(&mjpeg_encoder);
  1561.     register_avencoder(&divx_encoder);
  1563.     /* audio video formats */
  1564.     register_avformat(&mp2_format);
  1565.     register_avformat(&ac3_format);
  1566.     register_avformat(&mpeg_mux_format);
  1567.     register_avformat(&mpeg1video_format);
  1568.     register_avformat(&h263_format);
  1569.     register_avformat(&rm_format);
  1570.     register_avformat(&ra_format);
  1571.     register_avformat(&asf_format);
  1572.     register_avformat(&avi_format);
  1573.     register_avformat(&mpjpeg_format);
  1574.     register_avformat(&jpeg_format);
  1575.     register_avformat(&swf_format);
  1577.     config_filename = "/etc/ffserver.conf";
  1579.     for(;;) {
  1580.         c = getopt_long_only(argc, argv, "Lh?f:", NULL, NULL);
  1581.         if (c == -1)
  1582.             break;
  1583.         switch(c) {
  1584.         case 'L':
  1585.             licence();
  1586.             exit(1);
  1587.         case '?':
  1588.         case 'h':
  1589.             help();
  1590.             exit(1);
  1591.         case 'f':
  1592.             config_filename = optarg;
  1593.             break;
  1594.         default:
  1595.             exit(2);
  1596.         }
  1597.     }
  1599.     /* address on which the server will handle connections */
  1600.     my_addr.sin_family = AF_INET;
  1601.     my_addr.sin_port = htons (8080);
  1602.     my_addr.sin_addr.s_addr = htonl (INADDR_ANY);
  1603.     nb_max_connections = 5;
  1604.     first_stream = NULL;
  1605.     logfilename[0] = '';
  1607.     if (parse_ffconfig(config_filename) < 0) {
  1608.         fprintf(stderr, "Incorrect config file - exiting.n");
  1609.         exit(1);
  1610.     }
  1612.     /* signal init */
  1613.     signal(SIGPIPE, SIG_IGN);
  1615.     /* open log file if needed */
  1616.     if (logfilename[0] != '') {
  1617.         if (!strcmp(logfilename, "-"))
  1618.             logfile = stdout;
  1619.         else
  1620.             logfile = fopen(logfilename, "w");
  1621.     }
  1623.     /* init fifo */
  1624.     http_fifo_write_count = 0;
  1625.     if (fifo_init(&http_fifo, FIFO_MAX_SIZE) < 0) {
  1626.         fprintf(stderr, "Could not allow receive fifon");
  1627.         exit(1);
  1628.     }
  1630.     if (master_url[0] == '') {
  1631.         /* no master server: we grab ourself */
  1633.         /* launch server thread */
  1634.         if (pthread_create(&http_server_tid, NULL, 
  1635.                            http_server_thread, NULL) != 0) {
  1636.             fprintf(stderr, "Could not create http server threadn");
  1637.             exit(1);
  1638.         }
  1640.         /* launch the audio / video grab */
  1641.         if (av_grab() < 0) {
  1642.             fprintf(stderr, "Could not start audio/video grabn");
  1643.             exit(1);
  1644.         }
  1645.     } else {
  1646.         /* master server : no thread are needed */
  1647.         if (http_server(my_addr) < 0) {
  1648.             fprintf(stderr, "Could start http servern");
  1649.             exit(1);
  1650.         }
  1651.     }
  1653.     return 0;
  1654. }