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 #include "libavformat/ffm.h"
30 #include "libavformat/network.h"
31 #include "libavformat/os_support.h"
32 #include "libavformat/rtpdec.h"
33 #include "libavformat/rtsp.h"
34 // XXX for ffio_open_dyn_packet_buffer, to be removed
35 #include "libavformat/avio_internal.h"
36 #include "libavutil/avstring.h"
37 #include "libavutil/lfg.h"
38 #include "libavutil/dict.h"
39 #include "libavutil/mathematics.h"
40 #include "libavutil/random_seed.h"
41 #include "libavutil/parseutils.h"
42 #include "libavutil/opt.h"
46 #include <sys/ioctl.h>
61 const char program_name[] = "avserver";
62 const int program_birth_year = 2000;
64 static const OptionDef options[];
67 HTTPSTATE_WAIT_REQUEST,
68 HTTPSTATE_SEND_HEADER,
69 HTTPSTATE_SEND_DATA_HEADER,
70 HTTPSTATE_SEND_DATA, /* sending TCP or UDP data */
71 HTTPSTATE_SEND_DATA_TRAILER,
72 HTTPSTATE_RECEIVE_DATA,
73 HTTPSTATE_WAIT_FEED, /* wait for data from the feed */
76 RTSPSTATE_WAIT_REQUEST,
78 RTSPSTATE_SEND_PACKET,
81 static const char *http_state[] = {
97 #define MAX_STREAMS 20
99 #define IOBUFFER_INIT_SIZE 8192
101 /* timeouts are in ms */
102 #define HTTP_REQUEST_TIMEOUT (15 * 1000)
103 #define RTSP_REQUEST_TIMEOUT (3600 * 24 * 1000)
105 #define SYNC_TIMEOUT (10 * 1000)
107 typedef struct RTSPActionServerSetup {
109 char transport_option[512];
110 } RTSPActionServerSetup;
113 int64_t count1, count2;
114 int64_t time1, time2;
117 /* context associated with one connection */
118 typedef struct HTTPContext {
119 enum HTTPState state;
120 int fd; /* socket file descriptor */
121 struct sockaddr_in from_addr; /* origin */
122 struct pollfd *poll_entry; /* used when polling */
124 uint8_t *buffer_ptr, *buffer_end;
127 int chunked_encoding;
128 int chunk_size; /* 0 if it needs to be read */
129 struct HTTPContext *next;
130 int got_key_frame; /* stream 0 => 1, stream 1 => 2, stream 2=> 4 */
134 /* input format handling */
135 AVFormatContext *fmt_in;
136 int64_t start_time; /* In milliseconds - this wraps fairly often */
137 int64_t first_pts; /* initial pts value */
138 int64_t cur_pts; /* current pts value from the stream in us */
139 int64_t cur_frame_duration; /* duration of the current frame in us */
140 int cur_frame_bytes; /* output frame size, needed to compute
141 the time at which we send each
143 int pts_stream_index; /* stream we choose as clock reference */
144 int64_t cur_clock; /* current clock reference value in us */
145 /* output format handling */
146 struct FFStream *stream;
147 /* -1 is invalid stream */
148 int feed_streams[MAX_STREAMS]; /* index of streams in the feed */
149 int switch_feed_streams[MAX_STREAMS]; /* index of streams in the feed */
151 AVFormatContext fmt_ctx; /* instance of FFStream for one user */
152 int last_packet_sent; /* true if last data packet was sent */
154 DataRateData datarate;
161 int is_packetized; /* if true, the stream is packetized */
162 int packet_stream_index; /* current stream for output in state machine */
164 /* RTSP state specific */
165 uint8_t *pb_buffer; /* XXX: use that in all the code */
167 int seq; /* RTSP sequence number */
169 /* RTP state specific */
170 enum RTSPLowerTransport rtp_protocol;
171 char session_id[32]; /* session id */
172 AVFormatContext *rtp_ctx[MAX_STREAMS];
174 /* RTP/UDP specific */
175 URLContext *rtp_handles[MAX_STREAMS];
177 /* RTP/TCP specific */
178 struct HTTPContext *rtsp_c;
179 uint8_t *packet_buffer, *packet_buffer_ptr, *packet_buffer_end;
182 /* each generated stream is described here */
186 STREAM_TYPE_REDIRECT,
189 enum IPAddressAction {
194 typedef struct IPAddressACL {
195 struct IPAddressACL *next;
196 enum IPAddressAction action;
197 /* These are in host order */
198 struct in_addr first;
202 /* description of each stream of the avserver.conf file */
203 typedef struct FFStream {
204 enum StreamType stream_type;
205 char filename[1024]; /* stream filename */
206 struct FFStream *feed; /* feed we are using (can be null if
208 AVDictionary *in_opts; /* input parameters */
209 AVInputFormat *ifmt; /* if non NULL, force input format */
212 char dynamic_acl[1024];
214 int prebuffer; /* Number of millseconds early to start */
215 int64_t max_time; /* Number of milliseconds to run */
217 AVStream *streams[MAX_STREAMS];
218 int feed_streams[MAX_STREAMS]; /* index of streams in the feed */
219 char feed_filename[1024]; /* file name of the feed storage, or
220 input file name for a stream */
225 pid_t pid; /* of avconv process */
226 time_t pid_start; /* of avconv process */
228 struct FFStream *next;
229 unsigned bandwidth; /* bandwidth, in kbits/s */
232 /* multicast specific */
234 struct in_addr multicast_ip;
235 int multicast_port; /* first port used for multicast */
237 int loop; /* if true, send the stream in loops (only meaningful if file) */
240 int feed_opened; /* true if someone is writing to the feed */
241 int is_feed; /* true if it is a feed */
242 int readonly; /* True if writing is prohibited to the file */
243 int truncate; /* True if feeder connection truncate the feed file */
245 int64_t bytes_served;
246 int64_t feed_max_size; /* maximum storage size, zero means unlimited */
247 int64_t feed_write_index; /* current write position in feed (it wraps around) */
248 int64_t feed_size; /* current size of feed */
249 struct FFStream *next_feed;
252 typedef struct FeedData {
253 long long data_count;
254 float avg_frame_size; /* frame size averaged over last frames with exponential mean */
257 static struct sockaddr_in my_http_addr;
258 static struct sockaddr_in my_rtsp_addr;
260 static char logfilename[1024];
261 static HTTPContext *first_http_ctx;
262 static FFStream *first_feed; /* contains only feeds */
263 static FFStream *first_stream; /* contains all streams, including feeds */
265 static void new_connection(int server_fd, int is_rtsp);
266 static void close_connection(HTTPContext *c);
269 static int handle_connection(HTTPContext *c);
270 static int http_parse_request(HTTPContext *c);
271 static int http_send_data(HTTPContext *c);
272 static void compute_status(HTTPContext *c);
273 static int open_input_stream(HTTPContext *c, const char *info);
274 static int http_start_receive_data(HTTPContext *c);
275 static int http_receive_data(HTTPContext *c);
278 static int rtsp_parse_request(HTTPContext *c);
279 static void rtsp_cmd_describe(HTTPContext *c, const char *url);
280 static void rtsp_cmd_options(HTTPContext *c, const char *url);
281 static void rtsp_cmd_setup(HTTPContext *c, const char *url, RTSPMessageHeader *h);
282 static void rtsp_cmd_play(HTTPContext *c, const char *url, RTSPMessageHeader *h);
283 static void rtsp_cmd_pause(HTTPContext *c, const char *url, RTSPMessageHeader *h);
284 static void rtsp_cmd_teardown(HTTPContext *c, const char *url, RTSPMessageHeader *h);
287 static int prepare_sdp_description(FFStream *stream, uint8_t **pbuffer,
288 struct in_addr my_ip);
291 static HTTPContext *rtp_new_connection(struct sockaddr_in *from_addr,
292 FFStream *stream, const char *session_id,
293 enum RTSPLowerTransport rtp_protocol);
294 static int rtp_new_av_stream(HTTPContext *c,
295 int stream_index, struct sockaddr_in *dest_addr,
296 HTTPContext *rtsp_c);
298 static const char *my_program_name;
299 static const char *my_program_dir;
301 static const char *config_filename = "/etc/avserver.conf";
303 static int avserver_debug;
304 static int avserver_daemon;
305 static int no_launch;
306 static int need_to_start_children;
308 /* maximum number of simultaneous HTTP connections */
309 static unsigned int nb_max_http_connections = 2000;
310 static unsigned int nb_max_connections = 5;
311 static unsigned int nb_connections;
313 static uint64_t max_bandwidth = 1000;
314 static uint64_t current_bandwidth;
316 static int64_t cur_time; // Making this global saves on passing it around everywhere
318 static AVLFG random_state;
320 static FILE *logfile = NULL;
322 void exit_program(int ret)
327 /* FIXME: make avserver work with IPv6 */
328 /* resolve host with also IP address parsing */
329 static int resolve_host(struct in_addr *sin_addr, const char *hostname)
332 if (!ff_inet_aton(hostname, sin_addr)) {
334 struct addrinfo *ai, *cur;
335 struct addrinfo hints;
336 memset(&hints, 0, sizeof(hints));
337 hints.ai_family = AF_INET;
338 if (getaddrinfo(hostname, NULL, &hints, &ai))
340 /* getaddrinfo returns a linked list of addrinfo structs.
341 * Even if we set ai_family = AF_INET above, make sure
342 * that the returned one actually is of the correct type. */
343 for (cur = ai; cur; cur = cur->ai_next) {
344 if (cur->ai_family == AF_INET) {
345 *sin_addr = ((struct sockaddr_in *)cur->ai_addr)->sin_addr;
354 hp = gethostbyname(hostname);
357 memcpy(sin_addr, hp->h_addr_list[0], sizeof(struct in_addr));
363 static char *ctime1(char *buf2)
371 p = buf2 + strlen(p) - 1;
377 static void http_vlog(const char *fmt, va_list vargs)
379 static int print_prefix = 1;
384 fprintf(logfile, "%s ", buf);
386 print_prefix = strstr(fmt, "\n") != NULL;
387 vfprintf(logfile, fmt, vargs);
393 __attribute__ ((format (printf, 1, 2)))
395 static void http_log(const char *fmt, ...)
398 va_start(vargs, fmt);
399 http_vlog(fmt, vargs);
403 static void http_av_log(void *ptr, int level, const char *fmt, va_list vargs)
405 static int print_prefix = 1;
406 AVClass *avc = ptr ? *(AVClass**)ptr : NULL;
407 if (level > av_log_get_level())
409 if (print_prefix && avc)
410 http_log("[%s @ %p]", avc->item_name(ptr), ptr);
411 print_prefix = strstr(fmt, "\n") != NULL;
412 http_vlog(fmt, vargs);
415 static void log_connection(HTTPContext *c)
420 http_log("%s - - [%s] \"%s %s\" %d %"PRId64"\n",
421 inet_ntoa(c->from_addr.sin_addr), c->method, c->url,
422 c->protocol, (c->http_error ? c->http_error : 200), c->data_count);
425 static void update_datarate(DataRateData *drd, int64_t count)
427 if (!drd->time1 && !drd->count1) {
428 drd->time1 = drd->time2 = cur_time;
429 drd->count1 = drd->count2 = count;
430 } else if (cur_time - drd->time2 > 5000) {
431 drd->time1 = drd->time2;
432 drd->count1 = drd->count2;
433 drd->time2 = cur_time;
438 /* In bytes per second */
439 static int compute_datarate(DataRateData *drd, int64_t count)
441 if (cur_time == drd->time1)
444 return ((count - drd->count1) * 1000) / (cur_time - drd->time1);
448 static void start_children(FFStream *feed)
453 for (; feed; feed = feed->next) {
454 if (feed->child_argv && !feed->pid) {
455 feed->pid_start = time(0);
460 http_log("Unable to create children\n");
469 av_strlcpy(pathname, my_program_name, sizeof(pathname));
471 slash = strrchr(pathname, '/');
476 strcpy(slash, "avconv");
478 http_log("Launch command line: ");
479 http_log("%s ", pathname);
480 for (i = 1; feed->child_argv[i] && feed->child_argv[i][0]; i++)
481 http_log("%s ", feed->child_argv[i]);
484 for (i = 3; i < 256; i++)
487 if (!avserver_debug) {
488 i = open("/dev/null", O_RDWR);
497 /* This is needed to make relative pathnames work */
498 chdir(my_program_dir);
500 signal(SIGPIPE, SIG_DFL);
502 execvp(pathname, feed->child_argv);
510 /* open a listening socket */
511 static int socket_open_listen(struct sockaddr_in *my_addr)
515 server_fd = socket(AF_INET,SOCK_STREAM,0);
522 setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &tmp, sizeof(tmp));
524 my_addr->sin_family = AF_INET;
525 if (bind (server_fd, (struct sockaddr *) my_addr, sizeof (*my_addr)) < 0) {
527 snprintf(bindmsg, sizeof(bindmsg), "bind(port %d)", ntohs(my_addr->sin_port));
529 closesocket(server_fd);
533 if (listen (server_fd, 5) < 0) {
535 closesocket(server_fd);
538 ff_socket_nonblock(server_fd, 1);
543 /* start all multicast streams */
544 static void start_multicast(void)
549 struct sockaddr_in dest_addr;
550 int default_port, stream_index;
553 for(stream = first_stream; stream != NULL; stream = stream->next) {
554 if (stream->is_multicast) {
555 /* open the RTP connection */
556 snprintf(session_id, sizeof(session_id), "%08x%08x",
557 av_lfg_get(&random_state), av_lfg_get(&random_state));
559 /* choose a port if none given */
560 if (stream->multicast_port == 0) {
561 stream->multicast_port = default_port;
565 dest_addr.sin_family = AF_INET;
566 dest_addr.sin_addr = stream->multicast_ip;
567 dest_addr.sin_port = htons(stream->multicast_port);
569 rtp_c = rtp_new_connection(&dest_addr, stream, session_id,
570 RTSP_LOWER_TRANSPORT_UDP_MULTICAST);
574 if (open_input_stream(rtp_c, "") < 0) {
575 http_log("Could not open input stream for stream '%s'\n",
580 /* open each RTP stream */
581 for(stream_index = 0; stream_index < stream->nb_streams;
583 dest_addr.sin_port = htons(stream->multicast_port +
585 if (rtp_new_av_stream(rtp_c, stream_index, &dest_addr, NULL) < 0) {
586 http_log("Could not open output stream '%s/streamid=%d'\n",
587 stream->filename, stream_index);
592 /* change state to send data */
593 rtp_c->state = HTTPSTATE_SEND_DATA;
598 /* main loop of the http server */
599 static int http_server(void)
601 int server_fd = 0, rtsp_server_fd = 0;
602 int ret, delay, delay1;
603 struct pollfd *poll_table, *poll_entry;
604 HTTPContext *c, *c_next;
606 if(!(poll_table = av_mallocz((nb_max_http_connections + 2)*sizeof(*poll_table)))) {
607 http_log("Impossible to allocate a poll table handling %d connections.\n", nb_max_http_connections);
611 if (my_http_addr.sin_port) {
612 server_fd = socket_open_listen(&my_http_addr);
617 if (my_rtsp_addr.sin_port) {
618 rtsp_server_fd = socket_open_listen(&my_rtsp_addr);
619 if (rtsp_server_fd < 0)
623 if (!rtsp_server_fd && !server_fd) {
624 http_log("HTTP and RTSP disabled.\n");
628 http_log("AVserver started.\n");
630 start_children(first_feed);
635 poll_entry = poll_table;
637 poll_entry->fd = server_fd;
638 poll_entry->events = POLLIN;
641 if (rtsp_server_fd) {
642 poll_entry->fd = rtsp_server_fd;
643 poll_entry->events = POLLIN;
647 /* wait for events on each HTTP handle */
654 case HTTPSTATE_SEND_HEADER:
655 case RTSPSTATE_SEND_REPLY:
656 case RTSPSTATE_SEND_PACKET:
657 c->poll_entry = poll_entry;
659 poll_entry->events = POLLOUT;
662 case HTTPSTATE_SEND_DATA_HEADER:
663 case HTTPSTATE_SEND_DATA:
664 case HTTPSTATE_SEND_DATA_TRAILER:
665 if (!c->is_packetized) {
666 /* for TCP, we output as much as we can (may need to put a limit) */
667 c->poll_entry = poll_entry;
669 poll_entry->events = POLLOUT;
672 /* when avserver is doing the timing, we work by
673 looking at which packet need to be sent every
675 delay1 = 10; /* one tick wait XXX: 10 ms assumed */
680 case HTTPSTATE_WAIT_REQUEST:
681 case HTTPSTATE_RECEIVE_DATA:
682 case HTTPSTATE_WAIT_FEED:
683 case RTSPSTATE_WAIT_REQUEST:
684 /* need to catch errors */
685 c->poll_entry = poll_entry;
687 poll_entry->events = POLLIN;/* Maybe this will work */
691 c->poll_entry = NULL;
697 /* wait for an event on one connection. We poll at least every
698 second to handle timeouts */
700 ret = poll(poll_table, poll_entry - poll_table, delay);
701 if (ret < 0 && ff_neterrno() != AVERROR(EAGAIN) &&
702 ff_neterrno() != AVERROR(EINTR))
706 cur_time = av_gettime() / 1000;
708 if (need_to_start_children) {
709 need_to_start_children = 0;
710 start_children(first_feed);
713 /* now handle the events */
714 for(c = first_http_ctx; c != NULL; c = c_next) {
716 if (handle_connection(c) < 0) {
717 /* close and free the connection */
723 poll_entry = poll_table;
725 /* new HTTP connection request ? */
726 if (poll_entry->revents & POLLIN)
727 new_connection(server_fd, 0);
730 if (rtsp_server_fd) {
731 /* new RTSP connection request ? */
732 if (poll_entry->revents & POLLIN)
733 new_connection(rtsp_server_fd, 1);
738 /* start waiting for a new HTTP/RTSP request */
739 static void start_wait_request(HTTPContext *c, int is_rtsp)
741 c->buffer_ptr = c->buffer;
742 c->buffer_end = c->buffer + c->buffer_size - 1; /* leave room for '\0' */
745 c->timeout = cur_time + RTSP_REQUEST_TIMEOUT;
746 c->state = RTSPSTATE_WAIT_REQUEST;
748 c->timeout = cur_time + HTTP_REQUEST_TIMEOUT;
749 c->state = HTTPSTATE_WAIT_REQUEST;
753 static void http_send_too_busy_reply(int fd)
756 int len = snprintf(buffer, sizeof(buffer),
757 "HTTP/1.0 503 Server too busy\r\n"
758 "Content-type: text/html\r\n"
760 "<html><head><title>Too busy</title></head><body>\r\n"
761 "<p>The server is too busy to serve your request at this time.</p>\r\n"
762 "<p>The number of current connections is %d, and this exceeds the limit of %d.</p>\r\n"
763 "</body></html>\r\n",
764 nb_connections, nb_max_connections);
765 send(fd, buffer, len, 0);
769 static void new_connection(int server_fd, int is_rtsp)
771 struct sockaddr_in from_addr;
773 HTTPContext *c = NULL;
775 len = sizeof(from_addr);
776 fd = accept(server_fd, (struct sockaddr *)&from_addr,
779 http_log("error during accept %s\n", strerror(errno));
782 ff_socket_nonblock(fd, 1);
784 if (nb_connections >= nb_max_connections) {
785 http_send_too_busy_reply(fd);
789 /* add a new connection */
790 c = av_mallocz(sizeof(HTTPContext));
795 c->poll_entry = NULL;
796 c->from_addr = from_addr;
797 c->buffer_size = IOBUFFER_INIT_SIZE;
798 c->buffer = av_malloc(c->buffer_size);
802 c->next = first_http_ctx;
806 start_wait_request(c, is_rtsp);
818 static void close_connection(HTTPContext *c)
820 HTTPContext **cp, *c1;
822 AVFormatContext *ctx;
826 /* remove connection from list */
827 cp = &first_http_ctx;
828 while ((*cp) != NULL) {
836 /* remove references, if any (XXX: do it faster) */
837 for(c1 = first_http_ctx; c1 != NULL; c1 = c1->next) {
842 /* remove connection associated resources */
846 /* close each frame parser */
847 for(i=0;i<c->fmt_in->nb_streams;i++) {
848 st = c->fmt_in->streams[i];
849 if (st->codec->codec)
850 avcodec_close(st->codec);
852 avformat_close_input(&c->fmt_in);
855 /* free RTP output streams if any */
858 nb_streams = c->stream->nb_streams;
860 for(i=0;i<nb_streams;i++) {
863 av_write_trailer(ctx);
864 av_dict_free(&ctx->metadata);
865 av_free(ctx->streams[0]);
868 h = c->rtp_handles[i];
875 if (!c->last_packet_sent && c->state == HTTPSTATE_SEND_DATA_TRAILER) {
878 if (avio_open_dyn_buf(&ctx->pb) >= 0) {
879 av_write_trailer(ctx);
880 av_freep(&c->pb_buffer);
881 avio_close_dyn_buf(ctx->pb, &c->pb_buffer);
886 for(i=0; i<ctx->nb_streams; i++)
887 av_free(ctx->streams[i]);
889 if (c->stream && !c->post && c->stream->stream_type == STREAM_TYPE_LIVE)
890 current_bandwidth -= c->stream->bandwidth;
892 /* signal that there is no feed if we are the feeder socket */
893 if (c->state == HTTPSTATE_RECEIVE_DATA && c->stream) {
894 c->stream->feed_opened = 0;
898 av_freep(&c->pb_buffer);
899 av_freep(&c->packet_buffer);
905 static int handle_connection(HTTPContext *c)
910 case HTTPSTATE_WAIT_REQUEST:
911 case RTSPSTATE_WAIT_REQUEST:
913 if ((c->timeout - cur_time) < 0)
915 if (c->poll_entry->revents & (POLLERR | POLLHUP))
918 /* no need to read if no events */
919 if (!(c->poll_entry->revents & POLLIN))
923 len = recv(c->fd, c->buffer_ptr, 1, 0);
925 if (ff_neterrno() != AVERROR(EAGAIN) &&
926 ff_neterrno() != AVERROR(EINTR))
928 } else if (len == 0) {
931 /* search for end of request. */
933 c->buffer_ptr += len;
935 if ((ptr >= c->buffer + 2 && !memcmp(ptr-2, "\n\n", 2)) ||
936 (ptr >= c->buffer + 4 && !memcmp(ptr-4, "\r\n\r\n", 4))) {
937 /* request found : parse it and reply */
938 if (c->state == HTTPSTATE_WAIT_REQUEST) {
939 ret = http_parse_request(c);
941 ret = rtsp_parse_request(c);
945 } else if (ptr >= c->buffer_end) {
946 /* request too long: cannot do anything */
948 } else goto read_loop;
952 case HTTPSTATE_SEND_HEADER:
953 if (c->poll_entry->revents & (POLLERR | POLLHUP))
956 /* no need to write if no events */
957 if (!(c->poll_entry->revents & POLLOUT))
959 len = send(c->fd, c->buffer_ptr, c->buffer_end - c->buffer_ptr, 0);
961 if (ff_neterrno() != AVERROR(EAGAIN) &&
962 ff_neterrno() != AVERROR(EINTR)) {
963 /* error : close connection */
964 av_freep(&c->pb_buffer);
968 c->buffer_ptr += len;
970 c->stream->bytes_served += len;
971 c->data_count += len;
972 if (c->buffer_ptr >= c->buffer_end) {
973 av_freep(&c->pb_buffer);
977 /* all the buffer was sent : synchronize to the incoming stream */
978 c->state = HTTPSTATE_SEND_DATA_HEADER;
979 c->buffer_ptr = c->buffer_end = c->buffer;
984 case HTTPSTATE_SEND_DATA:
985 case HTTPSTATE_SEND_DATA_HEADER:
986 case HTTPSTATE_SEND_DATA_TRAILER:
987 /* for packetized output, we consider we can always write (the
988 input streams sets the speed). It may be better to verify
989 that we do not rely too much on the kernel queues */
990 if (!c->is_packetized) {
991 if (c->poll_entry->revents & (POLLERR | POLLHUP))
994 /* no need to read if no events */
995 if (!(c->poll_entry->revents & POLLOUT))
998 if (http_send_data(c) < 0)
1000 /* close connection if trailer sent */
1001 if (c->state == HTTPSTATE_SEND_DATA_TRAILER)
1004 case HTTPSTATE_RECEIVE_DATA:
1005 /* no need to read if no events */
1006 if (c->poll_entry->revents & (POLLERR | POLLHUP))
1008 if (!(c->poll_entry->revents & POLLIN))
1010 if (http_receive_data(c) < 0)
1013 case HTTPSTATE_WAIT_FEED:
1014 /* no need to read if no events */
1015 if (c->poll_entry->revents & (POLLIN | POLLERR | POLLHUP))
1018 /* nothing to do, we'll be waken up by incoming feed packets */
1021 case RTSPSTATE_SEND_REPLY:
1022 if (c->poll_entry->revents & (POLLERR | POLLHUP)) {
1023 av_freep(&c->pb_buffer);
1026 /* no need to write if no events */
1027 if (!(c->poll_entry->revents & POLLOUT))
1029 len = send(c->fd, c->buffer_ptr, c->buffer_end - c->buffer_ptr, 0);
1031 if (ff_neterrno() != AVERROR(EAGAIN) &&
1032 ff_neterrno() != AVERROR(EINTR)) {
1033 /* error : close connection */
1034 av_freep(&c->pb_buffer);
1038 c->buffer_ptr += len;
1039 c->data_count += len;
1040 if (c->buffer_ptr >= c->buffer_end) {
1041 /* all the buffer was sent : wait for a new request */
1042 av_freep(&c->pb_buffer);
1043 start_wait_request(c, 1);
1047 case RTSPSTATE_SEND_PACKET:
1048 if (c->poll_entry->revents & (POLLERR | POLLHUP)) {
1049 av_freep(&c->packet_buffer);
1052 /* no need to write if no events */
1053 if (!(c->poll_entry->revents & POLLOUT))
1055 len = send(c->fd, c->packet_buffer_ptr,
1056 c->packet_buffer_end - c->packet_buffer_ptr, 0);
1058 if (ff_neterrno() != AVERROR(EAGAIN) &&
1059 ff_neterrno() != AVERROR(EINTR)) {
1060 /* error : close connection */
1061 av_freep(&c->packet_buffer);
1065 c->packet_buffer_ptr += len;
1066 if (c->packet_buffer_ptr >= c->packet_buffer_end) {
1067 /* all the buffer was sent : wait for a new request */
1068 av_freep(&c->packet_buffer);
1069 c->state = RTSPSTATE_WAIT_REQUEST;
1073 case HTTPSTATE_READY:
1082 static int extract_rates(char *rates, int ratelen, const char *request)
1086 for (p = request; *p && *p != '\r' && *p != '\n'; ) {
1087 if (av_strncasecmp(p, "Pragma:", 7) == 0) {
1088 const char *q = p + 7;
1090 while (*q && *q != '\n' && isspace(*q))
1093 if (av_strncasecmp(q, "stream-switch-entry=", 20) == 0) {
1099 memset(rates, 0xff, ratelen);
1102 while (*q && *q != '\n' && *q != ':')
1105 if (sscanf(q, ":%d:%d", &stream_no, &rate_no) != 2)
1109 if (stream_no < ratelen && stream_no >= 0)
1110 rates[stream_no] = rate_no;
1112 while (*q && *q != '\n' && !isspace(*q))
1119 p = strchr(p, '\n');
1129 static int find_stream_in_feed(FFStream *feed, AVCodecContext *codec, int bit_rate)
1132 int best_bitrate = 100000000;
1135 for (i = 0; i < feed->nb_streams; i++) {
1136 AVCodecContext *feed_codec = feed->streams[i]->codec;
1138 if (feed_codec->codec_id != codec->codec_id ||
1139 feed_codec->sample_rate != codec->sample_rate ||
1140 feed_codec->width != codec->width ||
1141 feed_codec->height != codec->height)
1144 /* Potential stream */
1146 /* We want the fastest stream less than bit_rate, or the slowest
1147 * faster than bit_rate
1150 if (feed_codec->bit_rate <= bit_rate) {
1151 if (best_bitrate > bit_rate || feed_codec->bit_rate > best_bitrate) {
1152 best_bitrate = feed_codec->bit_rate;
1156 if (feed_codec->bit_rate < best_bitrate) {
1157 best_bitrate = feed_codec->bit_rate;
1166 static int modify_current_stream(HTTPContext *c, char *rates)
1169 FFStream *req = c->stream;
1170 int action_required = 0;
1172 /* Not much we can do for a feed */
1176 for (i = 0; i < req->nb_streams; i++) {
1177 AVCodecContext *codec = req->streams[i]->codec;
1181 c->switch_feed_streams[i] = req->feed_streams[i];
1184 c->switch_feed_streams[i] = find_stream_in_feed(req->feed, codec, codec->bit_rate / 2);
1187 /* Wants off or slow */
1188 c->switch_feed_streams[i] = find_stream_in_feed(req->feed, codec, codec->bit_rate / 4);
1190 /* This doesn't work well when it turns off the only stream! */
1191 c->switch_feed_streams[i] = -2;
1192 c->feed_streams[i] = -2;
1197 if (c->switch_feed_streams[i] >= 0 && c->switch_feed_streams[i] != c->feed_streams[i])
1198 action_required = 1;
1201 return action_required;
1204 /* XXX: factorize in utils.c ? */
1205 /* XXX: take care with different space meaning */
1206 static void skip_spaces(const char **pp)
1210 while (*p == ' ' || *p == '\t')
1215 static void get_word(char *buf, int buf_size, const char **pp)
1223 while (!isspace(*p) && *p != '\0') {
1224 if ((q - buf) < buf_size - 1)
1233 static void get_arg(char *buf, int buf_size, const char **pp)
1240 while (isspace(*p)) p++;
1243 if (*p == '\"' || *p == '\'')
1255 if ((q - buf) < buf_size - 1)
1260 if (quote && *p == quote)
1265 static void parse_acl_row(FFStream *stream, FFStream* feed, IPAddressACL *ext_acl,
1266 const char *p, const char *filename, int line_num)
1272 get_arg(arg, sizeof(arg), &p);
1273 if (av_strcasecmp(arg, "allow") == 0)
1274 acl.action = IP_ALLOW;
1275 else if (av_strcasecmp(arg, "deny") == 0)
1276 acl.action = IP_DENY;
1278 fprintf(stderr, "%s:%d: ACL action '%s' is not ALLOW or DENY\n",
1279 filename, line_num, arg);
1283 get_arg(arg, sizeof(arg), &p);
1285 if (resolve_host(&acl.first, arg) != 0) {
1286 fprintf(stderr, "%s:%d: ACL refers to invalid host or ip address '%s'\n",
1287 filename, line_num, arg);
1290 acl.last = acl.first;
1292 get_arg(arg, sizeof(arg), &p);
1295 if (resolve_host(&acl.last, arg) != 0) {
1296 fprintf(stderr, "%s:%d: ACL refers to invalid host or ip address '%s'\n",
1297 filename, line_num, arg);
1303 IPAddressACL *nacl = av_mallocz(sizeof(*nacl));
1304 IPAddressACL **naclp = 0;
1310 naclp = &stream->acl;
1316 fprintf(stderr, "%s:%d: ACL found not in <stream> or <feed>\n",
1317 filename, line_num);
1323 naclp = &(*naclp)->next;
1331 static IPAddressACL* parse_dynamic_acl(FFStream *stream, HTTPContext *c)
1336 IPAddressACL *acl = NULL;
1340 f = fopen(stream->dynamic_acl, "r");
1342 perror(stream->dynamic_acl);
1346 acl = av_mallocz(sizeof(IPAddressACL));
1350 if (fgets(line, sizeof(line), f) == NULL)
1356 if (*p == '\0' || *p == '#')
1358 get_arg(cmd, sizeof(cmd), &p);
1360 if (!av_strcasecmp(cmd, "ACL"))
1361 parse_acl_row(NULL, NULL, acl, p, stream->dynamic_acl, line_num);
1368 static void free_acl_list(IPAddressACL *in_acl)
1370 IPAddressACL *pacl,*pacl2;
1380 static int validate_acl_list(IPAddressACL *in_acl, HTTPContext *c)
1382 enum IPAddressAction last_action = IP_DENY;
1384 struct in_addr *src = &c->from_addr.sin_addr;
1385 unsigned long src_addr = src->s_addr;
1387 for (acl = in_acl; acl; acl = acl->next) {
1388 if (src_addr >= acl->first.s_addr && src_addr <= acl->last.s_addr)
1389 return (acl->action == IP_ALLOW) ? 1 : 0;
1390 last_action = acl->action;
1393 /* Nothing matched, so return not the last action */
1394 return (last_action == IP_DENY) ? 1 : 0;
1397 static int validate_acl(FFStream *stream, HTTPContext *c)
1403 /* if stream->acl is null validate_acl_list will return 1 */
1404 ret = validate_acl_list(stream->acl, c);
1406 if (stream->dynamic_acl[0]) {
1407 acl = parse_dynamic_acl(stream, c);
1409 ret = validate_acl_list(acl, c);
1417 /* compute the real filename of a file by matching it without its
1418 extensions to all the stream filenames */
1419 static void compute_real_filename(char *filename, int max_size)
1426 /* compute filename by matching without the file extensions */
1427 av_strlcpy(file1, filename, sizeof(file1));
1428 p = strrchr(file1, '.');
1431 for(stream = first_stream; stream != NULL; stream = stream->next) {
1432 av_strlcpy(file2, stream->filename, sizeof(file2));
1433 p = strrchr(file2, '.');
1436 if (!strcmp(file1, file2)) {
1437 av_strlcpy(filename, stream->filename, max_size);
1452 /* parse http request and prepare header */
1453 static int http_parse_request(HTTPContext *c)
1456 enum RedirType redir_type;
1458 char info[1024], filename[1024];
1462 const char *mime_type;
1466 char *useragent = 0;
1469 get_word(cmd, sizeof(cmd), (const char **)&p);
1470 av_strlcpy(c->method, cmd, sizeof(c->method));
1472 if (!strcmp(cmd, "GET"))
1474 else if (!strcmp(cmd, "POST"))
1479 get_word(url, sizeof(url), (const char **)&p);
1480 av_strlcpy(c->url, url, sizeof(c->url));
1482 get_word(protocol, sizeof(protocol), (const char **)&p);
1483 if (strcmp(protocol, "HTTP/1.0") && strcmp(protocol, "HTTP/1.1"))
1486 av_strlcpy(c->protocol, protocol, sizeof(c->protocol));
1489 http_log("%s - - New connection: %s %s\n", inet_ntoa(c->from_addr.sin_addr), cmd, url);
1491 /* find the filename and the optional info string in the request */
1492 p = strchr(url, '?');
1494 av_strlcpy(info, p, sizeof(info));
1499 av_strlcpy(filename, url + ((*url == '/') ? 1 : 0), sizeof(filename)-1);
1501 for (p = c->buffer; *p && *p != '\r' && *p != '\n'; ) {
1502 if (av_strncasecmp(p, "User-Agent:", 11) == 0) {
1504 if (*useragent && *useragent != '\n' && isspace(*useragent))
1508 p = strchr(p, '\n');
1515 redir_type = REDIR_NONE;
1516 if (av_match_ext(filename, "asx")) {
1517 redir_type = REDIR_ASX;
1518 filename[strlen(filename)-1] = 'f';
1519 } else if (av_match_ext(filename, "asf") &&
1520 (!useragent || av_strncasecmp(useragent, "NSPlayer", 8) != 0)) {
1521 /* if this isn't WMP or lookalike, return the redirector file */
1522 redir_type = REDIR_ASF;
1523 } else if (av_match_ext(filename, "rpm,ram")) {
1524 redir_type = REDIR_RAM;
1525 strcpy(filename + strlen(filename)-2, "m");
1526 } else if (av_match_ext(filename, "rtsp")) {
1527 redir_type = REDIR_RTSP;
1528 compute_real_filename(filename, sizeof(filename) - 1);
1529 } else if (av_match_ext(filename, "sdp")) {
1530 redir_type = REDIR_SDP;
1531 compute_real_filename(filename, sizeof(filename) - 1);
1534 // "redirect" / request to index.html
1535 if (!strlen(filename))
1536 av_strlcpy(filename, "index.html", sizeof(filename) - 1);
1538 stream = first_stream;
1539 while (stream != NULL) {
1540 if (!strcmp(stream->filename, filename) && validate_acl(stream, c))
1542 stream = stream->next;
1544 if (stream == NULL) {
1545 snprintf(msg, sizeof(msg), "File '%s' not found", url);
1546 http_log("File '%s' not found\n", url);
1551 memcpy(c->feed_streams, stream->feed_streams, sizeof(c->feed_streams));
1552 memset(c->switch_feed_streams, -1, sizeof(c->switch_feed_streams));
1554 if (stream->stream_type == STREAM_TYPE_REDIRECT) {
1555 c->http_error = 301;
1557 q += snprintf(q, c->buffer_size,
1558 "HTTP/1.0 301 Moved\r\n"
1560 "Content-type: text/html\r\n"
1562 "<html><head><title>Moved</title></head><body>\r\n"
1563 "You should be <a href=\"%s\">redirected</a>.\r\n"
1564 "</body></html>\r\n", stream->feed_filename, stream->feed_filename);
1565 /* prepare output buffer */
1566 c->buffer_ptr = c->buffer;
1568 c->state = HTTPSTATE_SEND_HEADER;
1572 /* If this is WMP, get the rate information */
1573 if (extract_rates(ratebuf, sizeof(ratebuf), c->buffer)) {
1574 if (modify_current_stream(c, ratebuf)) {
1575 for (i = 0; i < FF_ARRAY_ELEMS(c->feed_streams); i++) {
1576 if (c->switch_feed_streams[i] >= 0)
1577 c->switch_feed_streams[i] = -1;
1582 if (c->post == 0 && stream->stream_type == STREAM_TYPE_LIVE)
1583 current_bandwidth += stream->bandwidth;
1585 /* If already streaming this feed, do not let start another feeder. */
1586 if (stream->feed_opened) {
1587 snprintf(msg, sizeof(msg), "This feed is already being received.");
1588 http_log("Feed '%s' already being received\n", stream->feed_filename);
1592 if (c->post == 0 && max_bandwidth < current_bandwidth) {
1593 c->http_error = 503;
1595 q += snprintf(q, c->buffer_size,
1596 "HTTP/1.0 503 Server too busy\r\n"
1597 "Content-type: text/html\r\n"
1599 "<html><head><title>Too busy</title></head><body>\r\n"
1600 "<p>The server is too busy to serve your request at this time.</p>\r\n"
1601 "<p>The bandwidth being served (including your stream) is %"PRIu64"kbit/sec, "
1602 "and this exceeds the limit of %"PRIu64"kbit/sec.</p>\r\n"
1603 "</body></html>\r\n", current_bandwidth, max_bandwidth);
1604 /* prepare output buffer */
1605 c->buffer_ptr = c->buffer;
1607 c->state = HTTPSTATE_SEND_HEADER;
1611 if (redir_type != REDIR_NONE) {
1614 for (p = c->buffer; *p && *p != '\r' && *p != '\n'; ) {
1615 if (av_strncasecmp(p, "Host:", 5) == 0) {
1619 p = strchr(p, '\n');
1630 while (isspace(*hostinfo))
1633 eoh = strchr(hostinfo, '\n');
1635 if (eoh[-1] == '\r')
1638 if (eoh - hostinfo < sizeof(hostbuf) - 1) {
1639 memcpy(hostbuf, hostinfo, eoh - hostinfo);
1640 hostbuf[eoh - hostinfo] = 0;
1642 c->http_error = 200;
1644 switch(redir_type) {
1646 q += snprintf(q, c->buffer_size,
1647 "HTTP/1.0 200 ASX Follows\r\n"
1648 "Content-type: video/x-ms-asf\r\n"
1650 "<ASX Version=\"3\">\r\n"
1651 //"<!-- Autogenerated by avserver -->\r\n"
1652 "<ENTRY><REF HREF=\"http://%s/%s%s\"/></ENTRY>\r\n"
1653 "</ASX>\r\n", hostbuf, filename, info);
1656 q += snprintf(q, c->buffer_size,
1657 "HTTP/1.0 200 RAM Follows\r\n"
1658 "Content-type: audio/x-pn-realaudio\r\n"
1660 "# Autogenerated by avserver\r\n"
1661 "http://%s/%s%s\r\n", hostbuf, filename, info);
1664 q += snprintf(q, c->buffer_size,
1665 "HTTP/1.0 200 ASF Redirect follows\r\n"
1666 "Content-type: video/x-ms-asf\r\n"
1669 "Ref1=http://%s/%s%s\r\n", hostbuf, filename, info);
1673 char hostname[256], *p;
1674 /* extract only hostname */
1675 av_strlcpy(hostname, hostbuf, sizeof(hostname));
1676 p = strrchr(hostname, ':');
1679 q += snprintf(q, c->buffer_size,
1680 "HTTP/1.0 200 RTSP Redirect follows\r\n"
1681 /* XXX: incorrect mime type ? */
1682 "Content-type: application/x-rtsp\r\n"
1684 "rtsp://%s:%d/%s\r\n", hostname, ntohs(my_rtsp_addr.sin_port), filename);
1690 int sdp_data_size, len;
1691 struct sockaddr_in my_addr;
1693 q += snprintf(q, c->buffer_size,
1694 "HTTP/1.0 200 OK\r\n"
1695 "Content-type: application/sdp\r\n"
1698 len = sizeof(my_addr);
1699 getsockname(c->fd, (struct sockaddr *)&my_addr, &len);
1701 /* XXX: should use a dynamic buffer */
1702 sdp_data_size = prepare_sdp_description(stream,
1705 if (sdp_data_size > 0) {
1706 memcpy(q, sdp_data, sdp_data_size);
1718 /* prepare output buffer */
1719 c->buffer_ptr = c->buffer;
1721 c->state = HTTPSTATE_SEND_HEADER;
1727 snprintf(msg, sizeof(msg), "ASX/RAM file not handled");
1731 stream->conns_served++;
1733 /* XXX: add there authenticate and IP match */
1736 /* if post, it means a feed is being sent */
1737 if (!stream->is_feed) {
1738 /* However it might be a status report from WMP! Let us log the
1739 * data as it might come in handy one day. */
1743 for (p = c->buffer; *p && *p != '\r' && *p != '\n'; ) {
1744 if (av_strncasecmp(p, "Pragma: log-line=", 17) == 0) {
1748 if (av_strncasecmp(p, "Pragma: client-id=", 18) == 0)
1749 client_id = strtol(p + 18, 0, 10);
1750 p = strchr(p, '\n');
1758 char *eol = strchr(logline, '\n');
1763 if (eol[-1] == '\r')
1765 http_log("%.*s\n", (int) (eol - logline), logline);
1766 c->suppress_log = 1;
1771 http_log("\nGot request:\n%s\n", c->buffer);
1774 if (client_id && extract_rates(ratebuf, sizeof(ratebuf), c->buffer)) {
1777 /* Now we have to find the client_id */
1778 for (wmpc = first_http_ctx; wmpc; wmpc = wmpc->next) {
1779 if (wmpc->wmp_client_id == client_id)
1783 if (wmpc && modify_current_stream(wmpc, ratebuf))
1784 wmpc->switch_pending = 1;
1787 snprintf(msg, sizeof(msg), "POST command not handled");
1791 if (http_start_receive_data(c) < 0) {
1792 snprintf(msg, sizeof(msg), "could not open feed");
1796 c->state = HTTPSTATE_RECEIVE_DATA;
1801 if (strcmp(stream->filename + strlen(stream->filename) - 4, ".asf") == 0)
1802 http_log("\nGot request:\n%s\n", c->buffer);
1805 if (c->stream->stream_type == STREAM_TYPE_STATUS)
1808 /* open input stream */
1809 if (open_input_stream(c, info) < 0) {
1810 snprintf(msg, sizeof(msg), "Input stream corresponding to '%s' not found", url);
1814 /* prepare http header */
1816 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "HTTP/1.0 200 OK\r\n");
1817 mime_type = c->stream->fmt->mime_type;
1819 mime_type = "application/x-octet-stream";
1820 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "Pragma: no-cache\r\n");
1822 /* for asf, we need extra headers */
1823 if (!strcmp(c->stream->fmt->name,"asf_stream")) {
1824 /* Need to allocate a client id */
1826 c->wmp_client_id = av_lfg_get(&random_state);
1828 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);
1830 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "Content-Type: %s\r\n", mime_type);
1831 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "\r\n");
1833 /* prepare output buffer */
1835 c->buffer_ptr = c->buffer;
1837 c->state = HTTPSTATE_SEND_HEADER;
1840 c->http_error = 404;
1842 q += snprintf(q, c->buffer_size,
1843 "HTTP/1.0 404 Not Found\r\n"
1844 "Content-type: text/html\r\n"
1847 "<head><title>404 Not Found</title></head>\n"
1850 /* prepare output buffer */
1851 c->buffer_ptr = c->buffer;
1853 c->state = HTTPSTATE_SEND_HEADER;
1857 c->http_error = 200; /* horrible : we use this value to avoid
1858 going to the send data state */
1859 c->state = HTTPSTATE_SEND_HEADER;
1863 static void fmt_bytecount(AVIOContext *pb, int64_t count)
1865 static const char *suffix = " kMGTP";
1868 for (s = suffix; count >= 100000 && s[1]; count /= 1000, s++);
1870 avio_printf(pb, "%"PRId64"%c", count, *s);
1873 static void compute_status(HTTPContext *c)
1882 if (avio_open_dyn_buf(&pb) < 0) {
1883 /* XXX: return an error ? */
1884 c->buffer_ptr = c->buffer;
1885 c->buffer_end = c->buffer;
1889 avio_printf(pb, "HTTP/1.0 200 OK\r\n");
1890 avio_printf(pb, "Content-type: %s\r\n", "text/html");
1891 avio_printf(pb, "Pragma: no-cache\r\n");
1892 avio_printf(pb, "\r\n");
1894 avio_printf(pb, "<html><head><title>%s Status</title>\n", program_name);
1895 if (c->stream->feed_filename[0])
1896 avio_printf(pb, "<link rel=\"shortcut icon\" href=\"%s\">\n", c->stream->feed_filename);
1897 avio_printf(pb, "</head>\n<body>");
1898 avio_printf(pb, "<h1>%s Status</h1>\n", program_name);
1900 avio_printf(pb, "<h2>Available Streams</h2>\n");
1901 avio_printf(pb, "<table cellspacing=0 cellpadding=4>\n");
1902 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");
1903 stream = first_stream;
1904 while (stream != NULL) {
1905 char sfilename[1024];
1908 if (stream->feed != stream) {
1909 av_strlcpy(sfilename, stream->filename, sizeof(sfilename) - 10);
1910 eosf = sfilename + strlen(sfilename);
1911 if (eosf - sfilename >= 4) {
1912 if (strcmp(eosf - 4, ".asf") == 0)
1913 strcpy(eosf - 4, ".asx");
1914 else if (strcmp(eosf - 3, ".rm") == 0)
1915 strcpy(eosf - 3, ".ram");
1916 else if (stream->fmt && !strcmp(stream->fmt->name, "rtp")) {
1917 /* generate a sample RTSP director if
1918 unicast. Generate an SDP redirector if
1920 eosf = strrchr(sfilename, '.');
1922 eosf = sfilename + strlen(sfilename);
1923 if (stream->is_multicast)
1924 strcpy(eosf, ".sdp");
1926 strcpy(eosf, ".rtsp");
1930 avio_printf(pb, "<tr><td><a href=\"/%s\">%s</a> ",
1931 sfilename, stream->filename);
1932 avio_printf(pb, "<td align=right> %d <td align=right> ",
1933 stream->conns_served);
1934 fmt_bytecount(pb, stream->bytes_served);
1935 switch(stream->stream_type) {
1936 case STREAM_TYPE_LIVE: {
1937 int audio_bit_rate = 0;
1938 int video_bit_rate = 0;
1939 const char *audio_codec_name = "";
1940 const char *video_codec_name = "";
1941 const char *audio_codec_name_extra = "";
1942 const char *video_codec_name_extra = "";
1944 for(i=0;i<stream->nb_streams;i++) {
1945 AVStream *st = stream->streams[i];
1946 AVCodec *codec = avcodec_find_encoder(st->codec->codec_id);
1947 switch(st->codec->codec_type) {
1948 case AVMEDIA_TYPE_AUDIO:
1949 audio_bit_rate += st->codec->bit_rate;
1951 if (*audio_codec_name)
1952 audio_codec_name_extra = "...";
1953 audio_codec_name = codec->name;
1956 case AVMEDIA_TYPE_VIDEO:
1957 video_bit_rate += st->codec->bit_rate;
1959 if (*video_codec_name)
1960 video_codec_name_extra = "...";
1961 video_codec_name = codec->name;
1964 case AVMEDIA_TYPE_DATA:
1965 video_bit_rate += st->codec->bit_rate;
1971 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",
1974 video_bit_rate / 1000, video_codec_name, video_codec_name_extra,
1975 audio_bit_rate / 1000, audio_codec_name, audio_codec_name_extra);
1977 avio_printf(pb, "<td>%s", stream->feed->filename);
1979 avio_printf(pb, "<td>%s", stream->feed_filename);
1980 avio_printf(pb, "\n");
1984 avio_printf(pb, "<td align=center> - <td align=right> - <td align=right> - <td><td align=right> - <td>\n");
1988 stream = stream->next;
1990 avio_printf(pb, "</table>\n");
1992 stream = first_stream;
1993 while (stream != NULL) {
1994 if (stream->feed == stream) {
1995 avio_printf(pb, "<h2>Feed %s</h2>", stream->filename);
1997 avio_printf(pb, "Running as pid %d.\n", stream->pid);
1999 #if defined(linux) && !defined(CONFIG_NOCUTILS)
2004 /* This is somewhat linux specific I guess */
2005 snprintf(ps_cmd, sizeof(ps_cmd),
2006 "ps -o \"%%cpu,cputime\" --no-headers %d",
2009 pid_stat = popen(ps_cmd, "r");
2014 if (fscanf(pid_stat, "%10s %64s", cpuperc,
2016 avio_printf(pb, "Currently using %s%% of the cpu. Total time used %s.\n",
2024 avio_printf(pb, "<p>");
2026 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");
2028 for (i = 0; i < stream->nb_streams; i++) {
2029 AVStream *st = stream->streams[i];
2030 AVCodec *codec = avcodec_find_encoder(st->codec->codec_id);
2031 const char *type = "unknown";
2032 char parameters[64];
2036 switch(st->codec->codec_type) {
2037 case AVMEDIA_TYPE_AUDIO:
2039 snprintf(parameters, sizeof(parameters), "%d channel(s), %d Hz", st->codec->channels, st->codec->sample_rate);
2041 case AVMEDIA_TYPE_VIDEO:
2043 snprintf(parameters, sizeof(parameters), "%dx%d, q=%d-%d, fps=%d", st->codec->width, st->codec->height,
2044 st->codec->qmin, st->codec->qmax, st->codec->time_base.den / st->codec->time_base.num);
2049 avio_printf(pb, "<tr><td align=right>%d<td>%s<td align=right>%d<td>%s<td>%s\n",
2050 i, type, st->codec->bit_rate/1000, codec ? codec->name : "", parameters);
2052 avio_printf(pb, "</table>\n");
2055 stream = stream->next;
2058 /* connection status */
2059 avio_printf(pb, "<h2>Connection Status</h2>\n");
2061 avio_printf(pb, "Number of connections: %d / %d<br>\n",
2062 nb_connections, nb_max_connections);
2064 avio_printf(pb, "Bandwidth in use: %"PRIu64"k / %"PRIu64"k<br>\n",
2065 current_bandwidth, max_bandwidth);
2067 avio_printf(pb, "<table>\n");
2068 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");
2069 c1 = first_http_ctx;
2071 while (c1 != NULL) {
2077 for (j = 0; j < c1->stream->nb_streams; j++) {
2078 if (!c1->stream->feed)
2079 bitrate += c1->stream->streams[j]->codec->bit_rate;
2080 else if (c1->feed_streams[j] >= 0)
2081 bitrate += c1->stream->feed->streams[c1->feed_streams[j]]->codec->bit_rate;
2086 p = inet_ntoa(c1->from_addr.sin_addr);
2087 avio_printf(pb, "<tr><td><b>%d</b><td>%s%s<td>%s<td>%s<td>%s<td align=right>",
2089 c1->stream ? c1->stream->filename : "",
2090 c1->state == HTTPSTATE_RECEIVE_DATA ? "(input)" : "",
2093 http_state[c1->state]);
2094 fmt_bytecount(pb, bitrate);
2095 avio_printf(pb, "<td align=right>");
2096 fmt_bytecount(pb, compute_datarate(&c1->datarate, c1->data_count) * 8);
2097 avio_printf(pb, "<td align=right>");
2098 fmt_bytecount(pb, c1->data_count);
2099 avio_printf(pb, "\n");
2102 avio_printf(pb, "</table>\n");
2107 avio_printf(pb, "<hr size=1 noshade>Generated at %s", p);
2108 avio_printf(pb, "</body>\n</html>\n");
2110 len = avio_close_dyn_buf(pb, &c->pb_buffer);
2111 c->buffer_ptr = c->pb_buffer;
2112 c->buffer_end = c->pb_buffer + len;
2115 /* check if the parser needs to be opened for stream i */
2116 static void open_parser(AVFormatContext *s, int i)
2118 AVStream *st = s->streams[i];
2121 if (!st->codec->codec) {
2122 codec = avcodec_find_decoder(st->codec->codec_id);
2123 if (codec && (codec->capabilities & CODEC_CAP_PARSE_ONLY)) {
2124 st->codec->parse_only = 1;
2125 if (avcodec_open2(st->codec, codec, NULL) < 0)
2126 st->codec->parse_only = 0;
2131 static int open_input_stream(HTTPContext *c, const char *info)
2134 char input_filename[1024];
2135 AVFormatContext *s = NULL;
2139 /* find file name */
2140 if (c->stream->feed) {
2141 strcpy(input_filename, c->stream->feed->feed_filename);
2142 /* compute position (absolute time) */
2143 if (av_find_info_tag(buf, sizeof(buf), "date", info)) {
2144 if ((ret = av_parse_time(&stream_pos, buf, 0)) < 0)
2146 } else if (av_find_info_tag(buf, sizeof(buf), "buffer", info)) {
2147 int prebuffer = strtol(buf, 0, 10);
2148 stream_pos = av_gettime() - prebuffer * (int64_t)1000000;
2150 stream_pos = av_gettime() - c->stream->prebuffer * (int64_t)1000;
2152 strcpy(input_filename, c->stream->feed_filename);
2153 /* compute position (relative time) */
2154 if (av_find_info_tag(buf, sizeof(buf), "date", info)) {
2155 if ((ret = av_parse_time(&stream_pos, buf, 1)) < 0)
2160 if (input_filename[0] == '\0')
2164 if ((ret = avformat_open_input(&s, input_filename, c->stream->ifmt, &c->stream->in_opts)) < 0) {
2165 http_log("could not open %s: %d\n", input_filename, ret);
2168 s->flags |= AVFMT_FLAG_GENPTS;
2170 if (strcmp(s->iformat->name, "ffm") && avformat_find_stream_info(c->fmt_in, NULL) < 0) {
2171 http_log("Could not find stream info '%s'\n", input_filename);
2172 avformat_close_input(&s);
2176 /* open each parser */
2177 for(i=0;i<s->nb_streams;i++)
2180 /* choose stream as clock source (we favorize video stream if
2181 present) for packet sending */
2182 c->pts_stream_index = 0;
2183 for(i=0;i<c->stream->nb_streams;i++) {
2184 if (c->pts_stream_index == 0 &&
2185 c->stream->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2186 c->pts_stream_index = i;
2190 if (c->fmt_in->iformat->read_seek)
2191 av_seek_frame(c->fmt_in, -1, stream_pos, 0);
2192 /* set the start time (needed for maxtime and RTP packet timing) */
2193 c->start_time = cur_time;
2194 c->first_pts = AV_NOPTS_VALUE;
2198 /* return the server clock (in us) */
2199 static int64_t get_server_clock(HTTPContext *c)
2201 /* compute current pts value from system time */
2202 return (cur_time - c->start_time) * 1000;
2205 /* return the estimated time at which the current packet must be sent
2207 static int64_t get_packet_send_clock(HTTPContext *c)
2209 int bytes_left, bytes_sent, frame_bytes;
2211 frame_bytes = c->cur_frame_bytes;
2212 if (frame_bytes <= 0)
2215 bytes_left = c->buffer_end - c->buffer_ptr;
2216 bytes_sent = frame_bytes - bytes_left;
2217 return c->cur_pts + (c->cur_frame_duration * bytes_sent) / frame_bytes;
2222 static int http_prepare_data(HTTPContext *c)
2225 AVFormatContext *ctx;
2227 av_freep(&c->pb_buffer);
2229 case HTTPSTATE_SEND_DATA_HEADER:
2230 memset(&c->fmt_ctx, 0, sizeof(c->fmt_ctx));
2231 av_dict_set(&c->fmt_ctx.metadata, "author" , c->stream->author , 0);
2232 av_dict_set(&c->fmt_ctx.metadata, "comment" , c->stream->comment , 0);
2233 av_dict_set(&c->fmt_ctx.metadata, "copyright", c->stream->copyright, 0);
2234 av_dict_set(&c->fmt_ctx.metadata, "title" , c->stream->title , 0);
2236 c->fmt_ctx.streams = av_mallocz(sizeof(AVStream *) * c->stream->nb_streams);
2238 for(i=0;i<c->stream->nb_streams;i++) {
2240 c->fmt_ctx.streams[i] = av_mallocz(sizeof(AVStream));
2241 /* if file or feed, then just take streams from FFStream struct */
2242 if (!c->stream->feed ||
2243 c->stream->feed == c->stream)
2244 src = c->stream->streams[i];
2246 src = c->stream->feed->streams[c->stream->feed_streams[i]];
2248 *(c->fmt_ctx.streams[i]) = *src;
2249 c->fmt_ctx.streams[i]->priv_data = 0;
2250 c->fmt_ctx.streams[i]->codec->frame_number = 0; /* XXX: should be done in
2251 AVStream, not in codec */
2253 /* set output format parameters */
2254 c->fmt_ctx.oformat = c->stream->fmt;
2255 c->fmt_ctx.nb_streams = c->stream->nb_streams;
2257 c->got_key_frame = 0;
2259 /* prepare header and save header data in a stream */
2260 if (avio_open_dyn_buf(&c->fmt_ctx.pb) < 0) {
2261 /* XXX: potential leak */
2264 c->fmt_ctx.pb->seekable = 0;
2267 * HACK to avoid mpeg ps muxer to spit many underflow errors
2268 * Default value from Libav
2269 * Try to set it use configuration option
2271 c->fmt_ctx.preload = (int)(0.5*AV_TIME_BASE);
2272 c->fmt_ctx.max_delay = (int)(0.7*AV_TIME_BASE);
2274 if (avformat_write_header(&c->fmt_ctx, NULL) < 0) {
2275 http_log("Error writing output header\n");
2278 av_dict_free(&c->fmt_ctx.metadata);
2280 len = avio_close_dyn_buf(c->fmt_ctx.pb, &c->pb_buffer);
2281 c->buffer_ptr = c->pb_buffer;
2282 c->buffer_end = c->pb_buffer + len;
2284 c->state = HTTPSTATE_SEND_DATA;
2285 c->last_packet_sent = 0;
2287 case HTTPSTATE_SEND_DATA:
2288 /* find a new packet */
2289 /* read a packet from the input stream */
2290 if (c->stream->feed)
2291 ffm_set_write_index(c->fmt_in,
2292 c->stream->feed->feed_write_index,
2293 c->stream->feed->feed_size);
2295 if (c->stream->max_time &&
2296 c->stream->max_time + c->start_time - cur_time < 0)
2297 /* We have timed out */
2298 c->state = HTTPSTATE_SEND_DATA_TRAILER;
2302 ret = av_read_frame(c->fmt_in, &pkt);
2304 if (c->stream->feed) {
2305 /* if coming from feed, it means we reached the end of the
2306 ffm file, so must wait for more data */
2307 c->state = HTTPSTATE_WAIT_FEED;
2308 return 1; /* state changed */
2309 } else if (ret == AVERROR(EAGAIN)) {
2310 /* input not ready, come back later */
2313 if (c->stream->loop) {
2314 avformat_close_input(&c->fmt_in);
2315 if (open_input_stream(c, "") < 0)
2320 /* must send trailer now because eof or error */
2321 c->state = HTTPSTATE_SEND_DATA_TRAILER;
2325 int source_index = pkt.stream_index;
2326 /* update first pts if needed */
2327 if (c->first_pts == AV_NOPTS_VALUE) {
2328 c->first_pts = av_rescale_q(pkt.dts, c->fmt_in->streams[pkt.stream_index]->time_base, AV_TIME_BASE_Q);
2329 c->start_time = cur_time;
2331 /* send it to the appropriate stream */
2332 if (c->stream->feed) {
2333 /* if coming from a feed, select the right stream */
2334 if (c->switch_pending) {
2335 c->switch_pending = 0;
2336 for(i=0;i<c->stream->nb_streams;i++) {
2337 if (c->switch_feed_streams[i] == pkt.stream_index)
2338 if (pkt.flags & AV_PKT_FLAG_KEY)
2339 c->switch_feed_streams[i] = -1;
2340 if (c->switch_feed_streams[i] >= 0)
2341 c->switch_pending = 1;
2344 for(i=0;i<c->stream->nb_streams;i++) {
2345 if (c->stream->feed_streams[i] == pkt.stream_index) {
2346 AVStream *st = c->fmt_in->streams[source_index];
2347 pkt.stream_index = i;
2348 if (pkt.flags & AV_PKT_FLAG_KEY &&
2349 (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2350 c->stream->nb_streams == 1))
2351 c->got_key_frame = 1;
2352 if (!c->stream->send_on_key || c->got_key_frame)
2357 AVCodecContext *codec;
2358 AVStream *ist, *ost;
2360 ist = c->fmt_in->streams[source_index];
2361 /* specific handling for RTP: we use several
2362 output stream (one for each RTP
2363 connection). XXX: need more abstract handling */
2364 if (c->is_packetized) {
2365 /* compute send time and duration */
2366 c->cur_pts = av_rescale_q(pkt.dts, ist->time_base, AV_TIME_BASE_Q);
2367 c->cur_pts -= c->first_pts;
2368 c->cur_frame_duration = av_rescale_q(pkt.duration, ist->time_base, AV_TIME_BASE_Q);
2369 /* find RTP context */
2370 c->packet_stream_index = pkt.stream_index;
2371 ctx = c->rtp_ctx[c->packet_stream_index];
2373 av_free_packet(&pkt);
2376 codec = ctx->streams[0]->codec;
2377 /* only one stream per RTP connection */
2378 pkt.stream_index = 0;
2382 codec = ctx->streams[pkt.stream_index]->codec;
2385 if (c->is_packetized) {
2386 int max_packet_size;
2387 if (c->rtp_protocol == RTSP_LOWER_TRANSPORT_TCP)
2388 max_packet_size = RTSP_TCP_MAX_PACKET_SIZE;
2390 max_packet_size = url_get_max_packet_size(c->rtp_handles[c->packet_stream_index]);
2391 ret = ffio_open_dyn_packet_buf(&ctx->pb, max_packet_size);
2393 ret = avio_open_dyn_buf(&ctx->pb);
2396 /* XXX: potential leak */
2399 ost = ctx->streams[pkt.stream_index];
2401 ctx->pb->seekable = 0;
2402 if (pkt.dts != AV_NOPTS_VALUE)
2403 pkt.dts = av_rescale_q(pkt.dts, ist->time_base, ost->time_base);
2404 if (pkt.pts != AV_NOPTS_VALUE)
2405 pkt.pts = av_rescale_q(pkt.pts, ist->time_base, ost->time_base);
2406 pkt.duration = av_rescale_q(pkt.duration, ist->time_base, ost->time_base);
2407 if (av_write_frame(ctx, &pkt) < 0) {
2408 http_log("Error writing frame to output\n");
2409 c->state = HTTPSTATE_SEND_DATA_TRAILER;
2412 len = avio_close_dyn_buf(ctx->pb, &c->pb_buffer);
2413 c->cur_frame_bytes = len;
2414 c->buffer_ptr = c->pb_buffer;
2415 c->buffer_end = c->pb_buffer + len;
2417 codec->frame_number++;
2419 av_free_packet(&pkt);
2423 av_free_packet(&pkt);
2428 case HTTPSTATE_SEND_DATA_TRAILER:
2429 /* last packet test ? */
2430 if (c->last_packet_sent || c->is_packetized)
2433 /* prepare header */
2434 if (avio_open_dyn_buf(&ctx->pb) < 0) {
2435 /* XXX: potential leak */
2438 c->fmt_ctx.pb->seekable = 0;
2439 av_write_trailer(ctx);
2440 len = avio_close_dyn_buf(ctx->pb, &c->pb_buffer);
2441 c->buffer_ptr = c->pb_buffer;
2442 c->buffer_end = c->pb_buffer + len;
2444 c->last_packet_sent = 1;
2450 /* should convert the format at the same time */
2451 /* send data starting at c->buffer_ptr to the output connection
2452 (either UDP or TCP connection) */
2453 static int http_send_data(HTTPContext *c)
2458 if (c->buffer_ptr >= c->buffer_end) {
2459 ret = http_prepare_data(c);
2463 /* state change requested */
2466 if (c->is_packetized) {
2467 /* RTP data output */
2468 len = c->buffer_end - c->buffer_ptr;
2470 /* fail safe - should never happen */
2472 c->buffer_ptr = c->buffer_end;
2475 len = (c->buffer_ptr[0] << 24) |
2476 (c->buffer_ptr[1] << 16) |
2477 (c->buffer_ptr[2] << 8) |
2479 if (len > (c->buffer_end - c->buffer_ptr))
2481 if ((get_packet_send_clock(c) - get_server_clock(c)) > 0) {
2482 /* nothing to send yet: we can wait */
2486 c->data_count += len;
2487 update_datarate(&c->datarate, c->data_count);
2489 c->stream->bytes_served += len;
2491 if (c->rtp_protocol == RTSP_LOWER_TRANSPORT_TCP) {
2492 /* RTP packets are sent inside the RTSP TCP connection */
2494 int interleaved_index, size;
2496 HTTPContext *rtsp_c;
2499 /* if no RTSP connection left, error */
2502 /* if already sending something, then wait. */
2503 if (rtsp_c->state != RTSPSTATE_WAIT_REQUEST)
2505 if (avio_open_dyn_buf(&pb) < 0)
2507 interleaved_index = c->packet_stream_index * 2;
2508 /* RTCP packets are sent at odd indexes */
2509 if (c->buffer_ptr[1] == 200)
2510 interleaved_index++;
2511 /* write RTSP TCP header */
2513 header[1] = interleaved_index;
2514 header[2] = len >> 8;
2516 avio_write(pb, header, 4);
2517 /* write RTP packet data */
2519 avio_write(pb, c->buffer_ptr, len);
2520 size = avio_close_dyn_buf(pb, &c->packet_buffer);
2521 /* prepare asynchronous TCP sending */
2522 rtsp_c->packet_buffer_ptr = c->packet_buffer;
2523 rtsp_c->packet_buffer_end = c->packet_buffer + size;
2524 c->buffer_ptr += len;
2526 /* send everything we can NOW */
2527 len = send(rtsp_c->fd, rtsp_c->packet_buffer_ptr,
2528 rtsp_c->packet_buffer_end - rtsp_c->packet_buffer_ptr, 0);
2530 rtsp_c->packet_buffer_ptr += len;
2531 if (rtsp_c->packet_buffer_ptr < rtsp_c->packet_buffer_end) {
2532 /* if we could not send all the data, we will
2533 send it later, so a new state is needed to
2534 "lock" the RTSP TCP connection */
2535 rtsp_c->state = RTSPSTATE_SEND_PACKET;
2538 /* all data has been sent */
2539 av_freep(&c->packet_buffer);
2541 /* send RTP packet directly in UDP */
2543 url_write(c->rtp_handles[c->packet_stream_index],
2544 c->buffer_ptr, len);
2545 c->buffer_ptr += len;
2546 /* here we continue as we can send several packets per 10 ms slot */
2549 /* TCP data output */
2550 len = send(c->fd, c->buffer_ptr, c->buffer_end - c->buffer_ptr, 0);
2552 if (ff_neterrno() != AVERROR(EAGAIN) &&
2553 ff_neterrno() != AVERROR(EINTR))
2554 /* error : close connection */
2559 c->buffer_ptr += len;
2561 c->data_count += len;
2562 update_datarate(&c->datarate, c->data_count);
2564 c->stream->bytes_served += len;
2572 static int http_start_receive_data(HTTPContext *c)
2576 if (c->stream->feed_opened)
2579 /* Don't permit writing to this one */
2580 if (c->stream->readonly)
2584 fd = open(c->stream->feed_filename, O_RDWR);
2586 http_log("Error opening feeder file: %s\n", strerror(errno));
2591 if (c->stream->truncate) {
2592 /* truncate feed file */
2593 ffm_write_write_index(c->feed_fd, FFM_PACKET_SIZE);
2594 ftruncate(c->feed_fd, FFM_PACKET_SIZE);
2595 http_log("Truncating feed file '%s'\n", c->stream->feed_filename);
2597 if ((c->stream->feed_write_index = ffm_read_write_index(fd)) < 0) {
2598 http_log("Error reading write index from feed file: %s\n", strerror(errno));
2603 c->stream->feed_write_index = FFMAX(ffm_read_write_index(fd), FFM_PACKET_SIZE);
2604 c->stream->feed_size = lseek(fd, 0, SEEK_END);
2605 lseek(fd, 0, SEEK_SET);
2607 /* init buffer input */
2608 c->buffer_ptr = c->buffer;
2609 c->buffer_end = c->buffer + FFM_PACKET_SIZE;
2610 c->stream->feed_opened = 1;
2611 c->chunked_encoding = !!av_stristr(c->buffer, "Transfer-Encoding: chunked");
2615 static int http_receive_data(HTTPContext *c)
2618 int len, loop_run = 0;
2620 while (c->chunked_encoding && !c->chunk_size &&
2621 c->buffer_end > c->buffer_ptr) {
2622 /* read chunk header, if present */
2623 len = recv(c->fd, c->buffer_ptr, 1, 0);
2626 if (ff_neterrno() != AVERROR(EAGAIN) &&
2627 ff_neterrno() != AVERROR(EINTR))
2628 /* error : close connection */
2631 } else if (len == 0) {
2632 /* end of connection : close it */
2634 } else if (c->buffer_ptr - c->buffer >= 2 &&
2635 !memcmp(c->buffer_ptr - 1, "\r\n", 2)) {
2636 c->chunk_size = strtol(c->buffer, 0, 16);
2637 if (c->chunk_size == 0) // end of stream
2639 c->buffer_ptr = c->buffer;
2641 } else if (++loop_run > 10) {
2642 /* no chunk header, abort */
2649 if (c->buffer_end > c->buffer_ptr) {
2650 len = recv(c->fd, c->buffer_ptr,
2651 FFMIN(c->chunk_size, c->buffer_end - c->buffer_ptr), 0);
2653 if (ff_neterrno() != AVERROR(EAGAIN) &&
2654 ff_neterrno() != AVERROR(EINTR))
2655 /* error : close connection */
2657 } else if (len == 0)
2658 /* end of connection : close it */
2661 c->chunk_size -= len;
2662 c->buffer_ptr += len;
2663 c->data_count += len;
2664 update_datarate(&c->datarate, c->data_count);
2668 if (c->buffer_ptr - c->buffer >= 2 && c->data_count > FFM_PACKET_SIZE) {
2669 if (c->buffer[0] != 'f' ||
2670 c->buffer[1] != 'm') {
2671 http_log("Feed stream has become desynchronized -- disconnecting\n");
2676 if (c->buffer_ptr >= c->buffer_end) {
2677 FFStream *feed = c->stream;
2678 /* a packet has been received : write it in the store, except
2680 if (c->data_count > FFM_PACKET_SIZE) {
2682 // printf("writing pos=0x%"PRIx64" size=0x%"PRIx64"\n", feed->feed_write_index, feed->feed_size);
2683 /* XXX: use llseek or url_seek */
2684 lseek(c->feed_fd, feed->feed_write_index, SEEK_SET);
2685 if (write(c->feed_fd, c->buffer, FFM_PACKET_SIZE) < 0) {
2686 http_log("Error writing to feed file: %s\n", strerror(errno));
2690 feed->feed_write_index += FFM_PACKET_SIZE;
2691 /* update file size */
2692 if (feed->feed_write_index > c->stream->feed_size)
2693 feed->feed_size = feed->feed_write_index;
2695 /* handle wrap around if max file size reached */
2696 if (c->stream->feed_max_size && feed->feed_write_index >= c->stream->feed_max_size)
2697 feed->feed_write_index = FFM_PACKET_SIZE;
2700 if (ffm_write_write_index(c->feed_fd, feed->feed_write_index) < 0) {
2701 http_log("Error writing index to feed file: %s\n", strerror(errno));
2705 /* wake up any waiting connections */
2706 for(c1 = first_http_ctx; c1 != NULL; c1 = c1->next) {
2707 if (c1->state == HTTPSTATE_WAIT_FEED &&
2708 c1->stream->feed == c->stream->feed)
2709 c1->state = HTTPSTATE_SEND_DATA;
2712 /* We have a header in our hands that contains useful data */
2713 AVFormatContext *s = avformat_alloc_context();
2715 AVInputFormat *fmt_in;
2721 /* use feed output format name to find corresponding input format */
2722 fmt_in = av_find_input_format(feed->fmt->name);
2726 pb = avio_alloc_context(c->buffer, c->buffer_end - c->buffer,
2727 0, NULL, NULL, NULL, NULL);
2731 if (avformat_open_input(&s, c->stream->feed_filename, fmt_in, NULL) < 0) {
2736 /* Now we have the actual streams */
2737 if (s->nb_streams != feed->nb_streams) {
2738 avformat_close_input(&s);
2740 http_log("Feed '%s' stream number does not match registered feed\n",
2741 c->stream->feed_filename);
2745 for (i = 0; i < s->nb_streams; i++) {
2746 AVStream *fst = feed->streams[i];
2747 AVStream *st = s->streams[i];
2748 avcodec_copy_context(fst->codec, st->codec);
2751 avformat_close_input(&s);
2754 c->buffer_ptr = c->buffer;
2759 c->stream->feed_opened = 0;
2761 /* wake up any waiting connections to stop waiting for feed */
2762 for(c1 = first_http_ctx; c1 != NULL; c1 = c1->next) {
2763 if (c1->state == HTTPSTATE_WAIT_FEED &&
2764 c1->stream->feed == c->stream->feed)
2765 c1->state = HTTPSTATE_SEND_DATA_TRAILER;
2770 /********************************************************************/
2773 static void rtsp_reply_header(HTTPContext *c, enum RTSPStatusCode error_number)
2780 switch(error_number) {
2781 case RTSP_STATUS_OK:
2784 case RTSP_STATUS_METHOD:
2785 str = "Method Not Allowed";
2787 case RTSP_STATUS_BANDWIDTH:
2788 str = "Not Enough Bandwidth";
2790 case RTSP_STATUS_SESSION:
2791 str = "Session Not Found";
2793 case RTSP_STATUS_STATE:
2794 str = "Method Not Valid in This State";
2796 case RTSP_STATUS_AGGREGATE:
2797 str = "Aggregate operation not allowed";
2799 case RTSP_STATUS_ONLY_AGGREGATE:
2800 str = "Only aggregate operation allowed";
2802 case RTSP_STATUS_TRANSPORT:
2803 str = "Unsupported transport";
2805 case RTSP_STATUS_INTERNAL:
2806 str = "Internal Server Error";
2808 case RTSP_STATUS_SERVICE:
2809 str = "Service Unavailable";
2811 case RTSP_STATUS_VERSION:
2812 str = "RTSP Version not supported";
2815 str = "Unknown Error";
2819 avio_printf(c->pb, "RTSP/1.0 %d %s\r\n", error_number, str);
2820 avio_printf(c->pb, "CSeq: %d\r\n", c->seq);
2822 /* output GMT time */
2825 strftime(buf2, sizeof(buf2), "%a, %d %b %Y %H:%M:%S", tm);
2826 avio_printf(c->pb, "Date: %s GMT\r\n", buf2);
2829 static void rtsp_reply_error(HTTPContext *c, enum RTSPStatusCode error_number)
2831 rtsp_reply_header(c, error_number);
2832 avio_printf(c->pb, "\r\n");
2835 static int rtsp_parse_request(HTTPContext *c)
2837 const char *p, *p1, *p2;
2843 RTSPMessageHeader header1, *header = &header1;
2845 c->buffer_ptr[0] = '\0';
2848 get_word(cmd, sizeof(cmd), &p);
2849 get_word(url, sizeof(url), &p);
2850 get_word(protocol, sizeof(protocol), &p);
2852 av_strlcpy(c->method, cmd, sizeof(c->method));
2853 av_strlcpy(c->url, url, sizeof(c->url));
2854 av_strlcpy(c->protocol, protocol, sizeof(c->protocol));
2856 if (avio_open_dyn_buf(&c->pb) < 0) {
2857 /* XXX: cannot do more */
2858 c->pb = NULL; /* safety */
2862 /* check version name */
2863 if (strcmp(protocol, "RTSP/1.0") != 0) {
2864 rtsp_reply_error(c, RTSP_STATUS_VERSION);
2868 /* parse each header line */
2869 memset(header, 0, sizeof(*header));
2870 /* skip to next line */
2871 while (*p != '\n' && *p != '\0')
2875 while (*p != '\0') {
2876 p1 = memchr(p, '\n', (char *)c->buffer_ptr - p);
2880 if (p2 > p && p2[-1] == '\r')
2882 /* skip empty line */
2886 if (len > sizeof(line) - 1)
2887 len = sizeof(line) - 1;
2888 memcpy(line, p, len);
2890 ff_rtsp_parse_line(header, line, NULL, NULL);
2894 /* handle sequence number */
2895 c->seq = header->seq;
2897 if (!strcmp(cmd, "DESCRIBE"))
2898 rtsp_cmd_describe(c, url);
2899 else if (!strcmp(cmd, "OPTIONS"))
2900 rtsp_cmd_options(c, url);
2901 else if (!strcmp(cmd, "SETUP"))
2902 rtsp_cmd_setup(c, url, header);
2903 else if (!strcmp(cmd, "PLAY"))
2904 rtsp_cmd_play(c, url, header);
2905 else if (!strcmp(cmd, "PAUSE"))
2906 rtsp_cmd_pause(c, url, header);
2907 else if (!strcmp(cmd, "TEARDOWN"))
2908 rtsp_cmd_teardown(c, url, header);
2910 rtsp_reply_error(c, RTSP_STATUS_METHOD);
2913 len = avio_close_dyn_buf(c->pb, &c->pb_buffer);
2914 c->pb = NULL; /* safety */
2916 /* XXX: cannot do more */
2919 c->buffer_ptr = c->pb_buffer;
2920 c->buffer_end = c->pb_buffer + len;
2921 c->state = RTSPSTATE_SEND_REPLY;
2925 static int prepare_sdp_description(FFStream *stream, uint8_t **pbuffer,
2926 struct in_addr my_ip)
2928 AVFormatContext *avc;
2929 AVStream *avs = NULL;
2932 avc = avformat_alloc_context();
2936 av_dict_set(&avc->metadata, "title",
2937 stream->title[0] ? stream->title : "No Title", 0);
2938 avc->nb_streams = stream->nb_streams;
2939 if (stream->is_multicast) {
2940 snprintf(avc->filename, 1024, "rtp://%s:%d?multicast=1?ttl=%d",
2941 inet_ntoa(stream->multicast_ip),
2942 stream->multicast_port, stream->multicast_ttl);
2944 snprintf(avc->filename, 1024, "rtp://0.0.0.0");
2947 if (avc->nb_streams >= INT_MAX/sizeof(*avc->streams) ||
2948 !(avc->streams = av_malloc(avc->nb_streams * sizeof(*avc->streams))))
2950 if (avc->nb_streams >= INT_MAX/sizeof(*avs) ||
2951 !(avs = av_malloc(avc->nb_streams * sizeof(*avs))))
2954 for(i = 0; i < stream->nb_streams; i++) {
2955 avc->streams[i] = &avs[i];
2956 avc->streams[i]->codec = stream->streams[i]->codec;
2958 *pbuffer = av_mallocz(2048);
2959 av_sdp_create(&avc, 1, *pbuffer, 2048);
2962 av_free(avc->streams);
2963 av_dict_free(&avc->metadata);
2967 return strlen(*pbuffer);
2970 static void rtsp_cmd_options(HTTPContext *c, const char *url)
2972 // rtsp_reply_header(c, RTSP_STATUS_OK);
2973 avio_printf(c->pb, "RTSP/1.0 %d %s\r\n", RTSP_STATUS_OK, "OK");
2974 avio_printf(c->pb, "CSeq: %d\r\n", c->seq);
2975 avio_printf(c->pb, "Public: %s\r\n", "OPTIONS, DESCRIBE, SETUP, TEARDOWN, PLAY, PAUSE");
2976 avio_printf(c->pb, "\r\n");
2979 static void rtsp_cmd_describe(HTTPContext *c, const char *url)
2985 int content_length, len;
2986 struct sockaddr_in my_addr;
2988 /* find which url is asked */
2989 av_url_split(NULL, 0, NULL, 0, NULL, 0, NULL, path1, sizeof(path1), url);
2994 for(stream = first_stream; stream != NULL; stream = stream->next) {
2995 if (!stream->is_feed &&
2996 stream->fmt && !strcmp(stream->fmt->name, "rtp") &&
2997 !strcmp(path, stream->filename)) {
3001 /* no stream found */
3002 rtsp_reply_error(c, RTSP_STATUS_SERVICE); /* XXX: right error ? */
3006 /* prepare the media description in sdp format */
3008 /* get the host IP */
3009 len = sizeof(my_addr);
3010 getsockname(c->fd, (struct sockaddr *)&my_addr, &len);
3011 content_length = prepare_sdp_description(stream, &content, my_addr.sin_addr);
3012 if (content_length < 0) {
3013 rtsp_reply_error(c, RTSP_STATUS_INTERNAL);
3016 rtsp_reply_header(c, RTSP_STATUS_OK);
3017 avio_printf(c->pb, "Content-Base: %s/\r\n", url);
3018 avio_printf(c->pb, "Content-Type: application/sdp\r\n");
3019 avio_printf(c->pb, "Content-Length: %d\r\n", content_length);
3020 avio_printf(c->pb, "\r\n");
3021 avio_write(c->pb, content, content_length);
3025 static HTTPContext *find_rtp_session(const char *session_id)
3029 if (session_id[0] == '\0')
3032 for(c = first_http_ctx; c != NULL; c = c->next) {
3033 if (!strcmp(c->session_id, session_id))
3039 static RTSPTransportField *find_transport(RTSPMessageHeader *h, enum RTSPLowerTransport lower_transport)
3041 RTSPTransportField *th;
3044 for(i=0;i<h->nb_transports;i++) {
3045 th = &h->transports[i];
3046 if (th->lower_transport == lower_transport)
3052 static void rtsp_cmd_setup(HTTPContext *c, const char *url,
3053 RTSPMessageHeader *h)
3056 int stream_index, rtp_port, rtcp_port;
3061 RTSPTransportField *th;
3062 struct sockaddr_in dest_addr;
3063 RTSPActionServerSetup setup;
3065 /* find which url is asked */
3066 av_url_split(NULL, 0, NULL, 0, NULL, 0, NULL, path1, sizeof(path1), url);
3071 /* now check each stream */
3072 for(stream = first_stream; stream != NULL; stream = stream->next) {
3073 if (!stream->is_feed &&
3074 stream->fmt && !strcmp(stream->fmt->name, "rtp")) {
3075 /* accept aggregate filenames only if single stream */
3076 if (!strcmp(path, stream->filename)) {
3077 if (stream->nb_streams != 1) {
3078 rtsp_reply_error(c, RTSP_STATUS_AGGREGATE);
3085 for(stream_index = 0; stream_index < stream->nb_streams;
3087 snprintf(buf, sizeof(buf), "%s/streamid=%d",
3088 stream->filename, stream_index);
3089 if (!strcmp(path, buf))
3094 /* no stream found */
3095 rtsp_reply_error(c, RTSP_STATUS_SERVICE); /* XXX: right error ? */
3099 /* generate session id if needed */
3100 if (h->session_id[0] == '\0')
3101 snprintf(h->session_id, sizeof(h->session_id), "%08x%08x",
3102 av_lfg_get(&random_state), av_lfg_get(&random_state));
3104 /* find rtp session, and create it if none found */
3105 rtp_c = find_rtp_session(h->session_id);
3107 /* always prefer UDP */
3108 th = find_transport(h, RTSP_LOWER_TRANSPORT_UDP);
3110 th = find_transport(h, RTSP_LOWER_TRANSPORT_TCP);
3112 rtsp_reply_error(c, RTSP_STATUS_TRANSPORT);
3117 rtp_c = rtp_new_connection(&c->from_addr, stream, h->session_id,
3118 th->lower_transport);
3120 rtsp_reply_error(c, RTSP_STATUS_BANDWIDTH);
3124 /* open input stream */
3125 if (open_input_stream(rtp_c, "") < 0) {
3126 rtsp_reply_error(c, RTSP_STATUS_INTERNAL);
3131 /* test if stream is OK (test needed because several SETUP needs
3132 to be done for a given file) */
3133 if (rtp_c->stream != stream) {
3134 rtsp_reply_error(c, RTSP_STATUS_SERVICE);
3138 /* test if stream is already set up */
3139 if (rtp_c->rtp_ctx[stream_index]) {
3140 rtsp_reply_error(c, RTSP_STATUS_STATE);
3144 /* check transport */
3145 th = find_transport(h, rtp_c->rtp_protocol);
3146 if (!th || (th->lower_transport == RTSP_LOWER_TRANSPORT_UDP &&
3147 th->client_port_min <= 0)) {
3148 rtsp_reply_error(c, RTSP_STATUS_TRANSPORT);
3152 /* setup default options */
3153 setup.transport_option[0] = '\0';
3154 dest_addr = rtp_c->from_addr;
3155 dest_addr.sin_port = htons(th->client_port_min);
3158 if (rtp_new_av_stream(rtp_c, stream_index, &dest_addr, c) < 0) {
3159 rtsp_reply_error(c, RTSP_STATUS_TRANSPORT);
3163 /* now everything is OK, so we can send the connection parameters */
3164 rtsp_reply_header(c, RTSP_STATUS_OK);
3166 avio_printf(c->pb, "Session: %s\r\n", rtp_c->session_id);
3168 switch(rtp_c->rtp_protocol) {
3169 case RTSP_LOWER_TRANSPORT_UDP:
3170 rtp_port = ff_rtp_get_local_rtp_port(rtp_c->rtp_handles[stream_index]);
3171 rtcp_port = ff_rtp_get_local_rtcp_port(rtp_c->rtp_handles[stream_index]);
3172 avio_printf(c->pb, "Transport: RTP/AVP/UDP;unicast;"
3173 "client_port=%d-%d;server_port=%d-%d",
3174 th->client_port_min, th->client_port_max,
3175 rtp_port, rtcp_port);
3177 case RTSP_LOWER_TRANSPORT_TCP:
3178 avio_printf(c->pb, "Transport: RTP/AVP/TCP;interleaved=%d-%d",
3179 stream_index * 2, stream_index * 2 + 1);
3184 if (setup.transport_option[0] != '\0')
3185 avio_printf(c->pb, ";%s", setup.transport_option);
3186 avio_printf(c->pb, "\r\n");
3189 avio_printf(c->pb, "\r\n");
3193 /* find an rtp connection by using the session ID. Check consistency
3195 static HTTPContext *find_rtp_session_with_url(const char *url,
3196 const char *session_id)
3204 rtp_c = find_rtp_session(session_id);
3208 /* find which url is asked */
3209 av_url_split(NULL, 0, NULL, 0, NULL, 0, NULL, path1, sizeof(path1), url);
3213 if(!strcmp(path, rtp_c->stream->filename)) return rtp_c;
3214 for(s=0; s<rtp_c->stream->nb_streams; ++s) {
3215 snprintf(buf, sizeof(buf), "%s/streamid=%d",
3216 rtp_c->stream->filename, s);
3217 if(!strncmp(path, buf, sizeof(buf))) {
3218 // XXX: Should we reply with RTSP_STATUS_ONLY_AGGREGATE if nb_streams>1?
3223 if (len > 0 && path[len - 1] == '/' &&
3224 !strncmp(path, rtp_c->stream->filename, len - 1))
3229 static void rtsp_cmd_play(HTTPContext *c, const char *url, RTSPMessageHeader *h)
3233 rtp_c = find_rtp_session_with_url(url, h->session_id);
3235 rtsp_reply_error(c, RTSP_STATUS_SESSION);
3239 if (rtp_c->state != HTTPSTATE_SEND_DATA &&
3240 rtp_c->state != HTTPSTATE_WAIT_FEED &&
3241 rtp_c->state != HTTPSTATE_READY) {
3242 rtsp_reply_error(c, RTSP_STATUS_STATE);
3246 rtp_c->state = HTTPSTATE_SEND_DATA;
3248 /* now everything is OK, so we can send the connection parameters */
3249 rtsp_reply_header(c, RTSP_STATUS_OK);
3251 avio_printf(c->pb, "Session: %s\r\n", rtp_c->session_id);
3252 avio_printf(c->pb, "\r\n");
3255 static void rtsp_cmd_pause(HTTPContext *c, const char *url, RTSPMessageHeader *h)
3259 rtp_c = find_rtp_session_with_url(url, h->session_id);
3261 rtsp_reply_error(c, RTSP_STATUS_SESSION);
3265 if (rtp_c->state != HTTPSTATE_SEND_DATA &&
3266 rtp_c->state != HTTPSTATE_WAIT_FEED) {
3267 rtsp_reply_error(c, RTSP_STATUS_STATE);
3271 rtp_c->state = HTTPSTATE_READY;
3272 rtp_c->first_pts = AV_NOPTS_VALUE;
3273 /* now everything is OK, so we can send the connection parameters */
3274 rtsp_reply_header(c, RTSP_STATUS_OK);
3276 avio_printf(c->pb, "Session: %s\r\n", rtp_c->session_id);
3277 avio_printf(c->pb, "\r\n");
3280 static void rtsp_cmd_teardown(HTTPContext *c, const char *url, RTSPMessageHeader *h)
3284 rtp_c = find_rtp_session_with_url(url, h->session_id);
3286 rtsp_reply_error(c, RTSP_STATUS_SESSION);
3290 /* now everything is OK, so we can send the connection parameters */
3291 rtsp_reply_header(c, RTSP_STATUS_OK);
3293 avio_printf(c->pb, "Session: %s\r\n", rtp_c->session_id);
3294 avio_printf(c->pb, "\r\n");
3296 /* abort the session */
3297 close_connection(rtp_c);
3301 /********************************************************************/
3304 static HTTPContext *rtp_new_connection(struct sockaddr_in *from_addr,
3305 FFStream *stream, const char *session_id,
3306 enum RTSPLowerTransport rtp_protocol)
3308 HTTPContext *c = NULL;
3309 const char *proto_str;
3311 /* XXX: should output a warning page when coming
3312 close to the connection limit */
3313 if (nb_connections >= nb_max_connections)
3316 /* add a new connection */
3317 c = av_mallocz(sizeof(HTTPContext));
3322 c->poll_entry = NULL;
3323 c->from_addr = *from_addr;
3324 c->buffer_size = IOBUFFER_INIT_SIZE;
3325 c->buffer = av_malloc(c->buffer_size);
3330 av_strlcpy(c->session_id, session_id, sizeof(c->session_id));
3331 c->state = HTTPSTATE_READY;
3332 c->is_packetized = 1;
3333 c->rtp_protocol = rtp_protocol;
3335 /* protocol is shown in statistics */
3336 switch(c->rtp_protocol) {
3337 case RTSP_LOWER_TRANSPORT_UDP_MULTICAST:
3338 proto_str = "MCAST";
3340 case RTSP_LOWER_TRANSPORT_UDP:
3343 case RTSP_LOWER_TRANSPORT_TCP:
3350 av_strlcpy(c->protocol, "RTP/", sizeof(c->protocol));
3351 av_strlcat(c->protocol, proto_str, sizeof(c->protocol));
3353 current_bandwidth += stream->bandwidth;
3355 c->next = first_http_ctx;
3367 /* add a new RTP stream in an RTP connection (used in RTSP SETUP
3368 command). If RTP/TCP protocol is used, TCP connection 'rtsp_c' is
3370 static int rtp_new_av_stream(HTTPContext *c,
3371 int stream_index, struct sockaddr_in *dest_addr,
3372 HTTPContext *rtsp_c)
3374 AVFormatContext *ctx;
3377 URLContext *h = NULL;
3379 int max_packet_size;
3381 /* now we can open the relevant output stream */
3382 ctx = avformat_alloc_context();
3385 ctx->oformat = av_guess_format("rtp", NULL, NULL);
3387 st = av_mallocz(sizeof(AVStream));
3390 ctx->nb_streams = 1;
3391 ctx->streams = av_mallocz(sizeof(AVStream *) * ctx->nb_streams);
3394 ctx->streams[0] = st;
3396 if (!c->stream->feed ||
3397 c->stream->feed == c->stream)
3398 memcpy(st, c->stream->streams[stream_index], sizeof(AVStream));
3401 c->stream->feed->streams[c->stream->feed_streams[stream_index]],
3403 st->priv_data = NULL;
3405 /* build destination RTP address */
3406 ipaddr = inet_ntoa(dest_addr->sin_addr);
3408 switch(c->rtp_protocol) {
3409 case RTSP_LOWER_TRANSPORT_UDP:
3410 case RTSP_LOWER_TRANSPORT_UDP_MULTICAST:
3413 /* XXX: also pass as parameter to function ? */
3414 if (c->stream->is_multicast) {
3416 ttl = c->stream->multicast_ttl;
3419 snprintf(ctx->filename, sizeof(ctx->filename),
3420 "rtp://%s:%d?multicast=1&ttl=%d",
3421 ipaddr, ntohs(dest_addr->sin_port), ttl);
3423 snprintf(ctx->filename, sizeof(ctx->filename),
3424 "rtp://%s:%d", ipaddr, ntohs(dest_addr->sin_port));
3427 if (url_open(&h, ctx->filename, AVIO_FLAG_WRITE) < 0)
3429 c->rtp_handles[stream_index] = h;
3430 max_packet_size = url_get_max_packet_size(h);
3432 case RTSP_LOWER_TRANSPORT_TCP:
3435 max_packet_size = RTSP_TCP_MAX_PACKET_SIZE;
3441 http_log("%s:%d - - \"PLAY %s/streamid=%d %s\"\n",
3442 ipaddr, ntohs(dest_addr->sin_port),
3443 c->stream->filename, stream_index, c->protocol);
3445 /* normally, no packets should be output here, but the packet size may be checked */
3446 if (ffio_open_dyn_packet_buf(&ctx->pb, max_packet_size) < 0) {
3447 /* XXX: close stream */
3450 if (avformat_write_header(ctx, NULL) < 0) {
3457 avio_close_dyn_buf(ctx->pb, &dummy_buf);
3460 c->rtp_ctx[stream_index] = ctx;
3464 /********************************************************************/
3465 /* avserver initialization */
3467 static AVStream *add_av_stream1(FFStream *stream, AVCodecContext *codec, int copy)
3471 fst = av_mallocz(sizeof(AVStream));
3475 fst->codec = avcodec_alloc_context3(NULL);
3476 memcpy(fst->codec, codec, sizeof(AVCodecContext));
3477 if (codec->extradata_size) {
3478 fst->codec->extradata = av_malloc(codec->extradata_size);
3479 memcpy(fst->codec->extradata, codec->extradata,
3480 codec->extradata_size);
3483 /* live streams must use the actual feed's codec since it may be
3484 * updated later to carry extradata needed by the streams.
3488 fst->priv_data = av_mallocz(sizeof(FeedData));
3489 fst->index = stream->nb_streams;
3490 av_set_pts_info(fst, 33, 1, 90000);
3491 fst->sample_aspect_ratio = codec->sample_aspect_ratio;
3492 stream->streams[stream->nb_streams++] = fst;
3496 /* return the stream number in the feed */
3497 static int add_av_stream(FFStream *feed, AVStream *st)
3500 AVCodecContext *av, *av1;
3504 for(i=0;i<feed->nb_streams;i++) {
3505 st = feed->streams[i];
3507 if (av1->codec_id == av->codec_id &&
3508 av1->codec_type == av->codec_type &&
3509 av1->bit_rate == av->bit_rate) {
3511 switch(av->codec_type) {
3512 case AVMEDIA_TYPE_AUDIO:
3513 if (av1->channels == av->channels &&
3514 av1->sample_rate == av->sample_rate)
3517 case AVMEDIA_TYPE_VIDEO:
3518 if (av1->width == av->width &&
3519 av1->height == av->height &&
3520 av1->time_base.den == av->time_base.den &&
3521 av1->time_base.num == av->time_base.num &&
3522 av1->gop_size == av->gop_size)
3531 fst = add_av_stream1(feed, av, 0);
3534 return feed->nb_streams - 1;
3537 static void remove_stream(FFStream *stream)
3541 while (*ps != NULL) {
3549 /* specific mpeg4 handling : we extract the raw parameters */
3550 static void extract_mpeg4_header(AVFormatContext *infile)
3552 int mpeg4_count, i, size;
3558 for(i=0;i<infile->nb_streams;i++) {
3559 st = infile->streams[i];
3560 if (st->codec->codec_id == CODEC_ID_MPEG4 &&
3561 st->codec->extradata_size == 0) {
3568 printf("MPEG4 without extra data: trying to find header in %s\n", infile->filename);
3569 while (mpeg4_count > 0) {
3570 if (av_read_packet(infile, &pkt) < 0)
3572 st = infile->streams[pkt.stream_index];
3573 if (st->codec->codec_id == CODEC_ID_MPEG4 &&
3574 st->codec->extradata_size == 0) {
3575 av_freep(&st->codec->extradata);
3576 /* fill extradata with the header */
3577 /* XXX: we make hard suppositions here ! */
3579 while (p < pkt.data + pkt.size - 4) {
3580 /* stop when vop header is found */
3581 if (p[0] == 0x00 && p[1] == 0x00 &&
3582 p[2] == 0x01 && p[3] == 0xb6) {
3583 size = p - pkt.data;
3584 // av_hex_dump_log(infile, AV_LOG_DEBUG, pkt.data, size);
3585 st->codec->extradata = av_malloc(size);
3586 st->codec->extradata_size = size;
3587 memcpy(st->codec->extradata, pkt.data, size);
3594 av_free_packet(&pkt);
3598 /* compute the needed AVStream for each file */
3599 static void build_file_streams(void)
3601 FFStream *stream, *stream_next;
3604 /* gather all streams */
3605 for(stream = first_stream; stream != NULL; stream = stream_next) {
3606 AVFormatContext *infile = NULL;
3607 stream_next = stream->next;
3608 if (stream->stream_type == STREAM_TYPE_LIVE &&
3610 /* the stream comes from a file */
3611 /* try to open the file */
3613 if (stream->fmt && !strcmp(stream->fmt->name, "rtp")) {
3614 /* specific case : if transport stream output to RTP,
3615 we use a raw transport stream reader */
3616 av_dict_set(&stream->in_opts, "mpeg2ts_compute_pcr", "1", 0);
3619 http_log("Opening file '%s'\n", stream->feed_filename);
3620 if ((ret = avformat_open_input(&infile, stream->feed_filename, stream->ifmt, &stream->in_opts)) < 0) {
3621 http_log("Could not open '%s': %d\n", stream->feed_filename, ret);
3622 /* remove stream (no need to spend more time on it) */
3624 remove_stream(stream);
3626 /* find all the AVStreams inside and reference them in
3628 if (avformat_find_stream_info(infile, NULL) < 0) {
3629 http_log("Could not find codec parameters from '%s'\n",
3630 stream->feed_filename);
3631 avformat_close_input(&infile);
3634 extract_mpeg4_header(infile);
3636 for(i=0;i<infile->nb_streams;i++)
3637 add_av_stream1(stream, infile->streams[i]->codec, 1);
3639 avformat_close_input(&infile);
3645 /* compute the needed AVStream for each feed */
3646 static void build_feed_streams(void)
3648 FFStream *stream, *feed;
3651 /* gather all streams */
3652 for(stream = first_stream; stream != NULL; stream = stream->next) {
3653 feed = stream->feed;
3655 if (stream->is_feed) {
3656 for(i=0;i<stream->nb_streams;i++)
3657 stream->feed_streams[i] = i;
3659 /* we handle a stream coming from a feed */
3660 for(i=0;i<stream->nb_streams;i++)
3661 stream->feed_streams[i] = add_av_stream(feed, stream->streams[i]);
3666 /* create feed files if needed */
3667 for(feed = first_feed; feed != NULL; feed = feed->next_feed) {
3670 if (avio_check(feed->feed_filename, AVIO_FLAG_READ) > 0) {
3671 /* See if it matches */
3672 AVFormatContext *s = NULL;
3675 if (avformat_open_input(&s, feed->feed_filename, NULL, NULL) >= 0) {
3676 /* Now see if it matches */
3677 if (s->nb_streams == feed->nb_streams) {
3679 for(i=0;i<s->nb_streams;i++) {
3681 sf = feed->streams[i];
3684 if (sf->index != ss->index ||
3686 http_log("Index & Id do not match for stream %d (%s)\n",
3687 i, feed->feed_filename);
3690 AVCodecContext *ccf, *ccs;
3694 #define CHECK_CODEC(x) (ccf->x != ccs->x)
3696 if (CHECK_CODEC(codec_id) || CHECK_CODEC(codec_type)) {
3697 http_log("Codecs do not match for stream %d\n", i);
3699 } else if (CHECK_CODEC(bit_rate) || CHECK_CODEC(flags)) {
3700 http_log("Codec bitrates do not match for stream %d\n", i);
3702 } else if (ccf->codec_type == AVMEDIA_TYPE_VIDEO) {
3703 if (CHECK_CODEC(time_base.den) ||
3704 CHECK_CODEC(time_base.num) ||
3705 CHECK_CODEC(width) ||
3706 CHECK_CODEC(height)) {
3707 http_log("Codec width, height and framerate do not match for stream %d\n", i);
3710 } else if (ccf->codec_type == AVMEDIA_TYPE_AUDIO) {
3711 if (CHECK_CODEC(sample_rate) ||
3712 CHECK_CODEC(channels) ||
3713 CHECK_CODEC(frame_size)) {
3714 http_log("Codec sample_rate, channels, frame_size do not match for stream %d\n", i);
3718 http_log("Unknown codec type\n");
3726 http_log("Deleting feed file '%s' as stream counts differ (%d != %d)\n",
3727 feed->feed_filename, s->nb_streams, feed->nb_streams);
3729 avformat_close_input(&s);
3731 http_log("Deleting feed file '%s' as it appears to be corrupt\n",
3732 feed->feed_filename);
3735 if (feed->readonly) {
3736 http_log("Unable to delete feed file '%s' as it is marked readonly\n",
3737 feed->feed_filename);
3740 unlink(feed->feed_filename);
3743 if (avio_check(feed->feed_filename, AVIO_FLAG_WRITE) <= 0) {
3744 AVFormatContext s1 = {0}, *s = &s1;
3746 if (feed->readonly) {
3747 http_log("Unable to create feed file '%s' as it is marked readonly\n",
3748 feed->feed_filename);
3752 /* only write the header of the ffm file */
3753 if (avio_open(&s->pb, feed->feed_filename, AVIO_FLAG_WRITE) < 0) {
3754 http_log("Could not open output feed file '%s'\n",
3755 feed->feed_filename);
3758 s->oformat = feed->fmt;
3759 s->nb_streams = feed->nb_streams;
3760 s->streams = feed->streams;
3761 if (avformat_write_header(s, NULL) < 0) {
3762 http_log("Container doesn't supports the required parameters\n");
3765 /* XXX: need better api */
3766 av_freep(&s->priv_data);
3769 /* get feed size and write index */
3770 fd = open(feed->feed_filename, O_RDONLY);
3772 http_log("Could not open output feed file '%s'\n",
3773 feed->feed_filename);
3777 feed->feed_write_index = FFMAX(ffm_read_write_index(fd), FFM_PACKET_SIZE);
3778 feed->feed_size = lseek(fd, 0, SEEK_END);
3779 /* ensure that we do not wrap before the end of file */
3780 if (feed->feed_max_size && feed->feed_max_size < feed->feed_size)
3781 feed->feed_max_size = feed->feed_size;
3787 /* compute the bandwidth used by each stream */
3788 static void compute_bandwidth(void)
3794 for(stream = first_stream; stream != NULL; stream = stream->next) {
3796 for(i=0;i<stream->nb_streams;i++) {
3797 AVStream *st = stream->streams[i];
3798 switch(st->codec->codec_type) {
3799 case AVMEDIA_TYPE_AUDIO:
3800 case AVMEDIA_TYPE_VIDEO:
3801 bandwidth += st->codec->bit_rate;
3807 stream->bandwidth = (bandwidth + 999) / 1000;
3811 /* add a codec and set the default parameters */
3812 static void add_codec(FFStream *stream, AVCodecContext *av)
3816 /* compute default parameters */
3817 switch(av->codec_type) {
3818 case AVMEDIA_TYPE_AUDIO:
3819 if (av->bit_rate == 0)
3820 av->bit_rate = 64000;
3821 if (av->sample_rate == 0)
3822 av->sample_rate = 22050;
3823 if (av->channels == 0)
3826 case AVMEDIA_TYPE_VIDEO:
3827 if (av->bit_rate == 0)
3828 av->bit_rate = 64000;
3829 if (av->time_base.num == 0){
3830 av->time_base.den = 5;
3831 av->time_base.num = 1;
3833 if (av->width == 0 || av->height == 0) {
3837 /* Bitrate tolerance is less for streaming */
3838 if (av->bit_rate_tolerance == 0)
3839 av->bit_rate_tolerance = FFMAX(av->bit_rate / 4,
3840 (int64_t)av->bit_rate*av->time_base.num/av->time_base.den);
3845 if (av->max_qdiff == 0)
3847 av->qcompress = 0.5;
3850 if (!av->nsse_weight)
3851 av->nsse_weight = 8;
3853 av->frame_skip_cmp = FF_CMP_DCTMAX;
3855 av->me_method = ME_EPZS;
3856 av->rc_buffer_aggressivity = 1.0;
3859 av->rc_eq = "tex^qComp";
3860 if (!av->i_quant_factor)
3861 av->i_quant_factor = -0.8;
3862 if (!av->b_quant_factor)
3863 av->b_quant_factor = 1.25;
3864 if (!av->b_quant_offset)
3865 av->b_quant_offset = 1.25;
3866 if (!av->rc_max_rate)
3867 av->rc_max_rate = av->bit_rate * 2;
3869 if (av->rc_max_rate && !av->rc_buffer_size) {
3870 av->rc_buffer_size = av->rc_max_rate;
3879 st = av_mallocz(sizeof(AVStream));
3882 st->codec = avcodec_alloc_context3(NULL);
3883 stream->streams[stream->nb_streams++] = st;
3884 memcpy(st->codec, av, sizeof(AVCodecContext));
3887 static enum CodecID opt_audio_codec(const char *arg)
3889 AVCodec *p= avcodec_find_encoder_by_name(arg);
3891 if (p == NULL || p->type != AVMEDIA_TYPE_AUDIO)
3892 return CODEC_ID_NONE;
3897 static enum CodecID opt_video_codec(const char *arg)
3899 AVCodec *p= avcodec_find_encoder_by_name(arg);
3901 if (p == NULL || p->type != AVMEDIA_TYPE_VIDEO)
3902 return CODEC_ID_NONE;
3907 /* simplistic plugin support */
3910 static void load_module(const char *filename)
3913 void (*init_func)(void);
3914 dll = dlopen(filename, RTLD_NOW);
3916 fprintf(stderr, "Could not load module '%s' - %s\n",
3917 filename, dlerror());
3921 init_func = dlsym(dll, "avserver_module_init");
3924 "%s: init function 'avserver_module_init()' not found\n",
3933 static int avserver_opt_default(const char *opt, const char *arg,
3934 AVCodecContext *avctx, int type)
3937 const AVOption *o = av_opt_find(avctx, opt, NULL, type, 0);
3939 ret = av_opt_set(avctx, opt, arg, 0);
3943 static int avserver_opt_preset(const char *arg,
3944 AVCodecContext *avctx, int type,
3945 enum CodecID *audio_id, enum CodecID *video_id)
3948 char filename[1000], tmp[1000], tmp2[1000], line[1000];
3950 AVCodec *codec = avcodec_find_encoder(avctx->codec_id);
3952 if (!(f = get_preset_file(filename, sizeof(filename), arg, 0,
3953 codec ? codec->name : NULL))) {
3954 fprintf(stderr, "File for preset '%s' not found\n", arg);
3959 int e= fscanf(f, "%999[^\n]\n", line) - 1;
3960 if(line[0] == '#' && !e)
3962 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
3964 fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
3968 if(!strcmp(tmp, "acodec")){
3969 *audio_id = opt_audio_codec(tmp2);
3970 }else if(!strcmp(tmp, "vcodec")){
3971 *video_id = opt_video_codec(tmp2);
3972 }else if(!strcmp(tmp, "scodec")){
3973 /* opt_subtitle_codec(tmp2); */
3974 }else if(avserver_opt_default(tmp, tmp2, avctx, type) < 0){
3975 fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
3986 static AVOutputFormat *avserver_guess_format(const char *short_name, const char *filename,
3987 const char *mime_type)
3989 AVOutputFormat *fmt = av_guess_format(short_name, filename, mime_type);
3992 AVOutputFormat *stream_fmt;
3993 char stream_format_name[64];
3995 snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
3996 stream_fmt = av_guess_format(stream_format_name, NULL, NULL);
4005 static void report_config_error(const char *filename, int line_num, int *errors, const char *fmt, ...)
4009 fprintf(stderr, "%s:%d: ", filename, line_num);
4010 vfprintf(stderr, fmt, vl);
4016 static int parse_ffconfig(const char *filename)
4023 int val, errors, line_num;
4024 FFStream **last_stream, *stream, *redirect;
4025 FFStream **last_feed, *feed, *s;
4026 AVCodecContext audio_enc, video_enc;
4027 enum CodecID audio_id, video_id;
4029 f = fopen(filename, "r");
4037 first_stream = NULL;
4038 last_stream = &first_stream;
4040 last_feed = &first_feed;
4044 audio_id = CODEC_ID_NONE;
4045 video_id = CODEC_ID_NONE;
4047 #define ERROR(...) report_config_error(filename, line_num, &errors, __VA_ARGS__)
4049 if (fgets(line, sizeof(line), f) == NULL)
4055 if (*p == '\0' || *p == '#')
4058 get_arg(cmd, sizeof(cmd), &p);
4060 if (!av_strcasecmp(cmd, "Port")) {
4061 get_arg(arg, sizeof(arg), &p);
4063 if (val < 1 || val > 65536) {
4064 ERROR("Invalid_port: %s\n", arg);
4066 my_http_addr.sin_port = htons(val);
4067 } else if (!av_strcasecmp(cmd, "BindAddress")) {
4068 get_arg(arg, sizeof(arg), &p);
4069 if (resolve_host(&my_http_addr.sin_addr, arg) != 0) {
4070 ERROR("%s:%d: Invalid host/IP address: %s\n", arg);
4072 } else if (!av_strcasecmp(cmd, "NoDaemon")) {
4073 avserver_daemon = 0;
4074 } else if (!av_strcasecmp(cmd, "RTSPPort")) {
4075 get_arg(arg, sizeof(arg), &p);
4077 if (val < 1 || val > 65536) {
4078 ERROR("%s:%d: Invalid port: %s\n", arg);
4080 my_rtsp_addr.sin_port = htons(atoi(arg));
4081 } else if (!av_strcasecmp(cmd, "RTSPBindAddress")) {
4082 get_arg(arg, sizeof(arg), &p);
4083 if (resolve_host(&my_rtsp_addr.sin_addr, arg) != 0) {
4084 ERROR("Invalid host/IP address: %s\n", arg);
4086 } else if (!av_strcasecmp(cmd, "MaxHTTPConnections")) {
4087 get_arg(arg, sizeof(arg), &p);
4089 if (val < 1 || val > 65536) {
4090 ERROR("Invalid MaxHTTPConnections: %s\n", arg);
4092 nb_max_http_connections = val;
4093 } else if (!av_strcasecmp(cmd, "MaxClients")) {
4094 get_arg(arg, sizeof(arg), &p);
4096 if (val < 1 || val > nb_max_http_connections) {
4097 ERROR("Invalid MaxClients: %s\n", arg);
4099 nb_max_connections = val;
4101 } else if (!av_strcasecmp(cmd, "MaxBandwidth")) {
4103 get_arg(arg, sizeof(arg), &p);
4105 if (llval < 10 || llval > 10000000) {
4106 ERROR("Invalid MaxBandwidth: %s\n", arg);
4108 max_bandwidth = llval;
4109 } else if (!av_strcasecmp(cmd, "CustomLog")) {
4110 if (!avserver_debug)
4111 get_arg(logfilename, sizeof(logfilename), &p);
4112 } else if (!av_strcasecmp(cmd, "<Feed")) {
4113 /*********************************************/
4114 /* Feed related options */
4116 if (stream || feed) {
4117 ERROR("Already in a tag\n");
4119 feed = av_mallocz(sizeof(FFStream));
4120 get_arg(feed->filename, sizeof(feed->filename), &p);
4121 q = strrchr(feed->filename, '>');
4125 for (s = first_feed; s; s = s->next) {
4126 if (!strcmp(feed->filename, s->filename)) {
4127 ERROR("Feed '%s' already registered\n", s->filename);
4131 feed->fmt = av_guess_format("ffm", NULL, NULL);
4132 /* defaut feed file */
4133 snprintf(feed->feed_filename, sizeof(feed->feed_filename),
4134 "/tmp/%s.ffm", feed->filename);
4135 feed->feed_max_size = 5 * 1024 * 1024;
4137 feed->feed = feed; /* self feeding :-) */
4139 /* add in stream list */
4140 *last_stream = feed;
4141 last_stream = &feed->next;
4142 /* add in feed list */
4144 last_feed = &feed->next_feed;
4146 } else if (!av_strcasecmp(cmd, "Launch")) {
4150 feed->child_argv = av_mallocz(64 * sizeof(char *));
4152 for (i = 0; i < 62; i++) {
4153 get_arg(arg, sizeof(arg), &p);
4157 feed->child_argv[i] = av_strdup(arg);
4160 feed->child_argv[i] = av_malloc(30 + strlen(feed->filename));
4162 snprintf(feed->child_argv[i], 30+strlen(feed->filename),
4164 (my_http_addr.sin_addr.s_addr == INADDR_ANY) ? "127.0.0.1" :
4165 inet_ntoa(my_http_addr.sin_addr),
4166 ntohs(my_http_addr.sin_port), feed->filename);
4168 } else if (!av_strcasecmp(cmd, "ReadOnlyFile")) {
4170 get_arg(feed->feed_filename, sizeof(feed->feed_filename), &p);
4172 } else if (stream) {
4173 get_arg(stream->feed_filename, sizeof(stream->feed_filename), &p);
4175 } else if (!av_strcasecmp(cmd, "File")) {
4177 get_arg(feed->feed_filename, sizeof(feed->feed_filename), &p);
4179 get_arg(stream->feed_filename, sizeof(stream->feed_filename), &p);
4180 } else if (!av_strcasecmp(cmd, "Truncate")) {
4182 get_arg(arg, sizeof(arg), &p);
4183 feed->truncate = strtod(arg, NULL);
4185 } else if (!av_strcasecmp(cmd, "FileMaxSize")) {
4190 get_arg(arg, sizeof(arg), &p);
4192 fsize = strtod(p1, &p1);
4193 switch(toupper(*p1)) {
4198 fsize *= 1024 * 1024;
4201 fsize *= 1024 * 1024 * 1024;
4204 feed->feed_max_size = (int64_t)fsize;
4205 if (feed->feed_max_size < FFM_PACKET_SIZE*4) {
4206 ERROR("Feed max file size is too small, must be at least %d\n", FFM_PACKET_SIZE*4);
4209 } else if (!av_strcasecmp(cmd, "</Feed>")) {
4211 ERROR("No corresponding <Feed> for </Feed>\n");
4214 } else if (!av_strcasecmp(cmd, "<Stream")) {
4215 /*********************************************/
4216 /* Stream related options */
4218 if (stream || feed) {
4219 ERROR("Already in a tag\n");
4222 stream = av_mallocz(sizeof(FFStream));
4223 get_arg(stream->filename, sizeof(stream->filename), &p);
4224 q = strrchr(stream->filename, '>');
4228 for (s = first_stream; s; s = s->next) {
4229 if (!strcmp(stream->filename, s->filename)) {
4230 ERROR("Stream '%s' already registered\n", s->filename);
4234 stream->fmt = avserver_guess_format(NULL, stream->filename, NULL);
4235 avcodec_get_context_defaults3(&video_enc, NULL);
4236 avcodec_get_context_defaults3(&audio_enc, NULL);
4237 audio_id = CODEC_ID_NONE;
4238 video_id = CODEC_ID_NONE;
4240 audio_id = stream->fmt->audio_codec;
4241 video_id = stream->fmt->video_codec;
4244 *last_stream = stream;
4245 last_stream = &stream->next;
4247 } else if (!av_strcasecmp(cmd, "Feed")) {
4248 get_arg(arg, sizeof(arg), &p);
4253 while (sfeed != NULL) {
4254 if (!strcmp(sfeed->filename, arg))
4256 sfeed = sfeed->next_feed;
4259 ERROR("feed '%s' not defined\n", arg);
4261 stream->feed = sfeed;
4263 } else if (!av_strcasecmp(cmd, "Format")) {
4264 get_arg(arg, sizeof(arg), &p);
4266 if (!strcmp(arg, "status")) {
4267 stream->stream_type = STREAM_TYPE_STATUS;
4270 stream->stream_type = STREAM_TYPE_LIVE;
4271 /* jpeg cannot be used here, so use single frame jpeg */
4272 if (!strcmp(arg, "jpeg"))
4273 strcpy(arg, "mjpeg");
4274 stream->fmt = avserver_guess_format(arg, NULL, NULL);
4276 ERROR("Unknown Format: %s\n", arg);
4280 audio_id = stream->fmt->audio_codec;
4281 video_id = stream->fmt->video_codec;
4284 } else if (!av_strcasecmp(cmd, "InputFormat")) {
4285 get_arg(arg, sizeof(arg), &p);
4287 stream->ifmt = av_find_input_format(arg);
4288 if (!stream->ifmt) {
4289 ERROR("Unknown input format: %s\n", arg);
4292 } else if (!av_strcasecmp(cmd, "FaviconURL")) {
4293 if (stream && stream->stream_type == STREAM_TYPE_STATUS) {
4294 get_arg(stream->feed_filename, sizeof(stream->feed_filename), &p);
4296 ERROR("FaviconURL only permitted for status streams\n");
4298 } else if (!av_strcasecmp(cmd, "Author")) {
4300 get_arg(stream->author, sizeof(stream->author), &p);
4301 } else if (!av_strcasecmp(cmd, "Comment")) {
4303 get_arg(stream->comment, sizeof(stream->comment), &p);
4304 } else if (!av_strcasecmp(cmd, "Copyright")) {
4306 get_arg(stream->copyright, sizeof(stream->copyright), &p);
4307 } else if (!av_strcasecmp(cmd, "Title")) {
4309 get_arg(stream->title, sizeof(stream->title), &p);
4310 } else if (!av_strcasecmp(cmd, "Preroll")) {
4311 get_arg(arg, sizeof(arg), &p);
4313 stream->prebuffer = atof(arg) * 1000;
4314 } else if (!av_strcasecmp(cmd, "StartSendOnKey")) {
4316 stream->send_on_key = 1;
4317 } else if (!av_strcasecmp(cmd, "AudioCodec")) {
4318 get_arg(arg, sizeof(arg), &p);
4319 audio_id = opt_audio_codec(arg);
4320 if (audio_id == CODEC_ID_NONE) {
4321 ERROR("Unknown AudioCodec: %s\n", arg);
4323 } else if (!av_strcasecmp(cmd, "VideoCodec")) {
4324 get_arg(arg, sizeof(arg), &p);
4325 video_id = opt_video_codec(arg);
4326 if (video_id == CODEC_ID_NONE) {
4327 ERROR("Unknown VideoCodec: %s\n", arg);
4329 } else if (!av_strcasecmp(cmd, "MaxTime")) {
4330 get_arg(arg, sizeof(arg), &p);
4332 stream->max_time = atof(arg) * 1000;
4333 } else if (!av_strcasecmp(cmd, "AudioBitRate")) {
4334 get_arg(arg, sizeof(arg), &p);
4336 audio_enc.bit_rate = lrintf(atof(arg) * 1000);
4337 } else if (!av_strcasecmp(cmd, "AudioChannels")) {
4338 get_arg(arg, sizeof(arg), &p);
4340 audio_enc.channels = atoi(arg);
4341 } else if (!av_strcasecmp(cmd, "AudioSampleRate")) {
4342 get_arg(arg, sizeof(arg), &p);
4344 audio_enc.sample_rate = atoi(arg);
4345 } else if (!av_strcasecmp(cmd, "AudioQuality")) {
4346 get_arg(arg, sizeof(arg), &p);
4348 // audio_enc.quality = atof(arg) * 1000;
4350 } else if (!av_strcasecmp(cmd, "VideoBitRateRange")) {
4352 int minrate, maxrate;
4354 get_arg(arg, sizeof(arg), &p);
4356 if (sscanf(arg, "%d-%d", &minrate, &maxrate) == 2) {
4357 video_enc.rc_min_rate = minrate * 1000;
4358 video_enc.rc_max_rate = maxrate * 1000;
4360 ERROR("Incorrect format for VideoBitRateRange -- should be <min>-<max>: %s\n", arg);
4363 } else if (!av_strcasecmp(cmd, "Debug")) {
4365 get_arg(arg, sizeof(arg), &p);
4366 video_enc.debug = strtol(arg,0,0);
4368 } else if (!av_strcasecmp(cmd, "Strict")) {
4370 get_arg(arg, sizeof(arg), &p);
4371 video_enc.strict_std_compliance = atoi(arg);
4373 } else if (!av_strcasecmp(cmd, "VideoBufferSize")) {
4375 get_arg(arg, sizeof(arg), &p);
4376 video_enc.rc_buffer_size = atoi(arg) * 8*1024;
4378 } else if (!av_strcasecmp(cmd, "VideoBitRateTolerance")) {
4380 get_arg(arg, sizeof(arg), &p);
4381 video_enc.bit_rate_tolerance = atoi(arg) * 1000;
4383 } else if (!av_strcasecmp(cmd, "VideoBitRate")) {
4384 get_arg(arg, sizeof(arg), &p);
4386 video_enc.bit_rate = atoi(arg) * 1000;
4388 } else if (!av_strcasecmp(cmd, "VideoSize")) {
4389 get_arg(arg, sizeof(arg), &p);
4391 av_parse_video_size(&video_enc.width, &video_enc.height, arg);
4392 if ((video_enc.width % 16) != 0 ||
4393 (video_enc.height % 16) != 0) {
4394 ERROR("Image size must be a multiple of 16\n");
4397 } else if (!av_strcasecmp(cmd, "VideoFrameRate")) {
4398 get_arg(arg, sizeof(arg), &p);
4400 AVRational frame_rate;
4401 if (av_parse_video_rate(&frame_rate, arg) < 0) {
4402 ERROR("Incorrect frame rate: %s\n", arg);
4404 video_enc.time_base.num = frame_rate.den;
4405 video_enc.time_base.den = frame_rate.num;
4408 } else if (!av_strcasecmp(cmd, "VideoGopSize")) {
4409 get_arg(arg, sizeof(arg), &p);
4411 video_enc.gop_size = atoi(arg);
4412 } else if (!av_strcasecmp(cmd, "VideoIntraOnly")) {
4414 video_enc.gop_size = 1;
4415 } else if (!av_strcasecmp(cmd, "VideoHighQuality")) {
4417 video_enc.mb_decision = FF_MB_DECISION_BITS;
4418 } else if (!av_strcasecmp(cmd, "Video4MotionVector")) {
4420 video_enc.mb_decision = FF_MB_DECISION_BITS; //FIXME remove
4421 video_enc.flags |= CODEC_FLAG_4MV;
4423 } else if (!av_strcasecmp(cmd, "AVOptionVideo") ||
4424 !av_strcasecmp(cmd, "AVOptionAudio")) {
4426 AVCodecContext *avctx;
4428 get_arg(arg, sizeof(arg), &p);
4429 get_arg(arg2, sizeof(arg2), &p);
4430 if (!av_strcasecmp(cmd, "AVOptionVideo")) {
4432 type = AV_OPT_FLAG_VIDEO_PARAM;
4435 type = AV_OPT_FLAG_AUDIO_PARAM;
4437 if (avserver_opt_default(arg, arg2, avctx, type|AV_OPT_FLAG_ENCODING_PARAM)) {
4438 ERROR("AVOption error: %s %s\n", arg, arg2);
4440 } else if (!av_strcasecmp(cmd, "AVPresetVideo") ||
4441 !av_strcasecmp(cmd, "AVPresetAudio")) {
4442 AVCodecContext *avctx;
4444 get_arg(arg, sizeof(arg), &p);
4445 if (!av_strcasecmp(cmd, "AVPresetVideo")) {
4447 video_enc.codec_id = video_id;
4448 type = AV_OPT_FLAG_VIDEO_PARAM;
4451 audio_enc.codec_id = audio_id;
4452 type = AV_OPT_FLAG_AUDIO_PARAM;
4454 if (avserver_opt_preset(arg, avctx, type|AV_OPT_FLAG_ENCODING_PARAM, &audio_id, &video_id)) {
4455 ERROR("AVPreset error: %s\n", arg);
4457 } else if (!av_strcasecmp(cmd, "VideoTag")) {
4458 get_arg(arg, sizeof(arg), &p);
4459 if ((strlen(arg) == 4) && stream)
4460 video_enc.codec_tag = MKTAG(arg[0], arg[1], arg[2], arg[3]);
4461 } else if (!av_strcasecmp(cmd, "BitExact")) {
4463 video_enc.flags |= CODEC_FLAG_BITEXACT;
4464 } else if (!av_strcasecmp(cmd, "DctFastint")) {
4466 video_enc.dct_algo = FF_DCT_FASTINT;
4467 } else if (!av_strcasecmp(cmd, "IdctSimple")) {
4469 video_enc.idct_algo = FF_IDCT_SIMPLE;
4470 } else if (!av_strcasecmp(cmd, "Qscale")) {
4471 get_arg(arg, sizeof(arg), &p);
4473 video_enc.flags |= CODEC_FLAG_QSCALE;
4474 video_enc.global_quality = FF_QP2LAMBDA * atoi(arg);
4476 } else if (!av_strcasecmp(cmd, "VideoQDiff")) {
4477 get_arg(arg, sizeof(arg), &p);
4479 video_enc.max_qdiff = atoi(arg);
4480 if (video_enc.max_qdiff < 1 || video_enc.max_qdiff > 31) {
4481 ERROR("VideoQDiff out of range\n");
4484 } else if (!av_strcasecmp(cmd, "VideoQMax")) {
4485 get_arg(arg, sizeof(arg), &p);
4487 video_enc.qmax = atoi(arg);
4488 if (video_enc.qmax < 1 || video_enc.qmax > 31) {
4489 ERROR("VideoQMax out of range\n");
4492 } else if (!av_strcasecmp(cmd, "VideoQMin")) {
4493 get_arg(arg, sizeof(arg), &p);
4495 video_enc.qmin = atoi(arg);
4496 if (video_enc.qmin < 1 || video_enc.qmin > 31) {
4497 ERROR("VideoQMin out of range\n");
4500 } else if (!av_strcasecmp(cmd, "LumaElim")) {
4501 get_arg(arg, sizeof(arg), &p);
4503 video_enc.luma_elim_threshold = atoi(arg);
4504 } else if (!av_strcasecmp(cmd, "ChromaElim")) {
4505 get_arg(arg, sizeof(arg), &p);
4507 video_enc.chroma_elim_threshold = atoi(arg);
4508 } else if (!av_strcasecmp(cmd, "LumiMask")) {
4509 get_arg(arg, sizeof(arg), &p);
4511 video_enc.lumi_masking = atof(arg);
4512 } else if (!av_strcasecmp(cmd, "DarkMask")) {
4513 get_arg(arg, sizeof(arg), &p);
4515 video_enc.dark_masking = atof(arg);
4516 } else if (!av_strcasecmp(cmd, "NoVideo")) {
4517 video_id = CODEC_ID_NONE;
4518 } else if (!av_strcasecmp(cmd, "NoAudio")) {
4519 audio_id = CODEC_ID_NONE;
4520 } else if (!av_strcasecmp(cmd, "ACL")) {
4521 parse_acl_row(stream, feed, NULL, p, filename, line_num);
4522 } else if (!av_strcasecmp(cmd, "DynamicACL")) {
4524 get_arg(stream->dynamic_acl, sizeof(stream->dynamic_acl), &p);
4526 } else if (!av_strcasecmp(cmd, "RTSPOption")) {
4527 get_arg(arg, sizeof(arg), &p);
4529 av_freep(&stream->rtsp_option);
4530 stream->rtsp_option = av_strdup(arg);
4532 } else if (!av_strcasecmp(cmd, "MulticastAddress")) {
4533 get_arg(arg, sizeof(arg), &p);
4535 if (resolve_host(&stream->multicast_ip, arg) != 0) {
4536 ERROR("Invalid host/IP address: %s\n", arg);
4538 stream->is_multicast = 1;
4539 stream->loop = 1; /* default is looping */
4541 } else if (!av_strcasecmp(cmd, "MulticastPort")) {
4542 get_arg(arg, sizeof(arg), &p);
4544 stream->multicast_port = atoi(arg);
4545 } else if (!av_strcasecmp(cmd, "MulticastTTL")) {
4546 get_arg(arg, sizeof(arg), &p);
4548 stream->multicast_ttl = atoi(arg);
4549 } else if (!av_strcasecmp(cmd, "NoLoop")) {
4552 } else if (!av_strcasecmp(cmd, "</Stream>")) {
4554 ERROR("No corresponding <Stream> for </Stream>\n");
4556 if (stream->feed && stream->fmt && strcmp(stream->fmt->name, "ffm") != 0) {
4557 if (audio_id != CODEC_ID_NONE) {
4558 audio_enc.codec_type = AVMEDIA_TYPE_AUDIO;
4559 audio_enc.codec_id = audio_id;
4560 add_codec(stream, &audio_enc);
4562 if (video_id != CODEC_ID_NONE) {
4563 video_enc.codec_type = AVMEDIA_TYPE_VIDEO;
4564 video_enc.codec_id = video_id;
4565 add_codec(stream, &video_enc);
4570 } else if (!av_strcasecmp(cmd, "<Redirect")) {
4571 /*********************************************/
4573 if (stream || feed || redirect) {
4574 ERROR("Already in a tag\n");
4576 redirect = av_mallocz(sizeof(FFStream));
4577 *last_stream = redirect;
4578 last_stream = &redirect->next;
4580 get_arg(redirect->filename, sizeof(redirect->filename), &p);
4581 q = strrchr(redirect->filename, '>');
4584 redirect->stream_type = STREAM_TYPE_REDIRECT;
4586 } else if (!av_strcasecmp(cmd, "URL")) {
4588 get_arg(redirect->feed_filename, sizeof(redirect->feed_filename), &p);
4589 } else if (!av_strcasecmp(cmd, "</Redirect>")) {
4591 ERROR("No corresponding <Redirect> for </Redirect>\n");
4593 if (!redirect->feed_filename[0]) {
4594 ERROR("No URL found for <Redirect>\n");
4598 } else if (!av_strcasecmp(cmd, "LoadModule")) {
4599 get_arg(arg, sizeof(arg), &p);
4603 ERROR("Module support not compiled into this version: '%s'\n", arg);
4606 ERROR("Incorrect keyword: '%s'\n", cmd);
4618 static void handle_child_exit(int sig)
4623 while ((pid = waitpid(-1, &status, WNOHANG)) > 0) {
4626 for (feed = first_feed; feed; feed = feed->next) {
4627 if (feed->pid == pid) {
4628 int uptime = time(0) - feed->pid_start;
4631 fprintf(stderr, "%s: Pid %d exited with status %d after %d seconds\n", feed->filename, pid, status, uptime);
4634 /* Turn off any more restarts */
4635 feed->child_argv = 0;
4640 need_to_start_children = 1;
4643 static void opt_debug(void)
4646 avserver_daemon = 0;
4647 logfilename[0] = '-';
4650 static void show_help(void)
4652 printf("usage: avserver [options]\n"
4653 "Hyper fast multi format Audio/Video streaming server\n");
4655 show_help_options(options, "Main options:\n", 0, 0);
4658 static const OptionDef options[] = {
4659 #include "cmdutils_common_opts.h"
4660 { "n", OPT_BOOL, {(void *)&no_launch }, "enable no-launch mode" },
4661 { "d", 0, {(void*)opt_debug}, "enable debug mode" },
4662 { "f", HAS_ARG | OPT_STRING, {(void*)&config_filename }, "use configfile instead of /etc/avserver.conf", "configfile" },
4666 int main(int argc, char **argv)
4668 struct sigaction sigact;
4670 parse_loglevel(argc, argv, options);
4672 avformat_network_init();
4676 my_program_name = argv[0];
4677 my_program_dir = getcwd(0, 0);
4678 avserver_daemon = 1;
4680 parse_options(NULL, argc, argv, options, NULL);
4682 unsetenv("http_proxy"); /* Kill the http_proxy */
4684 av_lfg_init(&random_state, av_get_random_seed());
4686 memset(&sigact, 0, sizeof(sigact));
4687 sigact.sa_handler = handle_child_exit;
4688 sigact.sa_flags = SA_NOCLDSTOP | SA_RESTART;
4689 sigaction(SIGCHLD, &sigact, 0);
4691 if (parse_ffconfig(config_filename) < 0) {
4692 fprintf(stderr, "Incorrect config file - exiting.\n");
4696 /* open log file if needed */
4697 if (logfilename[0] != '\0') {
4698 if (!strcmp(logfilename, "-"))
4701 logfile = fopen(logfilename, "a");
4702 av_log_set_callback(http_av_log);
4705 build_file_streams();
4707 build_feed_streams();
4709 compute_bandwidth();
4711 /* put the process in background and detach it from its TTY */
4712 if (avserver_daemon) {
4719 } else if (pid > 0) {
4726 open("/dev/null", O_RDWR);
4727 if (strcmp(logfilename, "-") != 0) {
4737 signal(SIGPIPE, SIG_IGN);
4739 if (avserver_daemon)
4742 if (http_server() < 0) {
4743 http_log("Could not start server\n");