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>
67 const char program_name[] = "ffserver";
68 const int program_birth_year = 2000;
70 static const OptionDef options[];
73 HTTPSTATE_WAIT_REQUEST,
74 HTTPSTATE_SEND_HEADER,
75 HTTPSTATE_SEND_DATA_HEADER,
76 HTTPSTATE_SEND_DATA, /* sending TCP or UDP data */
77 HTTPSTATE_SEND_DATA_TRAILER,
78 HTTPSTATE_RECEIVE_DATA,
79 HTTPSTATE_WAIT_FEED, /* wait for data from the feed */
82 RTSPSTATE_WAIT_REQUEST,
84 RTSPSTATE_SEND_PACKET,
87 static const char *http_state[] = {
103 #define MAX_STREAMS 20
105 #define IOBUFFER_INIT_SIZE 8192
107 /* timeouts are in ms */
108 #define HTTP_REQUEST_TIMEOUT (15 * 1000)
109 #define RTSP_REQUEST_TIMEOUT (3600 * 24 * 1000)
111 #define SYNC_TIMEOUT (10 * 1000)
113 typedef struct RTSPActionServerSetup {
115 char transport_option[512];
116 } RTSPActionServerSetup;
119 int64_t count1, count2;
120 int64_t time1, time2;
123 /* context associated with one connection */
124 typedef struct HTTPContext {
125 enum HTTPState state;
126 int fd; /* socket file descriptor */
127 struct sockaddr_in from_addr; /* origin */
128 struct pollfd *poll_entry; /* used when polling */
130 uint8_t *buffer_ptr, *buffer_end;
133 int chunked_encoding;
134 int chunk_size; /* 0 if it needs to be read */
135 struct HTTPContext *next;
136 int got_key_frame; /* stream 0 => 1, stream 1 => 2, stream 2=> 4 */
140 /* input format handling */
141 AVFormatContext *fmt_in;
142 int64_t start_time; /* In milliseconds - this wraps fairly often */
143 int64_t first_pts; /* initial pts value */
144 int64_t cur_pts; /* current pts value from the stream in us */
145 int64_t cur_frame_duration; /* duration of the current frame in us */
146 int cur_frame_bytes; /* output frame size, needed to compute
147 the time at which we send each
149 int pts_stream_index; /* stream we choose as clock reference */
150 int64_t cur_clock; /* current clock reference value in us */
151 /* output format handling */
152 struct FFStream *stream;
153 /* -1 is invalid stream */
154 int feed_streams[MAX_STREAMS]; /* index of streams in the feed */
155 int switch_feed_streams[MAX_STREAMS]; /* index of streams in the feed */
157 AVFormatContext fmt_ctx; /* instance of FFStream for one user */
158 int last_packet_sent; /* true if last data packet was sent */
160 DataRateData datarate;
167 int is_packetized; /* if true, the stream is packetized */
168 int packet_stream_index; /* current stream for output in state machine */
170 /* RTSP state specific */
171 uint8_t *pb_buffer; /* XXX: use that in all the code */
173 int seq; /* RTSP sequence number */
175 /* RTP state specific */
176 enum RTSPLowerTransport rtp_protocol;
177 char session_id[32]; /* session id */
178 AVFormatContext *rtp_ctx[MAX_STREAMS];
180 /* RTP/UDP specific */
181 URLContext *rtp_handles[MAX_STREAMS];
183 /* RTP/TCP specific */
184 struct HTTPContext *rtsp_c;
185 uint8_t *packet_buffer, *packet_buffer_ptr, *packet_buffer_end;
188 /* each generated stream is described here */
192 STREAM_TYPE_REDIRECT,
195 enum IPAddressAction {
200 typedef struct IPAddressACL {
201 struct IPAddressACL *next;
202 enum IPAddressAction action;
203 /* These are in host order */
204 struct in_addr first;
208 /* description of each stream of the ffserver.conf file */
209 typedef struct FFStream {
210 enum StreamType stream_type;
211 char filename[1024]; /* stream filename */
212 struct FFStream *feed; /* feed we are using (can be null if
214 AVDictionary *in_opts; /* input parameters */
215 AVInputFormat *ifmt; /* if non NULL, force input format */
218 char dynamic_acl[1024];
220 int prebuffer; /* Number of millseconds early to start */
221 int64_t max_time; /* Number of milliseconds to run */
223 AVStream *streams[MAX_STREAMS];
224 int feed_streams[MAX_STREAMS]; /* index of streams in the feed */
225 char feed_filename[1024]; /* file name of the feed storage, or
226 input file name for a stream */
231 pid_t pid; /* Of ffmpeg process */
232 time_t pid_start; /* Of ffmpeg process */
234 struct FFStream *next;
235 unsigned bandwidth; /* bandwidth, in kbits/s */
238 /* multicast specific */
240 struct in_addr multicast_ip;
241 int multicast_port; /* first port used for multicast */
243 int loop; /* if true, send the stream in loops (only meaningful if file) */
246 int feed_opened; /* true if someone is writing to the feed */
247 int is_feed; /* true if it is a feed */
248 int readonly; /* True if writing is prohibited to the file */
249 int truncate; /* True if feeder connection truncate the feed file */
251 int64_t bytes_served;
252 int64_t feed_max_size; /* maximum storage size, zero means unlimited */
253 int64_t feed_write_index; /* current write position in feed (it wraps around) */
254 int64_t feed_size; /* current size of feed */
255 struct FFStream *next_feed;
258 typedef struct FeedData {
259 long long data_count;
260 float avg_frame_size; /* frame size averaged over last frames with exponential mean */
263 static struct sockaddr_in my_http_addr;
264 static struct sockaddr_in my_rtsp_addr;
266 static char logfilename[1024];
267 static HTTPContext *first_http_ctx;
268 static FFStream *first_feed; /* contains only feeds */
269 static FFStream *first_stream; /* contains all streams, including feeds */
271 static void new_connection(int server_fd, int is_rtsp);
272 static void close_connection(HTTPContext *c);
275 static int handle_connection(HTTPContext *c);
276 static int http_parse_request(HTTPContext *c);
277 static int http_send_data(HTTPContext *c);
278 static void compute_status(HTTPContext *c);
279 static int open_input_stream(HTTPContext *c, const char *info);
280 static int http_start_receive_data(HTTPContext *c);
281 static int http_receive_data(HTTPContext *c);
284 static int rtsp_parse_request(HTTPContext *c);
285 static void rtsp_cmd_describe(HTTPContext *c, const char *url);
286 static void rtsp_cmd_options(HTTPContext *c, const char *url);
287 static void rtsp_cmd_setup(HTTPContext *c, const char *url, RTSPMessageHeader *h);
288 static void rtsp_cmd_play(HTTPContext *c, const char *url, RTSPMessageHeader *h);
289 static void rtsp_cmd_pause(HTTPContext *c, const char *url, RTSPMessageHeader *h);
290 static void rtsp_cmd_teardown(HTTPContext *c, const char *url, RTSPMessageHeader *h);
293 static int prepare_sdp_description(FFStream *stream, uint8_t **pbuffer,
294 struct in_addr my_ip);
297 static HTTPContext *rtp_new_connection(struct sockaddr_in *from_addr,
298 FFStream *stream, const char *session_id,
299 enum RTSPLowerTransport rtp_protocol);
300 static int rtp_new_av_stream(HTTPContext *c,
301 int stream_index, struct sockaddr_in *dest_addr,
302 HTTPContext *rtsp_c);
304 static const char *my_program_name;
305 static const char *my_program_dir;
307 static const char *config_filename = "/etc/ffserver.conf";
309 static int ffserver_debug;
310 static int ffserver_daemon;
311 static int no_launch;
312 static int need_to_start_children;
314 /* maximum number of simultaneous HTTP connections */
315 static unsigned int nb_max_http_connections = 2000;
316 static unsigned int nb_max_connections = 5;
317 static unsigned int nb_connections;
319 static uint64_t max_bandwidth = 1000;
320 static uint64_t current_bandwidth;
322 static int64_t cur_time; // Making this global saves on passing it around everywhere
324 static AVLFG random_state;
326 static FILE *logfile = NULL;
328 /* FIXME: make ffserver work with IPv6 */
329 void av_noreturn exit_program(int ret)
334 /* resolve host with also IP address parsing */
335 static int resolve_host(struct in_addr *sin_addr, const char *hostname)
338 if (!ff_inet_aton(hostname, sin_addr)) {
340 struct addrinfo *ai, *cur;
341 struct addrinfo hints = { 0 };
342 hints.ai_family = AF_INET;
343 if (getaddrinfo(hostname, NULL, &hints, &ai))
345 /* getaddrinfo returns a linked list of addrinfo structs.
346 * Even if we set ai_family = AF_INET above, make sure
347 * that the returned one actually is of the correct type. */
348 for (cur = ai; cur; cur = cur->ai_next) {
349 if (cur->ai_family == AF_INET) {
350 *sin_addr = ((struct sockaddr_in *)cur->ai_addr)->sin_addr;
359 hp = gethostbyname(hostname);
362 memcpy(sin_addr, hp->h_addr_list[0], sizeof(struct in_addr));
368 static char *ctime1(char *buf2)
376 p = buf2 + strlen(p) - 1;
382 static void http_vlog(const char *fmt, va_list vargs)
384 static int print_prefix = 1;
389 fprintf(logfile, "%s ", buf);
391 print_prefix = strstr(fmt, "\n") != NULL;
392 vfprintf(logfile, fmt, vargs);
398 __attribute__ ((format (printf, 1, 2)))
400 static void http_log(const char *fmt, ...)
403 va_start(vargs, fmt);
404 http_vlog(fmt, vargs);
408 static void http_av_log(void *ptr, int level, const char *fmt, va_list vargs)
410 static int print_prefix = 1;
411 AVClass *avc = ptr ? *(AVClass**)ptr : NULL;
412 if (level > av_log_get_level())
414 if (print_prefix && avc)
415 http_log("[%s @ %p]", avc->item_name(ptr), ptr);
416 print_prefix = strstr(fmt, "\n") != NULL;
417 http_vlog(fmt, vargs);
420 static void log_connection(HTTPContext *c)
425 http_log("%s - - [%s] \"%s %s\" %d %"PRId64"\n",
426 inet_ntoa(c->from_addr.sin_addr), c->method, c->url,
427 c->protocol, (c->http_error ? c->http_error : 200), c->data_count);
430 static void update_datarate(DataRateData *drd, int64_t count)
432 if (!drd->time1 && !drd->count1) {
433 drd->time1 = drd->time2 = cur_time;
434 drd->count1 = drd->count2 = count;
435 } else if (cur_time - drd->time2 > 5000) {
436 drd->time1 = drd->time2;
437 drd->count1 = drd->count2;
438 drd->time2 = cur_time;
443 /* In bytes per second */
444 static int compute_datarate(DataRateData *drd, int64_t count)
446 if (cur_time == drd->time1)
449 return ((count - drd->count1) * 1000) / (cur_time - drd->time1);
453 static void start_children(FFStream *feed)
458 for (; feed; feed = feed->next) {
459 if (feed->child_argv && !feed->pid) {
460 feed->pid_start = time(0);
465 http_log("Unable to create children\n");
474 av_strlcpy(pathname, my_program_name, sizeof(pathname));
476 slash = strrchr(pathname, '/');
481 strcpy(slash, "ffmpeg");
483 http_log("Launch command line: ");
484 http_log("%s ", pathname);
485 for (i = 1; feed->child_argv[i] && feed->child_argv[i][0]; i++)
486 http_log("%s ", feed->child_argv[i]);
489 for (i = 3; i < 256; i++)
492 if (!ffserver_debug) {
493 i = open("/dev/null", O_RDWR);
502 /* This is needed to make relative pathnames work */
503 if (chdir(my_program_dir) < 0) {
504 http_log("chdir failed\n");
508 signal(SIGPIPE, SIG_DFL);
510 execvp(pathname, feed->child_argv);
518 /* open a listening socket */
519 static int socket_open_listen(struct sockaddr_in *my_addr)
523 server_fd = socket(AF_INET,SOCK_STREAM,0);
530 setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &tmp, sizeof(tmp));
532 my_addr->sin_family = AF_INET;
533 if (bind (server_fd, (struct sockaddr *) my_addr, sizeof (*my_addr)) < 0) {
535 snprintf(bindmsg, sizeof(bindmsg), "bind(port %d)", ntohs(my_addr->sin_port));
537 closesocket(server_fd);
541 if (listen (server_fd, 5) < 0) {
543 closesocket(server_fd);
546 ff_socket_nonblock(server_fd, 1);
551 /* start all multicast streams */
552 static void start_multicast(void)
557 struct sockaddr_in dest_addr;
558 int default_port, stream_index;
561 for(stream = first_stream; stream != NULL; stream = stream->next) {
562 if (stream->is_multicast) {
563 unsigned random0 = av_lfg_get(&random_state);
564 unsigned random1 = av_lfg_get(&random_state);
565 /* open the RTP connection */
566 snprintf(session_id, sizeof(session_id), "%08x%08x",
569 /* choose a port if none given */
570 if (stream->multicast_port == 0) {
571 stream->multicast_port = default_port;
575 dest_addr.sin_family = AF_INET;
576 dest_addr.sin_addr = stream->multicast_ip;
577 dest_addr.sin_port = htons(stream->multicast_port);
579 rtp_c = rtp_new_connection(&dest_addr, stream, session_id,
580 RTSP_LOWER_TRANSPORT_UDP_MULTICAST);
584 if (open_input_stream(rtp_c, "") < 0) {
585 http_log("Could not open input stream for stream '%s'\n",
590 /* open each RTP stream */
591 for(stream_index = 0; stream_index < stream->nb_streams;
593 dest_addr.sin_port = htons(stream->multicast_port +
595 if (rtp_new_av_stream(rtp_c, stream_index, &dest_addr, NULL) < 0) {
596 http_log("Could not open output stream '%s/streamid=%d'\n",
597 stream->filename, stream_index);
602 /* change state to send data */
603 rtp_c->state = HTTPSTATE_SEND_DATA;
608 /* main loop of the http server */
609 static int http_server(void)
611 int server_fd = 0, rtsp_server_fd = 0;
612 int ret, delay, delay1;
613 struct pollfd *poll_table, *poll_entry;
614 HTTPContext *c, *c_next;
616 if(!(poll_table = av_mallocz((nb_max_http_connections + 2)*sizeof(*poll_table)))) {
617 http_log("Impossible to allocate a poll table handling %d connections.\n", nb_max_http_connections);
621 if (my_http_addr.sin_port) {
622 server_fd = socket_open_listen(&my_http_addr);
627 if (my_rtsp_addr.sin_port) {
628 rtsp_server_fd = socket_open_listen(&my_rtsp_addr);
629 if (rtsp_server_fd < 0)
633 if (!rtsp_server_fd && !server_fd) {
634 http_log("HTTP and RTSP disabled.\n");
638 http_log("FFserver started.\n");
640 start_children(first_feed);
645 poll_entry = poll_table;
647 poll_entry->fd = server_fd;
648 poll_entry->events = POLLIN;
651 if (rtsp_server_fd) {
652 poll_entry->fd = rtsp_server_fd;
653 poll_entry->events = POLLIN;
657 /* wait for events on each HTTP handle */
664 case HTTPSTATE_SEND_HEADER:
665 case RTSPSTATE_SEND_REPLY:
666 case RTSPSTATE_SEND_PACKET:
667 c->poll_entry = poll_entry;
669 poll_entry->events = POLLOUT;
672 case HTTPSTATE_SEND_DATA_HEADER:
673 case HTTPSTATE_SEND_DATA:
674 case HTTPSTATE_SEND_DATA_TRAILER:
675 if (!c->is_packetized) {
676 /* for TCP, we output as much as we can (may need to put a limit) */
677 c->poll_entry = poll_entry;
679 poll_entry->events = POLLOUT;
682 /* when ffserver is doing the timing, we work by
683 looking at which packet need to be sent every
685 delay1 = 10; /* one tick wait XXX: 10 ms assumed */
690 case HTTPSTATE_WAIT_REQUEST:
691 case HTTPSTATE_RECEIVE_DATA:
692 case HTTPSTATE_WAIT_FEED:
693 case RTSPSTATE_WAIT_REQUEST:
694 /* need to catch errors */
695 c->poll_entry = poll_entry;
697 poll_entry->events = POLLIN;/* Maybe this will work */
701 c->poll_entry = NULL;
707 /* wait for an event on one connection. We poll at least every
708 second to handle timeouts */
710 ret = poll(poll_table, poll_entry - poll_table, delay);
711 if (ret < 0 && ff_neterrno() != AVERROR(EAGAIN) &&
712 ff_neterrno() != AVERROR(EINTR))
716 cur_time = av_gettime() / 1000;
718 if (need_to_start_children) {
719 need_to_start_children = 0;
720 start_children(first_feed);
723 /* now handle the events */
724 for(c = first_http_ctx; c != NULL; c = c_next) {
726 if (handle_connection(c) < 0) {
727 /* close and free the connection */
733 poll_entry = poll_table;
735 /* new HTTP connection request ? */
736 if (poll_entry->revents & POLLIN)
737 new_connection(server_fd, 0);
740 if (rtsp_server_fd) {
741 /* new RTSP connection request ? */
742 if (poll_entry->revents & POLLIN)
743 new_connection(rtsp_server_fd, 1);
748 /* start waiting for a new HTTP/RTSP request */
749 static void start_wait_request(HTTPContext *c, int is_rtsp)
751 c->buffer_ptr = c->buffer;
752 c->buffer_end = c->buffer + c->buffer_size - 1; /* leave room for '\0' */
755 c->timeout = cur_time + RTSP_REQUEST_TIMEOUT;
756 c->state = RTSPSTATE_WAIT_REQUEST;
758 c->timeout = cur_time + HTTP_REQUEST_TIMEOUT;
759 c->state = HTTPSTATE_WAIT_REQUEST;
763 static void http_send_too_busy_reply(int fd)
766 int len = snprintf(buffer, sizeof(buffer),
767 "HTTP/1.0 503 Server too busy\r\n"
768 "Content-type: text/html\r\n"
770 "<html><head><title>Too busy</title></head><body>\r\n"
771 "<p>The server is too busy to serve your request at this time.</p>\r\n"
772 "<p>The number of current connections is %d, and this exceeds the limit of %d.</p>\r\n"
773 "</body></html>\r\n",
774 nb_connections, nb_max_connections);
775 send(fd, buffer, len, 0);
779 static void new_connection(int server_fd, int is_rtsp)
781 struct sockaddr_in from_addr;
783 HTTPContext *c = NULL;
785 len = sizeof(from_addr);
786 fd = accept(server_fd, (struct sockaddr *)&from_addr,
789 http_log("error during accept %s\n", strerror(errno));
792 ff_socket_nonblock(fd, 1);
794 if (nb_connections >= nb_max_connections) {
795 http_send_too_busy_reply(fd);
799 /* add a new connection */
800 c = av_mallocz(sizeof(HTTPContext));
805 c->poll_entry = NULL;
806 c->from_addr = from_addr;
807 c->buffer_size = IOBUFFER_INIT_SIZE;
808 c->buffer = av_malloc(c->buffer_size);
812 c->next = first_http_ctx;
816 start_wait_request(c, is_rtsp);
828 static void close_connection(HTTPContext *c)
830 HTTPContext **cp, *c1;
832 AVFormatContext *ctx;
836 /* remove connection from list */
837 cp = &first_http_ctx;
838 while ((*cp) != NULL) {
846 /* remove references, if any (XXX: do it faster) */
847 for(c1 = first_http_ctx; c1 != NULL; c1 = c1->next) {
852 /* remove connection associated resources */
856 /* close each frame parser */
857 for(i=0;i<c->fmt_in->nb_streams;i++) {
858 st = c->fmt_in->streams[i];
859 if (st->codec->codec)
860 avcodec_close(st->codec);
862 avformat_close_input(&c->fmt_in);
865 /* free RTP output streams if any */
868 nb_streams = c->stream->nb_streams;
870 for(i=0;i<nb_streams;i++) {
873 av_write_trailer(ctx);
874 av_dict_free(&ctx->metadata);
875 av_free(ctx->streams[0]);
878 h = c->rtp_handles[i];
885 if (!c->last_packet_sent && c->state == HTTPSTATE_SEND_DATA_TRAILER) {
888 if (avio_open_dyn_buf(&ctx->pb) >= 0) {
889 av_write_trailer(ctx);
890 av_freep(&c->pb_buffer);
891 avio_close_dyn_buf(ctx->pb, &c->pb_buffer);
896 for(i=0; i<ctx->nb_streams; i++)
897 av_free(ctx->streams[i]);
899 if (c->stream && !c->post && c->stream->stream_type == STREAM_TYPE_LIVE)
900 current_bandwidth -= c->stream->bandwidth;
902 /* signal that there is no feed if we are the feeder socket */
903 if (c->state == HTTPSTATE_RECEIVE_DATA && c->stream) {
904 c->stream->feed_opened = 0;
908 av_freep(&c->pb_buffer);
909 av_freep(&c->packet_buffer);
915 static int handle_connection(HTTPContext *c)
920 case HTTPSTATE_WAIT_REQUEST:
921 case RTSPSTATE_WAIT_REQUEST:
923 if ((c->timeout - cur_time) < 0)
925 if (c->poll_entry->revents & (POLLERR | POLLHUP))
928 /* no need to read if no events */
929 if (!(c->poll_entry->revents & POLLIN))
933 len = recv(c->fd, c->buffer_ptr, 1, 0);
935 if (ff_neterrno() != AVERROR(EAGAIN) &&
936 ff_neterrno() != AVERROR(EINTR))
938 } else if (len == 0) {
941 /* search for end of request. */
943 c->buffer_ptr += len;
945 if ((ptr >= c->buffer + 2 && !memcmp(ptr-2, "\n\n", 2)) ||
946 (ptr >= c->buffer + 4 && !memcmp(ptr-4, "\r\n\r\n", 4))) {
947 /* request found : parse it and reply */
948 if (c->state == HTTPSTATE_WAIT_REQUEST) {
949 ret = http_parse_request(c);
951 ret = rtsp_parse_request(c);
955 } else if (ptr >= c->buffer_end) {
956 /* request too long: cannot do anything */
958 } else goto read_loop;
962 case HTTPSTATE_SEND_HEADER:
963 if (c->poll_entry->revents & (POLLERR | POLLHUP))
966 /* no need to write if no events */
967 if (!(c->poll_entry->revents & POLLOUT))
969 len = send(c->fd, c->buffer_ptr, c->buffer_end - c->buffer_ptr, 0);
971 if (ff_neterrno() != AVERROR(EAGAIN) &&
972 ff_neterrno() != AVERROR(EINTR)) {
973 /* error : close connection */
974 av_freep(&c->pb_buffer);
978 c->buffer_ptr += len;
980 c->stream->bytes_served += len;
981 c->data_count += len;
982 if (c->buffer_ptr >= c->buffer_end) {
983 av_freep(&c->pb_buffer);
987 /* all the buffer was sent : synchronize to the incoming stream */
988 c->state = HTTPSTATE_SEND_DATA_HEADER;
989 c->buffer_ptr = c->buffer_end = c->buffer;
994 case HTTPSTATE_SEND_DATA:
995 case HTTPSTATE_SEND_DATA_HEADER:
996 case HTTPSTATE_SEND_DATA_TRAILER:
997 /* for packetized output, we consider we can always write (the
998 input streams sets the speed). It may be better to verify
999 that we do not rely too much on the kernel queues */
1000 if (!c->is_packetized) {
1001 if (c->poll_entry->revents & (POLLERR | POLLHUP))
1004 /* no need to read if no events */
1005 if (!(c->poll_entry->revents & POLLOUT))
1008 if (http_send_data(c) < 0)
1010 /* close connection if trailer sent */
1011 if (c->state == HTTPSTATE_SEND_DATA_TRAILER)
1014 case HTTPSTATE_RECEIVE_DATA:
1015 /* no need to read if no events */
1016 if (c->poll_entry->revents & (POLLERR | POLLHUP))
1018 if (!(c->poll_entry->revents & POLLIN))
1020 if (http_receive_data(c) < 0)
1023 case HTTPSTATE_WAIT_FEED:
1024 /* no need to read if no events */
1025 if (c->poll_entry->revents & (POLLIN | POLLERR | POLLHUP))
1028 /* nothing to do, we'll be waken up by incoming feed packets */
1031 case RTSPSTATE_SEND_REPLY:
1032 if (c->poll_entry->revents & (POLLERR | POLLHUP)) {
1033 av_freep(&c->pb_buffer);
1036 /* no need to write if no events */
1037 if (!(c->poll_entry->revents & POLLOUT))
1039 len = send(c->fd, c->buffer_ptr, c->buffer_end - c->buffer_ptr, 0);
1041 if (ff_neterrno() != AVERROR(EAGAIN) &&
1042 ff_neterrno() != AVERROR(EINTR)) {
1043 /* error : close connection */
1044 av_freep(&c->pb_buffer);
1048 c->buffer_ptr += len;
1049 c->data_count += len;
1050 if (c->buffer_ptr >= c->buffer_end) {
1051 /* all the buffer was sent : wait for a new request */
1052 av_freep(&c->pb_buffer);
1053 start_wait_request(c, 1);
1057 case RTSPSTATE_SEND_PACKET:
1058 if (c->poll_entry->revents & (POLLERR | POLLHUP)) {
1059 av_freep(&c->packet_buffer);
1062 /* no need to write if no events */
1063 if (!(c->poll_entry->revents & POLLOUT))
1065 len = send(c->fd, c->packet_buffer_ptr,
1066 c->packet_buffer_end - c->packet_buffer_ptr, 0);
1068 if (ff_neterrno() != AVERROR(EAGAIN) &&
1069 ff_neterrno() != AVERROR(EINTR)) {
1070 /* error : close connection */
1071 av_freep(&c->packet_buffer);
1075 c->packet_buffer_ptr += len;
1076 if (c->packet_buffer_ptr >= c->packet_buffer_end) {
1077 /* all the buffer was sent : wait for a new request */
1078 av_freep(&c->packet_buffer);
1079 c->state = RTSPSTATE_WAIT_REQUEST;
1083 case HTTPSTATE_READY:
1092 static int extract_rates(char *rates, int ratelen, const char *request)
1096 for (p = request; *p && *p != '\r' && *p != '\n'; ) {
1097 if (av_strncasecmp(p, "Pragma:", 7) == 0) {
1098 const char *q = p + 7;
1100 while (*q && *q != '\n' && isspace(*q))
1103 if (av_strncasecmp(q, "stream-switch-entry=", 20) == 0) {
1109 memset(rates, 0xff, ratelen);
1112 while (*q && *q != '\n' && *q != ':')
1115 if (sscanf(q, ":%d:%d", &stream_no, &rate_no) != 2)
1119 if (stream_no < ratelen && stream_no >= 0)
1120 rates[stream_no] = rate_no;
1122 while (*q && *q != '\n' && !isspace(*q))
1129 p = strchr(p, '\n');
1139 static int find_stream_in_feed(FFStream *feed, AVCodecContext *codec, int bit_rate)
1142 int best_bitrate = 100000000;
1145 for (i = 0; i < feed->nb_streams; i++) {
1146 AVCodecContext *feed_codec = feed->streams[i]->codec;
1148 if (feed_codec->codec_id != codec->codec_id ||
1149 feed_codec->sample_rate != codec->sample_rate ||
1150 feed_codec->width != codec->width ||
1151 feed_codec->height != codec->height)
1154 /* Potential stream */
1156 /* We want the fastest stream less than bit_rate, or the slowest
1157 * faster than bit_rate
1160 if (feed_codec->bit_rate <= bit_rate) {
1161 if (best_bitrate > bit_rate || feed_codec->bit_rate > best_bitrate) {
1162 best_bitrate = feed_codec->bit_rate;
1166 if (feed_codec->bit_rate < best_bitrate) {
1167 best_bitrate = feed_codec->bit_rate;
1176 static int modify_current_stream(HTTPContext *c, char *rates)
1179 FFStream *req = c->stream;
1180 int action_required = 0;
1182 /* Not much we can do for a feed */
1186 for (i = 0; i < req->nb_streams; i++) {
1187 AVCodecContext *codec = req->streams[i]->codec;
1191 c->switch_feed_streams[i] = req->feed_streams[i];
1194 c->switch_feed_streams[i] = find_stream_in_feed(req->feed, codec, codec->bit_rate / 2);
1197 /* Wants off or slow */
1198 c->switch_feed_streams[i] = find_stream_in_feed(req->feed, codec, codec->bit_rate / 4);
1200 /* This doesn't work well when it turns off the only stream! */
1201 c->switch_feed_streams[i] = -2;
1202 c->feed_streams[i] = -2;
1207 if (c->switch_feed_streams[i] >= 0 && c->switch_feed_streams[i] != c->feed_streams[i])
1208 action_required = 1;
1211 return action_required;
1214 /* XXX: factorize in utils.c ? */
1215 /* XXX: take care with different space meaning */
1216 static void skip_spaces(const char **pp)
1220 while (*p == ' ' || *p == '\t')
1225 static void get_word(char *buf, int buf_size, const char **pp)
1233 while (!isspace(*p) && *p != '\0') {
1234 if ((q - buf) < buf_size - 1)
1243 static void get_arg(char *buf, int buf_size, const char **pp)
1250 while (isspace(*p)) p++;
1253 if (*p == '\"' || *p == '\'')
1265 if ((q - buf) < buf_size - 1)
1270 if (quote && *p == quote)
1275 static void parse_acl_row(FFStream *stream, FFStream* feed, IPAddressACL *ext_acl,
1276 const char *p, const char *filename, int line_num)
1282 get_arg(arg, sizeof(arg), &p);
1283 if (av_strcasecmp(arg, "allow") == 0)
1284 acl.action = IP_ALLOW;
1285 else if (av_strcasecmp(arg, "deny") == 0)
1286 acl.action = IP_DENY;
1288 fprintf(stderr, "%s:%d: ACL action '%s' is not ALLOW or DENY\n",
1289 filename, line_num, arg);
1293 get_arg(arg, sizeof(arg), &p);
1295 if (resolve_host(&acl.first, arg) != 0) {
1296 fprintf(stderr, "%s:%d: ACL refers to invalid host or ip address '%s'\n",
1297 filename, line_num, arg);
1300 acl.last = acl.first;
1302 get_arg(arg, sizeof(arg), &p);
1305 if (resolve_host(&acl.last, arg) != 0) {
1306 fprintf(stderr, "%s:%d: ACL refers to invalid host or ip address '%s'\n",
1307 filename, line_num, arg);
1313 IPAddressACL *nacl = av_mallocz(sizeof(*nacl));
1314 IPAddressACL **naclp = 0;
1320 naclp = &stream->acl;
1326 fprintf(stderr, "%s:%d: ACL found not in <stream> or <feed>\n",
1327 filename, line_num);
1333 naclp = &(*naclp)->next;
1341 static IPAddressACL* parse_dynamic_acl(FFStream *stream, HTTPContext *c)
1346 IPAddressACL *acl = NULL;
1350 f = fopen(stream->dynamic_acl, "r");
1352 perror(stream->dynamic_acl);
1356 acl = av_mallocz(sizeof(IPAddressACL));
1360 if (fgets(line, sizeof(line), f) == NULL)
1366 if (*p == '\0' || *p == '#')
1368 get_arg(cmd, sizeof(cmd), &p);
1370 if (!av_strcasecmp(cmd, "ACL"))
1371 parse_acl_row(NULL, NULL, acl, p, stream->dynamic_acl, line_num);
1378 static void free_acl_list(IPAddressACL *in_acl)
1380 IPAddressACL *pacl,*pacl2;
1390 static int validate_acl_list(IPAddressACL *in_acl, HTTPContext *c)
1392 enum IPAddressAction last_action = IP_DENY;
1394 struct in_addr *src = &c->from_addr.sin_addr;
1395 unsigned long src_addr = src->s_addr;
1397 for (acl = in_acl; acl; acl = acl->next) {
1398 if (src_addr >= acl->first.s_addr && src_addr <= acl->last.s_addr)
1399 return (acl->action == IP_ALLOW) ? 1 : 0;
1400 last_action = acl->action;
1403 /* Nothing matched, so return not the last action */
1404 return (last_action == IP_DENY) ? 1 : 0;
1407 static int validate_acl(FFStream *stream, HTTPContext *c)
1413 /* if stream->acl is null validate_acl_list will return 1 */
1414 ret = validate_acl_list(stream->acl, c);
1416 if (stream->dynamic_acl[0]) {
1417 acl = parse_dynamic_acl(stream, c);
1419 ret = validate_acl_list(acl, c);
1427 /* compute the real filename of a file by matching it without its
1428 extensions to all the stream filenames */
1429 static void compute_real_filename(char *filename, int max_size)
1436 /* compute filename by matching without the file extensions */
1437 av_strlcpy(file1, filename, sizeof(file1));
1438 p = strrchr(file1, '.');
1441 for(stream = first_stream; stream != NULL; stream = stream->next) {
1442 av_strlcpy(file2, stream->filename, sizeof(file2));
1443 p = strrchr(file2, '.');
1446 if (!strcmp(file1, file2)) {
1447 av_strlcpy(filename, stream->filename, max_size);
1462 /* parse http request and prepare header */
1463 static int http_parse_request(HTTPContext *c)
1466 enum RedirType redir_type;
1468 char info[1024], filename[1024];
1472 const char *mime_type;
1476 char *useragent = 0;
1479 get_word(cmd, sizeof(cmd), (const char **)&p);
1480 av_strlcpy(c->method, cmd, sizeof(c->method));
1482 if (!strcmp(cmd, "GET"))
1484 else if (!strcmp(cmd, "POST"))
1489 get_word(url, sizeof(url), (const char **)&p);
1490 av_strlcpy(c->url, url, sizeof(c->url));
1492 get_word(protocol, sizeof(protocol), (const char **)&p);
1493 if (strcmp(protocol, "HTTP/1.0") && strcmp(protocol, "HTTP/1.1"))
1496 av_strlcpy(c->protocol, protocol, sizeof(c->protocol));
1499 http_log("%s - - New connection: %s %s\n", inet_ntoa(c->from_addr.sin_addr), cmd, url);
1501 /* find the filename and the optional info string in the request */
1502 p = strchr(url, '?');
1504 av_strlcpy(info, p, sizeof(info));
1509 av_strlcpy(filename, url + ((*url == '/') ? 1 : 0), sizeof(filename)-1);
1511 for (p = c->buffer; *p && *p != '\r' && *p != '\n'; ) {
1512 if (av_strncasecmp(p, "User-Agent:", 11) == 0) {
1514 if (*useragent && *useragent != '\n' && isspace(*useragent))
1518 p = strchr(p, '\n');
1525 redir_type = REDIR_NONE;
1526 if (av_match_ext(filename, "asx")) {
1527 redir_type = REDIR_ASX;
1528 filename[strlen(filename)-1] = 'f';
1529 } else if (av_match_ext(filename, "asf") &&
1530 (!useragent || av_strncasecmp(useragent, "NSPlayer", 8) != 0)) {
1531 /* if this isn't WMP or lookalike, return the redirector file */
1532 redir_type = REDIR_ASF;
1533 } else if (av_match_ext(filename, "rpm,ram")) {
1534 redir_type = REDIR_RAM;
1535 strcpy(filename + strlen(filename)-2, "m");
1536 } else if (av_match_ext(filename, "rtsp")) {
1537 redir_type = REDIR_RTSP;
1538 compute_real_filename(filename, sizeof(filename) - 1);
1539 } else if (av_match_ext(filename, "sdp")) {
1540 redir_type = REDIR_SDP;
1541 compute_real_filename(filename, sizeof(filename) - 1);
1544 // "redirect" / request to index.html
1545 if (!strlen(filename))
1546 av_strlcpy(filename, "index.html", sizeof(filename) - 1);
1548 stream = first_stream;
1549 while (stream != NULL) {
1550 if (!strcmp(stream->filename, filename) && validate_acl(stream, c))
1552 stream = stream->next;
1554 if (stream == NULL) {
1555 snprintf(msg, sizeof(msg), "File '%s' not found", url);
1556 http_log("File '%s' not found\n", url);
1561 memcpy(c->feed_streams, stream->feed_streams, sizeof(c->feed_streams));
1562 memset(c->switch_feed_streams, -1, sizeof(c->switch_feed_streams));
1564 if (stream->stream_type == STREAM_TYPE_REDIRECT) {
1565 c->http_error = 301;
1567 q += snprintf(q, c->buffer_size,
1568 "HTTP/1.0 301 Moved\r\n"
1570 "Content-type: text/html\r\n"
1572 "<html><head><title>Moved</title></head><body>\r\n"
1573 "You should be <a href=\"%s\">redirected</a>.\r\n"
1574 "</body></html>\r\n", stream->feed_filename, stream->feed_filename);
1575 /* prepare output buffer */
1576 c->buffer_ptr = c->buffer;
1578 c->state = HTTPSTATE_SEND_HEADER;
1582 /* If this is WMP, get the rate information */
1583 if (extract_rates(ratebuf, sizeof(ratebuf), c->buffer)) {
1584 if (modify_current_stream(c, ratebuf)) {
1585 for (i = 0; i < FF_ARRAY_ELEMS(c->feed_streams); i++) {
1586 if (c->switch_feed_streams[i] >= 0)
1587 c->switch_feed_streams[i] = -1;
1592 if (c->post == 0 && stream->stream_type == STREAM_TYPE_LIVE)
1593 current_bandwidth += stream->bandwidth;
1595 /* If already streaming this feed, do not let start another feeder. */
1596 if (stream->feed_opened) {
1597 snprintf(msg, sizeof(msg), "This feed is already being received.");
1598 http_log("Feed '%s' already being received\n", stream->feed_filename);
1602 if (c->post == 0 && max_bandwidth < current_bandwidth) {
1603 c->http_error = 503;
1605 q += snprintf(q, c->buffer_size,
1606 "HTTP/1.0 503 Server too busy\r\n"
1607 "Content-type: text/html\r\n"
1609 "<html><head><title>Too busy</title></head><body>\r\n"
1610 "<p>The server is too busy to serve your request at this time.</p>\r\n"
1611 "<p>The bandwidth being served (including your stream) is %"PRIu64"kbit/sec, "
1612 "and this exceeds the limit of %"PRIu64"kbit/sec.</p>\r\n"
1613 "</body></html>\r\n", current_bandwidth, max_bandwidth);
1614 /* prepare output buffer */
1615 c->buffer_ptr = c->buffer;
1617 c->state = HTTPSTATE_SEND_HEADER;
1621 if (redir_type != REDIR_NONE) {
1624 for (p = c->buffer; *p && *p != '\r' && *p != '\n'; ) {
1625 if (av_strncasecmp(p, "Host:", 5) == 0) {
1629 p = strchr(p, '\n');
1640 while (isspace(*hostinfo))
1643 eoh = strchr(hostinfo, '\n');
1645 if (eoh[-1] == '\r')
1648 if (eoh - hostinfo < sizeof(hostbuf) - 1) {
1649 memcpy(hostbuf, hostinfo, eoh - hostinfo);
1650 hostbuf[eoh - hostinfo] = 0;
1652 c->http_error = 200;
1654 switch(redir_type) {
1656 q += snprintf(q, c->buffer_size,
1657 "HTTP/1.0 200 ASX Follows\r\n"
1658 "Content-type: video/x-ms-asf\r\n"
1660 "<ASX Version=\"3\">\r\n"
1661 //"<!-- Autogenerated by ffserver -->\r\n"
1662 "<ENTRY><REF HREF=\"http://%s/%s%s\"/></ENTRY>\r\n"
1663 "</ASX>\r\n", hostbuf, filename, info);
1666 q += snprintf(q, c->buffer_size,
1667 "HTTP/1.0 200 RAM Follows\r\n"
1668 "Content-type: audio/x-pn-realaudio\r\n"
1670 "# Autogenerated by ffserver\r\n"
1671 "http://%s/%s%s\r\n", hostbuf, filename, info);
1674 q += snprintf(q, c->buffer_size,
1675 "HTTP/1.0 200 ASF Redirect follows\r\n"
1676 "Content-type: video/x-ms-asf\r\n"
1679 "Ref1=http://%s/%s%s\r\n", hostbuf, filename, info);
1683 char hostname[256], *p;
1684 /* extract only hostname */
1685 av_strlcpy(hostname, hostbuf, sizeof(hostname));
1686 p = strrchr(hostname, ':');
1689 q += snprintf(q, c->buffer_size,
1690 "HTTP/1.0 200 RTSP Redirect follows\r\n"
1691 /* XXX: incorrect mime type ? */
1692 "Content-type: application/x-rtsp\r\n"
1694 "rtsp://%s:%d/%s\r\n", hostname, ntohs(my_rtsp_addr.sin_port), filename);
1700 int sdp_data_size, len;
1701 struct sockaddr_in my_addr;
1703 q += snprintf(q, c->buffer_size,
1704 "HTTP/1.0 200 OK\r\n"
1705 "Content-type: application/sdp\r\n"
1708 len = sizeof(my_addr);
1709 getsockname(c->fd, (struct sockaddr *)&my_addr, &len);
1711 /* XXX: should use a dynamic buffer */
1712 sdp_data_size = prepare_sdp_description(stream,
1715 if (sdp_data_size > 0) {
1716 memcpy(q, sdp_data, sdp_data_size);
1728 /* prepare output buffer */
1729 c->buffer_ptr = c->buffer;
1731 c->state = HTTPSTATE_SEND_HEADER;
1737 snprintf(msg, sizeof(msg), "ASX/RAM file not handled");
1741 stream->conns_served++;
1743 /* XXX: add there authenticate and IP match */
1746 /* if post, it means a feed is being sent */
1747 if (!stream->is_feed) {
1748 /* However it might be a status report from WMP! Let us log the
1749 * data as it might come in handy one day. */
1753 for (p = c->buffer; *p && *p != '\r' && *p != '\n'; ) {
1754 if (av_strncasecmp(p, "Pragma: log-line=", 17) == 0) {
1758 if (av_strncasecmp(p, "Pragma: client-id=", 18) == 0)
1759 client_id = strtol(p + 18, 0, 10);
1760 p = strchr(p, '\n');
1768 char *eol = strchr(logline, '\n');
1773 if (eol[-1] == '\r')
1775 http_log("%.*s\n", (int) (eol - logline), logline);
1776 c->suppress_log = 1;
1781 http_log("\nGot request:\n%s\n", c->buffer);
1784 if (client_id && extract_rates(ratebuf, sizeof(ratebuf), c->buffer)) {
1787 /* Now we have to find the client_id */
1788 for (wmpc = first_http_ctx; wmpc; wmpc = wmpc->next) {
1789 if (wmpc->wmp_client_id == client_id)
1793 if (wmpc && modify_current_stream(wmpc, ratebuf))
1794 wmpc->switch_pending = 1;
1797 snprintf(msg, sizeof(msg), "POST command not handled");
1801 if (http_start_receive_data(c) < 0) {
1802 snprintf(msg, sizeof(msg), "could not open feed");
1806 c->state = HTTPSTATE_RECEIVE_DATA;
1811 if (strcmp(stream->filename + strlen(stream->filename) - 4, ".asf") == 0)
1812 http_log("\nGot request:\n%s\n", c->buffer);
1815 if (c->stream->stream_type == STREAM_TYPE_STATUS)
1818 /* open input stream */
1819 if (open_input_stream(c, info) < 0) {
1820 snprintf(msg, sizeof(msg), "Input stream corresponding to '%s' not found", url);
1824 /* prepare http header */
1826 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "HTTP/1.0 200 OK\r\n");
1827 mime_type = c->stream->fmt->mime_type;
1829 mime_type = "application/x-octet-stream";
1830 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "Pragma: no-cache\r\n");
1832 /* for asf, we need extra headers */
1833 if (!strcmp(c->stream->fmt->name,"asf_stream")) {
1834 /* Need to allocate a client id */
1836 c->wmp_client_id = av_lfg_get(&random_state);
1838 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);
1840 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "Content-Type: %s\r\n", mime_type);
1841 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "\r\n");
1843 /* prepare output buffer */
1845 c->buffer_ptr = c->buffer;
1847 c->state = HTTPSTATE_SEND_HEADER;
1850 c->http_error = 404;
1852 q += snprintf(q, c->buffer_size,
1853 "HTTP/1.0 404 Not Found\r\n"
1854 "Content-type: text/html\r\n"
1857 "<head><title>404 Not Found</title></head>\n"
1860 /* prepare output buffer */
1861 c->buffer_ptr = c->buffer;
1863 c->state = HTTPSTATE_SEND_HEADER;
1867 c->http_error = 200; /* horrible : we use this value to avoid
1868 going to the send data state */
1869 c->state = HTTPSTATE_SEND_HEADER;
1873 static void fmt_bytecount(AVIOContext *pb, int64_t count)
1875 static const char suffix[] = " kMGTP";
1878 for (s = suffix; count >= 100000 && s[1]; count /= 1000, s++);
1880 avio_printf(pb, "%"PRId64"%c", count, *s);
1883 static void compute_status(HTTPContext *c)
1892 if (avio_open_dyn_buf(&pb) < 0) {
1893 /* XXX: return an error ? */
1894 c->buffer_ptr = c->buffer;
1895 c->buffer_end = c->buffer;
1899 avio_printf(pb, "HTTP/1.0 200 OK\r\n");
1900 avio_printf(pb, "Content-type: %s\r\n", "text/html");
1901 avio_printf(pb, "Pragma: no-cache\r\n");
1902 avio_printf(pb, "\r\n");
1904 avio_printf(pb, "<html><head><title>%s Status</title>\n", program_name);
1905 if (c->stream->feed_filename[0])
1906 avio_printf(pb, "<link rel=\"shortcut icon\" href=\"%s\">\n", c->stream->feed_filename);
1907 avio_printf(pb, "</head>\n<body>");
1908 avio_printf(pb, "<h1>%s Status</h1>\n", program_name);
1910 avio_printf(pb, "<h2>Available Streams</h2>\n");
1911 avio_printf(pb, "<table cellspacing=0 cellpadding=4>\n");
1912 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");
1913 stream = first_stream;
1914 while (stream != NULL) {
1915 char sfilename[1024];
1918 if (stream->feed != stream) {
1919 av_strlcpy(sfilename, stream->filename, sizeof(sfilename) - 10);
1920 eosf = sfilename + strlen(sfilename);
1921 if (eosf - sfilename >= 4) {
1922 if (strcmp(eosf - 4, ".asf") == 0)
1923 strcpy(eosf - 4, ".asx");
1924 else if (strcmp(eosf - 3, ".rm") == 0)
1925 strcpy(eosf - 3, ".ram");
1926 else if (stream->fmt && !strcmp(stream->fmt->name, "rtp")) {
1927 /* generate a sample RTSP director if
1928 unicast. Generate an SDP redirector if
1930 eosf = strrchr(sfilename, '.');
1932 eosf = sfilename + strlen(sfilename);
1933 if (stream->is_multicast)
1934 strcpy(eosf, ".sdp");
1936 strcpy(eosf, ".rtsp");
1940 avio_printf(pb, "<tr><td><a href=\"/%s\">%s</a> ",
1941 sfilename, stream->filename);
1942 avio_printf(pb, "<td align=right> %d <td align=right> ",
1943 stream->conns_served);
1944 fmt_bytecount(pb, stream->bytes_served);
1945 switch(stream->stream_type) {
1946 case STREAM_TYPE_LIVE: {
1947 int audio_bit_rate = 0;
1948 int video_bit_rate = 0;
1949 const char *audio_codec_name = "";
1950 const char *video_codec_name = "";
1951 const char *audio_codec_name_extra = "";
1952 const char *video_codec_name_extra = "";
1954 for(i=0;i<stream->nb_streams;i++) {
1955 AVStream *st = stream->streams[i];
1956 AVCodec *codec = avcodec_find_encoder(st->codec->codec_id);
1957 switch(st->codec->codec_type) {
1958 case AVMEDIA_TYPE_AUDIO:
1959 audio_bit_rate += st->codec->bit_rate;
1961 if (*audio_codec_name)
1962 audio_codec_name_extra = "...";
1963 audio_codec_name = codec->name;
1966 case AVMEDIA_TYPE_VIDEO:
1967 video_bit_rate += st->codec->bit_rate;
1969 if (*video_codec_name)
1970 video_codec_name_extra = "...";
1971 video_codec_name = codec->name;
1974 case AVMEDIA_TYPE_DATA:
1975 video_bit_rate += st->codec->bit_rate;
1981 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",
1984 video_bit_rate / 1000, video_codec_name, video_codec_name_extra,
1985 audio_bit_rate / 1000, audio_codec_name, audio_codec_name_extra);
1987 avio_printf(pb, "<td>%s", stream->feed->filename);
1989 avio_printf(pb, "<td>%s", stream->feed_filename);
1990 avio_printf(pb, "\n");
1994 avio_printf(pb, "<td align=center> - <td align=right> - <td align=right> - <td><td align=right> - <td>\n");
1998 stream = stream->next;
2000 avio_printf(pb, "</table>\n");
2002 stream = first_stream;
2003 while (stream != NULL) {
2004 if (stream->feed == stream) {
2005 avio_printf(pb, "<h2>Feed %s</h2>", stream->filename);
2007 avio_printf(pb, "Running as pid %d.\n", stream->pid);
2009 #if defined(linux) && !defined(CONFIG_NOCUTILS)
2014 /* This is somewhat linux specific I guess */
2015 snprintf(ps_cmd, sizeof(ps_cmd),
2016 "ps -o \"%%cpu,cputime\" --no-headers %d",
2019 pid_stat = popen(ps_cmd, "r");
2024 if (fscanf(pid_stat, "%10s %64s", cpuperc,
2026 avio_printf(pb, "Currently using %s%% of the cpu. Total time used %s.\n",
2034 avio_printf(pb, "<p>");
2036 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");
2038 for (i = 0; i < stream->nb_streams; i++) {
2039 AVStream *st = stream->streams[i];
2040 AVCodec *codec = avcodec_find_encoder(st->codec->codec_id);
2041 const char *type = "unknown";
2042 char parameters[64];
2046 switch(st->codec->codec_type) {
2047 case AVMEDIA_TYPE_AUDIO:
2049 snprintf(parameters, sizeof(parameters), "%d channel(s), %d Hz", st->codec->channels, st->codec->sample_rate);
2051 case AVMEDIA_TYPE_VIDEO:
2053 snprintf(parameters, sizeof(parameters), "%dx%d, q=%d-%d, fps=%d", st->codec->width, st->codec->height,
2054 st->codec->qmin, st->codec->qmax, st->codec->time_base.den / st->codec->time_base.num);
2059 avio_printf(pb, "<tr><td align=right>%d<td>%s<td align=right>%d<td>%s<td>%s\n",
2060 i, type, st->codec->bit_rate/1000, codec ? codec->name : "", parameters);
2062 avio_printf(pb, "</table>\n");
2065 stream = stream->next;
2068 /* connection status */
2069 avio_printf(pb, "<h2>Connection Status</h2>\n");
2071 avio_printf(pb, "Number of connections: %d / %d<br>\n",
2072 nb_connections, nb_max_connections);
2074 avio_printf(pb, "Bandwidth in use: %"PRIu64"k / %"PRIu64"k<br>\n",
2075 current_bandwidth, max_bandwidth);
2077 avio_printf(pb, "<table>\n");
2078 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");
2079 c1 = first_http_ctx;
2081 while (c1 != NULL) {
2087 for (j = 0; j < c1->stream->nb_streams; j++) {
2088 if (!c1->stream->feed)
2089 bitrate += c1->stream->streams[j]->codec->bit_rate;
2090 else if (c1->feed_streams[j] >= 0)
2091 bitrate += c1->stream->feed->streams[c1->feed_streams[j]]->codec->bit_rate;
2096 p = inet_ntoa(c1->from_addr.sin_addr);
2097 avio_printf(pb, "<tr><td><b>%d</b><td>%s%s<td>%s<td>%s<td>%s<td align=right>",
2099 c1->stream ? c1->stream->filename : "",
2100 c1->state == HTTPSTATE_RECEIVE_DATA ? "(input)" : "",
2103 http_state[c1->state]);
2104 fmt_bytecount(pb, bitrate);
2105 avio_printf(pb, "<td align=right>");
2106 fmt_bytecount(pb, compute_datarate(&c1->datarate, c1->data_count) * 8);
2107 avio_printf(pb, "<td align=right>");
2108 fmt_bytecount(pb, c1->data_count);
2109 avio_printf(pb, "\n");
2112 avio_printf(pb, "</table>\n");
2117 avio_printf(pb, "<hr size=1 noshade>Generated at %s", p);
2118 avio_printf(pb, "</body>\n</html>\n");
2120 len = avio_close_dyn_buf(pb, &c->pb_buffer);
2121 c->buffer_ptr = c->pb_buffer;
2122 c->buffer_end = c->pb_buffer + len;
2125 static int open_input_stream(HTTPContext *c, const char *info)
2128 char input_filename[1024];
2129 AVFormatContext *s = NULL;
2130 int buf_size, i, ret;
2133 /* find file name */
2134 if (c->stream->feed) {
2135 strcpy(input_filename, c->stream->feed->feed_filename);
2136 buf_size = FFM_PACKET_SIZE;
2137 /* compute position (absolute time) */
2138 if (av_find_info_tag(buf, sizeof(buf), "date", info)) {
2139 if ((ret = av_parse_time(&stream_pos, buf, 0)) < 0)
2141 } else if (av_find_info_tag(buf, sizeof(buf), "buffer", info)) {
2142 int prebuffer = strtol(buf, 0, 10);
2143 stream_pos = av_gettime() - prebuffer * (int64_t)1000000;
2145 stream_pos = av_gettime() - c->stream->prebuffer * (int64_t)1000;
2147 strcpy(input_filename, c->stream->feed_filename);
2149 /* compute position (relative time) */
2150 if (av_find_info_tag(buf, sizeof(buf), "date", info)) {
2151 if ((ret = av_parse_time(&stream_pos, buf, 1)) < 0)
2156 if (input_filename[0] == '\0')
2160 if ((ret = avformat_open_input(&s, input_filename, c->stream->ifmt, &c->stream->in_opts)) < 0) {
2161 http_log("could not open %s: %d\n", input_filename, ret);
2165 /* set buffer size */
2166 if (buf_size > 0) ffio_set_buf_size(s->pb, buf_size);
2168 s->flags |= AVFMT_FLAG_GENPTS;
2170 if (strcmp(s->iformat->name, "ffm") && avformat_find_stream_info(c->fmt_in, NULL) < 0) {
2171 http_log("Could not find stream info '%s'\n", input_filename);
2172 avformat_close_input(&s);
2176 /* choose stream as clock source (we favorize video stream if
2177 present) for packet sending */
2178 c->pts_stream_index = 0;
2179 for(i=0;i<c->stream->nb_streams;i++) {
2180 if (c->pts_stream_index == 0 &&
2181 c->stream->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2182 c->pts_stream_index = i;
2186 if (c->fmt_in->iformat->read_seek)
2187 av_seek_frame(c->fmt_in, -1, stream_pos, 0);
2188 /* set the start time (needed for maxtime and RTP packet timing) */
2189 c->start_time = cur_time;
2190 c->first_pts = AV_NOPTS_VALUE;
2194 /* return the server clock (in us) */
2195 static int64_t get_server_clock(HTTPContext *c)
2197 /* compute current pts value from system time */
2198 return (cur_time - c->start_time) * 1000;
2201 /* return the estimated time at which the current packet must be sent
2203 static int64_t get_packet_send_clock(HTTPContext *c)
2205 int bytes_left, bytes_sent, frame_bytes;
2207 frame_bytes = c->cur_frame_bytes;
2208 if (frame_bytes <= 0)
2211 bytes_left = c->buffer_end - c->buffer_ptr;
2212 bytes_sent = frame_bytes - bytes_left;
2213 return c->cur_pts + (c->cur_frame_duration * bytes_sent) / frame_bytes;
2218 static int http_prepare_data(HTTPContext *c)
2221 AVFormatContext *ctx;
2223 av_freep(&c->pb_buffer);
2225 case HTTPSTATE_SEND_DATA_HEADER:
2226 memset(&c->fmt_ctx, 0, sizeof(c->fmt_ctx));
2227 av_dict_set(&c->fmt_ctx.metadata, "author" , c->stream->author , 0);
2228 av_dict_set(&c->fmt_ctx.metadata, "comment" , c->stream->comment , 0);
2229 av_dict_set(&c->fmt_ctx.metadata, "copyright", c->stream->copyright, 0);
2230 av_dict_set(&c->fmt_ctx.metadata, "title" , c->stream->title , 0);
2232 c->fmt_ctx.streams = av_mallocz(sizeof(AVStream *) * c->stream->nb_streams);
2234 for(i=0;i<c->stream->nb_streams;i++) {
2236 c->fmt_ctx.streams[i] = av_mallocz(sizeof(AVStream));
2237 /* if file or feed, then just take streams from FFStream struct */
2238 if (!c->stream->feed ||
2239 c->stream->feed == c->stream)
2240 src = c->stream->streams[i];
2242 src = c->stream->feed->streams[c->stream->feed_streams[i]];
2244 *(c->fmt_ctx.streams[i]) = *src;
2245 c->fmt_ctx.streams[i]->priv_data = 0;
2246 c->fmt_ctx.streams[i]->codec->frame_number = 0; /* XXX: should be done in
2247 AVStream, not in codec */
2249 /* set output format parameters */
2250 c->fmt_ctx.oformat = c->stream->fmt;
2251 c->fmt_ctx.nb_streams = c->stream->nb_streams;
2253 c->got_key_frame = 0;
2255 /* prepare header and save header data in a stream */
2256 if (avio_open_dyn_buf(&c->fmt_ctx.pb) < 0) {
2257 /* XXX: potential leak */
2260 c->fmt_ctx.pb->seekable = 0;
2263 * HACK to avoid mpeg ps muxer to spit many underflow errors
2264 * Default value from FFmpeg
2265 * Try to set it use configuration option
2267 c->fmt_ctx.max_delay = (int)(0.7*AV_TIME_BASE);
2269 if (avformat_write_header(&c->fmt_ctx, NULL) < 0) {
2270 http_log("Error writing output header\n");
2273 av_dict_free(&c->fmt_ctx.metadata);
2275 len = avio_close_dyn_buf(c->fmt_ctx.pb, &c->pb_buffer);
2276 c->buffer_ptr = c->pb_buffer;
2277 c->buffer_end = c->pb_buffer + len;
2279 c->state = HTTPSTATE_SEND_DATA;
2280 c->last_packet_sent = 0;
2282 case HTTPSTATE_SEND_DATA:
2283 /* find a new packet */
2284 /* read a packet from the input stream */
2285 if (c->stream->feed)
2286 ffm_set_write_index(c->fmt_in,
2287 c->stream->feed->feed_write_index,
2288 c->stream->feed->feed_size);
2290 if (c->stream->max_time &&
2291 c->stream->max_time + c->start_time - cur_time < 0)
2292 /* We have timed out */
2293 c->state = HTTPSTATE_SEND_DATA_TRAILER;
2297 ret = av_read_frame(c->fmt_in, &pkt);
2299 if (c->stream->feed) {
2300 /* if coming from feed, it means we reached the end of the
2301 ffm file, so must wait for more data */
2302 c->state = HTTPSTATE_WAIT_FEED;
2303 return 1; /* state changed */
2304 } else if (ret == AVERROR(EAGAIN)) {
2305 /* input not ready, come back later */
2308 if (c->stream->loop) {
2309 avformat_close_input(&c->fmt_in);
2310 if (open_input_stream(c, "") < 0)
2315 /* must send trailer now because eof or error */
2316 c->state = HTTPSTATE_SEND_DATA_TRAILER;
2320 int source_index = pkt.stream_index;
2321 /* update first pts if needed */
2322 if (c->first_pts == AV_NOPTS_VALUE) {
2323 c->first_pts = av_rescale_q(pkt.dts, c->fmt_in->streams[pkt.stream_index]->time_base, AV_TIME_BASE_Q);
2324 c->start_time = cur_time;
2326 /* send it to the appropriate stream */
2327 if (c->stream->feed) {
2328 /* if coming from a feed, select the right stream */
2329 if (c->switch_pending) {
2330 c->switch_pending = 0;
2331 for(i=0;i<c->stream->nb_streams;i++) {
2332 if (c->switch_feed_streams[i] == pkt.stream_index)
2333 if (pkt.flags & AV_PKT_FLAG_KEY)
2334 c->switch_feed_streams[i] = -1;
2335 if (c->switch_feed_streams[i] >= 0)
2336 c->switch_pending = 1;
2339 for(i=0;i<c->stream->nb_streams;i++) {
2340 if (c->stream->feed_streams[i] == pkt.stream_index) {
2341 AVStream *st = c->fmt_in->streams[source_index];
2342 pkt.stream_index = i;
2343 if (pkt.flags & AV_PKT_FLAG_KEY &&
2344 (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2345 c->stream->nb_streams == 1))
2346 c->got_key_frame = 1;
2347 if (!c->stream->send_on_key || c->got_key_frame)
2352 AVCodecContext *codec;
2353 AVStream *ist, *ost;
2355 ist = c->fmt_in->streams[source_index];
2356 /* specific handling for RTP: we use several
2357 output stream (one for each RTP
2358 connection). XXX: need more abstract handling */
2359 if (c->is_packetized) {
2360 /* compute send time and duration */
2361 c->cur_pts = av_rescale_q(pkt.dts, ist->time_base, AV_TIME_BASE_Q);
2362 c->cur_pts -= c->first_pts;
2363 c->cur_frame_duration = av_rescale_q(pkt.duration, ist->time_base, AV_TIME_BASE_Q);
2364 /* find RTP context */
2365 c->packet_stream_index = pkt.stream_index;
2366 ctx = c->rtp_ctx[c->packet_stream_index];
2368 av_free_packet(&pkt);
2371 codec = ctx->streams[0]->codec;
2372 /* only one stream per RTP connection */
2373 pkt.stream_index = 0;
2377 codec = ctx->streams[pkt.stream_index]->codec;
2380 if (c->is_packetized) {
2381 int max_packet_size;
2382 if (c->rtp_protocol == RTSP_LOWER_TRANSPORT_TCP)
2383 max_packet_size = RTSP_TCP_MAX_PACKET_SIZE;
2385 max_packet_size = c->rtp_handles[c->packet_stream_index]->max_packet_size;
2386 ret = ffio_open_dyn_packet_buf(&ctx->pb, max_packet_size);
2388 ret = avio_open_dyn_buf(&ctx->pb);
2391 /* XXX: potential leak */
2394 ost = ctx->streams[pkt.stream_index];
2396 ctx->pb->seekable = 0;
2397 if (pkt.dts != AV_NOPTS_VALUE)
2398 pkt.dts = av_rescale_q(pkt.dts, ist->time_base, ost->time_base);
2399 if (pkt.pts != AV_NOPTS_VALUE)
2400 pkt.pts = av_rescale_q(pkt.pts, ist->time_base, ost->time_base);
2401 pkt.duration = av_rescale_q(pkt.duration, ist->time_base, ost->time_base);
2402 if (av_write_frame(ctx, &pkt) < 0) {
2403 http_log("Error writing frame to output\n");
2404 c->state = HTTPSTATE_SEND_DATA_TRAILER;
2407 len = avio_close_dyn_buf(ctx->pb, &c->pb_buffer);
2408 c->cur_frame_bytes = len;
2409 c->buffer_ptr = c->pb_buffer;
2410 c->buffer_end = c->pb_buffer + len;
2412 codec->frame_number++;
2414 av_free_packet(&pkt);
2418 av_free_packet(&pkt);
2423 case HTTPSTATE_SEND_DATA_TRAILER:
2424 /* last packet test ? */
2425 if (c->last_packet_sent || c->is_packetized)
2428 /* prepare header */
2429 if (avio_open_dyn_buf(&ctx->pb) < 0) {
2430 /* XXX: potential leak */
2433 c->fmt_ctx.pb->seekable = 0;
2434 av_write_trailer(ctx);
2435 len = avio_close_dyn_buf(ctx->pb, &c->pb_buffer);
2436 c->buffer_ptr = c->pb_buffer;
2437 c->buffer_end = c->pb_buffer + len;
2439 c->last_packet_sent = 1;
2445 /* should convert the format at the same time */
2446 /* send data starting at c->buffer_ptr to the output connection
2447 (either UDP or TCP connection) */
2448 static int http_send_data(HTTPContext *c)
2453 if (c->buffer_ptr >= c->buffer_end) {
2454 ret = http_prepare_data(c);
2458 /* state change requested */
2461 if (c->is_packetized) {
2462 /* RTP data output */
2463 len = c->buffer_end - c->buffer_ptr;
2465 /* fail safe - should never happen */
2467 c->buffer_ptr = c->buffer_end;
2470 len = (c->buffer_ptr[0] << 24) |
2471 (c->buffer_ptr[1] << 16) |
2472 (c->buffer_ptr[2] << 8) |
2474 if (len > (c->buffer_end - c->buffer_ptr))
2476 if ((get_packet_send_clock(c) - get_server_clock(c)) > 0) {
2477 /* nothing to send yet: we can wait */
2481 c->data_count += len;
2482 update_datarate(&c->datarate, c->data_count);
2484 c->stream->bytes_served += len;
2486 if (c->rtp_protocol == RTSP_LOWER_TRANSPORT_TCP) {
2487 /* RTP packets are sent inside the RTSP TCP connection */
2489 int interleaved_index, size;
2491 HTTPContext *rtsp_c;
2494 /* if no RTSP connection left, error */
2497 /* if already sending something, then wait. */
2498 if (rtsp_c->state != RTSPSTATE_WAIT_REQUEST)
2500 if (avio_open_dyn_buf(&pb) < 0)
2502 interleaved_index = c->packet_stream_index * 2;
2503 /* RTCP packets are sent at odd indexes */
2504 if (c->buffer_ptr[1] == 200)
2505 interleaved_index++;
2506 /* write RTSP TCP header */
2508 header[1] = interleaved_index;
2509 header[2] = len >> 8;
2511 avio_write(pb, header, 4);
2512 /* write RTP packet data */
2514 avio_write(pb, c->buffer_ptr, len);
2515 size = avio_close_dyn_buf(pb, &c->packet_buffer);
2516 /* prepare asynchronous TCP sending */
2517 rtsp_c->packet_buffer_ptr = c->packet_buffer;
2518 rtsp_c->packet_buffer_end = c->packet_buffer + size;
2519 c->buffer_ptr += len;
2521 /* send everything we can NOW */
2522 len = send(rtsp_c->fd, rtsp_c->packet_buffer_ptr,
2523 rtsp_c->packet_buffer_end - rtsp_c->packet_buffer_ptr, 0);
2525 rtsp_c->packet_buffer_ptr += len;
2526 if (rtsp_c->packet_buffer_ptr < rtsp_c->packet_buffer_end) {
2527 /* if we could not send all the data, we will
2528 send it later, so a new state is needed to
2529 "lock" the RTSP TCP connection */
2530 rtsp_c->state = RTSPSTATE_SEND_PACKET;
2533 /* all data has been sent */
2534 av_freep(&c->packet_buffer);
2536 /* send RTP packet directly in UDP */
2538 ffurl_write(c->rtp_handles[c->packet_stream_index],
2539 c->buffer_ptr, len);
2540 c->buffer_ptr += len;
2541 /* here we continue as we can send several packets per 10 ms slot */
2544 /* TCP data output */
2545 len = send(c->fd, c->buffer_ptr, c->buffer_end - c->buffer_ptr, 0);
2547 if (ff_neterrno() != AVERROR(EAGAIN) &&
2548 ff_neterrno() != AVERROR(EINTR))
2549 /* error : close connection */
2554 c->buffer_ptr += len;
2556 c->data_count += len;
2557 update_datarate(&c->datarate, c->data_count);
2559 c->stream->bytes_served += len;
2567 static int http_start_receive_data(HTTPContext *c)
2571 if (c->stream->feed_opened)
2574 /* Don't permit writing to this one */
2575 if (c->stream->readonly)
2579 fd = open(c->stream->feed_filename, O_RDWR);
2581 http_log("Error opening feeder file: %s\n", strerror(errno));
2586 if (c->stream->truncate) {
2587 /* truncate feed file */
2588 ffm_write_write_index(c->feed_fd, FFM_PACKET_SIZE);
2589 http_log("Truncating feed file '%s'\n", c->stream->feed_filename);
2590 if (ftruncate(c->feed_fd, FFM_PACKET_SIZE) < 0) {
2591 http_log("Error truncating feed file: %s\n", strerror(errno));
2595 if ((c->stream->feed_write_index = ffm_read_write_index(fd)) < 0) {
2596 http_log("Error reading write index from feed file: %s\n", strerror(errno));
2601 c->stream->feed_write_index = FFMAX(ffm_read_write_index(fd), FFM_PACKET_SIZE);
2602 c->stream->feed_size = lseek(fd, 0, SEEK_END);
2603 lseek(fd, 0, SEEK_SET);
2605 /* init buffer input */
2606 c->buffer_ptr = c->buffer;
2607 c->buffer_end = c->buffer + FFM_PACKET_SIZE;
2608 c->stream->feed_opened = 1;
2609 c->chunked_encoding = !!av_stristr(c->buffer, "Transfer-Encoding: chunked");
2613 static int http_receive_data(HTTPContext *c)
2616 int len, loop_run = 0;
2618 while (c->chunked_encoding && !c->chunk_size &&
2619 c->buffer_end > c->buffer_ptr) {
2620 /* read chunk header, if present */
2621 len = recv(c->fd, c->buffer_ptr, 1, 0);
2624 if (ff_neterrno() != AVERROR(EAGAIN) &&
2625 ff_neterrno() != AVERROR(EINTR))
2626 /* error : close connection */
2629 } else if (len == 0) {
2630 /* end of connection : close it */
2632 } else if (c->buffer_ptr - c->buffer >= 2 &&
2633 !memcmp(c->buffer_ptr - 1, "\r\n", 2)) {
2634 c->chunk_size = strtol(c->buffer, 0, 16);
2635 if (c->chunk_size == 0) // end of stream
2637 c->buffer_ptr = c->buffer;
2639 } else if (++loop_run > 10) {
2640 /* no chunk header, abort */
2647 if (c->buffer_end > c->buffer_ptr) {
2648 len = recv(c->fd, c->buffer_ptr,
2649 FFMIN(c->chunk_size, c->buffer_end - c->buffer_ptr), 0);
2651 if (ff_neterrno() != AVERROR(EAGAIN) &&
2652 ff_neterrno() != AVERROR(EINTR))
2653 /* error : close connection */
2655 } else if (len == 0)
2656 /* end of connection : close it */
2659 c->chunk_size -= len;
2660 c->buffer_ptr += len;
2661 c->data_count += len;
2662 update_datarate(&c->datarate, c->data_count);
2666 if (c->buffer_ptr - c->buffer >= 2 && c->data_count > FFM_PACKET_SIZE) {
2667 if (c->buffer[0] != 'f' ||
2668 c->buffer[1] != 'm') {
2669 http_log("Feed stream has become desynchronized -- disconnecting\n");
2674 if (c->buffer_ptr >= c->buffer_end) {
2675 FFStream *feed = c->stream;
2676 /* a packet has been received : write it in the store, except
2678 if (c->data_count > FFM_PACKET_SIZE) {
2680 // printf("writing pos=0x%"PRIx64" size=0x%"PRIx64"\n", feed->feed_write_index, feed->feed_size);
2681 /* XXX: use llseek or url_seek */
2682 lseek(c->feed_fd, feed->feed_write_index, SEEK_SET);
2683 if (write(c->feed_fd, c->buffer, FFM_PACKET_SIZE) < 0) {
2684 http_log("Error writing to feed file: %s\n", strerror(errno));
2688 feed->feed_write_index += FFM_PACKET_SIZE;
2689 /* update file size */
2690 if (feed->feed_write_index > c->stream->feed_size)
2691 feed->feed_size = feed->feed_write_index;
2693 /* handle wrap around if max file size reached */
2694 if (c->stream->feed_max_size && feed->feed_write_index >= c->stream->feed_max_size)
2695 feed->feed_write_index = FFM_PACKET_SIZE;
2698 if (ffm_write_write_index(c->feed_fd, feed->feed_write_index) < 0) {
2699 http_log("Error writing index to feed file: %s\n", strerror(errno));
2703 /* wake up any waiting connections */
2704 for(c1 = first_http_ctx; c1 != NULL; c1 = c1->next) {
2705 if (c1->state == HTTPSTATE_WAIT_FEED &&
2706 c1->stream->feed == c->stream->feed)
2707 c1->state = HTTPSTATE_SEND_DATA;
2710 /* We have a header in our hands that contains useful data */
2711 AVFormatContext *s = avformat_alloc_context();
2713 AVInputFormat *fmt_in;
2719 /* use feed output format name to find corresponding input format */
2720 fmt_in = av_find_input_format(feed->fmt->name);
2724 pb = avio_alloc_context(c->buffer, c->buffer_end - c->buffer,
2725 0, NULL, NULL, NULL, NULL);
2729 if (avformat_open_input(&s, c->stream->feed_filename, fmt_in, NULL) < 0) {
2734 /* Now we have the actual streams */
2735 if (s->nb_streams != feed->nb_streams) {
2736 avformat_close_input(&s);
2738 http_log("Feed '%s' stream number does not match registered feed\n",
2739 c->stream->feed_filename);
2743 for (i = 0; i < s->nb_streams; i++) {
2744 AVStream *fst = feed->streams[i];
2745 AVStream *st = s->streams[i];
2746 avcodec_copy_context(fst->codec, st->codec);
2749 avformat_close_input(&s);
2752 c->buffer_ptr = c->buffer;
2757 c->stream->feed_opened = 0;
2759 /* wake up any waiting connections to stop waiting for feed */
2760 for(c1 = first_http_ctx; c1 != NULL; c1 = c1->next) {
2761 if (c1->state == HTTPSTATE_WAIT_FEED &&
2762 c1->stream->feed == c->stream->feed)
2763 c1->state = HTTPSTATE_SEND_DATA_TRAILER;
2768 /********************************************************************/
2771 static void rtsp_reply_header(HTTPContext *c, enum RTSPStatusCode error_number)
2778 switch(error_number) {
2779 case RTSP_STATUS_OK:
2782 case RTSP_STATUS_METHOD:
2783 str = "Method Not Allowed";
2785 case RTSP_STATUS_BANDWIDTH:
2786 str = "Not Enough Bandwidth";
2788 case RTSP_STATUS_SESSION:
2789 str = "Session Not Found";
2791 case RTSP_STATUS_STATE:
2792 str = "Method Not Valid in This State";
2794 case RTSP_STATUS_AGGREGATE:
2795 str = "Aggregate operation not allowed";
2797 case RTSP_STATUS_ONLY_AGGREGATE:
2798 str = "Only aggregate operation allowed";
2800 case RTSP_STATUS_TRANSPORT:
2801 str = "Unsupported transport";
2803 case RTSP_STATUS_INTERNAL:
2804 str = "Internal Server Error";
2806 case RTSP_STATUS_SERVICE:
2807 str = "Service Unavailable";
2809 case RTSP_STATUS_VERSION:
2810 str = "RTSP Version not supported";
2813 str = "Unknown Error";
2817 avio_printf(c->pb, "RTSP/1.0 %d %s\r\n", error_number, str);
2818 avio_printf(c->pb, "CSeq: %d\r\n", c->seq);
2820 /* output GMT time */
2823 strftime(buf2, sizeof(buf2), "%a, %d %b %Y %H:%M:%S", tm);
2824 avio_printf(c->pb, "Date: %s GMT\r\n", buf2);
2827 static void rtsp_reply_error(HTTPContext *c, enum RTSPStatusCode error_number)
2829 rtsp_reply_header(c, error_number);
2830 avio_printf(c->pb, "\r\n");
2833 static int rtsp_parse_request(HTTPContext *c)
2835 const char *p, *p1, *p2;
2841 RTSPMessageHeader header1 = { 0 }, *header = &header1;
2843 c->buffer_ptr[0] = '\0';
2846 get_word(cmd, sizeof(cmd), &p);
2847 get_word(url, sizeof(url), &p);
2848 get_word(protocol, sizeof(protocol), &p);
2850 av_strlcpy(c->method, cmd, sizeof(c->method));
2851 av_strlcpy(c->url, url, sizeof(c->url));
2852 av_strlcpy(c->protocol, protocol, sizeof(c->protocol));
2854 if (avio_open_dyn_buf(&c->pb) < 0) {
2855 /* XXX: cannot do more */
2856 c->pb = NULL; /* safety */
2860 /* check version name */
2861 if (strcmp(protocol, "RTSP/1.0") != 0) {
2862 rtsp_reply_error(c, RTSP_STATUS_VERSION);
2866 /* parse each header line */
2867 /* skip to next line */
2868 while (*p != '\n' && *p != '\0')
2872 while (*p != '\0') {
2873 p1 = memchr(p, '\n', (char *)c->buffer_ptr - p);
2877 if (p2 > p && p2[-1] == '\r')
2879 /* skip empty line */
2883 if (len > sizeof(line) - 1)
2884 len = sizeof(line) - 1;
2885 memcpy(line, p, len);
2887 ff_rtsp_parse_line(header, line, NULL, NULL);
2891 /* handle sequence number */
2892 c->seq = header->seq;
2894 if (!strcmp(cmd, "DESCRIBE"))
2895 rtsp_cmd_describe(c, url);
2896 else if (!strcmp(cmd, "OPTIONS"))
2897 rtsp_cmd_options(c, url);
2898 else if (!strcmp(cmd, "SETUP"))
2899 rtsp_cmd_setup(c, url, header);
2900 else if (!strcmp(cmd, "PLAY"))
2901 rtsp_cmd_play(c, url, header);
2902 else if (!strcmp(cmd, "PAUSE"))
2903 rtsp_cmd_pause(c, url, header);
2904 else if (!strcmp(cmd, "TEARDOWN"))
2905 rtsp_cmd_teardown(c, url, header);
2907 rtsp_reply_error(c, RTSP_STATUS_METHOD);
2910 len = avio_close_dyn_buf(c->pb, &c->pb_buffer);
2911 c->pb = NULL; /* safety */
2913 /* XXX: cannot do more */
2916 c->buffer_ptr = c->pb_buffer;
2917 c->buffer_end = c->pb_buffer + len;
2918 c->state = RTSPSTATE_SEND_REPLY;
2922 static int prepare_sdp_description(FFStream *stream, uint8_t **pbuffer,
2923 struct in_addr my_ip)
2925 AVFormatContext *avc;
2926 AVStream *avs = NULL;
2929 avc = avformat_alloc_context();
2933 av_dict_set(&avc->metadata, "title",
2934 stream->title[0] ? stream->title : "No Title", 0);
2935 avc->nb_streams = stream->nb_streams;
2936 if (stream->is_multicast) {
2937 snprintf(avc->filename, 1024, "rtp://%s:%d?multicast=1?ttl=%d",
2938 inet_ntoa(stream->multicast_ip),
2939 stream->multicast_port, stream->multicast_ttl);
2941 snprintf(avc->filename, 1024, "rtp://0.0.0.0");
2944 if (avc->nb_streams >= INT_MAX/sizeof(*avc->streams) ||
2945 !(avc->streams = av_malloc(avc->nb_streams * sizeof(*avc->streams))))
2947 if (avc->nb_streams >= INT_MAX/sizeof(*avs) ||
2948 !(avs = av_malloc(avc->nb_streams * sizeof(*avs))))
2951 for(i = 0; i < stream->nb_streams; i++) {
2952 avc->streams[i] = &avs[i];
2953 avc->streams[i]->codec = stream->streams[i]->codec;
2955 *pbuffer = av_mallocz(2048);
2956 av_sdp_create(&avc, 1, *pbuffer, 2048);
2959 av_free(avc->streams);
2960 av_dict_free(&avc->metadata);
2964 return strlen(*pbuffer);
2967 static void rtsp_cmd_options(HTTPContext *c, const char *url)
2969 // rtsp_reply_header(c, RTSP_STATUS_OK);
2970 avio_printf(c->pb, "RTSP/1.0 %d %s\r\n", RTSP_STATUS_OK, "OK");
2971 avio_printf(c->pb, "CSeq: %d\r\n", c->seq);
2972 avio_printf(c->pb, "Public: %s\r\n", "OPTIONS, DESCRIBE, SETUP, TEARDOWN, PLAY, PAUSE");
2973 avio_printf(c->pb, "\r\n");
2976 static void rtsp_cmd_describe(HTTPContext *c, const char *url)
2982 int content_length, len;
2983 struct sockaddr_in my_addr;
2985 /* find which url is asked */
2986 av_url_split(NULL, 0, NULL, 0, NULL, 0, NULL, path1, sizeof(path1), url);
2991 for(stream = first_stream; stream != NULL; stream = stream->next) {
2992 if (!stream->is_feed &&
2993 stream->fmt && !strcmp(stream->fmt->name, "rtp") &&
2994 !strcmp(path, stream->filename)) {
2998 /* no stream found */
2999 rtsp_reply_error(c, RTSP_STATUS_SERVICE); /* XXX: right error ? */
3003 /* prepare the media description in sdp format */
3005 /* get the host IP */
3006 len = sizeof(my_addr);
3007 getsockname(c->fd, (struct sockaddr *)&my_addr, &len);
3008 content_length = prepare_sdp_description(stream, &content, my_addr.sin_addr);
3009 if (content_length < 0) {
3010 rtsp_reply_error(c, RTSP_STATUS_INTERNAL);
3013 rtsp_reply_header(c, RTSP_STATUS_OK);
3014 avio_printf(c->pb, "Content-Base: %s/\r\n", url);
3015 avio_printf(c->pb, "Content-Type: application/sdp\r\n");
3016 avio_printf(c->pb, "Content-Length: %d\r\n", content_length);
3017 avio_printf(c->pb, "\r\n");
3018 avio_write(c->pb, content, content_length);
3022 static HTTPContext *find_rtp_session(const char *session_id)
3026 if (session_id[0] == '\0')
3029 for(c = first_http_ctx; c != NULL; c = c->next) {
3030 if (!strcmp(c->session_id, session_id))
3036 static RTSPTransportField *find_transport(RTSPMessageHeader *h, enum RTSPLowerTransport lower_transport)
3038 RTSPTransportField *th;
3041 for(i=0;i<h->nb_transports;i++) {
3042 th = &h->transports[i];
3043 if (th->lower_transport == lower_transport)
3049 static void rtsp_cmd_setup(HTTPContext *c, const char *url,
3050 RTSPMessageHeader *h)
3053 int stream_index, rtp_port, rtcp_port;
3058 RTSPTransportField *th;
3059 struct sockaddr_in dest_addr;
3060 RTSPActionServerSetup setup;
3062 /* find which url is asked */
3063 av_url_split(NULL, 0, NULL, 0, NULL, 0, NULL, path1, sizeof(path1), url);
3068 /* now check each stream */
3069 for(stream = first_stream; stream != NULL; stream = stream->next) {
3070 if (!stream->is_feed &&
3071 stream->fmt && !strcmp(stream->fmt->name, "rtp")) {
3072 /* accept aggregate filenames only if single stream */
3073 if (!strcmp(path, stream->filename)) {
3074 if (stream->nb_streams != 1) {
3075 rtsp_reply_error(c, RTSP_STATUS_AGGREGATE);
3082 for(stream_index = 0; stream_index < stream->nb_streams;
3084 snprintf(buf, sizeof(buf), "%s/streamid=%d",
3085 stream->filename, stream_index);
3086 if (!strcmp(path, buf))
3091 /* no stream found */
3092 rtsp_reply_error(c, RTSP_STATUS_SERVICE); /* XXX: right error ? */
3096 /* generate session id if needed */
3097 if (h->session_id[0] == '\0') {
3098 unsigned random0 = av_lfg_get(&random_state);
3099 unsigned random1 = av_lfg_get(&random_state);
3100 snprintf(h->session_id, sizeof(h->session_id), "%08x%08x",
3104 /* find rtp session, and create it if none found */
3105 rtp_c = find_rtp_session(h->session_id);
3107 /* always prefer UDP */
3108 th = find_transport(h, RTSP_LOWER_TRANSPORT_UDP);
3110 th = find_transport(h, RTSP_LOWER_TRANSPORT_TCP);
3112 rtsp_reply_error(c, RTSP_STATUS_TRANSPORT);
3117 rtp_c = rtp_new_connection(&c->from_addr, stream, h->session_id,
3118 th->lower_transport);
3120 rtsp_reply_error(c, RTSP_STATUS_BANDWIDTH);
3124 /* open input stream */
3125 if (open_input_stream(rtp_c, "") < 0) {
3126 rtsp_reply_error(c, RTSP_STATUS_INTERNAL);
3131 /* test if stream is OK (test needed because several SETUP needs
3132 to be done for a given file) */
3133 if (rtp_c->stream != stream) {
3134 rtsp_reply_error(c, RTSP_STATUS_SERVICE);
3138 /* test if stream is already set up */
3139 if (rtp_c->rtp_ctx[stream_index]) {
3140 rtsp_reply_error(c, RTSP_STATUS_STATE);
3144 /* check transport */
3145 th = find_transport(h, rtp_c->rtp_protocol);
3146 if (!th || (th->lower_transport == RTSP_LOWER_TRANSPORT_UDP &&
3147 th->client_port_min <= 0)) {
3148 rtsp_reply_error(c, RTSP_STATUS_TRANSPORT);
3152 /* setup default options */
3153 setup.transport_option[0] = '\0';
3154 dest_addr = rtp_c->from_addr;
3155 dest_addr.sin_port = htons(th->client_port_min);
3158 if (rtp_new_av_stream(rtp_c, stream_index, &dest_addr, c) < 0) {
3159 rtsp_reply_error(c, RTSP_STATUS_TRANSPORT);
3163 /* now everything is OK, so we can send the connection parameters */
3164 rtsp_reply_header(c, RTSP_STATUS_OK);
3166 avio_printf(c->pb, "Session: %s\r\n", rtp_c->session_id);
3168 switch(rtp_c->rtp_protocol) {
3169 case RTSP_LOWER_TRANSPORT_UDP:
3170 rtp_port = ff_rtp_get_local_rtp_port(rtp_c->rtp_handles[stream_index]);
3171 rtcp_port = ff_rtp_get_local_rtcp_port(rtp_c->rtp_handles[stream_index]);
3172 avio_printf(c->pb, "Transport: RTP/AVP/UDP;unicast;"
3173 "client_port=%d-%d;server_port=%d-%d",
3174 th->client_port_min, th->client_port_max,
3175 rtp_port, rtcp_port);
3177 case RTSP_LOWER_TRANSPORT_TCP:
3178 avio_printf(c->pb, "Transport: RTP/AVP/TCP;interleaved=%d-%d",
3179 stream_index * 2, stream_index * 2 + 1);
3184 if (setup.transport_option[0] != '\0')
3185 avio_printf(c->pb, ";%s", setup.transport_option);
3186 avio_printf(c->pb, "\r\n");
3189 avio_printf(c->pb, "\r\n");
3193 /* find an rtp connection by using the session ID. Check consistency
3195 static HTTPContext *find_rtp_session_with_url(const char *url,
3196 const char *session_id)
3204 rtp_c = find_rtp_session(session_id);
3208 /* find which url is asked */
3209 av_url_split(NULL, 0, NULL, 0, NULL, 0, NULL, path1, sizeof(path1), url);
3213 if(!strcmp(path, rtp_c->stream->filename)) return rtp_c;
3214 for(s=0; s<rtp_c->stream->nb_streams; ++s) {
3215 snprintf(buf, sizeof(buf), "%s/streamid=%d",
3216 rtp_c->stream->filename, s);
3217 if(!strncmp(path, buf, sizeof(buf))) {
3218 // XXX: Should we reply with RTSP_STATUS_ONLY_AGGREGATE if nb_streams>1?
3223 if (len > 0 && path[len - 1] == '/' &&
3224 !strncmp(path, rtp_c->stream->filename, len - 1))
3229 static void rtsp_cmd_play(HTTPContext *c, const char *url, RTSPMessageHeader *h)
3233 rtp_c = find_rtp_session_with_url(url, h->session_id);
3235 rtsp_reply_error(c, RTSP_STATUS_SESSION);
3239 if (rtp_c->state != HTTPSTATE_SEND_DATA &&
3240 rtp_c->state != HTTPSTATE_WAIT_FEED &&
3241 rtp_c->state != HTTPSTATE_READY) {
3242 rtsp_reply_error(c, RTSP_STATUS_STATE);
3246 rtp_c->state = HTTPSTATE_SEND_DATA;
3248 /* now everything is OK, so we can send the connection parameters */
3249 rtsp_reply_header(c, RTSP_STATUS_OK);
3251 avio_printf(c->pb, "Session: %s\r\n", rtp_c->session_id);
3252 avio_printf(c->pb, "\r\n");
3255 static void rtsp_cmd_pause(HTTPContext *c, const char *url, RTSPMessageHeader *h)
3259 rtp_c = find_rtp_session_with_url(url, h->session_id);
3261 rtsp_reply_error(c, RTSP_STATUS_SESSION);
3265 if (rtp_c->state != HTTPSTATE_SEND_DATA &&
3266 rtp_c->state != HTTPSTATE_WAIT_FEED) {
3267 rtsp_reply_error(c, RTSP_STATUS_STATE);
3271 rtp_c->state = HTTPSTATE_READY;
3272 rtp_c->first_pts = AV_NOPTS_VALUE;
3273 /* now everything is OK, so we can send the connection parameters */
3274 rtsp_reply_header(c, RTSP_STATUS_OK);
3276 avio_printf(c->pb, "Session: %s\r\n", rtp_c->session_id);
3277 avio_printf(c->pb, "\r\n");
3280 static void rtsp_cmd_teardown(HTTPContext *c, const char *url, RTSPMessageHeader *h)
3284 rtp_c = find_rtp_session_with_url(url, h->session_id);
3286 rtsp_reply_error(c, RTSP_STATUS_SESSION);
3290 /* now everything is OK, so we can send the connection parameters */
3291 rtsp_reply_header(c, RTSP_STATUS_OK);
3293 avio_printf(c->pb, "Session: %s\r\n", rtp_c->session_id);
3294 avio_printf(c->pb, "\r\n");
3296 /* abort the session */
3297 close_connection(rtp_c);
3301 /********************************************************************/
3304 static HTTPContext *rtp_new_connection(struct sockaddr_in *from_addr,
3305 FFStream *stream, const char *session_id,
3306 enum RTSPLowerTransport rtp_protocol)
3308 HTTPContext *c = NULL;
3309 const char *proto_str;
3311 /* XXX: should output a warning page when coming
3312 close to the connection limit */
3313 if (nb_connections >= nb_max_connections)
3316 /* add a new connection */
3317 c = av_mallocz(sizeof(HTTPContext));
3322 c->poll_entry = NULL;
3323 c->from_addr = *from_addr;
3324 c->buffer_size = IOBUFFER_INIT_SIZE;
3325 c->buffer = av_malloc(c->buffer_size);
3330 av_strlcpy(c->session_id, session_id, sizeof(c->session_id));
3331 c->state = HTTPSTATE_READY;
3332 c->is_packetized = 1;
3333 c->rtp_protocol = rtp_protocol;
3335 /* protocol is shown in statistics */
3336 switch(c->rtp_protocol) {
3337 case RTSP_LOWER_TRANSPORT_UDP_MULTICAST:
3338 proto_str = "MCAST";
3340 case RTSP_LOWER_TRANSPORT_UDP:
3343 case RTSP_LOWER_TRANSPORT_TCP:
3350 av_strlcpy(c->protocol, "RTP/", sizeof(c->protocol));
3351 av_strlcat(c->protocol, proto_str, sizeof(c->protocol));
3353 current_bandwidth += stream->bandwidth;
3355 c->next = first_http_ctx;
3367 /* add a new RTP stream in an RTP connection (used in RTSP SETUP
3368 command). If RTP/TCP protocol is used, TCP connection 'rtsp_c' is
3370 static int rtp_new_av_stream(HTTPContext *c,
3371 int stream_index, struct sockaddr_in *dest_addr,
3372 HTTPContext *rtsp_c)
3374 AVFormatContext *ctx;
3377 URLContext *h = NULL;
3379 int max_packet_size;
3381 /* now we can open the relevant output stream */
3382 ctx = avformat_alloc_context();
3385 ctx->oformat = av_guess_format("rtp", NULL, NULL);
3387 st = av_mallocz(sizeof(AVStream));
3390 ctx->nb_streams = 1;
3391 ctx->streams = av_mallocz(sizeof(AVStream *) * ctx->nb_streams);
3394 ctx->streams[0] = st;
3396 if (!c->stream->feed ||
3397 c->stream->feed == c->stream)
3398 memcpy(st, c->stream->streams[stream_index], sizeof(AVStream));
3401 c->stream->feed->streams[c->stream->feed_streams[stream_index]],
3403 st->priv_data = NULL;
3405 /* build destination RTP address */
3406 ipaddr = inet_ntoa(dest_addr->sin_addr);
3408 switch(c->rtp_protocol) {
3409 case RTSP_LOWER_TRANSPORT_UDP:
3410 case RTSP_LOWER_TRANSPORT_UDP_MULTICAST:
3413 /* XXX: also pass as parameter to function ? */
3414 if (c->stream->is_multicast) {
3416 ttl = c->stream->multicast_ttl;
3419 snprintf(ctx->filename, sizeof(ctx->filename),
3420 "rtp://%s:%d?multicast=1&ttl=%d",
3421 ipaddr, ntohs(dest_addr->sin_port), ttl);
3423 snprintf(ctx->filename, sizeof(ctx->filename),
3424 "rtp://%s:%d", ipaddr, ntohs(dest_addr->sin_port));
3427 if (ffurl_open(&h, ctx->filename, AVIO_FLAG_WRITE, NULL, NULL) < 0)
3429 c->rtp_handles[stream_index] = h;
3430 max_packet_size = h->max_packet_size;
3432 case RTSP_LOWER_TRANSPORT_TCP:
3435 max_packet_size = RTSP_TCP_MAX_PACKET_SIZE;
3441 http_log("%s:%d - - \"PLAY %s/streamid=%d %s\"\n",
3442 ipaddr, ntohs(dest_addr->sin_port),
3443 c->stream->filename, stream_index, c->protocol);
3445 /* normally, no packets should be output here, but the packet size may be checked */
3446 if (ffio_open_dyn_packet_buf(&ctx->pb, max_packet_size) < 0) {
3447 /* XXX: close stream */
3450 if (avformat_write_header(ctx, NULL) < 0) {
3457 avio_close_dyn_buf(ctx->pb, &dummy_buf);
3460 c->rtp_ctx[stream_index] = ctx;
3464 /********************************************************************/
3465 /* ffserver initialization */
3467 static AVStream *add_av_stream1(FFStream *stream, AVCodecContext *codec, int copy)
3471 fst = av_mallocz(sizeof(AVStream));
3475 fst->codec = avcodec_alloc_context3(NULL);
3476 memcpy(fst->codec, codec, sizeof(AVCodecContext));
3477 if (codec->extradata_size) {
3478 fst->codec->extradata = av_malloc(codec->extradata_size);
3479 memcpy(fst->codec->extradata, codec->extradata,
3480 codec->extradata_size);
3483 /* live streams must use the actual feed's codec since it may be
3484 * updated later to carry extradata needed by the streams.
3488 fst->priv_data = av_mallocz(sizeof(FeedData));
3489 fst->index = stream->nb_streams;
3490 avpriv_set_pts_info(fst, 33, 1, 90000);
3491 fst->sample_aspect_ratio = codec->sample_aspect_ratio;
3492 stream->streams[stream->nb_streams++] = fst;
3496 /* return the stream number in the feed */
3497 static int add_av_stream(FFStream *feed, AVStream *st)
3500 AVCodecContext *av, *av1;
3504 for(i=0;i<feed->nb_streams;i++) {
3505 st = feed->streams[i];
3507 if (av1->codec_id == av->codec_id &&
3508 av1->codec_type == av->codec_type &&
3509 av1->bit_rate == av->bit_rate) {
3511 switch(av->codec_type) {
3512 case AVMEDIA_TYPE_AUDIO:
3513 if (av1->channels == av->channels &&
3514 av1->sample_rate == av->sample_rate)
3517 case AVMEDIA_TYPE_VIDEO:
3518 if (av1->width == av->width &&
3519 av1->height == av->height &&
3520 av1->time_base.den == av->time_base.den &&
3521 av1->time_base.num == av->time_base.num &&
3522 av1->gop_size == av->gop_size)
3531 fst = add_av_stream1(feed, av, 0);
3534 return feed->nb_streams - 1;
3537 static void remove_stream(FFStream *stream)
3541 while (*ps != NULL) {
3549 /* specific mpeg4 handling : we extract the raw parameters */
3550 static void extract_mpeg4_header(AVFormatContext *infile)
3552 int mpeg4_count, i, size;
3558 for(i=0;i<infile->nb_streams;i++) {
3559 st = infile->streams[i];
3560 if (st->codec->codec_id == AV_CODEC_ID_MPEG4 &&
3561 st->codec->extradata_size == 0) {
3568 printf("MPEG4 without extra data: trying to find header in %s\n", infile->filename);
3569 while (mpeg4_count > 0) {
3570 if (av_read_packet(infile, &pkt) < 0)
3572 st = infile->streams[pkt.stream_index];
3573 if (st->codec->codec_id == AV_CODEC_ID_MPEG4 &&
3574 st->codec->extradata_size == 0) {
3575 av_freep(&st->codec->extradata);
3576 /* fill extradata with the header */
3577 /* XXX: we make hard suppositions here ! */
3579 while (p < pkt.data + pkt.size - 4) {
3580 /* stop when vop header is found */
3581 if (p[0] == 0x00 && p[1] == 0x00 &&
3582 p[2] == 0x01 && p[3] == 0xb6) {
3583 size = p - pkt.data;
3584 // av_hex_dump_log(infile, AV_LOG_DEBUG, pkt.data, size);
3585 st->codec->extradata = av_malloc(size);
3586 st->codec->extradata_size = size;
3587 memcpy(st->codec->extradata, pkt.data, size);
3594 av_free_packet(&pkt);
3598 /* compute the needed AVStream for each file */
3599 static void build_file_streams(void)
3601 FFStream *stream, *stream_next;
3604 /* gather all streams */
3605 for(stream = first_stream; stream != NULL; stream = stream_next) {
3606 AVFormatContext *infile = NULL;
3607 stream_next = stream->next;
3608 if (stream->stream_type == STREAM_TYPE_LIVE &&
3610 /* the stream comes from a file */
3611 /* try to open the file */
3613 if (stream->fmt && !strcmp(stream->fmt->name, "rtp")) {
3614 /* specific case : if transport stream output to RTP,
3615 we use a raw transport stream reader */
3616 av_dict_set(&stream->in_opts, "mpeg2ts_compute_pcr", "1", 0);
3619 http_log("Opening file '%s'\n", stream->feed_filename);
3620 if ((ret = avformat_open_input(&infile, stream->feed_filename, stream->ifmt, &stream->in_opts)) < 0) {
3621 http_log("Could not open '%s': %d\n", stream->feed_filename, ret);
3622 /* remove stream (no need to spend more time on it) */
3624 remove_stream(stream);
3626 /* find all the AVStreams inside and reference them in
3628 if (avformat_find_stream_info(infile, NULL) < 0) {
3629 http_log("Could not find codec parameters from '%s'\n",
3630 stream->feed_filename);
3631 avformat_close_input(&infile);
3634 extract_mpeg4_header(infile);
3636 for(i=0;i<infile->nb_streams;i++)
3637 add_av_stream1(stream, infile->streams[i]->codec, 1);
3639 avformat_close_input(&infile);
3645 /* compute the needed AVStream for each feed */
3646 static void build_feed_streams(void)
3648 FFStream *stream, *feed;
3651 /* gather all streams */
3652 for(stream = first_stream; stream != NULL; stream = stream->next) {
3653 feed = stream->feed;
3655 if (stream->is_feed) {
3656 for(i=0;i<stream->nb_streams;i++)
3657 stream->feed_streams[i] = i;
3659 /* we handle a stream coming from a feed */
3660 for(i=0;i<stream->nb_streams;i++)
3661 stream->feed_streams[i] = add_av_stream(feed, stream->streams[i]);
3666 /* create feed files if needed */
3667 for(feed = first_feed; feed != NULL; feed = feed->next_feed) {
3670 if (avio_check(feed->feed_filename, AVIO_FLAG_READ) > 0) {
3671 /* See if it matches */
3672 AVFormatContext *s = NULL;
3675 if (avformat_open_input(&s, feed->feed_filename, NULL, NULL) >= 0) {
3676 /* set buffer size */
3677 ffio_set_buf_size(s->pb, FFM_PACKET_SIZE);
3678 /* Now see if it matches */
3679 if (s->nb_streams == feed->nb_streams) {
3681 for(i=0;i<s->nb_streams;i++) {
3683 sf = feed->streams[i];
3686 if (sf->index != ss->index ||
3688 http_log("Index & Id do not match for stream %d (%s)\n",
3689 i, feed->feed_filename);
3692 AVCodecContext *ccf, *ccs;
3696 #define CHECK_CODEC(x) (ccf->x != ccs->x)
3698 if (CHECK_CODEC(codec_id) || CHECK_CODEC(codec_type)) {
3699 http_log("Codecs do not match for stream %d\n", i);
3701 } else if (CHECK_CODEC(bit_rate) || CHECK_CODEC(flags)) {
3702 http_log("Codec bitrates do not match for stream %d\n", i);
3704 } else if (ccf->codec_type == AVMEDIA_TYPE_VIDEO) {
3705 if (CHECK_CODEC(time_base.den) ||
3706 CHECK_CODEC(time_base.num) ||
3707 CHECK_CODEC(width) ||
3708 CHECK_CODEC(height)) {
3709 http_log("Codec width, height and framerate do not match for stream %d\n", i);
3712 } else if (ccf->codec_type == AVMEDIA_TYPE_AUDIO) {
3713 if (CHECK_CODEC(sample_rate) ||
3714 CHECK_CODEC(channels) ||
3715 CHECK_CODEC(frame_size)) {
3716 http_log("Codec sample_rate, channels, frame_size do not match for stream %d\n", i);
3720 http_log("Unknown codec type\n");
3728 http_log("Deleting feed file '%s' as stream counts differ (%d != %d)\n",
3729 feed->feed_filename, s->nb_streams, feed->nb_streams);
3731 avformat_close_input(&s);
3733 http_log("Deleting feed file '%s' as it appears to be corrupt\n",
3734 feed->feed_filename);
3737 if (feed->readonly) {
3738 http_log("Unable to delete feed file '%s' as it is marked readonly\n",
3739 feed->feed_filename);
3742 unlink(feed->feed_filename);
3745 if (avio_check(feed->feed_filename, AVIO_FLAG_WRITE) <= 0) {
3746 AVFormatContext s1 = {0}, *s = &s1;
3748 if (feed->readonly) {
3749 http_log("Unable to create feed file '%s' as it is marked readonly\n",
3750 feed->feed_filename);
3754 /* only write the header of the ffm file */
3755 if (avio_open(&s->pb, feed->feed_filename, AVIO_FLAG_WRITE) < 0) {
3756 http_log("Could not open output feed file '%s'\n",
3757 feed->feed_filename);
3760 s->oformat = feed->fmt;
3761 s->nb_streams = feed->nb_streams;
3762 s->streams = feed->streams;
3763 if (avformat_write_header(s, NULL) < 0) {
3764 http_log("Container doesn't supports the required parameters\n");
3767 /* XXX: need better api */
3768 av_freep(&s->priv_data);
3771 /* get feed size and write index */
3772 fd = open(feed->feed_filename, O_RDONLY);
3774 http_log("Could not open output feed file '%s'\n",
3775 feed->feed_filename);
3779 feed->feed_write_index = FFMAX(ffm_read_write_index(fd), FFM_PACKET_SIZE);
3780 feed->feed_size = lseek(fd, 0, SEEK_END);
3781 /* ensure that we do not wrap before the end of file */
3782 if (feed->feed_max_size && feed->feed_max_size < feed->feed_size)
3783 feed->feed_max_size = feed->feed_size;
3789 /* compute the bandwidth used by each stream */
3790 static void compute_bandwidth(void)
3796 for(stream = first_stream; stream != NULL; stream = stream->next) {
3798 for(i=0;i<stream->nb_streams;i++) {
3799 AVStream *st = stream->streams[i];
3800 switch(st->codec->codec_type) {
3801 case AVMEDIA_TYPE_AUDIO:
3802 case AVMEDIA_TYPE_VIDEO:
3803 bandwidth += st->codec->bit_rate;
3809 stream->bandwidth = (bandwidth + 999) / 1000;
3813 /* add a codec and set the default parameters */
3814 static void add_codec(FFStream *stream, AVCodecContext *av)
3818 /* compute default parameters */
3819 switch(av->codec_type) {
3820 case AVMEDIA_TYPE_AUDIO:
3821 if (av->bit_rate == 0)
3822 av->bit_rate = 64000;
3823 if (av->sample_rate == 0)
3824 av->sample_rate = 22050;
3825 if (av->channels == 0)
3828 case AVMEDIA_TYPE_VIDEO:
3829 if (av->bit_rate == 0)
3830 av->bit_rate = 64000;
3831 if (av->time_base.num == 0){
3832 av->time_base.den = 5;
3833 av->time_base.num = 1;
3835 if (av->width == 0 || av->height == 0) {
3839 /* Bitrate tolerance is less for streaming */
3840 if (av->bit_rate_tolerance == 0)
3841 av->bit_rate_tolerance = FFMAX(av->bit_rate / 4,
3842 (int64_t)av->bit_rate*av->time_base.num/av->time_base.den);
3847 if (av->max_qdiff == 0)
3849 av->qcompress = 0.5;
3852 if (!av->nsse_weight)
3853 av->nsse_weight = 8;
3855 av->frame_skip_cmp = FF_CMP_DCTMAX;
3857 av->me_method = ME_EPZS;
3858 av->rc_buffer_aggressivity = 1.0;
3861 av->rc_eq = "tex^qComp";
3862 if (!av->i_quant_factor)
3863 av->i_quant_factor = -0.8;
3864 if (!av->b_quant_factor)
3865 av->b_quant_factor = 1.25;
3866 if (!av->b_quant_offset)
3867 av->b_quant_offset = 1.25;
3868 if (!av->rc_max_rate)
3869 av->rc_max_rate = av->bit_rate * 2;
3871 if (av->rc_max_rate && !av->rc_buffer_size) {
3872 av->rc_buffer_size = av->rc_max_rate;
3881 st = av_mallocz(sizeof(AVStream));
3884 st->codec = avcodec_alloc_context3(NULL);
3885 stream->streams[stream->nb_streams++] = st;
3886 memcpy(st->codec, av, sizeof(AVCodecContext));
3889 static enum AVCodecID opt_audio_codec(const char *arg)
3891 AVCodec *p= avcodec_find_encoder_by_name(arg);
3893 if (p == NULL || p->type != AVMEDIA_TYPE_AUDIO)
3894 return AV_CODEC_ID_NONE;
3899 static enum AVCodecID opt_video_codec(const char *arg)
3901 AVCodec *p= avcodec_find_encoder_by_name(arg);
3903 if (p == NULL || p->type != AVMEDIA_TYPE_VIDEO)
3904 return AV_CODEC_ID_NONE;
3909 /* simplistic plugin support */
3912 static void load_module(const char *filename)
3915 void (*init_func)(void);
3916 dll = dlopen(filename, RTLD_NOW);
3918 fprintf(stderr, "Could not load module '%s' - %s\n",
3919 filename, dlerror());
3923 init_func = dlsym(dll, "ffserver_module_init");
3926 "%s: init function 'ffserver_module_init()' not found\n",
3935 static int ffserver_opt_default(const char *opt, const char *arg,
3936 AVCodecContext *avctx, int type)
3939 const AVOption *o = av_opt_find(avctx, opt, NULL, type, 0);
3941 ret = av_opt_set(avctx, opt, arg, 0);
3945 static int ffserver_opt_preset(const char *arg,
3946 AVCodecContext *avctx, int type,
3947 enum AVCodecID *audio_id, enum AVCodecID *video_id)
3950 char filename[1000], tmp[1000], tmp2[1000], line[1000];
3952 AVCodec *codec = avcodec_find_encoder(avctx->codec_id);
3954 if (!(f = get_preset_file(filename, sizeof(filename), arg, 0,
3955 codec ? codec->name : NULL))) {
3956 fprintf(stderr, "File for preset '%s' not found\n", arg);
3961 int e= fscanf(f, "%999[^\n]\n", line) - 1;
3962 if(line[0] == '#' && !e)
3964 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
3966 fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
3970 if(!strcmp(tmp, "acodec")){
3971 *audio_id = opt_audio_codec(tmp2);
3972 }else if(!strcmp(tmp, "vcodec")){
3973 *video_id = opt_video_codec(tmp2);
3974 }else if(!strcmp(tmp, "scodec")){
3975 /* opt_subtitle_codec(tmp2); */
3976 }else if(ffserver_opt_default(tmp, tmp2, avctx, type) < 0){
3977 fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
3988 static AVOutputFormat *ffserver_guess_format(const char *short_name, const char *filename,
3989 const char *mime_type)
3991 AVOutputFormat *fmt = av_guess_format(short_name, filename, mime_type);
3994 AVOutputFormat *stream_fmt;
3995 char stream_format_name[64];
3997 snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
3998 stream_fmt = av_guess_format(stream_format_name, NULL, NULL);
4007 static void report_config_error(const char *filename, int line_num, int *errors, const char *fmt, ...)
4011 fprintf(stderr, "%s:%d: ", filename, line_num);
4012 vfprintf(stderr, fmt, vl);
4018 static int parse_ffconfig(const char *filename)
4025 int val, errors, line_num;
4026 FFStream **last_stream, *stream, *redirect;
4027 FFStream **last_feed, *feed, *s;
4028 AVCodecContext audio_enc, video_enc;
4029 enum AVCodecID audio_id, video_id;
4031 f = fopen(filename, "r");
4039 first_stream = NULL;
4040 last_stream = &first_stream;
4042 last_feed = &first_feed;
4046 audio_id = AV_CODEC_ID_NONE;
4047 video_id = AV_CODEC_ID_NONE;
4049 #define ERROR(...) report_config_error(filename, line_num, &errors, __VA_ARGS__)
4051 if (fgets(line, sizeof(line), f) == NULL)
4057 if (*p == '\0' || *p == '#')
4060 get_arg(cmd, sizeof(cmd), &p);
4062 if (!av_strcasecmp(cmd, "Port")) {
4063 get_arg(arg, sizeof(arg), &p);
4065 if (val < 1 || val > 65536) {
4066 ERROR("Invalid_port: %s\n", arg);
4068 my_http_addr.sin_port = htons(val);
4069 } else if (!av_strcasecmp(cmd, "BindAddress")) {
4070 get_arg(arg, sizeof(arg), &p);
4071 if (resolve_host(&my_http_addr.sin_addr, arg) != 0) {
4072 ERROR("%s:%d: Invalid host/IP address: %s\n", arg);
4074 } else if (!av_strcasecmp(cmd, "NoDaemon")) {
4075 ffserver_daemon = 0;
4076 } else if (!av_strcasecmp(cmd, "RTSPPort")) {
4077 get_arg(arg, sizeof(arg), &p);
4079 if (val < 1 || val > 65536) {
4080 ERROR("%s:%d: Invalid port: %s\n", arg);
4082 my_rtsp_addr.sin_port = htons(atoi(arg));
4083 } else if (!av_strcasecmp(cmd, "RTSPBindAddress")) {
4084 get_arg(arg, sizeof(arg), &p);
4085 if (resolve_host(&my_rtsp_addr.sin_addr, arg) != 0) {
4086 ERROR("Invalid host/IP address: %s\n", arg);
4088 } else if (!av_strcasecmp(cmd, "MaxHTTPConnections")) {
4089 get_arg(arg, sizeof(arg), &p);
4091 if (val < 1 || val > 65536) {
4092 ERROR("Invalid MaxHTTPConnections: %s\n", arg);
4094 nb_max_http_connections = val;
4095 } else if (!av_strcasecmp(cmd, "MaxClients")) {
4096 get_arg(arg, sizeof(arg), &p);
4098 if (val < 1 || val > nb_max_http_connections) {
4099 ERROR("Invalid MaxClients: %s\n", arg);
4101 nb_max_connections = val;
4103 } else if (!av_strcasecmp(cmd, "MaxBandwidth")) {
4105 get_arg(arg, sizeof(arg), &p);
4107 if (llval < 10 || llval > 10000000) {
4108 ERROR("Invalid MaxBandwidth: %s\n", arg);
4110 max_bandwidth = llval;
4111 } else if (!av_strcasecmp(cmd, "CustomLog")) {
4112 if (!ffserver_debug)
4113 get_arg(logfilename, sizeof(logfilename), &p);
4114 } else if (!av_strcasecmp(cmd, "<Feed")) {
4115 /*********************************************/
4116 /* Feed related options */
4118 if (stream || feed) {
4119 ERROR("Already in a tag\n");
4121 feed = av_mallocz(sizeof(FFStream));
4122 get_arg(feed->filename, sizeof(feed->filename), &p);
4123 q = strrchr(feed->filename, '>');
4127 for (s = first_feed; s; s = s->next) {
4128 if (!strcmp(feed->filename, s->filename)) {
4129 ERROR("Feed '%s' already registered\n", s->filename);
4133 feed->fmt = av_guess_format("ffm", NULL, NULL);
4134 /* defaut feed file */
4135 snprintf(feed->feed_filename, sizeof(feed->feed_filename),
4136 "/tmp/%s.ffm", feed->filename);
4137 feed->feed_max_size = 5 * 1024 * 1024;
4139 feed->feed = feed; /* self feeding :-) */
4141 /* add in stream list */
4142 *last_stream = feed;
4143 last_stream = &feed->next;
4144 /* add in feed list */
4146 last_feed = &feed->next_feed;
4148 } else if (!av_strcasecmp(cmd, "Launch")) {
4152 feed->child_argv = av_mallocz(64 * sizeof(char *));
4154 for (i = 0; i < 62; i++) {
4155 get_arg(arg, sizeof(arg), &p);
4159 feed->child_argv[i] = av_strdup(arg);
4162 feed->child_argv[i] = av_malloc(30 + strlen(feed->filename));
4164 snprintf(feed->child_argv[i], 30+strlen(feed->filename),
4166 (my_http_addr.sin_addr.s_addr == INADDR_ANY) ? "127.0.0.1" :
4167 inet_ntoa(my_http_addr.sin_addr),
4168 ntohs(my_http_addr.sin_port), feed->filename);
4170 } else if (!av_strcasecmp(cmd, "ReadOnlyFile")) {
4172 get_arg(feed->feed_filename, sizeof(feed->feed_filename), &p);
4174 } else if (stream) {
4175 get_arg(stream->feed_filename, sizeof(stream->feed_filename), &p);
4177 } else if (!av_strcasecmp(cmd, "File")) {
4179 get_arg(feed->feed_filename, sizeof(feed->feed_filename), &p);
4181 get_arg(stream->feed_filename, sizeof(stream->feed_filename), &p);
4182 } else if (!av_strcasecmp(cmd, "Truncate")) {
4184 get_arg(arg, sizeof(arg), &p);
4185 feed->truncate = strtod(arg, NULL);
4187 } else if (!av_strcasecmp(cmd, "FileMaxSize")) {
4192 get_arg(arg, sizeof(arg), &p);
4194 fsize = strtod(p1, &p1);
4195 switch(toupper(*p1)) {
4200 fsize *= 1024 * 1024;
4203 fsize *= 1024 * 1024 * 1024;
4206 feed->feed_max_size = (int64_t)fsize;
4207 if (feed->feed_max_size < FFM_PACKET_SIZE*4) {
4208 ERROR("Feed max file size is too small, must be at least %d\n", FFM_PACKET_SIZE*4);
4211 } else if (!av_strcasecmp(cmd, "</Feed>")) {
4213 ERROR("No corresponding <Feed> for </Feed>\n");
4216 } else if (!av_strcasecmp(cmd, "<Stream")) {
4217 /*********************************************/
4218 /* Stream related options */
4220 if (stream || feed) {
4221 ERROR("Already in a tag\n");
4224 stream = av_mallocz(sizeof(FFStream));
4225 get_arg(stream->filename, sizeof(stream->filename), &p);
4226 q = strrchr(stream->filename, '>');
4230 for (s = first_stream; s; s = s->next) {
4231 if (!strcmp(stream->filename, s->filename)) {
4232 ERROR("Stream '%s' already registered\n", s->filename);
4236 stream->fmt = ffserver_guess_format(NULL, stream->filename, NULL);
4237 avcodec_get_context_defaults3(&video_enc, NULL);
4238 avcodec_get_context_defaults3(&audio_enc, NULL);
4240 audio_id = AV_CODEC_ID_NONE;
4241 video_id = AV_CODEC_ID_NONE;
4243 audio_id = stream->fmt->audio_codec;
4244 video_id = stream->fmt->video_codec;
4247 *last_stream = stream;
4248 last_stream = &stream->next;
4250 } else if (!av_strcasecmp(cmd, "Feed")) {
4251 get_arg(arg, sizeof(arg), &p);
4256 while (sfeed != NULL) {
4257 if (!strcmp(sfeed->filename, arg))
4259 sfeed = sfeed->next_feed;
4262 ERROR("feed '%s' not defined\n", arg);
4264 stream->feed = sfeed;
4266 } else if (!av_strcasecmp(cmd, "Format")) {
4267 get_arg(arg, sizeof(arg), &p);
4269 if (!strcmp(arg, "status")) {
4270 stream->stream_type = STREAM_TYPE_STATUS;
4273 stream->stream_type = STREAM_TYPE_LIVE;
4274 /* jpeg cannot be used here, so use single frame jpeg */
4275 if (!strcmp(arg, "jpeg"))
4276 strcpy(arg, "mjpeg");
4277 stream->fmt = ffserver_guess_format(arg, NULL, NULL);
4279 ERROR("Unknown Format: %s\n", arg);
4283 audio_id = stream->fmt->audio_codec;
4284 video_id = stream->fmt->video_codec;
4287 } else if (!av_strcasecmp(cmd, "InputFormat")) {
4288 get_arg(arg, sizeof(arg), &p);
4290 stream->ifmt = av_find_input_format(arg);
4291 if (!stream->ifmt) {
4292 ERROR("Unknown input format: %s\n", arg);
4295 } else if (!av_strcasecmp(cmd, "FaviconURL")) {
4296 if (stream && stream->stream_type == STREAM_TYPE_STATUS) {
4297 get_arg(stream->feed_filename, sizeof(stream->feed_filename), &p);
4299 ERROR("FaviconURL only permitted for status streams\n");
4301 } else if (!av_strcasecmp(cmd, "Author")) {
4303 get_arg(stream->author, sizeof(stream->author), &p);
4304 } else if (!av_strcasecmp(cmd, "Comment")) {
4306 get_arg(stream->comment, sizeof(stream->comment), &p);
4307 } else if (!av_strcasecmp(cmd, "Copyright")) {
4309 get_arg(stream->copyright, sizeof(stream->copyright), &p);
4310 } else if (!av_strcasecmp(cmd, "Title")) {
4312 get_arg(stream->title, sizeof(stream->title), &p);
4313 } else if (!av_strcasecmp(cmd, "Preroll")) {
4314 get_arg(arg, sizeof(arg), &p);
4316 stream->prebuffer = atof(arg) * 1000;
4317 } else if (!av_strcasecmp(cmd, "StartSendOnKey")) {
4319 stream->send_on_key = 1;
4320 } else if (!av_strcasecmp(cmd, "AudioCodec")) {
4321 get_arg(arg, sizeof(arg), &p);
4322 audio_id = opt_audio_codec(arg);
4323 if (audio_id == AV_CODEC_ID_NONE) {
4324 ERROR("Unknown AudioCodec: %s\n", arg);
4326 } else if (!av_strcasecmp(cmd, "VideoCodec")) {
4327 get_arg(arg, sizeof(arg), &p);
4328 video_id = opt_video_codec(arg);
4329 if (video_id == AV_CODEC_ID_NONE) {
4330 ERROR("Unknown VideoCodec: %s\n", arg);
4332 } else if (!av_strcasecmp(cmd, "MaxTime")) {
4333 get_arg(arg, sizeof(arg), &p);
4335 stream->max_time = atof(arg) * 1000;
4336 } else if (!av_strcasecmp(cmd, "AudioBitRate")) {
4337 get_arg(arg, sizeof(arg), &p);
4339 audio_enc.bit_rate = lrintf(atof(arg) * 1000);
4340 } else if (!av_strcasecmp(cmd, "AudioChannels")) {
4341 get_arg(arg, sizeof(arg), &p);
4343 audio_enc.channels = atoi(arg);
4344 } else if (!av_strcasecmp(cmd, "AudioSampleRate")) {
4345 get_arg(arg, sizeof(arg), &p);
4347 audio_enc.sample_rate = atoi(arg);
4348 } else if (!av_strcasecmp(cmd, "AudioQuality")) {
4349 get_arg(arg, sizeof(arg), &p);
4351 // audio_enc.quality = atof(arg) * 1000;
4353 } else if (!av_strcasecmp(cmd, "VideoBitRateRange")) {
4355 int minrate, maxrate;
4357 get_arg(arg, sizeof(arg), &p);
4359 if (sscanf(arg, "%d-%d", &minrate, &maxrate) == 2) {
4360 video_enc.rc_min_rate = minrate * 1000;
4361 video_enc.rc_max_rate = maxrate * 1000;
4363 ERROR("Incorrect format for VideoBitRateRange -- should be <min>-<max>: %s\n", arg);
4366 } else if (!av_strcasecmp(cmd, "Debug")) {
4368 get_arg(arg, sizeof(arg), &p);
4369 video_enc.debug = strtol(arg,0,0);
4371 } else if (!av_strcasecmp(cmd, "Strict")) {
4373 get_arg(arg, sizeof(arg), &p);
4374 video_enc.strict_std_compliance = atoi(arg);
4376 } else if (!av_strcasecmp(cmd, "VideoBufferSize")) {
4378 get_arg(arg, sizeof(arg), &p);
4379 video_enc.rc_buffer_size = atoi(arg) * 8*1024;
4381 } else if (!av_strcasecmp(cmd, "VideoBitRateTolerance")) {
4383 get_arg(arg, sizeof(arg), &p);
4384 video_enc.bit_rate_tolerance = atoi(arg) * 1000;
4386 } else if (!av_strcasecmp(cmd, "VideoBitRate")) {
4387 get_arg(arg, sizeof(arg), &p);
4389 video_enc.bit_rate = atoi(arg) * 1000;
4391 } else if (!av_strcasecmp(cmd, "VideoSize")) {
4392 get_arg(arg, sizeof(arg), &p);
4394 av_parse_video_size(&video_enc.width, &video_enc.height, arg);
4395 if ((video_enc.width % 16) != 0 ||
4396 (video_enc.height % 16) != 0) {
4397 ERROR("Image size must be a multiple of 16\n");
4400 } else if (!av_strcasecmp(cmd, "VideoFrameRate")) {
4401 get_arg(arg, sizeof(arg), &p);
4403 AVRational frame_rate;
4404 if (av_parse_video_rate(&frame_rate, arg) < 0) {
4405 ERROR("Incorrect frame rate: %s\n", arg);
4407 video_enc.time_base.num = frame_rate.den;
4408 video_enc.time_base.den = frame_rate.num;
4411 } else if (!av_strcasecmp(cmd, "VideoGopSize")) {
4412 get_arg(arg, sizeof(arg), &p);
4414 video_enc.gop_size = atoi(arg);
4415 } else if (!av_strcasecmp(cmd, "VideoIntraOnly")) {
4417 video_enc.gop_size = 1;
4418 } else if (!av_strcasecmp(cmd, "VideoHighQuality")) {
4420 video_enc.mb_decision = FF_MB_DECISION_BITS;
4421 } else if (!av_strcasecmp(cmd, "Video4MotionVector")) {
4423 video_enc.mb_decision = FF_MB_DECISION_BITS; //FIXME remove
4424 video_enc.flags |= CODEC_FLAG_4MV;
4426 } else if (!av_strcasecmp(cmd, "AVOptionVideo") ||
4427 !av_strcasecmp(cmd, "AVOptionAudio")) {
4429 AVCodecContext *avctx;
4431 get_arg(arg, sizeof(arg), &p);
4432 get_arg(arg2, sizeof(arg2), &p);
4433 if (!av_strcasecmp(cmd, "AVOptionVideo")) {
4435 type = AV_OPT_FLAG_VIDEO_PARAM;
4438 type = AV_OPT_FLAG_AUDIO_PARAM;
4440 if (ffserver_opt_default(arg, arg2, avctx, type|AV_OPT_FLAG_ENCODING_PARAM)) {
4441 ERROR("AVOption error: %s %s\n", arg, arg2);
4443 } else if (!av_strcasecmp(cmd, "AVPresetVideo") ||
4444 !av_strcasecmp(cmd, "AVPresetAudio")) {
4445 AVCodecContext *avctx;
4447 get_arg(arg, sizeof(arg), &p);
4448 if (!av_strcasecmp(cmd, "AVPresetVideo")) {
4450 video_enc.codec_id = video_id;
4451 type = AV_OPT_FLAG_VIDEO_PARAM;
4454 audio_enc.codec_id = audio_id;
4455 type = AV_OPT_FLAG_AUDIO_PARAM;
4457 if (ffserver_opt_preset(arg, avctx, type|AV_OPT_FLAG_ENCODING_PARAM, &audio_id, &video_id)) {
4458 ERROR("AVPreset error: %s\n", arg);
4460 } else if (!av_strcasecmp(cmd, "VideoTag")) {
4461 get_arg(arg, sizeof(arg), &p);
4462 if ((strlen(arg) == 4) && stream)
4463 video_enc.codec_tag = MKTAG(arg[0], arg[1], arg[2], arg[3]);
4464 } else if (!av_strcasecmp(cmd, "BitExact")) {
4466 video_enc.flags |= CODEC_FLAG_BITEXACT;
4467 } else if (!av_strcasecmp(cmd, "DctFastint")) {
4469 video_enc.dct_algo = FF_DCT_FASTINT;
4470 } else if (!av_strcasecmp(cmd, "IdctSimple")) {
4472 video_enc.idct_algo = FF_IDCT_SIMPLE;
4473 } else if (!av_strcasecmp(cmd, "Qscale")) {
4474 get_arg(arg, sizeof(arg), &p);
4476 video_enc.flags |= CODEC_FLAG_QSCALE;
4477 video_enc.global_quality = FF_QP2LAMBDA * atoi(arg);
4479 } else if (!av_strcasecmp(cmd, "VideoQDiff")) {
4480 get_arg(arg, sizeof(arg), &p);
4482 video_enc.max_qdiff = atoi(arg);
4483 if (video_enc.max_qdiff < 1 || video_enc.max_qdiff > 31) {
4484 ERROR("VideoQDiff out of range\n");
4487 } else if (!av_strcasecmp(cmd, "VideoQMax")) {
4488 get_arg(arg, sizeof(arg), &p);
4490 video_enc.qmax = atoi(arg);
4491 if (video_enc.qmax < 1 || video_enc.qmax > 31) {
4492 ERROR("VideoQMax out of range\n");
4495 } else if (!av_strcasecmp(cmd, "VideoQMin")) {
4496 get_arg(arg, sizeof(arg), &p);
4498 video_enc.qmin = atoi(arg);
4499 if (video_enc.qmin < 1 || video_enc.qmin > 31) {
4500 ERROR("VideoQMin out of range\n");
4503 } else if (!av_strcasecmp(cmd, "LumaElim")) {
4504 get_arg(arg, sizeof(arg), &p);
4506 video_enc.luma_elim_threshold = atoi(arg);
4507 } else if (!av_strcasecmp(cmd, "ChromaElim")) {
4508 get_arg(arg, sizeof(arg), &p);
4510 video_enc.chroma_elim_threshold = atoi(arg);
4511 } else if (!av_strcasecmp(cmd, "LumiMask")) {
4512 get_arg(arg, sizeof(arg), &p);
4514 video_enc.lumi_masking = atof(arg);
4515 } else if (!av_strcasecmp(cmd, "DarkMask")) {
4516 get_arg(arg, sizeof(arg), &p);
4518 video_enc.dark_masking = atof(arg);
4519 } else if (!av_strcasecmp(cmd, "NoVideo")) {
4520 video_id = AV_CODEC_ID_NONE;
4521 } else if (!av_strcasecmp(cmd, "NoAudio")) {
4522 audio_id = AV_CODEC_ID_NONE;
4523 } else if (!av_strcasecmp(cmd, "ACL")) {
4524 parse_acl_row(stream, feed, NULL, p, filename, line_num);
4525 } else if (!av_strcasecmp(cmd, "DynamicACL")) {
4527 get_arg(stream->dynamic_acl, sizeof(stream->dynamic_acl), &p);
4529 } else if (!av_strcasecmp(cmd, "RTSPOption")) {
4530 get_arg(arg, sizeof(arg), &p);
4532 av_freep(&stream->rtsp_option);
4533 stream->rtsp_option = av_strdup(arg);
4535 } else if (!av_strcasecmp(cmd, "MulticastAddress")) {
4536 get_arg(arg, sizeof(arg), &p);
4538 if (resolve_host(&stream->multicast_ip, arg) != 0) {
4539 ERROR("Invalid host/IP address: %s\n", arg);
4541 stream->is_multicast = 1;
4542 stream->loop = 1; /* default is looping */
4544 } else if (!av_strcasecmp(cmd, "MulticastPort")) {
4545 get_arg(arg, sizeof(arg), &p);
4547 stream->multicast_port = atoi(arg);
4548 } else if (!av_strcasecmp(cmd, "MulticastTTL")) {
4549 get_arg(arg, sizeof(arg), &p);
4551 stream->multicast_ttl = atoi(arg);
4552 } else if (!av_strcasecmp(cmd, "NoLoop")) {
4555 } else if (!av_strcasecmp(cmd, "</Stream>")) {
4557 ERROR("No corresponding <Stream> for </Stream>\n");
4559 if (stream->feed && stream->fmt && strcmp(stream->fmt->name, "ffm") != 0) {
4560 if (audio_id != AV_CODEC_ID_NONE) {
4561 audio_enc.codec_type = AVMEDIA_TYPE_AUDIO;
4562 audio_enc.codec_id = audio_id;
4563 add_codec(stream, &audio_enc);
4565 if (video_id != AV_CODEC_ID_NONE) {
4566 video_enc.codec_type = AVMEDIA_TYPE_VIDEO;
4567 video_enc.codec_id = video_id;
4568 add_codec(stream, &video_enc);
4573 } else if (!av_strcasecmp(cmd, "<Redirect")) {
4574 /*********************************************/
4576 if (stream || feed || redirect) {
4577 ERROR("Already in a tag\n");
4579 redirect = av_mallocz(sizeof(FFStream));
4580 *last_stream = redirect;
4581 last_stream = &redirect->next;
4583 get_arg(redirect->filename, sizeof(redirect->filename), &p);
4584 q = strrchr(redirect->filename, '>');
4587 redirect->stream_type = STREAM_TYPE_REDIRECT;
4589 } else if (!av_strcasecmp(cmd, "URL")) {
4591 get_arg(redirect->feed_filename, sizeof(redirect->feed_filename), &p);
4592 } else if (!av_strcasecmp(cmd, "</Redirect>")) {
4594 ERROR("No corresponding <Redirect> for </Redirect>\n");
4596 if (!redirect->feed_filename[0]) {
4597 ERROR("No URL found for <Redirect>\n");
4601 } else if (!av_strcasecmp(cmd, "LoadModule")) {
4602 get_arg(arg, sizeof(arg), &p);
4606 ERROR("Module support not compiled into this version: '%s'\n", arg);
4609 ERROR("Incorrect keyword: '%s'\n", cmd);
4621 static void handle_child_exit(int sig)
4626 while ((pid = waitpid(-1, &status, WNOHANG)) > 0) {
4629 for (feed = first_feed; feed; feed = feed->next) {
4630 if (feed->pid == pid) {
4631 int uptime = time(0) - feed->pid_start;
4634 fprintf(stderr, "%s: Pid %d exited with status %d after %d seconds\n", feed->filename, pid, status, uptime);
4637 /* Turn off any more restarts */
4638 feed->child_argv = 0;
4643 need_to_start_children = 1;
4646 static void opt_debug(void)
4649 ffserver_daemon = 0;
4650 logfilename[0] = '-';
4653 void show_help_default(const char *opt, const char *arg)
4655 printf("usage: ffserver [options]\n"
4656 "Hyper fast multi format Audio/Video streaming server\n");
4658 show_help_options(options, "Main options:", 0, 0, 0);
4661 static const OptionDef options[] = {
4662 #include "cmdutils_common_opts.h"
4663 { "n", OPT_BOOL, {(void *)&no_launch }, "enable no-launch mode" },
4664 { "d", 0, {(void*)opt_debug}, "enable debug mode" },
4665 { "f", HAS_ARG | OPT_STRING, {(void*)&config_filename }, "use configfile instead of /etc/ffserver.conf", "configfile" },
4669 int main(int argc, char **argv)
4671 struct sigaction sigact = { { 0 } };
4673 parse_loglevel(argc, argv, options);
4675 avformat_network_init();
4677 show_banner(argc, argv, options);
4679 my_program_name = argv[0];
4680 my_program_dir = getcwd(0, 0);
4681 ffserver_daemon = 1;
4683 parse_options(NULL, argc, argv, options, NULL);
4685 unsetenv("http_proxy"); /* Kill the http_proxy */
4687 av_lfg_init(&random_state, av_get_random_seed());
4689 sigact.sa_handler = handle_child_exit;
4690 sigact.sa_flags = SA_NOCLDSTOP | SA_RESTART;
4691 sigaction(SIGCHLD, &sigact, 0);
4693 if (parse_ffconfig(config_filename) < 0) {
4694 fprintf(stderr, "Incorrect config file - exiting.\n");
4698 /* open log file if needed */
4699 if (logfilename[0] != '\0') {
4700 if (!strcmp(logfilename, "-"))
4703 logfile = fopen(logfilename, "a");
4704 av_log_set_callback(http_av_log);
4707 build_file_streams();
4709 build_feed_streams();
4711 compute_bandwidth();
4713 /* put the process in background and detach it from its TTY */
4714 if (ffserver_daemon) {
4721 } else if (pid > 0) {
4728 open("/dev/null", O_RDWR);
4729 if (strcmp(logfilename, "-") != 0) {
4739 signal(SIGPIPE, SIG_IGN);
4741 if (ffserver_daemon)
4744 if (http_server() < 0) {
4745 http_log("Could not start server\n");