2009-02-06 10:35:52 +00:00
/*
* RTP demuxer definitions
* Copyright ( c ) 2002 Fabrice Bellard
* Copyright ( c ) 2006 Ryan Martell < rdm4 @ martellventures . com >
*
2011-03-18 17:35:10 +00:00
* This file is part of Libav .
2009-02-06 10:35:52 +00:00
*
2011-03-18 17:35:10 +00:00
* Libav is free software ; you can redistribute it and / or
2009-02-06 10:35:52 +00:00
* 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 .
*
2011-03-18 17:35:10 +00:00
* Libav is distributed in the hope that it will be useful ,
2009-02-06 10:35:52 +00: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
2011-03-18 17:35:10 +00:00
* License along with Libav ; if not , write to the Free Software
2009-02-06 10:35:52 +00:00
* 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"
2011-04-07 18:25:52 +00:00
# include "url.h"
2009-02-06 10:35:52 +00:00
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
2010-10-01 17:50:24 +00:00
# define RTP_REORDER_QUEUE_DEFAULT_SIZE 10
2010-07-14 12:26:16 +00:00
# define RTP_NOTS_VALUE ((uint32_t)-1)
2009-02-06 10:35:52 +00:00
typedef struct RTPDemuxContext RTPDemuxContext ;
2011-10-12 09:37:42 +00:00
RTPDemuxContext * ff_rtp_parse_open ( AVFormatContext * s1 , AVStream * st , URLContext * rtpc , int payload_type , int queue_size ) ;
void ff_rtp_parse_set_dynamic_protocol ( RTPDemuxContext * s , PayloadContext * ctx ,
RTPDynamicProtocolHandler * handler ) ;
int ff_rtp_parse_packet ( RTPDemuxContext * s , AVPacket * pkt ,
uint8_t * * buf , int len ) ;
void ff_rtp_parse_close ( RTPDemuxContext * s ) ;
2010-10-01 17:50:24 +00:00
int64_t ff_rtp_queued_packet_time ( RTPDemuxContext * s ) ;
void ff_rtp_reset_packet_queue ( RTPDemuxContext * s ) ;
2011-10-12 09:37:42 +00:00
int ff_rtp_get_local_rtp_port ( URLContext * h ) ;
int ff_rtp_get_local_rtcp_port ( URLContext * h ) ;
2010-04-19 11:40:45 +00:00
2011-10-12 09:37:42 +00:00
int ff_rtp_set_remote_url ( URLContext * h , const char * uri ) ;
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 .
*/
2011-10-12 09:37:42 +00:00
void ff_rtp_send_punch_packets ( URLContext * rtp_handle ) ;
2010-02-16 22:50:50 +00:00
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 )
*/
2011-10-12 09:37:42 +00:00
int ff_rtp_check_and_send_back_rr ( RTPDemuxContext * s , int count ) ;
2009-02-06 10:35:52 +00:00
2010-08-25 17:32:59 +00:00
/**
* Get the file handle for the RTCP socket .
*/
2011-10-12 09:37:42 +00:00
int ff_rtp_get_rtcp_file_handle ( URLContext * h ) ;
2010-08-25 17:32:59 +00:00
2009-02-06 10:35:52 +00:00
// 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 ;
2012-08-05 09:11:04 +00:00
enum AVCodecID codec_id ;
2010-12-05 19:38:55 +00:00
int static_payload_id ; /* 0 means no payload id is set. 0 is a valid
* payload ID ( PCMU ) , too , but that format doesn ' t
* require any custom depacketization code . */
2009-02-06 10:35:52 +00:00
// may be null
2011-11-29 14:51:26 +00:00
int ( * init ) ( AVFormatContext * s , int st_index , PayloadContext * priv_data ) ; ///< Initialize dynamic protocol handler, called after the full rtpmap line is parsed
2009-02-06 10:35:52 +00:00
int ( * parse_sdp_a_line ) ( AVFormatContext * s ,
int st_index ,
PayloadContext * priv_data ,
const char * line ) ; ///< Parse the a= line from the sdp field
2011-04-20 12:36:37 +00:00
PayloadContext * ( * alloc ) ( void ) ; ///< allocate any data needed by the rtp parsing for this dynamic data.
void ( * free ) ( PayloadContext * protocol_data ) ; ///< free any data needed by the rtp parsing for this dynamic data.
2009-02-06 10:35:52 +00:00
DynamicPayloadPacketHandlerProc parse_packet ; ///< parse handler for this dynamic packet.
struct RTPDynamicProtocolHandler_s * next ;
} ;
2010-10-01 17:50:24 +00:00
typedef struct RTPPacket {
uint16_t seq ;
uint8_t * buf ;
int len ;
int64_t recvtime ;
struct RTPPacket * next ;
} RTPPacket ;
2009-02-06 10:35:52 +00:00
// 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 ;
2011-11-17 15:50:12 +00:00
int64_t unwrapped_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)
2010-10-01 17:50:24 +00:00
/** Fields for packet reordering @{ */
int prev_ret ; ///< The return value of the actual parsing of the previous packet
RTPPacket * queue ; ///< A sorted queue of buffered packets not yet returned
int queue_len ; ///< The number of packets in queue
int queue_size ; ///< The size of queue, or 0 if reordering is disabled
/*@}*/
2009-02-06 10:35:52 +00:00
/* 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
2011-01-01 22:27:16 +00:00
int64_t rtcp_ts_offset ;
2009-02-06 10:35:52 +00:00
/* 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 ;
} ;
void ff_register_dynamic_payload_handler ( RTPDynamicProtocolHandler * handler ) ;
2010-12-05 19:39:50 +00:00
RTPDynamicProtocolHandler * ff_rtp_handler_find_by_name ( const char * name ,
enum AVMediaType codec_type ) ;
RTPDynamicProtocolHandler * ff_rtp_handler_find_by_id ( int id ,
enum AVMediaType codec_type ) ;
2009-02-06 10:35:52 +00:00
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
2010-06-28 11:24:12 +00:00
int ff_parse_fmtp ( AVStream * stream , PayloadContext * data , const char * p ,
int ( * parse_fmtp ) ( AVStream * stream ,
PayloadContext * data ,
char * attr , char * value ) ) ;
2009-02-06 10:35:52 +00:00
void av_register_rtp_dynamic_payload_handlers ( void ) ;
# endif /* AVFORMAT_RTPDEC_H */