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/random_seed.h"
41 #include "libavutil/parseutils.h"
42 #include "libavutil/opt.h"
46 #include <sys/ioctl.h>
61 const char program_name[] = "ffserver";
62 const int program_birth_year = 2000;
64 static const OptionDef options[];
67 HTTPSTATE_WAIT_REQUEST,
68 HTTPSTATE_SEND_HEADER,
69 HTTPSTATE_SEND_DATA_HEADER,
70 HTTPSTATE_SEND_DATA, /* sending TCP or UDP data */
71 HTTPSTATE_SEND_DATA_TRAILER,
72 HTTPSTATE_RECEIVE_DATA,
73 HTTPSTATE_WAIT_FEED, /* wait for data from the feed */
76 RTSPSTATE_WAIT_REQUEST,
78 RTSPSTATE_SEND_PACKET,
81 static const char *http_state[] = {
97 #define MAX_STREAMS 20
99 #define IOBUFFER_INIT_SIZE 8192
101 /* timeouts are in ms */
102 #define HTTP_REQUEST_TIMEOUT (15 * 1000)
103 #define RTSP_REQUEST_TIMEOUT (3600 * 24 * 1000)
105 #define SYNC_TIMEOUT (10 * 1000)
107 typedef struct RTSPActionServerSetup {
109 char transport_option[512];
110 } RTSPActionServerSetup;
113 int64_t count1, count2;
114 int64_t time1, time2;
117 /* context associated with one connection */
118 typedef struct HTTPContext {
119 enum HTTPState state;
120 int fd; /* socket file descriptor */
121 struct sockaddr_in from_addr; /* origin */
122 struct pollfd *poll_entry; /* used when polling */
124 uint8_t *buffer_ptr, *buffer_end;
127 int chunked_encoding;
128 int chunk_size; /* 0 if it needs to be read */
129 struct HTTPContext *next;
130 int got_key_frame; /* stream 0 => 1, stream 1 => 2, stream 2=> 4 */
134 /* input format handling */
135 AVFormatContext *fmt_in;
136 int64_t start_time; /* In milliseconds - this wraps fairly often */
137 int64_t first_pts; /* initial pts value */
138 int64_t cur_pts; /* current pts value from the stream in us */
139 int64_t cur_frame_duration; /* duration of the current frame in us */
140 int cur_frame_bytes; /* output frame size, needed to compute
141 the time at which we send each
143 int pts_stream_index; /* stream we choose as clock reference */
144 int64_t cur_clock; /* current clock reference value in us */
145 /* output format handling */
146 struct FFStream *stream;
147 /* -1 is invalid stream */
148 int feed_streams[MAX_STREAMS]; /* index of streams in the feed */
149 int switch_feed_streams[MAX_STREAMS]; /* index of streams in the feed */
151 AVFormatContext fmt_ctx; /* instance of FFStream for one user */
152 int last_packet_sent; /* true if last data packet was sent */
154 DataRateData datarate;
161 int is_packetized; /* if true, the stream is packetized */
162 int packet_stream_index; /* current stream for output in state machine */
164 /* RTSP state specific */
165 uint8_t *pb_buffer; /* XXX: use that in all the code */
167 int seq; /* RTSP sequence number */
169 /* RTP state specific */
170 enum RTSPLowerTransport rtp_protocol;
171 char session_id[32]; /* session id */
172 AVFormatContext *rtp_ctx[MAX_STREAMS];
174 /* RTP/UDP specific */
175 URLContext *rtp_handles[MAX_STREAMS];
177 /* RTP/TCP specific */
178 struct HTTPContext *rtsp_c;
179 uint8_t *packet_buffer, *packet_buffer_ptr, *packet_buffer_end;
182 /* each generated stream is described here */
186 STREAM_TYPE_REDIRECT,
189 enum IPAddressAction {
194 typedef struct IPAddressACL {
195 struct IPAddressACL *next;
196 enum IPAddressAction action;
197 /* These are in host order */
198 struct in_addr first;
202 /* description of each stream of the ffserver.conf file */
203 typedef struct FFStream {
204 enum StreamType stream_type;
205 char filename[1024]; /* stream filename */
206 struct FFStream *feed; /* feed we are using (can be null if
208 AVDictionary *in_opts; /* input parameters */
209 AVInputFormat *ifmt; /* if non NULL, force input format */
212 char dynamic_acl[1024];
214 int prebuffer; /* Number of millseconds early to start */
215 int64_t max_time; /* Number of milliseconds to run */
217 AVStream *streams[MAX_STREAMS];
218 int feed_streams[MAX_STREAMS]; /* index of streams in the feed */
219 char feed_filename[1024]; /* file name of the feed storage, or
220 input file name for a stream */
225 pid_t pid; /* Of ffmpeg process */
226 time_t pid_start; /* Of ffmpeg process */
228 struct FFStream *next;
229 unsigned bandwidth; /* bandwidth, in kbits/s */
232 /* multicast specific */
234 struct in_addr multicast_ip;
235 int multicast_port; /* first port used for multicast */
237 int loop; /* if true, send the stream in loops (only meaningful if file) */
240 int feed_opened; /* true if someone is writing to the feed */
241 int is_feed; /* true if it is a feed */
242 int readonly; /* True if writing is prohibited to the file */
243 int truncate; /* True if feeder connection truncate the feed file */
245 int64_t bytes_served;
246 int64_t feed_max_size; /* maximum storage size, zero means unlimited */
247 int64_t feed_write_index; /* current write position in feed (it wraps around) */
248 int64_t feed_size; /* current size of feed */
249 struct FFStream *next_feed;
252 typedef struct FeedData {
253 long long data_count;
254 float avg_frame_size; /* frame size averaged over last frames with exponential mean */
257 static struct sockaddr_in my_http_addr;
258 static struct sockaddr_in my_rtsp_addr;
260 static char logfilename[1024];
261 static HTTPContext *first_http_ctx;
262 static FFStream *first_feed; /* contains only feeds */
263 static FFStream *first_stream; /* contains all streams, including feeds */
265 static void new_connection(int server_fd, int is_rtsp);
266 static void close_connection(HTTPContext *c);
269 static int handle_connection(HTTPContext *c);
270 static int http_parse_request(HTTPContext *c);
271 static int http_send_data(HTTPContext *c);
272 static void compute_status(HTTPContext *c);
273 static int open_input_stream(HTTPContext *c, const char *info);
274 static int http_start_receive_data(HTTPContext *c);
275 static int http_receive_data(HTTPContext *c);
278 static int rtsp_parse_request(HTTPContext *c);
279 static void rtsp_cmd_describe(HTTPContext *c, const char *url);
280 static void rtsp_cmd_options(HTTPContext *c, const char *url);
281 static void rtsp_cmd_setup(HTTPContext *c, const char *url, RTSPMessageHeader *h);
282 static void rtsp_cmd_play(HTTPContext *c, const char *url, RTSPMessageHeader *h);
283 static void rtsp_cmd_pause(HTTPContext *c, const char *url, RTSPMessageHeader *h);
284 static void rtsp_cmd_teardown(HTTPContext *c, const char *url, RTSPMessageHeader *h);
287 static int prepare_sdp_description(FFStream *stream, uint8_t **pbuffer,
288 struct in_addr my_ip);
291 static HTTPContext *rtp_new_connection(struct sockaddr_in *from_addr,
292 FFStream *stream, const char *session_id,
293 enum RTSPLowerTransport rtp_protocol);
294 static int rtp_new_av_stream(HTTPContext *c,
295 int stream_index, struct sockaddr_in *dest_addr,
296 HTTPContext *rtsp_c);
298 static const char *my_program_name;
299 static const char *my_program_dir;
301 static const char *config_filename = "/etc/ffserver.conf";
303 static int ffserver_debug;
304 static int ffserver_daemon;
305 static int no_launch;
306 static int need_to_start_children;
308 /* maximum number of simultaneous HTTP connections */
309 static unsigned int nb_max_http_connections = 2000;
310 static unsigned int nb_max_connections = 5;
311 static unsigned int nb_connections;
313 static uint64_t max_bandwidth = 1000;
314 static uint64_t current_bandwidth;
316 static int64_t cur_time; // Making this global saves on passing it around everywhere
318 static AVLFG random_state;
320 static FILE *logfile = NULL;
322 /* FIXME: make ffserver work with IPv6 */
323 /* resolve host with also IP address parsing */
324 static int resolve_host(struct in_addr *sin_addr, const char *hostname)
327 if (!ff_inet_aton(hostname, sin_addr)) {
329 struct addrinfo *ai, *cur;
330 struct addrinfo hints;
331 memset(&hints, 0, sizeof(hints));
332 hints.ai_family = AF_INET;
333 if (getaddrinfo(hostname, NULL, &hints, &ai))
335 /* getaddrinfo returns a linked list of addrinfo structs.
336 * Even if we set ai_family = AF_INET above, make sure
337 * that the returned one actually is of the correct type. */
338 for (cur = ai; cur; cur = cur->ai_next) {
339 if (cur->ai_family == AF_INET) {
340 *sin_addr = ((struct sockaddr_in *)cur->ai_addr)->sin_addr;
349 hp = gethostbyname(hostname);
352 memcpy(sin_addr, hp->h_addr_list[0], sizeof(struct in_addr));
358 static char *ctime1(char *buf2)
366 p = buf2 + strlen(p) - 1;
372 static void http_vlog(const char *fmt, va_list vargs)
374 static int print_prefix = 1;
379 fprintf(logfile, "%s ", buf);
381 print_prefix = strstr(fmt, "\n") != NULL;
382 vfprintf(logfile, fmt, vargs);
388 __attribute__ ((format (printf, 1, 2)))
390 static void http_log(const char *fmt, ...)
393 va_start(vargs, fmt);
394 http_vlog(fmt, vargs);
398 static void http_av_log(void *ptr, int level, const char *fmt, va_list vargs)
400 static int print_prefix = 1;
401 AVClass *avc = ptr ? *(AVClass**)ptr : NULL;
402 if (level > av_log_get_level())
404 if (print_prefix && avc)
405 http_log("[%s @ %p]", avc->item_name(ptr), ptr);
406 print_prefix = strstr(fmt, "\n") != NULL;
407 http_vlog(fmt, vargs);
410 static void log_connection(HTTPContext *c)
415 http_log("%s - - [%s] \"%s %s\" %d %"PRId64"\n",
416 inet_ntoa(c->from_addr.sin_addr), c->method, c->url,
417 c->protocol, (c->http_error ? c->http_error : 200), c->data_count);
420 static void update_datarate(DataRateData *drd, int64_t count)
422 if (!drd->time1 && !drd->count1) {
423 drd->time1 = drd->time2 = cur_time;
424 drd->count1 = drd->count2 = count;
425 } else if (cur_time - drd->time2 > 5000) {
426 drd->time1 = drd->time2;
427 drd->count1 = drd->count2;
428 drd->time2 = cur_time;
433 /* In bytes per second */
434 static int compute_datarate(DataRateData *drd, int64_t count)
436 if (cur_time == drd->time1)
439 return ((count - drd->count1) * 1000) / (cur_time - drd->time1);
443 static void start_children(FFStream *feed)
448 for (; feed; feed = feed->next) {
449 if (feed->child_argv && !feed->pid) {
450 feed->pid_start = time(0);
455 http_log("Unable to create children\n");
464 av_strlcpy(pathname, my_program_name, sizeof(pathname));
466 slash = strrchr(pathname, '/');
471 strcpy(slash, "ffmpeg");
473 http_log("Launch commandline: ");
474 http_log("%s ", pathname);
475 for (i = 1; feed->child_argv[i] && feed->child_argv[i][0]; i++)
476 http_log("%s ", feed->child_argv[i]);
479 for (i = 3; i < 256; i++)
482 if (!ffserver_debug) {
483 i = open("/dev/null", O_RDWR);
492 /* This is needed to make relative pathnames work */
493 chdir(my_program_dir);
495 signal(SIGPIPE, SIG_DFL);
497 execvp(pathname, feed->child_argv);
505 /* open a listening socket */
506 static int socket_open_listen(struct sockaddr_in *my_addr)
510 server_fd = socket(AF_INET,SOCK_STREAM,0);
517 setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &tmp, sizeof(tmp));
519 if (bind (server_fd, (struct sockaddr *) my_addr, sizeof (*my_addr)) < 0) {
521 snprintf(bindmsg, sizeof(bindmsg), "bind(port %d)", ntohs(my_addr->sin_port));
523 closesocket(server_fd);
527 if (listen (server_fd, 5) < 0) {
529 closesocket(server_fd);
532 ff_socket_nonblock(server_fd, 1);
537 /* start all multicast streams */
538 static void start_multicast(void)
543 struct sockaddr_in dest_addr;
544 int default_port, stream_index;
547 for(stream = first_stream; stream != NULL; stream = stream->next) {
548 if (stream->is_multicast) {
549 /* open the RTP connection */
550 snprintf(session_id, sizeof(session_id), "%08x%08x",
551 av_lfg_get(&random_state), av_lfg_get(&random_state));
553 /* choose a port if none given */
554 if (stream->multicast_port == 0) {
555 stream->multicast_port = default_port;
559 dest_addr.sin_family = AF_INET;
560 dest_addr.sin_addr = stream->multicast_ip;
561 dest_addr.sin_port = htons(stream->multicast_port);
563 rtp_c = rtp_new_connection(&dest_addr, stream, session_id,
564 RTSP_LOWER_TRANSPORT_UDP_MULTICAST);
568 if (open_input_stream(rtp_c, "") < 0) {
569 http_log("Could not open input stream for stream '%s'\n",
574 /* open each RTP stream */
575 for(stream_index = 0; stream_index < stream->nb_streams;
577 dest_addr.sin_port = htons(stream->multicast_port +
579 if (rtp_new_av_stream(rtp_c, stream_index, &dest_addr, NULL) < 0) {
580 http_log("Could not open output stream '%s/streamid=%d'\n",
581 stream->filename, stream_index);
586 /* change state to send data */
587 rtp_c->state = HTTPSTATE_SEND_DATA;
592 /* main loop of the http server */
593 static int http_server(void)
595 int server_fd = 0, rtsp_server_fd = 0;
596 int ret, delay, delay1;
597 struct pollfd *poll_table, *poll_entry;
598 HTTPContext *c, *c_next;
600 if(!(poll_table = av_mallocz((nb_max_http_connections + 2)*sizeof(*poll_table)))) {
601 http_log("Impossible to allocate a poll table handling %d connections.\n", nb_max_http_connections);
605 if (my_http_addr.sin_port) {
606 server_fd = socket_open_listen(&my_http_addr);
611 if (my_rtsp_addr.sin_port) {
612 rtsp_server_fd = socket_open_listen(&my_rtsp_addr);
613 if (rtsp_server_fd < 0)
617 if (!rtsp_server_fd && !server_fd) {
618 http_log("HTTP and RTSP disabled.\n");
622 http_log("FFserver started.\n");
624 start_children(first_feed);
629 poll_entry = poll_table;
631 poll_entry->fd = server_fd;
632 poll_entry->events = POLLIN;
635 if (rtsp_server_fd) {
636 poll_entry->fd = rtsp_server_fd;
637 poll_entry->events = POLLIN;
641 /* wait for events on each HTTP handle */
648 case HTTPSTATE_SEND_HEADER:
649 case RTSPSTATE_SEND_REPLY:
650 case RTSPSTATE_SEND_PACKET:
651 c->poll_entry = poll_entry;
653 poll_entry->events = POLLOUT;
656 case HTTPSTATE_SEND_DATA_HEADER:
657 case HTTPSTATE_SEND_DATA:
658 case HTTPSTATE_SEND_DATA_TRAILER:
659 if (!c->is_packetized) {
660 /* for TCP, we output as much as we can (may need to put a limit) */
661 c->poll_entry = poll_entry;
663 poll_entry->events = POLLOUT;
666 /* when ffserver is doing the timing, we work by
667 looking at which packet need to be sent every
669 delay1 = 10; /* one tick wait XXX: 10 ms assumed */
674 case HTTPSTATE_WAIT_REQUEST:
675 case HTTPSTATE_RECEIVE_DATA:
676 case HTTPSTATE_WAIT_FEED:
677 case RTSPSTATE_WAIT_REQUEST:
678 /* need to catch errors */
679 c->poll_entry = poll_entry;
681 poll_entry->events = POLLIN;/* Maybe this will work */
685 c->poll_entry = NULL;
691 /* wait for an event on one connection. We poll at least every
692 second to handle timeouts */
694 ret = poll(poll_table, poll_entry - poll_table, delay);
695 if (ret < 0 && ff_neterrno() != AVERROR(EAGAIN) &&
696 ff_neterrno() != AVERROR(EINTR))
700 cur_time = av_gettime() / 1000;
702 if (need_to_start_children) {
703 need_to_start_children = 0;
704 start_children(first_feed);
707 /* now handle the events */
708 for(c = first_http_ctx; c != NULL; c = c_next) {
710 if (handle_connection(c) < 0) {
711 /* close and free the connection */
717 poll_entry = poll_table;
719 /* new HTTP connection request ? */
720 if (poll_entry->revents & POLLIN)
721 new_connection(server_fd, 0);
724 if (rtsp_server_fd) {
725 /* new RTSP connection request ? */
726 if (poll_entry->revents & POLLIN)
727 new_connection(rtsp_server_fd, 1);
732 /* start waiting for a new HTTP/RTSP request */
733 static void start_wait_request(HTTPContext *c, int is_rtsp)
735 c->buffer_ptr = c->buffer;
736 c->buffer_end = c->buffer + c->buffer_size - 1; /* leave room for '\0' */
739 c->timeout = cur_time + RTSP_REQUEST_TIMEOUT;
740 c->state = RTSPSTATE_WAIT_REQUEST;
742 c->timeout = cur_time + HTTP_REQUEST_TIMEOUT;
743 c->state = HTTPSTATE_WAIT_REQUEST;
747 static void http_send_too_busy_reply(int fd)
750 int len = snprintf(buffer, sizeof(buffer),
751 "HTTP/1.0 503 Server too busy\r\n"
752 "Content-type: text/html\r\n"
754 "<html><head><title>Too busy</title></head><body>\r\n"
755 "<p>The server is too busy to serve your request at this time.</p>\r\n"
756 "<p>The number of current connections is %d, and this exceeds the limit of %d.</p>\r\n"
757 "</body></html>\r\n",
758 nb_connections, nb_max_connections);
759 send(fd, buffer, len, 0);
763 static void new_connection(int server_fd, int is_rtsp)
765 struct sockaddr_in from_addr;
767 HTTPContext *c = NULL;
769 len = sizeof(from_addr);
770 fd = accept(server_fd, (struct sockaddr *)&from_addr,
773 http_log("error during accept %s\n", strerror(errno));
776 ff_socket_nonblock(fd, 1);
778 if (nb_connections >= nb_max_connections) {
779 http_send_too_busy_reply(fd);
783 /* add a new connection */
784 c = av_mallocz(sizeof(HTTPContext));
789 c->poll_entry = NULL;
790 c->from_addr = from_addr;
791 c->buffer_size = IOBUFFER_INIT_SIZE;
792 c->buffer = av_malloc(c->buffer_size);
796 c->next = first_http_ctx;
800 start_wait_request(c, is_rtsp);
812 static void close_connection(HTTPContext *c)
814 HTTPContext **cp, *c1;
816 AVFormatContext *ctx;
820 /* remove connection from list */
821 cp = &first_http_ctx;
822 while ((*cp) != NULL) {
830 /* remove references, if any (XXX: do it faster) */
831 for(c1 = first_http_ctx; c1 != NULL; c1 = c1->next) {
836 /* remove connection associated resources */
840 /* close each frame parser */
841 for(i=0;i<c->fmt_in->nb_streams;i++) {
842 st = c->fmt_in->streams[i];
843 if (st->codec->codec)
844 avcodec_close(st->codec);
846 av_close_input_file(c->fmt_in);
849 /* free RTP output streams if any */
852 nb_streams = c->stream->nb_streams;
854 for(i=0;i<nb_streams;i++) {
857 av_write_trailer(ctx);
858 av_dict_free(&ctx->metadata);
859 av_free(ctx->streams[0]);
862 h = c->rtp_handles[i];
869 if (!c->last_packet_sent && c->state == HTTPSTATE_SEND_DATA_TRAILER) {
872 if (avio_open_dyn_buf(&ctx->pb) >= 0) {
873 av_write_trailer(ctx);
874 av_freep(&c->pb_buffer);
875 avio_close_dyn_buf(ctx->pb, &c->pb_buffer);
880 for(i=0; i<ctx->nb_streams; i++)
881 av_free(ctx->streams[i]);
883 if (c->stream && !c->post && c->stream->stream_type == STREAM_TYPE_LIVE)
884 current_bandwidth -= c->stream->bandwidth;
886 /* signal that there is no feed if we are the feeder socket */
887 if (c->state == HTTPSTATE_RECEIVE_DATA && c->stream) {
888 c->stream->feed_opened = 0;
892 av_freep(&c->pb_buffer);
893 av_freep(&c->packet_buffer);
899 static int handle_connection(HTTPContext *c)
904 case HTTPSTATE_WAIT_REQUEST:
905 case RTSPSTATE_WAIT_REQUEST:
907 if ((c->timeout - cur_time) < 0)
909 if (c->poll_entry->revents & (POLLERR | POLLHUP))
912 /* no need to read if no events */
913 if (!(c->poll_entry->revents & POLLIN))
917 len = recv(c->fd, c->buffer_ptr, 1, 0);
919 if (ff_neterrno() != AVERROR(EAGAIN) &&
920 ff_neterrno() != AVERROR(EINTR))
922 } else if (len == 0) {
925 /* search for end of request. */
927 c->buffer_ptr += len;
929 if ((ptr >= c->buffer + 2 && !memcmp(ptr-2, "\n\n", 2)) ||
930 (ptr >= c->buffer + 4 && !memcmp(ptr-4, "\r\n\r\n", 4))) {
931 /* request found : parse it and reply */
932 if (c->state == HTTPSTATE_WAIT_REQUEST) {
933 ret = http_parse_request(c);
935 ret = rtsp_parse_request(c);
939 } else if (ptr >= c->buffer_end) {
940 /* request too long: cannot do anything */
942 } else goto read_loop;
946 case HTTPSTATE_SEND_HEADER:
947 if (c->poll_entry->revents & (POLLERR | POLLHUP))
950 /* no need to write if no events */
951 if (!(c->poll_entry->revents & POLLOUT))
953 len = send(c->fd, c->buffer_ptr, c->buffer_end - c->buffer_ptr, 0);
955 if (ff_neterrno() != AVERROR(EAGAIN) &&
956 ff_neterrno() != AVERROR(EINTR)) {
957 /* error : close connection */
958 av_freep(&c->pb_buffer);
962 c->buffer_ptr += len;
964 c->stream->bytes_served += len;
965 c->data_count += len;
966 if (c->buffer_ptr >= c->buffer_end) {
967 av_freep(&c->pb_buffer);
971 /* all the buffer was sent : synchronize to the incoming stream */
972 c->state = HTTPSTATE_SEND_DATA_HEADER;
973 c->buffer_ptr = c->buffer_end = c->buffer;
978 case HTTPSTATE_SEND_DATA:
979 case HTTPSTATE_SEND_DATA_HEADER:
980 case HTTPSTATE_SEND_DATA_TRAILER:
981 /* for packetized output, we consider we can always write (the
982 input streams sets the speed). It may be better to verify
983 that we do not rely too much on the kernel queues */
984 if (!c->is_packetized) {
985 if (c->poll_entry->revents & (POLLERR | POLLHUP))
988 /* no need to read if no events */
989 if (!(c->poll_entry->revents & POLLOUT))
992 if (http_send_data(c) < 0)
994 /* close connection if trailer sent */
995 if (c->state == HTTPSTATE_SEND_DATA_TRAILER)
998 case HTTPSTATE_RECEIVE_DATA:
999 /* no need to read if no events */
1000 if (c->poll_entry->revents & (POLLERR | POLLHUP))
1002 if (!(c->poll_entry->revents & POLLIN))
1004 if (http_receive_data(c) < 0)
1007 case HTTPSTATE_WAIT_FEED:
1008 /* no need to read if no events */
1009 if (c->poll_entry->revents & (POLLIN | POLLERR | POLLHUP))
1012 /* nothing to do, we'll be waken up by incoming feed packets */
1015 case RTSPSTATE_SEND_REPLY:
1016 if (c->poll_entry->revents & (POLLERR | POLLHUP)) {
1017 av_freep(&c->pb_buffer);
1020 /* no need to write if no events */
1021 if (!(c->poll_entry->revents & POLLOUT))
1023 len = send(c->fd, c->buffer_ptr, c->buffer_end - c->buffer_ptr, 0);
1025 if (ff_neterrno() != AVERROR(EAGAIN) &&
1026 ff_neterrno() != AVERROR(EINTR)) {
1027 /* error : close connection */
1028 av_freep(&c->pb_buffer);
1032 c->buffer_ptr += len;
1033 c->data_count += len;
1034 if (c->buffer_ptr >= c->buffer_end) {
1035 /* all the buffer was sent : wait for a new request */
1036 av_freep(&c->pb_buffer);
1037 start_wait_request(c, 1);
1041 case RTSPSTATE_SEND_PACKET:
1042 if (c->poll_entry->revents & (POLLERR | POLLHUP)) {
1043 av_freep(&c->packet_buffer);
1046 /* no need to write if no events */
1047 if (!(c->poll_entry->revents & POLLOUT))
1049 len = send(c->fd, c->packet_buffer_ptr,
1050 c->packet_buffer_end - c->packet_buffer_ptr, 0);
1052 if (ff_neterrno() != AVERROR(EAGAIN) &&
1053 ff_neterrno() != AVERROR(EINTR)) {
1054 /* error : close connection */
1055 av_freep(&c->packet_buffer);
1059 c->packet_buffer_ptr += len;
1060 if (c->packet_buffer_ptr >= c->packet_buffer_end) {
1061 /* all the buffer was sent : wait for a new request */
1062 av_freep(&c->packet_buffer);
1063 c->state = RTSPSTATE_WAIT_REQUEST;
1067 case HTTPSTATE_READY:
1076 static int extract_rates(char *rates, int ratelen, const char *request)
1080 for (p = request; *p && *p != '\r' && *p != '\n'; ) {
1081 if (strncasecmp(p, "Pragma:", 7) == 0) {
1082 const char *q = p + 7;
1084 while (*q && *q != '\n' && isspace(*q))
1087 if (strncasecmp(q, "stream-switch-entry=", 20) == 0) {
1093 memset(rates, 0xff, ratelen);
1096 while (*q && *q != '\n' && *q != ':')
1099 if (sscanf(q, ":%d:%d", &stream_no, &rate_no) != 2)
1103 if (stream_no < ratelen && stream_no >= 0)
1104 rates[stream_no] = rate_no;
1106 while (*q && *q != '\n' && !isspace(*q))
1113 p = strchr(p, '\n');
1123 static int find_stream_in_feed(FFStream *feed, AVCodecContext *codec, int bit_rate)
1126 int best_bitrate = 100000000;
1129 for (i = 0; i < feed->nb_streams; i++) {
1130 AVCodecContext *feed_codec = feed->streams[i]->codec;
1132 if (feed_codec->codec_id != codec->codec_id ||
1133 feed_codec->sample_rate != codec->sample_rate ||
1134 feed_codec->width != codec->width ||
1135 feed_codec->height != codec->height)
1138 /* Potential stream */
1140 /* We want the fastest stream less than bit_rate, or the slowest
1141 * faster than bit_rate
1144 if (feed_codec->bit_rate <= bit_rate) {
1145 if (best_bitrate > bit_rate || feed_codec->bit_rate > best_bitrate) {
1146 best_bitrate = feed_codec->bit_rate;
1150 if (feed_codec->bit_rate < best_bitrate) {
1151 best_bitrate = feed_codec->bit_rate;
1160 static int modify_current_stream(HTTPContext *c, char *rates)
1163 FFStream *req = c->stream;
1164 int action_required = 0;
1166 /* Not much we can do for a feed */
1170 for (i = 0; i < req->nb_streams; i++) {
1171 AVCodecContext *codec = req->streams[i]->codec;
1175 c->switch_feed_streams[i] = req->feed_streams[i];
1178 c->switch_feed_streams[i] = find_stream_in_feed(req->feed, codec, codec->bit_rate / 2);
1181 /* Wants off or slow */
1182 c->switch_feed_streams[i] = find_stream_in_feed(req->feed, codec, codec->bit_rate / 4);
1184 /* This doesn't work well when it turns off the only stream! */
1185 c->switch_feed_streams[i] = -2;
1186 c->feed_streams[i] = -2;
1191 if (c->switch_feed_streams[i] >= 0 && c->switch_feed_streams[i] != c->feed_streams[i])
1192 action_required = 1;
1195 return action_required;
1198 /* XXX: factorize in utils.c ? */
1199 /* XXX: take care with different space meaning */
1200 static void skip_spaces(const char **pp)
1204 while (*p == ' ' || *p == '\t')
1209 static void get_word(char *buf, int buf_size, const char **pp)
1217 while (!isspace(*p) && *p != '\0') {
1218 if ((q - buf) < buf_size - 1)
1227 static void get_arg(char *buf, int buf_size, const char **pp)
1234 while (isspace(*p)) p++;
1237 if (*p == '\"' || *p == '\'')
1249 if ((q - buf) < buf_size - 1)
1254 if (quote && *p == quote)
1259 static void parse_acl_row(FFStream *stream, FFStream* feed, IPAddressACL *ext_acl,
1260 const char *p, const char *filename, int line_num)
1266 get_arg(arg, sizeof(arg), &p);
1267 if (strcasecmp(arg, "allow") == 0)
1268 acl.action = IP_ALLOW;
1269 else if (strcasecmp(arg, "deny") == 0)
1270 acl.action = IP_DENY;
1272 fprintf(stderr, "%s:%d: ACL action '%s' is not ALLOW or DENY\n",
1273 filename, line_num, arg);
1277 get_arg(arg, sizeof(arg), &p);
1279 if (resolve_host(&acl.first, arg) != 0) {
1280 fprintf(stderr, "%s:%d: ACL refers to invalid host or ip address '%s'\n",
1281 filename, line_num, arg);
1284 acl.last = acl.first;
1286 get_arg(arg, sizeof(arg), &p);
1289 if (resolve_host(&acl.last, arg) != 0) {
1290 fprintf(stderr, "%s:%d: ACL refers to invalid host or ip address '%s'\n",
1291 filename, line_num, arg);
1297 IPAddressACL *nacl = av_mallocz(sizeof(*nacl));
1298 IPAddressACL **naclp = 0;
1304 naclp = &stream->acl;
1310 fprintf(stderr, "%s:%d: ACL found not in <stream> or <feed>\n",
1311 filename, line_num);
1317 naclp = &(*naclp)->next;
1325 static IPAddressACL* parse_dynamic_acl(FFStream *stream, HTTPContext *c)
1330 IPAddressACL *acl = NULL;
1334 f = fopen(stream->dynamic_acl, "r");
1336 perror(stream->dynamic_acl);
1340 acl = av_mallocz(sizeof(IPAddressACL));
1344 if (fgets(line, sizeof(line), f) == NULL)
1350 if (*p == '\0' || *p == '#')
1352 get_arg(cmd, sizeof(cmd), &p);
1354 if (!strcasecmp(cmd, "ACL"))
1355 parse_acl_row(NULL, NULL, acl, p, stream->dynamic_acl, line_num);
1362 static void free_acl_list(IPAddressACL *in_acl)
1364 IPAddressACL *pacl,*pacl2;
1374 static int validate_acl_list(IPAddressACL *in_acl, HTTPContext *c)
1376 enum IPAddressAction last_action = IP_DENY;
1378 struct in_addr *src = &c->from_addr.sin_addr;
1379 unsigned long src_addr = src->s_addr;
1381 for (acl = in_acl; acl; acl = acl->next) {
1382 if (src_addr >= acl->first.s_addr && src_addr <= acl->last.s_addr)
1383 return (acl->action == IP_ALLOW) ? 1 : 0;
1384 last_action = acl->action;
1387 /* Nothing matched, so return not the last action */
1388 return (last_action == IP_DENY) ? 1 : 0;
1391 static int validate_acl(FFStream *stream, HTTPContext *c)
1397 /* if stream->acl is null validate_acl_list will return 1 */
1398 ret = validate_acl_list(stream->acl, c);
1400 if (stream->dynamic_acl[0]) {
1401 acl = parse_dynamic_acl(stream, c);
1403 ret = validate_acl_list(acl, c);
1411 /* compute the real filename of a file by matching it without its
1412 extensions to all the stream filenames */
1413 static void compute_real_filename(char *filename, int max_size)
1420 /* compute filename by matching without the file extensions */
1421 av_strlcpy(file1, filename, sizeof(file1));
1422 p = strrchr(file1, '.');
1425 for(stream = first_stream; stream != NULL; stream = stream->next) {
1426 av_strlcpy(file2, stream->filename, sizeof(file2));
1427 p = strrchr(file2, '.');
1430 if (!strcmp(file1, file2)) {
1431 av_strlcpy(filename, stream->filename, max_size);
1446 /* parse http request and prepare header */
1447 static int http_parse_request(HTTPContext *c)
1450 enum RedirType redir_type;
1452 char info[1024], filename[1024];
1456 const char *mime_type;
1460 char *useragent = 0;
1463 get_word(cmd, sizeof(cmd), (const char **)&p);
1464 av_strlcpy(c->method, cmd, sizeof(c->method));
1466 if (!strcmp(cmd, "GET"))
1468 else if (!strcmp(cmd, "POST"))
1473 get_word(url, sizeof(url), (const char **)&p);
1474 av_strlcpy(c->url, url, sizeof(c->url));
1476 get_word(protocol, sizeof(protocol), (const char **)&p);
1477 if (strcmp(protocol, "HTTP/1.0") && strcmp(protocol, "HTTP/1.1"))
1480 av_strlcpy(c->protocol, protocol, sizeof(c->protocol));
1483 http_log("%s - - New connection: %s %s\n", inet_ntoa(c->from_addr.sin_addr), cmd, url);
1485 /* find the filename and the optional info string in the request */
1486 p = strchr(url, '?');
1488 av_strlcpy(info, p, sizeof(info));
1493 av_strlcpy(filename, url + ((*url == '/') ? 1 : 0), sizeof(filename)-1);
1495 for (p = c->buffer; *p && *p != '\r' && *p != '\n'; ) {
1496 if (strncasecmp(p, "User-Agent:", 11) == 0) {
1498 if (*useragent && *useragent != '\n' && isspace(*useragent))
1502 p = strchr(p, '\n');
1509 redir_type = REDIR_NONE;
1510 if (av_match_ext(filename, "asx")) {
1511 redir_type = REDIR_ASX;
1512 filename[strlen(filename)-1] = 'f';
1513 } else if (av_match_ext(filename, "asf") &&
1514 (!useragent || strncasecmp(useragent, "NSPlayer", 8) != 0)) {
1515 /* if this isn't WMP or lookalike, return the redirector file */
1516 redir_type = REDIR_ASF;
1517 } else if (av_match_ext(filename, "rpm,ram")) {
1518 redir_type = REDIR_RAM;
1519 strcpy(filename + strlen(filename)-2, "m");
1520 } else if (av_match_ext(filename, "rtsp")) {
1521 redir_type = REDIR_RTSP;
1522 compute_real_filename(filename, sizeof(filename) - 1);
1523 } else if (av_match_ext(filename, "sdp")) {
1524 redir_type = REDIR_SDP;
1525 compute_real_filename(filename, sizeof(filename) - 1);
1528 // "redirect" / request to index.html
1529 if (!strlen(filename))
1530 av_strlcpy(filename, "index.html", sizeof(filename) - 1);
1532 stream = first_stream;
1533 while (stream != NULL) {
1534 if (!strcmp(stream->filename, filename) && validate_acl(stream, c))
1536 stream = stream->next;
1538 if (stream == NULL) {
1539 snprintf(msg, sizeof(msg), "File '%s' not found", url);
1540 http_log("File '%s' not found\n", url);
1545 memcpy(c->feed_streams, stream->feed_streams, sizeof(c->feed_streams));
1546 memset(c->switch_feed_streams, -1, sizeof(c->switch_feed_streams));
1548 if (stream->stream_type == STREAM_TYPE_REDIRECT) {
1549 c->http_error = 301;
1551 q += snprintf(q, c->buffer_size,
1552 "HTTP/1.0 301 Moved\r\n"
1554 "Content-type: text/html\r\n"
1556 "<html><head><title>Moved</title></head><body>\r\n"
1557 "You should be <a href=\"%s\">redirected</a>.\r\n"
1558 "</body></html>\r\n", stream->feed_filename, stream->feed_filename);
1559 /* prepare output buffer */
1560 c->buffer_ptr = c->buffer;
1562 c->state = HTTPSTATE_SEND_HEADER;
1566 /* If this is WMP, get the rate information */
1567 if (extract_rates(ratebuf, sizeof(ratebuf), c->buffer)) {
1568 if (modify_current_stream(c, ratebuf)) {
1569 for (i = 0; i < FF_ARRAY_ELEMS(c->feed_streams); i++) {
1570 if (c->switch_feed_streams[i] >= 0)
1571 c->switch_feed_streams[i] = -1;
1576 if (c->post == 0 && stream->stream_type == STREAM_TYPE_LIVE)
1577 current_bandwidth += stream->bandwidth;
1579 /* If already streaming this feed, do not let start another feeder. */
1580 if (stream->feed_opened) {
1581 snprintf(msg, sizeof(msg), "This feed is already being received.");
1582 http_log("Feed '%s' already being received\n", stream->feed_filename);
1586 if (c->post == 0 && max_bandwidth < current_bandwidth) {
1587 c->http_error = 503;
1589 q += snprintf(q, c->buffer_size,
1590 "HTTP/1.0 503 Server too busy\r\n"
1591 "Content-type: text/html\r\n"
1593 "<html><head><title>Too busy</title></head><body>\r\n"
1594 "<p>The server is too busy to serve your request at this time.</p>\r\n"
1595 "<p>The bandwidth being served (including your stream) is %"PRIu64"kbit/sec, "
1596 "and this exceeds the limit of %"PRIu64"kbit/sec.</p>\r\n"
1597 "</body></html>\r\n", current_bandwidth, max_bandwidth);
1598 /* prepare output buffer */
1599 c->buffer_ptr = c->buffer;
1601 c->state = HTTPSTATE_SEND_HEADER;
1605 if (redir_type != REDIR_NONE) {
1608 for (p = c->buffer; *p && *p != '\r' && *p != '\n'; ) {
1609 if (strncasecmp(p, "Host:", 5) == 0) {
1613 p = strchr(p, '\n');
1624 while (isspace(*hostinfo))
1627 eoh = strchr(hostinfo, '\n');
1629 if (eoh[-1] == '\r')
1632 if (eoh - hostinfo < sizeof(hostbuf) - 1) {
1633 memcpy(hostbuf, hostinfo, eoh - hostinfo);
1634 hostbuf[eoh - hostinfo] = 0;
1636 c->http_error = 200;
1638 switch(redir_type) {
1640 q += snprintf(q, c->buffer_size,
1641 "HTTP/1.0 200 ASX Follows\r\n"
1642 "Content-type: video/x-ms-asf\r\n"
1644 "<ASX Version=\"3\">\r\n"
1645 //"<!-- Autogenerated by ffserver -->\r\n"
1646 "<ENTRY><REF HREF=\"http://%s/%s%s\"/></ENTRY>\r\n"
1647 "</ASX>\r\n", hostbuf, filename, info);
1650 q += snprintf(q, c->buffer_size,
1651 "HTTP/1.0 200 RAM Follows\r\n"
1652 "Content-type: audio/x-pn-realaudio\r\n"
1654 "# Autogenerated by ffserver\r\n"
1655 "http://%s/%s%s\r\n", hostbuf, filename, info);
1658 q += snprintf(q, c->buffer_size,
1659 "HTTP/1.0 200 ASF Redirect follows\r\n"
1660 "Content-type: video/x-ms-asf\r\n"
1663 "Ref1=http://%s/%s%s\r\n", hostbuf, filename, info);
1667 char hostname[256], *p;
1668 /* extract only hostname */
1669 av_strlcpy(hostname, hostbuf, sizeof(hostname));
1670 p = strrchr(hostname, ':');
1673 q += snprintf(q, c->buffer_size,
1674 "HTTP/1.0 200 RTSP Redirect follows\r\n"
1675 /* XXX: incorrect mime type ? */
1676 "Content-type: application/x-rtsp\r\n"
1678 "rtsp://%s:%d/%s\r\n", hostname, ntohs(my_rtsp_addr.sin_port), filename);
1684 int sdp_data_size, len;
1685 struct sockaddr_in my_addr;
1687 q += snprintf(q, c->buffer_size,
1688 "HTTP/1.0 200 OK\r\n"
1689 "Content-type: application/sdp\r\n"
1692 len = sizeof(my_addr);
1693 getsockname(c->fd, (struct sockaddr *)&my_addr, &len);
1695 /* XXX: should use a dynamic buffer */
1696 sdp_data_size = prepare_sdp_description(stream,
1699 if (sdp_data_size > 0) {
1700 memcpy(q, sdp_data, sdp_data_size);
1712 /* prepare output buffer */
1713 c->buffer_ptr = c->buffer;
1715 c->state = HTTPSTATE_SEND_HEADER;
1721 snprintf(msg, sizeof(msg), "ASX/RAM file not handled");
1725 stream->conns_served++;
1727 /* XXX: add there authenticate and IP match */
1730 /* if post, it means a feed is being sent */
1731 if (!stream->is_feed) {
1732 /* However it might be a status report from WMP! Let us log the
1733 * data as it might come in handy one day. */
1737 for (p = c->buffer; *p && *p != '\r' && *p != '\n'; ) {
1738 if (strncasecmp(p, "Pragma: log-line=", 17) == 0) {
1742 if (strncasecmp(p, "Pragma: client-id=", 18) == 0)
1743 client_id = strtol(p + 18, 0, 10);
1744 p = strchr(p, '\n');
1752 char *eol = strchr(logline, '\n');
1757 if (eol[-1] == '\r')
1759 http_log("%.*s\n", (int) (eol - logline), logline);
1760 c->suppress_log = 1;
1765 http_log("\nGot request:\n%s\n", c->buffer);
1768 if (client_id && extract_rates(ratebuf, sizeof(ratebuf), c->buffer)) {
1771 /* Now we have to find the client_id */
1772 for (wmpc = first_http_ctx; wmpc; wmpc = wmpc->next) {
1773 if (wmpc->wmp_client_id == client_id)
1777 if (wmpc && modify_current_stream(wmpc, ratebuf))
1778 wmpc->switch_pending = 1;
1781 snprintf(msg, sizeof(msg), "POST command not handled");
1785 if (http_start_receive_data(c) < 0) {
1786 snprintf(msg, sizeof(msg), "could not open feed");
1790 c->state = HTTPSTATE_RECEIVE_DATA;
1795 if (strcmp(stream->filename + strlen(stream->filename) - 4, ".asf") == 0)
1796 http_log("\nGot request:\n%s\n", c->buffer);
1799 if (c->stream->stream_type == STREAM_TYPE_STATUS)
1802 /* open input stream */
1803 if (open_input_stream(c, info) < 0) {
1804 snprintf(msg, sizeof(msg), "Input stream corresponding to '%s' not found", url);
1808 /* prepare http header */
1810 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "HTTP/1.0 200 OK\r\n");
1811 mime_type = c->stream->fmt->mime_type;
1813 mime_type = "application/x-octet-stream";
1814 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "Pragma: no-cache\r\n");
1816 /* for asf, we need extra headers */
1817 if (!strcmp(c->stream->fmt->name,"asf_stream")) {
1818 /* Need to allocate a client id */
1820 c->wmp_client_id = av_lfg_get(&random_state);
1822 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "Server: Cougar 4.1.0.3923\r\nCache-Control: no-cache\r\nPragma: client-id=%d\r\nPragma: features=\"broadcast\"\r\n", c->wmp_client_id);
1824 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "Content-Type: %s\r\n", mime_type);
1825 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "\r\n");
1827 /* prepare output buffer */
1829 c->buffer_ptr = c->buffer;
1831 c->state = HTTPSTATE_SEND_HEADER;
1834 c->http_error = 404;
1836 q += snprintf(q, c->buffer_size,
1837 "HTTP/1.0 404 Not Found\r\n"
1838 "Content-type: text/html\r\n"
1841 "<head><title>404 Not Found</title></head>\n"
1844 /* prepare output buffer */
1845 c->buffer_ptr = c->buffer;
1847 c->state = HTTPSTATE_SEND_HEADER;
1851 c->http_error = 200; /* horrible : we use this value to avoid
1852 going to the send data state */
1853 c->state = HTTPSTATE_SEND_HEADER;
1857 static void fmt_bytecount(AVIOContext *pb, int64_t count)
1859 static const char *suffix = " kMGTP";
1862 for (s = suffix; count >= 100000 && s[1]; count /= 1000, s++);
1864 avio_printf(pb, "%"PRId64"%c", count, *s);
1867 static void compute_status(HTTPContext *c)
1876 if (avio_open_dyn_buf(&pb) < 0) {
1877 /* XXX: return an error ? */
1878 c->buffer_ptr = c->buffer;
1879 c->buffer_end = c->buffer;
1883 avio_printf(pb, "HTTP/1.0 200 OK\r\n");
1884 avio_printf(pb, "Content-type: %s\r\n", "text/html");
1885 avio_printf(pb, "Pragma: no-cache\r\n");
1886 avio_printf(pb, "\r\n");
1888 avio_printf(pb, "<html><head><title>%s Status</title>\n", program_name);
1889 if (c->stream->feed_filename[0])
1890 avio_printf(pb, "<link rel=\"shortcut icon\" href=\"%s\">\n", c->stream->feed_filename);
1891 avio_printf(pb, "</head>\n<body>");
1892 avio_printf(pb, "<h1>%s Status</h1>\n", program_name);
1894 avio_printf(pb, "<h2>Available Streams</h2>\n");
1895 avio_printf(pb, "<table cellspacing=0 cellpadding=4>\n");
1896 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");
1897 stream = first_stream;
1898 while (stream != NULL) {
1899 char sfilename[1024];
1902 if (stream->feed != stream) {
1903 av_strlcpy(sfilename, stream->filename, sizeof(sfilename) - 10);
1904 eosf = sfilename + strlen(sfilename);
1905 if (eosf - sfilename >= 4) {
1906 if (strcmp(eosf - 4, ".asf") == 0)
1907 strcpy(eosf - 4, ".asx");
1908 else if (strcmp(eosf - 3, ".rm") == 0)
1909 strcpy(eosf - 3, ".ram");
1910 else if (stream->fmt && !strcmp(stream->fmt->name, "rtp")) {
1911 /* generate a sample RTSP director if
1912 unicast. Generate an SDP redirector if
1914 eosf = strrchr(sfilename, '.');
1916 eosf = sfilename + strlen(sfilename);
1917 if (stream->is_multicast)
1918 strcpy(eosf, ".sdp");
1920 strcpy(eosf, ".rtsp");
1924 avio_printf(pb, "<tr><td><a href=\"/%s\">%s</a> ",
1925 sfilename, stream->filename);
1926 avio_printf(pb, "<td align=right> %d <td align=right> ",
1927 stream->conns_served);
1928 fmt_bytecount(pb, stream->bytes_served);
1929 switch(stream->stream_type) {
1930 case STREAM_TYPE_LIVE: {
1931 int audio_bit_rate = 0;
1932 int video_bit_rate = 0;
1933 const char *audio_codec_name = "";
1934 const char *video_codec_name = "";
1935 const char *audio_codec_name_extra = "";
1936 const char *video_codec_name_extra = "";
1938 for(i=0;i<stream->nb_streams;i++) {
1939 AVStream *st = stream->streams[i];
1940 AVCodec *codec = avcodec_find_encoder(st->codec->codec_id);
1941 switch(st->codec->codec_type) {
1942 case AVMEDIA_TYPE_AUDIO:
1943 audio_bit_rate += st->codec->bit_rate;
1945 if (*audio_codec_name)
1946 audio_codec_name_extra = "...";
1947 audio_codec_name = codec->name;
1950 case AVMEDIA_TYPE_VIDEO:
1951 video_bit_rate += st->codec->bit_rate;
1953 if (*video_codec_name)
1954 video_codec_name_extra = "...";
1955 video_codec_name = codec->name;
1958 case AVMEDIA_TYPE_DATA:
1959 video_bit_rate += st->codec->bit_rate;
1965 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",
1968 video_bit_rate / 1000, video_codec_name, video_codec_name_extra,
1969 audio_bit_rate / 1000, audio_codec_name, audio_codec_name_extra);
1971 avio_printf(pb, "<td>%s", stream->feed->filename);
1973 avio_printf(pb, "<td>%s", stream->feed_filename);
1974 avio_printf(pb, "\n");
1978 avio_printf(pb, "<td align=center> - <td align=right> - <td align=right> - <td><td align=right> - <td>\n");
1982 stream = stream->next;
1984 avio_printf(pb, "</table>\n");
1986 stream = first_stream;
1987 while (stream != NULL) {
1988 if (stream->feed == stream) {
1989 avio_printf(pb, "<h2>Feed %s</h2>", stream->filename);
1991 avio_printf(pb, "Running as pid %d.\n", stream->pid);
1993 #if defined(linux) && !defined(CONFIG_NOCUTILS)
1998 /* This is somewhat linux specific I guess */
1999 snprintf(ps_cmd, sizeof(ps_cmd),
2000 "ps -o \"%%cpu,cputime\" --no-headers %d",
2003 pid_stat = popen(ps_cmd, "r");
2008 if (fscanf(pid_stat, "%10s %64s", cpuperc,
2010 avio_printf(pb, "Currently using %s%% of the cpu. Total time used %s.\n",
2018 avio_printf(pb, "<p>");
2020 avio_printf(pb, "<table cellspacing=0 cellpadding=4><tr><th>Stream<th>type<th>kbits/s<th align=left>codec<th align=left>Parameters\n");
2022 for (i = 0; i < stream->nb_streams; i++) {
2023 AVStream *st = stream->streams[i];
2024 AVCodec *codec = avcodec_find_encoder(st->codec->codec_id);
2025 const char *type = "unknown";
2026 char parameters[64];
2030 switch(st->codec->codec_type) {
2031 case AVMEDIA_TYPE_AUDIO:
2033 snprintf(parameters, sizeof(parameters), "%d channel(s), %d Hz", st->codec->channels, st->codec->sample_rate);
2035 case AVMEDIA_TYPE_VIDEO:
2037 snprintf(parameters, sizeof(parameters), "%dx%d, q=%d-%d, fps=%d", st->codec->width, st->codec->height,
2038 st->codec->qmin, st->codec->qmax, st->codec->time_base.den / st->codec->time_base.num);
2043 avio_printf(pb, "<tr><td align=right>%d<td>%s<td align=right>%d<td>%s<td>%s\n",
2044 i, type, st->codec->bit_rate/1000, codec ? codec->name : "", parameters);
2046 avio_printf(pb, "</table>\n");
2049 stream = stream->next;
2052 /* connection status */
2053 avio_printf(pb, "<h2>Connection Status</h2>\n");
2055 avio_printf(pb, "Number of connections: %d / %d<br>\n",
2056 nb_connections, nb_max_connections);
2058 avio_printf(pb, "Bandwidth in use: %"PRIu64"k / %"PRIu64"k<br>\n",
2059 current_bandwidth, max_bandwidth);
2061 avio_printf(pb, "<table>\n");
2062 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");
2063 c1 = first_http_ctx;
2065 while (c1 != NULL) {
2071 for (j = 0; j < c1->stream->nb_streams; j++) {
2072 if (!c1->stream->feed)
2073 bitrate += c1->stream->streams[j]->codec->bit_rate;
2074 else if (c1->feed_streams[j] >= 0)
2075 bitrate += c1->stream->feed->streams[c1->feed_streams[j]]->codec->bit_rate;
2080 p = inet_ntoa(c1->from_addr.sin_addr);
2081 avio_printf(pb, "<tr><td><b>%d</b><td>%s%s<td>%s<td>%s<td>%s<td align=right>",
2083 c1->stream ? c1->stream->filename : "",
2084 c1->state == HTTPSTATE_RECEIVE_DATA ? "(input)" : "",
2087 http_state[c1->state]);
2088 fmt_bytecount(pb, bitrate);
2089 avio_printf(pb, "<td align=right>");
2090 fmt_bytecount(pb, compute_datarate(&c1->datarate, c1->data_count) * 8);
2091 avio_printf(pb, "<td align=right>");
2092 fmt_bytecount(pb, c1->data_count);
2093 avio_printf(pb, "\n");
2096 avio_printf(pb, "</table>\n");
2101 avio_printf(pb, "<hr size=1 noshade>Generated at %s", p);
2102 avio_printf(pb, "</body>\n</html>\n");
2104 len = avio_close_dyn_buf(pb, &c->pb_buffer);
2105 c->buffer_ptr = c->pb_buffer;
2106 c->buffer_end = c->pb_buffer + len;
2109 /* check if the parser needs to be opened for stream i */
2110 static void open_parser(AVFormatContext *s, int i)
2112 AVStream *st = s->streams[i];
2115 if (!st->codec->codec) {
2116 codec = avcodec_find_decoder(st->codec->codec_id);
2117 if (codec && (codec->capabilities & CODEC_CAP_PARSE_ONLY)) {
2118 st->codec->parse_only = 1;
2119 if (avcodec_open(st->codec, codec) < 0)
2120 st->codec->parse_only = 0;
2125 static int open_input_stream(HTTPContext *c, const char *info)
2128 char input_filename[1024];
2129 AVFormatContext *s = NULL;
2130 int buf_size, i, ret;
2133 /* find file name */
2134 if (c->stream->feed) {
2135 strcpy(input_filename, c->stream->feed->feed_filename);
2136 buf_size = FFM_PACKET_SIZE;
2137 /* compute position (absolute time) */
2138 if (av_find_info_tag(buf, sizeof(buf), "date", info)) {
2139 if ((ret = av_parse_time(&stream_pos, buf, 0)) < 0)
2141 } else if (av_find_info_tag(buf, sizeof(buf), "buffer", info)) {
2142 int prebuffer = strtol(buf, 0, 10);
2143 stream_pos = av_gettime() - prebuffer * (int64_t)1000000;
2145 stream_pos = av_gettime() - c->stream->prebuffer * (int64_t)1000;
2147 strcpy(input_filename, c->stream->feed_filename);
2149 /* compute position (relative time) */
2150 if (av_find_info_tag(buf, sizeof(buf), "date", info)) {
2151 if ((ret = av_parse_time(&stream_pos, buf, 1)) < 0)
2156 if (input_filename[0] == '\0')
2160 if ((ret = avformat_open_input(&s, input_filename, c->stream->ifmt, &c->stream->in_opts)) < 0) {
2161 http_log("could not open %s: %d\n", input_filename, ret);
2164 s->flags |= AVFMT_FLAG_GENPTS;
2166 if (strcmp(s->iformat->name, "ffm") && av_find_stream_info(c->fmt_in) < 0) {
2167 http_log("Could not find stream info '%s'\n", input_filename);
2168 av_close_input_file(s);
2172 /* open each parser */
2173 for(i=0;i<s->nb_streams;i++)
2176 /* choose stream as clock source (we favorize video stream if
2177 present) for packet sending */
2178 c->pts_stream_index = 0;
2179 for(i=0;i<c->stream->nb_streams;i++) {
2180 if (c->pts_stream_index == 0 &&
2181 c->stream->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2182 c->pts_stream_index = i;
2186 if (c->fmt_in->iformat->read_seek)
2187 av_seek_frame(c->fmt_in, -1, stream_pos, 0);
2188 /* set the start time (needed for maxtime and RTP packet timing) */
2189 c->start_time = cur_time;
2190 c->first_pts = AV_NOPTS_VALUE;
2194 /* return the server clock (in us) */
2195 static int64_t get_server_clock(HTTPContext *c)
2197 /* compute current pts value from system time */
2198 return (cur_time - c->start_time) * 1000;
2201 /* return the estimated time at which the current packet must be sent
2203 static int64_t get_packet_send_clock(HTTPContext *c)
2205 int bytes_left, bytes_sent, frame_bytes;
2207 frame_bytes = c->cur_frame_bytes;
2208 if (frame_bytes <= 0)
2211 bytes_left = c->buffer_end - c->buffer_ptr;
2212 bytes_sent = frame_bytes - bytes_left;
2213 return c->cur_pts + (c->cur_frame_duration * bytes_sent) / frame_bytes;
2218 static int http_prepare_data(HTTPContext *c)
2221 AVFormatContext *ctx;
2223 av_freep(&c->pb_buffer);
2225 case HTTPSTATE_SEND_DATA_HEADER:
2226 memset(&c->fmt_ctx, 0, sizeof(c->fmt_ctx));
2227 av_dict_set(&c->fmt_ctx.metadata, "author" , c->stream->author , 0);
2228 av_dict_set(&c->fmt_ctx.metadata, "comment" , c->stream->comment , 0);
2229 av_dict_set(&c->fmt_ctx.metadata, "copyright", c->stream->copyright, 0);
2230 av_dict_set(&c->fmt_ctx.metadata, "title" , c->stream->title , 0);
2232 c->fmt_ctx.streams = av_mallocz(sizeof(AVStream *) * c->stream->nb_streams);
2234 for(i=0;i<c->stream->nb_streams;i++) {
2236 c->fmt_ctx.streams[i] = av_mallocz(sizeof(AVStream));
2237 /* if file or feed, then just take streams from FFStream struct */
2238 if (!c->stream->feed ||
2239 c->stream->feed == c->stream)
2240 src = c->stream->streams[i];
2242 src = c->stream->feed->streams[c->stream->feed_streams[i]];
2244 *(c->fmt_ctx.streams[i]) = *src;
2245 c->fmt_ctx.streams[i]->priv_data = 0;
2246 c->fmt_ctx.streams[i]->codec->frame_number = 0; /* XXX: should be done in
2247 AVStream, not in codec */
2249 /* set output format parameters */
2250 c->fmt_ctx.oformat = c->stream->fmt;
2251 c->fmt_ctx.nb_streams = c->stream->nb_streams;
2253 c->got_key_frame = 0;
2255 /* prepare header and save header data in a stream */
2256 if (avio_open_dyn_buf(&c->fmt_ctx.pb) < 0) {
2257 /* XXX: potential leak */
2260 c->fmt_ctx.pb->seekable = 0;
2263 * HACK to avoid mpeg ps muxer to spit many underflow errors
2264 * Default value from Libav
2265 * Try to set it use configuration option
2267 c->fmt_ctx.preload = (int)(0.5*AV_TIME_BASE);
2268 c->fmt_ctx.max_delay = (int)(0.7*AV_TIME_BASE);
2270 if (avformat_write_header(&c->fmt_ctx, NULL) < 0) {
2271 http_log("Error writing output header\n");
2274 av_dict_free(&c->fmt_ctx.metadata);
2276 len = avio_close_dyn_buf(c->fmt_ctx.pb, &c->pb_buffer);
2277 c->buffer_ptr = c->pb_buffer;
2278 c->buffer_end = c->pb_buffer + len;
2280 c->state = HTTPSTATE_SEND_DATA;
2281 c->last_packet_sent = 0;
2283 case HTTPSTATE_SEND_DATA:
2284 /* find a new packet */
2285 /* read a packet from the input stream */
2286 if (c->stream->feed)
2287 ffm_set_write_index(c->fmt_in,
2288 c->stream->feed->feed_write_index,
2289 c->stream->feed->feed_size);
2291 if (c->stream->max_time &&
2292 c->stream->max_time + c->start_time - cur_time < 0)
2293 /* We have timed out */
2294 c->state = HTTPSTATE_SEND_DATA_TRAILER;
2298 ret = av_read_frame(c->fmt_in, &pkt);
2300 if (c->stream->feed) {
2301 /* if coming from feed, it means we reached the end of the
2302 ffm file, so must wait for more data */
2303 c->state = HTTPSTATE_WAIT_FEED;
2304 return 1; /* state changed */
2305 } else if (ret == AVERROR(EAGAIN)) {
2306 /* input not ready, come back later */
2309 if (c->stream->loop) {
2310 av_close_input_file(c->fmt_in);
2312 if (open_input_stream(c, "") < 0)
2317 /* must send trailer now because eof or error */
2318 c->state = HTTPSTATE_SEND_DATA_TRAILER;
2322 int source_index = pkt.stream_index;
2323 /* update first pts if needed */
2324 if (c->first_pts == AV_NOPTS_VALUE) {
2325 c->first_pts = av_rescale_q(pkt.dts, c->fmt_in->streams[pkt.stream_index]->time_base, AV_TIME_BASE_Q);
2326 c->start_time = cur_time;
2328 /* send it to the appropriate stream */
2329 if (c->stream->feed) {
2330 /* if coming from a feed, select the right stream */
2331 if (c->switch_pending) {
2332 c->switch_pending = 0;
2333 for(i=0;i<c->stream->nb_streams;i++) {
2334 if (c->switch_feed_streams[i] == pkt.stream_index)
2335 if (pkt.flags & AV_PKT_FLAG_KEY)
2336 c->switch_feed_streams[i] = -1;
2337 if (c->switch_feed_streams[i] >= 0)
2338 c->switch_pending = 1;
2341 for(i=0;i<c->stream->nb_streams;i++) {
2342 if (c->stream->feed_streams[i] == pkt.stream_index) {
2343 AVStream *st = c->fmt_in->streams[source_index];
2344 pkt.stream_index = i;
2345 if (pkt.flags & AV_PKT_FLAG_KEY &&
2346 (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2347 c->stream->nb_streams == 1))
2348 c->got_key_frame = 1;
2349 if (!c->stream->send_on_key || c->got_key_frame)
2354 AVCodecContext *codec;
2355 AVStream *ist, *ost;
2357 ist = c->fmt_in->streams[source_index];
2358 /* specific handling for RTP: we use several
2359 output stream (one for each RTP
2360 connection). XXX: need more abstract handling */
2361 if (c->is_packetized) {
2362 /* compute send time and duration */
2363 c->cur_pts = av_rescale_q(pkt.dts, ist->time_base, AV_TIME_BASE_Q);
2364 c->cur_pts -= c->first_pts;
2365 c->cur_frame_duration = av_rescale_q(pkt.duration, ist->time_base, AV_TIME_BASE_Q);
2366 /* find RTP context */
2367 c->packet_stream_index = pkt.stream_index;
2368 ctx = c->rtp_ctx[c->packet_stream_index];
2370 av_free_packet(&pkt);
2373 codec = ctx->streams[0]->codec;
2374 /* only one stream per RTP connection */
2375 pkt.stream_index = 0;
2379 codec = ctx->streams[pkt.stream_index]->codec;
2382 if (c->is_packetized) {
2383 int max_packet_size;
2384 if (c->rtp_protocol == RTSP_LOWER_TRANSPORT_TCP)
2385 max_packet_size = RTSP_TCP_MAX_PACKET_SIZE;
2387 max_packet_size = url_get_max_packet_size(c->rtp_handles[c->packet_stream_index]);
2388 ret = ffio_open_dyn_packet_buf(&ctx->pb, max_packet_size);
2390 ret = avio_open_dyn_buf(&ctx->pb);
2393 /* XXX: potential leak */
2396 ost = ctx->streams[pkt.stream_index];
2398 ctx->pb->seekable = 0;
2399 if (pkt.dts != AV_NOPTS_VALUE)
2400 pkt.dts = av_rescale_q(pkt.dts, ist->time_base, ost->time_base);
2401 if (pkt.pts != AV_NOPTS_VALUE)
2402 pkt.pts = av_rescale_q(pkt.pts, ist->time_base, ost->time_base);
2403 pkt.duration = av_rescale_q(pkt.duration, ist->time_base, ost->time_base);
2404 if (av_write_frame(ctx, &pkt) < 0) {
2405 http_log("Error writing frame to output\n");
2406 c->state = HTTPSTATE_SEND_DATA_TRAILER;
2409 len = avio_close_dyn_buf(ctx->pb, &c->pb_buffer);
2410 c->cur_frame_bytes = len;
2411 c->buffer_ptr = c->pb_buffer;
2412 c->buffer_end = c->pb_buffer + len;
2414 codec->frame_number++;
2416 av_free_packet(&pkt);
2420 av_free_packet(&pkt);
2425 case HTTPSTATE_SEND_DATA_TRAILER:
2426 /* last packet test ? */
2427 if (c->last_packet_sent || c->is_packetized)
2430 /* prepare header */
2431 if (avio_open_dyn_buf(&ctx->pb) < 0) {
2432 /* XXX: potential leak */
2435 c->fmt_ctx.pb->seekable = 0;
2436 av_write_trailer(ctx);
2437 len = avio_close_dyn_buf(ctx->pb, &c->pb_buffer);
2438 c->buffer_ptr = c->pb_buffer;
2439 c->buffer_end = c->pb_buffer + len;
2441 c->last_packet_sent = 1;
2447 /* should convert the format at the same time */
2448 /* send data starting at c->buffer_ptr to the output connection
2449 (either UDP or TCP connection) */
2450 static int http_send_data(HTTPContext *c)
2455 if (c->buffer_ptr >= c->buffer_end) {
2456 ret = http_prepare_data(c);
2460 /* state change requested */
2463 if (c->is_packetized) {
2464 /* RTP data output */
2465 len = c->buffer_end - c->buffer_ptr;
2467 /* fail safe - should never happen */
2469 c->buffer_ptr = c->buffer_end;
2472 len = (c->buffer_ptr[0] << 24) |
2473 (c->buffer_ptr[1] << 16) |
2474 (c->buffer_ptr[2] << 8) |
2476 if (len > (c->buffer_end - c->buffer_ptr))
2478 if ((get_packet_send_clock(c) - get_server_clock(c)) > 0) {
2479 /* nothing to send yet: we can wait */
2483 c->data_count += len;
2484 update_datarate(&c->datarate, c->data_count);
2486 c->stream->bytes_served += len;
2488 if (c->rtp_protocol == RTSP_LOWER_TRANSPORT_TCP) {
2489 /* RTP packets are sent inside the RTSP TCP connection */
2491 int interleaved_index, size;
2493 HTTPContext *rtsp_c;
2496 /* if no RTSP connection left, error */
2499 /* if already sending something, then wait. */
2500 if (rtsp_c->state != RTSPSTATE_WAIT_REQUEST)
2502 if (avio_open_dyn_buf(&pb) < 0)
2504 interleaved_index = c->packet_stream_index * 2;
2505 /* RTCP packets are sent at odd indexes */
2506 if (c->buffer_ptr[1] == 200)
2507 interleaved_index++;
2508 /* write RTSP TCP header */
2510 header[1] = interleaved_index;
2511 header[2] = len >> 8;
2513 avio_write(pb, header, 4);
2514 /* write RTP packet data */
2516 avio_write(pb, c->buffer_ptr, len);
2517 size = avio_close_dyn_buf(pb, &c->packet_buffer);
2518 /* prepare asynchronous TCP sending */
2519 rtsp_c->packet_buffer_ptr = c->packet_buffer;
2520 rtsp_c->packet_buffer_end = c->packet_buffer + size;
2521 c->buffer_ptr += len;
2523 /* send everything we can NOW */
2524 len = send(rtsp_c->fd, rtsp_c->packet_buffer_ptr,
2525 rtsp_c->packet_buffer_end - rtsp_c->packet_buffer_ptr, 0);
2527 rtsp_c->packet_buffer_ptr += len;
2528 if (rtsp_c->packet_buffer_ptr < rtsp_c->packet_buffer_end) {
2529 /* if we could not send all the data, we will
2530 send it later, so a new state is needed to
2531 "lock" the RTSP TCP connection */
2532 rtsp_c->state = RTSPSTATE_SEND_PACKET;
2535 /* all data has been sent */
2536 av_freep(&c->packet_buffer);
2538 /* send RTP packet directly in UDP */
2540 url_write(c->rtp_handles[c->packet_stream_index],
2541 c->buffer_ptr, len);
2542 c->buffer_ptr += len;
2543 /* here we continue as we can send several packets per 10 ms slot */
2546 /* TCP data output */
2547 len = send(c->fd, c->buffer_ptr, c->buffer_end - c->buffer_ptr, 0);
2549 if (ff_neterrno() != AVERROR(EAGAIN) &&
2550 ff_neterrno() != AVERROR(EINTR))
2551 /* error : close connection */
2556 c->buffer_ptr += len;
2558 c->data_count += len;
2559 update_datarate(&c->datarate, c->data_count);
2561 c->stream->bytes_served += len;
2569 static int http_start_receive_data(HTTPContext *c)
2573 if (c->stream->feed_opened)
2576 /* Don't permit writing to this one */
2577 if (c->stream->readonly)
2581 fd = open(c->stream->feed_filename, O_RDWR);
2583 http_log("Error opening feeder file: %s\n", strerror(errno));
2588 if (c->stream->truncate) {
2589 /* truncate feed file */
2590 ffm_write_write_index(c->feed_fd, FFM_PACKET_SIZE);
2591 ftruncate(c->feed_fd, FFM_PACKET_SIZE);
2592 http_log("Truncating feed file '%s'\n", c->stream->feed_filename);
2594 if ((c->stream->feed_write_index = ffm_read_write_index(fd)) < 0) {
2595 http_log("Error reading write index from feed file: %s\n", strerror(errno));
2600 c->stream->feed_write_index = FFMAX(ffm_read_write_index(fd), FFM_PACKET_SIZE);
2601 c->stream->feed_size = lseek(fd, 0, SEEK_END);
2602 lseek(fd, 0, SEEK_SET);
2604 /* init buffer input */
2605 c->buffer_ptr = c->buffer;
2606 c->buffer_end = c->buffer + FFM_PACKET_SIZE;
2607 c->stream->feed_opened = 1;
2608 c->chunked_encoding = !!av_stristr(c->buffer, "Transfer-Encoding: chunked");
2612 static int http_receive_data(HTTPContext *c)
2615 int len, loop_run = 0;
2617 while (c->chunked_encoding && !c->chunk_size &&
2618 c->buffer_end > c->buffer_ptr) {
2619 /* read chunk header, if present */
2620 len = recv(c->fd, c->buffer_ptr, 1, 0);
2623 if (ff_neterrno() != AVERROR(EAGAIN) &&
2624 ff_neterrno() != AVERROR(EINTR))
2625 /* error : close connection */
2628 } else if (len == 0) {
2629 /* end of connection : close it */
2631 } else if (c->buffer_ptr - c->buffer >= 2 &&
2632 !memcmp(c->buffer_ptr - 1, "\r\n", 2)) {
2633 c->chunk_size = strtol(c->buffer, 0, 16);
2634 if (c->chunk_size == 0) // end of stream
2636 c->buffer_ptr = c->buffer;
2638 } else if (++loop_run > 10) {
2639 /* no chunk header, abort */
2646 if (c->buffer_end > c->buffer_ptr) {
2647 len = recv(c->fd, c->buffer_ptr,
2648 FFMIN(c->chunk_size, c->buffer_end - c->buffer_ptr), 0);
2650 if (ff_neterrno() != AVERROR(EAGAIN) &&
2651 ff_neterrno() != AVERROR(EINTR))
2652 /* error : close connection */
2654 } else if (len == 0)
2655 /* end of connection : close it */
2658 c->chunk_size -= len;
2659 c->buffer_ptr += len;
2660 c->data_count += len;
2661 update_datarate(&c->datarate, c->data_count);
2665 if (c->buffer_ptr - c->buffer >= 2 && c->data_count > FFM_PACKET_SIZE) {
2666 if (c->buffer[0] != 'f' ||
2667 c->buffer[1] != 'm') {
2668 http_log("Feed stream has become desynchronized -- disconnecting\n");
2673 if (c->buffer_ptr >= c->buffer_end) {
2674 FFStream *feed = c->stream;
2675 /* a packet has been received : write it in the store, except
2677 if (c->data_count > FFM_PACKET_SIZE) {
2679 // printf("writing pos=0x%"PRIx64" size=0x%"PRIx64"\n", feed->feed_write_index, feed->feed_size);
2680 /* XXX: use llseek or url_seek */
2681 lseek(c->feed_fd, feed->feed_write_index, SEEK_SET);
2682 if (write(c->feed_fd, c->buffer, FFM_PACKET_SIZE) < 0) {
2683 http_log("Error writing to feed file: %s\n", strerror(errno));
2687 feed->feed_write_index += FFM_PACKET_SIZE;
2688 /* update file size */
2689 if (feed->feed_write_index > c->stream->feed_size)
2690 feed->feed_size = feed->feed_write_index;
2692 /* handle wrap around if max file size reached */
2693 if (c->stream->feed_max_size && feed->feed_write_index >= c->stream->feed_max_size)
2694 feed->feed_write_index = FFM_PACKET_SIZE;
2697 if (ffm_write_write_index(c->feed_fd, feed->feed_write_index) < 0) {
2698 http_log("Error writing index to feed file: %s\n", strerror(errno));
2702 /* wake up any waiting connections */
2703 for(c1 = first_http_ctx; c1 != NULL; c1 = c1->next) {
2704 if (c1->state == HTTPSTATE_WAIT_FEED &&
2705 c1->stream->feed == c->stream->feed)
2706 c1->state = HTTPSTATE_SEND_DATA;
2709 /* We have a header in our hands that contains useful data */
2710 AVFormatContext *s = avformat_alloc_context();
2712 AVInputFormat *fmt_in;
2718 /* use feed output format name to find corresponding input format */
2719 fmt_in = av_find_input_format(feed->fmt->name);
2723 pb = avio_alloc_context(c->buffer, c->buffer_end - c->buffer,
2724 0, NULL, NULL, NULL, NULL);
2728 if (avformat_open_input(&s, c->stream->feed_filename, fmt_in, NULL) < 0) {
2733 /* Now we have the actual streams */
2734 if (s->nb_streams != feed->nb_streams) {
2735 av_close_input_stream(s);
2737 http_log("Feed '%s' stream number does not match registered feed\n",
2738 c->stream->feed_filename);
2742 for (i = 0; i < s->nb_streams; i++) {
2743 AVStream *fst = feed->streams[i];
2744 AVStream *st = s->streams[i];
2745 avcodec_copy_context(fst->codec, st->codec);
2748 av_close_input_stream(s);
2751 c->buffer_ptr = c->buffer;
2756 c->stream->feed_opened = 0;
2758 /* wake up any waiting connections to stop waiting for feed */
2759 for(c1 = first_http_ctx; c1 != NULL; c1 = c1->next) {
2760 if (c1->state == HTTPSTATE_WAIT_FEED &&
2761 c1->stream->feed == c->stream->feed)
2762 c1->state = HTTPSTATE_SEND_DATA_TRAILER;
2767 /********************************************************************/
2770 static void rtsp_reply_header(HTTPContext *c, enum RTSPStatusCode error_number)
2777 switch(error_number) {
2778 case RTSP_STATUS_OK:
2781 case RTSP_STATUS_METHOD:
2782 str = "Method Not Allowed";
2784 case RTSP_STATUS_BANDWIDTH:
2785 str = "Not Enough Bandwidth";
2787 case RTSP_STATUS_SESSION:
2788 str = "Session Not Found";
2790 case RTSP_STATUS_STATE:
2791 str = "Method Not Valid in This State";
2793 case RTSP_STATUS_AGGREGATE:
2794 str = "Aggregate operation not allowed";
2796 case RTSP_STATUS_ONLY_AGGREGATE:
2797 str = "Only aggregate operation allowed";
2799 case RTSP_STATUS_TRANSPORT:
2800 str = "Unsupported transport";
2802 case RTSP_STATUS_INTERNAL:
2803 str = "Internal Server Error";
2805 case RTSP_STATUS_SERVICE:
2806 str = "Service Unavailable";
2808 case RTSP_STATUS_VERSION:
2809 str = "RTSP Version not supported";
2812 str = "Unknown Error";
2816 avio_printf(c->pb, "RTSP/1.0 %d %s\r\n", error_number, str);
2817 avio_printf(c->pb, "CSeq: %d\r\n", c->seq);
2819 /* output GMT time */
2822 strftime(buf2, sizeof(buf2), "%a, %d %b %Y %H:%M:%S", tm);
2823 avio_printf(c->pb, "Date: %s GMT\r\n", buf2);
2826 static void rtsp_reply_error(HTTPContext *c, enum RTSPStatusCode error_number)
2828 rtsp_reply_header(c, error_number);
2829 avio_printf(c->pb, "\r\n");
2832 static int rtsp_parse_request(HTTPContext *c)
2834 const char *p, *p1, *p2;
2840 RTSPMessageHeader header1, *header = &header1;
2842 c->buffer_ptr[0] = '\0';
2845 get_word(cmd, sizeof(cmd), &p);
2846 get_word(url, sizeof(url), &p);
2847 get_word(protocol, sizeof(protocol), &p);
2849 av_strlcpy(c->method, cmd, sizeof(c->method));
2850 av_strlcpy(c->url, url, sizeof(c->url));
2851 av_strlcpy(c->protocol, protocol, sizeof(c->protocol));
2853 if (avio_open_dyn_buf(&c->pb) < 0) {
2854 /* XXX: cannot do more */
2855 c->pb = NULL; /* safety */
2859 /* check version name */
2860 if (strcmp(protocol, "RTSP/1.0") != 0) {
2861 rtsp_reply_error(c, RTSP_STATUS_VERSION);
2865 /* parse each header line */
2866 memset(header, 0, sizeof(*header));
2867 /* skip to next line */
2868 while (*p != '\n' && *p != '\0')
2872 while (*p != '\0') {
2873 p1 = memchr(p, '\n', (char *)c->buffer_ptr - p);
2877 if (p2 > p && p2[-1] == '\r')
2879 /* skip empty line */
2883 if (len > sizeof(line) - 1)
2884 len = sizeof(line) - 1;
2885 memcpy(line, p, len);
2887 ff_rtsp_parse_line(header, line, NULL, NULL);
2891 /* handle sequence number */
2892 c->seq = header->seq;
2894 if (!strcmp(cmd, "DESCRIBE"))
2895 rtsp_cmd_describe(c, url);
2896 else if (!strcmp(cmd, "OPTIONS"))
2897 rtsp_cmd_options(c, url);
2898 else if (!strcmp(cmd, "SETUP"))
2899 rtsp_cmd_setup(c, url, header);
2900 else if (!strcmp(cmd, "PLAY"))
2901 rtsp_cmd_play(c, url, header);
2902 else if (!strcmp(cmd, "PAUSE"))
2903 rtsp_cmd_pause(c, url, header);
2904 else if (!strcmp(cmd, "TEARDOWN"))
2905 rtsp_cmd_teardown(c, url, header);
2907 rtsp_reply_error(c, RTSP_STATUS_METHOD);
2910 len = avio_close_dyn_buf(c->pb, &c->pb_buffer);
2911 c->pb = NULL; /* safety */
2913 /* XXX: cannot do more */
2916 c->buffer_ptr = c->pb_buffer;
2917 c->buffer_end = c->pb_buffer + len;
2918 c->state = RTSPSTATE_SEND_REPLY;
2922 static int prepare_sdp_description(FFStream *stream, uint8_t **pbuffer,
2923 struct in_addr my_ip)
2925 AVFormatContext *avc;
2926 AVStream *avs = NULL;
2929 avc = avformat_alloc_context();
2933 av_dict_set(&avc->metadata, "title",
2934 stream->title[0] ? stream->title : "No Title", 0);
2935 avc->nb_streams = stream->nb_streams;
2936 if (stream->is_multicast) {
2937 snprintf(avc->filename, 1024, "rtp://%s:%d?multicast=1?ttl=%d",
2938 inet_ntoa(stream->multicast_ip),
2939 stream->multicast_port, stream->multicast_ttl);
2941 snprintf(avc->filename, 1024, "rtp://0.0.0.0");
2944 if (avc->nb_streams >= INT_MAX/sizeof(*avc->streams) ||
2945 !(avc->streams = av_malloc(avc->nb_streams * sizeof(*avc->streams))))
2947 if (avc->nb_streams >= INT_MAX/sizeof(*avs) ||
2948 !(avs = av_malloc(avc->nb_streams * sizeof(*avs))))
2951 for(i = 0; i < stream->nb_streams; i++) {
2952 avc->streams[i] = &avs[i];
2953 avc->streams[i]->codec = stream->streams[i]->codec;
2955 *pbuffer = av_mallocz(2048);
2956 av_sdp_create(&avc, 1, *pbuffer, 2048);
2959 av_free(avc->streams);
2960 av_dict_free(&avc->metadata);
2964 return strlen(*pbuffer);
2967 static void rtsp_cmd_options(HTTPContext *c, const char *url)
2969 // rtsp_reply_header(c, RTSP_STATUS_OK);
2970 avio_printf(c->pb, "RTSP/1.0 %d %s\r\n", RTSP_STATUS_OK, "OK");
2971 avio_printf(c->pb, "CSeq: %d\r\n", c->seq);
2972 avio_printf(c->pb, "Public: %s\r\n", "OPTIONS, DESCRIBE, SETUP, TEARDOWN, PLAY, PAUSE");
2973 avio_printf(c->pb, "\r\n");
2976 static void rtsp_cmd_describe(HTTPContext *c, const char *url)
2982 int content_length, len;
2983 struct sockaddr_in my_addr;
2985 /* find which url is asked */
2986 av_url_split(NULL, 0, NULL, 0, NULL, 0, NULL, path1, sizeof(path1), url);
2991 for(stream = first_stream; stream != NULL; stream = stream->next) {
2992 if (!stream->is_feed &&
2993 stream->fmt && !strcmp(stream->fmt->name, "rtp") &&
2994 !strcmp(path, stream->filename)) {
2998 /* no stream found */
2999 rtsp_reply_error(c, RTSP_STATUS_SERVICE); /* XXX: right error ? */
3003 /* prepare the media description in sdp format */
3005 /* get the host IP */
3006 len = sizeof(my_addr);
3007 getsockname(c->fd, (struct sockaddr *)&my_addr, &len);
3008 content_length = prepare_sdp_description(stream, &content, my_addr.sin_addr);
3009 if (content_length < 0) {
3010 rtsp_reply_error(c, RTSP_STATUS_INTERNAL);
3013 rtsp_reply_header(c, RTSP_STATUS_OK);
3014 avio_printf(c->pb, "Content-Base: %s/\r\n", url);
3015 avio_printf(c->pb, "Content-Type: application/sdp\r\n");
3016 avio_printf(c->pb, "Content-Length: %d\r\n", content_length);
3017 avio_printf(c->pb, "\r\n");
3018 avio_write(c->pb, content, content_length);
3022 static HTTPContext *find_rtp_session(const char *session_id)
3026 if (session_id[0] == '\0')
3029 for(c = first_http_ctx; c != NULL; c = c->next) {
3030 if (!strcmp(c->session_id, session_id))
3036 static RTSPTransportField *find_transport(RTSPMessageHeader *h, enum RTSPLowerTransport lower_transport)
3038 RTSPTransportField *th;
3041 for(i=0;i<h->nb_transports;i++) {
3042 th = &h->transports[i];
3043 if (th->lower_transport == lower_transport)
3049 static void rtsp_cmd_setup(HTTPContext *c, const char *url,
3050 RTSPMessageHeader *h)
3053 int stream_index, rtp_port, rtcp_port;
3058 RTSPTransportField *th;
3059 struct sockaddr_in dest_addr;
3060 RTSPActionServerSetup setup;
3062 /* find which url is asked */
3063 av_url_split(NULL, 0, NULL, 0, NULL, 0, NULL, path1, sizeof(path1), url);
3068 /* now check each stream */
3069 for(stream = first_stream; stream != NULL; stream = stream->next) {
3070 if (!stream->is_feed &&
3071 stream->fmt && !strcmp(stream->fmt->name, "rtp")) {
3072 /* accept aggregate filenames only if single stream */
3073 if (!strcmp(path, stream->filename)) {
3074 if (stream->nb_streams != 1) {
3075 rtsp_reply_error(c, RTSP_STATUS_AGGREGATE);
3082 for(stream_index = 0; stream_index < stream->nb_streams;
3084 snprintf(buf, sizeof(buf), "%s/streamid=%d",
3085 stream->filename, stream_index);
3086 if (!strcmp(path, buf))
3091 /* no stream found */
3092 rtsp_reply_error(c, RTSP_STATUS_SERVICE); /* XXX: right error ? */
3096 /* generate session id if needed */
3097 if (h->session_id[0] == '\0')
3098 snprintf(h->session_id, sizeof(h->session_id), "%08x%08x",
3099 av_lfg_get(&random_state), av_lfg_get(&random_state));
3101 /* find rtp session, and create it if none found */
3102 rtp_c = find_rtp_session(h->session_id);
3104 /* always prefer UDP */
3105 th = find_transport(h, RTSP_LOWER_TRANSPORT_UDP);
3107 th = find_transport(h, RTSP_LOWER_TRANSPORT_TCP);
3109 rtsp_reply_error(c, RTSP_STATUS_TRANSPORT);
3114 rtp_c = rtp_new_connection(&c->from_addr, stream, h->session_id,
3115 th->lower_transport);
3117 rtsp_reply_error(c, RTSP_STATUS_BANDWIDTH);
3121 /* open input stream */
3122 if (open_input_stream(rtp_c, "") < 0) {
3123 rtsp_reply_error(c, RTSP_STATUS_INTERNAL);
3128 /* test if stream is OK (test needed because several SETUP needs
3129 to be done for a given file) */
3130 if (rtp_c->stream != stream) {
3131 rtsp_reply_error(c, RTSP_STATUS_SERVICE);
3135 /* test if stream is already set up */
3136 if (rtp_c->rtp_ctx[stream_index]) {
3137 rtsp_reply_error(c, RTSP_STATUS_STATE);
3141 /* check transport */
3142 th = find_transport(h, rtp_c->rtp_protocol);
3143 if (!th || (th->lower_transport == RTSP_LOWER_TRANSPORT_UDP &&
3144 th->client_port_min <= 0)) {
3145 rtsp_reply_error(c, RTSP_STATUS_TRANSPORT);
3149 /* setup default options */
3150 setup.transport_option[0] = '\0';
3151 dest_addr = rtp_c->from_addr;
3152 dest_addr.sin_port = htons(th->client_port_min);
3155 if (rtp_new_av_stream(rtp_c, stream_index, &dest_addr, c) < 0) {
3156 rtsp_reply_error(c, RTSP_STATUS_TRANSPORT);
3160 /* now everything is OK, so we can send the connection parameters */
3161 rtsp_reply_header(c, RTSP_STATUS_OK);
3163 avio_printf(c->pb, "Session: %s\r\n", rtp_c->session_id);
3165 switch(rtp_c->rtp_protocol) {
3166 case RTSP_LOWER_TRANSPORT_UDP:
3167 rtp_port = rtp_get_local_rtp_port(rtp_c->rtp_handles[stream_index]);
3168 rtcp_port = rtp_get_local_rtcp_port(rtp_c->rtp_handles[stream_index]);
3169 avio_printf(c->pb, "Transport: RTP/AVP/UDP;unicast;"
3170 "client_port=%d-%d;server_port=%d-%d",
3171 th->client_port_min, th->client_port_max,
3172 rtp_port, rtcp_port);
3174 case RTSP_LOWER_TRANSPORT_TCP:
3175 avio_printf(c->pb, "Transport: RTP/AVP/TCP;interleaved=%d-%d",
3176 stream_index * 2, stream_index * 2 + 1);
3181 if (setup.transport_option[0] != '\0')
3182 avio_printf(c->pb, ";%s", setup.transport_option);
3183 avio_printf(c->pb, "\r\n");
3186 avio_printf(c->pb, "\r\n");
3190 /* find an rtp connection by using the session ID. Check consistency
3192 static HTTPContext *find_rtp_session_with_url(const char *url,
3193 const char *session_id)
3201 rtp_c = find_rtp_session(session_id);
3205 /* find which url is asked */
3206 av_url_split(NULL, 0, NULL, 0, NULL, 0, NULL, path1, sizeof(path1), url);
3210 if(!strcmp(path, rtp_c->stream->filename)) return rtp_c;
3211 for(s=0; s<rtp_c->stream->nb_streams; ++s) {
3212 snprintf(buf, sizeof(buf), "%s/streamid=%d",
3213 rtp_c->stream->filename, s);
3214 if(!strncmp(path, buf, sizeof(buf))) {
3215 // XXX: Should we reply with RTSP_STATUS_ONLY_AGGREGATE if nb_streams>1?
3220 if (len > 0 && path[len - 1] == '/' &&
3221 !strncmp(path, rtp_c->stream->filename, len - 1))
3226 static void rtsp_cmd_play(HTTPContext *c, const char *url, RTSPMessageHeader *h)
3230 rtp_c = find_rtp_session_with_url(url, h->session_id);
3232 rtsp_reply_error(c, RTSP_STATUS_SESSION);
3236 if (rtp_c->state != HTTPSTATE_SEND_DATA &&
3237 rtp_c->state != HTTPSTATE_WAIT_FEED &&
3238 rtp_c->state != HTTPSTATE_READY) {
3239 rtsp_reply_error(c, RTSP_STATUS_STATE);
3243 rtp_c->state = HTTPSTATE_SEND_DATA;
3245 /* now everything is OK, so we can send the connection parameters */
3246 rtsp_reply_header(c, RTSP_STATUS_OK);
3248 avio_printf(c->pb, "Session: %s\r\n", rtp_c->session_id);
3249 avio_printf(c->pb, "\r\n");
3252 static void rtsp_cmd_pause(HTTPContext *c, const char *url, RTSPMessageHeader *h)
3256 rtp_c = find_rtp_session_with_url(url, h->session_id);
3258 rtsp_reply_error(c, RTSP_STATUS_SESSION);
3262 if (rtp_c->state != HTTPSTATE_SEND_DATA &&
3263 rtp_c->state != HTTPSTATE_WAIT_FEED) {
3264 rtsp_reply_error(c, RTSP_STATUS_STATE);
3268 rtp_c->state = HTTPSTATE_READY;
3269 rtp_c->first_pts = AV_NOPTS_VALUE;
3270 /* now everything is OK, so we can send the connection parameters */
3271 rtsp_reply_header(c, RTSP_STATUS_OK);
3273 avio_printf(c->pb, "Session: %s\r\n", rtp_c->session_id);
3274 avio_printf(c->pb, "\r\n");
3277 static void rtsp_cmd_teardown(HTTPContext *c, const char *url, RTSPMessageHeader *h)
3281 rtp_c = find_rtp_session_with_url(url, h->session_id);
3283 rtsp_reply_error(c, RTSP_STATUS_SESSION);
3287 /* now everything is OK, so we can send the connection parameters */
3288 rtsp_reply_header(c, RTSP_STATUS_OK);
3290 avio_printf(c->pb, "Session: %s\r\n", rtp_c->session_id);
3291 avio_printf(c->pb, "\r\n");
3293 /* abort the session */
3294 close_connection(rtp_c);
3298 /********************************************************************/
3301 static HTTPContext *rtp_new_connection(struct sockaddr_in *from_addr,
3302 FFStream *stream, const char *session_id,
3303 enum RTSPLowerTransport rtp_protocol)
3305 HTTPContext *c = NULL;
3306 const char *proto_str;
3308 /* XXX: should output a warning page when coming
3309 close to the connection limit */
3310 if (nb_connections >= nb_max_connections)
3313 /* add a new connection */
3314 c = av_mallocz(sizeof(HTTPContext));
3319 c->poll_entry = NULL;
3320 c->from_addr = *from_addr;
3321 c->buffer_size = IOBUFFER_INIT_SIZE;
3322 c->buffer = av_malloc(c->buffer_size);
3327 av_strlcpy(c->session_id, session_id, sizeof(c->session_id));
3328 c->state = HTTPSTATE_READY;
3329 c->is_packetized = 1;
3330 c->rtp_protocol = rtp_protocol;
3332 /* protocol is shown in statistics */
3333 switch(c->rtp_protocol) {
3334 case RTSP_LOWER_TRANSPORT_UDP_MULTICAST:
3335 proto_str = "MCAST";
3337 case RTSP_LOWER_TRANSPORT_UDP:
3340 case RTSP_LOWER_TRANSPORT_TCP:
3347 av_strlcpy(c->protocol, "RTP/", sizeof(c->protocol));
3348 av_strlcat(c->protocol, proto_str, sizeof(c->protocol));
3350 current_bandwidth += stream->bandwidth;
3352 c->next = first_http_ctx;
3364 /* add a new RTP stream in an RTP connection (used in RTSP SETUP
3365 command). If RTP/TCP protocol is used, TCP connection 'rtsp_c' is
3367 static int rtp_new_av_stream(HTTPContext *c,
3368 int stream_index, struct sockaddr_in *dest_addr,
3369 HTTPContext *rtsp_c)
3371 AVFormatContext *ctx;
3374 URLContext *h = NULL;
3376 int max_packet_size;
3378 /* now we can open the relevant output stream */
3379 ctx = avformat_alloc_context();
3382 ctx->oformat = av_guess_format("rtp", NULL, NULL);
3384 st = av_mallocz(sizeof(AVStream));
3387 ctx->nb_streams = 1;
3388 ctx->streams = av_mallocz(sizeof(AVStream *) * ctx->nb_streams);
3391 ctx->streams[0] = st;
3393 if (!c->stream->feed ||
3394 c->stream->feed == c->stream)
3395 memcpy(st, c->stream->streams[stream_index], sizeof(AVStream));
3398 c->stream->feed->streams[c->stream->feed_streams[stream_index]],
3400 st->priv_data = NULL;
3402 /* build destination RTP address */
3403 ipaddr = inet_ntoa(dest_addr->sin_addr);
3405 switch(c->rtp_protocol) {
3406 case RTSP_LOWER_TRANSPORT_UDP:
3407 case RTSP_LOWER_TRANSPORT_UDP_MULTICAST:
3410 /* XXX: also pass as parameter to function ? */
3411 if (c->stream->is_multicast) {
3413 ttl = c->stream->multicast_ttl;
3416 snprintf(ctx->filename, sizeof(ctx->filename),
3417 "rtp://%s:%d?multicast=1&ttl=%d",
3418 ipaddr, ntohs(dest_addr->sin_port), ttl);
3420 snprintf(ctx->filename, sizeof(ctx->filename),
3421 "rtp://%s:%d", ipaddr, ntohs(dest_addr->sin_port));
3424 if (url_open(&h, ctx->filename, AVIO_FLAG_WRITE) < 0)
3426 c->rtp_handles[stream_index] = h;
3427 max_packet_size = url_get_max_packet_size(h);
3429 case RTSP_LOWER_TRANSPORT_TCP:
3432 max_packet_size = RTSP_TCP_MAX_PACKET_SIZE;
3438 http_log("%s:%d - - \"PLAY %s/streamid=%d %s\"\n",
3439 ipaddr, ntohs(dest_addr->sin_port),
3440 c->stream->filename, stream_index, c->protocol);
3442 /* normally, no packets should be output here, but the packet size may be checked */
3443 if (ffio_open_dyn_packet_buf(&ctx->pb, max_packet_size) < 0) {
3444 /* XXX: close stream */
3447 if (avformat_write_header(ctx, NULL) < 0) {
3454 avio_close_dyn_buf(ctx->pb, &dummy_buf);
3457 c->rtp_ctx[stream_index] = ctx;
3461 /********************************************************************/
3462 /* ffserver initialization */
3464 static AVStream *add_av_stream1(FFStream *stream, AVCodecContext *codec, int copy)
3468 fst = av_mallocz(sizeof(AVStream));
3472 fst->codec= avcodec_alloc_context();
3473 memcpy(fst->codec, codec, sizeof(AVCodecContext));
3474 if (codec->extradata_size) {
3475 fst->codec->extradata = av_malloc(codec->extradata_size);
3476 memcpy(fst->codec->extradata, codec->extradata,
3477 codec->extradata_size);
3480 /* live streams must use the actual feed's codec since it may be
3481 * updated later to carry extradata needed by the streams.
3485 fst->priv_data = av_mallocz(sizeof(FeedData));
3486 fst->index = stream->nb_streams;
3487 av_set_pts_info(fst, 33, 1, 90000);
3488 fst->sample_aspect_ratio = codec->sample_aspect_ratio;
3489 stream->streams[stream->nb_streams++] = fst;
3493 /* return the stream number in the feed */
3494 static int add_av_stream(FFStream *feed, AVStream *st)
3497 AVCodecContext *av, *av1;
3501 for(i=0;i<feed->nb_streams;i++) {
3502 st = feed->streams[i];
3504 if (av1->codec_id == av->codec_id &&
3505 av1->codec_type == av->codec_type &&
3506 av1->bit_rate == av->bit_rate) {
3508 switch(av->codec_type) {
3509 case AVMEDIA_TYPE_AUDIO:
3510 if (av1->channels == av->channels &&
3511 av1->sample_rate == av->sample_rate)
3514 case AVMEDIA_TYPE_VIDEO:
3515 if (av1->width == av->width &&
3516 av1->height == av->height &&
3517 av1->time_base.den == av->time_base.den &&
3518 av1->time_base.num == av->time_base.num &&
3519 av1->gop_size == av->gop_size)
3528 fst = add_av_stream1(feed, av, 0);
3531 return feed->nb_streams - 1;
3536 static void remove_stream(FFStream *stream)
3540 while (*ps != NULL) {
3548 /* specific mpeg4 handling : we extract the raw parameters */
3549 static void extract_mpeg4_header(AVFormatContext *infile)
3551 int mpeg4_count, i, size;
3557 for(i=0;i<infile->nb_streams;i++) {
3558 st = infile->streams[i];
3559 if (st->codec->codec_id == CODEC_ID_MPEG4 &&
3560 st->codec->extradata_size == 0) {
3567 printf("MPEG4 without extra data: trying to find header in %s\n", infile->filename);
3568 while (mpeg4_count > 0) {
3569 if (av_read_packet(infile, &pkt) < 0)
3571 st = infile->streams[pkt.stream_index];
3572 if (st->codec->codec_id == CODEC_ID_MPEG4 &&
3573 st->codec->extradata_size == 0) {
3574 av_freep(&st->codec->extradata);
3575 /* fill extradata with the header */
3576 /* XXX: we make hard suppositions here ! */
3578 while (p < pkt.data + pkt.size - 4) {
3579 /* stop when vop header is found */
3580 if (p[0] == 0x00 && p[1] == 0x00 &&
3581 p[2] == 0x01 && p[3] == 0xb6) {
3582 size = p - pkt.data;
3583 // av_hex_dump_log(infile, AV_LOG_DEBUG, pkt.data, size);
3584 st->codec->extradata = av_malloc(size);
3585 st->codec->extradata_size = size;
3586 memcpy(st->codec->extradata, pkt.data, size);
3593 av_free_packet(&pkt);
3597 /* compute the needed AVStream for each file */
3598 static void build_file_streams(void)
3600 FFStream *stream, *stream_next;
3603 /* gather all streams */
3604 for(stream = first_stream; stream != NULL; stream = stream_next) {
3605 AVFormatContext *infile = NULL;
3606 stream_next = stream->next;
3607 if (stream->stream_type == STREAM_TYPE_LIVE &&
3609 /* the stream comes from a file */
3610 /* try to open the file */
3612 if (stream->fmt && !strcmp(stream->fmt->name, "rtp")) {
3613 /* specific case : if transport stream output to RTP,
3614 we use a raw transport stream reader */
3615 av_dict_set(&stream->in_opts, "mpeg2ts_compute_pcr", "1", 0);
3618 http_log("Opening file '%s'\n", stream->feed_filename);
3619 if ((ret = avformat_open_input(&infile, stream->feed_filename, stream->ifmt, &stream->in_opts)) < 0) {
3620 http_log("Could not open '%s': %d\n", stream->feed_filename, ret);
3621 /* remove stream (no need to spend more time on it) */
3623 remove_stream(stream);
3625 /* find all the AVStreams inside and reference them in
3627 if (av_find_stream_info(infile) < 0) {
3628 http_log("Could not find codec parameters from '%s'\n",
3629 stream->feed_filename);
3630 av_close_input_file(infile);
3633 extract_mpeg4_header(infile);
3635 for(i=0;i<infile->nb_streams;i++)
3636 add_av_stream1(stream, infile->streams[i]->codec, 1);
3638 av_close_input_file(infile);
3644 /* compute the needed AVStream for each feed */
3645 static void build_feed_streams(void)
3647 FFStream *stream, *feed;
3650 /* gather all streams */
3651 for(stream = first_stream; stream != NULL; stream = stream->next) {
3652 feed = stream->feed;
3654 if (!stream->is_feed) {
3655 /* we handle a stream coming from a feed */
3656 for(i=0;i<stream->nb_streams;i++)
3657 stream->feed_streams[i] = add_av_stream(feed, stream->streams[i]);
3662 /* gather all streams */
3663 for(stream = first_stream; stream != NULL; stream = stream->next) {
3664 feed = stream->feed;
3666 if (stream->is_feed) {
3667 for(i=0;i<stream->nb_streams;i++)
3668 stream->feed_streams[i] = i;
3673 /* create feed files if needed */
3674 for(feed = first_feed; feed != NULL; feed = feed->next_feed) {
3677 if (avio_check(feed->feed_filename, AVIO_FLAG_READ) > 0) {
3678 /* See if it matches */
3679 AVFormatContext *s = NULL;
3682 if (avformat_open_input(&s, feed->feed_filename, NULL, NULL) >= 0) {
3683 /* Now see if it matches */
3684 if (s->nb_streams == feed->nb_streams) {
3686 for(i=0;i<s->nb_streams;i++) {
3688 sf = feed->streams[i];
3691 if (sf->index != ss->index ||
3693 http_log("Index & Id do not match for stream %d (%s)\n",
3694 i, feed->feed_filename);
3697 AVCodecContext *ccf, *ccs;
3701 #define CHECK_CODEC(x) (ccf->x != ccs->x)
3703 if (CHECK_CODEC(codec_id) || CHECK_CODEC(codec_type)) {
3704 http_log("Codecs do not match for stream %d\n", i);
3706 } else if (CHECK_CODEC(bit_rate) || CHECK_CODEC(flags)) {
3707 http_log("Codec bitrates do not match for stream %d\n", i);
3709 } else if (ccf->codec_type == AVMEDIA_TYPE_VIDEO) {
3710 if (CHECK_CODEC(time_base.den) ||
3711 CHECK_CODEC(time_base.num) ||
3712 CHECK_CODEC(width) ||
3713 CHECK_CODEC(height)) {
3714 http_log("Codec width, height and framerate do not match for stream %d\n", i);
3717 } else if (ccf->codec_type == AVMEDIA_TYPE_AUDIO) {
3718 if (CHECK_CODEC(sample_rate) ||
3719 CHECK_CODEC(channels) ||
3720 CHECK_CODEC(frame_size)) {
3721 http_log("Codec sample_rate, channels, frame_size do not match for stream %d\n", i);
3725 http_log("Unknown codec type\n");
3733 http_log("Deleting feed file '%s' as stream counts differ (%d != %d)\n",
3734 feed->feed_filename, s->nb_streams, feed->nb_streams);
3736 av_close_input_file(s);
3738 http_log("Deleting feed file '%s' as it appears to be corrupt\n",
3739 feed->feed_filename);
3742 if (feed->readonly) {
3743 http_log("Unable to delete feed file '%s' as it is marked readonly\n",
3744 feed->feed_filename);
3747 unlink(feed->feed_filename);
3750 if (avio_check(feed->feed_filename, AVIO_FLAG_WRITE) <= 0) {
3751 AVFormatContext s1 = {0}, *s = &s1;
3753 if (feed->readonly) {
3754 http_log("Unable to create feed file '%s' as it is marked readonly\n",
3755 feed->feed_filename);
3759 /* only write the header of the ffm file */
3760 if (avio_open(&s->pb, feed->feed_filename, AVIO_FLAG_WRITE) < 0) {
3761 http_log("Could not open output feed file '%s'\n",
3762 feed->feed_filename);
3765 s->oformat = feed->fmt;
3766 s->nb_streams = feed->nb_streams;
3767 s->streams = feed->streams;
3768 if (avformat_write_header(s, NULL) < 0) {
3769 http_log("Container doesn't supports the required parameters\n");
3772 /* XXX: need better api */
3773 av_freep(&s->priv_data);
3776 /* get feed size and write index */
3777 fd = open(feed->feed_filename, O_RDONLY);
3779 http_log("Could not open output feed file '%s'\n",
3780 feed->feed_filename);
3784 feed->feed_write_index = FFMAX(ffm_read_write_index(fd), FFM_PACKET_SIZE);
3785 feed->feed_size = lseek(fd, 0, SEEK_END);
3786 /* ensure that we do not wrap before the end of file */
3787 if (feed->feed_max_size && feed->feed_max_size < feed->feed_size)
3788 feed->feed_max_size = feed->feed_size;
3794 /* compute the bandwidth used by each stream */
3795 static void compute_bandwidth(void)
3801 for(stream = first_stream; stream != NULL; stream = stream->next) {
3803 for(i=0;i<stream->nb_streams;i++) {
3804 AVStream *st = stream->streams[i];
3805 switch(st->codec->codec_type) {
3806 case AVMEDIA_TYPE_AUDIO:
3807 case AVMEDIA_TYPE_VIDEO:
3808 bandwidth += st->codec->bit_rate;
3814 stream->bandwidth = (bandwidth + 999) / 1000;
3818 /* add a codec and set the default parameters */
3819 static void add_codec(FFStream *stream, AVCodecContext *av)
3823 /* compute default parameters */
3824 switch(av->codec_type) {
3825 case AVMEDIA_TYPE_AUDIO:
3826 if (av->bit_rate == 0)
3827 av->bit_rate = 64000;
3828 if (av->sample_rate == 0)
3829 av->sample_rate = 22050;
3830 if (av->channels == 0)
3833 case AVMEDIA_TYPE_VIDEO:
3834 if (av->bit_rate == 0)
3835 av->bit_rate = 64000;
3836 if (av->time_base.num == 0){
3837 av->time_base.den = 5;
3838 av->time_base.num = 1;
3840 if (av->width == 0 || av->height == 0) {
3844 /* Bitrate tolerance is less for streaming */
3845 if (av->bit_rate_tolerance == 0)
3846 av->bit_rate_tolerance = FFMAX(av->bit_rate / 4,
3847 (int64_t)av->bit_rate*av->time_base.num/av->time_base.den);
3852 if (av->max_qdiff == 0)
3854 av->qcompress = 0.5;
3857 if (!av->nsse_weight)
3858 av->nsse_weight = 8;
3860 av->frame_skip_cmp = FF_CMP_DCTMAX;
3862 av->me_method = ME_EPZS;
3863 av->rc_buffer_aggressivity = 1.0;
3866 av->rc_eq = "tex^qComp";
3867 if (!av->i_quant_factor)
3868 av->i_quant_factor = -0.8;
3869 if (!av->b_quant_factor)
3870 av->b_quant_factor = 1.25;
3871 if (!av->b_quant_offset)
3872 av->b_quant_offset = 1.25;
3873 if (!av->rc_max_rate)
3874 av->rc_max_rate = av->bit_rate * 2;
3876 if (av->rc_max_rate && !av->rc_buffer_size) {
3877 av->rc_buffer_size = av->rc_max_rate;
3886 st = av_mallocz(sizeof(AVStream));
3889 st->codec = avcodec_alloc_context();
3890 stream->streams[stream->nb_streams++] = st;
3891 memcpy(st->codec, av, sizeof(AVCodecContext));
3894 static enum CodecID opt_audio_codec(const char *arg)
3896 AVCodec *p= avcodec_find_encoder_by_name(arg);
3898 if (p == NULL || p->type != AVMEDIA_TYPE_AUDIO)
3899 return CODEC_ID_NONE;
3904 static enum CodecID opt_video_codec(const char *arg)
3906 AVCodec *p= avcodec_find_encoder_by_name(arg);
3908 if (p == NULL || p->type != AVMEDIA_TYPE_VIDEO)
3909 return CODEC_ID_NONE;
3914 /* simplistic plugin support */
3917 static void load_module(const char *filename)
3920 void (*init_func)(void);
3921 dll = dlopen(filename, RTLD_NOW);
3923 fprintf(stderr, "Could not load module '%s' - %s\n",
3924 filename, dlerror());
3928 init_func = dlsym(dll, "ffserver_module_init");
3931 "%s: init function 'ffserver_module_init()' not found\n",
3940 static int ffserver_opt_default(const char *opt, const char *arg,
3941 AVCodecContext *avctx, int type)
3944 const AVOption *o = av_opt_find(avctx, opt, NULL, type, 0);
3946 ret = av_set_string3(avctx, opt, arg, 1, NULL);
3950 static int ffserver_opt_preset(const char *arg,
3951 AVCodecContext *avctx, int type,
3952 enum CodecID *audio_id, enum CodecID *video_id)
3955 char filename[1000], tmp[1000], tmp2[1000], line[1000];
3957 AVCodec *codec = avcodec_find_encoder(avctx->codec_id);
3959 if (!(f = get_preset_file(filename, sizeof(filename), arg, 0,
3960 codec ? codec->name : NULL))) {
3961 fprintf(stderr, "File for preset '%s' not found\n", arg);
3966 int e= fscanf(f, "%999[^\n]\n", line) - 1;
3967 if(line[0] == '#' && !e)
3969 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
3971 fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
3975 if(!strcmp(tmp, "acodec")){
3976 *audio_id = opt_audio_codec(tmp2);
3977 }else if(!strcmp(tmp, "vcodec")){
3978 *video_id = opt_video_codec(tmp2);
3979 }else if(!strcmp(tmp, "scodec")){
3980 /* opt_subtitle_codec(tmp2); */
3981 }else if(ffserver_opt_default(tmp, tmp2, avctx, type) < 0){
3982 fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
3993 static AVOutputFormat *ffserver_guess_format(const char *short_name, const char *filename,
3994 const char *mime_type)
3996 AVOutputFormat *fmt = av_guess_format(short_name, filename, mime_type);
3999 AVOutputFormat *stream_fmt;
4000 char stream_format_name[64];
4002 snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
4003 stream_fmt = av_guess_format(stream_format_name, NULL, NULL);
4012 static void report_config_error(const char *filename, int line_num, int *errors, const char *fmt, ...)
4016 fprintf(stderr, "%s:%d: ", filename, line_num);
4017 vfprintf(stderr, fmt, vl);
4023 static int parse_ffconfig(const char *filename)
4030 int val, errors, line_num;
4031 FFStream **last_stream, *stream, *redirect;
4032 FFStream **last_feed, *feed, *s;
4033 AVCodecContext audio_enc, video_enc;
4034 enum CodecID audio_id, video_id;
4036 f = fopen(filename, "r");
4044 first_stream = NULL;
4045 last_stream = &first_stream;
4047 last_feed = &first_feed;
4051 audio_id = CODEC_ID_NONE;
4052 video_id = CODEC_ID_NONE;
4054 #define ERROR(...) report_config_error(filename, line_num, &errors, __VA_ARGS__)
4056 if (fgets(line, sizeof(line), f) == NULL)
4062 if (*p == '\0' || *p == '#')
4065 get_arg(cmd, sizeof(cmd), &p);
4067 if (!strcasecmp(cmd, "Port")) {
4068 get_arg(arg, sizeof(arg), &p);
4070 if (val < 1 || val > 65536) {
4071 ERROR("Invalid_port: %s\n", arg);
4073 my_http_addr.sin_port = htons(val);
4074 } else if (!strcasecmp(cmd, "BindAddress")) {
4075 get_arg(arg, sizeof(arg), &p);
4076 if (resolve_host(&my_http_addr.sin_addr, arg) != 0) {
4077 ERROR("%s:%d: Invalid host/IP address: %s\n", arg);
4079 } else if (!strcasecmp(cmd, "NoDaemon")) {
4080 ffserver_daemon = 0;
4081 } else if (!strcasecmp(cmd, "RTSPPort")) {
4082 get_arg(arg, sizeof(arg), &p);
4084 if (val < 1 || val > 65536) {
4085 ERROR("%s:%d: Invalid port: %s\n", arg);
4087 my_rtsp_addr.sin_port = htons(atoi(arg));
4088 } else if (!strcasecmp(cmd, "RTSPBindAddress")) {
4089 get_arg(arg, sizeof(arg), &p);
4090 if (resolve_host(&my_rtsp_addr.sin_addr, arg) != 0) {
4091 ERROR("Invalid host/IP address: %s\n", arg);
4093 } else if (!strcasecmp(cmd, "MaxHTTPConnections")) {
4094 get_arg(arg, sizeof(arg), &p);
4096 if (val < 1 || val > 65536) {
4097 ERROR("Invalid MaxHTTPConnections: %s\n", arg);
4099 nb_max_http_connections = val;
4100 } else if (!strcasecmp(cmd, "MaxClients")) {
4101 get_arg(arg, sizeof(arg), &p);
4103 if (val < 1 || val > nb_max_http_connections) {
4104 ERROR("Invalid MaxClients: %s\n", arg);
4106 nb_max_connections = val;
4108 } else if (!strcasecmp(cmd, "MaxBandwidth")) {
4110 get_arg(arg, sizeof(arg), &p);
4112 if (llval < 10 || llval > 10000000) {
4113 ERROR("Invalid MaxBandwidth: %s\n", arg);
4115 max_bandwidth = llval;
4116 } else if (!strcasecmp(cmd, "CustomLog")) {
4117 if (!ffserver_debug)
4118 get_arg(logfilename, sizeof(logfilename), &p);
4119 } else if (!strcasecmp(cmd, "<Feed")) {
4120 /*********************************************/
4121 /* Feed related options */
4123 if (stream || feed) {
4124 ERROR("Already in a tag\n");
4126 feed = av_mallocz(sizeof(FFStream));
4127 get_arg(feed->filename, sizeof(feed->filename), &p);
4128 q = strrchr(feed->filename, '>');
4132 for (s = first_feed; s; s = s->next) {
4133 if (!strcmp(feed->filename, s->filename)) {
4134 ERROR("Feed '%s' already registered\n", s->filename);
4138 feed->fmt = av_guess_format("ffm", NULL, NULL);
4139 /* defaut feed file */
4140 snprintf(feed->feed_filename, sizeof(feed->feed_filename),
4141 "/tmp/%s.ffm", feed->filename);
4142 feed->feed_max_size = 5 * 1024 * 1024;
4144 feed->feed = feed; /* self feeding :-) */
4146 /* add in stream list */
4147 *last_stream = feed;
4148 last_stream = &feed->next;
4149 /* add in feed list */
4151 last_feed = &feed->next_feed;
4153 } else if (!strcasecmp(cmd, "Launch")) {
4157 feed->child_argv = av_mallocz(64 * sizeof(char *));
4159 for (i = 0; i < 62; i++) {
4160 get_arg(arg, sizeof(arg), &p);
4164 feed->child_argv[i] = av_strdup(arg);
4167 feed->child_argv[i] = av_malloc(30 + strlen(feed->filename));
4169 snprintf(feed->child_argv[i], 30+strlen(feed->filename),
4171 (my_http_addr.sin_addr.s_addr == INADDR_ANY) ? "127.0.0.1" :
4172 inet_ntoa(my_http_addr.sin_addr),
4173 ntohs(my_http_addr.sin_port), feed->filename);
4175 } else if (!strcasecmp(cmd, "ReadOnlyFile")) {
4177 get_arg(feed->feed_filename, sizeof(feed->feed_filename), &p);
4179 } else if (stream) {
4180 get_arg(stream->feed_filename, sizeof(stream->feed_filename), &p);
4182 } else if (!strcasecmp(cmd, "File")) {
4184 get_arg(feed->feed_filename, sizeof(feed->feed_filename), &p);
4186 get_arg(stream->feed_filename, sizeof(stream->feed_filename), &p);
4187 } else if (!strcasecmp(cmd, "Truncate")) {
4189 get_arg(arg, sizeof(arg), &p);
4190 feed->truncate = strtod(arg, NULL);
4192 } else if (!strcasecmp(cmd, "FileMaxSize")) {
4197 get_arg(arg, sizeof(arg), &p);
4199 fsize = strtod(p1, &p1);
4200 switch(toupper(*p1)) {
4205 fsize *= 1024 * 1024;
4208 fsize *= 1024 * 1024 * 1024;
4211 feed->feed_max_size = (int64_t)fsize;
4212 if (feed->feed_max_size < FFM_PACKET_SIZE*4) {
4213 ERROR("Feed max file size is too small, must be at least %d\n", FFM_PACKET_SIZE*4);
4216 } else if (!strcasecmp(cmd, "</Feed>")) {
4218 ERROR("No corresponding <Feed> for </Feed>\n");
4221 } else if (!strcasecmp(cmd, "<Stream")) {
4222 /*********************************************/
4223 /* Stream related options */
4225 if (stream || feed) {
4226 ERROR("Already in a tag\n");
4229 stream = av_mallocz(sizeof(FFStream));
4230 get_arg(stream->filename, sizeof(stream->filename), &p);
4231 q = strrchr(stream->filename, '>');
4235 for (s = first_stream; s; s = s->next) {
4236 if (!strcmp(stream->filename, s->filename)) {
4237 ERROR("Stream '%s' already registered\n", s->filename);
4241 stream->fmt = ffserver_guess_format(NULL, stream->filename, NULL);
4242 avcodec_get_context_defaults2(&video_enc, AVMEDIA_TYPE_VIDEO);
4243 avcodec_get_context_defaults2(&audio_enc, AVMEDIA_TYPE_AUDIO);
4244 audio_id = CODEC_ID_NONE;
4245 video_id = CODEC_ID_NONE;
4247 audio_id = stream->fmt->audio_codec;
4248 video_id = stream->fmt->video_codec;
4251 *last_stream = stream;
4252 last_stream = &stream->next;
4254 } else if (!strcasecmp(cmd, "Feed")) {
4255 get_arg(arg, sizeof(arg), &p);
4260 while (sfeed != NULL) {
4261 if (!strcmp(sfeed->filename, arg))
4263 sfeed = sfeed->next_feed;
4266 ERROR("feed '%s' not defined\n", arg);
4268 stream->feed = sfeed;
4270 } else if (!strcasecmp(cmd, "Format")) {
4271 get_arg(arg, sizeof(arg), &p);
4273 if (!strcmp(arg, "status")) {
4274 stream->stream_type = STREAM_TYPE_STATUS;
4277 stream->stream_type = STREAM_TYPE_LIVE;
4278 /* jpeg cannot be used here, so use single frame jpeg */
4279 if (!strcmp(arg, "jpeg"))
4280 strcpy(arg, "mjpeg");
4281 stream->fmt = ffserver_guess_format(arg, NULL, NULL);
4283 ERROR("Unknown Format: %s\n", arg);
4287 audio_id = stream->fmt->audio_codec;
4288 video_id = stream->fmt->video_codec;
4291 } else if (!strcasecmp(cmd, "InputFormat")) {
4292 get_arg(arg, sizeof(arg), &p);
4294 stream->ifmt = av_find_input_format(arg);
4295 if (!stream->ifmt) {
4296 ERROR("Unknown input format: %s\n", arg);
4299 } else if (!strcasecmp(cmd, "FaviconURL")) {
4300 if (stream && stream->stream_type == STREAM_TYPE_STATUS) {
4301 get_arg(stream->feed_filename, sizeof(stream->feed_filename), &p);
4303 ERROR("FaviconURL only permitted for status streams\n");
4305 } else if (!strcasecmp(cmd, "Author")) {
4307 get_arg(stream->author, sizeof(stream->author), &p);
4308 } else if (!strcasecmp(cmd, "Comment")) {
4310 get_arg(stream->comment, sizeof(stream->comment), &p);
4311 } else if (!strcasecmp(cmd, "Copyright")) {
4313 get_arg(stream->copyright, sizeof(stream->copyright), &p);
4314 } else if (!strcasecmp(cmd, "Title")) {
4316 get_arg(stream->title, sizeof(stream->title), &p);
4317 } else if (!strcasecmp(cmd, "Preroll")) {
4318 get_arg(arg, sizeof(arg), &p);
4320 stream->prebuffer = atof(arg) * 1000;
4321 } else if (!strcasecmp(cmd, "StartSendOnKey")) {
4323 stream->send_on_key = 1;
4324 } else if (!strcasecmp(cmd, "AudioCodec")) {
4325 get_arg(arg, sizeof(arg), &p);
4326 audio_id = opt_audio_codec(arg);
4327 if (audio_id == CODEC_ID_NONE) {
4328 ERROR("Unknown AudioCodec: %s\n", arg);
4330 } else if (!strcasecmp(cmd, "VideoCodec")) {
4331 get_arg(arg, sizeof(arg), &p);
4332 video_id = opt_video_codec(arg);
4333 if (video_id == CODEC_ID_NONE) {
4334 ERROR("Unknown VideoCodec: %s\n", arg);
4336 } else if (!strcasecmp(cmd, "MaxTime")) {
4337 get_arg(arg, sizeof(arg), &p);
4339 stream->max_time = atof(arg) * 1000;
4340 } else if (!strcasecmp(cmd, "AudioBitRate")) {
4341 get_arg(arg, sizeof(arg), &p);
4343 audio_enc.bit_rate = lrintf(atof(arg) * 1000);
4344 } else if (!strcasecmp(cmd, "AudioChannels")) {
4345 get_arg(arg, sizeof(arg), &p);
4347 audio_enc.channels = atoi(arg);
4348 } else if (!strcasecmp(cmd, "AudioSampleRate")) {
4349 get_arg(arg, sizeof(arg), &p);
4351 audio_enc.sample_rate = atoi(arg);
4352 } else if (!strcasecmp(cmd, "AudioQuality")) {
4353 get_arg(arg, sizeof(arg), &p);
4355 // audio_enc.quality = atof(arg) * 1000;
4357 } else if (!strcasecmp(cmd, "VideoBitRateRange")) {
4359 int minrate, maxrate;
4361 get_arg(arg, sizeof(arg), &p);
4363 if (sscanf(arg, "%d-%d", &minrate, &maxrate) == 2) {
4364 video_enc.rc_min_rate = minrate * 1000;
4365 video_enc.rc_max_rate = maxrate * 1000;
4367 ERROR("Incorrect format for VideoBitRateRange -- should be <min>-<max>: %s\n", arg);
4370 } else if (!strcasecmp(cmd, "Debug")) {
4372 get_arg(arg, sizeof(arg), &p);
4373 video_enc.debug = strtol(arg,0,0);
4375 } else if (!strcasecmp(cmd, "Strict")) {
4377 get_arg(arg, sizeof(arg), &p);
4378 video_enc.strict_std_compliance = atoi(arg);
4380 } else if (!strcasecmp(cmd, "VideoBufferSize")) {
4382 get_arg(arg, sizeof(arg), &p);
4383 video_enc.rc_buffer_size = atoi(arg) * 8*1024;
4385 } else if (!strcasecmp(cmd, "VideoBitRateTolerance")) {
4387 get_arg(arg, sizeof(arg), &p);
4388 video_enc.bit_rate_tolerance = atoi(arg) * 1000;
4390 } else if (!strcasecmp(cmd, "VideoBitRate")) {
4391 get_arg(arg, sizeof(arg), &p);
4393 video_enc.bit_rate = atoi(arg) * 1000;
4395 } else if (!strcasecmp(cmd, "VideoSize")) {
4396 get_arg(arg, sizeof(arg), &p);
4398 av_parse_video_size(&video_enc.width, &video_enc.height, arg);
4399 if ((video_enc.width % 16) != 0 ||
4400 (video_enc.height % 16) != 0) {
4401 ERROR("Image size must be a multiple of 16\n");
4404 } else if (!strcasecmp(cmd, "VideoFrameRate")) {
4405 get_arg(arg, sizeof(arg), &p);
4407 AVRational frame_rate;
4408 if (av_parse_video_rate(&frame_rate, arg) < 0) {
4409 ERROR("Incorrect frame rate: %s\n", arg);
4411 video_enc.time_base.num = frame_rate.den;
4412 video_enc.time_base.den = frame_rate.num;
4415 } else if (!strcasecmp(cmd, "VideoGopSize")) {
4416 get_arg(arg, sizeof(arg), &p);
4418 video_enc.gop_size = atoi(arg);
4419 } else if (!strcasecmp(cmd, "VideoIntraOnly")) {
4421 video_enc.gop_size = 1;
4422 } else if (!strcasecmp(cmd, "VideoHighQuality")) {
4424 video_enc.mb_decision = FF_MB_DECISION_BITS;
4425 } else if (!strcasecmp(cmd, "Video4MotionVector")) {
4427 video_enc.mb_decision = FF_MB_DECISION_BITS; //FIXME remove
4428 video_enc.flags |= CODEC_FLAG_4MV;
4430 } else if (!strcasecmp(cmd, "AVOptionVideo") ||
4431 !strcasecmp(cmd, "AVOptionAudio")) {
4433 AVCodecContext *avctx;
4435 get_arg(arg, sizeof(arg), &p);
4436 get_arg(arg2, sizeof(arg2), &p);
4437 if (!strcasecmp(cmd, "AVOptionVideo")) {
4439 type = AV_OPT_FLAG_VIDEO_PARAM;
4442 type = AV_OPT_FLAG_AUDIO_PARAM;
4444 if (ffserver_opt_default(arg, arg2, avctx, type|AV_OPT_FLAG_ENCODING_PARAM)) {
4445 ERROR("AVOption error: %s %s\n", arg, arg2);
4447 } else if (!strcasecmp(cmd, "AVPresetVideo") ||
4448 !strcasecmp(cmd, "AVPresetAudio")) {
4449 AVCodecContext *avctx;
4451 get_arg(arg, sizeof(arg), &p);
4452 if (!strcasecmp(cmd, "AVPresetVideo")) {
4454 video_enc.codec_id = video_id;
4455 type = AV_OPT_FLAG_VIDEO_PARAM;
4458 audio_enc.codec_id = audio_id;
4459 type = AV_OPT_FLAG_AUDIO_PARAM;
4461 if (ffserver_opt_preset(arg, avctx, type|AV_OPT_FLAG_ENCODING_PARAM, &audio_id, &video_id)) {
4462 ERROR("AVPreset error: %s\n", arg);
4464 } else if (!strcasecmp(cmd, "VideoTag")) {
4465 get_arg(arg, sizeof(arg), &p);
4466 if ((strlen(arg) == 4) && stream)
4467 video_enc.codec_tag = MKTAG(arg[0], arg[1], arg[2], arg[3]);
4468 } else if (!strcasecmp(cmd, "BitExact")) {
4470 video_enc.flags |= CODEC_FLAG_BITEXACT;
4471 } else if (!strcasecmp(cmd, "DctFastint")) {
4473 video_enc.dct_algo = FF_DCT_FASTINT;
4474 } else if (!strcasecmp(cmd, "IdctSimple")) {
4476 video_enc.idct_algo = FF_IDCT_SIMPLE;
4477 } else if (!strcasecmp(cmd, "Qscale")) {
4478 get_arg(arg, sizeof(arg), &p);
4480 video_enc.flags |= CODEC_FLAG_QSCALE;
4481 video_enc.global_quality = FF_QP2LAMBDA * atoi(arg);
4483 } else if (!strcasecmp(cmd, "VideoQDiff")) {
4484 get_arg(arg, sizeof(arg), &p);
4486 video_enc.max_qdiff = atoi(arg);
4487 if (video_enc.max_qdiff < 1 || video_enc.max_qdiff > 31) {
4488 ERROR("VideoQDiff out of range\n");
4491 } else if (!strcasecmp(cmd, "VideoQMax")) {
4492 get_arg(arg, sizeof(arg), &p);
4494 video_enc.qmax = atoi(arg);
4495 if (video_enc.qmax < 1 || video_enc.qmax > 31) {
4496 ERROR("VideoQMax out of range\n");
4499 } else if (!strcasecmp(cmd, "VideoQMin")) {
4500 get_arg(arg, sizeof(arg), &p);
4502 video_enc.qmin = atoi(arg);
4503 if (video_enc.qmin < 1 || video_enc.qmin > 31) {
4504 ERROR("VideoQMin out of range\n");
4507 } else if (!strcasecmp(cmd, "LumaElim")) {
4508 get_arg(arg, sizeof(arg), &p);
4510 video_enc.luma_elim_threshold = atoi(arg);
4511 } else if (!strcasecmp(cmd, "ChromaElim")) {
4512 get_arg(arg, sizeof(arg), &p);
4514 video_enc.chroma_elim_threshold = atoi(arg);
4515 } else if (!strcasecmp(cmd, "LumiMask")) {
4516 get_arg(arg, sizeof(arg), &p);
4518 video_enc.lumi_masking = atof(arg);
4519 } else if (!strcasecmp(cmd, "DarkMask")) {
4520 get_arg(arg, sizeof(arg), &p);
4522 video_enc.dark_masking = atof(arg);
4523 } else if (!strcasecmp(cmd, "NoVideo")) {
4524 video_id = CODEC_ID_NONE;
4525 } else if (!strcasecmp(cmd, "NoAudio")) {
4526 audio_id = CODEC_ID_NONE;
4527 } else if (!strcasecmp(cmd, "ACL")) {
4528 parse_acl_row(stream, feed, NULL, p, filename, line_num);
4529 } else if (!strcasecmp(cmd, "DynamicACL")) {
4531 get_arg(stream->dynamic_acl, sizeof(stream->dynamic_acl), &p);
4533 } else if (!strcasecmp(cmd, "RTSPOption")) {
4534 get_arg(arg, sizeof(arg), &p);
4536 av_freep(&stream->rtsp_option);
4537 stream->rtsp_option = av_strdup(arg);
4539 } else if (!strcasecmp(cmd, "MulticastAddress")) {
4540 get_arg(arg, sizeof(arg), &p);
4542 if (resolve_host(&stream->multicast_ip, arg) != 0) {
4543 ERROR("Invalid host/IP address: %s\n", arg);
4545 stream->is_multicast = 1;
4546 stream->loop = 1; /* default is looping */
4548 } else if (!strcasecmp(cmd, "MulticastPort")) {
4549 get_arg(arg, sizeof(arg), &p);
4551 stream->multicast_port = atoi(arg);
4552 } else if (!strcasecmp(cmd, "MulticastTTL")) {
4553 get_arg(arg, sizeof(arg), &p);
4555 stream->multicast_ttl = atoi(arg);
4556 } else if (!strcasecmp(cmd, "NoLoop")) {
4559 } else if (!strcasecmp(cmd, "</Stream>")) {
4561 ERROR("No corresponding <Stream> for </Stream>\n");
4563 if (stream->feed && stream->fmt && strcmp(stream->fmt->name, "ffm") != 0) {
4564 if (audio_id != CODEC_ID_NONE) {
4565 audio_enc.codec_type = AVMEDIA_TYPE_AUDIO;
4566 audio_enc.codec_id = audio_id;
4567 add_codec(stream, &audio_enc);
4569 if (video_id != CODEC_ID_NONE) {
4570 video_enc.codec_type = AVMEDIA_TYPE_VIDEO;
4571 video_enc.codec_id = video_id;
4572 add_codec(stream, &video_enc);
4577 } else if (!strcasecmp(cmd, "<Redirect")) {
4578 /*********************************************/
4580 if (stream || feed || redirect) {
4581 ERROR("Already in a tag\n");
4583 redirect = av_mallocz(sizeof(FFStream));
4584 *last_stream = redirect;
4585 last_stream = &redirect->next;
4587 get_arg(redirect->filename, sizeof(redirect->filename), &p);
4588 q = strrchr(redirect->filename, '>');
4591 redirect->stream_type = STREAM_TYPE_REDIRECT;
4593 } else if (!strcasecmp(cmd, "URL")) {
4595 get_arg(redirect->feed_filename, sizeof(redirect->feed_filename), &p);
4596 } else if (!strcasecmp(cmd, "</Redirect>")) {
4598 ERROR("No corresponding <Redirect> for </Redirect>\n");
4600 if (!redirect->feed_filename[0]) {
4601 ERROR("No URL found for <Redirect>\n");
4605 } else if (!strcasecmp(cmd, "LoadModule")) {
4606 get_arg(arg, sizeof(arg), &p);
4610 ERROR("Module support not compiled into this version: '%s'\n", arg);
4613 ERROR("Incorrect keyword: '%s'\n", cmd);
4625 static void handle_child_exit(int sig)
4630 while ((pid = waitpid(-1, &status, WNOHANG)) > 0) {
4633 for (feed = first_feed; feed; feed = feed->next) {
4634 if (feed->pid == pid) {
4635 int uptime = time(0) - feed->pid_start;
4638 fprintf(stderr, "%s: Pid %d exited with status %d after %d seconds\n", feed->filename, pid, status, uptime);
4641 /* Turn off any more restarts */
4642 feed->child_argv = 0;
4647 need_to_start_children = 1;
4650 static void opt_debug(void)
4653 ffserver_daemon = 0;
4654 logfilename[0] = '-';
4657 static void show_help(void)
4659 printf("usage: ffserver [options]\n"
4660 "Hyper fast multi format Audio/Video streaming server\n");
4662 show_help_options(options, "Main options:\n", 0, 0);
4665 static const OptionDef options[] = {
4666 #include "cmdutils_common_opts.h"
4667 { "n", OPT_BOOL, {(void *)&no_launch }, "enable no-launch mode" },
4668 { "d", 0, {(void*)opt_debug}, "enable debug mode" },
4669 { "f", HAS_ARG | OPT_STRING, {(void*)&config_filename }, "use configfile instead of /etc/ffserver.conf", "configfile" },
4673 int main(int argc, char **argv)
4675 struct sigaction sigact;
4681 my_program_name = argv[0];
4682 my_program_dir = getcwd(0, 0);
4683 ffserver_daemon = 1;
4685 parse_options(argc, argv, options, NULL);
4687 unsetenv("http_proxy"); /* Kill the http_proxy */
4689 av_lfg_init(&random_state, av_get_random_seed());
4691 memset(&sigact, 0, sizeof(sigact));
4692 sigact.sa_handler = handle_child_exit;
4693 sigact.sa_flags = SA_NOCLDSTOP | SA_RESTART;
4694 sigaction(SIGCHLD, &sigact, 0);
4696 if (parse_ffconfig(config_filename) < 0) {
4697 fprintf(stderr, "Incorrect config file - exiting.\n");
4701 /* open log file if needed */
4702 if (logfilename[0] != '\0') {
4703 if (!strcmp(logfilename, "-"))
4706 logfile = fopen(logfilename, "a");
4707 av_log_set_callback(http_av_log);
4710 build_file_streams();
4712 build_feed_streams();
4714 compute_bandwidth();
4716 /* put the process in background and detach it from its TTY */
4717 if (ffserver_daemon) {
4724 } else if (pid > 0) {
4731 open("/dev/null", O_RDWR);
4732 if (strcmp(logfilename, "-") != 0) {
4742 signal(SIGPIPE, SIG_IGN);
4744 if (ffserver_daemon)
4747 if (http_server() < 0) {
4748 http_log("Could not start server\n");