2002-07-04 12:41:34 +02:00
/*
2002-11-18 18:24:39 +01:00
* RTSP / SDP client
2009-01-19 16:46:40 +01:00
* Copyright ( c ) 2002 Fabrice Bellard
2002-07-04 12:41:34 +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-07-04 12:41:34 +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 .
2002-07-04 12:41:34 +02:00
*
2006-10-07 17:30:46 +02:00
* FFmpeg is distributed in the hope that it will be useful ,
2002-07-04 12:41:34 +02:00
* but WITHOUT ANY WARRANTY ; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE . See the GNU
* Lesser General Public License for more details .
*
* 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
2002-07-04 12:41:34 +02:00
*/
2008-05-09 13:56:36 +02:00
2012-09-22 04:47:45 +02:00
# include "libavutil/avassert.h"
2009-09-17 23:47:11 +02:00
# include "libavutil/base64.h"
2020-04-08 00:38:29 +02:00
# include "libavutil/bprint.h"
2008-05-09 13:56:36 +02:00
# include "libavutil/avstring.h"
2009-01-11 23:19:48 +01:00
# include "libavutil/intreadwrite.h"
2011-06-04 13:58:23 +02:00
# include "libavutil/mathematics.h"
2011-02-16 09:52:37 +01:00
# include "libavutil/parseutils.h"
2010-06-08 14:40:34 +02:00
# include "libavutil/random_seed.h"
2011-05-22 12:46:29 +02:00
# include "libavutil/dict.h"
2010-06-20 22:58:22 +02:00
# include "libavutil/opt.h"
2012-07-27 16:28:36 +02:00
# include "libavutil/time.h"
2002-07-04 12:41:34 +02:00
# include "avformat.h"
2011-02-20 11:04:13 +01:00
# include "avio_internal.h"
2002-07-04 12:41:34 +02:00
2011-01-28 03:12:21 +01:00
# if HAVE_POLL_H
# include <poll.h>
2008-09-26 04:12:37 +02:00
# endif
2010-03-15 00:59:48 +01:00
# include "internal.h"
2007-02-04 18:05:44 +01:00
# include "network.h"
2010-03-10 08:44:51 +01:00
# include "os_support.h"
2010-06-08 14:40:34 +02:00
# include "http.h"
2007-10-29 10:15:35 +01:00
# include "rtsp.h"
2002-07-04 12:41:34 +02:00
2009-02-06 11:35:52 +01:00
# include "rtpdec.h"
2013-07-31 11:29:32 +02:00
# include "rtpproto.h"
2008-09-03 06:44:58 +02:00
# include "rdt.h"
2010-07-30 14:04:27 +02:00
# include "rtpdec_formats.h"
2010-10-08 10:54:53 +02:00
# include "rtpenc_chain.h"
2011-03-31 16:04:59 +02:00
# include "url.h"
2011-06-24 01:04:54 +02:00
# include "rtpenc.h"
2012-08-08 22:05:52 +02:00
# include "mpegts.h"
2006-10-26 20:36:03 +02:00
2020-10-10 15:50:08 +02:00
/* Default timeout values for read packet in seconds */
2010-03-29 19:36:08 +02:00
# define READ_PACKET_TIMEOUT_S 10
2010-10-01 19:41:31 +02:00
# define RECVBUF_SIZE 10 * RTP_MAX_PACKET_LENGTH
2012-03-19 19:40:23 +01:00
# define DEFAULT_REORDERING_DELAY 100000
2010-03-29 19:36:08 +02:00
2011-10-13 13:00:06 +02:00
# define OFFSET(x) offsetof(RTSPState, x)
# define DEC AV_OPT_FLAG_DECODING_PARAM
2011-06-24 00:49:09 +02:00
# define ENC AV_OPT_FLAG_ENCODING_PARAM
2011-10-17 19:04:41 +02:00
# define RTSP_FLAG_OPTS(name, longname) \
2012-08-31 11:52:18 +02:00
{ name , longname , OFFSET ( rtsp_flags ) , AV_OPT_TYPE_FLAGS , { . i64 = 0 } , INT_MIN , INT_MAX , DEC , " rtsp_flags " } , \
2013-12-29 16:43:48 +01:00
{ " filter_src " , " only receive packets from the negotiated peer IP " , 0 , AV_OPT_TYPE_CONST , { . i64 = RTSP_FLAG_FILTER_SRC } , 0 , 0 , DEC , " rtsp_flags " }
2011-10-17 19:04:41 +02:00
2011-10-29 23:41:24 +02:00
# define RTSP_MEDIATYPE_OPTS(name, longname) \
2015-02-08 22:22:40 +01:00
{ name , longname , OFFSET ( media_type_mask ) , AV_OPT_TYPE_FLAGS , { . i64 = ( 1 < < ( AVMEDIA_TYPE_SUBTITLE + 1 ) ) - 1 } , INT_MIN , INT_MAX , DEC , " allowed_media_types " } , \
2012-08-31 11:45:52 +02:00
{ " video " , " Video " , 0 , AV_OPT_TYPE_CONST , { . i64 = 1 < < AVMEDIA_TYPE_VIDEO } , 0 , 0 , DEC , " allowed_media_types " } , \
{ " audio " , " Audio " , 0 , AV_OPT_TYPE_CONST , { . i64 = 1 < < AVMEDIA_TYPE_AUDIO } , 0 , 0 , DEC , " allowed_media_types " } , \
2015-02-08 22:22:40 +01:00
{ " data " , " Data " , 0 , AV_OPT_TYPE_CONST , { . i64 = 1 < < AVMEDIA_TYPE_DATA } , 0 , 0 , DEC , " allowed_media_types " } , \
{ " subtitle " , " Subtitle " , 0 , AV_OPT_TYPE_CONST , { . i64 = 1 < < AVMEDIA_TYPE_SUBTITLE } , 0 , 0 , DEC , " allowed_media_types " }
2011-10-29 23:41:24 +02:00
2015-03-22 21:16:55 +01:00
# define COMMON_OPTS() \
2015-04-01 21:27:45 +02:00
{ " reorder_queue_size " , " set number of packets to buffer for handling of reordered packets " , OFFSET ( reordering_queue_size ) , AV_OPT_TYPE_INT , { . i64 = - 1 } , - 1 , INT_MAX , DEC } , \
2019-04-11 06:07:15 +02:00
{ " buffer_size " , " Underlying protocol send/receive buffer size " , OFFSET ( buffer_size ) , AV_OPT_TYPE_INT , { . i64 = - 1 } , - 1 , INT_MAX , DEC | ENC } , \
{ " pkt_size " , " Underlying protocol send packet size " , OFFSET ( pkt_size ) , AV_OPT_TYPE_INT , { . i64 = - 1 } , - 1 , INT_MAX , ENC } \
2015-03-22 21:16:55 +01:00
2012-10-17 14:46:30 +02:00
2011-06-24 01:04:54 +02:00
const AVOption ff_rtsp_options [ ] = {
2015-11-21 22:05:07 +01:00
{ " initial_pause " , " do not start playing the stream immediately " , OFFSET ( initial_pause ) , AV_OPT_TYPE_BOOL , { . i64 = 0 } , 0 , 1 , DEC } ,
2012-07-21 16:13:48 +02:00
FF_RTP_FLAG_OPTS ( RTSPState , rtp_muxer_flags ) ,
2013-12-29 16:43:48 +01:00
{ " rtsp_transport " , " set RTSP transport protocols " , OFFSET ( lower_transport_mask ) , AV_OPT_TYPE_FLAGS , { . i64 = 0 } , INT_MIN , INT_MAX , DEC | ENC , " rtsp_transport " } , \
2012-08-31 11:45:52 +02:00
{ " udp " , " UDP " , 0 , AV_OPT_TYPE_CONST , { . i64 = 1 < < RTSP_LOWER_TRANSPORT_UDP } , 0 , 0 , DEC | ENC , " rtsp_transport " } , \
{ " tcp " , " TCP " , 0 , AV_OPT_TYPE_CONST , { . i64 = 1 < < RTSP_LOWER_TRANSPORT_TCP } , 0 , 0 , DEC | ENC , " rtsp_transport " } , \
{ " udp_multicast " , " UDP multicast " , 0 , AV_OPT_TYPE_CONST , { . i64 = 1 < < RTSP_LOWER_TRANSPORT_UDP_MULTICAST } , 0 , 0 , DEC , " rtsp_transport " } ,
{ " http " , " HTTP tunneling " , 0 , AV_OPT_TYPE_CONST , { . i64 = ( 1 < < RTSP_LOWER_TRANSPORT_HTTP ) } , 0 , 0 , DEC , " rtsp_transport " } ,
2019-03-22 00:58:41 +01:00
{ " https " , " HTTPS tunneling " , 0 , AV_OPT_TYPE_CONST , { . i64 = ( 1 < < RTSP_LOWER_TRANSPORT_HTTPS ) } , 0 , 0 , DEC , " rtsp_transport " } ,
2013-12-29 16:43:48 +01:00
RTSP_FLAG_OPTS ( " rtsp_flags " , " set RTSP flags " ) ,
{ " listen " , " wait for incoming connections " , 0 , AV_OPT_TYPE_CONST , { . i64 = RTSP_FLAG_LISTEN } , 0 , 0 , DEC , " rtsp_flags " } ,
2014-03-04 14:43:59 +01:00
{ " prefer_tcp " , " try RTP via TCP first, if available " , 0 , AV_OPT_TYPE_CONST , { . i64 = RTSP_FLAG_PREFER_TCP } , 0 , 0 , DEC | ENC , " rtsp_flags " } ,
avformat/rtsp: add satip_raw flag to receive raw mpegts stream
This can be used to receive the raw mpegts stream from a SAT>IP
server, by letting avformat handle the RTSP/RTP/UDP negotiation
and setup, but then simply passing the MP2T stream through
instead of demuxing it further.
For example, this command would demux/remux the mpegts stream:
SATIP_URL='satip://192.168.1.99:554/?src=1&freq=12188&pol=h&ro=0.35&msys=dvbs&mtype=qpsk&plts=off&sr=27500&fec=34&pids=0,17,18,167,136,47,71'
ffmpeg -i $SATIP_URL -map 0 -c copy -f mpegts -y remux.ts
Whereas this command will simply write out the raw stream, with
the original PAT/PMT/PIDs intact:
ffmpeg -rtsp_flags satip_raw -i $SATIP_URL -map 0 -c copy -f data -y raw.ts
Signed-off-by: Aman Karmani <aman@tmm1.net>
2020-12-22 00:53:55 +01:00
{ " satip_raw " , " export raw MPEG-TS stream instead of demuxing " , 0 , AV_OPT_TYPE_CONST , { . i64 = RTSP_FLAG_SATIP_RAW } , 0 , 0 , DEC , " rtsp_flags " } ,
2013-12-29 16:43:48 +01:00
RTSP_MEDIATYPE_OPTS ( " allowed_media_types " , " set media types to accept from the server " ) ,
{ " min_port " , " set minimum local UDP port " , OFFSET ( rtp_port_min ) , AV_OPT_TYPE_INT , { . i64 = RTSP_RTP_PORT_MIN } , 0 , 65535 , DEC | ENC } ,
{ " max_port " , " set maximum local UDP port " , OFFSET ( rtp_port_max ) , AV_OPT_TYPE_INT , { . i64 = RTSP_RTP_PORT_MAX } , 0 , 65535 , DEC | ENC } ,
2018-01-25 18:57:26 +01:00
{ " listen_timeout " , " set maximum timeout (in seconds) to wait for incoming connections (-1 is infinite, imply flag listen) " , OFFSET ( initial_timeout ) , AV_OPT_TYPE_INT , { . i64 = - 1 } , INT_MIN , INT_MAX , DEC } ,
2021-05-30 22:24:10 +02:00
{ " timeout " , " set timeout (in microseconds) of socket I/O operations " , OFFSET ( stimeout ) , AV_OPT_TYPE_INT64 , { . i64 = 0 } , INT_MIN , INT64_MAX , DEC } ,
2015-03-22 21:16:55 +01:00
COMMON_OPTS ( ) ,
2018-01-25 18:57:26 +01:00
{ " user_agent " , " override User-Agent header " , OFFSET ( user_agent ) , AV_OPT_TYPE_STRING , { . str = LIBAVFORMAT_IDENT } , 0 , 0 , DEC } ,
2011-06-24 01:04:54 +02:00
{ NULL } ,
} ;
2011-10-17 19:07:56 +02:00
static const AVOption sdp_options [ ] = {
RTSP_FLAG_OPTS ( " sdp_flags " , " SDP flags " ) ,
2013-12-29 16:43:48 +01:00
{ " custom_io " , " use custom I/O " , 0 , AV_OPT_TYPE_CONST , { . i64 = RTSP_FLAG_CUSTOM_IO } , 0 , 0 , DEC , " rtsp_flags " } ,
{ " rtcp_to_source " , " send RTCP packets to the source address of received packets " , 0 , AV_OPT_TYPE_CONST , { . i64 = RTSP_FLAG_RTCP_TO_SOURCE } , 0 , 0 , DEC , " rtsp_flags " } ,
2021-05-30 22:24:10 +02:00
{ " listen_timeout " , " set maximum timeout (in seconds) to wait for incoming connections " , OFFSET ( stimeout ) , AV_OPT_TYPE_DURATION , { . i64 = READ_PACKET_TIMEOUT_S * 1000000 } , INT_MIN , INT64_MAX , DEC } ,
2013-12-29 16:43:48 +01:00
RTSP_MEDIATYPE_OPTS ( " allowed_media_types " , " set media types to accept from the server " ) ,
2015-03-22 21:16:55 +01:00
COMMON_OPTS ( ) ,
2011-10-17 19:07:56 +02:00
{ NULL } ,
} ;
static const AVOption rtp_options [ ] = {
2013-12-29 16:43:48 +01:00
RTSP_FLAG_OPTS ( " rtp_flags " , " set RTP flags " ) ,
2021-05-30 22:24:10 +02:00
{ " listen_timeout " , " set maximum timeout (in seconds) to wait for incoming connections " , OFFSET ( stimeout ) , AV_OPT_TYPE_DURATION , { . i64 = READ_PACKET_TIMEOUT_S * 1000000 } , INT_MIN , INT64_MAX , DEC } ,
2020-10-10 15:30:21 +02:00
RTSP_MEDIATYPE_OPTS ( " allowed_media_types " , " set media types to accept from the server " ) ,
2015-03-22 21:16:55 +01:00
COMMON_OPTS ( ) ,
2011-10-17 19:07:56 +02:00
{ NULL } ,
} ;
2015-03-22 21:16:55 +01:00
static AVDictionary * map_to_opts ( RTSPState * rt )
{
AVDictionary * opts = NULL ;
2021-09-13 20:38:03 +02:00
av_dict_set_int ( & opts , " buffer_size " , rt - > buffer_size , 0 ) ;
av_dict_set_int ( & opts , " pkt_size " , rt - > pkt_size , 0 ) ;
2015-03-22 21:16:55 +01:00
return opts ;
}
2009-03-21 21:54:47 +01:00
static void get_word_until_chars ( char * buf , int buf_size ,
const char * sep , const char * * pp )
2002-07-04 12:41:34 +02:00
{
const char * p ;
char * q ;
p = * pp ;
2010-06-25 09:56:45 +02:00
p + = strspn ( p , SPACE_CHARS ) ;
2002-07-04 12:41:34 +02:00
q = buf ;
while ( ! strchr ( sep , * p ) & & * p ! = ' \0 ' ) {
if ( ( q - buf ) < buf_size - 1 )
* q + + = * p ;
p + + ;
}
if ( buf_size > 0 )
* q = ' \0 ' ;
* pp = p ;
}
2009-03-21 21:54:47 +01:00
static void get_word_sep ( char * buf , int buf_size , const char * sep ,
const char * * pp )
2002-07-04 12:41:34 +02:00
{
2009-03-21 21:54:47 +01:00
if ( * * pp = = ' / ' ) ( * pp ) + + ;
get_word_until_chars ( buf , buf_size , sep , pp ) ;
}
2002-07-04 12:41:34 +02:00
2009-03-21 21:54:47 +01:00
static void get_word ( char * buf , int buf_size , const char * * pp )
{
get_word_until_chars ( buf , buf_size , SPACE_CHARS , pp ) ;
2002-07-04 12:41:34 +02:00
}
2010-10-21 14:13:02 +02:00
/** Parse a string p in the form of Range:npt=xx-xx, and determine the start
* and end time .
* Used for seeking in the rtp stream .
*/
static void rtsp_parse_range_npt ( const char * p , int64_t * start , int64_t * end )
{
char buf [ 256 ] ;
p + = strspn ( p , SPACE_CHARS ) ;
if ( ! av_stristart ( p , " npt= " , & p ) )
return ;
* start = AV_NOPTS_VALUE ;
* end = AV_NOPTS_VALUE ;
get_word_sep ( buf , sizeof ( buf ) , " - " , & p ) ;
2015-04-22 22:15:58 +02:00
if ( av_parse_time ( start , buf , 1 ) < 0 )
2015-04-09 20:34:01 +02:00
return ;
2010-10-21 14:13:02 +02:00
if ( * p = = ' - ' ) {
p + + ;
get_word_sep ( buf , sizeof ( buf ) , " - " , & p ) ;
2015-05-15 20:19:21 +02:00
if ( av_parse_time ( end , buf , 1 ) < 0 )
av_log ( NULL , AV_LOG_DEBUG , " Failed to parse interval end specification '%s' \n " , buf ) ;
2010-10-21 14:13:02 +02:00
}
}
2015-11-24 01:13:00 +01:00
static int get_sockaddr ( AVFormatContext * s ,
const char * buf , struct sockaddr_storage * sock )
2010-10-21 14:13:02 +02:00
{
2011-06-06 14:13:02 +02:00
struct addrinfo hints = { 0 } , * ai = NULL ;
2015-11-24 01:13:00 +01:00
int ret ;
2010-10-21 14:13:02 +02:00
hints . ai_flags = AI_NUMERICHOST ;
2015-11-24 01:13:00 +01:00
if ( ( ret = getaddrinfo ( buf , NULL , & hints , & ai ) ) ) {
av_log ( s , AV_LOG_ERROR , " getaddrinfo(%s): %s \n " ,
buf ,
gai_strerror ( ret ) ) ;
2010-10-21 14:13:02 +02:00
return - 1 ;
2015-11-24 01:13:00 +01:00
}
2010-10-21 14:13:02 +02:00
memcpy ( sock , ai - > ai_addr , FFMIN ( sizeof ( * sock ) , ai - > ai_addrlen ) ) ;
freeaddrinfo ( ai ) ;
return 0 ;
}
2010-10-21 14:18:48 +02:00
# if CONFIG_RTPDEC
2018-02-10 02:54:42 +01:00
static void init_rtp_handler ( const RTPDynamicProtocolHandler * handler ,
2015-02-23 20:35:48 +01:00
RTSPStream * rtsp_st , AVStream * st )
2010-12-05 20:41:09 +01:00
{
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 20:42:52 +02:00
AVCodecParameters * par = st ? st - > codecpar : NULL ;
2010-12-05 20:41:09 +01:00
if ( ! handler )
return ;
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 20:42:52 +02:00
if ( par )
par - > codec_id = handler - > codec_id ;
2010-12-05 20:41:09 +01:00
rtsp_st - > dynamic_handler = handler ;
2015-02-23 20:35:48 +01:00
if ( st )
2021-08-24 19:41:16 +02:00
ffstream ( st ) - > need_parsing = handler - > need_parsing ;
2015-02-24 11:45:15 +01:00
if ( handler - > priv_data_size ) {
2015-02-23 20:57:33 +01:00
rtsp_st - > dynamic_protocol_context = av_mallocz ( handler - > priv_data_size ) ;
if ( ! rtsp_st - > dynamic_protocol_context )
rtsp_st - > dynamic_handler = NULL ;
2011-11-06 22:50:39 +01:00
}
2010-12-05 20:41:09 +01:00
}
2015-02-24 12:18:10 +01:00
static void finalize_rtp_handler_init ( AVFormatContext * s , RTSPStream * rtsp_st ,
AVStream * st )
{
if ( rtsp_st - > dynamic_handler & & rtsp_st - > dynamic_handler - > init ) {
int ret = rtsp_st - > dynamic_handler - > init ( s , st ? st - > index : - 1 ,
rtsp_st - > dynamic_protocol_context ) ;
if ( ret < 0 ) {
if ( rtsp_st - > dynamic_protocol_context ) {
2015-02-24 16:01:48 +01:00
if ( rtsp_st - > dynamic_handler - > close )
rtsp_st - > dynamic_handler - > close (
2015-02-24 12:18:10 +01:00
rtsp_st - > dynamic_protocol_context ) ;
av_free ( rtsp_st - > dynamic_protocol_context ) ;
}
rtsp_st - > dynamic_protocol_context = NULL ;
rtsp_st - > dynamic_handler = NULL ;
}
}
}
2020-12-16 21:40:16 +01:00
static int init_satip_stream ( AVFormatContext * s )
{
RTSPState * rt = s - > priv_data ;
RTSPStream * rtsp_st = av_mallocz ( sizeof ( RTSPStream ) ) ;
if ( ! rtsp_st )
return AVERROR ( ENOMEM ) ;
dynarray_add ( & rt - > rtsp_streams ,
& rt - > nb_rtsp_streams , rtsp_st ) ;
rtsp_st - > sdp_payload_type = 33 ; // MP2T
av_strlcpy ( rtsp_st - > control_url ,
rt - > control_uri , sizeof ( rtsp_st - > control_url ) ) ;
avformat/rtsp: add satip_raw flag to receive raw mpegts stream
This can be used to receive the raw mpegts stream from a SAT>IP
server, by letting avformat handle the RTSP/RTP/UDP negotiation
and setup, but then simply passing the MP2T stream through
instead of demuxing it further.
For example, this command would demux/remux the mpegts stream:
SATIP_URL='satip://192.168.1.99:554/?src=1&freq=12188&pol=h&ro=0.35&msys=dvbs&mtype=qpsk&plts=off&sr=27500&fec=34&pids=0,17,18,167,136,47,71'
ffmpeg -i $SATIP_URL -map 0 -c copy -f mpegts -y remux.ts
Whereas this command will simply write out the raw stream, with
the original PAT/PMT/PIDs intact:
ffmpeg -rtsp_flags satip_raw -i $SATIP_URL -map 0 -c copy -f data -y raw.ts
Signed-off-by: Aman Karmani <aman@tmm1.net>
2020-12-22 00:53:55 +01:00
if ( rt - > rtsp_flags & RTSP_FLAG_SATIP_RAW ) {
AVStream * st = avformat_new_stream ( s , NULL ) ;
if ( ! st )
return AVERROR ( ENOMEM ) ;
st - > id = rt - > nb_rtsp_streams - 1 ;
rtsp_st - > stream_index = st - > index ;
st - > codecpar - > codec_type = AVMEDIA_TYPE_DATA ;
st - > codecpar - > codec_id = AV_CODEC_ID_MPEG2TS ;
} else {
rtsp_st - > stream_index = - 1 ;
init_rtp_handler ( & ff_mpegts_dynamic_handler , rtsp_st , NULL ) ;
finalize_rtp_handler_init ( s , rtsp_st , NULL ) ;
}
2020-12-16 21:40:16 +01:00
return 0 ;
}
2010-01-07 23:41:14 +01:00
/* parse the rtpmap description: <codec_name>/<clock_rate>[/<other params>] */
2010-01-07 23:44:03 +01:00
static int sdp_parse_rtpmap ( AVFormatContext * s ,
2010-12-07 14:29:44 +01:00
AVStream * st , RTSPStream * rtsp_st ,
2010-01-07 23:41:14 +01:00
int payload_type , const char * p )
2002-11-18 18:24:39 +01:00
{
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 20:42:52 +02:00
AVCodecParameters * par = st - > codecpar ;
2002-11-18 18:24:39 +01:00
char buf [ 256 ] ;
2005-05-26 09:47:51 +02:00
int i ;
2016-05-24 10:20:28 +02:00
const AVCodecDescriptor * desc ;
2006-06-18 13:33:14 +02:00
const char * c_name ;
2002-11-18 18:24:39 +01:00
2013-01-11 13:47:10 +01:00
/* See if we can handle this kind of payload.
2010-01-13 16:55:42 +01:00
* The space should normally not be there but some Real streams or
* particular servers ( " RealServer Version 6.1.3.970 " , see issue 1658 )
* have a trailing space . */
get_word_sep ( buf , sizeof ( buf ) , " / " , & p ) ;
2011-12-08 14:19:58 +01:00
if ( payload_type < RTP_PT_PRIVATE ) {
/* We are in a standard case
* ( from http : //www.iana.org/assignments/rtp-parameters). */
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 20:42:52 +02:00
par - > codec_id = ff_rtp_codec_id ( buf , par - > codec_type ) ;
2011-12-08 14:19:58 +01:00
}
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 20:42:52 +02:00
if ( par - > codec_id = = AV_CODEC_ID_NONE ) {
2018-02-10 02:54:42 +01:00
const RTPDynamicProtocolHandler * handler =
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 20:42:52 +02:00
ff_rtp_handler_find_by_name ( buf , par - > codec_type ) ;
2015-02-23 20:35:48 +01:00
init_rtp_handler ( handler , rtsp_st , st ) ;
2010-09-15 19:39:25 +02:00
/* If no dynamic handler was found, check with the list of standard
* allocated types , if such a stream for some reason happens to
* use a private payload type . This isn ' t handled in rtpdec . c , since
* the format name from the rtpmap line never is passed into rtpdec . */
if ( ! rtsp_st - > dynamic_handler )
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 20:42:52 +02:00
par - > codec_id = ff_rtp_codec_id ( buf , par - > codec_type ) ;
2005-05-26 09:47:51 +02:00
}
2016-05-24 10:20:28 +02:00
desc = avcodec_descriptor_get ( par - > codec_id ) ;
if ( desc & & desc - > name )
c_name = desc - > name ;
2005-05-26 09:47:51 +02:00
else
2010-02-10 19:30:55 +01:00
c_name = " (null) " ;
2005-05-26 09:47:51 +02:00
2010-02-10 19:31:47 +01:00
get_word_sep ( buf , sizeof ( buf ) , " / " , & p ) ;
i = atoi ( buf ) ;
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 20:42:52 +02:00
switch ( par - > codec_type ) {
2010-03-31 01:30:55 +02:00
case AVMEDIA_TYPE_AUDIO :
2010-02-10 19:31:47 +01:00
av_log ( s , AV_LOG_DEBUG , " audio codec set to: %s \n " , c_name ) ;
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 20:42:52 +02:00
par - > sample_rate = RTSP_DEFAULT_AUDIO_SAMPLERATE ;
par - > channels = RTSP_DEFAULT_NB_AUDIO_CHANNELS ;
2010-02-10 19:31:47 +01:00
if ( i > 0 ) {
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 20:42:52 +02:00
par - > sample_rate = i ;
avpriv_set_pts_info ( st , 32 , 1 , par - > sample_rate ) ;
2010-02-10 19:31:47 +01:00
get_word_sep ( buf , sizeof ( buf ) , " / " , & p ) ;
i = atoi ( buf ) ;
if ( i > 0 )
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 20:42:52 +02:00
par - > channels = i ;
2005-05-26 09:47:51 +02:00
}
2010-02-10 19:31:47 +01:00
av_log ( s , AV_LOG_DEBUG , " audio samplerate set to: %i \n " ,
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 20:42:52 +02:00
par - > sample_rate ) ;
2010-02-10 19:31:47 +01:00
av_log ( s , AV_LOG_DEBUG , " audio channels set to: %i \n " ,
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 20:42:52 +02:00
par - > channels ) ;
2010-02-10 19:31:47 +01:00
break ;
2010-03-31 01:30:55 +02:00
case AVMEDIA_TYPE_VIDEO :
2010-02-10 19:31:47 +01:00
av_log ( s , AV_LOG_DEBUG , " video codec set to: %s \n " , c_name ) ;
2010-12-07 14:29:44 +01:00
if ( i > 0 )
2011-11-29 19:28:15 +01:00
avpriv_set_pts_info ( st , 32 , 1 , i ) ;
2010-02-10 19:31:47 +01:00
break ;
default :
break ;
}
2015-02-24 12:18:10 +01:00
finalize_rtp_handler_init ( s , rtsp_st , st ) ;
2010-02-10 19:31:47 +01:00
return 0 ;
2002-11-18 18:24:39 +01:00
}
2010-03-29 21:17:49 +02:00
/* parse the attribute line from the fmtp a line of an sdp response. This
2010-01-07 23:41:14 +01:00
* is broken out as a function because it is used in rtp_h264 . c , which is
* forthcoming . */
2010-02-23 01:35:50 +01:00
int ff_rtsp_next_attr_and_value ( const char * * p , char * attr , int attr_size ,
2010-02-23 12:05:36 +01:00
char * value , int value_size )
2006-10-29 11:58:51 +01:00
{
2010-06-25 09:56:45 +02:00
* p + = strspn ( * p , SPACE_CHARS ) ;
2010-01-07 23:41:14 +01:00
if ( * * p ) {
2006-10-29 11:58:51 +01:00
get_word_sep ( attr , attr_size , " = " , p ) ;
if ( * * p = = ' = ' )
( * p ) + + ;
get_word_sep ( value , value_size , " ; " , p ) ;
if ( * * p = = ' ; ' )
( * p ) + + ;
return 1 ;
}
return 0 ;
}
2002-11-18 18:24:39 +01:00
typedef struct SDPParseState {
/* SDP only */
2010-08-25 17:32:00 +02:00
struct sockaddr_storage default_ip ;
2010-01-07 23:41:14 +01:00
int default_ttl ;
int skip_media ; ///< set if an unknown m= line occurs
2013-07-26 12:38:00 +02:00
int nb_default_include_source_addrs ; /**< Number of source-specific multicast include source IP address (from SDP content) */
struct RTSPSource * * default_include_source_addrs ; /**< Source-specific multicast include source IP address (from SDP content) */
int nb_default_exclude_source_addrs ; /**< Number of source-specific multicast exclude source IP address (from SDP content) */
struct RTSPSource * * default_exclude_source_addrs ; /**< Source-specific multicast exclude source IP address (from SDP content) */
2014-06-17 02:49:46 +02:00
int seen_rtpmap ;
int seen_fmtp ;
char delayed_fmtp [ 2048 ] ;
2002-11-18 18:24:39 +01:00
} SDPParseState ;
2013-07-26 12:38:00 +02:00
static void copy_default_source_addrs ( struct RTSPSource * * addrs , int count ,
struct RTSPSource * * * dest , int * dest_count )
{
RTSPSource * rtsp_src , * rtsp_src2 ;
int i ;
for ( i = 0 ; i < count ; i + + ) {
rtsp_src = addrs [ i ] ;
rtsp_src2 = av_malloc ( sizeof ( * rtsp_src2 ) ) ;
if ( ! rtsp_src2 )
continue ;
memcpy ( rtsp_src2 , rtsp_src , sizeof ( * rtsp_src ) ) ;
dynarray_add ( dest , dest_count , rtsp_src2 ) ;
}
}
2014-06-17 02:36:55 +02:00
static void parse_fmtp ( AVFormatContext * s , RTSPState * rt ,
int payload_type , const char * line )
{
int i ;
for ( i = 0 ; i < rt - > nb_rtsp_streams ; i + + ) {
RTSPStream * rtsp_st = rt - > rtsp_streams [ i ] ;
if ( rtsp_st - > sdp_payload_type = = payload_type & &
rtsp_st - > dynamic_handler & &
rtsp_st - > dynamic_handler - > parse_sdp_a_line ) {
rtsp_st - > dynamic_handler - > parse_sdp_a_line ( s , i ,
2015-02-23 20:56:28 +01:00
rtsp_st - > dynamic_protocol_context , line ) ;
2014-06-17 02:36:55 +02:00
}
}
}
2002-11-18 18:24:39 +01:00
static void sdp_parse_line ( AVFormatContext * s , SDPParseState * s1 ,
2002-07-04 12:41:34 +02:00
int letter , const char * buf )
{
2003-10-29 15:25:27 +01:00
RTSPState * rt = s - > priv_data ;
2002-07-04 12:41:34 +02:00
char buf1 [ 64 ] , st_type [ 64 ] ;
const char * p ;
2010-03-31 01:30:55 +02:00
enum AVMediaType codec_type ;
2014-06-17 02:36:55 +02:00
int payload_type ;
2002-07-04 12:41:34 +02:00
AVStream * st ;
RTSPStream * rtsp_st ;
2013-07-26 12:38:00 +02:00
RTSPSource * rtsp_src ;
2010-08-25 17:32:00 +02:00
struct sockaddr_storage sdp_ip ;
2002-11-18 18:24:39 +01:00
int ttl ;
2015-03-16 09:57:35 +01:00
av_log ( s , AV_LOG_TRACE , " sdp: %c='%s' \n " , letter , buf ) ;
2002-07-04 12:41:34 +02:00
p = buf ;
2009-01-24 05:56:18 +01:00
if ( s1 - > skip_media & & letter ! = ' m ' )
return ;
2010-01-07 23:41:14 +01:00
switch ( letter ) {
2002-11-18 18:24:39 +01:00
case ' c ' :
get_word ( buf1 , sizeof ( buf1 ) , & p ) ;
if ( strcmp ( buf1 , " IN " ) ! = 0 )
return ;
get_word ( buf1 , sizeof ( buf1 ) , & p ) ;
2010-08-25 17:32:00 +02:00
if ( strcmp ( buf1 , " IP4 " ) & & strcmp ( buf1 , " IP6 " ) )
2002-11-18 18:24:39 +01:00
return ;
get_word_sep ( buf1 , sizeof ( buf1 ) , " / " , & p ) ;
2015-11-24 01:13:00 +01:00
if ( get_sockaddr ( s , buf1 , & sdp_ip ) )
2002-11-18 18:24:39 +01:00
return ;
ttl = 16 ;
if ( * p = = ' / ' ) {
p + + ;
get_word_sep ( buf1 , sizeof ( buf1 ) , " / " , & p ) ;
ttl = atoi ( buf1 ) ;
}
if ( s - > nb_streams = = 0 ) {
s1 - > default_ip = sdp_ip ;
s1 - > default_ttl = ttl ;
} else {
2011-02-02 10:08:01 +01:00
rtsp_st = rt - > rtsp_streams [ rt - > nb_rtsp_streams - 1 ] ;
2002-11-18 18:24:39 +01:00
rtsp_st - > sdp_ip = sdp_ip ;
rtsp_st - > sdp_ttl = ttl ;
}
break ;
2002-07-04 12:41:34 +02:00
case ' s ' :
2011-05-22 12:46:29 +02:00
av_dict_set ( & s - > metadata , " title " , p , 0 ) ;
2002-07-04 12:41:34 +02:00
break ;
case ' i ' :
if ( s - > nb_streams = = 0 ) {
2011-05-22 12:46:29 +02:00
av_dict_set ( & s - > metadata , " comment " , p , 0 ) ;
2002-07-04 12:41:34 +02:00
break ;
}
break ;
case ' m ' :
/* new stream */
2014-06-17 02:49:46 +02:00
s1 - > skip_media = 0 ;
s1 - > seen_fmtp = 0 ;
s1 - > seen_rtpmap = 0 ;
2011-10-29 23:41:24 +02:00
codec_type = AVMEDIA_TYPE_UNKNOWN ;
2002-07-04 12:41:34 +02:00
get_word ( st_type , sizeof ( st_type ) , & p ) ;
if ( ! strcmp ( st_type , " audio " ) ) {
2010-03-31 01:30:55 +02:00
codec_type = AVMEDIA_TYPE_AUDIO ;
2002-07-04 12:41:34 +02:00
} else if ( ! strcmp ( st_type , " video " ) ) {
2010-03-31 01:30:55 +02:00
codec_type = AVMEDIA_TYPE_VIDEO ;
2015-02-28 23:15:41 +01:00
} else if ( ! strcmp ( st_type , " application " ) ) {
2010-03-31 01:30:55 +02:00
codec_type = AVMEDIA_TYPE_DATA ;
2015-02-08 22:22:40 +01:00
} else if ( ! strcmp ( st_type , " text " ) ) {
codec_type = AVMEDIA_TYPE_SUBTITLE ;
2011-10-29 23:41:24 +02:00
}
2019-01-25 21:30:04 +01:00
if ( codec_type = = AVMEDIA_TYPE_UNKNOWN | |
! ( rt - > media_type_mask & ( 1 < < codec_type ) ) | |
rt - > nb_rtsp_streams > = s - > max_streams
) {
2009-01-24 05:56:18 +01:00
s1 - > skip_media = 1 ;
2002-07-04 12:41:34 +02:00
return ;
}
rtsp_st = av_mallocz ( sizeof ( RTSPStream ) ) ;
if ( ! rtsp_st )
return ;
2003-10-29 15:25:27 +01:00
rtsp_st - > stream_index = - 1 ;
dynarray_add ( & rt - > rtsp_streams , & rt - > nb_rtsp_streams , rtsp_st ) ;
2002-11-18 18:24:39 +01:00
rtsp_st - > sdp_ip = s1 - > default_ip ;
rtsp_st - > sdp_ttl = s1 - > default_ttl ;
2013-07-26 12:38:00 +02:00
copy_default_source_addrs ( s1 - > default_include_source_addrs ,
s1 - > nb_default_include_source_addrs ,
& rtsp_st - > include_source_addrs ,
& rtsp_st - > nb_include_source_addrs ) ;
copy_default_source_addrs ( s1 - > default_exclude_source_addrs ,
s1 - > nb_default_exclude_source_addrs ,
& rtsp_st - > exclude_source_addrs ,
& rtsp_st - > nb_exclude_source_addrs ) ;
2002-11-18 18:24:39 +01:00
get_word ( buf1 , sizeof ( buf1 ) , & p ) ; /* port */
rtsp_st - > sdp_port = atoi ( buf1 ) ;
2012-08-08 20:37:47 +02:00
get_word ( buf1 , sizeof ( buf1 ) , & p ) ; /* protocol */
if ( ! strcmp ( buf1 , " udp " ) )
rt - > transport = RTSP_TRANSPORT_RAW ;
2012-12-11 14:59:24 +01:00
else if ( strstr ( buf1 , " /AVPF " ) | | strstr ( buf1 , " /SAVPF " ) )
rtsp_st - > feedback = 1 ;
2005-12-17 19:14:38 +01:00
2002-11-18 18:24:39 +01:00
/* XXX: handle list of formats */
get_word ( buf1 , sizeof ( buf1 ) , & p ) ; /* format list */
rtsp_st - > sdp_payload_type = atoi ( buf1 ) ;
2007-11-16 08:59:41 +01:00
if ( ! strcmp ( ff_rtp_enc_name ( rtsp_st - > sdp_payload_type ) , " MP2T " ) ) {
2003-10-29 15:25:27 +01:00
/* no corresponding stream */
2013-01-17 13:34:59 +01:00
if ( rt - > transport = = RTSP_TRANSPORT_RAW ) {
2014-11-29 17:39:41 +01:00
if ( CONFIG_RTPDEC & & ! rt - > ts )
2014-08-07 01:59:56 +02:00
rt - > ts = avpriv_mpegts_parse_open ( s ) ;
2013-01-17 13:34:59 +01:00
} else {
2018-02-10 02:54:42 +01:00
const RTPDynamicProtocolHandler * handler ;
2013-01-17 13:34:59 +01:00
handler = ff_rtp_handler_find_by_id (
rtsp_st - > sdp_payload_type , AVMEDIA_TYPE_DATA ) ;
init_rtp_handler ( handler , rtsp_st , NULL ) ;
2015-02-24 12:18:10 +01:00
finalize_rtp_handler_init ( s , rtsp_st , NULL ) ;
2013-01-17 13:34:59 +01:00
}
2012-04-06 22:07:12 +02:00
} else if ( rt - > server_type = = RTSP_SERVER_WMS & &
codec_type = = AVMEDIA_TYPE_DATA ) {
/* RTX stream, a stream that carries all the other actual
* audio / video streams . Don ' t expose this to the callers . */
2003-10-29 15:25:27 +01:00
} else {
2011-06-18 11:43:24 +02:00
st = avformat_new_stream ( s , NULL ) ;
2003-10-29 15:25:27 +01:00
if ( ! st )
return ;
2011-06-18 11:43:24 +02:00
st - > id = rt - > nb_rtsp_streams - 1 ;
2003-10-29 15:25:27 +01:00
rtsp_st - > stream_index = st - > index ;
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 20:42:52 +02:00
st - > codecpar - > codec_type = codec_type ;
2005-05-26 09:47:51 +02:00
if ( rtsp_st - > sdp_payload_type < RTP_PT_PRIVATE ) {
2018-02-10 02:54:42 +01:00
const RTPDynamicProtocolHandler * handler ;
2003-10-29 15:25:27 +01:00
/* if standard payload type, we can find the codec right now */
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 20:42:52 +02:00
ff_rtp_get_codec_info ( st - > codecpar , rtsp_st - > sdp_payload_type ) ;
if ( st - > codecpar - > codec_type = = AVMEDIA_TYPE_AUDIO & &
st - > codecpar - > sample_rate > 0 )
avpriv_set_pts_info ( st , 32 , 1 , st - > codecpar - > sample_rate ) ;
2010-12-05 20:41:44 +01:00
/* Even static payload types may need a custom depacketizer */
handler = ff_rtp_handler_find_by_id (
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 20:42:52 +02:00
rtsp_st - > sdp_payload_type , st - > codecpar - > codec_type ) ;
2015-02-23 20:35:48 +01:00
init_rtp_handler ( handler , rtsp_st , st ) ;
2015-02-24 12:18:10 +01:00
finalize_rtp_handler_init ( s , rtsp_st , st ) ;
2003-10-29 15:25:27 +01:00
}
2015-02-08 22:22:45 +01:00
if ( rt - > default_lang [ 0 ] )
av_dict_set ( & st - > metadata , " language " , rt - > default_lang , 0 ) ;
2003-10-29 15:25:27 +01:00
}
2002-07-04 12:41:34 +02:00
/* put a default control url */
2010-01-22 17:04:15 +01:00
av_strlcpy ( rtsp_st - > control_url , rt - > control_uri ,
2010-01-07 23:41:14 +01:00
sizeof ( rtsp_st - > control_url ) ) ;
2002-07-04 12:41:34 +02:00
break ;
case ' a ' :
2010-01-22 17:04:15 +01:00
if ( av_strstart ( p , " control: " , & p ) ) {
2020-10-11 01:22:18 +02:00
if ( rt - > nb_rtsp_streams = = 0 ) {
2010-01-22 17:04:15 +01:00
if ( ! strncmp ( p , " rtsp:// " , 7 ) )
av_strlcpy ( rt - > control_uri , p ,
sizeof ( rt - > control_uri ) ) ;
} else {
2010-11-28 22:17:39 +01:00
char proto [ 32 ] ;
/* get the control url */
2011-02-02 10:08:01 +01:00
rtsp_st = rt - > rtsp_streams [ rt - > nb_rtsp_streams - 1 ] ;
2005-12-17 19:14:38 +01:00
2010-11-28 22:17:39 +01:00
/* XXX: may need to add full url resolution */
av_url_split ( proto , sizeof ( proto ) , NULL , 0 , NULL , 0 ,
NULL , NULL , 0 , p ) ;
if ( proto [ 0 ] = = ' \0 ' ) {
/* relative control URL */
if ( rtsp_st - > control_url [ strlen ( rtsp_st - > control_url ) - 1 ] ! = ' / ' )
av_strlcat ( rtsp_st - > control_url , " / " ,
sizeof ( rtsp_st - > control_url ) ) ;
av_strlcat ( rtsp_st - > control_url , p ,
sizeof ( rtsp_st - > control_url ) ) ;
} else
av_strlcpy ( rtsp_st - > control_url , p ,
sizeof ( rtsp_st - > control_url ) ) ;
2010-01-22 17:04:15 +01:00
}
2009-01-10 00:36:17 +01:00
} else if ( av_strstart ( p , " rtpmap: " , & p ) & & s - > nb_streams > 0 ) {
2002-11-18 18:24:39 +01:00
/* NOTE: rtpmap is only supported AFTER the 'm=' tag */
2005-12-17 19:14:38 +01:00
get_word ( buf1 , sizeof ( buf1 ) , & p ) ;
2002-11-18 18:24:39 +01:00
payload_type = atoi ( buf1 ) ;
2011-02-02 10:08:01 +01:00
rtsp_st = rt - > rtsp_streams [ rt - > nb_rtsp_streams - 1 ] ;
2012-04-06 22:07:12 +02:00
if ( rtsp_st - > stream_index > = 0 ) {
st = s - > streams [ rtsp_st - > stream_index ] ;
sdp_parse_rtpmap ( s , st , rtsp_st , payload_type , p ) ;
}
2014-06-17 02:49:46 +02:00
s1 - > seen_rtpmap = 1 ;
if ( s1 - > seen_fmtp ) {
parse_fmtp ( s , rt , payload_type , s1 - > delayed_fmtp ) ;
}
2010-06-25 10:00:05 +02:00
} else if ( av_strstart ( p , " fmtp: " , & p ) | |
av_strstart ( p , " framesize: " , & p ) ) {
2006-10-29 11:58:51 +01:00
// let dynamic protocol handlers have a stab at the line.
get_word ( buf1 , sizeof ( buf1 ) , & p ) ;
payload_type = atoi ( buf1 ) ;
2014-06-17 02:49:46 +02:00
if ( s1 - > seen_rtpmap ) {
parse_fmtp ( s , rt , payload_type , buf ) ;
} else {
s1 - > seen_fmtp = 1 ;
av_strlcpy ( s1 - > delayed_fmtp , buf , sizeof ( s1 - > delayed_fmtp ) ) ;
}
2012-12-04 14:28:29 +01:00
} else if ( av_strstart ( p , " ssrc: " , & p ) & & s - > nb_streams > 0 ) {
rtsp_st = rt - > rtsp_streams [ rt - > nb_rtsp_streams - 1 ] ;
get_word ( buf1 , sizeof ( buf1 ) , & p ) ;
rtsp_st - > ssrc = strtoll ( buf1 , NULL , 10 ) ;
2010-01-07 23:41:14 +01:00
} else if ( av_strstart ( p , " range: " , & p ) ) {
2006-11-06 22:58:43 +01:00
int64_t start , end ;
// this is so that seeking on a streamed file can work.
rtsp_parse_range_npt ( p , & start , & end ) ;
2010-01-07 23:41:14 +01:00
s - > start_time = start ;
/* AV_NOPTS_VALUE means live broadcast (and can't seek) */
s - > duration = ( end = = AV_NOPTS_VALUE ) ?
AV_NOPTS_VALUE : end - start ;
2015-02-08 22:22:45 +01:00
} else if ( av_strstart ( p , " lang: " , & p ) ) {
if ( s - > nb_streams > 0 ) {
get_word ( buf1 , sizeof ( buf1 ) , & p ) ;
rtsp_st = rt - > rtsp_streams [ rt - > nb_rtsp_streams - 1 ] ;
if ( rtsp_st - > stream_index > = 0 ) {
st = s - > streams [ rtsp_st - > stream_index ] ;
av_dict_set ( & st - > metadata , " language " , buf1 , 0 ) ;
}
} else
get_word ( rt - > default_lang , sizeof ( rt - > default_lang ) , & p ) ;
2008-09-30 15:26:20 +02:00
} else if ( av_strstart ( p , " IsRealDataType:integer; " , & p ) ) {
if ( atoi ( p ) = = 1 )
rt - > transport = RTSP_TRANSPORT_RDT ;
2010-12-07 14:28:45 +01:00
} else if ( av_strstart ( p , " SampleRate:integer; " , & p ) & &
s - > nb_streams > 0 ) {
st = s - > streams [ s - > nb_streams - 1 ] ;
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 20:42:52 +02:00
st - > codecpar - > sample_rate = atoi ( p ) ;
2012-10-20 22:18:01 +02:00
} else if ( av_strstart ( p , " crypto: " , & p ) & & s - > nb_streams > 0 ) {
// RFC 4568
rtsp_st = rt - > rtsp_streams [ rt - > nb_rtsp_streams - 1 ] ;
get_word ( buf1 , sizeof ( buf1 ) , & p ) ; // ignore tag
get_word ( rtsp_st - > crypto_suite , sizeof ( rtsp_st - > crypto_suite ) , & p ) ;
p + = strspn ( p , SPACE_CHARS ) ;
if ( av_strstart ( p , " inline: " , & p ) )
get_word ( rtsp_st - > crypto_params , sizeof ( rtsp_st - > crypto_params ) , & p ) ;
2013-07-26 12:38:00 +02:00
} else if ( av_strstart ( p , " source-filter: " , & p ) ) {
int exclude = 0 ;
2013-06-27 09:53:00 +02:00
get_word ( buf1 , sizeof ( buf1 ) , & p ) ;
2013-07-26 12:38:00 +02:00
if ( strcmp ( buf1 , " incl " ) & & strcmp ( buf1 , " excl " ) )
2013-06-27 09:53:00 +02:00
return ;
2013-07-26 12:38:00 +02:00
exclude = ! strcmp ( buf1 , " excl " ) ;
2013-06-27 09:53:00 +02:00
get_word ( buf1 , sizeof ( buf1 ) , & p ) ;
if ( strcmp ( buf1 , " IN " ) ! = 0 )
2013-06-27 09:53:00 +02:00
return ;
2013-06-27 09:53:00 +02:00
get_word ( buf1 , sizeof ( buf1 ) , & p ) ;
2013-07-26 12:38:00 +02:00
if ( strcmp ( buf1 , " IP4 " ) & & strcmp ( buf1 , " IP6 " ) & & strcmp ( buf1 , " * " ) )
2013-06-27 09:53:00 +02:00
return ;
2013-07-26 12:38:00 +02:00
// not checking that the destination address actually matches or is wildcard
2013-06-27 09:53:00 +02:00
get_word ( buf1 , sizeof ( buf1 ) , & p ) ;
2013-07-26 12:38:00 +02:00
while ( * p ! = ' \0 ' ) {
rtsp_src = av_mallocz ( sizeof ( * rtsp_src ) ) ;
if ( ! rtsp_src )
return ;
get_word ( rtsp_src - > addr , sizeof ( rtsp_src - > addr ) , & p ) ;
if ( exclude ) {
if ( s - > nb_streams = = 0 ) {
dynarray_add ( & s1 - > default_exclude_source_addrs , & s1 - > nb_default_exclude_source_addrs , rtsp_src ) ;
} else {
rtsp_st = rt - > rtsp_streams [ rt - > nb_rtsp_streams - 1 ] ;
dynarray_add ( & rtsp_st - > exclude_source_addrs , & rtsp_st - > nb_exclude_source_addrs , rtsp_src ) ;
}
} else {
if ( s - > nb_streams = = 0 ) {
dynarray_add ( & s1 - > default_include_source_addrs , & s1 - > nb_default_include_source_addrs , rtsp_src ) ;
} else {
rtsp_st = rt - > rtsp_streams [ rt - > nb_rtsp_streams - 1 ] ;
dynarray_add ( & rtsp_st - > include_source_addrs , & rtsp_st - > nb_include_source_addrs , rtsp_src ) ;
}
}
}
2009-03-17 13:34:57 +01:00
} else {
if ( rt - > server_type = = RTSP_SERVER_WMS )
ff_wms_parse_sdp_a_line ( s , p ) ;
if ( s - > nb_streams > 0 ) {
2012-04-06 22:07:12 +02:00
rtsp_st = rt - > rtsp_streams [ rt - > nb_rtsp_streams - 1 ] ;
2009-03-17 13:35:55 +01:00
if ( rt - > server_type = = RTSP_SERVER_REAL )
2012-04-06 22:07:12 +02:00
ff_real_parse_sdp_a_line ( s , rtsp_st - > stream_index , p ) ;
2009-03-17 13:35:55 +01:00
if ( rtsp_st - > dynamic_handler & &
rtsp_st - > dynamic_handler - > parse_sdp_a_line )
2010-01-07 23:41:14 +01:00
rtsp_st - > dynamic_handler - > parse_sdp_a_line ( s ,
2012-04-06 22:07:12 +02:00
rtsp_st - > stream_index ,
2009-03-17 13:35:55 +01:00
rtsp_st - > dynamic_protocol_context , buf ) ;
2009-03-17 13:34:57 +01:00
}
2002-07-04 12:41:34 +02:00
}
break ;
}
}
2010-10-29 10:43:57 +02:00
int ff_sdp_parse ( AVFormatContext * s , const char * content )
2002-07-04 12:41:34 +02:00
{
const char * p ;
2013-07-26 12:38:00 +02:00
int letter , i ;
2020-11-04 13:51:06 +01:00
char buf [ SDP_MAX_SIZE ] , * q ;
2011-06-06 14:13:02 +02:00
SDPParseState sdp_parse_state = { { 0 } } , * s1 = & sdp_parse_state ;
2005-12-17 19:14:38 +01:00
2002-07-04 12:41:34 +02:00
p = content ;
2010-01-07 23:41:14 +01:00
for ( ; ; ) {
2010-06-25 09:56:45 +02:00
p + = strspn ( p , SPACE_CHARS ) ;
2002-07-04 12:41:34 +02:00
letter = * p ;
if ( letter = = ' \0 ' )
break ;
p + + ;
if ( * p ! = ' = ' )
goto next_line ;
p + + ;
/* get the content */
q = buf ;
2003-07-15 18:57:35 +02:00
while ( * p ! = ' \n ' & & * p ! = ' \r ' & & * p ! = ' \0 ' ) {
2002-07-04 12:41:34 +02:00
if ( ( q - buf ) < sizeof ( buf ) - 1 )
* q + + = * p ;
p + + ;
}
* q = ' \0 ' ;
2002-11-18 18:24:39 +01:00
sdp_parse_line ( s , s1 , letter , buf ) ;
2002-07-04 12:41:34 +02:00
next_line :
while ( * p ! = ' \n ' & & * p ! = ' \0 ' )
p + + ;
if ( * p = = ' \n ' )
p + + ;
}
2013-07-26 12:38:00 +02:00
for ( i = 0 ; i < s1 - > nb_default_include_source_addrs ; i + + )
2014-12-26 14:59:29 +01:00
av_freep ( & s1 - > default_include_source_addrs [ i ] ) ;
2013-07-26 12:38:00 +02:00
av_freep ( & s1 - > default_include_source_addrs ) ;
for ( i = 0 ; i < s1 - > nb_default_exclude_source_addrs ; i + + )
2014-12-26 14:59:29 +01:00
av_freep ( & s1 - > default_exclude_source_addrs [ i ] ) ;
2013-07-26 12:38:00 +02:00
av_freep ( & s1 - > default_exclude_source_addrs ) ;
2002-07-04 12:41:34 +02:00
return 0 ;
}
2010-10-21 14:18:48 +02:00
# endif /* CONFIG_RTPDEC */
2002-07-04 12:41:34 +02:00
2013-10-30 18:12:45 +01:00
void ff_rtsp_undo_setup ( AVFormatContext * s , int send_packets )
2011-01-24 10:49:02 +01:00
{
RTSPState * rt = s - > priv_data ;
int i ;
for ( i = 0 ; i < rt - > nb_rtsp_streams ; i + + ) {
RTSPStream * rtsp_st = rt - > rtsp_streams [ i ] ;
if ( ! rtsp_st )
continue ;
if ( rtsp_st - > transport_priv ) {
if ( s - > oformat ) {
AVFormatContext * rtpctx = rtsp_st - > transport_priv ;
av_write_trailer ( rtpctx ) ;
if ( rt - > lower_transport = = RTSP_LOWER_TRANSPORT_TCP ) {
2013-10-30 18:12:45 +01:00
if ( CONFIG_RTSP_MUXER & & rtpctx - > pb & & send_packets )
ff_rtsp_tcp_write_packet ( s , rtsp_st ) ;
2015-02-24 13:07:54 +01:00
ffio_free_dyn_buf ( & rtpctx - > pb ) ;
2011-01-24 10:49:02 +01:00
} else {
2015-01-08 20:08:24 +01:00
avio_closep ( & rtpctx - > pb ) ;
2011-01-24 10:49:02 +01:00
}
2011-02-04 11:04:18 +01:00
avformat_free_context ( rtpctx ) ;
2014-11-29 17:39:41 +01:00
} else if ( CONFIG_RTPDEC & & rt - > transport = = RTSP_TRANSPORT_RDT )
2011-01-24 10:49:02 +01:00
ff_rdt_parse_close ( rtsp_st - > transport_priv ) ;
2014-11-29 17:39:41 +01:00
else if ( CONFIG_RTPDEC & & rt - > transport = = RTSP_TRANSPORT_RTP )
2011-10-12 11:37:42 +02:00
ff_rtp_parse_close ( rtsp_st - > transport_priv ) ;
2011-01-24 10:49:02 +01:00
}
rtsp_st - > transport_priv = NULL ;
2020-04-03 17:03:38 +02:00
ffurl_closep ( & rtsp_st - > rtp_handle ) ;
2011-01-24 10:49:02 +01:00
}
}
2009-11-12 11:31:37 +01:00
/* close and free RTSP streams */
2010-02-23 01:35:50 +01:00
void ff_rtsp_close_streams ( AVFormatContext * s )
2009-11-12 11:31:37 +01:00
{
2010-02-20 00:10:19 +01:00
RTSPState * rt = s - > priv_data ;
2013-07-26 12:38:00 +02:00
int i , j ;
2009-11-12 11:31:37 +01:00
RTSPStream * rtsp_st ;
2013-10-30 18:12:45 +01:00
ff_rtsp_undo_setup ( s , 0 ) ;
2010-01-07 23:41:14 +01:00
for ( i = 0 ; i < rt - > nb_rtsp_streams ; i + + ) {
2009-11-12 11:31:37 +01:00
rtsp_st = rt - > rtsp_streams [ i ] ;
if ( rtsp_st ) {
2015-02-23 20:57:33 +01:00
if ( rtsp_st - > dynamic_handler & & rtsp_st - > dynamic_protocol_context ) {
2015-02-24 16:01:48 +01:00
if ( rtsp_st - > dynamic_handler - > close )
rtsp_st - > dynamic_handler - > close (
2015-02-23 20:57:33 +01:00
rtsp_st - > dynamic_protocol_context ) ;
2015-02-24 12:07:57 +01:00
av_free ( rtsp_st - > dynamic_protocol_context ) ;
2015-02-23 20:57:33 +01:00
}
2013-07-26 12:38:00 +02:00
for ( j = 0 ; j < rtsp_st - > nb_include_source_addrs ; j + + )
2014-12-26 14:59:29 +01:00
av_freep ( & rtsp_st - > include_source_addrs [ j ] ) ;
2013-07-26 12:38:00 +02:00
av_freep ( & rtsp_st - > include_source_addrs ) ;
for ( j = 0 ; j < rtsp_st - > nb_exclude_source_addrs ; j + + )
2014-12-26 14:59:29 +01:00
av_freep ( & rtsp_st - > exclude_source_addrs [ j ] ) ;
2013-07-26 12:38:00 +02:00
av_freep ( & rtsp_st - > exclude_source_addrs ) ;
2014-12-26 14:59:29 +01:00
av_freep ( & rtsp_st ) ;
2009-11-12 11:31:37 +01:00
}
}
2014-12-26 14:59:29 +01:00
av_freep ( & rt - > rtsp_streams ) ;
2009-11-12 11:31:37 +01:00
if ( rt - > asf_ctx ) {
2011-12-11 10:38:28 +01:00
avformat_close_input ( & rt - > asf_ctx ) ;
2009-11-12 11:31:37 +01:00
}
2014-11-29 17:39:41 +01:00
if ( CONFIG_RTPDEC & & rt - > ts )
2014-08-07 01:59:56 +02:00
avpriv_mpegts_parse_close ( rt - > ts ) ;
2014-12-26 14:59:29 +01:00
av_freep ( & rt - > p ) ;
av_freep ( & rt - > recvbuf ) ;
2009-11-12 11:31:37 +01:00
}
2012-07-10 19:25:04 +02:00
int ff_rtsp_open_transport_ctx ( AVFormatContext * s , RTSPStream * rtsp_st )
2009-11-12 11:31:37 +01:00
{
RTSPState * rt = s - > priv_data ;
AVStream * st = NULL ;
2012-10-17 14:46:30 +02:00
int reordering_queue_size = rt - > reordering_queue_size ;
if ( reordering_queue_size < 0 ) {
if ( rt - > lower_transport = = RTSP_LOWER_TRANSPORT_TCP | | ! s - > max_delay )
reordering_queue_size = 0 ;
else
reordering_queue_size = RTP_REORDER_QUEUE_DEFAULT_SIZE ;
}
2009-11-12 11:31:37 +01:00
/* open the RTP context */
if ( rtsp_st - > stream_index > = 0 )
st = s - > streams [ rtsp_st - > stream_index ] ;
if ( ! st )
s - > ctx_flags | = AVFMTCTX_NOHEADER ;
2015-04-12 21:35:52 +02:00
if ( CONFIG_RTSP_MUXER & & s - > oformat & & st ) {
2013-12-10 23:48:19 +01:00
int ret = ff_rtp_chain_mux_open ( ( AVFormatContext * * ) & rtsp_st - > transport_priv ,
s , st , rtsp_st - > rtp_handle ,
2012-11-11 20:44:28 +01:00
RTSP_TCP_MAX_PACKET_SIZE ,
rtsp_st - > stream_index ) ;
2010-03-29 21:17:49 +02:00
/* Ownership of rtp_handle is passed to the rtp mux context */
2010-02-22 16:46:56 +01:00
rtsp_st - > rtp_handle = NULL ;
2012-05-25 21:26:00 +02:00
if ( ret < 0 )
return ret ;
2014-05-31 00:09:58 +02:00
st - > time_base = ( ( AVFormatContext * ) rtsp_st - > transport_priv ) - > streams [ 0 ] - > time_base ;
2012-08-08 20:37:47 +02:00
} else if ( rt - > transport = = RTSP_TRANSPORT_RAW ) {
return 0 ; // Don't need to open any parser here
2015-04-12 21:35:52 +02:00
} else if ( CONFIG_RTPDEC & & rt - > transport = = RTSP_TRANSPORT_RDT & & st )
2009-11-12 11:31:37 +01:00
rtsp_st - > transport_priv = ff_rdt_parse_open ( s , st - > index ,
rtsp_st - > dynamic_protocol_context ,
rtsp_st - > dynamic_handler ) ;
2010-10-21 14:18:48 +02:00
else if ( CONFIG_RTPDEC )
2012-10-17 15:05:24 +02:00
rtsp_st - > transport_priv = ff_rtp_parse_open ( s , st ,
2010-10-01 19:50:24 +02:00
rtsp_st - > sdp_payload_type ,
2012-10-17 14:46:30 +02:00
reordering_queue_size ) ;
2009-11-12 11:31:37 +01:00
if ( ! rtsp_st - > transport_priv ) {
return AVERROR ( ENOMEM ) ;
2016-09-15 13:50:57 +02:00
} else if ( CONFIG_RTPDEC & & rt - > transport = = RTSP_TRANSPORT_RTP & &
s - > iformat ) {
2012-12-04 14:28:29 +01:00
RTPDemuxContext * rtpctx = rtsp_st - > transport_priv ;
rtpctx - > ssrc = rtsp_st - > ssrc ;
2010-01-07 23:41:14 +01:00
if ( rtsp_st - > dynamic_handler ) {
2011-10-12 11:37:42 +02:00
ff_rtp_parse_set_dynamic_protocol ( rtsp_st - > transport_priv ,
rtsp_st - > dynamic_protocol_context ,
rtsp_st - > dynamic_handler ) ;
2009-11-12 11:31:37 +01:00
}
2012-10-20 22:18:01 +02:00
if ( rtsp_st - > crypto_suite [ 0 ] )
ff_rtp_parse_set_crypto ( rtsp_st - > transport_priv ,
rtsp_st - > crypto_suite ,
rtsp_st - > crypto_params ) ;
2009-11-12 11:31:37 +01:00
}
return 0 ;
}
2010-02-22 22:28:19 +01:00
# if CONFIG_RTSP_DEMUXER || CONFIG_RTSP_MUXER
2002-07-04 12:41:34 +02:00
static void rtsp_parse_range ( int * min_ptr , int * max_ptr , const char * * pp )
{
2012-04-26 00:37:29 +02:00
const char * q ;
char * p ;
2002-07-04 12:41:34 +02:00
int v ;
2012-04-26 00:37:29 +02:00
q = * pp ;
q + = strspn ( q , SPACE_CHARS ) ;
v = strtol ( q , & p , 10 ) ;
2002-07-04 12:41:34 +02:00
if ( * p = = ' - ' ) {
p + + ;
* min_ptr = v ;
2012-04-26 00:37:29 +02:00
v = strtol ( p , & p , 10 ) ;
2002-07-04 12:41:34 +02:00
* max_ptr = v ;
} else {
* min_ptr = v ;
* max_ptr = v ;
}
* pp = p ;
}
/* XXX: only one transport specification is parsed */
2015-11-24 01:13:00 +01:00
static void rtsp_parse_transport ( AVFormatContext * s ,
RTSPMessageHeader * reply , const char * p )
2002-07-04 12:41:34 +02:00
{
char transport_protocol [ 16 ] ;
char profile [ 16 ] ;
char lower_transport [ 16 ] ;
char parameter [ 16 ] ;
RTSPTransportField * th ;
char buf [ 256 ] ;
2005-12-17 19:14:38 +01:00
2002-07-04 12:41:34 +02:00
reply - > nb_transports = 0 ;
2005-12-17 19:14:38 +01:00
2010-01-07 23:41:14 +01:00
for ( ; ; ) {
2010-06-25 09:56:45 +02:00
p + = strspn ( p , SPACE_CHARS ) ;
2002-07-04 12:41:34 +02:00
if ( * p = = ' \0 ' )
break ;
th = & reply - > transports [ reply - > nb_transports ] ;
2005-12-17 19:14:38 +01:00
get_word_sep ( transport_protocol , sizeof ( transport_protocol ) ,
2002-07-04 12:41:34 +02:00
" / " , & p ) ;
2011-11-02 20:17:25 +01:00
if ( ! av_strcasecmp ( transport_protocol , " rtp " ) ) {
2007-12-28 12:25:25 +01:00
get_word_sep ( profile , sizeof ( profile ) , " /;, " , & p ) ;
lower_transport [ 0 ] = ' \0 ' ;
/* rtp/avp/<protocol> */
if ( * p = = ' / ' ) {
get_word_sep ( lower_transport , sizeof ( lower_transport ) ,
" ;, " , & p ) ;
2008-09-30 15:26:20 +02:00
}
th - > transport = RTSP_TRANSPORT_RTP ;
2011-11-02 20:17:25 +01:00
} else if ( ! av_strcasecmp ( transport_protocol , " x-pn-tng " ) | |
! av_strcasecmp ( transport_protocol , " x-real-rdt " ) ) {
2007-12-28 12:25:25 +01:00
/* x-pn-tng/<protocol> */
2007-12-28 12:23:25 +01:00
get_word_sep ( lower_transport , sizeof ( lower_transport ) , " /;, " , & p ) ;
profile [ 0 ] = ' \0 ' ;
2008-09-30 15:26:20 +02:00
th - > transport = RTSP_TRANSPORT_RDT ;
2012-08-08 20:37:47 +02:00
} else if ( ! av_strcasecmp ( transport_protocol , " raw " ) ) {
get_word_sep ( profile , sizeof ( profile ) , " /;, " , & p ) ;
lower_transport [ 0 ] = ' \0 ' ;
/* raw/raw/<protocol> */
if ( * p = = ' / ' ) {
get_word_sep ( lower_transport , sizeof ( lower_transport ) ,
" ;, " , & p ) ;
}
th - > transport = RTSP_TRANSPORT_RAW ;
2002-07-04 12:41:34 +02:00
}
2011-11-02 20:17:25 +01:00
if ( ! av_strcasecmp ( lower_transport , " TCP " ) )
2008-09-30 15:18:41 +02:00
th - > lower_transport = RTSP_LOWER_TRANSPORT_TCP ;
2002-07-04 12:41:34 +02:00
else
2008-09-30 15:18:41 +02:00
th - > lower_transport = RTSP_LOWER_TRANSPORT_UDP ;
2005-12-17 19:14:38 +01:00
2002-07-04 12:41:34 +02:00
if ( * p = = ' ; ' )
p + + ;
/* get each parameter */
while ( * p ! = ' \0 ' & & * p ! = ' , ' ) {
get_word_sep ( parameter , sizeof ( parameter ) , " =;, " , & p ) ;
if ( ! strcmp ( parameter , " port " ) ) {
if ( * p = = ' = ' ) {
p + + ;
rtsp_parse_range ( & th - > port_min , & th - > port_max , & p ) ;
}
} else if ( ! strcmp ( parameter , " client_port " ) ) {
if ( * p = = ' = ' ) {
p + + ;
2005-12-17 19:14:38 +01:00
rtsp_parse_range ( & th - > client_port_min ,
2002-07-04 12:41:34 +02:00
& th - > client_port_max , & p ) ;
}
} else if ( ! strcmp ( parameter , " server_port " ) ) {
if ( * p = = ' = ' ) {
p + + ;
2005-12-17 19:14:38 +01:00
rtsp_parse_range ( & th - > server_port_min ,
2002-07-04 12:41:34 +02:00
& th - > server_port_max , & p ) ;
}
} else if ( ! strcmp ( parameter , " interleaved " ) ) {
if ( * p = = ' = ' ) {
p + + ;
2005-12-17 19:14:38 +01:00
rtsp_parse_range ( & th - > interleaved_min ,
2002-07-04 12:41:34 +02:00
& th - > interleaved_max , & p ) ;
}
} else if ( ! strcmp ( parameter , " multicast " ) ) {
2008-09-30 15:18:41 +02:00
if ( th - > lower_transport = = RTSP_LOWER_TRANSPORT_UDP )
th - > lower_transport = RTSP_LOWER_TRANSPORT_UDP_MULTICAST ;
2002-07-04 12:41:34 +02:00
} else if ( ! strcmp ( parameter , " ttl " ) ) {
if ( * p = = ' = ' ) {
2012-10-22 22:13:49 +02:00
char * end ;
2002-07-04 12:41:34 +02:00
p + + ;
2012-10-22 22:13:49 +02:00
th - > ttl = strtol ( p , & end , 10 ) ;
p = end ;
2002-07-04 12:41:34 +02:00
}
} else if ( ! strcmp ( parameter , " destination " ) ) {
if ( * p = = ' = ' ) {
p + + ;
get_word_sep ( buf , sizeof ( buf ) , " ;, " , & p ) ;
2015-11-24 01:13:00 +01:00
get_sockaddr ( s , buf , & th - > destination ) ;
2002-07-04 12:41:34 +02:00
}
2010-09-03 21:25:59 +02:00
} else if ( ! strcmp ( parameter , " source " ) ) {
if ( * p = = ' = ' ) {
p + + ;
get_word_sep ( buf , sizeof ( buf ) , " ;, " , & p ) ;
av_strlcpy ( th - > source , buf , sizeof ( th - > source ) ) ;
}
2012-07-10 19:21:58 +02:00
} else if ( ! strcmp ( parameter , " mode " ) ) {
if ( * p = = ' = ' ) {
p + + ;
get_word_sep ( buf , sizeof ( buf ) , " ;, " , & p ) ;
if ( ! strcmp ( buf , " record " ) | |
! strcmp ( buf , " receive " ) )
th - > mode_record = 1 ;
}
2002-07-04 12:41:34 +02:00
}
2010-09-03 21:25:59 +02:00
2002-07-04 12:41:34 +02:00
while ( * p ! = ' ; ' & & * p ! = ' \0 ' & & * p ! = ' , ' )
p + + ;
if ( * p = = ' ; ' )
p + + ;
}
if ( * p = = ' , ' )
p + + ;
reply - > nb_transports + + ;
2015-04-24 11:38:09 +02:00
if ( reply - > nb_transports > = RTSP_MAX_TRANSPORTS )
break ;
2002-07-04 12:41:34 +02:00
}
}
2011-01-05 22:23:42 +01:00
static void handle_rtp_info ( RTSPState * rt , const char * url ,
uint32_t seq , uint32_t rtptime )
{
int i ;
if ( ! rtptime | | ! url [ 0 ] )
return ;
if ( rt - > transport ! = RTSP_TRANSPORT_RTP )
return ;
for ( i = 0 ; i < rt - > nb_rtsp_streams ; i + + ) {
RTSPStream * rtsp_st = rt - > rtsp_streams [ i ] ;
RTPDemuxContext * rtpctx = rtsp_st - > transport_priv ;
if ( ! rtpctx )
continue ;
if ( ! strcmp ( rtsp_st - > control_url , url ) ) {
rtpctx - > base_timestamp = rtptime ;
break ;
}
}
}
static void rtsp_parse_rtp_info ( RTSPState * rt , const char * p )
{
int read = 0 ;
2020-11-15 03:45:15 +01:00
char key [ 20 ] , value [ MAX_URL_SIZE ] , url [ MAX_URL_SIZE ] = " " ;
2011-01-05 22:23:42 +01:00
uint32_t seq = 0 , rtptime = 0 ;
for ( ; ; ) {
p + = strspn ( p , SPACE_CHARS ) ;
if ( ! * p )
break ;
get_word_sep ( key , sizeof ( key ) , " = " , & p ) ;
if ( * p ! = ' = ' )
break ;
p + + ;
get_word_sep ( value , sizeof ( value ) , " ;, " , & p ) ;
read + + ;
if ( ! strcmp ( key , " url " ) )
av_strlcpy ( url , value , sizeof ( url ) ) ;
else if ( ! strcmp ( key , " seq " ) )
2011-03-26 17:13:36 +01:00
seq = strtoul ( value , NULL , 10 ) ;
2011-01-05 22:23:42 +01:00
else if ( ! strcmp ( key , " rtptime " ) )
2011-03-26 17:13:36 +01:00
rtptime = strtoul ( value , NULL , 10 ) ;
2011-01-05 22:23:42 +01:00
if ( * p = = ' , ' ) {
handle_rtp_info ( rt , url , seq , rtptime ) ;
url [ 0 ] = ' \0 ' ;
seq = rtptime = 0 ;
read = 0 ;
}
if ( * p )
p + + ;
}
if ( read > 0 )
handle_rtp_info ( rt , url , seq , rtptime ) ;
}
2015-11-24 01:13:00 +01:00
void ff_rtsp_parse_line ( AVFormatContext * s ,
RTSPMessageHeader * reply , const char * buf ,
2011-01-02 11:10:12 +01:00
RTSPState * rt , const char * method )
2002-07-04 12:41:34 +02:00
{
const char * p ;
/* NOTE: we do case independent match for broken servers */
p = buf ;
2007-06-24 13:27:12 +02:00
if ( av_stristart ( p , " Session: " , & p ) ) {
2009-04-15 15:04:34 +02:00
int t ;
2002-07-04 12:41:34 +02:00
get_word_sep ( reply - > session_id , sizeof ( reply - > session_id ) , " ; " , & p ) ;
2009-04-15 15:04:34 +02:00
if ( av_stristart ( p , " ;timeout= " , & p ) & &
( t = strtol ( p , NULL , 10 ) ) > 0 ) {
reply - > timeout = t ;
}
2007-06-24 13:27:12 +02:00
} else if ( av_stristart ( p , " Content-Length: " , & p ) ) {
2002-07-04 12:41:34 +02:00
reply - > content_length = strtol ( p , NULL , 10 ) ;
2007-06-24 13:27:12 +02:00
} else if ( av_stristart ( p , " Transport: " , & p ) ) {
2015-11-24 01:13:00 +01:00
rtsp_parse_transport ( s , reply , p ) ;
2007-06-24 13:27:12 +02:00
} else if ( av_stristart ( p , " CSeq: " , & p ) ) {
2002-07-04 12:41:34 +02:00
reply - > seq = strtol ( p , NULL , 10 ) ;
2007-06-24 13:27:12 +02:00
} else if ( av_stristart ( p , " Range: " , & p ) ) {
2006-11-06 22:58:43 +01:00
rtsp_parse_range_npt ( p , & reply - > range_start , & reply - > range_end ) ;
2008-08-31 19:32:02 +02:00
} else if ( av_stristart ( p , " RealChallenge1: " , & p ) ) {
2010-06-25 09:56:45 +02:00
p + = strspn ( p , SPACE_CHARS ) ;
2008-08-31 19:32:02 +02:00
av_strlcpy ( reply - > real_challenge , p , sizeof ( reply - > real_challenge ) ) ;
2009-01-07 15:55:47 +01:00
} else if ( av_stristart ( p , " Server: " , & p ) ) {
2010-06-25 09:56:45 +02:00
p + = strspn ( p , SPACE_CHARS ) ;
2009-01-07 15:55:47 +01:00
av_strlcpy ( reply - > server , p , sizeof ( reply - > server ) ) ;
2009-07-27 16:03:53 +02:00
} else if ( av_stristart ( p , " Notice: " , & p ) | |
av_stristart ( p , " X-Notice: " , & p ) ) {
reply - > notice = strtol ( p , NULL , 10 ) ;
2009-10-25 02:06:31 +02:00
} else if ( av_stristart ( p , " Location: " , & p ) ) {
2010-06-25 09:56:45 +02:00
p + = strspn ( p , SPACE_CHARS ) ;
2009-10-25 02:06:31 +02:00
av_strlcpy ( reply - > location , p , sizeof ( reply - > location ) ) ;
2011-01-02 11:07:56 +01:00
} else if ( av_stristart ( p , " WWW-Authenticate: " , & p ) & & rt ) {
2010-06-25 09:56:45 +02:00
p + = strspn ( p , SPACE_CHARS ) ;
2011-01-02 11:07:56 +01:00
ff_http_auth_handle_header ( & rt - > auth_state , " WWW-Authenticate " , p ) ;
} else if ( av_stristart ( p , " Authentication-Info: " , & p ) & & rt ) {
2010-06-25 09:56:45 +02:00
p + = strspn ( p , SPACE_CHARS ) ;
2011-01-02 11:07:56 +01:00
ff_http_auth_handle_header ( & rt - > auth_state , " Authentication-Info " , p ) ;
2011-01-02 11:11:12 +01:00
} else if ( av_stristart ( p , " Content-Base: " , & p ) & & rt ) {
2010-11-15 16:08:53 +01:00
p + = strspn ( p , SPACE_CHARS ) ;
2011-01-02 11:11:12 +01:00
if ( method & & ! strcmp ( method , " DESCRIBE " ) )
av_strlcpy ( rt - > control_uri , p , sizeof ( rt - > control_uri ) ) ;
2011-01-05 22:23:42 +01:00
} else if ( av_stristart ( p , " RTP-Info: " , & p ) & & rt ) {
p + = strspn ( p , SPACE_CHARS ) ;
if ( method & & ! strcmp ( method , " PLAY " ) )
rtsp_parse_rtp_info ( rt , p ) ;
2011-05-09 19:11:16 +02:00
} else if ( av_stristart ( p , " Public: " , & p ) & & rt ) {
if ( strstr ( p , " GET_PARAMETER " ) & &
method & & ! strcmp ( method , " OPTIONS " ) )
rt - > get_parameter_supported = 1 ;
2011-01-02 13:32:18 +01:00
} else if ( av_stristart ( p , " x-Accept-Dynamic-Rate: " , & p ) & & rt ) {
p + = strspn ( p , SPACE_CHARS ) ;
rt - > accept_dynamic_rate = atoi ( p ) ;
2012-05-04 17:50:31 +02:00
} else if ( av_stristart ( p , " Content-Type: " , & p ) ) {
p + = strspn ( p , SPACE_CHARS ) ;
av_strlcpy ( reply - > content_type , p , sizeof ( reply - > content_type ) ) ;
2020-12-16 21:40:16 +01:00
} else if ( av_stristart ( p , " com.ses.streamID: " , & p ) ) {
p + = strspn ( p , SPACE_CHARS ) ;
av_strlcpy ( reply - > stream_id , p , sizeof ( reply - > stream_id ) ) ;
2002-07-04 12:41:34 +02:00
}
}
2003-07-17 12:27:47 +02:00
/* skip a RTP/TCP interleaved packet */
2010-03-15 17:31:15 +01:00
void ff_rtsp_skip_packet ( AVFormatContext * s )
2003-07-17 12:27:47 +02:00
{
RTSPState * rt = s - > priv_data ;
int ret , len , len1 ;
2020-11-15 03:45:15 +01:00
uint8_t buf [ MAX_URL_SIZE ] ;
2003-07-17 12:27:47 +02:00
2011-03-31 16:40:31 +02:00
ret = ffurl_read_complete ( rt - > rtsp_hd , buf , 3 ) ;
2003-07-17 12:27:47 +02:00
if ( ret ! = 3 )
return ;
2007-07-06 11:32:34 +02:00
len = AV_RB16 ( buf + 1 ) ;
2009-05-31 06:32:45 +02:00
2015-03-16 09:57:35 +01:00
av_log ( s , AV_LOG_TRACE , " skipping RTP packet len=%d \n " , len ) ;
2009-05-31 06:32:45 +02:00
2003-07-17 12:27:47 +02:00
/* skip payload */
while ( len > 0 ) {
len1 = len ;
if ( len1 > sizeof ( buf ) )
len1 = sizeof ( buf ) ;
2011-03-31 16:40:31 +02:00
ret = ffurl_read_complete ( rt - > rtsp_hd , buf , len1 ) ;
2003-07-17 12:27:47 +02:00
if ( ret ! = len1 )
return ;
len - = len1 ;
}
}
2002-07-04 12:41:34 +02:00
2010-02-23 01:35:50 +01:00
int ff_rtsp_read_reply ( AVFormatContext * s , RTSPMessageHeader * reply ,
2010-02-23 12:05:36 +01:00
unsigned char * * content_ptr ,
2011-01-02 11:06:21 +01:00
int return_on_interleaved_data , const char * method )
2002-07-04 12:41:34 +02:00
{
RTSPState * rt = s - > priv_data ;
2020-11-15 03:45:15 +01:00
char buf [ MAX_URL_SIZE ] , buf1 [ MAX_URL_SIZE ] , * q ;
2002-07-04 12:41:34 +02:00
unsigned char ch ;
const char * p ;
2011-10-12 11:26:45 +02:00
int ret , content_length , line_count = 0 , request = 0 ;
2002-07-04 12:41:34 +02:00
unsigned char * content = NULL ;
2011-10-12 11:26:45 +02:00
start :
line_count = 0 ;
request = 0 ;
content = NULL ;
2009-02-21 15:40:19 +01:00
memset ( reply , 0 , sizeof ( * reply ) ) ;
2002-07-04 12:41:34 +02:00
/* parse reply (XXX: use buffers) */
rt - > last_reply [ 0 ] = ' \0 ' ;
2010-01-07 23:41:14 +01:00
for ( ; ; ) {
2002-07-04 12:41:34 +02:00
q = buf ;
2010-01-07 23:41:14 +01:00
for ( ; ; ) {
2011-03-31 16:40:31 +02:00
ret = ffurl_read_complete ( rt - > rtsp_hd , & ch , 1 ) ;
2015-03-16 09:57:35 +01:00
av_log ( s , AV_LOG_TRACE , " ret=%d c=%02x [%c] \n " , ret , ch , ch ) ;
2009-03-21 21:46:36 +01:00
if ( ret ! = 1 )
2010-08-25 15:42:17 +02:00
return AVERROR_EOF ;
2002-07-04 12:41:34 +02:00
if ( ch = = ' \n ' )
break ;
2015-10-21 10:56:36 +02:00
if ( ch = = ' $ ' & & q = = buf ) {
2009-03-21 21:46:36 +01:00
if ( return_on_interleaved_data ) {
return 1 ;
} else
2010-03-15 17:31:15 +01:00
ff_rtsp_skip_packet ( s ) ;
2003-07-17 12:27:47 +02:00
} else if ( ch ! = ' \r ' ) {
2002-07-04 12:41:34 +02:00
if ( ( q - buf ) < sizeof ( buf ) - 1 )
* q + + = ch ;
}
}
* q = ' \0 ' ;
2009-05-31 06:32:45 +02:00
2015-03-16 09:57:35 +01:00
av_log ( s , AV_LOG_TRACE , " line='%s' \n " , buf ) ;
2009-05-31 06:32:45 +02:00
2002-07-04 12:41:34 +02:00
/* test if last line */
if ( buf [ 0 ] = = ' \0 ' )
break ;
p = buf ;
if ( line_count = = 0 ) {
/* get reply code */
get_word ( buf1 , sizeof ( buf1 ) , & p ) ;
2011-10-12 11:26:45 +02:00
if ( ! strncmp ( buf1 , " RTSP/ " , 5 ) ) {
get_word ( buf1 , sizeof ( buf1 ) , & p ) ;
reply - > status_code = atoi ( buf1 ) ;
av_strlcpy ( reply - > reason , p , sizeof ( reply - > reason ) ) ;
} else {
av_strlcpy ( reply - > reason , buf1 , sizeof ( reply - > reason ) ) ; // method
get_word ( buf1 , sizeof ( buf1 ) , & p ) ; // object
request = 1 ;
}
2002-07-04 12:41:34 +02:00
} else {
2015-11-24 01:13:00 +01:00
ff_rtsp_parse_line ( s , reply , p , rt , method ) ;
2007-06-24 01:10:32 +02:00
av_strlcat ( rt - > last_reply , p , sizeof ( rt - > last_reply ) ) ;
av_strlcat ( rt - > last_reply , " \n " , sizeof ( rt - > last_reply ) ) ;
2002-07-04 12:41:34 +02:00
}
line_count + + ;
}
2005-12-17 19:14:38 +01:00
2011-10-12 11:26:45 +02:00
if ( rt - > session_id [ 0 ] = = ' \0 ' & & reply - > session_id [ 0 ] ! = ' \0 ' & & ! request )
2007-06-24 01:10:32 +02:00
av_strlcpy ( rt - > session_id , reply - > session_id , sizeof ( rt - > session_id ) ) ;
2005-12-17 19:14:38 +01:00
2002-07-04 12:41:34 +02:00
content_length = reply - > content_length ;
if ( content_length > 0 ) {
/* leave some room for a trailing '\0' (useful for simple parsing) */
content = av_malloc ( content_length + 1 ) ;
2014-10-14 22:30:39 +02:00
if ( ! content )
return AVERROR ( ENOMEM ) ;
2020-11-04 13:44:43 +01:00
if ( ffurl_read_complete ( rt - > rtsp_hd , content , content_length ) ! = content_length )
return AVERROR ( EIO ) ;
2002-07-04 12:41:34 +02:00
content [ content_length ] = ' \0 ' ;
}
if ( content_ptr )
* content_ptr = content ;
2007-07-16 12:56:40 +02:00
else
2014-12-26 14:59:29 +01:00
av_freep ( & content ) ;
2009-03-21 21:46:36 +01:00
2011-10-12 11:26:45 +02:00
if ( request ) {
2020-11-15 03:45:15 +01:00
char buf [ MAX_URL_SIZE ] ;
2011-10-12 11:26:45 +02:00
char base64buf [ AV_BASE64_SIZE ( sizeof ( buf ) ) ] ;
const char * ptr = buf ;
2021-07-12 15:00:34 +02:00
if ( ! strcmp ( reply - > reason , " OPTIONS " ) | |
! strcmp ( reply - > reason , " GET_PARAMETER " ) ) {
2011-10-12 11:26:45 +02:00
snprintf ( buf , sizeof ( buf ) , " RTSP/1.0 200 OK \r \n " ) ;
if ( reply - > seq )
av_strlcatf ( buf , sizeof ( buf ) , " CSeq: %d \r \n " , reply - > seq ) ;
if ( reply - > session_id [ 0 ] )
av_strlcatf ( buf , sizeof ( buf ) , " Session: %s \r \n " ,
reply - > session_id ) ;
} else {
snprintf ( buf , sizeof ( buf ) , " RTSP/1.0 501 Not Implemented \r \n " ) ;
}
av_strlcat ( buf , " \r \n " , sizeof ( buf ) ) ;
if ( rt - > control_transport = = RTSP_MODE_TUNNEL ) {
av_base64_encode ( base64buf , sizeof ( base64buf ) , buf , strlen ( buf ) ) ;
ptr = base64buf ;
}
ffurl_write ( rt - > rtsp_hd_out , ptr , strlen ( ptr ) ) ;
2014-10-22 11:40:46 +02:00
rt - > last_cmd_time = av_gettime_relative ( ) ;
2011-10-12 11:26:45 +02:00
/* Even if the request from the server had data, it is not the data
* that the caller wants or expects . The memory could also be leaked
* if the actual following reply has content data . */
if ( content_ptr )
av_freep ( content_ptr ) ;
/* If method is set, this is called from ff_rtsp_send_cmd,
* where a reply to exactly this request is awaited . For
2012-03-12 15:07:33 +01:00
* callers from within packet receiving , we just want to
2011-10-12 11:26:45 +02:00
* return to the caller and go back to receiving packets . */
if ( method )
goto start ;
return 0 ;
}
2010-03-24 23:38:48 +01:00
if ( rt - > seq ! = reply - > seq ) {
av_log ( s , AV_LOG_WARNING , " CSeq %d expected, %d received. \n " ,
rt - > seq , reply - > seq ) ;
}
2009-07-27 16:03:53 +02:00
/* EOS */
if ( reply - > notice = = 2101 /* End-of-Stream Reached */ | |
reply - > notice = = 2104 /* Start-of-Stream Reached */ | |
2010-01-07 23:41:14 +01:00
reply - > notice = = 2306 /* Continuous Feed Terminated */ ) {
2009-07-27 16:03:53 +02:00
rt - > state = RTSP_STATE_IDLE ;
2010-01-07 23:41:14 +01:00
} else if ( reply - > notice > = 4400 & & reply - > notice < 5500 ) {
2009-07-27 16:03:53 +02:00
return AVERROR ( EIO ) ; /* data or server error */
2010-01-07 23:41:14 +01:00
} else if ( reply - > notice = = 2401 /* Ticket Expired */ | |
2009-07-27 16:03:53 +02:00
( reply - > notice > = 5500 & & reply - > notice < 5600 ) /* end of term */ )
return AVERROR ( EPERM ) ;
2009-03-21 21:46:36 +01:00
return 0 ;
2002-07-04 12:41:34 +02:00
}
2011-01-25 01:29:38 +01:00
/**
* Send a command to the RTSP server without waiting for the reply .
*
* @ param s RTSP ( de ) muxer context
* @ param method the method for the request
* @ param url the target url for the request
* @ param headers extra header lines to include in the request
* @ param send_content if non - null , the data to send as request body content
* @ param send_content_length the length of the send_content data , or 0 if
* send_content is null
*
* @ return zero if success , nonzero otherwise
*/
2013-04-20 21:47:15 +02:00
static int rtsp_send_cmd_with_content_async ( AVFormatContext * s ,
const char * method , const char * url ,
const char * headers ,
const unsigned char * send_content ,
int send_content_length )
2009-03-04 01:57:37 +01:00
{
RTSPState * rt = s - > priv_data ;
2020-11-15 03:45:15 +01:00
char buf [ MAX_URL_SIZE ] , * out_buf ;
2010-06-08 14:40:34 +02:00
char base64buf [ AV_BASE64_SIZE ( sizeof ( buf ) ) ] ;
2009-03-04 01:57:37 +01:00
2019-09-19 17:12:33 +02:00
if ( ! rt - > rtsp_hd_out )
2019-12-11 13:13:21 +01:00
return AVERROR ( ENOTCONN ) ;
2019-09-19 17:12:33 +02:00
2010-06-08 14:40:34 +02:00
/* Add in RTSP headers */
out_buf = buf ;
2009-03-04 01:57:37 +01:00
rt - > seq + + ;
2010-03-25 22:46:14 +01:00
snprintf ( buf , sizeof ( buf ) , " %s %s RTSP/1.0 \r \n " , method , url ) ;
if ( headers )
av_strlcat ( buf , headers , sizeof ( buf ) ) ;
2010-03-25 23:04:41 +01:00
av_strlcatf ( buf , sizeof ( buf ) , " CSeq: %d \r \n " , rt - > seq ) ;
2013-07-15 12:32:18 +02:00
av_strlcatf ( buf , sizeof ( buf ) , " User-Agent: %s \r \n " , rt - > user_agent ) ;
2010-03-25 22:46:14 +01:00
if ( rt - > session_id [ 0 ] ! = ' \0 ' & & ( ! headers | |
! strstr ( headers , " \n If-Match: " ) ) ) {
2010-03-25 23:04:41 +01:00
av_strlcatf ( buf , sizeof ( buf ) , " Session: %s \r \n " , rt - > session_id ) ;
2009-03-04 01:57:37 +01:00
}
2010-03-25 22:47:33 +01:00
if ( rt - > auth [ 0 ] ) {
char * str = ff_http_auth_create_response ( & rt - > auth_state ,
rt - > auth , url , method ) ;
if ( str )
av_strlcat ( buf , str , sizeof ( buf ) ) ;
av_free ( str ) ;
}
2010-02-17 20:24:02 +01:00
if ( send_content_length > 0 & & send_content )
av_strlcatf ( buf , sizeof ( buf ) , " Content-Length: %d \r \n " , send_content_length ) ;
2009-03-04 01:57:37 +01:00
av_strlcat ( buf , " \r \n " , sizeof ( buf ) ) ;
2009-05-31 06:32:45 +02:00
2010-06-08 14:40:34 +02:00
/* base64 encode rtsp if tunneling */
if ( rt - > control_transport = = RTSP_MODE_TUNNEL ) {
av_base64_encode ( base64buf , sizeof ( base64buf ) , buf , strlen ( buf ) ) ;
out_buf = base64buf ;
}
2015-03-16 09:57:35 +01:00
av_log ( s , AV_LOG_TRACE , " Sending: \n %s-- \n " , buf ) ;
2009-05-31 06:32:45 +02:00
2011-03-31 16:48:01 +02:00
ffurl_write ( rt - > rtsp_hd_out , out_buf , strlen ( out_buf ) ) ;
2010-06-08 14:40:34 +02:00
if ( send_content_length > 0 & & send_content ) {
if ( rt - > control_transport = = RTSP_MODE_TUNNEL ) {
2015-12-16 18:01:34 +01:00
avpriv_report_missing_feature ( s , " Tunneling of RTSP requests with content data " ) ;
2010-06-08 14:40:34 +02:00
return AVERROR_PATCHWELCOME ;
}
2011-03-31 16:48:01 +02:00
ffurl_write ( rt - > rtsp_hd_out , send_content , send_content_length ) ;
2010-06-08 14:40:34 +02:00
}
2014-10-22 11:40:46 +02:00
rt - > last_cmd_time = av_gettime_relative ( ) ;
2010-06-05 21:45:46 +02:00
return 0 ;
2009-04-15 15:04:34 +02:00
}
2010-06-05 21:45:46 +02:00
int ff_rtsp_send_cmd_async ( AVFormatContext * s , const char * method ,
2010-06-05 21:49:55 +02:00
const char * url , const char * headers )
2010-02-17 20:24:02 +01:00
{
2013-04-20 21:47:15 +02:00
return rtsp_send_cmd_with_content_async ( s , method , url , headers , NULL , 0 ) ;
2010-02-17 20:24:02 +01:00
}
2010-06-05 21:45:46 +02:00
int ff_rtsp_send_cmd ( AVFormatContext * s , const char * method , const char * url ,
2010-06-05 21:49:55 +02:00
const char * headers , RTSPMessageHeader * reply ,
unsigned char * * content_ptr )
2009-04-15 15:04:34 +02:00
{
2010-06-05 21:45:46 +02:00
return ff_rtsp_send_cmd_with_content ( s , method , url , headers , reply ,
2010-06-05 21:49:55 +02:00
content_ptr , NULL , 0 ) ;
2009-03-04 01:57:37 +01:00
}
2010-06-05 21:45:46 +02:00
int ff_rtsp_send_cmd_with_content ( AVFormatContext * s ,
2010-06-05 21:49:55 +02:00
const char * method , const char * url ,
const char * header ,
RTSPMessageHeader * reply ,
unsigned char * * content_ptr ,
const unsigned char * send_content ,
int send_content_length )
2010-02-17 20:24:02 +01:00
{
2010-03-25 22:49:43 +01:00
RTSPState * rt = s - > priv_data ;
HTTPAuthType cur_auth_type ;
2012-03-12 12:59:53 +01:00
int ret , attempts = 0 ;
2010-03-25 22:49:43 +01:00
retry :
cur_auth_type = rt - > auth_state . auth_type ;
2013-04-20 21:47:15 +02:00
if ( ( ret = rtsp_send_cmd_with_content_async ( s , method , url , header ,
send_content ,
send_content_length ) ) )
2010-06-05 21:45:46 +02:00
return ret ;
2010-02-17 20:24:02 +01:00
2011-01-02 11:06:21 +01:00
if ( ( ret = ff_rtsp_read_reply ( s , reply , content_ptr , 0 , method ) ) < 0 )
2010-06-05 21:45:46 +02:00
return ret ;
2012-03-12 12:59:53 +01:00
attempts + + ;
2010-03-25 22:49:43 +01:00
2012-03-12 12:59:53 +01:00
if ( reply - > status_code = = 401 & &
( cur_auth_type = = HTTP_AUTH_NONE | | rt - > auth_state . stale ) & &
rt - > auth_state . auth_type ! = HTTP_AUTH_NONE & & attempts < 2 )
2010-03-25 22:49:43 +01:00
goto retry ;
2010-06-05 21:45:46 +02:00
2010-07-12 12:17:20 +02:00
if ( reply - > status_code > 400 ) {
2010-08-06 12:26:30 +02:00
av_log ( s , AV_LOG_ERROR , " method %s failed: %d%s \n " ,
2010-07-12 12:17:20 +02:00
method ,
2010-08-06 12:26:30 +02:00
reply - > status_code ,
reply - > reason ) ;
2010-07-12 12:17:20 +02:00
av_log ( s , AV_LOG_DEBUG , " %s \n " , rt - > last_reply ) ;
}
2010-06-05 21:45:46 +02:00
return 0 ;
2010-02-17 20:24:02 +01:00
}
2011-01-24 10:49:01 +01:00
int ff_rtsp_make_setup_request ( AVFormatContext * s , const char * host , int port ,
2010-01-07 23:41:14 +01:00
int lower_transport , const char * real_challenge )
2002-07-04 12:41:34 +02:00
{
RTSPState * rt = s - > priv_data ;
2021-07-04 17:40:25 +02:00
int rtx = 0 , j , i , err , interleave = 0 , port_off = 0 ;
2002-07-04 12:41:34 +02:00
RTSPStream * rtsp_st ;
2009-02-21 23:26:44 +01:00
RTSPMessageHeader reply1 , * reply = & reply1 ;
2020-11-15 03:45:15 +01:00
char cmd [ MAX_URL_SIZE ] ;
2008-09-03 06:44:58 +02:00
const char * trans_pref ;
2008-09-30 15:26:20 +02:00
if ( rt - > transport = = RTSP_TRANSPORT_RDT )
2008-09-03 06:44:58 +02:00
trans_pref = " x-pn-tng " ;
2012-08-08 20:37:47 +02:00
else if ( rt - > transport = = RTSP_TRANSPORT_RAW )
trans_pref = " RAW/RAW " ;
2008-09-03 06:44:58 +02:00
else
trans_pref = " RTP/AVP " ;
2005-12-17 19:14:38 +01:00
2009-04-15 15:04:34 +02:00
/* default timeout: 1 minute */
rt - > timeout = 60 ;
2012-01-18 10:46:37 +01:00
/* Choose a random starting offset within the first half of the
* port range , to allow for a number of ports to try even if the offset
* happens to be at the end of the random range . */
2021-07-04 17:40:25 +02:00
if ( rt - > rtp_port_max - rt - > rtp_port_min > = 4 ) {
2021-07-04 17:40:26 +02:00
port_off = av_get_random_seed ( ) % ( ( rt - > rtp_port_max - rt - > rtp_port_min ) / 2 ) ;
/* even random offset */
port_off - = port_off & 0x01 ;
2021-07-04 17:40:25 +02:00
}
2005-05-26 09:47:51 +02:00
2012-01-18 10:46:37 +01:00
for ( j = rt - > rtp_port_min + port_off , i = 0 ; i < rt - > nb_rtsp_streams ; + + i ) {
2020-11-15 03:45:15 +01:00
char transport [ MAX_URL_SIZE ] ;
2002-07-04 12:41:34 +02:00
2011-07-03 16:35:10 +02:00
/*
2009-03-03 17:52:35 +01:00
* WMS serves all UDP data over a single connection , the RTX , which
* isn ' t necessarily the first in the SDP but has to be the first
* to be set up , else the second / third SETUP will fail with a 461.
*/
if ( lower_transport = = RTSP_LOWER_TRANSPORT_UDP & &
rt - > server_type = = RTSP_SERVER_WMS ) {
if ( i = = 0 ) {
/* rtx first */
for ( rtx = 0 ; rtx < rt - > nb_rtsp_streams ; rtx + + ) {
int len = strlen ( rt - > rtsp_streams [ rtx ] - > control_url ) ;
if ( len > = 4 & &
2010-01-07 23:41:14 +01:00
! strcmp ( rt - > rtsp_streams [ rtx ] - > control_url + len - 4 ,
" /rtx " ) )
2009-03-03 17:52:35 +01:00
break ;
}
if ( rtx = = rt - > nb_rtsp_streams )
return - 1 ; /* no RTX found */
rtsp_st = rt - > rtsp_streams [ rtx ] ;
} else
rtsp_st = rt - > rtsp_streams [ i > rtx ? i : i - 1 ] ;
} else
2009-03-03 17:53:04 +01:00
rtsp_st = rt - > rtsp_streams [ i ] ;
2002-07-04 12:41:34 +02:00
/* RTP/UDP */
2008-09-30 15:18:41 +02:00
if ( lower_transport = = RTSP_LOWER_TRANSPORT_UDP ) {
2002-07-24 19:40:26 +02:00
char buf [ 256 ] ;
2009-03-03 17:52:35 +01:00
if ( rt - > server_type = = RTSP_SERVER_WMS & & i > 1 ) {
port = reply - > transports [ 0 ] . client_port_min ;
goto have_port ;
}
2002-07-24 19:40:26 +02:00
/* first try in specified port range */
2021-07-04 17:40:27 +02:00
while ( j + 1 < = rt - > rtp_port_max ) {
2015-03-22 21:16:55 +01:00
AVDictionary * opts = map_to_opts ( rt ) ;
2012-01-18 10:54:16 +01:00
ff_url_join ( buf , sizeof ( buf ) , " rtp " , NULL , host , - 1 ,
" ?localport=%d " , j ) ;
/* we will use two ports per rtp stream (rtp and rtcp) */
j + = 2 ;
2016-01-30 02:17:51 +01:00
err = ffurl_open_whitelist ( & rtsp_st - > rtp_handle , buf , AVIO_FLAG_READ_WRITE ,
2016-04-21 16:55:09 +02:00
& s - > interrupt_callback , & opts , s - > protocol_whitelist , s - > protocol_blacklist , NULL ) ;
2015-03-22 21:16:55 +01:00
av_dict_free ( & opts ) ;
if ( ! err )
2012-01-18 10:54:16 +01:00
goto rtp_opened ;
2002-07-04 12:41:34 +02:00
}
2011-01-09 11:47:53 +01:00
av_log ( s , AV_LOG_ERROR , " Unable to open an input RTP port \n " ) ;
err = AVERROR ( EIO ) ;
goto fail ;
2002-07-24 19:40:26 +02:00
rtp_opened :
2011-10-12 11:37:42 +02:00
port = ff_rtp_get_local_rtp_port ( rtsp_st - > rtp_handle ) ;
2009-03-03 17:52:35 +01:00
have_port :
2020-12-16 21:40:16 +01:00
av_strlcpy ( transport , trans_pref , sizeof ( transport ) ) ;
av_strlcat ( transport ,
rt - > server_type = = RTSP_SERVER_SATIP ? " ; " : " /UDP; " ,
sizeof ( transport ) ) ;
2008-09-30 15:20:23 +02:00
if ( rt - > server_type ! = RTSP_SERVER_REAL )
av_strlcat ( transport , " unicast; " , sizeof ( transport ) ) ;
av_strlcatf ( transport , sizeof ( transport ) ,
" client_port=%d " , port ) ;
2009-03-03 17:52:35 +01:00
if ( rt - > transport = = RTSP_TRANSPORT_RTP & &
! ( rt - > server_type = = RTSP_SERVER_WMS & & i > 0 ) )
2008-09-03 06:44:58 +02:00
av_strlcatf ( transport , sizeof ( transport ) , " -%d " , port + 1 ) ;
2002-07-04 12:41:34 +02:00
}
/* RTP/TCP */
2008-09-30 15:18:41 +02:00
else if ( lower_transport = = RTSP_LOWER_TRANSPORT_TCP ) {
2011-07-03 16:35:10 +02:00
/* For WMS streams, the application streams are only used for
2009-03-03 17:48:56 +01:00
* UDP . When trying to set it up for TCP streams , the server
* will return an error . Therefore , we skip those streams . */
if ( rt - > server_type = = RTSP_SERVER_WMS & &
2012-04-06 22:07:12 +02:00
( rtsp_st - > stream_index < 0 | |
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 20:42:52 +02:00
s - > streams [ rtsp_st - > stream_index ] - > codecpar - > codec_type = =
2012-04-06 22:07:12 +02:00
AVMEDIA_TYPE_DATA ) )
2009-03-03 17:48:56 +01:00
continue ;
2008-09-03 06:47:44 +02:00
snprintf ( transport , sizeof ( transport ) - 1 ,
2009-02-01 14:37:45 +01:00
" %s/TCP; " , trans_pref ) ;
2011-03-21 13:19:09 +01:00
if ( rt - > transport ! = RTSP_TRANSPORT_RDT )
2009-02-01 14:37:45 +01:00
av_strlcat ( transport , " unicast; " , sizeof ( transport ) ) ;
av_strlcatf ( transport , sizeof ( transport ) ,
" interleaved=%d-%d " ,
interleave , interleave + 1 ) ;
interleave + = 2 ;
2002-07-04 12:41:34 +02:00
}
2008-09-30 15:18:41 +02:00
else if ( lower_transport = = RTSP_LOWER_TRANSPORT_UDP_MULTICAST ) {
2008-09-03 06:47:44 +02:00
snprintf ( transport , sizeof ( transport ) - 1 ,
2008-09-03 06:44:58 +02:00
" %s/UDP;multicast " , trans_pref ) ;
2002-07-04 12:41:34 +02:00
}
2010-02-20 00:11:59 +01:00
if ( s - > oformat ) {
2012-06-18 15:19:33 +02:00
av_strlcat ( transport , " ;mode=record " , sizeof ( transport ) ) ;
2010-02-20 00:11:59 +01:00
} else if ( rt - > server_type = = RTSP_SERVER_REAL | |
2010-02-22 17:11:38 +01:00
rt - > server_type = = RTSP_SERVER_WMS )
2008-09-03 06:44:58 +02:00
av_strlcat ( transport , " ;mode=play " , sizeof ( transport ) ) ;
2005-12-17 19:14:38 +01:00
snprintf ( cmd , sizeof ( cmd ) ,
2003-07-15 18:57:35 +02:00
" Transport: %s \r \n " ,
2010-03-25 22:46:14 +01:00
transport ) ;
2010-12-27 08:51:09 +01:00
if ( rt - > accept_dynamic_rate )
av_strlcat ( cmd , " x-Dynamic-Rate: 0 \r \n " , sizeof ( cmd ) ) ;
2014-11-29 17:39:41 +01:00
if ( CONFIG_RTPDEC & & i = = 0 & & rt - > server_type = = RTSP_SERVER_REAL ) {
2008-09-03 06:44:58 +02:00
char real_res [ 41 ] , real_csum [ 9 ] ;
ff_rdt_calc_response_and_checksum ( real_res , real_csum ,
real_challenge ) ;
av_strlcatf ( cmd , sizeof ( cmd ) ,
" If-Match: %s \r \n "
" RealChallenge2: %s, sd=%s \r \n " ,
rt - > session_id , real_res , real_csum ) ;
}
2010-03-25 22:46:14 +01:00
ff_rtsp_send_cmd ( s , " SETUP " , rtsp_st - > control_url , cmd , reply , NULL ) ;
2008-03-19 15:05:08 +01:00
if ( reply - > status_code = = 461 /* Unsupported protocol */ & & i = = 0 ) {
err = 1 ;
goto fail ;
2008-03-19 15:08:16 +01:00
} else if ( reply - > status_code ! = RTSP_STATUS_OK | |
reply - > nb_transports ! = 1 ) {
2014-10-17 22:24:03 +02:00
err = ff_rtsp_averror ( reply - > status_code , AVERROR_INVALIDDATA ) ;
2002-07-04 12:41:34 +02:00
goto fail ;
}
2020-12-16 21:40:16 +01:00
if ( rt - > server_type = = RTSP_SERVER_SATIP & & reply - > stream_id [ 0 ] ) {
char proto [ 128 ] , host [ 128 ] , path [ 512 ] , auth [ 128 ] ;
int port ;
av_url_split ( proto , sizeof ( proto ) , auth , sizeof ( auth ) , host , sizeof ( host ) ,
& port , path , sizeof ( path ) , rt - > control_uri ) ;
ff_url_join ( rt - > control_uri , sizeof ( rt - > control_uri ) , proto , NULL , host ,
port , " /stream=%s " , reply - > stream_id ) ;
}
2002-07-04 12:41:34 +02:00
/* XXX: same protocol for all streams is required */
if ( i > 0 ) {
2008-09-30 15:26:20 +02:00
if ( reply - > transports [ 0 ] . lower_transport ! = rt - > lower_transport | |
reply - > transports [ 0 ] . transport ! = rt - > transport ) {
2002-07-04 12:41:34 +02:00
err = AVERROR_INVALIDDATA ;
goto fail ;
}
} else {
2008-09-30 15:18:41 +02:00
rt - > lower_transport = reply - > transports [ 0 ] . lower_transport ;
2008-09-30 15:26:20 +02:00
rt - > transport = reply - > transports [ 0 ] . transport ;
2002-07-04 12:41:34 +02:00
}
2010-12-23 16:05:24 +01:00
/* Fail if the server responded with another lower transport mode
* than what we requested . */
if ( reply - > transports [ 0 ] . lower_transport ! = lower_transport ) {
av_log ( s , AV_LOG_ERROR , " Nonmatching transport in server reply \n " ) ;
err = AVERROR_INVALIDDATA ;
goto fail ;
2002-07-04 12:41:34 +02:00
}
2008-09-30 15:18:41 +02:00
switch ( reply - > transports [ 0 ] . lower_transport ) {
case RTSP_LOWER_TRANSPORT_TCP :
2002-07-04 12:41:34 +02:00
rtsp_st - > interleaved_min = reply - > transports [ 0 ] . interleaved_min ;
rtsp_st - > interleaved_max = reply - > transports [ 0 ] . interleaved_max ;
break ;
2005-12-17 19:14:38 +01:00
2010-01-07 23:41:14 +01:00
case RTSP_LOWER_TRANSPORT_UDP : {
2020-11-15 03:45:15 +01:00
char url [ MAX_URL_SIZE ] , options [ 30 ] = " " ;
2013-08-01 08:51:10 +02:00
const char * peer = host ;
2010-01-07 23:41:14 +01:00
2011-06-24 00:55:00 +02:00
if ( rt - > rtsp_flags & RTSP_FLAG_FILTER_SRC )
2011-01-06 16:22:58 +01:00
av_strlcpy ( options , " ?connect=1 " , sizeof ( options ) ) ;
2010-09-03 21:25:59 +02:00
/* Use source address if specified */
2013-08-01 08:51:10 +02:00
if ( reply - > transports [ 0 ] . source [ 0 ] )
peer = reply - > transports [ 0 ] . source ;
ff_url_join ( url , sizeof ( url ) , " rtp " , NULL , peer ,
reply - > transports [ 0 ] . server_port_min , " %s " , options ) ;
2010-01-07 23:41:14 +01:00
if ( ! ( rt - > server_type = = RTSP_SERVER_WMS & & i > 1 ) & &
2011-10-12 11:37:42 +02:00
ff_rtp_set_remote_url ( rtsp_st - > rtp_handle , url ) < 0 ) {
2010-01-07 23:41:14 +01:00
err = AVERROR_INVALIDDATA ;
goto fail ;
2002-07-04 12:41:34 +02:00
}
break ;
2010-01-07 23:41:14 +01:00
}
case RTSP_LOWER_TRANSPORT_UDP_MULTICAST : {
2020-11-15 03:45:15 +01:00
char url [ MAX_URL_SIZE ] , namebuf [ 50 ] , optbuf [ 20 ] = " " ;
2010-08-25 17:32:29 +02:00
struct sockaddr_storage addr ;
2010-01-07 23:41:14 +01:00
int port , ttl ;
2020-04-19 19:14:41 +02:00
AVDictionary * opts = map_to_opts ( rt ) ;
2010-01-07 23:41:14 +01:00
2010-08-25 17:32:29 +02:00
if ( reply - > transports [ 0 ] . destination . ss_family ) {
addr = reply - > transports [ 0 ] . destination ;
2010-01-07 23:41:14 +01:00
port = reply - > transports [ 0 ] . port_min ;
ttl = reply - > transports [ 0 ] . ttl ;
} else {
2010-08-25 17:32:29 +02:00
addr = rtsp_st - > sdp_ip ;
2010-01-07 23:41:14 +01:00
port = rtsp_st - > sdp_port ;
ttl = rtsp_st - > sdp_ttl ;
}
2012-03-08 14:32:39 +01:00
if ( ttl > 0 )
snprintf ( optbuf , sizeof ( optbuf ) , " ?ttl=%d " , ttl ) ;
2010-08-25 17:32:29 +02:00
getnameinfo ( ( struct sockaddr * ) & addr , sizeof ( addr ) ,
namebuf , sizeof ( namebuf ) , NULL , 0 , NI_NUMERICHOST ) ;
ff_url_join ( url , sizeof ( url ) , " rtp " , NULL , namebuf ,
2012-03-08 14:32:39 +01:00
port , " %s " , optbuf ) ;
2020-04-19 19:14:41 +02:00
err = ffurl_open_whitelist ( & rtsp_st - > rtp_handle , url , AVIO_FLAG_READ_WRITE ,
& s - > interrupt_callback , & opts , s - > protocol_whitelist , s - > protocol_blacklist , NULL ) ;
av_dict_free ( & opts ) ;
if ( err < 0 ) {
2010-01-07 23:41:14 +01:00
err = AVERROR_INVALIDDATA ;
goto fail ;
2002-07-04 12:41:34 +02:00
}
break ;
}
2010-01-07 23:41:14 +01:00
}
2005-05-26 09:47:51 +02:00
2012-07-10 19:25:04 +02:00
if ( ( err = ff_rtsp_open_transport_ctx ( s , rtsp_st ) ) )
2003-10-29 15:25:27 +01:00
goto fail ;
2002-07-04 12:41:34 +02:00
}
2012-04-06 21:35:48 +02:00
if ( rt - > nb_rtsp_streams & & reply - > timeout > 0 )
2009-04-15 15:04:34 +02:00
rt - > timeout = reply - > timeout ;
2008-09-14 15:55:21 +02:00
if ( rt - > server_type = = RTSP_SERVER_REAL )
2008-09-07 03:22:18 +02:00
rt - > need_subscription = 1 ;
2008-03-17 13:16:39 +01:00
return 0 ;
fail :
2013-10-30 18:12:45 +01:00
ff_rtsp_undo_setup ( s , 0 ) ;
2008-03-17 13:16:39 +01:00
return err ;
}
2010-06-05 21:41:43 +02:00
void ff_rtsp_close_connections ( AVFormatContext * s )
{
RTSPState * rt = s - > priv_data ;
2020-04-03 17:03:38 +02:00
if ( rt - > rtsp_hd_out ! = rt - > rtsp_hd )
ffurl_closep ( & rt - > rtsp_hd_out ) ;
rt - > rtsp_hd_out = NULL ;
ffurl_closep ( & rt - > rtsp_hd ) ;
2010-06-05 21:41:43 +02:00
}
2010-02-23 01:35:50 +01:00
int ff_rtsp_connect ( AVFormatContext * s )
2008-03-17 13:16:39 +01:00
{
RTSPState * rt = s - > priv_data ;
2014-10-09 19:35:34 +02:00
char proto [ 128 ] , host [ 1024 ] , path [ 1024 ] ;
2020-11-15 03:45:15 +01:00
char tcpname [ 1024 ] , cmd [ MAX_URL_SIZE ] , auth [ 128 ] ;
2014-10-09 19:35:34 +02:00
const char * lower_rtsp_proto = " tcp " ;
2010-03-09 15:59:40 +01:00
int port , err , tcp_fd ;
2019-01-28 00:53:22 +01:00
RTSPMessageHeader reply1 , * reply = & reply1 ;
2008-09-30 15:18:41 +02:00
int lower_transport_mask = 0 ;
2014-10-09 19:35:34 +02:00
int default_port = RTSP_DEFAULT_PORT ;
2019-03-22 00:58:41 +01:00
int https_tunnel = 0 ;
2011-01-10 11:45:24 +01:00
char real_challenge [ 64 ] = " " ;
2010-03-09 15:59:40 +01:00
struct sockaddr_storage peer ;
socklen_t peer_len = sizeof ( peer ) ;
2010-03-05 23:35:21 +01:00
2012-01-21 22:28:11 +01:00
if ( rt - > rtp_port_max < rt - > rtp_port_min ) {
av_log ( s , AV_LOG_ERROR , " Invalid UDP port range, max port %d less "
" than min port %d \n " , rt - > rtp_port_max ,
rt - > rtp_port_min ) ;
return AVERROR ( EINVAL ) ;
}
2010-03-05 23:35:21 +01:00
if ( ! ff_network_init ( ) )
return AVERROR ( EIO ) ;
2011-06-24 00:49:09 +02:00
2012-03-19 19:37:10 +01:00
if ( s - > max_delay < 0 ) /* Not set by the caller */
2012-03-19 19:40:23 +01:00
s - > max_delay = s - > iformat ? DEFAULT_REORDERING_DELAY : 0 ;
2012-03-19 19:37:10 +01:00
2010-06-08 14:40:34 +02:00
rt - > control_transport = RTSP_MODE_PLAIN ;
2019-03-22 00:58:41 +01:00
if ( rt - > lower_transport_mask & ( ( 1 < < RTSP_LOWER_TRANSPORT_HTTP ) |
( 1 < < RTSP_LOWER_TRANSPORT_HTTPS ) ) ) {
https_tunnel = ! ! ( rt - > lower_transport_mask & ( 1 < < RTSP_LOWER_TRANSPORT_HTTPS ) ) ;
2011-06-24 00:49:09 +02:00
rt - > lower_transport_mask = 1 < < RTSP_LOWER_TRANSPORT_TCP ;
rt - > control_transport = RTSP_MODE_TUNNEL ;
}
/* Only pass through valid flags from here */
rt - > lower_transport_mask & = ( 1 < < RTSP_LOWER_TRANSPORT_NB ) - 1 ;
redirect :
2019-01-28 00:53:22 +01:00
memset ( & reply1 , 0 , sizeof ( reply1 ) ) ;
2008-03-17 13:16:39 +01:00
/* extract hostname and port */
2014-10-09 19:35:34 +02:00
av_url_split ( proto , sizeof ( proto ) , auth , sizeof ( auth ) ,
2017-12-29 23:30:14 +01:00
host , sizeof ( host ) , & port , path , sizeof ( path ) , s - > url ) ;
2014-10-09 19:35:34 +02:00
if ( ! strcmp ( proto , " rtsps " ) ) {
lower_rtsp_proto = " tls " ;
default_port = RTSPS_DEFAULT_PORT ;
rt - > lower_transport_mask = 1 < < RTSP_LOWER_TRANSPORT_TCP ;
2020-12-16 21:40:16 +01:00
} else if ( ! strcmp ( proto , " satip " ) ) {
av_strlcpy ( proto , " rtsp " , sizeof ( proto ) ) ;
rt - > server_type = RTSP_SERVER_SATIP ;
2014-10-09 19:35:34 +02:00
}
2009-09-17 23:47:11 +02:00
if ( * auth ) {
2010-03-25 22:47:33 +01:00
av_strlcpy ( rt - > auth , auth , sizeof ( rt - > auth ) ) ;
2009-09-17 23:47:11 +02:00
}
2008-03-17 13:16:39 +01:00
if ( port < 0 )
2014-10-09 19:35:34 +02:00
port = default_port ;
lower_transport_mask = rt - > lower_transport_mask ;
2008-03-17 13:16:39 +01:00
2008-09-30 15:18:41 +02:00
if ( ! lower_transport_mask )
2009-02-16 17:27:35 +01:00
lower_transport_mask = ( 1 < < RTSP_LOWER_TRANSPORT_NB ) - 1 ;
2008-03-17 13:16:39 +01:00
2010-02-22 16:56:18 +01:00
if ( s - > oformat ) {
2010-03-22 16:07:05 +01:00
/* Only UDP or TCP - UDP multicast isn't supported. */
lower_transport_mask & = ( 1 < < RTSP_LOWER_TRANSPORT_UDP ) |
( 1 < < RTSP_LOWER_TRANSPORT_TCP ) ;
2010-06-08 14:40:34 +02:00
if ( ! lower_transport_mask | | rt - > control_transport = = RTSP_MODE_TUNNEL ) {
2010-02-22 16:56:18 +01:00
av_log ( s , AV_LOG_ERROR , " Unsupported lower transport method, "
2010-03-22 16:07:05 +01:00
" only UDP and TCP are supported for output. \n " ) ;
2010-02-22 16:56:18 +01:00
err = AVERROR ( EINVAL ) ;
goto fail ;
}
}
2017-12-29 23:30:14 +01:00
/* Construct the URI used in request; this is similar to s->url,
2010-03-25 23:21:09 +01:00
* but with authentication credentials removed and RTSP specific options
* stripped out . */
2014-10-09 19:35:34 +02:00
ff_url_join ( rt - > control_uri , sizeof ( rt - > control_uri ) , proto , NULL ,
2010-03-25 23:21:09 +01:00
host , port , " %s " , path ) ;
2010-06-08 14:40:34 +02:00
if ( rt - > control_transport = = RTSP_MODE_TUNNEL ) {
/* set up initial handshake for tunneling */
char httpname [ 1024 ] ;
char sessioncookie [ 17 ] ;
char headers [ 1024 ] ;
2019-04-15 13:46:20 +02:00
AVDictionary * options = NULL ;
av_dict_set_int ( & options , " timeout " , rt - > stimeout , 0 ) ;
2010-06-08 14:40:34 +02:00
2019-03-22 00:58:41 +01:00
ff_url_join ( httpname , sizeof ( httpname ) , https_tunnel ? " https " : " http " , auth , host , port , " %s " , path ) ;
2010-06-08 14:40:34 +02:00
snprintf ( sessioncookie , sizeof ( sessioncookie ) , " %08x%08x " ,
av_get_random_seed ( ) , av_get_random_seed ( ) ) ;
/* GET requests */
2011-11-06 21:50:44 +01:00
if ( ffurl_alloc ( & rt - > rtsp_hd , httpname , AVIO_FLAG_READ ,
& s - > interrupt_callback ) < 0 ) {
2010-06-08 14:40:34 +02:00
err = AVERROR ( EIO ) ;
goto fail ;
}
/* generate GET headers */
snprintf ( headers , sizeof ( headers ) ,
" x-sessioncookie: %s \r \n "
" Accept: application/x-rtsp-tunnelled \r \n "
" Pragma: no-cache \r \n "
" Cache-Control: no-cache \r \n " ,
sessioncookie ) ;
2011-11-07 10:45:57 +01:00
av_opt_set ( rt - > rtsp_hd - > priv_data , " headers " , headers , 0 ) ;
2010-06-08 14:40:34 +02:00
2016-02-03 01:01:34 +01:00
if ( ! rt - > rtsp_hd - > protocol_whitelist & & s - > protocol_whitelist ) {
rt - > rtsp_hd - > protocol_whitelist = av_strdup ( s - > protocol_whitelist ) ;
if ( ! rt - > rtsp_hd - > protocol_whitelist ) {
err = AVERROR ( ENOMEM ) ;
goto fail ;
}
}
2010-06-08 14:40:34 +02:00
/* complete the connection */
2019-04-15 13:46:20 +02:00
if ( ffurl_connect ( rt - > rtsp_hd , & options ) ) {
av_dict_free ( & options ) ;
2010-06-08 14:40:34 +02:00
err = AVERROR ( EIO ) ;
goto fail ;
}
/* POST requests */
2011-11-06 21:50:44 +01:00
if ( ffurl_alloc ( & rt - > rtsp_hd_out , httpname , AVIO_FLAG_WRITE ,
& s - > interrupt_callback ) < 0 ) {
2010-06-08 14:40:34 +02:00
err = AVERROR ( EIO ) ;
goto fail ;
}
/* generate POST headers */
snprintf ( headers , sizeof ( headers ) ,
" x-sessioncookie: %s \r \n "
" Content-Type: application/x-rtsp-tunnelled \r \n "
" Pragma: no-cache \r \n "
" Cache-Control: no-cache \r \n "
" Content-Length: 32767 \r \n "
" Expires: Sun, 9 Jan 1972 00:00:00 GMT \r \n " ,
sessioncookie ) ;
2011-11-07 10:45:57 +01:00
av_opt_set ( rt - > rtsp_hd_out - > priv_data , " headers " , headers , 0 ) ;
http: Change the chunksize AVOption into chunked_post
The chunksize internal variable has two different uses - for
reading, it's the amount of data left of the current chunk
(or -1 if the server doesn't send data in chunked mode), where
it's only an internal state variable. For writing, it's used
to decide whether to enable chunked encoding (by default), by
using the value 0, or disable chunked encoding (value -1).
This, while consistent, doesn't make much sense to expose
as an AVOption. This splits the usage of the internal variable
into two variables, chunksize which is used for reading (as
before), and chunked_post which is the user-settable option,
with the values 0 and 1, where 1 is default.
Signed-off-by: Martin Storsjö <martin@martin.st>
2011-11-10 10:03:35 +01:00
av_opt_set ( rt - > rtsp_hd_out - > priv_data , " chunked_post " , " 0 " , 0 ) ;
2019-03-31 06:35:51 +02:00
av_opt_set ( rt - > rtsp_hd_out - > priv_data , " send_expect_100 " , " 0 " , 0 ) ;
2010-06-08 14:40:34 +02:00
2010-06-21 21:41:02 +02:00
/* Initialize the authentication state for the POST session. The HTTP
* protocol implementation doesn ' t properly handle multi - pass
* authentication for POST requests , since it would require one of
* the following :
* - implementing Expect : 100 - continue , which many HTTP servers
* don ' t support anyway , even less the RTSP servers that do HTTP
* tunneling
* - sending the whole POST data until getting a 401 reply specifying
* what authentication method to use , then resending all that data
* - waiting for potential 401 replies directly after sending the
* POST header ( waiting for some unspecified time )
* Therefore , we copy the full auth state , which works for both basic
* and digest . ( For digest , we would have to synchronize the nonce
* count variable between the two sessions , if we ' d do more requests
* with the original session , though . )
*/
ff_http_init_auth_state ( rt - > rtsp_hd_out , rt - > rtsp_hd ) ;
2010-06-22 16:15:00 +02:00
/* complete the connection */
2019-04-15 13:46:20 +02:00
if ( ffurl_connect ( rt - > rtsp_hd_out , & options ) ) {
av_dict_free ( & options ) ;
2010-06-22 16:15:00 +02:00
err = AVERROR ( EIO ) ;
goto fail ;
}
2019-04-15 13:46:20 +02:00
av_dict_free ( & options ) ;
2010-06-08 14:40:34 +02:00
} else {
2014-10-23 18:55:45 +02:00
int ret ;
2010-06-14 11:09:59 +02:00
/* open the tcp connection */
2014-10-09 19:35:34 +02:00
ff_url_join ( tcpname , sizeof ( tcpname ) , lower_rtsp_proto , NULL ,
2014-10-10 21:18:41 +02:00
host , port ,
2021-05-30 22:24:10 +02:00
" ?timeout=% " PRId64 , rt - > stimeout ) ;
2016-01-30 02:17:51 +01:00
if ( ( ret = ffurl_open_whitelist ( & rt - > rtsp_hd , tcpname , AVIO_FLAG_READ_WRITE ,
2016-04-21 16:55:09 +02:00
& s - > interrupt_callback , NULL , s - > protocol_whitelist , s - > protocol_blacklist , NULL ) ) < 0 ) {
2014-10-23 18:55:45 +02:00
err = ret ;
2010-06-14 10:12:40 +02:00
goto fail ;
}
2010-06-19 23:36:13 +02:00
rt - > rtsp_hd_out = rt - > rtsp_hd ;
2010-06-08 14:40:34 +02:00
}
2008-03-17 13:16:39 +01:00
rt - > seq = 0 ;
2011-03-31 17:51:24 +02:00
tcp_fd = ffurl_get_file_handle ( rt - > rtsp_hd ) ;
2014-12-17 15:19:39 +01:00
if ( tcp_fd < 0 ) {
err = tcp_fd ;
goto fail ;
}
2010-03-09 15:59:40 +01:00
if ( ! getpeername ( tcp_fd , ( struct sockaddr * ) & peer , & peer_len ) ) {
getnameinfo ( ( struct sockaddr * ) & peer , peer_len , host , sizeof ( host ) ,
NULL , 0 , NI_NUMERICHOST ) ;
}
2010-01-07 23:41:14 +01:00
/* request options supported by the server; this also detects server
* type */
2020-12-16 21:40:16 +01:00
if ( rt - > server_type ! = RTSP_SERVER_SATIP )
rt - > server_type = RTSP_SERVER_RTP ;
for ( ; ; ) {
2010-03-25 22:46:14 +01:00
cmd [ 0 ] = 0 ;
2008-09-14 15:55:21 +02:00
if ( rt - > server_type = = RTSP_SERVER_REAL )
2008-08-31 19:32:58 +02:00
av_strlcat ( cmd ,
2011-07-03 16:35:10 +02:00
/*
2008-08-31 19:32:58 +02:00
* The following entries are required for proper
* streaming from a Realmedia server . They are
* interdependent in some way although we currently
* don ' t quite understand how . Values were copied
* from mplayer SVN r23589 .
2011-07-03 16:35:10 +02:00
* ClientChallenge is a 16 - byte ID in hex
* CompanyID is a 16 - byte ID in base64
2008-08-31 19:32:58 +02:00
*/
" ClientChallenge: 9e26d33f2984236010ef6253fb1887f7 \r \n "
" PlayerStarttime: [28/03/2003:22:50:23 00:00] \r \n "
" CompanyID: KnKV4M4I/B2FjJ1TToLycw== \r \n "
" GUID: 00000000-0000-0000-0000-000000000000 \r \n " ,
sizeof ( cmd ) ) ;
2010-03-25 22:46:14 +01:00
ff_rtsp_send_cmd ( s , " OPTIONS " , rt - > control_uri , cmd , reply , NULL ) ;
2008-08-31 19:32:58 +02:00
if ( reply - > status_code ! = RTSP_STATUS_OK ) {
2014-10-17 22:24:03 +02:00
err = ff_rtsp_averror ( reply - > status_code , AVERROR_INVALIDDATA ) ;
2008-08-31 19:32:58 +02:00
goto fail ;
}
/* detect server type if not standard-compliant RTP */
2008-09-14 15:55:21 +02:00
if ( rt - > server_type ! = RTSP_SERVER_REAL & & reply - > real_challenge [ 0 ] ) {
rt - > server_type = RTSP_SERVER_REAL ;
2008-08-31 19:32:58 +02:00
continue ;
2011-11-02 20:17:25 +01:00
} else if ( ! av_strncasecmp ( reply - > server , " WMServer/ " , 9 ) ) {
2009-01-07 15:55:47 +01:00
rt - > server_type = RTSP_SERVER_WMS ;
2010-01-07 23:41:14 +01:00
} else if ( rt - > server_type = = RTSP_SERVER_REAL )
2008-08-31 19:32:58 +02:00
strcpy ( real_challenge , reply - > real_challenge ) ;
break ;
}
2021-01-29 18:53:43 +01:00
# if CONFIG_RTSP_DEMUXER
if ( s - > iformat ) {
2020-12-16 21:40:16 +01:00
if ( rt - > server_type = = RTSP_SERVER_SATIP )
err = init_satip_stream ( s ) ;
else
err = ff_rtsp_setup_input_streams ( s , reply ) ;
2021-01-29 18:53:43 +01:00
} else
# endif
if ( CONFIG_RTSP_MUXER )
2010-10-29 10:41:49 +02:00
err = ff_rtsp_setup_output_streams ( s , host ) ;
2014-10-23 23:48:45 +02:00
else
av_assert0 ( 0 ) ;
2010-02-20 00:21:44 +01:00
if ( err )
2008-03-17 13:16:39 +01:00
goto fail ;
2008-03-19 15:05:08 +01:00
do {
2010-01-07 23:41:14 +01:00
int lower_transport = ff_log2_tab [ lower_transport_mask &
~ ( lower_transport_mask - 1 ) ] ;
2008-03-19 15:05:08 +01:00
2014-03-04 14:43:59 +01:00
if ( ( lower_transport_mask & ( 1 < < RTSP_LOWER_TRANSPORT_TCP ) )
& & ( rt - > rtsp_flags & RTSP_FLAG_PREFER_TCP ) )
lower_transport = RTSP_LOWER_TRANSPORT_TCP ;
2011-01-24 10:49:01 +01:00
err = ff_rtsp_make_setup_request ( s , host , port , lower_transport ,
2008-09-14 15:55:21 +02:00
rt - > server_type = = RTSP_SERVER_REAL ?
2008-09-03 06:44:58 +02:00
real_challenge : NULL ) ;
2008-03-19 15:05:08 +01:00
if ( err < 0 )
2008-03-19 15:08:16 +01:00
goto fail ;
2008-09-30 15:18:41 +02:00
lower_transport_mask & = ~ ( 1 < < lower_transport ) ;
if ( lower_transport_mask = = 0 & & err = = 1 ) {
2011-02-19 19:14:11 +01:00
err = AVERROR ( EPROTONOSUPPORT ) ;
2008-03-19 15:05:08 +01:00
goto fail ;
}
} while ( err ) ;
2008-03-17 13:16:39 +01:00
2011-01-10 11:45:24 +01:00
rt - > lower_transport_mask = lower_transport_mask ;
av_strlcpy ( rt - > real_challenge , real_challenge , sizeof ( rt - > real_challenge ) ) ;
2003-11-10 19:39:26 +01:00
rt - > state = RTSP_STATE_IDLE ;
2010-01-07 23:41:14 +01:00
rt - > seek_timestamp = 0 ; /* default is to start stream at position zero */
2002-07-04 12:41:34 +02:00
return 0 ;
fail :
2010-02-23 01:35:50 +01:00
ff_rtsp_close_streams ( s ) ;
2010-06-05 21:41:43 +02:00
ff_rtsp_close_connections ( s ) ;
2010-02-22 16:57:40 +01:00
if ( reply - > status_code > = 300 & & reply - > status_code < 400 & & s - > iformat ) {
2017-12-29 23:30:14 +01:00
char * new_url = av_strdup ( reply - > location ) ;
if ( ! new_url ) {
err = AVERROR ( ENOMEM ) ;
goto fail2 ;
}
ff_format_set_url ( s , new_url ) ;
2014-09-24 10:31:18 +02:00
rt - > session_id [ 0 ] = ' \0 ' ;
2009-10-25 02:06:31 +02:00
av_log ( s , AV_LOG_INFO , " Status %d: Redirecting to %s \n " ,
reply - > status_code ,
2017-12-29 23:30:14 +01:00
s - > url ) ;
2009-10-25 02:06:31 +02:00
goto redirect ;
}
2017-12-29 23:30:14 +01:00
fail2 :
2010-03-05 23:35:21 +01:00
ff_network_close ( ) ;
2002-07-04 12:41:34 +02:00
return err ;
}
2010-10-05 13:03:48 +02:00
# endif /* CONFIG_RTSP_DEMUXER || CONFIG_RTSP_MUXER */
2002-07-04 12:41:34 +02:00
2010-10-21 14:18:48 +02:00
# if CONFIG_RTPDEC
2017-03-14 17:44:45 +01:00
static int parse_rtsp_message ( AVFormatContext * s )
{
RTSPState * rt = s - > priv_data ;
int ret ;
if ( rt - > rtsp_flags & RTSP_FLAG_LISTEN ) {
if ( rt - > state = = RTSP_STATE_STREAMING ) {
2020-09-27 13:50:27 +02:00
return ff_rtsp_parse_streaming_commands ( s ) ;
2017-03-14 17:44:45 +01:00
} else
2020-09-30 11:27:00 +02:00
return AVERROR_EOF ;
2017-03-14 17:44:45 +01:00
} else {
RTSPMessageHeader reply ;
ret = ff_rtsp_read_reply ( s , & reply , NULL , 0 , NULL ) ;
if ( ret < 0 )
return ret ;
/* XXX: parse message */
if ( rt - > state ! = RTSP_STATE_STREAMING )
return 0 ;
}
return 0 ;
}
2010-01-04 20:55:43 +01:00
static int udp_read_packet ( AVFormatContext * s , RTSPStream * * prtsp_st ,
2010-10-01 19:52:26 +02:00
uint8_t * buf , int buf_size , int64_t wait_end )
2010-01-04 20:55:43 +01:00
{
RTSPState * rt = s - > priv_data ;
RTSPStream * rtsp_st ;
2020-10-10 15:30:21 +02:00
int n , i , ret ;
2011-01-28 03:12:21 +01:00
struct pollfd * p = rt - > p ;
2012-08-17 20:06:27 +02:00
int * fds = NULL , fdsnum , fdsidx ;
2021-05-30 22:24:10 +02:00
int64_t runs = rt - > stimeout / POLLING_TIME / 1000 ;
2010-01-04 20:55:43 +01:00
2017-02-20 02:11:58 +01:00
if ( ! p ) {
2020-11-04 13:09:02 +01:00
p = rt - > p = av_malloc_array ( 2 * rt - > nb_rtsp_streams + 1 , sizeof ( * p ) ) ;
2017-02-20 02:11:58 +01:00
if ( ! p )
return AVERROR ( ENOMEM ) ;
2017-02-20 02:16:28 +01:00
if ( rt - > rtsp_hd ) {
2017-03-14 17:44:45 +01:00
p [ rt - > max_p ] . fd = ffurl_get_file_handle ( rt - > rtsp_hd ) ;
2017-02-20 02:16:28 +01:00
p [ rt - > max_p + + ] . events = POLLIN ;
}
for ( i = 0 ; i < rt - > nb_rtsp_streams ; i + + ) {
rtsp_st = rt - > rtsp_streams [ i ] ;
if ( rtsp_st - > rtp_handle ) {
if ( ret = ffurl_get_multi_file_handle ( rtsp_st - > rtp_handle ,
& fds , & fdsnum ) ) {
av_log ( s , AV_LOG_ERROR , " Unable to recover rtp ports \n " ) ;
return ret ;
}
if ( fdsnum ! = 2 ) {
av_log ( s , AV_LOG_ERROR ,
" Number of fds %d not supported \n " , fdsnum ) ;
return AVERROR_INVALIDDATA ;
}
for ( fdsidx = 0 ; fdsidx < fdsnum ; fdsidx + + ) {
p [ rt - > max_p ] . fd = fds [ fdsidx ] ;
p [ rt - > max_p + + ] . events = POLLIN ;
}
2017-10-04 04:08:06 +02:00
av_freep ( & fds ) ;
2017-02-20 00:50:34 +01:00
}
}
}
2010-01-07 23:41:14 +01:00
for ( ; ; ) {
2011-11-06 21:34:24 +01:00
if ( ff_check_interrupt ( & s - > interrupt_callback ) )
2011-03-13 00:42:27 +01:00
return AVERROR_EXIT ;
2014-10-22 11:40:46 +02:00
if ( wait_end & & wait_end - av_gettime_relative ( ) < 0 )
2010-10-01 19:52:26 +02:00
return AVERROR ( EAGAIN ) ;
2020-10-10 15:50:08 +02:00
n = poll ( p , rt - > max_p , POLLING_TIME ) ;
2010-01-04 20:55:43 +01:00
if ( n > 0 ) {
2017-03-14 17:44:45 +01:00
int j = rt - > rtsp_hd ? 1 : 0 ;
2010-01-07 23:41:14 +01:00
for ( i = 0 ; i < rt - > nb_rtsp_streams ; i + + ) {
2010-01-04 20:55:43 +01:00
rtsp_st = rt - > rtsp_streams [ i ] ;
if ( rtsp_st - > rtp_handle ) {
2011-01-28 03:12:21 +01:00
if ( p [ j ] . revents & POLLIN | | p [ j + 1 ] . revents & POLLIN ) {
2011-03-31 16:31:43 +02:00
ret = ffurl_read ( rtsp_st - > rtp_handle , buf , buf_size ) ;
2010-01-04 20:55:43 +01:00
if ( ret > 0 ) {
* prtsp_st = rtsp_st ;
return ret ;
}
}
2011-01-28 03:12:21 +01:00
j + = 2 ;
2010-01-04 20:55:43 +01:00
}
}
2010-10-05 21:46:25 +02:00
# if CONFIG_RTSP_DEMUXER
2017-03-14 17:44:45 +01:00
if ( rt - > rtsp_hd & & p [ 0 ] . revents & POLLIN ) {
2017-11-29 20:16:02 +01:00
if ( ( ret = parse_rtsp_message ( s ) ) < 0 ) {
return ret ;
}
2010-01-04 20:55:43 +01:00
}
2010-10-05 21:46:25 +02:00
# endif
2021-05-30 22:24:10 +02:00
} else if ( n = = 0 & & rt - > stimeout > 0 & & - - runs < = 0 ) {
2011-02-19 19:14:11 +01:00
return AVERROR ( ETIMEDOUT ) ;
2010-03-29 19:36:08 +02:00
} else if ( n < 0 & & errno ! = EINTR )
return AVERROR ( errno ) ;
2010-01-04 20:55:43 +01:00
}
}
2013-01-01 22:41:29 +01:00
static int pick_stream ( AVFormatContext * s , RTSPStream * * rtsp_st ,
const uint8_t * buf , int len )
{
RTSPState * rt = s - > priv_data ;
int i ;
if ( len < 0 )
return len ;
if ( rt - > nb_rtsp_streams = = 1 ) {
* rtsp_st = rt - > rtsp_streams [ 0 ] ;
return len ;
}
if ( len > = 8 & & rt - > transport = = RTSP_TRANSPORT_RTP ) {
if ( RTP_PT_IS_RTCP ( rt - > recvbuf [ 1 ] ) ) {
int no_ssrc = 0 ;
for ( i = 0 ; i < rt - > nb_rtsp_streams ; i + + ) {
RTPDemuxContext * rtpctx = rt - > rtsp_streams [ i ] - > transport_priv ;
if ( ! rtpctx )
continue ;
if ( rtpctx - > ssrc = = AV_RB32 ( & buf [ 4 ] ) ) {
* rtsp_st = rt - > rtsp_streams [ i ] ;
return len ;
}
if ( ! rtpctx - > ssrc )
no_ssrc = 1 ;
}
if ( no_ssrc ) {
av_log ( s , AV_LOG_WARNING ,
" Unable to pick stream for packet - SSRC not known for "
" all streams \n " ) ;
return AVERROR ( EAGAIN ) ;
}
} else {
for ( i = 0 ; i < rt - > nb_rtsp_streams ; i + + ) {
if ( ( buf [ 1 ] & 0x7f ) = = rt - > rtsp_streams [ i ] - > sdp_payload_type ) {
* rtsp_st = rt - > rtsp_streams [ i ] ;
return len ;
}
}
}
}
av_log ( s , AV_LOG_WARNING , " Unable to pick stream for packet \n " ) ;
return AVERROR ( EAGAIN ) ;
}
2017-02-20 00:04:59 +01:00
static int read_packet ( AVFormatContext * s ,
RTSPStream * * rtsp_st , RTSPStream * first_queue_st ,
int64_t wait_end )
{
RTSPState * rt = s - > priv_data ;
int len ;
switch ( rt - > lower_transport ) {
default :
# if CONFIG_RTSP_DEMUXER
case RTSP_LOWER_TRANSPORT_TCP :
len = ff_rtsp_tcp_read_packet ( s , rtsp_st , rt - > recvbuf , RECVBUF_SIZE ) ;
break ;
# endif
case RTSP_LOWER_TRANSPORT_UDP :
case RTSP_LOWER_TRANSPORT_UDP_MULTICAST :
len = udp_read_packet ( s , rtsp_st , rt - > recvbuf , RECVBUF_SIZE , wait_end ) ;
if ( len > 0 & & ( * rtsp_st ) - > transport_priv & & rt - > transport = = RTSP_TRANSPORT_RTP )
ff_rtp_check_and_send_back_rr ( ( * rtsp_st ) - > transport_priv , ( * rtsp_st ) - > rtp_handle , NULL , len ) ;
break ;
case RTSP_LOWER_TRANSPORT_CUSTOM :
if ( first_queue_st & & rt - > transport = = RTSP_TRANSPORT_RTP & &
wait_end & & wait_end < av_gettime_relative ( ) )
len = AVERROR ( EAGAIN ) ;
else
2017-10-04 02:34:08 +02:00
len = avio_read_partial ( s - > pb , rt - > recvbuf , RECVBUF_SIZE ) ;
2017-02-20 00:04:59 +01:00
len = pick_stream ( s , rtsp_st , rt - > recvbuf , len ) ;
if ( len > 0 & & ( * rtsp_st ) - > transport_priv & & rt - > transport = = RTSP_TRANSPORT_RTP )
ff_rtp_check_and_send_back_rr ( ( * rtsp_st ) - > transport_priv , NULL , s - > pb , len ) ;
break ;
}
if ( len = = 0 )
return AVERROR_EOF ;
return len ;
}
2010-10-29 10:43:57 +02:00
int ff_rtsp_fetch_packet ( AVFormatContext * s , AVPacket * pkt )
2010-01-04 20:55:43 +01:00
{
RTSPState * rt = s - > priv_data ;
int ret , len ;
2010-10-01 19:52:26 +02:00
RTSPStream * rtsp_st , * first_queue_st = NULL ;
int64_t wait_end = 0 ;
2010-01-04 20:55:43 +01:00
2010-08-29 12:25:16 +02:00
if ( rt - > nb_byes = = rt - > nb_rtsp_streams )
return AVERROR_EOF ;
2010-01-04 20:55:43 +01:00
/* get next frames from the same RTP packet */
if ( rt - > cur_transport_priv ) {
2010-01-07 23:41:14 +01:00
if ( rt - > transport = = RTSP_TRANSPORT_RDT ) {
2010-01-04 20:55:43 +01:00
ret = ff_rdt_parse_packet ( rt - > cur_transport_priv , pkt , NULL , 0 ) ;
2012-08-08 22:05:52 +02:00
} else if ( rt - > transport = = RTSP_TRANSPORT_RTP ) {
2011-10-12 11:37:42 +02:00
ret = ff_rtp_parse_packet ( rt - > cur_transport_priv , pkt , NULL , 0 ) ;
2014-11-29 17:39:41 +01:00
} else if ( CONFIG_RTPDEC & & rt - > ts ) {
2014-08-07 01:59:56 +02:00
ret = avpriv_mpegts_parse_packet ( rt - > ts , pkt , rt - > recvbuf + rt - > recvbuf_pos , rt - > recvbuf_len - rt - > recvbuf_pos ) ;
2012-08-08 22:05:52 +02:00
if ( ret > = 0 ) {
rt - > recvbuf_pos + = ret ;
ret = rt - > recvbuf_pos < rt - > recvbuf_len ;
}
2012-09-22 04:47:45 +02:00
} else
2012-10-17 15:46:29 +02:00
ret = - 1 ;
2010-01-04 20:55:43 +01:00
if ( ret = = 0 ) {
rt - > cur_transport_priv = NULL ;
return 0 ;
} else if ( ret = = 1 ) {
return 0 ;
2010-01-07 23:41:14 +01:00
} else
2010-01-04 20:55:43 +01:00
rt - > cur_transport_priv = NULL ;
}
2013-01-07 17:39:04 +01:00
redo :
2010-10-01 19:52:26 +02:00
if ( rt - > transport = = RTSP_TRANSPORT_RTP ) {
int i ;
int64_t first_queue_time = 0 ;
for ( i = 0 ; i < rt - > nb_rtsp_streams ; i + + ) {
RTPDemuxContext * rtpctx = rt - > rtsp_streams [ i ] - > transport_priv ;
2010-12-27 10:56:19 +01:00
int64_t queue_time ;
if ( ! rtpctx )
continue ;
queue_time = ff_rtp_queued_packet_time ( rtpctx ) ;
2010-10-01 19:52:26 +02:00
if ( queue_time & & ( queue_time - first_queue_time < 0 | |
! first_queue_time ) ) {
first_queue_time = queue_time ;
first_queue_st = rt - > rtsp_streams [ i ] ;
}
}
2013-01-07 17:39:04 +01:00
if ( first_queue_time ) {
2010-10-01 19:52:26 +02:00
wait_end = first_queue_time + s - > max_delay ;
2013-01-07 17:39:04 +01:00
} else {
wait_end = 0 ;
first_queue_st = NULL ;
}
2010-10-01 19:52:26 +02:00
}
2010-01-04 20:55:43 +01:00
/* read next RTP packet */
2010-10-01 19:41:31 +02:00
if ( ! rt - > recvbuf ) {
rt - > recvbuf = av_malloc ( RECVBUF_SIZE ) ;
if ( ! rt - > recvbuf )
return AVERROR ( ENOMEM ) ;
}
2017-02-20 00:04:59 +01:00
len = read_packet ( s , & rtsp_st , first_queue_st , wait_end ) ;
2010-10-01 19:52:26 +02:00
if ( len = = AVERROR ( EAGAIN ) & & first_queue_st & &
rt - > transport = = RTSP_TRANSPORT_RTP ) {
2015-09-15 17:38:23 +02:00
av_log ( s , AV_LOG_WARNING ,
" max delay reached. need to consume packet \n " ) ;
2010-10-01 19:52:26 +02:00
rtsp_st = first_queue_st ;
2011-10-12 11:37:42 +02:00
ret = ff_rtp_parse_packet ( rtsp_st - > transport_priv , pkt , NULL , 0 ) ;
2010-10-01 19:52:26 +02:00
goto end ;
}
2010-01-04 20:55:43 +01:00
if ( len < 0 )
return len ;
2017-02-20 00:04:59 +01:00
2010-01-07 23:41:14 +01:00
if ( rt - > transport = = RTSP_TRANSPORT_RDT ) {
2010-10-01 19:43:27 +02:00
ret = ff_rdt_parse_packet ( rtsp_st - > transport_priv , pkt , & rt - > recvbuf , len ) ;
2012-08-08 20:37:47 +02:00
} else if ( rt - > transport = = RTSP_TRANSPORT_RTP ) {
2011-10-12 11:37:42 +02:00
ret = ff_rtp_parse_packet ( rtsp_st - > transport_priv , pkt , & rt - > recvbuf , len ) ;
2012-12-11 14:59:24 +01:00
if ( rtsp_st - > feedback ) {
AVIOContext * pb = NULL ;
if ( rt - > lower_transport = = RTSP_LOWER_TRANSPORT_CUSTOM )
pb = s - > pb ;
ff_rtp_send_rtcp_feedback ( rtsp_st - > transport_priv , rtsp_st - > rtp_handle , pb ) ;
}
2010-04-20 09:34:28 +02:00
if ( ret < 0 ) {
/* Either bad packet, or a RTCP packet. Check if the
* first_rtcp_ntp_time field was initialized . */
RTPDemuxContext * rtpctx = rtsp_st - > transport_priv ;
if ( rtpctx - > first_rtcp_ntp_time ! = AV_NOPTS_VALUE ) {
/* first_rtcp_ntp_time has been initialized for this stream,
* copy the same value to all other uninitialized streams ,
* in order to map their timestamp origin to the same ntp time
* as this one . */
int i ;
2011-01-01 23:27:16 +01:00
AVStream * st = NULL ;
if ( rtsp_st - > stream_index > = 0 )
st = s - > streams [ rtsp_st - > stream_index ] ;
2010-04-20 09:34:28 +02:00
for ( i = 0 ; i < rt - > nb_rtsp_streams ; i + + ) {
2010-09-03 09:10:21 +02:00
RTPDemuxContext * rtpctx2 = rt - > rtsp_streams [ i ] - > transport_priv ;
2011-01-01 23:27:16 +01:00
AVStream * st2 = NULL ;
if ( rt - > rtsp_streams [ i ] - > stream_index > = 0 )
st2 = s - > streams [ rt - > rtsp_streams [ i ] - > stream_index ] ;
if ( rtpctx2 & & st & & st2 & &
rtpctx2 - > first_rtcp_ntp_time = = AV_NOPTS_VALUE ) {
2010-04-20 09:34:28 +02:00
rtpctx2 - > first_rtcp_ntp_time = rtpctx - > first_rtcp_ntp_time ;
2011-01-01 23:27:16 +01:00
rtpctx2 - > rtcp_ts_offset = av_rescale_q (
rtpctx - > rtcp_ts_offset , st - > time_base ,
st2 - > time_base ) ;
}
2010-04-20 09:34:28 +02:00
}
2014-03-12 00:58:34 +01:00
// Make real NTP start time available in AVFormatContext
if ( s - > start_time_realtime = = AV_NOPTS_VALUE ) {
s - > start_time_realtime = av_rescale ( rtpctx - > first_rtcp_ntp_time - ( NTP_OFFSET < < 32 ) , 1000000 , 1LL < < 32 ) ;
if ( rtpctx - > st ) {
s - > start_time_realtime - =
2020-10-30 13:37:51 +01:00
av_rescale_q ( rtpctx - > rtcp_ts_offset , rtpctx - > st - > time_base , AV_TIME_BASE_Q ) ;
2014-03-12 00:58:34 +01:00
}
}
2010-04-20 09:34:28 +02:00
}
2010-08-29 12:25:16 +02:00
if ( ret = = - RTCP_BYE ) {
rt - > nb_byes + + ;
av_log ( s , AV_LOG_DEBUG , " Received BYE for stream %d (%d/%d) \n " ,
rtsp_st - > stream_index , rt - > nb_byes , rt - > nb_rtsp_streams ) ;
if ( rt - > nb_byes = = rt - > nb_rtsp_streams )
return AVERROR_EOF ;
}
2010-04-20 09:34:28 +02:00
}
2014-11-29 17:39:41 +01:00
} else if ( CONFIG_RTPDEC & & rt - > ts ) {
2014-08-07 01:59:56 +02:00
ret = avpriv_mpegts_parse_packet ( rt - > ts , pkt , rt - > recvbuf , len ) ;
2012-08-08 22:05:52 +02:00
if ( ret > = 0 ) {
if ( ret < len ) {
rt - > recvbuf_len = len ;
rt - > recvbuf_pos = ret ;
rt - > cur_transport_priv = rt - > ts ;
return 1 ;
} else {
ret = 0 ;
}
}
2012-08-08 20:37:47 +02:00
} else {
return AVERROR_INVALIDDATA ;
2010-04-20 09:34:28 +02:00
}
2010-10-01 19:52:26 +02:00
end :
2010-01-04 20:55:43 +01:00
if ( ret < 0 )
goto redo ;
2010-01-07 23:41:14 +01:00
if ( ret = = 1 )
2010-01-04 20:55:43 +01:00
/* more packets may follow, so we save the RTP context */
rt - > cur_transport_priv = rtsp_st - > transport_priv ;
return ret ;
}
2010-10-21 14:18:48 +02:00
# endif /* CONFIG_RTPDEC */
2010-01-04 20:55:43 +01:00
2010-10-21 14:18:48 +02:00
# if CONFIG_SDP_DEMUXER
2019-03-21 01:18:37 +01:00
static int sdp_probe ( const AVProbeData * p1 )
2002-11-18 18:24:39 +01:00
{
2005-03-16 20:06:34 +01:00
const char * p = p1 - > buf , * p_end = p1 - > buf + p1 - > buf_size ;
2002-11-20 15:54:13 +01:00
2010-08-25 17:32:00 +02:00
/* we look for a line beginning "c=IN IP" */
2005-03-16 20:06:34 +01:00
while ( p < p_end & & * p ! = ' \0 ' ) {
2015-03-16 22:40:36 +01:00
if ( sizeof ( " c=IN IP " ) - 1 < p_end - p & &
2010-08-25 17:32:00 +02:00
av_strstart ( p , " c=IN IP " , NULL ) )
2013-03-25 16:12:51 +01:00
return AVPROBE_SCORE_EXTENSION ;
2005-03-16 20:06:34 +01:00
2010-01-07 23:41:14 +01:00
while ( p < p_end - 1 & & * p ! = ' \n ' ) p + + ;
2005-03-16 20:06:34 +01:00
if ( + + p > = p_end )
2002-11-20 15:54:13 +01:00
break ;
if ( * p = = ' \r ' )
p + + ;
}
2002-11-18 18:24:39 +01:00
return 0 ;
}
2013-07-26 12:38:00 +02:00
static void append_source_addrs ( char * buf , int size , const char * name ,
int count , struct RTSPSource * * addrs )
{
int i ;
if ( ! count )
return ;
av_strlcatf ( buf , size , " &%s=%s " , name , addrs [ 0 ] - > addr ) ;
for ( i = 1 ; i < count ; i + + )
av_strlcatf ( buf , size , " ,%s " , addrs [ i ] - > addr ) ;
}
2012-01-12 13:20:36 +01:00
static int sdp_read_header ( AVFormatContext * s )
2002-11-18 18:24:39 +01:00
{
2003-10-29 15:25:27 +01:00
RTSPState * rt = s - > priv_data ;
2002-11-18 18:24:39 +01:00
RTSPStream * rtsp_st ;
int size , i , err ;
char * content ;
2020-11-15 03:45:15 +01:00
char url [ MAX_URL_SIZE ] ;
2002-11-18 18:24:39 +01:00
2010-03-05 23:35:21 +01:00
if ( ! ff_network_init ( ) )
return AVERROR ( EIO ) ;
2012-03-19 19:37:10 +01:00
if ( s - > max_delay < 0 ) /* Not set by the caller */
2012-03-19 19:40:23 +01:00
s - > max_delay = DEFAULT_REORDERING_DELAY ;
2013-01-01 22:41:29 +01:00
if ( rt - > rtsp_flags & RTSP_FLAG_CUSTOM_IO )
rt - > lower_transport = RTSP_LOWER_TRANSPORT_CUSTOM ;
2012-03-19 19:37:10 +01:00
2002-11-18 18:24:39 +01:00
/* read the whole sdp file */
/* XXX: better loading */
content = av_malloc ( SDP_MAX_SIZE ) ;
2020-10-12 22:36:09 +02:00
if ( ! content ) {
ff_network_close ( ) ;
2015-04-04 12:51:40 +02:00
return AVERROR ( ENOMEM ) ;
2020-10-12 22:36:09 +02:00
}
2011-02-21 16:43:01 +01:00
size = avio_read ( s - > pb , content , SDP_MAX_SIZE - 1 ) ;
2002-11-18 18:24:39 +01:00
if ( size < = 0 ) {
av_free ( content ) ;
2020-10-12 22:36:09 +02:00
ff_network_close ( ) ;
2002-11-18 18:24:39 +01:00
return AVERROR_INVALIDDATA ;
}
content [ size ] = ' \0 ' ;
2011-01-28 03:12:22 +01:00
err = ff_sdp_parse ( s , content ) ;
2014-12-26 14:59:29 +01:00
av_freep ( & content ) ;
2011-01-28 03:12:22 +01:00
if ( err ) goto fail ;
2002-11-18 18:24:39 +01:00
/* open each RTP stream */
2010-01-07 23:41:14 +01:00
for ( i = 0 ; i < rt - > nb_rtsp_streams ; i + + ) {
2010-08-25 17:32:00 +02:00
char namebuf [ 50 ] ;
2003-10-29 15:25:27 +01:00
rtsp_st = rt - > rtsp_streams [ i ] ;
2005-12-17 19:14:38 +01:00
2013-01-01 22:41:29 +01:00
if ( ! ( rt - > rtsp_flags & RTSP_FLAG_CUSTOM_IO ) ) {
2015-03-22 21:16:55 +01:00
AVDictionary * opts = map_to_opts ( rt ) ;
2015-11-23 23:57:47 +01:00
err = getnameinfo ( ( struct sockaddr * ) & rtsp_st - > sdp_ip ,
sizeof ( rtsp_st - > sdp_ip ) ,
namebuf , sizeof ( namebuf ) , NULL , 0 , NI_NUMERICHOST ) ;
if ( err ) {
av_log ( s , AV_LOG_ERROR , " getnameinfo: %s \n " , gai_strerror ( err ) ) ;
err = AVERROR ( EIO ) ;
2015-12-04 07:11:10 +01:00
av_dict_free ( & opts ) ;
2015-11-23 23:57:47 +01:00
goto fail ;
}
2013-01-01 22:41:29 +01:00
ff_url_join ( url , sizeof ( url ) , " rtp " , NULL ,
namebuf , rtsp_st - > sdp_port ,
2013-08-13 12:21:35 +02:00
" ?localport=%d&ttl=%d&connect=%d&write_to_source=%d " ,
rtsp_st - > sdp_port , rtsp_st - > sdp_ttl ,
rt - > rtsp_flags & RTSP_FLAG_FILTER_SRC ? 1 : 0 ,
rt - > rtsp_flags & RTSP_FLAG_RTCP_TO_SOURCE ? 1 : 0 ) ;
2013-07-26 12:38:00 +02:00
append_source_addrs ( url , sizeof ( url ) , " sources " ,
rtsp_st - > nb_include_source_addrs ,
rtsp_st - > include_source_addrs ) ;
append_source_addrs ( url , sizeof ( url ) , " block " ,
rtsp_st - > nb_exclude_source_addrs ,
rtsp_st - > exclude_source_addrs ) ;
2016-01-07 11:55:50 +01:00
err = ffurl_open_whitelist ( & rtsp_st - > rtp_handle , url , AVIO_FLAG_READ ,
2016-04-21 16:55:09 +02:00
& s - > interrupt_callback , & opts , s - > protocol_whitelist , s - > protocol_blacklist , NULL ) ;
2015-03-22 21:16:55 +01:00
av_dict_free ( & opts ) ;
if ( err < 0 ) {
2013-01-01 22:41:29 +01:00
err = AVERROR_INVALIDDATA ;
goto fail ;
}
2002-11-18 18:24:39 +01:00
}
2012-07-10 19:25:04 +02:00
if ( ( err = ff_rtsp_open_transport_ctx ( s , rtsp_st ) ) )
2003-10-29 15:25:27 +01:00
goto fail ;
2002-11-18 18:24:39 +01:00
}
return 0 ;
2010-01-07 23:41:14 +01:00
fail :
2010-02-23 01:35:50 +01:00
ff_rtsp_close_streams ( s ) ;
2010-03-05 23:35:21 +01:00
ff_network_close ( ) ;
2002-11-18 18:24:39 +01:00
return err ;
}
static int sdp_read_close ( AVFormatContext * s )
{
2010-02-23 01:35:50 +01:00
ff_rtsp_close_streams ( s ) ;
2010-03-05 23:35:21 +01:00
ff_network_close ( ) ;
2002-11-18 18:24:39 +01:00
return 0 ;
}
2011-10-17 19:07:56 +02:00
static const AVClass sdp_demuxer_class = {
. class_name = " SDP demuxer " ,
. item_name = av_default_item_name ,
. option = sdp_options ,
. version = LIBAVUTIL_VERSION_INT ,
} ;
2021-04-19 19:45:24 +02:00
const AVInputFormat ff_sdp_demuxer = {
2011-07-16 22:18:12 +02:00
. name = " sdp " ,
. long_name = NULL_IF_CONFIG_SMALL ( " SDP " ) ,
. priv_data_size = sizeof ( RTSPState ) ,
. read_probe = sdp_probe ,
. read_header = sdp_read_header ,
. read_packet = ff_rtsp_fetch_packet ,
. read_close = sdp_read_close ,
2012-03-19 11:17:47 +01:00
. priv_class = & sdp_demuxer_class ,
2002-11-18 18:24:39 +01:00
} ;
2010-10-21 14:18:48 +02:00
# endif /* CONFIG_SDP_DEMUXER */
2010-10-19 09:38:53 +02:00
2010-10-21 14:18:48 +02:00
# if CONFIG_RTP_DEMUXER
2019-03-21 01:18:37 +01:00
static int rtp_probe ( const AVProbeData * p )
2010-10-19 09:38:53 +02:00
{
if ( av_strstart ( p - > filename , " rtp: " , NULL ) )
return AVPROBE_SCORE_MAX ;
return 0 ;
}
2012-01-12 13:20:36 +01:00
static int rtp_read_header ( AVFormatContext * s )
2010-10-19 09:38:53 +02:00
{
2013-04-05 01:45:52 +02:00
uint8_t recvbuf [ RTP_MAX_PACKET_LENGTH ] ;
2020-04-08 00:38:29 +02:00
char host [ 500 ] , filters_buf [ 1000 ] ;
2020-04-05 11:58:02 +02:00
int ret , port ;
2010-10-19 09:38:53 +02:00
URLContext * in = NULL ;
int payload_type ;
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 20:42:52 +02:00
AVCodecParameters * par = NULL ;
2010-10-19 09:38:53 +02:00
struct sockaddr_storage addr ;
2021-08-04 16:52:07 +02:00
FFIOContext pb ;
2010-10-19 09:38:53 +02:00
socklen_t addrlen = sizeof ( addr ) ;
2011-12-02 10:06:18 +01:00
RTSPState * rt = s - > priv_data ;
2020-04-08 00:38:29 +02:00
const char * p ;
AVBPrint sdp ;
2021-03-09 07:21:19 +01:00
AVDictionary * opts = NULL ;
2010-10-19 09:38:53 +02:00
if ( ! ff_network_init ( ) )
return AVERROR ( EIO ) ;
2021-03-09 07:21:19 +01:00
opts = map_to_opts ( rt ) ;
2017-12-29 23:30:14 +01:00
ret = ffurl_open_whitelist ( & in , s - > url , AVIO_FLAG_READ ,
2021-03-09 07:21:19 +01:00
& s - > interrupt_callback , & opts , s - > protocol_whitelist , s - > protocol_blacklist , NULL ) ;
av_dict_free ( & opts ) ;
2010-10-19 09:38:53 +02:00
if ( ret )
goto fail ;
while ( 1 ) {
2011-03-31 16:31:43 +02:00
ret = ffurl_read ( in , recvbuf , sizeof ( recvbuf ) ) ;
2010-10-19 09:38:53 +02:00
if ( ret = = AVERROR ( EAGAIN ) )
continue ;
if ( ret < 0 )
goto fail ;
if ( ret < 12 ) {
av_log ( s , AV_LOG_WARNING , " Received too short packet \n " ) ;
continue ;
}
if ( ( recvbuf [ 0 ] & 0xc0 ) ! = 0x80 ) {
av_log ( s , AV_LOG_WARNING , " Unsupported RTP version packet "
" received \n " ) ;
continue ;
}
2012-02-16 17:31:03 +01:00
if ( RTP_PT_IS_RTCP ( recvbuf [ 1 ] ) )
2012-02-13 16:05:43 +01:00
continue ;
2010-10-19 09:38:53 +02:00
payload_type = recvbuf [ 1 ] & 0x7f ;
break ;
}
2011-03-31 17:51:24 +02:00
getsockname ( ffurl_get_file_handle ( in ) , ( struct sockaddr * ) & addr , & addrlen ) ;
2020-04-03 17:03:38 +02:00
ffurl_closep ( & in ) ;
2010-10-19 09:38:53 +02:00
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 20:42:52 +02:00
par = avcodec_parameters_alloc ( ) ;
if ( ! par ) {
ret = AVERROR ( ENOMEM ) ;
goto fail ;
}
if ( ff_rtp_get_codec_info ( par , payload_type ) ) {
2010-10-19 09:38:53 +02:00
av_log ( s , AV_LOG_ERROR , " Unable to receive RTP payload type %d "
" without an SDP file describing it \n " ,
payload_type ) ;
2020-10-12 22:36:08 +02:00
ret = AVERROR_INVALIDDATA ;
2010-10-19 09:38:53 +02:00
goto fail ;
}
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 20:42:52 +02:00
if ( par - > codec_type ! = AVMEDIA_TYPE_DATA ) {
2010-10-19 09:38:53 +02:00
av_log ( s , AV_LOG_WARNING , " Guessing on RTP content - if not received "
" properly you need an SDP file "
" describing it \n " ) ;
}
av_url_split ( NULL , 0 , NULL , 0 , host , sizeof ( host ) , & port ,
2017-12-29 23:30:14 +01:00
NULL , 0 , s - > url ) ;
2010-10-19 09:38:53 +02:00
2020-04-08 00:38:29 +02:00
av_bprint_init ( & sdp , 0 , AV_BPRINT_SIZE_UNLIMITED ) ;
av_bprintf ( & sdp , " v=0 \r \n c=IN IP%d %s \r \n " ,
addr . ss_family = = AF_INET ? 4 : 6 , host ) ;
p = strchr ( s - > url , ' ? ' ) ;
if ( p ) {
2020-04-03 15:02:07 +02:00
static const char filters [ ] [ 2 ] [ 8 ] = { { " sources " , " incl " } ,
{ " block " , " excl " } } ;
2020-04-08 00:38:29 +02:00
int i ;
char * q ;
2020-04-03 15:02:07 +02:00
for ( i = 0 ; i < FF_ARRAY_ELEMS ( filters ) ; i + + ) {
2020-04-08 00:38:29 +02:00
if ( av_find_info_tag ( filters_buf , sizeof ( filters_buf ) , filters [ i ] [ 0 ] , p ) ) {
q = filters_buf ;
while ( ( q = strchr ( q , ' , ' ) ) ! = NULL )
* q = ' ' ;
av_bprintf ( & sdp , " a=source-filter:%s IN IP%d %s %s \r \n " ,
filters [ i ] [ 1 ] ,
addr . ss_family = = AF_INET ? 4 : 6 , host ,
filters_buf ) ;
}
}
}
av_bprintf ( & sdp , " m=%s %d RTP/AVP %d \r \n " ,
par - > codec_type = = AVMEDIA_TYPE_DATA ? " application " :
par - > codec_type = = AVMEDIA_TYPE_VIDEO ? " video " : " audio " ,
port , payload_type ) ;
av_log ( s , AV_LOG_VERBOSE , " SDP: \n %s \n " , sdp . str ) ;
if ( ! av_bprint_is_complete ( & sdp ) )
goto fail_nobuf ;
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 20:42:52 +02:00
avcodec_parameters_free ( & par ) ;
2010-10-19 09:38:53 +02:00
2020-04-08 00:38:29 +02:00
ffio_init_context ( & pb , sdp . str , sdp . len , 0 , NULL , NULL , NULL , NULL ) ;
2021-08-04 16:52:07 +02:00
s - > pb = & pb . pub ;
2010-10-19 09:38:53 +02:00
2020-10-12 22:36:09 +02:00
/* if sdp_read_header() fails then following ff_network_close() cancels out */
/* ff_network_init() at the start of this function. Otherwise it cancels out */
/* ff_network_init() inside sdp_read_header() */
2010-10-19 09:38:53 +02:00
ff_network_close ( ) ;
2015-02-08 22:22:40 +01:00
rt - > media_type_mask = ( 1 < < ( AVMEDIA_TYPE_SUBTITLE + 1 ) ) - 1 ;
2011-12-02 10:06:18 +01:00
2012-01-12 13:20:36 +01:00
ret = sdp_read_header ( s ) ;
2010-10-19 09:38:53 +02:00
s - > pb = NULL ;
2020-04-08 00:38:29 +02:00
av_bprint_finalize ( & sdp , NULL ) ;
2010-10-19 09:38:53 +02:00
return ret ;
2020-04-08 00:38:29 +02:00
fail_nobuf :
ret = AVERROR ( ENOMEM ) ;
av_log ( s , AV_LOG_ERROR , " rtp_read_header(): not enough buffer space for sdp-headers \n " ) ;
av_bprint_finalize ( & sdp , NULL ) ;
2020-04-20 03:31:56 +02:00
fail :
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 20:42:52 +02:00
avcodec_parameters_free ( & par ) ;
2020-04-03 17:03:38 +02:00
ffurl_closep ( & in ) ;
2010-10-19 09:38:53 +02:00
ff_network_close ( ) ;
return ret ;
}
2011-10-17 19:07:56 +02:00
static const AVClass rtp_demuxer_class = {
. class_name = " RTP demuxer " ,
. item_name = av_default_item_name ,
. option = rtp_options ,
. version = LIBAVUTIL_VERSION_INT ,
} ;
2021-04-19 19:45:24 +02:00
const AVInputFormat ff_rtp_demuxer = {
2011-07-16 22:18:12 +02:00
. name = " rtp " ,
2012-07-24 23:51:41 +02:00
. long_name = NULL_IF_CONFIG_SMALL ( " RTP input " ) ,
2011-07-16 22:18:12 +02:00
. priv_data_size = sizeof ( RTSPState ) ,
. read_probe = rtp_probe ,
. read_header = rtp_read_header ,
. read_packet = ff_rtsp_fetch_packet ,
. read_close = sdp_read_close ,
2012-03-19 11:17:47 +01:00
. flags = AVFMT_NOFILE ,
. priv_class = & rtp_demuxer_class ,
2010-10-19 09:38:53 +02:00
} ;
2010-10-21 14:18:48 +02:00
# endif /* CONFIG_RTP_DEMUXER */