2 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
4 * This file is part of FFmpeg.
6 * FFmpeg is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * FFmpeg is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with FFmpeg; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23 * multiple format streaming server based on the FFmpeg libraries
28 #define closesocket close
32 #include "libavformat/avformat.h"
33 // FIXME those are internal headers, ffserver _really_ shouldn't use them
34 #include "libavformat/ffm.h"
35 #include "libavformat/network.h"
36 #include "libavformat/os_support.h"
37 #include "libavformat/rtpdec.h"
38 #include "libavformat/rtsp.h"
39 #include "libavformat/avio_internal.h"
40 #include "libavformat/internal.h"
41 #include "libavformat/url.h"
43 #include "libavutil/avstring.h"
44 #include "libavutil/lfg.h"
45 #include "libavutil/dict.h"
46 #include "libavutil/mathematics.h"
47 #include "libavutil/random_seed.h"
48 #include "libavutil/parseutils.h"
49 #include "libavutil/opt.h"
53 #include <sys/ioctl.h>
68 const char program_name[] = "ffserver";
69 const int program_birth_year = 2000;
71 static const OptionDef options[];
74 HTTPSTATE_WAIT_REQUEST,
75 HTTPSTATE_SEND_HEADER,
76 HTTPSTATE_SEND_DATA_HEADER,
77 HTTPSTATE_SEND_DATA, /* sending TCP or UDP data */
78 HTTPSTATE_SEND_DATA_TRAILER,
79 HTTPSTATE_RECEIVE_DATA,
80 HTTPSTATE_WAIT_FEED, /* wait for data from the feed */
83 RTSPSTATE_WAIT_REQUEST,
85 RTSPSTATE_SEND_PACKET,
88 static const char *http_state[] = {
104 #define MAX_STREAMS 20
106 #define IOBUFFER_INIT_SIZE 8192
108 /* timeouts are in ms */
109 #define HTTP_REQUEST_TIMEOUT (15 * 1000)
110 #define RTSP_REQUEST_TIMEOUT (3600 * 24 * 1000)
112 #define SYNC_TIMEOUT (10 * 1000)
114 typedef struct RTSPActionServerSetup {
116 char transport_option[512];
117 } RTSPActionServerSetup;
120 int64_t count1, count2;
121 int64_t time1, time2;
124 /* context associated with one connection */
125 typedef struct HTTPContext {
126 enum HTTPState state;
127 int fd; /* socket file descriptor */
128 struct sockaddr_in from_addr; /* origin */
129 struct pollfd *poll_entry; /* used when polling */
131 uint8_t *buffer_ptr, *buffer_end;
134 int chunked_encoding;
135 int chunk_size; /* 0 if it needs to be read */
136 struct HTTPContext *next;
137 int got_key_frame; /* stream 0 => 1, stream 1 => 2, stream 2=> 4 */
141 /* input format handling */
142 AVFormatContext *fmt_in;
143 int64_t start_time; /* In milliseconds - this wraps fairly often */
144 int64_t first_pts; /* initial pts value */
145 int64_t cur_pts; /* current pts value from the stream in us */
146 int64_t cur_frame_duration; /* duration of the current frame in us */
147 int cur_frame_bytes; /* output frame size, needed to compute
148 the time at which we send each
150 int pts_stream_index; /* stream we choose as clock reference */
151 int64_t cur_clock; /* current clock reference value in us */
152 /* output format handling */
153 struct FFStream *stream;
154 /* -1 is invalid stream */
155 int feed_streams[MAX_STREAMS]; /* index of streams in the feed */
156 int switch_feed_streams[MAX_STREAMS]; /* index of streams in the feed */
158 AVFormatContext fmt_ctx; /* instance of FFStream for one user */
159 int last_packet_sent; /* true if last data packet was sent */
161 DataRateData datarate;
168 int is_packetized; /* if true, the stream is packetized */
169 int packet_stream_index; /* current stream for output in state machine */
171 /* RTSP state specific */
172 uint8_t *pb_buffer; /* XXX: use that in all the code */
174 int seq; /* RTSP sequence number */
176 /* RTP state specific */
177 enum RTSPLowerTransport rtp_protocol;
178 char session_id[32]; /* session id */
179 AVFormatContext *rtp_ctx[MAX_STREAMS];
181 /* RTP/UDP specific */
182 URLContext *rtp_handles[MAX_STREAMS];
184 /* RTP/TCP specific */
185 struct HTTPContext *rtsp_c;
186 uint8_t *packet_buffer, *packet_buffer_ptr, *packet_buffer_end;
189 /* each generated stream is described here */
193 STREAM_TYPE_REDIRECT,
196 enum IPAddressAction {
201 typedef struct IPAddressACL {
202 struct IPAddressACL *next;
203 enum IPAddressAction action;
204 /* These are in host order */
205 struct in_addr first;
209 /* description of each stream of the ffserver.conf file */
210 typedef struct FFStream {
211 enum StreamType stream_type;
212 char filename[1024]; /* stream filename */
213 struct FFStream *feed; /* feed we are using (can be null if
215 AVDictionary *in_opts; /* input parameters */
216 AVInputFormat *ifmt; /* if non NULL, force input format */
219 char dynamic_acl[1024];
221 int prebuffer; /* Number of millseconds early to start */
222 int64_t max_time; /* Number of milliseconds to run */
224 AVStream *streams[MAX_STREAMS];
225 int feed_streams[MAX_STREAMS]; /* index of streams in the feed */
226 char feed_filename[1024]; /* file name of the feed storage, or
227 input file name for a stream */
232 pid_t pid; /* Of ffmpeg process */
233 time_t pid_start; /* Of ffmpeg process */
235 struct FFStream *next;
236 unsigned bandwidth; /* bandwidth, in kbits/s */
239 /* multicast specific */
241 struct in_addr multicast_ip;
242 int multicast_port; /* first port used for multicast */
244 int loop; /* if true, send the stream in loops (only meaningful if file) */
247 int feed_opened; /* true if someone is writing to the feed */
248 int is_feed; /* true if it is a feed */
249 int readonly; /* True if writing is prohibited to the file */
250 int truncate; /* True if feeder connection truncate the feed file */
252 int64_t bytes_served;
253 int64_t feed_max_size; /* maximum storage size, zero means unlimited */
254 int64_t feed_write_index; /* current write position in feed (it wraps around) */
255 int64_t feed_size; /* current size of feed */
256 struct FFStream *next_feed;
259 typedef struct FeedData {
260 long long data_count;
261 float avg_frame_size; /* frame size averaged over last frames with exponential mean */
264 static struct sockaddr_in my_http_addr;
265 static struct sockaddr_in my_rtsp_addr;
267 static char logfilename[1024];
268 static HTTPContext *first_http_ctx;
269 static FFStream *first_feed; /* contains only feeds */
270 static FFStream *first_stream; /* contains all streams, including feeds */
272 static void new_connection(int server_fd, int is_rtsp);
273 static void close_connection(HTTPContext *c);
276 static int handle_connection(HTTPContext *c);
277 static int http_parse_request(HTTPContext *c);
278 static int http_send_data(HTTPContext *c);
279 static void compute_status(HTTPContext *c);
280 static int open_input_stream(HTTPContext *c, const char *info);
281 static int http_start_receive_data(HTTPContext *c);
282 static int http_receive_data(HTTPContext *c);
285 static int rtsp_parse_request(HTTPContext *c);
286 static void rtsp_cmd_describe(HTTPContext *c, const char *url);
287 static void rtsp_cmd_options(HTTPContext *c, const char *url);
288 static void rtsp_cmd_setup(HTTPContext *c, const char *url, RTSPMessageHeader *h);
289 static void rtsp_cmd_play(HTTPContext *c, const char *url, RTSPMessageHeader *h);
290 static void rtsp_cmd_pause(HTTPContext *c, const char *url, RTSPMessageHeader *h);
291 static void rtsp_cmd_teardown(HTTPContext *c, const char *url, RTSPMessageHeader *h);
294 static int prepare_sdp_description(FFStream *stream, uint8_t **pbuffer,
295 struct in_addr my_ip);
298 static HTTPContext *rtp_new_connection(struct sockaddr_in *from_addr,
299 FFStream *stream, const char *session_id,
300 enum RTSPLowerTransport rtp_protocol);
301 static int rtp_new_av_stream(HTTPContext *c,
302 int stream_index, struct sockaddr_in *dest_addr,
303 HTTPContext *rtsp_c);
305 static const char *my_program_name;
306 static const char *my_program_dir;
308 static const char *config_filename = "/etc/ffserver.conf";
310 static int ffserver_debug;
311 static int ffserver_daemon;
312 static int no_launch;
313 static int need_to_start_children;
315 /* maximum number of simultaneous HTTP connections */
316 static unsigned int nb_max_http_connections = 2000;
317 static unsigned int nb_max_connections = 5;
318 static unsigned int nb_connections;
320 static uint64_t max_bandwidth = 1000;
321 static uint64_t current_bandwidth;
323 static int64_t cur_time; // Making this global saves on passing it around everywhere
325 static AVLFG random_state;
327 static FILE *logfile = NULL;
329 /* FIXME: make ffserver work with IPv6 */
330 void av_noreturn exit_program(int ret)
335 /* resolve host with also IP address parsing */
336 static int resolve_host(struct in_addr *sin_addr, const char *hostname)
339 if (!ff_inet_aton(hostname, sin_addr)) {
341 struct addrinfo *ai, *cur;
342 struct addrinfo hints = { 0 };
343 hints.ai_family = AF_INET;
344 if (getaddrinfo(hostname, NULL, &hints, &ai))
346 /* getaddrinfo returns a linked list of addrinfo structs.
347 * Even if we set ai_family = AF_INET above, make sure
348 * that the returned one actually is of the correct type. */
349 for (cur = ai; cur; cur = cur->ai_next) {
350 if (cur->ai_family == AF_INET) {
351 *sin_addr = ((struct sockaddr_in *)cur->ai_addr)->sin_addr;
360 hp = gethostbyname(hostname);
363 memcpy(sin_addr, hp->h_addr_list[0], sizeof(struct in_addr));
369 static char *ctime1(char *buf2)
377 p = buf2 + strlen(p) - 1;
383 static void http_vlog(const char *fmt, va_list vargs)
385 static int print_prefix = 1;
390 fprintf(logfile, "%s ", buf);
392 print_prefix = strstr(fmt, "\n") != NULL;
393 vfprintf(logfile, fmt, vargs);
399 __attribute__ ((format (printf, 1, 2)))
401 static void http_log(const char *fmt, ...)
404 va_start(vargs, fmt);
405 http_vlog(fmt, vargs);
409 static void http_av_log(void *ptr, int level, const char *fmt, va_list vargs)
411 static int print_prefix = 1;
412 AVClass *avc = ptr ? *(AVClass**)ptr : NULL;
413 if (level > av_log_get_level())
415 if (print_prefix && avc)
416 http_log("[%s @ %p]", avc->item_name(ptr), ptr);
417 print_prefix = strstr(fmt, "\n") != NULL;
418 http_vlog(fmt, vargs);
421 static void log_connection(HTTPContext *c)
426 http_log("%s - - [%s] \"%s %s\" %d %"PRId64"\n",
427 inet_ntoa(c->from_addr.sin_addr), c->method, c->url,
428 c->protocol, (c->http_error ? c->http_error : 200), c->data_count);
431 static void update_datarate(DataRateData *drd, int64_t count)
433 if (!drd->time1 && !drd->count1) {
434 drd->time1 = drd->time2 = cur_time;
435 drd->count1 = drd->count2 = count;
436 } else if (cur_time - drd->time2 > 5000) {
437 drd->time1 = drd->time2;
438 drd->count1 = drd->count2;
439 drd->time2 = cur_time;
444 /* In bytes per second */
445 static int compute_datarate(DataRateData *drd, int64_t count)
447 if (cur_time == drd->time1)
450 return ((count - drd->count1) * 1000) / (cur_time - drd->time1);
454 static void start_children(FFStream *feed)
459 for (; feed; feed = feed->next) {
460 if (feed->child_argv && !feed->pid) {
461 feed->pid_start = time(0);
466 http_log("Unable to create children\n");
475 av_strlcpy(pathname, my_program_name, sizeof(pathname));
477 slash = strrchr(pathname, '/');
482 strcpy(slash, "ffmpeg");
484 http_log("Launch command line: ");
485 http_log("%s ", pathname);
486 for (i = 1; feed->child_argv[i] && feed->child_argv[i][0]; i++)
487 http_log("%s ", feed->child_argv[i]);
490 for (i = 3; i < 256; i++)
493 if (!ffserver_debug) {
494 i = open("/dev/null", O_RDWR);
503 /* This is needed to make relative pathnames work */
504 if (chdir(my_program_dir) < 0) {
505 http_log("chdir failed\n");
509 signal(SIGPIPE, SIG_DFL);
511 execvp(pathname, feed->child_argv);
519 /* open a listening socket */
520 static int socket_open_listen(struct sockaddr_in *my_addr)
524 server_fd = socket(AF_INET,SOCK_STREAM,0);
531 setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &tmp, sizeof(tmp));
533 my_addr->sin_family = AF_INET;
534 if (bind (server_fd, (struct sockaddr *) my_addr, sizeof (*my_addr)) < 0) {
536 snprintf(bindmsg, sizeof(bindmsg), "bind(port %d)", ntohs(my_addr->sin_port));
538 closesocket(server_fd);
542 if (listen (server_fd, 5) < 0) {
544 closesocket(server_fd);
547 ff_socket_nonblock(server_fd, 1);
552 /* start all multicast streams */
553 static void start_multicast(void)
558 struct sockaddr_in dest_addr;
559 int default_port, stream_index;
562 for(stream = first_stream; stream != NULL; stream = stream->next) {
563 if (stream->is_multicast) {
564 /* open the RTP connection */
565 snprintf(session_id, sizeof(session_id), "%08x%08x",
566 av_lfg_get(&random_state), av_lfg_get(&random_state));
568 /* choose a port if none given */
569 if (stream->multicast_port == 0) {
570 stream->multicast_port = default_port;
574 dest_addr.sin_family = AF_INET;
575 dest_addr.sin_addr = stream->multicast_ip;
576 dest_addr.sin_port = htons(stream->multicast_port);
578 rtp_c = rtp_new_connection(&dest_addr, stream, session_id,
579 RTSP_LOWER_TRANSPORT_UDP_MULTICAST);
583 if (open_input_stream(rtp_c, "") < 0) {
584 http_log("Could not open input stream for stream '%s'\n",
589 /* open each RTP stream */
590 for(stream_index = 0; stream_index < stream->nb_streams;
592 dest_addr.sin_port = htons(stream->multicast_port +
594 if (rtp_new_av_stream(rtp_c, stream_index, &dest_addr, NULL) < 0) {
595 http_log("Could not open output stream '%s/streamid=%d'\n",
596 stream->filename, stream_index);
601 /* change state to send data */
602 rtp_c->state = HTTPSTATE_SEND_DATA;
607 /* main loop of the http server */
608 static int http_server(void)
610 int server_fd = 0, rtsp_server_fd = 0;
611 int ret, delay, delay1;
612 struct pollfd *poll_table, *poll_entry;
613 HTTPContext *c, *c_next;
615 if(!(poll_table = av_mallocz((nb_max_http_connections + 2)*sizeof(*poll_table)))) {
616 http_log("Impossible to allocate a poll table handling %d connections.\n", nb_max_http_connections);
620 if (my_http_addr.sin_port) {
621 server_fd = socket_open_listen(&my_http_addr);
626 if (my_rtsp_addr.sin_port) {
627 rtsp_server_fd = socket_open_listen(&my_rtsp_addr);
628 if (rtsp_server_fd < 0)
632 if (!rtsp_server_fd && !server_fd) {
633 http_log("HTTP and RTSP disabled.\n");
637 http_log("FFserver started.\n");
639 start_children(first_feed);
644 poll_entry = poll_table;
646 poll_entry->fd = server_fd;
647 poll_entry->events = POLLIN;
650 if (rtsp_server_fd) {
651 poll_entry->fd = rtsp_server_fd;
652 poll_entry->events = POLLIN;
656 /* wait for events on each HTTP handle */
663 case HTTPSTATE_SEND_HEADER:
664 case RTSPSTATE_SEND_REPLY:
665 case RTSPSTATE_SEND_PACKET:
666 c->poll_entry = poll_entry;
668 poll_entry->events = POLLOUT;
671 case HTTPSTATE_SEND_DATA_HEADER:
672 case HTTPSTATE_SEND_DATA:
673 case HTTPSTATE_SEND_DATA_TRAILER:
674 if (!c->is_packetized) {
675 /* for TCP, we output as much as we can (may need to put a limit) */
676 c->poll_entry = poll_entry;
678 poll_entry->events = POLLOUT;
681 /* when ffserver is doing the timing, we work by
682 looking at which packet need to be sent every
684 delay1 = 10; /* one tick wait XXX: 10 ms assumed */
689 case HTTPSTATE_WAIT_REQUEST:
690 case HTTPSTATE_RECEIVE_DATA:
691 case HTTPSTATE_WAIT_FEED:
692 case RTSPSTATE_WAIT_REQUEST:
693 /* need to catch errors */
694 c->poll_entry = poll_entry;
696 poll_entry->events = POLLIN;/* Maybe this will work */
700 c->poll_entry = NULL;
706 /* wait for an event on one connection. We poll at least every
707 second to handle timeouts */
709 ret = poll(poll_table, poll_entry - poll_table, delay);
710 if (ret < 0 && ff_neterrno() != AVERROR(EAGAIN) &&
711 ff_neterrno() != AVERROR(EINTR))
715 cur_time = av_gettime() / 1000;
717 if (need_to_start_children) {
718 need_to_start_children = 0;
719 start_children(first_feed);
722 /* now handle the events */
723 for(c = first_http_ctx; c != NULL; c = c_next) {
725 if (handle_connection(c) < 0) {
726 /* close and free the connection */
732 poll_entry = poll_table;
734 /* new HTTP connection request ? */
735 if (poll_entry->revents & POLLIN)
736 new_connection(server_fd, 0);
739 if (rtsp_server_fd) {
740 /* new RTSP connection request ? */
741 if (poll_entry->revents & POLLIN)
742 new_connection(rtsp_server_fd, 1);
747 /* start waiting for a new HTTP/RTSP request */
748 static void start_wait_request(HTTPContext *c, int is_rtsp)
750 c->buffer_ptr = c->buffer;
751 c->buffer_end = c->buffer + c->buffer_size - 1; /* leave room for '\0' */
754 c->timeout = cur_time + RTSP_REQUEST_TIMEOUT;
755 c->state = RTSPSTATE_WAIT_REQUEST;
757 c->timeout = cur_time + HTTP_REQUEST_TIMEOUT;
758 c->state = HTTPSTATE_WAIT_REQUEST;
762 static void http_send_too_busy_reply(int fd)
765 int len = snprintf(buffer, sizeof(buffer),
766 "HTTP/1.0 503 Server too busy\r\n"
767 "Content-type: text/html\r\n"
769 "<html><head><title>Too busy</title></head><body>\r\n"
770 "<p>The server is too busy to serve your request at this time.</p>\r\n"
771 "<p>The number of current connections is %d, and this exceeds the limit of %d.</p>\r\n"
772 "</body></html>\r\n",
773 nb_connections, nb_max_connections);
774 send(fd, buffer, len, 0);
778 static void new_connection(int server_fd, int is_rtsp)
780 struct sockaddr_in from_addr;
782 HTTPContext *c = NULL;
784 len = sizeof(from_addr);
785 fd = accept(server_fd, (struct sockaddr *)&from_addr,
788 http_log("error during accept %s\n", strerror(errno));
791 ff_socket_nonblock(fd, 1);
793 if (nb_connections >= nb_max_connections) {
794 http_send_too_busy_reply(fd);
798 /* add a new connection */
799 c = av_mallocz(sizeof(HTTPContext));
804 c->poll_entry = NULL;
805 c->from_addr = from_addr;
806 c->buffer_size = IOBUFFER_INIT_SIZE;
807 c->buffer = av_malloc(c->buffer_size);
811 c->next = first_http_ctx;
815 start_wait_request(c, is_rtsp);
827 static void close_connection(HTTPContext *c)
829 HTTPContext **cp, *c1;
831 AVFormatContext *ctx;
835 /* remove connection from list */
836 cp = &first_http_ctx;
837 while ((*cp) != NULL) {
845 /* remove references, if any (XXX: do it faster) */
846 for(c1 = first_http_ctx; c1 != NULL; c1 = c1->next) {
851 /* remove connection associated resources */
855 /* close each frame parser */
856 for(i=0;i<c->fmt_in->nb_streams;i++) {
857 st = c->fmt_in->streams[i];
858 if (st->codec->codec)
859 avcodec_close(st->codec);
861 avformat_close_input(&c->fmt_in);
864 /* free RTP output streams if any */
867 nb_streams = c->stream->nb_streams;
869 for(i=0;i<nb_streams;i++) {
872 av_write_trailer(ctx);
873 av_dict_free(&ctx->metadata);
874 av_free(ctx->streams[0]);
877 h = c->rtp_handles[i];
884 if (!c->last_packet_sent && c->state == HTTPSTATE_SEND_DATA_TRAILER) {
887 if (avio_open_dyn_buf(&ctx->pb) >= 0) {
888 av_write_trailer(ctx);
889 av_freep(&c->pb_buffer);
890 avio_close_dyn_buf(ctx->pb, &c->pb_buffer);
895 for(i=0; i<ctx->nb_streams; i++)
896 av_free(ctx->streams[i]);
898 if (c->stream && !c->post && c->stream->stream_type == STREAM_TYPE_LIVE)
899 current_bandwidth -= c->stream->bandwidth;
901 /* signal that there is no feed if we are the feeder socket */
902 if (c->state == HTTPSTATE_RECEIVE_DATA && c->stream) {
903 c->stream->feed_opened = 0;
907 av_freep(&c->pb_buffer);
908 av_freep(&c->packet_buffer);
914 static int handle_connection(HTTPContext *c)
919 case HTTPSTATE_WAIT_REQUEST:
920 case RTSPSTATE_WAIT_REQUEST:
922 if ((c->timeout - cur_time) < 0)
924 if (c->poll_entry->revents & (POLLERR | POLLHUP))
927 /* no need to read if no events */
928 if (!(c->poll_entry->revents & POLLIN))
932 len = recv(c->fd, c->buffer_ptr, 1, 0);
934 if (ff_neterrno() != AVERROR(EAGAIN) &&
935 ff_neterrno() != AVERROR(EINTR))
937 } else if (len == 0) {
940 /* search for end of request. */
942 c->buffer_ptr += len;
944 if ((ptr >= c->buffer + 2 && !memcmp(ptr-2, "\n\n", 2)) ||
945 (ptr >= c->buffer + 4 && !memcmp(ptr-4, "\r\n\r\n", 4))) {
946 /* request found : parse it and reply */
947 if (c->state == HTTPSTATE_WAIT_REQUEST) {
948 ret = http_parse_request(c);
950 ret = rtsp_parse_request(c);
954 } else if (ptr >= c->buffer_end) {
955 /* request too long: cannot do anything */
957 } else goto read_loop;
961 case HTTPSTATE_SEND_HEADER:
962 if (c->poll_entry->revents & (POLLERR | POLLHUP))
965 /* no need to write if no events */
966 if (!(c->poll_entry->revents & POLLOUT))
968 len = send(c->fd, c->buffer_ptr, c->buffer_end - c->buffer_ptr, 0);
970 if (ff_neterrno() != AVERROR(EAGAIN) &&
971 ff_neterrno() != AVERROR(EINTR)) {
972 /* error : close connection */
973 av_freep(&c->pb_buffer);
977 c->buffer_ptr += len;
979 c->stream->bytes_served += len;
980 c->data_count += len;
981 if (c->buffer_ptr >= c->buffer_end) {
982 av_freep(&c->pb_buffer);
986 /* all the buffer was sent : synchronize to the incoming stream */
987 c->state = HTTPSTATE_SEND_DATA_HEADER;
988 c->buffer_ptr = c->buffer_end = c->buffer;
993 case HTTPSTATE_SEND_DATA:
994 case HTTPSTATE_SEND_DATA_HEADER:
995 case HTTPSTATE_SEND_DATA_TRAILER:
996 /* for packetized output, we consider we can always write (the
997 input streams sets the speed). It may be better to verify
998 that we do not rely too much on the kernel queues */
999 if (!c->is_packetized) {
1000 if (c->poll_entry->revents & (POLLERR | POLLHUP))
1003 /* no need to read if no events */
1004 if (!(c->poll_entry->revents & POLLOUT))
1007 if (http_send_data(c) < 0)
1009 /* close connection if trailer sent */
1010 if (c->state == HTTPSTATE_SEND_DATA_TRAILER)
1013 case HTTPSTATE_RECEIVE_DATA:
1014 /* no need to read if no events */
1015 if (c->poll_entry->revents & (POLLERR | POLLHUP))
1017 if (!(c->poll_entry->revents & POLLIN))
1019 if (http_receive_data(c) < 0)
1022 case HTTPSTATE_WAIT_FEED:
1023 /* no need to read if no events */
1024 if (c->poll_entry->revents & (POLLIN | POLLERR | POLLHUP))
1027 /* nothing to do, we'll be waken up by incoming feed packets */
1030 case RTSPSTATE_SEND_REPLY:
1031 if (c->poll_entry->revents & (POLLERR | POLLHUP)) {
1032 av_freep(&c->pb_buffer);
1035 /* no need to write if no events */
1036 if (!(c->poll_entry->revents & POLLOUT))
1038 len = send(c->fd, c->buffer_ptr, c->buffer_end - c->buffer_ptr, 0);
1040 if (ff_neterrno() != AVERROR(EAGAIN) &&
1041 ff_neterrno() != AVERROR(EINTR)) {
1042 /* error : close connection */
1043 av_freep(&c->pb_buffer);
1047 c->buffer_ptr += len;
1048 c->data_count += len;
1049 if (c->buffer_ptr >= c->buffer_end) {
1050 /* all the buffer was sent : wait for a new request */
1051 av_freep(&c->pb_buffer);
1052 start_wait_request(c, 1);
1056 case RTSPSTATE_SEND_PACKET:
1057 if (c->poll_entry->revents & (POLLERR | POLLHUP)) {
1058 av_freep(&c->packet_buffer);
1061 /* no need to write if no events */
1062 if (!(c->poll_entry->revents & POLLOUT))
1064 len = send(c->fd, c->packet_buffer_ptr,
1065 c->packet_buffer_end - c->packet_buffer_ptr, 0);
1067 if (ff_neterrno() != AVERROR(EAGAIN) &&
1068 ff_neterrno() != AVERROR(EINTR)) {
1069 /* error : close connection */
1070 av_freep(&c->packet_buffer);
1074 c->packet_buffer_ptr += len;
1075 if (c->packet_buffer_ptr >= c->packet_buffer_end) {
1076 /* all the buffer was sent : wait for a new request */
1077 av_freep(&c->packet_buffer);
1078 c->state = RTSPSTATE_WAIT_REQUEST;
1082 case HTTPSTATE_READY:
1091 static int extract_rates(char *rates, int ratelen, const char *request)
1095 for (p = request; *p && *p != '\r' && *p != '\n'; ) {
1096 if (av_strncasecmp(p, "Pragma:", 7) == 0) {
1097 const char *q = p + 7;
1099 while (*q && *q != '\n' && isspace(*q))
1102 if (av_strncasecmp(q, "stream-switch-entry=", 20) == 0) {
1108 memset(rates, 0xff, ratelen);
1111 while (*q && *q != '\n' && *q != ':')
1114 if (sscanf(q, ":%d:%d", &stream_no, &rate_no) != 2)
1118 if (stream_no < ratelen && stream_no >= 0)
1119 rates[stream_no] = rate_no;
1121 while (*q && *q != '\n' && !isspace(*q))
1128 p = strchr(p, '\n');
1138 static int find_stream_in_feed(FFStream *feed, AVCodecContext *codec, int bit_rate)
1141 int best_bitrate = 100000000;
1144 for (i = 0; i < feed->nb_streams; i++) {
1145 AVCodecContext *feed_codec = feed->streams[i]->codec;
1147 if (feed_codec->codec_id != codec->codec_id ||
1148 feed_codec->sample_rate != codec->sample_rate ||
1149 feed_codec->width != codec->width ||
1150 feed_codec->height != codec->height)
1153 /* Potential stream */
1155 /* We want the fastest stream less than bit_rate, or the slowest
1156 * faster than bit_rate
1159 if (feed_codec->bit_rate <= bit_rate) {
1160 if (best_bitrate > bit_rate || feed_codec->bit_rate > best_bitrate) {
1161 best_bitrate = feed_codec->bit_rate;
1165 if (feed_codec->bit_rate < best_bitrate) {
1166 best_bitrate = feed_codec->bit_rate;
1175 static int modify_current_stream(HTTPContext *c, char *rates)
1178 FFStream *req = c->stream;
1179 int action_required = 0;
1181 /* Not much we can do for a feed */
1185 for (i = 0; i < req->nb_streams; i++) {
1186 AVCodecContext *codec = req->streams[i]->codec;
1190 c->switch_feed_streams[i] = req->feed_streams[i];
1193 c->switch_feed_streams[i] = find_stream_in_feed(req->feed, codec, codec->bit_rate / 2);
1196 /* Wants off or slow */
1197 c->switch_feed_streams[i] = find_stream_in_feed(req->feed, codec, codec->bit_rate / 4);
1199 /* This doesn't work well when it turns off the only stream! */
1200 c->switch_feed_streams[i] = -2;
1201 c->feed_streams[i] = -2;
1206 if (c->switch_feed_streams[i] >= 0 && c->switch_feed_streams[i] != c->feed_streams[i])
1207 action_required = 1;
1210 return action_required;
1213 /* XXX: factorize in utils.c ? */
1214 /* XXX: take care with different space meaning */
1215 static void skip_spaces(const char **pp)
1219 while (*p == ' ' || *p == '\t')
1224 static void get_word(char *buf, int buf_size, const char **pp)
1232 while (!isspace(*p) && *p != '\0') {
1233 if ((q - buf) < buf_size - 1)
1242 static void get_arg(char *buf, int buf_size, const char **pp)
1249 while (isspace(*p)) p++;
1252 if (*p == '\"' || *p == '\'')
1264 if ((q - buf) < buf_size - 1)
1269 if (quote && *p == quote)
1274 static void parse_acl_row(FFStream *stream, FFStream* feed, IPAddressACL *ext_acl,
1275 const char *p, const char *filename, int line_num)
1281 get_arg(arg, sizeof(arg), &p);
1282 if (av_strcasecmp(arg, "allow") == 0)
1283 acl.action = IP_ALLOW;
1284 else if (av_strcasecmp(arg, "deny") == 0)
1285 acl.action = IP_DENY;
1287 fprintf(stderr, "%s:%d: ACL action '%s' is not ALLOW or DENY\n",
1288 filename, line_num, arg);
1292 get_arg(arg, sizeof(arg), &p);
1294 if (resolve_host(&acl.first, arg) != 0) {
1295 fprintf(stderr, "%s:%d: ACL refers to invalid host or ip address '%s'\n",
1296 filename, line_num, arg);
1299 acl.last = acl.first;
1301 get_arg(arg, sizeof(arg), &p);
1304 if (resolve_host(&acl.last, arg) != 0) {
1305 fprintf(stderr, "%s:%d: ACL refers to invalid host or ip address '%s'\n",
1306 filename, line_num, arg);
1312 IPAddressACL *nacl = av_mallocz(sizeof(*nacl));
1313 IPAddressACL **naclp = 0;
1319 naclp = &stream->acl;
1325 fprintf(stderr, "%s:%d: ACL found not in <stream> or <feed>\n",
1326 filename, line_num);
1332 naclp = &(*naclp)->next;
1340 static IPAddressACL* parse_dynamic_acl(FFStream *stream, HTTPContext *c)
1345 IPAddressACL *acl = NULL;
1349 f = fopen(stream->dynamic_acl, "r");
1351 perror(stream->dynamic_acl);
1355 acl = av_mallocz(sizeof(IPAddressACL));
1359 if (fgets(line, sizeof(line), f) == NULL)
1365 if (*p == '\0' || *p == '#')
1367 get_arg(cmd, sizeof(cmd), &p);
1369 if (!av_strcasecmp(cmd, "ACL"))
1370 parse_acl_row(NULL, NULL, acl, p, stream->dynamic_acl, line_num);
1377 static void free_acl_list(IPAddressACL *in_acl)
1379 IPAddressACL *pacl,*pacl2;
1389 static int validate_acl_list(IPAddressACL *in_acl, HTTPContext *c)
1391 enum IPAddressAction last_action = IP_DENY;
1393 struct in_addr *src = &c->from_addr.sin_addr;
1394 unsigned long src_addr = src->s_addr;
1396 for (acl = in_acl; acl; acl = acl->next) {
1397 if (src_addr >= acl->first.s_addr && src_addr <= acl->last.s_addr)
1398 return (acl->action == IP_ALLOW) ? 1 : 0;
1399 last_action = acl->action;
1402 /* Nothing matched, so return not the last action */
1403 return (last_action == IP_DENY) ? 1 : 0;
1406 static int validate_acl(FFStream *stream, HTTPContext *c)
1412 /* if stream->acl is null validate_acl_list will return 1 */
1413 ret = validate_acl_list(stream->acl, c);
1415 if (stream->dynamic_acl[0]) {
1416 acl = parse_dynamic_acl(stream, c);
1418 ret = validate_acl_list(acl, c);
1426 /* compute the real filename of a file by matching it without its
1427 extensions to all the stream filenames */
1428 static void compute_real_filename(char *filename, int max_size)
1435 /* compute filename by matching without the file extensions */
1436 av_strlcpy(file1, filename, sizeof(file1));
1437 p = strrchr(file1, '.');
1440 for(stream = first_stream; stream != NULL; stream = stream->next) {
1441 av_strlcpy(file2, stream->filename, sizeof(file2));
1442 p = strrchr(file2, '.');
1445 if (!strcmp(file1, file2)) {
1446 av_strlcpy(filename, stream->filename, max_size);
1461 /* parse http request and prepare header */
1462 static int http_parse_request(HTTPContext *c)
1465 enum RedirType redir_type;
1467 char info[1024], filename[1024];
1471 const char *mime_type;
1475 char *useragent = 0;
1478 get_word(cmd, sizeof(cmd), (const char **)&p);
1479 av_strlcpy(c->method, cmd, sizeof(c->method));
1481 if (!strcmp(cmd, "GET"))
1483 else if (!strcmp(cmd, "POST"))
1488 get_word(url, sizeof(url), (const char **)&p);
1489 av_strlcpy(c->url, url, sizeof(c->url));
1491 get_word(protocol, sizeof(protocol), (const char **)&p);
1492 if (strcmp(protocol, "HTTP/1.0") && strcmp(protocol, "HTTP/1.1"))
1495 av_strlcpy(c->protocol, protocol, sizeof(c->protocol));
1498 http_log("%s - - New connection: %s %s\n", inet_ntoa(c->from_addr.sin_addr), cmd, url);
1500 /* find the filename and the optional info string in the request */
1501 p = strchr(url, '?');
1503 av_strlcpy(info, p, sizeof(info));
1508 av_strlcpy(filename, url + ((*url == '/') ? 1 : 0), sizeof(filename)-1);
1510 for (p = c->buffer; *p && *p != '\r' && *p != '\n'; ) {
1511 if (av_strncasecmp(p, "User-Agent:", 11) == 0) {
1513 if (*useragent && *useragent != '\n' && isspace(*useragent))
1517 p = strchr(p, '\n');
1524 redir_type = REDIR_NONE;
1525 if (av_match_ext(filename, "asx")) {
1526 redir_type = REDIR_ASX;
1527 filename[strlen(filename)-1] = 'f';
1528 } else if (av_match_ext(filename, "asf") &&
1529 (!useragent || av_strncasecmp(useragent, "NSPlayer", 8) != 0)) {
1530 /* if this isn't WMP or lookalike, return the redirector file */
1531 redir_type = REDIR_ASF;
1532 } else if (av_match_ext(filename, "rpm,ram")) {
1533 redir_type = REDIR_RAM;
1534 strcpy(filename + strlen(filename)-2, "m");
1535 } else if (av_match_ext(filename, "rtsp")) {
1536 redir_type = REDIR_RTSP;
1537 compute_real_filename(filename, sizeof(filename) - 1);
1538 } else if (av_match_ext(filename, "sdp")) {
1539 redir_type = REDIR_SDP;
1540 compute_real_filename(filename, sizeof(filename) - 1);
1543 // "redirect" / request to index.html
1544 if (!strlen(filename))
1545 av_strlcpy(filename, "index.html", sizeof(filename) - 1);
1547 stream = first_stream;
1548 while (stream != NULL) {
1549 if (!strcmp(stream->filename, filename) && validate_acl(stream, c))
1551 stream = stream->next;
1553 if (stream == NULL) {
1554 snprintf(msg, sizeof(msg), "File '%s' not found", url);
1555 http_log("File '%s' not found\n", url);
1560 memcpy(c->feed_streams, stream->feed_streams, sizeof(c->feed_streams));
1561 memset(c->switch_feed_streams, -1, sizeof(c->switch_feed_streams));
1563 if (stream->stream_type == STREAM_TYPE_REDIRECT) {
1564 c->http_error = 301;
1566 q += snprintf(q, c->buffer_size,
1567 "HTTP/1.0 301 Moved\r\n"
1569 "Content-type: text/html\r\n"
1571 "<html><head><title>Moved</title></head><body>\r\n"
1572 "You should be <a href=\"%s\">redirected</a>.\r\n"
1573 "</body></html>\r\n", stream->feed_filename, stream->feed_filename);
1574 /* prepare output buffer */
1575 c->buffer_ptr = c->buffer;
1577 c->state = HTTPSTATE_SEND_HEADER;
1581 /* If this is WMP, get the rate information */
1582 if (extract_rates(ratebuf, sizeof(ratebuf), c->buffer)) {
1583 if (modify_current_stream(c, ratebuf)) {
1584 for (i = 0; i < FF_ARRAY_ELEMS(c->feed_streams); i++) {
1585 if (c->switch_feed_streams[i] >= 0)
1586 c->switch_feed_streams[i] = -1;
1591 if (c->post == 0 && stream->stream_type == STREAM_TYPE_LIVE)
1592 current_bandwidth += stream->bandwidth;
1594 /* If already streaming this feed, do not let start another feeder. */
1595 if (stream->feed_opened) {
1596 snprintf(msg, sizeof(msg), "This feed is already being received.");
1597 http_log("Feed '%s' already being received\n", stream->feed_filename);
1601 if (c->post == 0 && max_bandwidth < current_bandwidth) {
1602 c->http_error = 503;
1604 q += snprintf(q, c->buffer_size,
1605 "HTTP/1.0 503 Server too busy\r\n"
1606 "Content-type: text/html\r\n"
1608 "<html><head><title>Too busy</title></head><body>\r\n"
1609 "<p>The server is too busy to serve your request at this time.</p>\r\n"
1610 "<p>The bandwidth being served (including your stream) is %"PRIu64"kbit/sec, "
1611 "and this exceeds the limit of %"PRIu64"kbit/sec.</p>\r\n"
1612 "</body></html>\r\n", current_bandwidth, max_bandwidth);
1613 /* prepare output buffer */
1614 c->buffer_ptr = c->buffer;
1616 c->state = HTTPSTATE_SEND_HEADER;
1620 if (redir_type != REDIR_NONE) {
1623 for (p = c->buffer; *p && *p != '\r' && *p != '\n'; ) {
1624 if (av_strncasecmp(p, "Host:", 5) == 0) {
1628 p = strchr(p, '\n');
1639 while (isspace(*hostinfo))
1642 eoh = strchr(hostinfo, '\n');
1644 if (eoh[-1] == '\r')
1647 if (eoh - hostinfo < sizeof(hostbuf) - 1) {
1648 memcpy(hostbuf, hostinfo, eoh - hostinfo);
1649 hostbuf[eoh - hostinfo] = 0;
1651 c->http_error = 200;
1653 switch(redir_type) {
1655 q += snprintf(q, c->buffer_size,
1656 "HTTP/1.0 200 ASX Follows\r\n"
1657 "Content-type: video/x-ms-asf\r\n"
1659 "<ASX Version=\"3\">\r\n"
1660 //"<!-- Autogenerated by ffserver -->\r\n"
1661 "<ENTRY><REF HREF=\"http://%s/%s%s\"/></ENTRY>\r\n"
1662 "</ASX>\r\n", hostbuf, filename, info);
1665 q += snprintf(q, c->buffer_size,
1666 "HTTP/1.0 200 RAM Follows\r\n"
1667 "Content-type: audio/x-pn-realaudio\r\n"
1669 "# Autogenerated by ffserver\r\n"
1670 "http://%s/%s%s\r\n", hostbuf, filename, info);
1673 q += snprintf(q, c->buffer_size,
1674 "HTTP/1.0 200 ASF Redirect follows\r\n"
1675 "Content-type: video/x-ms-asf\r\n"
1678 "Ref1=http://%s/%s%s\r\n", hostbuf, filename, info);
1682 char hostname[256], *p;
1683 /* extract only hostname */
1684 av_strlcpy(hostname, hostbuf, sizeof(hostname));
1685 p = strrchr(hostname, ':');
1688 q += snprintf(q, c->buffer_size,
1689 "HTTP/1.0 200 RTSP Redirect follows\r\n"
1690 /* XXX: incorrect mime type ? */
1691 "Content-type: application/x-rtsp\r\n"
1693 "rtsp://%s:%d/%s\r\n", hostname, ntohs(my_rtsp_addr.sin_port), filename);
1699 int sdp_data_size, len;
1700 struct sockaddr_in my_addr;
1702 q += snprintf(q, c->buffer_size,
1703 "HTTP/1.0 200 OK\r\n"
1704 "Content-type: application/sdp\r\n"
1707 len = sizeof(my_addr);
1708 getsockname(c->fd, (struct sockaddr *)&my_addr, &len);
1710 /* XXX: should use a dynamic buffer */
1711 sdp_data_size = prepare_sdp_description(stream,
1714 if (sdp_data_size > 0) {
1715 memcpy(q, sdp_data, sdp_data_size);
1727 /* prepare output buffer */
1728 c->buffer_ptr = c->buffer;
1730 c->state = HTTPSTATE_SEND_HEADER;
1736 snprintf(msg, sizeof(msg), "ASX/RAM file not handled");
1740 stream->conns_served++;
1742 /* XXX: add there authenticate and IP match */
1745 /* if post, it means a feed is being sent */
1746 if (!stream->is_feed) {
1747 /* However it might be a status report from WMP! Let us log the
1748 * data as it might come in handy one day. */
1752 for (p = c->buffer; *p && *p != '\r' && *p != '\n'; ) {
1753 if (av_strncasecmp(p, "Pragma: log-line=", 17) == 0) {
1757 if (av_strncasecmp(p, "Pragma: client-id=", 18) == 0)
1758 client_id = strtol(p + 18, 0, 10);
1759 p = strchr(p, '\n');
1767 char *eol = strchr(logline, '\n');
1772 if (eol[-1] == '\r')
1774 http_log("%.*s\n", (int) (eol - logline), logline);
1775 c->suppress_log = 1;
1780 http_log("\nGot request:\n%s\n", c->buffer);
1783 if (client_id && extract_rates(ratebuf, sizeof(ratebuf), c->buffer)) {
1786 /* Now we have to find the client_id */
1787 for (wmpc = first_http_ctx; wmpc; wmpc = wmpc->next) {
1788 if (wmpc->wmp_client_id == client_id)
1792 if (wmpc && modify_current_stream(wmpc, ratebuf))
1793 wmpc->switch_pending = 1;
1796 snprintf(msg, sizeof(msg), "POST command not handled");
1800 if (http_start_receive_data(c) < 0) {
1801 snprintf(msg, sizeof(msg), "could not open feed");
1805 c->state = HTTPSTATE_RECEIVE_DATA;
1810 if (strcmp(stream->filename + strlen(stream->filename) - 4, ".asf") == 0)
1811 http_log("\nGot request:\n%s\n", c->buffer);
1814 if (c->stream->stream_type == STREAM_TYPE_STATUS)
1817 /* open input stream */
1818 if (open_input_stream(c, info) < 0) {
1819 snprintf(msg, sizeof(msg), "Input stream corresponding to '%s' not found", url);
1823 /* prepare http header */
1825 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "HTTP/1.0 200 OK\r\n");
1826 mime_type = c->stream->fmt->mime_type;
1828 mime_type = "application/x-octet-stream";
1829 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "Pragma: no-cache\r\n");
1831 /* for asf, we need extra headers */
1832 if (!strcmp(c->stream->fmt->name,"asf_stream")) {
1833 /* Need to allocate a client id */
1835 c->wmp_client_id = av_lfg_get(&random_state);
1837 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);
1839 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "Content-Type: %s\r\n", mime_type);
1840 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "\r\n");
1842 /* prepare output buffer */
1844 c->buffer_ptr = c->buffer;
1846 c->state = HTTPSTATE_SEND_HEADER;
1849 c->http_error = 404;
1851 q += snprintf(q, c->buffer_size,
1852 "HTTP/1.0 404 Not Found\r\n"
1853 "Content-type: text/html\r\n"
1856 "<head><title>404 Not Found</title></head>\n"
1859 /* prepare output buffer */
1860 c->buffer_ptr = c->buffer;
1862 c->state = HTTPSTATE_SEND_HEADER;
1866 c->http_error = 200; /* horrible : we use this value to avoid
1867 going to the send data state */
1868 c->state = HTTPSTATE_SEND_HEADER;
1872 static void fmt_bytecount(AVIOContext *pb, int64_t count)
1874 static const char suffix[] = " kMGTP";
1877 for (s = suffix; count >= 100000 && s[1]; count /= 1000, s++);
1879 avio_printf(pb, "%"PRId64"%c", count, *s);
1882 static void compute_status(HTTPContext *c)
1891 if (avio_open_dyn_buf(&pb) < 0) {
1892 /* XXX: return an error ? */
1893 c->buffer_ptr = c->buffer;
1894 c->buffer_end = c->buffer;
1898 avio_printf(pb, "HTTP/1.0 200 OK\r\n");
1899 avio_printf(pb, "Content-type: %s\r\n", "text/html");
1900 avio_printf(pb, "Pragma: no-cache\r\n");
1901 avio_printf(pb, "\r\n");
1903 avio_printf(pb, "<html><head><title>%s Status</title>\n", program_name);
1904 if (c->stream->feed_filename[0])
1905 avio_printf(pb, "<link rel=\"shortcut icon\" href=\"%s\">\n", c->stream->feed_filename);
1906 avio_printf(pb, "</head>\n<body>");
1907 avio_printf(pb, "<h1>%s Status</h1>\n", program_name);
1909 avio_printf(pb, "<h2>Available Streams</h2>\n");
1910 avio_printf(pb, "<table cellspacing=0 cellpadding=4>\n");
1911 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");
1912 stream = first_stream;
1913 while (stream != NULL) {
1914 char sfilename[1024];
1917 if (stream->feed != stream) {
1918 av_strlcpy(sfilename, stream->filename, sizeof(sfilename) - 10);
1919 eosf = sfilename + strlen(sfilename);
1920 if (eosf - sfilename >= 4) {
1921 if (strcmp(eosf - 4, ".asf") == 0)
1922 strcpy(eosf - 4, ".asx");
1923 else if (strcmp(eosf - 3, ".rm") == 0)
1924 strcpy(eosf - 3, ".ram");
1925 else if (stream->fmt && !strcmp(stream->fmt->name, "rtp")) {
1926 /* generate a sample RTSP director if
1927 unicast. Generate an SDP redirector if
1929 eosf = strrchr(sfilename, '.');
1931 eosf = sfilename + strlen(sfilename);
1932 if (stream->is_multicast)
1933 strcpy(eosf, ".sdp");
1935 strcpy(eosf, ".rtsp");
1939 avio_printf(pb, "<tr><td><a href=\"/%s\">%s</a> ",
1940 sfilename, stream->filename);
1941 avio_printf(pb, "<td align=right> %d <td align=right> ",
1942 stream->conns_served);
1943 fmt_bytecount(pb, stream->bytes_served);
1944 switch(stream->stream_type) {
1945 case STREAM_TYPE_LIVE: {
1946 int audio_bit_rate = 0;
1947 int video_bit_rate = 0;
1948 const char *audio_codec_name = "";
1949 const char *video_codec_name = "";
1950 const char *audio_codec_name_extra = "";
1951 const char *video_codec_name_extra = "";
1953 for(i=0;i<stream->nb_streams;i++) {
1954 AVStream *st = stream->streams[i];
1955 AVCodec *codec = avcodec_find_encoder(st->codec->codec_id);
1956 switch(st->codec->codec_type) {
1957 case AVMEDIA_TYPE_AUDIO:
1958 audio_bit_rate += st->codec->bit_rate;
1960 if (*audio_codec_name)
1961 audio_codec_name_extra = "...";
1962 audio_codec_name = codec->name;
1965 case AVMEDIA_TYPE_VIDEO:
1966 video_bit_rate += st->codec->bit_rate;
1968 if (*video_codec_name)
1969 video_codec_name_extra = "...";
1970 video_codec_name = codec->name;
1973 case AVMEDIA_TYPE_DATA:
1974 video_bit_rate += st->codec->bit_rate;
1980 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",
1983 video_bit_rate / 1000, video_codec_name, video_codec_name_extra,
1984 audio_bit_rate / 1000, audio_codec_name, audio_codec_name_extra);
1986 avio_printf(pb, "<td>%s", stream->feed->filename);
1988 avio_printf(pb, "<td>%s", stream->feed_filename);
1989 avio_printf(pb, "\n");
1993 avio_printf(pb, "<td align=center> - <td align=right> - <td align=right> - <td><td align=right> - <td>\n");
1997 stream = stream->next;
1999 avio_printf(pb, "</table>\n");
2001 stream = first_stream;
2002 while (stream != NULL) {
2003 if (stream->feed == stream) {
2004 avio_printf(pb, "<h2>Feed %s</h2>", stream->filename);
2006 avio_printf(pb, "Running as pid %d.\n", stream->pid);
2008 #if defined(linux) && !defined(CONFIG_NOCUTILS)
2013 /* This is somewhat linux specific I guess */
2014 snprintf(ps_cmd, sizeof(ps_cmd),
2015 "ps -o \"%%cpu,cputime\" --no-headers %d",
2018 pid_stat = popen(ps_cmd, "r");
2023 if (fscanf(pid_stat, "%10s %64s", cpuperc,
2025 avio_printf(pb, "Currently using %s%% of the cpu. Total time used %s.\n",
2033 avio_printf(pb, "<p>");
2035 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");
2037 for (i = 0; i < stream->nb_streams; i++) {
2038 AVStream *st = stream->streams[i];
2039 AVCodec *codec = avcodec_find_encoder(st->codec->codec_id);
2040 const char *type = "unknown";
2041 char parameters[64];
2045 switch(st->codec->codec_type) {
2046 case AVMEDIA_TYPE_AUDIO:
2048 snprintf(parameters, sizeof(parameters), "%d channel(s), %d Hz", st->codec->channels, st->codec->sample_rate);
2050 case AVMEDIA_TYPE_VIDEO:
2052 snprintf(parameters, sizeof(parameters), "%dx%d, q=%d-%d, fps=%d", st->codec->width, st->codec->height,
2053 st->codec->qmin, st->codec->qmax, st->codec->time_base.den / st->codec->time_base.num);
2058 avio_printf(pb, "<tr><td align=right>%d<td>%s<td align=right>%d<td>%s<td>%s\n",
2059 i, type, st->codec->bit_rate/1000, codec ? codec->name : "", parameters);
2061 avio_printf(pb, "</table>\n");
2064 stream = stream->next;
2067 /* connection status */
2068 avio_printf(pb, "<h2>Connection Status</h2>\n");
2070 avio_printf(pb, "Number of connections: %d / %d<br>\n",
2071 nb_connections, nb_max_connections);
2073 avio_printf(pb, "Bandwidth in use: %"PRIu64"k / %"PRIu64"k<br>\n",
2074 current_bandwidth, max_bandwidth);
2076 avio_printf(pb, "<table>\n");
2077 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");
2078 c1 = first_http_ctx;
2080 while (c1 != NULL) {
2086 for (j = 0; j < c1->stream->nb_streams; j++) {
2087 if (!c1->stream->feed)
2088 bitrate += c1->stream->streams[j]->codec->bit_rate;
2089 else if (c1->feed_streams[j] >= 0)
2090 bitrate += c1->stream->feed->streams[c1->feed_streams[j]]->codec->bit_rate;
2095 p = inet_ntoa(c1->from_addr.sin_addr);
2096 avio_printf(pb, "<tr><td><b>%d</b><td>%s%s<td>%s<td>%s<td>%s<td align=right>",
2098 c1->stream ? c1->stream->filename : "",
2099 c1->state == HTTPSTATE_RECEIVE_DATA ? "(input)" : "",
2102 http_state[c1->state]);
2103 fmt_bytecount(pb, bitrate);
2104 avio_printf(pb, "<td align=right>");
2105 fmt_bytecount(pb, compute_datarate(&c1->datarate, c1->data_count) * 8);
2106 avio_printf(pb, "<td align=right>");
2107 fmt_bytecount(pb, c1->data_count);
2108 avio_printf(pb, "\n");
2111 avio_printf(pb, "</table>\n");
2116 avio_printf(pb, "<hr size=1 noshade>Generated at %s", p);
2117 avio_printf(pb, "</body>\n</html>\n");
2119 len = avio_close_dyn_buf(pb, &c->pb_buffer);
2120 c->buffer_ptr = c->pb_buffer;
2121 c->buffer_end = c->pb_buffer + len;
2124 static int open_input_stream(HTTPContext *c, const char *info)
2127 char input_filename[1024];
2128 AVFormatContext *s = NULL;
2129 int buf_size, i, ret;
2132 /* find file name */
2133 if (c->stream->feed) {
2134 strcpy(input_filename, c->stream->feed->feed_filename);
2135 buf_size = FFM_PACKET_SIZE;
2136 /* compute position (absolute time) */
2137 if (av_find_info_tag(buf, sizeof(buf), "date", info)) {
2138 if ((ret = av_parse_time(&stream_pos, buf, 0)) < 0)
2140 } else if (av_find_info_tag(buf, sizeof(buf), "buffer", info)) {
2141 int prebuffer = strtol(buf, 0, 10);
2142 stream_pos = av_gettime() - prebuffer * (int64_t)1000000;
2144 stream_pos = av_gettime() - c->stream->prebuffer * (int64_t)1000;
2146 strcpy(input_filename, c->stream->feed_filename);
2148 /* compute position (relative time) */
2149 if (av_find_info_tag(buf, sizeof(buf), "date", info)) {
2150 if ((ret = av_parse_time(&stream_pos, buf, 1)) < 0)
2155 if (input_filename[0] == '\0')
2159 if ((ret = avformat_open_input(&s, input_filename, c->stream->ifmt, &c->stream->in_opts)) < 0) {
2160 http_log("could not open %s: %d\n", input_filename, ret);
2164 /* set buffer size */
2165 if (buf_size > 0) ffio_set_buf_size(s->pb, buf_size);
2167 s->flags |= AVFMT_FLAG_GENPTS;
2169 if (strcmp(s->iformat->name, "ffm") && avformat_find_stream_info(c->fmt_in, NULL) < 0) {
2170 http_log("Could not find stream info '%s'\n", input_filename);
2171 avformat_close_input(&s);
2175 /* choose stream as clock source (we favorize video stream if
2176 present) for packet sending */
2177 c->pts_stream_index = 0;
2178 for(i=0;i<c->stream->nb_streams;i++) {
2179 if (c->pts_stream_index == 0 &&
2180 c->stream->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2181 c->pts_stream_index = i;
2185 if (c->fmt_in->iformat->read_seek)
2186 av_seek_frame(c->fmt_in, -1, stream_pos, 0);
2187 /* set the start time (needed for maxtime and RTP packet timing) */
2188 c->start_time = cur_time;
2189 c->first_pts = AV_NOPTS_VALUE;
2193 /* return the server clock (in us) */
2194 static int64_t get_server_clock(HTTPContext *c)
2196 /* compute current pts value from system time */
2197 return (cur_time - c->start_time) * 1000;
2200 /* return the estimated time at which the current packet must be sent
2202 static int64_t get_packet_send_clock(HTTPContext *c)
2204 int bytes_left, bytes_sent, frame_bytes;
2206 frame_bytes = c->cur_frame_bytes;
2207 if (frame_bytes <= 0)
2210 bytes_left = c->buffer_end - c->buffer_ptr;
2211 bytes_sent = frame_bytes - bytes_left;
2212 return c->cur_pts + (c->cur_frame_duration * bytes_sent) / frame_bytes;
2217 static int http_prepare_data(HTTPContext *c)
2220 AVFormatContext *ctx;
2222 av_freep(&c->pb_buffer);
2224 case HTTPSTATE_SEND_DATA_HEADER:
2225 memset(&c->fmt_ctx, 0, sizeof(c->fmt_ctx));
2226 av_dict_set(&c->fmt_ctx.metadata, "author" , c->stream->author , 0);
2227 av_dict_set(&c->fmt_ctx.metadata, "comment" , c->stream->comment , 0);
2228 av_dict_set(&c->fmt_ctx.metadata, "copyright", c->stream->copyright, 0);
2229 av_dict_set(&c->fmt_ctx.metadata, "title" , c->stream->title , 0);
2231 c->fmt_ctx.streams = av_mallocz(sizeof(AVStream *) * c->stream->nb_streams);
2233 for(i=0;i<c->stream->nb_streams;i++) {
2235 c->fmt_ctx.streams[i] = av_mallocz(sizeof(AVStream));
2236 /* if file or feed, then just take streams from FFStream struct */
2237 if (!c->stream->feed ||
2238 c->stream->feed == c->stream)
2239 src = c->stream->streams[i];
2241 src = c->stream->feed->streams[c->stream->feed_streams[i]];
2243 *(c->fmt_ctx.streams[i]) = *src;
2244 c->fmt_ctx.streams[i]->priv_data = 0;
2245 c->fmt_ctx.streams[i]->codec->frame_number = 0; /* XXX: should be done in
2246 AVStream, not in codec */
2248 /* set output format parameters */
2249 c->fmt_ctx.oformat = c->stream->fmt;
2250 c->fmt_ctx.nb_streams = c->stream->nb_streams;
2252 c->got_key_frame = 0;
2254 /* prepare header and save header data in a stream */
2255 if (avio_open_dyn_buf(&c->fmt_ctx.pb) < 0) {
2256 /* XXX: potential leak */
2259 c->fmt_ctx.pb->seekable = 0;
2262 * HACK to avoid mpeg ps muxer to spit many underflow errors
2263 * Default value from FFmpeg
2264 * Try to set it use configuration option
2266 c->fmt_ctx.max_delay = (int)(0.7*AV_TIME_BASE);
2268 if (avformat_write_header(&c->fmt_ctx, NULL) < 0) {
2269 http_log("Error writing output header\n");
2272 av_dict_free(&c->fmt_ctx.metadata);
2274 len = avio_close_dyn_buf(c->fmt_ctx.pb, &c->pb_buffer);
2275 c->buffer_ptr = c->pb_buffer;
2276 c->buffer_end = c->pb_buffer + len;
2278 c->state = HTTPSTATE_SEND_DATA;
2279 c->last_packet_sent = 0;
2281 case HTTPSTATE_SEND_DATA:
2282 /* find a new packet */
2283 /* read a packet from the input stream */
2284 if (c->stream->feed)
2285 ffm_set_write_index(c->fmt_in,
2286 c->stream->feed->feed_write_index,
2287 c->stream->feed->feed_size);
2289 if (c->stream->max_time &&
2290 c->stream->max_time + c->start_time - cur_time < 0)
2291 /* We have timed out */
2292 c->state = HTTPSTATE_SEND_DATA_TRAILER;
2296 ret = av_read_frame(c->fmt_in, &pkt);
2298 if (c->stream->feed) {
2299 /* if coming from feed, it means we reached the end of the
2300 ffm file, so must wait for more data */
2301 c->state = HTTPSTATE_WAIT_FEED;
2302 return 1; /* state changed */
2303 } else if (ret == AVERROR(EAGAIN)) {
2304 /* input not ready, come back later */
2307 if (c->stream->loop) {
2308 avformat_close_input(&c->fmt_in);
2309 if (open_input_stream(c, "") < 0)
2314 /* must send trailer now because eof or error */
2315 c->state = HTTPSTATE_SEND_DATA_TRAILER;
2319 int source_index = pkt.stream_index;
2320 /* update first pts if needed */
2321 if (c->first_pts == AV_NOPTS_VALUE) {
2322 c->first_pts = av_rescale_q(pkt.dts, c->fmt_in->streams[pkt.stream_index]->time_base, AV_TIME_BASE_Q);
2323 c->start_time = cur_time;
2325 /* send it to the appropriate stream */
2326 if (c->stream->feed) {
2327 /* if coming from a feed, select the right stream */
2328 if (c->switch_pending) {
2329 c->switch_pending = 0;
2330 for(i=0;i<c->stream->nb_streams;i++) {
2331 if (c->switch_feed_streams[i] == pkt.stream_index)
2332 if (pkt.flags & AV_PKT_FLAG_KEY)
2333 c->switch_feed_streams[i] = -1;
2334 if (c->switch_feed_streams[i] >= 0)
2335 c->switch_pending = 1;
2338 for(i=0;i<c->stream->nb_streams;i++) {
2339 if (c->stream->feed_streams[i] == pkt.stream_index) {
2340 AVStream *st = c->fmt_in->streams[source_index];
2341 pkt.stream_index = i;
2342 if (pkt.flags & AV_PKT_FLAG_KEY &&
2343 (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2344 c->stream->nb_streams == 1))
2345 c->got_key_frame = 1;
2346 if (!c->stream->send_on_key || c->got_key_frame)
2351 AVCodecContext *codec;
2352 AVStream *ist, *ost;
2354 ist = c->fmt_in->streams[source_index];
2355 /* specific handling for RTP: we use several
2356 output stream (one for each RTP
2357 connection). XXX: need more abstract handling */
2358 if (c->is_packetized) {
2359 /* compute send time and duration */
2360 c->cur_pts = av_rescale_q(pkt.dts, ist->time_base, AV_TIME_BASE_Q);
2361 c->cur_pts -= c->first_pts;
2362 c->cur_frame_duration = av_rescale_q(pkt.duration, ist->time_base, AV_TIME_BASE_Q);
2363 /* find RTP context */
2364 c->packet_stream_index = pkt.stream_index;
2365 ctx = c->rtp_ctx[c->packet_stream_index];
2367 av_free_packet(&pkt);
2370 codec = ctx->streams[0]->codec;
2371 /* only one stream per RTP connection */
2372 pkt.stream_index = 0;
2376 codec = ctx->streams[pkt.stream_index]->codec;
2379 if (c->is_packetized) {
2380 int max_packet_size;
2381 if (c->rtp_protocol == RTSP_LOWER_TRANSPORT_TCP)
2382 max_packet_size = RTSP_TCP_MAX_PACKET_SIZE;
2384 max_packet_size = c->rtp_handles[c->packet_stream_index]->max_packet_size;
2385 ret = ffio_open_dyn_packet_buf(&ctx->pb, max_packet_size);
2387 ret = avio_open_dyn_buf(&ctx->pb);
2390 /* XXX: potential leak */
2393 ost = ctx->streams[pkt.stream_index];
2395 ctx->pb->seekable = 0;
2396 if (pkt.dts != AV_NOPTS_VALUE)
2397 pkt.dts = av_rescale_q(pkt.dts, ist->time_base, ost->time_base);
2398 if (pkt.pts != AV_NOPTS_VALUE)
2399 pkt.pts = av_rescale_q(pkt.pts, ist->time_base, ost->time_base);
2400 pkt.duration = av_rescale_q(pkt.duration, ist->time_base, ost->time_base);
2401 if (av_write_frame(ctx, &pkt) < 0) {
2402 http_log("Error writing frame to output\n");
2403 c->state = HTTPSTATE_SEND_DATA_TRAILER;
2406 len = avio_close_dyn_buf(ctx->pb, &c->pb_buffer);
2407 c->cur_frame_bytes = len;
2408 c->buffer_ptr = c->pb_buffer;
2409 c->buffer_end = c->pb_buffer + len;
2411 codec->frame_number++;
2413 av_free_packet(&pkt);
2417 av_free_packet(&pkt);
2422 case HTTPSTATE_SEND_DATA_TRAILER:
2423 /* last packet test ? */
2424 if (c->last_packet_sent || c->is_packetized)
2427 /* prepare header */
2428 if (avio_open_dyn_buf(&ctx->pb) < 0) {
2429 /* XXX: potential leak */
2432 c->fmt_ctx.pb->seekable = 0;
2433 av_write_trailer(ctx);
2434 len = avio_close_dyn_buf(ctx->pb, &c->pb_buffer);
2435 c->buffer_ptr = c->pb_buffer;
2436 c->buffer_end = c->pb_buffer + len;
2438 c->last_packet_sent = 1;
2444 /* should convert the format at the same time */
2445 /* send data starting at c->buffer_ptr to the output connection
2446 (either UDP or TCP connection) */
2447 static int http_send_data(HTTPContext *c)
2452 if (c->buffer_ptr >= c->buffer_end) {
2453 ret = http_prepare_data(c);
2457 /* state change requested */
2460 if (c->is_packetized) {
2461 /* RTP data output */
2462 len = c->buffer_end - c->buffer_ptr;
2464 /* fail safe - should never happen */
2466 c->buffer_ptr = c->buffer_end;
2469 len = (c->buffer_ptr[0] << 24) |
2470 (c->buffer_ptr[1] << 16) |
2471 (c->buffer_ptr[2] << 8) |
2473 if (len > (c->buffer_end - c->buffer_ptr))
2475 if ((get_packet_send_clock(c) - get_server_clock(c)) > 0) {
2476 /* nothing to send yet: we can wait */
2480 c->data_count += len;
2481 update_datarate(&c->datarate, c->data_count);
2483 c->stream->bytes_served += len;
2485 if (c->rtp_protocol == RTSP_LOWER_TRANSPORT_TCP) {
2486 /* RTP packets are sent inside the RTSP TCP connection */
2488 int interleaved_index, size;
2490 HTTPContext *rtsp_c;
2493 /* if no RTSP connection left, error */
2496 /* if already sending something, then wait. */
2497 if (rtsp_c->state != RTSPSTATE_WAIT_REQUEST)
2499 if (avio_open_dyn_buf(&pb) < 0)
2501 interleaved_index = c->packet_stream_index * 2;
2502 /* RTCP packets are sent at odd indexes */
2503 if (c->buffer_ptr[1] == 200)
2504 interleaved_index++;
2505 /* write RTSP TCP header */
2507 header[1] = interleaved_index;
2508 header[2] = len >> 8;
2510 avio_write(pb, header, 4);
2511 /* write RTP packet data */
2513 avio_write(pb, c->buffer_ptr, len);
2514 size = avio_close_dyn_buf(pb, &c->packet_buffer);
2515 /* prepare asynchronous TCP sending */
2516 rtsp_c->packet_buffer_ptr = c->packet_buffer;
2517 rtsp_c->packet_buffer_end = c->packet_buffer + size;
2518 c->buffer_ptr += len;
2520 /* send everything we can NOW */
2521 len = send(rtsp_c->fd, rtsp_c->packet_buffer_ptr,
2522 rtsp_c->packet_buffer_end - rtsp_c->packet_buffer_ptr, 0);
2524 rtsp_c->packet_buffer_ptr += len;
2525 if (rtsp_c->packet_buffer_ptr < rtsp_c->packet_buffer_end) {
2526 /* if we could not send all the data, we will
2527 send it later, so a new state is needed to
2528 "lock" the RTSP TCP connection */
2529 rtsp_c->state = RTSPSTATE_SEND_PACKET;
2532 /* all data has been sent */
2533 av_freep(&c->packet_buffer);
2535 /* send RTP packet directly in UDP */
2537 ffurl_write(c->rtp_handles[c->packet_stream_index],
2538 c->buffer_ptr, len);
2539 c->buffer_ptr += len;
2540 /* here we continue as we can send several packets per 10 ms slot */
2543 /* TCP data output */
2544 len = send(c->fd, c->buffer_ptr, c->buffer_end - c->buffer_ptr, 0);
2546 if (ff_neterrno() != AVERROR(EAGAIN) &&
2547 ff_neterrno() != AVERROR(EINTR))
2548 /* error : close connection */
2553 c->buffer_ptr += len;
2555 c->data_count += len;
2556 update_datarate(&c->datarate, c->data_count);
2558 c->stream->bytes_served += len;
2566 static int http_start_receive_data(HTTPContext *c)
2570 if (c->stream->feed_opened)
2573 /* Don't permit writing to this one */
2574 if (c->stream->readonly)
2578 fd = open(c->stream->feed_filename, O_RDWR);
2580 http_log("Error opening feeder file: %s\n", strerror(errno));
2585 if (c->stream->truncate) {
2586 /* truncate feed file */
2587 ffm_write_write_index(c->feed_fd, FFM_PACKET_SIZE);
2588 http_log("Truncating feed file '%s'\n", c->stream->feed_filename);
2589 if (ftruncate(c->feed_fd, FFM_PACKET_SIZE) < 0) {
2590 http_log("Error truncating feed file: %s\n", strerror(errno));
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 avformat_close_input(&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 avformat_close_input(&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 = { 0 }, *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 /* skip to next line */
2867 while (*p != '\n' && *p != '\0')
2871 while (*p != '\0') {
2872 p1 = memchr(p, '\n', (char *)c->buffer_ptr - p);
2876 if (p2 > p && p2[-1] == '\r')
2878 /* skip empty line */
2882 if (len > sizeof(line) - 1)
2883 len = sizeof(line) - 1;
2884 memcpy(line, p, len);
2886 ff_rtsp_parse_line(header, line, NULL, NULL);
2890 /* handle sequence number */
2891 c->seq = header->seq;
2893 if (!strcmp(cmd, "DESCRIBE"))
2894 rtsp_cmd_describe(c, url);
2895 else if (!strcmp(cmd, "OPTIONS"))
2896 rtsp_cmd_options(c, url);
2897 else if (!strcmp(cmd, "SETUP"))
2898 rtsp_cmd_setup(c, url, header);
2899 else if (!strcmp(cmd, "PLAY"))
2900 rtsp_cmd_play(c, url, header);
2901 else if (!strcmp(cmd, "PAUSE"))
2902 rtsp_cmd_pause(c, url, header);
2903 else if (!strcmp(cmd, "TEARDOWN"))
2904 rtsp_cmd_teardown(c, url, header);
2906 rtsp_reply_error(c, RTSP_STATUS_METHOD);
2909 len = avio_close_dyn_buf(c->pb, &c->pb_buffer);
2910 c->pb = NULL; /* safety */
2912 /* XXX: cannot do more */
2915 c->buffer_ptr = c->pb_buffer;
2916 c->buffer_end = c->pb_buffer + len;
2917 c->state = RTSPSTATE_SEND_REPLY;
2921 static int prepare_sdp_description(FFStream *stream, uint8_t **pbuffer,
2922 struct in_addr my_ip)
2924 AVFormatContext *avc;
2925 AVStream *avs = NULL;
2928 avc = avformat_alloc_context();
2932 av_dict_set(&avc->metadata, "title",
2933 stream->title[0] ? stream->title : "No Title", 0);
2934 avc->nb_streams = stream->nb_streams;
2935 if (stream->is_multicast) {
2936 snprintf(avc->filename, 1024, "rtp://%s:%d?multicast=1?ttl=%d",
2937 inet_ntoa(stream->multicast_ip),
2938 stream->multicast_port, stream->multicast_ttl);
2940 snprintf(avc->filename, 1024, "rtp://0.0.0.0");
2943 if (avc->nb_streams >= INT_MAX/sizeof(*avc->streams) ||
2944 !(avc->streams = av_malloc(avc->nb_streams * sizeof(*avc->streams))))
2946 if (avc->nb_streams >= INT_MAX/sizeof(*avs) ||
2947 !(avs = av_malloc(avc->nb_streams * sizeof(*avs))))
2950 for(i = 0; i < stream->nb_streams; i++) {
2951 avc->streams[i] = &avs[i];
2952 avc->streams[i]->codec = stream->streams[i]->codec;
2954 *pbuffer = av_mallocz(2048);
2955 av_sdp_create(&avc, 1, *pbuffer, 2048);
2958 av_free(avc->streams);
2959 av_dict_free(&avc->metadata);
2963 return strlen(*pbuffer);
2966 static void rtsp_cmd_options(HTTPContext *c, const char *url)
2968 // rtsp_reply_header(c, RTSP_STATUS_OK);
2969 avio_printf(c->pb, "RTSP/1.0 %d %s\r\n", RTSP_STATUS_OK, "OK");
2970 avio_printf(c->pb, "CSeq: %d\r\n", c->seq);
2971 avio_printf(c->pb, "Public: %s\r\n", "OPTIONS, DESCRIBE, SETUP, TEARDOWN, PLAY, PAUSE");
2972 avio_printf(c->pb, "\r\n");
2975 static void rtsp_cmd_describe(HTTPContext *c, const char *url)
2981 int content_length, len;
2982 struct sockaddr_in my_addr;
2984 /* find which url is asked */
2985 av_url_split(NULL, 0, NULL, 0, NULL, 0, NULL, path1, sizeof(path1), url);
2990 for(stream = first_stream; stream != NULL; stream = stream->next) {
2991 if (!stream->is_feed &&
2992 stream->fmt && !strcmp(stream->fmt->name, "rtp") &&
2993 !strcmp(path, stream->filename)) {
2997 /* no stream found */
2998 rtsp_reply_error(c, RTSP_STATUS_SERVICE); /* XXX: right error ? */
3002 /* prepare the media description in sdp format */
3004 /* get the host IP */
3005 len = sizeof(my_addr);
3006 getsockname(c->fd, (struct sockaddr *)&my_addr, &len);
3007 content_length = prepare_sdp_description(stream, &content, my_addr.sin_addr);
3008 if (content_length < 0) {
3009 rtsp_reply_error(c, RTSP_STATUS_INTERNAL);
3012 rtsp_reply_header(c, RTSP_STATUS_OK);
3013 avio_printf(c->pb, "Content-Base: %s/\r\n", url);
3014 avio_printf(c->pb, "Content-Type: application/sdp\r\n");
3015 avio_printf(c->pb, "Content-Length: %d\r\n", content_length);
3016 avio_printf(c->pb, "\r\n");
3017 avio_write(c->pb, content, content_length);
3021 static HTTPContext *find_rtp_session(const char *session_id)
3025 if (session_id[0] == '\0')
3028 for(c = first_http_ctx; c != NULL; c = c->next) {
3029 if (!strcmp(c->session_id, session_id))
3035 static RTSPTransportField *find_transport(RTSPMessageHeader *h, enum RTSPLowerTransport lower_transport)
3037 RTSPTransportField *th;
3040 for(i=0;i<h->nb_transports;i++) {
3041 th = &h->transports[i];
3042 if (th->lower_transport == lower_transport)
3048 static void rtsp_cmd_setup(HTTPContext *c, const char *url,
3049 RTSPMessageHeader *h)
3052 int stream_index, rtp_port, rtcp_port;
3057 RTSPTransportField *th;
3058 struct sockaddr_in dest_addr;
3059 RTSPActionServerSetup setup;
3061 /* find which url is asked */
3062 av_url_split(NULL, 0, NULL, 0, NULL, 0, NULL, path1, sizeof(path1), url);
3067 /* now check each stream */
3068 for(stream = first_stream; stream != NULL; stream = stream->next) {
3069 if (!stream->is_feed &&
3070 stream->fmt && !strcmp(stream->fmt->name, "rtp")) {
3071 /* accept aggregate filenames only if single stream */
3072 if (!strcmp(path, stream->filename)) {
3073 if (stream->nb_streams != 1) {
3074 rtsp_reply_error(c, RTSP_STATUS_AGGREGATE);
3081 for(stream_index = 0; stream_index < stream->nb_streams;
3083 snprintf(buf, sizeof(buf), "%s/streamid=%d",
3084 stream->filename, stream_index);
3085 if (!strcmp(path, buf))
3090 /* no stream found */
3091 rtsp_reply_error(c, RTSP_STATUS_SERVICE); /* XXX: right error ? */
3095 /* generate session id if needed */
3096 if (h->session_id[0] == '\0')
3097 snprintf(h->session_id, sizeof(h->session_id), "%08x%08x",
3098 av_lfg_get(&random_state), av_lfg_get(&random_state));
3100 /* find rtp session, and create it if none found */
3101 rtp_c = find_rtp_session(h->session_id);
3103 /* always prefer UDP */
3104 th = find_transport(h, RTSP_LOWER_TRANSPORT_UDP);
3106 th = find_transport(h, RTSP_LOWER_TRANSPORT_TCP);
3108 rtsp_reply_error(c, RTSP_STATUS_TRANSPORT);
3113 rtp_c = rtp_new_connection(&c->from_addr, stream, h->session_id,
3114 th->lower_transport);
3116 rtsp_reply_error(c, RTSP_STATUS_BANDWIDTH);
3120 /* open input stream */
3121 if (open_input_stream(rtp_c, "") < 0) {
3122 rtsp_reply_error(c, RTSP_STATUS_INTERNAL);
3127 /* test if stream is OK (test needed because several SETUP needs
3128 to be done for a given file) */
3129 if (rtp_c->stream != stream) {
3130 rtsp_reply_error(c, RTSP_STATUS_SERVICE);
3134 /* test if stream is already set up */
3135 if (rtp_c->rtp_ctx[stream_index]) {
3136 rtsp_reply_error(c, RTSP_STATUS_STATE);
3140 /* check transport */
3141 th = find_transport(h, rtp_c->rtp_protocol);
3142 if (!th || (th->lower_transport == RTSP_LOWER_TRANSPORT_UDP &&
3143 th->client_port_min <= 0)) {
3144 rtsp_reply_error(c, RTSP_STATUS_TRANSPORT);
3148 /* setup default options */
3149 setup.transport_option[0] = '\0';
3150 dest_addr = rtp_c->from_addr;
3151 dest_addr.sin_port = htons(th->client_port_min);
3154 if (rtp_new_av_stream(rtp_c, stream_index, &dest_addr, c) < 0) {
3155 rtsp_reply_error(c, RTSP_STATUS_TRANSPORT);
3159 /* now everything is OK, so we can send the connection parameters */
3160 rtsp_reply_header(c, RTSP_STATUS_OK);
3162 avio_printf(c->pb, "Session: %s\r\n", rtp_c->session_id);
3164 switch(rtp_c->rtp_protocol) {
3165 case RTSP_LOWER_TRANSPORT_UDP:
3166 rtp_port = ff_rtp_get_local_rtp_port(rtp_c->rtp_handles[stream_index]);
3167 rtcp_port = ff_rtp_get_local_rtcp_port(rtp_c->rtp_handles[stream_index]);
3168 avio_printf(c->pb, "Transport: RTP/AVP/UDP;unicast;"
3169 "client_port=%d-%d;server_port=%d-%d",
3170 th->client_port_min, th->client_port_max,
3171 rtp_port, rtcp_port);
3173 case RTSP_LOWER_TRANSPORT_TCP:
3174 avio_printf(c->pb, "Transport: RTP/AVP/TCP;interleaved=%d-%d",
3175 stream_index * 2, stream_index * 2 + 1);
3180 if (setup.transport_option[0] != '\0')
3181 avio_printf(c->pb, ";%s", setup.transport_option);
3182 avio_printf(c->pb, "\r\n");
3185 avio_printf(c->pb, "\r\n");
3189 /* find an rtp connection by using the session ID. Check consistency
3191 static HTTPContext *find_rtp_session_with_url(const char *url,
3192 const char *session_id)
3200 rtp_c = find_rtp_session(session_id);
3204 /* find which url is asked */
3205 av_url_split(NULL, 0, NULL, 0, NULL, 0, NULL, path1, sizeof(path1), url);
3209 if(!strcmp(path, rtp_c->stream->filename)) return rtp_c;
3210 for(s=0; s<rtp_c->stream->nb_streams; ++s) {
3211 snprintf(buf, sizeof(buf), "%s/streamid=%d",
3212 rtp_c->stream->filename, s);
3213 if(!strncmp(path, buf, sizeof(buf))) {
3214 // XXX: Should we reply with RTSP_STATUS_ONLY_AGGREGATE if nb_streams>1?
3219 if (len > 0 && path[len - 1] == '/' &&
3220 !strncmp(path, rtp_c->stream->filename, len - 1))
3225 static void rtsp_cmd_play(HTTPContext *c, const char *url, RTSPMessageHeader *h)
3229 rtp_c = find_rtp_session_with_url(url, h->session_id);
3231 rtsp_reply_error(c, RTSP_STATUS_SESSION);
3235 if (rtp_c->state != HTTPSTATE_SEND_DATA &&
3236 rtp_c->state != HTTPSTATE_WAIT_FEED &&
3237 rtp_c->state != HTTPSTATE_READY) {
3238 rtsp_reply_error(c, RTSP_STATUS_STATE);
3242 rtp_c->state = HTTPSTATE_SEND_DATA;
3244 /* now everything is OK, so we can send the connection parameters */
3245 rtsp_reply_header(c, RTSP_STATUS_OK);
3247 avio_printf(c->pb, "Session: %s\r\n", rtp_c->session_id);
3248 avio_printf(c->pb, "\r\n");
3251 static void rtsp_cmd_pause(HTTPContext *c, const char *url, RTSPMessageHeader *h)
3255 rtp_c = find_rtp_session_with_url(url, h->session_id);
3257 rtsp_reply_error(c, RTSP_STATUS_SESSION);
3261 if (rtp_c->state != HTTPSTATE_SEND_DATA &&
3262 rtp_c->state != HTTPSTATE_WAIT_FEED) {
3263 rtsp_reply_error(c, RTSP_STATUS_STATE);
3267 rtp_c->state = HTTPSTATE_READY;
3268 rtp_c->first_pts = AV_NOPTS_VALUE;
3269 /* now everything is OK, so we can send the connection parameters */
3270 rtsp_reply_header(c, RTSP_STATUS_OK);
3272 avio_printf(c->pb, "Session: %s\r\n", rtp_c->session_id);
3273 avio_printf(c->pb, "\r\n");
3276 static void rtsp_cmd_teardown(HTTPContext *c, const char *url, RTSPMessageHeader *h)
3280 rtp_c = find_rtp_session_with_url(url, h->session_id);
3282 rtsp_reply_error(c, RTSP_STATUS_SESSION);
3286 /* now everything is OK, so we can send the connection parameters */
3287 rtsp_reply_header(c, RTSP_STATUS_OK);
3289 avio_printf(c->pb, "Session: %s\r\n", rtp_c->session_id);
3290 avio_printf(c->pb, "\r\n");
3292 /* abort the session */
3293 close_connection(rtp_c);
3297 /********************************************************************/
3300 static HTTPContext *rtp_new_connection(struct sockaddr_in *from_addr,
3301 FFStream *stream, const char *session_id,
3302 enum RTSPLowerTransport rtp_protocol)
3304 HTTPContext *c = NULL;
3305 const char *proto_str;
3307 /* XXX: should output a warning page when coming
3308 close to the connection limit */
3309 if (nb_connections >= nb_max_connections)
3312 /* add a new connection */
3313 c = av_mallocz(sizeof(HTTPContext));
3318 c->poll_entry = NULL;
3319 c->from_addr = *from_addr;
3320 c->buffer_size = IOBUFFER_INIT_SIZE;
3321 c->buffer = av_malloc(c->buffer_size);
3326 av_strlcpy(c->session_id, session_id, sizeof(c->session_id));
3327 c->state = HTTPSTATE_READY;
3328 c->is_packetized = 1;
3329 c->rtp_protocol = rtp_protocol;
3331 /* protocol is shown in statistics */
3332 switch(c->rtp_protocol) {
3333 case RTSP_LOWER_TRANSPORT_UDP_MULTICAST:
3334 proto_str = "MCAST";
3336 case RTSP_LOWER_TRANSPORT_UDP:
3339 case RTSP_LOWER_TRANSPORT_TCP:
3346 av_strlcpy(c->protocol, "RTP/", sizeof(c->protocol));
3347 av_strlcat(c->protocol, proto_str, sizeof(c->protocol));
3349 current_bandwidth += stream->bandwidth;
3351 c->next = first_http_ctx;
3363 /* add a new RTP stream in an RTP connection (used in RTSP SETUP
3364 command). If RTP/TCP protocol is used, TCP connection 'rtsp_c' is
3366 static int rtp_new_av_stream(HTTPContext *c,
3367 int stream_index, struct sockaddr_in *dest_addr,
3368 HTTPContext *rtsp_c)
3370 AVFormatContext *ctx;
3373 URLContext *h = NULL;
3375 int max_packet_size;
3377 /* now we can open the relevant output stream */
3378 ctx = avformat_alloc_context();
3381 ctx->oformat = av_guess_format("rtp", NULL, NULL);
3383 st = av_mallocz(sizeof(AVStream));
3386 ctx->nb_streams = 1;
3387 ctx->streams = av_mallocz(sizeof(AVStream *) * ctx->nb_streams);
3390 ctx->streams[0] = st;
3392 if (!c->stream->feed ||
3393 c->stream->feed == c->stream)
3394 memcpy(st, c->stream->streams[stream_index], sizeof(AVStream));
3397 c->stream->feed->streams[c->stream->feed_streams[stream_index]],
3399 st->priv_data = NULL;
3401 /* build destination RTP address */
3402 ipaddr = inet_ntoa(dest_addr->sin_addr);
3404 switch(c->rtp_protocol) {
3405 case RTSP_LOWER_TRANSPORT_UDP:
3406 case RTSP_LOWER_TRANSPORT_UDP_MULTICAST:
3409 /* XXX: also pass as parameter to function ? */
3410 if (c->stream->is_multicast) {
3412 ttl = c->stream->multicast_ttl;
3415 snprintf(ctx->filename, sizeof(ctx->filename),
3416 "rtp://%s:%d?multicast=1&ttl=%d",
3417 ipaddr, ntohs(dest_addr->sin_port), ttl);
3419 snprintf(ctx->filename, sizeof(ctx->filename),
3420 "rtp://%s:%d", ipaddr, ntohs(dest_addr->sin_port));
3423 if (ffurl_open(&h, ctx->filename, AVIO_FLAG_WRITE, NULL, NULL) < 0)
3425 c->rtp_handles[stream_index] = h;
3426 max_packet_size = h->max_packet_size;
3428 case RTSP_LOWER_TRANSPORT_TCP:
3431 max_packet_size = RTSP_TCP_MAX_PACKET_SIZE;
3437 http_log("%s:%d - - \"PLAY %s/streamid=%d %s\"\n",
3438 ipaddr, ntohs(dest_addr->sin_port),
3439 c->stream->filename, stream_index, c->protocol);
3441 /* normally, no packets should be output here, but the packet size may be checked */
3442 if (ffio_open_dyn_packet_buf(&ctx->pb, max_packet_size) < 0) {
3443 /* XXX: close stream */
3446 if (avformat_write_header(ctx, NULL) < 0) {
3453 avio_close_dyn_buf(ctx->pb, &dummy_buf);
3456 c->rtp_ctx[stream_index] = ctx;
3460 /********************************************************************/
3461 /* ffserver initialization */
3463 static AVStream *add_av_stream1(FFStream *stream, AVCodecContext *codec, int copy)
3467 fst = av_mallocz(sizeof(AVStream));
3471 fst->codec = avcodec_alloc_context3(NULL);
3472 memcpy(fst->codec, codec, sizeof(AVCodecContext));
3473 if (codec->extradata_size) {
3474 fst->codec->extradata = av_malloc(codec->extradata_size);
3475 memcpy(fst->codec->extradata, codec->extradata,
3476 codec->extradata_size);
3479 /* live streams must use the actual feed's codec since it may be
3480 * updated later to carry extradata needed by the streams.
3484 fst->priv_data = av_mallocz(sizeof(FeedData));
3485 fst->index = stream->nb_streams;
3486 avpriv_set_pts_info(fst, 33, 1, 90000);
3487 fst->sample_aspect_ratio = codec->sample_aspect_ratio;
3488 stream->streams[stream->nb_streams++] = fst;
3492 /* return the stream number in the feed */
3493 static int add_av_stream(FFStream *feed, AVStream *st)
3496 AVCodecContext *av, *av1;
3500 for(i=0;i<feed->nb_streams;i++) {
3501 st = feed->streams[i];
3503 if (av1->codec_id == av->codec_id &&
3504 av1->codec_type == av->codec_type &&
3505 av1->bit_rate == av->bit_rate) {
3507 switch(av->codec_type) {
3508 case AVMEDIA_TYPE_AUDIO:
3509 if (av1->channels == av->channels &&
3510 av1->sample_rate == av->sample_rate)
3513 case AVMEDIA_TYPE_VIDEO:
3514 if (av1->width == av->width &&
3515 av1->height == av->height &&
3516 av1->time_base.den == av->time_base.den &&
3517 av1->time_base.num == av->time_base.num &&
3518 av1->gop_size == av->gop_size)
3527 fst = add_av_stream1(feed, av, 0);
3530 return feed->nb_streams - 1;
3533 static void remove_stream(FFStream *stream)
3537 while (*ps != NULL) {
3545 /* specific mpeg4 handling : we extract the raw parameters */
3546 static void extract_mpeg4_header(AVFormatContext *infile)
3548 int mpeg4_count, i, size;
3554 for(i=0;i<infile->nb_streams;i++) {
3555 st = infile->streams[i];
3556 if (st->codec->codec_id == CODEC_ID_MPEG4 &&
3557 st->codec->extradata_size == 0) {
3564 printf("MPEG4 without extra data: trying to find header in %s\n", infile->filename);
3565 while (mpeg4_count > 0) {
3566 if (av_read_packet(infile, &pkt) < 0)
3568 st = infile->streams[pkt.stream_index];
3569 if (st->codec->codec_id == CODEC_ID_MPEG4 &&
3570 st->codec->extradata_size == 0) {
3571 av_freep(&st->codec->extradata);
3572 /* fill extradata with the header */
3573 /* XXX: we make hard suppositions here ! */
3575 while (p < pkt.data + pkt.size - 4) {
3576 /* stop when vop header is found */
3577 if (p[0] == 0x00 && p[1] == 0x00 &&
3578 p[2] == 0x01 && p[3] == 0xb6) {
3579 size = p - pkt.data;
3580 // av_hex_dump_log(infile, AV_LOG_DEBUG, pkt.data, size);
3581 st->codec->extradata = av_malloc(size);
3582 st->codec->extradata_size = size;
3583 memcpy(st->codec->extradata, pkt.data, size);
3590 av_free_packet(&pkt);
3594 /* compute the needed AVStream for each file */
3595 static void build_file_streams(void)
3597 FFStream *stream, *stream_next;
3600 /* gather all streams */
3601 for(stream = first_stream; stream != NULL; stream = stream_next) {
3602 AVFormatContext *infile = NULL;
3603 stream_next = stream->next;
3604 if (stream->stream_type == STREAM_TYPE_LIVE &&
3606 /* the stream comes from a file */
3607 /* try to open the file */
3609 if (stream->fmt && !strcmp(stream->fmt->name, "rtp")) {
3610 /* specific case : if transport stream output to RTP,
3611 we use a raw transport stream reader */
3612 av_dict_set(&stream->in_opts, "mpeg2ts_compute_pcr", "1", 0);
3615 http_log("Opening file '%s'\n", stream->feed_filename);
3616 if ((ret = avformat_open_input(&infile, stream->feed_filename, stream->ifmt, &stream->in_opts)) < 0) {
3617 http_log("Could not open '%s': %d\n", stream->feed_filename, ret);
3618 /* remove stream (no need to spend more time on it) */
3620 remove_stream(stream);
3622 /* find all the AVStreams inside and reference them in
3624 if (avformat_find_stream_info(infile, NULL) < 0) {
3625 http_log("Could not find codec parameters from '%s'\n",
3626 stream->feed_filename);
3627 avformat_close_input(&infile);
3630 extract_mpeg4_header(infile);
3632 for(i=0;i<infile->nb_streams;i++)
3633 add_av_stream1(stream, infile->streams[i]->codec, 1);
3635 avformat_close_input(&infile);
3641 /* compute the needed AVStream for each feed */
3642 static void build_feed_streams(void)
3644 FFStream *stream, *feed;
3647 /* gather all streams */
3648 for(stream = first_stream; stream != NULL; stream = stream->next) {
3649 feed = stream->feed;
3651 if (stream->is_feed) {
3652 for(i=0;i<stream->nb_streams;i++)
3653 stream->feed_streams[i] = i;
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 /* create feed files if needed */
3663 for(feed = first_feed; feed != NULL; feed = feed->next_feed) {
3666 if (avio_check(feed->feed_filename, AVIO_FLAG_READ) > 0) {
3667 /* See if it matches */
3668 AVFormatContext *s = NULL;
3671 if (avformat_open_input(&s, feed->feed_filename, NULL, NULL) >= 0) {
3672 /* set buffer size */
3673 ffio_set_buf_size(s->pb, FFM_PACKET_SIZE);
3674 /* Now see if it matches */
3675 if (s->nb_streams == feed->nb_streams) {
3677 for(i=0;i<s->nb_streams;i++) {
3679 sf = feed->streams[i];
3682 if (sf->index != ss->index ||
3684 http_log("Index & Id do not match for stream %d (%s)\n",
3685 i, feed->feed_filename);
3688 AVCodecContext *ccf, *ccs;
3692 #define CHECK_CODEC(x) (ccf->x != ccs->x)
3694 if (CHECK_CODEC(codec_id) || CHECK_CODEC(codec_type)) {
3695 http_log("Codecs do not match for stream %d\n", i);
3697 } else if (CHECK_CODEC(bit_rate) || CHECK_CODEC(flags)) {
3698 http_log("Codec bitrates do not match for stream %d\n", i);
3700 } else if (ccf->codec_type == AVMEDIA_TYPE_VIDEO) {
3701 if (CHECK_CODEC(time_base.den) ||
3702 CHECK_CODEC(time_base.num) ||
3703 CHECK_CODEC(width) ||
3704 CHECK_CODEC(height)) {
3705 http_log("Codec width, height and framerate do not match for stream %d\n", i);
3708 } else if (ccf->codec_type == AVMEDIA_TYPE_AUDIO) {
3709 if (CHECK_CODEC(sample_rate) ||
3710 CHECK_CODEC(channels) ||
3711 CHECK_CODEC(frame_size)) {
3712 http_log("Codec sample_rate, channels, frame_size do not match for stream %d\n", i);
3716 http_log("Unknown codec type\n");
3724 http_log("Deleting feed file '%s' as stream counts differ (%d != %d)\n",
3725 feed->feed_filename, s->nb_streams, feed->nb_streams);
3727 avformat_close_input(&s);
3729 http_log("Deleting feed file '%s' as it appears to be corrupt\n",
3730 feed->feed_filename);
3733 if (feed->readonly) {
3734 http_log("Unable to delete feed file '%s' as it is marked readonly\n",
3735 feed->feed_filename);
3738 unlink(feed->feed_filename);
3741 if (avio_check(feed->feed_filename, AVIO_FLAG_WRITE) <= 0) {
3742 AVFormatContext s1 = {0}, *s = &s1;
3744 if (feed->readonly) {
3745 http_log("Unable to create feed file '%s' as it is marked readonly\n",
3746 feed->feed_filename);
3750 /* only write the header of the ffm file */
3751 if (avio_open(&s->pb, feed->feed_filename, AVIO_FLAG_WRITE) < 0) {
3752 http_log("Could not open output feed file '%s'\n",
3753 feed->feed_filename);
3756 s->oformat = feed->fmt;
3757 s->nb_streams = feed->nb_streams;
3758 s->streams = feed->streams;
3759 if (avformat_write_header(s, NULL) < 0) {
3760 http_log("Container doesn't supports the required parameters\n");
3763 /* XXX: need better api */
3764 av_freep(&s->priv_data);
3767 /* get feed size and write index */
3768 fd = open(feed->feed_filename, O_RDONLY);
3770 http_log("Could not open output feed file '%s'\n",
3771 feed->feed_filename);
3775 feed->feed_write_index = FFMAX(ffm_read_write_index(fd), FFM_PACKET_SIZE);
3776 feed->feed_size = lseek(fd, 0, SEEK_END);
3777 /* ensure that we do not wrap before the end of file */
3778 if (feed->feed_max_size && feed->feed_max_size < feed->feed_size)
3779 feed->feed_max_size = feed->feed_size;
3785 /* compute the bandwidth used by each stream */
3786 static void compute_bandwidth(void)
3792 for(stream = first_stream; stream != NULL; stream = stream->next) {
3794 for(i=0;i<stream->nb_streams;i++) {
3795 AVStream *st = stream->streams[i];
3796 switch(st->codec->codec_type) {
3797 case AVMEDIA_TYPE_AUDIO:
3798 case AVMEDIA_TYPE_VIDEO:
3799 bandwidth += st->codec->bit_rate;
3805 stream->bandwidth = (bandwidth + 999) / 1000;
3809 /* add a codec and set the default parameters */
3810 static void add_codec(FFStream *stream, AVCodecContext *av)
3814 /* compute default parameters */
3815 switch(av->codec_type) {
3816 case AVMEDIA_TYPE_AUDIO:
3817 if (av->bit_rate == 0)
3818 av->bit_rate = 64000;
3819 if (av->sample_rate == 0)
3820 av->sample_rate = 22050;
3821 if (av->channels == 0)
3824 case AVMEDIA_TYPE_VIDEO:
3825 if (av->bit_rate == 0)
3826 av->bit_rate = 64000;
3827 if (av->time_base.num == 0){
3828 av->time_base.den = 5;
3829 av->time_base.num = 1;
3831 if (av->width == 0 || av->height == 0) {
3835 /* Bitrate tolerance is less for streaming */
3836 if (av->bit_rate_tolerance == 0)
3837 av->bit_rate_tolerance = FFMAX(av->bit_rate / 4,
3838 (int64_t)av->bit_rate*av->time_base.num/av->time_base.den);
3843 if (av->max_qdiff == 0)
3845 av->qcompress = 0.5;
3848 if (!av->nsse_weight)
3849 av->nsse_weight = 8;
3851 av->frame_skip_cmp = FF_CMP_DCTMAX;
3853 av->me_method = ME_EPZS;
3854 av->rc_buffer_aggressivity = 1.0;
3857 av->rc_eq = "tex^qComp";
3858 if (!av->i_quant_factor)
3859 av->i_quant_factor = -0.8;
3860 if (!av->b_quant_factor)
3861 av->b_quant_factor = 1.25;
3862 if (!av->b_quant_offset)
3863 av->b_quant_offset = 1.25;
3864 if (!av->rc_max_rate)
3865 av->rc_max_rate = av->bit_rate * 2;
3867 if (av->rc_max_rate && !av->rc_buffer_size) {
3868 av->rc_buffer_size = av->rc_max_rate;
3877 st = av_mallocz(sizeof(AVStream));
3880 st->codec = avcodec_alloc_context3(NULL);
3881 stream->streams[stream->nb_streams++] = st;
3882 memcpy(st->codec, av, sizeof(AVCodecContext));
3885 static enum CodecID opt_audio_codec(const char *arg)
3887 AVCodec *p= avcodec_find_encoder_by_name(arg);
3889 if (p == NULL || p->type != AVMEDIA_TYPE_AUDIO)
3890 return CODEC_ID_NONE;
3895 static enum CodecID opt_video_codec(const char *arg)
3897 AVCodec *p= avcodec_find_encoder_by_name(arg);
3899 if (p == NULL || p->type != AVMEDIA_TYPE_VIDEO)
3900 return CODEC_ID_NONE;
3905 /* simplistic plugin support */
3908 static void load_module(const char *filename)
3911 void (*init_func)(void);
3912 dll = dlopen(filename, RTLD_NOW);
3914 fprintf(stderr, "Could not load module '%s' - %s\n",
3915 filename, dlerror());
3919 init_func = dlsym(dll, "ffserver_module_init");
3922 "%s: init function 'ffserver_module_init()' not found\n",
3931 static int ffserver_opt_default(const char *opt, const char *arg,
3932 AVCodecContext *avctx, int type)
3935 const AVOption *o = av_opt_find(avctx, opt, NULL, type, 0);
3937 ret = av_opt_set(avctx, opt, arg, 0);
3941 static int ffserver_opt_preset(const char *arg,
3942 AVCodecContext *avctx, int type,
3943 enum CodecID *audio_id, enum CodecID *video_id)
3946 char filename[1000], tmp[1000], tmp2[1000], line[1000];
3948 AVCodec *codec = avcodec_find_encoder(avctx->codec_id);
3950 if (!(f = get_preset_file(filename, sizeof(filename), arg, 0,
3951 codec ? codec->name : NULL))) {
3952 fprintf(stderr, "File for preset '%s' not found\n", arg);
3957 int e= fscanf(f, "%999[^\n]\n", line) - 1;
3958 if(line[0] == '#' && !e)
3960 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
3962 fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
3966 if(!strcmp(tmp, "acodec")){
3967 *audio_id = opt_audio_codec(tmp2);
3968 }else if(!strcmp(tmp, "vcodec")){
3969 *video_id = opt_video_codec(tmp2);
3970 }else if(!strcmp(tmp, "scodec")){
3971 /* opt_subtitle_codec(tmp2); */
3972 }else if(ffserver_opt_default(tmp, tmp2, avctx, type) < 0){
3973 fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
3984 static AVOutputFormat *ffserver_guess_format(const char *short_name, const char *filename,
3985 const char *mime_type)
3987 AVOutputFormat *fmt = av_guess_format(short_name, filename, mime_type);
3990 AVOutputFormat *stream_fmt;
3991 char stream_format_name[64];
3993 snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
3994 stream_fmt = av_guess_format(stream_format_name, NULL, NULL);
4003 static void report_config_error(const char *filename, int line_num, int *errors, const char *fmt, ...)
4007 fprintf(stderr, "%s:%d: ", filename, line_num);
4008 vfprintf(stderr, fmt, vl);
4014 static int parse_ffconfig(const char *filename)
4021 int val, errors, line_num;
4022 FFStream **last_stream, *stream, *redirect;
4023 FFStream **last_feed, *feed, *s;
4024 AVCodecContext audio_enc, video_enc;
4025 enum CodecID audio_id, video_id;
4027 f = fopen(filename, "r");
4035 first_stream = NULL;
4036 last_stream = &first_stream;
4038 last_feed = &first_feed;
4042 audio_id = CODEC_ID_NONE;
4043 video_id = CODEC_ID_NONE;
4045 #define ERROR(...) report_config_error(filename, line_num, &errors, __VA_ARGS__)
4047 if (fgets(line, sizeof(line), f) == NULL)
4053 if (*p == '\0' || *p == '#')
4056 get_arg(cmd, sizeof(cmd), &p);
4058 if (!av_strcasecmp(cmd, "Port")) {
4059 get_arg(arg, sizeof(arg), &p);
4061 if (val < 1 || val > 65536) {
4062 ERROR("Invalid_port: %s\n", arg);
4064 my_http_addr.sin_port = htons(val);
4065 } else if (!av_strcasecmp(cmd, "BindAddress")) {
4066 get_arg(arg, sizeof(arg), &p);
4067 if (resolve_host(&my_http_addr.sin_addr, arg) != 0) {
4068 ERROR("%s:%d: Invalid host/IP address: %s\n", arg);
4070 } else if (!av_strcasecmp(cmd, "NoDaemon")) {
4071 ffserver_daemon = 0;
4072 } else if (!av_strcasecmp(cmd, "RTSPPort")) {
4073 get_arg(arg, sizeof(arg), &p);
4075 if (val < 1 || val > 65536) {
4076 ERROR("%s:%d: Invalid port: %s\n", arg);
4078 my_rtsp_addr.sin_port = htons(atoi(arg));
4079 } else if (!av_strcasecmp(cmd, "RTSPBindAddress")) {
4080 get_arg(arg, sizeof(arg), &p);
4081 if (resolve_host(&my_rtsp_addr.sin_addr, arg) != 0) {
4082 ERROR("Invalid host/IP address: %s\n", arg);
4084 } else if (!av_strcasecmp(cmd, "MaxHTTPConnections")) {
4085 get_arg(arg, sizeof(arg), &p);
4087 if (val < 1 || val > 65536) {
4088 ERROR("Invalid MaxHTTPConnections: %s\n", arg);
4090 nb_max_http_connections = val;
4091 } else if (!av_strcasecmp(cmd, "MaxClients")) {
4092 get_arg(arg, sizeof(arg), &p);
4094 if (val < 1 || val > nb_max_http_connections) {
4095 ERROR("Invalid MaxClients: %s\n", arg);
4097 nb_max_connections = val;
4099 } else if (!av_strcasecmp(cmd, "MaxBandwidth")) {
4101 get_arg(arg, sizeof(arg), &p);
4103 if (llval < 10 || llval > 10000000) {
4104 ERROR("Invalid MaxBandwidth: %s\n", arg);
4106 max_bandwidth = llval;
4107 } else if (!av_strcasecmp(cmd, "CustomLog")) {
4108 if (!ffserver_debug)
4109 get_arg(logfilename, sizeof(logfilename), &p);
4110 } else if (!av_strcasecmp(cmd, "<Feed")) {
4111 /*********************************************/
4112 /* Feed related options */
4114 if (stream || feed) {
4115 ERROR("Already in a tag\n");
4117 feed = av_mallocz(sizeof(FFStream));
4118 get_arg(feed->filename, sizeof(feed->filename), &p);
4119 q = strrchr(feed->filename, '>');
4123 for (s = first_feed; s; s = s->next) {
4124 if (!strcmp(feed->filename, s->filename)) {
4125 ERROR("Feed '%s' already registered\n", s->filename);
4129 feed->fmt = av_guess_format("ffm", NULL, NULL);
4130 /* defaut feed file */
4131 snprintf(feed->feed_filename, sizeof(feed->feed_filename),
4132 "/tmp/%s.ffm", feed->filename);
4133 feed->feed_max_size = 5 * 1024 * 1024;
4135 feed->feed = feed; /* self feeding :-) */
4137 /* add in stream list */
4138 *last_stream = feed;
4139 last_stream = &feed->next;
4140 /* add in feed list */
4142 last_feed = &feed->next_feed;
4144 } else if (!av_strcasecmp(cmd, "Launch")) {
4148 feed->child_argv = av_mallocz(64 * sizeof(char *));
4150 for (i = 0; i < 62; i++) {
4151 get_arg(arg, sizeof(arg), &p);
4155 feed->child_argv[i] = av_strdup(arg);
4158 feed->child_argv[i] = av_malloc(30 + strlen(feed->filename));
4160 snprintf(feed->child_argv[i], 30+strlen(feed->filename),
4162 (my_http_addr.sin_addr.s_addr == INADDR_ANY) ? "127.0.0.1" :
4163 inet_ntoa(my_http_addr.sin_addr),
4164 ntohs(my_http_addr.sin_port), feed->filename);
4166 } else if (!av_strcasecmp(cmd, "ReadOnlyFile")) {
4168 get_arg(feed->feed_filename, sizeof(feed->feed_filename), &p);
4170 } else if (stream) {
4171 get_arg(stream->feed_filename, sizeof(stream->feed_filename), &p);
4173 } else if (!av_strcasecmp(cmd, "File")) {
4175 get_arg(feed->feed_filename, sizeof(feed->feed_filename), &p);
4177 get_arg(stream->feed_filename, sizeof(stream->feed_filename), &p);
4178 } else if (!av_strcasecmp(cmd, "Truncate")) {
4180 get_arg(arg, sizeof(arg), &p);
4181 feed->truncate = strtod(arg, NULL);
4183 } else if (!av_strcasecmp(cmd, "FileMaxSize")) {
4188 get_arg(arg, sizeof(arg), &p);
4190 fsize = strtod(p1, &p1);
4191 switch(toupper(*p1)) {
4196 fsize *= 1024 * 1024;
4199 fsize *= 1024 * 1024 * 1024;
4202 feed->feed_max_size = (int64_t)fsize;
4203 if (feed->feed_max_size < FFM_PACKET_SIZE*4) {
4204 ERROR("Feed max file size is too small, must be at least %d\n", FFM_PACKET_SIZE*4);
4207 } else if (!av_strcasecmp(cmd, "</Feed>")) {
4209 ERROR("No corresponding <Feed> for </Feed>\n");
4212 } else if (!av_strcasecmp(cmd, "<Stream")) {
4213 /*********************************************/
4214 /* Stream related options */
4216 if (stream || feed) {
4217 ERROR("Already in a tag\n");
4220 stream = av_mallocz(sizeof(FFStream));
4221 get_arg(stream->filename, sizeof(stream->filename), &p);
4222 q = strrchr(stream->filename, '>');
4226 for (s = first_stream; s; s = s->next) {
4227 if (!strcmp(stream->filename, s->filename)) {
4228 ERROR("Stream '%s' already registered\n", s->filename);
4232 stream->fmt = ffserver_guess_format(NULL, stream->filename, NULL);
4233 avcodec_get_context_defaults3(&video_enc, NULL);
4234 avcodec_get_context_defaults3(&audio_enc, NULL);
4236 audio_id = CODEC_ID_NONE;
4237 video_id = CODEC_ID_NONE;
4239 audio_id = stream->fmt->audio_codec;
4240 video_id = stream->fmt->video_codec;
4243 *last_stream = stream;
4244 last_stream = &stream->next;
4246 } else if (!av_strcasecmp(cmd, "Feed")) {
4247 get_arg(arg, sizeof(arg), &p);
4252 while (sfeed != NULL) {
4253 if (!strcmp(sfeed->filename, arg))
4255 sfeed = sfeed->next_feed;
4258 ERROR("feed '%s' not defined\n", arg);
4260 stream->feed = sfeed;
4262 } else if (!av_strcasecmp(cmd, "Format")) {
4263 get_arg(arg, sizeof(arg), &p);
4265 if (!strcmp(arg, "status")) {
4266 stream->stream_type = STREAM_TYPE_STATUS;
4269 stream->stream_type = STREAM_TYPE_LIVE;
4270 /* jpeg cannot be used here, so use single frame jpeg */
4271 if (!strcmp(arg, "jpeg"))
4272 strcpy(arg, "mjpeg");
4273 stream->fmt = ffserver_guess_format(arg, NULL, NULL);
4275 ERROR("Unknown Format: %s\n", arg);
4279 audio_id = stream->fmt->audio_codec;
4280 video_id = stream->fmt->video_codec;
4283 } else if (!av_strcasecmp(cmd, "InputFormat")) {
4284 get_arg(arg, sizeof(arg), &p);
4286 stream->ifmt = av_find_input_format(arg);
4287 if (!stream->ifmt) {
4288 ERROR("Unknown input format: %s\n", arg);
4291 } else if (!av_strcasecmp(cmd, "FaviconURL")) {
4292 if (stream && stream->stream_type == STREAM_TYPE_STATUS) {
4293 get_arg(stream->feed_filename, sizeof(stream->feed_filename), &p);
4295 ERROR("FaviconURL only permitted for status streams\n");
4297 } else if (!av_strcasecmp(cmd, "Author")) {
4299 get_arg(stream->author, sizeof(stream->author), &p);
4300 } else if (!av_strcasecmp(cmd, "Comment")) {
4302 get_arg(stream->comment, sizeof(stream->comment), &p);
4303 } else if (!av_strcasecmp(cmd, "Copyright")) {
4305 get_arg(stream->copyright, sizeof(stream->copyright), &p);
4306 } else if (!av_strcasecmp(cmd, "Title")) {
4308 get_arg(stream->title, sizeof(stream->title), &p);
4309 } else if (!av_strcasecmp(cmd, "Preroll")) {
4310 get_arg(arg, sizeof(arg), &p);
4312 stream->prebuffer = atof(arg) * 1000;
4313 } else if (!av_strcasecmp(cmd, "StartSendOnKey")) {
4315 stream->send_on_key = 1;
4316 } else if (!av_strcasecmp(cmd, "AudioCodec")) {
4317 get_arg(arg, sizeof(arg), &p);
4318 audio_id = opt_audio_codec(arg);
4319 if (audio_id == CODEC_ID_NONE) {
4320 ERROR("Unknown AudioCodec: %s\n", arg);
4322 } else if (!av_strcasecmp(cmd, "VideoCodec")) {
4323 get_arg(arg, sizeof(arg), &p);
4324 video_id = opt_video_codec(arg);
4325 if (video_id == CODEC_ID_NONE) {
4326 ERROR("Unknown VideoCodec: %s\n", arg);
4328 } else if (!av_strcasecmp(cmd, "MaxTime")) {
4329 get_arg(arg, sizeof(arg), &p);
4331 stream->max_time = atof(arg) * 1000;
4332 } else if (!av_strcasecmp(cmd, "AudioBitRate")) {
4333 get_arg(arg, sizeof(arg), &p);
4335 audio_enc.bit_rate = lrintf(atof(arg) * 1000);
4336 } else if (!av_strcasecmp(cmd, "AudioChannels")) {
4337 get_arg(arg, sizeof(arg), &p);
4339 audio_enc.channels = atoi(arg);
4340 } else if (!av_strcasecmp(cmd, "AudioSampleRate")) {
4341 get_arg(arg, sizeof(arg), &p);
4343 audio_enc.sample_rate = atoi(arg);
4344 } else if (!av_strcasecmp(cmd, "AudioQuality")) {
4345 get_arg(arg, sizeof(arg), &p);
4347 // audio_enc.quality = atof(arg) * 1000;
4349 } else if (!av_strcasecmp(cmd, "VideoBitRateRange")) {
4351 int minrate, maxrate;
4353 get_arg(arg, sizeof(arg), &p);
4355 if (sscanf(arg, "%d-%d", &minrate, &maxrate) == 2) {
4356 video_enc.rc_min_rate = minrate * 1000;
4357 video_enc.rc_max_rate = maxrate * 1000;
4359 ERROR("Incorrect format for VideoBitRateRange -- should be <min>-<max>: %s\n", arg);
4362 } else if (!av_strcasecmp(cmd, "Debug")) {
4364 get_arg(arg, sizeof(arg), &p);
4365 video_enc.debug = strtol(arg,0,0);
4367 } else if (!av_strcasecmp(cmd, "Strict")) {
4369 get_arg(arg, sizeof(arg), &p);
4370 video_enc.strict_std_compliance = atoi(arg);
4372 } else if (!av_strcasecmp(cmd, "VideoBufferSize")) {
4374 get_arg(arg, sizeof(arg), &p);
4375 video_enc.rc_buffer_size = atoi(arg) * 8*1024;
4377 } else if (!av_strcasecmp(cmd, "VideoBitRateTolerance")) {
4379 get_arg(arg, sizeof(arg), &p);
4380 video_enc.bit_rate_tolerance = atoi(arg) * 1000;
4382 } else if (!av_strcasecmp(cmd, "VideoBitRate")) {
4383 get_arg(arg, sizeof(arg), &p);
4385 video_enc.bit_rate = atoi(arg) * 1000;
4387 } else if (!av_strcasecmp(cmd, "VideoSize")) {
4388 get_arg(arg, sizeof(arg), &p);
4390 av_parse_video_size(&video_enc.width, &video_enc.height, arg);
4391 if ((video_enc.width % 16) != 0 ||
4392 (video_enc.height % 16) != 0) {
4393 ERROR("Image size must be a multiple of 16\n");
4396 } else if (!av_strcasecmp(cmd, "VideoFrameRate")) {
4397 get_arg(arg, sizeof(arg), &p);
4399 AVRational frame_rate;
4400 if (av_parse_video_rate(&frame_rate, arg) < 0) {
4401 ERROR("Incorrect frame rate: %s\n", arg);
4403 video_enc.time_base.num = frame_rate.den;
4404 video_enc.time_base.den = frame_rate.num;
4407 } else if (!av_strcasecmp(cmd, "VideoGopSize")) {
4408 get_arg(arg, sizeof(arg), &p);
4410 video_enc.gop_size = atoi(arg);
4411 } else if (!av_strcasecmp(cmd, "VideoIntraOnly")) {
4413 video_enc.gop_size = 1;
4414 } else if (!av_strcasecmp(cmd, "VideoHighQuality")) {
4416 video_enc.mb_decision = FF_MB_DECISION_BITS;
4417 } else if (!av_strcasecmp(cmd, "Video4MotionVector")) {
4419 video_enc.mb_decision = FF_MB_DECISION_BITS; //FIXME remove
4420 video_enc.flags |= CODEC_FLAG_4MV;
4422 } else if (!av_strcasecmp(cmd, "AVOptionVideo") ||
4423 !av_strcasecmp(cmd, "AVOptionAudio")) {
4425 AVCodecContext *avctx;
4427 get_arg(arg, sizeof(arg), &p);
4428 get_arg(arg2, sizeof(arg2), &p);
4429 if (!av_strcasecmp(cmd, "AVOptionVideo")) {
4431 type = AV_OPT_FLAG_VIDEO_PARAM;
4434 type = AV_OPT_FLAG_AUDIO_PARAM;
4436 if (ffserver_opt_default(arg, arg2, avctx, type|AV_OPT_FLAG_ENCODING_PARAM)) {
4437 ERROR("AVOption error: %s %s\n", arg, arg2);
4439 } else if (!av_strcasecmp(cmd, "AVPresetVideo") ||
4440 !av_strcasecmp(cmd, "AVPresetAudio")) {
4441 AVCodecContext *avctx;
4443 get_arg(arg, sizeof(arg), &p);
4444 if (!av_strcasecmp(cmd, "AVPresetVideo")) {
4446 video_enc.codec_id = video_id;
4447 type = AV_OPT_FLAG_VIDEO_PARAM;
4450 audio_enc.codec_id = audio_id;
4451 type = AV_OPT_FLAG_AUDIO_PARAM;
4453 if (ffserver_opt_preset(arg, avctx, type|AV_OPT_FLAG_ENCODING_PARAM, &audio_id, &video_id)) {
4454 ERROR("AVPreset error: %s\n", arg);
4456 } else if (!av_strcasecmp(cmd, "VideoTag")) {
4457 get_arg(arg, sizeof(arg), &p);
4458 if ((strlen(arg) == 4) && stream)
4459 video_enc.codec_tag = MKTAG(arg[0], arg[1], arg[2], arg[3]);
4460 } else if (!av_strcasecmp(cmd, "BitExact")) {
4462 video_enc.flags |= CODEC_FLAG_BITEXACT;
4463 } else if (!av_strcasecmp(cmd, "DctFastint")) {
4465 video_enc.dct_algo = FF_DCT_FASTINT;
4466 } else if (!av_strcasecmp(cmd, "IdctSimple")) {
4468 video_enc.idct_algo = FF_IDCT_SIMPLE;
4469 } else if (!av_strcasecmp(cmd, "Qscale")) {
4470 get_arg(arg, sizeof(arg), &p);
4472 video_enc.flags |= CODEC_FLAG_QSCALE;
4473 video_enc.global_quality = FF_QP2LAMBDA * atoi(arg);
4475 } else if (!av_strcasecmp(cmd, "VideoQDiff")) {
4476 get_arg(arg, sizeof(arg), &p);
4478 video_enc.max_qdiff = atoi(arg);
4479 if (video_enc.max_qdiff < 1 || video_enc.max_qdiff > 31) {
4480 ERROR("VideoQDiff out of range\n");
4483 } else if (!av_strcasecmp(cmd, "VideoQMax")) {
4484 get_arg(arg, sizeof(arg), &p);
4486 video_enc.qmax = atoi(arg);
4487 if (video_enc.qmax < 1 || video_enc.qmax > 31) {
4488 ERROR("VideoQMax out of range\n");
4491 } else if (!av_strcasecmp(cmd, "VideoQMin")) {
4492 get_arg(arg, sizeof(arg), &p);
4494 video_enc.qmin = atoi(arg);
4495 if (video_enc.qmin < 1 || video_enc.qmin > 31) {
4496 ERROR("VideoQMin out of range\n");
4499 } else if (!av_strcasecmp(cmd, "LumaElim")) {
4500 get_arg(arg, sizeof(arg), &p);
4502 video_enc.luma_elim_threshold = atoi(arg);
4503 } else if (!av_strcasecmp(cmd, "ChromaElim")) {
4504 get_arg(arg, sizeof(arg), &p);
4506 video_enc.chroma_elim_threshold = atoi(arg);
4507 } else if (!av_strcasecmp(cmd, "LumiMask")) {
4508 get_arg(arg, sizeof(arg), &p);
4510 video_enc.lumi_masking = atof(arg);
4511 } else if (!av_strcasecmp(cmd, "DarkMask")) {
4512 get_arg(arg, sizeof(arg), &p);
4514 video_enc.dark_masking = atof(arg);
4515 } else if (!av_strcasecmp(cmd, "NoVideo")) {
4516 video_id = CODEC_ID_NONE;
4517 } else if (!av_strcasecmp(cmd, "NoAudio")) {
4518 audio_id = CODEC_ID_NONE;
4519 } else if (!av_strcasecmp(cmd, "ACL")) {
4520 parse_acl_row(stream, feed, NULL, p, filename, line_num);
4521 } else if (!av_strcasecmp(cmd, "DynamicACL")) {
4523 get_arg(stream->dynamic_acl, sizeof(stream->dynamic_acl), &p);
4525 } else if (!av_strcasecmp(cmd, "RTSPOption")) {
4526 get_arg(arg, sizeof(arg), &p);
4528 av_freep(&stream->rtsp_option);
4529 stream->rtsp_option = av_strdup(arg);
4531 } else if (!av_strcasecmp(cmd, "MulticastAddress")) {
4532 get_arg(arg, sizeof(arg), &p);
4534 if (resolve_host(&stream->multicast_ip, arg) != 0) {
4535 ERROR("Invalid host/IP address: %s\n", arg);
4537 stream->is_multicast = 1;
4538 stream->loop = 1; /* default is looping */
4540 } else if (!av_strcasecmp(cmd, "MulticastPort")) {
4541 get_arg(arg, sizeof(arg), &p);
4543 stream->multicast_port = atoi(arg);
4544 } else if (!av_strcasecmp(cmd, "MulticastTTL")) {
4545 get_arg(arg, sizeof(arg), &p);
4547 stream->multicast_ttl = atoi(arg);
4548 } else if (!av_strcasecmp(cmd, "NoLoop")) {
4551 } else if (!av_strcasecmp(cmd, "</Stream>")) {
4553 ERROR("No corresponding <Stream> for </Stream>\n");
4555 if (stream->feed && stream->fmt && strcmp(stream->fmt->name, "ffm") != 0) {
4556 if (audio_id != CODEC_ID_NONE) {
4557 audio_enc.codec_type = AVMEDIA_TYPE_AUDIO;
4558 audio_enc.codec_id = audio_id;
4559 add_codec(stream, &audio_enc);
4561 if (video_id != CODEC_ID_NONE) {
4562 video_enc.codec_type = AVMEDIA_TYPE_VIDEO;
4563 video_enc.codec_id = video_id;
4564 add_codec(stream, &video_enc);
4569 } else if (!av_strcasecmp(cmd, "<Redirect")) {
4570 /*********************************************/
4572 if (stream || feed || redirect) {
4573 ERROR("Already in a tag\n");
4575 redirect = av_mallocz(sizeof(FFStream));
4576 *last_stream = redirect;
4577 last_stream = &redirect->next;
4579 get_arg(redirect->filename, sizeof(redirect->filename), &p);
4580 q = strrchr(redirect->filename, '>');
4583 redirect->stream_type = STREAM_TYPE_REDIRECT;
4585 } else if (!av_strcasecmp(cmd, "URL")) {
4587 get_arg(redirect->feed_filename, sizeof(redirect->feed_filename), &p);
4588 } else if (!av_strcasecmp(cmd, "</Redirect>")) {
4590 ERROR("No corresponding <Redirect> for </Redirect>\n");
4592 if (!redirect->feed_filename[0]) {
4593 ERROR("No URL found for <Redirect>\n");
4597 } else if (!av_strcasecmp(cmd, "LoadModule")) {
4598 get_arg(arg, sizeof(arg), &p);
4602 ERROR("Module support not compiled into this version: '%s'\n", arg);
4605 ERROR("Incorrect keyword: '%s'\n", cmd);
4617 static void handle_child_exit(int sig)
4622 while ((pid = waitpid(-1, &status, WNOHANG)) > 0) {
4625 for (feed = first_feed; feed; feed = feed->next) {
4626 if (feed->pid == pid) {
4627 int uptime = time(0) - feed->pid_start;
4630 fprintf(stderr, "%s: Pid %d exited with status %d after %d seconds\n", feed->filename, pid, status, uptime);
4633 /* Turn off any more restarts */
4634 feed->child_argv = 0;
4639 need_to_start_children = 1;
4642 static void opt_debug(void)
4645 ffserver_daemon = 0;
4646 logfilename[0] = '-';
4649 static int opt_help(const char *opt, const char *arg)
4651 printf("usage: ffserver [options]\n"
4652 "Hyper fast multi format Audio/Video streaming server\n");
4654 show_help_options(options, "Main options:\n", 0, 0);
4658 static const OptionDef options[] = {
4659 #include "cmdutils_common_opts.h"
4660 { "n", OPT_BOOL, {(void *)&no_launch }, "enable no-launch mode" },
4661 { "d", 0, {(void*)opt_debug}, "enable debug mode" },
4662 { "f", HAS_ARG | OPT_STRING, {(void*)&config_filename }, "use configfile instead of /etc/ffserver.conf", "configfile" },
4666 int main(int argc, char **argv)
4668 struct sigaction sigact = { { 0 } };
4670 parse_loglevel(argc, argv, options);
4672 avformat_network_init();
4674 show_banner(argc, argv, options);
4676 my_program_name = argv[0];
4677 my_program_dir = getcwd(0, 0);
4678 ffserver_daemon = 1;
4680 parse_options(NULL, argc, argv, options, NULL);
4682 unsetenv("http_proxy"); /* Kill the http_proxy */
4684 av_lfg_init(&random_state, av_get_random_seed());
4686 sigact.sa_handler = handle_child_exit;
4687 sigact.sa_flags = SA_NOCLDSTOP | SA_RESTART;
4688 sigaction(SIGCHLD, &sigact, 0);
4690 if (parse_ffconfig(config_filename) < 0) {
4691 fprintf(stderr, "Incorrect config file - exiting.\n");
4695 /* open log file if needed */
4696 if (logfilename[0] != '\0') {
4697 if (!strcmp(logfilename, "-"))
4700 logfile = fopen(logfilename, "a");
4701 av_log_set_callback(http_av_log);
4704 build_file_streams();
4706 build_feed_streams();
4708 compute_bandwidth();
4710 /* put the process in background and detach it from its TTY */
4711 if (ffserver_daemon) {
4718 } else if (pid > 0) {
4725 open("/dev/null", O_RDWR);
4726 if (strcmp(logfilename, "-") != 0) {
4736 signal(SIGPIPE, SIG_IGN);
4738 if (ffserver_daemon)
4741 if (http_server() < 0) {
4742 http_log("Could not start server\n");