2 * Multiple format streaming server
3 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2 of the License, or (at your option) any later version.
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 #define HAVE_AV_CONFIG_H
25 #include <sys/ioctl.h>
30 #include <sys/types.h>
31 #include <sys/socket.h>
33 #include <netinet/in.h>
34 #include <arpa/inet.h>
37 #ifdef CONFIG_HAVE_DLFCN
43 /* maximum number of simultaneous HTTP connections */
44 #define HTTP_MAX_CONNECTIONS 2000
47 HTTPSTATE_WAIT_REQUEST,
48 HTTPSTATE_SEND_HEADER,
49 HTTPSTATE_SEND_DATA_HEADER,
50 HTTPSTATE_SEND_DATA, /* sending TCP or UDP data */
51 HTTPSTATE_SEND_DATA_TRAILER,
52 HTTPSTATE_RECEIVE_DATA,
53 HTTPSTATE_WAIT_FEED, /* wait for data from the feed */
56 RTSPSTATE_WAIT_REQUEST,
58 RTSPSTATE_SEND_PACKET,
61 const char *http_state[] = {
77 #define IOBUFFER_INIT_SIZE 8192
79 /* coef for exponential mean for bitrate estimation in statistics */
82 /* timeouts are in ms */
83 #define HTTP_REQUEST_TIMEOUT (15 * 1000)
84 #define RTSP_REQUEST_TIMEOUT (3600 * 24 * 1000)
86 #define SYNC_TIMEOUT (10 * 1000)
89 int64_t count1, count2;
93 /* context associated with one connection */
94 typedef struct HTTPContext {
96 int fd; /* socket file descriptor */
97 struct sockaddr_in from_addr; /* origin */
98 struct pollfd *poll_entry; /* used when polling */
100 uint8_t *buffer_ptr, *buffer_end;
102 struct HTTPContext *next;
103 int got_key_frame; /* stream 0 => 1, stream 1 => 2, stream 2=> 4 */
107 /* input format handling */
108 AVFormatContext *fmt_in;
109 long start_time; /* In milliseconds - this wraps fairly often */
110 int64_t first_pts; /* initial pts value */
111 int64_t cur_pts; /* current pts value from the stream in us */
112 int64_t cur_frame_duration; /* duration of the current frame in us */
113 int cur_frame_bytes; /* output frame size, needed to compute
114 the time at which we send each
116 int pts_stream_index; /* stream we choose as clock reference */
117 int64_t cur_clock; /* current clock reference value in us */
118 /* output format handling */
119 struct FFStream *stream;
120 /* -1 is invalid stream */
121 int feed_streams[MAX_STREAMS]; /* index of streams in the feed */
122 int switch_feed_streams[MAX_STREAMS]; /* index of streams in the feed */
124 AVFormatContext fmt_ctx; /* instance of FFStream for one user */
125 int last_packet_sent; /* true if last data packet was sent */
127 DataRateData datarate;
134 int is_packetized; /* if true, the stream is packetized */
135 int packet_stream_index; /* current stream for output in state machine */
137 /* RTSP state specific */
138 uint8_t *pb_buffer; /* XXX: use that in all the code */
140 int seq; /* RTSP sequence number */
142 /* RTP state specific */
143 enum RTSPProtocol rtp_protocol;
144 char session_id[32]; /* session id */
145 AVFormatContext *rtp_ctx[MAX_STREAMS];
147 /* RTP/UDP specific */
148 URLContext *rtp_handles[MAX_STREAMS];
150 /* RTP/TCP specific */
151 struct HTTPContext *rtsp_c;
152 uint8_t *packet_buffer, *packet_buffer_ptr, *packet_buffer_end;
155 static AVFrame dummy_frame;
157 /* each generated stream is described here */
161 STREAM_TYPE_REDIRECT,
164 enum IPAddressAction {
169 typedef struct IPAddressACL {
170 struct IPAddressACL *next;
171 enum IPAddressAction action;
172 /* These are in host order */
173 struct in_addr first;
177 /* description of each stream of the ffserver.conf file */
178 typedef struct FFStream {
179 enum StreamType stream_type;
180 char filename[1024]; /* stream filename */
181 struct FFStream *feed; /* feed we are using (can be null if
183 AVFormatParameters *ap_in; /* input parameters */
184 AVInputFormat *ifmt; /* if non NULL, force input format */
188 int prebuffer; /* Number of millseconds early to start */
189 long max_time; /* Number of milliseconds to run */
191 AVStream *streams[MAX_STREAMS];
192 int feed_streams[MAX_STREAMS]; /* index of streams in the feed */
193 char feed_filename[1024]; /* file name of the feed storage, or
194 input file name for a stream */
199 pid_t pid; /* Of ffmpeg process */
200 time_t pid_start; /* Of ffmpeg process */
202 struct FFStream *next;
203 int bandwidth; /* bandwidth, in kbits/s */
206 /* multicast specific */
208 struct in_addr multicast_ip;
209 int multicast_port; /* first port used for multicast */
211 int loop; /* if true, send the stream in loops (only meaningful if file) */
214 int feed_opened; /* true if someone is writing to the feed */
215 int is_feed; /* true if it is a feed */
216 int readonly; /* True if writing is prohibited to the file */
218 int64_t bytes_served;
219 int64_t feed_max_size; /* maximum storage size */
220 int64_t feed_write_index; /* current write position in feed (it wraps round) */
221 int64_t feed_size; /* current size of feed */
222 struct FFStream *next_feed;
225 typedef struct FeedData {
226 long long data_count;
227 float avg_frame_size; /* frame size averraged over last frames with exponential mean */
230 struct sockaddr_in my_http_addr;
231 struct sockaddr_in my_rtsp_addr;
233 char logfilename[1024];
234 HTTPContext *first_http_ctx;
235 FFStream *first_feed; /* contains only feeds */
236 FFStream *first_stream; /* contains all streams, including feeds */
238 static void new_connection(int server_fd, int is_rtsp);
239 static void close_connection(HTTPContext *c);
242 static int handle_connection(HTTPContext *c);
243 static int http_parse_request(HTTPContext *c);
244 static int http_send_data(HTTPContext *c);
245 static void compute_stats(HTTPContext *c);
246 static int open_input_stream(HTTPContext *c, const char *info);
247 static int http_start_receive_data(HTTPContext *c);
248 static int http_receive_data(HTTPContext *c);
251 static int rtsp_parse_request(HTTPContext *c);
252 static void rtsp_cmd_describe(HTTPContext *c, const char *url);
253 static void rtsp_cmd_options(HTTPContext *c, const char *url);
254 static void rtsp_cmd_setup(HTTPContext *c, const char *url, RTSPHeader *h);
255 static void rtsp_cmd_play(HTTPContext *c, const char *url, RTSPHeader *h);
256 static void rtsp_cmd_pause(HTTPContext *c, const char *url, RTSPHeader *h);
257 static void rtsp_cmd_teardown(HTTPContext *c, const char *url, RTSPHeader *h);
260 static int prepare_sdp_description(FFStream *stream, uint8_t **pbuffer,
261 struct in_addr my_ip);
264 static HTTPContext *rtp_new_connection(struct sockaddr_in *from_addr,
265 FFStream *stream, const char *session_id,
266 enum RTSPProtocol rtp_protocol);
267 static int rtp_new_av_stream(HTTPContext *c,
268 int stream_index, struct sockaddr_in *dest_addr,
269 HTTPContext *rtsp_c);
271 static const char *my_program_name;
272 static const char *my_program_dir;
274 static int ffserver_debug;
275 static int ffserver_daemon;
276 static int no_launch;
277 static int need_to_start_children;
279 int nb_max_connections;
283 int current_bandwidth;
285 static long cur_time; // Making this global saves on passing it around everywhere
287 static long gettime_ms(void)
291 gettimeofday(&tv,NULL);
292 return (long long)tv.tv_sec * 1000 + (tv.tv_usec / 1000);
295 static FILE *logfile = NULL;
297 static void __attribute__ ((format (printf, 1, 2))) http_log(const char *fmt, ...)
303 vfprintf(logfile, fmt, ap);
309 static char *ctime1(char *buf2)
317 p = buf2 + strlen(p) - 1;
323 static void log_connection(HTTPContext *c)
330 http_log("%s - - [%s] \"%s %s %s\" %d %lld\n",
331 inet_ntoa(c->from_addr.sin_addr),
332 ctime1(buf2), c->method, c->url,
333 c->protocol, (c->http_error ? c->http_error : 200), c->data_count);
336 static void update_datarate(DataRateData *drd, int64_t count)
338 if (!drd->time1 && !drd->count1) {
339 drd->time1 = drd->time2 = cur_time;
340 drd->count1 = drd->count2 = count;
342 if (cur_time - drd->time2 > 5000) {
343 drd->time1 = drd->time2;
344 drd->count1 = drd->count2;
345 drd->time2 = cur_time;
351 /* In bytes per second */
352 static int compute_datarate(DataRateData *drd, int64_t count)
354 if (cur_time == drd->time1)
357 return ((count - drd->count1) * 1000) / (cur_time - drd->time1);
360 static int get_longterm_datarate(DataRateData *drd, int64_t count)
362 /* You get the first 3 seconds flat out */
363 if (cur_time - drd->time1 < 3000)
365 return compute_datarate(drd, count);
369 static void start_children(FFStream *feed)
374 for (; feed; feed = feed->next) {
375 if (feed->child_argv && !feed->pid) {
376 feed->pid_start = time(0);
381 fprintf(stderr, "Unable to create children\n");
390 for (i = 3; i < 256; i++) {
394 if (!ffserver_debug) {
395 i = open("/dev/null", O_RDWR);
404 pstrcpy(pathname, sizeof(pathname), my_program_name);
406 slash = strrchr(pathname, '/');
412 strcpy(slash, "ffmpeg");
414 /* This is needed to make relative pathnames work */
415 chdir(my_program_dir);
417 signal(SIGPIPE, SIG_DFL);
419 execvp(pathname, feed->child_argv);
427 /* open a listening socket */
428 static int socket_open_listen(struct sockaddr_in *my_addr)
432 server_fd = socket(AF_INET,SOCK_STREAM,0);
439 setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &tmp, sizeof(tmp));
441 if (bind (server_fd, (struct sockaddr *) my_addr, sizeof (*my_addr)) < 0) {
443 snprintf(bindmsg, sizeof(bindmsg), "bind(port %d)", ntohs(my_addr->sin_port));
449 if (listen (server_fd, 5) < 0) {
454 fcntl(server_fd, F_SETFL, O_NONBLOCK);
459 /* start all multicast streams */
460 static void start_multicast(void)
465 struct sockaddr_in dest_addr;
466 int default_port, stream_index;
469 for(stream = first_stream; stream != NULL; stream = stream->next) {
470 if (stream->is_multicast) {
471 /* open the RTP connection */
472 snprintf(session_id, sizeof(session_id),
473 "%08x%08x", (int)random(), (int)random());
475 /* choose a port if none given */
476 if (stream->multicast_port == 0) {
477 stream->multicast_port = default_port;
481 dest_addr.sin_family = AF_INET;
482 dest_addr.sin_addr = stream->multicast_ip;
483 dest_addr.sin_port = htons(stream->multicast_port);
485 rtp_c = rtp_new_connection(&dest_addr, stream, session_id,
486 RTSP_PROTOCOL_RTP_UDP_MULTICAST);
490 if (open_input_stream(rtp_c, "") < 0) {
491 fprintf(stderr, "Could not open input stream for stream '%s'\n",
496 /* open each RTP stream */
497 for(stream_index = 0; stream_index < stream->nb_streams;
499 dest_addr.sin_port = htons(stream->multicast_port +
501 if (rtp_new_av_stream(rtp_c, stream_index, &dest_addr, NULL) < 0) {
502 fprintf(stderr, "Could not open output stream '%s/streamid=%d'\n",
503 stream->filename, stream_index);
508 /* change state to send data */
509 rtp_c->state = HTTPSTATE_SEND_DATA;
514 /* main loop of the http server */
515 static int http_server(void)
517 int server_fd, ret, rtsp_server_fd, delay, delay1;
518 struct pollfd poll_table[HTTP_MAX_CONNECTIONS + 2], *poll_entry;
519 HTTPContext *c, *c_next;
521 server_fd = socket_open_listen(&my_http_addr);
525 rtsp_server_fd = socket_open_listen(&my_rtsp_addr);
526 if (rtsp_server_fd < 0)
529 http_log("ffserver started.\n");
531 start_children(first_feed);
533 first_http_ctx = NULL;
539 poll_entry = poll_table;
540 poll_entry->fd = server_fd;
541 poll_entry->events = POLLIN;
544 poll_entry->fd = rtsp_server_fd;
545 poll_entry->events = POLLIN;
548 /* wait for events on each HTTP handle */
555 case HTTPSTATE_SEND_HEADER:
556 case RTSPSTATE_SEND_REPLY:
557 case RTSPSTATE_SEND_PACKET:
558 c->poll_entry = poll_entry;
560 poll_entry->events = POLLOUT;
563 case HTTPSTATE_SEND_DATA_HEADER:
564 case HTTPSTATE_SEND_DATA:
565 case HTTPSTATE_SEND_DATA_TRAILER:
566 if (!c->is_packetized) {
567 /* for TCP, we output as much as we can (may need to put a limit) */
568 c->poll_entry = poll_entry;
570 poll_entry->events = POLLOUT;
573 /* when ffserver is doing the timing, we work by
574 looking at which packet need to be sent every
576 delay1 = 10; /* one tick wait XXX: 10 ms assumed */
581 case HTTPSTATE_WAIT_REQUEST:
582 case HTTPSTATE_RECEIVE_DATA:
583 case HTTPSTATE_WAIT_FEED:
584 case RTSPSTATE_WAIT_REQUEST:
585 /* need to catch errors */
586 c->poll_entry = poll_entry;
588 poll_entry->events = POLLIN;/* Maybe this will work */
592 c->poll_entry = NULL;
598 /* wait for an event on one connection. We poll at least every
599 second to handle timeouts */
601 ret = poll(poll_table, poll_entry - poll_table, delay);
604 cur_time = gettime_ms();
606 if (need_to_start_children) {
607 need_to_start_children = 0;
608 start_children(first_feed);
611 /* now handle the events */
612 for(c = first_http_ctx; c != NULL; c = c_next) {
614 if (handle_connection(c) < 0) {
615 /* close and free the connection */
621 poll_entry = poll_table;
622 /* new HTTP connection request ? */
623 if (poll_entry->revents & POLLIN) {
624 new_connection(server_fd, 0);
627 /* new RTSP connection request ? */
628 if (poll_entry->revents & POLLIN) {
629 new_connection(rtsp_server_fd, 1);
634 /* start waiting for a new HTTP/RTSP request */
635 static void start_wait_request(HTTPContext *c, int is_rtsp)
637 c->buffer_ptr = c->buffer;
638 c->buffer_end = c->buffer + c->buffer_size - 1; /* leave room for '\0' */
641 c->timeout = cur_time + RTSP_REQUEST_TIMEOUT;
642 c->state = RTSPSTATE_WAIT_REQUEST;
644 c->timeout = cur_time + HTTP_REQUEST_TIMEOUT;
645 c->state = HTTPSTATE_WAIT_REQUEST;
649 static void new_connection(int server_fd, int is_rtsp)
651 struct sockaddr_in from_addr;
653 HTTPContext *c = NULL;
655 len = sizeof(from_addr);
656 fd = accept(server_fd, (struct sockaddr *)&from_addr,
660 fcntl(fd, F_SETFL, O_NONBLOCK);
662 /* XXX: should output a warning page when coming
663 close to the connection limit */
664 if (nb_connections >= nb_max_connections)
667 /* add a new connection */
668 c = av_mallocz(sizeof(HTTPContext));
673 c->poll_entry = NULL;
674 c->from_addr = from_addr;
675 c->buffer_size = IOBUFFER_INIT_SIZE;
676 c->buffer = av_malloc(c->buffer_size);
680 c->next = first_http_ctx;
684 start_wait_request(c, is_rtsp);
696 static void close_connection(HTTPContext *c)
698 HTTPContext **cp, *c1;
700 AVFormatContext *ctx;
704 /* remove connection from list */
705 cp = &first_http_ctx;
706 while ((*cp) != NULL) {
715 /* remove references, if any (XXX: do it faster) */
716 for(c1 = first_http_ctx; c1 != NULL; c1 = c1->next) {
721 /* remove connection associated resources */
725 /* close each frame parser */
726 for(i=0;i<c->fmt_in->nb_streams;i++) {
727 st = c->fmt_in->streams[i];
728 if (st->codec.codec) {
729 avcodec_close(&st->codec);
732 av_close_input_file(c->fmt_in);
735 /* free RTP output streams if any */
738 nb_streams = c->stream->nb_streams;
740 for(i=0;i<nb_streams;i++) {
743 av_write_trailer(ctx);
746 h = c->rtp_handles[i];
754 if (!c->last_packet_sent) {
757 if (url_open_dyn_buf(&ctx->pb) >= 0) {
758 av_write_trailer(ctx);
759 url_close_dyn_buf(&ctx->pb, &c->pb_buffer);
764 for(i=0; i<ctx->nb_streams; i++)
765 av_free(ctx->streams[i]) ;
768 current_bandwidth -= c->stream->bandwidth;
769 av_freep(&c->pb_buffer);
770 av_freep(&c->packet_buffer);
776 static int handle_connection(HTTPContext *c)
781 case HTTPSTATE_WAIT_REQUEST:
782 case RTSPSTATE_WAIT_REQUEST:
784 if ((c->timeout - cur_time) < 0)
786 if (c->poll_entry->revents & (POLLERR | POLLHUP))
789 /* no need to read if no events */
790 if (!(c->poll_entry->revents & POLLIN))
794 len = read(c->fd, c->buffer_ptr, 1);
796 if (errno != EAGAIN && errno != EINTR)
798 } else if (len == 0) {
801 /* search for end of request. */
803 c->buffer_ptr += len;
805 if ((ptr >= c->buffer + 2 && !memcmp(ptr-2, "\n\n", 2)) ||
806 (ptr >= c->buffer + 4 && !memcmp(ptr-4, "\r\n\r\n", 4))) {
807 /* request found : parse it and reply */
808 if (c->state == HTTPSTATE_WAIT_REQUEST) {
809 ret = http_parse_request(c);
811 ret = rtsp_parse_request(c);
815 } else if (ptr >= c->buffer_end) {
816 /* request too long: cannot do anything */
818 } else goto read_loop;
822 case HTTPSTATE_SEND_HEADER:
823 if (c->poll_entry->revents & (POLLERR | POLLHUP))
826 /* no need to write if no events */
827 if (!(c->poll_entry->revents & POLLOUT))
829 len = write(c->fd, c->buffer_ptr, c->buffer_end - c->buffer_ptr);
831 if (errno != EAGAIN && errno != EINTR) {
832 /* error : close connection */
833 av_freep(&c->pb_buffer);
837 c->buffer_ptr += len;
839 c->stream->bytes_served += len;
840 c->data_count += len;
841 if (c->buffer_ptr >= c->buffer_end) {
842 av_freep(&c->pb_buffer);
847 /* all the buffer was sent : synchronize to the incoming stream */
848 c->state = HTTPSTATE_SEND_DATA_HEADER;
849 c->buffer_ptr = c->buffer_end = c->buffer;
854 case HTTPSTATE_SEND_DATA:
855 case HTTPSTATE_SEND_DATA_HEADER:
856 case HTTPSTATE_SEND_DATA_TRAILER:
857 /* for packetized output, we consider we can always write (the
858 input streams sets the speed). It may be better to verify
859 that we do not rely too much on the kernel queues */
860 if (!c->is_packetized) {
861 if (c->poll_entry->revents & (POLLERR | POLLHUP))
864 /* no need to read if no events */
865 if (!(c->poll_entry->revents & POLLOUT))
868 if (http_send_data(c) < 0)
871 case HTTPSTATE_RECEIVE_DATA:
872 /* no need to read if no events */
873 if (c->poll_entry->revents & (POLLERR | POLLHUP))
875 if (!(c->poll_entry->revents & POLLIN))
877 if (http_receive_data(c) < 0)
880 case HTTPSTATE_WAIT_FEED:
881 /* no need to read if no events */
882 if (c->poll_entry->revents & (POLLIN | POLLERR | POLLHUP))
885 /* nothing to do, we'll be waken up by incoming feed packets */
888 case RTSPSTATE_SEND_REPLY:
889 if (c->poll_entry->revents & (POLLERR | POLLHUP)) {
890 av_freep(&c->pb_buffer);
893 /* no need to write if no events */
894 if (!(c->poll_entry->revents & POLLOUT))
896 len = write(c->fd, c->buffer_ptr, c->buffer_end - c->buffer_ptr);
898 if (errno != EAGAIN && errno != EINTR) {
899 /* error : close connection */
900 av_freep(&c->pb_buffer);
904 c->buffer_ptr += len;
905 c->data_count += len;
906 if (c->buffer_ptr >= c->buffer_end) {
907 /* all the buffer was sent : wait for a new request */
908 av_freep(&c->pb_buffer);
909 start_wait_request(c, 1);
913 case RTSPSTATE_SEND_PACKET:
914 if (c->poll_entry->revents & (POLLERR | POLLHUP)) {
915 av_freep(&c->packet_buffer);
918 /* no need to write if no events */
919 if (!(c->poll_entry->revents & POLLOUT))
921 len = write(c->fd, c->packet_buffer_ptr,
922 c->packet_buffer_end - c->packet_buffer_ptr);
924 if (errno != EAGAIN && errno != EINTR) {
925 /* error : close connection */
926 av_freep(&c->packet_buffer);
930 c->packet_buffer_ptr += len;
931 if (c->packet_buffer_ptr >= c->packet_buffer_end) {
932 /* all the buffer was sent : wait for a new request */
933 av_freep(&c->packet_buffer);
934 c->state = RTSPSTATE_WAIT_REQUEST;
938 case HTTPSTATE_READY:
947 static int extract_rates(char *rates, int ratelen, const char *request)
951 for (p = request; *p && *p != '\r' && *p != '\n'; ) {
952 if (strncasecmp(p, "Pragma:", 7) == 0) {
953 const char *q = p + 7;
955 while (*q && *q != '\n' && isspace(*q))
958 if (strncasecmp(q, "stream-switch-entry=", 20) == 0) {
964 memset(rates, 0xff, ratelen);
967 while (*q && *q != '\n' && *q != ':')
970 if (sscanf(q, ":%d:%d", &stream_no, &rate_no) != 2) {
974 if (stream_no < ratelen && stream_no >= 0) {
975 rates[stream_no] = rate_no;
978 while (*q && *q != '\n' && !isspace(*q))
995 static int find_stream_in_feed(FFStream *feed, AVCodecContext *codec, int bit_rate)
998 int best_bitrate = 100000000;
1001 for (i = 0; i < feed->nb_streams; i++) {
1002 AVCodecContext *feed_codec = &feed->streams[i]->codec;
1004 if (feed_codec->codec_id != codec->codec_id ||
1005 feed_codec->sample_rate != codec->sample_rate ||
1006 feed_codec->width != codec->width ||
1007 feed_codec->height != codec->height) {
1011 /* Potential stream */
1013 /* We want the fastest stream less than bit_rate, or the slowest
1014 * faster than bit_rate
1017 if (feed_codec->bit_rate <= bit_rate) {
1018 if (best_bitrate > bit_rate || feed_codec->bit_rate > best_bitrate) {
1019 best_bitrate = feed_codec->bit_rate;
1023 if (feed_codec->bit_rate < best_bitrate) {
1024 best_bitrate = feed_codec->bit_rate;
1033 static int modify_current_stream(HTTPContext *c, char *rates)
1036 FFStream *req = c->stream;
1037 int action_required = 0;
1039 /* Not much we can do for a feed */
1043 for (i = 0; i < req->nb_streams; i++) {
1044 AVCodecContext *codec = &req->streams[i]->codec;
1048 c->switch_feed_streams[i] = req->feed_streams[i];
1051 c->switch_feed_streams[i] = find_stream_in_feed(req->feed, codec, codec->bit_rate / 2);
1054 /* Wants off or slow */
1055 c->switch_feed_streams[i] = find_stream_in_feed(req->feed, codec, codec->bit_rate / 4);
1057 /* This doesn't work well when it turns off the only stream! */
1058 c->switch_feed_streams[i] = -2;
1059 c->feed_streams[i] = -2;
1064 if (c->switch_feed_streams[i] >= 0 && c->switch_feed_streams[i] != c->feed_streams[i])
1065 action_required = 1;
1068 return action_required;
1072 static void do_switch_stream(HTTPContext *c, int i)
1074 if (c->switch_feed_streams[i] >= 0) {
1076 c->feed_streams[i] = c->switch_feed_streams[i];
1079 /* Now update the stream */
1081 c->switch_feed_streams[i] = -1;
1084 /* XXX: factorize in utils.c ? */
1085 /* XXX: take care with different space meaning */
1086 static void skip_spaces(const char **pp)
1090 while (*p == ' ' || *p == '\t')
1095 static void get_word(char *buf, int buf_size, const char **pp)
1103 while (!isspace(*p) && *p != '\0') {
1104 if ((q - buf) < buf_size - 1)
1113 static int validate_acl(FFStream *stream, HTTPContext *c)
1115 enum IPAddressAction last_action = IP_DENY;
1117 struct in_addr *src = &c->from_addr.sin_addr;
1118 unsigned long src_addr = ntohl(src->s_addr);
1120 for (acl = stream->acl; acl; acl = acl->next) {
1121 if (src_addr >= acl->first.s_addr && src_addr <= acl->last.s_addr) {
1122 return (acl->action == IP_ALLOW) ? 1 : 0;
1124 last_action = acl->action;
1127 /* Nothing matched, so return not the last action */
1128 return (last_action == IP_DENY) ? 1 : 0;
1131 /* compute the real filename of a file by matching it without its
1132 extensions to all the stream filenames */
1133 static void compute_real_filename(char *filename, int max_size)
1140 /* compute filename by matching without the file extensions */
1141 pstrcpy(file1, sizeof(file1), filename);
1142 p = strrchr(file1, '.');
1145 for(stream = first_stream; stream != NULL; stream = stream->next) {
1146 pstrcpy(file2, sizeof(file2), stream->filename);
1147 p = strrchr(file2, '.');
1150 if (!strcmp(file1, file2)) {
1151 pstrcpy(filename, max_size, stream->filename);
1166 /* parse http request and prepare header */
1167 static int http_parse_request(HTTPContext *c)
1171 enum RedirType redir_type;
1173 char info[1024], *filename;
1177 const char *mime_type;
1181 char *useragent = 0;
1184 get_word(cmd, sizeof(cmd), (const char **)&p);
1185 pstrcpy(c->method, sizeof(c->method), cmd);
1187 if (!strcmp(cmd, "GET"))
1189 else if (!strcmp(cmd, "POST"))
1194 get_word(url, sizeof(url), (const char **)&p);
1195 pstrcpy(c->url, sizeof(c->url), url);
1197 get_word(protocol, sizeof(protocol), (const char **)&p);
1198 if (strcmp(protocol, "HTTP/1.0") && strcmp(protocol, "HTTP/1.1"))
1201 pstrcpy(c->protocol, sizeof(c->protocol), protocol);
1203 /* find the filename and the optional info string in the request */
1210 pstrcpy(info, sizeof(info), p);
1216 for (p = c->buffer; *p && *p != '\r' && *p != '\n'; ) {
1217 if (strncasecmp(p, "User-Agent:", 11) == 0) {
1219 if (*useragent && *useragent != '\n' && isspace(*useragent))
1223 p = strchr(p, '\n');
1230 redir_type = REDIR_NONE;
1231 if (match_ext(filename, "asx")) {
1232 redir_type = REDIR_ASX;
1233 filename[strlen(filename)-1] = 'f';
1234 } else if (match_ext(filename, "asf") &&
1235 (!useragent || strncasecmp(useragent, "NSPlayer", 8) != 0)) {
1236 /* if this isn't WMP or lookalike, return the redirector file */
1237 redir_type = REDIR_ASF;
1238 } else if (match_ext(filename, "rpm,ram")) {
1239 redir_type = REDIR_RAM;
1240 strcpy(filename + strlen(filename)-2, "m");
1241 } else if (match_ext(filename, "rtsp")) {
1242 redir_type = REDIR_RTSP;
1243 compute_real_filename(filename, sizeof(url) - 1);
1244 } else if (match_ext(filename, "sdp")) {
1245 redir_type = REDIR_SDP;
1246 compute_real_filename(filename, sizeof(url) - 1);
1249 stream = first_stream;
1250 while (stream != NULL) {
1251 if (!strcmp(stream->filename, filename) && validate_acl(stream, c))
1253 stream = stream->next;
1255 if (stream == NULL) {
1256 snprintf(msg, sizeof(msg), "File '%s' not found", url);
1261 memcpy(c->feed_streams, stream->feed_streams, sizeof(c->feed_streams));
1262 memset(c->switch_feed_streams, -1, sizeof(c->switch_feed_streams));
1264 if (stream->stream_type == STREAM_TYPE_REDIRECT) {
1265 c->http_error = 301;
1267 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "HTTP/1.0 301 Moved\r\n");
1268 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "Location: %s\r\n", stream->feed_filename);
1269 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "Content-type: text/html\r\n");
1270 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "\r\n");
1271 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "<html><head><title>Moved</title></head><body>\r\n");
1272 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "You should be <a href=\"%s\">redirected</a>.\r\n", stream->feed_filename);
1273 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "</body></html>\r\n");
1275 /* prepare output buffer */
1276 c->buffer_ptr = c->buffer;
1278 c->state = HTTPSTATE_SEND_HEADER;
1282 /* If this is WMP, get the rate information */
1283 if (extract_rates(ratebuf, sizeof(ratebuf), c->buffer)) {
1284 if (modify_current_stream(c, ratebuf)) {
1285 for (i = 0; i < sizeof(c->feed_streams) / sizeof(c->feed_streams[0]); i++) {
1286 if (c->switch_feed_streams[i] >= 0)
1287 do_switch_stream(c, i);
1292 if (post == 0 && stream->stream_type == STREAM_TYPE_LIVE) {
1293 current_bandwidth += stream->bandwidth;
1296 if (post == 0 && max_bandwidth < current_bandwidth) {
1297 c->http_error = 200;
1299 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "HTTP/1.0 200 Server too busy\r\n");
1300 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "Content-type: text/html\r\n");
1301 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "\r\n");
1302 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "<html><head><title>Too busy</title></head><body>\r\n");
1303 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "The server is too busy to serve your request at this time.<p>\r\n");
1304 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "The bandwidth being served (including your stream) is %dkbit/sec, and this exceeds the limit of %dkbit/sec\r\n",
1305 current_bandwidth, max_bandwidth);
1306 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "</body></html>\r\n");
1308 /* prepare output buffer */
1309 c->buffer_ptr = c->buffer;
1311 c->state = HTTPSTATE_SEND_HEADER;
1315 if (redir_type != REDIR_NONE) {
1318 for (p = c->buffer; *p && *p != '\r' && *p != '\n'; ) {
1319 if (strncasecmp(p, "Host:", 5) == 0) {
1323 p = strchr(p, '\n');
1334 while (isspace(*hostinfo))
1337 eoh = strchr(hostinfo, '\n');
1339 if (eoh[-1] == '\r')
1342 if (eoh - hostinfo < sizeof(hostbuf) - 1) {
1343 memcpy(hostbuf, hostinfo, eoh - hostinfo);
1344 hostbuf[eoh - hostinfo] = 0;
1346 c->http_error = 200;
1348 switch(redir_type) {
1350 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "HTTP/1.0 200 ASX Follows\r\n");
1351 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "Content-type: video/x-ms-asf\r\n");
1352 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "\r\n");
1353 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "<ASX Version=\"3\">\r\n");
1354 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "<!-- Autogenerated by ffserver -->\r\n");
1355 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "<ENTRY><REF HREF=\"http://%s/%s%s\"/></ENTRY>\r\n",
1356 hostbuf, filename, info);
1357 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "</ASX>\r\n");
1360 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "HTTP/1.0 200 RAM Follows\r\n");
1361 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "Content-type: audio/x-pn-realaudio\r\n");
1362 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "\r\n");
1363 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "# Autogenerated by ffserver\r\n");
1364 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "http://%s/%s%s\r\n",
1365 hostbuf, filename, info);
1368 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "HTTP/1.0 200 ASF Redirect follows\r\n");
1369 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "Content-type: video/x-ms-asf\r\n");
1370 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "\r\n");
1371 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "[Reference]\r\n");
1372 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "Ref1=http://%s/%s%s\r\n",
1373 hostbuf, filename, info);
1377 char hostname[256], *p;
1378 /* extract only hostname */
1379 pstrcpy(hostname, sizeof(hostname), hostbuf);
1380 p = strrchr(hostname, ':');
1383 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "HTTP/1.0 200 RTSP Redirect follows\r\n");
1384 /* XXX: incorrect mime type ? */
1385 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "Content-type: application/x-rtsp\r\n");
1386 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "\r\n");
1387 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "rtsp://%s:%d/%s\r\n",
1388 hostname, ntohs(my_rtsp_addr.sin_port),
1395 int sdp_data_size, len;
1396 struct sockaddr_in my_addr;
1398 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "HTTP/1.0 200 OK\r\n");
1399 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "Content-type: application/sdp\r\n");
1400 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "\r\n");
1402 len = sizeof(my_addr);
1403 getsockname(c->fd, (struct sockaddr *)&my_addr, &len);
1405 /* XXX: should use a dynamic buffer */
1406 sdp_data_size = prepare_sdp_description(stream,
1409 if (sdp_data_size > 0) {
1410 memcpy(q, sdp_data, sdp_data_size);
1422 /* prepare output buffer */
1423 c->buffer_ptr = c->buffer;
1425 c->state = HTTPSTATE_SEND_HEADER;
1431 snprintf(msg, sizeof(msg), "ASX/RAM file not handled");
1435 stream->conns_served++;
1437 /* XXX: add there authenticate and IP match */
1440 /* if post, it means a feed is being sent */
1441 if (!stream->is_feed) {
1442 /* However it might be a status report from WMP! Lets log the data
1443 * as it might come in handy one day
1448 for (p = c->buffer; *p && *p != '\r' && *p != '\n'; ) {
1449 if (strncasecmp(p, "Pragma: log-line=", 17) == 0) {
1453 if (strncasecmp(p, "Pragma: client-id=", 18) == 0) {
1454 client_id = strtol(p + 18, 0, 10);
1456 p = strchr(p, '\n');
1464 char *eol = strchr(logline, '\n');
1469 if (eol[-1] == '\r')
1471 http_log("%.*s\n", eol - logline, logline);
1472 c->suppress_log = 1;
1477 http_log("\nGot request:\n%s\n", c->buffer);
1480 if (client_id && extract_rates(ratebuf, sizeof(ratebuf), c->buffer)) {
1483 /* Now we have to find the client_id */
1484 for (wmpc = first_http_ctx; wmpc; wmpc = wmpc->next) {
1485 if (wmpc->wmp_client_id == client_id)
1490 if (modify_current_stream(wmpc, ratebuf)) {
1491 wmpc->switch_pending = 1;
1496 snprintf(msg, sizeof(msg), "POST command not handled");
1500 if (http_start_receive_data(c) < 0) {
1501 snprintf(msg, sizeof(msg), "could not open feed");
1505 c->state = HTTPSTATE_RECEIVE_DATA;
1510 if (strcmp(stream->filename + strlen(stream->filename) - 4, ".asf") == 0) {
1511 http_log("\nGot request:\n%s\n", c->buffer);
1515 if (c->stream->stream_type == STREAM_TYPE_STATUS)
1518 /* open input stream */
1519 if (open_input_stream(c, info) < 0) {
1520 snprintf(msg, sizeof(msg), "Input stream corresponding to '%s' not found", url);
1524 /* prepare http header */
1526 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "HTTP/1.0 200 OK\r\n");
1527 mime_type = c->stream->fmt->mime_type;
1529 mime_type = "application/x-octet_stream";
1530 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "Pragma: no-cache\r\n");
1532 /* for asf, we need extra headers */
1533 if (!strcmp(c->stream->fmt->name,"asf_stream")) {
1534 /* Need to allocate a client id */
1536 c->wmp_client_id = random() & 0x7fffffff;
1538 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);
1540 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "Content-Type: %s\r\n", mime_type);
1541 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "\r\n");
1543 /* prepare output buffer */
1545 c->buffer_ptr = c->buffer;
1547 c->state = HTTPSTATE_SEND_HEADER;
1550 c->http_error = 404;
1552 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "HTTP/1.0 404 Not Found\r\n");
1553 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "Content-type: %s\r\n", "text/html");
1554 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "\r\n");
1555 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "<HTML>\n");
1556 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "<HEAD><TITLE>404 Not Found</TITLE></HEAD>\n");
1557 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "<BODY>%s</BODY>\n", msg);
1558 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "</HTML>\n");
1560 /* prepare output buffer */
1561 c->buffer_ptr = c->buffer;
1563 c->state = HTTPSTATE_SEND_HEADER;
1567 c->http_error = 200; /* horrible : we use this value to avoid
1568 going to the send data state */
1569 c->state = HTTPSTATE_SEND_HEADER;
1573 static void fmt_bytecount(ByteIOContext *pb, int64_t count)
1575 static const char *suffix = " kMGTP";
1578 for (s = suffix; count >= 100000 && s[1]; count /= 1000, s++) {
1581 url_fprintf(pb, "%lld%c", count, *s);
1584 static void compute_stats(HTTPContext *c)
1591 ByteIOContext pb1, *pb = &pb1;
1593 if (url_open_dyn_buf(pb) < 0) {
1594 /* XXX: return an error ? */
1595 c->buffer_ptr = c->buffer;
1596 c->buffer_end = c->buffer;
1600 url_fprintf(pb, "HTTP/1.0 200 OK\r\n");
1601 url_fprintf(pb, "Content-type: %s\r\n", "text/html");
1602 url_fprintf(pb, "Pragma: no-cache\r\n");
1603 url_fprintf(pb, "\r\n");
1605 url_fprintf(pb, "<HEAD><TITLE>FFServer Status</TITLE>\n");
1606 if (c->stream->feed_filename) {
1607 url_fprintf(pb, "<link rel=\"shortcut icon\" href=\"%s\">\n", c->stream->feed_filename);
1609 url_fprintf(pb, "</HEAD>\n<BODY>");
1610 url_fprintf(pb, "<H1>FFServer Status</H1>\n");
1612 url_fprintf(pb, "<H2>Available Streams</H2>\n");
1613 url_fprintf(pb, "<TABLE cellspacing=0 cellpadding=4>\n");
1614 url_fprintf(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");
1615 stream = first_stream;
1616 while (stream != NULL) {
1617 char sfilename[1024];
1620 if (stream->feed != stream) {
1621 pstrcpy(sfilename, sizeof(sfilename) - 10, stream->filename);
1622 eosf = sfilename + strlen(sfilename);
1623 if (eosf - sfilename >= 4) {
1624 if (strcmp(eosf - 4, ".asf") == 0) {
1625 strcpy(eosf - 4, ".asx");
1626 } else if (strcmp(eosf - 3, ".rm") == 0) {
1627 strcpy(eosf - 3, ".ram");
1628 } else if (stream->fmt == &rtp_mux) {
1629 /* generate a sample RTSP director if
1630 unicast. Generate an SDP redirector if
1632 eosf = strrchr(sfilename, '.');
1634 eosf = sfilename + strlen(sfilename);
1635 if (stream->is_multicast)
1636 strcpy(eosf, ".sdp");
1638 strcpy(eosf, ".rtsp");
1642 url_fprintf(pb, "<TR><TD><A HREF=\"/%s\">%s</A> ",
1643 sfilename, stream->filename);
1644 url_fprintf(pb, "<td align=right> %d <td align=right> ",
1645 stream->conns_served);
1646 fmt_bytecount(pb, stream->bytes_served);
1647 switch(stream->stream_type) {
1648 case STREAM_TYPE_LIVE:
1650 int audio_bit_rate = 0;
1651 int video_bit_rate = 0;
1652 const char *audio_codec_name = "";
1653 const char *video_codec_name = "";
1654 const char *audio_codec_name_extra = "";
1655 const char *video_codec_name_extra = "";
1657 for(i=0;i<stream->nb_streams;i++) {
1658 AVStream *st = stream->streams[i];
1659 AVCodec *codec = avcodec_find_encoder(st->codec.codec_id);
1660 switch(st->codec.codec_type) {
1661 case CODEC_TYPE_AUDIO:
1662 audio_bit_rate += st->codec.bit_rate;
1664 if (*audio_codec_name)
1665 audio_codec_name_extra = "...";
1666 audio_codec_name = codec->name;
1669 case CODEC_TYPE_VIDEO:
1670 video_bit_rate += st->codec.bit_rate;
1672 if (*video_codec_name)
1673 video_codec_name_extra = "...";
1674 video_codec_name = codec->name;
1677 case CODEC_TYPE_DATA:
1678 video_bit_rate += st->codec.bit_rate;
1684 url_fprintf(pb, "<TD align=center> %s <TD align=right> %d <TD align=right> %d <TD> %s %s <TD align=right> %d <TD> %s %s",
1687 video_bit_rate / 1000, video_codec_name, video_codec_name_extra,
1688 audio_bit_rate / 1000, audio_codec_name, audio_codec_name_extra);
1690 url_fprintf(pb, "<TD>%s", stream->feed->filename);
1692 url_fprintf(pb, "<TD>%s", stream->feed_filename);
1694 url_fprintf(pb, "\n");
1698 url_fprintf(pb, "<TD align=center> - <TD align=right> - <TD align=right> - <td><td align=right> - <TD>\n");
1702 stream = stream->next;
1704 url_fprintf(pb, "</TABLE>\n");
1706 stream = first_stream;
1707 while (stream != NULL) {
1708 if (stream->feed == stream) {
1709 url_fprintf(pb, "<h2>Feed %s</h2>", stream->filename);
1711 url_fprintf(pb, "Running as pid %d.\n", stream->pid);
1713 #if defined(linux) && !defined(CONFIG_NOCUTILS)
1718 /* This is somewhat linux specific I guess */
1719 snprintf(ps_cmd, sizeof(ps_cmd),
1720 "ps -o \"%%cpu,cputime\" --no-headers %d",
1723 pid_stat = popen(ps_cmd, "r");
1728 if (fscanf(pid_stat, "%10s %64s", cpuperc,
1730 url_fprintf(pb, "Currently using %s%% of the cpu. Total time used %s.\n",
1738 url_fprintf(pb, "<p>");
1740 url_fprintf(pb, "<table cellspacing=0 cellpadding=4><tr><th>Stream<th>type<th>kbits/s<th align=left>codec<th align=left>Parameters\n");
1742 for (i = 0; i < stream->nb_streams; i++) {
1743 AVStream *st = stream->streams[i];
1744 AVCodec *codec = avcodec_find_encoder(st->codec.codec_id);
1745 const char *type = "unknown";
1746 char parameters[64];
1750 switch(st->codec.codec_type) {
1751 case CODEC_TYPE_AUDIO:
1754 case CODEC_TYPE_VIDEO:
1756 snprintf(parameters, sizeof(parameters), "%dx%d, q=%d-%d, fps=%d", st->codec.width, st->codec.height,
1757 st->codec.qmin, st->codec.qmax, st->codec.frame_rate / st->codec.frame_rate_base);
1762 url_fprintf(pb, "<tr><td align=right>%d<td>%s<td align=right>%d<td>%s<td>%s\n",
1763 i, type, st->codec.bit_rate/1000, codec ? codec->name : "", parameters);
1765 url_fprintf(pb, "</table>\n");
1768 stream = stream->next;
1774 AVCodecContext *enc;
1778 stream = first_feed;
1779 while (stream != NULL) {
1780 url_fprintf(pb, "<H1>Feed '%s'</H1>\n", stream->filename);
1781 url_fprintf(pb, "<TABLE>\n");
1782 url_fprintf(pb, "<TR><TD>Parameters<TD>Frame count<TD>Size<TD>Avg bitrate (kbits/s)\n");
1783 for(i=0;i<stream->nb_streams;i++) {
1784 AVStream *st = stream->streams[i];
1785 FeedData *fdata = st->priv_data;
1788 avcodec_string(buf, sizeof(buf), enc);
1789 avg = fdata->avg_frame_size * (float)enc->rate * 8.0;
1790 if (enc->codec->type == CODEC_TYPE_AUDIO && enc->frame_size > 0)
1791 avg /= enc->frame_size;
1792 url_fprintf(pb, "<TR><TD>%s <TD> %d <TD> %Ld <TD> %0.1f\n",
1793 buf, enc->frame_number, fdata->data_count, avg / 1000.0);
1795 url_fprintf(pb, "</TABLE>\n");
1796 stream = stream->next_feed;
1801 /* connection status */
1802 url_fprintf(pb, "<H2>Connection Status</H2>\n");
1804 url_fprintf(pb, "Number of connections: %d / %d<BR>\n",
1805 nb_connections, nb_max_connections);
1807 url_fprintf(pb, "Bandwidth in use: %dk / %dk<BR>\n",
1808 current_bandwidth, max_bandwidth);
1810 url_fprintf(pb, "<TABLE>\n");
1811 url_fprintf(pb, "<TR><th>#<th>File<th>IP<th>Proto<th>State<th>Target bits/sec<th>Actual bits/sec<th>Bytes transferred\n");
1812 c1 = first_http_ctx;
1814 while (c1 != NULL) {
1820 for (j = 0; j < c1->stream->nb_streams; j++) {
1821 if (!c1->stream->feed) {
1822 bitrate += c1->stream->streams[j]->codec.bit_rate;
1824 if (c1->feed_streams[j] >= 0) {
1825 bitrate += c1->stream->feed->streams[c1->feed_streams[j]]->codec.bit_rate;
1832 p = inet_ntoa(c1->from_addr.sin_addr);
1833 url_fprintf(pb, "<TR><TD><B>%d</B><TD>%s%s<TD>%s<TD>%s<TD>%s<td align=right>",
1835 c1->stream ? c1->stream->filename : "",
1836 c1->state == HTTPSTATE_RECEIVE_DATA ? "(input)" : "",
1839 http_state[c1->state]);
1840 fmt_bytecount(pb, bitrate);
1841 url_fprintf(pb, "<td align=right>");
1842 fmt_bytecount(pb, compute_datarate(&c1->datarate, c1->data_count) * 8);
1843 url_fprintf(pb, "<td align=right>");
1844 fmt_bytecount(pb, c1->data_count);
1845 url_fprintf(pb, "\n");
1848 url_fprintf(pb, "</TABLE>\n");
1853 url_fprintf(pb, "<HR size=1 noshade>Generated at %s", p);
1854 url_fprintf(pb, "</BODY>\n</HTML>\n");
1856 len = url_close_dyn_buf(pb, &c->pb_buffer);
1857 c->buffer_ptr = c->pb_buffer;
1858 c->buffer_end = c->pb_buffer + len;
1861 /* check if the parser needs to be opened for stream i */
1862 static void open_parser(AVFormatContext *s, int i)
1864 AVStream *st = s->streams[i];
1867 if (!st->codec.codec) {
1868 codec = avcodec_find_decoder(st->codec.codec_id);
1869 if (codec && (codec->capabilities & CODEC_CAP_PARSE_ONLY)) {
1870 st->codec.parse_only = 1;
1871 if (avcodec_open(&st->codec, codec) < 0) {
1872 st->codec.parse_only = 0;
1878 static int open_input_stream(HTTPContext *c, const char *info)
1881 char input_filename[1024];
1886 /* find file name */
1887 if (c->stream->feed) {
1888 strcpy(input_filename, c->stream->feed->feed_filename);
1889 buf_size = FFM_PACKET_SIZE;
1890 /* compute position (absolute time) */
1891 if (find_info_tag(buf, sizeof(buf), "date", info)) {
1892 stream_pos = parse_date(buf, 0);
1893 } else if (find_info_tag(buf, sizeof(buf), "buffer", info)) {
1894 int prebuffer = strtol(buf, 0, 10);
1895 stream_pos = av_gettime() - prebuffer * (int64_t)1000000;
1897 stream_pos = av_gettime() - c->stream->prebuffer * (int64_t)1000;
1900 strcpy(input_filename, c->stream->feed_filename);
1902 /* compute position (relative time) */
1903 if (find_info_tag(buf, sizeof(buf), "date", info)) {
1904 stream_pos = parse_date(buf, 1);
1909 if (input_filename[0] == '\0')
1913 { time_t when = stream_pos / 1000000;
1914 http_log("Stream pos = %lld, time=%s", stream_pos, ctime(&when));
1919 if (av_open_input_file(&s, input_filename, c->stream->ifmt,
1920 buf_size, c->stream->ap_in) < 0) {
1921 http_log("%s not found", input_filename);
1926 /* open each parser */
1927 for(i=0;i<s->nb_streams;i++)
1930 /* choose stream as clock source (we favorize video stream if
1931 present) for packet sending */
1932 c->pts_stream_index = 0;
1933 for(i=0;i<c->stream->nb_streams;i++) {
1934 if (c->pts_stream_index == 0 &&
1935 c->stream->streams[i]->codec.codec_type == CODEC_TYPE_VIDEO) {
1936 c->pts_stream_index = i;
1941 if (c->fmt_in->iformat->read_seek) {
1942 c->fmt_in->iformat->read_seek(c->fmt_in, stream_pos);
1945 /* set the start time (needed for maxtime and RTP packet timing) */
1946 c->start_time = cur_time;
1947 c->first_pts = AV_NOPTS_VALUE;
1951 /* return the server clock (in us) */
1952 static int64_t get_server_clock(HTTPContext *c)
1954 /* compute current pts value from system time */
1955 return (int64_t)(cur_time - c->start_time) * 1000LL;
1958 /* return the estimated time at which the current packet must be sent
1960 static int64_t get_packet_send_clock(HTTPContext *c)
1962 int bytes_left, bytes_sent, frame_bytes;
1964 frame_bytes = c->cur_frame_bytes;
1965 if (frame_bytes <= 0) {
1968 bytes_left = c->buffer_end - c->buffer_ptr;
1969 bytes_sent = frame_bytes - bytes_left;
1970 return c->cur_pts + (c->cur_frame_duration * bytes_sent) / frame_bytes;
1975 static int http_prepare_data(HTTPContext *c)
1978 AVFormatContext *ctx;
1980 av_freep(&c->pb_buffer);
1982 case HTTPSTATE_SEND_DATA_HEADER:
1983 memset(&c->fmt_ctx, 0, sizeof(c->fmt_ctx));
1984 pstrcpy(c->fmt_ctx.author, sizeof(c->fmt_ctx.author),
1986 pstrcpy(c->fmt_ctx.comment, sizeof(c->fmt_ctx.comment),
1987 c->stream->comment);
1988 pstrcpy(c->fmt_ctx.copyright, sizeof(c->fmt_ctx.copyright),
1989 c->stream->copyright);
1990 pstrcpy(c->fmt_ctx.title, sizeof(c->fmt_ctx.title),
1993 /* open output stream by using specified codecs */
1994 c->fmt_ctx.oformat = c->stream->fmt;
1995 c->fmt_ctx.nb_streams = c->stream->nb_streams;
1996 for(i=0;i<c->fmt_ctx.nb_streams;i++) {
1998 st = av_mallocz(sizeof(AVStream));
1999 c->fmt_ctx.streams[i] = st;
2000 /* if file or feed, then just take streams from FFStream struct */
2001 if (!c->stream->feed ||
2002 c->stream->feed == c->stream)
2003 memcpy(st, c->stream->streams[i], sizeof(AVStream));
2005 memcpy(st, c->stream->feed->streams[c->stream->feed_streams[i]],
2007 st->codec.frame_number = 0; /* XXX: should be done in
2008 AVStream, not in codec */
2009 /* I'm pretty sure that this is not correct...
2010 * However, without it, we crash
2012 st->codec.coded_frame = &dummy_frame;
2014 c->got_key_frame = 0;
2016 /* prepare header and save header data in a stream */
2017 if (url_open_dyn_buf(&c->fmt_ctx.pb) < 0) {
2018 /* XXX: potential leak */
2021 c->fmt_ctx.pb.is_streamed = 1;
2023 av_set_parameters(&c->fmt_ctx, NULL);
2024 av_write_header(&c->fmt_ctx);
2026 len = url_close_dyn_buf(&c->fmt_ctx.pb, &c->pb_buffer);
2027 c->buffer_ptr = c->pb_buffer;
2028 c->buffer_end = c->pb_buffer + len;
2030 c->state = HTTPSTATE_SEND_DATA;
2031 c->last_packet_sent = 0;
2033 case HTTPSTATE_SEND_DATA:
2034 /* find a new packet */
2038 /* read a packet from the input stream */
2039 if (c->stream->feed) {
2040 ffm_set_write_index(c->fmt_in,
2041 c->stream->feed->feed_write_index,
2042 c->stream->feed->feed_size);
2045 if (c->stream->max_time &&
2046 c->stream->max_time + c->start_time - cur_time < 0) {
2047 /* We have timed out */
2048 c->state = HTTPSTATE_SEND_DATA_TRAILER;
2051 if (av_read_frame(c->fmt_in, &pkt) < 0) {
2052 if (c->stream->feed && c->stream->feed->feed_opened) {
2053 /* if coming from feed, it means we reached the end of the
2054 ffm file, so must wait for more data */
2055 c->state = HTTPSTATE_WAIT_FEED;
2056 return 1; /* state changed */
2058 if (c->stream->loop) {
2059 av_close_input_file(c->fmt_in);
2061 if (open_input_stream(c, "") < 0)
2066 /* must send trailer now because eof or error */
2067 c->state = HTTPSTATE_SEND_DATA_TRAILER;
2071 /* update first pts if needed */
2072 if (c->first_pts == AV_NOPTS_VALUE) {
2073 c->first_pts = pkt.dts;
2074 c->start_time = cur_time;
2076 /* send it to the appropriate stream */
2077 if (c->stream->feed) {
2078 /* if coming from a feed, select the right stream */
2079 if (c->switch_pending) {
2080 c->switch_pending = 0;
2081 for(i=0;i<c->stream->nb_streams;i++) {
2082 if (c->switch_feed_streams[i] == pkt.stream_index) {
2083 if (pkt.flags & PKT_FLAG_KEY) {
2084 do_switch_stream(c, i);
2087 if (c->switch_feed_streams[i] >= 0) {
2088 c->switch_pending = 1;
2092 for(i=0;i<c->stream->nb_streams;i++) {
2093 if (c->feed_streams[i] == pkt.stream_index) {
2094 pkt.stream_index = i;
2095 if (pkt.flags & PKT_FLAG_KEY) {
2096 c->got_key_frame |= 1 << i;
2098 /* See if we have all the key frames, then
2099 * we start to send. This logic is not quite
2100 * right, but it works for the case of a
2101 * single video stream with one or more
2102 * audio streams (for which every frame is
2103 * typically a key frame).
2105 if (!c->stream->send_on_key ||
2106 ((c->got_key_frame + 1) >> c->stream->nb_streams)) {
2112 AVCodecContext *codec;
2115 /* specific handling for RTP: we use several
2116 output stream (one for each RTP
2117 connection). XXX: need more abstract handling */
2118 if (c->is_packetized) {
2120 /* compute send time and duration */
2121 st = c->fmt_in->streams[pkt.stream_index];
2122 c->cur_pts = pkt.dts;
2123 if (st->start_time != AV_NOPTS_VALUE)
2124 c->cur_pts -= st->start_time;
2125 c->cur_frame_duration = pkt.duration;
2127 printf("index=%d pts=%0.3f duration=%0.6f\n",
2129 (double)c->cur_pts /
2131 (double)c->cur_frame_duration /
2134 /* find RTP context */
2135 c->packet_stream_index = pkt.stream_index;
2136 ctx = c->rtp_ctx[c->packet_stream_index];
2138 av_free_packet(&pkt);
2141 codec = &ctx->streams[0]->codec;
2142 /* only one stream per RTP connection */
2143 pkt.stream_index = 0;
2147 codec = &ctx->streams[pkt.stream_index]->codec;
2150 codec->coded_frame->key_frame = ((pkt.flags & PKT_FLAG_KEY) != 0);
2151 if (c->is_packetized) {
2152 int max_packet_size;
2153 if (c->rtp_protocol == RTSP_PROTOCOL_RTP_TCP)
2154 max_packet_size = RTSP_TCP_MAX_PACKET_SIZE;
2156 max_packet_size = url_get_max_packet_size(c->rtp_handles[c->packet_stream_index]);
2157 ret = url_open_dyn_packet_buf(&ctx->pb, max_packet_size);
2159 ret = url_open_dyn_buf(&ctx->pb);
2162 /* XXX: potential leak */
2165 if (av_write_frame(ctx, pkt.stream_index, pkt.data, pkt.size)) {
2166 c->state = HTTPSTATE_SEND_DATA_TRAILER;
2169 len = url_close_dyn_buf(&ctx->pb, &c->pb_buffer);
2170 c->cur_frame_bytes = len;
2171 c->buffer_ptr = c->pb_buffer;
2172 c->buffer_end = c->pb_buffer + len;
2174 codec->frame_number++;
2178 av_free_packet(&pkt);
2184 case HTTPSTATE_SEND_DATA_TRAILER:
2185 /* last packet test ? */
2186 if (c->last_packet_sent || c->is_packetized)
2189 /* prepare header */
2190 if (url_open_dyn_buf(&ctx->pb) < 0) {
2191 /* XXX: potential leak */
2194 av_write_trailer(ctx);
2195 len = url_close_dyn_buf(&ctx->pb, &c->pb_buffer);
2196 c->buffer_ptr = c->pb_buffer;
2197 c->buffer_end = c->pb_buffer + len;
2199 c->last_packet_sent = 1;
2206 #define SHORT_TERM_BANDWIDTH 8000000
2208 /* should convert the format at the same time */
2209 /* send data starting at c->buffer_ptr to the output connection
2210 (either UDP or TCP connection) */
2211 static int http_send_data(HTTPContext *c)
2216 if (c->buffer_ptr >= c->buffer_end) {
2217 ret = http_prepare_data(c);
2220 else if (ret != 0) {
2221 /* state change requested */
2225 if (c->is_packetized) {
2226 /* RTP data output */
2227 len = c->buffer_end - c->buffer_ptr;
2229 /* fail safe - should never happen */
2231 c->buffer_ptr = c->buffer_end;
2234 len = (c->buffer_ptr[0] << 24) |
2235 (c->buffer_ptr[1] << 16) |
2236 (c->buffer_ptr[2] << 8) |
2238 if (len > (c->buffer_end - c->buffer_ptr))
2240 if ((get_packet_send_clock(c) - get_server_clock(c)) > 0) {
2241 /* nothing to send yet: we can wait */
2245 c->data_count += len;
2246 update_datarate(&c->datarate, c->data_count);
2248 c->stream->bytes_served += len;
2250 if (c->rtp_protocol == RTSP_PROTOCOL_RTP_TCP) {
2251 /* RTP packets are sent inside the RTSP TCP connection */
2252 ByteIOContext pb1, *pb = &pb1;
2253 int interleaved_index, size;
2255 HTTPContext *rtsp_c;
2258 /* if no RTSP connection left, error */
2261 /* if already sending something, then wait. */
2262 if (rtsp_c->state != RTSPSTATE_WAIT_REQUEST) {
2265 if (url_open_dyn_buf(pb) < 0)
2267 interleaved_index = c->packet_stream_index * 2;
2268 /* RTCP packets are sent at odd indexes */
2269 if (c->buffer_ptr[1] == 200)
2270 interleaved_index++;
2271 /* write RTSP TCP header */
2273 header[1] = interleaved_index;
2274 header[2] = len >> 8;
2276 put_buffer(pb, header, 4);
2277 /* write RTP packet data */
2279 put_buffer(pb, c->buffer_ptr, len);
2280 size = url_close_dyn_buf(pb, &c->packet_buffer);
2281 /* prepare asynchronous TCP sending */
2282 rtsp_c->packet_buffer_ptr = c->packet_buffer;
2283 rtsp_c->packet_buffer_end = c->packet_buffer + size;
2284 c->buffer_ptr += len;
2286 /* send everything we can NOW */
2287 len = write(rtsp_c->fd, rtsp_c->packet_buffer_ptr,
2288 rtsp_c->packet_buffer_end - rtsp_c->packet_buffer_ptr);
2290 rtsp_c->packet_buffer_ptr += len;
2292 if (rtsp_c->packet_buffer_ptr < rtsp_c->packet_buffer_end) {
2293 /* if we could not send all the data, we will
2294 send it later, so a new state is needed to
2295 "lock" the RTSP TCP connection */
2296 rtsp_c->state = RTSPSTATE_SEND_PACKET;
2299 /* all data has been sent */
2300 av_freep(&c->packet_buffer);
2303 /* send RTP packet directly in UDP */
2305 url_write(c->rtp_handles[c->packet_stream_index],
2306 c->buffer_ptr, len);
2307 c->buffer_ptr += len;
2308 /* here we continue as we can send several packets per 10 ms slot */
2311 /* TCP data output */
2312 len = write(c->fd, c->buffer_ptr, c->buffer_end - c->buffer_ptr);
2314 if (errno != EAGAIN && errno != EINTR) {
2315 /* error : close connection */
2321 c->buffer_ptr += len;
2323 c->data_count += len;
2324 update_datarate(&c->datarate, c->data_count);
2326 c->stream->bytes_served += len;
2334 static int http_start_receive_data(HTTPContext *c)
2338 if (c->stream->feed_opened)
2341 /* Don't permit writing to this one */
2342 if (c->stream->readonly)
2346 fd = open(c->stream->feed_filename, O_RDWR);
2351 c->stream->feed_write_index = ffm_read_write_index(fd);
2352 c->stream->feed_size = lseek(fd, 0, SEEK_END);
2353 lseek(fd, 0, SEEK_SET);
2355 /* init buffer input */
2356 c->buffer_ptr = c->buffer;
2357 c->buffer_end = c->buffer + FFM_PACKET_SIZE;
2358 c->stream->feed_opened = 1;
2362 static int http_receive_data(HTTPContext *c)
2366 if (c->buffer_end > c->buffer_ptr) {
2369 len = read(c->fd, c->buffer_ptr, c->buffer_end - c->buffer_ptr);
2371 if (errno != EAGAIN && errno != EINTR) {
2372 /* error : close connection */
2375 } else if (len == 0) {
2376 /* end of connection : close it */
2379 c->buffer_ptr += len;
2380 c->data_count += len;
2381 update_datarate(&c->datarate, c->data_count);
2385 if (c->buffer_ptr - c->buffer >= 2 && c->data_count > FFM_PACKET_SIZE) {
2386 if (c->buffer[0] != 'f' ||
2387 c->buffer[1] != 'm') {
2388 http_log("Feed stream has become desynchronized -- disconnecting\n");
2393 if (c->buffer_ptr >= c->buffer_end) {
2394 FFStream *feed = c->stream;
2395 /* a packet has been received : write it in the store, except
2397 if (c->data_count > FFM_PACKET_SIZE) {
2399 // printf("writing pos=0x%Lx size=0x%Lx\n", feed->feed_write_index, feed->feed_size);
2400 /* XXX: use llseek or url_seek */
2401 lseek(c->feed_fd, feed->feed_write_index, SEEK_SET);
2402 write(c->feed_fd, c->buffer, FFM_PACKET_SIZE);
2404 feed->feed_write_index += FFM_PACKET_SIZE;
2405 /* update file size */
2406 if (feed->feed_write_index > c->stream->feed_size)
2407 feed->feed_size = feed->feed_write_index;
2409 /* handle wrap around if max file size reached */
2410 if (feed->feed_write_index >= c->stream->feed_max_size)
2411 feed->feed_write_index = FFM_PACKET_SIZE;
2414 ffm_write_write_index(c->feed_fd, feed->feed_write_index);
2416 /* wake up any waiting connections */
2417 for(c1 = first_http_ctx; c1 != NULL; c1 = c1->next) {
2418 if (c1->state == HTTPSTATE_WAIT_FEED &&
2419 c1->stream->feed == c->stream->feed) {
2420 c1->state = HTTPSTATE_SEND_DATA;
2424 /* We have a header in our hands that contains useful data */
2426 AVInputFormat *fmt_in;
2427 ByteIOContext *pb = &s.pb;
2430 memset(&s, 0, sizeof(s));
2432 url_open_buf(pb, c->buffer, c->buffer_end - c->buffer, URL_RDONLY);
2433 pb->buf_end = c->buffer_end; /* ?? */
2434 pb->is_streamed = 1;
2436 /* use feed output format name to find corresponding input format */
2437 fmt_in = av_find_input_format(feed->fmt->name);
2441 if (fmt_in->priv_data_size > 0) {
2442 s.priv_data = av_mallocz(fmt_in->priv_data_size);
2448 if (fmt_in->read_header(&s, 0) < 0) {
2449 av_freep(&s.priv_data);
2453 /* Now we have the actual streams */
2454 if (s.nb_streams != feed->nb_streams) {
2455 av_freep(&s.priv_data);
2458 for (i = 0; i < s.nb_streams; i++) {
2459 memcpy(&feed->streams[i]->codec,
2460 &s.streams[i]->codec, sizeof(AVCodecContext));
2462 av_freep(&s.priv_data);
2464 c->buffer_ptr = c->buffer;
2469 c->stream->feed_opened = 0;
2474 /********************************************************************/
2477 static void rtsp_reply_header(HTTPContext *c, enum RTSPStatusCode error_number)
2484 switch(error_number) {
2485 #define DEF(n, c, s) case c: str = s; break;
2486 #include "rtspcodes.h"
2489 str = "Unknown Error";
2493 url_fprintf(c->pb, "RTSP/1.0 %d %s\r\n", error_number, str);
2494 url_fprintf(c->pb, "CSeq: %d\r\n", c->seq);
2496 /* output GMT time */
2500 p = buf2 + strlen(p) - 1;
2503 url_fprintf(c->pb, "Date: %s GMT\r\n", buf2);
2506 static void rtsp_reply_error(HTTPContext *c, enum RTSPStatusCode error_number)
2508 rtsp_reply_header(c, error_number);
2509 url_fprintf(c->pb, "\r\n");
2512 static int rtsp_parse_request(HTTPContext *c)
2514 const char *p, *p1, *p2;
2521 RTSPHeader header1, *header = &header1;
2523 c->buffer_ptr[0] = '\0';
2526 get_word(cmd, sizeof(cmd), &p);
2527 get_word(url, sizeof(url), &p);
2528 get_word(protocol, sizeof(protocol), &p);
2530 pstrcpy(c->method, sizeof(c->method), cmd);
2531 pstrcpy(c->url, sizeof(c->url), url);
2532 pstrcpy(c->protocol, sizeof(c->protocol), protocol);
2535 if (url_open_dyn_buf(c->pb) < 0) {
2536 /* XXX: cannot do more */
2537 c->pb = NULL; /* safety */
2541 /* check version name */
2542 if (strcmp(protocol, "RTSP/1.0") != 0) {
2543 rtsp_reply_error(c, RTSP_STATUS_VERSION);
2547 /* parse each header line */
2548 memset(header, 0, sizeof(RTSPHeader));
2549 /* skip to next line */
2550 while (*p != '\n' && *p != '\0')
2554 while (*p != '\0') {
2555 p1 = strchr(p, '\n');
2559 if (p2 > p && p2[-1] == '\r')
2561 /* skip empty line */
2565 if (len > sizeof(line) - 1)
2566 len = sizeof(line) - 1;
2567 memcpy(line, p, len);
2569 rtsp_parse_line(header, line);
2573 /* handle sequence number */
2574 c->seq = header->seq;
2576 if (!strcmp(cmd, "DESCRIBE")) {
2577 rtsp_cmd_describe(c, url);
2578 } else if (!strcmp(cmd, "OPTIONS")) {
2579 rtsp_cmd_options(c, url);
2580 } else if (!strcmp(cmd, "SETUP")) {
2581 rtsp_cmd_setup(c, url, header);
2582 } else if (!strcmp(cmd, "PLAY")) {
2583 rtsp_cmd_play(c, url, header);
2584 } else if (!strcmp(cmd, "PAUSE")) {
2585 rtsp_cmd_pause(c, url, header);
2586 } else if (!strcmp(cmd, "TEARDOWN")) {
2587 rtsp_cmd_teardown(c, url, header);
2589 rtsp_reply_error(c, RTSP_STATUS_METHOD);
2592 len = url_close_dyn_buf(c->pb, &c->pb_buffer);
2593 c->pb = NULL; /* safety */
2595 /* XXX: cannot do more */
2598 c->buffer_ptr = c->pb_buffer;
2599 c->buffer_end = c->pb_buffer + len;
2600 c->state = RTSPSTATE_SEND_REPLY;
2604 /* XXX: move that to rtsp.c, but would need to replace FFStream by
2606 static int prepare_sdp_description(FFStream *stream, uint8_t **pbuffer,
2607 struct in_addr my_ip)
2609 ByteIOContext pb1, *pb = &pb1;
2610 int i, payload_type, port, private_payload_type, j;
2611 const char *ipstr, *title, *mediatype;
2614 if (url_open_dyn_buf(pb) < 0)
2617 /* general media info */
2619 url_fprintf(pb, "v=0\n");
2620 ipstr = inet_ntoa(my_ip);
2621 url_fprintf(pb, "o=- 0 0 IN IP4 %s\n", ipstr);
2622 title = stream->title;
2623 if (title[0] == '\0')
2625 url_fprintf(pb, "s=%s\n", title);
2626 if (stream->comment[0] != '\0')
2627 url_fprintf(pb, "i=%s\n", stream->comment);
2628 if (stream->is_multicast) {
2629 url_fprintf(pb, "c=IN IP4 %s\n", inet_ntoa(stream->multicast_ip));
2631 /* for each stream, we output the necessary info */
2632 private_payload_type = RTP_PT_PRIVATE;
2633 for(i = 0; i < stream->nb_streams; i++) {
2634 st = stream->streams[i];
2635 if (st->codec.codec_id == CODEC_ID_MPEG2TS) {
2636 mediatype = "video";
2638 switch(st->codec.codec_type) {
2639 case CODEC_TYPE_AUDIO:
2640 mediatype = "audio";
2642 case CODEC_TYPE_VIDEO:
2643 mediatype = "video";
2646 mediatype = "application";
2650 /* NOTE: the port indication is not correct in case of
2651 unicast. It is not an issue because RTSP gives it */
2652 payload_type = rtp_get_payload_type(&st->codec);
2653 if (payload_type < 0)
2654 payload_type = private_payload_type++;
2655 if (stream->is_multicast) {
2656 port = stream->multicast_port + 2 * i;
2660 url_fprintf(pb, "m=%s %d RTP/AVP %d\n",
2661 mediatype, port, payload_type);
2662 if (payload_type >= RTP_PT_PRIVATE) {
2663 /* for private payload type, we need to give more info */
2664 switch(st->codec.codec_id) {
2665 case CODEC_ID_MPEG4:
2668 url_fprintf(pb, "a=rtpmap:%d MP4V-ES/%d\n",
2669 payload_type, 90000);
2670 /* we must also add the mpeg4 header */
2671 data = st->codec.extradata;
2673 url_fprintf(pb, "a=fmtp:%d config=", payload_type);
2674 for(j=0;j<st->codec.extradata_size;j++) {
2675 url_fprintf(pb, "%02x", data[j]);
2677 url_fprintf(pb, "\n");
2682 /* XXX: add other codecs ? */
2686 url_fprintf(pb, "a=control:streamid=%d\n", i);
2688 return url_close_dyn_buf(pb, pbuffer);
2690 url_close_dyn_buf(pb, pbuffer);
2695 static void rtsp_cmd_options(HTTPContext *c, const char *url)
2697 // rtsp_reply_header(c, RTSP_STATUS_OK);
2698 url_fprintf(c->pb, "RTSP/1.0 %d %s\r\n", RTSP_STATUS_OK, "OK");
2699 url_fprintf(c->pb, "CSeq: %d\r\n", c->seq);
2700 url_fprintf(c->pb, "Public: %s\r\n", "OPTIONS, DESCRIBE, SETUP, TEARDOWN, PLAY, PAUSE");
2701 url_fprintf(c->pb, "\r\n");
2704 static void rtsp_cmd_describe(HTTPContext *c, const char *url)
2710 int content_length, len;
2711 struct sockaddr_in my_addr;
2713 /* find which url is asked */
2714 url_split(NULL, 0, NULL, 0, NULL, path1, sizeof(path1), url);
2719 for(stream = first_stream; stream != NULL; stream = stream->next) {
2720 if (!stream->is_feed && stream->fmt == &rtp_mux &&
2721 !strcmp(path, stream->filename)) {
2725 /* no stream found */
2726 rtsp_reply_error(c, RTSP_STATUS_SERVICE); /* XXX: right error ? */
2730 /* prepare the media description in sdp format */
2732 /* get the host IP */
2733 len = sizeof(my_addr);
2734 getsockname(c->fd, (struct sockaddr *)&my_addr, &len);
2735 content_length = prepare_sdp_description(stream, &content, my_addr.sin_addr);
2736 if (content_length < 0) {
2737 rtsp_reply_error(c, RTSP_STATUS_INTERNAL);
2740 rtsp_reply_header(c, RTSP_STATUS_OK);
2741 url_fprintf(c->pb, "Content-Type: application/sdp\r\n");
2742 url_fprintf(c->pb, "Content-Length: %d\r\n", content_length);
2743 url_fprintf(c->pb, "\r\n");
2744 put_buffer(c->pb, content, content_length);
2747 static HTTPContext *find_rtp_session(const char *session_id)
2751 if (session_id[0] == '\0')
2754 for(c = first_http_ctx; c != NULL; c = c->next) {
2755 if (!strcmp(c->session_id, session_id))
2761 static RTSPTransportField *find_transport(RTSPHeader *h, enum RTSPProtocol protocol)
2763 RTSPTransportField *th;
2766 for(i=0;i<h->nb_transports;i++) {
2767 th = &h->transports[i];
2768 if (th->protocol == protocol)
2774 static void rtsp_cmd_setup(HTTPContext *c, const char *url,
2778 int stream_index, port;
2783 RTSPTransportField *th;
2784 struct sockaddr_in dest_addr;
2785 RTSPActionServerSetup setup;
2787 /* find which url is asked */
2788 url_split(NULL, 0, NULL, 0, NULL, path1, sizeof(path1), url);
2793 /* now check each stream */
2794 for(stream = first_stream; stream != NULL; stream = stream->next) {
2795 if (!stream->is_feed && stream->fmt == &rtp_mux) {
2796 /* accept aggregate filenames only if single stream */
2797 if (!strcmp(path, stream->filename)) {
2798 if (stream->nb_streams != 1) {
2799 rtsp_reply_error(c, RTSP_STATUS_AGGREGATE);
2806 for(stream_index = 0; stream_index < stream->nb_streams;
2808 snprintf(buf, sizeof(buf), "%s/streamid=%d",
2809 stream->filename, stream_index);
2810 if (!strcmp(path, buf))
2815 /* no stream found */
2816 rtsp_reply_error(c, RTSP_STATUS_SERVICE); /* XXX: right error ? */
2820 /* generate session id if needed */
2821 if (h->session_id[0] == '\0') {
2822 snprintf(h->session_id, sizeof(h->session_id),
2823 "%08x%08x", (int)random(), (int)random());
2826 /* find rtp session, and create it if none found */
2827 rtp_c = find_rtp_session(h->session_id);
2829 /* always prefer UDP */
2830 th = find_transport(h, RTSP_PROTOCOL_RTP_UDP);
2832 th = find_transport(h, RTSP_PROTOCOL_RTP_TCP);
2834 rtsp_reply_error(c, RTSP_STATUS_TRANSPORT);
2839 rtp_c = rtp_new_connection(&c->from_addr, stream, h->session_id,
2842 rtsp_reply_error(c, RTSP_STATUS_BANDWIDTH);
2846 /* open input stream */
2847 if (open_input_stream(rtp_c, "") < 0) {
2848 rtsp_reply_error(c, RTSP_STATUS_INTERNAL);
2853 /* test if stream is OK (test needed because several SETUP needs
2854 to be done for a given file) */
2855 if (rtp_c->stream != stream) {
2856 rtsp_reply_error(c, RTSP_STATUS_SERVICE);
2860 /* test if stream is already set up */
2861 if (rtp_c->rtp_ctx[stream_index]) {
2862 rtsp_reply_error(c, RTSP_STATUS_STATE);
2866 /* check transport */
2867 th = find_transport(h, rtp_c->rtp_protocol);
2868 if (!th || (th->protocol == RTSP_PROTOCOL_RTP_UDP &&
2869 th->client_port_min <= 0)) {
2870 rtsp_reply_error(c, RTSP_STATUS_TRANSPORT);
2874 /* setup default options */
2875 setup.transport_option[0] = '\0';
2876 dest_addr = rtp_c->from_addr;
2877 dest_addr.sin_port = htons(th->client_port_min);
2879 /* add transport option if needed */
2880 if (ff_rtsp_callback) {
2881 setup.ipaddr = ntohl(dest_addr.sin_addr.s_addr);
2882 if (ff_rtsp_callback(RTSP_ACTION_SERVER_SETUP, rtp_c->session_id,
2883 (char *)&setup, sizeof(setup),
2884 stream->rtsp_option) < 0) {
2885 rtsp_reply_error(c, RTSP_STATUS_TRANSPORT);
2888 dest_addr.sin_addr.s_addr = htonl(setup.ipaddr);
2892 if (rtp_new_av_stream(rtp_c, stream_index, &dest_addr, c) < 0) {
2893 rtsp_reply_error(c, RTSP_STATUS_TRANSPORT);
2897 /* now everything is OK, so we can send the connection parameters */
2898 rtsp_reply_header(c, RTSP_STATUS_OK);
2900 url_fprintf(c->pb, "Session: %s\r\n", rtp_c->session_id);
2902 switch(rtp_c->rtp_protocol) {
2903 case RTSP_PROTOCOL_RTP_UDP:
2904 port = rtp_get_local_port(rtp_c->rtp_handles[stream_index]);
2905 url_fprintf(c->pb, "Transport: RTP/AVP/UDP;unicast;"
2906 "client_port=%d-%d;server_port=%d-%d",
2907 th->client_port_min, th->client_port_min + 1,
2910 case RTSP_PROTOCOL_RTP_TCP:
2911 url_fprintf(c->pb, "Transport: RTP/AVP/TCP;interleaved=%d-%d",
2912 stream_index * 2, stream_index * 2 + 1);
2917 if (setup.transport_option[0] != '\0') {
2918 url_fprintf(c->pb, ";%s", setup.transport_option);
2920 url_fprintf(c->pb, "\r\n");
2923 url_fprintf(c->pb, "\r\n");
2927 /* find an rtp connection by using the session ID. Check consistency
2929 static HTTPContext *find_rtp_session_with_url(const char *url,
2930 const char *session_id)
2938 rtp_c = find_rtp_session(session_id);
2942 /* find which url is asked */
2943 url_split(NULL, 0, NULL, 0, NULL, path1, sizeof(path1), url);
2947 if(!strcmp(path, rtp_c->stream->filename)) return rtp_c;
2948 for(s=0; s<rtp_c->stream->nb_streams; ++s) {
2949 snprintf(buf, sizeof(buf), "%s/streamid=%d",
2950 rtp_c->stream->filename, s);
2951 if(!strncmp(path, buf, sizeof(buf))) {
2952 // XXX: Should we reply with RTSP_STATUS_ONLY_AGGREGATE if nb_streams>1?
2959 static void rtsp_cmd_play(HTTPContext *c, const char *url, RTSPHeader *h)
2963 rtp_c = find_rtp_session_with_url(url, h->session_id);
2965 rtsp_reply_error(c, RTSP_STATUS_SESSION);
2969 if (rtp_c->state != HTTPSTATE_SEND_DATA &&
2970 rtp_c->state != HTTPSTATE_WAIT_FEED &&
2971 rtp_c->state != HTTPSTATE_READY) {
2972 rtsp_reply_error(c, RTSP_STATUS_STATE);
2977 /* XXX: seek in stream */
2978 if (h->range_start != AV_NOPTS_VALUE) {
2979 printf("range_start=%0.3f\n", (double)h->range_start / AV_TIME_BASE);
2980 av_seek_frame(rtp_c->fmt_in, -1, h->range_start);
2984 rtp_c->state = HTTPSTATE_SEND_DATA;
2986 /* now everything is OK, so we can send the connection parameters */
2987 rtsp_reply_header(c, RTSP_STATUS_OK);
2989 url_fprintf(c->pb, "Session: %s\r\n", rtp_c->session_id);
2990 url_fprintf(c->pb, "\r\n");
2993 static void rtsp_cmd_pause(HTTPContext *c, const char *url, RTSPHeader *h)
2997 rtp_c = find_rtp_session_with_url(url, h->session_id);
2999 rtsp_reply_error(c, RTSP_STATUS_SESSION);
3003 if (rtp_c->state != HTTPSTATE_SEND_DATA &&
3004 rtp_c->state != HTTPSTATE_WAIT_FEED) {
3005 rtsp_reply_error(c, RTSP_STATUS_STATE);
3009 rtp_c->state = HTTPSTATE_READY;
3010 rtp_c->first_pts = AV_NOPTS_VALUE;
3011 /* now everything is OK, so we can send the connection parameters */
3012 rtsp_reply_header(c, RTSP_STATUS_OK);
3014 url_fprintf(c->pb, "Session: %s\r\n", rtp_c->session_id);
3015 url_fprintf(c->pb, "\r\n");
3018 static void rtsp_cmd_teardown(HTTPContext *c, const char *url, RTSPHeader *h)
3022 rtp_c = find_rtp_session_with_url(url, h->session_id);
3024 rtsp_reply_error(c, RTSP_STATUS_SESSION);
3028 /* abort the session */
3029 close_connection(rtp_c);
3031 if (ff_rtsp_callback) {
3032 ff_rtsp_callback(RTSP_ACTION_SERVER_TEARDOWN, rtp_c->session_id,
3034 rtp_c->stream->rtsp_option);
3037 /* now everything is OK, so we can send the connection parameters */
3038 rtsp_reply_header(c, RTSP_STATUS_OK);
3040 url_fprintf(c->pb, "Session: %s\r\n", rtp_c->session_id);
3041 url_fprintf(c->pb, "\r\n");
3045 /********************************************************************/
3048 static HTTPContext *rtp_new_connection(struct sockaddr_in *from_addr,
3049 FFStream *stream, const char *session_id,
3050 enum RTSPProtocol rtp_protocol)
3052 HTTPContext *c = NULL;
3053 const char *proto_str;
3055 /* XXX: should output a warning page when coming
3056 close to the connection limit */
3057 if (nb_connections >= nb_max_connections)
3060 /* add a new connection */
3061 c = av_mallocz(sizeof(HTTPContext));
3066 c->poll_entry = NULL;
3067 c->from_addr = *from_addr;
3068 c->buffer_size = IOBUFFER_INIT_SIZE;
3069 c->buffer = av_malloc(c->buffer_size);
3074 pstrcpy(c->session_id, sizeof(c->session_id), session_id);
3075 c->state = HTTPSTATE_READY;
3076 c->is_packetized = 1;
3077 c->rtp_protocol = rtp_protocol;
3079 /* protocol is shown in statistics */
3080 switch(c->rtp_protocol) {
3081 case RTSP_PROTOCOL_RTP_UDP_MULTICAST:
3082 proto_str = "MCAST";
3084 case RTSP_PROTOCOL_RTP_UDP:
3087 case RTSP_PROTOCOL_RTP_TCP:
3094 pstrcpy(c->protocol, sizeof(c->protocol), "RTP/");
3095 pstrcat(c->protocol, sizeof(c->protocol), proto_str);
3097 current_bandwidth += stream->bandwidth;
3099 c->next = first_http_ctx;
3111 /* add a new RTP stream in an RTP connection (used in RTSP SETUP
3112 command). If RTP/TCP protocol is used, TCP connection 'rtsp_c' is
3114 static int rtp_new_av_stream(HTTPContext *c,
3115 int stream_index, struct sockaddr_in *dest_addr,
3116 HTTPContext *rtsp_c)
3118 AVFormatContext *ctx;
3124 int max_packet_size;
3126 /* now we can open the relevant output stream */
3127 ctx = av_mallocz(sizeof(AVFormatContext));
3130 ctx->oformat = &rtp_mux;
3132 st = av_mallocz(sizeof(AVStream));
3135 ctx->nb_streams = 1;
3136 ctx->streams[0] = st;
3138 if (!c->stream->feed ||
3139 c->stream->feed == c->stream) {
3140 memcpy(st, c->stream->streams[stream_index], sizeof(AVStream));
3143 c->stream->feed->streams[c->stream->feed_streams[stream_index]],
3147 /* build destination RTP address */
3148 ipaddr = inet_ntoa(dest_addr->sin_addr);
3150 switch(c->rtp_protocol) {
3151 case RTSP_PROTOCOL_RTP_UDP:
3152 case RTSP_PROTOCOL_RTP_UDP_MULTICAST:
3155 /* XXX: also pass as parameter to function ? */
3156 if (c->stream->is_multicast) {
3158 ttl = c->stream->multicast_ttl;
3161 snprintf(ctx->filename, sizeof(ctx->filename),
3162 "rtp://%s:%d?multicast=1&ttl=%d",
3163 ipaddr, ntohs(dest_addr->sin_port), ttl);
3165 snprintf(ctx->filename, sizeof(ctx->filename),
3166 "rtp://%s:%d", ipaddr, ntohs(dest_addr->sin_port));
3169 if (url_open(&h, ctx->filename, URL_WRONLY) < 0)
3171 c->rtp_handles[stream_index] = h;
3172 max_packet_size = url_get_max_packet_size(h);
3174 case RTSP_PROTOCOL_RTP_TCP:
3177 max_packet_size = RTSP_TCP_MAX_PACKET_SIZE;
3183 http_log("%s:%d - - [%s] \"PLAY %s/streamid=%d %s\"\n",
3184 ipaddr, ntohs(dest_addr->sin_port),
3186 c->stream->filename, stream_index, c->protocol);
3188 /* normally, no packets should be output here, but the packet size may be checked */
3189 if (url_open_dyn_packet_buf(&ctx->pb, max_packet_size) < 0) {
3190 /* XXX: close stream */
3193 av_set_parameters(ctx, NULL);
3194 if (av_write_header(ctx) < 0) {
3201 url_close_dyn_buf(&ctx->pb, &dummy_buf);
3204 c->rtp_ctx[stream_index] = ctx;
3208 /********************************************************************/
3209 /* ffserver initialization */
3211 static AVStream *add_av_stream1(FFStream *stream, AVCodecContext *codec)
3215 fst = av_mallocz(sizeof(AVStream));
3218 fst->priv_data = av_mallocz(sizeof(FeedData));
3219 memcpy(&fst->codec, codec, sizeof(AVCodecContext));
3220 fst->codec.coded_frame = &dummy_frame;
3221 fst->index = stream->nb_streams;
3222 stream->streams[stream->nb_streams++] = fst;
3226 /* return the stream number in the feed */
3227 static int add_av_stream(FFStream *feed, AVStream *st)
3230 AVCodecContext *av, *av1;
3234 for(i=0;i<feed->nb_streams;i++) {
3235 st = feed->streams[i];
3237 if (av1->codec_id == av->codec_id &&
3238 av1->codec_type == av->codec_type &&
3239 av1->bit_rate == av->bit_rate) {
3241 switch(av->codec_type) {
3242 case CODEC_TYPE_AUDIO:
3243 if (av1->channels == av->channels &&
3244 av1->sample_rate == av->sample_rate)
3247 case CODEC_TYPE_VIDEO:
3248 if (av1->width == av->width &&
3249 av1->height == av->height &&
3250 av1->frame_rate == av->frame_rate &&
3251 av1->frame_rate_base == av->frame_rate_base &&
3252 av1->gop_size == av->gop_size)
3261 fst = add_av_stream1(feed, av);
3264 return feed->nb_streams - 1;
3269 static void remove_stream(FFStream *stream)
3273 while (*ps != NULL) {
3274 if (*ps == stream) {
3282 /* specific mpeg4 handling : we extract the raw parameters */
3283 static void extract_mpeg4_header(AVFormatContext *infile)
3285 int mpeg4_count, i, size;
3291 for(i=0;i<infile->nb_streams;i++) {
3292 st = infile->streams[i];
3293 if (st->codec.codec_id == CODEC_ID_MPEG4 &&
3294 st->codec.extradata_size == 0) {
3301 printf("MPEG4 without extra data: trying to find header in %s\n", infile->filename);
3302 while (mpeg4_count > 0) {
3303 if (av_read_packet(infile, &pkt) < 0)
3305 st = infile->streams[pkt.stream_index];
3306 if (st->codec.codec_id == CODEC_ID_MPEG4 &&
3307 st->codec.extradata_size == 0) {
3308 av_freep(&st->codec.extradata);
3309 /* fill extradata with the header */
3310 /* XXX: we make hard suppositions here ! */
3312 while (p < pkt.data + pkt.size - 4) {
3313 /* stop when vop header is found */
3314 if (p[0] == 0x00 && p[1] == 0x00 &&
3315 p[2] == 0x01 && p[3] == 0xb6) {
3316 size = p - pkt.data;
3317 // av_hex_dump(pkt.data, size);
3318 st->codec.extradata = av_malloc(size);
3319 st->codec.extradata_size = size;
3320 memcpy(st->codec.extradata, pkt.data, size);
3327 av_free_packet(&pkt);
3331 /* compute the needed AVStream for each file */
3332 static void build_file_streams(void)
3334 FFStream *stream, *stream_next;
3335 AVFormatContext *infile;
3338 /* gather all streams */
3339 for(stream = first_stream; stream != NULL; stream = stream_next) {
3340 stream_next = stream->next;
3341 if (stream->stream_type == STREAM_TYPE_LIVE &&
3343 /* the stream comes from a file */
3344 /* try to open the file */
3346 stream->ap_in = av_mallocz(sizeof(AVFormatParameters));
3347 if (stream->fmt == &rtp_mux) {
3348 /* specific case : if transport stream output to RTP,
3349 we use a raw transport stream reader */
3350 stream->ap_in->mpeg2ts_raw = 1;
3351 stream->ap_in->mpeg2ts_compute_pcr = 1;
3354 if (av_open_input_file(&infile, stream->feed_filename,
3355 stream->ifmt, 0, stream->ap_in) < 0) {
3356 http_log("%s not found", stream->feed_filename);
3357 /* remove stream (no need to spend more time on it) */
3359 remove_stream(stream);
3361 /* find all the AVStreams inside and reference them in
3363 if (av_find_stream_info(infile) < 0) {
3364 http_log("Could not find codec parameters from '%s'",
3365 stream->feed_filename);
3366 av_close_input_file(infile);
3369 extract_mpeg4_header(infile);
3371 for(i=0;i<infile->nb_streams;i++) {
3372 add_av_stream1(stream, &infile->streams[i]->codec);
3374 av_close_input_file(infile);
3380 /* compute the needed AVStream for each feed */
3381 static void build_feed_streams(void)
3383 FFStream *stream, *feed;
3386 /* gather all streams */
3387 for(stream = first_stream; stream != NULL; stream = stream->next) {
3388 feed = stream->feed;
3390 if (!stream->is_feed) {
3391 /* we handle a stream coming from a feed */
3392 for(i=0;i<stream->nb_streams;i++) {
3393 stream->feed_streams[i] = add_av_stream(feed, stream->streams[i]);
3399 /* gather all streams */
3400 for(stream = first_stream; stream != NULL; stream = stream->next) {
3401 feed = stream->feed;
3403 if (stream->is_feed) {
3404 for(i=0;i<stream->nb_streams;i++) {
3405 stream->feed_streams[i] = i;
3411 /* create feed files if needed */
3412 for(feed = first_feed; feed != NULL; feed = feed->next_feed) {
3415 if (url_exist(feed->feed_filename)) {
3416 /* See if it matches */
3420 if (av_open_input_file(&s, feed->feed_filename, NULL, FFM_PACKET_SIZE, NULL) >= 0) {
3421 /* Now see if it matches */
3422 if (s->nb_streams == feed->nb_streams) {
3424 for(i=0;i<s->nb_streams;i++) {
3426 sf = feed->streams[i];
3429 if (sf->index != ss->index ||
3431 printf("Index & Id do not match for stream %d (%s)\n",
3432 i, feed->feed_filename);
3435 AVCodecContext *ccf, *ccs;
3439 #define CHECK_CODEC(x) (ccf->x != ccs->x)
3441 if (CHECK_CODEC(codec) || CHECK_CODEC(codec_type)) {
3442 printf("Codecs do not match for stream %d\n", i);
3444 } else if (CHECK_CODEC(bit_rate) || CHECK_CODEC(flags)) {
3445 printf("Codec bitrates do not match for stream %d\n", i);
3447 } else if (ccf->codec_type == CODEC_TYPE_VIDEO) {
3448 if (CHECK_CODEC(frame_rate) ||
3449 CHECK_CODEC(frame_rate_base) ||
3450 CHECK_CODEC(width) ||
3451 CHECK_CODEC(height)) {
3452 printf("Codec width, height and framerate do not match for stream %d\n", i);
3455 } else if (ccf->codec_type == CODEC_TYPE_AUDIO) {
3456 if (CHECK_CODEC(sample_rate) ||
3457 CHECK_CODEC(channels) ||
3458 CHECK_CODEC(frame_size)) {
3459 printf("Codec sample_rate, channels, frame_size do not match for stream %d\n", i);
3463 printf("Unknown codec type\n");
3472 printf("Deleting feed file '%s' as stream counts differ (%d != %d)\n",
3473 feed->feed_filename, s->nb_streams, feed->nb_streams);
3476 av_close_input_file(s);
3478 printf("Deleting feed file '%s' as it appears to be corrupt\n",
3479 feed->feed_filename);
3482 if (feed->readonly) {
3483 printf("Unable to delete feed file '%s' as it is marked readonly\n",
3484 feed->feed_filename);
3487 unlink(feed->feed_filename);
3490 if (!url_exist(feed->feed_filename)) {
3491 AVFormatContext s1, *s = &s1;
3493 if (feed->readonly) {
3494 printf("Unable to create feed file '%s' as it is marked readonly\n",
3495 feed->feed_filename);
3499 /* only write the header of the ffm file */
3500 if (url_fopen(&s->pb, feed->feed_filename, URL_WRONLY) < 0) {
3501 fprintf(stderr, "Could not open output feed file '%s'\n",
3502 feed->feed_filename);
3505 s->oformat = feed->fmt;
3506 s->nb_streams = feed->nb_streams;
3507 for(i=0;i<s->nb_streams;i++) {
3509 st = feed->streams[i];
3512 av_set_parameters(s, NULL);
3514 /* XXX: need better api */
3515 av_freep(&s->priv_data);
3518 /* get feed size and write index */
3519 fd = open(feed->feed_filename, O_RDONLY);
3521 fprintf(stderr, "Could not open output feed file '%s'\n",
3522 feed->feed_filename);
3526 feed->feed_write_index = ffm_read_write_index(fd);
3527 feed->feed_size = lseek(fd, 0, SEEK_END);
3528 /* ensure that we do not wrap before the end of file */
3529 if (feed->feed_max_size < feed->feed_size)
3530 feed->feed_max_size = feed->feed_size;
3536 /* compute the bandwidth used by each stream */
3537 static void compute_bandwidth(void)
3542 for(stream = first_stream; stream != NULL; stream = stream->next) {
3544 for(i=0;i<stream->nb_streams;i++) {
3545 AVStream *st = stream->streams[i];
3546 switch(st->codec.codec_type) {
3547 case CODEC_TYPE_AUDIO:
3548 case CODEC_TYPE_VIDEO:
3549 bandwidth += st->codec.bit_rate;
3555 stream->bandwidth = (bandwidth + 999) / 1000;
3559 static void get_arg(char *buf, int buf_size, const char **pp)
3566 while (isspace(*p)) p++;
3569 if (*p == '\"' || *p == '\'')
3581 if ((q - buf) < buf_size - 1)
3586 if (quote && *p == quote)
3591 /* add a codec and set the default parameters */
3592 static void add_codec(FFStream *stream, AVCodecContext *av)
3596 /* compute default parameters */
3597 switch(av->codec_type) {
3598 case CODEC_TYPE_AUDIO:
3599 if (av->bit_rate == 0)
3600 av->bit_rate = 64000;
3601 if (av->sample_rate == 0)
3602 av->sample_rate = 22050;
3603 if (av->channels == 0)
3606 case CODEC_TYPE_VIDEO:
3607 if (av->bit_rate == 0)
3608 av->bit_rate = 64000;
3609 if (av->frame_rate == 0){
3611 av->frame_rate_base = 1;
3613 if (av->width == 0 || av->height == 0) {
3617 /* Bitrate tolerance is less for streaming */
3618 if (av->bit_rate_tolerance == 0)
3619 av->bit_rate_tolerance = av->bit_rate / 4;
3624 if (av->max_qdiff == 0)
3626 av->qcompress = 0.5;
3630 av->rc_eq = "tex^qComp";
3631 if (!av->i_quant_factor)
3632 av->i_quant_factor = -0.8;
3633 if (!av->b_quant_factor)
3634 av->b_quant_factor = 1.25;
3635 if (!av->b_quant_offset)
3636 av->b_quant_offset = 1.25;
3637 if (!av->rc_min_rate)
3638 av->rc_min_rate = av->bit_rate / 2;
3639 if (!av->rc_max_rate)
3640 av->rc_max_rate = av->bit_rate * 2;
3647 st = av_mallocz(sizeof(AVStream));
3650 stream->streams[stream->nb_streams++] = st;
3651 memcpy(&st->codec, av, sizeof(AVCodecContext));
3654 static int opt_audio_codec(const char *arg)
3660 if (!strcmp(p->name, arg) && p->type == CODEC_TYPE_AUDIO)
3665 return CODEC_ID_NONE;
3671 static int opt_video_codec(const char *arg)
3677 if (!strcmp(p->name, arg) && p->type == CODEC_TYPE_VIDEO)
3682 return CODEC_ID_NONE;
3688 /* simplistic plugin support */
3690 #ifdef CONFIG_HAVE_DLOPEN
3691 void load_module(const char *filename)
3694 void (*init_func)(void);
3695 dll = dlopen(filename, RTLD_NOW);
3697 fprintf(stderr, "Could not load module '%s' - %s\n",
3698 filename, dlerror());
3702 init_func = dlsym(dll, "ffserver_module_init");
3705 "%s: init function 'ffserver_module_init()' not found\n",
3714 static int parse_ffconfig(const char *filename)
3721 int val, errors, line_num;
3722 FFStream **last_stream, *stream, *redirect;
3723 FFStream **last_feed, *feed;
3724 AVCodecContext audio_enc, video_enc;
3725 int audio_id, video_id;
3727 f = fopen(filename, "r");
3735 first_stream = NULL;
3736 last_stream = &first_stream;
3738 last_feed = &first_feed;
3742 audio_id = CODEC_ID_NONE;
3743 video_id = CODEC_ID_NONE;
3745 if (fgets(line, sizeof(line), f) == NULL)
3751 if (*p == '\0' || *p == '#')
3754 get_arg(cmd, sizeof(cmd), &p);
3756 if (!strcasecmp(cmd, "Port")) {
3757 get_arg(arg, sizeof(arg), &p);
3758 my_http_addr.sin_port = htons (atoi(arg));
3759 } else if (!strcasecmp(cmd, "BindAddress")) {
3760 get_arg(arg, sizeof(arg), &p);
3761 if (!inet_aton(arg, &my_http_addr.sin_addr)) {
3762 fprintf(stderr, "%s:%d: Invalid IP address: %s\n",
3763 filename, line_num, arg);
3766 } else if (!strcasecmp(cmd, "NoDaemon")) {
3767 ffserver_daemon = 0;
3768 } else if (!strcasecmp(cmd, "RTSPPort")) {
3769 get_arg(arg, sizeof(arg), &p);
3770 my_rtsp_addr.sin_port = htons (atoi(arg));
3771 } else if (!strcasecmp(cmd, "RTSPBindAddress")) {
3772 get_arg(arg, sizeof(arg), &p);
3773 if (!inet_aton(arg, &my_rtsp_addr.sin_addr)) {
3774 fprintf(stderr, "%s:%d: Invalid IP address: %s\n",
3775 filename, line_num, arg);
3778 } else if (!strcasecmp(cmd, "MaxClients")) {
3779 get_arg(arg, sizeof(arg), &p);
3781 if (val < 1 || val > HTTP_MAX_CONNECTIONS) {
3782 fprintf(stderr, "%s:%d: Invalid MaxClients: %s\n",
3783 filename, line_num, arg);
3786 nb_max_connections = val;
3788 } else if (!strcasecmp(cmd, "MaxBandwidth")) {
3789 get_arg(arg, sizeof(arg), &p);
3791 if (val < 10 || val > 100000) {
3792 fprintf(stderr, "%s:%d: Invalid MaxBandwidth: %s\n",
3793 filename, line_num, arg);
3796 max_bandwidth = val;
3798 } else if (!strcasecmp(cmd, "CustomLog")) {
3799 get_arg(logfilename, sizeof(logfilename), &p);
3800 } else if (!strcasecmp(cmd, "<Feed")) {
3801 /*********************************************/
3802 /* Feed related options */
3804 if (stream || feed) {
3805 fprintf(stderr, "%s:%d: Already in a tag\n",
3806 filename, line_num);
3808 feed = av_mallocz(sizeof(FFStream));
3809 /* add in stream list */
3810 *last_stream = feed;
3811 last_stream = &feed->next;
3812 /* add in feed list */
3814 last_feed = &feed->next_feed;
3816 get_arg(feed->filename, sizeof(feed->filename), &p);
3817 q = strrchr(feed->filename, '>');
3820 feed->fmt = guess_format("ffm", NULL, NULL);
3821 /* defaut feed file */
3822 snprintf(feed->feed_filename, sizeof(feed->feed_filename),
3823 "/tmp/%s.ffm", feed->filename);
3824 feed->feed_max_size = 5 * 1024 * 1024;
3826 feed->feed = feed; /* self feeding :-) */
3828 } else if (!strcasecmp(cmd, "Launch")) {
3832 feed->child_argv = (char **) av_mallocz(64 * sizeof(char *));
3834 feed->child_argv[0] = av_malloc(7);
3835 strcpy(feed->child_argv[0], "ffmpeg");
3837 for (i = 1; i < 62; i++) {
3840 get_arg(argbuf, sizeof(argbuf), &p);
3844 feed->child_argv[i] = av_malloc(strlen(argbuf) + 1);
3845 strcpy(feed->child_argv[i], argbuf);
3848 feed->child_argv[i] = av_malloc(30 + strlen(feed->filename));
3850 snprintf(feed->child_argv[i], 256, "http://127.0.0.1:%d/%s",
3851 ntohs(my_http_addr.sin_port), feed->filename);
3853 } else if (!strcasecmp(cmd, "ReadOnlyFile")) {
3855 get_arg(feed->feed_filename, sizeof(feed->feed_filename), &p);
3857 } else if (stream) {
3858 get_arg(stream->feed_filename, sizeof(stream->feed_filename), &p);
3860 } else if (!strcasecmp(cmd, "File")) {
3862 get_arg(feed->feed_filename, sizeof(feed->feed_filename), &p);
3863 } else if (stream) {
3864 get_arg(stream->feed_filename, sizeof(stream->feed_filename), &p);
3866 } else if (!strcasecmp(cmd, "FileMaxSize")) {
3871 get_arg(arg, sizeof(arg), &p);
3873 fsize = strtod(p1, (char **)&p1);
3874 switch(toupper(*p1)) {
3879 fsize *= 1024 * 1024;
3882 fsize *= 1024 * 1024 * 1024;
3885 feed->feed_max_size = (int64_t)fsize;
3887 } else if (!strcasecmp(cmd, "</Feed>")) {
3889 fprintf(stderr, "%s:%d: No corresponding <Feed> for </Feed>\n",
3890 filename, line_num);
3894 /* Make sure that we start out clean */
3895 if (unlink(feed->feed_filename) < 0
3896 && errno != ENOENT) {
3897 fprintf(stderr, "%s:%d: Unable to clean old feed file '%s': %s\n",
3898 filename, line_num, feed->feed_filename, strerror(errno));
3904 } else if (!strcasecmp(cmd, "<Stream")) {
3905 /*********************************************/
3906 /* Stream related options */
3908 if (stream || feed) {
3909 fprintf(stderr, "%s:%d: Already in a tag\n",
3910 filename, line_num);
3912 stream = av_mallocz(sizeof(FFStream));
3913 *last_stream = stream;
3914 last_stream = &stream->next;
3916 get_arg(stream->filename, sizeof(stream->filename), &p);
3917 q = strrchr(stream->filename, '>');
3920 stream->fmt = guess_stream_format(NULL, stream->filename, NULL);
3921 memset(&audio_enc, 0, sizeof(AVCodecContext));
3922 memset(&video_enc, 0, sizeof(AVCodecContext));
3923 audio_id = CODEC_ID_NONE;
3924 video_id = CODEC_ID_NONE;
3926 audio_id = stream->fmt->audio_codec;
3927 video_id = stream->fmt->video_codec;
3930 } else if (!strcasecmp(cmd, "Feed")) {
3931 get_arg(arg, sizeof(arg), &p);
3936 while (sfeed != NULL) {
3937 if (!strcmp(sfeed->filename, arg))
3939 sfeed = sfeed->next_feed;
3942 fprintf(stderr, "%s:%d: feed '%s' not defined\n",
3943 filename, line_num, arg);
3945 stream->feed = sfeed;
3948 } else if (!strcasecmp(cmd, "Format")) {
3949 get_arg(arg, sizeof(arg), &p);
3950 if (!strcmp(arg, "status")) {
3951 stream->stream_type = STREAM_TYPE_STATUS;
3954 stream->stream_type = STREAM_TYPE_LIVE;
3955 /* jpeg cannot be used here, so use single frame jpeg */
3956 if (!strcmp(arg, "jpeg"))
3957 strcpy(arg, "singlejpeg");
3958 stream->fmt = guess_stream_format(arg, NULL, NULL);
3960 fprintf(stderr, "%s:%d: Unknown Format: %s\n",
3961 filename, line_num, arg);
3966 audio_id = stream->fmt->audio_codec;
3967 video_id = stream->fmt->video_codec;
3969 } else if (!strcasecmp(cmd, "InputFormat")) {
3970 stream->ifmt = av_find_input_format(arg);
3971 if (!stream->ifmt) {
3972 fprintf(stderr, "%s:%d: Unknown input format: %s\n",
3973 filename, line_num, arg);
3975 } else if (!strcasecmp(cmd, "FaviconURL")) {
3976 if (stream && stream->stream_type == STREAM_TYPE_STATUS) {
3977 get_arg(stream->feed_filename, sizeof(stream->feed_filename), &p);
3979 fprintf(stderr, "%s:%d: FaviconURL only permitted for status streams\n",
3980 filename, line_num);
3983 } else if (!strcasecmp(cmd, "Author")) {
3985 get_arg(stream->author, sizeof(stream->author), &p);
3987 } else if (!strcasecmp(cmd, "Comment")) {
3989 get_arg(stream->comment, sizeof(stream->comment), &p);
3991 } else if (!strcasecmp(cmd, "Copyright")) {
3993 get_arg(stream->copyright, sizeof(stream->copyright), &p);
3995 } else if (!strcasecmp(cmd, "Title")) {
3997 get_arg(stream->title, sizeof(stream->title), &p);
3999 } else if (!strcasecmp(cmd, "Preroll")) {
4000 get_arg(arg, sizeof(arg), &p);
4002 stream->prebuffer = atof(arg) * 1000;
4004 } else if (!strcasecmp(cmd, "StartSendOnKey")) {
4006 stream->send_on_key = 1;
4008 } else if (!strcasecmp(cmd, "AudioCodec")) {
4009 get_arg(arg, sizeof(arg), &p);
4010 audio_id = opt_audio_codec(arg);
4011 if (audio_id == CODEC_ID_NONE) {
4012 fprintf(stderr, "%s:%d: Unknown AudioCodec: %s\n",
4013 filename, line_num, arg);
4016 } else if (!strcasecmp(cmd, "VideoCodec")) {
4017 get_arg(arg, sizeof(arg), &p);
4018 video_id = opt_video_codec(arg);
4019 if (video_id == CODEC_ID_NONE) {
4020 fprintf(stderr, "%s:%d: Unknown VideoCodec: %s\n",
4021 filename, line_num, arg);
4024 } else if (!strcasecmp(cmd, "MaxTime")) {
4025 get_arg(arg, sizeof(arg), &p);
4027 stream->max_time = atof(arg) * 1000;
4029 } else if (!strcasecmp(cmd, "AudioBitRate")) {
4030 get_arg(arg, sizeof(arg), &p);
4032 audio_enc.bit_rate = atoi(arg) * 1000;
4034 } else if (!strcasecmp(cmd, "AudioChannels")) {
4035 get_arg(arg, sizeof(arg), &p);
4037 audio_enc.channels = atoi(arg);
4039 } else if (!strcasecmp(cmd, "AudioSampleRate")) {
4040 get_arg(arg, sizeof(arg), &p);
4042 audio_enc.sample_rate = atoi(arg);
4044 } else if (!strcasecmp(cmd, "AudioQuality")) {
4045 get_arg(arg, sizeof(arg), &p);
4047 // audio_enc.quality = atof(arg) * 1000;
4049 } else if (!strcasecmp(cmd, "VideoBitRateRange")) {
4051 int minrate, maxrate;
4053 get_arg(arg, sizeof(arg), &p);
4055 if (sscanf(arg, "%d-%d", &minrate, &maxrate) == 2) {
4056 video_enc.rc_min_rate = minrate * 1000;
4057 video_enc.rc_max_rate = maxrate * 1000;
4059 fprintf(stderr, "%s:%d: Incorrect format for VideoBitRateRange -- should be <min>-<max>: %s\n",
4060 filename, line_num, arg);
4064 } else if (!strcasecmp(cmd, "VideoBitRateTolerance")) {
4066 get_arg(arg, sizeof(arg), &p);
4067 video_enc.bit_rate_tolerance = atoi(arg) * 1000;
4069 } else if (!strcasecmp(cmd, "VideoBitRate")) {
4070 get_arg(arg, sizeof(arg), &p);
4072 video_enc.bit_rate = atoi(arg) * 1000;
4074 } else if (!strcasecmp(cmd, "VideoSize")) {
4075 get_arg(arg, sizeof(arg), &p);
4077 parse_image_size(&video_enc.width, &video_enc.height, arg);
4078 if ((video_enc.width % 16) != 0 ||
4079 (video_enc.height % 16) != 0) {
4080 fprintf(stderr, "%s:%d: Image size must be a multiple of 16\n",
4081 filename, line_num);
4085 } else if (!strcasecmp(cmd, "VideoFrameRate")) {
4086 get_arg(arg, sizeof(arg), &p);
4088 video_enc.frame_rate_base= DEFAULT_FRAME_RATE_BASE;
4089 video_enc.frame_rate = (int)(strtod(arg, NULL) * video_enc.frame_rate_base);
4091 } else if (!strcasecmp(cmd, "VideoGopSize")) {
4092 get_arg(arg, sizeof(arg), &p);
4094 video_enc.gop_size = atoi(arg);
4096 } else if (!strcasecmp(cmd, "VideoIntraOnly")) {
4098 video_enc.gop_size = 1;
4100 } else if (!strcasecmp(cmd, "VideoHighQuality")) {
4102 video_enc.mb_decision = FF_MB_DECISION_BITS;
4104 } else if (!strcasecmp(cmd, "Video4MotionVector")) {
4106 video_enc.mb_decision = FF_MB_DECISION_BITS; //FIXME remove
4107 video_enc.flags |= CODEC_FLAG_4MV;
4109 } else if (!strcasecmp(cmd, "VideoQDiff")) {
4110 get_arg(arg, sizeof(arg), &p);
4112 video_enc.max_qdiff = atoi(arg);
4113 if (video_enc.max_qdiff < 1 || video_enc.max_qdiff > 31) {
4114 fprintf(stderr, "%s:%d: VideoQDiff out of range\n",
4115 filename, line_num);
4119 } else if (!strcasecmp(cmd, "VideoQMax")) {
4120 get_arg(arg, sizeof(arg), &p);
4122 video_enc.qmax = atoi(arg);
4123 if (video_enc.qmax < 1 || video_enc.qmax > 31) {
4124 fprintf(stderr, "%s:%d: VideoQMax out of range\n",
4125 filename, line_num);
4129 } else if (!strcasecmp(cmd, "VideoQMin")) {
4130 get_arg(arg, sizeof(arg), &p);
4132 video_enc.qmin = atoi(arg);
4133 if (video_enc.qmin < 1 || video_enc.qmin > 31) {
4134 fprintf(stderr, "%s:%d: VideoQMin out of range\n",
4135 filename, line_num);
4139 } else if (!strcasecmp(cmd, "LumaElim")) {
4140 get_arg(arg, sizeof(arg), &p);
4142 video_enc.luma_elim_threshold = atoi(arg);
4144 } else if (!strcasecmp(cmd, "ChromaElim")) {
4145 get_arg(arg, sizeof(arg), &p);
4147 video_enc.chroma_elim_threshold = atoi(arg);
4149 } else if (!strcasecmp(cmd, "LumiMask")) {
4150 get_arg(arg, sizeof(arg), &p);
4152 video_enc.lumi_masking = atof(arg);
4154 } else if (!strcasecmp(cmd, "DarkMask")) {
4155 get_arg(arg, sizeof(arg), &p);
4157 video_enc.dark_masking = atof(arg);
4159 } else if (!strcasecmp(cmd, "NoVideo")) {
4160 video_id = CODEC_ID_NONE;
4161 } else if (!strcasecmp(cmd, "NoAudio")) {
4162 audio_id = CODEC_ID_NONE;
4163 } else if (!strcasecmp(cmd, "ACL")) {
4167 get_arg(arg, sizeof(arg), &p);
4168 if (strcasecmp(arg, "allow") == 0) {
4169 acl.action = IP_ALLOW;
4170 } else if (strcasecmp(arg, "deny") == 0) {
4171 acl.action = IP_DENY;
4173 fprintf(stderr, "%s:%d: ACL action '%s' is not ALLOW or DENY\n",
4174 filename, line_num, arg);
4178 get_arg(arg, sizeof(arg), &p);
4180 he = gethostbyname(arg);
4182 fprintf(stderr, "%s:%d: ACL refers to invalid host or ip address '%s'\n",
4183 filename, line_num, arg);
4186 /* Only take the first */
4187 acl.first.s_addr = ntohl(((struct in_addr *) he->h_addr_list[0])->s_addr);
4188 acl.last = acl.first;
4191 get_arg(arg, sizeof(arg), &p);
4194 he = gethostbyname(arg);
4196 fprintf(stderr, "%s:%d: ACL refers to invalid host or ip address '%s'\n",
4197 filename, line_num, arg);
4200 /* Only take the first */
4201 acl.last.s_addr = ntohl(((struct in_addr *) he->h_addr_list[0])->s_addr);
4206 IPAddressACL *nacl = (IPAddressACL *) av_mallocz(sizeof(*nacl));
4207 IPAddressACL **naclp = 0;
4213 naclp = &stream->acl;
4217 fprintf(stderr, "%s:%d: ACL found not in <stream> or <feed>\n",
4218 filename, line_num);
4224 naclp = &(*naclp)->next;
4229 } else if (!strcasecmp(cmd, "RTSPOption")) {
4230 get_arg(arg, sizeof(arg), &p);
4232 av_freep(&stream->rtsp_option);
4233 /* XXX: av_strdup ? */
4234 stream->rtsp_option = av_malloc(strlen(arg) + 1);
4235 if (stream->rtsp_option) {
4236 strcpy(stream->rtsp_option, arg);
4239 } else if (!strcasecmp(cmd, "MulticastAddress")) {
4240 get_arg(arg, sizeof(arg), &p);
4242 if (!inet_aton(arg, &stream->multicast_ip)) {
4243 fprintf(stderr, "%s:%d: Invalid IP address: %s\n",
4244 filename, line_num, arg);
4247 stream->is_multicast = 1;
4248 stream->loop = 1; /* default is looping */
4250 } else if (!strcasecmp(cmd, "MulticastPort")) {
4251 get_arg(arg, sizeof(arg), &p);
4253 stream->multicast_port = atoi(arg);
4255 } else if (!strcasecmp(cmd, "MulticastTTL")) {
4256 get_arg(arg, sizeof(arg), &p);
4258 stream->multicast_ttl = atoi(arg);
4260 } else if (!strcasecmp(cmd, "NoLoop")) {
4264 } else if (!strcasecmp(cmd, "</Stream>")) {
4266 fprintf(stderr, "%s:%d: No corresponding <Stream> for </Stream>\n",
4267 filename, line_num);
4270 if (stream->feed && stream->fmt && strcmp(stream->fmt->name, "ffm") != 0) {
4271 if (audio_id != CODEC_ID_NONE) {
4272 audio_enc.codec_type = CODEC_TYPE_AUDIO;
4273 audio_enc.codec_id = audio_id;
4274 add_codec(stream, &audio_enc);
4276 if (video_id != CODEC_ID_NONE) {
4277 video_enc.codec_type = CODEC_TYPE_VIDEO;
4278 video_enc.codec_id = video_id;
4279 add_codec(stream, &video_enc);
4283 } else if (!strcasecmp(cmd, "<Redirect")) {
4284 /*********************************************/
4286 if (stream || feed || redirect) {
4287 fprintf(stderr, "%s:%d: Already in a tag\n",
4288 filename, line_num);
4291 redirect = av_mallocz(sizeof(FFStream));
4292 *last_stream = redirect;
4293 last_stream = &redirect->next;
4295 get_arg(redirect->filename, sizeof(redirect->filename), &p);
4296 q = strrchr(redirect->filename, '>');
4299 redirect->stream_type = STREAM_TYPE_REDIRECT;
4301 } else if (!strcasecmp(cmd, "URL")) {
4303 get_arg(redirect->feed_filename, sizeof(redirect->feed_filename), &p);
4305 } else if (!strcasecmp(cmd, "</Redirect>")) {
4307 fprintf(stderr, "%s:%d: No corresponding <Redirect> for </Redirect>\n",
4308 filename, line_num);
4311 if (!redirect->feed_filename[0]) {
4312 fprintf(stderr, "%s:%d: No URL found for <Redirect>\n",
4313 filename, line_num);
4317 } else if (!strcasecmp(cmd, "LoadModule")) {
4318 get_arg(arg, sizeof(arg), &p);
4319 #ifdef CONFIG_HAVE_DLOPEN
4322 fprintf(stderr, "%s:%d: Module support not compiled into this version: '%s'\n",
4323 filename, line_num, arg);
4327 fprintf(stderr, "%s:%d: Incorrect keyword: '%s'\n",
4328 filename, line_num, cmd);
4342 static void write_packet(FFCodec *ffenc,
4343 uint8_t *buf, int size)
4346 AVCodecContext *enc = &ffenc->enc;
4348 mk_header(&hdr, enc, size);
4349 wptr = http_fifo.wptr;
4350 fifo_write(&http_fifo, (uint8_t *)&hdr, sizeof(hdr), &wptr);
4351 fifo_write(&http_fifo, buf, size, &wptr);
4352 /* atomic modification of wptr */
4353 http_fifo.wptr = wptr;
4354 ffenc->data_count += size;
4355 ffenc->avg_frame_size = ffenc->avg_frame_size * AVG_COEF + size * (1.0 - AVG_COEF);
4359 static void show_banner(void)
4361 printf("ffserver version " FFMPEG_VERSION ", Copyright (c) 2000-2003 Fabrice Bellard\n");
4364 static void show_help(void)
4367 printf("usage: ffserver [-L] [-h] [-f configfile]\n"
4368 "Hyper fast multi format Audio/Video streaming server\n"
4370 "-L : print the LICENSE\n"
4372 "-f configfile : use configfile instead of /etc/ffserver.conf\n"
4376 static void show_license(void)
4380 "This library is free software; you can redistribute it and/or\n"
4381 "modify it under the terms of the GNU Lesser General Public\n"
4382 "License as published by the Free Software Foundation; either\n"
4383 "version 2 of the License, or (at your option) any later version.\n"
4385 "This library is distributed in the hope that it will be useful,\n"
4386 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
4387 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n"
4388 "Lesser General Public License for more details.\n"
4390 "You should have received a copy of the GNU Lesser General Public\n"
4391 "License along with this library; if not, write to the Free Software\n"
4392 "Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA\n"
4396 static void handle_child_exit(int sig)
4401 while ((pid = waitpid(-1, &status, WNOHANG)) > 0) {
4404 for (feed = first_feed; feed; feed = feed->next) {
4405 if (feed->pid == pid) {
4406 int uptime = time(0) - feed->pid_start;
4409 fprintf(stderr, "%s: Pid %d exited with status %d after %d seconds\n", feed->filename, pid, status, uptime);
4412 /* Turn off any more restarts */
4413 feed->child_argv = 0;
4419 need_to_start_children = 1;
4422 int main(int argc, char **argv)
4424 const char *config_filename;
4426 struct sigaction sigact;
4430 config_filename = "/etc/ffserver.conf";
4432 my_program_name = argv[0];
4433 my_program_dir = getcwd(0, 0);
4434 ffserver_daemon = 1;
4437 c = getopt(argc, argv, "ndLh?f:");
4453 ffserver_daemon = 0;
4456 config_filename = optarg;
4463 putenv("http_proxy"); /* Kill the http_proxy */
4465 srandom(gettime_ms() + (getpid() << 16));
4467 /* address on which the server will handle HTTP connections */
4468 my_http_addr.sin_family = AF_INET;
4469 my_http_addr.sin_port = htons (8080);
4470 my_http_addr.sin_addr.s_addr = htonl (INADDR_ANY);
4472 /* address on which the server will handle RTSP connections */
4473 my_rtsp_addr.sin_family = AF_INET;
4474 my_rtsp_addr.sin_port = htons (5454);
4475 my_rtsp_addr.sin_addr.s_addr = htonl (INADDR_ANY);
4477 nb_max_connections = 5;
4478 max_bandwidth = 1000;
4479 first_stream = NULL;
4480 logfilename[0] = '\0';
4482 memset(&sigact, 0, sizeof(sigact));
4483 sigact.sa_handler = handle_child_exit;
4484 sigact.sa_flags = SA_NOCLDSTOP | SA_RESTART;
4485 sigaction(SIGCHLD, &sigact, 0);
4487 if (parse_ffconfig(config_filename) < 0) {
4488 fprintf(stderr, "Incorrect config file - exiting.\n");
4492 build_file_streams();
4494 build_feed_streams();
4496 compute_bandwidth();
4498 /* put the process in background and detach it from its TTY */
4499 if (ffserver_daemon) {
4506 } else if (pid > 0) {
4514 open("/dev/null", O_RDWR);
4515 if (strcmp(logfilename, "-") != 0) {
4525 signal(SIGPIPE, SIG_IGN);
4527 /* open log file if needed */
4528 if (logfilename[0] != '\0') {
4529 if (!strcmp(logfilename, "-"))
4532 logfile = fopen(logfilename, "w");
4535 if (http_server() < 0) {
4536 fprintf(stderr, "Could not start server\n");