2009-02-06 10:35:52 +00:00
/*
* RTP demuxer definitions
* Copyright ( c ) 2002 Fabrice Bellard
* Copyright ( c ) 2006 Ryan Martell < rdm4 @ martellventures . com >
*
* This file is part of FFmpeg .
*
* FFmpeg is free software ; you can redistribute it and / or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation ; either
* version 2.1 of the License , or ( at your option ) any later version .
*
* FFmpeg is distributed in the hope that it will be useful ,
* 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
* License along with FFmpeg ; if not , write to the Free Software
* Foundation , Inc . , 51 Franklin Street , Fifth Floor , Boston , MA 02110 - 1301 USA
*/
# ifndef AVFORMAT_RTPDEC_H
# define AVFORMAT_RTPDEC_H
# include "libavcodec/avcodec.h"
# include "avformat.h"
# include "rtp.h"
typedef struct PayloadContext PayloadContext ;
typedef struct RTPDynamicProtocolHandler_s RTPDynamicProtocolHandler ;
# define RTP_MIN_PACKET_LENGTH 12
2009-02-06 20:42:21 +00:00
# define RTP_MAX_PACKET_LENGTH 1500 /* XXX: suppress this define */
2009-02-06 10:35:52 +00:00
typedef struct RTPDemuxContext RTPDemuxContext ;
2010-06-25 08:02:50 +00:00
RTPDemuxContext * rtp_parse_open ( AVFormatContext * s1 , AVStream * st , URLContext * rtpc , int payload_type ) ;
2009-02-06 10:35:52 +00:00
void rtp_parse_set_dynamic_protocol ( RTPDemuxContext * s , PayloadContext * ctx ,
RTPDynamicProtocolHandler * handler ) ;
int rtp_parse_packet ( RTPDemuxContext * s , AVPacket * pkt ,
const uint8_t * buf , int len ) ;
void rtp_parse_close ( RTPDemuxContext * s ) ;
2010-04-19 11:40:45 +00:00
# if (LIBAVFORMAT_VERSION_MAJOR <= 53)
2009-02-06 10:35:52 +00:00
int rtp_get_local_port ( URLContext * h ) ;
2010-04-19 11:40:45 +00:00
# endif
int rtp_get_local_rtp_port ( URLContext * h ) ;
int rtp_get_local_rtcp_port ( URLContext * h ) ;
2009-02-06 10:35:52 +00:00
int rtp_set_remote_url ( URLContext * h , const char * uri ) ;
2009-03-03 17:04:51 +00:00
# if (LIBAVFORMAT_VERSION_MAJOR <= 52)
2009-02-06 10:35:52 +00:00
void rtp_get_file_handles ( URLContext * h , int * prtp_fd , int * prtcp_fd ) ;
2009-03-03 17:04:51 +00:00
# endif
2009-02-06 10:35:52 +00:00
2010-02-16 22:50:50 +00:00
/**
* Send a dummy packet on both port pairs to set up the connection
* state in potential NAT routers , so that we ' re able to receive
* packets .
*
* Note , this only works if the NAT router doesn ' t remap ports . This
* isn ' t a standardized procedure , but it works in many cases in practice .
*
* The same routine is used with RDT too , even if RDT doesn ' t use normal
* RTP packets otherwise .
*/
void rtp_send_punch_packets ( URLContext * rtp_handle ) ;
2009-02-06 10:35:52 +00:00
/**
* some rtp servers assume client is dead if they don ' t hear from them . . .
* so we send a Receiver Report to the provided ByteIO context
* ( we don ' t have access to the rtcp handle from here )
*/
int rtp_check_and_send_back_rr ( RTPDemuxContext * s , int count ) ;
// these statistics are used for rtcp receiver reports...
typedef struct {
uint16_t max_seq ; ///< highest sequence number seen
uint32_t cycles ; ///< shifted count of sequence number cycles
uint32_t base_seq ; ///< base sequence number
uint32_t bad_seq ; ///< last bad sequence number + 1
int probation ; ///< sequence packets till source is valid
int received ; ///< packets received
int expected_prior ; ///< packets expected in last interval
int received_prior ; ///< packets received in last interval
uint32_t transit ; ///< relative transit time for previous packet
uint32_t jitter ; ///< estimated jitter.
} RTPStatistics ;
2009-02-26 14:23:05 +00:00
# define RTP_FLAG_KEY 0x1 ///< RTP packet contains a keyframe
2009-02-26 14:24:50 +00:00
# define RTP_FLAG_MARKER 0x2 ///< RTP marker bit was set for this packet
2009-02-06 10:35:52 +00:00
/**
* Packet parsing for " private " payloads in the RTP specs .
*
* @ param ctx RTSP demuxer context
* @ param s stream context
* @ param st stream that this packet belongs to
* @ param pkt packet in which to write the parsed data
* @ param timestamp pointer in which to write the timestamp of this RTP packet
* @ param buf pointer to raw RTP packet data
* @ param len length of buf
2009-02-26 14:23:05 +00:00
* @ param flags flags from the RTP packet header ( RTP_FLAG_ * )
2009-02-06 10:35:52 +00:00
*/
typedef int ( * DynamicPayloadPacketHandlerProc ) ( AVFormatContext * ctx ,
PayloadContext * s ,
AVStream * st ,
AVPacket * pkt ,
uint32_t * timestamp ,
const uint8_t * buf ,
int len , int flags ) ;
struct RTPDynamicProtocolHandler_s {
// fields from AVRtpDynamicPayloadType_s
const char enc_name [ 50 ] ; /* XXX: still why 50 ? ;-) */
2010-03-30 23:30:55 +00:00
enum AVMediaType codec_type ;
2009-02-06 10:35:52 +00:00
enum CodecID codec_id ;
// may be null
int ( * parse_sdp_a_line ) ( AVFormatContext * s ,
int st_index ,
PayloadContext * priv_data ,
const char * line ) ; ///< Parse the a= line from the sdp field
2010-04-05 16:13:51 +00:00
PayloadContext * ( * open ) ( void ) ; ///< allocate any data needed by the rtp parsing for this dynamic data.
2009-02-06 10:35:52 +00:00
void ( * close ) ( PayloadContext * protocol_data ) ; ///< free any data needed by the rtp parsing for this dynamic data.
DynamicPayloadPacketHandlerProc parse_packet ; ///< parse handler for this dynamic packet.
struct RTPDynamicProtocolHandler_s * next ;
} ;
// moved out of rtp.c, because the h264 decoder needs to know about this structure..
struct RTPDemuxContext {
AVFormatContext * ic ;
AVStream * st ;
int payload_type ;
uint32_t ssrc ;
uint16_t seq ;
uint32_t timestamp ;
uint32_t base_timestamp ;
uint32_t cur_timestamp ;
2010-04-20 07:38:52 +00:00
int64_t range_start_offset ;
2009-02-06 10:35:52 +00:00
int max_payload_size ;
struct MpegTSContext * ts ; /* only used for MP2T payloads */
int read_buf_index ;
int read_buf_size ;
/* used to send back RTCP RR */
URLContext * rtp_ctx ;
char hostname [ 256 ] ;
RTPStatistics statistics ; ///< Statistics for this stream (used by RTCP receiver reports)
/* rtcp sender statistics receive */
int64_t last_rtcp_ntp_time ; // TODO: move into statistics
2010-04-20 07:34:28 +00:00
int64_t first_rtcp_ntp_time ; // TODO: move into statistics
2009-02-06 10:35:52 +00:00
uint32_t last_rtcp_timestamp ; // TODO: move into statistics
/* rtcp sender statistics */
unsigned int packet_count ; // TODO: move into statistics (outgoing)
unsigned int octet_count ; // TODO: move into statistics (outgoing)
unsigned int last_octet_count ; // TODO: move into statistics (outgoing)
int first_packet ;
/* buffer for output */
uint8_t buf [ RTP_MAX_PACKET_LENGTH ] ;
uint8_t * buf_ptr ;
/* dynamic payload stuff */
DynamicPayloadPacketHandlerProc parse_packet ; ///< This is also copied from the dynamic protocol handler structure
PayloadContext * dynamic_protocol_context ; ///< This is a copy from the values setup from the sdp parsing, in rtsp.c don't free me.
int max_frames_per_packet ;
} ;
extern RTPDynamicProtocolHandler * RTPFirstDynamicPayloadHandler ;
void ff_register_dynamic_payload_handler ( RTPDynamicProtocolHandler * handler ) ;
2010-02-23 00:35:50 +00:00
int ff_rtsp_next_attr_and_value ( const char * * p , char * attr , int attr_size , char * value , int value_size ) ; ///< from rtsp.c, but used by rtp dynamic protocol handlers.
2009-02-06 10:35:52 +00:00
void av_register_rtp_dynamic_payload_handlers ( void ) ;
# endif /* AVFORMAT_RTPDEC_H */