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
23 #ifndef HAVE_CLOSESOCKET
24 #define closesocket close
35 #include <sys/ioctl.h>
36 #ifdef HAVE_SYS_POLL_H
41 #undef time //needed because HAVE_AV_CONFIG_H is defined on top
58 static const char program_name[] = "FFserver";
59 static const int program_birth_year = 2000;
61 /* maximum number of simultaneous HTTP connections */
62 #define HTTP_MAX_CONNECTIONS 2000
65 HTTPSTATE_WAIT_REQUEST,
66 HTTPSTATE_SEND_HEADER,
67 HTTPSTATE_SEND_DATA_HEADER,
68 HTTPSTATE_SEND_DATA, /* sending TCP or UDP data */
69 HTTPSTATE_SEND_DATA_TRAILER,
70 HTTPSTATE_RECEIVE_DATA,
71 HTTPSTATE_WAIT_FEED, /* wait for data from the feed */
74 RTSPSTATE_WAIT_REQUEST,
76 RTSPSTATE_SEND_PACKET,
79 const char *http_state[] = {
95 #define IOBUFFER_INIT_SIZE 8192
97 /* timeouts are in ms */
98 #define HTTP_REQUEST_TIMEOUT (15 * 1000)
99 #define RTSP_REQUEST_TIMEOUT (3600 * 24 * 1000)
101 #define SYNC_TIMEOUT (10 * 1000)
104 int64_t count1, count2;
105 int64_t time1, time2;
108 /* context associated with one connection */
109 typedef struct HTTPContext {
110 enum HTTPState state;
111 int fd; /* socket file descriptor */
112 struct sockaddr_in from_addr; /* origin */
113 struct pollfd *poll_entry; /* used when polling */
115 uint8_t *buffer_ptr, *buffer_end;
118 struct HTTPContext *next;
119 int got_key_frame; /* stream 0 => 1, stream 1 => 2, stream 2=> 4 */
123 /* input format handling */
124 AVFormatContext *fmt_in;
125 int64_t start_time; /* In milliseconds - this wraps fairly often */
126 int64_t first_pts; /* initial pts value */
127 int64_t cur_pts; /* current pts value from the stream in us */
128 int64_t cur_frame_duration; /* duration of the current frame in us */
129 int cur_frame_bytes; /* output frame size, needed to compute
130 the time at which we send each
132 int pts_stream_index; /* stream we choose as clock reference */
133 int64_t cur_clock; /* current clock reference value in us */
134 /* output format handling */
135 struct FFStream *stream;
136 /* -1 is invalid stream */
137 int feed_streams[MAX_STREAMS]; /* index of streams in the feed */
138 int switch_feed_streams[MAX_STREAMS]; /* index of streams in the feed */
140 AVFormatContext fmt_ctx; /* instance of FFStream for one user */
141 int last_packet_sent; /* true if last data packet was sent */
143 DataRateData datarate;
150 int is_packetized; /* if true, the stream is packetized */
151 int packet_stream_index; /* current stream for output in state machine */
153 /* RTSP state specific */
154 uint8_t *pb_buffer; /* XXX: use that in all the code */
156 int seq; /* RTSP sequence number */
158 /* RTP state specific */
159 enum RTSPProtocol rtp_protocol;
160 char session_id[32]; /* session id */
161 AVFormatContext *rtp_ctx[MAX_STREAMS];
163 /* RTP/UDP specific */
164 URLContext *rtp_handles[MAX_STREAMS];
166 /* RTP/TCP specific */
167 struct HTTPContext *rtsp_c;
168 uint8_t *packet_buffer, *packet_buffer_ptr, *packet_buffer_end;
171 static AVFrame dummy_frame;
173 /* each generated stream is described here */
177 STREAM_TYPE_REDIRECT,
180 enum IPAddressAction {
185 typedef struct IPAddressACL {
186 struct IPAddressACL *next;
187 enum IPAddressAction action;
188 /* These are in host order */
189 struct in_addr first;
193 /* description of each stream of the ffserver.conf file */
194 typedef struct FFStream {
195 enum StreamType stream_type;
196 char filename[1024]; /* stream filename */
197 struct FFStream *feed; /* feed we are using (can be null if
199 AVFormatParameters *ap_in; /* input parameters */
200 AVInputFormat *ifmt; /* if non NULL, force input format */
204 int prebuffer; /* Number of millseconds early to start */
205 int64_t max_time; /* Number of milliseconds to run */
207 AVStream *streams[MAX_STREAMS];
208 int feed_streams[MAX_STREAMS]; /* index of streams in the feed */
209 char feed_filename[1024]; /* file name of the feed storage, or
210 input file name for a stream */
215 pid_t pid; /* Of ffmpeg process */
216 time_t pid_start; /* Of ffmpeg process */
218 struct FFStream *next;
219 int bandwidth; /* bandwidth, in kbits/s */
222 /* multicast specific */
224 struct in_addr multicast_ip;
225 int multicast_port; /* first port used for multicast */
227 int loop; /* if true, send the stream in loops (only meaningful if file) */
230 int feed_opened; /* true if someone is writing to the feed */
231 int is_feed; /* true if it is a feed */
232 int readonly; /* True if writing is prohibited to the file */
234 int64_t bytes_served;
235 int64_t feed_max_size; /* maximum storage size, zero means unlimited */
236 int64_t feed_write_index; /* current write position in feed (it wraps round) */
237 int64_t feed_size; /* current size of feed */
238 struct FFStream *next_feed;
241 typedef struct FeedData {
242 long long data_count;
243 float avg_frame_size; /* frame size averraged over last frames with exponential mean */
246 static struct sockaddr_in my_http_addr;
247 static struct sockaddr_in my_rtsp_addr;
249 static char logfilename[1024];
250 static HTTPContext *first_http_ctx;
251 static FFStream *first_feed; /* contains only feeds */
252 static FFStream *first_stream; /* contains all streams, including feeds */
254 static void new_connection(int server_fd, int is_rtsp);
255 static void close_connection(HTTPContext *c);
258 static int handle_connection(HTTPContext *c);
259 static int http_parse_request(HTTPContext *c);
260 static int http_send_data(HTTPContext *c);
261 static void compute_stats(HTTPContext *c);
262 static int open_input_stream(HTTPContext *c, const char *info);
263 static int http_start_receive_data(HTTPContext *c);
264 static int http_receive_data(HTTPContext *c);
267 static int rtsp_parse_request(HTTPContext *c);
268 static void rtsp_cmd_describe(HTTPContext *c, const char *url);
269 static void rtsp_cmd_options(HTTPContext *c, const char *url);
270 static void rtsp_cmd_setup(HTTPContext *c, const char *url, RTSPHeader *h);
271 static void rtsp_cmd_play(HTTPContext *c, const char *url, RTSPHeader *h);
272 static void rtsp_cmd_pause(HTTPContext *c, const char *url, RTSPHeader *h);
273 static void rtsp_cmd_teardown(HTTPContext *c, const char *url, RTSPHeader *h);
276 static int prepare_sdp_description(FFStream *stream, uint8_t **pbuffer,
277 struct in_addr my_ip);
280 static HTTPContext *rtp_new_connection(struct sockaddr_in *from_addr,
281 FFStream *stream, const char *session_id,
282 enum RTSPProtocol rtp_protocol);
283 static int rtp_new_av_stream(HTTPContext *c,
284 int stream_index, struct sockaddr_in *dest_addr,
285 HTTPContext *rtsp_c);
287 static const char *my_program_name;
288 static const char *my_program_dir;
290 static int ffserver_debug;
291 static int ffserver_daemon;
292 static int no_launch;
293 static int need_to_start_children;
295 static int nb_max_connections;
296 static int nb_connections;
298 static int max_bandwidth;
299 static int current_bandwidth;
301 static int64_t cur_time; // Making this global saves on passing it around everywhere
303 static AVRandomState random_state;
305 static FILE *logfile = NULL;
307 static void __attribute__ ((format (printf, 1, 2))) http_log(const char *fmt, ...)
313 vfprintf(logfile, fmt, ap);
319 static char *ctime1(char *buf2)
327 p = buf2 + strlen(p) - 1;
333 static void log_connection(HTTPContext *c)
340 http_log("%s - - [%s] \"%s %s %s\" %d %"PRId64"\n",
341 inet_ntoa(c->from_addr.sin_addr),
342 ctime1(buf2), c->method, c->url,
343 c->protocol, (c->http_error ? c->http_error : 200), c->data_count);
346 static void update_datarate(DataRateData *drd, int64_t count)
348 if (!drd->time1 && !drd->count1) {
349 drd->time1 = drd->time2 = cur_time;
350 drd->count1 = drd->count2 = count;
351 } else if (cur_time - drd->time2 > 5000) {
352 drd->time1 = drd->time2;
353 drd->count1 = drd->count2;
354 drd->time2 = cur_time;
359 /* In bytes per second */
360 static int compute_datarate(DataRateData *drd, int64_t count)
362 if (cur_time == drd->time1)
365 return ((count - drd->count1) * 1000) / (cur_time - drd->time1);
369 static void start_children(FFStream *feed)
374 for (; feed; feed = feed->next) {
375 if (feed->child_argv && !feed->pid) {
376 feed->pid_start = time(0);
381 fprintf(stderr, "Unable to create children\n");
390 for (i = 3; i < 256; i++)
393 if (!ffserver_debug) {
394 i = open("/dev/null", O_RDWR);
403 av_strlcpy(pathname, my_program_name, sizeof(pathname));
405 slash = strrchr(pathname, '/');
410 strcpy(slash, "ffmpeg");
412 /* This is needed to make relative pathnames work */
413 chdir(my_program_dir);
415 signal(SIGPIPE, SIG_DFL);
417 execvp(pathname, feed->child_argv);
425 /* open a listening socket */
426 static int socket_open_listen(struct sockaddr_in *my_addr)
430 server_fd = socket(AF_INET,SOCK_STREAM,0);
437 setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &tmp, sizeof(tmp));
439 if (bind (server_fd, (struct sockaddr *) my_addr, sizeof (*my_addr)) < 0) {
441 snprintf(bindmsg, sizeof(bindmsg), "bind(port %d)", ntohs(my_addr->sin_port));
443 closesocket(server_fd);
447 if (listen (server_fd, 5) < 0) {
449 closesocket(server_fd);
452 ff_socket_nonblock(server_fd, 1);
457 /* start all multicast streams */
458 static void start_multicast(void)
463 struct sockaddr_in dest_addr;
464 int default_port, stream_index;
467 for(stream = first_stream; stream != NULL; stream = stream->next) {
468 if (stream->is_multicast) {
469 /* open the RTP connection */
470 snprintf(session_id, sizeof(session_id), "%08x%08x",
471 av_random(&random_state), av_random(&random_state));
473 /* choose a port if none given */
474 if (stream->multicast_port == 0) {
475 stream->multicast_port = default_port;
479 dest_addr.sin_family = AF_INET;
480 dest_addr.sin_addr = stream->multicast_ip;
481 dest_addr.sin_port = htons(stream->multicast_port);
483 rtp_c = rtp_new_connection(&dest_addr, stream, session_id,
484 RTSP_PROTOCOL_RTP_UDP_MULTICAST);
488 if (open_input_stream(rtp_c, "") < 0) {
489 fprintf(stderr, "Could not open input stream for stream '%s'\n",
494 /* open each RTP stream */
495 for(stream_index = 0; stream_index < stream->nb_streams;
497 dest_addr.sin_port = htons(stream->multicast_port +
499 if (rtp_new_av_stream(rtp_c, stream_index, &dest_addr, NULL) < 0) {
500 fprintf(stderr, "Could not open output stream '%s/streamid=%d'\n",
501 stream->filename, stream_index);
506 /* change state to send data */
507 rtp_c->state = HTTPSTATE_SEND_DATA;
512 /* main loop of the http server */
513 static int http_server(void)
515 int server_fd, ret, rtsp_server_fd, delay, delay1;
516 struct pollfd poll_table[HTTP_MAX_CONNECTIONS + 2], *poll_entry;
517 HTTPContext *c, *c_next;
519 server_fd = socket_open_listen(&my_http_addr);
523 rtsp_server_fd = socket_open_listen(&my_rtsp_addr);
524 if (rtsp_server_fd < 0)
527 http_log("ffserver started.\n");
529 start_children(first_feed);
531 first_http_ctx = NULL;
537 poll_entry = poll_table;
538 poll_entry->fd = server_fd;
539 poll_entry->events = POLLIN;
542 poll_entry->fd = rtsp_server_fd;
543 poll_entry->events = POLLIN;
546 /* wait for events on each HTTP handle */
553 case HTTPSTATE_SEND_HEADER:
554 case RTSPSTATE_SEND_REPLY:
555 case RTSPSTATE_SEND_PACKET:
556 c->poll_entry = poll_entry;
558 poll_entry->events = POLLOUT;
561 case HTTPSTATE_SEND_DATA_HEADER:
562 case HTTPSTATE_SEND_DATA:
563 case HTTPSTATE_SEND_DATA_TRAILER:
564 if (!c->is_packetized) {
565 /* for TCP, we output as much as we can (may need to put a limit) */
566 c->poll_entry = poll_entry;
568 poll_entry->events = POLLOUT;
571 /* when ffserver is doing the timing, we work by
572 looking at which packet need to be sent every
574 delay1 = 10; /* one tick wait XXX: 10 ms assumed */
579 case HTTPSTATE_WAIT_REQUEST:
580 case HTTPSTATE_RECEIVE_DATA:
581 case HTTPSTATE_WAIT_FEED:
582 case RTSPSTATE_WAIT_REQUEST:
583 /* need to catch errors */
584 c->poll_entry = poll_entry;
586 poll_entry->events = POLLIN;/* Maybe this will work */
590 c->poll_entry = NULL;
596 /* wait for an event on one connection. We poll at least every
597 second to handle timeouts */
599 ret = poll(poll_table, poll_entry - poll_table, delay);
600 if (ret < 0 && ff_neterrno() != FF_NETERROR(EAGAIN) &&
601 ff_neterrno() != FF_NETERROR(EINTR))
605 cur_time = av_gettime() / 1000;
607 if (need_to_start_children) {
608 need_to_start_children = 0;
609 start_children(first_feed);
612 /* now handle the events */
613 for(c = first_http_ctx; c != NULL; c = c_next) {
615 if (handle_connection(c) < 0) {
616 /* close and free the connection */
622 poll_entry = poll_table;
623 /* new HTTP connection request ? */
624 if (poll_entry->revents & POLLIN)
625 new_connection(server_fd, 0);
627 /* new RTSP connection request ? */
628 if (poll_entry->revents & POLLIN)
629 new_connection(rtsp_server_fd, 1);
633 /* start waiting for a new HTTP/RTSP request */
634 static void start_wait_request(HTTPContext *c, int is_rtsp)
636 c->buffer_ptr = c->buffer;
637 c->buffer_end = c->buffer + c->buffer_size - 1; /* leave room for '\0' */
640 c->timeout = cur_time + RTSP_REQUEST_TIMEOUT;
641 c->state = RTSPSTATE_WAIT_REQUEST;
643 c->timeout = cur_time + HTTP_REQUEST_TIMEOUT;
644 c->state = HTTPSTATE_WAIT_REQUEST;
648 static void new_connection(int server_fd, int is_rtsp)
650 struct sockaddr_in from_addr;
652 HTTPContext *c = NULL;
654 len = sizeof(from_addr);
655 fd = accept(server_fd, (struct sockaddr *)&from_addr,
659 ff_socket_nonblock(fd, 1);
661 /* XXX: should output a warning page when coming
662 close to the connection limit */
663 if (nb_connections >= nb_max_connections)
666 /* add a new connection */
667 c = av_mallocz(sizeof(HTTPContext));
672 c->poll_entry = NULL;
673 c->from_addr = from_addr;
674 c->buffer_size = IOBUFFER_INIT_SIZE;
675 c->buffer = av_malloc(c->buffer_size);
679 c->next = first_http_ctx;
683 start_wait_request(c, is_rtsp);
695 static void close_connection(HTTPContext *c)
697 HTTPContext **cp, *c1;
699 AVFormatContext *ctx;
703 /* remove connection from list */
704 cp = &first_http_ctx;
705 while ((*cp) != NULL) {
713 /* remove references, if any (XXX: do it faster) */
714 for(c1 = first_http_ctx; c1 != NULL; c1 = c1->next) {
719 /* remove connection associated resources */
723 /* close each frame parser */
724 for(i=0;i<c->fmt_in->nb_streams;i++) {
725 st = c->fmt_in->streams[i];
726 if (st->codec->codec)
727 avcodec_close(st->codec);
729 av_close_input_file(c->fmt_in);
732 /* free RTP output streams if any */
735 nb_streams = c->stream->nb_streams;
737 for(i=0;i<nb_streams;i++) {
740 av_write_trailer(ctx);
743 h = c->rtp_handles[i];
750 if (!c->last_packet_sent) {
753 if (url_open_dyn_buf(&ctx->pb) >= 0) {
754 av_write_trailer(ctx);
755 url_close_dyn_buf(&ctx->pb, &c->pb_buffer);
760 for(i=0; i<ctx->nb_streams; i++)
761 av_free(ctx->streams[i]);
763 if (c->stream && !c->post && c->stream->stream_type == STREAM_TYPE_LIVE)
764 current_bandwidth -= c->stream->bandwidth;
766 /* signal that there is no feed if we are the feeder socket */
767 if (c->state == HTTPSTATE_RECEIVE_DATA && c->stream) {
768 c->stream->feed_opened = 0;
772 av_freep(&c->pb_buffer);
773 av_freep(&c->packet_buffer);
779 static int handle_connection(HTTPContext *c)
784 case HTTPSTATE_WAIT_REQUEST:
785 case RTSPSTATE_WAIT_REQUEST:
787 if ((c->timeout - cur_time) < 0)
789 if (c->poll_entry->revents & (POLLERR | POLLHUP))
792 /* no need to read if no events */
793 if (!(c->poll_entry->revents & POLLIN))
797 len = recv(c->fd, c->buffer_ptr, 1, 0);
799 if (ff_neterrno() != FF_NETERROR(EAGAIN) &&
800 ff_neterrno() != FF_NETERROR(EINTR))
802 } else if (len == 0) {
805 /* search for end of request. */
807 c->buffer_ptr += len;
809 if ((ptr >= c->buffer + 2 && !memcmp(ptr-2, "\n\n", 2)) ||
810 (ptr >= c->buffer + 4 && !memcmp(ptr-4, "\r\n\r\n", 4))) {
811 /* request found : parse it and reply */
812 if (c->state == HTTPSTATE_WAIT_REQUEST) {
813 ret = http_parse_request(c);
815 ret = rtsp_parse_request(c);
819 } else if (ptr >= c->buffer_end) {
820 /* request too long: cannot do anything */
822 } else goto read_loop;
826 case HTTPSTATE_SEND_HEADER:
827 if (c->poll_entry->revents & (POLLERR | POLLHUP))
830 /* no need to write if no events */
831 if (!(c->poll_entry->revents & POLLOUT))
833 len = send(c->fd, c->buffer_ptr, c->buffer_end - c->buffer_ptr, 0);
835 if (ff_neterrno() != FF_NETERROR(EAGAIN) &&
836 ff_neterrno() != FF_NETERROR(EINTR)) {
837 /* error : close connection */
838 av_freep(&c->pb_buffer);
842 c->buffer_ptr += len;
844 c->stream->bytes_served += len;
845 c->data_count += len;
846 if (c->buffer_ptr >= c->buffer_end) {
847 av_freep(&c->pb_buffer);
851 /* all the buffer was sent : synchronize to the incoming stream */
852 c->state = HTTPSTATE_SEND_DATA_HEADER;
853 c->buffer_ptr = c->buffer_end = c->buffer;
858 case HTTPSTATE_SEND_DATA:
859 case HTTPSTATE_SEND_DATA_HEADER:
860 case HTTPSTATE_SEND_DATA_TRAILER:
861 /* for packetized output, we consider we can always write (the
862 input streams sets the speed). It may be better to verify
863 that we do not rely too much on the kernel queues */
864 if (!c->is_packetized) {
865 if (c->poll_entry->revents & (POLLERR | POLLHUP))
868 /* no need to read if no events */
869 if (!(c->poll_entry->revents & POLLOUT))
872 if (http_send_data(c) < 0)
874 /* close connection if trailer sent */
875 if (c->state == HTTPSTATE_SEND_DATA_TRAILER)
878 case HTTPSTATE_RECEIVE_DATA:
879 /* no need to read if no events */
880 if (c->poll_entry->revents & (POLLERR | POLLHUP))
882 if (!(c->poll_entry->revents & POLLIN))
884 if (http_receive_data(c) < 0)
887 case HTTPSTATE_WAIT_FEED:
888 /* no need to read if no events */
889 if (c->poll_entry->revents & (POLLIN | POLLERR | POLLHUP))
892 /* nothing to do, we'll be waken up by incoming feed packets */
895 case RTSPSTATE_SEND_REPLY:
896 if (c->poll_entry->revents & (POLLERR | POLLHUP)) {
897 av_freep(&c->pb_buffer);
900 /* no need to write if no events */
901 if (!(c->poll_entry->revents & POLLOUT))
903 len = send(c->fd, c->buffer_ptr, c->buffer_end - c->buffer_ptr, 0);
905 if (ff_neterrno() != FF_NETERROR(EAGAIN) &&
906 ff_neterrno() != FF_NETERROR(EINTR)) {
907 /* error : close connection */
908 av_freep(&c->pb_buffer);
912 c->buffer_ptr += len;
913 c->data_count += len;
914 if (c->buffer_ptr >= c->buffer_end) {
915 /* all the buffer was sent : wait for a new request */
916 av_freep(&c->pb_buffer);
917 start_wait_request(c, 1);
921 case RTSPSTATE_SEND_PACKET:
922 if (c->poll_entry->revents & (POLLERR | POLLHUP)) {
923 av_freep(&c->packet_buffer);
926 /* no need to write if no events */
927 if (!(c->poll_entry->revents & POLLOUT))
929 len = send(c->fd, c->packet_buffer_ptr,
930 c->packet_buffer_end - c->packet_buffer_ptr, 0);
932 if (ff_neterrno() != FF_NETERROR(EAGAIN) &&
933 ff_neterrno() != FF_NETERROR(EINTR)) {
934 /* error : close connection */
935 av_freep(&c->packet_buffer);
939 c->packet_buffer_ptr += len;
940 if (c->packet_buffer_ptr >= c->packet_buffer_end) {
941 /* all the buffer was sent : wait for a new request */
942 av_freep(&c->packet_buffer);
943 c->state = RTSPSTATE_WAIT_REQUEST;
947 case HTTPSTATE_READY:
956 static int extract_rates(char *rates, int ratelen, const char *request)
960 for (p = request; *p && *p != '\r' && *p != '\n'; ) {
961 if (strncasecmp(p, "Pragma:", 7) == 0) {
962 const char *q = p + 7;
964 while (*q && *q != '\n' && isspace(*q))
967 if (strncasecmp(q, "stream-switch-entry=", 20) == 0) {
973 memset(rates, 0xff, ratelen);
976 while (*q && *q != '\n' && *q != ':')
979 if (sscanf(q, ":%d:%d", &stream_no, &rate_no) != 2)
983 if (stream_no < ratelen && stream_no >= 0)
984 rates[stream_no] = rate_no;
986 while (*q && *q != '\n' && !isspace(*q))
1003 static int find_stream_in_feed(FFStream *feed, AVCodecContext *codec, int bit_rate)
1006 int best_bitrate = 100000000;
1009 for (i = 0; i < feed->nb_streams; i++) {
1010 AVCodecContext *feed_codec = feed->streams[i]->codec;
1012 if (feed_codec->codec_id != codec->codec_id ||
1013 feed_codec->sample_rate != codec->sample_rate ||
1014 feed_codec->width != codec->width ||
1015 feed_codec->height != codec->height)
1018 /* Potential stream */
1020 /* We want the fastest stream less than bit_rate, or the slowest
1021 * faster than bit_rate
1024 if (feed_codec->bit_rate <= bit_rate) {
1025 if (best_bitrate > bit_rate || feed_codec->bit_rate > best_bitrate) {
1026 best_bitrate = feed_codec->bit_rate;
1030 if (feed_codec->bit_rate < best_bitrate) {
1031 best_bitrate = feed_codec->bit_rate;
1040 static int modify_current_stream(HTTPContext *c, char *rates)
1043 FFStream *req = c->stream;
1044 int action_required = 0;
1046 /* Not much we can do for a feed */
1050 for (i = 0; i < req->nb_streams; i++) {
1051 AVCodecContext *codec = req->streams[i]->codec;
1055 c->switch_feed_streams[i] = req->feed_streams[i];
1058 c->switch_feed_streams[i] = find_stream_in_feed(req->feed, codec, codec->bit_rate / 2);
1061 /* Wants off or slow */
1062 c->switch_feed_streams[i] = find_stream_in_feed(req->feed, codec, codec->bit_rate / 4);
1064 /* This doesn't work well when it turns off the only stream! */
1065 c->switch_feed_streams[i] = -2;
1066 c->feed_streams[i] = -2;
1071 if (c->switch_feed_streams[i] >= 0 && c->switch_feed_streams[i] != c->feed_streams[i])
1072 action_required = 1;
1075 return action_required;
1079 static void do_switch_stream(HTTPContext *c, int i)
1081 if (c->switch_feed_streams[i] >= 0) {
1083 c->feed_streams[i] = c->switch_feed_streams[i];
1086 /* Now update the stream */
1088 c->switch_feed_streams[i] = -1;
1091 /* XXX: factorize in utils.c ? */
1092 /* XXX: take care with different space meaning */
1093 static void skip_spaces(const char **pp)
1097 while (*p == ' ' || *p == '\t')
1102 static void get_word(char *buf, int buf_size, const char **pp)
1110 while (!isspace(*p) && *p != '\0') {
1111 if ((q - buf) < buf_size - 1)
1120 static int validate_acl(FFStream *stream, HTTPContext *c)
1122 enum IPAddressAction last_action = IP_DENY;
1124 struct in_addr *src = &c->from_addr.sin_addr;
1125 unsigned long src_addr = src->s_addr;
1127 for (acl = stream->acl; acl; acl = acl->next) {
1128 if (src_addr >= acl->first.s_addr && src_addr <= acl->last.s_addr)
1129 return (acl->action == IP_ALLOW) ? 1 : 0;
1130 last_action = acl->action;
1133 /* Nothing matched, so return not the last action */
1134 return (last_action == IP_DENY) ? 1 : 0;
1137 /* compute the real filename of a file by matching it without its
1138 extensions to all the stream filenames */
1139 static void compute_real_filename(char *filename, int max_size)
1146 /* compute filename by matching without the file extensions */
1147 av_strlcpy(file1, filename, sizeof(file1));
1148 p = strrchr(file1, '.');
1151 for(stream = first_stream; stream != NULL; stream = stream->next) {
1152 av_strlcpy(file2, stream->filename, sizeof(file2));
1153 p = strrchr(file2, '.');
1156 if (!strcmp(file1, file2)) {
1157 av_strlcpy(filename, stream->filename, max_size);
1172 /* parse http request and prepare header */
1173 static int http_parse_request(HTTPContext *c)
1176 enum RedirType redir_type;
1178 char info[1024], filename[1024];
1182 const char *mime_type;
1186 char *useragent = 0;
1189 get_word(cmd, sizeof(cmd), (const char **)&p);
1190 av_strlcpy(c->method, cmd, sizeof(c->method));
1192 if (!strcmp(cmd, "GET"))
1194 else if (!strcmp(cmd, "POST"))
1199 get_word(url, sizeof(url), (const char **)&p);
1200 av_strlcpy(c->url, url, sizeof(c->url));
1202 get_word(protocol, sizeof(protocol), (const char **)&p);
1203 if (strcmp(protocol, "HTTP/1.0") && strcmp(protocol, "HTTP/1.1"))
1206 av_strlcpy(c->protocol, protocol, sizeof(c->protocol));
1209 http_log("New connection: %s %s\n", cmd, url);
1211 /* find the filename and the optional info string in the request */
1212 p = strchr(url, '?');
1214 av_strlcpy(info, p, sizeof(info));
1219 av_strlcpy(filename, url + ((*url == '/') ? 1 : 0), sizeof(filename)-1);
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 av_strlcpy(filename, "index.html", sizeof(filename) - 1);
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, do not let start 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;
1310 if (c->post == 0 && max_bandwidth < current_bandwidth) {
1311 c->http_error = 200;
1313 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "HTTP/1.0 200 Server too busy\r\n");
1314 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "Content-type: text/html\r\n");
1315 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "\r\n");
1316 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "<html><head><title>Too busy</title></head><body>\r\n");
1317 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");
1318 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",
1319 current_bandwidth, max_bandwidth);
1320 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "</body></html>\r\n");
1322 /* prepare output buffer */
1323 c->buffer_ptr = c->buffer;
1325 c->state = HTTPSTATE_SEND_HEADER;
1329 if (redir_type != REDIR_NONE) {
1332 for (p = c->buffer; *p && *p != '\r' && *p != '\n'; ) {
1333 if (strncasecmp(p, "Host:", 5) == 0) {
1337 p = strchr(p, '\n');
1348 while (isspace(*hostinfo))
1351 eoh = strchr(hostinfo, '\n');
1353 if (eoh[-1] == '\r')
1356 if (eoh - hostinfo < sizeof(hostbuf) - 1) {
1357 memcpy(hostbuf, hostinfo, eoh - hostinfo);
1358 hostbuf[eoh - hostinfo] = 0;
1360 c->http_error = 200;
1362 switch(redir_type) {
1364 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "HTTP/1.0 200 ASX Follows\r\n");
1365 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "Content-type: video/x-ms-asf\r\n");
1366 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "\r\n");
1367 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "<ASX Version=\"3\">\r\n");
1368 //q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "<!-- Autogenerated by ffserver -->\r\n");
1369 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "<ENTRY><REF HREF=\"http://%s/%s%s\"/></ENTRY>\r\n",
1370 hostbuf, filename, info);
1371 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "</ASX>\r\n");
1374 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "HTTP/1.0 200 RAM Follows\r\n");
1375 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "Content-type: audio/x-pn-realaudio\r\n");
1376 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "\r\n");
1377 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "# Autogenerated by ffserver\r\n");
1378 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "http://%s/%s%s\r\n",
1379 hostbuf, filename, info);
1382 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "HTTP/1.0 200 ASF Redirect follows\r\n");
1383 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "Content-type: video/x-ms-asf\r\n");
1384 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "\r\n");
1385 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "[Reference]\r\n");
1386 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "Ref1=http://%s/%s%s\r\n",
1387 hostbuf, filename, info);
1391 char hostname[256], *p;
1392 /* extract only hostname */
1393 av_strlcpy(hostname, hostbuf, sizeof(hostname));
1394 p = strrchr(hostname, ':');
1397 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "HTTP/1.0 200 RTSP Redirect follows\r\n");
1398 /* XXX: incorrect mime type ? */
1399 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "Content-type: application/x-rtsp\r\n");
1400 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "\r\n");
1401 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "rtsp://%s:%d/%s\r\n",
1402 hostname, ntohs(my_rtsp_addr.sin_port),
1409 int sdp_data_size, len;
1410 struct sockaddr_in my_addr;
1412 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "HTTP/1.0 200 OK\r\n");
1413 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "Content-type: application/sdp\r\n");
1414 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "\r\n");
1416 len = sizeof(my_addr);
1417 getsockname(c->fd, (struct sockaddr *)&my_addr, &len);
1419 /* XXX: should use a dynamic buffer */
1420 sdp_data_size = prepare_sdp_description(stream,
1423 if (sdp_data_size > 0) {
1424 memcpy(q, sdp_data, sdp_data_size);
1436 /* prepare output buffer */
1437 c->buffer_ptr = c->buffer;
1439 c->state = HTTPSTATE_SEND_HEADER;
1445 snprintf(msg, sizeof(msg), "ASX/RAM file not handled");
1449 stream->conns_served++;
1451 /* XXX: add there authenticate and IP match */
1454 /* if post, it means a feed is being sent */
1455 if (!stream->is_feed) {
1456 /* However it might be a status report from WMP! Lets log the data
1457 * as it might come in handy one day
1462 for (p = c->buffer; *p && *p != '\r' && *p != '\n'; ) {
1463 if (strncasecmp(p, "Pragma: log-line=", 17) == 0) {
1467 if (strncasecmp(p, "Pragma: client-id=", 18) == 0)
1468 client_id = strtol(p + 18, 0, 10);
1469 p = strchr(p, '\n');
1477 char *eol = strchr(logline, '\n');
1482 if (eol[-1] == '\r')
1484 http_log("%.*s\n", (int) (eol - logline), logline);
1485 c->suppress_log = 1;
1490 http_log("\nGot request:\n%s\n", c->buffer);
1493 if (client_id && extract_rates(ratebuf, sizeof(ratebuf), c->buffer)) {
1496 /* Now we have to find the client_id */
1497 for (wmpc = first_http_ctx; wmpc; wmpc = wmpc->next) {
1498 if (wmpc->wmp_client_id == client_id)
1502 if (wmpc && modify_current_stream(wmpc, ratebuf))
1503 wmpc->switch_pending = 1;
1506 snprintf(msg, sizeof(msg), "POST command not handled");
1510 if (http_start_receive_data(c) < 0) {
1511 snprintf(msg, sizeof(msg), "could not open feed");
1515 c->state = HTTPSTATE_RECEIVE_DATA;
1520 if (strcmp(stream->filename + strlen(stream->filename) - 4, ".asf") == 0)
1521 http_log("\nGot request:\n%s\n", c->buffer);
1524 if (c->stream->stream_type == STREAM_TYPE_STATUS)
1527 /* open input stream */
1528 if (open_input_stream(c, info) < 0) {
1529 snprintf(msg, sizeof(msg), "Input stream corresponding to '%s' not found", url);
1533 /* prepare http header */
1535 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "HTTP/1.0 200 OK\r\n");
1536 mime_type = c->stream->fmt->mime_type;
1538 mime_type = "application/x-octet-stream";
1539 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "Pragma: no-cache\r\n");
1541 /* for asf, we need extra headers */
1542 if (!strcmp(c->stream->fmt->name,"asf_stream")) {
1543 /* Need to allocate a client id */
1545 c->wmp_client_id = av_random(&random_state) & 0x7fffffff;
1547 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);
1549 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "Content-Type: %s\r\n", mime_type);
1550 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "\r\n");
1552 /* prepare output buffer */
1554 c->buffer_ptr = c->buffer;
1556 c->state = HTTPSTATE_SEND_HEADER;
1559 c->http_error = 404;
1561 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "HTTP/1.0 404 Not Found\r\n");
1562 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "Content-type: %s\r\n", "text/html");
1563 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "\r\n");
1564 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "<HTML>\n");
1565 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "<HEAD><TITLE>404 Not Found</TITLE></HEAD>\n");
1566 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "<BODY>%s</BODY>\n", msg);
1567 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "</HTML>\n");
1569 /* prepare output buffer */
1570 c->buffer_ptr = c->buffer;
1572 c->state = HTTPSTATE_SEND_HEADER;
1576 c->http_error = 200; /* horrible : we use this value to avoid
1577 going to the send data state */
1578 c->state = HTTPSTATE_SEND_HEADER;
1582 static void fmt_bytecount(ByteIOContext *pb, int64_t count)
1584 static const char *suffix = " kMGTP";
1587 for (s = suffix; count >= 100000 && s[1]; count /= 1000, s++);
1589 url_fprintf(pb, "%"PRId64"%c", count, *s);
1592 static void compute_stats(HTTPContext *c)
1599 ByteIOContext pb1, *pb = &pb1;
1601 if (url_open_dyn_buf(pb) < 0) {
1602 /* XXX: return an error ? */
1603 c->buffer_ptr = c->buffer;
1604 c->buffer_end = c->buffer;
1608 url_fprintf(pb, "HTTP/1.0 200 OK\r\n");
1609 url_fprintf(pb, "Content-type: %s\r\n", "text/html");
1610 url_fprintf(pb, "Pragma: no-cache\r\n");
1611 url_fprintf(pb, "\r\n");
1613 url_fprintf(pb, "<HEAD><TITLE>FFServer Status</TITLE>\n");
1614 if (c->stream->feed_filename)
1615 url_fprintf(pb, "<link rel=\"shortcut icon\" href=\"%s\">\n", c->stream->feed_filename);
1616 url_fprintf(pb, "</HEAD>\n<BODY>");
1617 url_fprintf(pb, "<H1>FFServer Status</H1>\n");
1619 url_fprintf(pb, "<H2>Available Streams</H2>\n");
1620 url_fprintf(pb, "<TABLE cellspacing=0 cellpadding=4>\n");
1621 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");
1622 stream = first_stream;
1623 while (stream != NULL) {
1624 char sfilename[1024];
1627 if (stream->feed != stream) {
1628 av_strlcpy(sfilename, stream->filename, sizeof(sfilename) - 10);
1629 eosf = sfilename + strlen(sfilename);
1630 if (eosf - sfilename >= 4) {
1631 if (strcmp(eosf - 4, ".asf") == 0)
1632 strcpy(eosf - 4, ".asx");
1633 else if (strcmp(eosf - 3, ".rm") == 0)
1634 strcpy(eosf - 3, ".ram");
1635 else if (stream->fmt && !strcmp(stream->fmt->name, "rtp")) {
1636 /* generate a sample RTSP director if
1637 unicast. Generate an SDP redirector if
1639 eosf = strrchr(sfilename, '.');
1641 eosf = sfilename + strlen(sfilename);
1642 if (stream->is_multicast)
1643 strcpy(eosf, ".sdp");
1645 strcpy(eosf, ".rtsp");
1649 url_fprintf(pb, "<TR><TD><A HREF=\"/%s\">%s</A> ",
1650 sfilename, stream->filename);
1651 url_fprintf(pb, "<td align=right> %d <td align=right> ",
1652 stream->conns_served);
1653 fmt_bytecount(pb, stream->bytes_served);
1654 switch(stream->stream_type) {
1655 case STREAM_TYPE_LIVE:
1657 int audio_bit_rate = 0;
1658 int video_bit_rate = 0;
1659 const char *audio_codec_name = "";
1660 const char *video_codec_name = "";
1661 const char *audio_codec_name_extra = "";
1662 const char *video_codec_name_extra = "";
1664 for(i=0;i<stream->nb_streams;i++) {
1665 AVStream *st = stream->streams[i];
1666 AVCodec *codec = avcodec_find_encoder(st->codec->codec_id);
1667 switch(st->codec->codec_type) {
1668 case CODEC_TYPE_AUDIO:
1669 audio_bit_rate += st->codec->bit_rate;
1671 if (*audio_codec_name)
1672 audio_codec_name_extra = "...";
1673 audio_codec_name = codec->name;
1676 case CODEC_TYPE_VIDEO:
1677 video_bit_rate += st->codec->bit_rate;
1679 if (*video_codec_name)
1680 video_codec_name_extra = "...";
1681 video_codec_name = codec->name;
1684 case CODEC_TYPE_DATA:
1685 video_bit_rate += st->codec->bit_rate;
1691 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",
1694 video_bit_rate / 1000, video_codec_name, video_codec_name_extra,
1695 audio_bit_rate / 1000, audio_codec_name, audio_codec_name_extra);
1697 url_fprintf(pb, "<TD>%s", stream->feed->filename);
1699 url_fprintf(pb, "<TD>%s", stream->feed_filename);
1700 url_fprintf(pb, "\n");
1704 url_fprintf(pb, "<TD align=center> - <TD align=right> - <TD align=right> - <td><td align=right> - <TD>\n");
1708 stream = stream->next;
1710 url_fprintf(pb, "</TABLE>\n");
1712 stream = first_stream;
1713 while (stream != NULL) {
1714 if (stream->feed == stream) {
1715 url_fprintf(pb, "<h2>Feed %s</h2>", stream->filename);
1717 url_fprintf(pb, "Running as pid %d.\n", stream->pid);
1719 #if defined(linux) && !defined(CONFIG_NOCUTILS)
1724 /* This is somewhat linux specific I guess */
1725 snprintf(ps_cmd, sizeof(ps_cmd),
1726 "ps -o \"%%cpu,cputime\" --no-headers %d",
1729 pid_stat = popen(ps_cmd, "r");
1734 if (fscanf(pid_stat, "%10s %64s", cpuperc,
1736 url_fprintf(pb, "Currently using %s%% of the cpu. Total time used %s.\n",
1744 url_fprintf(pb, "<p>");
1746 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");
1748 for (i = 0; i < stream->nb_streams; i++) {
1749 AVStream *st = stream->streams[i];
1750 AVCodec *codec = avcodec_find_encoder(st->codec->codec_id);
1751 const char *type = "unknown";
1752 char parameters[64];
1756 switch(st->codec->codec_type) {
1757 case CODEC_TYPE_AUDIO:
1759 snprintf(parameters, sizeof(parameters), "%d channel(s), %d Hz", st->codec->channels, st->codec->sample_rate);
1761 case CODEC_TYPE_VIDEO:
1763 snprintf(parameters, sizeof(parameters), "%dx%d, q=%d-%d, fps=%d", st->codec->width, st->codec->height,
1764 st->codec->qmin, st->codec->qmax, st->codec->time_base.den / st->codec->time_base.num);
1769 url_fprintf(pb, "<tr><td align=right>%d<td>%s<td align=right>%d<td>%s<td>%s\n",
1770 i, type, st->codec->bit_rate/1000, codec ? codec->name : "", parameters);
1772 url_fprintf(pb, "</table>\n");
1775 stream = stream->next;
1781 AVCodecContext *enc;
1785 stream = first_feed;
1786 while (stream != NULL) {
1787 url_fprintf(pb, "<H1>Feed '%s'</H1>\n", stream->filename);
1788 url_fprintf(pb, "<TABLE>\n");
1789 url_fprintf(pb, "<TR><TD>Parameters<TD>Frame count<TD>Size<TD>Avg bitrate (kbits/s)\n");
1790 for(i=0;i<stream->nb_streams;i++) {
1791 AVStream *st = stream->streams[i];
1792 FeedData *fdata = st->priv_data;
1795 avcodec_string(buf, sizeof(buf), enc);
1796 avg = fdata->avg_frame_size * (float)enc->rate * 8.0;
1797 if (enc->codec->type == CODEC_TYPE_AUDIO && enc->frame_size > 0)
1798 avg /= enc->frame_size;
1799 url_fprintf(pb, "<TR><TD>%s <TD> %d <TD> %"PRId64" <TD> %0.1f\n",
1800 buf, enc->frame_number, fdata->data_count, avg / 1000.0);
1802 url_fprintf(pb, "</TABLE>\n");
1803 stream = stream->next_feed;
1808 /* connection status */
1809 url_fprintf(pb, "<H2>Connection Status</H2>\n");
1811 url_fprintf(pb, "Number of connections: %d / %d<BR>\n",
1812 nb_connections, nb_max_connections);
1814 url_fprintf(pb, "Bandwidth in use: %dk / %dk<BR>\n",
1815 current_bandwidth, max_bandwidth);
1817 url_fprintf(pb, "<TABLE>\n");
1818 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");
1819 c1 = first_http_ctx;
1821 while (c1 != NULL) {
1827 for (j = 0; j < c1->stream->nb_streams; j++) {
1828 if (!c1->stream->feed)
1829 bitrate += c1->stream->streams[j]->codec->bit_rate;
1830 else if (c1->feed_streams[j] >= 0)
1831 bitrate += c1->stream->feed->streams[c1->feed_streams[j]]->codec->bit_rate;
1836 p = inet_ntoa(c1->from_addr.sin_addr);
1837 url_fprintf(pb, "<TR><TD><B>%d</B><TD>%s%s<TD>%s<TD>%s<TD>%s<td align=right>",
1839 c1->stream ? c1->stream->filename : "",
1840 c1->state == HTTPSTATE_RECEIVE_DATA ? "(input)" : "",
1843 http_state[c1->state]);
1844 fmt_bytecount(pb, bitrate);
1845 url_fprintf(pb, "<td align=right>");
1846 fmt_bytecount(pb, compute_datarate(&c1->datarate, c1->data_count) * 8);
1847 url_fprintf(pb, "<td align=right>");
1848 fmt_bytecount(pb, c1->data_count);
1849 url_fprintf(pb, "\n");
1852 url_fprintf(pb, "</TABLE>\n");
1857 url_fprintf(pb, "<HR size=1 noshade>Generated at %s", p);
1858 url_fprintf(pb, "</BODY>\n</HTML>\n");
1860 len = url_close_dyn_buf(pb, &c->pb_buffer);
1861 c->buffer_ptr = c->pb_buffer;
1862 c->buffer_end = c->pb_buffer + len;
1865 /* check if the parser needs to be opened for stream i */
1866 static void open_parser(AVFormatContext *s, int i)
1868 AVStream *st = s->streams[i];
1871 if (!st->codec->codec) {
1872 codec = avcodec_find_decoder(st->codec->codec_id);
1873 if (codec && (codec->capabilities & CODEC_CAP_PARSE_ONLY)) {
1874 st->codec->parse_only = 1;
1875 if (avcodec_open(st->codec, codec) < 0)
1876 st->codec->parse_only = 0;
1881 static int open_input_stream(HTTPContext *c, const char *info)
1884 char input_filename[1024];
1889 /* find file name */
1890 if (c->stream->feed) {
1891 strcpy(input_filename, c->stream->feed->feed_filename);
1892 buf_size = FFM_PACKET_SIZE;
1893 /* compute position (absolute time) */
1894 if (find_info_tag(buf, sizeof(buf), "date", info))
1896 stream_pos = parse_date(buf, 0);
1897 if (stream_pos == INT64_MIN)
1900 else if (find_info_tag(buf, sizeof(buf), "buffer", info)) {
1901 int prebuffer = strtol(buf, 0, 10);
1902 stream_pos = av_gettime() - prebuffer * (int64_t)1000000;
1904 stream_pos = av_gettime() - c->stream->prebuffer * (int64_t)1000;
1906 strcpy(input_filename, c->stream->feed_filename);
1908 /* compute position (relative time) */
1909 if (find_info_tag(buf, sizeof(buf), "date", info))
1911 stream_pos = parse_date(buf, 1);
1912 if (stream_pos == INT64_MIN)
1918 if (input_filename[0] == '\0')
1922 { time_t when = stream_pos / 1000000;
1923 http_log("Stream pos = %"PRId64", time=%s", stream_pos, ctime(&when));
1928 if (av_open_input_file(&s, input_filename, c->stream->ifmt,
1929 buf_size, c->stream->ap_in) < 0) {
1930 http_log("%s not found", input_filename);
1933 s->flags |= AVFMT_FLAG_GENPTS;
1935 av_find_stream_info(c->fmt_in);
1937 /* open each parser */
1938 for(i=0;i<s->nb_streams;i++)
1941 /* choose stream as clock source (we favorize video stream if
1942 present) for packet sending */
1943 c->pts_stream_index = 0;
1944 for(i=0;i<c->stream->nb_streams;i++) {
1945 if (c->pts_stream_index == 0 &&
1946 c->stream->streams[i]->codec->codec_type == CODEC_TYPE_VIDEO) {
1947 c->pts_stream_index = i;
1952 if (c->fmt_in->iformat->read_seek)
1953 c->fmt_in->iformat->read_seek(c->fmt_in, 0, stream_pos, 0);
1955 /* set the start time (needed for maxtime and RTP packet timing) */
1956 c->start_time = cur_time;
1957 c->first_pts = AV_NOPTS_VALUE;
1961 /* return the server clock (in us) */
1962 static int64_t get_server_clock(HTTPContext *c)
1964 /* compute current pts value from system time */
1965 return (cur_time - c->start_time) * 1000;
1968 /* return the estimated time at which the current packet must be sent
1970 static int64_t get_packet_send_clock(HTTPContext *c)
1972 int bytes_left, bytes_sent, frame_bytes;
1974 frame_bytes = c->cur_frame_bytes;
1975 if (frame_bytes <= 0)
1978 bytes_left = c->buffer_end - c->buffer_ptr;
1979 bytes_sent = frame_bytes - bytes_left;
1980 return c->cur_pts + (c->cur_frame_duration * bytes_sent) / frame_bytes;
1985 static int http_prepare_data(HTTPContext *c)
1988 AVFormatContext *ctx;
1990 av_freep(&c->pb_buffer);
1992 case HTTPSTATE_SEND_DATA_HEADER:
1993 memset(&c->fmt_ctx, 0, sizeof(c->fmt_ctx));
1994 av_strlcpy(c->fmt_ctx.author, c->stream->author,
1995 sizeof(c->fmt_ctx.author));
1996 av_strlcpy(c->fmt_ctx.comment, c->stream->comment,
1997 sizeof(c->fmt_ctx.comment));
1998 av_strlcpy(c->fmt_ctx.copyright, c->stream->copyright,
1999 sizeof(c->fmt_ctx.copyright));
2000 av_strlcpy(c->fmt_ctx.title, c->stream->title,
2001 sizeof(c->fmt_ctx.title));
2003 /* open output stream by using specified codecs */
2004 c->fmt_ctx.oformat = c->stream->fmt;
2005 c->fmt_ctx.nb_streams = c->stream->nb_streams;
2006 for(i=0;i<c->fmt_ctx.nb_streams;i++) {
2009 st = av_mallocz(sizeof(AVStream));
2010 st->codec= avcodec_alloc_context();
2011 c->fmt_ctx.streams[i] = st;
2012 /* if file or feed, then just take streams from FFStream struct */
2013 if (!c->stream->feed ||
2014 c->stream->feed == c->stream)
2015 src = c->stream->streams[i];
2017 src = c->stream->feed->streams[c->stream->feed_streams[i]];
2021 st->codec->frame_number = 0; /* XXX: should be done in
2022 AVStream, not in codec */
2023 /* I'm pretty sure that this is not correct...
2024 * However, without it, we crash
2026 st->codec->coded_frame = &dummy_frame;
2028 c->got_key_frame = 0;
2030 /* prepare header and save header data in a stream */
2031 if (url_open_dyn_buf(&c->fmt_ctx.pb) < 0) {
2032 /* XXX: potential leak */
2035 c->fmt_ctx.pb.is_streamed = 1;
2037 av_set_parameters(&c->fmt_ctx, NULL);
2038 if (av_write_header(&c->fmt_ctx) < 0)
2041 len = url_close_dyn_buf(&c->fmt_ctx.pb, &c->pb_buffer);
2042 c->buffer_ptr = c->pb_buffer;
2043 c->buffer_end = c->pb_buffer + len;
2045 c->state = HTTPSTATE_SEND_DATA;
2046 c->last_packet_sent = 0;
2048 case HTTPSTATE_SEND_DATA:
2049 /* find a new packet */
2053 /* read a packet from the input stream */
2054 if (c->stream->feed)
2055 ffm_set_write_index(c->fmt_in,
2056 c->stream->feed->feed_write_index,
2057 c->stream->feed->feed_size);
2059 if (c->stream->max_time &&
2060 c->stream->max_time + c->start_time - cur_time < 0)
2061 /* We have timed out */
2062 c->state = HTTPSTATE_SEND_DATA_TRAILER;
2065 if (av_read_frame(c->fmt_in, &pkt) < 0) {
2066 if (c->stream->feed && c->stream->feed->feed_opened) {
2067 /* if coming from feed, it means we reached the end of the
2068 ffm file, so must wait for more data */
2069 c->state = HTTPSTATE_WAIT_FEED;
2070 return 1; /* state changed */
2072 if (c->stream->loop) {
2073 av_close_input_file(c->fmt_in);
2075 if (open_input_stream(c, "") < 0)
2080 /* must send trailer now because eof or error */
2081 c->state = HTTPSTATE_SEND_DATA_TRAILER;
2085 /* update first pts if needed */
2086 if (c->first_pts == AV_NOPTS_VALUE) {
2087 c->first_pts = av_rescale_q(pkt.dts, c->fmt_in->streams[pkt.stream_index]->time_base, AV_TIME_BASE_Q);
2088 c->start_time = cur_time;
2090 /* send it to the appropriate stream */
2091 if (c->stream->feed) {
2092 /* if coming from a feed, select the right stream */
2093 if (c->switch_pending) {
2094 c->switch_pending = 0;
2095 for(i=0;i<c->stream->nb_streams;i++) {
2096 if (c->switch_feed_streams[i] == pkt.stream_index)
2097 if (pkt.flags & PKT_FLAG_KEY)
2098 do_switch_stream(c, i);
2099 if (c->switch_feed_streams[i] >= 0)
2100 c->switch_pending = 1;
2103 for(i=0;i<c->stream->nb_streams;i++) {
2104 if (c->feed_streams[i] == pkt.stream_index) {
2105 pkt.stream_index = i;
2106 if (pkt.flags & PKT_FLAG_KEY)
2107 c->got_key_frame |= 1 << i;
2108 /* See if we have all the key frames, then
2109 * we start to send. This logic is not quite
2110 * right, but it works for the case of a
2111 * single video stream with one or more
2112 * audio streams (for which every frame is
2113 * typically a key frame).
2115 if (!c->stream->send_on_key ||
2116 ((c->got_key_frame + 1) >> c->stream->nb_streams))
2121 AVCodecContext *codec;
2124 /* specific handling for RTP: we use several
2125 output stream (one for each RTP
2126 connection). XXX: need more abstract handling */
2127 if (c->is_packetized) {
2129 /* compute send time and duration */
2130 st = c->fmt_in->streams[pkt.stream_index];
2131 c->cur_pts = av_rescale_q(pkt.dts, st->time_base, AV_TIME_BASE_Q);
2132 if (st->start_time != AV_NOPTS_VALUE)
2133 c->cur_pts -= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
2134 c->cur_frame_duration = av_rescale_q(pkt.duration, st->time_base, AV_TIME_BASE_Q);
2136 printf("index=%d pts=%0.3f duration=%0.6f\n",
2138 (double)c->cur_pts /
2140 (double)c->cur_frame_duration /
2143 /* find RTP context */
2144 c->packet_stream_index = pkt.stream_index;
2145 ctx = c->rtp_ctx[c->packet_stream_index];
2147 av_free_packet(&pkt);
2150 codec = ctx->streams[0]->codec;
2151 /* only one stream per RTP connection */
2152 pkt.stream_index = 0;
2156 codec = ctx->streams[pkt.stream_index]->codec;
2159 codec->coded_frame->key_frame = ((pkt.flags & PKT_FLAG_KEY) != 0);
2160 if (c->is_packetized) {
2161 int max_packet_size;
2162 if (c->rtp_protocol == RTSP_PROTOCOL_RTP_TCP)
2163 max_packet_size = RTSP_TCP_MAX_PACKET_SIZE;
2165 max_packet_size = url_get_max_packet_size(c->rtp_handles[c->packet_stream_index]);
2166 ret = url_open_dyn_packet_buf(&ctx->pb, max_packet_size);
2168 ret = url_open_dyn_buf(&ctx->pb);
2171 /* XXX: potential leak */
2174 if (pkt.dts != AV_NOPTS_VALUE)
2175 pkt.dts = av_rescale_q(pkt.dts,
2176 c->fmt_in->streams[pkt.stream_index]->time_base,
2177 ctx->streams[pkt.stream_index]->time_base);
2178 if (pkt.pts != AV_NOPTS_VALUE)
2179 pkt.pts = av_rescale_q(pkt.pts,
2180 c->fmt_in->streams[pkt.stream_index]->time_base,
2181 ctx->streams[pkt.stream_index]->time_base);
2182 if (av_write_frame(ctx, &pkt))
2183 c->state = HTTPSTATE_SEND_DATA_TRAILER;
2185 len = url_close_dyn_buf(&ctx->pb, &c->pb_buffer);
2186 c->cur_frame_bytes = len;
2187 c->buffer_ptr = c->pb_buffer;
2188 c->buffer_end = c->pb_buffer + len;
2190 codec->frame_number++;
2194 av_free_packet(&pkt);
2200 case HTTPSTATE_SEND_DATA_TRAILER:
2201 /* last packet test ? */
2202 if (c->last_packet_sent || c->is_packetized)
2205 /* prepare header */
2206 if (url_open_dyn_buf(&ctx->pb) < 0) {
2207 /* XXX: potential leak */
2210 av_write_trailer(ctx);
2211 len = url_close_dyn_buf(&ctx->pb, &c->pb_buffer);
2212 c->buffer_ptr = c->pb_buffer;
2213 c->buffer_end = c->pb_buffer + len;
2215 c->last_packet_sent = 1;
2221 /* should convert the format at the same time */
2222 /* send data starting at c->buffer_ptr to the output connection
2223 (either UDP or TCP connection) */
2224 static int http_send_data(HTTPContext *c)
2229 if (c->buffer_ptr >= c->buffer_end) {
2230 ret = http_prepare_data(c);
2234 /* state change requested */
2237 if (c->is_packetized) {
2238 /* RTP data output */
2239 len = c->buffer_end - c->buffer_ptr;
2241 /* fail safe - should never happen */
2243 c->buffer_ptr = c->buffer_end;
2246 len = (c->buffer_ptr[0] << 24) |
2247 (c->buffer_ptr[1] << 16) |
2248 (c->buffer_ptr[2] << 8) |
2250 if (len > (c->buffer_end - c->buffer_ptr))
2252 if ((get_packet_send_clock(c) - get_server_clock(c)) > 0) {
2253 /* nothing to send yet: we can wait */
2257 c->data_count += len;
2258 update_datarate(&c->datarate, c->data_count);
2260 c->stream->bytes_served += len;
2262 if (c->rtp_protocol == RTSP_PROTOCOL_RTP_TCP) {
2263 /* RTP packets are sent inside the RTSP TCP connection */
2264 ByteIOContext pb1, *pb = &pb1;
2265 int interleaved_index, size;
2267 HTTPContext *rtsp_c;
2270 /* if no RTSP connection left, error */
2273 /* if already sending something, then wait. */
2274 if (rtsp_c->state != RTSPSTATE_WAIT_REQUEST)
2276 if (url_open_dyn_buf(pb) < 0)
2278 interleaved_index = c->packet_stream_index * 2;
2279 /* RTCP packets are sent at odd indexes */
2280 if (c->buffer_ptr[1] == 200)
2281 interleaved_index++;
2282 /* write RTSP TCP header */
2284 header[1] = interleaved_index;
2285 header[2] = len >> 8;
2287 put_buffer(pb, header, 4);
2288 /* write RTP packet data */
2290 put_buffer(pb, c->buffer_ptr, len);
2291 size = url_close_dyn_buf(pb, &c->packet_buffer);
2292 /* prepare asynchronous TCP sending */
2293 rtsp_c->packet_buffer_ptr = c->packet_buffer;
2294 rtsp_c->packet_buffer_end = c->packet_buffer + size;
2295 c->buffer_ptr += len;
2297 /* send everything we can NOW */
2298 len = send(rtsp_c->fd, rtsp_c->packet_buffer_ptr,
2299 rtsp_c->packet_buffer_end - rtsp_c->packet_buffer_ptr, 0);
2301 rtsp_c->packet_buffer_ptr += len;
2302 if (rtsp_c->packet_buffer_ptr < rtsp_c->packet_buffer_end) {
2303 /* if we could not send all the data, we will
2304 send it later, so a new state is needed to
2305 "lock" the RTSP TCP connection */
2306 rtsp_c->state = RTSPSTATE_SEND_PACKET;
2309 /* all data has been sent */
2310 av_freep(&c->packet_buffer);
2312 /* send RTP packet directly in UDP */
2314 url_write(c->rtp_handles[c->packet_stream_index],
2315 c->buffer_ptr, len);
2316 c->buffer_ptr += len;
2317 /* here we continue as we can send several packets per 10 ms slot */
2320 /* TCP data output */
2321 len = send(c->fd, c->buffer_ptr, c->buffer_end - c->buffer_ptr, 0);
2323 if (ff_neterrno() != FF_NETERROR(EAGAIN) &&
2324 ff_neterrno() != FF_NETERROR(EINTR))
2325 /* error : close connection */
2330 c->buffer_ptr += len;
2332 c->data_count += len;
2333 update_datarate(&c->datarate, c->data_count);
2335 c->stream->bytes_served += len;
2343 static int http_start_receive_data(HTTPContext *c)
2347 if (c->stream->feed_opened)
2350 /* Don't permit writing to this one */
2351 if (c->stream->readonly)
2355 fd = open(c->stream->feed_filename, O_RDWR);
2360 c->stream->feed_write_index = ffm_read_write_index(fd);
2361 c->stream->feed_size = lseek(fd, 0, SEEK_END);
2362 lseek(fd, 0, SEEK_SET);
2364 /* init buffer input */
2365 c->buffer_ptr = c->buffer;
2366 c->buffer_end = c->buffer + FFM_PACKET_SIZE;
2367 c->stream->feed_opened = 1;
2371 static int http_receive_data(HTTPContext *c)
2375 if (c->buffer_end > c->buffer_ptr) {
2378 len = recv(c->fd, c->buffer_ptr, c->buffer_end - c->buffer_ptr, 0);
2380 if (ff_neterrno() != FF_NETERROR(EAGAIN) &&
2381 ff_neterrno() != FF_NETERROR(EINTR))
2382 /* error : close connection */
2384 } else if (len == 0)
2385 /* end of connection : close it */
2388 c->buffer_ptr += len;
2389 c->data_count += len;
2390 update_datarate(&c->datarate, c->data_count);
2394 if (c->buffer_ptr - c->buffer >= 2 && c->data_count > FFM_PACKET_SIZE) {
2395 if (c->buffer[0] != 'f' ||
2396 c->buffer[1] != 'm') {
2397 http_log("Feed stream has become desynchronized -- disconnecting\n");
2402 if (c->buffer_ptr >= c->buffer_end) {
2403 FFStream *feed = c->stream;
2404 /* a packet has been received : write it in the store, except
2406 if (c->data_count > FFM_PACKET_SIZE) {
2408 // printf("writing pos=0x%"PRIx64" size=0x%"PRIx64"\n", feed->feed_write_index, feed->feed_size);
2409 /* XXX: use llseek or url_seek */
2410 lseek(c->feed_fd, feed->feed_write_index, SEEK_SET);
2411 write(c->feed_fd, c->buffer, FFM_PACKET_SIZE);
2413 feed->feed_write_index += FFM_PACKET_SIZE;
2414 /* update file size */
2415 if (feed->feed_write_index > c->stream->feed_size)
2416 feed->feed_size = feed->feed_write_index;
2418 /* handle wrap around if max file size reached */
2419 if (c->stream->feed_max_size && feed->feed_write_index >= c->stream->feed_max_size)
2420 feed->feed_write_index = FFM_PACKET_SIZE;
2423 ffm_write_write_index(c->feed_fd, feed->feed_write_index);
2425 /* wake up any waiting connections */
2426 for(c1 = first_http_ctx; c1 != NULL; c1 = c1->next) {
2427 if (c1->state == HTTPSTATE_WAIT_FEED &&
2428 c1->stream->feed == c->stream->feed)
2429 c1->state = HTTPSTATE_SEND_DATA;
2432 /* We have a header in our hands that contains useful data */
2434 AVInputFormat *fmt_in;
2435 ByteIOContext *pb = &s.pb;
2438 memset(&s, 0, sizeof(s));
2440 url_open_buf(pb, c->buffer, c->buffer_end - c->buffer, URL_RDONLY);
2441 pb->buf_end = c->buffer_end; /* ?? */
2442 pb->is_streamed = 1;
2444 /* use feed output format name to find corresponding input format */
2445 fmt_in = av_find_input_format(feed->fmt->name);
2449 if (fmt_in->priv_data_size > 0) {
2450 s.priv_data = av_mallocz(fmt_in->priv_data_size);
2456 if (fmt_in->read_header(&s, 0) < 0) {
2457 av_freep(&s.priv_data);
2461 /* Now we have the actual streams */
2462 if (s.nb_streams != feed->nb_streams) {
2463 av_freep(&s.priv_data);
2466 for (i = 0; i < s.nb_streams; i++)
2467 memcpy(feed->streams[i]->codec,
2468 s.streams[i]->codec, sizeof(AVCodecContext));
2469 av_freep(&s.priv_data);
2471 c->buffer_ptr = c->buffer;
2476 c->stream->feed_opened = 0;
2481 /********************************************************************/
2484 static void rtsp_reply_header(HTTPContext *c, enum RTSPStatusCode error_number)
2491 switch(error_number) {
2492 case RTSP_STATUS_OK:
2495 case RTSP_STATUS_METHOD:
2496 str = "Method Not Allowed";
2498 case RTSP_STATUS_BANDWIDTH:
2499 str = "Not Enough Bandwidth";
2501 case RTSP_STATUS_SESSION:
2502 str = "Session Not Found";
2504 case RTSP_STATUS_STATE:
2505 str = "Method Not Valid in This State";
2507 case RTSP_STATUS_AGGREGATE:
2508 str = "Aggregate operation not allowed";
2510 case RTSP_STATUS_ONLY_AGGREGATE:
2511 str = "Only aggregate operation allowed";
2513 case RTSP_STATUS_TRANSPORT:
2514 str = "Unsupported transport";
2516 case RTSP_STATUS_INTERNAL:
2517 str = "Internal Server Error";
2519 case RTSP_STATUS_SERVICE:
2520 str = "Service Unavailable";
2522 case RTSP_STATUS_VERSION:
2523 str = "RTSP Version not supported";
2526 str = "Unknown Error";
2530 url_fprintf(c->pb, "RTSP/1.0 %d %s\r\n", error_number, str);
2531 url_fprintf(c->pb, "CSeq: %d\r\n", c->seq);
2533 /* output GMT time */
2537 p = buf2 + strlen(p) - 1;
2540 url_fprintf(c->pb, "Date: %s GMT\r\n", buf2);
2543 static void rtsp_reply_error(HTTPContext *c, enum RTSPStatusCode error_number)
2545 rtsp_reply_header(c, error_number);
2546 url_fprintf(c->pb, "\r\n");
2549 static int rtsp_parse_request(HTTPContext *c)
2551 const char *p, *p1, *p2;
2558 RTSPHeader header1, *header = &header1;
2560 c->buffer_ptr[0] = '\0';
2563 get_word(cmd, sizeof(cmd), &p);
2564 get_word(url, sizeof(url), &p);
2565 get_word(protocol, sizeof(protocol), &p);
2567 av_strlcpy(c->method, cmd, sizeof(c->method));
2568 av_strlcpy(c->url, url, sizeof(c->url));
2569 av_strlcpy(c->protocol, protocol, sizeof(c->protocol));
2572 if (url_open_dyn_buf(c->pb) < 0) {
2573 /* XXX: cannot do more */
2574 c->pb = NULL; /* safety */
2578 /* check version name */
2579 if (strcmp(protocol, "RTSP/1.0") != 0) {
2580 rtsp_reply_error(c, RTSP_STATUS_VERSION);
2584 /* parse each header line */
2585 memset(header, 0, sizeof(RTSPHeader));
2586 /* skip to next line */
2587 while (*p != '\n' && *p != '\0')
2591 while (*p != '\0') {
2592 p1 = strchr(p, '\n');
2596 if (p2 > p && p2[-1] == '\r')
2598 /* skip empty line */
2602 if (len > sizeof(line) - 1)
2603 len = sizeof(line) - 1;
2604 memcpy(line, p, len);
2606 rtsp_parse_line(header, line);
2610 /* handle sequence number */
2611 c->seq = header->seq;
2613 if (!strcmp(cmd, "DESCRIBE"))
2614 rtsp_cmd_describe(c, url);
2615 else if (!strcmp(cmd, "OPTIONS"))
2616 rtsp_cmd_options(c, url);
2617 else if (!strcmp(cmd, "SETUP"))
2618 rtsp_cmd_setup(c, url, header);
2619 else if (!strcmp(cmd, "PLAY"))
2620 rtsp_cmd_play(c, url, header);
2621 else if (!strcmp(cmd, "PAUSE"))
2622 rtsp_cmd_pause(c, url, header);
2623 else if (!strcmp(cmd, "TEARDOWN"))
2624 rtsp_cmd_teardown(c, url, header);
2626 rtsp_reply_error(c, RTSP_STATUS_METHOD);
2629 len = url_close_dyn_buf(c->pb, &c->pb_buffer);
2630 c->pb = NULL; /* safety */
2632 /* XXX: cannot do more */
2635 c->buffer_ptr = c->pb_buffer;
2636 c->buffer_end = c->pb_buffer + len;
2637 c->state = RTSPSTATE_SEND_REPLY;
2641 static int prepare_sdp_description(FFStream *stream, uint8_t **pbuffer,
2642 struct in_addr my_ip)
2644 AVFormatContext *avc;
2645 AVStream avs[MAX_STREAMS];
2648 avc = av_alloc_format_context();
2652 if (stream->title[0] != 0) {
2653 av_strlcpy(avc->title, stream->title, sizeof(avc->title));
2655 av_strlcpy(avc->title, "No Title", sizeof(avc->title));
2657 avc->nb_streams = stream->nb_streams;
2658 if (stream->is_multicast) {
2659 snprintf(avc->filename, 1024, "rtp://%s:%d?multicast=1?ttl=%d",
2660 inet_ntoa(stream->multicast_ip),
2661 stream->multicast_port, stream->multicast_ttl);
2664 for(i = 0; i < stream->nb_streams; i++) {
2665 avc->streams[i] = &avs[i];
2666 avc->streams[i]->codec = stream->streams[i]->codec;
2668 *pbuffer = av_mallocz(2048);
2669 avf_sdp_create(&avc, 1, *pbuffer, 2048);
2672 return strlen(*pbuffer);
2675 static void rtsp_cmd_options(HTTPContext *c, const char *url)
2677 // rtsp_reply_header(c, RTSP_STATUS_OK);
2678 url_fprintf(c->pb, "RTSP/1.0 %d %s\r\n", RTSP_STATUS_OK, "OK");
2679 url_fprintf(c->pb, "CSeq: %d\r\n", c->seq);
2680 url_fprintf(c->pb, "Public: %s\r\n", "OPTIONS, DESCRIBE, SETUP, TEARDOWN, PLAY, PAUSE");
2681 url_fprintf(c->pb, "\r\n");
2684 static void rtsp_cmd_describe(HTTPContext *c, const char *url)
2690 int content_length, len;
2691 struct sockaddr_in my_addr;
2693 /* find which url is asked */
2694 url_split(NULL, 0, NULL, 0, NULL, 0, NULL, path1, sizeof(path1), url);
2699 for(stream = first_stream; stream != NULL; stream = stream->next) {
2700 if (!stream->is_feed &&
2701 stream->fmt && !strcmp(stream->fmt->name, "rtp") &&
2702 !strcmp(path, stream->filename)) {
2706 /* no stream found */
2707 rtsp_reply_error(c, RTSP_STATUS_SERVICE); /* XXX: right error ? */
2711 /* prepare the media description in sdp format */
2713 /* get the host IP */
2714 len = sizeof(my_addr);
2715 getsockname(c->fd, (struct sockaddr *)&my_addr, &len);
2716 content_length = prepare_sdp_description(stream, &content, my_addr.sin_addr);
2717 if (content_length < 0) {
2718 rtsp_reply_error(c, RTSP_STATUS_INTERNAL);
2721 rtsp_reply_header(c, RTSP_STATUS_OK);
2722 url_fprintf(c->pb, "Content-Type: application/sdp\r\n");
2723 url_fprintf(c->pb, "Content-Length: %d\r\n", content_length);
2724 url_fprintf(c->pb, "\r\n");
2725 put_buffer(c->pb, content, content_length);
2728 static HTTPContext *find_rtp_session(const char *session_id)
2732 if (session_id[0] == '\0')
2735 for(c = first_http_ctx; c != NULL; c = c->next) {
2736 if (!strcmp(c->session_id, session_id))
2742 static RTSPTransportField *find_transport(RTSPHeader *h, enum RTSPProtocol protocol)
2744 RTSPTransportField *th;
2747 for(i=0;i<h->nb_transports;i++) {
2748 th = &h->transports[i];
2749 if (th->protocol == protocol)
2755 static void rtsp_cmd_setup(HTTPContext *c, const char *url,
2759 int stream_index, port;
2764 RTSPTransportField *th;
2765 struct sockaddr_in dest_addr;
2766 RTSPActionServerSetup setup;
2768 /* find which url is asked */
2769 url_split(NULL, 0, NULL, 0, NULL, 0, NULL, path1, sizeof(path1), url);
2774 /* now check each stream */
2775 for(stream = first_stream; stream != NULL; stream = stream->next) {
2776 if (!stream->is_feed &&
2777 stream->fmt && !strcmp(stream->fmt->name, "rtp")) {
2778 /* accept aggregate filenames only if single stream */
2779 if (!strcmp(path, stream->filename)) {
2780 if (stream->nb_streams != 1) {
2781 rtsp_reply_error(c, RTSP_STATUS_AGGREGATE);
2788 for(stream_index = 0; stream_index < stream->nb_streams;
2790 snprintf(buf, sizeof(buf), "%s/streamid=%d",
2791 stream->filename, stream_index);
2792 if (!strcmp(path, buf))
2797 /* no stream found */
2798 rtsp_reply_error(c, RTSP_STATUS_SERVICE); /* XXX: right error ? */
2802 /* generate session id if needed */
2803 if (h->session_id[0] == '\0')
2804 snprintf(h->session_id, sizeof(h->session_id), "%08x%08x",
2805 av_random(&random_state), av_random(&random_state));
2807 /* find rtp session, and create it if none found */
2808 rtp_c = find_rtp_session(h->session_id);
2810 /* always prefer UDP */
2811 th = find_transport(h, RTSP_PROTOCOL_RTP_UDP);
2813 th = find_transport(h, RTSP_PROTOCOL_RTP_TCP);
2815 rtsp_reply_error(c, RTSP_STATUS_TRANSPORT);
2820 rtp_c = rtp_new_connection(&c->from_addr, stream, h->session_id,
2823 rtsp_reply_error(c, RTSP_STATUS_BANDWIDTH);
2827 /* open input stream */
2828 if (open_input_stream(rtp_c, "") < 0) {
2829 rtsp_reply_error(c, RTSP_STATUS_INTERNAL);
2834 /* test if stream is OK (test needed because several SETUP needs
2835 to be done for a given file) */
2836 if (rtp_c->stream != stream) {
2837 rtsp_reply_error(c, RTSP_STATUS_SERVICE);
2841 /* test if stream is already set up */
2842 if (rtp_c->rtp_ctx[stream_index]) {
2843 rtsp_reply_error(c, RTSP_STATUS_STATE);
2847 /* check transport */
2848 th = find_transport(h, rtp_c->rtp_protocol);
2849 if (!th || (th->protocol == RTSP_PROTOCOL_RTP_UDP &&
2850 th->client_port_min <= 0)) {
2851 rtsp_reply_error(c, RTSP_STATUS_TRANSPORT);
2855 /* setup default options */
2856 setup.transport_option[0] = '\0';
2857 dest_addr = rtp_c->from_addr;
2858 dest_addr.sin_port = htons(th->client_port_min);
2861 if (rtp_new_av_stream(rtp_c, stream_index, &dest_addr, c) < 0) {
2862 rtsp_reply_error(c, RTSP_STATUS_TRANSPORT);
2866 /* now everything is OK, so we can send the connection parameters */
2867 rtsp_reply_header(c, RTSP_STATUS_OK);
2869 url_fprintf(c->pb, "Session: %s\r\n", rtp_c->session_id);
2871 switch(rtp_c->rtp_protocol) {
2872 case RTSP_PROTOCOL_RTP_UDP:
2873 port = rtp_get_local_port(rtp_c->rtp_handles[stream_index]);
2874 url_fprintf(c->pb, "Transport: RTP/AVP/UDP;unicast;"
2875 "client_port=%d-%d;server_port=%d-%d",
2876 th->client_port_min, th->client_port_min + 1,
2879 case RTSP_PROTOCOL_RTP_TCP:
2880 url_fprintf(c->pb, "Transport: RTP/AVP/TCP;interleaved=%d-%d",
2881 stream_index * 2, stream_index * 2 + 1);
2886 if (setup.transport_option[0] != '\0')
2887 url_fprintf(c->pb, ";%s", setup.transport_option);
2888 url_fprintf(c->pb, "\r\n");
2891 url_fprintf(c->pb, "\r\n");
2895 /* find an rtp connection by using the session ID. Check consistency
2897 static HTTPContext *find_rtp_session_with_url(const char *url,
2898 const char *session_id)
2906 rtp_c = find_rtp_session(session_id);
2910 /* find which url is asked */
2911 url_split(NULL, 0, NULL, 0, NULL, 0, NULL, path1, sizeof(path1), url);
2915 if(!strcmp(path, rtp_c->stream->filename)) return rtp_c;
2916 for(s=0; s<rtp_c->stream->nb_streams; ++s) {
2917 snprintf(buf, sizeof(buf), "%s/streamid=%d",
2918 rtp_c->stream->filename, s);
2919 if(!strncmp(path, buf, sizeof(buf))) {
2920 // XXX: Should we reply with RTSP_STATUS_ONLY_AGGREGATE if nb_streams>1?
2927 static void rtsp_cmd_play(HTTPContext *c, const char *url, RTSPHeader *h)
2931 rtp_c = find_rtp_session_with_url(url, h->session_id);
2933 rtsp_reply_error(c, RTSP_STATUS_SESSION);
2937 if (rtp_c->state != HTTPSTATE_SEND_DATA &&
2938 rtp_c->state != HTTPSTATE_WAIT_FEED &&
2939 rtp_c->state != HTTPSTATE_READY) {
2940 rtsp_reply_error(c, RTSP_STATUS_STATE);
2945 /* XXX: seek in stream */
2946 if (h->range_start != AV_NOPTS_VALUE) {
2947 printf("range_start=%0.3f\n", (double)h->range_start / AV_TIME_BASE);
2948 av_seek_frame(rtp_c->fmt_in, -1, h->range_start);
2952 rtp_c->state = HTTPSTATE_SEND_DATA;
2954 /* now everything is OK, so we can send the connection parameters */
2955 rtsp_reply_header(c, RTSP_STATUS_OK);
2957 url_fprintf(c->pb, "Session: %s\r\n", rtp_c->session_id);
2958 url_fprintf(c->pb, "\r\n");
2961 static void rtsp_cmd_pause(HTTPContext *c, const char *url, RTSPHeader *h)
2965 rtp_c = find_rtp_session_with_url(url, h->session_id);
2967 rtsp_reply_error(c, RTSP_STATUS_SESSION);
2971 if (rtp_c->state != HTTPSTATE_SEND_DATA &&
2972 rtp_c->state != HTTPSTATE_WAIT_FEED) {
2973 rtsp_reply_error(c, RTSP_STATUS_STATE);
2977 rtp_c->state = HTTPSTATE_READY;
2978 rtp_c->first_pts = AV_NOPTS_VALUE;
2979 /* now everything is OK, so we can send the connection parameters */
2980 rtsp_reply_header(c, RTSP_STATUS_OK);
2982 url_fprintf(c->pb, "Session: %s\r\n", rtp_c->session_id);
2983 url_fprintf(c->pb, "\r\n");
2986 static void rtsp_cmd_teardown(HTTPContext *c, const char *url, RTSPHeader *h)
2989 char session_id[32];
2991 rtp_c = find_rtp_session_with_url(url, h->session_id);
2993 rtsp_reply_error(c, RTSP_STATUS_SESSION);
2997 av_strlcpy(session_id, rtp_c->session_id, sizeof(session_id));
2999 /* abort the session */
3000 close_connection(rtp_c);
3002 /* now everything is OK, so we can send the connection parameters */
3003 rtsp_reply_header(c, RTSP_STATUS_OK);
3005 url_fprintf(c->pb, "Session: %s\r\n", session_id);
3006 url_fprintf(c->pb, "\r\n");
3010 /********************************************************************/
3013 static HTTPContext *rtp_new_connection(struct sockaddr_in *from_addr,
3014 FFStream *stream, const char *session_id,
3015 enum RTSPProtocol rtp_protocol)
3017 HTTPContext *c = NULL;
3018 const char *proto_str;
3020 /* XXX: should output a warning page when coming
3021 close to the connection limit */
3022 if (nb_connections >= nb_max_connections)
3025 /* add a new connection */
3026 c = av_mallocz(sizeof(HTTPContext));
3031 c->poll_entry = NULL;
3032 c->from_addr = *from_addr;
3033 c->buffer_size = IOBUFFER_INIT_SIZE;
3034 c->buffer = av_malloc(c->buffer_size);
3039 av_strlcpy(c->session_id, session_id, sizeof(c->session_id));
3040 c->state = HTTPSTATE_READY;
3041 c->is_packetized = 1;
3042 c->rtp_protocol = rtp_protocol;
3044 /* protocol is shown in statistics */
3045 switch(c->rtp_protocol) {
3046 case RTSP_PROTOCOL_RTP_UDP_MULTICAST:
3047 proto_str = "MCAST";
3049 case RTSP_PROTOCOL_RTP_UDP:
3052 case RTSP_PROTOCOL_RTP_TCP:
3059 av_strlcpy(c->protocol, "RTP/", sizeof(c->protocol));
3060 av_strlcat(c->protocol, proto_str, sizeof(c->protocol));
3062 current_bandwidth += stream->bandwidth;
3064 c->next = first_http_ctx;
3076 /* add a new RTP stream in an RTP connection (used in RTSP SETUP
3077 command). If RTP/TCP protocol is used, TCP connection 'rtsp_c' is
3079 static int rtp_new_av_stream(HTTPContext *c,
3080 int stream_index, struct sockaddr_in *dest_addr,
3081 HTTPContext *rtsp_c)
3083 AVFormatContext *ctx;
3089 int max_packet_size;
3091 /* now we can open the relevant output stream */
3092 ctx = av_alloc_format_context();
3095 ctx->oformat = guess_format("rtp", NULL, NULL);
3097 st = av_mallocz(sizeof(AVStream));
3100 st->codec= avcodec_alloc_context();
3101 ctx->nb_streams = 1;
3102 ctx->streams[0] = st;
3104 if (!c->stream->feed ||
3105 c->stream->feed == c->stream)
3106 memcpy(st, c->stream->streams[stream_index], sizeof(AVStream));
3109 c->stream->feed->streams[c->stream->feed_streams[stream_index]],
3111 st->priv_data = NULL;
3113 /* build destination RTP address */
3114 ipaddr = inet_ntoa(dest_addr->sin_addr);
3116 switch(c->rtp_protocol) {
3117 case RTSP_PROTOCOL_RTP_UDP:
3118 case RTSP_PROTOCOL_RTP_UDP_MULTICAST:
3121 /* XXX: also pass as parameter to function ? */
3122 if (c->stream->is_multicast) {
3124 ttl = c->stream->multicast_ttl;
3127 snprintf(ctx->filename, sizeof(ctx->filename),
3128 "rtp://%s:%d?multicast=1&ttl=%d",
3129 ipaddr, ntohs(dest_addr->sin_port), ttl);
3131 snprintf(ctx->filename, sizeof(ctx->filename),
3132 "rtp://%s:%d", ipaddr, ntohs(dest_addr->sin_port));
3135 if (url_open(&h, ctx->filename, URL_WRONLY) < 0)
3137 c->rtp_handles[stream_index] = h;
3138 max_packet_size = url_get_max_packet_size(h);
3140 case RTSP_PROTOCOL_RTP_TCP:
3143 max_packet_size = RTSP_TCP_MAX_PACKET_SIZE;
3149 http_log("%s:%d - - [%s] \"PLAY %s/streamid=%d %s\"\n",
3150 ipaddr, ntohs(dest_addr->sin_port),
3152 c->stream->filename, stream_index, c->protocol);
3154 /* normally, no packets should be output here, but the packet size may be checked */
3155 if (url_open_dyn_packet_buf(&ctx->pb, max_packet_size) < 0) {
3156 /* XXX: close stream */
3159 av_set_parameters(ctx, NULL);
3160 if (av_write_header(ctx) < 0) {
3167 url_close_dyn_buf(&ctx->pb, &dummy_buf);
3170 c->rtp_ctx[stream_index] = ctx;
3174 /********************************************************************/
3175 /* ffserver initialization */
3177 static AVStream *add_av_stream1(FFStream *stream, AVCodecContext *codec)
3181 fst = av_mallocz(sizeof(AVStream));
3184 fst->codec= avcodec_alloc_context();
3185 fst->priv_data = av_mallocz(sizeof(FeedData));
3186 memcpy(fst->codec, codec, sizeof(AVCodecContext));
3187 fst->codec->coded_frame = &dummy_frame;
3188 fst->index = stream->nb_streams;
3189 av_set_pts_info(fst, 33, 1, 90000);
3190 stream->streams[stream->nb_streams++] = fst;
3194 /* return the stream number in the feed */
3195 static int add_av_stream(FFStream *feed, AVStream *st)
3198 AVCodecContext *av, *av1;
3202 for(i=0;i<feed->nb_streams;i++) {
3203 st = feed->streams[i];
3205 if (av1->codec_id == av->codec_id &&
3206 av1->codec_type == av->codec_type &&
3207 av1->bit_rate == av->bit_rate) {
3209 switch(av->codec_type) {
3210 case CODEC_TYPE_AUDIO:
3211 if (av1->channels == av->channels &&
3212 av1->sample_rate == av->sample_rate)
3215 case CODEC_TYPE_VIDEO:
3216 if (av1->width == av->width &&
3217 av1->height == av->height &&
3218 av1->time_base.den == av->time_base.den &&
3219 av1->time_base.num == av->time_base.num &&
3220 av1->gop_size == av->gop_size)
3229 fst = add_av_stream1(feed, av);
3232 return feed->nb_streams - 1;
3237 static void remove_stream(FFStream *stream)
3241 while (*ps != NULL) {
3249 /* specific mpeg4 handling : we extract the raw parameters */
3250 static void extract_mpeg4_header(AVFormatContext *infile)
3252 int mpeg4_count, i, size;
3258 for(i=0;i<infile->nb_streams;i++) {
3259 st = infile->streams[i];
3260 if (st->codec->codec_id == CODEC_ID_MPEG4 &&
3261 st->codec->extradata_size == 0) {
3268 printf("MPEG4 without extra data: trying to find header in %s\n", infile->filename);
3269 while (mpeg4_count > 0) {
3270 if (av_read_packet(infile, &pkt) < 0)
3272 st = infile->streams[pkt.stream_index];
3273 if (st->codec->codec_id == CODEC_ID_MPEG4 &&
3274 st->codec->extradata_size == 0) {
3275 av_freep(&st->codec->extradata);
3276 /* fill extradata with the header */
3277 /* XXX: we make hard suppositions here ! */
3279 while (p < pkt.data + pkt.size - 4) {
3280 /* stop when vop header is found */
3281 if (p[0] == 0x00 && p[1] == 0x00 &&
3282 p[2] == 0x01 && p[3] == 0xb6) {
3283 size = p - pkt.data;
3284 // av_hex_dump_log(infile, AV_LOG_DEBUG, pkt.data, size);
3285 st->codec->extradata = av_malloc(size);
3286 st->codec->extradata_size = size;
3287 memcpy(st->codec->extradata, pkt.data, size);
3294 av_free_packet(&pkt);
3298 /* compute the needed AVStream for each file */
3299 static void build_file_streams(void)
3301 FFStream *stream, *stream_next;
3302 AVFormatContext *infile;
3305 /* gather all streams */
3306 for(stream = first_stream; stream != NULL; stream = stream_next) {
3307 stream_next = stream->next;
3308 if (stream->stream_type == STREAM_TYPE_LIVE &&
3310 /* the stream comes from a file */
3311 /* try to open the file */
3313 stream->ap_in = av_mallocz(sizeof(AVFormatParameters));
3314 if (stream->fmt && !strcmp(stream->fmt->name, "rtp")) {
3315 /* specific case : if transport stream output to RTP,
3316 we use a raw transport stream reader */
3317 stream->ap_in->mpeg2ts_raw = 1;
3318 stream->ap_in->mpeg2ts_compute_pcr = 1;
3321 if (av_open_input_file(&infile, stream->feed_filename,
3322 stream->ifmt, 0, stream->ap_in) < 0) {
3323 http_log("%s not found", stream->feed_filename);
3324 /* remove stream (no need to spend more time on it) */
3326 remove_stream(stream);
3328 /* find all the AVStreams inside and reference them in
3330 if (av_find_stream_info(infile) < 0) {
3331 http_log("Could not find codec parameters from '%s'",
3332 stream->feed_filename);
3333 av_close_input_file(infile);
3336 extract_mpeg4_header(infile);
3338 for(i=0;i<infile->nb_streams;i++)
3339 add_av_stream1(stream, infile->streams[i]->codec);
3341 av_close_input_file(infile);
3347 /* compute the needed AVStream for each feed */
3348 static void build_feed_streams(void)
3350 FFStream *stream, *feed;
3353 /* gather all streams */
3354 for(stream = first_stream; stream != NULL; stream = stream->next) {
3355 feed = stream->feed;
3357 if (!stream->is_feed) {
3358 /* we handle a stream coming from a feed */
3359 for(i=0;i<stream->nb_streams;i++)
3360 stream->feed_streams[i] = add_av_stream(feed, stream->streams[i]);
3365 /* gather all streams */
3366 for(stream = first_stream; stream != NULL; stream = stream->next) {
3367 feed = stream->feed;
3369 if (stream->is_feed) {
3370 for(i=0;i<stream->nb_streams;i++)
3371 stream->feed_streams[i] = i;
3376 /* create feed files if needed */
3377 for(feed = first_feed; feed != NULL; feed = feed->next_feed) {
3380 if (url_exist(feed->feed_filename)) {
3381 /* See if it matches */
3385 if (av_open_input_file(&s, feed->feed_filename, NULL, FFM_PACKET_SIZE, NULL) >= 0) {
3386 /* Now see if it matches */
3387 if (s->nb_streams == feed->nb_streams) {
3389 for(i=0;i<s->nb_streams;i++) {
3391 sf = feed->streams[i];
3394 if (sf->index != ss->index ||
3396 printf("Index & Id do not match for stream %d (%s)\n",
3397 i, feed->feed_filename);
3400 AVCodecContext *ccf, *ccs;
3404 #define CHECK_CODEC(x) (ccf->x != ccs->x)
3406 if (CHECK_CODEC(codec) || CHECK_CODEC(codec_type)) {
3407 printf("Codecs do not match for stream %d\n", i);
3409 } else if (CHECK_CODEC(bit_rate) || CHECK_CODEC(flags)) {
3410 printf("Codec bitrates do not match for stream %d\n", i);
3412 } else if (ccf->codec_type == CODEC_TYPE_VIDEO) {
3413 if (CHECK_CODEC(time_base.den) ||
3414 CHECK_CODEC(time_base.num) ||
3415 CHECK_CODEC(width) ||
3416 CHECK_CODEC(height)) {
3417 printf("Codec width, height and framerate do not match for stream %d\n", i);
3420 } else if (ccf->codec_type == CODEC_TYPE_AUDIO) {
3421 if (CHECK_CODEC(sample_rate) ||
3422 CHECK_CODEC(channels) ||
3423 CHECK_CODEC(frame_size)) {
3424 printf("Codec sample_rate, channels, frame_size do not match for stream %d\n", i);
3428 printf("Unknown codec type\n");
3436 printf("Deleting feed file '%s' as stream counts differ (%d != %d)\n",
3437 feed->feed_filename, s->nb_streams, feed->nb_streams);
3439 av_close_input_file(s);
3441 printf("Deleting feed file '%s' as it appears to be corrupt\n",
3442 feed->feed_filename);
3445 if (feed->readonly) {
3446 printf("Unable to delete feed file '%s' as it is marked readonly\n",
3447 feed->feed_filename);
3450 unlink(feed->feed_filename);
3453 if (!url_exist(feed->feed_filename)) {
3454 AVFormatContext s1, *s = &s1;
3456 if (feed->readonly) {
3457 printf("Unable to create feed file '%s' as it is marked readonly\n",
3458 feed->feed_filename);
3462 /* only write the header of the ffm file */
3463 if (url_fopen(&s->pb, feed->feed_filename, URL_WRONLY) < 0) {
3464 fprintf(stderr, "Could not open output feed file '%s'\n",
3465 feed->feed_filename);
3468 s->oformat = feed->fmt;
3469 s->nb_streams = feed->nb_streams;
3470 for(i=0;i<s->nb_streams;i++) {
3472 st = feed->streams[i];
3475 av_set_parameters(s, NULL);
3476 if (av_write_header(s) < 0) {
3477 fprintf(stderr, "Container doesn't supports the required parameters\n");
3480 /* XXX: need better api */
3481 av_freep(&s->priv_data);
3484 /* get feed size and write index */
3485 fd = open(feed->feed_filename, O_RDONLY);
3487 fprintf(stderr, "Could not open output feed file '%s'\n",
3488 feed->feed_filename);
3492 feed->feed_write_index = ffm_read_write_index(fd);
3493 feed->feed_size = lseek(fd, 0, SEEK_END);
3494 /* ensure that we do not wrap before the end of file */
3495 if (feed->feed_max_size && feed->feed_max_size < feed->feed_size)
3496 feed->feed_max_size = feed->feed_size;
3502 /* compute the bandwidth used by each stream */
3503 static void compute_bandwidth(void)
3508 for(stream = first_stream; stream != NULL; stream = stream->next) {
3510 for(i=0;i<stream->nb_streams;i++) {
3511 AVStream *st = stream->streams[i];
3512 switch(st->codec->codec_type) {
3513 case CODEC_TYPE_AUDIO:
3514 case CODEC_TYPE_VIDEO:
3515 bandwidth += st->codec->bit_rate;
3521 stream->bandwidth = (bandwidth + 999) / 1000;
3525 static void get_arg(char *buf, int buf_size, const char **pp)
3532 while (isspace(*p)) p++;
3535 if (*p == '\"' || *p == '\'')
3547 if ((q - buf) < buf_size - 1)
3552 if (quote && *p == quote)
3557 /* add a codec and set the default parameters */
3558 static void add_codec(FFStream *stream, AVCodecContext *av)
3562 /* compute default parameters */
3563 switch(av->codec_type) {
3564 case CODEC_TYPE_AUDIO:
3565 if (av->bit_rate == 0)
3566 av->bit_rate = 64000;
3567 if (av->sample_rate == 0)
3568 av->sample_rate = 22050;
3569 if (av->channels == 0)
3572 case CODEC_TYPE_VIDEO:
3573 if (av->bit_rate == 0)
3574 av->bit_rate = 64000;
3575 if (av->time_base.num == 0){
3576 av->time_base.den = 5;
3577 av->time_base.num = 1;
3579 if (av->width == 0 || av->height == 0) {
3583 /* Bitrate tolerance is less for streaming */
3584 if (av->bit_rate_tolerance == 0)
3585 av->bit_rate_tolerance = av->bit_rate / 4;
3590 if (av->max_qdiff == 0)
3592 av->qcompress = 0.5;
3595 if (!av->nsse_weight)
3596 av->nsse_weight = 8;
3598 av->frame_skip_cmp = FF_CMP_DCTMAX;
3599 av->me_method = ME_EPZS;
3600 av->rc_buffer_aggressivity = 1.0;
3603 av->rc_eq = "tex^qComp";
3604 if (!av->i_quant_factor)
3605 av->i_quant_factor = -0.8;
3606 if (!av->b_quant_factor)
3607 av->b_quant_factor = 1.25;
3608 if (!av->b_quant_offset)
3609 av->b_quant_offset = 1.25;
3610 if (!av->rc_max_rate)
3611 av->rc_max_rate = av->bit_rate * 2;
3613 if (av->rc_max_rate && !av->rc_buffer_size) {
3614 av->rc_buffer_size = av->rc_max_rate;
3623 st = av_mallocz(sizeof(AVStream));
3626 st->codec = avcodec_alloc_context();
3627 stream->streams[stream->nb_streams++] = st;
3628 memcpy(st->codec, av, sizeof(AVCodecContext));
3631 static int opt_audio_codec(const char *arg)
3637 if (!strcmp(p->name, arg) && p->type == CODEC_TYPE_AUDIO)
3642 return CODEC_ID_NONE;
3647 static int opt_video_codec(const char *arg)
3653 if (!strcmp(p->name, arg) && p->type == CODEC_TYPE_VIDEO)
3658 return CODEC_ID_NONE;
3663 /* simplistic plugin support */
3666 static void load_module(const char *filename)
3669 void (*init_func)(void);
3670 dll = dlopen(filename, RTLD_NOW);
3672 fprintf(stderr, "Could not load module '%s' - %s\n",
3673 filename, dlerror());
3677 init_func = dlsym(dll, "ffserver_module_init");
3680 "%s: init function 'ffserver_module_init()' not found\n",
3689 static int parse_ffconfig(const char *filename)
3696 int val, errors, line_num;
3697 FFStream **last_stream, *stream, *redirect;
3698 FFStream **last_feed, *feed;
3699 AVCodecContext audio_enc, video_enc;
3700 int audio_id, video_id;
3702 f = fopen(filename, "r");
3710 first_stream = NULL;
3711 last_stream = &first_stream;
3713 last_feed = &first_feed;
3717 audio_id = CODEC_ID_NONE;
3718 video_id = CODEC_ID_NONE;
3720 if (fgets(line, sizeof(line), f) == NULL)
3726 if (*p == '\0' || *p == '#')
3729 get_arg(cmd, sizeof(cmd), &p);
3731 if (!strcasecmp(cmd, "Port")) {
3732 get_arg(arg, sizeof(arg), &p);
3734 if (val < 1 || val > 65536) {
3735 fprintf(stderr, "%s:%d: Invalid port: %s\n",
3736 filename, line_num, arg);
3739 my_http_addr.sin_port = htons(val);
3740 } else if (!strcasecmp(cmd, "BindAddress")) {
3741 get_arg(arg, sizeof(arg), &p);
3742 if (resolve_host(&my_http_addr.sin_addr, arg) != 0) {
3743 fprintf(stderr, "%s:%d: Invalid host/IP address: %s\n",
3744 filename, line_num, arg);
3747 } else if (!strcasecmp(cmd, "NoDaemon")) {
3748 ffserver_daemon = 0;
3749 } else if (!strcasecmp(cmd, "RTSPPort")) {
3750 get_arg(arg, sizeof(arg), &p);
3752 if (val < 1 || val > 65536) {
3753 fprintf(stderr, "%s:%d: Invalid port: %s\n",
3754 filename, line_num, arg);
3757 my_rtsp_addr.sin_port = htons(atoi(arg));
3758 } else if (!strcasecmp(cmd, "RTSPBindAddress")) {
3759 get_arg(arg, sizeof(arg), &p);
3760 if (resolve_host(&my_rtsp_addr.sin_addr, arg) != 0) {
3761 fprintf(stderr, "%s:%d: Invalid host/IP address: %s\n",
3762 filename, line_num, arg);
3765 } else if (!strcasecmp(cmd, "MaxClients")) {
3766 get_arg(arg, sizeof(arg), &p);
3768 if (val < 1 || val > HTTP_MAX_CONNECTIONS) {
3769 fprintf(stderr, "%s:%d: Invalid MaxClients: %s\n",
3770 filename, line_num, arg);
3773 nb_max_connections = val;
3775 } else if (!strcasecmp(cmd, "MaxBandwidth")) {
3776 get_arg(arg, sizeof(arg), &p);
3778 if (val < 10 || val > 100000) {
3779 fprintf(stderr, "%s:%d: Invalid MaxBandwidth: %s\n",
3780 filename, line_num, arg);
3783 max_bandwidth = val;
3784 } else if (!strcasecmp(cmd, "CustomLog")) {
3785 get_arg(logfilename, sizeof(logfilename), &p);
3786 } else if (!strcasecmp(cmd, "<Feed")) {
3787 /*********************************************/
3788 /* Feed related options */
3790 if (stream || feed) {
3791 fprintf(stderr, "%s:%d: Already in a tag\n",
3792 filename, line_num);
3794 feed = av_mallocz(sizeof(FFStream));
3795 /* add in stream list */
3796 *last_stream = feed;
3797 last_stream = &feed->next;
3798 /* add in feed list */
3800 last_feed = &feed->next_feed;
3802 get_arg(feed->filename, sizeof(feed->filename), &p);
3803 q = strrchr(feed->filename, '>');
3806 feed->fmt = guess_format("ffm", NULL, NULL);
3807 /* defaut feed file */
3808 snprintf(feed->feed_filename, sizeof(feed->feed_filename),
3809 "/tmp/%s.ffm", feed->filename);
3810 feed->feed_max_size = 5 * 1024 * 1024;
3812 feed->feed = feed; /* self feeding :-) */
3814 } else if (!strcasecmp(cmd, "Launch")) {
3818 feed->child_argv = (char **) av_mallocz(64 * sizeof(char *));
3820 for (i = 0; i < 62; i++) {
3821 get_arg(arg, sizeof(arg), &p);
3825 feed->child_argv[i] = av_strdup(arg);
3828 feed->child_argv[i] = av_malloc(30 + strlen(feed->filename));
3830 snprintf(feed->child_argv[i], 30+strlen(feed->filename),
3832 (my_http_addr.sin_addr.s_addr == INADDR_ANY) ? "127.0.0.1" :
3833 inet_ntoa(my_http_addr.sin_addr),
3834 ntohs(my_http_addr.sin_port), feed->filename);
3839 fprintf(stdout, "Launch commandline: ");
3840 for (j = 0; j <= i; j++)
3841 fprintf(stdout, "%s ", feed->child_argv[j]);
3842 fprintf(stdout, "\n");
3845 } else if (!strcasecmp(cmd, "ReadOnlyFile")) {
3847 get_arg(feed->feed_filename, sizeof(feed->feed_filename), &p);
3849 } else if (stream) {
3850 get_arg(stream->feed_filename, sizeof(stream->feed_filename), &p);
3852 } else if (!strcasecmp(cmd, "File")) {
3854 get_arg(feed->feed_filename, sizeof(feed->feed_filename), &p);
3856 get_arg(stream->feed_filename, sizeof(stream->feed_filename), &p);
3857 } else if (!strcasecmp(cmd, "FileMaxSize")) {
3862 get_arg(arg, sizeof(arg), &p);
3864 fsize = strtod(p1, (char **)&p1);
3865 switch(toupper(*p1)) {
3870 fsize *= 1024 * 1024;
3873 fsize *= 1024 * 1024 * 1024;
3876 feed->feed_max_size = (int64_t)fsize;
3878 } else if (!strcasecmp(cmd, "</Feed>")) {
3880 fprintf(stderr, "%s:%d: No corresponding <Feed> for </Feed>\n",
3881 filename, line_num);
3885 } else if (!strcasecmp(cmd, "<Stream")) {
3886 /*********************************************/
3887 /* Stream related options */
3889 if (stream || feed) {
3890 fprintf(stderr, "%s:%d: Already in a tag\n",
3891 filename, line_num);
3893 stream = av_mallocz(sizeof(FFStream));
3894 *last_stream = stream;
3895 last_stream = &stream->next;
3897 get_arg(stream->filename, sizeof(stream->filename), &p);
3898 q = strrchr(stream->filename, '>');
3901 stream->fmt = guess_stream_format(NULL, stream->filename, NULL);
3902 memset(&audio_enc, 0, sizeof(AVCodecContext));
3903 memset(&video_enc, 0, sizeof(AVCodecContext));
3904 audio_id = CODEC_ID_NONE;
3905 video_id = CODEC_ID_NONE;
3907 audio_id = stream->fmt->audio_codec;
3908 video_id = stream->fmt->video_codec;
3911 } else if (!strcasecmp(cmd, "Feed")) {
3912 get_arg(arg, sizeof(arg), &p);
3917 while (sfeed != NULL) {
3918 if (!strcmp(sfeed->filename, arg))
3920 sfeed = sfeed->next_feed;
3923 fprintf(stderr, "%s:%d: feed '%s' not defined\n",
3924 filename, line_num, arg);
3926 stream->feed = sfeed;
3928 } else if (!strcasecmp(cmd, "Format")) {
3929 get_arg(arg, sizeof(arg), &p);
3930 if (!strcmp(arg, "status")) {
3931 stream->stream_type = STREAM_TYPE_STATUS;
3934 stream->stream_type = STREAM_TYPE_LIVE;
3935 /* jpeg cannot be used here, so use single frame jpeg */
3936 if (!strcmp(arg, "jpeg"))
3937 strcpy(arg, "mjpeg");
3938 stream->fmt = guess_stream_format(arg, NULL, NULL);
3940 fprintf(stderr, "%s:%d: Unknown Format: %s\n",
3941 filename, line_num, arg);
3946 audio_id = stream->fmt->audio_codec;
3947 video_id = stream->fmt->video_codec;
3949 } else if (!strcasecmp(cmd, "InputFormat")) {
3950 get_arg(arg, sizeof(arg), &p);
3951 stream->ifmt = av_find_input_format(arg);
3952 if (!stream->ifmt) {
3953 fprintf(stderr, "%s:%d: Unknown input format: %s\n",
3954 filename, line_num, arg);
3956 } else if (!strcasecmp(cmd, "FaviconURL")) {
3957 if (stream && stream->stream_type == STREAM_TYPE_STATUS) {
3958 get_arg(stream->feed_filename, sizeof(stream->feed_filename), &p);
3960 fprintf(stderr, "%s:%d: FaviconURL only permitted for status streams\n",
3961 filename, line_num);
3964 } else if (!strcasecmp(cmd, "Author")) {
3966 get_arg(stream->author, sizeof(stream->author), &p);
3967 } else if (!strcasecmp(cmd, "Comment")) {
3969 get_arg(stream->comment, sizeof(stream->comment), &p);
3970 } else if (!strcasecmp(cmd, "Copyright")) {
3972 get_arg(stream->copyright, sizeof(stream->copyright), &p);
3973 } else if (!strcasecmp(cmd, "Title")) {
3975 get_arg(stream->title, sizeof(stream->title), &p);
3976 } else if (!strcasecmp(cmd, "Preroll")) {
3977 get_arg(arg, sizeof(arg), &p);
3979 stream->prebuffer = atof(arg) * 1000;
3980 } else if (!strcasecmp(cmd, "StartSendOnKey")) {
3982 stream->send_on_key = 1;
3983 } else if (!strcasecmp(cmd, "AudioCodec")) {
3984 get_arg(arg, sizeof(arg), &p);
3985 audio_id = opt_audio_codec(arg);
3986 if (audio_id == CODEC_ID_NONE) {
3987 fprintf(stderr, "%s:%d: Unknown AudioCodec: %s\n",
3988 filename, line_num, arg);
3991 } else if (!strcasecmp(cmd, "VideoCodec")) {
3992 get_arg(arg, sizeof(arg), &p);
3993 video_id = opt_video_codec(arg);
3994 if (video_id == CODEC_ID_NONE) {
3995 fprintf(stderr, "%s:%d: Unknown VideoCodec: %s\n",
3996 filename, line_num, arg);
3999 } else if (!strcasecmp(cmd, "MaxTime")) {
4000 get_arg(arg, sizeof(arg), &p);
4002 stream->max_time = atof(arg) * 1000;
4003 } else if (!strcasecmp(cmd, "AudioBitRate")) {
4004 get_arg(arg, sizeof(arg), &p);
4006 audio_enc.bit_rate = atoi(arg) * 1000;
4007 } else if (!strcasecmp(cmd, "AudioChannels")) {
4008 get_arg(arg, sizeof(arg), &p);
4010 audio_enc.channels = atoi(arg);
4011 } else if (!strcasecmp(cmd, "AudioSampleRate")) {
4012 get_arg(arg, sizeof(arg), &p);
4014 audio_enc.sample_rate = atoi(arg);
4015 } else if (!strcasecmp(cmd, "AudioQuality")) {
4016 get_arg(arg, sizeof(arg), &p);
4018 // audio_enc.quality = atof(arg) * 1000;
4020 } else if (!strcasecmp(cmd, "VideoBitRateRange")) {
4022 int minrate, maxrate;
4024 get_arg(arg, sizeof(arg), &p);
4026 if (sscanf(arg, "%d-%d", &minrate, &maxrate) == 2) {
4027 video_enc.rc_min_rate = minrate * 1000;
4028 video_enc.rc_max_rate = maxrate * 1000;
4030 fprintf(stderr, "%s:%d: Incorrect format for VideoBitRateRange -- should be <min>-<max>: %s\n",
4031 filename, line_num, arg);
4035 } else if (!strcasecmp(cmd, "Debug")) {
4037 get_arg(arg, sizeof(arg), &p);
4038 video_enc.debug = strtol(arg,0,0);
4040 } else if (!strcasecmp(cmd, "Strict")) {
4042 get_arg(arg, sizeof(arg), &p);
4043 video_enc.strict_std_compliance = atoi(arg);
4045 } else if (!strcasecmp(cmd, "VideoBufferSize")) {
4047 get_arg(arg, sizeof(arg), &p);
4048 video_enc.rc_buffer_size = atoi(arg) * 8*1024;
4050 } else if (!strcasecmp(cmd, "VideoBitRateTolerance")) {
4052 get_arg(arg, sizeof(arg), &p);
4053 video_enc.bit_rate_tolerance = atoi(arg) * 1000;
4055 } else if (!strcasecmp(cmd, "VideoBitRate")) {
4056 get_arg(arg, sizeof(arg), &p);
4058 video_enc.bit_rate = atoi(arg) * 1000;
4060 } else if (!strcasecmp(cmd, "VideoSize")) {
4061 get_arg(arg, sizeof(arg), &p);
4063 av_parse_video_frame_size(&video_enc.width, &video_enc.height, arg);
4064 if ((video_enc.width % 16) != 0 ||
4065 (video_enc.height % 16) != 0) {
4066 fprintf(stderr, "%s:%d: Image size must be a multiple of 16\n",
4067 filename, line_num);
4071 } else if (!strcasecmp(cmd, "VideoFrameRate")) {
4072 get_arg(arg, sizeof(arg), &p);
4074 video_enc.time_base.num= DEFAULT_FRAME_RATE_BASE;
4075 video_enc.time_base.den = (int)(strtod(arg, NULL) * video_enc.time_base.num);
4077 } else if (!strcasecmp(cmd, "VideoGopSize")) {
4078 get_arg(arg, sizeof(arg), &p);
4080 video_enc.gop_size = atoi(arg);
4081 } else if (!strcasecmp(cmd, "VideoIntraOnly")) {
4083 video_enc.gop_size = 1;
4084 } else if (!strcasecmp(cmd, "VideoHighQuality")) {
4086 video_enc.mb_decision = FF_MB_DECISION_BITS;
4087 } else if (!strcasecmp(cmd, "Video4MotionVector")) {
4089 video_enc.mb_decision = FF_MB_DECISION_BITS; //FIXME remove
4090 video_enc.flags |= CODEC_FLAG_4MV;
4092 } else if (!strcasecmp(cmd, "VideoTag")) {
4093 get_arg(arg, sizeof(arg), &p);
4094 if ((strlen(arg) == 4) && stream)
4095 video_enc.codec_tag = ff_get_fourcc(arg);
4096 } else if (!strcasecmp(cmd, "BitExact")) {
4098 video_enc.flags |= CODEC_FLAG_BITEXACT;
4099 } else if (!strcasecmp(cmd, "DctFastint")) {
4101 video_enc.dct_algo = FF_DCT_FASTINT;
4102 } else if (!strcasecmp(cmd, "IdctSimple")) {
4104 video_enc.idct_algo = FF_IDCT_SIMPLE;
4105 } else if (!strcasecmp(cmd, "Qscale")) {
4106 get_arg(arg, sizeof(arg), &p);
4108 video_enc.flags |= CODEC_FLAG_QSCALE;
4109 video_enc.global_quality = FF_QP2LAMBDA * atoi(arg);
4111 } else if (!strcasecmp(cmd, "VideoQDiff")) {
4112 get_arg(arg, sizeof(arg), &p);
4114 video_enc.max_qdiff = atoi(arg);
4115 if (video_enc.max_qdiff < 1 || video_enc.max_qdiff > 31) {
4116 fprintf(stderr, "%s:%d: VideoQDiff out of range\n",
4117 filename, line_num);
4121 } else if (!strcasecmp(cmd, "VideoQMax")) {
4122 get_arg(arg, sizeof(arg), &p);
4124 video_enc.qmax = atoi(arg);
4125 if (video_enc.qmax < 1 || video_enc.qmax > 31) {
4126 fprintf(stderr, "%s:%d: VideoQMax out of range\n",
4127 filename, line_num);
4131 } else if (!strcasecmp(cmd, "VideoQMin")) {
4132 get_arg(arg, sizeof(arg), &p);
4134 video_enc.qmin = atoi(arg);
4135 if (video_enc.qmin < 1 || video_enc.qmin > 31) {
4136 fprintf(stderr, "%s:%d: VideoQMin out of range\n",
4137 filename, line_num);
4141 } else if (!strcasecmp(cmd, "LumaElim")) {
4142 get_arg(arg, sizeof(arg), &p);
4144 video_enc.luma_elim_threshold = atoi(arg);
4145 } else if (!strcasecmp(cmd, "ChromaElim")) {
4146 get_arg(arg, sizeof(arg), &p);
4148 video_enc.chroma_elim_threshold = atoi(arg);
4149 } else if (!strcasecmp(cmd, "LumiMask")) {
4150 get_arg(arg, sizeof(arg), &p);
4152 video_enc.lumi_masking = atof(arg);
4153 } else if (!strcasecmp(cmd, "DarkMask")) {
4154 get_arg(arg, sizeof(arg), &p);
4156 video_enc.dark_masking = atof(arg);
4157 } else if (!strcasecmp(cmd, "NoVideo")) {
4158 video_id = CODEC_ID_NONE;
4159 } else if (!strcasecmp(cmd, "NoAudio")) {
4160 audio_id = CODEC_ID_NONE;
4161 } else if (!strcasecmp(cmd, "ACL")) {
4164 get_arg(arg, sizeof(arg), &p);
4165 if (strcasecmp(arg, "allow") == 0)
4166 acl.action = IP_ALLOW;
4167 else if (strcasecmp(arg, "deny") == 0)
4168 acl.action = IP_DENY;
4170 fprintf(stderr, "%s:%d: ACL action '%s' is not ALLOW or DENY\n",
4171 filename, line_num, arg);
4175 get_arg(arg, sizeof(arg), &p);
4177 if (resolve_host(&acl.first, arg) != 0) {
4178 fprintf(stderr, "%s:%d: ACL refers to invalid host or ip address '%s'\n",
4179 filename, line_num, arg);
4182 acl.last = acl.first;
4184 get_arg(arg, sizeof(arg), &p);
4187 if (resolve_host(&acl.last, arg) != 0) {
4188 fprintf(stderr, "%s:%d: ACL refers to invalid host or ip address '%s'\n",
4189 filename, line_num, arg);
4195 IPAddressACL *nacl = (IPAddressACL *) av_mallocz(sizeof(*nacl));
4196 IPAddressACL **naclp = 0;
4202 naclp = &stream->acl;
4206 fprintf(stderr, "%s:%d: ACL found not in <stream> or <feed>\n",
4207 filename, line_num);
4213 naclp = &(*naclp)->next;
4218 } else if (!strcasecmp(cmd, "RTSPOption")) {
4219 get_arg(arg, sizeof(arg), &p);
4221 av_freep(&stream->rtsp_option);
4222 stream->rtsp_option = av_strdup(arg);
4224 } else if (!strcasecmp(cmd, "MulticastAddress")) {
4225 get_arg(arg, sizeof(arg), &p);
4227 if (resolve_host(&stream->multicast_ip, arg) != 0) {
4228 fprintf(stderr, "%s:%d: Invalid host/IP address: %s\n",
4229 filename, line_num, arg);
4232 stream->is_multicast = 1;
4233 stream->loop = 1; /* default is looping */
4235 } else if (!strcasecmp(cmd, "MulticastPort")) {
4236 get_arg(arg, sizeof(arg), &p);
4238 stream->multicast_port = atoi(arg);
4239 } else if (!strcasecmp(cmd, "MulticastTTL")) {
4240 get_arg(arg, sizeof(arg), &p);
4242 stream->multicast_ttl = atoi(arg);
4243 } else if (!strcasecmp(cmd, "NoLoop")) {
4246 } else if (!strcasecmp(cmd, "</Stream>")) {
4248 fprintf(stderr, "%s:%d: No corresponding <Stream> for </Stream>\n",
4249 filename, line_num);
4252 if (stream->feed && stream->fmt && strcmp(stream->fmt->name, "ffm") != 0) {
4253 if (audio_id != CODEC_ID_NONE) {
4254 audio_enc.codec_type = CODEC_TYPE_AUDIO;
4255 audio_enc.codec_id = audio_id;
4256 add_codec(stream, &audio_enc);
4258 if (video_id != CODEC_ID_NONE) {
4259 video_enc.codec_type = CODEC_TYPE_VIDEO;
4260 video_enc.codec_id = video_id;
4261 add_codec(stream, &video_enc);
4265 } else if (!strcasecmp(cmd, "<Redirect")) {
4266 /*********************************************/
4268 if (stream || feed || redirect) {
4269 fprintf(stderr, "%s:%d: Already in a tag\n",
4270 filename, line_num);
4273 redirect = av_mallocz(sizeof(FFStream));
4274 *last_stream = redirect;
4275 last_stream = &redirect->next;
4277 get_arg(redirect->filename, sizeof(redirect->filename), &p);
4278 q = strrchr(redirect->filename, '>');
4281 redirect->stream_type = STREAM_TYPE_REDIRECT;
4283 } else if (!strcasecmp(cmd, "URL")) {
4285 get_arg(redirect->feed_filename, sizeof(redirect->feed_filename), &p);
4286 } else if (!strcasecmp(cmd, "</Redirect>")) {
4288 fprintf(stderr, "%s:%d: No corresponding <Redirect> for </Redirect>\n",
4289 filename, line_num);
4292 if (!redirect->feed_filename[0]) {
4293 fprintf(stderr, "%s:%d: No URL found for <Redirect>\n",
4294 filename, line_num);
4298 } else if (!strcasecmp(cmd, "LoadModule")) {
4299 get_arg(arg, sizeof(arg), &p);
4303 fprintf(stderr, "%s:%d: Module support not compiled into this version: '%s'\n",
4304 filename, line_num, arg);
4308 fprintf(stderr, "%s:%d: Incorrect keyword: '%s'\n",
4309 filename, line_num, cmd);
4321 static void show_help(void)
4323 printf("usage: ffserver [-L] [-h] [-f configfile]\n"
4324 "Hyper fast multi format Audio/Video streaming server\n"
4326 "-L : print the LICENSE\n"
4328 "-f configfile : use configfile instead of /etc/ffserver.conf\n"
4332 static void handle_child_exit(int sig)
4337 while ((pid = waitpid(-1, &status, WNOHANG)) > 0) {
4340 for (feed = first_feed; feed; feed = feed->next) {
4341 if (feed->pid == pid) {
4342 int uptime = time(0) - feed->pid_start;
4345 fprintf(stderr, "%s: Pid %d exited with status %d after %d seconds\n", feed->filename, pid, status, uptime);
4348 /* Turn off any more restarts */
4349 feed->child_argv = 0;
4354 need_to_start_children = 1;
4357 int main(int argc, char **argv)
4359 const char *config_filename;
4361 struct sigaction sigact;
4365 show_banner(program_name, program_birth_year);
4367 config_filename = "/etc/ffserver.conf";
4369 my_program_name = argv[0];
4370 my_program_dir = getcwd(0, 0);
4371 ffserver_daemon = 1;
4374 c = getopt(argc, argv, "ndLh?f:");
4390 ffserver_daemon = 0;
4393 config_filename = optarg;
4400 putenv("http_proxy"); /* Kill the http_proxy */
4402 av_init_random(av_gettime() + (getpid() << 16), &random_state);
4404 /* address on which the server will handle HTTP connections */
4405 my_http_addr.sin_family = AF_INET;
4406 my_http_addr.sin_port = htons (8080);
4407 my_http_addr.sin_addr.s_addr = htonl (INADDR_ANY);
4409 /* address on which the server will handle RTSP connections */
4410 my_rtsp_addr.sin_family = AF_INET;
4411 my_rtsp_addr.sin_port = htons (5454);
4412 my_rtsp_addr.sin_addr.s_addr = htonl (INADDR_ANY);
4414 nb_max_connections = 5;
4415 max_bandwidth = 1000;
4416 first_stream = NULL;
4417 logfilename[0] = '\0';
4419 memset(&sigact, 0, sizeof(sigact));
4420 sigact.sa_handler = handle_child_exit;
4421 sigact.sa_flags = SA_NOCLDSTOP | SA_RESTART;
4422 sigaction(SIGCHLD, &sigact, 0);
4424 if (parse_ffconfig(config_filename) < 0) {
4425 fprintf(stderr, "Incorrect config file - exiting.\n");
4429 build_file_streams();
4431 build_feed_streams();
4433 compute_bandwidth();
4435 /* put the process in background and detach it from its TTY */
4436 if (ffserver_daemon) {
4443 } else if (pid > 0) {
4451 open("/dev/null", O_RDWR);
4452 if (strcmp(logfilename, "-") != 0) {
4462 signal(SIGPIPE, SIG_IGN);
4464 /* open log file if needed */
4465 if (logfilename[0] != '\0') {
4466 if (!strcmp(logfilename, "-"))
4469 logfile = fopen(logfilename, "w");
4472 if (http_server() < 0) {
4473 fprintf(stderr, "Could not start server\n");