httpplayerserver.java

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

								writer.writeln();
								if (shutdown)
									return;
								writer.flush();
								return;
							}
							else
							{
								writer.writeln("HTTP/1.0 503 " + tryAgain); //$NON-NLS-1$
								writer.writeln("Content-type: text/plain"); //$NON-NLS-1$
								writer.writeln();
							
								writer.setNewLineMark(NewLineWriter.LF);
								writer.writeln(tryAgain); 
								if (shutdown)
									return;
								writer.flush();
								return;
							}
						}
						else
						{						
							// Ist es ein MP3-Strom?
							if (shutdown)
								return;
							if (buffer.getMetadata().isICYStream())
							{
								writer.writeln("ICY 200 OK"); //$NON-NLS-1$
								writeAnswer(writer, "icy-", true); //$NON-NLS-1$
							}
							else
							{
								writer.writeln("HTTP/1.0 200 OK"); //$NON-NLS-1$
								writeAnswer(writer, "ice-", false); //$NON-NLS-1$
							}
						}
					}
				}
			}
			else
			{
				if (method.equals("head")) //$NON-NLS-1$
				{
					if (requestURL.equals(HttpPlayer.PLAYLIST_NAME))
					{
						writer.writeln("HTTP/1.0 200 OK"); //$NON-NLS-1$
						writer.writeln("Content-type: audio/x-scpls"); //$NON-NLS-1$
						writer.writeln();
						if (shutdown)
							return;
						writer.flush();
			
						return;
					}
					else //if (requestURL.equals(ShoutcastPlayer.STREAM_NAME))
					{
						if (shutdown)
							return;
						if (!icyMetadataFound)
						{
							writer.writeln("HTTP/1.0 200 OK"); //$NON-NLS-1$
							writer.writeln("Content-type: " + buffer.getMetadata().getContentType()); //$NON-NLS-1$
							writer.writeln();
							if (shutdown)
								return;
							writer.flush();
							
							return;
						}
						else
						{
							// Das sollte nicht vorkommen
							Logger.warning("HttpPlayerServer", "HttpPlayerServer.MEDIA_PLAYER_REQUESTED_HEADER"); //$NON-NLS-1$ //$NON-NLS-2$
							return;
						}
					}
				}
			}
			
			//jhooks - We have greeted the media player textually, now we are on to sending raw data, i.e. the stream itself 
		
			// Jetzt kommt der eigentliche MP3-Strom
			
		
			/*
			long time = System.currentTimeMillis();
			int total = 0;
			*/
			
			// Soviele Datenbytes m黶sen noch geschrieben werden,
			// bis Shoutcast-Metadaten kommen
			int dataBytesLeft = ICY_METADATA_INTERVAL;   //Bytes left until we need to send metadata
			
			// Die zu schreibenden Daten
			byte[] data = null;
			
			// Offset in das data-Array, wo die Daten stehen, die als n鋍hstes geschrieben
			// werden m黶sen
			int dataOffset = 0;
			
			// L鋘ge der Daten des aktuellen Datenpakets, die noch geschrieben werden m黶sen.
			// Immer, wenn dataLength 0 ist, werden neue Daten besorgt
			int dataLength = 0;
			
			// Beim ersten mal muss die Sequenznummer gesetzt werden
			boolean firstTime = true;
			
			// Ist es ein MP3-Strom?
			boolean isICYStream = buffer.getMetadata().isICYStream();
			if (shutdown)
				return;
			// Header schreiben, falls n鰐ig
			// Sicherstellen, dass der Header gelesen wurde
			buffer.getReady();
			if (shutdown)
				return;
			if (headerHasChanged)
			{
				// Den Header schreiben
				buffer.writeHeader(outputStream);
				if (shutdown)
					return;
				outputStream.flush();
				headerHasChanged = false;
			}
			while(!shutdown)
			{
				// M黶sen neue Daten abgeholt werden?
				if (dataLength == 0)
				{
					// Alte Daten abschicken
					outputStream.flush();
					if(shutdown)
						return;
					// Die Daten abholen
					if (firstTime)
					{
						firstTime = false;
					}
					else
					{
						buffer.nextDataPacket();
					}
					if (shutdown)
						return;
					data = buffer.getData();
					dataOffset = buffer.getDataOffset();
					dataLength = buffer.getDataLength();
					
					//jhooks - lag code here
					//timeStamp = buffer.getTimeStamp();
					/*System.out.println("Time(ms):" + timeStamp);
					/**Equation to calculate the expected stream position is:
					 *											  //Time our client has been running										
					 * Time_Server_Has_Been_Running_At_Startup + (System.currentTimeMillis() - startTime)
					 * 
					 * 
					 * The real stream position is timeStamp
					 * 
					 * To find lag we use: actual - estimated
					 * 
					 * 
					 */
					//			 actual   -                              estimated
					/*if ((lag = (timeStamp - (Server_Running_Minus_Start_Time + System.currentTimeMillis()))) >= 0)
						System.out.println("Lag(ms):" + lag  ); */
					
				}
	
				// Wichtig: Nach dem Abholen eines Datenpakets
				// pr黤en, ob sich der Header ge鋘dert hat
				// (vor dem Verschicken des Datenpakets!)
				if (headerHasChanged)
				{
					if (buffer.getMetadata().getContentType().toLowerCase().equals("application/ogg")) //$NON-NLS-1$
					{
						// Bei Ogg ist das normal. Neuen Header schreiben
						buffer.writeHeader(outputStream);
						outputStream.flush();
						headerHasChanged = false;
					}	
					else
					{
						// Mit dieser Situation kann der Media Player nur fertig werden,
						// indem er die Verbindung neu aufbaut
						return;
					}
				}

				if (shutdown)
					return;
				// K鰊nen die Daten in einem St點k geschrieben werden
				// oder m黶sen die Metadaten dazwischen geschrieben werden?
				
				//If the stream is a shoutcast stream with metadata 
				//AND the data from the current packet is greater than the bytes left to update metadata
				if (icyMetadataFound && isICYStream && (dataLength > dataBytesLeft))
				{
					// Einen Teil der Daten schreiben
					
					outputStream.write(data, dataOffset, dataBytesLeft);
					// total += dataBytesLeft;
					if(shutdown)
						return;
					
					
					// N鋍hsten Teil der Daten vorbereiten
					dataLength -= dataBytesLeft;
					dataOffset += dataBytesLeft;
					
					dataBytesLeft = 0;
				}
				else
				{
					// Alle Daten schreiben
					outputStream.write(data, dataOffset, dataLength);
					// total += dataLength;
					
					// Kopie des Stroms in eine Datei schreiben	
					if(shutdown)
						return;
					dataBytesLeft -= dataLength;
					dataLength = 0;
				}
				//System.out.println("" + dataOffset);  //jhooks - offset test
				// M黶sen die Metadaten geschrieben werden?
				if (icyMetadataFound && isICYStream && (dataBytesLeft == 0))
				{
					// Haben sich die Metadaten ge鋘dert?
					if (metadataHasChanged)
					{
						metadataHasChanged = false;
			
						// Jetzt m黶sen die Metadaten gesendet werden
						int length = ShoutcastMetadata.metadataToShoutcast(buffer.getMetadata(), shoutcastMetadata);
		
						// L鋘genbyte schreiben
						outputStream.write(length / 16);
		
						// Metadaten schreiben
						outputStream.write(shoutcastMetadata, 0, length);
			
						// Kopie der Metadaten in eine Datei schreiben
						/*if ((saveStreamTo != null) && saveMetadataToo)
						{
							outgoingStreamDump.write(length / 16);
							outgoingStreamDump.write(shoutcastMetadata, 0, length);
						}*/	
						if(shutdown)
							return;
					}
					else
					{
						// L鋘genbyte 0 schreiben
						outputStream.write(0);
						
						// Kopie der Metadaten in eine Datei schreiben
						/*if ((saveStreamTo != null) && saveMetadataToo)
						{
							outgoingStreamDump.write(0);
						}*/
						if(shutdown)
							return;
					}
					
					// Jetzt kommen wieder Datenbytes
					dataBytesLeft = ICY_METADATA_INTERVAL;
				}				
				
				/*
				long now = System.currentTimeMillis();
				
				if (now - time >= 1000)
				{
					time = now;
					System.out.println(total);
					total = 0;
				}
				*/
			}
		}
		catch (IOException e)
		{
			if(shutdown)
				return;
			Logger.fine("HttpPlayerServer", "IO_ERROR", e); //$NON-NLS-1$ //$NON-NLS-2$
		}
		catch (Exception e)
		{
			if(shutdown)
				return;
			Logger.severe("HttpPlayerServer", "INTERNAL_ERROR", e); //$NON-NLS-1$ //$NON-NLS-2$
		}
		finally
		{
			if (inputStream != null)
			{
				try
				{
					inputStream.close();
				}
				catch (IOException e)
				{
				}
			}
		
			if (outputStream != null)
			{
				try
				{
					outputStream.close();
				}
				catch (IOException e)
				{
				}
			}
			
			if (socket != null)
			{
				try
				{
					socket.close();
				}
				catch (IOException e)
				{
				}
			}
		}		
	}
	
	private void writeAnswer(NewLineWriter writer, String prefix, boolean includeMetaInt) throws IOException
	{
		writer.writeln("Content-type: " + buffer.getMetadata().getContentType()); //$NON-NLS-1$
							
		// Zus鋞zliche Metadaten schreiben
		String metadataHeaders = buffer.getMetadata().toHttpHeaders(prefix, includeMetaInt);
		if (metadataHeaders != null)
		{
			writer.writeln(metadataHeaders);
		}
		
		// Zus鋞zliche HTTP-Header schreiben
		String httpHeaders = buffer.getMetadata().getHttpHeaders();
		if (!httpHeaders.equals(Metadata.HTTP_HEADERS_DEFAULT))
		{
			writer.writeln(httpHeaders);
		}

		if (!prefix.toLowerCase().equals("icy-")) //$NON-NLS-1$
		{
			// Server schreiben
			writer.writeln("Server: " + buffer.getMetadata().getServer()); //$NON-NLS-1$ //$NON-NLS-2$
		}
							
		writer.writeln();
		writer.flush();
	}
	private void shutdown()
	{
		shutdown = true;
		try {
			socket.close();
		} catch (IOException e) {
		}
	}
}