2 * Multiple format streaming server
3 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
5 * This file is part of Libav.
7 * Libav is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * Libav is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with Libav; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
24 #define closesocket close
29 #include "libavformat/avformat.h"
30 #include "libavformat/ffm.h"
31 #include "libavformat/network.h"
32 #include "libavformat/os_support.h"
33 #include "libavformat/rtpdec.h"
34 #include "libavformat/rtsp.h"
35 // XXX for ffio_open_dyn_packet_buffer, to be removed
36 #include "libavformat/avio_internal.h"
37 #include "libavutil/avstring.h"
38 #include "libavutil/lfg.h"
39 #include "libavutil/dict.h"
40 #include "libavutil/mathematics.h"
41 #include "libavutil/random_seed.h"
42 #include "libavutil/parseutils.h"
43 #include "libavutil/opt.h"
47 #include <sys/ioctl.h>
62 const char program_name[] = "ffserver";
63 const int program_birth_year = 2000;
65 static const OptionDef options[];
68 HTTPSTATE_WAIT_REQUEST,
69 HTTPSTATE_SEND_HEADER,
70 HTTPSTATE_SEND_DATA_HEADER,
71 HTTPSTATE_SEND_DATA, /* sending TCP or UDP data */
72 HTTPSTATE_SEND_DATA_TRAILER,
73 HTTPSTATE_RECEIVE_DATA,
74 HTTPSTATE_WAIT_FEED, /* wait for data from the feed */
77 RTSPSTATE_WAIT_REQUEST,
79 RTSPSTATE_SEND_PACKET,
82 static const char *http_state[] = {
98 #define MAX_STREAMS 20
100 #define IOBUFFER_INIT_SIZE 8192
102 /* timeouts are in ms */
103 #define HTTP_REQUEST_TIMEOUT (15 * 1000)
104 #define RTSP_REQUEST_TIMEOUT (3600 * 24 * 1000)
106 #define SYNC_TIMEOUT (10 * 1000)
108 typedef struct RTSPActionServerSetup {
110 char transport_option[512];
111 } RTSPActionServerSetup;
114 int64_t count1, count2;
115 int64_t time1, time2;
118 /* context associated with one connection */
119 typedef struct HTTPContext {
120 enum HTTPState state;
121 int fd; /* socket file descriptor */
122 struct sockaddr_in from_addr; /* origin */
123 struct pollfd *poll_entry; /* used when polling */
125 uint8_t *buffer_ptr, *buffer_end;
128 int chunked_encoding;
129 int chunk_size; /* 0 if it needs to be read */
130 struct HTTPContext *next;
131 int got_key_frame; /* stream 0 => 1, stream 1 => 2, stream 2=> 4 */
135 /* input format handling */
136 AVFormatContext *fmt_in;
137 int64_t start_time; /* In milliseconds - this wraps fairly often */
138 int64_t first_pts; /* initial pts value */
139 int64_t cur_pts; /* current pts value from the stream in us */
140 int64_t cur_frame_duration; /* duration of the current frame in us */
141 int cur_frame_bytes; /* output frame size, needed to compute
142 the time at which we send each
144 int pts_stream_index; /* stream we choose as clock reference */
145 int64_t cur_clock; /* current clock reference value in us */
146 /* output format handling */
147 struct FFStream *stream;
148 /* -1 is invalid stream */
149 int feed_streams[MAX_STREAMS]; /* index of streams in the feed */
150 int switch_feed_streams[MAX_STREAMS]; /* index of streams in the feed */
152 AVFormatContext fmt_ctx; /* instance of FFStream for one user */
153 int last_packet_sent; /* true if last data packet was sent */
155 DataRateData datarate;
162 int is_packetized; /* if true, the stream is packetized */
163 int packet_stream_index; /* current stream for output in state machine */
165 /* RTSP state specific */
166 uint8_t *pb_buffer; /* XXX: use that in all the code */
168 int seq; /* RTSP sequence number */
170 /* RTP state specific */
171 enum RTSPLowerTransport rtp_protocol;
172 char session_id[32]; /* session id */
173 AVFormatContext *rtp_ctx[MAX_STREAMS];
175 /* RTP/UDP specific */
176 URLContext *rtp_handles[MAX_STREAMS];
178 /* RTP/TCP specific */
179 struct HTTPContext *rtsp_c;
180 uint8_t *packet_buffer, *packet_buffer_ptr, *packet_buffer_end;
183 /* each generated stream is described here */
187 STREAM_TYPE_REDIRECT,
190 enum IPAddressAction {
195 typedef struct IPAddressACL {
196 struct IPAddressACL *next;
197 enum IPAddressAction action;
198 /* These are in host order */
199 struct in_addr first;
203 /* description of each stream of the ffserver.conf file */
204 typedef struct FFStream {
205 enum StreamType stream_type;
206 char filename[1024]; /* stream filename */
207 struct FFStream *feed; /* feed we are using (can be null if
209 AVDictionary *in_opts; /* input parameters */
210 AVInputFormat *ifmt; /* if non NULL, force input format */
213 char dynamic_acl[1024];
215 int prebuffer; /* Number of millseconds early to start */
216 int64_t max_time; /* Number of milliseconds to run */
218 AVStream *streams[MAX_STREAMS];
219 int feed_streams[MAX_STREAMS]; /* index of streams in the feed */
220 char feed_filename[1024]; /* file name of the feed storage, or
221 input file name for a stream */
226 pid_t pid; /* Of ffmpeg process */
227 time_t pid_start; /* Of ffmpeg process */
229 struct FFStream *next;
230 unsigned bandwidth; /* bandwidth, in kbits/s */
233 /* multicast specific */
235 struct in_addr multicast_ip;
236 int multicast_port; /* first port used for multicast */
238 int loop; /* if true, send the stream in loops (only meaningful if file) */
241 int feed_opened; /* true if someone is writing to the feed */
242 int is_feed; /* true if it is a feed */
243 int readonly; /* True if writing is prohibited to the file */
244 int truncate; /* True if feeder connection truncate the feed file */
246 int64_t bytes_served;
247 int64_t feed_max_size; /* maximum storage size, zero means unlimited */
248 int64_t feed_write_index; /* current write position in feed (it wraps around) */
249 int64_t feed_size; /* current size of feed */
250 struct FFStream *next_feed;
253 typedef struct FeedData {
254 long long data_count;
255 float avg_frame_size; /* frame size averaged over last frames with exponential mean */
258 static struct sockaddr_in my_http_addr;
259 static struct sockaddr_in my_rtsp_addr;
261 static char logfilename[1024];
262 static HTTPContext *first_http_ctx;
263 static FFStream *first_feed; /* contains only feeds */
264 static FFStream *first_stream; /* contains all streams, including feeds */
266 static void new_connection(int server_fd, int is_rtsp);
267 static void close_connection(HTTPContext *c);
270 static int handle_connection(HTTPContext *c);
271 static int http_parse_request(HTTPContext *c);
272 static int http_send_data(HTTPContext *c);
273 static void compute_status(HTTPContext *c);
274 static int open_input_stream(HTTPContext *c, const char *info);
275 static int http_start_receive_data(HTTPContext *c);
276 static int http_receive_data(HTTPContext *c);
279 static int rtsp_parse_request(HTTPContext *c);
280 static void rtsp_cmd_describe(HTTPContext *c, const char *url);
281 static void rtsp_cmd_options(HTTPContext *c, const char *url);
282 static void rtsp_cmd_setup(HTTPContext *c, const char *url, RTSPMessageHeader *h);
283 static void rtsp_cmd_play(HTTPContext *c, const char *url, RTSPMessageHeader *h);
284 static void rtsp_cmd_pause(HTTPContext *c, const char *url, RTSPMessageHeader *h);
285 static void rtsp_cmd_teardown(HTTPContext *c, const char *url, RTSPMessageHeader *h);
288 static int prepare_sdp_description(FFStream *stream, uint8_t **pbuffer,
289 struct in_addr my_ip);
292 static HTTPContext *rtp_new_connection(struct sockaddr_in *from_addr,
293 FFStream *stream, const char *session_id,
294 enum RTSPLowerTransport rtp_protocol);
295 static int rtp_new_av_stream(HTTPContext *c,
296 int stream_index, struct sockaddr_in *dest_addr,
297 HTTPContext *rtsp_c);
299 static const char *my_program_name;
300 static const char *my_program_dir;
302 static const char *config_filename = "/etc/ffserver.conf";
304 static int ffserver_debug;
305 static int ffserver_daemon;
306 static int no_launch;
307 static int need_to_start_children;
309 /* maximum number of simultaneous HTTP connections */
310 static unsigned int nb_max_http_connections = 2000;
311 static unsigned int nb_max_connections = 5;
312 static unsigned int nb_connections;
314 static uint64_t max_bandwidth = 1000;
315 static uint64_t current_bandwidth;
317 static int64_t cur_time; // Making this global saves on passing it around everywhere
319 static AVLFG random_state;
321 static FILE *logfile = NULL;
323 /* FIXME: make ffserver work with IPv6 */
324 /* resolve host with also IP address parsing */
325 static int resolve_host(struct in_addr *sin_addr, const char *hostname)
328 if (!ff_inet_aton(hostname, sin_addr)) {
330 struct addrinfo *ai, *cur;
331 struct addrinfo hints;
332 memset(&hints, 0, sizeof(hints));
333 hints.ai_family = AF_INET;
334 if (getaddrinfo(hostname, NULL, &hints, &ai))
336 /* getaddrinfo returns a linked list of addrinfo structs.
337 * Even if we set ai_family = AF_INET above, make sure
338 * that the returned one actually is of the correct type. */
339 for (cur = ai; cur; cur = cur->ai_next) {
340 if (cur->ai_family == AF_INET) {
341 *sin_addr = ((struct sockaddr_in *)cur->ai_addr)->sin_addr;
350 hp = gethostbyname(hostname);
353 memcpy(sin_addr, hp->h_addr_list[0], sizeof(struct in_addr));
359 static char *ctime1(char *buf2)
367 p = buf2 + strlen(p) - 1;
373 static void http_vlog(const char *fmt, va_list vargs)
375 static int print_prefix = 1;
380 fprintf(logfile, "%s ", buf);
382 print_prefix = strstr(fmt, "\n") != NULL;
383 vfprintf(logfile, fmt, vargs);
389 __attribute__ ((format (printf, 1, 2)))
391 static void http_log(const char *fmt, ...)
394 va_start(vargs, fmt);
395 http_vlog(fmt, vargs);
399 static void http_av_log(void *ptr, int level, const char *fmt, va_list vargs)
401 static int print_prefix = 1;
402 AVClass *avc = ptr ? *(AVClass**)ptr : NULL;
403 if (level > av_log_get_level())
405 if (print_prefix && avc)
406 http_log("[%s @ %p]", avc->item_name(ptr), ptr);
407 print_prefix = strstr(fmt, "\n") != NULL;
408 http_vlog(fmt, vargs);
411 static void log_connection(HTTPContext *c)
416 http_log("%s - - [%s] \"%s %s\" %d %"PRId64"\n",
417 inet_ntoa(c->from_addr.sin_addr), c->method, c->url,
418 c->protocol, (c->http_error ? c->http_error : 200), c->data_count);
421 static void update_datarate(DataRateData *drd, int64_t count)
423 if (!drd->time1 && !drd->count1) {
424 drd->time1 = drd->time2 = cur_time;
425 drd->count1 = drd->count2 = count;
426 } else if (cur_time - drd->time2 > 5000) {
427 drd->time1 = drd->time2;
428 drd->count1 = drd->count2;
429 drd->time2 = cur_time;
434 /* In bytes per second */
435 static int compute_datarate(DataRateData *drd, int64_t count)
437 if (cur_time == drd->time1)
440 return ((count - drd->count1) * 1000) / (cur_time - drd->time1);
444 static void start_children(FFStream *feed)
449 for (; feed; feed = feed->next) {
450 if (feed->child_argv && !feed->pid) {
451 feed->pid_start = time(0);
456 http_log("Unable to create children\n");
465 av_strlcpy(pathname, my_program_name, sizeof(pathname));
467 slash = strrchr(pathname, '/');
472 strcpy(slash, "ffmpeg");
474 http_log("Launch commandline: ");
475 http_log("%s ", pathname);
476 for (i = 1; feed->child_argv[i] && feed->child_argv[i][0]; i++)
477 http_log("%s ", feed->child_argv[i]);
480 for (i = 3; i < 256; i++)
483 if (!ffserver_debug) {
484 i = open("/dev/null", O_RDWR);
493 /* This is needed to make relative pathnames work */
494 chdir(my_program_dir);
496 signal(SIGPIPE, SIG_DFL);
498 execvp(pathname, feed->child_argv);
506 /* open a listening socket */
507 static int socket_open_listen(struct sockaddr_in *my_addr)
511 server_fd = socket(AF_INET,SOCK_STREAM,0);
518 setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &tmp, sizeof(tmp));
520 if (bind (server_fd, (struct sockaddr *) my_addr, sizeof (*my_addr)) < 0) {
522 snprintf(bindmsg, sizeof(bindmsg), "bind(port %d)", ntohs(my_addr->sin_port));
524 closesocket(server_fd);
528 if (listen (server_fd, 5) < 0) {
530 closesocket(server_fd);
533 ff_socket_nonblock(server_fd, 1);
538 /* start all multicast streams */
539 static void start_multicast(void)
544 struct sockaddr_in dest_addr;
545 int default_port, stream_index;
548 for(stream = first_stream; stream != NULL; stream = stream->next) {
549 if (stream->is_multicast) {
550 /* open the RTP connection */
551 snprintf(session_id, sizeof(session_id), "%08x%08x",
552 av_lfg_get(&random_state), av_lfg_get(&random_state));
554 /* choose a port if none given */
555 if (stream->multicast_port == 0) {
556 stream->multicast_port = default_port;
560 dest_addr.sin_family = AF_INET;
561 dest_addr.sin_addr = stream->multicast_ip;
562 dest_addr.sin_port = htons(stream->multicast_port);
564 rtp_c = rtp_new_connection(&dest_addr, stream, session_id,
565 RTSP_LOWER_TRANSPORT_UDP_MULTICAST);
569 if (open_input_stream(rtp_c, "") < 0) {
570 http_log("Could not open input stream for stream '%s'\n",
575 /* open each RTP stream */
576 for(stream_index = 0; stream_index < stream->nb_streams;
578 dest_addr.sin_port = htons(stream->multicast_port +
580 if (rtp_new_av_stream(rtp_c, stream_index, &dest_addr, NULL) < 0) {
581 http_log("Could not open output stream '%s/streamid=%d'\n",
582 stream->filename, stream_index);
587 /* change state to send data */
588 rtp_c->state = HTTPSTATE_SEND_DATA;
593 /* main loop of the http server */
594 static int http_server(void)
596 int server_fd = 0, rtsp_server_fd = 0;
597 int ret, delay, delay1;
598 struct pollfd *poll_table, *poll_entry;
599 HTTPContext *c, *c_next;
601 if(!(poll_table = av_mallocz((nb_max_http_connections + 2)*sizeof(*poll_table)))) {
602 http_log("Impossible to allocate a poll table handling %d connections.\n", nb_max_http_connections);
606 if (my_http_addr.sin_port) {
607 server_fd = socket_open_listen(&my_http_addr);
612 if (my_rtsp_addr.sin_port) {
613 rtsp_server_fd = socket_open_listen(&my_rtsp_addr);
614 if (rtsp_server_fd < 0)
618 if (!rtsp_server_fd && !server_fd) {
619 http_log("HTTP and RTSP disabled.\n");
623 http_log("FFserver started.\n");
625 start_children(first_feed);
630 poll_entry = poll_table;
632 poll_entry->fd = server_fd;
633 poll_entry->events = POLLIN;
636 if (rtsp_server_fd) {
637 poll_entry->fd = rtsp_server_fd;
638 poll_entry->events = POLLIN;
642 /* wait for events on each HTTP handle */
649 case HTTPSTATE_SEND_HEADER:
650 case RTSPSTATE_SEND_REPLY:
651 case RTSPSTATE_SEND_PACKET:
652 c->poll_entry = poll_entry;
654 poll_entry->events = POLLOUT;
657 case HTTPSTATE_SEND_DATA_HEADER:
658 case HTTPSTATE_SEND_DATA:
659 case HTTPSTATE_SEND_DATA_TRAILER:
660 if (!c->is_packetized) {
661 /* for TCP, we output as much as we can (may need to put a limit) */
662 c->poll_entry = poll_entry;
664 poll_entry->events = POLLOUT;
667 /* when ffserver is doing the timing, we work by
668 looking at which packet need to be sent every
670 delay1 = 10; /* one tick wait XXX: 10 ms assumed */
675 case HTTPSTATE_WAIT_REQUEST:
676 case HTTPSTATE_RECEIVE_DATA:
677 case HTTPSTATE_WAIT_FEED:
678 case RTSPSTATE_WAIT_REQUEST:
679 /* need to catch errors */
680 c->poll_entry = poll_entry;
682 poll_entry->events = POLLIN;/* Maybe this will work */
686 c->poll_entry = NULL;
692 /* wait for an event on one connection. We poll at least every
693 second to handle timeouts */
695 ret = poll(poll_table, poll_entry - poll_table, delay);
696 if (ret < 0 && ff_neterrno() != AVERROR(EAGAIN) &&
697 ff_neterrno() != AVERROR(EINTR))
701 cur_time = av_gettime() / 1000;
703 if (need_to_start_children) {
704 need_to_start_children = 0;
705 start_children(first_feed);
708 /* now handle the events */
709 for(c = first_http_ctx; c != NULL; c = c_next) {
711 if (handle_connection(c) < 0) {
712 /* close and free the connection */
718 poll_entry = poll_table;
720 /* new HTTP connection request ? */
721 if (poll_entry->revents & POLLIN)
722 new_connection(server_fd, 0);
725 if (rtsp_server_fd) {
726 /* new RTSP connection request ? */
727 if (poll_entry->revents & POLLIN)
728 new_connection(rtsp_server_fd, 1);
733 /* start waiting for a new HTTP/RTSP request */
734 static void start_wait_request(HTTPContext *c, int is_rtsp)
736 c->buffer_ptr = c->buffer;
737 c->buffer_end = c->buffer + c->buffer_size - 1; /* leave room for '\0' */
740 c->timeout = cur_time + RTSP_REQUEST_TIMEOUT;
741 c->state = RTSPSTATE_WAIT_REQUEST;
743 c->timeout = cur_time + HTTP_REQUEST_TIMEOUT;
744 c->state = HTTPSTATE_WAIT_REQUEST;
748 static void http_send_too_busy_reply(int fd)
751 int len = snprintf(buffer, sizeof(buffer),
752 "HTTP/1.0 503 Server too busy\r\n"
753 "Content-type: text/html\r\n"
755 "<html><head><title>Too busy</title></head><body>\r\n"
756 "<p>The server is too busy to serve your request at this time.</p>\r\n"
757 "<p>The number of current connections is %d, and this exceeds the limit of %d.</p>\r\n"
758 "</body></html>\r\n",
759 nb_connections, nb_max_connections);
760 send(fd, buffer, len, 0);
764 static void new_connection(int server_fd, int is_rtsp)
766 struct sockaddr_in from_addr;
768 HTTPContext *c = NULL;
770 len = sizeof(from_addr);
771 fd = accept(server_fd, (struct sockaddr *)&from_addr,
774 http_log("error during accept %s\n", strerror(errno));
777 ff_socket_nonblock(fd, 1);
779 if (nb_connections >= nb_max_connections) {
780 http_send_too_busy_reply(fd);
784 /* add a new connection */
785 c = av_mallocz(sizeof(HTTPContext));
790 c->poll_entry = NULL;
791 c->from_addr = from_addr;
792 c->buffer_size = IOBUFFER_INIT_SIZE;
793 c->buffer = av_malloc(c->buffer_size);
797 c->next = first_http_ctx;
801 start_wait_request(c, is_rtsp);
813 static void close_connection(HTTPContext *c)
815 HTTPContext **cp, *c1;
817 AVFormatContext *ctx;
821 /* remove connection from list */
822 cp = &first_http_ctx;
823 while ((*cp) != NULL) {
831 /* remove references, if any (XXX: do it faster) */
832 for(c1 = first_http_ctx; c1 != NULL; c1 = c1->next) {
837 /* remove connection associated resources */
841 /* close each frame parser */
842 for(i=0;i<c->fmt_in->nb_streams;i++) {
843 st = c->fmt_in->streams[i];
844 if (st->codec->codec)
845 avcodec_close(st->codec);
847 av_close_input_file(c->fmt_in);
850 /* free RTP output streams if any */
853 nb_streams = c->stream->nb_streams;
855 for(i=0;i<nb_streams;i++) {
858 av_write_trailer(ctx);
859 av_dict_free(&ctx->metadata);
860 av_free(ctx->streams[0]);
863 h = c->rtp_handles[i];
870 if (!c->last_packet_sent && c->state == HTTPSTATE_SEND_DATA_TRAILER) {
873 if (avio_open_dyn_buf(&ctx->pb) >= 0) {
874 av_write_trailer(ctx);
875 av_freep(&c->pb_buffer);
876 avio_close_dyn_buf(ctx->pb, &c->pb_buffer);
881 for(i=0; i<ctx->nb_streams; i++)
882 av_free(ctx->streams[i]);
884 if (c->stream && !c->post && c->stream->stream_type == STREAM_TYPE_LIVE)
885 current_bandwidth -= c->stream->bandwidth;
887 /* signal that there is no feed if we are the feeder socket */
888 if (c->state == HTTPSTATE_RECEIVE_DATA && c->stream) {
889 c->stream->feed_opened = 0;
893 av_freep(&c->pb_buffer);
894 av_freep(&c->packet_buffer);
900 static int handle_connection(HTTPContext *c)
905 case HTTPSTATE_WAIT_REQUEST:
906 case RTSPSTATE_WAIT_REQUEST:
908 if ((c->timeout - cur_time) < 0)
910 if (c->poll_entry->revents & (POLLERR | POLLHUP))
913 /* no need to read if no events */
914 if (!(c->poll_entry->revents & POLLIN))
918 len = recv(c->fd, c->buffer_ptr, 1, 0);
920 if (ff_neterrno() != AVERROR(EAGAIN) &&
921 ff_neterrno() != AVERROR(EINTR))
923 } else if (len == 0) {
926 /* search for end of request. */
928 c->buffer_ptr += len;
930 if ((ptr >= c->buffer + 2 && !memcmp(ptr-2, "\n\n", 2)) ||
931 (ptr >= c->buffer + 4 && !memcmp(ptr-4, "\r\n\r\n", 4))) {
932 /* request found : parse it and reply */
933 if (c->state == HTTPSTATE_WAIT_REQUEST) {
934 ret = http_parse_request(c);
936 ret = rtsp_parse_request(c);
940 } else if (ptr >= c->buffer_end) {
941 /* request too long: cannot do anything */
943 } else goto read_loop;
947 case HTTPSTATE_SEND_HEADER:
948 if (c->poll_entry->revents & (POLLERR | POLLHUP))
951 /* no need to write if no events */
952 if (!(c->poll_entry->revents & POLLOUT))
954 len = send(c->fd, c->buffer_ptr, c->buffer_end - c->buffer_ptr, 0);
956 if (ff_neterrno() != AVERROR(EAGAIN) &&
957 ff_neterrno() != AVERROR(EINTR)) {
958 /* error : close connection */
959 av_freep(&c->pb_buffer);
963 c->buffer_ptr += len;
965 c->stream->bytes_served += len;
966 c->data_count += len;
967 if (c->buffer_ptr >= c->buffer_end) {
968 av_freep(&c->pb_buffer);
972 /* all the buffer was sent : synchronize to the incoming stream */
973 c->state = HTTPSTATE_SEND_DATA_HEADER;
974 c->buffer_ptr = c->buffer_end = c->buffer;
979 case HTTPSTATE_SEND_DATA:
980 case HTTPSTATE_SEND_DATA_HEADER:
981 case HTTPSTATE_SEND_DATA_TRAILER:
982 /* for packetized output, we consider we can always write (the
983 input streams sets the speed). It may be better to verify
984 that we do not rely too much on the kernel queues */
985 if (!c->is_packetized) {
986 if (c->poll_entry->revents & (POLLERR | POLLHUP))
989 /* no need to read if no events */
990 if (!(c->poll_entry->revents & POLLOUT))
993 if (http_send_data(c) < 0)
995 /* close connection if trailer sent */
996 if (c->state == HTTPSTATE_SEND_DATA_TRAILER)
999 case HTTPSTATE_RECEIVE_DATA:
1000 /* no need to read if no events */
1001 if (c->poll_entry->revents & (POLLERR | POLLHUP))
1003 if (!(c->poll_entry->revents & POLLIN))
1005 if (http_receive_data(c) < 0)
1008 case HTTPSTATE_WAIT_FEED:
1009 /* no need to read if no events */
1010 if (c->poll_entry->revents & (POLLIN | POLLERR | POLLHUP))
1013 /* nothing to do, we'll be waken up by incoming feed packets */
1016 case RTSPSTATE_SEND_REPLY:
1017 if (c->poll_entry->revents & (POLLERR | POLLHUP)) {
1018 av_freep(&c->pb_buffer);
1021 /* no need to write if no events */
1022 if (!(c->poll_entry->revents & POLLOUT))
1024 len = send(c->fd, c->buffer_ptr, c->buffer_end - c->buffer_ptr, 0);
1026 if (ff_neterrno() != AVERROR(EAGAIN) &&
1027 ff_neterrno() != AVERROR(EINTR)) {
1028 /* error : close connection */
1029 av_freep(&c->pb_buffer);
1033 c->buffer_ptr += len;
1034 c->data_count += len;
1035 if (c->buffer_ptr >= c->buffer_end) {
1036 /* all the buffer was sent : wait for a new request */
1037 av_freep(&c->pb_buffer);
1038 start_wait_request(c, 1);
1042 case RTSPSTATE_SEND_PACKET:
1043 if (c->poll_entry->revents & (POLLERR | POLLHUP)) {
1044 av_freep(&c->packet_buffer);
1047 /* no need to write if no events */
1048 if (!(c->poll_entry->revents & POLLOUT))
1050 len = send(c->fd, c->packet_buffer_ptr,
1051 c->packet_buffer_end - c->packet_buffer_ptr, 0);
1053 if (ff_neterrno() != AVERROR(EAGAIN) &&
1054 ff_neterrno() != AVERROR(EINTR)) {
1055 /* error : close connection */
1056 av_freep(&c->packet_buffer);
1060 c->packet_buffer_ptr += len;
1061 if (c->packet_buffer_ptr >= c->packet_buffer_end) {
1062 /* all the buffer was sent : wait for a new request */
1063 av_freep(&c->packet_buffer);
1064 c->state = RTSPSTATE_WAIT_REQUEST;
1068 case HTTPSTATE_READY:
1077 static int extract_rates(char *rates, int ratelen, const char *request)
1081 for (p = request; *p && *p != '\r' && *p != '\n'; ) {
1082 if (strncasecmp(p, "Pragma:", 7) == 0) {
1083 const char *q = p + 7;
1085 while (*q && *q != '\n' && isspace(*q))
1088 if (strncasecmp(q, "stream-switch-entry=", 20) == 0) {
1094 memset(rates, 0xff, ratelen);
1097 while (*q && *q != '\n' && *q != ':')
1100 if (sscanf(q, ":%d:%d", &stream_no, &rate_no) != 2)
1104 if (stream_no < ratelen && stream_no >= 0)
1105 rates[stream_no] = rate_no;
1107 while (*q && *q != '\n' && !isspace(*q))
1114 p = strchr(p, '\n');
1124 static int find_stream_in_feed(FFStream *feed, AVCodecContext *codec, int bit_rate)
1127 int best_bitrate = 100000000;
1130 for (i = 0; i < feed->nb_streams; i++) {
1131 AVCodecContext *feed_codec = feed->streams[i]->codec;
1133 if (feed_codec->codec_id != codec->codec_id ||
1134 feed_codec->sample_rate != codec->sample_rate ||
1135 feed_codec->width != codec->width ||
1136 feed_codec->height != codec->height)
1139 /* Potential stream */
1141 /* We want the fastest stream less than bit_rate, or the slowest
1142 * faster than bit_rate
1145 if (feed_codec->bit_rate <= bit_rate) {
1146 if (best_bitrate > bit_rate || feed_codec->bit_rate > best_bitrate) {
1147 best_bitrate = feed_codec->bit_rate;
1151 if (feed_codec->bit_rate < best_bitrate) {
1152 best_bitrate = feed_codec->bit_rate;
1161 static int modify_current_stream(HTTPContext *c, char *rates)
1164 FFStream *req = c->stream;
1165 int action_required = 0;
1167 /* Not much we can do for a feed */
1171 for (i = 0; i < req->nb_streams; i++) {
1172 AVCodecContext *codec = req->streams[i]->codec;
1176 c->switch_feed_streams[i] = req->feed_streams[i];
1179 c->switch_feed_streams[i] = find_stream_in_feed(req->feed, codec, codec->bit_rate / 2);
1182 /* Wants off or slow */
1183 c->switch_feed_streams[i] = find_stream_in_feed(req->feed, codec, codec->bit_rate / 4);
1185 /* This doesn't work well when it turns off the only stream! */
1186 c->switch_feed_streams[i] = -2;
1187 c->feed_streams[i] = -2;
1192 if (c->switch_feed_streams[i] >= 0 && c->switch_feed_streams[i] != c->feed_streams[i])
1193 action_required = 1;
1196 return action_required;
1199 /* XXX: factorize in utils.c ? */
1200 /* XXX: take care with different space meaning */
1201 static void skip_spaces(const char **pp)
1205 while (*p == ' ' || *p == '\t')
1210 static void get_word(char *buf, int buf_size, const char **pp)
1218 while (!isspace(*p) && *p != '\0') {
1219 if ((q - buf) < buf_size - 1)
1228 static void get_arg(char *buf, int buf_size, const char **pp)
1235 while (isspace(*p)) p++;
1238 if (*p == '\"' || *p == '\'')
1250 if ((q - buf) < buf_size - 1)
1255 if (quote && *p == quote)
1260 static void parse_acl_row(FFStream *stream, FFStream* feed, IPAddressACL *ext_acl,
1261 const char *p, const char *filename, int line_num)
1267 get_arg(arg, sizeof(arg), &p);
1268 if (strcasecmp(arg, "allow") == 0)
1269 acl.action = IP_ALLOW;
1270 else if (strcasecmp(arg, "deny") == 0)
1271 acl.action = IP_DENY;
1273 fprintf(stderr, "%s:%d: ACL action '%s' is not ALLOW or DENY\n",
1274 filename, line_num, arg);
1278 get_arg(arg, sizeof(arg), &p);
1280 if (resolve_host(&acl.first, arg) != 0) {
1281 fprintf(stderr, "%s:%d: ACL refers to invalid host or ip address '%s'\n",
1282 filename, line_num, arg);
1285 acl.last = acl.first;
1287 get_arg(arg, sizeof(arg), &p);
1290 if (resolve_host(&acl.last, arg) != 0) {
1291 fprintf(stderr, "%s:%d: ACL refers to invalid host or ip address '%s'\n",
1292 filename, line_num, arg);
1298 IPAddressACL *nacl = av_mallocz(sizeof(*nacl));
1299 IPAddressACL **naclp = 0;
1305 naclp = &stream->acl;
1311 fprintf(stderr, "%s:%d: ACL found not in <stream> or <feed>\n",
1312 filename, line_num);
1318 naclp = &(*naclp)->next;
1326 static IPAddressACL* parse_dynamic_acl(FFStream *stream, HTTPContext *c)
1331 IPAddressACL *acl = NULL;
1335 f = fopen(stream->dynamic_acl, "r");
1337 perror(stream->dynamic_acl);
1341 acl = av_mallocz(sizeof(IPAddressACL));
1345 if (fgets(line, sizeof(line), f) == NULL)
1351 if (*p == '\0' || *p == '#')
1353 get_arg(cmd, sizeof(cmd), &p);
1355 if (!strcasecmp(cmd, "ACL"))
1356 parse_acl_row(NULL, NULL, acl, p, stream->dynamic_acl, line_num);
1363 static void free_acl_list(IPAddressACL *in_acl)
1365 IPAddressACL *pacl,*pacl2;
1375 static int validate_acl_list(IPAddressACL *in_acl, HTTPContext *c)
1377 enum IPAddressAction last_action = IP_DENY;
1379 struct in_addr *src = &c->from_addr.sin_addr;
1380 unsigned long src_addr = src->s_addr;
1382 for (acl = in_acl; acl; acl = acl->next) {
1383 if (src_addr >= acl->first.s_addr && src_addr <= acl->last.s_addr)
1384 return (acl->action == IP_ALLOW) ? 1 : 0;
1385 last_action = acl->action;
1388 /* Nothing matched, so return not the last action */
1389 return (last_action == IP_DENY) ? 1 : 0;
1392 static int validate_acl(FFStream *stream, HTTPContext *c)
1398 /* if stream->acl is null validate_acl_list will return 1 */
1399 ret = validate_acl_list(stream->acl, c);
1401 if (stream->dynamic_acl[0]) {
1402 acl = parse_dynamic_acl(stream, c);
1404 ret = validate_acl_list(acl, c);
1412 /* compute the real filename of a file by matching it without its
1413 extensions to all the stream filenames */
1414 static void compute_real_filename(char *filename, int max_size)
1421 /* compute filename by matching without the file extensions */
1422 av_strlcpy(file1, filename, sizeof(file1));
1423 p = strrchr(file1, '.');
1426 for(stream = first_stream; stream != NULL; stream = stream->next) {
1427 av_strlcpy(file2, stream->filename, sizeof(file2));
1428 p = strrchr(file2, '.');
1431 if (!strcmp(file1, file2)) {
1432 av_strlcpy(filename, stream->filename, max_size);
1447 /* parse http request and prepare header */
1448 static int http_parse_request(HTTPContext *c)
1451 enum RedirType redir_type;
1453 char info[1024], filename[1024];
1457 const char *mime_type;
1461 char *useragent = 0;
1464 get_word(cmd, sizeof(cmd), (const char **)&p);
1465 av_strlcpy(c->method, cmd, sizeof(c->method));
1467 if (!strcmp(cmd, "GET"))
1469 else if (!strcmp(cmd, "POST"))
1474 get_word(url, sizeof(url), (const char **)&p);
1475 av_strlcpy(c->url, url, sizeof(c->url));
1477 get_word(protocol, sizeof(protocol), (const char **)&p);
1478 if (strcmp(protocol, "HTTP/1.0") && strcmp(protocol, "HTTP/1.1"))
1481 av_strlcpy(c->protocol, protocol, sizeof(c->protocol));
1484 http_log("%s - - New connection: %s %s\n", inet_ntoa(c->from_addr.sin_addr), cmd, url);
1486 /* find the filename and the optional info string in the request */
1487 p = strchr(url, '?');
1489 av_strlcpy(info, p, sizeof(info));
1494 av_strlcpy(filename, url + ((*url == '/') ? 1 : 0), sizeof(filename)-1);
1496 for (p = c->buffer; *p && *p != '\r' && *p != '\n'; ) {
1497 if (strncasecmp(p, "User-Agent:", 11) == 0) {
1499 if (*useragent && *useragent != '\n' && isspace(*useragent))
1503 p = strchr(p, '\n');
1510 redir_type = REDIR_NONE;
1511 if (av_match_ext(filename, "asx")) {
1512 redir_type = REDIR_ASX;
1513 filename[strlen(filename)-1] = 'f';
1514 } else if (av_match_ext(filename, "asf") &&
1515 (!useragent || strncasecmp(useragent, "NSPlayer", 8) != 0)) {
1516 /* if this isn't WMP or lookalike, return the redirector file */
1517 redir_type = REDIR_ASF;
1518 } else if (av_match_ext(filename, "rpm,ram")) {
1519 redir_type = REDIR_RAM;
1520 strcpy(filename + strlen(filename)-2, "m");
1521 } else if (av_match_ext(filename, "rtsp")) {
1522 redir_type = REDIR_RTSP;
1523 compute_real_filename(filename, sizeof(filename) - 1);
1524 } else if (av_match_ext(filename, "sdp")) {
1525 redir_type = REDIR_SDP;
1526 compute_real_filename(filename, sizeof(filename) - 1);
1529 // "redirect" / request to index.html
1530 if (!strlen(filename))
1531 av_strlcpy(filename, "index.html", sizeof(filename) - 1);
1533 stream = first_stream;
1534 while (stream != NULL) {
1535 if (!strcmp(stream->filename, filename) && validate_acl(stream, c))
1537 stream = stream->next;
1539 if (stream == NULL) {
1540 snprintf(msg, sizeof(msg), "File '%s' not found", url);
1541 http_log("File '%s' not found\n", url);
1546 memcpy(c->feed_streams, stream->feed_streams, sizeof(c->feed_streams));
1547 memset(c->switch_feed_streams, -1, sizeof(c->switch_feed_streams));
1549 if (stream->stream_type == STREAM_TYPE_REDIRECT) {
1550 c->http_error = 301;
1552 q += snprintf(q, c->buffer_size,
1553 "HTTP/1.0 301 Moved\r\n"
1555 "Content-type: text/html\r\n"
1557 "<html><head><title>Moved</title></head><body>\r\n"
1558 "You should be <a href=\"%s\">redirected</a>.\r\n"
1559 "</body></html>\r\n", stream->feed_filename, stream->feed_filename);
1560 /* prepare output buffer */
1561 c->buffer_ptr = c->buffer;
1563 c->state = HTTPSTATE_SEND_HEADER;
1567 /* If this is WMP, get the rate information */
1568 if (extract_rates(ratebuf, sizeof(ratebuf), c->buffer)) {
1569 if (modify_current_stream(c, ratebuf)) {
1570 for (i = 0; i < FF_ARRAY_ELEMS(c->feed_streams); i++) {
1571 if (c->switch_feed_streams[i] >= 0)
1572 c->switch_feed_streams[i] = -1;
1577 if (c->post == 0 && stream->stream_type == STREAM_TYPE_LIVE)
1578 current_bandwidth += stream->bandwidth;
1580 /* If already streaming this feed, do not let start another feeder. */
1581 if (stream->feed_opened) {
1582 snprintf(msg, sizeof(msg), "This feed is already being received.");
1583 http_log("Feed '%s' already being received\n", stream->feed_filename);
1587 if (c->post == 0 && max_bandwidth < current_bandwidth) {
1588 c->http_error = 503;
1590 q += snprintf(q, c->buffer_size,
1591 "HTTP/1.0 503 Server too busy\r\n"
1592 "Content-type: text/html\r\n"
1594 "<html><head><title>Too busy</title></head><body>\r\n"
1595 "<p>The server is too busy to serve your request at this time.</p>\r\n"
1596 "<p>The bandwidth being served (including your stream) is %"PRIu64"kbit/sec, "
1597 "and this exceeds the limit of %"PRIu64"kbit/sec.</p>\r\n"
1598 "</body></html>\r\n", current_bandwidth, max_bandwidth);
1599 /* prepare output buffer */
1600 c->buffer_ptr = c->buffer;
1602 c->state = HTTPSTATE_SEND_HEADER;
1606 if (redir_type != REDIR_NONE) {
1609 for (p = c->buffer; *p && *p != '\r' && *p != '\n'; ) {
1610 if (strncasecmp(p, "Host:", 5) == 0) {
1614 p = strchr(p, '\n');
1625 while (isspace(*hostinfo))
1628 eoh = strchr(hostinfo, '\n');
1630 if (eoh[-1] == '\r')
1633 if (eoh - hostinfo < sizeof(hostbuf) - 1) {
1634 memcpy(hostbuf, hostinfo, eoh - hostinfo);
1635 hostbuf[eoh - hostinfo] = 0;
1637 c->http_error = 200;
1639 switch(redir_type) {
1641 q += snprintf(q, c->buffer_size,
1642 "HTTP/1.0 200 ASX Follows\r\n"
1643 "Content-type: video/x-ms-asf\r\n"
1645 "<ASX Version=\"3\">\r\n"
1646 //"<!-- Autogenerated by ffserver -->\r\n"
1647 "<ENTRY><REF HREF=\"http://%s/%s%s\"/></ENTRY>\r\n"
1648 "</ASX>\r\n", hostbuf, filename, info);
1651 q += snprintf(q, c->buffer_size,
1652 "HTTP/1.0 200 RAM Follows\r\n"
1653 "Content-type: audio/x-pn-realaudio\r\n"
1655 "# Autogenerated by ffserver\r\n"
1656 "http://%s/%s%s\r\n", hostbuf, filename, info);
1659 q += snprintf(q, c->buffer_size,
1660 "HTTP/1.0 200 ASF Redirect follows\r\n"
1661 "Content-type: video/x-ms-asf\r\n"
1664 "Ref1=http://%s/%s%s\r\n", hostbuf, filename, info);
1668 char hostname[256], *p;
1669 /* extract only hostname */
1670 av_strlcpy(hostname, hostbuf, sizeof(hostname));
1671 p = strrchr(hostname, ':');
1674 q += snprintf(q, c->buffer_size,
1675 "HTTP/1.0 200 RTSP Redirect follows\r\n"
1676 /* XXX: incorrect mime type ? */
1677 "Content-type: application/x-rtsp\r\n"
1679 "rtsp://%s:%d/%s\r\n", hostname, ntohs(my_rtsp_addr.sin_port), filename);
1685 int sdp_data_size, len;
1686 struct sockaddr_in my_addr;
1688 q += snprintf(q, c->buffer_size,
1689 "HTTP/1.0 200 OK\r\n"
1690 "Content-type: application/sdp\r\n"
1693 len = sizeof(my_addr);
1694 getsockname(c->fd, (struct sockaddr *)&my_addr, &len);
1696 /* XXX: should use a dynamic buffer */
1697 sdp_data_size = prepare_sdp_description(stream,
1700 if (sdp_data_size > 0) {
1701 memcpy(q, sdp_data, sdp_data_size);
1713 /* prepare output buffer */
1714 c->buffer_ptr = c->buffer;
1716 c->state = HTTPSTATE_SEND_HEADER;
1722 snprintf(msg, sizeof(msg), "ASX/RAM file not handled");
1726 stream->conns_served++;
1728 /* XXX: add there authenticate and IP match */
1731 /* if post, it means a feed is being sent */
1732 if (!stream->is_feed) {
1733 /* However it might be a status report from WMP! Let us log the
1734 * data as it might come in handy one day. */
1738 for (p = c->buffer; *p && *p != '\r' && *p != '\n'; ) {
1739 if (strncasecmp(p, "Pragma: log-line=", 17) == 0) {
1743 if (strncasecmp(p, "Pragma: client-id=", 18) == 0)
1744 client_id = strtol(p + 18, 0, 10);
1745 p = strchr(p, '\n');
1753 char *eol = strchr(logline, '\n');
1758 if (eol[-1] == '\r')
1760 http_log("%.*s\n", (int) (eol - logline), logline);
1761 c->suppress_log = 1;
1766 http_log("\nGot request:\n%s\n", c->buffer);
1769 if (client_id && extract_rates(ratebuf, sizeof(ratebuf), c->buffer)) {
1772 /* Now we have to find the client_id */
1773 for (wmpc = first_http_ctx; wmpc; wmpc = wmpc->next) {
1774 if (wmpc->wmp_client_id == client_id)
1778 if (wmpc && modify_current_stream(wmpc, ratebuf))
1779 wmpc->switch_pending = 1;
1782 snprintf(msg, sizeof(msg), "POST command not handled");
1786 if (http_start_receive_data(c) < 0) {
1787 snprintf(msg, sizeof(msg), "could not open feed");
1791 c->state = HTTPSTATE_RECEIVE_DATA;
1796 if (strcmp(stream->filename + strlen(stream->filename) - 4, ".asf") == 0)
1797 http_log("\nGot request:\n%s\n", c->buffer);
1800 if (c->stream->stream_type == STREAM_TYPE_STATUS)
1803 /* open input stream */
1804 if (open_input_stream(c, info) < 0) {
1805 snprintf(msg, sizeof(msg), "Input stream corresponding to '%s' not found", url);
1809 /* prepare http header */
1811 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "HTTP/1.0 200 OK\r\n");
1812 mime_type = c->stream->fmt->mime_type;
1814 mime_type = "application/x-octet-stream";
1815 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "Pragma: no-cache\r\n");
1817 /* for asf, we need extra headers */
1818 if (!strcmp(c->stream->fmt->name,"asf_stream")) {
1819 /* Need to allocate a client id */
1821 c->wmp_client_id = av_lfg_get(&random_state);
1823 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "Server: Cougar 4.1.0.3923\r\nCache-Control: no-cache\r\nPragma: client-id=%d\r\nPragma: features=\"broadcast\"\r\n", c->wmp_client_id);
1825 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "Content-Type: %s\r\n", mime_type);
1826 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "\r\n");
1828 /* prepare output buffer */
1830 c->buffer_ptr = c->buffer;
1832 c->state = HTTPSTATE_SEND_HEADER;
1835 c->http_error = 404;
1837 q += snprintf(q, c->buffer_size,
1838 "HTTP/1.0 404 Not Found\r\n"
1839 "Content-type: text/html\r\n"
1842 "<head><title>404 Not Found</title></head>\n"
1845 /* prepare output buffer */
1846 c->buffer_ptr = c->buffer;
1848 c->state = HTTPSTATE_SEND_HEADER;
1852 c->http_error = 200; /* horrible : we use this value to avoid
1853 going to the send data state */
1854 c->state = HTTPSTATE_SEND_HEADER;
1858 static void fmt_bytecount(AVIOContext *pb, int64_t count)
1860 static const char *suffix = " kMGTP";
1863 for (s = suffix; count >= 100000 && s[1]; count /= 1000, s++);
1865 avio_printf(pb, "%"PRId64"%c", count, *s);
1868 static void compute_status(HTTPContext *c)
1877 if (avio_open_dyn_buf(&pb) < 0) {
1878 /* XXX: return an error ? */
1879 c->buffer_ptr = c->buffer;
1880 c->buffer_end = c->buffer;
1884 avio_printf(pb, "HTTP/1.0 200 OK\r\n");
1885 avio_printf(pb, "Content-type: %s\r\n", "text/html");
1886 avio_printf(pb, "Pragma: no-cache\r\n");
1887 avio_printf(pb, "\r\n");
1889 avio_printf(pb, "<html><head><title>%s Status</title>\n", program_name);
1890 if (c->stream->feed_filename[0])
1891 avio_printf(pb, "<link rel=\"shortcut icon\" href=\"%s\">\n", c->stream->feed_filename);
1892 avio_printf(pb, "</head>\n<body>");
1893 avio_printf(pb, "<h1>%s Status</h1>\n", program_name);
1895 avio_printf(pb, "<h2>Available Streams</h2>\n");
1896 avio_printf(pb, "<table cellspacing=0 cellpadding=4>\n");
1897 avio_printf(pb, "<tr><th valign=top>Path<th align=left>Served<br>Conns<th><br>bytes<th valign=top>Format<th>Bit rate<br>kbits/s<th align=left>Video<br>kbits/s<th><br>Codec<th align=left>Audio<br>kbits/s<th><br>Codec<th align=left valign=top>Feed\n");
1898 stream = first_stream;
1899 while (stream != NULL) {
1900 char sfilename[1024];
1903 if (stream->feed != stream) {
1904 av_strlcpy(sfilename, stream->filename, sizeof(sfilename) - 10);
1905 eosf = sfilename + strlen(sfilename);
1906 if (eosf - sfilename >= 4) {
1907 if (strcmp(eosf - 4, ".asf") == 0)
1908 strcpy(eosf - 4, ".asx");
1909 else if (strcmp(eosf - 3, ".rm") == 0)
1910 strcpy(eosf - 3, ".ram");
1911 else if (stream->fmt && !strcmp(stream->fmt->name, "rtp")) {
1912 /* generate a sample RTSP director if
1913 unicast. Generate an SDP redirector if
1915 eosf = strrchr(sfilename, '.');
1917 eosf = sfilename + strlen(sfilename);
1918 if (stream->is_multicast)
1919 strcpy(eosf, ".sdp");
1921 strcpy(eosf, ".rtsp");
1925 avio_printf(pb, "<tr><td><a href=\"/%s\">%s</a> ",
1926 sfilename, stream->filename);
1927 avio_printf(pb, "<td align=right> %d <td align=right> ",
1928 stream->conns_served);
1929 fmt_bytecount(pb, stream->bytes_served);
1930 switch(stream->stream_type) {
1931 case STREAM_TYPE_LIVE: {
1932 int audio_bit_rate = 0;
1933 int video_bit_rate = 0;
1934 const char *audio_codec_name = "";
1935 const char *video_codec_name = "";
1936 const char *audio_codec_name_extra = "";
1937 const char *video_codec_name_extra = "";
1939 for(i=0;i<stream->nb_streams;i++) {
1940 AVStream *st = stream->streams[i];
1941 AVCodec *codec = avcodec_find_encoder(st->codec->codec_id);
1942 switch(st->codec->codec_type) {
1943 case AVMEDIA_TYPE_AUDIO:
1944 audio_bit_rate += st->codec->bit_rate;
1946 if (*audio_codec_name)
1947 audio_codec_name_extra = "...";
1948 audio_codec_name = codec->name;
1951 case AVMEDIA_TYPE_VIDEO:
1952 video_bit_rate += st->codec->bit_rate;
1954 if (*video_codec_name)
1955 video_codec_name_extra = "...";
1956 video_codec_name = codec->name;
1959 case AVMEDIA_TYPE_DATA:
1960 video_bit_rate += st->codec->bit_rate;
1966 avio_printf(pb, "<td align=center> %s <td align=right> %d <td align=right> %d <td> %s %s <td align=right> %d <td> %s %s",
1969 video_bit_rate / 1000, video_codec_name, video_codec_name_extra,
1970 audio_bit_rate / 1000, audio_codec_name, audio_codec_name_extra);
1972 avio_printf(pb, "<td>%s", stream->feed->filename);
1974 avio_printf(pb, "<td>%s", stream->feed_filename);
1975 avio_printf(pb, "\n");
1979 avio_printf(pb, "<td align=center> - <td align=right> - <td align=right> - <td><td align=right> - <td>\n");
1983 stream = stream->next;
1985 avio_printf(pb, "</table>\n");
1987 stream = first_stream;
1988 while (stream != NULL) {
1989 if (stream->feed == stream) {
1990 avio_printf(pb, "<h2>Feed %s</h2>", stream->filename);
1992 avio_printf(pb, "Running as pid %d.\n", stream->pid);
1994 #if defined(linux) && !defined(CONFIG_NOCUTILS)
1999 /* This is somewhat linux specific I guess */
2000 snprintf(ps_cmd, sizeof(ps_cmd),
2001 "ps -o \"%%cpu,cputime\" --no-headers %d",
2004 pid_stat = popen(ps_cmd, "r");
2009 if (fscanf(pid_stat, "%10s %64s", cpuperc,
2011 avio_printf(pb, "Currently using %s%% of the cpu. Total time used %s.\n",
2019 avio_printf(pb, "<p>");
2021 avio_printf(pb, "<table cellspacing=0 cellpadding=4><tr><th>Stream<th>type<th>kbits/s<th align=left>codec<th align=left>Parameters\n");
2023 for (i = 0; i < stream->nb_streams; i++) {
2024 AVStream *st = stream->streams[i];
2025 AVCodec *codec = avcodec_find_encoder(st->codec->codec_id);
2026 const char *type = "unknown";
2027 char parameters[64];
2031 switch(st->codec->codec_type) {
2032 case AVMEDIA_TYPE_AUDIO:
2034 snprintf(parameters, sizeof(parameters), "%d channel(s), %d Hz", st->codec->channels, st->codec->sample_rate);
2036 case AVMEDIA_TYPE_VIDEO:
2038 snprintf(parameters, sizeof(parameters), "%dx%d, q=%d-%d, fps=%d", st->codec->width, st->codec->height,
2039 st->codec->qmin, st->codec->qmax, st->codec->time_base.den / st->codec->time_base.num);
2044 avio_printf(pb, "<tr><td align=right>%d<td>%s<td align=right>%d<td>%s<td>%s\n",
2045 i, type, st->codec->bit_rate/1000, codec ? codec->name : "", parameters);
2047 avio_printf(pb, "</table>\n");
2050 stream = stream->next;
2053 /* connection status */
2054 avio_printf(pb, "<h2>Connection Status</h2>\n");
2056 avio_printf(pb, "Number of connections: %d / %d<br>\n",
2057 nb_connections, nb_max_connections);
2059 avio_printf(pb, "Bandwidth in use: %"PRIu64"k / %"PRIu64"k<br>\n",
2060 current_bandwidth, max_bandwidth);
2062 avio_printf(pb, "<table>\n");
2063 avio_printf(pb, "<tr><th>#<th>File<th>IP<th>Proto<th>State<th>Target bits/sec<th>Actual bits/sec<th>Bytes transferred\n");
2064 c1 = first_http_ctx;
2066 while (c1 != NULL) {
2072 for (j = 0; j < c1->stream->nb_streams; j++) {
2073 if (!c1->stream->feed)
2074 bitrate += c1->stream->streams[j]->codec->bit_rate;
2075 else if (c1->feed_streams[j] >= 0)
2076 bitrate += c1->stream->feed->streams[c1->feed_streams[j]]->codec->bit_rate;
2081 p = inet_ntoa(c1->from_addr.sin_addr);
2082 avio_printf(pb, "<tr><td><b>%d</b><td>%s%s<td>%s<td>%s<td>%s<td align=right>",
2084 c1->stream ? c1->stream->filename : "",
2085 c1->state == HTTPSTATE_RECEIVE_DATA ? "(input)" : "",
2088 http_state[c1->state]);
2089 fmt_bytecount(pb, bitrate);
2090 avio_printf(pb, "<td align=right>");
2091 fmt_bytecount(pb, compute_datarate(&c1->datarate, c1->data_count) * 8);
2092 avio_printf(pb, "<td align=right>");
2093 fmt_bytecount(pb, c1->data_count);
2094 avio_printf(pb, "\n");
2097 avio_printf(pb, "</table>\n");
2102 avio_printf(pb, "<hr size=1 noshade>Generated at %s", p);
2103 avio_printf(pb, "</body>\n</html>\n");
2105 len = avio_close_dyn_buf(pb, &c->pb_buffer);
2106 c->buffer_ptr = c->pb_buffer;
2107 c->buffer_end = c->pb_buffer + len;
2110 /* check if the parser needs to be opened for stream i */
2111 static void open_parser(AVFormatContext *s, int i)
2113 AVStream *st = s->streams[i];
2116 if (!st->codec->codec) {
2117 codec = avcodec_find_decoder(st->codec->codec_id);
2118 if (codec && (codec->capabilities & CODEC_CAP_PARSE_ONLY)) {
2119 st->codec->parse_only = 1;
2120 if (avcodec_open(st->codec, codec) < 0)
2121 st->codec->parse_only = 0;
2126 static int open_input_stream(HTTPContext *c, const char *info)
2129 char input_filename[1024];
2130 AVFormatContext *s = NULL;
2131 int buf_size, i, ret;
2134 /* find file name */
2135 if (c->stream->feed) {
2136 strcpy(input_filename, c->stream->feed->feed_filename);
2137 buf_size = FFM_PACKET_SIZE;
2138 /* compute position (absolute time) */
2139 if (av_find_info_tag(buf, sizeof(buf), "date", info)) {
2140 if ((ret = av_parse_time(&stream_pos, buf, 0)) < 0)
2142 } else if (av_find_info_tag(buf, sizeof(buf), "buffer", info)) {
2143 int prebuffer = strtol(buf, 0, 10);
2144 stream_pos = av_gettime() - prebuffer * (int64_t)1000000;
2146 stream_pos = av_gettime() - c->stream->prebuffer * (int64_t)1000;
2148 strcpy(input_filename, c->stream->feed_filename);
2150 /* compute position (relative time) */
2151 if (av_find_info_tag(buf, sizeof(buf), "date", info)) {
2152 if ((ret = av_parse_time(&stream_pos, buf, 1)) < 0)
2157 if (input_filename[0] == '\0')
2161 if ((ret = avformat_open_input(&s, input_filename, c->stream->ifmt, &c->stream->in_opts)) < 0) {
2162 http_log("could not open %s: %d\n", input_filename, ret);
2165 s->flags |= AVFMT_FLAG_GENPTS;
2167 if (strcmp(s->iformat->name, "ffm") && av_find_stream_info(c->fmt_in) < 0) {
2168 http_log("Could not find stream info '%s'\n", input_filename);
2169 av_close_input_file(s);
2173 /* open each parser */
2174 for(i=0;i<s->nb_streams;i++)
2177 /* choose stream as clock source (we favorize video stream if
2178 present) for packet sending */
2179 c->pts_stream_index = 0;
2180 for(i=0;i<c->stream->nb_streams;i++) {
2181 if (c->pts_stream_index == 0 &&
2182 c->stream->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2183 c->pts_stream_index = i;
2187 if (c->fmt_in->iformat->read_seek)
2188 av_seek_frame(c->fmt_in, -1, stream_pos, 0);
2189 /* set the start time (needed for maxtime and RTP packet timing) */
2190 c->start_time = cur_time;
2191 c->first_pts = AV_NOPTS_VALUE;
2195 /* return the server clock (in us) */
2196 static int64_t get_server_clock(HTTPContext *c)
2198 /* compute current pts value from system time */
2199 return (cur_time - c->start_time) * 1000;
2202 /* return the estimated time at which the current packet must be sent
2204 static int64_t get_packet_send_clock(HTTPContext *c)
2206 int bytes_left, bytes_sent, frame_bytes;
2208 frame_bytes = c->cur_frame_bytes;
2209 if (frame_bytes <= 0)
2212 bytes_left = c->buffer_end - c->buffer_ptr;
2213 bytes_sent = frame_bytes - bytes_left;
2214 return c->cur_pts + (c->cur_frame_duration * bytes_sent) / frame_bytes;
2219 static int http_prepare_data(HTTPContext *c)
2222 AVFormatContext *ctx;
2224 av_freep(&c->pb_buffer);
2226 case HTTPSTATE_SEND_DATA_HEADER:
2227 memset(&c->fmt_ctx, 0, sizeof(c->fmt_ctx));
2228 av_dict_set(&c->fmt_ctx.metadata, "author" , c->stream->author , 0);
2229 av_dict_set(&c->fmt_ctx.metadata, "comment" , c->stream->comment , 0);
2230 av_dict_set(&c->fmt_ctx.metadata, "copyright", c->stream->copyright, 0);
2231 av_dict_set(&c->fmt_ctx.metadata, "title" , c->stream->title , 0);
2233 c->fmt_ctx.streams = av_mallocz(sizeof(AVStream *) * c->stream->nb_streams);
2235 for(i=0;i<c->stream->nb_streams;i++) {
2237 c->fmt_ctx.streams[i] = av_mallocz(sizeof(AVStream));
2238 /* if file or feed, then just take streams from FFStream struct */
2239 if (!c->stream->feed ||
2240 c->stream->feed == c->stream)
2241 src = c->stream->streams[i];
2243 src = c->stream->feed->streams[c->stream->feed_streams[i]];
2245 *(c->fmt_ctx.streams[i]) = *src;
2246 c->fmt_ctx.streams[i]->priv_data = 0;
2247 c->fmt_ctx.streams[i]->codec->frame_number = 0; /* XXX: should be done in
2248 AVStream, not in codec */
2250 /* set output format parameters */
2251 c->fmt_ctx.oformat = c->stream->fmt;
2252 c->fmt_ctx.nb_streams = c->stream->nb_streams;
2254 c->got_key_frame = 0;
2256 /* prepare header and save header data in a stream */
2257 if (avio_open_dyn_buf(&c->fmt_ctx.pb) < 0) {
2258 /* XXX: potential leak */
2261 c->fmt_ctx.pb->seekable = 0;
2264 * HACK to avoid mpeg ps muxer to spit many underflow errors
2265 * Default value from Libav
2266 * Try to set it use configuration option
2268 c->fmt_ctx.preload = (int)(0.5*AV_TIME_BASE);
2269 c->fmt_ctx.max_delay = (int)(0.7*AV_TIME_BASE);
2271 if (avformat_write_header(&c->fmt_ctx, NULL) < 0) {
2272 http_log("Error writing output header\n");
2275 av_dict_free(&c->fmt_ctx.metadata);
2277 len = avio_close_dyn_buf(c->fmt_ctx.pb, &c->pb_buffer);
2278 c->buffer_ptr = c->pb_buffer;
2279 c->buffer_end = c->pb_buffer + len;
2281 c->state = HTTPSTATE_SEND_DATA;
2282 c->last_packet_sent = 0;
2284 case HTTPSTATE_SEND_DATA:
2285 /* find a new packet */
2286 /* read a packet from the input stream */
2287 if (c->stream->feed)
2288 ffm_set_write_index(c->fmt_in,
2289 c->stream->feed->feed_write_index,
2290 c->stream->feed->feed_size);
2292 if (c->stream->max_time &&
2293 c->stream->max_time + c->start_time - cur_time < 0)
2294 /* We have timed out */
2295 c->state = HTTPSTATE_SEND_DATA_TRAILER;
2299 ret = av_read_frame(c->fmt_in, &pkt);
2301 if (c->stream->feed) {
2302 /* if coming from feed, it means we reached the end of the
2303 ffm file, so must wait for more data */
2304 c->state = HTTPSTATE_WAIT_FEED;
2305 return 1; /* state changed */
2306 } else if (ret == AVERROR(EAGAIN)) {
2307 /* input not ready, come back later */
2310 if (c->stream->loop) {
2311 av_close_input_file(c->fmt_in);
2313 if (open_input_stream(c, "") < 0)
2318 /* must send trailer now because eof or error */
2319 c->state = HTTPSTATE_SEND_DATA_TRAILER;
2323 int source_index = pkt.stream_index;
2324 /* update first pts if needed */
2325 if (c->first_pts == AV_NOPTS_VALUE) {
2326 c->first_pts = av_rescale_q(pkt.dts, c->fmt_in->streams[pkt.stream_index]->time_base, AV_TIME_BASE_Q);
2327 c->start_time = cur_time;
2329 /* send it to the appropriate stream */
2330 if (c->stream->feed) {
2331 /* if coming from a feed, select the right stream */
2332 if (c->switch_pending) {
2333 c->switch_pending = 0;
2334 for(i=0;i<c->stream->nb_streams;i++) {
2335 if (c->switch_feed_streams[i] == pkt.stream_index)
2336 if (pkt.flags & AV_PKT_FLAG_KEY)
2337 c->switch_feed_streams[i] = -1;
2338 if (c->switch_feed_streams[i] >= 0)
2339 c->switch_pending = 1;
2342 for(i=0;i<c->stream->nb_streams;i++) {
2343 if (c->stream->feed_streams[i] == pkt.stream_index) {
2344 AVStream *st = c->fmt_in->streams[source_index];
2345 pkt.stream_index = i;
2346 if (pkt.flags & AV_PKT_FLAG_KEY &&
2347 (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2348 c->stream->nb_streams == 1))
2349 c->got_key_frame = 1;
2350 if (!c->stream->send_on_key || c->got_key_frame)
2355 AVCodecContext *codec;
2356 AVStream *ist, *ost;
2358 ist = c->fmt_in->streams[source_index];
2359 /* specific handling for RTP: we use several
2360 output stream (one for each RTP
2361 connection). XXX: need more abstract handling */
2362 if (c->is_packetized) {
2363 /* compute send time and duration */
2364 c->cur_pts = av_rescale_q(pkt.dts, ist->time_base, AV_TIME_BASE_Q);
2365 c->cur_pts -= c->first_pts;
2366 c->cur_frame_duration = av_rescale_q(pkt.duration, ist->time_base, AV_TIME_BASE_Q);
2367 /* find RTP context */
2368 c->packet_stream_index = pkt.stream_index;
2369 ctx = c->rtp_ctx[c->packet_stream_index];
2371 av_free_packet(&pkt);
2374 codec = ctx->streams[0]->codec;
2375 /* only one stream per RTP connection */
2376 pkt.stream_index = 0;
2380 codec = ctx->streams[pkt.stream_index]->codec;
2383 if (c->is_packetized) {
2384 int max_packet_size;
2385 if (c->rtp_protocol == RTSP_LOWER_TRANSPORT_TCP)
2386 max_packet_size = RTSP_TCP_MAX_PACKET_SIZE;
2388 max_packet_size = url_get_max_packet_size(c->rtp_handles[c->packet_stream_index]);
2389 ret = ffio_open_dyn_packet_buf(&ctx->pb, max_packet_size);
2391 ret = avio_open_dyn_buf(&ctx->pb);
2394 /* XXX: potential leak */
2397 ost = ctx->streams[pkt.stream_index];
2399 ctx->pb->seekable = 0;
2400 if (pkt.dts != AV_NOPTS_VALUE)
2401 pkt.dts = av_rescale_q(pkt.dts, ist->time_base, ost->time_base);
2402 if (pkt.pts != AV_NOPTS_VALUE)
2403 pkt.pts = av_rescale_q(pkt.pts, ist->time_base, ost->time_base);
2404 pkt.duration = av_rescale_q(pkt.duration, ist->time_base, ost->time_base);
2405 if (av_write_frame(ctx, &pkt) < 0) {
2406 http_log("Error writing frame to output\n");
2407 c->state = HTTPSTATE_SEND_DATA_TRAILER;
2410 len = avio_close_dyn_buf(ctx->pb, &c->pb_buffer);
2411 c->cur_frame_bytes = len;
2412 c->buffer_ptr = c->pb_buffer;
2413 c->buffer_end = c->pb_buffer + len;
2415 codec->frame_number++;
2417 av_free_packet(&pkt);
2421 av_free_packet(&pkt);
2426 case HTTPSTATE_SEND_DATA_TRAILER:
2427 /* last packet test ? */
2428 if (c->last_packet_sent || c->is_packetized)
2431 /* prepare header */
2432 if (avio_open_dyn_buf(&ctx->pb) < 0) {
2433 /* XXX: potential leak */
2436 c->fmt_ctx.pb->seekable = 0;
2437 av_write_trailer(ctx);
2438 len = avio_close_dyn_buf(ctx->pb, &c->pb_buffer);
2439 c->buffer_ptr = c->pb_buffer;
2440 c->buffer_end = c->pb_buffer + len;
2442 c->last_packet_sent = 1;
2448 /* should convert the format at the same time */
2449 /* send data starting at c->buffer_ptr to the output connection
2450 (either UDP or TCP connection) */
2451 static int http_send_data(HTTPContext *c)
2456 if (c->buffer_ptr >= c->buffer_end) {
2457 ret = http_prepare_data(c);
2461 /* state change requested */
2464 if (c->is_packetized) {
2465 /* RTP data output */
2466 len = c->buffer_end - c->buffer_ptr;
2468 /* fail safe - should never happen */
2470 c->buffer_ptr = c->buffer_end;
2473 len = (c->buffer_ptr[0] << 24) |
2474 (c->buffer_ptr[1] << 16) |
2475 (c->buffer_ptr[2] << 8) |
2477 if (len > (c->buffer_end - c->buffer_ptr))
2479 if ((get_packet_send_clock(c) - get_server_clock(c)) > 0) {
2480 /* nothing to send yet: we can wait */
2484 c->data_count += len;
2485 update_datarate(&c->datarate, c->data_count);
2487 c->stream->bytes_served += len;
2489 if (c->rtp_protocol == RTSP_LOWER_TRANSPORT_TCP) {
2490 /* RTP packets are sent inside the RTSP TCP connection */
2492 int interleaved_index, size;
2494 HTTPContext *rtsp_c;
2497 /* if no RTSP connection left, error */
2500 /* if already sending something, then wait. */
2501 if (rtsp_c->state != RTSPSTATE_WAIT_REQUEST)
2503 if (avio_open_dyn_buf(&pb) < 0)
2505 interleaved_index = c->packet_stream_index * 2;
2506 /* RTCP packets are sent at odd indexes */
2507 if (c->buffer_ptr[1] == 200)
2508 interleaved_index++;
2509 /* write RTSP TCP header */
2511 header[1] = interleaved_index;
2512 header[2] = len >> 8;
2514 avio_write(pb, header, 4);
2515 /* write RTP packet data */
2517 avio_write(pb, c->buffer_ptr, len);
2518 size = avio_close_dyn_buf(pb, &c->packet_buffer);
2519 /* prepare asynchronous TCP sending */
2520 rtsp_c->packet_buffer_ptr = c->packet_buffer;
2521 rtsp_c->packet_buffer_end = c->packet_buffer + size;
2522 c->buffer_ptr += len;
2524 /* send everything we can NOW */
2525 len = send(rtsp_c->fd, rtsp_c->packet_buffer_ptr,
2526 rtsp_c->packet_buffer_end - rtsp_c->packet_buffer_ptr, 0);
2528 rtsp_c->packet_buffer_ptr += len;
2529 if (rtsp_c->packet_buffer_ptr < rtsp_c->packet_buffer_end) {
2530 /* if we could not send all the data, we will
2531 send it later, so a new state is needed to
2532 "lock" the RTSP TCP connection */
2533 rtsp_c->state = RTSPSTATE_SEND_PACKET;
2536 /* all data has been sent */
2537 av_freep(&c->packet_buffer);
2539 /* send RTP packet directly in UDP */
2541 url_write(c->rtp_handles[c->packet_stream_index],
2542 c->buffer_ptr, len);
2543 c->buffer_ptr += len;
2544 /* here we continue as we can send several packets per 10 ms slot */
2547 /* TCP data output */
2548 len = send(c->fd, c->buffer_ptr, c->buffer_end - c->buffer_ptr, 0);
2550 if (ff_neterrno() != AVERROR(EAGAIN) &&
2551 ff_neterrno() != AVERROR(EINTR))
2552 /* error : close connection */
2557 c->buffer_ptr += len;
2559 c->data_count += len;
2560 update_datarate(&c->datarate, c->data_count);
2562 c->stream->bytes_served += len;
2570 static int http_start_receive_data(HTTPContext *c)
2574 if (c->stream->feed_opened)
2577 /* Don't permit writing to this one */
2578 if (c->stream->readonly)
2582 fd = open(c->stream->feed_filename, O_RDWR);
2584 http_log("Error opening feeder file: %s\n", strerror(errno));
2589 if (c->stream->truncate) {
2590 /* truncate feed file */
2591 ffm_write_write_index(c->feed_fd, FFM_PACKET_SIZE);
2592 ftruncate(c->feed_fd, FFM_PACKET_SIZE);
2593 http_log("Truncating feed file '%s'\n", c->stream->feed_filename);
2595 if ((c->stream->feed_write_index = ffm_read_write_index(fd)) < 0) {
2596 http_log("Error reading write index from feed file: %s\n", strerror(errno));
2601 c->stream->feed_write_index = FFMAX(ffm_read_write_index(fd), FFM_PACKET_SIZE);
2602 c->stream->feed_size = lseek(fd, 0, SEEK_END);
2603 lseek(fd, 0, SEEK_SET);
2605 /* init buffer input */
2606 c->buffer_ptr = c->buffer;
2607 c->buffer_end = c->buffer + FFM_PACKET_SIZE;
2608 c->stream->feed_opened = 1;
2609 c->chunked_encoding = !!av_stristr(c->buffer, "Transfer-Encoding: chunked");
2613 static int http_receive_data(HTTPContext *c)
2616 int len, loop_run = 0;
2618 while (c->chunked_encoding && !c->chunk_size &&
2619 c->buffer_end > c->buffer_ptr) {
2620 /* read chunk header, if present */
2621 len = recv(c->fd, c->buffer_ptr, 1, 0);
2624 if (ff_neterrno() != AVERROR(EAGAIN) &&
2625 ff_neterrno() != AVERROR(EINTR))
2626 /* error : close connection */
2629 } else if (len == 0) {
2630 /* end of connection : close it */
2632 } else if (c->buffer_ptr - c->buffer >= 2 &&
2633 !memcmp(c->buffer_ptr - 1, "\r\n", 2)) {
2634 c->chunk_size = strtol(c->buffer, 0, 16);
2635 if (c->chunk_size == 0) // end of stream
2637 c->buffer_ptr = c->buffer;
2639 } else if (++loop_run > 10) {
2640 /* no chunk header, abort */
2647 if (c->buffer_end > c->buffer_ptr) {
2648 len = recv(c->fd, c->buffer_ptr,
2649 FFMIN(c->chunk_size, c->buffer_end - c->buffer_ptr), 0);
2651 if (ff_neterrno() != AVERROR(EAGAIN) &&
2652 ff_neterrno() != AVERROR(EINTR))
2653 /* error : close connection */
2655 } else if (len == 0)
2656 /* end of connection : close it */
2659 c->chunk_size -= len;
2660 c->buffer_ptr += len;
2661 c->data_count += len;
2662 update_datarate(&c->datarate, c->data_count);
2666 if (c->buffer_ptr - c->buffer >= 2 && c->data_count > FFM_PACKET_SIZE) {
2667 if (c->buffer[0] != 'f' ||
2668 c->buffer[1] != 'm') {
2669 http_log("Feed stream has become desynchronized -- disconnecting\n");
2674 if (c->buffer_ptr >= c->buffer_end) {
2675 FFStream *feed = c->stream;
2676 /* a packet has been received : write it in the store, except
2678 if (c->data_count > FFM_PACKET_SIZE) {
2680 // printf("writing pos=0x%"PRIx64" size=0x%"PRIx64"\n", feed->feed_write_index, feed->feed_size);
2681 /* XXX: use llseek or url_seek */
2682 lseek(c->feed_fd, feed->feed_write_index, SEEK_SET);
2683 if (write(c->feed_fd, c->buffer, FFM_PACKET_SIZE) < 0) {
2684 http_log("Error writing to feed file: %s\n", strerror(errno));
2688 feed->feed_write_index += FFM_PACKET_SIZE;
2689 /* update file size */
2690 if (feed->feed_write_index > c->stream->feed_size)
2691 feed->feed_size = feed->feed_write_index;
2693 /* handle wrap around if max file size reached */
2694 if (c->stream->feed_max_size && feed->feed_write_index >= c->stream->feed_max_size)
2695 feed->feed_write_index = FFM_PACKET_SIZE;
2698 if (ffm_write_write_index(c->feed_fd, feed->feed_write_index) < 0) {
2699 http_log("Error writing index to feed file: %s\n", strerror(errno));
2703 /* wake up any waiting connections */
2704 for(c1 = first_http_ctx; c1 != NULL; c1 = c1->next) {
2705 if (c1->state == HTTPSTATE_WAIT_FEED &&
2706 c1->stream->feed == c->stream->feed)
2707 c1->state = HTTPSTATE_SEND_DATA;
2710 /* We have a header in our hands that contains useful data */
2711 AVFormatContext *s = avformat_alloc_context();
2713 AVInputFormat *fmt_in;
2719 /* use feed output format name to find corresponding input format */
2720 fmt_in = av_find_input_format(feed->fmt->name);
2724 pb = avio_alloc_context(c->buffer, c->buffer_end - c->buffer,
2725 0, NULL, NULL, NULL, NULL);
2729 if (avformat_open_input(&s, c->stream->feed_filename, fmt_in, NULL) < 0) {
2734 /* Now we have the actual streams */
2735 if (s->nb_streams != feed->nb_streams) {
2736 av_close_input_stream(s);
2738 http_log("Feed '%s' stream number does not match registered feed\n",
2739 c->stream->feed_filename);
2743 for (i = 0; i < s->nb_streams; i++) {
2744 AVStream *fst = feed->streams[i];
2745 AVStream *st = s->streams[i];
2746 avcodec_copy_context(fst->codec, st->codec);
2749 av_close_input_stream(s);
2752 c->buffer_ptr = c->buffer;
2757 c->stream->feed_opened = 0;
2759 /* wake up any waiting connections to stop waiting for feed */
2760 for(c1 = first_http_ctx; c1 != NULL; c1 = c1->next) {
2761 if (c1->state == HTTPSTATE_WAIT_FEED &&
2762 c1->stream->feed == c->stream->feed)
2763 c1->state = HTTPSTATE_SEND_DATA_TRAILER;
2768 /********************************************************************/
2771 static void rtsp_reply_header(HTTPContext *c, enum RTSPStatusCode error_number)
2778 switch(error_number) {
2779 case RTSP_STATUS_OK:
2782 case RTSP_STATUS_METHOD:
2783 str = "Method Not Allowed";
2785 case RTSP_STATUS_BANDWIDTH:
2786 str = "Not Enough Bandwidth";
2788 case RTSP_STATUS_SESSION:
2789 str = "Session Not Found";
2791 case RTSP_STATUS_STATE:
2792 str = "Method Not Valid in This State";
2794 case RTSP_STATUS_AGGREGATE:
2795 str = "Aggregate operation not allowed";
2797 case RTSP_STATUS_ONLY_AGGREGATE:
2798 str = "Only aggregate operation allowed";
2800 case RTSP_STATUS_TRANSPORT:
2801 str = "Unsupported transport";
2803 case RTSP_STATUS_INTERNAL:
2804 str = "Internal Server Error";
2806 case RTSP_STATUS_SERVICE:
2807 str = "Service Unavailable";
2809 case RTSP_STATUS_VERSION:
2810 str = "RTSP Version not supported";
2813 str = "Unknown Error";
2817 avio_printf(c->pb, "RTSP/1.0 %d %s\r\n", error_number, str);
2818 avio_printf(c->pb, "CSeq: %d\r\n", c->seq);
2820 /* output GMT time */
2823 strftime(buf2, sizeof(buf2), "%a, %d %b %Y %H:%M:%S", tm);
2824 avio_printf(c->pb, "Date: %s GMT\r\n", buf2);
2827 static void rtsp_reply_error(HTTPContext *c, enum RTSPStatusCode error_number)
2829 rtsp_reply_header(c, error_number);
2830 avio_printf(c->pb, "\r\n");
2833 static int rtsp_parse_request(HTTPContext *c)
2835 const char *p, *p1, *p2;
2841 RTSPMessageHeader header1, *header = &header1;
2843 c->buffer_ptr[0] = '\0';
2846 get_word(cmd, sizeof(cmd), &p);
2847 get_word(url, sizeof(url), &p);
2848 get_word(protocol, sizeof(protocol), &p);
2850 av_strlcpy(c->method, cmd, sizeof(c->method));
2851 av_strlcpy(c->url, url, sizeof(c->url));
2852 av_strlcpy(c->protocol, protocol, sizeof(c->protocol));
2854 if (avio_open_dyn_buf(&c->pb) < 0) {
2855 /* XXX: cannot do more */
2856 c->pb = NULL; /* safety */
2860 /* check version name */
2861 if (strcmp(protocol, "RTSP/1.0") != 0) {
2862 rtsp_reply_error(c, RTSP_STATUS_VERSION);
2866 /* parse each header line */
2867 memset(header, 0, sizeof(*header));
2868 /* skip to next line */
2869 while (*p != '\n' && *p != '\0')
2873 while (*p != '\0') {
2874 p1 = memchr(p, '\n', (char *)c->buffer_ptr - p);
2878 if (p2 > p && p2[-1] == '\r')
2880 /* skip empty line */
2884 if (len > sizeof(line) - 1)
2885 len = sizeof(line) - 1;
2886 memcpy(line, p, len);
2888 ff_rtsp_parse_line(header, line, NULL, NULL);
2892 /* handle sequence number */
2893 c->seq = header->seq;
2895 if (!strcmp(cmd, "DESCRIBE"))
2896 rtsp_cmd_describe(c, url);
2897 else if (!strcmp(cmd, "OPTIONS"))
2898 rtsp_cmd_options(c, url);
2899 else if (!strcmp(cmd, "SETUP"))
2900 rtsp_cmd_setup(c, url, header);
2901 else if (!strcmp(cmd, "PLAY"))
2902 rtsp_cmd_play(c, url, header);
2903 else if (!strcmp(cmd, "PAUSE"))
2904 rtsp_cmd_pause(c, url, header);
2905 else if (!strcmp(cmd, "TEARDOWN"))
2906 rtsp_cmd_teardown(c, url, header);
2908 rtsp_reply_error(c, RTSP_STATUS_METHOD);
2911 len = avio_close_dyn_buf(c->pb, &c->pb_buffer);
2912 c->pb = NULL; /* safety */
2914 /* XXX: cannot do more */
2917 c->buffer_ptr = c->pb_buffer;
2918 c->buffer_end = c->pb_buffer + len;
2919 c->state = RTSPSTATE_SEND_REPLY;
2923 static int prepare_sdp_description(FFStream *stream, uint8_t **pbuffer,
2924 struct in_addr my_ip)
2926 AVFormatContext *avc;
2927 AVStream *avs = NULL;
2930 avc = avformat_alloc_context();
2934 av_dict_set(&avc->metadata, "title",
2935 stream->title[0] ? stream->title : "No Title", 0);
2936 avc->nb_streams = stream->nb_streams;
2937 if (stream->is_multicast) {
2938 snprintf(avc->filename, 1024, "rtp://%s:%d?multicast=1?ttl=%d",
2939 inet_ntoa(stream->multicast_ip),
2940 stream->multicast_port, stream->multicast_ttl);
2942 snprintf(avc->filename, 1024, "rtp://0.0.0.0");
2945 if (avc->nb_streams >= INT_MAX/sizeof(*avc->streams) ||
2946 !(avc->streams = av_malloc(avc->nb_streams * sizeof(*avc->streams))))
2948 if (avc->nb_streams >= INT_MAX/sizeof(*avs) ||
2949 !(avs = av_malloc(avc->nb_streams * sizeof(*avs))))
2952 for(i = 0; i < stream->nb_streams; i++) {
2953 avc->streams[i] = &avs[i];
2954 avc->streams[i]->codec = stream->streams[i]->codec;
2956 *pbuffer = av_mallocz(2048);
2957 av_sdp_create(&avc, 1, *pbuffer, 2048);
2960 av_free(avc->streams);
2961 av_dict_free(&avc->metadata);
2965 return strlen(*pbuffer);
2968 static void rtsp_cmd_options(HTTPContext *c, const char *url)
2970 // rtsp_reply_header(c, RTSP_STATUS_OK);
2971 avio_printf(c->pb, "RTSP/1.0 %d %s\r\n", RTSP_STATUS_OK, "OK");
2972 avio_printf(c->pb, "CSeq: %d\r\n", c->seq);
2973 avio_printf(c->pb, "Public: %s\r\n", "OPTIONS, DESCRIBE, SETUP, TEARDOWN, PLAY, PAUSE");
2974 avio_printf(c->pb, "\r\n");
2977 static void rtsp_cmd_describe(HTTPContext *c, const char *url)
2983 int content_length, len;
2984 struct sockaddr_in my_addr;
2986 /* find which url is asked */
2987 av_url_split(NULL, 0, NULL, 0, NULL, 0, NULL, path1, sizeof(path1), url);
2992 for(stream = first_stream; stream != NULL; stream = stream->next) {
2993 if (!stream->is_feed &&
2994 stream->fmt && !strcmp(stream->fmt->name, "rtp") &&
2995 !strcmp(path, stream->filename)) {
2999 /* no stream found */
3000 rtsp_reply_error(c, RTSP_STATUS_SERVICE); /* XXX: right error ? */
3004 /* prepare the media description in sdp format */
3006 /* get the host IP */
3007 len = sizeof(my_addr);
3008 getsockname(c->fd, (struct sockaddr *)&my_addr, &len);
3009 content_length = prepare_sdp_description(stream, &content, my_addr.sin_addr);
3010 if (content_length < 0) {
3011 rtsp_reply_error(c, RTSP_STATUS_INTERNAL);
3014 rtsp_reply_header(c, RTSP_STATUS_OK);
3015 avio_printf(c->pb, "Content-Base: %s/\r\n", url);
3016 avio_printf(c->pb, "Content-Type: application/sdp\r\n");
3017 avio_printf(c->pb, "Content-Length: %d\r\n", content_length);
3018 avio_printf(c->pb, "\r\n");
3019 avio_write(c->pb, content, content_length);
3023 static HTTPContext *find_rtp_session(const char *session_id)
3027 if (session_id[0] == '\0')
3030 for(c = first_http_ctx; c != NULL; c = c->next) {
3031 if (!strcmp(c->session_id, session_id))
3037 static RTSPTransportField *find_transport(RTSPMessageHeader *h, enum RTSPLowerTransport lower_transport)
3039 RTSPTransportField *th;
3042 for(i=0;i<h->nb_transports;i++) {
3043 th = &h->transports[i];
3044 if (th->lower_transport == lower_transport)
3050 static void rtsp_cmd_setup(HTTPContext *c, const char *url,
3051 RTSPMessageHeader *h)
3054 int stream_index, rtp_port, rtcp_port;
3059 RTSPTransportField *th;
3060 struct sockaddr_in dest_addr;
3061 RTSPActionServerSetup setup;
3063 /* find which url is asked */
3064 av_url_split(NULL, 0, NULL, 0, NULL, 0, NULL, path1, sizeof(path1), url);
3069 /* now check each stream */
3070 for(stream = first_stream; stream != NULL; stream = stream->next) {
3071 if (!stream->is_feed &&
3072 stream->fmt && !strcmp(stream->fmt->name, "rtp")) {
3073 /* accept aggregate filenames only if single stream */
3074 if (!strcmp(path, stream->filename)) {
3075 if (stream->nb_streams != 1) {
3076 rtsp_reply_error(c, RTSP_STATUS_AGGREGATE);
3083 for(stream_index = 0; stream_index < stream->nb_streams;
3085 snprintf(buf, sizeof(buf), "%s/streamid=%d",
3086 stream->filename, stream_index);
3087 if (!strcmp(path, buf))
3092 /* no stream found */
3093 rtsp_reply_error(c, RTSP_STATUS_SERVICE); /* XXX: right error ? */
3097 /* generate session id if needed */
3098 if (h->session_id[0] == '\0')
3099 snprintf(h->session_id, sizeof(h->session_id), "%08x%08x",
3100 av_lfg_get(&random_state), av_lfg_get(&random_state));
3102 /* find rtp session, and create it if none found */
3103 rtp_c = find_rtp_session(h->session_id);
3105 /* always prefer UDP */
3106 th = find_transport(h, RTSP_LOWER_TRANSPORT_UDP);
3108 th = find_transport(h, RTSP_LOWER_TRANSPORT_TCP);
3110 rtsp_reply_error(c, RTSP_STATUS_TRANSPORT);
3115 rtp_c = rtp_new_connection(&c->from_addr, stream, h->session_id,
3116 th->lower_transport);
3118 rtsp_reply_error(c, RTSP_STATUS_BANDWIDTH);
3122 /* open input stream */
3123 if (open_input_stream(rtp_c, "") < 0) {
3124 rtsp_reply_error(c, RTSP_STATUS_INTERNAL);
3129 /* test if stream is OK (test needed because several SETUP needs
3130 to be done for a given file) */
3131 if (rtp_c->stream != stream) {
3132 rtsp_reply_error(c, RTSP_STATUS_SERVICE);
3136 /* test if stream is already set up */
3137 if (rtp_c->rtp_ctx[stream_index]) {
3138 rtsp_reply_error(c, RTSP_STATUS_STATE);
3142 /* check transport */
3143 th = find_transport(h, rtp_c->rtp_protocol);
3144 if (!th || (th->lower_transport == RTSP_LOWER_TRANSPORT_UDP &&
3145 th->client_port_min <= 0)) {
3146 rtsp_reply_error(c, RTSP_STATUS_TRANSPORT);
3150 /* setup default options */
3151 setup.transport_option[0] = '\0';
3152 dest_addr = rtp_c->from_addr;
3153 dest_addr.sin_port = htons(th->client_port_min);
3156 if (rtp_new_av_stream(rtp_c, stream_index, &dest_addr, c) < 0) {
3157 rtsp_reply_error(c, RTSP_STATUS_TRANSPORT);
3161 /* now everything is OK, so we can send the connection parameters */
3162 rtsp_reply_header(c, RTSP_STATUS_OK);
3164 avio_printf(c->pb, "Session: %s\r\n", rtp_c->session_id);
3166 switch(rtp_c->rtp_protocol) {
3167 case RTSP_LOWER_TRANSPORT_UDP:
3168 rtp_port = rtp_get_local_rtp_port(rtp_c->rtp_handles[stream_index]);
3169 rtcp_port = rtp_get_local_rtcp_port(rtp_c->rtp_handles[stream_index]);
3170 avio_printf(c->pb, "Transport: RTP/AVP/UDP;unicast;"
3171 "client_port=%d-%d;server_port=%d-%d",
3172 th->client_port_min, th->client_port_max,
3173 rtp_port, rtcp_port);
3175 case RTSP_LOWER_TRANSPORT_TCP:
3176 avio_printf(c->pb, "Transport: RTP/AVP/TCP;interleaved=%d-%d",
3177 stream_index * 2, stream_index * 2 + 1);
3182 if (setup.transport_option[0] != '\0')
3183 avio_printf(c->pb, ";%s", setup.transport_option);
3184 avio_printf(c->pb, "\r\n");
3187 avio_printf(c->pb, "\r\n");
3191 /* find an rtp connection by using the session ID. Check consistency
3193 static HTTPContext *find_rtp_session_with_url(const char *url,
3194 const char *session_id)
3202 rtp_c = find_rtp_session(session_id);
3206 /* find which url is asked */
3207 av_url_split(NULL, 0, NULL, 0, NULL, 0, NULL, path1, sizeof(path1), url);
3211 if(!strcmp(path, rtp_c->stream->filename)) return rtp_c;
3212 for(s=0; s<rtp_c->stream->nb_streams; ++s) {
3213 snprintf(buf, sizeof(buf), "%s/streamid=%d",
3214 rtp_c->stream->filename, s);
3215 if(!strncmp(path, buf, sizeof(buf))) {
3216 // XXX: Should we reply with RTSP_STATUS_ONLY_AGGREGATE if nb_streams>1?
3221 if (len > 0 && path[len - 1] == '/' &&
3222 !strncmp(path, rtp_c->stream->filename, len - 1))
3227 static void rtsp_cmd_play(HTTPContext *c, const char *url, RTSPMessageHeader *h)
3231 rtp_c = find_rtp_session_with_url(url, h->session_id);
3233 rtsp_reply_error(c, RTSP_STATUS_SESSION);
3237 if (rtp_c->state != HTTPSTATE_SEND_DATA &&
3238 rtp_c->state != HTTPSTATE_WAIT_FEED &&
3239 rtp_c->state != HTTPSTATE_READY) {
3240 rtsp_reply_error(c, RTSP_STATUS_STATE);
3244 rtp_c->state = HTTPSTATE_SEND_DATA;
3246 /* now everything is OK, so we can send the connection parameters */
3247 rtsp_reply_header(c, RTSP_STATUS_OK);
3249 avio_printf(c->pb, "Session: %s\r\n", rtp_c->session_id);
3250 avio_printf(c->pb, "\r\n");
3253 static void rtsp_cmd_pause(HTTPContext *c, const char *url, RTSPMessageHeader *h)
3257 rtp_c = find_rtp_session_with_url(url, h->session_id);
3259 rtsp_reply_error(c, RTSP_STATUS_SESSION);
3263 if (rtp_c->state != HTTPSTATE_SEND_DATA &&
3264 rtp_c->state != HTTPSTATE_WAIT_FEED) {
3265 rtsp_reply_error(c, RTSP_STATUS_STATE);
3269 rtp_c->state = HTTPSTATE_READY;
3270 rtp_c->first_pts = AV_NOPTS_VALUE;
3271 /* now everything is OK, so we can send the connection parameters */
3272 rtsp_reply_header(c, RTSP_STATUS_OK);
3274 avio_printf(c->pb, "Session: %s\r\n", rtp_c->session_id);
3275 avio_printf(c->pb, "\r\n");
3278 static void rtsp_cmd_teardown(HTTPContext *c, const char *url, RTSPMessageHeader *h)
3282 rtp_c = find_rtp_session_with_url(url, h->session_id);
3284 rtsp_reply_error(c, RTSP_STATUS_SESSION);
3288 /* now everything is OK, so we can send the connection parameters */
3289 rtsp_reply_header(c, RTSP_STATUS_OK);
3291 avio_printf(c->pb, "Session: %s\r\n", rtp_c->session_id);
3292 avio_printf(c->pb, "\r\n");
3294 /* abort the session */
3295 close_connection(rtp_c);
3299 /********************************************************************/
3302 static HTTPContext *rtp_new_connection(struct sockaddr_in *from_addr,
3303 FFStream *stream, const char *session_id,
3304 enum RTSPLowerTransport rtp_protocol)
3306 HTTPContext *c = NULL;
3307 const char *proto_str;
3309 /* XXX: should output a warning page when coming
3310 close to the connection limit */
3311 if (nb_connections >= nb_max_connections)
3314 /* add a new connection */
3315 c = av_mallocz(sizeof(HTTPContext));
3320 c->poll_entry = NULL;
3321 c->from_addr = *from_addr;
3322 c->buffer_size = IOBUFFER_INIT_SIZE;
3323 c->buffer = av_malloc(c->buffer_size);
3328 av_strlcpy(c->session_id, session_id, sizeof(c->session_id));
3329 c->state = HTTPSTATE_READY;
3330 c->is_packetized = 1;
3331 c->rtp_protocol = rtp_protocol;
3333 /* protocol is shown in statistics */
3334 switch(c->rtp_protocol) {
3335 case RTSP_LOWER_TRANSPORT_UDP_MULTICAST:
3336 proto_str = "MCAST";
3338 case RTSP_LOWER_TRANSPORT_UDP:
3341 case RTSP_LOWER_TRANSPORT_TCP:
3348 av_strlcpy(c->protocol, "RTP/", sizeof(c->protocol));
3349 av_strlcat(c->protocol, proto_str, sizeof(c->protocol));
3351 current_bandwidth += stream->bandwidth;
3353 c->next = first_http_ctx;
3365 /* add a new RTP stream in an RTP connection (used in RTSP SETUP
3366 command). If RTP/TCP protocol is used, TCP connection 'rtsp_c' is
3368 static int rtp_new_av_stream(HTTPContext *c,
3369 int stream_index, struct sockaddr_in *dest_addr,
3370 HTTPContext *rtsp_c)
3372 AVFormatContext *ctx;
3375 URLContext *h = NULL;
3377 int max_packet_size;
3379 /* now we can open the relevant output stream */
3380 ctx = avformat_alloc_context();
3383 ctx->oformat = av_guess_format("rtp", NULL, NULL);
3385 st = av_mallocz(sizeof(AVStream));
3388 ctx->nb_streams = 1;
3389 ctx->streams = av_mallocz(sizeof(AVStream *) * ctx->nb_streams);
3392 ctx->streams[0] = st;
3394 if (!c->stream->feed ||
3395 c->stream->feed == c->stream)
3396 memcpy(st, c->stream->streams[stream_index], sizeof(AVStream));
3399 c->stream->feed->streams[c->stream->feed_streams[stream_index]],
3401 st->priv_data = NULL;
3403 /* build destination RTP address */
3404 ipaddr = inet_ntoa(dest_addr->sin_addr);
3406 switch(c->rtp_protocol) {
3407 case RTSP_LOWER_TRANSPORT_UDP:
3408 case RTSP_LOWER_TRANSPORT_UDP_MULTICAST:
3411 /* XXX: also pass as parameter to function ? */
3412 if (c->stream->is_multicast) {
3414 ttl = c->stream->multicast_ttl;
3417 snprintf(ctx->filename, sizeof(ctx->filename),
3418 "rtp://%s:%d?multicast=1&ttl=%d",
3419 ipaddr, ntohs(dest_addr->sin_port), ttl);
3421 snprintf(ctx->filename, sizeof(ctx->filename),
3422 "rtp://%s:%d", ipaddr, ntohs(dest_addr->sin_port));
3425 if (url_open(&h, ctx->filename, AVIO_FLAG_WRITE) < 0)
3427 c->rtp_handles[stream_index] = h;
3428 max_packet_size = url_get_max_packet_size(h);
3430 case RTSP_LOWER_TRANSPORT_TCP:
3433 max_packet_size = RTSP_TCP_MAX_PACKET_SIZE;
3439 http_log("%s:%d - - \"PLAY %s/streamid=%d %s\"\n",
3440 ipaddr, ntohs(dest_addr->sin_port),
3441 c->stream->filename, stream_index, c->protocol);
3443 /* normally, no packets should be output here, but the packet size may be checked */
3444 if (ffio_open_dyn_packet_buf(&ctx->pb, max_packet_size) < 0) {
3445 /* XXX: close stream */
3448 if (avformat_write_header(ctx, NULL) < 0) {
3455 avio_close_dyn_buf(ctx->pb, &dummy_buf);
3458 c->rtp_ctx[stream_index] = ctx;
3462 /********************************************************************/
3463 /* ffserver initialization */
3465 static AVStream *add_av_stream1(FFStream *stream, AVCodecContext *codec, int copy)
3469 fst = av_mallocz(sizeof(AVStream));
3473 fst->codec= avcodec_alloc_context();
3474 memcpy(fst->codec, codec, sizeof(AVCodecContext));
3475 if (codec->extradata_size) {
3476 fst->codec->extradata = av_malloc(codec->extradata_size);
3477 memcpy(fst->codec->extradata, codec->extradata,
3478 codec->extradata_size);
3481 /* live streams must use the actual feed's codec since it may be
3482 * updated later to carry extradata needed by the streams.
3486 fst->priv_data = av_mallocz(sizeof(FeedData));
3487 fst->index = stream->nb_streams;
3488 av_set_pts_info(fst, 33, 1, 90000);
3489 fst->sample_aspect_ratio = codec->sample_aspect_ratio;
3490 stream->streams[stream->nb_streams++] = fst;
3494 /* return the stream number in the feed */
3495 static int add_av_stream(FFStream *feed, AVStream *st)
3498 AVCodecContext *av, *av1;
3502 for(i=0;i<feed->nb_streams;i++) {
3503 st = feed->streams[i];
3505 if (av1->codec_id == av->codec_id &&
3506 av1->codec_type == av->codec_type &&
3507 av1->bit_rate == av->bit_rate) {
3509 switch(av->codec_type) {
3510 case AVMEDIA_TYPE_AUDIO:
3511 if (av1->channels == av->channels &&
3512 av1->sample_rate == av->sample_rate)
3515 case AVMEDIA_TYPE_VIDEO:
3516 if (av1->width == av->width &&
3517 av1->height == av->height &&
3518 av1->time_base.den == av->time_base.den &&
3519 av1->time_base.num == av->time_base.num &&
3520 av1->gop_size == av->gop_size)
3529 fst = add_av_stream1(feed, av, 0);
3532 return feed->nb_streams - 1;
3537 static void remove_stream(FFStream *stream)
3541 while (*ps != NULL) {
3549 /* specific mpeg4 handling : we extract the raw parameters */
3550 static void extract_mpeg4_header(AVFormatContext *infile)
3552 int mpeg4_count, i, size;
3558 for(i=0;i<infile->nb_streams;i++) {
3559 st = infile->streams[i];
3560 if (st->codec->codec_id == CODEC_ID_MPEG4 &&
3561 st->codec->extradata_size == 0) {
3568 printf("MPEG4 without extra data: trying to find header in %s\n", infile->filename);
3569 while (mpeg4_count > 0) {
3570 if (av_read_packet(infile, &pkt) < 0)
3572 st = infile->streams[pkt.stream_index];
3573 if (st->codec->codec_id == CODEC_ID_MPEG4 &&
3574 st->codec->extradata_size == 0) {
3575 av_freep(&st->codec->extradata);
3576 /* fill extradata with the header */
3577 /* XXX: we make hard suppositions here ! */
3579 while (p < pkt.data + pkt.size - 4) {
3580 /* stop when vop header is found */
3581 if (p[0] == 0x00 && p[1] == 0x00 &&
3582 p[2] == 0x01 && p[3] == 0xb6) {
3583 size = p - pkt.data;
3584 // av_hex_dump_log(infile, AV_LOG_DEBUG, pkt.data, size);
3585 st->codec->extradata = av_malloc(size);
3586 st->codec->extradata_size = size;
3587 memcpy(st->codec->extradata, pkt.data, size);
3594 av_free_packet(&pkt);
3598 /* compute the needed AVStream for each file */
3599 static void build_file_streams(void)
3601 FFStream *stream, *stream_next;
3604 /* gather all streams */
3605 for(stream = first_stream; stream != NULL; stream = stream_next) {
3606 AVFormatContext *infile = NULL;
3607 stream_next = stream->next;
3608 if (stream->stream_type == STREAM_TYPE_LIVE &&
3610 /* the stream comes from a file */
3611 /* try to open the file */
3613 if (stream->fmt && !strcmp(stream->fmt->name, "rtp")) {
3614 /* specific case : if transport stream output to RTP,
3615 we use a raw transport stream reader */
3616 av_dict_set(&stream->in_opts, "mpeg2ts_compute_pcr", "1", 0);
3619 http_log("Opening file '%s'\n", stream->feed_filename);
3620 if ((ret = avformat_open_input(&infile, stream->feed_filename, stream->ifmt, &stream->in_opts)) < 0) {
3621 http_log("Could not open '%s': %d\n", stream->feed_filename, ret);
3622 /* remove stream (no need to spend more time on it) */
3624 remove_stream(stream);
3626 /* find all the AVStreams inside and reference them in
3628 if (av_find_stream_info(infile) < 0) {
3629 http_log("Could not find codec parameters from '%s'\n",
3630 stream->feed_filename);
3631 av_close_input_file(infile);
3634 extract_mpeg4_header(infile);
3636 for(i=0;i<infile->nb_streams;i++)
3637 add_av_stream1(stream, infile->streams[i]->codec, 1);
3639 av_close_input_file(infile);
3645 /* compute the needed AVStream for each feed */
3646 static void build_feed_streams(void)
3648 FFStream *stream, *feed;
3651 /* gather all streams */
3652 for(stream = first_stream; stream != NULL; stream = stream->next) {
3653 feed = stream->feed;
3655 if (!stream->is_feed) {
3656 /* we handle a stream coming from a feed */
3657 for(i=0;i<stream->nb_streams;i++)
3658 stream->feed_streams[i] = add_av_stream(feed, stream->streams[i]);
3663 /* gather all streams */
3664 for(stream = first_stream; stream != NULL; stream = stream->next) {
3665 feed = stream->feed;
3667 if (stream->is_feed) {
3668 for(i=0;i<stream->nb_streams;i++)
3669 stream->feed_streams[i] = i;
3674 /* create feed files if needed */
3675 for(feed = first_feed; feed != NULL; feed = feed->next_feed) {
3678 if (avio_check(feed->feed_filename, AVIO_FLAG_READ) > 0) {
3679 /* See if it matches */
3680 AVFormatContext *s = NULL;
3683 if (avformat_open_input(&s, feed->feed_filename, NULL, NULL) >= 0) {
3684 /* Now see if it matches */
3685 if (s->nb_streams == feed->nb_streams) {
3687 for(i=0;i<s->nb_streams;i++) {
3689 sf = feed->streams[i];
3692 if (sf->index != ss->index ||
3694 http_log("Index & Id do not match for stream %d (%s)\n",
3695 i, feed->feed_filename);
3698 AVCodecContext *ccf, *ccs;
3702 #define CHECK_CODEC(x) (ccf->x != ccs->x)
3704 if (CHECK_CODEC(codec_id) || CHECK_CODEC(codec_type)) {
3705 http_log("Codecs do not match for stream %d\n", i);
3707 } else if (CHECK_CODEC(bit_rate) || CHECK_CODEC(flags)) {
3708 http_log("Codec bitrates do not match for stream %d\n", i);
3710 } else if (ccf->codec_type == AVMEDIA_TYPE_VIDEO) {
3711 if (CHECK_CODEC(time_base.den) ||
3712 CHECK_CODEC(time_base.num) ||
3713 CHECK_CODEC(width) ||
3714 CHECK_CODEC(height)) {
3715 http_log("Codec width, height and framerate do not match for stream %d\n", i);
3718 } else if (ccf->codec_type == AVMEDIA_TYPE_AUDIO) {
3719 if (CHECK_CODEC(sample_rate) ||
3720 CHECK_CODEC(channels) ||
3721 CHECK_CODEC(frame_size)) {
3722 http_log("Codec sample_rate, channels, frame_size do not match for stream %d\n", i);
3726 http_log("Unknown codec type\n");
3734 http_log("Deleting feed file '%s' as stream counts differ (%d != %d)\n",
3735 feed->feed_filename, s->nb_streams, feed->nb_streams);
3737 av_close_input_file(s);
3739 http_log("Deleting feed file '%s' as it appears to be corrupt\n",
3740 feed->feed_filename);
3743 if (feed->readonly) {
3744 http_log("Unable to delete feed file '%s' as it is marked readonly\n",
3745 feed->feed_filename);
3748 unlink(feed->feed_filename);
3751 if (avio_check(feed->feed_filename, AVIO_FLAG_WRITE) <= 0) {
3752 AVFormatContext s1 = {0}, *s = &s1;
3754 if (feed->readonly) {
3755 http_log("Unable to create feed file '%s' as it is marked readonly\n",
3756 feed->feed_filename);
3760 /* only write the header of the ffm file */
3761 if (avio_open(&s->pb, feed->feed_filename, AVIO_FLAG_WRITE) < 0) {
3762 http_log("Could not open output feed file '%s'\n",
3763 feed->feed_filename);
3766 s->oformat = feed->fmt;
3767 s->nb_streams = feed->nb_streams;
3768 s->streams = feed->streams;
3769 if (avformat_write_header(s, NULL) < 0) {
3770 http_log("Container doesn't supports the required parameters\n");
3773 /* XXX: need better api */
3774 av_freep(&s->priv_data);
3777 /* get feed size and write index */
3778 fd = open(feed->feed_filename, O_RDONLY);
3780 http_log("Could not open output feed file '%s'\n",
3781 feed->feed_filename);
3785 feed->feed_write_index = FFMAX(ffm_read_write_index(fd), FFM_PACKET_SIZE);
3786 feed->feed_size = lseek(fd, 0, SEEK_END);
3787 /* ensure that we do not wrap before the end of file */
3788 if (feed->feed_max_size && feed->feed_max_size < feed->feed_size)
3789 feed->feed_max_size = feed->feed_size;
3795 /* compute the bandwidth used by each stream */
3796 static void compute_bandwidth(void)
3802 for(stream = first_stream; stream != NULL; stream = stream->next) {
3804 for(i=0;i<stream->nb_streams;i++) {
3805 AVStream *st = stream->streams[i];
3806 switch(st->codec->codec_type) {
3807 case AVMEDIA_TYPE_AUDIO:
3808 case AVMEDIA_TYPE_VIDEO:
3809 bandwidth += st->codec->bit_rate;
3815 stream->bandwidth = (bandwidth + 999) / 1000;
3819 /* add a codec and set the default parameters */
3820 static void add_codec(FFStream *stream, AVCodecContext *av)
3824 /* compute default parameters */
3825 switch(av->codec_type) {
3826 case AVMEDIA_TYPE_AUDIO:
3827 if (av->bit_rate == 0)
3828 av->bit_rate = 64000;
3829 if (av->sample_rate == 0)
3830 av->sample_rate = 22050;
3831 if (av->channels == 0)
3834 case AVMEDIA_TYPE_VIDEO:
3835 if (av->bit_rate == 0)
3836 av->bit_rate = 64000;
3837 if (av->time_base.num == 0){
3838 av->time_base.den = 5;
3839 av->time_base.num = 1;
3841 if (av->width == 0 || av->height == 0) {
3845 /* Bitrate tolerance is less for streaming */
3846 if (av->bit_rate_tolerance == 0)
3847 av->bit_rate_tolerance = FFMAX(av->bit_rate / 4,
3848 (int64_t)av->bit_rate*av->time_base.num/av->time_base.den);
3853 if (av->max_qdiff == 0)
3855 av->qcompress = 0.5;
3858 if (!av->nsse_weight)
3859 av->nsse_weight = 8;
3861 av->frame_skip_cmp = FF_CMP_DCTMAX;
3863 av->me_method = ME_EPZS;
3864 av->rc_buffer_aggressivity = 1.0;
3867 av->rc_eq = "tex^qComp";
3868 if (!av->i_quant_factor)
3869 av->i_quant_factor = -0.8;
3870 if (!av->b_quant_factor)
3871 av->b_quant_factor = 1.25;
3872 if (!av->b_quant_offset)
3873 av->b_quant_offset = 1.25;
3874 if (!av->rc_max_rate)
3875 av->rc_max_rate = av->bit_rate * 2;
3877 if (av->rc_max_rate && !av->rc_buffer_size) {
3878 av->rc_buffer_size = av->rc_max_rate;
3887 st = av_mallocz(sizeof(AVStream));
3890 st->codec = avcodec_alloc_context();
3891 stream->streams[stream->nb_streams++] = st;
3892 memcpy(st->codec, av, sizeof(AVCodecContext));
3895 static enum CodecID opt_audio_codec(const char *arg)
3897 AVCodec *p= avcodec_find_encoder_by_name(arg);
3899 if (p == NULL || p->type != AVMEDIA_TYPE_AUDIO)
3900 return CODEC_ID_NONE;
3905 static enum CodecID opt_video_codec(const char *arg)
3907 AVCodec *p= avcodec_find_encoder_by_name(arg);
3909 if (p == NULL || p->type != AVMEDIA_TYPE_VIDEO)
3910 return CODEC_ID_NONE;
3915 /* simplistic plugin support */
3918 static void load_module(const char *filename)
3921 void (*init_func)(void);
3922 dll = dlopen(filename, RTLD_NOW);
3924 fprintf(stderr, "Could not load module '%s' - %s\n",
3925 filename, dlerror());
3929 init_func = dlsym(dll, "ffserver_module_init");
3932 "%s: init function 'ffserver_module_init()' not found\n",
3941 static int ffserver_opt_default(const char *opt, const char *arg,
3942 AVCodecContext *avctx, int type)
3945 const AVOption *o = av_opt_find(avctx, opt, NULL, type, 0);
3947 ret = av_set_string3(avctx, opt, arg, 1, NULL);
3951 static int ffserver_opt_preset(const char *arg,
3952 AVCodecContext *avctx, int type,
3953 enum CodecID *audio_id, enum CodecID *video_id)
3956 char filename[1000], tmp[1000], tmp2[1000], line[1000];
3958 AVCodec *codec = avcodec_find_encoder(avctx->codec_id);
3960 if (!(f = get_preset_file(filename, sizeof(filename), arg, 0,
3961 codec ? codec->name : NULL))) {
3962 fprintf(stderr, "File for preset '%s' not found\n", arg);
3967 int e= fscanf(f, "%999[^\n]\n", line) - 1;
3968 if(line[0] == '#' && !e)
3970 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
3972 fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
3976 if(!strcmp(tmp, "acodec")){
3977 *audio_id = opt_audio_codec(tmp2);
3978 }else if(!strcmp(tmp, "vcodec")){
3979 *video_id = opt_video_codec(tmp2);
3980 }else if(!strcmp(tmp, "scodec")){
3981 /* opt_subtitle_codec(tmp2); */
3982 }else if(ffserver_opt_default(tmp, tmp2, avctx, type) < 0){
3983 fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
3994 static AVOutputFormat *ffserver_guess_format(const char *short_name, const char *filename,
3995 const char *mime_type)
3997 AVOutputFormat *fmt = av_guess_format(short_name, filename, mime_type);
4000 AVOutputFormat *stream_fmt;
4001 char stream_format_name[64];
4003 snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
4004 stream_fmt = av_guess_format(stream_format_name, NULL, NULL);
4013 static void report_config_error(const char *filename, int line_num, int *errors, const char *fmt, ...)
4017 fprintf(stderr, "%s:%d: ", filename, line_num);
4018 vfprintf(stderr, fmt, vl);
4024 static int parse_ffconfig(const char *filename)
4031 int val, errors, line_num;
4032 FFStream **last_stream, *stream, *redirect;
4033 FFStream **last_feed, *feed, *s;
4034 AVCodecContext audio_enc, video_enc;
4035 enum CodecID audio_id, video_id;
4037 f = fopen(filename, "r");
4045 first_stream = NULL;
4046 last_stream = &first_stream;
4048 last_feed = &first_feed;
4052 audio_id = CODEC_ID_NONE;
4053 video_id = CODEC_ID_NONE;
4055 #define ERROR(...) report_config_error(filename, line_num, &errors, __VA_ARGS__)
4057 if (fgets(line, sizeof(line), f) == NULL)
4063 if (*p == '\0' || *p == '#')
4066 get_arg(cmd, sizeof(cmd), &p);
4068 if (!strcasecmp(cmd, "Port")) {
4069 get_arg(arg, sizeof(arg), &p);
4071 if (val < 1 || val > 65536) {
4072 ERROR("Invalid_port: %s\n", arg);
4074 my_http_addr.sin_port = htons(val);
4075 } else if (!strcasecmp(cmd, "BindAddress")) {
4076 get_arg(arg, sizeof(arg), &p);
4077 if (resolve_host(&my_http_addr.sin_addr, arg) != 0) {
4078 ERROR("%s:%d: Invalid host/IP address: %s\n", arg);
4080 } else if (!strcasecmp(cmd, "NoDaemon")) {
4081 ffserver_daemon = 0;
4082 } else if (!strcasecmp(cmd, "RTSPPort")) {
4083 get_arg(arg, sizeof(arg), &p);
4085 if (val < 1 || val > 65536) {
4086 ERROR("%s:%d: Invalid port: %s\n", arg);
4088 my_rtsp_addr.sin_port = htons(atoi(arg));
4089 } else if (!strcasecmp(cmd, "RTSPBindAddress")) {
4090 get_arg(arg, sizeof(arg), &p);
4091 if (resolve_host(&my_rtsp_addr.sin_addr, arg) != 0) {
4092 ERROR("Invalid host/IP address: %s\n", arg);
4094 } else if (!strcasecmp(cmd, "MaxHTTPConnections")) {
4095 get_arg(arg, sizeof(arg), &p);
4097 if (val < 1 || val > 65536) {
4098 ERROR("Invalid MaxHTTPConnections: %s\n", arg);
4100 nb_max_http_connections = val;
4101 } else if (!strcasecmp(cmd, "MaxClients")) {
4102 get_arg(arg, sizeof(arg), &p);
4104 if (val < 1 || val > nb_max_http_connections) {
4105 ERROR("Invalid MaxClients: %s\n", arg);
4107 nb_max_connections = val;
4109 } else if (!strcasecmp(cmd, "MaxBandwidth")) {
4111 get_arg(arg, sizeof(arg), &p);
4113 if (llval < 10 || llval > 10000000) {
4114 ERROR("Invalid MaxBandwidth: %s\n", arg);
4116 max_bandwidth = llval;
4117 } else if (!strcasecmp(cmd, "CustomLog")) {
4118 if (!ffserver_debug)
4119 get_arg(logfilename, sizeof(logfilename), &p);
4120 } else if (!strcasecmp(cmd, "<Feed")) {
4121 /*********************************************/
4122 /* Feed related options */
4124 if (stream || feed) {
4125 ERROR("Already in a tag\n");
4127 feed = av_mallocz(sizeof(FFStream));
4128 get_arg(feed->filename, sizeof(feed->filename), &p);
4129 q = strrchr(feed->filename, '>');
4133 for (s = first_feed; s; s = s->next) {
4134 if (!strcmp(feed->filename, s->filename)) {
4135 ERROR("Feed '%s' already registered\n", s->filename);
4139 feed->fmt = av_guess_format("ffm", NULL, NULL);
4140 /* defaut feed file */
4141 snprintf(feed->feed_filename, sizeof(feed->feed_filename),
4142 "/tmp/%s.ffm", feed->filename);
4143 feed->feed_max_size = 5 * 1024 * 1024;
4145 feed->feed = feed; /* self feeding :-) */
4147 /* add in stream list */
4148 *last_stream = feed;
4149 last_stream = &feed->next;
4150 /* add in feed list */
4152 last_feed = &feed->next_feed;
4154 } else if (!strcasecmp(cmd, "Launch")) {
4158 feed->child_argv = av_mallocz(64 * sizeof(char *));
4160 for (i = 0; i < 62; i++) {
4161 get_arg(arg, sizeof(arg), &p);
4165 feed->child_argv[i] = av_strdup(arg);
4168 feed->child_argv[i] = av_malloc(30 + strlen(feed->filename));
4170 snprintf(feed->child_argv[i], 30+strlen(feed->filename),
4172 (my_http_addr.sin_addr.s_addr == INADDR_ANY) ? "127.0.0.1" :
4173 inet_ntoa(my_http_addr.sin_addr),
4174 ntohs(my_http_addr.sin_port), feed->filename);
4176 } else if (!strcasecmp(cmd, "ReadOnlyFile")) {
4178 get_arg(feed->feed_filename, sizeof(feed->feed_filename), &p);
4180 } else if (stream) {
4181 get_arg(stream->feed_filename, sizeof(stream->feed_filename), &p);
4183 } else if (!strcasecmp(cmd, "File")) {
4185 get_arg(feed->feed_filename, sizeof(feed->feed_filename), &p);
4187 get_arg(stream->feed_filename, sizeof(stream->feed_filename), &p);
4188 } else if (!strcasecmp(cmd, "Truncate")) {
4190 get_arg(arg, sizeof(arg), &p);
4191 feed->truncate = strtod(arg, NULL);
4193 } else if (!strcasecmp(cmd, "FileMaxSize")) {
4198 get_arg(arg, sizeof(arg), &p);
4200 fsize = strtod(p1, &p1);
4201 switch(toupper(*p1)) {
4206 fsize *= 1024 * 1024;
4209 fsize *= 1024 * 1024 * 1024;
4212 feed->feed_max_size = (int64_t)fsize;
4213 if (feed->feed_max_size < FFM_PACKET_SIZE*4) {
4214 ERROR("Feed max file size is too small, must be at least %d\n", FFM_PACKET_SIZE*4);
4217 } else if (!strcasecmp(cmd, "</Feed>")) {
4219 ERROR("No corresponding <Feed> for </Feed>\n");
4222 } else if (!strcasecmp(cmd, "<Stream")) {
4223 /*********************************************/
4224 /* Stream related options */
4226 if (stream || feed) {
4227 ERROR("Already in a tag\n");
4230 stream = av_mallocz(sizeof(FFStream));
4231 get_arg(stream->filename, sizeof(stream->filename), &p);
4232 q = strrchr(stream->filename, '>');
4236 for (s = first_stream; s; s = s->next) {
4237 if (!strcmp(stream->filename, s->filename)) {
4238 ERROR("Stream '%s' already registered\n", s->filename);
4242 stream->fmt = ffserver_guess_format(NULL, stream->filename, NULL);
4243 avcodec_get_context_defaults2(&video_enc, AVMEDIA_TYPE_VIDEO);
4244 avcodec_get_context_defaults2(&audio_enc, AVMEDIA_TYPE_AUDIO);
4245 audio_id = CODEC_ID_NONE;
4246 video_id = CODEC_ID_NONE;
4248 audio_id = stream->fmt->audio_codec;
4249 video_id = stream->fmt->video_codec;
4252 *last_stream = stream;
4253 last_stream = &stream->next;
4255 } else if (!strcasecmp(cmd, "Feed")) {
4256 get_arg(arg, sizeof(arg), &p);
4261 while (sfeed != NULL) {
4262 if (!strcmp(sfeed->filename, arg))
4264 sfeed = sfeed->next_feed;
4267 ERROR("feed '%s' not defined\n", arg);
4269 stream->feed = sfeed;
4271 } else if (!strcasecmp(cmd, "Format")) {
4272 get_arg(arg, sizeof(arg), &p);
4274 if (!strcmp(arg, "status")) {
4275 stream->stream_type = STREAM_TYPE_STATUS;
4278 stream->stream_type = STREAM_TYPE_LIVE;
4279 /* jpeg cannot be used here, so use single frame jpeg */
4280 if (!strcmp(arg, "jpeg"))
4281 strcpy(arg, "mjpeg");
4282 stream->fmt = ffserver_guess_format(arg, NULL, NULL);
4284 ERROR("Unknown Format: %s\n", arg);
4288 audio_id = stream->fmt->audio_codec;
4289 video_id = stream->fmt->video_codec;
4292 } else if (!strcasecmp(cmd, "InputFormat")) {
4293 get_arg(arg, sizeof(arg), &p);
4295 stream->ifmt = av_find_input_format(arg);
4296 if (!stream->ifmt) {
4297 ERROR("Unknown input format: %s\n", arg);
4300 } else if (!strcasecmp(cmd, "FaviconURL")) {
4301 if (stream && stream->stream_type == STREAM_TYPE_STATUS) {
4302 get_arg(stream->feed_filename, sizeof(stream->feed_filename), &p);
4304 ERROR("FaviconURL only permitted for status streams\n");
4306 } else if (!strcasecmp(cmd, "Author")) {
4308 get_arg(stream->author, sizeof(stream->author), &p);
4309 } else if (!strcasecmp(cmd, "Comment")) {
4311 get_arg(stream->comment, sizeof(stream->comment), &p);
4312 } else if (!strcasecmp(cmd, "Copyright")) {
4314 get_arg(stream->copyright, sizeof(stream->copyright), &p);
4315 } else if (!strcasecmp(cmd, "Title")) {
4317 get_arg(stream->title, sizeof(stream->title), &p);
4318 } else if (!strcasecmp(cmd, "Preroll")) {
4319 get_arg(arg, sizeof(arg), &p);
4321 stream->prebuffer = atof(arg) * 1000;
4322 } else if (!strcasecmp(cmd, "StartSendOnKey")) {
4324 stream->send_on_key = 1;
4325 } else if (!strcasecmp(cmd, "AudioCodec")) {
4326 get_arg(arg, sizeof(arg), &p);
4327 audio_id = opt_audio_codec(arg);
4328 if (audio_id == CODEC_ID_NONE) {
4329 ERROR("Unknown AudioCodec: %s\n", arg);
4331 } else if (!strcasecmp(cmd, "VideoCodec")) {
4332 get_arg(arg, sizeof(arg), &p);
4333 video_id = opt_video_codec(arg);
4334 if (video_id == CODEC_ID_NONE) {
4335 ERROR("Unknown VideoCodec: %s\n", arg);
4337 } else if (!strcasecmp(cmd, "MaxTime")) {
4338 get_arg(arg, sizeof(arg), &p);
4340 stream->max_time = atof(arg) * 1000;
4341 } else if (!strcasecmp(cmd, "AudioBitRate")) {
4342 get_arg(arg, sizeof(arg), &p);
4344 audio_enc.bit_rate = lrintf(atof(arg) * 1000);
4345 } else if (!strcasecmp(cmd, "AudioChannels")) {
4346 get_arg(arg, sizeof(arg), &p);
4348 audio_enc.channels = atoi(arg);
4349 } else if (!strcasecmp(cmd, "AudioSampleRate")) {
4350 get_arg(arg, sizeof(arg), &p);
4352 audio_enc.sample_rate = atoi(arg);
4353 } else if (!strcasecmp(cmd, "AudioQuality")) {
4354 get_arg(arg, sizeof(arg), &p);
4356 // audio_enc.quality = atof(arg) * 1000;
4358 } else if (!strcasecmp(cmd, "VideoBitRateRange")) {
4360 int minrate, maxrate;
4362 get_arg(arg, sizeof(arg), &p);
4364 if (sscanf(arg, "%d-%d", &minrate, &maxrate) == 2) {
4365 video_enc.rc_min_rate = minrate * 1000;
4366 video_enc.rc_max_rate = maxrate * 1000;
4368 ERROR("Incorrect format for VideoBitRateRange -- should be <min>-<max>: %s\n", arg);
4371 } else if (!strcasecmp(cmd, "Debug")) {
4373 get_arg(arg, sizeof(arg), &p);
4374 video_enc.debug = strtol(arg,0,0);
4376 } else if (!strcasecmp(cmd, "Strict")) {
4378 get_arg(arg, sizeof(arg), &p);
4379 video_enc.strict_std_compliance = atoi(arg);
4381 } else if (!strcasecmp(cmd, "VideoBufferSize")) {
4383 get_arg(arg, sizeof(arg), &p);
4384 video_enc.rc_buffer_size = atoi(arg) * 8*1024;
4386 } else if (!strcasecmp(cmd, "VideoBitRateTolerance")) {
4388 get_arg(arg, sizeof(arg), &p);
4389 video_enc.bit_rate_tolerance = atoi(arg) * 1000;
4391 } else if (!strcasecmp(cmd, "VideoBitRate")) {
4392 get_arg(arg, sizeof(arg), &p);
4394 video_enc.bit_rate = atoi(arg) * 1000;
4396 } else if (!strcasecmp(cmd, "VideoSize")) {
4397 get_arg(arg, sizeof(arg), &p);
4399 av_parse_video_size(&video_enc.width, &video_enc.height, arg);
4400 if ((video_enc.width % 16) != 0 ||
4401 (video_enc.height % 16) != 0) {
4402 ERROR("Image size must be a multiple of 16\n");
4405 } else if (!strcasecmp(cmd, "VideoFrameRate")) {
4406 get_arg(arg, sizeof(arg), &p);
4408 AVRational frame_rate;
4409 if (av_parse_video_rate(&frame_rate, arg) < 0) {
4410 ERROR("Incorrect frame rate: %s\n", arg);
4412 video_enc.time_base.num = frame_rate.den;
4413 video_enc.time_base.den = frame_rate.num;
4416 } else if (!strcasecmp(cmd, "VideoGopSize")) {
4417 get_arg(arg, sizeof(arg), &p);
4419 video_enc.gop_size = atoi(arg);
4420 } else if (!strcasecmp(cmd, "VideoIntraOnly")) {
4422 video_enc.gop_size = 1;
4423 } else if (!strcasecmp(cmd, "VideoHighQuality")) {
4425 video_enc.mb_decision = FF_MB_DECISION_BITS;
4426 } else if (!strcasecmp(cmd, "Video4MotionVector")) {
4428 video_enc.mb_decision = FF_MB_DECISION_BITS; //FIXME remove
4429 video_enc.flags |= CODEC_FLAG_4MV;
4431 } else if (!strcasecmp(cmd, "AVOptionVideo") ||
4432 !strcasecmp(cmd, "AVOptionAudio")) {
4434 AVCodecContext *avctx;
4436 get_arg(arg, sizeof(arg), &p);
4437 get_arg(arg2, sizeof(arg2), &p);
4438 if (!strcasecmp(cmd, "AVOptionVideo")) {
4440 type = AV_OPT_FLAG_VIDEO_PARAM;
4443 type = AV_OPT_FLAG_AUDIO_PARAM;
4445 if (ffserver_opt_default(arg, arg2, avctx, type|AV_OPT_FLAG_ENCODING_PARAM)) {
4446 ERROR("AVOption error: %s %s\n", arg, arg2);
4448 } else if (!strcasecmp(cmd, "AVPresetVideo") ||
4449 !strcasecmp(cmd, "AVPresetAudio")) {
4450 AVCodecContext *avctx;
4452 get_arg(arg, sizeof(arg), &p);
4453 if (!strcasecmp(cmd, "AVPresetVideo")) {
4455 video_enc.codec_id = video_id;
4456 type = AV_OPT_FLAG_VIDEO_PARAM;
4459 audio_enc.codec_id = audio_id;
4460 type = AV_OPT_FLAG_AUDIO_PARAM;
4462 if (ffserver_opt_preset(arg, avctx, type|AV_OPT_FLAG_ENCODING_PARAM, &audio_id, &video_id)) {
4463 ERROR("AVPreset error: %s\n", arg);
4465 } else if (!strcasecmp(cmd, "VideoTag")) {
4466 get_arg(arg, sizeof(arg), &p);
4467 if ((strlen(arg) == 4) && stream)
4468 video_enc.codec_tag = MKTAG(arg[0], arg[1], arg[2], arg[3]);
4469 } else if (!strcasecmp(cmd, "BitExact")) {
4471 video_enc.flags |= CODEC_FLAG_BITEXACT;
4472 } else if (!strcasecmp(cmd, "DctFastint")) {
4474 video_enc.dct_algo = FF_DCT_FASTINT;
4475 } else if (!strcasecmp(cmd, "IdctSimple")) {
4477 video_enc.idct_algo = FF_IDCT_SIMPLE;
4478 } else if (!strcasecmp(cmd, "Qscale")) {
4479 get_arg(arg, sizeof(arg), &p);
4481 video_enc.flags |= CODEC_FLAG_QSCALE;
4482 video_enc.global_quality = FF_QP2LAMBDA * atoi(arg);
4484 } else if (!strcasecmp(cmd, "VideoQDiff")) {
4485 get_arg(arg, sizeof(arg), &p);
4487 video_enc.max_qdiff = atoi(arg);
4488 if (video_enc.max_qdiff < 1 || video_enc.max_qdiff > 31) {
4489 ERROR("VideoQDiff out of range\n");
4492 } else if (!strcasecmp(cmd, "VideoQMax")) {
4493 get_arg(arg, sizeof(arg), &p);
4495 video_enc.qmax = atoi(arg);
4496 if (video_enc.qmax < 1 || video_enc.qmax > 31) {
4497 ERROR("VideoQMax out of range\n");
4500 } else if (!strcasecmp(cmd, "VideoQMin")) {
4501 get_arg(arg, sizeof(arg), &p);
4503 video_enc.qmin = atoi(arg);
4504 if (video_enc.qmin < 1 || video_enc.qmin > 31) {
4505 ERROR("VideoQMin out of range\n");
4508 } else if (!strcasecmp(cmd, "LumaElim")) {
4509 get_arg(arg, sizeof(arg), &p);
4511 video_enc.luma_elim_threshold = atoi(arg);
4512 } else if (!strcasecmp(cmd, "ChromaElim")) {
4513 get_arg(arg, sizeof(arg), &p);
4515 video_enc.chroma_elim_threshold = atoi(arg);
4516 } else if (!strcasecmp(cmd, "LumiMask")) {
4517 get_arg(arg, sizeof(arg), &p);
4519 video_enc.lumi_masking = atof(arg);
4520 } else if (!strcasecmp(cmd, "DarkMask")) {
4521 get_arg(arg, sizeof(arg), &p);
4523 video_enc.dark_masking = atof(arg);
4524 } else if (!strcasecmp(cmd, "NoVideo")) {
4525 video_id = CODEC_ID_NONE;
4526 } else if (!strcasecmp(cmd, "NoAudio")) {
4527 audio_id = CODEC_ID_NONE;
4528 } else if (!strcasecmp(cmd, "ACL")) {
4529 parse_acl_row(stream, feed, NULL, p, filename, line_num);
4530 } else if (!strcasecmp(cmd, "DynamicACL")) {
4532 get_arg(stream->dynamic_acl, sizeof(stream->dynamic_acl), &p);
4534 } else if (!strcasecmp(cmd, "RTSPOption")) {
4535 get_arg(arg, sizeof(arg), &p);
4537 av_freep(&stream->rtsp_option);
4538 stream->rtsp_option = av_strdup(arg);
4540 } else if (!strcasecmp(cmd, "MulticastAddress")) {
4541 get_arg(arg, sizeof(arg), &p);
4543 if (resolve_host(&stream->multicast_ip, arg) != 0) {
4544 ERROR("Invalid host/IP address: %s\n", arg);
4546 stream->is_multicast = 1;
4547 stream->loop = 1; /* default is looping */
4549 } else if (!strcasecmp(cmd, "MulticastPort")) {
4550 get_arg(arg, sizeof(arg), &p);
4552 stream->multicast_port = atoi(arg);
4553 } else if (!strcasecmp(cmd, "MulticastTTL")) {
4554 get_arg(arg, sizeof(arg), &p);
4556 stream->multicast_ttl = atoi(arg);
4557 } else if (!strcasecmp(cmd, "NoLoop")) {
4560 } else if (!strcasecmp(cmd, "</Stream>")) {
4562 ERROR("No corresponding <Stream> for </Stream>\n");
4564 if (stream->feed && stream->fmt && strcmp(stream->fmt->name, "ffm") != 0) {
4565 if (audio_id != CODEC_ID_NONE) {
4566 audio_enc.codec_type = AVMEDIA_TYPE_AUDIO;
4567 audio_enc.codec_id = audio_id;
4568 add_codec(stream, &audio_enc);
4570 if (video_id != CODEC_ID_NONE) {
4571 video_enc.codec_type = AVMEDIA_TYPE_VIDEO;
4572 video_enc.codec_id = video_id;
4573 add_codec(stream, &video_enc);
4578 } else if (!strcasecmp(cmd, "<Redirect")) {
4579 /*********************************************/
4581 if (stream || feed || redirect) {
4582 ERROR("Already in a tag\n");
4584 redirect = av_mallocz(sizeof(FFStream));
4585 *last_stream = redirect;
4586 last_stream = &redirect->next;
4588 get_arg(redirect->filename, sizeof(redirect->filename), &p);
4589 q = strrchr(redirect->filename, '>');
4592 redirect->stream_type = STREAM_TYPE_REDIRECT;
4594 } else if (!strcasecmp(cmd, "URL")) {
4596 get_arg(redirect->feed_filename, sizeof(redirect->feed_filename), &p);
4597 } else if (!strcasecmp(cmd, "</Redirect>")) {
4599 ERROR("No corresponding <Redirect> for </Redirect>\n");
4601 if (!redirect->feed_filename[0]) {
4602 ERROR("No URL found for <Redirect>\n");
4606 } else if (!strcasecmp(cmd, "LoadModule")) {
4607 get_arg(arg, sizeof(arg), &p);
4611 ERROR("Module support not compiled into this version: '%s'\n", arg);
4614 ERROR("Incorrect keyword: '%s'\n", cmd);
4626 static void handle_child_exit(int sig)
4631 while ((pid = waitpid(-1, &status, WNOHANG)) > 0) {
4634 for (feed = first_feed; feed; feed = feed->next) {
4635 if (feed->pid == pid) {
4636 int uptime = time(0) - feed->pid_start;
4639 fprintf(stderr, "%s: Pid %d exited with status %d after %d seconds\n", feed->filename, pid, status, uptime);
4642 /* Turn off any more restarts */
4643 feed->child_argv = 0;
4648 need_to_start_children = 1;
4651 static void opt_debug(void)
4654 ffserver_daemon = 0;
4655 logfilename[0] = '-';
4658 static void show_help(void)
4660 printf("usage: ffserver [options]\n"
4661 "Hyper fast multi format Audio/Video streaming server\n");
4663 show_help_options(options, "Main options:\n", 0, 0);
4666 static const OptionDef options[] = {
4667 #include "cmdutils_common_opts.h"
4668 { "n", OPT_BOOL, {(void *)&no_launch }, "enable no-launch mode" },
4669 { "d", 0, {(void*)opt_debug}, "enable debug mode" },
4670 { "f", HAS_ARG | OPT_STRING, {(void*)&config_filename }, "use configfile instead of /etc/ffserver.conf", "configfile" },
4674 int main(int argc, char **argv)
4676 struct sigaction sigact;
4682 my_program_name = argv[0];
4683 my_program_dir = getcwd(0, 0);
4684 ffserver_daemon = 1;
4686 parse_options(argc, argv, options, NULL);
4688 unsetenv("http_proxy"); /* Kill the http_proxy */
4690 av_lfg_init(&random_state, av_get_random_seed());
4692 memset(&sigact, 0, sizeof(sigact));
4693 sigact.sa_handler = handle_child_exit;
4694 sigact.sa_flags = SA_NOCLDSTOP | SA_RESTART;
4695 sigaction(SIGCHLD, &sigact, 0);
4697 if (parse_ffconfig(config_filename) < 0) {
4698 fprintf(stderr, "Incorrect config file - exiting.\n");
4702 /* open log file if needed */
4703 if (logfilename[0] != '\0') {
4704 if (!strcmp(logfilename, "-"))
4707 logfile = fopen(logfilename, "a");
4708 av_log_set_callback(http_av_log);
4711 build_file_streams();
4713 build_feed_streams();
4715 compute_bandwidth();
4717 /* put the process in background and detach it from its TTY */
4718 if (ffserver_daemon) {
4725 } else if (pid > 0) {
4732 open("/dev/null", O_RDWR);
4733 if (strcmp(logfilename, "-") != 0) {
4743 signal(SIGPIPE, SIG_IGN);
4745 if (ffserver_daemon)
4748 if (http_server() < 0) {
4749 http_log("Could not start server\n");