2001-07-22 16:37:44 +02:00
/*
* Multiple format streaming server
2002-05-26 00:26:19 +02:00
* Copyright ( c ) 2000 , 2001 , 2002 Fabrice Bellard
2001-07-22 16:37:44 +02:00
*
2006-10-07 17:30:46 +02:00
* This file is part of FFmpeg .
*
* FFmpeg is free software ; you can redistribute it and / or
2002-05-26 00:26:19 +02:00
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation ; either
2006-10-07 17:30:46 +02:00
* version 2.1 of the License , or ( at your option ) any later version .
2001-07-22 16:37:44 +02:00
*
2006-10-07 17:30:46 +02:00
* FFmpeg is distributed in the hope that it will be useful ,
2001-07-22 16:37:44 +02:00
* but WITHOUT ANY WARRANTY ; without even the implied warranty of
2002-05-26 00:26:19 +02:00
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE . See the GNU
* Lesser General Public License for more details .
2001-07-22 16:37:44 +02:00
*
2002-05-26 00:26:19 +02:00
* You should have received a copy of the GNU Lesser General Public
2006-10-07 17:30:46 +02:00
* License along with FFmpeg ; if not , write to the Free Software
2006-01-12 23:43:26 +01:00
* Foundation , Inc . , 51 Franklin Street , Fifth Floor , Boston , MA 02110 - 1301 USA
2001-07-22 16:37:44 +02:00
*/
2002-05-26 00:26:19 +02:00
# define HAVE_AV_CONFIG_H
# include "avformat.h"
2001-07-22 16:37:44 +02:00
# include <stdarg.h>
# include <unistd.h>
# include <fcntl.h>
# include <sys/ioctl.h>
2007-02-15 08:44:10 +01:00
# ifdef HAVE_SYS_POLL_H
2001-07-22 16:37:44 +02:00
# include <sys/poll.h>
2007-02-15 08:44:10 +01:00
# endif
2001-07-22 16:37:44 +02:00
# include <errno.h>
# include <sys/time.h>
2004-04-06 08:31:12 +02:00
# undef time //needed because HAVE_AV_CONFIG_H is defined on top
2001-07-22 16:37:44 +02:00
# include <time.h>
# include <sys/types.h>
# include <sys/socket.h>
2002-06-10 04:44:36 +02:00
# include <sys/wait.h>
2002-11-26 06:01:36 +01:00
# include <netinet/in.h>
2002-11-10 12:46:59 +01:00
# include <arpa/inet.h>
2001-07-22 16:37:44 +02:00
# include <netdb.h>
# include <signal.h>
2006-11-15 00:53:37 +01:00
# ifdef HAVE_DLFCN_H
2002-07-25 18:48:44 +02:00
# include <dlfcn.h>
2002-11-30 18:18:59 +01:00
# endif
2002-07-25 18:48:44 +02:00
2006-06-20 12:24:08 +02:00
# include "version.h"
2002-07-25 18:48:44 +02:00
# include "ffserver.h"
2007-02-21 14:50:32 +01:00
# include "random.h"
2001-07-22 16:37:44 +02:00
2007-03-27 23:47:03 +02:00
# undef exit
2001-07-22 16:37:44 +02:00
/* maximum number of simultaneous HTTP connections */
# define HTTP_MAX_CONNECTIONS 2000
enum HTTPState {
HTTPSTATE_WAIT_REQUEST ,
HTTPSTATE_SEND_HEADER ,
HTTPSTATE_SEND_DATA_HEADER ,
2002-07-25 18:48:44 +02:00
HTTPSTATE_SEND_DATA , /* sending TCP or UDP data */
2001-07-22 16:37:44 +02:00
HTTPSTATE_SEND_DATA_TRAILER ,
2005-12-17 19:14:38 +01:00
HTTPSTATE_RECEIVE_DATA ,
2002-07-25 18:48:44 +02:00
HTTPSTATE_WAIT_FEED , /* wait for data from the feed */
HTTPSTATE_READY ,
RTSPSTATE_WAIT_REQUEST ,
RTSPSTATE_SEND_REPLY ,
2003-07-17 12:31:23 +02:00
RTSPSTATE_SEND_PACKET ,
2001-07-22 16:37:44 +02:00
} ;
const char * http_state [ ] = {
2002-07-25 18:48:44 +02:00
" HTTP_WAIT_REQUEST " ,
" HTTP_SEND_HEADER " ,
2001-07-22 16:37:44 +02:00
" SEND_DATA_HEADER " ,
" SEND_DATA " ,
" SEND_DATA_TRAILER " ,
" RECEIVE_DATA " ,
" WAIT_FEED " ,
2002-07-25 18:48:44 +02:00
" READY " ,
" RTSP_WAIT_REQUEST " ,
" RTSP_SEND_REPLY " ,
2003-07-17 12:31:23 +02:00
" RTSP_SEND_PACKET " ,
2001-07-22 16:37:44 +02:00
} ;
2002-05-30 04:49:07 +02:00
# define IOBUFFER_INIT_SIZE 8192
2001-07-22 16:37:44 +02:00
/* timeouts are in ms */
2002-07-25 18:48:44 +02:00
# define HTTP_REQUEST_TIMEOUT (15 * 1000)
# define RTSP_REQUEST_TIMEOUT (3600 * 24 * 1000)
2001-07-22 16:37:44 +02:00
# define SYNC_TIMEOUT (10 * 1000)
2002-06-10 04:44:36 +02:00
typedef struct {
2003-02-11 17:35:48 +01:00
int64_t count1 , count2 ;
2007-02-24 03:39:57 +01:00
int64_t time1 , time2 ;
2002-06-10 04:44:36 +02:00
} DataRateData ;
2001-07-22 16:37:44 +02:00
/* context associated with one connection */
typedef struct HTTPContext {
enum HTTPState state ;
int fd ; /* socket file descriptor */
struct sockaddr_in from_addr ; /* origin */
struct pollfd * poll_entry ; /* used when polling */
2007-02-24 03:39:57 +01:00
int64_t timeout ;
2003-02-11 17:35:48 +01:00
uint8_t * buffer_ptr , * buffer_end ;
2001-07-22 16:37:44 +02:00
int http_error ;
2005-10-14 19:29:00 +02:00
int post ;
2001-07-22 16:37:44 +02:00
struct HTTPContext * next ;
2002-05-16 04:03:07 +02:00
int got_key_frame ; /* stream 0 => 1, stream 1 => 2, stream 2=> 4 */
2003-02-11 17:35:48 +01:00
int64_t data_count ;
2001-07-22 16:37:44 +02:00
/* feed input */
int feed_fd ;
/* input format handling */
AVFormatContext * fmt_in ;
2007-02-24 03:39:57 +01:00
int64_t start_time ; /* In milliseconds - this wraps fairly often */
2003-02-11 17:35:48 +01:00
int64_t first_pts ; /* initial pts value */
2003-11-10 20:02:56 +01:00
int64_t cur_pts ; /* current pts value from the stream in us */
int64_t cur_frame_duration ; /* duration of the current frame in us */
int cur_frame_bytes ; /* output frame size, needed to compute
the time at which we send each
packet */
int pts_stream_index ; /* stream we choose as clock reference */
int64_t cur_clock ; /* current clock reference value in us */
2001-07-22 16:37:44 +02:00
/* output format handling */
struct FFStream * stream ;
2002-05-30 04:49:07 +02:00
/* -1 is invalid stream */
int feed_streams [ MAX_STREAMS ] ; /* index of streams in the feed */
int switch_feed_streams [ MAX_STREAMS ] ; /* index of streams in the feed */
int switch_pending ;
2002-07-25 18:48:44 +02:00
AVFormatContext fmt_ctx ; /* instance of FFStream for one user */
2001-07-22 16:37:44 +02:00
int last_packet_sent ; /* true if last data packet was sent */
2002-05-10 04:20:27 +02:00
int suppress_log ;
2002-06-10 04:44:36 +02:00
DataRateData datarate ;
2002-05-26 05:36:34 +02:00
int wmp_client_id ;
2002-05-10 04:20:27 +02:00
char protocol [ 16 ] ;
char method [ 16 ] ;
char url [ 128 ] ;
2002-05-30 04:49:07 +02:00
int buffer_size ;
2003-02-11 17:35:48 +01:00
uint8_t * buffer ;
2002-07-25 18:48:44 +02:00
int is_packetized ; /* if true, the stream is packetized */
int packet_stream_index ; /* current stream for output in state machine */
2005-12-17 19:14:38 +01:00
2002-07-25 18:48:44 +02:00
/* RTSP state specific */
2003-02-11 17:35:48 +01:00
uint8_t * pb_buffer ; /* XXX: use that in all the code */
2002-07-25 18:48:44 +02:00
ByteIOContext * pb ;
int seq ; /* RTSP sequence number */
2005-12-17 19:14:38 +01:00
2002-07-25 18:48:44 +02:00
/* RTP state specific */
enum RTSPProtocol rtp_protocol ;
char session_id [ 32 ] ; /* session id */
AVFormatContext * rtp_ctx [ MAX_STREAMS ] ;
2003-11-10 20:02:56 +01:00
2003-07-17 12:31:23 +02:00
/* RTP/UDP specific */
URLContext * rtp_handles [ MAX_STREAMS ] ;
/* RTP/TCP specific */
struct HTTPContext * rtsp_c ;
uint8_t * packet_buffer , * packet_buffer_ptr , * packet_buffer_end ;
2001-07-22 16:37:44 +02:00
} HTTPContext ;
2002-12-11 04:16:51 +01:00
static AVFrame dummy_frame ;
2001-07-22 16:37:44 +02:00
/* each generated stream is described here */
enum StreamType {
STREAM_TYPE_LIVE ,
STREAM_TYPE_STATUS ,
2002-05-30 04:49:07 +02:00
STREAM_TYPE_REDIRECT ,
2001-07-22 16:37:44 +02:00
} ;
2002-07-27 05:03:04 +02:00
enum IPAddressAction {
IP_ALLOW = 1 ,
IP_DENY ,
} ;
typedef struct IPAddressACL {
struct IPAddressACL * next ;
enum IPAddressAction action ;
2003-02-23 21:35:47 +01:00
/* These are in host order */
2002-07-27 05:03:04 +02:00
struct in_addr first ;
struct in_addr last ;
} IPAddressACL ;
2001-07-22 16:37:44 +02:00
/* description of each stream of the ffserver.conf file */
typedef struct FFStream {
enum StreamType stream_type ;
char filename [ 1024 ] ; /* stream filename */
2002-07-25 18:48:44 +02:00
struct FFStream * feed ; /* feed we are using (can be null if
coming from file ) */
2003-11-10 20:02:56 +01:00
AVFormatParameters * ap_in ; /* input parameters */
AVInputFormat * ifmt ; /* if non NULL, force input format */
2002-05-20 18:33:46 +02:00
AVOutputFormat * fmt ;
2002-07-27 05:03:04 +02:00
IPAddressACL * acl ;
2001-07-22 16:37:44 +02:00
int nb_streams ;
2002-05-16 04:03:07 +02:00
int prebuffer ; /* Number of millseconds early to start */
2007-02-24 03:39:57 +01:00
int64_t max_time ; /* Number of milliseconds to run */
2002-05-17 03:53:28 +02:00
int send_on_key ;
2001-07-22 16:37:44 +02:00
AVStream * streams [ MAX_STREAMS ] ;
int feed_streams [ MAX_STREAMS ] ; /* index of streams in the feed */
char feed_filename [ 1024 ] ; /* file name of the feed storage, or
input file name for a stream */
2002-06-05 04:17:06 +02:00
char author [ 512 ] ;
char title [ 512 ] ;
char copyright [ 512 ] ;
char comment [ 512 ] ;
2002-05-30 04:49:07 +02:00
pid_t pid ; /* Of ffmpeg process */
2002-06-10 04:44:36 +02:00
time_t pid_start ; /* Of ffmpeg process */
2002-05-30 04:49:07 +02:00
char * * child_argv ;
2001-07-22 16:37:44 +02:00
struct FFStream * next ;
2002-11-20 19:05:45 +01:00
int bandwidth ; /* bandwidth, in kbits/s */
2002-07-25 18:48:44 +02:00
/* RTSP options */
char * rtsp_option ;
2002-11-20 16:00:05 +01:00
/* multicast specific */
int is_multicast ;
struct in_addr multicast_ip ;
int multicast_port ; /* first port used for multicast */
2002-11-20 19:05:45 +01:00
int multicast_ttl ;
int loop ; /* if true, send the stream in loops (only meaningful if file) */
2002-11-20 16:00:05 +01:00
2001-07-22 16:37:44 +02:00
/* feed specific */
2002-07-25 18:48:44 +02:00
int feed_opened ; /* true if someone is writing to the feed */
2001-07-22 16:37:44 +02:00
int is_feed ; /* true if it is a feed */
2003-04-09 04:16:01 +02:00
int readonly ; /* True if writing is prohibited to the file */
2002-05-18 23:33:05 +02:00
int conns_served ;
2003-02-11 17:35:48 +01:00
int64_t bytes_served ;
2005-11-13 04:26:43 +01:00
int64_t feed_max_size ; /* maximum storage size, zero means unlimited */
2003-02-11 17:35:48 +01:00
int64_t feed_write_index ; /* current write position in feed (it wraps round) */
int64_t feed_size ; /* current size of feed */
2001-07-22 16:37:44 +02:00
struct FFStream * next_feed ;
} FFStream ;
typedef struct FeedData {
long long data_count ;
float avg_frame_size ; /* frame size averraged over last frames with exponential mean */
} FeedData ;
2002-07-25 18:48:44 +02:00
struct sockaddr_in my_http_addr ;
struct sockaddr_in my_rtsp_addr ;
2006-02-21 22:15:19 +01:00
static char logfilename [ 1024 ] ;
static HTTPContext * first_http_ctx ;
static FFStream * first_feed ; /* contains only feeds */
static FFStream * first_stream ; /* contains all streams, including feeds */
2001-07-22 16:37:44 +02:00
2002-07-25 18:48:44 +02:00
static void new_connection ( int server_fd , int is_rtsp ) ;
static void close_connection ( HTTPContext * c ) ;
/* HTTP handling */
static int handle_connection ( HTTPContext * c ) ;
2001-07-22 16:37:44 +02:00
static int http_parse_request ( HTTPContext * c ) ;
2002-06-10 04:44:36 +02:00
static int http_send_data ( HTTPContext * c ) ;
2001-07-22 16:37:44 +02:00
static void compute_stats ( HTTPContext * c ) ;
static int open_input_stream ( HTTPContext * c , const char * info ) ;
static int http_start_receive_data ( HTTPContext * c ) ;
static int http_receive_data ( HTTPContext * c ) ;
2002-07-25 18:48:44 +02:00
/* RTSP handling */
static int rtsp_parse_request ( HTTPContext * c ) ;
static void rtsp_cmd_describe ( HTTPContext * c , const char * url ) ;
2003-04-04 15:29:58 +02:00
static void rtsp_cmd_options ( HTTPContext * c , const char * url ) ;
2002-07-25 18:48:44 +02:00
static void rtsp_cmd_setup ( HTTPContext * c , const char * url , RTSPHeader * h ) ;
static void rtsp_cmd_play ( HTTPContext * c , const char * url , RTSPHeader * h ) ;
static void rtsp_cmd_pause ( HTTPContext * c , const char * url , RTSPHeader * h ) ;
static void rtsp_cmd_teardown ( HTTPContext * c , const char * url , RTSPHeader * h ) ;
2002-11-20 16:00:05 +01:00
/* SDP handling */
2005-12-17 19:14:38 +01:00
static int prepare_sdp_description ( FFStream * stream , uint8_t * * pbuffer ,
2002-11-20 16:00:05 +01:00
struct in_addr my_ip ) ;
2002-07-25 18:48:44 +02:00
/* RTP handling */
2005-12-17 19:14:38 +01:00
static HTTPContext * rtp_new_connection ( struct sockaddr_in * from_addr ,
2003-07-17 12:31:23 +02:00
FFStream * stream , const char * session_id ,
enum RTSPProtocol rtp_protocol ) ;
2005-12-17 19:14:38 +01:00
static int rtp_new_av_stream ( HTTPContext * c ,
2003-07-17 12:31:23 +02:00
int stream_index , struct sockaddr_in * dest_addr ,
HTTPContext * rtsp_c ) ;
2001-07-22 16:37:44 +02:00
2002-05-30 04:49:07 +02:00
static const char * my_program_name ;
2002-10-30 03:15:07 +01:00
static const char * my_program_dir ;
2002-05-30 04:49:07 +02:00
2002-06-05 04:17:06 +02:00
static int ffserver_debug ;
2002-07-25 18:48:44 +02:00
static int ffserver_daemon ;
2002-06-05 04:17:06 +02:00
static int no_launch ;
2002-06-10 04:44:36 +02:00
static int need_to_start_children ;
2002-06-05 04:17:06 +02:00
2006-02-21 22:15:19 +01:00
static int nb_max_connections ;
static int nb_connections ;
2001-07-22 16:37:44 +02:00
2006-02-21 22:15:19 +01:00
static int max_bandwidth ;
static int current_bandwidth ;
2002-05-16 04:03:07 +02:00
2007-02-24 03:39:57 +01:00
static int64_t cur_time ; // Making this global saves on passing it around everywhere
2002-06-10 04:44:36 +02:00
2007-02-21 14:50:32 +01:00
static AVRandomState random_state ;
2001-07-22 16:37:44 +02:00
static FILE * logfile = NULL ;
2005-12-17 19:14:38 +01:00
static void __attribute__ ( ( format ( printf , 1 , 2 ) ) ) http_log ( const char * fmt , . . . )
2001-07-22 16:37:44 +02:00
{
va_list ap ;
va_start ( ap , fmt ) ;
2005-12-17 19:14:38 +01:00
2002-05-10 04:20:27 +02:00
if ( logfile ) {
2001-07-22 16:37:44 +02:00
vfprintf ( logfile , fmt , ap ) ;
2002-05-10 04:20:27 +02:00
fflush ( logfile ) ;
}
2001-07-22 16:37:44 +02:00
va_end ( ap ) ;
}
2002-11-20 19:05:45 +01:00
static char * ctime1 ( char * buf2 )
2002-05-10 04:20:27 +02:00
{
time_t ti ;
2002-11-20 19:05:45 +01:00
char * p ;
2002-05-10 04:20:27 +02:00
ti = time ( NULL ) ;
p = ctime ( & ti ) ;
strcpy ( buf2 , p ) ;
p = buf2 + strlen ( p ) - 1 ;
if ( * p = = ' \n ' )
* p = ' \0 ' ;
2002-11-20 19:05:45 +01:00
return buf2 ;
}
static void log_connection ( HTTPContext * c )
{
char buf2 [ 32 ] ;
2005-12-17 19:14:38 +01:00
if ( c - > suppress_log )
2002-11-20 19:05:45 +01:00
return ;
2005-12-17 19:14:38 +01:00
http_log ( " %s - - [%s] \" %s %s %s \" %d % " PRId64 " \n " ,
inet_ntoa ( c - > from_addr . sin_addr ) ,
ctime1 ( buf2 ) , c - > method , c - > url ,
2002-11-20 19:05:45 +01:00
c - > protocol , ( c - > http_error ? c - > http_error : 200 ) , c - > data_count ) ;
2002-05-30 04:49:07 +02:00
}
2003-02-11 17:35:48 +01:00
static void update_datarate ( DataRateData * drd , int64_t count )
2002-06-10 04:44:36 +02:00
{
if ( ! drd - > time1 & & ! drd - > count1 ) {
drd - > time1 = drd - > time2 = cur_time ;
drd - > count1 = drd - > count2 = count ;
} else {
if ( cur_time - drd - > time2 > 5000 ) {
drd - > time1 = drd - > time2 ;
drd - > count1 = drd - > count2 ;
drd - > time2 = cur_time ;
drd - > count2 = count ;
}
}
}
/* In bytes per second */
2003-02-11 17:35:48 +01:00
static int compute_datarate ( DataRateData * drd , int64_t count )
2002-06-10 04:44:36 +02:00
{
if ( cur_time = = drd - > time1 )
return 0 ;
2005-12-17 19:14:38 +01:00
2002-06-10 04:44:36 +02:00
return ( ( count - drd - > count1 ) * 1000 ) / ( cur_time - drd - > time1 ) ;
}
2002-09-12 04:31:11 +02:00
2002-05-30 04:49:07 +02:00
static void start_children ( FFStream * feed )
{
2002-06-05 04:17:06 +02:00
if ( no_launch )
return ;
2002-05-30 04:49:07 +02:00
for ( ; feed ; feed = feed - > next ) {
2002-06-10 04:44:36 +02:00
if ( feed - > child_argv & & ! feed - > pid ) {
feed - > pid_start = time ( 0 ) ;
2002-05-30 04:49:07 +02:00
feed - > pid = fork ( ) ;
if ( feed - > pid < 0 ) {
fprintf ( stderr , " Unable to create children \n " ) ;
exit ( 1 ) ;
}
if ( ! feed - > pid ) {
/* In child */
char pathname [ 1024 ] ;
char * slash ;
int i ;
2002-06-10 04:44:36 +02:00
for ( i = 3 ; i < 256 ; i + + ) {
close ( i ) ;
}
2002-05-30 04:49:07 +02:00
2002-06-10 04:44:36 +02:00
if ( ! ffserver_debug ) {
2002-06-05 04:17:06 +02:00
i = open ( " /dev/null " , O_RDWR ) ;
if ( i )
dup2 ( i , 0 ) ;
dup2 ( i , 1 ) ;
dup2 ( i , 2 ) ;
2002-06-10 04:44:36 +02:00
if ( i )
close ( i ) ;
2002-06-05 04:17:06 +02:00
}
2002-05-30 04:49:07 +02:00
pstrcpy ( pathname , sizeof ( pathname ) , my_program_name ) ;
slash = strrchr ( pathname , ' / ' ) ;
if ( ! slash ) {
slash = pathname ;
} else {
slash + + ;
}
strcpy ( slash , " ffmpeg " ) ;
2002-10-30 03:15:07 +01:00
/* This is needed to make relative pathnames work */
chdir ( my_program_dir ) ;
2002-12-11 04:16:51 +01:00
signal ( SIGPIPE , SIG_DFL ) ;
2002-05-30 04:49:07 +02:00
execvp ( pathname , feed - > child_argv ) ;
_exit ( 1 ) ;
}
}
}
2002-05-10 04:20:27 +02:00
}
2002-07-25 18:48:44 +02:00
/* open a listening socket */
static int socket_open_listen ( struct sockaddr_in * my_addr )
2001-07-22 16:37:44 +02:00
{
2002-07-25 18:48:44 +02:00
int server_fd , tmp ;
2001-07-22 16:37:44 +02:00
server_fd = socket ( AF_INET , SOCK_STREAM , 0 ) ;
if ( server_fd < 0 ) {
perror ( " socket " ) ;
return - 1 ;
}
2005-12-17 19:14:38 +01:00
2001-07-22 16:37:44 +02:00
tmp = 1 ;
setsockopt ( server_fd , SOL_SOCKET , SO_REUSEADDR , & tmp , sizeof ( tmp ) ) ;
2002-07-25 18:48:44 +02:00
if ( bind ( server_fd , ( struct sockaddr * ) my_addr , sizeof ( * my_addr ) ) < 0 ) {
2003-01-06 00:09:01 +01:00
char bindmsg [ 32 ] ;
snprintf ( bindmsg , sizeof ( bindmsg ) , " bind(port %d) " , ntohs ( my_addr - > sin_port ) ) ;
perror ( bindmsg ) ;
2007-02-22 13:17:25 +01:00
closesocket ( server_fd ) ;
2001-07-22 16:37:44 +02:00
return - 1 ;
}
2005-12-17 19:14:38 +01:00
2001-07-22 16:37:44 +02:00
if ( listen ( server_fd , 5 ) < 0 ) {
perror ( " listen " ) ;
2007-02-22 13:17:25 +01:00
closesocket ( server_fd ) ;
2001-07-22 16:37:44 +02:00
return - 1 ;
}
2002-07-25 18:48:44 +02:00
fcntl ( server_fd , F_SETFL , O_NONBLOCK ) ;
return server_fd ;
}
2002-11-20 19:05:45 +01:00
/* start all multicast streams */
static void start_multicast ( void )
{
FFStream * stream ;
char session_id [ 32 ] ;
HTTPContext * rtp_c ;
struct sockaddr_in dest_addr ;
int default_port , stream_index ;
default_port = 6000 ;
for ( stream = first_stream ; stream ! = NULL ; stream = stream - > next ) {
if ( stream - > is_multicast ) {
/* open the RTP connection */
2007-02-21 14:50:32 +01:00
snprintf ( session_id , sizeof ( session_id ) , " %08x%08x " ,
av_random ( & random_state ) , av_random ( & random_state ) ) ;
2002-11-20 19:05:45 +01:00
/* choose a port if none given */
if ( stream - > multicast_port = = 0 ) {
stream - > multicast_port = default_port ;
default_port + = 100 ;
}
dest_addr . sin_family = AF_INET ;
dest_addr . sin_addr = stream - > multicast_ip ;
dest_addr . sin_port = htons ( stream - > multicast_port ) ;
2005-12-17 19:14:38 +01:00
rtp_c = rtp_new_connection ( & dest_addr , stream , session_id ,
2003-07-17 12:31:23 +02:00
RTSP_PROTOCOL_RTP_UDP_MULTICAST ) ;
2002-11-20 19:05:45 +01:00
if ( ! rtp_c ) {
continue ;
}
if ( open_input_stream ( rtp_c , " " ) < 0 ) {
2005-12-17 19:14:38 +01:00
fprintf ( stderr , " Could not open input stream for stream '%s' \n " ,
2002-11-20 19:05:45 +01:00
stream - > filename ) ;
continue ;
}
/* open each RTP stream */
2005-12-17 19:14:38 +01:00
for ( stream_index = 0 ; stream_index < stream - > nb_streams ;
2002-11-20 19:05:45 +01:00
stream_index + + ) {
2005-12-17 19:14:38 +01:00
dest_addr . sin_port = htons ( stream - > multicast_port +
2002-11-20 19:05:45 +01:00
2 * stream_index ) ;
2003-07-17 12:31:23 +02:00
if ( rtp_new_av_stream ( rtp_c , stream_index , & dest_addr , NULL ) < 0 ) {
2005-12-17 19:14:38 +01:00
fprintf ( stderr , " Could not open output stream '%s/streamid=%d' \n " ,
2002-11-20 21:49:47 +01:00
stream - > filename , stream_index ) ;
exit ( 1 ) ;
2002-11-20 19:05:45 +01:00
}
}
/* change state to send data */
rtp_c - > state = HTTPSTATE_SEND_DATA ;
}
}
}
2002-07-25 18:48:44 +02:00
/* main loop of the http server */
static int http_server ( void )
{
int server_fd , ret , rtsp_server_fd , delay , delay1 ;
struct pollfd poll_table [ HTTP_MAX_CONNECTIONS + 2 ] , * poll_entry ;
HTTPContext * c , * c_next ;
server_fd = socket_open_listen ( & my_http_addr ) ;
if ( server_fd < 0 )
return - 1 ;
2001-07-22 16:37:44 +02:00
2002-07-25 18:48:44 +02:00
rtsp_server_fd = socket_open_listen ( & my_rtsp_addr ) ;
if ( rtsp_server_fd < 0 )
return - 1 ;
2005-12-17 19:14:38 +01:00
2001-07-22 16:37:44 +02:00
http_log ( " ffserver started. \n " ) ;
2002-05-30 04:49:07 +02:00
start_children ( first_feed ) ;
2001-07-22 16:37:44 +02:00
first_http_ctx = NULL ;
nb_connections = 0 ;
2002-11-20 19:05:45 +01:00
start_multicast ( ) ;
2001-07-22 16:37:44 +02:00
for ( ; ; ) {
poll_entry = poll_table ;
poll_entry - > fd = server_fd ;
poll_entry - > events = POLLIN ;
poll_entry + + ;
2002-07-25 18:48:44 +02:00
poll_entry - > fd = rtsp_server_fd ;
poll_entry - > events = POLLIN ;
poll_entry + + ;
2001-07-22 16:37:44 +02:00
/* wait for events on each HTTP handle */
c = first_http_ctx ;
2002-07-25 18:48:44 +02:00
delay = 1000 ;
2001-07-22 16:37:44 +02:00
while ( c ! = NULL ) {
int fd ;
fd = c - > fd ;
switch ( c - > state ) {
2002-07-25 18:48:44 +02:00
case HTTPSTATE_SEND_HEADER :
case RTSPSTATE_SEND_REPLY :
2003-07-17 12:31:23 +02:00
case RTSPSTATE_SEND_PACKET :
2001-07-22 16:37:44 +02:00
c - > poll_entry = poll_entry ;
poll_entry - > fd = fd ;
2002-07-25 18:48:44 +02:00
poll_entry - > events = POLLOUT ;
2001-07-22 16:37:44 +02:00
poll_entry + + ;
break ;
case HTTPSTATE_SEND_DATA_HEADER :
case HTTPSTATE_SEND_DATA :
case HTTPSTATE_SEND_DATA_TRAILER :
2002-07-25 18:48:44 +02:00
if ( ! c - > is_packetized ) {
/* for TCP, we output as much as we can (may need to put a limit) */
c - > poll_entry = poll_entry ;
poll_entry - > fd = fd ;
poll_entry - > events = POLLOUT ;
poll_entry + + ;
} else {
2003-11-10 20:02:56 +01:00
/* when ffserver is doing the timing, we work by
looking at which packet need to be sent every
10 ms */
delay1 = 10 ; /* one tick wait XXX: 10 ms assumed */
if ( delay1 < delay )
delay = delay1 ;
2002-07-25 18:48:44 +02:00
}
2001-07-22 16:37:44 +02:00
break ;
2002-07-25 18:48:44 +02:00
case HTTPSTATE_WAIT_REQUEST :
2001-07-22 16:37:44 +02:00
case HTTPSTATE_RECEIVE_DATA :
case HTTPSTATE_WAIT_FEED :
2002-07-25 18:48:44 +02:00
case RTSPSTATE_WAIT_REQUEST :
2001-07-22 16:37:44 +02:00
/* need to catch errors */
c - > poll_entry = poll_entry ;
poll_entry - > fd = fd ;
2002-05-18 23:33:05 +02:00
poll_entry - > events = POLLIN ; /* Maybe this will work */
2001-07-22 16:37:44 +02:00
poll_entry + + ;
break ;
default :
c - > poll_entry = NULL ;
break ;
}
c = c - > next ;
}
/* wait for an event on one connection. We poll at least every
second to handle timeouts */
do {
2002-07-25 18:48:44 +02:00
ret = poll ( poll_table , poll_entry - poll_table , delay ) ;
2004-07-25 13:59:34 +02:00
if ( ret < 0 & & errno ! = EAGAIN & & errno ! = EINTR )
return - 1 ;
2007-04-10 16:40:03 +02:00
} while ( ret < 0 ) ;
2005-12-17 19:14:38 +01:00
2007-02-24 03:39:57 +01:00
cur_time = av_gettime ( ) / 1000 ;
2001-07-22 16:37:44 +02:00
2002-06-10 04:44:36 +02:00
if ( need_to_start_children ) {
need_to_start_children = 0 ;
start_children ( first_feed ) ;
}
2001-07-22 16:37:44 +02:00
/* now handle the events */
2002-07-25 18:48:44 +02:00
for ( c = first_http_ctx ; c ! = NULL ; c = c_next ) {
c_next = c - > next ;
if ( handle_connection ( c ) < 0 ) {
2001-07-22 16:37:44 +02:00
/* close and free the connection */
2002-05-10 04:20:27 +02:00
log_connection ( c ) ;
2002-07-25 18:48:44 +02:00
close_connection ( c ) ;
2001-07-22 16:37:44 +02:00
}
}
poll_entry = poll_table ;
2002-07-25 18:48:44 +02:00
/* new HTTP connection request ? */
2001-07-22 16:37:44 +02:00
if ( poll_entry - > revents & POLLIN ) {
2002-07-25 18:48:44 +02:00
new_connection ( server_fd , 0 ) ;
2001-07-22 16:37:44 +02:00
}
poll_entry + + ;
2002-07-25 18:48:44 +02:00
/* new RTSP connection request ? */
if ( poll_entry - > revents & POLLIN ) {
new_connection ( rtsp_server_fd , 1 ) ;
}
2001-07-22 16:37:44 +02:00
}
}
2002-07-25 18:48:44 +02:00
/* start waiting for a new HTTP/RTSP request */
static void start_wait_request ( HTTPContext * c , int is_rtsp )
2001-07-22 16:37:44 +02:00
{
2002-07-25 18:48:44 +02:00
c - > buffer_ptr = c - > buffer ;
c - > buffer_end = c - > buffer + c - > buffer_size - 1 ; /* leave room for '\0' */
if ( is_rtsp ) {
c - > timeout = cur_time + RTSP_REQUEST_TIMEOUT ;
c - > state = RTSPSTATE_WAIT_REQUEST ;
} else {
c - > timeout = cur_time + HTTP_REQUEST_TIMEOUT ;
c - > state = HTTPSTATE_WAIT_REQUEST ;
}
}
static void new_connection ( int server_fd , int is_rtsp )
{
struct sockaddr_in from_addr ;
int fd , len ;
HTTPContext * c = NULL ;
len = sizeof ( from_addr ) ;
2005-12-17 19:14:38 +01:00
fd = accept ( server_fd , ( struct sockaddr * ) & from_addr ,
2002-07-25 18:48:44 +02:00
& len ) ;
if ( fd < 0 )
return ;
fcntl ( fd , F_SETFL , O_NONBLOCK ) ;
/* XXX: should output a warning page when coming
close to the connection limit */
if ( nb_connections > = nb_max_connections )
goto fail ;
2005-12-17 19:14:38 +01:00
2002-07-25 18:48:44 +02:00
/* add a new connection */
c = av_mallocz ( sizeof ( HTTPContext ) ) ;
if ( ! c )
goto fail ;
2005-12-17 19:14:38 +01:00
2002-07-25 18:48:44 +02:00
c - > fd = fd ;
c - > poll_entry = NULL ;
c - > from_addr = from_addr ;
c - > buffer_size = IOBUFFER_INIT_SIZE ;
c - > buffer = av_malloc ( c - > buffer_size ) ;
if ( ! c - > buffer )
goto fail ;
2003-09-27 03:23:40 +02:00
c - > next = first_http_ctx ;
first_http_ctx = c ;
2002-07-25 18:48:44 +02:00
nb_connections + + ;
2005-12-17 19:14:38 +01:00
2002-07-25 18:48:44 +02:00
start_wait_request ( c , is_rtsp ) ;
return ;
fail :
if ( c ) {
av_free ( c - > buffer ) ;
av_free ( c ) ;
}
2007-02-22 13:17:25 +01:00
closesocket ( fd ) ;
2002-07-25 18:48:44 +02:00
}
static void close_connection ( HTTPContext * c )
{
HTTPContext * * cp , * c1 ;
int i , nb_streams ;
AVFormatContext * ctx ;
URLContext * h ;
AVStream * st ;
/* remove connection from list */
cp = & first_http_ctx ;
while ( ( * cp ) ! = NULL ) {
c1 = * cp ;
if ( c1 = = c ) {
* cp = c - > next ;
} else {
cp = & c1 - > next ;
}
}
2003-07-17 12:31:23 +02:00
/* remove references, if any (XXX: do it faster) */
for ( c1 = first_http_ctx ; c1 ! = NULL ; c1 = c1 - > next ) {
if ( c1 - > rtsp_c = = c )
c1 - > rtsp_c = NULL ;
}
2002-07-25 18:48:44 +02:00
/* remove connection associated resources */
if ( c - > fd > = 0 )
2007-02-22 13:17:25 +01:00
closesocket ( c - > fd ) ;
2002-07-25 18:48:44 +02:00
if ( c - > fmt_in ) {
/* close each frame parser */
for ( i = 0 ; i < c - > fmt_in - > nb_streams ; i + + ) {
st = c - > fmt_in - > streams [ i ] ;
2005-07-18 00:24:36 +02:00
if ( st - > codec - > codec ) {
avcodec_close ( st - > codec ) ;
2002-07-25 18:48:44 +02:00
}
}
av_close_input_file ( c - > fmt_in ) ;
}
/* free RTP output streams if any */
nb_streams = 0 ;
2005-12-17 19:14:38 +01:00
if ( c - > stream )
2002-07-25 18:48:44 +02:00
nb_streams = c - > stream - > nb_streams ;
2005-12-17 19:14:38 +01:00
2002-07-25 18:48:44 +02:00
for ( i = 0 ; i < nb_streams ; i + + ) {
ctx = c - > rtp_ctx [ i ] ;
if ( ctx ) {
av_write_trailer ( ctx ) ;
av_free ( ctx ) ;
}
h = c - > rtp_handles [ i ] ;
if ( h ) {
url_close ( h ) ;
}
}
2005-12-17 19:14:38 +01:00
2003-03-26 11:30:08 +01:00
ctx = & c - > fmt_ctx ;
2003-03-04 04:12:32 +01:00
if ( ! c - > last_packet_sent ) {
if ( ctx - > oformat ) {
/* prepare header */
if ( url_open_dyn_buf ( & ctx - > pb ) > = 0 ) {
av_write_trailer ( ctx ) ;
2003-07-17 12:31:23 +02:00
url_close_dyn_buf ( & ctx - > pb , & c - > pb_buffer ) ;
2003-03-04 04:12:32 +01:00
}
}
}
2005-12-17 19:14:38 +01:00
for ( i = 0 ; i < ctx - > nb_streams ; i + + )
av_free ( ctx - > streams [ i ] ) ;
2003-04-12 04:27:54 +02:00
2005-10-14 19:29:00 +02:00
if ( c - > stream & & ! c - > post & & c - > stream - > stream_type = = STREAM_TYPE_LIVE )
2002-11-20 19:05:45 +01:00
current_bandwidth - = c - > stream - > bandwidth ;
2007-02-22 14:27:39 +01:00
/* signal that there is no feed if we are the feeder socket */
if ( c - > state = = HTTPSTATE_RECEIVE_DATA & & c - > stream ) {
c - > stream - > feed_opened = 0 ;
close ( c - > feed_fd ) ;
}
2002-07-25 18:48:44 +02:00
av_freep ( & c - > pb_buffer ) ;
2003-07-17 12:31:23 +02:00
av_freep ( & c - > packet_buffer ) ;
2002-07-25 18:48:44 +02:00
av_free ( c - > buffer ) ;
av_free ( c ) ;
nb_connections - - ;
}
static int handle_connection ( HTTPContext * c )
{
int len , ret ;
2005-12-17 19:14:38 +01:00
2001-07-22 16:37:44 +02:00
switch ( c - > state ) {
case HTTPSTATE_WAIT_REQUEST :
2002-07-25 18:48:44 +02:00
case RTSPSTATE_WAIT_REQUEST :
2001-07-22 16:37:44 +02:00
/* timeout ? */
if ( ( c - > timeout - cur_time ) < 0 )
return - 1 ;
if ( c - > poll_entry - > revents & ( POLLERR | POLLHUP ) )
return - 1 ;
/* no need to read if no events */
if ( ! ( c - > poll_entry - > revents & POLLIN ) )
return 0 ;
/* read the data */
2003-07-12 00:30:12 +02:00
read_loop :
2007-02-22 13:38:37 +01:00
len = recv ( c - > fd , c - > buffer_ptr , 1 , 0 ) ;
2001-07-22 16:37:44 +02:00
if ( len < 0 ) {
if ( errno ! = EAGAIN & & errno ! = EINTR )
return - 1 ;
} else if ( len = = 0 ) {
return - 1 ;
} else {
2003-06-29 03:25:41 +02:00
/* search for end of request. */
2003-02-11 17:35:48 +01:00
uint8_t * ptr ;
2001-07-22 16:37:44 +02:00
c - > buffer_ptr + = len ;
ptr = c - > buffer_ptr ;
if ( ( ptr > = c - > buffer + 2 & & ! memcmp ( ptr - 2 , " \n \n " , 2 ) ) | |
( ptr > = c - > buffer + 4 & & ! memcmp ( ptr - 4 , " \r \n \r \n " , 4 ) ) ) {
/* request found : parse it and reply */
2002-07-25 18:48:44 +02:00
if ( c - > state = = HTTPSTATE_WAIT_REQUEST ) {
ret = http_parse_request ( c ) ;
} else {
ret = rtsp_parse_request ( c ) ;
}
if ( ret < 0 )
2001-07-22 16:37:44 +02:00
return - 1 ;
} else if ( ptr > = c - > buffer_end ) {
/* request too long: cannot do anything */
return - 1 ;
2003-07-12 00:30:12 +02:00
} else goto read_loop ;
2001-07-22 16:37:44 +02:00
}
break ;
case HTTPSTATE_SEND_HEADER :
if ( c - > poll_entry - > revents & ( POLLERR | POLLHUP ) )
return - 1 ;
2002-07-25 18:48:44 +02:00
/* no need to write if no events */
2001-07-22 16:37:44 +02:00
if ( ! ( c - > poll_entry - > revents & POLLOUT ) )
return 0 ;
2007-02-22 13:38:37 +01:00
len = send ( c - > fd , c - > buffer_ptr , c - > buffer_end - c - > buffer_ptr , 0 ) ;
2001-07-22 16:37:44 +02:00
if ( len < 0 ) {
if ( errno ! = EAGAIN & & errno ! = EINTR ) {
/* error : close connection */
2002-07-25 18:48:44 +02:00
av_freep ( & c - > pb_buffer ) ;
2001-07-22 16:37:44 +02:00
return - 1 ;
}
} else {
c - > buffer_ptr + = len ;
2002-05-20 05:02:09 +02:00
if ( c - > stream )
c - > stream - > bytes_served + = len ;
2002-05-18 23:33:05 +02:00
c - > data_count + = len ;
2001-07-22 16:37:44 +02:00
if ( c - > buffer_ptr > = c - > buffer_end ) {
2002-07-25 18:48:44 +02:00
av_freep ( & c - > pb_buffer ) ;
2001-07-22 16:37:44 +02:00
/* if error, exit */
2002-07-25 18:48:44 +02:00
if ( c - > http_error ) {
2001-07-22 16:37:44 +02:00
return - 1 ;
2002-07-25 18:48:44 +02:00
}
/* all the buffer was sent : synchronize to the incoming stream */
2001-07-22 16:37:44 +02:00
c - > state = HTTPSTATE_SEND_DATA_HEADER ;
c - > buffer_ptr = c - > buffer_end = c - > buffer ;
}
}
break ;
case HTTPSTATE_SEND_DATA :
case HTTPSTATE_SEND_DATA_HEADER :
case HTTPSTATE_SEND_DATA_TRAILER :
2002-07-25 18:48:44 +02:00
/* for packetized output, we consider we can always write (the
input streams sets the speed ) . It may be better to verify
that we do not rely too much on the kernel queues */
if ( ! c - > is_packetized ) {
if ( c - > poll_entry - > revents & ( POLLERR | POLLHUP ) )
return - 1 ;
2005-12-17 19:14:38 +01:00
2002-07-25 18:48:44 +02:00
/* no need to read if no events */
if ( ! ( c - > poll_entry - > revents & POLLOUT ) )
return 0 ;
}
2002-06-10 04:44:36 +02:00
if ( http_send_data ( c ) < 0 )
2001-07-22 16:37:44 +02:00
return - 1 ;
2007-02-24 03:16:12 +01:00
/* close connection if trailer sent */
if ( c - > state = = HTTPSTATE_SEND_DATA_TRAILER )
return - 1 ;
2001-07-22 16:37:44 +02:00
break ;
case HTTPSTATE_RECEIVE_DATA :
/* no need to read if no events */
if ( c - > poll_entry - > revents & ( POLLERR | POLLHUP ) )
return - 1 ;
if ( ! ( c - > poll_entry - > revents & POLLIN ) )
return 0 ;
if ( http_receive_data ( c ) < 0 )
return - 1 ;
break ;
case HTTPSTATE_WAIT_FEED :
/* no need to read if no events */
2002-05-18 23:33:05 +02:00
if ( c - > poll_entry - > revents & ( POLLIN | POLLERR | POLLHUP ) )
2001-07-22 16:37:44 +02:00
return - 1 ;
/* nothing to do, we'll be waken up by incoming feed packets */
break ;
2002-07-25 18:48:44 +02:00
case RTSPSTATE_SEND_REPLY :
if ( c - > poll_entry - > revents & ( POLLERR | POLLHUP ) ) {
av_freep ( & c - > pb_buffer ) ;
return - 1 ;
}
/* no need to write if no events */
if ( ! ( c - > poll_entry - > revents & POLLOUT ) )
return 0 ;
2007-02-22 13:38:37 +01:00
len = send ( c - > fd , c - > buffer_ptr , c - > buffer_end - c - > buffer_ptr , 0 ) ;
2002-07-25 18:48:44 +02:00
if ( len < 0 ) {
if ( errno ! = EAGAIN & & errno ! = EINTR ) {
/* error : close connection */
av_freep ( & c - > pb_buffer ) ;
return - 1 ;
}
} else {
c - > buffer_ptr + = len ;
c - > data_count + = len ;
if ( c - > buffer_ptr > = c - > buffer_end ) {
/* all the buffer was sent : wait for a new request */
av_freep ( & c - > pb_buffer ) ;
start_wait_request ( c , 1 ) ;
}
}
break ;
2003-07-17 12:31:23 +02:00
case RTSPSTATE_SEND_PACKET :
if ( c - > poll_entry - > revents & ( POLLERR | POLLHUP ) ) {
av_freep ( & c - > packet_buffer ) ;
return - 1 ;
}
/* no need to write if no events */
if ( ! ( c - > poll_entry - > revents & POLLOUT ) )
return 0 ;
2007-02-22 13:38:37 +01:00
len = send ( c - > fd , c - > packet_buffer_ptr ,
c - > packet_buffer_end - c - > packet_buffer_ptr , 0 ) ;
2003-07-17 12:31:23 +02:00
if ( len < 0 ) {
if ( errno ! = EAGAIN & & errno ! = EINTR ) {
/* error : close connection */
av_freep ( & c - > packet_buffer ) ;
return - 1 ;
}
} else {
c - > packet_buffer_ptr + = len ;
if ( c - > packet_buffer_ptr > = c - > packet_buffer_end ) {
/* all the buffer was sent : wait for a new request */
av_freep ( & c - > packet_buffer ) ;
c - > state = RTSPSTATE_WAIT_REQUEST ;
}
}
break ;
2002-07-25 18:48:44 +02:00
case HTTPSTATE_READY :
/* nothing to do */
break ;
2001-07-22 16:37:44 +02:00
default :
return - 1 ;
}
return 0 ;
}
2002-05-26 05:36:34 +02:00
static int extract_rates ( char * rates , int ratelen , const char * request )
{
const char * p ;
for ( p = request ; * p & & * p ! = ' \r ' & & * p ! = ' \n ' ; ) {
if ( strncasecmp ( p , " Pragma: " , 7 ) = = 0 ) {
const char * q = p + 7 ;
while ( * q & & * q ! = ' \n ' & & isspace ( * q ) )
q + + ;
if ( strncasecmp ( q , " stream-switch-entry= " , 20 ) = = 0 ) {
int stream_no ;
int rate_no ;
q + = 20 ;
2002-05-30 04:49:07 +02:00
memset ( rates , 0xff , ratelen ) ;
2002-05-26 05:36:34 +02:00
while ( 1 ) {
while ( * q & & * q ! = ' \n ' & & * q ! = ' : ' )
q + + ;
if ( sscanf ( q , " :%d:%d " , & stream_no , & rate_no ) ! = 2 ) {
break ;
}
stream_no - - ;
if ( stream_no < ratelen & & stream_no > = 0 ) {
rates [ stream_no ] = rate_no ;
}
while ( * q & & * q ! = ' \n ' & & ! isspace ( * q ) )
q + + ;
}
return 1 ;
}
}
p = strchr ( p , ' \n ' ) ;
if ( ! p )
break ;
p + + ;
}
return 0 ;
}
2002-05-30 04:49:07 +02:00
static int find_stream_in_feed ( FFStream * feed , AVCodecContext * codec , int bit_rate )
2002-05-26 05:36:34 +02:00
{
int i ;
2002-05-30 04:49:07 +02:00
int best_bitrate = 100000000 ;
int best = - 1 ;
for ( i = 0 ; i < feed - > nb_streams ; i + + ) {
2005-07-18 00:24:36 +02:00
AVCodecContext * feed_codec = feed - > streams [ i ] - > codec ;
2002-05-30 04:49:07 +02:00
if ( feed_codec - > codec_id ! = codec - > codec_id | |
feed_codec - > sample_rate ! = codec - > sample_rate | |
feed_codec - > width ! = codec - > width | |
feed_codec - > height ! = codec - > height ) {
continue ;
}
/* Potential stream */
2005-12-17 19:14:38 +01:00
/* We want the fastest stream less than bit_rate, or the slowest
2002-05-30 04:49:07 +02:00
* faster than bit_rate
*/
if ( feed_codec - > bit_rate < = bit_rate ) {
if ( best_bitrate > bit_rate | | feed_codec - > bit_rate > best_bitrate ) {
best_bitrate = feed_codec - > bit_rate ;
best = i ;
}
} else {
if ( feed_codec - > bit_rate < best_bitrate ) {
best_bitrate = feed_codec - > bit_rate ;
best = i ;
}
}
}
return best ;
}
static int modify_current_stream ( HTTPContext * c , char * rates )
{
int i ;
FFStream * req = c - > stream ;
int action_required = 0 ;
2002-05-26 05:36:34 +02:00
2003-01-03 21:00:49 +01:00
/* Not much we can do for a feed */
if ( ! req - > feed )
return 0 ;
2002-05-26 05:36:34 +02:00
for ( i = 0 ; i < req - > nb_streams ; i + + ) {
2005-07-18 00:24:36 +02:00
AVCodecContext * codec = req - > streams [ i ] - > codec ;
2002-05-26 05:36:34 +02:00
switch ( rates [ i ] ) {
case 0 :
2002-05-30 04:49:07 +02:00
c - > switch_feed_streams [ i ] = req - > feed_streams [ i ] ;
2002-05-26 05:36:34 +02:00
break ;
case 1 :
2002-05-30 04:49:07 +02:00
c - > switch_feed_streams [ i ] = find_stream_in_feed ( req - > feed , codec , codec - > bit_rate / 2 ) ;
2002-05-26 05:36:34 +02:00
break ;
case 2 :
2002-05-30 04:49:07 +02:00
/* Wants off or slow */
c - > switch_feed_streams [ i ] = find_stream_in_feed ( req - > feed , codec , codec - > bit_rate / 4 ) ;
# ifdef WANTS_OFF
/* This doesn't work well when it turns off the only stream! */
c - > switch_feed_streams [ i ] = - 2 ;
c - > feed_streams [ i ] = - 2 ;
# endif
2002-05-26 05:36:34 +02:00
break ;
}
2002-05-30 04:49:07 +02:00
if ( c - > switch_feed_streams [ i ] > = 0 & & c - > switch_feed_streams [ i ] ! = c - > feed_streams [ i ] )
action_required = 1 ;
}
2002-05-26 05:36:34 +02:00
2002-05-30 04:49:07 +02:00
return action_required ;
}
2002-05-26 05:36:34 +02:00
2002-05-30 04:49:07 +02:00
static void do_switch_stream ( HTTPContext * c , int i )
{
if ( c - > switch_feed_streams [ i ] > = 0 ) {
2005-12-17 19:14:38 +01:00
# ifdef PHILIP
2002-05-30 04:49:07 +02:00
c - > feed_streams [ i ] = c - > switch_feed_streams [ i ] ;
# endif
2002-05-26 05:36:34 +02:00
2002-05-30 04:49:07 +02:00
/* Now update the stream */
2002-05-26 05:36:34 +02:00
}
2002-05-30 04:49:07 +02:00
c - > switch_feed_streams [ i ] = - 1 ;
2002-05-26 05:36:34 +02:00
}
2002-05-10 04:20:27 +02:00
2002-07-25 18:48:44 +02:00
/* XXX: factorize in utils.c ? */
/* XXX: take care with different space meaning */
static void skip_spaces ( const char * * pp )
{
const char * p ;
p = * pp ;
while ( * p = = ' ' | | * p = = ' \t ' )
p + + ;
* pp = p ;
}
static void get_word ( char * buf , int buf_size , const char * * pp )
{
const char * p ;
char * q ;
p = * pp ;
skip_spaces ( & p ) ;
q = buf ;
while ( ! isspace ( * p ) & & * p ! = ' \0 ' ) {
if ( ( q - buf ) < buf_size - 1 )
* q + + = * p ;
p + + ;
}
if ( buf_size > 0 )
* q = ' \0 ' ;
* pp = p ;
}
2002-07-27 05:03:04 +02:00
static int validate_acl ( FFStream * stream , HTTPContext * c )
{
enum IPAddressAction last_action = IP_DENY ;
IPAddressACL * acl ;
struct in_addr * src = & c - > from_addr . sin_addr ;
2003-02-23 21:35:47 +01:00
unsigned long src_addr = ntohl ( src - > s_addr ) ;
2002-07-27 05:03:04 +02:00
for ( acl = stream - > acl ; acl ; acl = acl - > next ) {
2003-02-23 21:35:47 +01:00
if ( src_addr > = acl - > first . s_addr & & src_addr < = acl - > last . s_addr ) {
2002-07-27 05:03:04 +02:00
return ( acl - > action = = IP_ALLOW ) ? 1 : 0 ;
}
last_action = acl - > action ;
}
/* Nothing matched, so return not the last action */
return ( last_action = = IP_DENY ) ? 1 : 0 ;
}
2002-11-20 16:00:05 +01:00
/* compute the real filename of a file by matching it without its
extensions to all the stream filenames */
static void compute_real_filename ( char * filename , int max_size )
{
char file1 [ 1024 ] ;
char file2 [ 1024 ] ;
char * p ;
FFStream * stream ;
/* compute filename by matching without the file extensions */
pstrcpy ( file1 , sizeof ( file1 ) , filename ) ;
p = strrchr ( file1 , ' . ' ) ;
if ( p )
* p = ' \0 ' ;
for ( stream = first_stream ; stream ! = NULL ; stream = stream - > next ) {
pstrcpy ( file2 , sizeof ( file2 ) , stream - > filename ) ;
p = strrchr ( file2 , ' . ' ) ;
if ( p )
* p = ' \0 ' ;
if ( ! strcmp ( file1 , file2 ) ) {
pstrcpy ( filename , max_size , stream - > filename ) ;
break ;
}
}
}
enum RedirType {
REDIR_NONE ,
REDIR_ASX ,
REDIR_RAM ,
REDIR_ASF ,
REDIR_RTSP ,
REDIR_SDP ,
} ;
2001-07-22 16:37:44 +02:00
/* parse http request and prepare header */
static int http_parse_request ( HTTPContext * c )
{
char * p ;
2002-11-20 16:00:05 +01:00
enum RedirType redir_type ;
2001-07-22 16:37:44 +02:00
char cmd [ 32 ] ;
2007-02-24 04:17:59 +01:00
char info [ 1024 ] , filename [ 1024 ] ;
2001-07-22 16:37:44 +02:00
char url [ 1024 ] , * q ;
char protocol [ 32 ] ;
char msg [ 1024 ] ;
const char * mime_type ;
FFStream * stream ;
2002-05-16 04:03:07 +02:00
int i ;
2002-05-26 05:36:34 +02:00
char ratebuf [ 32 ] ;
2002-05-30 04:49:07 +02:00
char * useragent = 0 ;
2001-07-22 16:37:44 +02:00
p = c - > buffer ;
2002-07-25 18:48:44 +02:00
get_word ( cmd , sizeof ( cmd ) , ( const char * * ) & p ) ;
2002-05-20 18:33:46 +02:00
pstrcpy ( c - > method , sizeof ( c - > method ) , cmd ) ;
2002-05-10 04:20:27 +02:00
2001-07-22 16:37:44 +02:00
if ( ! strcmp ( cmd , " GET " ) )
2005-10-14 19:29:00 +02:00
c - > post = 0 ;
2001-07-22 16:37:44 +02:00
else if ( ! strcmp ( cmd , " POST " ) )
2005-10-14 19:29:00 +02:00
c - > post = 1 ;
2001-07-22 16:37:44 +02:00
else
return - 1 ;
2002-07-25 18:48:44 +02:00
get_word ( url , sizeof ( url ) , ( const char * * ) & p ) ;
2002-05-20 18:33:46 +02:00
pstrcpy ( c - > url , sizeof ( c - > url ) , url ) ;
2002-05-10 04:20:27 +02:00
2002-07-25 18:48:44 +02:00
get_word ( protocol , sizeof ( protocol ) , ( const char * * ) & p ) ;
2001-07-22 16:37:44 +02:00
if ( strcmp ( protocol , " HTTP/1.0 " ) & & strcmp ( protocol , " HTTP/1.1 " ) )
return - 1 ;
2002-05-10 04:20:27 +02:00
2002-05-20 18:33:46 +02:00
pstrcpy ( c - > protocol , sizeof ( c - > protocol ) , protocol ) ;
2005-11-13 04:12:14 +01:00
if ( ffserver_debug )
2005-12-22 02:10:11 +01:00
http_log ( " New connection: %s %s \n " , cmd , url ) ;
2005-12-17 19:14:38 +01:00
2001-07-22 16:37:44 +02:00
/* find the filename and the optional info string in the request */
2007-02-24 04:17:59 +01:00
p = strchr ( url , ' ? ' ) ;
2001-07-22 16:37:44 +02:00
if ( p ) {
2002-05-20 18:33:46 +02:00
pstrcpy ( info , sizeof ( info ) , p ) ;
2001-07-22 16:37:44 +02:00
* p = ' \0 ' ;
} else {
info [ 0 ] = ' \0 ' ;
}
2007-02-24 04:17:59 +01:00
pstrcpy ( filename , sizeof ( filename ) - 1 , url + ( ( * url = = ' / ' ) ? 1 : 0 ) ) ;
2002-05-30 04:49:07 +02:00
for ( p = c - > buffer ; * p & & * p ! = ' \r ' & & * p ! = ' \n ' ; ) {
if ( strncasecmp ( p , " User-Agent: " , 11 ) = = 0 ) {
useragent = p + 11 ;
if ( * useragent & & * useragent ! = ' \n ' & & isspace ( * useragent ) )
useragent + + ;
break ;
}
p = strchr ( p , ' \n ' ) ;
if ( ! p )
break ;
p + + ;
}
2002-11-20 16:00:05 +01:00
redir_type = REDIR_NONE ;
if ( match_ext ( filename , " asx " ) ) {
redir_type = REDIR_ASX ;
2002-05-10 04:20:27 +02:00
filename [ strlen ( filename ) - 1 ] = ' f ' ;
2002-12-21 03:41:22 +01:00
} else if ( match_ext ( filename , " asf " ) & &
2002-05-30 04:49:07 +02:00
( ! useragent | | strncasecmp ( useragent , " NSPlayer " , 8 ) ! = 0 ) ) {
/* if this isn't WMP or lookalike, return the redirector file */
2002-11-20 16:00:05 +01:00
redir_type = REDIR_ASF ;
} else if ( match_ext ( filename , " rpm,ram " ) ) {
redir_type = REDIR_RAM ;
2002-05-16 04:03:07 +02:00
strcpy ( filename + strlen ( filename ) - 2 , " m " ) ;
2002-11-20 16:00:05 +01:00
} else if ( match_ext ( filename , " rtsp " ) ) {
redir_type = REDIR_RTSP ;
2007-02-24 04:17:59 +01:00
compute_real_filename ( filename , sizeof ( filename ) - 1 ) ;
2002-11-20 16:00:05 +01:00
} else if ( match_ext ( filename , " sdp " ) ) {
redir_type = REDIR_SDP ;
2007-02-24 04:17:59 +01:00
compute_real_filename ( filename , sizeof ( filename ) - 1 ) ;
2002-05-16 04:03:07 +02:00
}
2005-12-17 19:14:38 +01:00
2007-02-24 04:17:59 +01:00
// "redirect" / request to index.html
if ( ! strlen ( filename ) )
pstrcpy ( filename , sizeof ( filename ) - 1 , " index.html " ) ;
2001-07-22 16:37:44 +02:00
stream = first_stream ;
while ( stream ! = NULL ) {
2002-07-27 05:03:04 +02:00
if ( ! strcmp ( stream - > filename , filename ) & & validate_acl ( stream , c ) )
2001-07-22 16:37:44 +02:00
break ;
stream = stream - > next ;
}
if ( stream = = NULL ) {
2003-11-19 03:23:17 +01:00
snprintf ( msg , sizeof ( msg ) , " File '%s' not found " , url ) ;
2001-07-22 16:37:44 +02:00
goto send_error ;
}
2002-05-16 04:03:07 +02:00
2002-05-30 04:49:07 +02:00
c - > stream = stream ;
memcpy ( c - > feed_streams , stream - > feed_streams , sizeof ( c - > feed_streams ) ) ;
memset ( c - > switch_feed_streams , - 1 , sizeof ( c - > switch_feed_streams ) ) ;
if ( stream - > stream_type = = STREAM_TYPE_REDIRECT ) {
c - > http_error = 301 ;
q = c - > buffer ;
2003-11-19 03:23:17 +01:00
q + = snprintf ( q , q - ( char * ) c - > buffer + c - > buffer_size , " HTTP/1.0 301 Moved \r \n " ) ;
q + = snprintf ( q , q - ( char * ) c - > buffer + c - > buffer_size , " Location: %s \r \n " , stream - > feed_filename ) ;
q + = snprintf ( q , q - ( char * ) c - > buffer + c - > buffer_size , " Content-type: text/html \r \n " ) ;
q + = snprintf ( q , q - ( char * ) c - > buffer + c - > buffer_size , " \r \n " ) ;
q + = snprintf ( q , q - ( char * ) c - > buffer + c - > buffer_size , " <html><head><title>Moved</title></head><body> \r \n " ) ;
q + = snprintf ( q , q - ( char * ) c - > buffer + c - > buffer_size , " You should be <a href= \" %s \" >redirected</a>. \r \n " , stream - > feed_filename ) ;
q + = snprintf ( q , q - ( char * ) c - > buffer + c - > buffer_size , " </body></html> \r \n " ) ;
2002-05-30 04:49:07 +02:00
/* prepare output buffer */
c - > buffer_ptr = c - > buffer ;
c - > buffer_end = q ;
c - > state = HTTPSTATE_SEND_HEADER ;
return 0 ;
}
2002-05-26 05:36:34 +02:00
/* If this is WMP, get the rate information */
if ( extract_rates ( ratebuf , sizeof ( ratebuf ) , c - > buffer ) ) {
2002-05-30 04:49:07 +02:00
if ( modify_current_stream ( c , ratebuf ) ) {
for ( i = 0 ; i < sizeof ( c - > feed_streams ) / sizeof ( c - > feed_streams [ 0 ] ) ; i + + ) {
if ( c - > switch_feed_streams [ i ] > = 0 )
do_switch_stream ( c , i ) ;
}
}
2002-05-26 05:36:34 +02:00
}
2007-03-06 14:29:04 +01:00
/* If already streaming this feed, dont let start an another feeder */
if ( stream - > feed_opened ) {
snprintf ( msg , sizeof ( msg ) , " This feed is already being received. " ) ;
goto send_error ;
}
2005-10-14 19:29:00 +02:00
if ( c - > post = = 0 & & stream - > stream_type = = STREAM_TYPE_LIVE ) {
2002-11-20 19:05:45 +01:00
current_bandwidth + = stream - > bandwidth ;
2002-05-16 04:03:07 +02:00
}
2005-12-17 19:14:38 +01:00
2005-10-14 19:29:00 +02:00
if ( c - > post = = 0 & & max_bandwidth < current_bandwidth ) {
2002-05-16 04:03:07 +02:00
c - > http_error = 200 ;
q = c - > buffer ;
2003-11-19 03:23:17 +01:00
q + = snprintf ( q , q - ( char * ) c - > buffer + c - > buffer_size , " HTTP/1.0 200 Server too busy \r \n " ) ;
q + = snprintf ( q , q - ( char * ) c - > buffer + c - > buffer_size , " Content-type: text/html \r \n " ) ;
q + = snprintf ( q , q - ( char * ) c - > buffer + c - > buffer_size , " \r \n " ) ;
q + = snprintf ( q , q - ( char * ) c - > buffer + c - > buffer_size , " <html><head><title>Too busy</title></head><body> \r \n " ) ;
2006-02-21 22:15:19 +01:00
q + = snprintf ( q , q - ( char * ) c - > buffer + c - > buffer_size , " <p>The server is too busy to serve your request at this time.</p> \r \n " ) ;
q + = snprintf ( q , q - ( char * ) c - > buffer + c - > buffer_size , " <p>The bandwidth being served (including your stream) is %dkbit/sec, and this exceeds the limit of %dkbit/sec.</p> \r \n " ,
2002-11-20 19:05:45 +01:00
current_bandwidth , max_bandwidth ) ;
2003-11-19 03:23:17 +01:00
q + = snprintf ( q , q - ( char * ) c - > buffer + c - > buffer_size , " </body></html> \r \n " ) ;
2002-05-16 04:03:07 +02:00
/* prepare output buffer */
c - > buffer_ptr = c - > buffer ;
c - > buffer_end = q ;
c - > state = HTTPSTATE_SEND_HEADER ;
return 0 ;
}
2005-12-17 19:14:38 +01:00
2002-11-20 16:00:05 +01:00
if ( redir_type ! = REDIR_NONE ) {
2002-05-10 04:20:27 +02:00
char * hostinfo = 0 ;
2005-12-17 19:14:38 +01:00
2002-05-10 04:20:27 +02:00
for ( p = c - > buffer ; * p & & * p ! = ' \r ' & & * p ! = ' \n ' ; ) {
if ( strncasecmp ( p , " Host: " , 5 ) = = 0 ) {
hostinfo = p + 5 ;
break ;
}
p = strchr ( p , ' \n ' ) ;
if ( ! p )
break ;
p + + ;
}
if ( hostinfo ) {
char * eoh ;
char hostbuf [ 260 ] ;
while ( isspace ( * hostinfo ) )
hostinfo + + ;
eoh = strchr ( hostinfo , ' \n ' ) ;
if ( eoh ) {
if ( eoh [ - 1 ] = = ' \r ' )
eoh - - ;
if ( eoh - hostinfo < sizeof ( hostbuf ) - 1 ) {
memcpy ( hostbuf , hostinfo , eoh - hostinfo ) ;
hostbuf [ eoh - hostinfo ] = 0 ;
c - > http_error = 200 ;
q = c - > buffer ;
2002-11-20 16:00:05 +01:00
switch ( redir_type ) {
case REDIR_ASX :
2003-11-19 03:23:17 +01:00
q + = snprintf ( q , q - ( char * ) c - > buffer + c - > buffer_size , " HTTP/1.0 200 ASX Follows \r \n " ) ;
q + = snprintf ( q , q - ( char * ) c - > buffer + c - > buffer_size , " Content-type: video/x-ms-asf \r \n " ) ;
q + = snprintf ( q , q - ( char * ) c - > buffer + c - > buffer_size , " \r \n " ) ;
q + = snprintf ( q , q - ( char * ) c - > buffer + c - > buffer_size , " <ASX Version= \" 3 \" > \r \n " ) ;
2005-01-03 03:42:02 +01:00
//q += snprintf(q, q - (char *) c->buffer + c->buffer_size, "<!-- Autogenerated by ffserver -->\r\n");
2005-12-17 19:14:38 +01:00
q + = snprintf ( q , q - ( char * ) c - > buffer + c - > buffer_size , " <ENTRY><REF HREF= \" http://%s/%s%s \" /></ENTRY> \r \n " ,
2002-05-16 04:03:07 +02:00
hostbuf , filename , info ) ;
2003-11-19 03:23:17 +01:00
q + = snprintf ( q , q - ( char * ) c - > buffer + c - > buffer_size , " </ASX> \r \n " ) ;
2002-11-20 16:00:05 +01:00
break ;
case REDIR_RAM :
2003-11-19 03:23:17 +01:00
q + = snprintf ( q , q - ( char * ) c - > buffer + c - > buffer_size , " HTTP/1.0 200 RAM Follows \r \n " ) ;
q + = snprintf ( q , q - ( char * ) c - > buffer + c - > buffer_size , " Content-type: audio/x-pn-realaudio \r \n " ) ;
q + = snprintf ( q , q - ( char * ) c - > buffer + c - > buffer_size , " \r \n " ) ;
q + = snprintf ( q , q - ( char * ) c - > buffer + c - > buffer_size , " # Autogenerated by ffserver \r \n " ) ;
2005-12-17 19:14:38 +01:00
q + = snprintf ( q , q - ( char * ) c - > buffer + c - > buffer_size , " http://%s/%s%s \r \n " ,
2002-05-16 04:03:07 +02:00
hostbuf , filename , info ) ;
2002-11-20 16:00:05 +01:00
break ;
case REDIR_ASF :
2003-11-19 03:23:17 +01:00
q + = snprintf ( q , q - ( char * ) c - > buffer + c - > buffer_size , " HTTP/1.0 200 ASF Redirect follows \r \n " ) ;
q + = snprintf ( q , q - ( char * ) c - > buffer + c - > buffer_size , " Content-type: video/x-ms-asf \r \n " ) ;
q + = snprintf ( q , q - ( char * ) c - > buffer + c - > buffer_size , " \r \n " ) ;
q + = snprintf ( q , q - ( char * ) c - > buffer + c - > buffer_size , " [Reference] \r \n " ) ;
2005-12-17 19:14:38 +01:00
q + = snprintf ( q , q - ( char * ) c - > buffer + c - > buffer_size , " Ref1=http://%s/%s%s \r \n " ,
2002-05-30 04:49:07 +02:00
hostbuf , filename , info ) ;
2002-11-20 16:00:05 +01:00
break ;
case REDIR_RTSP :
{
char hostname [ 256 ] , * p ;
/* extract only hostname */
pstrcpy ( hostname , sizeof ( hostname ) , hostbuf ) ;
p = strrchr ( hostname , ' : ' ) ;
if ( p )
* p = ' \0 ' ;
2003-11-19 03:23:17 +01:00
q + = snprintf ( q , q - ( char * ) c - > buffer + c - > buffer_size , " HTTP/1.0 200 RTSP Redirect follows \r \n " ) ;
2002-11-20 16:00:05 +01:00
/* XXX: incorrect mime type ? */
2003-11-19 03:23:17 +01:00
q + = snprintf ( q , q - ( char * ) c - > buffer + c - > buffer_size , " Content-type: application/x-rtsp \r \n " ) ;
q + = snprintf ( q , q - ( char * ) c - > buffer + c - > buffer_size , " \r \n " ) ;
2005-12-17 19:14:38 +01:00
q + = snprintf ( q , q - ( char * ) c - > buffer + c - > buffer_size , " rtsp://%s:%d/%s \r \n " ,
hostname , ntohs ( my_rtsp_addr . sin_port ) ,
2002-11-20 16:00:05 +01:00
filename ) ;
}
break ;
case REDIR_SDP :
{
2003-02-11 17:35:48 +01:00
uint8_t * sdp_data ;
2002-11-20 16:00:05 +01:00
int sdp_data_size , len ;
struct sockaddr_in my_addr ;
2003-11-19 03:23:17 +01:00
q + = snprintf ( q , q - ( char * ) c - > buffer + c - > buffer_size , " HTTP/1.0 200 OK \r \n " ) ;
q + = snprintf ( q , q - ( char * ) c - > buffer + c - > buffer_size , " Content-type: application/sdp \r \n " ) ;
q + = snprintf ( q , q - ( char * ) c - > buffer + c - > buffer_size , " \r \n " ) ;
2002-11-20 16:00:05 +01:00
len = sizeof ( my_addr ) ;
getsockname ( c - > fd , ( struct sockaddr * ) & my_addr , & len ) ;
2005-12-17 19:14:38 +01:00
2002-11-20 16:00:05 +01:00
/* XXX: should use a dynamic buffer */
2005-12-17 19:14:38 +01:00
sdp_data_size = prepare_sdp_description ( stream ,
& sdp_data ,
2002-11-20 16:00:05 +01:00
my_addr . sin_addr ) ;
if ( sdp_data_size > 0 ) {
memcpy ( q , sdp_data , sdp_data_size ) ;
q + = sdp_data_size ;
* q = ' \0 ' ;
av_free ( sdp_data ) ;
}
}
break ;
default :
2002-05-24 03:18:19 +02:00
av_abort ( ) ;
2002-11-20 16:00:05 +01:00
break ;
2002-07-25 18:48:44 +02:00
}
2002-05-10 04:20:27 +02:00
/* prepare output buffer */
c - > buffer_ptr = c - > buffer ;
c - > buffer_end = q ;
c - > state = HTTPSTATE_SEND_HEADER ;
return 0 ;
}
}
}
2003-11-19 03:23:17 +01:00
snprintf ( msg , sizeof ( msg ) , " ASX/RAM file not handled " ) ;
2002-05-10 04:20:27 +02:00
goto send_error ;
2001-07-22 16:37:44 +02:00
}
2002-05-18 23:33:05 +02:00
stream - > conns_served + + ;
2002-05-10 04:20:27 +02:00
2001-07-22 16:37:44 +02:00
/* XXX: add there authenticate and IP match */
2005-10-14 19:29:00 +02:00
if ( c - > post ) {
2001-07-22 16:37:44 +02:00
/* if post, it means a feed is being sent */
if ( ! stream - > is_feed ) {
2002-05-10 04:20:27 +02:00
/* However it might be a status report from WMP! Lets log the data
* as it might come in handy one day
*/
char * logline = 0 ;
2002-05-26 05:36:34 +02:00
int client_id = 0 ;
2005-12-17 19:14:38 +01:00
2002-05-10 04:20:27 +02:00
for ( p = c - > buffer ; * p & & * p ! = ' \r ' & & * p ! = ' \n ' ; ) {
if ( strncasecmp ( p , " Pragma: log-line= " , 17 ) = = 0 ) {
logline = p ;
break ;
}
2002-05-26 05:36:34 +02:00
if ( strncasecmp ( p , " Pragma: client-id= " , 18 ) = = 0 ) {
client_id = strtol ( p + 18 , 0 , 10 ) ;
}
2002-05-10 04:20:27 +02:00
p = strchr ( p , ' \n ' ) ;
if ( ! p )
break ;
p + + ;
}
if ( logline ) {
char * eol = strchr ( logline , ' \n ' ) ;
logline + = 17 ;
if ( eol ) {
if ( eol [ - 1 ] = = ' \r ' )
eol - - ;
2004-03-25 00:32:48 +01:00
http_log ( " %.*s \n " , ( int ) ( eol - logline ) , logline ) ;
2002-05-10 04:20:27 +02:00
c - > suppress_log = 1 ;
}
}
2002-05-26 05:36:34 +02:00
2002-05-30 04:49:07 +02:00
# ifdef DEBUG_WMP
http_log ( " \n Got request: \n %s \n " , c - > buffer ) ;
2002-05-26 05:36:34 +02:00
# endif
if ( client_id & & extract_rates ( ratebuf , sizeof ( ratebuf ) , c - > buffer ) ) {
HTTPContext * wmpc ;
/* Now we have to find the client_id */
for ( wmpc = first_http_ctx ; wmpc ; wmpc = wmpc - > next ) {
if ( wmpc - > wmp_client_id = = client_id )
break ;
}
if ( wmpc ) {
2002-05-30 04:49:07 +02:00
if ( modify_current_stream ( wmpc , ratebuf ) ) {
wmpc - > switch_pending = 1 ;
2002-05-26 05:36:34 +02:00
}
}
}
2005-12-17 19:14:38 +01:00
2003-11-19 03:23:17 +01:00
snprintf ( msg , sizeof ( msg ) , " POST command not handled " ) ;
2003-03-04 03:56:51 +01:00
c - > stream = 0 ;
2001-07-22 16:37:44 +02:00
goto send_error ;
}
if ( http_start_receive_data ( c ) < 0 ) {
2003-11-19 03:23:17 +01:00
snprintf ( msg , sizeof ( msg ) , " could not open feed " ) ;
2001-07-22 16:37:44 +02:00
goto send_error ;
}
c - > http_error = 0 ;
c - > state = HTTPSTATE_RECEIVE_DATA ;
return 0 ;
}
2002-05-30 04:49:07 +02:00
# ifdef DEBUG_WMP
2002-05-26 05:36:34 +02:00
if ( strcmp ( stream - > filename + strlen ( stream - > filename ) - 4 , " .asf " ) = = 0 ) {
2002-05-30 04:49:07 +02:00
http_log ( " \n Got request: \n %s \n " , c - > buffer ) ;
2002-05-26 05:36:34 +02:00
}
# endif
2001-07-22 16:37:44 +02:00
if ( c - > stream - > stream_type = = STREAM_TYPE_STATUS )
goto send_stats ;
/* open input stream */
if ( open_input_stream ( c , info ) < 0 ) {
2003-11-19 03:23:17 +01:00
snprintf ( msg , sizeof ( msg ) , " Input stream corresponding to '%s' not found " , url ) ;
2001-07-22 16:37:44 +02:00
goto send_error ;
}
/* prepare http header */
q = c - > buffer ;
2003-11-19 03:23:17 +01:00
q + = snprintf ( q , q - ( char * ) c - > buffer + c - > buffer_size , " HTTP/1.0 200 OK \r \n " ) ;
2001-07-22 16:37:44 +02:00
mime_type = c - > stream - > fmt - > mime_type ;
if ( ! mime_type )
2007-03-31 16:39:04 +02:00
mime_type = " application/x-octet-stream " ;
2003-11-19 03:23:17 +01:00
q + = snprintf ( q , q - ( char * ) c - > buffer + c - > buffer_size , " Pragma: no-cache \r \n " ) ;
2001-07-22 16:37:44 +02:00
/* for asf, we need extra headers */
2002-07-27 05:03:04 +02:00
if ( ! strcmp ( c - > stream - > fmt - > name , " asf_stream " ) ) {
2002-05-26 05:36:34 +02:00
/* Need to allocate a client id */
2007-02-21 14:50:32 +01:00
c - > wmp_client_id = av_random ( & random_state ) & 0x7fffffff ;
2002-05-26 05:36:34 +02:00
2003-11-19 03:23:17 +01:00
q + = snprintf ( q , q - ( char * ) c - > buffer + c - > buffer_size , " Server: Cougar 4.1.0.3923 \r \n Cache-Control: no-cache \r \n Pragma: client-id=%d \r \n Pragma: features= \" broadcast \" \r \n " , c - > wmp_client_id ) ;
2001-07-22 16:37:44 +02:00
}
2003-11-19 03:23:17 +01:00
q + = snprintf ( q , q - ( char * ) c - > buffer + c - > buffer_size , " Content-Type: %s \r \n " , mime_type ) ;
q + = snprintf ( q , q - ( char * ) c - > buffer + c - > buffer_size , " \r \n " ) ;
2005-12-17 19:14:38 +01:00
2001-07-22 16:37:44 +02:00
/* prepare output buffer */
c - > http_error = 0 ;
c - > buffer_ptr = c - > buffer ;
c - > buffer_end = q ;
c - > state = HTTPSTATE_SEND_HEADER ;
return 0 ;
send_error :
c - > http_error = 404 ;
q = c - > buffer ;
2003-11-19 03:23:17 +01:00
q + = snprintf ( q , q - ( char * ) c - > buffer + c - > buffer_size , " HTTP/1.0 404 Not Found \r \n " ) ;
q + = snprintf ( q , q - ( char * ) c - > buffer + c - > buffer_size , " Content-type: %s \r \n " , " text/html " ) ;
q + = snprintf ( q , q - ( char * ) c - > buffer + c - > buffer_size , " \r \n " ) ;
q + = snprintf ( q , q - ( char * ) c - > buffer + c - > buffer_size , " <HTML> \n " ) ;
q + = snprintf ( q , q - ( char * ) c - > buffer + c - > buffer_size , " <HEAD><TITLE>404 Not Found</TITLE></HEAD> \n " ) ;
q + = snprintf ( q , q - ( char * ) c - > buffer + c - > buffer_size , " <BODY>%s</BODY> \n " , msg ) ;
q + = snprintf ( q , q - ( char * ) c - > buffer + c - > buffer_size , " </HTML> \n " ) ;
2001-07-22 16:37:44 +02:00
/* prepare output buffer */
c - > buffer_ptr = c - > buffer ;
c - > buffer_end = q ;
c - > state = HTTPSTATE_SEND_HEADER ;
return 0 ;
send_stats :
compute_stats ( c ) ;
c - > http_error = 200 ; /* horrible : we use this value to avoid
going to the send data state */
c - > state = HTTPSTATE_SEND_HEADER ;
return 0 ;
}
2003-02-11 17:35:48 +01:00
static void fmt_bytecount ( ByteIOContext * pb , int64_t count )
2002-06-05 04:17:06 +02:00
{
static const char * suffix = " kMGTP " ;
const char * s ;
for ( s = suffix ; count > = 100000 & & s [ 1 ] ; count / = 1000 , s + + ) {
}
2005-12-12 02:56:46 +01:00
url_fprintf ( pb , " % " PRId64 " %c " , count , * s ) ;
2002-06-05 04:17:06 +02:00
}
2001-07-22 16:37:44 +02:00
static void compute_stats ( HTTPContext * c )
{
HTTPContext * c1 ;
FFStream * stream ;
2002-07-25 18:48:44 +02:00
char * p ;
2001-07-22 16:37:44 +02:00
time_t ti ;
2002-07-25 18:48:44 +02:00
int i , len ;
ByteIOContext pb1 , * pb = & pb1 ;
2002-05-30 04:49:07 +02:00
2002-07-25 18:48:44 +02:00
if ( url_open_dyn_buf ( pb ) < 0 ) {
/* XXX: return an error ? */
2002-05-30 04:49:07 +02:00
c - > buffer_ptr = c - > buffer ;
2002-07-25 18:48:44 +02:00
c - > buffer_end = c - > buffer ;
return ;
2002-05-30 04:49:07 +02:00
}
2001-07-22 16:37:44 +02:00
2002-07-25 18:48:44 +02:00
url_fprintf ( pb , " HTTP/1.0 200 OK \r \n " ) ;
url_fprintf ( pb , " Content-type: %s \r \n " , " text/html " ) ;
url_fprintf ( pb , " Pragma: no-cache \r \n " ) ;
url_fprintf ( pb , " \r \n " ) ;
2005-12-17 19:14:38 +01:00
2002-07-25 18:48:44 +02:00
url_fprintf ( pb , " <HEAD><TITLE>FFServer Status</TITLE> \n " ) ;
2002-05-30 04:49:07 +02:00
if ( c - > stream - > feed_filename ) {
2002-07-25 18:48:44 +02:00
url_fprintf ( pb , " <link rel= \" shortcut icon \" href= \" %s \" > \n " , c - > stream - > feed_filename ) ;
2002-05-30 04:49:07 +02:00
}
2002-07-25 18:48:44 +02:00
url_fprintf ( pb , " </HEAD> \n <BODY> " ) ;
url_fprintf ( pb , " <H1>FFServer Status</H1> \n " ) ;
2001-07-22 16:37:44 +02:00
/* format status */
2002-07-25 18:48:44 +02:00
url_fprintf ( pb , " <H2>Available Streams</H2> \n " ) ;
url_fprintf ( pb , " <TABLE cellspacing=0 cellpadding=4> \n " ) ;
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 " ) ;
2001-07-22 16:37:44 +02:00
stream = first_stream ;
while ( stream ! = NULL ) {
2002-05-16 04:03:07 +02:00
char sfilename [ 1024 ] ;
char * eosf ;
2002-05-18 23:33:05 +02:00
if ( stream - > feed ! = stream ) {
2002-07-25 18:48:44 +02:00
pstrcpy ( sfilename , sizeof ( sfilename ) - 10 , stream - > filename ) ;
2002-05-18 23:33:05 +02:00
eosf = sfilename + strlen ( sfilename ) ;
if ( eosf - sfilename > = 4 ) {
if ( strcmp ( eosf - 4 , " .asf " ) = = 0 ) {
strcpy ( eosf - 4 , " .asx " ) ;
} else if ( strcmp ( eosf - 3 , " .rm " ) = = 0 ) {
strcpy ( eosf - 3 , " .ram " ) ;
2006-07-10 01:40:53 +02:00
} else if ( stream - > fmt = = & rtp_muxer ) {
2002-11-20 16:00:05 +01:00
/* generate a sample RTSP director if
unicast . Generate an SDP redirector if
multicast */
2002-07-25 18:48:44 +02:00
eosf = strrchr ( sfilename , ' . ' ) ;
if ( ! eosf )
eosf = sfilename + strlen ( sfilename ) ;
2002-11-20 16:00:05 +01:00
if ( stream - > is_multicast )
strcpy ( eosf , " .sdp " ) ;
else
strcpy ( eosf , " .rtsp " ) ;
2002-05-18 23:33:05 +02:00
}
2002-05-16 04:03:07 +02:00
}
2005-12-17 19:14:38 +01:00
url_fprintf ( pb , " <TR><TD><A HREF= \" /%s \" >%s</A> " ,
2002-05-18 23:33:05 +02:00
sfilename , stream - > filename ) ;
2002-07-25 18:48:44 +02:00
url_fprintf ( pb , " <td align=right> %d <td align=right> " ,
2002-06-05 04:17:06 +02:00
stream - > conns_served ) ;
2002-07-25 18:48:44 +02:00
fmt_bytecount ( pb , stream - > bytes_served ) ;
2002-05-18 23:33:05 +02:00
switch ( stream - > stream_type ) {
case STREAM_TYPE_LIVE :
{
int audio_bit_rate = 0 ;
int video_bit_rate = 0 ;
2002-11-14 20:07:25 +01:00
const char * audio_codec_name = " " ;
const char * video_codec_name = " " ;
const char * audio_codec_name_extra = " " ;
const char * video_codec_name_extra = " " ;
2002-05-18 23:33:05 +02:00
for ( i = 0 ; i < stream - > nb_streams ; i + + ) {
AVStream * st = stream - > streams [ i ] ;
2005-07-18 00:24:36 +02:00
AVCodec * codec = avcodec_find_encoder ( st - > codec - > codec_id ) ;
switch ( st - > codec - > codec_type ) {
2002-05-18 23:33:05 +02:00
case CODEC_TYPE_AUDIO :
2005-07-18 00:24:36 +02:00
audio_bit_rate + = st - > codec - > bit_rate ;
2002-05-18 23:33:05 +02:00
if ( codec ) {
if ( * audio_codec_name )
audio_codec_name_extra = " ... " ;
audio_codec_name = codec - > name ;
}
break ;
case CODEC_TYPE_VIDEO :
2005-07-18 00:24:36 +02:00
video_bit_rate + = st - > codec - > bit_rate ;
2002-05-18 23:33:05 +02:00
if ( codec ) {
if ( * video_codec_name )
video_codec_name_extra = " ... " ;
video_codec_name = codec - > name ;
}
break ;
2003-11-10 20:02:56 +01:00
case CODEC_TYPE_DATA :
2005-07-18 00:24:36 +02:00
video_bit_rate + = st - > codec - > bit_rate ;
2003-11-10 20:02:56 +01:00
break ;
2002-05-18 23:33:05 +02:00
default :
2002-05-24 03:18:19 +02:00
av_abort ( ) ;
2002-05-17 03:53:28 +02:00
}
2001-07-22 16:37:44 +02:00
}
2005-12-17 19:14:38 +01:00
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 " ,
2002-05-18 23:33:05 +02:00
stream - > fmt - > name ,
2002-11-20 19:05:45 +01:00
stream - > bandwidth ,
2002-05-18 23:33:05 +02:00
video_bit_rate / 1000 , video_codec_name , video_codec_name_extra ,
audio_bit_rate / 1000 , audio_codec_name , audio_codec_name_extra ) ;
if ( stream - > feed ) {
2002-07-25 18:48:44 +02:00
url_fprintf ( pb , " <TD>%s " , stream - > feed - > filename ) ;
2002-05-18 23:33:05 +02:00
} else {
2002-07-25 18:48:44 +02:00
url_fprintf ( pb , " <TD>%s " , stream - > feed_filename ) ;
2002-05-18 23:33:05 +02:00
}
2002-07-25 18:48:44 +02:00
url_fprintf ( pb , " \n " ) ;
2001-07-22 16:37:44 +02:00
}
2002-05-18 23:33:05 +02:00
break ;
default :
2002-07-25 18:48:44 +02:00
url_fprintf ( pb , " <TD align=center> - <TD align=right> - <TD align=right> - <td><td align=right> - <TD> \n " ) ;
2002-05-18 23:33:05 +02:00
break ;
2001-07-22 16:37:44 +02:00
}
}
stream = stream - > next ;
}
2002-07-25 18:48:44 +02:00
url_fprintf ( pb , " </TABLE> \n " ) ;
2002-05-18 23:33:05 +02:00
stream = first_stream ;
while ( stream ! = NULL ) {
if ( stream - > feed = = stream ) {
2002-07-25 18:48:44 +02:00
url_fprintf ( pb , " <h2>Feed %s</h2> " , stream - > filename ) ;
2002-05-30 04:49:07 +02:00
if ( stream - > pid ) {
2002-07-25 18:48:44 +02:00
url_fprintf ( pb , " Running as pid %d. \n " , stream - > pid ) ;
2002-05-30 04:49:07 +02:00
2002-07-25 18:48:44 +02:00
# if defined(linux) && !defined(CONFIG_NOCUTILS)
{
FILE * pid_stat ;
char ps_cmd [ 64 ] ;
/* This is somewhat linux specific I guess */
2005-12-17 19:14:38 +01:00
snprintf ( ps_cmd , sizeof ( ps_cmd ) ,
" ps -o \" %%cpu,cputime \" --no-headers %d " ,
2002-07-25 18:48:44 +02:00
stream - > pid ) ;
2005-12-17 19:14:38 +01:00
2002-07-25 18:48:44 +02:00
pid_stat = popen ( ps_cmd , " r " ) ;
if ( pid_stat ) {
char cpuperc [ 10 ] ;
char cpuused [ 64 ] ;
2005-12-17 19:14:38 +01:00
if ( fscanf ( pid_stat , " %10s %64s " , cpuperc ,
2002-07-25 18:48:44 +02:00
cpuused ) = = 2 ) {
url_fprintf ( pb , " Currently using %s%% of the cpu. Total time used %s. \n " ,
cpuperc , cpuused ) ;
}
fclose ( pid_stat ) ;
2002-05-30 04:49:07 +02:00
}
}
# endif
2002-07-25 18:48:44 +02:00
url_fprintf ( pb , " <p> " ) ;
2002-05-30 04:49:07 +02:00
}
2002-07-25 18:48:44 +02:00
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 " ) ;
2002-05-18 23:33:05 +02:00
for ( i = 0 ; i < stream - > nb_streams ; i + + ) {
AVStream * st = stream - > streams [ i ] ;
2005-07-18 00:24:36 +02:00
AVCodec * codec = avcodec_find_encoder ( st - > codec - > codec_id ) ;
2003-02-10 10:44:47 +01:00
const char * type = " unknown " ;
2002-05-24 04:06:15 +02:00
char parameters [ 64 ] ;
parameters [ 0 ] = 0 ;
2002-05-18 23:33:05 +02:00
2005-07-18 00:24:36 +02:00
switch ( st - > codec - > codec_type ) {
2002-05-18 23:33:05 +02:00
case CODEC_TYPE_AUDIO :
type = " audio " ;
2007-03-09 12:20:57 +01:00
snprintf ( parameters , sizeof ( parameters ) , " %d channel(s), %d Hz " , st - > codec - > channels , st - > codec - > sample_rate ) ;
2002-05-18 23:33:05 +02:00
break ;
case CODEC_TYPE_VIDEO :
type = " video " ;
2005-07-18 00:24:36 +02:00
snprintf ( parameters , sizeof ( parameters ) , " %dx%d, q=%d-%d, fps=%d " , st - > codec - > width , st - > codec - > height ,
st - > codec - > qmin , st - > codec - > qmax , st - > codec - > time_base . den / st - > codec - > time_base . num ) ;
2002-05-18 23:33:05 +02:00
break ;
default :
2002-05-24 03:18:19 +02:00
av_abort ( ) ;
2002-05-18 23:33:05 +02:00
}
2002-07-25 18:48:44 +02:00
url_fprintf ( pb , " <tr><td align=right>%d<td>%s<td align=right>%d<td>%s<td>%s \n " ,
2005-07-18 00:24:36 +02:00
i , type , st - > codec - > bit_rate / 1000 , codec ? codec - > name : " " , parameters ) ;
2002-05-18 23:33:05 +02:00
}
2002-07-25 18:48:44 +02:00
url_fprintf ( pb , " </table> \n " ) ;
2002-05-18 23:33:05 +02:00
2005-12-17 19:14:38 +01:00
}
2002-05-18 23:33:05 +02:00
stream = stream - > next ;
}
2005-12-17 19:14:38 +01:00
2001-07-22 16:37:44 +02:00
#if 0
{
float avg ;
AVCodecContext * enc ;
char buf [ 1024 ] ;
2005-12-17 19:14:38 +01:00
2001-07-22 16:37:44 +02:00
/* feed status */
stream = first_feed ;
while ( stream ! = NULL ) {
2002-07-25 18:48:44 +02:00
url_fprintf ( pb , " <H1>Feed '%s'</H1> \n " , stream - > filename ) ;
url_fprintf ( pb , " <TABLE> \n " ) ;
url_fprintf ( pb , " <TR><TD>Parameters<TD>Frame count<TD>Size<TD>Avg bitrate (kbits/s) \n " ) ;
2001-07-22 16:37:44 +02:00
for ( i = 0 ; i < stream - > nb_streams ; i + + ) {
AVStream * st = stream - > streams [ i ] ;
FeedData * fdata = st - > priv_data ;
2005-07-18 00:24:36 +02:00
enc = st - > codec ;
2005-12-17 19:14:38 +01:00
2001-07-22 16:37:44 +02:00
avcodec_string ( buf , sizeof ( buf ) , enc ) ;
avg = fdata - > avg_frame_size * ( float ) enc - > rate * 8.0 ;
if ( enc - > codec - > type = = CODEC_TYPE_AUDIO & & enc - > frame_size > 0 )
avg / = enc - > frame_size ;
2006-11-01 23:39:58 +01:00
url_fprintf ( pb , " <TR><TD>%s <TD> %d <TD> % " PRId64 " <TD> %0.1f \n " ,
2001-07-22 16:37:44 +02:00
buf , enc - > frame_number , fdata - > data_count , avg / 1000.0 ) ;
}
2002-07-25 18:48:44 +02:00
url_fprintf ( pb , " </TABLE> \n " ) ;
2001-07-22 16:37:44 +02:00
stream = stream - > next_feed ;
}
}
# endif
/* connection status */
2002-07-25 18:48:44 +02:00
url_fprintf ( pb , " <H2>Connection Status</H2> \n " ) ;
2001-07-22 16:37:44 +02:00
2002-07-25 18:48:44 +02:00
url_fprintf ( pb , " Number of connections: %d / %d<BR> \n " ,
2001-07-22 16:37:44 +02:00
nb_connections , nb_max_connections ) ;
2002-07-25 18:48:44 +02:00
url_fprintf ( pb , " Bandwidth in use: %dk / %dk<BR> \n " ,
2002-11-20 19:05:45 +01:00
current_bandwidth , max_bandwidth ) ;
2002-05-16 04:03:07 +02:00
2002-07-25 18:48:44 +02:00
url_fprintf ( pb , " <TABLE> \n " ) ;
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 " ) ;
2001-07-22 16:37:44 +02:00
c1 = first_http_ctx ;
i = 0 ;
2002-07-25 18:48:44 +02:00
while ( c1 ! = NULL ) {
2002-05-30 04:49:07 +02:00
int bitrate ;
int j ;
bitrate = 0 ;
2002-07-25 18:48:44 +02:00
if ( c1 - > stream ) {
for ( j = 0 ; j < c1 - > stream - > nb_streams ; j + + ) {
if ( ! c1 - > stream - > feed ) {
2005-07-18 00:24:36 +02:00
bitrate + = c1 - > stream - > streams [ j ] - > codec - > bit_rate ;
2002-07-25 18:48:44 +02:00
} else {
if ( c1 - > feed_streams [ j ] > = 0 ) {
2005-07-18 00:24:36 +02:00
bitrate + = c1 - > stream - > feed - > streams [ c1 - > feed_streams [ j ] ] - > codec - > bit_rate ;
2002-07-25 18:48:44 +02:00
}
}
2002-05-30 04:49:07 +02:00
}
}
2001-07-22 16:37:44 +02:00
i + + ;
p = inet_ntoa ( c1 - > from_addr . sin_addr ) ;
2005-12-17 19:14:38 +01:00
url_fprintf ( pb , " <TR><TD><B>%d</B><TD>%s%s<TD>%s<TD>%s<TD>%s<td align=right> " ,
i ,
c1 - > stream ? c1 - > stream - > filename : " " ,
2002-07-25 18:48:44 +02:00
c1 - > state = = HTTPSTATE_RECEIVE_DATA ? " (input) " : " " ,
2005-12-17 19:14:38 +01:00
p ,
2002-07-25 18:48:44 +02:00
c1 - > protocol ,
http_state [ c1 - > state ] ) ;
fmt_bytecount ( pb , bitrate ) ;
url_fprintf ( pb , " <td align=right> " ) ;
fmt_bytecount ( pb , compute_datarate ( & c1 - > datarate , c1 - > data_count ) * 8 ) ;
url_fprintf ( pb , " <td align=right> " ) ;
fmt_bytecount ( pb , c1 - > data_count ) ;
url_fprintf ( pb , " \n " ) ;
2001-07-22 16:37:44 +02:00
c1 = c1 - > next ;
}
2002-07-25 18:48:44 +02:00
url_fprintf ( pb , " </TABLE> \n " ) ;
2005-12-17 19:14:38 +01:00
2001-07-22 16:37:44 +02:00
/* date */
ti = time ( NULL ) ;
p = ctime ( & ti ) ;
2002-07-25 18:48:44 +02:00
url_fprintf ( pb , " <HR size=1 noshade>Generated at %s " , p ) ;
url_fprintf ( pb , " </BODY> \n </HTML> \n " ) ;
2001-07-22 16:37:44 +02:00
2002-07-25 18:48:44 +02:00
len = url_close_dyn_buf ( pb , & c - > pb_buffer ) ;
c - > buffer_ptr = c - > pb_buffer ;
c - > buffer_end = c - > pb_buffer + len ;
2001-07-22 16:37:44 +02:00
}
2002-07-25 18:48:44 +02:00
/* check if the parser needs to be opened for stream i */
static void open_parser ( AVFormatContext * s , int i )
2001-07-22 16:37:44 +02:00
{
2002-07-25 18:48:44 +02:00
AVStream * st = s - > streams [ i ] ;
AVCodec * codec ;
2002-05-30 22:37:51 +02:00
2005-07-18 00:24:36 +02:00
if ( ! st - > codec - > codec ) {
codec = avcodec_find_decoder ( st - > codec - > codec_id ) ;
2002-07-25 18:48:44 +02:00
if ( codec & & ( codec - > capabilities & CODEC_CAP_PARSE_ONLY ) ) {
2005-07-18 00:24:36 +02:00
st - > codec - > parse_only = 1 ;
if ( avcodec_open ( st - > codec , codec ) < 0 ) {
st - > codec - > parse_only = 0 ;
2002-07-25 18:48:44 +02:00
}
2002-05-30 04:49:07 +02:00
}
}
2001-07-22 16:37:44 +02:00
}
static int open_input_stream ( HTTPContext * c , const char * info )
{
char buf [ 128 ] ;
char input_filename [ 1024 ] ;
AVFormatContext * s ;
2002-07-25 18:48:44 +02:00
int buf_size , i ;
2003-02-11 17:35:48 +01:00
int64_t stream_pos ;
2001-07-22 16:37:44 +02:00
/* find file name */
if ( c - > stream - > feed ) {
strcpy ( input_filename , c - > stream - > feed - > feed_filename ) ;
buf_size = FFM_PACKET_SIZE ;
/* compute position (absolute time) */
if ( find_info_tag ( buf , sizeof ( buf ) , " date " , info ) ) {
stream_pos = parse_date ( buf , 0 ) ;
2002-05-09 03:11:08 +02:00
} else if ( find_info_tag ( buf , sizeof ( buf ) , " buffer " , info ) ) {
int prebuffer = strtol ( buf , 0 , 10 ) ;
2003-02-11 17:35:48 +01:00
stream_pos = av_gettime ( ) - prebuffer * ( int64_t ) 1000000 ;
2001-07-22 16:37:44 +02:00
} else {
2003-02-11 17:35:48 +01:00
stream_pos = av_gettime ( ) - c - > stream - > prebuffer * ( int64_t ) 1000 ;
2001-07-22 16:37:44 +02:00
}
} else {
strcpy ( input_filename , c - > stream - > feed_filename ) ;
buf_size = 0 ;
/* compute position (relative time) */
if ( find_info_tag ( buf , sizeof ( buf ) , " date " , info ) ) {
stream_pos = parse_date ( buf , 1 ) ;
} else {
stream_pos = 0 ;
}
}
if ( input_filename [ 0 ] = = ' \0 ' )
return - 1 ;
2002-07-27 05:03:04 +02:00
#if 0
{ time_t when = stream_pos / 1000000 ;
2006-11-01 23:39:58 +01:00
http_log ( " Stream pos = % " PRId64 " , time=%s " , stream_pos , ctime ( & when ) ) ;
2002-07-27 05:03:04 +02:00
}
# endif
2001-07-22 16:37:44 +02:00
/* open stream */
2005-12-17 19:14:38 +01:00
if ( av_open_input_file ( & s , input_filename , c - > stream - > ifmt ,
2003-11-10 20:02:56 +01:00
buf_size , c - > stream - > ap_in ) < 0 ) {
2002-07-25 18:48:44 +02:00
http_log ( " %s not found " , input_filename ) ;
2001-07-22 16:37:44 +02:00
return - 1 ;
2002-07-25 18:48:44 +02:00
}
2001-07-22 16:37:44 +02:00
c - > fmt_in = s ;
2005-12-17 19:14:38 +01:00
2002-07-25 18:48:44 +02:00
/* open each parser */
for ( i = 0 ; i < s - > nb_streams ; i + + )
open_parser ( s , i ) ;
/* choose stream as clock source (we favorize video stream if
present ) for packet sending */
c - > pts_stream_index = 0 ;
for ( i = 0 ; i < c - > stream - > nb_streams ; i + + ) {
2005-12-17 19:14:38 +01:00
if ( c - > pts_stream_index = = 0 & &
2005-07-18 00:24:36 +02:00
c - > stream - > streams [ i ] - > codec - > codec_type = = CODEC_TYPE_VIDEO ) {
2002-07-25 18:48:44 +02:00
c - > pts_stream_index = i ;
}
}
2001-07-22 16:37:44 +02:00
2005-05-07 02:56:05 +02:00
# if 1
2002-05-20 18:33:46 +02:00
if ( c - > fmt_in - > iformat - > read_seek ) {
2005-05-07 02:56:05 +02:00
c - > fmt_in - > iformat - > read_seek ( c - > fmt_in , 0 , stream_pos , 0 ) ;
2001-07-22 16:37:44 +02:00
}
2003-11-10 20:02:56 +01:00
# endif
2002-07-25 18:48:44 +02:00
/* set the start time (needed for maxtime and RTP packet timing) */
c - > start_time = cur_time ;
c - > first_pts = AV_NOPTS_VALUE ;
2001-07-22 16:37:44 +02:00
return 0 ;
}
2003-11-10 20:02:56 +01:00
/* return the server clock (in us) */
static int64_t get_server_clock ( HTTPContext * c )
2002-07-25 18:48:44 +02:00
{
2003-11-10 20:02:56 +01:00
/* compute current pts value from system time */
2007-02-24 03:39:57 +01:00
return ( cur_time - c - > start_time ) * 1000 ;
2002-07-25 18:48:44 +02:00
}
2003-11-10 20:02:56 +01:00
/* return the estimated time at which the current packet must be sent
( in us ) */
static int64_t get_packet_send_clock ( HTTPContext * c )
2002-07-25 18:48:44 +02:00
{
2003-11-10 20:02:56 +01:00
int bytes_left , bytes_sent , frame_bytes ;
2005-12-17 19:14:38 +01:00
2003-11-10 20:02:56 +01:00
frame_bytes = c - > cur_frame_bytes ;
if ( frame_bytes < = 0 ) {
return c - > cur_pts ;
2002-07-25 18:48:44 +02:00
} else {
2003-11-10 20:02:56 +01:00
bytes_left = c - > buffer_end - c - > buffer_ptr ;
bytes_sent = frame_bytes - bytes_left ;
return c - > cur_pts + ( c - > cur_frame_duration * bytes_sent ) / frame_bytes ;
2002-07-25 18:48:44 +02:00
}
}
static int http_prepare_data ( HTTPContext * c )
{
int i , len , ret ;
AVFormatContext * ctx ;
2003-07-17 12:31:23 +02:00
av_freep ( & c - > pb_buffer ) ;
2002-07-25 18:48:44 +02:00
switch ( c - > state ) {
case HTTPSTATE_SEND_DATA_HEADER :
memset ( & c - > fmt_ctx , 0 , sizeof ( c - > fmt_ctx ) ) ;
2005-12-17 19:14:38 +01:00
pstrcpy ( c - > fmt_ctx . author , sizeof ( c - > fmt_ctx . author ) ,
2002-07-25 18:48:44 +02:00
c - > stream - > author ) ;
2005-12-17 19:14:38 +01:00
pstrcpy ( c - > fmt_ctx . comment , sizeof ( c - > fmt_ctx . comment ) ,
2002-07-25 18:48:44 +02:00
c - > stream - > comment ) ;
2005-12-17 19:14:38 +01:00
pstrcpy ( c - > fmt_ctx . copyright , sizeof ( c - > fmt_ctx . copyright ) ,
2002-07-25 18:48:44 +02:00
c - > stream - > copyright ) ;
2005-12-17 19:14:38 +01:00
pstrcpy ( c - > fmt_ctx . title , sizeof ( c - > fmt_ctx . title ) ,
2002-07-25 18:48:44 +02:00
c - > stream - > title ) ;
/* open output stream by using specified codecs */
c - > fmt_ctx . oformat = c - > stream - > fmt ;
c - > fmt_ctx . nb_streams = c - > stream - > nb_streams ;
for ( i = 0 ; i < c - > fmt_ctx . nb_streams ; i + + ) {
AVStream * st ;
2005-12-22 02:10:11 +01:00
AVStream * src ;
2002-07-25 18:48:44 +02:00
st = av_mallocz ( sizeof ( AVStream ) ) ;
2005-07-18 11:02:58 +02:00
st - > codec = avcodec_alloc_context ( ) ;
2002-07-25 18:48:44 +02:00
c - > fmt_ctx . streams [ i ] = st ;
/* if file or feed, then just take streams from FFStream struct */
2005-12-17 19:14:38 +01:00
if ( ! c - > stream - > feed | |
2002-07-25 18:48:44 +02:00
c - > stream - > feed = = c - > stream )
2005-01-03 03:42:02 +01:00
src = c - > stream - > streams [ i ] ;
2002-07-25 18:48:44 +02:00
else
2005-01-03 03:42:02 +01:00
src = c - > stream - > feed - > streams [ c - > stream - > feed_streams [ i ] ] ;
2005-12-22 02:10:11 +01:00
* st = * src ;
st - > priv_data = 0 ;
2005-07-18 00:24:36 +02:00
st - > codec - > frame_number = 0 ; /* XXX: should be done in
2002-07-25 18:48:44 +02:00
AVStream , not in codec */
2002-12-11 04:16:51 +01:00
/* I'm pretty sure that this is not correct...
* However , without it , we crash
*/
2005-07-18 00:24:36 +02:00
st - > codec - > coded_frame = & dummy_frame ;
2002-07-25 18:48:44 +02:00
}
c - > got_key_frame = 0 ;
/* prepare header and save header data in a stream */
if ( url_open_dyn_buf ( & c - > fmt_ctx . pb ) < 0 ) {
/* XXX: potential leak */
return - 1 ;
}
c - > fmt_ctx . pb . is_streamed = 1 ;
2003-01-11 06:14:28 +01:00
av_set_parameters ( & c - > fmt_ctx , NULL ) ;
2007-02-24 03:24:42 +01:00
if ( av_write_header ( & c - > fmt_ctx ) < 0 )
return - 1 ;
2002-07-25 18:48:44 +02:00
len = url_close_dyn_buf ( & c - > fmt_ctx . pb , & c - > pb_buffer ) ;
c - > buffer_ptr = c - > pb_buffer ;
c - > buffer_end = c - > pb_buffer + len ;
c - > state = HTTPSTATE_SEND_DATA ;
2001-07-22 16:37:44 +02:00
c - > last_packet_sent = 0 ;
break ;
case HTTPSTATE_SEND_DATA :
/* find a new packet */
{
AVPacket pkt ;
2005-12-17 19:14:38 +01:00
2001-07-22 16:37:44 +02:00
/* read a packet from the input stream */
if ( c - > stream - > feed ) {
2005-12-17 19:14:38 +01:00
ffm_set_write_index ( c - > fmt_in ,
2001-07-22 16:37:44 +02:00
c - > stream - > feed - > feed_write_index ,
c - > stream - > feed - > feed_size ) ;
}
2002-05-24 03:18:19 +02:00
2005-12-17 19:14:38 +01:00
if ( c - > stream - > max_time & &
2002-06-05 04:17:06 +02:00
c - > stream - > max_time + c - > start_time - cur_time < 0 ) {
2002-05-24 03:18:19 +02:00
/* We have timed out */
c - > state = HTTPSTATE_SEND_DATA_TRAILER ;
2001-07-22 16:37:44 +02:00
} else {
2002-11-20 19:05:45 +01:00
redo :
2002-07-25 18:48:44 +02:00
if ( av_read_frame ( c - > fmt_in , & pkt ) < 0 ) {
if ( c - > stream - > feed & & c - > stream - > feed - > feed_opened ) {
/* if coming from feed, it means we reached the end of the
ffm file , so must wait for more data */
c - > state = HTTPSTATE_WAIT_FEED ;
return 1 ; /* state changed */
} else {
2002-11-20 19:05:45 +01:00
if ( c - > stream - > loop ) {
av_close_input_file ( c - > fmt_in ) ;
c - > fmt_in = NULL ;
if ( open_input_stream ( c , " " ) < 0 )
goto no_loop ;
goto redo ;
} else {
no_loop :
/* must send trailer now because eof or error */
c - > state = HTTPSTATE_SEND_DATA_TRAILER ;
}
2002-07-25 18:48:44 +02:00
}
} else {
/* update first pts if needed */
2003-07-12 00:30:12 +02:00
if ( c - > first_pts = = AV_NOPTS_VALUE ) {
2005-04-30 23:43:59 +02:00
c - > first_pts = av_rescale_q ( pkt . dts , c - > fmt_in - > streams [ pkt . stream_index ] - > time_base , AV_TIME_BASE_Q ) ;
2003-07-12 00:30:12 +02:00
c - > start_time = cur_time ;
}
2002-07-25 18:48:44 +02:00
/* send it to the appropriate stream */
if ( c - > stream - > feed ) {
/* if coming from a feed, select the right stream */
if ( c - > switch_pending ) {
c - > switch_pending = 0 ;
for ( i = 0 ; i < c - > stream - > nb_streams ; i + + ) {
if ( c - > switch_feed_streams [ i ] = = pkt . stream_index ) {
if ( pkt . flags & PKT_FLAG_KEY ) {
do_switch_stream ( c , i ) ;
}
}
if ( c - > switch_feed_streams [ i ] > = 0 ) {
c - > switch_pending = 1 ;
}
}
}
2002-05-30 04:49:07 +02:00
for ( i = 0 ; i < c - > stream - > nb_streams ; i + + ) {
2002-07-25 18:48:44 +02:00
if ( c - > feed_streams [ i ] = = pkt . stream_index ) {
pkt . stream_index = i ;
2002-05-30 04:49:07 +02:00
if ( pkt . flags & PKT_FLAG_KEY ) {
2002-07-25 18:48:44 +02:00
c - > got_key_frame | = 1 < < i ;
}
2005-12-17 19:14:38 +01:00
/* See if we have all the key frames, then
2002-07-25 18:48:44 +02:00
* we start to send . This logic is not quite
2005-12-17 19:14:38 +01:00
* right , but it works for the case of a
2002-07-25 18:48:44 +02:00
* single video stream with one or more
2005-12-17 19:14:38 +01:00
* audio streams ( for which every frame is
* typically a key frame ) .
2002-07-25 18:48:44 +02:00
*/
2005-12-17 19:14:38 +01:00
if ( ! c - > stream - > send_on_key | |
2002-07-25 18:48:44 +02:00
( ( c - > got_key_frame + 1 ) > > c - > stream - > nb_streams ) ) {
goto send_it ;
2002-05-30 04:49:07 +02:00
}
}
}
2002-07-25 18:48:44 +02:00
} else {
AVCodecContext * codec ;
2005-12-17 19:14:38 +01:00
2002-07-25 18:48:44 +02:00
send_it :
/* specific handling for RTP: we use several
output stream ( one for each RTP
connection ) . XXX : need more abstract handling */
if ( c - > is_packetized ) {
2003-11-10 20:02:56 +01:00
AVStream * st ;
/* compute send time and duration */
st = c - > fmt_in - > streams [ pkt . stream_index ] ;
2005-04-30 23:43:59 +02:00
c - > cur_pts = av_rescale_q ( pkt . dts , st - > time_base , AV_TIME_BASE_Q ) ;
2003-11-10 20:02:56 +01:00
if ( st - > start_time ! = AV_NOPTS_VALUE )
2005-04-30 23:43:59 +02:00
c - > cur_pts - = av_rescale_q ( st - > start_time , st - > time_base , AV_TIME_BASE_Q ) ;
c - > cur_frame_duration = av_rescale_q ( pkt . duration , st - > time_base , AV_TIME_BASE_Q ) ;
2003-11-10 20:02:56 +01:00
#if 0
printf ( " index=%d pts=%0.3f duration=%0.6f \n " ,
pkt . stream_index ,
2005-12-17 19:14:38 +01:00
( double ) c - > cur_pts /
2003-11-10 20:02:56 +01:00
AV_TIME_BASE ,
2005-12-17 19:14:38 +01:00
( double ) c - > cur_frame_duration /
2003-11-10 20:02:56 +01:00
AV_TIME_BASE ) ;
# endif
/* find RTP context */
2002-07-25 18:48:44 +02:00
c - > packet_stream_index = pkt . stream_index ;
ctx = c - > rtp_ctx [ c - > packet_stream_index ] ;
2003-07-03 23:09:06 +02:00
if ( ! ctx ) {
av_free_packet ( & pkt ) ;
2003-07-12 00:30:12 +02:00
break ;
2003-07-03 23:09:06 +02:00
}
2005-07-18 00:24:36 +02:00
codec = ctx - > streams [ 0 ] - > codec ;
2002-11-20 19:05:45 +01:00
/* only one stream per RTP connection */
pkt . stream_index = 0 ;
2002-07-25 18:48:44 +02:00
} else {
ctx = & c - > fmt_ctx ;
/* Fudge here */
2005-07-18 00:24:36 +02:00
codec = ctx - > streams [ pkt . stream_index ] - > codec ;
2001-07-22 16:37:44 +02:00
}
2005-12-17 19:14:38 +01:00
2002-12-09 13:03:43 +01:00
codec - > coded_frame - > key_frame = ( ( pkt . flags & PKT_FLAG_KEY ) ! = 0 ) ;
2002-07-25 18:48:44 +02:00
if ( c - > is_packetized ) {
2003-07-17 12:31:23 +02:00
int max_packet_size ;
if ( c - > rtp_protocol = = RTSP_PROTOCOL_RTP_TCP )
max_packet_size = RTSP_TCP_MAX_PACKET_SIZE ;
else
max_packet_size = url_get_max_packet_size ( c - > rtp_handles [ c - > packet_stream_index ] ) ;
ret = url_open_dyn_packet_buf ( & ctx - > pb , max_packet_size ) ;
2002-07-25 18:48:44 +02:00
} else {
ret = url_open_dyn_buf ( & ctx - > pb ) ;
}
if ( ret < 0 ) {
/* XXX: potential leak */
return - 1 ;
}
2007-02-24 03:28:28 +01:00
if ( pkt . dts ! = AV_NOPTS_VALUE )
pkt . dts = av_rescale_q ( pkt . dts ,
c - > fmt_in - > streams [ pkt . stream_index ] - > time_base ,
ctx - > streams [ pkt . stream_index ] - > time_base ) ;
if ( pkt . pts ! = AV_NOPTS_VALUE )
pkt . pts = av_rescale_q ( pkt . pts ,
c - > fmt_in - > streams [ pkt . stream_index ] - > time_base ,
ctx - > streams [ pkt . stream_index ] - > time_base ) ;
2004-05-29 04:06:32 +02:00
if ( av_write_frame ( ctx , & pkt ) ) {
2002-07-25 18:48:44 +02:00
c - > state = HTTPSTATE_SEND_DATA_TRAILER ;
}
2005-12-17 19:14:38 +01:00
2002-07-25 18:48:44 +02:00
len = url_close_dyn_buf ( & ctx - > pb , & c - > pb_buffer ) ;
2003-11-10 20:02:56 +01:00
c - > cur_frame_bytes = len ;
2002-07-25 18:48:44 +02:00
c - > buffer_ptr = c - > pb_buffer ;
c - > buffer_end = c - > pb_buffer + len ;
2005-12-17 19:14:38 +01:00
2002-07-25 18:48:44 +02:00
codec - > frame_number + + ;
2003-11-10 20:02:56 +01:00
if ( len = = 0 )
goto redo ;
2002-05-09 03:11:08 +02:00
}
2002-07-25 18:48:44 +02:00
av_free_packet ( & pkt ) ;
2001-07-22 16:37:44 +02:00
}
}
}
break ;
default :
case HTTPSTATE_SEND_DATA_TRAILER :
/* last packet test ? */
2002-07-25 18:48:44 +02:00
if ( c - > last_packet_sent | | c - > is_packetized )
2001-07-22 16:37:44 +02:00
return - 1 ;
2002-07-25 18:48:44 +02:00
ctx = & c - > fmt_ctx ;
2001-07-22 16:37:44 +02:00
/* prepare header */
2002-07-25 18:48:44 +02:00
if ( url_open_dyn_buf ( & ctx - > pb ) < 0 ) {
/* XXX: potential leak */
return - 1 ;
}
av_write_trailer ( ctx ) ;
len = url_close_dyn_buf ( & ctx - > pb , & c - > pb_buffer ) ;
c - > buffer_ptr = c - > pb_buffer ;
c - > buffer_end = c - > pb_buffer + len ;
2001-07-22 16:37:44 +02:00
c - > last_packet_sent = 1 ;
break ;
}
return 0 ;
}
/* should convert the format at the same time */
2003-07-17 12:31:23 +02:00
/* send data starting at c->buffer_ptr to the output connection
( either UDP or TCP connection ) */
2002-06-10 04:44:36 +02:00
static int http_send_data ( HTTPContext * c )
2001-07-22 16:37:44 +02:00
{
2003-11-10 20:02:56 +01:00
int len , ret ;
2001-07-22 16:37:44 +02:00
2003-07-17 12:31:23 +02:00
for ( ; ; ) {
if ( c - > buffer_ptr > = c - > buffer_end ) {
ret = http_prepare_data ( c ) ;
if ( ret < 0 )
return - 1 ;
else if ( ret ! = 0 ) {
/* state change requested */
break ;
2002-05-09 03:11:08 +02:00
}
2002-07-25 18:48:44 +02:00
} else {
2003-07-17 12:31:23 +02:00
if ( c - > is_packetized ) {
/* RTP data output */
len = c - > buffer_end - c - > buffer_ptr ;
if ( len < 4 ) {
/* fail safe - should never happen */
fail1 :
c - > buffer_ptr = c - > buffer_end ;
2002-07-25 18:48:44 +02:00
return 0 ;
}
2003-07-17 12:31:23 +02:00
len = ( c - > buffer_ptr [ 0 ] < < 24 ) |
( c - > buffer_ptr [ 1 ] < < 16 ) |
( c - > buffer_ptr [ 2 ] < < 8 ) |
( c - > buffer_ptr [ 3 ] ) ;
if ( len > ( c - > buffer_end - c - > buffer_ptr ) )
goto fail1 ;
2003-11-10 20:02:56 +01:00
if ( ( get_packet_send_clock ( c ) - get_server_clock ( c ) ) > 0 ) {
/* nothing to send yet: we can wait */
return 0 ;
}
c - > data_count + = len ;
update_datarate ( & c - > datarate , c - > data_count ) ;
if ( c - > stream )
c - > stream - > bytes_served + = len ;
2003-07-17 12:31:23 +02:00
if ( c - > rtp_protocol = = RTSP_PROTOCOL_RTP_TCP ) {
/* RTP packets are sent inside the RTSP TCP connection */
ByteIOContext pb1 , * pb = & pb1 ;
int interleaved_index , size ;
uint8_t header [ 4 ] ;
HTTPContext * rtsp_c ;
2005-12-17 19:14:38 +01:00
2003-07-17 12:31:23 +02:00
rtsp_c = c - > rtsp_c ;
/* if no RTSP connection left, error */
if ( ! rtsp_c )
return - 1 ;
/* if already sending something, then wait. */
if ( rtsp_c - > state ! = RTSPSTATE_WAIT_REQUEST ) {
break ;
}
if ( url_open_dyn_buf ( pb ) < 0 )
goto fail1 ;
interleaved_index = c - > packet_stream_index * 2 ;
/* RTCP packets are sent at odd indexes */
if ( c - > buffer_ptr [ 1 ] = = 200 )
interleaved_index + + ;
/* write RTSP TCP header */
header [ 0 ] = ' $ ' ;
header [ 1 ] = interleaved_index ;
header [ 2 ] = len > > 8 ;
header [ 3 ] = len ;
put_buffer ( pb , header , 4 ) ;
/* write RTP packet data */
c - > buffer_ptr + = 4 ;
put_buffer ( pb , c - > buffer_ptr , len ) ;
size = url_close_dyn_buf ( pb , & c - > packet_buffer ) ;
/* prepare asynchronous TCP sending */
rtsp_c - > packet_buffer_ptr = c - > packet_buffer ;
rtsp_c - > packet_buffer_end = c - > packet_buffer + size ;
2003-11-10 20:02:56 +01:00
c - > buffer_ptr + = len ;
2005-12-17 19:14:38 +01:00
2003-11-10 20:02:56 +01:00
/* send everything we can NOW */
2007-02-22 13:38:37 +01:00
len = send ( rtsp_c - > fd , rtsp_c - > packet_buffer_ptr ,
rtsp_c - > packet_buffer_end - rtsp_c - > packet_buffer_ptr , 0 ) ;
2003-11-10 20:02:56 +01:00
if ( len > 0 ) {
rtsp_c - > packet_buffer_ptr + = len ;
2003-07-17 12:31:23 +02:00
}
2003-11-10 20:02:56 +01:00
if ( rtsp_c - > packet_buffer_ptr < rtsp_c - > packet_buffer_end ) {
/* if we could not send all the data, we will
send it later , so a new state is needed to
" lock " the RTSP TCP connection */
rtsp_c - > state = RTSPSTATE_SEND_PACKET ;
break ;
} else {
/* all data has been sent */
av_freep ( & c - > packet_buffer ) ;
}
} else {
/* send RTP packet directly in UDP */
2003-07-17 12:31:23 +02:00
c - > buffer_ptr + = 4 ;
2005-12-17 19:14:38 +01:00
url_write ( c - > rtp_handles [ c - > packet_stream_index ] ,
2003-07-17 12:31:23 +02:00
c - > buffer_ptr , len ) ;
2003-11-10 20:02:56 +01:00
c - > buffer_ptr + = len ;
/* here we continue as we can send several packets per 10 ms slot */
2003-07-17 12:31:23 +02:00
}
} else {
/* TCP data output */
2007-02-22 13:38:37 +01:00
len = send ( c - > fd , c - > buffer_ptr , c - > buffer_end - c - > buffer_ptr , 0 ) ;
2003-07-17 12:31:23 +02:00
if ( len < 0 ) {
if ( errno ! = EAGAIN & & errno ! = EINTR ) {
/* error : close connection */
return - 1 ;
} else {
return 0 ;
}
} else {
c - > buffer_ptr + = len ;
}
2003-11-10 20:02:56 +01:00
c - > data_count + = len ;
update_datarate ( & c - > datarate , c - > data_count ) ;
if ( c - > stream )
c - > stream - > bytes_served + = len ;
break ;
2002-07-25 18:48:44 +02:00
}
2001-07-22 16:37:44 +02:00
}
2003-07-17 12:31:23 +02:00
} /* for(;;) */
2001-07-22 16:37:44 +02:00
return 0 ;
}
static int http_start_receive_data ( HTTPContext * c )
{
int fd ;
if ( c - > stream - > feed_opened )
return - 1 ;
2003-04-09 04:16:01 +02:00
/* Don't permit writing to this one */
if ( c - > stream - > readonly )
return - 1 ;
2001-07-22 16:37:44 +02:00
/* open feed */
fd = open ( c - > stream - > feed_filename , O_RDWR ) ;
if ( fd < 0 )
return - 1 ;
c - > feed_fd = fd ;
2005-12-17 19:14:38 +01:00
2001-07-22 16:37:44 +02:00
c - > stream - > feed_write_index = ffm_read_write_index ( fd ) ;
c - > stream - > feed_size = lseek ( fd , 0 , SEEK_END ) ;
lseek ( fd , 0 , SEEK_SET ) ;
/* init buffer input */
c - > buffer_ptr = c - > buffer ;
c - > buffer_end = c - > buffer + FFM_PACKET_SIZE ;
c - > stream - > feed_opened = 1 ;
return 0 ;
}
2005-12-17 19:14:38 +01:00
2001-07-22 16:37:44 +02:00
static int http_receive_data ( HTTPContext * c )
{
HTTPContext * c1 ;
2002-05-18 23:33:05 +02:00
if ( c - > buffer_end > c - > buffer_ptr ) {
int len ;
2007-02-22 13:38:37 +01:00
len = recv ( c - > fd , c - > buffer_ptr , c - > buffer_end - c - > buffer_ptr , 0 ) ;
2002-05-18 23:33:05 +02:00
if ( len < 0 ) {
if ( errno ! = EAGAIN & & errno ! = EINTR ) {
/* error : close connection */
goto fail ;
}
} else if ( len = = 0 ) {
/* end of connection : close it */
goto fail ;
} else {
c - > buffer_ptr + = len ;
c - > data_count + = len ;
2002-06-10 04:44:36 +02:00
update_datarate ( & c - > datarate , c - > data_count ) ;
2002-05-18 23:33:05 +02:00
}
}
2003-11-19 03:23:17 +01:00
if ( c - > buffer_ptr - c - > buffer > = 2 & & c - > data_count > FFM_PACKET_SIZE ) {
if ( c - > buffer [ 0 ] ! = ' f ' | |
c - > buffer [ 1 ] ! = ' m ' ) {
http_log ( " Feed stream has become desynchronized -- disconnecting \n " ) ;
goto fail ;
}
}
2001-07-22 16:37:44 +02:00
if ( c - > buffer_ptr > = c - > buffer_end ) {
2002-05-09 03:11:08 +02:00
FFStream * feed = c - > stream ;
2001-07-22 16:37:44 +02:00
/* a packet has been received : write it in the store, except
if header */
if ( c - > data_count > FFM_PACKET_SIZE ) {
2005-12-17 19:14:38 +01:00
2006-11-01 23:39:58 +01:00
// printf("writing pos=0x%"PRIx64" size=0x%"PRIx64"\n", feed->feed_write_index, feed->feed_size);
2001-07-22 16:37:44 +02:00
/* XXX: use llseek or url_seek */
lseek ( c - > feed_fd , feed - > feed_write_index , SEEK_SET ) ;
write ( c - > feed_fd , c - > buffer , FFM_PACKET_SIZE ) ;
2005-12-17 19:14:38 +01:00
2001-07-22 16:37:44 +02:00
feed - > feed_write_index + = FFM_PACKET_SIZE ;
/* update file size */
if ( feed - > feed_write_index > c - > stream - > feed_size )
feed - > feed_size = feed - > feed_write_index ;
/* handle wrap around if max file size reached */
2005-11-13 04:26:43 +01:00
if ( c - > stream - > feed_max_size & & feed - > feed_write_index > = c - > stream - > feed_max_size )
2001-07-22 16:37:44 +02:00
feed - > feed_write_index = FFM_PACKET_SIZE ;
/* write index */
ffm_write_write_index ( c - > feed_fd , feed - > feed_write_index ) ;
/* wake up any waiting connections */
for ( c1 = first_http_ctx ; c1 ! = NULL ; c1 = c1 - > next ) {
2005-12-17 19:14:38 +01:00
if ( c1 - > state = = HTTPSTATE_WAIT_FEED & &
2001-07-22 16:37:44 +02:00
c1 - > stream - > feed = = c - > stream - > feed ) {
c1 - > state = HTTPSTATE_SEND_DATA ;
}
}
2002-05-09 03:11:08 +02:00
} else {
/* We have a header in our hands that contains useful data */
AVFormatContext s ;
2002-05-20 18:33:46 +02:00
AVInputFormat * fmt_in ;
2002-05-09 03:11:08 +02:00
ByteIOContext * pb = & s . pb ;
int i ;
memset ( & s , 0 , sizeof ( s ) ) ;
url_open_buf ( pb , c - > buffer , c - > buffer_end - c - > buffer , URL_RDONLY ) ;
pb - > buf_end = c - > buffer_end ; /* ?? */
pb - > is_streamed = 1 ;
2002-05-20 18:33:46 +02:00
/* use feed output format name to find corresponding input format */
fmt_in = av_find_input_format ( feed - > fmt - > name ) ;
if ( ! fmt_in )
goto fail ;
2003-01-23 23:00:57 +01:00
if ( fmt_in - > priv_data_size > 0 ) {
s . priv_data = av_mallocz ( fmt_in - > priv_data_size ) ;
if ( ! s . priv_data )
goto fail ;
2005-12-22 02:10:11 +01:00
} else
s . priv_data = NULL ;
2002-05-24 03:18:19 +02:00
2002-05-20 18:33:46 +02:00
if ( fmt_in - > read_header ( & s , 0 ) < 0 ) {
2002-05-24 03:18:19 +02:00
av_freep ( & s . priv_data ) ;
2002-05-09 03:11:08 +02:00
goto fail ;
}
/* Now we have the actual streams */
if ( s . nb_streams ! = feed - > nb_streams ) {
2002-05-24 03:18:19 +02:00
av_freep ( & s . priv_data ) ;
2002-05-09 03:11:08 +02:00
goto fail ;
}
for ( i = 0 ; i < s . nb_streams ; i + + ) {
2005-12-17 19:14:38 +01:00
memcpy ( feed - > streams [ i ] - > codec ,
2005-07-18 00:24:36 +02:00
s . streams [ i ] - > codec , sizeof ( AVCodecContext ) ) ;
2005-12-17 19:14:38 +01:00
}
2002-05-24 03:18:19 +02:00
av_freep ( & s . priv_data ) ;
2001-07-22 16:37:44 +02:00
}
c - > buffer_ptr = c - > buffer ;
}
return 0 ;
fail :
c - > stream - > feed_opened = 0 ;
close ( c - > feed_fd ) ;
return - 1 ;
}
2002-07-25 18:48:44 +02:00
/********************************************************************/
/* RTSP handling */
static void rtsp_reply_header ( HTTPContext * c , enum RTSPStatusCode error_number )
{
const char * str ;
time_t ti ;
char * p ;
char buf2 [ 32 ] ;
switch ( error_number ) {
2007-04-10 16:36:11 +02:00
case RTSP_STATUS_OK :
str = " OK " ;
break ;
case RTSP_STATUS_METHOD :
str = " Method Not Allowed " ;
break ;
case RTSP_STATUS_BANDWIDTH :
str = " Not Enough Bandwidth " ;
break ;
case RTSP_STATUS_SESSION :
str = " Session Not Found " ;
break ;
case RTSP_STATUS_STATE :
str = " Method Not Valid in This State " ;
break ;
case RTSP_STATUS_AGGREGATE :
str = " Aggregate operation not allowed " ;
break ;
case RTSP_STATUS_ONLY_AGGREGATE :
str = " Only aggregate operation allowed " ;
break ;
case RTSP_STATUS_TRANSPORT :
str = " Unsupported transport " ;
break ;
case RTSP_STATUS_INTERNAL :
str = " Internal Server Error " ;
break ;
case RTSP_STATUS_SERVICE :
str = " Service Unavailable " ;
break ;
case RTSP_STATUS_VERSION :
str = " RTSP Version not supported " ;
break ;
2002-07-25 18:48:44 +02:00
default :
str = " Unknown Error " ;
break ;
}
2005-12-17 19:14:38 +01:00
2002-07-25 18:48:44 +02:00
url_fprintf ( c - > pb , " RTSP/1.0 %d %s \r \n " , error_number , str ) ;
url_fprintf ( c - > pb , " CSeq: %d \r \n " , c - > seq ) ;
/* output GMT time */
ti = time ( NULL ) ;
p = ctime ( & ti ) ;
strcpy ( buf2 , p ) ;
p = buf2 + strlen ( p ) - 1 ;
if ( * p = = ' \n ' )
* p = ' \0 ' ;
url_fprintf ( c - > pb , " Date: %s GMT \r \n " , buf2 ) ;
}
static void rtsp_reply_error ( HTTPContext * c , enum RTSPStatusCode error_number )
{
rtsp_reply_header ( c , error_number ) ;
url_fprintf ( c - > pb , " \r \n " ) ;
}
static int rtsp_parse_request ( HTTPContext * c )
{
const char * p , * p1 , * p2 ;
char cmd [ 32 ] ;
char url [ 1024 ] ;
char protocol [ 32 ] ;
char line [ 1024 ] ;
ByteIOContext pb1 ;
int len ;
RTSPHeader header1 , * header = & header1 ;
2005-12-17 19:14:38 +01:00
2002-07-25 18:48:44 +02:00
c - > buffer_ptr [ 0 ] = ' \0 ' ;
p = c - > buffer ;
2005-12-17 19:14:38 +01:00
2002-07-25 18:48:44 +02:00
get_word ( cmd , sizeof ( cmd ) , & p ) ;
get_word ( url , sizeof ( url ) , & p ) ;
get_word ( protocol , sizeof ( protocol ) , & p ) ;
pstrcpy ( c - > method , sizeof ( c - > method ) , cmd ) ;
pstrcpy ( c - > url , sizeof ( c - > url ) , url ) ;
pstrcpy ( c - > protocol , sizeof ( c - > protocol ) , protocol ) ;
c - > pb = & pb1 ;
if ( url_open_dyn_buf ( c - > pb ) < 0 ) {
/* XXX: cannot do more */
c - > pb = NULL ; /* safety */
return - 1 ;
}
/* check version name */
if ( strcmp ( protocol , " RTSP/1.0 " ) ! = 0 ) {
rtsp_reply_error ( c , RTSP_STATUS_VERSION ) ;
goto the_end ;
}
/* parse each header line */
memset ( header , 0 , sizeof ( RTSPHeader ) ) ;
/* skip to next line */
while ( * p ! = ' \n ' & & * p ! = ' \0 ' )
p + + ;
if ( * p = = ' \n ' )
p + + ;
while ( * p ! = ' \0 ' ) {
p1 = strchr ( p , ' \n ' ) ;
if ( ! p1 )
break ;
p2 = p1 ;
if ( p2 > p & & p2 [ - 1 ] = = ' \r ' )
p2 - - ;
/* skip empty line */
if ( p2 = = p )
break ;
len = p2 - p ;
if ( len > sizeof ( line ) - 1 )
len = sizeof ( line ) - 1 ;
memcpy ( line , p , len ) ;
line [ len ] = ' \0 ' ;
rtsp_parse_line ( header , line ) ;
p = p1 + 1 ;
}
/* handle sequence number */
c - > seq = header - > seq ;
if ( ! strcmp ( cmd , " DESCRIBE " ) ) {
rtsp_cmd_describe ( c , url ) ;
2003-04-04 15:29:58 +02:00
} else if ( ! strcmp ( cmd , " OPTIONS " ) ) {
rtsp_cmd_options ( c , url ) ;
2002-07-25 18:48:44 +02:00
} else if ( ! strcmp ( cmd , " SETUP " ) ) {
rtsp_cmd_setup ( c , url , header ) ;
} else if ( ! strcmp ( cmd , " PLAY " ) ) {
rtsp_cmd_play ( c , url , header ) ;
} else if ( ! strcmp ( cmd , " PAUSE " ) ) {
rtsp_cmd_pause ( c , url , header ) ;
} else if ( ! strcmp ( cmd , " TEARDOWN " ) ) {
rtsp_cmd_teardown ( c , url , header ) ;
} else {
rtsp_reply_error ( c , RTSP_STATUS_METHOD ) ;
}
the_end :
len = url_close_dyn_buf ( c - > pb , & c - > pb_buffer ) ;
c - > pb = NULL ; /* safety */
if ( len < 0 ) {
/* XXX: cannot do more */
return - 1 ;
}
c - > buffer_ptr = c - > pb_buffer ;
c - > buffer_end = c - > pb_buffer + len ;
c - > state = RTSPSTATE_SEND_REPLY ;
return 0 ;
}
2002-11-20 16:00:05 +01:00
/* XXX: move that to rtsp.c, but would need to replace FFStream by
AVFormatContext */
2005-12-17 19:14:38 +01:00
static int prepare_sdp_description ( FFStream * stream , uint8_t * * pbuffer ,
2002-11-20 16:00:05 +01:00
struct in_addr my_ip )
2002-07-25 18:48:44 +02:00
{
ByteIOContext pb1 , * pb = & pb1 ;
2002-11-20 21:49:47 +01:00
int i , payload_type , port , private_payload_type , j ;
2002-07-25 18:48:44 +02:00
const char * ipstr , * title , * mediatype ;
AVStream * st ;
2005-12-17 19:14:38 +01:00
2002-07-25 18:48:44 +02:00
if ( url_open_dyn_buf ( pb ) < 0 )
return - 1 ;
2005-12-17 19:14:38 +01:00
2002-07-25 18:48:44 +02:00
/* general media info */
url_fprintf ( pb , " v=0 \n " ) ;
2002-11-20 16:00:05 +01:00
ipstr = inet_ntoa ( my_ip ) ;
2002-07-25 18:48:44 +02:00
url_fprintf ( pb , " o=- 0 0 IN IP4 %s \n " , ipstr ) ;
title = stream - > title ;
if ( title [ 0 ] = = ' \0 ' )
title = " No Title " ;
url_fprintf ( pb , " s=%s \n " , title ) ;
if ( stream - > comment [ 0 ] ! = ' \0 ' )
url_fprintf ( pb , " i=%s \n " , stream - > comment ) ;
2002-11-20 16:00:05 +01:00
if ( stream - > is_multicast ) {
url_fprintf ( pb , " c=IN IP4 %s \n " , inet_ntoa ( stream - > multicast_ip ) ) ;
}
2002-07-25 18:48:44 +02:00
/* for each stream, we output the necessary info */
2003-11-10 20:02:56 +01:00
private_payload_type = RTP_PT_PRIVATE ;
2002-07-25 18:48:44 +02:00
for ( i = 0 ; i < stream - > nb_streams ; i + + ) {
st = stream - > streams [ i ] ;
2005-07-18 00:24:36 +02:00
if ( st - > codec - > codec_id = = CODEC_ID_MPEG2TS ) {
2002-07-25 18:48:44 +02:00
mediatype = " video " ;
2003-11-10 20:02:56 +01:00
} else {
2005-07-18 00:24:36 +02:00
switch ( st - > codec - > codec_type ) {
2003-11-10 20:02:56 +01:00
case CODEC_TYPE_AUDIO :
mediatype = " audio " ;
break ;
case CODEC_TYPE_VIDEO :
mediatype = " video " ;
break ;
default :
mediatype = " application " ;
break ;
}
2002-07-25 18:48:44 +02:00
}
2002-11-20 16:00:05 +01:00
/* NOTE: the port indication is not correct in case of
unicast . It is not an issue because RTSP gives it */
2005-07-18 00:24:36 +02:00
payload_type = rtp_get_payload_type ( st - > codec ) ;
2002-11-20 21:49:47 +01:00
if ( payload_type < 0 )
payload_type = private_payload_type + + ;
2002-11-20 16:00:05 +01:00
if ( stream - > is_multicast ) {
port = stream - > multicast_port + 2 * i ;
} else {
port = 0 ;
}
2005-12-17 19:14:38 +01:00
url_fprintf ( pb , " m=%s %d RTP/AVP %d \n " ,
2002-11-20 16:00:05 +01:00
mediatype , port , payload_type ) ;
2003-11-10 20:02:56 +01:00
if ( payload_type > = RTP_PT_PRIVATE ) {
2002-11-20 21:49:47 +01:00
/* for private payload type, we need to give more info */
2005-07-18 00:24:36 +02:00
switch ( st - > codec - > codec_id ) {
2002-11-20 21:49:47 +01:00
case CODEC_ID_MPEG4 :
{
uint8_t * data ;
2005-12-17 19:14:38 +01:00
url_fprintf ( pb , " a=rtpmap:%d MP4V-ES/%d \n " ,
2002-11-20 21:49:47 +01:00
payload_type , 90000 ) ;
/* we must also add the mpeg4 header */
2005-07-18 00:24:36 +02:00
data = st - > codec - > extradata ;
2002-11-20 21:49:47 +01:00
if ( data ) {
2003-07-04 00:56:54 +02:00
url_fprintf ( pb , " a=fmtp:%d config= " , payload_type ) ;
2005-07-18 00:24:36 +02:00
for ( j = 0 ; j < st - > codec - > extradata_size ; j + + ) {
2002-11-20 21:49:47 +01:00
url_fprintf ( pb , " %02x " , data [ j ] ) ;
}
url_fprintf ( pb , " \n " ) ;
}
}
break ;
default :
/* XXX: add other codecs ? */
goto fail ;
}
}
2002-07-25 18:48:44 +02:00
url_fprintf ( pb , " a=control:streamid=%d \n " , i ) ;
}
return url_close_dyn_buf ( pb , pbuffer ) ;
2002-11-20 21:49:47 +01:00
fail :
url_close_dyn_buf ( pb , pbuffer ) ;
av_free ( * pbuffer ) ;
return - 1 ;
2002-07-25 18:48:44 +02:00
}
2003-04-04 15:29:58 +02:00
static void rtsp_cmd_options ( HTTPContext * c , const char * url )
{
// rtsp_reply_header(c, RTSP_STATUS_OK);
url_fprintf ( c - > pb , " RTSP/1.0 %d %s \r \n " , RTSP_STATUS_OK , " OK " ) ;
url_fprintf ( c - > pb , " CSeq: %d \r \n " , c - > seq ) ;
url_fprintf ( c - > pb , " Public: %s \r \n " , " OPTIONS, DESCRIBE, SETUP, TEARDOWN, PLAY, PAUSE " ) ;
url_fprintf ( c - > pb , " \r \n " ) ;
}
2002-07-25 18:48:44 +02:00
static void rtsp_cmd_describe ( HTTPContext * c , const char * url )
{
FFStream * stream ;
char path1 [ 1024 ] ;
const char * path ;
2003-02-11 17:35:48 +01:00
uint8_t * content ;
2002-11-20 16:00:05 +01:00
int content_length , len ;
struct sockaddr_in my_addr ;
2005-12-17 19:14:38 +01:00
2002-07-25 18:48:44 +02:00
/* find which url is asked */
2004-08-12 02:09:32 +02:00
url_split ( NULL , 0 , NULL , 0 , NULL , 0 , NULL , path1 , sizeof ( path1 ) , url ) ;
2002-07-25 18:48:44 +02:00
path = path1 ;
if ( * path = = ' / ' )
path + + ;
for ( stream = first_stream ; stream ! = NULL ; stream = stream - > next ) {
2006-07-10 01:40:53 +02:00
if ( ! stream - > is_feed & & stream - > fmt = = & rtp_muxer & &
2002-07-25 18:48:44 +02:00
! strcmp ( path , stream - > filename ) ) {
goto found ;
}
}
/* no stream found */
rtsp_reply_error ( c , RTSP_STATUS_SERVICE ) ; /* XXX: right error ? */
return ;
found :
/* prepare the media description in sdp format */
2002-11-20 16:00:05 +01:00
/* get the host IP */
len = sizeof ( my_addr ) ;
getsockname ( c - > fd , ( struct sockaddr * ) & my_addr , & len ) ;
content_length = prepare_sdp_description ( stream , & content , my_addr . sin_addr ) ;
2002-07-25 18:48:44 +02:00
if ( content_length < 0 ) {
rtsp_reply_error ( c , RTSP_STATUS_INTERNAL ) ;
return ;
}
rtsp_reply_header ( c , RTSP_STATUS_OK ) ;
url_fprintf ( c - > pb , " Content-Type: application/sdp \r \n " ) ;
url_fprintf ( c - > pb , " Content-Length: %d \r \n " , content_length ) ;
url_fprintf ( c - > pb , " \r \n " ) ;
put_buffer ( c - > pb , content , content_length ) ;
}
static HTTPContext * find_rtp_session ( const char * session_id )
{
HTTPContext * c ;
if ( session_id [ 0 ] = = ' \0 ' )
return NULL ;
for ( c = first_http_ctx ; c ! = NULL ; c = c - > next ) {
if ( ! strcmp ( c - > session_id , session_id ) )
return c ;
}
return NULL ;
}
2003-02-10 10:44:47 +01:00
static RTSPTransportField * find_transport ( RTSPHeader * h , enum RTSPProtocol protocol )
2002-07-25 18:48:44 +02:00
{
RTSPTransportField * th ;
int i ;
for ( i = 0 ; i < h - > nb_transports ; i + + ) {
th = & h - > transports [ i ] ;
if ( th - > protocol = = protocol )
return th ;
}
return NULL ;
}
2005-12-17 19:14:38 +01:00
static void rtsp_cmd_setup ( HTTPContext * c , const char * url ,
2002-07-25 18:48:44 +02:00
RTSPHeader * h )
{
FFStream * stream ;
int stream_index , port ;
char buf [ 1024 ] ;
char path1 [ 1024 ] ;
const char * path ;
HTTPContext * rtp_c ;
RTSPTransportField * th ;
struct sockaddr_in dest_addr ;
RTSPActionServerSetup setup ;
2005-12-17 19:14:38 +01:00
2002-07-25 18:48:44 +02:00
/* find which url is asked */
2004-08-12 02:09:32 +02:00
url_split ( NULL , 0 , NULL , 0 , NULL , 0 , NULL , path1 , sizeof ( path1 ) , url ) ;
2002-07-25 18:48:44 +02:00
path = path1 ;
if ( * path = = ' / ' )
path + + ;
/* now check each stream */
for ( stream = first_stream ; stream ! = NULL ; stream = stream - > next ) {
2006-07-10 01:40:53 +02:00
if ( ! stream - > is_feed & & stream - > fmt = = & rtp_muxer ) {
2002-07-25 18:48:44 +02:00
/* accept aggregate filenames only if single stream */
if ( ! strcmp ( path , stream - > filename ) ) {
if ( stream - > nb_streams ! = 1 ) {
rtsp_reply_error ( c , RTSP_STATUS_AGGREGATE ) ;
return ;
}
stream_index = 0 ;
goto found ;
}
2005-12-17 19:14:38 +01:00
2002-07-25 18:48:44 +02:00
for ( stream_index = 0 ; stream_index < stream - > nb_streams ;
stream_index + + ) {
2005-12-17 19:14:38 +01:00
snprintf ( buf , sizeof ( buf ) , " %s/streamid=%d " ,
2002-07-25 18:48:44 +02:00
stream - > filename , stream_index ) ;
if ( ! strcmp ( path , buf ) )
goto found ;
}
}
}
/* no stream found */
rtsp_reply_error ( c , RTSP_STATUS_SERVICE ) ; /* XXX: right error ? */
return ;
found :
/* generate session id if needed */
if ( h - > session_id [ 0 ] = = ' \0 ' ) {
2007-02-21 14:50:32 +01:00
snprintf ( h - > session_id , sizeof ( h - > session_id ) , " %08x%08x " ,
av_random ( & random_state ) , av_random ( & random_state ) ) ;
2002-07-25 18:48:44 +02:00
}
/* find rtp session, and create it if none found */
rtp_c = find_rtp_session ( h - > session_id ) ;
if ( ! rtp_c ) {
2003-07-17 12:31:23 +02:00
/* always prefer UDP */
th = find_transport ( h , RTSP_PROTOCOL_RTP_UDP ) ;
if ( ! th ) {
th = find_transport ( h , RTSP_PROTOCOL_RTP_TCP ) ;
if ( ! th ) {
rtsp_reply_error ( c , RTSP_STATUS_TRANSPORT ) ;
return ;
}
}
rtp_c = rtp_new_connection ( & c - > from_addr , stream , h - > session_id ,
th - > protocol ) ;
2002-07-25 18:48:44 +02:00
if ( ! rtp_c ) {
rtsp_reply_error ( c , RTSP_STATUS_BANDWIDTH ) ;
return ;
}
/* open input stream */
if ( open_input_stream ( rtp_c , " " ) < 0 ) {
rtsp_reply_error ( c , RTSP_STATUS_INTERNAL ) ;
return ;
}
}
2005-12-17 19:14:38 +01:00
2002-07-25 18:48:44 +02:00
/* test if stream is OK (test needed because several SETUP needs
to be done for a given file ) */
if ( rtp_c - > stream ! = stream ) {
rtsp_reply_error ( c , RTSP_STATUS_SERVICE ) ;
return ;
}
2005-12-17 19:14:38 +01:00
2002-07-25 18:48:44 +02:00
/* test if stream is already set up */
if ( rtp_c - > rtp_ctx [ stream_index ] ) {
rtsp_reply_error ( c , RTSP_STATUS_STATE ) ;
return ;
}
/* check transport */
th = find_transport ( h , rtp_c - > rtp_protocol ) ;
2005-12-17 19:14:38 +01:00
if ( ! th | | ( th - > protocol = = RTSP_PROTOCOL_RTP_UDP & &
2002-07-25 18:48:44 +02:00
th - > client_port_min < = 0 ) ) {
rtsp_reply_error ( c , RTSP_STATUS_TRANSPORT ) ;
return ;
}
/* setup default options */
setup . transport_option [ 0 ] = ' \0 ' ;
dest_addr = rtp_c - > from_addr ;
dest_addr . sin_port = htons ( th - > client_port_min ) ;
2005-12-17 19:14:38 +01:00
2002-07-25 18:48:44 +02:00
/* setup stream */
2003-07-17 12:31:23 +02:00
if ( rtp_new_av_stream ( rtp_c , stream_index , & dest_addr , c ) < 0 ) {
2002-07-25 18:48:44 +02:00
rtsp_reply_error ( c , RTSP_STATUS_TRANSPORT ) ;
return ;
}
/* now everything is OK, so we can send the connection parameters */
rtsp_reply_header ( c , RTSP_STATUS_OK ) ;
/* session ID */
url_fprintf ( c - > pb , " Session: %s \r \n " , rtp_c - > session_id ) ;
switch ( rtp_c - > rtp_protocol ) {
case RTSP_PROTOCOL_RTP_UDP :
port = rtp_get_local_port ( rtp_c - > rtp_handles [ stream_index ] ) ;
url_fprintf ( c - > pb , " Transport: RTP/AVP/UDP;unicast; "
" client_port=%d-%d;server_port=%d-%d " ,
th - > client_port_min , th - > client_port_min + 1 ,
port , port + 1 ) ;
break ;
case RTSP_PROTOCOL_RTP_TCP :
url_fprintf ( c - > pb , " Transport: RTP/AVP/TCP;interleaved=%d-%d " ,
stream_index * 2 , stream_index * 2 + 1 ) ;
break ;
default :
break ;
}
if ( setup . transport_option [ 0 ] ! = ' \0 ' ) {
url_fprintf ( c - > pb , " ;%s " , setup . transport_option ) ;
}
url_fprintf ( c - > pb , " \r \n " ) ;
2005-12-17 19:14:38 +01:00
2002-07-25 18:48:44 +02:00
url_fprintf ( c - > pb , " \r \n " ) ;
}
/* find an rtp connection by using the session ID. Check consistency
with filename */
2005-12-17 19:14:38 +01:00
static HTTPContext * find_rtp_session_with_url ( const char * url ,
2002-07-25 18:48:44 +02:00
const char * session_id )
{
HTTPContext * rtp_c ;
char path1 [ 1024 ] ;
const char * path ;
2003-06-29 03:25:41 +02:00
char buf [ 1024 ] ;
int s ;
2002-07-25 18:48:44 +02:00
rtp_c = find_rtp_session ( session_id ) ;
if ( ! rtp_c )
return NULL ;
/* find which url is asked */
2004-08-12 02:09:32 +02:00
url_split ( NULL , 0 , NULL , 0 , NULL , 0 , NULL , path1 , sizeof ( path1 ) , url ) ;
2002-07-25 18:48:44 +02:00
path = path1 ;
if ( * path = = ' / ' )
path + + ;
2003-06-29 03:25:41 +02:00
if ( ! strcmp ( path , rtp_c - > stream - > filename ) ) return rtp_c ;
for ( s = 0 ; s < rtp_c - > stream - > nb_streams ; + + s ) {
snprintf ( buf , sizeof ( buf ) , " %s/streamid=%d " ,
rtp_c - > stream - > filename , s ) ;
if ( ! strncmp ( path , buf , sizeof ( buf ) ) ) {
// XXX: Should we reply with RTSP_STATUS_ONLY_AGGREGATE if nb_streams>1?
return rtp_c ;
}
}
return NULL ;
2002-07-25 18:48:44 +02:00
}
static void rtsp_cmd_play ( HTTPContext * c , const char * url , RTSPHeader * h )
{
HTTPContext * rtp_c ;
rtp_c = find_rtp_session_with_url ( url , h - > session_id ) ;
if ( ! rtp_c ) {
rtsp_reply_error ( c , RTSP_STATUS_SESSION ) ;
return ;
}
2005-12-17 19:14:38 +01:00
2002-07-25 18:48:44 +02:00
if ( rtp_c - > state ! = HTTPSTATE_SEND_DATA & &
rtp_c - > state ! = HTTPSTATE_WAIT_FEED & &
rtp_c - > state ! = HTTPSTATE_READY ) {
rtsp_reply_error ( c , RTSP_STATUS_STATE ) ;
return ;
}
2003-11-10 20:02:56 +01:00
#if 0
/* XXX: seek in stream */
if ( h - > range_start ! = AV_NOPTS_VALUE ) {
printf ( " range_start=%0.3f \n " , ( double ) h - > range_start / AV_TIME_BASE ) ;
av_seek_frame ( rtp_c - > fmt_in , - 1 , h - > range_start ) ;
}
# endif
2002-07-25 18:48:44 +02:00
rtp_c - > state = HTTPSTATE_SEND_DATA ;
2005-12-17 19:14:38 +01:00
2002-07-25 18:48:44 +02:00
/* now everything is OK, so we can send the connection parameters */
rtsp_reply_header ( c , RTSP_STATUS_OK ) ;
/* session ID */
url_fprintf ( c - > pb , " Session: %s \r \n " , rtp_c - > session_id ) ;
url_fprintf ( c - > pb , " \r \n " ) ;
}
static void rtsp_cmd_pause ( HTTPContext * c , const char * url , RTSPHeader * h )
{
HTTPContext * rtp_c ;
rtp_c = find_rtp_session_with_url ( url , h - > session_id ) ;
if ( ! rtp_c ) {
rtsp_reply_error ( c , RTSP_STATUS_SESSION ) ;
return ;
}
2005-12-17 19:14:38 +01:00
2002-07-25 18:48:44 +02:00
if ( rtp_c - > state ! = HTTPSTATE_SEND_DATA & &
rtp_c - > state ! = HTTPSTATE_WAIT_FEED ) {
rtsp_reply_error ( c , RTSP_STATUS_STATE ) ;
return ;
}
2005-12-17 19:14:38 +01:00
2002-07-25 18:48:44 +02:00
rtp_c - > state = HTTPSTATE_READY ;
2003-07-12 00:30:12 +02:00
rtp_c - > first_pts = AV_NOPTS_VALUE ;
2002-07-25 18:48:44 +02:00
/* now everything is OK, so we can send the connection parameters */
rtsp_reply_header ( c , RTSP_STATUS_OK ) ;
/* session ID */
url_fprintf ( c - > pb , " Session: %s \r \n " , rtp_c - > session_id ) ;
url_fprintf ( c - > pb , " \r \n " ) ;
}
static void rtsp_cmd_teardown ( HTTPContext * c , const char * url , RTSPHeader * h )
{
HTTPContext * rtp_c ;
2007-04-19 15:55:06 +02:00
char session_id [ 32 ] ;
2002-07-25 18:48:44 +02:00
rtp_c = find_rtp_session_with_url ( url , h - > session_id ) ;
if ( ! rtp_c ) {
rtsp_reply_error ( c , RTSP_STATUS_SESSION ) ;
return ;
}
2005-12-17 19:14:38 +01:00
2007-04-19 15:55:06 +02:00
pstrcpy ( session_id , sizeof ( session_id ) , rtp_c - > session_id ) ;
2002-07-25 18:48:44 +02:00
/* abort the session */
close_connection ( rtp_c ) ;
/* now everything is OK, so we can send the connection parameters */
rtsp_reply_header ( c , RTSP_STATUS_OK ) ;
/* session ID */
2007-04-19 15:55:06 +02:00
url_fprintf ( c - > pb , " Session: %s \r \n " , session_id ) ;
2002-07-25 18:48:44 +02:00
url_fprintf ( c - > pb , " \r \n " ) ;
}
/********************************************************************/
/* RTP handling */
2005-12-17 19:14:38 +01:00
static HTTPContext * rtp_new_connection ( struct sockaddr_in * from_addr ,
2003-07-17 12:31:23 +02:00
FFStream * stream , const char * session_id ,
enum RTSPProtocol rtp_protocol )
2002-07-25 18:48:44 +02:00
{
HTTPContext * c = NULL ;
2003-07-17 12:31:23 +02:00
const char * proto_str ;
2005-12-17 19:14:38 +01:00
2002-07-25 18:48:44 +02:00
/* XXX: should output a warning page when coming
close to the connection limit */
if ( nb_connections > = nb_max_connections )
goto fail ;
2005-12-17 19:14:38 +01:00
2002-07-25 18:48:44 +02:00
/* add a new connection */
c = av_mallocz ( sizeof ( HTTPContext ) ) ;
if ( ! c )
goto fail ;
2005-12-17 19:14:38 +01:00
2002-07-25 18:48:44 +02:00
c - > fd = - 1 ;
c - > poll_entry = NULL ;
2002-11-20 19:05:45 +01:00
c - > from_addr = * from_addr ;
2002-07-25 18:48:44 +02:00
c - > buffer_size = IOBUFFER_INIT_SIZE ;
c - > buffer = av_malloc ( c - > buffer_size ) ;
if ( ! c - > buffer )
goto fail ;
nb_connections + + ;
c - > stream = stream ;
pstrcpy ( c - > session_id , sizeof ( c - > session_id ) , session_id ) ;
c - > state = HTTPSTATE_READY ;
c - > is_packetized = 1 ;
2003-07-17 12:31:23 +02:00
c - > rtp_protocol = rtp_protocol ;
2002-07-25 18:48:44 +02:00
/* protocol is shown in statistics */
2003-07-17 12:31:23 +02:00
switch ( c - > rtp_protocol ) {
case RTSP_PROTOCOL_RTP_UDP_MULTICAST :
proto_str = " MCAST " ;
break ;
case RTSP_PROTOCOL_RTP_UDP :
proto_str = " UDP " ;
break ;
case RTSP_PROTOCOL_RTP_TCP :
proto_str = " TCP " ;
break ;
default :
proto_str = " ??? " ;
break ;
}
pstrcpy ( c - > protocol , sizeof ( c - > protocol ) , " RTP/ " ) ;
pstrcat ( c - > protocol , sizeof ( c - > protocol ) , proto_str ) ;
2002-07-25 18:48:44 +02:00
2002-11-20 19:05:45 +01:00
current_bandwidth + = stream - > bandwidth ;
2002-07-25 18:48:44 +02:00
c - > next = first_http_ctx ;
first_http_ctx = c ;
return c ;
2005-12-17 19:14:38 +01:00
2002-07-25 18:48:44 +02:00
fail :
if ( c ) {
av_free ( c - > buffer ) ;
av_free ( c ) ;
}
return NULL ;
}
/* add a new RTP stream in an RTP connection (used in RTSP SETUP
2003-07-17 12:31:23 +02:00
command ) . If RTP / TCP protocol is used , TCP connection ' rtsp_c ' is
2002-07-25 18:48:44 +02:00
used . */
2005-12-17 19:14:38 +01:00
static int rtp_new_av_stream ( HTTPContext * c ,
2003-07-17 12:31:23 +02:00
int stream_index , struct sockaddr_in * dest_addr ,
HTTPContext * rtsp_c )
2002-07-25 18:48:44 +02:00
{
AVFormatContext * ctx ;
AVStream * st ;
char * ipaddr ;
URLContext * h ;
2003-02-11 17:35:48 +01:00
uint8_t * dummy_buf ;
2002-11-20 19:05:45 +01:00
char buf2 [ 32 ] ;
2003-07-17 12:31:23 +02:00
int max_packet_size ;
2005-12-17 19:14:38 +01:00
2002-07-25 18:48:44 +02:00
/* now we can open the relevant output stream */
2004-03-03 16:41:21 +01:00
ctx = av_alloc_format_context ( ) ;
2002-07-25 18:48:44 +02:00
if ( ! ctx )
return - 1 ;
2006-07-10 01:40:53 +02:00
ctx - > oformat = & rtp_muxer ;
2002-07-25 18:48:44 +02:00
st = av_mallocz ( sizeof ( AVStream ) ) ;
if ( ! st )
goto fail ;
2005-07-18 11:02:58 +02:00
st - > codec = avcodec_alloc_context ( ) ;
2002-07-25 18:48:44 +02:00
ctx - > nb_streams = 1 ;
ctx - > streams [ 0 ] = st ;
2005-12-17 19:14:38 +01:00
if ( ! c - > stream - > feed | |
2002-07-25 18:48:44 +02:00
c - > stream - > feed = = c - > stream ) {
memcpy ( st , c - > stream - > streams [ stream_index ] , sizeof ( AVStream ) ) ;
} else {
2005-12-17 19:14:38 +01:00
memcpy ( st ,
2002-07-25 18:48:44 +02:00
c - > stream - > feed - > streams [ c - > stream - > feed_streams [ stream_index ] ] ,
sizeof ( AVStream ) ) ;
}
2005-12-17 19:14:38 +01:00
2003-07-17 12:31:23 +02:00
/* build destination RTP address */
ipaddr = inet_ntoa ( dest_addr - > sin_addr ) ;
switch ( c - > rtp_protocol ) {
case RTSP_PROTOCOL_RTP_UDP :
case RTSP_PROTOCOL_RTP_UDP_MULTICAST :
/* RTP/UDP case */
2005-12-17 19:14:38 +01:00
2002-11-20 19:05:45 +01:00
/* XXX: also pass as parameter to function ? */
if ( c - > stream - > is_multicast ) {
int ttl ;
ttl = c - > stream - > multicast_ttl ;
if ( ! ttl )
ttl = 16 ;
snprintf ( ctx - > filename , sizeof ( ctx - > filename ) ,
2005-12-17 19:14:38 +01:00
" rtp://%s:%d?multicast=1&ttl=%d " ,
2002-11-20 19:05:45 +01:00
ipaddr , ntohs ( dest_addr - > sin_port ) , ttl ) ;
} else {
snprintf ( ctx - > filename , sizeof ( ctx - > filename ) ,
" rtp://%s:%d " , ipaddr , ntohs ( dest_addr - > sin_port ) ) ;
}
2002-07-25 18:48:44 +02:00
if ( url_open ( & h , ctx - > filename , URL_WRONLY ) < 0 )
goto fail ;
c - > rtp_handles [ stream_index ] = h ;
2003-07-17 12:31:23 +02:00
max_packet_size = url_get_max_packet_size ( h ) ;
break ;
case RTSP_PROTOCOL_RTP_TCP :
/* RTP/TCP case */
c - > rtsp_c = rtsp_c ;
max_packet_size = RTSP_TCP_MAX_PACKET_SIZE ;
break ;
default :
2002-07-25 18:48:44 +02:00
goto fail ;
}
2003-07-17 12:31:23 +02:00
http_log ( " %s:%d - - [%s] \" PLAY %s/streamid=%d %s \" \n " ,
2005-12-17 19:14:38 +01:00
ipaddr , ntohs ( dest_addr - > sin_port ) ,
ctime1 ( buf2 ) ,
2003-07-17 12:31:23 +02:00
c - > stream - > filename , stream_index , c - > protocol ) ;
2002-11-20 19:05:45 +01:00
2002-07-25 18:48:44 +02:00
/* normally, no packets should be output here, but the packet size may be checked */
2003-07-17 12:31:23 +02:00
if ( url_open_dyn_packet_buf ( & ctx - > pb , max_packet_size ) < 0 ) {
2002-07-25 18:48:44 +02:00
/* XXX: close stream */
goto fail ;
}
2003-01-11 06:14:28 +01:00
av_set_parameters ( ctx , NULL ) ;
2002-07-25 18:48:44 +02:00
if ( av_write_header ( ctx ) < 0 ) {
fail :
if ( h )
url_close ( h ) ;
av_free ( ctx ) ;
return - 1 ;
}
url_close_dyn_buf ( & ctx - > pb , & dummy_buf ) ;
av_free ( dummy_buf ) ;
2005-12-17 19:14:38 +01:00
2002-07-25 18:48:44 +02:00
c - > rtp_ctx [ stream_index ] = ctx ;
return 0 ;
}
/********************************************************************/
/* ffserver initialization */
2003-02-10 10:44:47 +01:00
static AVStream * add_av_stream1 ( FFStream * stream , AVCodecContext * codec )
2002-07-25 18:48:44 +02:00
{
AVStream * fst ;
fst = av_mallocz ( sizeof ( AVStream ) ) ;
if ( ! fst )
return NULL ;
2005-07-18 11:02:58 +02:00
fst - > codec = avcodec_alloc_context ( ) ;
2002-07-25 18:48:44 +02:00
fst - > priv_data = av_mallocz ( sizeof ( FeedData ) ) ;
2005-07-18 00:24:36 +02:00
memcpy ( fst - > codec , codec , sizeof ( AVCodecContext ) ) ;
fst - > codec - > coded_frame = & dummy_frame ;
2003-11-19 03:23:17 +01:00
fst - > index = stream - > nb_streams ;
2005-01-03 03:42:02 +01:00
av_set_pts_info ( fst , 33 , 1 , 90000 ) ;
2002-07-25 18:48:44 +02:00
stream - > streams [ stream - > nb_streams + + ] = fst ;
return fst ;
}
2001-07-22 16:37:44 +02:00
/* return the stream number in the feed */
2003-02-10 10:44:47 +01:00
static int add_av_stream ( FFStream * feed , AVStream * st )
2001-07-22 16:37:44 +02:00
{
AVStream * fst ;
AVCodecContext * av , * av1 ;
int i ;
2005-07-18 00:24:36 +02:00
av = st - > codec ;
2001-07-22 16:37:44 +02:00
for ( i = 0 ; i < feed - > nb_streams ; i + + ) {
st = feed - > streams [ i ] ;
2005-07-18 00:24:36 +02:00
av1 = st - > codec ;
2002-05-09 03:11:08 +02:00
if ( av1 - > codec_id = = av - > codec_id & &
av1 - > codec_type = = av - > codec_type & &
2001-07-22 16:37:44 +02:00
av1 - > bit_rate = = av - > bit_rate ) {
switch ( av - > codec_type ) {
case CODEC_TYPE_AUDIO :
if ( av1 - > channels = = av - > channels & &
av1 - > sample_rate = = av - > sample_rate )
goto found ;
break ;
case CODEC_TYPE_VIDEO :
if ( av1 - > width = = av - > width & &
av1 - > height = = av - > height & &
2005-04-30 23:43:59 +02:00
av1 - > time_base . den = = av - > time_base . den & &
av1 - > time_base . num = = av - > time_base . num & &
2001-07-22 16:37:44 +02:00
av1 - > gop_size = = av - > gop_size )
goto found ;
break ;
2002-05-09 03:11:08 +02:00
default :
2002-05-24 03:18:19 +02:00
av_abort ( ) ;
2001-07-22 16:37:44 +02:00
}
}
}
2005-12-17 19:14:38 +01:00
2002-07-25 18:48:44 +02:00
fst = add_av_stream1 ( feed , av ) ;
2001-07-22 16:37:44 +02:00
if ( ! fst )
return - 1 ;
return feed - > nb_streams - 1 ;
found :
return i ;
}
2003-02-10 10:44:47 +01:00
static void remove_stream ( FFStream * stream )
2002-07-25 18:48:44 +02:00
{
FFStream * * ps ;
ps = & first_stream ;
while ( * ps ! = NULL ) {
if ( * ps = = stream ) {
* ps = ( * ps ) - > next ;
} else {
ps = & ( * ps ) - > next ;
}
}
}
2002-11-20 21:49:47 +01:00
/* specific mpeg4 handling : we extract the raw parameters */
2003-02-10 10:44:47 +01:00
static void extract_mpeg4_header ( AVFormatContext * infile )
2002-11-20 21:49:47 +01:00
{
int mpeg4_count , i , size ;
AVPacket pkt ;
AVStream * st ;
2003-02-11 17:35:48 +01:00
const uint8_t * p ;
2002-11-20 21:49:47 +01:00
mpeg4_count = 0 ;
for ( i = 0 ; i < infile - > nb_streams ; i + + ) {
st = infile - > streams [ i ] ;
2005-07-18 00:24:36 +02:00
if ( st - > codec - > codec_id = = CODEC_ID_MPEG4 & &
st - > codec - > extradata_size = = 0 ) {
2002-11-20 21:49:47 +01:00
mpeg4_count + + ;
}
}
if ( ! mpeg4_count )
return ;
2003-11-19 03:23:17 +01:00
printf ( " MPEG4 without extra data: trying to find header in %s \n " , infile - > filename ) ;
2002-11-20 21:49:47 +01:00
while ( mpeg4_count > 0 ) {
if ( av_read_packet ( infile , & pkt ) < 0 )
break ;
st = infile - > streams [ pkt . stream_index ] ;
2005-07-18 00:24:36 +02:00
if ( st - > codec - > codec_id = = CODEC_ID_MPEG4 & &
st - > codec - > extradata_size = = 0 ) {
av_freep ( & st - > codec - > extradata ) ;
2002-11-20 21:49:47 +01:00
/* fill extradata with the header */
/* XXX: we make hard suppositions here ! */
p = pkt . data ;
while ( p < pkt . data + pkt . size - 4 ) {
/* stop when vop header is found */
2005-12-17 19:14:38 +01:00
if ( p [ 0 ] = = 0x00 & & p [ 1 ] = = 0x00 & &
2002-11-20 21:49:47 +01:00
p [ 2 ] = = 0x01 & & p [ 3 ] = = 0xb6 ) {
size = p - pkt . data ;
2007-03-12 15:17:26 +01:00
// av_hex_dump_log(infile, AV_LOG_DEBUG, pkt.data, size);
2005-07-18 00:24:36 +02:00
st - > codec - > extradata = av_malloc ( size ) ;
st - > codec - > extradata_size = size ;
memcpy ( st - > codec - > extradata , pkt . data , size ) ;
2002-11-20 21:49:47 +01:00
break ;
}
p + + ;
}
mpeg4_count - - ;
}
av_free_packet ( & pkt ) ;
}
}
2002-07-25 18:48:44 +02:00
/* compute the needed AVStream for each file */
2003-02-10 10:44:47 +01:00
static void build_file_streams ( void )
2002-07-25 18:48:44 +02:00
{
FFStream * stream , * stream_next ;
AVFormatContext * infile ;
int i ;
/* gather all streams */
for ( stream = first_stream ; stream ! = NULL ; stream = stream_next ) {
stream_next = stream - > next ;
if ( stream - > stream_type = = STREAM_TYPE_LIVE & &
! stream - > feed ) {
/* the stream comes from a file */
/* try to open the file */
/* open stream */
2003-11-10 20:02:56 +01:00
stream - > ap_in = av_mallocz ( sizeof ( AVFormatParameters ) ) ;
2006-07-10 01:40:53 +02:00
if ( stream - > fmt = = & rtp_muxer ) {
2003-11-10 20:02:56 +01:00
/* specific case : if transport stream output to RTP,
we use a raw transport stream reader */
stream - > ap_in - > mpeg2ts_raw = 1 ;
stream - > ap_in - > mpeg2ts_compute_pcr = 1 ;
}
2005-12-17 19:14:38 +01:00
if ( av_open_input_file ( & infile , stream - > feed_filename ,
2003-11-10 20:02:56 +01:00
stream - > ifmt , 0 , stream - > ap_in ) < 0 ) {
2002-07-25 18:48:44 +02:00
http_log ( " %s not found " , stream - > feed_filename ) ;
/* remove stream (no need to spend more time on it) */
fail :
remove_stream ( stream ) ;
} else {
/* find all the AVStreams inside and reference them in
' stream ' */
if ( av_find_stream_info ( infile ) < 0 ) {
2005-12-17 19:14:38 +01:00
http_log ( " Could not find codec parameters from '%s' " ,
2002-07-25 18:48:44 +02:00
stream - > feed_filename ) ;
av_close_input_file ( infile ) ;
goto fail ;
}
2002-11-20 21:49:47 +01:00
extract_mpeg4_header ( infile ) ;
2002-07-25 18:48:44 +02:00
for ( i = 0 ; i < infile - > nb_streams ; i + + ) {
2005-07-18 00:24:36 +02:00
add_av_stream1 ( stream , infile - > streams [ i ] - > codec ) ;
2002-07-25 18:48:44 +02:00
}
av_close_input_file ( infile ) ;
}
}
}
}
2001-07-22 16:37:44 +02:00
/* compute the needed AVStream for each feed */
2003-02-10 10:44:47 +01:00
static void build_feed_streams ( void )
2001-07-22 16:37:44 +02:00
{
FFStream * stream , * feed ;
int i ;
/* gather all streams */
for ( stream = first_stream ; stream ! = NULL ; stream = stream - > next ) {
feed = stream - > feed ;
if ( feed ) {
if ( ! stream - > is_feed ) {
2002-07-25 18:48:44 +02:00
/* we handle a stream coming from a feed */
2001-07-22 16:37:44 +02:00
for ( i = 0 ; i < stream - > nb_streams ; i + + ) {
stream - > feed_streams [ i ] = add_av_stream ( feed , stream - > streams [ i ] ) ;
}
2002-05-30 04:49:07 +02:00
}
}
}
/* gather all streams */
for ( stream = first_stream ; stream ! = NULL ; stream = stream - > next ) {
feed = stream - > feed ;
if ( feed ) {
if ( stream - > is_feed ) {
2001-07-22 16:37:44 +02:00
for ( i = 0 ; i < stream - > nb_streams ; i + + ) {
stream - > feed_streams [ i ] = i ;
}
}
}
}
/* create feed files if needed */
for ( feed = first_feed ; feed ! = NULL ; feed = feed - > next_feed ) {
int fd ;
2002-07-28 06:19:46 +02:00
if ( url_exist ( feed - > feed_filename ) ) {
/* See if it matches */
AVFormatContext * s ;
int matches = 0 ;
if ( av_open_input_file ( & s , feed - > feed_filename , NULL , FFM_PACKET_SIZE , NULL ) > = 0 ) {
/* Now see if it matches */
if ( s - > nb_streams = = feed - > nb_streams ) {
matches = 1 ;
for ( i = 0 ; i < s - > nb_streams ; i + + ) {
AVStream * sf , * ss ;
sf = feed - > streams [ i ] ;
ss = s - > streams [ i ] ;
if ( sf - > index ! = ss - > index | |
sf - > id ! = ss - > id ) {
2005-12-17 19:14:38 +01:00
printf ( " Index & Id do not match for stream %d (%s) \n " ,
2003-11-10 20:02:56 +01:00
i , feed - > feed_filename ) ;
2002-07-28 06:19:46 +02:00
matches = 0 ;
} else {
AVCodecContext * ccf , * ccs ;
2005-07-18 00:24:36 +02:00
ccf = sf - > codec ;
ccs = ss - > codec ;
2002-07-28 06:19:46 +02:00
# define CHECK_CODEC(x) (ccf->x != ccs->x)
if ( CHECK_CODEC ( codec ) | | CHECK_CODEC ( codec_type ) ) {
printf ( " Codecs do not match for stream %d \n " , i ) ;
matches = 0 ;
} else if ( CHECK_CODEC ( bit_rate ) | | CHECK_CODEC ( flags ) ) {
printf ( " Codec bitrates do not match for stream %d \n " , i ) ;
matches = 0 ;
} else if ( ccf - > codec_type = = CODEC_TYPE_VIDEO ) {
2005-04-30 23:43:59 +02:00
if ( CHECK_CODEC ( time_base . den ) | |
CHECK_CODEC ( time_base . num ) | |
2002-07-28 06:19:46 +02:00
CHECK_CODEC ( width ) | |
CHECK_CODEC ( height ) ) {
printf ( " Codec width, height and framerate do not match for stream %d \n " , i ) ;
matches = 0 ;
}
} else if ( ccf - > codec_type = = CODEC_TYPE_AUDIO ) {
if ( CHECK_CODEC ( sample_rate ) | |
CHECK_CODEC ( channels ) | |
CHECK_CODEC ( frame_size ) ) {
printf ( " Codec sample_rate, channels, frame_size do not match for stream %d \n " , i ) ;
matches = 0 ;
}
} else {
printf ( " Unknown codec type \n " ) ;
matches = 0 ;
}
}
if ( ! matches ) {
break ;
}
}
} else {
printf ( " Deleting feed file '%s' as stream counts differ (%d != %d) \n " ,
feed - > feed_filename , s - > nb_streams , feed - > nb_streams ) ;
}
av_close_input_file ( s ) ;
} else {
printf ( " Deleting feed file '%s' as it appears to be corrupt \n " ,
feed - > feed_filename ) ;
}
2003-04-09 04:16:01 +02:00
if ( ! matches ) {
if ( feed - > readonly ) {
printf ( " Unable to delete feed file '%s' as it is marked readonly \n " ,
feed - > feed_filename ) ;
exit ( 1 ) ;
}
2002-07-28 06:19:46 +02:00
unlink ( feed - > feed_filename ) ;
2003-04-09 04:16:01 +02:00
}
2002-07-28 06:19:46 +02:00
}
2001-07-22 16:37:44 +02:00
if ( ! url_exist ( feed - > feed_filename ) ) {
AVFormatContext s1 , * s = & s1 ;
2003-04-09 04:16:01 +02:00
if ( feed - > readonly ) {
printf ( " Unable to create feed file '%s' as it is marked readonly \n " ,
feed - > feed_filename ) ;
exit ( 1 ) ;
}
2001-07-22 16:37:44 +02:00
/* only write the header of the ffm file */
if ( url_fopen ( & s - > pb , feed - > feed_filename , URL_WRONLY ) < 0 ) {
fprintf ( stderr , " Could not open output feed file '%s' \n " ,
feed - > feed_filename ) ;
exit ( 1 ) ;
}
2002-05-20 18:33:46 +02:00
s - > oformat = feed - > fmt ;
2001-07-22 16:37:44 +02:00
s - > nb_streams = feed - > nb_streams ;
for ( i = 0 ; i < s - > nb_streams ; i + + ) {
AVStream * st ;
st = feed - > streams [ i ] ;
s - > streams [ i ] = st ;
}
2003-01-11 06:14:28 +01:00
av_set_parameters ( s , NULL ) ;
2007-02-24 03:24:42 +01:00
if ( av_write_header ( s ) < 0 ) {
fprintf ( stderr , " Container doesn't supports the required parameters \n " ) ;
exit ( 1 ) ;
}
2002-05-20 18:33:46 +02:00
/* XXX: need better api */
av_freep ( & s - > priv_data ) ;
2001-07-22 16:37:44 +02:00
url_fclose ( & s - > pb ) ;
}
/* get feed size and write index */
fd = open ( feed - > feed_filename , O_RDONLY ) ;
if ( fd < 0 ) {
fprintf ( stderr , " Could not open output feed file '%s' \n " ,
feed - > feed_filename ) ;
exit ( 1 ) ;
}
feed - > feed_write_index = ffm_read_write_index ( fd ) ;
feed - > feed_size = lseek ( fd , 0 , SEEK_END ) ;
/* ensure that we do not wrap before the end of file */
2005-11-13 04:26:43 +01:00
if ( feed - > feed_max_size & & feed - > feed_max_size < feed - > feed_size )
2001-07-22 16:37:44 +02:00
feed - > feed_max_size = feed - > feed_size ;
close ( fd ) ;
}
}
2002-11-20 19:05:45 +01:00
/* compute the bandwidth used by each stream */
static void compute_bandwidth ( void )
{
int bandwidth , i ;
FFStream * stream ;
2005-12-17 19:14:38 +01:00
2002-11-20 19:05:45 +01:00
for ( stream = first_stream ; stream ! = NULL ; stream = stream - > next ) {
bandwidth = 0 ;
for ( i = 0 ; i < stream - > nb_streams ; i + + ) {
AVStream * st = stream - > streams [ i ] ;
2005-07-18 00:24:36 +02:00
switch ( st - > codec - > codec_type ) {
2002-11-20 19:05:45 +01:00
case CODEC_TYPE_AUDIO :
case CODEC_TYPE_VIDEO :
2005-07-18 00:24:36 +02:00
bandwidth + = st - > codec - > bit_rate ;
2002-11-20 19:05:45 +01:00
break ;
default :
break ;
}
}
stream - > bandwidth = ( bandwidth + 999 ) / 1000 ;
}
}
2001-07-22 16:37:44 +02:00
static void get_arg ( char * buf , int buf_size , const char * * pp )
{
const char * p ;
char * q ;
int quote ;
p = * pp ;
while ( isspace ( * p ) ) p + + ;
q = buf ;
quote = 0 ;
if ( * p = = ' \" ' | | * p = = ' \' ' )
quote = * p + + ;
for ( ; ; ) {
if ( quote ) {
if ( * p = = quote )
break ;
} else {
if ( isspace ( * p ) )
break ;
}
if ( * p = = ' \0 ' )
break ;
if ( ( q - buf ) < buf_size - 1 )
* q + + = * p ;
p + + ;
}
* q = ' \0 ' ;
if ( quote & & * p = = quote )
p + + ;
* pp = p ;
}
/* add a codec and set the default parameters */
2003-02-10 10:44:47 +01:00
static void add_codec ( FFStream * stream , AVCodecContext * av )
2001-07-22 16:37:44 +02:00
{
AVStream * st ;
/* compute default parameters */
switch ( av - > codec_type ) {
case CODEC_TYPE_AUDIO :
if ( av - > bit_rate = = 0 )
av - > bit_rate = 64000 ;
if ( av - > sample_rate = = 0 )
av - > sample_rate = 22050 ;
if ( av - > channels = = 0 )
av - > channels = 1 ;
break ;
case CODEC_TYPE_VIDEO :
if ( av - > bit_rate = = 0 )
av - > bit_rate = 64000 ;
2005-04-30 23:43:59 +02:00
if ( av - > time_base . num = = 0 ) {
av - > time_base . den = 5 ;
av - > time_base . num = 1 ;
2003-03-12 16:16:19 +01:00
}
2001-07-22 16:37:44 +02:00
if ( av - > width = = 0 | | av - > height = = 0 ) {
av - > width = 160 ;
av - > height = 128 ;
}
2002-05-09 04:33:27 +02:00
/* Bitrate tolerance is less for streaming */
2002-05-16 04:03:07 +02:00
if ( av - > bit_rate_tolerance = = 0 )
av - > bit_rate_tolerance = av - > bit_rate / 4 ;
if ( av - > qmin = = 0 )
av - > qmin = 3 ;
if ( av - > qmax = = 0 )
av - > qmax = 31 ;
if ( av - > max_qdiff = = 0 )
av - > max_qdiff = 3 ;
2002-05-09 04:33:27 +02:00
av - > qcompress = 0.5 ;
av - > qblur = 0.5 ;
2002-03-19 05:31:10 +01:00
2005-12-17 19:14:38 +01:00
if ( ! av - > nsse_weight )
2005-05-06 05:21:04 +02:00
av - > nsse_weight = 8 ;
av - > frame_skip_cmp = FF_CMP_DCTMAX ;
av - > me_method = ME_EPZS ;
av - > rc_buffer_aggressivity = 1.0 ;
2002-09-12 04:31:11 +02:00
if ( ! av - > rc_eq )
av - > rc_eq = " tex^qComp " ;
if ( ! av - > i_quant_factor )
2002-09-19 22:22:39 +02:00
av - > i_quant_factor = - 0.8 ;
2002-09-12 04:31:11 +02:00
if ( ! av - > b_quant_factor )
av - > b_quant_factor = 1.25 ;
if ( ! av - > b_quant_offset )
av - > b_quant_offset = 1.25 ;
2002-10-30 03:15:07 +01:00
if ( ! av - > rc_max_rate )
av - > rc_max_rate = av - > bit_rate * 2 ;
2002-09-12 04:31:11 +02:00
2005-05-06 05:21:04 +02:00
if ( av - > rc_max_rate & & ! av - > rc_buffer_size ) {
av - > rc_buffer_size = av - > rc_max_rate ;
}
2001-07-22 16:37:44 +02:00
break ;
2002-05-09 03:11:08 +02:00
default :
2002-05-24 03:18:19 +02:00
av_abort ( ) ;
2001-07-22 16:37:44 +02:00
}
st = av_mallocz ( sizeof ( AVStream ) ) ;
if ( ! st )
return ;
2005-07-18 11:02:58 +02:00
st - > codec = avcodec_alloc_context ( ) ;
2001-07-22 16:37:44 +02:00
stream - > streams [ stream - > nb_streams + + ] = st ;
2005-07-18 00:24:36 +02:00
memcpy ( st - > codec , av , sizeof ( AVCodecContext ) ) ;
2001-07-22 16:37:44 +02:00
}
2003-02-10 10:44:47 +01:00
static int opt_audio_codec ( const char * arg )
2002-05-09 03:11:08 +02:00
{
AVCodec * p ;
p = first_avcodec ;
while ( p ) {
if ( ! strcmp ( p - > name , arg ) & & p - > type = = CODEC_TYPE_AUDIO )
break ;
p = p - > next ;
}
if ( p = = NULL ) {
return CODEC_ID_NONE ;
}
return p - > id ;
}
2003-02-10 10:44:47 +01:00
static int opt_video_codec ( const char * arg )
2002-05-09 03:11:08 +02:00
{
AVCodec * p ;
p = first_avcodec ;
while ( p ) {
if ( ! strcmp ( p - > name , arg ) & & p - > type = = CODEC_TYPE_VIDEO )
break ;
p = p - > next ;
}
if ( p = = NULL ) {
return CODEC_ID_NONE ;
}
return p - > id ;
}
2002-07-25 18:48:44 +02:00
/* simplistic plugin support */
2006-11-14 00:14:24 +01:00
# ifdef HAVE_DLOPEN
2006-06-18 13:33:14 +02:00
static void load_module ( const char * filename )
2002-07-25 18:48:44 +02:00
{
void * dll ;
void ( * init_func ) ( void ) ;
dll = dlopen ( filename , RTLD_NOW ) ;
if ( ! dll ) {
fprintf ( stderr , " Could not load module '%s' - %s \n " ,
filename , dlerror ( ) ) ;
return ;
}
2005-12-17 19:14:38 +01:00
2002-07-25 18:48:44 +02:00
init_func = dlsym ( dll , " ffserver_module_init " ) ;
if ( ! init_func ) {
2005-12-17 19:14:38 +01:00
fprintf ( stderr ,
2002-07-25 18:48:44 +02:00
" %s: init function 'ffserver_module_init()' not found \n " ,
filename ) ;
dlclose ( dll ) ;
}
init_func ( ) ;
}
2002-11-30 18:18:59 +01:00
# endif
2002-07-25 18:48:44 +02:00
2003-02-10 10:44:47 +01:00
static int parse_ffconfig ( const char * filename )
2001-07-22 16:37:44 +02:00
{
FILE * f ;
char line [ 1024 ] ;
char cmd [ 64 ] ;
char arg [ 1024 ] ;
const char * p ;
int val , errors , line_num ;
2002-05-30 04:49:07 +02:00
FFStream * * last_stream , * stream , * redirect ;
2001-07-22 16:37:44 +02:00
FFStream * * last_feed , * feed ;
AVCodecContext audio_enc , video_enc ;
int audio_id , video_id ;
f = fopen ( filename , " r " ) ;
if ( ! f ) {
perror ( filename ) ;
return - 1 ;
}
2005-12-17 19:14:38 +01:00
2001-07-22 16:37:44 +02:00
errors = 0 ;
line_num = 0 ;
first_stream = NULL ;
last_stream = & first_stream ;
first_feed = NULL ;
last_feed = & first_feed ;
stream = NULL ;
feed = NULL ;
2002-05-30 04:49:07 +02:00
redirect = NULL ;
2001-07-22 16:37:44 +02:00
audio_id = CODEC_ID_NONE ;
video_id = CODEC_ID_NONE ;
for ( ; ; ) {
if ( fgets ( line , sizeof ( line ) , f ) = = NULL )
break ;
line_num + + ;
p = line ;
2005-12-17 19:14:38 +01:00
while ( isspace ( * p ) )
2001-07-22 16:37:44 +02:00
p + + ;
if ( * p = = ' \0 ' | | * p = = ' # ' )
continue ;
get_arg ( cmd , sizeof ( cmd ) , & p ) ;
2005-12-17 19:14:38 +01:00
2001-07-22 16:37:44 +02:00
if ( ! strcasecmp ( cmd , " Port " ) ) {
get_arg ( arg , sizeof ( arg ) , & p ) ;
2002-07-25 18:48:44 +02:00
my_http_addr . sin_port = htons ( atoi ( arg ) ) ;
2001-07-22 16:37:44 +02:00
} else if ( ! strcasecmp ( cmd , " BindAddress " ) ) {
get_arg ( arg , sizeof ( arg ) , & p ) ;
2002-07-25 18:48:44 +02:00
if ( ! inet_aton ( arg , & my_http_addr . sin_addr ) ) {
2005-12-17 19:14:38 +01:00
fprintf ( stderr , " %s:%d: Invalid IP address: %s \n " ,
2002-07-25 18:48:44 +02:00
filename , line_num , arg ) ;
errors + + ;
}
} else if ( ! strcasecmp ( cmd , " NoDaemon " ) ) {
ffserver_daemon = 0 ;
} else if ( ! strcasecmp ( cmd , " RTSPPort " ) ) {
get_arg ( arg , sizeof ( arg ) , & p ) ;
my_rtsp_addr . sin_port = htons ( atoi ( arg ) ) ;
} else if ( ! strcasecmp ( cmd , " RTSPBindAddress " ) ) {
get_arg ( arg , sizeof ( arg ) , & p ) ;
if ( ! inet_aton ( arg , & my_rtsp_addr . sin_addr ) ) {
2005-12-17 19:14:38 +01:00
fprintf ( stderr , " %s:%d: Invalid IP address: %s \n " ,
2001-07-22 16:37:44 +02:00
filename , line_num , arg ) ;
errors + + ;
}
} else if ( ! strcasecmp ( cmd , " MaxClients " ) ) {
get_arg ( arg , sizeof ( arg ) , & p ) ;
val = atoi ( arg ) ;
if ( val < 1 | | val > HTTP_MAX_CONNECTIONS ) {
2005-12-17 19:14:38 +01:00
fprintf ( stderr , " %s:%d: Invalid MaxClients: %s \n " ,
2001-07-22 16:37:44 +02:00
filename , line_num , arg ) ;
errors + + ;
} else {
nb_max_connections = val ;
}
2002-05-16 04:03:07 +02:00
} else if ( ! strcasecmp ( cmd , " MaxBandwidth " ) ) {
get_arg ( arg , sizeof ( arg ) , & p ) ;
val = atoi ( arg ) ;
if ( val < 10 | | val > 100000 ) {
2005-12-17 19:14:38 +01:00
fprintf ( stderr , " %s:%d: Invalid MaxBandwidth: %s \n " ,
2002-05-16 04:03:07 +02:00
filename , line_num , arg ) ;
errors + + ;
} else {
2002-11-20 19:05:45 +01:00
max_bandwidth = val ;
2002-05-16 04:03:07 +02:00
}
2001-07-22 16:37:44 +02:00
} else if ( ! strcasecmp ( cmd , " CustomLog " ) ) {
get_arg ( logfilename , sizeof ( logfilename ) , & p ) ;
} else if ( ! strcasecmp ( cmd , " <Feed " ) ) {
/*********************************************/
/* Feed related options */
char * q ;
if ( stream | | feed ) {
fprintf ( stderr , " %s:%d: Already in a tag \n " ,
filename , line_num ) ;
} else {
feed = av_mallocz ( sizeof ( FFStream ) ) ;
/* add in stream list */
* last_stream = feed ;
last_stream = & feed - > next ;
/* add in feed list */
* last_feed = feed ;
last_feed = & feed - > next_feed ;
2005-12-17 19:14:38 +01:00
2001-07-22 16:37:44 +02:00
get_arg ( feed - > filename , sizeof ( feed - > filename ) , & p ) ;
q = strrchr ( feed - > filename , ' > ' ) ;
if ( * q )
* q = ' \0 ' ;
feed - > fmt = guess_format ( " ffm " , NULL , NULL ) ;
/* defaut feed file */
snprintf ( feed - > feed_filename , sizeof ( feed - > feed_filename ) ,
" /tmp/%s.ffm " , feed - > filename ) ;
feed - > feed_max_size = 5 * 1024 * 1024 ;
feed - > is_feed = 1 ;
feed - > feed = feed ; /* self feeding :-) */
}
2002-05-30 04:49:07 +02:00
} else if ( ! strcasecmp ( cmd , " Launch " ) ) {
if ( feed ) {
int i ;
feed - > child_argv = ( char * * ) av_mallocz ( 64 * sizeof ( char * ) ) ;
2005-11-13 02:45:13 +01:00
for ( i = 0 ; i < 62 ; i + + ) {
2002-05-30 04:49:07 +02:00
char argbuf [ 256 ] ;
get_arg ( argbuf , sizeof ( argbuf ) , & p ) ;
if ( ! argbuf [ 0 ] )
break ;
2003-04-12 05:03:26 +02:00
feed - > child_argv [ i ] = av_malloc ( strlen ( argbuf ) + 1 ) ;
strcpy ( feed - > child_argv [ i ] , argbuf ) ;
2002-05-30 04:49:07 +02:00
}
feed - > child_argv [ i ] = av_malloc ( 30 + strlen ( feed - > filename ) ) ;
2005-12-22 02:10:11 +01:00
snprintf ( feed - > child_argv [ i ] , 30 + strlen ( feed - > filename ) ,
" http://%s:%d/%s " ,
( my_http_addr . sin_addr . s_addr = = INADDR_ANY ) ? " 127.0.0.1 " :
inet_ntoa ( my_http_addr . sin_addr ) ,
ntohs ( my_http_addr . sin_port ) , feed - > filename ) ;
if ( ffserver_debug )
{
int j ;
fprintf ( stdout , " Launch commandline: " ) ;
for ( j = 0 ; j < = i ; j + + )
fprintf ( stdout , " %s " , feed - > child_argv [ j ] ) ;
fprintf ( stdout , " \n " ) ;
}
2002-05-30 04:49:07 +02:00
}
2003-04-09 04:16:01 +02:00
} else if ( ! strcasecmp ( cmd , " ReadOnlyFile " ) ) {
if ( feed ) {
get_arg ( feed - > feed_filename , sizeof ( feed - > feed_filename ) , & p ) ;
feed - > readonly = 1 ;
} else if ( stream ) {
get_arg ( stream - > feed_filename , sizeof ( stream - > feed_filename ) , & p ) ;
}
2001-07-22 16:37:44 +02:00
} else if ( ! strcasecmp ( cmd , " File " ) ) {
if ( feed ) {
get_arg ( feed - > feed_filename , sizeof ( feed - > feed_filename ) , & p ) ;
} else if ( stream ) {
get_arg ( stream - > feed_filename , sizeof ( stream - > feed_filename ) , & p ) ;
}
} else if ( ! strcasecmp ( cmd , " FileMaxSize " ) ) {
if ( feed ) {
const char * p1 ;
double fsize ;
get_arg ( arg , sizeof ( arg ) , & p ) ;
p1 = arg ;
fsize = strtod ( p1 , ( char * * ) & p1 ) ;
switch ( toupper ( * p1 ) ) {
case ' K ' :
fsize * = 1024 ;
break ;
case ' M ' :
fsize * = 1024 * 1024 ;
break ;
case ' G ' :
fsize * = 1024 * 1024 * 1024 ;
break ;
}
2003-02-11 17:35:48 +01:00
feed - > feed_max_size = ( int64_t ) fsize ;
2001-07-22 16:37:44 +02:00
}
} else if ( ! strcasecmp ( cmd , " </Feed> " ) ) {
if ( ! feed ) {
fprintf ( stderr , " %s:%d: No corresponding <Feed> for </Feed> \n " ,
filename , line_num ) ;
errors + + ;
}
feed = NULL ;
} else if ( ! strcasecmp ( cmd , " <Stream " ) ) {
/*********************************************/
/* Stream related options */
char * q ;
if ( stream | | feed ) {
fprintf ( stderr , " %s:%d: Already in a tag \n " ,
filename , line_num ) ;
} else {
stream = av_mallocz ( sizeof ( FFStream ) ) ;
* last_stream = stream ;
last_stream = & stream - > next ;
get_arg ( stream - > filename , sizeof ( stream - > filename ) , & p ) ;
q = strrchr ( stream - > filename , ' > ' ) ;
if ( * q )
* q = ' \0 ' ;
2002-07-27 05:03:04 +02:00
stream - > fmt = guess_stream_format ( NULL , stream - > filename , NULL ) ;
2001-07-22 16:37:44 +02:00
memset ( & audio_enc , 0 , sizeof ( AVCodecContext ) ) ;
memset ( & video_enc , 0 , sizeof ( AVCodecContext ) ) ;
audio_id = CODEC_ID_NONE ;
video_id = CODEC_ID_NONE ;
if ( stream - > fmt ) {
audio_id = stream - > fmt - > audio_codec ;
video_id = stream - > fmt - > video_codec ;
}
}
} else if ( ! strcasecmp ( cmd , " Feed " ) ) {
get_arg ( arg , sizeof ( arg ) , & p ) ;
if ( stream ) {
FFStream * sfeed ;
2005-12-17 19:14:38 +01:00
2001-07-22 16:37:44 +02:00
sfeed = first_feed ;
while ( sfeed ! = NULL ) {
if ( ! strcmp ( sfeed - > filename , arg ) )
break ;
sfeed = sfeed - > next_feed ;
}
if ( ! sfeed ) {
fprintf ( stderr , " %s:%d: feed '%s' not defined \n " ,
filename , line_num , arg ) ;
} else {
stream - > feed = sfeed ;
}
}
} else if ( ! strcasecmp ( cmd , " Format " ) ) {
get_arg ( arg , sizeof ( arg ) , & p ) ;
if ( ! strcmp ( arg , " status " ) ) {
stream - > stream_type = STREAM_TYPE_STATUS ;
stream - > fmt = NULL ;
} else {
stream - > stream_type = STREAM_TYPE_LIVE ;
2001-08-15 15:03:37 +02:00
/* jpeg cannot be used here, so use single frame jpeg */
if ( ! strcmp ( arg , " jpeg " ) )
2005-07-18 11:02:58 +02:00
strcpy ( arg , " mjpeg " ) ;
2002-07-27 05:03:04 +02:00
stream - > fmt = guess_stream_format ( arg , NULL , NULL ) ;
2001-07-22 16:37:44 +02:00
if ( ! stream - > fmt ) {
2005-12-17 19:14:38 +01:00
fprintf ( stderr , " %s:%d: Unknown Format: %s \n " ,
2001-07-22 16:37:44 +02:00
filename , line_num , arg ) ;
errors + + ;
}
}
if ( stream - > fmt ) {
audio_id = stream - > fmt - > audio_codec ;
video_id = stream - > fmt - > video_codec ;
}
2003-11-10 20:02:56 +01:00
} else if ( ! strcasecmp ( cmd , " InputFormat " ) ) {
2007-04-22 19:48:23 +02:00
get_arg ( arg , sizeof ( arg ) , & p ) ;
2003-11-10 20:02:56 +01:00
stream - > ifmt = av_find_input_format ( arg ) ;
if ( ! stream - > ifmt ) {
2005-12-17 19:14:38 +01:00
fprintf ( stderr , " %s:%d: Unknown input format: %s \n " ,
2003-11-10 20:02:56 +01:00
filename , line_num , arg ) ;
}
2002-05-30 04:49:07 +02:00
} else if ( ! strcasecmp ( cmd , " FaviconURL " ) ) {
if ( stream & & stream - > stream_type = = STREAM_TYPE_STATUS ) {
get_arg ( stream - > feed_filename , sizeof ( stream - > feed_filename ) , & p ) ;
} else {
2005-12-17 19:14:38 +01:00
fprintf ( stderr , " %s:%d: FaviconURL only permitted for status streams \n " ,
2002-05-30 04:49:07 +02:00
filename , line_num ) ;
errors + + ;
}
2002-06-05 04:17:06 +02:00
} else if ( ! strcasecmp ( cmd , " Author " ) ) {
if ( stream ) {
get_arg ( stream - > author , sizeof ( stream - > author ) , & p ) ;
}
} else if ( ! strcasecmp ( cmd , " Comment " ) ) {
if ( stream ) {
get_arg ( stream - > comment , sizeof ( stream - > comment ) , & p ) ;
}
} else if ( ! strcasecmp ( cmd , " Copyright " ) ) {
if ( stream ) {
get_arg ( stream - > copyright , sizeof ( stream - > copyright ) , & p ) ;
}
} else if ( ! strcasecmp ( cmd , " Title " ) ) {
if ( stream ) {
get_arg ( stream - > title , sizeof ( stream - > title ) , & p ) ;
}
2002-05-16 04:03:07 +02:00
} else if ( ! strcasecmp ( cmd , " Preroll " ) ) {
get_arg ( arg , sizeof ( arg ) , & p ) ;
if ( stream ) {
2002-07-27 05:03:04 +02:00
stream - > prebuffer = atof ( arg ) * 1000 ;
2002-05-16 04:03:07 +02:00
}
2002-05-17 03:53:28 +02:00
} else if ( ! strcasecmp ( cmd , " StartSendOnKey " ) ) {
if ( stream ) {
stream - > send_on_key = 1 ;
}
2002-05-09 03:11:08 +02:00
} else if ( ! strcasecmp ( cmd , " AudioCodec " ) ) {
get_arg ( arg , sizeof ( arg ) , & p ) ;
audio_id = opt_audio_codec ( arg ) ;
if ( audio_id = = CODEC_ID_NONE ) {
2005-12-17 19:14:38 +01:00
fprintf ( stderr , " %s:%d: Unknown AudioCodec: %s \n " ,
2002-05-09 03:11:08 +02:00
filename , line_num , arg ) ;
errors + + ;
}
} else if ( ! strcasecmp ( cmd , " VideoCodec " ) ) {
get_arg ( arg , sizeof ( arg ) , & p ) ;
video_id = opt_video_codec ( arg ) ;
if ( video_id = = CODEC_ID_NONE ) {
2005-12-17 19:14:38 +01:00
fprintf ( stderr , " %s:%d: Unknown VideoCodec: %s \n " ,
2002-05-09 03:11:08 +02:00
filename , line_num , arg ) ;
errors + + ;
}
2002-05-24 03:18:19 +02:00
} else if ( ! strcasecmp ( cmd , " MaxTime " ) ) {
get_arg ( arg , sizeof ( arg ) , & p ) ;
if ( stream ) {
2002-07-27 05:03:04 +02:00
stream - > max_time = atof ( arg ) * 1000 ;
2002-05-24 03:18:19 +02:00
}
2001-07-22 16:37:44 +02:00
} else if ( ! strcasecmp ( cmd , " AudioBitRate " ) ) {
get_arg ( arg , sizeof ( arg ) , & p ) ;
if ( stream ) {
audio_enc . bit_rate = atoi ( arg ) * 1000 ;
}
} else if ( ! strcasecmp ( cmd , " AudioChannels " ) ) {
get_arg ( arg , sizeof ( arg ) , & p ) ;
if ( stream ) {
audio_enc . channels = atoi ( arg ) ;
}
} else if ( ! strcasecmp ( cmd , " AudioSampleRate " ) ) {
get_arg ( arg , sizeof ( arg ) , & p ) ;
if ( stream ) {
audio_enc . sample_rate = atoi ( arg ) ;
}
2005-12-22 02:10:11 +01:00
} else if ( ! strcasecmp ( cmd , " AudioQuality " ) ) {
get_arg ( arg , sizeof ( arg ) , & p ) ;
2002-09-01 20:07:56 +02:00
if ( stream ) {
2002-12-04 11:04:03 +01:00
// audio_enc.quality = atof(arg) * 1000;
2002-09-01 20:07:56 +02:00
}
2002-10-30 03:15:07 +01:00
} else if ( ! strcasecmp ( cmd , " VideoBitRateRange " ) ) {
if ( stream ) {
int minrate , maxrate ;
get_arg ( arg , sizeof ( arg ) , & p ) ;
if ( sscanf ( arg , " %d-%d " , & minrate , & maxrate ) = = 2 ) {
video_enc . rc_min_rate = minrate * 1000 ;
video_enc . rc_max_rate = maxrate * 1000 ;
} else {
2005-12-17 19:14:38 +01:00
fprintf ( stderr , " %s:%d: Incorrect format for VideoBitRateRange -- should be <min>-<max>: %s \n " ,
2002-10-30 03:15:07 +01:00
filename , line_num , arg ) ;
errors + + ;
}
}
2005-05-06 05:21:04 +02:00
} else if ( ! strcasecmp ( cmd , " Debug " ) ) {
if ( stream ) {
get_arg ( arg , sizeof ( arg ) , & p ) ;
video_enc . debug = strtol ( arg , 0 , 0 ) ;
}
} else if ( ! strcasecmp ( cmd , " Strict " ) ) {
if ( stream ) {
get_arg ( arg , sizeof ( arg ) , & p ) ;
video_enc . strict_std_compliance = atoi ( arg ) ;
}
2004-02-05 18:47:24 +01:00
} else if ( ! strcasecmp ( cmd , " VideoBufferSize " ) ) {
if ( stream ) {
get_arg ( arg , sizeof ( arg ) , & p ) ;
2005-05-06 05:21:04 +02:00
video_enc . rc_buffer_size = atoi ( arg ) * 8 * 1024 ;
2004-02-05 18:47:24 +01:00
}
2002-10-30 03:15:07 +01:00
} else if ( ! strcasecmp ( cmd , " VideoBitRateTolerance " ) ) {
if ( stream ) {
get_arg ( arg , sizeof ( arg ) , & p ) ;
video_enc . bit_rate_tolerance = atoi ( arg ) * 1000 ;
}
2001-07-22 16:37:44 +02:00
} else if ( ! strcasecmp ( cmd , " VideoBitRate " ) ) {
get_arg ( arg , sizeof ( arg ) , & p ) ;
if ( stream ) {
video_enc . bit_rate = atoi ( arg ) * 1000 ;
}
} else if ( ! strcasecmp ( cmd , " VideoSize " ) ) {
get_arg ( arg , sizeof ( arg ) , & p ) ;
if ( stream ) {
parse_image_size ( & video_enc . width , & video_enc . height , arg ) ;
if ( ( video_enc . width % 16 ) ! = 0 | |
( video_enc . height % 16 ) ! = 0 ) {
fprintf ( stderr , " %s:%d: Image size must be a multiple of 16 \n " ,
filename , line_num ) ;
errors + + ;
}
}
} else if ( ! strcasecmp ( cmd , " VideoFrameRate " ) ) {
get_arg ( arg , sizeof ( arg ) , & p ) ;
if ( stream ) {
2005-04-30 23:43:59 +02:00
video_enc . time_base . num = DEFAULT_FRAME_RATE_BASE ;
video_enc . time_base . den = ( int ) ( strtod ( arg , NULL ) * video_enc . time_base . num ) ;
2001-07-22 16:37:44 +02:00
}
} else if ( ! strcasecmp ( cmd , " VideoGopSize " ) ) {
get_arg ( arg , sizeof ( arg ) , & p ) ;
if ( stream ) {
video_enc . gop_size = atoi ( arg ) ;
}
} else if ( ! strcasecmp ( cmd , " VideoIntraOnly " ) ) {
if ( stream ) {
video_enc . gop_size = 1 ;
}
2002-05-09 09:43:07 +02:00
} else if ( ! strcasecmp ( cmd , " VideoHighQuality " ) ) {
if ( stream ) {
2003-07-29 04:09:12 +02:00
video_enc . mb_decision = FF_MB_DECISION_BITS ;
2002-05-09 09:43:07 +02:00
}
2003-04-09 04:16:01 +02:00
} else if ( ! strcasecmp ( cmd , " Video4MotionVector " ) ) {
if ( stream ) {
2003-07-29 04:09:12 +02:00
video_enc . mb_decision = FF_MB_DECISION_BITS ; //FIXME remove
2003-04-09 04:16:01 +02:00
video_enc . flags | = CODEC_FLAG_4MV ;
}
2007-02-22 14:23:38 +01:00
} else if ( ! strcasecmp ( cmd , " VideoTag " ) ) {
get_arg ( arg , sizeof ( arg ) , & p ) ;
if ( ( strlen ( arg ) = = 4 ) & & stream ) {
video_enc . codec_tag = ff_get_fourcc ( arg ) ;
}
2006-03-09 01:36:39 +01:00
} else if ( ! strcasecmp ( cmd , " BitExact " ) ) {
if ( stream ) {
video_enc . flags | = CODEC_FLAG_BITEXACT ;
}
} else if ( ! strcasecmp ( cmd , " DctFastint " ) ) {
if ( stream ) {
video_enc . dct_algo = FF_DCT_FASTINT ;
}
} else if ( ! strcasecmp ( cmd , " IdctSimple " ) ) {
if ( stream ) {
video_enc . idct_algo = FF_IDCT_SIMPLE ;
}
} else if ( ! strcasecmp ( cmd , " Qscale " ) ) {
get_arg ( arg , sizeof ( arg ) , & p ) ;
if ( stream ) {
video_enc . flags | = CODEC_FLAG_QSCALE ;
video_enc . global_quality = FF_QP2LAMBDA * atoi ( arg ) ;
}
2002-05-16 04:03:07 +02:00
} else if ( ! strcasecmp ( cmd , " VideoQDiff " ) ) {
2002-09-12 04:31:11 +02:00
get_arg ( arg , sizeof ( arg ) , & p ) ;
2002-05-16 04:03:07 +02:00
if ( stream ) {
video_enc . max_qdiff = atoi ( arg ) ;
if ( video_enc . max_qdiff < 1 | | video_enc . max_qdiff > 31 ) {
fprintf ( stderr , " %s:%d: VideoQDiff out of range \n " ,
filename , line_num ) ;
errors + + ;
}
}
} else if ( ! strcasecmp ( cmd , " VideoQMax " ) ) {
2002-09-12 04:31:11 +02:00
get_arg ( arg , sizeof ( arg ) , & p ) ;
2002-05-16 04:03:07 +02:00
if ( stream ) {
video_enc . qmax = atoi ( arg ) ;
if ( video_enc . qmax < 1 | | video_enc . qmax > 31 ) {
fprintf ( stderr , " %s:%d: VideoQMax out of range \n " ,
filename , line_num ) ;
errors + + ;
}
}
} else if ( ! strcasecmp ( cmd , " VideoQMin " ) ) {
2002-09-12 04:31:11 +02:00
get_arg ( arg , sizeof ( arg ) , & p ) ;
2002-05-16 04:03:07 +02:00
if ( stream ) {
video_enc . qmin = atoi ( arg ) ;
if ( video_enc . qmin < 1 | | video_enc . qmin > 31 ) {
fprintf ( stderr , " %s:%d: VideoQMin out of range \n " ,
filename , line_num ) ;
errors + + ;
}
}
2002-10-21 18:08:39 +02:00
} else if ( ! strcasecmp ( cmd , " LumaElim " ) ) {
get_arg ( arg , sizeof ( arg ) , & p ) ;
if ( stream ) {
video_enc . luma_elim_threshold = atoi ( arg ) ;
}
} else if ( ! strcasecmp ( cmd , " ChromaElim " ) ) {
get_arg ( arg , sizeof ( arg ) , & p ) ;
if ( stream ) {
video_enc . chroma_elim_threshold = atoi ( arg ) ;
}
} else if ( ! strcasecmp ( cmd , " LumiMask " ) ) {
get_arg ( arg , sizeof ( arg ) , & p ) ;
if ( stream ) {
video_enc . lumi_masking = atof ( arg ) ;
}
} else if ( ! strcasecmp ( cmd , " DarkMask " ) ) {
get_arg ( arg , sizeof ( arg ) , & p ) ;
if ( stream ) {
video_enc . dark_masking = atof ( arg ) ;
}
2001-07-22 16:37:44 +02:00
} else if ( ! strcasecmp ( cmd , " NoVideo " ) ) {
video_id = CODEC_ID_NONE ;
} else if ( ! strcasecmp ( cmd , " NoAudio " ) ) {
audio_id = CODEC_ID_NONE ;
2002-07-27 05:03:04 +02:00
} else if ( ! strcasecmp ( cmd , " ACL " ) ) {
IPAddressACL acl ;
struct hostent * he ;
get_arg ( arg , sizeof ( arg ) , & p ) ;
if ( strcasecmp ( arg , " allow " ) = = 0 ) {
acl . action = IP_ALLOW ;
} else if ( strcasecmp ( arg , " deny " ) = = 0 ) {
acl . action = IP_DENY ;
} else {
fprintf ( stderr , " %s:%d: ACL action '%s' is not ALLOW or DENY \n " ,
filename , line_num , arg ) ;
errors + + ;
}
get_arg ( arg , sizeof ( arg ) , & p ) ;
he = gethostbyname ( arg ) ;
if ( ! he ) {
fprintf ( stderr , " %s:%d: ACL refers to invalid host or ip address '%s' \n " ,
filename , line_num , arg ) ;
errors + + ;
} else {
/* Only take the first */
2003-02-23 21:35:47 +01:00
acl . first . s_addr = ntohl ( ( ( struct in_addr * ) he - > h_addr_list [ 0 ] ) - > s_addr ) ;
2002-07-27 05:03:04 +02:00
acl . last = acl . first ;
}
get_arg ( arg , sizeof ( arg ) , & p ) ;
if ( arg [ 0 ] ) {
he = gethostbyname ( arg ) ;
if ( ! he ) {
fprintf ( stderr , " %s:%d: ACL refers to invalid host or ip address '%s' \n " ,
filename , line_num , arg ) ;
errors + + ;
} else {
/* Only take the first */
2003-02-23 21:35:47 +01:00
acl . last . s_addr = ntohl ( ( ( struct in_addr * ) he - > h_addr_list [ 0 ] ) - > s_addr ) ;
2002-07-27 05:03:04 +02:00
}
}
if ( ! errors ) {
IPAddressACL * nacl = ( IPAddressACL * ) av_mallocz ( sizeof ( * nacl ) ) ;
IPAddressACL * * naclp = 0 ;
2007-03-31 18:36:56 +02:00
acl . next = 0 ;
2002-07-27 05:03:04 +02:00
* nacl = acl ;
if ( stream ) {
naclp = & stream - > acl ;
} else if ( feed ) {
naclp = & feed - > acl ;
} else {
fprintf ( stderr , " %s:%d: ACL found not in <stream> or <feed> \n " ,
filename , line_num ) ;
errors + + ;
}
if ( naclp ) {
while ( * naclp )
naclp = & ( * naclp ) - > next ;
* naclp = nacl ;
}
}
2002-07-25 18:48:44 +02:00
} else if ( ! strcasecmp ( cmd , " RTSPOption " ) ) {
get_arg ( arg , sizeof ( arg ) , & p ) ;
if ( stream ) {
av_freep ( & stream - > rtsp_option ) ;
2007-03-31 16:36:24 +02:00
stream - > rtsp_option = av_strdup ( arg ) ;
2002-07-25 18:48:44 +02:00
}
2002-11-20 16:00:05 +01:00
} else if ( ! strcasecmp ( cmd , " MulticastAddress " ) ) {
get_arg ( arg , sizeof ( arg ) , & p ) ;
if ( stream ) {
if ( ! inet_aton ( arg , & stream - > multicast_ip ) ) {
2005-12-17 19:14:38 +01:00
fprintf ( stderr , " %s:%d: Invalid IP address: %s \n " ,
2002-11-20 16:00:05 +01:00
filename , line_num , arg ) ;
errors + + ;
}
stream - > is_multicast = 1 ;
2002-11-20 19:05:45 +01:00
stream - > loop = 1 ; /* default is looping */
2002-11-20 16:00:05 +01:00
}
} else if ( ! strcasecmp ( cmd , " MulticastPort " ) ) {
get_arg ( arg , sizeof ( arg ) , & p ) ;
if ( stream ) {
stream - > multicast_port = atoi ( arg ) ;
}
2002-11-20 19:05:45 +01:00
} else if ( ! strcasecmp ( cmd , " MulticastTTL " ) ) {
get_arg ( arg , sizeof ( arg ) , & p ) ;
if ( stream ) {
stream - > multicast_ttl = atoi ( arg ) ;
}
} else if ( ! strcasecmp ( cmd , " NoLoop " ) ) {
if ( stream ) {
stream - > loop = 0 ;
}
2001-07-22 16:37:44 +02:00
} else if ( ! strcasecmp ( cmd , " </Stream> " ) ) {
if ( ! stream ) {
fprintf ( stderr , " %s:%d: No corresponding <Stream> for </Stream> \n " ,
filename , line_num ) ;
errors + + ;
}
if ( stream - > feed & & stream - > fmt & & strcmp ( stream - > fmt - > name , " ffm " ) ! = 0 ) {
if ( audio_id ! = CODEC_ID_NONE ) {
audio_enc . codec_type = CODEC_TYPE_AUDIO ;
audio_enc . codec_id = audio_id ;
add_codec ( stream , & audio_enc ) ;
}
if ( video_id ! = CODEC_ID_NONE ) {
video_enc . codec_type = CODEC_TYPE_VIDEO ;
video_enc . codec_id = video_id ;
add_codec ( stream , & video_enc ) ;
}
}
stream = NULL ;
2002-05-30 04:49:07 +02:00
} else if ( ! strcasecmp ( cmd , " <Redirect " ) ) {
/*********************************************/
char * q ;
if ( stream | | feed | | redirect ) {
fprintf ( stderr , " %s:%d: Already in a tag \n " ,
filename , line_num ) ;
errors + + ;
} else {
redirect = av_mallocz ( sizeof ( FFStream ) ) ;
* last_stream = redirect ;
last_stream = & redirect - > next ;
get_arg ( redirect - > filename , sizeof ( redirect - > filename ) , & p ) ;
q = strrchr ( redirect - > filename , ' > ' ) ;
if ( * q )
* q = ' \0 ' ;
redirect - > stream_type = STREAM_TYPE_REDIRECT ;
}
} else if ( ! strcasecmp ( cmd , " URL " ) ) {
if ( redirect ) {
get_arg ( redirect - > feed_filename , sizeof ( redirect - > feed_filename ) , & p ) ;
}
} else if ( ! strcasecmp ( cmd , " </Redirect> " ) ) {
if ( ! redirect ) {
fprintf ( stderr , " %s:%d: No corresponding <Redirect> for </Redirect> \n " ,
filename , line_num ) ;
errors + + ;
}
if ( ! redirect - > feed_filename [ 0 ] ) {
fprintf ( stderr , " %s:%d: No URL found for <Redirect> \n " ,
filename , line_num ) ;
errors + + ;
}
redirect = NULL ;
2002-07-25 18:48:44 +02:00
} else if ( ! strcasecmp ( cmd , " LoadModule " ) ) {
get_arg ( arg , sizeof ( arg ) , & p ) ;
2006-11-14 00:14:24 +01:00
# ifdef HAVE_DLOPEN
2002-07-25 18:48:44 +02:00
load_module ( arg ) ;
2002-11-30 18:18:59 +01:00
# else
2005-12-17 19:14:38 +01:00
fprintf ( stderr , " %s:%d: Module support not compiled into this version: '%s' \n " ,
2002-11-30 18:18:59 +01:00
filename , line_num , arg ) ;
errors + + ;
# endif
2001-07-22 16:37:44 +02:00
} else {
2005-12-17 19:14:38 +01:00
fprintf ( stderr , " %s:%d: Incorrect keyword: '%s' \n " ,
2001-07-22 16:37:44 +02:00
filename , line_num , cmd ) ;
errors + + ;
}
}
fclose ( f ) ;
if ( errors )
return - 1 ;
else
return 0 ;
}
2003-08-24 17:29:48 +02:00
static void show_banner ( void )
2001-07-22 16:37:44 +02:00
{
2006-10-01 19:26:15 +02:00
printf ( " ffserver version " FFMPEG_VERSION " , Copyright (c) 2000-2006 Fabrice Bellard, et al. \n " ) ;
2003-08-24 17:29:48 +02:00
}
static void show_help ( void )
{
show_banner ( ) ;
printf ( " usage: ffserver [-L] [-h] [-f configfile] \n "
2001-07-22 16:37:44 +02:00
" Hyper fast multi format Audio/Video streaming server \n "
" \n "
2003-08-24 17:29:48 +02:00
" -L : print the LICENSE \n "
2001-07-22 16:37:44 +02:00
" -h : this help \n "
" -f configfile : use configfile instead of /etc/ffserver.conf \n "
) ;
}
2003-08-24 17:29:48 +02:00
static void show_license ( void )
2001-07-22 16:37:44 +02:00
{
2003-08-24 17:29:48 +02:00
show_banner ( ) ;
2001-07-22 16:37:44 +02:00
printf (
2006-10-07 17:30:46 +02:00
" FFmpeg is free software; you can redistribute it and/or \n "
2002-05-26 00:26:19 +02:00
" modify it under the terms of the GNU Lesser General Public \n "
" License as published by the Free Software Foundation; either \n "
2006-10-07 17:30:46 +02:00
" version 2.1 of the License, or (at your option) any later version. \n "
2001-07-22 16:37:44 +02:00
" \n "
2006-10-07 17:30:46 +02:00
" FFmpeg is distributed in the hope that it will be useful, \n "
2001-07-22 16:37:44 +02:00
" but WITHOUT ANY WARRANTY; without even the implied warranty of \n "
2002-05-26 00:26:19 +02:00
" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU \n "
" Lesser General Public License for more details. \n "
2001-07-22 16:37:44 +02:00
" \n "
2002-05-26 00:26:19 +02:00
" You should have received a copy of the GNU Lesser General Public \n "
2006-10-07 17:30:46 +02:00
" License along with FFmpeg; if not, write to the Free Software \n "
2006-01-12 23:43:26 +01:00
" Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA \n "
2001-07-22 16:37:44 +02:00
) ;
}
2002-06-10 04:44:36 +02:00
static void handle_child_exit ( int sig )
{
pid_t pid ;
int status ;
while ( ( pid = waitpid ( - 1 , & status , WNOHANG ) ) > 0 ) {
FFStream * feed ;
for ( feed = first_feed ; feed ; feed = feed - > next ) {
if ( feed - > pid = = pid ) {
int uptime = time ( 0 ) - feed - > pid_start ;
feed - > pid = 0 ;
fprintf ( stderr , " %s: Pid %d exited with status %d after %d seconds \n " , feed - > filename , pid , status , uptime ) ;
if ( uptime < 30 ) {
/* Turn off any more restarts */
feed - > child_argv = 0 ;
2005-12-17 19:14:38 +01:00
}
2002-06-10 04:44:36 +02:00
}
}
}
need_to_start_children = 1 ;
}
2001-07-22 16:37:44 +02:00
int main ( int argc , char * * argv )
{
const char * config_filename ;
int c ;
2002-06-10 04:44:36 +02:00
struct sigaction sigact ;
2001-07-22 16:37:44 +02:00
2002-07-25 18:07:39 +02:00
av_register_all ( ) ;
2001-07-22 16:37:44 +02:00
config_filename = " /etc/ffserver.conf " ;
2002-05-30 04:49:07 +02:00
my_program_name = argv [ 0 ] ;
2002-10-30 03:15:07 +01:00
my_program_dir = getcwd ( 0 , 0 ) ;
2002-07-25 18:48:44 +02:00
ffserver_daemon = 1 ;
2005-12-17 19:14:38 +01:00
2001-07-22 16:37:44 +02:00
for ( ; ; ) {
2002-07-25 18:48:44 +02:00
c = getopt ( argc , argv , " ndLh?f: " ) ;
2001-07-22 16:37:44 +02:00
if ( c = = - 1 )
break ;
switch ( c ) {
case ' L ' :
2003-08-24 17:29:48 +02:00
show_license ( ) ;
2001-07-22 16:37:44 +02:00
exit ( 1 ) ;
case ' ? ' :
case ' h ' :
2003-08-24 17:29:48 +02:00
show_help ( ) ;
2001-07-22 16:37:44 +02:00
exit ( 1 ) ;
2002-06-05 04:17:06 +02:00
case ' n ' :
no_launch = 1 ;
break ;
case ' d ' :
ffserver_debug = 1 ;
2002-07-25 18:48:44 +02:00
ffserver_daemon = 0 ;
2002-06-05 04:17:06 +02:00
break ;
2001-07-22 16:37:44 +02:00
case ' f ' :
config_filename = optarg ;
break ;
default :
exit ( 2 ) ;
}
}
2002-05-30 04:49:07 +02:00
putenv ( " http_proxy " ) ; /* Kill the http_proxy */
2007-02-21 15:06:03 +01:00
av_init_random ( av_gettime ( ) + ( getpid ( ) < < 16 ) , & random_state ) ;
2002-07-27 05:03:04 +02:00
2002-07-25 18:48:44 +02:00
/* address on which the server will handle HTTP connections */
my_http_addr . sin_family = AF_INET ;
my_http_addr . sin_port = htons ( 8080 ) ;
my_http_addr . sin_addr . s_addr = htonl ( INADDR_ANY ) ;
/* address on which the server will handle RTSP connections */
my_rtsp_addr . sin_family = AF_INET ;
my_rtsp_addr . sin_port = htons ( 5454 ) ;
my_rtsp_addr . sin_addr . s_addr = htonl ( INADDR_ANY ) ;
2005-12-17 19:14:38 +01:00
2001-07-22 16:37:44 +02:00
nb_max_connections = 5 ;
2002-11-20 19:05:45 +01:00
max_bandwidth = 1000 ;
2001-07-22 16:37:44 +02:00
first_stream = NULL ;
logfilename [ 0 ] = ' \0 ' ;
2002-06-10 04:44:36 +02:00
memset ( & sigact , 0 , sizeof ( sigact ) ) ;
sigact . sa_handler = handle_child_exit ;
sigact . sa_flags = SA_NOCLDSTOP | SA_RESTART ;
sigaction ( SIGCHLD , & sigact , 0 ) ;
2001-07-22 16:37:44 +02:00
if ( parse_ffconfig ( config_filename ) < 0 ) {
fprintf ( stderr , " Incorrect config file - exiting. \n " ) ;
exit ( 1 ) ;
}
2002-07-25 18:48:44 +02:00
build_file_streams ( ) ;
2001-07-22 16:37:44 +02:00
build_feed_streams ( ) ;
2002-11-20 19:05:45 +01:00
compute_bandwidth ( ) ;
2002-07-25 18:48:44 +02:00
/* put the process in background and detach it from its TTY */
if ( ffserver_daemon ) {
int pid ;
pid = fork ( ) ;
if ( pid < 0 ) {
perror ( " fork " ) ;
exit ( 1 ) ;
} else if ( pid > 0 ) {
/* parent : exit */
exit ( 0 ) ;
} else {
/* child */
setsid ( ) ;
chdir ( " / " ) ;
close ( 0 ) ;
open ( " /dev/null " , O_RDWR ) ;
2002-07-27 17:22:17 +02:00
if ( strcmp ( logfilename , " - " ) ! = 0 ) {
2002-07-27 05:03:04 +02:00
close ( 1 ) ;
dup ( 0 ) ;
}
close ( 2 ) ;
2002-07-25 18:48:44 +02:00
dup ( 0 ) ;
}
}
2001-07-22 16:37:44 +02:00
/* signal init */
signal ( SIGPIPE , SIG_IGN ) ;
/* open log file if needed */
if ( logfilename [ 0 ] ! = ' \0 ' ) {
if ( ! strcmp ( logfilename , " - " ) )
logfile = stdout ;
else
logfile = fopen ( logfilename , " w " ) ;
}
2002-07-25 18:48:44 +02:00
if ( http_server ( ) < 0 ) {
fprintf ( stderr , " Could not start server \n " ) ;
2001-07-22 16:37:44 +02:00
exit ( 1 ) ;
}
return 0 ;
}