2 * Multiple format streaming server
3 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22 #define _XOPEN_SOURCE 600
26 #define closesocket close
31 /* avformat.h defines LIBAVFORMAT_BUILD, include it before all the other libav* headers which use it */
32 #include "libavformat/avformat.h"
33 #include "libavformat/network.h"
34 #include "libavformat/os_support.h"
35 #include "libavformat/rtpdec.h"
36 #include "libavformat/rtsp.h"
37 #include "libavutil/avstring.h"
38 #include "libavutil/lfg.h"
39 #include "libavutil/random_seed.h"
40 #include "libavutil/intreadwrite.h"
41 #include "libavcodec/opt.h"
45 #include <sys/ioctl.h>
51 #undef time //needed because HAVE_AV_CONFIG_H is defined on top
63 const char program_name
[] = "FFserver";
64 const int program_birth_year
= 2000;
66 static const OptionDef options
[];
69 HTTPSTATE_WAIT_REQUEST
,
70 HTTPSTATE_SEND_HEADER
,
71 HTTPSTATE_SEND_DATA_HEADER
,
72 HTTPSTATE_SEND_DATA
, /* sending TCP or UDP data */
73 HTTPSTATE_SEND_DATA_TRAILER
,
74 HTTPSTATE_RECEIVE_DATA
,
75 HTTPSTATE_WAIT_FEED
, /* wait for data from the feed */
78 RTSPSTATE_WAIT_REQUEST
,
80 RTSPSTATE_SEND_PACKET
,
83 static const char *http_state
[] = {
99 #define IOBUFFER_INIT_SIZE 8192
101 /* timeouts are in ms */
102 #define HTTP_REQUEST_TIMEOUT (15 * 1000)
103 #define RTSP_REQUEST_TIMEOUT (3600 * 24 * 1000)
105 #define SYNC_TIMEOUT (10 * 1000)
107 typedef struct RTSPActionServerSetup
{
109 char transport_option
[512];
110 } RTSPActionServerSetup
;
113 int64_t count1
, count2
;
114 int64_t time1
, time2
;
117 /* context associated with one connection */
118 typedef struct HTTPContext
{
119 enum HTTPState state
;
120 int fd
; /* socket file descriptor */
121 struct sockaddr_in from_addr
; /* origin */
122 struct pollfd
*poll_entry
; /* used when polling */
124 uint8_t *buffer_ptr
, *buffer_end
;
127 struct HTTPContext
*next
;
128 int got_key_frame
; /* stream 0 => 1, stream 1 => 2, stream 2=> 4 */
132 /* input format handling */
133 AVFormatContext
*fmt_in
;
134 int64_t start_time
; /* In milliseconds - this wraps fairly often */
135 int64_t first_pts
; /* initial pts value */
136 int64_t cur_pts
; /* current pts value from the stream in us */
137 int64_t cur_frame_duration
; /* duration of the current frame in us */
138 int cur_frame_bytes
; /* output frame size, needed to compute
139 the time at which we send each
141 int pts_stream_index
; /* stream we choose as clock reference */
142 int64_t cur_clock
; /* current clock reference value in us */
143 /* output format handling */
144 struct FFStream
*stream
;
145 /* -1 is invalid stream */
146 int feed_streams
[MAX_STREAMS
]; /* index of streams in the feed */
147 int switch_feed_streams
[MAX_STREAMS
]; /* index of streams in the feed */
149 AVFormatContext fmt_ctx
; /* instance of FFStream for one user */
150 int last_packet_sent
; /* true if last data packet was sent */
152 DataRateData datarate
;
159 int is_packetized
; /* if true, the stream is packetized */
160 int packet_stream_index
; /* current stream for output in state machine */
162 /* RTSP state specific */
163 uint8_t *pb_buffer
; /* XXX: use that in all the code */
165 int seq
; /* RTSP sequence number */
167 /* RTP state specific */
168 enum RTSPLowerTransport rtp_protocol
;
169 char session_id
[32]; /* session id */
170 AVFormatContext
*rtp_ctx
[MAX_STREAMS
];
172 /* RTP/UDP specific */
173 URLContext
*rtp_handles
[MAX_STREAMS
];
175 /* RTP/TCP specific */
176 struct HTTPContext
*rtsp_c
;
177 uint8_t *packet_buffer
, *packet_buffer_ptr
, *packet_buffer_end
;
180 /* each generated stream is described here */
184 STREAM_TYPE_REDIRECT
,
187 enum IPAddressAction
{
192 typedef struct IPAddressACL
{
193 struct IPAddressACL
*next
;
194 enum IPAddressAction action
;
195 /* These are in host order */
196 struct in_addr first
;
200 /* description of each stream of the ffserver.conf file */
201 typedef struct FFStream
{
202 enum StreamType stream_type
;
203 char filename
[1024]; /* stream filename */
204 struct FFStream
*feed
; /* feed we are using (can be null if
206 AVFormatParameters
*ap_in
; /* input parameters */
207 AVInputFormat
*ifmt
; /* if non NULL, force input format */
211 int prebuffer
; /* Number of millseconds early to start */
212 int64_t max_time
; /* Number of milliseconds to run */
214 AVStream
*streams
[MAX_STREAMS
];
215 int feed_streams
[MAX_STREAMS
]; /* index of streams in the feed */
216 char feed_filename
[1024]; /* file name of the feed storage, or
217 input file name for a stream */
222 pid_t pid
; /* Of ffmpeg process */
223 time_t pid_start
; /* Of ffmpeg process */
225 struct FFStream
*next
;
226 unsigned bandwidth
; /* bandwidth, in kbits/s */
229 /* multicast specific */
231 struct in_addr multicast_ip
;
232 int multicast_port
; /* first port used for multicast */
234 int loop
; /* if true, send the stream in loops (only meaningful if file) */
237 int feed_opened
; /* true if someone is writing to the feed */
238 int is_feed
; /* true if it is a feed */
239 int readonly
; /* True if writing is prohibited to the file */
240 int truncate
; /* True if feeder connection truncate the feed file */
242 int64_t bytes_served
;
243 int64_t feed_max_size
; /* maximum storage size, zero means unlimited */
244 int64_t feed_write_index
; /* current write position in feed (it wraps around) */
245 int64_t feed_size
; /* current size of feed */
246 struct FFStream
*next_feed
;
249 typedef struct FeedData
{
250 long long data_count
;
251 float avg_frame_size
; /* frame size averaged over last frames with exponential mean */
254 static struct sockaddr_in my_http_addr
;
255 static struct sockaddr_in my_rtsp_addr
;
257 static char logfilename
[1024];
258 static HTTPContext
*first_http_ctx
;
259 static FFStream
*first_feed
; /* contains only feeds */
260 static FFStream
*first_stream
; /* contains all streams, including feeds */
262 static void new_connection(int server_fd
, int is_rtsp
);
263 static void close_connection(HTTPContext
*c
);
266 static int handle_connection(HTTPContext
*c
);
267 static int http_parse_request(HTTPContext
*c
);
268 static int http_send_data(HTTPContext
*c
);
269 static void compute_status(HTTPContext
*c
);
270 static int open_input_stream(HTTPContext
*c
, const char *info
);
271 static int http_start_receive_data(HTTPContext
*c
);
272 static int http_receive_data(HTTPContext
*c
);
275 static int rtsp_parse_request(HTTPContext
*c
);
276 static void rtsp_cmd_describe(HTTPContext
*c
, const char *url
);
277 static void rtsp_cmd_options(HTTPContext
*c
, const char *url
);
278 static void rtsp_cmd_setup(HTTPContext
*c
, const char *url
, RTSPMessageHeader
*h
);
279 static void rtsp_cmd_play(HTTPContext
*c
, const char *url
, RTSPMessageHeader
*h
);
280 static void rtsp_cmd_pause(HTTPContext
*c
, const char *url
, RTSPMessageHeader
*h
);
281 static void rtsp_cmd_teardown(HTTPContext
*c
, const char *url
, RTSPMessageHeader
*h
);
284 static int prepare_sdp_description(FFStream
*stream
, uint8_t **pbuffer
,
285 struct in_addr my_ip
);
288 static HTTPContext
*rtp_new_connection(struct sockaddr_in
*from_addr
,
289 FFStream
*stream
, const char *session_id
,
290 enum RTSPLowerTransport rtp_protocol
);
291 static int rtp_new_av_stream(HTTPContext
*c
,
292 int stream_index
, struct sockaddr_in
*dest_addr
,
293 HTTPContext
*rtsp_c
);
295 static const char *my_program_name
;
296 static const char *my_program_dir
;
298 static const char *config_filename
;
299 static int ffserver_debug
;
300 static int ffserver_daemon
;
301 static int no_launch
;
302 static int need_to_start_children
;
304 /* maximum number of simultaneous HTTP connections */
305 static unsigned int nb_max_http_connections
= 2000;
306 static unsigned int nb_max_connections
= 5;
307 static unsigned int nb_connections
;
309 static uint64_t max_bandwidth
= 1000;
310 static uint64_t current_bandwidth
;
312 static int64_t cur_time
; // Making this global saves on passing it around everywhere
314 static AVLFG random_state
;
316 static FILE *logfile
= NULL
;
318 static char *ctime1(char *buf2
)
326 p
= buf2
+ strlen(p
) - 1;
332 static void http_vlog(const char *fmt
, va_list vargs
)
334 static int print_prefix
= 1;
339 fprintf(logfile
, "%s ", buf
);
341 print_prefix
= strstr(fmt
, "\n") != NULL
;
342 vfprintf(logfile
, fmt
, vargs
);
347 void __attribute__ ((format (printf
, 1, 2))) http_log(const char *fmt
, ...)
350 va_start(vargs
, fmt
);
351 http_vlog(fmt
, vargs
);
355 static void http_av_log(void *ptr
, int level
, const char *fmt
, va_list vargs
)
357 static int print_prefix
= 1;
358 AVClass
*avc
= ptr
? *(AVClass
**)ptr
: NULL
;
359 if (level
> av_log_get_level())
361 if (print_prefix
&& avc
)
362 http_log("[%s @ %p]", avc
->item_name(ptr
), ptr
);
363 print_prefix
= strstr(fmt
, "\n") != NULL
;
364 http_vlog(fmt
, vargs
);
367 static void log_connection(HTTPContext
*c
)
372 http_log("%s - - [%s] \"%s %s\" %d %"PRId64
"\n",
373 inet_ntoa(c
->from_addr
.sin_addr
), c
->method
, c
->url
,
374 c
->protocol
, (c
->http_error
? c
->http_error
: 200), c
->data_count
);
377 static void update_datarate(DataRateData
*drd
, int64_t count
)
379 if (!drd
->time1
&& !drd
->count1
) {
380 drd
->time1
= drd
->time2
= cur_time
;
381 drd
->count1
= drd
->count2
= count
;
382 } else if (cur_time
- drd
->time2
> 5000) {
383 drd
->time1
= drd
->time2
;
384 drd
->count1
= drd
->count2
;
385 drd
->time2
= cur_time
;
390 /* In bytes per second */
391 static int compute_datarate(DataRateData
*drd
, int64_t count
)
393 if (cur_time
== drd
->time1
)
396 return ((count
- drd
->count1
) * 1000) / (cur_time
- drd
->time1
);
400 static void start_children(FFStream
*feed
)
405 for (; feed
; feed
= feed
->next
) {
406 if (feed
->child_argv
&& !feed
->pid
) {
407 feed
->pid_start
= time(0);
412 http_log("Unable to create children\n");
421 av_strlcpy(pathname
, my_program_name
, sizeof(pathname
));
423 slash
= strrchr(pathname
, '/');
428 strcpy(slash
, "ffmpeg");
430 http_log("Launch commandline: ");
431 http_log("%s ", pathname
);
432 for (i
= 1; feed
->child_argv
[i
] && feed
->child_argv
[i
][0]; i
++)
433 http_log("%s ", feed
->child_argv
[i
]);
436 for (i
= 3; i
< 256; i
++)
439 if (!ffserver_debug
) {
440 i
= open("/dev/null", O_RDWR
);
449 /* This is needed to make relative pathnames work */
450 chdir(my_program_dir
);
452 signal(SIGPIPE
, SIG_DFL
);
454 execvp(pathname
, feed
->child_argv
);
462 /* open a listening socket */
463 static int socket_open_listen(struct sockaddr_in
*my_addr
)
467 server_fd
= socket(AF_INET
,SOCK_STREAM
,0);
474 setsockopt(server_fd
, SOL_SOCKET
, SO_REUSEADDR
, &tmp
, sizeof(tmp
));
476 if (bind (server_fd
, (struct sockaddr
*) my_addr
, sizeof (*my_addr
)) < 0) {
478 snprintf(bindmsg
, sizeof(bindmsg
), "bind(port %d)", ntohs(my_addr
->sin_port
));
480 closesocket(server_fd
);
484 if (listen (server_fd
, 5) < 0) {
486 closesocket(server_fd
);
489 ff_socket_nonblock(server_fd
, 1);
494 /* start all multicast streams */
495 static void start_multicast(void)
500 struct sockaddr_in dest_addr
;
501 int default_port
, stream_index
;
504 for(stream
= first_stream
; stream
!= NULL
; stream
= stream
->next
) {
505 if (stream
->is_multicast
) {
506 /* open the RTP connection */
507 snprintf(session_id
, sizeof(session_id
), "%08x%08x",
508 av_lfg_get(&random_state
), av_lfg_get(&random_state
));
510 /* choose a port if none given */
511 if (stream
->multicast_port
== 0) {
512 stream
->multicast_port
= default_port
;
516 dest_addr
.sin_family
= AF_INET
;
517 dest_addr
.sin_addr
= stream
->multicast_ip
;
518 dest_addr
.sin_port
= htons(stream
->multicast_port
);
520 rtp_c
= rtp_new_connection(&dest_addr
, stream
, session_id
,
521 RTSP_LOWER_TRANSPORT_UDP_MULTICAST
);
525 if (open_input_stream(rtp_c
, "") < 0) {
526 http_log("Could not open input stream for stream '%s'\n",
531 /* open each RTP stream */
532 for(stream_index
= 0; stream_index
< stream
->nb_streams
;
534 dest_addr
.sin_port
= htons(stream
->multicast_port
+
536 if (rtp_new_av_stream(rtp_c
, stream_index
, &dest_addr
, NULL
) < 0) {
537 http_log("Could not open output stream '%s/streamid=%d'\n",
538 stream
->filename
, stream_index
);
543 /* change state to send data */
544 rtp_c
->state
= HTTPSTATE_SEND_DATA
;
549 /* main loop of the http server */
550 static int http_server(void)
552 int server_fd
= 0, rtsp_server_fd
= 0;
553 int ret
, delay
, delay1
;
554 struct pollfd
*poll_table
, *poll_entry
;
555 HTTPContext
*c
, *c_next
;
557 if(!(poll_table
= av_mallocz((nb_max_http_connections
+ 2)*sizeof(*poll_table
)))) {
558 http_log("Impossible to allocate a poll table handling %d connections.\n", nb_max_http_connections
);
562 if (my_http_addr
.sin_port
) {
563 server_fd
= socket_open_listen(&my_http_addr
);
568 if (my_rtsp_addr
.sin_port
) {
569 rtsp_server_fd
= socket_open_listen(&my_rtsp_addr
);
570 if (rtsp_server_fd
< 0)
574 if (!rtsp_server_fd
&& !server_fd
) {
575 http_log("HTTP and RTSP disabled.\n");
579 http_log("FFserver started.\n");
581 start_children(first_feed
);
586 poll_entry
= poll_table
;
588 poll_entry
->fd
= server_fd
;
589 poll_entry
->events
= POLLIN
;
592 if (rtsp_server_fd
) {
593 poll_entry
->fd
= rtsp_server_fd
;
594 poll_entry
->events
= POLLIN
;
598 /* wait for events on each HTTP handle */
605 case HTTPSTATE_SEND_HEADER
:
606 case RTSPSTATE_SEND_REPLY
:
607 case RTSPSTATE_SEND_PACKET
:
608 c
->poll_entry
= poll_entry
;
610 poll_entry
->events
= POLLOUT
;
613 case HTTPSTATE_SEND_DATA_HEADER
:
614 case HTTPSTATE_SEND_DATA
:
615 case HTTPSTATE_SEND_DATA_TRAILER
:
616 if (!c
->is_packetized
) {
617 /* for TCP, we output as much as we can (may need to put a limit) */
618 c
->poll_entry
= poll_entry
;
620 poll_entry
->events
= POLLOUT
;
623 /* when ffserver is doing the timing, we work by
624 looking at which packet need to be sent every
626 delay1
= 10; /* one tick wait XXX: 10 ms assumed */
631 case HTTPSTATE_WAIT_REQUEST
:
632 case HTTPSTATE_RECEIVE_DATA
:
633 case HTTPSTATE_WAIT_FEED
:
634 case RTSPSTATE_WAIT_REQUEST
:
635 /* need to catch errors */
636 c
->poll_entry
= poll_entry
;
638 poll_entry
->events
= POLLIN
;/* Maybe this will work */
642 c
->poll_entry
= NULL
;
648 /* wait for an event on one connection. We poll at least every
649 second to handle timeouts */
651 ret
= poll(poll_table
, poll_entry
- poll_table
, delay
);
652 if (ret
< 0 && ff_neterrno() != FF_NETERROR(EAGAIN
) &&
653 ff_neterrno() != FF_NETERROR(EINTR
))
657 cur_time
= av_gettime() / 1000;
659 if (need_to_start_children
) {
660 need_to_start_children
= 0;
661 start_children(first_feed
);
664 /* now handle the events */
665 for(c
= first_http_ctx
; c
!= NULL
; c
= c_next
) {
667 if (handle_connection(c
) < 0) {
668 /* close and free the connection */
674 poll_entry
= poll_table
;
676 /* new HTTP connection request ? */
677 if (poll_entry
->revents
& POLLIN
)
678 new_connection(server_fd
, 0);
681 if (rtsp_server_fd
) {
682 /* new RTSP connection request ? */
683 if (poll_entry
->revents
& POLLIN
)
684 new_connection(rtsp_server_fd
, 1);
689 /* start waiting for a new HTTP/RTSP request */
690 static void start_wait_request(HTTPContext
*c
, int is_rtsp
)
692 c
->buffer_ptr
= c
->buffer
;
693 c
->buffer_end
= c
->buffer
+ c
->buffer_size
- 1; /* leave room for '\0' */
696 c
->timeout
= cur_time
+ RTSP_REQUEST_TIMEOUT
;
697 c
->state
= RTSPSTATE_WAIT_REQUEST
;
699 c
->timeout
= cur_time
+ HTTP_REQUEST_TIMEOUT
;
700 c
->state
= HTTPSTATE_WAIT_REQUEST
;
704 static void http_send_too_busy_reply(int fd
)
707 int len
= snprintf(buffer
, sizeof(buffer
),
708 "HTTP/1.0 200 Server too busy\r\n"
709 "Content-type: text/html\r\n"
711 "<html><head><title>Too busy</title></head><body>\r\n"
712 "<p>The server is too busy to serve your request at this time.</p>\r\n"
713 "<p>The number of current connections is %d, and this exceeds the limit of %d.</p>\r\n"
714 "</body></html>\r\n",
715 nb_connections
, nb_max_connections
);
716 send(fd
, buffer
, len
, 0);
720 static void new_connection(int server_fd
, int is_rtsp
)
722 struct sockaddr_in from_addr
;
724 HTTPContext
*c
= NULL
;
726 len
= sizeof(from_addr
);
727 fd
= accept(server_fd
, (struct sockaddr
*)&from_addr
,
730 http_log("error during accept %s\n", strerror(errno
));
733 ff_socket_nonblock(fd
, 1);
735 if (nb_connections
>= nb_max_connections
) {
736 http_send_too_busy_reply(fd
);
740 /* add a new connection */
741 c
= av_mallocz(sizeof(HTTPContext
));
746 c
->poll_entry
= NULL
;
747 c
->from_addr
= from_addr
;
748 c
->buffer_size
= IOBUFFER_INIT_SIZE
;
749 c
->buffer
= av_malloc(c
->buffer_size
);
753 c
->next
= first_http_ctx
;
757 start_wait_request(c
, is_rtsp
);
769 static void close_connection(HTTPContext
*c
)
771 HTTPContext
**cp
, *c1
;
773 AVFormatContext
*ctx
;
777 /* remove connection from list */
778 cp
= &first_http_ctx
;
779 while ((*cp
) != NULL
) {
787 /* remove references, if any (XXX: do it faster) */
788 for(c1
= first_http_ctx
; c1
!= NULL
; c1
= c1
->next
) {
793 /* remove connection associated resources */
797 /* close each frame parser */
798 for(i
=0;i
<c
->fmt_in
->nb_streams
;i
++) {
799 st
= c
->fmt_in
->streams
[i
];
800 if (st
->codec
->codec
)
801 avcodec_close(st
->codec
);
803 av_close_input_file(c
->fmt_in
);
806 /* free RTP output streams if any */
809 nb_streams
= c
->stream
->nb_streams
;
811 for(i
=0;i
<nb_streams
;i
++) {
814 av_write_trailer(ctx
);
817 h
= c
->rtp_handles
[i
];
824 if (!c
->last_packet_sent
&& c
->state
== HTTPSTATE_SEND_DATA_TRAILER
) {
827 if (url_open_dyn_buf(&ctx
->pb
) >= 0) {
828 av_write_trailer(ctx
);
829 av_freep(&c
->pb_buffer
);
830 url_close_dyn_buf(ctx
->pb
, &c
->pb_buffer
);
835 for(i
=0; i
<ctx
->nb_streams
; i
++)
836 av_free(ctx
->streams
[i
]);
838 if (c
->stream
&& !c
->post
&& c
->stream
->stream_type
== STREAM_TYPE_LIVE
)
839 current_bandwidth
-= c
->stream
->bandwidth
;
841 /* signal that there is no feed if we are the feeder socket */
842 if (c
->state
== HTTPSTATE_RECEIVE_DATA
&& c
->stream
) {
843 c
->stream
->feed_opened
= 0;
847 av_freep(&c
->pb_buffer
);
848 av_freep(&c
->packet_buffer
);
854 static int handle_connection(HTTPContext
*c
)
859 case HTTPSTATE_WAIT_REQUEST
:
860 case RTSPSTATE_WAIT_REQUEST
:
862 if ((c
->timeout
- cur_time
) < 0)
864 if (c
->poll_entry
->revents
& (POLLERR
| POLLHUP
))
867 /* no need to read if no events */
868 if (!(c
->poll_entry
->revents
& POLLIN
))
872 len
= recv(c
->fd
, c
->buffer_ptr
, 1, 0);
874 if (ff_neterrno() != FF_NETERROR(EAGAIN
) &&
875 ff_neterrno() != FF_NETERROR(EINTR
))
877 } else if (len
== 0) {
880 /* search for end of request. */
882 c
->buffer_ptr
+= len
;
884 if ((ptr
>= c
->buffer
+ 2 && !memcmp(ptr
-2, "\n\n", 2)) ||
885 (ptr
>= c
->buffer
+ 4 && !memcmp(ptr
-4, "\r\n\r\n", 4))) {
886 /* request found : parse it and reply */
887 if (c
->state
== HTTPSTATE_WAIT_REQUEST
) {
888 ret
= http_parse_request(c
);
890 ret
= rtsp_parse_request(c
);
894 } else if (ptr
>= c
->buffer_end
) {
895 /* request too long: cannot do anything */
897 } else goto read_loop
;
901 case HTTPSTATE_SEND_HEADER
:
902 if (c
->poll_entry
->revents
& (POLLERR
| POLLHUP
))
905 /* no need to write if no events */
906 if (!(c
->poll_entry
->revents
& POLLOUT
))
908 len
= send(c
->fd
, c
->buffer_ptr
, c
->buffer_end
- c
->buffer_ptr
, 0);
910 if (ff_neterrno() != FF_NETERROR(EAGAIN
) &&
911 ff_neterrno() != FF_NETERROR(EINTR
)) {
912 /* error : close connection */
913 av_freep(&c
->pb_buffer
);
917 c
->buffer_ptr
+= len
;
919 c
->stream
->bytes_served
+= len
;
920 c
->data_count
+= len
;
921 if (c
->buffer_ptr
>= c
->buffer_end
) {
922 av_freep(&c
->pb_buffer
);
926 /* all the buffer was sent : synchronize to the incoming stream */
927 c
->state
= HTTPSTATE_SEND_DATA_HEADER
;
928 c
->buffer_ptr
= c
->buffer_end
= c
->buffer
;
933 case HTTPSTATE_SEND_DATA
:
934 case HTTPSTATE_SEND_DATA_HEADER
:
935 case HTTPSTATE_SEND_DATA_TRAILER
:
936 /* for packetized output, we consider we can always write (the
937 input streams sets the speed). It may be better to verify
938 that we do not rely too much on the kernel queues */
939 if (!c
->is_packetized
) {
940 if (c
->poll_entry
->revents
& (POLLERR
| POLLHUP
))
943 /* no need to read if no events */
944 if (!(c
->poll_entry
->revents
& POLLOUT
))
947 if (http_send_data(c
) < 0)
949 /* close connection if trailer sent */
950 if (c
->state
== HTTPSTATE_SEND_DATA_TRAILER
)
953 case HTTPSTATE_RECEIVE_DATA
:
954 /* no need to read if no events */
955 if (c
->poll_entry
->revents
& (POLLERR
| POLLHUP
))
957 if (!(c
->poll_entry
->revents
& POLLIN
))
959 if (http_receive_data(c
) < 0)
962 case HTTPSTATE_WAIT_FEED
:
963 /* no need to read if no events */
964 if (c
->poll_entry
->revents
& (POLLIN
| POLLERR
| POLLHUP
))
967 /* nothing to do, we'll be waken up by incoming feed packets */
970 case RTSPSTATE_SEND_REPLY
:
971 if (c
->poll_entry
->revents
& (POLLERR
| POLLHUP
)) {
972 av_freep(&c
->pb_buffer
);
975 /* no need to write if no events */
976 if (!(c
->poll_entry
->revents
& POLLOUT
))
978 len
= send(c
->fd
, c
->buffer_ptr
, c
->buffer_end
- c
->buffer_ptr
, 0);
980 if (ff_neterrno() != FF_NETERROR(EAGAIN
) &&
981 ff_neterrno() != FF_NETERROR(EINTR
)) {
982 /* error : close connection */
983 av_freep(&c
->pb_buffer
);
987 c
->buffer_ptr
+= len
;
988 c
->data_count
+= len
;
989 if (c
->buffer_ptr
>= c
->buffer_end
) {
990 /* all the buffer was sent : wait for a new request */
991 av_freep(&c
->pb_buffer
);
992 start_wait_request(c
, 1);
996 case RTSPSTATE_SEND_PACKET
:
997 if (c
->poll_entry
->revents
& (POLLERR
| POLLHUP
)) {
998 av_freep(&c
->packet_buffer
);
1001 /* no need to write if no events */
1002 if (!(c
->poll_entry
->revents
& POLLOUT
))
1004 len
= send(c
->fd
, c
->packet_buffer_ptr
,
1005 c
->packet_buffer_end
- c
->packet_buffer_ptr
, 0);
1007 if (ff_neterrno() != FF_NETERROR(EAGAIN
) &&
1008 ff_neterrno() != FF_NETERROR(EINTR
)) {
1009 /* error : close connection */
1010 av_freep(&c
->packet_buffer
);
1014 c
->packet_buffer_ptr
+= len
;
1015 if (c
->packet_buffer_ptr
>= c
->packet_buffer_end
) {
1016 /* all the buffer was sent : wait for a new request */
1017 av_freep(&c
->packet_buffer
);
1018 c
->state
= RTSPSTATE_WAIT_REQUEST
;
1022 case HTTPSTATE_READY
:
1031 static int extract_rates(char *rates
, int ratelen
, const char *request
)
1035 for (p
= request
; *p
&& *p
!= '\r' && *p
!= '\n'; ) {
1036 if (strncasecmp(p
, "Pragma:", 7) == 0) {
1037 const char *q
= p
+ 7;
1039 while (*q
&& *q
!= '\n' && isspace(*q
))
1042 if (strncasecmp(q
, "stream-switch-entry=", 20) == 0) {
1048 memset(rates
, 0xff, ratelen
);
1051 while (*q
&& *q
!= '\n' && *q
!= ':')
1054 if (sscanf(q
, ":%d:%d", &stream_no
, &rate_no
) != 2)
1058 if (stream_no
< ratelen
&& stream_no
>= 0)
1059 rates
[stream_no
] = rate_no
;
1061 while (*q
&& *q
!= '\n' && !isspace(*q
))
1068 p
= strchr(p
, '\n');
1078 static int find_stream_in_feed(FFStream
*feed
, AVCodecContext
*codec
, int bit_rate
)
1081 int best_bitrate
= 100000000;
1084 for (i
= 0; i
< feed
->nb_streams
; i
++) {
1085 AVCodecContext
*feed_codec
= feed
->streams
[i
]->codec
;
1087 if (feed_codec
->codec_id
!= codec
->codec_id
||
1088 feed_codec
->sample_rate
!= codec
->sample_rate
||
1089 feed_codec
->width
!= codec
->width
||
1090 feed_codec
->height
!= codec
->height
)
1093 /* Potential stream */
1095 /* We want the fastest stream less than bit_rate, or the slowest
1096 * faster than bit_rate
1099 if (feed_codec
->bit_rate
<= bit_rate
) {
1100 if (best_bitrate
> bit_rate
|| feed_codec
->bit_rate
> best_bitrate
) {
1101 best_bitrate
= feed_codec
->bit_rate
;
1105 if (feed_codec
->bit_rate
< best_bitrate
) {
1106 best_bitrate
= feed_codec
->bit_rate
;
1115 static int modify_current_stream(HTTPContext
*c
, char *rates
)
1118 FFStream
*req
= c
->stream
;
1119 int action_required
= 0;
1121 /* Not much we can do for a feed */
1125 for (i
= 0; i
< req
->nb_streams
; i
++) {
1126 AVCodecContext
*codec
= req
->streams
[i
]->codec
;
1130 c
->switch_feed_streams
[i
] = req
->feed_streams
[i
];
1133 c
->switch_feed_streams
[i
] = find_stream_in_feed(req
->feed
, codec
, codec
->bit_rate
/ 2);
1136 /* Wants off or slow */
1137 c
->switch_feed_streams
[i
] = find_stream_in_feed(req
->feed
, codec
, codec
->bit_rate
/ 4);
1139 /* This doesn't work well when it turns off the only stream! */
1140 c
->switch_feed_streams
[i
] = -2;
1141 c
->feed_streams
[i
] = -2;
1146 if (c
->switch_feed_streams
[i
] >= 0 && c
->switch_feed_streams
[i
] != c
->feed_streams
[i
])
1147 action_required
= 1;
1150 return action_required
;
1154 static void do_switch_stream(HTTPContext
*c
, int i
)
1156 if (c
->switch_feed_streams
[i
] >= 0) {
1158 c
->feed_streams
[i
] = c
->switch_feed_streams
[i
];
1161 /* Now update the stream */
1163 c
->switch_feed_streams
[i
] = -1;
1166 /* XXX: factorize in utils.c ? */
1167 /* XXX: take care with different space meaning */
1168 static void skip_spaces(const char **pp
)
1172 while (*p
== ' ' || *p
== '\t')
1177 static void get_word(char *buf
, int buf_size
, const char **pp
)
1185 while (!isspace(*p
) && *p
!= '\0') {
1186 if ((q
- buf
) < buf_size
- 1)
1195 static void get_arg(char *buf
, int buf_size
, const char **pp
)
1202 while (isspace(*p
)) p
++;
1205 if (*p
== '\"' || *p
== '\'')
1217 if ((q
- buf
) < buf_size
- 1)
1222 if (quote
&& *p
== quote
)
1227 static int validate_acl(FFStream
*stream
, HTTPContext
*c
)
1229 enum IPAddressAction last_action
= IP_DENY
;
1231 struct in_addr
*src
= &c
->from_addr
.sin_addr
;
1232 unsigned long src_addr
= src
->s_addr
;
1234 for (acl
= stream
->acl
; acl
; acl
= acl
->next
) {
1235 if (src_addr
>= acl
->first
.s_addr
&& src_addr
<= acl
->last
.s_addr
)
1236 return (acl
->action
== IP_ALLOW
) ? 1 : 0;
1237 last_action
= acl
->action
;
1240 /* Nothing matched, so return not the last action */
1241 return (last_action
== IP_DENY
) ? 1 : 0;
1244 /* compute the real filename of a file by matching it without its
1245 extensions to all the stream filenames */
1246 static void compute_real_filename(char *filename
, int max_size
)
1253 /* compute filename by matching without the file extensions */
1254 av_strlcpy(file1
, filename
, sizeof(file1
));
1255 p
= strrchr(file1
, '.');
1258 for(stream
= first_stream
; stream
!= NULL
; stream
= stream
->next
) {
1259 av_strlcpy(file2
, stream
->filename
, sizeof(file2
));
1260 p
= strrchr(file2
, '.');
1263 if (!strcmp(file1
, file2
)) {
1264 av_strlcpy(filename
, stream
->filename
, max_size
);
1279 /* parse http request and prepare header */
1280 static int http_parse_request(HTTPContext
*c
)
1283 enum RedirType redir_type
;
1285 char info
[1024], filename
[1024];
1289 const char *mime_type
;
1293 char *useragent
= 0;
1296 get_word(cmd
, sizeof(cmd
), (const char **)&p
);
1297 av_strlcpy(c
->method
, cmd
, sizeof(c
->method
));
1299 if (!strcmp(cmd
, "GET"))
1301 else if (!strcmp(cmd
, "POST"))
1306 get_word(url
, sizeof(url
), (const char **)&p
);
1307 av_strlcpy(c
->url
, url
, sizeof(c
->url
));
1309 get_word(protocol
, sizeof(protocol
), (const char **)&p
);
1310 if (strcmp(protocol
, "HTTP/1.0") && strcmp(protocol
, "HTTP/1.1"))
1313 av_strlcpy(c
->protocol
, protocol
, sizeof(c
->protocol
));
1316 http_log("%s - - New connection: %s %s\n", inet_ntoa(c
->from_addr
.sin_addr
), cmd
, url
);
1318 /* find the filename and the optional info string in the request */
1319 p
= strchr(url
, '?');
1321 av_strlcpy(info
, p
, sizeof(info
));
1326 av_strlcpy(filename
, url
+ ((*url
== '/') ? 1 : 0), sizeof(filename
)-1);
1328 for (p
= c
->buffer
; *p
&& *p
!= '\r' && *p
!= '\n'; ) {
1329 if (strncasecmp(p
, "User-Agent:", 11) == 0) {
1331 if (*useragent
&& *useragent
!= '\n' && isspace(*useragent
))
1335 p
= strchr(p
, '\n');
1342 redir_type
= REDIR_NONE
;
1343 if (match_ext(filename
, "asx")) {
1344 redir_type
= REDIR_ASX
;
1345 filename
[strlen(filename
)-1] = 'f';
1346 } else if (match_ext(filename
, "asf") &&
1347 (!useragent
|| strncasecmp(useragent
, "NSPlayer", 8) != 0)) {
1348 /* if this isn't WMP or lookalike, return the redirector file */
1349 redir_type
= REDIR_ASF
;
1350 } else if (match_ext(filename
, "rpm,ram")) {
1351 redir_type
= REDIR_RAM
;
1352 strcpy(filename
+ strlen(filename
)-2, "m");
1353 } else if (match_ext(filename
, "rtsp")) {
1354 redir_type
= REDIR_RTSP
;
1355 compute_real_filename(filename
, sizeof(filename
) - 1);
1356 } else if (match_ext(filename
, "sdp")) {
1357 redir_type
= REDIR_SDP
;
1358 compute_real_filename(filename
, sizeof(filename
) - 1);
1361 // "redirect" / request to index.html
1362 if (!strlen(filename
))
1363 av_strlcpy(filename
, "index.html", sizeof(filename
) - 1);
1365 stream
= first_stream
;
1366 while (stream
!= NULL
) {
1367 if (!strcmp(stream
->filename
, filename
) && validate_acl(stream
, c
))
1369 stream
= stream
->next
;
1371 if (stream
== NULL
) {
1372 snprintf(msg
, sizeof(msg
), "File '%s' not found", url
);
1373 http_log("File '%s' not found\n", url
);
1378 memcpy(c
->feed_streams
, stream
->feed_streams
, sizeof(c
->feed_streams
));
1379 memset(c
->switch_feed_streams
, -1, sizeof(c
->switch_feed_streams
));
1381 if (stream
->stream_type
== STREAM_TYPE_REDIRECT
) {
1382 c
->http_error
= 301;
1384 q
+= snprintf(q
, c
->buffer_size
,
1385 "HTTP/1.0 301 Moved\r\n"
1387 "Content-type: text/html\r\n"
1389 "<html><head><title>Moved</title></head><body>\r\n"
1390 "You should be <a href=\"%s\">redirected</a>.\r\n"
1391 "</body></html>\r\n", stream
->feed_filename
, stream
->feed_filename
);
1392 /* prepare output buffer */
1393 c
->buffer_ptr
= c
->buffer
;
1395 c
->state
= HTTPSTATE_SEND_HEADER
;
1399 /* If this is WMP, get the rate information */
1400 if (extract_rates(ratebuf
, sizeof(ratebuf
), c
->buffer
)) {
1401 if (modify_current_stream(c
, ratebuf
)) {
1402 for (i
= 0; i
< FF_ARRAY_ELEMS(c
->feed_streams
); i
++) {
1403 if (c
->switch_feed_streams
[i
] >= 0)
1404 do_switch_stream(c
, i
);
1409 if (c
->post
== 0 && stream
->stream_type
== STREAM_TYPE_LIVE
)
1410 current_bandwidth
+= stream
->bandwidth
;
1412 /* If already streaming this feed, do not let start another feeder. */
1413 if (stream
->feed_opened
) {
1414 snprintf(msg
, sizeof(msg
), "This feed is already being received.");
1415 http_log("Feed '%s' already being received\n", stream
->feed_filename
);
1419 if (c
->post
== 0 && max_bandwidth
< current_bandwidth
) {
1420 c
->http_error
= 200;
1422 q
+= snprintf(q
, c
->buffer_size
,
1423 "HTTP/1.0 200 Server too busy\r\n"
1424 "Content-type: text/html\r\n"
1426 "<html><head><title>Too busy</title></head><body>\r\n"
1427 "<p>The server is too busy to serve your request at this time.</p>\r\n"
1428 "<p>The bandwidth being served (including your stream) is %"PRIu64
"kbit/sec, "
1429 "and this exceeds the limit of %"PRIu64
"kbit/sec.</p>\r\n"
1430 "</body></html>\r\n", current_bandwidth
, max_bandwidth
);
1431 /* prepare output buffer */
1432 c
->buffer_ptr
= c
->buffer
;
1434 c
->state
= HTTPSTATE_SEND_HEADER
;
1438 if (redir_type
!= REDIR_NONE
) {
1441 for (p
= c
->buffer
; *p
&& *p
!= '\r' && *p
!= '\n'; ) {
1442 if (strncasecmp(p
, "Host:", 5) == 0) {
1446 p
= strchr(p
, '\n');
1457 while (isspace(*hostinfo
))
1460 eoh
= strchr(hostinfo
, '\n');
1462 if (eoh
[-1] == '\r')
1465 if (eoh
- hostinfo
< sizeof(hostbuf
) - 1) {
1466 memcpy(hostbuf
, hostinfo
, eoh
- hostinfo
);
1467 hostbuf
[eoh
- hostinfo
] = 0;
1469 c
->http_error
= 200;
1471 switch(redir_type
) {
1473 q
+= snprintf(q
, c
->buffer_size
,
1474 "HTTP/1.0 200 ASX Follows\r\n"
1475 "Content-type: video/x-ms-asf\r\n"
1477 "<ASX Version=\"3\">\r\n"
1478 //"<!-- Autogenerated by ffserver -->\r\n"
1479 "<ENTRY><REF HREF=\"http://%s/%s%s\"/></ENTRY>\r\n"
1480 "</ASX>\r\n", hostbuf
, filename
, info
);
1483 q
+= snprintf(q
, c
->buffer_size
,
1484 "HTTP/1.0 200 RAM Follows\r\n"
1485 "Content-type: audio/x-pn-realaudio\r\n"
1487 "# Autogenerated by ffserver\r\n"
1488 "http://%s/%s%s\r\n", hostbuf
, filename
, info
);
1491 q
+= snprintf(q
, c
->buffer_size
,
1492 "HTTP/1.0 200 ASF Redirect follows\r\n"
1493 "Content-type: video/x-ms-asf\r\n"
1496 "Ref1=http://%s/%s%s\r\n", hostbuf
, filename
, info
);
1500 char hostname
[256], *p
;
1501 /* extract only hostname */
1502 av_strlcpy(hostname
, hostbuf
, sizeof(hostname
));
1503 p
= strrchr(hostname
, ':');
1506 q
+= snprintf(q
, c
->buffer_size
,
1507 "HTTP/1.0 200 RTSP Redirect follows\r\n"
1508 /* XXX: incorrect mime type ? */
1509 "Content-type: application/x-rtsp\r\n"
1511 "rtsp://%s:%d/%s\r\n", hostname
, ntohs(my_rtsp_addr
.sin_port
), filename
);
1517 int sdp_data_size
, len
;
1518 struct sockaddr_in my_addr
;
1520 q
+= snprintf(q
, c
->buffer_size
,
1521 "HTTP/1.0 200 OK\r\n"
1522 "Content-type: application/sdp\r\n"
1525 len
= sizeof(my_addr
);
1526 getsockname(c
->fd
, (struct sockaddr
*)&my_addr
, &len
);
1528 /* XXX: should use a dynamic buffer */
1529 sdp_data_size
= prepare_sdp_description(stream
,
1532 if (sdp_data_size
> 0) {
1533 memcpy(q
, sdp_data
, sdp_data_size
);
1545 /* prepare output buffer */
1546 c
->buffer_ptr
= c
->buffer
;
1548 c
->state
= HTTPSTATE_SEND_HEADER
;
1554 snprintf(msg
, sizeof(msg
), "ASX/RAM file not handled");
1558 stream
->conns_served
++;
1560 /* XXX: add there authenticate and IP match */
1563 /* if post, it means a feed is being sent */
1564 if (!stream
->is_feed
) {
1565 /* However it might be a status report from WMP! Let us log the
1566 * data as it might come in handy one day. */
1570 for (p
= c
->buffer
; *p
&& *p
!= '\r' && *p
!= '\n'; ) {
1571 if (strncasecmp(p
, "Pragma: log-line=", 17) == 0) {
1575 if (strncasecmp(p
, "Pragma: client-id=", 18) == 0)
1576 client_id
= strtol(p
+ 18, 0, 10);
1577 p
= strchr(p
, '\n');
1585 char *eol
= strchr(logline
, '\n');
1590 if (eol
[-1] == '\r')
1592 http_log("%.*s\n", (int) (eol
- logline
), logline
);
1593 c
->suppress_log
= 1;
1598 http_log("\nGot request:\n%s\n", c
->buffer
);
1601 if (client_id
&& extract_rates(ratebuf
, sizeof(ratebuf
), c
->buffer
)) {
1604 /* Now we have to find the client_id */
1605 for (wmpc
= first_http_ctx
; wmpc
; wmpc
= wmpc
->next
) {
1606 if (wmpc
->wmp_client_id
== client_id
)
1610 if (wmpc
&& modify_current_stream(wmpc
, ratebuf
))
1611 wmpc
->switch_pending
= 1;
1614 snprintf(msg
, sizeof(msg
), "POST command not handled");
1618 if (http_start_receive_data(c
) < 0) {
1619 snprintf(msg
, sizeof(msg
), "could not open feed");
1623 c
->state
= HTTPSTATE_RECEIVE_DATA
;
1628 if (strcmp(stream
->filename
+ strlen(stream
->filename
) - 4, ".asf") == 0)
1629 http_log("\nGot request:\n%s\n", c
->buffer
);
1632 if (c
->stream
->stream_type
== STREAM_TYPE_STATUS
)
1635 /* open input stream */
1636 if (open_input_stream(c
, info
) < 0) {
1637 snprintf(msg
, sizeof(msg
), "Input stream corresponding to '%s' not found", url
);
1641 /* prepare http header */
1643 q
+= snprintf(q
, q
- (char *) c
->buffer
+ c
->buffer_size
, "HTTP/1.0 200 OK\r\n");
1644 mime_type
= c
->stream
->fmt
->mime_type
;
1646 mime_type
= "application/x-octet-stream";
1647 q
+= snprintf(q
, q
- (char *) c
->buffer
+ c
->buffer_size
, "Pragma: no-cache\r\n");
1649 /* for asf, we need extra headers */
1650 if (!strcmp(c
->stream
->fmt
->name
,"asf_stream")) {
1651 /* Need to allocate a client id */
1653 c
->wmp_client_id
= av_lfg_get(&random_state
);
1655 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
);
1657 q
+= snprintf(q
, q
- (char *) c
->buffer
+ c
->buffer_size
, "Content-Type: %s\r\n", mime_type
);
1658 q
+= snprintf(q
, q
- (char *) c
->buffer
+ c
->buffer_size
, "\r\n");
1660 /* prepare output buffer */
1662 c
->buffer_ptr
= c
->buffer
;
1664 c
->state
= HTTPSTATE_SEND_HEADER
;
1667 c
->http_error
= 404;
1669 q
+= snprintf(q
, c
->buffer_size
,
1670 "HTTP/1.0 404 Not Found\r\n"
1671 "Content-type: text/html\r\n"
1674 "<head><title>404 Not Found</title></head>\n"
1677 /* prepare output buffer */
1678 c
->buffer_ptr
= c
->buffer
;
1680 c
->state
= HTTPSTATE_SEND_HEADER
;
1684 c
->http_error
= 200; /* horrible : we use this value to avoid
1685 going to the send data state */
1686 c
->state
= HTTPSTATE_SEND_HEADER
;
1690 static void fmt_bytecount(ByteIOContext
*pb
, int64_t count
)
1692 static const char *suffix
= " kMGTP";
1695 for (s
= suffix
; count
>= 100000 && s
[1]; count
/= 1000, s
++);
1697 url_fprintf(pb
, "%"PRId64
"%c", count
, *s
);
1700 static void compute_status(HTTPContext
*c
)
1709 if (url_open_dyn_buf(&pb
) < 0) {
1710 /* XXX: return an error ? */
1711 c
->buffer_ptr
= c
->buffer
;
1712 c
->buffer_end
= c
->buffer
;
1716 url_fprintf(pb
, "HTTP/1.0 200 OK\r\n");
1717 url_fprintf(pb
, "Content-type: %s\r\n", "text/html");
1718 url_fprintf(pb
, "Pragma: no-cache\r\n");
1719 url_fprintf(pb
, "\r\n");
1721 url_fprintf(pb
, "<html><head><title>%s Status</title>\n", program_name
);
1722 if (c
->stream
->feed_filename
[0])
1723 url_fprintf(pb
, "<link rel=\"shortcut icon\" href=\"%s\">\n", c
->stream
->feed_filename
);
1724 url_fprintf(pb
, "</head>\n<body>");
1725 url_fprintf(pb
, "<h1>%s Status</h1>\n", program_name
);
1727 url_fprintf(pb
, "<h2>Available Streams</h2>\n");
1728 url_fprintf(pb
, "<table cellspacing=0 cellpadding=4>\n");
1729 url_fprintf(pb
, "<tr><th valign=top>Path<th align=left>Served<br>Conns<th><br>bytes<th valign=top>Format<th>Bit rate<br>kbits/s<th align=left>Video<br>kbits/s<th><br>Codec<th align=left>Audio<br>kbits/s<th><br>Codec<th align=left valign=top>Feed\n");
1730 stream
= first_stream
;
1731 while (stream
!= NULL
) {
1732 char sfilename
[1024];
1735 if (stream
->feed
!= stream
) {
1736 av_strlcpy(sfilename
, stream
->filename
, sizeof(sfilename
) - 10);
1737 eosf
= sfilename
+ strlen(sfilename
);
1738 if (eosf
- sfilename
>= 4) {
1739 if (strcmp(eosf
- 4, ".asf") == 0)
1740 strcpy(eosf
- 4, ".asx");
1741 else if (strcmp(eosf
- 3, ".rm") == 0)
1742 strcpy(eosf
- 3, ".ram");
1743 else if (stream
->fmt
&& !strcmp(stream
->fmt
->name
, "rtp")) {
1744 /* generate a sample RTSP director if
1745 unicast. Generate an SDP redirector if
1747 eosf
= strrchr(sfilename
, '.');
1749 eosf
= sfilename
+ strlen(sfilename
);
1750 if (stream
->is_multicast
)
1751 strcpy(eosf
, ".sdp");
1753 strcpy(eosf
, ".rtsp");
1757 url_fprintf(pb
, "<tr><td><a href=\"/%s\">%s</a> ",
1758 sfilename
, stream
->filename
);
1759 url_fprintf(pb
, "<td align=right> %d <td align=right> ",
1760 stream
->conns_served
);
1761 fmt_bytecount(pb
, stream
->bytes_served
);
1762 switch(stream
->stream_type
) {
1763 case STREAM_TYPE_LIVE
: {
1764 int audio_bit_rate
= 0;
1765 int video_bit_rate
= 0;
1766 const char *audio_codec_name
= "";
1767 const char *video_codec_name
= "";
1768 const char *audio_codec_name_extra
= "";
1769 const char *video_codec_name_extra
= "";
1771 for(i
=0;i
<stream
->nb_streams
;i
++) {
1772 AVStream
*st
= stream
->streams
[i
];
1773 AVCodec
*codec
= avcodec_find_encoder(st
->codec
->codec_id
);
1774 switch(st
->codec
->codec_type
) {
1775 case CODEC_TYPE_AUDIO
:
1776 audio_bit_rate
+= st
->codec
->bit_rate
;
1778 if (*audio_codec_name
)
1779 audio_codec_name_extra
= "...";
1780 audio_codec_name
= codec
->name
;
1783 case CODEC_TYPE_VIDEO
:
1784 video_bit_rate
+= st
->codec
->bit_rate
;
1786 if (*video_codec_name
)
1787 video_codec_name_extra
= "...";
1788 video_codec_name
= codec
->name
;
1791 case CODEC_TYPE_DATA
:
1792 video_bit_rate
+= st
->codec
->bit_rate
;
1798 url_fprintf(pb
, "<td align=center> %s <td align=right> %d <td align=right> %d <td> %s %s <td align=right> %d <td> %s %s",
1801 video_bit_rate
/ 1000, video_codec_name
, video_codec_name_extra
,
1802 audio_bit_rate
/ 1000, audio_codec_name
, audio_codec_name_extra
);
1804 url_fprintf(pb
, "<td>%s", stream
->feed
->filename
);
1806 url_fprintf(pb
, "<td>%s", stream
->feed_filename
);
1807 url_fprintf(pb
, "\n");
1811 url_fprintf(pb
, "<td align=center> - <td align=right> - <td align=right> - <td><td align=right> - <td>\n");
1815 stream
= stream
->next
;
1817 url_fprintf(pb
, "</table>\n");
1819 stream
= first_stream
;
1820 while (stream
!= NULL
) {
1821 if (stream
->feed
== stream
) {
1822 url_fprintf(pb
, "<h2>Feed %s</h2>", stream
->filename
);
1824 url_fprintf(pb
, "Running as pid %d.\n", stream
->pid
);
1826 #if defined(linux) && !defined(CONFIG_NOCUTILS)
1831 /* This is somewhat linux specific I guess */
1832 snprintf(ps_cmd
, sizeof(ps_cmd
),
1833 "ps -o \"%%cpu,cputime\" --no-headers %d",
1836 pid_stat
= popen(ps_cmd
, "r");
1841 if (fscanf(pid_stat
, "%10s %64s", cpuperc
,
1843 url_fprintf(pb
, "Currently using %s%% of the cpu. Total time used %s.\n",
1851 url_fprintf(pb
, "<p>");
1853 url_fprintf(pb
, "<table cellspacing=0 cellpadding=4><tr><th>Stream<th>type<th>kbits/s<th align=left>codec<th align=left>Parameters\n");
1855 for (i
= 0; i
< stream
->nb_streams
; i
++) {
1856 AVStream
*st
= stream
->streams
[i
];
1857 AVCodec
*codec
= avcodec_find_encoder(st
->codec
->codec_id
);
1858 const char *type
= "unknown";
1859 char parameters
[64];
1863 switch(st
->codec
->codec_type
) {
1864 case CODEC_TYPE_AUDIO
:
1866 snprintf(parameters
, sizeof(parameters
), "%d channel(s), %d Hz", st
->codec
->channels
, st
->codec
->sample_rate
);
1868 case CODEC_TYPE_VIDEO
:
1870 snprintf(parameters
, sizeof(parameters
), "%dx%d, q=%d-%d, fps=%d", st
->codec
->width
, st
->codec
->height
,
1871 st
->codec
->qmin
, st
->codec
->qmax
, st
->codec
->time_base
.den
/ st
->codec
->time_base
.num
);
1876 url_fprintf(pb
, "<tr><td align=right>%d<td>%s<td align=right>%d<td>%s<td>%s\n",
1877 i
, type
, st
->codec
->bit_rate
/1000, codec
? codec
->name
: "", parameters
);
1879 url_fprintf(pb
, "</table>\n");
1882 stream
= stream
->next
;
1888 AVCodecContext
*enc
;
1892 stream
= first_feed
;
1893 while (stream
!= NULL
) {
1894 url_fprintf(pb
, "<h1>Feed '%s'</h1>\n", stream
->filename
);
1895 url_fprintf(pb
, "<table>\n");
1896 url_fprintf(pb
, "<tr><td>Parameters<td>Frame count<td>Size<td>Avg bitrate (kbits/s)\n");
1897 for(i
=0;i
<stream
->nb_streams
;i
++) {
1898 AVStream
*st
= stream
->streams
[i
];
1899 FeedData
*fdata
= st
->priv_data
;
1902 avcodec_string(buf
, sizeof(buf
), enc
);
1903 avg
= fdata
->avg_frame_size
* (float)enc
->rate
* 8.0;
1904 if (enc
->codec
->type
== CODEC_TYPE_AUDIO
&& enc
->frame_size
> 0)
1905 avg
/= enc
->frame_size
;
1906 url_fprintf(pb
, "<tr><td>%s <td> %d <td> %"PRId64
" <td> %0.1f\n",
1907 buf
, enc
->frame_number
, fdata
->data_count
, avg
/ 1000.0);
1909 url_fprintf(pb
, "</table>\n");
1910 stream
= stream
->next_feed
;
1915 /* connection status */
1916 url_fprintf(pb
, "<h2>Connection Status</h2>\n");
1918 url_fprintf(pb
, "Number of connections: %d / %d<br>\n",
1919 nb_connections
, nb_max_connections
);
1921 url_fprintf(pb
, "Bandwidth in use: %"PRIu64
"k / %"PRIu64
"k<br>\n",
1922 current_bandwidth
, max_bandwidth
);
1924 url_fprintf(pb
, "<table>\n");
1925 url_fprintf(pb
, "<tr><th>#<th>File<th>IP<th>Proto<th>State<th>Target bits/sec<th>Actual bits/sec<th>Bytes transferred\n");
1926 c1
= first_http_ctx
;
1928 while (c1
!= NULL
) {
1934 for (j
= 0; j
< c1
->stream
->nb_streams
; j
++) {
1935 if (!c1
->stream
->feed
)
1936 bitrate
+= c1
->stream
->streams
[j
]->codec
->bit_rate
;
1937 else if (c1
->feed_streams
[j
] >= 0)
1938 bitrate
+= c1
->stream
->feed
->streams
[c1
->feed_streams
[j
]]->codec
->bit_rate
;
1943 p
= inet_ntoa(c1
->from_addr
.sin_addr
);
1944 url_fprintf(pb
, "<tr><td><b>%d</b><td>%s%s<td>%s<td>%s<td>%s<td align=right>",
1946 c1
->stream
? c1
->stream
->filename
: "",
1947 c1
->state
== HTTPSTATE_RECEIVE_DATA
? "(input)" : "",
1950 http_state
[c1
->state
]);
1951 fmt_bytecount(pb
, bitrate
);
1952 url_fprintf(pb
, "<td align=right>");
1953 fmt_bytecount(pb
, compute_datarate(&c1
->datarate
, c1
->data_count
) * 8);
1954 url_fprintf(pb
, "<td align=right>");
1955 fmt_bytecount(pb
, c1
->data_count
);
1956 url_fprintf(pb
, "\n");
1959 url_fprintf(pb
, "</table>\n");
1964 url_fprintf(pb
, "<hr size=1 noshade>Generated at %s", p
);
1965 url_fprintf(pb
, "</body>\n</html>\n");
1967 len
= url_close_dyn_buf(pb
, &c
->pb_buffer
);
1968 c
->buffer_ptr
= c
->pb_buffer
;
1969 c
->buffer_end
= c
->pb_buffer
+ len
;
1972 /* check if the parser needs to be opened for stream i */
1973 static void open_parser(AVFormatContext
*s
, int i
)
1975 AVStream
*st
= s
->streams
[i
];
1978 if (!st
->codec
->codec
) {
1979 codec
= avcodec_find_decoder(st
->codec
->codec_id
);
1980 if (codec
&& (codec
->capabilities
& CODEC_CAP_PARSE_ONLY
)) {
1981 st
->codec
->parse_only
= 1;
1982 if (avcodec_open(st
->codec
, codec
) < 0)
1983 st
->codec
->parse_only
= 0;
1988 static int open_input_stream(HTTPContext
*c
, const char *info
)
1991 char input_filename
[1024];
1993 int buf_size
, i
, ret
;
1996 /* find file name */
1997 if (c
->stream
->feed
) {
1998 strcpy(input_filename
, c
->stream
->feed
->feed_filename
);
1999 buf_size
= FFM_PACKET_SIZE
;
2000 /* compute position (absolute time) */
2001 if (find_info_tag(buf
, sizeof(buf
), "date", info
)) {
2002 stream_pos
= parse_date(buf
, 0);
2003 if (stream_pos
== INT64_MIN
)
2005 } else if (find_info_tag(buf
, sizeof(buf
), "buffer", info
)) {
2006 int prebuffer
= strtol(buf
, 0, 10);
2007 stream_pos
= av_gettime() - prebuffer
* (int64_t)1000000;
2009 stream_pos
= av_gettime() - c
->stream
->prebuffer
* (int64_t)1000;
2011 strcpy(input_filename
, c
->stream
->feed_filename
);
2013 /* compute position (relative time) */
2014 if (find_info_tag(buf
, sizeof(buf
), "date", info
)) {
2015 stream_pos
= parse_date(buf
, 1);
2016 if (stream_pos
== INT64_MIN
)
2021 if (input_filename
[0] == '\0')
2025 { time_t when
= stream_pos
/ 1000000;
2026 http_log("Stream pos = %"PRId64
", time=%s", stream_pos
, ctime(&when
));
2031 if ((ret
= av_open_input_file(&s
, input_filename
, c
->stream
->ifmt
,
2032 buf_size
, c
->stream
->ap_in
)) < 0) {
2033 http_log("could not open %s: %d\n", input_filename
, ret
);
2036 s
->flags
|= AVFMT_FLAG_GENPTS
;
2038 if (strcmp(s
->iformat
->name
, "ffm") && av_find_stream_info(c
->fmt_in
) < 0) {
2039 http_log("Could not find stream info '%s'\n", input_filename
);
2040 av_close_input_file(s
);
2044 /* open each parser */
2045 for(i
=0;i
<s
->nb_streams
;i
++)
2048 /* choose stream as clock source (we favorize video stream if
2049 present) for packet sending */
2050 c
->pts_stream_index
= 0;
2051 for(i
=0;i
<c
->stream
->nb_streams
;i
++) {
2052 if (c
->pts_stream_index
== 0 &&
2053 c
->stream
->streams
[i
]->codec
->codec_type
== CODEC_TYPE_VIDEO
) {
2054 c
->pts_stream_index
= i
;
2059 if (c
->fmt_in
->iformat
->read_seek
)
2060 av_seek_frame(c
->fmt_in
, -1, stream_pos
, 0);
2062 /* set the start time (needed for maxtime and RTP packet timing) */
2063 c
->start_time
= cur_time
;
2064 c
->first_pts
= AV_NOPTS_VALUE
;
2068 /* return the server clock (in us) */
2069 static int64_t get_server_clock(HTTPContext
*c
)
2071 /* compute current pts value from system time */
2072 return (cur_time
- c
->start_time
) * 1000;
2075 /* return the estimated time at which the current packet must be sent
2077 static int64_t get_packet_send_clock(HTTPContext
*c
)
2079 int bytes_left
, bytes_sent
, frame_bytes
;
2081 frame_bytes
= c
->cur_frame_bytes
;
2082 if (frame_bytes
<= 0)
2085 bytes_left
= c
->buffer_end
- c
->buffer_ptr
;
2086 bytes_sent
= frame_bytes
- bytes_left
;
2087 return c
->cur_pts
+ (c
->cur_frame_duration
* bytes_sent
) / frame_bytes
;
2092 static int http_prepare_data(HTTPContext
*c
)
2095 AVFormatContext
*ctx
;
2097 av_freep(&c
->pb_buffer
);
2099 case HTTPSTATE_SEND_DATA_HEADER
:
2100 memset(&c
->fmt_ctx
, 0, sizeof(c
->fmt_ctx
));
2101 av_metadata_set(&c
->fmt_ctx
.metadata
, "author" ,c
->stream
->author
);
2102 av_metadata_set(&c
->fmt_ctx
.metadata
, "comment" ,c
->stream
->comment
);
2103 av_metadata_set(&c
->fmt_ctx
.metadata
, "copyright",c
->stream
->copyright
);
2104 av_metadata_set(&c
->fmt_ctx
.metadata
, "title" ,c
->stream
->title
);
2106 for(i
=0;i
<c
->stream
->nb_streams
;i
++) {
2109 st
= av_mallocz(sizeof(AVStream
));
2110 c
->fmt_ctx
.streams
[i
] = st
;
2111 /* if file or feed, then just take streams from FFStream struct */
2112 if (!c
->stream
->feed
||
2113 c
->stream
->feed
== c
->stream
)
2114 src
= c
->stream
->streams
[i
];
2116 src
= c
->stream
->feed
->streams
[c
->stream
->feed_streams
[i
]];
2120 st
->codec
->frame_number
= 0; /* XXX: should be done in
2121 AVStream, not in codec */
2123 /* set output format parameters */
2124 c
->fmt_ctx
.oformat
= c
->stream
->fmt
;
2125 c
->fmt_ctx
.nb_streams
= c
->stream
->nb_streams
;
2127 c
->got_key_frame
= 0;
2129 /* prepare header and save header data in a stream */
2130 if (url_open_dyn_buf(&c
->fmt_ctx
.pb
) < 0) {
2131 /* XXX: potential leak */
2134 c
->fmt_ctx
.pb
->is_streamed
= 1;
2137 * HACK to avoid mpeg ps muxer to spit many underflow errors
2138 * Default value from FFmpeg
2139 * Try to set it use configuration option
2141 c
->fmt_ctx
.preload
= (int)(0.5*AV_TIME_BASE
);
2142 c
->fmt_ctx
.max_delay
= (int)(0.7*AV_TIME_BASE
);
2144 av_set_parameters(&c
->fmt_ctx
, NULL
);
2145 if (av_write_header(&c
->fmt_ctx
) < 0) {
2146 http_log("Error writing output header\n");
2150 len
= url_close_dyn_buf(c
->fmt_ctx
.pb
, &c
->pb_buffer
);
2151 c
->buffer_ptr
= c
->pb_buffer
;
2152 c
->buffer_end
= c
->pb_buffer
+ len
;
2154 c
->state
= HTTPSTATE_SEND_DATA
;
2155 c
->last_packet_sent
= 0;
2157 case HTTPSTATE_SEND_DATA
:
2158 /* find a new packet */
2159 /* read a packet from the input stream */
2160 if (c
->stream
->feed
)
2161 ffm_set_write_index(c
->fmt_in
,
2162 c
->stream
->feed
->feed_write_index
,
2163 c
->stream
->feed
->feed_size
);
2165 if (c
->stream
->max_time
&&
2166 c
->stream
->max_time
+ c
->start_time
- cur_time
< 0)
2167 /* We have timed out */
2168 c
->state
= HTTPSTATE_SEND_DATA_TRAILER
;
2172 if (av_read_frame(c
->fmt_in
, &pkt
) < 0) {
2173 if (c
->stream
->feed
&& c
->stream
->feed
->feed_opened
) {
2174 /* if coming from feed, it means we reached the end of the
2175 ffm file, so must wait for more data */
2176 c
->state
= HTTPSTATE_WAIT_FEED
;
2177 return 1; /* state changed */
2179 if (c
->stream
->loop
) {
2180 av_close_input_file(c
->fmt_in
);
2182 if (open_input_stream(c
, "") < 0)
2187 /* must send trailer now because eof or error */
2188 c
->state
= HTTPSTATE_SEND_DATA_TRAILER
;
2192 int source_index
= pkt
.stream_index
;
2193 /* update first pts if needed */
2194 if (c
->first_pts
== AV_NOPTS_VALUE
) {
2195 c
->first_pts
= av_rescale_q(pkt
.dts
, c
->fmt_in
->streams
[pkt
.stream_index
]->time_base
, AV_TIME_BASE_Q
);
2196 c
->start_time
= cur_time
;
2198 /* send it to the appropriate stream */
2199 if (c
->stream
->feed
) {
2200 /* if coming from a feed, select the right stream */
2201 if (c
->switch_pending
) {
2202 c
->switch_pending
= 0;
2203 for(i
=0;i
<c
->stream
->nb_streams
;i
++) {
2204 if (c
->switch_feed_streams
[i
] == pkt
.stream_index
)
2205 if (pkt
.flags
& PKT_FLAG_KEY
)
2206 do_switch_stream(c
, i
);
2207 if (c
->switch_feed_streams
[i
] >= 0)
2208 c
->switch_pending
= 1;
2211 for(i
=0;i
<c
->stream
->nb_streams
;i
++) {
2212 if (c
->feed_streams
[i
] == pkt
.stream_index
) {
2213 AVStream
*st
= c
->fmt_in
->streams
[source_index
];
2214 pkt
.stream_index
= i
;
2215 if (pkt
.flags
& PKT_FLAG_KEY
&&
2216 (st
->codec
->codec_type
== CODEC_TYPE_VIDEO
||
2217 c
->stream
->nb_streams
== 1))
2218 c
->got_key_frame
= 1;
2219 if (!c
->stream
->send_on_key
|| c
->got_key_frame
)
2224 AVCodecContext
*codec
;
2225 AVStream
*ist
, *ost
;
2227 ist
= c
->fmt_in
->streams
[source_index
];
2228 /* specific handling for RTP: we use several
2229 output stream (one for each RTP
2230 connection). XXX: need more abstract handling */
2231 if (c
->is_packetized
) {
2232 /* compute send time and duration */
2233 c
->cur_pts
= av_rescale_q(pkt
.dts
, ist
->time_base
, AV_TIME_BASE_Q
);
2234 if (ist
->start_time
!= AV_NOPTS_VALUE
)
2235 c
->cur_pts
-= av_rescale_q(ist
->start_time
, ist
->time_base
, AV_TIME_BASE_Q
);
2236 c
->cur_frame_duration
= av_rescale_q(pkt
.duration
, ist
->time_base
, AV_TIME_BASE_Q
);
2238 printf("index=%d pts=%0.3f duration=%0.6f\n",
2240 (double)c
->cur_pts
/
2242 (double)c
->cur_frame_duration
/
2245 /* find RTP context */
2246 c
->packet_stream_index
= pkt
.stream_index
;
2247 ctx
= c
->rtp_ctx
[c
->packet_stream_index
];
2249 av_free_packet(&pkt
);
2252 codec
= ctx
->streams
[0]->codec
;
2253 /* only one stream per RTP connection */
2254 pkt
.stream_index
= 0;
2258 codec
= ctx
->streams
[pkt
.stream_index
]->codec
;
2261 if (c
->is_packetized
) {
2262 int max_packet_size
;
2263 if (c
->rtp_protocol
== RTSP_LOWER_TRANSPORT_TCP
)
2264 max_packet_size
= RTSP_TCP_MAX_PACKET_SIZE
;
2266 max_packet_size
= url_get_max_packet_size(c
->rtp_handles
[c
->packet_stream_index
]);
2267 ret
= url_open_dyn_packet_buf(&ctx
->pb
, max_packet_size
);
2269 ret
= url_open_dyn_buf(&ctx
->pb
);
2272 /* XXX: potential leak */
2275 ost
= ctx
->streams
[pkt
.stream_index
];
2277 ctx
->pb
->is_streamed
= 1;
2278 if (pkt
.dts
!= AV_NOPTS_VALUE
)
2279 pkt
.dts
= av_rescale_q(pkt
.dts
, ist
->time_base
, ost
->time_base
);
2280 if (pkt
.pts
!= AV_NOPTS_VALUE
)
2281 pkt
.pts
= av_rescale_q(pkt
.pts
, ist
->time_base
, ost
->time_base
);
2282 pkt
.duration
= av_rescale_q(pkt
.duration
, ist
->time_base
, ost
->time_base
);
2283 if (av_write_frame(ctx
, &pkt
) < 0) {
2284 http_log("Error writing frame to output\n");
2285 c
->state
= HTTPSTATE_SEND_DATA_TRAILER
;
2288 len
= url_close_dyn_buf(ctx
->pb
, &c
->pb_buffer
);
2289 c
->cur_frame_bytes
= len
;
2290 c
->buffer_ptr
= c
->pb_buffer
;
2291 c
->buffer_end
= c
->pb_buffer
+ len
;
2293 codec
->frame_number
++;
2295 av_free_packet(&pkt
);
2299 av_free_packet(&pkt
);
2304 case HTTPSTATE_SEND_DATA_TRAILER
:
2305 /* last packet test ? */
2306 if (c
->last_packet_sent
|| c
->is_packetized
)
2309 /* prepare header */
2310 if (url_open_dyn_buf(&ctx
->pb
) < 0) {
2311 /* XXX: potential leak */
2314 c
->fmt_ctx
.pb
->is_streamed
= 1;
2315 av_write_trailer(ctx
);
2316 len
= url_close_dyn_buf(ctx
->pb
, &c
->pb_buffer
);
2317 c
->buffer_ptr
= c
->pb_buffer
;
2318 c
->buffer_end
= c
->pb_buffer
+ len
;
2320 c
->last_packet_sent
= 1;
2326 /* should convert the format at the same time */
2327 /* send data starting at c->buffer_ptr to the output connection
2328 (either UDP or TCP connection) */
2329 static int http_send_data(HTTPContext
*c
)
2334 if (c
->buffer_ptr
>= c
->buffer_end
) {
2335 ret
= http_prepare_data(c
);
2339 /* state change requested */
2342 if (c
->is_packetized
) {
2343 /* RTP data output */
2344 len
= c
->buffer_end
- c
->buffer_ptr
;
2346 /* fail safe - should never happen */
2348 c
->buffer_ptr
= c
->buffer_end
;
2351 len
= (c
->buffer_ptr
[0] << 24) |
2352 (c
->buffer_ptr
[1] << 16) |
2353 (c
->buffer_ptr
[2] << 8) |
2355 if (len
> (c
->buffer_end
- c
->buffer_ptr
))
2357 if ((get_packet_send_clock(c
) - get_server_clock(c
)) > 0) {
2358 /* nothing to send yet: we can wait */
2362 c
->data_count
+= len
;
2363 update_datarate(&c
->datarate
, c
->data_count
);
2365 c
->stream
->bytes_served
+= len
;
2367 if (c
->rtp_protocol
== RTSP_LOWER_TRANSPORT_TCP
) {
2368 /* RTP packets are sent inside the RTSP TCP connection */
2370 int interleaved_index
, size
;
2372 HTTPContext
*rtsp_c
;
2375 /* if no RTSP connection left, error */
2378 /* if already sending something, then wait. */
2379 if (rtsp_c
->state
!= RTSPSTATE_WAIT_REQUEST
)
2381 if (url_open_dyn_buf(&pb
) < 0)
2383 interleaved_index
= c
->packet_stream_index
* 2;
2384 /* RTCP packets are sent at odd indexes */
2385 if (c
->buffer_ptr
[1] == 200)
2386 interleaved_index
++;
2387 /* write RTSP TCP header */
2389 header
[1] = interleaved_index
;
2390 header
[2] = len
>> 8;
2392 put_buffer(pb
, header
, 4);
2393 /* write RTP packet data */
2395 put_buffer(pb
, c
->buffer_ptr
, len
);
2396 size
= url_close_dyn_buf(pb
, &c
->packet_buffer
);
2397 /* prepare asynchronous TCP sending */
2398 rtsp_c
->packet_buffer_ptr
= c
->packet_buffer
;
2399 rtsp_c
->packet_buffer_end
= c
->packet_buffer
+ size
;
2400 c
->buffer_ptr
+= len
;
2402 /* send everything we can NOW */
2403 len
= send(rtsp_c
->fd
, rtsp_c
->packet_buffer_ptr
,
2404 rtsp_c
->packet_buffer_end
- rtsp_c
->packet_buffer_ptr
, 0);
2406 rtsp_c
->packet_buffer_ptr
+= len
;
2407 if (rtsp_c
->packet_buffer_ptr
< rtsp_c
->packet_buffer_end
) {
2408 /* if we could not send all the data, we will
2409 send it later, so a new state is needed to
2410 "lock" the RTSP TCP connection */
2411 rtsp_c
->state
= RTSPSTATE_SEND_PACKET
;
2414 /* all data has been sent */
2415 av_freep(&c
->packet_buffer
);
2417 /* send RTP packet directly in UDP */
2419 url_write(c
->rtp_handles
[c
->packet_stream_index
],
2420 c
->buffer_ptr
, len
);
2421 c
->buffer_ptr
+= len
;
2422 /* here we continue as we can send several packets per 10 ms slot */
2425 /* TCP data output */
2426 len
= send(c
->fd
, c
->buffer_ptr
, c
->buffer_end
- c
->buffer_ptr
, 0);
2428 if (ff_neterrno() != FF_NETERROR(EAGAIN
) &&
2429 ff_neterrno() != FF_NETERROR(EINTR
))
2430 /* error : close connection */
2435 c
->buffer_ptr
+= len
;
2437 c
->data_count
+= len
;
2438 update_datarate(&c
->datarate
, c
->data_count
);
2440 c
->stream
->bytes_served
+= len
;
2448 static int http_start_receive_data(HTTPContext
*c
)
2452 if (c
->stream
->feed_opened
)
2455 /* Don't permit writing to this one */
2456 if (c
->stream
->readonly
)
2460 fd
= open(c
->stream
->feed_filename
, O_RDWR
);
2462 http_log("Error opening feeder file: %s\n", strerror(errno
));
2467 if (c
->stream
->truncate
) {
2468 /* truncate feed file */
2469 ffm_write_write_index(c
->feed_fd
, FFM_PACKET_SIZE
);
2470 ftruncate(c
->feed_fd
, FFM_PACKET_SIZE
);
2471 http_log("Truncating feed file '%s'\n", c
->stream
->feed_filename
);
2473 if ((c
->stream
->feed_write_index
= ffm_read_write_index(fd
)) < 0) {
2474 http_log("Error reading write index from feed file: %s\n", strerror(errno
));
2479 c
->stream
->feed_write_index
= FFMAX(ffm_read_write_index(fd
), FFM_PACKET_SIZE
);
2480 c
->stream
->feed_size
= lseek(fd
, 0, SEEK_END
);
2481 lseek(fd
, 0, SEEK_SET
);
2483 /* init buffer input */
2484 c
->buffer_ptr
= c
->buffer
;
2485 c
->buffer_end
= c
->buffer
+ FFM_PACKET_SIZE
;
2486 c
->stream
->feed_opened
= 1;
2490 static int http_receive_data(HTTPContext
*c
)
2494 if (c
->buffer_end
> c
->buffer_ptr
) {
2497 len
= recv(c
->fd
, c
->buffer_ptr
, c
->buffer_end
- c
->buffer_ptr
, 0);
2499 if (ff_neterrno() != FF_NETERROR(EAGAIN
) &&
2500 ff_neterrno() != FF_NETERROR(EINTR
))
2501 /* error : close connection */
2503 } else if (len
== 0)
2504 /* end of connection : close it */
2507 c
->buffer_ptr
+= len
;
2508 c
->data_count
+= len
;
2509 update_datarate(&c
->datarate
, c
->data_count
);
2513 if (c
->buffer_ptr
- c
->buffer
>= 2 && c
->data_count
> FFM_PACKET_SIZE
) {
2514 if (c
->buffer
[0] != 'f' ||
2515 c
->buffer
[1] != 'm') {
2516 http_log("Feed stream has become desynchronized -- disconnecting\n");
2521 if (c
->buffer_ptr
>= c
->buffer_end
) {
2522 FFStream
*feed
= c
->stream
;
2523 /* a packet has been received : write it in the store, except
2525 if (c
->data_count
> FFM_PACKET_SIZE
) {
2527 // printf("writing pos=0x%"PRIx64" size=0x%"PRIx64"\n", feed->feed_write_index, feed->feed_size);
2528 /* XXX: use llseek or url_seek */
2529 lseek(c
->feed_fd
, feed
->feed_write_index
, SEEK_SET
);
2530 if (write(c
->feed_fd
, c
->buffer
, FFM_PACKET_SIZE
) < 0) {
2531 http_log("Error writing to feed file: %s\n", strerror(errno
));
2535 feed
->feed_write_index
+= FFM_PACKET_SIZE
;
2536 /* update file size */
2537 if (feed
->feed_write_index
> c
->stream
->feed_size
)
2538 feed
->feed_size
= feed
->feed_write_index
;
2540 /* handle wrap around if max file size reached */
2541 if (c
->stream
->feed_max_size
&& feed
->feed_write_index
>= c
->stream
->feed_max_size
)
2542 feed
->feed_write_index
= FFM_PACKET_SIZE
;
2545 if (ffm_write_write_index(c
->feed_fd
, feed
->feed_write_index
) < 0) {
2546 http_log("Error writing index to feed file: %s\n", strerror(errno
));
2550 /* wake up any waiting connections */
2551 for(c1
= first_http_ctx
; c1
!= NULL
; c1
= c1
->next
) {
2552 if (c1
->state
== HTTPSTATE_WAIT_FEED
&&
2553 c1
->stream
->feed
== c
->stream
->feed
)
2554 c1
->state
= HTTPSTATE_SEND_DATA
;
2557 /* We have a header in our hands that contains useful data */
2558 AVFormatContext
*s
= NULL
;
2560 AVInputFormat
*fmt_in
;
2563 /* use feed output format name to find corresponding input format */
2564 fmt_in
= av_find_input_format(feed
->fmt
->name
);
2568 url_open_buf(&pb
, c
->buffer
, c
->buffer_end
- c
->buffer
, URL_RDONLY
);
2569 pb
->is_streamed
= 1;
2571 if (av_open_input_stream(&s
, pb
, c
->stream
->feed_filename
, fmt_in
, NULL
) < 0) {
2576 /* Now we have the actual streams */
2577 if (s
->nb_streams
!= feed
->nb_streams
) {
2578 av_close_input_stream(s
);
2580 http_log("Feed '%s' stream number does not match registered feed\n",
2581 c
->stream
->feed_filename
);
2585 for (i
= 0; i
< s
->nb_streams
; i
++) {
2586 AVStream
*fst
= feed
->streams
[i
];
2587 AVStream
*st
= s
->streams
[i
];
2588 memcpy(fst
->codec
, st
->codec
, sizeof(AVCodecContext
));
2589 if (fst
->codec
->extradata_size
) {
2590 fst
->codec
->extradata
= av_malloc(fst
->codec
->extradata_size
);
2591 if (!fst
->codec
->extradata
)
2593 memcpy(fst
->codec
->extradata
, st
->codec
->extradata
,
2594 fst
->codec
->extradata_size
);
2598 av_close_input_stream(s
);
2601 c
->buffer_ptr
= c
->buffer
;
2606 c
->stream
->feed_opened
= 0;
2608 /* wake up any waiting connections to stop waiting for feed */
2609 for(c1
= first_http_ctx
; c1
!= NULL
; c1
= c1
->next
) {
2610 if (c1
->state
== HTTPSTATE_WAIT_FEED
&&
2611 c1
->stream
->feed
== c
->stream
->feed
)
2612 c1
->state
= HTTPSTATE_SEND_DATA_TRAILER
;
2617 /********************************************************************/
2620 static void rtsp_reply_header(HTTPContext
*c
, enum RTSPStatusCode error_number
)
2627 switch(error_number
) {
2628 case RTSP_STATUS_OK
:
2631 case RTSP_STATUS_METHOD
:
2632 str
= "Method Not Allowed";
2634 case RTSP_STATUS_BANDWIDTH
:
2635 str
= "Not Enough Bandwidth";
2637 case RTSP_STATUS_SESSION
:
2638 str
= "Session Not Found";
2640 case RTSP_STATUS_STATE
:
2641 str
= "Method Not Valid in This State";
2643 case RTSP_STATUS_AGGREGATE
:
2644 str
= "Aggregate operation not allowed";
2646 case RTSP_STATUS_ONLY_AGGREGATE
:
2647 str
= "Only aggregate operation allowed";
2649 case RTSP_STATUS_TRANSPORT
:
2650 str
= "Unsupported transport";
2652 case RTSP_STATUS_INTERNAL
:
2653 str
= "Internal Server Error";
2655 case RTSP_STATUS_SERVICE
:
2656 str
= "Service Unavailable";
2658 case RTSP_STATUS_VERSION
:
2659 str
= "RTSP Version not supported";
2662 str
= "Unknown Error";
2666 url_fprintf(c
->pb
, "RTSP/1.0 %d %s\r\n", error_number
, str
);
2667 url_fprintf(c
->pb
, "CSeq: %d\r\n", c
->seq
);
2669 /* output GMT time */
2673 p
= buf2
+ strlen(p
) - 1;
2676 url_fprintf(c
->pb
, "Date: %s GMT\r\n", buf2
);
2679 static void rtsp_reply_error(HTTPContext
*c
, enum RTSPStatusCode error_number
)
2681 rtsp_reply_header(c
, error_number
);
2682 url_fprintf(c
->pb
, "\r\n");
2685 static int rtsp_parse_request(HTTPContext
*c
)
2687 const char *p
, *p1
, *p2
;
2693 RTSPMessageHeader header1
, *header
= &header1
;
2695 c
->buffer_ptr
[0] = '\0';
2698 get_word(cmd
, sizeof(cmd
), &p
);
2699 get_word(url
, sizeof(url
), &p
);
2700 get_word(protocol
, sizeof(protocol
), &p
);
2702 av_strlcpy(c
->method
, cmd
, sizeof(c
->method
));
2703 av_strlcpy(c
->url
, url
, sizeof(c
->url
));
2704 av_strlcpy(c
->protocol
, protocol
, sizeof(c
->protocol
));
2706 if (url_open_dyn_buf(&c
->pb
) < 0) {
2707 /* XXX: cannot do more */
2708 c
->pb
= NULL
; /* safety */
2712 /* check version name */
2713 if (strcmp(protocol
, "RTSP/1.0") != 0) {
2714 rtsp_reply_error(c
, RTSP_STATUS_VERSION
);
2718 /* parse each header line */
2719 memset(header
, 0, sizeof(*header
));
2720 /* skip to next line */
2721 while (*p
!= '\n' && *p
!= '\0')
2725 while (*p
!= '\0') {
2726 p1
= strchr(p
, '\n');
2730 if (p2
> p
&& p2
[-1] == '\r')
2732 /* skip empty line */
2736 if (len
> sizeof(line
) - 1)
2737 len
= sizeof(line
) - 1;
2738 memcpy(line
, p
, len
);
2740 rtsp_parse_line(header
, line
);
2744 /* handle sequence number */
2745 c
->seq
= header
->seq
;
2747 if (!strcmp(cmd
, "DESCRIBE"))
2748 rtsp_cmd_describe(c
, url
);
2749 else if (!strcmp(cmd
, "OPTIONS"))
2750 rtsp_cmd_options(c
, url
);
2751 else if (!strcmp(cmd
, "SETUP"))
2752 rtsp_cmd_setup(c
, url
, header
);
2753 else if (!strcmp(cmd
, "PLAY"))
2754 rtsp_cmd_play(c
, url
, header
);
2755 else if (!strcmp(cmd
, "PAUSE"))
2756 rtsp_cmd_pause(c
, url
, header
);
2757 else if (!strcmp(cmd
, "TEARDOWN"))
2758 rtsp_cmd_teardown(c
, url
, header
);
2760 rtsp_reply_error(c
, RTSP_STATUS_METHOD
);
2763 len
= url_close_dyn_buf(c
->pb
, &c
->pb_buffer
);
2764 c
->pb
= NULL
; /* safety */
2766 /* XXX: cannot do more */
2769 c
->buffer_ptr
= c
->pb_buffer
;
2770 c
->buffer_end
= c
->pb_buffer
+ len
;
2771 c
->state
= RTSPSTATE_SEND_REPLY
;
2775 static int prepare_sdp_description(FFStream
*stream
, uint8_t **pbuffer
,
2776 struct in_addr my_ip
)
2778 AVFormatContext
*avc
;
2779 AVStream avs
[MAX_STREAMS
];
2782 avc
= avformat_alloc_context();
2786 av_metadata_set(&avc
->metadata
, "title",
2787 stream
->title
[0] ? stream
->title
: "No Title");
2788 avc
->nb_streams
= stream
->nb_streams
;
2789 if (stream
->is_multicast
) {
2790 snprintf(avc
->filename
, 1024, "rtp://%s:%d?multicast=1?ttl=%d",
2791 inet_ntoa(stream
->multicast_ip
),
2792 stream
->multicast_port
, stream
->multicast_ttl
);
2795 for(i
= 0; i
< stream
->nb_streams
; i
++) {
2796 avc
->streams
[i
] = &avs
[i
];
2797 avc
->streams
[i
]->codec
= stream
->streams
[i
]->codec
;
2799 *pbuffer
= av_mallocz(2048);
2800 avf_sdp_create(&avc
, 1, *pbuffer
, 2048);
2803 return strlen(*pbuffer
);
2806 static void rtsp_cmd_options(HTTPContext
*c
, const char *url
)
2808 // rtsp_reply_header(c, RTSP_STATUS_OK);
2809 url_fprintf(c
->pb
, "RTSP/1.0 %d %s\r\n", RTSP_STATUS_OK
, "OK");
2810 url_fprintf(c
->pb
, "CSeq: %d\r\n", c
->seq
);
2811 url_fprintf(c
->pb
, "Public: %s\r\n", "OPTIONS, DESCRIBE, SETUP, TEARDOWN, PLAY, PAUSE");
2812 url_fprintf(c
->pb
, "\r\n");
2815 static void rtsp_cmd_describe(HTTPContext
*c
, const char *url
)
2821 int content_length
, len
;
2822 struct sockaddr_in my_addr
;
2824 /* find which url is asked */
2825 url_split(NULL
, 0, NULL
, 0, NULL
, 0, NULL
, path1
, sizeof(path1
), url
);
2830 for(stream
= first_stream
; stream
!= NULL
; stream
= stream
->next
) {
2831 if (!stream
->is_feed
&&
2832 stream
->fmt
&& !strcmp(stream
->fmt
->name
, "rtp") &&
2833 !strcmp(path
, stream
->filename
)) {
2837 /* no stream found */
2838 rtsp_reply_error(c
, RTSP_STATUS_SERVICE
); /* XXX: right error ? */
2842 /* prepare the media description in sdp format */
2844 /* get the host IP */
2845 len
= sizeof(my_addr
);
2846 getsockname(c
->fd
, (struct sockaddr
*)&my_addr
, &len
);
2847 content_length
= prepare_sdp_description(stream
, &content
, my_addr
.sin_addr
);
2848 if (content_length
< 0) {
2849 rtsp_reply_error(c
, RTSP_STATUS_INTERNAL
);
2852 rtsp_reply_header(c
, RTSP_STATUS_OK
);
2853 url_fprintf(c
->pb
, "Content-Type: application/sdp\r\n");
2854 url_fprintf(c
->pb
, "Content-Length: %d\r\n", content_length
);
2855 url_fprintf(c
->pb
, "\r\n");
2856 put_buffer(c
->pb
, content
, content_length
);
2859 static HTTPContext
*find_rtp_session(const char *session_id
)
2863 if (session_id
[0] == '\0')
2866 for(c
= first_http_ctx
; c
!= NULL
; c
= c
->next
) {
2867 if (!strcmp(c
->session_id
, session_id
))
2873 static RTSPTransportField
*find_transport(RTSPMessageHeader
*h
, enum RTSPLowerTransport lower_transport
)
2875 RTSPTransportField
*th
;
2878 for(i
=0;i
<h
->nb_transports
;i
++) {
2879 th
= &h
->transports
[i
];
2880 if (th
->lower_transport
== lower_transport
)
2886 static void rtsp_cmd_setup(HTTPContext
*c
, const char *url
,
2887 RTSPMessageHeader
*h
)
2890 int stream_index
, port
;
2895 RTSPTransportField
*th
;
2896 struct sockaddr_in dest_addr
;
2897 RTSPActionServerSetup setup
;
2899 /* find which url is asked */
2900 url_split(NULL
, 0, NULL
, 0, NULL
, 0, NULL
, path1
, sizeof(path1
), url
);
2905 /* now check each stream */
2906 for(stream
= first_stream
; stream
!= NULL
; stream
= stream
->next
) {
2907 if (!stream
->is_feed
&&
2908 stream
->fmt
&& !strcmp(stream
->fmt
->name
, "rtp")) {
2909 /* accept aggregate filenames only if single stream */
2910 if (!strcmp(path
, stream
->filename
)) {
2911 if (stream
->nb_streams
!= 1) {
2912 rtsp_reply_error(c
, RTSP_STATUS_AGGREGATE
);
2919 for(stream_index
= 0; stream_index
< stream
->nb_streams
;
2921 snprintf(buf
, sizeof(buf
), "%s/streamid=%d",
2922 stream
->filename
, stream_index
);
2923 if (!strcmp(path
, buf
))
2928 /* no stream found */
2929 rtsp_reply_error(c
, RTSP_STATUS_SERVICE
); /* XXX: right error ? */
2933 /* generate session id if needed */
2934 if (h
->session_id
[0] == '\0')
2935 snprintf(h
->session_id
, sizeof(h
->session_id
), "%08x%08x",
2936 av_lfg_get(&random_state
), av_lfg_get(&random_state
));
2938 /* find rtp session, and create it if none found */
2939 rtp_c
= find_rtp_session(h
->session_id
);
2941 /* always prefer UDP */
2942 th
= find_transport(h
, RTSP_LOWER_TRANSPORT_UDP
);
2944 th
= find_transport(h
, RTSP_LOWER_TRANSPORT_TCP
);
2946 rtsp_reply_error(c
, RTSP_STATUS_TRANSPORT
);
2951 rtp_c
= rtp_new_connection(&c
->from_addr
, stream
, h
->session_id
,
2952 th
->lower_transport
);
2954 rtsp_reply_error(c
, RTSP_STATUS_BANDWIDTH
);
2958 /* open input stream */
2959 if (open_input_stream(rtp_c
, "") < 0) {
2960 rtsp_reply_error(c
, RTSP_STATUS_INTERNAL
);
2965 /* test if stream is OK (test needed because several SETUP needs
2966 to be done for a given file) */
2967 if (rtp_c
->stream
!= stream
) {
2968 rtsp_reply_error(c
, RTSP_STATUS_SERVICE
);
2972 /* test if stream is already set up */
2973 if (rtp_c
->rtp_ctx
[stream_index
]) {
2974 rtsp_reply_error(c
, RTSP_STATUS_STATE
);
2978 /* check transport */
2979 th
= find_transport(h
, rtp_c
->rtp_protocol
);
2980 if (!th
|| (th
->lower_transport
== RTSP_LOWER_TRANSPORT_UDP
&&
2981 th
->client_port_min
<= 0)) {
2982 rtsp_reply_error(c
, RTSP_STATUS_TRANSPORT
);
2986 /* setup default options */
2987 setup
.transport_option
[0] = '\0';
2988 dest_addr
= rtp_c
->from_addr
;
2989 dest_addr
.sin_port
= htons(th
->client_port_min
);
2992 if (rtp_new_av_stream(rtp_c
, stream_index
, &dest_addr
, c
) < 0) {
2993 rtsp_reply_error(c
, RTSP_STATUS_TRANSPORT
);
2997 /* now everything is OK, so we can send the connection parameters */
2998 rtsp_reply_header(c
, RTSP_STATUS_OK
);
3000 url_fprintf(c
->pb
, "Session: %s\r\n", rtp_c
->session_id
);
3002 switch(rtp_c
->rtp_protocol
) {
3003 case RTSP_LOWER_TRANSPORT_UDP
:
3004 port
= rtp_get_local_port(rtp_c
->rtp_handles
[stream_index
]);
3005 url_fprintf(c
->pb
, "Transport: RTP/AVP/UDP;unicast;"
3006 "client_port=%d-%d;server_port=%d-%d",
3007 th
->client_port_min
, th
->client_port_min
+ 1,
3010 case RTSP_LOWER_TRANSPORT_TCP
:
3011 url_fprintf(c
->pb
, "Transport: RTP/AVP/TCP;interleaved=%d-%d",
3012 stream_index
* 2, stream_index
* 2 + 1);
3017 if (setup
.transport_option
[0] != '\0')
3018 url_fprintf(c
->pb
, ";%s", setup
.transport_option
);
3019 url_fprintf(c
->pb
, "\r\n");
3022 url_fprintf(c
->pb
, "\r\n");
3026 /* find an rtp connection by using the session ID. Check consistency
3028 static HTTPContext
*find_rtp_session_with_url(const char *url
,
3029 const char *session_id
)
3037 rtp_c
= find_rtp_session(session_id
);
3041 /* find which url is asked */
3042 url_split(NULL
, 0, NULL
, 0, NULL
, 0, NULL
, path1
, sizeof(path1
), url
);
3046 if(!strcmp(path
, rtp_c
->stream
->filename
)) return rtp_c
;
3047 for(s
=0; s
<rtp_c
->stream
->nb_streams
; ++s
) {
3048 snprintf(buf
, sizeof(buf
), "%s/streamid=%d",
3049 rtp_c
->stream
->filename
, s
);
3050 if(!strncmp(path
, buf
, sizeof(buf
))) {
3051 // XXX: Should we reply with RTSP_STATUS_ONLY_AGGREGATE if nb_streams>1?
3058 static void rtsp_cmd_play(HTTPContext
*c
, const char *url
, RTSPMessageHeader
*h
)
3062 rtp_c
= find_rtp_session_with_url(url
, h
->session_id
);
3064 rtsp_reply_error(c
, RTSP_STATUS_SESSION
);
3068 if (rtp_c
->state
!= HTTPSTATE_SEND_DATA
&&
3069 rtp_c
->state
!= HTTPSTATE_WAIT_FEED
&&
3070 rtp_c
->state
!= HTTPSTATE_READY
) {
3071 rtsp_reply_error(c
, RTSP_STATUS_STATE
);
3076 /* XXX: seek in stream */
3077 if (h
->range_start
!= AV_NOPTS_VALUE
) {
3078 printf("range_start=%0.3f\n", (double)h
->range_start
/ AV_TIME_BASE
);
3079 av_seek_frame(rtp_c
->fmt_in
, -1, h
->range_start
);
3083 rtp_c
->state
= HTTPSTATE_SEND_DATA
;
3085 /* now everything is OK, so we can send the connection parameters */
3086 rtsp_reply_header(c
, RTSP_STATUS_OK
);
3088 url_fprintf(c
->pb
, "Session: %s\r\n", rtp_c
->session_id
);
3089 url_fprintf(c
->pb
, "\r\n");
3092 static void rtsp_cmd_pause(HTTPContext
*c
, const char *url
, RTSPMessageHeader
*h
)
3096 rtp_c
= find_rtp_session_with_url(url
, h
->session_id
);
3098 rtsp_reply_error(c
, RTSP_STATUS_SESSION
);
3102 if (rtp_c
->state
!= HTTPSTATE_SEND_DATA
&&
3103 rtp_c
->state
!= HTTPSTATE_WAIT_FEED
) {
3104 rtsp_reply_error(c
, RTSP_STATUS_STATE
);
3108 rtp_c
->state
= HTTPSTATE_READY
;
3109 rtp_c
->first_pts
= AV_NOPTS_VALUE
;
3110 /* now everything is OK, so we can send the connection parameters */
3111 rtsp_reply_header(c
, RTSP_STATUS_OK
);
3113 url_fprintf(c
->pb
, "Session: %s\r\n", rtp_c
->session_id
);
3114 url_fprintf(c
->pb
, "\r\n");
3117 static void rtsp_cmd_teardown(HTTPContext
*c
, const char *url
, RTSPMessageHeader
*h
)
3120 char session_id
[32];
3122 rtp_c
= find_rtp_session_with_url(url
, h
->session_id
);
3124 rtsp_reply_error(c
, RTSP_STATUS_SESSION
);
3128 av_strlcpy(session_id
, rtp_c
->session_id
, sizeof(session_id
));
3130 /* abort the session */
3131 close_connection(rtp_c
);
3133 /* now everything is OK, so we can send the connection parameters */
3134 rtsp_reply_header(c
, RTSP_STATUS_OK
);
3136 url_fprintf(c
->pb
, "Session: %s\r\n", session_id
);
3137 url_fprintf(c
->pb
, "\r\n");
3141 /********************************************************************/
3144 static HTTPContext
*rtp_new_connection(struct sockaddr_in
*from_addr
,
3145 FFStream
*stream
, const char *session_id
,
3146 enum RTSPLowerTransport rtp_protocol
)
3148 HTTPContext
*c
= NULL
;
3149 const char *proto_str
;
3151 /* XXX: should output a warning page when coming
3152 close to the connection limit */
3153 if (nb_connections
>= nb_max_connections
)
3156 /* add a new connection */
3157 c
= av_mallocz(sizeof(HTTPContext
));
3162 c
->poll_entry
= NULL
;
3163 c
->from_addr
= *from_addr
;
3164 c
->buffer_size
= IOBUFFER_INIT_SIZE
;
3165 c
->buffer
= av_malloc(c
->buffer_size
);
3170 av_strlcpy(c
->session_id
, session_id
, sizeof(c
->session_id
));
3171 c
->state
= HTTPSTATE_READY
;
3172 c
->is_packetized
= 1;
3173 c
->rtp_protocol
= rtp_protocol
;
3175 /* protocol is shown in statistics */
3176 switch(c
->rtp_protocol
) {
3177 case RTSP_LOWER_TRANSPORT_UDP_MULTICAST
:
3178 proto_str
= "MCAST";
3180 case RTSP_LOWER_TRANSPORT_UDP
:
3183 case RTSP_LOWER_TRANSPORT_TCP
:
3190 av_strlcpy(c
->protocol
, "RTP/", sizeof(c
->protocol
));
3191 av_strlcat(c
->protocol
, proto_str
, sizeof(c
->protocol
));
3193 current_bandwidth
+= stream
->bandwidth
;
3195 c
->next
= first_http_ctx
;
3207 /* add a new RTP stream in an RTP connection (used in RTSP SETUP
3208 command). If RTP/TCP protocol is used, TCP connection 'rtsp_c' is
3210 static int rtp_new_av_stream(HTTPContext
*c
,
3211 int stream_index
, struct sockaddr_in
*dest_addr
,
3212 HTTPContext
*rtsp_c
)
3214 AVFormatContext
*ctx
;
3217 URLContext
*h
= NULL
;
3219 int max_packet_size
;
3221 /* now we can open the relevant output stream */
3222 ctx
= avformat_alloc_context();
3225 ctx
->oformat
= guess_format("rtp", NULL
, NULL
);
3227 st
= av_mallocz(sizeof(AVStream
));
3230 st
->codec
= avcodec_alloc_context();
3231 ctx
->nb_streams
= 1;
3232 ctx
->streams
[0] = st
;
3234 if (!c
->stream
->feed
||
3235 c
->stream
->feed
== c
->stream
)
3236 memcpy(st
, c
->stream
->streams
[stream_index
], sizeof(AVStream
));
3239 c
->stream
->feed
->streams
[c
->stream
->feed_streams
[stream_index
]],
3241 st
->priv_data
= NULL
;
3243 /* build destination RTP address */
3244 ipaddr
= inet_ntoa(dest_addr
->sin_addr
);
3246 switch(c
->rtp_protocol
) {
3247 case RTSP_LOWER_TRANSPORT_UDP
:
3248 case RTSP_LOWER_TRANSPORT_UDP_MULTICAST
:
3251 /* XXX: also pass as parameter to function ? */
3252 if (c
->stream
->is_multicast
) {
3254 ttl
= c
->stream
->multicast_ttl
;
3257 snprintf(ctx
->filename
, sizeof(ctx
->filename
),
3258 "rtp://%s:%d?multicast=1&ttl=%d",
3259 ipaddr
, ntohs(dest_addr
->sin_port
), ttl
);
3261 snprintf(ctx
->filename
, sizeof(ctx
->filename
),
3262 "rtp://%s:%d", ipaddr
, ntohs(dest_addr
->sin_port
));
3265 if (url_open(&h
, ctx
->filename
, URL_WRONLY
) < 0)
3267 c
->rtp_handles
[stream_index
] = h
;
3268 max_packet_size
= url_get_max_packet_size(h
);
3270 case RTSP_LOWER_TRANSPORT_TCP
:
3273 max_packet_size
= RTSP_TCP_MAX_PACKET_SIZE
;
3279 http_log("%s:%d - - \"PLAY %s/streamid=%d %s\"\n",
3280 ipaddr
, ntohs(dest_addr
->sin_port
),
3281 c
->stream
->filename
, stream_index
, c
->protocol
);
3283 /* normally, no packets should be output here, but the packet size may be checked */
3284 if (url_open_dyn_packet_buf(&ctx
->pb
, max_packet_size
) < 0) {
3285 /* XXX: close stream */
3288 av_set_parameters(ctx
, NULL
);
3289 if (av_write_header(ctx
) < 0) {
3296 url_close_dyn_buf(ctx
->pb
, &dummy_buf
);
3299 c
->rtp_ctx
[stream_index
] = ctx
;
3303 /********************************************************************/
3304 /* ffserver initialization */
3306 static AVStream
*add_av_stream1(FFStream
*stream
, AVCodecContext
*codec
)
3310 fst
= av_mallocz(sizeof(AVStream
));
3313 fst
->codec
= avcodec_alloc_context();
3314 fst
->priv_data
= av_mallocz(sizeof(FeedData
));
3315 memcpy(fst
->codec
, codec
, sizeof(AVCodecContext
));
3316 fst
->index
= stream
->nb_streams
;
3317 av_set_pts_info(fst
, 33, 1, 90000);
3318 stream
->streams
[stream
->nb_streams
++] = fst
;
3322 /* return the stream number in the feed */
3323 static int add_av_stream(FFStream
*feed
, AVStream
*st
)
3326 AVCodecContext
*av
, *av1
;
3330 for(i
=0;i
<feed
->nb_streams
;i
++) {
3331 st
= feed
->streams
[i
];
3333 if (av1
->codec_id
== av
->codec_id
&&
3334 av1
->codec_type
== av
->codec_type
&&
3335 av1
->bit_rate
== av
->bit_rate
) {
3337 switch(av
->codec_type
) {
3338 case CODEC_TYPE_AUDIO
:
3339 if (av1
->channels
== av
->channels
&&
3340 av1
->sample_rate
== av
->sample_rate
)
3343 case CODEC_TYPE_VIDEO
:
3344 if (av1
->width
== av
->width
&&
3345 av1
->height
== av
->height
&&
3346 av1
->time_base
.den
== av
->time_base
.den
&&
3347 av1
->time_base
.num
== av
->time_base
.num
&&
3348 av1
->gop_size
== av
->gop_size
)
3357 fst
= add_av_stream1(feed
, av
);
3360 return feed
->nb_streams
- 1;
3365 static void remove_stream(FFStream
*stream
)
3369 while (*ps
!= NULL
) {
3377 /* specific mpeg4 handling : we extract the raw parameters */
3378 static void extract_mpeg4_header(AVFormatContext
*infile
)
3380 int mpeg4_count
, i
, size
;
3386 for(i
=0;i
<infile
->nb_streams
;i
++) {
3387 st
= infile
->streams
[i
];
3388 if (st
->codec
->codec_id
== CODEC_ID_MPEG4
&&
3389 st
->codec
->extradata_size
== 0) {
3396 printf("MPEG4 without extra data: trying to find header in %s\n", infile
->filename
);
3397 while (mpeg4_count
> 0) {
3398 if (av_read_packet(infile
, &pkt
) < 0)
3400 st
= infile
->streams
[pkt
.stream_index
];
3401 if (st
->codec
->codec_id
== CODEC_ID_MPEG4
&&
3402 st
->codec
->extradata_size
== 0) {
3403 av_freep(&st
->codec
->extradata
);
3404 /* fill extradata with the header */
3405 /* XXX: we make hard suppositions here ! */
3407 while (p
< pkt
.data
+ pkt
.size
- 4) {
3408 /* stop when vop header is found */
3409 if (p
[0] == 0x00 && p
[1] == 0x00 &&
3410 p
[2] == 0x01 && p
[3] == 0xb6) {
3411 size
= p
- pkt
.data
;
3412 // av_hex_dump_log(infile, AV_LOG_DEBUG, pkt.data, size);
3413 st
->codec
->extradata
= av_malloc(size
);
3414 st
->codec
->extradata_size
= size
;
3415 memcpy(st
->codec
->extradata
, pkt
.data
, size
);
3422 av_free_packet(&pkt
);
3426 /* compute the needed AVStream for each file */
3427 static void build_file_streams(void)
3429 FFStream
*stream
, *stream_next
;
3430 AVFormatContext
*infile
;
3433 /* gather all streams */
3434 for(stream
= first_stream
; stream
!= NULL
; stream
= stream_next
) {
3435 stream_next
= stream
->next
;
3436 if (stream
->stream_type
== STREAM_TYPE_LIVE
&&
3438 /* the stream comes from a file */
3439 /* try to open the file */
3441 stream
->ap_in
= av_mallocz(sizeof(AVFormatParameters
));
3442 if (stream
->fmt
&& !strcmp(stream
->fmt
->name
, "rtp")) {
3443 /* specific case : if transport stream output to RTP,
3444 we use a raw transport stream reader */
3445 stream
->ap_in
->mpeg2ts_raw
= 1;
3446 stream
->ap_in
->mpeg2ts_compute_pcr
= 1;
3449 http_log("Opening file '%s'\n", stream
->feed_filename
);
3450 if ((ret
= av_open_input_file(&infile
, stream
->feed_filename
,
3451 stream
->ifmt
, 0, stream
->ap_in
)) < 0) {
3452 http_log("Could not open '%s': %d\n", stream
->feed_filename
, ret
);
3453 /* remove stream (no need to spend more time on it) */
3455 remove_stream(stream
);
3457 /* find all the AVStreams inside and reference them in
3459 if (av_find_stream_info(infile
) < 0) {
3460 http_log("Could not find codec parameters from '%s'\n",
3461 stream
->feed_filename
);
3462 av_close_input_file(infile
);
3465 extract_mpeg4_header(infile
);
3467 for(i
=0;i
<infile
->nb_streams
;i
++)
3468 add_av_stream1(stream
, infile
->streams
[i
]->codec
);
3470 av_close_input_file(infile
);
3476 /* compute the needed AVStream for each feed */
3477 static void build_feed_streams(void)
3479 FFStream
*stream
, *feed
;
3482 /* gather all streams */
3483 for(stream
= first_stream
; stream
!= NULL
; stream
= stream
->next
) {
3484 feed
= stream
->feed
;
3486 if (!stream
->is_feed
) {
3487 /* we handle a stream coming from a feed */
3488 for(i
=0;i
<stream
->nb_streams
;i
++)
3489 stream
->feed_streams
[i
] = add_av_stream(feed
, stream
->streams
[i
]);
3494 /* gather all streams */
3495 for(stream
= first_stream
; stream
!= NULL
; stream
= stream
->next
) {
3496 feed
= stream
->feed
;
3498 if (stream
->is_feed
) {
3499 for(i
=0;i
<stream
->nb_streams
;i
++)
3500 stream
->feed_streams
[i
] = i
;
3505 /* create feed files if needed */
3506 for(feed
= first_feed
; feed
!= NULL
; feed
= feed
->next_feed
) {
3509 if (url_exist(feed
->feed_filename
)) {
3510 /* See if it matches */
3514 if (av_open_input_file(&s
, feed
->feed_filename
, NULL
, FFM_PACKET_SIZE
, NULL
) >= 0) {
3515 /* Now see if it matches */
3516 if (s
->nb_streams
== feed
->nb_streams
) {
3518 for(i
=0;i
<s
->nb_streams
;i
++) {
3520 sf
= feed
->streams
[i
];
3523 if (sf
->index
!= ss
->index
||
3525 http_log("Index & Id do not match for stream %d (%s)\n",
3526 i
, feed
->feed_filename
);
3529 AVCodecContext
*ccf
, *ccs
;
3533 #define CHECK_CODEC(x) (ccf->x != ccs->x)
3535 if (CHECK_CODEC(codec
) || CHECK_CODEC(codec_type
)) {
3536 http_log("Codecs do not match for stream %d\n", i
);
3538 } else if (CHECK_CODEC(bit_rate
) || CHECK_CODEC(flags
)) {
3539 http_log("Codec bitrates do not match for stream %d\n", i
);
3541 } else if (ccf
->codec_type
== CODEC_TYPE_VIDEO
) {
3542 if (CHECK_CODEC(time_base
.den
) ||
3543 CHECK_CODEC(time_base
.num
) ||
3544 CHECK_CODEC(width
) ||
3545 CHECK_CODEC(height
)) {
3546 http_log("Codec width, height and framerate do not match for stream %d\n", i
);
3549 } else if (ccf
->codec_type
== CODEC_TYPE_AUDIO
) {
3550 if (CHECK_CODEC(sample_rate
) ||
3551 CHECK_CODEC(channels
) ||
3552 CHECK_CODEC(frame_size
)) {
3553 http_log("Codec sample_rate, channels, frame_size do not match for stream %d\n", i
);
3557 http_log("Unknown codec type\n");
3565 http_log("Deleting feed file '%s' as stream counts differ (%d != %d)\n",
3566 feed
->feed_filename
, s
->nb_streams
, feed
->nb_streams
);
3568 av_close_input_file(s
);
3570 http_log("Deleting feed file '%s' as it appears to be corrupt\n",
3571 feed
->feed_filename
);
3574 if (feed
->readonly
) {
3575 http_log("Unable to delete feed file '%s' as it is marked readonly\n",
3576 feed
->feed_filename
);
3579 unlink(feed
->feed_filename
);
3582 if (!url_exist(feed
->feed_filename
)) {
3583 AVFormatContext s1
= {0}, *s
= &s1
;
3585 if (feed
->readonly
) {
3586 http_log("Unable to create feed file '%s' as it is marked readonly\n",
3587 feed
->feed_filename
);
3591 /* only write the header of the ffm file */
3592 if (url_fopen(&s
->pb
, feed
->feed_filename
, URL_WRONLY
) < 0) {
3593 http_log("Could not open output feed file '%s'\n",
3594 feed
->feed_filename
);
3597 s
->oformat
= feed
->fmt
;
3598 s
->nb_streams
= feed
->nb_streams
;
3599 for(i
=0;i
<s
->nb_streams
;i
++) {
3601 st
= feed
->streams
[i
];
3604 av_set_parameters(s
, NULL
);
3605 if (av_write_header(s
) < 0) {
3606 http_log("Container doesn't supports the required parameters\n");
3609 /* XXX: need better api */
3610 av_freep(&s
->priv_data
);
3613 /* get feed size and write index */
3614 fd
= open(feed
->feed_filename
, O_RDONLY
);
3616 http_log("Could not open output feed file '%s'\n",
3617 feed
->feed_filename
);
3621 feed
->feed_write_index
= FFMAX(ffm_read_write_index(fd
), FFM_PACKET_SIZE
);
3622 feed
->feed_size
= lseek(fd
, 0, SEEK_END
);
3623 /* ensure that we do not wrap before the end of file */
3624 if (feed
->feed_max_size
&& feed
->feed_max_size
< feed
->feed_size
)
3625 feed
->feed_max_size
= feed
->feed_size
;
3631 /* compute the bandwidth used by each stream */
3632 static void compute_bandwidth(void)
3638 for(stream
= first_stream
; stream
!= NULL
; stream
= stream
->next
) {
3640 for(i
=0;i
<stream
->nb_streams
;i
++) {
3641 AVStream
*st
= stream
->streams
[i
];
3642 switch(st
->codec
->codec_type
) {
3643 case CODEC_TYPE_AUDIO
:
3644 case CODEC_TYPE_VIDEO
:
3645 bandwidth
+= st
->codec
->bit_rate
;
3651 stream
->bandwidth
= (bandwidth
+ 999) / 1000;
3655 /* add a codec and set the default parameters */
3656 static void add_codec(FFStream
*stream
, AVCodecContext
*av
)
3660 /* compute default parameters */
3661 switch(av
->codec_type
) {
3662 case CODEC_TYPE_AUDIO
:
3663 if (av
->bit_rate
== 0)
3664 av
->bit_rate
= 64000;
3665 if (av
->sample_rate
== 0)
3666 av
->sample_rate
= 22050;
3667 if (av
->channels
== 0)
3670 case CODEC_TYPE_VIDEO
:
3671 if (av
->bit_rate
== 0)
3672 av
->bit_rate
= 64000;
3673 if (av
->time_base
.num
== 0){
3674 av
->time_base
.den
= 5;
3675 av
->time_base
.num
= 1;
3677 if (av
->width
== 0 || av
->height
== 0) {
3681 /* Bitrate tolerance is less for streaming */
3682 if (av
->bit_rate_tolerance
== 0)
3683 av
->bit_rate_tolerance
= FFMAX(av
->bit_rate
/ 4,
3684 (int64_t)av
->bit_rate
*av
->time_base
.num
/av
->time_base
.den
);
3689 if (av
->max_qdiff
== 0)
3691 av
->qcompress
= 0.5;
3694 if (!av
->nsse_weight
)
3695 av
->nsse_weight
= 8;
3697 av
->frame_skip_cmp
= FF_CMP_DCTMAX
;
3698 av
->me_method
= ME_EPZS
;
3699 av
->rc_buffer_aggressivity
= 1.0;
3702 av
->rc_eq
= "tex^qComp";
3703 if (!av
->i_quant_factor
)
3704 av
->i_quant_factor
= -0.8;
3705 if (!av
->b_quant_factor
)
3706 av
->b_quant_factor
= 1.25;
3707 if (!av
->b_quant_offset
)
3708 av
->b_quant_offset
= 1.25;
3709 if (!av
->rc_max_rate
)
3710 av
->rc_max_rate
= av
->bit_rate
* 2;
3712 if (av
->rc_max_rate
&& !av
->rc_buffer_size
) {
3713 av
->rc_buffer_size
= av
->rc_max_rate
;
3722 st
= av_mallocz(sizeof(AVStream
));
3725 st
->codec
= avcodec_alloc_context();
3726 stream
->streams
[stream
->nb_streams
++] = st
;
3727 memcpy(st
->codec
, av
, sizeof(AVCodecContext
));
3730 static enum CodecID
opt_audio_codec(const char *arg
)
3732 AVCodec
*p
= avcodec_find_encoder_by_name(arg
);
3734 if (p
== NULL
|| p
->type
!= CODEC_TYPE_AUDIO
)
3735 return CODEC_ID_NONE
;
3740 static enum CodecID
opt_video_codec(const char *arg
)
3742 AVCodec
*p
= avcodec_find_encoder_by_name(arg
);
3744 if (p
== NULL
|| p
->type
!= CODEC_TYPE_VIDEO
)
3745 return CODEC_ID_NONE
;
3750 /* simplistic plugin support */
3753 static void load_module(const char *filename
)
3756 void (*init_func
)(void);
3757 dll
= dlopen(filename
, RTLD_NOW
);
3759 fprintf(stderr
, "Could not load module '%s' - %s\n",
3760 filename
, dlerror());
3764 init_func
= dlsym(dll
, "ffserver_module_init");
3767 "%s: init function 'ffserver_module_init()' not found\n",
3776 static int ffserver_opt_default(const char *opt
, const char *arg
,
3777 AVCodecContext
*avctx
, int type
)
3780 const AVOption
*o
= av_find_opt(avctx
, opt
, NULL
, type
, type
);
3782 ret
= av_set_string3(avctx
, opt
, arg
, 1, NULL
);
3786 static int parse_ffconfig(const char *filename
)
3793 int val
, errors
, line_num
;
3794 FFStream
**last_stream
, *stream
, *redirect
;
3795 FFStream
**last_feed
, *feed
, *s
;
3796 AVCodecContext audio_enc
, video_enc
;
3797 enum CodecID audio_id
, video_id
;
3799 f
= fopen(filename
, "r");
3807 first_stream
= NULL
;
3808 last_stream
= &first_stream
;
3810 last_feed
= &first_feed
;
3814 audio_id
= CODEC_ID_NONE
;
3815 video_id
= CODEC_ID_NONE
;
3817 if (fgets(line
, sizeof(line
), f
) == NULL
)
3823 if (*p
== '\0' || *p
== '#')
3826 get_arg(cmd
, sizeof(cmd
), &p
);
3828 if (!strcasecmp(cmd
, "Port")) {
3829 get_arg(arg
, sizeof(arg
), &p
);
3831 if (val
< 1 || val
> 65536) {
3832 fprintf(stderr
, "%s:%d: Invalid port: %s\n",
3833 filename
, line_num
, arg
);
3836 my_http_addr
.sin_port
= htons(val
);
3837 } else if (!strcasecmp(cmd
, "BindAddress")) {
3838 get_arg(arg
, sizeof(arg
), &p
);
3839 if (resolve_host(&my_http_addr
.sin_addr
, arg
) != 0) {
3840 fprintf(stderr
, "%s:%d: Invalid host/IP address: %s\n",
3841 filename
, line_num
, arg
);
3844 } else if (!strcasecmp(cmd
, "NoDaemon")) {
3845 ffserver_daemon
= 0;
3846 } else if (!strcasecmp(cmd
, "RTSPPort")) {
3847 get_arg(arg
, sizeof(arg
), &p
);
3849 if (val
< 1 || val
> 65536) {
3850 fprintf(stderr
, "%s:%d: Invalid port: %s\n",
3851 filename
, line_num
, arg
);
3854 my_rtsp_addr
.sin_port
= htons(atoi(arg
));
3855 } else if (!strcasecmp(cmd
, "RTSPBindAddress")) {
3856 get_arg(arg
, sizeof(arg
), &p
);
3857 if (resolve_host(&my_rtsp_addr
.sin_addr
, arg
) != 0) {
3858 fprintf(stderr
, "%s:%d: Invalid host/IP address: %s\n",
3859 filename
, line_num
, arg
);
3862 } else if (!strcasecmp(cmd
, "MaxHTTPConnections")) {
3863 get_arg(arg
, sizeof(arg
), &p
);
3865 if (val
< 1 || val
> 65536) {
3866 fprintf(stderr
, "%s:%d: Invalid MaxHTTPConnections: %s\n",
3867 filename
, line_num
, arg
);
3870 nb_max_http_connections
= val
;
3871 } else if (!strcasecmp(cmd
, "MaxClients")) {
3872 get_arg(arg
, sizeof(arg
), &p
);
3874 if (val
< 1 || val
> nb_max_http_connections
) {
3875 fprintf(stderr
, "%s:%d: Invalid MaxClients: %s\n",
3876 filename
, line_num
, arg
);
3879 nb_max_connections
= val
;
3881 } else if (!strcasecmp(cmd
, "MaxBandwidth")) {
3883 get_arg(arg
, sizeof(arg
), &p
);
3885 if (llval
< 10 || llval
> 10000000) {
3886 fprintf(stderr
, "%s:%d: Invalid MaxBandwidth: %s\n",
3887 filename
, line_num
, arg
);
3890 max_bandwidth
= llval
;
3891 } else if (!strcasecmp(cmd
, "CustomLog")) {
3892 if (!ffserver_debug
)
3893 get_arg(logfilename
, sizeof(logfilename
), &p
);
3894 } else if (!strcasecmp(cmd
, "<Feed")) {
3895 /*********************************************/
3896 /* Feed related options */
3898 if (stream
|| feed
) {
3899 fprintf(stderr
, "%s:%d: Already in a tag\n",
3900 filename
, line_num
);
3902 feed
= av_mallocz(sizeof(FFStream
));
3903 get_arg(feed
->filename
, sizeof(feed
->filename
), &p
);
3904 q
= strrchr(feed
->filename
, '>');
3908 for (s
= first_feed
; s
; s
= s
->next
) {
3909 if (!strcmp(feed
->filename
, s
->filename
)) {
3910 fprintf(stderr
, "%s:%d: Feed '%s' already registered\n",
3911 filename
, line_num
, s
->filename
);
3916 feed
->fmt
= guess_format("ffm", NULL
, NULL
);
3917 /* defaut feed file */
3918 snprintf(feed
->feed_filename
, sizeof(feed
->feed_filename
),
3919 "/tmp/%s.ffm", feed
->filename
);
3920 feed
->feed_max_size
= 5 * 1024 * 1024;
3922 feed
->feed
= feed
; /* self feeding :-) */
3924 /* add in stream list */
3925 *last_stream
= feed
;
3926 last_stream
= &feed
->next
;
3927 /* add in feed list */
3929 last_feed
= &feed
->next_feed
;
3931 } else if (!strcasecmp(cmd
, "Launch")) {
3935 feed
->child_argv
= av_mallocz(64 * sizeof(char *));
3937 for (i
= 0; i
< 62; i
++) {
3938 get_arg(arg
, sizeof(arg
), &p
);
3942 feed
->child_argv
[i
] = av_strdup(arg
);
3945 feed
->child_argv
[i
] = av_malloc(30 + strlen(feed
->filename
));
3947 snprintf(feed
->child_argv
[i
], 30+strlen(feed
->filename
),
3949 (my_http_addr
.sin_addr
.s_addr
== INADDR_ANY
) ? "127.0.0.1" :
3950 inet_ntoa(my_http_addr
.sin_addr
),
3951 ntohs(my_http_addr
.sin_port
), feed
->filename
);
3953 } else if (!strcasecmp(cmd
, "ReadOnlyFile")) {
3955 get_arg(feed
->feed_filename
, sizeof(feed
->feed_filename
), &p
);
3957 } else if (stream
) {
3958 get_arg(stream
->feed_filename
, sizeof(stream
->feed_filename
), &p
);
3960 } else if (!strcasecmp(cmd
, "File")) {
3962 get_arg(feed
->feed_filename
, sizeof(feed
->feed_filename
), &p
);
3964 get_arg(stream
->feed_filename
, sizeof(stream
->feed_filename
), &p
);
3965 } else if (!strcasecmp(cmd
, "Truncate")) {
3967 get_arg(arg
, sizeof(arg
), &p
);
3968 feed
->truncate
= strtod(arg
, NULL
);
3970 } else if (!strcasecmp(cmd
, "FileMaxSize")) {
3975 get_arg(arg
, sizeof(arg
), &p
);
3977 fsize
= strtod(p1
, &p1
);
3978 switch(toupper(*p1
)) {
3983 fsize
*= 1024 * 1024;
3986 fsize
*= 1024 * 1024 * 1024;
3989 feed
->feed_max_size
= (int64_t)fsize
;
3990 if (feed
->feed_max_size
< FFM_PACKET_SIZE
*4) {
3991 fprintf(stderr
, "%s:%d: Feed max file size is too small, "
3992 "must be at least %d\n", filename
, line_num
, FFM_PACKET_SIZE
*4);
3996 } else if (!strcasecmp(cmd
, "</Feed>")) {
3998 fprintf(stderr
, "%s:%d: No corresponding <Feed> for </Feed>\n",
3999 filename
, line_num
);
4003 } else if (!strcasecmp(cmd
, "<Stream")) {
4004 /*********************************************/
4005 /* Stream related options */
4007 if (stream
|| feed
) {
4008 fprintf(stderr
, "%s:%d: Already in a tag\n",
4009 filename
, line_num
);
4012 const AVClass
*class;
4013 stream
= av_mallocz(sizeof(FFStream
));
4014 get_arg(stream
->filename
, sizeof(stream
->filename
), &p
);
4015 q
= strrchr(stream
->filename
, '>');
4019 for (s
= first_stream
; s
; s
= s
->next
) {
4020 if (!strcmp(stream
->filename
, s
->filename
)) {
4021 fprintf(stderr
, "%s:%d: Stream '%s' already registered\n",
4022 filename
, line_num
, s
->filename
);
4027 stream
->fmt
= guess_stream_format(NULL
, stream
->filename
, NULL
);
4028 /* fetch avclass so AVOption works
4029 * FIXME try to use avcodec_get_context_defaults2
4030 * without changing defaults too much */
4031 avcodec_get_context_defaults(&video_enc
);
4032 class = video_enc
.av_class
;
4033 memset(&audio_enc
, 0, sizeof(AVCodecContext
));
4034 memset(&video_enc
, 0, sizeof(AVCodecContext
));
4035 audio_enc
.av_class
= class;
4036 video_enc
.av_class
= class;
4037 audio_id
= CODEC_ID_NONE
;
4038 video_id
= CODEC_ID_NONE
;
4040 audio_id
= stream
->fmt
->audio_codec
;
4041 video_id
= stream
->fmt
->video_codec
;
4044 *last_stream
= stream
;
4045 last_stream
= &stream
->next
;
4047 } else if (!strcasecmp(cmd
, "Feed")) {
4048 get_arg(arg
, sizeof(arg
), &p
);
4053 while (sfeed
!= NULL
) {
4054 if (!strcmp(sfeed
->filename
, arg
))
4056 sfeed
= sfeed
->next_feed
;
4059 fprintf(stderr
, "%s:%d: feed '%s' not defined\n",
4060 filename
, line_num
, arg
);
4062 stream
->feed
= sfeed
;
4064 } else if (!strcasecmp(cmd
, "Format")) {
4065 get_arg(arg
, sizeof(arg
), &p
);
4067 if (!strcmp(arg
, "status")) {
4068 stream
->stream_type
= STREAM_TYPE_STATUS
;
4071 stream
->stream_type
= STREAM_TYPE_LIVE
;
4072 /* jpeg cannot be used here, so use single frame jpeg */
4073 if (!strcmp(arg
, "jpeg"))
4074 strcpy(arg
, "mjpeg");
4075 stream
->fmt
= guess_stream_format(arg
, NULL
, NULL
);
4077 fprintf(stderr
, "%s:%d: Unknown Format: %s\n",
4078 filename
, line_num
, arg
);
4083 audio_id
= stream
->fmt
->audio_codec
;
4084 video_id
= stream
->fmt
->video_codec
;
4087 } else if (!strcasecmp(cmd
, "InputFormat")) {
4088 get_arg(arg
, sizeof(arg
), &p
);
4090 stream
->ifmt
= av_find_input_format(arg
);
4091 if (!stream
->ifmt
) {
4092 fprintf(stderr
, "%s:%d: Unknown input format: %s\n",
4093 filename
, line_num
, arg
);
4096 } else if (!strcasecmp(cmd
, "FaviconURL")) {
4097 if (stream
&& stream
->stream_type
== STREAM_TYPE_STATUS
) {
4098 get_arg(stream
->feed_filename
, sizeof(stream
->feed_filename
), &p
);
4100 fprintf(stderr
, "%s:%d: FaviconURL only permitted for status streams\n",
4101 filename
, line_num
);
4104 } else if (!strcasecmp(cmd
, "Author")) {
4106 get_arg(stream
->author
, sizeof(stream
->author
), &p
);
4107 } else if (!strcasecmp(cmd
, "Comment")) {
4109 get_arg(stream
->comment
, sizeof(stream
->comment
), &p
);
4110 } else if (!strcasecmp(cmd
, "Copyright")) {
4112 get_arg(stream
->copyright
, sizeof(stream
->copyright
), &p
);
4113 } else if (!strcasecmp(cmd
, "Title")) {
4115 get_arg(stream
->title
, sizeof(stream
->title
), &p
);
4116 } else if (!strcasecmp(cmd
, "Preroll")) {
4117 get_arg(arg
, sizeof(arg
), &p
);
4119 stream
->prebuffer
= atof(arg
) * 1000;
4120 } else if (!strcasecmp(cmd
, "StartSendOnKey")) {
4122 stream
->send_on_key
= 1;
4123 } else if (!strcasecmp(cmd
, "AudioCodec")) {
4124 get_arg(arg
, sizeof(arg
), &p
);
4125 audio_id
= opt_audio_codec(arg
);
4126 if (audio_id
== CODEC_ID_NONE
) {
4127 fprintf(stderr
, "%s:%d: Unknown AudioCodec: %s\n",
4128 filename
, line_num
, arg
);
4131 } else if (!strcasecmp(cmd
, "VideoCodec")) {
4132 get_arg(arg
, sizeof(arg
), &p
);
4133 video_id
= opt_video_codec(arg
);
4134 if (video_id
== CODEC_ID_NONE
) {
4135 fprintf(stderr
, "%s:%d: Unknown VideoCodec: %s\n",
4136 filename
, line_num
, arg
);
4139 } else if (!strcasecmp(cmd
, "MaxTime")) {
4140 get_arg(arg
, sizeof(arg
), &p
);
4142 stream
->max_time
= atof(arg
) * 1000;
4143 } else if (!strcasecmp(cmd
, "AudioBitRate")) {
4144 get_arg(arg
, sizeof(arg
), &p
);
4146 audio_enc
.bit_rate
= atoi(arg
) * 1000;
4147 } else if (!strcasecmp(cmd
, "AudioChannels")) {
4148 get_arg(arg
, sizeof(arg
), &p
);
4150 audio_enc
.channels
= atoi(arg
);
4151 } else if (!strcasecmp(cmd
, "AudioSampleRate")) {
4152 get_arg(arg
, sizeof(arg
), &p
);
4154 audio_enc
.sample_rate
= atoi(arg
);
4155 } else if (!strcasecmp(cmd
, "AudioQuality")) {
4156 get_arg(arg
, sizeof(arg
), &p
);
4158 // audio_enc.quality = atof(arg) * 1000;
4160 } else if (!strcasecmp(cmd
, "VideoBitRateRange")) {
4162 int minrate
, maxrate
;
4164 get_arg(arg
, sizeof(arg
), &p
);
4166 if (sscanf(arg
, "%d-%d", &minrate
, &maxrate
) == 2) {
4167 video_enc
.rc_min_rate
= minrate
* 1000;
4168 video_enc
.rc_max_rate
= maxrate
* 1000;
4170 fprintf(stderr
, "%s:%d: Incorrect format for VideoBitRateRange -- should be <min>-<max>: %s\n",
4171 filename
, line_num
, arg
);
4175 } else if (!strcasecmp(cmd
, "Debug")) {
4177 get_arg(arg
, sizeof(arg
), &p
);
4178 video_enc
.debug
= strtol(arg
,0,0);
4180 } else if (!strcasecmp(cmd
, "Strict")) {
4182 get_arg(arg
, sizeof(arg
), &p
);
4183 video_enc
.strict_std_compliance
= atoi(arg
);
4185 } else if (!strcasecmp(cmd
, "VideoBufferSize")) {
4187 get_arg(arg
, sizeof(arg
), &p
);
4188 video_enc
.rc_buffer_size
= atoi(arg
) * 8*1024;
4190 } else if (!strcasecmp(cmd
, "VideoBitRateTolerance")) {
4192 get_arg(arg
, sizeof(arg
), &p
);
4193 video_enc
.bit_rate_tolerance
= atoi(arg
) * 1000;
4195 } else if (!strcasecmp(cmd
, "VideoBitRate")) {
4196 get_arg(arg
, sizeof(arg
), &p
);
4198 video_enc
.bit_rate
= atoi(arg
) * 1000;
4200 } else if (!strcasecmp(cmd
, "VideoSize")) {
4201 get_arg(arg
, sizeof(arg
), &p
);
4203 av_parse_video_frame_size(&video_enc
.width
, &video_enc
.height
, arg
);
4204 if ((video_enc
.width
% 16) != 0 ||
4205 (video_enc
.height
% 16) != 0) {
4206 fprintf(stderr
, "%s:%d: Image size must be a multiple of 16\n",
4207 filename
, line_num
);
4211 } else if (!strcasecmp(cmd
, "VideoFrameRate")) {
4212 get_arg(arg
, sizeof(arg
), &p
);
4214 AVRational frame_rate
;
4215 if (av_parse_video_frame_rate(&frame_rate
, arg
) < 0) {
4216 fprintf(stderr
, "Incorrect frame rate\n");
4219 video_enc
.time_base
.num
= frame_rate
.den
;
4220 video_enc
.time_base
.den
= frame_rate
.num
;
4223 } else if (!strcasecmp(cmd
, "VideoGopSize")) {
4224 get_arg(arg
, sizeof(arg
), &p
);
4226 video_enc
.gop_size
= atoi(arg
);
4227 } else if (!strcasecmp(cmd
, "VideoIntraOnly")) {
4229 video_enc
.gop_size
= 1;
4230 } else if (!strcasecmp(cmd
, "VideoHighQuality")) {
4232 video_enc
.mb_decision
= FF_MB_DECISION_BITS
;
4233 } else if (!strcasecmp(cmd
, "Video4MotionVector")) {
4235 video_enc
.mb_decision
= FF_MB_DECISION_BITS
; //FIXME remove
4236 video_enc
.flags
|= CODEC_FLAG_4MV
;
4238 } else if (!strcasecmp(cmd
, "AVOptionVideo") ||
4239 !strcasecmp(cmd
, "AVOptionAudio")) {
4241 AVCodecContext
*avctx
;
4243 get_arg(arg
, sizeof(arg
), &p
);
4244 get_arg(arg2
, sizeof(arg2
), &p
);
4245 if (!strcasecmp(cmd
, "AVOptionVideo")) {
4247 type
= AV_OPT_FLAG_VIDEO_PARAM
;
4250 type
= AV_OPT_FLAG_AUDIO_PARAM
;
4252 if (ffserver_opt_default(arg
, arg2
, avctx
, type
|AV_OPT_FLAG_ENCODING_PARAM
)) {
4253 fprintf(stderr
, "AVOption error: %s %s\n", arg
, arg2
);
4256 } else if (!strcasecmp(cmd
, "VideoTag")) {
4257 get_arg(arg
, sizeof(arg
), &p
);
4258 if ((strlen(arg
) == 4) && stream
)
4259 video_enc
.codec_tag
= AV_RL32(arg
);
4260 } else if (!strcasecmp(cmd
, "BitExact")) {
4262 video_enc
.flags
|= CODEC_FLAG_BITEXACT
;
4263 } else if (!strcasecmp(cmd
, "DctFastint")) {
4265 video_enc
.dct_algo
= FF_DCT_FASTINT
;
4266 } else if (!strcasecmp(cmd
, "IdctSimple")) {
4268 video_enc
.idct_algo
= FF_IDCT_SIMPLE
;
4269 } else if (!strcasecmp(cmd
, "Qscale")) {
4270 get_arg(arg
, sizeof(arg
), &p
);
4272 video_enc
.flags
|= CODEC_FLAG_QSCALE
;
4273 video_enc
.global_quality
= FF_QP2LAMBDA
* atoi(arg
);
4275 } else if (!strcasecmp(cmd
, "VideoQDiff")) {
4276 get_arg(arg
, sizeof(arg
), &p
);
4278 video_enc
.max_qdiff
= atoi(arg
);
4279 if (video_enc
.max_qdiff
< 1 || video_enc
.max_qdiff
> 31) {
4280 fprintf(stderr
, "%s:%d: VideoQDiff out of range\n",
4281 filename
, line_num
);
4285 } else if (!strcasecmp(cmd
, "VideoQMax")) {
4286 get_arg(arg
, sizeof(arg
), &p
);
4288 video_enc
.qmax
= atoi(arg
);
4289 if (video_enc
.qmax
< 1 || video_enc
.qmax
> 31) {
4290 fprintf(stderr
, "%s:%d: VideoQMax out of range\n",
4291 filename
, line_num
);
4295 } else if (!strcasecmp(cmd
, "VideoQMin")) {
4296 get_arg(arg
, sizeof(arg
), &p
);
4298 video_enc
.qmin
= atoi(arg
);
4299 if (video_enc
.qmin
< 1 || video_enc
.qmin
> 31) {
4300 fprintf(stderr
, "%s:%d: VideoQMin out of range\n",
4301 filename
, line_num
);
4305 } else if (!strcasecmp(cmd
, "LumaElim")) {
4306 get_arg(arg
, sizeof(arg
), &p
);
4308 video_enc
.luma_elim_threshold
= atoi(arg
);
4309 } else if (!strcasecmp(cmd
, "ChromaElim")) {
4310 get_arg(arg
, sizeof(arg
), &p
);
4312 video_enc
.chroma_elim_threshold
= atoi(arg
);
4313 } else if (!strcasecmp(cmd
, "LumiMask")) {
4314 get_arg(arg
, sizeof(arg
), &p
);
4316 video_enc
.lumi_masking
= atof(arg
);
4317 } else if (!strcasecmp(cmd
, "DarkMask")) {
4318 get_arg(arg
, sizeof(arg
), &p
);
4320 video_enc
.dark_masking
= atof(arg
);
4321 } else if (!strcasecmp(cmd
, "NoVideo")) {
4322 video_id
= CODEC_ID_NONE
;
4323 } else if (!strcasecmp(cmd
, "NoAudio")) {
4324 audio_id
= CODEC_ID_NONE
;
4325 } else if (!strcasecmp(cmd
, "ACL")) {
4328 get_arg(arg
, sizeof(arg
), &p
);
4329 if (strcasecmp(arg
, "allow") == 0)
4330 acl
.action
= IP_ALLOW
;
4331 else if (strcasecmp(arg
, "deny") == 0)
4332 acl
.action
= IP_DENY
;
4334 fprintf(stderr
, "%s:%d: ACL action '%s' is not ALLOW or DENY\n",
4335 filename
, line_num
, arg
);
4339 get_arg(arg
, sizeof(arg
), &p
);
4341 if (resolve_host(&acl
.first
, arg
) != 0) {
4342 fprintf(stderr
, "%s:%d: ACL refers to invalid host or ip address '%s'\n",
4343 filename
, line_num
, arg
);
4346 acl
.last
= acl
.first
;
4348 get_arg(arg
, sizeof(arg
), &p
);
4351 if (resolve_host(&acl
.last
, arg
) != 0) {
4352 fprintf(stderr
, "%s:%d: ACL refers to invalid host or ip address '%s'\n",
4353 filename
, line_num
, arg
);
4359 IPAddressACL
*nacl
= av_mallocz(sizeof(*nacl
));
4360 IPAddressACL
**naclp
= 0;
4366 naclp
= &stream
->acl
;
4370 fprintf(stderr
, "%s:%d: ACL found not in <stream> or <feed>\n",
4371 filename
, line_num
);
4377 naclp
= &(*naclp
)->next
;
4382 } else if (!strcasecmp(cmd
, "RTSPOption")) {
4383 get_arg(arg
, sizeof(arg
), &p
);
4385 av_freep(&stream
->rtsp_option
);
4386 stream
->rtsp_option
= av_strdup(arg
);
4388 } else if (!strcasecmp(cmd
, "MulticastAddress")) {
4389 get_arg(arg
, sizeof(arg
), &p
);
4391 if (resolve_host(&stream
->multicast_ip
, arg
) != 0) {
4392 fprintf(stderr
, "%s:%d: Invalid host/IP address: %s\n",
4393 filename
, line_num
, arg
);
4396 stream
->is_multicast
= 1;
4397 stream
->loop
= 1; /* default is looping */
4399 } else if (!strcasecmp(cmd
, "MulticastPort")) {
4400 get_arg(arg
, sizeof(arg
), &p
);
4402 stream
->multicast_port
= atoi(arg
);
4403 } else if (!strcasecmp(cmd
, "MulticastTTL")) {
4404 get_arg(arg
, sizeof(arg
), &p
);
4406 stream
->multicast_ttl
= atoi(arg
);
4407 } else if (!strcasecmp(cmd
, "NoLoop")) {
4410 } else if (!strcasecmp(cmd
, "</Stream>")) {
4412 fprintf(stderr
, "%s:%d: No corresponding <Stream> for </Stream>\n",
4413 filename
, line_num
);
4416 if (stream
->feed
&& stream
->fmt
&& strcmp(stream
->fmt
->name
, "ffm") != 0) {
4417 if (audio_id
!= CODEC_ID_NONE
) {
4418 audio_enc
.codec_type
= CODEC_TYPE_AUDIO
;
4419 audio_enc
.codec_id
= audio_id
;
4420 add_codec(stream
, &audio_enc
);
4422 if (video_id
!= CODEC_ID_NONE
) {
4423 video_enc
.codec_type
= CODEC_TYPE_VIDEO
;
4424 video_enc
.codec_id
= video_id
;
4425 add_codec(stream
, &video_enc
);
4430 } else if (!strcasecmp(cmd
, "<Redirect")) {
4431 /*********************************************/
4433 if (stream
|| feed
|| redirect
) {
4434 fprintf(stderr
, "%s:%d: Already in a tag\n",
4435 filename
, line_num
);
4438 redirect
= av_mallocz(sizeof(FFStream
));
4439 *last_stream
= redirect
;
4440 last_stream
= &redirect
->next
;
4442 get_arg(redirect
->filename
, sizeof(redirect
->filename
), &p
);
4443 q
= strrchr(redirect
->filename
, '>');
4446 redirect
->stream_type
= STREAM_TYPE_REDIRECT
;
4448 } else if (!strcasecmp(cmd
, "URL")) {
4450 get_arg(redirect
->feed_filename
, sizeof(redirect
->feed_filename
), &p
);
4451 } else if (!strcasecmp(cmd
, "</Redirect>")) {
4453 fprintf(stderr
, "%s:%d: No corresponding <Redirect> for </Redirect>\n",
4454 filename
, line_num
);
4457 if (!redirect
->feed_filename
[0]) {
4458 fprintf(stderr
, "%s:%d: No URL found for <Redirect>\n",
4459 filename
, line_num
);
4464 } else if (!strcasecmp(cmd
, "LoadModule")) {
4465 get_arg(arg
, sizeof(arg
), &p
);
4469 fprintf(stderr
, "%s:%d: Module support not compiled into this version: '%s'\n",
4470 filename
, line_num
, arg
);
4474 fprintf(stderr
, "%s:%d: Incorrect keyword: '%s'\n",
4475 filename
, line_num
, cmd
);
4486 static void handle_child_exit(int sig
)
4491 while ((pid
= waitpid(-1, &status
, WNOHANG
)) > 0) {
4494 for (feed
= first_feed
; feed
; feed
= feed
->next
) {
4495 if (feed
->pid
== pid
) {
4496 int uptime
= time(0) - feed
->pid_start
;
4499 fprintf(stderr
, "%s: Pid %d exited with status %d after %d seconds\n", feed
->filename
, pid
, status
, uptime
);
4502 /* Turn off any more restarts */
4503 feed
->child_argv
= 0;
4508 need_to_start_children
= 1;
4511 static void opt_debug(void)
4514 ffserver_daemon
= 0;
4515 logfilename
[0] = '-';
4518 static void opt_show_help(void)
4520 printf("usage: ffserver [options]\n"
4521 "Hyper fast multi format Audio/Video streaming server\n");
4523 show_help_options(options
, "Main options:\n", 0, 0);
4526 static const OptionDef options
[] = {
4527 { "h", OPT_EXIT
, {(void*)opt_show_help
}, "show help" },
4528 { "version", OPT_EXIT
, {(void*)show_version
}, "show version" },
4529 { "L", OPT_EXIT
, {(void*)show_license
}, "show license" },
4530 { "formats", OPT_EXIT
, {(void*)show_formats
}, "show available formats, codecs, protocols, ..." },
4531 { "n", OPT_BOOL
, {(void *)&no_launch
}, "enable no-launch mode" },
4532 { "d", 0, {(void*)opt_debug
}, "enable debug mode" },
4533 { "f", HAS_ARG
| OPT_STRING
, {(void*)&config_filename
}, "use configfile instead of /etc/ffserver.conf", "configfile" },
4537 int main(int argc
, char **argv
)
4539 struct sigaction sigact
;
4545 config_filename
= "/etc/ffserver.conf";
4547 my_program_name
= argv
[0];
4548 my_program_dir
= getcwd(0, 0);
4549 ffserver_daemon
= 1;
4551 parse_options(argc
, argv
, options
, NULL
);
4553 unsetenv("http_proxy"); /* Kill the http_proxy */
4555 av_lfg_init(&random_state
, ff_random_get_seed());
4557 memset(&sigact
, 0, sizeof(sigact
));
4558 sigact
.sa_handler
= handle_child_exit
;
4559 sigact
.sa_flags
= SA_NOCLDSTOP
| SA_RESTART
;
4560 sigaction(SIGCHLD
, &sigact
, 0);
4562 if (parse_ffconfig(config_filename
) < 0) {
4563 fprintf(stderr
, "Incorrect config file - exiting.\n");
4567 /* open log file if needed */
4568 if (logfilename
[0] != '\0') {
4569 if (!strcmp(logfilename
, "-"))
4572 logfile
= fopen(logfilename
, "a");
4573 av_log_set_callback(http_av_log
);
4576 build_file_streams();
4578 build_feed_streams();
4580 compute_bandwidth();
4582 /* put the process in background and detach it from its TTY */
4583 if (ffserver_daemon
) {
4590 } else if (pid
> 0) {
4597 open("/dev/null", O_RDWR
);
4598 if (strcmp(logfilename
, "-") != 0) {
4608 signal(SIGPIPE
, SIG_IGN
);
4610 if (ffserver_daemon
)
4613 if (http_server() < 0) {
4614 http_log("Could not start server\n");