2 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
4 * This file is part of FFmpeg.
6 * FFmpeg is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * FFmpeg is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with FFmpeg; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23 * multiple format streaming server based on the FFmpeg libraries
28 #define closesocket close
32 #include "libavformat/avformat.h"
33 // FIXME those are internal headers, ffserver _really_ shouldn't use them
34 #include "libavformat/ffm.h"
35 #include "libavformat/network.h"
36 #include "libavformat/os_support.h"
37 #include "libavformat/rtpdec.h"
38 #include "libavformat/rtsp.h"
39 #include "libavformat/avio_internal.h"
40 #include "libavformat/internal.h"
41 #include "libavformat/url.h"
43 #include "libavutil/avstring.h"
44 #include "libavutil/lfg.h"
45 #include "libavutil/dict.h"
46 #include "libavutil/mathematics.h"
47 #include "libavutil/random_seed.h"
48 #include "libavutil/parseutils.h"
49 #include "libavutil/opt.h"
53 #include <sys/ioctl.h>
68 const char program_name[] = "ffserver";
69 const int program_birth_year = 2000;
71 static const OptionDef options[];
74 HTTPSTATE_WAIT_REQUEST,
75 HTTPSTATE_SEND_HEADER,
76 HTTPSTATE_SEND_DATA_HEADER,
77 HTTPSTATE_SEND_DATA, /* sending TCP or UDP data */
78 HTTPSTATE_SEND_DATA_TRAILER,
79 HTTPSTATE_RECEIVE_DATA,
80 HTTPSTATE_WAIT_FEED, /* wait for data from the feed */
83 RTSPSTATE_WAIT_REQUEST,
85 RTSPSTATE_SEND_PACKET,
88 static const char *http_state[] = {
104 #define MAX_STREAMS 20
106 #define IOBUFFER_INIT_SIZE 8192
108 /* timeouts are in ms */
109 #define HTTP_REQUEST_TIMEOUT (15 * 1000)
110 #define RTSP_REQUEST_TIMEOUT (3600 * 24 * 1000)
112 #define SYNC_TIMEOUT (10 * 1000)
114 typedef struct RTSPActionServerSetup {
116 char transport_option[512];
117 } RTSPActionServerSetup;
120 int64_t count1, count2;
121 int64_t time1, time2;
124 /* context associated with one connection */
125 typedef struct HTTPContext {
126 enum HTTPState state;
127 int fd; /* socket file descriptor */
128 struct sockaddr_in from_addr; /* origin */
129 struct pollfd *poll_entry; /* used when polling */
131 uint8_t *buffer_ptr, *buffer_end;
134 int chunked_encoding;
135 int chunk_size; /* 0 if it needs to be read */
136 struct HTTPContext *next;
137 int got_key_frame; /* stream 0 => 1, stream 1 => 2, stream 2=> 4 */
141 /* input format handling */
142 AVFormatContext *fmt_in;
143 int64_t start_time; /* In milliseconds - this wraps fairly often */
144 int64_t first_pts; /* initial pts value */
145 int64_t cur_pts; /* current pts value from the stream in us */
146 int64_t cur_frame_duration; /* duration of the current frame in us */
147 int cur_frame_bytes; /* output frame size, needed to compute
148 the time at which we send each
150 int pts_stream_index; /* stream we choose as clock reference */
151 int64_t cur_clock; /* current clock reference value in us */
152 /* output format handling */
153 struct FFStream *stream;
154 /* -1 is invalid stream */
155 int feed_streams[MAX_STREAMS]; /* index of streams in the feed */
156 int switch_feed_streams[MAX_STREAMS]; /* index of streams in the feed */
158 AVFormatContext fmt_ctx; /* instance of FFStream for one user */
159 int last_packet_sent; /* true if last data packet was sent */
161 DataRateData datarate;
168 int is_packetized; /* if true, the stream is packetized */
169 int packet_stream_index; /* current stream for output in state machine */
171 /* RTSP state specific */
172 uint8_t *pb_buffer; /* XXX: use that in all the code */
174 int seq; /* RTSP sequence number */
176 /* RTP state specific */
177 enum RTSPLowerTransport rtp_protocol;
178 char session_id[32]; /* session id */
179 AVFormatContext *rtp_ctx[MAX_STREAMS];
181 /* RTP/UDP specific */
182 URLContext *rtp_handles[MAX_STREAMS];
184 /* RTP/TCP specific */
185 struct HTTPContext *rtsp_c;
186 uint8_t *packet_buffer, *packet_buffer_ptr, *packet_buffer_end;
189 /* each generated stream is described here */
193 STREAM_TYPE_REDIRECT,
196 enum IPAddressAction {
201 typedef struct IPAddressACL {
202 struct IPAddressACL *next;
203 enum IPAddressAction action;
204 /* These are in host order */
205 struct in_addr first;
209 /* description of each stream of the ffserver.conf file */
210 typedef struct FFStream {
211 enum StreamType stream_type;
212 char filename[1024]; /* stream filename */
213 struct FFStream *feed; /* feed we are using (can be null if
215 AVDictionary *in_opts; /* input parameters */
216 AVInputFormat *ifmt; /* if non NULL, force input format */
219 char dynamic_acl[1024];
221 int prebuffer; /* Number of millseconds early to start */
222 int64_t max_time; /* Number of milliseconds to run */
224 AVStream *streams[MAX_STREAMS];
225 int feed_streams[MAX_STREAMS]; /* index of streams in the feed */
226 char feed_filename[1024]; /* file name of the feed storage, or
227 input file name for a stream */
232 pid_t pid; /* Of ffmpeg process */
233 time_t pid_start; /* Of ffmpeg process */
235 struct FFStream *next;
236 unsigned bandwidth; /* bandwidth, in kbits/s */
239 /* multicast specific */
241 struct in_addr multicast_ip;
242 int multicast_port; /* first port used for multicast */
244 int loop; /* if true, send the stream in loops (only meaningful if file) */
247 int feed_opened; /* true if someone is writing to the feed */
248 int is_feed; /* true if it is a feed */
249 int readonly; /* True if writing is prohibited to the file */
250 int truncate; /* True if feeder connection truncate the feed file */
252 int64_t bytes_served;
253 int64_t feed_max_size; /* maximum storage size, zero means unlimited */
254 int64_t feed_write_index; /* current write position in feed (it wraps around) */
255 int64_t feed_size; /* current size of feed */
256 struct FFStream *next_feed;
259 typedef struct FeedData {
260 long long data_count;
261 float avg_frame_size; /* frame size averaged over last frames with exponential mean */
264 static struct sockaddr_in my_http_addr;
265 static struct sockaddr_in my_rtsp_addr;
267 static char logfilename[1024];
268 static HTTPContext *first_http_ctx;
269 static FFStream *first_feed; /* contains only feeds */
270 static FFStream *first_stream; /* contains all streams, including feeds */
272 static void new_connection(int server_fd, int is_rtsp);
273 static void close_connection(HTTPContext *c);
276 static int handle_connection(HTTPContext *c);
277 static int http_parse_request(HTTPContext *c);
278 static int http_send_data(HTTPContext *c);
279 static void compute_status(HTTPContext *c);
280 static int open_input_stream(HTTPContext *c, const char *info);
281 static int http_start_receive_data(HTTPContext *c);
282 static int http_receive_data(HTTPContext *c);
285 static int rtsp_parse_request(HTTPContext *c);
286 static void rtsp_cmd_describe(HTTPContext *c, const char *url);
287 static void rtsp_cmd_options(HTTPContext *c, const char *url);
288 static void rtsp_cmd_setup(HTTPContext *c, const char *url, RTSPMessageHeader *h);
289 static void rtsp_cmd_play(HTTPContext *c, const char *url, RTSPMessageHeader *h);
290 static void rtsp_cmd_pause(HTTPContext *c, const char *url, RTSPMessageHeader *h);
291 static void rtsp_cmd_teardown(HTTPContext *c, const char *url, RTSPMessageHeader *h);
294 static int prepare_sdp_description(FFStream *stream, uint8_t **pbuffer,
295 struct in_addr my_ip);
298 static HTTPContext *rtp_new_connection(struct sockaddr_in *from_addr,
299 FFStream *stream, const char *session_id,
300 enum RTSPLowerTransport rtp_protocol);
301 static int rtp_new_av_stream(HTTPContext *c,
302 int stream_index, struct sockaddr_in *dest_addr,
303 HTTPContext *rtsp_c);
305 static const char *my_program_name;
306 static const char *my_program_dir;
308 static const char *config_filename = "/etc/ffserver.conf";
310 static int ffserver_debug;
311 static int ffserver_daemon;
312 static int no_launch;
313 static int need_to_start_children;
315 /* maximum number of simultaneous HTTP connections */
316 static unsigned int nb_max_http_connections = 2000;
317 static unsigned int nb_max_connections = 5;
318 static unsigned int nb_connections;
320 static uint64_t max_bandwidth = 1000;
321 static uint64_t current_bandwidth;
323 static int64_t cur_time; // Making this global saves on passing it around everywhere
325 static AVLFG random_state;
327 static FILE *logfile = NULL;
329 /* FIXME: make ffserver work with IPv6 */
330 void av_noreturn exit_program(int ret)
335 /* resolve host with also IP address parsing */
336 static int resolve_host(struct in_addr *sin_addr, const char *hostname)
339 if (!ff_inet_aton(hostname, sin_addr)) {
341 struct addrinfo *ai, *cur;
342 struct addrinfo hints;
343 memset(&hints, 0, sizeof(hints));
344 hints.ai_family = AF_INET;
345 if (getaddrinfo(hostname, NULL, &hints, &ai))
347 /* getaddrinfo returns a linked list of addrinfo structs.
348 * Even if we set ai_family = AF_INET above, make sure
349 * that the returned one actually is of the correct type. */
350 for (cur = ai; cur; cur = cur->ai_next) {
351 if (cur->ai_family == AF_INET) {
352 *sin_addr = ((struct sockaddr_in *)cur->ai_addr)->sin_addr;
361 hp = gethostbyname(hostname);
364 memcpy(sin_addr, hp->h_addr_list[0], sizeof(struct in_addr));
370 static char *ctime1(char *buf2)
378 p = buf2 + strlen(p) - 1;
384 static void http_vlog(const char *fmt, va_list vargs)
386 static int print_prefix = 1;
391 fprintf(logfile, "%s ", buf);
393 print_prefix = strstr(fmt, "\n") != NULL;
394 vfprintf(logfile, fmt, vargs);
400 __attribute__ ((format (printf, 1, 2)))
402 static void http_log(const char *fmt, ...)
405 va_start(vargs, fmt);
406 http_vlog(fmt, vargs);
410 static void http_av_log(void *ptr, int level, const char *fmt, va_list vargs)
412 static int print_prefix = 1;
413 AVClass *avc = ptr ? *(AVClass**)ptr : NULL;
414 if (level > av_log_get_level())
416 if (print_prefix && avc)
417 http_log("[%s @ %p]", avc->item_name(ptr), ptr);
418 print_prefix = strstr(fmt, "\n") != NULL;
419 http_vlog(fmt, vargs);
422 static void log_connection(HTTPContext *c)
427 http_log("%s - - [%s] \"%s %s\" %d %"PRId64"\n",
428 inet_ntoa(c->from_addr.sin_addr), c->method, c->url,
429 c->protocol, (c->http_error ? c->http_error : 200), c->data_count);
432 static void update_datarate(DataRateData *drd, int64_t count)
434 if (!drd->time1 && !drd->count1) {
435 drd->time1 = drd->time2 = cur_time;
436 drd->count1 = drd->count2 = count;
437 } else if (cur_time - drd->time2 > 5000) {
438 drd->time1 = drd->time2;
439 drd->count1 = drd->count2;
440 drd->time2 = cur_time;
445 /* In bytes per second */
446 static int compute_datarate(DataRateData *drd, int64_t count)
448 if (cur_time == drd->time1)
451 return ((count - drd->count1) * 1000) / (cur_time - drd->time1);
455 static void start_children(FFStream *feed)
460 for (; feed; feed = feed->next) {
461 if (feed->child_argv && !feed->pid) {
462 feed->pid_start = time(0);
467 http_log("Unable to create children\n");
476 av_strlcpy(pathname, my_program_name, sizeof(pathname));
478 slash = strrchr(pathname, '/');
483 strcpy(slash, "ffmpeg");
485 http_log("Launch command line: ");
486 http_log("%s ", pathname);
487 for (i = 1; feed->child_argv[i] && feed->child_argv[i][0]; i++)
488 http_log("%s ", feed->child_argv[i]);
491 for (i = 3; i < 256; i++)
494 if (!ffserver_debug) {
495 i = open("/dev/null", O_RDWR);
504 /* This is needed to make relative pathnames work */
505 if (chdir(my_program_dir) < 0) {
506 http_log("chdir failed\n");
510 signal(SIGPIPE, SIG_DFL);
512 execvp(pathname, feed->child_argv);
520 /* open a listening socket */
521 static int socket_open_listen(struct sockaddr_in *my_addr)
525 server_fd = socket(AF_INET,SOCK_STREAM,0);
532 setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &tmp, sizeof(tmp));
534 my_addr->sin_family = AF_INET;
535 if (bind (server_fd, (struct sockaddr *) my_addr, sizeof (*my_addr)) < 0) {
537 snprintf(bindmsg, sizeof(bindmsg), "bind(port %d)", ntohs(my_addr->sin_port));
539 closesocket(server_fd);
543 if (listen (server_fd, 5) < 0) {
545 closesocket(server_fd);
548 ff_socket_nonblock(server_fd, 1);
553 /* start all multicast streams */
554 static void start_multicast(void)
559 struct sockaddr_in dest_addr;
560 int default_port, stream_index;
563 for(stream = first_stream; stream != NULL; stream = stream->next) {
564 if (stream->is_multicast) {
565 /* open the RTP connection */
566 snprintf(session_id, sizeof(session_id), "%08x%08x",
567 av_lfg_get(&random_state), av_lfg_get(&random_state));
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);
2164 s->flags |= AVFMT_FLAG_GENPTS;
2166 if (strcmp(s->iformat->name, "ffm") && avformat_find_stream_info(c->fmt_in, NULL) < 0) {
2167 http_log("Could not find stream info '%s'\n", input_filename);
2168 avformat_close_input(&s);
2172 /* choose stream as clock source (we favorize video stream if
2173 present) for packet sending */
2174 c->pts_stream_index = 0;
2175 for(i=0;i<c->stream->nb_streams;i++) {
2176 if (c->pts_stream_index == 0 &&
2177 c->stream->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2178 c->pts_stream_index = i;
2182 if (c->fmt_in->iformat->read_seek)
2183 av_seek_frame(c->fmt_in, -1, stream_pos, 0);
2184 /* set the start time (needed for maxtime and RTP packet timing) */
2185 c->start_time = cur_time;
2186 c->first_pts = AV_NOPTS_VALUE;
2190 /* return the server clock (in us) */
2191 static int64_t get_server_clock(HTTPContext *c)
2193 /* compute current pts value from system time */
2194 return (cur_time - c->start_time) * 1000;
2197 /* return the estimated time at which the current packet must be sent
2199 static int64_t get_packet_send_clock(HTTPContext *c)
2201 int bytes_left, bytes_sent, frame_bytes;
2203 frame_bytes = c->cur_frame_bytes;
2204 if (frame_bytes <= 0)
2207 bytes_left = c->buffer_end - c->buffer_ptr;
2208 bytes_sent = frame_bytes - bytes_left;
2209 return c->cur_pts + (c->cur_frame_duration * bytes_sent) / frame_bytes;
2214 static int http_prepare_data(HTTPContext *c)
2217 AVFormatContext *ctx;
2219 av_freep(&c->pb_buffer);
2221 case HTTPSTATE_SEND_DATA_HEADER:
2222 memset(&c->fmt_ctx, 0, sizeof(c->fmt_ctx));
2223 av_dict_set(&c->fmt_ctx.metadata, "author" , c->stream->author , 0);
2224 av_dict_set(&c->fmt_ctx.metadata, "comment" , c->stream->comment , 0);
2225 av_dict_set(&c->fmt_ctx.metadata, "copyright", c->stream->copyright, 0);
2226 av_dict_set(&c->fmt_ctx.metadata, "title" , c->stream->title , 0);
2228 c->fmt_ctx.streams = av_mallocz(sizeof(AVStream *) * c->stream->nb_streams);
2230 for(i=0;i<c->stream->nb_streams;i++) {
2232 c->fmt_ctx.streams[i] = av_mallocz(sizeof(AVStream));
2233 /* if file or feed, then just take streams from FFStream struct */
2234 if (!c->stream->feed ||
2235 c->stream->feed == c->stream)
2236 src = c->stream->streams[i];
2238 src = c->stream->feed->streams[c->stream->feed_streams[i]];
2240 *(c->fmt_ctx.streams[i]) = *src;
2241 c->fmt_ctx.streams[i]->priv_data = 0;
2242 c->fmt_ctx.streams[i]->codec->frame_number = 0; /* XXX: should be done in
2243 AVStream, not in codec */
2245 /* set output format parameters */
2246 c->fmt_ctx.oformat = c->stream->fmt;
2247 c->fmt_ctx.nb_streams = c->stream->nb_streams;
2249 c->got_key_frame = 0;
2251 /* prepare header and save header data in a stream */
2252 if (avio_open_dyn_buf(&c->fmt_ctx.pb) < 0) {
2253 /* XXX: potential leak */
2256 c->fmt_ctx.pb->seekable = 0;
2259 * HACK to avoid mpeg ps muxer to spit many underflow errors
2260 * Default value from FFmpeg
2261 * Try to set it use configuration option
2263 c->fmt_ctx.max_delay = (int)(0.7*AV_TIME_BASE);
2265 if (avformat_write_header(&c->fmt_ctx, NULL) < 0) {
2266 http_log("Error writing output header\n");
2269 av_dict_free(&c->fmt_ctx.metadata);
2271 len = avio_close_dyn_buf(c->fmt_ctx.pb, &c->pb_buffer);
2272 c->buffer_ptr = c->pb_buffer;
2273 c->buffer_end = c->pb_buffer + len;
2275 c->state = HTTPSTATE_SEND_DATA;
2276 c->last_packet_sent = 0;
2278 case HTTPSTATE_SEND_DATA:
2279 /* find a new packet */
2280 /* read a packet from the input stream */
2281 if (c->stream->feed)
2282 ffm_set_write_index(c->fmt_in,
2283 c->stream->feed->feed_write_index,
2284 c->stream->feed->feed_size);
2286 if (c->stream->max_time &&
2287 c->stream->max_time + c->start_time - cur_time < 0)
2288 /* We have timed out */
2289 c->state = HTTPSTATE_SEND_DATA_TRAILER;
2293 ret = av_read_frame(c->fmt_in, &pkt);
2295 if (c->stream->feed) {
2296 /* if coming from feed, it means we reached the end of the
2297 ffm file, so must wait for more data */
2298 c->state = HTTPSTATE_WAIT_FEED;
2299 return 1; /* state changed */
2300 } else if (ret == AVERROR(EAGAIN)) {
2301 /* input not ready, come back later */
2304 if (c->stream->loop) {
2305 avformat_close_input(&c->fmt_in);
2306 if (open_input_stream(c, "") < 0)
2311 /* must send trailer now because eof or error */
2312 c->state = HTTPSTATE_SEND_DATA_TRAILER;
2316 int source_index = pkt.stream_index;
2317 /* update first pts if needed */
2318 if (c->first_pts == AV_NOPTS_VALUE) {
2319 c->first_pts = av_rescale_q(pkt.dts, c->fmt_in->streams[pkt.stream_index]->time_base, AV_TIME_BASE_Q);
2320 c->start_time = cur_time;
2322 /* send it to the appropriate stream */
2323 if (c->stream->feed) {
2324 /* if coming from a feed, select the right stream */
2325 if (c->switch_pending) {
2326 c->switch_pending = 0;
2327 for(i=0;i<c->stream->nb_streams;i++) {
2328 if (c->switch_feed_streams[i] == pkt.stream_index)
2329 if (pkt.flags & AV_PKT_FLAG_KEY)
2330 c->switch_feed_streams[i] = -1;
2331 if (c->switch_feed_streams[i] >= 0)
2332 c->switch_pending = 1;
2335 for(i=0;i<c->stream->nb_streams;i++) {
2336 if (c->stream->feed_streams[i] == pkt.stream_index) {
2337 AVStream *st = c->fmt_in->streams[source_index];
2338 pkt.stream_index = i;
2339 if (pkt.flags & AV_PKT_FLAG_KEY &&
2340 (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2341 c->stream->nb_streams == 1))
2342 c->got_key_frame = 1;
2343 if (!c->stream->send_on_key || c->got_key_frame)
2348 AVCodecContext *codec;
2349 AVStream *ist, *ost;
2351 ist = c->fmt_in->streams[source_index];
2352 /* specific handling for RTP: we use several
2353 output stream (one for each RTP
2354 connection). XXX: need more abstract handling */
2355 if (c->is_packetized) {
2356 /* compute send time and duration */
2357 c->cur_pts = av_rescale_q(pkt.dts, ist->time_base, AV_TIME_BASE_Q);
2358 c->cur_pts -= c->first_pts;
2359 c->cur_frame_duration = av_rescale_q(pkt.duration, ist->time_base, AV_TIME_BASE_Q);
2360 /* find RTP context */
2361 c->packet_stream_index = pkt.stream_index;
2362 ctx = c->rtp_ctx[c->packet_stream_index];
2364 av_free_packet(&pkt);
2367 codec = ctx->streams[0]->codec;
2368 /* only one stream per RTP connection */
2369 pkt.stream_index = 0;
2373 codec = ctx->streams[pkt.stream_index]->codec;
2376 if (c->is_packetized) {
2377 int max_packet_size;
2378 if (c->rtp_protocol == RTSP_LOWER_TRANSPORT_TCP)
2379 max_packet_size = RTSP_TCP_MAX_PACKET_SIZE;
2381 max_packet_size = c->rtp_handles[c->packet_stream_index]->max_packet_size;
2382 ret = ffio_open_dyn_packet_buf(&ctx->pb, max_packet_size);
2384 ret = avio_open_dyn_buf(&ctx->pb);
2387 /* XXX: potential leak */
2390 ost = ctx->streams[pkt.stream_index];
2392 ctx->pb->seekable = 0;
2393 if (pkt.dts != AV_NOPTS_VALUE)
2394 pkt.dts = av_rescale_q(pkt.dts, ist->time_base, ost->time_base);
2395 if (pkt.pts != AV_NOPTS_VALUE)
2396 pkt.pts = av_rescale_q(pkt.pts, ist->time_base, ost->time_base);
2397 pkt.duration = av_rescale_q(pkt.duration, ist->time_base, ost->time_base);
2398 if (av_write_frame(ctx, &pkt) < 0) {
2399 http_log("Error writing frame to output\n");
2400 c->state = HTTPSTATE_SEND_DATA_TRAILER;
2403 len = avio_close_dyn_buf(ctx->pb, &c->pb_buffer);
2404 c->cur_frame_bytes = len;
2405 c->buffer_ptr = c->pb_buffer;
2406 c->buffer_end = c->pb_buffer + len;
2408 codec->frame_number++;
2410 av_free_packet(&pkt);
2414 av_free_packet(&pkt);
2419 case HTTPSTATE_SEND_DATA_TRAILER:
2420 /* last packet test ? */
2421 if (c->last_packet_sent || c->is_packetized)
2424 /* prepare header */
2425 if (avio_open_dyn_buf(&ctx->pb) < 0) {
2426 /* XXX: potential leak */
2429 c->fmt_ctx.pb->seekable = 0;
2430 av_write_trailer(ctx);
2431 len = avio_close_dyn_buf(ctx->pb, &c->pb_buffer);
2432 c->buffer_ptr = c->pb_buffer;
2433 c->buffer_end = c->pb_buffer + len;
2435 c->last_packet_sent = 1;
2441 /* should convert the format at the same time */
2442 /* send data starting at c->buffer_ptr to the output connection
2443 (either UDP or TCP connection) */
2444 static int http_send_data(HTTPContext *c)
2449 if (c->buffer_ptr >= c->buffer_end) {
2450 ret = http_prepare_data(c);
2454 /* state change requested */
2457 if (c->is_packetized) {
2458 /* RTP data output */
2459 len = c->buffer_end - c->buffer_ptr;
2461 /* fail safe - should never happen */
2463 c->buffer_ptr = c->buffer_end;
2466 len = (c->buffer_ptr[0] << 24) |
2467 (c->buffer_ptr[1] << 16) |
2468 (c->buffer_ptr[2] << 8) |
2470 if (len > (c->buffer_end - c->buffer_ptr))
2472 if ((get_packet_send_clock(c) - get_server_clock(c)) > 0) {
2473 /* nothing to send yet: we can wait */
2477 c->data_count += len;
2478 update_datarate(&c->datarate, c->data_count);
2480 c->stream->bytes_served += len;
2482 if (c->rtp_protocol == RTSP_LOWER_TRANSPORT_TCP) {
2483 /* RTP packets are sent inside the RTSP TCP connection */
2485 int interleaved_index, size;
2487 HTTPContext *rtsp_c;
2490 /* if no RTSP connection left, error */
2493 /* if already sending something, then wait. */
2494 if (rtsp_c->state != RTSPSTATE_WAIT_REQUEST)
2496 if (avio_open_dyn_buf(&pb) < 0)
2498 interleaved_index = c->packet_stream_index * 2;
2499 /* RTCP packets are sent at odd indexes */
2500 if (c->buffer_ptr[1] == 200)
2501 interleaved_index++;
2502 /* write RTSP TCP header */
2504 header[1] = interleaved_index;
2505 header[2] = len >> 8;
2507 avio_write(pb, header, 4);
2508 /* write RTP packet data */
2510 avio_write(pb, c->buffer_ptr, len);
2511 size = avio_close_dyn_buf(pb, &c->packet_buffer);
2512 /* prepare asynchronous TCP sending */
2513 rtsp_c->packet_buffer_ptr = c->packet_buffer;
2514 rtsp_c->packet_buffer_end = c->packet_buffer + size;
2515 c->buffer_ptr += len;
2517 /* send everything we can NOW */
2518 len = send(rtsp_c->fd, rtsp_c->packet_buffer_ptr,
2519 rtsp_c->packet_buffer_end - rtsp_c->packet_buffer_ptr, 0);
2521 rtsp_c->packet_buffer_ptr += len;
2522 if (rtsp_c->packet_buffer_ptr < rtsp_c->packet_buffer_end) {
2523 /* if we could not send all the data, we will
2524 send it later, so a new state is needed to
2525 "lock" the RTSP TCP connection */
2526 rtsp_c->state = RTSPSTATE_SEND_PACKET;
2529 /* all data has been sent */
2530 av_freep(&c->packet_buffer);
2532 /* send RTP packet directly in UDP */
2534 ffurl_write(c->rtp_handles[c->packet_stream_index],
2535 c->buffer_ptr, len);
2536 c->buffer_ptr += len;
2537 /* here we continue as we can send several packets per 10 ms slot */
2540 /* TCP data output */
2541 len = send(c->fd, c->buffer_ptr, c->buffer_end - c->buffer_ptr, 0);
2543 if (ff_neterrno() != AVERROR(EAGAIN) &&
2544 ff_neterrno() != AVERROR(EINTR))
2545 /* error : close connection */
2550 c->buffer_ptr += len;
2552 c->data_count += len;
2553 update_datarate(&c->datarate, c->data_count);
2555 c->stream->bytes_served += len;
2563 static int http_start_receive_data(HTTPContext *c)
2567 if (c->stream->feed_opened)
2570 /* Don't permit writing to this one */
2571 if (c->stream->readonly)
2575 fd = open(c->stream->feed_filename, O_RDWR);
2577 http_log("Error opening feeder file: %s\n", strerror(errno));
2582 if (c->stream->truncate) {
2583 /* truncate feed file */
2584 ffm_write_write_index(c->feed_fd, FFM_PACKET_SIZE);
2585 ftruncate(c->feed_fd, FFM_PACKET_SIZE);
2586 http_log("Truncating feed file '%s'\n", c->stream->feed_filename);
2588 if ((c->stream->feed_write_index = ffm_read_write_index(fd)) < 0) {
2589 http_log("Error reading write index from feed file: %s\n", strerror(errno));
2594 c->stream->feed_write_index = FFMAX(ffm_read_write_index(fd), FFM_PACKET_SIZE);
2595 c->stream->feed_size = lseek(fd, 0, SEEK_END);
2596 lseek(fd, 0, SEEK_SET);
2598 /* init buffer input */
2599 c->buffer_ptr = c->buffer;
2600 c->buffer_end = c->buffer + FFM_PACKET_SIZE;
2601 c->stream->feed_opened = 1;
2602 c->chunked_encoding = !!av_stristr(c->buffer, "Transfer-Encoding: chunked");
2606 static int http_receive_data(HTTPContext *c)
2609 int len, loop_run = 0;
2611 while (c->chunked_encoding && !c->chunk_size &&
2612 c->buffer_end > c->buffer_ptr) {
2613 /* read chunk header, if present */
2614 len = recv(c->fd, c->buffer_ptr, 1, 0);
2617 if (ff_neterrno() != AVERROR(EAGAIN) &&
2618 ff_neterrno() != AVERROR(EINTR))
2619 /* error : close connection */
2622 } else if (len == 0) {
2623 /* end of connection : close it */
2625 } else if (c->buffer_ptr - c->buffer >= 2 &&
2626 !memcmp(c->buffer_ptr - 1, "\r\n", 2)) {
2627 c->chunk_size = strtol(c->buffer, 0, 16);
2628 if (c->chunk_size == 0) // end of stream
2630 c->buffer_ptr = c->buffer;
2632 } else if (++loop_run > 10) {
2633 /* no chunk header, abort */
2640 if (c->buffer_end > c->buffer_ptr) {
2641 len = recv(c->fd, c->buffer_ptr,
2642 FFMIN(c->chunk_size, c->buffer_end - c->buffer_ptr), 0);
2644 if (ff_neterrno() != AVERROR(EAGAIN) &&
2645 ff_neterrno() != AVERROR(EINTR))
2646 /* error : close connection */
2648 } else if (len == 0)
2649 /* end of connection : close it */
2652 c->chunk_size -= len;
2653 c->buffer_ptr += len;
2654 c->data_count += len;
2655 update_datarate(&c->datarate, c->data_count);
2659 if (c->buffer_ptr - c->buffer >= 2 && c->data_count > FFM_PACKET_SIZE) {
2660 if (c->buffer[0] != 'f' ||
2661 c->buffer[1] != 'm') {
2662 http_log("Feed stream has become desynchronized -- disconnecting\n");
2667 if (c->buffer_ptr >= c->buffer_end) {
2668 FFStream *feed = c->stream;
2669 /* a packet has been received : write it in the store, except
2671 if (c->data_count > FFM_PACKET_SIZE) {
2673 // printf("writing pos=0x%"PRIx64" size=0x%"PRIx64"\n", feed->feed_write_index, feed->feed_size);
2674 /* XXX: use llseek or url_seek */
2675 lseek(c->feed_fd, feed->feed_write_index, SEEK_SET);
2676 if (write(c->feed_fd, c->buffer, FFM_PACKET_SIZE) < 0) {
2677 http_log("Error writing to feed file: %s\n", strerror(errno));
2681 feed->feed_write_index += FFM_PACKET_SIZE;
2682 /* update file size */
2683 if (feed->feed_write_index > c->stream->feed_size)
2684 feed->feed_size = feed->feed_write_index;
2686 /* handle wrap around if max file size reached */
2687 if (c->stream->feed_max_size && feed->feed_write_index >= c->stream->feed_max_size)
2688 feed->feed_write_index = FFM_PACKET_SIZE;
2691 if (ffm_write_write_index(c->feed_fd, feed->feed_write_index) < 0) {
2692 http_log("Error writing index to feed file: %s\n", strerror(errno));
2696 /* wake up any waiting connections */
2697 for(c1 = first_http_ctx; c1 != NULL; c1 = c1->next) {
2698 if (c1->state == HTTPSTATE_WAIT_FEED &&
2699 c1->stream->feed == c->stream->feed)
2700 c1->state = HTTPSTATE_SEND_DATA;
2703 /* We have a header in our hands that contains useful data */
2704 AVFormatContext *s = avformat_alloc_context();
2706 AVInputFormat *fmt_in;
2712 /* use feed output format name to find corresponding input format */
2713 fmt_in = av_find_input_format(feed->fmt->name);
2717 pb = avio_alloc_context(c->buffer, c->buffer_end - c->buffer,
2718 0, NULL, NULL, NULL, NULL);
2722 if (avformat_open_input(&s, c->stream->feed_filename, fmt_in, NULL) < 0) {
2727 /* Now we have the actual streams */
2728 if (s->nb_streams != feed->nb_streams) {
2729 avformat_close_input(&s);
2731 http_log("Feed '%s' stream number does not match registered feed\n",
2732 c->stream->feed_filename);
2736 for (i = 0; i < s->nb_streams; i++) {
2737 AVStream *fst = feed->streams[i];
2738 AVStream *st = s->streams[i];
2739 avcodec_copy_context(fst->codec, st->codec);
2742 avformat_close_input(&s);
2745 c->buffer_ptr = c->buffer;
2750 c->stream->feed_opened = 0;
2752 /* wake up any waiting connections to stop waiting for feed */
2753 for(c1 = first_http_ctx; c1 != NULL; c1 = c1->next) {
2754 if (c1->state == HTTPSTATE_WAIT_FEED &&
2755 c1->stream->feed == c->stream->feed)
2756 c1->state = HTTPSTATE_SEND_DATA_TRAILER;
2761 /********************************************************************/
2764 static void rtsp_reply_header(HTTPContext *c, enum RTSPStatusCode error_number)
2771 switch(error_number) {
2772 case RTSP_STATUS_OK:
2775 case RTSP_STATUS_METHOD:
2776 str = "Method Not Allowed";
2778 case RTSP_STATUS_BANDWIDTH:
2779 str = "Not Enough Bandwidth";
2781 case RTSP_STATUS_SESSION:
2782 str = "Session Not Found";
2784 case RTSP_STATUS_STATE:
2785 str = "Method Not Valid in This State";
2787 case RTSP_STATUS_AGGREGATE:
2788 str = "Aggregate operation not allowed";
2790 case RTSP_STATUS_ONLY_AGGREGATE:
2791 str = "Only aggregate operation allowed";
2793 case RTSP_STATUS_TRANSPORT:
2794 str = "Unsupported transport";
2796 case RTSP_STATUS_INTERNAL:
2797 str = "Internal Server Error";
2799 case RTSP_STATUS_SERVICE:
2800 str = "Service Unavailable";
2802 case RTSP_STATUS_VERSION:
2803 str = "RTSP Version not supported";
2806 str = "Unknown Error";
2810 avio_printf(c->pb, "RTSP/1.0 %d %s\r\n", error_number, str);
2811 avio_printf(c->pb, "CSeq: %d\r\n", c->seq);
2813 /* output GMT time */
2816 strftime(buf2, sizeof(buf2), "%a, %d %b %Y %H:%M:%S", tm);
2817 avio_printf(c->pb, "Date: %s GMT\r\n", buf2);
2820 static void rtsp_reply_error(HTTPContext *c, enum RTSPStatusCode error_number)
2822 rtsp_reply_header(c, error_number);
2823 avio_printf(c->pb, "\r\n");
2826 static int rtsp_parse_request(HTTPContext *c)
2828 const char *p, *p1, *p2;
2834 RTSPMessageHeader header1, *header = &header1;
2836 c->buffer_ptr[0] = '\0';
2839 get_word(cmd, sizeof(cmd), &p);
2840 get_word(url, sizeof(url), &p);
2841 get_word(protocol, sizeof(protocol), &p);
2843 av_strlcpy(c->method, cmd, sizeof(c->method));
2844 av_strlcpy(c->url, url, sizeof(c->url));
2845 av_strlcpy(c->protocol, protocol, sizeof(c->protocol));
2847 if (avio_open_dyn_buf(&c->pb) < 0) {
2848 /* XXX: cannot do more */
2849 c->pb = NULL; /* safety */
2853 /* check version name */
2854 if (strcmp(protocol, "RTSP/1.0") != 0) {
2855 rtsp_reply_error(c, RTSP_STATUS_VERSION);
2859 /* parse each header line */
2860 memset(header, 0, sizeof(*header));
2861 /* skip to next line */
2862 while (*p != '\n' && *p != '\0')
2866 while (*p != '\0') {
2867 p1 = memchr(p, '\n', (char *)c->buffer_ptr - p);
2871 if (p2 > p && p2[-1] == '\r')
2873 /* skip empty line */
2877 if (len > sizeof(line) - 1)
2878 len = sizeof(line) - 1;
2879 memcpy(line, p, len);
2881 ff_rtsp_parse_line(header, line, NULL, NULL);
2885 /* handle sequence number */
2886 c->seq = header->seq;
2888 if (!strcmp(cmd, "DESCRIBE"))
2889 rtsp_cmd_describe(c, url);
2890 else if (!strcmp(cmd, "OPTIONS"))
2891 rtsp_cmd_options(c, url);
2892 else if (!strcmp(cmd, "SETUP"))
2893 rtsp_cmd_setup(c, url, header);
2894 else if (!strcmp(cmd, "PLAY"))
2895 rtsp_cmd_play(c, url, header);
2896 else if (!strcmp(cmd, "PAUSE"))
2897 rtsp_cmd_pause(c, url, header);
2898 else if (!strcmp(cmd, "TEARDOWN"))
2899 rtsp_cmd_teardown(c, url, header);
2901 rtsp_reply_error(c, RTSP_STATUS_METHOD);
2904 len = avio_close_dyn_buf(c->pb, &c->pb_buffer);
2905 c->pb = NULL; /* safety */
2907 /* XXX: cannot do more */
2910 c->buffer_ptr = c->pb_buffer;
2911 c->buffer_end = c->pb_buffer + len;
2912 c->state = RTSPSTATE_SEND_REPLY;
2916 static int prepare_sdp_description(FFStream *stream, uint8_t **pbuffer,
2917 struct in_addr my_ip)
2919 AVFormatContext *avc;
2920 AVStream *avs = NULL;
2923 avc = avformat_alloc_context();
2927 av_dict_set(&avc->metadata, "title",
2928 stream->title[0] ? stream->title : "No Title", 0);
2929 avc->nb_streams = stream->nb_streams;
2930 if (stream->is_multicast) {
2931 snprintf(avc->filename, 1024, "rtp://%s:%d?multicast=1?ttl=%d",
2932 inet_ntoa(stream->multicast_ip),
2933 stream->multicast_port, stream->multicast_ttl);
2935 snprintf(avc->filename, 1024, "rtp://0.0.0.0");
2938 if (avc->nb_streams >= INT_MAX/sizeof(*avc->streams) ||
2939 !(avc->streams = av_malloc(avc->nb_streams * sizeof(*avc->streams))))
2941 if (avc->nb_streams >= INT_MAX/sizeof(*avs) ||
2942 !(avs = av_malloc(avc->nb_streams * sizeof(*avs))))
2945 for(i = 0; i < stream->nb_streams; i++) {
2946 avc->streams[i] = &avs[i];
2947 avc->streams[i]->codec = stream->streams[i]->codec;
2949 *pbuffer = av_mallocz(2048);
2950 av_sdp_create(&avc, 1, *pbuffer, 2048);
2953 av_free(avc->streams);
2954 av_dict_free(&avc->metadata);
2958 return strlen(*pbuffer);
2961 static void rtsp_cmd_options(HTTPContext *c, const char *url)
2963 // rtsp_reply_header(c, RTSP_STATUS_OK);
2964 avio_printf(c->pb, "RTSP/1.0 %d %s\r\n", RTSP_STATUS_OK, "OK");
2965 avio_printf(c->pb, "CSeq: %d\r\n", c->seq);
2966 avio_printf(c->pb, "Public: %s\r\n", "OPTIONS, DESCRIBE, SETUP, TEARDOWN, PLAY, PAUSE");
2967 avio_printf(c->pb, "\r\n");
2970 static void rtsp_cmd_describe(HTTPContext *c, const char *url)
2976 int content_length, len;
2977 struct sockaddr_in my_addr;
2979 /* find which url is asked */
2980 av_url_split(NULL, 0, NULL, 0, NULL, 0, NULL, path1, sizeof(path1), url);
2985 for(stream = first_stream; stream != NULL; stream = stream->next) {
2986 if (!stream->is_feed &&
2987 stream->fmt && !strcmp(stream->fmt->name, "rtp") &&
2988 !strcmp(path, stream->filename)) {
2992 /* no stream found */
2993 rtsp_reply_error(c, RTSP_STATUS_SERVICE); /* XXX: right error ? */
2997 /* prepare the media description in sdp format */
2999 /* get the host IP */
3000 len = sizeof(my_addr);
3001 getsockname(c->fd, (struct sockaddr *)&my_addr, &len);
3002 content_length = prepare_sdp_description(stream, &content, my_addr.sin_addr);
3003 if (content_length < 0) {
3004 rtsp_reply_error(c, RTSP_STATUS_INTERNAL);
3007 rtsp_reply_header(c, RTSP_STATUS_OK);
3008 avio_printf(c->pb, "Content-Base: %s/\r\n", url);
3009 avio_printf(c->pb, "Content-Type: application/sdp\r\n");
3010 avio_printf(c->pb, "Content-Length: %d\r\n", content_length);
3011 avio_printf(c->pb, "\r\n");
3012 avio_write(c->pb, content, content_length);
3016 static HTTPContext *find_rtp_session(const char *session_id)
3020 if (session_id[0] == '\0')
3023 for(c = first_http_ctx; c != NULL; c = c->next) {
3024 if (!strcmp(c->session_id, session_id))
3030 static RTSPTransportField *find_transport(RTSPMessageHeader *h, enum RTSPLowerTransport lower_transport)
3032 RTSPTransportField *th;
3035 for(i=0;i<h->nb_transports;i++) {
3036 th = &h->transports[i];
3037 if (th->lower_transport == lower_transport)
3043 static void rtsp_cmd_setup(HTTPContext *c, const char *url,
3044 RTSPMessageHeader *h)
3047 int stream_index, rtp_port, rtcp_port;
3052 RTSPTransportField *th;
3053 struct sockaddr_in dest_addr;
3054 RTSPActionServerSetup setup;
3056 /* find which url is asked */
3057 av_url_split(NULL, 0, NULL, 0, NULL, 0, NULL, path1, sizeof(path1), url);
3062 /* now check each stream */
3063 for(stream = first_stream; stream != NULL; stream = stream->next) {
3064 if (!stream->is_feed &&
3065 stream->fmt && !strcmp(stream->fmt->name, "rtp")) {
3066 /* accept aggregate filenames only if single stream */
3067 if (!strcmp(path, stream->filename)) {
3068 if (stream->nb_streams != 1) {
3069 rtsp_reply_error(c, RTSP_STATUS_AGGREGATE);
3076 for(stream_index = 0; stream_index < stream->nb_streams;
3078 snprintf(buf, sizeof(buf), "%s/streamid=%d",
3079 stream->filename, stream_index);
3080 if (!strcmp(path, buf))
3085 /* no stream found */
3086 rtsp_reply_error(c, RTSP_STATUS_SERVICE); /* XXX: right error ? */
3090 /* generate session id if needed */
3091 if (h->session_id[0] == '\0')
3092 snprintf(h->session_id, sizeof(h->session_id), "%08x%08x",
3093 av_lfg_get(&random_state), av_lfg_get(&random_state));
3095 /* find rtp session, and create it if none found */
3096 rtp_c = find_rtp_session(h->session_id);
3098 /* always prefer UDP */
3099 th = find_transport(h, RTSP_LOWER_TRANSPORT_UDP);
3101 th = find_transport(h, RTSP_LOWER_TRANSPORT_TCP);
3103 rtsp_reply_error(c, RTSP_STATUS_TRANSPORT);
3108 rtp_c = rtp_new_connection(&c->from_addr, stream, h->session_id,
3109 th->lower_transport);
3111 rtsp_reply_error(c, RTSP_STATUS_BANDWIDTH);
3115 /* open input stream */
3116 if (open_input_stream(rtp_c, "") < 0) {
3117 rtsp_reply_error(c, RTSP_STATUS_INTERNAL);
3122 /* test if stream is OK (test needed because several SETUP needs
3123 to be done for a given file) */
3124 if (rtp_c->stream != stream) {
3125 rtsp_reply_error(c, RTSP_STATUS_SERVICE);
3129 /* test if stream is already set up */
3130 if (rtp_c->rtp_ctx[stream_index]) {
3131 rtsp_reply_error(c, RTSP_STATUS_STATE);
3135 /* check transport */
3136 th = find_transport(h, rtp_c->rtp_protocol);
3137 if (!th || (th->lower_transport == RTSP_LOWER_TRANSPORT_UDP &&
3138 th->client_port_min <= 0)) {
3139 rtsp_reply_error(c, RTSP_STATUS_TRANSPORT);
3143 /* setup default options */
3144 setup.transport_option[0] = '\0';
3145 dest_addr = rtp_c->from_addr;
3146 dest_addr.sin_port = htons(th->client_port_min);
3149 if (rtp_new_av_stream(rtp_c, stream_index, &dest_addr, c) < 0) {
3150 rtsp_reply_error(c, RTSP_STATUS_TRANSPORT);
3154 /* now everything is OK, so we can send the connection parameters */
3155 rtsp_reply_header(c, RTSP_STATUS_OK);
3157 avio_printf(c->pb, "Session: %s\r\n", rtp_c->session_id);
3159 switch(rtp_c->rtp_protocol) {
3160 case RTSP_LOWER_TRANSPORT_UDP:
3161 rtp_port = ff_rtp_get_local_rtp_port(rtp_c->rtp_handles[stream_index]);
3162 rtcp_port = ff_rtp_get_local_rtcp_port(rtp_c->rtp_handles[stream_index]);
3163 avio_printf(c->pb, "Transport: RTP/AVP/UDP;unicast;"
3164 "client_port=%d-%d;server_port=%d-%d",
3165 th->client_port_min, th->client_port_max,
3166 rtp_port, rtcp_port);
3168 case RTSP_LOWER_TRANSPORT_TCP:
3169 avio_printf(c->pb, "Transport: RTP/AVP/TCP;interleaved=%d-%d",
3170 stream_index * 2, stream_index * 2 + 1);
3175 if (setup.transport_option[0] != '\0')
3176 avio_printf(c->pb, ";%s", setup.transport_option);
3177 avio_printf(c->pb, "\r\n");
3180 avio_printf(c->pb, "\r\n");
3184 /* find an rtp connection by using the session ID. Check consistency
3186 static HTTPContext *find_rtp_session_with_url(const char *url,
3187 const char *session_id)
3195 rtp_c = find_rtp_session(session_id);
3199 /* find which url is asked */
3200 av_url_split(NULL, 0, NULL, 0, NULL, 0, NULL, path1, sizeof(path1), url);
3204 if(!strcmp(path, rtp_c->stream->filename)) return rtp_c;
3205 for(s=0; s<rtp_c->stream->nb_streams; ++s) {
3206 snprintf(buf, sizeof(buf), "%s/streamid=%d",
3207 rtp_c->stream->filename, s);
3208 if(!strncmp(path, buf, sizeof(buf))) {
3209 // XXX: Should we reply with RTSP_STATUS_ONLY_AGGREGATE if nb_streams>1?
3214 if (len > 0 && path[len - 1] == '/' &&
3215 !strncmp(path, rtp_c->stream->filename, len - 1))
3220 static void rtsp_cmd_play(HTTPContext *c, const char *url, RTSPMessageHeader *h)
3224 rtp_c = find_rtp_session_with_url(url, h->session_id);
3226 rtsp_reply_error(c, RTSP_STATUS_SESSION);
3230 if (rtp_c->state != HTTPSTATE_SEND_DATA &&
3231 rtp_c->state != HTTPSTATE_WAIT_FEED &&
3232 rtp_c->state != HTTPSTATE_READY) {
3233 rtsp_reply_error(c, RTSP_STATUS_STATE);
3237 rtp_c->state = HTTPSTATE_SEND_DATA;
3239 /* now everything is OK, so we can send the connection parameters */
3240 rtsp_reply_header(c, RTSP_STATUS_OK);
3242 avio_printf(c->pb, "Session: %s\r\n", rtp_c->session_id);
3243 avio_printf(c->pb, "\r\n");
3246 static void rtsp_cmd_pause(HTTPContext *c, const char *url, RTSPMessageHeader *h)
3250 rtp_c = find_rtp_session_with_url(url, h->session_id);
3252 rtsp_reply_error(c, RTSP_STATUS_SESSION);
3256 if (rtp_c->state != HTTPSTATE_SEND_DATA &&
3257 rtp_c->state != HTTPSTATE_WAIT_FEED) {
3258 rtsp_reply_error(c, RTSP_STATUS_STATE);
3262 rtp_c->state = HTTPSTATE_READY;
3263 rtp_c->first_pts = AV_NOPTS_VALUE;
3264 /* now everything is OK, so we can send the connection parameters */
3265 rtsp_reply_header(c, RTSP_STATUS_OK);
3267 avio_printf(c->pb, "Session: %s\r\n", rtp_c->session_id);
3268 avio_printf(c->pb, "\r\n");
3271 static void rtsp_cmd_teardown(HTTPContext *c, const char *url, RTSPMessageHeader *h)
3275 rtp_c = find_rtp_session_with_url(url, h->session_id);
3277 rtsp_reply_error(c, RTSP_STATUS_SESSION);
3281 /* now everything is OK, so we can send the connection parameters */
3282 rtsp_reply_header(c, RTSP_STATUS_OK);
3284 avio_printf(c->pb, "Session: %s\r\n", rtp_c->session_id);
3285 avio_printf(c->pb, "\r\n");
3287 /* abort the session */
3288 close_connection(rtp_c);
3292 /********************************************************************/
3295 static HTTPContext *rtp_new_connection(struct sockaddr_in *from_addr,
3296 FFStream *stream, const char *session_id,
3297 enum RTSPLowerTransport rtp_protocol)
3299 HTTPContext *c = NULL;
3300 const char *proto_str;
3302 /* XXX: should output a warning page when coming
3303 close to the connection limit */
3304 if (nb_connections >= nb_max_connections)
3307 /* add a new connection */
3308 c = av_mallocz(sizeof(HTTPContext));
3313 c->poll_entry = NULL;
3314 c->from_addr = *from_addr;
3315 c->buffer_size = IOBUFFER_INIT_SIZE;
3316 c->buffer = av_malloc(c->buffer_size);
3321 av_strlcpy(c->session_id, session_id, sizeof(c->session_id));
3322 c->state = HTTPSTATE_READY;
3323 c->is_packetized = 1;
3324 c->rtp_protocol = rtp_protocol;
3326 /* protocol is shown in statistics */
3327 switch(c->rtp_protocol) {
3328 case RTSP_LOWER_TRANSPORT_UDP_MULTICAST:
3329 proto_str = "MCAST";
3331 case RTSP_LOWER_TRANSPORT_UDP:
3334 case RTSP_LOWER_TRANSPORT_TCP:
3341 av_strlcpy(c->protocol, "RTP/", sizeof(c->protocol));
3342 av_strlcat(c->protocol, proto_str, sizeof(c->protocol));
3344 current_bandwidth += stream->bandwidth;
3346 c->next = first_http_ctx;
3358 /* add a new RTP stream in an RTP connection (used in RTSP SETUP
3359 command). If RTP/TCP protocol is used, TCP connection 'rtsp_c' is
3361 static int rtp_new_av_stream(HTTPContext *c,
3362 int stream_index, struct sockaddr_in *dest_addr,
3363 HTTPContext *rtsp_c)
3365 AVFormatContext *ctx;
3368 URLContext *h = NULL;
3370 int max_packet_size;
3372 /* now we can open the relevant output stream */
3373 ctx = avformat_alloc_context();
3376 ctx->oformat = av_guess_format("rtp", NULL, NULL);
3378 st = av_mallocz(sizeof(AVStream));
3381 ctx->nb_streams = 1;
3382 ctx->streams = av_mallocz(sizeof(AVStream *) * ctx->nb_streams);
3385 ctx->streams[0] = st;
3387 if (!c->stream->feed ||
3388 c->stream->feed == c->stream)
3389 memcpy(st, c->stream->streams[stream_index], sizeof(AVStream));
3392 c->stream->feed->streams[c->stream->feed_streams[stream_index]],
3394 st->priv_data = NULL;
3396 /* build destination RTP address */
3397 ipaddr = inet_ntoa(dest_addr->sin_addr);
3399 switch(c->rtp_protocol) {
3400 case RTSP_LOWER_TRANSPORT_UDP:
3401 case RTSP_LOWER_TRANSPORT_UDP_MULTICAST:
3404 /* XXX: also pass as parameter to function ? */
3405 if (c->stream->is_multicast) {
3407 ttl = c->stream->multicast_ttl;
3410 snprintf(ctx->filename, sizeof(ctx->filename),
3411 "rtp://%s:%d?multicast=1&ttl=%d",
3412 ipaddr, ntohs(dest_addr->sin_port), ttl);
3414 snprintf(ctx->filename, sizeof(ctx->filename),
3415 "rtp://%s:%d", ipaddr, ntohs(dest_addr->sin_port));
3418 if (ffurl_open(&h, ctx->filename, AVIO_FLAG_WRITE, NULL, NULL) < 0)
3420 c->rtp_handles[stream_index] = h;
3421 max_packet_size = h->max_packet_size;
3423 case RTSP_LOWER_TRANSPORT_TCP:
3426 max_packet_size = RTSP_TCP_MAX_PACKET_SIZE;
3432 http_log("%s:%d - - \"PLAY %s/streamid=%d %s\"\n",
3433 ipaddr, ntohs(dest_addr->sin_port),
3434 c->stream->filename, stream_index, c->protocol);
3436 /* normally, no packets should be output here, but the packet size may be checked */
3437 if (ffio_open_dyn_packet_buf(&ctx->pb, max_packet_size) < 0) {
3438 /* XXX: close stream */
3441 if (avformat_write_header(ctx, NULL) < 0) {
3448 avio_close_dyn_buf(ctx->pb, &dummy_buf);
3451 c->rtp_ctx[stream_index] = ctx;
3455 /********************************************************************/
3456 /* ffserver initialization */
3458 static AVStream *add_av_stream1(FFStream *stream, AVCodecContext *codec, int copy)
3462 fst = av_mallocz(sizeof(AVStream));
3466 fst->codec = avcodec_alloc_context3(NULL);
3467 memcpy(fst->codec, codec, sizeof(AVCodecContext));
3468 if (codec->extradata_size) {
3469 fst->codec->extradata = av_malloc(codec->extradata_size);
3470 memcpy(fst->codec->extradata, codec->extradata,
3471 codec->extradata_size);
3474 /* live streams must use the actual feed's codec since it may be
3475 * updated later to carry extradata needed by the streams.
3479 fst->priv_data = av_mallocz(sizeof(FeedData));
3480 fst->index = stream->nb_streams;
3481 avpriv_set_pts_info(fst, 33, 1, 90000);
3482 fst->sample_aspect_ratio = codec->sample_aspect_ratio;
3483 stream->streams[stream->nb_streams++] = fst;
3487 /* return the stream number in the feed */
3488 static int add_av_stream(FFStream *feed, AVStream *st)
3491 AVCodecContext *av, *av1;
3495 for(i=0;i<feed->nb_streams;i++) {
3496 st = feed->streams[i];
3498 if (av1->codec_id == av->codec_id &&
3499 av1->codec_type == av->codec_type &&
3500 av1->bit_rate == av->bit_rate) {
3502 switch(av->codec_type) {
3503 case AVMEDIA_TYPE_AUDIO:
3504 if (av1->channels == av->channels &&
3505 av1->sample_rate == av->sample_rate)
3508 case AVMEDIA_TYPE_VIDEO:
3509 if (av1->width == av->width &&
3510 av1->height == av->height &&
3511 av1->time_base.den == av->time_base.den &&
3512 av1->time_base.num == av->time_base.num &&
3513 av1->gop_size == av->gop_size)
3522 fst = add_av_stream1(feed, av, 0);
3525 return feed->nb_streams - 1;
3528 static void remove_stream(FFStream *stream)
3532 while (*ps != NULL) {
3540 /* specific mpeg4 handling : we extract the raw parameters */
3541 static void extract_mpeg4_header(AVFormatContext *infile)
3543 int mpeg4_count, i, size;
3549 for(i=0;i<infile->nb_streams;i++) {
3550 st = infile->streams[i];
3551 if (st->codec->codec_id == CODEC_ID_MPEG4 &&
3552 st->codec->extradata_size == 0) {
3559 printf("MPEG4 without extra data: trying to find header in %s\n", infile->filename);
3560 while (mpeg4_count > 0) {
3561 if (av_read_packet(infile, &pkt) < 0)
3563 st = infile->streams[pkt.stream_index];
3564 if (st->codec->codec_id == CODEC_ID_MPEG4 &&
3565 st->codec->extradata_size == 0) {
3566 av_freep(&st->codec->extradata);
3567 /* fill extradata with the header */
3568 /* XXX: we make hard suppositions here ! */
3570 while (p < pkt.data + pkt.size - 4) {
3571 /* stop when vop header is found */
3572 if (p[0] == 0x00 && p[1] == 0x00 &&
3573 p[2] == 0x01 && p[3] == 0xb6) {
3574 size = p - pkt.data;
3575 // av_hex_dump_log(infile, AV_LOG_DEBUG, pkt.data, size);
3576 st->codec->extradata = av_malloc(size);
3577 st->codec->extradata_size = size;
3578 memcpy(st->codec->extradata, pkt.data, size);
3585 av_free_packet(&pkt);
3589 /* compute the needed AVStream for each file */
3590 static void build_file_streams(void)
3592 FFStream *stream, *stream_next;
3595 /* gather all streams */
3596 for(stream = first_stream; stream != NULL; stream = stream_next) {
3597 AVFormatContext *infile = NULL;
3598 stream_next = stream->next;
3599 if (stream->stream_type == STREAM_TYPE_LIVE &&
3601 /* the stream comes from a file */
3602 /* try to open the file */
3604 if (stream->fmt && !strcmp(stream->fmt->name, "rtp")) {
3605 /* specific case : if transport stream output to RTP,
3606 we use a raw transport stream reader */
3607 av_dict_set(&stream->in_opts, "mpeg2ts_compute_pcr", "1", 0);
3610 http_log("Opening file '%s'\n", stream->feed_filename);
3611 if ((ret = avformat_open_input(&infile, stream->feed_filename, stream->ifmt, &stream->in_opts)) < 0) {
3612 http_log("Could not open '%s': %d\n", stream->feed_filename, ret);
3613 /* remove stream (no need to spend more time on it) */
3615 remove_stream(stream);
3617 /* find all the AVStreams inside and reference them in
3619 if (avformat_find_stream_info(infile, NULL) < 0) {
3620 http_log("Could not find codec parameters from '%s'\n",
3621 stream->feed_filename);
3622 avformat_close_input(&infile);
3625 extract_mpeg4_header(infile);
3627 for(i=0;i<infile->nb_streams;i++)
3628 add_av_stream1(stream, infile->streams[i]->codec, 1);
3630 avformat_close_input(&infile);
3636 /* compute the needed AVStream for each feed */
3637 static void build_feed_streams(void)
3639 FFStream *stream, *feed;
3642 /* gather all streams */
3643 for(stream = first_stream; stream != NULL; stream = stream->next) {
3644 feed = stream->feed;
3646 if (stream->is_feed) {
3647 for(i=0;i<stream->nb_streams;i++)
3648 stream->feed_streams[i] = i;
3650 /* we handle a stream coming from a feed */
3651 for(i=0;i<stream->nb_streams;i++)
3652 stream->feed_streams[i] = add_av_stream(feed, stream->streams[i]);
3657 /* create feed files if needed */
3658 for(feed = first_feed; feed != NULL; feed = feed->next_feed) {
3661 if (avio_check(feed->feed_filename, AVIO_FLAG_READ) > 0) {
3662 /* See if it matches */
3663 AVFormatContext *s = NULL;
3666 if (avformat_open_input(&s, feed->feed_filename, NULL, NULL) >= 0) {
3667 /* Now see if it matches */
3668 if (s->nb_streams == feed->nb_streams) {
3670 for(i=0;i<s->nb_streams;i++) {
3672 sf = feed->streams[i];
3675 if (sf->index != ss->index ||
3677 http_log("Index & Id do not match for stream %d (%s)\n",
3678 i, feed->feed_filename);
3681 AVCodecContext *ccf, *ccs;
3685 #define CHECK_CODEC(x) (ccf->x != ccs->x)
3687 if (CHECK_CODEC(codec_id) || CHECK_CODEC(codec_type)) {
3688 http_log("Codecs do not match for stream %d\n", i);
3690 } else if (CHECK_CODEC(bit_rate) || CHECK_CODEC(flags)) {
3691 http_log("Codec bitrates do not match for stream %d\n", i);
3693 } else if (ccf->codec_type == AVMEDIA_TYPE_VIDEO) {
3694 if (CHECK_CODEC(time_base.den) ||
3695 CHECK_CODEC(time_base.num) ||
3696 CHECK_CODEC(width) ||
3697 CHECK_CODEC(height)) {
3698 http_log("Codec width, height and framerate do not match for stream %d\n", i);
3701 } else if (ccf->codec_type == AVMEDIA_TYPE_AUDIO) {
3702 if (CHECK_CODEC(sample_rate) ||
3703 CHECK_CODEC(channels) ||
3704 CHECK_CODEC(frame_size)) {
3705 http_log("Codec sample_rate, channels, frame_size do not match for stream %d\n", i);
3709 http_log("Unknown codec type\n");
3717 http_log("Deleting feed file '%s' as stream counts differ (%d != %d)\n",
3718 feed->feed_filename, s->nb_streams, feed->nb_streams);
3720 avformat_close_input(&s);
3722 http_log("Deleting feed file '%s' as it appears to be corrupt\n",
3723 feed->feed_filename);
3726 if (feed->readonly) {
3727 http_log("Unable to delete feed file '%s' as it is marked readonly\n",
3728 feed->feed_filename);
3731 unlink(feed->feed_filename);
3734 if (avio_check(feed->feed_filename, AVIO_FLAG_WRITE) <= 0) {
3735 AVFormatContext s1 = {0}, *s = &s1;
3737 if (feed->readonly) {
3738 http_log("Unable to create feed file '%s' as it is marked readonly\n",
3739 feed->feed_filename);
3743 /* only write the header of the ffm file */
3744 if (avio_open(&s->pb, feed->feed_filename, AVIO_FLAG_WRITE) < 0) {
3745 http_log("Could not open output feed file '%s'\n",
3746 feed->feed_filename);
3749 s->oformat = feed->fmt;
3750 s->nb_streams = feed->nb_streams;
3751 s->streams = feed->streams;
3752 if (avformat_write_header(s, NULL) < 0) {
3753 http_log("Container doesn't supports the required parameters\n");
3756 /* XXX: need better api */
3757 av_freep(&s->priv_data);
3760 /* get feed size and write index */
3761 fd = open(feed->feed_filename, O_RDONLY);
3763 http_log("Could not open output feed file '%s'\n",
3764 feed->feed_filename);
3768 feed->feed_write_index = FFMAX(ffm_read_write_index(fd), FFM_PACKET_SIZE);
3769 feed->feed_size = lseek(fd, 0, SEEK_END);
3770 /* ensure that we do not wrap before the end of file */
3771 if (feed->feed_max_size && feed->feed_max_size < feed->feed_size)
3772 feed->feed_max_size = feed->feed_size;
3778 /* compute the bandwidth used by each stream */
3779 static void compute_bandwidth(void)
3785 for(stream = first_stream; stream != NULL; stream = stream->next) {
3787 for(i=0;i<stream->nb_streams;i++) {
3788 AVStream *st = stream->streams[i];
3789 switch(st->codec->codec_type) {
3790 case AVMEDIA_TYPE_AUDIO:
3791 case AVMEDIA_TYPE_VIDEO:
3792 bandwidth += st->codec->bit_rate;
3798 stream->bandwidth = (bandwidth + 999) / 1000;
3802 /* add a codec and set the default parameters */
3803 static void add_codec(FFStream *stream, AVCodecContext *av)
3807 /* compute default parameters */
3808 switch(av->codec_type) {
3809 case AVMEDIA_TYPE_AUDIO:
3810 if (av->bit_rate == 0)
3811 av->bit_rate = 64000;
3812 if (av->sample_rate == 0)
3813 av->sample_rate = 22050;
3814 if (av->channels == 0)
3817 case AVMEDIA_TYPE_VIDEO:
3818 if (av->bit_rate == 0)
3819 av->bit_rate = 64000;
3820 if (av->time_base.num == 0){
3821 av->time_base.den = 5;
3822 av->time_base.num = 1;
3824 if (av->width == 0 || av->height == 0) {
3828 /* Bitrate tolerance is less for streaming */
3829 if (av->bit_rate_tolerance == 0)
3830 av->bit_rate_tolerance = FFMAX(av->bit_rate / 4,
3831 (int64_t)av->bit_rate*av->time_base.num/av->time_base.den);
3836 if (av->max_qdiff == 0)
3838 av->qcompress = 0.5;
3841 if (!av->nsse_weight)
3842 av->nsse_weight = 8;
3844 av->frame_skip_cmp = FF_CMP_DCTMAX;
3846 av->me_method = ME_EPZS;
3847 av->rc_buffer_aggressivity = 1.0;
3850 av->rc_eq = "tex^qComp";
3851 if (!av->i_quant_factor)
3852 av->i_quant_factor = -0.8;
3853 if (!av->b_quant_factor)
3854 av->b_quant_factor = 1.25;
3855 if (!av->b_quant_offset)
3856 av->b_quant_offset = 1.25;
3857 if (!av->rc_max_rate)
3858 av->rc_max_rate = av->bit_rate * 2;
3860 if (av->rc_max_rate && !av->rc_buffer_size) {
3861 av->rc_buffer_size = av->rc_max_rate;
3870 st = av_mallocz(sizeof(AVStream));
3873 st->codec = avcodec_alloc_context3(NULL);
3874 stream->streams[stream->nb_streams++] = st;
3875 memcpy(st->codec, av, sizeof(AVCodecContext));
3878 static enum CodecID opt_audio_codec(const char *arg)
3880 AVCodec *p= avcodec_find_encoder_by_name(arg);
3882 if (p == NULL || p->type != AVMEDIA_TYPE_AUDIO)
3883 return CODEC_ID_NONE;
3888 static enum CodecID opt_video_codec(const char *arg)
3890 AVCodec *p= avcodec_find_encoder_by_name(arg);
3892 if (p == NULL || p->type != AVMEDIA_TYPE_VIDEO)
3893 return CODEC_ID_NONE;
3898 /* simplistic plugin support */
3901 static void load_module(const char *filename)
3904 void (*init_func)(void);
3905 dll = dlopen(filename, RTLD_NOW);
3907 fprintf(stderr, "Could not load module '%s' - %s\n",
3908 filename, dlerror());
3912 init_func = dlsym(dll, "ffserver_module_init");
3915 "%s: init function 'ffserver_module_init()' not found\n",
3924 static int ffserver_opt_default(const char *opt, const char *arg,
3925 AVCodecContext *avctx, int type)
3928 const AVOption *o = av_opt_find(avctx, opt, NULL, type, 0);
3930 ret = av_opt_set(avctx, opt, arg, 0);
3934 static int ffserver_opt_preset(const char *arg,
3935 AVCodecContext *avctx, int type,
3936 enum CodecID *audio_id, enum CodecID *video_id)
3939 char filename[1000], tmp[1000], tmp2[1000], line[1000];
3941 AVCodec *codec = avcodec_find_encoder(avctx->codec_id);
3943 if (!(f = get_preset_file(filename, sizeof(filename), arg, 0,
3944 codec ? codec->name : NULL))) {
3945 fprintf(stderr, "File for preset '%s' not found\n", arg);
3950 int e= fscanf(f, "%999[^\n]\n", line) - 1;
3951 if(line[0] == '#' && !e)
3953 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
3955 fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
3959 if(!strcmp(tmp, "acodec")){
3960 *audio_id = opt_audio_codec(tmp2);
3961 }else if(!strcmp(tmp, "vcodec")){
3962 *video_id = opt_video_codec(tmp2);
3963 }else if(!strcmp(tmp, "scodec")){
3964 /* opt_subtitle_codec(tmp2); */
3965 }else if(ffserver_opt_default(tmp, tmp2, avctx, type) < 0){
3966 fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
3977 static AVOutputFormat *ffserver_guess_format(const char *short_name, const char *filename,
3978 const char *mime_type)
3980 AVOutputFormat *fmt = av_guess_format(short_name, filename, mime_type);
3983 AVOutputFormat *stream_fmt;
3984 char stream_format_name[64];
3986 snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
3987 stream_fmt = av_guess_format(stream_format_name, NULL, NULL);
3996 static void report_config_error(const char *filename, int line_num, int *errors, const char *fmt, ...)
4000 fprintf(stderr, "%s:%d: ", filename, line_num);
4001 vfprintf(stderr, fmt, vl);
4007 static int parse_ffconfig(const char *filename)
4014 int val, errors, line_num;
4015 FFStream **last_stream, *stream, *redirect;
4016 FFStream **last_feed, *feed, *s;
4017 AVCodecContext audio_enc, video_enc;
4018 enum CodecID audio_id, video_id;
4020 f = fopen(filename, "r");
4028 first_stream = NULL;
4029 last_stream = &first_stream;
4031 last_feed = &first_feed;
4035 audio_id = CODEC_ID_NONE;
4036 video_id = CODEC_ID_NONE;
4038 #define ERROR(...) report_config_error(filename, line_num, &errors, __VA_ARGS__)
4040 if (fgets(line, sizeof(line), f) == NULL)
4046 if (*p == '\0' || *p == '#')
4049 get_arg(cmd, sizeof(cmd), &p);
4051 if (!av_strcasecmp(cmd, "Port")) {
4052 get_arg(arg, sizeof(arg), &p);
4054 if (val < 1 || val > 65536) {
4055 ERROR("Invalid_port: %s\n", arg);
4057 my_http_addr.sin_port = htons(val);
4058 } else if (!av_strcasecmp(cmd, "BindAddress")) {
4059 get_arg(arg, sizeof(arg), &p);
4060 if (resolve_host(&my_http_addr.sin_addr, arg) != 0) {
4061 ERROR("%s:%d: Invalid host/IP address: %s\n", arg);
4063 } else if (!av_strcasecmp(cmd, "NoDaemon")) {
4064 ffserver_daemon = 0;
4065 } else if (!av_strcasecmp(cmd, "RTSPPort")) {
4066 get_arg(arg, sizeof(arg), &p);
4068 if (val < 1 || val > 65536) {
4069 ERROR("%s:%d: Invalid port: %s\n", arg);
4071 my_rtsp_addr.sin_port = htons(atoi(arg));
4072 } else if (!av_strcasecmp(cmd, "RTSPBindAddress")) {
4073 get_arg(arg, sizeof(arg), &p);
4074 if (resolve_host(&my_rtsp_addr.sin_addr, arg) != 0) {
4075 ERROR("Invalid host/IP address: %s\n", arg);
4077 } else if (!av_strcasecmp(cmd, "MaxHTTPConnections")) {
4078 get_arg(arg, sizeof(arg), &p);
4080 if (val < 1 || val > 65536) {
4081 ERROR("Invalid MaxHTTPConnections: %s\n", arg);
4083 nb_max_http_connections = val;
4084 } else if (!av_strcasecmp(cmd, "MaxClients")) {
4085 get_arg(arg, sizeof(arg), &p);
4087 if (val < 1 || val > nb_max_http_connections) {
4088 ERROR("Invalid MaxClients: %s\n", arg);
4090 nb_max_connections = val;
4092 } else if (!av_strcasecmp(cmd, "MaxBandwidth")) {
4094 get_arg(arg, sizeof(arg), &p);
4096 if (llval < 10 || llval > 10000000) {
4097 ERROR("Invalid MaxBandwidth: %s\n", arg);
4099 max_bandwidth = llval;
4100 } else if (!av_strcasecmp(cmd, "CustomLog")) {
4101 if (!ffserver_debug)
4102 get_arg(logfilename, sizeof(logfilename), &p);
4103 } else if (!av_strcasecmp(cmd, "<Feed")) {
4104 /*********************************************/
4105 /* Feed related options */
4107 if (stream || feed) {
4108 ERROR("Already in a tag\n");
4110 feed = av_mallocz(sizeof(FFStream));
4111 get_arg(feed->filename, sizeof(feed->filename), &p);
4112 q = strrchr(feed->filename, '>');
4116 for (s = first_feed; s; s = s->next) {
4117 if (!strcmp(feed->filename, s->filename)) {
4118 ERROR("Feed '%s' already registered\n", s->filename);
4122 feed->fmt = av_guess_format("ffm", NULL, NULL);
4123 /* defaut feed file */
4124 snprintf(feed->feed_filename, sizeof(feed->feed_filename),
4125 "/tmp/%s.ffm", feed->filename);
4126 feed->feed_max_size = 5 * 1024 * 1024;
4128 feed->feed = feed; /* self feeding :-) */
4130 /* add in stream list */
4131 *last_stream = feed;
4132 last_stream = &feed->next;
4133 /* add in feed list */
4135 last_feed = &feed->next_feed;
4137 } else if (!av_strcasecmp(cmd, "Launch")) {
4141 feed->child_argv = av_mallocz(64 * sizeof(char *));
4143 for (i = 0; i < 62; i++) {
4144 get_arg(arg, sizeof(arg), &p);
4148 feed->child_argv[i] = av_strdup(arg);
4151 feed->child_argv[i] = av_malloc(30 + strlen(feed->filename));
4153 snprintf(feed->child_argv[i], 30+strlen(feed->filename),
4155 (my_http_addr.sin_addr.s_addr == INADDR_ANY) ? "127.0.0.1" :
4156 inet_ntoa(my_http_addr.sin_addr),
4157 ntohs(my_http_addr.sin_port), feed->filename);
4159 } else if (!av_strcasecmp(cmd, "ReadOnlyFile")) {
4161 get_arg(feed->feed_filename, sizeof(feed->feed_filename), &p);
4163 } else if (stream) {
4164 get_arg(stream->feed_filename, sizeof(stream->feed_filename), &p);
4166 } else if (!av_strcasecmp(cmd, "File")) {
4168 get_arg(feed->feed_filename, sizeof(feed->feed_filename), &p);
4170 get_arg(stream->feed_filename, sizeof(stream->feed_filename), &p);
4171 } else if (!av_strcasecmp(cmd, "Truncate")) {
4173 get_arg(arg, sizeof(arg), &p);
4174 feed->truncate = strtod(arg, NULL);
4176 } else if (!av_strcasecmp(cmd, "FileMaxSize")) {
4181 get_arg(arg, sizeof(arg), &p);
4183 fsize = strtod(p1, &p1);
4184 switch(toupper(*p1)) {
4189 fsize *= 1024 * 1024;
4192 fsize *= 1024 * 1024 * 1024;
4195 feed->feed_max_size = (int64_t)fsize;
4196 if (feed->feed_max_size < FFM_PACKET_SIZE*4) {
4197 ERROR("Feed max file size is too small, must be at least %d\n", FFM_PACKET_SIZE*4);
4200 } else if (!av_strcasecmp(cmd, "</Feed>")) {
4202 ERROR("No corresponding <Feed> for </Feed>\n");
4205 } else if (!av_strcasecmp(cmd, "<Stream")) {
4206 /*********************************************/
4207 /* Stream related options */
4209 if (stream || feed) {
4210 ERROR("Already in a tag\n");
4213 stream = av_mallocz(sizeof(FFStream));
4214 get_arg(stream->filename, sizeof(stream->filename), &p);
4215 q = strrchr(stream->filename, '>');
4219 for (s = first_stream; s; s = s->next) {
4220 if (!strcmp(stream->filename, s->filename)) {
4221 ERROR("Stream '%s' already registered\n", s->filename);
4225 stream->fmt = ffserver_guess_format(NULL, stream->filename, NULL);
4226 avcodec_get_context_defaults3(&video_enc, NULL);
4227 avcodec_get_context_defaults3(&audio_enc, NULL);
4229 audio_id = CODEC_ID_NONE;
4230 video_id = CODEC_ID_NONE;
4232 audio_id = stream->fmt->audio_codec;
4233 video_id = stream->fmt->video_codec;
4236 *last_stream = stream;
4237 last_stream = &stream->next;
4239 } else if (!av_strcasecmp(cmd, "Feed")) {
4240 get_arg(arg, sizeof(arg), &p);
4245 while (sfeed != NULL) {
4246 if (!strcmp(sfeed->filename, arg))
4248 sfeed = sfeed->next_feed;
4251 ERROR("feed '%s' not defined\n", arg);
4253 stream->feed = sfeed;
4255 } else if (!av_strcasecmp(cmd, "Format")) {
4256 get_arg(arg, sizeof(arg), &p);
4258 if (!strcmp(arg, "status")) {
4259 stream->stream_type = STREAM_TYPE_STATUS;
4262 stream->stream_type = STREAM_TYPE_LIVE;
4263 /* jpeg cannot be used here, so use single frame jpeg */
4264 if (!strcmp(arg, "jpeg"))
4265 strcpy(arg, "mjpeg");
4266 stream->fmt = ffserver_guess_format(arg, NULL, NULL);
4268 ERROR("Unknown Format: %s\n", arg);
4272 audio_id = stream->fmt->audio_codec;
4273 video_id = stream->fmt->video_codec;
4276 } else if (!av_strcasecmp(cmd, "InputFormat")) {
4277 get_arg(arg, sizeof(arg), &p);
4279 stream->ifmt = av_find_input_format(arg);
4280 if (!stream->ifmt) {
4281 ERROR("Unknown input format: %s\n", arg);
4284 } else if (!av_strcasecmp(cmd, "FaviconURL")) {
4285 if (stream && stream->stream_type == STREAM_TYPE_STATUS) {
4286 get_arg(stream->feed_filename, sizeof(stream->feed_filename), &p);
4288 ERROR("FaviconURL only permitted for status streams\n");
4290 } else if (!av_strcasecmp(cmd, "Author")) {
4292 get_arg(stream->author, sizeof(stream->author), &p);
4293 } else if (!av_strcasecmp(cmd, "Comment")) {
4295 get_arg(stream->comment, sizeof(stream->comment), &p);
4296 } else if (!av_strcasecmp(cmd, "Copyright")) {
4298 get_arg(stream->copyright, sizeof(stream->copyright), &p);
4299 } else if (!av_strcasecmp(cmd, "Title")) {
4301 get_arg(stream->title, sizeof(stream->title), &p);
4302 } else if (!av_strcasecmp(cmd, "Preroll")) {
4303 get_arg(arg, sizeof(arg), &p);
4305 stream->prebuffer = atof(arg) * 1000;
4306 } else if (!av_strcasecmp(cmd, "StartSendOnKey")) {
4308 stream->send_on_key = 1;
4309 } else if (!av_strcasecmp(cmd, "AudioCodec")) {
4310 get_arg(arg, sizeof(arg), &p);
4311 audio_id = opt_audio_codec(arg);
4312 if (audio_id == CODEC_ID_NONE) {
4313 ERROR("Unknown AudioCodec: %s\n", arg);
4315 } else if (!av_strcasecmp(cmd, "VideoCodec")) {
4316 get_arg(arg, sizeof(arg), &p);
4317 video_id = opt_video_codec(arg);
4318 if (video_id == CODEC_ID_NONE) {
4319 ERROR("Unknown VideoCodec: %s\n", arg);
4321 } else if (!av_strcasecmp(cmd, "MaxTime")) {
4322 get_arg(arg, sizeof(arg), &p);
4324 stream->max_time = atof(arg) * 1000;
4325 } else if (!av_strcasecmp(cmd, "AudioBitRate")) {
4326 get_arg(arg, sizeof(arg), &p);
4328 audio_enc.bit_rate = lrintf(atof(arg) * 1000);
4329 } else if (!av_strcasecmp(cmd, "AudioChannels")) {
4330 get_arg(arg, sizeof(arg), &p);
4332 audio_enc.channels = atoi(arg);
4333 } else if (!av_strcasecmp(cmd, "AudioSampleRate")) {
4334 get_arg(arg, sizeof(arg), &p);
4336 audio_enc.sample_rate = atoi(arg);
4337 } else if (!av_strcasecmp(cmd, "AudioQuality")) {
4338 get_arg(arg, sizeof(arg), &p);
4340 // audio_enc.quality = atof(arg) * 1000;
4342 } else if (!av_strcasecmp(cmd, "VideoBitRateRange")) {
4344 int minrate, maxrate;
4346 get_arg(arg, sizeof(arg), &p);
4348 if (sscanf(arg, "%d-%d", &minrate, &maxrate) == 2) {
4349 video_enc.rc_min_rate = minrate * 1000;
4350 video_enc.rc_max_rate = maxrate * 1000;
4352 ERROR("Incorrect format for VideoBitRateRange -- should be <min>-<max>: %s\n", arg);
4355 } else if (!av_strcasecmp(cmd, "Debug")) {
4357 get_arg(arg, sizeof(arg), &p);
4358 video_enc.debug = strtol(arg,0,0);
4360 } else if (!av_strcasecmp(cmd, "Strict")) {
4362 get_arg(arg, sizeof(arg), &p);
4363 video_enc.strict_std_compliance = atoi(arg);
4365 } else if (!av_strcasecmp(cmd, "VideoBufferSize")) {
4367 get_arg(arg, sizeof(arg), &p);
4368 video_enc.rc_buffer_size = atoi(arg) * 8*1024;
4370 } else if (!av_strcasecmp(cmd, "VideoBitRateTolerance")) {
4372 get_arg(arg, sizeof(arg), &p);
4373 video_enc.bit_rate_tolerance = atoi(arg) * 1000;
4375 } else if (!av_strcasecmp(cmd, "VideoBitRate")) {
4376 get_arg(arg, sizeof(arg), &p);
4378 video_enc.bit_rate = atoi(arg) * 1000;
4380 } else if (!av_strcasecmp(cmd, "VideoSize")) {
4381 get_arg(arg, sizeof(arg), &p);
4383 av_parse_video_size(&video_enc.width, &video_enc.height, arg);
4384 if ((video_enc.width % 16) != 0 ||
4385 (video_enc.height % 16) != 0) {
4386 ERROR("Image size must be a multiple of 16\n");
4389 } else if (!av_strcasecmp(cmd, "VideoFrameRate")) {
4390 get_arg(arg, sizeof(arg), &p);
4392 AVRational frame_rate;
4393 if (av_parse_video_rate(&frame_rate, arg) < 0) {
4394 ERROR("Incorrect frame rate: %s\n", arg);
4396 video_enc.time_base.num = frame_rate.den;
4397 video_enc.time_base.den = frame_rate.num;
4400 } else if (!av_strcasecmp(cmd, "VideoGopSize")) {
4401 get_arg(arg, sizeof(arg), &p);
4403 video_enc.gop_size = atoi(arg);
4404 } else if (!av_strcasecmp(cmd, "VideoIntraOnly")) {
4406 video_enc.gop_size = 1;
4407 } else if (!av_strcasecmp(cmd, "VideoHighQuality")) {
4409 video_enc.mb_decision = FF_MB_DECISION_BITS;
4410 } else if (!av_strcasecmp(cmd, "Video4MotionVector")) {
4412 video_enc.mb_decision = FF_MB_DECISION_BITS; //FIXME remove
4413 video_enc.flags |= CODEC_FLAG_4MV;
4415 } else if (!av_strcasecmp(cmd, "AVOptionVideo") ||
4416 !av_strcasecmp(cmd, "AVOptionAudio")) {
4418 AVCodecContext *avctx;
4420 get_arg(arg, sizeof(arg), &p);
4421 get_arg(arg2, sizeof(arg2), &p);
4422 if (!av_strcasecmp(cmd, "AVOptionVideo")) {
4424 type = AV_OPT_FLAG_VIDEO_PARAM;
4427 type = AV_OPT_FLAG_AUDIO_PARAM;
4429 if (ffserver_opt_default(arg, arg2, avctx, type|AV_OPT_FLAG_ENCODING_PARAM)) {
4430 ERROR("AVOption error: %s %s\n", arg, arg2);
4432 } else if (!av_strcasecmp(cmd, "AVPresetVideo") ||
4433 !av_strcasecmp(cmd, "AVPresetAudio")) {
4434 AVCodecContext *avctx;
4436 get_arg(arg, sizeof(arg), &p);
4437 if (!av_strcasecmp(cmd, "AVPresetVideo")) {
4439 video_enc.codec_id = video_id;
4440 type = AV_OPT_FLAG_VIDEO_PARAM;
4443 audio_enc.codec_id = audio_id;
4444 type = AV_OPT_FLAG_AUDIO_PARAM;
4446 if (ffserver_opt_preset(arg, avctx, type|AV_OPT_FLAG_ENCODING_PARAM, &audio_id, &video_id)) {
4447 ERROR("AVPreset error: %s\n", arg);
4449 } else if (!av_strcasecmp(cmd, "VideoTag")) {
4450 get_arg(arg, sizeof(arg), &p);
4451 if ((strlen(arg) == 4) && stream)
4452 video_enc.codec_tag = MKTAG(arg[0], arg[1], arg[2], arg[3]);
4453 } else if (!av_strcasecmp(cmd, "BitExact")) {
4455 video_enc.flags |= CODEC_FLAG_BITEXACT;
4456 } else if (!av_strcasecmp(cmd, "DctFastint")) {
4458 video_enc.dct_algo = FF_DCT_FASTINT;
4459 } else if (!av_strcasecmp(cmd, "IdctSimple")) {
4461 video_enc.idct_algo = FF_IDCT_SIMPLE;
4462 } else if (!av_strcasecmp(cmd, "Qscale")) {
4463 get_arg(arg, sizeof(arg), &p);
4465 video_enc.flags |= CODEC_FLAG_QSCALE;
4466 video_enc.global_quality = FF_QP2LAMBDA * atoi(arg);
4468 } else if (!av_strcasecmp(cmd, "VideoQDiff")) {
4469 get_arg(arg, sizeof(arg), &p);
4471 video_enc.max_qdiff = atoi(arg);
4472 if (video_enc.max_qdiff < 1 || video_enc.max_qdiff > 31) {
4473 ERROR("VideoQDiff out of range\n");
4476 } else if (!av_strcasecmp(cmd, "VideoQMax")) {
4477 get_arg(arg, sizeof(arg), &p);
4479 video_enc.qmax = atoi(arg);
4480 if (video_enc.qmax < 1 || video_enc.qmax > 31) {
4481 ERROR("VideoQMax out of range\n");
4484 } else if (!av_strcasecmp(cmd, "VideoQMin")) {
4485 get_arg(arg, sizeof(arg), &p);
4487 video_enc.qmin = atoi(arg);
4488 if (video_enc.qmin < 1 || video_enc.qmin > 31) {
4489 ERROR("VideoQMin out of range\n");
4492 } else if (!av_strcasecmp(cmd, "LumaElim")) {
4493 get_arg(arg, sizeof(arg), &p);
4495 video_enc.luma_elim_threshold = atoi(arg);
4496 } else if (!av_strcasecmp(cmd, "ChromaElim")) {
4497 get_arg(arg, sizeof(arg), &p);
4499 video_enc.chroma_elim_threshold = atoi(arg);
4500 } else if (!av_strcasecmp(cmd, "LumiMask")) {
4501 get_arg(arg, sizeof(arg), &p);
4503 video_enc.lumi_masking = atof(arg);
4504 } else if (!av_strcasecmp(cmd, "DarkMask")) {
4505 get_arg(arg, sizeof(arg), &p);
4507 video_enc.dark_masking = atof(arg);
4508 } else if (!av_strcasecmp(cmd, "NoVideo")) {
4509 video_id = CODEC_ID_NONE;
4510 } else if (!av_strcasecmp(cmd, "NoAudio")) {
4511 audio_id = CODEC_ID_NONE;
4512 } else if (!av_strcasecmp(cmd, "ACL")) {
4513 parse_acl_row(stream, feed, NULL, p, filename, line_num);
4514 } else if (!av_strcasecmp(cmd, "DynamicACL")) {
4516 get_arg(stream->dynamic_acl, sizeof(stream->dynamic_acl), &p);
4518 } else if (!av_strcasecmp(cmd, "RTSPOption")) {
4519 get_arg(arg, sizeof(arg), &p);
4521 av_freep(&stream->rtsp_option);
4522 stream->rtsp_option = av_strdup(arg);
4524 } else if (!av_strcasecmp(cmd, "MulticastAddress")) {
4525 get_arg(arg, sizeof(arg), &p);
4527 if (resolve_host(&stream->multicast_ip, arg) != 0) {
4528 ERROR("Invalid host/IP address: %s\n", arg);
4530 stream->is_multicast = 1;
4531 stream->loop = 1; /* default is looping */
4533 } else if (!av_strcasecmp(cmd, "MulticastPort")) {
4534 get_arg(arg, sizeof(arg), &p);
4536 stream->multicast_port = atoi(arg);
4537 } else if (!av_strcasecmp(cmd, "MulticastTTL")) {
4538 get_arg(arg, sizeof(arg), &p);
4540 stream->multicast_ttl = atoi(arg);
4541 } else if (!av_strcasecmp(cmd, "NoLoop")) {
4544 } else if (!av_strcasecmp(cmd, "</Stream>")) {
4546 ERROR("No corresponding <Stream> for </Stream>\n");
4548 if (stream->feed && stream->fmt && strcmp(stream->fmt->name, "ffm") != 0) {
4549 if (audio_id != CODEC_ID_NONE) {
4550 audio_enc.codec_type = AVMEDIA_TYPE_AUDIO;
4551 audio_enc.codec_id = audio_id;
4552 add_codec(stream, &audio_enc);
4554 if (video_id != CODEC_ID_NONE) {
4555 video_enc.codec_type = AVMEDIA_TYPE_VIDEO;
4556 video_enc.codec_id = video_id;
4557 add_codec(stream, &video_enc);
4562 } else if (!av_strcasecmp(cmd, "<Redirect")) {
4563 /*********************************************/
4565 if (stream || feed || redirect) {
4566 ERROR("Already in a tag\n");
4568 redirect = av_mallocz(sizeof(FFStream));
4569 *last_stream = redirect;
4570 last_stream = &redirect->next;
4572 get_arg(redirect->filename, sizeof(redirect->filename), &p);
4573 q = strrchr(redirect->filename, '>');
4576 redirect->stream_type = STREAM_TYPE_REDIRECT;
4578 } else if (!av_strcasecmp(cmd, "URL")) {
4580 get_arg(redirect->feed_filename, sizeof(redirect->feed_filename), &p);
4581 } else if (!av_strcasecmp(cmd, "</Redirect>")) {
4583 ERROR("No corresponding <Redirect> for </Redirect>\n");
4585 if (!redirect->feed_filename[0]) {
4586 ERROR("No URL found for <Redirect>\n");
4590 } else if (!av_strcasecmp(cmd, "LoadModule")) {
4591 get_arg(arg, sizeof(arg), &p);
4595 ERROR("Module support not compiled into this version: '%s'\n", arg);
4598 ERROR("Incorrect keyword: '%s'\n", cmd);
4610 static void handle_child_exit(int sig)
4615 while ((pid = waitpid(-1, &status, WNOHANG)) > 0) {
4618 for (feed = first_feed; feed; feed = feed->next) {
4619 if (feed->pid == pid) {
4620 int uptime = time(0) - feed->pid_start;
4623 fprintf(stderr, "%s: Pid %d exited with status %d after %d seconds\n", feed->filename, pid, status, uptime);
4626 /* Turn off any more restarts */
4627 feed->child_argv = 0;
4632 need_to_start_children = 1;
4635 static void opt_debug(void)
4638 ffserver_daemon = 0;
4639 logfilename[0] = '-';
4642 static int opt_help(const char *opt, const char *arg)
4644 printf("usage: ffserver [options]\n"
4645 "Hyper fast multi format Audio/Video streaming server\n");
4647 show_help_options(options, "Main options:\n", 0, 0);
4651 static const OptionDef options[] = {
4652 #include "cmdutils_common_opts.h"
4653 { "n", OPT_BOOL, {(void *)&no_launch }, "enable no-launch mode" },
4654 { "d", 0, {(void*)opt_debug}, "enable debug mode" },
4655 { "f", HAS_ARG | OPT_STRING, {(void*)&config_filename }, "use configfile instead of /etc/ffserver.conf", "configfile" },
4659 int main(int argc, char **argv)
4661 struct sigaction sigact;
4663 parse_loglevel(argc, argv, options);
4665 avformat_network_init();
4667 show_banner(argc, argv, options);
4669 my_program_name = argv[0];
4670 my_program_dir = getcwd(0, 0);
4671 ffserver_daemon = 1;
4673 parse_options(NULL, argc, argv, options, NULL);
4675 unsetenv("http_proxy"); /* Kill the http_proxy */
4677 av_lfg_init(&random_state, av_get_random_seed());
4679 memset(&sigact, 0, sizeof(sigact));
4680 sigact.sa_handler = handle_child_exit;
4681 sigact.sa_flags = SA_NOCLDSTOP | SA_RESTART;
4682 sigaction(SIGCHLD, &sigact, 0);
4684 if (parse_ffconfig(config_filename) < 0) {
4685 fprintf(stderr, "Incorrect config file - exiting.\n");
4689 /* open log file if needed */
4690 if (logfilename[0] != '\0') {
4691 if (!strcmp(logfilename, "-"))
4694 logfile = fopen(logfilename, "a");
4695 av_log_set_callback(http_av_log);
4698 build_file_streams();
4700 build_feed_streams();
4702 compute_bandwidth();
4704 /* put the process in background and detach it from its TTY */
4705 if (ffserver_daemon) {
4712 } else if (pid > 0) {
4719 open("/dev/null", O_RDWR);
4720 if (strcmp(logfilename, "-") != 0) {
4730 signal(SIGPIPE, SIG_IGN);
4732 if (ffserver_daemon)
4735 if (http_server() < 0) {
4736 http_log("Could not start server\n");