listenbuffer.java

java语言开发的P2P流媒体系统

/* Stream-2-Stream - Peer to peer television and radio
 * October 13, 2005 - This file has been modified from the original P2P-Radio source
 * Project homepage: http://s2s.sourceforge.net/
 * Copyright (C) 2005-2006 Jason Hooks
 */

/* 
 * P2P-Radio - Peer to peer streaming system
 * Project homepage: http://p2p-radio.sourceforge.net/
 * Copyright (C) 2003-2004 Michael Kaufmann <[e-mail]>
 * 
 * ---------------------------------------------------------------------------
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 * ---------------------------------------------------------------------------
 */

package p2pradio.players;

import p2pradio.*;
import p2pradio.event.*;
import p2pradio.packets.*;
import p2pradio.logging.Logger;
import java.io.*;

//jhooks - This class is used to retrieve data from the p2pradio network Buffer 
//The data will be sent to the media player in HttpPlayerServer.java 
public class ListenBuffer
{
	private Buffer buffer;
	private boolean firstPacket = true;
	private long seqNr;
	
	private HeaderPacket header;
	private Metadata metadata;
	private MetadataPacket metadataPacket;
	private DataPacket data;
	
	private HeaderChangedListener headerChangedListener = null;
	private MetadataChangedListener metadataChangedListener = null;
	private DataLeapListener dataLeapListener = null;
	private WaitForLeadListener waitForLeadListener = null;
	
	private int lead;
	private boolean waitForLead = false;
	private int timeToWaitForLead = 0;
	public ListenBuffer(Buffer buffer, Metadata metadata)
	{
		super();
		this.buffer = buffer;
		this.metadata = metadata;
	}
	
	public void setLead(int lead, boolean waitForLead)
	{
		this.lead = lead;
		this.waitForLead = waitForLead;
	}
		
	public void getReady()
	{
		if (firstPacket)
		{
			getFirstPacket();
		}
	}
	
	private void getFirstPacket()
	{
		firstPacket = false;
		
		if (waitForLead)
		{
			if (!buffer.isPacketAvailableWithAge(lead))
			{
				timeToWaitForLead = lead - buffer.getAgeOfOldestPacket();
			
				if (timeToWaitForLead <= 0)
				{
					timeToWaitForLead = 0;
				}
				else
				{
					doWaitForLead();
				}
			}
			else
			{
				timeToWaitForLead = 0;
			}
		}
		
		Packet packet = null;

		synchronized(buffer)
		{
			if (lead == 0)
			{
				seqNr = buffer.getNewestSeqNr();
			}
			else
			{
				seqNr = buffer.searchPacketWithAge(lead);
			}
	
			packet = buffer.get(seqNr);
			
			while (!(packet instanceof DataPacket))
			{
				seqNr++;
				packet = buffer.get(seqNr);
			}
			
			data = (DataPacket)packet;
			header = buffer.getAssociatedHeaderPacket(data);
			metadataPacket = buffer.getAssociatedMetadataPacket(data);
			metadata.setSongTitle(buffer.getAssociatedMetadataPacket(data).getSongTitle());
			metadata.setSongURL(buffer.getAssociatedMetadataPacket(data).getSongUrl());
		}
		
		headerChanged();
		metadataChanged();
	}

	public void nextDataPacket()
	{
		// Falls die aktuellen Daten noch nicht abgeholt wurden,
		// werden bereits die Daten des zweiten Pakets abgeliefert
		
		
		getReady();
			
		Packet packet = null;
		seqNr++;

		synchronized(buffer)
		{
			packet = buffer.get(seqNr);
			
			if (packet == null)
			{
				// Data leap
				dataLeap();
			}
						
			while ((packet == null) || !(packet instanceof DataPacket))
			{
				seqNr++;
				packet = buffer.get(seqNr);
			}
						
			data = (DataPacket)packet;
			
			HeaderPacket newHeader = buffer.getAssociatedHeaderPacket(data);
			if (header != newHeader)
			{
				header = newHeader;
				headerChanged();
			}
			
			MetadataPacket newMetadata = buffer.getAssociatedMetadataPacket(data);
			if (metadataPacket != newMetadata)
			{
				metadataPacket = newMetadata;
				metadata.setSongTitle(buffer.getAssociatedMetadataPacket(data).getSongTitle());
				metadata.setSongURL(buffer.getAssociatedMetadataPacket(data).getSongUrl());
				metadataChanged();
			}
		}
	}

	public void addHeaderChangedListener(HeaderChangedListener l)
	{
		headerChangedListener = StreamEventMulticaster.add(headerChangedListener, l);
	}

	public void removeHeaderChangedListener(HeaderChangedListener l)
	{
		headerChangedListener = StreamEventMulticaster.remove(headerChangedListener, l);
	}

	public void addMetadataChangedListener(MetadataChangedListener l)
	{
		metadataChangedListener = StreamEventMulticaster.add(metadataChangedListener, l);
	}
	
	public void removeMetadataChangedListener(MetadataChangedListener l)
	{
		metadataChangedListener = StreamEventMulticaster.remove(metadataChangedListener, l);
	}
	
	public void addDataLeapListener(DataLeapListener l)
	{
		dataLeapListener = StreamEventMulticaster.add(dataLeapListener, l);
	}

	public void removeDataLeapListener(DataLeapListener l)
	{
		dataLeapListener = StreamEventMulticaster.remove(dataLeapListener, l);
	}

	public void addWaitForLeadListener(WaitForLeadListener l)
	{
		waitForLeadListener = StreamEventMulticaster.add(waitForLeadListener, l);
	}

	public void removeWaitForLeadListener(WaitForLeadListener l)
	{
		waitForLeadListener = StreamEventMulticaster.remove(waitForLeadListener, l);
	}

	private void headerChanged()
	{
		if (headerChangedListener != null)
		{
			HeaderChangedEvent event = new HeaderChangedEvent(this);
			headerChangedListener.headerChanged(event);
		}
	}
	
	private void metadataChanged()
	{
		if (metadataChangedListener != null)
		{
			MetadataChangedEvent event = new MetadataChangedEvent(this);
			metadataChangedListener.metadataChanged(event);
		}
	}
	
	private void dataLeap()
	{
		if (dataLeapListener != null)
		{
			DataLeapEvent event = new DataLeapEvent(this);
			dataLeapListener.dataLeap(event);
		}
	}		
	
	private void doWaitForLead()
	{		
		if (waitForLeadListener != null)
		{
			WaitForLeadEvent event = new WaitForLeadEvent(this);
			waitForLeadListener.waitForLead(event);
		}
		else
		{
			waitForLead();
		}
	}
	
	public void waitForLead()
	{		
		try
		{
			Thread.sleep(getTimeToWaitForLead());
		}
		catch (InterruptedException e)
		{
			// Sollte nicht vorkommen
			Logger.severe("ListenBuffer", "INTERNAL_ERROR", e); //$NON-NLS-1$ //$NON-NLS-2$
		}
	}
	
	public int getTimeToWaitForLead()
	{
		getReady();
		
		return timeToWaitForLead;
	}

	public void writeHeader(OutputStream output) throws IOException
	{
		getReady();
		output.write(getHeader(), getHeaderOffset(), getHeaderLength());
	}

	public byte[] getHeader()
	{
		getReady();
		return header.getContent();
	}
	
	public int getHeaderOffset()
	{
		getReady();
		return header.getHeaderOffset();
	}
	
	public int getHeaderLength()
	{
		getReady();
		return header.getHeaderLength();
	}

	/**
	 * Returns the current metadata.
	 */
	public Metadata getMetadata()
	{
		getReady();
		return metadata;
	}
	
	public void writeData(OutputStream output) throws IOException
	{
		getReady();
		output.write(getData(), getDataOffset(), getDataLength());
	}
	
	public byte[] getData()
	{
		getReady();
		return data.getContent();
	}
	
	/**
	 * Returns the offset of the data in the current data byte array.
	 */
	public int getDataOffset()
	{
		getReady();
		return data.getDataOffset();
	}

	/**
	 * Returns the length of the data in the current data byte array.
	 */
	public int getDataLength()
	{
		getReady();
		return data.getDataLength();
	}
//	jhooks - lag code here
	public long getTimeStamp()
	{
		getReady();
		return data.getTimeStamp();
	}
	public long getSeqNr()
	{
		getReady();
		return data.getSeqNr();
	}
}