audiosystem.java

java处理声音文件

			// continue the iteration
			return false;
		}



		public AudioInputStream getAudioInputStream()
		{
			return m_audioInputStream;
		}
	}



	public static AudioInputStream getAudioInputStream(InputStream inputStream)
		throws	UnsupportedAudioFileException, IOException
	{
		BufferedInputStream	bufferedInputStream = new BufferedInputStream(inputStream, 1024);
		return getAudioInputStreamImpl(bufferedInputStream);
	}



	public static AudioInputStream getAudioInputStream(URL url)
		throws	UnsupportedAudioFileException, IOException
	{
		return getAudioInputStreamImpl(url);
	}



	public static AudioInputStream getAudioInputStream(File file)
		throws	UnsupportedAudioFileException, IOException
	{
		return getAudioInputStreamImpl(file);
	}



	private static AudioInputStream getAudioInputStreamImpl(
		Object source)
		throws	UnsupportedAudioFileException, IOException
	{
		GetAudioInputStreamAudioFileReaderAction	action = new GetAudioInputStreamAudioFileReaderAction(source);
		doAudioFileReaderIteration(action);
		AudioInputStream	audioInputStream = action.getAudioInputStream();
		if (audioInputStream != null)
		{
			return audioInputStream;
		}
		else
		{
			throw new UnsupportedAudioFileException("format not supported");
		}
	}



	public static AudioFileFormat.Type[] getAudioFileTypes()
	{
		Set		supportedTypes = new HashSet();
		Iterator	audioFileWriters = TAudioConfig.getAudioFileWriters();
		while (audioFileWriters.hasNext())
		{
			AudioFileWriter	audioFileProvider = (AudioFileWriter) audioFileWriters.next();
			if (TDebug.TraceAudioSystem)
			{
				TDebug.out("AudioSystem.getAudioFileTypes(): trying AudioFileWriter: " + audioFileProvider);
			}
			AudioFileFormat.Type[]	aSupportedTypes = audioFileProvider.getAudioFileTypes();
			if (TDebug.TraceAudioSystem)
			{
				TDebug.out("AudioSystem.getAudioFileTypes(): AudioFileWriter supports the following Types:");
			}
			for (int i = 0; i < aSupportedTypes.length; i++)
			{
				if (TDebug.TraceAudioSystem)
				{
					TDebug.out("AudioSystem.getAudioFileTypes():" + aSupportedTypes[i]);
				}
				supportedTypes.add(aSupportedTypes[i]);
			}
		}
		return (AudioFileFormat.Type[]) supportedTypes.toArray(EMPTY_TYPE_ARRAY);
	}



	/**	AudioFileWriterAction for isFileTypeSupported().
	 */
	private static class IsFileTypeSupportedAudioFileWriterAction
		implements	AudioFileWriterAction
	{
		private AudioFileFormat.Type	m_fileType;
		private AudioInputStream	m_audioInputStream;
		private boolean			m_bSupported;



		public IsFileTypeSupportedAudioFileWriterAction(
			AudioFileFormat.Type fileType,
			AudioInputStream audioInputStream)
		{
			m_fileType = fileType;
			m_audioInputStream = audioInputStream;
			m_bSupported = false;
		}



		public boolean handleAudioFileWriter(
			AudioFileWriter mixer)
		{
			boolean bSupported = false;
			if (m_audioInputStream == null)
			{
				bSupported = mixer.isFileTypeSupported(
					m_fileType);
			}
			else
			{
				bSupported = mixer.isFileTypeSupported(
					m_fileType,
					m_audioInputStream);
			}
			m_bSupported |= bSupported;
			// interrupt the iteration depending on the result
			return bSupported;
		}



		public boolean isSupported()
		{
			return m_bSupported;
		}
	}



	public static boolean isFileTypeSupported(
		AudioFileFormat.Type fileType)
	{
		return isFileTypeSupported(fileType, null);
	}



	public static AudioFileFormat.Type[] getAudioFileTypes(
		AudioInputStream audioInputStream)
	{
		Set		supportedTypes = new HashSet();
		Iterator	audioFileWriters = TAudioConfig.getAudioFileWriters();
		while (audioFileWriters.hasNext())
		{
			AudioFileWriter	audioFileProvider = (AudioFileWriter) audioFileWriters.next();
			if (TDebug.TraceAudioSystem)
			{
				TDebug.out("AudioSystem.getAudioFileTypes(): trying AudioFileWriter: " + audioFileProvider);
			}
			AudioFileFormat.Type[]	aSupportedTypes = audioFileProvider.getAudioFileTypes(audioInputStream);
			if (TDebug.TraceAudioSystem)
			{
				TDebug.out("AudioSystem.getAudioFileTypes(): AudioFileWriter supports the following Types:");
			}
			for (int i = 0; i < aSupportedTypes.length; i++)
			{
				if (TDebug.TraceAudioSystem)
				{
					TDebug.out("AudioSystem.getAudioFileTypes():" + aSupportedTypes[i]);
				}
				supportedTypes.add(aSupportedTypes[i]);
			}
		}
		return (AudioFileFormat.Type[]) supportedTypes.toArray(EMPTY_TYPE_ARRAY);
	}



	public static boolean isFileTypeSupported(
		AudioFileFormat.Type fileType,
		AudioInputStream audioInputStream)
	{
		IsFileTypeSupportedAudioFileWriterAction	action = new IsFileTypeSupportedAudioFileWriterAction(
			fileType,
			audioInputStream);
		try
		{
			doAudioFileWriterIteration(action);
		}
		catch (IOException e)
		{
		}
		return action.isSupported();
	}



	/**	AudioFileWriterAction for write().
	 */
	private static class WriteAudioFileWriterAction
		implements	AudioFileWriterAction
	{
		private AudioInputStream	m_audioInputStream;
		private AudioFileFormat.Type	m_fileType;
		private Object			m_destination;
		private int			m_nWritten;



		public WriteAudioFileWriterAction(
			AudioInputStream audioInputStream,
			AudioFileFormat.Type fileType,
			Object destination)
		{
			m_audioInputStream = audioInputStream;
			m_fileType = fileType;
			m_destination = destination;
			m_nWritten = -1;
		}



		// $$fb 2000-04-02: variable should be called "audioFileWriter" (too much copy&paste :)
		public boolean handleAudioFileWriter(
			AudioFileWriter audioFileWriter)
			throws	IOException
		{
			int	nWritten = -1;
			// $$fb 2000-04-02: need to check whether this audioFileWriter is actually
			//                  capable of handling this file type !
			if (!audioFileWriter.isFileTypeSupported(m_fileType)) 
			{
				return false;
			}
			try
			{
				if (m_destination instanceof OutputStream)
				{
					// $$fb 2000-04-02: s.a.
					nWritten = audioFileWriter.write(
						m_audioInputStream,
						m_fileType,
						(OutputStream) m_destination);
				}
				else if (m_destination instanceof File)
				{
					// $$fb 2000-04-02: s.a.
					nWritten = audioFileWriter.write(
						m_audioInputStream,
						m_fileType,
						(File) m_destination);
				}
				else
				{
					// TODO: debug message
				}
				m_nWritten = nWritten;
				// interrupt the iteration
				return true;
			}
			catch (IllegalArgumentException e)
			{
				if (TDebug.TraceAudioSystem)
				{
					TDebug.out(e);
				}
			}
			// continue the iteration
			return false;
		}



		public int getWritten()
		{
			return m_nWritten;
		}
	}



	public static int write(AudioInputStream inputStream,
				AudioFileFormat.Type fileType,
				OutputStream outputStream)
		throws	IOException
	{
		return writeImpl(inputStream,
				 fileType,
				 outputStream);
	}



	public static int write(AudioInputStream inputStream,
				AudioFileFormat.Type fileType,
				File file)
		throws	IOException
	{
		return writeImpl(inputStream,
				 fileType,
				 file);
	}



	private static int writeImpl(AudioInputStream audioInputStream,
				     AudioFileFormat.Type fileType,
				     Object destination)
		throws	IOException
	{
		WriteAudioFileWriterAction	action = new WriteAudioFileWriterAction(
			audioInputStream,
			fileType,
			destination);
		doAudioFileWriterIteration(action);
		int	nWritten = action.getWritten();
		if (nWritten == -1)
		{
			throw new IllegalArgumentException("format not  supported");
		}
		else
		{
			return nWritten;
		}
	}




	//////////////////////////////////////////////////////////////
	//
	//	auxiliary methods and interfaces
	//
	//////////////////////////////////////////////////////////////



	private static interface MixerProviderAction
	{
		public boolean handleMixerProvider(MixerProvider mixerProvider);
	}



	/**	Iterates over the available MixerProviders.
	 *	For each MixerProvider, the mathod handleMixerProvider() of
	 *	the passed MixerProviderAction is called with the MixerProvider
	 *	in question as the only argument.
	 */
	private static void doMixerProviderIteration(
		MixerProviderAction action)
	{
		Iterator	mixerProviders = TAudioConfig.getMixerProviders();
		boolean	bCompleted = false;
		while (mixerProviders.hasNext() && ! bCompleted)
		{
			MixerProvider	mixerProvider = (MixerProvider) mixerProviders.next();
			if (TDebug.TraceAudioSystem)
			{
				TDebug.out("AudioSystem.doMixerProviderIteration(): handling MixerProvider: " + mixerProvider);
			}
			bCompleted = action.handleMixerProvider(mixerProvider);
		}
	}



	private static interface MixerAction
	{
		public boolean handleMixer(Mixer mixer);
	}



	/**	Iterates over the available MixerProviders.
	 *	For each MixerProvider, the mathod handleMixerProvider() of
	 *	the passed MixerProviderAction is called with the MixerProvider
	 *	in question as the only argument.
	 */
	private static void doMixerIteration(
		MixerAction action)
	{
		Mixer.Info[]	mixerInfos = getMixerInfo();
		boolean	bCompleted = false;
		for (int nMixer = 0; nMixer < mixerInfos.length && ! bCompleted; nMixer++)
		{
			Mixer	mixer = getMixer(mixerInfos[nMixer]);
			if (TDebug.TraceAudioSystem)
			{
				TDebug.out("AudioSystem.doMixerIteration(): handling Mixer: " + mixer);
			}
			bCompleted = action.handleMixer(mixer);
		}
	}



	private static interface FormatConversionProviderAction
	{
		public boolean handleFormatConversionProvider(FormatConversionProvider formatConversionProvider);
		// throws	IOException;
	}



	/**	Iterates over the available FormatConversionProviders.
	 *	For each FormatConversionProvider, the mathod handleFormatConversionProvider() of
	 *	the passed FormatConversionProviderAction is called with the FormatConversionProvider
	 *	in question as the only argument.
	 */
	private static void doFormatConversionProviderIteration(
		FormatConversionProviderAction action)
		// throws	IOException
	{
		Iterator	formatConversionProviders = TAudioConfig.getFormatConversionProviders();
		boolean bCompleted = false;
		while (formatConversionProviders.hasNext() && ! bCompleted)
		{
			FormatConversionProvider	formatConversionProvider = (FormatConversionProvider) formatConversionProviders.next();
			if (TDebug.TraceAudioSystem)
			{
				TDebug.out("AudioSystem.doFormatConversionProviderIteration(): handling FormatConversionProvider: " + formatConversionProvider);
			}
			bCompleted = action.handleFormatConversionProvider(formatConversionProvider);
		}
	}



	private static interface AudioFileReaderAction
	{
		public boolean handleAudioFileReader(AudioFileReader audioFileReader)
			throws	IOException;
	}



	/**	Iterates over the available AudioFileReaders.
	 *	For each AudioFileReader, the mathod handleAudioFileReader() of
	 *	the passed AudioFileReaderAction is called with the AudioFileReader
	 *	in question as the only argument.
	 */
	private static void doAudioFileReaderIteration(
		AudioFileReaderAction action)
		throws	IOException
	{
		Iterator	audioFileReaders = TAudioConfig.getAudioFileReaders();
		boolean bCompleted = false;
		while (audioFileReaders.hasNext() && ! bCompleted)
		{
			AudioFileReader	audioFileReader = (AudioFileReader) audioFileReaders.next();
			if (TDebug.TraceAudioSystem)
			{
				TDebug.out("AudioSystem.doAudioFileReaderIteration(): handling AudioFileReader: " + audioFileReader);
			}
			bCompleted = action.handleAudioFileReader(audioFileReader);
		}
	}



	private static interface AudioFileWriterAction
	{
		public boolean handleAudioFileWriter(AudioFileWriter audioFileWriter)
			throws	IOException;
	}



	/**	Iterates over the available AudioFileWriters.
	 *	For each AudioFileWriter, the mathod handleAudioFileWriter() of
	 *	the passed AudioFileWriterAction is called with the AudioFileWriter
	 *	in question as the only argument.
	 */
	private static void doAudioFileWriterIteration(
		AudioFileWriterAction action)
		throws	IOException
	{
		Iterator	audioFileWriters = TAudioConfig.getAudioFileWriters();
		boolean bCompleted = false;
		while (audioFileWriters.hasNext() && ! bCompleted)
		{
			AudioFileWriter	audioFileWriter = (AudioFileWriter) audioFileWriters.next();
			if (TDebug.TraceAudioSystem)
			{
				TDebug.out("AudioSystem.doAudioFileWriterIteration(): handling AudioFileWriter: " + audioFileWriter);
			}
			bCompleted = action.handleAudioFileWriter(audioFileWriter);
		}
	}


}



/*** AudioSystem.java ***/