| Methods Summary |
|---|
| public static javax.sound.sampled.AudioFileFormat | getAudioFileFormat(java.io.InputStream stream)Obtains the audio file format of the provided input stream. The stream must
point to valid audio file data. The implementation of this method may require
multiple parsers to examine the stream to determine whether they support it.
These parsers must be able to mark the stream, read enough data to determine whether they
support the stream, and, if not, reset the stream's read pointer to its original
position. If the input stream does not support these operations, this method may fail
with an IOException.
List providers = getAudioFileReaders();
AudioFileFormat format = null;
for(int i = 0; i < providers.size(); i++ ) {
AudioFileReader reader = (AudioFileReader) providers.get(i);
try {
format = reader.getAudioFileFormat( stream ); // throws IOException
break;
} catch (UnsupportedAudioFileException e) {
continue;
}
}
if( format==null ) {
throw new UnsupportedAudioFileException("file is not a supported file type");
} else {
return format;
}
|
| public static javax.sound.sampled.AudioFileFormat | getAudioFileFormat(java.net.URL url)Obtains the audio file format of the specified URL. The URL must
point to valid audio file data.
List providers = getAudioFileReaders();
AudioFileFormat format = null;
for(int i = 0; i < providers.size(); i++ ) {
AudioFileReader reader = (AudioFileReader) providers.get(i);
try {
format = reader.getAudioFileFormat( url ); // throws IOException
break;
} catch (UnsupportedAudioFileException e) {
continue;
}
}
if( format==null ) {
throw new UnsupportedAudioFileException("file is not a supported file type");
} else {
return format;
}
|
| public static javax.sound.sampled.AudioFileFormat | getAudioFileFormat(java.io.File file)Obtains the audio file format of the specified File. The File must
point to valid audio file data.
List providers = getAudioFileReaders();
AudioFileFormat format = null;
for(int i = 0; i < providers.size(); i++ ) {
AudioFileReader reader = (AudioFileReader) providers.get(i);
try {
format = reader.getAudioFileFormat( file ); // throws IOException
break;
} catch (UnsupportedAudioFileException e) {
continue;
}
}
if( format==null ) {
throw new UnsupportedAudioFileException("file is not a supported file type");
} else {
return format;
}
|
| private static java.util.List | getAudioFileReaders()Obtains the set of audio file readers that are currently installed on the system.
return getProviders(AudioFileReader.class);
|
| public static javax.sound.sampled.AudioFileFormat$Type[] | getAudioFileTypes()Obtains the file types for which file writing support is provided by the system.
List providers = getAudioFileWriters();
Set returnTypesSet = new HashSet();
for(int i=0; i < providers.size(); i++) {
AudioFileWriter writer = (AudioFileWriter) providers.get(i);
AudioFileFormat.Type[] fileTypes = writer.getAudioFileTypes();
for(int j=0; j < fileTypes.length; j++) {
returnTypesSet.add(fileTypes[j]);
}
}
AudioFileFormat.Type returnTypes[] = (AudioFileFormat.Type[])
returnTypesSet.toArray(new AudioFileFormat.Type[0]);
return returnTypes;
|
| public static javax.sound.sampled.AudioFileFormat$Type[] | getAudioFileTypes(javax.sound.sampled.AudioInputStream stream)Obtains the file types that the system can write from the
audio input stream specified.
List providers = getAudioFileWriters();
Set returnTypesSet = new HashSet();
for(int i=0; i < providers.size(); i++) {
AudioFileWriter writer = (AudioFileWriter) providers.get(i);
AudioFileFormat.Type[] fileTypes = writer.getAudioFileTypes(stream);
for(int j=0; j < fileTypes.length; j++) {
returnTypesSet.add(fileTypes[j]);
}
}
AudioFileFormat.Type returnTypes[] = (AudioFileFormat.Type[])
returnTypesSet.toArray(new AudioFileFormat.Type[0]);
return returnTypes;
|
| private static java.util.List | getAudioFileWriters()Obtains the set of audio file writers that are currently installed on the system.
return getProviders(AudioFileWriter.class);
|
| public static javax.sound.sampled.AudioInputStream | getAudioInputStream(javax.sound.sampled.AudioFormat$Encoding targetEncoding, javax.sound.sampled.AudioInputStream sourceStream)Obtains an audio input stream of the indicated encoding, by converting the
provided audio input stream.
List codecs = getFormatConversionProviders();
for(int i = 0; i < codecs.size(); i++) {
FormatConversionProvider codec = (FormatConversionProvider) codecs.get(i);
if( codec.isConversionSupported( targetEncoding, sourceStream.getFormat() ) ) {
return codec.getAudioInputStream( targetEncoding, sourceStream );
}
}
// we ran out of options, throw an exception
throw new IllegalArgumentException("Unsupported conversion: " + targetEncoding + " from " + sourceStream.getFormat());
|
| public static javax.sound.sampled.AudioInputStream | getAudioInputStream(javax.sound.sampled.AudioFormat targetFormat, javax.sound.sampled.AudioInputStream sourceStream)Obtains an audio input stream of the indicated format, by converting the
provided audio input stream.
if (sourceStream.getFormat().matches(targetFormat)) {
return sourceStream;
}
List codecs = getFormatConversionProviders();
for(int i = 0; i < codecs.size(); i++) {
FormatConversionProvider codec = (FormatConversionProvider) codecs.get(i);
if(codec.isConversionSupported(targetFormat,sourceStream.getFormat()) ) {
return codec.getAudioInputStream(targetFormat,sourceStream);
}
}
// we ran out of options...
throw new IllegalArgumentException("Unsupported conversion: " + targetFormat + " from " + sourceStream.getFormat());
|
| public static javax.sound.sampled.AudioInputStream | getAudioInputStream(java.io.InputStream stream)Obtains an audio input stream from the provided input stream. The stream must
point to valid audio file data. The implementation of this method may
require multiple parsers to
examine the stream to determine whether they support it. These parsers must
be able to mark the stream, read enough data to determine whether they
support the stream, and, if not, reset the stream's read pointer to its original
position. If the input stream does not support these operation, this method may fail
with an IOException.
List providers = getAudioFileReaders();
AudioInputStream audioStream = null;
for(int i = 0; i < providers.size(); i++ ) {
AudioFileReader reader = (AudioFileReader) providers.get(i);
try {
audioStream = reader.getAudioInputStream( stream ); // throws IOException
break;
} catch (UnsupportedAudioFileException e) {
continue;
}
}
if( audioStream==null ) {
throw new UnsupportedAudioFileException("could not get audio input stream from input stream");
} else {
return audioStream;
}
|
| public static javax.sound.sampled.AudioInputStream | getAudioInputStream(java.net.URL url)Obtains an audio input stream from the URL provided. The URL must
point to valid audio file data.
List providers = getAudioFileReaders();
AudioInputStream audioStream = null;
for(int i = 0; i < providers.size(); i++ ) {
AudioFileReader reader = (AudioFileReader) providers.get(i);
try {
audioStream = reader.getAudioInputStream( url ); // throws IOException
break;
} catch (UnsupportedAudioFileException e) {
continue;
}
}
if( audioStream==null ) {
throw new UnsupportedAudioFileException("could not get audio input stream from input URL");
} else {
return audioStream;
}
|
| public static javax.sound.sampled.AudioInputStream | getAudioInputStream(java.io.File file)Obtains an audio input stream from the provided File. The File must
point to valid audio file data.
List providers = getAudioFileReaders();
AudioInputStream audioStream = null;
for(int i = 0; i < providers.size(); i++ ) {
AudioFileReader reader = (AudioFileReader) providers.get(i);
try {
audioStream = reader.getAudioInputStream( file ); // throws IOException
break;
} catch (UnsupportedAudioFileException e) {
continue;
}
}
if( audioStream==null ) {
throw new UnsupportedAudioFileException("could not get audio input stream from input file");
} else {
return audioStream;
}
|
| public static javax.sound.sampled.Clip | getClip()Obtains a clip that can be used for playing back
an audio file or an audio stream. The returned clip
will be provided by the default system mixer, or,
if not possible, by any other mixer installed in the
system that supports a Clip
object.
The returned clip must be opened with the
open(AudioFormat) or
open(AudioInputStream) method.
This is a high-level method that uses getMixer
and getLine internally.
If the system property
javax.sound.sampled.Clip
is defined or it is defined in the file "sound.properties",
it is used to retrieve the default clip.
For details, refer to the {@link AudioSystem class description}.
AudioFormat format = new AudioFormat(AudioFormat.Encoding.PCM_SIGNED,
AudioSystem.NOT_SPECIFIED,
16, 2, 4,
AudioSystem.NOT_SPECIFIED, true);
DataLine.Info info = new DataLine.Info(Clip.class, format);
return (Clip) AudioSystem.getLine(info);
|
| public static javax.sound.sampled.Clip | getClip(javax.sound.sampled.Mixer$Info mixerInfo)Obtains a clip from the specified mixer that can be
used for playing back an audio file or an audio stream.
The returned clip must be opened with the
open(AudioFormat) or
open(AudioInputStream) method.
This is a high-level method that uses getMixer
and getLine internally.
AudioFormat format = new AudioFormat(AudioFormat.Encoding.PCM_SIGNED,
AudioSystem.NOT_SPECIFIED,
16, 2, 4,
AudioSystem.NOT_SPECIFIED, true);
DataLine.Info info = new DataLine.Info(Clip.class, format);
Mixer mixer = AudioSystem.getMixer(mixerInfo);
return (Clip) mixer.getLine(info);
|
| private static javax.sound.sampled.Mixer | getDefaultMixer(java.util.List providers, javax.sound.sampled.Line$Info info)Attempts to locate and return a default Mixer that provides lines
of the specified type.
Class lineClass = info.getLineClass();
String providerClassName = JDK13Services.getDefaultProviderClassName(lineClass);
String instanceName = JDK13Services.getDefaultInstanceName(lineClass);
Mixer mixer;
if (providerClassName != null) {
MixerProvider defaultProvider = getNamedProvider(providerClassName, providers);
if (defaultProvider != null) {
if (instanceName != null) {
mixer = getNamedMixer(instanceName, defaultProvider, info);
if (mixer != null) {
return mixer;
}
} else {
mixer = getFirstMixer(defaultProvider, info,
false /* mixing not required*/);
if (mixer != null) {
return mixer;
}
}
}
}
/* Provider class not specified or
provider class cannot be found, or
provider class and instance specified and instance cannot be found or is not appropriate */
if (instanceName != null) {
mixer = getNamedMixer(instanceName, providers, info);
if (mixer != null) {
return mixer;
}
}
/* No default are specified, or if something is specified, everything
failed. */
return null;
|
| private static javax.sound.sampled.Mixer | getFirstMixer(javax.sound.sampled.spi.MixerProvider provider, javax.sound.sampled.Line$Info info, boolean isMixingRequired)From a given MixerProvider, return the first appropriate Mixer.
Mixer.Info[] infos = provider.getMixerInfo();
for (int j = 0; j < infos.length; j++) {
Mixer mixer = provider.getMixer(infos[j]);
if (isAppropriateMixer(mixer, info, isMixingRequired)) {
return mixer;
}
}
return null;
|
| private static java.util.List | getFormatConversionProviders()Obtains the set of format converters (codecs, transcoders, etc.)
that are currently installed on the system.
return getProviders(FormatConversionProvider.class);
|
| public static javax.sound.sampled.Line | getLine(javax.sound.sampled.Line$Info info)Obtains a line that matches the description in the specified
Line.Info object.
If a DataLine is requested, and info
is an instance of DataLine.Info specifying at least
one fully qualified audio format, the last one
will be used as the default format of the returned
DataLine.
If system properties
javax.sound.sampled.Clip,
javax.sound.sampled.Port,
javax.sound.sampled.SourceDataLine and
javax.sound.sampled.TargetDataLine are defined
or they are defined in the file "sound.properties",
they are used to retrieve default lines.
For details, refer to the {@link AudioSystem class description}.
If the respective property is not set, or the mixer
requested in the property is not installed or does not provide the
requested line, all installed mixers are queried for the
requested line type. A Line will be returned from the first mixer
providing the requested line type.
LineUnavailableException lue = null;
List providers = getMixerProviders();
// 1: try from default mixer for this line class
try {
Mixer mixer = getDefaultMixer(providers, info);
if (mixer != null && mixer.isLineSupported(info)) {
return mixer.getLine(info);
}
} catch (LineUnavailableException e) {
lue = e;
} catch (IllegalArgumentException iae) {
// must not happen... but better to catch it here,
// if plug-ins are badly written
}
// 2: if that doesn't work, try to find any mixing mixer
for(int i = 0; i < providers.size(); i++) {
MixerProvider provider = (MixerProvider) providers.get(i);
Mixer.Info[] infos = provider.getMixerInfo();
for (int j = 0; j < infos.length; j++) {
try {
Mixer mixer = provider.getMixer(infos[j]);
// see if this is an appropriate mixer which can mix
if (isAppropriateMixer(mixer, info, true)) {
return mixer.getLine(info);
}
} catch (LineUnavailableException e) {
lue = e;
} catch (IllegalArgumentException iae) {
// must not happen... but better to catch it here,
// if plug-ins are badly written
}
}
}
// 3: if that didn't work, try to find any non-mixing mixer
for(int i = 0; i < providers.size(); i++) {
MixerProvider provider = (MixerProvider) providers.get(i);
Mixer.Info[] infos = provider.getMixerInfo();
for (int j = 0; j < infos.length; j++) {
try {
Mixer mixer = provider.getMixer(infos[j]);
// see if this is an appropriate mixer which can mix
if (isAppropriateMixer(mixer, info, false)) {
return mixer.getLine(info);
}
} catch (LineUnavailableException e) {
lue = e;
} catch (IllegalArgumentException iae) {
// must not happen... but better to catch it here,
// if plug-ins are badly written
}
}
}
// if this line was supported but was not available, throw the last
// LineUnavailableException we got (??).
if (lue != null) {
throw lue;
}
// otherwise, the requested line was not supported, so throw
// an Illegal argument exception
throw new IllegalArgumentException("No line matching " +
info.toString() + " is supported.");
|
| public static javax.sound.sampled.Mixer | getMixer(javax.sound.sampled.Mixer$Info info)Obtains the requested audio mixer.
Mixer mixer = null;
List providers = getMixerProviders();
for(int i = 0; i < providers.size(); i++ ) {
try {
return ((MixerProvider)providers.get(i)).getMixer(info);
} catch (IllegalArgumentException e) {
} catch (NullPointerException e) {
// $$jb 08.20.99: If the strings in the info object aren't
// set, then Netscape (using jdk1.1.5) tends to throw
// NPE's when doing some string manipulation. This is
// probably not the best fix, but is solves the problem
// of the NPE in Netscape using local classes
// $$jb 11.01.99: Replacing this patch.
}
}
//$$fb if looking for default mixer, and not found yet, add a round of looking
if (info == null) {
for(int i = 0; i < providers.size(); i++ ) {
try {
MixerProvider provider = (MixerProvider) providers.get(i);
Mixer.Info[] infos = provider.getMixerInfo();
// start from 0 to last device (do not reverse this order)
for (int ii = 0; ii < infos.length; ii++) {
try {
return provider.getMixer(infos[ii]);
} catch (IllegalArgumentException e) {
// this is not a good default device :)
}
}
} catch (IllegalArgumentException e) {
} catch (NullPointerException e) {
}
}
}
throw new IllegalArgumentException("Mixer not supported: "
+ (info!=null?info.toString():"null"));
|
| public static javax.sound.sampled.Mixer$Info[] | getMixerInfo()Obtains an array of mixer info objects that represents
the set of audio mixers that are currently installed on the system.
List infos = getMixerInfoList();
Mixer.Info[] allInfos = (Mixer.Info[]) infos.toArray(new Mixer.Info[infos.size()]);
return allInfos;
|
| private static java.util.List | getMixerInfoList()Like getMixerInfo, but return List
List providers = getMixerProviders();
return getMixerInfoList(providers);
|
| private static java.util.List | getMixerInfoList(java.util.List providers)Like getMixerInfo, but return List
List infos = new ArrayList();
Mixer.Info[] someInfos; // per-mixer
Mixer.Info[] allInfos; // for all mixers
for(int i = 0; i < providers.size(); i++ ) {
someInfos = (Mixer.Info[])
((MixerProvider)providers.get(i)).getMixerInfo();
for (int j = 0; j < someInfos.length; j++) {
infos.add(someInfos[j]);
}
}
return infos;
|
| private static java.util.List | getMixerProviders()Obtains the set of MixerProviders on the system.
return getProviders(MixerProvider.class);
|
| private static javax.sound.sampled.Mixer | getNamedMixer(java.lang.String mixerName, javax.sound.sampled.spi.MixerProvider provider, javax.sound.sampled.Line$Info info)Return a Mixer with a given name from a given MixerProvider.
This method never requires the returned Mixer to do mixing.
Mixer.Info[] infos = provider.getMixerInfo();
for (int i = 0; i < infos.length; i++) {
if (infos[i].getName().equals(mixerName)) {
Mixer mixer = provider.getMixer(infos[i]);
if (isAppropriateMixer(mixer, info, false)) {
return mixer;
}
}
}
return null;
|
| private static javax.sound.sampled.Mixer | getNamedMixer(java.lang.String mixerName, java.util.List providers, javax.sound.sampled.Line$Info info)From a List of MixerProviders, return a Mixer with a given name.
This method never requires the returned Mixer to do mixing.
for(int i = 0; i < providers.size(); i++) {
MixerProvider provider = (MixerProvider) providers.get(i);
Mixer mixer = getNamedMixer(mixerName, provider, info);
if (mixer != null) {
return mixer;
}
}
return null;
|
| private static javax.sound.sampled.spi.MixerProvider | getNamedProvider(java.lang.String providerClassName, java.util.List providers)Return a MixerProvider of a given class from the list of
MixerProviders.
This method never requires the returned Mixer to do mixing.
for(int i = 0; i < providers.size(); i++) {
MixerProvider provider = (MixerProvider) providers.get(i);
if (provider.getClass().getName().equals(providerClassName)) {
return provider;
}
}
return null;
|
| private static java.util.List | getProviders(java.lang.Class providerClass)Obtains the set of services currently installed on the system
using sun.misc.Service, the SPI mechanism in 1.3.
return JDK13Services.getProviders(providerClass);
|
| public static javax.sound.sampled.SourceDataLine | getSourceDataLine(javax.sound.sampled.AudioFormat format)Obtains a source data line that can be used for playing back
audio data in the format specified by the
AudioFormat object. The returned line
will be provided by the default system mixer, or,
if not possible, by any other mixer installed in the
system that supports a matching
SourceDataLine object.
The returned line should be opened with the
open(AudioFormat) or
open(AudioFormat, int) method.
This is a high-level method that uses getMixer
and getLine internally.
The returned SourceDataLine's default
audio format will be initialized with format.
If the system property
javax.sound.sampled.SourceDataLine
is defined or it is defined in the file "sound.properties",
it is used to retrieve the default source data line.
For details, refer to the {@link AudioSystem class description}.
DataLine.Info info = new DataLine.Info(SourceDataLine.class, format);
return (SourceDataLine) AudioSystem.getLine(info);
|
| public static javax.sound.sampled.SourceDataLine | getSourceDataLine(javax.sound.sampled.AudioFormat format, javax.sound.sampled.Mixer$Info mixerinfo)Obtains a source data line that can be used for playing back
audio data in the format specified by the
AudioFormat object, provided by the mixer
specified by the Mixer.Info object.
The returned line should be opened with the
open(AudioFormat) or
open(AudioFormat, int) method.
This is a high-level method that uses getMixer
and getLine internally.
The returned SourceDataLine's default
audio format will be initialized with format.
DataLine.Info info = new DataLine.Info(SourceDataLine.class, format);
Mixer mixer = AudioSystem.getMixer(mixerinfo);
return (SourceDataLine) mixer.getLine(info);
|
| public static javax.sound.sampled.Line$Info[] | getSourceLineInfo(javax.sound.sampled.Line$Info info)Obtains information about all source lines of a particular type that are supported
by the installed mixers.
Vector vector = new Vector();
Line.Info[] currentInfoArray;
Mixer mixer;
Line.Info fullInfo = null;
Mixer.Info[] infoArray = getMixerInfo();
for (int i = 0; i < infoArray.length; i++) {
mixer = getMixer(infoArray[i]);
currentInfoArray = mixer.getSourceLineInfo(info);
for (int j = 0; j < currentInfoArray.length; j++) {
vector.addElement(currentInfoArray[j]);
}
}
Line.Info[] returnedArray = new Line.Info[vector.size()];
for (int i = 0; i < returnedArray.length; i++) {
returnedArray[i] = (Line.Info)vector.get(i);
}
return returnedArray;
|
| public static javax.sound.sampled.TargetDataLine | getTargetDataLine(javax.sound.sampled.AudioFormat format)Obtains a target data line that can be used for recording
audio data in the format specified by the
AudioFormat object. The returned line
will be provided by the default system mixer, or,
if not possible, by any other mixer installed in the
system that supports a matching
TargetDataLine object.
The returned line should be opened with the
open(AudioFormat) or
open(AudioFormat, int) method.
This is a high-level method that uses getMixer
and getLine internally.
The returned TargetDataLine's default
audio format will be initialized with format.
DataLine.Info info = new DataLine.Info(TargetDataLine.class, format);
return (TargetDataLine) AudioSystem.getLine(info);
|
| public static javax.sound.sampled.TargetDataLine | getTargetDataLine(javax.sound.sampled.AudioFormat format, javax.sound.sampled.Mixer$Info mixerinfo)Obtains a target data line that can be used for recording
audio data in the format specified by the
AudioFormat object, provided by the mixer
specified by the Mixer.Info object.
The returned line should be opened with the
open(AudioFormat) or
open(AudioFormat, int) method.
This is a high-level method that uses getMixer
and getLine internally.
The returned TargetDataLine's default
audio format will be initialized with format.
If the system property
javax.sound.sampled.TargetDataLine
is defined or it is defined in the file "sound.properties",
it is used to retrieve the default target data line.
For details, refer to the {@link AudioSystem class description}.
DataLine.Info info = new DataLine.Info(TargetDataLine.class, format);
Mixer mixer = AudioSystem.getMixer(mixerinfo);
return (TargetDataLine) mixer.getLine(info);
|
| public static javax.sound.sampled.AudioFormat$Encoding[] | getTargetEncodings(javax.sound.sampled.AudioFormat$Encoding sourceEncoding)Obtains the encodings that the system can obtain from an
audio input stream with the specified encoding using the set
of installed format converters.
List codecs = getFormatConversionProviders();
Vector encodings = new Vector();
AudioFormat.Encoding encs[] = null;
// gather from all the codecs
for(int i=0; i<codecs.size(); i++ ) {
FormatConversionProvider codec = (FormatConversionProvider) codecs.get(i);
if( codec.isSourceEncodingSupported( sourceEncoding ) ) {
encs = codec.getTargetEncodings();
for (int j = 0; j < encs.length; j++) {
encodings.addElement( encs[j] );
}
}
}
AudioFormat.Encoding encs2[] = (AudioFormat.Encoding[]) encodings.toArray(new AudioFormat.Encoding[0]);
return encs2;
|
| public static javax.sound.sampled.AudioFormat$Encoding[] | getTargetEncodings(javax.sound.sampled.AudioFormat sourceFormat)Obtains the encodings that the system can obtain from an
audio input stream with the specified format using the set
of installed format converters.
List codecs = getFormatConversionProviders();
Vector encodings = new Vector();
int size = 0;
int index = 0;
AudioFormat.Encoding encs[] = null;
// gather from all the codecs
for(int i=0; i<codecs.size(); i++ ) {
encs = ((FormatConversionProvider) codecs.get(i)).getTargetEncodings(sourceFormat);
size += encs.length;
encodings.addElement( encs );
}
// now build a new array
AudioFormat.Encoding encs2[] = new AudioFormat.Encoding[size];
for(int i=0; i<encodings.size(); i++ ) {
encs = (AudioFormat.Encoding [])(encodings.get(i));
for(int j=0; j<encs.length; j++ ) {
encs2[index++] = encs[j];
}
}
return encs2;
|
| public static javax.sound.sampled.AudioFormat[] | getTargetFormats(javax.sound.sampled.AudioFormat$Encoding targetEncoding, javax.sound.sampled.AudioFormat sourceFormat)Obtains the formats that have a particular encoding and that the system can
obtain from a stream of the specified format using the set of
installed format converters.
List codecs = getFormatConversionProviders();
Vector formats = new Vector();
int size = 0;
int index = 0;
AudioFormat fmts[] = null;
// gather from all the codecs
for(int i=0; i<codecs.size(); i++ ) {
FormatConversionProvider codec = (FormatConversionProvider) codecs.get(i);
fmts = codec.getTargetFormats(targetEncoding, sourceFormat);
size += fmts.length;
formats.addElement( fmts );
}
// now build a new array
AudioFormat fmts2[] = new AudioFormat[size];
for(int i=0; i<formats.size(); i++ ) {
fmts = (AudioFormat [])(formats.get(i));
for(int j=0; j<fmts.length; j++ ) {
fmts2[index++] = fmts[j];
}
}
return fmts2;
|
| public static javax.sound.sampled.Line$Info[] | getTargetLineInfo(javax.sound.sampled.Line$Info info)Obtains information about all target lines of a particular type that are supported
by the installed mixers.
Vector vector = new Vector();
Line.Info[] currentInfoArray;
Mixer mixer;
Line.Info fullInfo = null;
Mixer.Info[] infoArray = getMixerInfo();
for (int i = 0; i < infoArray.length; i++) {
mixer = getMixer(infoArray[i]);
currentInfoArray = mixer.getTargetLineInfo(info);
for (int j = 0; j < currentInfoArray.length; j++) {
vector.addElement(currentInfoArray[j]);
}
}
Line.Info[] returnedArray = new Line.Info[vector.size()];
for (int i = 0; i < returnedArray.length; i++) {
returnedArray[i] = (Line.Info)vector.get(i);
}
return returnedArray;
|
| private static boolean | isAppropriateMixer(javax.sound.sampled.Mixer mixer, javax.sound.sampled.Line$Info lineInfo, boolean isMixingRequired)Checks if a Mixer is appropriate.
A Mixer is considered appropriate if it support the given line type.
If isMixingRequired is true and the line type is an output one
(SourceDataLine, Clip), the mixer is appropriate if it supports
at least 2 (concurrent) lines of the given type.
if (! mixer.isLineSupported(lineInfo)) {
return false;
}
Class lineClass = lineInfo.getLineClass();
if (isMixingRequired
&& (SourceDataLine.class.isAssignableFrom(lineClass) ||
Clip.class.isAssignableFrom(lineClass))) {
int maxLines = mixer.getMaxLines(lineInfo);
return ((maxLines == NOT_SPECIFIED) || (maxLines > 1));
}
return true;
|
| public static boolean | isConversionSupported(javax.sound.sampled.AudioFormat$Encoding targetEncoding, javax.sound.sampled.AudioFormat sourceFormat)Indicates whether an audio input stream of the specified encoding
can be obtained from an audio input stream that has the specified
format.
List codecs = getFormatConversionProviders();
for(int i=0; i<codecs.size(); i++ ) {
FormatConversionProvider codec = (FormatConversionProvider) codecs.get(i);
if(codec.isConversionSupported(targetEncoding,sourceFormat) ) {
return true;
}
}
return false;
|
| public static boolean | isConversionSupported(javax.sound.sampled.AudioFormat targetFormat, javax.sound.sampled.AudioFormat sourceFormat)Indicates whether an audio input stream of a specified format
can be obtained from an audio input stream of another specified format.
List codecs = getFormatConversionProviders();
for(int i=0; i<codecs.size(); i++ ) {
FormatConversionProvider codec = (FormatConversionProvider) codecs.get(i);
if(codec.isConversionSupported(targetFormat, sourceFormat) ) {
return true;
}
}
return false;
|
| public static boolean | isFileTypeSupported(javax.sound.sampled.AudioFileFormat$Type fileType)Indicates whether file writing support for the specified file type is provided
by the system.
List providers = getAudioFileWriters();
for(int i=0; i < providers.size(); i++) {
AudioFileWriter writer = (AudioFileWriter) providers.get(i);
if (writer.isFileTypeSupported(fileType)) {
return true;
}
}
return false;
|
| public static boolean | isFileTypeSupported(javax.sound.sampled.AudioFileFormat$Type fileType, javax.sound.sampled.AudioInputStream stream)Indicates whether an audio file of the specified file type can be written
from the indicated audio input stream.
List providers = getAudioFileWriters();
for(int i=0; i < providers.size(); i++) {
AudioFileWriter writer = (AudioFileWriter) providers.get(i);
if(writer.isFileTypeSupported(fileType, stream)) {
return true;
}
}
return false;
|
| public static boolean | isLineSupported(javax.sound.sampled.Line$Info info)Indicates whether the system supports any lines that match
the specified Line.Info object. A line is supported if
any installed mixer supports it.
Mixer mixer;
Mixer.Info[] infoArray = getMixerInfo();
for (int i = 0; i < infoArray.length; i++) {
if( infoArray[i] != null ) {
mixer = getMixer(infoArray[i]);
if (mixer.isLineSupported(info)) {
return true;
}
}
}
return false;
|
| public static int | write(javax.sound.sampled.AudioInputStream stream, javax.sound.sampled.AudioFileFormat$Type fileType, java.io.OutputStream out)Writes a stream of bytes representing an audio file of the specified file type
to the output stream provided. Some file types require that
the length be written into the file header; such files cannot be written from
start to finish unless the length is known in advance. An attempt
to write a file of such a type will fail with an IOException if the length in
the audio file type is AudioSystem.NOT_SPECIFIED.
List providers = getAudioFileWriters();
int bytesWritten = 0;
boolean flag = false;
for(int i=0; i < providers.size(); i++) {
AudioFileWriter writer = (AudioFileWriter) providers.get(i);
try {
bytesWritten = writer.write( stream, fileType, out ); // throws IOException
flag = true;
break;
} catch (IllegalArgumentException e) {
// thrown if this provider cannot write the sequence, try the next
continue;
}
}
if(!flag) {
throw new IllegalArgumentException("could not write audio file: file type not supported: " + fileType);
} else {
return bytesWritten;
}
|
| public static int | write(javax.sound.sampled.AudioInputStream stream, javax.sound.sampled.AudioFileFormat$Type fileType, java.io.File out)Writes a stream of bytes representing an audio file of the specified file type
to the external file provided.
List providers = getAudioFileWriters();
int bytesWritten = 0;
boolean flag = false;
for(int i=0; i < providers.size(); i++) {
AudioFileWriter writer = (AudioFileWriter) providers.get(i);
try {
bytesWritten = writer.write( stream, fileType, out ); // throws IOException
flag = true;
break;
} catch (IllegalArgumentException e) {
// thrown if this provider cannot write the sequence, try the next
continue;
}
}
if (!flag) {
throw new IllegalArgumentException("could not write audio file: file type not supported: " + fileType);
} else {
return bytesWritten;
}
|
