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 */
240 int truncate; /* True if feeder connection truncate the feed file */
242 int64_t bytes_served;
243 int64_t feed_max_size; /* maximum storage size, zero means unlimited */
244 int64_t feed_write_index; /* current write position in feed (it wraps around) */
245 int64_t feed_size; /* current size of feed */
246 struct FFStream *next_feed;
249 typedef struct FeedData {
250 long long data_count;
251 float avg_frame_size; /* frame size averaged over last frames with exponential mean */
254 static struct sockaddr_in my_http_addr;
255 static struct sockaddr_in my_rtsp_addr;
257 static char logfilename[1024];
258 static HTTPContext *first_http_ctx;
259 static FFStream *first_feed; /* contains only feeds */
260 static FFStream *first_stream; /* contains all streams, including feeds */
262 static void new_connection(int server_fd, int is_rtsp);
263 static void close_connection(HTTPContext *c);
266 static int handle_connection(HTTPContext *c);
267 static int http_parse_request(HTTPContext *c);
268 static int http_send_data(HTTPContext *c);
269 static void compute_status(HTTPContext *c);
270 static int open_input_stream(HTTPContext *c, const char *info);
271 static int http_start_receive_data(HTTPContext *c);
272 static int http_receive_data(HTTPContext *c);
275 static int rtsp_parse_request(HTTPContext *c);
276 static void rtsp_cmd_describe(HTTPContext *c, const char *url);
277 static void rtsp_cmd_options(HTTPContext *c, const char *url);
278 static void rtsp_cmd_setup(HTTPContext *c, const char *url, RTSPMessageHeader *h);
279 static void rtsp_cmd_play(HTTPContext *c, const char *url, RTSPMessageHeader *h);
280 static void rtsp_cmd_pause(HTTPContext *c, const char *url, RTSPMessageHeader *h);
281 static void rtsp_cmd_teardown(HTTPContext *c, const char *url, RTSPMessageHeader *h);
284 static int prepare_sdp_description(FFStream *stream, uint8_t **pbuffer,
285 struct in_addr my_ip);
288 static HTTPContext *rtp_new_connection(struct sockaddr_in *from_addr,
289 FFStream *stream, const char *session_id,
290 enum RTSPLowerTransport rtp_protocol);
291 static int rtp_new_av_stream(HTTPContext *c,
292 int stream_index, struct sockaddr_in *dest_addr,
293 HTTPContext *rtsp_c);
295 static const char *my_program_name;
296 static const char *my_program_dir;
298 static const char *config_filename;
299 static int ffserver_debug;
300 static int ffserver_daemon;
301 static int no_launch;
302 static int need_to_start_children;
304 /* maximum number of simultaneous HTTP connections */
305 static unsigned int nb_max_http_connections = 2000;
306 static unsigned int nb_max_connections = 5;
307 static unsigned int nb_connections;
309 static uint64_t max_bandwidth = 1000;
310 static uint64_t current_bandwidth;
312 static int64_t cur_time; // Making this global saves on passing it around everywhere
314 static AVLFG random_state;
316 static FILE *logfile = NULL;
318 static char *ctime1(char *buf2)
326 p = buf2 + strlen(p) - 1;
332 static void http_vlog(const char *fmt, va_list vargs)
334 static int print_prefix = 1;
339 fprintf(logfile, "%s ", buf);
341 print_prefix = strstr(fmt, "\n") != NULL;
342 vfprintf(logfile, fmt, vargs);
347 void __attribute__ ((format (printf, 1, 2))) http_log(const char *fmt, ...)
350 va_start(vargs, fmt);
351 http_vlog(fmt, vargs);
355 static void http_av_log(void *ptr, int level, const char *fmt, va_list vargs)
357 static int print_prefix = 1;
358 AVClass *avc = ptr ? *(AVClass**)ptr : NULL;
359 if (level > av_log_get_level())
361 if (print_prefix && avc)
362 http_log("[%s @ %p]", avc->item_name(ptr), ptr);
363 print_prefix = strstr(fmt, "\n") != NULL;
364 http_vlog(fmt, vargs);
367 static void log_connection(HTTPContext *c)
372 http_log("%s - - [%s] \"%s %s\" %d %"PRId64"\n",
373 inet_ntoa(c->from_addr.sin_addr), c->method, c->url,
374 c->protocol, (c->http_error ? c->http_error : 200), c->data_count);
377 static void update_datarate(DataRateData *drd, int64_t count)
379 if (!drd->time1 && !drd->count1) {
380 drd->time1 = drd->time2 = cur_time;
381 drd->count1 = drd->count2 = count;
382 } else if (cur_time - drd->time2 > 5000) {
383 drd->time1 = drd->time2;
384 drd->count1 = drd->count2;
385 drd->time2 = cur_time;
390 /* In bytes per second */
391 static int compute_datarate(DataRateData *drd, int64_t count)
393 if (cur_time == drd->time1)
396 return ((count - drd->count1) * 1000) / (cur_time - drd->time1);
400 static void start_children(FFStream *feed)
405 for (; feed; feed = feed->next) {
406 if (feed->child_argv && !feed->pid) {
407 feed->pid_start = time(0);
412 http_log("Unable to create children\n");
421 av_strlcpy(pathname, my_program_name, sizeof(pathname));
423 slash = strrchr(pathname, '/');
428 strcpy(slash, "ffmpeg");
430 http_log("Launch commandline: ");
431 http_log("%s ", pathname);
432 for (i = 1; feed->child_argv[i] && feed->child_argv[i][0]; i++)
433 http_log("%s ", feed->child_argv[i]);
436 for (i = 3; i < 256; i++)
439 if (!ffserver_debug) {
440 i = open("/dev/null", O_RDWR);
449 /* This is needed to make relative pathnames work */
450 chdir(my_program_dir);
452 signal(SIGPIPE, SIG_DFL);
454 execvp(pathname, feed->child_argv);
462 /* open a listening socket */
463 static int socket_open_listen(struct sockaddr_in *my_addr)
467 server_fd = socket(AF_INET,SOCK_STREAM,0);
474 setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &tmp, sizeof(tmp));
476 if (bind (server_fd, (struct sockaddr *) my_addr, sizeof (*my_addr)) < 0) {
478 snprintf(bindmsg, sizeof(bindmsg), "bind(port %d)", ntohs(my_addr->sin_port));
480 closesocket(server_fd);
484 if (listen (server_fd, 5) < 0) {
486 closesocket(server_fd);
489 ff_socket_nonblock(server_fd, 1);
494 /* start all multicast streams */
495 static void start_multicast(void)
500 struct sockaddr_in dest_addr;
501 int default_port, stream_index;
504 for(stream = first_stream; stream != NULL; stream = stream->next) {
505 if (stream->is_multicast) {
506 /* open the RTP connection */
507 snprintf(session_id, sizeof(session_id), "%08x%08x",
508 av_lfg_get(&random_state), av_lfg_get(&random_state));
510 /* choose a port if none given */
511 if (stream->multicast_port == 0) {
512 stream->multicast_port = default_port;
516 dest_addr.sin_family = AF_INET;
517 dest_addr.sin_addr = stream->multicast_ip;
518 dest_addr.sin_port = htons(stream->multicast_port);
520 rtp_c = rtp_new_connection(&dest_addr, stream, session_id,
521 RTSP_LOWER_TRANSPORT_UDP_MULTICAST);
525 if (open_input_stream(rtp_c, "") < 0) {
526 http_log("Could not open input stream for stream '%s'\n",
531 /* open each RTP stream */
532 for(stream_index = 0; stream_index < stream->nb_streams;
534 dest_addr.sin_port = htons(stream->multicast_port +
536 if (rtp_new_av_stream(rtp_c, stream_index, &dest_addr, NULL) < 0) {
537 http_log("Could not open output stream '%s/streamid=%d'\n",
538 stream->filename, stream_index);
543 /* change state to send data */
544 rtp_c->state = HTTPSTATE_SEND_DATA;
549 /* main loop of the http server */
550 static int http_server(void)
552 int server_fd = 0, rtsp_server_fd = 0;
553 int ret, delay, delay1;
554 struct pollfd *poll_table, *poll_entry;
555 HTTPContext *c, *c_next;
557 if(!(poll_table = av_mallocz((nb_max_http_connections + 2)*sizeof(*poll_table)))) {
558 http_log("Impossible to allocate a poll table handling %d connections.\n", nb_max_http_connections);
562 if (my_http_addr.sin_port) {
563 server_fd = socket_open_listen(&my_http_addr);
568 if (my_rtsp_addr.sin_port) {
569 rtsp_server_fd = socket_open_listen(&my_rtsp_addr);
570 if (rtsp_server_fd < 0)
574 if (!rtsp_server_fd && !server_fd) {
575 http_log("HTTP and RTSP disabled.\n");
579 http_log("FFserver started.\n");
581 start_children(first_feed);
586 poll_entry = poll_table;
588 poll_entry->fd = server_fd;
589 poll_entry->events = POLLIN;
592 if (rtsp_server_fd) {
593 poll_entry->fd = rtsp_server_fd;
594 poll_entry->events = POLLIN;
598 /* wait for events on each HTTP handle */
605 case HTTPSTATE_SEND_HEADER:
606 case RTSPSTATE_SEND_REPLY:
607 case RTSPSTATE_SEND_PACKET:
608 c->poll_entry = poll_entry;
610 poll_entry->events = POLLOUT;
613 case HTTPSTATE_SEND_DATA_HEADER:
614 case HTTPSTATE_SEND_DATA:
615 case HTTPSTATE_SEND_DATA_TRAILER:
616 if (!c->is_packetized) {
617 /* for TCP, we output as much as we can (may need to put a limit) */
618 c->poll_entry = poll_entry;
620 poll_entry->events = POLLOUT;
623 /* when ffserver is doing the timing, we work by
624 looking at which packet need to be sent every
626 delay1 = 10; /* one tick wait XXX: 10 ms assumed */
631 case HTTPSTATE_WAIT_REQUEST:
632 case HTTPSTATE_RECEIVE_DATA:
633 case HTTPSTATE_WAIT_FEED:
634 case RTSPSTATE_WAIT_REQUEST:
635 /* need to catch errors */
636 c->poll_entry = poll_entry;
638 poll_entry->events = POLLIN;/* Maybe this will work */
642 c->poll_entry = NULL;
648 /* wait for an event on one connection. We poll at least every
649 second to handle timeouts */
651 ret = poll(poll_table, poll_entry - poll_table, delay);
652 if (ret < 0 && ff_neterrno() != FF_NETERROR(EAGAIN) &&
653 ff_neterrno() != FF_NETERROR(EINTR))
657 cur_time = av_gettime() / 1000;
659 if (need_to_start_children) {
660 need_to_start_children = 0;
661 start_children(first_feed);
664 /* now handle the events */
665 for(c = first_http_ctx; c != NULL; c = c_next) {
667 if (handle_connection(c) < 0) {
668 /* close and free the connection */
674 poll_entry = poll_table;
676 /* new HTTP connection request ? */
677 if (poll_entry->revents & POLLIN)
678 new_connection(server_fd, 0);
681 if (rtsp_server_fd) {
682 /* new RTSP connection request ? */
683 if (poll_entry->revents & POLLIN)
684 new_connection(rtsp_server_fd, 1);
689 /* start waiting for a new HTTP/RTSP request */
690 static void start_wait_request(HTTPContext *c, int is_rtsp)
692 c->buffer_ptr = c->buffer;
693 c->buffer_end = c->buffer + c->buffer_size - 1; /* leave room for '\0' */
696 c->timeout = cur_time + RTSP_REQUEST_TIMEOUT;
697 c->state = RTSPSTATE_WAIT_REQUEST;
699 c->timeout = cur_time + HTTP_REQUEST_TIMEOUT;
700 c->state = HTTPSTATE_WAIT_REQUEST;
704 static void http_send_too_busy_reply(int fd)
707 int len = snprintf(buffer, sizeof(buffer),
708 "HTTP/1.0 200 Server too busy\r\n"
709 "Content-type: text/html\r\n"
711 "<html><head><title>Too busy</title></head><body>\r\n"
712 "<p>The server is too busy to serve your request at this time.</p>\r\n"
713 "<p>The number of current connections is %d, and this exceeds the limit of %d.</p>\r\n"
714 "</body></html>\r\n",
715 nb_connections, nb_max_connections);
716 send(fd, buffer, len, 0);
720 static void new_connection(int server_fd, int is_rtsp)
722 struct sockaddr_in from_addr;
724 HTTPContext *c = NULL;
726 len = sizeof(from_addr);
727 fd = accept(server_fd, (struct sockaddr *)&from_addr,
730 http_log("error during accept %s\n", strerror(errno));
733 ff_socket_nonblock(fd, 1);
735 if (nb_connections >= nb_max_connections) {
736 http_send_too_busy_reply(fd);
740 /* add a new connection */
741 c = av_mallocz(sizeof(HTTPContext));
746 c->poll_entry = NULL;
747 c->from_addr = from_addr;
748 c->buffer_size = IOBUFFER_INIT_SIZE;
749 c->buffer = av_malloc(c->buffer_size);
753 c->next = first_http_ctx;
757 start_wait_request(c, is_rtsp);
769 static void close_connection(HTTPContext *c)
771 HTTPContext **cp, *c1;
773 AVFormatContext *ctx;
777 /* remove connection from list */
778 cp = &first_http_ctx;
779 while ((*cp) != NULL) {
787 /* remove references, if any (XXX: do it faster) */
788 for(c1 = first_http_ctx; c1 != NULL; c1 = c1->next) {
793 /* remove connection associated resources */
797 /* close each frame parser */
798 for(i=0;i<c->fmt_in->nb_streams;i++) {
799 st = c->fmt_in->streams[i];
800 if (st->codec->codec)
801 avcodec_close(st->codec);
803 av_close_input_file(c->fmt_in);
806 /* free RTP output streams if any */
809 nb_streams = c->stream->nb_streams;
811 for(i=0;i<nb_streams;i++) {
814 av_write_trailer(ctx);
817 h = c->rtp_handles[i];
824 if (!c->last_packet_sent && c->state == HTTPSTATE_SEND_DATA_TRAILER) {
827 if (url_open_dyn_buf(&ctx->pb) >= 0) {
828 av_write_trailer(ctx);
829 av_freep(&c->pb_buffer);
830 url_close_dyn_buf(ctx->pb, &c->pb_buffer);
835 for(i=0; i<ctx->nb_streams; i++)
836 av_free(ctx->streams[i]);
838 if (c->stream && !c->post && c->stream->stream_type == STREAM_TYPE_LIVE)
839 current_bandwidth -= c->stream->bandwidth;
841 /* signal that there is no feed if we are the feeder socket */
842 if (c->state == HTTPSTATE_RECEIVE_DATA && c->stream) {
843 c->stream->feed_opened = 0;
847 av_freep(&c->pb_buffer);
848 av_freep(&c->packet_buffer);
854 static int handle_connection(HTTPContext *c)
859 case HTTPSTATE_WAIT_REQUEST:
860 case RTSPSTATE_WAIT_REQUEST:
862 if ((c->timeout - cur_time) < 0)
864 if (c->poll_entry->revents & (POLLERR | POLLHUP))
867 /* no need to read if no events */
868 if (!(c->poll_entry->revents & POLLIN))
872 len = recv(c->fd, c->buffer_ptr, 1, 0);
874 if (ff_neterrno() != FF_NETERROR(EAGAIN) &&
875 ff_neterrno() != FF_NETERROR(EINTR))
877 } else if (len == 0) {
880 /* search for end of request. */
882 c->buffer_ptr += len;
884 if ((ptr >= c->buffer + 2 && !memcmp(ptr-2, "\n\n", 2)) ||
885 (ptr >= c->buffer + 4 && !memcmp(ptr-4, "\r\n\r\n", 4))) {
886 /* request found : parse it and reply */
887 if (c->state == HTTPSTATE_WAIT_REQUEST) {
888 ret = http_parse_request(c);
890 ret = rtsp_parse_request(c);
894 } else if (ptr >= c->buffer_end) {
895 /* request too long: cannot do anything */
897 } else goto read_loop;
901 case HTTPSTATE_SEND_HEADER:
902 if (c->poll_entry->revents & (POLLERR | POLLHUP))
905 /* no need to write if no events */
906 if (!(c->poll_entry->revents & POLLOUT))
908 len = send(c->fd, c->buffer_ptr, c->buffer_end - c->buffer_ptr, 0);
910 if (ff_neterrno() != FF_NETERROR(EAGAIN) &&
911 ff_neterrno() != FF_NETERROR(EINTR)) {
912 /* error : close connection */
913 av_freep(&c->pb_buffer);
917 c->buffer_ptr += len;
919 c->stream->bytes_served += len;
920 c->data_count += len;
921 if (c->buffer_ptr >= c->buffer_end) {
922 av_freep(&c->pb_buffer);
926 /* all the buffer was sent : synchronize to the incoming stream */
927 c->state = HTTPSTATE_SEND_DATA_HEADER;
928 c->buffer_ptr = c->buffer_end = c->buffer;
933 case HTTPSTATE_SEND_DATA:
934 case HTTPSTATE_SEND_DATA_HEADER:
935 case HTTPSTATE_SEND_DATA_TRAILER:
936 /* for packetized output, we consider we can always write (the
937 input streams sets the speed). It may be better to verify
938 that we do not rely too much on the kernel queues */
939 if (!c->is_packetized) {
940 if (c->poll_entry->revents & (POLLERR | POLLHUP))
943 /* no need to read if no events */
944 if (!(c->poll_entry->revents & POLLOUT))
947 if (http_send_data(c) < 0)
949 /* close connection if trailer sent */
950 if (c->state == HTTPSTATE_SEND_DATA_TRAILER)
953 case HTTPSTATE_RECEIVE_DATA:
954 /* no need to read if no events */
955 if (c->poll_entry->revents & (POLLERR | POLLHUP))
957 if (!(c->poll_entry->revents & POLLIN))
959 if (http_receive_data(c) < 0)
962 case HTTPSTATE_WAIT_FEED:
963 /* no need to read if no events */
964 if (c->poll_entry->revents & (POLLIN | POLLERR | POLLHUP))
967 /* nothing to do, we'll be waken up by incoming feed packets */
970 case RTSPSTATE_SEND_REPLY:
971 if (c->poll_entry->revents & (POLLERR | POLLHUP)) {
972 av_freep(&c->pb_buffer);
975 /* no need to write if no events */
976 if (!(c->poll_entry->revents & POLLOUT))
978 len = send(c->fd, c->buffer_ptr, c->buffer_end - c->buffer_ptr, 0);
980 if (ff_neterrno() != FF_NETERROR(EAGAIN) &&
981 ff_neterrno() != FF_NETERROR(EINTR)) {
982 /* error : close connection */
983 av_freep(&c->pb_buffer);
987 c->buffer_ptr += len;
988 c->data_count += len;
989 if (c->buffer_ptr >= c->buffer_end) {
990 /* all the buffer was sent : wait for a new request */
991 av_freep(&c->pb_buffer);
992 start_wait_request(c, 1);
996 case RTSPSTATE_SEND_PACKET:
997 if (c->poll_entry->revents & (POLLERR | POLLHUP)) {
998 av_freep(&c->packet_buffer);
1001 /* no need to write if no events */
1002 if (!(c->poll_entry->revents & POLLOUT))
1004 len = send(c->fd, c->packet_buffer_ptr,
1005 c->packet_buffer_end - c->packet_buffer_ptr, 0);
1007 if (ff_neterrno() != FF_NETERROR(EAGAIN) &&
1008 ff_neterrno() != FF_NETERROR(EINTR)) {
1009 /* error : close connection */
1010 av_freep(&c->packet_buffer);
1014 c->packet_buffer_ptr += len;
1015 if (c->packet_buffer_ptr >= c->packet_buffer_end) {
1016 /* all the buffer was sent : wait for a new request */
1017 av_freep(&c->packet_buffer);
1018 c->state = RTSPSTATE_WAIT_REQUEST;
1022 case HTTPSTATE_READY:
1031 static int extract_rates(char *rates, int ratelen, const char *request)
1035 for (p = request; *p && *p != '\r' && *p != '\n'; ) {
1036 if (strncasecmp(p, "Pragma:", 7) == 0) {
1037 const char *q = p + 7;
1039 while (*q && *q != '\n' && isspace(*q))
1042 if (strncasecmp(q, "stream-switch-entry=", 20) == 0) {
1048 memset(rates, 0xff, ratelen);
1051 while (*q && *q != '\n' && *q != ':')
1054 if (sscanf(q, ":%d:%d", &stream_no, &rate_no) != 2)
1058 if (stream_no < ratelen && stream_no >= 0)
1059 rates[stream_no] = rate_no;
1061 while (*q && *q != '\n' && !isspace(*q))
1068 p = strchr(p, '\n');
1078 static int find_stream_in_feed(FFStream *feed, AVCodecContext *codec, int bit_rate)
1081 int best_bitrate = 100000000;
1084 for (i = 0; i < feed->nb_streams; i++) {
1085 AVCodecContext *feed_codec = feed->streams[i]->codec;
1087 if (feed_codec->codec_id != codec->codec_id ||
1088 feed_codec->sample_rate != codec->sample_rate ||
1089 feed_codec->width != codec->width ||
1090 feed_codec->height != codec->height)
1093 /* Potential stream */
1095 /* We want the fastest stream less than bit_rate, or the slowest
1096 * faster than bit_rate
1099 if (feed_codec->bit_rate <= bit_rate) {
1100 if (best_bitrate > bit_rate || feed_codec->bit_rate > best_bitrate) {
1101 best_bitrate = feed_codec->bit_rate;
1105 if (feed_codec->bit_rate < best_bitrate) {
1106 best_bitrate = feed_codec->bit_rate;
1115 static int modify_current_stream(HTTPContext *c, char *rates)
1118 FFStream *req = c->stream;
1119 int action_required = 0;
1121 /* Not much we can do for a feed */
1125 for (i = 0; i < req->nb_streams; i++) {
1126 AVCodecContext *codec = req->streams[i]->codec;
1130 c->switch_feed_streams[i] = req->feed_streams[i];
1133 c->switch_feed_streams[i] = find_stream_in_feed(req->feed, codec, codec->bit_rate / 2);
1136 /* Wants off or slow */
1137 c->switch_feed_streams[i] = find_stream_in_feed(req->feed, codec, codec->bit_rate / 4);
1139 /* This doesn't work well when it turns off the only stream! */
1140 c->switch_feed_streams[i] = -2;
1141 c->feed_streams[i] = -2;
1146 if (c->switch_feed_streams[i] >= 0 && c->switch_feed_streams[i] != c->feed_streams[i])
1147 action_required = 1;
1150 return action_required;
1154 static void do_switch_stream(HTTPContext *c, int i)
1156 if (c->switch_feed_streams[i] >= 0) {
1158 c->feed_streams[i] = c->switch_feed_streams[i];
1161 /* Now update the stream */
1163 c->switch_feed_streams[i] = -1;
1166 /* XXX: factorize in utils.c ? */
1167 /* XXX: take care with different space meaning */
1168 static void skip_spaces(const char **pp)
1172 while (*p == ' ' || *p == '\t')
1177 static void get_word(char *buf, int buf_size, const char **pp)
1185 while (!isspace(*p) && *p != '\0') {
1186 if ((q - buf) < buf_size - 1)
1195 static int validate_acl(FFStream *stream, HTTPContext *c)
1197 enum IPAddressAction last_action = IP_DENY;
1199 struct in_addr *src = &c->from_addr.sin_addr;
1200 unsigned long src_addr = src->s_addr;
1202 for (acl = stream->acl; acl; acl = acl->next) {
1203 if (src_addr >= acl->first.s_addr && src_addr <= acl->last.s_addr)
1204 return (acl->action == IP_ALLOW) ? 1 : 0;
1205 last_action = acl->action;
1208 /* Nothing matched, so return not the last action */
1209 return (last_action == IP_DENY) ? 1 : 0;
1212 /* compute the real filename of a file by matching it without its
1213 extensions to all the stream filenames */
1214 static void compute_real_filename(char *filename, int max_size)
1221 /* compute filename by matching without the file extensions */
1222 av_strlcpy(file1, filename, sizeof(file1));
1223 p = strrchr(file1, '.');
1226 for(stream = first_stream; stream != NULL; stream = stream->next) {
1227 av_strlcpy(file2, stream->filename, sizeof(file2));
1228 p = strrchr(file2, '.');
1231 if (!strcmp(file1, file2)) {
1232 av_strlcpy(filename, stream->filename, max_size);
1247 /* parse http request and prepare header */
1248 static int http_parse_request(HTTPContext *c)
1251 enum RedirType redir_type;
1253 char info[1024], filename[1024];
1257 const char *mime_type;
1261 char *useragent = 0;
1264 get_word(cmd, sizeof(cmd), (const char **)&p);
1265 av_strlcpy(c->method, cmd, sizeof(c->method));
1267 if (!strcmp(cmd, "GET"))
1269 else if (!strcmp(cmd, "POST"))
1274 get_word(url, sizeof(url), (const char **)&p);
1275 av_strlcpy(c->url, url, sizeof(c->url));
1277 get_word(protocol, sizeof(protocol), (const char **)&p);
1278 if (strcmp(protocol, "HTTP/1.0") && strcmp(protocol, "HTTP/1.1"))
1281 av_strlcpy(c->protocol, protocol, sizeof(c->protocol));
1284 http_log("%s - - New connection: %s %s\n", inet_ntoa(c->from_addr.sin_addr), cmd, url);
1286 /* find the filename and the optional info string in the request */
1287 p = strchr(url, '?');
1289 av_strlcpy(info, p, sizeof(info));
1294 av_strlcpy(filename, url + ((*url == '/') ? 1 : 0), sizeof(filename)-1);
1296 for (p = c->buffer; *p && *p != '\r' && *p != '\n'; ) {
1297 if (strncasecmp(p, "User-Agent:", 11) == 0) {
1299 if (*useragent && *useragent != '\n' && isspace(*useragent))
1303 p = strchr(p, '\n');
1310 redir_type = REDIR_NONE;
1311 if (match_ext(filename, "asx")) {
1312 redir_type = REDIR_ASX;
1313 filename[strlen(filename)-1] = 'f';
1314 } else if (match_ext(filename, "asf") &&
1315 (!useragent || strncasecmp(useragent, "NSPlayer", 8) != 0)) {
1316 /* if this isn't WMP or lookalike, return the redirector file */
1317 redir_type = REDIR_ASF;
1318 } else if (match_ext(filename, "rpm,ram")) {
1319 redir_type = REDIR_RAM;
1320 strcpy(filename + strlen(filename)-2, "m");
1321 } else if (match_ext(filename, "rtsp")) {
1322 redir_type = REDIR_RTSP;
1323 compute_real_filename(filename, sizeof(filename) - 1);
1324 } else if (match_ext(filename, "sdp")) {
1325 redir_type = REDIR_SDP;
1326 compute_real_filename(filename, sizeof(filename) - 1);
1329 // "redirect" / request to index.html
1330 if (!strlen(filename))
1331 av_strlcpy(filename, "index.html", sizeof(filename) - 1);
1333 stream = first_stream;
1334 while (stream != NULL) {
1335 if (!strcmp(stream->filename, filename) && validate_acl(stream, c))
1337 stream = stream->next;
1339 if (stream == NULL) {
1340 snprintf(msg, sizeof(msg), "File '%s' not found", url);
1341 http_log("File '%s' not found\n", url);
1346 memcpy(c->feed_streams, stream->feed_streams, sizeof(c->feed_streams));
1347 memset(c->switch_feed_streams, -1, sizeof(c->switch_feed_streams));
1349 if (stream->stream_type == STREAM_TYPE_REDIRECT) {
1350 c->http_error = 301;
1352 q += snprintf(q, c->buffer_size,
1353 "HTTP/1.0 301 Moved\r\n"
1355 "Content-type: text/html\r\n"
1357 "<html><head><title>Moved</title></head><body>\r\n"
1358 "You should be <a href=\"%s\">redirected</a>.\r\n"
1359 "</body></html>\r\n", stream->feed_filename, stream->feed_filename);
1360 /* prepare output buffer */
1361 c->buffer_ptr = c->buffer;
1363 c->state = HTTPSTATE_SEND_HEADER;
1367 /* If this is WMP, get the rate information */
1368 if (extract_rates(ratebuf, sizeof(ratebuf), c->buffer)) {
1369 if (modify_current_stream(c, ratebuf)) {
1370 for (i = 0; i < FF_ARRAY_ELEMS(c->feed_streams); i++) {
1371 if (c->switch_feed_streams[i] >= 0)
1372 do_switch_stream(c, i);
1377 if (c->post == 0 && stream->stream_type == STREAM_TYPE_LIVE)
1378 current_bandwidth += stream->bandwidth;
1380 /* If already streaming this feed, do not let start another feeder. */
1381 if (stream->feed_opened) {
1382 snprintf(msg, sizeof(msg), "This feed is already being received.");
1383 http_log("Feed '%s' already being received\n", stream->feed_filename);
1387 if (c->post == 0 && max_bandwidth < current_bandwidth) {
1388 c->http_error = 200;
1390 q += snprintf(q, c->buffer_size,
1391 "HTTP/1.0 200 Server too busy\r\n"
1392 "Content-type: text/html\r\n"
1394 "<html><head><title>Too busy</title></head><body>\r\n"
1395 "<p>The server is too busy to serve your request at this time.</p>\r\n"
1396 "<p>The bandwidth being served (including your stream) is %"PRIu64"kbit/sec, "
1397 "and this exceeds the limit of %"PRIu64"kbit/sec.</p>\r\n"
1398 "</body></html>\r\n", current_bandwidth, max_bandwidth);
1399 /* prepare output buffer */
1400 c->buffer_ptr = c->buffer;
1402 c->state = HTTPSTATE_SEND_HEADER;
1406 if (redir_type != REDIR_NONE) {
1409 for (p = c->buffer; *p && *p != '\r' && *p != '\n'; ) {
1410 if (strncasecmp(p, "Host:", 5) == 0) {
1414 p = strchr(p, '\n');
1425 while (isspace(*hostinfo))
1428 eoh = strchr(hostinfo, '\n');
1430 if (eoh[-1] == '\r')
1433 if (eoh - hostinfo < sizeof(hostbuf) - 1) {
1434 memcpy(hostbuf, hostinfo, eoh - hostinfo);
1435 hostbuf[eoh - hostinfo] = 0;
1437 c->http_error = 200;
1439 switch(redir_type) {
1441 q += snprintf(q, c->buffer_size,
1442 "HTTP/1.0 200 ASX Follows\r\n"
1443 "Content-type: video/x-ms-asf\r\n"
1445 "<ASX Version=\"3\">\r\n"
1446 //"<!-- Autogenerated by ffserver -->\r\n"
1447 "<ENTRY><REF HREF=\"http://%s/%s%s\"/></ENTRY>\r\n"
1448 "</ASX>\r\n", hostbuf, filename, info);
1451 q += snprintf(q, c->buffer_size,
1452 "HTTP/1.0 200 RAM Follows\r\n"
1453 "Content-type: audio/x-pn-realaudio\r\n"
1455 "# Autogenerated by ffserver\r\n"
1456 "http://%s/%s%s\r\n", hostbuf, filename, info);
1459 q += snprintf(q, c->buffer_size,
1460 "HTTP/1.0 200 ASF Redirect follows\r\n"
1461 "Content-type: video/x-ms-asf\r\n"
1464 "Ref1=http://%s/%s%s\r\n", hostbuf, filename, info);
1468 char hostname[256], *p;
1469 /* extract only hostname */
1470 av_strlcpy(hostname, hostbuf, sizeof(hostname));
1471 p = strrchr(hostname, ':');
1474 q += snprintf(q, c->buffer_size,
1475 "HTTP/1.0 200 RTSP Redirect follows\r\n"
1476 /* XXX: incorrect mime type ? */
1477 "Content-type: application/x-rtsp\r\n"
1479 "rtsp://%s:%d/%s\r\n", hostname, ntohs(my_rtsp_addr.sin_port), filename);
1485 int sdp_data_size, len;
1486 struct sockaddr_in my_addr;
1488 q += snprintf(q, c->buffer_size,
1489 "HTTP/1.0 200 OK\r\n"
1490 "Content-type: application/sdp\r\n"
1493 len = sizeof(my_addr);
1494 getsockname(c->fd, (struct sockaddr *)&my_addr, &len);
1496 /* XXX: should use a dynamic buffer */
1497 sdp_data_size = prepare_sdp_description(stream,
1500 if (sdp_data_size > 0) {
1501 memcpy(q, sdp_data, sdp_data_size);
1513 /* prepare output buffer */
1514 c->buffer_ptr = c->buffer;
1516 c->state = HTTPSTATE_SEND_HEADER;
1522 snprintf(msg, sizeof(msg), "ASX/RAM file not handled");
1526 stream->conns_served++;
1528 /* XXX: add there authenticate and IP match */
1531 /* if post, it means a feed is being sent */
1532 if (!stream->is_feed) {
1533 /* However it might be a status report from WMP! Let us log the
1534 * data as it might come in handy one day. */
1538 for (p = c->buffer; *p && *p != '\r' && *p != '\n'; ) {
1539 if (strncasecmp(p, "Pragma: log-line=", 17) == 0) {
1543 if (strncasecmp(p, "Pragma: client-id=", 18) == 0)
1544 client_id = strtol(p + 18, 0, 10);
1545 p = strchr(p, '\n');
1553 char *eol = strchr(logline, '\n');
1558 if (eol[-1] == '\r')
1560 http_log("%.*s\n", (int) (eol - logline), logline);
1561 c->suppress_log = 1;
1566 http_log("\nGot request:\n%s\n", c->buffer);
1569 if (client_id && extract_rates(ratebuf, sizeof(ratebuf), c->buffer)) {
1572 /* Now we have to find the client_id */
1573 for (wmpc = first_http_ctx; wmpc; wmpc = wmpc->next) {
1574 if (wmpc->wmp_client_id == client_id)
1578 if (wmpc && modify_current_stream(wmpc, ratebuf))
1579 wmpc->switch_pending = 1;
1582 snprintf(msg, sizeof(msg), "POST command not handled");
1586 if (http_start_receive_data(c) < 0) {
1587 snprintf(msg, sizeof(msg), "could not open feed");
1591 c->state = HTTPSTATE_RECEIVE_DATA;
1596 if (strcmp(stream->filename + strlen(stream->filename) - 4, ".asf") == 0)
1597 http_log("\nGot request:\n%s\n", c->buffer);
1600 if (c->stream->stream_type == STREAM_TYPE_STATUS)
1603 /* open input stream */
1604 if (open_input_stream(c, info) < 0) {
1605 snprintf(msg, sizeof(msg), "Input stream corresponding to '%s' not found", url);
1609 /* prepare http header */
1611 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "HTTP/1.0 200 OK\r\n");
1612 mime_type = c->stream->fmt->mime_type;
1614 mime_type = "application/x-octet-stream";
1615 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "Pragma: no-cache\r\n");
1617 /* for asf, we need extra headers */
1618 if (!strcmp(c->stream->fmt->name,"asf_stream")) {
1619 /* Need to allocate a client id */
1621 c->wmp_client_id = av_lfg_get(&random_state);
1623 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);
1625 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "Content-Type: %s\r\n", mime_type);
1626 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "\r\n");
1628 /* prepare output buffer */
1630 c->buffer_ptr = c->buffer;
1632 c->state = HTTPSTATE_SEND_HEADER;
1635 c->http_error = 404;
1637 q += snprintf(q, c->buffer_size,
1638 "HTTP/1.0 404 Not Found\r\n"
1639 "Content-type: text/html\r\n"
1642 "<HEAD><TITLE>404 Not Found</TITLE></HEAD>\n"
1645 /* prepare output buffer */
1646 c->buffer_ptr = c->buffer;
1648 c->state = HTTPSTATE_SEND_HEADER;
1652 c->http_error = 200; /* horrible : we use this value to avoid
1653 going to the send data state */
1654 c->state = HTTPSTATE_SEND_HEADER;
1658 static void fmt_bytecount(ByteIOContext *pb, int64_t count)
1660 static const char *suffix = " kMGTP";
1663 for (s = suffix; count >= 100000 && s[1]; count /= 1000, s++);
1665 url_fprintf(pb, "%"PRId64"%c", count, *s);
1668 static void compute_status(HTTPContext *c)
1677 if (url_open_dyn_buf(&pb) < 0) {
1678 /* XXX: return an error ? */
1679 c->buffer_ptr = c->buffer;
1680 c->buffer_end = c->buffer;
1684 url_fprintf(pb, "HTTP/1.0 200 OK\r\n");
1685 url_fprintf(pb, "Content-type: %s\r\n", "text/html");
1686 url_fprintf(pb, "Pragma: no-cache\r\n");
1687 url_fprintf(pb, "\r\n");
1689 url_fprintf(pb, "<HTML><HEAD><TITLE>%s Status</TITLE>\n", program_name);
1690 if (c->stream->feed_filename[0])
1691 url_fprintf(pb, "<link rel=\"shortcut icon\" href=\"%s\">\n", c->stream->feed_filename);
1692 url_fprintf(pb, "</HEAD>\n<BODY>");
1693 url_fprintf(pb, "<H1>%s Status</H1>\n", program_name);
1695 url_fprintf(pb, "<H2>Available Streams</H2>\n");
1696 url_fprintf(pb, "<TABLE cellspacing=0 cellpadding=4>\n");
1697 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");
1698 stream = first_stream;
1699 while (stream != NULL) {
1700 char sfilename[1024];
1703 if (stream->feed != stream) {
1704 av_strlcpy(sfilename, stream->filename, sizeof(sfilename) - 10);
1705 eosf = sfilename + strlen(sfilename);
1706 if (eosf - sfilename >= 4) {
1707 if (strcmp(eosf - 4, ".asf") == 0)
1708 strcpy(eosf - 4, ".asx");
1709 else if (strcmp(eosf - 3, ".rm") == 0)
1710 strcpy(eosf - 3, ".ram");
1711 else if (stream->fmt && !strcmp(stream->fmt->name, "rtp")) {
1712 /* generate a sample RTSP director if
1713 unicast. Generate an SDP redirector if
1715 eosf = strrchr(sfilename, '.');
1717 eosf = sfilename + strlen(sfilename);
1718 if (stream->is_multicast)
1719 strcpy(eosf, ".sdp");
1721 strcpy(eosf, ".rtsp");
1725 url_fprintf(pb, "<TR><TD><A HREF=\"/%s\">%s</A> ",
1726 sfilename, stream->filename);
1727 url_fprintf(pb, "<td align=right> %d <td align=right> ",
1728 stream->conns_served);
1729 fmt_bytecount(pb, stream->bytes_served);
1730 switch(stream->stream_type) {
1731 case STREAM_TYPE_LIVE: {
1732 int audio_bit_rate = 0;
1733 int video_bit_rate = 0;
1734 const char *audio_codec_name = "";
1735 const char *video_codec_name = "";
1736 const char *audio_codec_name_extra = "";
1737 const char *video_codec_name_extra = "";
1739 for(i=0;i<stream->nb_streams;i++) {
1740 AVStream *st = stream->streams[i];
1741 AVCodec *codec = avcodec_find_encoder(st->codec->codec_id);
1742 switch(st->codec->codec_type) {
1743 case CODEC_TYPE_AUDIO:
1744 audio_bit_rate += st->codec->bit_rate;
1746 if (*audio_codec_name)
1747 audio_codec_name_extra = "...";
1748 audio_codec_name = codec->name;
1751 case CODEC_TYPE_VIDEO:
1752 video_bit_rate += st->codec->bit_rate;
1754 if (*video_codec_name)
1755 video_codec_name_extra = "...";
1756 video_codec_name = codec->name;
1759 case CODEC_TYPE_DATA:
1760 video_bit_rate += st->codec->bit_rate;
1766 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",
1769 video_bit_rate / 1000, video_codec_name, video_codec_name_extra,
1770 audio_bit_rate / 1000, audio_codec_name, audio_codec_name_extra);
1772 url_fprintf(pb, "<TD>%s", stream->feed->filename);
1774 url_fprintf(pb, "<TD>%s", stream->feed_filename);
1775 url_fprintf(pb, "\n");
1779 url_fprintf(pb, "<TD align=center> - <TD align=right> - <TD align=right> - <td><td align=right> - <TD>\n");
1783 stream = stream->next;
1785 url_fprintf(pb, "</TABLE>\n");
1787 stream = first_stream;
1788 while (stream != NULL) {
1789 if (stream->feed == stream) {
1790 url_fprintf(pb, "<h2>Feed %s</h2>", stream->filename);
1792 url_fprintf(pb, "Running as pid %d.\n", stream->pid);
1794 #if defined(linux) && !defined(CONFIG_NOCUTILS)
1799 /* This is somewhat linux specific I guess */
1800 snprintf(ps_cmd, sizeof(ps_cmd),
1801 "ps -o \"%%cpu,cputime\" --no-headers %d",
1804 pid_stat = popen(ps_cmd, "r");
1809 if (fscanf(pid_stat, "%10s %64s", cpuperc,
1811 url_fprintf(pb, "Currently using %s%% of the cpu. Total time used %s.\n",
1819 url_fprintf(pb, "<p>");
1821 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");
1823 for (i = 0; i < stream->nb_streams; i++) {
1824 AVStream *st = stream->streams[i];
1825 AVCodec *codec = avcodec_find_encoder(st->codec->codec_id);
1826 const char *type = "unknown";
1827 char parameters[64];
1831 switch(st->codec->codec_type) {
1832 case CODEC_TYPE_AUDIO:
1834 snprintf(parameters, sizeof(parameters), "%d channel(s), %d Hz", st->codec->channels, st->codec->sample_rate);
1836 case CODEC_TYPE_VIDEO:
1838 snprintf(parameters, sizeof(parameters), "%dx%d, q=%d-%d, fps=%d", st->codec->width, st->codec->height,
1839 st->codec->qmin, st->codec->qmax, st->codec->time_base.den / st->codec->time_base.num);
1844 url_fprintf(pb, "<tr><td align=right>%d<td>%s<td align=right>%d<td>%s<td>%s\n",
1845 i, type, st->codec->bit_rate/1000, codec ? codec->name : "", parameters);
1847 url_fprintf(pb, "</table>\n");
1850 stream = stream->next;
1856 AVCodecContext *enc;
1860 stream = first_feed;
1861 while (stream != NULL) {
1862 url_fprintf(pb, "<H1>Feed '%s'</H1>\n", stream->filename);
1863 url_fprintf(pb, "<TABLE>\n");
1864 url_fprintf(pb, "<TR><TD>Parameters<TD>Frame count<TD>Size<TD>Avg bitrate (kbits/s)\n");
1865 for(i=0;i<stream->nb_streams;i++) {
1866 AVStream *st = stream->streams[i];
1867 FeedData *fdata = st->priv_data;
1870 avcodec_string(buf, sizeof(buf), enc);
1871 avg = fdata->avg_frame_size * (float)enc->rate * 8.0;
1872 if (enc->codec->type == CODEC_TYPE_AUDIO && enc->frame_size > 0)
1873 avg /= enc->frame_size;
1874 url_fprintf(pb, "<TR><TD>%s <TD> %d <TD> %"PRId64" <TD> %0.1f\n",
1875 buf, enc->frame_number, fdata->data_count, avg / 1000.0);
1877 url_fprintf(pb, "</TABLE>\n");
1878 stream = stream->next_feed;
1883 /* connection status */
1884 url_fprintf(pb, "<H2>Connection Status</H2>\n");
1886 url_fprintf(pb, "Number of connections: %d / %d<BR>\n",
1887 nb_connections, nb_max_connections);
1889 url_fprintf(pb, "Bandwidth in use: %"PRIu64"k / %"PRIu64"k<BR>\n",
1890 current_bandwidth, max_bandwidth);
1892 url_fprintf(pb, "<TABLE>\n");
1893 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");
1894 c1 = first_http_ctx;
1896 while (c1 != NULL) {
1902 for (j = 0; j < c1->stream->nb_streams; j++) {
1903 if (!c1->stream->feed)
1904 bitrate += c1->stream->streams[j]->codec->bit_rate;
1905 else if (c1->feed_streams[j] >= 0)
1906 bitrate += c1->stream->feed->streams[c1->feed_streams[j]]->codec->bit_rate;
1911 p = inet_ntoa(c1->from_addr.sin_addr);
1912 url_fprintf(pb, "<TR><TD><B>%d</B><TD>%s%s<TD>%s<TD>%s<TD>%s<td align=right>",
1914 c1->stream ? c1->stream->filename : "",
1915 c1->state == HTTPSTATE_RECEIVE_DATA ? "(input)" : "",
1918 http_state[c1->state]);
1919 fmt_bytecount(pb, bitrate);
1920 url_fprintf(pb, "<td align=right>");
1921 fmt_bytecount(pb, compute_datarate(&c1->datarate, c1->data_count) * 8);
1922 url_fprintf(pb, "<td align=right>");
1923 fmt_bytecount(pb, c1->data_count);
1924 url_fprintf(pb, "\n");
1927 url_fprintf(pb, "</TABLE>\n");
1932 url_fprintf(pb, "<HR size=1 noshade>Generated at %s", p);
1933 url_fprintf(pb, "</BODY>\n</HTML>\n");
1935 len = url_close_dyn_buf(pb, &c->pb_buffer);
1936 c->buffer_ptr = c->pb_buffer;
1937 c->buffer_end = c->pb_buffer + len;
1940 /* check if the parser needs to be opened for stream i */
1941 static void open_parser(AVFormatContext *s, int i)
1943 AVStream *st = s->streams[i];
1946 if (!st->codec->codec) {
1947 codec = avcodec_find_decoder(st->codec->codec_id);
1948 if (codec && (codec->capabilities & CODEC_CAP_PARSE_ONLY)) {
1949 st->codec->parse_only = 1;
1950 if (avcodec_open(st->codec, codec) < 0)
1951 st->codec->parse_only = 0;
1956 static int open_input_stream(HTTPContext *c, const char *info)
1959 char input_filename[1024];
1961 int buf_size, i, ret;
1964 /* find file name */
1965 if (c->stream->feed) {
1966 strcpy(input_filename, c->stream->feed->feed_filename);
1967 buf_size = FFM_PACKET_SIZE;
1968 /* compute position (absolute time) */
1969 if (find_info_tag(buf, sizeof(buf), "date", info)) {
1970 stream_pos = parse_date(buf, 0);
1971 if (stream_pos == INT64_MIN)
1973 } else if (find_info_tag(buf, sizeof(buf), "buffer", info)) {
1974 int prebuffer = strtol(buf, 0, 10);
1975 stream_pos = av_gettime() - prebuffer * (int64_t)1000000;
1977 stream_pos = av_gettime() - c->stream->prebuffer * (int64_t)1000;
1979 strcpy(input_filename, c->stream->feed_filename);
1981 /* compute position (relative time) */
1982 if (find_info_tag(buf, sizeof(buf), "date", info)) {
1983 stream_pos = parse_date(buf, 1);
1984 if (stream_pos == INT64_MIN)
1989 if (input_filename[0] == '\0')
1993 { time_t when = stream_pos / 1000000;
1994 http_log("Stream pos = %"PRId64", time=%s", stream_pos, ctime(&when));
1999 if ((ret = av_open_input_file(&s, input_filename, c->stream->ifmt,
2000 buf_size, c->stream->ap_in)) < 0) {
2001 http_log("could not open %s: %d\n", input_filename, ret);
2004 s->flags |= AVFMT_FLAG_GENPTS;
2006 if (strcmp(s->iformat->name, "ffm") && av_find_stream_info(c->fmt_in) < 0) {
2007 http_log("Could not find stream info '%s'\n", input_filename);
2008 av_close_input_file(s);
2012 /* open each parser */
2013 for(i=0;i<s->nb_streams;i++)
2016 /* choose stream as clock source (we favorize video stream if
2017 present) for packet sending */
2018 c->pts_stream_index = 0;
2019 for(i=0;i<c->stream->nb_streams;i++) {
2020 if (c->pts_stream_index == 0 &&
2021 c->stream->streams[i]->codec->codec_type == CODEC_TYPE_VIDEO) {
2022 c->pts_stream_index = i;
2027 if (c->fmt_in->iformat->read_seek)
2028 av_seek_frame(c->fmt_in, -1, stream_pos, 0);
2030 /* set the start time (needed for maxtime and RTP packet timing) */
2031 c->start_time = cur_time;
2032 c->first_pts = AV_NOPTS_VALUE;
2036 /* return the server clock (in us) */
2037 static int64_t get_server_clock(HTTPContext *c)
2039 /* compute current pts value from system time */
2040 return (cur_time - c->start_time) * 1000;
2043 /* return the estimated time at which the current packet must be sent
2045 static int64_t get_packet_send_clock(HTTPContext *c)
2047 int bytes_left, bytes_sent, frame_bytes;
2049 frame_bytes = c->cur_frame_bytes;
2050 if (frame_bytes <= 0)
2053 bytes_left = c->buffer_end - c->buffer_ptr;
2054 bytes_sent = frame_bytes - bytes_left;
2055 return c->cur_pts + (c->cur_frame_duration * bytes_sent) / frame_bytes;
2060 static int http_prepare_data(HTTPContext *c)
2063 AVFormatContext *ctx;
2065 av_freep(&c->pb_buffer);
2067 case HTTPSTATE_SEND_DATA_HEADER:
2068 memset(&c->fmt_ctx, 0, sizeof(c->fmt_ctx));
2069 av_metadata_set(&c->fmt_ctx.metadata, "author" ,c->stream->author);
2070 av_metadata_set(&c->fmt_ctx.metadata, "comment" ,c->stream->comment);
2071 av_metadata_set(&c->fmt_ctx.metadata, "copyright",c->stream->copyright);
2072 av_metadata_set(&c->fmt_ctx.metadata, "title" ,c->stream->title);
2074 for(i=0;i<c->stream->nb_streams;i++) {
2077 st = av_mallocz(sizeof(AVStream));
2078 c->fmt_ctx.streams[i] = st;
2079 /* if file or feed, then just take streams from FFStream struct */
2080 if (!c->stream->feed ||
2081 c->stream->feed == c->stream)
2082 src = c->stream->streams[i];
2084 src = c->stream->feed->streams[c->stream->feed_streams[i]];
2088 st->codec->frame_number = 0; /* XXX: should be done in
2089 AVStream, not in codec */
2091 /* set output format parameters */
2092 c->fmt_ctx.oformat = c->stream->fmt;
2093 c->fmt_ctx.nb_streams = c->stream->nb_streams;
2095 c->got_key_frame = 0;
2097 /* prepare header and save header data in a stream */
2098 if (url_open_dyn_buf(&c->fmt_ctx.pb) < 0) {
2099 /* XXX: potential leak */
2102 c->fmt_ctx.pb->is_streamed = 1;
2105 * HACK to avoid mpeg ps muxer to spit many underflow errors
2106 * Default value from FFmpeg
2107 * Try to set it use configuration option
2109 c->fmt_ctx.preload = (int)(0.5*AV_TIME_BASE);
2110 c->fmt_ctx.max_delay = (int)(0.7*AV_TIME_BASE);
2112 av_set_parameters(&c->fmt_ctx, NULL);
2113 if (av_write_header(&c->fmt_ctx) < 0) {
2114 http_log("Error writing output header\n");
2118 len = url_close_dyn_buf(c->fmt_ctx.pb, &c->pb_buffer);
2119 c->buffer_ptr = c->pb_buffer;
2120 c->buffer_end = c->pb_buffer + len;
2122 c->state = HTTPSTATE_SEND_DATA;
2123 c->last_packet_sent = 0;
2125 case HTTPSTATE_SEND_DATA:
2126 /* find a new packet */
2127 /* read a packet from the input stream */
2128 if (c->stream->feed)
2129 ffm_set_write_index(c->fmt_in,
2130 c->stream->feed->feed_write_index,
2131 c->stream->feed->feed_size);
2133 if (c->stream->max_time &&
2134 c->stream->max_time + c->start_time - cur_time < 0)
2135 /* We have timed out */
2136 c->state = HTTPSTATE_SEND_DATA_TRAILER;
2140 if (av_read_frame(c->fmt_in, &pkt) < 0) {
2141 if (c->stream->feed && c->stream->feed->feed_opened) {
2142 /* if coming from feed, it means we reached the end of the
2143 ffm file, so must wait for more data */
2144 c->state = HTTPSTATE_WAIT_FEED;
2145 return 1; /* state changed */
2147 if (c->stream->loop) {
2148 av_close_input_file(c->fmt_in);
2150 if (open_input_stream(c, "") < 0)
2155 /* must send trailer now because eof or error */
2156 c->state = HTTPSTATE_SEND_DATA_TRAILER;
2160 int source_index = pkt.stream_index;
2161 /* update first pts if needed */
2162 if (c->first_pts == AV_NOPTS_VALUE) {
2163 c->first_pts = av_rescale_q(pkt.dts, c->fmt_in->streams[pkt.stream_index]->time_base, AV_TIME_BASE_Q);
2164 c->start_time = cur_time;
2166 /* send it to the appropriate stream */
2167 if (c->stream->feed) {
2168 /* if coming from a feed, select the right stream */
2169 if (c->switch_pending) {
2170 c->switch_pending = 0;
2171 for(i=0;i<c->stream->nb_streams;i++) {
2172 if (c->switch_feed_streams[i] == pkt.stream_index)
2173 if (pkt.flags & PKT_FLAG_KEY)
2174 do_switch_stream(c, i);
2175 if (c->switch_feed_streams[i] >= 0)
2176 c->switch_pending = 1;
2179 for(i=0;i<c->stream->nb_streams;i++) {
2180 if (c->feed_streams[i] == pkt.stream_index) {
2181 AVStream *st = c->fmt_in->streams[source_index];
2182 pkt.stream_index = i;
2183 if (pkt.flags & PKT_FLAG_KEY &&
2184 (st->codec->codec_type == CODEC_TYPE_VIDEO ||
2185 c->stream->nb_streams == 1))
2186 c->got_key_frame = 1;
2187 if (!c->stream->send_on_key || c->got_key_frame)
2192 AVCodecContext *codec;
2193 AVStream *ist, *ost;
2195 ist = c->fmt_in->streams[source_index];
2196 /* specific handling for RTP: we use several
2197 output stream (one for each RTP
2198 connection). XXX: need more abstract handling */
2199 if (c->is_packetized) {
2200 /* compute send time and duration */
2201 c->cur_pts = av_rescale_q(pkt.dts, ist->time_base, AV_TIME_BASE_Q);
2202 if (ist->start_time != AV_NOPTS_VALUE)
2203 c->cur_pts -= av_rescale_q(ist->start_time, ist->time_base, AV_TIME_BASE_Q);
2204 c->cur_frame_duration = av_rescale_q(pkt.duration, ist->time_base, AV_TIME_BASE_Q);
2206 printf("index=%d pts=%0.3f duration=%0.6f\n",
2208 (double)c->cur_pts /
2210 (double)c->cur_frame_duration /
2213 /* find RTP context */
2214 c->packet_stream_index = pkt.stream_index;
2215 ctx = c->rtp_ctx[c->packet_stream_index];
2217 av_free_packet(&pkt);
2220 codec = ctx->streams[0]->codec;
2221 /* only one stream per RTP connection */
2222 pkt.stream_index = 0;
2226 codec = ctx->streams[pkt.stream_index]->codec;
2229 if (c->is_packetized) {
2230 int max_packet_size;
2231 if (c->rtp_protocol == RTSP_LOWER_TRANSPORT_TCP)
2232 max_packet_size = RTSP_TCP_MAX_PACKET_SIZE;
2234 max_packet_size = url_get_max_packet_size(c->rtp_handles[c->packet_stream_index]);
2235 ret = url_open_dyn_packet_buf(&ctx->pb, max_packet_size);
2237 ret = url_open_dyn_buf(&ctx->pb);
2240 /* XXX: potential leak */
2243 ost = ctx->streams[pkt.stream_index];
2245 ctx->pb->is_streamed = 1;
2246 if (pkt.dts != AV_NOPTS_VALUE)
2247 pkt.dts = av_rescale_q(pkt.dts, ist->time_base, ost->time_base);
2248 if (pkt.pts != AV_NOPTS_VALUE)
2249 pkt.pts = av_rescale_q(pkt.pts, ist->time_base, ost->time_base);
2250 pkt.duration = av_rescale_q(pkt.duration, ist->time_base, ost->time_base);
2251 if (av_write_frame(ctx, &pkt) < 0) {
2252 http_log("Error writing frame to output\n");
2253 c->state = HTTPSTATE_SEND_DATA_TRAILER;
2256 len = url_close_dyn_buf(ctx->pb, &c->pb_buffer);
2257 c->cur_frame_bytes = len;
2258 c->buffer_ptr = c->pb_buffer;
2259 c->buffer_end = c->pb_buffer + len;
2261 codec->frame_number++;
2263 av_free_packet(&pkt);
2267 av_free_packet(&pkt);
2272 case HTTPSTATE_SEND_DATA_TRAILER:
2273 /* last packet test ? */
2274 if (c->last_packet_sent || c->is_packetized)
2277 /* prepare header */
2278 if (url_open_dyn_buf(&ctx->pb) < 0) {
2279 /* XXX: potential leak */
2282 c->fmt_ctx.pb->is_streamed = 1;
2283 av_write_trailer(ctx);
2284 len = url_close_dyn_buf(ctx->pb, &c->pb_buffer);
2285 c->buffer_ptr = c->pb_buffer;
2286 c->buffer_end = c->pb_buffer + len;
2288 c->last_packet_sent = 1;
2294 /* should convert the format at the same time */
2295 /* send data starting at c->buffer_ptr to the output connection
2296 (either UDP or TCP connection) */
2297 static int http_send_data(HTTPContext *c)
2302 if (c->buffer_ptr >= c->buffer_end) {
2303 ret = http_prepare_data(c);
2307 /* state change requested */
2310 if (c->is_packetized) {
2311 /* RTP data output */
2312 len = c->buffer_end - c->buffer_ptr;
2314 /* fail safe - should never happen */
2316 c->buffer_ptr = c->buffer_end;
2319 len = (c->buffer_ptr[0] << 24) |
2320 (c->buffer_ptr[1] << 16) |
2321 (c->buffer_ptr[2] << 8) |
2323 if (len > (c->buffer_end - c->buffer_ptr))
2325 if ((get_packet_send_clock(c) - get_server_clock(c)) > 0) {
2326 /* nothing to send yet: we can wait */
2330 c->data_count += len;
2331 update_datarate(&c->datarate, c->data_count);
2333 c->stream->bytes_served += len;
2335 if (c->rtp_protocol == RTSP_LOWER_TRANSPORT_TCP) {
2336 /* RTP packets are sent inside the RTSP TCP connection */
2338 int interleaved_index, size;
2340 HTTPContext *rtsp_c;
2343 /* if no RTSP connection left, error */
2346 /* if already sending something, then wait. */
2347 if (rtsp_c->state != RTSPSTATE_WAIT_REQUEST)
2349 if (url_open_dyn_buf(&pb) < 0)
2351 interleaved_index = c->packet_stream_index * 2;
2352 /* RTCP packets are sent at odd indexes */
2353 if (c->buffer_ptr[1] == 200)
2354 interleaved_index++;
2355 /* write RTSP TCP header */
2357 header[1] = interleaved_index;
2358 header[2] = len >> 8;
2360 put_buffer(pb, header, 4);
2361 /* write RTP packet data */
2363 put_buffer(pb, c->buffer_ptr, len);
2364 size = url_close_dyn_buf(pb, &c->packet_buffer);
2365 /* prepare asynchronous TCP sending */
2366 rtsp_c->packet_buffer_ptr = c->packet_buffer;
2367 rtsp_c->packet_buffer_end = c->packet_buffer + size;
2368 c->buffer_ptr += len;
2370 /* send everything we can NOW */
2371 len = send(rtsp_c->fd, rtsp_c->packet_buffer_ptr,
2372 rtsp_c->packet_buffer_end - rtsp_c->packet_buffer_ptr, 0);
2374 rtsp_c->packet_buffer_ptr += len;
2375 if (rtsp_c->packet_buffer_ptr < rtsp_c->packet_buffer_end) {
2376 /* if we could not send all the data, we will
2377 send it later, so a new state is needed to
2378 "lock" the RTSP TCP connection */
2379 rtsp_c->state = RTSPSTATE_SEND_PACKET;
2382 /* all data has been sent */
2383 av_freep(&c->packet_buffer);
2385 /* send RTP packet directly in UDP */
2387 url_write(c->rtp_handles[c->packet_stream_index],
2388 c->buffer_ptr, len);
2389 c->buffer_ptr += len;
2390 /* here we continue as we can send several packets per 10 ms slot */
2393 /* TCP data output */
2394 len = send(c->fd, c->buffer_ptr, c->buffer_end - c->buffer_ptr, 0);
2396 if (ff_neterrno() != FF_NETERROR(EAGAIN) &&
2397 ff_neterrno() != FF_NETERROR(EINTR))
2398 /* error : close connection */
2403 c->buffer_ptr += len;
2405 c->data_count += len;
2406 update_datarate(&c->datarate, c->data_count);
2408 c->stream->bytes_served += len;
2416 static int http_start_receive_data(HTTPContext *c)
2420 if (c->stream->feed_opened)
2423 /* Don't permit writing to this one */
2424 if (c->stream->readonly)
2428 fd = open(c->stream->feed_filename, O_RDWR);
2430 http_log("Error opening feeder file: %s\n", strerror(errno));
2435 if (c->stream->truncate) {
2436 /* truncate feed file */
2437 ffm_write_write_index(c->feed_fd, FFM_PACKET_SIZE);
2438 ftruncate(c->feed_fd, FFM_PACKET_SIZE);
2439 http_log("Truncating feed file '%s'\n", c->stream->feed_filename);
2441 if ((c->stream->feed_write_index = ffm_read_write_index(fd)) < 0) {
2442 http_log("Error reading write index from feed file: %s\n", strerror(errno));
2447 c->stream->feed_write_index = FFMAX(ffm_read_write_index(fd), FFM_PACKET_SIZE);
2449 c->stream->feed_size = lseek(fd, 0, SEEK_END);
2450 lseek(fd, 0, SEEK_SET);
2452 /* init buffer input */
2453 c->buffer_ptr = c->buffer;
2454 c->buffer_end = c->buffer + FFM_PACKET_SIZE;
2455 c->stream->feed_opened = 1;
2459 static int http_receive_data(HTTPContext *c)
2463 if (c->buffer_end > c->buffer_ptr) {
2466 len = recv(c->fd, c->buffer_ptr, c->buffer_end - c->buffer_ptr, 0);
2468 if (ff_neterrno() != FF_NETERROR(EAGAIN) &&
2469 ff_neterrno() != FF_NETERROR(EINTR))
2470 /* error : close connection */
2472 } else if (len == 0)
2473 /* end of connection : close it */
2476 c->buffer_ptr += len;
2477 c->data_count += len;
2478 update_datarate(&c->datarate, c->data_count);
2482 if (c->buffer_ptr - c->buffer >= 2 && c->data_count > FFM_PACKET_SIZE) {
2483 if (c->buffer[0] != 'f' ||
2484 c->buffer[1] != 'm') {
2485 http_log("Feed stream has become desynchronized -- disconnecting\n");
2490 if (c->buffer_ptr >= c->buffer_end) {
2491 FFStream *feed = c->stream;
2492 /* a packet has been received : write it in the store, except
2494 if (c->data_count > FFM_PACKET_SIZE) {
2496 // printf("writing pos=0x%"PRIx64" size=0x%"PRIx64"\n", feed->feed_write_index, feed->feed_size);
2497 /* XXX: use llseek or url_seek */
2498 lseek(c->feed_fd, feed->feed_write_index, SEEK_SET);
2499 if (write(c->feed_fd, c->buffer, FFM_PACKET_SIZE) < 0) {
2500 http_log("Error writing to feed file: %s\n", strerror(errno));
2504 feed->feed_write_index += FFM_PACKET_SIZE;
2505 /* update file size */
2506 if (feed->feed_write_index > c->stream->feed_size)
2507 feed->feed_size = feed->feed_write_index;
2509 /* handle wrap around if max file size reached */
2510 if (c->stream->feed_max_size && feed->feed_write_index >= c->stream->feed_max_size)
2511 feed->feed_write_index = FFM_PACKET_SIZE;
2514 if (ffm_write_write_index(c->feed_fd, feed->feed_write_index) < 0) {
2515 http_log("Error writing index to feed file: %s\n", strerror(errno));
2519 /* wake up any waiting connections */
2520 for(c1 = first_http_ctx; c1 != NULL; c1 = c1->next) {
2521 if (c1->state == HTTPSTATE_WAIT_FEED &&
2522 c1->stream->feed == c->stream->feed)
2523 c1->state = HTTPSTATE_SEND_DATA;
2526 /* We have a header in our hands that contains useful data */
2527 AVFormatContext *s = NULL;
2529 AVInputFormat *fmt_in;
2532 /* use feed output format name to find corresponding input format */
2533 fmt_in = av_find_input_format(feed->fmt->name);
2537 url_open_buf(&pb, c->buffer, c->buffer_end - c->buffer, URL_RDONLY);
2538 pb->is_streamed = 1;
2540 if (av_open_input_stream(&s, pb, c->stream->feed_filename, fmt_in, NULL) < 0) {
2545 /* Now we have the actual streams */
2546 if (s->nb_streams != feed->nb_streams) {
2547 av_close_input_stream(s);
2549 http_log("Feed '%s' stream number does not match registered feed\n",
2550 c->stream->feed_filename);
2554 for (i = 0; i < s->nb_streams; i++) {
2555 AVStream *fst = feed->streams[i];
2556 AVStream *st = s->streams[i];
2557 memcpy(fst->codec, st->codec, sizeof(AVCodecContext));
2558 if (fst->codec->extradata_size) {
2559 fst->codec->extradata = av_malloc(fst->codec->extradata_size);
2560 if (!fst->codec->extradata)
2562 memcpy(fst->codec->extradata, st->codec->extradata,
2563 fst->codec->extradata_size);
2567 av_close_input_stream(s);
2570 c->buffer_ptr = c->buffer;
2575 c->stream->feed_opened = 0;
2577 /* wake up any waiting connections to stop waiting for feed */
2578 for(c1 = first_http_ctx; c1 != NULL; c1 = c1->next) {
2579 if (c1->state == HTTPSTATE_WAIT_FEED &&
2580 c1->stream->feed == c->stream->feed)
2581 c1->state = HTTPSTATE_SEND_DATA_TRAILER;
2586 /********************************************************************/
2589 static void rtsp_reply_header(HTTPContext *c, enum RTSPStatusCode error_number)
2596 switch(error_number) {
2597 case RTSP_STATUS_OK:
2600 case RTSP_STATUS_METHOD:
2601 str = "Method Not Allowed";
2603 case RTSP_STATUS_BANDWIDTH:
2604 str = "Not Enough Bandwidth";
2606 case RTSP_STATUS_SESSION:
2607 str = "Session Not Found";
2609 case RTSP_STATUS_STATE:
2610 str = "Method Not Valid in This State";
2612 case RTSP_STATUS_AGGREGATE:
2613 str = "Aggregate operation not allowed";
2615 case RTSP_STATUS_ONLY_AGGREGATE:
2616 str = "Only aggregate operation allowed";
2618 case RTSP_STATUS_TRANSPORT:
2619 str = "Unsupported transport";
2621 case RTSP_STATUS_INTERNAL:
2622 str = "Internal Server Error";
2624 case RTSP_STATUS_SERVICE:
2625 str = "Service Unavailable";
2627 case RTSP_STATUS_VERSION:
2628 str = "RTSP Version not supported";
2631 str = "Unknown Error";
2635 url_fprintf(c->pb, "RTSP/1.0 %d %s\r\n", error_number, str);
2636 url_fprintf(c->pb, "CSeq: %d\r\n", c->seq);
2638 /* output GMT time */
2642 p = buf2 + strlen(p) - 1;
2645 url_fprintf(c->pb, "Date: %s GMT\r\n", buf2);
2648 static void rtsp_reply_error(HTTPContext *c, enum RTSPStatusCode error_number)
2650 rtsp_reply_header(c, error_number);
2651 url_fprintf(c->pb, "\r\n");
2654 static int rtsp_parse_request(HTTPContext *c)
2656 const char *p, *p1, *p2;
2662 RTSPMessageHeader header1, *header = &header1;
2664 c->buffer_ptr[0] = '\0';
2667 get_word(cmd, sizeof(cmd), &p);
2668 get_word(url, sizeof(url), &p);
2669 get_word(protocol, sizeof(protocol), &p);
2671 av_strlcpy(c->method, cmd, sizeof(c->method));
2672 av_strlcpy(c->url, url, sizeof(c->url));
2673 av_strlcpy(c->protocol, protocol, sizeof(c->protocol));
2675 if (url_open_dyn_buf(&c->pb) < 0) {
2676 /* XXX: cannot do more */
2677 c->pb = NULL; /* safety */
2681 /* check version name */
2682 if (strcmp(protocol, "RTSP/1.0") != 0) {
2683 rtsp_reply_error(c, RTSP_STATUS_VERSION);
2687 /* parse each header line */
2688 memset(header, 0, sizeof(*header));
2689 /* skip to next line */
2690 while (*p != '\n' && *p != '\0')
2694 while (*p != '\0') {
2695 p1 = strchr(p, '\n');
2699 if (p2 > p && p2[-1] == '\r')
2701 /* skip empty line */
2705 if (len > sizeof(line) - 1)
2706 len = sizeof(line) - 1;
2707 memcpy(line, p, len);
2709 rtsp_parse_line(header, line);
2713 /* handle sequence number */
2714 c->seq = header->seq;
2716 if (!strcmp(cmd, "DESCRIBE"))
2717 rtsp_cmd_describe(c, url);
2718 else if (!strcmp(cmd, "OPTIONS"))
2719 rtsp_cmd_options(c, url);
2720 else if (!strcmp(cmd, "SETUP"))
2721 rtsp_cmd_setup(c, url, header);
2722 else if (!strcmp(cmd, "PLAY"))
2723 rtsp_cmd_play(c, url, header);
2724 else if (!strcmp(cmd, "PAUSE"))
2725 rtsp_cmd_pause(c, url, header);
2726 else if (!strcmp(cmd, "TEARDOWN"))
2727 rtsp_cmd_teardown(c, url, header);
2729 rtsp_reply_error(c, RTSP_STATUS_METHOD);
2732 len = url_close_dyn_buf(c->pb, &c->pb_buffer);
2733 c->pb = NULL; /* safety */
2735 /* XXX: cannot do more */
2738 c->buffer_ptr = c->pb_buffer;
2739 c->buffer_end = c->pb_buffer + len;
2740 c->state = RTSPSTATE_SEND_REPLY;
2744 static int prepare_sdp_description(FFStream *stream, uint8_t **pbuffer,
2745 struct in_addr my_ip)
2747 AVFormatContext *avc;
2748 AVStream avs[MAX_STREAMS];
2751 avc = avformat_alloc_context();
2755 av_metadata_set(&avc->metadata, "title",
2756 stream->title[0] ? stream->title : "No Title");
2757 avc->nb_streams = stream->nb_streams;
2758 if (stream->is_multicast) {
2759 snprintf(avc->filename, 1024, "rtp://%s:%d?multicast=1?ttl=%d",
2760 inet_ntoa(stream->multicast_ip),
2761 stream->multicast_port, stream->multicast_ttl);
2764 for(i = 0; i < stream->nb_streams; i++) {
2765 avc->streams[i] = &avs[i];
2766 avc->streams[i]->codec = stream->streams[i]->codec;
2768 *pbuffer = av_mallocz(2048);
2769 avf_sdp_create(&avc, 1, *pbuffer, 2048);
2772 return strlen(*pbuffer);
2775 static void rtsp_cmd_options(HTTPContext *c, const char *url)
2777 // rtsp_reply_header(c, RTSP_STATUS_OK);
2778 url_fprintf(c->pb, "RTSP/1.0 %d %s\r\n", RTSP_STATUS_OK, "OK");
2779 url_fprintf(c->pb, "CSeq: %d\r\n", c->seq);
2780 url_fprintf(c->pb, "Public: %s\r\n", "OPTIONS, DESCRIBE, SETUP, TEARDOWN, PLAY, PAUSE");
2781 url_fprintf(c->pb, "\r\n");
2784 static void rtsp_cmd_describe(HTTPContext *c, const char *url)
2790 int content_length, len;
2791 struct sockaddr_in my_addr;
2793 /* find which url is asked */
2794 url_split(NULL, 0, NULL, 0, NULL, 0, NULL, path1, sizeof(path1), url);
2799 for(stream = first_stream; stream != NULL; stream = stream->next) {
2800 if (!stream->is_feed &&
2801 stream->fmt && !strcmp(stream->fmt->name, "rtp") &&
2802 !strcmp(path, stream->filename)) {
2806 /* no stream found */
2807 rtsp_reply_error(c, RTSP_STATUS_SERVICE); /* XXX: right error ? */
2811 /* prepare the media description in sdp format */
2813 /* get the host IP */
2814 len = sizeof(my_addr);
2815 getsockname(c->fd, (struct sockaddr *)&my_addr, &len);
2816 content_length = prepare_sdp_description(stream, &content, my_addr.sin_addr);
2817 if (content_length < 0) {
2818 rtsp_reply_error(c, RTSP_STATUS_INTERNAL);
2821 rtsp_reply_header(c, RTSP_STATUS_OK);
2822 url_fprintf(c->pb, "Content-Type: application/sdp\r\n");
2823 url_fprintf(c->pb, "Content-Length: %d\r\n", content_length);
2824 url_fprintf(c->pb, "\r\n");
2825 put_buffer(c->pb, content, content_length);
2828 static HTTPContext *find_rtp_session(const char *session_id)
2832 if (session_id[0] == '\0')
2835 for(c = first_http_ctx; c != NULL; c = c->next) {
2836 if (!strcmp(c->session_id, session_id))
2842 static RTSPTransportField *find_transport(RTSPMessageHeader *h, enum RTSPLowerTransport lower_transport)
2844 RTSPTransportField *th;
2847 for(i=0;i<h->nb_transports;i++) {
2848 th = &h->transports[i];
2849 if (th->lower_transport == lower_transport)
2855 static void rtsp_cmd_setup(HTTPContext *c, const char *url,
2856 RTSPMessageHeader *h)
2859 int stream_index, port;
2864 RTSPTransportField *th;
2865 struct sockaddr_in dest_addr;
2866 RTSPActionServerSetup setup;
2868 /* find which url is asked */
2869 url_split(NULL, 0, NULL, 0, NULL, 0, NULL, path1, sizeof(path1), url);
2874 /* now check each stream */
2875 for(stream = first_stream; stream != NULL; stream = stream->next) {
2876 if (!stream->is_feed &&
2877 stream->fmt && !strcmp(stream->fmt->name, "rtp")) {
2878 /* accept aggregate filenames only if single stream */
2879 if (!strcmp(path, stream->filename)) {
2880 if (stream->nb_streams != 1) {
2881 rtsp_reply_error(c, RTSP_STATUS_AGGREGATE);
2888 for(stream_index = 0; stream_index < stream->nb_streams;
2890 snprintf(buf, sizeof(buf), "%s/streamid=%d",
2891 stream->filename, stream_index);
2892 if (!strcmp(path, buf))
2897 /* no stream found */
2898 rtsp_reply_error(c, RTSP_STATUS_SERVICE); /* XXX: right error ? */
2902 /* generate session id if needed */
2903 if (h->session_id[0] == '\0')
2904 snprintf(h->session_id, sizeof(h->session_id), "%08x%08x",
2905 av_lfg_get(&random_state), av_lfg_get(&random_state));
2907 /* find rtp session, and create it if none found */
2908 rtp_c = find_rtp_session(h->session_id);
2910 /* always prefer UDP */
2911 th = find_transport(h, RTSP_LOWER_TRANSPORT_UDP);
2913 th = find_transport(h, RTSP_LOWER_TRANSPORT_TCP);
2915 rtsp_reply_error(c, RTSP_STATUS_TRANSPORT);
2920 rtp_c = rtp_new_connection(&c->from_addr, stream, h->session_id,
2921 th->lower_transport);
2923 rtsp_reply_error(c, RTSP_STATUS_BANDWIDTH);
2927 /* open input stream */
2928 if (open_input_stream(rtp_c, "") < 0) {
2929 rtsp_reply_error(c, RTSP_STATUS_INTERNAL);
2934 /* test if stream is OK (test needed because several SETUP needs
2935 to be done for a given file) */
2936 if (rtp_c->stream != stream) {
2937 rtsp_reply_error(c, RTSP_STATUS_SERVICE);
2941 /* test if stream is already set up */
2942 if (rtp_c->rtp_ctx[stream_index]) {
2943 rtsp_reply_error(c, RTSP_STATUS_STATE);
2947 /* check transport */
2948 th = find_transport(h, rtp_c->rtp_protocol);
2949 if (!th || (th->lower_transport == RTSP_LOWER_TRANSPORT_UDP &&
2950 th->client_port_min <= 0)) {
2951 rtsp_reply_error(c, RTSP_STATUS_TRANSPORT);
2955 /* setup default options */
2956 setup.transport_option[0] = '\0';
2957 dest_addr = rtp_c->from_addr;
2958 dest_addr.sin_port = htons(th->client_port_min);
2961 if (rtp_new_av_stream(rtp_c, stream_index, &dest_addr, c) < 0) {
2962 rtsp_reply_error(c, RTSP_STATUS_TRANSPORT);
2966 /* now everything is OK, so we can send the connection parameters */
2967 rtsp_reply_header(c, RTSP_STATUS_OK);
2969 url_fprintf(c->pb, "Session: %s\r\n", rtp_c->session_id);
2971 switch(rtp_c->rtp_protocol) {
2972 case RTSP_LOWER_TRANSPORT_UDP:
2973 port = rtp_get_local_port(rtp_c->rtp_handles[stream_index]);
2974 url_fprintf(c->pb, "Transport: RTP/AVP/UDP;unicast;"
2975 "client_port=%d-%d;server_port=%d-%d",
2976 th->client_port_min, th->client_port_min + 1,
2979 case RTSP_LOWER_TRANSPORT_TCP:
2980 url_fprintf(c->pb, "Transport: RTP/AVP/TCP;interleaved=%d-%d",
2981 stream_index * 2, stream_index * 2 + 1);
2986 if (setup.transport_option[0] != '\0')
2987 url_fprintf(c->pb, ";%s", setup.transport_option);
2988 url_fprintf(c->pb, "\r\n");
2991 url_fprintf(c->pb, "\r\n");
2995 /* find an rtp connection by using the session ID. Check consistency
2997 static HTTPContext *find_rtp_session_with_url(const char *url,
2998 const char *session_id)
3006 rtp_c = find_rtp_session(session_id);
3010 /* find which url is asked */
3011 url_split(NULL, 0, NULL, 0, NULL, 0, NULL, path1, sizeof(path1), url);
3015 if(!strcmp(path, rtp_c->stream->filename)) return rtp_c;
3016 for(s=0; s<rtp_c->stream->nb_streams; ++s) {
3017 snprintf(buf, sizeof(buf), "%s/streamid=%d",
3018 rtp_c->stream->filename, s);
3019 if(!strncmp(path, buf, sizeof(buf))) {
3020 // XXX: Should we reply with RTSP_STATUS_ONLY_AGGREGATE if nb_streams>1?
3027 static void rtsp_cmd_play(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 rtp_c->state != HTTPSTATE_READY) {
3040 rtsp_reply_error(c, RTSP_STATUS_STATE);
3045 /* XXX: seek in stream */
3046 if (h->range_start != AV_NOPTS_VALUE) {
3047 printf("range_start=%0.3f\n", (double)h->range_start / AV_TIME_BASE);
3048 av_seek_frame(rtp_c->fmt_in, -1, h->range_start);
3052 rtp_c->state = HTTPSTATE_SEND_DATA;
3054 /* now everything is OK, so we can send the connection parameters */
3055 rtsp_reply_header(c, RTSP_STATUS_OK);
3057 url_fprintf(c->pb, "Session: %s\r\n", rtp_c->session_id);
3058 url_fprintf(c->pb, "\r\n");
3061 static void rtsp_cmd_pause(HTTPContext *c, const char *url, RTSPMessageHeader *h)
3065 rtp_c = find_rtp_session_with_url(url, h->session_id);
3067 rtsp_reply_error(c, RTSP_STATUS_SESSION);
3071 if (rtp_c->state != HTTPSTATE_SEND_DATA &&
3072 rtp_c->state != HTTPSTATE_WAIT_FEED) {
3073 rtsp_reply_error(c, RTSP_STATUS_STATE);
3077 rtp_c->state = HTTPSTATE_READY;
3078 rtp_c->first_pts = AV_NOPTS_VALUE;
3079 /* now everything is OK, so we can send the connection parameters */
3080 rtsp_reply_header(c, RTSP_STATUS_OK);
3082 url_fprintf(c->pb, "Session: %s\r\n", rtp_c->session_id);
3083 url_fprintf(c->pb, "\r\n");
3086 static void rtsp_cmd_teardown(HTTPContext *c, const char *url, RTSPMessageHeader *h)
3089 char session_id[32];
3091 rtp_c = find_rtp_session_with_url(url, h->session_id);
3093 rtsp_reply_error(c, RTSP_STATUS_SESSION);
3097 av_strlcpy(session_id, rtp_c->session_id, sizeof(session_id));
3099 /* abort the session */
3100 close_connection(rtp_c);
3102 /* now everything is OK, so we can send the connection parameters */
3103 rtsp_reply_header(c, RTSP_STATUS_OK);
3105 url_fprintf(c->pb, "Session: %s\r\n", session_id);
3106 url_fprintf(c->pb, "\r\n");
3110 /********************************************************************/
3113 static HTTPContext *rtp_new_connection(struct sockaddr_in *from_addr,
3114 FFStream *stream, const char *session_id,
3115 enum RTSPLowerTransport rtp_protocol)
3117 HTTPContext *c = NULL;
3118 const char *proto_str;
3120 /* XXX: should output a warning page when coming
3121 close to the connection limit */
3122 if (nb_connections >= nb_max_connections)
3125 /* add a new connection */
3126 c = av_mallocz(sizeof(HTTPContext));
3131 c->poll_entry = NULL;
3132 c->from_addr = *from_addr;
3133 c->buffer_size = IOBUFFER_INIT_SIZE;
3134 c->buffer = av_malloc(c->buffer_size);
3139 av_strlcpy(c->session_id, session_id, sizeof(c->session_id));
3140 c->state = HTTPSTATE_READY;
3141 c->is_packetized = 1;
3142 c->rtp_protocol = rtp_protocol;
3144 /* protocol is shown in statistics */
3145 switch(c->rtp_protocol) {
3146 case RTSP_LOWER_TRANSPORT_UDP_MULTICAST:
3147 proto_str = "MCAST";
3149 case RTSP_LOWER_TRANSPORT_UDP:
3152 case RTSP_LOWER_TRANSPORT_TCP:
3159 av_strlcpy(c->protocol, "RTP/", sizeof(c->protocol));
3160 av_strlcat(c->protocol, proto_str, sizeof(c->protocol));
3162 current_bandwidth += stream->bandwidth;
3164 c->next = first_http_ctx;
3176 /* add a new RTP stream in an RTP connection (used in RTSP SETUP
3177 command). If RTP/TCP protocol is used, TCP connection 'rtsp_c' is
3179 static int rtp_new_av_stream(HTTPContext *c,
3180 int stream_index, struct sockaddr_in *dest_addr,
3181 HTTPContext *rtsp_c)
3183 AVFormatContext *ctx;
3186 URLContext *h = NULL;
3188 int max_packet_size;
3190 /* now we can open the relevant output stream */
3191 ctx = avformat_alloc_context();
3194 ctx->oformat = guess_format("rtp", NULL, NULL);
3196 st = av_mallocz(sizeof(AVStream));
3199 st->codec= avcodec_alloc_context();
3200 ctx->nb_streams = 1;
3201 ctx->streams[0] = st;
3203 if (!c->stream->feed ||
3204 c->stream->feed == c->stream)
3205 memcpy(st, c->stream->streams[stream_index], sizeof(AVStream));
3208 c->stream->feed->streams[c->stream->feed_streams[stream_index]],
3210 st->priv_data = NULL;
3212 /* build destination RTP address */
3213 ipaddr = inet_ntoa(dest_addr->sin_addr);
3215 switch(c->rtp_protocol) {
3216 case RTSP_LOWER_TRANSPORT_UDP:
3217 case RTSP_LOWER_TRANSPORT_UDP_MULTICAST:
3220 /* XXX: also pass as parameter to function ? */
3221 if (c->stream->is_multicast) {
3223 ttl = c->stream->multicast_ttl;
3226 snprintf(ctx->filename, sizeof(ctx->filename),
3227 "rtp://%s:%d?multicast=1&ttl=%d",
3228 ipaddr, ntohs(dest_addr->sin_port), ttl);
3230 snprintf(ctx->filename, sizeof(ctx->filename),
3231 "rtp://%s:%d", ipaddr, ntohs(dest_addr->sin_port));
3234 if (url_open(&h, ctx->filename, URL_WRONLY) < 0)
3236 c->rtp_handles[stream_index] = h;
3237 max_packet_size = url_get_max_packet_size(h);
3239 case RTSP_LOWER_TRANSPORT_TCP:
3242 max_packet_size = RTSP_TCP_MAX_PACKET_SIZE;
3248 http_log("%s:%d - - \"PLAY %s/streamid=%d %s\"\n",
3249 ipaddr, ntohs(dest_addr->sin_port),
3250 c->stream->filename, stream_index, c->protocol);
3252 /* normally, no packets should be output here, but the packet size may be checked */
3253 if (url_open_dyn_packet_buf(&ctx->pb, max_packet_size) < 0) {
3254 /* XXX: close stream */
3257 av_set_parameters(ctx, NULL);
3258 if (av_write_header(ctx) < 0) {
3265 url_close_dyn_buf(ctx->pb, &dummy_buf);
3268 c->rtp_ctx[stream_index] = ctx;
3272 /********************************************************************/
3273 /* ffserver initialization */
3275 static AVStream *add_av_stream1(FFStream *stream, AVCodecContext *codec)
3279 fst = av_mallocz(sizeof(AVStream));
3282 fst->codec= avcodec_alloc_context();
3283 fst->priv_data = av_mallocz(sizeof(FeedData));
3284 memcpy(fst->codec, codec, sizeof(AVCodecContext));
3285 fst->index = stream->nb_streams;
3286 av_set_pts_info(fst, 33, 1, 90000);
3287 stream->streams[stream->nb_streams++] = fst;
3291 /* return the stream number in the feed */
3292 static int add_av_stream(FFStream *feed, AVStream *st)
3295 AVCodecContext *av, *av1;
3299 for(i=0;i<feed->nb_streams;i++) {
3300 st = feed->streams[i];
3302 if (av1->codec_id == av->codec_id &&
3303 av1->codec_type == av->codec_type &&
3304 av1->bit_rate == av->bit_rate) {
3306 switch(av->codec_type) {
3307 case CODEC_TYPE_AUDIO:
3308 if (av1->channels == av->channels &&
3309 av1->sample_rate == av->sample_rate)
3312 case CODEC_TYPE_VIDEO:
3313 if (av1->width == av->width &&
3314 av1->height == av->height &&
3315 av1->time_base.den == av->time_base.den &&
3316 av1->time_base.num == av->time_base.num &&
3317 av1->gop_size == av->gop_size)
3326 fst = add_av_stream1(feed, av);
3329 return feed->nb_streams - 1;
3334 static void remove_stream(FFStream *stream)
3338 while (*ps != NULL) {
3346 /* specific mpeg4 handling : we extract the raw parameters */
3347 static void extract_mpeg4_header(AVFormatContext *infile)
3349 int mpeg4_count, i, size;
3355 for(i=0;i<infile->nb_streams;i++) {
3356 st = infile->streams[i];
3357 if (st->codec->codec_id == CODEC_ID_MPEG4 &&
3358 st->codec->extradata_size == 0) {
3365 printf("MPEG4 without extra data: trying to find header in %s\n", infile->filename);
3366 while (mpeg4_count > 0) {
3367 if (av_read_packet(infile, &pkt) < 0)
3369 st = infile->streams[pkt.stream_index];
3370 if (st->codec->codec_id == CODEC_ID_MPEG4 &&
3371 st->codec->extradata_size == 0) {
3372 av_freep(&st->codec->extradata);
3373 /* fill extradata with the header */
3374 /* XXX: we make hard suppositions here ! */
3376 while (p < pkt.data + pkt.size - 4) {
3377 /* stop when vop header is found */
3378 if (p[0] == 0x00 && p[1] == 0x00 &&
3379 p[2] == 0x01 && p[3] == 0xb6) {
3380 size = p - pkt.data;
3381 // av_hex_dump_log(infile, AV_LOG_DEBUG, pkt.data, size);
3382 st->codec->extradata = av_malloc(size);
3383 st->codec->extradata_size = size;
3384 memcpy(st->codec->extradata, pkt.data, size);
3391 av_free_packet(&pkt);
3395 /* compute the needed AVStream for each file */
3396 static void build_file_streams(void)
3398 FFStream *stream, *stream_next;
3399 AVFormatContext *infile;
3402 /* gather all streams */
3403 for(stream = first_stream; stream != NULL; stream = stream_next) {
3404 stream_next = stream->next;
3405 if (stream->stream_type == STREAM_TYPE_LIVE &&
3407 /* the stream comes from a file */
3408 /* try to open the file */
3410 stream->ap_in = av_mallocz(sizeof(AVFormatParameters));
3411 if (stream->fmt && !strcmp(stream->fmt->name, "rtp")) {
3412 /* specific case : if transport stream output to RTP,
3413 we use a raw transport stream reader */
3414 stream->ap_in->mpeg2ts_raw = 1;
3415 stream->ap_in->mpeg2ts_compute_pcr = 1;
3418 http_log("Opening file '%s'\n", stream->feed_filename);
3419 if ((ret = av_open_input_file(&infile, stream->feed_filename,
3420 stream->ifmt, 0, stream->ap_in)) < 0) {
3421 http_log("Could not open '%s': %d\n", stream->feed_filename, ret);
3422 /* remove stream (no need to spend more time on it) */
3424 remove_stream(stream);
3426 /* find all the AVStreams inside and reference them in
3428 if (av_find_stream_info(infile) < 0) {
3429 http_log("Could not find codec parameters from '%s'\n",
3430 stream->feed_filename);
3431 av_close_input_file(infile);
3434 extract_mpeg4_header(infile);
3436 for(i=0;i<infile->nb_streams;i++)
3437 add_av_stream1(stream, infile->streams[i]->codec);
3439 av_close_input_file(infile);
3445 /* compute the needed AVStream for each feed */
3446 static void build_feed_streams(void)
3448 FFStream *stream, *feed;
3451 /* gather all streams */
3452 for(stream = first_stream; stream != NULL; stream = stream->next) {
3453 feed = stream->feed;
3455 if (!stream->is_feed) {
3456 /* we handle a stream coming from a feed */
3457 for(i=0;i<stream->nb_streams;i++)
3458 stream->feed_streams[i] = add_av_stream(feed, stream->streams[i]);
3463 /* gather all streams */
3464 for(stream = first_stream; stream != NULL; stream = stream->next) {
3465 feed = stream->feed;
3467 if (stream->is_feed) {
3468 for(i=0;i<stream->nb_streams;i++)
3469 stream->feed_streams[i] = i;
3474 /* create feed files if needed */
3475 for(feed = first_feed; feed != NULL; feed = feed->next_feed) {
3478 if (url_exist(feed->feed_filename)) {
3479 /* See if it matches */
3483 if (av_open_input_file(&s, feed->feed_filename, NULL, FFM_PACKET_SIZE, NULL) >= 0) {
3484 /* Now see if it matches */
3485 if (s->nb_streams == feed->nb_streams) {
3487 for(i=0;i<s->nb_streams;i++) {
3489 sf = feed->streams[i];
3492 if (sf->index != ss->index ||
3494 http_log("Index & Id do not match for stream %d (%s)\n",
3495 i, feed->feed_filename);
3498 AVCodecContext *ccf, *ccs;
3502 #define CHECK_CODEC(x) (ccf->x != ccs->x)
3504 if (CHECK_CODEC(codec) || CHECK_CODEC(codec_type)) {
3505 http_log("Codecs do not match for stream %d\n", i);
3507 } else if (CHECK_CODEC(bit_rate) || CHECK_CODEC(flags)) {
3508 http_log("Codec bitrates do not match for stream %d\n", i);
3510 } else if (ccf->codec_type == CODEC_TYPE_VIDEO) {
3511 if (CHECK_CODEC(time_base.den) ||
3512 CHECK_CODEC(time_base.num) ||
3513 CHECK_CODEC(width) ||
3514 CHECK_CODEC(height)) {
3515 http_log("Codec width, height and framerate do not match for stream %d\n", i);
3518 } else if (ccf->codec_type == CODEC_TYPE_AUDIO) {
3519 if (CHECK_CODEC(sample_rate) ||
3520 CHECK_CODEC(channels) ||
3521 CHECK_CODEC(frame_size)) {
3522 http_log("Codec sample_rate, channels, frame_size do not match for stream %d\n", i);
3526 http_log("Unknown codec type\n");
3534 http_log("Deleting feed file '%s' as stream counts differ (%d != %d)\n",
3535 feed->feed_filename, s->nb_streams, feed->nb_streams);
3537 av_close_input_file(s);
3539 http_log("Deleting feed file '%s' as it appears to be corrupt\n",
3540 feed->feed_filename);
3543 if (feed->readonly) {
3544 http_log("Unable to delete feed file '%s' as it is marked readonly\n",
3545 feed->feed_filename);
3548 unlink(feed->feed_filename);
3551 if (!url_exist(feed->feed_filename)) {
3552 AVFormatContext s1 = {0}, *s = &s1;
3554 if (feed->readonly) {
3555 http_log("Unable to create feed file '%s' as it is marked readonly\n",
3556 feed->feed_filename);
3560 /* only write the header of the ffm file */
3561 if (url_fopen(&s->pb, feed->feed_filename, URL_WRONLY) < 0) {
3562 http_log("Could not open output feed file '%s'\n",
3563 feed->feed_filename);
3566 s->oformat = feed->fmt;
3567 s->nb_streams = feed->nb_streams;
3568 for(i=0;i<s->nb_streams;i++) {
3570 st = feed->streams[i];
3573 av_set_parameters(s, NULL);
3574 if (av_write_header(s) < 0) {
3575 http_log("Container doesn't supports the required parameters\n");
3578 /* XXX: need better api */
3579 av_freep(&s->priv_data);
3582 /* get feed size and write index */
3583 fd = open(feed->feed_filename, O_RDONLY);
3585 http_log("Could not open output feed file '%s'\n",
3586 feed->feed_filename);
3590 feed->feed_write_index = FFMAX(ffm_read_write_index(fd), FFM_PACKET_SIZE);
3591 feed->feed_size = lseek(fd, 0, SEEK_END);
3592 /* ensure that we do not wrap before the end of file */
3593 if (feed->feed_max_size && feed->feed_max_size < feed->feed_size)
3594 feed->feed_max_size = feed->feed_size;
3600 /* compute the bandwidth used by each stream */
3601 static void compute_bandwidth(void)
3607 for(stream = first_stream; stream != NULL; stream = stream->next) {
3609 for(i=0;i<stream->nb_streams;i++) {
3610 AVStream *st = stream->streams[i];
3611 switch(st->codec->codec_type) {
3612 case CODEC_TYPE_AUDIO:
3613 case CODEC_TYPE_VIDEO:
3614 bandwidth += st->codec->bit_rate;
3620 stream->bandwidth = (bandwidth + 999) / 1000;
3624 static void get_arg(char *buf, int buf_size, const char **pp)
3631 while (isspace(*p)) p++;
3634 if (*p == '\"' || *p == '\'')
3646 if ((q - buf) < buf_size - 1)
3651 if (quote && *p == quote)
3656 /* add a codec and set the default parameters */
3657 static void add_codec(FFStream *stream, AVCodecContext *av)
3661 /* compute default parameters */
3662 switch(av->codec_type) {
3663 case CODEC_TYPE_AUDIO:
3664 if (av->bit_rate == 0)
3665 av->bit_rate = 64000;
3666 if (av->sample_rate == 0)
3667 av->sample_rate = 22050;
3668 if (av->channels == 0)
3671 case CODEC_TYPE_VIDEO:
3672 if (av->bit_rate == 0)
3673 av->bit_rate = 64000;
3674 if (av->time_base.num == 0){
3675 av->time_base.den = 5;
3676 av->time_base.num = 1;
3678 if (av->width == 0 || av->height == 0) {
3682 /* Bitrate tolerance is less for streaming */
3683 if (av->bit_rate_tolerance == 0)
3684 av->bit_rate_tolerance = FFMAX(av->bit_rate / 4,
3685 (int64_t)av->bit_rate*av->time_base.num/av->time_base.den);
3690 if (av->max_qdiff == 0)
3692 av->qcompress = 0.5;
3695 if (!av->nsse_weight)
3696 av->nsse_weight = 8;
3698 av->frame_skip_cmp = FF_CMP_DCTMAX;
3699 av->me_method = ME_EPZS;
3700 av->rc_buffer_aggressivity = 1.0;
3703 av->rc_eq = "tex^qComp";
3704 if (!av->i_quant_factor)
3705 av->i_quant_factor = -0.8;
3706 if (!av->b_quant_factor)
3707 av->b_quant_factor = 1.25;
3708 if (!av->b_quant_offset)
3709 av->b_quant_offset = 1.25;
3710 if (!av->rc_max_rate)
3711 av->rc_max_rate = av->bit_rate * 2;
3713 if (av->rc_max_rate && !av->rc_buffer_size) {
3714 av->rc_buffer_size = av->rc_max_rate;
3723 st = av_mallocz(sizeof(AVStream));
3726 st->codec = avcodec_alloc_context();
3727 stream->streams[stream->nb_streams++] = st;
3728 memcpy(st->codec, av, sizeof(AVCodecContext));
3731 static enum CodecID opt_audio_codec(const char *arg)
3733 AVCodec *p= avcodec_find_encoder_by_name(arg);
3735 if (p == NULL || p->type != CODEC_TYPE_AUDIO)
3736 return CODEC_ID_NONE;
3741 static enum CodecID opt_video_codec(const char *arg)
3743 AVCodec *p= avcodec_find_encoder_by_name(arg);
3745 if (p == NULL || p->type != CODEC_TYPE_VIDEO)
3746 return CODEC_ID_NONE;
3751 /* simplistic plugin support */
3754 static void load_module(const char *filename)
3757 void (*init_func)(void);
3758 dll = dlopen(filename, RTLD_NOW);
3760 fprintf(stderr, "Could not load module '%s' - %s\n",
3761 filename, dlerror());
3765 init_func = dlsym(dll, "ffserver_module_init");
3768 "%s: init function 'ffserver_module_init()' not found\n",
3777 static int ffserver_opt_default(const char *opt, const char *arg,
3778 AVCodecContext *avctx, int type)
3781 const AVOption *o = av_find_opt(avctx, opt, NULL, type, type);
3783 ret = av_set_string3(avctx, opt, arg, 1, NULL);
3787 static int parse_ffconfig(const char *filename)
3794 int val, errors, line_num;
3795 FFStream **last_stream, *stream, *redirect;
3796 FFStream **last_feed, *feed, *s;
3797 AVCodecContext audio_enc, video_enc;
3798 enum CodecID audio_id, video_id;
3800 f = fopen(filename, "r");
3808 first_stream = NULL;
3809 last_stream = &first_stream;
3811 last_feed = &first_feed;
3815 audio_id = CODEC_ID_NONE;
3816 video_id = CODEC_ID_NONE;
3818 if (fgets(line, sizeof(line), f) == NULL)
3824 if (*p == '\0' || *p == '#')
3827 get_arg(cmd, sizeof(cmd), &p);
3829 if (!strcasecmp(cmd, "Port")) {
3830 get_arg(arg, sizeof(arg), &p);
3832 if (val < 1 || val > 65536) {
3833 fprintf(stderr, "%s:%d: Invalid port: %s\n",
3834 filename, line_num, arg);
3837 my_http_addr.sin_port = htons(val);
3838 } else if (!strcasecmp(cmd, "BindAddress")) {
3839 get_arg(arg, sizeof(arg), &p);
3840 if (resolve_host(&my_http_addr.sin_addr, arg) != 0) {
3841 fprintf(stderr, "%s:%d: Invalid host/IP address: %s\n",
3842 filename, line_num, arg);
3845 } else if (!strcasecmp(cmd, "NoDaemon")) {
3846 ffserver_daemon = 0;
3847 } else if (!strcasecmp(cmd, "RTSPPort")) {
3848 get_arg(arg, sizeof(arg), &p);
3850 if (val < 1 || val > 65536) {
3851 fprintf(stderr, "%s:%d: Invalid port: %s\n",
3852 filename, line_num, arg);
3855 my_rtsp_addr.sin_port = htons(atoi(arg));
3856 } else if (!strcasecmp(cmd, "RTSPBindAddress")) {
3857 get_arg(arg, sizeof(arg), &p);
3858 if (resolve_host(&my_rtsp_addr.sin_addr, arg) != 0) {
3859 fprintf(stderr, "%s:%d: Invalid host/IP address: %s\n",
3860 filename, line_num, arg);
3863 } else if (!strcasecmp(cmd, "MaxHTTPConnections")) {
3864 get_arg(arg, sizeof(arg), &p);
3866 if (val < 1 || val > 65536) {
3867 fprintf(stderr, "%s:%d: Invalid MaxHTTPConnections: %s\n",
3868 filename, line_num, arg);
3871 nb_max_http_connections = val;
3872 } else if (!strcasecmp(cmd, "MaxClients")) {
3873 get_arg(arg, sizeof(arg), &p);
3875 if (val < 1 || val > nb_max_http_connections) {
3876 fprintf(stderr, "%s:%d: Invalid MaxClients: %s\n",
3877 filename, line_num, arg);
3880 nb_max_connections = val;
3882 } else if (!strcasecmp(cmd, "MaxBandwidth")) {
3884 get_arg(arg, sizeof(arg), &p);
3886 if (llval < 10 || llval > 10000000) {
3887 fprintf(stderr, "%s:%d: Invalid MaxBandwidth: %s\n",
3888 filename, line_num, arg);
3891 max_bandwidth = llval;
3892 } else if (!strcasecmp(cmd, "CustomLog")) {
3893 if (!ffserver_debug)
3894 get_arg(logfilename, sizeof(logfilename), &p);
3895 } else if (!strcasecmp(cmd, "<Feed")) {
3896 /*********************************************/
3897 /* Feed related options */
3899 if (stream || feed) {
3900 fprintf(stderr, "%s:%d: Already in a tag\n",
3901 filename, line_num);
3903 feed = av_mallocz(sizeof(FFStream));
3904 get_arg(feed->filename, sizeof(feed->filename), &p);
3905 q = strrchr(feed->filename, '>');
3909 for (s = first_feed; s; s = s->next) {
3910 if (!strcmp(feed->filename, s->filename)) {
3911 fprintf(stderr, "%s:%d: Feed '%s' already registered\n",
3912 filename, line_num, s->filename);
3917 feed->fmt = guess_format("ffm", NULL, NULL);
3918 /* defaut feed file */
3919 snprintf(feed->feed_filename, sizeof(feed->feed_filename),
3920 "/tmp/%s.ffm", feed->filename);
3921 feed->feed_max_size = 5 * 1024 * 1024;
3923 feed->feed = feed; /* self feeding :-) */
3925 /* add in stream list */
3926 *last_stream = feed;
3927 last_stream = &feed->next;
3928 /* add in feed list */
3930 last_feed = &feed->next_feed;
3932 } else if (!strcasecmp(cmd, "Launch")) {
3936 feed->child_argv = av_mallocz(64 * sizeof(char *));
3938 for (i = 0; i < 62; i++) {
3939 get_arg(arg, sizeof(arg), &p);
3943 feed->child_argv[i] = av_strdup(arg);
3946 feed->child_argv[i] = av_malloc(30 + strlen(feed->filename));
3948 snprintf(feed->child_argv[i], 30+strlen(feed->filename),
3950 (my_http_addr.sin_addr.s_addr == INADDR_ANY) ? "127.0.0.1" :
3951 inet_ntoa(my_http_addr.sin_addr),
3952 ntohs(my_http_addr.sin_port), feed->filename);
3954 } else if (!strcasecmp(cmd, "ReadOnlyFile")) {
3956 get_arg(feed->feed_filename, sizeof(feed->feed_filename), &p);
3958 } else if (stream) {
3959 get_arg(stream->feed_filename, sizeof(stream->feed_filename), &p);
3961 } else if (!strcasecmp(cmd, "File")) {
3963 get_arg(feed->feed_filename, sizeof(feed->feed_filename), &p);
3965 get_arg(stream->feed_filename, sizeof(stream->feed_filename), &p);
3966 } else if (!strcasecmp(cmd, "Truncate")) {
3968 get_arg(arg, sizeof(arg), &p);
3969 feed->truncate = strtod(arg, NULL);
3971 } else if (!strcasecmp(cmd, "FileMaxSize")) {
3976 get_arg(arg, sizeof(arg), &p);
3978 fsize = strtod(p1, &p1);
3979 switch(toupper(*p1)) {
3984 fsize *= 1024 * 1024;
3987 fsize *= 1024 * 1024 * 1024;
3990 feed->feed_max_size = (int64_t)fsize;
3992 } else if (!strcasecmp(cmd, "</Feed>")) {
3994 fprintf(stderr, "%s:%d: No corresponding <Feed> for </Feed>\n",
3995 filename, line_num);
3999 } else if (!strcasecmp(cmd, "<Stream")) {
4000 /*********************************************/
4001 /* Stream related options */
4003 if (stream || feed) {
4004 fprintf(stderr, "%s:%d: Already in a tag\n",
4005 filename, line_num);
4008 const AVClass *class;
4009 stream = av_mallocz(sizeof(FFStream));
4010 get_arg(stream->filename, sizeof(stream->filename), &p);
4011 q = strrchr(stream->filename, '>');
4015 for (s = first_stream; s; s = s->next) {
4016 if (!strcmp(stream->filename, s->filename)) {
4017 fprintf(stderr, "%s:%d: Stream '%s' already registered\n",
4018 filename, line_num, s->filename);
4023 stream->fmt = guess_stream_format(NULL, stream->filename, NULL);
4024 /* fetch avclass so AVOption works
4025 * FIXME try to use avcodec_get_context_defaults2
4026 * without changing defaults too much */
4027 avcodec_get_context_defaults(&video_enc);
4028 class = video_enc.av_class;
4029 memset(&audio_enc, 0, sizeof(AVCodecContext));
4030 memset(&video_enc, 0, sizeof(AVCodecContext));
4031 audio_enc.av_class = class;
4032 video_enc.av_class = class;
4033 audio_id = CODEC_ID_NONE;
4034 video_id = CODEC_ID_NONE;
4036 audio_id = stream->fmt->audio_codec;
4037 video_id = stream->fmt->video_codec;
4040 *last_stream = stream;
4041 last_stream = &stream->next;
4043 } else if (!strcasecmp(cmd, "Feed")) {
4044 get_arg(arg, sizeof(arg), &p);
4049 while (sfeed != NULL) {
4050 if (!strcmp(sfeed->filename, arg))
4052 sfeed = sfeed->next_feed;
4055 fprintf(stderr, "%s:%d: feed '%s' not defined\n",
4056 filename, line_num, arg);
4058 stream->feed = sfeed;
4060 } else if (!strcasecmp(cmd, "Format")) {
4061 get_arg(arg, sizeof(arg), &p);
4063 if (!strcmp(arg, "status")) {
4064 stream->stream_type = STREAM_TYPE_STATUS;
4067 stream->stream_type = STREAM_TYPE_LIVE;
4068 /* jpeg cannot be used here, so use single frame jpeg */
4069 if (!strcmp(arg, "jpeg"))
4070 strcpy(arg, "mjpeg");
4071 stream->fmt = guess_stream_format(arg, NULL, NULL);
4073 fprintf(stderr, "%s:%d: Unknown Format: %s\n",
4074 filename, line_num, arg);
4079 audio_id = stream->fmt->audio_codec;
4080 video_id = stream->fmt->video_codec;
4083 } else if (!strcasecmp(cmd, "InputFormat")) {
4084 get_arg(arg, sizeof(arg), &p);
4086 stream->ifmt = av_find_input_format(arg);
4087 if (!stream->ifmt) {
4088 fprintf(stderr, "%s:%d: Unknown input format: %s\n",
4089 filename, line_num, arg);
4092 } else if (!strcasecmp(cmd, "FaviconURL")) {
4093 if (stream && stream->stream_type == STREAM_TYPE_STATUS) {
4094 get_arg(stream->feed_filename, sizeof(stream->feed_filename), &p);
4096 fprintf(stderr, "%s:%d: FaviconURL only permitted for status streams\n",
4097 filename, line_num);
4100 } else if (!strcasecmp(cmd, "Author")) {
4102 get_arg(stream->author, sizeof(stream->author), &p);
4103 } else if (!strcasecmp(cmd, "Comment")) {
4105 get_arg(stream->comment, sizeof(stream->comment), &p);
4106 } else if (!strcasecmp(cmd, "Copyright")) {
4108 get_arg(stream->copyright, sizeof(stream->copyright), &p);
4109 } else if (!strcasecmp(cmd, "Title")) {
4111 get_arg(stream->title, sizeof(stream->title), &p);
4112 } else if (!strcasecmp(cmd, "Preroll")) {
4113 get_arg(arg, sizeof(arg), &p);
4115 stream->prebuffer = atof(arg) * 1000;
4116 } else if (!strcasecmp(cmd, "StartSendOnKey")) {
4118 stream->send_on_key = 1;
4119 } else if (!strcasecmp(cmd, "AudioCodec")) {
4120 get_arg(arg, sizeof(arg), &p);
4121 audio_id = opt_audio_codec(arg);
4122 if (audio_id == CODEC_ID_NONE) {
4123 fprintf(stderr, "%s:%d: Unknown AudioCodec: %s\n",
4124 filename, line_num, arg);
4127 } else if (!strcasecmp(cmd, "VideoCodec")) {
4128 get_arg(arg, sizeof(arg), &p);
4129 video_id = opt_video_codec(arg);
4130 if (video_id == CODEC_ID_NONE) {
4131 fprintf(stderr, "%s:%d: Unknown VideoCodec: %s\n",
4132 filename, line_num, arg);
4135 } else if (!strcasecmp(cmd, "MaxTime")) {
4136 get_arg(arg, sizeof(arg), &p);
4138 stream->max_time = atof(arg) * 1000;
4139 } else if (!strcasecmp(cmd, "AudioBitRate")) {
4140 get_arg(arg, sizeof(arg), &p);
4142 audio_enc.bit_rate = atoi(arg) * 1000;
4143 } else if (!strcasecmp(cmd, "AudioChannels")) {
4144 get_arg(arg, sizeof(arg), &p);
4146 audio_enc.channels = atoi(arg);
4147 } else if (!strcasecmp(cmd, "AudioSampleRate")) {
4148 get_arg(arg, sizeof(arg), &p);
4150 audio_enc.sample_rate = atoi(arg);
4151 } else if (!strcasecmp(cmd, "AudioQuality")) {
4152 get_arg(arg, sizeof(arg), &p);
4154 // audio_enc.quality = atof(arg) * 1000;
4156 } else if (!strcasecmp(cmd, "VideoBitRateRange")) {
4158 int minrate, maxrate;
4160 get_arg(arg, sizeof(arg), &p);
4162 if (sscanf(arg, "%d-%d", &minrate, &maxrate) == 2) {
4163 video_enc.rc_min_rate = minrate * 1000;
4164 video_enc.rc_max_rate = maxrate * 1000;
4166 fprintf(stderr, "%s:%d: Incorrect format for VideoBitRateRange -- should be <min>-<max>: %s\n",
4167 filename, line_num, arg);
4171 } else if (!strcasecmp(cmd, "Debug")) {
4173 get_arg(arg, sizeof(arg), &p);
4174 video_enc.debug = strtol(arg,0,0);
4176 } else if (!strcasecmp(cmd, "Strict")) {
4178 get_arg(arg, sizeof(arg), &p);
4179 video_enc.strict_std_compliance = atoi(arg);
4181 } else if (!strcasecmp(cmd, "VideoBufferSize")) {
4183 get_arg(arg, sizeof(arg), &p);
4184 video_enc.rc_buffer_size = atoi(arg) * 8*1024;
4186 } else if (!strcasecmp(cmd, "VideoBitRateTolerance")) {
4188 get_arg(arg, sizeof(arg), &p);
4189 video_enc.bit_rate_tolerance = atoi(arg) * 1000;
4191 } else if (!strcasecmp(cmd, "VideoBitRate")) {
4192 get_arg(arg, sizeof(arg), &p);
4194 video_enc.bit_rate = atoi(arg) * 1000;
4196 } else if (!strcasecmp(cmd, "VideoSize")) {
4197 get_arg(arg, sizeof(arg), &p);
4199 av_parse_video_frame_size(&video_enc.width, &video_enc.height, arg);
4200 if ((video_enc.width % 16) != 0 ||
4201 (video_enc.height % 16) != 0) {
4202 fprintf(stderr, "%s:%d: Image size must be a multiple of 16\n",
4203 filename, line_num);
4207 } else if (!strcasecmp(cmd, "VideoFrameRate")) {
4208 get_arg(arg, sizeof(arg), &p);
4210 AVRational frame_rate;
4211 if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
4212 fprintf(stderr, "Incorrect frame rate\n");
4215 video_enc.time_base.num = frame_rate.den;
4216 video_enc.time_base.den = frame_rate.num;
4219 } else if (!strcasecmp(cmd, "VideoGopSize")) {
4220 get_arg(arg, sizeof(arg), &p);
4222 video_enc.gop_size = atoi(arg);
4223 } else if (!strcasecmp(cmd, "VideoIntraOnly")) {
4225 video_enc.gop_size = 1;
4226 } else if (!strcasecmp(cmd, "VideoHighQuality")) {
4228 video_enc.mb_decision = FF_MB_DECISION_BITS;
4229 } else if (!strcasecmp(cmd, "Video4MotionVector")) {
4231 video_enc.mb_decision = FF_MB_DECISION_BITS; //FIXME remove
4232 video_enc.flags |= CODEC_FLAG_4MV;
4234 } else if (!strcasecmp(cmd, "AVOptionVideo") ||
4235 !strcasecmp(cmd, "AVOptionAudio")) {
4237 AVCodecContext *avctx;
4239 get_arg(arg, sizeof(arg), &p);
4240 get_arg(arg2, sizeof(arg2), &p);
4241 if (!strcasecmp(cmd, "AVOptionVideo")) {
4243 type = AV_OPT_FLAG_VIDEO_PARAM;
4246 type = AV_OPT_FLAG_AUDIO_PARAM;
4248 if (ffserver_opt_default(arg, arg2, avctx, type|AV_OPT_FLAG_ENCODING_PARAM)) {
4249 fprintf(stderr, "AVOption error: %s %s\n", arg, arg2);
4252 } else if (!strcasecmp(cmd, "VideoTag")) {
4253 get_arg(arg, sizeof(arg), &p);
4254 if ((strlen(arg) == 4) && stream)
4255 video_enc.codec_tag = AV_RL32(arg);
4256 } else if (!strcasecmp(cmd, "BitExact")) {
4258 video_enc.flags |= CODEC_FLAG_BITEXACT;
4259 } else if (!strcasecmp(cmd, "DctFastint")) {
4261 video_enc.dct_algo = FF_DCT_FASTINT;
4262 } else if (!strcasecmp(cmd, "IdctSimple")) {
4264 video_enc.idct_algo = FF_IDCT_SIMPLE;
4265 } else if (!strcasecmp(cmd, "Qscale")) {
4266 get_arg(arg, sizeof(arg), &p);
4268 video_enc.flags |= CODEC_FLAG_QSCALE;
4269 video_enc.global_quality = FF_QP2LAMBDA * atoi(arg);
4271 } else if (!strcasecmp(cmd, "VideoQDiff")) {
4272 get_arg(arg, sizeof(arg), &p);
4274 video_enc.max_qdiff = atoi(arg);
4275 if (video_enc.max_qdiff < 1 || video_enc.max_qdiff > 31) {
4276 fprintf(stderr, "%s:%d: VideoQDiff out of range\n",
4277 filename, line_num);
4281 } else if (!strcasecmp(cmd, "VideoQMax")) {
4282 get_arg(arg, sizeof(arg), &p);
4284 video_enc.qmax = atoi(arg);
4285 if (video_enc.qmax < 1 || video_enc.qmax > 31) {
4286 fprintf(stderr, "%s:%d: VideoQMax out of range\n",
4287 filename, line_num);
4291 } else if (!strcasecmp(cmd, "VideoQMin")) {
4292 get_arg(arg, sizeof(arg), &p);
4294 video_enc.qmin = atoi(arg);
4295 if (video_enc.qmin < 1 || video_enc.qmin > 31) {
4296 fprintf(stderr, "%s:%d: VideoQMin out of range\n",
4297 filename, line_num);
4301 } else if (!strcasecmp(cmd, "LumaElim")) {
4302 get_arg(arg, sizeof(arg), &p);
4304 video_enc.luma_elim_threshold = atoi(arg);
4305 } else if (!strcasecmp(cmd, "ChromaElim")) {
4306 get_arg(arg, sizeof(arg), &p);
4308 video_enc.chroma_elim_threshold = atoi(arg);
4309 } else if (!strcasecmp(cmd, "LumiMask")) {
4310 get_arg(arg, sizeof(arg), &p);
4312 video_enc.lumi_masking = atof(arg);
4313 } else if (!strcasecmp(cmd, "DarkMask")) {
4314 get_arg(arg, sizeof(arg), &p);
4316 video_enc.dark_masking = atof(arg);
4317 } else if (!strcasecmp(cmd, "NoVideo")) {
4318 video_id = CODEC_ID_NONE;
4319 } else if (!strcasecmp(cmd, "NoAudio")) {
4320 audio_id = CODEC_ID_NONE;
4321 } else if (!strcasecmp(cmd, "ACL")) {
4324 get_arg(arg, sizeof(arg), &p);
4325 if (strcasecmp(arg, "allow") == 0)
4326 acl.action = IP_ALLOW;
4327 else if (strcasecmp(arg, "deny") == 0)
4328 acl.action = IP_DENY;
4330 fprintf(stderr, "%s:%d: ACL action '%s' is not ALLOW or DENY\n",
4331 filename, line_num, arg);
4335 get_arg(arg, sizeof(arg), &p);
4337 if (resolve_host(&acl.first, arg) != 0) {
4338 fprintf(stderr, "%s:%d: ACL refers to invalid host or ip address '%s'\n",
4339 filename, line_num, arg);
4342 acl.last = acl.first;
4344 get_arg(arg, sizeof(arg), &p);
4347 if (resolve_host(&acl.last, arg) != 0) {
4348 fprintf(stderr, "%s:%d: ACL refers to invalid host or ip address '%s'\n",
4349 filename, line_num, arg);
4355 IPAddressACL *nacl = av_mallocz(sizeof(*nacl));
4356 IPAddressACL **naclp = 0;
4362 naclp = &stream->acl;
4366 fprintf(stderr, "%s:%d: ACL found not in <stream> or <feed>\n",
4367 filename, line_num);
4373 naclp = &(*naclp)->next;
4378 } else if (!strcasecmp(cmd, "RTSPOption")) {
4379 get_arg(arg, sizeof(arg), &p);
4381 av_freep(&stream->rtsp_option);
4382 stream->rtsp_option = av_strdup(arg);
4384 } else if (!strcasecmp(cmd, "MulticastAddress")) {
4385 get_arg(arg, sizeof(arg), &p);
4387 if (resolve_host(&stream->multicast_ip, arg) != 0) {
4388 fprintf(stderr, "%s:%d: Invalid host/IP address: %s\n",
4389 filename, line_num, arg);
4392 stream->is_multicast = 1;
4393 stream->loop = 1; /* default is looping */
4395 } else if (!strcasecmp(cmd, "MulticastPort")) {
4396 get_arg(arg, sizeof(arg), &p);
4398 stream->multicast_port = atoi(arg);
4399 } else if (!strcasecmp(cmd, "MulticastTTL")) {
4400 get_arg(arg, sizeof(arg), &p);
4402 stream->multicast_ttl = atoi(arg);
4403 } else if (!strcasecmp(cmd, "NoLoop")) {
4406 } else if (!strcasecmp(cmd, "</Stream>")) {
4408 fprintf(stderr, "%s:%d: No corresponding <Stream> for </Stream>\n",
4409 filename, line_num);
4412 if (stream->feed && stream->fmt && strcmp(stream->fmt->name, "ffm") != 0) {
4413 if (audio_id != CODEC_ID_NONE) {
4414 audio_enc.codec_type = CODEC_TYPE_AUDIO;
4415 audio_enc.codec_id = audio_id;
4416 add_codec(stream, &audio_enc);
4418 if (video_id != CODEC_ID_NONE) {
4419 video_enc.codec_type = CODEC_TYPE_VIDEO;
4420 video_enc.codec_id = video_id;
4421 add_codec(stream, &video_enc);
4426 } else if (!strcasecmp(cmd, "<Redirect")) {
4427 /*********************************************/
4429 if (stream || feed || redirect) {
4430 fprintf(stderr, "%s:%d: Already in a tag\n",
4431 filename, line_num);
4434 redirect = av_mallocz(sizeof(FFStream));
4435 *last_stream = redirect;
4436 last_stream = &redirect->next;
4438 get_arg(redirect->filename, sizeof(redirect->filename), &p);
4439 q = strrchr(redirect->filename, '>');
4442 redirect->stream_type = STREAM_TYPE_REDIRECT;
4444 } else if (!strcasecmp(cmd, "URL")) {
4446 get_arg(redirect->feed_filename, sizeof(redirect->feed_filename), &p);
4447 } else if (!strcasecmp(cmd, "</Redirect>")) {
4449 fprintf(stderr, "%s:%d: No corresponding <Redirect> for </Redirect>\n",
4450 filename, line_num);
4453 if (!redirect->feed_filename[0]) {
4454 fprintf(stderr, "%s:%d: No URL found for <Redirect>\n",
4455 filename, line_num);
4460 } else if (!strcasecmp(cmd, "LoadModule")) {
4461 get_arg(arg, sizeof(arg), &p);
4465 fprintf(stderr, "%s:%d: Module support not compiled into this version: '%s'\n",
4466 filename, line_num, arg);
4470 fprintf(stderr, "%s:%d: Incorrect keyword: '%s'\n",
4471 filename, line_num, cmd);
4482 static void handle_child_exit(int sig)
4487 while ((pid = waitpid(-1, &status, WNOHANG)) > 0) {
4490 for (feed = first_feed; feed; feed = feed->next) {
4491 if (feed->pid == pid) {
4492 int uptime = time(0) - feed->pid_start;
4495 fprintf(stderr, "%s: Pid %d exited with status %d after %d seconds\n", feed->filename, pid, status, uptime);
4498 /* Turn off any more restarts */
4499 feed->child_argv = 0;
4504 need_to_start_children = 1;
4507 static void opt_debug(void)
4510 ffserver_daemon = 0;
4511 logfilename[0] = '-';
4514 static void opt_show_help(void)
4516 printf("usage: ffserver [options]\n"
4517 "Hyper fast multi format Audio/Video streaming server\n");
4519 show_help_options(options, "Main options:\n", 0, 0);
4522 static const OptionDef options[] = {
4523 { "h", OPT_EXIT, {(void*)opt_show_help}, "show help" },
4524 { "version", OPT_EXIT, {(void*)show_version}, "show version" },
4525 { "L", OPT_EXIT, {(void*)show_license}, "show license" },
4526 { "formats", OPT_EXIT, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
4527 { "n", OPT_BOOL, {(void *)&no_launch }, "enable no-launch mode" },
4528 { "d", 0, {(void*)opt_debug}, "enable debug mode" },
4529 { "f", HAS_ARG | OPT_STRING, {(void*)&config_filename }, "use configfile instead of /etc/ffserver.conf", "configfile" },
4533 int main(int argc, char **argv)
4535 struct sigaction sigact;
4541 config_filename = "/etc/ffserver.conf";
4543 my_program_name = argv[0];
4544 my_program_dir = getcwd(0, 0);
4545 ffserver_daemon = 1;
4547 parse_options(argc, argv, options, NULL);
4549 unsetenv("http_proxy"); /* Kill the http_proxy */
4551 av_lfg_init(&random_state, ff_random_get_seed());
4553 memset(&sigact, 0, sizeof(sigact));
4554 sigact.sa_handler = handle_child_exit;
4555 sigact.sa_flags = SA_NOCLDSTOP | SA_RESTART;
4556 sigaction(SIGCHLD, &sigact, 0);
4558 if (parse_ffconfig(config_filename) < 0) {
4559 fprintf(stderr, "Incorrect config file - exiting.\n");
4563 /* open log file if needed */
4564 if (logfilename[0] != '\0') {
4565 if (!strcmp(logfilename, "-"))
4568 logfile = fopen(logfilename, "a");
4569 av_log_set_callback(http_av_log);
4572 build_file_streams();
4574 build_feed_streams();
4576 compute_bandwidth();
4578 /* put the process in background and detach it from its TTY */
4579 if (ffserver_daemon) {
4586 } else if (pid > 0) {
4593 open("/dev/null", O_RDWR);
4594 if (strcmp(logfilename, "-") != 0) {
4604 signal(SIGPIPE, SIG_IGN);
4606 if (ffserver_daemon)
4609 if (http_server() < 0) {
4610 http_log("Could not start server\n");