2 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
4 * This file is part of FFmpeg.
6 * FFmpeg is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * FFmpeg is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with FFmpeg; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23 * multiple format streaming server based on the FFmpeg libraries
28 #define closesocket close
33 #include "libavformat/avformat.h"
34 // FIXME those are internal headers, ffserver _really_ shouldn't use them
35 #include "libavformat/ffm.h"
36 #include "libavformat/network.h"
37 #include "libavformat/os_support.h"
38 #include "libavformat/rtpdec.h"
39 #include "libavformat/rtpproto.h"
40 #include "libavformat/rtsp.h"
41 #include "libavformat/avio_internal.h"
42 #include "libavformat/internal.h"
43 #include "libavformat/url.h"
45 #include "libavutil/avassert.h"
46 #include "libavutil/avstring.h"
47 #include "libavutil/lfg.h"
48 #include "libavutil/dict.h"
49 #include "libavutil/intreadwrite.h"
50 #include "libavutil/mathematics.h"
51 #include "libavutil/pixdesc.h"
52 #include "libavutil/random_seed.h"
53 #include "libavutil/parseutils.h"
54 #include "libavutil/opt.h"
55 #include "libavutil/time.h"
60 #include <sys/ioctl.h>
71 const char program_name[] = "ffserver";
72 const int program_birth_year = 2000;
74 static const OptionDef options[];
77 HTTPSTATE_WAIT_REQUEST,
78 HTTPSTATE_SEND_HEADER,
79 HTTPSTATE_SEND_DATA_HEADER,
80 HTTPSTATE_SEND_DATA, /* sending TCP or UDP data */
81 HTTPSTATE_SEND_DATA_TRAILER,
82 HTTPSTATE_RECEIVE_DATA,
83 HTTPSTATE_WAIT_FEED, /* wait for data from the feed */
86 RTSPSTATE_WAIT_REQUEST,
88 RTSPSTATE_SEND_PACKET,
91 static const char *http_state[] = {
107 #define MAX_STREAMS 20
109 #define IOBUFFER_INIT_SIZE 8192
111 /* timeouts are in ms */
112 #define HTTP_REQUEST_TIMEOUT (15 * 1000)
113 #define RTSP_REQUEST_TIMEOUT (3600 * 24 * 1000)
115 #define SYNC_TIMEOUT (10 * 1000)
117 typedef struct RTSPActionServerSetup {
119 char transport_option[512];
120 } RTSPActionServerSetup;
123 int64_t count1, count2;
124 int64_t time1, time2;
127 /* context associated with one connection */
128 typedef struct HTTPContext {
129 enum HTTPState state;
130 int fd; /* socket file descriptor */
131 struct sockaddr_in from_addr; /* origin */
132 struct pollfd *poll_entry; /* used when polling */
134 uint8_t *buffer_ptr, *buffer_end;
137 int chunked_encoding;
138 int chunk_size; /* 0 if it needs to be read */
139 struct HTTPContext *next;
140 int got_key_frame; /* stream 0 => 1, stream 1 => 2, stream 2=> 4 */
144 /* input format handling */
145 AVFormatContext *fmt_in;
146 int64_t start_time; /* In milliseconds - this wraps fairly often */
147 int64_t first_pts; /* initial pts value */
148 int64_t cur_pts; /* current pts value from the stream in us */
149 int64_t cur_frame_duration; /* duration of the current frame in us */
150 int cur_frame_bytes; /* output frame size, needed to compute
151 the time at which we send each
153 int pts_stream_index; /* stream we choose as clock reference */
154 int64_t cur_clock; /* current clock reference value in us */
155 /* output format handling */
156 struct FFStream *stream;
157 /* -1 is invalid stream */
158 int feed_streams[MAX_STREAMS]; /* index of streams in the feed */
159 int switch_feed_streams[MAX_STREAMS]; /* index of streams in the feed */
161 AVFormatContext fmt_ctx; /* instance of FFStream for one user */
162 int last_packet_sent; /* true if last data packet was sent */
164 DataRateData datarate;
171 int is_packetized; /* if true, the stream is packetized */
172 int packet_stream_index; /* current stream for output in state machine */
174 /* RTSP state specific */
175 uint8_t *pb_buffer; /* XXX: use that in all the code */
177 int seq; /* RTSP sequence number */
179 /* RTP state specific */
180 enum RTSPLowerTransport rtp_protocol;
181 char session_id[32]; /* session id */
182 AVFormatContext *rtp_ctx[MAX_STREAMS];
184 /* RTP/UDP specific */
185 URLContext *rtp_handles[MAX_STREAMS];
187 /* RTP/TCP specific */
188 struct HTTPContext *rtsp_c;
189 uint8_t *packet_buffer, *packet_buffer_ptr, *packet_buffer_end;
192 /* each generated stream is described here */
196 STREAM_TYPE_REDIRECT,
199 enum IPAddressAction {
204 typedef struct IPAddressACL {
205 struct IPAddressACL *next;
206 enum IPAddressAction action;
207 /* These are in host order */
208 struct in_addr first;
212 /* description of each stream of the ffserver.conf file */
213 typedef struct FFStream {
214 enum StreamType stream_type;
215 char filename[1024]; /* stream filename */
216 struct FFStream *feed; /* feed we are using (can be null if
218 AVDictionary *in_opts; /* input parameters */
219 AVInputFormat *ifmt; /* if non NULL, force input format */
222 char dynamic_acl[1024];
224 int prebuffer; /* Number of millseconds early to start */
225 int64_t max_time; /* Number of milliseconds to run */
227 AVStream *streams[MAX_STREAMS];
228 int feed_streams[MAX_STREAMS]; /* index of streams in the feed */
229 char feed_filename[1024]; /* file name of the feed storage, or
230 input file name for a stream */
235 pid_t pid; /* Of ffmpeg process */
236 time_t pid_start; /* Of ffmpeg process */
238 struct FFStream *next;
239 unsigned bandwidth; /* bandwidth, in kbits/s */
242 /* multicast specific */
244 struct in_addr multicast_ip;
245 int multicast_port; /* first port used for multicast */
247 int loop; /* if true, send the stream in loops (only meaningful if file) */
250 int feed_opened; /* true if someone is writing to the feed */
251 int is_feed; /* true if it is a feed */
252 int readonly; /* True if writing is prohibited to the file */
253 int truncate; /* True if feeder connection truncate the feed file */
255 int64_t bytes_served;
256 int64_t feed_max_size; /* maximum storage size, zero means unlimited */
257 int64_t feed_write_index; /* current write position in feed (it wraps around) */
258 int64_t feed_size; /* current size of feed */
259 struct FFStream *next_feed;
262 typedef struct FeedData {
263 long long data_count;
264 float avg_frame_size; /* frame size averaged over last frames with exponential mean */
267 static struct sockaddr_in my_http_addr;
268 static struct sockaddr_in my_rtsp_addr;
270 static char logfilename[1024];
271 static HTTPContext *first_http_ctx;
272 static FFStream *first_feed; /* contains only feeds */
273 static FFStream *first_stream; /* contains all streams, including feeds */
275 static void new_connection(int server_fd, int is_rtsp);
276 static void close_connection(HTTPContext *c);
279 static int handle_connection(HTTPContext *c);
280 static int http_parse_request(HTTPContext *c);
281 static int http_send_data(HTTPContext *c);
282 static void compute_status(HTTPContext *c);
283 static int open_input_stream(HTTPContext *c, const char *info);
284 static int http_start_receive_data(HTTPContext *c);
285 static int http_receive_data(HTTPContext *c);
288 static int rtsp_parse_request(HTTPContext *c);
289 static void rtsp_cmd_describe(HTTPContext *c, const char *url);
290 static void rtsp_cmd_options(HTTPContext *c, const char *url);
291 static void rtsp_cmd_setup(HTTPContext *c, const char *url, RTSPMessageHeader *h);
292 static void rtsp_cmd_play(HTTPContext *c, const char *url, RTSPMessageHeader *h);
293 static void rtsp_cmd_pause(HTTPContext *c, const char *url, RTSPMessageHeader *h);
294 static void rtsp_cmd_teardown(HTTPContext *c, const char *url, RTSPMessageHeader *h);
297 static int prepare_sdp_description(FFStream *stream, uint8_t **pbuffer,
298 struct in_addr my_ip);
301 static HTTPContext *rtp_new_connection(struct sockaddr_in *from_addr,
302 FFStream *stream, const char *session_id,
303 enum RTSPLowerTransport rtp_protocol);
304 static int rtp_new_av_stream(HTTPContext *c,
305 int stream_index, struct sockaddr_in *dest_addr,
306 HTTPContext *rtsp_c);
308 static const char *my_program_name;
310 static const char *config_filename;
312 static int ffserver_debug;
313 static int no_launch;
314 static int need_to_start_children;
316 /* maximum number of simultaneous HTTP connections */
317 static unsigned int nb_max_http_connections = 2000;
318 static unsigned int nb_max_connections = 5;
319 static unsigned int nb_connections;
321 static uint64_t max_bandwidth = 1000;
322 static uint64_t current_bandwidth;
324 static int64_t cur_time; // Making this global saves on passing it around everywhere
326 static AVLFG random_state;
328 static FILE *logfile = NULL;
330 static void htmlstrip(char *s) {
332 s += strspn(s, "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ,. ");
338 static int64_t ffm_read_write_index(int fd)
342 if (lseek(fd, 8, SEEK_SET) < 0)
344 if (read(fd, buf, 8) != 8)
349 static int ffm_write_write_index(int fd, int64_t pos)
355 buf[i] = (pos >> (56 - i * 8)) & 0xff;
356 if (lseek(fd, 8, SEEK_SET) < 0)
358 if (write(fd, buf, 8) != 8)
363 static void ffm_set_write_index(AVFormatContext *s, int64_t pos,
366 FFMContext *ffm = s->priv_data;
367 ffm->write_index = pos;
368 ffm->file_size = file_size;
371 /* FIXME: make ffserver work with IPv6 */
372 /* resolve host with also IP address parsing */
373 static int resolve_host(struct in_addr *sin_addr, const char *hostname)
376 if (!ff_inet_aton(hostname, sin_addr)) {
378 struct addrinfo *ai, *cur;
379 struct addrinfo hints = { 0 };
380 hints.ai_family = AF_INET;
381 if (getaddrinfo(hostname, NULL, &hints, &ai))
383 /* getaddrinfo returns a linked list of addrinfo structs.
384 * Even if we set ai_family = AF_INET above, make sure
385 * that the returned one actually is of the correct type. */
386 for (cur = ai; cur; cur = cur->ai_next) {
387 if (cur->ai_family == AF_INET) {
388 *sin_addr = ((struct sockaddr_in *)cur->ai_addr)->sin_addr;
397 hp = gethostbyname(hostname);
400 memcpy(sin_addr, hp->h_addr_list[0], sizeof(struct in_addr));
406 static char *ctime1(char *buf2, int buf_size)
413 av_strlcpy(buf2, p, buf_size);
414 p = buf2 + strlen(p) - 1;
420 static void http_vlog(const char *fmt, va_list vargs)
422 static int print_prefix = 1;
426 ctime1(buf, sizeof(buf));
427 fprintf(logfile, "%s ", buf);
429 print_prefix = strstr(fmt, "\n") != NULL;
430 vfprintf(logfile, fmt, vargs);
436 __attribute__ ((format (printf, 1, 2)))
438 static void http_log(const char *fmt, ...)
441 va_start(vargs, fmt);
442 http_vlog(fmt, vargs);
446 static void http_av_log(void *ptr, int level, const char *fmt, va_list vargs)
448 static int print_prefix = 1;
449 AVClass *avc = ptr ? *(AVClass**)ptr : NULL;
450 if (level > av_log_get_level())
452 if (print_prefix && avc)
453 http_log("[%s @ %p]", avc->item_name(ptr), ptr);
454 print_prefix = strstr(fmt, "\n") != NULL;
455 http_vlog(fmt, vargs);
458 static void log_connection(HTTPContext *c)
463 http_log("%s - - [%s] \"%s %s\" %d %"PRId64"\n",
464 inet_ntoa(c->from_addr.sin_addr), c->method, c->url,
465 c->protocol, (c->http_error ? c->http_error : 200), c->data_count);
468 static void update_datarate(DataRateData *drd, int64_t count)
470 if (!drd->time1 && !drd->count1) {
471 drd->time1 = drd->time2 = cur_time;
472 drd->count1 = drd->count2 = count;
473 } else if (cur_time - drd->time2 > 5000) {
474 drd->time1 = drd->time2;
475 drd->count1 = drd->count2;
476 drd->time2 = cur_time;
481 /* In bytes per second */
482 static int compute_datarate(DataRateData *drd, int64_t count)
484 if (cur_time == drd->time1)
487 return ((count - drd->count1) * 1000) / (cur_time - drd->time1);
491 static void start_children(FFStream *feed)
496 for (; feed; feed = feed->next) {
497 if (feed->child_argv && !feed->pid) {
498 feed->pid_start = time(0);
503 http_log("Unable to create children\n");
512 av_strlcpy(pathname, my_program_name, sizeof(pathname));
514 slash = strrchr(pathname, '/');
519 strcpy(slash, "ffmpeg");
521 http_log("Launch command line: ");
522 http_log("%s ", pathname);
523 for (i = 1; feed->child_argv[i] && feed->child_argv[i][0]; i++)
524 http_log("%s ", feed->child_argv[i]);
527 for (i = 3; i < 256; i++)
530 if (!ffserver_debug) {
531 if (!freopen("/dev/null", "r", stdin))
532 http_log("failed to redirect STDIN to /dev/null\n;");
533 if (!freopen("/dev/null", "w", stdout))
534 http_log("failed to redirect STDOUT to /dev/null\n;");
535 if (!freopen("/dev/null", "w", stderr))
536 http_log("failed to redirect STDERR to /dev/null\n;");
539 signal(SIGPIPE, SIG_DFL);
541 execvp(pathname, feed->child_argv);
549 /* open a listening socket */
550 static int socket_open_listen(struct sockaddr_in *my_addr)
554 server_fd = socket(AF_INET,SOCK_STREAM,0);
561 setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &tmp, sizeof(tmp));
563 my_addr->sin_family = AF_INET;
564 if (bind (server_fd, (struct sockaddr *) my_addr, sizeof (*my_addr)) < 0) {
566 snprintf(bindmsg, sizeof(bindmsg), "bind(port %d)", ntohs(my_addr->sin_port));
568 closesocket(server_fd);
572 if (listen (server_fd, 5) < 0) {
574 closesocket(server_fd);
577 ff_socket_nonblock(server_fd, 1);
582 /* start all multicast streams */
583 static void start_multicast(void)
588 struct sockaddr_in dest_addr = {0};
589 int default_port, stream_index;
592 for(stream = first_stream; stream != NULL; stream = stream->next) {
593 if (stream->is_multicast) {
594 unsigned random0 = av_lfg_get(&random_state);
595 unsigned random1 = av_lfg_get(&random_state);
596 /* open the RTP connection */
597 snprintf(session_id, sizeof(session_id), "%08x%08x",
600 /* choose a port if none given */
601 if (stream->multicast_port == 0) {
602 stream->multicast_port = default_port;
606 dest_addr.sin_family = AF_INET;
607 dest_addr.sin_addr = stream->multicast_ip;
608 dest_addr.sin_port = htons(stream->multicast_port);
610 rtp_c = rtp_new_connection(&dest_addr, stream, session_id,
611 RTSP_LOWER_TRANSPORT_UDP_MULTICAST);
615 if (open_input_stream(rtp_c, "") < 0) {
616 http_log("Could not open input stream for stream '%s'\n",
621 /* open each RTP stream */
622 for(stream_index = 0; stream_index < stream->nb_streams;
624 dest_addr.sin_port = htons(stream->multicast_port +
626 if (rtp_new_av_stream(rtp_c, stream_index, &dest_addr, NULL) < 0) {
627 http_log("Could not open output stream '%s/streamid=%d'\n",
628 stream->filename, stream_index);
633 /* change state to send data */
634 rtp_c->state = HTTPSTATE_SEND_DATA;
639 /* main loop of the http server */
640 static int http_server(void)
642 int server_fd = 0, rtsp_server_fd = 0;
643 int ret, delay, delay1;
644 struct pollfd *poll_table, *poll_entry;
645 HTTPContext *c, *c_next;
647 if(!(poll_table = av_mallocz((nb_max_http_connections + 2)*sizeof(*poll_table)))) {
648 http_log("Impossible to allocate a poll table handling %d connections.\n", nb_max_http_connections);
652 if (my_http_addr.sin_port) {
653 server_fd = socket_open_listen(&my_http_addr);
658 if (my_rtsp_addr.sin_port) {
659 rtsp_server_fd = socket_open_listen(&my_rtsp_addr);
660 if (rtsp_server_fd < 0)
664 if (!rtsp_server_fd && !server_fd) {
665 http_log("HTTP and RTSP disabled.\n");
669 http_log("FFserver started.\n");
671 start_children(first_feed);
676 poll_entry = poll_table;
678 poll_entry->fd = server_fd;
679 poll_entry->events = POLLIN;
682 if (rtsp_server_fd) {
683 poll_entry->fd = rtsp_server_fd;
684 poll_entry->events = POLLIN;
688 /* wait for events on each HTTP handle */
695 case HTTPSTATE_SEND_HEADER:
696 case RTSPSTATE_SEND_REPLY:
697 case RTSPSTATE_SEND_PACKET:
698 c->poll_entry = poll_entry;
700 poll_entry->events = POLLOUT;
703 case HTTPSTATE_SEND_DATA_HEADER:
704 case HTTPSTATE_SEND_DATA:
705 case HTTPSTATE_SEND_DATA_TRAILER:
706 if (!c->is_packetized) {
707 /* for TCP, we output as much as we can (may need to put a limit) */
708 c->poll_entry = poll_entry;
710 poll_entry->events = POLLOUT;
713 /* when ffserver is doing the timing, we work by
714 looking at which packet need to be sent every
716 delay1 = 10; /* one tick wait XXX: 10 ms assumed */
721 case HTTPSTATE_WAIT_REQUEST:
722 case HTTPSTATE_RECEIVE_DATA:
723 case HTTPSTATE_WAIT_FEED:
724 case RTSPSTATE_WAIT_REQUEST:
725 /* need to catch errors */
726 c->poll_entry = poll_entry;
728 poll_entry->events = POLLIN;/* Maybe this will work */
732 c->poll_entry = NULL;
738 /* wait for an event on one connection. We poll at least every
739 second to handle timeouts */
741 ret = poll(poll_table, poll_entry - poll_table, delay);
742 if (ret < 0 && ff_neterrno() != AVERROR(EAGAIN) &&
743 ff_neterrno() != AVERROR(EINTR))
747 cur_time = av_gettime() / 1000;
749 if (need_to_start_children) {
750 need_to_start_children = 0;
751 start_children(first_feed);
754 /* now handle the events */
755 for(c = first_http_ctx; c != NULL; c = c_next) {
757 if (handle_connection(c) < 0) {
758 /* close and free the connection */
764 poll_entry = poll_table;
766 /* new HTTP connection request ? */
767 if (poll_entry->revents & POLLIN)
768 new_connection(server_fd, 0);
771 if (rtsp_server_fd) {
772 /* new RTSP connection request ? */
773 if (poll_entry->revents & POLLIN)
774 new_connection(rtsp_server_fd, 1);
779 /* start waiting for a new HTTP/RTSP request */
780 static void start_wait_request(HTTPContext *c, int is_rtsp)
782 c->buffer_ptr = c->buffer;
783 c->buffer_end = c->buffer + c->buffer_size - 1; /* leave room for '\0' */
786 c->timeout = cur_time + RTSP_REQUEST_TIMEOUT;
787 c->state = RTSPSTATE_WAIT_REQUEST;
789 c->timeout = cur_time + HTTP_REQUEST_TIMEOUT;
790 c->state = HTTPSTATE_WAIT_REQUEST;
794 static void http_send_too_busy_reply(int fd)
797 int len = snprintf(buffer, sizeof(buffer),
798 "HTTP/1.0 503 Server too busy\r\n"
799 "Content-type: text/html\r\n"
801 "<html><head><title>Too busy</title></head><body>\r\n"
802 "<p>The server is too busy to serve your request at this time.</p>\r\n"
803 "<p>The number of current connections is %u, and this exceeds the limit of %u.</p>\r\n"
804 "</body></html>\r\n",
805 nb_connections, nb_max_connections);
806 av_assert0(len < sizeof(buffer));
807 send(fd, buffer, len, 0);
811 static void new_connection(int server_fd, int is_rtsp)
813 struct sockaddr_in from_addr;
816 HTTPContext *c = NULL;
818 len = sizeof(from_addr);
819 fd = accept(server_fd, (struct sockaddr *)&from_addr,
822 http_log("error during accept %s\n", strerror(errno));
825 ff_socket_nonblock(fd, 1);
827 if (nb_connections >= nb_max_connections) {
828 http_send_too_busy_reply(fd);
832 /* add a new connection */
833 c = av_mallocz(sizeof(HTTPContext));
838 c->poll_entry = NULL;
839 c->from_addr = from_addr;
840 c->buffer_size = IOBUFFER_INIT_SIZE;
841 c->buffer = av_malloc(c->buffer_size);
845 c->next = first_http_ctx;
849 start_wait_request(c, is_rtsp);
861 static void close_connection(HTTPContext *c)
863 HTTPContext **cp, *c1;
865 AVFormatContext *ctx;
869 /* remove connection from list */
870 cp = &first_http_ctx;
871 while ((*cp) != NULL) {
879 /* remove references, if any (XXX: do it faster) */
880 for(c1 = first_http_ctx; c1 != NULL; c1 = c1->next) {
885 /* remove connection associated resources */
889 /* close each frame parser */
890 for(i=0;i<c->fmt_in->nb_streams;i++) {
891 st = c->fmt_in->streams[i];
892 if (st->codec->codec)
893 avcodec_close(st->codec);
895 avformat_close_input(&c->fmt_in);
898 /* free RTP output streams if any */
901 nb_streams = c->stream->nb_streams;
903 for(i=0;i<nb_streams;i++) {
906 av_write_trailer(ctx);
907 av_dict_free(&ctx->metadata);
908 av_free(ctx->streams[0]);
911 h = c->rtp_handles[i];
918 if (!c->last_packet_sent && c->state == HTTPSTATE_SEND_DATA_TRAILER) {
921 if (avio_open_dyn_buf(&ctx->pb) >= 0) {
922 av_write_trailer(ctx);
923 av_freep(&c->pb_buffer);
924 avio_close_dyn_buf(ctx->pb, &c->pb_buffer);
929 for(i=0; i<ctx->nb_streams; i++)
930 av_free(ctx->streams[i]);
931 av_freep(&ctx->streams);
932 av_freep(&ctx->priv_data);
934 if (c->stream && !c->post && c->stream->stream_type == STREAM_TYPE_LIVE)
935 current_bandwidth -= c->stream->bandwidth;
937 /* signal that there is no feed if we are the feeder socket */
938 if (c->state == HTTPSTATE_RECEIVE_DATA && c->stream) {
939 c->stream->feed_opened = 0;
943 av_freep(&c->pb_buffer);
944 av_freep(&c->packet_buffer);
950 static int handle_connection(HTTPContext *c)
955 case HTTPSTATE_WAIT_REQUEST:
956 case RTSPSTATE_WAIT_REQUEST:
958 if ((c->timeout - cur_time) < 0)
960 if (c->poll_entry->revents & (POLLERR | POLLHUP))
963 /* no need to read if no events */
964 if (!(c->poll_entry->revents & POLLIN))
968 len = recv(c->fd, c->buffer_ptr, 1, 0);
970 if (ff_neterrno() != AVERROR(EAGAIN) &&
971 ff_neterrno() != AVERROR(EINTR))
973 } else if (len == 0) {
976 /* search for end of request. */
978 c->buffer_ptr += len;
980 if ((ptr >= c->buffer + 2 && !memcmp(ptr-2, "\n\n", 2)) ||
981 (ptr >= c->buffer + 4 && !memcmp(ptr-4, "\r\n\r\n", 4))) {
982 /* request found : parse it and reply */
983 if (c->state == HTTPSTATE_WAIT_REQUEST) {
984 ret = http_parse_request(c);
986 ret = rtsp_parse_request(c);
990 } else if (ptr >= c->buffer_end) {
991 /* request too long: cannot do anything */
993 } else goto read_loop;
997 case HTTPSTATE_SEND_HEADER:
998 if (c->poll_entry->revents & (POLLERR | POLLHUP))
1001 /* no need to write if no events */
1002 if (!(c->poll_entry->revents & POLLOUT))
1004 len = send(c->fd, c->buffer_ptr, c->buffer_end - c->buffer_ptr, 0);
1006 if (ff_neterrno() != AVERROR(EAGAIN) &&
1007 ff_neterrno() != AVERROR(EINTR)) {
1008 /* error : close connection */
1009 av_freep(&c->pb_buffer);
1013 c->buffer_ptr += len;
1015 c->stream->bytes_served += len;
1016 c->data_count += len;
1017 if (c->buffer_ptr >= c->buffer_end) {
1018 av_freep(&c->pb_buffer);
1019 /* if error, exit */
1022 /* all the buffer was sent : synchronize to the incoming stream */
1023 c->state = HTTPSTATE_SEND_DATA_HEADER;
1024 c->buffer_ptr = c->buffer_end = c->buffer;
1029 case HTTPSTATE_SEND_DATA:
1030 case HTTPSTATE_SEND_DATA_HEADER:
1031 case HTTPSTATE_SEND_DATA_TRAILER:
1032 /* for packetized output, we consider we can always write (the
1033 input streams sets the speed). It may be better to verify
1034 that we do not rely too much on the kernel queues */
1035 if (!c->is_packetized) {
1036 if (c->poll_entry->revents & (POLLERR | POLLHUP))
1039 /* no need to read if no events */
1040 if (!(c->poll_entry->revents & POLLOUT))
1043 if (http_send_data(c) < 0)
1045 /* close connection if trailer sent */
1046 if (c->state == HTTPSTATE_SEND_DATA_TRAILER)
1049 case HTTPSTATE_RECEIVE_DATA:
1050 /* no need to read if no events */
1051 if (c->poll_entry->revents & (POLLERR | POLLHUP))
1053 if (!(c->poll_entry->revents & POLLIN))
1055 if (http_receive_data(c) < 0)
1058 case HTTPSTATE_WAIT_FEED:
1059 /* no need to read if no events */
1060 if (c->poll_entry->revents & (POLLIN | POLLERR | POLLHUP))
1063 /* nothing to do, we'll be waken up by incoming feed packets */
1066 case RTSPSTATE_SEND_REPLY:
1067 if (c->poll_entry->revents & (POLLERR | POLLHUP)) {
1068 av_freep(&c->pb_buffer);
1071 /* no need to write if no events */
1072 if (!(c->poll_entry->revents & POLLOUT))
1074 len = send(c->fd, c->buffer_ptr, c->buffer_end - c->buffer_ptr, 0);
1076 if (ff_neterrno() != AVERROR(EAGAIN) &&
1077 ff_neterrno() != AVERROR(EINTR)) {
1078 /* error : close connection */
1079 av_freep(&c->pb_buffer);
1083 c->buffer_ptr += len;
1084 c->data_count += len;
1085 if (c->buffer_ptr >= c->buffer_end) {
1086 /* all the buffer was sent : wait for a new request */
1087 av_freep(&c->pb_buffer);
1088 start_wait_request(c, 1);
1092 case RTSPSTATE_SEND_PACKET:
1093 if (c->poll_entry->revents & (POLLERR | POLLHUP)) {
1094 av_freep(&c->packet_buffer);
1097 /* no need to write if no events */
1098 if (!(c->poll_entry->revents & POLLOUT))
1100 len = send(c->fd, c->packet_buffer_ptr,
1101 c->packet_buffer_end - c->packet_buffer_ptr, 0);
1103 if (ff_neterrno() != AVERROR(EAGAIN) &&
1104 ff_neterrno() != AVERROR(EINTR)) {
1105 /* error : close connection */
1106 av_freep(&c->packet_buffer);
1110 c->packet_buffer_ptr += len;
1111 if (c->packet_buffer_ptr >= c->packet_buffer_end) {
1112 /* all the buffer was sent : wait for a new request */
1113 av_freep(&c->packet_buffer);
1114 c->state = RTSPSTATE_WAIT_REQUEST;
1118 case HTTPSTATE_READY:
1127 static int extract_rates(char *rates, int ratelen, const char *request)
1131 for (p = request; *p && *p != '\r' && *p != '\n'; ) {
1132 if (av_strncasecmp(p, "Pragma:", 7) == 0) {
1133 const char *q = p + 7;
1135 while (*q && *q != '\n' && av_isspace(*q))
1138 if (av_strncasecmp(q, "stream-switch-entry=", 20) == 0) {
1144 memset(rates, 0xff, ratelen);
1147 while (*q && *q != '\n' && *q != ':')
1150 if (sscanf(q, ":%d:%d", &stream_no, &rate_no) != 2)
1154 if (stream_no < ratelen && stream_no >= 0)
1155 rates[stream_no] = rate_no;
1157 while (*q && *q != '\n' && !av_isspace(*q))
1164 p = strchr(p, '\n');
1174 static int find_stream_in_feed(FFStream *feed, AVCodecContext *codec, int bit_rate)
1177 int best_bitrate = 100000000;
1180 for (i = 0; i < feed->nb_streams; i++) {
1181 AVCodecContext *feed_codec = feed->streams[i]->codec;
1183 if (feed_codec->codec_id != codec->codec_id ||
1184 feed_codec->sample_rate != codec->sample_rate ||
1185 feed_codec->width != codec->width ||
1186 feed_codec->height != codec->height)
1189 /* Potential stream */
1191 /* We want the fastest stream less than bit_rate, or the slowest
1192 * faster than bit_rate
1195 if (feed_codec->bit_rate <= bit_rate) {
1196 if (best_bitrate > bit_rate || feed_codec->bit_rate > best_bitrate) {
1197 best_bitrate = feed_codec->bit_rate;
1201 if (feed_codec->bit_rate < best_bitrate) {
1202 best_bitrate = feed_codec->bit_rate;
1211 static int modify_current_stream(HTTPContext *c, char *rates)
1214 FFStream *req = c->stream;
1215 int action_required = 0;
1217 /* Not much we can do for a feed */
1221 for (i = 0; i < req->nb_streams; i++) {
1222 AVCodecContext *codec = req->streams[i]->codec;
1226 c->switch_feed_streams[i] = req->feed_streams[i];
1229 c->switch_feed_streams[i] = find_stream_in_feed(req->feed, codec, codec->bit_rate / 2);
1232 /* Wants off or slow */
1233 c->switch_feed_streams[i] = find_stream_in_feed(req->feed, codec, codec->bit_rate / 4);
1235 /* This doesn't work well when it turns off the only stream! */
1236 c->switch_feed_streams[i] = -2;
1237 c->feed_streams[i] = -2;
1242 if (c->switch_feed_streams[i] >= 0 && c->switch_feed_streams[i] != c->feed_streams[i])
1243 action_required = 1;
1246 return action_required;
1249 /* XXX: factorize in utils.c ? */
1250 /* XXX: take care with different space meaning */
1251 static void skip_spaces(const char **pp)
1255 while (*p == ' ' || *p == '\t')
1260 static void get_word(char *buf, int buf_size, const char **pp)
1268 while (!av_isspace(*p) && *p != '\0') {
1269 if ((q - buf) < buf_size - 1)
1278 static void get_arg(char *buf, int buf_size, const char **pp)
1285 while (av_isspace(*p)) p++;
1288 if (*p == '\"' || *p == '\'')
1300 if ((q - buf) < buf_size - 1)
1305 if (quote && *p == quote)
1310 static void parse_acl_row(FFStream *stream, FFStream* feed, IPAddressACL *ext_acl,
1311 const char *p, const char *filename, int line_num)
1317 get_arg(arg, sizeof(arg), &p);
1318 if (av_strcasecmp(arg, "allow") == 0)
1319 acl.action = IP_ALLOW;
1320 else if (av_strcasecmp(arg, "deny") == 0)
1321 acl.action = IP_DENY;
1323 fprintf(stderr, "%s:%d: ACL action '%s' is not ALLOW or DENY\n",
1324 filename, line_num, arg);
1328 get_arg(arg, sizeof(arg), &p);
1330 if (resolve_host(&acl.first, arg) != 0) {
1331 fprintf(stderr, "%s:%d: ACL refers to invalid host or ip address '%s'\n",
1332 filename, line_num, arg);
1335 acl.last = acl.first;
1337 get_arg(arg, sizeof(arg), &p);
1340 if (resolve_host(&acl.last, arg) != 0) {
1341 fprintf(stderr, "%s:%d: ACL refers to invalid host or ip address '%s'\n",
1342 filename, line_num, arg);
1348 IPAddressACL *nacl = av_mallocz(sizeof(*nacl));
1349 IPAddressACL **naclp = 0;
1355 naclp = &stream->acl;
1361 fprintf(stderr, "%s:%d: ACL found not in <stream> or <feed>\n",
1362 filename, line_num);
1368 naclp = &(*naclp)->next;
1376 static IPAddressACL* parse_dynamic_acl(FFStream *stream, HTTPContext *c)
1381 IPAddressACL *acl = NULL;
1385 f = fopen(stream->dynamic_acl, "r");
1387 perror(stream->dynamic_acl);
1391 acl = av_mallocz(sizeof(IPAddressACL));
1395 if (fgets(line, sizeof(line), f) == NULL)
1399 while (av_isspace(*p))
1401 if (*p == '\0' || *p == '#')
1403 get_arg(cmd, sizeof(cmd), &p);
1405 if (!av_strcasecmp(cmd, "ACL"))
1406 parse_acl_row(NULL, NULL, acl, p, stream->dynamic_acl, line_num);
1413 static void free_acl_list(IPAddressACL *in_acl)
1415 IPAddressACL *pacl,*pacl2;
1425 static int validate_acl_list(IPAddressACL *in_acl, HTTPContext *c)
1427 enum IPAddressAction last_action = IP_DENY;
1429 struct in_addr *src = &c->from_addr.sin_addr;
1430 unsigned long src_addr = src->s_addr;
1432 for (acl = in_acl; acl; acl = acl->next) {
1433 if (src_addr >= acl->first.s_addr && src_addr <= acl->last.s_addr)
1434 return (acl->action == IP_ALLOW) ? 1 : 0;
1435 last_action = acl->action;
1438 /* Nothing matched, so return not the last action */
1439 return (last_action == IP_DENY) ? 1 : 0;
1442 static int validate_acl(FFStream *stream, HTTPContext *c)
1448 /* if stream->acl is null validate_acl_list will return 1 */
1449 ret = validate_acl_list(stream->acl, c);
1451 if (stream->dynamic_acl[0]) {
1452 acl = parse_dynamic_acl(stream, c);
1454 ret = validate_acl_list(acl, c);
1462 /* compute the real filename of a file by matching it without its
1463 extensions to all the stream filenames */
1464 static void compute_real_filename(char *filename, int max_size)
1471 /* compute filename by matching without the file extensions */
1472 av_strlcpy(file1, filename, sizeof(file1));
1473 p = strrchr(file1, '.');
1476 for(stream = first_stream; stream != NULL; stream = stream->next) {
1477 av_strlcpy(file2, stream->filename, sizeof(file2));
1478 p = strrchr(file2, '.');
1481 if (!strcmp(file1, file2)) {
1482 av_strlcpy(filename, stream->filename, max_size);
1497 /* parse http request and prepare header */
1498 static int http_parse_request(HTTPContext *c)
1502 enum RedirType redir_type;
1504 char info[1024], filename[1024];
1508 const char *mime_type;
1512 const char *useragent = 0;
1515 get_word(cmd, sizeof(cmd), &p);
1516 av_strlcpy(c->method, cmd, sizeof(c->method));
1518 if (!strcmp(cmd, "GET"))
1520 else if (!strcmp(cmd, "POST"))
1525 get_word(url, sizeof(url), &p);
1526 av_strlcpy(c->url, url, sizeof(c->url));
1528 get_word(protocol, sizeof(protocol), (const char **)&p);
1529 if (strcmp(protocol, "HTTP/1.0") && strcmp(protocol, "HTTP/1.1"))
1532 av_strlcpy(c->protocol, protocol, sizeof(c->protocol));
1535 http_log("%s - - New connection: %s %s\n", inet_ntoa(c->from_addr.sin_addr), cmd, url);
1537 /* find the filename and the optional info string in the request */
1538 p1 = strchr(url, '?');
1540 av_strlcpy(info, p1, sizeof(info));
1545 av_strlcpy(filename, url + ((*url == '/') ? 1 : 0), sizeof(filename)-1);
1547 for (p = c->buffer; *p && *p != '\r' && *p != '\n'; ) {
1548 if (av_strncasecmp(p, "User-Agent:", 11) == 0) {
1550 if (*useragent && *useragent != '\n' && av_isspace(*useragent))
1554 p = strchr(p, '\n');
1561 redir_type = REDIR_NONE;
1562 if (av_match_ext(filename, "asx")) {
1563 redir_type = REDIR_ASX;
1564 filename[strlen(filename)-1] = 'f';
1565 } else if (av_match_ext(filename, "asf") &&
1566 (!useragent || av_strncasecmp(useragent, "NSPlayer", 8) != 0)) {
1567 /* if this isn't WMP or lookalike, return the redirector file */
1568 redir_type = REDIR_ASF;
1569 } else if (av_match_ext(filename, "rpm,ram")) {
1570 redir_type = REDIR_RAM;
1571 strcpy(filename + strlen(filename)-2, "m");
1572 } else if (av_match_ext(filename, "rtsp")) {
1573 redir_type = REDIR_RTSP;
1574 compute_real_filename(filename, sizeof(filename) - 1);
1575 } else if (av_match_ext(filename, "sdp")) {
1576 redir_type = REDIR_SDP;
1577 compute_real_filename(filename, sizeof(filename) - 1);
1580 // "redirect" / request to index.html
1581 if (!strlen(filename))
1582 av_strlcpy(filename, "index.html", sizeof(filename) - 1);
1584 stream = first_stream;
1585 while (stream != NULL) {
1586 if (!strcmp(stream->filename, filename) && validate_acl(stream, c))
1588 stream = stream->next;
1590 if (stream == NULL) {
1591 snprintf(msg, sizeof(msg), "File '%s' not found", url);
1592 http_log("File '%s' not found\n", url);
1597 memcpy(c->feed_streams, stream->feed_streams, sizeof(c->feed_streams));
1598 memset(c->switch_feed_streams, -1, sizeof(c->switch_feed_streams));
1600 if (stream->stream_type == STREAM_TYPE_REDIRECT) {
1601 c->http_error = 301;
1603 snprintf(q, c->buffer_size,
1604 "HTTP/1.0 301 Moved\r\n"
1606 "Content-type: text/html\r\n"
1608 "<html><head><title>Moved</title></head><body>\r\n"
1609 "You should be <a href=\"%s\">redirected</a>.\r\n"
1610 "</body></html>\r\n", stream->feed_filename, stream->feed_filename);
1612 /* prepare output buffer */
1613 c->buffer_ptr = c->buffer;
1615 c->state = HTTPSTATE_SEND_HEADER;
1619 /* If this is WMP, get the rate information */
1620 if (extract_rates(ratebuf, sizeof(ratebuf), c->buffer)) {
1621 if (modify_current_stream(c, ratebuf)) {
1622 for (i = 0; i < FF_ARRAY_ELEMS(c->feed_streams); i++) {
1623 if (c->switch_feed_streams[i] >= 0)
1624 c->switch_feed_streams[i] = -1;
1629 if (c->post == 0 && stream->stream_type == STREAM_TYPE_LIVE)
1630 current_bandwidth += stream->bandwidth;
1632 /* If already streaming this feed, do not let start another feeder. */
1633 if (stream->feed_opened) {
1634 snprintf(msg, sizeof(msg), "This feed is already being received.");
1635 http_log("Feed '%s' already being received\n", stream->feed_filename);
1639 if (c->post == 0 && max_bandwidth < current_bandwidth) {
1640 c->http_error = 503;
1642 snprintf(q, c->buffer_size,
1643 "HTTP/1.0 503 Server too busy\r\n"
1644 "Content-type: text/html\r\n"
1646 "<html><head><title>Too busy</title></head><body>\r\n"
1647 "<p>The server is too busy to serve your request at this time.</p>\r\n"
1648 "<p>The bandwidth being served (including your stream) is %"PRIu64"kbit/sec, "
1649 "and this exceeds the limit of %"PRIu64"kbit/sec.</p>\r\n"
1650 "</body></html>\r\n", current_bandwidth, max_bandwidth);
1652 /* prepare output buffer */
1653 c->buffer_ptr = c->buffer;
1655 c->state = HTTPSTATE_SEND_HEADER;
1659 if (redir_type != REDIR_NONE) {
1660 const char *hostinfo = 0;
1662 for (p = c->buffer; *p && *p != '\r' && *p != '\n'; ) {
1663 if (av_strncasecmp(p, "Host:", 5) == 0) {
1667 p = strchr(p, '\n');
1678 while (av_isspace(*hostinfo))
1681 eoh = strchr(hostinfo, '\n');
1683 if (eoh[-1] == '\r')
1686 if (eoh - hostinfo < sizeof(hostbuf) - 1) {
1687 memcpy(hostbuf, hostinfo, eoh - hostinfo);
1688 hostbuf[eoh - hostinfo] = 0;
1690 c->http_error = 200;
1692 switch(redir_type) {
1694 snprintf(q, c->buffer_size,
1695 "HTTP/1.0 200 ASX Follows\r\n"
1696 "Content-type: video/x-ms-asf\r\n"
1698 "<ASX Version=\"3\">\r\n"
1699 //"<!-- Autogenerated by ffserver -->\r\n"
1700 "<ENTRY><REF HREF=\"http://%s/%s%s\"/></ENTRY>\r\n"
1701 "</ASX>\r\n", hostbuf, filename, info);
1705 snprintf(q, c->buffer_size,
1706 "HTTP/1.0 200 RAM Follows\r\n"
1707 "Content-type: audio/x-pn-realaudio\r\n"
1709 "# Autogenerated by ffserver\r\n"
1710 "http://%s/%s%s\r\n", hostbuf, filename, info);
1714 snprintf(q, c->buffer_size,
1715 "HTTP/1.0 200 ASF Redirect follows\r\n"
1716 "Content-type: video/x-ms-asf\r\n"
1719 "Ref1=http://%s/%s%s\r\n", hostbuf, filename, info);
1724 char hostname[256], *p;
1725 /* extract only hostname */
1726 av_strlcpy(hostname, hostbuf, sizeof(hostname));
1727 p = strrchr(hostname, ':');
1730 snprintf(q, c->buffer_size,
1731 "HTTP/1.0 200 RTSP Redirect follows\r\n"
1732 /* XXX: incorrect mime type ? */
1733 "Content-type: application/x-rtsp\r\n"
1735 "rtsp://%s:%d/%s\r\n", hostname, ntohs(my_rtsp_addr.sin_port), filename);
1744 struct sockaddr_in my_addr;
1746 snprintf(q, c->buffer_size,
1747 "HTTP/1.0 200 OK\r\n"
1748 "Content-type: application/sdp\r\n"
1752 len = sizeof(my_addr);
1753 getsockname(c->fd, (struct sockaddr *)&my_addr, &len);
1755 /* XXX: should use a dynamic buffer */
1756 sdp_data_size = prepare_sdp_description(stream,
1759 if (sdp_data_size > 0) {
1760 memcpy(q, sdp_data, sdp_data_size);
1772 /* prepare output buffer */
1773 c->buffer_ptr = c->buffer;
1775 c->state = HTTPSTATE_SEND_HEADER;
1781 snprintf(msg, sizeof(msg), "ASX/RAM file not handled");
1785 stream->conns_served++;
1787 /* XXX: add there authenticate and IP match */
1790 /* if post, it means a feed is being sent */
1791 if (!stream->is_feed) {
1792 /* However it might be a status report from WMP! Let us log the
1793 * data as it might come in handy one day. */
1794 const char *logline = 0;
1797 for (p = c->buffer; *p && *p != '\r' && *p != '\n'; ) {
1798 if (av_strncasecmp(p, "Pragma: log-line=", 17) == 0) {
1802 if (av_strncasecmp(p, "Pragma: client-id=", 18) == 0)
1803 client_id = strtol(p + 18, 0, 10);
1804 p = strchr(p, '\n');
1812 char *eol = strchr(logline, '\n');
1817 if (eol[-1] == '\r')
1819 http_log("%.*s\n", (int) (eol - logline), logline);
1820 c->suppress_log = 1;
1825 http_log("\nGot request:\n%s\n", c->buffer);
1828 if (client_id && extract_rates(ratebuf, sizeof(ratebuf), c->buffer)) {
1831 /* Now we have to find the client_id */
1832 for (wmpc = first_http_ctx; wmpc; wmpc = wmpc->next) {
1833 if (wmpc->wmp_client_id == client_id)
1837 if (wmpc && modify_current_stream(wmpc, ratebuf))
1838 wmpc->switch_pending = 1;
1841 snprintf(msg, sizeof(msg), "POST command not handled");
1845 if (http_start_receive_data(c) < 0) {
1846 snprintf(msg, sizeof(msg), "could not open feed");
1850 c->state = HTTPSTATE_RECEIVE_DATA;
1855 if (strcmp(stream->filename + strlen(stream->filename) - 4, ".asf") == 0)
1856 http_log("\nGot request:\n%s\n", c->buffer);
1859 if (c->stream->stream_type == STREAM_TYPE_STATUS)
1862 /* open input stream */
1863 if (open_input_stream(c, info) < 0) {
1864 snprintf(msg, sizeof(msg), "Input stream corresponding to '%s' not found", url);
1868 /* prepare http header */
1870 av_strlcatf(c->buffer, c->buffer_size, "HTTP/1.0 200 OK\r\n");
1871 mime_type = c->stream->fmt->mime_type;
1873 mime_type = "application/x-octet-stream";
1874 av_strlcatf(c->buffer, c->buffer_size, "Pragma: no-cache\r\n");
1876 /* for asf, we need extra headers */
1877 if (!strcmp(c->stream->fmt->name,"asf_stream")) {
1878 /* Need to allocate a client id */
1880 c->wmp_client_id = av_lfg_get(&random_state);
1882 av_strlcatf(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);
1884 av_strlcatf(c->buffer, c->buffer_size, "Content-Type: %s\r\n", mime_type);
1885 av_strlcatf(c->buffer, c->buffer_size, "\r\n");
1886 q = c->buffer + strlen(c->buffer);
1888 /* prepare output buffer */
1890 c->buffer_ptr = c->buffer;
1892 c->state = HTTPSTATE_SEND_HEADER;
1895 c->http_error = 404;
1898 snprintf(q, c->buffer_size,
1899 "HTTP/1.0 404 Not Found\r\n"
1900 "Content-type: text/html\r\n"
1903 "<head><title>404 Not Found</title></head>\n"
1907 /* prepare output buffer */
1908 c->buffer_ptr = c->buffer;
1910 c->state = HTTPSTATE_SEND_HEADER;
1914 c->http_error = 200; /* horrible : we use this value to avoid
1915 going to the send data state */
1916 c->state = HTTPSTATE_SEND_HEADER;
1920 static void fmt_bytecount(AVIOContext *pb, int64_t count)
1922 static const char suffix[] = " kMGTP";
1925 for (s = suffix; count >= 100000 && s[1]; count /= 1000, s++);
1927 avio_printf(pb, "%"PRId64"%c", count, *s);
1930 static void compute_status(HTTPContext *c)
1939 if (avio_open_dyn_buf(&pb) < 0) {
1940 /* XXX: return an error ? */
1941 c->buffer_ptr = c->buffer;
1942 c->buffer_end = c->buffer;
1946 avio_printf(pb, "HTTP/1.0 200 OK\r\n");
1947 avio_printf(pb, "Content-type: %s\r\n", "text/html");
1948 avio_printf(pb, "Pragma: no-cache\r\n");
1949 avio_printf(pb, "\r\n");
1951 avio_printf(pb, "<html><head><title>%s Status</title>\n", program_name);
1952 if (c->stream->feed_filename[0])
1953 avio_printf(pb, "<link rel=\"shortcut icon\" href=\"%s\">\n", c->stream->feed_filename);
1954 avio_printf(pb, "</head>\n<body>");
1955 avio_printf(pb, "<h1>%s Status</h1>\n", program_name);
1957 avio_printf(pb, "<h2>Available Streams</h2>\n");
1958 avio_printf(pb, "<table cellspacing=0 cellpadding=4>\n");
1959 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");
1960 stream = first_stream;
1961 while (stream != NULL) {
1962 char sfilename[1024];
1965 if (stream->feed != stream) {
1966 av_strlcpy(sfilename, stream->filename, sizeof(sfilename) - 10);
1967 eosf = sfilename + strlen(sfilename);
1968 if (eosf - sfilename >= 4) {
1969 if (strcmp(eosf - 4, ".asf") == 0)
1970 strcpy(eosf - 4, ".asx");
1971 else if (strcmp(eosf - 3, ".rm") == 0)
1972 strcpy(eosf - 3, ".ram");
1973 else if (stream->fmt && !strcmp(stream->fmt->name, "rtp")) {
1974 /* generate a sample RTSP director if
1975 unicast. Generate an SDP redirector if
1977 eosf = strrchr(sfilename, '.');
1979 eosf = sfilename + strlen(sfilename);
1980 if (stream->is_multicast)
1981 strcpy(eosf, ".sdp");
1983 strcpy(eosf, ".rtsp");
1987 avio_printf(pb, "<tr><td><a href=\"/%s\">%s</a> ",
1988 sfilename, stream->filename);
1989 avio_printf(pb, "<td align=right> %d <td align=right> ",
1990 stream->conns_served);
1991 fmt_bytecount(pb, stream->bytes_served);
1992 switch(stream->stream_type) {
1993 case STREAM_TYPE_LIVE: {
1994 int audio_bit_rate = 0;
1995 int video_bit_rate = 0;
1996 const char *audio_codec_name = "";
1997 const char *video_codec_name = "";
1998 const char *audio_codec_name_extra = "";
1999 const char *video_codec_name_extra = "";
2001 for(i=0;i<stream->nb_streams;i++) {
2002 AVStream *st = stream->streams[i];
2003 AVCodec *codec = avcodec_find_encoder(st->codec->codec_id);
2004 switch(st->codec->codec_type) {
2005 case AVMEDIA_TYPE_AUDIO:
2006 audio_bit_rate += st->codec->bit_rate;
2008 if (*audio_codec_name)
2009 audio_codec_name_extra = "...";
2010 audio_codec_name = codec->name;
2013 case AVMEDIA_TYPE_VIDEO:
2014 video_bit_rate += st->codec->bit_rate;
2016 if (*video_codec_name)
2017 video_codec_name_extra = "...";
2018 video_codec_name = codec->name;
2021 case AVMEDIA_TYPE_DATA:
2022 video_bit_rate += st->codec->bit_rate;
2028 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",
2031 video_bit_rate / 1000, video_codec_name, video_codec_name_extra,
2032 audio_bit_rate / 1000, audio_codec_name, audio_codec_name_extra);
2034 avio_printf(pb, "<td>%s", stream->feed->filename);
2036 avio_printf(pb, "<td>%s", stream->feed_filename);
2037 avio_printf(pb, "\n");
2041 avio_printf(pb, "<td align=center> - <td align=right> - <td align=right> - <td><td align=right> - <td>\n");
2045 stream = stream->next;
2047 avio_printf(pb, "</table>\n");
2049 stream = first_stream;
2050 while (stream != NULL) {
2051 if (stream->feed == stream) {
2052 avio_printf(pb, "<h2>Feed %s</h2>", stream->filename);
2054 avio_printf(pb, "Running as pid %d.\n", stream->pid);
2061 /* This is somewhat linux specific I guess */
2062 snprintf(ps_cmd, sizeof(ps_cmd),
2063 "ps -o \"%%cpu,cputime\" --no-headers %d",
2066 pid_stat = popen(ps_cmd, "r");
2071 if (fscanf(pid_stat, "%9s %63s", cpuperc,
2073 avio_printf(pb, "Currently using %s%% of the cpu. Total time used %s.\n",
2081 avio_printf(pb, "<p>");
2083 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");
2085 for (i = 0; i < stream->nb_streams; i++) {
2086 AVStream *st = stream->streams[i];
2087 AVCodec *codec = avcodec_find_encoder(st->codec->codec_id);
2088 const char *type = "unknown";
2089 char parameters[64];
2093 switch(st->codec->codec_type) {
2094 case AVMEDIA_TYPE_AUDIO:
2096 snprintf(parameters, sizeof(parameters), "%d channel(s), %d Hz", st->codec->channels, st->codec->sample_rate);
2098 case AVMEDIA_TYPE_VIDEO:
2100 snprintf(parameters, sizeof(parameters), "%dx%d, q=%d-%d, fps=%d", st->codec->width, st->codec->height,
2101 st->codec->qmin, st->codec->qmax, st->codec->time_base.den / st->codec->time_base.num);
2106 avio_printf(pb, "<tr><td align=right>%d<td>%s<td align=right>%d<td>%s<td>%s\n",
2107 i, type, st->codec->bit_rate/1000, codec ? codec->name : "", parameters);
2109 avio_printf(pb, "</table>\n");
2112 stream = stream->next;
2115 /* connection status */
2116 avio_printf(pb, "<h2>Connection Status</h2>\n");
2118 avio_printf(pb, "Number of connections: %d / %d<br>\n",
2119 nb_connections, nb_max_connections);
2121 avio_printf(pb, "Bandwidth in use: %"PRIu64"k / %"PRIu64"k<br>\n",
2122 current_bandwidth, max_bandwidth);
2124 avio_printf(pb, "<table>\n");
2125 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");
2126 c1 = first_http_ctx;
2128 while (c1 != NULL) {
2134 for (j = 0; j < c1->stream->nb_streams; j++) {
2135 if (!c1->stream->feed)
2136 bitrate += c1->stream->streams[j]->codec->bit_rate;
2137 else if (c1->feed_streams[j] >= 0)
2138 bitrate += c1->stream->feed->streams[c1->feed_streams[j]]->codec->bit_rate;
2143 p = inet_ntoa(c1->from_addr.sin_addr);
2144 avio_printf(pb, "<tr><td><b>%d</b><td>%s%s<td>%s<td>%s<td>%s<td align=right>",
2146 c1->stream ? c1->stream->filename : "",
2147 c1->state == HTTPSTATE_RECEIVE_DATA ? "(input)" : "",
2150 http_state[c1->state]);
2151 fmt_bytecount(pb, bitrate);
2152 avio_printf(pb, "<td align=right>");
2153 fmt_bytecount(pb, compute_datarate(&c1->datarate, c1->data_count) * 8);
2154 avio_printf(pb, "<td align=right>");
2155 fmt_bytecount(pb, c1->data_count);
2156 avio_printf(pb, "\n");
2159 avio_printf(pb, "</table>\n");
2164 avio_printf(pb, "<hr size=1 noshade>Generated at %s", p);
2165 avio_printf(pb, "</body>\n</html>\n");
2167 len = avio_close_dyn_buf(pb, &c->pb_buffer);
2168 c->buffer_ptr = c->pb_buffer;
2169 c->buffer_end = c->pb_buffer + len;
2172 static int open_input_stream(HTTPContext *c, const char *info)
2175 char input_filename[1024];
2176 AVFormatContext *s = NULL;
2177 int buf_size, i, ret;
2180 /* find file name */
2181 if (c->stream->feed) {
2182 strcpy(input_filename, c->stream->feed->feed_filename);
2183 buf_size = FFM_PACKET_SIZE;
2184 /* compute position (absolute time) */
2185 if (av_find_info_tag(buf, sizeof(buf), "date", info)) {
2186 if ((ret = av_parse_time(&stream_pos, buf, 0)) < 0)
2188 } else if (av_find_info_tag(buf, sizeof(buf), "buffer", info)) {
2189 int prebuffer = strtol(buf, 0, 10);
2190 stream_pos = av_gettime() - prebuffer * (int64_t)1000000;
2192 stream_pos = av_gettime() - c->stream->prebuffer * (int64_t)1000;
2194 strcpy(input_filename, c->stream->feed_filename);
2196 /* compute position (relative time) */
2197 if (av_find_info_tag(buf, sizeof(buf), "date", info)) {
2198 if ((ret = av_parse_time(&stream_pos, buf, 1)) < 0)
2203 if (input_filename[0] == '\0')
2207 if ((ret = avformat_open_input(&s, input_filename, c->stream->ifmt, &c->stream->in_opts)) < 0) {
2208 http_log("could not open %s: %d\n", input_filename, ret);
2212 /* set buffer size */
2213 if (buf_size > 0) ffio_set_buf_size(s->pb, buf_size);
2215 s->flags |= AVFMT_FLAG_GENPTS;
2217 if (strcmp(s->iformat->name, "ffm") && avformat_find_stream_info(c->fmt_in, NULL) < 0) {
2218 http_log("Could not find stream info '%s'\n", input_filename);
2219 avformat_close_input(&s);
2223 /* choose stream as clock source (we favorize video stream if
2224 present) for packet sending */
2225 c->pts_stream_index = 0;
2226 for(i=0;i<c->stream->nb_streams;i++) {
2227 if (c->pts_stream_index == 0 &&
2228 c->stream->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2229 c->pts_stream_index = i;
2233 if (c->fmt_in->iformat->read_seek)
2234 av_seek_frame(c->fmt_in, -1, stream_pos, 0);
2235 /* set the start time (needed for maxtime and RTP packet timing) */
2236 c->start_time = cur_time;
2237 c->first_pts = AV_NOPTS_VALUE;
2241 /* return the server clock (in us) */
2242 static int64_t get_server_clock(HTTPContext *c)
2244 /* compute current pts value from system time */
2245 return (cur_time - c->start_time) * 1000;
2248 /* return the estimated time at which the current packet must be sent
2250 static int64_t get_packet_send_clock(HTTPContext *c)
2252 int bytes_left, bytes_sent, frame_bytes;
2254 frame_bytes = c->cur_frame_bytes;
2255 if (frame_bytes <= 0)
2258 bytes_left = c->buffer_end - c->buffer_ptr;
2259 bytes_sent = frame_bytes - bytes_left;
2260 return c->cur_pts + (c->cur_frame_duration * bytes_sent) / frame_bytes;
2265 static int http_prepare_data(HTTPContext *c)
2268 AVFormatContext *ctx;
2270 av_freep(&c->pb_buffer);
2272 case HTTPSTATE_SEND_DATA_HEADER:
2273 memset(&c->fmt_ctx, 0, sizeof(c->fmt_ctx));
2274 av_dict_set(&c->fmt_ctx.metadata, "author" , c->stream->author , 0);
2275 av_dict_set(&c->fmt_ctx.metadata, "comment" , c->stream->comment , 0);
2276 av_dict_set(&c->fmt_ctx.metadata, "copyright", c->stream->copyright, 0);
2277 av_dict_set(&c->fmt_ctx.metadata, "title" , c->stream->title , 0);
2279 c->fmt_ctx.streams = av_mallocz(sizeof(AVStream *) * c->stream->nb_streams);
2281 for(i=0;i<c->stream->nb_streams;i++) {
2283 c->fmt_ctx.streams[i] = av_mallocz(sizeof(AVStream));
2284 /* if file or feed, then just take streams from FFStream struct */
2285 if (!c->stream->feed ||
2286 c->stream->feed == c->stream)
2287 src = c->stream->streams[i];
2289 src = c->stream->feed->streams[c->stream->feed_streams[i]];
2291 *(c->fmt_ctx.streams[i]) = *src;
2292 c->fmt_ctx.streams[i]->priv_data = 0;
2293 c->fmt_ctx.streams[i]->codec->frame_number = 0; /* XXX: should be done in
2294 AVStream, not in codec */
2296 /* set output format parameters */
2297 c->fmt_ctx.oformat = c->stream->fmt;
2298 c->fmt_ctx.nb_streams = c->stream->nb_streams;
2300 c->got_key_frame = 0;
2302 /* prepare header and save header data in a stream */
2303 if (avio_open_dyn_buf(&c->fmt_ctx.pb) < 0) {
2304 /* XXX: potential leak */
2307 c->fmt_ctx.pb->seekable = 0;
2310 * HACK to avoid mpeg ps muxer to spit many underflow errors
2311 * Default value from FFmpeg
2312 * Try to set it use configuration option
2314 c->fmt_ctx.max_delay = (int)(0.7*AV_TIME_BASE);
2316 if (avformat_write_header(&c->fmt_ctx, NULL) < 0) {
2317 http_log("Error writing output header\n");
2320 av_dict_free(&c->fmt_ctx.metadata);
2322 len = avio_close_dyn_buf(c->fmt_ctx.pb, &c->pb_buffer);
2323 c->buffer_ptr = c->pb_buffer;
2324 c->buffer_end = c->pb_buffer + len;
2326 c->state = HTTPSTATE_SEND_DATA;
2327 c->last_packet_sent = 0;
2329 case HTTPSTATE_SEND_DATA:
2330 /* find a new packet */
2331 /* read a packet from the input stream */
2332 if (c->stream->feed)
2333 ffm_set_write_index(c->fmt_in,
2334 c->stream->feed->feed_write_index,
2335 c->stream->feed->feed_size);
2337 if (c->stream->max_time &&
2338 c->stream->max_time + c->start_time - cur_time < 0)
2339 /* We have timed out */
2340 c->state = HTTPSTATE_SEND_DATA_TRAILER;
2344 ret = av_read_frame(c->fmt_in, &pkt);
2346 if (c->stream->feed) {
2347 /* if coming from feed, it means we reached the end of the
2348 ffm file, so must wait for more data */
2349 c->state = HTTPSTATE_WAIT_FEED;
2350 return 1; /* state changed */
2351 } else if (ret == AVERROR(EAGAIN)) {
2352 /* input not ready, come back later */
2355 if (c->stream->loop) {
2356 avformat_close_input(&c->fmt_in);
2357 if (open_input_stream(c, "") < 0)
2362 /* must send trailer now because eof or error */
2363 c->state = HTTPSTATE_SEND_DATA_TRAILER;
2367 int source_index = pkt.stream_index;
2368 /* update first pts if needed */
2369 if (c->first_pts == AV_NOPTS_VALUE) {
2370 c->first_pts = av_rescale_q(pkt.dts, c->fmt_in->streams[pkt.stream_index]->time_base, AV_TIME_BASE_Q);
2371 c->start_time = cur_time;
2373 /* send it to the appropriate stream */
2374 if (c->stream->feed) {
2375 /* if coming from a feed, select the right stream */
2376 if (c->switch_pending) {
2377 c->switch_pending = 0;
2378 for(i=0;i<c->stream->nb_streams;i++) {
2379 if (c->switch_feed_streams[i] == pkt.stream_index)
2380 if (pkt.flags & AV_PKT_FLAG_KEY)
2381 c->switch_feed_streams[i] = -1;
2382 if (c->switch_feed_streams[i] >= 0)
2383 c->switch_pending = 1;
2386 for(i=0;i<c->stream->nb_streams;i++) {
2387 if (c->stream->feed_streams[i] == pkt.stream_index) {
2388 AVStream *st = c->fmt_in->streams[source_index];
2389 pkt.stream_index = i;
2390 if (pkt.flags & AV_PKT_FLAG_KEY &&
2391 (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2392 c->stream->nb_streams == 1))
2393 c->got_key_frame = 1;
2394 if (!c->stream->send_on_key || c->got_key_frame)
2399 AVCodecContext *codec;
2400 AVStream *ist, *ost;
2402 ist = c->fmt_in->streams[source_index];
2403 /* specific handling for RTP: we use several
2404 output stream (one for each RTP
2405 connection). XXX: need more abstract handling */
2406 if (c->is_packetized) {
2407 /* compute send time and duration */
2408 c->cur_pts = av_rescale_q(pkt.dts, ist->time_base, AV_TIME_BASE_Q);
2409 c->cur_pts -= c->first_pts;
2410 c->cur_frame_duration = av_rescale_q(pkt.duration, ist->time_base, AV_TIME_BASE_Q);
2411 /* find RTP context */
2412 c->packet_stream_index = pkt.stream_index;
2413 ctx = c->rtp_ctx[c->packet_stream_index];
2415 av_free_packet(&pkt);
2418 codec = ctx->streams[0]->codec;
2419 /* only one stream per RTP connection */
2420 pkt.stream_index = 0;
2424 codec = ctx->streams[pkt.stream_index]->codec;
2427 if (c->is_packetized) {
2428 int max_packet_size;
2429 if (c->rtp_protocol == RTSP_LOWER_TRANSPORT_TCP)
2430 max_packet_size = RTSP_TCP_MAX_PACKET_SIZE;
2432 max_packet_size = c->rtp_handles[c->packet_stream_index]->max_packet_size;
2433 ret = ffio_open_dyn_packet_buf(&ctx->pb, max_packet_size);
2435 ret = avio_open_dyn_buf(&ctx->pb);
2438 /* XXX: potential leak */
2441 ost = ctx->streams[pkt.stream_index];
2443 ctx->pb->seekable = 0;
2444 if (pkt.dts != AV_NOPTS_VALUE)
2445 pkt.dts = av_rescale_q(pkt.dts, ist->time_base, ost->time_base);
2446 if (pkt.pts != AV_NOPTS_VALUE)
2447 pkt.pts = av_rescale_q(pkt.pts, ist->time_base, ost->time_base);
2448 pkt.duration = av_rescale_q(pkt.duration, ist->time_base, ost->time_base);
2449 if (av_write_frame(ctx, &pkt) < 0) {
2450 http_log("Error writing frame to output\n");
2451 c->state = HTTPSTATE_SEND_DATA_TRAILER;
2454 len = avio_close_dyn_buf(ctx->pb, &c->pb_buffer);
2455 c->cur_frame_bytes = len;
2456 c->buffer_ptr = c->pb_buffer;
2457 c->buffer_end = c->pb_buffer + len;
2459 codec->frame_number++;
2461 av_free_packet(&pkt);
2465 av_free_packet(&pkt);
2470 case HTTPSTATE_SEND_DATA_TRAILER:
2471 /* last packet test ? */
2472 if (c->last_packet_sent || c->is_packetized)
2475 /* prepare header */
2476 if (avio_open_dyn_buf(&ctx->pb) < 0) {
2477 /* XXX: potential leak */
2480 c->fmt_ctx.pb->seekable = 0;
2481 av_write_trailer(ctx);
2482 len = avio_close_dyn_buf(ctx->pb, &c->pb_buffer);
2483 c->buffer_ptr = c->pb_buffer;
2484 c->buffer_end = c->pb_buffer + len;
2486 c->last_packet_sent = 1;
2492 /* should convert the format at the same time */
2493 /* send data starting at c->buffer_ptr to the output connection
2494 (either UDP or TCP connection) */
2495 static int http_send_data(HTTPContext *c)
2500 if (c->buffer_ptr >= c->buffer_end) {
2501 ret = http_prepare_data(c);
2505 /* state change requested */
2508 if (c->is_packetized) {
2509 /* RTP data output */
2510 len = c->buffer_end - c->buffer_ptr;
2512 /* fail safe - should never happen */
2514 c->buffer_ptr = c->buffer_end;
2517 len = (c->buffer_ptr[0] << 24) |
2518 (c->buffer_ptr[1] << 16) |
2519 (c->buffer_ptr[2] << 8) |
2521 if (len > (c->buffer_end - c->buffer_ptr))
2523 if ((get_packet_send_clock(c) - get_server_clock(c)) > 0) {
2524 /* nothing to send yet: we can wait */
2528 c->data_count += len;
2529 update_datarate(&c->datarate, c->data_count);
2531 c->stream->bytes_served += len;
2533 if (c->rtp_protocol == RTSP_LOWER_TRANSPORT_TCP) {
2534 /* RTP packets are sent inside the RTSP TCP connection */
2536 int interleaved_index, size;
2538 HTTPContext *rtsp_c;
2541 /* if no RTSP connection left, error */
2544 /* if already sending something, then wait. */
2545 if (rtsp_c->state != RTSPSTATE_WAIT_REQUEST)
2547 if (avio_open_dyn_buf(&pb) < 0)
2549 interleaved_index = c->packet_stream_index * 2;
2550 /* RTCP packets are sent at odd indexes */
2551 if (c->buffer_ptr[1] == 200)
2552 interleaved_index++;
2553 /* write RTSP TCP header */
2555 header[1] = interleaved_index;
2556 header[2] = len >> 8;
2558 avio_write(pb, header, 4);
2559 /* write RTP packet data */
2561 avio_write(pb, c->buffer_ptr, len);
2562 size = avio_close_dyn_buf(pb, &c->packet_buffer);
2563 /* prepare asynchronous TCP sending */
2564 rtsp_c->packet_buffer_ptr = c->packet_buffer;
2565 rtsp_c->packet_buffer_end = c->packet_buffer + size;
2566 c->buffer_ptr += len;
2568 /* send everything we can NOW */
2569 len = send(rtsp_c->fd, rtsp_c->packet_buffer_ptr,
2570 rtsp_c->packet_buffer_end - rtsp_c->packet_buffer_ptr, 0);
2572 rtsp_c->packet_buffer_ptr += len;
2573 if (rtsp_c->packet_buffer_ptr < rtsp_c->packet_buffer_end) {
2574 /* if we could not send all the data, we will
2575 send it later, so a new state is needed to
2576 "lock" the RTSP TCP connection */
2577 rtsp_c->state = RTSPSTATE_SEND_PACKET;
2580 /* all data has been sent */
2581 av_freep(&c->packet_buffer);
2583 /* send RTP packet directly in UDP */
2585 ffurl_write(c->rtp_handles[c->packet_stream_index],
2586 c->buffer_ptr, len);
2587 c->buffer_ptr += len;
2588 /* here we continue as we can send several packets per 10 ms slot */
2591 /* TCP data output */
2592 len = send(c->fd, c->buffer_ptr, c->buffer_end - c->buffer_ptr, 0);
2594 if (ff_neterrno() != AVERROR(EAGAIN) &&
2595 ff_neterrno() != AVERROR(EINTR))
2596 /* error : close connection */
2601 c->buffer_ptr += len;
2603 c->data_count += len;
2604 update_datarate(&c->datarate, c->data_count);
2606 c->stream->bytes_served += len;
2614 static int http_start_receive_data(HTTPContext *c)
2618 if (c->stream->feed_opened)
2621 /* Don't permit writing to this one */
2622 if (c->stream->readonly)
2626 fd = open(c->stream->feed_filename, O_RDWR);
2628 http_log("Error opening feeder file: %s\n", strerror(errno));
2633 if (c->stream->truncate) {
2634 /* truncate feed file */
2635 ffm_write_write_index(c->feed_fd, FFM_PACKET_SIZE);
2636 http_log("Truncating feed file '%s'\n", c->stream->feed_filename);
2637 if (ftruncate(c->feed_fd, FFM_PACKET_SIZE) < 0) {
2638 http_log("Error truncating feed file: %s\n", strerror(errno));
2642 if ((c->stream->feed_write_index = ffm_read_write_index(fd)) < 0) {
2643 http_log("Error reading write index from feed file: %s\n", strerror(errno));
2648 c->stream->feed_write_index = FFMAX(ffm_read_write_index(fd), FFM_PACKET_SIZE);
2649 c->stream->feed_size = lseek(fd, 0, SEEK_END);
2650 lseek(fd, 0, SEEK_SET);
2652 /* init buffer input */
2653 c->buffer_ptr = c->buffer;
2654 c->buffer_end = c->buffer + FFM_PACKET_SIZE;
2655 c->stream->feed_opened = 1;
2656 c->chunked_encoding = !!av_stristr(c->buffer, "Transfer-Encoding: chunked");
2660 static int http_receive_data(HTTPContext *c)
2663 int len, loop_run = 0;
2665 while (c->chunked_encoding && !c->chunk_size &&
2666 c->buffer_end > c->buffer_ptr) {
2667 /* read chunk header, if present */
2668 len = recv(c->fd, c->buffer_ptr, 1, 0);
2671 if (ff_neterrno() != AVERROR(EAGAIN) &&
2672 ff_neterrno() != AVERROR(EINTR))
2673 /* error : close connection */
2676 } else if (len == 0) {
2677 /* end of connection : close it */
2679 } else if (c->buffer_ptr - c->buffer >= 2 &&
2680 !memcmp(c->buffer_ptr - 1, "\r\n", 2)) {
2681 c->chunk_size = strtol(c->buffer, 0, 16);
2682 if (c->chunk_size == 0) // end of stream
2684 c->buffer_ptr = c->buffer;
2686 } else if (++loop_run > 10) {
2687 /* no chunk header, abort */
2694 if (c->buffer_end > c->buffer_ptr) {
2695 len = recv(c->fd, c->buffer_ptr,
2696 FFMIN(c->chunk_size, c->buffer_end - c->buffer_ptr), 0);
2698 if (ff_neterrno() != AVERROR(EAGAIN) &&
2699 ff_neterrno() != AVERROR(EINTR))
2700 /* error : close connection */
2702 } else if (len == 0)
2703 /* end of connection : close it */
2706 c->chunk_size -= len;
2707 c->buffer_ptr += len;
2708 c->data_count += len;
2709 update_datarate(&c->datarate, c->data_count);
2713 if (c->buffer_ptr - c->buffer >= 2 && c->data_count > FFM_PACKET_SIZE) {
2714 if (c->buffer[0] != 'f' ||
2715 c->buffer[1] != 'm') {
2716 http_log("Feed stream has become desynchronized -- disconnecting\n");
2721 if (c->buffer_ptr >= c->buffer_end) {
2722 FFStream *feed = c->stream;
2723 /* a packet has been received : write it in the store, except
2725 if (c->data_count > FFM_PACKET_SIZE) {
2726 /* XXX: use llseek or url_seek */
2727 lseek(c->feed_fd, feed->feed_write_index, SEEK_SET);
2728 if (write(c->feed_fd, c->buffer, FFM_PACKET_SIZE) < 0) {
2729 http_log("Error writing to feed file: %s\n", strerror(errno));
2733 feed->feed_write_index += FFM_PACKET_SIZE;
2734 /* update file size */
2735 if (feed->feed_write_index > c->stream->feed_size)
2736 feed->feed_size = feed->feed_write_index;
2738 /* handle wrap around if max file size reached */
2739 if (c->stream->feed_max_size && feed->feed_write_index >= c->stream->feed_max_size)
2740 feed->feed_write_index = FFM_PACKET_SIZE;
2743 if (ffm_write_write_index(c->feed_fd, feed->feed_write_index) < 0) {
2744 http_log("Error writing index to feed file: %s\n", strerror(errno));
2748 /* wake up any waiting connections */
2749 for(c1 = first_http_ctx; c1 != NULL; c1 = c1->next) {
2750 if (c1->state == HTTPSTATE_WAIT_FEED &&
2751 c1->stream->feed == c->stream->feed)
2752 c1->state = HTTPSTATE_SEND_DATA;
2755 /* We have a header in our hands that contains useful data */
2756 AVFormatContext *s = avformat_alloc_context();
2758 AVInputFormat *fmt_in;
2764 /* use feed output format name to find corresponding input format */
2765 fmt_in = av_find_input_format(feed->fmt->name);
2769 pb = avio_alloc_context(c->buffer, c->buffer_end - c->buffer,
2770 0, NULL, NULL, NULL, NULL);
2774 if (avformat_open_input(&s, c->stream->feed_filename, fmt_in, NULL) < 0) {
2779 /* Now we have the actual streams */
2780 if (s->nb_streams != feed->nb_streams) {
2781 avformat_close_input(&s);
2783 http_log("Feed '%s' stream number does not match registered feed\n",
2784 c->stream->feed_filename);
2788 for (i = 0; i < s->nb_streams; i++) {
2789 AVStream *fst = feed->streams[i];
2790 AVStream *st = s->streams[i];
2791 avcodec_copy_context(fst->codec, st->codec);
2794 avformat_close_input(&s);
2797 c->buffer_ptr = c->buffer;
2802 c->stream->feed_opened = 0;
2804 /* wake up any waiting connections to stop waiting for feed */
2805 for(c1 = first_http_ctx; c1 != NULL; c1 = c1->next) {
2806 if (c1->state == HTTPSTATE_WAIT_FEED &&
2807 c1->stream->feed == c->stream->feed)
2808 c1->state = HTTPSTATE_SEND_DATA_TRAILER;
2813 /********************************************************************/
2816 static void rtsp_reply_header(HTTPContext *c, enum RTSPStatusCode error_number)
2823 switch(error_number) {
2824 case RTSP_STATUS_OK:
2827 case RTSP_STATUS_METHOD:
2828 str = "Method Not Allowed";
2830 case RTSP_STATUS_BANDWIDTH:
2831 str = "Not Enough Bandwidth";
2833 case RTSP_STATUS_SESSION:
2834 str = "Session Not Found";
2836 case RTSP_STATUS_STATE:
2837 str = "Method Not Valid in This State";
2839 case RTSP_STATUS_AGGREGATE:
2840 str = "Aggregate operation not allowed";
2842 case RTSP_STATUS_ONLY_AGGREGATE:
2843 str = "Only aggregate operation allowed";
2845 case RTSP_STATUS_TRANSPORT:
2846 str = "Unsupported transport";
2848 case RTSP_STATUS_INTERNAL:
2849 str = "Internal Server Error";
2851 case RTSP_STATUS_SERVICE:
2852 str = "Service Unavailable";
2854 case RTSP_STATUS_VERSION:
2855 str = "RTSP Version not supported";
2858 str = "Unknown Error";
2862 avio_printf(c->pb, "RTSP/1.0 %d %s\r\n", error_number, str);
2863 avio_printf(c->pb, "CSeq: %d\r\n", c->seq);
2865 /* output GMT time */
2868 strftime(buf2, sizeof(buf2), "%a, %d %b %Y %H:%M:%S", tm);
2869 avio_printf(c->pb, "Date: %s GMT\r\n", buf2);
2872 static void rtsp_reply_error(HTTPContext *c, enum RTSPStatusCode error_number)
2874 rtsp_reply_header(c, error_number);
2875 avio_printf(c->pb, "\r\n");
2878 static int rtsp_parse_request(HTTPContext *c)
2880 const char *p, *p1, *p2;
2886 RTSPMessageHeader header1 = { 0 }, *header = &header1;
2888 c->buffer_ptr[0] = '\0';
2891 get_word(cmd, sizeof(cmd), &p);
2892 get_word(url, sizeof(url), &p);
2893 get_word(protocol, sizeof(protocol), &p);
2895 av_strlcpy(c->method, cmd, sizeof(c->method));
2896 av_strlcpy(c->url, url, sizeof(c->url));
2897 av_strlcpy(c->protocol, protocol, sizeof(c->protocol));
2899 if (avio_open_dyn_buf(&c->pb) < 0) {
2900 /* XXX: cannot do more */
2901 c->pb = NULL; /* safety */
2905 /* check version name */
2906 if (strcmp(protocol, "RTSP/1.0") != 0) {
2907 rtsp_reply_error(c, RTSP_STATUS_VERSION);
2911 /* parse each header line */
2912 /* skip to next line */
2913 while (*p != '\n' && *p != '\0')
2917 while (*p != '\0') {
2918 p1 = memchr(p, '\n', (char *)c->buffer_ptr - p);
2922 if (p2 > p && p2[-1] == '\r')
2924 /* skip empty line */
2928 if (len > sizeof(line) - 1)
2929 len = sizeof(line) - 1;
2930 memcpy(line, p, len);
2932 ff_rtsp_parse_line(header, line, NULL, NULL);
2936 /* handle sequence number */
2937 c->seq = header->seq;
2939 if (!strcmp(cmd, "DESCRIBE"))
2940 rtsp_cmd_describe(c, url);
2941 else if (!strcmp(cmd, "OPTIONS"))
2942 rtsp_cmd_options(c, url);
2943 else if (!strcmp(cmd, "SETUP"))
2944 rtsp_cmd_setup(c, url, header);
2945 else if (!strcmp(cmd, "PLAY"))
2946 rtsp_cmd_play(c, url, header);
2947 else if (!strcmp(cmd, "PAUSE"))
2948 rtsp_cmd_pause(c, url, header);
2949 else if (!strcmp(cmd, "TEARDOWN"))
2950 rtsp_cmd_teardown(c, url, header);
2952 rtsp_reply_error(c, RTSP_STATUS_METHOD);
2955 len = avio_close_dyn_buf(c->pb, &c->pb_buffer);
2956 c->pb = NULL; /* safety */
2958 /* XXX: cannot do more */
2961 c->buffer_ptr = c->pb_buffer;
2962 c->buffer_end = c->pb_buffer + len;
2963 c->state = RTSPSTATE_SEND_REPLY;
2967 static int prepare_sdp_description(FFStream *stream, uint8_t **pbuffer,
2968 struct in_addr my_ip)
2970 AVFormatContext *avc;
2971 AVStream *avs = NULL;
2972 AVOutputFormat *rtp_format = av_guess_format("rtp", NULL, NULL);
2977 avc = avformat_alloc_context();
2978 if (avc == NULL || !rtp_format) {
2981 avc->oformat = rtp_format;
2982 av_dict_set(&avc->metadata, "title",
2983 stream->title[0] ? stream->title : "No Title", 0);
2984 avc->nb_streams = stream->nb_streams;
2985 if (stream->is_multicast) {
2986 snprintf(avc->filename, 1024, "rtp://%s:%d?multicast=1?ttl=%d",
2987 inet_ntoa(stream->multicast_ip),
2988 stream->multicast_port, stream->multicast_ttl);
2990 snprintf(avc->filename, 1024, "rtp://0.0.0.0");
2993 if (avc->nb_streams >= INT_MAX/sizeof(*avc->streams) ||
2994 !(avc->streams = av_malloc(avc->nb_streams * sizeof(*avc->streams))))
2996 if (avc->nb_streams >= INT_MAX/sizeof(*avs) ||
2997 !(avs = av_malloc(avc->nb_streams * sizeof(*avs))))
3000 for(i = 0; i < stream->nb_streams; i++) {
3001 avc->streams[i] = &avs[i];
3002 avc->streams[i]->codec = stream->streams[i]->codec;
3004 *pbuffer = av_mallocz(2048);
3005 av_sdp_create(&avc, 1, *pbuffer, 2048);
3008 av_free(avc->streams);
3009 av_dict_free(&avc->metadata);
3013 return *pbuffer ? strlen(*pbuffer) : AVERROR(ENOMEM);
3016 static void rtsp_cmd_options(HTTPContext *c, const char *url)
3018 // rtsp_reply_header(c, RTSP_STATUS_OK);
3019 avio_printf(c->pb, "RTSP/1.0 %d %s\r\n", RTSP_STATUS_OK, "OK");
3020 avio_printf(c->pb, "CSeq: %d\r\n", c->seq);
3021 avio_printf(c->pb, "Public: %s\r\n", "OPTIONS, DESCRIBE, SETUP, TEARDOWN, PLAY, PAUSE");
3022 avio_printf(c->pb, "\r\n");
3025 static void rtsp_cmd_describe(HTTPContext *c, const char *url)
3033 struct sockaddr_in my_addr;
3035 /* find which url is asked */
3036 av_url_split(NULL, 0, NULL, 0, NULL, 0, NULL, path1, sizeof(path1), url);
3041 for(stream = first_stream; stream != NULL; stream = stream->next) {
3042 if (!stream->is_feed &&
3043 stream->fmt && !strcmp(stream->fmt->name, "rtp") &&
3044 !strcmp(path, stream->filename)) {
3048 /* no stream found */
3049 rtsp_reply_error(c, RTSP_STATUS_SERVICE); /* XXX: right error ? */
3053 /* prepare the media description in sdp format */
3055 /* get the host IP */
3056 len = sizeof(my_addr);
3057 getsockname(c->fd, (struct sockaddr *)&my_addr, &len);
3058 content_length = prepare_sdp_description(stream, &content, my_addr.sin_addr);
3059 if (content_length < 0) {
3060 rtsp_reply_error(c, RTSP_STATUS_INTERNAL);
3063 rtsp_reply_header(c, RTSP_STATUS_OK);
3064 avio_printf(c->pb, "Content-Base: %s/\r\n", url);
3065 avio_printf(c->pb, "Content-Type: application/sdp\r\n");
3066 avio_printf(c->pb, "Content-Length: %d\r\n", content_length);
3067 avio_printf(c->pb, "\r\n");
3068 avio_write(c->pb, content, content_length);
3072 static HTTPContext *find_rtp_session(const char *session_id)
3076 if (session_id[0] == '\0')
3079 for(c = first_http_ctx; c != NULL; c = c->next) {
3080 if (!strcmp(c->session_id, session_id))
3086 static RTSPTransportField *find_transport(RTSPMessageHeader *h, enum RTSPLowerTransport lower_transport)
3088 RTSPTransportField *th;
3091 for(i=0;i<h->nb_transports;i++) {
3092 th = &h->transports[i];
3093 if (th->lower_transport == lower_transport)
3099 static void rtsp_cmd_setup(HTTPContext *c, const char *url,
3100 RTSPMessageHeader *h)
3103 int stream_index, rtp_port, rtcp_port;
3108 RTSPTransportField *th;
3109 struct sockaddr_in dest_addr;
3110 RTSPActionServerSetup setup;
3112 /* find which url is asked */
3113 av_url_split(NULL, 0, NULL, 0, NULL, 0, NULL, path1, sizeof(path1), url);
3118 /* now check each stream */
3119 for(stream = first_stream; stream != NULL; stream = stream->next) {
3120 if (!stream->is_feed &&
3121 stream->fmt && !strcmp(stream->fmt->name, "rtp")) {
3122 /* accept aggregate filenames only if single stream */
3123 if (!strcmp(path, stream->filename)) {
3124 if (stream->nb_streams != 1) {
3125 rtsp_reply_error(c, RTSP_STATUS_AGGREGATE);
3132 for(stream_index = 0; stream_index < stream->nb_streams;
3134 snprintf(buf, sizeof(buf), "%s/streamid=%d",
3135 stream->filename, stream_index);
3136 if (!strcmp(path, buf))
3141 /* no stream found */
3142 rtsp_reply_error(c, RTSP_STATUS_SERVICE); /* XXX: right error ? */
3146 /* generate session id if needed */
3147 if (h->session_id[0] == '\0') {
3148 unsigned random0 = av_lfg_get(&random_state);
3149 unsigned random1 = av_lfg_get(&random_state);
3150 snprintf(h->session_id, sizeof(h->session_id), "%08x%08x",
3154 /* find rtp session, and create it if none found */
3155 rtp_c = find_rtp_session(h->session_id);
3157 /* always prefer UDP */
3158 th = find_transport(h, RTSP_LOWER_TRANSPORT_UDP);
3160 th = find_transport(h, RTSP_LOWER_TRANSPORT_TCP);
3162 rtsp_reply_error(c, RTSP_STATUS_TRANSPORT);
3167 rtp_c = rtp_new_connection(&c->from_addr, stream, h->session_id,
3168 th->lower_transport);
3170 rtsp_reply_error(c, RTSP_STATUS_BANDWIDTH);
3174 /* open input stream */
3175 if (open_input_stream(rtp_c, "") < 0) {
3176 rtsp_reply_error(c, RTSP_STATUS_INTERNAL);
3181 /* test if stream is OK (test needed because several SETUP needs
3182 to be done for a given file) */
3183 if (rtp_c->stream != stream) {
3184 rtsp_reply_error(c, RTSP_STATUS_SERVICE);
3188 /* test if stream is already set up */
3189 if (rtp_c->rtp_ctx[stream_index]) {
3190 rtsp_reply_error(c, RTSP_STATUS_STATE);
3194 /* check transport */
3195 th = find_transport(h, rtp_c->rtp_protocol);
3196 if (!th || (th->lower_transport == RTSP_LOWER_TRANSPORT_UDP &&
3197 th->client_port_min <= 0)) {
3198 rtsp_reply_error(c, RTSP_STATUS_TRANSPORT);
3202 /* setup default options */
3203 setup.transport_option[0] = '\0';
3204 dest_addr = rtp_c->from_addr;
3205 dest_addr.sin_port = htons(th->client_port_min);
3208 if (rtp_new_av_stream(rtp_c, stream_index, &dest_addr, c) < 0) {
3209 rtsp_reply_error(c, RTSP_STATUS_TRANSPORT);
3213 /* now everything is OK, so we can send the connection parameters */
3214 rtsp_reply_header(c, RTSP_STATUS_OK);
3216 avio_printf(c->pb, "Session: %s\r\n", rtp_c->session_id);
3218 switch(rtp_c->rtp_protocol) {
3219 case RTSP_LOWER_TRANSPORT_UDP:
3220 rtp_port = ff_rtp_get_local_rtp_port(rtp_c->rtp_handles[stream_index]);
3221 rtcp_port = ff_rtp_get_local_rtcp_port(rtp_c->rtp_handles[stream_index]);
3222 avio_printf(c->pb, "Transport: RTP/AVP/UDP;unicast;"
3223 "client_port=%d-%d;server_port=%d-%d",
3224 th->client_port_min, th->client_port_max,
3225 rtp_port, rtcp_port);
3227 case RTSP_LOWER_TRANSPORT_TCP:
3228 avio_printf(c->pb, "Transport: RTP/AVP/TCP;interleaved=%d-%d",
3229 stream_index * 2, stream_index * 2 + 1);
3234 if (setup.transport_option[0] != '\0')
3235 avio_printf(c->pb, ";%s", setup.transport_option);
3236 avio_printf(c->pb, "\r\n");
3239 avio_printf(c->pb, "\r\n");
3243 /* find an rtp connection by using the session ID. Check consistency
3245 static HTTPContext *find_rtp_session_with_url(const char *url,
3246 const char *session_id)
3254 rtp_c = find_rtp_session(session_id);
3258 /* find which url is asked */
3259 av_url_split(NULL, 0, NULL, 0, NULL, 0, NULL, path1, sizeof(path1), url);
3263 if(!strcmp(path, rtp_c->stream->filename)) return rtp_c;
3264 for(s=0; s<rtp_c->stream->nb_streams; ++s) {
3265 snprintf(buf, sizeof(buf), "%s/streamid=%d",
3266 rtp_c->stream->filename, s);
3267 if(!strncmp(path, buf, sizeof(buf))) {
3268 // XXX: Should we reply with RTSP_STATUS_ONLY_AGGREGATE if nb_streams>1?
3273 if (len > 0 && path[len - 1] == '/' &&
3274 !strncmp(path, rtp_c->stream->filename, len - 1))
3279 static void rtsp_cmd_play(HTTPContext *c, const char *url, RTSPMessageHeader *h)
3283 rtp_c = find_rtp_session_with_url(url, h->session_id);
3285 rtsp_reply_error(c, RTSP_STATUS_SESSION);
3289 if (rtp_c->state != HTTPSTATE_SEND_DATA &&
3290 rtp_c->state != HTTPSTATE_WAIT_FEED &&
3291 rtp_c->state != HTTPSTATE_READY) {
3292 rtsp_reply_error(c, RTSP_STATUS_STATE);
3296 rtp_c->state = HTTPSTATE_SEND_DATA;
3298 /* now everything is OK, so we can send the connection parameters */
3299 rtsp_reply_header(c, RTSP_STATUS_OK);
3301 avio_printf(c->pb, "Session: %s\r\n", rtp_c->session_id);
3302 avio_printf(c->pb, "\r\n");
3305 static void rtsp_cmd_pause(HTTPContext *c, const char *url, RTSPMessageHeader *h)
3309 rtp_c = find_rtp_session_with_url(url, h->session_id);
3311 rtsp_reply_error(c, RTSP_STATUS_SESSION);
3315 if (rtp_c->state != HTTPSTATE_SEND_DATA &&
3316 rtp_c->state != HTTPSTATE_WAIT_FEED) {
3317 rtsp_reply_error(c, RTSP_STATUS_STATE);
3321 rtp_c->state = HTTPSTATE_READY;
3322 rtp_c->first_pts = AV_NOPTS_VALUE;
3323 /* now everything is OK, so we can send the connection parameters */
3324 rtsp_reply_header(c, RTSP_STATUS_OK);
3326 avio_printf(c->pb, "Session: %s\r\n", rtp_c->session_id);
3327 avio_printf(c->pb, "\r\n");
3330 static void rtsp_cmd_teardown(HTTPContext *c, const char *url, RTSPMessageHeader *h)
3334 rtp_c = find_rtp_session_with_url(url, h->session_id);
3336 rtsp_reply_error(c, RTSP_STATUS_SESSION);
3340 /* now everything is OK, so we can send the connection parameters */
3341 rtsp_reply_header(c, RTSP_STATUS_OK);
3343 avio_printf(c->pb, "Session: %s\r\n", rtp_c->session_id);
3344 avio_printf(c->pb, "\r\n");
3346 /* abort the session */
3347 close_connection(rtp_c);
3351 /********************************************************************/
3354 static HTTPContext *rtp_new_connection(struct sockaddr_in *from_addr,
3355 FFStream *stream, const char *session_id,
3356 enum RTSPLowerTransport rtp_protocol)
3358 HTTPContext *c = NULL;
3359 const char *proto_str;
3361 /* XXX: should output a warning page when coming
3362 close to the connection limit */
3363 if (nb_connections >= nb_max_connections)
3366 /* add a new connection */
3367 c = av_mallocz(sizeof(HTTPContext));
3372 c->poll_entry = NULL;
3373 c->from_addr = *from_addr;
3374 c->buffer_size = IOBUFFER_INIT_SIZE;
3375 c->buffer = av_malloc(c->buffer_size);
3380 av_strlcpy(c->session_id, session_id, sizeof(c->session_id));
3381 c->state = HTTPSTATE_READY;
3382 c->is_packetized = 1;
3383 c->rtp_protocol = rtp_protocol;
3385 /* protocol is shown in statistics */
3386 switch(c->rtp_protocol) {
3387 case RTSP_LOWER_TRANSPORT_UDP_MULTICAST:
3388 proto_str = "MCAST";
3390 case RTSP_LOWER_TRANSPORT_UDP:
3393 case RTSP_LOWER_TRANSPORT_TCP:
3400 av_strlcpy(c->protocol, "RTP/", sizeof(c->protocol));
3401 av_strlcat(c->protocol, proto_str, sizeof(c->protocol));
3403 current_bandwidth += stream->bandwidth;
3405 c->next = first_http_ctx;
3417 /* add a new RTP stream in an RTP connection (used in RTSP SETUP
3418 command). If RTP/TCP protocol is used, TCP connection 'rtsp_c' is
3420 static int rtp_new_av_stream(HTTPContext *c,
3421 int stream_index, struct sockaddr_in *dest_addr,
3422 HTTPContext *rtsp_c)
3424 AVFormatContext *ctx;
3427 URLContext *h = NULL;
3429 int max_packet_size;
3431 /* now we can open the relevant output stream */
3432 ctx = avformat_alloc_context();
3435 ctx->oformat = av_guess_format("rtp", NULL, NULL);
3437 st = av_mallocz(sizeof(AVStream));
3440 ctx->nb_streams = 1;
3441 ctx->streams = av_mallocz(sizeof(AVStream *) * ctx->nb_streams);
3444 ctx->streams[0] = st;
3446 if (!c->stream->feed ||
3447 c->stream->feed == c->stream)
3448 memcpy(st, c->stream->streams[stream_index], sizeof(AVStream));
3451 c->stream->feed->streams[c->stream->feed_streams[stream_index]],
3453 st->priv_data = NULL;
3455 /* build destination RTP address */
3456 ipaddr = inet_ntoa(dest_addr->sin_addr);
3458 switch(c->rtp_protocol) {
3459 case RTSP_LOWER_TRANSPORT_UDP:
3460 case RTSP_LOWER_TRANSPORT_UDP_MULTICAST:
3463 /* XXX: also pass as parameter to function ? */
3464 if (c->stream->is_multicast) {
3466 ttl = c->stream->multicast_ttl;
3469 snprintf(ctx->filename, sizeof(ctx->filename),
3470 "rtp://%s:%d?multicast=1&ttl=%d",
3471 ipaddr, ntohs(dest_addr->sin_port), ttl);
3473 snprintf(ctx->filename, sizeof(ctx->filename),
3474 "rtp://%s:%d", ipaddr, ntohs(dest_addr->sin_port));
3477 if (ffurl_open(&h, ctx->filename, AVIO_FLAG_WRITE, NULL, NULL) < 0)
3479 c->rtp_handles[stream_index] = h;
3480 max_packet_size = h->max_packet_size;
3482 case RTSP_LOWER_TRANSPORT_TCP:
3485 max_packet_size = RTSP_TCP_MAX_PACKET_SIZE;
3491 http_log("%s:%d - - \"PLAY %s/streamid=%d %s\"\n",
3492 ipaddr, ntohs(dest_addr->sin_port),
3493 c->stream->filename, stream_index, c->protocol);
3495 /* normally, no packets should be output here, but the packet size may be checked */
3496 if (ffio_open_dyn_packet_buf(&ctx->pb, max_packet_size) < 0) {
3497 /* XXX: close stream */
3500 if (avformat_write_header(ctx, NULL) < 0) {
3507 avio_close_dyn_buf(ctx->pb, &dummy_buf);
3510 c->rtp_ctx[stream_index] = ctx;
3514 /********************************************************************/
3515 /* ffserver initialization */
3517 static AVStream *add_av_stream1(FFStream *stream, AVCodecContext *codec, int copy)
3521 if(stream->nb_streams >= FF_ARRAY_ELEMS(stream->streams))
3524 fst = av_mallocz(sizeof(AVStream));
3528 fst->codec = avcodec_alloc_context3(NULL);
3529 memcpy(fst->codec, codec, sizeof(AVCodecContext));
3530 if (codec->extradata_size) {
3531 fst->codec->extradata = av_mallocz(codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
3532 memcpy(fst->codec->extradata, codec->extradata,
3533 codec->extradata_size);
3536 /* live streams must use the actual feed's codec since it may be
3537 * updated later to carry extradata needed by the streams.
3541 fst->priv_data = av_mallocz(sizeof(FeedData));
3542 fst->index = stream->nb_streams;
3543 avpriv_set_pts_info(fst, 33, 1, 90000);
3544 fst->sample_aspect_ratio = codec->sample_aspect_ratio;
3545 stream->streams[stream->nb_streams++] = fst;
3549 /* return the stream number in the feed */
3550 static int add_av_stream(FFStream *feed, AVStream *st)
3553 AVCodecContext *av, *av1;
3557 for(i=0;i<feed->nb_streams;i++) {
3558 st = feed->streams[i];
3560 if (av1->codec_id == av->codec_id &&
3561 av1->codec_type == av->codec_type &&
3562 av1->bit_rate == av->bit_rate) {
3564 switch(av->codec_type) {
3565 case AVMEDIA_TYPE_AUDIO:
3566 if (av1->channels == av->channels &&
3567 av1->sample_rate == av->sample_rate)
3570 case AVMEDIA_TYPE_VIDEO:
3571 if (av1->width == av->width &&
3572 av1->height == av->height &&
3573 av1->time_base.den == av->time_base.den &&
3574 av1->time_base.num == av->time_base.num &&
3575 av1->gop_size == av->gop_size)
3584 fst = add_av_stream1(feed, av, 0);
3587 return feed->nb_streams - 1;
3590 static void remove_stream(FFStream *stream)
3594 while (*ps != NULL) {
3602 /* specific mpeg4 handling : we extract the raw parameters */
3603 static void extract_mpeg4_header(AVFormatContext *infile)
3605 int mpeg4_count, i, size;
3610 infile->flags |= AVFMT_FLAG_NOFILLIN | AVFMT_FLAG_NOPARSE;
3613 for(i=0;i<infile->nb_streams;i++) {
3614 st = infile->streams[i];
3615 if (st->codec->codec_id == AV_CODEC_ID_MPEG4 &&
3616 st->codec->extradata_size == 0) {
3623 printf("MPEG4 without extra data: trying to find header in %s\n", infile->filename);
3624 while (mpeg4_count > 0) {
3625 if (av_read_frame(infile, &pkt) < 0)
3627 st = infile->streams[pkt.stream_index];
3628 if (st->codec->codec_id == AV_CODEC_ID_MPEG4 &&
3629 st->codec->extradata_size == 0) {
3630 av_freep(&st->codec->extradata);
3631 /* fill extradata with the header */
3632 /* XXX: we make hard suppositions here ! */
3634 while (p < pkt.data + pkt.size - 4) {
3635 /* stop when vop header is found */
3636 if (p[0] == 0x00 && p[1] == 0x00 &&
3637 p[2] == 0x01 && p[3] == 0xb6) {
3638 size = p - pkt.data;
3639 // av_hex_dump_log(infile, AV_LOG_DEBUG, pkt.data, size);
3640 st->codec->extradata = av_mallocz(size + FF_INPUT_BUFFER_PADDING_SIZE);
3641 st->codec->extradata_size = size;
3642 memcpy(st->codec->extradata, pkt.data, size);
3649 av_free_packet(&pkt);
3653 /* compute the needed AVStream for each file */
3654 static void build_file_streams(void)
3656 FFStream *stream, *stream_next;
3659 /* gather all streams */
3660 for(stream = first_stream; stream != NULL; stream = stream_next) {
3661 AVFormatContext *infile = NULL;
3662 stream_next = stream->next;
3663 if (stream->stream_type == STREAM_TYPE_LIVE &&
3665 /* the stream comes from a file */
3666 /* try to open the file */
3668 if (stream->fmt && !strcmp(stream->fmt->name, "rtp")) {
3669 /* specific case : if transport stream output to RTP,
3670 we use a raw transport stream reader */
3671 av_dict_set(&stream->in_opts, "mpeg2ts_compute_pcr", "1", 0);
3674 http_log("Opening file '%s'\n", stream->feed_filename);
3675 if ((ret = avformat_open_input(&infile, stream->feed_filename, stream->ifmt, &stream->in_opts)) < 0) {
3676 http_log("Could not open '%s': %d\n", stream->feed_filename, ret);
3677 /* remove stream (no need to spend more time on it) */
3679 remove_stream(stream);
3681 /* find all the AVStreams inside and reference them in
3683 if (avformat_find_stream_info(infile, NULL) < 0) {
3684 http_log("Could not find codec parameters from '%s'\n",
3685 stream->feed_filename);
3686 avformat_close_input(&infile);
3689 extract_mpeg4_header(infile);
3691 for(i=0;i<infile->nb_streams;i++)
3692 add_av_stream1(stream, infile->streams[i]->codec, 1);
3694 avformat_close_input(&infile);
3700 /* compute the needed AVStream for each feed */
3701 static void build_feed_streams(void)
3703 FFStream *stream, *feed;
3706 /* gather all streams */
3707 for(stream = first_stream; stream != NULL; stream = stream->next) {
3708 feed = stream->feed;
3710 if (stream->is_feed) {
3711 for(i=0;i<stream->nb_streams;i++)
3712 stream->feed_streams[i] = i;
3714 /* we handle a stream coming from a feed */
3715 for(i=0;i<stream->nb_streams;i++)
3716 stream->feed_streams[i] = add_av_stream(feed, stream->streams[i]);
3721 /* create feed files if needed */
3722 for(feed = first_feed; feed != NULL; feed = feed->next_feed) {
3725 if (avio_check(feed->feed_filename, AVIO_FLAG_READ) > 0) {
3726 /* See if it matches */
3727 AVFormatContext *s = NULL;
3730 if (avformat_open_input(&s, feed->feed_filename, NULL, NULL) >= 0) {
3731 /* set buffer size */
3732 ffio_set_buf_size(s->pb, FFM_PACKET_SIZE);
3733 /* Now see if it matches */
3734 if (s->nb_streams == feed->nb_streams) {
3736 for(i=0;i<s->nb_streams;i++) {
3738 sf = feed->streams[i];
3741 if (sf->index != ss->index ||
3743 http_log("Index & Id do not match for stream %d (%s)\n",
3744 i, feed->feed_filename);
3747 AVCodecContext *ccf, *ccs;
3751 #define CHECK_CODEC(x) (ccf->x != ccs->x)
3753 if (CHECK_CODEC(codec_id) || CHECK_CODEC(codec_type)) {
3754 http_log("Codecs do not match for stream %d\n", i);
3756 } else if (CHECK_CODEC(bit_rate) || CHECK_CODEC(flags)) {
3757 http_log("Codec bitrates do not match for stream %d\n", i);
3759 } else if (ccf->codec_type == AVMEDIA_TYPE_VIDEO) {
3760 if (CHECK_CODEC(time_base.den) ||
3761 CHECK_CODEC(time_base.num) ||
3762 CHECK_CODEC(width) ||
3763 CHECK_CODEC(height)) {
3764 http_log("Codec width, height and framerate do not match for stream %d\n", i);
3767 } else if (ccf->codec_type == AVMEDIA_TYPE_AUDIO) {
3768 if (CHECK_CODEC(sample_rate) ||
3769 CHECK_CODEC(channels) ||
3770 CHECK_CODEC(frame_size)) {
3771 http_log("Codec sample_rate, channels, frame_size do not match for stream %d\n", i);
3775 http_log("Unknown codec type\n");
3783 http_log("Deleting feed file '%s' as stream counts differ (%d != %d)\n",
3784 feed->feed_filename, s->nb_streams, feed->nb_streams);
3786 avformat_close_input(&s);
3788 http_log("Deleting feed file '%s' as it appears to be corrupt\n",
3789 feed->feed_filename);
3792 if (feed->readonly) {
3793 http_log("Unable to delete feed file '%s' as it is marked readonly\n",
3794 feed->feed_filename);
3797 unlink(feed->feed_filename);
3800 if (avio_check(feed->feed_filename, AVIO_FLAG_WRITE) <= 0) {
3801 AVFormatContext s1 = {0}, *s = &s1;
3803 if (feed->readonly) {
3804 http_log("Unable to create feed file '%s' as it is marked readonly\n",
3805 feed->feed_filename);
3809 /* only write the header of the ffm file */
3810 if (avio_open(&s->pb, feed->feed_filename, AVIO_FLAG_WRITE) < 0) {
3811 http_log("Could not open output feed file '%s'\n",
3812 feed->feed_filename);
3815 s->oformat = feed->fmt;
3816 s->nb_streams = feed->nb_streams;
3817 s->streams = feed->streams;
3818 if (avformat_write_header(s, NULL) < 0) {
3819 http_log("Container doesn't support the required parameters\n");
3822 /* XXX: need better api */
3823 av_freep(&s->priv_data);
3826 /* get feed size and write index */
3827 fd = open(feed->feed_filename, O_RDONLY);
3829 http_log("Could not open output feed file '%s'\n",
3830 feed->feed_filename);
3834 feed->feed_write_index = FFMAX(ffm_read_write_index(fd), FFM_PACKET_SIZE);
3835 feed->feed_size = lseek(fd, 0, SEEK_END);
3836 /* ensure that we do not wrap before the end of file */
3837 if (feed->feed_max_size && feed->feed_max_size < feed->feed_size)
3838 feed->feed_max_size = feed->feed_size;
3844 /* compute the bandwidth used by each stream */
3845 static void compute_bandwidth(void)
3851 for(stream = first_stream; stream != NULL; stream = stream->next) {
3853 for(i=0;i<stream->nb_streams;i++) {
3854 AVStream *st = stream->streams[i];
3855 switch(st->codec->codec_type) {
3856 case AVMEDIA_TYPE_AUDIO:
3857 case AVMEDIA_TYPE_VIDEO:
3858 bandwidth += st->codec->bit_rate;
3864 stream->bandwidth = (bandwidth + 999) / 1000;
3868 /* add a codec and set the default parameters */
3869 static void add_codec(FFStream *stream, AVCodecContext *av)
3873 if(stream->nb_streams >= FF_ARRAY_ELEMS(stream->streams))
3876 /* compute default parameters */
3877 switch(av->codec_type) {
3878 case AVMEDIA_TYPE_AUDIO:
3879 if (av->bit_rate == 0)
3880 av->bit_rate = 64000;
3881 if (av->sample_rate == 0)
3882 av->sample_rate = 22050;
3883 if (av->channels == 0)
3886 case AVMEDIA_TYPE_VIDEO:
3887 if (av->bit_rate == 0)
3888 av->bit_rate = 64000;
3889 if (av->time_base.num == 0){
3890 av->time_base.den = 5;
3891 av->time_base.num = 1;
3893 if (av->width == 0 || av->height == 0) {
3897 /* Bitrate tolerance is less for streaming */
3898 if (av->bit_rate_tolerance == 0)
3899 av->bit_rate_tolerance = FFMAX(av->bit_rate / 4,
3900 (int64_t)av->bit_rate*av->time_base.num/av->time_base.den);
3905 if (av->max_qdiff == 0)
3907 av->qcompress = 0.5;
3910 if (!av->nsse_weight)
3911 av->nsse_weight = 8;
3913 av->frame_skip_cmp = FF_CMP_DCTMAX;
3915 av->me_method = ME_EPZS;
3916 av->rc_buffer_aggressivity = 1.0;
3919 av->rc_eq = av_strdup("tex^qComp");
3920 if (!av->i_quant_factor)
3921 av->i_quant_factor = -0.8;
3922 if (!av->b_quant_factor)
3923 av->b_quant_factor = 1.25;
3924 if (!av->b_quant_offset)
3925 av->b_quant_offset = 1.25;
3926 if (!av->rc_max_rate)
3927 av->rc_max_rate = av->bit_rate * 2;
3929 if (av->rc_max_rate && !av->rc_buffer_size) {
3930 av->rc_buffer_size = av->rc_max_rate;
3939 st = av_mallocz(sizeof(AVStream));
3942 st->codec = avcodec_alloc_context3(NULL);
3943 stream->streams[stream->nb_streams++] = st;
3944 memcpy(st->codec, av, sizeof(AVCodecContext));
3947 static enum AVCodecID opt_audio_codec(const char *arg)
3949 AVCodec *p= avcodec_find_encoder_by_name(arg);
3951 if (p == NULL || p->type != AVMEDIA_TYPE_AUDIO)
3952 return AV_CODEC_ID_NONE;
3957 static enum AVCodecID opt_video_codec(const char *arg)
3959 AVCodec *p= avcodec_find_encoder_by_name(arg);
3961 if (p == NULL || p->type != AVMEDIA_TYPE_VIDEO)
3962 return AV_CODEC_ID_NONE;
3967 static int ffserver_opt_default(const char *opt, const char *arg,
3968 AVCodecContext *avctx, int type)
3971 const AVOption *o = av_opt_find(avctx, opt, NULL, type, 0);
3973 ret = av_opt_set(avctx, opt, arg, 0);
3977 static int ffserver_opt_preset(const char *arg,
3978 AVCodecContext *avctx, int type,
3979 enum AVCodecID *audio_id, enum AVCodecID *video_id)
3982 char filename[1000], tmp[1000], tmp2[1000], line[1000];
3984 AVCodec *codec = avcodec_find_encoder(avctx->codec_id);
3986 if (!(f = get_preset_file(filename, sizeof(filename), arg, 0,
3987 codec ? codec->name : NULL))) {
3988 fprintf(stderr, "File for preset '%s' not found\n", arg);
3993 int e= fscanf(f, "%999[^\n]\n", line) - 1;
3994 if(line[0] == '#' && !e)
3996 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
3998 fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4002 if(!strcmp(tmp, "acodec")){
4003 *audio_id = opt_audio_codec(tmp2);
4004 }else if(!strcmp(tmp, "vcodec")){
4005 *video_id = opt_video_codec(tmp2);
4006 }else if(!strcmp(tmp, "scodec")){
4007 /* opt_subtitle_codec(tmp2); */
4008 }else if(ffserver_opt_default(tmp, tmp2, avctx, type) < 0){
4009 fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4020 static AVOutputFormat *ffserver_guess_format(const char *short_name, const char *filename,
4021 const char *mime_type)
4023 AVOutputFormat *fmt = av_guess_format(short_name, filename, mime_type);
4026 AVOutputFormat *stream_fmt;
4027 char stream_format_name[64];
4029 snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
4030 stream_fmt = av_guess_format(stream_format_name, NULL, NULL);
4039 static void report_config_error(const char *filename, int line_num, int *errors, const char *fmt, ...)
4043 fprintf(stderr, "%s:%d: ", filename, line_num);
4044 vfprintf(stderr, fmt, vl);
4050 static int parse_ffconfig(const char *filename)
4057 int val, errors, line_num;
4058 FFStream **last_stream, *stream, *redirect;
4059 FFStream **last_feed, *feed, *s;
4060 AVCodecContext audio_enc, video_enc;
4061 enum AVCodecID audio_id, video_id;
4063 f = fopen(filename, "r");
4071 first_stream = NULL;
4072 last_stream = &first_stream;
4074 last_feed = &first_feed;
4078 audio_id = AV_CODEC_ID_NONE;
4079 video_id = AV_CODEC_ID_NONE;
4081 #define ERROR(...) report_config_error(filename, line_num, &errors, __VA_ARGS__)
4083 if (fgets(line, sizeof(line), f) == NULL)
4087 while (av_isspace(*p))
4089 if (*p == '\0' || *p == '#')
4092 get_arg(cmd, sizeof(cmd), &p);
4094 if (!av_strcasecmp(cmd, "Port")) {
4095 get_arg(arg, sizeof(arg), &p);
4097 if (val < 1 || val > 65536) {
4098 ERROR("Invalid_port: %s\n", arg);
4100 my_http_addr.sin_port = htons(val);
4101 } else if (!av_strcasecmp(cmd, "BindAddress")) {
4102 get_arg(arg, sizeof(arg), &p);
4103 if (resolve_host(&my_http_addr.sin_addr, arg) != 0) {
4104 ERROR("%s:%d: Invalid host/IP address: %s\n", arg);
4106 } else if (!av_strcasecmp(cmd, "NoDaemon")) {
4107 // do nothing here, its the default now
4108 } else if (!av_strcasecmp(cmd, "RTSPPort")) {
4109 get_arg(arg, sizeof(arg), &p);
4111 if (val < 1 || val > 65536) {
4112 ERROR("%s:%d: Invalid port: %s\n", arg);
4114 my_rtsp_addr.sin_port = htons(atoi(arg));
4115 } else if (!av_strcasecmp(cmd, "RTSPBindAddress")) {
4116 get_arg(arg, sizeof(arg), &p);
4117 if (resolve_host(&my_rtsp_addr.sin_addr, arg) != 0) {
4118 ERROR("Invalid host/IP address: %s\n", arg);
4120 } else if (!av_strcasecmp(cmd, "MaxHTTPConnections")) {
4121 get_arg(arg, sizeof(arg), &p);
4123 if (val < 1 || val > 65536) {
4124 ERROR("Invalid MaxHTTPConnections: %s\n", arg);
4126 nb_max_http_connections = val;
4127 } else if (!av_strcasecmp(cmd, "MaxClients")) {
4128 get_arg(arg, sizeof(arg), &p);
4130 if (val < 1 || val > nb_max_http_connections) {
4131 ERROR("Invalid MaxClients: %s\n", arg);
4133 nb_max_connections = val;
4135 } else if (!av_strcasecmp(cmd, "MaxBandwidth")) {
4137 get_arg(arg, sizeof(arg), &p);
4138 llval = strtoll(arg, NULL, 10);
4139 if (llval < 10 || llval > 10000000) {
4140 ERROR("Invalid MaxBandwidth: %s\n", arg);
4142 max_bandwidth = llval;
4143 } else if (!av_strcasecmp(cmd, "CustomLog")) {
4144 if (!ffserver_debug)
4145 get_arg(logfilename, sizeof(logfilename), &p);
4146 } else if (!av_strcasecmp(cmd, "<Feed")) {
4147 /*********************************************/
4148 /* Feed related options */
4150 if (stream || feed) {
4151 ERROR("Already in a tag\n");
4153 feed = av_mallocz(sizeof(FFStream));
4154 get_arg(feed->filename, sizeof(feed->filename), &p);
4155 q = strrchr(feed->filename, '>');
4159 for (s = first_feed; s; s = s->next) {
4160 if (!strcmp(feed->filename, s->filename)) {
4161 ERROR("Feed '%s' already registered\n", s->filename);
4165 feed->fmt = av_guess_format("ffm", NULL, NULL);
4166 /* defaut feed file */
4167 snprintf(feed->feed_filename, sizeof(feed->feed_filename),
4168 "/tmp/%s.ffm", feed->filename);
4169 feed->feed_max_size = 5 * 1024 * 1024;
4171 feed->feed = feed; /* self feeding :-) */
4173 /* add in stream list */
4174 *last_stream = feed;
4175 last_stream = &feed->next;
4176 /* add in feed list */
4178 last_feed = &feed->next_feed;
4180 } else if (!av_strcasecmp(cmd, "Launch")) {
4184 feed->child_argv = av_mallocz(64 * sizeof(char *));
4186 for (i = 0; i < 62; i++) {
4187 get_arg(arg, sizeof(arg), &p);
4191 feed->child_argv[i] = av_strdup(arg);
4194 feed->child_argv[i] = av_asprintf("http://%s:%d/%s",
4195 (my_http_addr.sin_addr.s_addr == INADDR_ANY) ? "127.0.0.1" :
4196 inet_ntoa(my_http_addr.sin_addr),
4197 ntohs(my_http_addr.sin_port), feed->filename);
4199 } else if (!av_strcasecmp(cmd, "ReadOnlyFile")) {
4201 get_arg(feed->feed_filename, sizeof(feed->feed_filename), &p);
4203 } else if (stream) {
4204 get_arg(stream->feed_filename, sizeof(stream->feed_filename), &p);
4206 } else if (!av_strcasecmp(cmd, "File")) {
4208 get_arg(feed->feed_filename, sizeof(feed->feed_filename), &p);
4210 get_arg(stream->feed_filename, sizeof(stream->feed_filename), &p);
4211 } else if (!av_strcasecmp(cmd, "Truncate")) {
4213 get_arg(arg, sizeof(arg), &p);
4214 feed->truncate = strtod(arg, NULL);
4216 } else if (!av_strcasecmp(cmd, "FileMaxSize")) {
4221 get_arg(arg, sizeof(arg), &p);
4223 fsize = strtod(p1, &p1);
4224 switch(av_toupper(*p1)) {
4229 fsize *= 1024 * 1024;
4232 fsize *= 1024 * 1024 * 1024;
4235 feed->feed_max_size = (int64_t)fsize;
4236 if (feed->feed_max_size < FFM_PACKET_SIZE*4) {
4237 ERROR("Feed max file size is too small, must be at least %d\n", FFM_PACKET_SIZE*4);
4240 } else if (!av_strcasecmp(cmd, "</Feed>")) {
4242 ERROR("No corresponding <Feed> for </Feed>\n");
4245 } else if (!av_strcasecmp(cmd, "<Stream")) {
4246 /*********************************************/
4247 /* Stream related options */
4249 if (stream || feed) {
4250 ERROR("Already in a tag\n");
4253 stream = av_mallocz(sizeof(FFStream));
4254 get_arg(stream->filename, sizeof(stream->filename), &p);
4255 q = strrchr(stream->filename, '>');
4259 for (s = first_stream; s; s = s->next) {
4260 if (!strcmp(stream->filename, s->filename)) {
4261 ERROR("Stream '%s' already registered\n", s->filename);
4265 stream->fmt = ffserver_guess_format(NULL, stream->filename, NULL);
4266 avcodec_get_context_defaults3(&video_enc, NULL);
4267 avcodec_get_context_defaults3(&audio_enc, NULL);
4269 audio_id = AV_CODEC_ID_NONE;
4270 video_id = AV_CODEC_ID_NONE;
4272 audio_id = stream->fmt->audio_codec;
4273 video_id = stream->fmt->video_codec;
4276 *last_stream = stream;
4277 last_stream = &stream->next;
4279 } else if (!av_strcasecmp(cmd, "Feed")) {
4280 get_arg(arg, sizeof(arg), &p);
4285 while (sfeed != NULL) {
4286 if (!strcmp(sfeed->filename, arg))
4288 sfeed = sfeed->next_feed;
4291 ERROR("feed '%s' not defined\n", arg);
4293 stream->feed = sfeed;
4295 } else if (!av_strcasecmp(cmd, "Format")) {
4296 get_arg(arg, sizeof(arg), &p);
4298 if (!strcmp(arg, "status")) {
4299 stream->stream_type = STREAM_TYPE_STATUS;
4302 stream->stream_type = STREAM_TYPE_LIVE;
4303 /* jpeg cannot be used here, so use single frame jpeg */
4304 if (!strcmp(arg, "jpeg"))
4305 strcpy(arg, "mjpeg");
4306 stream->fmt = ffserver_guess_format(arg, NULL, NULL);
4308 ERROR("Unknown Format: %s\n", arg);
4312 audio_id = stream->fmt->audio_codec;
4313 video_id = stream->fmt->video_codec;
4316 } else if (!av_strcasecmp(cmd, "InputFormat")) {
4317 get_arg(arg, sizeof(arg), &p);
4319 stream->ifmt = av_find_input_format(arg);
4320 if (!stream->ifmt) {
4321 ERROR("Unknown input format: %s\n", arg);
4324 } else if (!av_strcasecmp(cmd, "FaviconURL")) {
4325 if (stream && stream->stream_type == STREAM_TYPE_STATUS) {
4326 get_arg(stream->feed_filename, sizeof(stream->feed_filename), &p);
4328 ERROR("FaviconURL only permitted for status streams\n");
4330 } else if (!av_strcasecmp(cmd, "Author")) {
4332 get_arg(stream->author, sizeof(stream->author), &p);
4333 } else if (!av_strcasecmp(cmd, "Comment")) {
4335 get_arg(stream->comment, sizeof(stream->comment), &p);
4336 } else if (!av_strcasecmp(cmd, "Copyright")) {
4338 get_arg(stream->copyright, sizeof(stream->copyright), &p);
4339 } else if (!av_strcasecmp(cmd, "Title")) {
4341 get_arg(stream->title, sizeof(stream->title), &p);
4342 } else if (!av_strcasecmp(cmd, "Preroll")) {
4343 get_arg(arg, sizeof(arg), &p);
4345 stream->prebuffer = atof(arg) * 1000;
4346 } else if (!av_strcasecmp(cmd, "StartSendOnKey")) {
4348 stream->send_on_key = 1;
4349 } else if (!av_strcasecmp(cmd, "AudioCodec")) {
4350 get_arg(arg, sizeof(arg), &p);
4351 audio_id = opt_audio_codec(arg);
4352 if (audio_id == AV_CODEC_ID_NONE) {
4353 ERROR("Unknown AudioCodec: %s\n", arg);
4355 } else if (!av_strcasecmp(cmd, "VideoCodec")) {
4356 get_arg(arg, sizeof(arg), &p);
4357 video_id = opt_video_codec(arg);
4358 if (video_id == AV_CODEC_ID_NONE) {
4359 ERROR("Unknown VideoCodec: %s\n", arg);
4361 } else if (!av_strcasecmp(cmd, "MaxTime")) {
4362 get_arg(arg, sizeof(arg), &p);
4364 stream->max_time = atof(arg) * 1000;
4365 } else if (!av_strcasecmp(cmd, "AudioBitRate")) {
4366 get_arg(arg, sizeof(arg), &p);
4368 audio_enc.bit_rate = lrintf(atof(arg) * 1000);
4369 } else if (!av_strcasecmp(cmd, "AudioChannels")) {
4370 get_arg(arg, sizeof(arg), &p);
4372 audio_enc.channels = atoi(arg);
4373 } else if (!av_strcasecmp(cmd, "AudioSampleRate")) {
4374 get_arg(arg, sizeof(arg), &p);
4376 audio_enc.sample_rate = atoi(arg);
4377 } else if (!av_strcasecmp(cmd, "AudioQuality")) {
4378 get_arg(arg, sizeof(arg), &p);
4380 // audio_enc.quality = atof(arg) * 1000;
4382 } else if (!av_strcasecmp(cmd, "VideoBitRateRange")) {
4384 int minrate, maxrate;
4386 get_arg(arg, sizeof(arg), &p);
4388 if (sscanf(arg, "%d-%d", &minrate, &maxrate) == 2) {
4389 video_enc.rc_min_rate = minrate * 1000;
4390 video_enc.rc_max_rate = maxrate * 1000;
4392 ERROR("Incorrect format for VideoBitRateRange -- should be <min>-<max>: %s\n", arg);
4395 } else if (!av_strcasecmp(cmd, "Debug")) {
4397 get_arg(arg, sizeof(arg), &p);
4398 video_enc.debug = strtol(arg,0,0);
4400 } else if (!av_strcasecmp(cmd, "Strict")) {
4402 get_arg(arg, sizeof(arg), &p);
4403 video_enc.strict_std_compliance = atoi(arg);
4405 } else if (!av_strcasecmp(cmd, "VideoBufferSize")) {
4407 get_arg(arg, sizeof(arg), &p);
4408 video_enc.rc_buffer_size = atoi(arg) * 8*1024;
4410 } else if (!av_strcasecmp(cmd, "VideoBitRateTolerance")) {
4412 get_arg(arg, sizeof(arg), &p);
4413 video_enc.bit_rate_tolerance = atoi(arg) * 1000;
4415 } else if (!av_strcasecmp(cmd, "VideoBitRate")) {
4416 get_arg(arg, sizeof(arg), &p);
4418 video_enc.bit_rate = atoi(arg) * 1000;
4420 } else if (!av_strcasecmp(cmd, "VideoSize")) {
4421 get_arg(arg, sizeof(arg), &p);
4423 av_parse_video_size(&video_enc.width, &video_enc.height, arg);
4424 if ((video_enc.width % 16) != 0 ||
4425 (video_enc.height % 16) != 0) {
4426 ERROR("Image size must be a multiple of 16\n");
4429 } else if (!av_strcasecmp(cmd, "VideoFrameRate")) {
4430 get_arg(arg, sizeof(arg), &p);
4432 AVRational frame_rate;
4433 if (av_parse_video_rate(&frame_rate, arg) < 0) {
4434 ERROR("Incorrect frame rate: %s\n", arg);
4436 video_enc.time_base.num = frame_rate.den;
4437 video_enc.time_base.den = frame_rate.num;
4440 } else if (!av_strcasecmp(cmd, "PixelFormat")) {
4441 get_arg(arg, sizeof(arg), &p);
4443 video_enc.pix_fmt = av_get_pix_fmt(arg);
4444 if (video_enc.pix_fmt == AV_PIX_FMT_NONE) {
4445 ERROR("Unknown pixel format: %s\n", arg);
4448 } else if (!av_strcasecmp(cmd, "VideoGopSize")) {
4449 get_arg(arg, sizeof(arg), &p);
4451 video_enc.gop_size = atoi(arg);
4452 } else if (!av_strcasecmp(cmd, "VideoIntraOnly")) {
4454 video_enc.gop_size = 1;
4455 } else if (!av_strcasecmp(cmd, "VideoHighQuality")) {
4457 video_enc.mb_decision = FF_MB_DECISION_BITS;
4458 } else if (!av_strcasecmp(cmd, "Video4MotionVector")) {
4460 video_enc.mb_decision = FF_MB_DECISION_BITS; //FIXME remove
4461 video_enc.flags |= CODEC_FLAG_4MV;
4463 } else if (!av_strcasecmp(cmd, "AVOptionVideo") ||
4464 !av_strcasecmp(cmd, "AVOptionAudio")) {
4466 AVCodecContext *avctx;
4468 get_arg(arg, sizeof(arg), &p);
4469 get_arg(arg2, sizeof(arg2), &p);
4470 if (!av_strcasecmp(cmd, "AVOptionVideo")) {
4472 type = AV_OPT_FLAG_VIDEO_PARAM;
4475 type = AV_OPT_FLAG_AUDIO_PARAM;
4477 if (ffserver_opt_default(arg, arg2, avctx, type|AV_OPT_FLAG_ENCODING_PARAM)) {
4478 ERROR("AVOption error: %s %s\n", arg, arg2);
4480 } else if (!av_strcasecmp(cmd, "AVPresetVideo") ||
4481 !av_strcasecmp(cmd, "AVPresetAudio")) {
4482 AVCodecContext *avctx;
4484 get_arg(arg, sizeof(arg), &p);
4485 if (!av_strcasecmp(cmd, "AVPresetVideo")) {
4487 video_enc.codec_id = video_id;
4488 type = AV_OPT_FLAG_VIDEO_PARAM;
4491 audio_enc.codec_id = audio_id;
4492 type = AV_OPT_FLAG_AUDIO_PARAM;
4494 if (ffserver_opt_preset(arg, avctx, type|AV_OPT_FLAG_ENCODING_PARAM, &audio_id, &video_id)) {
4495 ERROR("AVPreset error: %s\n", arg);
4497 } else if (!av_strcasecmp(cmd, "VideoTag")) {
4498 get_arg(arg, sizeof(arg), &p);
4499 if ((strlen(arg) == 4) && stream)
4500 video_enc.codec_tag = MKTAG(arg[0], arg[1], arg[2], arg[3]);
4501 } else if (!av_strcasecmp(cmd, "BitExact")) {
4503 video_enc.flags |= CODEC_FLAG_BITEXACT;
4504 } else if (!av_strcasecmp(cmd, "DctFastint")) {
4506 video_enc.dct_algo = FF_DCT_FASTINT;
4507 } else if (!av_strcasecmp(cmd, "IdctSimple")) {
4509 video_enc.idct_algo = FF_IDCT_SIMPLE;
4510 } else if (!av_strcasecmp(cmd, "Qscale")) {
4511 get_arg(arg, sizeof(arg), &p);
4513 video_enc.flags |= CODEC_FLAG_QSCALE;
4514 video_enc.global_quality = FF_QP2LAMBDA * atoi(arg);
4516 } else if (!av_strcasecmp(cmd, "VideoQDiff")) {
4517 get_arg(arg, sizeof(arg), &p);
4519 video_enc.max_qdiff = atoi(arg);
4520 if (video_enc.max_qdiff < 1 || video_enc.max_qdiff > 31) {
4521 ERROR("VideoQDiff out of range\n");
4524 } else if (!av_strcasecmp(cmd, "VideoQMax")) {
4525 get_arg(arg, sizeof(arg), &p);
4527 video_enc.qmax = atoi(arg);
4528 if (video_enc.qmax < 1 || video_enc.qmax > 31) {
4529 ERROR("VideoQMax out of range\n");
4532 } else if (!av_strcasecmp(cmd, "VideoQMin")) {
4533 get_arg(arg, sizeof(arg), &p);
4535 video_enc.qmin = atoi(arg);
4536 if (video_enc.qmin < 1 || video_enc.qmin > 31) {
4537 ERROR("VideoQMin out of range\n");
4540 } else if (!av_strcasecmp(cmd, "LumiMask")) {
4541 get_arg(arg, sizeof(arg), &p);
4543 video_enc.lumi_masking = atof(arg);
4544 } else if (!av_strcasecmp(cmd, "DarkMask")) {
4545 get_arg(arg, sizeof(arg), &p);
4547 video_enc.dark_masking = atof(arg);
4548 } else if (!av_strcasecmp(cmd, "NoVideo")) {
4549 video_id = AV_CODEC_ID_NONE;
4550 } else if (!av_strcasecmp(cmd, "NoAudio")) {
4551 audio_id = AV_CODEC_ID_NONE;
4552 } else if (!av_strcasecmp(cmd, "ACL")) {
4553 parse_acl_row(stream, feed, NULL, p, filename, line_num);
4554 } else if (!av_strcasecmp(cmd, "DynamicACL")) {
4556 get_arg(stream->dynamic_acl, sizeof(stream->dynamic_acl), &p);
4558 } else if (!av_strcasecmp(cmd, "RTSPOption")) {
4559 get_arg(arg, sizeof(arg), &p);
4561 av_freep(&stream->rtsp_option);
4562 stream->rtsp_option = av_strdup(arg);
4564 } else if (!av_strcasecmp(cmd, "MulticastAddress")) {
4565 get_arg(arg, sizeof(arg), &p);
4567 if (resolve_host(&stream->multicast_ip, arg) != 0) {
4568 ERROR("Invalid host/IP address: %s\n", arg);
4570 stream->is_multicast = 1;
4571 stream->loop = 1; /* default is looping */
4573 } else if (!av_strcasecmp(cmd, "MulticastPort")) {
4574 get_arg(arg, sizeof(arg), &p);
4576 stream->multicast_port = atoi(arg);
4577 } else if (!av_strcasecmp(cmd, "MulticastTTL")) {
4578 get_arg(arg, sizeof(arg), &p);
4580 stream->multicast_ttl = atoi(arg);
4581 } else if (!av_strcasecmp(cmd, "NoLoop")) {
4584 } else if (!av_strcasecmp(cmd, "</Stream>")) {
4586 ERROR("No corresponding <Stream> for </Stream>\n");
4588 if (stream->feed && stream->fmt && strcmp(stream->fmt->name, "ffm") != 0) {
4589 if (audio_id != AV_CODEC_ID_NONE) {
4590 audio_enc.codec_type = AVMEDIA_TYPE_AUDIO;
4591 audio_enc.codec_id = audio_id;
4592 add_codec(stream, &audio_enc);
4594 if (video_id != AV_CODEC_ID_NONE) {
4595 video_enc.codec_type = AVMEDIA_TYPE_VIDEO;
4596 video_enc.codec_id = video_id;
4597 add_codec(stream, &video_enc);
4602 } else if (!av_strcasecmp(cmd, "<Redirect")) {
4603 /*********************************************/
4605 if (stream || feed || redirect) {
4606 ERROR("Already in a tag\n");
4608 redirect = av_mallocz(sizeof(FFStream));
4609 *last_stream = redirect;
4610 last_stream = &redirect->next;
4612 get_arg(redirect->filename, sizeof(redirect->filename), &p);
4613 q = strrchr(redirect->filename, '>');
4616 redirect->stream_type = STREAM_TYPE_REDIRECT;
4618 } else if (!av_strcasecmp(cmd, "URL")) {
4620 get_arg(redirect->feed_filename, sizeof(redirect->feed_filename), &p);
4621 } else if (!av_strcasecmp(cmd, "</Redirect>")) {
4623 ERROR("No corresponding <Redirect> for </Redirect>\n");
4625 if (!redirect->feed_filename[0]) {
4626 ERROR("No URL found for <Redirect>\n");
4630 } else if (!av_strcasecmp(cmd, "LoadModule")) {
4631 ERROR("Loadable modules no longer supported\n");
4633 ERROR("Incorrect keyword: '%s'\n", cmd);
4645 static void handle_child_exit(int sig)
4650 while ((pid = waitpid(-1, &status, WNOHANG)) > 0) {
4653 for (feed = first_feed; feed; feed = feed->next) {
4654 if (feed->pid == pid) {
4655 int uptime = time(0) - feed->pid_start;
4658 fprintf(stderr, "%s: Pid %d exited with status %d after %d seconds\n", feed->filename, pid, status, uptime);
4661 /* Turn off any more restarts */
4662 feed->child_argv = 0;
4667 need_to_start_children = 1;
4670 static void opt_debug(void)
4673 logfilename[0] = '-';
4676 void show_help_default(const char *opt, const char *arg)
4678 printf("usage: ffserver [options]\n"
4679 "Hyper fast multi format Audio/Video streaming server\n");
4681 show_help_options(options, "Main options:", 0, 0, 0);
4684 static const OptionDef options[] = {
4685 #include "cmdutils_common_opts.h"
4686 { "n", OPT_BOOL, {(void *)&no_launch }, "enable no-launch mode" },
4687 { "d", 0, {(void*)opt_debug}, "enable debug mode" },
4688 { "f", HAS_ARG | OPT_STRING, {(void*)&config_filename }, "use configfile instead of /etc/ffserver.conf", "configfile" },
4692 int main(int argc, char **argv)
4694 struct sigaction sigact = { { 0 } };
4696 config_filename = av_strdup("/etc/ffserver.conf");
4698 parse_loglevel(argc, argv, options);
4700 avformat_network_init();
4702 show_banner(argc, argv, options);
4704 my_program_name = argv[0];
4706 parse_options(NULL, argc, argv, options, NULL);
4708 unsetenv("http_proxy"); /* Kill the http_proxy */
4710 av_lfg_init(&random_state, av_get_random_seed());
4712 sigact.sa_handler = handle_child_exit;
4713 sigact.sa_flags = SA_NOCLDSTOP | SA_RESTART;
4714 sigaction(SIGCHLD, &sigact, 0);
4716 if (parse_ffconfig(config_filename) < 0) {
4717 fprintf(stderr, "Incorrect config file - exiting.\n");
4720 av_freep(&config_filename);
4722 /* open log file if needed */
4723 if (logfilename[0] != '\0') {
4724 if (!strcmp(logfilename, "-"))
4727 logfile = fopen(logfilename, "a");
4728 av_log_set_callback(http_av_log);
4731 build_file_streams();
4733 build_feed_streams();
4735 compute_bandwidth();
4738 signal(SIGPIPE, SIG_IGN);
4740 if (http_server() < 0) {
4741 http_log("Could not start server\n");