You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@harmony.apache.org by ml...@apache.org on 2007/02/19 12:42:23 UTC
svn commit: r509169 - in /harmony/enhanced/classlib/trunk/modules/sound: ./
src/main/java/javax/sound/sampled/
src/main/java/org/apache/harmony/sound/internal/nls/
src/main/java/org/apache/harmony/sound/utils/
src/test/java/org/apache/harmony/sound/tes...
Author: mloenko
Date: Mon Feb 19 03:42:22 2007
New Revision: 509169
URL: http://svn.apache.org/viewvc?view=rev&rev=509169
Log:
integrated HARMONY-3125
[classlib][sound] javax.sound.sampled.AudioSystem implementation and tests
Added:
harmony/enhanced/classlib/trunk/modules/sound/src/test/java/org/apache/harmony/sound/tests/javax/sound/sampled/AudioSystemTest.java (with props)
harmony/enhanced/classlib/trunk/modules/sound/src/test/resources/
harmony/enhanced/classlib/trunk/modules/sound/src/test/resources/org/
harmony/enhanced/classlib/trunk/modules/sound/src/test/resources/org/apache/
harmony/enhanced/classlib/trunk/modules/sound/src/test/resources/org/apache/harmony/
harmony/enhanced/classlib/trunk/modules/sound/src/test/resources/org/apache/harmony/sound/
harmony/enhanced/classlib/trunk/modules/sound/src/test/resources/org/apache/harmony/sound/tests/
harmony/enhanced/classlib/trunk/modules/sound/src/test/resources/org/apache/harmony/sound/tests/javax/
harmony/enhanced/classlib/trunk/modules/sound/src/test/resources/org/apache/harmony/sound/tests/javax/sound/
harmony/enhanced/classlib/trunk/modules/sound/src/test/resources/org/apache/harmony/sound/tests/javax/sound/sampled/
harmony/enhanced/classlib/trunk/modules/sound/src/test/resources/org/apache/harmony/sound/tests/javax/sound/sampled/soundProvider.jar (with props)
Modified:
harmony/enhanced/classlib/trunk/modules/sound/build.xml
harmony/enhanced/classlib/trunk/modules/sound/src/main/java/javax/sound/sampled/AudioSystem.java
harmony/enhanced/classlib/trunk/modules/sound/src/main/java/org/apache/harmony/sound/internal/nls/messages.properties
harmony/enhanced/classlib/trunk/modules/sound/src/main/java/org/apache/harmony/sound/utils/ProviderService.java
Modified: harmony/enhanced/classlib/trunk/modules/sound/build.xml
URL: http://svn.apache.org/viewvc/harmony/enhanced/classlib/trunk/modules/sound/build.xml?view=diff&rev=509169&r1=509168&r2=509169
==============================================================================
--- harmony/enhanced/classlib/trunk/modules/sound/build.xml (original)
+++ harmony/enhanced/classlib/trunk/modules/sound/build.xml Mon Feb 19 03:42:22 2007
@@ -37,6 +37,8 @@
</or>
</fileset>
+ <fileset id="resources" dir="${hy.sound}/src/test/resources"/>
+
<property name="sound.exclude.file" location="${hy.hdk}/build/sound.exclude" />
<target name="build" depends="compile-java, copy-resources, build-jar" />
@@ -53,7 +55,10 @@
</target>
<!-- internal target for local and global test run sequence -->
- <target name="-test-module" depends="build, compile-tests, prepare-exclude, run-tests" />
+ <target name="-test-module" depends="build, compile-tests, prepare-exclude, copy-tests-resources, run-tests" />
+
+ <property name="tests.hdk.dir" value="${hy.hdk}/build/test" />
+ <property name="tests.resources.dir" value="${tests.hdk.dir}/resources/${hy.sound.packaging.jarname}" />
<target name="clean">
<delete file="${hy.jdk}/jre/lib/boot/${hy.sound.packaging.jarname}.jar" />
@@ -116,6 +121,13 @@
</jar>
</target>
+ <target name="copy-tests-resources">
+ <mkdir dir="${tests.resources.dir}" />
+ <copy todir="${tests.resources.dir}" includeemptydirs="false">
+ <fileset refid="resources" />
+ </copy>
+ </target>
+
<target name="compile-tests">
<echo message="Compiling SOUND tests" />
@@ -137,6 +149,7 @@
</bootclasspath>
<classpath location="../../build/tests" />
<classpath location="${hy.hdk}/build/test/support.jar" />
+ <classpath location="${hy.hdk}/build/test/resources/sound/org/apache/harmony/sound/tests/javax/sound/sampled/soundProvider.jar" />
</javac>
</target>
@@ -166,7 +179,7 @@
<pathelement path="${hy.sound.bin.test}"/>
</classpath>
<classpath location="${hy.hdk}/build/test/support.jar" />
-
+ <classpath location="${hy.hdk}/build/test/resources/sound/org/apache/harmony/sound/tests/javax/sound/sampled/soundProvider.jar" />
<formatter type="xml" />
<test name="${test.case}" todir="${hy.tests.reports}"
Modified: harmony/enhanced/classlib/trunk/modules/sound/src/main/java/javax/sound/sampled/AudioSystem.java
URL: http://svn.apache.org/viewvc/harmony/enhanced/classlib/trunk/modules/sound/src/main/java/javax/sound/sampled/AudioSystem.java?view=diff&rev=509169&r1=509168&r2=509169
==============================================================================
--- harmony/enhanced/classlib/trunk/modules/sound/src/main/java/javax/sound/sampled/AudioSystem.java (original)
+++ harmony/enhanced/classlib/trunk/modules/sound/src/main/java/javax/sound/sampled/AudioSystem.java Mon Feb 19 03:42:22 2007
@@ -17,6 +17,587 @@
package javax.sound.sampled;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Iterator;
+import java.util.Properties;
+
+import javax.sound.sampled.spi.AudioFileReader;
+import javax.sound.sampled.spi.AudioFileWriter;
+import javax.sound.sampled.spi.FormatConversionProvider;
+import javax.sound.sampled.spi.MixerProvider;
+
+import org.apache.harmony.sound.utils.ProviderService;
+
+import org.apache.harmony.sound.internal.nls.Messages;
+
public class AudioSystem {
+
public static final int NOT_SPECIFIED = -1;
+
+ private final static String audioFileReaderPath = "META-INF/services/javax.sound.sampled.spi.AudioFileReader"; //$NON-NLS-1$
+
+ private final static String audioFileWriterPath = "META-INF/services/javax.sound.sampled.spi.AudioFileWriter"; //$NON-NLS-1$
+
+ private final static String formatConversionProviderPath = "META-INF/services/javax.sound.sampled.spi.FormatConversionProvider"; //$NON-NLS-1$
+
+ private final static String mixerProviderPath = "META-INF/services/javax.sound.sampled.spi.MixerProvider"; //$NON-NLS-1$
+
+ private final static String CLIP = "javax.sound.sampled.Clip"; //$NON-NLS-1$
+
+ private final static String PORT = "javax.sound.sampled.Port"; //$NON-NLS-1$
+
+ private final static String SOURCEDATALINE = "javax.sound.sampled.SourceDataLine"; //$NON-NLS-1$
+
+ private final static String TARGETDATALINE = "javax.sound.sampled.TargetDataLine"; //$NON-NLS-1$
+
+ public static Mixer.Info[] getMixerInfo() {
+ List<Mixer.Info> result = new ArrayList<Mixer.Info>();
+ for (Iterator providers = ProviderService.getProviders(
+ mixerProviderPath).iterator(); providers.hasNext();) {
+ try {
+ Mixer.Info[] infos = ((MixerProvider) (providers.next()))
+ .getMixerInfo();
+ for (Mixer.Info info : infos) {
+ result.add(info);
+ }
+ } catch (ClassCastException e) {}
+ }
+ Mixer.Info[] temp = new Mixer.Info[result.size()];
+ return result.toArray(temp);
+ }
+
+ public static Mixer getMixer(Mixer.Info info) {
+ Mixer.Info[] infos;
+ Mixer.Info inf;
+ if (info == null) {
+ infos = getMixerInfo();
+ if (infos == null) {
+ throw new IllegalArgumentException(
+ "No system default mixer installed"); //$NON-NLS-1$
+ }
+ inf = infos[0];
+ } else {
+ inf = info;
+ }
+
+ for (Iterator providers = ProviderService.getProviders(
+ mixerProviderPath).iterator(); providers.hasNext();) {
+ try {
+ return ((MixerProvider) (providers.next())).getMixer(inf);
+ } catch (ClassCastException e) {} catch (IllegalArgumentException e) {}
+ }
+ throw new IllegalArgumentException("Mixer not supported: " + inf); //$NON-NLS-1$
+ }
+
+ public static Line.Info[] getSourceLineInfo(Line.Info info) {
+ List<Line.Info> result = new ArrayList<Line.Info>();
+ for (Iterator providers = ProviderService.getProviders(
+ mixerProviderPath).iterator(); providers.hasNext();) {
+ try {
+ MixerProvider pr = (MixerProvider) providers.next();
+ Mixer.Info[] mixinfos = pr.getMixerInfo();
+ for (Mixer.Info mixinfo : mixinfos) {
+ Mixer mix = pr.getMixer(mixinfo);
+ Line.Info[] linfos = mix.getSourceLineInfo(info);
+ for (Line.Info linfo : linfos) {
+ result.add(linfo);
+ }
+ }
+ } catch (ClassCastException e) {}
+ }
+ Line.Info[] temp = new Line.Info[result.size()];
+ return result.toArray(temp);
+ }
+
+ public static Line.Info[] getTargetLineInfo(Line.Info info) {
+ List<Line.Info> result = new ArrayList<Line.Info>();
+ for (Iterator providers = ProviderService.getProviders(
+ mixerProviderPath).iterator(); providers.hasNext();) {
+ try {
+ MixerProvider pr = (MixerProvider) providers.next();
+ Mixer.Info[] mixinfos = pr.getMixerInfo();
+ for (Mixer.Info mixinfo : mixinfos) {
+ Mixer mix = pr.getMixer(mixinfo);
+ Line.Info[] linfos = mix.getTargetLineInfo(info);
+ for (Line.Info linfo : linfos) {
+ result.add(linfo);
+ }
+ }
+ } catch (ClassCastException e) {}
+ }
+ Line.Info[] temp = new Line.Info[result.size()];
+ return result.toArray(temp);
+ }
+
+ public static boolean isLineSupported(Line.Info info) {
+
+ for (Iterator providers = ProviderService.getProviders(
+ mixerProviderPath).iterator(); providers.hasNext();) {
+ try {
+ MixerProvider pr = (MixerProvider) providers.next();
+ Mixer.Info[] mixinfos = pr.getMixerInfo();
+ for (Mixer.Info mixinfo : mixinfos) {
+ Mixer mix = pr.getMixer(mixinfo);
+ if (mix.isLineSupported(info)) {
+ return true;
+ }
+ }
+ } catch (ClassCastException e) {}
+ }
+ return false;
+ }
+
+ private static Mixer getMixer(String propVal, Line.Info info,
+ List<?> mixerProviders) {
+
+ int index = propVal.indexOf("#"); //$NON-NLS-1$
+ String className;
+ String mixName;
+ if (index == -1) {
+ className = propVal.trim();
+ mixName = ""; //$NON-NLS-1$
+ } else {
+ className = propVal.substring(0, index).trim();
+ if (index == propVal.length()) {
+ mixName = ""; //$NON-NLS-1$
+ } else {
+ mixName = propVal.substring(index + 1).trim();
+ }
+ }
+ Mixer.Info[] minfos = null;
+ if (!className.equals("")) { //$NON-NLS-1$
+ for (Iterator providers = mixerProviders.iterator(); providers
+ .hasNext();) {
+ try {
+ MixerProvider pr = (MixerProvider) (providers.next());
+ if (className.equals(pr.getClass().getName())) {
+ minfos = pr.getMixerInfo();
+ break;
+ }
+ } catch (ClassCastException e) {}
+ }
+ }
+ if (minfos == null) {
+ minfos = getMixerInfo();
+ }
+
+ if (!mixName.equals("")) { //$NON-NLS-1$
+ for (Mixer.Info minfo : minfos) {
+ if (mixName.equals(minfo.getName())) {
+ return getMixer(minfo);
+ }
+ }
+ }
+ if (minfos.length > 0) {
+ return getMixer(minfos[0]);
+ }
+ return null;
+ }
+
+ public static Line getLine(Line.Info info) throws LineUnavailableException {
+ String propName = null;
+ Class lineClass = info.getLineClass();
+
+ if (Clip.class.isAssignableFrom(lineClass)) {
+ propName = CLIP;
+ } else if (Port.class.isAssignableFrom(lineClass)) {
+ propName = PORT;
+ } else if (SourceDataLine.class.isAssignableFrom(lineClass)) {
+ propName = SOURCEDATALINE;
+ } else if (TargetDataLine.class.isAssignableFrom(lineClass)) {
+ propName = TARGETDATALINE;
+ }
+ return getLine(propName, info);
+ }
+
+ private static Line getLine(String propName, Line.Info info)
+ throws LineUnavailableException {
+
+ List<?> mixerProviders = ProviderService
+ .getProviders(mixerProviderPath);
+
+ if (propName != null) {
+ String propVal = System.getProperty(propName);
+ if (propVal != null) {
+ Mixer m = getMixer(propVal, info, mixerProviders);
+ if (m != null) {
+ Line l = m.getLine(info);
+ if (l != null) {
+ return l;
+ }
+ }
+ }
+
+ Properties soundProperties = ProviderService.getSoundProperties();
+ propVal = soundProperties.getProperty(propName);
+ if (propVal != null) {
+ Mixer m = getMixer(propVal, info, mixerProviders);
+ if (m != null) {
+ Line l = m.getLine(info);
+ if (l != null) {
+ return l;
+ }
+ }
+ }
+ }
+
+ for (Iterator providers = ProviderService.getProviders(
+ mixerProviderPath).iterator(); providers.hasNext();) {
+ try {
+ MixerProvider pr = (MixerProvider) (providers.next());
+ Mixer.Info[] mixinfos = pr.getMixerInfo();
+ for (Mixer.Info mixinfo : mixinfos) {
+ try {
+ Mixer mix = pr.getMixer(mixinfo);
+ return mix.getLine(info);
+ } catch (IllegalArgumentException e) {
+ // continue
+ }
+ }
+ } catch (ClassCastException e) {}
+ }
+ // sound.11=Could not get line
+ throw new IllegalArgumentException(Messages.getString("sound.11")); //$NON-NLS-1$
+ }
+
+ public static Clip getClip() throws LineUnavailableException {
+ return (Clip) getLine(new Line.Info(Clip.class));
+ }
+
+ public static Clip getClip(Mixer.Info mixerInfo)
+ throws LineUnavailableException {
+ return (Clip) (getMixer(mixerInfo).getLine(new Line.Info(Clip.class)));
+ }
+
+ public static SourceDataLine getSourceDataLine(AudioFormat format)
+ throws LineUnavailableException {
+ SourceDataLine line = (SourceDataLine) getLine(new Line.Info(
+ SourceDataLine.class));
+ line.open(format);
+ return line;
+ }
+
+ public static SourceDataLine getSourceDataLine(AudioFormat format,
+ Mixer.Info mixerinfo) throws LineUnavailableException {
+
+ SourceDataLine line = (SourceDataLine) getMixer(mixerinfo).getLine(
+ new Line.Info(SourceDataLine.class));
+ line.open(format);
+ return line;
+ }
+
+ public static TargetDataLine getTargetDataLine(AudioFormat format)
+ throws LineUnavailableException {
+ TargetDataLine line = (TargetDataLine) getLine(new Line.Info(
+ TargetDataLine.class));
+ line.open(format);
+ return line;
+ }
+
+ public static TargetDataLine getTargetDataLine(AudioFormat format,
+ Mixer.Info mixerinfo) throws LineUnavailableException {
+
+ TargetDataLine line = (TargetDataLine) getMixer(mixerinfo).getLine(
+ new Line.Info(TargetDataLine.class));
+ line.open(format);
+ return line;
+ }
+
+ public static AudioFormat.Encoding[] getTargetEncodings(
+ AudioFormat.Encoding sourceEncoding) {
+
+ List<AudioFormat.Encoding> result = new ArrayList<AudioFormat.Encoding>();
+ for (Iterator providers = ProviderService.getProviders(
+ formatConversionProviderPath).iterator(); providers.hasNext();) {
+ try {
+ FormatConversionProvider pr = (FormatConversionProvider) providers
+ .next();
+ if (!pr.isSourceEncodingSupported(sourceEncoding)) {
+ continue;
+ }
+ AudioFormat.Encoding[] encodings = pr.getTargetEncodings();
+ for (AudioFormat.Encoding encoding : encodings) {
+ result.add(encoding);
+ }
+ } catch (ClassCastException e) {}
+ }
+ AudioFormat.Encoding[] temp = new AudioFormat.Encoding[result.size()];
+ return result.toArray(temp);
+ }
+
+ public static AudioFormat.Encoding[] getTargetEncodings(
+ AudioFormat sourceFormat) {
+
+ List<AudioFormat.Encoding> result = new ArrayList<AudioFormat.Encoding>();
+ for (Iterator providers = ProviderService.getProviders(
+ formatConversionProviderPath).iterator(); providers.hasNext();) {
+ try {
+ AudioFormat.Encoding[] encodings = ((FormatConversionProvider) (providers
+ .next())).getTargetEncodings(sourceFormat);
+ for (AudioFormat.Encoding encoding : encodings) {
+ result.add(encoding);
+ }
+ } catch (ClassCastException e) {}
+ }
+ AudioFormat.Encoding[] temp = new AudioFormat.Encoding[result.size()];
+ return result.toArray(temp);
+ }
+
+ public static boolean isConversionSupported(
+ AudioFormat.Encoding targetEncoding, AudioFormat sourceFormat) {
+
+ for (Iterator providers = ProviderService.getProviders(
+ formatConversionProviderPath).iterator(); providers.hasNext();) {
+ if (((FormatConversionProvider) (providers.next()))
+ .isConversionSupported(targetEncoding, sourceFormat)) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ public static AudioInputStream getAudioInputStream(
+ AudioFormat.Encoding targetEncoding, AudioInputStream sourceStream) {
+
+ if (sourceStream.getFormat().getEncoding().equals(targetEncoding)) {
+ return sourceStream;
+ }
+ for (Iterator providers = ProviderService.getProviders(
+ formatConversionProviderPath).iterator(); providers.hasNext();) {
+ try {
+ return ((FormatConversionProvider) (providers.next()))
+ .getAudioInputStream(targetEncoding, sourceStream);
+ } catch (ClassCastException e) {} catch (IllegalArgumentException e) {}
+ }
+ // sound.12=Could not get audio input stream from source stream
+ throw new IllegalArgumentException(Messages.getString("sound.12")); //$NON-NLS-1$
+ }
+
+ public static AudioFormat[] getTargetFormats(
+ AudioFormat.Encoding targetEncoding, AudioFormat sourceFormat) {
+
+ List<AudioFormat> result = new ArrayList<AudioFormat>();
+ for (Iterator providers = ProviderService.getProviders(
+ formatConversionProviderPath).iterator(); providers.hasNext();) {
+ try {
+ AudioFormat[] formats = ((FormatConversionProvider) (providers
+ .next()))
+ .getTargetFormats(targetEncoding, sourceFormat);
+ for (AudioFormat format : formats) {
+ result.add(format);
+ }
+ } catch (ClassCastException e) {}
+ }
+ AudioFormat[] temp = new AudioFormat[result.size()];
+ return result.toArray(temp);
+ }
+
+ public static boolean isConversionSupported(AudioFormat targetFormat,
+ AudioFormat sourceFormat) {
+
+ for (Iterator providers = ProviderService.getProviders(
+ formatConversionProviderPath).iterator(); providers.hasNext();) {
+ if (((FormatConversionProvider) (providers.next()))
+ .isConversionSupported(targetFormat, sourceFormat)) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ public static AudioInputStream getAudioInputStream(
+ AudioFormat targetFormat, AudioInputStream sourceStream) {
+
+ if (sourceStream.getFormat().matches(targetFormat)) {
+ return sourceStream;
+ }
+ for (Iterator providers = ProviderService.getProviders(
+ formatConversionProviderPath).iterator(); providers.hasNext();) {
+ try {
+ return ((FormatConversionProvider) (providers.next()))
+ .getAudioInputStream(targetFormat, sourceStream);
+ } catch (ClassCastException e) {} catch (IllegalArgumentException e) {}
+ }
+ // sound.13=Could not get audio input stream from source stream
+ throw new IllegalArgumentException(Messages.getString("sound.13")); //$NON-NLS-1$
+ }
+
+ public static AudioFileFormat getAudioFileFormat(InputStream stream)
+ throws UnsupportedAudioFileException, IOException {
+
+ for (Iterator providers = ProviderService.getProviders(
+ audioFileReaderPath).iterator(); providers.hasNext();) {
+ try {
+ return ((AudioFileReader) (providers.next()))
+ .getAudioFileFormat(stream);
+ } catch (ClassCastException e) {} catch (UnsupportedAudioFileException e) {}
+ }
+ // sound.14=File is not a supported file type
+ throw new UnsupportedAudioFileException(Messages.getString("sound.14")); //$NON-NLS-1$
+ }
+
+ public static AudioFileFormat getAudioFileFormat(URL url)
+ throws UnsupportedAudioFileException, IOException {
+
+ for (Iterator providers = ProviderService.getProviders(
+ audioFileReaderPath).iterator(); providers.hasNext();) {
+ try {
+ return ((AudioFileReader) (providers.next()))
+ .getAudioFileFormat(url);
+ } catch (ClassCastException e) {} catch (UnsupportedAudioFileException e) {}
+ }
+ // sound.14=File is not a supported file type
+ throw new UnsupportedAudioFileException(Messages.getString("sound.14")); //$NON-NLS-1$
+ }
+
+ public static AudioFileFormat getAudioFileFormat(File file)
+ throws UnsupportedAudioFileException, IOException {
+
+ for (Iterator providers = ProviderService.getProviders(
+ audioFileReaderPath).iterator(); providers.hasNext();) {
+ try {
+ return ((AudioFileReader) (providers.next()))
+ .getAudioFileFormat(file);
+ } catch (ClassCastException e) {} catch (UnsupportedAudioFileException e) {}
+ }
+ // sound.14=File is not a supported file type
+ throw new UnsupportedAudioFileException(Messages.getString("sound.14")); //$NON-NLS-1$
+ }
+
+ public static AudioInputStream getAudioInputStream(InputStream stream)
+ throws UnsupportedAudioFileException, IOException {
+
+ if (stream instanceof AudioInputStream) {
+ return (AudioInputStream) stream;
+ }
+ for (Iterator providers = ProviderService.getProviders(
+ audioFileReaderPath).iterator(); providers.hasNext();) {
+ try {
+ return ((AudioFileReader) (providers.next()))
+ .getAudioInputStream(stream);
+ } catch (ClassCastException e) {} catch (UnsupportedAudioFileException e) {}
+ }
+ // sound.15=Could not get audio input stream from input stream
+ throw new UnsupportedAudioFileException(Messages.getString("sound.15")); //$NON-NLS-1$
+ }
+
+ public static AudioInputStream getAudioInputStream(URL url)
+ throws UnsupportedAudioFileException, IOException {
+
+ for (Iterator providers = ProviderService.getProviders(
+ audioFileReaderPath).iterator(); providers.hasNext();) {
+ try {
+ return ((AudioFileReader) (providers.next()))
+ .getAudioInputStream(url);
+ } catch (ClassCastException e) {} catch (UnsupportedAudioFileException e) {}
+ }
+ // sound.16=Could not get audio input stream from input URL
+ throw new UnsupportedAudioFileException(Messages.getString("sound.16")); //$NON-NLS-1$
+ }
+
+ public static AudioInputStream getAudioInputStream(File file)
+ throws UnsupportedAudioFileException, IOException {
+
+ for (Iterator providers = ProviderService.getProviders(
+ audioFileReaderPath).iterator(); providers.hasNext();) {
+ try {
+ return ((AudioFileReader) (providers.next()))
+ .getAudioInputStream(file);
+ } catch (ClassCastException e) {} catch (UnsupportedAudioFileException e) {}
+ }
+ // sound.17=Could not get audio input stream from input file
+ throw new UnsupportedAudioFileException(Messages.getString("sound.17")); //$NON-NLS-1$
+ }
+
+ public static AudioFileFormat.Type[] getAudioFileTypes() {
+ List<AudioFileFormat.Type> result = new ArrayList<AudioFileFormat.Type>();
+ for (Iterator providers = ProviderService.getProviders(
+ audioFileWriterPath).iterator(); providers.hasNext();) {
+ try {
+ AudioFileFormat.Type[] types = ((AudioFileWriter) (providers
+ .next())).getAudioFileTypes();
+ for (AudioFileFormat.Type type : types) {
+ result.add(type);
+ }
+ } catch (ClassCastException e) {}
+ }
+ AudioFileFormat.Type[] temp = new AudioFileFormat.Type[result.size()];
+ return result.toArray(temp);
+ }
+
+ public static boolean isFileTypeSupported(AudioFileFormat.Type fileType) {
+
+ for (Iterator providers = ProviderService.getProviders(
+ audioFileWriterPath).iterator(); providers.hasNext();) {
+ if (((AudioFileWriter) (providers.next()))
+ .isFileTypeSupported(fileType)) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ public static AudioFileFormat.Type[] getAudioFileTypes(
+ AudioInputStream stream) {
+ List<AudioFileFormat.Type> result = new ArrayList<AudioFileFormat.Type>();
+ for (Iterator providers = ProviderService.getProviders(
+ audioFileWriterPath).iterator(); providers.hasNext();) {
+ try {
+ AudioFileFormat.Type[] types = ((AudioFileWriter) (providers
+ .next())).getAudioFileTypes(stream);
+ for (AudioFileFormat.Type type : types) {
+ result.add(type);
+ }
+ } catch (ClassCastException e) {}
+ }
+ AudioFileFormat.Type[] temp = new AudioFileFormat.Type[result.size()];
+ return result.toArray(temp);
+ }
+
+ public static boolean isFileTypeSupported(AudioFileFormat.Type fileType,
+ AudioInputStream stream) {
+
+ for (Iterator providers = ProviderService.getProviders(
+ audioFileWriterPath).iterator(); providers.hasNext();) {
+ if (((AudioFileWriter) (providers.next())).isFileTypeSupported(
+ fileType, stream)) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ public static int write(AudioInputStream stream,
+ AudioFileFormat.Type fileType, OutputStream out) throws IOException {
+ AudioFileWriter writer;
+ for (Iterator providers = ProviderService.getProviders(
+ audioFileWriterPath).iterator(); providers.hasNext();) {
+ writer = (AudioFileWriter) (providers.next());
+ if (writer.isFileTypeSupported(fileType, stream)) {
+ return writer.write(stream, fileType, out);
+ }
+ }
+ // sound.18=Type is not supported
+ throw new IllegalArgumentException(Messages.getString("sound.18")); //$NON-NLS-1$
+ }
+
+ public static int write(AudioInputStream stream,
+ AudioFileFormat.Type fileType, File out) throws IOException {
+ AudioFileWriter writer;
+ for (Iterator providers = ProviderService.getProviders(
+ audioFileWriterPath).iterator(); providers.hasNext();) {
+ writer = (AudioFileWriter) (providers.next());
+ if (writer.isFileTypeSupported(fileType, stream)) {
+ return writer.write(stream, fileType, out);
+ }
+ }
+ // sound.18=Type is not supported
+ throw new IllegalArgumentException(Messages.getString("sound.18")); //$NON-NLS-1$
+ }
}
Modified: harmony/enhanced/classlib/trunk/modules/sound/src/main/java/org/apache/harmony/sound/internal/nls/messages.properties
URL: http://svn.apache.org/viewvc/harmony/enhanced/classlib/trunk/modules/sound/src/main/java/org/apache/harmony/sound/internal/nls/messages.properties?view=diff&rev=509169&r1=509168&r2=509169
==============================================================================
--- harmony/enhanced/classlib/trunk/modules/sound/src/main/java/org/apache/harmony/sound/internal/nls/messages.properties (original)
+++ harmony/enhanced/classlib/trunk/modules/sound/src/main/java/org/apache/harmony/sound/internal/nls/messages.properties Mon Feb 19 03:42:22 2007
@@ -29,3 +29,11 @@
sound.0C=Frame size must be one byte
sound.0D=The value is not supported
sound.0F=value does not fall within the allowable range
+sound.11=Could not get line
+sound.12=Could not get audio input stream from source stream
+sound.13=Could not get audio input stream from source stream
+sound.14=File is not a supported file type
+sound.15=Could not get audio input stream from input stream
+sound.16=Could not get audio input stream from input URL
+sound.17=Could not get audio input stream from input file
+sound.18=Type is not supported
Modified: harmony/enhanced/classlib/trunk/modules/sound/src/main/java/org/apache/harmony/sound/utils/ProviderService.java
URL: http://svn.apache.org/viewvc/harmony/enhanced/classlib/trunk/modules/sound/src/main/java/org/apache/harmony/sound/utils/ProviderService.java?view=diff&rev=509169&r1=509168&r2=509169
==============================================================================
--- harmony/enhanced/classlib/trunk/modules/sound/src/main/java/org/apache/harmony/sound/utils/ProviderService.java (original)
+++ harmony/enhanced/classlib/trunk/modules/sound/src/main/java/org/apache/harmony/sound/utils/ProviderService.java Mon Feb 19 03:42:22 2007
@@ -19,47 +19,63 @@
import java.io.File;
import java.io.FileInputStream;
+import java.io.InputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
+import java.net.URL;
+import java.security.AccessController;
+import java.security.PrivilegedAction;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.List;
import java.util.Properties;
-import java.util.jar.JarEntry;
-import java.util.jar.JarFile;
-public class ProviderService {
+public class ProviderService {
+
+ // Properties from sound.propertie file
+ private static Properties devices;
+
+ static {
+ devices = new Properties();
+
+ FileInputStream fstream = AccessController
+ .doPrivileged(new PrivilegedAction<FileInputStream>() {
+
+ public FileInputStream run() {
+ // obtain the path to the file sound.properties
+ String soundPropertiesPath = System
+ .getProperty("java.home") //$NON-NLS-1$
+ + File.separator + "lib" + File.separator //$NON-NLS-1$
+ + "sound.properties"; //$NON-NLS-1$
+ try {
+ return new FileInputStream(soundPropertiesPath);
+ } catch (FileNotFoundException e) {
+ return null;
+ }
+ }
+ });
+
+ if (fstream != null) {
+ // reading file sound.properties
+ try {
+ devices.load(fstream);
+ } catch (IOException e) {}
+ }
+ }
+
/**
* this method return information about default device
+ *
* @param deviceName
* @return
*/
public static List<String> getDefaultDeviceDescription(String deviceName) {
- /*
- * obtain the path to the file sound.properties
- */
- String soundPropertiesPath = System.getProperty("java.home") + File.separator + "lib" +
- File.separator + "sound.properties";
- Properties devices = new Properties();
- FileInputStream fstream;
- /*
- * variable that contain information about default device
- */
+
+ // variable that contain information about default device
List<String> defaultDevice = new ArrayList<String>();
String str;
int index;
- /*
- * reading file sound.properties
- */
- try {
- fstream = new FileInputStream(soundPropertiesPath);
- devices.load(fstream);
- } catch (FileNotFoundException e) {
- throw new Error("Configuration file sound.properties doesn't exist!");
- }
- catch (IOException e) {
- throw new Error("An error while reading file sound.properties");
- }
+
/*
* obtain the default device that describes by deviceName
*/
@@ -71,140 +87,91 @@
return defaultDevice;
}
/*
- * the separator between provider and name is '#';
- * find separator of provider and name of device in the notation of default device
+ * the separator between provider and name is '#'; find separator of
+ * provider and name of device in the notation of default device
*/
- index = str.indexOf("#");
+ index = str.indexOf("#"); //$NON-NLS-1$
/*
- * if separator doesn't find, so in the definition of default device contain only
- * name of provider, and so we add it
+ * if separator doesn't find, so in the definition of default device
+ * contain only name of provider, and so we add it
*/
if (index == -1) {
defaultDevice.add(str);
defaultDevice.add(null);
- /*
- * if separator is the first symbol, so definition contain only name of device
- */
+ /*
+ * if separator is the first symbol, so definition contain only name
+ * of device
+ */
} else if (index == 0) {
defaultDevice.add(null);
defaultDevice.add(str.substring(index + 1));
- /*
- * if separator is not the first, so we find provider and name of device
- */
+ /*
+ * if separator is not the first, so we find provider and name of
+ * device
+ */
} else {
defaultDevice.add(str.substring(0, index));
defaultDevice.add(str.substring(index + 1));
}
return defaultDevice;
}
-
+
/**
* this method return the list of providers
+ *
* @param providerName
* @return
*/
public static List<?> getProviders(String providerName) {
- //this variable contain providers
- List<Object> providers = new ArrayList<Object>();
- List<String> providerNames = getProviderNames(providerName);
- Class<?> cl;
- /*
- * obtain classes
- */
- for (int i = 0; i < providerNames.size(); i++) {
- try {
- cl = Class.forName(providerNames.get(i));
- providers.add(cl.newInstance());
- } catch (ClassNotFoundException e) {}
- catch (IllegalAccessException e) {}
- catch (InstantiationException e) {}
- }
- return providers;
- }
-
- /**
- * this method return the list of provider names
- * @param providerPath
- * @return
- */
- public static List<String> getProviderNames(String providerPath) {
- /*
- * this variable contain providers that install in the system
- */
- Properties providers = new Properties();
- /*
- * this variable contain list of all jar-files that are contained in the java-home directory
- */
- List<String> jarFiles = new ArrayList<String>();
-
- File home = new File(System.getProperty("java.home"));
- /*
- * obtain all jar-files that contain in the java home directory;
- * if we already find it, we don't find again
- */
- find(home, jarFiles);
- /*
- * for the each obtained file we search providers in it
- */
- for (int i = 0; i < jarFiles.size(); i++) {
- try {
- JarFile jFile = new JarFile(jarFiles.get(i));
- /*
- * obtain contents of jar-file
- */
- Enumeration<JarEntry> files = jFile.entries();
-
- /*
- * the list of installed devices be found in the fixed place, and this place describes by
- * parameter providerPath, so we search this place in each jar-file
- */
- while (files.hasMoreElements()) {
- JarEntry filePath = files.nextElement();
- if (filePath.toString().equals(providerPath)) {
- /*
- * if we found such place, we save providers in the variable 'providers'
- * and exit from this iteration, because in each file it can be only one time
- */
- providers.load(jFile.getInputStream(filePath));
- break;
+ final String name = providerName;
+
+ return AccessController
+ .doPrivileged(new PrivilegedAction<List<Object>>() {
+
+ public List<Object> run() {
+ List<Object> providers = new ArrayList<Object>();
+ String className = null;
+ byte[] bytes;
+
+ ClassLoader cl = ClassLoader.getSystemClassLoader();
+ Enumeration<URL> urls = null;
+ try {
+ urls = cl.getResources(name);
+ } catch (IOException e) {
+ return providers;
+ }
+ for (; urls.hasMoreElements();) {
+ try {
+ InputStream in = urls.nextElement()
+ .openStream();
+ bytes = new byte[in.available()];
+ in.read(bytes);
+ in.close();
+ } catch (IOException e) {
+ continue;
+ }
+ String[] astr = new String(bytes).split("\r\n"); //$NON-NLS-1$
+ for (String str : astr) {
+ className = str.trim();
+ if (!className.startsWith("#")) { // skip
+ // comments
+ // //$NON-NLS-1$
+ try {
+ providers.add(Class.forName(
+ className.trim(), true, cl)
+ .newInstance());
+ } catch (IllegalAccessException e) {} catch (InstantiationException e) {} catch (ClassNotFoundException e) {}
+ }
+ }
+ }
+ return providers;
}
- }
- } catch (IOException e) {}
- }
-
- List<String> listProviders = new ArrayList<String>();
- Enumeration<?> en = providers.propertyNames();
- while (en.hasMoreElements()) {
- listProviders.add(en.nextElement().toString());
- }
- return listProviders;
+ });
+
}
-
- /**
- * This function search recursively in the Java home directory all jar-files
- * @param parent
- */
- static private void find(File parent, List<String> jarFiles) {
- /*
- * Obtain the list of files that contains in the directory 'parent'
- */
- String[] listFiles = parent.list();
- for (String element : listFiles) {
- File file = new File(parent, element);
- /*
- * if new file is directory, than recursively go in it...
- */
- if (file.isDirectory()) {
- find(file, jarFiles);
- } else {
- /*
- * else if it's file, we check up that it's jar-file. If it's true
- * we save it
- */
- if (element.endsWith(".jar")) {
- jarFiles.add(parent.toString() + File.separator + element);
- }
- }
- }
+
+ public static Properties getSoundProperties() {
+ return devices;
}
+
}
Added: harmony/enhanced/classlib/trunk/modules/sound/src/test/java/org/apache/harmony/sound/tests/javax/sound/sampled/AudioSystemTest.java
URL: http://svn.apache.org/viewvc/harmony/enhanced/classlib/trunk/modules/sound/src/test/java/org/apache/harmony/sound/tests/javax/sound/sampled/AudioSystemTest.java?view=auto&rev=509169
==============================================================================
--- harmony/enhanced/classlib/trunk/modules/sound/src/test/java/org/apache/harmony/sound/tests/javax/sound/sampled/AudioSystemTest.java (added)
+++ harmony/enhanced/classlib/trunk/modules/sound/src/test/java/org/apache/harmony/sound/tests/javax/sound/sampled/AudioSystemTest.java Mon Feb 19 03:42:22 2007
@@ -0,0 +1,634 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.harmony.sound.tests.javax.sound.sampled;
+
+import java.io.File;
+import java.net.URL;
+
+import javax.sound.sampled.AudioFileFormat;
+import javax.sound.sampled.AudioFormat;
+import javax.sound.sampled.AudioInputStream;
+import javax.sound.sampled.AudioSystem;
+import javax.sound.sampled.Line;
+import javax.sound.sampled.Mixer;
+
+import junit.framework.TestCase;
+
+/**
+ *
+ * Dummy sound provider located in soundProvider.jar is used for testing.
+ * Provider sources are provided at the comments at the end of this file.
+ *
+ */
+public class AudioSystemTest extends TestCase {
+
+ public void testAudioFile() throws Exception {
+ boolean ok;
+
+ assertTrue(AudioSystem.getAudioFileFormat(new URL("file:./myFile.txt")) != null);
+
+ AudioFileFormat.Type[] types = AudioSystem.getAudioFileTypes();
+
+ ok = false;
+ for (int i = 0; i < types.length; i++) {
+ if (types[i].getExtension().equals("txt")) {
+ ok = true;
+ break;
+ }
+ }
+ assertTrue(ok);
+ }
+
+ public void testMixer() throws Exception {
+ boolean ok;
+
+ Mixer.Info[] minfos = AudioSystem.getMixerInfo();
+ assertTrue(minfos.length > 0);
+ assertEquals(minfos[0].getName(), "NAME");
+ assertEquals(minfos[0].getVersion(), "VERSION");
+
+ assertTrue(AudioSystem.getMixer(null) != null);
+
+ Mixer mix = AudioSystem.getMixer(minfos[0]);
+ assertEquals(mix.getClass().getName(),
+ "org.apache.harmony.sound.testProvider.MyMixer");
+ Line.Info[] mli = mix.getSourceLineInfo();
+ assertEquals(mli.length, 4);
+
+ Line.Info[] infos = AudioSystem.getSourceLineInfo(mli[0]);
+ ok = false;
+ for (int i = 0; i < infos.length; i++) {
+ if (infos[i].getLineClass().getName().equals(
+ "org.apache.harmony.sound.testProvider.myClip")) {
+ ok = true;
+ break;
+ }
+ }
+ assertTrue(ok);
+
+ infos = AudioSystem.getTargetLineInfo(mli[0]);
+ ok = false;
+ for (int i = 0; i < infos.length; i++) {
+ if (infos[i].getLineClass().getName().equals(
+ "org.apache.harmony.sound.testProvider.myClip")) {
+ ok = true;
+ break;
+ }
+ }
+ assertTrue(ok);
+ }
+
+ public void testAudioInputStream() throws Exception {
+
+ AudioInputStream stream = AudioSystem.getAudioInputStream(new File(
+ "myFile.txt"));
+ assertTrue(stream != null);
+
+ // no exception expected
+ AudioSystem.write(stream, new AudioFileFormat.Type("TXT", "txt"),
+ System.out);
+
+ assertEquals(AudioSystem.getAudioInputStream(
+ AudioFormat.Encoding.PCM_UNSIGNED, stream), stream);
+ }
+
+ // see TestFormatConversionProvider
+ public void testFormatConversion() throws Exception {
+
+ boolean ok;
+
+ AudioFormat af_source = new AudioFormat(
+ AudioFormat.Encoding.PCM_UNSIGNED, 1f, 2, 3, 4, 5f, true);
+
+ AudioFormat.Encoding[] aafe = AudioSystem
+ .getTargetEncodings(AudioFormat.Encoding.PCM_UNSIGNED);
+ ok = false;
+ for (int i = 0; i < aafe.length; i++) {
+ // contains PCM_SIGNED (see TestFormatConversionProvider)
+ if (aafe[i].equals(AudioFormat.Encoding.PCM_SIGNED)) {
+ ok = true;
+ break;
+ }
+ }
+ assertTrue(ok);
+
+ assertTrue(AudioSystem.isConversionSupported(
+ AudioFormat.Encoding.PCM_SIGNED, af_source));
+
+ AudioFormat[] aaf = AudioSystem.getTargetFormats(
+ AudioFormat.Encoding.PCM_UNSIGNED, af_source);
+
+ ok = false;
+ for (int i = 0; i < aaf.length; i++) {
+ if (aaf[i].getSampleRate() == 10f
+ && aaf[i].getSampleSizeInBits() == 2
+ && aaf[i].getChannels() == 30
+ && aaf[i].getFrameSize() == 40
+ && aaf[i].getFrameRate() == 50f) {
+ ok = true;
+ break;
+ }
+ }
+ assertTrue(ok);
+ }
+
+ public void testGetLine() throws Exception {
+
+ assertEquals(AudioSystem.getLine(
+ new Line.Info(javax.sound.sampled.Clip.class)).getClass()
+ .getName(), "org.apache.harmony.sound.testProvider.myClip");
+ assertEquals(AudioSystem.getLine(
+ new Line.Info(javax.sound.sampled.SourceDataLine.class))
+ .getClass().getName(),
+ "org.apache.harmony.sound.testProvider.mySourceDataLine");
+ assertEquals(AudioSystem.getLine(
+ new Line.Info(javax.sound.sampled.TargetDataLine.class))
+ .getClass().getName(),
+ "org.apache.harmony.sound.testProvider.myTargetDataLine");
+ assertEquals(AudioSystem.getLine(
+ new Line.Info(javax.sound.sampled.Port.class)).getClass()
+ .getName(), "org.apache.harmony.sound.testProvider.myPort");
+
+ assertEquals(AudioSystem.getClip().getClass().getName(),
+ "org.apache.harmony.sound.testProvider.myClip");
+
+ }
+}
+
+
+// SOUND PROVIDER SOURCES:
+//
+// META-INF/services/ files:
+// file META-INF/services/javax.sound.sampled.spi:
+//org.apache.harmony.sound.testProvider.TestAudioFileWriter
+//
+// file META-INF/services/javax.sound.sampled.spi:
+//org.apache.harmony.sound.testProvider.TestFormatConversionProvider
+//
+// file META-INF/services/javax.sound.sampled.spi:
+//org.apache.harmony.sound.testProvider.TestMixerProvider
+//
+// file META-INF/services/javax.sound.sampled.spi.AudioFileReader:
+//org.apache.harmony.sound.testProvider.TestAudioFileReader
+//
+//Source files:
+//
+//TestAudioFileReader.java
+//
+//package org.apache.harmony.sound.testProvider;
+//
+//import javax.sound.sampled.*;
+//import javax.sound.sampled.spi.*;
+//import java.util.*;
+//import java.io.*;
+//import java.net.*;
+//
+//public class TestAudioFileReader extends AudioFileReader {
+// static AudioFileFormat aff;
+// static AudioFormat af;
+//
+// static {
+// AudioFormat.Encoding enc = AudioFormat.Encoding.PCM_UNSIGNED;
+// AudioFileFormat.Type type = new AudioFileFormat.Type("TXT", "txt");
+// af = new AudioFormat(enc , 1f, 2, 3, 4, 5f, true);
+// aff = new AudioFileFormat(type , af, 10);
+// }
+//
+// public TestAudioFileReader() {
+// super();
+// };
+//
+// public AudioFileFormat getAudioFileFormat(InputStream stream) throws UnsupportedAudioFileException, IOException {
+// return aff;
+// }
+//
+// public AudioFileFormat getAudioFileFormat(URL url) throws UnsupportedAudioFileException, IOException {
+// return aff;
+// }
+// public AudioFileFormat getAudioFileFormat(File file) throws UnsupportedAudioFileException, IOException {
+// return aff;
+// }
+// public AudioInputStream getAudioInputStream(InputStream stream) throws UnsupportedAudioFileException, IOException {
+// InputStream is = new ByteArrayInputStream(new byte[1001]);
+// return new AudioInputStream(is, af, 10);
+// }
+// public AudioInputStream getAudioInputStream(URL url) throws UnsupportedAudioFileException, IOException {
+// InputStream is = new ByteArrayInputStream(new byte[1001]);
+// return new AudioInputStream(is, af, 10);
+// }
+// public AudioInputStream getAudioInputStream(File file)
+// throws UnsupportedAudioFileException,IOException {
+// InputStream is = new ByteArrayInputStream(new byte[1001]);
+// return new AudioInputStream(is, af, 10);
+// }
+//}
+//
+//TestAudioFileWriter.java
+//
+//package org.apache.harmony.sound.testProvider;
+//
+//import javax.sound.sampled.*;
+//import javax.sound.sampled.spi.*;
+//import java.util.*;
+//import java.io.*;
+//import java.net.*;
+//
+//public class TestAudioFileWriter extends AudioFileWriter {
+//
+// static AudioFileFormat aff;
+// static AudioFormat af;
+// static AudioFileFormat.Type type;
+//
+// static {
+// AudioFormat.Encoding enc = AudioFormat.Encoding.PCM_UNSIGNED;
+// type = new AudioFileFormat.Type("TXT", "txt");
+// vaf = new AudioFormat(enc , 1f, 2, 3, 4, 5f, true);
+// aff = new AudioFileFormat(type , af, 10);
+// }
+//
+// public TestAudioFileWriter () {
+// super();
+// };
+//
+// public AudioFileFormat.Type[] getAudioFileTypes() {
+// return new AudioFileFormat.Type[] {type};
+// }
+// public AudioFileFormat.Type[] getAudioFileTypes(AudioInputStream stream) {
+// return new AudioFileFormat.Type[] {type};
+// }
+// public boolean isFileTypeSupported(AudioFileFormat.Type fileType) {
+// return type.equals(fileType);
+// }
+// public boolean isFileTypeSupported(AudioFileFormat.Type fileType, AudioInputStream stream) {
+// return type.equals(fileType);
+// }
+// public int write(AudioInputStream stream, AudioFileFormat.Type fileType, OutputStream out) throws IOException {
+// return 10;
+// }
+// public int write(AudioInputStream stream, AudioFileFormat.Type fileType, File out) throws IOException {
+// return 10;
+// }
+//}
+//
+//TestFormatConversionProvider.java
+//
+//package org.apache.harmony.sound.testProvider;
+//
+//import javax.sound.sampled.*;
+//import javax.sound.sampled.spi.*;
+//import java.util.*;
+//import java.io.*;
+//import java.net.*;
+//
+//public class TestFormatConversionProvider extends FormatConversionProvider{
+//
+// static AudioFormat.Encoding[] enc_source;
+// static AudioFormat.Encoding[] enc_target;
+// static AudioFormat af_source;
+// static AudioFormat af_target;
+//
+// static {
+// enc_source = new AudioFormat.Encoding[] {AudioFormat.Encoding.PCM_UNSIGNED};
+// af_source = new AudioFormat(enc_source [0] , 1f, 2, 3, 4, 5f, true);
+// enc_target= new AudioFormat.Encoding[] {AudioFormat.Encoding.PCM_SIGNED};
+// af_target= new AudioFormat(enc_target[0] , 10f, 2, 30, 40, 50f, false);
+// }
+// public TestFormatConversionProvider() {
+// super();
+// };
+// public AudioInputStream getAudioInputStream(
+// AudioFormat.Encoding targetEncoding, AudioInputStream sourceStream) {
+// if (!enc_target[0].equals(targetEncoding) ||
+// !af_source.equals(sourceStream.getFormat())) {
+// throw new IllegalArgumentException("conversion not supported");
+// }
+// return sourceStream;
+// }
+// public AudioInputStream getAudioInputStream(
+// AudioFormat targetFormat, AudioInputStream sourceStream) {
+// if (!af_target.equals(targetFormat) ||
+// !af_source.equals(sourceStream.getFormat())) {
+// throw new IllegalArgumentException("conversion not supported");
+// }
+// return sourceStream;
+// }
+// public AudioFormat.Encoding[] getTargetEncodings(
+// AudioFormat sourceFormat) {
+// if (af_source.matches(sourceFormat)) {
+// return enc_target;
+// } else {
+// return new AudioFormat.Encoding[0];
+// }
+// }
+// public AudioFormat[] getTargetFormats(
+// AudioFormat.Encoding targetFormat, AudioFormat sourceFormat) {
+// if (af_source.matches(sourceFormat)) {
+// return new AudioFormat[] {af_target};
+// } else {
+// return new AudioFormat[0];
+// }
+// }
+// public AudioFormat.Encoding[] getSourceEncodings() {
+// return enc_source;
+// }
+// public AudioFormat.Encoding[] getTargetEncodings() {
+// return enc_target;
+// }
+//}
+//
+//TestMixerProvider.java
+//
+//package org.apache.harmony.sound.testProvider;
+//
+//import javax.sound.sampled.*;
+//import javax.sound.sampled.spi.*;
+//import java.util.*;
+//import java.io.*;
+//import java.net.*;
+//
+//public class TestMixerProvider extends MixerProvider {
+// static Mixer.Info info;
+// static Mixer mixer;
+// static {
+// info = new MyMixerInfo("NAME", "VENDOR", "DESCRIPTION", "VERSION");
+// mixer = new MyMixer(info);
+// }
+// public TestMixerProvider () {super();}
+// public boolean isMixerSupported(Mixer.Info info) {
+// return this.info.equals(info);
+// }
+// public Mixer.Info[] getMixerInfo() {
+// return new Mixer.Info[] {info};
+// }
+// public Mixer getMixer(Mixer.Info info) {
+// if (this.info.equals(info)) {
+// return mixer;
+// }
+// throw new IllegalArgumentException("TestMixerProvider ");
+// }
+//}
+//
+//class MyMixerInfo extends Mixer.Info {
+// public MyMixerInfo(String name, String vendor, String description,
+// String version) {
+// super(name, vendor, description, version);
+// }
+//}
+//
+//class MyMixer implements Mixer {
+// private Mixer.Info minfo;
+// private Line[] sourceLines = new Line[] {new myClip(),
+// new mySourceDataLine(),
+// new myTargetDataLine(),
+// new myPort()};
+// private Line[] targetLines = new Line[] {new myClip(),
+// new mySourceDataLine(),
+// new myTargetDataLine(),
+// new myPort()};
+// private Line.Info[] lineInfos = new Line.Info[] {
+// new Line.Info(javax.sound.sampled.Clip.class),
+// new Line.Info(javax.sound.sampled.SourceDataLine.class),
+// new Line.Info(javax.sound.sampled.TargetDataLine.class),
+// new Line.Info(javax.sound.sampled.Port.class)
+// };
+// public MyMixer(Mixer.Info info) {
+// minfo = info;
+// }
+// public Line getLine(Line.Info info) throws LineUnavailableException {
+// for (int i = 0; i < lineInfos.length; i++) {
+// if (lineInfos[i].matches(info)) {
+// return sourceLines[i];
+// }
+// }
+// throw new IllegalArgumentException("not supported " + info);
+// }
+// public int getMaxLines(Line.Info info) {
+// return AudioSystem.NOT_SPECIFIED;
+// }
+// public Mixer.Info getMixerInfo() {
+// return minfo;
+// }
+// public Line.Info[] getSourceLineInfo() {
+// return lineInfos;
+// }
+// public Line.Info[] getSourceLineInfo(Line.Info info) {
+// for (int i = 0; i < lineInfos.length; i++) {
+// if (lineInfos[i].matches(info)) {
+// return new Line.Info[] {sourceLines[i].getLineInfo()};
+// }
+// }
+// throw new IllegalArgumentException("not supported " + info);
+// }
+// public Line[] getSourceLines() {
+// return sourceLines;
+// }
+// public Line.Info[] getTargetLineInfo() {
+// return lineInfos;
+// }
+// public Line.Info[] getTargetLineInfo(Line.Info info) {
+// for (int i = 0; i < lineInfos.length; i++) {
+// if (lineInfos[i].matches(info)) {
+// return new Line.Info[] {targetLines[i].getLineInfo()};
+// }
+// }
+// throw new IllegalArgumentException("not supported " + info);
+// }
+// public Line[] getTargetLines() {
+// return targetLines;
+// }
+// public boolean isLineSupported(Line.Info info) {
+// for (int i = 0; i < lineInfos.length; i++) {
+// if (lineInfos[i].matches(info)) {
+// return true;
+// }
+// }
+// return false;
+// }
+// public boolean isSynchronizationSupported(Line[] lines, boolean maintainSync) {
+// return false;
+// }
+// public void synchronize(Line[] lines, boolean maintainSync) {}
+//
+// public void unsynchronize(Line[] lines) {}
+//
+// // methods of Line interface
+// public void close() {}
+// public Control getControl(Control.Type control) {
+// throw new IllegalArgumentException("not supported "+ control);
+// }
+// public Control[] getControls() {
+// return new Control[0];
+// }
+// public Line.Info getLineInfo() {
+// return new Line.Info(this.getClass());
+// }
+// public boolean isControlSupported(Control.Type control) {
+// return false;
+// }
+// public boolean isOpen() {
+// return false;
+// }
+// public void open() throws LineUnavailableException {}
+// public void removeLineListener(LineListener listener) {}
+// public void addLineListener(LineListener listener) {}
+//}
+//
+//class myClip implements Clip {
+// public int getFrameLength() { return 10;}
+// public long getMicrosecondLength() {return 100;}
+// public void loop(int count) {}
+// public void open(AudioFormat format, byte[] data, int offset, int bufferSize)
+// throws LineUnavailableException {}
+// public void open(AudioInputStream stream) throws LineUnavailableException,
+// IOException {}
+// public void setFramePosition(int frames) {}
+// public void setLoopPoints(int start, int end) {}
+// public void setMicrosecondPosition(long microseconds) {}
+// public int available() {return 1;}
+// public void drain() {}
+// public void flush() {}
+// public int getBufferSize() {return 1;}
+// public AudioFormat getFormat() {return null;}
+// public int getFramePosition() {return 1;}
+// public float getLevel() {return 1f;}
+// public long getLongFramePosition() {return 1;}
+// public long getMicrosecondPosition() {return 10;}
+// public boolean isActive() {return false;}
+// public boolean isRunning(){return false;}
+// public void start() {}
+// public void stop(){}
+// public void close() {}
+// public Control getControl(Control.Type control) {
+// throw new IllegalArgumentException("not supported "+ control);
+// }
+// public Control[] getControls() {
+// return new Control[0];
+// }
+// public Line.Info getLineInfo() {
+// return new Line.Info(this.getClass());
+// }
+// public boolean isControlSupported(Control.Type control) {
+// return false;
+// }
+// public boolean isOpen() {
+// return false;
+// }
+// public void open() throws LineUnavailableException {}
+// public void removeLineListener(LineListener listener) {}
+// public void addLineListener(LineListener listener) {}
+//}
+//
+//class mySourceDataLine implements SourceDataLine{
+// public void open(AudioFormat format) throws LineUnavailableException {}
+// public void open(AudioFormat format, int bufferSize)
+// throws LineUnavailableException {}
+// public int write(byte[] b, int off, int len) {return 1;}
+// public int available() {return 1;}
+// public void drain() {}
+// public void flush() {}
+// public int getBufferSize() {return 1;}
+// public AudioFormat getFormat() {return null;}
+// public int getFramePosition() {return 1;}
+// public float getLevel() {return 1f;}
+// public long getLongFramePosition() {return 1;}
+// public long getMicrosecondPosition() {return 10;}
+// public boolean isActive() {return false;}
+// public boolean isRunning(){return false;}
+// public void start() {}
+// public void stop(){}
+// public void close() {}
+// public Control getControl(Control.Type control) {
+// throw new IllegalArgumentException("not supported "+ control);
+// }
+// public Control[] getControls() {
+// return new Control[0];
+// }
+// public Line.Info getLineInfo() {
+// return new Line.Info(this.getClass());
+// }
+// public boolean isControlSupported(Control.Type control) {
+// return false;
+// }
+// public boolean isOpen() {
+// return false;
+// }
+// public void open() throws LineUnavailableException {}
+// public void removeLineListener(LineListener listener) {}
+// public void addLineListener(LineListener listener) {}
+//}
+//
+//class myTargetDataLine implements TargetDataLine {
+// public void open(AudioFormat format) throws LineUnavailableException{}
+// public void open(AudioFormat format, int bufferSize)
+// throws LineUnavailableException{}
+// public int read(byte[] b, int off, int len) {return 1;}
+// public int available() {return 1;}
+// public void drain() {}
+// public void flush() {}
+// public int getBufferSize() {return 1;}
+// public AudioFormat getFormat() {return null;}
+// public int getFramePosition() {return 1;}
+// public float getLevel() {return 1f;}
+// public long getLongFramePosition() {return 1;}
+// public long getMicrosecondPosition() {return 10;}
+// public boolean isActive() {return false;}
+// public boolean isRunning(){return false;}
+// public void start() {}
+// public void stop(){}
+// public void close() {}
+// public Control getControl(Control.Type control) {
+// throw new IllegalArgumentException("not supported "+ control);
+// }
+// public Control[] getControls() {
+// return new Control[0];
+// }
+// public Line.Info getLineInfo() {
+// return new Line.Info(this.getClass());
+// }
+// public boolean isControlSupported(Control.Type control) {
+// return false;
+// }
+// public boolean isOpen() {
+// return false;
+// }
+// public void open() throws LineUnavailableException {}
+// public void removeLineListener(LineListener listener) {}
+// public void addLineListener(LineListener listener) {}
+//}
+//
+//class myPort implements Port {
+// public void close() {}
+// public Control getControl(Control.Type control) {
+// throw new IllegalArgumentException("not supported "+ control);
+// }
+// public Control[] getControls() {
+// return new Control[0];
+// }
+// public Line.Info getLineInfo() {
+// return new Line.Info(this.getClass());
+// }
+// public boolean isControlSupported(Control.Type control) {
+// return false;
+// }
+// public boolean isOpen() {
+// return false;
+// }
+// public void open() throws LineUnavailableException {}
+// public void removeLineListener(LineListener listener) {}
+// public void addLineListener(LineListener listener) {}
+//}
Propchange: harmony/enhanced/classlib/trunk/modules/sound/src/test/java/org/apache/harmony/sound/tests/javax/sound/sampled/AudioSystemTest.java
------------------------------------------------------------------------------
svn:eol-style = native
Added: harmony/enhanced/classlib/trunk/modules/sound/src/test/resources/org/apache/harmony/sound/tests/javax/sound/sampled/soundProvider.jar
URL: http://svn.apache.org/viewvc/harmony/enhanced/classlib/trunk/modules/sound/src/test/resources/org/apache/harmony/sound/tests/javax/sound/sampled/soundProvider.jar?view=auto&rev=509169
==============================================================================
Binary file - no diff available.
Propchange: harmony/enhanced/classlib/trunk/modules/sound/src/test/resources/org/apache/harmony/sound/tests/javax/sound/sampled/soundProvider.jar
------------------------------------------------------------------------------
svn:mime-type = application/octet-stream