2 * Multiple format streaming server
3 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
24 #define closesocket close
29 #include "libavformat/avformat.h"
30 #include "libavformat/ffm.h"
31 #include "libavformat/network.h"
32 #include "libavformat/os_support.h"
33 #include "libavformat/rtpdec.h"
34 #include "libavformat/rtsp.h"
35 // XXX for ffio_open_dyn_packet_buffer, to be removed
36 #include "libavformat/avio_internal.h"
37 #include "libavutil/avstring.h"
38 #include "libavutil/lfg.h"
39 #include "libavutil/dict.h"
40 #include "libavutil/mathematics.h"
41 #include "libavutil/random_seed.h"
42 #include "libavutil/parseutils.h"
43 #include "libavutil/opt.h"
47 #include <sys/ioctl.h>
62 const char program_name[] = "ffserver";
63 const int program_birth_year = 2000;
65 static const OptionDef options[];
68 HTTPSTATE_WAIT_REQUEST,
69 HTTPSTATE_SEND_HEADER,
70 HTTPSTATE_SEND_DATA_HEADER,
71 HTTPSTATE_SEND_DATA, /* sending TCP or UDP data */
72 HTTPSTATE_SEND_DATA_TRAILER,
73 HTTPSTATE_RECEIVE_DATA,
74 HTTPSTATE_WAIT_FEED, /* wait for data from the feed */
77 RTSPSTATE_WAIT_REQUEST,
79 RTSPSTATE_SEND_PACKET,
82 static const char *http_state[] = {
98 #define MAX_STREAMS 20
100 #define IOBUFFER_INIT_SIZE 8192
102 /* timeouts are in ms */
103 #define HTTP_REQUEST_TIMEOUT (15 * 1000)
104 #define RTSP_REQUEST_TIMEOUT (3600 * 24 * 1000)
106 #define SYNC_TIMEOUT (10 * 1000)
108 typedef struct RTSPActionServerSetup {
110 char transport_option[512];
111 } RTSPActionServerSetup;
114 int64_t count1, count2;
115 int64_t time1, time2;
118 /* context associated with one connection */
119 typedef struct HTTPContext {
120 enum HTTPState state;
121 int fd; /* socket file descriptor */
122 struct sockaddr_in from_addr; /* origin */
123 struct pollfd *poll_entry; /* used when polling */
125 uint8_t *buffer_ptr, *buffer_end;
128 int chunked_encoding;
129 int chunk_size; /* 0 if it needs to be read */
130 struct HTTPContext *next;
131 int got_key_frame; /* stream 0 => 1, stream 1 => 2, stream 2=> 4 */
135 /* input format handling */
136 AVFormatContext *fmt_in;
137 int64_t start_time; /* In milliseconds - this wraps fairly often */
138 int64_t first_pts; /* initial pts value */
139 int64_t cur_pts; /* current pts value from the stream in us */
140 int64_t cur_frame_duration; /* duration of the current frame in us */
141 int cur_frame_bytes; /* output frame size, needed to compute
142 the time at which we send each
144 int pts_stream_index; /* stream we choose as clock reference */
145 int64_t cur_clock; /* current clock reference value in us */
146 /* output format handling */
147 struct FFStream *stream;
148 /* -1 is invalid stream */
149 int feed_streams[MAX_STREAMS]; /* index of streams in the feed */
150 int switch_feed_streams[MAX_STREAMS]; /* index of streams in the feed */
152 AVFormatContext fmt_ctx; /* instance of FFStream for one user */
153 int last_packet_sent; /* true if last data packet was sent */
155 DataRateData datarate;
162 int is_packetized; /* if true, the stream is packetized */
163 int packet_stream_index; /* current stream for output in state machine */
165 /* RTSP state specific */
166 uint8_t *pb_buffer; /* XXX: use that in all the code */
168 int seq; /* RTSP sequence number */
170 /* RTP state specific */
171 enum RTSPLowerTransport rtp_protocol;
172 char session_id[32]; /* session id */
173 AVFormatContext *rtp_ctx[MAX_STREAMS];
175 /* RTP/UDP specific */
176 URLContext *rtp_handles[MAX_STREAMS];
178 /* RTP/TCP specific */
179 struct HTTPContext *rtsp_c;
180 uint8_t *packet_buffer, *packet_buffer_ptr, *packet_buffer_end;
183 /* each generated stream is described here */
187 STREAM_TYPE_REDIRECT,
190 enum IPAddressAction {
195 typedef struct IPAddressACL {
196 struct IPAddressACL *next;
197 enum IPAddressAction action;
198 /* These are in host order */
199 struct in_addr first;
203 /* description of each stream of the ffserver.conf file */
204 typedef struct FFStream {
205 enum StreamType stream_type;
206 char filename[1024]; /* stream filename */
207 struct FFStream *feed; /* feed we are using (can be null if
209 AVDictionary *in_opts; /* input parameters */
210 AVInputFormat *ifmt; /* if non NULL, force input format */
213 char dynamic_acl[1024];
215 int prebuffer; /* Number of millseconds early to start */
216 int64_t max_time; /* Number of milliseconds to run */
218 AVStream *streams[MAX_STREAMS];
219 int feed_streams[MAX_STREAMS]; /* index of streams in the feed */
220 char feed_filename[1024]; /* file name of the feed storage, or
221 input file name for a stream */
226 pid_t pid; /* Of ffmpeg process */
227 time_t pid_start; /* Of ffmpeg process */
229 struct FFStream *next;
230 unsigned bandwidth; /* bandwidth, in kbits/s */
233 /* multicast specific */
235 struct in_addr multicast_ip;
236 int multicast_port; /* first port used for multicast */
238 int loop; /* if true, send the stream in loops (only meaningful if file) */
241 int feed_opened; /* true if someone is writing to the feed */
242 int is_feed; /* true if it is a feed */
243 int readonly; /* True if writing is prohibited to the file */
244 int truncate; /* True if feeder connection truncate the feed file */
246 int64_t bytes_served;
247 int64_t feed_max_size; /* maximum storage size, zero means unlimited */
248 int64_t feed_write_index; /* current write position in feed (it wraps around) */
249 int64_t feed_size; /* current size of feed */
250 struct FFStream *next_feed;
253 typedef struct FeedData {
254 long long data_count;
255 float avg_frame_size; /* frame size averaged over last frames with exponential mean */
258 static struct sockaddr_in my_http_addr;
259 static struct sockaddr_in my_rtsp_addr;
261 static char logfilename[1024];
262 static HTTPContext *first_http_ctx;
263 static FFStream *first_feed; /* contains only feeds */
264 static FFStream *first_stream; /* contains all streams, including feeds */
266 static void new_connection(int server_fd, int is_rtsp);
267 static void close_connection(HTTPContext *c);
270 static int handle_connection(HTTPContext *c);
271 static int http_parse_request(HTTPContext *c);
272 static int http_send_data(HTTPContext *c);
273 static void compute_status(HTTPContext *c);
274 static int open_input_stream(HTTPContext *c, const char *info);
275 static int http_start_receive_data(HTTPContext *c);
276 static int http_receive_data(HTTPContext *c);
279 static int rtsp_parse_request(HTTPContext *c);
280 static void rtsp_cmd_describe(HTTPContext *c, const char *url);
281 static void rtsp_cmd_options(HTTPContext *c, const char *url);
282 static void rtsp_cmd_setup(HTTPContext *c, const char *url, RTSPMessageHeader *h);
283 static void rtsp_cmd_play(HTTPContext *c, const char *url, RTSPMessageHeader *h);
284 static void rtsp_cmd_pause(HTTPContext *c, const char *url, RTSPMessageHeader *h);
285 static void rtsp_cmd_teardown(HTTPContext *c, const char *url, RTSPMessageHeader *h);
288 static int prepare_sdp_description(FFStream *stream, uint8_t **pbuffer,
289 struct in_addr my_ip);
292 static HTTPContext *rtp_new_connection(struct sockaddr_in *from_addr,
293 FFStream *stream, const char *session_id,
294 enum RTSPLowerTransport rtp_protocol);
295 static int rtp_new_av_stream(HTTPContext *c,
296 int stream_index, struct sockaddr_in *dest_addr,
297 HTTPContext *rtsp_c);
299 static const char *my_program_name;
300 static const char *my_program_dir;
302 static const char *config_filename = "/etc/ffserver.conf";
304 static int ffserver_debug;
305 static int ffserver_daemon;
306 static int no_launch;
307 static int need_to_start_children;
309 /* maximum number of simultaneous HTTP connections */
310 static unsigned int nb_max_http_connections = 2000;
311 static unsigned int nb_max_connections = 5;
312 static unsigned int nb_connections;
314 static uint64_t max_bandwidth = 1000;
315 static uint64_t current_bandwidth;
317 static int64_t cur_time; // Making this global saves on passing it around everywhere
319 static AVLFG random_state;
321 static FILE *logfile = NULL;
323 /* FIXME: make ffserver work with IPv6 */
324 void exit_program(int ret)
329 /* resolve host with also IP address parsing */
330 static int resolve_host(struct in_addr *sin_addr, const char *hostname)
333 if (!ff_inet_aton(hostname, sin_addr)) {
335 struct addrinfo *ai, *cur;
336 struct addrinfo hints;
337 memset(&hints, 0, sizeof(hints));
338 hints.ai_family = AF_INET;
339 if (getaddrinfo(hostname, NULL, &hints, &ai))
341 /* getaddrinfo returns a linked list of addrinfo structs.
342 * Even if we set ai_family = AF_INET above, make sure
343 * that the returned one actually is of the correct type. */
344 for (cur = ai; cur; cur = cur->ai_next) {
345 if (cur->ai_family == AF_INET) {
346 *sin_addr = ((struct sockaddr_in *)cur->ai_addr)->sin_addr;
355 hp = gethostbyname(hostname);
358 memcpy(sin_addr, hp->h_addr_list[0], sizeof(struct in_addr));
364 static char *ctime1(char *buf2)
372 p = buf2 + strlen(p) - 1;
378 static void http_vlog(const char *fmt, va_list vargs)
380 static int print_prefix = 1;
385 fprintf(logfile, "%s ", buf);
387 print_prefix = strstr(fmt, "\n") != NULL;
388 vfprintf(logfile, fmt, vargs);
394 __attribute__ ((format (printf, 1, 2)))
396 static void http_log(const char *fmt, ...)
399 va_start(vargs, fmt);
400 http_vlog(fmt, vargs);
404 static void http_av_log(void *ptr, int level, const char *fmt, va_list vargs)
406 static int print_prefix = 1;
407 AVClass *avc = ptr ? *(AVClass**)ptr : NULL;
408 if (level > av_log_get_level())
410 if (print_prefix && avc)
411 http_log("[%s @ %p]", avc->item_name(ptr), ptr);
412 print_prefix = strstr(fmt, "\n") != NULL;
413 http_vlog(fmt, vargs);
416 static void log_connection(HTTPContext *c)
421 http_log("%s - - [%s] \"%s %s\" %d %"PRId64"\n",
422 inet_ntoa(c->from_addr.sin_addr), c->method, c->url,
423 c->protocol, (c->http_error ? c->http_error : 200), c->data_count);
426 static void update_datarate(DataRateData *drd, int64_t count)
428 if (!drd->time1 && !drd->count1) {
429 drd->time1 = drd->time2 = cur_time;
430 drd->count1 = drd->count2 = count;
431 } else if (cur_time - drd->time2 > 5000) {
432 drd->time1 = drd->time2;
433 drd->count1 = drd->count2;
434 drd->time2 = cur_time;
439 /* In bytes per second */
440 static int compute_datarate(DataRateData *drd, int64_t count)
442 if (cur_time == drd->time1)
445 return ((count - drd->count1) * 1000) / (cur_time - drd->time1);
449 static void start_children(FFStream *feed)
454 for (; feed; feed = feed->next) {
455 if (feed->child_argv && !feed->pid) {
456 feed->pid_start = time(0);
461 http_log("Unable to create children\n");
470 av_strlcpy(pathname, my_program_name, sizeof(pathname));
472 slash = strrchr(pathname, '/');
477 strcpy(slash, "ffmpeg");
479 http_log("Launch commandline: ");
480 http_log("%s ", pathname);
481 for (i = 1; feed->child_argv[i] && feed->child_argv[i][0]; i++)
482 http_log("%s ", feed->child_argv[i]);
485 for (i = 3; i < 256; i++)
488 if (!ffserver_debug) {
489 i = open("/dev/null", O_RDWR);
498 /* This is needed to make relative pathnames work */
499 chdir(my_program_dir);
501 signal(SIGPIPE, SIG_DFL);
503 execvp(pathname, feed->child_argv);
511 /* open a listening socket */
512 static int socket_open_listen(struct sockaddr_in *my_addr)
516 server_fd = socket(AF_INET,SOCK_STREAM,0);
523 setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &tmp, sizeof(tmp));
525 my_addr->sin_family = AF_INET;
526 if (bind (server_fd, (struct sockaddr *) my_addr, sizeof (*my_addr)) < 0) {
528 snprintf(bindmsg, sizeof(bindmsg), "bind(port %d)", ntohs(my_addr->sin_port));
530 closesocket(server_fd);
534 if (listen (server_fd, 5) < 0) {
536 closesocket(server_fd);
539 ff_socket_nonblock(server_fd, 1);
544 /* start all multicast streams */
545 static void start_multicast(void)
550 struct sockaddr_in dest_addr;
551 int default_port, stream_index;
554 for(stream = first_stream; stream != NULL; stream = stream->next) {
555 if (stream->is_multicast) {
556 /* open the RTP connection */
557 snprintf(session_id, sizeof(session_id), "%08x%08x",
558 av_lfg_get(&random_state), av_lfg_get(&random_state));
560 /* choose a port if none given */
561 if (stream->multicast_port == 0) {
562 stream->multicast_port = default_port;
566 dest_addr.sin_family = AF_INET;
567 dest_addr.sin_addr = stream->multicast_ip;
568 dest_addr.sin_port = htons(stream->multicast_port);
570 rtp_c = rtp_new_connection(&dest_addr, stream, session_id,
571 RTSP_LOWER_TRANSPORT_UDP_MULTICAST);
575 if (open_input_stream(rtp_c, "") < 0) {
576 http_log("Could not open input stream for stream '%s'\n",
581 /* open each RTP stream */
582 for(stream_index = 0; stream_index < stream->nb_streams;
584 dest_addr.sin_port = htons(stream->multicast_port +
586 if (rtp_new_av_stream(rtp_c, stream_index, &dest_addr, NULL) < 0) {
587 http_log("Could not open output stream '%s/streamid=%d'\n",
588 stream->filename, stream_index);
593 /* change state to send data */
594 rtp_c->state = HTTPSTATE_SEND_DATA;
599 /* main loop of the http server */
600 static int http_server(void)
602 int server_fd = 0, rtsp_server_fd = 0;
603 int ret, delay, delay1;
604 struct pollfd *poll_table, *poll_entry;
605 HTTPContext *c, *c_next;
607 if(!(poll_table = av_mallocz((nb_max_http_connections + 2)*sizeof(*poll_table)))) {
608 http_log("Impossible to allocate a poll table handling %d connections.\n", nb_max_http_connections);
612 if (my_http_addr.sin_port) {
613 server_fd = socket_open_listen(&my_http_addr);
618 if (my_rtsp_addr.sin_port) {
619 rtsp_server_fd = socket_open_listen(&my_rtsp_addr);
620 if (rtsp_server_fd < 0)
624 if (!rtsp_server_fd && !server_fd) {
625 http_log("HTTP and RTSP disabled.\n");
629 http_log("FFserver started.\n");
631 start_children(first_feed);
636 poll_entry = poll_table;
638 poll_entry->fd = server_fd;
639 poll_entry->events = POLLIN;
642 if (rtsp_server_fd) {
643 poll_entry->fd = rtsp_server_fd;
644 poll_entry->events = POLLIN;
648 /* wait for events on each HTTP handle */
655 case HTTPSTATE_SEND_HEADER:
656 case RTSPSTATE_SEND_REPLY:
657 case RTSPSTATE_SEND_PACKET:
658 c->poll_entry = poll_entry;
660 poll_entry->events = POLLOUT;
663 case HTTPSTATE_SEND_DATA_HEADER:
664 case HTTPSTATE_SEND_DATA:
665 case HTTPSTATE_SEND_DATA_TRAILER:
666 if (!c->is_packetized) {
667 /* for TCP, we output as much as we can (may need to put a limit) */
668 c->poll_entry = poll_entry;
670 poll_entry->events = POLLOUT;
673 /* when ffserver is doing the timing, we work by
674 looking at which packet need to be sent every
676 delay1 = 10; /* one tick wait XXX: 10 ms assumed */
681 case HTTPSTATE_WAIT_REQUEST:
682 case HTTPSTATE_RECEIVE_DATA:
683 case HTTPSTATE_WAIT_FEED:
684 case RTSPSTATE_WAIT_REQUEST:
685 /* need to catch errors */
686 c->poll_entry = poll_entry;
688 poll_entry->events = POLLIN;/* Maybe this will work */
692 c->poll_entry = NULL;
698 /* wait for an event on one connection. We poll at least every
699 second to handle timeouts */
701 ret = poll(poll_table, poll_entry - poll_table, delay);
702 if (ret < 0 && ff_neterrno() != AVERROR(EAGAIN) &&
703 ff_neterrno() != AVERROR(EINTR))
707 cur_time = av_gettime() / 1000;
709 if (need_to_start_children) {
710 need_to_start_children = 0;
711 start_children(first_feed);
714 /* now handle the events */
715 for(c = first_http_ctx; c != NULL; c = c_next) {
717 if (handle_connection(c) < 0) {
718 /* close and free the connection */
724 poll_entry = poll_table;
726 /* new HTTP connection request ? */
727 if (poll_entry->revents & POLLIN)
728 new_connection(server_fd, 0);
731 if (rtsp_server_fd) {
732 /* new RTSP connection request ? */
733 if (poll_entry->revents & POLLIN)
734 new_connection(rtsp_server_fd, 1);
739 /* start waiting for a new HTTP/RTSP request */
740 static void start_wait_request(HTTPContext *c, int is_rtsp)
742 c->buffer_ptr = c->buffer;
743 c->buffer_end = c->buffer + c->buffer_size - 1; /* leave room for '\0' */
746 c->timeout = cur_time + RTSP_REQUEST_TIMEOUT;
747 c->state = RTSPSTATE_WAIT_REQUEST;
749 c->timeout = cur_time + HTTP_REQUEST_TIMEOUT;
750 c->state = HTTPSTATE_WAIT_REQUEST;
754 static void http_send_too_busy_reply(int fd)
757 int len = snprintf(buffer, sizeof(buffer),
758 "HTTP/1.0 503 Server too busy\r\n"
759 "Content-type: text/html\r\n"
761 "<html><head><title>Too busy</title></head><body>\r\n"
762 "<p>The server is too busy to serve your request at this time.</p>\r\n"
763 "<p>The number of current connections is %d, and this exceeds the limit of %d.</p>\r\n"
764 "</body></html>\r\n",
765 nb_connections, nb_max_connections);
766 send(fd, buffer, len, 0);
770 static void new_connection(int server_fd, int is_rtsp)
772 struct sockaddr_in from_addr;
774 HTTPContext *c = NULL;
776 len = sizeof(from_addr);
777 fd = accept(server_fd, (struct sockaddr *)&from_addr,
780 http_log("error during accept %s\n", strerror(errno));
783 ff_socket_nonblock(fd, 1);
785 if (nb_connections >= nb_max_connections) {
786 http_send_too_busy_reply(fd);
790 /* add a new connection */
791 c = av_mallocz(sizeof(HTTPContext));
796 c->poll_entry = NULL;
797 c->from_addr = from_addr;
798 c->buffer_size = IOBUFFER_INIT_SIZE;
799 c->buffer = av_malloc(c->buffer_size);
803 c->next = first_http_ctx;
807 start_wait_request(c, is_rtsp);
819 static void close_connection(HTTPContext *c)
821 HTTPContext **cp, *c1;
823 AVFormatContext *ctx;
827 /* remove connection from list */
828 cp = &first_http_ctx;
829 while ((*cp) != NULL) {
837 /* remove references, if any (XXX: do it faster) */
838 for(c1 = first_http_ctx; c1 != NULL; c1 = c1->next) {
843 /* remove connection associated resources */
847 /* close each frame parser */
848 for(i=0;i<c->fmt_in->nb_streams;i++) {
849 st = c->fmt_in->streams[i];
850 if (st->codec->codec)
851 avcodec_close(st->codec);
853 av_close_input_file(c->fmt_in);
856 /* free RTP output streams if any */
859 nb_streams = c->stream->nb_streams;
861 for(i=0;i<nb_streams;i++) {
864 av_write_trailer(ctx);
865 av_dict_free(&ctx->metadata);
866 av_free(ctx->streams[0]);
869 h = c->rtp_handles[i];
876 if (!c->last_packet_sent && c->state == HTTPSTATE_SEND_DATA_TRAILER) {
879 if (avio_open_dyn_buf(&ctx->pb) >= 0) {
880 av_write_trailer(ctx);
881 av_freep(&c->pb_buffer);
882 avio_close_dyn_buf(ctx->pb, &c->pb_buffer);
887 for(i=0; i<ctx->nb_streams; i++)
888 av_free(ctx->streams[i]);
890 if (c->stream && !c->post && c->stream->stream_type == STREAM_TYPE_LIVE)
891 current_bandwidth -= c->stream->bandwidth;
893 /* signal that there is no feed if we are the feeder socket */
894 if (c->state == HTTPSTATE_RECEIVE_DATA && c->stream) {
895 c->stream->feed_opened = 0;
899 av_freep(&c->pb_buffer);
900 av_freep(&c->packet_buffer);
906 static int handle_connection(HTTPContext *c)
911 case HTTPSTATE_WAIT_REQUEST:
912 case RTSPSTATE_WAIT_REQUEST:
914 if ((c->timeout - cur_time) < 0)
916 if (c->poll_entry->revents & (POLLERR | POLLHUP))
919 /* no need to read if no events */
920 if (!(c->poll_entry->revents & POLLIN))
924 len = recv(c->fd, c->buffer_ptr, 1, 0);
926 if (ff_neterrno() != AVERROR(EAGAIN) &&
927 ff_neterrno() != AVERROR(EINTR))
929 } else if (len == 0) {
932 /* search for end of request. */
934 c->buffer_ptr += len;
936 if ((ptr >= c->buffer + 2 && !memcmp(ptr-2, "\n\n", 2)) ||
937 (ptr >= c->buffer + 4 && !memcmp(ptr-4, "\r\n\r\n", 4))) {
938 /* request found : parse it and reply */
939 if (c->state == HTTPSTATE_WAIT_REQUEST) {
940 ret = http_parse_request(c);
942 ret = rtsp_parse_request(c);
946 } else if (ptr >= c->buffer_end) {
947 /* request too long: cannot do anything */
949 } else goto read_loop;
953 case HTTPSTATE_SEND_HEADER:
954 if (c->poll_entry->revents & (POLLERR | POLLHUP))
957 /* no need to write if no events */
958 if (!(c->poll_entry->revents & POLLOUT))
960 len = send(c->fd, c->buffer_ptr, c->buffer_end - c->buffer_ptr, 0);
962 if (ff_neterrno() != AVERROR(EAGAIN) &&
963 ff_neterrno() != AVERROR(EINTR)) {
964 /* error : close connection */
965 av_freep(&c->pb_buffer);
969 c->buffer_ptr += len;
971 c->stream->bytes_served += len;
972 c->data_count += len;
973 if (c->buffer_ptr >= c->buffer_end) {
974 av_freep(&c->pb_buffer);
978 /* all the buffer was sent : synchronize to the incoming stream */
979 c->state = HTTPSTATE_SEND_DATA_HEADER;
980 c->buffer_ptr = c->buffer_end = c->buffer;
985 case HTTPSTATE_SEND_DATA:
986 case HTTPSTATE_SEND_DATA_HEADER:
987 case HTTPSTATE_SEND_DATA_TRAILER:
988 /* for packetized output, we consider we can always write (the
989 input streams sets the speed). It may be better to verify
990 that we do not rely too much on the kernel queues */
991 if (!c->is_packetized) {
992 if (c->poll_entry->revents & (POLLERR | POLLHUP))
995 /* no need to read if no events */
996 if (!(c->poll_entry->revents & POLLOUT))
999 if (http_send_data(c) < 0)
1001 /* close connection if trailer sent */
1002 if (c->state == HTTPSTATE_SEND_DATA_TRAILER)
1005 case HTTPSTATE_RECEIVE_DATA:
1006 /* no need to read if no events */
1007 if (c->poll_entry->revents & (POLLERR | POLLHUP))
1009 if (!(c->poll_entry->revents & POLLIN))
1011 if (http_receive_data(c) < 0)
1014 case HTTPSTATE_WAIT_FEED:
1015 /* no need to read if no events */
1016 if (c->poll_entry->revents & (POLLIN | POLLERR | POLLHUP))
1019 /* nothing to do, we'll be waken up by incoming feed packets */
1022 case RTSPSTATE_SEND_REPLY:
1023 if (c->poll_entry->revents & (POLLERR | POLLHUP)) {
1024 av_freep(&c->pb_buffer);
1027 /* no need to write if no events */
1028 if (!(c->poll_entry->revents & POLLOUT))
1030 len = send(c->fd, c->buffer_ptr, c->buffer_end - c->buffer_ptr, 0);
1032 if (ff_neterrno() != AVERROR(EAGAIN) &&
1033 ff_neterrno() != AVERROR(EINTR)) {
1034 /* error : close connection */
1035 av_freep(&c->pb_buffer);
1039 c->buffer_ptr += len;
1040 c->data_count += len;
1041 if (c->buffer_ptr >= c->buffer_end) {
1042 /* all the buffer was sent : wait for a new request */
1043 av_freep(&c->pb_buffer);
1044 start_wait_request(c, 1);
1048 case RTSPSTATE_SEND_PACKET:
1049 if (c->poll_entry->revents & (POLLERR | POLLHUP)) {
1050 av_freep(&c->packet_buffer);
1053 /* no need to write if no events */
1054 if (!(c->poll_entry->revents & POLLOUT))
1056 len = send(c->fd, c->packet_buffer_ptr,
1057 c->packet_buffer_end - c->packet_buffer_ptr, 0);
1059 if (ff_neterrno() != AVERROR(EAGAIN) &&
1060 ff_neterrno() != AVERROR(EINTR)) {
1061 /* error : close connection */
1062 av_freep(&c->packet_buffer);
1066 c->packet_buffer_ptr += len;
1067 if (c->packet_buffer_ptr >= c->packet_buffer_end) {
1068 /* all the buffer was sent : wait for a new request */
1069 av_freep(&c->packet_buffer);
1070 c->state = RTSPSTATE_WAIT_REQUEST;
1074 case HTTPSTATE_READY:
1083 static int extract_rates(char *rates, int ratelen, const char *request)
1087 for (p = request; *p && *p != '\r' && *p != '\n'; ) {
1088 if (strncasecmp(p, "Pragma:", 7) == 0) {
1089 const char *q = p + 7;
1091 while (*q && *q != '\n' && isspace(*q))
1094 if (strncasecmp(q, "stream-switch-entry=", 20) == 0) {
1100 memset(rates, 0xff, ratelen);
1103 while (*q && *q != '\n' && *q != ':')
1106 if (sscanf(q, ":%d:%d", &stream_no, &rate_no) != 2)
1110 if (stream_no < ratelen && stream_no >= 0)
1111 rates[stream_no] = rate_no;
1113 while (*q && *q != '\n' && !isspace(*q))
1120 p = strchr(p, '\n');
1130 static int find_stream_in_feed(FFStream *feed, AVCodecContext *codec, int bit_rate)
1133 int best_bitrate = 100000000;
1136 for (i = 0; i < feed->nb_streams; i++) {
1137 AVCodecContext *feed_codec = feed->streams[i]->codec;
1139 if (feed_codec->codec_id != codec->codec_id ||
1140 feed_codec->sample_rate != codec->sample_rate ||
1141 feed_codec->width != codec->width ||
1142 feed_codec->height != codec->height)
1145 /* Potential stream */
1147 /* We want the fastest stream less than bit_rate, or the slowest
1148 * faster than bit_rate
1151 if (feed_codec->bit_rate <= bit_rate) {
1152 if (best_bitrate > bit_rate || feed_codec->bit_rate > best_bitrate) {
1153 best_bitrate = feed_codec->bit_rate;
1157 if (feed_codec->bit_rate < best_bitrate) {
1158 best_bitrate = feed_codec->bit_rate;
1167 static int modify_current_stream(HTTPContext *c, char *rates)
1170 FFStream *req = c->stream;
1171 int action_required = 0;
1173 /* Not much we can do for a feed */
1177 for (i = 0; i < req->nb_streams; i++) {
1178 AVCodecContext *codec = req->streams[i]->codec;
1182 c->switch_feed_streams[i] = req->feed_streams[i];
1185 c->switch_feed_streams[i] = find_stream_in_feed(req->feed, codec, codec->bit_rate / 2);
1188 /* Wants off or slow */
1189 c->switch_feed_streams[i] = find_stream_in_feed(req->feed, codec, codec->bit_rate / 4);
1191 /* This doesn't work well when it turns off the only stream! */
1192 c->switch_feed_streams[i] = -2;
1193 c->feed_streams[i] = -2;
1198 if (c->switch_feed_streams[i] >= 0 && c->switch_feed_streams[i] != c->feed_streams[i])
1199 action_required = 1;
1202 return action_required;
1205 /* XXX: factorize in utils.c ? */
1206 /* XXX: take care with different space meaning */
1207 static void skip_spaces(const char **pp)
1211 while (*p == ' ' || *p == '\t')
1216 static void get_word(char *buf, int buf_size, const char **pp)
1224 while (!isspace(*p) && *p != '\0') {
1225 if ((q - buf) < buf_size - 1)
1234 static void get_arg(char *buf, int buf_size, const char **pp)
1241 while (isspace(*p)) p++;
1244 if (*p == '\"' || *p == '\'')
1256 if ((q - buf) < buf_size - 1)
1261 if (quote && *p == quote)
1266 static void parse_acl_row(FFStream *stream, FFStream* feed, IPAddressACL *ext_acl,
1267 const char *p, const char *filename, int line_num)
1273 get_arg(arg, sizeof(arg), &p);
1274 if (strcasecmp(arg, "allow") == 0)
1275 acl.action = IP_ALLOW;
1276 else if (strcasecmp(arg, "deny") == 0)
1277 acl.action = IP_DENY;
1279 fprintf(stderr, "%s:%d: ACL action '%s' is not ALLOW or DENY\n",
1280 filename, line_num, arg);
1284 get_arg(arg, sizeof(arg), &p);
1286 if (resolve_host(&acl.first, arg) != 0) {
1287 fprintf(stderr, "%s:%d: ACL refers to invalid host or ip address '%s'\n",
1288 filename, line_num, arg);
1291 acl.last = acl.first;
1293 get_arg(arg, sizeof(arg), &p);
1296 if (resolve_host(&acl.last, arg) != 0) {
1297 fprintf(stderr, "%s:%d: ACL refers to invalid host or ip address '%s'\n",
1298 filename, line_num, arg);
1304 IPAddressACL *nacl = av_mallocz(sizeof(*nacl));
1305 IPAddressACL **naclp = 0;
1311 naclp = &stream->acl;
1317 fprintf(stderr, "%s:%d: ACL found not in <stream> or <feed>\n",
1318 filename, line_num);
1324 naclp = &(*naclp)->next;
1332 static IPAddressACL* parse_dynamic_acl(FFStream *stream, HTTPContext *c)
1337 IPAddressACL *acl = NULL;
1341 f = fopen(stream->dynamic_acl, "r");
1343 perror(stream->dynamic_acl);
1347 acl = av_mallocz(sizeof(IPAddressACL));
1351 if (fgets(line, sizeof(line), f) == NULL)
1357 if (*p == '\0' || *p == '#')
1359 get_arg(cmd, sizeof(cmd), &p);
1361 if (!strcasecmp(cmd, "ACL"))
1362 parse_acl_row(NULL, NULL, acl, p, stream->dynamic_acl, line_num);
1369 static void free_acl_list(IPAddressACL *in_acl)
1371 IPAddressACL *pacl,*pacl2;
1381 static int validate_acl_list(IPAddressACL *in_acl, HTTPContext *c)
1383 enum IPAddressAction last_action = IP_DENY;
1385 struct in_addr *src = &c->from_addr.sin_addr;
1386 unsigned long src_addr = src->s_addr;
1388 for (acl = in_acl; acl; acl = acl->next) {
1389 if (src_addr >= acl->first.s_addr && src_addr <= acl->last.s_addr)
1390 return (acl->action == IP_ALLOW) ? 1 : 0;
1391 last_action = acl->action;
1394 /* Nothing matched, so return not the last action */
1395 return (last_action == IP_DENY) ? 1 : 0;
1398 static int validate_acl(FFStream *stream, HTTPContext *c)
1404 /* if stream->acl is null validate_acl_list will return 1 */
1405 ret = validate_acl_list(stream->acl, c);
1407 if (stream->dynamic_acl[0]) {
1408 acl = parse_dynamic_acl(stream, c);
1410 ret = validate_acl_list(acl, c);
1418 /* compute the real filename of a file by matching it without its
1419 extensions to all the stream filenames */
1420 static void compute_real_filename(char *filename, int max_size)
1427 /* compute filename by matching without the file extensions */
1428 av_strlcpy(file1, filename, sizeof(file1));
1429 p = strrchr(file1, '.');
1432 for(stream = first_stream; stream != NULL; stream = stream->next) {
1433 av_strlcpy(file2, stream->filename, sizeof(file2));
1434 p = strrchr(file2, '.');
1437 if (!strcmp(file1, file2)) {
1438 av_strlcpy(filename, stream->filename, max_size);
1453 /* parse http request and prepare header */
1454 static int http_parse_request(HTTPContext *c)
1457 enum RedirType redir_type;
1459 char info[1024], filename[1024];
1463 const char *mime_type;
1467 char *useragent = 0;
1470 get_word(cmd, sizeof(cmd), (const char **)&p);
1471 av_strlcpy(c->method, cmd, sizeof(c->method));
1473 if (!strcmp(cmd, "GET"))
1475 else if (!strcmp(cmd, "POST"))
1480 get_word(url, sizeof(url), (const char **)&p);
1481 av_strlcpy(c->url, url, sizeof(c->url));
1483 get_word(protocol, sizeof(protocol), (const char **)&p);
1484 if (strcmp(protocol, "HTTP/1.0") && strcmp(protocol, "HTTP/1.1"))
1487 av_strlcpy(c->protocol, protocol, sizeof(c->protocol));
1490 http_log("%s - - New connection: %s %s\n", inet_ntoa(c->from_addr.sin_addr), cmd, url);
1492 /* find the filename and the optional info string in the request */
1493 p = strchr(url, '?');
1495 av_strlcpy(info, p, sizeof(info));
1500 av_strlcpy(filename, url + ((*url == '/') ? 1 : 0), sizeof(filename)-1);
1502 for (p = c->buffer; *p && *p != '\r' && *p != '\n'; ) {
1503 if (strncasecmp(p, "User-Agent:", 11) == 0) {
1505 if (*useragent && *useragent != '\n' && isspace(*useragent))
1509 p = strchr(p, '\n');
1516 redir_type = REDIR_NONE;
1517 if (av_match_ext(filename, "asx")) {
1518 redir_type = REDIR_ASX;
1519 filename[strlen(filename)-1] = 'f';
1520 } else if (av_match_ext(filename, "asf") &&
1521 (!useragent || strncasecmp(useragent, "NSPlayer", 8) != 0)) {
1522 /* if this isn't WMP or lookalike, return the redirector file */
1523 redir_type = REDIR_ASF;
1524 } else if (av_match_ext(filename, "rpm,ram")) {
1525 redir_type = REDIR_RAM;
1526 strcpy(filename + strlen(filename)-2, "m");
1527 } else if (av_match_ext(filename, "rtsp")) {
1528 redir_type = REDIR_RTSP;
1529 compute_real_filename(filename, sizeof(filename) - 1);
1530 } else if (av_match_ext(filename, "sdp")) {
1531 redir_type = REDIR_SDP;
1532 compute_real_filename(filename, sizeof(filename) - 1);
1535 // "redirect" / request to index.html
1536 if (!strlen(filename))
1537 av_strlcpy(filename, "index.html", sizeof(filename) - 1);
1539 stream = first_stream;
1540 while (stream != NULL) {
1541 if (!strcmp(stream->filename, filename) && validate_acl(stream, c))
1543 stream = stream->next;
1545 if (stream == NULL) {
1546 snprintf(msg, sizeof(msg), "File '%s' not found", url);
1547 http_log("File '%s' not found\n", url);
1552 memcpy(c->feed_streams, stream->feed_streams, sizeof(c->feed_streams));
1553 memset(c->switch_feed_streams, -1, sizeof(c->switch_feed_streams));
1555 if (stream->stream_type == STREAM_TYPE_REDIRECT) {
1556 c->http_error = 301;
1558 q += snprintf(q, c->buffer_size,
1559 "HTTP/1.0 301 Moved\r\n"
1561 "Content-type: text/html\r\n"
1563 "<html><head><title>Moved</title></head><body>\r\n"
1564 "You should be <a href=\"%s\">redirected</a>.\r\n"
1565 "</body></html>\r\n", stream->feed_filename, stream->feed_filename);
1566 /* prepare output buffer */
1567 c->buffer_ptr = c->buffer;
1569 c->state = HTTPSTATE_SEND_HEADER;
1573 /* If this is WMP, get the rate information */
1574 if (extract_rates(ratebuf, sizeof(ratebuf), c->buffer)) {
1575 if (modify_current_stream(c, ratebuf)) {
1576 for (i = 0; i < FF_ARRAY_ELEMS(c->feed_streams); i++) {
1577 if (c->switch_feed_streams[i] >= 0)
1578 c->switch_feed_streams[i] = -1;
1583 if (c->post == 0 && stream->stream_type == STREAM_TYPE_LIVE)
1584 current_bandwidth += stream->bandwidth;
1586 /* If already streaming this feed, do not let start another feeder. */
1587 if (stream->feed_opened) {
1588 snprintf(msg, sizeof(msg), "This feed is already being received.");
1589 http_log("Feed '%s' already being received\n", stream->feed_filename);
1593 if (c->post == 0 && max_bandwidth < current_bandwidth) {
1594 c->http_error = 503;
1596 q += snprintf(q, c->buffer_size,
1597 "HTTP/1.0 503 Server too busy\r\n"
1598 "Content-type: text/html\r\n"
1600 "<html><head><title>Too busy</title></head><body>\r\n"
1601 "<p>The server is too busy to serve your request at this time.</p>\r\n"
1602 "<p>The bandwidth being served (including your stream) is %"PRIu64"kbit/sec, "
1603 "and this exceeds the limit of %"PRIu64"kbit/sec.</p>\r\n"
1604 "</body></html>\r\n", current_bandwidth, max_bandwidth);
1605 /* prepare output buffer */
1606 c->buffer_ptr = c->buffer;
1608 c->state = HTTPSTATE_SEND_HEADER;
1612 if (redir_type != REDIR_NONE) {
1615 for (p = c->buffer; *p && *p != '\r' && *p != '\n'; ) {
1616 if (strncasecmp(p, "Host:", 5) == 0) {
1620 p = strchr(p, '\n');
1631 while (isspace(*hostinfo))
1634 eoh = strchr(hostinfo, '\n');
1636 if (eoh[-1] == '\r')
1639 if (eoh - hostinfo < sizeof(hostbuf) - 1) {
1640 memcpy(hostbuf, hostinfo, eoh - hostinfo);
1641 hostbuf[eoh - hostinfo] = 0;
1643 c->http_error = 200;
1645 switch(redir_type) {
1647 q += snprintf(q, c->buffer_size,
1648 "HTTP/1.0 200 ASX Follows\r\n"
1649 "Content-type: video/x-ms-asf\r\n"
1651 "<ASX Version=\"3\">\r\n"
1652 //"<!-- Autogenerated by ffserver -->\r\n"
1653 "<ENTRY><REF HREF=\"http://%s/%s%s\"/></ENTRY>\r\n"
1654 "</ASX>\r\n", hostbuf, filename, info);
1657 q += snprintf(q, c->buffer_size,
1658 "HTTP/1.0 200 RAM Follows\r\n"
1659 "Content-type: audio/x-pn-realaudio\r\n"
1661 "# Autogenerated by ffserver\r\n"
1662 "http://%s/%s%s\r\n", hostbuf, filename, info);
1665 q += snprintf(q, c->buffer_size,
1666 "HTTP/1.0 200 ASF Redirect follows\r\n"
1667 "Content-type: video/x-ms-asf\r\n"
1670 "Ref1=http://%s/%s%s\r\n", hostbuf, filename, info);
1674 char hostname[256], *p;
1675 /* extract only hostname */
1676 av_strlcpy(hostname, hostbuf, sizeof(hostname));
1677 p = strrchr(hostname, ':');
1680 q += snprintf(q, c->buffer_size,
1681 "HTTP/1.0 200 RTSP Redirect follows\r\n"
1682 /* XXX: incorrect mime type ? */
1683 "Content-type: application/x-rtsp\r\n"
1685 "rtsp://%s:%d/%s\r\n", hostname, ntohs(my_rtsp_addr.sin_port), filename);
1691 int sdp_data_size, len;
1692 struct sockaddr_in my_addr;
1694 q += snprintf(q, c->buffer_size,
1695 "HTTP/1.0 200 OK\r\n"
1696 "Content-type: application/sdp\r\n"
1699 len = sizeof(my_addr);
1700 getsockname(c->fd, (struct sockaddr *)&my_addr, &len);
1702 /* XXX: should use a dynamic buffer */
1703 sdp_data_size = prepare_sdp_description(stream,
1706 if (sdp_data_size > 0) {
1707 memcpy(q, sdp_data, sdp_data_size);
1719 /* prepare output buffer */
1720 c->buffer_ptr = c->buffer;
1722 c->state = HTTPSTATE_SEND_HEADER;
1728 snprintf(msg, sizeof(msg), "ASX/RAM file not handled");
1732 stream->conns_served++;
1734 /* XXX: add there authenticate and IP match */
1737 /* if post, it means a feed is being sent */
1738 if (!stream->is_feed) {
1739 /* However it might be a status report from WMP! Let us log the
1740 * data as it might come in handy one day. */
1744 for (p = c->buffer; *p && *p != '\r' && *p != '\n'; ) {
1745 if (strncasecmp(p, "Pragma: log-line=", 17) == 0) {
1749 if (strncasecmp(p, "Pragma: client-id=", 18) == 0)
1750 client_id = strtol(p + 18, 0, 10);
1751 p = strchr(p, '\n');
1759 char *eol = strchr(logline, '\n');
1764 if (eol[-1] == '\r')
1766 http_log("%.*s\n", (int) (eol - logline), logline);
1767 c->suppress_log = 1;
1772 http_log("\nGot request:\n%s\n", c->buffer);
1775 if (client_id && extract_rates(ratebuf, sizeof(ratebuf), c->buffer)) {
1778 /* Now we have to find the client_id */
1779 for (wmpc = first_http_ctx; wmpc; wmpc = wmpc->next) {
1780 if (wmpc->wmp_client_id == client_id)
1784 if (wmpc && modify_current_stream(wmpc, ratebuf))
1785 wmpc->switch_pending = 1;
1788 snprintf(msg, sizeof(msg), "POST command not handled");
1792 if (http_start_receive_data(c) < 0) {
1793 snprintf(msg, sizeof(msg), "could not open feed");
1797 c->state = HTTPSTATE_RECEIVE_DATA;
1802 if (strcmp(stream->filename + strlen(stream->filename) - 4, ".asf") == 0)
1803 http_log("\nGot request:\n%s\n", c->buffer);
1806 if (c->stream->stream_type == STREAM_TYPE_STATUS)
1809 /* open input stream */
1810 if (open_input_stream(c, info) < 0) {
1811 snprintf(msg, sizeof(msg), "Input stream corresponding to '%s' not found", url);
1815 /* prepare http header */
1817 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "HTTP/1.0 200 OK\r\n");
1818 mime_type = c->stream->fmt->mime_type;
1820 mime_type = "application/x-octet-stream";
1821 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "Pragma: no-cache\r\n");
1823 /* for asf, we need extra headers */
1824 if (!strcmp(c->stream->fmt->name,"asf_stream")) {
1825 /* Need to allocate a client id */
1827 c->wmp_client_id = av_lfg_get(&random_state);
1829 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "Server: Cougar 4.1.0.3923\r\nCache-Control: no-cache\r\nPragma: client-id=%d\r\nPragma: features=\"broadcast\"\r\n", c->wmp_client_id);
1831 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "Content-Type: %s\r\n", mime_type);
1832 q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "\r\n");
1834 /* prepare output buffer */
1836 c->buffer_ptr = c->buffer;
1838 c->state = HTTPSTATE_SEND_HEADER;
1841 c->http_error = 404;
1843 q += snprintf(q, c->buffer_size,
1844 "HTTP/1.0 404 Not Found\r\n"
1845 "Content-type: text/html\r\n"
1848 "<head><title>404 Not Found</title></head>\n"
1851 /* prepare output buffer */
1852 c->buffer_ptr = c->buffer;
1854 c->state = HTTPSTATE_SEND_HEADER;
1858 c->http_error = 200; /* horrible : we use this value to avoid
1859 going to the send data state */
1860 c->state = HTTPSTATE_SEND_HEADER;
1864 static void fmt_bytecount(AVIOContext *pb, int64_t count)
1866 static const char *suffix = " kMGTP";
1869 for (s = suffix; count >= 100000 && s[1]; count /= 1000, s++);
1871 avio_printf(pb, "%"PRId64"%c", count, *s);
1874 static void compute_status(HTTPContext *c)
1883 if (avio_open_dyn_buf(&pb) < 0) {
1884 /* XXX: return an error ? */
1885 c->buffer_ptr = c->buffer;
1886 c->buffer_end = c->buffer;
1890 avio_printf(pb, "HTTP/1.0 200 OK\r\n");
1891 avio_printf(pb, "Content-type: %s\r\n", "text/html");
1892 avio_printf(pb, "Pragma: no-cache\r\n");
1893 avio_printf(pb, "\r\n");
1895 avio_printf(pb, "<html><head><title>%s Status</title>\n", program_name);
1896 if (c->stream->feed_filename[0])
1897 avio_printf(pb, "<link rel=\"shortcut icon\" href=\"%s\">\n", c->stream->feed_filename);
1898 avio_printf(pb, "</head>\n<body>");
1899 avio_printf(pb, "<h1>%s Status</h1>\n", program_name);
1901 avio_printf(pb, "<h2>Available Streams</h2>\n");
1902 avio_printf(pb, "<table cellspacing=0 cellpadding=4>\n");
1903 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");
1904 stream = first_stream;
1905 while (stream != NULL) {
1906 char sfilename[1024];
1909 if (stream->feed != stream) {
1910 av_strlcpy(sfilename, stream->filename, sizeof(sfilename) - 10);
1911 eosf = sfilename + strlen(sfilename);
1912 if (eosf - sfilename >= 4) {
1913 if (strcmp(eosf - 4, ".asf") == 0)
1914 strcpy(eosf - 4, ".asx");
1915 else if (strcmp(eosf - 3, ".rm") == 0)
1916 strcpy(eosf - 3, ".ram");
1917 else if (stream->fmt && !strcmp(stream->fmt->name, "rtp")) {
1918 /* generate a sample RTSP director if
1919 unicast. Generate an SDP redirector if
1921 eosf = strrchr(sfilename, '.');
1923 eosf = sfilename + strlen(sfilename);
1924 if (stream->is_multicast)
1925 strcpy(eosf, ".sdp");
1927 strcpy(eosf, ".rtsp");
1931 avio_printf(pb, "<tr><td><a href=\"/%s\">%s</a> ",
1932 sfilename, stream->filename);
1933 avio_printf(pb, "<td align=right> %d <td align=right> ",
1934 stream->conns_served);
1935 fmt_bytecount(pb, stream->bytes_served);
1936 switch(stream->stream_type) {
1937 case STREAM_TYPE_LIVE: {
1938 int audio_bit_rate = 0;
1939 int video_bit_rate = 0;
1940 const char *audio_codec_name = "";
1941 const char *video_codec_name = "";
1942 const char *audio_codec_name_extra = "";
1943 const char *video_codec_name_extra = "";
1945 for(i=0;i<stream->nb_streams;i++) {
1946 AVStream *st = stream->streams[i];
1947 AVCodec *codec = avcodec_find_encoder(st->codec->codec_id);
1948 switch(st->codec->codec_type) {
1949 case AVMEDIA_TYPE_AUDIO:
1950 audio_bit_rate += st->codec->bit_rate;
1952 if (*audio_codec_name)
1953 audio_codec_name_extra = "...";
1954 audio_codec_name = codec->name;
1957 case AVMEDIA_TYPE_VIDEO:
1958 video_bit_rate += st->codec->bit_rate;
1960 if (*video_codec_name)
1961 video_codec_name_extra = "...";
1962 video_codec_name = codec->name;
1965 case AVMEDIA_TYPE_DATA:
1966 video_bit_rate += st->codec->bit_rate;
1972 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",
1975 video_bit_rate / 1000, video_codec_name, video_codec_name_extra,
1976 audio_bit_rate / 1000, audio_codec_name, audio_codec_name_extra);
1978 avio_printf(pb, "<td>%s", stream->feed->filename);
1980 avio_printf(pb, "<td>%s", stream->feed_filename);
1981 avio_printf(pb, "\n");
1985 avio_printf(pb, "<td align=center> - <td align=right> - <td align=right> - <td><td align=right> - <td>\n");
1989 stream = stream->next;
1991 avio_printf(pb, "</table>\n");
1993 stream = first_stream;
1994 while (stream != NULL) {
1995 if (stream->feed == stream) {
1996 avio_printf(pb, "<h2>Feed %s</h2>", stream->filename);
1998 avio_printf(pb, "Running as pid %d.\n", stream->pid);
2000 #if defined(linux) && !defined(CONFIG_NOCUTILS)
2005 /* This is somewhat linux specific I guess */
2006 snprintf(ps_cmd, sizeof(ps_cmd),
2007 "ps -o \"%%cpu,cputime\" --no-headers %d",
2010 pid_stat = popen(ps_cmd, "r");
2015 if (fscanf(pid_stat, "%10s %64s", cpuperc,
2017 avio_printf(pb, "Currently using %s%% of the cpu. Total time used %s.\n",
2025 avio_printf(pb, "<p>");
2027 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");
2029 for (i = 0; i < stream->nb_streams; i++) {
2030 AVStream *st = stream->streams[i];
2031 AVCodec *codec = avcodec_find_encoder(st->codec->codec_id);
2032 const char *type = "unknown";
2033 char parameters[64];
2037 switch(st->codec->codec_type) {
2038 case AVMEDIA_TYPE_AUDIO:
2040 snprintf(parameters, sizeof(parameters), "%d channel(s), %d Hz", st->codec->channels, st->codec->sample_rate);
2042 case AVMEDIA_TYPE_VIDEO:
2044 snprintf(parameters, sizeof(parameters), "%dx%d, q=%d-%d, fps=%d", st->codec->width, st->codec->height,
2045 st->codec->qmin, st->codec->qmax, st->codec->time_base.den / st->codec->time_base.num);
2050 avio_printf(pb, "<tr><td align=right>%d<td>%s<td align=right>%d<td>%s<td>%s\n",
2051 i, type, st->codec->bit_rate/1000, codec ? codec->name : "", parameters);
2053 avio_printf(pb, "</table>\n");
2056 stream = stream->next;
2059 /* connection status */
2060 avio_printf(pb, "<h2>Connection Status</h2>\n");
2062 avio_printf(pb, "Number of connections: %d / %d<br>\n",
2063 nb_connections, nb_max_connections);
2065 avio_printf(pb, "Bandwidth in use: %"PRIu64"k / %"PRIu64"k<br>\n",
2066 current_bandwidth, max_bandwidth);
2068 avio_printf(pb, "<table>\n");
2069 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");
2070 c1 = first_http_ctx;
2072 while (c1 != NULL) {
2078 for (j = 0; j < c1->stream->nb_streams; j++) {
2079 if (!c1->stream->feed)
2080 bitrate += c1->stream->streams[j]->codec->bit_rate;
2081 else if (c1->feed_streams[j] >= 0)
2082 bitrate += c1->stream->feed->streams[c1->feed_streams[j]]->codec->bit_rate;
2087 p = inet_ntoa(c1->from_addr.sin_addr);
2088 avio_printf(pb, "<tr><td><b>%d</b><td>%s%s<td>%s<td>%s<td>%s<td align=right>",
2090 c1->stream ? c1->stream->filename : "",
2091 c1->state == HTTPSTATE_RECEIVE_DATA ? "(input)" : "",
2094 http_state[c1->state]);
2095 fmt_bytecount(pb, bitrate);
2096 avio_printf(pb, "<td align=right>");
2097 fmt_bytecount(pb, compute_datarate(&c1->datarate, c1->data_count) * 8);
2098 avio_printf(pb, "<td align=right>");
2099 fmt_bytecount(pb, c1->data_count);
2100 avio_printf(pb, "\n");
2103 avio_printf(pb, "</table>\n");
2108 avio_printf(pb, "<hr size=1 noshade>Generated at %s", p);
2109 avio_printf(pb, "</body>\n</html>\n");
2111 len = avio_close_dyn_buf(pb, &c->pb_buffer);
2112 c->buffer_ptr = c->pb_buffer;
2113 c->buffer_end = c->pb_buffer + len;
2116 /* check if the parser needs to be opened for stream i */
2117 static void open_parser(AVFormatContext *s, int i)
2119 AVStream *st = s->streams[i];
2122 if (!st->codec->codec) {
2123 codec = avcodec_find_decoder(st->codec->codec_id);
2124 if (codec && (codec->capabilities & CODEC_CAP_PARSE_ONLY)) {
2125 st->codec->parse_only = 1;
2126 if (avcodec_open2(st->codec, codec, NULL) < 0)
2127 st->codec->parse_only = 0;
2132 static int open_input_stream(HTTPContext *c, const char *info)
2135 char input_filename[1024];
2136 AVFormatContext *s = NULL;
2140 /* find file name */
2141 if (c->stream->feed) {
2142 strcpy(input_filename, c->stream->feed->feed_filename);
2143 /* compute position (absolute time) */
2144 if (av_find_info_tag(buf, sizeof(buf), "date", info)) {
2145 if ((ret = av_parse_time(&stream_pos, buf, 0)) < 0)
2147 } else if (av_find_info_tag(buf, sizeof(buf), "buffer", info)) {
2148 int prebuffer = strtol(buf, 0, 10);
2149 stream_pos = av_gettime() - prebuffer * (int64_t)1000000;
2151 stream_pos = av_gettime() - c->stream->prebuffer * (int64_t)1000;
2153 strcpy(input_filename, c->stream->feed_filename);
2154 /* compute position (relative time) */
2155 if (av_find_info_tag(buf, sizeof(buf), "date", info)) {
2156 if ((ret = av_parse_time(&stream_pos, buf, 1)) < 0)
2161 if (input_filename[0] == '\0')
2165 if ((ret = avformat_open_input(&s, input_filename, c->stream->ifmt, &c->stream->in_opts)) < 0) {
2166 http_log("could not open %s: %d\n", input_filename, ret);
2169 s->flags |= AVFMT_FLAG_GENPTS;
2171 if (strcmp(s->iformat->name, "ffm") && avformat_find_stream_info(c->fmt_in, NULL) < 0) {
2172 http_log("Could not find stream info '%s'\n", input_filename);
2173 av_close_input_file(s);
2177 /* open each parser */
2178 for(i=0;i<s->nb_streams;i++)
2181 /* choose stream as clock source (we favorize video stream if
2182 present) for packet sending */
2183 c->pts_stream_index = 0;
2184 for(i=0;i<c->stream->nb_streams;i++) {
2185 if (c->pts_stream_index == 0 &&
2186 c->stream->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2187 c->pts_stream_index = i;
2191 if (c->fmt_in->iformat->read_seek)
2192 av_seek_frame(c->fmt_in, -1, stream_pos, 0);
2193 /* set the start time (needed for maxtime and RTP packet timing) */
2194 c->start_time = cur_time;
2195 c->first_pts = AV_NOPTS_VALUE;
2199 /* return the server clock (in us) */
2200 static int64_t get_server_clock(HTTPContext *c)
2202 /* compute current pts value from system time */
2203 return (cur_time - c->start_time) * 1000;
2206 /* return the estimated time at which the current packet must be sent
2208 static int64_t get_packet_send_clock(HTTPContext *c)
2210 int bytes_left, bytes_sent, frame_bytes;
2212 frame_bytes = c->cur_frame_bytes;
2213 if (frame_bytes <= 0)
2216 bytes_left = c->buffer_end - c->buffer_ptr;
2217 bytes_sent = frame_bytes - bytes_left;
2218 return c->cur_pts + (c->cur_frame_duration * bytes_sent) / frame_bytes;
2223 static int http_prepare_data(HTTPContext *c)
2226 AVFormatContext *ctx;
2228 av_freep(&c->pb_buffer);
2230 case HTTPSTATE_SEND_DATA_HEADER:
2231 memset(&c->fmt_ctx, 0, sizeof(c->fmt_ctx));
2232 av_dict_set(&c->fmt_ctx.metadata, "author" , c->stream->author , 0);
2233 av_dict_set(&c->fmt_ctx.metadata, "comment" , c->stream->comment , 0);
2234 av_dict_set(&c->fmt_ctx.metadata, "copyright", c->stream->copyright, 0);
2235 av_dict_set(&c->fmt_ctx.metadata, "title" , c->stream->title , 0);
2237 c->fmt_ctx.streams = av_mallocz(sizeof(AVStream *) * c->stream->nb_streams);
2239 for(i=0;i<c->stream->nb_streams;i++) {
2241 c->fmt_ctx.streams[i] = av_mallocz(sizeof(AVStream));
2242 /* if file or feed, then just take streams from FFStream struct */
2243 if (!c->stream->feed ||
2244 c->stream->feed == c->stream)
2245 src = c->stream->streams[i];
2247 src = c->stream->feed->streams[c->stream->feed_streams[i]];
2249 *(c->fmt_ctx.streams[i]) = *src;
2250 c->fmt_ctx.streams[i]->priv_data = 0;
2251 c->fmt_ctx.streams[i]->codec->frame_number = 0; /* XXX: should be done in
2252 AVStream, not in codec */
2254 /* set output format parameters */
2255 c->fmt_ctx.oformat = c->stream->fmt;
2256 c->fmt_ctx.nb_streams = c->stream->nb_streams;
2258 c->got_key_frame = 0;
2260 /* prepare header and save header data in a stream */
2261 if (avio_open_dyn_buf(&c->fmt_ctx.pb) < 0) {
2262 /* XXX: potential leak */
2265 c->fmt_ctx.pb->seekable = 0;
2268 * HACK to avoid mpeg ps muxer to spit many underflow errors
2269 * Default value from FFmpeg
2270 * Try to set it use configuration option
2272 c->fmt_ctx.preload = (int)(0.5*AV_TIME_BASE);
2273 c->fmt_ctx.max_delay = (int)(0.7*AV_TIME_BASE);
2275 if (avformat_write_header(&c->fmt_ctx, NULL) < 0) {
2276 http_log("Error writing output header\n");
2279 av_dict_free(&c->fmt_ctx.metadata);
2281 len = avio_close_dyn_buf(c->fmt_ctx.pb, &c->pb_buffer);
2282 c->buffer_ptr = c->pb_buffer;
2283 c->buffer_end = c->pb_buffer + len;
2285 c->state = HTTPSTATE_SEND_DATA;
2286 c->last_packet_sent = 0;
2288 case HTTPSTATE_SEND_DATA:
2289 /* find a new packet */
2290 /* read a packet from the input stream */
2291 if (c->stream->feed)
2292 ffm_set_write_index(c->fmt_in,
2293 c->stream->feed->feed_write_index,
2294 c->stream->feed->feed_size);
2296 if (c->stream->max_time &&
2297 c->stream->max_time + c->start_time - cur_time < 0)
2298 /* We have timed out */
2299 c->state = HTTPSTATE_SEND_DATA_TRAILER;
2303 ret = av_read_frame(c->fmt_in, &pkt);
2305 if (c->stream->feed) {
2306 /* if coming from feed, it means we reached the end of the
2307 ffm file, so must wait for more data */
2308 c->state = HTTPSTATE_WAIT_FEED;
2309 return 1; /* state changed */
2310 } else if (ret == AVERROR(EAGAIN)) {
2311 /* input not ready, come back later */
2314 if (c->stream->loop) {
2315 av_close_input_file(c->fmt_in);
2317 if (open_input_stream(c, "") < 0)
2322 /* must send trailer now because eof or error */
2323 c->state = HTTPSTATE_SEND_DATA_TRAILER;
2327 int source_index = pkt.stream_index;
2328 /* update first pts if needed */
2329 if (c->first_pts == AV_NOPTS_VALUE) {
2330 c->first_pts = av_rescale_q(pkt.dts, c->fmt_in->streams[pkt.stream_index]->time_base, AV_TIME_BASE_Q);
2331 c->start_time = cur_time;
2333 /* send it to the appropriate stream */
2334 if (c->stream->feed) {
2335 /* if coming from a feed, select the right stream */
2336 if (c->switch_pending) {
2337 c->switch_pending = 0;
2338 for(i=0;i<c->stream->nb_streams;i++) {
2339 if (c->switch_feed_streams[i] == pkt.stream_index)
2340 if (pkt.flags & AV_PKT_FLAG_KEY)
2341 c->switch_feed_streams[i] = -1;
2342 if (c->switch_feed_streams[i] >= 0)
2343 c->switch_pending = 1;
2346 for(i=0;i<c->stream->nb_streams;i++) {
2347 if (c->stream->feed_streams[i] == pkt.stream_index) {
2348 AVStream *st = c->fmt_in->streams[source_index];
2349 pkt.stream_index = i;
2350 if (pkt.flags & AV_PKT_FLAG_KEY &&
2351 (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2352 c->stream->nb_streams == 1))
2353 c->got_key_frame = 1;
2354 if (!c->stream->send_on_key || c->got_key_frame)
2359 AVCodecContext *codec;
2360 AVStream *ist, *ost;
2362 ist = c->fmt_in->streams[source_index];
2363 /* specific handling for RTP: we use several
2364 output stream (one for each RTP
2365 connection). XXX: need more abstract handling */
2366 if (c->is_packetized) {
2367 /* compute send time and duration */
2368 c->cur_pts = av_rescale_q(pkt.dts, ist->time_base, AV_TIME_BASE_Q);
2369 c->cur_pts -= c->first_pts;
2370 c->cur_frame_duration = av_rescale_q(pkt.duration, ist->time_base, AV_TIME_BASE_Q);
2371 /* find RTP context */
2372 c->packet_stream_index = pkt.stream_index;
2373 ctx = c->rtp_ctx[c->packet_stream_index];
2375 av_free_packet(&pkt);
2378 codec = ctx->streams[0]->codec;
2379 /* only one stream per RTP connection */
2380 pkt.stream_index = 0;
2384 codec = ctx->streams[pkt.stream_index]->codec;
2387 if (c->is_packetized) {
2388 int max_packet_size;
2389 if (c->rtp_protocol == RTSP_LOWER_TRANSPORT_TCP)
2390 max_packet_size = RTSP_TCP_MAX_PACKET_SIZE;
2392 max_packet_size = url_get_max_packet_size(c->rtp_handles[c->packet_stream_index]);
2393 ret = ffio_open_dyn_packet_buf(&ctx->pb, max_packet_size);
2395 ret = avio_open_dyn_buf(&ctx->pb);
2398 /* XXX: potential leak */
2401 ost = ctx->streams[pkt.stream_index];
2403 ctx->pb->seekable = 0;
2404 if (pkt.dts != AV_NOPTS_VALUE)
2405 pkt.dts = av_rescale_q(pkt.dts, ist->time_base, ost->time_base);
2406 if (pkt.pts != AV_NOPTS_VALUE)
2407 pkt.pts = av_rescale_q(pkt.pts, ist->time_base, ost->time_base);
2408 pkt.duration = av_rescale_q(pkt.duration, ist->time_base, ost->time_base);
2409 if (av_write_frame(ctx, &pkt) < 0) {
2410 http_log("Error writing frame to output\n");
2411 c->state = HTTPSTATE_SEND_DATA_TRAILER;
2414 len = avio_close_dyn_buf(ctx->pb, &c->pb_buffer);
2415 c->cur_frame_bytes = len;
2416 c->buffer_ptr = c->pb_buffer;
2417 c->buffer_end = c->pb_buffer + len;
2419 codec->frame_number++;
2421 av_free_packet(&pkt);
2425 av_free_packet(&pkt);
2430 case HTTPSTATE_SEND_DATA_TRAILER:
2431 /* last packet test ? */
2432 if (c->last_packet_sent || c->is_packetized)
2435 /* prepare header */
2436 if (avio_open_dyn_buf(&ctx->pb) < 0) {
2437 /* XXX: potential leak */
2440 c->fmt_ctx.pb->seekable = 0;
2441 av_write_trailer(ctx);
2442 len = avio_close_dyn_buf(ctx->pb, &c->pb_buffer);
2443 c->buffer_ptr = c->pb_buffer;
2444 c->buffer_end = c->pb_buffer + len;
2446 c->last_packet_sent = 1;
2452 /* should convert the format at the same time */
2453 /* send data starting at c->buffer_ptr to the output connection
2454 (either UDP or TCP connection) */
2455 static int http_send_data(HTTPContext *c)
2460 if (c->buffer_ptr >= c->buffer_end) {
2461 ret = http_prepare_data(c);
2465 /* state change requested */
2468 if (c->is_packetized) {
2469 /* RTP data output */
2470 len = c->buffer_end - c->buffer_ptr;
2472 /* fail safe - should never happen */
2474 c->buffer_ptr = c->buffer_end;
2477 len = (c->buffer_ptr[0] << 24) |
2478 (c->buffer_ptr[1] << 16) |
2479 (c->buffer_ptr[2] << 8) |
2481 if (len > (c->buffer_end - c->buffer_ptr))
2483 if ((get_packet_send_clock(c) - get_server_clock(c)) > 0) {
2484 /* nothing to send yet: we can wait */
2488 c->data_count += len;
2489 update_datarate(&c->datarate, c->data_count);
2491 c->stream->bytes_served += len;
2493 if (c->rtp_protocol == RTSP_LOWER_TRANSPORT_TCP) {
2494 /* RTP packets are sent inside the RTSP TCP connection */
2496 int interleaved_index, size;
2498 HTTPContext *rtsp_c;
2501 /* if no RTSP connection left, error */
2504 /* if already sending something, then wait. */
2505 if (rtsp_c->state != RTSPSTATE_WAIT_REQUEST)
2507 if (avio_open_dyn_buf(&pb) < 0)
2509 interleaved_index = c->packet_stream_index * 2;
2510 /* RTCP packets are sent at odd indexes */
2511 if (c->buffer_ptr[1] == 200)
2512 interleaved_index++;
2513 /* write RTSP TCP header */
2515 header[1] = interleaved_index;
2516 header[2] = len >> 8;
2518 avio_write(pb, header, 4);
2519 /* write RTP packet data */
2521 avio_write(pb, c->buffer_ptr, len);
2522 size = avio_close_dyn_buf(pb, &c->packet_buffer);
2523 /* prepare asynchronous TCP sending */
2524 rtsp_c->packet_buffer_ptr = c->packet_buffer;
2525 rtsp_c->packet_buffer_end = c->packet_buffer + size;
2526 c->buffer_ptr += len;
2528 /* send everything we can NOW */
2529 len = send(rtsp_c->fd, rtsp_c->packet_buffer_ptr,
2530 rtsp_c->packet_buffer_end - rtsp_c->packet_buffer_ptr, 0);
2532 rtsp_c->packet_buffer_ptr += len;
2533 if (rtsp_c->packet_buffer_ptr < rtsp_c->packet_buffer_end) {
2534 /* if we could not send all the data, we will
2535 send it later, so a new state is needed to
2536 "lock" the RTSP TCP connection */
2537 rtsp_c->state = RTSPSTATE_SEND_PACKET;
2540 /* all data has been sent */
2541 av_freep(&c->packet_buffer);
2543 /* send RTP packet directly in UDP */
2545 url_write(c->rtp_handles[c->packet_stream_index],
2546 c->buffer_ptr, len);
2547 c->buffer_ptr += len;
2548 /* here we continue as we can send several packets per 10 ms slot */
2551 /* TCP data output */
2552 len = send(c->fd, c->buffer_ptr, c->buffer_end - c->buffer_ptr, 0);
2554 if (ff_neterrno() != AVERROR(EAGAIN) &&
2555 ff_neterrno() != AVERROR(EINTR))
2556 /* error : close connection */
2561 c->buffer_ptr += len;
2563 c->data_count += len;
2564 update_datarate(&c->datarate, c->data_count);
2566 c->stream->bytes_served += len;
2574 static int http_start_receive_data(HTTPContext *c)
2578 if (c->stream->feed_opened)
2581 /* Don't permit writing to this one */
2582 if (c->stream->readonly)
2586 fd = open(c->stream->feed_filename, O_RDWR);
2588 http_log("Error opening feeder file: %s\n", strerror(errno));
2593 if (c->stream->truncate) {
2594 /* truncate feed file */
2595 ffm_write_write_index(c->feed_fd, FFM_PACKET_SIZE);
2596 ftruncate(c->feed_fd, FFM_PACKET_SIZE);
2597 http_log("Truncating feed file '%s'\n", c->stream->feed_filename);
2599 if ((c->stream->feed_write_index = ffm_read_write_index(fd)) < 0) {
2600 http_log("Error reading write index from feed file: %s\n", strerror(errno));
2605 c->stream->feed_write_index = FFMAX(ffm_read_write_index(fd), FFM_PACKET_SIZE);
2606 c->stream->feed_size = lseek(fd, 0, SEEK_END);
2607 lseek(fd, 0, SEEK_SET);
2609 /* init buffer input */
2610 c->buffer_ptr = c->buffer;
2611 c->buffer_end = c->buffer + FFM_PACKET_SIZE;
2612 c->stream->feed_opened = 1;
2613 c->chunked_encoding = !!av_stristr(c->buffer, "Transfer-Encoding: chunked");
2617 static int http_receive_data(HTTPContext *c)
2620 int len, loop_run = 0;
2622 while (c->chunked_encoding && !c->chunk_size &&
2623 c->buffer_end > c->buffer_ptr) {
2624 /* read chunk header, if present */
2625 len = recv(c->fd, c->buffer_ptr, 1, 0);
2628 if (ff_neterrno() != AVERROR(EAGAIN) &&
2629 ff_neterrno() != AVERROR(EINTR))
2630 /* error : close connection */
2633 } else if (len == 0) {
2634 /* end of connection : close it */
2636 } else if (c->buffer_ptr - c->buffer >= 2 &&
2637 !memcmp(c->buffer_ptr - 1, "\r\n", 2)) {
2638 c->chunk_size = strtol(c->buffer, 0, 16);
2639 if (c->chunk_size == 0) // end of stream
2641 c->buffer_ptr = c->buffer;
2643 } else if (++loop_run > 10) {
2644 /* no chunk header, abort */
2651 if (c->buffer_end > c->buffer_ptr) {
2652 len = recv(c->fd, c->buffer_ptr,
2653 FFMIN(c->chunk_size, c->buffer_end - c->buffer_ptr), 0);
2655 if (ff_neterrno() != AVERROR(EAGAIN) &&
2656 ff_neterrno() != AVERROR(EINTR))
2657 /* error : close connection */
2659 } else if (len == 0)
2660 /* end of connection : close it */
2663 c->chunk_size -= len;
2664 c->buffer_ptr += len;
2665 c->data_count += len;
2666 update_datarate(&c->datarate, c->data_count);
2670 if (c->buffer_ptr - c->buffer >= 2 && c->data_count > FFM_PACKET_SIZE) {
2671 if (c->buffer[0] != 'f' ||
2672 c->buffer[1] != 'm') {
2673 http_log("Feed stream has become desynchronized -- disconnecting\n");
2678 if (c->buffer_ptr >= c->buffer_end) {
2679 FFStream *feed = c->stream;
2680 /* a packet has been received : write it in the store, except
2682 if (c->data_count > FFM_PACKET_SIZE) {
2684 // printf("writing pos=0x%"PRIx64" size=0x%"PRIx64"\n", feed->feed_write_index, feed->feed_size);
2685 /* XXX: use llseek or url_seek */
2686 lseek(c->feed_fd, feed->feed_write_index, SEEK_SET);
2687 if (write(c->feed_fd, c->buffer, FFM_PACKET_SIZE) < 0) {
2688 http_log("Error writing to feed file: %s\n", strerror(errno));
2692 feed->feed_write_index += FFM_PACKET_SIZE;
2693 /* update file size */
2694 if (feed->feed_write_index > c->stream->feed_size)
2695 feed->feed_size = feed->feed_write_index;
2697 /* handle wrap around if max file size reached */
2698 if (c->stream->feed_max_size && feed->feed_write_index >= c->stream->feed_max_size)
2699 feed->feed_write_index = FFM_PACKET_SIZE;
2702 if (ffm_write_write_index(c->feed_fd, feed->feed_write_index) < 0) {
2703 http_log("Error writing index to feed file: %s\n", strerror(errno));
2707 /* wake up any waiting connections */
2708 for(c1 = first_http_ctx; c1 != NULL; c1 = c1->next) {
2709 if (c1->state == HTTPSTATE_WAIT_FEED &&
2710 c1->stream->feed == c->stream->feed)
2711 c1->state = HTTPSTATE_SEND_DATA;
2714 /* We have a header in our hands that contains useful data */
2715 AVFormatContext *s = avformat_alloc_context();
2717 AVInputFormat *fmt_in;
2723 /* use feed output format name to find corresponding input format */
2724 fmt_in = av_find_input_format(feed->fmt->name);
2728 pb = avio_alloc_context(c->buffer, c->buffer_end - c->buffer,
2729 0, NULL, NULL, NULL, NULL);
2733 if (avformat_open_input(&s, c->stream->feed_filename, fmt_in, NULL) < 0) {
2738 /* Now we have the actual streams */
2739 if (s->nb_streams != feed->nb_streams) {
2740 av_close_input_stream(s);
2742 http_log("Feed '%s' stream number does not match registered feed\n",
2743 c->stream->feed_filename);
2747 for (i = 0; i < s->nb_streams; i++) {
2748 AVStream *fst = feed->streams[i];
2749 AVStream *st = s->streams[i];
2750 avcodec_copy_context(fst->codec, st->codec);
2753 av_close_input_stream(s);
2756 c->buffer_ptr = c->buffer;
2761 c->stream->feed_opened = 0;
2763 /* wake up any waiting connections to stop waiting for feed */
2764 for(c1 = first_http_ctx; c1 != NULL; c1 = c1->next) {
2765 if (c1->state == HTTPSTATE_WAIT_FEED &&
2766 c1->stream->feed == c->stream->feed)
2767 c1->state = HTTPSTATE_SEND_DATA_TRAILER;
2772 /********************************************************************/
2775 static void rtsp_reply_header(HTTPContext *c, enum RTSPStatusCode error_number)
2782 switch(error_number) {
2783 case RTSP_STATUS_OK:
2786 case RTSP_STATUS_METHOD:
2787 str = "Method Not Allowed";
2789 case RTSP_STATUS_BANDWIDTH:
2790 str = "Not Enough Bandwidth";
2792 case RTSP_STATUS_SESSION:
2793 str = "Session Not Found";
2795 case RTSP_STATUS_STATE:
2796 str = "Method Not Valid in This State";
2798 case RTSP_STATUS_AGGREGATE:
2799 str = "Aggregate operation not allowed";
2801 case RTSP_STATUS_ONLY_AGGREGATE:
2802 str = "Only aggregate operation allowed";
2804 case RTSP_STATUS_TRANSPORT:
2805 str = "Unsupported transport";
2807 case RTSP_STATUS_INTERNAL:
2808 str = "Internal Server Error";
2810 case RTSP_STATUS_SERVICE:
2811 str = "Service Unavailable";
2813 case RTSP_STATUS_VERSION:
2814 str = "RTSP Version not supported";
2817 str = "Unknown Error";
2821 avio_printf(c->pb, "RTSP/1.0 %d %s\r\n", error_number, str);
2822 avio_printf(c->pb, "CSeq: %d\r\n", c->seq);
2824 /* output GMT time */
2827 strftime(buf2, sizeof(buf2), "%a, %d %b %Y %H:%M:%S", tm);
2828 avio_printf(c->pb, "Date: %s GMT\r\n", buf2);
2831 static void rtsp_reply_error(HTTPContext *c, enum RTSPStatusCode error_number)
2833 rtsp_reply_header(c, error_number);
2834 avio_printf(c->pb, "\r\n");
2837 static int rtsp_parse_request(HTTPContext *c)
2839 const char *p, *p1, *p2;
2845 RTSPMessageHeader header1, *header = &header1;
2847 c->buffer_ptr[0] = '\0';
2850 get_word(cmd, sizeof(cmd), &p);
2851 get_word(url, sizeof(url), &p);
2852 get_word(protocol, sizeof(protocol), &p);
2854 av_strlcpy(c->method, cmd, sizeof(c->method));
2855 av_strlcpy(c->url, url, sizeof(c->url));
2856 av_strlcpy(c->protocol, protocol, sizeof(c->protocol));
2858 if (avio_open_dyn_buf(&c->pb) < 0) {
2859 /* XXX: cannot do more */
2860 c->pb = NULL; /* safety */
2864 /* check version name */
2865 if (strcmp(protocol, "RTSP/1.0") != 0) {
2866 rtsp_reply_error(c, RTSP_STATUS_VERSION);
2870 /* parse each header line */
2871 memset(header, 0, sizeof(*header));
2872 /* skip to next line */
2873 while (*p != '\n' && *p != '\0')
2877 while (*p != '\0') {
2878 p1 = memchr(p, '\n', (char *)c->buffer_ptr - p);
2882 if (p2 > p && p2[-1] == '\r')
2884 /* skip empty line */
2888 if (len > sizeof(line) - 1)
2889 len = sizeof(line) - 1;
2890 memcpy(line, p, len);
2892 ff_rtsp_parse_line(header, line, NULL, NULL);
2896 /* handle sequence number */
2897 c->seq = header->seq;
2899 if (!strcmp(cmd, "DESCRIBE"))
2900 rtsp_cmd_describe(c, url);
2901 else if (!strcmp(cmd, "OPTIONS"))
2902 rtsp_cmd_options(c, url);
2903 else if (!strcmp(cmd, "SETUP"))
2904 rtsp_cmd_setup(c, url, header);
2905 else if (!strcmp(cmd, "PLAY"))
2906 rtsp_cmd_play(c, url, header);
2907 else if (!strcmp(cmd, "PAUSE"))
2908 rtsp_cmd_pause(c, url, header);
2909 else if (!strcmp(cmd, "TEARDOWN"))
2910 rtsp_cmd_teardown(c, url, header);
2912 rtsp_reply_error(c, RTSP_STATUS_METHOD);
2915 len = avio_close_dyn_buf(c->pb, &c->pb_buffer);
2916 c->pb = NULL; /* safety */
2918 /* XXX: cannot do more */
2921 c->buffer_ptr = c->pb_buffer;
2922 c->buffer_end = c->pb_buffer + len;
2923 c->state = RTSPSTATE_SEND_REPLY;
2927 static int prepare_sdp_description(FFStream *stream, uint8_t **pbuffer,
2928 struct in_addr my_ip)
2930 AVFormatContext *avc;
2931 AVStream *avs = NULL;
2934 avc = avformat_alloc_context();
2938 av_dict_set(&avc->metadata, "title",
2939 stream->title[0] ? stream->title : "No Title", 0);
2940 avc->nb_streams = stream->nb_streams;
2941 if (stream->is_multicast) {
2942 snprintf(avc->filename, 1024, "rtp://%s:%d?multicast=1?ttl=%d",
2943 inet_ntoa(stream->multicast_ip),
2944 stream->multicast_port, stream->multicast_ttl);
2946 snprintf(avc->filename, 1024, "rtp://0.0.0.0");
2949 if (avc->nb_streams >= INT_MAX/sizeof(*avc->streams) ||
2950 !(avc->streams = av_malloc(avc->nb_streams * sizeof(*avc->streams))))
2952 if (avc->nb_streams >= INT_MAX/sizeof(*avs) ||
2953 !(avs = av_malloc(avc->nb_streams * sizeof(*avs))))
2956 for(i = 0; i < stream->nb_streams; i++) {
2957 avc->streams[i] = &avs[i];
2958 avc->streams[i]->codec = stream->streams[i]->codec;
2960 *pbuffer = av_mallocz(2048);
2961 av_sdp_create(&avc, 1, *pbuffer, 2048);
2964 av_free(avc->streams);
2965 av_dict_free(&avc->metadata);
2969 return strlen(*pbuffer);
2972 static void rtsp_cmd_options(HTTPContext *c, const char *url)
2974 // rtsp_reply_header(c, RTSP_STATUS_OK);
2975 avio_printf(c->pb, "RTSP/1.0 %d %s\r\n", RTSP_STATUS_OK, "OK");
2976 avio_printf(c->pb, "CSeq: %d\r\n", c->seq);
2977 avio_printf(c->pb, "Public: %s\r\n", "OPTIONS, DESCRIBE, SETUP, TEARDOWN, PLAY, PAUSE");
2978 avio_printf(c->pb, "\r\n");
2981 static void rtsp_cmd_describe(HTTPContext *c, const char *url)
2987 int content_length, len;
2988 struct sockaddr_in my_addr;
2990 /* find which url is asked */
2991 av_url_split(NULL, 0, NULL, 0, NULL, 0, NULL, path1, sizeof(path1), url);
2996 for(stream = first_stream; stream != NULL; stream = stream->next) {
2997 if (!stream->is_feed &&
2998 stream->fmt && !strcmp(stream->fmt->name, "rtp") &&
2999 !strcmp(path, stream->filename)) {
3003 /* no stream found */
3004 rtsp_reply_error(c, RTSP_STATUS_SERVICE); /* XXX: right error ? */
3008 /* prepare the media description in sdp format */
3010 /* get the host IP */
3011 len = sizeof(my_addr);
3012 getsockname(c->fd, (struct sockaddr *)&my_addr, &len);
3013 content_length = prepare_sdp_description(stream, &content, my_addr.sin_addr);
3014 if (content_length < 0) {
3015 rtsp_reply_error(c, RTSP_STATUS_INTERNAL);
3018 rtsp_reply_header(c, RTSP_STATUS_OK);
3019 avio_printf(c->pb, "Content-Base: %s/\r\n", url);
3020 avio_printf(c->pb, "Content-Type: application/sdp\r\n");
3021 avio_printf(c->pb, "Content-Length: %d\r\n", content_length);
3022 avio_printf(c->pb, "\r\n");
3023 avio_write(c->pb, content, content_length);
3027 static HTTPContext *find_rtp_session(const char *session_id)
3031 if (session_id[0] == '\0')
3034 for(c = first_http_ctx; c != NULL; c = c->next) {
3035 if (!strcmp(c->session_id, session_id))
3041 static RTSPTransportField *find_transport(RTSPMessageHeader *h, enum RTSPLowerTransport lower_transport)
3043 RTSPTransportField *th;
3046 for(i=0;i<h->nb_transports;i++) {
3047 th = &h->transports[i];
3048 if (th->lower_transport == lower_transport)
3054 static void rtsp_cmd_setup(HTTPContext *c, const char *url,
3055 RTSPMessageHeader *h)
3058 int stream_index, rtp_port, rtcp_port;
3063 RTSPTransportField *th;
3064 struct sockaddr_in dest_addr;
3065 RTSPActionServerSetup setup;
3067 /* find which url is asked */
3068 av_url_split(NULL, 0, NULL, 0, NULL, 0, NULL, path1, sizeof(path1), url);
3073 /* now check each stream */
3074 for(stream = first_stream; stream != NULL; stream = stream->next) {
3075 if (!stream->is_feed &&
3076 stream->fmt && !strcmp(stream->fmt->name, "rtp")) {
3077 /* accept aggregate filenames only if single stream */
3078 if (!strcmp(path, stream->filename)) {
3079 if (stream->nb_streams != 1) {
3080 rtsp_reply_error(c, RTSP_STATUS_AGGREGATE);
3087 for(stream_index = 0; stream_index < stream->nb_streams;
3089 snprintf(buf, sizeof(buf), "%s/streamid=%d",
3090 stream->filename, stream_index);
3091 if (!strcmp(path, buf))
3096 /* no stream found */
3097 rtsp_reply_error(c, RTSP_STATUS_SERVICE); /* XXX: right error ? */
3101 /* generate session id if needed */
3102 if (h->session_id[0] == '\0')
3103 snprintf(h->session_id, sizeof(h->session_id), "%08x%08x",
3104 av_lfg_get(&random_state), av_lfg_get(&random_state));
3106 /* find rtp session, and create it if none found */
3107 rtp_c = find_rtp_session(h->session_id);
3109 /* always prefer UDP */
3110 th = find_transport(h, RTSP_LOWER_TRANSPORT_UDP);
3112 th = find_transport(h, RTSP_LOWER_TRANSPORT_TCP);
3114 rtsp_reply_error(c, RTSP_STATUS_TRANSPORT);
3119 rtp_c = rtp_new_connection(&c->from_addr, stream, h->session_id,
3120 th->lower_transport);
3122 rtsp_reply_error(c, RTSP_STATUS_BANDWIDTH);
3126 /* open input stream */
3127 if (open_input_stream(rtp_c, "") < 0) {
3128 rtsp_reply_error(c, RTSP_STATUS_INTERNAL);
3133 /* test if stream is OK (test needed because several SETUP needs
3134 to be done for a given file) */
3135 if (rtp_c->stream != stream) {
3136 rtsp_reply_error(c, RTSP_STATUS_SERVICE);
3140 /* test if stream is already set up */
3141 if (rtp_c->rtp_ctx[stream_index]) {
3142 rtsp_reply_error(c, RTSP_STATUS_STATE);
3146 /* check transport */
3147 th = find_transport(h, rtp_c->rtp_protocol);
3148 if (!th || (th->lower_transport == RTSP_LOWER_TRANSPORT_UDP &&
3149 th->client_port_min <= 0)) {
3150 rtsp_reply_error(c, RTSP_STATUS_TRANSPORT);
3154 /* setup default options */
3155 setup.transport_option[0] = '\0';
3156 dest_addr = rtp_c->from_addr;
3157 dest_addr.sin_port = htons(th->client_port_min);
3160 if (rtp_new_av_stream(rtp_c, stream_index, &dest_addr, c) < 0) {
3161 rtsp_reply_error(c, RTSP_STATUS_TRANSPORT);
3165 /* now everything is OK, so we can send the connection parameters */
3166 rtsp_reply_header(c, RTSP_STATUS_OK);
3168 avio_printf(c->pb, "Session: %s\r\n", rtp_c->session_id);
3170 switch(rtp_c->rtp_protocol) {
3171 case RTSP_LOWER_TRANSPORT_UDP:
3172 rtp_port = ff_rtp_get_local_rtp_port(rtp_c->rtp_handles[stream_index]);
3173 rtcp_port = ff_rtp_get_local_rtcp_port(rtp_c->rtp_handles[stream_index]);
3174 avio_printf(c->pb, "Transport: RTP/AVP/UDP;unicast;"
3175 "client_port=%d-%d;server_port=%d-%d",
3176 th->client_port_min, th->client_port_max,
3177 rtp_port, rtcp_port);
3179 case RTSP_LOWER_TRANSPORT_TCP:
3180 avio_printf(c->pb, "Transport: RTP/AVP/TCP;interleaved=%d-%d",
3181 stream_index * 2, stream_index * 2 + 1);
3186 if (setup.transport_option[0] != '\0')
3187 avio_printf(c->pb, ";%s", setup.transport_option);
3188 avio_printf(c->pb, "\r\n");
3191 avio_printf(c->pb, "\r\n");
3195 /* find an rtp connection by using the session ID. Check consistency
3197 static HTTPContext *find_rtp_session_with_url(const char *url,
3198 const char *session_id)
3206 rtp_c = find_rtp_session(session_id);
3210 /* find which url is asked */
3211 av_url_split(NULL, 0, NULL, 0, NULL, 0, NULL, path1, sizeof(path1), url);
3215 if(!strcmp(path, rtp_c->stream->filename)) return rtp_c;
3216 for(s=0; s<rtp_c->stream->nb_streams; ++s) {
3217 snprintf(buf, sizeof(buf), "%s/streamid=%d",
3218 rtp_c->stream->filename, s);
3219 if(!strncmp(path, buf, sizeof(buf))) {
3220 // XXX: Should we reply with RTSP_STATUS_ONLY_AGGREGATE if nb_streams>1?
3225 if (len > 0 && path[len - 1] == '/' &&
3226 !strncmp(path, rtp_c->stream->filename, len - 1))
3231 static void rtsp_cmd_play(HTTPContext *c, const char *url, RTSPMessageHeader *h)
3235 rtp_c = find_rtp_session_with_url(url, h->session_id);
3237 rtsp_reply_error(c, RTSP_STATUS_SESSION);
3241 if (rtp_c->state != HTTPSTATE_SEND_DATA &&
3242 rtp_c->state != HTTPSTATE_WAIT_FEED &&
3243 rtp_c->state != HTTPSTATE_READY) {
3244 rtsp_reply_error(c, RTSP_STATUS_STATE);
3248 rtp_c->state = HTTPSTATE_SEND_DATA;
3250 /* now everything is OK, so we can send the connection parameters */
3251 rtsp_reply_header(c, RTSP_STATUS_OK);
3253 avio_printf(c->pb, "Session: %s\r\n", rtp_c->session_id);
3254 avio_printf(c->pb, "\r\n");
3257 static void rtsp_cmd_pause(HTTPContext *c, const char *url, RTSPMessageHeader *h)
3261 rtp_c = find_rtp_session_with_url(url, h->session_id);
3263 rtsp_reply_error(c, RTSP_STATUS_SESSION);
3267 if (rtp_c->state != HTTPSTATE_SEND_DATA &&
3268 rtp_c->state != HTTPSTATE_WAIT_FEED) {
3269 rtsp_reply_error(c, RTSP_STATUS_STATE);
3273 rtp_c->state = HTTPSTATE_READY;
3274 rtp_c->first_pts = AV_NOPTS_VALUE;
3275 /* now everything is OK, so we can send the connection parameters */
3276 rtsp_reply_header(c, RTSP_STATUS_OK);
3278 avio_printf(c->pb, "Session: %s\r\n", rtp_c->session_id);
3279 avio_printf(c->pb, "\r\n");
3282 static void rtsp_cmd_teardown(HTTPContext *c, const char *url, RTSPMessageHeader *h)
3286 rtp_c = find_rtp_session_with_url(url, h->session_id);
3288 rtsp_reply_error(c, RTSP_STATUS_SESSION);
3292 /* now everything is OK, so we can send the connection parameters */
3293 rtsp_reply_header(c, RTSP_STATUS_OK);
3295 avio_printf(c->pb, "Session: %s\r\n", rtp_c->session_id);
3296 avio_printf(c->pb, "\r\n");
3298 /* abort the session */
3299 close_connection(rtp_c);
3303 /********************************************************************/
3306 static HTTPContext *rtp_new_connection(struct sockaddr_in *from_addr,
3307 FFStream *stream, const char *session_id,
3308 enum RTSPLowerTransport rtp_protocol)
3310 HTTPContext *c = NULL;
3311 const char *proto_str;
3313 /* XXX: should output a warning page when coming
3314 close to the connection limit */
3315 if (nb_connections >= nb_max_connections)
3318 /* add a new connection */
3319 c = av_mallocz(sizeof(HTTPContext));
3324 c->poll_entry = NULL;
3325 c->from_addr = *from_addr;
3326 c->buffer_size = IOBUFFER_INIT_SIZE;
3327 c->buffer = av_malloc(c->buffer_size);
3332 av_strlcpy(c->session_id, session_id, sizeof(c->session_id));
3333 c->state = HTTPSTATE_READY;
3334 c->is_packetized = 1;
3335 c->rtp_protocol = rtp_protocol;
3337 /* protocol is shown in statistics */
3338 switch(c->rtp_protocol) {
3339 case RTSP_LOWER_TRANSPORT_UDP_MULTICAST:
3340 proto_str = "MCAST";
3342 case RTSP_LOWER_TRANSPORT_UDP:
3345 case RTSP_LOWER_TRANSPORT_TCP:
3352 av_strlcpy(c->protocol, "RTP/", sizeof(c->protocol));
3353 av_strlcat(c->protocol, proto_str, sizeof(c->protocol));
3355 current_bandwidth += stream->bandwidth;
3357 c->next = first_http_ctx;
3369 /* add a new RTP stream in an RTP connection (used in RTSP SETUP
3370 command). If RTP/TCP protocol is used, TCP connection 'rtsp_c' is
3372 static int rtp_new_av_stream(HTTPContext *c,
3373 int stream_index, struct sockaddr_in *dest_addr,
3374 HTTPContext *rtsp_c)
3376 AVFormatContext *ctx;
3379 URLContext *h = NULL;
3381 int max_packet_size;
3383 /* now we can open the relevant output stream */
3384 ctx = avformat_alloc_context();
3387 ctx->oformat = av_guess_format("rtp", NULL, NULL);
3389 st = av_mallocz(sizeof(AVStream));
3392 ctx->nb_streams = 1;
3393 ctx->streams = av_mallocz(sizeof(AVStream *) * ctx->nb_streams);
3396 ctx->streams[0] = st;
3398 if (!c->stream->feed ||
3399 c->stream->feed == c->stream)
3400 memcpy(st, c->stream->streams[stream_index], sizeof(AVStream));
3403 c->stream->feed->streams[c->stream->feed_streams[stream_index]],
3405 st->priv_data = NULL;
3407 /* build destination RTP address */
3408 ipaddr = inet_ntoa(dest_addr->sin_addr);
3410 switch(c->rtp_protocol) {
3411 case RTSP_LOWER_TRANSPORT_UDP:
3412 case RTSP_LOWER_TRANSPORT_UDP_MULTICAST:
3415 /* XXX: also pass as parameter to function ? */
3416 if (c->stream->is_multicast) {
3418 ttl = c->stream->multicast_ttl;
3421 snprintf(ctx->filename, sizeof(ctx->filename),
3422 "rtp://%s:%d?multicast=1&ttl=%d",
3423 ipaddr, ntohs(dest_addr->sin_port), ttl);
3425 snprintf(ctx->filename, sizeof(ctx->filename),
3426 "rtp://%s:%d", ipaddr, ntohs(dest_addr->sin_port));
3429 if (url_open(&h, ctx->filename, AVIO_FLAG_WRITE) < 0)
3431 c->rtp_handles[stream_index] = h;
3432 max_packet_size = url_get_max_packet_size(h);
3434 case RTSP_LOWER_TRANSPORT_TCP:
3437 max_packet_size = RTSP_TCP_MAX_PACKET_SIZE;
3443 http_log("%s:%d - - \"PLAY %s/streamid=%d %s\"\n",
3444 ipaddr, ntohs(dest_addr->sin_port),
3445 c->stream->filename, stream_index, c->protocol);
3447 /* normally, no packets should be output here, but the packet size may be checked */
3448 if (ffio_open_dyn_packet_buf(&ctx->pb, max_packet_size) < 0) {
3449 /* XXX: close stream */
3452 if (avformat_write_header(ctx, NULL) < 0) {
3459 avio_close_dyn_buf(ctx->pb, &dummy_buf);
3462 c->rtp_ctx[stream_index] = ctx;
3466 /********************************************************************/
3467 /* ffserver initialization */
3469 static AVStream *add_av_stream1(FFStream *stream, AVCodecContext *codec, int copy)
3473 fst = av_mallocz(sizeof(AVStream));
3477 fst->codec = avcodec_alloc_context3(NULL);
3478 memcpy(fst->codec, codec, sizeof(AVCodecContext));
3479 if (codec->extradata_size) {
3480 fst->codec->extradata = av_malloc(codec->extradata_size);
3481 memcpy(fst->codec->extradata, codec->extradata,
3482 codec->extradata_size);
3485 /* live streams must use the actual feed's codec since it may be
3486 * updated later to carry extradata needed by the streams.
3490 fst->priv_data = av_mallocz(sizeof(FeedData));
3491 fst->index = stream->nb_streams;
3492 av_set_pts_info(fst, 33, 1, 90000);
3493 fst->sample_aspect_ratio = codec->sample_aspect_ratio;
3494 stream->streams[stream->nb_streams++] = fst;
3498 /* return the stream number in the feed */
3499 static int add_av_stream(FFStream *feed, AVStream *st)
3502 AVCodecContext *av, *av1;
3506 for(i=0;i<feed->nb_streams;i++) {
3507 st = feed->streams[i];
3509 if (av1->codec_id == av->codec_id &&
3510 av1->codec_type == av->codec_type &&
3511 av1->bit_rate == av->bit_rate) {
3513 switch(av->codec_type) {
3514 case AVMEDIA_TYPE_AUDIO:
3515 if (av1->channels == av->channels &&
3516 av1->sample_rate == av->sample_rate)
3519 case AVMEDIA_TYPE_VIDEO:
3520 if (av1->width == av->width &&
3521 av1->height == av->height &&
3522 av1->time_base.den == av->time_base.den &&
3523 av1->time_base.num == av->time_base.num &&
3524 av1->gop_size == av->gop_size)
3533 fst = add_av_stream1(feed, av, 0);
3536 return feed->nb_streams - 1;
3539 static void remove_stream(FFStream *stream)
3543 while (*ps != NULL) {
3551 /* specific mpeg4 handling : we extract the raw parameters */
3552 static void extract_mpeg4_header(AVFormatContext *infile)
3554 int mpeg4_count, i, size;
3560 for(i=0;i<infile->nb_streams;i++) {
3561 st = infile->streams[i];
3562 if (st->codec->codec_id == CODEC_ID_MPEG4 &&
3563 st->codec->extradata_size == 0) {
3570 printf("MPEG4 without extra data: trying to find header in %s\n", infile->filename);
3571 while (mpeg4_count > 0) {
3572 if (av_read_packet(infile, &pkt) < 0)
3574 st = infile->streams[pkt.stream_index];
3575 if (st->codec->codec_id == CODEC_ID_MPEG4 &&
3576 st->codec->extradata_size == 0) {
3577 av_freep(&st->codec->extradata);
3578 /* fill extradata with the header */
3579 /* XXX: we make hard suppositions here ! */
3581 while (p < pkt.data + pkt.size - 4) {
3582 /* stop when vop header is found */
3583 if (p[0] == 0x00 && p[1] == 0x00 &&
3584 p[2] == 0x01 && p[3] == 0xb6) {
3585 size = p - pkt.data;
3586 // av_hex_dump_log(infile, AV_LOG_DEBUG, pkt.data, size);
3587 st->codec->extradata = av_malloc(size);
3588 st->codec->extradata_size = size;
3589 memcpy(st->codec->extradata, pkt.data, size);
3596 av_free_packet(&pkt);
3600 /* compute the needed AVStream for each file */
3601 static void build_file_streams(void)
3603 FFStream *stream, *stream_next;
3606 /* gather all streams */
3607 for(stream = first_stream; stream != NULL; stream = stream_next) {
3608 AVFormatContext *infile = NULL;
3609 stream_next = stream->next;
3610 if (stream->stream_type == STREAM_TYPE_LIVE &&
3612 /* the stream comes from a file */
3613 /* try to open the file */
3615 if (stream->fmt && !strcmp(stream->fmt->name, "rtp")) {
3616 /* specific case : if transport stream output to RTP,
3617 we use a raw transport stream reader */
3618 av_dict_set(&stream->in_opts, "mpeg2ts_compute_pcr", "1", 0);
3621 http_log("Opening file '%s'\n", stream->feed_filename);
3622 if ((ret = avformat_open_input(&infile, stream->feed_filename, stream->ifmt, &stream->in_opts)) < 0) {
3623 http_log("Could not open '%s': %d\n", stream->feed_filename, ret);
3624 /* remove stream (no need to spend more time on it) */
3626 remove_stream(stream);
3628 /* find all the AVStreams inside and reference them in
3630 if (avformat_find_stream_info(infile, NULL) < 0) {
3631 http_log("Could not find codec parameters from '%s'\n",
3632 stream->feed_filename);
3633 av_close_input_file(infile);
3636 extract_mpeg4_header(infile);
3638 for(i=0;i<infile->nb_streams;i++)
3639 add_av_stream1(stream, infile->streams[i]->codec, 1);
3641 av_close_input_file(infile);
3647 /* compute the needed AVStream for each feed */
3648 static void build_feed_streams(void)
3650 FFStream *stream, *feed;
3653 /* gather all streams */
3654 for(stream = first_stream; stream != NULL; stream = stream->next) {
3655 feed = stream->feed;
3657 if (stream->is_feed) {
3658 for(i=0;i<stream->nb_streams;i++)
3659 stream->feed_streams[i] = i;
3661 /* we handle a stream coming from a feed */
3662 for(i=0;i<stream->nb_streams;i++)
3663 stream->feed_streams[i] = add_av_stream(feed, stream->streams[i]);
3668 /* create feed files if needed */
3669 for(feed = first_feed; feed != NULL; feed = feed->next_feed) {
3672 if (avio_check(feed->feed_filename, AVIO_FLAG_READ) > 0) {
3673 /* See if it matches */
3674 AVFormatContext *s = NULL;