2 * Multiple format streaming server
3 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
5 * This file is part of Libav.
7 * Libav 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 * Libav 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 Libav; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
24 #define closesocket close
28 #include "libavformat/avformat.h"
29 // FIXME those are internal headers, avserver _really_ shouldn't use them
30 #include "libavformat/ffm.h"
31 #include "libavformat/network.h"
32 #include "libavformat/os_support.h"
33 #include "libavformat/rtpdec.h"
34 #include "libavformat/rtsp.h"
35 #include "libavformat/avio_internal.h"
36 #include "libavformat/internal.h"
37 #include "libavformat/url.h"
39 #include "libavutil/avstring.h"
40 #include "libavutil/lfg.h"
41 #include "libavutil/dict.h"
42 #include "libavutil/mathematics.h"
43 #include "libavutil/random_seed.h"
44 #include "libavutil/parseutils.h"
45 #include "libavutil/opt.h"
49 #include <sys/ioctl.h>
64 const char program_name[] = "avserver";
65 const int program_birth_year = 2000;
67 static const OptionDef options[];
70 HTTPSTATE_WAIT_REQUEST,
71 HTTPSTATE_SEND_HEADER,
72 HTTPSTATE_SEND_DATA_HEADER,
73 HTTPSTATE_SEND_DATA, /* sending TCP or UDP data */
74 HTTPSTATE_SEND_DATA_TRAILER,
75 HTTPSTATE_RECEIVE_DATA,
76 HTTPSTATE_WAIT_FEED, /* wait for data from the feed */
79 RTSPSTATE_WAIT_REQUEST,
81 RTSPSTATE_SEND_PACKET,
84 static const char *http_state[] = {
100 #define MAX_STREAMS 20
102 #define IOBUFFER_INIT_SIZE 8192
104 /* timeouts are in ms */
105 #define HTTP_REQUEST_TIMEOUT (15 * 1000)
106 #define RTSP_REQUEST_TIMEOUT (3600 * 24 * 1000)
108 #define SYNC_TIMEOUT (10 * 1000)
110 typedef struct RTSPActionServerSetup {
112 char transport_option[512];
113 } RTSPActionServerSetup;
116 int64_t count1, count2;
117 int64_t time1, time2;
120 /* context associated with one connection */
121 typedef struct HTTPContext {
122 enum HTTPState state;
123 int fd; /* socket file descriptor */
124 struct sockaddr_in from_addr; /* origin */
125 struct pollfd *poll_entry; /* used when polling */
127 uint8_t *buffer_ptr, *buffer_end;
130 int chunked_encoding;
131 int chunk_size; /* 0 if it needs to be read */
132 struct HTTPContext *next;
133 int got_key_frame; /* stream 0 => 1, stream 1 => 2, stream 2=> 4 */
137 /* input format handling */
138 AVFormatContext *fmt_in;
139 int64_t start_time; /* In milliseconds - this wraps fairly often */
140 int64_t first_pts; /* initial pts value */
141 int64_t cur_pts; /* current pts value from the stream in us */
142 int64_t cur_frame_duration; /* duration of the current frame in us */
143 int cur_frame_bytes; /* output frame size, needed to compute
144 the time at which we send each
146 int pts_stream_index; /* stream we choose as clock reference */
147 int64_t cur_clock; /* current clock reference value in us */
148 /* output format handling */
149 struct FFStream *stream;
150 /* -1 is invalid stream */
151 int feed_streams[MAX_STREAMS]; /* index of streams in the feed */
152 int switch_feed_streams[MAX_STREAMS]; /* index of streams in the feed */
154 AVFormatContext fmt_ctx; /* instance of FFStream for one user */
155 int last_packet_sent; /* true if last data packet was sent */
157 DataRateData datarate;
164 int is_packetized; /* if true, the stream is packetized */
165 int packet_stream_index; /* current stream for output in state machine */
167 /* RTSP state specific */
168 uint8_t *pb_buffer; /* XXX: use that in all the code */
170 int seq; /* RTSP sequence number */
172 /* RTP state specific */
173 enum RTSPLowerTransport rtp_protocol;
174 char session_id[32]; /* session id */
175 AVFormatContext *rtp_ctx[MAX_STREAMS];
177 /* RTP/UDP specific */
178 URLContext *rtp_handles[MAX_STREAMS];
180 /* RTP/TCP specific */
181 struct HTTPContext *rtsp_c;
182 uint8_t *packet_buffer, *packet_buffer_ptr, *packet_buffer_end;
185 /* each generated stream is described here */
189 STREAM_TYPE_REDIRECT,
192 enum IPAddressAction {
197 typedef struct IPAddressACL {
198 struct IPAddressACL *next;
199 enum IPAddressAction action;
200 /* These are in host order */
201 struct in_addr first;
205 /* description of each stream of the avserver.conf file */
206 typedef struct FFStream {
207 enum StreamType stream_type;
208 char filename[1024]; /* stream filename */
209 struct FFStream *feed; /* feed we are using (can be null if
211 AVDictionary *in_opts; /* input parameters */
212 AVInputFormat *ifmt; /* if non NULL, force input format */
215 char dynamic_acl[1024];
217 int prebuffer; /* Number of millseconds early to start */
218 int64_t max_time; /* Number of milliseconds to run */
220 AVStream *streams[MAX_STREAMS];
221 int feed_streams[MAX_STREAMS]; /* index of streams in the feed */
222 char feed_filename[1024]; /* file name of the feed storage, or
223 input file name for a stream */
228 pid_t pid; /* of avconv process */
229 time_t pid_start; /* of avconv process */
231 struct FFStream *next;
232 unsigned bandwidth; /* bandwidth, in kbits/s */
235 /* multicast specific */
237 struct in_addr multicast_ip;
238 int multicast_port; /* first port used for multicast */
240 int loop; /* if true, send the stream in loops (only meaningful if file) */
243 int feed_opened; /* true if someone is writing to the feed */
244 int is_feed; /* true if it is a feed */
245 int readonly; /* True if writing is prohibited to the file */
246 int truncate; /* True if feeder connection truncate the feed file */
248 int64_t bytes_served;
249 int64_t feed_max_size; /* maximum storage size, zero means unlimited */
250 int64_t feed_write_index; /* current write position in feed (it wraps around) */
251 int64_t feed_size; /* current size of feed */
252 struct FFStream *next_feed;
255 typedef struct FeedData {
256 long long data_count;
257 float avg_frame_size; /* frame size averaged over last frames with exponential mean */
260 static struct sockaddr_in my_http_addr;
261 static struct sockaddr_in my_rtsp_addr;
263 static char logfilename[1024];
264 static HTTPContext *first_http_ctx;
265 static FFStream *first_feed; /* contains only feeds */
266 static FFStream *first_stream; /* contains all streams, including feeds */
268 static void new_connection(int server_fd, int is_rtsp);
269 static void close_connection(HTTPContext *c);
272 static int handle_connection(HTTPContext *c);
273 static int http_parse_request(HTTPContext *c);
274 static int http_send_data(HTTPContext *c);
275 static void compute_status(HTTPContext *c);
276 static int open_input_stream(HTTPContext *c, const char *info);
277 static int http_start_receive_data(HTTPContext *c);
278 static int http_receive_data(HTTPContext *c);
281 static int rtsp_parse_request(HTTPContext *c);
282 static void rtsp_cmd_describe(HTTPContext *c, const char *url);
283 static void rtsp_cmd_options(HTTPContext *c, const char *url);
284 static void rtsp_cmd_setup(HTTPContext *c, const char *url, RTSPMessageHeader *h);
285 static void rtsp_cmd_play(HTTPContext *c, const char *url, RTSPMessageHeader *h);
286 static void rtsp_cmd_pause(HTTPContext *c, const char *url, RTSPMessageHeader *h);
287 static void rtsp_cmd_teardown(HTTPContext *c, const char *url, RTSPMessageHeader *h);
290 static int prepare_sdp_description(FFStream *stream, uint8_t **pbuffer,
291 struct in_addr my_ip);
294 static HTTPContext *rtp_new_connection(struct sockaddr_in *from_addr,
295 FFStream *stream, const char *session_id,
296 enum RTSPLowerTransport rtp_protocol);
297 static int rtp_new_av_stream(HTTPContext *c,
298 int stream_index, struct sockaddr_in *dest_addr,
299 HTTPContext *rtsp_c);
301 static const char *my_program_name;
302 static const char *my_program_dir;
304 static const char *config_filename = "/etc/avserver.conf";
306 static int avserver_debug;
307 static int avserver_daemon;
308 static int no_launch;
309 static int need_to_start_children;
311 /* maximum number of simultaneous HTTP connections */
312 static unsigned int nb_max_http_connections = 2000;
313 static unsigned int nb_max_connections = 5;
314 static unsigned int nb_connections;
316 static uint64_t max_bandwidth = 1000;
317 static uint64_t current_bandwidth;
319 static int64_t cur_time; // Making this global saves on passing it around everywhere
321 static AVLFG random_state;
323 static FILE *logfile = NULL;
325 void exit_program(int ret)
330 /* FIXME: make avserver work with IPv6 */
331 /* resolve host with also IP address parsing */
332 static int resolve_host(struct in_addr *sin_addr, const char *hostname)
335 if (!ff_inet_aton(hostname, sin_addr)) {
337 struct addrinfo *ai, *cur;
338 struct addrinfo hints;
339 memset(&hints, 0, sizeof(hints));
340 hints.ai_family = AF_INET;
341 if (getaddrinfo(hostname, NULL, &hints, &ai))
343 /* getaddrinfo returns a linked list of addrinfo structs.
344 * Even if we set ai_family = AF_INET above, make sure
345 * that the returned one actually is of the correct type. */
346 for (cur = ai; cur; cur = cur->ai_next) {
347 if (cur->ai_family == AF_INET) {
348 *sin_addr = ((struct sockaddr_in *)cur->ai_addr)->sin_addr;
357 hp = gethostbyname(hostname);
360 memcpy(sin_addr, hp->h_addr_list[0], sizeof(struct in_addr));
366 static char *ctime1(char *buf2)
374 p = buf2 + strlen(p) - 1;
380 static void http_vlog(const char *fmt, va_list vargs)
382 static int print_prefix = 1;
387 fprintf(logfile, "%s ", buf);
389 print_prefix = strstr(fmt, "\n") != NULL;
390 vfprintf(logfile, fmt, vargs);
396 __attribute__ ((format (printf, 1, 2)))
398 static void http_log(const char *fmt, ...)
401 va_start(vargs, fmt);
402 http_vlog(fmt, vargs);
406 static void http_av_log(void *ptr, int level, const char *fmt, va_list vargs)
408 static int print_prefix = 1;
409 AVClass *avc = ptr ? *(AVClass**)ptr : NULL;
410 if (level > av_log_get_level())
412 if (print_prefix && avc)
413 http_log("[%s @ %p]", avc->item_name(ptr), ptr);
414 print_prefix = strstr(fmt, "\n") != NULL;
415 http_vlog(fmt, vargs);
418 static void log_connection(HTTPContext *c)
423 http_log("%s - - [%s] \"%s %s\" %d %"PRId64"\n",
424 inet_ntoa(c->from_addr.sin_addr), c->method, c->url,
425 c->protocol, (c->http_error ? c->http_error : 200), c->data_count);
428 static void update_datarate(DataRateData *drd, int64_t count)
430 if (!drd->time1 && !drd->count1) {
431 drd->time1 = drd->time2 = cur_time;
432 drd->count1 = drd->count2 = count;
433 } else if (cur_time - drd->time2 > 5000) {
434 drd->time1 = drd->time2;
435 drd->count1 = drd->count2;
436 drd->time2 = cur_time;
441 /* In bytes per second */
442 static int compute_datarate(DataRateData *drd, int64_t count)
444 if (cur_time == drd->time1)
447 return ((count - drd->count1) * 1000) / (cur_time - drd->time1);
451 static void start_children(FFStream *feed)
456 for (; feed; feed = feed->next) {
457 if (feed->child_argv && !feed->pid) {
458 feed->pid_start = time(0);
463 http_log("Unable to create children\n");
472 av_strlcpy(pathname, my_program_name, sizeof(pathname));
474 slash = strrchr(pathname, '/');
479 strcpy(slash, "avconv");
481 http_log("Launch command line: ");
482 http_log("%s ", pathname);
483 for (i = 1; feed->child_argv[i] && feed->child_argv[i][0]; i++)
484 http_log("%s ", feed->child_argv[i]);
487 for (i = 3; i < 256; i++)
490 if (!avserver_debug) {
491 i = open("/dev/null", O_RDWR);
500 /* This is needed to make relative pathnames work */
501 chdir(my_program_dir);
503 signal(SIGPIPE, SIG_DFL);
505 execvp(pathname, feed->child_argv);
513 /* open a listening socket */
514 static int socket_open_listen(struct sockaddr_in *my_addr)
518 server_fd = socket(AF_INET,SOCK_STREAM,0);
525 setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &tmp, sizeof(tmp));
527 my_addr->sin_family = AF_INET;
528 if (bind (server_fd, (struct sockaddr *) my_addr, sizeof (*my_addr)) < 0) {
530 snprintf(bindmsg, sizeof(bindmsg), "bind(port %d)", ntohs(my_addr->sin_port));
532 closesocket(server_fd);
536 if (listen (server_fd, 5) < 0) {
538 closesocket(server_fd);
541 ff_socket_nonblock(server_fd, 1);
546 /* start all multicast streams */
547 static void start_multicast(void)
552 struct sockaddr_in dest_addr;
553 int default_port, stream_index;
556 for(stream = first_stream; stream != NULL; stream = stream->next) {
557 if (stream->is_multicast) {
558 /* open the RTP connection */
559 snprintf(session_id, sizeof(session_id), "%08x%08x",
560 av_lfg_get(&random_state), av_lfg_get(&random_state));
562 /* choose a port if none given */
563 if (stream->multicast_port == 0) {
564 stream->multicast_port = default_port;
568 dest_addr.sin_family = AF_INET;
569 dest_addr.sin_addr = stream->multicast_ip;
570 dest_addr.sin_port = htons(stream->multicast_port);
572 rtp_c = rtp_new_connection(&dest_addr, stream, session_id,
573 RTSP_LOWER_TRANSPORT_UDP_MULTICAST);
577 if (open_input_stream(rtp_c, "") < 0) {
578 http_log("Could not open input stream for stream '%s'\n",
583 /* open each RTP stream */
584 for(stream_index = 0; stream_index < stream->nb_streams;
586 dest_addr.sin_port = htons(stream->multicast_port +
588 if (rtp_new_av_stream(rtp_c, stream_index, &dest_addr, NULL) < 0) {
589 http_log("Could not open output stream '%s/streamid=%d'\n",
590 stream->filename, stream_index);
595 /* change state to send data */
596 rtp_c->state = HTTPSTATE_SEND_DATA;
601 /* main loop of the http server */
602 static int http_server(void)
604 int server_fd = 0, rtsp_server_fd = 0;
605 int ret, delay, delay1;
606 struct pollfd *poll_table, *poll_entry;
607 HTTPContext *c, *c_next;
609 if(!(poll_table = av_mallocz((nb_max_http_connections + 2)*sizeof(*poll_table)))) {
610 http_log("Impossible to allocate a poll table handling %d connections.\n", nb_max_http_connections);
614 if (my_http_addr.sin_port) {
615 server_fd = socket_open_listen(&my_http_addr);
620 if (my_rtsp_addr.sin_port) {
621 rtsp_server_fd = socket_open_listen(&my_rtsp_addr);
622 if (rtsp_server_fd < 0)
626 if (!rtsp_server_fd && !server_fd) {
627 http_log("HTTP and RTSP disabled.\n");
631 http_log("AVserver started.\n");
633 start_children(first_feed);
638 poll_entry = poll_table;
640 poll_entry->fd = server_fd;
641 poll_entry->events = POLLIN;
644 if (rtsp_server_fd) {
645 poll_entry->fd = rtsp_server_fd;
646 poll_entry->events = POLLIN;
650 /* wait for events on each HTTP handle */
657 case HTTPSTATE_SEND_HEADER:
658 case RTSPSTATE_SEND_REPLY:
659 case RTSPSTATE_SEND_PACKET:
660 c->poll_entry = poll_entry;
662 poll_entry->events = POLLOUT;
665 case HTTPSTATE_SEND_DATA_HEADER:
666 case HTTPSTATE_SEND_DATA:
667 case HTTPSTATE_SEND_DATA_TRAILER:
668 if (!c->is_packetized) {
669 /* for TCP, we output as much as we can (may need to put a limit) */
670 c->poll_entry = poll_entry;
672 poll_entry->events = POLLOUT;
675 /* when avserver is doing the timing, we work by
676 looking at which packet need to be sent every
678 delay1 = 10; /* one tick wait XXX: 10 ms assumed */
683 case HTTPSTATE_WAIT_REQUEST:
684 case HTTPSTATE_RECEIVE_DATA:
685 case HTTPSTATE_WAIT_FEED:
686 case RTSPSTATE_WAIT_REQUEST:
687 /* need to catch errors */
688 c->poll_entry = poll_entry;
690 poll_entry->events = POLLIN;/* Maybe this will work */
694 c->poll_entry = NULL;
700 /* wait for an event on one connection. We poll at least every
701 second to handle timeouts */
703 ret = poll(poll_table, poll_entry - poll_table, delay);
704 if (ret < 0 && ff_neterrno() != AVERROR(EAGAIN) &&
705 ff_neterrno() != AVERROR(EINTR))
709 cur_time = av_gettime() / 1000;
711 if (need_to_start_children) {
712 need_to_start_children = 0;
713 start_children(first_feed);
716 /* now handle the events */
717 for(c = first_http_ctx; c != NULL; c = c_next) {
719 if (handle_connection(c) < 0) {
720 /* close and free the connection */
726 poll_entry = poll_table;
728 /* new HTTP connection request ? */
729 if (poll_entry->revents & POLLIN)
730 new_connection(server_fd, 0);
733 if (rtsp_server_fd) {
734 /* new RTSP connection request ? */
735 if (poll_entry->revents & POLLIN)
736 new_connection(rtsp_server_fd, 1);
741 /* start waiting for a new HTTP/RTSP request */
742 static void start_wait_request(HTTPContext *c, int is_rtsp)
744 c->buffer_ptr = c->buffer;
745 c->buffer_end = c->buffer + c->buffer_size - 1; /* leave room for '\0' */
748 c->timeout = cur_time + RTSP_REQUEST_TIMEOUT;
749 c->state = RTSPSTATE_WAIT_REQUEST;
751 c->timeout = cur_time + HTTP_REQUEST_TIMEOUT;
752 c->state = HTTPSTATE_WAIT_REQUEST;
756 static void http_send_too_busy_reply(int fd)
759 int len = snprintf(buffer, sizeof(buffer),
760 "HTTP/1.0 503 Server too busy\r\n"
761 "Content-type: text/html\r\n"
763 "<html><head><title>Too busy</title></head><body>\r\n"
764 "<p>The server is too busy to serve your request at this time.</p>\r\n"
765 "<p>The number of current connections is %d, and this exceeds the limit of %d.</p>\r\n"
766 "</body></html>\r\n",
767 nb_connections, nb_max_connections);
768 send(fd, buffer, len, 0);
772 static void new_connection(int server_fd, int is_rtsp)
774 struct sockaddr_in from_addr;
776 HTTPContext *c = NULL;
778 len = sizeof(from_addr);
779 fd = accept(server_fd, (struct sockaddr *)&from_addr,
782 http_log("error during accept %s\n", strerror(errno));
785 ff_socket_nonblock(fd, 1);
787 if (nb_connections >= nb_max_connections) {
788 http_send_too_busy_reply(fd);
792 /* add a new connection */
793 c = av_mallocz(sizeof(HTTPContext));
798 c->poll_entry = NULL;
799 c->from_addr = from_addr;
800 c->buffer_size = IOBUFFER_INIT_SIZE;
801 c->buffer = av_malloc(c->buffer_size);
805 c->next = first_http_ctx;
809 start_wait_request(c, is_rtsp);
821 static void close_connection(HTTPContext *c)
823 HTTPContext **cp, *c1;
825 AVFormatContext *ctx;
829 /* remove connection from list */
830 cp = &first_http_ctx;
831 while ((*cp) != NULL) {
839 /* remove references, if any (XXX: do it faster) */
840 for(c1 = first_http_ctx; c1 != NULL; c1 = c1->next) {
845 /* remove connection associated resources */
849 /* close each frame parser */
850 for(i=0;i<c->fmt_in->nb_streams;i++) {
851 st = c->fmt_in->streams[i];
852 if (st->codec->codec)
853 avcodec_close(st->codec);
855 avformat_close_input(&c->fmt_in);
858 /* free RTP output streams if any */
861 nb_streams = c->stream->nb_streams;
863 for(i=0;i<nb_streams;i++) {
866 av_write_trailer(ctx);
867 av_dict_free(&ctx->metadata);
868 av_free(ctx->streams[0]);
871 h = c->rtp_handles[i];
878 if (!c->last_packet_sent && c->state == HTTPSTATE_SEND_DATA_TRAILER) {
881 if (avio_open_dyn_buf(&ctx->pb) >= 0) {
882 av_write_trailer(ctx);
883 av_freep(&c->pb_buffer);
884 avio_close_dyn_buf(ctx->pb, &c->pb_buffer);
889 for(i=0; i<ctx->nb_streams; i++)
890 av_free(ctx->streams[i]);
892 if (c->stream && !c->post && c->stream->stream_type == STREAM_TYPE_LIVE)
893 current_bandwidth -= c->stream->bandwidth;
895 /* signal that there is no feed if we are the feeder socket */
896 if (c->state == HTTPSTATE_RECEIVE_DATA && c->stream) {
897 c->stream->feed_opened = 0;
901 av_freep(&c->pb_buffer);
902 av_freep(&c->packet_buffer);
908 static int handle_connection(HTTPContext *c)
913 case HTTPSTATE_WAIT_REQUEST:
914 case RTSPSTATE_WAIT_REQUEST:
916 if ((c->timeout - cur_time) < 0)
918 if (c->poll_entry->revents & (POLLERR | POLLHUP))
921 /* no need to read if no events */
922 if (!(c->poll_entry->revents & POLLIN))
926 len = recv(c->fd, c->buffer_ptr, 1, 0);
928 if (ff_neterrno() != AVERROR(EAGAIN) &&
929 ff_neterrno() != AVERROR(EINTR))
931 } else if (len == 0) {
934 /* search for end of request. */
936 c->buffer_ptr += len;
938 if ((ptr >= c->buffer + 2 && !memcmp(ptr-2, "\n\n", 2)) ||
939 (ptr >= c->buffer + 4 && !memcmp(ptr-4, "\r\n\r\n", 4))) {
940 /* request found : parse it and reply */
941 if (c->state == HTTPSTATE_WAIT_REQUEST) {
942 ret = http_parse_request(c);
944 ret = rtsp_parse_request(c);
948 } else if (ptr >= c->buffer_end) {
949 /* request too long: cannot do anything */
951 } else goto read_loop;
955 case HTTPSTATE_SEND_HEADER:
956 if (c->poll_entry->revents & (POLLERR | POLLHUP))
959 /* no need to write if no events */
960 if (!(c->poll_entry->revents & POLLOUT))
962 len = send(c->fd, c->buffer_ptr, c->buffer_end - c->buffer_ptr, 0);
964 if (ff_neterrno() != AVERROR(EAGAIN) &&
965 ff_neterrno() != AVERROR(EINTR)) {
966 /* error : close connection */
967 av_freep(&c->pb_buffer);
971 c->buffer_ptr += len;
973 c->stream->bytes_served += len;
974 c->data_count += len;
975 if (c->buffer_ptr >= c->buffer_end) {
976 av_freep(&c->pb_buffer);
980 /* all the buffer was sent : synchronize to the incoming stream */
981 c->state = HTTPSTATE_SEND_DATA_HEADER;
982 c->buffer_ptr = c->buffer_end = c->buffer;
987 case HTTPSTATE_SEND_DATA:
988 case HTTPSTATE_SEND_DATA_HEADER:
989 case HTTPSTATE_SEND_DATA_TRAILER:
990 /* for packetized output, we consider we can always write (the
991 input streams sets the speed). It may be better to verify
992 that we do not rely too much on the kernel queues */
993 if (!c->is_packetized) {
994 if (c->poll_entry->revents & (POLLERR | POLLHUP))
997 /* no need to read if no events */
998 if (!(c->poll_entry->revents & POLLOUT))
1001 if (http_send_data(c) < 0)
1003 /* close connection if trailer sent */
1004 if (c->state == HTTPSTATE_SEND_DATA_TRAILER)
1007 case HTTPSTATE_RECEIVE_DATA:
1008 /* no need to read if no events */
1009 if (c->poll_entry->revents & (POLLERR | POLLHUP))
1011 if (!(c->poll_entry->revents & POLLIN))
1013 if (http_receive_data(c) < 0)
1016 case HTTPSTATE_WAIT_FEED:
1017 /* no need to read if no events */
1018 if (c->poll_entry->revents & (POLLIN | POLLERR | POLLHUP))
1021 /* nothing to do, we'll be waken up by incoming feed packets */
1024 case RTSPSTATE_SEND_REPLY:
1025 if (c->poll_entry->revents & (POLLERR | POLLHUP)) {
1026 av_freep(&c->pb_buffer);
1029 /* no need to write if no events */
1030 if (!(c->poll_entry->revents & POLLOUT))
1032 len = send(c->fd, c->buffer_ptr, c->buffer_end - c->buffer_ptr, 0);
1034 if (ff_neterrno() != AVERROR(EAGAIN) &&
1035 ff_neterrno() != AVERROR(EINTR)) {
1036 /* error : close connection */
1037 av_freep(&c->pb_buffer);
1041 c->buffer_ptr += len;
1042 c->data_count += len;
1043 if (c->buffer_ptr >= c->buffer_end) {
1044 /* all the buffer was sent : wait for a new request */
1045 av_freep(&c->pb_buffer);
1046 start_wait_request(c, 1);
1050 case RTSPSTATE_SEND_PACKET:
1051 if (c->poll_entry->revents & (POLLERR | POLLHUP)) {
1052 av_freep(&c->packet_buffer);
1055 /* no need to write if no events */
1056 if (!(c->poll_entry->revents & POLLOUT))
1058 len = send(c->fd, c->packet_buffer_ptr,
1059 c->packet_buffer_end - c->packet_buffer_ptr, 0);
1061 if (ff_neterrno() != AVERROR(EAGAIN) &&
1062 ff_neterrno() != AVERROR(EINTR)) {
1063 /* error : close connection */
1064 av_freep(&c->packet_buffer);
1068 c->packet_buffer_ptr += len;
1069 if (c->packet_buffer_ptr >= c->packet_buffer_end) {
1070 /* all the buffer was sent : wait for a new request */
1071 av_freep(&c->packet_buffer);
1072 c->state = RTSPSTATE_WAIT_REQUEST;
1076 case HTTPSTATE_READY:
1085 static int extract_rates(char *rates, int ratelen, const char *request)
1089 for (p = request; *p && *p != '\r' && *p != '\n'; ) {
1090 if (av_strncasecmp(p, "Pragma:", 7) == 0) {
1091 const char *q = p + 7;
1093 while (*q && *q != '\n' && isspace(*q))
1096 if (av_strncasecmp(q, "stream-switch-entry=", 20) == 0) {
1102 memset(rates, 0xff, ratelen);
1105 while (*q && *q != '\n' && *q != ':')
1108 if (sscanf(q, ":%d:%d", &stream_no, &rate_no) != 2)
1112 if (stream_no < ratelen && stream_no >= 0)
1113 rates[stream_no] = rate_no;
1115 while (*q && *q != '\n' && !isspace(*q))
1122 p = strchr(p, '\n');
1132 static int find_stream_in_feed(FFStream *feed, AVCodecContext *codec, int bit_rate)
1135 int best_bitrate = 100000000;
1138 for (i = 0; i < feed->nb_streams; i++) {
1139 AVCodecContext *feed_codec = feed->streams[i]->codec;
1141 if (feed_codec->codec_id != codec->codec_id ||
1142 feed_codec->sample_rate != codec->sample_rate ||
1143 feed_codec->width != codec->width ||
1144 feed_codec->height != codec->height)
1147 /* Potential stream */
1149 /* We want the fastest stream less than bit_rate, or the slowest
1150 * faster than bit_rate
1153 if (feed_codec->bit_rate <= bit_rate) {
1154 if (best_bitrate > bit_rate || feed_codec->bit_rate > best_bitrate) {
1155 best_bitrate = feed_codec->bit_rate;
1159 if (feed_codec->bit_rate < best_bitrate) {
1160 best_bitrate = feed_codec->bit_rate;
1169 static int modify_current_stream(HTTPContext *c, char *rates)
1172 FFStream *req = c->stream;
1173 int action_required = 0;
1175 /* Not much we can do for a feed */
1179 for (i = 0; i < req->nb_streams; i++) {
1180 AVCodecContext *codec = req->streams[i]->codec;
1184 c->switch_feed_streams[i] = req->feed_streams[i];
1187 c->switch_feed_streams[i] = find_stream_in_feed(req->feed, codec, codec->bit_rate / 2);
1190 /* Wants off or slow */
1191 c->switch_feed_streams[i] = find_stream_in_feed(req->feed, codec, codec->bit_rate / 4);
1193 /* This doesn't work well when it turns off the only stream! */
1194 c->switch_feed_streams[i] = -2;
1195 c->feed_streams[i] = -2;
1200 if (c->switch_feed_streams[i] >= 0 && c->switch_feed_streams[i] != c->feed_streams[i])
1201 action_required = 1;
1204 return action_required;
1207 /* XXX: factorize in utils.c ? */
1208 /* XXX: take care with different space meaning */
1209 static void skip_spaces(const char **pp)
1213 while (*p == ' ' || *p == '\t')
1218 static void get_word(char *buf, int buf_size, const char **pp)
1226 while (!isspace(*p) && *p != '\0') {
1227 if ((q - buf) < buf_size - 1)
1236 static void get_arg(char *buf, int buf_size, const char **pp)
1243 while (isspace(*p)) p++;
1246 if (*p == '\"' || *p == '\'')
1258 if ((q - buf) < buf_size - 1)
1263 if (quote && *p == quote)
1268 static void parse_acl_row(FFStream *stream, FFStream* feed, IPAddressACL *ext_acl,
1269 const char *p, const char *filename, int line_num)
1275 get_arg(arg, sizeof(arg), &p);
1276 if (av_strcasecmp(arg, "allow") == 0)
1277 acl.action = IP_ALLOW;
1278 else if (av_strcasecmp(arg, "deny") == 0)
1279 acl.action = IP_DENY;
1281 fprintf(stderr, "%s:%d: ACL action '%s' is not ALLOW or DENY\n",
1282 filename, line_num, arg);
1286 get_arg(arg, sizeof(arg), &p);
1288 if (resolve_host(&acl.first, arg) != 0) {
1289 fprintf(stderr, "%s:%d: ACL refers to invalid host or ip address '%s'\n",
1290 filename, line_num, arg);
1293 acl.last = acl.first;
1295 get_arg(arg, sizeof(arg), &p);
1298 if (resolve_host(&acl.last, arg) != 0) {
1299 fprintf(stderr, "%s:%d: ACL refers to invalid host or ip address '%s'\n",
1300 filename, line_num, arg);
1306 IPAddressACL *nacl = av_mallocz(sizeof(*nacl));
1307 IPAddressACL **naclp = 0;
1313 naclp = &stream->acl;
1319 fprintf(stderr, "%s:%d: ACL found not in <stream> or <feed>\n",
1320 filename, line_num);
1326 naclp = &(*naclp)->next;
1334 static IPAddressACL* parse_dynamic_acl(FFStream *stream, HTTPContext *c)
1339 IPAddressACL *acl = NULL;
1343 f = fopen(stream->dynamic_acl, "r");
1345 perror(stream->dynamic_acl);
1349 acl = av_mallocz(sizeof(IPAddressACL));
1353 if (fgets(line, sizeof(line), f) == NULL)
1359 if (*p == '\0' || *p == '#')
1361 get_arg(cmd, sizeof(cmd), &p);
1363 if (!av_strcasecmp(cmd, "ACL"))
1364 parse_acl_row(NULL, NULL, acl, p, stream->dynamic_acl, line_num);
1371 static void free_acl_list(IPAddressACL *in_acl)
1373 IPAddressACL *pacl,*pacl2;
1383 static int validate_acl_list(IPAddressACL *in_acl, HTTPContext *c)
1385 enum IPAddressAction last_action = IP_DENY;
1387 struct in_addr *src = &c->from_addr.sin_addr;
1388 unsigned long src_addr = src->s_addr;
1390 for (acl = in_acl; acl; acl = acl->next) {
1391 if (src_addr >= acl->first.s_addr && src_addr <= acl->last.s_addr)
1392 return (acl->action == IP_ALLOW) ? 1 : 0;
1393 last_action = acl->action;
1396 /* Nothing matched, so return not the last action */
1397 return (last_action == IP_DENY) ? 1 : 0;
1400 static int validate_acl(FFStream *stream, HTTPContext *c)
1406 /* if stream->acl is null validate_acl_list will return 1 */
1407 ret = validate_acl_list(stream->acl, c);
1409 if (stream->dynamic_acl[0]) {
1410 acl = parse_dynamic_acl(stream, c);
1412 ret = validate_acl_list(acl, c);
1420 /* compute the real filename of a file by matching it without its
1421 extensions to all the stream filenames */
1422 static void compute_real_filename(char *filename, int max_size)
1429 /* compute filename by matching without the file extensions */
1430 av_strlcpy(file1, filename, sizeof(file1));
1431 p = strrchr(file1, '.');
1434 for(stream = first_stream; stream != NULL; stream = stream->next) {
1435 av_strlcpy(file2, stream->filename, sizeof(file2));
1436 p = strrchr(file2, '.');
1439 if (!strcmp(file1, file2)) {
1440 av_strlcpy(filename, stream->filename, max_size);
1455 /* parse http request and prepare header */
1456 static int http_parse_request(HTTPContext *c)
1459 enum RedirType redir_type;
1461 char info[1024], filename[1024];
1465 const char *mime_type;
1469 char *useragent = 0;
1472 get_word(cmd, sizeof(cmd), (const char **)&p);
1473 av_strlcpy(c->method, cmd, sizeof(c->method));
1475 if (!strcmp(cmd, "GET"))
1477 else if (!strcmp(cmd, "POST"))
1482 get_word(url, sizeof(url), (const char **)&p);
1483 av_strlcpy(c->url, url, sizeof(c->url));
1485 get_word(protocol, sizeof(protocol), (const char **)&p);
1486 if (strcmp(protocol, "HTTP/1.0") && strcmp(protocol, "HTTP/1.1"))
1489 av_strlcpy(c->protocol, protocol, sizeof(c->protocol));
1492 http_log("%s - - New connection: %s %s\n", inet_ntoa(c->from_addr.sin_addr), cmd, url);
1494 /* find the filename and the optional info string in the request */
1495 p = strchr(url, '?');
1497 av_strlcpy(info, p, sizeof(info));
1502 av_strlcpy(filename, url + ((*url == '/') ? 1 : 0), sizeof(filename)-1);
1504 for (p = c->buffer; *p && *p != '\r' && *p != '\n'; ) {
1505 if (av_strncasecmp(p, "User-Agent:", 11) == 0) {
1507 if (*useragent && *useragent != '\n' && isspace(*useragent))
1511 p = strchr(p, '\n');
1518 redir_type = REDIR_NONE;
1519 if (av_match_ext(filename, "asx")) {
1520 redir_type = REDIR_ASX;
1521 filename[strlen(filename)-1] = 'f';
1522 } else if (av_match_ext(filename, "asf") &&
1523 (!useragent || av_strncasecmp(useragent, "NSPlayer", 8) != 0)) {
1524 /* if this isn't WMP or lookalike, return the redirector file */
1525 redir_type = REDIR_ASF;
1526 } else if (av_match_ext(filename, "rpm,ram")) {
1527 redir_type = REDIR_RAM;
1528 strcpy(filename + strlen(filename)-2, "m");
1529 } else if (av_match_ext(filename, "rtsp")) {
1530 redir_type = REDIR_RTSP;
1531 compute_real_filename(filename, sizeof(filename) - 1);
1532 } else if (av_match_ext(filename, "sdp")) {
1533 redir_type = REDIR_SDP;
1534 compute_real_filename(filename, sizeof(filename) - 1);
1537 // "redirect" / request to index.html
1538 if (!strlen(filename))
1539 av_strlcpy(filename, "index.html", sizeof(filename) - 1);
1541 stream = first_stream;
1542 while (stream != NULL) {
1543 if (!strcmp(stream->filename, filename) && validate_acl(stream, c))
1545 stream = stream->next;
1547 if (stream == NULL) {
1548 snprintf(msg, sizeof(msg), "File '%s' not found", url);
1549 http_log("File '%s' not found\n", url);
1554 memcpy(c->feed_streams, stream->feed_streams, sizeof(c->feed_streams));
1555 memset(c->switch_feed_streams, -1, sizeof(c->switch_feed_streams));
1557 if (stream->stream_type == STREAM_TYPE_REDIRECT) {
1558 c->http_error = 301;
1560 q += snprintf(q, c->buffer_size,
1561 "HTTP/1.0 301 Moved\r\n"
1563 "Content-type: text/html\r\n"
1565 "<html><head><title>Moved</title></head><body>\r\n"
1566 "You should be <a href=\"%s\">redirected</a>.\r\n"
1567 "</body></html>\r\n", stream->feed_filename, stream->feed_filename);
1568 /* prepare output buffer */
1569 c->buffer_ptr = c->buffer;
1571 c->state = HTTPSTATE_SEND_HEADER;
1575 /* If this is WMP, get the rate information */
1576 if (extract_rates(ratebuf, sizeof(ratebuf), c->buffer)) {
1577 if (modify_current_stream(c, ratebuf)) {
1578 for (i = 0; i < FF_ARRAY_ELEMS(c->feed_streams); i++) {
1579 if (c->switch_feed_streams[i] >= 0)
1580 c->switch_feed_streams[i] = -1;
1585 if (c->post == 0 && stream->stream_type == STREAM_TYPE_LIVE)
1586 current_bandwidth += stream->bandwidth;
1588 /* If already streaming this feed, do not let start another feeder. */
1589 if (stream->feed_opened) {
1590 snprintf(msg, sizeof(msg), "This feed is already being received.");
1591 http_log("Feed '%s' already being received\n", stream->feed_filename);
1595 if (c->post == 0 && max_bandwidth < current_bandwidth) {
1596 c->http_error = 503;
1598 q += snprintf(q, c->buffer_size,
1599 "HTTP/1.0 503 Server too busy\r\n"
1600 "Content-type: text/html\r\n"
1602 "<html><head><title>Too busy</title></head><body>\r\n"
1603 "<p>The server is too busy to serve your request at this time.</p>\r\n"
1604 "<p>The bandwidth being served (including your stream) is %"PRIu64"kbit/sec, "
1605 "and this exceeds the limit of %"PRIu64"kbit/sec.</p>\r\n"
1606 "</body></html>\r\n", current_bandwidth, max_bandwidth);
1607 /* prepare output buffer */
1608 c->buffer_ptr = c->buffer;
1610 c->state = HTTPSTATE_SEND_HEADER;
1614 if (redir_type != REDIR_NONE) {
1617 for (p = c->buffer; *p && *p != '\r' && *p != '\n'; ) {
1618 if (av_strncasecmp(p, "Host:", 5) == 0) {
1622 p = strchr(p, '\n');
1633 while (isspace(*hostinfo))
1636 eoh = strchr(hostinfo, '\n');
1638 if (eoh[-1] == '\r')
1641 if (eoh - hostinfo < sizeof(hostbuf) - 1) {
1642 memcpy(hostbuf, hostinfo, eoh - hostinfo);
1643 hostbuf[eoh - hostinfo] = 0;
1645 c->http_error = 200;
1647 switch(redir_type) {
1649 q += snprintf(q, c->buffer_size,
1650 "HTTP/1.0 200 ASX Follows\r\n"
1651 "Content-type: video/x-ms-asf\r\n"
1653 "<ASX Version=\"3\">\r\n"
1654 //"<!-- Autogenerated by avserver -->\r\n"
1655 "<ENTRY><REF HREF=\"http://%s/%s%s\"/></ENTRY>\r\n"
1656 "</ASX>\r\n", hostbuf, filename, info);
1659 q += snprintf(q, c->buffer_size,
1660 "HTTP/1.0 200 RAM Follows\r\n"
1661 "Content-type: audio/x-pn-realaudio\r\n"
1663 "# Autogenerated by avserver\r\n"
1664 "http://%s/%s%s\r\n", hostbuf, filename, info);
1667 q += snprintf(q, c->buffer_size,
1668 "HTTP/1.0 200 ASF Redirect follows\r\n"
1669 "Content-type: video/x-ms-asf\r\n"
1672 "Ref1=http://%s/%s%s\r\n", hostbuf, filename, info);
1676 char hostname[256], *p;
1677 /* extract only hostname */
1678 av_strlcpy(hostname, hostbuf, sizeof(hostname));
1679 p = strrchr(hostname, ':');
1682 q += snprintf(q, c->buffer_size,
1683 "HTTP/1.0 200 RTSP Redirect follows\r\n"
1684 /* XXX: incorrect mime type ? */
1685 "Content-type: application/x-rtsp\r\n"
1687 "rtsp://%s:%d/%s\r\n", hostname, ntohs(my_rtsp_addr.sin_port), filename);
1693 int sdp_data_size, len;
1694 struct sockaddr_in my_addr;
1696 q += snprintf(q, c->buffer_size,
1697 "HTTP/1.0 200 OK\r\n"
1698 "Content-type: application/sdp\r\n"
1701 len = sizeof(my_addr);
1702 getsockname(c->fd, (struct sockaddr *)&my_addr, &len);
1704 /* XXX: should use a dynamic buffer */
1705 sdp_data_size = prepare_sdp_description(stream,
1708 if (sdp_data_size > 0) {
1709 memcpy(q, sdp_data, sdp_data_size);
1721 /* prepare output buffer */
1722 c->buffer_ptr = c->buffer;
1724 c->state = HTTPSTATE_SEND_HEADER;
1730 snprintf(msg, sizeof(msg), "ASX/RAM file not handled");
1734 stream->conns_served++;
1736 /* XXX: add there authenticate and IP match */
1739 /* if post, it means a feed is being sent */
1740 if (!stream->is_feed) {
1741 /* However it might be a status report from WMP! Let us log the
1742 * data as it might come in handy one day. */
1746 for (p = c->buffer; *p && *p != '\r' && *p != '\n'; ) {
1747 if (av_strncasecmp(p, "Pragma: log-line=", 17) == 0) {
1751 if (av_strncasecmp(p, "Pragma: client-id=", 18) == 0)
1752 client_id = strtol(p + 18, 0, 10);
1753 p = strchr(p, '\n');
1761 char *eol = strchr(logline, '\n');
1766 if (eol[-1] == '\r')
1768 http_log("%.*s\n", (int) (eol - logline), logline);
1769 c->suppress_log = 1;
1774 http_log("\nGot request:\n%s\n", c->buffer);
1777 if (client_id && extract_rates(ratebuf, sizeof(ratebuf), c->buffer)) {
1780 /* Now we have to find the client_id */
1781 for (wmpc = first_http_ctx; wmpc; wmpc = wmpc->next) {
1782 if (wmpc->wmp_client_id == client_id)
1786 if (wmpc && modify_current_stream(wmpc, ratebuf))
1787 wmpc->switch_pending = 1;
1790 snprintf(msg, sizeof(msg), "POST command not handled");
1794 if (http_start_receive_data(c) < 0) {
1795 snprintf(msg, sizeof(msg), "could not open feed");
1799 c->state = HTTPSTATE_RECEIVE_DATA;
1804 if (strcmp(stream->filename + strlen(stream->filename) - 4, ".asf") == 0)
1805 http_log("\nGot request:\n%s\n", c->buffer);
1808 if (c->stream->stream_type == STREAM_TYPE_STATUS)
1811 /* open input stream */
1812 if (open_input_stream(c, info) < 0) {
1813 snprintf(msg, sizeof(msg), "Input stream corresponding to '%s' not found", url);
1817 /* prepare http header */
1819 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "HTTP/1.0 200 OK\r\n");
1820 mime_type = c->stream->fmt->mime_type;
1822 mime_type = "application/x-octet-stream";
1823 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "Pragma: no-cache\r\n");
1825 /* for asf, we need extra headers */
1826 if (!strcmp(c->stream->fmt->name,"asf_stream")) {
1827 /* Need to allocate a client id */
1829 c->wmp_client_id = av_lfg_get(&random_state);
1831 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);
1833 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "Content-Type: %s\r\n", mime_type);
1834 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "\r\n");
1836 /* prepare output buffer */
1838 c->buffer_ptr = c->buffer;
1840 c->state = HTTPSTATE_SEND_HEADER;
1843 c->http_error = 404;
1845 q += snprintf(q, c->buffer_size,
1846 "HTTP/1.0 404 Not Found\r\n"
1847 "Content-type: text/html\r\n"
1850 "<head><title>404 Not Found</title></head>\n"
1853 /* prepare output buffer */
1854 c->buffer_ptr = c->buffer;
1856 c->state = HTTPSTATE_SEND_HEADER;
1860 c->http_error = 200; /* horrible : we use this value to avoid
1861 going to the send data state */
1862 c->state = HTTPSTATE_SEND_HEADER;
1866 static void fmt_bytecount(AVIOContext *pb, int64_t count)
1868 static const char *suffix = " kMGTP";
1871 for (s = suffix; count >= 100000 && s[1]; count /= 1000, s++);
1873 avio_printf(pb, "%"PRId64"%c", count, *s);
1876 static void compute_status(HTTPContext *c)
1885 if (avio_open_dyn_buf(&pb) < 0) {
1886 /* XXX: return an error ? */
1887 c->buffer_ptr = c->buffer;
1888 c->buffer_end = c->buffer;
1892 avio_printf(pb, "HTTP/1.0 200 OK\r\n");
1893 avio_printf(pb, "Content-type: %s\r\n", "text/html");
1894 avio_printf(pb, "Pragma: no-cache\r\n");
1895 avio_printf(pb, "\r\n");
1897 avio_printf(pb, "<html><head><title>%s Status</title>\n", program_name);
1898 if (c->stream->feed_filename[0])
1899 avio_printf(pb, "<link rel=\"shortcut icon\" href=\"%s\">\n", c->stream->feed_filename);
1900 avio_printf(pb, "</head>\n<body>");
1901 avio_printf(pb, "<h1>%s Status</h1>\n", program_name);
1903 avio_printf(pb, "<h2>Available Streams</h2>\n");
1904 avio_printf(pb, "<table cellspacing=0 cellpadding=4>\n");
1905 avio_printf(pb, "<tr><th valign=top>Path<th align=left>Served<br>Conns<th><br>bytes<th valign=top>Format<th>Bit rate<br>kbits/s<th align=left>Video<br>kbits/s<th><br>Codec<th align=left>Audio<br>kbits/s<th><br>Codec<th align=left valign=top>Feed\n");
1906 stream = first_stream;
1907 while (stream != NULL) {
1908 char sfilename[1024];
1911 if (stream->feed != stream) {
1912 av_strlcpy(sfilename, stream->filename, sizeof(sfilename) - 10);
1913 eosf = sfilename + strlen(sfilename);
1914 if (eosf - sfilename >= 4) {
1915 if (strcmp(eosf - 4, ".asf") == 0)
1916 strcpy(eosf - 4, ".asx");
1917 else if (strcmp(eosf - 3, ".rm") == 0)
1918 strcpy(eosf - 3, ".ram");
1919 else if (stream->fmt && !strcmp(stream->fmt->name, "rtp")) {
1920 /* generate a sample RTSP director if
1921 unicast. Generate an SDP redirector if
1923 eosf = strrchr(sfilename, '.');
1925 eosf = sfilename + strlen(sfilename);
1926 if (stream->is_multicast)
1927 strcpy(eosf, ".sdp");
1929 strcpy(eosf, ".rtsp");
1933 avio_printf(pb, "<tr><td><a href=\"/%s\">%s</a> ",
1934 sfilename, stream->filename);
1935 avio_printf(pb, "<td align=right> %d <td align=right> ",
1936 stream->conns_served);
1937 fmt_bytecount(pb, stream->bytes_served);
1938 switch(stream->stream_type) {
1939 case STREAM_TYPE_LIVE: {
1940 int audio_bit_rate = 0;
1941 int video_bit_rate = 0;
1942 const char *audio_codec_name = "";
1943 const char *video_codec_name = "";
1944 const char *audio_codec_name_extra = "";
1945 const char *video_codec_name_extra = "";
1947 for(i=0;i<stream->nb_streams;i++) {
1948 AVStream *st = stream->streams[i];
1949 AVCodec *codec = avcodec_find_encoder(st->codec->codec_id);
1950 switch(st->codec->codec_type) {
1951 case AVMEDIA_TYPE_AUDIO:
1952 audio_bit_rate += st->codec->bit_rate;
1954 if (*audio_codec_name)
1955 audio_codec_name_extra = "...";
1956 audio_codec_name = codec->name;
1959 case AVMEDIA_TYPE_VIDEO:
1960 video_bit_rate += st->codec->bit_rate;
1962 if (*video_codec_name)
1963 video_codec_name_extra = "...";
1964 video_codec_name = codec->name;
1967 case AVMEDIA_TYPE_DATA:
1968 video_bit_rate += st->codec->bit_rate;
1974 avio_printf(pb, "<td align=center> %s <td align=right> %d <td align=right> %d <td> %s %s <td align=right> %d <td> %s %s",
1977 video_bit_rate / 1000, video_codec_name, video_codec_name_extra,
1978 audio_bit_rate / 1000, audio_codec_name, audio_codec_name_extra);
1980 avio_printf(pb, "<td>%s", stream->feed->filename);
1982 avio_printf(pb, "<td>%s", stream->feed_filename);
1983 avio_printf(pb, "\n");
1987 avio_printf(pb, "<td align=center> - <td align=right> - <td align=right> - <td><td align=right> - <td>\n");
1991 stream = stream->next;
1993 avio_printf(pb, "</table>\n");
1995 stream = first_stream;
1996 while (stream != NULL) {
1997 if (stream->feed == stream) {
1998 avio_printf(pb, "<h2>Feed %s</h2>", stream->filename);
2000 avio_printf(pb, "Running as pid %d.\n", stream->pid);
2002 #if defined(linux) && !defined(CONFIG_NOCUTILS)
2007 /* This is somewhat linux specific I guess */
2008 snprintf(ps_cmd, sizeof(ps_cmd),
2009 "ps -o \"%%cpu,cputime\" --no-headers %d",
2012 pid_stat = popen(ps_cmd, "r");
2017 if (fscanf(pid_stat, "%10s %64s", cpuperc,
2019 avio_printf(pb, "Currently using %s%% of the cpu. Total time used %s.\n",
2027 avio_printf(pb, "<p>");
2029 avio_printf(pb, "<table cellspacing=0 cellpadding=4><tr><th>Stream<th>type<th>kbits/s<th align=left>codec<th align=left>Parameters\n");
2031 for (i = 0; i < stream->nb_streams; i++) {
2032 AVStream *st = stream->streams[i];
2033 AVCodec *codec = avcodec_find_encoder(st->codec->codec_id);
2034 const char *type = "unknown";
2035 char parameters[64];
2039 switch(st->codec->codec_type) {
2040 case AVMEDIA_TYPE_AUDIO:
2042 snprintf(parameters, sizeof(parameters), "%d channel(s), %d Hz", st->codec->channels, st->codec->sample_rate);
2044 case AVMEDIA_TYPE_VIDEO:
2046 snprintf(parameters, sizeof(parameters), "%dx%d, q=%d-%d, fps=%d", st->codec->width, st->codec->height,
2047 st->codec->qmin, st->codec->qmax, st->codec->time_base.den / st->codec->time_base.num);
2052 avio_printf(pb, "<tr><td align=right>%d<td>%s<td align=right>%d<td>%s<td>%s\n",
2053 i, type, st->codec->bit_rate/1000, codec ? codec->name : "", parameters);
2055 avio_printf(pb, "</table>\n");
2058 stream = stream->next;
2061 /* connection status */
2062 avio_printf(pb, "<h2>Connection Status</h2>\n");
2064 avio_printf(pb, "Number of connections: %d / %d<br>\n",
2065 nb_connections, nb_max_connections);
2067 avio_printf(pb, "Bandwidth in use: %"PRIu64"k / %"PRIu64"k<br>\n",
2068 current_bandwidth, max_bandwidth);
2070 avio_printf(pb, "<table>\n");
2071 avio_printf(pb, "<tr><th>#<th>File<th>IP<th>Proto<th>State<th>Target bits/sec<th>Actual bits/sec<th>Bytes transferred\n");
2072 c1 = first_http_ctx;
2074 while (c1 != NULL) {
2080 for (j = 0; j < c1->stream->nb_streams; j++) {
2081 if (!c1->stream->feed)
2082 bitrate += c1->stream->streams[j]->codec->bit_rate;
2083 else if (c1->feed_streams[j] >= 0)
2084 bitrate += c1->stream->feed->streams[c1->feed_streams[j]]->codec->bit_rate;
2089 p = inet_ntoa(c1->from_addr.sin_addr);
2090 avio_printf(pb, "<tr><td><b>%d</b><td>%s%s<td>%s<td>%s<td>%s<td align=right>",
2092 c1->stream ? c1->stream->filename : "",
2093 c1->state == HTTPSTATE_RECEIVE_DATA ? "(input)" : "",
2096 http_state[c1->state]);
2097 fmt_bytecount(pb, bitrate);
2098 avio_printf(pb, "<td align=right>");
2099 fmt_bytecount(pb, compute_datarate(&c1->datarate, c1->data_count) * 8);
2100 avio_printf(pb, "<td align=right>");
2101 fmt_bytecount(pb, c1->data_count);
2102 avio_printf(pb, "\n");
2105 avio_printf(pb, "</table>\n");
2110 avio_printf(pb, "<hr size=1 noshade>Generated at %s", p);
2111 avio_printf(pb, "</body>\n</html>\n");
2113 len = avio_close_dyn_buf(pb, &c->pb_buffer);
2114 c->buffer_ptr = c->pb_buffer;
2115 c->buffer_end = c->pb_buffer + len;
2118 static int open_input_stream(HTTPContext *c, const char *info)
2121 char input_filename[1024];
2122 AVFormatContext *s = NULL;
2126 /* find file name */
2127 if (c->stream->feed) {
2128 strcpy(input_filename, c->stream->feed->feed_filename);
2129 /* compute position (absolute time) */
2130 if (av_find_info_tag(buf, sizeof(buf), "date", info)) {
2131 if ((ret = av_parse_time(&stream_pos, buf, 0)) < 0)
2133 } else if (av_find_info_tag(buf, sizeof(buf), "buffer", info)) {
2134 int prebuffer = strtol(buf, 0, 10);
2135 stream_pos = av_gettime() - prebuffer * (int64_t)1000000;
2137 stream_pos = av_gettime() - c->stream->prebuffer * (int64_t)1000;
2139 strcpy(input_filename, c->stream->feed_filename);
2140 /* compute position (relative time) */
2141 if (av_find_info_tag(buf, sizeof(buf), "date", info)) {
2142 if ((ret = av_parse_time(&stream_pos, buf, 1)) < 0)
2147 if (input_filename[0] == '\0')
2151 if ((ret = avformat_open_input(&s, input_filename, c->stream->ifmt, &c->stream->in_opts)) < 0) {
2152 http_log("could not open %s: %d\n", input_filename, ret);
2155 s->flags |= AVFMT_FLAG_GENPTS;
2157 if (strcmp(s->iformat->name, "ffm") && avformat_find_stream_info(c->fmt_in, NULL) < 0) {
2158 http_log("Could not find stream info '%s'\n", input_filename);
2159 avformat_close_input(&s);
2163 /* choose stream as clock source (we favorize video stream if
2164 present) for packet sending */
2165 c->pts_stream_index = 0;
2166 for(i=0;i<c->stream->nb_streams;i++) {
2167 if (c->pts_stream_index == 0 &&
2168 c->stream->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2169 c->pts_stream_index = i;
2173 if (c->fmt_in->iformat->read_seek)
2174 av_seek_frame(c->fmt_in, -1, stream_pos, 0);
2175 /* set the start time (needed for maxtime and RTP packet timing) */
2176 c->start_time = cur_time;
2177 c->first_pts = AV_NOPTS_VALUE;
2181 /* return the server clock (in us) */
2182 static int64_t get_server_clock(HTTPContext *c)
2184 /* compute current pts value from system time */
2185 return (cur_time - c->start_time) * 1000;
2188 /* return the estimated time at which the current packet must be sent
2190 static int64_t get_packet_send_clock(HTTPContext *c)
2192 int bytes_left, bytes_sent, frame_bytes;
2194 frame_bytes = c->cur_frame_bytes;
2195 if (frame_bytes <= 0)
2198 bytes_left = c->buffer_end - c->buffer_ptr;
2199 bytes_sent = frame_bytes - bytes_left;
2200 return c->cur_pts + (c->cur_frame_duration * bytes_sent) / frame_bytes;
2205 static int http_prepare_data(HTTPContext *c)
2208 AVFormatContext *ctx;
2210 av_freep(&c->pb_buffer);
2212 case HTTPSTATE_SEND_DATA_HEADER:
2213 memset(&c->fmt_ctx, 0, sizeof(c->fmt_ctx));
2214 av_dict_set(&c->fmt_ctx.metadata, "author" , c->stream->author , 0);
2215 av_dict_set(&c->fmt_ctx.metadata, "comment" , c->stream->comment , 0);
2216 av_dict_set(&c->fmt_ctx.metadata, "copyright", c->stream->copyright, 0);
2217 av_dict_set(&c->fmt_ctx.metadata, "title" , c->stream->title , 0);
2219 c->fmt_ctx.streams = av_mallocz(sizeof(AVStream *) * c->stream->nb_streams);
2221 for(i=0;i<c->stream->nb_streams;i++) {
2223 c->fmt_ctx.streams[i] = av_mallocz(sizeof(AVStream));
2224 /* if file or feed, then just take streams from FFStream struct */
2225 if (!c->stream->feed ||
2226 c->stream->feed == c->stream)
2227 src = c->stream->streams[i];
2229 src = c->stream->feed->streams[c->stream->feed_streams[i]];
2231 *(c->fmt_ctx.streams[i]) = *src;
2232 c->fmt_ctx.streams[i]->priv_data = 0;
2233 c->fmt_ctx.streams[i]->codec->frame_number = 0; /* XXX: should be done in
2234 AVStream, not in codec */
2236 /* set output format parameters */
2237 c->fmt_ctx.oformat = c->stream->fmt;
2238 c->fmt_ctx.nb_streams = c->stream->nb_streams;
2240 c->got_key_frame = 0;
2242 /* prepare header and save header data in a stream */
2243 if (avio_open_dyn_buf(&c->fmt_ctx.pb) < 0) {
2244 /* XXX: potential leak */
2247 c->fmt_ctx.pb->seekable = 0;
2250 * HACK to avoid mpeg ps muxer to spit many underflow errors
2251 * Default value from Libav
2252 * Try to set it use configuration option
2254 c->fmt_ctx.max_delay = (int)(0.7*AV_TIME_BASE);
2256 if (avformat_write_header(&c->fmt_ctx, NULL) < 0) {
2257 http_log("Error writing output header\n");
2260 av_dict_free(&c->fmt_ctx.metadata);
2262 len = avio_close_dyn_buf(c->fmt_ctx.pb, &c->pb_buffer);
2263 c->buffer_ptr = c->pb_buffer;
2264 c->buffer_end = c->pb_buffer + len;
2266 c->state = HTTPSTATE_SEND_DATA;
2267 c->last_packet_sent = 0;
2269 case HTTPSTATE_SEND_DATA:
2270 /* find a new packet */
2271 /* read a packet from the input stream */
2272 if (c->stream->feed)
2273 ffm_set_write_index(c->fmt_in,
2274 c->stream->feed->feed_write_index,
2275 c->stream->feed->feed_size);
2277 if (c->stream->max_time &&
2278 c->stream->max_time + c->start_time - cur_time < 0)
2279 /* We have timed out */
2280 c->state = HTTPSTATE_SEND_DATA_TRAILER;
2284 ret = av_read_frame(c->fmt_in, &pkt);
2286 if (c->stream->feed) {
2287 /* if coming from feed, it means we reached the end of the
2288 ffm file, so must wait for more data */
2289 c->state = HTTPSTATE_WAIT_FEED;
2290 return 1; /* state changed */
2291 } else if (ret == AVERROR(EAGAIN)) {
2292 /* input not ready, come back later */
2295 if (c->stream->loop) {
2296 avformat_close_input(&c->fmt_in);
2297 if (open_input_stream(c, "") < 0)
2302 /* must send trailer now because eof or error */
2303 c->state = HTTPSTATE_SEND_DATA_TRAILER;
2307 int source_index = pkt.stream_index;
2308 /* update first pts if needed */
2309 if (c->first_pts == AV_NOPTS_VALUE) {
2310 c->first_pts = av_rescale_q(pkt.dts, c->fmt_in->streams[pkt.stream_index]->time_base, AV_TIME_BASE_Q);
2311 c->start_time = cur_time;
2313 /* send it to the appropriate stream */
2314 if (c->stream->feed) {
2315 /* if coming from a feed, select the right stream */
2316 if (c->switch_pending) {
2317 c->switch_pending = 0;
2318 for(i=0;i<c->stream->nb_streams;i++) {
2319 if (c->switch_feed_streams[i] == pkt.stream_index)
2320 if (pkt.flags & AV_PKT_FLAG_KEY)
2321 c->switch_feed_streams[i] = -1;
2322 if (c->switch_feed_streams[i] >= 0)
2323 c->switch_pending = 1;
2326 for(i=0;i<c->stream->nb_streams;i++) {
2327 if (c->stream->feed_streams[i] == pkt.stream_index) {
2328 AVStream *st = c->fmt_in->streams[source_index];
2329 pkt.stream_index = i;
2330 if (pkt.flags & AV_PKT_FLAG_KEY &&
2331 (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2332 c->stream->nb_streams == 1))
2333 c->got_key_frame = 1;
2334 if (!c->stream->send_on_key || c->got_key_frame)
2339 AVCodecContext *codec;
2340 AVStream *ist, *ost;
2342 ist = c->fmt_in->streams[source_index];
2343 /* specific handling for RTP: we use several
2344 output stream (one for each RTP
2345 connection). XXX: need more abstract handling */
2346 if (c->is_packetized) {
2347 /* compute send time and duration */
2348 c->cur_pts = av_rescale_q(pkt.dts, ist->time_base, AV_TIME_BASE_Q);
2349 c->cur_pts -= c->first_pts;
2350 c->cur_frame_duration = av_rescale_q(pkt.duration, ist->time_base, AV_TIME_BASE_Q);
2351 /* find RTP context */
2352 c->packet_stream_index = pkt.stream_index;
2353 ctx = c->rtp_ctx[c->packet_stream_index];
2355 av_free_packet(&pkt);
2358 codec = ctx->streams[0]->codec;
2359 /* only one stream per RTP connection */
2360 pkt.stream_index = 0;
2364 codec = ctx->streams[pkt.stream_index]->codec;
2367 if (c->is_packetized) {
2368 int max_packet_size;
2369 if (c->rtp_protocol == RTSP_LOWER_TRANSPORT_TCP)
2370 max_packet_size = RTSP_TCP_MAX_PACKET_SIZE;
2372 max_packet_size = c->rtp_handles[c->packet_stream_index]->max_packet_size;
2373 ret = ffio_open_dyn_packet_buf(&ctx->pb, max_packet_size);
2375 ret = avio_open_dyn_buf(&ctx->pb);
2378 /* XXX: potential leak */
2381 ost = ctx->streams[pkt.stream_index];
2383 ctx->pb->seekable = 0;
2384 if (pkt.dts != AV_NOPTS_VALUE)
2385 pkt.dts = av_rescale_q(pkt.dts, ist->time_base, ost->time_base);
2386 if (pkt.pts != AV_NOPTS_VALUE)
2387 pkt.pts = av_rescale_q(pkt.pts, ist->time_base, ost->time_base);
2388 pkt.duration = av_rescale_q(pkt.duration, ist->time_base, ost->time_base);
2389 if (av_write_frame(ctx, &pkt) < 0) {
2390 http_log("Error writing frame to output\n");
2391 c->state = HTTPSTATE_SEND_DATA_TRAILER;
2394 len = avio_close_dyn_buf(ctx->pb, &c->pb_buffer);
2395 c->cur_frame_bytes = len;
2396 c->buffer_ptr = c->pb_buffer;
2397 c->buffer_end = c->pb_buffer + len;
2399 codec->frame_number++;
2401 av_free_packet(&pkt);
2405 av_free_packet(&pkt);
2410 case HTTPSTATE_SEND_DATA_TRAILER:
2411 /* last packet test ? */
2412 if (c->last_packet_sent || c->is_packetized)
2415 /* prepare header */
2416 if (avio_open_dyn_buf(&ctx->pb) < 0) {
2417 /* XXX: potential leak */
2420 c->fmt_ctx.pb->seekable = 0;
2421 av_write_trailer(ctx);
2422 len = avio_close_dyn_buf(ctx->pb, &c->pb_buffer);
2423 c->buffer_ptr = c->pb_buffer;
2424 c->buffer_end = c->pb_buffer + len;
2426 c->last_packet_sent = 1;
2432 /* should convert the format at the same time */
2433 /* send data starting at c->buffer_ptr to the output connection
2434 (either UDP or TCP connection) */
2435 static int http_send_data(HTTPContext *c)
2440 if (c->buffer_ptr >= c->buffer_end) {
2441 ret = http_prepare_data(c);
2445 /* state change requested */
2448 if (c->is_packetized) {
2449 /* RTP data output */
2450 len = c->buffer_end - c->buffer_ptr;
2452 /* fail safe - should never happen */
2454 c->buffer_ptr = c->buffer_end;
2457 len = (c->buffer_ptr[0] << 24) |
2458 (c->buffer_ptr[1] << 16) |
2459 (c->buffer_ptr[2] << 8) |
2461 if (len > (c->buffer_end - c->buffer_ptr))
2463 if ((get_packet_send_clock(c) - get_server_clock(c)) > 0) {
2464 /* nothing to send yet: we can wait */
2468 c->data_count += len;
2469 update_datarate(&c->datarate, c->data_count);
2471 c->stream->bytes_served += len;
2473 if (c->rtp_protocol == RTSP_LOWER_TRANSPORT_TCP) {
2474 /* RTP packets are sent inside the RTSP TCP connection */
2476 int interleaved_index, size;
2478 HTTPContext *rtsp_c;
2481 /* if no RTSP connection left, error */
2484 /* if already sending something, then wait. */
2485 if (rtsp_c->state != RTSPSTATE_WAIT_REQUEST)
2487 if (avio_open_dyn_buf(&pb) < 0)
2489 interleaved_index = c->packet_stream_index * 2;
2490 /* RTCP packets are sent at odd indexes */
2491 if (c->buffer_ptr[1] == 200)
2492 interleaved_index++;
2493 /* write RTSP TCP header */
2495 header[1] = interleaved_index;
2496 header[2] = len >> 8;
2498 avio_write(pb, header, 4);
2499 /* write RTP packet data */
2501 avio_write(pb, c->buffer_ptr, len);
2502 size = avio_close_dyn_buf(pb, &c->packet_buffer);
2503 /* prepare asynchronous TCP sending */
2504 rtsp_c->packet_buffer_ptr = c->packet_buffer;
2505 rtsp_c->packet_buffer_end = c->packet_buffer + size;
2506 c->buffer_ptr += len;
2508 /* send everything we can NOW */
2509 len = send(rtsp_c->fd, rtsp_c->packet_buffer_ptr,
2510 rtsp_c->packet_buffer_end - rtsp_c->packet_buffer_ptr, 0);
2512 rtsp_c->packet_buffer_ptr += len;
2513 if (rtsp_c->packet_buffer_ptr < rtsp_c->packet_buffer_end) {
2514 /* if we could not send all the data, we will
2515 send it later, so a new state is needed to
2516 "lock" the RTSP TCP connection */
2517 rtsp_c->state = RTSPSTATE_SEND_PACKET;
2520 /* all data has been sent */
2521 av_freep(&c->packet_buffer);
2523 /* send RTP packet directly in UDP */
2525 ffurl_write(c->rtp_handles[c->packet_stream_index],
2526 c->buffer_ptr, len);
2527 c->buffer_ptr += len;
2528 /* here we continue as we can send several packets per 10 ms slot */
2531 /* TCP data output */
2532 len = send(c->fd, c->buffer_ptr, c->buffer_end - c->buffer_ptr, 0);
2534 if (ff_neterrno() != AVERROR(EAGAIN) &&
2535 ff_neterrno() != AVERROR(EINTR))
2536 /* error : close connection */
2541 c->buffer_ptr += len;
2543 c->data_count += len;
2544 update_datarate(&c->datarate, c->data_count);
2546 c->stream->bytes_served += len;
2554 static int http_start_receive_data(HTTPContext *c)
2558 if (c->stream->feed_opened)
2561 /* Don't permit writing to this one */
2562 if (c->stream->readonly)
2566 fd = open(c->stream->feed_filename, O_RDWR);
2568 http_log("Error opening feeder file: %s\n", strerror(errno));
2573 if (c->stream->truncate) {
2574 /* truncate feed file */
2575 ffm_write_write_index(c->feed_fd, FFM_PACKET_SIZE);
2576 ftruncate(c->feed_fd, FFM_PACKET_SIZE);
2577 http_log("Truncating feed file '%s'\n", c->stream->feed_filename);
2579 if ((c->stream->feed_write_index = ffm_read_write_index(fd)) < 0) {
2580 http_log("Error reading write index from feed file: %s\n", strerror(errno));
2585 c->stream->feed_write_index = FFMAX(ffm_read_write_index(fd), FFM_PACKET_SIZE);
2586 c->stream->feed_size = lseek(fd, 0, SEEK_END);
2587 lseek(fd, 0, SEEK_SET);
2589 /* init buffer input */
2590 c->buffer_ptr = c->buffer;
2591 c->buffer_end = c->buffer + FFM_PACKET_SIZE;
2592 c->stream->feed_opened = 1;
2593 c->chunked_encoding = !!av_stristr(c->buffer, "Transfer-Encoding: chunked");
2597 static int http_receive_data(HTTPContext *c)
2600 int len, loop_run = 0;
2602 while (c->chunked_encoding && !c->chunk_size &&
2603 c->buffer_end > c->buffer_ptr) {
2604 /* read chunk header, if present */
2605 len = recv(c->fd, c->buffer_ptr, 1, 0);
2608 if (ff_neterrno() != AVERROR(EAGAIN) &&
2609 ff_neterrno() != AVERROR(EINTR))
2610 /* error : close connection */
2613 } else if (len == 0) {
2614 /* end of connection : close it */
2616 } else if (c->buffer_ptr - c->buffer >= 2 &&
2617 !memcmp(c->buffer_ptr - 1, "\r\n", 2)) {
2618 c->chunk_size = strtol(c->buffer, 0, 16);
2619 if (c->chunk_size == 0) // end of stream
2621 c->buffer_ptr = c->buffer;
2623 } else if (++loop_run > 10) {
2624 /* no chunk header, abort */
2631 if (c->buffer_end > c->buffer_ptr) {
2632 len = recv(c->fd, c->buffer_ptr,
2633 FFMIN(c->chunk_size, c->buffer_end - c->buffer_ptr), 0);
2635 if (ff_neterrno() != AVERROR(EAGAIN) &&
2636 ff_neterrno() != AVERROR(EINTR))
2637 /* error : close connection */
2639 } else if (len == 0)
2640 /* end of connection : close it */
2643 c->chunk_size -= len;
2644 c->buffer_ptr += len;
2645 c->data_count += len;
2646 update_datarate(&c->datarate, c->data_count);
2650 if (c->buffer_ptr - c->buffer >= 2 && c->data_count > FFM_PACKET_SIZE) {
2651 if (c->buffer[0] != 'f' ||
2652 c->buffer[1] != 'm') {
2653 http_log("Feed stream has become desynchronized -- disconnecting\n");
2658 if (c->buffer_ptr >= c->buffer_end) {
2659 FFStream *feed = c->stream;
2660 /* a packet has been received : write it in the store, except
2662 if (c->data_count > FFM_PACKET_SIZE) {
2664 // printf("writing pos=0x%"PRIx64" size=0x%"PRIx64"\n", feed->feed_write_index, feed->feed_size);
2665 /* XXX: use llseek or url_seek */
2666 lseek(c->feed_fd, feed->feed_write_index, SEEK_SET);
2667 if (write(c->feed_fd, c->buffer, FFM_PACKET_SIZE) < 0) {
2668 http_log("Error writing to feed file: %s\n", strerror(errno));
2672 feed->feed_write_index += FFM_PACKET_SIZE;
2673 /* update file size */
2674 if (feed->feed_write_index > c->stream->feed_size)
2675 feed->feed_size = feed->feed_write_index;
2677 /* handle wrap around if max file size reached */
2678 if (c->stream->feed_max_size && feed->feed_write_index >= c->stream->feed_max_size)
2679 feed->feed_write_index = FFM_PACKET_SIZE;
2682 if (ffm_write_write_index(c->feed_fd, feed->feed_write_index) < 0) {
2683 http_log("Error writing index to feed file: %s\n", strerror(errno));
2687 /* wake up any waiting connections */
2688 for(c1 = first_http_ctx; c1 != NULL; c1 = c1->next) {
2689 if (c1->state == HTTPSTATE_WAIT_FEED &&
2690 c1->stream->feed == c->stream->feed)
2691 c1->state = HTTPSTATE_SEND_DATA;
2694 /* We have a header in our hands that contains useful data */
2695 AVFormatContext *s = avformat_alloc_context();
2697 AVInputFormat *fmt_in;
2703 /* use feed output format name to find corresponding input format */
2704 fmt_in = av_find_input_format(feed->fmt->name);
2708 pb = avio_alloc_context(c->buffer, c->buffer_end - c->buffer,
2709 0, NULL, NULL, NULL, NULL);
2713 if (avformat_open_input(&s, c->stream->feed_filename, fmt_in, NULL) < 0) {
2718 /* Now we have the actual streams */
2719 if (s->nb_streams != feed->nb_streams) {
2720 avformat_close_input(&s);
2722 http_log("Feed '%s' stream number does not match registered feed\n",
2723 c->stream->feed_filename);
2727 for (i = 0; i < s->nb_streams; i++) {
2728 AVStream *fst = feed->streams[i];
2729 AVStream *st = s->streams[i];
2730 avcodec_copy_context(fst->codec, st->codec);
2733 avformat_close_input(&s);
2736 c->buffer_ptr = c->buffer;
2741 c->stream->feed_opened = 0;
2743 /* wake up any waiting connections to stop waiting for feed */
2744 for(c1 = first_http_ctx; c1 != NULL; c1 = c1->next) {
2745 if (c1->state == HTTPSTATE_WAIT_FEED &&
2746 c1->stream->feed == c->stream->feed)
2747 c1->state = HTTPSTATE_SEND_DATA_TRAILER;
2752 /********************************************************************/
2755 static void rtsp_reply_header(HTTPContext *c, enum RTSPStatusCode error_number)
2762 switch(error_number) {
2763 case RTSP_STATUS_OK:
2766 case RTSP_STATUS_METHOD:
2767 str = "Method Not Allowed";
2769 case RTSP_STATUS_BANDWIDTH:
2770 str = "Not Enough Bandwidth";
2772 case RTSP_STATUS_SESSION:
2773 str = "Session Not Found";
2775 case RTSP_STATUS_STATE:
2776 str = "Method Not Valid in This State";
2778 case RTSP_STATUS_AGGREGATE:
2779 str = "Aggregate operation not allowed";
2781 case RTSP_STATUS_ONLY_AGGREGATE:
2782 str = "Only aggregate operation allowed";
2784 case RTSP_STATUS_TRANSPORT:
2785 str = "Unsupported transport";
2787 case RTSP_STATUS_INTERNAL:
2788 str = "Internal Server Error";
2790 case RTSP_STATUS_SERVICE:
2791 str = "Service Unavailable";
2793 case RTSP_STATUS_VERSION:
2794 str = "RTSP Version not supported";
2797 str = "Unknown Error";
2801 avio_printf(c->pb, "RTSP/1.0 %d %s\r\n", error_number, str);
2802 avio_printf(c->pb, "CSeq: %d\r\n", c->seq);
2804 /* output GMT time */
2807 strftime(buf2, sizeof(buf2), "%a, %d %b %Y %H:%M:%S", tm);
2808 avio_printf(c->pb, "Date: %s GMT\r\n", buf2);
2811 static void rtsp_reply_error(HTTPContext *c, enum RTSPStatusCode error_number)
2813 rtsp_reply_header(c, error_number);
2814 avio_printf(c->pb, "\r\n");
2817 static int rtsp_parse_request(HTTPContext *c)
2819 const char *p, *p1, *p2;
2825 RTSPMessageHeader header1, *header = &header1;
2827 c->buffer_ptr[0] = '\0';
2830 get_word(cmd, sizeof(cmd), &p);
2831 get_word(url, sizeof(url), &p);
2832 get_word(protocol, sizeof(protocol), &p);
2834 av_strlcpy(c->method, cmd, sizeof(c->method));
2835 av_strlcpy(c->url, url, sizeof(c->url));
2836 av_strlcpy(c->protocol, protocol, sizeof(c->protocol));
2838 if (avio_open_dyn_buf(&c->pb) < 0) {
2839 /* XXX: cannot do more */
2840 c->pb = NULL; /* safety */
2844 /* check version name */
2845 if (strcmp(protocol, "RTSP/1.0") != 0) {
2846 rtsp_reply_error(c, RTSP_STATUS_VERSION);
2850 /* parse each header line */
2851 memset(header, 0, sizeof(*header));
2852 /* skip to next line */
2853 while (*p != '\n' && *p != '\0')
2857 while (*p != '\0') {
2858 p1 = memchr(p, '\n', (char *)c->buffer_ptr - p);
2862 if (p2 > p && p2[-1] == '\r')
2864 /* skip empty line */
2868 if (len > sizeof(line) - 1)
2869 len = sizeof(line) - 1;
2870 memcpy(line, p, len);
2872 ff_rtsp_parse_line(header, line, NULL, NULL);
2876 /* handle sequence number */
2877 c->seq = header->seq;
2879 if (!strcmp(cmd, "DESCRIBE"))
2880 rtsp_cmd_describe(c, url);
2881 else if (!strcmp(cmd, "OPTIONS"))
2882 rtsp_cmd_options(c, url);
2883 else if (!strcmp(cmd, "SETUP"))
2884 rtsp_cmd_setup(c, url, header);
2885 else if (!strcmp(cmd, "PLAY"))
2886 rtsp_cmd_play(c, url, header);
2887 else if (!strcmp(cmd, "PAUSE"))
2888 rtsp_cmd_pause(c, url, header);
2889 else if (!strcmp(cmd, "TEARDOWN"))
2890 rtsp_cmd_teardown(c, url, header);
2892 rtsp_reply_error(c, RTSP_STATUS_METHOD);
2895 len = avio_close_dyn_buf(c->pb, &c->pb_buffer);
2896 c->pb = NULL; /* safety */
2898 /* XXX: cannot do more */
2901 c->buffer_ptr = c->pb_buffer;
2902 c->buffer_end = c->pb_buffer + len;
2903 c->state = RTSPSTATE_SEND_REPLY;
2907 static int prepare_sdp_description(FFStream *stream, uint8_t **pbuffer,
2908 struct in_addr my_ip)
2910 AVFormatContext *avc;
2911 AVStream *avs = NULL;
2914 avc = avformat_alloc_context();
2918 av_dict_set(&avc->metadata, "title",
2919 stream->title[0] ? stream->title : "No Title", 0);
2920 avc->nb_streams = stream->nb_streams;
2921 if (stream->is_multicast) {
2922 snprintf(avc->filename, 1024, "rtp://%s:%d?multicast=1?ttl=%d",
2923 inet_ntoa(stream->multicast_ip),
2924 stream->multicast_port, stream->multicast_ttl);
2926 snprintf(avc->filename, 1024, "rtp://0.0.0.0");
2929 if (avc->nb_streams >= INT_MAX/sizeof(*avc->streams) ||
2930 !(avc->streams = av_malloc(avc->nb_streams * sizeof(*avc->streams))))
2932 if (avc->nb_streams >= INT_MAX/sizeof(*avs) ||
2933 !(avs = av_malloc(avc->nb_streams * sizeof(*avs))))
2936 for(i = 0; i < stream->nb_streams; i++) {
2937 avc->streams[i] = &avs[i];
2938 avc->streams[i]->codec = stream->streams[i]->codec;
2940 *pbuffer = av_mallocz(2048);
2941 av_sdp_create(&avc, 1, *pbuffer, 2048);
2944 av_free(avc->streams);
2945 av_dict_free(&avc->metadata);
2949 return strlen(*pbuffer);
2952 static void rtsp_cmd_options(HTTPContext *c, const char *url)
2954 // rtsp_reply_header(c, RTSP_STATUS_OK);
2955 avio_printf(c->pb, "RTSP/1.0 %d %s\r\n", RTSP_STATUS_OK, "OK");
2956 avio_printf(c->pb, "CSeq: %d\r\n", c->seq);
2957 avio_printf(c->pb, "Public: %s\r\n", "OPTIONS, DESCRIBE, SETUP, TEARDOWN, PLAY, PAUSE");
2958 avio_printf(c->pb, "\r\n");
2961 static void rtsp_cmd_describe(HTTPContext *c, const char *url)
2967 int content_length, len;
2968 struct sockaddr_in my_addr;
2970 /* find which url is asked */
2971 av_url_split(NULL, 0, NULL, 0, NULL, 0, NULL, path1, sizeof(path1), url);
2976 for(stream = first_stream; stream != NULL; stream = stream->next) {
2977 if (!stream->is_feed &&
2978 stream->fmt && !strcmp(stream->fmt->name, "rtp") &&
2979 !strcmp(path, stream->filename)) {
2983 /* no stream found */
2984 rtsp_reply_error(c, RTSP_STATUS_SERVICE); /* XXX: right error ? */
2988 /* prepare the media description in sdp format */
2990 /* get the host IP */
2991 len = sizeof(my_addr);
2992 getsockname(c->fd, (struct sockaddr *)&my_addr, &len);
2993 content_length = prepare_sdp_description(stream, &content, my_addr.sin_addr);
2994 if (content_length < 0) {
2995 rtsp_reply_error(c, RTSP_STATUS_INTERNAL);
2998 rtsp_reply_header(c, RTSP_STATUS_OK);
2999 avio_printf(c->pb, "Content-Base: %s/\r\n", url);
3000 avio_printf(c->pb, "Content-Type: application/sdp\r\n");
3001 avio_printf(c->pb, "Content-Length: %d\r\n", content_length);
3002 avio_printf(c->pb, "\r\n");
3003 avio_write(c->pb, content, content_length);
3007 static HTTPContext *find_rtp_session(const char *session_id)
3011 if (session_id[0] == '\0')
3014 for(c = first_http_ctx; c != NULL; c = c->next) {
3015 if (!strcmp(c->session_id, session_id))
3021 static RTSPTransportField *find_transport(RTSPMessageHeader *h, enum RTSPLowerTransport lower_transport)
3023 RTSPTransportField *th;
3026 for(i=0;i<h->nb_transports;i++) {
3027 th = &h->transports[i];
3028 if (th->lower_transport == lower_transport)
3034 static void rtsp_cmd_setup(HTTPContext *c, const char *url,
3035 RTSPMessageHeader *h)
3038 int stream_index, rtp_port, rtcp_port;
3043 RTSPTransportField *th;
3044 struct sockaddr_in dest_addr;
3045 RTSPActionServerSetup setup;
3047 /* find which url is asked */
3048 av_url_split(NULL, 0, NULL, 0, NULL, 0, NULL, path1, sizeof(path1), url);
3053 /* now check each stream */
3054 for(stream = first_stream; stream != NULL; stream = stream->next) {
3055 if (!stream->is_feed &&
3056 stream->fmt && !strcmp(stream->fmt->name, "rtp")) {
3057 /* accept aggregate filenames only if single stream */
3058 if (!strcmp(path, stream->filename)) {
3059 if (stream->nb_streams != 1) {
3060 rtsp_reply_error(c, RTSP_STATUS_AGGREGATE);
3067 for(stream_index = 0; stream_index < stream->nb_streams;
3069 snprintf(buf, sizeof(buf), "%s/streamid=%d",
3070 stream->filename, stream_index);
3071 if (!strcmp(path, buf))
3076 /* no stream found */
3077 rtsp_reply_error(c, RTSP_STATUS_SERVICE); /* XXX: right error ? */
3081 /* generate session id if needed */
3082 if (h->session_id[0] == '\0')
3083 snprintf(h->session_id, sizeof(h->session_id), "%08x%08x",
3084 av_lfg_get(&random_state), av_lfg_get(&random_state));
3086 /* find rtp session, and create it if none found */
3087 rtp_c = find_rtp_session(h->session_id);
3089 /* always prefer UDP */
3090 th = find_transport(h, RTSP_LOWER_TRANSPORT_UDP);
3092 th = find_transport(h, RTSP_LOWER_TRANSPORT_TCP);
3094 rtsp_reply_error(c, RTSP_STATUS_TRANSPORT);
3099 rtp_c = rtp_new_connection(&c->from_addr, stream, h->session_id,
3100 th->lower_transport);
3102 rtsp_reply_error(c, RTSP_STATUS_BANDWIDTH);
3106 /* open input stream */
3107 if (open_input_stream(rtp_c, "") < 0) {
3108 rtsp_reply_error(c, RTSP_STATUS_INTERNAL);
3113 /* test if stream is OK (test needed because several SETUP needs
3114 to be done for a given file) */
3115 if (rtp_c->stream != stream) {
3116 rtsp_reply_error(c, RTSP_STATUS_SERVICE);
3120 /* test if stream is already set up */
3121 if (rtp_c->rtp_ctx[stream_index]) {
3122 rtsp_reply_error(c, RTSP_STATUS_STATE);
3126 /* check transport */
3127 th = find_transport(h, rtp_c->rtp_protocol);
3128 if (!th || (th->lower_transport == RTSP_LOWER_TRANSPORT_UDP &&
3129 th->client_port_min <= 0)) {
3130 rtsp_reply_error(c, RTSP_STATUS_TRANSPORT);
3134 /* setup default options */
3135 setup.transport_option[0] = '\0';
3136 dest_addr = rtp_c->from_addr;
3137 dest_addr.sin_port = htons(th->client_port_min);
3140 if (rtp_new_av_stream(rtp_c, stream_index, &dest_addr, c) < 0) {
3141 rtsp_reply_error(c, RTSP_STATUS_TRANSPORT);
3145 /* now everything is OK, so we can send the connection parameters */
3146 rtsp_reply_header(c, RTSP_STATUS_OK);
3148 avio_printf(c->pb, "Session: %s\r\n", rtp_c->session_id);
3150 switch(rtp_c->rtp_protocol) {
3151 case RTSP_LOWER_TRANSPORT_UDP:
3152 rtp_port = ff_rtp_get_local_rtp_port(rtp_c->rtp_handles[stream_index]);
3153 rtcp_port = ff_rtp_get_local_rtcp_port(rtp_c->rtp_handles[stream_index]);
3154 avio_printf(c->pb, "Transport: RTP/AVP/UDP;unicast;"
3155 "client_port=%d-%d;server_port=%d-%d",
3156 th->client_port_min, th->client_port_max,
3157 rtp_port, rtcp_port);
3159 case RTSP_LOWER_TRANSPORT_TCP:
3160 avio_printf(c->pb, "Transport: RTP/AVP/TCP;interleaved=%d-%d",
3161 stream_index * 2, stream_index * 2 + 1);
3166 if (setup.transport_option[0] != '\0')
3167 avio_printf(c->pb, ";%s", setup.transport_option);
3168 avio_printf(c->pb, "\r\n");
3171 avio_printf(c->pb, "\r\n");
3175 /* find an rtp connection by using the session ID. Check consistency
3177 static HTTPContext *find_rtp_session_with_url(const char *url,
3178 const char *session_id)
3186 rtp_c = find_rtp_session(session_id);
3190 /* find which url is asked */
3191 av_url_split(NULL, 0, NULL, 0, NULL, 0, NULL, path1, sizeof(path1), url);
3195 if(!strcmp(path, rtp_c->stream->filename)) return rtp_c;
3196 for(s=0; s<rtp_c->stream->nb_streams; ++s) {
3197 snprintf(buf, sizeof(buf), "%s/streamid=%d",
3198 rtp_c->stream->filename, s);
3199 if(!strncmp(path, buf, sizeof(buf))) {
3200 // XXX: Should we reply with RTSP_STATUS_ONLY_AGGREGATE if nb_streams>1?
3205 if (len > 0 && path[len - 1] == '/' &&
3206 !strncmp(path, rtp_c->stream->filename, len - 1))
3211 static void rtsp_cmd_play(HTTPContext *c, const char *url, RTSPMessageHeader *h)
3215 rtp_c = find_rtp_session_with_url(url, h->session_id);
3217 rtsp_reply_error(c, RTSP_STATUS_SESSION);
3221 if (rtp_c->state != HTTPSTATE_SEND_DATA &&
3222 rtp_c->state != HTTPSTATE_WAIT_FEED &&
3223 rtp_c->state != HTTPSTATE_READY) {
3224 rtsp_reply_error(c, RTSP_STATUS_STATE);
3228 rtp_c->state = HTTPSTATE_SEND_DATA;
3230 /* now everything is OK, so we can send the connection parameters */
3231 rtsp_reply_header(c, RTSP_STATUS_OK);
3233 avio_printf(c->pb, "Session: %s\r\n", rtp_c->session_id);
3234 avio_printf(c->pb, "\r\n");
3237 static void rtsp_cmd_pause(HTTPContext *c, const char *url, RTSPMessageHeader *h)
3241 rtp_c = find_rtp_session_with_url(url, h->session_id);
3243 rtsp_reply_error(c, RTSP_STATUS_SESSION);
3247 if (rtp_c->state != HTTPSTATE_SEND_DATA &&
3248 rtp_c->state != HTTPSTATE_WAIT_FEED) {
3249 rtsp_reply_error(c, RTSP_STATUS_STATE);
3253 rtp_c->state = HTTPSTATE_READY;
3254 rtp_c->first_pts = AV_NOPTS_VALUE;
3255 /* now everything is OK, so we can send the connection parameters */
3256 rtsp_reply_header(c, RTSP_STATUS_OK);
3258 avio_printf(c->pb, "Session: %s\r\n", rtp_c->session_id);
3259 avio_printf(c->pb, "\r\n");
3262 static void rtsp_cmd_teardown(HTTPContext *c, const char *url, RTSPMessageHeader *h)
3266 rtp_c = find_rtp_session_with_url(url, h->session_id);
3268 rtsp_reply_error(c, RTSP_STATUS_SESSION);
3272 /* now everything is OK, so we can send the connection parameters */
3273 rtsp_reply_header(c, RTSP_STATUS_OK);
3275 avio_printf(c->pb, "Session: %s\r\n", rtp_c->session_id);
3276 avio_printf(c->pb, "\r\n");
3278 /* abort the session */
3279 close_connection(rtp_c);
3283 /********************************************************************/
3286 static HTTPContext *rtp_new_connection(struct sockaddr_in *from_addr,
3287 FFStream *stream, const char *session_id,
3288 enum RTSPLowerTransport rtp_protocol)
3290 HTTPContext *c = NULL;
3291 const char *proto_str;
3293 /* XXX: should output a warning page when coming
3294 close to the connection limit */
3295 if (nb_connections >= nb_max_connections)
3298 /* add a new connection */
3299 c = av_mallocz(sizeof(HTTPContext));
3304 c->poll_entry = NULL;
3305 c->from_addr = *from_addr;
3306 c->buffer_size = IOBUFFER_INIT_SIZE;
3307 c->buffer = av_malloc(c->buffer_size);
3312 av_strlcpy(c->session_id, session_id, sizeof(c->session_id));
3313 c->state = HTTPSTATE_READY;
3314 c->is_packetized = 1;
3315 c->rtp_protocol = rtp_protocol;
3317 /* protocol is shown in statistics */
3318 switch(c->rtp_protocol) {
3319 case RTSP_LOWER_TRANSPORT_UDP_MULTICAST:
3320 proto_str = "MCAST";
3322 case RTSP_LOWER_TRANSPORT_UDP:
3325 case RTSP_LOWER_TRANSPORT_TCP:
3332 av_strlcpy(c->protocol, "RTP/", sizeof(c->protocol));
3333 av_strlcat(c->protocol, proto_str, sizeof(c->protocol));
3335 current_bandwidth += stream->bandwidth;
3337 c->next = first_http_ctx;
3349 /* add a new RTP stream in an RTP connection (used in RTSP SETUP
3350 command). If RTP/TCP protocol is used, TCP connection 'rtsp_c' is
3352 static int rtp_new_av_stream(HTTPContext *c,
3353 int stream_index, struct sockaddr_in *dest_addr,
3354 HTTPContext *rtsp_c)
3356 AVFormatContext *ctx;
3359 URLContext *h = NULL;
3361 int max_packet_size;
3363 /* now we can open the relevant output stream */
3364 ctx = avformat_alloc_context();
3367 ctx->oformat = av_guess_format("rtp", NULL, NULL);
3369 st = av_mallocz(sizeof(AVStream));
3372 ctx->nb_streams = 1;
3373 ctx->streams = av_mallocz(sizeof(AVStream *) * ctx->nb_streams);
3376 ctx->streams[0] = st;
3378 if (!c->stream->feed ||
3379 c->stream->feed == c->stream)
3380 memcpy(st, c->stream->streams[stream_index], sizeof(AVStream));
3383 c->stream->feed->streams[c->stream->feed_streams[stream_index]],
3385 st->priv_data = NULL;
3387 /* build destination RTP address */
3388 ipaddr = inet_ntoa(dest_addr->sin_addr);
3390 switch(c->rtp_protocol) {
3391 case RTSP_LOWER_TRANSPORT_UDP:
3392 case RTSP_LOWER_TRANSPORT_UDP_MULTICAST:
3395 /* XXX: also pass as parameter to function ? */
3396 if (c->stream->is_multicast) {
3398 ttl = c->stream->multicast_ttl;
3401 snprintf(ctx->filename, sizeof(ctx->filename),
3402 "rtp://%s:%d?multicast=1&ttl=%d",
3403 ipaddr, ntohs(dest_addr->sin_port), ttl);
3405 snprintf(ctx->filename, sizeof(ctx->filename),
3406 "rtp://%s:%d", ipaddr, ntohs(dest_addr->sin_port));
3409 if (ffurl_open(&h, ctx->filename, AVIO_FLAG_WRITE, NULL, NULL) < 0)
3411 c->rtp_handles[stream_index] = h;
3412 max_packet_size = h->max_packet_size;
3414 case RTSP_LOWER_TRANSPORT_TCP:
3417 max_packet_size = RTSP_TCP_MAX_PACKET_SIZE;
3423 http_log("%s:%d - - \"PLAY %s/streamid=%d %s\"\n",
3424 ipaddr, ntohs(dest_addr->sin_port),
3425 c->stream->filename, stream_index, c->protocol);
3427 /* normally, no packets should be output here, but the packet size may be checked */
3428 if (ffio_open_dyn_packet_buf(&ctx->pb, max_packet_size) < 0) {
3429 /* XXX: close stream */
3432 if (avformat_write_header(ctx, NULL) < 0) {
3439 avio_close_dyn_buf(ctx->pb, &dummy_buf);
3442 c->rtp_ctx[stream_index] = ctx;
3446 /********************************************************************/
3447 /* avserver initialization */
3449 static AVStream *add_av_stream1(FFStream *stream, AVCodecContext *codec, int copy)
3453 fst = av_mallocz(sizeof(AVStream));
3457 fst->codec = avcodec_alloc_context3(NULL);
3458 memcpy(fst->codec, codec, sizeof(AVCodecContext));
3459 if (codec->extradata_size) {
3460 fst->codec->extradata = av_malloc(codec->extradata_size);
3461 memcpy(fst->codec->extradata, codec->extradata,
3462 codec->extradata_size);
3465 /* live streams must use the actual feed's codec since it may be
3466 * updated later to carry extradata needed by the streams.
3470 fst->priv_data = av_mallocz(sizeof(FeedData));
3471 fst->index = stream->nb_streams;
3472 avpriv_set_pts_info(fst, 33, 1, 90000);
3473 fst->sample_aspect_ratio = codec->sample_aspect_ratio;
3474 stream->streams[stream->nb_streams++] = fst;
3478 /* return the stream number in the feed */
3479 static int add_av_stream(FFStream *feed, AVStream *st)
3482 AVCodecContext *av, *av1;
3486 for(i=0;i<feed->nb_streams;i++) {
3487 st = feed->streams[i];
3489 if (av1->codec_id == av->codec_id &&
3490 av1->codec_type == av->codec_type &&
3491 av1->bit_rate == av->bit_rate) {
3493 switch(av->codec_type) {
3494 case AVMEDIA_TYPE_AUDIO:
3495 if (av1->channels == av->channels &&
3496 av1->sample_rate == av->sample_rate)
3499 case AVMEDIA_TYPE_VIDEO:
3500 if (av1->width == av->width &&
3501 av1->height == av->height &&
3502 av1->time_base.den == av->time_base.den &&
3503 av1->time_base.num == av->time_base.num &&
3504 av1->gop_size == av->gop_size)
3513 fst = add_av_stream1(feed, av, 0);
3516 return feed->nb_streams - 1;
3519 static void remove_stream(FFStream *stream)
3523 while (*ps != NULL) {
3531 /* specific mpeg4 handling : we extract the raw parameters */
3532 static void extract_mpeg4_header(AVFormatContext *infile)
3534 int mpeg4_count, i, size;
3540 for(i=0;i<infile->nb_streams;i++) {
3541 st = infile->streams[i];
3542 if (st->codec->codec_id == CODEC_ID_MPEG4 &&
3543 st->codec->extradata_size == 0) {
3550 printf("MPEG4 without extra data: trying to find header in %s\n", infile->filename);
3551 while (mpeg4_count > 0) {
3552 if (av_read_packet(infile, &pkt) < 0)
3554 st = infile->streams[pkt.stream_index];
3555 if (st->codec->codec_id == CODEC_ID_MPEG4 &&
3556 st->codec->extradata_size == 0) {
3557 av_freep(&st->codec->extradata);
3558 /* fill extradata with the header */
3559 /* XXX: we make hard suppositions here ! */
3561 while (p < pkt.data + pkt.size - 4) {
3562 /* stop when vop header is found */
3563 if (p[0] == 0x00 && p[1] == 0x00 &&
3564 p[2] == 0x01 && p[3] == 0xb6) {
3565 size = p - pkt.data;
3566 // av_hex_dump_log(infile, AV_LOG_DEBUG, pkt.data, size);
3567 st->codec->extradata = av_malloc(size);
3568 st->codec->extradata_size = size;
3569 memcpy(st->codec->extradata, pkt.data, size);
3576 av_free_packet(&pkt);
3580 /* compute the needed AVStream for each file */
3581 static void build_file_streams(void)
3583 FFStream *stream, *stream_next;
3586 /* gather all streams */
3587 for(stream = first_stream; stream != NULL; stream = stream_next) {
3588 AVFormatContext *infile = NULL;
3589 stream_next = stream->next;
3590 if (stream->stream_type == STREAM_TYPE_LIVE &&
3592 /* the stream comes from a file */
3593 /* try to open the file */
3595 if (stream->fmt && !strcmp(stream->fmt->name, "rtp")) {
3596 /* specific case : if transport stream output to RTP,
3597 we use a raw transport stream reader */
3598 av_dict_set(&stream->in_opts, "mpeg2ts_compute_pcr", "1", 0);
3601 http_log("Opening file '%s'\n", stream->feed_filename);
3602 if ((ret = avformat_open_input(&infile, stream->feed_filename, stream->ifmt, &stream->in_opts)) < 0) {
3603 http_log("Could not open '%s': %d\n", stream->feed_filename, ret);
3604 /* remove stream (no need to spend more time on it) */
3606 remove_stream(stream);
3608 /* find all the AVStreams inside and reference them in
3610 if (avformat_find_stream_info(infile, NULL) < 0) {
3611 http_log("Could not find codec parameters from '%s'\n",
3612 stream->feed_filename);
3613 avformat_close_input(&infile);
3616 extract_mpeg4_header(infile);
3618 for(i=0;i<infile->nb_streams;i++)
3619 add_av_stream1(stream, infile->streams[i]->codec, 1);
3621 avformat_close_input(&infile);
3627 /* compute the needed AVStream for each feed */
3628 static void build_feed_streams(void)
3630 FFStream *stream, *feed;
3633 /* gather all streams */
3634 for(stream = first_stream; stream != NULL; stream = stream->next) {
3635 feed = stream->feed;
3637 if (stream->is_feed) {
3638 for(i=0;i<stream->nb_streams;i++)
3639 stream->feed_streams[i] = i;
3641 /* we handle a stream coming from a feed */
3642 for(i=0;i<stream->nb_streams;i++)
3643 stream->feed_streams[i] = add_av_stream(feed, stream->streams[i]);
3648 /* create feed files if needed */
3649 for(feed = first_feed; feed != NULL; feed = feed->next_feed) {
3652 if (avio_check(feed->feed_filename, AVIO_FLAG_READ) > 0) {
3653 /* See if it matches */
3654 AVFormatContext *s = NULL;
3657 if (avformat_open_input(&s, feed->feed_filename, NULL, NULL) >= 0) {
3658 /* Now see if it matches */
3659 if (s->nb_streams == feed->nb_streams) {
3661 for(i=0;i<s->nb_streams;i++) {
3663 sf = feed->streams[i];
3666 if (sf->index != ss->index ||
3668 http_log("Index & Id do not match for stream %d (%s)\n",
3669 i, feed->feed_filename);
3672 AVCodecContext *ccf, *ccs;
3676 #define CHECK_CODEC(x) (ccf->x != ccs->x)
3678 if (CHECK_CODEC(codec_id) || CHECK_CODEC(codec_type)) {
3679 http_log("Codecs do not match for stream %d\n", i);
3681 } else if (CHECK_CODEC(bit_rate) || CHECK_CODEC(flags)) {
3682 http_log("Codec bitrates do not match for stream %d\n", i);
3684 } else if (ccf->codec_type == AVMEDIA_TYPE_VIDEO) {
3685 if (CHECK_CODEC(time_base.den) ||
3686 CHECK_CODEC(time_base.num) ||
3687 CHECK_CODEC(width) ||
3688 CHECK_CODEC(height)) {
3689 http_log("Codec width, height and framerate do not match for stream %d\n", i);
3692 } else if (ccf->codec_type == AVMEDIA_TYPE_AUDIO) {
3693 if (CHECK_CODEC(sample_rate) ||
3694 CHECK_CODEC(channels) ||
3695 CHECK_CODEC(frame_size)) {
3696 http_log("Codec sample_rate, channels, frame_size do not match for stream %d\n", i);
3700 http_log("Unknown codec type\n");
3708 http_log("Deleting feed file '%s' as stream counts differ (%d != %d)\n",
3709 feed->feed_filename, s->nb_streams, feed->nb_streams);
3711 avformat_close_input(&s);
3713 http_log("Deleting feed file '%s' as it appears to be corrupt\n",
3714 feed->feed_filename);
3717 if (feed->readonly) {
3718 http_log("Unable to delete feed file '%s' as it is marked readonly\n",
3719 feed->feed_filename);
3722 unlink(feed->feed_filename);
3725 if (avio_check(feed->feed_filename, AVIO_FLAG_WRITE) <= 0) {
3726 AVFormatContext s1 = {0}, *s = &s1;
3728 if (feed->readonly) {
3729 http_log("Unable to create feed file '%s' as it is marked readonly\n",
3730 feed->feed_filename);
3734 /* only write the header of the ffm file */
3735 if (avio_open(&s->pb, feed->feed_filename, AVIO_FLAG_WRITE) < 0) {
3736 http_log("Could not open output feed file '%s'\n",
3737 feed->feed_filename);
3740 s->oformat = feed->fmt;
3741 s->nb_streams = feed->nb_streams;
3742 s->streams = feed->streams;
3743 if (avformat_write_header(s, NULL) < 0) {
3744 http_log("Container doesn't supports the required parameters\n");
3747 /* XXX: need better api */
3748 av_freep(&s->priv_data);
3751 /* get feed size and write index */
3752 fd = open(feed->feed_filename, O_RDONLY);
3754 http_log("Could not open output feed file '%s'\n",
3755 feed->feed_filename);
3759 feed->feed_write_index = FFMAX(ffm_read_write_index(fd), FFM_PACKET_SIZE);
3760 feed->feed_size = lseek(fd, 0, SEEK_END);
3761 /* ensure that we do not wrap before the end of file */
3762 if (feed->feed_max_size && feed->feed_max_size < feed->feed_size)
3763 feed->feed_max_size = feed->feed_size;
3769 /* compute the bandwidth used by each stream */
3770 static void compute_bandwidth(void)
3776 for(stream = first_stream; stream != NULL; stream = stream->next) {
3778 for(i=0;i<stream->nb_streams;i++) {
3779 AVStream *st = stream->streams[i];
3780 switch(st->codec->codec_type) {
3781 case AVMEDIA_TYPE_AUDIO:
3782 case AVMEDIA_TYPE_VIDEO:
3783 bandwidth += st->codec->bit_rate;
3789 stream->bandwidth = (bandwidth + 999) / 1000;
3793 /* add a codec and set the default parameters */
3794 static void add_codec(FFStream *stream, AVCodecContext *av)
3798 /* compute default parameters */
3799 switch(av->codec_type) {
3800 case AVMEDIA_TYPE_AUDIO:
3801 if (av->bit_rate == 0)
3802 av->bit_rate = 64000;
3803 if (av->sample_rate == 0)
3804 av->sample_rate = 22050;
3805 if (av->channels == 0)
3808 case AVMEDIA_TYPE_VIDEO:
3809 if (av->bit_rate == 0)
3810 av->bit_rate = 64000;
3811 if (av->time_base.num == 0){
3812 av->time_base.den = 5;
3813 av->time_base.num = 1;
3815 if (av->width == 0 || av->height == 0) {
3819 /* Bitrate tolerance is less for streaming */
3820 if (av->bit_rate_tolerance == 0)
3821 av->bit_rate_tolerance = FFMAX(av->bit_rate / 4,
3822 (int64_t)av->bit_rate*av->time_base.num/av->time_base.den);
3827 if (av->max_qdiff == 0)
3829 av->qcompress = 0.5;
3832 if (!av->nsse_weight)
3833 av->nsse_weight = 8;
3835 av->frame_skip_cmp = FF_CMP_DCTMAX;
3837 av->me_method = ME_EPZS;
3838 av->rc_buffer_aggressivity = 1.0;
3841 av->rc_eq = "tex^qComp";
3842 if (!av->i_quant_factor)
3843 av->i_quant_factor = -0.8;
3844 if (!av->b_quant_factor)
3845 av->b_quant_factor = 1.25;
3846 if (!av->b_quant_offset)
3847 av->b_quant_offset = 1.25;
3848 if (!av->rc_max_rate)
3849 av->rc_max_rate = av->bit_rate * 2;
3851 if (av->rc_max_rate && !av->rc_buffer_size) {
3852 av->rc_buffer_size = av->rc_max_rate;
3861 st = av_mallocz(sizeof(AVStream));
3864 st->codec = avcodec_alloc_context3(NULL);
3865 stream->streams[stream->nb_streams++] = st;
3866 memcpy(st->codec, av, sizeof(AVCodecContext));
3869 static enum CodecID opt_audio_codec(const char *arg)
3871 AVCodec *p= avcodec_find_encoder_by_name(arg);
3873 if (p == NULL || p->type != AVMEDIA_TYPE_AUDIO)
3874 return CODEC_ID_NONE;
3879 static enum CodecID opt_video_codec(const char *arg)
3881 AVCodec *p= avcodec_find_encoder_by_name(arg);
3883 if (p == NULL || p->type != AVMEDIA_TYPE_VIDEO)
3884 return CODEC_ID_NONE;
3889 /* simplistic plugin support */
3892 static void load_module(const char *filename)
3895 void (*init_func)(void);
3896 dll = dlopen(filename, RTLD_NOW);
3898 fprintf(stderr, "Could not load module '%s' - %s\n",
3899 filename, dlerror());
3903 init_func = dlsym(dll, "avserver_module_init");
3906 "%s: init function 'avserver_module_init()' not found\n",
3915 static int avserver_opt_default(const char *opt, const char *arg,
3916 AVCodecContext *avctx, int type)
3919 const AVOption *o = av_opt_find(avctx, opt, NULL, type, 0);
3921 ret = av_opt_set(avctx, opt, arg, 0);
3925 static int avserver_opt_preset(const char *arg,
3926 AVCodecContext *avctx, int type,
3927 enum CodecID *audio_id, enum CodecID *video_id)
3930 char filename[1000], tmp[1000], tmp2[1000], line[1000];
3932 AVCodec *codec = avcodec_find_encoder(avctx->codec_id);
3934 if (!(f = get_preset_file(filename, sizeof(filename), arg, 0,
3935 codec ? codec->name : NULL))) {
3936 fprintf(stderr, "File for preset '%s' not found\n", arg);
3941 int e= fscanf(f, "%999[^\n]\n", line) - 1;
3942 if(line[0] == '#' && !e)
3944 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
3946 fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
3950 if(!strcmp(tmp, "acodec")){
3951 *audio_id = opt_audio_codec(tmp2);
3952 }else if(!strcmp(tmp, "vcodec")){
3953 *video_id = opt_video_codec(tmp2);
3954 }else if(!strcmp(tmp, "scodec")){
3955 /* opt_subtitle_codec(tmp2); */
3956 }else if(avserver_opt_default(tmp, tmp2, avctx, type) < 0){
3957 fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
3968 static AVOutputFormat *avserver_guess_format(const char *short_name, const char *filename,
3969 const char *mime_type)
3971 AVOutputFormat *fmt = av_guess_format(short_name, filename, mime_type);
3974 AVOutputFormat *stream_fmt;
3975 char stream_format_name[64];
3977 snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
3978 stream_fmt = av_guess_format(stream_format_name, NULL, NULL);
3987 static void report_config_error(const char *filename, int line_num, int *errors, const char *fmt, ...)
3991 fprintf(stderr, "%s:%d: ", filename, line_num);
3992 vfprintf(stderr, fmt, vl);
3998 static int parse_ffconfig(const char *filename)
4005 int val, errors, line_num;
4006 FFStream **last_stream, *stream, *redirect;
4007 FFStream **last_feed, *feed, *s;
4008 AVCodecContext audio_enc, video_enc;
4009 enum CodecID audio_id, video_id;
4011 f = fopen(filename, "r");
4019 first_stream = NULL;
4020 last_stream = &first_stream;
4022 last_feed = &first_feed;
4026 audio_id = CODEC_ID_NONE;
4027 video_id = CODEC_ID_NONE;
4029 #define ERROR(...) report_config_error(filename, line_num, &errors, __VA_ARGS__)
4031 if (fgets(line, sizeof(line), f) == NULL)
4037 if (*p == '\0' || *p == '#')
4040 get_arg(cmd, sizeof(cmd), &p);
4042 if (!av_strcasecmp(cmd, "Port")) {
4043 get_arg(arg, sizeof(arg), &p);
4045 if (val < 1 || val > 65536) {
4046 ERROR("Invalid_port: %s\n", arg);
4048 my_http_addr.sin_port = htons(val);
4049 } else if (!av_strcasecmp(cmd, "BindAddress")) {
4050 get_arg(arg, sizeof(arg), &p);
4051 if (resolve_host(&my_http_addr.sin_addr, arg) != 0) {
4052 ERROR("%s:%d: Invalid host/IP address: %s\n", arg);
4054 } else if (!av_strcasecmp(cmd, "NoDaemon")) {
4055 avserver_daemon = 0;
4056 } else if (!av_strcasecmp(cmd, "RTSPPort")) {
4057 get_arg(arg, sizeof(arg), &p);
4059 if (val < 1 || val > 65536) {
4060 ERROR("%s:%d: Invalid port: %s\n", arg);
4062 my_rtsp_addr.sin_port = htons(atoi(arg));
4063 } else if (!av_strcasecmp(cmd, "RTSPBindAddress")) {
4064 get_arg(arg, sizeof(arg), &p);
4065 if (resolve_host(&my_rtsp_addr.sin_addr, arg) != 0) {
4066 ERROR("Invalid host/IP address: %s\n", arg);
4068 } else if (!av_strcasecmp(cmd, "MaxHTTPConnections")) {
4069 get_arg(arg, sizeof(arg), &p);
4071 if (val < 1 || val > 65536) {
4072 ERROR("Invalid MaxHTTPConnections: %s\n", arg);
4074 nb_max_http_connections = val;
4075 } else if (!av_strcasecmp(cmd, "MaxClients")) {
4076 get_arg(arg, sizeof(arg), &p);
4078 if (val < 1 || val > nb_max_http_connections) {
4079 ERROR("Invalid MaxClients: %s\n", arg);
4081 nb_max_connections = val;
4083 } else if (!av_strcasecmp(cmd, "MaxBandwidth")) {
4085 get_arg(arg, sizeof(arg), &p);
4087 if (llval < 10 || llval > 10000000) {
4088 ERROR("Invalid MaxBandwidth: %s\n", arg);
4090 max_bandwidth = llval;
4091 } else if (!av_strcasecmp(cmd, "CustomLog")) {
4092 if (!avserver_debug)
4093 get_arg(logfilename, sizeof(logfilename), &p);
4094 } else if (!av_strcasecmp(cmd, "<Feed")) {
4095 /*********************************************/
4096 /* Feed related options */
4098 if (stream || feed) {
4099 ERROR("Already in a tag\n");
4101 feed = av_mallocz(sizeof(FFStream));
4102 get_arg(feed->filename, sizeof(feed->filename), &p);
4103 q = strrchr(feed->filename, '>');
4107 for (s = first_feed; s; s = s->next) {
4108 if (!strcmp(feed->filename, s->filename)) {
4109 ERROR("Feed '%s' already registered\n", s->filename);
4113 feed->fmt = av_guess_format("ffm", NULL, NULL);
4114 /* defaut feed file */
4115 snprintf(feed->feed_filename, sizeof(feed->feed_filename),
4116 "/tmp/%s.ffm", feed->filename);
4117 feed->feed_max_size = 5 * 1024 * 1024;
4119 feed->feed = feed; /* self feeding :-) */
4121 /* add in stream list */
4122 *last_stream = feed;
4123 last_stream = &feed->next;
4124 /* add in feed list */
4126 last_feed = &feed->next_feed;
4128 } else if (!av_strcasecmp(cmd, "Launch")) {
4132 feed->child_argv = av_mallocz(64 * sizeof(char *));
4134 for (i = 0; i < 62; i++) {
4135 get_arg(arg, sizeof(arg), &p);
4139 feed->child_argv[i] = av_strdup(arg);
4142 feed->child_argv[i] = av_malloc(30 + strlen(feed->filename));
4144 snprintf(feed->child_argv[i], 30+strlen(feed->filename),
4146 (my_http_addr.sin_addr.s_addr == INADDR_ANY) ? "127.0.0.1" :
4147 inet_ntoa(my_http_addr.sin_addr),
4148 ntohs(my_http_addr.sin_port), feed->filename);
4150 } else if (!av_strcasecmp(cmd, "ReadOnlyFile")) {
4152 get_arg(feed->feed_filename, sizeof(feed->feed_filename), &p);
4154 } else if (stream) {
4155 get_arg(stream->feed_filename, sizeof(stream->feed_filename), &p);
4157 } else if (!av_strcasecmp(cmd, "File")) {
4159 get_arg(feed->feed_filename, sizeof(feed->feed_filename), &p);
4161 get_arg(stream->feed_filename, sizeof(stream->feed_filename), &p);
4162 } else if (!av_strcasecmp(cmd, "Truncate")) {
4164 get_arg(arg, sizeof(arg), &p);
4165 feed->truncate = strtod(arg, NULL);
4167 } else if (!av_strcasecmp(cmd, "FileMaxSize")) {
4172 get_arg(arg, sizeof(arg), &p);
4174 fsize = strtod(p1, &p1);
4175 switch(toupper(*p1)) {
4180 fsize *= 1024 * 1024;
4183 fsize *= 1024 * 1024 * 1024;
4186 feed->feed_max_size = (int64_t)fsize;
4187 if (feed->feed_max_size < FFM_PACKET_SIZE*4) {
4188 ERROR("Feed max file size is too small, must be at least %d\n", FFM_PACKET_SIZE*4);
4191 } else if (!av_strcasecmp(cmd, "</Feed>")) {
4193 ERROR("No corresponding <Feed> for </Feed>\n");
4196 } else if (!av_strcasecmp(cmd, "<Stream")) {
4197 /*********************************************/
4198 /* Stream related options */
4200 if (stream || feed) {
4201 ERROR("Already in a tag\n");
4204 stream = av_mallocz(sizeof(FFStream));
4205 get_arg(stream->filename, sizeof(stream->filename), &p);
4206 q = strrchr(stream->filename, '>');
4210 for (s = first_stream; s; s = s->next) {
4211 if (!strcmp(stream->filename, s->filename)) {
4212 ERROR("Stream '%s' already registered\n", s->filename);
4216 stream->fmt = avserver_guess_format(NULL, stream->filename, NULL);
4217 avcodec_get_context_defaults3(&video_enc, NULL);
4218 avcodec_get_context_defaults3(&audio_enc, NULL);
4219 audio_id = CODEC_ID_NONE;
4220 video_id = CODEC_ID_NONE;
4222 audio_id = stream->fmt->audio_codec;
4223 video_id = stream->fmt->video_codec;
4226 *last_stream = stream;
4227 last_stream = &stream->next;
4229 } else if (!av_strcasecmp(cmd, "Feed")) {
4230 get_arg(arg, sizeof(arg), &p);
4235 while (sfeed != NULL) {
4236 if (!strcmp(sfeed->filename, arg))
4238 sfeed = sfeed->next_feed;
4241 ERROR("feed '%s' not defined\n", arg);
4243 stream->feed = sfeed;
4245 } else if (!av_strcasecmp(cmd, "Format")) {
4246 get_arg(arg, sizeof(arg), &p);
4248 if (!strcmp(arg, "status")) {
4249 stream->stream_type = STREAM_TYPE_STATUS;
4252 stream->stream_type = STREAM_TYPE_LIVE;
4253 /* jpeg cannot be used here, so use single frame jpeg */
4254 if (!strcmp(arg, "jpeg"))
4255 strcpy(arg, "mjpeg");
4256 stream->fmt = avserver_guess_format(arg, NULL, NULL);
4258 ERROR("Unknown Format: %s\n", arg);
4262 audio_id = stream->fmt->audio_codec;
4263 video_id = stream->fmt->video_codec;
4266 } else if (!av_strcasecmp(cmd, "InputFormat")) {
4267 get_arg(arg, sizeof(arg), &p);
4269 stream->ifmt = av_find_input_format(arg);
4270 if (!stream->ifmt) {
4271 ERROR("Unknown input format: %s\n", arg);
4274 } else if (!av_strcasecmp(cmd, "FaviconURL")) {
4275 if (stream && stream->stream_type == STREAM_TYPE_STATUS) {
4276 get_arg(stream->feed_filename, sizeof(stream->feed_filename), &p);
4278 ERROR("FaviconURL only permitted for status streams\n");
4280 } else if (!av_strcasecmp(cmd, "Author")) {
4282 get_arg(stream->author, sizeof(stream->author), &p);
4283 } else if (!av_strcasecmp(cmd, "Comment")) {
4285 get_arg(stream->comment, sizeof(stream->comment), &p);
4286 } else if (!av_strcasecmp(cmd, "Copyright")) {
4288 get_arg(stream->copyright, sizeof(stream->copyright), &p);
4289 } else if (!av_strcasecmp(cmd, "Title")) {
4291 get_arg(stream->title, sizeof(stream->title), &p);
4292 } else if (!av_strcasecmp(cmd, "Preroll")) {
4293 get_arg(arg, sizeof(arg), &p);
4295 stream->prebuffer = atof(arg) * 1000;
4296 } else if (!av_strcasecmp(cmd, "StartSendOnKey")) {
4298 stream->send_on_key = 1;
4299 } else if (!av_strcasecmp(cmd, "AudioCodec")) {
4300 get_arg(arg, sizeof(arg), &p);
4301 audio_id = opt_audio_codec(arg);
4302 if (audio_id == CODEC_ID_NONE) {
4303 ERROR("Unknown AudioCodec: %s\n", arg);
4305 } else if (!av_strcasecmp(cmd, "VideoCodec")) {
4306 get_arg(arg, sizeof(arg), &p);
4307 video_id = opt_video_codec(arg);
4308 if (video_id == CODEC_ID_NONE) {
4309 ERROR("Unknown VideoCodec: %s\n", arg);
4311 } else if (!av_strcasecmp(cmd, "MaxTime")) {
4312 get_arg(arg, sizeof(arg), &p);
4314 stream->max_time = atof(arg) * 1000;
4315 } else if (!av_strcasecmp(cmd, "AudioBitRate")) {
4316 get_arg(arg, sizeof(arg), &p);
4318 audio_enc.bit_rate = lrintf(atof(arg) * 1000);
4319 } else if (!av_strcasecmp(cmd, "AudioChannels")) {
4320 get_arg(arg, sizeof(arg), &p);
4322 audio_enc.channels = atoi(arg);
4323 } else if (!av_strcasecmp(cmd, "AudioSampleRate")) {
4324 get_arg(arg, sizeof(arg), &p);
4326 audio_enc.sample_rate = atoi(arg);
4327 } else if (!av_strcasecmp(cmd, "AudioQuality")) {
4328 get_arg(arg, sizeof(arg), &p);
4330 // audio_enc.quality = atof(arg) * 1000;
4332 } else if (!av_strcasecmp(cmd, "VideoBitRateRange")) {
4334 int minrate, maxrate;
4336 get_arg(arg, sizeof(arg), &p);
4338 if (sscanf(arg, "%d-%d", &minrate, &maxrate) == 2) {
4339 video_enc.rc_min_rate = minrate * 1000;
4340 video_enc.rc_max_rate = maxrate * 1000;
4342 ERROR("Incorrect format for VideoBitRateRange -- should be <min>-<max>: %s\n", arg);
4345 } else if (!av_strcasecmp(cmd, "Debug")) {
4347 get_arg(arg, sizeof(arg), &p);
4348 video_enc.debug = strtol(arg,0,0);
4350 } else if (!av_strcasecmp(cmd, "Strict")) {
4352 get_arg(arg, sizeof(arg), &p);
4353 video_enc.strict_std_compliance = atoi(arg);
4355 } else if (!av_strcasecmp(cmd, "VideoBufferSize")) {
4357 get_arg(arg, sizeof(arg), &p);
4358 video_enc.rc_buffer_size = atoi(arg) * 8*1024;
4360 } else if (!av_strcasecmp(cmd, "VideoBitRateTolerance")) {
4362 get_arg(arg, sizeof(arg), &p);
4363 video_enc.bit_rate_tolerance = atoi(arg) * 1000;
4365 } else if (!av_strcasecmp(cmd, "VideoBitRate")) {
4366 get_arg(arg, sizeof(arg), &p);
4368 video_enc.bit_rate = atoi(arg) * 1000;
4370 } else if (!av_strcasecmp(cmd, "VideoSize")) {
4371 get_arg(arg, sizeof(arg), &p);
4373 av_parse_video_size(&video_enc.width, &video_enc.height, arg);
4374 if ((video_enc.width % 16) != 0 ||
4375 (video_enc.height % 16) != 0) {
4376 ERROR("Image size must be a multiple of 16\n");
4379 } else if (!av_strcasecmp(cmd, "VideoFrameRate")) {
4380 get_arg(arg, sizeof(arg), &p);
4382 AVRational frame_rate;
4383 if (av_parse_video_rate(&frame_rate, arg) < 0) {
4384 ERROR("Incorrect frame rate: %s\n", arg);
4386 video_enc.time_base.num = frame_rate.den;
4387 video_enc.time_base.den = frame_rate.num;
4390 } else if (!av_strcasecmp(cmd, "VideoGopSize")) {
4391 get_arg(arg, sizeof(arg), &p);
4393 video_enc.gop_size = atoi(arg);
4394 } else if (!av_strcasecmp(cmd, "VideoIntraOnly")) {
4396 video_enc.gop_size = 1;
4397 } else if (!av_strcasecmp(cmd, "VideoHighQuality")) {
4399 video_enc.mb_decision = FF_MB_DECISION_BITS;
4400 } else if (!av_strcasecmp(cmd, "Video4MotionVector")) {
4402 video_enc.mb_decision = FF_MB_DECISION_BITS; //FIXME remove
4403 video_enc.flags |= CODEC_FLAG_4MV;
4405 } else if (!av_strcasecmp(cmd, "AVOptionVideo") ||
4406 !av_strcasecmp(cmd, "AVOptionAudio")) {
4408 AVCodecContext *avctx;
4410 get_arg(arg, sizeof(arg), &p);
4411 get_arg(arg2, sizeof(arg2), &p);
4412 if (!av_strcasecmp(cmd, "AVOptionVideo")) {
4414 type = AV_OPT_FLAG_VIDEO_PARAM;
4417 type = AV_OPT_FLAG_AUDIO_PARAM;
4419 if (avserver_opt_default(arg, arg2, avctx, type|AV_OPT_FLAG_ENCODING_PARAM)) {
4420 ERROR("AVOption error: %s %s\n", arg, arg2);
4422 } else if (!av_strcasecmp(cmd, "AVPresetVideo") ||
4423 !av_strcasecmp(cmd, "AVPresetAudio")) {
4424 AVCodecContext *avctx;
4426 get_arg(arg, sizeof(arg), &p);
4427 if (!av_strcasecmp(cmd, "AVPresetVideo")) {
4429 video_enc.codec_id = video_id;
4430 type = AV_OPT_FLAG_VIDEO_PARAM;
4433 audio_enc.codec_id = audio_id;
4434 type = AV_OPT_FLAG_AUDIO_PARAM;
4436 if (avserver_opt_preset(arg, avctx, type|AV_OPT_FLAG_ENCODING_PARAM, &audio_id, &video_id)) {
4437 ERROR("AVPreset error: %s\n", arg);
4439 } else if (!av_strcasecmp(cmd, "VideoTag")) {
4440 get_arg(arg, sizeof(arg), &p);
4441 if ((strlen(arg) == 4) && stream)
4442 video_enc.codec_tag = MKTAG(arg[0], arg[1], arg[2], arg[3]);
4443 } else if (!av_strcasecmp(cmd, "BitExact")) {
4445 video_enc.flags |= CODEC_FLAG_BITEXACT;
4446 } else if (!av_strcasecmp(cmd, "DctFastint")) {
4448 video_enc.dct_algo = FF_DCT_FASTINT;
4449 } else if (!av_strcasecmp(cmd, "IdctSimple")) {
4451 video_enc.idct_algo = FF_IDCT_SIMPLE;
4452 } else if (!av_strcasecmp(cmd, "Qscale")) {
4453 get_arg(arg, sizeof(arg), &p);
4455 video_enc.flags |= CODEC_FLAG_QSCALE;
4456 video_enc.global_quality = FF_QP2LAMBDA * atoi(arg);
4458 } else if (!av_strcasecmp(cmd, "VideoQDiff")) {
4459 get_arg(arg, sizeof(arg), &p);
4461 video_enc.max_qdiff = atoi(arg);
4462 if (video_enc.max_qdiff < 1 || video_enc.max_qdiff > 31) {
4463 ERROR("VideoQDiff out of range\n");
4466 } else if (!av_strcasecmp(cmd, "VideoQMax")) {
4467 get_arg(arg, sizeof(arg), &p);
4469 video_enc.qmax = atoi(arg);
4470 if (video_enc.qmax < 1 || video_enc.qmax > 31) {
4471 ERROR("VideoQMax out of range\n");
4474 } else if (!av_strcasecmp(cmd, "VideoQMin")) {
4475 get_arg(arg, sizeof(arg), &p);
4477 video_enc.qmin = atoi(arg);
4478 if (video_enc.qmin < 1 || video_enc.qmin > 31) {
4479 ERROR("VideoQMin out of range\n");
4482 } else if (!av_strcasecmp(cmd, "LumaElim")) {
4483 get_arg(arg, sizeof(arg), &p);
4485 video_enc.luma_elim_threshold = atoi(arg);
4486 } else if (!av_strcasecmp(cmd, "ChromaElim")) {
4487 get_arg(arg, sizeof(arg), &p);
4489 video_enc.chroma_elim_threshold = atoi(arg);
4490 } else if (!av_strcasecmp(cmd, "LumiMask")) {
4491 get_arg(arg, sizeof(arg), &p);
4493 video_enc.lumi_masking = atof(arg);
4494 } else if (!av_strcasecmp(cmd, "DarkMask")) {
4495 get_arg(arg, sizeof(arg), &p);
4497 video_enc.dark_masking = atof(arg);
4498 } else if (!av_strcasecmp(cmd, "NoVideo")) {
4499 video_id = CODEC_ID_NONE;
4500 } else if (!av_strcasecmp(cmd, "NoAudio")) {
4501 audio_id = CODEC_ID_NONE;
4502 } else if (!av_strcasecmp(cmd, "ACL")) {
4503 parse_acl_row(stream, feed, NULL, p, filename, line_num);
4504 } else if (!av_strcasecmp(cmd, "DynamicACL")) {
4506 get_arg(stream->dynamic_acl, sizeof(stream->dynamic_acl), &p);
4508 } else if (!av_strcasecmp(cmd, "RTSPOption")) {
4509 get_arg(arg, sizeof(arg), &p);
4511 av_freep(&stream->rtsp_option);
4512 stream->rtsp_option = av_strdup(arg);
4514 } else if (!av_strcasecmp(cmd, "MulticastAddress")) {
4515 get_arg(arg, sizeof(arg), &p);
4517 if (resolve_host(&stream->multicast_ip, arg) != 0) {
4518 ERROR("Invalid host/IP address: %s\n", arg);
4520 stream->is_multicast = 1;
4521 stream->loop = 1; /* default is looping */
4523 } else if (!av_strcasecmp(cmd, "MulticastPort")) {
4524 get_arg(arg, sizeof(arg), &p);
4526 stream->multicast_port = atoi(arg);
4527 } else if (!av_strcasecmp(cmd, "MulticastTTL")) {
4528 get_arg(arg, sizeof(arg), &p);
4530 stream->multicast_ttl = atoi(arg);
4531 } else if (!av_strcasecmp(cmd, "NoLoop")) {
4534 } else if (!av_strcasecmp(cmd, "</Stream>")) {
4536 ERROR("No corresponding <Stream> for </Stream>\n");
4538 if (stream->feed && stream->fmt && strcmp(stream->fmt->name, "ffm") != 0) {
4539 if (audio_id != CODEC_ID_NONE) {
4540 audio_enc.codec_type = AVMEDIA_TYPE_AUDIO;
4541 audio_enc.codec_id = audio_id;
4542 add_codec(stream, &audio_enc);
4544 if (video_id != CODEC_ID_NONE) {
4545 video_enc.codec_type = AVMEDIA_TYPE_VIDEO;
4546 video_enc.codec_id = video_id;
4547 add_codec(stream, &video_enc);
4552 } else if (!av_strcasecmp(cmd, "<Redirect")) {
4553 /*********************************************/
4555 if (stream || feed || redirect) {
4556 ERROR("Already in a tag\n");
4558 redirect = av_mallocz(sizeof(FFStream));
4559 *last_stream = redirect;
4560 last_stream = &redirect->next;
4562 get_arg(redirect->filename, sizeof(redirect->filename), &p);
4563 q = strrchr(redirect->filename, '>');
4566 redirect->stream_type = STREAM_TYPE_REDIRECT;
4568 } else if (!av_strcasecmp(cmd, "URL")) {
4570 get_arg(redirect->feed_filename, sizeof(redirect->feed_filename), &p);
4571 } else if (!av_strcasecmp(cmd, "</Redirect>")) {
4573 ERROR("No corresponding <Redirect> for </Redirect>\n");
4575 if (!redirect->feed_filename[0]) {
4576 ERROR("No URL found for <Redirect>\n");
4580 } else if (!av_strcasecmp(cmd, "LoadModule")) {
4581 get_arg(arg, sizeof(arg), &p);
4585 ERROR("Module support not compiled into this version: '%s'\n", arg);
4588 ERROR("Incorrect keyword: '%s'\n", cmd);
4600 static void handle_child_exit(int sig)
4605 while ((pid = waitpid(-1, &status, WNOHANG)) > 0) {
4608 for (feed = first_feed; feed; feed = feed->next) {
4609 if (feed->pid == pid) {
4610 int uptime = time(0) - feed->pid_start;
4613 fprintf(stderr, "%s: Pid %d exited with status %d after %d seconds\n", feed->filename, pid, status, uptime);
4616 /* Turn off any more restarts */
4617 feed->child_argv = 0;
4622 need_to_start_children = 1;
4625 static void opt_debug(void)
4628 avserver_daemon = 0;
4629 logfilename[0] = '-';
4632 static void show_help(void)
4634 printf("usage: avserver [options]\n"
4635 "Hyper fast multi format Audio/Video streaming server\n");
4637 show_help_options(options, "Main options:\n", 0, 0);
4640 static const OptionDef options[] = {
4641 #include "cmdutils_common_opts.h"
4642 { "n", OPT_BOOL, {(void *)&no_launch }, "enable no-launch mode" },
4643 { "d", 0, {(void*)opt_debug}, "enable debug mode" },
4644 { "f", HAS_ARG | OPT_STRING, {(void*)&config_filename }, "use configfile instead of /etc/avserver.conf", "configfile" },
4648 int main(int argc, char **argv)
4650 struct sigaction sigact;
4652 parse_loglevel(argc, argv, options);
4654 avformat_network_init();
4658 my_program_name = argv[0];
4659 my_program_dir = getcwd(0, 0);
4660 avserver_daemon = 1;
4662 parse_options(NULL, argc, argv, options, NULL);
4664 unsetenv("http_proxy"); /* Kill the http_proxy */
4666 av_lfg_init(&random_state, av_get_random_seed());
4668 memset(&sigact, 0, sizeof(sigact));
4669 sigact.sa_handler = handle_child_exit;
4670 sigact.sa_flags = SA_NOCLDSTOP | SA_RESTART;
4671 sigaction(SIGCHLD, &sigact, 0);
4673 if (parse_ffconfig(config_filename) < 0) {
4674 fprintf(stderr, "Incorrect config file - exiting.\n");
4678 /* open log file if needed */
4679 if (logfilename[0] != '\0') {
4680 if (!strcmp(logfilename, "-"))
4683 logfile = fopen(logfilename, "a");
4684 av_log_set_callback(http_av_log);
4687 build_file_streams();
4689 build_feed_streams();
4691 compute_bandwidth();
4693 /* put the process in background and detach it from its TTY */
4694 if (avserver_daemon) {
4701 } else if (pid > 0) {
4708 open("/dev/null", O_RDWR);
4709 if (strcmp(logfilename, "-") != 0) {
4719 signal(SIGPIPE, SIG_IGN);
4721 if (avserver_daemon)
4724 if (http_server() < 0) {
4725 http_log("Could not start server\n");