2 * Multiple format streaming server
3 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21 #define HAVE_AV_CONFIG_H
27 #include <sys/ioctl.h>
28 #ifdef HAVE_SYS_POLL_H
33 #undef time //needed because HAVE_AV_CONFIG_H is defined on top
35 #include <sys/types.h>
36 #include <sys/socket.h>
38 #include <netinet/in.h>
39 #include <arpa/inet.h>
52 /* maximum number of simultaneous HTTP connections */
53 #define HTTP_MAX_CONNECTIONS 2000
56 HTTPSTATE_WAIT_REQUEST,
57 HTTPSTATE_SEND_HEADER,
58 HTTPSTATE_SEND_DATA_HEADER,
59 HTTPSTATE_SEND_DATA, /* sending TCP or UDP data */
60 HTTPSTATE_SEND_DATA_TRAILER,
61 HTTPSTATE_RECEIVE_DATA,
62 HTTPSTATE_WAIT_FEED, /* wait for data from the feed */
65 RTSPSTATE_WAIT_REQUEST,
67 RTSPSTATE_SEND_PACKET,
70 const char *http_state[] = {
86 #define IOBUFFER_INIT_SIZE 8192
88 /* timeouts are in ms */
89 #define HTTP_REQUEST_TIMEOUT (15 * 1000)
90 #define RTSP_REQUEST_TIMEOUT (3600 * 24 * 1000)
92 #define SYNC_TIMEOUT (10 * 1000)
95 int64_t count1, count2;
99 /* context associated with one connection */
100 typedef struct HTTPContext {
101 enum HTTPState state;
102 int fd; /* socket file descriptor */
103 struct sockaddr_in from_addr; /* origin */
104 struct pollfd *poll_entry; /* used when polling */
106 uint8_t *buffer_ptr, *buffer_end;
109 struct HTTPContext *next;
110 int got_key_frame; /* stream 0 => 1, stream 1 => 2, stream 2=> 4 */
114 /* input format handling */
115 AVFormatContext *fmt_in;
116 int64_t start_time; /* In milliseconds - this wraps fairly often */
117 int64_t first_pts; /* initial pts value */
118 int64_t cur_pts; /* current pts value from the stream in us */
119 int64_t cur_frame_duration; /* duration of the current frame in us */
120 int cur_frame_bytes; /* output frame size, needed to compute
121 the time at which we send each
123 int pts_stream_index; /* stream we choose as clock reference */
124 int64_t cur_clock; /* current clock reference value in us */
125 /* output format handling */
126 struct FFStream *stream;
127 /* -1 is invalid stream */
128 int feed_streams[MAX_STREAMS]; /* index of streams in the feed */
129 int switch_feed_streams[MAX_STREAMS]; /* index of streams in the feed */
131 AVFormatContext fmt_ctx; /* instance of FFStream for one user */
132 int last_packet_sent; /* true if last data packet was sent */
134 DataRateData datarate;
141 int is_packetized; /* if true, the stream is packetized */
142 int packet_stream_index; /* current stream for output in state machine */
144 /* RTSP state specific */
145 uint8_t *pb_buffer; /* XXX: use that in all the code */
147 int seq; /* RTSP sequence number */
149 /* RTP state specific */
150 enum RTSPProtocol rtp_protocol;
151 char session_id[32]; /* session id */
152 AVFormatContext *rtp_ctx[MAX_STREAMS];
154 /* RTP/UDP specific */
155 URLContext *rtp_handles[MAX_STREAMS];
157 /* RTP/TCP specific */
158 struct HTTPContext *rtsp_c;
159 uint8_t *packet_buffer, *packet_buffer_ptr, *packet_buffer_end;
162 static AVFrame dummy_frame;
164 /* each generated stream is described here */
168 STREAM_TYPE_REDIRECT,
171 enum IPAddressAction {
176 typedef struct IPAddressACL {
177 struct IPAddressACL *next;
178 enum IPAddressAction action;
179 /* These are in host order */
180 struct in_addr first;
184 /* description of each stream of the ffserver.conf file */
185 typedef struct FFStream {
186 enum StreamType stream_type;
187 char filename[1024]; /* stream filename */
188 struct FFStream *feed; /* feed we are using (can be null if
190 AVFormatParameters *ap_in; /* input parameters */
191 AVInputFormat *ifmt; /* if non NULL, force input format */
195 int prebuffer; /* Number of millseconds early to start */
196 int64_t max_time; /* Number of milliseconds to run */
198 AVStream *streams[MAX_STREAMS];
199 int feed_streams[MAX_STREAMS]; /* index of streams in the feed */
200 char feed_filename[1024]; /* file name of the feed storage, or
201 input file name for a stream */
206 pid_t pid; /* Of ffmpeg process */
207 time_t pid_start; /* Of ffmpeg process */
209 struct FFStream *next;
210 int bandwidth; /* bandwidth, in kbits/s */
213 /* multicast specific */
215 struct in_addr multicast_ip;
216 int multicast_port; /* first port used for multicast */
218 int loop; /* if true, send the stream in loops (only meaningful if file) */
221 int feed_opened; /* true if someone is writing to the feed */
222 int is_feed; /* true if it is a feed */
223 int readonly; /* True if writing is prohibited to the file */
225 int64_t bytes_served;
226 int64_t feed_max_size; /* maximum storage size, zero means unlimited */
227 int64_t feed_write_index; /* current write position in feed (it wraps round) */
228 int64_t feed_size; /* current size of feed */
229 struct FFStream *next_feed;
232 typedef struct FeedData {
233 long long data_count;
234 float avg_frame_size; /* frame size averraged over last frames with exponential mean */
237 struct sockaddr_in my_http_addr;
238 struct sockaddr_in my_rtsp_addr;
240 static char logfilename[1024];
241 static HTTPContext *first_http_ctx;
242 static FFStream *first_feed; /* contains only feeds */
243 static FFStream *first_stream; /* contains all streams, including feeds */
245 static void new_connection(int server_fd, int is_rtsp);
246 static void close_connection(HTTPContext *c);
249 static int handle_connection(HTTPContext *c);
250 static int http_parse_request(HTTPContext *c);
251 static int http_send_data(HTTPContext *c);
252 static void compute_stats(HTTPContext *c);
253 static int open_input_stream(HTTPContext *c, const char *info);
254 static int http_start_receive_data(HTTPContext *c);
255 static int http_receive_data(HTTPContext *c);
258 static int rtsp_parse_request(HTTPContext *c);
259 static void rtsp_cmd_describe(HTTPContext *c, const char *url);
260 static void rtsp_cmd_options(HTTPContext *c, const char *url);
261 static void rtsp_cmd_setup(HTTPContext *c, const char *url, RTSPHeader *h);
262 static void rtsp_cmd_play(HTTPContext *c, const char *url, RTSPHeader *h);
263 static void rtsp_cmd_pause(HTTPContext *c, const char *url, RTSPHeader *h);
264 static void rtsp_cmd_teardown(HTTPContext *c, const char *url, RTSPHeader *h);
267 static int prepare_sdp_description(FFStream *stream, uint8_t **pbuffer,
268 struct in_addr my_ip);
271 static HTTPContext *rtp_new_connection(struct sockaddr_in *from_addr,
272 FFStream *stream, const char *session_id,
273 enum RTSPProtocol rtp_protocol);
274 static int rtp_new_av_stream(HTTPContext *c,
275 int stream_index, struct sockaddr_in *dest_addr,
276 HTTPContext *rtsp_c);
278 static const char *my_program_name;
279 static const char *my_program_dir;
281 static int ffserver_debug;
282 static int ffserver_daemon;
283 static int no_launch;
284 static int need_to_start_children;
286 static int nb_max_connections;
287 static int nb_connections;
289 static int max_bandwidth;
290 static int current_bandwidth;
292 static int64_t cur_time; // Making this global saves on passing it around everywhere
294 static AVRandomState random_state;
296 static FILE *logfile = NULL;
298 static void __attribute__ ((format (printf, 1, 2))) http_log(const char *fmt, ...)
304 vfprintf(logfile, fmt, ap);
310 static char *ctime1(char *buf2)
318 p = buf2 + strlen(p) - 1;
324 static void log_connection(HTTPContext *c)
331 http_log("%s - - [%s] \"%s %s %s\" %d %"PRId64"\n",
332 inet_ntoa(c->from_addr.sin_addr),
333 ctime1(buf2), c->method, c->url,
334 c->protocol, (c->http_error ? c->http_error : 200), c->data_count);
337 static void update_datarate(DataRateData *drd, int64_t count)
339 if (!drd->time1 && !drd->count1) {
340 drd->time1 = drd->time2 = cur_time;
341 drd->count1 = drd->count2 = count;
343 if (cur_time - drd->time2 > 5000) {
344 drd->time1 = drd->time2;
345 drd->count1 = drd->count2;
346 drd->time2 = cur_time;
352 /* In bytes per second */
353 static int compute_datarate(DataRateData *drd, int64_t count)
355 if (cur_time == drd->time1)
358 return ((count - drd->count1) * 1000) / (cur_time - drd->time1);
362 static void start_children(FFStream *feed)
367 for (; feed; feed = feed->next) {
368 if (feed->child_argv && !feed->pid) {
369 feed->pid_start = time(0);
374 fprintf(stderr, "Unable to create children\n");
383 for (i = 3; i < 256; i++) {
387 if (!ffserver_debug) {
388 i = open("/dev/null", O_RDWR);
397 pstrcpy(pathname, sizeof(pathname), my_program_name);
399 slash = strrchr(pathname, '/');
405 strcpy(slash, "ffmpeg");
407 /* This is needed to make relative pathnames work */
408 chdir(my_program_dir);
410 signal(SIGPIPE, SIG_DFL);
412 execvp(pathname, feed->child_argv);
420 /* open a listening socket */
421 static int socket_open_listen(struct sockaddr_in *my_addr)
425 server_fd = socket(AF_INET,SOCK_STREAM,0);
432 setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &tmp, sizeof(tmp));
434 if (bind (server_fd, (struct sockaddr *) my_addr, sizeof (*my_addr)) < 0) {
436 snprintf(bindmsg, sizeof(bindmsg), "bind(port %d)", ntohs(my_addr->sin_port));
438 closesocket(server_fd);
442 if (listen (server_fd, 5) < 0) {
444 closesocket(server_fd);
447 fcntl(server_fd, F_SETFL, O_NONBLOCK);
452 /* start all multicast streams */
453 static void start_multicast(void)
458 struct sockaddr_in dest_addr;
459 int default_port, stream_index;
462 for(stream = first_stream; stream != NULL; stream = stream->next) {
463 if (stream->is_multicast) {
464 /* open the RTP connection */
465 snprintf(session_id, sizeof(session_id), "%08x%08x",
466 av_random(&random_state), av_random(&random_state));
468 /* choose a port if none given */
469 if (stream->multicast_port == 0) {
470 stream->multicast_port = default_port;
474 dest_addr.sin_family = AF_INET;
475 dest_addr.sin_addr = stream->multicast_ip;
476 dest_addr.sin_port = htons(stream->multicast_port);
478 rtp_c = rtp_new_connection(&dest_addr, stream, session_id,
479 RTSP_PROTOCOL_RTP_UDP_MULTICAST);
483 if (open_input_stream(rtp_c, "") < 0) {
484 fprintf(stderr, "Could not open input stream for stream '%s'\n",
489 /* open each RTP stream */
490 for(stream_index = 0; stream_index < stream->nb_streams;
492 dest_addr.sin_port = htons(stream->multicast_port +
494 if (rtp_new_av_stream(rtp_c, stream_index, &dest_addr, NULL) < 0) {
495 fprintf(stderr, "Could not open output stream '%s/streamid=%d'\n",
496 stream->filename, stream_index);
501 /* change state to send data */
502 rtp_c->state = HTTPSTATE_SEND_DATA;
507 /* main loop of the http server */
508 static int http_server(void)
510 int server_fd, ret, rtsp_server_fd, delay, delay1;
511 struct pollfd poll_table[HTTP_MAX_CONNECTIONS + 2], *poll_entry;
512 HTTPContext *c, *c_next;
514 server_fd = socket_open_listen(&my_http_addr);
518 rtsp_server_fd = socket_open_listen(&my_rtsp_addr);
519 if (rtsp_server_fd < 0)
522 http_log("ffserver started.\n");
524 start_children(first_feed);
526 first_http_ctx = NULL;
532 poll_entry = poll_table;
533 poll_entry->fd = server_fd;
534 poll_entry->events = POLLIN;
537 poll_entry->fd = rtsp_server_fd;
538 poll_entry->events = POLLIN;
541 /* wait for events on each HTTP handle */
548 case HTTPSTATE_SEND_HEADER:
549 case RTSPSTATE_SEND_REPLY:
550 case RTSPSTATE_SEND_PACKET:
551 c->poll_entry = poll_entry;
553 poll_entry->events = POLLOUT;
556 case HTTPSTATE_SEND_DATA_HEADER:
557 case HTTPSTATE_SEND_DATA:
558 case HTTPSTATE_SEND_DATA_TRAILER:
559 if (!c->is_packetized) {
560 /* for TCP, we output as much as we can (may need to put a limit) */
561 c->poll_entry = poll_entry;
563 poll_entry->events = POLLOUT;
566 /* when ffserver is doing the timing, we work by
567 looking at which packet need to be sent every
569 delay1 = 10; /* one tick wait XXX: 10 ms assumed */
574 case HTTPSTATE_WAIT_REQUEST:
575 case HTTPSTATE_RECEIVE_DATA:
576 case HTTPSTATE_WAIT_FEED:
577 case RTSPSTATE_WAIT_REQUEST:
578 /* need to catch errors */
579 c->poll_entry = poll_entry;
581 poll_entry->events = POLLIN;/* Maybe this will work */
585 c->poll_entry = NULL;
591 /* wait for an event on one connection. We poll at least every
592 second to handle timeouts */
594 ret = poll(poll_table, poll_entry - poll_table, delay);
595 if (ret < 0 && errno != EAGAIN && errno != EINTR)
599 cur_time = av_gettime() / 1000;
601 if (need_to_start_children) {
602 need_to_start_children = 0;
603 start_children(first_feed);
606 /* now handle the events */
607 for(c = first_http_ctx; c != NULL; c = c_next) {
609 if (handle_connection(c) < 0) {
610 /* close and free the connection */
616 poll_entry = poll_table;
617 /* new HTTP connection request ? */
618 if (poll_entry->revents & POLLIN) {
619 new_connection(server_fd, 0);
622 /* new RTSP connection request ? */
623 if (poll_entry->revents & POLLIN) {
624 new_connection(rtsp_server_fd, 1);
629 /* start waiting for a new HTTP/RTSP request */
630 static void start_wait_request(HTTPContext *c, int is_rtsp)
632 c->buffer_ptr = c->buffer;
633 c->buffer_end = c->buffer + c->buffer_size - 1; /* leave room for '\0' */
636 c->timeout = cur_time + RTSP_REQUEST_TIMEOUT;
637 c->state = RTSPSTATE_WAIT_REQUEST;
639 c->timeout = cur_time + HTTP_REQUEST_TIMEOUT;
640 c->state = HTTPSTATE_WAIT_REQUEST;
644 static void new_connection(int server_fd, int is_rtsp)
646 struct sockaddr_in from_addr;
648 HTTPContext *c = NULL;
650 len = sizeof(from_addr);
651 fd = accept(server_fd, (struct sockaddr *)&from_addr,
655 fcntl(fd, F_SETFL, O_NONBLOCK);
657 /* XXX: should output a warning page when coming
658 close to the connection limit */
659 if (nb_connections >= nb_max_connections)
662 /* add a new connection */
663 c = av_mallocz(sizeof(HTTPContext));
668 c->poll_entry = NULL;
669 c->from_addr = from_addr;
670 c->buffer_size = IOBUFFER_INIT_SIZE;
671 c->buffer = av_malloc(c->buffer_size);
675 c->next = first_http_ctx;
679 start_wait_request(c, is_rtsp);
691 static void close_connection(HTTPContext *c)
693 HTTPContext **cp, *c1;
695 AVFormatContext *ctx;
699 /* remove connection from list */
700 cp = &first_http_ctx;
701 while ((*cp) != NULL) {
710 /* remove references, if any (XXX: do it faster) */
711 for(c1 = first_http_ctx; c1 != NULL; c1 = c1->next) {
716 /* remove connection associated resources */
720 /* close each frame parser */
721 for(i=0;i<c->fmt_in->nb_streams;i++) {
722 st = c->fmt_in->streams[i];
723 if (st->codec->codec) {
724 avcodec_close(st->codec);
727 av_close_input_file(c->fmt_in);
730 /* free RTP output streams if any */
733 nb_streams = c->stream->nb_streams;
735 for(i=0;i<nb_streams;i++) {
738 av_write_trailer(ctx);
741 h = c->rtp_handles[i];
749 if (!c->last_packet_sent) {
752 if (url_open_dyn_buf(&ctx->pb) >= 0) {
753 av_write_trailer(ctx);
754 url_close_dyn_buf(&ctx->pb, &c->pb_buffer);
759 for(i=0; i<ctx->nb_streams; i++)
760 av_free(ctx->streams[i]) ;
762 if (c->stream && !c->post && c->stream->stream_type == STREAM_TYPE_LIVE)
763 current_bandwidth -= c->stream->bandwidth;
765 /* signal that there is no feed if we are the feeder socket */
766 if (c->state == HTTPSTATE_RECEIVE_DATA && c->stream) {
767 c->stream->feed_opened = 0;
771 av_freep(&c->pb_buffer);
772 av_freep(&c->packet_buffer);
778 static int handle_connection(HTTPContext *c)
783 case HTTPSTATE_WAIT_REQUEST:
784 case RTSPSTATE_WAIT_REQUEST:
786 if ((c->timeout - cur_time) < 0)
788 if (c->poll_entry->revents & (POLLERR | POLLHUP))
791 /* no need to read if no events */
792 if (!(c->poll_entry->revents & POLLIN))
796 len = recv(c->fd, c->buffer_ptr, 1, 0);
798 if (errno != EAGAIN && errno != EINTR)
800 } else if (len == 0) {
803 /* search for end of request. */
805 c->buffer_ptr += len;
807 if ((ptr >= c->buffer + 2 && !memcmp(ptr-2, "\n\n", 2)) ||
808 (ptr >= c->buffer + 4 && !memcmp(ptr-4, "\r\n\r\n", 4))) {
809 /* request found : parse it and reply */
810 if (c->state == HTTPSTATE_WAIT_REQUEST) {
811 ret = http_parse_request(c);
813 ret = rtsp_parse_request(c);
817 } else if (ptr >= c->buffer_end) {
818 /* request too long: cannot do anything */
820 } else goto read_loop;
824 case HTTPSTATE_SEND_HEADER:
825 if (c->poll_entry->revents & (POLLERR | POLLHUP))
828 /* no need to write if no events */
829 if (!(c->poll_entry->revents & POLLOUT))
831 len = send(c->fd, c->buffer_ptr, c->buffer_end - c->buffer_ptr, 0);
833 if (errno != EAGAIN && errno != EINTR) {
834 /* error : close connection */
835 av_freep(&c->pb_buffer);
839 c->buffer_ptr += len;
841 c->stream->bytes_served += len;
842 c->data_count += len;
843 if (c->buffer_ptr >= c->buffer_end) {
844 av_freep(&c->pb_buffer);
849 /* all the buffer was sent : synchronize to the incoming stream */
850 c->state = HTTPSTATE_SEND_DATA_HEADER;
851 c->buffer_ptr = c->buffer_end = c->buffer;
856 case HTTPSTATE_SEND_DATA:
857 case HTTPSTATE_SEND_DATA_HEADER:
858 case HTTPSTATE_SEND_DATA_TRAILER:
859 /* for packetized output, we consider we can always write (the
860 input streams sets the speed). It may be better to verify
861 that we do not rely too much on the kernel queues */
862 if (!c->is_packetized) {
863 if (c->poll_entry->revents & (POLLERR | POLLHUP))
866 /* no need to read if no events */
867 if (!(c->poll_entry->revents & POLLOUT))
870 if (http_send_data(c) < 0)
872 /* close connection if trailer sent */
873 if (c->state == HTTPSTATE_SEND_DATA_TRAILER)
876 case HTTPSTATE_RECEIVE_DATA:
877 /* no need to read if no events */
878 if (c->poll_entry->revents & (POLLERR | POLLHUP))
880 if (!(c->poll_entry->revents & POLLIN))
882 if (http_receive_data(c) < 0)
885 case HTTPSTATE_WAIT_FEED:
886 /* no need to read if no events */
887 if (c->poll_entry->revents & (POLLIN | POLLERR | POLLHUP))
890 /* nothing to do, we'll be waken up by incoming feed packets */
893 case RTSPSTATE_SEND_REPLY:
894 if (c->poll_entry->revents & (POLLERR | POLLHUP)) {
895 av_freep(&c->pb_buffer);
898 /* no need to write if no events */
899 if (!(c->poll_entry->revents & POLLOUT))
901 len = send(c->fd, c->buffer_ptr, c->buffer_end - c->buffer_ptr, 0);
903 if (errno != EAGAIN && errno != EINTR) {
904 /* error : close connection */
905 av_freep(&c->pb_buffer);
909 c->buffer_ptr += len;
910 c->data_count += len;
911 if (c->buffer_ptr >= c->buffer_end) {
912 /* all the buffer was sent : wait for a new request */
913 av_freep(&c->pb_buffer);
914 start_wait_request(c, 1);
918 case RTSPSTATE_SEND_PACKET:
919 if (c->poll_entry->revents & (POLLERR | POLLHUP)) {
920 av_freep(&c->packet_buffer);
923 /* no need to write if no events */
924 if (!(c->poll_entry->revents & POLLOUT))
926 len = send(c->fd, c->packet_buffer_ptr,
927 c->packet_buffer_end - c->packet_buffer_ptr, 0);
929 if (errno != EAGAIN && errno != EINTR) {
930 /* error : close connection */
931 av_freep(&c->packet_buffer);
935 c->packet_buffer_ptr += len;
936 if (c->packet_buffer_ptr >= c->packet_buffer_end) {
937 /* all the buffer was sent : wait for a new request */
938 av_freep(&c->packet_buffer);
939 c->state = RTSPSTATE_WAIT_REQUEST;
943 case HTTPSTATE_READY:
952 static int extract_rates(char *rates, int ratelen, const char *request)
956 for (p = request; *p && *p != '\r' && *p != '\n'; ) {
957 if (strncasecmp(p, "Pragma:", 7) == 0) {
958 const char *q = p + 7;
960 while (*q && *q != '\n' && isspace(*q))
963 if (strncasecmp(q, "stream-switch-entry=", 20) == 0) {
969 memset(rates, 0xff, ratelen);
972 while (*q && *q != '\n' && *q != ':')
975 if (sscanf(q, ":%d:%d", &stream_no, &rate_no) != 2) {
979 if (stream_no < ratelen && stream_no >= 0) {
980 rates[stream_no] = rate_no;
983 while (*q && *q != '\n' && !isspace(*q))
1000 static int find_stream_in_feed(FFStream *feed, AVCodecContext *codec, int bit_rate)
1003 int best_bitrate = 100000000;
1006 for (i = 0; i < feed->nb_streams; i++) {
1007 AVCodecContext *feed_codec = feed->streams[i]->codec;
1009 if (feed_codec->codec_id != codec->codec_id ||
1010 feed_codec->sample_rate != codec->sample_rate ||
1011 feed_codec->width != codec->width ||
1012 feed_codec->height != codec->height) {
1016 /* Potential stream */
1018 /* We want the fastest stream less than bit_rate, or the slowest
1019 * faster than bit_rate
1022 if (feed_codec->bit_rate <= bit_rate) {
1023 if (best_bitrate > bit_rate || feed_codec->bit_rate > best_bitrate) {
1024 best_bitrate = feed_codec->bit_rate;
1028 if (feed_codec->bit_rate < best_bitrate) {
1029 best_bitrate = feed_codec->bit_rate;
1038 static int modify_current_stream(HTTPContext *c, char *rates)
1041 FFStream *req = c->stream;
1042 int action_required = 0;
1044 /* Not much we can do for a feed */
1048 for (i = 0; i < req->nb_streams; i++) {
1049 AVCodecContext *codec = req->streams[i]->codec;
1053 c->switch_feed_streams[i] = req->feed_streams[i];
1056 c->switch_feed_streams[i] = find_stream_in_feed(req->feed, codec, codec->bit_rate / 2);
1059 /* Wants off or slow */
1060 c->switch_feed_streams[i] = find_stream_in_feed(req->feed, codec, codec->bit_rate / 4);
1062 /* This doesn't work well when it turns off the only stream! */
1063 c->switch_feed_streams[i] = -2;
1064 c->feed_streams[i] = -2;
1069 if (c->switch_feed_streams[i] >= 0 && c->switch_feed_streams[i] != c->feed_streams[i])
1070 action_required = 1;
1073 return action_required;
1077 static void do_switch_stream(HTTPContext *c, int i)
1079 if (c->switch_feed_streams[i] >= 0) {
1081 c->feed_streams[i] = c->switch_feed_streams[i];
1084 /* Now update the stream */
1086 c->switch_feed_streams[i] = -1;
1089 /* XXX: factorize in utils.c ? */
1090 /* XXX: take care with different space meaning */
1091 static void skip_spaces(const char **pp)
1095 while (*p == ' ' || *p == '\t')
1100 static void get_word(char *buf, int buf_size, const char **pp)
1108 while (!isspace(*p) && *p != '\0') {
1109 if ((q - buf) < buf_size - 1)
1118 static int validate_acl(FFStream *stream, HTTPContext *c)
1120 enum IPAddressAction last_action = IP_DENY;
1122 struct in_addr *src = &c->from_addr.sin_addr;
1123 unsigned long src_addr = ntohl(src->s_addr);
1125 for (acl = stream->acl; acl; acl = acl->next) {
1126 if (src_addr >= acl->first.s_addr && src_addr <= acl->last.s_addr) {
1127 return (acl->action == IP_ALLOW) ? 1 : 0;
1129 last_action = acl->action;
1132 /* Nothing matched, so return not the last action */
1133 return (last_action == IP_DENY) ? 1 : 0;
1136 /* compute the real filename of a file by matching it without its
1137 extensions to all the stream filenames */
1138 static void compute_real_filename(char *filename, int max_size)
1145 /* compute filename by matching without the file extensions */
1146 pstrcpy(file1, sizeof(file1), filename);
1147 p = strrchr(file1, '.');
1150 for(stream = first_stream; stream != NULL; stream = stream->next) {
1151 pstrcpy(file2, sizeof(file2), stream->filename);
1152 p = strrchr(file2, '.');
1155 if (!strcmp(file1, file2)) {
1156 pstrcpy(filename, max_size, stream->filename);
1171 /* parse http request and prepare header */
1172 static int http_parse_request(HTTPContext *c)
1175 enum RedirType redir_type;
1177 char info[1024], filename[1024];
1181 const char *mime_type;
1185 char *useragent = 0;
1188 get_word(cmd, sizeof(cmd), (const char **)&p);
1189 pstrcpy(c->method, sizeof(c->method), cmd);
1191 if (!strcmp(cmd, "GET"))
1193 else if (!strcmp(cmd, "POST"))
1198 get_word(url, sizeof(url), (const char **)&p);
1199 pstrcpy(c->url, sizeof(c->url), url);
1201 get_word(protocol, sizeof(protocol), (const char **)&p);
1202 if (strcmp(protocol, "HTTP/1.0") && strcmp(protocol, "HTTP/1.1"))
1205 pstrcpy(c->protocol, sizeof(c->protocol), protocol);
1208 http_log("New connection: %s %s\n", cmd, url);
1210 /* find the filename and the optional info string in the request */
1211 p = strchr(url, '?');
1213 pstrcpy(info, sizeof(info), p);
1219 pstrcpy(filename, sizeof(filename)-1, url + ((*url == '/') ? 1 : 0));
1221 for (p = c->buffer; *p && *p != '\r' && *p != '\n'; ) {
1222 if (strncasecmp(p, "User-Agent:", 11) == 0) {
1224 if (*useragent && *useragent != '\n' && isspace(*useragent))
1228 p = strchr(p, '\n');
1235 redir_type = REDIR_NONE;
1236 if (match_ext(filename, "asx")) {
1237 redir_type = REDIR_ASX;
1238 filename[strlen(filename)-1] = 'f';
1239 } else if (match_ext(filename, "asf") &&
1240 (!useragent || strncasecmp(useragent, "NSPlayer", 8) != 0)) {
1241 /* if this isn't WMP or lookalike, return the redirector file */
1242 redir_type = REDIR_ASF;
1243 } else if (match_ext(filename, "rpm,ram")) {
1244 redir_type = REDIR_RAM;
1245 strcpy(filename + strlen(filename)-2, "m");
1246 } else if (match_ext(filename, "rtsp")) {
1247 redir_type = REDIR_RTSP;
1248 compute_real_filename(filename, sizeof(filename) - 1);
1249 } else if (match_ext(filename, "sdp")) {
1250 redir_type = REDIR_SDP;
1251 compute_real_filename(filename, sizeof(filename) - 1);
1254 // "redirect" / request to index.html
1255 if (!strlen(filename))
1256 pstrcpy(filename, sizeof(filename) - 1, "index.html");
1258 stream = first_stream;
1259 while (stream != NULL) {
1260 if (!strcmp(stream->filename, filename) && validate_acl(stream, c))
1262 stream = stream->next;
1264 if (stream == NULL) {
1265 snprintf(msg, sizeof(msg), "File '%s' not found", url);
1270 memcpy(c->feed_streams, stream->feed_streams, sizeof(c->feed_streams));
1271 memset(c->switch_feed_streams, -1, sizeof(c->switch_feed_streams));
1273 if (stream->stream_type == STREAM_TYPE_REDIRECT) {
1274 c->http_error = 301;
1276 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "HTTP/1.0 301 Moved\r\n");
1277 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "Location: %s\r\n", stream->feed_filename);
1278 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "Content-type: text/html\r\n");
1279 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "\r\n");
1280 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "<html><head><title>Moved</title></head><body>\r\n");
1281 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "You should be <a href=\"%s\">redirected</a>.\r\n", stream->feed_filename);
1282 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "</body></html>\r\n");
1284 /* prepare output buffer */
1285 c->buffer_ptr = c->buffer;
1287 c->state = HTTPSTATE_SEND_HEADER;
1291 /* If this is WMP, get the rate information */
1292 if (extract_rates(ratebuf, sizeof(ratebuf), c->buffer)) {
1293 if (modify_current_stream(c, ratebuf)) {
1294 for (i = 0; i < sizeof(c->feed_streams) / sizeof(c->feed_streams[0]); i++) {
1295 if (c->switch_feed_streams[i] >= 0)
1296 do_switch_stream(c, i);
1301 /* If already streaming this feed, dont let start an another feeder */
1302 if (stream->feed_opened) {
1303 snprintf(msg, sizeof(msg), "This feed is already being received.");
1307 if (c->post == 0 && stream->stream_type == STREAM_TYPE_LIVE) {
1308 current_bandwidth += stream->bandwidth;
1311 if (c->post == 0 && max_bandwidth < current_bandwidth) {
1312 c->http_error = 200;
1314 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "HTTP/1.0 200 Server too busy\r\n");
1315 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "Content-type: text/html\r\n");
1316 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "\r\n");
1317 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "<html><head><title>Too busy</title></head><body>\r\n");
1318 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "<p>The server is too busy to serve your request at this time.</p>\r\n");
1319 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "<p>The bandwidth being served (including your stream) is %dkbit/sec, and this exceeds the limit of %dkbit/sec.</p>\r\n",
1320 current_bandwidth, max_bandwidth);
1321 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "</body></html>\r\n");
1323 /* prepare output buffer */
1324 c->buffer_ptr = c->buffer;
1326 c->state = HTTPSTATE_SEND_HEADER;
1330 if (redir_type != REDIR_NONE) {
1333 for (p = c->buffer; *p && *p != '\r' && *p != '\n'; ) {
1334 if (strncasecmp(p, "Host:", 5) == 0) {
1338 p = strchr(p, '\n');
1349 while (isspace(*hostinfo))
1352 eoh = strchr(hostinfo, '\n');
1354 if (eoh[-1] == '\r')
1357 if (eoh - hostinfo < sizeof(hostbuf) - 1) {
1358 memcpy(hostbuf, hostinfo, eoh - hostinfo);
1359 hostbuf[eoh - hostinfo] = 0;
1361 c->http_error = 200;
1363 switch(redir_type) {
1365 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "HTTP/1.0 200 ASX Follows\r\n");
1366 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "Content-type: video/x-ms-asf\r\n");
1367 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "\r\n");
1368 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "<ASX Version=\"3\">\r\n");
1369 //q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "<!-- Autogenerated by ffserver -->\r\n");
1370 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "<ENTRY><REF HREF=\"http://%s/%s%s\"/></ENTRY>\r\n",
1371 hostbuf, filename, info);
1372 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "</ASX>\r\n");
1375 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "HTTP/1.0 200 RAM Follows\r\n");
1376 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "Content-type: audio/x-pn-realaudio\r\n");
1377 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "\r\n");
1378 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "# Autogenerated by ffserver\r\n");
1379 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "http://%s/%s%s\r\n",
1380 hostbuf, filename, info);
1383 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "HTTP/1.0 200 ASF Redirect follows\r\n");
1384 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "Content-type: video/x-ms-asf\r\n");
1385 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "\r\n");
1386 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "[Reference]\r\n");
1387 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "Ref1=http://%s/%s%s\r\n",
1388 hostbuf, filename, info);
1392 char hostname[256], *p;
1393 /* extract only hostname */
1394 pstrcpy(hostname, sizeof(hostname), hostbuf);
1395 p = strrchr(hostname, ':');
1398 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "HTTP/1.0 200 RTSP Redirect follows\r\n");
1399 /* XXX: incorrect mime type ? */
1400 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "Content-type: application/x-rtsp\r\n");
1401 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "\r\n");
1402 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "rtsp://%s:%d/%s\r\n",
1403 hostname, ntohs(my_rtsp_addr.sin_port),
1410 int sdp_data_size, len;
1411 struct sockaddr_in my_addr;
1413 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "HTTP/1.0 200 OK\r\n");
1414 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "Content-type: application/sdp\r\n");
1415 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "\r\n");
1417 len = sizeof(my_addr);
1418 getsockname(c->fd, (struct sockaddr *)&my_addr, &len);
1420 /* XXX: should use a dynamic buffer */
1421 sdp_data_size = prepare_sdp_description(stream,
1424 if (sdp_data_size > 0) {
1425 memcpy(q, sdp_data, sdp_data_size);
1437 /* prepare output buffer */
1438 c->buffer_ptr = c->buffer;
1440 c->state = HTTPSTATE_SEND_HEADER;
1446 snprintf(msg, sizeof(msg), "ASX/RAM file not handled");
1450 stream->conns_served++;
1452 /* XXX: add there authenticate and IP match */
1455 /* if post, it means a feed is being sent */
1456 if (!stream->is_feed) {
1457 /* However it might be a status report from WMP! Lets log the data
1458 * as it might come in handy one day
1463 for (p = c->buffer; *p && *p != '\r' && *p != '\n'; ) {
1464 if (strncasecmp(p, "Pragma: log-line=", 17) == 0) {
1468 if (strncasecmp(p, "Pragma: client-id=", 18) == 0) {
1469 client_id = strtol(p + 18, 0, 10);
1471 p = strchr(p, '\n');
1479 char *eol = strchr(logline, '\n');
1484 if (eol[-1] == '\r')
1486 http_log("%.*s\n", (int) (eol - logline), logline);
1487 c->suppress_log = 1;
1492 http_log("\nGot request:\n%s\n", c->buffer);
1495 if (client_id && extract_rates(ratebuf, sizeof(ratebuf), c->buffer)) {
1498 /* Now we have to find the client_id */
1499 for (wmpc = first_http_ctx; wmpc; wmpc = wmpc->next) {
1500 if (wmpc->wmp_client_id == client_id)
1505 if (modify_current_stream(wmpc, ratebuf)) {
1506 wmpc->switch_pending = 1;
1511 snprintf(msg, sizeof(msg), "POST command not handled");
1515 if (http_start_receive_data(c) < 0) {
1516 snprintf(msg, sizeof(msg), "could not open feed");
1520 c->state = HTTPSTATE_RECEIVE_DATA;
1525 if (strcmp(stream->filename + strlen(stream->filename) - 4, ".asf") == 0) {
1526 http_log("\nGot request:\n%s\n", c->buffer);
1530 if (c->stream->stream_type == STREAM_TYPE_STATUS)
1533 /* open input stream */
1534 if (open_input_stream(c, info) < 0) {
1535 snprintf(msg, sizeof(msg), "Input stream corresponding to '%s' not found", url);
1539 /* prepare http header */
1541 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "HTTP/1.0 200 OK\r\n");
1542 mime_type = c->stream->fmt->mime_type;
1544 mime_type = "application/x-octet-stream";
1545 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "Pragma: no-cache\r\n");
1547 /* for asf, we need extra headers */
1548 if (!strcmp(c->stream->fmt->name,"asf_stream")) {
1549 /* Need to allocate a client id */
1551 c->wmp_client_id = av_random(&random_state) & 0x7fffffff;
1553 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);
1555 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "Content-Type: %s\r\n", mime_type);
1556 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "\r\n");
1558 /* prepare output buffer */
1560 c->buffer_ptr = c->buffer;
1562 c->state = HTTPSTATE_SEND_HEADER;
1565 c->http_error = 404;
1567 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "HTTP/1.0 404 Not Found\r\n");
1568 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "Content-type: %s\r\n", "text/html");
1569 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "\r\n");
1570 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "<HTML>\n");
1571 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "<HEAD><TITLE>404 Not Found</TITLE></HEAD>\n");
1572 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "<BODY>%s</BODY>\n", msg);
1573 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "</HTML>\n");
1575 /* prepare output buffer */
1576 c->buffer_ptr = c->buffer;
1578 c->state = HTTPSTATE_SEND_HEADER;
1582 c->http_error = 200; /* horrible : we use this value to avoid
1583 going to the send data state */
1584 c->state = HTTPSTATE_SEND_HEADER;
1588 static void fmt_bytecount(ByteIOContext *pb, int64_t count)
1590 static const char *suffix = " kMGTP";
1593 for (s = suffix; count >= 100000 && s[1]; count /= 1000, s++) {
1596 url_fprintf(pb, "%"PRId64"%c", count, *s);
1599 static void compute_stats(HTTPContext *c)
1606 ByteIOContext pb1, *pb = &pb1;
1608 if (url_open_dyn_buf(pb) < 0) {
1609 /* XXX: return an error ? */
1610 c->buffer_ptr = c->buffer;
1611 c->buffer_end = c->buffer;
1615 url_fprintf(pb, "HTTP/1.0 200 OK\r\n");
1616 url_fprintf(pb, "Content-type: %s\r\n", "text/html");
1617 url_fprintf(pb, "Pragma: no-cache\r\n");
1618 url_fprintf(pb, "\r\n");
1620 url_fprintf(pb, "<HEAD><TITLE>FFServer Status</TITLE>\n");
1621 if (c->stream->feed_filename) {
1622 url_fprintf(pb, "<link rel=\"shortcut icon\" href=\"%s\">\n", c->stream->feed_filename);
1624 url_fprintf(pb, "</HEAD>\n<BODY>");
1625 url_fprintf(pb, "<H1>FFServer Status</H1>\n");
1627 url_fprintf(pb, "<H2>Available Streams</H2>\n");
1628 url_fprintf(pb, "<TABLE cellspacing=0 cellpadding=4>\n");
1629 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");
1630 stream = first_stream;
1631 while (stream != NULL) {
1632 char sfilename[1024];
1635 if (stream->feed != stream) {
1636 pstrcpy(sfilename, sizeof(sfilename) - 10, stream->filename);
1637 eosf = sfilename + strlen(sfilename);
1638 if (eosf - sfilename >= 4) {
1639 if (strcmp(eosf - 4, ".asf") == 0) {
1640 strcpy(eosf - 4, ".asx");
1641 } else if (strcmp(eosf - 3, ".rm") == 0) {
1642 strcpy(eosf - 3, ".ram");
1643 } else if (stream->fmt == &rtp_muxer) {
1644 /* generate a sample RTSP director if
1645 unicast. Generate an SDP redirector if
1647 eosf = strrchr(sfilename, '.');
1649 eosf = sfilename + strlen(sfilename);
1650 if (stream->is_multicast)
1651 strcpy(eosf, ".sdp");
1653 strcpy(eosf, ".rtsp");
1657 url_fprintf(pb, "<TR><TD><A HREF=\"/%s\">%s</A> ",
1658 sfilename, stream->filename);
1659 url_fprintf(pb, "<td align=right> %d <td align=right> ",
1660 stream->conns_served);
1661 fmt_bytecount(pb, stream->bytes_served);
1662 switch(stream->stream_type) {
1663 case STREAM_TYPE_LIVE:
1665 int audio_bit_rate = 0;
1666 int video_bit_rate = 0;
1667 const char *audio_codec_name = "";
1668 const char *video_codec_name = "";
1669 const char *audio_codec_name_extra = "";
1670 const char *video_codec_name_extra = "";
1672 for(i=0;i<stream->nb_streams;i++) {
1673 AVStream *st = stream->streams[i];
1674 AVCodec *codec = avcodec_find_encoder(st->codec->codec_id);
1675 switch(st->codec->codec_type) {
1676 case CODEC_TYPE_AUDIO:
1677 audio_bit_rate += st->codec->bit_rate;
1679 if (*audio_codec_name)
1680 audio_codec_name_extra = "...";
1681 audio_codec_name = codec->name;
1684 case CODEC_TYPE_VIDEO:
1685 video_bit_rate += st->codec->bit_rate;
1687 if (*video_codec_name)
1688 video_codec_name_extra = "...";
1689 video_codec_name = codec->name;
1692 case CODEC_TYPE_DATA:
1693 video_bit_rate += st->codec->bit_rate;
1699 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",
1702 video_bit_rate / 1000, video_codec_name, video_codec_name_extra,
1703 audio_bit_rate / 1000, audio_codec_name, audio_codec_name_extra);
1705 url_fprintf(pb, "<TD>%s", stream->feed->filename);
1707 url_fprintf(pb, "<TD>%s", stream->feed_filename);
1709 url_fprintf(pb, "\n");
1713 url_fprintf(pb, "<TD align=center> - <TD align=right> - <TD align=right> - <td><td align=right> - <TD>\n");
1717 stream = stream->next;
1719 url_fprintf(pb, "</TABLE>\n");
1721 stream = first_stream;
1722 while (stream != NULL) {
1723 if (stream->feed == stream) {
1724 url_fprintf(pb, "<h2>Feed %s</h2>", stream->filename);
1726 url_fprintf(pb, "Running as pid %d.\n", stream->pid);
1728 #if defined(linux) && !defined(CONFIG_NOCUTILS)
1733 /* This is somewhat linux specific I guess */
1734 snprintf(ps_cmd, sizeof(ps_cmd),
1735 "ps -o \"%%cpu,cputime\" --no-headers %d",
1738 pid_stat = popen(ps_cmd, "r");
1743 if (fscanf(pid_stat, "%10s %64s", cpuperc,
1745 url_fprintf(pb, "Currently using %s%% of the cpu. Total time used %s.\n",
1753 url_fprintf(pb, "<p>");
1755 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");
1757 for (i = 0; i < stream->nb_streams; i++) {
1758 AVStream *st = stream->streams[i];
1759 AVCodec *codec = avcodec_find_encoder(st->codec->codec_id);
1760 const char *type = "unknown";
1761 char parameters[64];
1765 switch(st->codec->codec_type) {
1766 case CODEC_TYPE_AUDIO:
1768 snprintf(parameters, sizeof(parameters), "%d channel(s), %d Hz", st->codec->channels, st->codec->sample_rate);
1770 case CODEC_TYPE_VIDEO:
1772 snprintf(parameters, sizeof(parameters), "%dx%d, q=%d-%d, fps=%d", st->codec->width, st->codec->height,
1773 st->codec->qmin, st->codec->qmax, st->codec->time_base.den / st->codec->time_base.num);
1778 url_fprintf(pb, "<tr><td align=right>%d<td>%s<td align=right>%d<td>%s<td>%s\n",
1779 i, type, st->codec->bit_rate/1000, codec ? codec->name : "", parameters);
1781 url_fprintf(pb, "</table>\n");
1784 stream = stream->next;
1790 AVCodecContext *enc;
1794 stream = first_feed;
1795 while (stream != NULL) {
1796 url_fprintf(pb, "<H1>Feed '%s'</H1>\n", stream->filename);
1797 url_fprintf(pb, "<TABLE>\n");
1798 url_fprintf(pb, "<TR><TD>Parameters<TD>Frame count<TD>Size<TD>Avg bitrate (kbits/s)\n");
1799 for(i=0;i<stream->nb_streams;i++) {
1800 AVStream *st = stream->streams[i];
1801 FeedData *fdata = st->priv_data;
1804 avcodec_string(buf, sizeof(buf), enc);
1805 avg = fdata->avg_frame_size * (float)enc->rate * 8.0;
1806 if (enc->codec->type == CODEC_TYPE_AUDIO && enc->frame_size > 0)
1807 avg /= enc->frame_size;
1808 url_fprintf(pb, "<TR><TD>%s <TD> %d <TD> %"PRId64" <TD> %0.1f\n",
1809 buf, enc->frame_number, fdata->data_count, avg / 1000.0);
1811 url_fprintf(pb, "</TABLE>\n");
1812 stream = stream->next_feed;
1817 /* connection status */
1818 url_fprintf(pb, "<H2>Connection Status</H2>\n");
1820 url_fprintf(pb, "Number of connections: %d / %d<BR>\n",
1821 nb_connections, nb_max_connections);
1823 url_fprintf(pb, "Bandwidth in use: %dk / %dk<BR>\n",
1824 current_bandwidth, max_bandwidth);
1826 url_fprintf(pb, "<TABLE>\n");
1827 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");
1828 c1 = first_http_ctx;
1830 while (c1 != NULL) {
1836 for (j = 0; j < c1->stream->nb_streams; j++) {
1837 if (!c1->stream->feed) {
1838 bitrate += c1->stream->streams[j]->codec->bit_rate;
1840 if (c1->feed_streams[j] >= 0) {
1841 bitrate += c1->stream->feed->streams[c1->feed_streams[j]]->codec->bit_rate;
1848 p = inet_ntoa(c1->from_addr.sin_addr);
1849 url_fprintf(pb, "<TR><TD><B>%d</B><TD>%s%s<TD>%s<TD>%s<TD>%s<td align=right>",
1851 c1->stream ? c1->stream->filename : "",
1852 c1->state == HTTPSTATE_RECEIVE_DATA ? "(input)" : "",
1855 http_state[c1->state]);
1856 fmt_bytecount(pb, bitrate);
1857 url_fprintf(pb, "<td align=right>");
1858 fmt_bytecount(pb, compute_datarate(&c1->datarate, c1->data_count) * 8);
1859 url_fprintf(pb, "<td align=right>");
1860 fmt_bytecount(pb, c1->data_count);
1861 url_fprintf(pb, "\n");
1864 url_fprintf(pb, "</TABLE>\n");
1869 url_fprintf(pb, "<HR size=1 noshade>Generated at %s", p);
1870 url_fprintf(pb, "</BODY>\n</HTML>\n");
1872 len = url_close_dyn_buf(pb, &c->pb_buffer);
1873 c->buffer_ptr = c->pb_buffer;
1874 c->buffer_end = c->pb_buffer + len;
1877 /* check if the parser needs to be opened for stream i */
1878 static void open_parser(AVFormatContext *s, int i)
1880 AVStream *st = s->streams[i];
1883 if (!st->codec->codec) {
1884 codec = avcodec_find_decoder(st->codec->codec_id);
1885 if (codec && (codec->capabilities & CODEC_CAP_PARSE_ONLY)) {
1886 st->codec->parse_only = 1;
1887 if (avcodec_open(st->codec, codec) < 0) {
1888 st->codec->parse_only = 0;
1894 static int open_input_stream(HTTPContext *c, const char *info)
1897 char input_filename[1024];
1902 /* find file name */
1903 if (c->stream->feed) {
1904 strcpy(input_filename, c->stream->feed->feed_filename);
1905 buf_size = FFM_PACKET_SIZE;
1906 /* compute position (absolute time) */
1907 if (find_info_tag(buf, sizeof(buf), "date", info)) {
1908 stream_pos = parse_date(buf, 0);
1909 } else if (find_info_tag(buf, sizeof(buf), "buffer", info)) {
1910 int prebuffer = strtol(buf, 0, 10);
1911 stream_pos = av_gettime() - prebuffer * (int64_t)1000000;
1913 stream_pos = av_gettime() - c->stream->prebuffer * (int64_t)1000;
1916 strcpy(input_filename, c->stream->feed_filename);
1918 /* compute position (relative time) */
1919 if (find_info_tag(buf, sizeof(buf), "date", info)) {
1920 stream_pos = parse_date(buf, 1);
1925 if (input_filename[0] == '\0')
1929 { time_t when = stream_pos / 1000000;
1930 http_log("Stream pos = %"PRId64", time=%s", stream_pos, ctime(&when));
1935 if (av_open_input_file(&s, input_filename, c->stream->ifmt,
1936 buf_size, c->stream->ap_in) < 0) {
1937 http_log("%s not found", input_filename);
1942 /* open each parser */
1943 for(i=0;i<s->nb_streams;i++)
1946 /* choose stream as clock source (we favorize video stream if
1947 present) for packet sending */
1948 c->pts_stream_index = 0;
1949 for(i=0;i<c->stream->nb_streams;i++) {
1950 if (c->pts_stream_index == 0 &&
1951 c->stream->streams[i]->codec->codec_type == CODEC_TYPE_VIDEO) {
1952 c->pts_stream_index = i;
1957 if (c->fmt_in->iformat->read_seek) {
1958 c->fmt_in->iformat->read_seek(c->fmt_in, 0, stream_pos, 0);
1961 /* set the start time (needed for maxtime and RTP packet timing) */
1962 c->start_time = cur_time;
1963 c->first_pts = AV_NOPTS_VALUE;
1967 /* return the server clock (in us) */
1968 static int64_t get_server_clock(HTTPContext *c)
1970 /* compute current pts value from system time */
1971 return (cur_time - c->start_time) * 1000;
1974 /* return the estimated time at which the current packet must be sent
1976 static int64_t get_packet_send_clock(HTTPContext *c)
1978 int bytes_left, bytes_sent, frame_bytes;
1980 frame_bytes = c->cur_frame_bytes;
1981 if (frame_bytes <= 0) {
1984 bytes_left = c->buffer_end - c->buffer_ptr;
1985 bytes_sent = frame_bytes - bytes_left;
1986 return c->cur_pts + (c->cur_frame_duration * bytes_sent) / frame_bytes;
1991 static int http_prepare_data(HTTPContext *c)
1994 AVFormatContext *ctx;
1996 av_freep(&c->pb_buffer);
1998 case HTTPSTATE_SEND_DATA_HEADER:
1999 memset(&c->fmt_ctx, 0, sizeof(c->fmt_ctx));
2000 pstrcpy(c->fmt_ctx.author, sizeof(c->fmt_ctx.author),
2002 pstrcpy(c->fmt_ctx.comment, sizeof(c->fmt_ctx.comment),
2003 c->stream->comment);
2004 pstrcpy(c->fmt_ctx.copyright, sizeof(c->fmt_ctx.copyright),
2005 c->stream->copyright);
2006 pstrcpy(c->fmt_ctx.title, sizeof(c->fmt_ctx.title),
2009 /* open output stream by using specified codecs */
2010 c->fmt_ctx.oformat = c->stream->fmt;
2011 c->fmt_ctx.nb_streams = c->stream->nb_streams;
2012 for(i=0;i<c->fmt_ctx.nb_streams;i++) {
2015 st = av_mallocz(sizeof(AVStream));
2016 st->codec= avcodec_alloc_context();
2017 c->fmt_ctx.streams[i] = st;
2018 /* if file or feed, then just take streams from FFStream struct */
2019 if (!c->stream->feed ||
2020 c->stream->feed == c->stream)
2021 src = c->stream->streams[i];
2023 src = c->stream->feed->streams[c->stream->feed_streams[i]];
2027 st->codec->frame_number = 0; /* XXX: should be done in
2028 AVStream, not in codec */
2029 /* I'm pretty sure that this is not correct...
2030 * However, without it, we crash
2032 st->codec->coded_frame = &dummy_frame;
2034 c->got_key_frame = 0;
2036 /* prepare header and save header data in a stream */
2037 if (url_open_dyn_buf(&c->fmt_ctx.pb) < 0) {
2038 /* XXX: potential leak */
2041 c->fmt_ctx.pb.is_streamed = 1;
2043 av_set_parameters(&c->fmt_ctx, NULL);
2044 if (av_write_header(&c->fmt_ctx) < 0)
2047 len = url_close_dyn_buf(&c->fmt_ctx.pb, &c->pb_buffer);
2048 c->buffer_ptr = c->pb_buffer;
2049 c->buffer_end = c->pb_buffer + len;
2051 c->state = HTTPSTATE_SEND_DATA;
2052 c->last_packet_sent = 0;
2054 case HTTPSTATE_SEND_DATA:
2055 /* find a new packet */
2059 /* read a packet from the input stream */
2060 if (c->stream->feed) {
2061 ffm_set_write_index(c->fmt_in,
2062 c->stream->feed->feed_write_index,
2063 c->stream->feed->feed_size);
2066 if (c->stream->max_time &&
2067 c->stream->max_time + c->start_time - cur_time < 0) {
2068 /* We have timed out */
2069 c->state = HTTPSTATE_SEND_DATA_TRAILER;
2072 if (av_read_frame(c->fmt_in, &pkt) < 0) {
2073 if (c->stream->feed && c->stream->feed->feed_opened) {
2074 /* if coming from feed, it means we reached the end of the
2075 ffm file, so must wait for more data */
2076 c->state = HTTPSTATE_WAIT_FEED;
2077 return 1; /* state changed */
2079 if (c->stream->loop) {
2080 av_close_input_file(c->fmt_in);
2082 if (open_input_stream(c, "") < 0)
2087 /* must send trailer now because eof or error */
2088 c->state = HTTPSTATE_SEND_DATA_TRAILER;
2092 /* update first pts if needed */
2093 if (c->first_pts == AV_NOPTS_VALUE) {
2094 c->first_pts = av_rescale_q(pkt.dts, c->fmt_in->streams[pkt.stream_index]->time_base, AV_TIME_BASE_Q);
2095 c->start_time = cur_time;
2097 /* send it to the appropriate stream */
2098 if (c->stream->feed) {
2099 /* if coming from a feed, select the right stream */
2100 if (c->switch_pending) {
2101 c->switch_pending = 0;
2102 for(i=0;i<c->stream->nb_streams;i++) {
2103 if (c->switch_feed_streams[i] == pkt.stream_index) {
2104 if (pkt.flags & PKT_FLAG_KEY) {
2105 do_switch_stream(c, i);
2108 if (c->switch_feed_streams[i] >= 0) {
2109 c->switch_pending = 1;
2113 for(i=0;i<c->stream->nb_streams;i++) {
2114 if (c->feed_streams[i] == pkt.stream_index) {
2115 pkt.stream_index = i;
2116 if (pkt.flags & PKT_FLAG_KEY) {
2117 c->got_key_frame |= 1 << i;
2119 /* See if we have all the key frames, then
2120 * we start to send. This logic is not quite
2121 * right, but it works for the case of a
2122 * single video stream with one or more
2123 * audio streams (for which every frame is
2124 * typically a key frame).
2126 if (!c->stream->send_on_key ||
2127 ((c->got_key_frame + 1) >> c->stream->nb_streams)) {
2133 AVCodecContext *codec;
2136 /* specific handling for RTP: we use several
2137 output stream (one for each RTP
2138 connection). XXX: need more abstract handling */
2139 if (c->is_packetized) {
2141 /* compute send time and duration */
2142 st = c->fmt_in->streams[pkt.stream_index];
2143 c->cur_pts = av_rescale_q(pkt.dts, st->time_base, AV_TIME_BASE_Q);
2144 if (st->start_time != AV_NOPTS_VALUE)
2145 c->cur_pts -= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
2146 c->cur_frame_duration = av_rescale_q(pkt.duration, st->time_base, AV_TIME_BASE_Q);
2148 printf("index=%d pts=%0.3f duration=%0.6f\n",
2150 (double)c->cur_pts /
2152 (double)c->cur_frame_duration /
2155 /* find RTP context */
2156 c->packet_stream_index = pkt.stream_index;
2157 ctx = c->rtp_ctx[c->packet_stream_index];
2159 av_free_packet(&pkt);
2162 codec = ctx->streams[0]->codec;
2163 /* only one stream per RTP connection */
2164 pkt.stream_index = 0;
2168 codec = ctx->streams[pkt.stream_index]->codec;
2171 codec->coded_frame->key_frame = ((pkt.flags & PKT_FLAG_KEY) != 0);
2172 if (c->is_packetized) {
2173 int max_packet_size;
2174 if (c->rtp_protocol == RTSP_PROTOCOL_RTP_TCP)
2175 max_packet_size = RTSP_TCP_MAX_PACKET_SIZE;
2177 max_packet_size = url_get_max_packet_size(c->rtp_handles[c->packet_stream_index]);
2178 ret = url_open_dyn_packet_buf(&ctx->pb, max_packet_size);
2180 ret = url_open_dyn_buf(&ctx->pb);
2183 /* XXX: potential leak */
2186 if (pkt.dts != AV_NOPTS_VALUE)
2187 pkt.dts = av_rescale_q(pkt.dts,
2188 c->fmt_in->streams[pkt.stream_index]->time_base,
2189 ctx->streams[pkt.stream_index]->time_base);
2190 if (pkt.pts != AV_NOPTS_VALUE)
2191 pkt.pts = av_rescale_q(pkt.pts,
2192 c->fmt_in->streams[pkt.stream_index]->time_base,
2193 ctx->streams[pkt.stream_index]->time_base);
2194 if (av_write_frame(ctx, &pkt)) {
2195 c->state = HTTPSTATE_SEND_DATA_TRAILER;
2198 len = url_close_dyn_buf(&ctx->pb, &c->pb_buffer);
2199 c->cur_frame_bytes = len;
2200 c->buffer_ptr = c->pb_buffer;
2201 c->buffer_end = c->pb_buffer + len;
2203 codec->frame_number++;
2207 av_free_packet(&pkt);
2213 case HTTPSTATE_SEND_DATA_TRAILER:
2214 /* last packet test ? */
2215 if (c->last_packet_sent || c->is_packetized)
2218 /* prepare header */
2219 if (url_open_dyn_buf(&ctx->pb) < 0) {
2220 /* XXX: potential leak */
2223 av_write_trailer(ctx);
2224 len = url_close_dyn_buf(&ctx->pb, &c->pb_buffer);
2225 c->buffer_ptr = c->pb_buffer;
2226 c->buffer_end = c->pb_buffer + len;
2228 c->last_packet_sent = 1;
2234 /* should convert the format at the same time */
2235 /* send data starting at c->buffer_ptr to the output connection
2236 (either UDP or TCP connection) */
2237 static int http_send_data(HTTPContext *c)
2242 if (c->buffer_ptr >= c->buffer_end) {
2243 ret = http_prepare_data(c);
2246 else if (ret != 0) {
2247 /* state change requested */
2251 if (c->is_packetized) {
2252 /* RTP data output */
2253 len = c->buffer_end - c->buffer_ptr;
2255 /* fail safe - should never happen */
2257 c->buffer_ptr = c->buffer_end;
2260 len = (c->buffer_ptr[0] << 24) |
2261 (c->buffer_ptr[1] << 16) |
2262 (c->buffer_ptr[2] << 8) |
2264 if (len > (c->buffer_end - c->buffer_ptr))
2266 if ((get_packet_send_clock(c) - get_server_clock(c)) > 0) {
2267 /* nothing to send yet: we can wait */
2271 c->data_count += len;
2272 update_datarate(&c->datarate, c->data_count);
2274 c->stream->bytes_served += len;
2276 if (c->rtp_protocol == RTSP_PROTOCOL_RTP_TCP) {
2277 /* RTP packets are sent inside the RTSP TCP connection */
2278 ByteIOContext pb1, *pb = &pb1;
2279 int interleaved_index, size;
2281 HTTPContext *rtsp_c;
2284 /* if no RTSP connection left, error */
2287 /* if already sending something, then wait. */
2288 if (rtsp_c->state != RTSPSTATE_WAIT_REQUEST) {
2291 if (url_open_dyn_buf(pb) < 0)
2293 interleaved_index = c->packet_stream_index * 2;
2294 /* RTCP packets are sent at odd indexes */
2295 if (c->buffer_ptr[1] == 200)
2296 interleaved_index++;
2297 /* write RTSP TCP header */
2299 header[1] = interleaved_index;
2300 header[2] = len >> 8;
2302 put_buffer(pb, header, 4);
2303 /* write RTP packet data */
2305 put_buffer(pb, c->buffer_ptr, len);
2306 size = url_close_dyn_buf(pb, &c->packet_buffer);
2307 /* prepare asynchronous TCP sending */
2308 rtsp_c->packet_buffer_ptr = c->packet_buffer;
2309 rtsp_c->packet_buffer_end = c->packet_buffer + size;
2310 c->buffer_ptr += len;
2312 /* send everything we can NOW */
2313 len = send(rtsp_c->fd, rtsp_c->packet_buffer_ptr,
2314 rtsp_c->packet_buffer_end - rtsp_c->packet_buffer_ptr, 0);
2316 rtsp_c->packet_buffer_ptr += len;
2318 if (rtsp_c->packet_buffer_ptr < rtsp_c->packet_buffer_end) {
2319 /* if we could not send all the data, we will
2320 send it later, so a new state is needed to
2321 "lock" the RTSP TCP connection */
2322 rtsp_c->state = RTSPSTATE_SEND_PACKET;
2325 /* all data has been sent */
2326 av_freep(&c->packet_buffer);
2329 /* send RTP packet directly in UDP */
2331 url_write(c->rtp_handles[c->packet_stream_index],
2332 c->buffer_ptr, len);
2333 c->buffer_ptr += len;
2334 /* here we continue as we can send several packets per 10 ms slot */
2337 /* TCP data output */
2338 len = send(c->fd, c->buffer_ptr, c->buffer_end - c->buffer_ptr, 0);
2340 if (errno != EAGAIN && errno != EINTR) {
2341 /* error : close connection */
2347 c->buffer_ptr += len;
2349 c->data_count += len;
2350 update_datarate(&c->datarate, c->data_count);
2352 c->stream->bytes_served += len;
2360 static int http_start_receive_data(HTTPContext *c)
2364 if (c->stream->feed_opened)
2367 /* Don't permit writing to this one */
2368 if (c->stream->readonly)
2372 fd = open(c->stream->feed_filename, O_RDWR);
2377 c->stream->feed_write_index = ffm_read_write_index(fd);
2378 c->stream->feed_size = lseek(fd, 0, SEEK_END);
2379 lseek(fd, 0, SEEK_SET);
2381 /* init buffer input */
2382 c->buffer_ptr = c->buffer;
2383 c->buffer_end = c->buffer + FFM_PACKET_SIZE;
2384 c->stream->feed_opened = 1;
2388 static int http_receive_data(HTTPContext *c)
2392 if (c->buffer_end > c->buffer_ptr) {
2395 len = recv(c->fd, c->buffer_ptr, c->buffer_end - c->buffer_ptr, 0);
2397 if (errno != EAGAIN && errno != EINTR) {
2398 /* error : close connection */
2401 } else if (len == 0) {
2402 /* end of connection : close it */
2405 c->buffer_ptr += len;
2406 c->data_count += len;
2407 update_datarate(&c->datarate, c->data_count);
2411 if (c->buffer_ptr - c->buffer >= 2 && c->data_count > FFM_PACKET_SIZE) {
2412 if (c->buffer[0] != 'f' ||
2413 c->buffer[1] != 'm') {
2414 http_log("Feed stream has become desynchronized -- disconnecting\n");
2419 if (c->buffer_ptr >= c->buffer_end) {
2420 FFStream *feed = c->stream;
2421 /* a packet has been received : write it in the store, except
2423 if (c->data_count > FFM_PACKET_SIZE) {
2425 // printf("writing pos=0x%"PRIx64" size=0x%"PRIx64"\n", feed->feed_write_index, feed->feed_size);
2426 /* XXX: use llseek or url_seek */
2427 lseek(c->feed_fd, feed->feed_write_index, SEEK_SET);
2428 write(c->feed_fd, c->buffer, FFM_PACKET_SIZE);
2430 feed->feed_write_index += FFM_PACKET_SIZE;
2431 /* update file size */
2432 if (feed->feed_write_index > c->stream->feed_size)
2433 feed->feed_size = feed->feed_write_index;
2435 /* handle wrap around if max file size reached */
2436 if (c->stream->feed_max_size && feed->feed_write_index >= c->stream->feed_max_size)
2437 feed->feed_write_index = FFM_PACKET_SIZE;
2440 ffm_write_write_index(c->feed_fd, feed->feed_write_index);
2442 /* wake up any waiting connections */
2443 for(c1 = first_http_ctx; c1 != NULL; c1 = c1->next) {
2444 if (c1->state == HTTPSTATE_WAIT_FEED &&
2445 c1->stream->feed == c->stream->feed) {
2446 c1->state = HTTPSTATE_SEND_DATA;
2450 /* We have a header in our hands that contains useful data */
2452 AVInputFormat *fmt_in;
2453 ByteIOContext *pb = &s.pb;
2456 memset(&s, 0, sizeof(s));
2458 url_open_buf(pb, c->buffer, c->buffer_end - c->buffer, URL_RDONLY);
2459 pb->buf_end = c->buffer_end; /* ?? */
2460 pb->is_streamed = 1;
2462 /* use feed output format name to find corresponding input format */
2463 fmt_in = av_find_input_format(feed->fmt->name);
2467 if (fmt_in->priv_data_size > 0) {
2468 s.priv_data = av_mallocz(fmt_in->priv_data_size);
2474 if (fmt_in->read_header(&s, 0) < 0) {
2475 av_freep(&s.priv_data);
2479 /* Now we have the actual streams */
2480 if (s.nb_streams != feed->nb_streams) {
2481 av_freep(&s.priv_data);
2484 for (i = 0; i < s.nb_streams; i++) {
2485 memcpy(feed->streams[i]->codec,
2486 s.streams[i]->codec, sizeof(AVCodecContext));
2488 av_freep(&s.priv_data);
2490 c->buffer_ptr = c->buffer;
2495 c->stream->feed_opened = 0;
2500 /********************************************************************/
2503 static void rtsp_reply_header(HTTPContext *c, enum RTSPStatusCode error_number)
2510 switch(error_number) {
2511 case RTSP_STATUS_OK:
2514 case RTSP_STATUS_METHOD:
2515 str = "Method Not Allowed";
2517 case RTSP_STATUS_BANDWIDTH:
2518 str = "Not Enough Bandwidth";
2520 case RTSP_STATUS_SESSION:
2521 str = "Session Not Found";
2523 case RTSP_STATUS_STATE:
2524 str = "Method Not Valid in This State";
2526 case RTSP_STATUS_AGGREGATE:
2527 str = "Aggregate operation not allowed";
2529 case RTSP_STATUS_ONLY_AGGREGATE:
2530 str = "Only aggregate operation allowed";
2532 case RTSP_STATUS_TRANSPORT:
2533 str = "Unsupported transport";
2535 case RTSP_STATUS_INTERNAL:
2536 str = "Internal Server Error";
2538 case RTSP_STATUS_SERVICE:
2539 str = "Service Unavailable";
2541 case RTSP_STATUS_VERSION:
2542 str = "RTSP Version not supported";
2545 str = "Unknown Error";
2549 url_fprintf(c->pb, "RTSP/1.0 %d %s\r\n", error_number, str);
2550 url_fprintf(c->pb, "CSeq: %d\r\n", c->seq);
2552 /* output GMT time */
2556 p = buf2 + strlen(p) - 1;
2559 url_fprintf(c->pb, "Date: %s GMT\r\n", buf2);
2562 static void rtsp_reply_error(HTTPContext *c, enum RTSPStatusCode error_number)
2564 rtsp_reply_header(c, error_number);
2565 url_fprintf(c->pb, "\r\n");
2568 static int rtsp_parse_request(HTTPContext *c)
2570 const char *p, *p1, *p2;
2577 RTSPHeader header1, *header = &header1;
2579 c->buffer_ptr[0] = '\0';
2582 get_word(cmd, sizeof(cmd), &p);
2583 get_word(url, sizeof(url), &p);
2584 get_word(protocol, sizeof(protocol), &p);
2586 pstrcpy(c->method, sizeof(c->method), cmd);
2587 pstrcpy(c->url, sizeof(c->url), url);
2588 pstrcpy(c->protocol, sizeof(c->protocol), protocol);
2591 if (url_open_dyn_buf(c->pb) < 0) {
2592 /* XXX: cannot do more */
2593 c->pb = NULL; /* safety */
2597 /* check version name */
2598 if (strcmp(protocol, "RTSP/1.0") != 0) {
2599 rtsp_reply_error(c, RTSP_STATUS_VERSION);
2603 /* parse each header line */
2604 memset(header, 0, sizeof(RTSPHeader));
2605 /* skip to next line */
2606 while (*p != '\n' && *p != '\0')
2610 while (*p != '\0') {
2611 p1 = strchr(p, '\n');
2615 if (p2 > p && p2[-1] == '\r')
2617 /* skip empty line */
2621 if (len > sizeof(line) - 1)
2622 len = sizeof(line) - 1;
2623 memcpy(line, p, len);
2625 rtsp_parse_line(header, line);
2629 /* handle sequence number */
2630 c->seq = header->seq;
2632 if (!strcmp(cmd, "DESCRIBE")) {
2633 rtsp_cmd_describe(c, url);
2634 } else if (!strcmp(cmd, "OPTIONS")) {
2635 rtsp_cmd_options(c, url);
2636 } else if (!strcmp(cmd, "SETUP")) {
2637 rtsp_cmd_setup(c, url, header);
2638 } else if (!strcmp(cmd, "PLAY")) {
2639 rtsp_cmd_play(c, url, header);
2640 } else if (!strcmp(cmd, "PAUSE")) {
2641 rtsp_cmd_pause(c, url, header);
2642 } else if (!strcmp(cmd, "TEARDOWN")) {
2643 rtsp_cmd_teardown(c, url, header);
2645 rtsp_reply_error(c, RTSP_STATUS_METHOD);
2648 len = url_close_dyn_buf(c->pb, &c->pb_buffer);
2649 c->pb = NULL; /* safety */
2651 /* XXX: cannot do more */
2654 c->buffer_ptr = c->pb_buffer;
2655 c->buffer_end = c->pb_buffer + len;
2656 c->state = RTSPSTATE_SEND_REPLY;
2660 /* XXX: move that to rtsp.c, but would need to replace FFStream by
2662 static int prepare_sdp_description(FFStream *stream, uint8_t **pbuffer,
2663 struct in_addr my_ip)
2665 ByteIOContext pb1, *pb = &pb1;
2666 int i, payload_type, port, private_payload_type, j;
2667 const char *ipstr, *title, *mediatype;
2670 if (url_open_dyn_buf(pb) < 0)
2673 /* general media info */
2675 url_fprintf(pb, "v=0\n");
2676 ipstr = inet_ntoa(my_ip);
2677 url_fprintf(pb, "o=- 0 0 IN IP4 %s\n", ipstr);
2678 title = stream->title;
2679 if (title[0] == '\0')
2681 url_fprintf(pb, "s=%s\n", title);
2682 if (stream->comment[0] != '\0')
2683 url_fprintf(pb, "i=%s\n", stream->comment);
2684 if (stream->is_multicast) {
2685 url_fprintf(pb, "c=IN IP4 %s\n", inet_ntoa(stream->multicast_ip));
2687 /* for each stream, we output the necessary info */
2688 private_payload_type = RTP_PT_PRIVATE;
2689 for(i = 0; i < stream->nb_streams; i++) {
2690 st = stream->streams[i];
2691 if (st->codec->codec_id == CODEC_ID_MPEG2TS) {
2692 mediatype = "video";
2694 switch(st->codec->codec_type) {
2695 case CODEC_TYPE_AUDIO:
2696 mediatype = "audio";
2698 case CODEC_TYPE_VIDEO:
2699 mediatype = "video";
2702 mediatype = "application";
2706 /* NOTE: the port indication is not correct in case of
2707 unicast. It is not an issue because RTSP gives it */
2708 payload_type = rtp_get_payload_type(st->codec);
2709 if (payload_type < 0)
2710 payload_type = private_payload_type++;
2711 if (stream->is_multicast) {
2712 port = stream->multicast_port + 2 * i;
2716 url_fprintf(pb, "m=%s %d RTP/AVP %d\n",
2717 mediatype, port, payload_type);
2718 if (payload_type >= RTP_PT_PRIVATE) {
2719 /* for private payload type, we need to give more info */
2720 switch(st->codec->codec_id) {
2721 case CODEC_ID_MPEG4:
2724 url_fprintf(pb, "a=rtpmap:%d MP4V-ES/%d\n",
2725 payload_type, 90000);
2726 /* we must also add the mpeg4 header */
2727 data = st->codec->extradata;
2729 url_fprintf(pb, "a=fmtp:%d config=", payload_type);
2730 for(j=0;j<st->codec->extradata_size;j++) {
2731 url_fprintf(pb, "%02x", data[j]);
2733 url_fprintf(pb, "\n");
2738 /* XXX: add other codecs ? */
2742 url_fprintf(pb, "a=control:streamid=%d\n", i);
2744 return url_close_dyn_buf(pb, pbuffer);
2746 url_close_dyn_buf(pb, pbuffer);
2751 static void rtsp_cmd_options(HTTPContext *c, const char *url)
2753 // rtsp_reply_header(c, RTSP_STATUS_OK);
2754 url_fprintf(c->pb, "RTSP/1.0 %d %s\r\n", RTSP_STATUS_OK, "OK");
2755 url_fprintf(c->pb, "CSeq: %d\r\n", c->seq);
2756 url_fprintf(c->pb, "Public: %s\r\n", "OPTIONS, DESCRIBE, SETUP, TEARDOWN, PLAY, PAUSE");
2757 url_fprintf(c->pb, "\r\n");
2760 static void rtsp_cmd_describe(HTTPContext *c, const char *url)
2766 int content_length, len;
2767 struct sockaddr_in my_addr;
2769 /* find which url is asked */
2770 url_split(NULL, 0, NULL, 0, NULL, 0, NULL, path1, sizeof(path1), url);
2775 for(stream = first_stream; stream != NULL; stream = stream->next) {
2776 if (!stream->is_feed && stream->fmt == &rtp_muxer &&
2777 !strcmp(path, stream->filename)) {
2781 /* no stream found */
2782 rtsp_reply_error(c, RTSP_STATUS_SERVICE); /* XXX: right error ? */
2786 /* prepare the media description in sdp format */
2788 /* get the host IP */
2789 len = sizeof(my_addr);
2790 getsockname(c->fd, (struct sockaddr *)&my_addr, &len);
2791 content_length = prepare_sdp_description(stream, &content, my_addr.sin_addr);
2792 if (content_length < 0) {
2793 rtsp_reply_error(c, RTSP_STATUS_INTERNAL);
2796 rtsp_reply_header(c, RTSP_STATUS_OK);
2797 url_fprintf(c->pb, "Content-Type: application/sdp\r\n");
2798 url_fprintf(c->pb, "Content-Length: %d\r\n", content_length);
2799 url_fprintf(c->pb, "\r\n");
2800 put_buffer(c->pb, content, content_length);
2803 static HTTPContext *find_rtp_session(const char *session_id)
2807 if (session_id[0] == '\0')
2810 for(c = first_http_ctx; c != NULL; c = c->next) {
2811 if (!strcmp(c->session_id, session_id))
2817 static RTSPTransportField *find_transport(RTSPHeader *h, enum RTSPProtocol protocol)
2819 RTSPTransportField *th;
2822 for(i=0;i<h->nb_transports;i++) {
2823 th = &h->transports[i];
2824 if (th->protocol == protocol)
2830 static void rtsp_cmd_setup(HTTPContext *c, const char *url,
2834 int stream_index, port;
2839 RTSPTransportField *th;
2840 struct sockaddr_in dest_addr;
2841 RTSPActionServerSetup setup;
2843 /* find which url is asked */
2844 url_split(NULL, 0, NULL, 0, NULL, 0, NULL, path1, sizeof(path1), url);
2849 /* now check each stream */
2850 for(stream = first_stream; stream != NULL; stream = stream->next) {
2851 if (!stream->is_feed && stream->fmt == &rtp_muxer) {
2852 /* accept aggregate filenames only if single stream */
2853 if (!strcmp(path, stream->filename)) {
2854 if (stream->nb_streams != 1) {
2855 rtsp_reply_error(c, RTSP_STATUS_AGGREGATE);
2862 for(stream_index = 0; stream_index < stream->nb_streams;
2864 snprintf(buf, sizeof(buf), "%s/streamid=%d",
2865 stream->filename, stream_index);
2866 if (!strcmp(path, buf))
2871 /* no stream found */
2872 rtsp_reply_error(c, RTSP_STATUS_SERVICE); /* XXX: right error ? */
2876 /* generate session id if needed */
2877 if (h->session_id[0] == '\0') {
2878 snprintf(h->session_id, sizeof(h->session_id), "%08x%08x",
2879 av_random(&random_state), av_random(&random_state));
2882 /* find rtp session, and create it if none found */
2883 rtp_c = find_rtp_session(h->session_id);
2885 /* always prefer UDP */
2886 th = find_transport(h, RTSP_PROTOCOL_RTP_UDP);
2888 th = find_transport(h, RTSP_PROTOCOL_RTP_TCP);
2890 rtsp_reply_error(c, RTSP_STATUS_TRANSPORT);
2895 rtp_c = rtp_new_connection(&c->from_addr, stream, h->session_id,
2898 rtsp_reply_error(c, RTSP_STATUS_BANDWIDTH);
2902 /* open input stream */
2903 if (open_input_stream(rtp_c, "") < 0) {
2904 rtsp_reply_error(c, RTSP_STATUS_INTERNAL);
2909 /* test if stream is OK (test needed because several SETUP needs
2910 to be done for a given file) */
2911 if (rtp_c->stream != stream) {
2912 rtsp_reply_error(c, RTSP_STATUS_SERVICE);
2916 /* test if stream is already set up */
2917 if (rtp_c->rtp_ctx[stream_index]) {
2918 rtsp_reply_error(c, RTSP_STATUS_STATE);
2922 /* check transport */
2923 th = find_transport(h, rtp_c->rtp_protocol);
2924 if (!th || (th->protocol == RTSP_PROTOCOL_RTP_UDP &&
2925 th->client_port_min <= 0)) {
2926 rtsp_reply_error(c, RTSP_STATUS_TRANSPORT);
2930 /* setup default options */
2931 setup.transport_option[0] = '\0';
2932 dest_addr = rtp_c->from_addr;
2933 dest_addr.sin_port = htons(th->client_port_min);
2935 /* add transport option if needed */
2936 if (ff_rtsp_callback) {
2937 setup.ipaddr = ntohl(dest_addr.sin_addr.s_addr);
2938 if (ff_rtsp_callback(RTSP_ACTION_SERVER_SETUP, rtp_c->session_id,
2939 (char *)&setup, sizeof(setup),
2940 stream->rtsp_option) < 0) {
2941 rtsp_reply_error(c, RTSP_STATUS_TRANSPORT);
2944 dest_addr.sin_addr.s_addr = htonl(setup.ipaddr);
2948 if (rtp_new_av_stream(rtp_c, stream_index, &dest_addr, c) < 0) {
2949 rtsp_reply_error(c, RTSP_STATUS_TRANSPORT);
2953 /* now everything is OK, so we can send the connection parameters */
2954 rtsp_reply_header(c, RTSP_STATUS_OK);
2956 url_fprintf(c->pb, "Session: %s\r\n", rtp_c->session_id);
2958 switch(rtp_c->rtp_protocol) {
2959 case RTSP_PROTOCOL_RTP_UDP:
2960 port = rtp_get_local_port(rtp_c->rtp_handles[stream_index]);
2961 url_fprintf(c->pb, "Transport: RTP/AVP/UDP;unicast;"
2962 "client_port=%d-%d;server_port=%d-%d",
2963 th->client_port_min, th->client_port_min + 1,
2966 case RTSP_PROTOCOL_RTP_TCP:
2967 url_fprintf(c->pb, "Transport: RTP/AVP/TCP;interleaved=%d-%d",
2968 stream_index * 2, stream_index * 2 + 1);
2973 if (setup.transport_option[0] != '\0') {
2974 url_fprintf(c->pb, ";%s", setup.transport_option);
2976 url_fprintf(c->pb, "\r\n");
2979 url_fprintf(c->pb, "\r\n");
2983 /* find an rtp connection by using the session ID. Check consistency
2985 static HTTPContext *find_rtp_session_with_url(const char *url,
2986 const char *session_id)
2994 rtp_c = find_rtp_session(session_id);
2998 /* find which url is asked */
2999 url_split(NULL, 0, NULL, 0, NULL, 0, NULL, path1, sizeof(path1), url);
3003 if(!strcmp(path, rtp_c->stream->filename)) return rtp_c;
3004 for(s=0; s<rtp_c->stream->nb_streams; ++s) {
3005 snprintf(buf, sizeof(buf), "%s/streamid=%d",
3006 rtp_c->stream->filename, s);
3007 if(!strncmp(path, buf, sizeof(buf))) {
3008 // XXX: Should we reply with RTSP_STATUS_ONLY_AGGREGATE if nb_streams>1?
3015 static void rtsp_cmd_play(HTTPContext *c, const char *url, RTSPHeader *h)
3019 rtp_c = find_rtp_session_with_url(url, h->session_id);
3021 rtsp_reply_error(c, RTSP_STATUS_SESSION);
3025 if (rtp_c->state != HTTPSTATE_SEND_DATA &&
3026 rtp_c->state != HTTPSTATE_WAIT_FEED &&
3027 rtp_c->state != HTTPSTATE_READY) {
3028 rtsp_reply_error(c, RTSP_STATUS_STATE);
3033 /* XXX: seek in stream */
3034 if (h->range_start != AV_NOPTS_VALUE) {
3035 printf("range_start=%0.3f\n", (double)h->range_start / AV_TIME_BASE);
3036 av_seek_frame(rtp_c->fmt_in, -1, h->range_start);
3040 rtp_c->state = HTTPSTATE_SEND_DATA;
3042 /* now everything is OK, so we can send the connection parameters */
3043 rtsp_reply_header(c, RTSP_STATUS_OK);
3045 url_fprintf(c->pb, "Session: %s\r\n", rtp_c->session_id);
3046 url_fprintf(c->pb, "\r\n");
3049 static void rtsp_cmd_pause(HTTPContext *c, const char *url, RTSPHeader *h)
3053 rtp_c = find_rtp_session_with_url(url, h->session_id);
3055 rtsp_reply_error(c, RTSP_STATUS_SESSION);
3059 if (rtp_c->state != HTTPSTATE_SEND_DATA &&
3060 rtp_c->state != HTTPSTATE_WAIT_FEED) {
3061 rtsp_reply_error(c, RTSP_STATUS_STATE);
3065 rtp_c->state = HTTPSTATE_READY;
3066 rtp_c->first_pts = AV_NOPTS_VALUE;
3067 /* now everything is OK, so we can send the connection parameters */
3068 rtsp_reply_header(c, RTSP_STATUS_OK);
3070 url_fprintf(c->pb, "Session: %s\r\n", rtp_c->session_id);
3071 url_fprintf(c->pb, "\r\n");
3074 static void rtsp_cmd_teardown(HTTPContext *c, const char *url, RTSPHeader *h)
3078 rtp_c = find_rtp_session_with_url(url, h->session_id);
3080 rtsp_reply_error(c, RTSP_STATUS_SESSION);
3084 /* abort the session */
3085 close_connection(rtp_c);
3087 if (ff_rtsp_callback) {
3088 ff_rtsp_callback(RTSP_ACTION_SERVER_TEARDOWN, rtp_c->session_id,
3090 rtp_c->stream->rtsp_option);
3093 /* now everything is OK, so we can send the connection parameters */
3094 rtsp_reply_header(c, RTSP_STATUS_OK);
3096 url_fprintf(c->pb, "Session: %s\r\n", rtp_c->session_id);
3097 url_fprintf(c->pb, "\r\n");
3101 /********************************************************************/
3104 static HTTPContext *rtp_new_connection(struct sockaddr_in *from_addr,
3105 FFStream *stream, const char *session_id,
3106 enum RTSPProtocol rtp_protocol)
3108 HTTPContext *c = NULL;
3109 const char *proto_str;
3111 /* XXX: should output a warning page when coming
3112 close to the connection limit */
3113 if (nb_connections >= nb_max_connections)
3116 /* add a new connection */
3117 c = av_mallocz(sizeof(HTTPContext));
3122 c->poll_entry = NULL;
3123 c->from_addr = *from_addr;
3124 c->buffer_size = IOBUFFER_INIT_SIZE;
3125 c->buffer = av_malloc(c->buffer_size);
3130 pstrcpy(c->session_id, sizeof(c->session_id), session_id);
3131 c->state = HTTPSTATE_READY;
3132 c->is_packetized = 1;
3133 c->rtp_protocol = rtp_protocol;
3135 /* protocol is shown in statistics */
3136 switch(c->rtp_protocol) {
3137 case RTSP_PROTOCOL_RTP_UDP_MULTICAST:
3138 proto_str = "MCAST";
3140 case RTSP_PROTOCOL_RTP_UDP:
3143 case RTSP_PROTOCOL_RTP_TCP:
3150 pstrcpy(c->protocol, sizeof(c->protocol), "RTP/");
3151 pstrcat(c->protocol, sizeof(c->protocol), proto_str);
3153 current_bandwidth += stream->bandwidth;
3155 c->next = first_http_ctx;
3167 /* add a new RTP stream in an RTP connection (used in RTSP SETUP
3168 command). If RTP/TCP protocol is used, TCP connection 'rtsp_c' is
3170 static int rtp_new_av_stream(HTTPContext *c,
3171 int stream_index, struct sockaddr_in *dest_addr,
3172 HTTPContext *rtsp_c)
3174 AVFormatContext *ctx;
3180 int max_packet_size;
3182 /* now we can open the relevant output stream */
3183 ctx = av_alloc_format_context();
3186 ctx->oformat = &rtp_muxer;
3188 st = av_mallocz(sizeof(AVStream));
3191 st->codec= avcodec_alloc_context();
3192 ctx->nb_streams = 1;
3193 ctx->streams[0] = st;
3195 if (!c->stream->feed ||
3196 c->stream->feed == c->stream) {
3197 memcpy(st, c->stream->streams[stream_index], sizeof(AVStream));
3200 c->stream->feed->streams[c->stream->feed_streams[stream_index]],
3204 /* build destination RTP address */
3205 ipaddr = inet_ntoa(dest_addr->sin_addr);
3207 switch(c->rtp_protocol) {
3208 case RTSP_PROTOCOL_RTP_UDP:
3209 case RTSP_PROTOCOL_RTP_UDP_MULTICAST:
3212 /* XXX: also pass as parameter to function ? */
3213 if (c->stream->is_multicast) {
3215 ttl = c->stream->multicast_ttl;
3218 snprintf(ctx->filename, sizeof(ctx->filename),
3219 "rtp://%s:%d?multicast=1&ttl=%d",
3220 ipaddr, ntohs(dest_addr->sin_port), ttl);
3222 snprintf(ctx->filename, sizeof(ctx->filename),
3223 "rtp://%s:%d", ipaddr, ntohs(dest_addr->sin_port));
3226 if (url_open(&h, ctx->filename, URL_WRONLY) < 0)
3228 c->rtp_handles[stream_index] = h;
3229 max_packet_size = url_get_max_packet_size(h);
3231 case RTSP_PROTOCOL_RTP_TCP:
3234 max_packet_size = RTSP_TCP_MAX_PACKET_SIZE;
3240 http_log("%s:%d - - [%s] \"PLAY %s/streamid=%d %s\"\n",
3241 ipaddr, ntohs(dest_addr->sin_port),
3243 c->stream->filename, stream_index, c->protocol);
3245 /* normally, no packets should be output here, but the packet size may be checked */
3246 if (url_open_dyn_packet_buf(&ctx->pb, max_packet_size) < 0) {
3247 /* XXX: close stream */
3250 av_set_parameters(ctx, NULL);
3251 if (av_write_header(ctx) < 0) {
3258 url_close_dyn_buf(&ctx->pb, &dummy_buf);
3261 c->rtp_ctx[stream_index] = ctx;
3265 /********************************************************************/
3266 /* ffserver initialization */
3268 static AVStream *add_av_stream1(FFStream *stream, AVCodecContext *codec)
3272 fst = av_mallocz(sizeof(AVStream));
3275 fst->codec= avcodec_alloc_context();
3276 fst->priv_data = av_mallocz(sizeof(FeedData));
3277 memcpy(fst->codec, codec, sizeof(AVCodecContext));
3278 fst->codec->coded_frame = &dummy_frame;
3279 fst->index = stream->nb_streams;
3280 av_set_pts_info(fst, 33, 1, 90000);
3281 stream->streams[stream->nb_streams++] = fst;
3285 /* return the stream number in the feed */
3286 static int add_av_stream(FFStream *feed, AVStream *st)
3289 AVCodecContext *av, *av1;
3293 for(i=0;i<feed->nb_streams;i++) {
3294 st = feed->streams[i];
3296 if (av1->codec_id == av->codec_id &&
3297 av1->codec_type == av->codec_type &&
3298 av1->bit_rate == av->bit_rate) {
3300 switch(av->codec_type) {
3301 case CODEC_TYPE_AUDIO:
3302 if (av1->channels == av->channels &&
3303 av1->sample_rate == av->sample_rate)
3306 case CODEC_TYPE_VIDEO:
3307 if (av1->width == av->width &&
3308 av1->height == av->height &&
3309 av1->time_base.den == av->time_base.den &&
3310 av1->time_base.num == av->time_base.num &&
3311 av1->gop_size == av->gop_size)
3320 fst = add_av_stream1(feed, av);
3323 return feed->nb_streams - 1;
3328 static void remove_stream(FFStream *stream)
3332 while (*ps != NULL) {
3333 if (*ps == stream) {
3341 /* specific mpeg4 handling : we extract the raw parameters */
3342 static void extract_mpeg4_header(AVFormatContext *infile)
3344 int mpeg4_count, i, size;
3350 for(i=0;i<infile->nb_streams;i++) {
3351 st = infile->streams[i];
3352 if (st->codec->codec_id == CODEC_ID_MPEG4 &&
3353 st->codec->extradata_size == 0) {
3360 printf("MPEG4 without extra data: trying to find header in %s\n", infile->filename);
3361 while (mpeg4_count > 0) {
3362 if (av_read_packet(infile, &pkt) < 0)
3364 st = infile->streams[pkt.stream_index];
3365 if (st->codec->codec_id == CODEC_ID_MPEG4 &&
3366 st->codec->extradata_size == 0) {
3367 av_freep(&st->codec->extradata);
3368 /* fill extradata with the header */
3369 /* XXX: we make hard suppositions here ! */
3371 while (p < pkt.data + pkt.size - 4) {
3372 /* stop when vop header is found */
3373 if (p[0] == 0x00 && p[1] == 0x00 &&
3374 p[2] == 0x01 && p[3] == 0xb6) {
3375 size = p - pkt.data;
3376 // av_hex_dump_log(infile, AV_LOG_DEBUG, pkt.data, size);
3377 st->codec->extradata = av_malloc(size);
3378 st->codec->extradata_size = size;
3379 memcpy(st->codec->extradata, pkt.data, size);
3386 av_free_packet(&pkt);
3390 /* compute the needed AVStream for each file */
3391 static void build_file_streams(void)
3393 FFStream *stream, *stream_next;
3394 AVFormatContext *infile;
3397 /* gather all streams */
3398 for(stream = first_stream; stream != NULL; stream = stream_next) {
3399 stream_next = stream->next;
3400 if (stream->stream_type == STREAM_TYPE_LIVE &&
3402 /* the stream comes from a file */
3403 /* try to open the file */
3405 stream->ap_in = av_mallocz(sizeof(AVFormatParameters));
3406 if (stream->fmt == &rtp_muxer) {
3407 /* specific case : if transport stream output to RTP,
3408 we use a raw transport stream reader */
3409 stream->ap_in->mpeg2ts_raw = 1;
3410 stream->ap_in->mpeg2ts_compute_pcr = 1;
3413 if (av_open_input_file(&infile, stream->feed_filename,
3414 stream->ifmt, 0, stream->ap_in) < 0) {
3415 http_log("%s not found", stream->feed_filename);
3416 /* remove stream (no need to spend more time on it) */
3418 remove_stream(stream);
3420 /* find all the AVStreams inside and reference them in
3422 if (av_find_stream_info(infile) < 0) {
3423 http_log("Could not find codec parameters from '%s'",
3424 stream->feed_filename);
3425 av_close_input_file(infile);
3428 extract_mpeg4_header(infile);
3430 for(i=0;i<infile->nb_streams;i++) {
3431 add_av_stream1(stream, infile->streams[i]->codec);
3433 av_close_input_file(infile);
3439 /* compute the needed AVStream for each feed */
3440 static void build_feed_streams(void)
3442 FFStream *stream, *feed;
3445 /* gather all streams */
3446 for(stream = first_stream; stream != NULL; stream = stream->next) {
3447 feed = stream->feed;
3449 if (!stream->is_feed) {
3450 /* we handle a stream coming from a feed */
3451 for(i=0;i<stream->nb_streams;i++) {
3452 stream->feed_streams[i] = add_av_stream(feed, stream->streams[i]);
3458 /* gather all streams */
3459 for(stream = first_stream; stream != NULL; stream = stream->next) {
3460 feed = stream->feed;
3462 if (stream->is_feed) {
3463 for(i=0;i<stream->nb_streams;i++) {
3464 stream->feed_streams[i] = i;
3470 /* create feed files if needed */
3471 for(feed = first_feed; feed != NULL; feed = feed->next_feed) {
3474 if (url_exist(feed->feed_filename)) {
3475 /* See if it matches */
3479 if (av_open_input_file(&s, feed->feed_filename, NULL, FFM_PACKET_SIZE, NULL) >= 0) {
3480 /* Now see if it matches */
3481 if (s->nb_streams == feed->nb_streams) {
3483 for(i=0;i<s->nb_streams;i++) {
3485 sf = feed->streams[i];
3488 if (sf->index != ss->index ||
3490 printf("Index & Id do not match for stream %d (%s)\n",
3491 i, feed->feed_filename);
3494 AVCodecContext *ccf, *ccs;
3498 #define CHECK_CODEC(x) (ccf->x != ccs->x)
3500 if (CHECK_CODEC(codec) || CHECK_CODEC(codec_type)) {
3501 printf("Codecs do not match for stream %d\n", i);
3503 } else if (CHECK_CODEC(bit_rate) || CHECK_CODEC(flags)) {
3504 printf("Codec bitrates do not match for stream %d\n", i);
3506 } else if (ccf->codec_type == CODEC_TYPE_VIDEO) {
3507 if (CHECK_CODEC(time_base.den) ||
3508 CHECK_CODEC(time_base.num) ||
3509 CHECK_CODEC(width) ||
3510 CHECK_CODEC(height)) {
3511 printf("Codec width, height and framerate do not match for stream %d\n", i);
3514 } else if (ccf->codec_type == CODEC_TYPE_AUDIO) {
3515 if (CHECK_CODEC(sample_rate) ||
3516 CHECK_CODEC(channels) ||
3517 CHECK_CODEC(frame_size)) {
3518 printf("Codec sample_rate, channels, frame_size do not match for stream %d\n", i);
3522 printf("Unknown codec type\n");
3531 printf("Deleting feed file '%s' as stream counts differ (%d != %d)\n",
3532 feed->feed_filename, s->nb_streams, feed->nb_streams);
3535 av_close_input_file(s);
3537 printf("Deleting feed file '%s' as it appears to be corrupt\n",
3538 feed->feed_filename);
3541 if (feed->readonly) {
3542 printf("Unable to delete feed file '%s' as it is marked readonly\n",
3543 feed->feed_filename);
3546 unlink(feed->feed_filename);
3549 if (!url_exist(feed->feed_filename)) {
3550 AVFormatContext s1, *s = &s1;
3552 if (feed->readonly) {
3553 printf("Unable to create feed file '%s' as it is marked readonly\n",
3554 feed->feed_filename);
3558 /* only write the header of the ffm file */
3559 if (url_fopen(&s->pb, feed->feed_filename, URL_WRONLY) < 0) {
3560 fprintf(stderr, "Could not open output feed file '%s'\n",
3561 feed->feed_filename);
3564 s->oformat = feed->fmt;
3565 s->nb_streams = feed->nb_streams;
3566 for(i=0;i<s->nb_streams;i++) {
3568 st = feed->streams[i];
3571 av_set_parameters(s, NULL);
3572 if (av_write_header(s) < 0) {
3573 fprintf(stderr, "Container doesn't supports the required parameters\n");
3576 /* XXX: need better api */
3577 av_freep(&s->priv_data);
3580 /* get feed size and write index */
3581 fd = open(feed->feed_filename, O_RDONLY);
3583 fprintf(stderr, "Could not open output feed file '%s'\n",
3584 feed->feed_filename);
3588 feed->feed_write_index = ffm_read_write_index(fd);
3589 feed->feed_size = lseek(fd, 0, SEEK_END);
3590 /* ensure that we do not wrap before the end of file */
3591 if (feed->feed_max_size && feed->feed_max_size < feed->feed_size)
3592 feed->feed_max_size = feed->feed_size;
3598 /* compute the bandwidth used by each stream */
3599 static void compute_bandwidth(void)
3604 for(stream = first_stream; stream != NULL; stream = stream->next) {
3606 for(i=0;i<stream->nb_streams;i++) {
3607 AVStream *st = stream->streams[i];
3608 switch(st->codec->codec_type) {
3609 case CODEC_TYPE_AUDIO:
3610 case CODEC_TYPE_VIDEO:
3611 bandwidth += st->codec->bit_rate;
3617 stream->bandwidth = (bandwidth + 999) / 1000;
3621 static void get_arg(char *buf, int buf_size, const char **pp)
3628 while (isspace(*p)) p++;
3631 if (*p == '\"' || *p == '\'')
3643 if ((q - buf) < buf_size - 1)
3648 if (quote && *p == quote)
3653 /* add a codec and set the default parameters */
3654 static void add_codec(FFStream *stream, AVCodecContext *av)
3658 /* compute default parameters */
3659 switch(av->codec_type) {
3660 case CODEC_TYPE_AUDIO:
3661 if (av->bit_rate == 0)
3662 av->bit_rate = 64000;
3663 if (av->sample_rate == 0)
3664 av->sample_rate = 22050;
3665 if (av->channels == 0)
3668 case CODEC_TYPE_VIDEO:
3669 if (av->bit_rate == 0)
3670 av->bit_rate = 64000;
3671 if (av->time_base.num == 0){
3672 av->time_base.den = 5;
3673 av->time_base.num = 1;
3675 if (av->width == 0 || av->height == 0) {
3679 /* Bitrate tolerance is less for streaming */
3680 if (av->bit_rate_tolerance == 0)
3681 av->bit_rate_tolerance = av->bit_rate / 4;
3686 if (av->max_qdiff == 0)
3688 av->qcompress = 0.5;
3691 if (!av->nsse_weight)
3692 av->nsse_weight = 8;
3694 av->frame_skip_cmp = FF_CMP_DCTMAX;
3695 av->me_method = ME_EPZS;
3696 av->rc_buffer_aggressivity = 1.0;
3699 av->rc_eq = "tex^qComp";
3700 if (!av->i_quant_factor)
3701 av->i_quant_factor = -0.8;
3702 if (!av->b_quant_factor)
3703 av->b_quant_factor = 1.25;
3704 if (!av->b_quant_offset)
3705 av->b_quant_offset = 1.25;
3706 if (!av->rc_max_rate)
3707 av->rc_max_rate = av->bit_rate * 2;
3709 if (av->rc_max_rate && !av->rc_buffer_size) {
3710 av->rc_buffer_size = av->rc_max_rate;
3719 st = av_mallocz(sizeof(AVStream));
3722 st->codec = avcodec_alloc_context();
3723 stream->streams[stream->nb_streams++] = st;
3724 memcpy(st->codec, av, sizeof(AVCodecContext));
3727 static int opt_audio_codec(const char *arg)
3733 if (!strcmp(p->name, arg) && p->type == CODEC_TYPE_AUDIO)
3738 return CODEC_ID_NONE;
3744 static int opt_video_codec(const char *arg)
3750 if (!strcmp(p->name, arg) && p->type == CODEC_TYPE_VIDEO)
3755 return CODEC_ID_NONE;
3761 /* simplistic plugin support */
3764 static void load_module(const char *filename)
3767 void (*init_func)(void);
3768 dll = dlopen(filename, RTLD_NOW);
3770 fprintf(stderr, "Could not load module '%s' - %s\n",
3771 filename, dlerror());
3775 init_func = dlsym(dll, "ffserver_module_init");
3778 "%s: init function 'ffserver_module_init()' not found\n",
3787 static int parse_ffconfig(const char *filename)
3794 int val, errors, line_num;
3795 FFStream **last_stream, *stream, *redirect;
3796 FFStream **last_feed, *feed;
3797 AVCodecContext audio_enc, video_enc;
3798 int audio_id, video_id;
3800 f = fopen(filename, "r");
3808 first_stream = NULL;
3809 last_stream = &first_stream;
3811 last_feed = &first_feed;
3815 audio_id = CODEC_ID_NONE;
3816 video_id = CODEC_ID_NONE;
3818 if (fgets(line, sizeof(line), f) == NULL)
3824 if (*p == '\0' || *p == '#')
3827 get_arg(cmd, sizeof(cmd), &p);
3829 if (!strcasecmp(cmd, "Port")) {
3830 get_arg(arg, sizeof(arg), &p);
3831 my_http_addr.sin_port = htons (atoi(arg));
3832 } else if (!strcasecmp(cmd, "BindAddress")) {
3833 get_arg(arg, sizeof(arg), &p);
3834 if (!inet_aton(arg, &my_http_addr.sin_addr)) {
3835 fprintf(stderr, "%s:%d: Invalid IP address: %s\n",
3836 filename, line_num, arg);
3839 } else if (!strcasecmp(cmd, "NoDaemon")) {
3840 ffserver_daemon = 0;
3841 } else if (!strcasecmp(cmd, "RTSPPort")) {
3842 get_arg(arg, sizeof(arg), &p);
3843 my_rtsp_addr.sin_port = htons (atoi(arg));
3844 } else if (!strcasecmp(cmd, "RTSPBindAddress")) {
3845 get_arg(arg, sizeof(arg), &p);
3846 if (!inet_aton(arg, &my_rtsp_addr.sin_addr)) {
3847 fprintf(stderr, "%s:%d: Invalid IP address: %s\n",
3848 filename, line_num, arg);
3851 } else if (!strcasecmp(cmd, "MaxClients")) {
3852 get_arg(arg, sizeof(arg), &p);
3854 if (val < 1 || val > HTTP_MAX_CONNECTIONS) {
3855 fprintf(stderr, "%s:%d: Invalid MaxClients: %s\n",
3856 filename, line_num, arg);
3859 nb_max_connections = val;
3861 } else if (!strcasecmp(cmd, "MaxBandwidth")) {
3862 get_arg(arg, sizeof(arg), &p);
3864 if (val < 10 || val > 100000) {
3865 fprintf(stderr, "%s:%d: Invalid MaxBandwidth: %s\n",
3866 filename, line_num, arg);
3869 max_bandwidth = val;
3871 } else if (!strcasecmp(cmd, "CustomLog")) {
3872 get_arg(logfilename, sizeof(logfilename), &p);
3873 } else if (!strcasecmp(cmd, "<Feed")) {
3874 /*********************************************/
3875 /* Feed related options */
3877 if (stream || feed) {
3878 fprintf(stderr, "%s:%d: Already in a tag\n",
3879 filename, line_num);
3881 feed = av_mallocz(sizeof(FFStream));
3882 /* add in stream list */
3883 *last_stream = feed;
3884 last_stream = &feed->next;
3885 /* add in feed list */
3887 last_feed = &feed->next_feed;
3889 get_arg(feed->filename, sizeof(feed->filename), &p);
3890 q = strrchr(feed->filename, '>');
3893 feed->fmt = guess_format("ffm", NULL, NULL);
3894 /* defaut feed file */
3895 snprintf(feed->feed_filename, sizeof(feed->feed_filename),
3896 "/tmp/%s.ffm", feed->filename);
3897 feed->feed_max_size = 5 * 1024 * 1024;
3899 feed->feed = feed; /* self feeding :-) */
3901 } else if (!strcasecmp(cmd, "Launch")) {
3905 feed->child_argv = (char **) av_mallocz(64 * sizeof(char *));
3907 for (i = 0; i < 62; i++) {
3910 get_arg(argbuf, sizeof(argbuf), &p);
3914 feed->child_argv[i] = av_malloc(strlen(argbuf) + 1);
3915 strcpy(feed->child_argv[i], argbuf);
3918 feed->child_argv[i] = av_malloc(30 + strlen(feed->filename));
3920 snprintf(feed->child_argv[i], 30+strlen(feed->filename),
3922 (my_http_addr.sin_addr.s_addr == INADDR_ANY) ? "127.0.0.1" :
3923 inet_ntoa(my_http_addr.sin_addr),
3924 ntohs(my_http_addr.sin_port), feed->filename);
3929 fprintf(stdout, "Launch commandline: ");
3930 for (j = 0; j <= i; j++)
3931 fprintf(stdout, "%s ", feed->child_argv[j]);
3932 fprintf(stdout, "\n");
3935 } else if (!strcasecmp(cmd, "ReadOnlyFile")) {
3937 get_arg(feed->feed_filename, sizeof(feed->feed_filename), &p);
3939 } else if (stream) {
3940 get_arg(stream->feed_filename, sizeof(stream->feed_filename), &p);
3942 } else if (!strcasecmp(cmd, "File")) {
3944 get_arg(feed->feed_filename, sizeof(feed->feed_filename), &p);
3945 } else if (stream) {
3946 get_arg(stream->feed_filename, sizeof(stream->feed_filename), &p);
3948 } else if (!strcasecmp(cmd, "FileMaxSize")) {
3953 get_arg(arg, sizeof(arg), &p);
3955 fsize = strtod(p1, (char **)&p1);
3956 switch(toupper(*p1)) {
3961 fsize *= 1024 * 1024;
3964 fsize *= 1024 * 1024 * 1024;
3967 feed->feed_max_size = (int64_t)fsize;
3969 } else if (!strcasecmp(cmd, "</Feed>")) {
3971 fprintf(stderr, "%s:%d: No corresponding <Feed> for </Feed>\n",
3972 filename, line_num);
3976 /* Make sure that we start out clean */
3977 if (unlink(feed->feed_filename) < 0
3978 && errno != ENOENT) {
3979 fprintf(stderr, "%s:%d: Unable to clean old feed file '%s': %s\n",
3980 filename, line_num, feed->feed_filename, strerror(errno));
3986 } else if (!strcasecmp(cmd, "<Stream")) {
3987 /*********************************************/
3988 /* Stream related options */
3990 if (stream || feed) {
3991 fprintf(stderr, "%s:%d: Already in a tag\n",
3992 filename, line_num);
3994 stream = av_mallocz(sizeof(FFStream));
3995 *last_stream = stream;
3996 last_stream = &stream->next;
3998 get_arg(stream->filename, sizeof(stream->filename), &p);
3999 q = strrchr(stream->filename, '>');
4002 stream->fmt = guess_stream_format(NULL, stream->filename, NULL);
4003 memset(&audio_enc, 0, sizeof(AVCodecContext));
4004 memset(&video_enc, 0, sizeof(AVCodecContext));
4005 audio_id = CODEC_ID_NONE;
4006 video_id = CODEC_ID_NONE;
4008 audio_id = stream->fmt->audio_codec;
4009 video_id = stream->fmt->video_codec;
4012 } else if (!strcasecmp(cmd, "Feed")) {
4013 get_arg(arg, sizeof(arg), &p);
4018 while (sfeed != NULL) {
4019 if (!strcmp(sfeed->filename, arg))
4021 sfeed = sfeed->next_feed;
4024 fprintf(stderr, "%s:%d: feed '%s' not defined\n",
4025 filename, line_num, arg);
4027 stream->feed = sfeed;
4030 } else if (!strcasecmp(cmd, "Format")) {
4031 get_arg(arg, sizeof(arg), &p);
4032 if (!strcmp(arg, "status")) {
4033 stream->stream_type = STREAM_TYPE_STATUS;
4036 stream->stream_type = STREAM_TYPE_LIVE;
4037 /* jpeg cannot be used here, so use single frame jpeg */
4038 if (!strcmp(arg, "jpeg"))
4039 strcpy(arg, "mjpeg");
4040 stream->fmt = guess_stream_format(arg, NULL, NULL);
4042 fprintf(stderr, "%s:%d: Unknown Format: %s\n",
4043 filename, line_num, arg);
4048 audio_id = stream->fmt->audio_codec;
4049 video_id = stream->fmt->video_codec;
4051 } else if (!strcasecmp(cmd, "InputFormat")) {
4052 stream->ifmt = av_find_input_format(arg);
4053 if (!stream->ifmt) {
4054 fprintf(stderr, "%s:%d: Unknown input format: %s\n",
4055 filename, line_num, arg);
4057 } else if (!strcasecmp(cmd, "FaviconURL")) {
4058 if (stream && stream->stream_type == STREAM_TYPE_STATUS) {
4059 get_arg(stream->feed_filename, sizeof(stream->feed_filename), &p);
4061 fprintf(stderr, "%s:%d: FaviconURL only permitted for status streams\n",
4062 filename, line_num);
4065 } else if (!strcasecmp(cmd, "Author")) {
4067 get_arg(stream->author, sizeof(stream->author), &p);
4069 } else if (!strcasecmp(cmd, "Comment")) {
4071 get_arg(stream->comment, sizeof(stream->comment), &p);
4073 } else if (!strcasecmp(cmd, "Copyright")) {
4075 get_arg(stream->copyright, sizeof(stream->copyright), &p);
4077 } else if (!strcasecmp(cmd, "Title")) {
4079 get_arg(stream->title, sizeof(stream->title), &p);
4081 } else if (!strcasecmp(cmd, "Preroll")) {
4082 get_arg(arg, sizeof(arg), &p);
4084 stream->prebuffer = atof(arg) * 1000;
4086 } else if (!strcasecmp(cmd, "StartSendOnKey")) {
4088 stream->send_on_key = 1;
4090 } else if (!strcasecmp(cmd, "AudioCodec")) {
4091 get_arg(arg, sizeof(arg), &p);
4092 audio_id = opt_audio_codec(arg);
4093 if (audio_id == CODEC_ID_NONE) {
4094 fprintf(stderr, "%s:%d: Unknown AudioCodec: %s\n",
4095 filename, line_num, arg);
4098 } else if (!strcasecmp(cmd, "VideoCodec")) {
4099 get_arg(arg, sizeof(arg), &p);
4100 video_id = opt_video_codec(arg);
4101 if (video_id == CODEC_ID_NONE) {
4102 fprintf(stderr, "%s:%d: Unknown VideoCodec: %s\n",
4103 filename, line_num, arg);
4106 } else if (!strcasecmp(cmd, "MaxTime")) {
4107 get_arg(arg, sizeof(arg), &p);
4109 stream->max_time = atof(arg) * 1000;
4111 } else if (!strcasecmp(cmd, "AudioBitRate")) {
4112 get_arg(arg, sizeof(arg), &p);
4114 audio_enc.bit_rate = atoi(arg) * 1000;
4116 } else if (!strcasecmp(cmd, "AudioChannels")) {
4117 get_arg(arg, sizeof(arg), &p);
4119 audio_enc.channels = atoi(arg);
4121 } else if (!strcasecmp(cmd, "AudioSampleRate")) {
4122 get_arg(arg, sizeof(arg), &p);
4124 audio_enc.sample_rate = atoi(arg);
4126 } else if (!strcasecmp(cmd, "AudioQuality")) {
4127 get_arg(arg, sizeof(arg), &p);
4129 // audio_enc.quality = atof(arg) * 1000;
4131 } else if (!strcasecmp(cmd, "VideoBitRateRange")) {
4133 int minrate, maxrate;
4135 get_arg(arg, sizeof(arg), &p);
4137 if (sscanf(arg, "%d-%d", &minrate, &maxrate) == 2) {
4138 video_enc.rc_min_rate = minrate * 1000;
4139 video_enc.rc_max_rate = maxrate * 1000;
4141 fprintf(stderr, "%s:%d: Incorrect format for VideoBitRateRange -- should be <min>-<max>: %s\n",
4142 filename, line_num, arg);
4146 } else if (!strcasecmp(cmd, "Debug")) {
4148 get_arg(arg, sizeof(arg), &p);
4149 video_enc.debug = strtol(arg,0,0);
4151 } else if (!strcasecmp(cmd, "Strict")) {
4153 get_arg(arg, sizeof(arg), &p);
4154 video_enc.strict_std_compliance = atoi(arg);
4156 } else if (!strcasecmp(cmd, "VideoBufferSize")) {
4158 get_arg(arg, sizeof(arg), &p);
4159 video_enc.rc_buffer_size = atoi(arg) * 8*1024;
4161 } else if (!strcasecmp(cmd, "VideoBitRateTolerance")) {
4163 get_arg(arg, sizeof(arg), &p);
4164 video_enc.bit_rate_tolerance = atoi(arg) * 1000;
4166 } else if (!strcasecmp(cmd, "VideoBitRate")) {
4167 get_arg(arg, sizeof(arg), &p);
4169 video_enc.bit_rate = atoi(arg) * 1000;
4171 } else if (!strcasecmp(cmd, "VideoSize")) {
4172 get_arg(arg, sizeof(arg), &p);
4174 parse_image_size(&video_enc.width, &video_enc.height, arg);
4175 if ((video_enc.width % 16) != 0 ||
4176 (video_enc.height % 16) != 0) {
4177 fprintf(stderr, "%s:%d: Image size must be a multiple of 16\n",
4178 filename, line_num);
4182 } else if (!strcasecmp(cmd, "VideoFrameRate")) {
4183 get_arg(arg, sizeof(arg), &p);
4185 video_enc.time_base.num= DEFAULT_FRAME_RATE_BASE;
4186 video_enc.time_base.den = (int)(strtod(arg, NULL) * video_enc.time_base.num);
4188 } else if (!strcasecmp(cmd, "VideoGopSize")) {
4189 get_arg(arg, sizeof(arg), &p);
4191 video_enc.gop_size = atoi(arg);
4193 } else if (!strcasecmp(cmd, "VideoIntraOnly")) {
4195 video_enc.gop_size = 1;
4197 } else if (!strcasecmp(cmd, "VideoHighQuality")) {
4199 video_enc.mb_decision = FF_MB_DECISION_BITS;
4201 } else if (!strcasecmp(cmd, "Video4MotionVector")) {
4203 video_enc.mb_decision = FF_MB_DECISION_BITS; //FIXME remove
4204 video_enc.flags |= CODEC_FLAG_4MV;
4206 } else if (!strcasecmp(cmd, "VideoTag")) {
4207 get_arg(arg, sizeof(arg), &p);
4208 if ((strlen(arg) == 4) && stream) {
4209 video_enc.codec_tag = ff_get_fourcc(arg);
4211 } else if (!strcasecmp(cmd, "BitExact")) {
4213 video_enc.flags |= CODEC_FLAG_BITEXACT;
4215 } else if (!strcasecmp(cmd, "DctFastint")) {
4217 video_enc.dct_algo = FF_DCT_FASTINT;
4219 } else if (!strcasecmp(cmd, "IdctSimple")) {
4221 video_enc.idct_algo = FF_IDCT_SIMPLE;
4223 } else if (!strcasecmp(cmd, "Qscale")) {
4224 get_arg(arg, sizeof(arg), &p);
4226 video_enc.flags |= CODEC_FLAG_QSCALE;
4227 video_enc.global_quality = FF_QP2LAMBDA * atoi(arg);
4229 } else if (!strcasecmp(cmd, "VideoQDiff")) {
4230 get_arg(arg, sizeof(arg), &p);
4232 video_enc.max_qdiff = atoi(arg);
4233 if (video_enc.max_qdiff < 1 || video_enc.max_qdiff > 31) {
4234 fprintf(stderr, "%s:%d: VideoQDiff out of range\n",
4235 filename, line_num);
4239 } else if (!strcasecmp(cmd, "VideoQMax")) {
4240 get_arg(arg, sizeof(arg), &p);
4242 video_enc.qmax = atoi(arg);
4243 if (video_enc.qmax < 1 || video_enc.qmax > 31) {
4244 fprintf(stderr, "%s:%d: VideoQMax out of range\n",
4245 filename, line_num);
4249 } else if (!strcasecmp(cmd, "VideoQMin")) {
4250 get_arg(arg, sizeof(arg), &p);
4252 video_enc.qmin = atoi(arg);
4253 if (video_enc.qmin < 1 || video_enc.qmin > 31) {
4254 fprintf(stderr, "%s:%d: VideoQMin out of range\n",
4255 filename, line_num);
4259 } else if (!strcasecmp(cmd, "LumaElim")) {
4260 get_arg(arg, sizeof(arg), &p);
4262 video_enc.luma_elim_threshold = atoi(arg);
4264 } else if (!strcasecmp(cmd, "ChromaElim")) {
4265 get_arg(arg, sizeof(arg), &p);
4267 video_enc.chroma_elim_threshold = atoi(arg);
4269 } else if (!strcasecmp(cmd, "LumiMask")) {
4270 get_arg(arg, sizeof(arg), &p);
4272 video_enc.lumi_masking = atof(arg);
4274 } else if (!strcasecmp(cmd, "DarkMask")) {
4275 get_arg(arg, sizeof(arg), &p);
4277 video_enc.dark_masking = atof(arg);
4279 } else if (!strcasecmp(cmd, "NoVideo")) {
4280 video_id = CODEC_ID_NONE;
4281 } else if (!strcasecmp(cmd, "NoAudio")) {
4282 audio_id = CODEC_ID_NONE;
4283 } else if (!strcasecmp(cmd, "ACL")) {
4287 get_arg(arg, sizeof(arg), &p);
4288 if (strcasecmp(arg, "allow") == 0) {
4289 acl.action = IP_ALLOW;
4290 } else if (strcasecmp(arg, "deny") == 0) {
4291 acl.action = IP_DENY;
4293 fprintf(stderr, "%s:%d: ACL action '%s' is not ALLOW or DENY\n",
4294 filename, line_num, arg);
4298 get_arg(arg, sizeof(arg), &p);
4300 he = gethostbyname(arg);
4302 fprintf(stderr, "%s:%d: ACL refers to invalid host or ip address '%s'\n",
4303 filename, line_num, arg);
4306 /* Only take the first */
4307 acl.first.s_addr = ntohl(((struct in_addr *) he->h_addr_list[0])->s_addr);
4308 acl.last = acl.first;
4311 get_arg(arg, sizeof(arg), &p);
4314 he = gethostbyname(arg);
4316 fprintf(stderr, "%s:%d: ACL refers to invalid host or ip address '%s'\n",
4317 filename, line_num, arg);
4320 /* Only take the first */
4321 acl.last.s_addr = ntohl(((struct in_addr *) he->h_addr_list[0])->s_addr);
4326 IPAddressACL *nacl = (IPAddressACL *) av_mallocz(sizeof(*nacl));
4327 IPAddressACL **naclp = 0;
4333 naclp = &stream->acl;
4337 fprintf(stderr, "%s:%d: ACL found not in <stream> or <feed>\n",
4338 filename, line_num);
4344 naclp = &(*naclp)->next;
4349 } else if (!strcasecmp(cmd, "RTSPOption")) {
4350 get_arg(arg, sizeof(arg), &p);
4352 av_freep(&stream->rtsp_option);
4353 stream->rtsp_option = av_strdup(arg);
4355 } else if (!strcasecmp(cmd, "MulticastAddress")) {
4356 get_arg(arg, sizeof(arg), &p);
4358 if (!inet_aton(arg, &stream->multicast_ip)) {
4359 fprintf(stderr, "%s:%d: Invalid IP address: %s\n",
4360 filename, line_num, arg);
4363 stream->is_multicast = 1;
4364 stream->loop = 1; /* default is looping */
4366 } else if (!strcasecmp(cmd, "MulticastPort")) {
4367 get_arg(arg, sizeof(arg), &p);
4369 stream->multicast_port = atoi(arg);
4371 } else if (!strcasecmp(cmd, "MulticastTTL")) {
4372 get_arg(arg, sizeof(arg), &p);
4374 stream->multicast_ttl = atoi(arg);
4376 } else if (!strcasecmp(cmd, "NoLoop")) {
4380 } else if (!strcasecmp(cmd, "</Stream>")) {
4382 fprintf(stderr, "%s:%d: No corresponding <Stream> for </Stream>\n",
4383 filename, line_num);
4386 if (stream->feed && stream->fmt && strcmp(stream->fmt->name, "ffm") != 0) {
4387 if (audio_id != CODEC_ID_NONE) {
4388 audio_enc.codec_type = CODEC_TYPE_AUDIO;
4389 audio_enc.codec_id = audio_id;
4390 add_codec(stream, &audio_enc);
4392 if (video_id != CODEC_ID_NONE) {
4393 video_enc.codec_type = CODEC_TYPE_VIDEO;
4394 video_enc.codec_id = video_id;
4395 add_codec(stream, &video_enc);
4399 } else if (!strcasecmp(cmd, "<Redirect")) {
4400 /*********************************************/
4402 if (stream || feed || redirect) {
4403 fprintf(stderr, "%s:%d: Already in a tag\n",
4404 filename, line_num);
4407 redirect = av_mallocz(sizeof(FFStream));
4408 *last_stream = redirect;
4409 last_stream = &redirect->next;
4411 get_arg(redirect->filename, sizeof(redirect->filename), &p);
4412 q = strrchr(redirect->filename, '>');
4415 redirect->stream_type = STREAM_TYPE_REDIRECT;
4417 } else if (!strcasecmp(cmd, "URL")) {
4419 get_arg(redirect->feed_filename, sizeof(redirect->feed_filename), &p);
4421 } else if (!strcasecmp(cmd, "</Redirect>")) {
4423 fprintf(stderr, "%s:%d: No corresponding <Redirect> for </Redirect>\n",
4424 filename, line_num);
4427 if (!redirect->feed_filename[0]) {
4428 fprintf(stderr, "%s:%d: No URL found for <Redirect>\n",
4429 filename, line_num);
4433 } else if (!strcasecmp(cmd, "LoadModule")) {
4434 get_arg(arg, sizeof(arg), &p);
4438 fprintf(stderr, "%s:%d: Module support not compiled into this version: '%s'\n",
4439 filename, line_num, arg);
4443 fprintf(stderr, "%s:%d: Incorrect keyword: '%s'\n",
4444 filename, line_num, cmd);
4456 static void show_banner(void)
4458 printf("ffserver version " FFMPEG_VERSION ", Copyright (c) 2000-2006 Fabrice Bellard, et al.\n");
4461 static void show_help(void)
4464 printf("usage: ffserver [-L] [-h] [-f configfile]\n"
4465 "Hyper fast multi format Audio/Video streaming server\n"
4467 "-L : print the LICENSE\n"
4469 "-f configfile : use configfile instead of /etc/ffserver.conf\n"
4473 static void show_license(void)
4477 "FFmpeg is free software; you can redistribute it and/or\n"
4478 "modify it under the terms of the GNU Lesser General Public\n"
4479 "License as published by the Free Software Foundation; either\n"
4480 "version 2.1 of the License, or (at your option) any later version.\n"
4482 "FFmpeg is distributed in the hope that it will be useful,\n"
4483 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
4484 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n"
4485 "Lesser General Public License for more details.\n"
4487 "You should have received a copy of the GNU Lesser General Public\n"
4488 "License along with FFmpeg; if not, write to the Free Software\n"
4489 "Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA\n"
4493 static void handle_child_exit(int sig)
4498 while ((pid = waitpid(-1, &status, WNOHANG)) > 0) {
4501 for (feed = first_feed; feed; feed = feed->next) {
4502 if (feed->pid == pid) {
4503 int uptime = time(0) - feed->pid_start;
4506 fprintf(stderr, "%s: Pid %d exited with status %d after %d seconds\n", feed->filename, pid, status, uptime);
4509 /* Turn off any more restarts */
4510 feed->child_argv = 0;
4516 need_to_start_children = 1;
4519 int main(int argc, char **argv)
4521 const char *config_filename;
4523 struct sigaction sigact;
4527 config_filename = "/etc/ffserver.conf";
4529 my_program_name = argv[0];
4530 my_program_dir = getcwd(0, 0);
4531 ffserver_daemon = 1;
4534 c = getopt(argc, argv, "ndLh?f:");
4550 ffserver_daemon = 0;
4553 config_filename = optarg;
4560 putenv("http_proxy"); /* Kill the http_proxy */
4562 av_init_random(av_gettime() + (getpid() << 16), &random_state);
4564 /* address on which the server will handle HTTP connections */
4565 my_http_addr.sin_family = AF_INET;
4566 my_http_addr.sin_port = htons (8080);
4567 my_http_addr.sin_addr.s_addr = htonl (INADDR_ANY);
4569 /* address on which the server will handle RTSP connections */
4570 my_rtsp_addr.sin_family = AF_INET;
4571 my_rtsp_addr.sin_port = htons (5454);
4572 my_rtsp_addr.sin_addr.s_addr = htonl (INADDR_ANY);
4574 nb_max_connections = 5;
4575 max_bandwidth = 1000;
4576 first_stream = NULL;
4577 logfilename[0] = '\0';
4579 memset(&sigact, 0, sizeof(sigact));
4580 sigact.sa_handler = handle_child_exit;
4581 sigact.sa_flags = SA_NOCLDSTOP | SA_RESTART;
4582 sigaction(SIGCHLD, &sigact, 0);
4584 if (parse_ffconfig(config_filename) < 0) {
4585 fprintf(stderr, "Incorrect config file - exiting.\n");
4589 build_file_streams();
4591 build_feed_streams();
4593 compute_bandwidth();
4595 /* put the process in background and detach it from its TTY */
4596 if (ffserver_daemon) {
4603 } else if (pid > 0) {
4611 open("/dev/null", O_RDWR);
4612 if (strcmp(logfilename, "-") != 0) {
4622 signal(SIGPIPE, SIG_IGN);
4624 /* open log file if needed */
4625 if (logfilename[0] != '\0') {
4626 if (!strcmp(logfilename, "-"))
4629 logfile = fopen(logfilename, "w");
4632 if (http_server() < 0) {
4633 fprintf(stderr, "Could not start server\n");