Rename ffserver to avserver.

Anton Khirnov committed 15 years ago

Commit 4d58e4c1 parent 9e12f0b16 files · +102 −102Browse files

Showing the changes to avserver.c (1 of 16 files). Show all

Unified · Split

@@ -0,0 +1,4742 @@
	1	+/*
	2	+ * Multiple format streaming server
	3	+ * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
	4	+ *
	5	+ * This file is part of Libav.
	6	+ *
	7	+ * Libav is free software; you can redistribute it and/or
	8	+ * modify it under the terms of the GNU Lesser General Public
	9	+ * License as published by the Free Software Foundation; either
	10	+ * version 2.1 of the License, or (at your option) any later version.
	11	+ *
	12	+ * Libav is distributed in the hope that it will be useful,
	13	+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	15	+ * Lesser General Public License for more details.
	16	+ *
	17	+ * You should have received a copy of the GNU Lesser General Public
	18	+ * License along with Libav; if not, write to the Free Software
	19	+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
	20	+ */
	21	+
	22	+#include "config.h"
	23	+#if !HAVE_CLOSESOCKET
	24	+#define closesocket close
	25	+#endif
	26	+#include <string.h>
	27	+#include <strings.h>
	28	+#include <stdlib.h>
	29	+#include "libavformat/avformat.h"
	30	+#include "libavformat/ffm.h"
	31	+#include "libavformat/network.h"
	32	+#include "libavformat/os_support.h"
	33	+#include "libavformat/rtpdec.h"
	34	+#include "libavformat/rtsp.h"
	35	+// XXX for ffio_open_dyn_packet_buffer, to be removed
	36	+#include "libavformat/avio_internal.h"
	37	+#include "libavutil/avstring.h"
	38	+#include "libavutil/lfg.h"
	39	+#include "libavutil/dict.h"
	40	+#include "libavutil/mathematics.h"
	41	+#include "libavutil/random_seed.h"
	42	+#include "libavutil/parseutils.h"
	43	+#include "libavutil/opt.h"
	44	+#include <stdarg.h>
	45	+#include <unistd.h>
	46	+#include <fcntl.h>
	47	+#include <sys/ioctl.h>
	48	+#if HAVE_POLL_H
	49	+#include <poll.h>
	50	+#endif
	51	+#include <errno.h>
	52	+#include <sys/time.h>
	53	+#include <time.h>
	54	+#include <sys/wait.h>
	55	+#include <signal.h>
	56	+#if HAVE_DLFCN_H
	57	+#include <dlfcn.h>
	58	+#endif
	59	+
	60	+#include "cmdutils.h"
	61	+
	62	+const char program_name[] = "avserver";
	63	+const int program_birth_year = 2000;
	64	+
	65	+static const OptionDef options[];
	66	+
	67	+enum HTTPState {
	68	+ HTTPSTATE_WAIT_REQUEST,
	69	+ HTTPSTATE_SEND_HEADER,
	70	+ HTTPSTATE_SEND_DATA_HEADER,
	71	+ HTTPSTATE_SEND_DATA, /* sending TCP or UDP data */
	72	+ HTTPSTATE_SEND_DATA_TRAILER,
	73	+ HTTPSTATE_RECEIVE_DATA,
	74	+ HTTPSTATE_WAIT_FEED, /* wait for data from the feed */
	75	+ HTTPSTATE_READY,
	76	+
	77	+ RTSPSTATE_WAIT_REQUEST,
	78	+ RTSPSTATE_SEND_REPLY,
	79	+ RTSPSTATE_SEND_PACKET,
	80	+};
	81	+
	82	+static const char *http_state[] = {
	83	+ "HTTP_WAIT_REQUEST",
	84	+ "HTTP_SEND_HEADER",
	85	+
	86	+ "SEND_DATA_HEADER",
	87	+ "SEND_DATA",
	88	+ "SEND_DATA_TRAILER",
	89	+ "RECEIVE_DATA",
	90	+ "WAIT_FEED",
	91	+ "READY",
	92	+
	93	+ "RTSP_WAIT_REQUEST",
	94	+ "RTSP_SEND_REPLY",
	95	+ "RTSP_SEND_PACKET",
	96	+};
	97	+
	98	+#define MAX_STREAMS 20
	99	+
	100	+#define IOBUFFER_INIT_SIZE 8192
	101	+
	102	+/* timeouts are in ms */
	103	+#define HTTP_REQUEST_TIMEOUT (15 * 1000)
	104	+#define RTSP_REQUEST_TIMEOUT (3600 * 24 * 1000)
	105	+
	106	+#define SYNC_TIMEOUT (10 * 1000)
	107	+
	108	+typedef struct RTSPActionServerSetup {
	109	+ uint32_t ipaddr;
	110	+ char transport_option[512];
	111	+} RTSPActionServerSetup;
	112	+
	113	+typedef struct {
	114	+ int64_t count1, count2;
	115	+ int64_t time1, time2;
	116	+} DataRateData;
	117	+
	118	+/* context associated with one connection */
	119	+typedef struct HTTPContext {
	120	+ enum HTTPState state;
	121	+ int fd; /* socket file descriptor */
	122	+ struct sockaddr_in from_addr; /* origin */
	123	+ struct pollfd poll_entry; / used when polling */
	124	+ int64_t timeout;
	125	+ uint8_t buffer_ptr, buffer_end;
	126	+ int http_error;
	127	+ int post;
	128	+ int chunked_encoding;
	129	+ int chunk_size; /* 0 if it needs to be read */
	130	+ struct HTTPContext *next;
	131	+ int got_key_frame; /* stream 0 => 1, stream 1 => 2, stream 2=> 4 */
	132	+ int64_t data_count;
	133	+ /* feed input */
	134	+ int feed_fd;
	135	+ /* input format handling */
	136	+ AVFormatContext *fmt_in;
	137	+ int64_t start_time; /* In milliseconds - this wraps fairly often */
	138	+ int64_t first_pts; /* initial pts value */
	139	+ int64_t cur_pts; /* current pts value from the stream in us */
	140	+ int64_t cur_frame_duration; /* duration of the current frame in us */
	141	+ int cur_frame_bytes; /* output frame size, needed to compute
	142	+ the time at which we send each
	143	+ packet */
	144	+ int pts_stream_index; /* stream we choose as clock reference */
	145	+ int64_t cur_clock; /* current clock reference value in us */
	146	+ /* output format handling */
	147	+ struct FFStream *stream;
	148	+ /* -1 is invalid stream */
	149	+ int feed_streams[MAX_STREAMS]; /* index of streams in the feed */
	150	+ int switch_feed_streams[MAX_STREAMS]; /* index of streams in the feed */
	151	+ int switch_pending;
	152	+ AVFormatContext fmt_ctx; /* instance of FFStream for one user */
	153	+ int last_packet_sent; /* true if last data packet was sent */
	154	+ int suppress_log;
	155	+ DataRateData datarate;
	156	+ int wmp_client_id;
	157	+ char protocol[16];
	158	+ char method[16];
	159	+ char url[128];
	160	+ int buffer_size;
	161	+ uint8_t *buffer;
	162	+ int is_packetized; /* if true, the stream is packetized */
	163	+ int packet_stream_index; /* current stream for output in state machine */
	164	+
	165	+ /* RTSP state specific */
	166	+ uint8_t pb_buffer; / XXX: use that in all the code */
	167	+ AVIOContext *pb;
	168	+ int seq; /* RTSP sequence number */
	169	+
	170	+ /* RTP state specific */
	171	+ enum RTSPLowerTransport rtp_protocol;
	172	+ char session_id[32]; /* session id */
	173	+ AVFormatContext *rtp_ctx[MAX_STREAMS];
	174	+
	175	+ /* RTP/UDP specific */
	176	+ URLContext *rtp_handles[MAX_STREAMS];
	177	+
	178	+ /* RTP/TCP specific */
	179	+ struct HTTPContext *rtsp_c;
	180	+ uint8_t packet_buffer, packet_buffer_ptr, *packet_buffer_end;
	181	+} HTTPContext;
	182	+
	183	+/* each generated stream is described here */
	184	+enum StreamType {
	185	+ STREAM_TYPE_LIVE,
	186	+ STREAM_TYPE_STATUS,
	187	+ STREAM_TYPE_REDIRECT,
	188	+};
	189	+
	190	+enum IPAddressAction {
	191	+ IP_ALLOW = 1,
	192	+ IP_DENY,
	193	+};
	194	+
	195	+typedef struct IPAddressACL {
	196	+ struct IPAddressACL *next;
	197	+ enum IPAddressAction action;
	198	+ /* These are in host order */
	199	+ struct in_addr first;
	200	+ struct in_addr last;
	201	+} IPAddressACL;
	202	+
	203	+/* description of each stream of the avserver.conf file */
	204	+typedef struct FFStream {
	205	+ enum StreamType stream_type;
	206	+ char filename[1024]; /* stream filename */
	207	+ struct FFStream feed; / feed we are using (can be null if
	208	+ coming from file) */
	209	+ AVDictionary in_opts; / input parameters */
	210	+ AVInputFormat ifmt; / if non NULL, force input format */
	211	+ AVOutputFormat *fmt;
	212	+ IPAddressACL *acl;
	213	+ char dynamic_acl[1024];
	214	+ int nb_streams;
	215	+ int prebuffer; /* Number of millseconds early to start */
	216	+ int64_t max_time; /* Number of milliseconds to run */
	217	+ int send_on_key;
	218	+ AVStream *streams[MAX_STREAMS];
	219	+ int feed_streams[MAX_STREAMS]; /* index of streams in the feed */
	220	+ char feed_filename[1024]; /* file name of the feed storage, or
	221	+ input file name for a stream */
	222	+ char author[512];
	223	+ char title[512];
	224	+ char copyright[512];
	225	+ char comment[512];
	226	+ pid_t pid; /* Of ffmpeg process */
	227	+ time_t pid_start; /* Of ffmpeg process */
	228	+ char **child_argv;
	229	+ struct FFStream *next;
	230	+ unsigned bandwidth; /* bandwidth, in kbits/s */
	231	+ /* RTSP options */
	232	+ char *rtsp_option;
	233	+ /* multicast specific */
	234	+ int is_multicast;
	235	+ struct in_addr multicast_ip;
	236	+ int multicast_port; /* first port used for multicast */
	237	+ int multicast_ttl;
	238	+ int loop; /* if true, send the stream in loops (only meaningful if file) */
	239	+
	240	+ /* feed specific */
	241	+ int feed_opened; /* true if someone is writing to the feed */
	242	+ int is_feed; /* true if it is a feed */
	243	+ int readonly; /* True if writing is prohibited to the file */
	244	+ int truncate; /* True if feeder connection truncate the feed file */
	245	+ int conns_served;
	246	+ int64_t bytes_served;
	247	+ int64_t feed_max_size; /* maximum storage size, zero means unlimited */
	248	+ int64_t feed_write_index; /* current write position in feed (it wraps around) */
	249	+ int64_t feed_size; /* current size of feed */
	250	+ struct FFStream *next_feed;
	251	+} FFStream;
	252	+
	253	+typedef struct FeedData {
	254	+ long long data_count;
	255	+ float avg_frame_size; /* frame size averaged over last frames with exponential mean */
	256	+} FeedData;
	257	+
	258	+static struct sockaddr_in my_http_addr;
	259	+static struct sockaddr_in my_rtsp_addr;
	260	+
	261	+static char logfilename[1024];
	262	+static HTTPContext *first_http_ctx;
	263	+static FFStream first_feed; / contains only feeds */
	264	+static FFStream first_stream; / contains all streams, including feeds */
	265	+
	266	+static void new_connection(int server_fd, int is_rtsp);
	267	+static void close_connection(HTTPContext *c);
	268	+
	269	+/* HTTP handling */
	270	+static int handle_connection(HTTPContext *c);
	271	+static int http_parse_request(HTTPContext *c);
	272	+static int http_send_data(HTTPContext *c);
	273	+static void compute_status(HTTPContext *c);
	274	+static int open_input_stream(HTTPContext c, const char info);
	275	+static int http_start_receive_data(HTTPContext *c);
	276	+static int http_receive_data(HTTPContext *c);
	277	+
	278	+/* RTSP handling */
	279	+static int rtsp_parse_request(HTTPContext *c);
	280	+static void rtsp_cmd_describe(HTTPContext c, const char url);
	281	+static void rtsp_cmd_options(HTTPContext c, const char url);
	282	+static void rtsp_cmd_setup(HTTPContext c, const char url, RTSPMessageHeader *h);
	283	+static void rtsp_cmd_play(HTTPContext c, const char url, RTSPMessageHeader *h);
	284	+static void rtsp_cmd_pause(HTTPContext c, const char url, RTSPMessageHeader *h);
	285	+static void rtsp_cmd_teardown(HTTPContext c, const char url, RTSPMessageHeader *h);
	286	+
	287	+/* SDP handling */
	288	+static int prepare_sdp_description(FFStream stream, uint8_t *pbuffer,
	289	+ struct in_addr my_ip);
	290	+
	291	+/* RTP handling */
	292	+static HTTPContext rtp_new_connection(struct sockaddr_in from_addr,
	293	+ FFStream stream, const char session_id,
	294	+ enum RTSPLowerTransport rtp_protocol);
	295	+static int rtp_new_av_stream(HTTPContext *c,
	296	+ int stream_index, struct sockaddr_in *dest_addr,
	297	+ HTTPContext *rtsp_c);
	298	+
	299	+static const char *my_program_name;
	300	+static const char *my_program_dir;
	301	+
	302	+static const char *config_filename = "/etc/avserver.conf";
	303	+
	304	+static int avserver_debug;
	305	+static int avserver_daemon;
	306	+static int no_launch;
	307	+static int need_to_start_children;
	308	+
	309	+/* maximum number of simultaneous HTTP connections */
	310	+static unsigned int nb_max_http_connections = 2000;
	311	+static unsigned int nb_max_connections = 5;
	312	+static unsigned int nb_connections;
	313	+
	314	+static uint64_t max_bandwidth = 1000;
	315	+static uint64_t current_bandwidth;
	316	+
	317	+static int64_t cur_time; // Making this global saves on passing it around everywhere
	318	+
	319	+static AVLFG random_state;
	320	+
	321	+static FILE *logfile = NULL;
	322	+
	323	+/* FIXME: make avserver work with IPv6 */
	324	+/* resolve host with also IP address parsing */
	325	+static int resolve_host(struct in_addr sin_addr, const char hostname)
	326	+{
	327	+
	328	+ if (!ff_inet_aton(hostname, sin_addr)) {
	329	+#if HAVE_GETADDRINFO
	330	+ struct addrinfo ai, cur;
	331	+ struct addrinfo hints;
	332	+ memset(&hints, 0, sizeof(hints));
	333	+ hints.ai_family = AF_INET;
	334	+ if (getaddrinfo(hostname, NULL, &hints, &ai))
	335	+ return -1;
	336	+ /* getaddrinfo returns a linked list of addrinfo structs.
	337	+ * Even if we set ai_family = AF_INET above, make sure
	338	+ * that the returned one actually is of the correct type. */
	339	+ for (cur = ai; cur; cur = cur->ai_next) {
	340	+ if (cur->ai_family == AF_INET) {
	341	+ sin_addr = ((struct sockaddr_in )cur->ai_addr)->sin_addr;
	342	+ freeaddrinfo(ai);
	343	+ return 0;
	344	+ }
	345	+ }
	346	+ freeaddrinfo(ai);
	347	+ return -1;
	348	+#else
	349	+ struct hostent *hp;
	350	+ hp = gethostbyname(hostname);
	351	+ if (!hp)
	352	+ return -1;
	353	+ memcpy(sin_addr, hp->h_addr_list[0], sizeof(struct in_addr));
	354	+#endif
	355	+ }
	356	+ return 0;
	357	+}
	358	+
	359	+static char ctime1(char buf2)
	360	+{
	361	+ time_t ti;
	362	+ char *p;
	363	+
	364	+ ti = time(NULL);
	365	+ p = ctime(&ti);
	366	+ strcpy(buf2, p);
	367	+ p = buf2 + strlen(p) - 1;
	368	+ if (*p == '\n')
	369	+ *p = '\0';
	370	+ return buf2;
	371	+}
	372	+
	373	+static void http_vlog(const char *fmt, va_list vargs)
	374	+{
	375	+ static int print_prefix = 1;
	376	+ if (logfile) {
	377	+ if (print_prefix) {
	378	+ char buf[32];
	379	+ ctime1(buf);
	380	+ fprintf(logfile, "%s ", buf);
	381	+ }
	382	+ print_prefix = strstr(fmt, "\n") != NULL;
	383	+ vfprintf(logfile, fmt, vargs);
	384	+ fflush(logfile);
	385	+ }
	386	+}
	387	+
	388	+#ifdef __GNUC__
	389	+__attribute__ ((format (printf, 1, 2)))
	390	+#endif
	391	+static void http_log(const char *fmt, ...)
	392	+{
	393	+ va_list vargs;
	394	+ va_start(vargs, fmt);
	395	+ http_vlog(fmt, vargs);
	396	+ va_end(vargs);
	397	+}
	398	+
	399	+static void http_av_log(void ptr, int level, const char fmt, va_list vargs)
	400	+{
	401	+ static int print_prefix = 1;
	402	+ AVClass avc = ptr ? (AVClass**)ptr : NULL;
	403	+ if (level > av_log_get_level())
	404	+ return;
	405	+ if (print_prefix && avc)
	406	+ http_log("[%s @ %p]", avc->item_name(ptr), ptr);
	407	+ print_prefix = strstr(fmt, "\n") != NULL;
	408	+ http_vlog(fmt, vargs);
	409	+}
	410	+
	411	+static void log_connection(HTTPContext *c)
	412	+{
	413	+ if (c->suppress_log)
	414	+ return;
	415	+
	416	+ http_log("%s - - [%s] \"%s %s\" %d %"PRId64"\n",
	417	+ inet_ntoa(c->from_addr.sin_addr), c->method, c->url,
	418	+ c->protocol, (c->http_error ? c->http_error : 200), c->data_count);
	419	+}
	420	+
	421	+static void update_datarate(DataRateData *drd, int64_t count)
	422	+{
	423	+ if (!drd->time1 && !drd->count1) {
	424	+ drd->time1 = drd->time2 = cur_time;
	425	+ drd->count1 = drd->count2 = count;
	426	+ } else if (cur_time - drd->time2 > 5000) {
	427	+ drd->time1 = drd->time2;
	428	+ drd->count1 = drd->count2;
	429	+ drd->time2 = cur_time;
	430	+ drd->count2 = count;
	431	+ }
	432	+}
	433	+
	434	+/* In bytes per second */
	435	+static int compute_datarate(DataRateData *drd, int64_t count)
	436	+{
	437	+ if (cur_time == drd->time1)
	438	+ return 0;
	439	+
	440	+ return ((count - drd->count1) * 1000) / (cur_time - drd->time1);
	441	+}
	442	+
	443	+
	444	+static void start_children(FFStream *feed)
	445	+{
	446	+ if (no_launch)
	447	+ return;
	448	+
	449	+ for (; feed; feed = feed->next) {
	450	+ if (feed->child_argv && !feed->pid) {
	451	+ feed->pid_start = time(0);
	452	+
	453	+ feed->pid = fork();
	454	+
	455	+ if (feed->pid < 0) {
	456	+ http_log("Unable to create children\n");
	457	+ exit(1);
	458	+ }
	459	+ if (!feed->pid) {
	460	+ /* In child */
	461	+ char pathname[1024];
	462	+ char *slash;
	463	+ int i;
	464	+
	465	+ av_strlcpy(pathname, my_program_name, sizeof(pathname));
	466	+
	467	+ slash = strrchr(pathname, '/');
	468	+ if (!slash)
	469	+ slash = pathname;
	470	+ else
	471	+ slash++;
	472	+ strcpy(slash, "ffmpeg");
	473	+
	474	+ http_log("Launch commandline: ");
	475	+ http_log("%s ", pathname);
	476	+ for (i = 1; feed->child_argv[i] && feed->child_argv[i][0]; i++)
	477	+ http_log("%s ", feed->child_argv[i]);
	478	+ http_log("\n");
	479	+
	480	+ for (i = 3; i < 256; i++)
	481	+ close(i);
	482	+
	483	+ if (!avserver_debug) {
	484	+ i = open("/dev/null", O_RDWR);
	485	+ if (i != -1) {
	486	+ dup2(i, 0);
	487	+ dup2(i, 1);
	488	+ dup2(i, 2);
	489	+ close(i);
	490	+ }
	491	+ }
	492	+
	493	+ /* This is needed to make relative pathnames work */
	494	+ chdir(my_program_dir);
	495	+
	496	+ signal(SIGPIPE, SIG_DFL);
	497	+
	498	+ execvp(pathname, feed->child_argv);
	499	+
	500	+ _exit(1);
	501	+ }
	502	+ }
	503	+ }
	504	+}
	505	+
	506	+/* open a listening socket */
	507	+static int socket_open_listen(struct sockaddr_in *my_addr)
	508	+{
	509	+ int server_fd, tmp;
	510	+
	511	+ server_fd = socket(AF_INET,SOCK_STREAM,0);
	512	+ if (server_fd < 0) {
	513	+ perror ("socket");
	514	+ return -1;
	515	+ }
	516	+
	517	+ tmp = 1;
	518	+ setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &tmp, sizeof(tmp));
	519	+
	520	+ if (bind (server_fd, (struct sockaddr ) my_addr, sizeof (my_addr)) < 0) {
	521	+ char bindmsg[32];
	522	+ snprintf(bindmsg, sizeof(bindmsg), "bind(port %d)", ntohs(my_addr->sin_port));
	523	+ perror (bindmsg);
	524	+ closesocket(server_fd);
	525	+ return -1;
	526	+ }
	527	+
	528	+ if (listen (server_fd, 5) < 0) {
	529	+ perror ("listen");
	530	+ closesocket(server_fd);
	531	+ return -1;
	532	+ }
	533	+ ff_socket_nonblock(server_fd, 1);
	534	+
	535	+ return server_fd;
	536	+}
	537	+
	538	+/* start all multicast streams */
	539	+static void start_multicast(void)
	540	+{
	541	+ FFStream *stream;
	542	+ char session_id[32];
	543	+ HTTPContext *rtp_c;
	544	+ struct sockaddr_in dest_addr;
	545	+ int default_port, stream_index;
	546	+
	547	+ default_port = 6000;
	548	+ for(stream = first_stream; stream != NULL; stream = stream->next) {
	549	+ if (stream->is_multicast) {
	550	+ /* open the RTP connection */
	551	+ snprintf(session_id, sizeof(session_id), "%08x%08x",
	552	+ av_lfg_get(&random_state), av_lfg_get(&random_state));
	553	+
	554	+ /* choose a port if none given */
	555	+ if (stream->multicast_port == 0) {
	556	+ stream->multicast_port = default_port;
	557	+ default_port += 100;
	558	+ }
	559	+
	560	+ dest_addr.sin_family = AF_INET;
	561	+ dest_addr.sin_addr = stream->multicast_ip;
	562	+ dest_addr.sin_port = htons(stream->multicast_port);
	563	+
	564	+ rtp_c = rtp_new_connection(&dest_addr, stream, session_id,
	565	+ RTSP_LOWER_TRANSPORT_UDP_MULTICAST);
	566	+ if (!rtp_c)
	567	+ continue;
	568	+
	569	+ if (open_input_stream(rtp_c, "") < 0) {
	570	+ http_log("Could not open input stream for stream '%s'\n",
	571	+ stream->filename);
	572	+ continue;
	573	+ }
	574	+
	575	+ /* open each RTP stream */
	576	+ for(stream_index = 0; stream_index < stream->nb_streams;
	577	+ stream_index++) {
	578	+ dest_addr.sin_port = htons(stream->multicast_port +
	579	+ 2 * stream_index);
	580	+ if (rtp_new_av_stream(rtp_c, stream_index, &dest_addr, NULL) < 0) {
	581	+ http_log("Could not open output stream '%s/streamid=%d'\n",
	582	+ stream->filename, stream_index);
	583	+ exit(1);
	584	+ }
	585	+ }
	586	+
	587	+ /* change state to send data */
	588	+ rtp_c->state = HTTPSTATE_SEND_DATA;
	589	+ }
	590	+ }
	591	+}
	592	+
	593	+/* main loop of the http server */
	594	+static int http_server(void)
	595	+{
	596	+ int server_fd = 0, rtsp_server_fd = 0;
	597	+ int ret, delay, delay1;
	598	+ struct pollfd poll_table, poll_entry;
	599	+ HTTPContext c, c_next;
	600	+
	601	+ if(!(poll_table = av_mallocz((nb_max_http_connections + 2)sizeof(poll_table)))) {
	602	+ http_log("Impossible to allocate a poll table handling %d connections.\n", nb_max_http_connections);
	603	+ return -1;
	604	+ }
	605	+
	606	+ if (my_http_addr.sin_port) {
	607	+ server_fd = socket_open_listen(&my_http_addr);
	608	+ if (server_fd < 0)
	609	+ return -1;
	610	+ }
	611	+
	612	+ if (my_rtsp_addr.sin_port) {
	613	+ rtsp_server_fd = socket_open_listen(&my_rtsp_addr);
	614	+ if (rtsp_server_fd < 0)
	615	+ return -1;
	616	+ }
	617	+
	618	+ if (!rtsp_server_fd && !server_fd) {
	619	+ http_log("HTTP and RTSP disabled.\n");
	620	+ return -1;
	621	+ }
	622	+
	623	+ http_log("AVserver started.\n");
	624	+
	625	+ start_children(first_feed);
	626	+
	627	+ start_multicast();
	628	+
	629	+ for(;;) {
	630	+ poll_entry = poll_table;
	631	+ if (server_fd) {
	632	+ poll_entry->fd = server_fd;
	633	+ poll_entry->events = POLLIN;
	634	+ poll_entry++;
	635	+ }
	636	+ if (rtsp_server_fd) {
	637	+ poll_entry->fd = rtsp_server_fd;
	638	+ poll_entry->events = POLLIN;
	639	+ poll_entry++;
	640	+ }
	641	+
	642	+ /* wait for events on each HTTP handle */
	643	+ c = first_http_ctx;
	644	+ delay = 1000;
	645	+ while (c != NULL) {
	646	+ int fd;
	647	+ fd = c->fd;
	648	+ switch(c->state) {
	649	+ case HTTPSTATE_SEND_HEADER:
	650	+ case RTSPSTATE_SEND_REPLY:
	651	+ case RTSPSTATE_SEND_PACKET:
	652	+ c->poll_entry = poll_entry;
	653	+ poll_entry->fd = fd;
	654	+ poll_entry->events = POLLOUT;
	655	+ poll_entry++;
	656	+ break;
	657	+ case HTTPSTATE_SEND_DATA_HEADER:
	658	+ case HTTPSTATE_SEND_DATA:
	659	+ case HTTPSTATE_SEND_DATA_TRAILER:
	660	+ if (!c->is_packetized) {
	661	+ /* for TCP, we output as much as we can (may need to put a limit) */
	662	+ c->poll_entry = poll_entry;
	663	+ poll_entry->fd = fd;
	664	+ poll_entry->events = POLLOUT;
	665	+ poll_entry++;
	666	+ } else {
	667	+ /* when avserver is doing the timing, we work by
	668	+ looking at which packet need to be sent every
	669	+ 10 ms */
	670	+ delay1 = 10; /* one tick wait XXX: 10 ms assumed */
	671	+ if (delay1 < delay)
	672	+ delay = delay1;
	673	+ }
	674	+ break;
	675	+ case HTTPSTATE_WAIT_REQUEST:
	676	+ case HTTPSTATE_RECEIVE_DATA:
	677	+ case HTTPSTATE_WAIT_FEED:
	678	+ case RTSPSTATE_WAIT_REQUEST:
	679	+ /* need to catch errors */
	680	+ c->poll_entry = poll_entry;
	681	+ poll_entry->fd = fd;
	682	+ poll_entry->events = POLLIN;/* Maybe this will work */
	683	+ poll_entry++;
	684	+ break;
	685	+ default:
	686	+ c->poll_entry = NULL;
	687	+ break;
	688	+ }
	689	+ c = c->next;
	690	+ }
	691	+
	692	+ /* wait for an event on one connection. We poll at least every
	693	+ second to handle timeouts */
	694	+ do {
	695	+ ret = poll(poll_table, poll_entry - poll_table, delay);
	696	+ if (ret < 0 && ff_neterrno() != AVERROR(EAGAIN) &&
	697	+ ff_neterrno() != AVERROR(EINTR))
	698	+ return -1;
	699	+ } while (ret < 0);
	700	+
	701	+ cur_time = av_gettime() / 1000;
	702	+
	703	+ if (need_to_start_children) {
	704	+ need_to_start_children = 0;
	705	+ start_children(first_feed);
	706	+ }
	707	+
	708	+ /* now handle the events */
	709	+ for(c = first_http_ctx; c != NULL; c = c_next) {
	710	+ c_next = c->next;
	711	+ if (handle_connection(c) < 0) {
	712	+ /* close and free the connection */
	713	+ log_connection(c);
	714	+ close_connection(c);
	715	+ }
	716	+ }
	717	+
	718	+ poll_entry = poll_table;
	719	+ if (server_fd) {
	720	+ /* new HTTP connection request ? */
	721	+ if (poll_entry->revents & POLLIN)
	722	+ new_connection(server_fd, 0);
	723	+ poll_entry++;
	724	+ }
	725	+ if (rtsp_server_fd) {
	726	+ /* new RTSP connection request ? */
	727	+ if (poll_entry->revents & POLLIN)
	728	+ new_connection(rtsp_server_fd, 1);
	729	+ }
	730	+ }
	731	+}
	732	+
	733	+/* start waiting for a new HTTP/RTSP request */
	734	+static void start_wait_request(HTTPContext *c, int is_rtsp)
	735	+{
	736	+ c->buffer_ptr = c->buffer;
	737	+ c->buffer_end = c->buffer + c->buffer_size - 1; /* leave room for '\0' */
	738	+
	739	+ if (is_rtsp) {
	740	+ c->timeout = cur_time + RTSP_REQUEST_TIMEOUT;
	741	+ c->state = RTSPSTATE_WAIT_REQUEST;
	742	+ } else {
	743	+ c->timeout = cur_time + HTTP_REQUEST_TIMEOUT;
	744	+ c->state = HTTPSTATE_WAIT_REQUEST;
	745	+ }
	746	+}
	747	+
	748	+static void http_send_too_busy_reply(int fd)
	749	+{
	750	+ char buffer[300];
	751	+ int len = snprintf(buffer, sizeof(buffer),
	752	+ "HTTP/1.0 503 Server too busy\r\n"
	753	+ "Content-type: text/html\r\n"
	754	+ "\r\n"
	755	+ "<html><head><title>Too busy</title></head><body>\r\n"
	756	+ "<p>The server is too busy to serve your request at this time.</p>\r\n"
	757	+ "<p>The number of current connections is %d, and this exceeds the limit of %d.</p>\r\n"
	758	+ "</body></html>\r\n",
	759	+ nb_connections, nb_max_connections);
	760	+ send(fd, buffer, len, 0);
	761	+}
	762	+
	763	+
	764	+static void new_connection(int server_fd, int is_rtsp)
	765	+{
	766	+ struct sockaddr_in from_addr;
	767	+ int fd, len;
	768	+ HTTPContext *c = NULL;
	769	+
	770	+ len = sizeof(from_addr);
	771	+ fd = accept(server_fd, (struct sockaddr *)&from_addr,
	772	+ &len);
	773	+ if (fd < 0) {
	774	+ http_log("error during accept %s\n", strerror(errno));
	775	+ return;
	776	+ }
	777	+ ff_socket_nonblock(fd, 1);
	778	+
	779	+ if (nb_connections >= nb_max_connections) {
	780	+ http_send_too_busy_reply(fd);
	781	+ goto fail;
	782	+ }
	783	+
	784	+ /* add a new connection */
	785	+ c = av_mallocz(sizeof(HTTPContext));
	786	+ if (!c)
	787	+ goto fail;
	788	+
	789	+ c->fd = fd;
	790	+ c->poll_entry = NULL;
	791	+ c->from_addr = from_addr;
	792	+ c->buffer_size = IOBUFFER_INIT_SIZE;
	793	+ c->buffer = av_malloc(c->buffer_size);
	794	+ if (!c->buffer)
	795	+ goto fail;
	796	+
	797	+ c->next = first_http_ctx;
	798	+ first_http_ctx = c;
	799	+ nb_connections++;
	800	+
	801	+ start_wait_request(c, is_rtsp);
	802	+
	803	+ return;
	804	+
	805	+ fail:
	806	+ if (c) {
	807	+ av_free(c->buffer);
	808	+ av_free(c);
	809	+ }
	810	+ closesocket(fd);
	811	+}
	812	+
	813	+static void close_connection(HTTPContext *c)
	814	+{
	815	+ HTTPContext *cp, c1;
	816	+ int i, nb_streams;
	817	+ AVFormatContext *ctx;
	818	+ URLContext *h;
	819	+ AVStream *st;
	820	+
	821	+ /* remove connection from list */
	822	+ cp = &first_http_ctx;
	823	+ while ((*cp) != NULL) {
	824	+ c1 = *cp;
	825	+ if (c1 == c)
	826	+ *cp = c->next;
	827	+ else
	828	+ cp = &c1->next;
	829	+ }
	830	+
	831	+ /* remove references, if any (XXX: do it faster) */
	832	+ for(c1 = first_http_ctx; c1 != NULL; c1 = c1->next) {
	833	+ if (c1->rtsp_c == c)
	834	+ c1->rtsp_c = NULL;
	835	+ }
	836	+
	837	+ /* remove connection associated resources */
	838	+ if (c->fd >= 0)
	839	+ closesocket(c->fd);
	840	+ if (c->fmt_in) {
	841	+ /* close each frame parser */
	842	+ for(i=0;i<c->fmt_in->nb_streams;i++) {
	843	+ st = c->fmt_in->streams[i];
	844	+ if (st->codec->codec)
	845	+ avcodec_close(st->codec);
	846	+ }
	847	+ av_close_input_file(c->fmt_in);
	848	+ }
	849	+
	850	+ /* free RTP output streams if any */
	851	+ nb_streams = 0;
	852	+ if (c->stream)
	853	+ nb_streams = c->stream->nb_streams;
	854	+
	855	+ for(i=0;i<nb_streams;i++) {
	856	+ ctx = c->rtp_ctx[i];
	857	+ if (ctx) {
	858	+ av_write_trailer(ctx);
	859	+ av_dict_free(&ctx->metadata);
	860	+ av_free(ctx->streams[0]);
	861	+ av_free(ctx);
	862	+ }
	863	+ h = c->rtp_handles[i];
	864	+ if (h)
	865	+ url_close(h);
	866	+ }
	867	+
	868	+ ctx = &c->fmt_ctx;
	869	+
	870	+ if (!c->last_packet_sent && c->state == HTTPSTATE_SEND_DATA_TRAILER) {
	871	+ if (ctx->oformat) {
	872	+ /* prepare header */
	873	+ if (avio_open_dyn_buf(&ctx->pb) >= 0) {
	874	+ av_write_trailer(ctx);
	875	+ av_freep(&c->pb_buffer);
	876	+ avio_close_dyn_buf(ctx->pb, &c->pb_buffer);
	877	+ }
	878	+ }
	879	+ }
	880	+
	881	+ for(i=0; i<ctx->nb_streams; i++)
	882	+ av_free(ctx->streams[i]);
	883	+
	884	+ if (c->stream && !c->post && c->stream->stream_type == STREAM_TYPE_LIVE)
	885	+ current_bandwidth -= c->stream->bandwidth;
	886	+
	887	+ /* signal that there is no feed if we are the feeder socket */
	888	+ if (c->state == HTTPSTATE_RECEIVE_DATA && c->stream) {
	889	+ c->stream->feed_opened = 0;
	890	+ close(c->feed_fd);
	891	+ }
	892	+
	893	+ av_freep(&c->pb_buffer);
	894	+ av_freep(&c->packet_buffer);
	895	+ av_free(c->buffer);
	896	+ av_free(c);
	897	+ nb_connections--;
	898	+}
	899	+
	900	+static int handle_connection(HTTPContext *c)
	901	+{
	902	+ int len, ret;
	903	+
	904	+ switch(c->state) {
	905	+ case HTTPSTATE_WAIT_REQUEST:
	906	+ case RTSPSTATE_WAIT_REQUEST:
	907	+ /* timeout ? */
	908	+ if ((c->timeout - cur_time) < 0)
	909	+ return -1;
	910	+ if (c->poll_entry->revents & (POLLERR \| POLLHUP))
	911	+ return -1;
	912	+
	913	+ /* no need to read if no events */
	914	+ if (!(c->poll_entry->revents & POLLIN))
	915	+ return 0;
	916	+ /* read the data */
	917	+ read_loop:
	918	+ len = recv(c->fd, c->buffer_ptr, 1, 0);
	919	+ if (len < 0) {
	920	+ if (ff_neterrno() != AVERROR(EAGAIN) &&
	921	+ ff_neterrno() != AVERROR(EINTR))
	922	+ return -1;
	923	+ } else if (len == 0) {
	924	+ return -1;
	925	+ } else {
	926	+ /* search for end of request. */
	927	+ uint8_t *ptr;
	928	+ c->buffer_ptr += len;
	929	+ ptr = c->buffer_ptr;
	930	+ if ((ptr >= c->buffer + 2 && !memcmp(ptr-2, "\n\n", 2)) \|\|
	931	+ (ptr >= c->buffer + 4 && !memcmp(ptr-4, "\r\n\r\n", 4))) {
	932	+ /* request found : parse it and reply */
	933	+ if (c->state == HTTPSTATE_WAIT_REQUEST) {
	934	+ ret = http_parse_request(c);
	935	+ } else {
	936	+ ret = rtsp_parse_request(c);
	937	+ }
	938	+ if (ret < 0)
	939	+ return -1;
	940	+ } else if (ptr >= c->buffer_end) {
	941	+ /* request too long: cannot do anything */
	942	+ return -1;
	943	+ } else goto read_loop;
	944	+ }
	945	+ break;
	946	+
	947	+ case HTTPSTATE_SEND_HEADER:
	948	+ if (c->poll_entry->revents & (POLLERR \| POLLHUP))
	949	+ return -1;
	950	+
	951	+ /* no need to write if no events */
	952	+ if (!(c->poll_entry->revents & POLLOUT))
	953	+ return 0;
	954	+ len = send(c->fd, c->buffer_ptr, c->buffer_end - c->buffer_ptr, 0);
	955	+ if (len < 0) {
	956	+ if (ff_neterrno() != AVERROR(EAGAIN) &&
	957	+ ff_neterrno() != AVERROR(EINTR)) {
	958	+ /* error : close connection */
	959	+ av_freep(&c->pb_buffer);
	960	+ return -1;
	961	+ }
	962	+ } else {
	963	+ c->buffer_ptr += len;
	964	+ if (c->stream)
	965	+ c->stream->bytes_served += len;
	966	+ c->data_count += len;
	967	+ if (c->buffer_ptr >= c->buffer_end) {
	968	+ av_freep(&c->pb_buffer);
	969	+ /* if error, exit */
	970	+ if (c->http_error)
	971	+ return -1;
	972	+ /* all the buffer was sent : synchronize to the incoming stream */
	973	+ c->state = HTTPSTATE_SEND_DATA_HEADER;
	974	+ c->buffer_ptr = c->buffer_end = c->buffer;
	975	+ }
	976	+ }
	977	+ break;
	978	+
	979	+ case HTTPSTATE_SEND_DATA:
	980	+ case HTTPSTATE_SEND_DATA_HEADER:
	981	+ case HTTPSTATE_SEND_DATA_TRAILER:
	982	+ /* for packetized output, we consider we can always write (the
	983	+ input streams sets the speed). It may be better to verify
	984	+ that we do not rely too much on the kernel queues */
	985	+ if (!c->is_packetized) {
	986	+ if (c->poll_entry->revents & (POLLERR \| POLLHUP))
	987	+ return -1;
	988	+
	989	+ /* no need to read if no events */
	990	+ if (!(c->poll_entry->revents & POLLOUT))
	991	+ return 0;
	992	+ }
	993	+ if (http_send_data(c) < 0)
	994	+ return -1;
	995	+ /* close connection if trailer sent */
	996	+ if (c->state == HTTPSTATE_SEND_DATA_TRAILER)
	997	+ return -1;
	998	+ break;
	999	+ case HTTPSTATE_RECEIVE_DATA:
	1000	+ /* no need to read if no events */
	1001	+ if (c->poll_entry->revents & (POLLERR \| POLLHUP))
	1002	+ return -1;
	1003	+ if (!(c->poll_entry->revents & POLLIN))
	1004	+ return 0;
	1005	+ if (http_receive_data(c) < 0)
	1006	+ return -1;
	1007	+ break;
	1008	+ case HTTPSTATE_WAIT_FEED:
	1009	+ /* no need to read if no events */
	1010	+ if (c->poll_entry->revents & (POLLIN \| POLLERR \| POLLHUP))
	1011	+ return -1;
	1012	+
	1013	+ /* nothing to do, we'll be waken up by incoming feed packets */
	1014	+ break;
	1015	+
	1016	+ case RTSPSTATE_SEND_REPLY:
	1017	+ if (c->poll_entry->revents & (POLLERR \| POLLHUP)) {
	1018	+ av_freep(&c->pb_buffer);
	1019	+ return -1;
	1020	+ }
	1021	+ /* no need to write if no events */
	1022	+ if (!(c->poll_entry->revents & POLLOUT))
	1023	+ return 0;
	1024	+ len = send(c->fd, c->buffer_ptr, c->buffer_end - c->buffer_ptr, 0);
	1025	+ if (len < 0) {
	1026	+ if (ff_neterrno() != AVERROR(EAGAIN) &&
	1027	+ ff_neterrno() != AVERROR(EINTR)) {
	1028	+ /* error : close connection */
	1029	+ av_freep(&c->pb_buffer);
	1030	+ return -1;
	1031	+ }
	1032	+ } else {
	1033	+ c->buffer_ptr += len;
	1034	+ c->data_count += len;
	1035	+ if (c->buffer_ptr >= c->buffer_end) {
	1036	+ /* all the buffer was sent : wait for a new request */
	1037	+ av_freep(&c->pb_buffer);
	1038	+ start_wait_request(c, 1);
	1039	+ }
	1040	+ }
	1041	+ break;
	1042	+ case RTSPSTATE_SEND_PACKET:
	1043	+ if (c->poll_entry->revents & (POLLERR \| POLLHUP)) {
	1044	+ av_freep(&c->packet_buffer);
	1045	+ return -1;
	1046	+ }
	1047	+ /* no need to write if no events */
	1048	+ if (!(c->poll_entry->revents & POLLOUT))
	1049	+ return 0;
	1050	+ len = send(c->fd, c->packet_buffer_ptr,
	1051	+ c->packet_buffer_end - c->packet_buffer_ptr, 0);
	1052	+ if (len < 0) {
	1053	+ if (ff_neterrno() != AVERROR(EAGAIN) &&
	1054	+ ff_neterrno() != AVERROR(EINTR)) {
	1055	+ /* error : close connection */
	1056	+ av_freep(&c->packet_buffer);
	1057	+ return -1;
	1058	+ }
	1059	+ } else {
	1060	+ c->packet_buffer_ptr += len;
	1061	+ if (c->packet_buffer_ptr >= c->packet_buffer_end) {
	1062	+ /* all the buffer was sent : wait for a new request */
	1063	+ av_freep(&c->packet_buffer);
	1064	+ c->state = RTSPSTATE_WAIT_REQUEST;
	1065	+ }
	1066	+ }
	1067	+ break;
	1068	+ case HTTPSTATE_READY:
	1069	+ /* nothing to do */
	1070	+ break;
	1071	+ default:
	1072	+ return -1;
	1073	+ }
	1074	+ return 0;
	1075	+}
	1076	+
	1077	+static int extract_rates(char rates, int ratelen, const char request)
	1078	+{
	1079	+ const char *p;
	1080	+
	1081	+ for (p = request; p && p != '\r' && *p != '\n'; ) {
	1082	+ if (strncasecmp(p, "Pragma:", 7) == 0) {
	1083	+ const char *q = p + 7;
	1084	+
	1085	+ while (q && q != '\n' && isspace(*q))
	1086	+ q++;
	1087	+
	1088	+ if (strncasecmp(q, "stream-switch-entry=", 20) == 0) {
	1089	+ int stream_no;
	1090	+ int rate_no;
	1091	+
	1092	+ q += 20;
	1093	+
	1094	+ memset(rates, 0xff, ratelen);
	1095	+
	1096	+ while (1) {
	1097	+ while (q && q != '\n' && *q != ':')
	1098	+ q++;
	1099	+
	1100	+ if (sscanf(q, ":%d:%d", &stream_no, &rate_no) != 2)
	1101	+ break;
	1102	+
	1103	+ stream_no--;
	1104	+ if (stream_no < ratelen && stream_no >= 0)
	1105	+ rates[stream_no] = rate_no;
	1106	+
	1107	+ while (q && q != '\n' && !isspace(*q))
	1108	+ q++;
	1109	+ }
	1110	+
	1111	+ return 1;
	1112	+ }
	1113	+ }
	1114	+ p = strchr(p, '\n');
	1115	+ if (!p)
	1116	+ break;
	1117	+
	1118	+ p++;
	1119	+ }
	1120	+
	1121	+ return 0;
	1122	+}
	1123	+
	1124	+static int find_stream_in_feed(FFStream feed, AVCodecContext codec, int bit_rate)
	1125	+{
	1126	+ int i;
	1127	+ int best_bitrate = 100000000;
	1128	+ int best = -1;
	1129	+
	1130	+ for (i = 0; i < feed->nb_streams; i++) {
	1131	+ AVCodecContext *feed_codec = feed->streams[i]->codec;
	1132	+
	1133	+ if (feed_codec->codec_id != codec->codec_id \|\|
	1134	+ feed_codec->sample_rate != codec->sample_rate \|\|
	1135	+ feed_codec->width != codec->width \|\|
	1136	+ feed_codec->height != codec->height)
	1137	+ continue;
	1138	+
	1139	+ /* Potential stream */
	1140	+
	1141	+ /* We want the fastest stream less than bit_rate, or the slowest
	1142	+ * faster than bit_rate
	1143	+ */
	1144	+
	1145	+ if (feed_codec->bit_rate <= bit_rate) {
	1146	+ if (best_bitrate > bit_rate \|\| feed_codec->bit_rate > best_bitrate) {
	1147	+ best_bitrate = feed_codec->bit_rate;
	1148	+ best = i;
	1149	+ }
	1150	+ } else {
	1151	+ if (feed_codec->bit_rate < best_bitrate) {
	1152	+ best_bitrate = feed_codec->bit_rate;
	1153	+ best = i;
	1154	+ }
	1155	+ }
	1156	+ }
	1157	+
	1158	+ return best;
	1159	+}
	1160	+
	1161	+static int modify_current_stream(HTTPContext c, char rates)
	1162	+{
	1163	+ int i;
	1164	+ FFStream *req = c->stream;
	1165	+ int action_required = 0;
	1166	+
	1167	+ /* Not much we can do for a feed */
	1168	+ if (!req->feed)
	1169	+ return 0;
	1170	+
	1171	+ for (i = 0; i < req->nb_streams; i++) {
	1172	+ AVCodecContext *codec = req->streams[i]->codec;
	1173	+
	1174	+ switch(rates[i]) {
	1175	+ case 0:
	1176	+ c->switch_feed_streams[i] = req->feed_streams[i];
	1177	+ break;
	1178	+ case 1:
	1179	+ c->switch_feed_streams[i] = find_stream_in_feed(req->feed, codec, codec->bit_rate / 2);
	1180	+ break;
	1181	+ case 2:
	1182	+ /* Wants off or slow */
	1183	+ c->switch_feed_streams[i] = find_stream_in_feed(req->feed, codec, codec->bit_rate / 4);
	1184	+#ifdef WANTS_OFF
	1185	+ /* This doesn't work well when it turns off the only stream! */
	1186	+ c->switch_feed_streams[i] = -2;
	1187	+ c->feed_streams[i] = -2;
	1188	+#endif
	1189	+ break;
	1190	+ }
	1191	+
	1192	+ if (c->switch_feed_streams[i] >= 0 && c->switch_feed_streams[i] != c->feed_streams[i])
	1193	+ action_required = 1;
	1194	+ }
	1195	+
	1196	+ return action_required;
	1197	+}
	1198	+
	1199	+/* XXX: factorize in utils.c ? */
	1200	+/* XXX: take care with different space meaning */
	1201	+static void skip_spaces(const char **pp)
	1202	+{
	1203	+ const char *p;
	1204	+ p = *pp;
	1205	+ while (p == ' ' \|\| p == '\t')
	1206	+ p++;
	1207	+ *pp = p;
	1208	+}
	1209	+
	1210	+static void get_word(char buf, int buf_size, const char *pp)
	1211	+{
	1212	+ const char *p;
	1213	+ char *q;
	1214	+
	1215	+ p = *pp;
	1216	+ skip_spaces(&p);
	1217	+ q = buf;
	1218	+ while (!isspace(p) && p != '\0') {
	1219	+ if ((q - buf) < buf_size - 1)
	1220	+ q++ = p;
	1221	+ p++;
	1222	+ }
	1223	+ if (buf_size > 0)
	1224	+ *q = '\0';
	1225	+ *pp = p;
	1226	+}
	1227	+
	1228	+static void get_arg(char buf, int buf_size, const char *pp)
	1229	+{
	1230	+ const char *p;
	1231	+ char *q;
	1232	+ int quote;
	1233	+
	1234	+ p = *pp;
	1235	+ while (isspace(*p)) p++;
	1236	+ q = buf;
	1237	+ quote = 0;
	1238	+ if (p == '\"' \|\| p == '\'')
	1239	+ quote = *p++;
	1240	+ for(;;) {
	1241	+ if (quote) {
	1242	+ if (*p == quote)
	1243	+ break;
	1244	+ } else {
	1245	+ if (isspace(*p))
	1246	+ break;
	1247	+ }
	1248	+ if (*p == '\0')
	1249	+ break;
	1250	+ if ((q - buf) < buf_size - 1)
	1251	+ q++ = p;
	1252	+ p++;
	1253	+ }
	1254	+ *q = '\0';
	1255	+ if (quote && *p == quote)
	1256	+ p++;
	1257	+ *pp = p;
	1258	+}
	1259	+
	1260	+static void parse_acl_row(FFStream stream, FFStream feed, IPAddressACL *ext_acl,
	1261	+ const char p, const char filename, int line_num)
	1262	+{
	1263	+ char arg[1024];
	1264	+ IPAddressACL acl;
	1265	+ int errors = 0;
	1266	+
	1267	+ get_arg(arg, sizeof(arg), &p);
	1268	+ if (strcasecmp(arg, "allow") == 0)
	1269	+ acl.action = IP_ALLOW;
	1270	+ else if (strcasecmp(arg, "deny") == 0)
	1271	+ acl.action = IP_DENY;
	1272	+ else {
	1273	+ fprintf(stderr, "%s:%d: ACL action '%s' is not ALLOW or DENY\n",
	1274	+ filename, line_num, arg);
	1275	+ errors++;
	1276	+ }
	1277	+
	1278	+ get_arg(arg, sizeof(arg), &p);
	1279	+
	1280	+ if (resolve_host(&acl.first, arg) != 0) {
	1281	+ fprintf(stderr, "%s:%d: ACL refers to invalid host or ip address '%s'\n",
	1282	+ filename, line_num, arg);
	1283	+ errors++;
	1284	+ } else
	1285	+ acl.last = acl.first;
	1286	+
	1287	+ get_arg(arg, sizeof(arg), &p);
	1288	+
	1289	+ if (arg[0]) {
	1290	+ if (resolve_host(&acl.last, arg) != 0) {
	1291	+ fprintf(stderr, "%s:%d: ACL refers to invalid host or ip address '%s'\n",
	1292	+ filename, line_num, arg);
	1293	+ errors++;
	1294	+ }
	1295	+ }
	1296	+
	1297	+ if (!errors) {
	1298	+ IPAddressACL nacl = av_mallocz(sizeof(nacl));
	1299	+ IPAddressACL **naclp = 0;
	1300	+
	1301	+ acl.next = 0;
	1302	+ *nacl = acl;
	1303	+
	1304	+ if (stream)
	1305	+ naclp = &stream->acl;
	1306	+ else if (feed)
	1307	+ naclp = &feed->acl;
	1308	+ else if (ext_acl)
	1309	+ naclp = &ext_acl;
	1310	+ else {
	1311	+ fprintf(stderr, "%s:%d: ACL found not in <stream> or <feed>\n",
	1312	+ filename, line_num);
	1313	+ errors++;
	1314	+ }
	1315	+
	1316	+ if (naclp) {
	1317	+ while (*naclp)
	1318	+ naclp = &(*naclp)->next;
	1319	+
	1320	+ *naclp = nacl;
	1321	+ }
	1322	+ }
	1323	+}
	1324	+
	1325	+
	1326	+static IPAddressACL* parse_dynamic_acl(FFStream stream, HTTPContext c)
	1327	+{
	1328	+ FILE* f;
	1329	+ char line[1024];
	1330	+ char cmd[1024];
	1331	+ IPAddressACL *acl = NULL;
	1332	+ int line_num = 0;
	1333	+ const char *p;
	1334	+
	1335	+ f = fopen(stream->dynamic_acl, "r");
	1336	+ if (!f) {
	1337	+ perror(stream->dynamic_acl);
	1338	+ return NULL;
	1339	+ }
	1340	+
	1341	+ acl = av_mallocz(sizeof(IPAddressACL));
	1342	+
	1343	+ /* Build ACL */
	1344	+ for(;;) {
	1345	+ if (fgets(line, sizeof(line), f) == NULL)
	1346	+ break;
	1347	+ line_num++;
	1348	+ p = line;
	1349	+ while (isspace(*p))
	1350	+ p++;
	1351	+ if (p == '\0' \|\| p == '#')
	1352	+ continue;
	1353	+ get_arg(cmd, sizeof(cmd), &p);
	1354	+
	1355	+ if (!strcasecmp(cmd, "ACL"))
	1356	+ parse_acl_row(NULL, NULL, acl, p, stream->dynamic_acl, line_num);
	1357	+ }
	1358	+ fclose(f);
	1359	+ return acl;
	1360	+}
	1361	+
	1362	+
	1363	+static void free_acl_list(IPAddressACL *in_acl)
	1364	+{
	1365	+ IPAddressACL pacl,pacl2;
	1366	+
	1367	+ pacl = in_acl;
	1368	+ while(pacl) {
	1369	+ pacl2 = pacl;
	1370	+ pacl = pacl->next;
	1371	+ av_freep(pacl2);
	1372	+ }
	1373	+}
	1374	+
	1375	+static int validate_acl_list(IPAddressACL in_acl, HTTPContext c)
	1376	+{
	1377	+ enum IPAddressAction last_action = IP_DENY;
	1378	+ IPAddressACL *acl;
	1379	+ struct in_addr *src = &c->from_addr.sin_addr;
	1380	+ unsigned long src_addr = src->s_addr;
	1381	+
	1382	+ for (acl = in_acl; acl; acl = acl->next) {
	1383	+ if (src_addr >= acl->first.s_addr && src_addr <= acl->last.s_addr)
	1384	+ return (acl->action == IP_ALLOW) ? 1 : 0;
	1385	+ last_action = acl->action;
	1386	+ }
	1387	+
	1388	+ /* Nothing matched, so return not the last action */
	1389	+ return (last_action == IP_DENY) ? 1 : 0;
	1390	+}
	1391	+
	1392	+static int validate_acl(FFStream stream, HTTPContext c)
	1393	+{
	1394	+ int ret = 0;
	1395	+ IPAddressACL *acl;
	1396	+
	1397	+
	1398	+ /* if stream->acl is null validate_acl_list will return 1 */
	1399	+ ret = validate_acl_list(stream->acl, c);
	1400	+
	1401	+ if (stream->dynamic_acl[0]) {
	1402	+ acl = parse_dynamic_acl(stream, c);
	1403	+
	1404	+ ret = validate_acl_list(acl, c);
	1405	+
	1406	+ free_acl_list(acl);
	1407	+ }
	1408	+
	1409	+ return ret;
	1410	+}
	1411	+
	1412	+/* compute the real filename of a file by matching it without its
	1413	+ extensions to all the stream filenames */
	1414	+static void compute_real_filename(char *filename, int max_size)
	1415	+{
	1416	+ char file1[1024];
	1417	+ char file2[1024];
	1418	+ char *p;
	1419	+ FFStream *stream;
	1420	+
	1421	+ /* compute filename by matching without the file extensions */
	1422	+ av_strlcpy(file1, filename, sizeof(file1));
	1423	+ p = strrchr(file1, '.');
	1424	+ if (p)
	1425	+ *p = '\0';
	1426	+ for(stream = first_stream; stream != NULL; stream = stream->next) {
	1427	+ av_strlcpy(file2, stream->filename, sizeof(file2));
	1428	+ p = strrchr(file2, '.');
	1429	+ if (p)
	1430	+ *p = '\0';
	1431	+ if (!strcmp(file1, file2)) {
	1432	+ av_strlcpy(filename, stream->filename, max_size);
	1433	+ break;
	1434	+ }
	1435	+ }
	1436	+}
	1437	+
	1438	+enum RedirType {
	1439	+ REDIR_NONE,
	1440	+ REDIR_ASX,
	1441	+ REDIR_RAM,
	1442	+ REDIR_ASF,
	1443	+ REDIR_RTSP,
	1444	+ REDIR_SDP,
	1445	+};
	1446	+
	1447	+/* parse http request and prepare header */
	1448	+static int http_parse_request(HTTPContext *c)
	1449	+{
	1450	+ char *p;
	1451	+ enum RedirType redir_type;
	1452	+ char cmd[32];
	1453	+ char info[1024], filename[1024];
	1454	+ char url[1024], *q;
	1455	+ char protocol[32];
	1456	+ char msg[1024];
	1457	+ const char *mime_type;
	1458	+ FFStream *stream;
	1459	+ int i;
	1460	+ char ratebuf[32];
	1461	+ char *useragent = 0;
	1462	+
	1463	+ p = c->buffer;
	1464	+ get_word(cmd, sizeof(cmd), (const char **)&p);
	1465	+ av_strlcpy(c->method, cmd, sizeof(c->method));
	1466	+
	1467	+ if (!strcmp(cmd, "GET"))
	1468	+ c->post = 0;
	1469	+ else if (!strcmp(cmd, "POST"))
	1470	+ c->post = 1;
	1471	+ else
	1472	+ return -1;
	1473	+
	1474	+ get_word(url, sizeof(url), (const char **)&p);
	1475	+ av_strlcpy(c->url, url, sizeof(c->url));
	1476	+
	1477	+ get_word(protocol, sizeof(protocol), (const char **)&p);
	1478	+ if (strcmp(protocol, "HTTP/1.0") && strcmp(protocol, "HTTP/1.1"))
	1479	+ return -1;
	1480	+
	1481	+ av_strlcpy(c->protocol, protocol, sizeof(c->protocol));
	1482	+
	1483	+ if (avserver_debug)
	1484	+ http_log("%s - - New connection: %s %s\n", inet_ntoa(c->from_addr.sin_addr), cmd, url);
	1485	+
	1486	+ /* find the filename and the optional info string in the request */
	1487	+ p = strchr(url, '?');
	1488	+ if (p) {
	1489	+ av_strlcpy(info, p, sizeof(info));
	1490	+ *p = '\0';
	1491	+ } else
	1492	+ info[0] = '\0';
	1493	+
	1494	+ av_strlcpy(filename, url + ((*url == '/') ? 1 : 0), sizeof(filename)-1);
	1495	+
	1496	+ for (p = c->buffer; p && p != '\r' && *p != '\n'; ) {
	1497	+ if (strncasecmp(p, "User-Agent:", 11) == 0) {
	1498	+ useragent = p + 11;
	1499	+ if (useragent && useragent != '\n' && isspace(*useragent))
	1500	+ useragent++;
	1501	+ break;
	1502	+ }
	1503	+ p = strchr(p, '\n');
	1504	+ if (!p)
	1505	+ break;
	1506	+
	1507	+ p++;
	1508	+ }
	1509	+
	1510	+ redir_type = REDIR_NONE;
	1511	+ if (av_match_ext(filename, "asx")) {
	1512	+ redir_type = REDIR_ASX;
	1513	+ filename[strlen(filename)-1] = 'f';
	1514	+ } else if (av_match_ext(filename, "asf") &&
	1515	+ (!useragent \|\| strncasecmp(useragent, "NSPlayer", 8) != 0)) {
	1516	+ /* if this isn't WMP or lookalike, return the redirector file */
	1517	+ redir_type = REDIR_ASF;
	1518	+ } else if (av_match_ext(filename, "rpm,ram")) {
	1519	+ redir_type = REDIR_RAM;
	1520	+ strcpy(filename + strlen(filename)-2, "m");
	1521	+ } else if (av_match_ext(filename, "rtsp")) {
	1522	+ redir_type = REDIR_RTSP;
	1523	+ compute_real_filename(filename, sizeof(filename) - 1);
	1524	+ } else if (av_match_ext(filename, "sdp")) {
	1525	+ redir_type = REDIR_SDP;
	1526	+ compute_real_filename(filename, sizeof(filename) - 1);
	1527	+ }
	1528	+
	1529	+ // "redirect" / request to index.html
	1530	+ if (!strlen(filename))
	1531	+ av_strlcpy(filename, "index.html", sizeof(filename) - 1);
	1532	+
	1533	+ stream = first_stream;
	1534	+ while (stream != NULL) {
	1535	+ if (!strcmp(stream->filename, filename) && validate_acl(stream, c))
	1536	+ break;
	1537	+ stream = stream->next;
	1538	+ }
	1539	+ if (stream == NULL) {
	1540	+ snprintf(msg, sizeof(msg), "File '%s' not found", url);
	1541	+ http_log("File '%s' not found\n", url);
	1542	+ goto send_error;
	1543	+ }
	1544	+
	1545	+ c->stream = stream;
	1546	+ memcpy(c->feed_streams, stream->feed_streams, sizeof(c->feed_streams));
	1547	+ memset(c->switch_feed_streams, -1, sizeof(c->switch_feed_streams));
	1548	+
	1549	+ if (stream->stream_type == STREAM_TYPE_REDIRECT) {
	1550	+ c->http_error = 301;
	1551	+ q = c->buffer;
	1552	+ q += snprintf(q, c->buffer_size,
	1553	+ "HTTP/1.0 301 Moved\r\n"
	1554	+ "Location: %s\r\n"
	1555	+ "Content-type: text/html\r\n"
	1556	+ "\r\n"
	1557	+ "<html><head><title>Moved</title></head><body>\r\n"
	1558	+ "You should be <a href=\"%s\">redirected</a>.\r\n"
	1559	+ "</body></html>\r\n", stream->feed_filename, stream->feed_filename);
	1560	+ /* prepare output buffer */
	1561	+ c->buffer_ptr = c->buffer;
	1562	+ c->buffer_end = q;
	1563	+ c->state = HTTPSTATE_SEND_HEADER;
	1564	+ return 0;
	1565	+ }
	1566	+
	1567	+ /* If this is WMP, get the rate information */
	1568	+ if (extract_rates(ratebuf, sizeof(ratebuf), c->buffer)) {
	1569	+ if (modify_current_stream(c, ratebuf)) {
	1570	+ for (i = 0; i < FF_ARRAY_ELEMS(c->feed_streams); i++) {
	1571	+ if (c->switch_feed_streams[i] >= 0)
	1572	+ c->switch_feed_streams[i] = -1;
	1573	+ }
	1574	+ }
	1575	+ }
	1576	+
	1577	+ if (c->post == 0 && stream->stream_type == STREAM_TYPE_LIVE)
	1578	+ current_bandwidth += stream->bandwidth;
	1579	+
	1580	+ /* If already streaming this feed, do not let start another feeder. */
	1581	+ if (stream->feed_opened) {
	1582	+ snprintf(msg, sizeof(msg), "This feed is already being received.");
	1583	+ http_log("Feed '%s' already being received\n", stream->feed_filename);
	1584	+ goto send_error;
	1585	+ }
	1586	+
	1587	+ if (c->post == 0 && max_bandwidth < current_bandwidth) {
	1588	+ c->http_error = 503;
	1589	+ q = c->buffer;
	1590	+ q += snprintf(q, c->buffer_size,
	1591	+ "HTTP/1.0 503 Server too busy\r\n"
	1592	+ "Content-type: text/html\r\n"
	1593	+ "\r\n"
	1594	+ "<html><head><title>Too busy</title></head><body>\r\n"
	1595	+ "<p>The server is too busy to serve your request at this time.</p>\r\n"
	1596	+ "<p>The bandwidth being served (including your stream) is %"PRIu64"kbit/sec, "
	1597	+ "and this exceeds the limit of %"PRIu64"kbit/sec.</p>\r\n"
	1598	+ "</body></html>\r\n", current_bandwidth, max_bandwidth);
	1599	+ /* prepare output buffer */
	1600	+ c->buffer_ptr = c->buffer;
	1601	+ c->buffer_end = q;
	1602	+ c->state = HTTPSTATE_SEND_HEADER;
	1603	+ return 0;
	1604	+ }
	1605	+
	1606	+ if (redir_type != REDIR_NONE) {
	1607	+ char *hostinfo = 0;
	1608	+
	1609	+ for (p = c->buffer; p && p != '\r' && *p != '\n'; ) {
	1610	+ if (strncasecmp(p, "Host:", 5) == 0) {
	1611	+ hostinfo = p + 5;
	1612	+ break;
	1613	+ }
	1614	+ p = strchr(p, '\n');
	1615	+ if (!p)
	1616	+ break;
	1617	+
	1618	+ p++;
	1619	+ }
	1620	+
	1621	+ if (hostinfo) {
	1622	+ char *eoh;
	1623	+ char hostbuf[260];
	1624	+
	1625	+ while (isspace(*hostinfo))
	1626	+ hostinfo++;
	1627	+
	1628	+ eoh = strchr(hostinfo, '\n');
	1629	+ if (eoh) {
	1630	+ if (eoh[-1] == '\r')
	1631	+ eoh--;
	1632	+
	1633	+ if (eoh - hostinfo < sizeof(hostbuf) - 1) {
	1634	+ memcpy(hostbuf, hostinfo, eoh - hostinfo);
	1635	+ hostbuf[eoh - hostinfo] = 0;
	1636	+
	1637	+ c->http_error = 200;
	1638	+ q = c->buffer;
	1639	+ switch(redir_type) {
	1640	+ case REDIR_ASX:
	1641	+ q += snprintf(q, c->buffer_size,
	1642	+ "HTTP/1.0 200 ASX Follows\r\n"
	1643	+ "Content-type: video/x-ms-asf\r\n"
	1644	+ "\r\n"
	1645	+ "<ASX Version=\"3\">\r\n"
	1646	+ //"<!-- Autogenerated by avserver -->\r\n"
	1647	+ "<ENTRY><REF HREF=\"http://%s/%s%s\"/></ENTRY>\r\n"
	1648	+ "</ASX>\r\n", hostbuf, filename, info);
	1649	+ break;
	1650	+ case REDIR_RAM:
	1651	+ q += snprintf(q, c->buffer_size,
	1652	+ "HTTP/1.0 200 RAM Follows\r\n"
	1653	+ "Content-type: audio/x-pn-realaudio\r\n"
	1654	+ "\r\n"
	1655	+ "# Autogenerated by avserver\r\n"
	1656	+ "http://%s/%s%s\r\n", hostbuf, filename, info);
	1657	+ break;
	1658	+ case REDIR_ASF:
	1659	+ q += snprintf(q, c->buffer_size,
	1660	+ "HTTP/1.0 200 ASF Redirect follows\r\n"
	1661	+ "Content-type: video/x-ms-asf\r\n"
	1662	+ "\r\n"
	1663	+ "[Reference]\r\n"
	1664	+ "Ref1=http://%s/%s%s\r\n", hostbuf, filename, info);
	1665	+ break;
	1666	+ case REDIR_RTSP:
	1667	+ {
	1668	+ char hostname[256], *p;
	1669	+ /* extract only hostname */
	1670	+ av_strlcpy(hostname, hostbuf, sizeof(hostname));
	1671	+ p = strrchr(hostname, ':');
	1672	+ if (p)
	1673	+ *p = '\0';
	1674	+ q += snprintf(q, c->buffer_size,
	1675	+ "HTTP/1.0 200 RTSP Redirect follows\r\n"
	1676	+ /* XXX: incorrect mime type ? */
	1677	+ "Content-type: application/x-rtsp\r\n"
	1678	+ "\r\n"
	1679	+ "rtsp://%s:%d/%s\r\n", hostname, ntohs(my_rtsp_addr.sin_port), filename);
	1680	+ }
	1681	+ break;
	1682	+ case REDIR_SDP:
	1683	+ {
	1684	+ uint8_t *sdp_data;
	1685	+ int sdp_data_size, len;
	1686	+ struct sockaddr_in my_addr;
	1687	+
	1688	+ q += snprintf(q, c->buffer_size,
	1689	+ "HTTP/1.0 200 OK\r\n"
	1690	+ "Content-type: application/sdp\r\n"
	1691	+ "\r\n");
	1692	+
	1693	+ len = sizeof(my_addr);
	1694	+ getsockname(c->fd, (struct sockaddr *)&my_addr, &len);
	1695	+
	1696	+ /* XXX: should use a dynamic buffer */
	1697	+ sdp_data_size = prepare_sdp_description(stream,
	1698	+ &sdp_data,
	1699	+ my_addr.sin_addr);
	1700	+ if (sdp_data_size > 0) {
	1701	+ memcpy(q, sdp_data, sdp_data_size);
	1702	+ q += sdp_data_size;
	1703	+ *q = '\0';
	1704	+ av_free(sdp_data);
	1705	+ }
	1706	+ }
	1707	+ break;
	1708	+ default:
	1709	+ abort();
	1710	+ break;
	1711	+ }
	1712	+
	1713	+ /* prepare output buffer */
	1714	+ c->buffer_ptr = c->buffer;
	1715	+ c->buffer_end = q;
	1716	+ c->state = HTTPSTATE_SEND_HEADER;
	1717	+ return 0;
	1718	+ }
	1719	+ }
	1720	+ }
	1721	+
	1722	+ snprintf(msg, sizeof(msg), "ASX/RAM file not handled");
	1723	+ goto send_error;
	1724	+ }
	1725	+
	1726	+ stream->conns_served++;
	1727	+
	1728	+ /* XXX: add there authenticate and IP match */
	1729	+
	1730	+ if (c->post) {
	1731	+ /* if post, it means a feed is being sent */
	1732	+ if (!stream->is_feed) {
	1733	+ /* However it might be a status report from WMP! Let us log the
	1734	+ * data as it might come in handy one day. */
	1735	+ char *logline = 0;
	1736	+ int client_id = 0;
	1737	+
	1738	+ for (p = c->buffer; p && p != '\r' && *p != '\n'; ) {
	1739	+ if (strncasecmp(p, "Pragma: log-line=", 17) == 0) {
	1740	+ logline = p;
	1741	+ break;
	1742	+ }
	1743	+ if (strncasecmp(p, "Pragma: client-id=", 18) == 0)
	1744	+ client_id = strtol(p + 18, 0, 10);
	1745	+ p = strchr(p, '\n');
	1746	+ if (!p)
	1747	+ break;
	1748	+
	1749	+ p++;
	1750	+ }
	1751	+
	1752	+ if (logline) {
	1753	+ char *eol = strchr(logline, '\n');
	1754	+
	1755	+ logline += 17;
	1756	+
	1757	+ if (eol) {
	1758	+ if (eol[-1] == '\r')
	1759	+ eol--;
	1760	+ http_log("%.*s\n", (int) (eol - logline), logline);
	1761	+ c->suppress_log = 1;
	1762	+ }
	1763	+ }
	1764	+
	1765	+#ifdef DEBUG
	1766	+ http_log("\nGot request:\n%s\n", c->buffer);
	1767	+#endif
	1768	+
	1769	+ if (client_id && extract_rates(ratebuf, sizeof(ratebuf), c->buffer)) {
	1770	+ HTTPContext *wmpc;
	1771	+
	1772	+ /* Now we have to find the client_id */
	1773	+ for (wmpc = first_http_ctx; wmpc; wmpc = wmpc->next) {
	1774	+ if (wmpc->wmp_client_id == client_id)
	1775	+ break;
	1776	+ }
	1777	+
	1778	+ if (wmpc && modify_current_stream(wmpc, ratebuf))
	1779	+ wmpc->switch_pending = 1;
	1780	+ }
	1781	+
	1782	+ snprintf(msg, sizeof(msg), "POST command not handled");
	1783	+ c->stream = 0;
	1784	+ goto send_error;
	1785	+ }
	1786	+ if (http_start_receive_data(c) < 0) {
	1787	+ snprintf(msg, sizeof(msg), "could not open feed");
	1788	+ goto send_error;
	1789	+ }
	1790	+ c->http_error = 0;
	1791	+ c->state = HTTPSTATE_RECEIVE_DATA;
	1792	+ return 0;
	1793	+ }
	1794	+
	1795	+#ifdef DEBUG
	1796	+ if (strcmp(stream->filename + strlen(stream->filename) - 4, ".asf") == 0)
	1797	+ http_log("\nGot request:\n%s\n", c->buffer);
	1798	+#endif
	1799	+
	1800	+ if (c->stream->stream_type == STREAM_TYPE_STATUS)
	1801	+ goto send_status;
	1802	+
	1803	+ /* open input stream */
	1804	+ if (open_input_stream(c, info) < 0) {
	1805	+ snprintf(msg, sizeof(msg), "Input stream corresponding to '%s' not found", url);
	1806	+ goto send_error;
	1807	+ }
	1808	+
	1809	+ /* prepare http header */
	1810	+ q = c->buffer;
	1811	+ q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "HTTP/1.0 200 OK\r\n");
	1812	+ mime_type = c->stream->fmt->mime_type;
	1813	+ if (!mime_type)
	1814	+ mime_type = "application/x-octet-stream";
	1815	+ q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "Pragma: no-cache\r\n");
	1816	+
	1817	+ /* for asf, we need extra headers */
	1818	+ if (!strcmp(c->stream->fmt->name,"asf_stream")) {
	1819	+ /* Need to allocate a client id */
	1820	+
	1821	+ c->wmp_client_id = av_lfg_get(&random_state);
	1822	+
	1823	+ q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "Server: Cougar 4.1.0.3923\r\nCache-Control: no-cache\r\nPragma: client-id=%d\r\nPragma: features=\"broadcast\"\r\n", c->wmp_client_id);
	1824	+ }
	1825	+ q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "Content-Type: %s\r\n", mime_type);
	1826	+ q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "\r\n");
	1827	+
	1828	+ /* prepare output buffer */
	1829	+ c->http_error = 0;
	1830	+ c->buffer_ptr = c->buffer;
	1831	+ c->buffer_end = q;
	1832	+ c->state = HTTPSTATE_SEND_HEADER;
	1833	+ return 0;
	1834	+ send_error:
	1835	+ c->http_error = 404;
	1836	+ q = c->buffer;
	1837	+ q += snprintf(q, c->buffer_size,
	1838	+ "HTTP/1.0 404 Not Found\r\n"
	1839	+ "Content-type: text/html\r\n"
	1840	+ "\r\n"
	1841	+ "<html>\n"
	1842	+ "<head><title>404 Not Found</title></head>\n"
	1843	+ "<body>%s</body>\n"
	1844	+ "</html>\n", msg);
	1845	+ /* prepare output buffer */
	1846	+ c->buffer_ptr = c->buffer;
	1847	+ c->buffer_end = q;
	1848	+ c->state = HTTPSTATE_SEND_HEADER;
	1849	+ return 0;
	1850	+ send_status:
	1851	+ compute_status(c);
	1852	+ c->http_error = 200; /* horrible : we use this value to avoid
	1853	+ going to the send data state */
	1854	+ c->state = HTTPSTATE_SEND_HEADER;
	1855	+ return 0;
	1856	+}
	1857	+
	1858	+static void fmt_bytecount(AVIOContext *pb, int64_t count)
	1859	+{
	1860	+ static const char *suffix = " kMGTP";
	1861	+ const char *s;
	1862	+
	1863	+ for (s = suffix; count >= 100000 && s[1]; count /= 1000, s++);
	1864	+
	1865	+ avio_printf(pb, "%"PRId64"%c", count, *s);
	1866	+}
	1867	+
	1868	+static void compute_status(HTTPContext *c)
	1869	+{
	1870	+ HTTPContext *c1;
	1871	+ FFStream *stream;
	1872	+ char *p;
	1873	+ time_t ti;
	1874	+ int i, len;
	1875	+ AVIOContext *pb;
	1876	+
	1877	+ if (avio_open_dyn_buf(&pb) < 0) {
	1878	+ /* XXX: return an error ? */
	1879	+ c->buffer_ptr = c->buffer;
	1880	+ c->buffer_end = c->buffer;
	1881	+ return;
	1882	+ }
	1883	+
	1884	+ avio_printf(pb, "HTTP/1.0 200 OK\r\n");
	1885	+ avio_printf(pb, "Content-type: %s\r\n", "text/html");
	1886	+ avio_printf(pb, "Pragma: no-cache\r\n");
	1887	+ avio_printf(pb, "\r\n");
	1888	+
	1889	+ avio_printf(pb, "<html><head><title>%s Status</title>\n", program_name);
	1890	+ if (c->stream->feed_filename[0])
	1891	+ avio_printf(pb, "<link rel=\"shortcut icon\" href=\"%s\">\n", c->stream->feed_filename);
	1892	+ avio_printf(pb, "</head>\n<body>");
	1893	+ avio_printf(pb, "<h1>%s Status</h1>\n", program_name);
	1894	+ /* format status */
	1895	+ avio_printf(pb, "<h2>Available Streams</h2>\n");
	1896	+ avio_printf(pb, "<table cellspacing=0 cellpadding=4>\n");
	1897	+ avio_printf(pb, "<tr><th valign=top>Path<th align=left>Served<br>Conns<th><br>bytes<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");
	1898	+ stream = first_stream;
	1899	+ while (stream != NULL) {
	1900	+ char sfilename[1024];
	1901	+ char *eosf;
	1902	+
	1903	+ if (stream->feed != stream) {
	1904	+ av_strlcpy(sfilename, stream->filename, sizeof(sfilename) - 10);
	1905	+ eosf = sfilename + strlen(sfilename);
	1906	+ if (eosf - sfilename >= 4) {
	1907	+ if (strcmp(eosf - 4, ".asf") == 0)
	1908	+ strcpy(eosf - 4, ".asx");
	1909	+ else if (strcmp(eosf - 3, ".rm") == 0)
	1910	+ strcpy(eosf - 3, ".ram");
	1911	+ else if (stream->fmt && !strcmp(stream->fmt->name, "rtp")) {
	1912	+ /* generate a sample RTSP director if
	1913	+ unicast. Generate an SDP redirector if
	1914	+ multicast */
	1915	+ eosf = strrchr(sfilename, '.');
	1916	+ if (!eosf)
	1917	+ eosf = sfilename + strlen(sfilename);
	1918	+ if (stream->is_multicast)
	1919	+ strcpy(eosf, ".sdp");
	1920	+ else
	1921	+ strcpy(eosf, ".rtsp");
	1922	+ }
	1923	+ }
	1924	+
	1925	+ avio_printf(pb, "<tr><td><a href=\"/%s\">%s</a> ",
	1926	+ sfilename, stream->filename);
	1927	+ avio_printf(pb, "<td align=right> %d <td align=right> ",
	1928	+ stream->conns_served);
	1929	+ fmt_bytecount(pb, stream->bytes_served);
	1930	+ switch(stream->stream_type) {
	1931	+ case STREAM_TYPE_LIVE: {
	1932	+ int audio_bit_rate = 0;
	1933	+ int video_bit_rate = 0;
	1934	+ const char *audio_codec_name = "";
	1935	+ const char *video_codec_name = "";
	1936	+ const char *audio_codec_name_extra = "";
	1937	+ const char *video_codec_name_extra = "";
	1938	+
	1939	+ for(i=0;i<stream->nb_streams;i++) {
	1940	+ AVStream *st = stream->streams[i];
	1941	+ AVCodec *codec = avcodec_find_encoder(st->codec->codec_id);
	1942	+ switch(st->codec->codec_type) {
	1943	+ case AVMEDIA_TYPE_AUDIO:
	1944	+ audio_bit_rate += st->codec->bit_rate;
	1945	+ if (codec) {
	1946	+ if (*audio_codec_name)
	1947	+ audio_codec_name_extra = "...";
	1948	+ audio_codec_name = codec->name;
	1949	+ }
	1950	+ break;
	1951	+ case AVMEDIA_TYPE_VIDEO:
	1952	+ video_bit_rate += st->codec->bit_rate;
	1953	+ if (codec) {
	1954	+ if (*video_codec_name)
	1955	+ video_codec_name_extra = "...";
	1956	+ video_codec_name = codec->name;
	1957	+ }
	1958	+ break;
	1959	+ case AVMEDIA_TYPE_DATA:
	1960	+ video_bit_rate += st->codec->bit_rate;
	1961	+ break;
	1962	+ default:
	1963	+ abort();
	1964	+ }
	1965	+ }
	1966	+ avio_printf(pb, "<td align=center> %s <td align=right> %d <td align=right> %d <td> %s %s <td align=right> %d <td> %s %s",
	1967	+ stream->fmt->name,
	1968	+ stream->bandwidth,
	1969	+ video_bit_rate / 1000, video_codec_name, video_codec_name_extra,
	1970	+ audio_bit_rate / 1000, audio_codec_name, audio_codec_name_extra);
	1971	+ if (stream->feed)
	1972	+ avio_printf(pb, "<td>%s", stream->feed->filename);
	1973	+ else
	1974	+ avio_printf(pb, "<td>%s", stream->feed_filename);
	1975	+ avio_printf(pb, "\n");
	1976	+ }
	1977	+ break;
	1978	+ default:
	1979	+ avio_printf(pb, "<td align=center> - <td align=right> - <td align=right> - <td><td align=right> - <td>\n");
	1980	+ break;
	1981	+ }
	1982	+ }
	1983	+ stream = stream->next;
	1984	+ }
	1985	+ avio_printf(pb, "</table>\n");
	1986	+
	1987	+ stream = first_stream;
	1988	+ while (stream != NULL) {
	1989	+ if (stream->feed == stream) {
	1990	+ avio_printf(pb, "<h2>Feed %s</h2>", stream->filename);
	1991	+ if (stream->pid) {
	1992	+ avio_printf(pb, "Running as pid %d.\n", stream->pid);
	1993	+
	1994	+#if defined(linux) && !defined(CONFIG_NOCUTILS)
	1995	+ {
	1996	+ FILE *pid_stat;
	1997	+ char ps_cmd[64];
	1998	+
	1999	+ /* This is somewhat linux specific I guess */
	2000	+ snprintf(ps_cmd, sizeof(ps_cmd),
	2001	+ "ps -o \"%%cpu,cputime\" --no-headers %d",
	2002	+ stream->pid);
	2003	+
	2004	+ pid_stat = popen(ps_cmd, "r");
	2005	+ if (pid_stat) {
	2006	+ char cpuperc[10];
	2007	+ char cpuused[64];
	2008	+
	2009	+ if (fscanf(pid_stat, "%10s %64s", cpuperc,
	2010	+ cpuused) == 2) {
	2011	+ avio_printf(pb, "Currently using %s%% of the cpu. Total time used %s.\n",
	2012	+ cpuperc, cpuused);
	2013	+ }
	2014	+ fclose(pid_stat);
	2015	+ }
	2016	+ }
	2017	+#endif
	2018	+
	2019	+ avio_printf(pb, "<p>");
	2020	+ }
	2021	+ avio_printf(pb, "<table cellspacing=0 cellpadding=4><tr><th>Stream<th>type<th>kbits/s<th align=left>codec<th align=left>Parameters\n");
	2022	+
	2023	+ for (i = 0; i < stream->nb_streams; i++) {
	2024	+ AVStream *st = stream->streams[i];
	2025	+ AVCodec *codec = avcodec_find_encoder(st->codec->codec_id);
	2026	+ const char *type = "unknown";
	2027	+ char parameters[64];
	2028	+
	2029	+ parameters[0] = 0;
	2030	+
	2031	+ switch(st->codec->codec_type) {
	2032	+ case AVMEDIA_TYPE_AUDIO:
	2033	+ type = "audio";
	2034	+ snprintf(parameters, sizeof(parameters), "%d channel(s), %d Hz", st->codec->channels, st->codec->sample_rate);
	2035	+ break;
	2036	+ case AVMEDIA_TYPE_VIDEO:
	2037	+ type = "video";
	2038	+ snprintf(parameters, sizeof(parameters), "%dx%d, q=%d-%d, fps=%d", st->codec->width, st->codec->height,
	2039	+ st->codec->qmin, st->codec->qmax, st->codec->time_base.den / st->codec->time_base.num);
	2040	+ break;
	2041	+ default:
	2042	+ abort();
	2043	+ }
	2044	+ avio_printf(pb, "<tr><td align=right>%d<td>%s<td align=right>%d<td>%s<td>%s\n",
	2045	+ i, type, st->codec->bit_rate/1000, codec ? codec->name : "", parameters);
	2046	+ }
	2047	+ avio_printf(pb, "</table>\n");
	2048	+
	2049	+ }
	2050	+ stream = stream->next;
	2051	+ }
	2052	+
	2053	+ /* connection status */
	2054	+ avio_printf(pb, "<h2>Connection Status</h2>\n");
	2055	+
	2056	+ avio_printf(pb, "Number of connections: %d / %d<br>\n",
	2057	+ nb_connections, nb_max_connections);
	2058	+
	2059	+ avio_printf(pb, "Bandwidth in use: %"PRIu64"k / %"PRIu64"k<br>\n",
	2060	+ current_bandwidth, max_bandwidth);
	2061	+
	2062	+ avio_printf(pb, "<table>\n");
	2063	+ avio_printf(pb, "<tr><th>#<th>File<th>IP<th>Proto<th>State<th>Target bits/sec<th>Actual bits/sec<th>Bytes transferred\n");
	2064	+ c1 = first_http_ctx;
	2065	+ i = 0;
	2066	+ while (c1 != NULL) {
	2067	+ int bitrate;
	2068	+ int j;
	2069	+
	2070	+ bitrate = 0;
	2071	+ if (c1->stream) {
	2072	+ for (j = 0; j < c1->stream->nb_streams; j++) {
	2073	+ if (!c1->stream->feed)
	2074	+ bitrate += c1->stream->streams[j]->codec->bit_rate;
	2075	+ else if (c1->feed_streams[j] >= 0)
	2076	+ bitrate += c1->stream->feed->streams[c1->feed_streams[j]]->codec->bit_rate;
	2077	+ }
	2078	+ }
	2079	+
	2080	+ i++;
	2081	+ p = inet_ntoa(c1->from_addr.sin_addr);
	2082	+ avio_printf(pb, "<tr><td><b>%d</b><td>%s%s<td>%s<td>%s<td>%s<td align=right>",
	2083	+ i,
	2084	+ c1->stream ? c1->stream->filename : "",
	2085	+ c1->state == HTTPSTATE_RECEIVE_DATA ? "(input)" : "",
	2086	+ p,
	2087	+ c1->protocol,
	2088	+ http_state[c1->state]);
	2089	+ fmt_bytecount(pb, bitrate);
	2090	+ avio_printf(pb, "<td align=right>");
	2091	+ fmt_bytecount(pb, compute_datarate(&c1->datarate, c1->data_count) * 8);
	2092	+ avio_printf(pb, "<td align=right>");
	2093	+ fmt_bytecount(pb, c1->data_count);
	2094	+ avio_printf(pb, "\n");
	2095	+ c1 = c1->next;
	2096	+ }
	2097	+ avio_printf(pb, "</table>\n");
	2098	+
	2099	+ /* date */
	2100	+ ti = time(NULL);
	2101	+ p = ctime(&ti);
	2102	+ avio_printf(pb, "<hr size=1 noshade>Generated at %s", p);
	2103	+ avio_printf(pb, "</body>\n</html>\n");
	2104	+
	2105	+ len = avio_close_dyn_buf(pb, &c->pb_buffer);
	2106	+ c->buffer_ptr = c->pb_buffer;
	2107	+ c->buffer_end = c->pb_buffer + len;
	2108	+}
	2109	+
	2110	+/* check if the parser needs to be opened for stream i */
	2111	+static void open_parser(AVFormatContext *s, int i)
	2112	+{
	2113	+ AVStream *st = s->streams[i];
	2114	+ AVCodec *codec;
	2115	+
	2116	+ if (!st->codec->codec) {
	2117	+ codec = avcodec_find_decoder(st->codec->codec_id);
	2118	+ if (codec && (codec->capabilities & CODEC_CAP_PARSE_ONLY)) {
	2119	+ st->codec->parse_only = 1;
	2120	+ if (avcodec_open2(st->codec, codec, NULL) < 0)
	2121	+ st->codec->parse_only = 0;
	2122	+ }
	2123	+ }
	2124	+}
	2125	+
	2126	+static int open_input_stream(HTTPContext c, const char info)
	2127	+{
	2128	+ char buf[128];
	2129	+ char input_filename[1024];
	2130	+ AVFormatContext *s = NULL;
	2131	+ int i, ret;
	2132	+ int64_t stream_pos;
	2133	+
	2134	+ /* find file name */
	2135	+ if (c->stream->feed) {
	2136	+ strcpy(input_filename, c->stream->feed->feed_filename);
	2137	+ /* compute position (absolute time) */
	2138	+ if (av_find_info_tag(buf, sizeof(buf), "date", info)) {
	2139	+ if ((ret = av_parse_time(&stream_pos, buf, 0)) < 0)
	2140	+ return ret;
	2141	+ } else if (av_find_info_tag(buf, sizeof(buf), "buffer", info)) {
	2142	+ int prebuffer = strtol(buf, 0, 10);
	2143	+ stream_pos = av_gettime() - prebuffer * (int64_t)1000000;
	2144	+ } else
	2145	+ stream_pos = av_gettime() - c->stream->prebuffer * (int64_t)1000;
	2146	+ } else {
	2147	+ strcpy(input_filename, c->stream->feed_filename);
	2148	+ /* compute position (relative time) */
	2149	+ if (av_find_info_tag(buf, sizeof(buf), "date", info)) {
	2150	+ if ((ret = av_parse_time(&stream_pos, buf, 1)) < 0)
	2151	+ return ret;
	2152	+ } else
	2153	+ stream_pos = 0;
	2154	+ }
	2155	+ if (input_filename[0] == '\0')
	2156	+ return -1;
	2157	+
	2158	+ /* open stream */
	2159	+ if ((ret = avformat_open_input(&s, input_filename, c->stream->ifmt, &c->stream->in_opts)) < 0) {
	2160	+ http_log("could not open %s: %d\n", input_filename, ret);
	2161	+ return -1;
	2162	+ }
	2163	+ s->flags \|= AVFMT_FLAG_GENPTS;
	2164	+ c->fmt_in = s;
	2165	+ if (strcmp(s->iformat->name, "ffm") && av_find_stream_info(c->fmt_in) < 0) {
	2166	+ http_log("Could not find stream info '%s'\n", input_filename);
	2167	+ av_close_input_file(s);
	2168	+ return -1;
	2169	+ }
	2170	+
	2171	+ /* open each parser */
	2172	+ for(i=0;i<s->nb_streams;i++)
	2173	+ open_parser(s, i);
	2174	+
	2175	+ /* choose stream as clock source (we favorize video stream if
	2176	+ present) for packet sending */
	2177	+ c->pts_stream_index = 0;
	2178	+ for(i=0;i<c->stream->nb_streams;i++) {
	2179	+ if (c->pts_stream_index == 0 &&
	2180	+ c->stream->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
	2181	+ c->pts_stream_index = i;
	2182	+ }
	2183	+ }
	2184	+
	2185	+ if (c->fmt_in->iformat->read_seek)
	2186	+ av_seek_frame(c->fmt_in, -1, stream_pos, 0);
	2187	+ /* set the start time (needed for maxtime and RTP packet timing) */
	2188	+ c->start_time = cur_time;
	2189	+ c->first_pts = AV_NOPTS_VALUE;
	2190	+ return 0;
	2191	+}
	2192	+
	2193	+/* return the server clock (in us) */
	2194	+static int64_t get_server_clock(HTTPContext *c)
	2195	+{
	2196	+ /* compute current pts value from system time */
	2197	+ return (cur_time - c->start_time) * 1000;
	2198	+}
	2199	+
	2200	+/* return the estimated time at which the current packet must be sent
	2201	+ (in us) */
	2202	+static int64_t get_packet_send_clock(HTTPContext *c)
	2203	+{
	2204	+ int bytes_left, bytes_sent, frame_bytes;
	2205	+
	2206	+ frame_bytes = c->cur_frame_bytes;
	2207	+ if (frame_bytes <= 0)
	2208	+ return c->cur_pts;
	2209	+ else {
	2210	+ bytes_left = c->buffer_end - c->buffer_ptr;
	2211	+ bytes_sent = frame_bytes - bytes_left;
	2212	+ return c->cur_pts + (c->cur_frame_duration * bytes_sent) / frame_bytes;
	2213	+ }
	2214	+}
	2215	+
	2216	+
	2217	+static int http_prepare_data(HTTPContext *c)
	2218	+{
	2219	+ int i, len, ret;
	2220	+ AVFormatContext *ctx;
	2221	+
	2222	+ av_freep(&c->pb_buffer);
	2223	+ switch(c->state) {
	2224	+ case HTTPSTATE_SEND_DATA_HEADER:
	2225	+ memset(&c->fmt_ctx, 0, sizeof(c->fmt_ctx));
	2226	+ av_dict_set(&c->fmt_ctx.metadata, "author" , c->stream->author , 0);
	2227	+ av_dict_set(&c->fmt_ctx.metadata, "comment" , c->stream->comment , 0);
	2228	+ av_dict_set(&c->fmt_ctx.metadata, "copyright", c->stream->copyright, 0);
	2229	+ av_dict_set(&c->fmt_ctx.metadata, "title" , c->stream->title , 0);
	2230	+
	2231	+ c->fmt_ctx.streams = av_mallocz(sizeof(AVStream ) c->stream->nb_streams);
	2232	+
	2233	+ for(i=0;i<c->stream->nb_streams;i++) {
	2234	+ AVStream *src;
	2235	+ c->fmt_ctx.streams[i] = av_mallocz(sizeof(AVStream));
	2236	+ /* if file or feed, then just take streams from FFStream struct */
	2237	+ if (!c->stream->feed \|\|
	2238	+ c->stream->feed == c->stream)
	2239	+ src = c->stream->streams[i];
	2240	+ else
	2241	+ src = c->stream->feed->streams[c->stream->feed_streams[i]];
	2242	+
	2243	+ (c->fmt_ctx.streams[i]) = src;
	2244	+ c->fmt_ctx.streams[i]->priv_data = 0;
	2245	+ c->fmt_ctx.streams[i]->codec->frame_number = 0; /* XXX: should be done in
	2246	+ AVStream, not in codec */
	2247	+ }
	2248	+ /* set output format parameters */
	2249	+ c->fmt_ctx.oformat = c->stream->fmt;
	2250	+ c->fmt_ctx.nb_streams = c->stream->nb_streams;
	2251	+
	2252	+ c->got_key_frame = 0;
	2253	+
	2254	+ /* prepare header and save header data in a stream */
	2255	+ if (avio_open_dyn_buf(&c->fmt_ctx.pb) < 0) {
	2256	+ /* XXX: potential leak */
	2257	+ return -1;
	2258	+ }
	2259	+ c->fmt_ctx.pb->seekable = 0;
	2260	+
	2261	+ /*
	2262	+ * HACK to avoid mpeg ps muxer to spit many underflow errors
	2263	+ * Default value from Libav
	2264	+ * Try to set it use configuration option
	2265	+ */
	2266	+ c->fmt_ctx.preload = (int)(0.5*AV_TIME_BASE);
	2267	+ c->fmt_ctx.max_delay = (int)(0.7*AV_TIME_BASE);
	2268	+
	2269	+ if (avformat_write_header(&c->fmt_ctx, NULL) < 0) {
	2270	+ http_log("Error writing output header\n");
	2271	+ return -1;
	2272	+ }
	2273	+ av_dict_free(&c->fmt_ctx.metadata);
	2274	+
	2275	+ len = avio_close_dyn_buf(c->fmt_ctx.pb, &c->pb_buffer);
	2276	+ c->buffer_ptr = c->pb_buffer;
	2277	+ c->buffer_end = c->pb_buffer + len;
	2278	+
	2279	+ c->state = HTTPSTATE_SEND_DATA;
	2280	+ c->last_packet_sent = 0;
	2281	+ break;
	2282	+ case HTTPSTATE_SEND_DATA:
	2283	+ /* find a new packet */
	2284	+ /* read a packet from the input stream */
	2285	+ if (c->stream->feed)
	2286	+ ffm_set_write_index(c->fmt_in,
	2287	+ c->stream->feed->feed_write_index,
	2288	+ c->stream->feed->feed_size);
	2289	+
	2290	+ if (c->stream->max_time &&
	2291	+ c->stream->max_time + c->start_time - cur_time < 0)
	2292	+ /* We have timed out */
	2293	+ c->state = HTTPSTATE_SEND_DATA_TRAILER;
	2294	+ else {
	2295	+ AVPacket pkt;
	2296	+ redo:
	2297	+ ret = av_read_frame(c->fmt_in, &pkt);
	2298	+ if (ret < 0) {
	2299	+ if (c->stream->feed) {
	2300	+ /* if coming from feed, it means we reached the end of the
	2301	+ ffm file, so must wait for more data */
	2302	+ c->state = HTTPSTATE_WAIT_FEED;
	2303	+ return 1; /* state changed */
	2304	+ } else if (ret == AVERROR(EAGAIN)) {
	2305	+ /* input not ready, come back later */
	2306	+ return 0;
	2307	+ } else {
	2308	+ if (c->stream->loop) {
	2309	+ av_close_input_file(c->fmt_in);
	2310	+ c->fmt_in = NULL;
	2311	+ if (open_input_stream(c, "") < 0)
	2312	+ goto no_loop;
	2313	+ goto redo;
	2314	+ } else {
	2315	+ no_loop:
	2316	+ /* must send trailer now because eof or error */
	2317	+ c->state = HTTPSTATE_SEND_DATA_TRAILER;
	2318	+ }
	2319	+ }
	2320	+ } else {
	2321	+ int source_index = pkt.stream_index;
	2322	+ /* update first pts if needed */
	2323	+ if (c->first_pts == AV_NOPTS_VALUE) {
	2324	+ c->first_pts = av_rescale_q(pkt.dts, c->fmt_in->streams[pkt.stream_index]->time_base, AV_TIME_BASE_Q);
	2325	+ c->start_time = cur_time;
	2326	+ }
	2327	+ /* send it to the appropriate stream */
	2328	+ if (c->stream->feed) {
	2329	+ /* if coming from a feed, select the right stream */
	2330	+ if (c->switch_pending) {
	2331	+ c->switch_pending = 0;
	2332	+ for(i=0;i<c->stream->nb_streams;i++) {
	2333	+ if (c->switch_feed_streams[i] == pkt.stream_index)
	2334	+ if (pkt.flags & AV_PKT_FLAG_KEY)
	2335	+ c->switch_feed_streams[i] = -1;
	2336	+ if (c->switch_feed_streams[i] >= 0)
	2337	+ c->switch_pending = 1;
	2338	+ }
	2339	+ }
	2340	+ for(i=0;i<c->stream->nb_streams;i++) {
	2341	+ if (c->stream->feed_streams[i] == pkt.stream_index) {
	2342	+ AVStream *st = c->fmt_in->streams[source_index];
	2343	+ pkt.stream_index = i;
	2344	+ if (pkt.flags & AV_PKT_FLAG_KEY &&
	2345	+ (st->codec->codec_type == AVMEDIA_TYPE_VIDEO \|\|
	2346	+ c->stream->nb_streams == 1))
	2347	+ c->got_key_frame = 1;
	2348	+ if (!c->stream->send_on_key \|\| c->got_key_frame)
	2349	+ goto send_it;
	2350	+ }
	2351	+ }
	2352	+ } else {
	2353	+ AVCodecContext *codec;
	2354	+ AVStream ist, ost;
	2355	+ send_it:
	2356	+ ist = c->fmt_in->streams[source_index];
	2357	+ /* specific handling for RTP: we use several
	2358	+ output stream (one for each RTP
	2359	+ connection). XXX: need more abstract handling */
	2360	+ if (c->is_packetized) {
	2361	+ /* compute send time and duration */
	2362	+ c->cur_pts = av_rescale_q(pkt.dts, ist->time_base, AV_TIME_BASE_Q);
	2363	+ c->cur_pts -= c->first_pts;
	2364	+ c->cur_frame_duration = av_rescale_q(pkt.duration, ist->time_base, AV_TIME_BASE_Q);
	2365	+ /* find RTP context */
	2366	+ c->packet_stream_index = pkt.stream_index;
	2367	+ ctx = c->rtp_ctx[c->packet_stream_index];
	2368	+ if(!ctx) {
	2369	+ av_free_packet(&pkt);
	2370	+ break;
	2371	+ }
	2372	+ codec = ctx->streams[0]->codec;
	2373	+ /* only one stream per RTP connection */
	2374	+ pkt.stream_index = 0;
	2375	+ } else {
	2376	+ ctx = &c->fmt_ctx;
	2377	+ /* Fudge here */
	2378	+ codec = ctx->streams[pkt.stream_index]->codec;
	2379	+ }
	2380	+
	2381	+ if (c->is_packetized) {
	2382	+ int max_packet_size;
	2383	+ if (c->rtp_protocol == RTSP_LOWER_TRANSPORT_TCP)
	2384	+ max_packet_size = RTSP_TCP_MAX_PACKET_SIZE;
	2385	+ else
	2386	+ max_packet_size = url_get_max_packet_size(c->rtp_handles[c->packet_stream_index]);
	2387	+ ret = ffio_open_dyn_packet_buf(&ctx->pb, max_packet_size);
	2388	+ } else {
	2389	+ ret = avio_open_dyn_buf(&ctx->pb);
	2390	+ }
	2391	+ if (ret < 0) {
	2392	+ /* XXX: potential leak */
	2393	+ return -1;
	2394	+ }
	2395	+ ost = ctx->streams[pkt.stream_index];
	2396	+
	2397	+ ctx->pb->seekable = 0;
	2398	+ if (pkt.dts != AV_NOPTS_VALUE)
	2399	+ pkt.dts = av_rescale_q(pkt.dts, ist->time_base, ost->time_base);
	2400	+ if (pkt.pts != AV_NOPTS_VALUE)
	2401	+ pkt.pts = av_rescale_q(pkt.pts, ist->time_base, ost->time_base);
	2402	+ pkt.duration = av_rescale_q(pkt.duration, ist->time_base, ost->time_base);
	2403	+ if (av_write_frame(ctx, &pkt) < 0) {
	2404	+ http_log("Error writing frame to output\n");
	2405	+ c->state = HTTPSTATE_SEND_DATA_TRAILER;
	2406	+ }
	2407	+
	2408	+ len = avio_close_dyn_buf(ctx->pb, &c->pb_buffer);
	2409	+ c->cur_frame_bytes = len;
	2410	+ c->buffer_ptr = c->pb_buffer;
	2411	+ c->buffer_end = c->pb_buffer + len;
	2412	+
	2413	+ codec->frame_number++;
	2414	+ if (len == 0) {
	2415	+ av_free_packet(&pkt);
	2416	+ goto redo;
	2417	+ }
	2418	+ }
	2419	+ av_free_packet(&pkt);
	2420	+ }
	2421	+ }
	2422	+ break;
	2423	+ default:
	2424	+ case HTTPSTATE_SEND_DATA_TRAILER:
	2425	+ /* last packet test ? */
	2426	+ if (c->last_packet_sent \|\| c->is_packetized)
	2427	+ return -1;
	2428	+ ctx = &c->fmt_ctx;
	2429	+ /* prepare header */
	2430	+ if (avio_open_dyn_buf(&ctx->pb) < 0) {
	2431	+ /* XXX: potential leak */
	2432	+ return -1;
	2433	+ }
	2434	+ c->fmt_ctx.pb->seekable = 0;
	2435	+ av_write_trailer(ctx);
	2436	+ len = avio_close_dyn_buf(ctx->pb, &c->pb_buffer);
	2437	+ c->buffer_ptr = c->pb_buffer;
	2438	+ c->buffer_end = c->pb_buffer + len;
	2439	+
	2440	+ c->last_packet_sent = 1;
	2441	+ break;
	2442	+ }
	2443	+ return 0;
	2444	+}
	2445	+
	2446	+/* should convert the format at the same time */
	2447	+/* send data starting at c->buffer_ptr to the output connection
	2448	+ (either UDP or TCP connection) */
	2449	+static int http_send_data(HTTPContext *c)
	2450	+{
	2451	+ int len, ret;
	2452	+
	2453	+ for(;;) {
	2454	+ if (c->buffer_ptr >= c->buffer_end) {
	2455	+ ret = http_prepare_data(c);
	2456	+ if (ret < 0)
	2457	+ return -1;
	2458	+ else if (ret != 0)
	2459	+ /* state change requested */
	2460	+ break;
	2461	+ } else {
	2462	+ if (c->is_packetized) {
	2463	+ /* RTP data output */
	2464	+ len = c->buffer_end - c->buffer_ptr;
	2465	+ if (len < 4) {
	2466	+ /* fail safe - should never happen */
	2467	+ fail1:
	2468	+ c->buffer_ptr = c->buffer_end;
	2469	+ return 0;
	2470	+ }
	2471	+ len = (c->buffer_ptr[0] << 24) \|
	2472	+ (c->buffer_ptr[1] << 16) \|
	2473	+ (c->buffer_ptr[2] << 8) \|
	2474	+ (c->buffer_ptr[3]);
	2475	+ if (len > (c->buffer_end - c->buffer_ptr))
	2476	+ goto fail1;
	2477	+ if ((get_packet_send_clock(c) - get_server_clock(c)) > 0) {
	2478	+ /* nothing to send yet: we can wait */
	2479	+ return 0;
	2480	+ }
	2481	+
	2482	+ c->data_count += len;
	2483	+ update_datarate(&c->datarate, c->data_count);
	2484	+ if (c->stream)
	2485	+ c->stream->bytes_served += len;
	2486	+
	2487	+ if (c->rtp_protocol == RTSP_LOWER_TRANSPORT_TCP) {
	2488	+ /* RTP packets are sent inside the RTSP TCP connection */
	2489	+ AVIOContext *pb;
	2490	+ int interleaved_index, size;
	2491	+ uint8_t header[4];
	2492	+ HTTPContext *rtsp_c;
	2493	+
	2494	+ rtsp_c = c->rtsp_c;
	2495	+ /* if no RTSP connection left, error */
	2496	+ if (!rtsp_c)
	2497	+ return -1;
	2498	+ /* if already sending something, then wait. */
	2499	+ if (rtsp_c->state != RTSPSTATE_WAIT_REQUEST)
	2500	+ break;
	2501	+ if (avio_open_dyn_buf(&pb) < 0)
	2502	+ goto fail1;
	2503	+ interleaved_index = c->packet_stream_index * 2;
	2504	+ /* RTCP packets are sent at odd indexes */
	2505	+ if (c->buffer_ptr[1] == 200)
	2506	+ interleaved_index++;
	2507	+ /* write RTSP TCP header */
	2508	+ header[0] = '$';
	2509	+ header[1] = interleaved_index;
	2510	+ header[2] = len >> 8;
	2511	+ header[3] = len;
	2512	+ avio_write(pb, header, 4);
	2513	+ /* write RTP packet data */
	2514	+ c->buffer_ptr += 4;
	2515	+ avio_write(pb, c->buffer_ptr, len);
	2516	+ size = avio_close_dyn_buf(pb, &c->packet_buffer);
	2517	+ /* prepare asynchronous TCP sending */
	2518	+ rtsp_c->packet_buffer_ptr = c->packet_buffer;
	2519	+ rtsp_c->packet_buffer_end = c->packet_buffer + size;
	2520	+ c->buffer_ptr += len;
	2521	+
	2522	+ /* send everything we can NOW */
	2523	+ len = send(rtsp_c->fd, rtsp_c->packet_buffer_ptr,
	2524	+ rtsp_c->packet_buffer_end - rtsp_c->packet_buffer_ptr, 0);
	2525	+ if (len > 0)
	2526	+ rtsp_c->packet_buffer_ptr += len;
	2527	+ if (rtsp_c->packet_buffer_ptr < rtsp_c->packet_buffer_end) {
	2528	+ /* if we could not send all the data, we will
	2529	+ send it later, so a new state is needed to
	2530	+ "lock" the RTSP TCP connection */
	2531	+ rtsp_c->state = RTSPSTATE_SEND_PACKET;
	2532	+ break;
	2533	+ } else
	2534	+ /* all data has been sent */
	2535	+ av_freep(&c->packet_buffer);
	2536	+ } else {
	2537	+ /* send RTP packet directly in UDP */
	2538	+ c->buffer_ptr += 4;
	2539	+ url_write(c->rtp_handles[c->packet_stream_index],
	2540	+ c->buffer_ptr, len);
	2541	+ c->buffer_ptr += len;
	2542	+ /* here we continue as we can send several packets per 10 ms slot */
	2543	+ }
	2544	+ } else {
	2545	+ /* TCP data output */
	2546	+ len = send(c->fd, c->buffer_ptr, c->buffer_end - c->buffer_ptr, 0);
	2547	+ if (len < 0) {
	2548	+ if (ff_neterrno() != AVERROR(EAGAIN) &&
	2549	+ ff_neterrno() != AVERROR(EINTR))
	2550	+ /* error : close connection */
	2551	+ return -1;
	2552	+ else
	2553	+ return 0;
	2554	+ } else
	2555	+ c->buffer_ptr += len;
	2556	+
	2557	+ c->data_count += len;
	2558	+ update_datarate(&c->datarate, c->data_count);
	2559	+ if (c->stream)
	2560	+ c->stream->bytes_served += len;
	2561	+ break;
	2562	+ }
	2563	+ }
	2564	+ } /* for(;;) */
	2565	+ return 0;
	2566	+}
	2567	+
	2568	+static int http_start_receive_data(HTTPContext *c)
	2569	+{
	2570	+ int fd;
	2571	+
	2572	+ if (c->stream->feed_opened)
	2573	+ return -1;
	2574	+
	2575	+ /* Don't permit writing to this one */
	2576	+ if (c->stream->readonly)
	2577	+ return -1;
	2578	+
	2579	+ /* open feed */
	2580	+ fd = open(c->stream->feed_filename, O_RDWR);
	2581	+ if (fd < 0) {
	2582	+ http_log("Error opening feeder file: %s\n", strerror(errno));
	2583	+ return -1;
	2584	+ }
	2585	+ c->feed_fd = fd;
	2586	+
	2587	+ if (c->stream->truncate) {
	2588	+ /* truncate feed file */
	2589	+ ffm_write_write_index(c->feed_fd, FFM_PACKET_SIZE);
	2590	+ ftruncate(c->feed_fd, FFM_PACKET_SIZE);
	2591	+ http_log("Truncating feed file '%s'\n", c->stream->feed_filename);
	2592	+ } else {
	2593	+ if ((c->stream->feed_write_index = ffm_read_write_index(fd)) < 0) {
	2594	+ http_log("Error reading write index from feed file: %s\n", strerror(errno));
	2595	+ return -1;
	2596	+ }
	2597	+ }
	2598	+
	2599	+ c->stream->feed_write_index = FFMAX(ffm_read_write_index(fd), FFM_PACKET_SIZE);
	2600	+ c->stream->feed_size = lseek(fd, 0, SEEK_END);
	2601	+ lseek(fd, 0, SEEK_SET);
	2602	+
	2603	+ /* init buffer input */
	2604	+ c->buffer_ptr = c->buffer;
	2605	+ c->buffer_end = c->buffer + FFM_PACKET_SIZE;
	2606	+ c->stream->feed_opened = 1;
	2607	+ c->chunked_encoding = !!av_stristr(c->buffer, "Transfer-Encoding: chunked");
	2608	+ return 0;
	2609	+}
	2610	+
	2611	+static int http_receive_data(HTTPContext *c)
	2612	+{
	2613	+ HTTPContext *c1;
	2614	+ int len, loop_run = 0;
	2615	+
	2616	+ while (c->chunked_encoding && !c->chunk_size &&
	2617	+ c->buffer_end > c->buffer_ptr) {
	2618	+ /* read chunk header, if present */
	2619	+ len = recv(c->fd, c->buffer_ptr, 1, 0);
	2620	+
	2621	+ if (len < 0) {
	2622	+ if (ff_neterrno() != AVERROR(EAGAIN) &&
	2623	+ ff_neterrno() != AVERROR(EINTR))
	2624	+ /* error : close connection */
	2625	+ goto fail;
	2626	+ return 0;
	2627	+ } else if (len == 0) {
	2628	+ /* end of connection : close it */
	2629	+ goto fail;
	2630	+ } else if (c->buffer_ptr - c->buffer >= 2 &&
	2631	+ !memcmp(c->buffer_ptr - 1, "\r\n", 2)) {
	2632	+ c->chunk_size = strtol(c->buffer, 0, 16);
	2633	+ if (c->chunk_size == 0) // end of stream
	2634	+ goto fail;
	2635	+ c->buffer_ptr = c->buffer;
	2636	+ break;
	2637	+ } else if (++loop_run > 10) {
	2638	+ /* no chunk header, abort */
	2639	+ goto fail;
	2640	+ } else {
	2641	+ c->buffer_ptr++;
	2642	+ }
	2643	+ }
	2644	+
	2645	+ if (c->buffer_end > c->buffer_ptr) {
	2646	+ len = recv(c->fd, c->buffer_ptr,
	2647	+ FFMIN(c->chunk_size, c->buffer_end - c->buffer_ptr), 0);
	2648	+ if (len < 0) {
	2649	+ if (ff_neterrno() != AVERROR(EAGAIN) &&
	2650	+ ff_neterrno() != AVERROR(EINTR))
	2651	+ /* error : close connection */
	2652	+ goto fail;
	2653	+ } else if (len == 0)
	2654	+ /* end of connection : close it */
	2655	+ goto fail;
	2656	+ else {
	2657	+ c->chunk_size -= len;
	2658	+ c->buffer_ptr += len;
	2659	+ c->data_count += len;
	2660	+ update_datarate(&c->datarate, c->data_count);
	2661	+ }
	2662	+ }
	2663	+
	2664	+ if (c->buffer_ptr - c->buffer >= 2 && c->data_count > FFM_PACKET_SIZE) {
	2665	+ if (c->buffer[0] != 'f' \|\|
	2666	+ c->buffer[1] != 'm') {
	2667	+ http_log("Feed stream has become desynchronized -- disconnecting\n");
	2668	+ goto fail;
	2669	+ }
	2670	+ }
	2671	+
	2672	+ if (c->buffer_ptr >= c->buffer_end) {
	2673	+ FFStream *feed = c->stream;
	2674	+ /* a packet has been received : write it in the store, except
	2675	+ if header */
	2676	+ if (c->data_count > FFM_PACKET_SIZE) {
	2677	+
	2678	+ // printf("writing pos=0x%"PRIx64" size=0x%"PRIx64"\n", feed->feed_write_index, feed->feed_size);
	2679	+ /* XXX: use llseek or url_seek */
	2680	+ lseek(c->feed_fd, feed->feed_write_index, SEEK_SET);
	2681	+ if (write(c->feed_fd, c->buffer, FFM_PACKET_SIZE) < 0) {
	2682	+ http_log("Error writing to feed file: %s\n", strerror(errno));
	2683	+ goto fail;
	2684	+ }
	2685	+
	2686	+ feed->feed_write_index += FFM_PACKET_SIZE;
	2687	+ /* update file size */
	2688	+ if (feed->feed_write_index > c->stream->feed_size)
	2689	+ feed->feed_size = feed->feed_write_index;
	2690	+
	2691	+ /* handle wrap around if max file size reached */
	2692	+ if (c->stream->feed_max_size && feed->feed_write_index >= c->stream->feed_max_size)
	2693	+ feed->feed_write_index = FFM_PACKET_SIZE;
	2694	+
	2695	+ /* write index */
	2696	+ if (ffm_write_write_index(c->feed_fd, feed->feed_write_index) < 0) {
	2697	+ http_log("Error writing index to feed file: %s\n", strerror(errno));
	2698	+ goto fail;
	2699	+ }
	2700	+
	2701	+ /* wake up any waiting connections */
	2702	+ for(c1 = first_http_ctx; c1 != NULL; c1 = c1->next) {
	2703	+ if (c1->state == HTTPSTATE_WAIT_FEED &&
	2704	+ c1->stream->feed == c->stream->feed)
	2705	+ c1->state = HTTPSTATE_SEND_DATA;
	2706	+ }
	2707	+ } else {
	2708	+ /* We have a header in our hands that contains useful data */
	2709	+ AVFormatContext *s = avformat_alloc_context();
	2710	+ AVIOContext *pb;
	2711	+ AVInputFormat *fmt_in;
	2712	+ int i;
	2713	+
	2714	+ if (!s)
	2715	+ goto fail;
	2716	+
	2717	+ /* use feed output format name to find corresponding input format */
	2718	+ fmt_in = av_find_input_format(feed->fmt->name);
	2719	+ if (!fmt_in)
	2720	+ goto fail;
	2721	+
	2722	+ pb = avio_alloc_context(c->buffer, c->buffer_end - c->buffer,
	2723	+ 0, NULL, NULL, NULL, NULL);
	2724	+ pb->seekable = 0;
	2725	+
	2726	+ s->pb = pb;
	2727	+ if (avformat_open_input(&s, c->stream->feed_filename, fmt_in, NULL) < 0) {
	2728	+ av_free(pb);
	2729	+ goto fail;
	2730	+ }
	2731	+
	2732	+ /* Now we have the actual streams */
	2733	+ if (s->nb_streams != feed->nb_streams) {
	2734	+ av_close_input_stream(s);
	2735	+ av_free(pb);
	2736	+ http_log("Feed '%s' stream number does not match registered feed\n",
	2737	+ c->stream->feed_filename);
	2738	+ goto fail;
	2739	+ }
	2740	+
	2741	+ for (i = 0; i < s->nb_streams; i++) {
	2742	+ AVStream *fst = feed->streams[i];
	2743	+ AVStream *st = s->streams[i];
	2744	+ avcodec_copy_context(fst->codec, st->codec);
	2745	+ }
	2746	+
	2747	+ av_close_input_stream(s);
	2748	+ av_free(pb);
	2749	+ }
	2750	+ c->buffer_ptr = c->buffer;
	2751	+ }
	2752	+
	2753	+ return 0;
	2754	+ fail:
	2755	+ c->stream->feed_opened = 0;
	2756	+ close(c->feed_fd);
	2757	+ /* wake up any waiting connections to stop waiting for feed */
	2758	+ for(c1 = first_http_ctx; c1 != NULL; c1 = c1->next) {
	2759	+ if (c1->state == HTTPSTATE_WAIT_FEED &&
	2760	+ c1->stream->feed == c->stream->feed)
	2761	+ c1->state = HTTPSTATE_SEND_DATA_TRAILER;
	2762	+ }
	2763	+ return -1;
	2764	+}
	2765	+
	2766	+/********************************************************************/
	2767	+/* RTSP handling */
	2768	+
	2769	+static void rtsp_reply_header(HTTPContext *c, enum RTSPStatusCode error_number)
	2770	+{
	2771	+ const char *str;
	2772	+ time_t ti;
	2773	+ struct tm *tm;
	2774	+ char buf2[32];
	2775	+
	2776	+ switch(error_number) {
	2777	+ case RTSP_STATUS_OK:
	2778	+ str = "OK";
	2779	+ break;
	2780	+ case RTSP_STATUS_METHOD:
	2781	+ str = "Method Not Allowed";
	2782	+ break;
	2783	+ case RTSP_STATUS_BANDWIDTH:
	2784	+ str = "Not Enough Bandwidth";
	2785	+ break;
	2786	+ case RTSP_STATUS_SESSION:
	2787	+ str = "Session Not Found";
	2788	+ break;
	2789	+ case RTSP_STATUS_STATE:
	2790	+ str = "Method Not Valid in This State";
	2791	+ break;
	2792	+ case RTSP_STATUS_AGGREGATE:
	2793	+ str = "Aggregate operation not allowed";
	2794	+ break;
	2795	+ case RTSP_STATUS_ONLY_AGGREGATE:
	2796	+ str = "Only aggregate operation allowed";
	2797	+ break;
	2798	+ case RTSP_STATUS_TRANSPORT:
	2799	+ str = "Unsupported transport";
	2800	+ break;
	2801	+ case RTSP_STATUS_INTERNAL:
	2802	+ str = "Internal Server Error";
	2803	+ break;
	2804	+ case RTSP_STATUS_SERVICE:
	2805	+ str = "Service Unavailable";
	2806	+ break;
	2807	+ case RTSP_STATUS_VERSION:
	2808	+ str = "RTSP Version not supported";
	2809	+ break;
	2810	+ default:
	2811	+ str = "Unknown Error";
	2812	+ break;
	2813	+ }
	2814	+
	2815	+ avio_printf(c->pb, "RTSP/1.0 %d %s\r\n", error_number, str);
	2816	+ avio_printf(c->pb, "CSeq: %d\r\n", c->seq);
	2817	+
	2818	+ /* output GMT time */
	2819	+ ti = time(NULL);
	2820	+ tm = gmtime(&ti);
	2821	+ strftime(buf2, sizeof(buf2), "%a, %d %b %Y %H:%M:%S", tm);
	2822	+ avio_printf(c->pb, "Date: %s GMT\r\n", buf2);
	2823	+}
	2824	+
	2825	+static void rtsp_reply_error(HTTPContext *c, enum RTSPStatusCode error_number)
	2826	+{
	2827	+ rtsp_reply_header(c, error_number);
	2828	+ avio_printf(c->pb, "\r\n");
	2829	+}
	2830	+
	2831	+static int rtsp_parse_request(HTTPContext *c)
	2832	+{
	2833	+ const char p, p1, *p2;
	2834	+ char cmd[32];
	2835	+ char url[1024];
	2836	+ char protocol[32];
	2837	+ char line[1024];
	2838	+ int len;
	2839	+ RTSPMessageHeader header1, *header = &header1;
	2840	+
	2841	+ c->buffer_ptr[0] = '\0';
	2842	+ p = c->buffer;
	2843	+
	2844	+ get_word(cmd, sizeof(cmd), &p);
	2845	+ get_word(url, sizeof(url), &p);
	2846	+ get_word(protocol, sizeof(protocol), &p);
	2847	+
	2848	+ av_strlcpy(c->method, cmd, sizeof(c->method));
	2849	+ av_strlcpy(c->url, url, sizeof(c->url));
	2850	+ av_strlcpy(c->protocol, protocol, sizeof(c->protocol));
	2851	+
	2852	+ if (avio_open_dyn_buf(&c->pb) < 0) {
	2853	+ /* XXX: cannot do more */
	2854	+ c->pb = NULL; /* safety */
	2855	+ return -1;
	2856	+ }
	2857	+
	2858	+ /* check version name */
	2859	+ if (strcmp(protocol, "RTSP/1.0") != 0) {
	2860	+ rtsp_reply_error(c, RTSP_STATUS_VERSION);
	2861	+ goto the_end;
	2862	+ }
	2863	+
	2864	+ /* parse each header line */
	2865	+ memset(header, 0, sizeof(*header));
	2866	+ /* skip to next line */
	2867	+ while (p != '\n' && p != '\0')
	2868	+ p++;
	2869	+ if (*p == '\n')
	2870	+ p++;
	2871	+ while (*p != '\0') {
	2872	+ p1 = memchr(p, '\n', (char *)c->buffer_ptr - p);
	2873	+ if (!p1)
	2874	+ break;
	2875	+ p2 = p1;
	2876	+ if (p2 > p && p2[-1] == '\r')
	2877	+ p2--;
	2878	+ /* skip empty line */
	2879	+ if (p2 == p)
	2880	+ break;
	2881	+ len = p2 - p;
	2882	+ if (len > sizeof(line) - 1)
	2883	+ len = sizeof(line) - 1;
	2884	+ memcpy(line, p, len);
	2885	+ line[len] = '\0';
	2886	+ ff_rtsp_parse_line(header, line, NULL, NULL);
	2887	+ p = p1 + 1;
	2888	+ }
	2889	+
	2890	+ /* handle sequence number */
	2891	+ c->seq = header->seq;
	2892	+
	2893	+ if (!strcmp(cmd, "DESCRIBE"))
	2894	+ rtsp_cmd_describe(c, url);
	2895	+ else if (!strcmp(cmd, "OPTIONS"))
	2896	+ rtsp_cmd_options(c, url);
	2897	+ else if (!strcmp(cmd, "SETUP"))
	2898	+ rtsp_cmd_setup(c, url, header);
	2899	+ else if (!strcmp(cmd, "PLAY"))
	2900	+ rtsp_cmd_play(c, url, header);
	2901	+ else if (!strcmp(cmd, "PAUSE"))
	2902	+ rtsp_cmd_pause(c, url, header);
	2903	+ else if (!strcmp(cmd, "TEARDOWN"))
	2904	+ rtsp_cmd_teardown(c, url, header);
	2905	+ else
	2906	+ rtsp_reply_error(c, RTSP_STATUS_METHOD);
	2907	+
	2908	+ the_end:
	2909	+ len = avio_close_dyn_buf(c->pb, &c->pb_buffer);
	2910	+ c->pb = NULL; /* safety */
	2911	+ if (len < 0) {
	2912	+ /* XXX: cannot do more */
	2913	+ return -1;
	2914	+ }
	2915	+ c->buffer_ptr = c->pb_buffer;
	2916	+ c->buffer_end = c->pb_buffer + len;
	2917	+ c->state = RTSPSTATE_SEND_REPLY;
	2918	+ return 0;
	2919	+}
	2920	+
	2921	+static int prepare_sdp_description(FFStream stream, uint8_t *pbuffer,
	2922	+ struct in_addr my_ip)
	2923	+{
	2924	+ AVFormatContext *avc;
	2925	+ AVStream *avs = NULL;
	2926	+ int i;
	2927	+
	2928	+ avc = avformat_alloc_context();
	2929	+ if (avc == NULL) {
	2930	+ return -1;
	2931	+ }
	2932	+ av_dict_set(&avc->metadata, "title",
	2933	+ stream->title[0] ? stream->title : "No Title", 0);
	2934	+ avc->nb_streams = stream->nb_streams;
	2935	+ if (stream->is_multicast) {
	2936	+ snprintf(avc->filename, 1024, "rtp://%s:%d?multicast=1?ttl=%d",
	2937	+ inet_ntoa(stream->multicast_ip),
	2938	+ stream->multicast_port, stream->multicast_ttl);
	2939	+ } else {
	2940	+ snprintf(avc->filename, 1024, "rtp://0.0.0.0");
	2941	+ }
	2942	+
	2943	+ if (avc->nb_streams >= INT_MAX/sizeof(*avc->streams) \|\|
	2944	+ !(avc->streams = av_malloc(avc->nb_streams * sizeof(*avc->streams))))
	2945	+ goto sdp_done;
	2946	+ if (avc->nb_streams >= INT_MAX/sizeof(*avs) \|\|
	2947	+ !(avs = av_malloc(avc->nb_streams * sizeof(*avs))))
	2948	+ goto sdp_done;
	2949	+
	2950	+ for(i = 0; i < stream->nb_streams; i++) {
	2951	+ avc->streams[i] = &avs[i];
	2952	+ avc->streams[i]->codec = stream->streams[i]->codec;
	2953	+ }
	2954	+ *pbuffer = av_mallocz(2048);
	2955	+ av_sdp_create(&avc, 1, *pbuffer, 2048);
	2956	+
	2957	+ sdp_done:
	2958	+ av_free(avc->streams);
	2959	+ av_dict_free(&avc->metadata);
	2960	+ av_free(avc);
	2961	+ av_free(avs);
	2962	+
	2963	+ return strlen(*pbuffer);
	2964	+}
	2965	+
	2966	+static void rtsp_cmd_options(HTTPContext c, const char url)
	2967	+{
	2968	+// rtsp_reply_header(c, RTSP_STATUS_OK);
	2969	+ avio_printf(c->pb, "RTSP/1.0 %d %s\r\n", RTSP_STATUS_OK, "OK");
	2970	+ avio_printf(c->pb, "CSeq: %d\r\n", c->seq);
	2971	+ avio_printf(c->pb, "Public: %s\r\n", "OPTIONS, DESCRIBE, SETUP, TEARDOWN, PLAY, PAUSE");
	2972	+ avio_printf(c->pb, "\r\n");
	2973	+}
	2974	+
	2975	+static void rtsp_cmd_describe(HTTPContext c, const char url)
	2976	+{
	2977	+ FFStream *stream;
	2978	+ char path1[1024];
	2979	+ const char *path;
	2980	+ uint8_t *content;
	2981	+ int content_length, len;
	2982	+ struct sockaddr_in my_addr;
	2983	+
	2984	+ /* find which url is asked */
	2985	+ av_url_split(NULL, 0, NULL, 0, NULL, 0, NULL, path1, sizeof(path1), url);
	2986	+ path = path1;
	2987	+ if (*path == '/')
	2988	+ path++;
	2989	+
	2990	+ for(stream = first_stream; stream != NULL; stream = stream->next) {
	2991	+ if (!stream->is_feed &&
	2992	+ stream->fmt && !strcmp(stream->fmt->name, "rtp") &&
	2993	+ !strcmp(path, stream->filename)) {
	2994	+ goto found;
	2995	+ }
	2996	+ }
	2997	+ /* no stream found */
	2998	+ rtsp_reply_error(c, RTSP_STATUS_SERVICE); /* XXX: right error ? */
	2999	+ return;
	3000	+
	3001	+ found:
	3002	+ /* prepare the media description in sdp format */
	3003	+
	3004	+ /* get the host IP */
	3005	+ len = sizeof(my_addr);
	3006	+ getsockname(c->fd, (struct sockaddr *)&my_addr, &len);
	3007	+ content_length = prepare_sdp_description(stream, &content, my_addr.sin_addr);
	3008	+ if (content_length < 0) {
	3009	+ rtsp_reply_error(c, RTSP_STATUS_INTERNAL);
	3010	+ return;
	3011	+ }
	3012	+ rtsp_reply_header(c, RTSP_STATUS_OK);
	3013	+ avio_printf(c->pb, "Content-Base: %s/\r\n", url);
	3014	+ avio_printf(c->pb, "Content-Type: application/sdp\r\n");
	3015	+ avio_printf(c->pb, "Content-Length: %d\r\n", content_length);
	3016	+ avio_printf(c->pb, "\r\n");
	3017	+ avio_write(c->pb, content, content_length);
	3018	+ av_free(content);
	3019	+}
	3020	+
	3021	+static HTTPContext find_rtp_session(const char session_id)
	3022	+{
	3023	+ HTTPContext *c;
	3024	+
	3025	+ if (session_id[0] == '\0')
	3026	+ return NULL;
	3027	+
	3028	+ for(c = first_http_ctx; c != NULL; c = c->next) {
	3029	+ if (!strcmp(c->session_id, session_id))
	3030	+ return c;
	3031	+ }
	3032	+ return NULL;
	3033	+}
	3034	+
	3035	+static RTSPTransportField find_transport(RTSPMessageHeader h, enum RTSPLowerTransport lower_transport)
	3036	+{
	3037	+ RTSPTransportField *th;
	3038	+ int i;
	3039	+
	3040	+ for(i=0;i<h->nb_transports;i++) {
	3041	+ th = &h->transports[i];
	3042	+ if (th->lower_transport == lower_transport)
	3043	+ return th;
	3044	+ }
	3045	+ return NULL;
	3046	+}
	3047	+
	3048	+static void rtsp_cmd_setup(HTTPContext c, const char url,
	3049	+ RTSPMessageHeader *h)
	3050	+{
	3051	+ FFStream *stream;
	3052	+ int stream_index, rtp_port, rtcp_port;
	3053	+ char buf[1024];
	3054	+ char path1[1024];
	3055	+ const char *path;
	3056	+ HTTPContext *rtp_c;
	3057	+ RTSPTransportField *th;
	3058	+ struct sockaddr_in dest_addr;
	3059	+ RTSPActionServerSetup setup;
	3060	+
	3061	+ /* find which url is asked */
	3062	+ av_url_split(NULL, 0, NULL, 0, NULL, 0, NULL, path1, sizeof(path1), url);
	3063	+ path = path1;
	3064	+ if (*path == '/')
	3065	+ path++;
	3066	+
	3067	+ /* now check each stream */
	3068	+ for(stream = first_stream; stream != NULL; stream = stream->next) {
	3069	+ if (!stream->is_feed &&
	3070	+ stream->fmt && !strcmp(stream->fmt->name, "rtp")) {
	3071	+ /* accept aggregate filenames only if single stream */
	3072	+ if (!strcmp(path, stream->filename)) {
	3073	+ if (stream->nb_streams != 1) {
	3074	+ rtsp_reply_error(c, RTSP_STATUS_AGGREGATE);
	3075	+ return;
	3076	+ }
	3077	+ stream_index = 0;
	3078	+ goto found;
	3079	+ }
	3080	+
	3081	+ for(stream_index = 0; stream_index < stream->nb_streams;
	3082	+ stream_index++) {
	3083	+ snprintf(buf, sizeof(buf), "%s/streamid=%d",
	3084	+ stream->filename, stream_index);
	3085	+ if (!strcmp(path, buf))
	3086	+ goto found;
	3087	+ }
	3088	+ }
	3089	+ }
	3090	+ /* no stream found */
	3091	+ rtsp_reply_error(c, RTSP_STATUS_SERVICE); /* XXX: right error ? */
	3092	+ return;
	3093	+ found:
	3094	+
	3095	+ /* generate session id if needed */
	3096	+ if (h->session_id[0] == '\0')
	3097	+ snprintf(h->session_id, sizeof(h->session_id), "%08x%08x",
	3098	+ av_lfg_get(&random_state), av_lfg_get(&random_state));
	3099	+
	3100	+ /* find rtp session, and create it if none found */
	3101	+ rtp_c = find_rtp_session(h->session_id);
	3102	+ if (!rtp_c) {
	3103	+ /* always prefer UDP */
	3104	+ th = find_transport(h, RTSP_LOWER_TRANSPORT_UDP);
	3105	+ if (!th) {
	3106	+ th = find_transport(h, RTSP_LOWER_TRANSPORT_TCP);
	3107	+ if (!th) {
	3108	+ rtsp_reply_error(c, RTSP_STATUS_TRANSPORT);
	3109	+ return;
	3110	+ }
	3111	+ }
	3112	+
	3113	+ rtp_c = rtp_new_connection(&c->from_addr, stream, h->session_id,
	3114	+ th->lower_transport);
	3115	+ if (!rtp_c) {
	3116	+ rtsp_reply_error(c, RTSP_STATUS_BANDWIDTH);
	3117	+ return;
	3118	+ }
	3119	+
	3120	+ /* open input stream */
	3121	+ if (open_input_stream(rtp_c, "") < 0) {
	3122	+ rtsp_reply_error(c, RTSP_STATUS_INTERNAL);
	3123	+ return;
	3124	+ }
	3125	+ }
	3126	+
	3127	+ /* test if stream is OK (test needed because several SETUP needs
	3128	+ to be done for a given file) */
	3129	+ if (rtp_c->stream != stream) {
	3130	+ rtsp_reply_error(c, RTSP_STATUS_SERVICE);
	3131	+ return;
	3132	+ }
	3133	+
	3134	+ /* test if stream is already set up */
	3135	+ if (rtp_c->rtp_ctx[stream_index]) {
	3136	+ rtsp_reply_error(c, RTSP_STATUS_STATE);
	3137	+ return;
	3138	+ }
	3139	+
	3140	+ /* check transport */
	3141	+ th = find_transport(h, rtp_c->rtp_protocol);
	3142	+ if (!th \|\| (th->lower_transport == RTSP_LOWER_TRANSPORT_UDP &&
	3143	+ th->client_port_min <= 0)) {
	3144	+ rtsp_reply_error(c, RTSP_STATUS_TRANSPORT);
	3145	+ return;
	3146	+ }
	3147	+
	3148	+ /* setup default options */
	3149	+ setup.transport_option[0] = '\0';
	3150	+ dest_addr = rtp_c->from_addr;
	3151	+ dest_addr.sin_port = htons(th->client_port_min);
	3152	+
	3153	+ /* setup stream */
	3154	+ if (rtp_new_av_stream(rtp_c, stream_index, &dest_addr, c) < 0) {
	3155	+ rtsp_reply_error(c, RTSP_STATUS_TRANSPORT);
	3156	+ return;
	3157	+ }
	3158	+
	3159	+ /* now everything is OK, so we can send the connection parameters */
	3160	+ rtsp_reply_header(c, RTSP_STATUS_OK);
	3161	+ /* session ID */
	3162	+ avio_printf(c->pb, "Session: %s\r\n", rtp_c->session_id);
	3163	+
	3164	+ switch(rtp_c->rtp_protocol) {
	3165	+ case RTSP_LOWER_TRANSPORT_UDP:
	3166	+ rtp_port = rtp_get_local_rtp_port(rtp_c->rtp_handles[stream_index]);
	3167	+ rtcp_port = rtp_get_local_rtcp_port(rtp_c->rtp_handles[stream_index]);
	3168	+ avio_printf(c->pb, "Transport: RTP/AVP/UDP;unicast;"
	3169	+ "client_port=%d-%d;server_port=%d-%d",
	3170	+ th->client_port_min, th->client_port_max,
	3171	+ rtp_port, rtcp_port);
	3172	+ break;
	3173	+ case RTSP_LOWER_TRANSPORT_TCP:
	3174	+ avio_printf(c->pb, "Transport: RTP/AVP/TCP;interleaved=%d-%d",
	3175	+ stream_index * 2, stream_index * 2 + 1);
	3176	+ break;
	3177	+ default:
	3178	+ break;
	3179	+ }
	3180	+ if (setup.transport_option[0] != '\0')
	3181	+ avio_printf(c->pb, ";%s", setup.transport_option);
	3182	+ avio_printf(c->pb, "\r\n");
	3183	+
	3184	+
	3185	+ avio_printf(c->pb, "\r\n");
	3186	+}
	3187	+
	3188	+
	3189	+/* find an rtp connection by using the session ID. Check consistency
	3190	+ with filename */
	3191	+static HTTPContext find_rtp_session_with_url(const char url,
	3192	+ const char *session_id)
	3193	+{
	3194	+ HTTPContext *rtp_c;
	3195	+ char path1[1024];
	3196	+ const char *path;
	3197	+ char buf[1024];
	3198	+ int s, len;
	3199	+
	3200	+ rtp_c = find_rtp_session(session_id);
	3201	+ if (!rtp_c)
	3202	+ return NULL;
	3203	+
	3204	+ /* find which url is asked */
	3205	+ av_url_split(NULL, 0, NULL, 0, NULL, 0, NULL, path1, sizeof(path1), url);
	3206	+ path = path1;
	3207	+ if (*path == '/')
	3208	+ path++;
	3209	+ if(!strcmp(path, rtp_c->stream->filename)) return rtp_c;
	3210	+ for(s=0; s<rtp_c->stream->nb_streams; ++s) {
	3211	+ snprintf(buf, sizeof(buf), "%s/streamid=%d",
	3212	+ rtp_c->stream->filename, s);
	3213	+ if(!strncmp(path, buf, sizeof(buf))) {
	3214	+ // XXX: Should we reply with RTSP_STATUS_ONLY_AGGREGATE if nb_streams>1?
	3215	+ return rtp_c;
	3216	+ }
	3217	+ }
	3218	+ len = strlen(path);
	3219	+ if (len > 0 && path[len - 1] == '/' &&
	3220	+ !strncmp(path, rtp_c->stream->filename, len - 1))
	3221	+ return rtp_c;
	3222	+ return NULL;
	3223	+}
	3224	+
	3225	+static void rtsp_cmd_play(HTTPContext c, const char url, RTSPMessageHeader *h)
	3226	+{
	3227	+ HTTPContext *rtp_c;
	3228	+
	3229	+ rtp_c = find_rtp_session_with_url(url, h->session_id);
	3230	+ if (!rtp_c) {
	3231	+ rtsp_reply_error(c, RTSP_STATUS_SESSION);
	3232	+ return;
	3233	+ }
	3234	+
	3235	+ if (rtp_c->state != HTTPSTATE_SEND_DATA &&
	3236	+ rtp_c->state != HTTPSTATE_WAIT_FEED &&
	3237	+ rtp_c->state != HTTPSTATE_READY) {
	3238	+ rtsp_reply_error(c, RTSP_STATUS_STATE);
	3239	+ return;
	3240	+ }
	3241	+
	3242	+ rtp_c->state = HTTPSTATE_SEND_DATA;
	3243	+
	3244	+ /* now everything is OK, so we can send the connection parameters */
	3245	+ rtsp_reply_header(c, RTSP_STATUS_OK);
	3246	+ /* session ID */
	3247	+ avio_printf(c->pb, "Session: %s\r\n", rtp_c->session_id);
	3248	+ avio_printf(c->pb, "\r\n");
	3249	+}
	3250	+
	3251	+static void rtsp_cmd_pause(HTTPContext c, const char url, RTSPMessageHeader *h)
	3252	+{
	3253	+ HTTPContext *rtp_c;
	3254	+
	3255	+ rtp_c = find_rtp_session_with_url(url, h->session_id);
	3256	+ if (!rtp_c) {
	3257	+ rtsp_reply_error(c, RTSP_STATUS_SESSION);
	3258	+ return;
	3259	+ }
	3260	+
	3261	+ if (rtp_c->state != HTTPSTATE_SEND_DATA &&
	3262	+ rtp_c->state != HTTPSTATE_WAIT_FEED) {
	3263	+ rtsp_reply_error(c, RTSP_STATUS_STATE);
	3264	+ return;
	3265	+ }
	3266	+
	3267	+ rtp_c->state = HTTPSTATE_READY;
	3268	+ rtp_c->first_pts = AV_NOPTS_VALUE;
	3269	+ /* now everything is OK, so we can send the connection parameters */
	3270	+ rtsp_reply_header(c, RTSP_STATUS_OK);
	3271	+ /* session ID */
	3272	+ avio_printf(c->pb, "Session: %s\r\n", rtp_c->session_id);
	3273	+ avio_printf(c->pb, "\r\n");
	3274	+}
	3275	+
	3276	+static void rtsp_cmd_teardown(HTTPContext c, const char url, RTSPMessageHeader *h)
	3277	+{
	3278	+ HTTPContext *rtp_c;
	3279	+
	3280	+ rtp_c = find_rtp_session_with_url(url, h->session_id);
	3281	+ if (!rtp_c) {
	3282	+ rtsp_reply_error(c, RTSP_STATUS_SESSION);
	3283	+ return;
	3284	+ }
	3285	+
	3286	+ /* now everything is OK, so we can send the connection parameters */
	3287	+ rtsp_reply_header(c, RTSP_STATUS_OK);
	3288	+ /* session ID */
	3289	+ avio_printf(c->pb, "Session: %s\r\n", rtp_c->session_id);
	3290	+ avio_printf(c->pb, "\r\n");
	3291	+
	3292	+ /* abort the session */
	3293	+ close_connection(rtp_c);
	3294	+}
	3295	+
	3296	+
	3297	+/********************************************************************/
	3298	+/* RTP handling */
	3299	+
	3300	+static HTTPContext rtp_new_connection(struct sockaddr_in from_addr,
	3301	+ FFStream stream, const char session_id,
	3302	+ enum RTSPLowerTransport rtp_protocol)
	3303	+{
	3304	+ HTTPContext *c = NULL;
	3305	+ const char *proto_str;
	3306	+
	3307	+ /* XXX: should output a warning page when coming
	3308	+ close to the connection limit */
	3309	+ if (nb_connections >= nb_max_connections)
	3310	+ goto fail;
	3311	+
	3312	+ /* add a new connection */
	3313	+ c = av_mallocz(sizeof(HTTPContext));
	3314	+ if (!c)
	3315	+ goto fail;
	3316	+
	3317	+ c->fd = -1;
	3318	+ c->poll_entry = NULL;
	3319	+ c->from_addr = *from_addr;
	3320	+ c->buffer_size = IOBUFFER_INIT_SIZE;
	3321	+ c->buffer = av_malloc(c->buffer_size);
	3322	+ if (!c->buffer)
	3323	+ goto fail;
	3324	+ nb_connections++;
	3325	+ c->stream = stream;
	3326	+ av_strlcpy(c->session_id, session_id, sizeof(c->session_id));
	3327	+ c->state = HTTPSTATE_READY;
	3328	+ c->is_packetized = 1;
	3329	+ c->rtp_protocol = rtp_protocol;
	3330	+
	3331	+ /* protocol is shown in statistics */
	3332	+ switch(c->rtp_protocol) {
	3333	+ case RTSP_LOWER_TRANSPORT_UDP_MULTICAST:
	3334	+ proto_str = "MCAST";
	3335	+ break;
	3336	+ case RTSP_LOWER_TRANSPORT_UDP:
	3337	+ proto_str = "UDP";
	3338	+ break;
	3339	+ case RTSP_LOWER_TRANSPORT_TCP:
	3340	+ proto_str = "TCP";
	3341	+ break;
	3342	+ default:
	3343	+ proto_str = "???";
	3344	+ break;
	3345	+ }
	3346	+ av_strlcpy(c->protocol, "RTP/", sizeof(c->protocol));
	3347	+ av_strlcat(c->protocol, proto_str, sizeof(c->protocol));
	3348	+
	3349	+ current_bandwidth += stream->bandwidth;
	3350	+
	3351	+ c->next = first_http_ctx;
	3352	+ first_http_ctx = c;
	3353	+ return c;
	3354	+
	3355	+ fail:
	3356	+ if (c) {
	3357	+ av_free(c->buffer);
	3358	+ av_free(c);
	3359	+ }
	3360	+ return NULL;
	3361	+}
	3362	+
	3363	+/* add a new RTP stream in an RTP connection (used in RTSP SETUP
	3364	+ command). If RTP/TCP protocol is used, TCP connection 'rtsp_c' is
	3365	+ used. */
	3366	+static int rtp_new_av_stream(HTTPContext *c,
	3367	+ int stream_index, struct sockaddr_in *dest_addr,
	3368	+ HTTPContext *rtsp_c)
	3369	+{
	3370	+ AVFormatContext *ctx;
	3371	+ AVStream *st;
	3372	+ char *ipaddr;
	3373	+ URLContext *h = NULL;
	3374	+ uint8_t *dummy_buf;
	3375	+ int max_packet_size;
	3376	+
	3377	+ /* now we can open the relevant output stream */
	3378	+ ctx = avformat_alloc_context();
	3379	+ if (!ctx)
	3380	+ return -1;
	3381	+ ctx->oformat = av_guess_format("rtp", NULL, NULL);
	3382	+
	3383	+ st = av_mallocz(sizeof(AVStream));
	3384	+ if (!st)
	3385	+ goto fail;
	3386	+ ctx->nb_streams = 1;
	3387	+ ctx->streams = av_mallocz(sizeof(AVStream ) ctx->nb_streams);
	3388	+ if (!ctx->streams)
	3389	+ goto fail;
	3390	+ ctx->streams[0] = st;
	3391	+
	3392	+ if (!c->stream->feed \|\|
	3393	+ c->stream->feed == c->stream)
	3394	+ memcpy(st, c->stream->streams[stream_index], sizeof(AVStream));
	3395	+ else
	3396	+ memcpy(st,
	3397	+ c->stream->feed->streams[c->stream->feed_streams[stream_index]],
	3398	+ sizeof(AVStream));
	3399	+ st->priv_data = NULL;
	3400	+
	3401	+ /* build destination RTP address */
	3402	+ ipaddr = inet_ntoa(dest_addr->sin_addr);
	3403	+
	3404	+ switch(c->rtp_protocol) {
	3405	+ case RTSP_LOWER_TRANSPORT_UDP:
	3406	+ case RTSP_LOWER_TRANSPORT_UDP_MULTICAST:
	3407	+ /* RTP/UDP case */
	3408	+
	3409	+ /* XXX: also pass as parameter to function ? */
	3410	+ if (c->stream->is_multicast) {
	3411	+ int ttl;
	3412	+ ttl = c->stream->multicast_ttl;
	3413	+ if (!ttl)
	3414	+ ttl = 16;
	3415	+ snprintf(ctx->filename, sizeof(ctx->filename),
	3416	+ "rtp://%s:%d?multicast=1&ttl=%d",
	3417	+ ipaddr, ntohs(dest_addr->sin_port), ttl);
	3418	+ } else {
	3419	+ snprintf(ctx->filename, sizeof(ctx->filename),
	3420	+ "rtp://%s:%d", ipaddr, ntohs(dest_addr->sin_port));
	3421	+ }
	3422	+
	3423	+ if (url_open(&h, ctx->filename, AVIO_FLAG_WRITE) < 0)
	3424	+ goto fail;
	3425	+ c->rtp_handles[stream_index] = h;
	3426	+ max_packet_size = url_get_max_packet_size(h);
	3427	+ break;
	3428	+ case RTSP_LOWER_TRANSPORT_TCP:
	3429	+ /* RTP/TCP case */
	3430	+ c->rtsp_c = rtsp_c;
	3431	+ max_packet_size = RTSP_TCP_MAX_PACKET_SIZE;
	3432	+ break;
	3433	+ default:
	3434	+ goto fail;
	3435	+ }
	3436	+
	3437	+ http_log("%s:%d - - \"PLAY %s/streamid=%d %s\"\n",
	3438	+ ipaddr, ntohs(dest_addr->sin_port),
	3439	+ c->stream->filename, stream_index, c->protocol);
	3440	+
	3441	+ /* normally, no packets should be output here, but the packet size may be checked */
	3442	+ if (ffio_open_dyn_packet_buf(&ctx->pb, max_packet_size) < 0) {
	3443	+ /* XXX: close stream */
	3444	+ goto fail;
	3445	+ }
	3446	+ if (avformat_write_header(ctx, NULL) < 0) {
	3447	+ fail:
	3448	+ if (h)
	3449	+ url_close(h);
	3450	+ av_free(ctx);
	3451	+ return -1;
	3452	+ }
	3453	+ avio_close_dyn_buf(ctx->pb, &dummy_buf);
	3454	+ av_free(dummy_buf);
	3455	+
	3456	+ c->rtp_ctx[stream_index] = ctx;
	3457	+ return 0;
	3458	+}
	3459	+
	3460	+/********************************************************************/
	3461	+/* avserver initialization */
	3462	+
	3463	+static AVStream add_av_stream1(FFStream stream, AVCodecContext *codec, int copy)
	3464	+{
	3465	+ AVStream *fst;
	3466	+
	3467	+ fst = av_mallocz(sizeof(AVStream));
	3468	+ if (!fst)
	3469	+ return NULL;
	3470	+ if (copy) {
	3471	+ fst->codec = avcodec_alloc_context3(NULL);
	3472	+ memcpy(fst->codec, codec, sizeof(AVCodecContext));
	3473	+ if (codec->extradata_size) {
	3474	+ fst->codec->extradata = av_malloc(codec->extradata_size);
	3475	+ memcpy(fst->codec->extradata, codec->extradata,
	3476	+ codec->extradata_size);
	3477	+ }
	3478	+ } else {
	3479	+ /* live streams must use the actual feed's codec since it may be
	3480	+ * updated later to carry extradata needed by the streams.
	3481	+ */
	3482	+ fst->codec = codec;
	3483	+ }
	3484	+ fst->priv_data = av_mallocz(sizeof(FeedData));
	3485	+ fst->index = stream->nb_streams;
	3486	+ av_set_pts_info(fst, 33, 1, 90000);
	3487	+ fst->sample_aspect_ratio = codec->sample_aspect_ratio;
	3488	+ stream->streams[stream->nb_streams++] = fst;
	3489	+ return fst;
	3490	+}
	3491	+
	3492	+/* return the stream number in the feed */
	3493	+static int add_av_stream(FFStream feed, AVStream st)
	3494	+{
	3495	+ AVStream *fst;
	3496	+ AVCodecContext av, av1;
	3497	+ int i;
	3498	+
	3499	+ av = st->codec;
	3500	+ for(i=0;i<feed->nb_streams;i++) {
	3501	+ st = feed->streams[i];
	3502	+ av1 = st->codec;
	3503	+ if (av1->codec_id == av->codec_id &&
	3504	+ av1->codec_type == av->codec_type &&
	3505	+ av1->bit_rate == av->bit_rate) {
	3506	+
	3507	+ switch(av->codec_type) {
	3508	+ case AVMEDIA_TYPE_AUDIO:
	3509	+ if (av1->channels == av->channels &&
	3510	+ av1->sample_rate == av->sample_rate)
	3511	+ return i;
	3512	+ break;
	3513	+ case AVMEDIA_TYPE_VIDEO:
	3514	+ if (av1->width == av->width &&
	3515	+ av1->height == av->height &&
	3516	+ av1->time_base.den == av->time_base.den &&
	3517	+ av1->time_base.num == av->time_base.num &&
	3518	+ av1->gop_size == av->gop_size)
	3519	+ return i;
	3520	+ break;
	3521	+ default:
	3522	+ abort();
	3523	+ }
	3524	+ }
	3525	+ }
	3526	+
	3527	+ fst = add_av_stream1(feed, av, 0);
	3528	+ if (!fst)
	3529	+ return -1;
	3530	+ return feed->nb_streams - 1;
	3531	+}
	3532	+
	3533	+static void remove_stream(FFStream *stream)
	3534	+{
	3535	+ FFStream **ps;
	3536	+ ps = &first_stream;
	3537	+ while (*ps != NULL) {
	3538	+ if (*ps == stream)
	3539	+ ps = (ps)->next;
	3540	+ else
	3541	+ ps = &(*ps)->next;
	3542	+ }
	3543	+}
	3544	+
	3545	+/* specific mpeg4 handling : we extract the raw parameters */
	3546	+static void extract_mpeg4_header(AVFormatContext *infile)
	3547	+{
	3548	+ int mpeg4_count, i, size;
	3549	+ AVPacket pkt;
	3550	+ AVStream *st;
	3551	+ const uint8_t *p;
	3552	+
	3553	+ mpeg4_count = 0;
	3554	+ for(i=0;i<infile->nb_streams;i++) {
	3555	+ st = infile->streams[i];
	3556	+ if (st->codec->codec_id == CODEC_ID_MPEG4 &&
	3557	+ st->codec->extradata_size == 0) {
	3558	+ mpeg4_count++;
	3559	+ }
	3560	+ }
	3561	+ if (!mpeg4_count)
	3562	+ return;
	3563	+
	3564	+ printf("MPEG4 without extra data: trying to find header in %s\n", infile->filename);
	3565	+ while (mpeg4_count > 0) {
	3566	+ if (av_read_packet(infile, &pkt) < 0)
	3567	+ break;
	3568	+ st = infile->streams[pkt.stream_index];
	3569	+ if (st->codec->codec_id == CODEC_ID_MPEG4 &&
	3570	+ st->codec->extradata_size == 0) {
	3571	+ av_freep(&st->codec->extradata);
	3572	+ /* fill extradata with the header */
	3573	+ /* XXX: we make hard suppositions here ! */
	3574	+ p = pkt.data;
	3575	+ while (p < pkt.data + pkt.size - 4) {
	3576	+ /* stop when vop header is found */
	3577	+ if (p[0] == 0x00 && p[1] == 0x00 &&
	3578	+ p[2] == 0x01 && p[3] == 0xb6) {
	3579	+ size = p - pkt.data;
	3580	+ // av_hex_dump_log(infile, AV_LOG_DEBUG, pkt.data, size);
	3581	+ st->codec->extradata = av_malloc(size);
	3582	+ st->codec->extradata_size = size;
	3583	+ memcpy(st->codec->extradata, pkt.data, size);
	3584	+ break;
	3585	+ }
	3586	+ p++;
	3587	+ }
	3588	+ mpeg4_count--;
	3589	+ }
	3590	+ av_free_packet(&pkt);
	3591	+ }
	3592	+}
	3593	+
	3594	+/* compute the needed AVStream for each file */
	3595	+static void build_file_streams(void)
	3596	+{
	3597	+ FFStream stream, stream_next;
	3598	+ int i, ret;
	3599	+
	3600	+ /* gather all streams */
	3601	+ for(stream = first_stream; stream != NULL; stream = stream_next) {
	3602	+ AVFormatContext *infile = NULL;
	3603	+ stream_next = stream->next;
	3604	+ if (stream->stream_type == STREAM_TYPE_LIVE &&
	3605	+ !stream->feed) {
	3606	+ /* the stream comes from a file */
	3607	+ /* try to open the file */
	3608	+ /* open stream */
	3609	+ if (stream->fmt && !strcmp(stream->fmt->name, "rtp")) {
	3610	+ /* specific case : if transport stream output to RTP,
	3611	+ we use a raw transport stream reader */
	3612	+ av_dict_set(&stream->in_opts, "mpeg2ts_compute_pcr", "1", 0);
	3613	+ }
	3614	+
	3615	+ http_log("Opening file '%s'\n", stream->feed_filename);
	3616	+ if ((ret = avformat_open_input(&infile, stream->feed_filename, stream->ifmt, &stream->in_opts)) < 0) {
	3617	+ http_log("Could not open '%s': %d\n", stream->feed_filename, ret);
	3618	+ /* remove stream (no need to spend more time on it) */
	3619	+ fail:
	3620	+ remove_stream(stream);
	3621	+ } else {
	3622	+ /* find all the AVStreams inside and reference them in
	3623	+ 'stream' */
	3624	+ if (av_find_stream_info(infile) < 0) {
	3625	+ http_log("Could not find codec parameters from '%s'\n",
	3626	+ stream->feed_filename);
	3627	+ av_close_input_file(infile);
	3628	+ goto fail;
	3629	+ }
	3630	+ extract_mpeg4_header(infile);
	3631	+
	3632	+ for(i=0;i<infile->nb_streams;i++)
	3633	+ add_av_stream1(stream, infile->streams[i]->codec, 1);
	3634	+
	3635	+ av_close_input_file(infile);
	3636	+ }
	3637	+ }
	3638	+ }
	3639	+}
	3640	+
	3641	+/* compute the needed AVStream for each feed */
	3642	+static void build_feed_streams(void)
	3643	+{
	3644	+ FFStream stream, feed;
	3645	+ int i;
	3646	+
	3647	+ /* gather all streams */
	3648	+ for(stream = first_stream; stream != NULL; stream = stream->next) {
	3649	+ feed = stream->feed;
	3650	+ if (feed) {
	3651	+ if (stream->is_feed) {
	3652	+ for(i=0;i<stream->nb_streams;i++)
	3653	+ stream->feed_streams[i] = i;
	3654	+ } else {
	3655	+ /* we handle a stream coming from a feed */
	3656	+ for(i=0;i<stream->nb_streams;i++)
	3657	+ stream->feed_streams[i] = add_av_stream(feed, stream->streams[i]);
	3658	+ }
	3659	+ }
	3660	+ }
	3661	+
	3662	+ /* create feed files if needed */
	3663	+ for(feed = first_feed; feed != NULL; feed = feed->next_feed) {
	3664	+ int fd;
	3665	+
	3666	+ if (avio_check(feed->feed_filename, AVIO_FLAG_READ) > 0) {
	3667	+ /* See if it matches */
	3668	+ AVFormatContext *s = NULL;
	3669	+ int matches = 0;
	3670	+
	3671	+ if (avformat_open_input(&s, feed->feed_filename, NULL, NULL) >= 0) {
	3672	+ /* Now see if it matches */
	3673	+ if (s->nb_streams == feed->nb_streams) {
	3674	+ matches = 1;
	3675	+ for(i=0;i<s->nb_streams;i++) {
	3676	+ AVStream sf, ss;
	3677	+ sf = feed->streams[i];
	3678	+ ss = s->streams[i];
	3679	+
	3680	+ if (sf->index != ss->index \|\|
	3681	+ sf->id != ss->id) {
	3682	+ http_log("Index & Id do not match for stream %d (%s)\n",
	3683	+ i, feed->feed_filename);
	3684	+ matches = 0;
	3685	+ } else {
	3686	+ AVCodecContext ccf, ccs;
	3687	+
	3688	+ ccf = sf->codec;
	3689	+ ccs = ss->codec;
	3690	+#define CHECK_CODEC(x) (ccf->x != ccs->x)
	3691	+
	3692	+ if (CHECK_CODEC(codec_id) \|\| CHECK_CODEC(codec_type)) {
	3693	+ http_log("Codecs do not match for stream %d\n", i);
	3694	+ matches = 0;
	3695	+ } else if (CHECK_CODEC(bit_rate) \|\| CHECK_CODEC(flags)) {
	3696	+ http_log("Codec bitrates do not match for stream %d\n", i);
	3697	+ matches = 0;
	3698	+ } else if (ccf->codec_type == AVMEDIA_TYPE_VIDEO) {
	3699	+ if (CHECK_CODEC(time_base.den) \|\|
	3700	+ CHECK_CODEC(time_base.num) \|\|
	3701	+ CHECK_CODEC(width) \|\|
	3702	+ CHECK_CODEC(height)) {
	3703	+ http_log("Codec width, height and framerate do not match for stream %d\n", i);
	3704	+ matches = 0;
	3705	+ }
	3706	+ } else if (ccf->codec_type == AVMEDIA_TYPE_AUDIO) {
	3707	+ if (CHECK_CODEC(sample_rate) \|\|
	3708	+ CHECK_CODEC(channels) \|\|
	3709	+ CHECK_CODEC(frame_size)) {
	3710	+ http_log("Codec sample_rate, channels, frame_size do not match for stream %d\n", i);
	3711	+ matches = 0;
	3712	+ }
	3713	+ } else {
	3714	+ http_log("Unknown codec type\n");
	3715	+ matches = 0;
	3716	+ }
	3717	+ }
	3718	+ if (!matches)
	3719	+ break;
	3720	+ }
	3721	+ } else
	3722	+ http_log("Deleting feed file '%s' as stream counts differ (%d != %d)\n",
	3723	+ feed->feed_filename, s->nb_streams, feed->nb_streams);
	3724	+
	3725	+ av_close_input_file(s);
	3726	+ } else
	3727	+ http_log("Deleting feed file '%s' as it appears to be corrupt\n",
	3728	+ feed->feed_filename);
	3729	+
	3730	+ if (!matches) {
	3731	+ if (feed->readonly) {
	3732	+ http_log("Unable to delete feed file '%s' as it is marked readonly\n",
	3733	+ feed->feed_filename);
	3734	+ exit(1);
	3735	+ }
	3736	+ unlink(feed->feed_filename);
	3737	+ }
	3738	+ }
	3739	+ if (avio_check(feed->feed_filename, AVIO_FLAG_WRITE) <= 0) {
	3740	+ AVFormatContext s1 = {0}, *s = &s1;
	3741	+
	3742	+ if (feed->readonly) {
	3743	+ http_log("Unable to create feed file '%s' as it is marked readonly\n",
	3744	+ feed->feed_filename);
	3745	+ exit(1);
	3746	+ }
	3747	+
	3748	+ /* only write the header of the ffm file */
	3749	+ if (avio_open(&s->pb, feed->feed_filename, AVIO_FLAG_WRITE) < 0) {
	3750	+ http_log("Could not open output feed file '%s'\n",
	3751	+ feed->feed_filename);
	3752	+ exit(1);
	3753	+ }
	3754	+ s->oformat = feed->fmt;
	3755	+ s->nb_streams = feed->nb_streams;
	3756	+ s->streams = feed->streams;
	3757	+ if (avformat_write_header(s, NULL) < 0) {
	3758	+ http_log("Container doesn't supports the required parameters\n");
	3759	+ exit(1);
	3760	+ }
	3761	+ /* XXX: need better api */
	3762	+ av_freep(&s->priv_data);
	3763	+ avio_close(s->pb);
	3764	+ }
	3765	+ /* get feed size and write index */
	3766	+ fd = open(feed->feed_filename, O_RDONLY);
	3767	+ if (fd < 0) {
	3768	+ http_log("Could not open output feed file '%s'\n",
	3769	+ feed->feed_filename);
	3770	+ exit(1);
	3771	+ }
	3772	+
	3773	+ feed->feed_write_index = FFMAX(ffm_read_write_index(fd), FFM_PACKET_SIZE);
	3774	+ feed->feed_size = lseek(fd, 0, SEEK_END);
	3775	+ /* ensure that we do not wrap before the end of file */
	3776	+ if (feed->feed_max_size && feed->feed_max_size < feed->feed_size)
	3777	+ feed->feed_max_size = feed->feed_size;
	3778	+
	3779	+ close(fd);
	3780	+ }
	3781	+}
	3782	+
	3783	+/* compute the bandwidth used by each stream */
	3784	+static void compute_bandwidth(void)
	3785	+{
	3786	+ unsigned bandwidth;
	3787	+ int i;
	3788	+ FFStream *stream;
	3789	+
	3790	+ for(stream = first_stream; stream != NULL; stream = stream->next) {
	3791	+ bandwidth = 0;
	3792	+ for(i=0;i<stream->nb_streams;i++) {
	3793	+ AVStream *st = stream->streams[i];
	3794	+ switch(st->codec->codec_type) {
	3795	+ case AVMEDIA_TYPE_AUDIO:
	3796	+ case AVMEDIA_TYPE_VIDEO:
	3797	+ bandwidth += st->codec->bit_rate;
	3798	+ break;
	3799	+ default:
	3800	+ break;
	3801	+ }
	3802	+ }
	3803	+ stream->bandwidth = (bandwidth + 999) / 1000;
	3804	+ }
	3805	+}
	3806	+
	3807	+/* add a codec and set the default parameters */
	3808	+static void add_codec(FFStream stream, AVCodecContext av)
	3809	+{
	3810	+ AVStream *st;
	3811	+
	3812	+ /* compute default parameters */
	3813	+ switch(av->codec_type) {
	3814	+ case AVMEDIA_TYPE_AUDIO:
	3815	+ if (av->bit_rate == 0)
	3816	+ av->bit_rate = 64000;
	3817	+ if (av->sample_rate == 0)
	3818	+ av->sample_rate = 22050;
	3819	+ if (av->channels == 0)
	3820	+ av->channels = 1;
	3821	+ break;
	3822	+ case AVMEDIA_TYPE_VIDEO:
	3823	+ if (av->bit_rate == 0)
	3824	+ av->bit_rate = 64000;
	3825	+ if (av->time_base.num == 0){
	3826	+ av->time_base.den = 5;
	3827	+ av->time_base.num = 1;
	3828	+ }
	3829	+ if (av->width == 0 \|\| av->height == 0) {
	3830	+ av->width = 160;
	3831	+ av->height = 128;
	3832	+ }
	3833	+ /* Bitrate tolerance is less for streaming */
	3834	+ if (av->bit_rate_tolerance == 0)
	3835	+ av->bit_rate_tolerance = FFMAX(av->bit_rate / 4,
	3836	+ (int64_t)av->bit_rate*av->time_base.num/av->time_base.den);
	3837	+ if (av->qmin == 0)
	3838	+ av->qmin = 3;
	3839	+ if (av->qmax == 0)
	3840	+ av->qmax = 31;
	3841	+ if (av->max_qdiff == 0)
	3842	+ av->max_qdiff = 3;
	3843	+ av->qcompress = 0.5;
	3844	+ av->qblur = 0.5;
	3845	+
	3846	+ if (!av->nsse_weight)
	3847	+ av->nsse_weight = 8;
	3848	+
	3849	+ av->frame_skip_cmp = FF_CMP_DCTMAX;
	3850	+ if (!av->me_method)
	3851	+ av->me_method = ME_EPZS;
	3852	+ av->rc_buffer_aggressivity = 1.0;
	3853	+
	3854	+ if (!av->rc_eq)
	3855	+ av->rc_eq = "tex^qComp";
	3856	+ if (!av->i_quant_factor)
	3857	+ av->i_quant_factor = -0.8;
	3858	+ if (!av->b_quant_factor)
	3859	+ av->b_quant_factor = 1.25;
	3860	+ if (!av->b_quant_offset)
	3861	+ av->b_quant_offset = 1.25;
	3862	+ if (!av->rc_max_rate)
	3863	+ av->rc_max_rate = av->bit_rate * 2;
	3864	+
	3865	+ if (av->rc_max_rate && !av->rc_buffer_size) {
	3866	+ av->rc_buffer_size = av->rc_max_rate;
	3867	+ }
	3868	+
	3869	+
	3870	+ break;
	3871	+ default:
	3872	+ abort();
	3873	+ }
	3874	+
	3875	+ st = av_mallocz(sizeof(AVStream));
	3876	+ if (!st)
	3877	+ return;
	3878	+ st->codec = avcodec_alloc_context3(NULL);
	3879	+ stream->streams[stream->nb_streams++] = st;
	3880	+ memcpy(st->codec, av, sizeof(AVCodecContext));
	3881	+}
	3882	+
	3883	+static enum CodecID opt_audio_codec(const char *arg)
	3884	+{
	3885	+ AVCodec *p= avcodec_find_encoder_by_name(arg);
	3886	+
	3887	+ if (p == NULL \|\| p->type != AVMEDIA_TYPE_AUDIO)
	3888	+ return CODEC_ID_NONE;
	3889	+
	3890	+ return p->id;
	3891	+}
	3892	+
	3893	+static enum CodecID opt_video_codec(const char *arg)
	3894	+{
	3895	+ AVCodec *p= avcodec_find_encoder_by_name(arg);
	3896	+
	3897	+ if (p == NULL \|\| p->type != AVMEDIA_TYPE_VIDEO)
	3898	+ return CODEC_ID_NONE;
	3899	+
	3900	+ return p->id;
	3901	+}
	3902	+
	3903	+/* simplistic plugin support */
	3904	+
	3905	+#if HAVE_DLOPEN
	3906	+static void load_module(const char *filename)
	3907	+{
	3908	+ void *dll;
	3909	+ void (*init_func)(void);
	3910	+ dll = dlopen(filename, RTLD_NOW);
	3911	+ if (!dll) {
	3912	+ fprintf(stderr, "Could not load module '%s' - %s\n",
	3913	+ filename, dlerror());
	3914	+ return;
	3915	+ }
	3916	+
	3917	+ init_func = dlsym(dll, "avserver_module_init");
	3918	+ if (!init_func) {
	3919	+ fprintf(stderr,
	3920	+ "%s: init function 'avserver_module_init()' not found\n",
	3921	+ filename);
	3922	+ dlclose(dll);
	3923	+ }
	3924	+
	3925	+ init_func();
	3926	+}
	3927	+#endif
	3928	+
	3929	+static int avserver_opt_default(const char opt, const char arg,
	3930	+ AVCodecContext *avctx, int type)
	3931	+{
	3932	+ int ret = 0;
	3933	+ const AVOption *o = av_opt_find(avctx, opt, NULL, type, 0);
	3934	+ if(o)
	3935	+ ret = av_set_string3(avctx, opt, arg, 1, NULL);
	3936	+ return ret;
	3937	+}
	3938	+
	3939	+static int avserver_opt_preset(const char *arg,
	3940	+ AVCodecContext *avctx, int type,
	3941	+ enum CodecID audio_id, enum CodecID video_id)
	3942	+{
	3943	+ FILE *f=NULL;
	3944	+ char filename[1000], tmp[1000], tmp2[1000], line[1000];
	3945	+ int ret = 0;
	3946	+ AVCodec *codec = avcodec_find_encoder(avctx->codec_id);
	3947	+
	3948	+ if (!(f = get_preset_file(filename, sizeof(filename), arg, 0,
	3949	+ codec ? codec->name : NULL))) {
	3950	+ fprintf(stderr, "File for preset '%s' not found\n", arg);
	3951	+ return 1;
	3952	+ }
	3953	+
	3954	+ while(!feof(f)){
	3955	+ int e= fscanf(f, "%999[^\n]\n", line) - 1;
	3956	+ if(line[0] == '#' && !e)
	3957	+ continue;
	3958	+ e\|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
	3959	+ if(e){
	3960	+ fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
	3961	+ ret = 1;
	3962	+ break;
	3963	+ }
	3964	+ if(!strcmp(tmp, "acodec")){
	3965	+ *audio_id = opt_audio_codec(tmp2);
	3966	+ }else if(!strcmp(tmp, "vcodec")){
	3967	+ *video_id = opt_video_codec(tmp2);
	3968	+ }else if(!strcmp(tmp, "scodec")){
	3969	+ /* opt_subtitle_codec(tmp2); */
	3970	+ }else if(avserver_opt_default(tmp, tmp2, avctx, type) < 0){
	3971	+ fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
	3972	+ ret = 1;
	3973	+ break;
	3974	+ }
	3975	+ }
	3976	+
	3977	+ fclose(f);
	3978	+
	3979	+ return ret;
	3980	+}
	3981	+
	3982	+static AVOutputFormat avserver_guess_format(const char short_name, const char *filename,
	3983	+ const char *mime_type)
	3984	+{
	3985	+ AVOutputFormat *fmt = av_guess_format(short_name, filename, mime_type);
	3986	+
	3987	+ if (fmt) {
	3988	+ AVOutputFormat *stream_fmt;
	3989	+ char stream_format_name[64];
	3990	+
	3991	+ snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
	3992	+ stream_fmt = av_guess_format(stream_format_name, NULL, NULL);
	3993	+
	3994	+ if (stream_fmt)
	3995	+ fmt = stream_fmt;
	3996	+ }
	3997	+
	3998	+ return fmt;
	3999	+}
	4000	+
	4001	+static void report_config_error(const char filename, int line_num, int errors, const char *fmt, ...)
	4002	+{
	4003	+ va_list vl;
	4004	+ va_start(vl, fmt);
	4005	+ fprintf(stderr, "%s:%d: ", filename, line_num);
	4006	+ vfprintf(stderr, fmt, vl);
	4007	+ va_end(vl);
	4008	+
	4009	+ (*errors)++;
	4010	+}
	4011	+
	4012	+static int parse_ffconfig(const char *filename)
	4013	+{
	4014	+ FILE *f;
	4015	+ char line[1024];
	4016	+ char cmd[64];
	4017	+ char arg[1024];
	4018	+ const char *p;
	4019	+ int val, errors, line_num;
	4020	+ FFStream *last_stream, stream, *redirect;
	4021	+ FFStream *last_feed, feed, *s;
	4022	+ AVCodecContext audio_enc, video_enc;
	4023	+ enum CodecID audio_id, video_id;
	4024	+
	4025	+ f = fopen(filename, "r");
	4026	+ if (!f) {
	4027	+ perror(filename);
	4028	+ return -1;
	4029	+ }
	4030	+
	4031	+ errors = 0;
	4032	+ line_num = 0;
	4033	+ first_stream = NULL;
	4034	+ last_stream = &first_stream;
	4035	+ first_feed = NULL;
	4036	+ last_feed = &first_feed;
	4037	+ stream = NULL;
	4038	+ feed = NULL;
	4039	+ redirect = NULL;
	4040	+ audio_id = CODEC_ID_NONE;
	4041	+ video_id = CODEC_ID_NONE;
	4042	+
	4043	+#define ERROR(...) report_config_error(filename, line_num, &errors, __VA_ARGS__)
	4044	+ for(;;) {
	4045	+ if (fgets(line, sizeof(line), f) == NULL)
	4046	+ break;
	4047	+ line_num++;
	4048	+ p = line;
	4049	+ while (isspace(*p))
	4050	+ p++;
	4051	+ if (p == '\0' \|\| p == '#')
	4052	+ continue;
	4053	+
	4054	+ get_arg(cmd, sizeof(cmd), &p);
	4055	+
	4056	+ if (!strcasecmp(cmd, "Port")) {
	4057	+ get_arg(arg, sizeof(arg), &p);
	4058	+ val = atoi(arg);
	4059	+ if (val < 1 \|\| val > 65536) {
	4060	+ ERROR("Invalid_port: %s\n", arg);
	4061	+ }
	4062	+ my_http_addr.sin_port = htons(val);
	4063	+ } else if (!strcasecmp(cmd, "BindAddress")) {
	4064	+ get_arg(arg, sizeof(arg), &p);
	4065	+ if (resolve_host(&my_http_addr.sin_addr, arg) != 0) {
	4066	+ ERROR("%s:%d: Invalid host/IP address: %s\n", arg);
	4067	+ }
	4068	+ } else if (!strcasecmp(cmd, "NoDaemon")) {
	4069	+ avserver_daemon = 0;
	4070	+ } else if (!strcasecmp(cmd, "RTSPPort")) {
	4071	+ get_arg(arg, sizeof(arg), &p);
	4072	+ val = atoi(arg);
	4073	+ if (val < 1 \|\| val > 65536) {
	4074	+ ERROR("%s:%d: Invalid port: %s\n", arg);
	4075	+ }
	4076	+ my_rtsp_addr.sin_port = htons(atoi(arg));
	4077	+ } else if (!strcasecmp(cmd, "RTSPBindAddress")) {
	4078	+ get_arg(arg, sizeof(arg), &p);
	4079	+ if (resolve_host(&my_rtsp_addr.sin_addr, arg) != 0) {
	4080	+ ERROR("Invalid host/IP address: %s\n", arg);
	4081	+ }
	4082	+ } else if (!strcasecmp(cmd, "MaxHTTPConnections")) {
	4083	+ get_arg(arg, sizeof(arg), &p);
	4084	+ val = atoi(arg);
	4085	+ if (val < 1 \|\| val > 65536) {
	4086	+ ERROR("Invalid MaxHTTPConnections: %s\n", arg);
	4087	+ }
	4088	+ nb_max_http_connections = val;
	4089	+ } else if (!strcasecmp(cmd, "MaxClients")) {
	4090	+ get_arg(arg, sizeof(arg), &p);
	4091	+ val = atoi(arg);
	4092	+ if (val < 1 \|\| val > nb_max_http_connections) {
	4093	+ ERROR("Invalid MaxClients: %s\n", arg);
	4094	+ } else {
	4095	+ nb_max_connections = val;
	4096	+ }
	4097	+ } else if (!strcasecmp(cmd, "MaxBandwidth")) {
	4098	+ int64_t llval;
	4099	+ get_arg(arg, sizeof(arg), &p);
	4100	+ llval = atoll(arg);
	4101	+ if (llval < 10 \|\| llval > 10000000) {
	4102	+ ERROR("Invalid MaxBandwidth: %s\n", arg);
	4103	+ } else
	4104	+ max_bandwidth = llval;
	4105	+ } else if (!strcasecmp(cmd, "CustomLog")) {
	4106	+ if (!avserver_debug)
	4107	+ get_arg(logfilename, sizeof(logfilename), &p);
	4108	+ } else if (!strcasecmp(cmd, "<Feed")) {
	4109	+ /*********************************************/
	4110	+ /* Feed related options */
	4111	+ char *q;
	4112	+ if (stream \|\| feed) {
	4113	+ ERROR("Already in a tag\n");
	4114	+ } else {
	4115	+ feed = av_mallocz(sizeof(FFStream));
	4116	+ get_arg(feed->filename, sizeof(feed->filename), &p);
	4117	+ q = strrchr(feed->filename, '>');
	4118	+ if (*q)
	4119	+ *q = '\0';
	4120	+
	4121	+ for (s = first_feed; s; s = s->next) {
	4122	+ if (!strcmp(feed->filename, s->filename)) {
	4123	+ ERROR("Feed '%s' already registered\n", s->filename);
	4124	+ }
	4125	+ }
	4126	+
	4127	+ feed->fmt = av_guess_format("ffm", NULL, NULL);
	4128	+ /* defaut feed file */
	4129	+ snprintf(feed->feed_filename, sizeof(feed->feed_filename),
	4130	+ "/tmp/%s.ffm", feed->filename);
	4131	+ feed->feed_max_size = 5 * 1024 * 1024;
	4132	+ feed->is_feed = 1;
	4133	+ feed->feed = feed; /* self feeding :-) */
	4134	+
	4135	+ /* add in stream list */
	4136	+ *last_stream = feed;
	4137	+ last_stream = &feed->next;
	4138	+ /* add in feed list */
	4139	+ *last_feed = feed;
	4140	+ last_feed = &feed->next_feed;
	4141	+ }
	4142	+ } else if (!strcasecmp(cmd, "Launch")) {
	4143	+ if (feed) {
	4144	+ int i;
	4145	+
	4146	+ feed->child_argv = av_mallocz(64 * sizeof(char *));
	4147	+
	4148	+ for (i = 0; i < 62; i++) {
	4149	+ get_arg(arg, sizeof(arg), &p);
	4150	+ if (!arg[0])
	4151	+ break;
	4152	+
	4153	+ feed->child_argv[i] = av_strdup(arg);
	4154	+ }
	4155	+
	4156	+ feed->child_argv[i] = av_malloc(30 + strlen(feed->filename));
	4157	+
	4158	+ snprintf(feed->child_argv[i], 30+strlen(feed->filename),
	4159	+ "http://%s:%d/%s",
	4160	+ (my_http_addr.sin_addr.s_addr == INADDR_ANY) ? "127.0.0.1" :
	4161	+ inet_ntoa(my_http_addr.sin_addr),
	4162	+ ntohs(my_http_addr.sin_port), feed->filename);
	4163	+ }
	4164	+ } else if (!strcasecmp(cmd, "ReadOnlyFile")) {
	4165	+ if (feed) {
	4166	+ get_arg(feed->feed_filename, sizeof(feed->feed_filename), &p);
	4167	+ feed->readonly = 1;
	4168	+ } else if (stream) {
	4169	+ get_arg(stream->feed_filename, sizeof(stream->feed_filename), &p);
	4170	+ }
	4171	+ } else if (!strcasecmp(cmd, "File")) {
	4172	+ if (feed) {
	4173	+ get_arg(feed->feed_filename, sizeof(feed->feed_filename), &p);
	4174	+ } else if (stream)
	4175	+ get_arg(stream->feed_filename, sizeof(stream->feed_filename), &p);
	4176	+ } else if (!strcasecmp(cmd, "Truncate")) {
	4177	+ if (feed) {
	4178	+ get_arg(arg, sizeof(arg), &p);
	4179	+ feed->truncate = strtod(arg, NULL);
	4180	+ }
	4181	+ } else if (!strcasecmp(cmd, "FileMaxSize")) {
	4182	+ if (feed) {
	4183	+ char *p1;
	4184	+ double fsize;
	4185	+
	4186	+ get_arg(arg, sizeof(arg), &p);
	4187	+ p1 = arg;
	4188	+ fsize = strtod(p1, &p1);
	4189	+ switch(toupper(*p1)) {
	4190	+ case 'K':
	4191	+ fsize *= 1024;
	4192	+ break;
	4193	+ case 'M':
	4194	+ fsize = 1024 1024;
	4195	+ break;
	4196	+ case 'G':
	4197	+ fsize = 1024 1024 * 1024;
	4198	+ break;
	4199	+ }
	4200	+ feed->feed_max_size = (int64_t)fsize;
	4201	+ if (feed->feed_max_size < FFM_PACKET_SIZE*4) {
	4202	+ ERROR("Feed max file size is too small, must be at least %d\n", FFM_PACKET_SIZE*4);
	4203	+ }
	4204	+ }
	4205	+ } else if (!strcasecmp(cmd, "</Feed>")) {
	4206	+ if (!feed) {
	4207	+ ERROR("No corresponding <Feed> for </Feed>\n");
	4208	+ }
	4209	+ feed = NULL;
	4210	+ } else if (!strcasecmp(cmd, "<Stream")) {
	4211	+ /*********************************************/
	4212	+ /* Stream related options */
	4213	+ char *q;
	4214	+ if (stream \|\| feed) {
	4215	+ ERROR("Already in a tag\n");
	4216	+ } else {
	4217	+ FFStream *s;
	4218	+ stream = av_mallocz(sizeof(FFStream));
	4219	+ get_arg(stream->filename, sizeof(stream->filename), &p);
	4220	+ q = strrchr(stream->filename, '>');
	4221	+ if (*q)
	4222	+ *q = '\0';
	4223	+
	4224	+ for (s = first_stream; s; s = s->next) {
	4225	+ if (!strcmp(stream->filename, s->filename)) {
	4226	+ ERROR("Stream '%s' already registered\n", s->filename);
	4227	+ }
	4228	+ }
	4229	+
	4230	+ stream->fmt = avserver_guess_format(NULL, stream->filename, NULL);
	4231	+ avcodec_get_context_defaults2(&video_enc, AVMEDIA_TYPE_VIDEO);
	4232	+ avcodec_get_context_defaults2(&audio_enc, AVMEDIA_TYPE_AUDIO);
	4233	+ audio_id = CODEC_ID_NONE;
	4234	+ video_id = CODEC_ID_NONE;
	4235	+ if (stream->fmt) {
	4236	+ audio_id = stream->fmt->audio_codec;
	4237	+ video_id = stream->fmt->video_codec;
	4238	+ }
	4239	+
	4240	+ *last_stream = stream;
	4241	+ last_stream = &stream->next;
	4242	+ }
	4243	+ } else if (!strcasecmp(cmd, "Feed")) {
	4244	+ get_arg(arg, sizeof(arg), &p);
	4245	+ if (stream) {
	4246	+ FFStream *sfeed;
	4247	+
	4248	+ sfeed = first_feed;
	4249	+ while (sfeed != NULL) {
	4250	+ if (!strcmp(sfeed->filename, arg))
	4251	+ break;
	4252	+ sfeed = sfeed->next_feed;
	4253	+ }
	4254	+ if (!sfeed)
	4255	+ ERROR("feed '%s' not defined\n", arg);
	4256	+ else
	4257	+ stream->feed = sfeed;
	4258	+ }
	4259	+ } else if (!strcasecmp(cmd, "Format")) {
	4260	+ get_arg(arg, sizeof(arg), &p);
	4261	+ if (stream) {
	4262	+ if (!strcmp(arg, "status")) {
	4263	+ stream->stream_type = STREAM_TYPE_STATUS;
	4264	+ stream->fmt = NULL;
	4265	+ } else {
	4266	+ stream->stream_type = STREAM_TYPE_LIVE;
	4267	+ /* jpeg cannot be used here, so use single frame jpeg */
	4268	+ if (!strcmp(arg, "jpeg"))
	4269	+ strcpy(arg, "mjpeg");
	4270	+ stream->fmt = avserver_guess_format(arg, NULL, NULL);
	4271	+ if (!stream->fmt) {
	4272	+ ERROR("Unknown Format: %s\n", arg);
	4273	+ }
	4274	+ }
	4275	+ if (stream->fmt) {
	4276	+ audio_id = stream->fmt->audio_codec;
	4277	+ video_id = stream->fmt->video_codec;
	4278	+ }
	4279	+ }
	4280	+ } else if (!strcasecmp(cmd, "InputFormat")) {
	4281	+ get_arg(arg, sizeof(arg), &p);
	4282	+ if (stream) {
	4283	+ stream->ifmt = av_find_input_format(arg);
	4284	+ if (!stream->ifmt) {
	4285	+ ERROR("Unknown input format: %s\n", arg);
	4286	+ }
	4287	+ }
	4288	+ } else if (!strcasecmp(cmd, "FaviconURL")) {
	4289	+ if (stream && stream->stream_type == STREAM_TYPE_STATUS) {
	4290	+ get_arg(stream->feed_filename, sizeof(stream->feed_filename), &p);
	4291	+ } else {
	4292	+ ERROR("FaviconURL only permitted for status streams\n");
	4293	+ }
	4294	+ } else if (!strcasecmp(cmd, "Author")) {
	4295	+ if (stream)
	4296	+ get_arg(stream->author, sizeof(stream->author), &p);
	4297	+ } else if (!strcasecmp(cmd, "Comment")) {
	4298	+ if (stream)
	4299	+ get_arg(stream->comment, sizeof(stream->comment), &p);
	4300	+ } else if (!strcasecmp(cmd, "Copyright")) {
	4301	+ if (stream)
	4302	+ get_arg(stream->copyright, sizeof(stream->copyright), &p);
	4303	+ } else if (!strcasecmp(cmd, "Title")) {
	4304	+ if (stream)
	4305	+ get_arg(stream->title, sizeof(stream->title), &p);
	4306	+ } else if (!strcasecmp(cmd, "Preroll")) {
	4307	+ get_arg(arg, sizeof(arg), &p);
	4308	+ if (stream)
	4309	+ stream->prebuffer = atof(arg) * 1000;
	4310	+ } else if (!strcasecmp(cmd, "StartSendOnKey")) {
	4311	+ if (stream)
	4312	+ stream->send_on_key = 1;
	4313	+ } else if (!strcasecmp(cmd, "AudioCodec")) {
	4314	+ get_arg(arg, sizeof(arg), &p);
	4315	+ audio_id = opt_audio_codec(arg);
	4316	+ if (audio_id == CODEC_ID_NONE) {
	4317	+ ERROR("Unknown AudioCodec: %s\n", arg);
	4318	+ }
	4319	+ } else if (!strcasecmp(cmd, "VideoCodec")) {
	4320	+ get_arg(arg, sizeof(arg), &p);
	4321	+ video_id = opt_video_codec(arg);
	4322	+ if (video_id == CODEC_ID_NONE) {
	4323	+ ERROR("Unknown VideoCodec: %s\n", arg);
	4324	+ }
	4325	+ } else if (!strcasecmp(cmd, "MaxTime")) {
	4326	+ get_arg(arg, sizeof(arg), &p);
	4327	+ if (stream)
	4328	+ stream->max_time = atof(arg) * 1000;
	4329	+ } else if (!strcasecmp(cmd, "AudioBitRate")) {
	4330	+ get_arg(arg, sizeof(arg), &p);
	4331	+ if (stream)
	4332	+ audio_enc.bit_rate = lrintf(atof(arg) * 1000);
	4333	+ } else if (!strcasecmp(cmd, "AudioChannels")) {
	4334	+ get_arg(arg, sizeof(arg), &p);
	4335	+ if (stream)
	4336	+ audio_enc.channels = atoi(arg);
	4337	+ } else if (!strcasecmp(cmd, "AudioSampleRate")) {
	4338	+ get_arg(arg, sizeof(arg), &p);
	4339	+ if (stream)
	4340	+ audio_enc.sample_rate = atoi(arg);
	4341	+ } else if (!strcasecmp(cmd, "AudioQuality")) {
	4342	+ get_arg(arg, sizeof(arg), &p);
	4343	+ if (stream) {
	4344	+// audio_enc.quality = atof(arg) * 1000;
	4345	+ }
	4346	+ } else if (!strcasecmp(cmd, "VideoBitRateRange")) {
	4347	+ if (stream) {
	4348	+ int minrate, maxrate;
	4349	+
	4350	+ get_arg(arg, sizeof(arg), &p);
	4351	+
	4352	+ if (sscanf(arg, "%d-%d", &minrate, &maxrate) == 2) {
	4353	+ video_enc.rc_min_rate = minrate * 1000;
	4354	+ video_enc.rc_max_rate = maxrate * 1000;
	4355	+ } else {
	4356	+ ERROR("Incorrect format for VideoBitRateRange -- should be <min>-<max>: %s\n", arg);
	4357	+ }
	4358	+ }
	4359	+ } else if (!strcasecmp(cmd, "Debug")) {
	4360	+ if (stream) {
	4361	+ get_arg(arg, sizeof(arg), &p);
	4362	+ video_enc.debug = strtol(arg,0,0);
	4363	+ }
	4364	+ } else if (!strcasecmp(cmd, "Strict")) {
	4365	+ if (stream) {
	4366	+ get_arg(arg, sizeof(arg), &p);
	4367	+ video_enc.strict_std_compliance = atoi(arg);
	4368	+ }
	4369	+ } else if (!strcasecmp(cmd, "VideoBufferSize")) {
	4370	+ if (stream) {
	4371	+ get_arg(arg, sizeof(arg), &p);
	4372	+ video_enc.rc_buffer_size = atoi(arg) * 8*1024;
	4373	+ }
	4374	+ } else if (!strcasecmp(cmd, "VideoBitRateTolerance")) {
	4375	+ if (stream) {
	4376	+ get_arg(arg, sizeof(arg), &p);
	4377	+ video_enc.bit_rate_tolerance = atoi(arg) * 1000;
	4378	+ }
	4379	+ } else if (!strcasecmp(cmd, "VideoBitRate")) {
	4380	+ get_arg(arg, sizeof(arg), &p);
	4381	+ if (stream) {
	4382	+ video_enc.bit_rate = atoi(arg) * 1000;
	4383	+ }
	4384	+ } else if (!strcasecmp(cmd, "VideoSize")) {
	4385	+ get_arg(arg, sizeof(arg), &p);
	4386	+ if (stream) {
	4387	+ av_parse_video_size(&video_enc.width, &video_enc.height, arg);
	4388	+ if ((video_enc.width % 16) != 0 \|\|
	4389	+ (video_enc.height % 16) != 0) {
	4390	+ ERROR("Image size must be a multiple of 16\n");
	4391	+ }
	4392	+ }
	4393	+ } else if (!strcasecmp(cmd, "VideoFrameRate")) {
	4394	+ get_arg(arg, sizeof(arg), &p);
	4395	+ if (stream) {
	4396	+ AVRational frame_rate;
	4397	+ if (av_parse_video_rate(&frame_rate, arg) < 0) {
	4398	+ ERROR("Incorrect frame rate: %s\n", arg);
	4399	+ } else {
	4400	+ video_enc.time_base.num = frame_rate.den;
	4401	+ video_enc.time_base.den = frame_rate.num;
	4402	+ }
	4403	+ }
	4404	+ } else if (!strcasecmp(cmd, "VideoGopSize")) {
	4405	+ get_arg(arg, sizeof(arg), &p);
	4406	+ if (stream)
	4407	+ video_enc.gop_size = atoi(arg);
	4408	+ } else if (!strcasecmp(cmd, "VideoIntraOnly")) {
	4409	+ if (stream)
	4410	+ video_enc.gop_size = 1;
	4411	+ } else if (!strcasecmp(cmd, "VideoHighQuality")) {
	4412	+ if (stream)
	4413	+ video_enc.mb_decision = FF_MB_DECISION_BITS;
	4414	+ } else if (!strcasecmp(cmd, "Video4MotionVector")) {
	4415	+ if (stream) {
	4416	+ video_enc.mb_decision = FF_MB_DECISION_BITS; //FIXME remove
	4417	+ video_enc.flags \|= CODEC_FLAG_4MV;
	4418	+ }
	4419	+ } else if (!strcasecmp(cmd, "AVOptionVideo") \|\|
	4420	+ !strcasecmp(cmd, "AVOptionAudio")) {
	4421	+ char arg2[1024];
	4422	+ AVCodecContext *avctx;
	4423	+ int type;
	4424	+ get_arg(arg, sizeof(arg), &p);
	4425	+ get_arg(arg2, sizeof(arg2), &p);
	4426	+ if (!strcasecmp(cmd, "AVOptionVideo")) {
	4427	+ avctx = &video_enc;
	4428	+ type = AV_OPT_FLAG_VIDEO_PARAM;
	4429	+ } else {
	4430	+ avctx = &audio_enc;
	4431	+ type = AV_OPT_FLAG_AUDIO_PARAM;
	4432	+ }
	4433	+ if (avserver_opt_default(arg, arg2, avctx, type\|AV_OPT_FLAG_ENCODING_PARAM)) {
	4434	+ ERROR("AVOption error: %s %s\n", arg, arg2);
	4435	+ }
	4436	+ } else if (!strcasecmp(cmd, "AVPresetVideo") \|\|
	4437	+ !strcasecmp(cmd, "AVPresetAudio")) {
	4438	+ AVCodecContext *avctx;
	4439	+ int type;
	4440	+ get_arg(arg, sizeof(arg), &p);
	4441	+ if (!strcasecmp(cmd, "AVPresetVideo")) {
	4442	+ avctx = &video_enc;
	4443	+ video_enc.codec_id = video_id;
	4444	+ type = AV_OPT_FLAG_VIDEO_PARAM;
	4445	+ } else {
	4446	+ avctx = &audio_enc;
	4447	+ audio_enc.codec_id = audio_id;
	4448	+ type = AV_OPT_FLAG_AUDIO_PARAM;
	4449	+ }
	4450	+ if (avserver_opt_preset(arg, avctx, type\|AV_OPT_FLAG_ENCODING_PARAM, &audio_id, &video_id)) {
	4451	+ ERROR("AVPreset error: %s\n", arg);
	4452	+ }
	4453	+ } else if (!strcasecmp(cmd, "VideoTag")) {
	4454	+ get_arg(arg, sizeof(arg), &p);
	4455	+ if ((strlen(arg) == 4) && stream)
	4456	+ video_enc.codec_tag = MKTAG(arg[0], arg[1], arg[2], arg[3]);
	4457	+ } else if (!strcasecmp(cmd, "BitExact")) {
	4458	+ if (stream)
	4459	+ video_enc.flags \|= CODEC_FLAG_BITEXACT;
	4460	+ } else if (!strcasecmp(cmd, "DctFastint")) {
	4461	+ if (stream)
	4462	+ video_enc.dct_algo = FF_DCT_FASTINT;
	4463	+ } else if (!strcasecmp(cmd, "IdctSimple")) {
	4464	+ if (stream)
	4465	+ video_enc.idct_algo = FF_IDCT_SIMPLE;
	4466	+ } else if (!strcasecmp(cmd, "Qscale")) {
	4467	+ get_arg(arg, sizeof(arg), &p);
	4468	+ if (stream) {
	4469	+ video_enc.flags \|= CODEC_FLAG_QSCALE;
	4470	+ video_enc.global_quality = FF_QP2LAMBDA * atoi(arg);
	4471	+ }
	4472	+ } else if (!strcasecmp(cmd, "VideoQDiff")) {
	4473	+ get_arg(arg, sizeof(arg), &p);
	4474	+ if (stream) {
	4475	+ video_enc.max_qdiff = atoi(arg);
	4476	+ if (video_enc.max_qdiff < 1 \|\| video_enc.max_qdiff > 31) {
	4477	+ ERROR("VideoQDiff out of range\n");
	4478	+ }
	4479	+ }
	4480	+ } else if (!strcasecmp(cmd, "VideoQMax")) {
	4481	+ get_arg(arg, sizeof(arg), &p);
	4482	+ if (stream) {
	4483	+ video_enc.qmax = atoi(arg);
	4484	+ if (video_enc.qmax < 1 \|\| video_enc.qmax > 31) {
	4485	+ ERROR("VideoQMax out of range\n");
	4486	+ }
	4487	+ }
	4488	+ } else if (!strcasecmp(cmd, "VideoQMin")) {
	4489	+ get_arg(arg, sizeof(arg), &p);
	4490	+ if (stream) {
	4491	+ video_enc.qmin = atoi(arg);
	4492	+ if (video_enc.qmin < 1 \|\| video_enc.qmin > 31) {
	4493	+ ERROR("VideoQMin out of range\n");
	4494	+ }
	4495	+ }
	4496	+ } else if (!strcasecmp(cmd, "LumaElim")) {
	4497	+ get_arg(arg, sizeof(arg), &p);
	4498	+ if (stream)
	4499	+ video_enc.luma_elim_threshold = atoi(arg);
	4500	+ } else if (!strcasecmp(cmd, "ChromaElim")) {
	4501	+ get_arg(arg, sizeof(arg), &p);
	4502	+ if (stream)
	4503	+ video_enc.chroma_elim_threshold = atoi(arg);
	4504	+ } else if (!strcasecmp(cmd, "LumiMask")) {
	4505	+ get_arg(arg, sizeof(arg), &p);
	4506	+ if (stream)
	4507	+ video_enc.lumi_masking = atof(arg);
	4508	+ } else if (!strcasecmp(cmd, "DarkMask")) {
	4509	+ get_arg(arg, sizeof(arg), &p);
	4510	+ if (stream)
	4511	+ video_enc.dark_masking = atof(arg);
	4512	+ } else if (!strcasecmp(cmd, "NoVideo")) {
	4513	+ video_id = CODEC_ID_NONE;
	4514	+ } else if (!strcasecmp(cmd, "NoAudio")) {
	4515	+ audio_id = CODEC_ID_NONE;
	4516	+ } else if (!strcasecmp(cmd, "ACL")) {
	4517	+ parse_acl_row(stream, feed, NULL, p, filename, line_num);
	4518	+ } else if (!strcasecmp(cmd, "DynamicACL")) {
	4519	+ if (stream) {
	4520	+ get_arg(stream->dynamic_acl, sizeof(stream->dynamic_acl), &p);
	4521	+ }
	4522	+ } else if (!strcasecmp(cmd, "RTSPOption")) {
	4523	+ get_arg(arg, sizeof(arg), &p);
	4524	+ if (stream) {
	4525	+ av_freep(&stream->rtsp_option);
	4526	+ stream->rtsp_option = av_strdup(arg);
	4527	+ }
	4528	+ } else if (!strcasecmp(cmd, "MulticastAddress")) {
	4529	+ get_arg(arg, sizeof(arg), &p);
	4530	+ if (stream) {
	4531	+ if (resolve_host(&stream->multicast_ip, arg) != 0) {
	4532	+ ERROR("Invalid host/IP address: %s\n", arg);
	4533	+ }
	4534	+ stream->is_multicast = 1;
	4535	+ stream->loop = 1; /* default is looping */
	4536	+ }
	4537	+ } else if (!strcasecmp(cmd, "MulticastPort")) {
	4538	+ get_arg(arg, sizeof(arg), &p);
	4539	+ if (stream)
	4540	+ stream->multicast_port = atoi(arg);
	4541	+ } else if (!strcasecmp(cmd, "MulticastTTL")) {
	4542	+ get_arg(arg, sizeof(arg), &p);
	4543	+ if (stream)
	4544	+ stream->multicast_ttl = atoi(arg);
	4545	+ } else if (!strcasecmp(cmd, "NoLoop")) {
	4546	+ if (stream)
	4547	+ stream->loop = 0;
	4548	+ } else if (!strcasecmp(cmd, "</Stream>")) {
	4549	+ if (!stream) {
	4550	+ ERROR("No corresponding <Stream> for </Stream>\n");
	4551	+ } else {
	4552	+ if (stream->feed && stream->fmt && strcmp(stream->fmt->name, "ffm") != 0) {
	4553	+ if (audio_id != CODEC_ID_NONE) {
	4554	+ audio_enc.codec_type = AVMEDIA_TYPE_AUDIO;
	4555	+ audio_enc.codec_id = audio_id;
	4556	+ add_codec(stream, &audio_enc);
	4557	+ }
	4558	+ if (video_id != CODEC_ID_NONE) {
	4559	+ video_enc.codec_type = AVMEDIA_TYPE_VIDEO;
	4560	+ video_enc.codec_id = video_id;
	4561	+ add_codec(stream, &video_enc);
	4562	+ }
	4563	+ }
	4564	+ stream = NULL;
	4565	+ }
	4566	+ } else if (!strcasecmp(cmd, "<Redirect")) {
	4567	+ /*********************************************/
	4568	+ char *q;
	4569	+ if (stream \|\| feed \|\| redirect) {
	4570	+ ERROR("Already in a tag\n");
	4571	+ } else {
	4572	+ redirect = av_mallocz(sizeof(FFStream));
	4573	+ *last_stream = redirect;
	4574	+ last_stream = &redirect->next;
	4575	+
	4576	+ get_arg(redirect->filename, sizeof(redirect->filename), &p);
	4577	+ q = strrchr(redirect->filename, '>');
	4578	+ if (*q)
	4579	+ *q = '\0';
	4580	+ redirect->stream_type = STREAM_TYPE_REDIRECT;
	4581	+ }
	4582	+ } else if (!strcasecmp(cmd, "URL")) {
	4583	+ if (redirect)
	4584	+ get_arg(redirect->feed_filename, sizeof(redirect->feed_filename), &p);
	4585	+ } else if (!strcasecmp(cmd, "</Redirect>")) {
	4586	+ if (!redirect) {
	4587	+ ERROR("No corresponding <Redirect> for </Redirect>\n");
	4588	+ } else {
	4589	+ if (!redirect->feed_filename[0]) {
	4590	+ ERROR("No URL found for <Redirect>\n");
	4591	+ }
	4592	+ redirect = NULL;
	4593	+ }
	4594	+ } else if (!strcasecmp(cmd, "LoadModule")) {
	4595	+ get_arg(arg, sizeof(arg), &p);
	4596	+#if HAVE_DLOPEN
	4597	+ load_module(arg);
	4598	+#else
	4599	+ ERROR("Module support not compiled into this version: '%s'\n", arg);
	4600	+#endif
	4601	+ } else {
	4602	+ ERROR("Incorrect keyword: '%s'\n", cmd);
	4603	+ }
	4604	+ }
	4605	+#undef ERROR
	4606	+
	4607	+ fclose(f);
	4608	+ if (errors)
	4609	+ return -1;
	4610	+ else
	4611	+ return 0;
	4612	+}
	4613	+
	4614	+static void handle_child_exit(int sig)
	4615	+{
	4616	+ pid_t pid;
	4617	+ int status;
	4618	+
	4619	+ while ((pid = waitpid(-1, &status, WNOHANG)) > 0) {
	4620	+ FFStream *feed;
	4621	+
	4622	+ for (feed = first_feed; feed; feed = feed->next) {
	4623	+ if (feed->pid == pid) {
	4624	+ int uptime = time(0) - feed->pid_start;
	4625	+
	4626	+ feed->pid = 0;
	4627	+ fprintf(stderr, "%s: Pid %d exited with status %d after %d seconds\n", feed->filename, pid, status, uptime);
	4628	+
	4629	+ if (uptime < 30)
	4630	+ /* Turn off any more restarts */
	4631	+ feed->child_argv = 0;
	4632	+ }
	4633	+ }
	4634	+ }
	4635	+
	4636	+ need_to_start_children = 1;
	4637	+}
	4638	+
	4639	+static void opt_debug(void)
	4640	+{
	4641	+ avserver_debug = 1;
	4642	+ avserver_daemon = 0;
	4643	+ logfilename[0] = '-';
	4644	+}
	4645	+
	4646	+static void show_help(void)
	4647	+{
	4648	+ printf("usage: avserver [options]\n"
	4649	+ "Hyper fast multi format Audio/Video streaming server\n");
	4650	+ printf("\n");
	4651	+ show_help_options(options, "Main options:\n", 0, 0);
	4652	+}
	4653	+
	4654	+static const OptionDef options[] = {
	4655	+#include "cmdutils_common_opts.h"
	4656	+ { "n", OPT_BOOL, {(void *)&no_launch }, "enable no-launch mode" },
	4657	+ { "d", 0, {(void*)opt_debug}, "enable debug mode" },
	4658	+ { "f", HAS_ARG \| OPT_STRING, {(void*)&config_filename }, "use configfile instead of /etc/avserver.conf", "configfile" },
	4659	+ { NULL },
	4660	+};
	4661	+
	4662	+int main(int argc, char **argv)
	4663	+{
	4664	+ struct sigaction sigact;
	4665	+
	4666	+ av_register_all();
	4667	+
	4668	+ show_banner();
	4669	+
	4670	+ my_program_name = argv[0];
	4671	+ my_program_dir = getcwd(0, 0);
	4672	+ avserver_daemon = 1;
	4673	+
	4674	+ parse_options(argc, argv, options, NULL);
	4675	+
	4676	+ unsetenv("http_proxy"); /* Kill the http_proxy */
	4677	+
	4678	+ av_lfg_init(&random_state, av_get_random_seed());
	4679	+
	4680	+ memset(&sigact, 0, sizeof(sigact));
	4681	+ sigact.sa_handler = handle_child_exit;
	4682	+ sigact.sa_flags = SA_NOCLDSTOP \| SA_RESTART;
	4683	+ sigaction(SIGCHLD, &sigact, 0);
	4684	+
	4685	+ if (parse_ffconfig(config_filename) < 0) {
	4686	+ fprintf(stderr, "Incorrect config file - exiting.\n");
	4687	+ exit(1);
	4688	+ }
	4689	+
	4690	+ /* open log file if needed */
	4691	+ if (logfilename[0] != '\0') {
	4692	+ if (!strcmp(logfilename, "-"))
	4693	+ logfile = stdout;
	4694	+ else
	4695	+ logfile = fopen(logfilename, "a");
	4696	+ av_log_set_callback(http_av_log);
	4697	+ }
	4698	+
	4699	+ build_file_streams();
	4700	+
	4701	+ build_feed_streams();
	4702	+
	4703	+ compute_bandwidth();
	4704	+
	4705	+ /* put the process in background and detach it from its TTY */
	4706	+ if (avserver_daemon) {
	4707	+ int pid;
	4708	+
	4709	+ pid = fork();
	4710	+ if (pid < 0) {
	4711	+ perror("fork");
	4712	+ exit(1);
	4713	+ } else if (pid > 0) {
	4714	+ /* parent : exit */
	4715	+ exit(0);
	4716	+ } else {
	4717	+ /* child */
	4718	+ setsid();
	4719	+ close(0);
	4720	+ open("/dev/null", O_RDWR);
	4721	+ if (strcmp(logfilename, "-") != 0) {
	4722	+ close(1);
	4723	+ dup(0);
	4724	+ }
	4725	+ close(2);
	4726	+ dup(0);
	4727	+ }
	4728	+ }
	4729	+
	4730	+ /* signal init */
	4731	+ signal(SIGPIPE, SIG_IGN);
	4732	+
	4733	+ if (avserver_daemon)
	4734	+ chdir("/");
	4735	+
	4736	+ if (http_server() < 0) {
	4737	+ http_log("Could not start server\n");
	4738	+ exit(1);
	4739	+ }
	4740	+
	4741	+ return 0;
	4742	+}

Rename ffserver to avserver.

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code