/**

 * 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.DatagramPacket;

import java.net.DatagramSocket;

import java.net.InetAddress;

import java.net.InetSocketAddress;

import java.net.MulticastSocket;

import java.util.Enumeration;

import java.util.Iterator;

import java.util.Random;

import java.util.concurrent.locks.Condition;

import java.util.concurrent.locks.Lock;

import java.util.concurrent.locks.ReentrantLock;

import org.sipdroid.net.tools.DataFramePool;

import org.sipdroid.net.tools.DatagramPool;

import org.sipdroid.net.tools.PktBufNodePool;

import org.sipdroid.net.tools.RtpPktPool;

import android.util.Log;

/**

 * The RTPSession object is the core of jlibrtp.

 * 

 * One should be instantiated for every communication channel, i.e. if you send

 * voice and video, you should create one for each.

 * 

 * The instance holds a participant database, as well as other information about

 * the session. When the application registers with the session, the necessary

 * threads for receiving and processing RTP packets are spawned.

 * 

 * RTP Packets are sent synchronously, all other operations are asynchronous.

 * 

 * @author Arne Kepp

 */

public class RTPSession {

	/**

	 * The debug level is final to avoid compilation of if-statements.</br> 0

	 * provides no debugging information, 20 provides everything </br> Debug

	 * output is written to System.out</br> Debug level for RTP related things.

	 */

	final static public int rtpDebugLevel = 1;

	/**

	 * The debug level is final to avoid compilation of if-statements.</br> 0

	 * provides no debugging information, 20 provides everything </br> Debug

	 * output is written to System.out</br> Debug level for RTCP related things.

	 */

	final static public int rtcpDebugLevel = 1;

	/** RTP unicast socket */

	protected DatagramSocket rtpSock = null;

	/** RTP multicast socket */

	protected MulticastSocket rtpMCSock = null;

	/** RTP multicast group */

	protected InetAddress mcGroup = null;

	// Internal state

	/** Whether this session is a multicast session or not */

	protected boolean mcSession = false;

	/** Current payload type, can be changed by application */

	protected int payloadType = 0;

	/** SSRC of this session */

	protected long ssrc;

	/** The last timestamp when we sent something */

	protected long lastTimestamp = 0;

	/** Current sequence number */

	protected int seqNum = 0;

	/** Number of packets sent by this session */

	protected int sentPktCount = 0;

	/** Number of octets sent by this session */

	protected int sentOctetCount = 0;

	/** The random seed */

	protected Random random = null;

	/** Session bandwidth in BYTES per second */

	protected int bandwidth = 8000;

	/** By default we do not return packets from strangers in unicast mode */

	protected boolean naiveReception = false;

	/** Should the library attempt frame reconstruction? */

	protected boolean frameReconstruction = true;

	/** Maximum number of packets used for reordering */

	protected int pktBufBehavior = 3;

	/** Participant database */

	protected ParticipantDatabase partDb = new ParticipantDatabase(this);

	/** First participant */

	protected Participant firstPart;

	/** Handle to application interface for RTP */

	protected RTPAppIntf appIntf = null;

	/** Handle to application interface for RTCP (optional) */

	protected RTCPAppIntf rtcpAppIntf = null;

	/** Handle to application interface for AVPF, RFC 4585 (optional) */

	protected RTCPAVPFIntf rtcpAVPFIntf = null;

	/** Handle to application interface for debugging */

	protected DebugAppIntf debugAppIntf = null;

	/** The RTCP session associated with this RTP Session */

	protected RTCPSession rtcpSession = null;

	/** The thread for receiving RTP packets */

	protected RTPReceiverThread recvThrd = null;

	/** The thread for invoking callbacks for RTP packets */

	protected AppCallerThread appCallerThrd = null;

	/** Lock to protect the packet buffers */

	final protected Lock pktBufLock = new ReentrantLock();

	/** Condition variable, to tell the */

	final protected Condition pktBufDataReady = pktBufLock.newCondition();

	/** Enough is enough, set to true when you want to quit. */

	protected boolean endSession = false;

	/** Only one registered application, please */

	protected boolean registered = false;

	/** We're busy resolving a SSRC conflict, please try again later */

	protected boolean conflict = false;

	/** Number of conflicts observed, exessive number suggests loop in network */

	protected int conflictCount = 0;

	/** SDES CNAME */

	protected String cname = null;

	/** SDES The participant's real name */

	public String name = null;

	/** SDES The participant's email */

	public String email = null;

	/** SDES The participant's phone number */

	public String phone = null;

	/** SDES The participant's location */

	public String loc = null;

	/** SDES The tool the participants is using */

	public String tool = null;

	/** SDES A note */

	public String note = null;

	/** SDES A priv string, loosely defined */

	public String priv = null;

	// RFC 4585 stuff. This should live on RTCPSession, but we need to have this

	// infromation ready by the time the RTCP Session starts

	// 0 = RFC 3550 , -1 = ACK , 1 = Immediate feedback, 2 = Early RTCP,

	protected int rtcpMode = 0;

	protected int fbEarlyThreshold = -1; // group size, immediate -> early

	// transition point

	protected int fbRegularThreshold = -1; // group size, early -> regular

	// transition point

	protected int minInterval = 5000; // minimum interval

	protected int fbMaxDelay = 1000; // how long the information is useful

	// RTCP bandwidth

	protected int rtcpBandwidth = -1;

	/**

	 * Returns an instance of a <b>unicast</b> RTP session. Following this you

	 * should adjust any settings and then register your application.

	 * 

	 * The sockets should have external ip addresses, else your CNAME

	 * automatically generated CNAMe will be bad.

	 * 

	 * @param rtpSocket

	 *            UDP socket to receive RTP communication on

	 * @param rtcpSocket

	 *            UDP socket to receive RTCP communication on, null if none.

	 */

	public RTPSession(DatagramSocket rtpSocket, DatagramSocket rtcpSocket) {

		mcSession = false;

		rtpSock = rtpSocket;

		this.generateCNAME();

		this.generateSsrc();

		this.rtcpSession = new RTCPSession(this, rtcpSocket);

		// The sockets are not always imediately available?

		try {

			Thread.sleep(1);

		} catch (InterruptedException e) {

			System.out.println("RTPSession sleep failed");

		}

	}

	/**

	 * Returns an instance of a <b>multicast</b> RTP session. Following this you

	 * should register your application.

	 * 

	 * The sockets should have external ip addresses, else your CNAME

	 * automatically generated CNAMe will be bad.

	 * 

	 * @param rtpSock

	 *            a multicast socket to receive RTP communication on

	 * @param rtcpSock

	 *            a multicast socket to receive RTP communication on

	 * @param multicastGroup

	 *            the multicast group that we want to communicate with.

	 */

	public RTPSession(MulticastSocket rtpSock, MulticastSocket rtcpSock,

			InetAddress multicastGroup) throws Exception {

		mcSession = true;

		rtpMCSock = rtpSock;

		mcGroup = multicastGroup;

		rtpMCSock.joinGroup(mcGroup);

		rtcpSock.joinGroup(mcGroup);

		this.generateCNAME();

		this.generateSsrc();

		this.rtcpSession = new RTCPSession(this, rtcpSock, mcGroup);

		// The sockets are not always imediately available?

		try {

			Thread.sleep(1);

		} catch (InterruptedException e) {

			System.out.println("RTPSession sleep failed");

		}

	}

	/**

	 * Registers an application (RTPAppIntf) with the RTP session. The session

	 * will call receiveData() on the supplied instance whenever data has been

	 * received.

	 * 

	 * Following this you should set the payload type and add participants to

	 * the session.

	 * 

	 * @param rtpApp

	 *            an object that implements the RTPAppIntf-interface

	 * @param rtcpApp

	 *            an object that implements the RTCPAppIntf-interface (optional)

	 * @return -1 if this RTPSession-instance already has an application

	 *         registered.

	 */

	public int RTPSessionRegister(RTPAppIntf rtpApp, RTCPAppIntf rtcpApp,

			DebugAppIntf debugApp) {

		if (registered) {

			System.out

			.println("RTPSessionRegister(): Can\'t register another application!");

			return -1;

		} else {

			registered = true;

			generateSeqNum();

			if (RTPSession.rtpDebugLevel > 0) {

				System.out.println("-> RTPSessionRegister");

			}

			this.appIntf = rtpApp;

			this.rtcpAppIntf = rtcpApp;

			this.debugAppIntf = debugApp;

			recvThrd = new RTPReceiverThread(this);

			appCallerThrd = new AppCallerThread(this, rtpApp);

			//recvThrd.start();

			//appCallerThrd.start();

			//rtcpSession.start();

			return 0;

		}

	}

	public AppCallerThread getAppCallerThrd() {

		return appCallerThrd;

	}

	public RTPReceiverThread getRTPRecvThrd() {

		return recvThrd;

	}

	/**

	 * Send data to all participants registered as receivers, using the current

	 * timeStamp, dynamic sequence number and the current payload type specified

	 * for the session.

	 * 

	 * @param buf

	 *            A buffer of bytes, less than 1496 bytes

	 * @return null if there was a problem, {RTP Timestamp, Sequence number}

	 *         otherwise

	 */

	public long[] sendData(byte[] buf) {

		byte[][] tmp = { buf };

		long[][] ret = this.sendData(tmp, null, null, -1, null);

		if (ret != null)

			return ret[0];

		return null;

	}

	/**

	 * Send data to all participants registered as receivers, using the

	 * specified timeStamp, sequence number and the current payload type

	 * specified for the session.

	 * 

	 * @param buf

	 *            A buffer of bytes, less than 1496 bytes

	 * @param rtpTimestamp

	 *            the RTP timestamp to be used in the packet

	 * @param seqNum

	 *            the sequence number to be used in the packet

	 * @return null if there was a problem, {RTP Timestamp, Sequence number}

	 *         otherwise

	 */

	public long[] sendData(byte[] buf, long rtpTimestamp, long seqNum) {

		byte[][] tmp = { buf };

		long[][] ret = this.sendData(tmp, null, null, -1, null);

		if (ret != null)

			return ret[0];

		return null;

	}

	/**

	 * Send data to all participants registered as receivers, using the current

	 * timeStamp and payload type. The RTP timestamp will be the same for all

	 * the packets.

	 * 

	 * @param buffers

	 *            A buffer of bytes, should not bed padded and less than 1500

	 *            bytes on most networks.

	 * @param csrcArray

	 *            an array with the SSRCs of contributing sources

	 * @param markers

	 *            An array indicating what packets should be marked. Rarely

	 *            anything but the first one

	 * @param rtpTimestamp

	 *            The RTP timestamp to be applied to all packets

	 * @param seqNumbers

	 *            An array with the sequence number associated with each byte[]

	 * @return null if there was a problem sending the packets, 2-dim array with

	 *         {RTP Timestamp, Sequence number}

	 */

	public long[][] sendData(byte[][] buffers, long[] csrcArray,

			boolean[] markers, long rtpTimestamp, long[] seqNumbers) {

		if (RTPSession.rtpDebugLevel > 5) {

			System.out.println("-> RTPSession.sendData(byte[])");

		}

		// Same RTP timestamp for all

		if (rtpTimestamp < 0)

			rtpTimestamp = System.currentTimeMillis();

		// Return values

		long[][] ret = new long[buffers.length][2];

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

			byte[] buf = buffers[i];

			boolean marker = false;

			if (markers != null)

				marker = markers[i];

			if (buf.length > 1500) {

				System.out

				.println("RTPSession.sendData() called with buffer exceeding 1500 bytes ("

						+ buf.length + ")");

			}

			// Get the return values

			ret[i][0] = rtpTimestamp;

			if (seqNumbers == null) {

				ret[i][1] = getNextSeqNum();

			} else {

				ret[i][1] = seqNumbers[i];

			}

			// Create a new RTP Packet

			RtpPkt pkt = RtpPktPool.getInstance().borrowPkt();

			pkt.initPacket(rtpTimestamp, this.ssrc, (int) ret[i][1],

					this.payloadType, buf);

			if (csrcArray != null)

				pkt.setCsrcs(csrcArray);

			pkt.setMarked(marker);

			// Creates a raw packet

			byte[] pktBytes = pkt.encode();

			// System.out.println(Integer.toString(StaticProcs.bytesToUIntInt(pktBytes,

			// 2)));

			// Pre-flight check, are resolving an SSRC conflict?

			if (this.conflict) {

				System.out

				.println("RTPSession.sendData() called while trying to resolve conflict.");

				return null;

			}

			if (this.mcSession) {

				DatagramPacket packet = null;

				try {

					packet = new DatagramPacket(pktBytes, pktBytes.length,

							this.mcGroup, this.rtpMCSock.getPort());

				} catch (Exception e) {

					System.out

					.println("RTPSession.sendData() packet creation failed.");

					e.printStackTrace();

					return null;

				}

				try {

					rtpMCSock.send(packet);

					// Debug

					if (this.debugAppIntf != null) {

						this.debugAppIntf.packetSent(1,

								(InetSocketAddress) packet.getSocketAddress(),

								new String("Sent multicast RTP packet of size "

										+ packet.getLength()

										+ " to "

										+ packet.getSocketAddress().toString()

										+ " via "

										+ rtpMCSock.getLocalSocketAddress()

										.toString()));

					}

				} catch (Exception e) {

					System.out

					.println("RTPSession.sendData() multicast failed.");

					e.printStackTrace();

					return null;

				}

			} else {

				// Loop over recipients

				Iterator<Participant> iter = partDb.getUnicastReceivers();

				while (iter.hasNext()) {

					InetSocketAddress receiver = iter.next().rtpAddress;

					DatagramPacket packet = null;

					if (RTPSession.rtpDebugLevel > 15) {

						System.out.println("   Sending to "

								+ receiver.toString());

					}

					try {

						packet = new DatagramPacket(pktBytes, pktBytes.length,

								receiver);

					} catch (Exception e) {

						System.out

						.println("RTPSession.sendData() packet creation failed.");

						e.printStackTrace();

						return null;

					}

					// Actually send the packet

					try {

						rtpSock.send(packet);

						// Debug

						if (this.debugAppIntf != null) {

							this.debugAppIntf

							.packetSent(

									0,

									(InetSocketAddress) packet

									.getSocketAddress(),

									new String(

											"Sent unicast RTP packet of size "

											+ packet

											.getLength()

											+ " to "

											+ packet

											.getSocketAddress()

											.toString()

											+ " via "

											+ rtpSock

											.getLocalSocketAddress()

											.toString()));

						}

					} catch (Exception e) {

						System.out

						.println("RTPSession.sendData() unicast failed.");

						e.printStackTrace();

						return null;

					}

				}

			}

			// Update our stats

			this.sentPktCount++;

			this.sentOctetCount++;

			if (RTPSession.rtpDebugLevel > 5) {

				System.out.println("<- RTPSession.sendData(byte[]) "

						+ pkt.getSeqNumber());

			}

		}

		return ret;

	}

	public void sendData(DatagramPacket packet, RtpPkt pkt) {

		if (RTPSession.rtpDebugLevel > 5) {

			System.out.println("-> RTPSession.sendData(byte[])");

		}

		pkt.setTimeStamp(System.currentTimeMillis());

		pkt.setSsrc(ssrc);

		pkt.setSeqNumber(getNextSeqNum());

		// Creates a raw packet

		pkt.writeHeader();

		// Pre-flight check, are resolving an SSRC conflict?

		if (this.conflict) {

			System.out

			.println("RTPSession.sendData() called while trying to resolve conflict.");

			return;

		}

		if (this.mcSession) {

			try {

				packet.setPort(this.rtpMCSock.getPort());

				packet.setAddress(this.mcGroup);

			} catch (Exception e) {

				System.out

				.println("RTPSession.sendData() packet creation failed.");

				e.printStackTrace();

				return;

			}

			try {

				rtpMCSock.send(packet);