1 /* 2 * RTP demuxer definitions 3 * Copyright (c) 2002 Fabrice Bellard 4 * Copyright (c) 2006 Ryan Martell <rdm4@martellventures.com> 5 * 6 * This file is part of FFmpeg. 7 * 8 * FFmpeg is free software; you can redistribute it and/or 9 * modify it under the terms of the GNU Lesser General Public 10 * License as published by the Free Software Foundation; either 11 * version 2.1 of the License, or (at your option) any later version. 12 * 13 * FFmpeg is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 16 * Lesser General Public License for more details. 17 * 18 * You should have received a copy of the GNU Lesser General Public 19 * License along with FFmpeg; if not, write to the Free Software 20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 21 */ 22 23 #ifndef AVFORMAT_RTPDEC_H 24 #define AVFORMAT_RTPDEC_H 25 26 #include "libavcodec/avcodec.h" 27 #include "avformat.h" 28 #include "rtp.h" 29 #include "url.h" 30 #include "srtp.h" 31 32 typedef struct PayloadContext PayloadContext; 33 typedef struct RTPDynamicProtocolHandler RTPDynamicProtocolHandler; 34 35 #define RTP_MIN_PACKET_LENGTH 12 36 #define RTP_MAX_PACKET_LENGTH 8192 37 38 #define RTP_REORDER_QUEUE_DEFAULT_SIZE 500 39 40 #define RTP_NOTS_VALUE ((uint32_t)-1) 41 42 typedef struct RTPDemuxContext RTPDemuxContext; 43 RTPDemuxContext *ff_rtp_parse_open(AVFormatContext *s1, AVStream *st, 44 int payload_type, int queue_size); 45 void ff_rtp_parse_set_dynamic_protocol(RTPDemuxContext *s, PayloadContext *ctx, 46 const RTPDynamicProtocolHandler *handler); 47 void ff_rtp_parse_set_crypto(RTPDemuxContext *s, const char *suite, 48 const char *params); 49 int ff_rtp_parse_packet(RTPDemuxContext *s, AVPacket *pkt, 50 uint8_t **buf, int len); 51 void ff_rtp_parse_close(RTPDemuxContext *s); 52 int64_t ff_rtp_queued_packet_time(RTPDemuxContext *s); 53 void ff_rtp_reset_packet_queue(RTPDemuxContext *s); 54 55 /** 56 * Send a dummy packet on both port pairs to set up the connection 57 * state in potential NAT routers, so that we're able to receive 58 * packets. 59 * 60 * Note, this only works if the NAT router doesn't remap ports. This 61 * isn't a standardized procedure, but it works in many cases in practice. 62 * 63 * The same routine is used with RDT too, even if RDT doesn't use normal 64 * RTP packets otherwise. 65 */ 66 void ff_rtp_send_punch_packets(URLContext* rtp_handle); 67 68 /** 69 * some rtp servers assume client is dead if they don't hear from them... 70 * so we send a Receiver Report to the provided URLContext or AVIOContext 71 * (we don't have access to the rtcp handle from here) 72 */ 73 int ff_rtp_check_and_send_back_rr(RTPDemuxContext *s, URLContext *fd, 74 AVIOContext *avio, int count); 75 int ff_rtp_send_rtcp_feedback(RTPDemuxContext *s, URLContext *fd, 76 AVIOContext *avio); 77 78 // these statistics are used for rtcp receiver reports... 79 typedef struct RTPStatistics { 80 uint16_t max_seq; ///< highest sequence number seen 81 uint32_t cycles; ///< shifted count of sequence number cycles 82 uint32_t base_seq; ///< base sequence number 83 uint32_t bad_seq; ///< last bad sequence number + 1 84 int probation; ///< sequence packets till source is valid 85 uint32_t received; ///< packets received 86 uint32_t expected_prior; ///< packets expected in last interval 87 uint32_t received_prior; ///< packets received in last interval 88 uint32_t transit; ///< relative transit time for previous packet 89 uint32_t jitter; ///< estimated jitter. 90 } RTPStatistics; 91 92 #define RTP_FLAG_KEY 0x1 ///< RTP packet contains a keyframe 93 #define RTP_FLAG_MARKER 0x2 ///< RTP marker bit was set for this packet 94 /** 95 * Packet parsing for "private" payloads in the RTP specs. 96 * 97 * @param ctx RTSP demuxer context 98 * @param s stream context 99 * @param st stream that this packet belongs to 100 * @param pkt packet in which to write the parsed data 101 * @param timestamp pointer to the RTP timestamp of the input data, can be 102 * updated by the function if returning older, buffered data 103 * @param buf pointer to raw RTP packet data 104 * @param len length of buf 105 * @param seq RTP sequence number of the packet 106 * @param flags flags from the RTP packet header (RTP_FLAG_*) 107 */ 108 typedef int (*DynamicPayloadPacketHandlerProc)(AVFormatContext *ctx, 109 PayloadContext *s, 110 AVStream *st, AVPacket *pkt, 111 uint32_t *timestamp, 112 const uint8_t * buf, 113 int len, uint16_t seq, int flags); 114 115 struct RTPDynamicProtocolHandler { 116 const char *enc_name; 117 enum AVMediaType codec_type; 118 enum AVCodecID codec_id; 119 enum AVStreamParseType need_parsing; 120 int static_payload_id; /* 0 means no payload id is set. 0 is a valid 121 * payload ID (PCMU), too, but that format doesn't 122 * require any custom depacketization code. */ 123 int priv_data_size; 124 125 /** Initialize dynamic protocol handler, called after the full rtpmap line is parsed, may be null */ 126 int (*init)(AVFormatContext *s, int st_index, PayloadContext *priv_data); 127 /** Parse the a= line from the sdp field */ 128 int (*parse_sdp_a_line)(AVFormatContext *s, int st_index, 129 PayloadContext *priv_data, const char *line); 130 /** Free any data needed by the rtp parsing for this dynamic data. 131 * Don't free the protocol_data pointer itself, that is freed by the 132 * caller. This is called even if the init method failed. */ 133 void (*close)(PayloadContext *protocol_data); 134 /** Parse handler for this dynamic packet */ 135 DynamicPayloadPacketHandlerProc parse_packet; 136 int (*need_keyframe)(PayloadContext *context); 137 }; 138 139 typedef struct RTPPacket { 140 uint16_t seq; 141 uint8_t *buf; 142 int len; 143 int64_t recvtime; 144 struct RTPPacket *next; 145 } RTPPacket; 146 147 struct RTPDemuxContext { 148 AVFormatContext *ic; 149 AVStream *st; 150 int payload_type; 151 uint32_t ssrc; 152 uint16_t seq; 153 uint32_t timestamp; 154 uint32_t base_timestamp; 155 int64_t unwrapped_timestamp; 156 int64_t range_start_offset; 157 int max_payload_size; 158 /* used to send back RTCP RR */ 159 char hostname[256]; 160 161 int srtp_enabled; 162 struct SRTPContext srtp; 163 164 /** Statistics for this stream (used by RTCP receiver reports) */ 165 RTPStatistics statistics; 166 167 /** Fields for packet reordering @{ */ 168 int prev_ret; ///< The return value of the actual parsing of the previous packet 169 RTPPacket* queue; ///< A sorted queue of buffered packets not yet returned 170 int queue_len; ///< The number of packets in queue 171 int queue_size; ///< The size of queue, or 0 if reordering is disabled 172 /*@}*/ 173 174 /* rtcp sender statistics receive */ 175 uint64_t last_rtcp_ntp_time; 176 int64_t last_rtcp_reception_time; 177 uint64_t first_rtcp_ntp_time; 178 uint32_t last_rtcp_timestamp; 179 int64_t rtcp_ts_offset; 180 181 /* rtcp sender statistics */ 182 unsigned int packet_count; 183 unsigned int octet_count; 184 unsigned int last_octet_count; 185 int64_t last_feedback_time; 186 187 /* dynamic payload stuff */ 188 const RTPDynamicProtocolHandler *handler; 189 PayloadContext *dynamic_protocol_context; 190 }; 191 192 /** 193 * Iterate over all registered rtp dynamic protocol handlers. 194 * 195 * @param opaque a pointer where libavformat will store the iteration state. Must 196 * point to NULL to start the iteration. 197 * 198 * @return the next registered rtp dynamic protocol handler or NULL when the iteration is 199 * finished 200 */ 201 const RTPDynamicProtocolHandler *ff_rtp_handler_iterate(void **opaque); 202 /** 203 * Find a registered rtp dynamic protocol handler with the specified name. 204 * 205 * @param name name of the requested rtp dynamic protocol handler 206 * @return A rtp dynamic protocol handler if one was found, NULL otherwise. 207 */ 208 const RTPDynamicProtocolHandler *ff_rtp_handler_find_by_name(const char *name, 209 enum AVMediaType codec_type); 210 /** 211 * Find a registered rtp dynamic protocol handler with a matching codec ID. 212 * 213 * @param id AVCodecID of the requested rtp dynamic protocol handler. 214 * @return A rtp dynamic protocol handler if one was found, NULL otherwise. 215 */ 216 const RTPDynamicProtocolHandler *ff_rtp_handler_find_by_id(int id, 217 enum AVMediaType codec_type); 218 219 /* from rtsp.c, but used by rtp dynamic protocol handlers. */ 220 int ff_rtsp_next_attr_and_value(const char **p, char *attr, int attr_size, 221 char *value, int value_size); 222 223 int ff_parse_fmtp(AVFormatContext *s, 224 AVStream *stream, PayloadContext *data, const char *p, 225 int (*parse_fmtp)(AVFormatContext *s, 226 AVStream *stream, 227 PayloadContext *data, 228 const char *attr, const char *value)); 229 230 /** 231 * Close the dynamic buffer and make a packet from it. 232 */ 233 int ff_rtp_finalize_packet(AVPacket *pkt, AVIOContext **dyn_buf, int stream_idx); 234 235 #endif /* AVFORMAT_RTPDEC_H */ 236