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