audiosystem.java

java处理声音文件

						   encoding, 
						   NOT_SPECIFIED, // sample rate
						   NOT_SPECIFIED, // sample size in bits
						   NOT_SPECIFIED, // channels
						   NOT_SPECIFIED, // frame size
						   NOT_SPECIFIED, // frame rate,
						   bigEndian);
		action.setSourceDescription(format);
		doFormatConversionProviderIteration(action);
	}

	public static AudioFormat.Encoding[] getTargetEncodings(
		AudioFormat.Encoding sourceEncoding)
	{
		//$$fb 2000-08-15: workaround
		//return getTargetEncodings((Object) sourceEncoding);
		GetTargetEncodingsFormatConversionProviderAction action = 
		new GetTargetEncodingsFormatConversionProviderAction();
		doEncodingActionWorkaround(false, sourceEncoding, action);
		doEncodingActionWorkaround(true, sourceEncoding, action);
		return action.getEncodings();
	}



	public static AudioFormat.Encoding[] getTargetEncodings(
		AudioFormat sourceFormat)
	{
		return getTargetEncodings((Object) sourceFormat);
	}



	private static AudioFormat.Encoding[] getTargetEncodings(
		Object sourceDescription)
	{
		GetTargetEncodingsFormatConversionProviderAction	action = new GetTargetEncodingsFormatConversionProviderAction(sourceDescription);
		doFormatConversionProviderIteration(action);
		return action.getEncodings();
	}



	/**	FormatConversionProviderAction for isConversionSupported().
	 */
	private static class IsConversionSupportedFormatConversionProviderAction
		implements	FormatConversionProviderAction
	{
		private AudioFormat		m_sourceFormat;
		/*
		 *	May be AudioFormat or AudioFormat.Encoding.
		 */
		private Object			m_targetDescription;
		private boolean			m_bSupported;



		public IsConversionSupportedFormatConversionProviderAction(
			AudioFormat sourceFormat,
			Object targetDescription)
		{
			m_sourceFormat = sourceFormat;
			m_targetDescription = targetDescription;
			m_bSupported = false;
		}



		public boolean handleFormatConversionProvider(
			FormatConversionProvider formatConversionProvider)
		{
			boolean bSupported = false;
			if (m_targetDescription instanceof AudioFormat.Encoding)
			{
					bSupported = formatConversionProvider.isConversionSupported(
						(AudioFormat.Encoding) m_targetDescription,
						m_sourceFormat);
			}
			else if (m_targetDescription instanceof AudioFormat)
			{
					bSupported = formatConversionProvider.isConversionSupported(
						(AudioFormat) m_targetDescription,
						m_sourceFormat);
			}
			else
			{
				// TODO: debug message
			}
			m_bSupported |= bSupported;
			// interrupt the iteration depending on the result
			return bSupported;
		}



		public boolean isSupported()
		{
			return m_bSupported;
		}
	}



	public static boolean isConversionSupported(
		AudioFormat.Encoding targetEncoding,
		AudioFormat sourceFormat)
	{
		IsConversionSupportedFormatConversionProviderAction	action = new IsConversionSupportedFormatConversionProviderAction(sourceFormat, targetEncoding);
		doFormatConversionProviderIteration(action);
		return action.isSupported();
	}



	/**	FormatConversionProviderAction for getAudioInputStream().
	 */
	private static class GetAudioInputStreamFormatConversionProviderAction
		implements	FormatConversionProviderAction
	{
		private AudioInputStream	m_sourceAudioInputStream;
		private Object			m_targetDescription;
		private AudioInputStream	m_targetAudioInputStream;



		public GetAudioInputStreamFormatConversionProviderAction(
			AudioInputStream audioInputStream,
			Object targetDescription)
		{
			m_sourceAudioInputStream = audioInputStream;
			m_targetDescription = targetDescription;
			m_targetAudioInputStream = null;
		}



		public boolean handleFormatConversionProvider(
			FormatConversionProvider formatConversionProvider)
		{
			AudioInputStream	audioInputStream = null;
			try
			{
				if (m_targetDescription instanceof AudioFormat.Encoding)
				{
					audioInputStream = formatConversionProvider.getAudioInputStream(
						(AudioFormat.Encoding) m_targetDescription,
						m_sourceAudioInputStream);
				}
				else if (m_targetDescription instanceof AudioFormat)
				{
					audioInputStream = formatConversionProvider.getAudioInputStream(
						(AudioFormat) m_targetDescription,
						m_sourceAudioInputStream);
				}
				else
				{
					// TODO: debug message
				}
				m_targetAudioInputStream = audioInputStream;
				// interrupt the iteration
				return true;
			}
			catch (IllegalArgumentException e)
			{
				if (TDebug.TraceAudioSystem)
				{
					TDebug.out(e);
				}
			}
			// continue the iteration
			return false;
		}



		public AudioInputStream getAudioInputStream()
		{
			return m_targetAudioInputStream;
		}
	}



	public static AudioInputStream getAudioInputStream(
		AudioFormat.Encoding targetEncoding,
		AudioInputStream sourceStream)
	{
		return getAudioInputStreamImpl((Object) targetEncoding,
					       sourceStream);
	}



	private static AudioInputStream getAudioInputStreamImpl(
		Object targetDescription,
		AudioInputStream sourceStream)
	{
		GetAudioInputStreamFormatConversionProviderAction	action = new GetAudioInputStreamFormatConversionProviderAction(sourceStream, targetDescription);
		doFormatConversionProviderIteration(action);
		AudioInputStream	audioInputStream = action.getAudioInputStream();
		if (audioInputStream != null)
		{
			return audioInputStream;
		}
		else
		{
			throw new IllegalArgumentException("conversion not supported");
		}
	}



	public static AudioFormat[] getTargetFormats(
		AudioFormat.Encoding targetEncoding,
		AudioFormat sourceFormat)
	{
		// TODO:
		return null;
	}


	public static boolean isConversionSupported(
		AudioFormat targetFormat,
		AudioFormat sourceFormat)
	{
		IsConversionSupportedFormatConversionProviderAction	action = new IsConversionSupportedFormatConversionProviderAction(sourceFormat, targetFormat);
		doFormatConversionProviderIteration(action);
		return action.isSupported();
	}



	public static AudioInputStream getAudioInputStream(
		AudioFormat targetFormat,
		AudioInputStream sourceStream)
	{
		return getAudioInputStreamImpl((Object) targetFormat,
					       sourceStream);
	}




	// $$fb 19 Dec 99: what about cascaded conversions ?
	// we'll never have an alround-converter doing all possible conversions.
	// we could implement an algorithm that, if no conversion is available,
	// in a second step a conversion to PCM is tried, followed by a conversion from
	// PCM to the requested target format.
	// we might even introduce a third level for inter-PCM-conversion.
	// e.g. we want to convert from aLaw 8000Hz to uLaw 44100Hz.
	// 1. the first round we won't find a direct converter
	// 2. try to find a converter from aLaw 8000 to PCM 44100
	//    we won't find it.
	// 3. third level: try to find a converter from alaw 8000 to PCM 8000
	//    we'll find one.
	//    then find a converter from PCM 8000 to PCM 44100
	//    let's say we have that already.
	//    then find a converter from PCM 44100 to ulaw 44100.
	// I think that sounds more impossible than it is, when
	// we have a powerful PCM-PCM converter.
/*
  public static AudioInputStream getAudioInputStream(AudioFormat audioFormat, AudioInputStream audioInputStream)
  {
  Iterator	formatConversionProviders = TAudioConfig.getFormatConversionProviders();
  while (formatConversionProviders.hasNext())
  {
  FormatConversionProvider	formatConversionProvider = (FormatConversionProvider) formatConversionProviders.next();
  if (TDebug.TraceAudioSystem)
  {
  System.out.print("AudioSystem.getAudioInputStream(AudioFormat, AudioInputStream): asking FormatConversionProvider: " + formatConversionProvider + "...");
  }
  try
  {
  AudioInputStream	outputStream = formatConversionProvider.getConvertedStream(audioFormat, audioInputStream);
  if (TDebug.TraceAudioSystem)
  {
  TDebug.out("ok");
  }
  return outputStream;
  }
  catch (IllegalArgumentException e)
  {
  if (TDebug.TraceAudioSystem)
  {
  TDebug.out("failed");
  TDebug.out(e);
  }
  }
  }
  if (TDebug.TraceAudioSystem)
  {
  TDebug.out("AudioSystem.getAudioInputStream(AudioFormat, AudioInputStream): no suitable FormatConversionProvider found. Returning null.");
  }
  return null;
  }
*/
/*
  public static AudioInputStream getAudioInputStream(Type encoding, AudioInputStream audioInputStream)
  {
  AudioFormat	inputFormat = audioInputStream.getFormat();
  // $$fb 19 Dec 99: Here I think, sample size in bits and framesize should
  // be set to NOT_SPECIFIED, as we cannot assume that it stays
  // the same with the new encoding.
*/
	/* $$mp19991220: Yes, possible optimisation:
	   find all formats with the given encoding that can be
	   generated by conversion from the stream. Then pick the
	   one nearest to the original format.
	*/
/*
  AudioFormat	outputFormat = new AudioFormat(encoding,
  inputFormat.getSampleRate(),
  inputFormat.getSampleSizeInBits(),
  inputFormat.getChannels(),
  inputFormat.getFrameSize(),
  inputFormat.getFrameRate(),
  inputFormat.isBigEndian());
  return getAudioInputStream(outputFormat, audioInputStream);
  }
*/


	/**	AudioFileReaderAction for getAudioFileFormat().
	 */
	private static class GetAudioFileFormatAudioFileReaderAction
		implements	AudioFileReaderAction
	{
		private Object			m_source = null;
		private AudioFileFormat		m_audioFileFormat = null;



		public GetAudioFileFormatAudioFileReaderAction(Object source)
		{
			m_source = source;
		}



		public boolean handleAudioFileReader(
			AudioFileReader audioFileReader)
			throws	IOException
		{
			AudioFileFormat	audioFileFormat = null;
			try
			{
				if (m_source instanceof BufferedInputStream)
				{
					((BufferedInputStream) m_source).mark(1024);
					audioFileFormat = audioFileReader.getAudioFileFormat(((BufferedInputStream) m_source));
				}
				else if (m_source instanceof File)
				{
					audioFileFormat = audioFileReader.getAudioFileFormat(((File) m_source));
				}
				else if (m_source instanceof URL)
				{
					audioFileFormat = audioFileReader.getAudioFileFormat(((URL) m_source));
				}
				else
				{
					// TODO: debug message
				}
				if (m_audioFileFormat == null)
				{
					m_audioFileFormat = audioFileFormat;
					// interrupt the iteration
					return true;
				}
			}
			catch (UnsupportedAudioFileException e)
			{
				if (TDebug.TraceAudioSystem)
				{
					TDebug.out(e);
				}
			}
			if (m_source instanceof BufferedInputStream)
			{
				((BufferedInputStream) m_source).reset();
			}
			// continue the iteration
			return false;
		}



		public AudioFileFormat getAudioFileFormat()
		{
			return m_audioFileFormat;
		}
	}



	public static AudioFileFormat getAudioFileFormat(
		InputStream inputStream)
		throws	UnsupportedAudioFileException, IOException
	{
		BufferedInputStream	bufferedInputStream = new BufferedInputStream(inputStream, 1024);
		return getAudioFileFormatImpl(bufferedInputStream);
	}



	public static AudioFileFormat getAudioFileFormat(URL url)
		throws	UnsupportedAudioFileException, IOException
	{
		return getAudioFileFormatImpl(url);
	}



	public static AudioFileFormat getAudioFileFormat(File file)
		throws	UnsupportedAudioFileException, IOException
	{
		return getAudioFileFormatImpl(file);
	}



	private static AudioFileFormat getAudioFileFormatImpl(
		Object source)
		throws	UnsupportedAudioFileException, IOException
	{
		GetAudioFileFormatAudioFileReaderAction	action = new GetAudioFileFormatAudioFileReaderAction(source);
		doAudioFileReaderIteration(action);
		AudioFileFormat	audioFileFormat = action.getAudioFileFormat();
		if (audioFileFormat != null)
		{
			return audioFileFormat;
		}
		else
		{
			throw new UnsupportedAudioFileException("format not supported");
		}
	}



	/**	AudioFileReaderAction for getAudioInputStream().
	 */
	private static class GetAudioInputStreamAudioFileReaderAction
		implements	AudioFileReaderAction
	{
		private Object			m_source = null;
		private AudioInputStream	m_audioInputStream = null;



		public GetAudioInputStreamAudioFileReaderAction(Object source)
		{
			m_source = source;
		}



		public boolean handleAudioFileReader(
			AudioFileReader audioFileReader)
			throws	IOException
		{
			AudioInputStream	audioInputStream = null;
			try
			{
				if (m_source instanceof BufferedInputStream)
				{
					((BufferedInputStream) m_source).mark(1024);
					audioInputStream = audioFileReader.getAudioInputStream(((BufferedInputStream) m_source));
				}
				else if (m_source instanceof File)
				{
					audioInputStream = audioFileReader.getAudioInputStream(((File) m_source));
				}
				else if (m_source instanceof URL)
				{
					audioInputStream = audioFileReader.getAudioInputStream(((URL) m_source));
				}
				else
				{
					// TODO: debug message
				}
				if (m_audioInputStream == null)
				{
					m_audioInputStream = audioInputStream;
					// interrupt the iteration
					return true;
				}
			}
			catch (UnsupportedAudioFileException e)
			{
				if (TDebug.TraceAudioSystem)
				{
					TDebug.out(e);
				}
			}
			if (m_source instanceof BufferedInputStream)
			{
				((BufferedInputStream) m_source).reset();
			}