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#ifndef AVFORMAT_RTPDEC_H 23#define AVFORMAT_RTPDEC_H 24 25#include "libavcodec/avcodec.h" 26#include "avformat.h" 27#include "rtp.h" 28 29/** Structure listing useful vars to parse RTP packet payload*/ 30typedef struct rtp_payload_data 31{ 32 int sizelength; 33 int indexlength; 34 int indexdeltalength; 35 int profile_level_id; 36 int streamtype; 37 int objecttype; 38 char *mode; 39 40 /** mpeg 4 AU headers */ 41 struct AUHeaders { 42 int size; 43 int index; 44 int cts_flag; 45 int cts; 46 int dts_flag; 47 int dts; 48 int rap_flag; 49 int streamstate; 50 } *au_headers; 51 int nb_au_headers; 52 int au_headers_length_bytes; 53 int cur_au_index; 54} RTPPayloadData; 55 56typedef struct PayloadContext PayloadContext; 57typedef struct RTPDynamicProtocolHandler_s RTPDynamicProtocolHandler; 58 59#define RTP_MIN_PACKET_LENGTH 12 60#define RTP_MAX_PACKET_LENGTH 1500 /* XXX: suppress this define */ 61 62typedef struct RTPDemuxContext RTPDemuxContext; 63RTPDemuxContext *rtp_parse_open(AVFormatContext *s1, AVStream *st, URLContext *rtpc, int payload_type, RTPPayloadData *rtp_payload_data); 64void rtp_parse_set_dynamic_protocol(RTPDemuxContext *s, PayloadContext *ctx, 65 RTPDynamicProtocolHandler *handler); 66int rtp_parse_packet(RTPDemuxContext *s, AVPacket *pkt, 67 const uint8_t *buf, int len); 68void rtp_parse_close(RTPDemuxContext *s); 69 70int rtp_get_local_port(URLContext *h); 71int rtp_set_remote_url(URLContext *h, const char *uri); 72void rtp_get_file_handles(URLContext *h, int *prtp_fd, int *prtcp_fd); 73 74/** 75 * some rtp servers assume client is dead if they don't hear from them... 76 * so we send a Receiver Report to the provided ByteIO context 77 * (we don't have access to the rtcp handle from here) 78 */ 79int rtp_check_and_send_back_rr(RTPDemuxContext *s, int count); 80 81// these statistics are used for rtcp receiver reports... 82typedef struct { 83 uint16_t max_seq; ///< highest sequence number seen 84 uint32_t cycles; ///< shifted count of sequence number cycles 85 uint32_t base_seq; ///< base sequence number 86 uint32_t bad_seq; ///< last bad sequence number + 1 87 int probation; ///< sequence packets till source is valid 88 int received; ///< packets received 89 int expected_prior; ///< packets expected in last interval 90 int received_prior; ///< packets received in last interval 91 uint32_t transit; ///< relative transit time for previous packet 92 uint32_t jitter; ///< estimated jitter. 93} RTPStatistics; 94 95#define RTP_FLAG_KEY 0x1 ///< RTP packet contains a keyframe 96#define RTP_FLAG_MARKER 0x2 ///< RTP marker bit was set for this packet 97/** 98 * Packet parsing for "private" payloads in the RTP specs. 99 * 100 * @param ctx RTSP demuxer context 101 * @param s stream context 102 * @param st stream that this packet belongs to 103 * @param pkt packet in which to write the parsed data 104 * @param timestamp pointer in which to write the timestamp of this RTP packet 105 * @param buf pointer to raw RTP packet data 106 * @param len length of buf 107 * @param flags flags from the RTP packet header (RTP_FLAG_*) 108 */ 109typedef int (*DynamicPayloadPacketHandlerProc) (AVFormatContext *ctx, 110 PayloadContext *s, 111 AVStream *st, 112 AVPacket * pkt, 113 uint32_t *timestamp, 114 const uint8_t * buf, 115 int len, int flags); 116 117struct RTPDynamicProtocolHandler_s { 118 // fields from AVRtpDynamicPayloadType_s 119 const char enc_name[50]; /* XXX: still why 50 ? ;-) */ 120 enum CodecType codec_type; 121 enum CodecID codec_id; 122 123 // may be null 124 int (*parse_sdp_a_line) (AVFormatContext *s, 125 int st_index, 126 PayloadContext *priv_data, 127 const char *line); ///< Parse the a= line from the sdp field 128 PayloadContext *(*open) (); ///< allocate any data needed by the rtp parsing for this dynamic data. 129 void (*close)(PayloadContext *protocol_data); ///< free any data needed by the rtp parsing for this dynamic data. 130 DynamicPayloadPacketHandlerProc parse_packet; ///< parse handler for this dynamic packet. 131 132 struct RTPDynamicProtocolHandler_s *next; 133}; 134 135// moved out of rtp.c, because the h264 decoder needs to know about this structure.. 136struct RTPDemuxContext { 137 AVFormatContext *ic; 138 AVStream *st; 139 int payload_type; 140 uint32_t ssrc; 141 uint16_t seq; 142 uint32_t timestamp; 143 uint32_t base_timestamp; 144 uint32_t cur_timestamp; 145 int max_payload_size; 146 struct MpegTSContext *ts; /* only used for MP2T payloads */ 147 int read_buf_index; 148 int read_buf_size; 149 /* used to send back RTCP RR */ 150 URLContext *rtp_ctx; 151 char hostname[256]; 152 153 RTPStatistics statistics; ///< Statistics for this stream (used by RTCP receiver reports) 154 155 /* rtcp sender statistics receive */ 156 int64_t last_rtcp_ntp_time; // TODO: move into statistics 157 int64_t first_rtcp_ntp_time; // TODO: move into statistics 158 uint32_t last_rtcp_timestamp; // TODO: move into statistics 159 160 /* rtcp sender statistics */ 161 unsigned int packet_count; // TODO: move into statistics (outgoing) 162 unsigned int octet_count; // TODO: move into statistics (outgoing) 163 unsigned int last_octet_count; // TODO: move into statistics (outgoing) 164 int first_packet; 165 /* buffer for output */ 166 uint8_t buf[RTP_MAX_PACKET_LENGTH]; 167 uint8_t *buf_ptr; 168 169 /* special infos for au headers parsing */ 170 RTPPayloadData *rtp_payload_data; // TODO: Move into dynamic payload handlers 171 172 /* dynamic payload stuff */ 173 DynamicPayloadPacketHandlerProc parse_packet; ///< This is also copied from the dynamic protocol handler structure 174 PayloadContext *dynamic_protocol_context; ///< This is a copy from the values setup from the sdp parsing, in rtsp.c don't free me. 175 int max_frames_per_packet; 176}; 177 178extern RTPDynamicProtocolHandler *RTPFirstDynamicPayloadHandler; 179void ff_register_dynamic_payload_handler(RTPDynamicProtocolHandler *handler); 180 181int 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. 182 183void av_register_rtp_dynamic_payload_handlers(void); 184 185#endif /* AVFORMAT_RTPDEC_H */ 186