1 /** |
|
2 * Java RTP Library (jlibrtp) |
|
3 * Copyright (C) 2006 Arne Kepp |
|
4 * |
|
5 * This library is free software; you can redistribute it and/or |
|
6 * modify it under the terms of the GNU Lesser General Public |
|
7 * License as published by the Free Software Foundation; either |
|
8 * version 2.1 of the License, or (at your option) any later version. |
|
9 * |
|
10 * This library is distributed in the hope that it will be useful, |
|
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
|
13 * Lesser General Public License for more details. |
|
14 * |
|
15 * You should have received a copy of the GNU Lesser General Public |
|
16 * License along with this library; if not, write to the Free Software |
|
17 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
|
18 */ |
|
19 package jlibrtp; |
|
20 |
|
21 /** |
|
22 * RtpPkt is the basic class for creating and parsing RTP packets. |
|
23 * |
|
24 * There are two ways of instantiating an RtpPkt. One is for packets that you wish to send, |
|
25 * which requires that you provide basic information about the packet and a payload. Upon calling |
|
26 * encode() the fields of the structure are written into a bytebuffer, in the form that it would |
|
27 * sent across the network, excluding the UDP headers. |
|
28 * |
|
29 * The other way is by passing a bytebuffer. The assumption is that this is a packet |
|
30 * that has been received from the network, excluding UDP headers, and the bytebuffer will |
|
31 * be parsed into the correct fields. |
|
32 * |
|
33 * The class keeps track of changes. Therefore, modifications are possible after calling encode(), |
|
34 * if necessary, the raw version of the packet will be regenerated on subsequent requests. |
|
35 * |
|
36 * @author Arne Kepp |
|
37 */ |
|
38 public class RtpPkt { |
|
39 /** Whether the packet has been changed since encode() */ |
|
40 private boolean rawPktCurrent = false; |
|
41 /** The version, always 2, 2 bits */ |
|
42 private int version = 2; //2 bits |
|
43 /** Whether the packet is padded, 1 bit */ |
|
44 private int padding; //1 bit |
|
45 /** Whether and extension is used, 1 bit */ |
|
46 private int extension = 0; //1 bit |
|
47 /** Whether the packet is marked, 1 bit */ |
|
48 private int marker = 0; //1 bit |
|
49 /** What payload type is used, 7 bits */ |
|
50 private int payloadType; // |
|
51 /** The sequence number, taken from RTP Session, 16 bits */ |
|
52 private int seqNumber; //16 bits |
|
53 /** The RTP timestamp, 32bits */ |
|
54 private long timeStamp; //32 bits |
|
55 /** The SSRC of the packet sender, 32 bits*/ |
|
56 private long ssrc; //32 bits |
|
57 /** SSRCs of contributing sources, 32xn bits, n<16 */ |
|
58 private long[] csrcArray = null;// |
|
59 |
|
60 /** Contains the actual data (eventually) */ |
|
61 private byte[] rawPkt = null; |
|
62 /** The actual data, without any RTP stuff */ |
|
63 private byte[] payload = null; |
|
64 |
|
65 /** |
|
66 * Construct a packet-instance. The ByteBuffer required for UDP transmission can afterwards be obtained from getRawPkt(). If you need to set additional parameters, such as the marker bit or contributing sources, you should do so before calling getRawPkt; |
|
67 * |
|
68 * @param aTimeStamp RTP timestamp for data |
|
69 * @param syncSource the SSRC, usually taken from RTPSession |
|
70 * @param seqNum Sequency number |
|
71 * @param plt Type of payload |
|
72 * @param pl Payload, the actual data |
|
73 */ |
|
74 protected RtpPkt(long aTimeStamp, long syncSource, int seqNum, int plt, byte[] pl){ |
|
75 int test = 0; |
|
76 test += setTimeStamp(aTimeStamp); |
|
77 test += setSsrc(syncSource); |
|
78 test += setSeqNumber(seqNum); |
|
79 test += setPayloadType(plt); |
|
80 test += setPayload(pl); |
|
81 if(test != 0) { |
|
82 System.out.println("RtpPkt() failed, check with checkPkt()"); |
|
83 } |
|
84 rawPktCurrent = true; |
|
85 if( RTPSession.rtpDebugLevel > 5) { |
|
86 System.out.println("<--> RtpPkt(aTimeStamp, syncSource, seqNum, plt, pl)"); |
|
87 } |
|
88 } |
|
89 /** |
|
90 * Construct a packet-instance from an raw packet (believed to be RTP). The UDP-headers must be removed before invoking this method. Call checkPkt on the instance to verify that it was successfully parsed. |
|
91 * |
|
92 * @param aRawPkt The data-part of a UDP-packet believed to be RTP |
|
93 * @param packetSize the number of valid octets in the packet, should be aRawPkt.length |
|
94 */ |
|
95 protected RtpPkt(byte[] aRawPkt, int packetSize){ |
|
96 if( RTPSession.rtpDebugLevel > 5) { |
|
97 System.out.println("-> RtpPkt(aRawPkt)"); |
|
98 } |
|
99 //Check size, need to have at least a complete header |
|
100 if(aRawPkt == null) { |
|
101 System.out.println("RtpPkt(byte[]) Packet null"); |
|
102 } |
|
103 |
|
104 int remOct = packetSize - 12; |
|
105 if(remOct >= 0) { |
|
106 rawPkt = aRawPkt; //Store it |
|
107 //Interrogate the packet |
|
108 sliceFirstLine(); |
|
109 if(version == 2) { |
|
110 sliceTimeStamp(); |
|
111 sliceSSRC(); |
|
112 if(remOct > 4 && getCsrcCount() > 0) { |
|
113 sliceCSRCs(); |
|
114 remOct -= csrcArray.length * 4; //4 octets per CSRC |
|
115 } |
|
116 // TODO Extension |
|
117 if(remOct > 0) { |
|
118 slicePayload(remOct); |
|
119 } |
|
120 |
|
121 //Sanity checks |
|
122 checkPkt(); |
|
123 |
|
124 //Mark the buffer as current |
|
125 rawPktCurrent = true; |
|
126 } else { |
|
127 System.out.println("RtpPkt(byte[]) Packet is not version 2, giving up."); |
|
128 } |
|
129 } else { |
|
130 System.out.println("RtpPkt(byte[]) Packet too small to be sliced"); |
|
131 } |
|
132 rawPktCurrent = true; |
|
133 if( RTPSession.rtpDebugLevel > 5) { |
|
134 System.out.println("<- RtpPkt(aRawPkt)"); |
|
135 } |
|
136 } |
|
137 |
|
138 /********************************************************************************************************* |
|
139 * Reading stuff |
|
140 *********************************************************************************************************/ |
|
141 protected int checkPkt() { |
|
142 //TODO, check for version 2 etc |
|
143 return 0; |
|
144 } |
|
145 protected int getHeaderLength() { |
|
146 //TODO include extension |
|
147 return 12 + 4*getCsrcCount(); |
|
148 } |
|
149 protected int getPayloadLength() { |
|
150 return payload.length; |
|
151 } |
|
152 //public int getPaddingLength() { |
|
153 // return lenPadding; |
|
154 //} |
|
155 protected int getVersion() { |
|
156 return version; |
|
157 } |
|
158 //public boolean isPadded() { |
|
159 // if(lenPadding > 0) { |
|
160 // return true; |
|
161 // }else { |
|
162 // return false; |
|
163 // } |
|
164 //} |
|
165 //public int getHeaderExtension() { |
|
166 //TODO |
|
167 //} |
|
168 protected boolean isMarked() { |
|
169 return (marker != 0); |
|
170 } |
|
171 protected int getPayloadType() { |
|
172 return payloadType; |
|
173 } |
|
174 |
|
175 protected int getSeqNumber() { |
|
176 return seqNumber; |
|
177 } |
|
178 protected long getTimeStamp() { |
|
179 return timeStamp; |
|
180 } |
|
181 protected long getSsrc() { |
|
182 return ssrc; |
|
183 } |
|
184 |
|
185 protected int getCsrcCount() { |
|
186 if(csrcArray != null) { |
|
187 return csrcArray.length; |
|
188 }else{ |
|
189 return 0; |
|
190 } |
|
191 } |
|
192 protected long[] getCsrcArray() { |
|
193 return csrcArray; |
|
194 } |
|
195 |
|
196 /** |
|
197 * Encodes the a |
|
198 */ |
|
199 protected byte[] encode() { |
|
200 if(! rawPktCurrent || rawPkt == null) { |
|
201 writePkt(); |
|
202 } |
|
203 return rawPkt; |
|
204 } |
|
205 |
|
206 /* For debugging purposes */ |
|
207 protected void printPkt() { |
|
208 System.out.print("V:" + version + " P:" + padding + " EXT:" + extension); |
|
209 System.out.println(" CC:" + getCsrcCount() + " M:"+ marker +" PT:" + payloadType + " SN: "+ seqNumber); |
|
210 System.out.println("Timestamp:" + timeStamp + "(long output as int, may be 2s complement)"); |
|
211 System.out.println("SSRC:" + ssrc + "(long output as int, may be 2s complement)"); |
|
212 for(int i=0;i<getCsrcCount();i++) { |
|
213 System.out.println("CSRC:" + csrcArray[i] + "(long output as int, may be 2s complement)"); |
|
214 } |
|
215 //TODO Extension |
|
216 System.out.println("Payload, first four bytes: " + payload[0] + " " + payload[1] + " " + payload[2] + " " + payload[3]); |
|
217 } |
|
218 /********************************************************************************************************* |
|
219 * Setting stuff |
|
220 *********************************************************************************************************/ |
|
221 protected void setMarked(boolean mark) { |
|
222 rawPktCurrent = false; |
|
223 if(mark) { |
|
224 marker = 1; |
|
225 } else { |
|
226 marker = 0; |
|
227 } |
|
228 } |
|
229 //public int setHeaderExtension() { |
|
230 //TODO |
|
231 //} |
|
232 protected int setPayloadType(int plType) { |
|
233 int temp = (plType & 0x0000007F); // 7 bits, checks in RTPSession as well. |
|
234 if(temp == plType) { |
|
235 rawPktCurrent = false; |
|
236 payloadType = temp; |
|
237 return 0; |
|
238 } else { |
|
239 return -1; |
|
240 } |
|
241 } |
|
242 |
|
243 protected int setSeqNumber(int number) { |
|
244 if(number <= 65536 && number >= 0) { |
|
245 rawPktCurrent = false; |
|
246 seqNumber = number; |
|
247 return 0; |
|
248 } else { |
|
249 System.out.println("RtpPkt.setSeqNumber: invalid number"); |
|
250 return -1; |
|
251 } |
|
252 } |
|
253 |
|
254 protected int setTimeStamp(long time) { |
|
255 rawPktCurrent = false; |
|
256 timeStamp = time; |
|
257 return 0; //Naive for now |
|
258 } |
|
259 |
|
260 protected int setSsrc(long source) { |
|
261 rawPktCurrent = false; |
|
262 ssrc = source; |
|
263 return 0; //Naive for now |
|
264 } |
|
265 |
|
266 protected int setCsrcs(long[] contributors) { |
|
267 if(contributors.length <= 16) { |
|
268 csrcArray = contributors; |
|
269 return 0; |
|
270 } else { |
|
271 System.out.println("RtpPkt.setCsrcs: Cannot have more than 16 CSRCs"); |
|
272 return -1; |
|
273 } |
|
274 } |
|
275 |
|
276 protected int setPayload(byte[] data) { |
|
277 // TODO Padding |
|
278 if(data.length < (1500 - 12)) { |
|
279 rawPktCurrent = false; |
|
280 payload = data; |
|
281 return 0; |
|
282 } else { |
|
283 System.out.println("RtpPkt.setPayload: Cannot carry more than 1480 bytes for now."); |
|
284 return -1; |
|
285 } |
|
286 } |
|
287 protected byte[] getPayload() { |
|
288 return payload; |
|
289 } |
|
290 |
|
291 /********************************************************************************************************* |
|
292 * Private functions |
|
293 *********************************************************************************************************/ |
|
294 //Generate a bytebyffer representing the packet, store it. |
|
295 private void writePkt() { |
|
296 int bytes = getPayloadLength(); |
|
297 int headerLen = getHeaderLength(); |
|
298 int csrcLen = getCsrcCount(); |
|
299 rawPkt = new byte[headerLen + bytes]; |
|
300 |
|
301 // The first line contains, version and various bits |
|
302 writeFirstLine(); |
|
303 byte[] someBytes = StaticProcs.uIntLongToByteWord(timeStamp); |
|
304 for(int i=0;i<4;i++) { |
|
305 rawPkt[i + 4] = someBytes[i]; |
|
306 } |
|
307 //System.out.println("writePkt timeStamp:" + rawPkt[7]); |
|
308 |
|
309 someBytes = StaticProcs.uIntLongToByteWord(ssrc); |
|
310 System.arraycopy(someBytes, 0, rawPkt, 8, 4); |
|
311 //System.out.println("writePkt ssrc:" + rawPkt[11]); |
|
312 |
|
313 for(int i=0; i<csrcLen ; i++) { |
|
314 someBytes = StaticProcs.uIntLongToByteWord(csrcArray[i]); |
|
315 System.arraycopy(someBytes, 0, rawPkt, 12 + 4*i, 4); |
|
316 } |
|
317 // TODO Extension |
|
318 |
|
319 //Payload |
|
320 System.arraycopy(payload, 0, rawPkt, headerLen, bytes); |
|
321 rawPktCurrent = true; |
|
322 } |
|
323 //Writes the first 4 octets of the RTP packet |
|
324 private void writeFirstLine() { |
|
325 byte aByte = 0; |
|
326 aByte |=(version << 6); |
|
327 aByte |=(padding << 5); |
|
328 aByte |=(extension << 4); |
|
329 aByte |=(getCsrcCount()); |
|
330 rawPkt[0] = aByte; |
|
331 aByte = 0; |
|
332 aByte |=(marker << 7); |
|
333 aByte |= payloadType; |
|
334 rawPkt[1] = aByte; |
|
335 byte[] someBytes = StaticProcs.uIntIntToByteWord(seqNumber); |
|
336 rawPkt[2] = someBytes[0]; |
|
337 rawPkt[3] = someBytes[1]; |
|
338 } |
|
339 //Picks apart the first 4 octets of an RTP packet |
|
340 private void sliceFirstLine() { |
|
341 version = ((rawPkt[0] & 0xC0) >>> 6); |
|
342 padding = ((rawPkt[0] & 0x20) >>> 5); |
|
343 extension = ((rawPkt[0] & 0x10) >>> 4); |
|
344 csrcArray = new long[(rawPkt[0] & 0x0F)]; |
|
345 marker = ((rawPkt[1] & 0x80) >> 7); |
|
346 payloadType = (rawPkt[1] & 0x7F); |
|
347 seqNumber = StaticProcs.bytesToUIntInt(rawPkt, 2); |
|
348 } |
|
349 //Takes the 4 octets representing the timestamp |
|
350 private void sliceTimeStamp() { |
|
351 timeStamp = StaticProcs.bytesToUIntLong(rawPkt, 4); |
|
352 } |
|
353 //Takes the 4 octets representing the SSRC |
|
354 private void sliceSSRC() { |
|
355 ssrc = StaticProcs.bytesToUIntLong(rawPkt,8); |
|
356 } |
|
357 //Check the length of the csrcArray (set during sliceFirstLine) |
|
358 private void sliceCSRCs() { |
|
359 for(int i=0; i< csrcArray.length; i++) { |
|
360 ssrc = StaticProcs.bytesToUIntLong(rawPkt, i*4 + 12); |
|
361 } |
|
362 } |
|
363 //Extensions //TODO |
|
364 private void slicePayload(int bytes) { |
|
365 payload = new byte[bytes]; |
|
366 int headerLen = getHeaderLength(); |
|
367 |
|
368 System.arraycopy(rawPkt, headerLen, payload, 0, bytes); |
|
369 } |
|
370 } |
|