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