/**

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

/**

 * Data structure to hold a complete frame if frame reconstruction

 * is enabled, or the data from an individual packet if it is not

 * 

 * It also contains most of the data from the individual packets 

 * that it is based on.

 * 

 * @author Arne Kepp

 */

public class DataFrame {

	/** The share RTP timestamp */

	private long rtpTimestamp;

	/** The calculated UNIX timestamp, guessed after 2 Sender Reports */

	private long timestamp = -1;

	/** the SSRC from which this frame originated */

	private long SSRC;

	/** contributing CSRCs, only read from the first packet */

	private long[] CSRCs;

	/** RTP payload type */

	private int payloadType;

	/** The marks on individual packets, ordered */

	private boolean[] marks;

	/** Whether any packets were marked or not */

	private boolean anyMarked = false;

	/** Whether the frame contains the expected number of packets */

	private int isComplete = 0;

	//private int dataLength;

	/** The data from the individual packets, ordered */

	private byte[][] data;

	/** The sequence numbers of the individual packets, ordered */

	private int[] seqNum;

	/** The total amount of data bytes in this frame */

	private int totalLength = 0;

	/** The last sequence number in this frame */

	protected int lastSeqNum;

	/** The first sequence number in this frame */

	protected int firstSeqNum;

	/** The number of packets expected for a complete frame */

	protected int noPkts;

	/**

	 * The usual way to construct a frame is by giving it a PktBufNode,

	 * which contains links to all the other pkts that make it up.

	 */

	protected DataFrame(PktBufNode aBufNode, Participant p, int noPkts) {

		if(RTPSession.rtpDebugLevel > 6) {

			System.out.println("-> DataFrame(PktBufNode, noPkts = " + noPkts +")");

		}

		this.noPkts = noPkts;

		RtpPkt aPkt = aBufNode.pkt;

		int pktCount = aBufNode.pktCount;

		firstSeqNum = aBufNode.pktCount;

		// All this data should be shared, so we just get it from the first one

		this.rtpTimestamp = aBufNode.timeStamp;

		SSRC = aPkt.getSsrc();

		CSRCs = aPkt.getCsrcArray();

		// Check whether we can compute an NTPish timestamp? Requires two SR reports 

		if(p.ntpGradient > 0) {

			//System.out.print(Long.toString(p.ntpOffset)+" " 

			timestamp =  p.ntpOffset + (long) (p.ntpGradient*(double)(this.rtpTimestamp-p.lastSRRtpTs));

		}

		// Make data the right length

		int payloadLength = aPkt.getPayloadLength();

		//System.out.println("aBufNode.pktCount " + aBufNode.pktCount);

		data = new byte[aBufNode.pktCount][payloadLength];

		seqNum = new int[aBufNode.pktCount];

		marks = new boolean[aBufNode.pktCount];

		// Concatenate the data of the packets

		int i;

		for(i=0; i< pktCount; i++) {

			aPkt = aBufNode.pkt;

			byte[] temp = aPkt.getPayload();

			totalLength += temp.length;

			if(temp.length == payloadLength) {

				data[i] = temp;

			} else if(temp.length < payloadLength){

				System.arraycopy(temp, 0, data[i], 0, temp.length);

			} else {

				System.out.println("DataFrame() received node structure with increasing packet payload size.");

			}

			//System.out.println("i " + i + " seqNum[i] " + seqNum[i] + " aBufNode"  + aBufNode);

			seqNum[i] = aBufNode.seqNum;

			marks[i] = aBufNode.pkt.isMarked();

			if(marks[i])

				anyMarked = true;

			// Get next node

			aBufNode = aBufNode.nextFrameNode;

		}

		lastSeqNum = seqNum[i - 1];

		if(noPkts > 0) {

			int seqDiff = firstSeqNum - lastSeqNum;

			if(seqDiff < 0)

				seqDiff = (Integer.MAX_VALUE - firstSeqNum)  + lastSeqNum;

			if(seqDiff == pktCount && pktCount == noPkts)

				isComplete = 1;

		} else {

			isComplete = -1;

		}

		if(RTPSession.rtpDebugLevel > 6) {

			System.out.println("<- DataFrame(PktBufNode, noPkt), data length: " + data.length);

		}

	}

	/**

	 * Returns a two dimensial array where the first dimension represents individual

	 * packets, from which the frame is made up, in order of increasing sequence number. 

	 * These indeces can be matched to the sequence numbers returned by sequenceNumbers().

	 * 

	 * @return 2-dim array with raw data from packets

	 */

	public byte[][] getData() {

		return this.data;

	}

	/**

	 * Returns a concatenated version of the data from getData()

	 * It ignores missing sequence numbers, but then isComplete()

	 * will return false provided that RTPAppIntf.frameSize()

	 * provides a non-negative number for this payload type.

	 * 

	 * @return byte[] with all the data concatenated

	 */

	public byte[] getConcatenatedData() {

		if(this.noPkts < 2) {

			byte[] ret = new byte[this.totalLength];

			int pos = 0;

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

				int length = data[i].length;

				// Last packet may be shorter

				if(pos + length > totalLength) 

					length = totalLength - pos;

				System.arraycopy(data[i], 0, ret, pos, length);

				pos += data[i].length;

			}

			return ret;

		} else {

			return data[0];

		}

	}

	/**

	 * If two SR packet have been received jlibrtp will attempt to calculate 

	 * the local UNIX timestamp (in milliseconds) of all packets received.

	 * 

	 * This value should ideally correspond to the local time when the 

	 * SSRC sent the packet. Note that the source may not be reliable.

	 * 

	 * Returns -1 if less than two SRs have been received

	 * 

	 * @return the UNIX timestamp, similar to System.currentTimeMillis() or -1;

	 */

	public long timestamp() {

		return this.timestamp;

	}

	/**

	 * Returns the RTP timestamp of all the packets in the frame.

	 * 

	 * @return unmodified RTP timestamp

	 */

	public long rtpTimestamp() {

		return this.rtpTimestamp;

	}

	/**

	 * Returns the payload type of the packets

	 * 

	 * @return the payload type of the packets

	 */

	public int payloadType() {

		return this.payloadType;

	}

	/**

	 * Returns an array whose values, for the same index, correpond to the 

	 * sequence number of the packet from which the data came.

	 * 

	 * This information can be valuable in conjunction with getData(), 

	 * to identify what parts of a frame are missing.

	 * 

	 * @return array with sequence numbers

	 */

	public int[] sequenceNumbers() {

		return seqNum;

	}

	/**

	 * Returns an array whose values, for the same index, correpond to 

	 * whether the data was marked or not. 

	 * 

	 * This information can be valuable in conjunction with getData().

	 * 

	 * @return array of booleans

	 */

	public boolean[] marks() {

		return this.marks;

	}

	/**

	 * Returns true if any packet in the frame was marked.

	 * 

	 * This function should be used if all your frames fit

	 * into single packets.

	 * 

	 * @return true if any packet was marked, false otherwise

	 */

	public boolean marked() {

		return this.anyMarked;

	}

	/**

	 * The SSRC associated with this frame.

	 * 

	 * @return the ssrc that created this frame

	 */

	public long ssrc() {

		return this.SSRC;

	}

	/**

	 * The SSRCs that contributed to this frame

	 * 

	 * @return an array of contributing SSRCs, or null

	 */

	public long[] csrcs() {

		return this.CSRCs;

	}

	/**

	 * Checks whether the difference in sequence numbers corresponds

	 * to the number of packets received for the current timestamp,

	 * and whether this value corresponds to the expected number of

	 * packets.

	 * 

	 * @return true if the right number of packets make up the frame

	 */

	public int complete() {

		return this.isComplete;

	}

}