/**
* 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.util.Enumeration;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.concurrent.ConcurrentHashMap;
/**
* The participant database maintains three hashtables with participants.
*
* The key issue is to be fast for operations that happen every time an RTP
* packet is sent or received. We allow linear searching in cases where we need
* to update participants with information.
*
* The keying is therefore usually the SSRC. In cases where we have the cname,
* but no SSRC is known (no SDES packet has been received), a simple hash i
* calculated based on the CNAME. The RTCP code should, when receiving SDES
* packets, check whether the participant is known and update the copy in this
* database with SSRC if needed.
*
* @author Arne Kepp
*/
public class ParticipantDatabase {
/** The parent RTP Session */
RTPSession rtpSession = null;
/**
* A linked list to hold participants explicitly added by the application In
* unicast mode this is the list used for RTP and RTCP transmission, in
* multicast it should not be in use.
*/
LinkedList<Participant> receivers = new LinkedList<Participant>();
/**
* The hashtable holds participants added through received RTP and RTCP
* packets, as well as participants that have been linked to an SSRC by ip
* address (in unicast mode).
*/
ConcurrentHashMap<Long, Participant> ssrcTable = new ConcurrentHashMap<Long, Participant>();
/**
* Simple constructor
*
* @param parent
* parent RTPSession
*/
protected ParticipantDatabase(RTPSession parent) {
rtpSession = parent;
}
/**
*
* @param cameFrom
* 0: Application, 1: RTP packet, 2: RTCP
* @param p
* the participant
* @return 0 if okay, -1 if not
*/
protected int addParticipant(int cameFrom, Participant p) {
// Multicast or not?
if (this.rtpSession.mcSession) {
return this.addParticipantMulticast(cameFrom, p);
} else {
return this.addParticipantUnicast(cameFrom, p);
}
}
/**
* Add a multicast participant to the database
*
* @param cameFrom
* 0: Application, 1,2: discovered through RTP or RTCP
* @param p
* the participant to add
* @return 0 if okay, -2 if redundant, -1 if adding participant to multicast
*/
private int addParticipantMulticast(int cameFrom, Participant p) {
if (cameFrom == 0) {
System.out
.println("ParticipantDatabase.addParticipant() doesnt expect"
+ " application to add participants to multicast session.");
return -1;
} else {
// Check this one is not redundant
if (this.ssrcTable.contains(p.ssrc)) {
System.out.println("ParticipantDatabase.addParticipant() SSRC "
+ "already known " + Long.toString(p.ssrc));
return -2;
} else {
this.ssrcTable.put(p.ssrc, p);
return 0;
}
}
}
/**
* Add a unicast participant to the database
*
* Result will be reported back through tpSession.appIntf.userEvent
*
* @param cameFrom
* 0: Application, 1,2: discovered through RTP or RTCP
* @param p
* the participant to add
* @return 0 if new, 1 if
*/
private int addParticipantUnicast(int cameFrom, Participant p) {
if (cameFrom == 0) {
// Check whether there is a match in the ssrcTable
boolean notDone = true;
Enumeration<Participant> enu = this.ssrcTable.elements();
while (notDone && enu.hasMoreElements()) {
Participant part = enu.nextElement();
if (part.unexpected
&& (part.rtcpReceivedFromAddress
.equals(part.rtcpAddress.getAddress()) || part.rtpReceivedFromAddress
.equals(part.rtpAddress.getAddress()))) {
part.rtpAddress = p.rtpAddress;
part.rtcpAddress = p.rtcpAddress;
part.unexpected = false;
// Report the match back to the application
Participant[] partArray = { part };
this.rtpSession.appIntf.userEvent(5, partArray);
notDone = false;
p = part;
}
}
// Add to the table of people that we send packets to
this.receivers.add(p);
return 0;
} else {
// Check whether there's a match in the receivers table
boolean notDone = true;
// System.out.println("GOT " + p.cname);
Iterator<Participant> iter = this.receivers.iterator();
while (notDone && iter.hasNext()) {
Participant part = iter.next();
// System.out.println(part.rtpAddress.getAddress().toString()
// + " " + part.rtcpAddress.getAddress().toString()
// + " " + p.rtpReceivedFromAddress.getAddress().toString()
// + " " + p.rtcpReceivedFromAddress.getAddress().toString());
// System.out.println(" HUUHHHH? " +
// p.rtcpReceivedFromAddress.getAddress().equals(part.rtcpAddress.getAddress()));
if ((cameFrom == 1 && p.rtpReceivedFromAddress.getAddress()
.equals(part.rtpAddress.getAddress()))
|| (cameFrom == 2 && p.rtcpReceivedFromAddress
.getAddress().equals(
part.rtcpAddress.getAddress()))) {
part.rtpReceivedFromAddress = p.rtpReceivedFromAddress;
part.rtcpReceivedFromAddress = p.rtcpReceivedFromAddress;
// Move information
part.ssrc = p.ssrc;
part.cname = p.cname;
part.name = p.name;
part.loc = p.loc;
part.phone = p.phone;
part.email = p.email;
part.note = p.note;
part.tool = p.tool;
part.priv = p.priv;
this.ssrcTable.put(part.ssrc, part);
// Report the match back to the application
Participant[] partArray = { part };
this.rtpSession.appIntf.userEvent(5, partArray);
return 0;
}
}
// No match? ok
this.ssrcTable.put(p.ssrc, p);
return 0;
}
}
/**
* Remove a participant from all tables
*
* @param p
* the participant to be removed
*/
protected void removeParticipant(Participant p) {
if (!this.rtpSession.mcSession)
this.receivers.remove(p);
this.ssrcTable.remove(p.ssrc, p);
}
/**
* Find a participant based on the ssrc
*
* @param ssrc
* of the participant to be found
* @return the participant, null if unknonw
*/
protected Participant getParticipant(long ssrc) {
Participant p = null;
p = ssrcTable.get(ssrc);
return p;
}
/**
* Iterator for all the unicast receivers.
*
* This one is used by both RTP for sending packets, as well as RTCP.
*
* @return iterator for unicast participants
*/
protected Iterator<Participant> getUnicastReceivers() {
if (!this.rtpSession.mcSession) {
return this.receivers.iterator();
} else {
System.out
.println("Request for ParticipantDatabase.getUnicastReceivers in multicast session");
return null;
}
}
/**
* Enumeration of all the participants with known ssrcs.
*
* This is primarily used for sending packets in multicast sessions.
*
* @return enumerator with all the participants with known SSRCs
*/
protected Enumeration<Participant> getParticipants() {
return this.ssrcTable.elements();
}
protected void debugPrint() {
System.out.println(" ParticipantDatabase.debugPrint()");
Participant p;
Enumeration enu = ssrcTable.elements();
while (enu.hasMoreElements()) {
p = (Participant) enu.nextElement();
System.out.println(" ssrcTable ssrc:" + p.ssrc
+ " cname:" + p.cname + " loc:" + p.loc + " rtpAddress:"
+ p.rtpAddress + " rtcpAddress:" + p.rtcpAddress);
}
Iterator<Participant> iter = receivers.iterator();
while (iter.hasNext()) {
p = iter.next();
System.out.println(" receivers: "
+ p.rtpAddress.toString());
}
}
}