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 import java.net.DatagramPacket;

    22 

    23 /**

    24  * RtpPkt is the basic class for creating and parsing RTP packets.

    25  * 

    26  * There are two ways of instantiating an RtpPkt. One is for packets that you

    27  * wish to send, which requires that you provide basic information about the

    28  * packet and a payload. Upon calling encode() the fields of the structure are

    29  * written into a bytebuffer, in the form that it would sent across the network,

    30  * excluding the UDP headers.

    31  * 

    32  * The other way is by passing a bytebuffer. The assumption is that this is a

    33  * packet that has been received from the network, excluding UDP headers, and

    34  * the bytebuffer will be parsed into the correct fields.

    35  * 

    36  * The class keeps track of changes. Therefore, modifications are possible after

    37  * calling encode(), if necessary, the raw version of the packet will be

    38  * regenerated on subsequent requests.

    39  * 

    40  * @author Arne Kepp

    41  */

    42 public class RtpPkt {

    43 	/** Whether the packet has been changed since encode() */

    44 	private boolean rawPktCurrent = false;

    45 	/** The version, always 2, 2 bits */

    46 	private int version = 2; // 2 bits

    47 	/** Whether the packet is padded, 1 bit */

    48 	private int padding; // 1 bit

    49 	/** Whether and extension is used, 1 bit */

    50 	private int extension = 0; // 1 bit

    51 	/** Whether the packet is marked, 1 bit */

    52 	private int marker = 0; // 1 bit

    53 	/** What payload type is used, 7 bits */

    54 	private int payloadType; //

    55 	/** The sequence number, taken from RTP Session, 16 bits */

    56 	private int seqNumber; // 16 bits

    57 	/** The RTP timestamp, 32bits */

    58 	private long timeStamp; // 32 bits

    59 	/** The SSRC of the packet sender, 32 bits */

    60 	private long ssrc; // 32 bits

    61 	/** SSRCs of contributing sources, 32xn bits, n<16 */

    62 	private long[] csrcArray = new long[0];//

    63 

    64 	/** Contains the actual data (eventually) */

    65 	private byte[] rawPkt = null;

    66 	

    67 

    68 

    69 	/** The actual data, without any RTP stuff */

    70 	//private byte[] payload = null;

    71 	private DatagramPacket datagramPacket;

    72 

    73 	/**

    74 	 * Construct a packet-instance. The ByteBuffer required for UDP transmission

    75 	 * can afterwards be obtained from getRawPkt(). If you need to set

    76 	 * additional parameters, such as the marker bit or contributing sources,

    77 	 * you should do so before calling getRawPkt;

    78 	 * 

    79 	 * @param aTimeStamp

    80 	 *            RTP timestamp for data

    81 	 * @param syncSource

    82 	 *            the SSRC, usually taken from RTPSession

    83 	 * @param seqNum

    84 	 *            Sequency number

    85 	 * @param plt

    86 	 *            Type of payload

    87 	 * @param pl

    88 	 *            Payload, the actual data

    89 	 */

    90 	protected void initPacket(long aTimeStamp, long syncSource, int seqNum, int plt,

    91 			byte[] pl) {

    92 		int test = 0;

    93 		test += setTimeStamp(aTimeStamp);

    94 		test += setSsrc(syncSource);

    95 		test += setSeqNumber(seqNum);

    96 		test += setPayloadType(plt);

    97 		//test += setPayload(pl); //TODO: faire d'une manière propre

    98 		datagramPacket = null;

    99 		if (test != 0) {

   100 			System.out.println("RtpPkt() failed, check with checkPkt()");

   101 		}

   102 		rawPktCurrent = true;

   103 		if (RTPSession.rtpDebugLevel > 5) {

   104 			System.out

   105 					.println("<--> RtpPkt(aTimeStamp, syncSource, seqNum, plt, pl)");

   106 		}

   107 	}

   108 

   109 	/**

   110 	 * Construct a packet-instance from an raw packet (believed to be RTP). The

   111 	 * UDP-headers must be removed before invoking this method. Call checkPkt on

   112 	 * the instance to verify that it was successfully parsed.

   113 	 * 

   114 	 * @param aRawPkt

   115 	 *            The data-part of a UDP-packet believed to be RTP

   116 	 * @param packetSize

   117 	 *            the number of valid octets in the packet, should be

   118 	 *            aRawPkt.length

   119 	 */

   120 	public RtpPkt(byte[] aRawPkt, int packetSize, DatagramPacket packet) {

   121 		initPacket(aRawPkt, packetSize, packet);

   122 	}

   123 	

   124 	public RtpPkt() {

   125 	}

   126 	

   127 	public RtpPkt(long aTimeStamp, long syncSource, int seqNum, int plt,

   128 			byte[] pl) {

   129 		initPacket(aTimeStamp, syncSource, seqNum, plt, pl);

   130 	}

   131 	

   132 	protected void initPacket(byte[] aRawPkt, int packetSize, DatagramPacket packet) {

   133 		if (RTPSession.rtpDebugLevel > 5) {

   134 			System.out.println("-> RtpPkt(aRawPkt)");

   135 		}

   136 		// Check size, need to have at least a complete header

   137 		if (aRawPkt == null) {

   138 			System.out.println("RtpPkt(byte[]) Packet null");

   139 		}

   140 

   141 		int remOct = packetSize - 12;

   142 		if (remOct >= 0) {

   143 			rawPkt = aRawPkt; // Store it

   144 			// Interrogate the packet

   145 			datagramPacket = packet;

   146 			sliceFirstLine();

   147 			if (version == 2) {

   148 				sliceTimeStamp();

   149 				sliceSSRC();

   150 				if (remOct > 4 && getCsrcCount() > 0) {

   151 					sliceCSRCs();

   152 					remOct -= csrcArray.length * 4; // 4 octets per CSRC

   153 				}

   154 				// TODO Extension

   155 				/*if (remOct > 0) {

   156 					slicePayload(remOct);

   157 				}*/

   158 

   159 				// Sanity checks

   160 				checkPkt();

   161 

   162 				// Mark the buffer as current

   163 				rawPktCurrent = true;

   164 			} else {

   165 				System.out

   166 						.println("RtpPkt(byte[]) Packet is not version 2, giving up.");

   167 			}

   168 		} else {

   169 			System.out.println("RtpPkt(byte[]) Packet too small to be sliced");

   170 		}

   171 		rawPktCurrent = true;

   172 		if (RTPSession.rtpDebugLevel > 5) {

   173 			System.out.println("<- RtpPkt(aRawPkt)");

   174 		}

   175 	}

   176 

   177 	/*********************************************************************************************************

   178 	 * Reading stuff

   179 	 *********************************************************************************************************/

   180 	protected int checkPkt() {

   181 		// TODO, check for version 2 etc

   182 		return 0;

   183 	}

   184 

   185 	protected int getHeaderLength() {

   186 		// TODO include extension

   187 		return 12 + 4 * getCsrcCount();

   188 	}

   189 

   190 	protected int getPayloadLength() {

   191 		return rawPkt.length - getHeaderLength();

   192 	}

   193 

   194 	// public int getPaddingLength() {

   195 	// return lenPadding;

   196 	// }

   197 	protected int getVersion() {

   198 		return version;

   199 	}

   200 

   201 	// public boolean isPadded() {

   202 	// if(lenPadding > 0) {

   203 	// return true;

   204 	// }else {

   205 	// return false;

   206 	// }

   207 	// }

   208 	// public int getHeaderExtension() {

   209 	// TODO

   210 	// }

   211 	protected boolean isMarked() {

   212 		return (marker != 0);

   213 	}

   214 

   215 	protected int getPayloadType() {

   216 		return payloadType;

   217 	}

   218 

   219 	public int getSeqNumber() {

   220 		return seqNumber;

   221 	}

   222 

   223 	protected long getTimeStamp() {

   224 		return timeStamp;

   225 	}

   226 

   227 	protected long getSsrc() {

   228 		return ssrc;

   229 	}

   230 

   231 	protected int getCsrcCount() {

   232 		if (csrcArray != null) {

   233 			return csrcArray.length;

   234 		} else {

   235 			return 0;

   236 		}

   237 	}

   238 

   239 	protected long[] getCsrcArray() {

   240 		return csrcArray;

   241 	}

   242 

   243 	/**

   244 	 * Encodes the a

   245 	 */

   246 	protected byte[] encode() {

   247 		if (!rawPktCurrent || rawPkt == null) {

   248 			writePkt();

   249 			android.util.Log.d("RtpPkt", "writePkt");

   250 		}

   251 		return rawPkt;

   252 	}

   253 

   254 	/* For debugging purposes */

   255 	protected void printPkt() {

   256 		System.out

   257 				.print("V:" + version + " P:" + padding + " EXT:" + extension);

   258 		System.out.println(" CC:" + getCsrcCount() + " M:" + marker + " PT:"

   259 				+ payloadType + " SN: " + seqNumber);

   260 		System.out.println("Timestamp:" + timeStamp

   261 				+ "(long output as int, may be 2s complement)");

   262 		System.out.println("SSRC:" + ssrc

   263 				+ "(long output as int, may be 2s complement)");

   264 		for (int i = 0; i < getCsrcCount(); i++) {

   265 			System.out.println("CSRC:" + csrcArray[i]

   266 					+ "(long output as int, may be 2s complement)");

   267 		}

   268 

   269 	}

   270 

   271 	/*********************************************************************************************************

   272 	 * Setting stuff

   273 	 *********************************************************************************************************/

   274 	protected void setMarked(boolean mark) {

   275 		rawPktCurrent = false;

   276 		if (mark) {

   277 			marker = 1;

   278 		} else {

   279 			marker = 0;

   280 		}

   281 	}

   282 

   283 	// public int setHeaderExtension() {

   284 	// TODO

   285 	// }

   286 	public int setPayloadType(int plType) {

   287 		int temp = (plType & 0x0000007F); // 7 bits, checks in RTPSession as

   288 											// well.

   289 		if (temp == plType) {

   290 			rawPktCurrent = false;

   291 			payloadType = temp;

   292 			return 0;

   293 		} else {

   294 			return -1;

   295 		}

   296 	}

   297 

   298 	protected int setSeqNumber(int number) {

   299 		if (number <= 65536 && number >= 0) {

   300 			rawPktCurrent = false;

   301 			seqNumber = number;

   302 			return 0;

   303 		} else {

   304 			System.out.println("RtpPkt.setSeqNumber: invalid number");

   305 			return -1;

   306 		}

   307 	}

   308 

   309 	protected int setTimeStamp(long time) {

   310 		rawPktCurrent = false;

   311 		timeStamp = time;

   312 		return 0; // Naive for now

   313 	}

   314 

   315 	protected int setSsrc(long source) {

   316 		rawPktCurrent = false;

   317 		ssrc = source;

   318 		return 0; // Naive for now

   319 	}

   320 

   321 	protected int setCsrcs(long[] contributors) {

   322 		if (contributors.length <= 16) {

   323 			csrcArray = contributors;

   324 			return 0;

   325 		} else {

   326 			System.out

   327 					.println("RtpPkt.setCsrcs: Cannot have more than 16 CSRCs");

   328 			return -1;

   329 		}

   330 	}

   331 

   332 	/*protected int setPayload(byte[] data) {

   333 		// TODO Padding

   334 		if (data.length < (1500 - 12)) {

   335 			rawPktCurrent = false;

   336 			payload = data;

   337 			return 0;

   338 		} else {

   339 			System.out

   340 					.println("RtpPkt.setPayload: Cannot carry more than 1480 bytes for now.");

   341 			return -1;

   342 		}

   343 	}*/

   344 

   345 	public byte[] getPayload() {

   346 		return rawPkt;

   347 	}

   348 

   349 	/*********************************************************************************************************

   350 	 * Private functions

   351 	 *********************************************************************************************************/

   352 	// Generate a bytebyffer representing the packet, store it.

   353 	private void writePkt() {

   354 		int bytes = getPayloadLength();

   355 		int headerLen = getHeaderLength();

   356 		int csrcLen = getCsrcCount();

   357 		rawPkt = new byte[headerLen + bytes];

   358 

   359 		// The first line contains, version and various bits

   360 		writeFirstLine();

   361 		byte[] someBytes = StaticProcs.uIntLongToByteWord(timeStamp);

   362 		for (int i = 0; i < 4; i++) {

   363 			rawPkt[i + 4] = someBytes[i];

   364 		}

   365 		// System.out.println("writePkt timeStamp:" + rawPkt[7]);

   366 

   367 		someBytes = StaticProcs.uIntLongToByteWord(ssrc);

   368 		System.arraycopy(someBytes, 0, rawPkt, 8, 4);

   369 		// System.out.println("writePkt ssrc:" + rawPkt[11]);

   370 

   371 		for (int i = 0; i < csrcLen; i++) {

   372 			someBytes = StaticProcs.uIntLongToByteWord(csrcArray[i]);

   373 			System.arraycopy(someBytes, 0, rawPkt, 12 + 4 * i, 4);

   374 		}

   375 		// TODO Extension

   376 

   377 		// Payload

   378 		//System.arraycopy(payload, 0, rawPkt, headerLen, bytes);

   379 		rawPktCurrent = true;

   380 	}

   381 	

   382 	void writeHeader() {

   383 		//int bytes = rawPkt.length - 12;

   384 		//int headerLen = getHeaderLength();

   385 		int csrcLen = getCsrcCount();

   386 

   387 		// The first line contains, version and various bits

   388 		writeFirstLine();

   389 		StaticProcs.uIntLongToByteWord(timeStamp, rawPkt, 4);

   390 		// System.out.println("writePkt timeStamp:" + rawPkt[7]);

   391 

   392 		StaticProcs.uIntLongToByteWord(ssrc, rawPkt, 8);

   393 		//System.arraycopy(someBytes, 0, rawPkt, 8, 4);

   394 		// System.out.println("writePkt ssrc:" + rawPkt[11]);

   395 

   396 		for (int i = 0; i < csrcLen; i++) {

   397 			StaticProcs.uIntLongToByteWord(csrcArray[i], rawPkt, 12 + 4 * i);

   398 			//System.arraycopy(someBytes, 0, rawPkt, 12 + 4 * i, 4);

   399 		}

   400 		// TODO Extension

   401 

   402 		// Payload

   403 		//System.arraycopy(payload, 0, rawPkt, headerLen, bytes);

   404 		rawPktCurrent = true;

   405 	}

   406 

   407 	// Writes the first 4 octets of the RTP packet

   408 	protected void writeFirstLine() {

   409 		byte aByte = 0;

   410 		aByte |= (version << 6);

   411 		aByte |= (padding << 5);

   412 		aByte |= (extension << 4);

   413 		aByte |= (getCsrcCount());

   414 		rawPkt[0] = aByte;

   415 		aByte = 0;

   416 		aByte |= (marker << 7);

   417 		aByte |= payloadType;

   418 		rawPkt[1] = aByte;

   419 		StaticProcs.uIntIntToByteWord(seqNumber, rawPkt, 2);

   420 	}

   421 

   422 	// Picks apart the first 4 octets of an RTP packet

   423 	private void sliceFirstLine() {

   424 		version = ((rawPkt[0] & 0xC0) >>> 6);

   425 		padding = ((rawPkt[0] & 0x20) >>> 5);

   426 		extension = ((rawPkt[0] & 0x10) >>> 4);

   427 		//csrcArray = new long[(rawPkt[0] & 0x0F)];

   428 		marker = ((rawPkt[1] & 0x80) >> 7);

   429 		payloadType = (rawPkt[1] & 0x7F);

   430 		seqNumber = StaticProcs.bytesToUIntInt(rawPkt, 2);

   431 	}

   432 

   433 	// Takes the 4 octets representing the timestamp

   434 	private void sliceTimeStamp() {

   435 		timeStamp = StaticProcs.bytesToUIntLong(rawPkt, 4);

   436 	}

   437 

   438 	// Takes the 4 octets representing the SSRC

   439 	private void sliceSSRC() {

   440 		ssrc = StaticProcs.bytesToUIntLong(rawPkt, 8);

   441 	}

   442 

   443 	// Check the length of the csrcArray (set during sliceFirstLine)

   444 	private void sliceCSRCs() {

   445 		for (int i = 0; i < csrcArray.length; i++) {

   446 			ssrc = StaticProcs.bytesToUIntLong(rawPkt, i * 4 + 12);

   447 		}

   448 	}

   449 

   450 	// Extensions //TODO

   451 	/*private void slicePayload(int bytes) {

   452 		payload = new byte[bytes];

   453 		int headerLen = getHeaderLength();

   454 

   455 		System.arraycopy(rawPkt, headerLen, payload, 0, bytes);

   456 	}*/

   457 	

   458 	public void setRawPkt(byte[] rawPkt) {

   459 		this.rawPkt = rawPkt;

   460 	}

   461 

   462 	public DatagramPacket getDatagramPacket() {

   463 		return datagramPacket;

   464 	}

   465 }