| /* Main interface to audio system |
| Copyright (C) 2005 Free Software Foundation, Inc. |
| |
| This file is part of GNU Classpath. |
| |
| GNU Classpath 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, or (at your option) |
| any later version. |
| |
| GNU Classpath 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 GNU Classpath; see the file COPYING. If not, write to the |
| Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA |
| 02110-1301 USA. |
| |
| Linking this library statically or dynamically with other modules is |
| making a combined work based on this library. Thus, the terms and |
| conditions of the GNU General Public License cover the whole |
| combination. |
| |
| As a special exception, the copyright holders of this library give you |
| permission to link this library with independent modules to produce an |
| executable, regardless of the license terms of these independent |
| modules, and to copy and distribute the resulting executable under |
| terms of your choice, provided that you also meet, for each linked |
| independent module, the terms and conditions of the license of that |
| module. An independent module is a module which is not derived from |
| or based on this library. If you modify this library, you may extend |
| this exception to your version of the library, but you are not |
| obligated to do so. If you do not wish to do so, delete this |
| exception statement from your version. */ |
| |
| |
| package javax.sound.sampled; |
| |
| import gnu.classpath.ServiceFactory; |
| |
| import java.io.File; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.io.OutputStream; |
| import java.net.URL; |
| import java.util.HashSet; |
| import java.util.Iterator; |
| |
| import javax.sound.sampled.spi.AudioFileReader; |
| import javax.sound.sampled.spi.AudioFileWriter; |
| import javax.sound.sampled.spi.FormatConversionProvider; |
| import javax.sound.sampled.spi.MixerProvider; |
| |
| /** |
| * This clas is the primary interface to the audio system. It contains |
| * a number of static methods which can be used to access this package's |
| * functionality. |
| * |
| * @since 1.3 |
| */ |
| public class AudioSystem |
| { |
| /** |
| * A constant which can be passed to a number of methods in this package, |
| * to indicate an unspecified value. |
| */ |
| public static final int NOT_SPECIFIED = -1; |
| |
| // This class is not instantiable. |
| private AudioSystem() |
| { |
| } |
| |
| /** |
| * Return the file format of a given File. |
| * @param f the file to check |
| * @return the format of the file |
| * @throws UnsupportedAudioFileException if the file's format is not |
| * recognized |
| * @throws IOException if there is an I/O error reading the file |
| */ |
| public static AudioFileFormat getAudioFileFormat(File f) |
| throws UnsupportedAudioFileException, IOException |
| { |
| Iterator i = ServiceFactory.lookupProviders(AudioFileReader.class); |
| while (i.hasNext()) |
| { |
| AudioFileReader reader = (AudioFileReader) i.next(); |
| try |
| { |
| return reader.getAudioFileFormat(f); |
| } |
| catch (UnsupportedAudioFileException _) |
| { |
| // Try the next provider. |
| } |
| } |
| throw new UnsupportedAudioFileException("file type not recognized"); |
| } |
| |
| /** |
| * Return the file format of a given input stream. |
| * @param is the input stream to check |
| * @return the format of the stream |
| * @throws UnsupportedAudioFileException if the stream's format is not |
| * recognized |
| * @throws IOException if there is an I/O error reading the stream |
| */ |
| public static AudioFileFormat getAudioFileFormat(InputStream is) |
| throws UnsupportedAudioFileException, IOException |
| { |
| Iterator i = ServiceFactory.lookupProviders(AudioFileReader.class); |
| while (i.hasNext()) |
| { |
| AudioFileReader reader = (AudioFileReader) i.next(); |
| try |
| { |
| return reader.getAudioFileFormat(is); |
| } |
| catch (UnsupportedAudioFileException _) |
| { |
| // Try the next provider. |
| } |
| } |
| throw new UnsupportedAudioFileException("input stream type not recognized"); |
| } |
| |
| /** |
| * Return the file format of a given URL. |
| * @param url the URL to check |
| * @return the format of the URL |
| * @throws UnsupportedAudioFileException if the URL's format is not |
| * recognized |
| * @throws IOException if there is an I/O error reading the URL |
| */ |
| public static AudioFileFormat getAudioFileFormat(URL url) |
| throws UnsupportedAudioFileException, IOException |
| { |
| Iterator i = ServiceFactory.lookupProviders(AudioFileReader.class); |
| while (i.hasNext()) |
| { |
| AudioFileReader reader = (AudioFileReader) i.next(); |
| try |
| { |
| return reader.getAudioFileFormat(url); |
| } |
| catch (UnsupportedAudioFileException _) |
| { |
| // Try the next provider. |
| } |
| } |
| throw new UnsupportedAudioFileException("URL type not recognized"); |
| } |
| |
| /** |
| * Return an array of all the supported AudioFileFormat types. |
| * @return an array of unique types |
| */ |
| public static AudioFileFormat.Type[] getAudioFileTypes() |
| { |
| HashSet<AudioFileFormat.Type> result |
| = new HashSet<AudioFileFormat.Type>(); |
| Iterator i = ServiceFactory.lookupProviders(AudioFileWriter.class); |
| while (i.hasNext()) |
| { |
| AudioFileWriter writer = (AudioFileWriter) i.next(); |
| AudioFileFormat.Type[] types = writer.getAudioFileTypes(); |
| for (int j = 0; j < types.length; ++j) |
| result.add(types[j]); |
| } |
| return result.toArray(new AudioFileFormat.Type[result.size()]); |
| } |
| |
| /** |
| * Return an array of all the supported AudioFileFormat types which match the |
| * given audio input stream |
| * @param ais the audio input stream |
| * @return an array of unique types |
| */ |
| public static AudioFileFormat.Type[] getAudioFileTypes(AudioInputStream ais) |
| { |
| HashSet<AudioFileFormat.Type> result |
| = new HashSet<AudioFileFormat.Type>(); |
| Iterator i = ServiceFactory.lookupProviders(AudioFileWriter.class); |
| while (i.hasNext()) |
| { |
| AudioFileWriter writer = (AudioFileWriter) i.next(); |
| AudioFileFormat.Type[] types = writer.getAudioFileTypes(ais); |
| for (int j = 0; j < types.length; ++j) |
| result.add(types[j]); |
| } |
| return result.toArray(new AudioFileFormat.Type[result.size()]); |
| } |
| |
| /** |
| * Given an audio input stream, this will try to create a new audio input |
| * stream whose encoding matches the given target encoding. If no provider |
| * offers this conversion, an exception is thrown. |
| * @param targ the target encoding |
| * @param ais the original audio stream |
| * @return a new audio stream |
| * @throws IllegalArgumentException if the conversion cannot be made |
| */ |
| public static AudioInputStream getAudioInputStream(AudioFormat.Encoding targ, |
| AudioInputStream ais) |
| { |
| Iterator i = ServiceFactory.lookupProviders(FormatConversionProvider.class); |
| while (i.hasNext()) |
| { |
| FormatConversionProvider prov = (FormatConversionProvider) i.next(); |
| if (! prov.isConversionSupported(targ, ais.getFormat())) |
| continue; |
| return prov.getAudioInputStream(targ, ais); |
| } |
| throw new IllegalArgumentException("encoding not supported for stream"); |
| } |
| |
| /** |
| * Given an audio input stream, this will try to create a new audio input |
| * stream whose format matches the given target format. If no provider |
| * offers this conversion, an exception is thrown. |
| * @param targ the target format |
| * @param ais the original audio stream |
| * @return a new audio stream |
| * @throws IllegalArgumentException if the conversion cannot be made |
| */ |
| public static AudioInputStream getAudioInputStream(AudioFormat targ, |
| AudioInputStream ais) |
| { |
| Iterator i = ServiceFactory.lookupProviders(FormatConversionProvider.class); |
| while (i.hasNext()) |
| { |
| FormatConversionProvider prov = (FormatConversionProvider) i.next(); |
| if (! prov.isConversionSupported(targ, ais.getFormat())) |
| continue; |
| return prov.getAudioInputStream(targ, ais); |
| } |
| throw new IllegalArgumentException("format not supported for stream"); |
| } |
| |
| /** |
| * Return an audio input stream for the file. |
| * @param f the file to read |
| * @return an audio input stream for the file |
| * @throws UnsupportedAudioFileException if the file's audio format is not |
| * recognized |
| * @throws IOException if there is an error while reading the file |
| */ |
| public static AudioInputStream getAudioInputStream(File f) |
| throws UnsupportedAudioFileException, IOException |
| { |
| Iterator i = ServiceFactory.lookupProviders(AudioFileReader.class); |
| while (i.hasNext()) |
| { |
| AudioFileReader reader = (AudioFileReader) i.next(); |
| try |
| { |
| return reader.getAudioInputStream(f); |
| } |
| catch (UnsupportedAudioFileException _) |
| { |
| // Try the next provider. |
| } |
| } |
| throw new UnsupportedAudioFileException("file type not recognized"); |
| } |
| |
| /** |
| * Return an audio input stream given an input stream. |
| * @param is the input stream |
| * @return an audio input stream |
| * @throws UnsupportedAudioFileException if the input stream's audio format |
| * is not supported by any of the installed providers |
| * @throws IOException if there is an error while reading the input stream |
| */ |
| public static AudioInputStream getAudioInputStream(InputStream is) |
| throws UnsupportedAudioFileException, IOException |
| { |
| Iterator i = ServiceFactory.lookupProviders(AudioFileReader.class); |
| while (i.hasNext()) |
| { |
| AudioFileReader reader = (AudioFileReader) i.next(); |
| try |
| { |
| return reader.getAudioInputStream(is); |
| } |
| catch (UnsupportedAudioFileException _) |
| { |
| // Try the next provider. |
| } |
| } |
| throw new UnsupportedAudioFileException("input stream type not recognized"); |
| } |
| |
| /** |
| * Return an audio input stream for the given URL. |
| * @param url the URL |
| * @return an audio input stream |
| * @throws UnsupportedAudioFileException if the URL's audio format is not |
| * supported by any of the installed providers |
| * @throws IOException if there is an error while reading the URL |
| */ |
| public static AudioInputStream getAudioInputStream(URL url) |
| throws UnsupportedAudioFileException, IOException |
| { |
| Iterator i = ServiceFactory.lookupProviders(AudioFileReader.class); |
| while (i.hasNext()) |
| { |
| AudioFileReader reader = (AudioFileReader) i.next(); |
| try |
| { |
| return reader.getAudioInputStream(url); |
| } |
| catch (UnsupportedAudioFileException _) |
| { |
| // Try the next provider. |
| } |
| } |
| throw new UnsupportedAudioFileException("URL type not recognized"); |
| } |
| |
| /** |
| * Return a new clip which can be used for playing back an audio stream. |
| * @throws LineUnavailableException if a clip is not available for some |
| * reason |
| * @throws SecurityException if a clip cannot be made for security reasons |
| * @since 1.5 |
| */ |
| public static Clip getClip() |
| throws LineUnavailableException |
| { |
| Mixer.Info[] infos = getMixerInfo(); |
| for (int i = 0; i < infos.length; ++i) |
| { |
| Mixer mix = getMixer(infos[i]); |
| Line[] lines = mix.getSourceLines(); |
| for (int j = 0; j < lines.length; ++j) |
| { |
| if (lines[j] instanceof Clip) |
| return (Clip) lines[j]; |
| } |
| } |
| throw new LineUnavailableException("no Clip available"); |
| } |
| |
| /** |
| * Return a new clip which can be used for playing back an audio stream. |
| * The clip is obtained from the indicated mixer. |
| * @param info the mixer to use |
| * @throws LineUnavailableException if a clip is not available for some |
| * reason |
| * @throws SecurityException if a clip cannot be made for security reasons |
| * @since 1.5 |
| */ |
| public static Clip getClip(Mixer.Info info) |
| throws LineUnavailableException |
| { |
| Mixer mix = getMixer(info); |
| Line[] lines = mix.getSourceLines(); |
| for (int j = 0; j < lines.length; ++j) |
| { |
| if (lines[j] instanceof Clip) |
| return (Clip) lines[j]; |
| } |
| throw new LineUnavailableException("no Clip available"); |
| } |
| |
| /** |
| * Return a line matching the provided description. All the providers |
| * on the system are searched for a matching line. |
| * @param info description of the line |
| * @return the matching line |
| * @throws LineUnavailableException if no provider supplies a matching line |
| */ |
| public static Line getLine(Line.Info info) throws LineUnavailableException |
| { |
| Mixer.Info[] infos = getMixerInfo(); |
| for (int i = 0; i < infos.length; ++i) |
| { |
| Mixer mix = getMixer(infos[i]); |
| try |
| { |
| return mix.getLine(info); |
| } |
| catch (LineUnavailableException _) |
| { |
| // Try the next provider. |
| } |
| } |
| throw new LineUnavailableException("no Clip available"); |
| } |
| |
| /** |
| * Return a mixer matching the provided description. All the providers |
| * on the system are searched for a matching mixer. |
| * @param info description of the mixer |
| * @return the matching mixer |
| * @throws IllegalArgumentException if no provider supplies a matching mixer |
| */ |
| public static Mixer getMixer(Mixer.Info info) |
| { |
| Iterator i = ServiceFactory.lookupProviders(MixerProvider.class); |
| while (i.hasNext()) |
| { |
| MixerProvider prov = (MixerProvider) i.next(); |
| if (prov.isMixerSupported(info)) |
| return prov.getMixer(info); |
| } |
| throw new IllegalArgumentException("mixer not found"); |
| } |
| |
| /** |
| * Return an array of descriptions of all the mixers provided on the system. |
| */ |
| public static Mixer.Info[] getMixerInfo() |
| { |
| HashSet<Mixer.Info> result = new HashSet<Mixer.Info>(); |
| Iterator i = ServiceFactory.lookupProviders(MixerProvider.class); |
| while (i.hasNext()) |
| { |
| MixerProvider prov = (MixerProvider) i.next(); |
| Mixer.Info[] is = prov.getMixerInfo(); |
| for (int j = 0; j < is.length; ++j) |
| result.add(is[j]); |
| } |
| return result.toArray(new Mixer.Info[result.size()]); |
| } |
| |
| /** |
| * Return a source data line matching the given audio format. |
| * @param fmt the audio format |
| * @throws LineUnavailableException if no source data line matching |
| * this format is available |
| * @since 1.5 |
| */ |
| public static SourceDataLine getSourceDataLine(AudioFormat fmt) |
| throws LineUnavailableException |
| { |
| DataLine.Info info = new DataLine.Info(SourceDataLine.class, fmt); |
| Mixer.Info[] mixers = getMixerInfo(); |
| for (int i = 0; i < mixers.length; ++i) |
| { |
| Mixer mix = getMixer(mixers[i]); |
| if (mix.isLineSupported(info)) |
| return (SourceDataLine) mix.getLine(info); |
| } |
| throw new LineUnavailableException("source data line not found"); |
| } |
| |
| /** |
| * Return a target data line matching the given audio format. |
| * @param fmt the audio format |
| * @throws LineUnavailableException if no target data line matching |
| * this format is available |
| * @since 1.5 |
| */ |
| public static SourceDataLine getSourceDataLine(AudioFormat fmt, |
| Mixer.Info mixer) |
| throws LineUnavailableException |
| { |
| DataLine.Info info = new DataLine.Info(SourceDataLine.class, fmt); |
| Mixer mix = getMixer(mixer); |
| if (mix.isLineSupported(info)) |
| return (SourceDataLine) mix.getLine(info); |
| throw new LineUnavailableException("source data line not found"); |
| } |
| |
| /** |
| * Return an array of descriptions of all the source lines matching |
| * the given line description. |
| * @param info description of the lines to match |
| */ |
| public static Line.Info[] getSourceLineInfo(Line.Info info) |
| { |
| HashSet<Line.Info> result = new HashSet<Line.Info>(); |
| Mixer.Info[] infos = getMixerInfo(); |
| for (int i = 0; i < infos.length; ++i) |
| { |
| Mixer mix = getMixer(infos[i]); |
| Line.Info[] srcs = mix.getSourceLineInfo(info); |
| for (int j = 0; j < srcs.length; ++j) |
| result.add(srcs[j]); |
| } |
| return result.toArray(new Line.Info[result.size()]); |
| } |
| |
| /** |
| * Find and return a target data line matching the given audio format. |
| * @param fmt the format to match |
| * @throws LineUnavailableException if no matching line was found |
| * @since 1.5 |
| */ |
| public static TargetDataLine getTargetDataLine(AudioFormat fmt) |
| throws LineUnavailableException |
| { |
| DataLine.Info info = new DataLine.Info(TargetDataLine.class, fmt); |
| Mixer.Info[] mixers = getMixerInfo(); |
| for (int i = 0; i < mixers.length; ++i) |
| { |
| Mixer mix = getMixer(mixers[i]); |
| if (mix.isLineSupported(info)) |
| return (TargetDataLine) mix.getLine(info); |
| } |
| throw new LineUnavailableException("target data line not found"); |
| } |
| |
| /** |
| * Return a target data line matching the given audio format and |
| * mixer. |
| * @param fmt the audio format |
| * @param mixer the mixer description |
| * @return a target data line |
| * @throws LineUnavailableException if no matching target data line was |
| * found |
| * @since 1.5 |
| */ |
| public static TargetDataLine getTargetDataLine(AudioFormat fmt, |
| Mixer.Info mixer) |
| throws LineUnavailableException |
| { |
| DataLine.Info info = new DataLine.Info(TargetDataLine.class, fmt); |
| Mixer mix = getMixer(mixer); |
| if (mix.isLineSupported(info)) |
| return (TargetDataLine) mix.getLine(info); |
| throw new LineUnavailableException("target data line not found"); |
| } |
| |
| /** |
| * Given a source encoding, return an array of all target encodings to which |
| * data in this form can be converted. |
| * @param source the source encoding |
| */ |
| public static AudioFormat.Encoding[] getTargetEncodings(AudioFormat.Encoding source) |
| { |
| HashSet<AudioFormat.Encoding> result |
| = new HashSet<AudioFormat.Encoding>(); |
| Iterator i = ServiceFactory.lookupProviders(FormatConversionProvider.class); |
| while (i.hasNext()) |
| { |
| FormatConversionProvider prov = (FormatConversionProvider) i.next(); |
| if (! prov.isSourceEncodingSupported(source)) |
| continue; |
| AudioFormat.Encoding[] es = prov.getTargetEncodings(); |
| for (int j = 0; j < es.length; ++j) |
| result.add(es[j]); |
| } |
| return result.toArray(new AudioFormat.Encoding[result.size()]); |
| } |
| |
| /** |
| * Given a source format, return an array of all the target encodings to |
| * which data in this format can be converted. |
| * @param source the source format |
| */ |
| public static AudioFormat.Encoding[] getTargetEncodings(AudioFormat source) |
| { |
| HashSet<AudioFormat.Encoding> result |
| = new HashSet<AudioFormat.Encoding>(); |
| Iterator i = ServiceFactory.lookupProviders(FormatConversionProvider.class); |
| while (i.hasNext()) |
| { |
| FormatConversionProvider prov = (FormatConversionProvider) i.next(); |
| AudioFormat.Encoding[] es = prov.getTargetEncodings(source); |
| for (int j = 0; j < es.length; ++j) |
| result.add(es[j]); |
| } |
| return result.toArray(new AudioFormat.Encoding[result.size()]); |
| } |
| |
| /** |
| * Given a target encoding and a source audio format, return an array of all |
| * matching audio formats to which data in this source format can be converted. |
| * @param encoding the target encoding |
| * @param sourceFmt the source format |
| */ |
| public static AudioFormat[] getTargetFormats(AudioFormat.Encoding encoding, |
| AudioFormat sourceFmt) |
| { |
| HashSet<AudioFormat> result = new HashSet<AudioFormat>(); |
| Iterator i = ServiceFactory.lookupProviders(FormatConversionProvider.class); |
| while (i.hasNext()) |
| { |
| FormatConversionProvider prov = (FormatConversionProvider) i.next(); |
| AudioFormat[] es = prov.getTargetFormats(encoding, sourceFmt); |
| for (int j = 0; j < es.length; ++j) |
| result.add(es[j]); |
| } |
| return result.toArray(new AudioFormat[result.size()]); |
| } |
| |
| /** |
| * Given a line description, return an array of descriptions of all |
| * the matching target lines. |
| * @param info the line description |
| */ |
| public static Line.Info[] getTargetLineInfo(Line.Info info) |
| { |
| HashSet<Line.Info> result = new HashSet<Line.Info>(); |
| Mixer.Info[] infos = getMixerInfo(); |
| for (int i = 0; i < infos.length; ++i) |
| { |
| Mixer mix = getMixer(infos[i]); |
| Line.Info[] targs = mix.getTargetLineInfo(info); |
| for (int j = 0; j < targs.length; ++j) |
| result.add(targs[j]); |
| } |
| return result.toArray(new Line.Info[result.size()]); |
| } |
| |
| /** |
| * Return true if the currently installed providers are able to |
| * convert data from the given source format to the given target encoding. |
| * @param targ the target encoding |
| * @param source the source format |
| */ |
| public static boolean isConversionSupported(AudioFormat.Encoding targ, |
| AudioFormat source) |
| { |
| Iterator i |
| = ServiceFactory.lookupProviders(FormatConversionProvider.class); |
| while (i.hasNext()) |
| { |
| FormatConversionProvider prov = (FormatConversionProvider) i.next(); |
| if (prov.isConversionSupported(targ, source)) |
| return true; |
| } |
| return false; |
| } |
| |
| /** |
| * Return true if the currently installed providers are able to convert |
| * the given source format to the given target format. |
| * @param targ the target format |
| * @param source the source format |
| */ |
| public static boolean isConversionSupported(AudioFormat targ, |
| AudioFormat source) |
| { |
| Iterator i |
| = ServiceFactory.lookupProviders(FormatConversionProvider.class); |
| while (i.hasNext()) |
| { |
| FormatConversionProvider prov = (FormatConversionProvider) i.next(); |
| if (prov.isConversionSupported(targ, source)) |
| return true; |
| } |
| return false; |
| } |
| |
| private static boolean isFileTypeSupported(AudioFileFormat.Type[] types, |
| AudioFileFormat.Type type) |
| { |
| for (int i = 0; i < types.length; ++i) |
| { |
| if (types[i].equals(type)) |
| return true; |
| } |
| return false; |
| } |
| |
| /** |
| * Return true if the given audio file format is supported by one of |
| * the providers installed on the system. |
| * @param type the audio file format type |
| */ |
| public static boolean isFileTypeSupported(AudioFileFormat.Type type) |
| { |
| return isFileTypeSupported(getAudioFileTypes(), type); |
| } |
| |
| /** |
| * Return true if the given audio file format is supported for the |
| * given audio input stream by one of the providers installed on the |
| * system. |
| * @param type the audio file format type |
| * @param ais the audio input stream |
| */ |
| public static boolean isFileTypeSupported(AudioFileFormat.Type type, |
| AudioInputStream ais) |
| { |
| return isFileTypeSupported(getAudioFileTypes(ais), type); |
| } |
| |
| /** |
| * Return true if some provider on the system supplies a line |
| * matching the argument. |
| * @param info the line to match |
| */ |
| public static boolean isLineSupported(Line.Info info) |
| { |
| Mixer.Info[] infos = getMixerInfo(); |
| for (int i = 0; i < infos.length; ++i) |
| { |
| if (getMixer(infos[i]).isLineSupported(info)) |
| return true; |
| } |
| return false; |
| } |
| |
| /** |
| * Write an audio input stream to the given file, using the specified |
| * audio file format. All the providers installed on the system will |
| * be searched to find one that supports this operation. |
| * @param ais the audio input stream to write |
| * @param type the desired audio file format type |
| * @param out the file to write to |
| * @return the number of bytes written |
| * @throws IOException if an I/O error occurs while writing |
| * @throws IllegalArgumentException if the file type is not supported |
| */ |
| public static int write(AudioInputStream ais, AudioFileFormat.Type type, |
| File out) |
| throws IOException |
| { |
| Iterator i = ServiceFactory.lookupProviders(AudioFileWriter.class); |
| while (i.hasNext()) |
| { |
| AudioFileWriter w = (AudioFileWriter) i.next(); |
| if (w.isFileTypeSupported(type, ais)) |
| return w.write(ais, type, out); |
| } |
| throw new IllegalArgumentException("file type not supported by system"); |
| } |
| |
| /** |
| * Write an audio input stream to the given output stream, using the |
| * specified audio file format. All the providers installed on the |
| * system will be searched to find one that supports this operation. |
| * @param ais the audio input stream to write |
| * @param type the desired audio file format type |
| * @param os the output stream to write to |
| * @return the number of bytes written |
| * @throws IOException if an I/O error occurs while writing |
| * @throws IllegalArgumentException if the file type is not supported |
| */ |
| public static int write(AudioInputStream ais, AudioFileFormat.Type type, |
| OutputStream os) |
| throws IOException |
| { |
| Iterator i = ServiceFactory.lookupProviders(AudioFileWriter.class); |
| while (i.hasNext()) |
| { |
| AudioFileWriter w = (AudioFileWriter) i.next(); |
| if (w.isFileTypeSupported(type, ais)) |
| return w.write(ais, type, os); |
| } |
| throw new IllegalArgumentException("file type not supported by system"); |
| } |
| } |