/**
* Java RTP Library (jlibrtp)
* Copyright (C) 2006 Arne Kepp
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
package jlibrtp;
import java.net.InetSocketAddress;
import java.util.LinkedList;
import java.util.ListIterator;
/**
* Compound RTCP packet class.
*
* It basically holds a list of packets. This list can either be constructed by
* providing a byte[] of a compound packet, or by adding individual packets.
*
* Upon encode(), the packet will call encode on all the added packets.
*
* problem == 0 indicates the parsing succeeded.
*
*
* @author Arne Kepp
*/
public class CompRtcpPkt {
/** Problem indicator, negative values denote packet type that cause problem */
protected int problem = 0;
/**
* Stores the different subclasses of RtcpPkt that make up the compound
* packet
*/
protected LinkedList<RtcpPkt> rtcpPkts = new LinkedList<RtcpPkt>();
/**
* Instantiates an empty Compound RTCP packet to which you can add RTCP
* packets
*/
protected CompRtcpPkt() {
// Will have to add packets directly to rtcpPkts.
if (RTPSession.rtpDebugLevel > 7) {
System.out.println("<-> CompRtcpPkt()");
}
}
/**
* Add a RTCP packet to the compound packet. Pakcets are added in order, so
* you have to ensure that a Sender Report or Receiver Report is added
* first.
*
* @param aPkt
* the packet to be added
*/
protected void addPacket(RtcpPkt aPkt) {
if (RTPSession.rtpDebugLevel > 11) {
System.out.println(" <-> CompRtcpPkt.addPacket( "
+ aPkt.getClass() + " )");
}
if (aPkt.problem == 0) {
rtcpPkts.add(aPkt);
} else {
this.problem = aPkt.problem;
}
}
/**
* Picks a received Compound RTCP packet apart.
*
* Only SDES packets are processed directly, other packets are parsed and
* put into aComptRtcpPkt.rtcpPkts, but not
*
* Check the aComptRtcpPkt.problem , if the value is non-zero the packets
* should probably be discarded.
*
* @param rawPkt
* the byte array received from the socket
* @param packetSize
* the actual number of used bytes
* @param adr
* the socket address from which the packet was received
* @param rtpSession
* the RTPSession with the participant database
*/
protected void init(byte[] rawPkt, int packetSize, InetSocketAddress adr,
RTPSession rtpSession) {
if (RTPSession.rtcpDebugLevel > 7) {
System.out.println("-> CompRtcpPkt(" + rawPkt.getClass()
+ ", size " + packetSize + ", from " + adr.toString()
+ ", " + rtpSession.getClass() + ")");
}
// System.out.println("rawPkt.length:" + rawPkt.length + " packetSize:"
// + packetSize);
// Chop it up
int start = 0;
while (start < packetSize && problem == 0) {
int length = (StaticProcs.bytesToUIntInt(rawPkt, start + 2)) + 1;
if (length * 4 + start > rawPkt.length) {
System.out.println("!!!! CompRtcpPkt.(rawPkt,..,..) length ("
+ (length * 4 + start)
+ ") exceeds size of raw packet (" + rawPkt.length
+ ") !");
this.problem = -3;
}
int pktType = (int) rawPkt[start + 1];
if (pktType < 0) {
pktType += 256;
}
if (start == 0) {
// Compound packets need to start with SR or RR
if (pktType != 200 && pktType != 201) {
if (RTPSession.rtcpDebugLevel > 3) {
System.out
.println("!!!! CompRtcpPkt(rawPkt...) packet did not start with SR or RR");
}
this.problem = -1;
}
// Padding bit should be zero for the first packet
if (((rawPkt[start] & 0x20) >>> 5) == 1) {
if (RTPSession.rtcpDebugLevel > 3) {
System.out
.println("!!!! CompRtcpPkt(rawPkt...) first packet was padded");
}
this.problem = -2;
}
}
// System.out.println("start: " + start + " pktType: " + pktType +
// " length:" + length );
if (pktType == 200) {
addPacket(new RtcpPktSR(rawPkt, start, length * 4));
} else if (pktType == 201) {
addPacket(new RtcpPktRR(rawPkt, start, -1));
} else if (pktType == 202) {
addPacket(new RtcpPktSDES(rawPkt, start, adr, rtpSession.partDb));
} else if (pktType == 203) {
addPacket(new RtcpPktBYE(rawPkt, start));
} else if (pktType == 204) {
addPacket(new RtcpPktAPP(rawPkt, start));
} else if (pktType == 205) {
addPacket(new RtcpPktRTPFB(rawPkt, start, rtpSession));
} else if (pktType == 206) {
addPacket(new RtcpPktPSFB(rawPkt, start, rtpSession));
} else {
System.out
.println("!!!! CompRtcpPkt(byte[] rawPkt, int packetSize...) "
+ "UNKNOWN RTCP PACKET TYPE:" + pktType);
}
// System.out.println(" start:" + start + " pktType:" + pktType +
// " length:" + length);
start += length * 4;
if (RTPSession.rtcpDebugLevel > 12) {
System.out.println(" start:" + start + " parsing pktType "
+ pktType + " length: " + length);
}
}
if (RTPSession.rtcpDebugLevel > 7) {
System.out.println("<- CompRtcpPkt(rawPkt....)");
}
}
/**
* Encode combines the RTCP packets in this.rtcpPkts into a byte[] by
* calling the encode() function on each of them individually.
*
* The order of rtcpPkts is preserved, so a RR or SR packet must be first.
*
* @return the trimmed byte[] representation of the packet, ready to go into
* a UDP packet.
*/
protected byte[] encode() {
if (RTPSession.rtpDebugLevel > 9) {
System.out.println(" <- CompRtcpPkt.encode()");
}
ListIterator<RtcpPkt> iter = rtcpPkts.listIterator();
byte[] rawPkt = new byte[1500];
int index = 0;
while (iter.hasNext()) {
RtcpPkt aPkt = (RtcpPkt) iter.next();
if (aPkt.packetType == 200) {
RtcpPktSR pkt = (RtcpPktSR) aPkt;
pkt.encode();
System.arraycopy(pkt.rawPkt, 0, rawPkt, index,
pkt.rawPkt.length);
index += pkt.rawPkt.length;
} else if (aPkt.packetType == 201) {
RtcpPktRR pkt = (RtcpPktRR) aPkt;
pkt.encode();
System.arraycopy(pkt.rawPkt, 0, rawPkt, index,
pkt.rawPkt.length);
index += pkt.rawPkt.length;
} else if (aPkt.packetType == 202) {
RtcpPktSDES pkt = (RtcpPktSDES) aPkt;
pkt.encode();
// System.out.println(" ENCODE SIZE: " + pkt.rawPkt.length);
System.arraycopy(pkt.rawPkt, 0, rawPkt, index,
pkt.rawPkt.length);
index += pkt.rawPkt.length;
} else if (aPkt.packetType == 203) {
RtcpPktBYE pkt = (RtcpPktBYE) aPkt;
pkt.encode();
System.arraycopy(pkt.rawPkt, 0, rawPkt, index,
pkt.rawPkt.length);
index += pkt.rawPkt.length;
} else if (aPkt.packetType == 204) {
RtcpPktAPP pkt = (RtcpPktAPP) aPkt;
pkt.encode();
System.arraycopy(pkt.rawPkt, 0, rawPkt, index,
pkt.rawPkt.length);
index += pkt.rawPkt.length;
} else if (aPkt.packetType == 205) {
RtcpPktRTPFB pkt = (RtcpPktRTPFB) aPkt;
pkt.encode();
System.arraycopy(pkt.rawPkt, 0, rawPkt, index,
pkt.rawPkt.length);
index += pkt.rawPkt.length;
} else if (aPkt.packetType == 206) {
RtcpPktPSFB pkt = (RtcpPktPSFB) aPkt;
pkt.encode();
System.arraycopy(pkt.rawPkt, 0, rawPkt, index,
pkt.rawPkt.length);
index += pkt.rawPkt.length;
} else {
System.out.println("CompRtcpPkt aPkt.packetType:"
+ aPkt.packetType);
}
// System.out.println(" packetType:" + aPkt.packetType + " length:"
// + aPkt.rawPkt.length + " index:" + index);
}
byte[] output = new byte[index];
System.arraycopy(rawPkt, 0, output, 0, index);
if (RTPSession.rtpDebugLevel > 9) {
System.out.println(" -> CompRtcpPkt.encode()");
}
return output;
}
}