@@ -14,7 +14,7 @@ doxy

 ffmpeg

 avplay

 avprobe

-ffserver

+avserver

 libavcodec/*_tablegen

 libavcodec/*_tables.c

 libavcodec/*_tables.h

@@ -5,7 +5,7 @@ releases are sorted from youngest to oldest.

 version <next>:

 - BWF muxer

 - Flash Screen Video 2 decoder

-- ffplay/ffprobe renamed to avplay/avprobe

+- ffplay/ffprobe/ffserver renamed to avplay/avprobe/avserver

 version 0.7:

@@ -55,7 +55,7 @@ COMPILE_S = $(call COMPILE,AS)

 PROGS-$(CONFIG_FFMPEG)   += ffmpeg

 PROGS-$(CONFIG_AVPLAY)   += avplay

 PROGS-$(CONFIG_AVPROBE)  += avprobe

-PROGS-$(CONFIG_FFSERVER) += ffserver

+PROGS-$(CONFIG_AVSERVER) += avserver

 PROGS      := $(PROGS-yes:%=%$(EXESUF))

 OBJS        = $(PROGS-yes:%=%.o) cmdutils.o

@@ -64,7 +64,7 @@ HOSTPROGS  := $(TESTTOOLS:%=tests/%)

 TOOLS       = qt-faststart trasher

 TOOLS-$(CONFIG_ZLIB) += cws2fws

-BASENAMES   = ffmpeg avplay avprobe ffserver

+BASENAMES   = ffmpeg avplay avprobe avserver

 ALLPROGS    = $(BASENAMES:%=%$(EXESUF))

 ALLMANPAGES = $(BASENAMES:%=%.1)

@@ -118,7 +118,7 @@ $(foreach D,$(FFLIBS),$(eval $(call DOSUBDIR,lib$(D))))

 avplay.o: CFLAGS += $(SDL_CFLAGS)

 avplay$(EXESUF): FF_EXTRALIBS += $(SDL_LIBS)

-ffserver$(EXESUF): LDFLAGS += $(FFSERVERLDFLAGS)

+avserver$(EXESUF): LDFLAGS += $(AVSERVERLDFLAGS)

 $(PROGS): %$(EXESUF): %.o cmdutils.o $(FF_DEP_LIBS)

 	$(LD) $(LDFLAGS) -o $@ $< cmdutils.o $(FF_EXTRALIBS)

new file mode 100644

@@ -0,0 +1,4742 @@

+/*

+ * Multiple format streaming server

+ * Copyright (c) 2000, 2001, 2002 Fabrice Bellard

+ *

+ * This file is part of Libav.

+ *

+ * Libav is free software; you can redistribute it and/or

+ * modify it under the terms of the GNU Lesser General Public

+ * License as published by the Free Software Foundation; either

+ * version 2.1 of the License, or (at your option) any later version.

+ *

+ * Libav is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

+ * Lesser General Public License for more details.

+ *

+ * You should have received a copy of the GNU Lesser General Public

+ * License along with Libav; if not, write to the Free Software

+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

+ */

+

+#include "config.h"

+#if !HAVE_CLOSESOCKET

+#define closesocket close

+#endif

+#include <string.h>

+#include <strings.h>

+#include <stdlib.h>

+#include "libavformat/avformat.h"

+#include "libavformat/ffm.h"

+#include "libavformat/network.h"

+#include "libavformat/os_support.h"

+#include "libavformat/rtpdec.h"

+#include "libavformat/rtsp.h"

+// XXX for ffio_open_dyn_packet_buffer, to be removed

+#include "libavformat/avio_internal.h"

+#include "libavutil/avstring.h"

+#include "libavutil/lfg.h"

+#include "libavutil/dict.h"

+#include "libavutil/mathematics.h"

+#include "libavutil/random_seed.h"

+#include "libavutil/parseutils.h"

+#include "libavutil/opt.h"

+#include <stdarg.h>

+#include <unistd.h>

+#include <fcntl.h>

+#include <sys/ioctl.h>

+#if HAVE_POLL_H

+#include <poll.h>

+#endif

+#include <errno.h>

+#include <sys/time.h>

+#include <time.h>

+#include <sys/wait.h>

+#include <signal.h>

+#if HAVE_DLFCN_H

+#include <dlfcn.h>

+#endif

+

+#include "cmdutils.h"

+

+const char program_name[] = "avserver";

+const int program_birth_year = 2000;

+

+static const OptionDef options[];

+

+enum HTTPState {

+    HTTPSTATE_WAIT_REQUEST,

+    HTTPSTATE_SEND_HEADER,

+    HTTPSTATE_SEND_DATA_HEADER,

+    HTTPSTATE_SEND_DATA,          /* sending TCP or UDP data */

+    HTTPSTATE_SEND_DATA_TRAILER,

+    HTTPSTATE_RECEIVE_DATA,

+    HTTPSTATE_WAIT_FEED,          /* wait for data from the feed */

+    HTTPSTATE_READY,

+

+    RTSPSTATE_WAIT_REQUEST,

+    RTSPSTATE_SEND_REPLY,

+    RTSPSTATE_SEND_PACKET,

+};

+

+static const char *http_state[] = {

+    "HTTP_WAIT_REQUEST",

+    "HTTP_SEND_HEADER",

+

+    "SEND_DATA_HEADER",

+    "SEND_DATA",

+    "SEND_DATA_TRAILER",

+    "RECEIVE_DATA",

+    "WAIT_FEED",

+    "READY",

+

+    "RTSP_WAIT_REQUEST",

+    "RTSP_SEND_REPLY",

+    "RTSP_SEND_PACKET",

+};

+

+#define MAX_STREAMS 20

+

+#define IOBUFFER_INIT_SIZE 8192

+

+/* timeouts are in ms */

+#define HTTP_REQUEST_TIMEOUT (15 * 1000)

+#define RTSP_REQUEST_TIMEOUT (3600 * 24 * 1000)

+

+#define SYNC_TIMEOUT (10 * 1000)

+

+typedef struct RTSPActionServerSetup {

+    uint32_t ipaddr;

+    char transport_option[512];

+} RTSPActionServerSetup;

+

+typedef struct {

+    int64_t count1, count2;

+    int64_t time1, time2;

+} DataRateData;

+

+/* context associated with one connection */

+typedef struct HTTPContext {

+    enum HTTPState state;

+    int fd; /* socket file descriptor */

+    struct sockaddr_in from_addr; /* origin */

+    struct pollfd *poll_entry; /* used when polling */

+    int64_t timeout;

+    uint8_t *buffer_ptr, *buffer_end;

+    int http_error;

+    int post;

+    int chunked_encoding;

+    int chunk_size;               /* 0 if it needs to be read */

+    struct HTTPContext *next;

+    int got_key_frame; /* stream 0 => 1, stream 1 => 2, stream 2=> 4 */

+    int64_t data_count;

+    /* feed input */

+    int feed_fd;

+    /* input format handling */

+    AVFormatContext *fmt_in;

+    int64_t start_time;            /* In milliseconds - this wraps fairly often */

+    int64_t first_pts;            /* initial pts value */

+    int64_t cur_pts;             /* current pts value from the stream in us */

+    int64_t cur_frame_duration;  /* duration of the current frame in us */

+    int cur_frame_bytes;       /* output frame size, needed to compute

+                                  the time at which we send each

+                                  packet */

+    int pts_stream_index;        /* stream we choose as clock reference */

+    int64_t cur_clock;           /* current clock reference value in us */

+    /* output format handling */

+    struct FFStream *stream;

+    /* -1 is invalid stream */

+    int feed_streams[MAX_STREAMS]; /* index of streams in the feed */

+    int switch_feed_streams[MAX_STREAMS]; /* index of streams in the feed */

+    int switch_pending;

+    AVFormatContext fmt_ctx; /* instance of FFStream for one user */

+    int last_packet_sent; /* true if last data packet was sent */

+    int suppress_log;

+    DataRateData datarate;

+    int wmp_client_id;

+    char protocol[16];

+    char method[16];

+    char url[128];

+    int buffer_size;

+    uint8_t *buffer;

+    int is_packetized; /* if true, the stream is packetized */

+    int packet_stream_index; /* current stream for output in state machine */

+

+    /* RTSP state specific */

+    uint8_t *pb_buffer; /* XXX: use that in all the code */

+    AVIOContext *pb;

+    int seq; /* RTSP sequence number */

+

+    /* RTP state specific */

+    enum RTSPLowerTransport rtp_protocol;

+    char session_id[32]; /* session id */

+    AVFormatContext *rtp_ctx[MAX_STREAMS];

+

+    /* RTP/UDP specific */

+    URLContext *rtp_handles[MAX_STREAMS];

+

+    /* RTP/TCP specific */

+    struct HTTPContext *rtsp_c;

+    uint8_t *packet_buffer, *packet_buffer_ptr, *packet_buffer_end;

+} HTTPContext;

+

+/* each generated stream is described here */

+enum StreamType {

+    STREAM_TYPE_LIVE,

+    STREAM_TYPE_STATUS,

+    STREAM_TYPE_REDIRECT,

+};

+

+enum IPAddressAction {

+    IP_ALLOW = 1,

+    IP_DENY,

+};

+

+typedef struct IPAddressACL {

+    struct IPAddressACL *next;

+    enum IPAddressAction action;

+    /* These are in host order */

+    struct in_addr first;

+    struct in_addr last;

+} IPAddressACL;

+

+/* description of each stream of the avserver.conf file */

+typedef struct FFStream {

+    enum StreamType stream_type;

+    char filename[1024];     /* stream filename */

+    struct FFStream *feed;   /* feed we are using (can be null if

+                                coming from file) */

+    AVDictionary *in_opts;   /* input parameters */

+    AVInputFormat *ifmt;       /* if non NULL, force input format */

+    AVOutputFormat *fmt;

+    IPAddressACL *acl;

+    char dynamic_acl[1024];

+    int nb_streams;

+    int prebuffer;      /* Number of millseconds early to start */

+    int64_t max_time;      /* Number of milliseconds to run */

+    int send_on_key;

+    AVStream *streams[MAX_STREAMS];

+    int feed_streams[MAX_STREAMS]; /* index of streams in the feed */

+    char feed_filename[1024]; /* file name of the feed storage, or

+                                 input file name for a stream */

+    char author[512];

+    char title[512];

+    char copyright[512];

+    char comment[512];

+    pid_t pid;  /* Of ffmpeg process */

+    time_t pid_start;  /* Of ffmpeg process */

+    char **child_argv;

+    struct FFStream *next;

+    unsigned bandwidth; /* bandwidth, in kbits/s */

+    /* RTSP options */

+    char *rtsp_option;

+    /* multicast specific */

+    int is_multicast;

+    struct in_addr multicast_ip;

+    int multicast_port; /* first port used for multicast */

+    int multicast_ttl;

+    int loop; /* if true, send the stream in loops (only meaningful if file) */

+

+    /* feed specific */

+    int feed_opened;     /* true if someone is writing to the feed */

+    int is_feed;         /* true if it is a feed */

+    int readonly;        /* True if writing is prohibited to the file */

+    int truncate;        /* True if feeder connection truncate the feed file */

+    int conns_served;

+    int64_t bytes_served;

+    int64_t feed_max_size;      /* maximum storage size, zero means unlimited */

+    int64_t feed_write_index;   /* current write position in feed (it wraps around) */

+    int64_t feed_size;          /* current size of feed */

+    struct FFStream *next_feed;

+} FFStream;

+

+typedef struct FeedData {

+    long long data_count;

+    float avg_frame_size;   /* frame size averaged over last frames with exponential mean */

+} FeedData;

+

+static struct sockaddr_in my_http_addr;

+static struct sockaddr_in my_rtsp_addr;

+

+static char logfilename[1024];

+static HTTPContext *first_http_ctx;

+static FFStream *first_feed;   /* contains only feeds */

+static FFStream *first_stream; /* contains all streams, including feeds */

+

+static void new_connection(int server_fd, int is_rtsp);

+static void close_connection(HTTPContext *c);

+

+/* HTTP handling */

+static int handle_connection(HTTPContext *c);

+static int http_parse_request(HTTPContext *c);

+static int http_send_data(HTTPContext *c);

+static void compute_status(HTTPContext *c);

+static int open_input_stream(HTTPContext *c, const char *info);

+static int http_start_receive_data(HTTPContext *c);

+static int http_receive_data(HTTPContext *c);

+

+/* RTSP handling */

+static int rtsp_parse_request(HTTPContext *c);

+static void rtsp_cmd_describe(HTTPContext *c, const char *url);

+static void rtsp_cmd_options(HTTPContext *c, const char *url);

+static void rtsp_cmd_setup(HTTPContext *c, const char *url, RTSPMessageHeader *h);

+static void rtsp_cmd_play(HTTPContext *c, const char *url, RTSPMessageHeader *h);

+static void rtsp_cmd_pause(HTTPContext *c, const char *url, RTSPMessageHeader *h);

+static void rtsp_cmd_teardown(HTTPContext *c, const char *url, RTSPMessageHeader *h);

+

+/* SDP handling */

+static int prepare_sdp_description(FFStream *stream, uint8_t **pbuffer,

+                                   struct in_addr my_ip);

+

+/* RTP handling */

+static HTTPContext *rtp_new_connection(struct sockaddr_in *from_addr,

+                                       FFStream *stream, const char *session_id,

+                                       enum RTSPLowerTransport rtp_protocol);

+static int rtp_new_av_stream(HTTPContext *c,

+                             int stream_index, struct sockaddr_in *dest_addr,

+                             HTTPContext *rtsp_c);

+

+static const char *my_program_name;

+static const char *my_program_dir;

+

+static const char *config_filename = "/etc/avserver.conf";

+

+static int avserver_debug;

+static int avserver_daemon;

+static int no_launch;

+static int need_to_start_children;

+

+/* maximum number of simultaneous HTTP connections */

+static unsigned int nb_max_http_connections = 2000;

+static unsigned int nb_max_connections = 5;

+static unsigned int nb_connections;

+

+static uint64_t max_bandwidth = 1000;

+static uint64_t current_bandwidth;

+

+static int64_t cur_time;           // Making this global saves on passing it around everywhere

+

+static AVLFG random_state;

+

+static FILE *logfile = NULL;

+

+/* FIXME: make avserver work with IPv6 */

+/* resolve host with also IP address parsing */

+static int resolve_host(struct in_addr *sin_addr, const char *hostname)

+{

+

+    if (!ff_inet_aton(hostname, sin_addr)) {

+#if HAVE_GETADDRINFO

+        struct addrinfo *ai, *cur;

+        struct addrinfo hints;

+        memset(&hints, 0, sizeof(hints));

+        hints.ai_family = AF_INET;

+        if (getaddrinfo(hostname, NULL, &hints, &ai))

+            return -1;

+        /* getaddrinfo returns a linked list of addrinfo structs.

+         * Even if we set ai_family = AF_INET above, make sure

+         * that the returned one actually is of the correct type. */

+        for (cur = ai; cur; cur = cur->ai_next) {

+            if (cur->ai_family == AF_INET) {

+                *sin_addr = ((struct sockaddr_in *)cur->ai_addr)->sin_addr;

+                freeaddrinfo(ai);

+                return 0;

+            }

+        }

+        freeaddrinfo(ai);

+        return -1;

+#else

+        struct hostent *hp;

+        hp = gethostbyname(hostname);

+        if (!hp)

+            return -1;

+        memcpy(sin_addr, hp->h_addr_list[0], sizeof(struct in_addr));

+#endif

+    }

+    return 0;

+}

+

+static char *ctime1(char *buf2)

+{

+    time_t ti;

+    char *p;

+

+    ti = time(NULL);

+    p = ctime(&ti);

+    strcpy(buf2, p);

+    p = buf2 + strlen(p) - 1;

+    if (*p == '\n')

+        *p = '\0';

+    return buf2;

+}

+

+static void http_vlog(const char *fmt, va_list vargs)

+{

+    static int print_prefix = 1;

+    if (logfile) {

+        if (print_prefix) {

+            char buf[32];

+            ctime1(buf);

+            fprintf(logfile, "%s ", buf);

+        }

+        print_prefix = strstr(fmt, "\n") != NULL;

+        vfprintf(logfile, fmt, vargs);

+        fflush(logfile);

+    }

+}

+

+#ifdef __GNUC__

+__attribute__ ((format (printf, 1, 2)))

+#endif

+static void http_log(const char *fmt, ...)

+{

+    va_list vargs;

+    va_start(vargs, fmt);

+    http_vlog(fmt, vargs);

+    va_end(vargs);

+}

+

+static void http_av_log(void *ptr, int level, const char *fmt, va_list vargs)

+{

+    static int print_prefix = 1;

+    AVClass *avc = ptr ? *(AVClass**)ptr : NULL;

+    if (level > av_log_get_level())

+        return;

+    if (print_prefix && avc)

+        http_log("[%s @ %p]", avc->item_name(ptr), ptr);

+    print_prefix = strstr(fmt, "\n") != NULL;

+    http_vlog(fmt, vargs);

+}

+

+static void log_connection(HTTPContext *c)

+{

+    if (c->suppress_log)

+        return;

+

+    http_log("%s - - [%s] \"%s %s\" %d %"PRId64"\n",

+             inet_ntoa(c->from_addr.sin_addr), c->method, c->url,

+             c->protocol, (c->http_error ? c->http_error : 200), c->data_count);

+}

+

+static void update_datarate(DataRateData *drd, int64_t count)

+{

+    if (!drd->time1 && !drd->count1) {

+        drd->time1 = drd->time2 = cur_time;

+        drd->count1 = drd->count2 = count;

+    } else if (cur_time - drd->time2 > 5000) {

+        drd->time1 = drd->time2;

+        drd->count1 = drd->count2;

+        drd->time2 = cur_time;

+        drd->count2 = count;

+    }

+}

+

+/* In bytes per second */

+static int compute_datarate(DataRateData *drd, int64_t count)

+{

+    if (cur_time == drd->time1)

+        return 0;

+

+    return ((count - drd->count1) * 1000) / (cur_time - drd->time1);

+}

+

+

+static void start_children(FFStream *feed)

+{

+    if (no_launch)

+        return;

+

+    for (; feed; feed = feed->next) {

+        if (feed->child_argv && !feed->pid) {

+            feed->pid_start = time(0);

+

+            feed->pid = fork();

+

+            if (feed->pid < 0) {

+                http_log("Unable to create children\n");

+                exit(1);

+            }

+            if (!feed->pid) {

+                /* In child */

+                char pathname[1024];

+                char *slash;

+                int i;

+

+                av_strlcpy(pathname, my_program_name, sizeof(pathname));

+

+                slash = strrchr(pathname, '/');

+                if (!slash)

+                    slash = pathname;

+                else

+                    slash++;

+                strcpy(slash, "ffmpeg");

+

+                http_log("Launch commandline: ");

+                http_log("%s ", pathname);

+                for (i = 1; feed->child_argv[i] && feed->child_argv[i][0]; i++)

+                    http_log("%s ", feed->child_argv[i]);

+                http_log("\n");

+

+                for (i = 3; i < 256; i++)

+                    close(i);

+

+                if (!avserver_debug) {

+                    i = open("/dev/null", O_RDWR);

+                    if (i != -1) {

+                        dup2(i, 0);

+                        dup2(i, 1);

+                        dup2(i, 2);

+                        close(i);

+                    }

+                }

+

+                /* This is needed to make relative pathnames work */

+                chdir(my_program_dir);

+

+                signal(SIGPIPE, SIG_DFL);

+

+                execvp(pathname, feed->child_argv);

+

+                _exit(1);

+            }

+        }

+    }

+}

+

+/* open a listening socket */

+static int socket_open_listen(struct sockaddr_in *my_addr)

+{

+    int server_fd, tmp;

+

+    server_fd = socket(AF_INET,SOCK_STREAM,0);

+    if (server_fd < 0) {

+        perror ("socket");

+        return -1;

+    }

+

+    tmp = 1;

+    setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &tmp, sizeof(tmp));

+

+    if (bind (server_fd, (struct sockaddr *) my_addr, sizeof (*my_addr)) < 0) {

+        char bindmsg[32];

+        snprintf(bindmsg, sizeof(bindmsg), "bind(port %d)", ntohs(my_addr->sin_port));

+        perror (bindmsg);

+        closesocket(server_fd);

+        return -1;

+    }

+

+    if (listen (server_fd, 5) < 0) {

+        perror ("listen");

+        closesocket(server_fd);

+        return -1;

+    }

+    ff_socket_nonblock(server_fd, 1);

+

+    return server_fd;

+}

+

+/* start all multicast streams */

+static void start_multicast(void)

+{

+    FFStream *stream;

+    char session_id[32];

+    HTTPContext *rtp_c;

+    struct sockaddr_in dest_addr;

+    int default_port, stream_index;

+

+    default_port = 6000;

+    for(stream = first_stream; stream != NULL; stream = stream->next) {

+        if (stream->is_multicast) {

+            /* open the RTP connection */

+            snprintf(session_id, sizeof(session_id), "%08x%08x",

+                     av_lfg_get(&random_state), av_lfg_get(&random_state));

+

+            /* choose a port if none given */

+            if (stream->multicast_port == 0) {

+                stream->multicast_port = default_port;

+                default_port += 100;

+            }

+

+            dest_addr.sin_family = AF_INET;

+            dest_addr.sin_addr = stream->multicast_ip;

+            dest_addr.sin_port = htons(stream->multicast_port);

+

+            rtp_c = rtp_new_connection(&dest_addr, stream, session_id,

+                                       RTSP_LOWER_TRANSPORT_UDP_MULTICAST);

+            if (!rtp_c)

+                continue;

+

+            if (open_input_stream(rtp_c, "") < 0) {

+                http_log("Could not open input stream for stream '%s'\n",

+                         stream->filename);

+                continue;

+            }

+

+            /* open each RTP stream */

+            for(stream_index = 0; stream_index < stream->nb_streams;

+                stream_index++) {

+                dest_addr.sin_port = htons(stream->multicast_port +

+                                           2 * stream_index);

+                if (rtp_new_av_stream(rtp_c, stream_index, &dest_addr, NULL) < 0) {

+                    http_log("Could not open output stream '%s/streamid=%d'\n",

+                             stream->filename, stream_index);

+                    exit(1);

+                }

+            }

+

+            /* change state to send data */

+            rtp_c->state = HTTPSTATE_SEND_DATA;

+        }

+    }

+}

+

+/* main loop of the http server */

+static int http_server(void)

+{

+    int server_fd = 0, rtsp_server_fd = 0;

+    int ret, delay, delay1;

+    struct pollfd *poll_table, *poll_entry;

+    HTTPContext *c, *c_next;

+

+    if(!(poll_table = av_mallocz((nb_max_http_connections + 2)*sizeof(*poll_table)))) {

+        http_log("Impossible to allocate a poll table handling %d connections.\n", nb_max_http_connections);

+        return -1;

+    }

+

+    if (my_http_addr.sin_port) {

+        server_fd = socket_open_listen(&my_http_addr);

+        if (server_fd < 0)

+            return -1;

+    }

+

+    if (my_rtsp_addr.sin_port) {

+        rtsp_server_fd = socket_open_listen(&my_rtsp_addr);

+        if (rtsp_server_fd < 0)

+            return -1;

+    }

+

+    if (!rtsp_server_fd && !server_fd) {

+        http_log("HTTP and RTSP disabled.\n");

+        return -1;

+    }

+

+    http_log("AVserver started.\n");

+

+    start_children(first_feed);

+

+    start_multicast();

+

+    for(;;) {

+        poll_entry = poll_table;

+        if (server_fd) {

+            poll_entry->fd = server_fd;

+            poll_entry->events = POLLIN;

+            poll_entry++;

+        }

+        if (rtsp_server_fd) {

+            poll_entry->fd = rtsp_server_fd;

+            poll_entry->events = POLLIN;

+            poll_entry++;

+        }

+

+        /* wait for events on each HTTP handle */

+        c = first_http_ctx;

+        delay = 1000;

+        while (c != NULL) {

+            int fd;

+            fd = c->fd;

+            switch(c->state) {

+            case HTTPSTATE_SEND_HEADER:

+            case RTSPSTATE_SEND_REPLY:

+            case RTSPSTATE_SEND_PACKET:

+                c->poll_entry = poll_entry;

+                poll_entry->fd = fd;

+                poll_entry->events = POLLOUT;

+                poll_entry++;

+                break;

+            case HTTPSTATE_SEND_DATA_HEADER:

+            case HTTPSTATE_SEND_DATA:

+            case HTTPSTATE_SEND_DATA_TRAILER:

+                if (!c->is_packetized) {

+                    /* for TCP, we output as much as we can (may need to put a limit) */

+                    c->poll_entry = poll_entry;

+                    poll_entry->fd = fd;

+                    poll_entry->events = POLLOUT;

+                    poll_entry++;

+                } else {

+                    /* when avserver is doing the timing, we work by

+                       looking at which packet need to be sent every

+                       10 ms */

+                    delay1 = 10; /* one tick wait XXX: 10 ms assumed */

+                    if (delay1 < delay)

+                        delay = delay1;

+                }

+                break;

+            case HTTPSTATE_WAIT_REQUEST:

+            case HTTPSTATE_RECEIVE_DATA:

+            case HTTPSTATE_WAIT_FEED:

+            case RTSPSTATE_WAIT_REQUEST:

+                /* need to catch errors */

+                c->poll_entry = poll_entry;

+                poll_entry->fd = fd;

+                poll_entry->events = POLLIN;/* Maybe this will work */

+                poll_entry++;

+                break;

+            default:

+                c->poll_entry = NULL;

+                break;

+            }

+            c = c->next;

+        }

+

+        /* wait for an event on one connection. We poll at least every

+           second to handle timeouts */

+        do {

+            ret = poll(poll_table, poll_entry - poll_table, delay);

+            if (ret < 0 && ff_neterrno() != AVERROR(EAGAIN) &&

+                ff_neterrno() != AVERROR(EINTR))

+                return -1;

+        } while (ret < 0);

+

+        cur_time = av_gettime() / 1000;

+

+        if (need_to_start_children) {

+            need_to_start_children = 0;

+            start_children(first_feed);

+        }

+

+        /* now handle the events */

+        for(c = first_http_ctx; c != NULL; c = c_next) {

+            c_next = c->next;

+            if (handle_connection(c) < 0) {

+                /* close and free the connection */

+                log_connection(c);

+                close_connection(c);

+            }

+        }

+

+        poll_entry = poll_table;

+        if (server_fd) {

+            /* new HTTP connection request ? */

+            if (poll_entry->revents & POLLIN)

+                new_connection(server_fd, 0);

+            poll_entry++;

+        }

+        if (rtsp_server_fd) {

+            /* new RTSP connection request ? */

+            if (poll_entry->revents & POLLIN)

+                new_connection(rtsp_server_fd, 1);

+        }

+    }

+}

+

+/* start waiting for a new HTTP/RTSP request */

+static void start_wait_request(HTTPContext *c, int is_rtsp)

+{

+    c->buffer_ptr = c->buffer;

+    c->buffer_end = c->buffer + c->buffer_size - 1; /* leave room for '\0' */

+

+    if (is_rtsp) {

+        c->timeout = cur_time + RTSP_REQUEST_TIMEOUT;

+        c->state = RTSPSTATE_WAIT_REQUEST;

+    } else {

+        c->timeout = cur_time + HTTP_REQUEST_TIMEOUT;

+        c->state = HTTPSTATE_WAIT_REQUEST;

+    }

+}

+

+static void http_send_too_busy_reply(int fd)

+{

+    char buffer[300];

+    int len = snprintf(buffer, sizeof(buffer),

+                       "HTTP/1.0 503 Server too busy\r\n"

+                       "Content-type: text/html\r\n"

+                       "\r\n"

+                       "<html><head><title>Too busy</title></head><body>\r\n"

+                       "<p>The server is too busy to serve your request at this time.</p>\r\n"

+                       "<p>The number of current connections is %d, and this exceeds the limit of %d.</p>\r\n"

+                       "</body></html>\r\n",

+                       nb_connections, nb_max_connections);

+    send(fd, buffer, len, 0);

+}

+

+

+static void new_connection(int server_fd, int is_rtsp)

+{

+    struct sockaddr_in from_addr;

+    int fd, len;

+    HTTPContext *c = NULL;

+

+    len = sizeof(from_addr);

+    fd = accept(server_fd, (struct sockaddr *)&from_addr,

+                &len);

+    if (fd < 0) {

+        http_log("error during accept %s\n", strerror(errno));

+        return;

+    }

+    ff_socket_nonblock(fd, 1);

+

+    if (nb_connections >= nb_max_connections) {

+        http_send_too_busy_reply(fd);

+        goto fail;

+    }

+

+    /* add a new connection */

+    c = av_mallocz(sizeof(HTTPContext));

+    if (!c)

+        goto fail;

+

+    c->fd = fd;

+    c->poll_entry = NULL;

+    c->from_addr = from_addr;

+    c->buffer_size = IOBUFFER_INIT_SIZE;

+    c->buffer = av_malloc(c->buffer_size);

+    if (!c->buffer)

+        goto fail;

+

+    c->next = first_http_ctx;

+    first_http_ctx = c;

+    nb_connections++;

+

+    start_wait_request(c, is_rtsp);

+

+    return;

+

+ fail:

+    if (c) {

+        av_free(c->buffer);

+        av_free(c);

+    }

+    closesocket(fd);

+}

+

+static void close_connection(HTTPContext *c)

+{

+    HTTPContext **cp, *c1;

+    int i, nb_streams;

+    AVFormatContext *ctx;

+    URLContext *h;

+    AVStream *st;

+

+    /* remove connection from list */

+    cp = &first_http_ctx;

+    while ((*cp) != NULL) {

+        c1 = *cp;

+        if (c1 == c)

+            *cp = c->next;