2 * Multiple format streaming server
3 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22 #define _XOPEN_SOURCE 600
26 #define closesocket close
31 /* avformat.h defines LIBAVFORMAT_BUILD, include it before all the other libav* headers which use it */
32 #include "libavformat/avformat.h"
33 #include "libavformat/network.h"
34 #include "libavformat/os_support.h"
35 #include "libavformat/rtpdec.h"
36 #include "libavformat/rtsp.h"
37 #include "libavutil/avstring.h"
38 #include "libavutil/lfg.h"
39 #include "libavutil/random_seed.h"
40 #include "libavutil/intreadwrite.h"
41 #include "libavcodec/opt.h"
45 #include <sys/ioctl.h>
51 #undef time //needed because HAVE_AV_CONFIG_H is defined on top
63 const char program_name[] = "FFserver";
64 const int program_birth_year = 2000;
66 static const OptionDef options[];
69 HTTPSTATE_WAIT_REQUEST,
70 HTTPSTATE_SEND_HEADER,
71 HTTPSTATE_SEND_DATA_HEADER,
72 HTTPSTATE_SEND_DATA, /* sending TCP or UDP data */
73 HTTPSTATE_SEND_DATA_TRAILER,
74 HTTPSTATE_RECEIVE_DATA,
75 HTTPSTATE_WAIT_FEED, /* wait for data from the feed */
78 RTSPSTATE_WAIT_REQUEST,
80 RTSPSTATE_SEND_PACKET,
83 static const char *http_state[] = {
99 #define IOBUFFER_INIT_SIZE 8192
101 /* timeouts are in ms */
102 #define HTTP_REQUEST_TIMEOUT (15 * 1000)
103 #define RTSP_REQUEST_TIMEOUT (3600 * 24 * 1000)
105 #define SYNC_TIMEOUT (10 * 1000)
107 typedef struct RTSPActionServerSetup {
109 char transport_option[512];
110 } RTSPActionServerSetup;
113 int64_t count1, count2;
114 int64_t time1, time2;
117 /* context associated with one connection */
118 typedef struct HTTPContext {
119 enum HTTPState state;
120 int fd; /* socket file descriptor */
121 struct sockaddr_in from_addr; /* origin */
122 struct pollfd *poll_entry; /* used when polling */
124 uint8_t *buffer_ptr, *buffer_end;
127 struct HTTPContext *next;
128 int got_key_frame; /* stream 0 => 1, stream 1 => 2, stream 2=> 4 */
132 /* input format handling */
133 AVFormatContext *fmt_in;
134 int64_t start_time; /* In milliseconds - this wraps fairly often */
135 int64_t first_pts; /* initial pts value */
136 int64_t cur_pts; /* current pts value from the stream in us */
137 int64_t cur_frame_duration; /* duration of the current frame in us */
138 int cur_frame_bytes; /* output frame size, needed to compute
139 the time at which we send each
141 int pts_stream_index; /* stream we choose as clock reference */
142 int64_t cur_clock; /* current clock reference value in us */
143 /* output format handling */
144 struct FFStream *stream;
145 /* -1 is invalid stream */
146 int feed_streams[MAX_STREAMS]; /* index of streams in the feed */
147 int switch_feed_streams[MAX_STREAMS]; /* index of streams in the feed */
149 AVFormatContext fmt_ctx; /* instance of FFStream for one user */
150 int last_packet_sent; /* true if last data packet was sent */
152 DataRateData datarate;
159 int is_packetized; /* if true, the stream is packetized */
160 int packet_stream_index; /* current stream for output in state machine */
162 /* RTSP state specific */
163 uint8_t *pb_buffer; /* XXX: use that in all the code */
165 int seq; /* RTSP sequence number */
167 /* RTP state specific */
168 enum RTSPLowerTransport rtp_protocol;
169 char session_id[32]; /* session id */
170 AVFormatContext *rtp_ctx[MAX_STREAMS];
172 /* RTP/UDP specific */
173 URLContext *rtp_handles[MAX_STREAMS];
175 /* RTP/TCP specific */
176 struct HTTPContext *rtsp_c;
177 uint8_t *packet_buffer, *packet_buffer_ptr, *packet_buffer_end;
180 /* each generated stream is described here */
184 STREAM_TYPE_REDIRECT,
187 enum IPAddressAction {
192 typedef struct IPAddressACL {
193 struct IPAddressACL *next;
194 enum IPAddressAction action;
195 /* These are in host order */
196 struct in_addr first;
200 /* description of each stream of the ffserver.conf file */
201 typedef struct FFStream {
202 enum StreamType stream_type;
203 char filename[1024]; /* stream filename */
204 struct FFStream *feed; /* feed we are using (can be null if
206 AVFormatParameters *ap_in; /* input parameters */
207 AVInputFormat *ifmt; /* if non NULL, force input format */
211 int prebuffer; /* Number of millseconds early to start */
212 int64_t max_time; /* Number of milliseconds to run */
214 AVStream *streams[MAX_STREAMS];
215 int feed_streams[MAX_STREAMS]; /* index of streams in the feed */
216 char feed_filename[1024]; /* file name of the feed storage, or
217 input file name for a stream */
222 pid_t pid; /* Of ffmpeg process */
223 time_t pid_start; /* Of ffmpeg process */
225 struct FFStream *next;
226 unsigned bandwidth; /* bandwidth, in kbits/s */
229 /* multicast specific */
231 struct in_addr multicast_ip;
232 int multicast_port; /* first port used for multicast */
234 int loop; /* if true, send the stream in loops (only meaningful if file) */
237 int feed_opened; /* true if someone is writing to the feed */
238 int is_feed; /* true if it is a feed */
239 int readonly; /* True if writing is prohibited to the file */
241 int64_t bytes_served;
242 int64_t feed_max_size; /* maximum storage size, zero means unlimited */
243 int64_t feed_write_index; /* current write position in feed (it wraps around) */
244 int64_t feed_size; /* current size of feed */
245 struct FFStream *next_feed;
248 typedef struct FeedData {
249 long long data_count;
250 float avg_frame_size; /* frame size averaged over last frames with exponential mean */
253 static struct sockaddr_in my_http_addr;
254 static struct sockaddr_in my_rtsp_addr;
256 static char logfilename[1024];
257 static HTTPContext *first_http_ctx;
258 static FFStream *first_feed; /* contains only feeds */
259 static FFStream *first_stream; /* contains all streams, including feeds */
261 static void new_connection(int server_fd, int is_rtsp);
262 static void close_connection(HTTPContext *c);
265 static int handle_connection(HTTPContext *c);
266 static int http_parse_request(HTTPContext *c);
267 static int http_send_data(HTTPContext *c);
268 static void compute_status(HTTPContext *c);
269 static int open_input_stream(HTTPContext *c, const char *info);
270 static int http_start_receive_data(HTTPContext *c);
271 static int http_receive_data(HTTPContext *c);
274 static int rtsp_parse_request(HTTPContext *c);
275 static void rtsp_cmd_describe(HTTPContext *c, const char *url);
276 static void rtsp_cmd_options(HTTPContext *c, const char *url);
277 static void rtsp_cmd_setup(HTTPContext *c, const char *url, RTSPMessageHeader *h);
278 static void rtsp_cmd_play(HTTPContext *c, const char *url, RTSPMessageHeader *h);
279 static void rtsp_cmd_pause(HTTPContext *c, const char *url, RTSPMessageHeader *h);
280 static void rtsp_cmd_teardown(HTTPContext *c, const char *url, RTSPMessageHeader *h);
283 static int prepare_sdp_description(FFStream *stream, uint8_t **pbuffer,
284 struct in_addr my_ip);
287 static HTTPContext *rtp_new_connection(struct sockaddr_in *from_addr,
288 FFStream *stream, const char *session_id,
289 enum RTSPLowerTransport rtp_protocol);
290 static int rtp_new_av_stream(HTTPContext *c,
291 int stream_index, struct sockaddr_in *dest_addr,
292 HTTPContext *rtsp_c);
294 static const char *my_program_name;
295 static const char *my_program_dir;
297 static const char *config_filename;
298 static int ffserver_debug;
299 static int ffserver_daemon;
300 static int no_launch;
301 static int need_to_start_children;
303 /* maximum number of simultaneous HTTP connections */
304 static unsigned int nb_max_http_connections = 2000;
305 static unsigned int nb_max_connections = 5;
306 static unsigned int nb_connections;
308 static uint64_t max_bandwidth = 1000;
309 static uint64_t current_bandwidth;
311 static int64_t cur_time; // Making this global saves on passing it around everywhere
313 static AVLFG random_state;
315 static FILE *logfile = NULL;
317 static char *ctime1(char *buf2)
325 p = buf2 + strlen(p) - 1;
331 static void http_vlog(const char *fmt, va_list vargs)
333 static int print_prefix = 1;
338 fprintf(logfile, "%s ", buf);
340 print_prefix = strstr(fmt, "\n") != NULL;
341 vfprintf(logfile, fmt, vargs);
346 void __attribute__ ((format (printf, 1, 2))) http_log(const char *fmt, ...)
349 va_start(vargs, fmt);
350 http_vlog(fmt, vargs);
354 static void http_av_log(void *ptr, int level, const char *fmt, va_list vargs)
356 static int print_prefix = 1;
357 AVClass *avc = ptr ? *(AVClass**)ptr : NULL;
358 if (level > av_log_get_level())
360 if (print_prefix && avc)
361 http_log("[%s @ %p]", avc->item_name(ptr), ptr);
362 print_prefix = strstr(fmt, "\n") != NULL;
363 http_vlog(fmt, vargs);
366 static void log_connection(HTTPContext *c)
371 http_log("%s - - [%s] \"%s %s\" %d %"PRId64"\n",
372 inet_ntoa(c->from_addr.sin_addr), c->method, c->url,
373 c->protocol, (c->http_error ? c->http_error : 200), c->data_count);
376 static void update_datarate(DataRateData *drd, int64_t count)
378 if (!drd->time1 && !drd->count1) {
379 drd->time1 = drd->time2 = cur_time;
380 drd->count1 = drd->count2 = count;
381 } else if (cur_time - drd->time2 > 5000) {
382 drd->time1 = drd->time2;
383 drd->count1 = drd->count2;
384 drd->time2 = cur_time;
389 /* In bytes per second */
390 static int compute_datarate(DataRateData *drd, int64_t count)
392 if (cur_time == drd->time1)
395 return ((count - drd->count1) * 1000) / (cur_time - drd->time1);
399 static void start_children(FFStream *feed)
404 for (; feed; feed = feed->next) {
405 if (feed->child_argv && !feed->pid) {
406 feed->pid_start = time(0);
411 http_log("Unable to create children\n");
420 av_strlcpy(pathname, my_program_name, sizeof(pathname));
422 slash = strrchr(pathname, '/');
427 strcpy(slash, "ffmpeg");
429 http_log("Launch commandline: ");
430 http_log("%s ", pathname);
431 for (i = 1; feed->child_argv[i] && feed->child_argv[i][0]; i++)
432 http_log("%s ", feed->child_argv[i]);
435 for (i = 3; i < 256; i++)
438 if (!ffserver_debug) {
439 i = open("/dev/null", O_RDWR);
448 /* This is needed to make relative pathnames work */
449 chdir(my_program_dir);
451 signal(SIGPIPE, SIG_DFL);
453 execvp(pathname, feed->child_argv);
461 /* open a listening socket */
462 static int socket_open_listen(struct sockaddr_in *my_addr)
466 server_fd = socket(AF_INET,SOCK_STREAM,0);
473 setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &tmp, sizeof(tmp));
475 if (bind (server_fd, (struct sockaddr *) my_addr, sizeof (*my_addr)) < 0) {
477 snprintf(bindmsg, sizeof(bindmsg), "bind(port %d)", ntohs(my_addr->sin_port));
479 closesocket(server_fd);
483 if (listen (server_fd, 5) < 0) {
485 closesocket(server_fd);
488 ff_socket_nonblock(server_fd, 1);
493 /* start all multicast streams */
494 static void start_multicast(void)
499 struct sockaddr_in dest_addr;
500 int default_port, stream_index;
503 for(stream = first_stream; stream != NULL; stream = stream->next) {
504 if (stream->is_multicast) {
505 /* open the RTP connection */
506 snprintf(session_id, sizeof(session_id), "%08x%08x",
507 av_lfg_get(&random_state), av_lfg_get(&random_state));
509 /* choose a port if none given */
510 if (stream->multicast_port == 0) {
511 stream->multicast_port = default_port;
515 dest_addr.sin_family = AF_INET;
516 dest_addr.sin_addr = stream->multicast_ip;
517 dest_addr.sin_port = htons(stream->multicast_port);
519 rtp_c = rtp_new_connection(&dest_addr, stream, session_id,
520 RTSP_LOWER_TRANSPORT_UDP_MULTICAST);
524 if (open_input_stream(rtp_c, "") < 0) {
525 http_log("Could not open input stream for stream '%s'\n",
530 /* open each RTP stream */
531 for(stream_index = 0; stream_index < stream->nb_streams;
533 dest_addr.sin_port = htons(stream->multicast_port +
535 if (rtp_new_av_stream(rtp_c, stream_index, &dest_addr, NULL) < 0) {
536 http_log("Could not open output stream '%s/streamid=%d'\n",
537 stream->filename, stream_index);
542 /* change state to send data */
543 rtp_c->state = HTTPSTATE_SEND_DATA;
548 /* main loop of the http server */
549 static int http_server(void)
551 int server_fd = 0, rtsp_server_fd = 0;
552 int ret, delay, delay1;
553 struct pollfd *poll_table, *poll_entry;
554 HTTPContext *c, *c_next;
556 if(!(poll_table = av_mallocz((nb_max_http_connections + 2)*sizeof(*poll_table)))) {
557 http_log("Impossible to allocate a poll table handling %d connections.\n", nb_max_http_connections);
561 if (my_http_addr.sin_port) {
562 server_fd = socket_open_listen(&my_http_addr);
567 if (my_rtsp_addr.sin_port) {
568 rtsp_server_fd = socket_open_listen(&my_rtsp_addr);
569 if (rtsp_server_fd < 0)
573 if (!rtsp_server_fd && !server_fd) {
574 http_log("HTTP and RTSP disabled.\n");
578 http_log("FFserver started.\n");
580 start_children(first_feed);
585 poll_entry = poll_table;
587 poll_entry->fd = server_fd;
588 poll_entry->events = POLLIN;
591 if (rtsp_server_fd) {
592 poll_entry->fd = rtsp_server_fd;
593 poll_entry->events = POLLIN;
597 /* wait for events on each HTTP handle */
604 case HTTPSTATE_SEND_HEADER:
605 case RTSPSTATE_SEND_REPLY:
606 case RTSPSTATE_SEND_PACKET:
607 c->poll_entry = poll_entry;
609 poll_entry->events = POLLOUT;
612 case HTTPSTATE_SEND_DATA_HEADER:
613 case HTTPSTATE_SEND_DATA:
614 case HTTPSTATE_SEND_DATA_TRAILER:
615 if (!c->is_packetized) {
616 /* for TCP, we output as much as we can (may need to put a limit) */
617 c->poll_entry = poll_entry;
619 poll_entry->events = POLLOUT;
622 /* when ffserver is doing the timing, we work by
623 looking at which packet need to be sent every
625 delay1 = 10; /* one tick wait XXX: 10 ms assumed */
630 case HTTPSTATE_WAIT_REQUEST:
631 case HTTPSTATE_RECEIVE_DATA:
632 case HTTPSTATE_WAIT_FEED:
633 case RTSPSTATE_WAIT_REQUEST:
634 /* need to catch errors */
635 c->poll_entry = poll_entry;
637 poll_entry->events = POLLIN;/* Maybe this will work */
641 c->poll_entry = NULL;
647 /* wait for an event on one connection. We poll at least every
648 second to handle timeouts */
650 ret = poll(poll_table, poll_entry - poll_table, delay);
651 if (ret < 0 && ff_neterrno() != FF_NETERROR(EAGAIN) &&
652 ff_neterrno() != FF_NETERROR(EINTR))
656 cur_time = av_gettime() / 1000;
658 if (need_to_start_children) {
659 need_to_start_children = 0;
660 start_children(first_feed);
663 /* now handle the events */
664 for(c = first_http_ctx; c != NULL; c = c_next) {
666 if (handle_connection(c) < 0) {
667 /* close and free the connection */
673 poll_entry = poll_table;
675 /* new HTTP connection request ? */
676 if (poll_entry->revents & POLLIN)
677 new_connection(server_fd, 0);
680 if (rtsp_server_fd) {
681 /* new RTSP connection request ? */
682 if (poll_entry->revents & POLLIN)
683 new_connection(rtsp_server_fd, 1);
688 /* start waiting for a new HTTP/RTSP request */
689 static void start_wait_request(HTTPContext *c, int is_rtsp)
691 c->buffer_ptr = c->buffer;
692 c->buffer_end = c->buffer + c->buffer_size - 1; /* leave room for '\0' */
695 c->timeout = cur_time + RTSP_REQUEST_TIMEOUT;
696 c->state = RTSPSTATE_WAIT_REQUEST;
698 c->timeout = cur_time + HTTP_REQUEST_TIMEOUT;
699 c->state = HTTPSTATE_WAIT_REQUEST;
703 static void new_connection(int server_fd, int is_rtsp)
705 struct sockaddr_in from_addr;
707 HTTPContext *c = NULL;
709 len = sizeof(from_addr);
710 fd = accept(server_fd, (struct sockaddr *)&from_addr,
713 http_log("error during accept %s\n", strerror(errno));
716 ff_socket_nonblock(fd, 1);
718 /* XXX: should output a warning page when coming
719 close to the connection limit */
720 if (nb_connections >= nb_max_connections)
723 /* add a new connection */
724 c = av_mallocz(sizeof(HTTPContext));
729 c->poll_entry = NULL;
730 c->from_addr = from_addr;
731 c->buffer_size = IOBUFFER_INIT_SIZE;
732 c->buffer = av_malloc(c->buffer_size);
736 c->next = first_http_ctx;
740 start_wait_request(c, is_rtsp);
752 static void close_connection(HTTPContext *c)
754 HTTPContext **cp, *c1;
756 AVFormatContext *ctx;
760 /* remove connection from list */
761 cp = &first_http_ctx;
762 while ((*cp) != NULL) {
770 /* remove references, if any (XXX: do it faster) */
771 for(c1 = first_http_ctx; c1 != NULL; c1 = c1->next) {
776 /* remove connection associated resources */
780 /* close each frame parser */
781 for(i=0;i<c->fmt_in->nb_streams;i++) {
782 st = c->fmt_in->streams[i];
783 if (st->codec->codec)
784 avcodec_close(st->codec);
786 av_close_input_file(c->fmt_in);
789 /* free RTP output streams if any */
792 nb_streams = c->stream->nb_streams;
794 for(i=0;i<nb_streams;i++) {
797 av_write_trailer(ctx);
800 h = c->rtp_handles[i];
807 if (!c->last_packet_sent && c->state == HTTPSTATE_SEND_DATA_TRAILER) {
810 if (url_open_dyn_buf(&ctx->pb) >= 0) {
811 av_write_trailer(ctx);
812 av_freep(&c->pb_buffer);
813 url_close_dyn_buf(ctx->pb, &c->pb_buffer);
818 for(i=0; i<ctx->nb_streams; i++)
819 av_free(ctx->streams[i]);
821 if (c->stream && !c->post && c->stream->stream_type == STREAM_TYPE_LIVE)
822 current_bandwidth -= c->stream->bandwidth;
824 /* signal that there is no feed if we are the feeder socket */
825 if (c->state == HTTPSTATE_RECEIVE_DATA && c->stream) {
826 c->stream->feed_opened = 0;
830 av_freep(&c->pb_buffer);
831 av_freep(&c->packet_buffer);
837 static int handle_connection(HTTPContext *c)
842 case HTTPSTATE_WAIT_REQUEST:
843 case RTSPSTATE_WAIT_REQUEST:
845 if ((c->timeout - cur_time) < 0)
847 if (c->poll_entry->revents & (POLLERR | POLLHUP))
850 /* no need to read if no events */
851 if (!(c->poll_entry->revents & POLLIN))
855 len = recv(c->fd, c->buffer_ptr, 1, 0);
857 if (ff_neterrno() != FF_NETERROR(EAGAIN) &&
858 ff_neterrno() != FF_NETERROR(EINTR))
860 } else if (len == 0) {
863 /* search for end of request. */
865 c->buffer_ptr += len;
867 if ((ptr >= c->buffer + 2 && !memcmp(ptr-2, "\n\n", 2)) ||
868 (ptr >= c->buffer + 4 && !memcmp(ptr-4, "\r\n\r\n", 4))) {
869 /* request found : parse it and reply */
870 if (c->state == HTTPSTATE_WAIT_REQUEST) {
871 ret = http_parse_request(c);
873 ret = rtsp_parse_request(c);
877 } else if (ptr >= c->buffer_end) {
878 /* request too long: cannot do anything */
880 } else goto read_loop;
884 case HTTPSTATE_SEND_HEADER:
885 if (c->poll_entry->revents & (POLLERR | POLLHUP))
888 /* no need to write if no events */
889 if (!(c->poll_entry->revents & POLLOUT))
891 len = send(c->fd, c->buffer_ptr, c->buffer_end - c->buffer_ptr, 0);
893 if (ff_neterrno() != FF_NETERROR(EAGAIN) &&
894 ff_neterrno() != FF_NETERROR(EINTR)) {
895 /* error : close connection */
896 av_freep(&c->pb_buffer);
900 c->buffer_ptr += len;
902 c->stream->bytes_served += len;
903 c->data_count += len;
904 if (c->buffer_ptr >= c->buffer_end) {
905 av_freep(&c->pb_buffer);
909 /* all the buffer was sent : synchronize to the incoming stream */
910 c->state = HTTPSTATE_SEND_DATA_HEADER;
911 c->buffer_ptr = c->buffer_end = c->buffer;
916 case HTTPSTATE_SEND_DATA:
917 case HTTPSTATE_SEND_DATA_HEADER:
918 case HTTPSTATE_SEND_DATA_TRAILER:
919 /* for packetized output, we consider we can always write (the
920 input streams sets the speed). It may be better to verify
921 that we do not rely too much on the kernel queues */
922 if (!c->is_packetized) {
923 if (c->poll_entry->revents & (POLLERR | POLLHUP))
926 /* no need to read if no events */
927 if (!(c->poll_entry->revents & POLLOUT))
930 if (http_send_data(c) < 0)
932 /* close connection if trailer sent */
933 if (c->state == HTTPSTATE_SEND_DATA_TRAILER)
936 case HTTPSTATE_RECEIVE_DATA:
937 /* no need to read if no events */
938 if (c->poll_entry->revents & (POLLERR | POLLHUP))
940 if (!(c->poll_entry->revents & POLLIN))
942 if (http_receive_data(c) < 0)
945 case HTTPSTATE_WAIT_FEED:
946 /* no need to read if no events */
947 if (c->poll_entry->revents & (POLLIN | POLLERR | POLLHUP))
950 /* nothing to do, we'll be waken up by incoming feed packets */
953 case RTSPSTATE_SEND_REPLY:
954 if (c->poll_entry->revents & (POLLERR | POLLHUP)) {
955 av_freep(&c->pb_buffer);
958 /* no need to write if no events */
959 if (!(c->poll_entry->revents & POLLOUT))
961 len = send(c->fd, c->buffer_ptr, c->buffer_end - c->buffer_ptr, 0);
963 if (ff_neterrno() != FF_NETERROR(EAGAIN) &&
964 ff_neterrno() != FF_NETERROR(EINTR)) {
965 /* error : close connection */
966 av_freep(&c->pb_buffer);
970 c->buffer_ptr += len;
971 c->data_count += len;
972 if (c->buffer_ptr >= c->buffer_end) {
973 /* all the buffer was sent : wait for a new request */
974 av_freep(&c->pb_buffer);
975 start_wait_request(c, 1);
979 case RTSPSTATE_SEND_PACKET:
980 if (c->poll_entry->revents & (POLLERR | POLLHUP)) {
981 av_freep(&c->packet_buffer);
984 /* no need to write if no events */
985 if (!(c->poll_entry->revents & POLLOUT))
987 len = send(c->fd, c->packet_buffer_ptr,
988 c->packet_buffer_end - c->packet_buffer_ptr, 0);
990 if (ff_neterrno() != FF_NETERROR(EAGAIN) &&
991 ff_neterrno() != FF_NETERROR(EINTR)) {
992 /* error : close connection */
993 av_freep(&c->packet_buffer);
997 c->packet_buffer_ptr += len;
998 if (c->packet_buffer_ptr >= c->packet_buffer_end) {
999 /* all the buffer was sent : wait for a new request */
1000 av_freep(&c->packet_buffer);
1001 c->state = RTSPSTATE_WAIT_REQUEST;
1005 case HTTPSTATE_READY:
1014 static int extract_rates(char *rates, int ratelen, const char *request)
1018 for (p = request; *p && *p != '\r' && *p != '\n'; ) {
1019 if (strncasecmp(p, "Pragma:", 7) == 0) {
1020 const char *q = p + 7;
1022 while (*q && *q != '\n' && isspace(*q))
1025 if (strncasecmp(q, "stream-switch-entry=", 20) == 0) {
1031 memset(rates, 0xff, ratelen);
1034 while (*q && *q != '\n' && *q != ':')
1037 if (sscanf(q, ":%d:%d", &stream_no, &rate_no) != 2)
1041 if (stream_no < ratelen && stream_no >= 0)
1042 rates[stream_no] = rate_no;
1044 while (*q && *q != '\n' && !isspace(*q))
1051 p = strchr(p, '\n');
1061 static int find_stream_in_feed(FFStream *feed, AVCodecContext *codec, int bit_rate)
1064 int best_bitrate = 100000000;
1067 for (i = 0; i < feed->nb_streams; i++) {
1068 AVCodecContext *feed_codec = feed->streams[i]->codec;
1070 if (feed_codec->codec_id != codec->codec_id ||
1071 feed_codec->sample_rate != codec->sample_rate ||
1072 feed_codec->width != codec->width ||
1073 feed_codec->height != codec->height)
1076 /* Potential stream */
1078 /* We want the fastest stream less than bit_rate, or the slowest
1079 * faster than bit_rate
1082 if (feed_codec->bit_rate <= bit_rate) {
1083 if (best_bitrate > bit_rate || feed_codec->bit_rate > best_bitrate) {
1084 best_bitrate = feed_codec->bit_rate;
1088 if (feed_codec->bit_rate < best_bitrate) {
1089 best_bitrate = feed_codec->bit_rate;
1098 static int modify_current_stream(HTTPContext *c, char *rates)
1101 FFStream *req = c->stream;
1102 int action_required = 0;
1104 /* Not much we can do for a feed */
1108 for (i = 0; i < req->nb_streams; i++) {
1109 AVCodecContext *codec = req->streams[i]->codec;
1113 c->switch_feed_streams[i] = req->feed_streams[i];
1116 c->switch_feed_streams[i] = find_stream_in_feed(req->feed, codec, codec->bit_rate / 2);
1119 /* Wants off or slow */
1120 c->switch_feed_streams[i] = find_stream_in_feed(req->feed, codec, codec->bit_rate / 4);
1122 /* This doesn't work well when it turns off the only stream! */
1123 c->switch_feed_streams[i] = -2;
1124 c->feed_streams[i] = -2;
1129 if (c->switch_feed_streams[i] >= 0 && c->switch_feed_streams[i] != c->feed_streams[i])
1130 action_required = 1;
1133 return action_required;
1137 static void do_switch_stream(HTTPContext *c, int i)
1139 if (c->switch_feed_streams[i] >= 0) {
1141 c->feed_streams[i] = c->switch_feed_streams[i];
1144 /* Now update the stream */
1146 c->switch_feed_streams[i] = -1;
1149 /* XXX: factorize in utils.c ? */
1150 /* XXX: take care with different space meaning */
1151 static void skip_spaces(const char **pp)
1155 while (*p == ' ' || *p == '\t')
1160 static void get_word(char *buf, int buf_size, const char **pp)
1168 while (!isspace(*p) && *p != '\0') {
1169 if ((q - buf) < buf_size - 1)
1178 static int validate_acl(FFStream *stream, HTTPContext *c)
1180 enum IPAddressAction last_action = IP_DENY;
1182 struct in_addr *src = &c->from_addr.sin_addr;
1183 unsigned long src_addr = src->s_addr;
1185 for (acl = stream->acl; acl; acl = acl->next) {
1186 if (src_addr >= acl->first.s_addr && src_addr <= acl->last.s_addr)
1187 return (acl->action == IP_ALLOW) ? 1 : 0;
1188 last_action = acl->action;
1191 /* Nothing matched, so return not the last action */
1192 return (last_action == IP_DENY) ? 1 : 0;
1195 /* compute the real filename of a file by matching it without its
1196 extensions to all the stream filenames */
1197 static void compute_real_filename(char *filename, int max_size)
1204 /* compute filename by matching without the file extensions */
1205 av_strlcpy(file1, filename, sizeof(file1));
1206 p = strrchr(file1, '.');
1209 for(stream = first_stream; stream != NULL; stream = stream->next) {
1210 av_strlcpy(file2, stream->filename, sizeof(file2));
1211 p = strrchr(file2, '.');
1214 if (!strcmp(file1, file2)) {
1215 av_strlcpy(filename, stream->filename, max_size);
1230 /* parse http request and prepare header */
1231 static int http_parse_request(HTTPContext *c)
1234 enum RedirType redir_type;
1236 char info[1024], filename[1024];
1240 const char *mime_type;
1244 char *useragent = 0;
1247 get_word(cmd, sizeof(cmd), (const char **)&p);
1248 av_strlcpy(c->method, cmd, sizeof(c->method));
1250 if (!strcmp(cmd, "GET"))
1252 else if (!strcmp(cmd, "POST"))
1257 get_word(url, sizeof(url), (const char **)&p);
1258 av_strlcpy(c->url, url, sizeof(c->url));
1260 get_word(protocol, sizeof(protocol), (const char **)&p);
1261 if (strcmp(protocol, "HTTP/1.0") && strcmp(protocol, "HTTP/1.1"))
1264 av_strlcpy(c->protocol, protocol, sizeof(c->protocol));
1267 http_log("New connection: %s %s\n", cmd, url);
1269 /* find the filename and the optional info string in the request */
1270 p = strchr(url, '?');
1272 av_strlcpy(info, p, sizeof(info));
1277 av_strlcpy(filename, url + ((*url == '/') ? 1 : 0), sizeof(filename)-1);
1279 for (p = c->buffer; *p && *p != '\r' && *p != '\n'; ) {
1280 if (strncasecmp(p, "User-Agent:", 11) == 0) {
1282 if (*useragent && *useragent != '\n' && isspace(*useragent))
1286 p = strchr(p, '\n');
1293 redir_type = REDIR_NONE;
1294 if (match_ext(filename, "asx")) {
1295 redir_type = REDIR_ASX;
1296 filename[strlen(filename)-1] = 'f';
1297 } else if (match_ext(filename, "asf") &&
1298 (!useragent || strncasecmp(useragent, "NSPlayer", 8) != 0)) {
1299 /* if this isn't WMP or lookalike, return the redirector file */
1300 redir_type = REDIR_ASF;
1301 } else if (match_ext(filename, "rpm,ram")) {
1302 redir_type = REDIR_RAM;
1303 strcpy(filename + strlen(filename)-2, "m");
1304 } else if (match_ext(filename, "rtsp")) {
1305 redir_type = REDIR_RTSP;
1306 compute_real_filename(filename, sizeof(filename) - 1);
1307 } else if (match_ext(filename, "sdp")) {
1308 redir_type = REDIR_SDP;
1309 compute_real_filename(filename, sizeof(filename) - 1);
1312 // "redirect" / request to index.html
1313 if (!strlen(filename))
1314 av_strlcpy(filename, "index.html", sizeof(filename) - 1);
1316 stream = first_stream;
1317 while (stream != NULL) {
1318 if (!strcmp(stream->filename, filename) && validate_acl(stream, c))
1320 stream = stream->next;
1322 if (stream == NULL) {
1323 snprintf(msg, sizeof(msg), "File '%s' not found", url);
1328 memcpy(c->feed_streams, stream->feed_streams, sizeof(c->feed_streams));
1329 memset(c->switch_feed_streams, -1, sizeof(c->switch_feed_streams));
1331 if (stream->stream_type == STREAM_TYPE_REDIRECT) {
1332 c->http_error = 301;
1334 q += snprintf(q, c->buffer_size,
1335 "HTTP/1.0 301 Moved\r\n"
1337 "Content-type: text/html\r\n"
1339 "<html><head><title>Moved</title></head><body>\r\n"
1340 "You should be <a href=\"%s\">redirected</a>.\r\n"
1341 "</body></html>\r\n", stream->feed_filename, stream->feed_filename);
1342 /* prepare output buffer */
1343 c->buffer_ptr = c->buffer;
1345 c->state = HTTPSTATE_SEND_HEADER;
1349 /* If this is WMP, get the rate information */
1350 if (extract_rates(ratebuf, sizeof(ratebuf), c->buffer)) {
1351 if (modify_current_stream(c, ratebuf)) {
1352 for (i = 0; i < FF_ARRAY_ELEMS(c->feed_streams); i++) {
1353 if (c->switch_feed_streams[i] >= 0)
1354 do_switch_stream(c, i);
1359 if (c->post == 0 && stream->stream_type == STREAM_TYPE_LIVE)
1360 current_bandwidth += stream->bandwidth;
1362 /* If already streaming this feed, do not let start another feeder. */
1363 if (stream->feed_opened) {
1364 snprintf(msg, sizeof(msg), "This feed is already being received.");
1365 http_log("feed %s already being received\n", stream->feed_filename);
1369 if (c->post == 0 && max_bandwidth < current_bandwidth) {
1370 c->http_error = 200;
1372 q += snprintf(q, c->buffer_size,
1373 "HTTP/1.0 200 Server too busy\r\n"
1374 "Content-type: text/html\r\n"
1376 "<html><head><title>Too busy</title></head><body>\r\n"
1377 "<p>The server is too busy to serve your request at this time.</p>\r\n"
1378 "<p>The bandwidth being served (including your stream) is %"PRIu64"kbit/sec, "
1379 "and this exceeds the limit of %"PRIu64"kbit/sec.</p>\r\n"
1380 "</body></html>\r\n", current_bandwidth, max_bandwidth);
1381 /* prepare output buffer */
1382 c->buffer_ptr = c->buffer;
1384 c->state = HTTPSTATE_SEND_HEADER;
1388 if (redir_type != REDIR_NONE) {
1391 for (p = c->buffer; *p && *p != '\r' && *p != '\n'; ) {
1392 if (strncasecmp(p, "Host:", 5) == 0) {
1396 p = strchr(p, '\n');
1407 while (isspace(*hostinfo))
1410 eoh = strchr(hostinfo, '\n');
1412 if (eoh[-1] == '\r')
1415 if (eoh - hostinfo < sizeof(hostbuf) - 1) {
1416 memcpy(hostbuf, hostinfo, eoh - hostinfo);
1417 hostbuf[eoh - hostinfo] = 0;
1419 c->http_error = 200;
1421 switch(redir_type) {
1423 q += snprintf(q, c->buffer_size,
1424 "HTTP/1.0 200 ASX Follows\r\n"
1425 "Content-type: video/x-ms-asf\r\n"
1427 "<ASX Version=\"3\">\r\n"
1428 //"<!-- Autogenerated by ffserver -->\r\n"
1429 "<ENTRY><REF HREF=\"http://%s/%s%s\"/></ENTRY>\r\n"
1430 "</ASX>\r\n", hostbuf, filename, info);
1433 q += snprintf(q, c->buffer_size,
1434 "HTTP/1.0 200 RAM Follows\r\n"
1435 "Content-type: audio/x-pn-realaudio\r\n"
1437 "# Autogenerated by ffserver\r\n"
1438 "http://%s/%s%s\r\n", hostbuf, filename, info);
1441 q += snprintf(q, c->buffer_size,
1442 "HTTP/1.0 200 ASF Redirect follows\r\n"
1443 "Content-type: video/x-ms-asf\r\n"
1446 "Ref1=http://%s/%s%s\r\n", hostbuf, filename, info);
1450 char hostname[256], *p;
1451 /* extract only hostname */
1452 av_strlcpy(hostname, hostbuf, sizeof(hostname));
1453 p = strrchr(hostname, ':');
1456 q += snprintf(q, c->buffer_size,
1457 "HTTP/1.0 200 RTSP Redirect follows\r\n"
1458 /* XXX: incorrect mime type ? */
1459 "Content-type: application/x-rtsp\r\n"
1461 "rtsp://%s:%d/%s\r\n", hostname, ntohs(my_rtsp_addr.sin_port), filename);
1467 int sdp_data_size, len;
1468 struct sockaddr_in my_addr;
1470 q += snprintf(q, c->buffer_size,
1471 "HTTP/1.0 200 OK\r\n"
1472 "Content-type: application/sdp\r\n"
1475 len = sizeof(my_addr);
1476 getsockname(c->fd, (struct sockaddr *)&my_addr, &len);
1478 /* XXX: should use a dynamic buffer */
1479 sdp_data_size = prepare_sdp_description(stream,
1482 if (sdp_data_size > 0) {
1483 memcpy(q, sdp_data, sdp_data_size);
1495 /* prepare output buffer */
1496 c->buffer_ptr = c->buffer;
1498 c->state = HTTPSTATE_SEND_HEADER;
1504 snprintf(msg, sizeof(msg), "ASX/RAM file not handled");
1508 stream->conns_served++;
1510 /* XXX: add there authenticate and IP match */
1513 /* if post, it means a feed is being sent */
1514 if (!stream->is_feed) {
1515 /* However it might be a status report from WMP! Let us log the
1516 * data as it might come in handy one day. */
1520 for (p = c->buffer; *p && *p != '\r' && *p != '\n'; ) {
1521 if (strncasecmp(p, "Pragma: log-line=", 17) == 0) {
1525 if (strncasecmp(p, "Pragma: client-id=", 18) == 0)
1526 client_id = strtol(p + 18, 0, 10);
1527 p = strchr(p, '\n');
1535 char *eol = strchr(logline, '\n');
1540 if (eol[-1] == '\r')
1542 http_log("%.*s\n", (int) (eol - logline), logline);
1543 c->suppress_log = 1;
1548 http_log("\nGot request:\n%s\n", c->buffer);
1551 if (client_id && extract_rates(ratebuf, sizeof(ratebuf), c->buffer)) {
1554 /* Now we have to find the client_id */
1555 for (wmpc = first_http_ctx; wmpc; wmpc = wmpc->next) {
1556 if (wmpc->wmp_client_id == client_id)
1560 if (wmpc && modify_current_stream(wmpc, ratebuf))
1561 wmpc->switch_pending = 1;
1564 snprintf(msg, sizeof(msg), "POST command not handled");
1568 if (http_start_receive_data(c) < 0) {
1569 snprintf(msg, sizeof(msg), "could not open feed");
1573 c->state = HTTPSTATE_RECEIVE_DATA;
1578 if (strcmp(stream->filename + strlen(stream->filename) - 4, ".asf") == 0)
1579 http_log("\nGot request:\n%s\n", c->buffer);
1582 if (c->stream->stream_type == STREAM_TYPE_STATUS)
1585 /* open input stream */
1586 if (open_input_stream(c, info) < 0) {
1587 snprintf(msg, sizeof(msg), "Input stream corresponding to '%s' not found", url);
1591 /* prepare http header */
1593 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "HTTP/1.0 200 OK\r\n");
1594 mime_type = c->stream->fmt->mime_type;
1596 mime_type = "application/x-octet-stream";
1597 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "Pragma: no-cache\r\n");
1599 /* for asf, we need extra headers */
1600 if (!strcmp(c->stream->fmt->name,"asf_stream")) {
1601 /* Need to allocate a client id */
1603 c->wmp_client_id = av_lfg_get(&random_state);
1605 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);
1607 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "Content-Type: %s\r\n", mime_type);
1608 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "\r\n");
1610 /* prepare output buffer */
1612 c->buffer_ptr = c->buffer;
1614 c->state = HTTPSTATE_SEND_HEADER;
1617 c->http_error = 404;
1619 q += snprintf(q, c->buffer_size,
1620 "HTTP/1.0 404 Not Found\r\n"
1621 "Content-type: text/html\r\n"
1624 "<HEAD><TITLE>404 Not Found</TITLE></HEAD>\n"
1627 /* prepare output buffer */
1628 c->buffer_ptr = c->buffer;
1630 c->state = HTTPSTATE_SEND_HEADER;
1634 c->http_error = 200; /* horrible : we use this value to avoid
1635 going to the send data state */
1636 c->state = HTTPSTATE_SEND_HEADER;
1640 static void fmt_bytecount(ByteIOContext *pb, int64_t count)
1642 static const char *suffix = " kMGTP";
1645 for (s = suffix; count >= 100000 && s[1]; count /= 1000, s++);
1647 url_fprintf(pb, "%"PRId64"%c", count, *s);
1650 static void compute_status(HTTPContext *c)
1659 if (url_open_dyn_buf(&pb) < 0) {
1660 /* XXX: return an error ? */
1661 c->buffer_ptr = c->buffer;
1662 c->buffer_end = c->buffer;
1666 url_fprintf(pb, "HTTP/1.0 200 OK\r\n");
1667 url_fprintf(pb, "Content-type: %s\r\n", "text/html");
1668 url_fprintf(pb, "Pragma: no-cache\r\n");
1669 url_fprintf(pb, "\r\n");
1671 url_fprintf(pb, "<HTML><HEAD><TITLE>%s Status</TITLE>\n", program_name);
1672 if (c->stream->feed_filename[0])
1673 url_fprintf(pb, "<link rel=\"shortcut icon\" href=\"%s\">\n", c->stream->feed_filename);
1674 url_fprintf(pb, "</HEAD>\n<BODY>");
1675 url_fprintf(pb, "<H1>%s Status</H1>\n", program_name);
1677 url_fprintf(pb, "<H2>Available Streams</H2>\n");
1678 url_fprintf(pb, "<TABLE cellspacing=0 cellpadding=4>\n");
1679 url_fprintf(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");
1680 stream = first_stream;
1681 while (stream != NULL) {
1682 char sfilename[1024];
1685 if (stream->feed != stream) {
1686 av_strlcpy(sfilename, stream->filename, sizeof(sfilename) - 10);
1687 eosf = sfilename + strlen(sfilename);
1688 if (eosf - sfilename >= 4) {
1689 if (strcmp(eosf - 4, ".asf") == 0)
1690 strcpy(eosf - 4, ".asx");
1691 else if (strcmp(eosf - 3, ".rm") == 0)
1692 strcpy(eosf - 3, ".ram");
1693 else if (stream->fmt && !strcmp(stream->fmt->name, "rtp")) {
1694 /* generate a sample RTSP director if
1695 unicast. Generate an SDP redirector if
1697 eosf = strrchr(sfilename, '.');
1699 eosf = sfilename + strlen(sfilename);
1700 if (stream->is_multicast)
1701 strcpy(eosf, ".sdp");
1703 strcpy(eosf, ".rtsp");
1707 url_fprintf(pb, "<TR><TD><A HREF=\"/%s\">%s</A> ",
1708 sfilename, stream->filename);
1709 url_fprintf(pb, "<td align=right> %d <td align=right> ",
1710 stream->conns_served);
1711 fmt_bytecount(pb, stream->bytes_served);
1712 switch(stream->stream_type) {
1713 case STREAM_TYPE_LIVE: {
1714 int audio_bit_rate = 0;
1715 int video_bit_rate = 0;
1716 const char *audio_codec_name = "";
1717 const char *video_codec_name = "";
1718 const char *audio_codec_name_extra = "";
1719 const char *video_codec_name_extra = "";
1721 for(i=0;i<stream->nb_streams;i++) {
1722 AVStream *st = stream->streams[i];
1723 AVCodec *codec = avcodec_find_encoder(st->codec->codec_id);
1724 switch(st->codec->codec_type) {
1725 case CODEC_TYPE_AUDIO:
1726 audio_bit_rate += st->codec->bit_rate;
1728 if (*audio_codec_name)
1729 audio_codec_name_extra = "...";
1730 audio_codec_name = codec->name;
1733 case CODEC_TYPE_VIDEO:
1734 video_bit_rate += st->codec->bit_rate;
1736 if (*video_codec_name)
1737 video_codec_name_extra = "...";
1738 video_codec_name = codec->name;
1741 case CODEC_TYPE_DATA:
1742 video_bit_rate += st->codec->bit_rate;
1748 url_fprintf(pb, "<TD align=center> %s <TD align=right> %d <TD align=right> %d <TD> %s %s <TD align=right> %d <TD> %s %s",
1751 video_bit_rate / 1000, video_codec_name, video_codec_name_extra,
1752 audio_bit_rate / 1000, audio_codec_name, audio_codec_name_extra);
1754 url_fprintf(pb, "<TD>%s", stream->feed->filename);
1756 url_fprintf(pb, "<TD>%s", stream->feed_filename);
1757 url_fprintf(pb, "\n");
1761 url_fprintf(pb, "<TD align=center> - <TD align=right> - <TD align=right> - <td><td align=right> - <TD>\n");
1765 stream = stream->next;
1767 url_fprintf(pb, "</TABLE>\n");
1769 stream = first_stream;
1770 while (stream != NULL) {
1771 if (stream->feed == stream) {
1772 url_fprintf(pb, "<h2>Feed %s</h2>", stream->filename);
1774 url_fprintf(pb, "Running as pid %d.\n", stream->pid);
1776 #if defined(linux) && !defined(CONFIG_NOCUTILS)
1781 /* This is somewhat linux specific I guess */
1782 snprintf(ps_cmd, sizeof(ps_cmd),
1783 "ps -o \"%%cpu,cputime\" --no-headers %d",
1786 pid_stat = popen(ps_cmd, "r");
1791 if (fscanf(pid_stat, "%10s %64s", cpuperc,
1793 url_fprintf(pb, "Currently using %s%% of the cpu. Total time used %s.\n",
1801 url_fprintf(pb, "<p>");
1803 url_fprintf(pb, "<table cellspacing=0 cellpadding=4><tr><th>Stream<th>type<th>kbits/s<th align=left>codec<th align=left>Parameters\n");
1805 for (i = 0; i < stream->nb_streams; i++) {
1806 AVStream *st = stream->streams[i];
1807 AVCodec *codec = avcodec_find_encoder(st->codec->codec_id);
1808 const char *type = "unknown";
1809 char parameters[64];
1813 switch(st->codec->codec_type) {
1814 case CODEC_TYPE_AUDIO:
1816 snprintf(parameters, sizeof(parameters), "%d channel(s), %d Hz", st->codec->channels, st->codec->sample_rate);
1818 case CODEC_TYPE_VIDEO:
1820 snprintf(parameters, sizeof(parameters), "%dx%d, q=%d-%d, fps=%d", st->codec->width, st->codec->height,
1821 st->codec->qmin, st->codec->qmax, st->codec->time_base.den / st->codec->time_base.num);
1826 url_fprintf(pb, "<tr><td align=right>%d<td>%s<td align=right>%d<td>%s<td>%s\n",
1827 i, type, st->codec->bit_rate/1000, codec ? codec->name : "", parameters);
1829 url_fprintf(pb, "</table>\n");
1832 stream = stream->next;
1838 AVCodecContext *enc;
1842 stream = first_feed;
1843 while (stream != NULL) {
1844 url_fprintf(pb, "<H1>Feed '%s'</H1>\n", stream->filename);
1845 url_fprintf(pb, "<TABLE>\n");
1846 url_fprintf(pb, "<TR><TD>Parameters<TD>Frame count<TD>Size<TD>Avg bitrate (kbits/s)\n");
1847 for(i=0;i<stream->nb_streams;i++) {
1848 AVStream *st = stream->streams[i];
1849 FeedData *fdata = st->priv_data;
1852 avcodec_string(buf, sizeof(buf), enc);
1853 avg = fdata->avg_frame_size * (float)enc->rate * 8.0;
1854 if (enc->codec->type == CODEC_TYPE_AUDIO && enc->frame_size > 0)
1855 avg /= enc->frame_size;
1856 url_fprintf(pb, "<TR><TD>%s <TD> %d <TD> %"PRId64" <TD> %0.1f\n",
1857 buf, enc->frame_number, fdata->data_count, avg / 1000.0);
1859 url_fprintf(pb, "</TABLE>\n");
1860 stream = stream->next_feed;
1865 /* connection status */
1866 url_fprintf(pb, "<H2>Connection Status</H2>\n");
1868 url_fprintf(pb, "Number of connections: %d / %d<BR>\n",
1869 nb_connections, nb_max_connections);
1871 url_fprintf(pb, "Bandwidth in use: %"PRIu64"k / %"PRIu64"k<BR>\n",
1872 current_bandwidth, max_bandwidth);
1874 url_fprintf(pb, "<TABLE>\n");
1875 url_fprintf(pb, "<TR><th>#<th>File<th>IP<th>Proto<th>State<th>Target bits/sec<th>Actual bits/sec<th>Bytes transferred\n");
1876 c1 = first_http_ctx;
1878 while (c1 != NULL) {
1884 for (j = 0; j < c1->stream->nb_streams; j++) {
1885 if (!c1->stream->feed)
1886 bitrate += c1->stream->streams[j]->codec->bit_rate;
1887 else if (c1->feed_streams[j] >= 0)
1888 bitrate += c1->stream->feed->streams[c1->feed_streams[j]]->codec->bit_rate;
1893 p = inet_ntoa(c1->from_addr.sin_addr);
1894 url_fprintf(pb, "<TR><TD><B>%d</B><TD>%s%s<TD>%s<TD>%s<TD>%s<td align=right>",
1896 c1->stream ? c1->stream->filename : "",
1897 c1->state == HTTPSTATE_RECEIVE_DATA ? "(input)" : "",
1900 http_state[c1->state]);
1901 fmt_bytecount(pb, bitrate);
1902 url_fprintf(pb, "<td align=right>");
1903 fmt_bytecount(pb, compute_datarate(&c1->datarate, c1->data_count) * 8);
1904 url_fprintf(pb, "<td align=right>");
1905 fmt_bytecount(pb, c1->data_count);
1906 url_fprintf(pb, "\n");
1909 url_fprintf(pb, "</TABLE>\n");
1914 url_fprintf(pb, "<HR size=1 noshade>Generated at %s", p);
1915 url_fprintf(pb, "</BODY>\n</HTML>\n");
1917 len = url_close_dyn_buf(pb, &c->pb_buffer);
1918 c->buffer_ptr = c->pb_buffer;
1919 c->buffer_end = c->pb_buffer + len;
1922 /* check if the parser needs to be opened for stream i */
1923 static void open_parser(AVFormatContext *s, int i)
1925 AVStream *st = s->streams[i];
1928 if (!st->codec->codec) {
1929 codec = avcodec_find_decoder(st->codec->codec_id);
1930 if (codec && (codec->capabilities & CODEC_CAP_PARSE_ONLY)) {
1931 st->codec->parse_only = 1;
1932 if (avcodec_open(st->codec, codec) < 0)
1933 st->codec->parse_only = 0;
1938 static int open_input_stream(HTTPContext *c, const char *info)
1941 char input_filename[1024];
1943 int buf_size, i, ret;
1946 /* find file name */
1947 if (c->stream->feed) {
1948 strcpy(input_filename, c->stream->feed->feed_filename);
1949 buf_size = FFM_PACKET_SIZE;
1950 /* compute position (absolute time) */
1951 if (find_info_tag(buf, sizeof(buf), "date", info)) {
1952 stream_pos = parse_date(buf, 0);
1953 if (stream_pos == INT64_MIN)
1955 } else if (find_info_tag(buf, sizeof(buf), "buffer", info)) {
1956 int prebuffer = strtol(buf, 0, 10);
1957 stream_pos = av_gettime() - prebuffer * (int64_t)1000000;
1959 stream_pos = av_gettime() - c->stream->prebuffer * (int64_t)1000;
1961 strcpy(input_filename, c->stream->feed_filename);
1963 /* compute position (relative time) */
1964 if (find_info_tag(buf, sizeof(buf), "date", info)) {
1965 stream_pos = parse_date(buf, 1);
1966 if (stream_pos == INT64_MIN)
1971 if (input_filename[0] == '\0')
1975 { time_t when = stream_pos / 1000000;
1976 http_log("Stream pos = %"PRId64", time=%s", stream_pos, ctime(&when));
1981 if ((ret = av_open_input_file(&s, input_filename, c->stream->ifmt,
1982 buf_size, c->stream->ap_in)) < 0) {
1983 http_log("could not open %s: %d\n", input_filename, ret);
1986 s->flags |= AVFMT_FLAG_GENPTS;
1988 av_find_stream_info(c->fmt_in);
1990 /* open each parser */
1991 for(i=0;i<s->nb_streams;i++)
1994 /* choose stream as clock source (we favorize video stream if
1995 present) for packet sending */
1996 c->pts_stream_index = 0;
1997 for(i=0;i<c->stream->nb_streams;i++) {
1998 if (c->pts_stream_index == 0 &&
1999 c->stream->streams[i]->codec->codec_type == CODEC_TYPE_VIDEO) {
2000 c->pts_stream_index = i;
2005 if (c->fmt_in->iformat->read_seek)
2006 av_seek_frame(c->fmt_in, -1, stream_pos, 0);
2008 /* set the start time (needed for maxtime and RTP packet timing) */
2009 c->start_time = cur_time;
2010 c->first_pts = AV_NOPTS_VALUE;
2014 /* return the server clock (in us) */
2015 static int64_t get_server_clock(HTTPContext *c)
2017 /* compute current pts value from system time */
2018 return (cur_time - c->start_time) * 1000;
2021 /* return the estimated time at which the current packet must be sent
2023 static int64_t get_packet_send_clock(HTTPContext *c)
2025 int bytes_left, bytes_sent, frame_bytes;
2027 frame_bytes = c->cur_frame_bytes;
2028 if (frame_bytes <= 0)
2031 bytes_left = c->buffer_end - c->buffer_ptr;
2032 bytes_sent = frame_bytes - bytes_left;
2033 return c->cur_pts + (c->cur_frame_duration * bytes_sent) / frame_bytes;
2038 static int http_prepare_data(HTTPContext *c)
2041 AVFormatContext *ctx;
2043 av_freep(&c->pb_buffer);
2045 case HTTPSTATE_SEND_DATA_HEADER:
2046 memset(&c->fmt_ctx, 0, sizeof(c->fmt_ctx));
2047 av_metadata_set(&c->fmt_ctx.metadata, "author" ,c->stream->author);
2048 av_metadata_set(&c->fmt_ctx.metadata, "comment" ,c->stream->comment);
2049 av_metadata_set(&c->fmt_ctx.metadata, "copyright",c->stream->copyright);
2050 av_metadata_set(&c->fmt_ctx.metadata, "title" ,c->stream->title);
2052 for(i=0;i<c->stream->nb_streams;i++) {
2055 st = av_mallocz(sizeof(AVStream));
2056 c->fmt_ctx.streams[i] = st;
2057 /* if file or feed, then just take streams from FFStream struct */
2058 if (!c->stream->feed ||
2059 c->stream->feed == c->stream)
2060 src = c->stream->streams[i];
2062 src = c->stream->feed->streams[c->stream->feed_streams[i]];
2066 st->codec->frame_number = 0; /* XXX: should be done in
2067 AVStream, not in codec */
2069 /* set output format parameters */
2070 c->fmt_ctx.oformat = c->stream->fmt;
2071 c->fmt_ctx.nb_streams = c->stream->nb_streams;
2073 c->got_key_frame = 0;
2075 /* prepare header and save header data in a stream */
2076 if (url_open_dyn_buf(&c->fmt_ctx.pb) < 0) {
2077 /* XXX: potential leak */
2080 c->fmt_ctx.pb->is_streamed = 1;
2083 * HACK to avoid mpeg ps muxer to spit many underflow errors
2084 * Default value from FFmpeg
2085 * Try to set it use configuration option
2087 c->fmt_ctx.preload = (int)(0.5*AV_TIME_BASE);
2088 c->fmt_ctx.max_delay = (int)(0.7*AV_TIME_BASE);
2090 av_set_parameters(&c->fmt_ctx, NULL);
2091 if (av_write_header(&c->fmt_ctx) < 0) {
2092 http_log("Error writing output header\n");
2096 len = url_close_dyn_buf(c->fmt_ctx.pb, &c->pb_buffer);
2097 c->buffer_ptr = c->pb_buffer;
2098 c->buffer_end = c->pb_buffer + len;
2100 c->state = HTTPSTATE_SEND_DATA;
2101 c->last_packet_sent = 0;
2103 case HTTPSTATE_SEND_DATA:
2104 /* find a new packet */
2105 /* read a packet from the input stream */
2106 if (c->stream->feed)
2107 ffm_set_write_index(c->fmt_in,
2108 c->stream->feed->feed_write_index,
2109 c->stream->feed->feed_size);
2111 if (c->stream->max_time &&
2112 c->stream->max_time + c->start_time - cur_time < 0)
2113 /* We have timed out */
2114 c->state = HTTPSTATE_SEND_DATA_TRAILER;
2118 if (av_read_frame(c->fmt_in, &pkt) < 0) {
2119 if (c->stream->feed && c->stream->feed->feed_opened) {
2120 /* if coming from feed, it means we reached the end of the
2121 ffm file, so must wait for more data */
2122 c->state = HTTPSTATE_WAIT_FEED;
2123 return 1; /* state changed */
2125 if (c->stream->loop) {
2126 av_close_input_file(c->fmt_in);
2128 if (open_input_stream(c, "") < 0)
2133 /* must send trailer now because eof or error */
2134 c->state = HTTPSTATE_SEND_DATA_TRAILER;
2138 int source_index = pkt.stream_index;
2139 /* update first pts if needed */
2140 if (c->first_pts == AV_NOPTS_VALUE) {
2141 c->first_pts = av_rescale_q(pkt.dts, c->fmt_in->streams[pkt.stream_index]->time_base, AV_TIME_BASE_Q);
2142 c->start_time = cur_time;
2144 /* send it to the appropriate stream */
2145 if (c->stream->feed) {
2146 /* if coming from a feed, select the right stream */
2147 if (c->switch_pending) {
2148 c->switch_pending = 0;
2149 for(i=0;i<c->stream->nb_streams;i++) {
2150 if (c->switch_feed_streams[i] == pkt.stream_index)
2151 if (pkt.flags & PKT_FLAG_KEY)
2152 do_switch_stream(c, i);
2153 if (c->switch_feed_streams[i] >= 0)
2154 c->switch_pending = 1;
2157 for(i=0;i<c->stream->nb_streams;i++) {
2158 if (c->feed_streams[i] == pkt.stream_index) {
2159 AVStream *st = c->fmt_in->streams[source_index];
2160 pkt.stream_index = i;
2161 if (pkt.flags & PKT_FLAG_KEY &&
2162 (st->codec->codec_type == CODEC_TYPE_VIDEO ||
2163 c->stream->nb_streams == 1))
2164 c->got_key_frame = 1;
2165 if (!c->stream->send_on_key || c->got_key_frame)
2170 AVCodecContext *codec;
2171 AVStream *ist, *ost;
2173 ist = c->fmt_in->streams[source_index];
2174 /* specific handling for RTP: we use several
2175 output stream (one for each RTP
2176 connection). XXX: need more abstract handling */
2177 if (c->is_packetized) {
2178 /* compute send time and duration */
2179 c->cur_pts = av_rescale_q(pkt.dts, ist->time_base, AV_TIME_BASE_Q);
2180 if (ist->start_time != AV_NOPTS_VALUE)
2181 c->cur_pts -= av_rescale_q(ist->start_time, ist->time_base, AV_TIME_BASE_Q);
2182 c->cur_frame_duration = av_rescale_q(pkt.duration, ist->time_base, AV_TIME_BASE_Q);
2184 printf("index=%d pts=%0.3f duration=%0.6f\n",
2186 (double)c->cur_pts /
2188 (double)c->cur_frame_duration /
2191 /* find RTP context */
2192 c->packet_stream_index = pkt.stream_index;
2193 ctx = c->rtp_ctx[c->packet_stream_index];
2195 av_free_packet(&pkt);
2198 codec = ctx->streams[0]->codec;
2199 /* only one stream per RTP connection */
2200 pkt.stream_index = 0;
2204 codec = ctx->streams[pkt.stream_index]->codec;
2207 if (c->is_packetized) {
2208 int max_packet_size;
2209 if (c->rtp_protocol == RTSP_LOWER_TRANSPORT_TCP)
2210 max_packet_size = RTSP_TCP_MAX_PACKET_SIZE;
2212 max_packet_size = url_get_max_packet_size(c->rtp_handles[c->packet_stream_index]);
2213 ret = url_open_dyn_packet_buf(&ctx->pb, max_packet_size);
2215 ret = url_open_dyn_buf(&ctx->pb);
2218 /* XXX: potential leak */
2221 ost = ctx->streams[pkt.stream_index];
2223 ctx->pb->is_streamed = 1;
2224 if (pkt.dts != AV_NOPTS_VALUE)
2225 pkt.dts = av_rescale_q(pkt.dts, ist->time_base, ost->time_base);
2226 if (pkt.pts != AV_NOPTS_VALUE)
2227 pkt.pts = av_rescale_q(pkt.pts, ist->time_base, ost->time_base);
2228 pkt.duration = av_rescale_q(pkt.duration, ist->time_base, ost->time_base);
2229 if (av_write_frame(ctx, &pkt) < 0) {
2230 http_log("Error writing frame to output\n");
2231 c->state = HTTPSTATE_SEND_DATA_TRAILER;
2234 len = url_close_dyn_buf(ctx->pb, &c->pb_buffer);
2235 c->cur_frame_bytes = len;
2236 c->buffer_ptr = c->pb_buffer;
2237 c->buffer_end = c->pb_buffer + len;
2239 codec->frame_number++;
2241 av_free_packet(&pkt);
2245 av_free_packet(&pkt);
2250 case HTTPSTATE_SEND_DATA_TRAILER:
2251 /* last packet test ? */
2252 if (c->last_packet_sent || c->is_packetized)
2255 /* prepare header */
2256 if (url_open_dyn_buf(&ctx->pb) < 0) {
2257 /* XXX: potential leak */
2260 c->fmt_ctx.pb->is_streamed = 1;
2261 av_write_trailer(ctx);
2262 len = url_close_dyn_buf(ctx->pb, &c->pb_buffer);
2263 c->buffer_ptr = c->pb_buffer;
2264 c->buffer_end = c->pb_buffer + len;
2266 c->last_packet_sent = 1;
2272 /* should convert the format at the same time */
2273 /* send data starting at c->buffer_ptr to the output connection
2274 (either UDP or TCP connection) */
2275 static int http_send_data(HTTPContext *c)
2280 if (c->buffer_ptr >= c->buffer_end) {
2281 ret = http_prepare_data(c);
2285 /* state change requested */
2288 if (c->is_packetized) {
2289 /* RTP data output */
2290 len = c->buffer_end - c->buffer_ptr;
2292 /* fail safe - should never happen */
2294 c->buffer_ptr = c->buffer_end;
2297 len = (c->buffer_ptr[0] << 24) |
2298 (c->buffer_ptr[1] << 16) |
2299 (c->buffer_ptr[2] << 8) |
2301 if (len > (c->buffer_end - c->buffer_ptr))
2303 if ((get_packet_send_clock(c) - get_server_clock(c)) > 0) {
2304 /* nothing to send yet: we can wait */
2308 c->data_count += len;
2309 update_datarate(&c->datarate, c->data_count);
2311 c->stream->bytes_served += len;
2313 if (c->rtp_protocol == RTSP_LOWER_TRANSPORT_TCP) {
2314 /* RTP packets are sent inside the RTSP TCP connection */
2316 int interleaved_index, size;
2318 HTTPContext *rtsp_c;
2321 /* if no RTSP connection left, error */
2324 /* if already sending something, then wait. */
2325 if (rtsp_c->state != RTSPSTATE_WAIT_REQUEST)
2327 if (url_open_dyn_buf(&pb) < 0)
2329 interleaved_index = c->packet_stream_index * 2;
2330 /* RTCP packets are sent at odd indexes */
2331 if (c->buffer_ptr[1] == 200)
2332 interleaved_index++;
2333 /* write RTSP TCP header */
2335 header[1] = interleaved_index;
2336 header[2] = len >> 8;
2338 put_buffer(pb, header, 4);
2339 /* write RTP packet data */
2341 put_buffer(pb, c->buffer_ptr, len);
2342 size = url_close_dyn_buf(pb, &c->packet_buffer);
2343 /* prepare asynchronous TCP sending */
2344 rtsp_c->packet_buffer_ptr = c->packet_buffer;
2345 rtsp_c->packet_buffer_end = c->packet_buffer + size;
2346 c->buffer_ptr += len;
2348 /* send everything we can NOW */
2349 len = send(rtsp_c->fd, rtsp_c->packet_buffer_ptr,
2350 rtsp_c->packet_buffer_end - rtsp_c->packet_buffer_ptr, 0);
2352 rtsp_c->packet_buffer_ptr += len;
2353 if (rtsp_c->packet_buffer_ptr < rtsp_c->packet_buffer_end) {
2354 /* if we could not send all the data, we will
2355 send it later, so a new state is needed to
2356 "lock" the RTSP TCP connection */
2357 rtsp_c->state = RTSPSTATE_SEND_PACKET;
2360 /* all data has been sent */
2361 av_freep(&c->packet_buffer);
2363 /* send RTP packet directly in UDP */
2365 url_write(c->rtp_handles[c->packet_stream_index],
2366 c->buffer_ptr, len);
2367 c->buffer_ptr += len;
2368 /* here we continue as we can send several packets per 10 ms slot */
2371 /* TCP data output */
2372 len = send(c->fd, c->buffer_ptr, c->buffer_end - c->buffer_ptr, 0);
2374 if (ff_neterrno() != FF_NETERROR(EAGAIN) &&
2375 ff_neterrno() != FF_NETERROR(EINTR))
2376 /* error : close connection */
2381 c->buffer_ptr += len;
2383 c->data_count += len;
2384 update_datarate(&c->datarate, c->data_count);
2386 c->stream->bytes_served += len;
2394 static int http_start_receive_data(HTTPContext *c)
2398 if (c->stream->feed_opened)
2401 /* Don't permit writing to this one */
2402 if (c->stream->readonly)
2406 fd = open(c->stream->feed_filename, O_RDWR);
2408 http_log("Error opening feeder file: %s\n", strerror(errno));
2413 if ((c->stream->feed_write_index = ffm_read_write_index(fd)) < 0) {
2414 http_log("Error reading write index from feed file: %s\n", strerror(errno));
2417 c->stream->feed_size = lseek(fd, 0, SEEK_END);
2418 lseek(fd, 0, SEEK_SET);
2420 /* init buffer input */
2421 c->buffer_ptr = c->buffer;
2422 c->buffer_end = c->buffer + FFM_PACKET_SIZE;
2423 c->stream->feed_opened = 1;
2427 static int http_receive_data(HTTPContext *c)
2431 if (c->buffer_end > c->buffer_ptr) {
2434 len = recv(c->fd, c->buffer_ptr, c->buffer_end - c->buffer_ptr, 0);
2436 if (ff_neterrno() != FF_NETERROR(EAGAIN) &&
2437 ff_neterrno() != FF_NETERROR(EINTR))
2438 /* error : close connection */
2440 } else if (len == 0)
2441 /* end of connection : close it */
2444 c->buffer_ptr += len;
2445 c->data_count += len;
2446 update_datarate(&c->datarate, c->data_count);
2450 if (c->buffer_ptr - c->buffer >= 2 && c->data_count > FFM_PACKET_SIZE) {
2451 if (c->buffer[0] != 'f' ||
2452 c->buffer[1] != 'm') {
2453 http_log("Feed stream has become desynchronized -- disconnecting\n");
2458 if (c->buffer_ptr >= c->buffer_end) {
2459 FFStream *feed = c->stream;
2460 /* a packet has been received : write it in the store, except
2462 if (c->data_count > FFM_PACKET_SIZE) {
2464 // printf("writing pos=0x%"PRIx64" size=0x%"PRIx64"\n", feed->feed_write_index, feed->feed_size);
2465 /* XXX: use llseek or url_seek */
2466 lseek(c->feed_fd, feed->feed_write_index, SEEK_SET);
2467 if (write(c->feed_fd, c->buffer, FFM_PACKET_SIZE) < 0) {
2468 http_log("Error writing to feed file: %s\n", strerror(errno));
2472 feed->feed_write_index += FFM_PACKET_SIZE;
2473 /* update file size */
2474 if (feed->feed_write_index > c->stream->feed_size)
2475 feed->feed_size = feed->feed_write_index;
2477 /* handle wrap around if max file size reached */
2478 if (c->stream->feed_max_size && feed->feed_write_index >= c->stream->feed_max_size)
2479 feed->feed_write_index = FFM_PACKET_SIZE;
2482 if (ffm_write_write_index(c->feed_fd, feed->feed_write_index) < 0) {
2483 http_log("Error writing index to feed file: %s\n", strerror(errno));
2487 /* wake up any waiting connections */
2488 for(c1 = first_http_ctx; c1 != NULL; c1 = c1->next) {
2489 if (c1->state == HTTPSTATE_WAIT_FEED &&
2490 c1->stream->feed == c->stream->feed)
2491 c1->state = HTTPSTATE_SEND_DATA;
2494 /* We have a header in our hands that contains useful data */
2495 AVFormatContext *s = NULL;
2497 AVInputFormat *fmt_in;
2500 /* use feed output format name to find corresponding input format */
2501 fmt_in = av_find_input_format(feed->fmt->name);
2505 url_open_buf(&pb, c->buffer, c->buffer_end - c->buffer, URL_RDONLY);
2506 pb->is_streamed = 1;
2508 if (av_open_input_stream(&s, pb, c->stream->feed_filename, fmt_in, NULL) < 0) {
2513 /* Now we have the actual streams */
2514 if (s->nb_streams != feed->nb_streams) {
2515 av_close_input_stream(s);
2520 for (i = 0; i < s->nb_streams; i++) {
2521 AVStream *fst = feed->streams[i];
2522 AVStream *st = s->streams[i];
2523 memcpy(fst->codec, st->codec, sizeof(AVCodecContext));
2524 if (fst->codec->extradata_size) {
2525 fst->codec->extradata = av_malloc(fst->codec->extradata_size);
2526 if (!fst->codec->extradata)
2528 memcpy(fst->codec->extradata, st->codec->extradata,
2529 fst->codec->extradata_size);
2533 av_close_input_stream(s);
2536 c->buffer_ptr = c->buffer;
2541 c->stream->feed_opened = 0;
2543 /* wake up any waiting connections to stop waiting for feed */
2544 for(c1 = first_http_ctx; c1 != NULL; c1 = c1->next) {
2545 if (c1->state == HTTPSTATE_WAIT_FEED &&
2546 c1->stream->feed == c->stream->feed)
2547 c1->state = HTTPSTATE_SEND_DATA_TRAILER;
2552 /********************************************************************/
2555 static void rtsp_reply_header(HTTPContext *c, enum RTSPStatusCode error_number)
2562 switch(error_number) {
2563 case RTSP_STATUS_OK:
2566 case RTSP_STATUS_METHOD:
2567 str = "Method Not Allowed";
2569 case RTSP_STATUS_BANDWIDTH:
2570 str = "Not Enough Bandwidth";
2572 case RTSP_STATUS_SESSION:
2573 str = "Session Not Found";
2575 case RTSP_STATUS_STATE:
2576 str = "Method Not Valid in This State";
2578 case RTSP_STATUS_AGGREGATE:
2579 str = "Aggregate operation not allowed";
2581 case RTSP_STATUS_ONLY_AGGREGATE:
2582 str = "Only aggregate operation allowed";
2584 case RTSP_STATUS_TRANSPORT:
2585 str = "Unsupported transport";
2587 case RTSP_STATUS_INTERNAL:
2588 str = "Internal Server Error";
2590 case RTSP_STATUS_SERVICE:
2591 str = "Service Unavailable";
2593 case RTSP_STATUS_VERSION:
2594 str = "RTSP Version not supported";
2597 str = "Unknown Error";
2601 url_fprintf(c->pb, "RTSP/1.0 %d %s\r\n", error_number, str);
2602 url_fprintf(c->pb, "CSeq: %d\r\n", c->seq);
2604 /* output GMT time */
2608 p = buf2 + strlen(p) - 1;
2611 url_fprintf(c->pb, "Date: %s GMT\r\n", buf2);
2614 static void rtsp_reply_error(HTTPContext *c, enum RTSPStatusCode error_number)
2616 rtsp_reply_header(c, error_number);
2617 url_fprintf(c->pb, "\r\n");
2620 static int rtsp_parse_request(HTTPContext *c)
2622 const char *p, *p1, *p2;
2628 RTSPMessageHeader header1, *header = &header1;
2630 c->buffer_ptr[0] = '\0';
2633 get_word(cmd, sizeof(cmd), &p);
2634 get_word(url, sizeof(url), &p);
2635 get_word(protocol, sizeof(protocol), &p);
2637 av_strlcpy(c->method, cmd, sizeof(c->method));
2638 av_strlcpy(c->url, url, sizeof(c->url));
2639 av_strlcpy(c->protocol, protocol, sizeof(c->protocol));
2641 if (url_open_dyn_buf(&c->pb) < 0) {
2642 /* XXX: cannot do more */
2643 c->pb = NULL; /* safety */
2647 /* check version name */
2648 if (strcmp(protocol, "RTSP/1.0") != 0) {
2649 rtsp_reply_error(c, RTSP_STATUS_VERSION);
2653 /* parse each header line */
2654 memset(header, 0, sizeof(*header));
2655 /* skip to next line */
2656 while (*p != '\n' && *p != '\0')
2660 while (*p != '\0') {
2661 p1 = strchr(p, '\n');
2665 if (p2 > p && p2[-1] == '\r')
2667 /* skip empty line */
2671 if (len > sizeof(line) - 1)
2672 len = sizeof(line) - 1;
2673 memcpy(line, p, len);
2675 rtsp_parse_line(header, line);
2679 /* handle sequence number */
2680 c->seq = header->seq;
2682 if (!strcmp(cmd, "DESCRIBE"))
2683 rtsp_cmd_describe(c, url);
2684 else if (!strcmp(cmd, "OPTIONS"))
2685 rtsp_cmd_options(c, url);
2686 else if (!strcmp(cmd, "SETUP"))
2687 rtsp_cmd_setup(c, url, header);
2688 else if (!strcmp(cmd, "PLAY"))
2689 rtsp_cmd_play(c, url, header);
2690 else if (!strcmp(cmd, "PAUSE"))
2691 rtsp_cmd_pause(c, url, header);
2692 else if (!strcmp(cmd, "TEARDOWN"))
2693 rtsp_cmd_teardown(c, url, header);
2695 rtsp_reply_error(c, RTSP_STATUS_METHOD);
2698 len = url_close_dyn_buf(c->pb, &c->pb_buffer);
2699 c->pb = NULL; /* safety */
2701 /* XXX: cannot do more */
2704 c->buffer_ptr = c->pb_buffer;
2705 c->buffer_end = c->pb_buffer + len;
2706 c->state = RTSPSTATE_SEND_REPLY;
2710 static int prepare_sdp_description(FFStream *stream, uint8_t **pbuffer,
2711 struct in_addr my_ip)
2713 AVFormatContext *avc;
2714 AVStream avs[MAX_STREAMS];
2717 avc = avformat_alloc_context();
2721 av_metadata_set(&avc->metadata, "title",
2722 stream->title[0] ? stream->title : "No Title");
2723 avc->nb_streams = stream->nb_streams;
2724 if (stream->is_multicast) {
2725 snprintf(avc->filename, 1024, "rtp://%s:%d?multicast=1?ttl=%d",
2726 inet_ntoa(stream->multicast_ip),
2727 stream->multicast_port, stream->multicast_ttl);
2730 for(i = 0; i < stream->nb_streams; i++) {
2731 avc->streams[i] = &avs[i];
2732 avc->streams[i]->codec = stream->streams[i]->codec;
2734 *pbuffer = av_mallocz(2048);
2735 avf_sdp_create(&avc, 1, *pbuffer, 2048);
2738 return strlen(*pbuffer);
2741 static void rtsp_cmd_options(HTTPContext *c, const char *url)
2743 // rtsp_reply_header(c, RTSP_STATUS_OK);
2744 url_fprintf(c->pb, "RTSP/1.0 %d %s\r\n", RTSP_STATUS_OK, "OK");
2745 url_fprintf(c->pb, "CSeq: %d\r\n", c->seq);
2746 url_fprintf(c->pb, "Public: %s\r\n", "OPTIONS, DESCRIBE, SETUP, TEARDOWN, PLAY, PAUSE");
2747 url_fprintf(c->pb, "\r\n");
2750 static void rtsp_cmd_describe(HTTPContext *c, const char *url)
2756 int content_length, len;
2757 struct sockaddr_in my_addr;
2759 /* find which url is asked */
2760 url_split(NULL, 0, NULL, 0, NULL, 0, NULL, path1, sizeof(path1), url);
2765 for(stream = first_stream; stream != NULL; stream = stream->next) {
2766 if (!stream->is_feed &&
2767 stream->fmt && !strcmp(stream->fmt->name, "rtp") &&
2768 !strcmp(path, stream->filename)) {
2772 /* no stream found */
2773 rtsp_reply_error(c, RTSP_STATUS_SERVICE); /* XXX: right error ? */
2777 /* prepare the media description in sdp format */
2779 /* get the host IP */
2780 len = sizeof(my_addr);
2781 getsockname(c->fd, (struct sockaddr *)&my_addr, &len);
2782 content_length = prepare_sdp_description(stream, &content, my_addr.sin_addr);
2783 if (content_length < 0) {
2784 rtsp_reply_error(c, RTSP_STATUS_INTERNAL);
2787 rtsp_reply_header(c, RTSP_STATUS_OK);
2788 url_fprintf(c->pb, "Content-Type: application/sdp\r\n");
2789 url_fprintf(c->pb, "Content-Length: %d\r\n", content_length);
2790 url_fprintf(c->pb, "\r\n");
2791 put_buffer(c->pb, content, content_length);
2794 static HTTPContext *find_rtp_session(const char *session_id)
2798 if (session_id[0] == '\0')
2801 for(c = first_http_ctx; c != NULL; c = c->next) {
2802 if (!strcmp(c->session_id, session_id))
2808 static RTSPTransportField *find_transport(RTSPMessageHeader *h, enum RTSPLowerTransport lower_transport)
2810 RTSPTransportField *th;
2813 for(i=0;i<h->nb_transports;i++) {
2814 th = &h->transports[i];
2815 if (th->lower_transport == lower_transport)
2821 static void rtsp_cmd_setup(HTTPContext *c, const char *url,
2822 RTSPMessageHeader *h)
2825 int stream_index, port;
2830 RTSPTransportField *th;
2831 struct sockaddr_in dest_addr;
2832 RTSPActionServerSetup setup;
2834 /* find which url is asked */
2835 url_split(NULL, 0, NULL, 0, NULL, 0, NULL, path1, sizeof(path1), url);
2840 /* now check each stream */
2841 for(stream = first_stream; stream != NULL; stream = stream->next) {
2842 if (!stream->is_feed &&
2843 stream->fmt && !strcmp(stream->fmt->name, "rtp")) {
2844 /* accept aggregate filenames only if single stream */
2845 if (!strcmp(path, stream->filename)) {
2846 if (stream->nb_streams != 1) {
2847 rtsp_reply_error(c, RTSP_STATUS_AGGREGATE);
2854 for(stream_index = 0; stream_index < stream->nb_streams;
2856 snprintf(buf, sizeof(buf), "%s/streamid=%d",
2857 stream->filename, stream_index);
2858 if (!strcmp(path, buf))
2863 /* no stream found */
2864 rtsp_reply_error(c, RTSP_STATUS_SERVICE); /* XXX: right error ? */
2868 /* generate session id if needed */
2869 if (h->session_id[0] == '\0')
2870 snprintf(h->session_id, sizeof(h->session_id), "%08x%08x",
2871 av_lfg_get(&random_state), av_lfg_get(&random_state));
2873 /* find rtp session, and create it if none found */
2874 rtp_c = find_rtp_session(h->session_id);
2876 /* always prefer UDP */
2877 th = find_transport(h, RTSP_LOWER_TRANSPORT_UDP);
2879 th = find_transport(h, RTSP_LOWER_TRANSPORT_TCP);
2881 rtsp_reply_error(c, RTSP_STATUS_TRANSPORT);
2886 rtp_c = rtp_new_connection(&c->from_addr, stream, h->session_id,
2887 th->lower_transport);
2889 rtsp_reply_error(c, RTSP_STATUS_BANDWIDTH);
2893 /* open input stream */
2894 if (open_input_stream(rtp_c, "") < 0) {
2895 rtsp_reply_error(c, RTSP_STATUS_INTERNAL);
2900 /* test if stream is OK (test needed because several SETUP needs
2901 to be done for a given file) */
2902 if (rtp_c->stream != stream) {
2903 rtsp_reply_error(c, RTSP_STATUS_SERVICE);
2907 /* test if stream is already set up */
2908 if (rtp_c->rtp_ctx[stream_index]) {
2909 rtsp_reply_error(c, RTSP_STATUS_STATE);
2913 /* check transport */
2914 th = find_transport(h, rtp_c->rtp_protocol);
2915 if (!th || (th->lower_transport == RTSP_LOWER_TRANSPORT_UDP &&
2916 th->client_port_min <= 0)) {
2917 rtsp_reply_error(c, RTSP_STATUS_TRANSPORT);
2921 /* setup default options */
2922 setup.transport_option[0] = '\0';
2923 dest_addr = rtp_c->from_addr;
2924 dest_addr.sin_port = htons(th->client_port_min);
2927 if (rtp_new_av_stream(rtp_c, stream_index, &dest_addr, c) < 0) {
2928 rtsp_reply_error(c, RTSP_STATUS_TRANSPORT);
2932 /* now everything is OK, so we can send the connection parameters */
2933 rtsp_reply_header(c, RTSP_STATUS_OK);
2935 url_fprintf(c->pb, "Session: %s\r\n", rtp_c->session_id);
2937 switch(rtp_c->rtp_protocol) {
2938 case RTSP_LOWER_TRANSPORT_UDP:
2939 port = rtp_get_local_port(rtp_c->rtp_handles[stream_index]);
2940 url_fprintf(c->pb, "Transport: RTP/AVP/UDP;unicast;"
2941 "client_port=%d-%d;server_port=%d-%d",
2942 th->client_port_min, th->client_port_min + 1,
2945 case RTSP_LOWER_TRANSPORT_TCP:
2946 url_fprintf(c->pb, "Transport: RTP/AVP/TCP;interleaved=%d-%d",
2947 stream_index * 2, stream_index * 2 + 1);
2952 if (setup.transport_option[0] != '\0')
2953 url_fprintf(c->pb, ";%s", setup.transport_option);
2954 url_fprintf(c->pb, "\r\n");
2957 url_fprintf(c->pb, "\r\n");
2961 /* find an rtp connection by using the session ID. Check consistency
2963 static HTTPContext *find_rtp_session_with_url(const char *url,
2964 const char *session_id)
2972 rtp_c = find_rtp_session(session_id);
2976 /* find which url is asked */
2977 url_split(NULL, 0, NULL, 0, NULL, 0, NULL, path1, sizeof(path1), url);
2981 if(!strcmp(path, rtp_c->stream->filename)) return rtp_c;
2982 for(s=0; s<rtp_c->stream->nb_streams; ++s) {
2983 snprintf(buf, sizeof(buf), "%s/streamid=%d",
2984 rtp_c->stream->filename, s);
2985 if(!strncmp(path, buf, sizeof(buf))) {
2986 // XXX: Should we reply with RTSP_STATUS_ONLY_AGGREGATE if nb_streams>1?
2993 static void rtsp_cmd_play(HTTPContext *c, const char *url, RTSPMessageHeader *h)
2997 rtp_c = find_rtp_session_with_url(url, h->session_id);
2999 rtsp_reply_error(c, RTSP_STATUS_SESSION);
3003 if (rtp_c->state != HTTPSTATE_SEND_DATA &&
3004 rtp_c->state != HTTPSTATE_WAIT_FEED &&
3005 rtp_c->state != HTTPSTATE_READY) {
3006 rtsp_reply_error(c, RTSP_STATUS_STATE);
3011 /* XXX: seek in stream */
3012 if (h->range_start != AV_NOPTS_VALUE) {
3013 printf("range_start=%0.3f\n", (double)h->range_start / AV_TIME_BASE);
3014 av_seek_frame(rtp_c->fmt_in, -1, h->range_start);
3018 rtp_c->state = HTTPSTATE_SEND_DATA;
3020 /* now everything is OK, so we can send the connection parameters */
3021 rtsp_reply_header(c, RTSP_STATUS_OK);
3023 url_fprintf(c->pb, "Session: %s\r\n", rtp_c->session_id);
3024 url_fprintf(c->pb, "\r\n");
3027 static void rtsp_cmd_pause(HTTPContext *c, const char *url, RTSPMessageHeader *h)
3031 rtp_c = find_rtp_session_with_url(url, h->session_id);
3033 rtsp_reply_error(c, RTSP_STATUS_SESSION);
3037 if (rtp_c->state != HTTPSTATE_SEND_DATA &&
3038 rtp_c->state != HTTPSTATE_WAIT_FEED) {
3039 rtsp_reply_error(c, RTSP_STATUS_STATE);
3043 rtp_c->state = HTTPSTATE_READY;
3044 rtp_c->first_pts = AV_NOPTS_VALUE;
3045 /* now everything is OK, so we can send the connection parameters */
3046 rtsp_reply_header(c, RTSP_STATUS_OK);
3048 url_fprintf(c->pb, "Session: %s\r\n", rtp_c->session_id);
3049 url_fprintf(c->pb, "\r\n");
3052 static void rtsp_cmd_teardown(HTTPContext *c, const char *url, RTSPMessageHeader *h)
3055 char session_id[32];
3057 rtp_c = find_rtp_session_with_url(url, h->session_id);
3059 rtsp_reply_error(c, RTSP_STATUS_SESSION);
3063 av_strlcpy(session_id, rtp_c->session_id, sizeof(session_id));
3065 /* abort the session */
3066 close_connection(rtp_c);
3068 /* now everything is OK, so we can send the connection parameters */
3069 rtsp_reply_header(c, RTSP_STATUS_OK);
3071 url_fprintf(c->pb, "Session: %s\r\n", session_id);
3072 url_fprintf(c->pb, "\r\n");
3076 /********************************************************************/
3079 static HTTPContext *rtp_new_connection(struct sockaddr_in *from_addr,
3080 FFStream *stream, const char *session_id,
3081 enum RTSPLowerTransport rtp_protocol)
3083 HTTPContext *c = NULL;
3084 const char *proto_str;
3086 /* XXX: should output a warning page when coming
3087 close to the connection limit */
3088 if (nb_connections >= nb_max_connections)
3091 /* add a new connection */
3092 c = av_mallocz(sizeof(HTTPContext));
3097 c->poll_entry = NULL;
3098 c->from_addr = *from_addr;
3099 c->buffer_size = IOBUFFER_INIT_SIZE;
3100 c->buffer = av_malloc(c->buffer_size);
3105 av_strlcpy(c->session_id, session_id, sizeof(c->session_id));
3106 c->state = HTTPSTATE_READY;
3107 c->is_packetized = 1;
3108 c->rtp_protocol = rtp_protocol;
3110 /* protocol is shown in statistics */
3111 switch(c->rtp_protocol) {
3112 case RTSP_LOWER_TRANSPORT_UDP_MULTICAST:
3113 proto_str = "MCAST";
3115 case RTSP_LOWER_TRANSPORT_UDP:
3118 case RTSP_LOWER_TRANSPORT_TCP:
3125 av_strlcpy(c->protocol, "RTP/", sizeof(c->protocol));
3126 av_strlcat(c->protocol, proto_str, sizeof(c->protocol));
3128 current_bandwidth += stream->bandwidth;
3130 c->next = first_http_ctx;
3142 /* add a new RTP stream in an RTP connection (used in RTSP SETUP
3143 command). If RTP/TCP protocol is used, TCP connection 'rtsp_c' is
3145 static int rtp_new_av_stream(HTTPContext *c,
3146 int stream_index, struct sockaddr_in *dest_addr,
3147 HTTPContext *rtsp_c)
3149 AVFormatContext *ctx;
3152 URLContext *h = NULL;
3154 int max_packet_size;
3156 /* now we can open the relevant output stream */
3157 ctx = avformat_alloc_context();
3160 ctx->oformat = guess_format("rtp", NULL, NULL);
3162 st = av_mallocz(sizeof(AVStream));
3165 st->codec= avcodec_alloc_context();
3166 ctx->nb_streams = 1;
3167 ctx->streams[0] = st;
3169 if (!c->stream->feed ||
3170 c->stream->feed == c->stream)
3171 memcpy(st, c->stream->streams[stream_index], sizeof(AVStream));
3174 c->stream->feed->streams[c->stream->feed_streams[stream_index]],
3176 st->priv_data = NULL;
3178 /* build destination RTP address */
3179 ipaddr = inet_ntoa(dest_addr->sin_addr);
3181 switch(c->rtp_protocol) {
3182 case RTSP_LOWER_TRANSPORT_UDP:
3183 case RTSP_LOWER_TRANSPORT_UDP_MULTICAST:
3186 /* XXX: also pass as parameter to function ? */
3187 if (c->stream->is_multicast) {
3189 ttl = c->stream->multicast_ttl;
3192 snprintf(ctx->filename, sizeof(ctx->filename),
3193 "rtp://%s:%d?multicast=1&ttl=%d",
3194 ipaddr, ntohs(dest_addr->sin_port), ttl);
3196 snprintf(ctx->filename, sizeof(ctx->filename),
3197 "rtp://%s:%d", ipaddr, ntohs(dest_addr->sin_port));
3200 if (url_open(&h, ctx->filename, URL_WRONLY) < 0)
3202 c->rtp_handles[stream_index] = h;
3203 max_packet_size = url_get_max_packet_size(h);
3205 case RTSP_LOWER_TRANSPORT_TCP:
3208 max_packet_size = RTSP_TCP_MAX_PACKET_SIZE;
3214 http_log("%s:%d - - \"PLAY %s/streamid=%d %s\"\n",
3215 ipaddr, ntohs(dest_addr->sin_port),
3216 c->stream->filename, stream_index, c->protocol);
3218 /* normally, no packets should be output here, but the packet size may be checked */
3219 if (url_open_dyn_packet_buf(&ctx->pb, max_packet_size) < 0) {
3220 /* XXX: close stream */
3223 av_set_parameters(ctx, NULL);
3224 if (av_write_header(ctx) < 0) {
3231 url_close_dyn_buf(ctx->pb, &dummy_buf);
3234 c->rtp_ctx[stream_index] = ctx;
3238 /********************************************************************/
3239 /* ffserver initialization */
3241 static AVStream *add_av_stream1(FFStream *stream, AVCodecContext *codec)
3245 fst = av_mallocz(sizeof(AVStream));
3248 fst->codec= avcodec_alloc_context();
3249 fst->priv_data = av_mallocz(sizeof(FeedData));
3250 memcpy(fst->codec, codec, sizeof(AVCodecContext));
3251 fst->index = stream->nb_streams;
3252 av_set_pts_info(fst, 33, 1, 90000);
3253 stream->streams[stream->nb_streams++] = fst;
3257 /* return the stream number in the feed */
3258 static int add_av_stream(FFStream *feed, AVStream *st)
3261 AVCodecContext *av, *av1;
3265 for(i=0;i<feed->nb_streams;i++) {
3266 st = feed->streams[i];
3268 if (av1->codec_id == av->codec_id &&
3269 av1->codec_type == av->codec_type &&
3270 av1->bit_rate == av->bit_rate) {
3272 switch(av->codec_type) {
3273 case CODEC_TYPE_AUDIO:
3274 if (av1->channels == av->channels &&
3275 av1->sample_rate == av->sample_rate)
3278 case CODEC_TYPE_VIDEO:
3279 if (av1->width == av->width &&
3280 av1->height == av->height &&
3281 av1->time_base.den == av->time_base.den &&
3282 av1->time_base.num == av->time_base.num &&
3283 av1->gop_size == av->gop_size)
3292 fst = add_av_stream1(feed, av);
3295 return feed->nb_streams - 1;
3300 static void remove_stream(FFStream *stream)
3304 while (*ps != NULL) {
3312 /* specific mpeg4 handling : we extract the raw parameters */
3313 static void extract_mpeg4_header(AVFormatContext *infile)
3315 int mpeg4_count, i, size;
3321 for(i=0;i<infile->nb_streams;i++) {
3322 st = infile->streams[i];
3323 if (st->codec->codec_id == CODEC_ID_MPEG4 &&
3324 st->codec->extradata_size == 0) {
3331 printf("MPEG4 without extra data: trying to find header in %s\n", infile->filename);
3332 while (mpeg4_count > 0) {
3333 if (av_read_packet(infile, &pkt) < 0)
3335 st = infile->streams[pkt.stream_index];
3336 if (st->codec->codec_id == CODEC_ID_MPEG4 &&
3337 st->codec->extradata_size == 0) {
3338 av_freep(&st->codec->extradata);
3339 /* fill extradata with the header */
3340 /* XXX: we make hard suppositions here ! */
3342 while (p < pkt.data + pkt.size - 4) {
3343 /* stop when vop header is found */
3344 if (p[0] == 0x00 && p[1] == 0x00 &&
3345 p[2] == 0x01 && p[3] == 0xb6) {
3346 size = p - pkt.data;
3347 // av_hex_dump_log(infile, AV_LOG_DEBUG, pkt.data, size);
3348 st->codec->extradata = av_malloc(size);
3349 st->codec->extradata_size = size;
3350 memcpy(st->codec->extradata, pkt.data, size);
3357 av_free_packet(&pkt);
3361 /* compute the needed AVStream for each file */
3362 static void build_file_streams(void)
3364 FFStream *stream, *stream_next;
3365 AVFormatContext *infile;
3368 /* gather all streams */
3369 for(stream = first_stream; stream != NULL; stream = stream_next) {
3370 stream_next = stream->next;
3371 if (stream->stream_type == STREAM_TYPE_LIVE &&
3373 /* the stream comes from a file */
3374 /* try to open the file */
3376 stream->ap_in = av_mallocz(sizeof(AVFormatParameters));
3377 if (stream->fmt && !strcmp(stream->fmt->name, "rtp")) {
3378 /* specific case : if transport stream output to RTP,
3379 we use a raw transport stream reader */
3380 stream->ap_in->mpeg2ts_raw = 1;
3381 stream->ap_in->mpeg2ts_compute_pcr = 1;
3384 if ((ret = av_open_input_file(&infile, stream->feed_filename,
3385 stream->ifmt, 0, stream->ap_in)) < 0) {
3386 http_log("could not open %s: %d\n", stream->feed_filename, ret);
3387 /* remove stream (no need to spend more time on it) */
3389 remove_stream(stream);
3391 /* find all the AVStreams inside and reference them in
3393 if (av_find_stream_info(infile) < 0) {
3394 http_log("Could not find codec parameters from '%s'\n",
3395 stream->feed_filename);
3396 av_close_input_file(infile);
3399 extract_mpeg4_header(infile);
3401 for(i=0;i<infile->nb_streams;i++)
3402 add_av_stream1(stream, infile->streams[i]->codec);
3404 av_close_input_file(infile);
3410 /* compute the needed AVStream for each feed */
3411 static void build_feed_streams(void)
3413 FFStream *stream, *feed;
3416 /* gather all streams */
3417 for(stream = first_stream; stream != NULL; stream = stream->next) {
3418 feed = stream->feed;
3420 if (!stream->is_feed) {
3421 /* we handle a stream coming from a feed */
3422 for(i=0;i<stream->nb_streams;i++)
3423 stream->feed_streams[i] = add_av_stream(feed, stream->streams[i]);
3428 /* gather all streams */
3429 for(stream = first_stream; stream != NULL; stream = stream->next) {
3430 feed = stream->feed;
3432 if (stream->is_feed) {
3433 for(i=0;i<stream->nb_streams;i++)
3434 stream->feed_streams[i] = i;
3439 /* create feed files if needed */
3440 for(feed = first_feed; feed != NULL; feed = feed->next_feed) {
3443 if (url_exist(feed->feed_filename)) {
3444 /* See if it matches */
3448 if (av_open_input_file(&s, feed->feed_filename, NULL, FFM_PACKET_SIZE, NULL) >= 0) {
3449 /* Now see if it matches */
3450 if (s->nb_streams == feed->nb_streams) {
3452 for(i=0;i<s->nb_streams;i++) {
3454 sf = feed->streams[i];
3457 if (sf->index != ss->index ||
3459 http_log("Index & Id do not match for stream %d (%s)\n",
3460 i, feed->feed_filename);
3463 AVCodecContext *ccf, *ccs;
3467 #define CHECK_CODEC(x) (ccf->x != ccs->x)
3469 if (CHECK_CODEC(codec) || CHECK_CODEC(codec_type)) {
3470 http_log("Codecs do not match for stream %d\n", i);
3472 } else if (CHECK_CODEC(bit_rate) || CHECK_CODEC(flags)) {
3473 http_log("Codec bitrates do not match for stream %d\n", i);
3475 } else if (ccf->codec_type == CODEC_TYPE_VIDEO) {
3476 if (CHECK_CODEC(time_base.den) ||
3477 CHECK_CODEC(time_base.num) ||
3478 CHECK_CODEC(width) ||
3479 CHECK_CODEC(height)) {
3480 http_log("Codec width, height and framerate do not match for stream %d\n", i);
3483 } else if (ccf->codec_type == CODEC_TYPE_AUDIO) {
3484 if (CHECK_CODEC(sample_rate) ||
3485 CHECK_CODEC(channels) ||
3486 CHECK_CODEC(frame_size)) {
3487 http_log("Codec sample_rate, channels, frame_size do not match for stream %d\n", i);
3491 http_log("Unknown codec type\n");
3499 http_log("Deleting feed file '%s' as stream counts differ (%d != %d)\n",
3500 feed->feed_filename, s->nb_streams, feed->nb_streams);
3502 av_close_input_file(s);
3504 http_log("Deleting feed file '%s' as it appears to be corrupt\n",
3505 feed->feed_filename);
3508 if (feed->readonly) {
3509 http_log("Unable to delete feed file '%s' as it is marked readonly\n",
3510 feed->feed_filename);
3513 unlink(feed->feed_filename);
3516 if (!url_exist(feed->feed_filename)) {
3517 AVFormatContext s1 = {0}, *s = &s1;
3519 if (feed->readonly) {
3520 http_log("Unable to create feed file '%s' as it is marked readonly\n",
3521 feed->feed_filename);
3525 /* only write the header of the ffm file */
3526 if (url_fopen(&s->pb, feed->feed_filename, URL_WRONLY) < 0) {
3527 http_log("Could not open output feed file '%s'\n",
3528 feed->feed_filename);
3531 s->oformat = feed->fmt;
3532 s->nb_streams = feed->nb_streams;
3533 for(i=0;i<s->nb_streams;i++) {
3535 st = feed->streams[i];
3538 av_set_parameters(s, NULL);
3539 if (av_write_header(s) < 0) {
3540 http_log("Container doesn't supports the required parameters\n");
3543 /* XXX: need better api */
3544 av_freep(&s->priv_data);
3547 /* get feed size and write index */
3548 fd = open(feed->feed_filename, O_RDONLY);
3550 http_log("Could not open output feed file '%s'\n",
3551 feed->feed_filename);
3555 feed->feed_write_index = ffm_read_write_index(fd);
3556 feed->feed_size = lseek(fd, 0, SEEK_END);
3557 /* ensure that we do not wrap before the end of file */
3558 if (feed->feed_max_size && feed->feed_max_size < feed->feed_size)
3559 feed->feed_max_size = feed->feed_size;
3565 /* compute the bandwidth used by each stream */
3566 static void compute_bandwidth(void)
3572 for(stream = first_stream; stream != NULL; stream = stream->next) {
3574 for(i=0;i<stream->nb_streams;i++) {
3575 AVStream *st = stream->streams[i];
3576 switch(st->codec->codec_type) {
3577 case CODEC_TYPE_AUDIO:
3578 case CODEC_TYPE_VIDEO:
3579 bandwidth += st->codec->bit_rate;
3585 stream->bandwidth = (bandwidth + 999) / 1000;
3589 static void get_arg(char *buf, int buf_size, const char **pp)
3596 while (isspace(*p)) p++;
3599 if (*p == '\"' || *p == '\'')
3611 if ((q - buf) < buf_size - 1)
3616 if (quote && *p == quote)
3621 /* add a codec and set the default parameters */
3622 static void add_codec(FFStream *stream, AVCodecContext *av)
3626 /* compute default parameters */
3627 switch(av->codec_type) {
3628 case CODEC_TYPE_AUDIO:
3629 if (av->bit_rate == 0)
3630 av->bit_rate = 64000;
3631 if (av->sample_rate == 0)
3632 av->sample_rate = 22050;
3633 if (av->channels == 0)
3636 case CODEC_TYPE_VIDEO:
3637 if (av->bit_rate == 0)
3638 av->bit_rate = 64000;
3639 if (av->time_base.num == 0){
3640 av->time_base.den = 5;
3641 av->time_base.num = 1;
3643 if (av->width == 0 || av->height == 0) {
3647 /* Bitrate tolerance is less for streaming */
3648 if (av->bit_rate_tolerance == 0)
3649 av->bit_rate_tolerance = FFMAX(av->bit_rate / 4,
3650 (int64_t)av->bit_rate*av->time_base.num/av->time_base.den);
3655 if (av->max_qdiff == 0)
3657 av->qcompress = 0.5;
3660 if (!av->nsse_weight)
3661 av->nsse_weight = 8;
3663 av->frame_skip_cmp = FF_CMP_DCTMAX;
3664 av->me_method = ME_EPZS;
3665 av->rc_buffer_aggressivity = 1.0;
3668 av->rc_eq = "tex^qComp";
3669 if (!av->i_quant_factor)
3670 av->i_quant_factor = -0.8;
3671 if (!av->b_quant_factor)
3672 av->b_quant_factor = 1.25;
3673 if (!av->b_quant_offset)
3674 av->b_quant_offset = 1.25;
3675 if (!av->rc_max_rate)
3676 av->rc_max_rate = av->bit_rate * 2;
3678 if (av->rc_max_rate && !av->rc_buffer_size) {
3679 av->rc_buffer_size = av->rc_max_rate;
3688 st = av_mallocz(sizeof(AVStream));
3691 st->codec = avcodec_alloc_context();
3692 stream->streams[stream->nb_streams++] = st;
3693 memcpy(st->codec, av, sizeof(AVCodecContext));
3696 static enum CodecID opt_audio_codec(const char *arg)
3698 AVCodec *p= avcodec_find_encoder_by_name(arg);
3700 if (p == NULL || p->type != CODEC_TYPE_AUDIO)
3701 return CODEC_ID_NONE;
3706 static enum CodecID opt_video_codec(const char *arg)
3708 AVCodec *p= avcodec_find_encoder_by_name(arg);
3710 if (p == NULL || p->type != CODEC_TYPE_VIDEO)
3711 return CODEC_ID_NONE;
3716 /* simplistic plugin support */
3719 static void load_module(const char *filename)
3722 void (*init_func)(void);
3723 dll = dlopen(filename, RTLD_NOW);
3725 fprintf(stderr, "Could not load module '%s' - %s\n",
3726 filename, dlerror());
3730 init_func = dlsym(dll, "ffserver_module_init");
3733 "%s: init function 'ffserver_module_init()' not found\n",
3742 static int ffserver_opt_default(const char *opt, const char *arg,
3743 AVCodecContext *avctx, int type)
3746 const AVOption *o = av_find_opt(avctx, opt, NULL, type, type);
3748 ret = av_set_string3(avctx, opt, arg, 1, NULL);
3752 static int parse_ffconfig(const char *filename)
3759 int val, errors, line_num;
3760 FFStream **last_stream, *stream, *redirect;
3761 FFStream **last_feed, *feed, *s;
3762 AVCodecContext audio_enc, video_enc;
3763 enum CodecID audio_id, video_id;
3765 f = fopen(filename, "r");
3773 first_stream = NULL;
3774 last_stream = &first_stream;
3776 last_feed = &first_feed;
3780 audio_id = CODEC_ID_NONE;
3781 video_id = CODEC_ID_NONE;
3783 if (fgets(line, sizeof(line), f) == NULL)
3789 if (*p == '\0' || *p == '#')
3792 get_arg(cmd, sizeof(cmd), &p);
3794 if (!strcasecmp(cmd, "Port")) {
3795 get_arg(arg, sizeof(arg), &p);
3797 if (val < 1 || val > 65536) {
3798 fprintf(stderr, "%s:%d: Invalid port: %s\n",
3799 filename, line_num, arg);
3802 my_http_addr.sin_port = htons(val);
3803 } else if (!strcasecmp(cmd, "BindAddress")) {
3804 get_arg(arg, sizeof(arg), &p);
3805 if (resolve_host(&my_http_addr.sin_addr, arg) != 0) {
3806 fprintf(stderr, "%s:%d: Invalid host/IP address: %s\n",
3807 filename, line_num, arg);
3810 } else if (!strcasecmp(cmd, "NoDaemon")) {
3811 ffserver_daemon = 0;
3812 } else if (!strcasecmp(cmd, "RTSPPort")) {
3813 get_arg(arg, sizeof(arg), &p);
3815 if (val < 1 || val > 65536) {
3816 fprintf(stderr, "%s:%d: Invalid port: %s\n",
3817 filename, line_num, arg);
3820 my_rtsp_addr.sin_port = htons(atoi(arg));
3821 } else if (!strcasecmp(cmd, "RTSPBindAddress")) {
3822 get_arg(arg, sizeof(arg), &p);
3823 if (resolve_host(&my_rtsp_addr.sin_addr, arg) != 0) {
3824 fprintf(stderr, "%s:%d: Invalid host/IP address: %s\n",
3825 filename, line_num, arg);
3828 } else if (!strcasecmp(cmd, "MaxHTTPConnections")) {
3829 get_arg(arg, sizeof(arg), &p);
3831 if (val < 1 || val > 65536) {
3832 fprintf(stderr, "%s:%d: Invalid MaxHTTPConnections: %s\n",
3833 filename, line_num, arg);
3836 nb_max_http_connections = val;
3837 } else if (!strcasecmp(cmd, "MaxClients")) {
3838 get_arg(arg, sizeof(arg), &p);
3840 if (val < 1 || val > nb_max_http_connections) {
3841 fprintf(stderr, "%s:%d: Invalid MaxClients: %s\n",
3842 filename, line_num, arg);
3845 nb_max_connections = val;
3847 } else if (!strcasecmp(cmd, "MaxBandwidth")) {
3849 get_arg(arg, sizeof(arg), &p);
3851 if (llval < 10 || llval > 10000000) {
3852 fprintf(stderr, "%s:%d: Invalid MaxBandwidth: %s\n",
3853 filename, line_num, arg);
3856 max_bandwidth = llval;
3857 } else if (!strcasecmp(cmd, "CustomLog")) {
3858 if (!ffserver_debug)
3859 get_arg(logfilename, sizeof(logfilename), &p);
3860 } else if (!strcasecmp(cmd, "<Feed")) {
3861 /*********************************************/
3862 /* Feed related options */
3864 if (stream || feed) {
3865 fprintf(stderr, "%s:%d: Already in a tag\n",
3866 filename, line_num);
3868 feed = av_mallocz(sizeof(FFStream));
3869 get_arg(feed->filename, sizeof(feed->filename), &p);
3870 q = strrchr(feed->filename, '>');
3874 for (s = first_feed; s; s = s->next) {
3875 if (!strcmp(feed->filename, s->filename)) {
3876 fprintf(stderr, "%s:%d: Feed '%s' already registered\n",
3877 filename, line_num, s->filename);
3882 feed->fmt = guess_format("ffm", NULL, NULL);
3883 /* defaut feed file */
3884 snprintf(feed->feed_filename, sizeof(feed->feed_filename),
3885 "/tmp/%s.ffm", feed->filename);
3886 feed->feed_max_size = 5 * 1024 * 1024;
3888 feed->feed = feed; /* self feeding :-) */
3890 /* add in stream list */
3891 *last_stream = feed;
3892 last_stream = &feed->next;
3893 /* add in feed list */
3895 last_feed = &feed->next_feed;
3897 } else if (!strcasecmp(cmd, "Launch")) {
3901 feed->child_argv = av_mallocz(64 * sizeof(char *));
3903 for (i = 0; i < 62; i++) {
3904 get_arg(arg, sizeof(arg), &p);
3908 feed->child_argv[i] = av_strdup(arg);
3911 feed->child_argv[i] = av_malloc(30 + strlen(feed->filename));
3913 snprintf(feed->child_argv[i], 30+strlen(feed->filename),
3915 (my_http_addr.sin_addr.s_addr == INADDR_ANY) ? "127.0.0.1" :
3916 inet_ntoa(my_http_addr.sin_addr),
3917 ntohs(my_http_addr.sin_port), feed->filename);
3919 } else if (!strcasecmp(cmd, "ReadOnlyFile")) {
3921 get_arg(feed->feed_filename, sizeof(feed->feed_filename), &p);
3923 } else if (stream) {
3924 get_arg(stream->feed_filename, sizeof(stream->feed_filename), &p);
3926 } else if (!strcasecmp(cmd, "File")) {
3928 get_arg(feed->feed_filename, sizeof(feed->feed_filename), &p);
3930 get_arg(stream->feed_filename, sizeof(stream->feed_filename), &p);
3931 } else if (!strcasecmp(cmd, "FileMaxSize")) {
3936 get_arg(arg, sizeof(arg), &p);
3938 fsize = strtod(p1, &p1);
3939 switch(toupper(*p1)) {
3944 fsize *= 1024 * 1024;
3947 fsize *= 1024 * 1024 * 1024;
3950 feed->feed_max_size = (int64_t)fsize;
3952 } else if (!strcasecmp(cmd, "</Feed>")) {
3954 fprintf(stderr, "%s:%d: No corresponding <Feed> for </Feed>\n",
3955 filename, line_num);
3959 } else if (!strcasecmp(cmd, "<Stream")) {
3960 /*********************************************/
3961 /* Stream related options */
3963 if (stream || feed) {
3964 fprintf(stderr, "%s:%d: Already in a tag\n",
3965 filename, line_num);
3968 const AVClass *class;
3969 stream = av_mallocz(sizeof(FFStream));
3970 get_arg(stream->filename, sizeof(stream->filename), &p);
3971 q = strrchr(stream->filename, '>');
3975 for (s = first_stream; s; s = s->next) {
3976 if (!strcmp(stream->filename, s->filename)) {
3977 fprintf(stderr, "%s:%d: Stream '%s' already registered\n",
3978 filename, line_num, s->filename);
3983 stream->fmt = guess_stream_format(NULL, stream->filename, NULL);
3984 /* fetch avclass so AVOption works
3985 * FIXME try to use avcodec_get_context_defaults2
3986 * without changing defaults too much */
3987 avcodec_get_context_defaults(&video_enc);
3988 class = video_enc.av_class;
3989 memset(&audio_enc, 0, sizeof(AVCodecContext));
3990 memset(&video_enc, 0, sizeof(AVCodecContext));
3991 audio_enc.av_class = class;
3992 video_enc.av_class = class;
3993 audio_id = CODEC_ID_NONE;
3994 video_id = CODEC_ID_NONE;
3996 audio_id = stream->fmt->audio_codec;
3997 video_id = stream->fmt->video_codec;
4000 *last_stream = stream;
4001 last_stream = &stream->next;
4003 } else if (!strcasecmp(cmd, "Feed")) {
4004 get_arg(arg, sizeof(arg), &p);
4009 while (sfeed != NULL) {
4010 if (!strcmp(sfeed->filename, arg))
4012 sfeed = sfeed->next_feed;
4015 fprintf(stderr, "%s:%d: feed '%s' not defined\n",
4016 filename, line_num, arg);
4018 stream->feed = sfeed;
4020 } else if (!strcasecmp(cmd, "Format")) {
4021 get_arg(arg, sizeof(arg), &p);
4023 if (!strcmp(arg, "status")) {
4024 stream->stream_type = STREAM_TYPE_STATUS;
4027 stream->stream_type = STREAM_TYPE_LIVE;
4028 /* jpeg cannot be used here, so use single frame jpeg */
4029 if (!strcmp(arg, "jpeg"))
4030 strcpy(arg, "mjpeg");
4031 stream->fmt = guess_stream_format(arg, NULL, NULL);
4033 fprintf(stderr, "%s:%d: Unknown Format: %s\n",
4034 filename, line_num, arg);
4039 audio_id = stream->fmt->audio_codec;
4040 video_id = stream->fmt->video_codec;
4043 } else if (!strcasecmp(cmd, "InputFormat")) {
4044 get_arg(arg, sizeof(arg), &p);
4046 stream->ifmt = av_find_input_format(arg);
4047 if (!stream->ifmt) {
4048 fprintf(stderr, "%s:%d: Unknown input format: %s\n",
4049 filename, line_num, arg);
4052 } else if (!strcasecmp(cmd, "FaviconURL")) {
4053 if (stream && stream->stream_type == STREAM_TYPE_STATUS) {
4054 get_arg(stream->feed_filename, sizeof(stream->feed_filename), &p);
4056 fprintf(stderr, "%s:%d: FaviconURL only permitted for status streams\n",
4057 filename, line_num);
4060 } else if (!strcasecmp(cmd, "Author")) {
4062 get_arg(stream->author, sizeof(stream->author), &p);
4063 } else if (!strcasecmp(cmd, "Comment")) {
4065 get_arg(stream->comment, sizeof(stream->comment), &p);
4066 } else if (!strcasecmp(cmd, "Copyright")) {
4068 get_arg(stream->copyright, sizeof(stream->copyright), &p);
4069 } else if (!strcasecmp(cmd, "Title")) {
4071 get_arg(stream->title, sizeof(stream->title), &p);
4072 } else if (!strcasecmp(cmd, "Preroll")) {
4073 get_arg(arg, sizeof(arg), &p);
4075 stream->prebuffer = atof(arg) * 1000;
4076 } else if (!strcasecmp(cmd, "StartSendOnKey")) {
4078 stream->send_on_key = 1;
4079 } else if (!strcasecmp(cmd, "AudioCodec")) {
4080 get_arg(arg, sizeof(arg), &p);
4081 audio_id = opt_audio_codec(arg);
4082 if (audio_id == CODEC_ID_NONE) {
4083 fprintf(stderr, "%s:%d: Unknown AudioCodec: %s\n",
4084 filename, line_num, arg);
4087 } else if (!strcasecmp(cmd, "VideoCodec")) {
4088 get_arg(arg, sizeof(arg), &p);
4089 video_id = opt_video_codec(arg);
4090 if (video_id == CODEC_ID_NONE) {
4091 fprintf(stderr, "%s:%d: Unknown VideoCodec: %s\n",
4092 filename, line_num, arg);
4095 } else if (!strcasecmp(cmd, "MaxTime")) {
4096 get_arg(arg, sizeof(arg), &p);
4098 stream->max_time = atof(arg) * 1000;
4099 } else if (!strcasecmp(cmd, "AudioBitRate")) {
4100 get_arg(arg, sizeof(arg), &p);
4102 audio_enc.bit_rate = atoi(arg) * 1000;
4103 } else if (!strcasecmp(cmd, "AudioChannels")) {
4104 get_arg(arg, sizeof(arg), &p);
4106 audio_enc.channels = atoi(arg);
4107 } else if (!strcasecmp(cmd, "AudioSampleRate")) {
4108 get_arg(arg, sizeof(arg), &p);
4110 audio_enc.sample_rate = atoi(arg);
4111 } else if (!strcasecmp(cmd, "AudioQuality")) {
4112 get_arg(arg, sizeof(arg), &p);
4114 // audio_enc.quality = atof(arg) * 1000;
4116 } else if (!strcasecmp(cmd, "VideoBitRateRange")) {
4118 int minrate, maxrate;
4120 get_arg(arg, sizeof(arg), &p);
4122 if (sscanf(arg, "%d-%d", &minrate, &maxrate) == 2) {
4123 video_enc.rc_min_rate = minrate * 1000;
4124 video_enc.rc_max_rate = maxrate * 1000;
4126 fprintf(stderr, "%s:%d: Incorrect format for VideoBitRateRange -- should be <min>-<max>: %s\n",
4127 filename, line_num, arg);
4131 } else if (!strcasecmp(cmd, "Debug")) {
4133 get_arg(arg, sizeof(arg), &p);
4134 video_enc.debug = strtol(arg,0,0);
4136 } else if (!strcasecmp(cmd, "Strict")) {
4138 get_arg(arg, sizeof(arg), &p);
4139 video_enc.strict_std_compliance = atoi(arg);
4141 } else if (!strcasecmp(cmd, "VideoBufferSize")) {
4143 get_arg(arg, sizeof(arg), &p);
4144 video_enc.rc_buffer_size = atoi(arg) * 8*1024;
4146 } else if (!strcasecmp(cmd, "VideoBitRateTolerance")) {
4148 get_arg(arg, sizeof(arg), &p);
4149 video_enc.bit_rate_tolerance = atoi(arg) * 1000;
4151 } else if (!strcasecmp(cmd, "VideoBitRate")) {
4152 get_arg(arg, sizeof(arg), &p);
4154 video_enc.bit_rate = atoi(arg) * 1000;
4156 } else if (!strcasecmp(cmd, "VideoSize")) {
4157 get_arg(arg, sizeof(arg), &p);
4159 av_parse_video_frame_size(&video_enc.width, &video_enc.height, arg);
4160 if ((video_enc.width % 16) != 0 ||
4161 (video_enc.height % 16) != 0) {
4162 fprintf(stderr, "%s:%d: Image size must be a multiple of 16\n",
4163 filename, line_num);
4167 } else if (!strcasecmp(cmd, "VideoFrameRate")) {
4168 get_arg(arg, sizeof(arg), &p);
4170 AVRational frame_rate;
4171 if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
4172 fprintf(stderr, "Incorrect frame rate\n");
4175 video_enc.time_base.num = frame_rate.den;
4176 video_enc.time_base.den = frame_rate.num;
4179 } else if (!strcasecmp(cmd, "VideoGopSize")) {
4180 get_arg(arg, sizeof(arg), &p);
4182 video_enc.gop_size = atoi(arg);
4183 } else if (!strcasecmp(cmd, "VideoIntraOnly")) {
4185 video_enc.gop_size = 1;
4186 } else if (!strcasecmp(cmd, "VideoHighQuality")) {
4188 video_enc.mb_decision = FF_MB_DECISION_BITS;
4189 } else if (!strcasecmp(cmd, "Video4MotionVector")) {
4191 video_enc.mb_decision = FF_MB_DECISION_BITS; //FIXME remove
4192 video_enc.flags |= CODEC_FLAG_4MV;
4194 } else if (!strcasecmp(cmd, "AVOptionVideo") ||
4195 !strcasecmp(cmd, "AVOptionAudio")) {
4197 AVCodecContext *avctx;
4199 get_arg(arg, sizeof(arg), &p);
4200 get_arg(arg2, sizeof(arg2), &p);
4201 if (!strcasecmp(cmd, "AVOptionVideo")) {
4203 type = AV_OPT_FLAG_VIDEO_PARAM;
4206 type = AV_OPT_FLAG_AUDIO_PARAM;
4208 if (ffserver_opt_default(arg, arg2, avctx, type|AV_OPT_FLAG_ENCODING_PARAM)) {
4209 fprintf(stderr, "AVOption error: %s %s\n", arg, arg2);
4212 } else if (!strcasecmp(cmd, "VideoTag")) {
4213 get_arg(arg, sizeof(arg), &p);
4214 if ((strlen(arg) == 4) && stream)
4215 video_enc.codec_tag = AV_RL32(arg);
4216 } else if (!strcasecmp(cmd, "BitExact")) {
4218 video_enc.flags |= CODEC_FLAG_BITEXACT;
4219 } else if (!strcasecmp(cmd, "DctFastint")) {
4221 video_enc.dct_algo = FF_DCT_FASTINT;
4222 } else if (!strcasecmp(cmd, "IdctSimple")) {
4224 video_enc.idct_algo = FF_IDCT_SIMPLE;
4225 } else if (!strcasecmp(cmd, "Qscale")) {
4226 get_arg(arg, sizeof(arg), &p);
4228 video_enc.flags |= CODEC_FLAG_QSCALE;
4229 video_enc.global_quality = FF_QP2LAMBDA * atoi(arg);
4231 } else if (!strcasecmp(cmd, "VideoQDiff")) {
4232 get_arg(arg, sizeof(arg), &p);
4234 video_enc.max_qdiff = atoi(arg);
4235 if (video_enc.max_qdiff < 1 || video_enc.max_qdiff > 31) {
4236 fprintf(stderr, "%s:%d: VideoQDiff out of range\n",
4237 filename, line_num);
4241 } else if (!strcasecmp(cmd, "VideoQMax")) {
4242 get_arg(arg, sizeof(arg), &p);
4244 video_enc.qmax = atoi(arg);
4245 if (video_enc.qmax < 1 || video_enc.qmax > 31) {
4246 fprintf(stderr, "%s:%d: VideoQMax out of range\n",
4247 filename, line_num);
4251 } else if (!strcasecmp(cmd, "VideoQMin")) {
4252 get_arg(arg, sizeof(arg), &p);
4254 video_enc.qmin = atoi(arg);
4255 if (video_enc.qmin < 1 || video_enc.qmin > 31) {
4256 fprintf(stderr, "%s:%d: VideoQMin out of range\n",
4257 filename, line_num);
4261 } else if (!strcasecmp(cmd, "LumaElim")) {
4262 get_arg(arg, sizeof(arg), &p);
4264 video_enc.luma_elim_threshold = atoi(arg);
4265 } else if (!strcasecmp(cmd, "ChromaElim")) {
4266 get_arg(arg, sizeof(arg), &p);
4268 video_enc.chroma_elim_threshold = atoi(arg);
4269 } else if (!strcasecmp(cmd, "LumiMask")) {
4270 get_arg(arg, sizeof(arg), &p);
4272 video_enc.lumi_masking = atof(arg);
4273 } else if (!strcasecmp(cmd, "DarkMask")) {
4274 get_arg(arg, sizeof(arg), &p);
4276 video_enc.dark_masking = atof(arg);
4277 } else if (!strcasecmp(cmd, "NoVideo")) {
4278 video_id = CODEC_ID_NONE;
4279 } else if (!strcasecmp(cmd, "NoAudio")) {
4280 audio_id = CODEC_ID_NONE;
4281 } else if (!strcasecmp(cmd, "ACL")) {
4284 get_arg(arg, sizeof(arg), &p);
4285 if (strcasecmp(arg, "allow") == 0)
4286 acl.action = IP_ALLOW;
4287 else if (strcasecmp(arg, "deny") == 0)
4288 acl.action = IP_DENY;
4290 fprintf(stderr, "%s:%d: ACL action '%s' is not ALLOW or DENY\n",
4291 filename, line_num, arg);
4295 get_arg(arg, sizeof(arg), &p);
4297 if (resolve_host(&acl.first, arg) != 0) {
4298 fprintf(stderr, "%s:%d: ACL refers to invalid host or ip address '%s'\n",
4299 filename, line_num, arg);
4302 acl.last = acl.first;
4304 get_arg(arg, sizeof(arg), &p);
4307 if (resolve_host(&acl.last, arg) != 0) {
4308 fprintf(stderr, "%s:%d: ACL refers to invalid host or ip address '%s'\n",
4309 filename, line_num, arg);
4315 IPAddressACL *nacl = av_mallocz(sizeof(*nacl));
4316 IPAddressACL **naclp = 0;
4322 naclp = &stream->acl;
4326 fprintf(stderr, "%s:%d: ACL found not in <stream> or <feed>\n",
4327 filename, line_num);
4333 naclp = &(*naclp)->next;
4338 } else if (!strcasecmp(cmd, "RTSPOption")) {
4339 get_arg(arg, sizeof(arg), &p);
4341 av_freep(&stream->rtsp_option);
4342 stream->rtsp_option = av_strdup(arg);
4344 } else if (!strcasecmp(cmd, "MulticastAddress")) {
4345 get_arg(arg, sizeof(arg), &p);
4347 if (resolve_host(&stream->multicast_ip, arg) != 0) {
4348 fprintf(stderr, "%s:%d: Invalid host/IP address: %s\n",
4349 filename, line_num, arg);
4352 stream->is_multicast = 1;
4353 stream->loop = 1; /* default is looping */
4355 } else if (!strcasecmp(cmd, "MulticastPort")) {
4356 get_arg(arg, sizeof(arg), &p);
4358 stream->multicast_port = atoi(arg);
4359 } else if (!strcasecmp(cmd, "MulticastTTL")) {
4360 get_arg(arg, sizeof(arg), &p);
4362 stream->multicast_ttl = atoi(arg);
4363 } else if (!strcasecmp(cmd, "NoLoop")) {
4366 } else if (!strcasecmp(cmd, "</Stream>")) {
4368 fprintf(stderr, "%s:%d: No corresponding <Stream> for </Stream>\n",
4369 filename, line_num);
4372 if (stream->feed && stream->fmt && strcmp(stream->fmt->name, "ffm") != 0) {
4373 if (audio_id != CODEC_ID_NONE) {
4374 audio_enc.codec_type = CODEC_TYPE_AUDIO;
4375 audio_enc.codec_id = audio_id;
4376 add_codec(stream, &audio_enc);
4378 if (video_id != CODEC_ID_NONE) {
4379 video_enc.codec_type = CODEC_TYPE_VIDEO;
4380 video_enc.codec_id = video_id;
4381 add_codec(stream, &video_enc);
4386 } else if (!strcasecmp(cmd, "<Redirect")) {
4387 /*********************************************/
4389 if (stream || feed || redirect) {
4390 fprintf(stderr, "%s:%d: Already in a tag\n",
4391 filename, line_num);
4394 redirect = av_mallocz(sizeof(FFStream));
4395 *last_stream = redirect;
4396 last_stream = &redirect->next;
4398 get_arg(redirect->filename, sizeof(redirect->filename), &p);
4399 q = strrchr(redirect->filename, '>');
4402 redirect->stream_type = STREAM_TYPE_REDIRECT;
4404 } else if (!strcasecmp(cmd, "URL")) {
4406 get_arg(redirect->feed_filename, sizeof(redirect->feed_filename), &p);
4407 } else if (!strcasecmp(cmd, "</Redirect>")) {
4409 fprintf(stderr, "%s:%d: No corresponding <Redirect> for </Redirect>\n",
4410 filename, line_num);
4413 if (!redirect->feed_filename[0]) {
4414 fprintf(stderr, "%s:%d: No URL found for <Redirect>\n",
4415 filename, line_num);
4420 } else if (!strcasecmp(cmd, "LoadModule")) {
4421 get_arg(arg, sizeof(arg), &p);
4425 fprintf(stderr, "%s:%d: Module support not compiled into this version: '%s'\n",
4426 filename, line_num, arg);
4430 fprintf(stderr, "%s:%d: Incorrect keyword: '%s'\n",
4431 filename, line_num, cmd);
4442 static void handle_child_exit(int sig)
4447 while ((pid = waitpid(-1, &status, WNOHANG)) > 0) {
4450 for (feed = first_feed; feed; feed = feed->next) {
4451 if (feed->pid == pid) {
4452 int uptime = time(0) - feed->pid_start;
4455 fprintf(stderr, "%s: Pid %d exited with status %d after %d seconds\n", feed->filename, pid, status, uptime);
4458 /* Turn off any more restarts */
4459 feed->child_argv = 0;
4464 need_to_start_children = 1;
4467 static void opt_debug(void)
4470 ffserver_daemon = 0;
4471 logfilename[0] = '-';
4474 static void opt_show_help(void)
4476 printf("usage: ffserver [options]\n"
4477 "Hyper fast multi format Audio/Video streaming server\n");
4479 show_help_options(options, "Main options:\n", 0, 0);
4482 static const OptionDef options[] = {
4483 { "h", OPT_EXIT, {(void*)opt_show_help}, "show help" },
4484 { "version", OPT_EXIT, {(void*)show_version}, "show version" },
4485 { "L", OPT_EXIT, {(void*)show_license}, "show license" },
4486 { "formats", OPT_EXIT, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
4487 { "n", OPT_BOOL, {(void *)&no_launch }, "enable no-launch mode" },
4488 { "d", 0, {(void*)opt_debug}, "enable debug mode" },
4489 { "f", HAS_ARG | OPT_STRING, {(void*)&config_filename }, "use configfile instead of /etc/ffserver.conf", "configfile" },
4493 int main(int argc, char **argv)
4495 struct sigaction sigact;
4501 config_filename = "/etc/ffserver.conf";
4503 my_program_name = argv[0];
4504 my_program_dir = getcwd(0, 0);
4505 ffserver_daemon = 1;
4507 parse_options(argc, argv, options, NULL);
4509 unsetenv("http_proxy"); /* Kill the http_proxy */
4511 av_lfg_init(&random_state, ff_random_get_seed());
4513 memset(&sigact, 0, sizeof(sigact));
4514 sigact.sa_handler = handle_child_exit;
4515 sigact.sa_flags = SA_NOCLDSTOP | SA_RESTART;
4516 sigaction(SIGCHLD, &sigact, 0);
4518 if (parse_ffconfig(config_filename) < 0) {
4519 fprintf(stderr, "Incorrect config file - exiting.\n");
4523 /* open log file if needed */
4524 if (logfilename[0] != '\0') {
4525 if (!strcmp(logfilename, "-"))
4528 logfile = fopen(logfilename, "a");
4529 av_log_set_callback(http_av_log);
4532 build_file_streams();
4534 build_feed_streams();
4536 compute_bandwidth();
4538 /* put the process in background and detach it from its TTY */
4539 if (ffserver_daemon) {
4546 } else if (pid > 0) {
4553 open("/dev/null", O_RDWR);
4554 if (strcmp(logfilename, "-") != 0) {
4564 signal(SIGPIPE, SIG_IGN);
4566 if (ffserver_daemon)
4569 if (http_server() < 0) {
4570 http_log("Could not start server\n");