How can i get more info about the sent data in RTP?

Question

Hello.
I'm working with the examples AVTransmitt2 and AV Receive2 and i want to get more information about the data that it is being sent to de receiver side. In AVTrasmitt2 i only see a calling to processor.start();. How could i know each packet that AvTransmit2 sends to the other side. I want info like the size of the data, the quality, format, etc..

Answer 1

Hi!
As I mentioned above. RTPSocketAdapter has two inner classes, SockOutputStream and SockInputStream.
SockOutputStream have a write method which is called when RTP data is sent over the NET. SockInputStream have a read method which is called when RTP data is received.
If you for instance want to know exactly what is sent you can parse the byte array that comes into write.
Like this:
* An inner class to implement an OutputDataStream based on UDP sockets.
class SockOutputStream implements OutputDataStream {
     DatagramSocket sock;
     InetAddress addr;
     int port;
     boolean isRTCP;
     public SockOutputStream(DatagramSocket sock, InetAddress addr, int port, boolean isRTCP) {
          this.sock = sock;
          this.addr = addr;
          this.port = port;
     public int write(byte data[], int offset, int len) {
          if(isRTCP){
               parseAndPrintRTCPData(data);               
          }else{
               parseAndPrintRTPData(data);
          try {
               sock.send(new DatagramPacket(data, offset, len, addr, port));
          } catch (Exception e) {
               return -1;
          if(debug){
               System.out.println(debugName+": written "+len+" bytes to address:port: "+addr+":"+port);
          return len;
private void parseAndPrintRTPData(byte[] data) {
     // part of header, there still left SSRC and CSRC:s
     byte[] rtpHeader = new byte[8];
     System.arraycopy(data, 0, rtpHeader, 0, rtpHeader.length);
     ByteBuffer buffer = ByteBuffer.wrap(rtpHeader);
     int word = buffer.getInt();
     // version
     int v = word >>> 30;
     System.out.println("version: "+v);
     // padding
     int p = (word & 0x20000000) >>> 29;
     System.out.println("padding: "+p);
     // extension
     int x = (word & 0x10000000) >>> 28;
     System.out.println("extension: "+x);
     // CSRC count
     int cc = (word & 0x0F000000) >>> 24;
     System.out.println("CSRC: "+cc);
     // marker
     int m = (word & 0x00800000) >>> 23;
     System.out.println("marker: "+m);
     // payload type
     int pt = (word & 0x00700000) >>> 16;
     System.out.println("payload type: "+pt);
     // sequence number
     int seqNbr = (word & 0x0000FFFF);
     System.out.println("sequence number: "+seqNbr);
     // timestamp
     int timestamp = buffer.getInt();
     System.out.println("timestamp: "+timestamp);
private void parseAndPrintRTCPData(byte[] data) {
     // this only works when the RTCP packet is a Sender report (SR).
     // All RTCP packets are compound packets with a SR or Receiver report (RR) packet first.
     // part of header, there is still the report blocks (see RFC 3550).
     byte[] rtcpHeader = new byte[28];
     System.arraycopy(data, 0, rtcpHeader, 0, rtcpHeader.length);
     ByteBuffer buffer = ByteBuffer.wrap(rtcpHeader);
     int word = buffer.getInt();
     // version
     int v = word >>> 30;
     System.out.println("version: "+v);
     // padding
     int p = (word & 0x20000000) >>> 29;
     System.out.println("padding: "+p);
     // reception report count
     int rc = (word & 0x0F000000) >>> 24;
     System.out.println("reception report count: "+rc);
     // payload type, which is 200 in this case (SR=200)
     int pt = (0x00FF0000 & word) >>> 16;
     System.out.println("payload type: "+pt);
     // length
     int length = (word & 0x0000FFFF);
     System.out.println("length: "+length);
     // SSRC of sender
     int ssrc = buffer.getInt();
     System.out.println("SSRC: "+ssrc);
     // NTP timestamp
     long ntp_timestamp = buffer.getLong();
     System.out.println("NTP timestamp: "+ntp_timestamp);
     // RTP timestamp
     int rtp_timestamp = buffer.getInt();
     System.out.println("RTP timestamp: "+rtp_timestamp);
     // sender's packet count
     int nbrOfSentPackets = buffer.getInt();
     System.out.println("sender's packet count: "+nbrOfSentPackets);
     // sender's octet count
     int nbrOfSentBytes = buffer.getInt();
     System.out.println("sender's octet count: "+nbrOfSentBytes);
}I added a boolean isRTCP to the constructor so to know what sort of data is sent.
Hope this clarifies things.