From 554fd8c5195424bdbcabf5de30fdc183aba391bd Mon Sep 17 00:00:00 2001 From: upstream source tree Date: Sun, 15 Mar 2015 20:14:05 -0400 Subject: obtained gcc-4.6.4.tar.bz2 from upstream website; verified gcc-4.6.4.tar.bz2.sig; imported gcc-4.6.4 source tree from verified upstream tarball. downloading a git-generated archive based on the 'upstream' tag should provide you with a source tree that is binary identical to the one extracted from the above tarball. if you have obtained the source via the command 'git clone', however, do note that line-endings of files in your working directory might differ from line-endings of the respective files in the upstream repository. --- .../javax/sound/midi/ControllerEventListener.java | 58 ++ libjava/classpath/javax/sound/midi/Instrument.java | 77 +++ .../javax/sound/midi/InvalidMidiDataException.java | 69 ++ .../javax/sound/midi/MetaEventListener.java | 58 ++ .../classpath/javax/sound/midi/MetaMessage.java | 176 +++++ .../classpath/javax/sound/midi/MidiChannel.java | 236 +++++++ libjava/classpath/javax/sound/midi/MidiDevice.java | 220 ++++++ libjava/classpath/javax/sound/midi/MidiEvent.java | 95 +++ .../classpath/javax/sound/midi/MidiFileFormat.java | 158 +++++ .../classpath/javax/sound/midi/MidiMessage.java | 126 ++++ libjava/classpath/javax/sound/midi/MidiSystem.java | 570 ++++++++++++++++ .../javax/sound/midi/MidiUnavailableException.java | 69 ++ libjava/classpath/javax/sound/midi/Patch.java | 86 +++ libjava/classpath/javax/sound/midi/Receiver.java | 66 ++ libjava/classpath/javax/sound/midi/Sequence.java | 248 +++++++ libjava/classpath/javax/sound/midi/Sequencer.java | 402 +++++++++++ .../classpath/javax/sound/midi/ShortMessage.java | 336 +++++++++ libjava/classpath/javax/sound/midi/Soundbank.java | 101 +++ .../javax/sound/midi/SoundbankResource.java | 104 +++ .../classpath/javax/sound/midi/Synthesizer.java | 173 +++++ .../classpath/javax/sound/midi/SysexMessage.java | 138 ++++ libjava/classpath/javax/sound/midi/Track.java | 164 +++++ .../classpath/javax/sound/midi/Transmitter.java | 70 ++ .../classpath/javax/sound/midi/VoiceStatus.java | 79 +++ .../javax/sound/midi/spi/MidiDeviceProvider.java | 90 +++ .../javax/sound/midi/spi/MidiFileReader.java | 125 ++++ .../javax/sound/midi/spi/MidiFileWriter.java | 143 ++++ .../javax/sound/midi/spi/SoundbankReader.java | 97 +++ .../javax/sound/sampled/AudioFileFormat.java | 242 +++++++ .../classpath/javax/sound/sampled/AudioFormat.java | 366 ++++++++++ .../javax/sound/sampled/AudioInputStream.java | 258 +++++++ .../javax/sound/sampled/AudioPermission.java | 70 ++ .../classpath/javax/sound/sampled/AudioSystem.java | 751 +++++++++++++++++++++ .../javax/sound/sampled/BooleanControl.java | 144 ++++ libjava/classpath/javax/sound/sampled/Clip.java | 115 ++++ .../javax/sound/sampled/CompoundControl.java | 104 +++ libjava/classpath/javax/sound/sampled/Control.java | 111 +++ .../classpath/javax/sound/sampled/DataLine.java | 271 ++++++++ .../classpath/javax/sound/sampled/EnumControl.java | 126 ++++ .../javax/sound/sampled/FloatControl.java | 267 ++++++++ libjava/classpath/javax/sound/sampled/Line.java | 150 ++++ .../classpath/javax/sound/sampled/LineEvent.java | 170 +++++ .../javax/sound/sampled/LineListener.java | 55 ++ .../sound/sampled/LineUnavailableException.java | 61 ++ libjava/classpath/javax/sound/sampled/Mixer.java | 206 ++++++ libjava/classpath/javax/sound/sampled/Port.java | 135 ++++ .../classpath/javax/sound/sampled/ReverbType.java | 144 ++++ .../javax/sound/sampled/SourceDataLine.java | 77 +++ .../javax/sound/sampled/TargetDataLine.java | 79 +++ .../sampled/UnsupportedAudioFileException.java | 65 ++ .../javax/sound/sampled/spi/AudioFileReader.java | 146 ++++ .../javax/sound/sampled/spi/AudioFileWriter.java | 131 ++++ .../sampled/spi/FormatConversionProvider.java | 179 +++++ .../javax/sound/sampled/spi/MixerProvider.java | 86 +++ 54 files changed, 8843 insertions(+) create mode 100644 libjava/classpath/javax/sound/midi/ControllerEventListener.java create mode 100644 libjava/classpath/javax/sound/midi/Instrument.java create mode 100644 libjava/classpath/javax/sound/midi/InvalidMidiDataException.java create mode 100644 libjava/classpath/javax/sound/midi/MetaEventListener.java create mode 100644 libjava/classpath/javax/sound/midi/MetaMessage.java create mode 100644 libjava/classpath/javax/sound/midi/MidiChannel.java create mode 100644 libjava/classpath/javax/sound/midi/MidiDevice.java create mode 100644 libjava/classpath/javax/sound/midi/MidiEvent.java create mode 100644 libjava/classpath/javax/sound/midi/MidiFileFormat.java create mode 100644 libjava/classpath/javax/sound/midi/MidiMessage.java create mode 100644 libjava/classpath/javax/sound/midi/MidiSystem.java create mode 100644 libjava/classpath/javax/sound/midi/MidiUnavailableException.java create mode 100644 libjava/classpath/javax/sound/midi/Patch.java create mode 100644 libjava/classpath/javax/sound/midi/Receiver.java create mode 100644 libjava/classpath/javax/sound/midi/Sequence.java create mode 100644 libjava/classpath/javax/sound/midi/Sequencer.java create mode 100644 libjava/classpath/javax/sound/midi/ShortMessage.java create mode 100644 libjava/classpath/javax/sound/midi/Soundbank.java create mode 100644 libjava/classpath/javax/sound/midi/SoundbankResource.java create mode 100644 libjava/classpath/javax/sound/midi/Synthesizer.java create mode 100644 libjava/classpath/javax/sound/midi/SysexMessage.java create mode 100644 libjava/classpath/javax/sound/midi/Track.java create mode 100644 libjava/classpath/javax/sound/midi/Transmitter.java create mode 100644 libjava/classpath/javax/sound/midi/VoiceStatus.java create mode 100644 libjava/classpath/javax/sound/midi/spi/MidiDeviceProvider.java create mode 100644 libjava/classpath/javax/sound/midi/spi/MidiFileReader.java create mode 100644 libjava/classpath/javax/sound/midi/spi/MidiFileWriter.java create mode 100644 libjava/classpath/javax/sound/midi/spi/SoundbankReader.java create mode 100644 libjava/classpath/javax/sound/sampled/AudioFileFormat.java create mode 100644 libjava/classpath/javax/sound/sampled/AudioFormat.java create mode 100644 libjava/classpath/javax/sound/sampled/AudioInputStream.java create mode 100644 libjava/classpath/javax/sound/sampled/AudioPermission.java create mode 100644 libjava/classpath/javax/sound/sampled/AudioSystem.java create mode 100644 libjava/classpath/javax/sound/sampled/BooleanControl.java create mode 100644 libjava/classpath/javax/sound/sampled/Clip.java create mode 100644 libjava/classpath/javax/sound/sampled/CompoundControl.java create mode 100644 libjava/classpath/javax/sound/sampled/Control.java create mode 100644 libjava/classpath/javax/sound/sampled/DataLine.java create mode 100644 libjava/classpath/javax/sound/sampled/EnumControl.java create mode 100644 libjava/classpath/javax/sound/sampled/FloatControl.java create mode 100644 libjava/classpath/javax/sound/sampled/Line.java create mode 100644 libjava/classpath/javax/sound/sampled/LineEvent.java create mode 100644 libjava/classpath/javax/sound/sampled/LineListener.java create mode 100644 libjava/classpath/javax/sound/sampled/LineUnavailableException.java create mode 100644 libjava/classpath/javax/sound/sampled/Mixer.java create mode 100644 libjava/classpath/javax/sound/sampled/Port.java create mode 100644 libjava/classpath/javax/sound/sampled/ReverbType.java create mode 100644 libjava/classpath/javax/sound/sampled/SourceDataLine.java create mode 100644 libjava/classpath/javax/sound/sampled/TargetDataLine.java create mode 100644 libjava/classpath/javax/sound/sampled/UnsupportedAudioFileException.java create mode 100644 libjava/classpath/javax/sound/sampled/spi/AudioFileReader.java create mode 100644 libjava/classpath/javax/sound/sampled/spi/AudioFileWriter.java create mode 100644 libjava/classpath/javax/sound/sampled/spi/FormatConversionProvider.java create mode 100644 libjava/classpath/javax/sound/sampled/spi/MixerProvider.java (limited to 'libjava/classpath/javax/sound') diff --git a/libjava/classpath/javax/sound/midi/ControllerEventListener.java b/libjava/classpath/javax/sound/midi/ControllerEventListener.java new file mode 100644 index 000000000..8349de057 --- /dev/null +++ b/libjava/classpath/javax/sound/midi/ControllerEventListener.java @@ -0,0 +1,58 @@ +/* ControllerEventListener.java -- Listener for MIDI controller events + 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.midi; + +import java.util.EventListener; + +/** + * The interface defines the methods to be implemented by classes wanting + * to be notified on MIDI controller events from a Sequencer. + * + * @author Anthony Green (green@redhat.com) + * @since 1.3 + * + */ +public interface ControllerEventListener extends EventListener +{ + /** + * Called on MIDI controller events. + * @param event the controller change event message + */ + public void controlChange(ShortMessage event); +} diff --git a/libjava/classpath/javax/sound/midi/Instrument.java b/libjava/classpath/javax/sound/midi/Instrument.java new file mode 100644 index 000000000..a8626faeb --- /dev/null +++ b/libjava/classpath/javax/sound/midi/Instrument.java @@ -0,0 +1,77 @@ +/* Instrument.java -- A MIDI Instrument + 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.midi; + +/** + * The abstract base class for all MIDI instruments. + * + * @author Anthony Green (green@redhat.com) + * @since 1.3 + * + */ +public abstract class Instrument extends SoundbankResource +{ + // The instrument patch. + private Patch patch; + + /** + * Create a new Instrument. + * + * @param soundbank the Soundbank containing the instrument. + * @param patch the patch for this instrument + * @param name the name of this instrument + * @param dataClass the class used to represent sample data for this instrument + */ + protected Instrument(Soundbank soundbank, Patch patch, + String name, Class dataClass) + { + super(soundbank, name, dataClass); + this.patch = patch; + } + + /** + * Get the patch for this instrument. + * + * @return the patch for this instrument + */ + public Patch getPatch() + { + return patch; + } +} diff --git a/libjava/classpath/javax/sound/midi/InvalidMidiDataException.java b/libjava/classpath/javax/sound/midi/InvalidMidiDataException.java new file mode 100644 index 000000000..6325b04e0 --- /dev/null +++ b/libjava/classpath/javax/sound/midi/InvalidMidiDataException.java @@ -0,0 +1,69 @@ +/* InvalidMidiDataException.java -- Thrown for invalid MIDI data. + 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.midi; + +/** + * This exception is thrown when we encounter bad MIDI data. + * + * @author Anthony Green (green@redhat.com) + * @since 1.3 + * + */ +public class InvalidMidiDataException extends Exception +{ + private static final long serialVersionUID = 2780771756789932067L; + + /** + * Create an InvalidMidiDataException object. + */ + public InvalidMidiDataException() + { + super(); + } + + /** + * Create an InvalidMidiDataException object. + * + * @param s the exception message string + */ + public InvalidMidiDataException(String s) + { + super(s); + } +} diff --git a/libjava/classpath/javax/sound/midi/MetaEventListener.java b/libjava/classpath/javax/sound/midi/MetaEventListener.java new file mode 100644 index 000000000..28a7a9de4 --- /dev/null +++ b/libjava/classpath/javax/sound/midi/MetaEventListener.java @@ -0,0 +1,58 @@ +/* MetaEventListener.java -- Listener for MIDI meta events + 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.midi; + +import java.util.EventListener; + +/** + * The interface defines the methods to be implemented by classes wanting + * to be notified on MIDI meta events from a Sequencer. + * + * @author Anthony Green (green@redhat.com) + * @since 1.3 + * + */ +public interface MetaEventListener extends EventListener +{ + /** + * Called on MIDI meta events. + * @param meta the meta event message + */ + public void meta(MetaMessage meta); +} diff --git a/libjava/classpath/javax/sound/midi/MetaMessage.java b/libjava/classpath/javax/sound/midi/MetaMessage.java new file mode 100644 index 000000000..4d43975c3 --- /dev/null +++ b/libjava/classpath/javax/sound/midi/MetaMessage.java @@ -0,0 +1,176 @@ +/* MetaMessage.java -- A meta message for MIDI files. + 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.midi; + +/** + * A system exclusive MIDI message. + * + * @author Anthony Green (green@redhat.com) + * @since 1.3 + * + */ +public class MetaMessage extends MidiMessage +{ + /** + * The META status code. Only valid for MIDI files, not the wire protocol. + */ + public static final int META = 0xFF; + + // The length of the variable length data length encoding. + private int lengthLength = 0; + + /** + * Create a default valid meta message. + * + * The official specs don't specify what message is to be + * created. For now, we create a zero length meta message + * with a type code of 0. + */ + public MetaMessage() + { + super(new byte[4]); + data[0] = (byte) META; + data[1] = (byte) 0; // Type + data[2] = (byte) 1; // Length length + data[3] = (byte) 0; // Length + lengthLength = 1; + } + + /** + * Create a MetaMessage object. + * @param data a complete system exclusive message + */ + protected MetaMessage(byte[] data) + { + super(data); + int index = 2; + lengthLength = 1; + while ((data[index++] & 0x80) > 0) + lengthLength++; + } + + /** + * Set the meta message. + * + * @param type the meta type byte (< 128) + * @param data the message data + * @param length the length of the message data + * @throws InvalidMidiDataException if this message is invalid + */ + public void setMessage(int type, byte[] data, int length) + throws InvalidMidiDataException + { + if (type > 127) + throw new InvalidMidiDataException("Meta type 0x" + + Integer.toHexString(type) + + " must be less than 128"); + + // For a nice description of how variable length values are handled, + // see http://www.borg.com/~jglatt/tech/midifile.htm + + // First compute the length of the length value + lengthLength = 0; + int lengthValue = length; + do { + lengthValue = lengthValue >> 7; + lengthLength++; + } while (lengthValue > 0); + + // Now allocate our data array + this.length = 2 + lengthLength + length; + this.data = new byte[this.length]; + this.data[0] = (byte) META; + this.data[1] = (byte) type; + + // Now compute the length representation + long buffer = length & 0x7F; + while ((length >>= 7) > 0) + { + buffer <<= 8; + buffer |= ((length & 0x7F) | 0x80); + } + + // Now store the variable length length value + int index = 2; + do + { + this.data[index++] = (byte) (buffer & 0xFF); + if ((buffer & 0x80) == 0) + break; + buffer >>= 8; + } while (true); + + // Now copy the real data. + System.arraycopy(data, 0, this.data, index, length); + } + + /** + * Get the meta message type. + * + * @return the meta message type + */ + public int getType() + { + return data[1]; + } + + /** + * Get the data for this message, not including the status, + * type, or length information. + * + * @return the message data, not including status, type or lenght info + */ + public byte[] getData() + { + int dataLength = length - 2 - lengthLength; + byte[] result = new byte[dataLength]; + System.arraycopy(data, 2 + lengthLength, result, 0, dataLength); + return result; + } + + /* Create a deep-copy clone of this object. + * @see java.lang.Object#clone() + */ + public Object clone() + { + byte message[] = new byte[length]; + System.arraycopy(data, 0, message, 0, length); + return new MetaMessage(message); + } +} diff --git a/libjava/classpath/javax/sound/midi/MidiChannel.java b/libjava/classpath/javax/sound/midi/MidiChannel.java new file mode 100644 index 000000000..36da51d0f --- /dev/null +++ b/libjava/classpath/javax/sound/midi/MidiChannel.java @@ -0,0 +1,236 @@ +/* MidiChannel.java -- A MIDI channel + 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.midi; + +/** + * A MIDI channel. + * + * @author Anthony Green (green@redhat.com) + * @since 1.3 + * + */ +public interface MidiChannel +{ + + /** + * Start playing a note. + * + * @param noteNumber the MIDI note number + * @param velocity the velocity at which the key was pressed + */ + public void noteOn(int noteNumber, int velocity); + + /** + * Stop playing a note. + * + * @param noteNumber the MIDI note number + * @param velocity the volcity at which the ket was released + */ + public void noteOff(int noteNumber, int velocity); + + /** + * Stop playing a note. + * + * @param noteNumber the MIDI note number + */ + public void noteOff(int noteNumber); + + /** + * Change in a key pressure for a note. + * + * @param noteNumber the MIDI note number + * @param pressure the key pressure + */ + public void setPolyPressure(int noteNumber, int pressure); + + /** + * Get the key pressure for a note. + * + * @param noteNumber the MIDI note number + * @return the key pressure + */ + public int getPolyPressure(int noteNumber); + + /** + * Set the key pressure for the channel. + * + * @param pressure the key pressure + */ + public void setChannelPressure(int pressure); + + /** + * Get the key pressure for the channel. + * + * @return the key pressure + */ + public int getChannelPressure(); + + /** + * Set a change in a controller's value. + * + * @param controller the MIDI controller number (0 to 127) + * @param value the new value (0 to 127) + */ + public void controlChange(int controller, int value); + + /** + * Get a controller's value. + * + * @param controller the MIDI controller number (0 to 127) + * @return the controller's value (0 to 127) + */ + public int getController(int controller); + + /** + * Change the patch for this channel. + * + * @param program the patch number to switch to (0 to 127) + */ + public void programChange(int program); + + /** + * Change the bank and patch for this channel. + * + * @param bank the bank to switch to (0 to 16383) + * @param program the patch to switch to (0 to 127) + */ + public void programChange(int bank, int program); + + /** + * Get the current patch for this channel. + * + * @return current patch (0 to 127) + */ + public int getProgram(); + + /** + * Change the pitch bend for this channel using a positive 14-bit value. + * + * @param bend the new pitch bend value + */ + public void setPitchBend(int bend); + + /** + * Get the pitch bend for this channel as a positive 14-bit value. + * + * @return the current patch bend value + */ + public int getPitchBend(); + + /** + * Reset all MIDI controllers to their default values. + */ + public void resetAllControllers(); + + /** + * Stop playing all notes. Sound may not stop. + */ + public void allNotesOff(); + + /** + * Stop all sound. + */ + public void allSoundOff(); + + /** + * Set whether or not local controls are on or off. They are on by + * default. + * + * @param on true to enable local controls, false to disable + * @return the new value + */ + public boolean localControl(boolean on); + + /** + * Turns mono mode on or off. + * + * @param on true to enable mono mode, false to disable + */ + public void setMono(boolean on); + + /** + * Get the current mono mode. + * + * @return true if mono is enabled, false otherwise + */ + public boolean getMono(); + + /** + * Turns omni mode on or off. + * + * @param on true to enable omni mode, false to disable + */ + public void setOmni(boolean on); + + /** + * Get the current omni mode. + * + * @return true if omni is enabled, false otherwise + */ + public boolean getOmni(); + + /** + * Turns mute mode on or off. + * + * @param mute true to enable mute mode, false to disable + */ + public void setMute(boolean mute); + + /** + * Get the current mute mode. + * + * @return true if mute is enabled, false otherwise + */ + public boolean getMute(); + + /** + * Turns solo mode on or off. If any channels are soloed, then only those + * channels make sounds, otherwise all channels will make sound. + * + * @param solo true to enable solo mode, false to disable + */ + public void setSolo(boolean solo); + + /** + * Get the current solo mode. + * + * @return true is solo is enabled, false otherwise. + */ + public boolean getSolo(); +} diff --git a/libjava/classpath/javax/sound/midi/MidiDevice.java b/libjava/classpath/javax/sound/midi/MidiDevice.java new file mode 100644 index 000000000..7a0ca7f2b --- /dev/null +++ b/libjava/classpath/javax/sound/midi/MidiDevice.java @@ -0,0 +1,220 @@ +/* MidiDevice.java -- Interface for MIDI devices + 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.midi; + +/** + * Interface for all MIDI devices. + * + * @author Anthony Green (green@redhat.com) + * @since 1.3 + * + */ +public interface MidiDevice +{ + /** + * Get the Info object describing this device. + * @return the Info object describing this device + */ + public Info getDeviceInfo(); + + /** + * Open this MIDI device and allocate any system resource we need. + * + * @throws MidiUnavailableException if we're not able to open for some reason + */ + public void open() throws MidiUnavailableException; + + /** + * Close this MIDI device, and release any system resources we're using. + */ + public void close(); + + /** + * Returns true if this MIDI device is open and false otherwise. + * + * @return true if this is open, false otherwise + */ + public boolean isOpen(); + + /** + * If this device supports time-stamps, then it will return the number + * of microseconds since this device has been open, and -1 otherwise. + * + * @return -1 or the number of microseconds since this was opened + */ + public long getMicrosecondPosition(); + + /** + * The maximum number of MIDI IN connections we can get as Receivers, + * or -1 if there is no maximum. + * + * @return -1 or the maximum number of Receivers we can get + */ + public int getMaxReceivers(); + + /** + * The maximum number of MIDI OUT connections we can get as Transmitters, + * or -1 if there is no maximum. + * + * @return -1 or the maximum number of Transmitters we can get + */ + public int getMaxTransmitters(); + + /** + * Get a MIDI IN Receiver for this device. + * + * @return a MIDI IN Receiver for this device + * @throws MidiUnavailableException if we can't get a Receiver + */ + public Receiver getReceiver() throws MidiUnavailableException; + + /** + * Get a MIDI OUT Transmitter for this device. + * + * @return a MIDI OUT Transmitter for this device + * @throws MidiUnavailableException if we can't get a Transmitter + */ + public Transmitter getTransmitter() throws MidiUnavailableException; + + /** + * A MIDI device descriptor object. + * + * @author green@redhat.com + * + */ + public static class Info + { + // Private data describing this device + private String name; + private String vendor; + private String description; + private String version; + + /** + * Create an Info object for a MIDI device + * + * @param name the device name + * @param vendor the vendor name + * @param description the device description + * @param version the device version string + */ + protected Info(String name, String vendor, String description, String version) + { + this.name = name; + this.vendor = vendor; + this.description = description; + this.version = version; + } + + /** + * This equals method only returns true if this object + * is the same as obj. + * + * @param obj the object we're comparing to + * @return true if this is the same object + * @see java.lang.Object#equals(java.lang.Object) + */ + public final boolean equals(Object obj) + { + return super.equals(obj); + } + + /** + * A hash code for this object. + * + * @return the hash code for this object + * @see java.lang.Object#hashCode() + */ + public final int hashCode() + { + return super.hashCode(); + } + + /** + * Get the device name. + * + * @return the device name + */ + public final String getName() + { + return name; + } + + /** + * Get the device vendor. + * + * @return the device vendor + */ + public final String getVendor() + { + return vendor; + } + + /** + * Get the device description + * + * @return the device description + */ + public final String getDescription() + { + return description; + } + + /** + * get the device version + * + * @return the device version + */ + public final String getVersion() + { + return version; + } + + /** + * Simple return the name of the device. + * + * @return the device name + * @see java.lang.Object#toString() + */ + public final String toString() + { + return name; + } + } +} diff --git a/libjava/classpath/javax/sound/midi/MidiEvent.java b/libjava/classpath/javax/sound/midi/MidiEvent.java new file mode 100644 index 000000000..3b0072cfa --- /dev/null +++ b/libjava/classpath/javax/sound/midi/MidiEvent.java @@ -0,0 +1,95 @@ +/* MidiEvent.java -- A MIDI Event + 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.midi; + +/** + * A MIDI event is the combination of a MIDI message and a timestamp specified + * in MIDI ticks. + * + * @author Anthony Green (green@redhat.com) + * @since 1.3 + * + */ +public class MidiEvent +{ + private final MidiMessage message; + private long tick; + + /** + * Create a MIDI event object from the given MIDI message and timestamp. + * + * @param message the MidiMessage for this event + * @param tick the timestamp for this event + */ + public MidiEvent(MidiMessage message, long tick) + { + this.message = message; + this.tick = tick; + } + + /** + * Get the MIDI message for this event. + * + * @return the MidiMessage for this event + */ + public MidiMessage getMessage() + { + return message; + } + + /** + * Set the timestemp for this event in MIDI ticks. + * + * @param tick the timestamp + */ + public void setTick(long tick) + { + this.tick = tick; + } + + /** + * Get the timestamp for this event in MIDI ticks. + * + * @return the timestamp for this even in MIDI ticks + */ + public long getTick() + { + return tick; + } +} diff --git a/libjava/classpath/javax/sound/midi/MidiFileFormat.java b/libjava/classpath/javax/sound/midi/MidiFileFormat.java new file mode 100644 index 000000000..73744523d --- /dev/null +++ b/libjava/classpath/javax/sound/midi/MidiFileFormat.java @@ -0,0 +1,158 @@ +/* MidiFileFormat.java -- Information about a MIDI file + 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.midi; + +/** + * Describe a MIDI file, including specifics about its type, length and timing. + * + * @author Anthony Green (green@redhat.com) + * @since 1.3 + * + */ +public class MidiFileFormat +{ + /** + * The MIDI file type. This is either 0, 1 or 2. + * + * Type 0 files contain a single track and represents a single song + * performance. + * Type 1 may contain multiple tracks for a single song performance. + * Type 2 may contain multiple tracks, each representing a + * separate song performance. + * + * See http://en.wikipedia.org/wiki/MIDI#MIDI_file_formats for more + * information. + */ + protected int type; + + /** + * The division type of the MIDI file. + */ + protected float divisionType; + + /** + * The timing resolution of the MIDI file. + */ + protected int resolution; + + /** + * The size of the MIDI file in bytes. + */ + protected int byteLength = UNKNOWN_LENGTH; + + /** + * The length of the MIDI file in microseconds. + */ + protected long microsecondLength = UNKNOWN_LENGTH; + + /** + * A special value indicating an unknown quantity. + */ + public static final int UNKNOWN_LENGTH = -1; // FIXME is this really -1? + + /** + * Create a MidiFileFormat object from the given parameters. + * + * @param type the MIDI file type (0, 1, or 2) + * @param divisionType the MIDI file division type + * @param resolution the MIDI file timing resolution + * @param bytes the MIDI file size in bytes + * @param microseconds the MIDI file length in microseconds + */ + public MidiFileFormat(int type, float divisionType, + int resolution, int bytes, long microseconds) + { + this.type = type; + this.divisionType = divisionType; + this.resolution = resolution; + this.byteLength = bytes; + this.microsecondLength = microseconds; + } + + /** + * Get the MIDI file type (0, 1, or 2). + * + * @return the MIDI file type (0, 1, or 2) + */ + public int getType() + { + return type; + } + + /** + * Get the file division type. + * + * @return the file divison type + */ + public float getDivisionType() + { + return divisionType; + } + + /** + * Get the file timing resolution. If the division type is PPQ, then this + * is value represents ticks per beat, otherwise it's ticks per frame (SMPTE). + * + * @return the timing resolution in ticks per beat or ticks per frame + */ + public int getResolution() + { + return resolution; + } + + /** + * Get the file length in bytes. + * + * @return the file length in bytes or UNKNOWN_LENGTH + */ + public int getByteLength() + { + return byteLength; + } + + /** + * Get the file length in microseconds. + * + * @return the file length in microseconds or UNKNOWN_LENGTH + */ + public long getMicrosecondLength() + { + return microsecondLength; + } +} diff --git a/libjava/classpath/javax/sound/midi/MidiMessage.java b/libjava/classpath/javax/sound/midi/MidiMessage.java new file mode 100644 index 000000000..806615199 --- /dev/null +++ b/libjava/classpath/javax/sound/midi/MidiMessage.java @@ -0,0 +1,126 @@ +/* MidiMessage.java -- base class for MIDI messages. + 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.midi; + +/** + * The base class for all MIDI messages. + * + * @author Anthony Green (green@redhat.com) + * @since 1.3 + * + */ +public abstract class MidiMessage implements Cloneable +{ + /** + * MIDI message data. + */ + protected byte data[]; + + /** + * The total length of the MIDI message. + */ + protected int length; + + /** + * MidiMessage contructor. + * + * @param data a valid MIDI message + */ + protected MidiMessage(byte[] data) + { + this.data = data; + this.length = data.length; + } + + /** + * Set the complete MIDI message. + * + * @param data The complete MIDI message. + * @param length The length of the MIDI message. + * @throws InvalidMidiDataException Thrown when the MIDI message is invalid. + */ + protected void setMessage(byte[] data, int length) + throws InvalidMidiDataException + { + this.data = new byte[length]; + System.arraycopy(data, 0, this.data, 0, length); + this.length = length; + } + + /** + * Get the MIDI message data. + * + * @return an array containing the MIDI message data + */ + public byte[] getMessage() + { + byte copy[] = new byte[length]; + System.arraycopy(data, 0, copy, 0, length); + return copy; + } + + /** + * Get the status byte of the MIDI message (as an int) + * + * @return the status byte of the MIDI message (as an int), or zero if the message length is zero. + */ + public int getStatus() + { + if (length > 0) + return (data[0] & 0xff); + else + return 0; + } + + /** + * Get the length of the MIDI message. + * + * @return the length of the MIDI messsage + */ + public int getLength() + { + return length; + } + + /* Create a clone of this object. + * + * @see java.lang.Object#clone() + */ + public abstract Object clone(); +} diff --git a/libjava/classpath/javax/sound/midi/MidiSystem.java b/libjava/classpath/javax/sound/midi/MidiSystem.java new file mode 100644 index 000000000..b273b98e5 --- /dev/null +++ b/libjava/classpath/javax/sound/midi/MidiSystem.java @@ -0,0 +1,570 @@ +/* MidiSystem.java -- Access system MIDI resources + 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.midi; + +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.ArrayList; +import java.util.List; +import java.util.Iterator; + +import javax.sound.midi.spi.MidiDeviceProvider; +import javax.sound.midi.spi.MidiFileReader; +import javax.sound.midi.spi.MidiFileWriter; +import javax.sound.midi.spi.SoundbankReader; + +/** + * MidiSystem provides access to the computer system's MIDI resources, + * as well as utility routines for reading MIDI files and more. + * + * @author Anthony Green (green@redhat.com) + * @since 1.3 + * + */ +public class MidiSystem +{ + private MidiSystem() + { + // Not instantiable. + } + + /** + * Get an array of all available MIDI devices. + * + * @return a possibly empty array of all available MIDI devices + */ + public static MidiDevice.Info[] getMidiDeviceInfo() + { + Iterator deviceProviders = + ServiceFactory.lookupProviders(MidiDeviceProvider.class); + List infoList = new ArrayList(); + + while (deviceProviders.hasNext()) + { + MidiDeviceProvider provider = (MidiDeviceProvider) deviceProviders.next(); + MidiDevice.Info[] infos = provider.getDeviceInfo(); + for (int i = infos.length; i > 0; ) + infoList.add(infos[--i]); + } + + return (MidiDevice.Info[]) + infoList.toArray(new MidiDevice.Info[infoList.size()]); + } + + /** + * Get the specified MIDI device. + * + * @param info a description of the device we're looking for + * @return the requested MIDI device + * @throws MidiUnavailableException if no MIDI devices are configured or found + * @throws IllegalArgumentException if the device described by info is not found + */ + public static MidiDevice getMidiDevice(MidiDevice.Info info) + throws MidiUnavailableException + { + Iterator deviceProviders = + ServiceFactory.lookupProviders(MidiDeviceProvider.class); + + if (! deviceProviders.hasNext()) + throw new MidiUnavailableException("No MIDI device providers available."); + + do + { + MidiDeviceProvider provider = + (MidiDeviceProvider) deviceProviders.next(); + if (provider.isDeviceSupported(info)) + return provider.getDevice(info); + } while (deviceProviders.hasNext()); + + throw new IllegalArgumentException("MIDI device " + + info + " not available."); + } + + /** + * Get the default Receiver instance. This just picks the first one + * it finds for now. + * + * @return the default Receiver instance + * @throws MidiUnavailableException if no Receiver is found + */ + public static Receiver getReceiver() throws MidiUnavailableException + { + // TODO: The 1.5 spec has a fancy mechanism to specify the default + // receiver device. For now, well just return the first one we find. + MidiDevice.Info[] infos = getMidiDeviceInfo(); + for (int i = 0; i < infos.length; i++) + { + MidiDevice device = getMidiDevice(infos[i]); + if (device instanceof Receiver) + return (Receiver) device; + } + throw new MidiUnavailableException("No Receiver device available"); + } + + /** + * Get the default Transmitter instance. This just picks the first one + * it finds for now. + * + * @return the default Transmitter instance + * @throws MidiUnavailableException if no Transmitter is found + */ + public static Transmitter getTransmitter() throws MidiUnavailableException + { + // TODO: The 1.5 spec has a fancy mechanism to specify the default + // Transmitter device. For now, well just return the first one we find. + MidiDevice.Info[] infos = getMidiDeviceInfo(); + for (int i = 0; i < infos.length; i++) + { + MidiDevice device = getMidiDevice(infos[i]); + if (device instanceof Transmitter) + return (Transmitter) device; + } + throw new MidiUnavailableException("No Transmitter device available"); + } + + /** + * Get the default Synthesizer instance. This just picks the first one + * it finds for now. + * + * @return the default Synthesizer instance + * @throws MidiUnavailableException if no Synthesizer is found + */ + public static Synthesizer getSynthesizer() throws MidiUnavailableException + { + // TODO: The 1.5 spec has a fancy mechanism to specify the default + // Synthesizer device. For now, well just return the first one we find. + MidiDevice.Info[] infos = getMidiDeviceInfo(); + for (int i = 0; i < infos.length; i++) + { + MidiDevice device = getMidiDevice(infos[i]); + if (device instanceof Synthesizer) + return (Synthesizer) device; + } + throw new MidiUnavailableException("No Synthesizer device available"); + } + + /** + * Get the default Sequencer instance. This just picks the first one + * it finds for now. + * + * @return the default Sequencer instance + * @throws MidiUnavailableException if no Sequencer is found + */ + public static Sequencer getSequencer() throws MidiUnavailableException + { + // TODO: The 1.5 spec has a fancy mechanism to specify the default + // Sequencer device. For now, well just return the first one we find. + MidiDevice.Info[] infos = getMidiDeviceInfo(); + for (int i = 0; i < infos.length; i++) + { + MidiDevice device = getMidiDevice(infos[i]); + if (device instanceof Sequencer) + return (Sequencer) device; + } + throw new MidiUnavailableException("No Sequencer device available"); + } + + /** + * Read a Soundbank object from the given stream. + * + * @param stream the stream from which to read the Soundbank + * @return the Soundbank object + * @throws InvalidMidiDataException if we were unable to read the soundbank + * @throws IOException if an I/O error happened while reading + */ + public static Soundbank getSoundbank(InputStream stream) + throws InvalidMidiDataException, IOException + { + Iterator readers = ServiceFactory.lookupProviders(SoundbankReader.class); + while (readers.hasNext()) + { + SoundbankReader sr = (SoundbankReader) readers.next(); + Soundbank sb = sr.getSoundbank(stream); + if (sb != null) + return sb; + } + throw new InvalidMidiDataException("Cannot read soundbank from stream"); + } + + /** + * Read a Soundbank object from the given url. + * + * @param url the url from which to read the Soundbank + * @return the Soundbank object + * @throws InvalidMidiDataException if we were unable to read the soundbank + * @throws IOException if an I/O error happened while reading + */ + public static Soundbank getSoundbank(URL url) + throws InvalidMidiDataException, IOException + { + Iterator readers = ServiceFactory.lookupProviders(SoundbankReader.class); + while (readers.hasNext()) + { + SoundbankReader sr = (SoundbankReader) readers.next(); + Soundbank sb = sr.getSoundbank(url); + if (sb != null) + return sb; + } + throw new InvalidMidiDataException("Cannot read from url " + url); + } + + /** + * Read a Soundbank object from the given file. + * + * @param file the file from which to read the Soundbank + * @return the Soundbank object + * @throws InvalidMidiDataException if we were unable to read the soundbank + * @throws IOException if an I/O error happened while reading + */ + public static Soundbank getSoundbank(File file) + throws InvalidMidiDataException, IOException + { + Iterator readers = ServiceFactory.lookupProviders(SoundbankReader.class); + while (readers.hasNext()) + { + SoundbankReader sr = (SoundbankReader) readers.next(); + Soundbank sb = sr.getSoundbank(file); + if (sb != null) + return sb; + } + throw new InvalidMidiDataException("Cannot read soundbank from file " + + file); + } + + /** + * Read a MidiFileFormat object from the given stream. + * + * @param stream the stream from which to read the MidiFileFormat + * @return the MidiFileFormat object + * @throws InvalidMidiDataException if we were unable to read the MidiFileFormat + * @throws IOException if an I/O error happened while reading + */ + public static MidiFileFormat getMidiFileFormat(InputStream stream) + throws InvalidMidiDataException, IOException + { + Iterator readers = ServiceFactory.lookupProviders(MidiFileReader.class); + while (readers.hasNext()) + { + MidiFileReader sr = (MidiFileReader) readers.next(); + MidiFileFormat sb = sr.getMidiFileFormat(stream); + if (sb != null) + return sb; + } + throw new InvalidMidiDataException("Can't read MidiFileFormat from stream"); + } + + /** + * Read a MidiFileFormat object from the given url. + * + * @param url the url from which to read the MidiFileFormat + * @return the MidiFileFormat object + * @throws InvalidMidiDataException if we were unable to read the MidiFileFormat + * @throws IOException if an I/O error happened while reading + */ + public static MidiFileFormat getMidiFileFormat(URL url) + throws InvalidMidiDataException, IOException + { + Iterator readers = ServiceFactory.lookupProviders(MidiFileReader.class); + while (readers.hasNext()) + { + MidiFileReader sr = (MidiFileReader) readers.next(); + MidiFileFormat sb = sr.getMidiFileFormat(url); + if (sb != null) + return sb; + } + throw new InvalidMidiDataException("Cannot read from url " + url); + } + + /** + * Read a MidiFileFormat object from the given file. + * + * @param file the file from which to read the MidiFileFormat + * @return the MidiFileFormat object + * @throws InvalidMidiDataException if we were unable to read the MidiFileFormat + * @throws IOException if an I/O error happened while reading + */ + public static MidiFileFormat getMidiFileFormat(File file) + throws InvalidMidiDataException, IOException + { + Iterator readers = ServiceFactory.lookupProviders(MidiFileReader.class); + while (readers.hasNext()) + { + MidiFileReader sr = (MidiFileReader) readers.next(); + MidiFileFormat sb = sr.getMidiFileFormat(file); + if (sb != null) + return sb; + } + throw new InvalidMidiDataException("Can't read MidiFileFormat from file " + + file); + } + + /** + * Read a Sequence object from the given stream. + * + * @param stream the stream from which to read the Sequence + * @return the Sequence object + * @throws InvalidMidiDataException if we were unable to read the Sequence + * @throws IOException if an I/O error happened while reading + */ + public static Sequence getSequence(InputStream stream) + throws InvalidMidiDataException, IOException + { + Iterator readers = ServiceFactory.lookupProviders(MidiFileReader.class); + while (readers.hasNext()) + { + MidiFileReader sr = (MidiFileReader) readers.next(); + Sequence sq = sr.getSequence(stream); + if (sq != null) + return sq; + } + throw new InvalidMidiDataException("Can't read Sequence from stream"); + } + + /** + * Read a Sequence object from the given url. + * + * @param url the url from which to read the Sequence + * @return the Sequence object + * @throws InvalidMidiDataException if we were unable to read the Sequence + * @throws IOException if an I/O error happened while reading + */ + public static Sequence getSequence(URL url) + throws InvalidMidiDataException, IOException + { + Iterator readers = ServiceFactory.lookupProviders(MidiFileReader.class); + while (readers.hasNext()) + { + MidiFileReader sr = (MidiFileReader) readers.next(); + Sequence sq = sr.getSequence(url); + if (sq != null) + return sq; + } + throw new InvalidMidiDataException("Cannot read from url " + url); + } + + /** + * Read a Sequence object from the given file. + * + * @param file the file from which to read the Sequence + * @return the Sequence object + * @throws InvalidMidiDataException if we were unable to read the Sequence + * @throws IOException if an I/O error happened while reading + */ + public static Sequence getSequence(File file) + throws InvalidMidiDataException, IOException + { + Iterator readers = ServiceFactory.lookupProviders(MidiFileReader.class); + while (readers.hasNext()) + { + MidiFileReader sr = (MidiFileReader) readers.next(); + Sequence sq = sr.getSequence(file); + if (sq != null) + return sq; + } + throw new InvalidMidiDataException("Can't read Sequence from file " + + file); + } + + /** + * Return an array of supported MIDI file types on this system. + * + * @return the array of supported MIDI file types + */ + public static int[] getMidiFileTypes() + { + // We only support a max of 3 MIDI file types. + boolean supported[] = new boolean[3]; + // The number of supported formats. + int count = 0; + Iterator writers = ServiceFactory.lookupProviders(MidiFileWriter.class); + while (writers.hasNext()) + { + MidiFileWriter fw = (MidiFileWriter) writers.next(); + int types[] = fw.getMidiFileTypes(); + for (int i = types.length; i > 0;) + { + int type = types[--i]; + if (supported[type] == false) + { + count++; + supported[type] = true; + } + } + } + int result[] = new int[count]; + for (int i = supported.length; i > 0;) + { + if (supported[--i]) + result[--count] = i; + } + return result; + } + + /** + * Return true if the system supports writing files of type fileType. + * + * @param fileType the MIDI file type we want to write + * @return true if we can write fileType files, false otherwise + */ + public static boolean isFileTypeSupported(int fileType) + { + Iterator writers = ServiceFactory.lookupProviders(MidiFileWriter.class); + while (writers.hasNext()) + { + MidiFileWriter fw = (MidiFileWriter) writers.next(); + + if (fw.isFileTypeSupported(fileType)) + return true; + } + return false; + } + + /** + * Return an array of supported MIDI file types on this system + * for the given sequnce. + * + * @param sequence the sequnce to write + * @return the array of supported MIDI file types + */ + public static int[] getMidiFileTypes(Sequence sequence) + { + // We only support a max of 3 MIDI file types. + boolean supported[] = new boolean[3]; + // The number of supported formats. + int count = 0; + Iterator writers = ServiceFactory.lookupProviders(MidiFileWriter.class); + while (writers.hasNext()) + { + MidiFileWriter fw = (MidiFileWriter) writers.next(); + int types[] = fw.getMidiFileTypes(sequence); + for (int i = types.length; i > 0;) + { + int type = types[--i]; + if (supported[type] == false) + { + count++; + supported[type] = true; + } + } + } + int result[] = new int[count]; + for (int i = supported.length; i > 0;) + { + if (supported[--i]) + result[--count] = i; + } + return result; + } + + /** + * Return true if the system supports writing files of type fileType + * for the given sequence. + * + * @param fileType the MIDI file type we want to write + * @param sequence the Sequence we want to write + * @return true if we can write fileType files for sequence, false otherwise + */ + public static boolean isFileTypeSupported(int fileType, Sequence sequence) + { + Iterator writers = ServiceFactory.lookupProviders(MidiFileWriter.class); + while (writers.hasNext()) + { + MidiFileWriter fw = (MidiFileWriter) writers.next(); + + if (fw.isFileTypeSupported(fileType, sequence)) + return true; + } + return false; + } + + /** + * Write a sequence to an output stream using a specific MIDI file format. + * + * @param in the sequence to write + * @param fileType the MIDI file format to use + * @param out the output stream to write to + * @return the number of bytes written + * @throws IOException if an I/O exception happens + * @throws IllegalArgumentException if fileType is not supported for in + */ + public static int write(Sequence in, int fileType, OutputStream out) + throws IOException + { + Iterator writers = ServiceFactory.lookupProviders(MidiFileWriter.class); + while (writers.hasNext()) + { + MidiFileWriter fw = (MidiFileWriter) writers.next(); + + if (fw.isFileTypeSupported(fileType, in)) + return fw.write(in, fileType, out); + } + throw new IllegalArgumentException("File type " + + fileType + " is not supported"); + } + + /** + * Write a sequence to a file using a specific MIDI file format. + * + * @param in the sequence to write + * @param fileType the MIDI file format to use + * @param out the file to write to + * @return the number of bytes written + * @throws IOException if an I/O exception happens + * @throws IllegalArgumentException if fileType is not supported for in + */ + public static int write(Sequence in, int fileType, File out) + throws IOException + { + Iterator writers = ServiceFactory.lookupProviders(MidiFileWriter.class); + while (writers.hasNext()) + { + MidiFileWriter fw = (MidiFileWriter) writers.next(); + + if (fw.isFileTypeSupported(fileType, in)) + return fw.write(in, fileType, out); + } + throw new IllegalArgumentException("File type " + + fileType + " is not supported"); + } +} diff --git a/libjava/classpath/javax/sound/midi/MidiUnavailableException.java b/libjava/classpath/javax/sound/midi/MidiUnavailableException.java new file mode 100644 index 000000000..5403e42c3 --- /dev/null +++ b/libjava/classpath/javax/sound/midi/MidiUnavailableException.java @@ -0,0 +1,69 @@ +/* MidiUnavailableException.java -- MIDI resources are not available + 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.midi; + +/** + * This exception is thrown when MIDI resources are not available. + * + * @author Anthony Green (green@redhat.com) + * @since 1.3 + * + */ +public class MidiUnavailableException extends Exception +{ + private static final long serialVersionUID = 6093809578628944323L; + + /** + * Create a MidiUnavailableException. + */ + public MidiUnavailableException() + { + super(); + } + + /** + * Create an MidiUnavailableException object. + * + * @param s the exception message string + */ + public MidiUnavailableException(String s) + { + super(s); + } +} diff --git a/libjava/classpath/javax/sound/midi/Patch.java b/libjava/classpath/javax/sound/midi/Patch.java new file mode 100644 index 000000000..75e347f51 --- /dev/null +++ b/libjava/classpath/javax/sound/midi/Patch.java @@ -0,0 +1,86 @@ +/* Patch.java -- A MIDI patch. + 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.midi; + +/** + * A Patch describes where an Instrument is loaded on a Synthesizer. + * + * @author Anthony Green (green@redhat.com) + * @since 1.3 + * + */ +public class Patch +{ + // Private data describing the patch + private int bank = 0; + private int program = 0; + + /** + * Create a Patch object, specifying the bank and program in which this Patch + * is located. + * + * @param bank the bank in which this Patch is located + * @param program the program in which this Patch is located + */ + public Patch(int bank, int program) + { + this.bank = bank; + this.program = program; + } + + /** + * Get the bank in which this Patch is located. + * + * @return the bank in which this Patch is located + */ + public int getBank() + { + return bank; + } + + /** + * Get the program in which this Patch is located. + * + * @return the program in which this Patch is located + */ + public int getProgram() + { + return program; + } +} diff --git a/libjava/classpath/javax/sound/midi/Receiver.java b/libjava/classpath/javax/sound/midi/Receiver.java new file mode 100644 index 000000000..bc660d0d6 --- /dev/null +++ b/libjava/classpath/javax/sound/midi/Receiver.java @@ -0,0 +1,66 @@ +/* Receiver.java -- An interface for objects receiving MIDI data + 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.midi; + +/** + * This interface describes the methods required by objects receiving MIDI + * messages. + * + * @author Anthony Green (green@redhat.com) + * @since 1.3 + * + */ +public interface Receiver +{ + /** + * Send a MIDI message and timestamp. Some receivers don't support + * timestamps, in which case timeStamp should be -1. + * + * @param message the MIDI message to send + * @param timeStamp time timestamp for this message in microseconds (or -1) + * @throws IllegalStateException if the receiver is closed + */ + public void send(MidiMessage message, long timeStamp) + throws IllegalStateException; + + /** + * Close this receiver, possibly freeing system resources. + */ + public void close(); +} diff --git a/libjava/classpath/javax/sound/midi/Sequence.java b/libjava/classpath/javax/sound/midi/Sequence.java new file mode 100644 index 000000000..833150afe --- /dev/null +++ b/libjava/classpath/javax/sound/midi/Sequence.java @@ -0,0 +1,248 @@ +/* Sequence.java -- A sequence of MIDI events + 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.midi; + +import java.util.Iterator; +import java.util.Vector; + +/** + * Objects of this type represent sequences of MIDI messages that can be + * played back by a Sequencer. + * + * @author Anthony Green (green@redhat.com) + * @since 1.3 + * + */ +public class Sequence +{ + /** + * The timing division type for this sequence (PPQ or SMPTE*) + */ + protected float divisionType; + + /** + * The timing resolution in ticks/beat or ticks/frame, depending on the + * division type. + */ + protected int resolution; + + /** + * The MIDI tracks used by this sequence. + */ + protected Vector tracks; + + /** + * Tempo-based timing. Resolution is specified in ticks per beat. + */ + public static final float PPQ = 0.0f; + + /** + * 24 frames/second timing. Resolution is specific in ticks per frame. + */ + public static final float SMPTE_24 = 24.0f; + + /** + * 25 frames/second timing. Resolution is specific in ticks per frame. + */ + public static final float SMPTE_25 = 25.0f; + + /** + * 30 frames/second timing. Resolution is specific in ticks per frame. + */ + public static final float SMPTE_30 = 30.0f; + + /** + * 29.97 frames/second timing. Resolution is specific in ticks per frame. + */ + public static final float SMPTE_30DROP = 29.97f; + + // Private helper class + private void init(float divisionType, int resolution, int numTracks) + throws InvalidMidiDataException + { + if (divisionType != PPQ + && divisionType != SMPTE_24 + && divisionType != SMPTE_25 + && divisionType != SMPTE_30 + && divisionType != SMPTE_30DROP) + throw new InvalidMidiDataException("Invalid division type (" + + divisionType + ")"); + + this.divisionType = divisionType; + this.resolution = resolution; + + tracks = new Vector(numTracks); + while (numTracks > 0) + tracks.set(--numTracks, new Track()); + } + + /** + * Create a MIDI sequence object with no initial tracks. + * + * @param divisionType the division type (must be one of PPQ or SMPTE_*) + * @param resolution the timing resolution + * @throws InvalidMidiDataException if the division type is invalid + */ + public Sequence(float divisionType, int resolution) + throws InvalidMidiDataException + { + init(divisionType, resolution, 0); + } + + /** + * Create a MIDI seqence object. + * + * @param divisionType the division type (must be one of PPQ or SMPTE_*) + * @param resolution the timing resolution + * @param numTracks the number of initial tracks + * @throws InvalidMidiDataException if the division type is invalid + */ + public Sequence(float divisionType, int resolution, int numTracks) + throws InvalidMidiDataException + { + init(divisionType, resolution, 0); + } + + /** + * The division type of this sequence. + * + * @return division type of this sequence + */ + public float getDivisionType() + { + return divisionType; + } + + /** + * The timing resolution for this sequence, relative to the division type. + * + * @return the timing resolution for this sequence + */ + public int getResolution() + { + return resolution; + } + + /** + * Create a new empty MIDI track and add it to this sequence. + * + * @return the newly create MIDI track + */ + public Track createTrack() + { + Track track = new Track(); + tracks.add(track); + return track; + } + + /** + * Remove the specified MIDI track from this sequence. + * + * @param track the track to remove + * @return true if track was removed and false othewise + */ + public boolean deleteTrack(Track track) + { + return tracks.remove(track); + } + + /** + * Get an array of MIDI tracks used in this sequence. + * + * @return a possibly empty array of tracks + */ + public Track[] getTracks() + { + return tracks.toArray(new Track[tracks.size()]); + } + + /** + * The length of this sequence in microseconds. + * + * @return the length of this sequence in microseconds + */ + public long getMicrosecondLength() + { + long tickLength = getTickLength(); + + if (divisionType == PPQ) + { + // FIXME + // How can this possible be computed? PPQ is pulses per quarter-note, + // which is dependent on the tempo of the Sequencer. + throw new + UnsupportedOperationException("Can't compute PPQ based lengths yet"); + } + else + { + // This is a fixed tick per frame computation + return (long) ((tickLength * 1000000) / (divisionType * resolution)); + } + } + + /** + * The length of this sequence in MIDI ticks. + * + * @return the length of this sequence in MIDI ticks + */ + public long getTickLength() + { + long length = 0; + Iterator itr = tracks.iterator(); + while (itr.hasNext()) + { + Track track = itr.next(); + long trackTicks = track.ticks(); + if (trackTicks > length) + length = trackTicks; + } + return length; + } + + /** + * Get an array of patches used in this sequence. + * + * @return an array of patches used in this sequence + */ + public Patch[] getPatchList() + { + // FIXE: not quite sure how to do this yet. + throw new UnsupportedOperationException("Can't get patch list yet"); + } +} diff --git a/libjava/classpath/javax/sound/midi/Sequencer.java b/libjava/classpath/javax/sound/midi/Sequencer.java new file mode 100644 index 000000000..ca9cad779 --- /dev/null +++ b/libjava/classpath/javax/sound/midi/Sequencer.java @@ -0,0 +1,402 @@ +/* Sequencer.java -- A MIDI sequencer object + 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.midi; + +import java.io.IOException; +import java.io.InputStream; + +/** + * A Sequencer object plays MIDI sequences described as Sequence objects. + * This class provides methods for loading and unloading sequences, as well + * as basic transport controls. + * + * @author Anthony Green (green@redhat.com) + * @since 1.3 + * + */ +public interface Sequencer extends MidiDevice +{ + /** + * Set the Sequence object for this sequencer. + * + * @param seq the Sequence to process + * @throws InvalidMidiDataException if the sequence is invalid for any reason + */ + public void setSequence(Sequence seq) throws InvalidMidiDataException; + + /** + * Set the sequence for this sequencer. istream reads on a valid MIDI file. + * + * @param istream an input stream for a valid MIDI file + * @throws IOException if an I/O exception happens + * @throws InvalidMidiDataException if the MIDI file contains bad data + */ + public void setSequence(InputStream istream) + throws IOException, InvalidMidiDataException; + + /** + * Get the current sequence object for this sequencer. + * + * @return the current sequence object. May be null. + */ + public Sequence getSequence(); + + /** + * Start playback of the current sequence. + */ + public void start(); + + /** + * Stop playback of the current sequence. + */ + public void stop(); + + /** + * Returns true if the sequence is playing. + * + * @return true if the sequence is playing and false otherwise + */ + public boolean isRunning(); + + /** + * Start playback and record of MIDI events. + * Any tracks enabled for recording will have their events replaced. + * Any newly recorded events, and all events from non-recording tracks + * will be sent to the sequencer's transmitter. + */ + public void startRecording(); + + /** + * Stop recording, although continue playing. + */ + public void stopRecording(); + + /** + * Returns true if sequence is recording. + * + * @return true if the sequence is recording and false otherwise + */ + public boolean isRecording(); + + /** + * Enable recording for a specific track using data from a specific channel. + * + * @param track the track to enable for recording + * @param channel the channel from which to record + */ + public void recordEnable(Track track, int channel); + + /** + * Disable recording for a specific track. + * + * @param track the track to disable recording for + */ + public void recordDisable(Track track); + + /** + * Get the current tempo in beats per minute. + * + * @return the current tempo in beats per minute + */ + public float getTempoInBPM(); + + /** + * Sets the current tempo in beats per minute. + * + * @param bpm the new tempo in bears per minutes + */ + public void setTempoInBPM(float bpm); + + /** + * Get the current tempo in microseconds per quarter note. + * + * @return the current tempo in microseconds per quarter note. + */ + public float getTempoInMPQ(); + + /** + * Sets the current tempo in microseconds per quarter note. + * + * @param mpq the new tempo in microseconds per quarter note. + */ + public void setTempoInMPQ(float mpq); + + /** + * Set a scaling factor for the playback tempo, which is 1.0 by default. + * + * @param factor the new tempo scaling factor + */ + public void setTempoFactor(float factor); + + /** + * Get the current scaling factor for the playback tempo. + * + * @return the current tempo scaling factor + */ + public float getTempoFactor(); + + /** + * Get the length of the current sequence in MIDI ticks. + * + * @return the length of the current sequence in MIDI ticks + */ + public long getTickLength(); + + /** + * Get the current playback position of the sequencer in MIDI ticks. + * + * @return the current playback position of the sequencer in MIDI ticks + */ + public long getTickPosition(); + + /** + * Set the current playback position of the sequencer in MIDI ticks. + * + * @param tick the new playback position of the sequencer in MIDI ticks + */ + public void setTickPosition(long tick); + + /** + * Get the length of the current sequence in microseconds. + * + * @return the length of the current sequence in microseconds + */ + public long getMicrosecondLength(); + + /** + * Get the current playback position of the sequencer in microseconds. + * + * @return the current playback position of the sequencer in microseconds + */ + public long getMicrosecondPosition(); + + /** + * Set the current playback position of the sequencer in microseconds. + * + * @param microsecond the new playback position of the sequencer in microseconds + */ + public void setMicrosecondPosition(long microsecond); + + /** + * Set the source of timing information. sync must be found in the array + * returned by getMasterSyncModes(). + * FIXME: What happens if it isn't? + * + * @param sync the new source of timing information + */ + public void setMasterSyncMode(SyncMode sync); + + /** + * Get the source of timing information. + * + * @return the current source of timing information + */ + public SyncMode getMasterSyncMode(); + + /** + * Get an array of timing sources supported by this sequencer. + * + * @return an array of timing sources supported by this sequencer + */ + public SyncMode[] getMasterSyncModes(); + + /** + * Set the slave synchronization mode for this sequencer. sync must be + * found in the array returned by getSlaveSyncModes(). + * FIXME: What happens if it isn't? + * + * @param sync the new slave sync mode for this sequencer + */ + public void setSlaveSyncMode(SyncMode sync); + + /** + * Get the current slave synchronization mode. + * + * @return the current slave synchronization mode + */ + public SyncMode getSlaveSyncMode(); + + /** + * Get an array of slave sync modes supported by this sequencer. + * + * @return an array of slave sync modes supported by this sequencer + */ + public SyncMode[] getSlaveSyncModes(); + + /** + * Sets the mute state for a specific track. + * + * @param track the track to modify + * @param mute the new mute state + */ + public void setTrackMute(int track, boolean mute); + + /** + * Get the mute state of a specific track. + * + * @param track the track to query + * @return the mute state for track + */ + public boolean getTrackMute(int track); + + /** + * Sets the solo state for a specific track. + * + * @param track the track to modify + * @param solo the new solo state + */ + public void setTrackSolo(int track, boolean solo); + + /** + * Get the solo state for a specific track. + * + * @param track the track to query + * @return the solo state for track + */ + public boolean getTrackSolo(int track); + + /** + * Add a meta event listening object to this sequencer. It will receive + * notification whenever the sequencer processes a meta event. + * A listener may fail to get added if this sequencer doesn't support + * meta events. + * + * @param listener the listener to add + * @return true if listener was added, false othewise + */ + public boolean addMetaEventListener(MetaEventListener listener); + + /** + * Remove a meta event listener from this sequencer. + * + * @param listener the listener to remove + */ + public void removeMetaEventListener(MetaEventListener listener); + + /** + * Add a controller event listening object to this sequencer. It will + * receive notification whenever the sequencer processes a controller + * event for a specified controller number.. + * + * @param listener the listener to add + * @param controllers the conroller numbers to listen to + * @return the controller numbers being listened to + */ + public int[] addControllerEventListener(ControllerEventListener listener, + int controllers[]); + + /** + * Remove a controller listener from this sequencer for the specified + * controller numbers. + * + * @param listener the listener to remove + * @param controllers the controllers to unlisten + * @return the controller numbers being unlistened + */ + public int[] removeControllerEventListener(ControllerEventListener listener, + int controllers[]); + + /** + * A SyncMode object represents the mechanism by which a MIDI sequencer + * synchronizes time with a master or slave device. + * + * @author green@redhat.com + * + */ + public static class SyncMode + { + /** + * A master sync mode indicating the use of an internal sequencer clock. + */ + public static final SyncMode INTERNAL_CLOCK = new SyncMode("Internal Clock"); + + /** + * A master or slave sync mode indicating the use of MIDI clock messages. + */ + public static final SyncMode MIDI_SYNC = new SyncMode("MIDI Sync"); + + /** + * A master or slave sync mode indicating the use of MIDI Time Code + * messages. + */ + public static final SyncMode MIDI_TIME_CODE = new SyncMode("MIDI Time Code"); + + /** + * A slave sync mode indicating that no timing info will be transmitted. + */ + public static final SyncMode NO_SYNC = new SyncMode("No Timing"); + + // The name + private String name; + + /** + * Create a new SyncMode object + * @param name the SyncMode name + */ + protected SyncMode(String name) + { + this.name = name; + } + + /** + * SyncMode objects are only equal when identical. + */ + public final boolean equals(Object o) + { + return super.equals(o); + } + + /** + * SyncMode objects use the Object hashCode. + */ + public final int hashCode() + { + return super.hashCode(); + } + + /** + * Use the SyncMode name as the string representation. + * @see java.lang.Object#toString() + */ + public final String toString() + { + return name; + } + } +} diff --git a/libjava/classpath/javax/sound/midi/ShortMessage.java b/libjava/classpath/javax/sound/midi/ShortMessage.java new file mode 100644 index 000000000..08b873703 --- /dev/null +++ b/libjava/classpath/javax/sound/midi/ShortMessage.java @@ -0,0 +1,336 @@ +/* ShortMessage.java -- A MIDI message no longer than 3 bytes + 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.midi; + +/** + * A short MIDI message that is no longer than 3 bytes long. + * + * @author Anthony Green (green@redhat.com) + * @since 1.3 + * + */ +public class ShortMessage extends MidiMessage +{ + /** + * Status byte for Time Code message. + */ + public static final int MIDI_TIME_CODE = 0xF1; + + /** + * Status byte for Song Position Pointer message. + */ + public static final int SONG_POSITION_POINTER = 0xF2; + + /** + * Status byte for Song Select message. + */ + public static final int SONG_SELECT = 0xF3; + + /** + * Status byte for Tune Request message. + */ + public static final int TUNE_REQUEST = 0xF6; + + /** + * Status byte for End Of Exclusive message. + */ + public static final int END_OF_EXCLUSIVE = 0xF7; + + /** + * Status byte for Timing Clock message. + */ + public static final int TIMING_CLOCK = 0xF8; + + /** + * Status byte for Start message. + */ + public static final int START = 0xFA; + + /** + * Status byte for Continue message. + */ + public static final int CONTINUE = 0xFB; + + /** + * Status byte for Stop message. + */ + public static final int STOP = 0xFC; + + /** + * Status byte for Active Sensing message. + */ + public static final int ACTIVE_SENSING = 0xFE; + + /** + * Status byte for System Reset message. + */ + public static final int SYSTEM_RESET = 0xFF; + + /** + * Status nibble for Note Off message. + */ + public static final int NOTE_OFF = 0x80; + + /** + * Status nibble for Note On message. + */ + public static final int NOTE_ON = 0x90; + + /** + * Status nibble for Poly Pressure message. + */ + public static final int POLY_PRESSURE = 0xA0; + + /** + * Status nibble for Control Change message. + */ + public static final int CONTROL_CHANGE = 0xB0; + + /** + * Status nibble for Program Change message. + */ + public static final int PROGRAM_CHANGE = 0xC0; + + /** + * Statue nibble for Channel Pressure message. + */ + public static final int CHANNEL_PRESSURE = 0xD0; + + /** + * Status nibble for Pitch Bend message. + */ + public static final int PITCH_BEND = 0xE0; + + // Create and initialize a default, arbitrary message. + private static byte[] defaultMessage; + static + { + defaultMessage = new byte[1]; + defaultMessage[0] = (byte) STOP; + } + + /** + * Create a short MIDI message. + * + * The spec requires that this represent a valid MIDI message, but doesn't + * specify what it should be. We've chosen the STOP message for our + * implementation. + */ + public ShortMessage() + { + this(defaultMessage); + } + + /** + * Create a short MIDI message. + * + * The data argument should be a valid MIDI message. Unfortunately the spec + * does not allow us to throw an InvalidMidiDataException if data is invalid. + * + * @param data the message data + */ + protected ShortMessage(byte[] data) + { + super(data); + } + + /** + * Set the MIDI message. + * + * @param status the status byte for this message + * @param data1 the first data byte for this message + * @param data2 the second data byte for this message + * @throws InvalidMidiDataException if status is bad, or data is out of range + */ + public void setMessage(int status, int data1, int data2) + throws InvalidMidiDataException + { + length = getDataLength(status); + length++; + if (data == null || data.length < length) + data = new byte[length]; + data[0] = (byte) status; + if (length > 1) + { + if (data1 < 0 || data1 > 127) + throw new InvalidMidiDataException("data1 (" + data1 + + ") must be between 0 and 127."); + data[1] = (byte) data1; + if (length > 2) + { + if (data2 < 0 || data2 > 127) + throw new InvalidMidiDataException("data2 (" + data2 + + ") must be between 0 and 127."); + data[2] = (byte) data2; + } + } + } + + public void setMessage(int command, int channel, int data1, int data2) + throws InvalidMidiDataException + { + // TODO: This could probably stand some error checking. + // It currently assumes command and channel are valid values. + setMessage(command + channel, data1, data2); + } + + /** + * Set the MIDI message to one that requires no data bytes. + * + * @param status the status byte for this message + * @throws InvalidMidiDataException if status is bad, or requires data + */ + public void setMessage(int status) throws InvalidMidiDataException + { + int length = getDataLength(status); + if (length != 0) + throw new InvalidMidiDataException("Status byte 0x" + + Integer.toHexString(status) + + " requires " + + length + " bytes of data."); + setMessage(status, 0, 0); + } + + + /** + * Return the number of data bytes needed for a given MIDI status byte. + * + * @param status the status byte for a short MIDI message + * @return the number of data bytes needed for this status byte + * @throws InvalidMidiDataException if status is an invalid status byte + */ + protected final int getDataLength(int status) throws InvalidMidiDataException + { + int originalStatus = status; + + if ((status & 0xF0) != 0xF0) + status &= 0xF0; + + switch (status) + { + case NOTE_OFF: + case NOTE_ON: + case POLY_PRESSURE: + case CONTROL_CHANGE: + case PITCH_BEND: + case SONG_POSITION_POINTER: + return 2; + + case PROGRAM_CHANGE: + case CHANNEL_PRESSURE: + case SONG_SELECT: + case 0xF5: // FIXME: unofficial bus select. Not in spec?? + return 1; + + case TUNE_REQUEST: + case END_OF_EXCLUSIVE: + case TIMING_CLOCK: + case START: + case CONTINUE: + case STOP: + case ACTIVE_SENSING: + case SYSTEM_RESET: + return 0; + + default: + throw new InvalidMidiDataException("Invalid status: 0x" + + Integer.toHexString(originalStatus)); + } + } + + /** + * Get the channel information from this MIDI message, assuming it is a + * MIDI channel message. + * + * @return the MIDI channel for this message + */ + public int getChannel() + { + return data[0] & 0x0F; + } + + /** + * Get the command nibble from this MIDI message, assuming it is a MIDI + * channel message. + * + * @return the MIDI command for this message + */ + public int getCommand() + { + return data[0] & 0xF0; + } + + /** + * Get the first data byte from this message, assuming it exists, and + * zero otherwise. + * + * @return the first data byte or zero if none exists. + */ + public int getData1() + { + if (length > 1) + return data[1]; + else + return 0; + } + + /** + * Get the second data byte from this message, assuming it exists, and + * zero otherwise. + * + * @return the second date byte or zero if none exists. + */ + public int getData2() + { + if (length > 2) + return data[2]; + else + return 0; + } + + /* Create a deep-copy clone of this object. + * @see java.lang.Object#clone() + */ + public Object clone() + { + byte message[] = new byte[length]; + System.arraycopy(data, 0, message, 0, length); + return new ShortMessage(message); + } +} diff --git a/libjava/classpath/javax/sound/midi/Soundbank.java b/libjava/classpath/javax/sound/midi/Soundbank.java new file mode 100644 index 000000000..d959cf5cd --- /dev/null +++ b/libjava/classpath/javax/sound/midi/Soundbank.java @@ -0,0 +1,101 @@ +/* Soundbank.java -- Container of Instruments to be loaded into a Synthesizer + 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.midi; + +/** + * A Soundbank is a container for instruments which may be loaded into + * a Synthesizer. + * + * @author Anthony Green (green@redhat.com) + * @since 1.3 + * + */ +public interface Soundbank +{ + /** + * Get the sound bank name. + * + * @return the sound bank name + */ + String getName(); + + /** + * Get the sound bank version. + * + * @return the sound bank version + */ + String getVersion(); + + /** + * Get the sound bank vendor. + * + * @return the sound bank vendor + */ + String getVendor(); + + + /** + * Get the sound bank description. + * + * @return the sound bank description + */ + String getDescription(); + + /** + * Get an array of non-Instrument resources in this sound bank. + * + * @return an array of non-instrument resources in this sound bank + */ + SoundbankResource[] getResources(); + + /** + * Get an array of Instruments in this sound bank. + * + * @return an array of instruments in this sound bank + */ + Instrument[] getInstruments(); + + /** + * Get the Instrument for the given Patch. + * + * @param patch the Patch to search for + * @return the Instrument corresponding to patch + */ + Instrument getInstrument(Patch patch); +} diff --git a/libjava/classpath/javax/sound/midi/SoundbankResource.java b/libjava/classpath/javax/sound/midi/SoundbankResource.java new file mode 100644 index 000000000..0b4675b10 --- /dev/null +++ b/libjava/classpath/javax/sound/midi/SoundbankResource.java @@ -0,0 +1,104 @@ +/* SoundbankResource.java -- An audio resource from a sound bank + 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.midi; + +/** + * SoundbankResource objects represent audio data stored in a sound bank. + * + * @author Anthony Green (green@redhat.com) + * @since 1.3 + * + */ +public abstract class SoundbankResource +{ + private final Soundbank soundbank; + private final String name; + private final Class dataClass; + + /** + * Create a SoundbankResource object. + * + * @param soundbank the soundbank object containing this resource + * @param name the name of the resource + * @param dataClass the class used to represent the audio data + */ + protected SoundbankResource(Soundbank soundbank, String name, Class dataClass) + { + this.soundbank = soundbank; + this.name = name; + this.dataClass = dataClass; + } + + /** + * Get the sound bank containing this resource. + * + * @return the sound bank in which this resource resides + */ + public Soundbank getSoundbank() + { + return soundbank; + } + + /** + * Get the name of this resource. + * + * @return the name of this resource + */ + public String getName() + { + return name; + } + + /** + * Get the class used to represent the audio data for this resource. + * + * @return the class used to represent the audio data for this resource + */ + public Class getDataClass() + { + return dataClass; + } + + /** + * Get the audio data for this resource. + * + * @return the audio data object for this resource + */ + public abstract Object getData(); +} diff --git a/libjava/classpath/javax/sound/midi/Synthesizer.java b/libjava/classpath/javax/sound/midi/Synthesizer.java new file mode 100644 index 000000000..3a7ab3c7b --- /dev/null +++ b/libjava/classpath/javax/sound/midi/Synthesizer.java @@ -0,0 +1,173 @@ +/* Synthesizer.java -- A MIDI audio synthesizer interface + 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.midi; + +/** + * Interface for MIDI audio synthesizer devices. + * + * @author Anthony Green (green@redhat.com) + * @since 1.3 + * + */ +public interface Synthesizer extends MidiDevice +{ + /** + * Get the maximum number of notes that the synth can play at once. + * + * @return the maximum number of notes that the synth can play at once + */ + public int getMaxPolyphony(); + + /** + * The processing latency for this synth in microseconds. + * + * @return the processing latency for this synth in microseconds + */ + public long getLatency(); + + /** + * Get the set of MIDI channels controlled by this synth. + * + * @return an array of MIDI channels controlled by this synth + */ + public MidiChannel[] getChannels(); + + /** + * Get the current status for the voices produced by this synth. + * + * @return an array of VoiceStatus objects, getMaxPolyphony() in length + */ + public VoiceStatus[] getVoiceStatus(); + + /** + * Returns true is this synth is capable of loading soundbank. + * + * @param soundbank the Soundbank to examine + * @return true if soundbank can be loaded, false otherwise + */ + public boolean isSoundbankSupported(Soundbank soundbank); + + /** + * Load an instrument into this synth. The instrument must be part of a + * supported soundbank. + * + * @param instrument the Instrument to load + * @return true if the instrument was loaded and false otherwise + * @throws IllegalArgumentException if this synth doesn't support instrument + */ + public boolean loadInstrument(Instrument instrument); + + /** + * Unload an instrument from this synth. + * + * @param instrument the Instrument to unload + * @throws IllegalArgumentException if this synth doesn't support instrument + */ + public void unloadInstrument(Instrument instrument); + + /** + * Move an intrument from one place to another. The instrument at the + * target location is unloaded. + * + * @param from the instrument source + * @param to the instrument target + * @return if from was remapped + * @throws IllegalArgumentException + */ + public boolean remapInstrument(Instrument from, Instrument to); + + /** + * Get the default Soundbank for this synth. Return null if there is no + * default. + * + * @return the default Soundbank for this synth, possibly null. + */ + public Soundbank getDefaultSoundbank(); + + /** + * Get an array containing all instruments in this synthesizer. + * + * @return an array containing all instruments in this synthesizer + */ + public Instrument[] getAvailableInstruments(); + + /** + * Get an array containing all instruments loaded in this synthesizer. + * + * @return an array containing all instruments loaded in this synthesizer + */ + public Instrument[] getLoadedInstruments(); + + /** + * Load all soundbank instruments into this synthesizer. + * + * @param soundbank the Soundbank from which to load instruments + * @return true if all instruments were loaded, false othewise + * @throws IllegalArgumentException if the soundbank isn't supported by this + */ + public boolean loadAllInstruments(Soundbank soundbank); + + /** + * Unload all soundbank instruments from this synthesizer. + * + * @param soundbank the Soundbank containing the instruments to unload + * @throws IllegalArgumentException if the soundbank isn't supported by this + */ + public void unloadAllInstruments(Soundbank soundbank); + + /** + * Load a subset of soundbank instruments into this synthesizer. The + * subset is defined by an array of Patch objects. + * + * @param soundbank the Soundbank from which to load instruments + * @param patchList the array of patches identifying instruments to load + * @return true if instruments were loaded, false otherwise + * @throws IllegalArgumentException if the soundbank isn't supported by this + */ + public boolean loadInstruments(Soundbank soundbank, Patch[] patchList); + + /** + * Unload a subset of soundbank instruments from this synthesizer. + * + * @param soundbank the Soundbank containing the instruments to unload + * @param patchList the array of patches identifying instruments to unload + * @throws IllegalArgumentException if the soundbank isn't supported by this + */ + public void unloadInstruments(Soundbank soundbank, Patch[] patchList); +} diff --git a/libjava/classpath/javax/sound/midi/SysexMessage.java b/libjava/classpath/javax/sound/midi/SysexMessage.java new file mode 100644 index 000000000..93e3b5d09 --- /dev/null +++ b/libjava/classpath/javax/sound/midi/SysexMessage.java @@ -0,0 +1,138 @@ +/* SysexMessage.java -- System Exclusive MIDI message. + 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.midi; + +/** + * A system exclusive MIDI message. + * + * @author Anthony Green (green@redhat.com) + * @since 1.3 + * + */ +public class SysexMessage extends MidiMessage +{ + public static final int SYSTEM_EXCLUSIVE = 0xF0; + + public static final int SPECIAL_SYSTEM_EXCLUSIVE = 0xF7; + + /** + * Create a default valid system exclusive message. + * + * The official specs don't specify what message is to be + * created. Our implementation creates an empty + * system exclusive message. + */ + public SysexMessage() + { + super(new byte[2]); + data[0] = (byte) SYSTEM_EXCLUSIVE; + data[1] = (byte) ShortMessage.END_OF_EXCLUSIVE; + } + + /** + * Create a SysexMessage object. + * @param data a complete system exclusive message + */ + protected SysexMessage(byte[] data) + { + super(data); + } + + /** + * Set the sysex message. The first data byte (status) must be + * 0xF0 or 0xF7. + * + * @param data the message data + * @param length the length of the message data + * @throws InvalidMidiDataException if the status byte is not 0xF0 or 0xF7 + */ + public void setMessage(byte[] data, int length) + throws InvalidMidiDataException + { + if (data[0] != SYSTEM_EXCLUSIVE + && data[0] != SPECIAL_SYSTEM_EXCLUSIVE) + throw new InvalidMidiDataException("Sysex message starts with 0x" + + Integer.toHexString(data[0]) + + " instead of 0xF0 or 0xF7"); + super.setMessage(data, length); + } + + /** + * Set the sysex message. status must be either 0xF0 or 0xF7. + * + * @param status the sysex statys byte (0xF0 or 0xF7) + * @param data the message data + * @param length the length of the message data + * @throws InvalidMidiDataException if status is not 0xF0 or 0xF7 + */ + public void setMessage(int status, byte[] data, int length) + throws InvalidMidiDataException + { + if (status != SYSTEM_EXCLUSIVE + && status != SPECIAL_SYSTEM_EXCLUSIVE) + throw new InvalidMidiDataException("Sysex message starts with 0x" + + Integer.toHexString(status) + + " instead of 0xF0 or 0xF7"); + this.data = new byte[length+1]; + this.data[0] = (byte) status; + System.arraycopy(data, 0, this.data, 1, length); + this.length = length+1; + } + + /** + * Get the data for this message, not including the status byte. + * @return the message data, not including the status byte + */ + public byte[] getData() + { + byte[] result = new byte[length - 1]; + System.arraycopy(data, 1, result, 0, length - 1); + return result; + } + + /* Create a deep-copy clone of this object. + * @see java.lang.Object#clone() + */ + public Object clone() + { + byte message[] = new byte[length]; + System.arraycopy(data, 0, message, 0, length); + return new SysexMessage(message); + } +} diff --git a/libjava/classpath/javax/sound/midi/Track.java b/libjava/classpath/javax/sound/midi/Track.java new file mode 100644 index 000000000..550d2e1c4 --- /dev/null +++ b/libjava/classpath/javax/sound/midi/Track.java @@ -0,0 +1,164 @@ +/* Track.java -- A track of MIDI events + 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.midi; + +import java.util.HashSet; +import java.util.Vector; + +/** + * A Track contains a list of timecoded MIDI events for processing + * by a Sequencer. + * + * @author Anthony Green (green@redhat.com) + * @since 1.3 + * + */ +public class Track +{ + /** + * The list of MidiEvents for this track. + */ + Vector events = new Vector(); + + // A HashSet to speed processing + private HashSet eventSet = new HashSet(); + + // This is only instantiable within this package. + Track() + { + } + + /** + * Add a new event to this track. Specific events may only be added once. + * The event will be inserted into the appropriate spot in the event list + * based on its timecode. + * + * @param event the event to add + * @return true if the event was added, false otherwise + */ + public boolean add(MidiEvent event) + { + synchronized (events) + { + if (eventSet.contains(event)) + return false; + + eventSet.add(event); + + long targetTick = event.getTick(); + int i = events.size() - 1; + while (i >= 0 && (((MidiEvent)events.get(i)).getTick() > targetTick)) + i--; + events.add(i+1, event); + return true; + } + } + + /** + * Remove an event from this track. + * + * @param event the event to remove + * @return true if the event was removed, false otherwise + */ + public boolean remove(MidiEvent event) + { + synchronized (events) + { + if (! eventSet.remove(event)) + return false; + + int i = events.indexOf(event); + if (i >= 0) + { + events.remove(i); + return true; + } + + throw new InternalError("event in set but not list"); + } + } + + /** + * Get an event idetified by its order index + * + * @param index the location of the event to get + * @return the event at index + * @throws ArrayIndexOutOfBoundsException if index is out of bounds + */ + public MidiEvent get(int index) throws ArrayIndexOutOfBoundsException + { + synchronized (events) + { + try + { + return (MidiEvent) events.get(index); + } + catch (IndexOutOfBoundsException e) + { + throw (ArrayIndexOutOfBoundsException) + new ArrayIndexOutOfBoundsException().initCause(e); + } + } + } + + + /** + * Get the number events in this track. + * + * @return the number of events in this track + */ + public int size() + { + return events.size(); + } + + /** + * Get the length of the track in MIDI ticks. + * + * @return the length of the track in MIDI ticks + */ + public long ticks() + { + synchronized (events) + { + int size = events.size(); + return ((MidiEvent) events.get(size - 1)).getTick(); + } + } + } diff --git a/libjava/classpath/javax/sound/midi/Transmitter.java b/libjava/classpath/javax/sound/midi/Transmitter.java new file mode 100644 index 000000000..ab81cc819 --- /dev/null +++ b/libjava/classpath/javax/sound/midi/Transmitter.java @@ -0,0 +1,70 @@ +/* Transmitter.java -- A interface for objects sending MIDI events + 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.midi; + +/** + * This interface specifies the methods required by objects which send + * MIDI events to Receivers, including MIDI IN ports and Sequencers. + * + * @author Anthony Green (green@redhat.com) + * @since 1.3 + * + */ +public interface Transmitter +{ + /** + * Set the Receiver to which MIDI events will be sent. + * + * @param receiver the Receiver to which MIDI events will be sent + */ + public void setReceiver(Receiver receiver); + + /** + * Get the Receiver to which MIDI events will be sent (possibly null) + * + * @return the Receiver to which MIDI events will be sent (possibly null) + */ + public Receiver getReceiver(); + + /** + * Close this Transmitter, possibly releasing system resources. + * FIXME: Does this mean the Receiver is closed? I think it must. + */ + public void close(); +} diff --git a/libjava/classpath/javax/sound/midi/VoiceStatus.java b/libjava/classpath/javax/sound/midi/VoiceStatus.java new file mode 100644 index 000000000..2ba0c9ea1 --- /dev/null +++ b/libjava/classpath/javax/sound/midi/VoiceStatus.java @@ -0,0 +1,79 @@ +/* VoiceStatus.java -- the current status of a Synthesizer voice + 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.midi; + +/** + * Objects of this type define the status of a Synthesizer voice. + * + * @author Anthony Green (green@redhat.com) + * @since 1.3 + * + */ +public class VoiceStatus +{ + /** + * True if this voice is processing a MIDI note. + */ + public boolean active = false; + + /** + * The channel for this voice when active. + */ + public int channel = 0; + + /** + * The bank of the voice when active. + */ + public int bank = 0; + + /** + * The program for this voice when active. + */ + public int program = 0; + + /** + * The note for this voice when active. + */ + public int note = 0; + + /** + * The volume for this voice when active. + */ + public int volume = 0; +} diff --git a/libjava/classpath/javax/sound/midi/spi/MidiDeviceProvider.java b/libjava/classpath/javax/sound/midi/spi/MidiDeviceProvider.java new file mode 100644 index 000000000..7119ec4a2 --- /dev/null +++ b/libjava/classpath/javax/sound/midi/spi/MidiDeviceProvider.java @@ -0,0 +1,90 @@ +/* MidiDeviceProvider.java -- Abstract parent for a MIDI device provider. + 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.midi.spi; + +import javax.sound.midi.*; + +/** + * The abstract base class for all MidiDeviceProvider types. + * + * @author Anthony Green (green@redhat.com) + * @since 1.3 + * + */ +public abstract class MidiDeviceProvider +{ + /** + * Returns true if this provider supports a specific MIDI device. + * + * @param info the MIDI device descriptor + * @return true if this provider supports info + */ + public boolean isDeviceSupported(MidiDevice.Info info) + { + MidiDevice.Info infos[] = getDeviceInfo(); + + int i = infos.length; + + while (i > 0) + { + if (info.equals(infos[--i])) + return true; + } + + return false; + } + + /** + * Get the list descriptors for all MIDI devices supported by + * this provider. + * + * @return an array of descriptors for all supported MIDI devices. + */ + public abstract MidiDevice.Info[] getDeviceInfo(); + + /** + * Get the MidiDevice for the MIDI device described by info + * + * @param info the descriptor for the MIDI device we want + * @return the MidiDevice we're looking for + * @throws IllegalArgumentException is this provider doesn't support info + */ + public abstract MidiDevice getDevice(MidiDevice.Info info) + throws IllegalArgumentException; +} diff --git a/libjava/classpath/javax/sound/midi/spi/MidiFileReader.java b/libjava/classpath/javax/sound/midi/spi/MidiFileReader.java new file mode 100644 index 000000000..d370a8a44 --- /dev/null +++ b/libjava/classpath/javax/sound/midi/spi/MidiFileReader.java @@ -0,0 +1,125 @@ +/* MidiFilerReader.java -- MIDI file reading services + 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.midi.spi; + +import java.io.File; +import java.io.IOException; +import java.io.InputStream; +import java.net.URL; + +import javax.sound.midi.InvalidMidiDataException; +import javax.sound.midi.MidiFileFormat; +import javax.sound.midi.Sequence; + +/** + * The MidiFileReader abstract class defines the methods to be provided + * by a MIDI file reader. + * + * @author Anthony Green (green@redhat.com) + * @since 1.3 + * + */ +public abstract class MidiFileReader +{ + /** + * Read a MidiFileFormat from the given stream. + * + * @param stream the stream from which to read the MIDI data + * @return the MidiFileFormat object + * @throws InvalidMidiDataException if the stream refers to invalid data + * @throws IOException if an I/O exception occurs while reading + */ + public abstract MidiFileFormat getMidiFileFormat(InputStream stream) + throws InvalidMidiDataException, IOException; + + /** + * Read a MidiFileFormat from the given stream. + * + * @param url the url from which to read the MIDI data + * @return the MidiFileFormat object + * @throws InvalidMidiDataException if the url refers to invalid data + * @throws IOException if an I/O exception occurs while reading + */ + public abstract MidiFileFormat getMidiFileFormat(URL url) + throws InvalidMidiDataException, IOException; + + /** + * Read a MidiFileFormat from the given stream. + * + * @param file the file from which to read the MIDI data + * @return the MidiFileFormat object + * @throws InvalidMidiDataException if the file refers to invalid data + * @throws IOException if an I/O exception occurs while reading + */ + public abstract MidiFileFormat getMidiFileFormat(File file) + throws InvalidMidiDataException, IOException; + + /** + * Read a Sequence from the given stream. + * + * @param stream the stream from which to read the MIDI data + * @return the Sequence object + * @throws InvalidMidiDataException if the stream refers to invalid data + * @throws IOException if an I/O exception occurs while reading + */ + public abstract Sequence getSequence(InputStream stream) + throws InvalidMidiDataException, IOException; + + /** + * Read a Sequence from the given stream. + * + * @param url the url from which to read the MIDI data + * @return the Sequence object + * @throws InvalidMidiDataException if the url refers to invalid data + * @throws IOException if an I/O exception occurs while reading + */ + public abstract Sequence getSequence(URL url) + throws InvalidMidiDataException, IOException; + + /** + * Read a Sequence from the given stream. + * + * @param file the file from which to read the MIDI data + * @return the Sequence object + * @throws InvalidMidiDataException if the file refers to invalid data + * @throws IOException if an I/O exception occurs while reading + */ + public abstract Sequence getSequence(File file) + throws InvalidMidiDataException, IOException; +} diff --git a/libjava/classpath/javax/sound/midi/spi/MidiFileWriter.java b/libjava/classpath/javax/sound/midi/spi/MidiFileWriter.java new file mode 100644 index 000000000..08aee36f0 --- /dev/null +++ b/libjava/classpath/javax/sound/midi/spi/MidiFileWriter.java @@ -0,0 +1,143 @@ +/* MidiFileWriter.java -- MIDI file writing services + 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.midi.spi; + +import java.io.File; +import java.io.IOException; +import java.io.OutputStream; + +import javax.sound.midi.Sequence; + +/** + * MidiFileWriter provides MIDI file writing services. + * + * There are three types of Standard MIDI File (SMF) formats, + * represented by integers 0, 1, and 2. + * + * Type 0 files contain a single track and represents a single song + * performance. + * Type 1 may contain multiple tracks for a single song performance. + * Type 2 may contain multiple tracks, each representing a + * separate song performance. + * + * See http://en.wikipedia.org/wiki/MIDI#MIDI_file_formats for more + * information. + * + * @author Anthony Green (green@redhat.com) + * @since 1.3 + * + */ +public abstract class MidiFileWriter +{ + /** + * Return the MIDI file types supported by this writer. + * + * @return the MIDI file types, or an empty array + */ + public abstract int[] getMidiFileTypes(); + + /** + * Return the MIDI file types supported by this writer for the + * given sequence. + * + * @param sequence the sequence we'd like to write + * @return the MIDI file types, or an empty array + */ + public abstract int[] getMidiFileTypes(Sequence sequence); + + /** + * Returns true if this writer supports the given file type. + * + * @param fileType the file type we're asking about + * @return true if this writer supports fileType, false otherwise + */ + public boolean isFileTypeSupported(int fileType) + { + int types[] = getMidiFileTypes(); + for (int i = types.length; i > 0;) + { + if (types[--i] == fileType) + return true; + } + return false; + } + + /** + * Returns true if this writer supports the given file type for the + * given sequence. + * + * @param fileType the file type we're asking about + * @param sequence the sequence we'd like to write + * @return true if this writer supports fileType, false otherwise + */ + public boolean isFileTypeSupported(int fileType, Sequence sequence) + { + int types[] = getMidiFileTypes(sequence); + for (int i = types.length; i > 0;) + { + if (types[--i] == fileType) + return true; + } + return false; + } + + /** + * Write a sequence to a stream using the specified MIDI file type. + * + * @param in the sequence to write + * @param fileType the MIDI file type to use + * @param out the output stream to write to + * @return the number of byte written + * @throws IOException if an I/O exception happens + */ + public abstract int write(Sequence in, int fileType, OutputStream out) + throws IOException; + + /** + * Write a sequence to a file using the specified MIDI file type. + * + * @param in the sequence to write + * @param fileType the MIDI file type to use + * @param out the file to write to + * @return the number of byte written + * @throws IOException if an I/O exception happens + */ + public abstract int write(Sequence in, int fileType, File out) + throws IOException; +} diff --git a/libjava/classpath/javax/sound/midi/spi/SoundbankReader.java b/libjava/classpath/javax/sound/midi/spi/SoundbankReader.java new file mode 100644 index 000000000..948d54fd1 --- /dev/null +++ b/libjava/classpath/javax/sound/midi/spi/SoundbankReader.java @@ -0,0 +1,97 @@ +/* SoundbankReader.java -- Soundbank file reading services + 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.midi.spi; + +import java.io.File; +import java.io.IOException; +import java.io.InputStream; +import java.net.URL; + +import javax.sound.midi.InvalidMidiDataException; +import javax.sound.midi.Soundbank; + +/** + * The SoundbankReader abstract class defines the methods to be provided + * by a soundbank file reader. + * + * @author Anthony Green (green@redhat.com) + * @since 1.3 + * + */ +public abstract class SoundbankReader +{ + /** + * Get a Soundbank from the given URL. + * + * @param url from which to read the Soundbank + * + * @return the Soundbank object + * + * @throws InvalidMidiDataException if the data provided by url cannot be recognized + * @throws IOException if the data provided by url cannot be read + */ + public abstract Soundbank getSoundbank(URL url) + throws InvalidMidiDataException, IOException; + + /** + * Get a Soundbank from the given InputStream. + * + * @param stream from which to read the Soundbank + * + * @return the Soundbank object + * + * @throws InvalidMidiDataException if the data provided by InputStream cannot be recognized + * @throws IOException if the data provided by InputStream cannot be read + */ + public abstract Soundbank getSoundbank(InputStream stream) + throws InvalidMidiDataException, IOException; + + /** + * Get a Soundbank from the given File. + * + * @param file from which to read the Soundbank + * + * @return the Soundbank object + * + * @throws InvalidMidiDataException if the data provided by File cannot be recognized + * @throws IOException if the data provided by File cannot be read + */ + public abstract Soundbank getSoundbank(File file) + throws InvalidMidiDataException, IOException; +} diff --git a/libjava/classpath/javax/sound/sampled/AudioFileFormat.java b/libjava/classpath/javax/sound/sampled/AudioFileFormat.java new file mode 100644 index 000000000..2eeb78cf3 --- /dev/null +++ b/libjava/classpath/javax/sound/sampled/AudioFileFormat.java @@ -0,0 +1,242 @@ +/* Audio file format + 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 java.util.Collections; +import java.util.HashMap; +import java.util.Map; + +/** + * This describes an audio file, including information about its length, + * the format of the audio data, and other things. + * @since 1.3 + */ +public class AudioFileFormat +{ + /** + * An instance of this type describes a standard audio file format. + * @since 1.3 + */ + public static class Type + { + // This is kind of goofy since there are multiple extensions for + // some of these. + + /** The AIFC format. */ + public static final Type AIFC = new Type("AIFC", "aifc"); + + /** The AIFF format. */ + public static final Type AIFF = new Type("AIFF", "aiff"); + + /** The AU format. */ + public static final Type AU = new Type("AU", "au"); + + /** The SND format. */ + public static final Type SND = new Type("SND", "snd"); + + /** The WAVE format. */ + public static final Type WAVE = new Type ("WAVE", "wav"); + + private String name; + private String extension; + + /** + * Create a new Type given its name and file extension. + * The file extension does not include the ".". + * @param name the type's name + * @param extension the file extension + */ + public Type(String name, String extension) + { + this.name = name; + this.extension = extension; + } + + public final boolean equals(Object o) + { + if (! (o instanceof Type)) + return false; + Type other = (Type) o; + return name.equals(other.name) && extension.equals(other.extension); + } + + public final int hashCode() + { + return name.hashCode() + extension.hashCode(); + } + + /** + * Return the extension associated with this Type. + */ + public String getExtension() + { + return extension; + } + + /** + * Return the name of this Type. + */ + public final String toString() + { + return name; + } + } + + private int byteLength; + private AudioFormat format; + private Type type; + private int frameLength; + private Map properties; + + /** + * Create a new AudioFileFormat given the type, the format, and the + * frame length. The new object will have an unspecified byte length, + * and an empty properties map. + * @param type the type + * @param fmt the format + * @param frameLen the frame length + */ + public AudioFileFormat(Type type, AudioFormat fmt, int frameLen) + { + this.byteLength = AudioSystem.NOT_SPECIFIED; + this.format = fmt; + this.type = type; + this.frameLength = frameLen; + this.properties = Collections. emptyMap(); + } + + /** + * Create a new AudioFileFormat given the type, the format, the + * frame length, and some properties. The new object will have an + * unspecified byte length. A copy of the properties argument will + * be made, so changes to the map passed in will not affect the + * new AudioFileFormat. + * @param type the type + * @param fmt the format + * @param frameLen the frame length + * @param properties the properties + */ + public AudioFileFormat(Type type, AudioFormat fmt, int frameLen, + Map properties) + { + this.byteLength = AudioSystem.NOT_SPECIFIED; + this.format = fmt; + this.type = type; + this.frameLength = frameLen; + this.properties = Collections.unmodifiableMap(new HashMap(properties)); + } + + /** + * Create a new AudioFileFormat given the type, the byte length, the format, + * and the frame length. The new object will have an empty properties map. + * @param type the type + * @param byteLen the byte length + * @param fmt the format + * @param frameLen the frame length + */ + protected AudioFileFormat(Type type, int byteLen, AudioFormat fmt, + int frameLen) + { + this.byteLength = byteLen; + this.format = fmt; + this.type = type; + this.frameLength = frameLen; + this.properties = Collections. emptyMap(); + } + + /** + * Return the byte length of this file format. + */ + public int getByteLength() + { + return byteLength; + } + + /** + * Return the AudioFormat associated with this file format. + */ + public AudioFormat getFormat() + { + return format; + } + + /** + * Return the frame length of this file format. + */ + public int getFrameLength() + { + return frameLength; + } + + /** + * Return the value of a property defined in this format. + * @param key the property name + * @return the value of the property, or null if the property is not defined + */ + public Object getProperty(String key) + { + return properties.get(key); + } + + /** + * Return the Type associated with this file format. + */ + public Type getType() + { + return type; + } + + /** + * Return the properties associated with this format, as a Map. + * The returned Map is unmodifiable. + */ + public Map properties() + { + return properties; + } + + /** + * Return a description of this AudioFileFormat. + */ + public String toString() + { + return ("byteLength=" + byteLength + "; format=" + format + + "; type=" + type + "; frameLength=" + frameLength); + } +} diff --git a/libjava/classpath/javax/sound/sampled/AudioFormat.java b/libjava/classpath/javax/sound/sampled/AudioFormat.java new file mode 100644 index 000000000..b4fc601f2 --- /dev/null +++ b/libjava/classpath/javax/sound/sampled/AudioFormat.java @@ -0,0 +1,366 @@ +/* An audio format + 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.java.lang.CPStringBuilder; + +import java.util.Collections; +import java.util.HashMap; +import java.util.Map; + +/** + * This class describes an audio format, including its encoding, + * the number of channels, its frame rate, etc. + * @since 1.3 + */ +public class AudioFormat +{ + /** + * This describes a given audio format encoding. + * @since 1.3 + */ + public static class Encoding + { + /** The ALAW encoding. */ + public static final Encoding ALAW = new Encoding("alaw"); + + /** The signed PCM encoding. */ + public static final Encoding PCM_SIGNED = new Encoding("pcm_signed"); + + /** The unsigned PCM encoding. */ + public static final Encoding PCM_UNSIGNED = new Encoding("pcm_unsigned"); + + /** The ULAW encoding. */ + public static final Encoding ULAW = new Encoding("ulaw"); + + private String name; + + /** + * Create a new encoding descriptor, given its name. + * @param name the name + */ + public Encoding(String name) + { + this.name = name; + } + + public final boolean equals(Object o) + { + return super.equals(o); + } + + public final int hashCode() + { + return super.hashCode(); + } + + /** + * Return the name of this encoding. + */ + public final String toString() + { + return name; + } + } + + /** + * True if the audio data is stored big-endian. + */ + protected boolean bigEndian; + + /** + * The number of channels of data in this format. + */ + protected int channels; + + /** + * The encoding of this format. + */ + protected Encoding encoding; + + /** + * The frame rate of this format. This is the number of frames + * per second. + */ + protected float frameRate; + + /** + * The number of bytes per frame in this format. + */ + protected int frameSize; + + /** + * The number of samples per second. + */ + protected float sampleRate; + + /** + * The number of bits in each sample. + */ + protected int sampleSizeInBits; + + private Map properties; + + /** + * Create a new audio format, given various attributes of it. + * The properties map for this format will be empty. + * + * @param encoding the encoding for this format + * @param sampleRate the sample rate + * @param sampleSizeInBits the sample size, in bits + * @param channels the number of channels + * @param frameSize the frame size, in bytes + * @param frameRate the frame rate, in frames per second + * @param bigEndian true if the data is stored big-endian + */ + public AudioFormat(Encoding encoding, float sampleRate, int sampleSizeInBits, + int channels, int frameSize, float frameRate, + boolean bigEndian) + { + this.encoding = encoding; + this.sampleRate = sampleRate; + this.sampleSizeInBits = sampleSizeInBits; + this.channels = channels; + this.frameSize = frameSize; + this.frameRate = frameRate; + this.bigEndian = bigEndian; + this.properties = Collections. emptyMap(); + } + + /** + * Create a new audio format, given various attributes of it. + * The properties map is copied by this constructor, so changes + * to the argument Map will not affect the new object. + * + * @param encoding the encoding for this format + * @param sampleRate the sample rate + * @param sampleSizeInBits the sample size, in bits + * @param channels the number of channels + * @param frameSize the frame size, in bytes + * @param frameRate the frame rate, in frames per second + * @param bigEndian true if the data is stored big-endian + * @param properties a map describing properties of this format + */ + public AudioFormat(Encoding encoding, float sampleRate, int sampleSizeInBits, + int channels, int frameSize, float frameRate, + boolean bigEndian, Map properties) + { + this.encoding = encoding; + this.sampleRate = sampleRate; + this.sampleSizeInBits = sampleSizeInBits; + this.channels = channels; + this.frameSize = frameSize; + this.frameRate = frameRate; + this.bigEndian = bigEndian; + this.properties = Collections.unmodifiableMap(new HashMap(properties)); + } + + /** + * Create a new PCM-based audio format, given various attributes of it. + * The encoding will either be Encoding#PCM_SIGNED or Encoding#PCM_UNSIGNED. + * The frame size for this format will be derived from the sample size in + * bits and the number of channels, unless one of those is + * AudioSystem#NOT_SPECIFIED. The frame rate will be the same as the sample + * rate, and the properties map will be empty. + * + * @param sampleRate the sample rate + * @param sampleSizeInBits the sample size, in bits + * @param channels the number of channels + * @param signed true if this is a signed encoding + * @param bigEndian true if the data is stored big-endian + */ + public AudioFormat(float sampleRate, int sampleSizeInBits, + int channels, boolean signed, boolean bigEndian) + { + this.encoding = signed ? Encoding.PCM_SIGNED : Encoding.PCM_UNSIGNED; + this.sampleRate = sampleRate; + this.sampleSizeInBits = sampleSizeInBits; + this.channels = channels; + // It isn't clear whether channels can be NOT_SPECIFIED. + if (sampleSizeInBits == AudioSystem.NOT_SPECIFIED + || channels == AudioSystem.NOT_SPECIFIED) + this.frameSize = AudioSystem.NOT_SPECIFIED; + else + this.frameSize = (sampleSizeInBits + 7) / 8 * channels; + this.frameRate = sampleRate; + this.bigEndian = bigEndian; + this.properties = Collections. emptyMap(); + } + + /** + * Return the number of channels in this format. + */ + public int getChannels() + { + return channels; + } + + /** + * Return the encoding of this format. + */ + public Encoding getEncoding() + { + return encoding; + } + + /** + * Return the frame rate of this format. + */ + public float getFrameRate() + { + return frameRate; + } + + /** + * Return the frame size of this format. + */ + public int getFrameSize() + { + return frameSize; + } + + /** + * Given a key, return a property associated with this format; + * or null if this property is not set. + * @param key the name of the property + * @return the value of the property, or null if the property is not set + */ + public Object getProperty(String key) + { + return properties.get(key); + } + + /** + * Return the sample rate of this format. + */ + public float getSampleRate() + { + return sampleRate; + } + + /** + * Return the sample size of this format, in bits. + */ + public int getSampleSizeInBits() + { + return sampleSizeInBits; + } + + /** + * Return true if this format is big endian, false otherwise. + * This only matters for formats whose sample size is greater than + * one byte. + */ + public boolean isBigEndian() + { + return bigEndian; + } + + /** + * Return true if this audio format matches another. + * @param fmt the format to match against + * @return true if they match, false otherwise + */ + public boolean matches(AudioFormat fmt) + { + if (! encoding.equals(fmt.encoding) + || channels != fmt.channels + || sampleSizeInBits != fmt.sampleSizeInBits + || frameSize != fmt.frameSize) + return false; + if (sampleRate != AudioSystem.NOT_SPECIFIED + && fmt.sampleRate != AudioSystem.NOT_SPECIFIED + && sampleRate != fmt.sampleRate) + return false; + if (frameRate != AudioSystem.NOT_SPECIFIED + && fmt.frameRate != AudioSystem.NOT_SPECIFIED + && frameRate != fmt.frameRate) + return false; + if (sampleSizeInBits > 8) + return bigEndian == fmt.bigEndian; + return true; + } + + /** + * Return a read-only Map holding the properties associated with + * this format. + */ + public Map properties() + { + return properties; + } + + /** + * Return a description of this format. + */ + public String toString() + { + CPStringBuilder result = new CPStringBuilder(); + + // usually at least encoding should be somewhat specified + result.append(encoding); + + if (sampleRate != AudioSystem.NOT_SPECIFIED) + { + result.append(" "); + result.append(sampleRate); + result.append(" Hz"); + } + + if (sampleSizeInBits != AudioSystem.NOT_SPECIFIED) + { + result.append(" "); + result.append(sampleSizeInBits); + result.append(" bits"); + } + + if (channels != AudioSystem.NOT_SPECIFIED) + { + result.append(" "); + result.append(channels); + result.append(" channel"); + if (channels > 1) result.append("s"); + } + + if (sampleSizeInBits > 8) + result.append(bigEndian ? " big endian" : " little endian"); + + return result.toString(); + } +} diff --git a/libjava/classpath/javax/sound/sampled/AudioInputStream.java b/libjava/classpath/javax/sound/sampled/AudioInputStream.java new file mode 100644 index 000000000..526e7e192 --- /dev/null +++ b/libjava/classpath/javax/sound/sampled/AudioInputStream.java @@ -0,0 +1,258 @@ +/* + 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 java.io.IOException; +import java.io.InputStream; + +/** + * This is an InputStream which is specialized for reading audio files. + * In particular it only allows operations to act on a multiple of + * the audio stream's frame size. + * @since 1.3 + */ +public class AudioInputStream extends InputStream +{ + /** The format of the audio stream. */ + protected AudioFormat format; + + /** The length of the audio stream in frames. */ + protected long frameLength; + + /** The current frame position, starting from frame zero. */ + protected long framePos; + + /** The size of a frame in bytes. */ + protected int frameSize; + + // I wonder why this class doesn't inherit from FilterInputStream. + private InputStream input; + + // The saved frame position, used for mark/reset. + private long markedFramePos; + + /** + * Create a new AudioInputStream given an underlying InputStream, + * the audio format, and the length of the data in frames. The + * frame size is taken from the format. + * @param is the underlying input stream + * @param fmt the format of the data + * @param length the length of the data in frames + */ + public AudioInputStream(InputStream is, AudioFormat fmt, long length) + { + this.format = fmt; + this.frameLength = length; + this.framePos = 0; + this.frameSize = fmt.getFrameSize(); + this.input = is; + } + + /** + * Create a new AudioInputStream given a TargetDataLine. The audio + * format and the frame size are taken from the line. + * @param line the TargetDataLine + */ + public AudioInputStream(TargetDataLine line) + { + this(new TargetInputStream(line), line.getFormat(), + AudioSystem.NOT_SPECIFIED); + } + + /** + * Return the number of bytes available to be read from the + * underlying stream. This wrapper method ensures that the result + * is always a multiple of the frame size. + */ + public int available() throws IOException + { + int result = input.available(); + // Ensure result is a multiple of the frame size. + if (frameSize != AudioSystem.NOT_SPECIFIED) + result -= result % frameSize; + return result; + } + + /** + * Close the stream. + */ + public void close() throws IOException + { + input.close(); + } + + /** + * Get the format associated with this stream. + * @return the AudioFormat + */ + public AudioFormat getFormat() + { + return format; + } + + /** + * Get the length of this stream in frames. Note that this + * may be AudioSystem#NOT_SPECIFIED. + * @return the length of the stream in frames + */ + public long getFrameLength() + { + return frameLength; + } + + public void mark(int limit) + { + input.mark(limit); + markedFramePos = framePos; + } + + /** + * Return true if the underlying stream supports mark and reset, + * false otherwise. + */ + public boolean markSupported() + { + return input.markSupported(); + } + + /** + * Read a single byte from the underlying stream. If the frame + * size is set, and is not one byte, an IOException will be thrown. + */ + public int read() throws IOException + { + if (frameSize != 1) + throw new IOException("frame size must be 1 for read()"); + int result; + if (framePos == frameLength) + result = -1; + else + result = input.read(); + if (result != -1) + ++framePos; + return result; + } + + public int read(byte[] buf) throws IOException + { + return read(buf, 0, buf.length); + } + + public int read(byte[] buf, int offset, int length) throws IOException + { + int result; + if (framePos == frameLength) + result = -1; + else + { + int myFrameSize = (frameSize == AudioSystem.NOT_SPECIFIED + ? 1 : frameSize); + // Ensure length is a multiple of frame size. + length -= length % myFrameSize; + + result = 0; + while (result == 0 || result % myFrameSize != 0) + { + int val = input.read(buf, offset, length); + if (val < 0) + { + // This is a weird situation as we might have read a + // frame already. It isn't clear at all what to do if + // we only found a partial frame. For now we just + // return whatever we did find. + if (result == 0) + return -1; + result -= result % myFrameSize; + break; + } + result += val; + } + // assert result % myFrameSize == 0; + framePos += result / myFrameSize; + } + return result; + } + + public void reset() throws IOException + { + input.reset(); + framePos = markedFramePos; + } + + public long skip(long n) throws IOException + { + if (frameSize != AudioSystem.NOT_SPECIFIED) + n -= n % frameSize; + long actual = input.skip(n); + if (frameSize != AudioSystem.NOT_SPECIFIED) + framePos += actual / frameSize; + return actual; + } + + private static class TargetInputStream extends InputStream + { + private TargetDataLine line; + private byte[] buf; + + /** + * Create a new TargetInputStream. + * @param line the line to wrap + */ + public TargetInputStream(TargetDataLine line) + { + this.line = line; + // FIXME: do we have to call line.open()? + } + + public synchronized int read() throws IOException + { + if (buf == null) + buf = new byte[1]; + int count = read(buf, 0, 1); + if (count < 0) + return -1; + return buf[0]; + } + + public int read(byte[] buf, int offset, int length) throws IOException + { + return line.read(buf, offset, length); + } + } +} diff --git a/libjava/classpath/javax/sound/sampled/AudioPermission.java b/libjava/classpath/javax/sound/sampled/AudioPermission.java new file mode 100644 index 000000000..a5325c910 --- /dev/null +++ b/libjava/classpath/javax/sound/sampled/AudioPermission.java @@ -0,0 +1,70 @@ +/* + 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 java.security.BasicPermission; + +/** + * This represents the permission to use an audio device. + * The only predefined permission names are "play" and "record". + * @since 1.3 + */ +public class AudioPermission extends BasicPermission +{ + private static final long serialVersionUID = -5518053473477801126L; + + /** + * Construct an AudioPermission with the given name. + * @param name the name of the permission, like "play" or "record" + */ + public AudioPermission(String name) + { + super(name); + } + + /** + * Construct an AudioPermission with the given name. + * @param name the name of the permission, like "play" or "record" + * @param actions the actions; should be null + */ + public AudioPermission(String name, String actions) + { + super(name, actions); + } +} diff --git a/libjava/classpath/javax/sound/sampled/AudioSystem.java b/libjava/classpath/javax/sound/sampled/AudioSystem.java new file mode 100644 index 000000000..01133c91d --- /dev/null +++ b/libjava/classpath/javax/sound/sampled/AudioSystem.java @@ -0,0 +1,751 @@ +/* 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 result + = new HashSet(); + 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 result + = new HashSet(); + 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 result = new HashSet(); + 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 result = new HashSet(); + 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 result + = new HashSet(); + 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 result + = new HashSet(); + 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 result = new HashSet(); + 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 result = new HashSet(); + 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"); + } +} diff --git a/libjava/classpath/javax/sound/sampled/BooleanControl.java b/libjava/classpath/javax/sound/sampled/BooleanControl.java new file mode 100644 index 000000000..37e372e7b --- /dev/null +++ b/libjava/classpath/javax/sound/sampled/BooleanControl.java @@ -0,0 +1,144 @@ +/* + 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; + +/** + * A BooleanControl is a Control which has two states. + * @since 1.3 + */ +public abstract class BooleanControl extends Control +{ + /** + * A Type specialized to represent a boolean control. + * @since 1.3 + */ + public static class Type extends Control.Type + { + // FIXME: correct constructions? + + /** + * A control for applying reverb. + */ + public final static Type APPLY_REVERB = new Type("Apply reverb"); + + /** + * A control for muting. + */ + public final static Type MUTE = new Type("Mute"); + + /** + * Create a new Type given its name. + * @param name the name of the type + */ + protected Type(String name) + { + super(name); + } + } + + private boolean value; + private String trueLabel; + private String falseLabel; + + /** + * Create a new boolean control, with the indicated Type and initial + * value. The description strings will default to "true" and "false". + * @param type the type + * @param init the initial value + */ + protected BooleanControl(Type type, boolean init) + { + super(type); + this.value = init; + this.trueLabel = "true"; + this.falseLabel = "false"; + } + + /** + * Create a new boolean control, with the indicated Type, initial + * value, and labels. + * @param type the type + * @param init the initial value + * @param trueLabel the label for the true state + * @param falseLabel the label for the false state + */ + protected BooleanControl(Type type, boolean init, String trueLabel, + String falseLabel) + { + super(type); + this.value = init; + this.trueLabel = trueLabel; + this.falseLabel = falseLabel; + } + + /** + * Return the label corresponding to the indicated state. + * @param state the state + * @return the true label or the false label, as appropriate + */ + public String getStateLabel(boolean state) + { + return state ? trueLabel : falseLabel; + } + + /** + * Return the current value of thhe control. + */ + public boolean getValue() + { + return value; + } + + /** + * Set the value of the control as indicated. + * @param value the new value + */ + public void setValue(boolean value) + { + this.value = value; + } + + /** + * Return a string describing this control. + */ + public String toString() + { + return super.toString() + ": " + getStateLabel(value); + } +} diff --git a/libjava/classpath/javax/sound/sampled/Clip.java b/libjava/classpath/javax/sound/sampled/Clip.java new file mode 100644 index 000000000..28b49796f --- /dev/null +++ b/libjava/classpath/javax/sound/sampled/Clip.java @@ -0,0 +1,115 @@ +/* + 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 java.io.IOException; + +/** + * A Clip represents some pre-loaded audio data. + * @since 1.3 + */ +public interface Clip extends DataLine +{ + /** + * This can be passed to {@link #loop(int)} to indicate that looping + * should be done continuously. + */ + int LOOP_CONTINUOUSLY = -1; + + /** + * Return the frame length of this clip. + */ + int getFrameLength(); + + /** + * Return the length of the clip in microseconds. + */ + long getMicrosecondLength(); + + /** + * Start looping the clip. Looping will occur count times, or, if count + * is LOOP_CONTINUOUSLY, will be done continuously. A count of 0 indicates + * that any current looping should stop. + * @param count the number of times to loop + */ + void loop(int count); + + /** + * Open a clip, given an audio format and some data. + * @param fmt the format of the data + * @param data a byte array containing the audio data + * @param offset the offset of the first byte of data in the array + * @param len the length of the audio data in the array, in bytes + * @throws LineUnavailableException if the line cannot be opened + * @throws SecurityException if the line cannot be opened for security + * reasons + */ + void open(AudioFormat fmt, byte[] data, int offset, int len) + throws LineUnavailableException; + + /** + * Open a clip, given an audio input stream. + * @param ais the input stream + * @throws LineUnavailableException if the line cannot be opened + * @throws SecurityException if the line cannot be opened for security + * reasons + * @throws IOException if there is an I/O error while reading the stream + */ + void open(AudioInputStream ais) + throws LineUnavailableException, IOException; + + /** + * Set the position to the indicated frame. + * @param where new frame position + */ + void setFramePosition(int where); + + /** + * Set the loop begin and end points. These are used by loop(int). + * @param begin the starting point + * @param end the ending point + */ + void setLoopPoints(int begin, int end); + + /** + * Set the position to the indicated microsecond. + * @param ms the new position in microseconds + */ + void setMicrosecondPosition(long ms); +} diff --git a/libjava/classpath/javax/sound/sampled/CompoundControl.java b/libjava/classpath/javax/sound/sampled/CompoundControl.java new file mode 100644 index 000000000..2b8941cf3 --- /dev/null +++ b/libjava/classpath/javax/sound/sampled/CompoundControl.java @@ -0,0 +1,104 @@ +/* Control consisting of several other controls + 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.java.lang.CPStringBuilder; + +/** + * A compound control provides control over several other controls. + * @since 1.3 + */ +public abstract class CompoundControl extends Control +{ + /** + * This describes a single compound control. + * @since 1.3 + */ + public static class Type extends Control.Type + { + /** + * Create a new Type given its name. + * @param name the name of the type + */ + protected Type(String name) + { + super(name); + } + } + + private Control[] memberControls; + + /** + * Create a new compound control given its type and members. + * @param type the type of the compound control + * @param members the members of the compound control + */ + protected CompoundControl(Type type, Control[] members) + { + super(type); + // FIXME: clone? + this.memberControls = members; + } + + /** + * Return the members of this compound control. + */ + public Control[] getMemberControls() + { + // FIXME: clone? + return memberControls; + } + + /** + * Return a string description of this compound control. + */ + public String toString() + { + CPStringBuilder result = new CPStringBuilder(); + result.append(super.toString()); + result.append(": "); + for (int i = 0; i < memberControls.length; ++i) + { + if (i > 0) + result.append(", "); + result.append(memberControls[i].toString()); + } + return result.toString(); + } +} diff --git a/libjava/classpath/javax/sound/sampled/Control.java b/libjava/classpath/javax/sound/sampled/Control.java new file mode 100644 index 000000000..4759a3353 --- /dev/null +++ b/libjava/classpath/javax/sound/sampled/Control.java @@ -0,0 +1,111 @@ +/* Control over an attribute of a line + 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; + +/** + * A control provides the ability to affect some attribute of a line, + * for instance its volume. + * @since 1.3 + */ +public abstract class Control +{ + /** + * This describes a single control. + * @since 1.3 + */ + public static class Type + { + private String name; + + /** + * Create a new Type given its name. + * @param name the name of the type + */ + protected Type(String name) + { + this.name = name; + } + + public final boolean equals(Object o) + { + return super.equals(o); + } + + public final int hashCode() + { + return super.hashCode(); + } + + /** + * Return the name of this Type. + */ + public final String toString() + { + return name; + } + } + + private Type type; + + /** + * Create a new Control given its Type. + * @param type the type + */ + protected Control(Type type) + { + this.type = type; + } + + /** + * Return the Type of this Control. + */ + public Type getType() + { + return type; + } + + /** + * Return a String descrsibing this control. In particular the + * value will include the name of the associated Type. + */ + public String toString() + { + return type.toString(); + } +} diff --git a/libjava/classpath/javax/sound/sampled/DataLine.java b/libjava/classpath/javax/sound/sampled/DataLine.java new file mode 100644 index 000000000..5d88c6ace --- /dev/null +++ b/libjava/classpath/javax/sound/sampled/DataLine.java @@ -0,0 +1,271 @@ +/* + Copyright (C) 2005-2007 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.java.lang.CPStringBuilder; + +/** + * The DataLine interface adds data-related functionality to the Line + * interface. For example, it adds methods to start and stop the data + * on the line. + * @since 1.3 + */ +public interface DataLine extends Line +{ + /** + * This class extends Line.Info with information specific to DataLine. + * In particular it adds information about buffer sizes, and about supported + * audio formats. + * @since 1.3 + */ + class Info extends Line.Info + { + private int minBufferSize; + private int maxBufferSize; + private AudioFormat[] formats; + + /** + * Create a new Info given the line's class and a supported + * audio format. The buffer sizes default to AudioSystem.NOT_SPECIFIED. + * @param klass the class of the line + * @param fmt the supported format + */ + public Info(Class klass, AudioFormat fmt) + { + super(klass); + this.minBufferSize = AudioSystem.NOT_SPECIFIED; + this.maxBufferSize = AudioSystem.NOT_SPECIFIED; + this.formats = new AudioFormat[] { fmt }; + } + + /** + * Create a new Info given the line's class, the supported audio formats, + * the minimum buffer size, and the maximum buffer size. + * @param klass the class of the linee + * @param fmts the supported audio formats + * @param minSize the minimum buffer size + * @param maxSize the maximum buffer size + */ + public Info(Class klass, AudioFormat[] fmts, int minSize, int maxSize) + { + super(klass); + this.minBufferSize = minSize; + this.maxBufferSize = maxSize; + this.formats = fmts; + } + + /** + * Create a new Info given the line's class, a supported + * audio format, and a buffer size. Both the minimum and maximum + * sizes are set from this size. + * @param klass the class of the line + * @param fmt the supported format + * @param size the buffer size + */ + public Info(Class klass, AudioFormat fmt, int size) + { + super(klass); + this.minBufferSize = size; + this.maxBufferSize = size; + this.formats = new AudioFormat[] { fmt }; + } + + /** + * Return the supported audio formats. + */ + public AudioFormat[] getFormats() + { + // FIXME: clone? + return formats; + } + + /** + * Return the maximum buffer size. + */ + public int getMaxBufferSize() + { + return maxBufferSize; + } + + /** + * Return the minimum buffer size. + */ + public int getMinBufferSize() + { + return minBufferSize; + } + + /** + * Return true if the indicated audio format is supported by this + * Info, false otherwise. + * @param fmt the audio format + * @return true if the format is supported + */ + public boolean isFormatSupported(AudioFormat fmt) + { + for (int i = 0; i < formats.length; ++i) + { + if (fmt.matches(formats[i])) + return true; + } + return false; + } + + /** + * Return true if this Info matches another Info object. + */ + public boolean matches(Line.Info o) + { + if (! super.matches(o) || ! (o instanceof Info)) + return false; + + Info other = (Info) o; + if (minBufferSize < other.minBufferSize || + maxBufferSize > other.maxBufferSize) + return false; + + for (int i = 0; i < formats.length; ++i) + { + boolean ok = false; + for (int j = 0; j < other.formats.length; ++j) + { + if (formats[i].matches(other.formats[j])) + { + ok = true; + break; + } + } + if (! ok) + return false; + } + + return true; + } + + /** + * Return a description of this Info object. + */ + public String toString() + { + CPStringBuilder result = new CPStringBuilder(); + result.append("formats: ["); + for (int i = 0; i < formats.length; ++i) + { + if (i > 0) + result.append(", "); + result.append(formats[i].toString()); + } + + result.append("]; minBufferSize: "); + result.append(minBufferSize); + result.append("; maxBufferSize: "); + result.append(maxBufferSize); + return result.toString(); + } + + } // end class: Info + + /** + * Return the number of bytes currently available on this DataLine. + */ + int available(); + + /** + * This method blocks until whatever data is buffered in the + * DataLine's internal buffer has been drained. + */ + void drain(); + + /** + * This flushes the DataLine by discarding any buffered data. + */ + void flush(); + + /** + * Returns the size of the DataLine's internal buffer, in bytes. + */ + int getBufferSize(); + + /** + * Return the current format of the data associated with this DataLine. + */ + AudioFormat getFormat(); + + /** + * Return the current frame position. + */ + int getFramePosition(); + + /** + * Return the volume level for this DataLine. + */ + float getLevel(); + + /** + * Return the current frame position. + * @since 1.5 + */ + long getLongFramePosition(); + + /** + * Return the number of microseconds this DataLine has been playing. + */ + long getMicrosecondPosition(); + + /** + * Return true if this line is active, meaning that it is actively + * performing audio I/O. + */ + boolean isActive(); + + /** + * Return true if this line is running, meaning that it has been + * started. When the line is stopped, this method will return false. + */ + boolean isRunning(); + + /** + * Start processing data. This will emit a START event. + */ + void start(); + + /** + * Stop processing data. This will emit a STOP event. + */ + void stop(); +} diff --git a/libjava/classpath/javax/sound/sampled/EnumControl.java b/libjava/classpath/javax/sound/sampled/EnumControl.java new file mode 100644 index 000000000..7a032420d --- /dev/null +++ b/libjava/classpath/javax/sound/sampled/EnumControl.java @@ -0,0 +1,126 @@ +/* + 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; + +/** + * An EnumControl is a Control which can take one of a specified set of + * values. + * @since 1.3 + */ +public abstract class EnumControl extends Control +{ + /** + * This Type describes an EnumControl. + * @since 1.3 + */ + public static class Type extends Control.Type + { + /** This describes an enum control used for reverb. */ + public static final Type REVERB = new Type("Reverb"); + + /** + * Create a new Type given its name. + * @param name the name of the type + */ + protected Type(String name) + { + super(name); + } + } + + private Object[] values; + private Object value; + + /** + * Create a new enumerated control given its Type, the range of valid + * values, and its initial value. + * @param type the type + * @param values the valid values + * @param val the initial value + */ + protected EnumControl(Type type, Object[] values, Object val) + { + super(type); + // FIXME: error checking: values.length>0, val in values... ? + // FIXME: clone here? + this.values = values; + this.value = val; + } + + /** + * Return the current value of this control. + */ + public Object getValue() + { + return value; + } + + /** + * Return the valid values for this control. + */ + public Object[] getValues() + { + // FIXME: clone here? + return values; + } + + /** + * Set the value of this control. If the indicated value is not among + * the valid values, this method will throw an IllegalArgumentException. + * @param value the new value + * @throws IllegalArgumentException if the new value is invalid + */ + public void setValue(Object value) + { + for (int i = 0; i < values.length; ++i) + { + if (! values[i].equals(value)) + throw new IllegalArgumentException("value not supported"); + } + this.value = value; + } + + /** + * Return a string describing this control. + */ + public String toString() + { + return super.toString() + ": " + value; + } +} diff --git a/libjava/classpath/javax/sound/sampled/FloatControl.java b/libjava/classpath/javax/sound/sampled/FloatControl.java new file mode 100644 index 000000000..6ae917829 --- /dev/null +++ b/libjava/classpath/javax/sound/sampled/FloatControl.java @@ -0,0 +1,267 @@ +/* Floating point control + 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; + +/** @since 1.3 */ +public abstract class FloatControl extends Control +{ + /** + * An instance of this class describes a particular floating point control. + * @since 1.3 + */ + public static class Type extends Control.Type + { + /** Auxiliary return gain. */ + public static final Type AUX_RETURN = new Type("AUX return"); + + /** Auxiliary send gain. */ + public static final Type AUX_SEND = new Type("AUX send"); + + /** Balance. */ + public static final Type BALANCE = new Type("Balance"); + + /** Master gain control. */ + public static final Type MASTER_GAIN = new Type("Master gain"); + + /** Control for panning. */ + public static final Type PAN = new Type("Pan"); + + /** Post-reverb gain. */ + public static final Type REVERB_RETURN = new Type("Reverb return"); + + /** Pre-reverb gain. */ + public static final Type REVERB_SEND = new Type("Reverb send"); + + /** Control the sample rate. */ + public static final Type SAMPLE_RATE = new Type("Sample rate"); + + /** Volume control. */ + public static final Type VOLUME = new Type("Volume"); + + /** + * Create a new type given its name. + * @param name the name of the type + */ + protected Type(String name) + { + super(name); + } + } + + private float minimum; + private float maximum; + private float precision; + private int updatePeriod; + private float value; + private String units; + private String minLabel; + private String maxLabel; + private String midLabel; + + /** + * Create a new FloatControl given its type and various parameters. + * The minimum, maximum, and midpoint labels will all be the empty string. + * + * @param type the type + * @param min the minimum valuee + * @param max the maximum value + * @param prec the precision + * @param update the update period + * @param init the initial value + * @param units the description of the units + */ + protected FloatControl(Type type, float min, float max, float prec, + int update, float init, String units) + { + super(type); + this.minimum = min; + this.maximum = max; + this.precision = prec; + this.updatePeriod = update; + this.value = init; + this.units = units; + this.minLabel = ""; + this.maxLabel = ""; + this.midLabel = ""; + } + + /** + * Create a new FloatControl given its type and various parameters. + * + * @param type the type + * @param min the minimum valuee + * @param max the maximum value + * @param prec the precision + * @param update the update period + * @param init the initial value + * @param units the description of the units + * @param minLabel the label for the minimum value + * @param midLabel the label for the midpoint + * @param maxLabel the label for the maximum value + */ + protected FloatControl(Type type, float min, float max, float prec, + int update, float init, String units, + String minLabel, String midLabel, String maxLabel) + { + super(type); + this.minimum = min; + this.maximum = max; + this.precision = prec; + this.updatePeriod = update; + this.value = init; + this.units = units; + this.minLabel = minLabel; + this.maxLabel = maxLabel; + this.midLabel = midLabel; + } + + /** + * Return the maximum value of this control. + */ + public float getMaximum() + { + return maximum; + } + + /** + * Return the label for the minimum value of this control. + */ + public String getMaxLabel() + { + return maxLabel; + } + + /** + * Return the label for the midpoint of this control. + */ + public String getMidLabel() + { + return midLabel; + } + + /** + * Return the minimum value of this control. + */ + public float getMinimum() + { + return minimum; + } + + /** + * Return the label for the minimum value of this control. + */ + public String getMinLabel() + { + return minLabel; + } + + /** + * Return the precision of this control. + */ + public float getPrecision() + { + return precision; + } + + /** + * Return the name of the units for this control. + */ + public String getUnits() + { + return units; + } + + /** + * Return the update period of this control. + */ + public int getUpdatePeriod() + { + return updatePeriod; + } + + /** + * Return the current value of this control. + */ + public float getValue() + { + return value; + } + + /** + * Set the new value of this control. + * @param value the new value + * @throws IllegalArgumentException if the new value is greater than the + * maximum or less than the minimum. + */ + public void setValue(float value) + { + if (value < minimum || value > maximum) + throw new IllegalArgumentException("value out of range"); + this.value = value; + } + + /** + * This tells the control to start at the starting value + * and to shift its value incrementally to the final value + * over the given time interval, specified in microseconds. + * The default implementation does not do this, but instead + * simply sets the value to the final value immediately. + * + * @param from the starting value + * @param to the final value + * @param ms the number of microseconds + */ + public void shift(float from, float to, int ms) + { + if (from < minimum || from > maximum + || to < minimum || to > maximum + || ms < 0) + throw new IllegalArgumentException("argument out of range"); + // The default just sets the value to TO. + this.value = to; + } + + /** + * Return a string describing this control. + */ + public String toString() + { + return super.toString() + ": " + value; + } +} diff --git a/libjava/classpath/javax/sound/sampled/Line.java b/libjava/classpath/javax/sound/sampled/Line.java new file mode 100644 index 000000000..62d284bd8 --- /dev/null +++ b/libjava/classpath/javax/sound/sampled/Line.java @@ -0,0 +1,150 @@ +/* An input or output line + 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; + +/** + * A Line represents a single input or output audio line. + * @since 1.3 + */ +public interface Line +{ + /** + * An object of this type holds information about a Line. + * @since 1.3 + */ + class Info + { + private Class klass; + + /** + * Create a new Info object. The argument is the class of the line, + * for instance TargetDataLine.class. + * @param klass the class of the line + */ + public Info(Class klass) + { + this.klass = klass; + } + + /** + * Return the line's class. + */ + public Class getLineClass() + { + return klass; + } + + /** + * Return true if this Info object matches the given object. + * @param other the object to match + * @return true if they match, false otherwise + */ + public boolean matches(Info other) + { + return klass.equals(other.klass); + } + + /** + * Return a description of this Info object. + */ + public String toString() + { + return klass.toString(); + } + } + + /** + * Add a listener which will be notified whenever this Line changes state. + * @param listener the listener to notify + */ + void addLineListener(LineListener listener); + + /** + * Close this line. + */ + void close(); + + /** + * Return the control associated with this Line that matches the + * argument. + * @param what the type of the control to match + * @return the associated control + * @throws IllegalArgumentException if a control of this type is not + * available for this line + */ + Control getControl(Control.Type what); + + /** + * Return an array of controls associated with this Line. Note that + * this method will not return null -- if there are no controls, it + * will return a zero-length array. + */ + Control[] getControls(); + + /** + * Return the Info object associated with this Line. + */ + Info getLineInfo(); + + /** + * Return true if a Control matching the argument is available for this + * Line, false otherwise. + * @param what the type of the control to match + */ + boolean isControlSupported(Control.Type what); + + /** + * Return true if this line is open, false otherwise. + */ + boolean isOpen(); + + /** + * Open this line. + * @throws LineUnavailableException if the line is unavailable for some + * reason + */ + void open() throws LineUnavailableException; + + /** + * Remove the listener from this Line; after this call the listener will + * no longer be notified when this Line changes state. + * @param listener the listener to remove + */ + void removeLineListener(LineListener listener); +} diff --git a/libjava/classpath/javax/sound/sampled/LineEvent.java b/libjava/classpath/javax/sound/sampled/LineEvent.java new file mode 100644 index 000000000..43a184cae --- /dev/null +++ b/libjava/classpath/javax/sound/sampled/LineEvent.java @@ -0,0 +1,170 @@ +/* + 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 java.io.IOException; +import java.io.NotSerializableException; +import java.io.ObjectInputStream; +import java.io.ObjectOutputStream; +import java.util.EventObject; + +/** + * This class holds information about a state change of a Line. + * @specnote This class is not really serializable, and attempts to + * serialize it will throw {@link NotSerializableException}. + * @since 1.3 + */ +public class LineEvent extends EventObject +{ + // We define this even though this class can't be serialized, in + // order to placate the compiler. + private static final long serialVersionUID = -1274246333383880410L; + + /** + * This class represents the kinds of state changes that can occur + * to a Line. The standard states are availabe as static instances. + * @since 1.3 + */ + public static class Type + { + /** An event of this type is posted when a Line closes. */ + public static final Type CLOSE = new Type("close"); + + /** An event of this type is posted when a Line opens. */ + public static final Type OPEN = new Type("open"); + + /** An event of this type is posted when a Line starts. */ + public static final Type START = new Type("start"); + + /** An event of this type is posted when a Line stops. */ + public static final Type STOP = new Type("stop"); + + private String name; + + /** + * Create a new type with the indicated name. + * @param name the name + */ + protected Type(String name) + { + this.name = name; + } + + public final boolean equals(Object o) + { + return super.equals(o); + } + + public final int hashCode() + { + return super.hashCode(); + } + + /** + * Return the name of this Type. + */ + public String toString() + { + return name; + } + } + + private Type type; + private long framePosition; + private Line line; + + /** + * Create a new LineEvent with the indicated line, type, and frame position. + * @param line the line + * @param type the type of the event + * @param pos the frame position + */ + public LineEvent(Line line, Type type, long pos) + { + super(line); + this.line = line; + this.type = type; + this.framePosition = pos; + } + + /** + * Return the frame position associated with this event. + */ + public final long getFramePosition() + { + return framePosition; + } + + /** + * Return the Line associated with this event. + */ + public final Line getLine() + { + return line; + } + + /** + * Return the Type associated with this event. + */ + public final Type getType() + { + return type; + } + + /** + * Return a description of this event. + */ + public String toString() + { + return ("type=" + type + "; framePosition=" + framePosition + + "line=" + line); + } + + private void readObject(ObjectInputStream ois) + throws IOException + { + throw new NotSerializableException("LineEvent is not serializable"); + } + + private void writeObject(ObjectOutputStream oos) + throws IOException + { + throw new NotSerializableException("LineEvent is not serializable"); + } +} diff --git a/libjava/classpath/javax/sound/sampled/LineListener.java b/libjava/classpath/javax/sound/sampled/LineListener.java new file mode 100644 index 000000000..1b87c0279 --- /dev/null +++ b/libjava/classpath/javax/sound/sampled/LineListener.java @@ -0,0 +1,55 @@ +/* Listener for Lines + 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 java.util.EventListener; + +/** + * This interface is used by classes which wish to be notified + * when the state of a Line changes. + * @since 1.3 + */ +public interface LineListener extends EventListener +{ + /** + * This is called when the line's status changes. + * @param ev the event describing the change + */ + void update(LineEvent ev); +} diff --git a/libjava/classpath/javax/sound/sampled/LineUnavailableException.java b/libjava/classpath/javax/sound/sampled/LineUnavailableException.java new file mode 100644 index 000000000..a4655fffd --- /dev/null +++ b/libjava/classpath/javax/sound/sampled/LineUnavailableException.java @@ -0,0 +1,61 @@ +/* + 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; + +/** @since 1.3 */ +public class LineUnavailableException extends Exception +{ + private static final long serialVersionUID = -2046718279487432130L; + + /** + * Create a new LineUnavailableException. + */ + public LineUnavailableException() + { + } + + /** + * Create a new LineUnavailableException with the given message. + * @param msg the message + */ + public LineUnavailableException(String msg) + { + super(msg); + } +} diff --git a/libjava/classpath/javax/sound/sampled/Mixer.java b/libjava/classpath/javax/sound/sampled/Mixer.java new file mode 100644 index 000000000..dd400f94d --- /dev/null +++ b/libjava/classpath/javax/sound/sampled/Mixer.java @@ -0,0 +1,206 @@ +/* Mixers + 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; + +/** + * A Mixer is a Line which itself holds multiple lines. + * @since 1.3 + */ +public interface Mixer extends Line +{ + /** + * An Info object describes a mixer. + * @since 1.3 + */ + class Info + { + private String name; + private String description; + private String vendor; + private String version; + + /** + * Create a new mixer description. + * @param name the name of the mixer + * @param vendor the vendor + * @param desc a descriptive string + * @param vers the mixer's version + */ + protected Info(String name, String vendor, String desc, String vers) + { + this.name = name; + this.description = desc; + this.vendor = vendor; + this.version = vers; + } + + public final boolean equals(Object o) + { + return super.equals(o); + } + + public final int hashCode() + { + return super.hashCode(); + } + + /** + * Return the name of the mixer. + */ + public final String getName() + { + return name; + } + + /** + * Return the mixer's description. + */ + public final String getDescription() + { + return description; + } + + /** + * Return the mixer's vendor. + */ + public final String getVendor() + { + return vendor; + } + + /** + * Return the mixer's version. + */ + public final String getVersion() + { + return version; + } + + public final String toString() + { + return ("name=" + name + "; description=" + description + + "; vendor=" + vendor + "; version=" + version); + } + } + + /** + * Return a Line associated with this Mixer, given its description. + * @param info the description of the line to find + * @return the corresponding Line + * @throws LineUnavailableException if no Line matching the description + * exists in this Mixer + */ + Line getLine(Line.Info info) throws LineUnavailableException; + + /** + * Return the number of lines matching this description. + * @param info the description of the lines to find. + */ + int getMaxLines(Line.Info info); + + /** + * Return an Info object describing this Mixer. + */ + Info getMixerInfo(); + + /** + * Return an array of Info objects describing all the source lines + * available in this Mixer. + */ + Line.Info[] getSourceLineInfo(); + + /** + * Return an array of Info objects describing all the source lines + * available in this Mixer, which match the provided decsription. + * @param info the description of the source lines to find + */ + Line.Info[] getSourceLineInfo(Line.Info info); + + /** + * Return an array of all the source lines available in this Mixer. + */ + Line[] getSourceLines(); + + /** + * Return an array of Info objects describing all the target lines + * available in this Mixer. + */ + Line.Info[] getTargetLineInfo(); + + /** + * Return an array of Info objects describing all the target lines + * available in this Mixer, which match the provided decsription. + * @param info the description of the target lines to find + */ + Line.Info[] getTargetLineInfo(Line.Info info); + + /** + * Return an array of all the target lines available in this Mixer. + */ + Line[] getTargetLines(); + + /** + * Return true if a Line matching the given description is supported + * by this Mixer, false otherwise. + * @param info the description of the line to find + */ + boolean isLineSupported(Line.Info info); + + /** + * Return true if this Mixer supports synchronization of the given set + * of lines. + * @param lines the lines to check + * @param sync true if the synchronization must be accurate at all times + */ + boolean isSynchronizationSupported(Line[] lines, boolean sync); + + /** + * Start synchronization on the given set of lines. + * @param lines the lines to synchronize, or null for all the lines + * @param sync true if the synchronization must be accurate at all times + * @throws IllegalArgumentException if the lines cannot be synchronized + */ + void synchronize(Line[] lines, boolean sync); + + /** + * Stop synchronization for the given set of lines. + * @param lines the lines to unsynchronize, or null for all the lines + */ + void unsynchronize(Line[] lines); +} diff --git a/libjava/classpath/javax/sound/sampled/Port.java b/libjava/classpath/javax/sound/sampled/Port.java new file mode 100644 index 000000000..292e1f151 --- /dev/null +++ b/libjava/classpath/javax/sound/sampled/Port.java @@ -0,0 +1,135 @@ +/* + 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; + +/** + * A Port is a Line which represents an audio device, for instance + * a microphone. + * + * @since 1.3 + */ +public interface Port extends Line +{ + /** + * This describes a single port. + * @since 1.3 + */ + class Info extends Line.Info + { + // FIXME names? + + /** A CD player. */ + public static final Info COMPACT_DISC = new Info(Port.class, + "Compact Disc", + true); + + /** Headphones. */ + public static final Info HEADPHONE = new Info(Port.class, "Headphone", + false); + + /** Generic input line. */ + public static final Info LINE_IN = new Info(Port.class, "Line in", + true); + + /** Generic output line. */ + public static final Info LINE_OUT = new Info(Port.class, "Line out", + false); + + /** A microphone. */ + public static final Info MICROPHONE = new Info(Port.class, "Microphone", + true); + + /** A speaker. */ + public static final Info SPEAKER = new Info(Port.class, "Speaker", + false); + + private String name; + private boolean isSource; + + /** + * Create a new Info object, given the line's class, the name, + * and an argument indicating whether this is an input or an output. + * @param klass the class of the line + * @param name the name of the line + * @param isSource true if this is an input source + */ + public Info(Class klass, String name, boolean isSource) + { + super(klass); + this.name = name; + this.isSource = isSource; + } + + public final boolean equals(Object o) + { + return super.equals(o); + } + + public final int hashCode() + { + return super.hashCode(); + } + + /** + * Return the name of this object. + */ + public String getName() + { + return name; + } + + /** + * Return true if this describes an input line. + */ + public boolean isSource() + { + return isSource; + } + + public boolean matches(Line.Info other) + { + return super.matches(other) && equals(other); + } + + public final String toString() + { + return super.toString() + "; name=" + name + "; isSource=" + isSource; + } + } +} diff --git a/libjava/classpath/javax/sound/sampled/ReverbType.java b/libjava/classpath/javax/sound/sampled/ReverbType.java new file mode 100644 index 000000000..79a4b4945 --- /dev/null +++ b/libjava/classpath/javax/sound/sampled/ReverbType.java @@ -0,0 +1,144 @@ +/* Reverb attributes + 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; + +/** + * This represents a reverb effect which can be applied to an audio signal. + * @since 1.3 + */ +public class ReverbType +{ + private String name; + private int earlyReflectionDelay; + private float earlyReflectionIntensity; + private int lateReflectionDelay; + private float lateReflectionIntensity; + private int decayTime; + + /** + * Create a new ReverbType given its attributes. + * @param name the name of this type + * @param earlyDelay the early delay time in microseconds + * @param earlyInten the early intensity in decibels + * @param lateDelay the late delay time in microseconds + * @param lateInten the late intensity in decibels + * @param decay the decay time in microseconds + */ + protected ReverbType(String name, int earlyDelay, float earlyInten, + int lateDelay, float lateInten, int decay) + { + this.name = name; + this.earlyReflectionDelay = earlyDelay; + this.earlyReflectionIntensity = earlyInten; + this.lateReflectionDelay = lateDelay; + this.lateReflectionIntensity = lateInten; + this.decayTime = decay; + } + + public final boolean equals(Object o) + { + return super.equals(o); + } + + public final int hashCode() + { + return super.hashCode(); + } + + /** + * Return the decay time. + */ + public final int getDecayTime() + { + return decayTime; + } + + /** + * Return the early reflection delay. + */ + public final int getEarlyReflectionDelay() + { + return earlyReflectionDelay; + } + + /** + * Return the early reflection intensity. + */ + public final float getEarlyReflectionIntensity() + { + return earlyReflectionIntensity; + } + + /** + * Return the late reflection delay. + */ + public final int getLateReflectionDelay() + { + return lateReflectionDelay; + } + + /** + * Return the late reflection intensity. + */ + public final float getLateReflectionIntensity() + { + return lateReflectionIntensity; + } + + /** + * Return the name of this ReverbType. + * @since 1.5 + */ + public String getName() + { + return name; + } + + /** + * Return a description of this ReverbType. + */ + public final String toString() + { + return ("name=" + name + "; earlyReflectionDelay=" + earlyReflectionDelay + + "; earlyReflectionIntensity=" + earlyReflectionIntensity + + "; lateReflectionDelay=" + lateReflectionDelay + + "; lateReflectionIntensity=" + lateReflectionIntensity + + "; decayTime=" + decayTime); + } +} diff --git a/libjava/classpath/javax/sound/sampled/SourceDataLine.java b/libjava/classpath/javax/sound/sampled/SourceDataLine.java new file mode 100644 index 000000000..6e73d6d9c --- /dev/null +++ b/libjava/classpath/javax/sound/sampled/SourceDataLine.java @@ -0,0 +1,77 @@ +/* Output data line. + 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; + +/** + * This is a DataLine to which data may be written. + * @since 1.3 + */ +public interface SourceDataLine extends DataLine +{ + /** + * Open the line, given the desired audio format. + * @param fmt the format to use + * @throws LineUnavailableException if the line is not available for + * some reason + * @throws SecurityException if this is prevented by the security manager + */ + void open(AudioFormat fmt) + throws LineUnavailableException; + + /** + * Open the line, given the desired audio format and the buffer size. + * @param fmt the format to use + * @param size the buffer size + * @throws LineUnavailableException if the line is not available for + * some reason + * @throws SecurityException if this is prevented by the security manager + */ + void open(AudioFormat fmt, int size) + throws LineUnavailableException; + + /** + * Write audio data to this line. The data must be an integral number + * of frames, as determined by the audio format. + * @param buf a byte array of audio data + * @param offset index of the first byte in the array to use + * @param length the number of bytes to write + * @return the number of bytes written + */ + int write(byte[] buf, int offset, int length); +} diff --git a/libjava/classpath/javax/sound/sampled/TargetDataLine.java b/libjava/classpath/javax/sound/sampled/TargetDataLine.java new file mode 100644 index 000000000..61ad344ef --- /dev/null +++ b/libjava/classpath/javax/sound/sampled/TargetDataLine.java @@ -0,0 +1,79 @@ +/* Input data line. + 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; + +/** + * This is a DataLine from which data may be read. + * @since 1.3 + */ +public interface TargetDataLine extends DataLine +{ + /** + * Open the line using the indicated audio format. + * @param fmt the format to use + * @throws LineUnavailableException if the line is not available for + * some reason + * @throws SecurityException if this operation is prevented by the + * security manager + */ + void open(AudioFormat fmt) + throws LineUnavailableException; + + /** + * Open the line using the indicated audio format and buffer size. + * @param fmt the format to use + * @throws LineUnavailableException if the line is not available for + * some reason + * @throws SecurityException if this operation is prevented by the + * security manager + */ + void open(AudioFormat fmt, int size) + throws LineUnavailableException; + + /** + * Read data from the line into the given buffer. The requested data + * should be an integral number of framaes, as determined by the audio + * format. + * @param buf the buffer into which the data is put + * @param offset the initial offset at which to write + * @param length the maximum number of bytes to read + * @return the actual number of bytes read + */ + int read(byte[] buf, int offset, int length); +} diff --git a/libjava/classpath/javax/sound/sampled/UnsupportedAudioFileException.java b/libjava/classpath/javax/sound/sampled/UnsupportedAudioFileException.java new file mode 100644 index 000000000..1399b61a8 --- /dev/null +++ b/libjava/classpath/javax/sound/sampled/UnsupportedAudioFileException.java @@ -0,0 +1,65 @@ +/* + 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; + +/** + * An exception of this type is thrown when an operation is attempted + * on a file whose format is unrecognized. + * @since 1.3 + */ +public class UnsupportedAudioFileException extends Exception +{ + private static final long serialVersionUID = -139127412623160368L; + + /** + * Create a new UnsupportedAudioFileException. + */ + public UnsupportedAudioFileException() + { + } + + /** + * Create a new UnsupportedAudioFileException with the indicated message. + * @param msg the message + */ + public UnsupportedAudioFileException(String msg) + { + super(msg); + } +} diff --git a/libjava/classpath/javax/sound/sampled/spi/AudioFileReader.java b/libjava/classpath/javax/sound/sampled/spi/AudioFileReader.java new file mode 100644 index 000000000..098190f0f --- /dev/null +++ b/libjava/classpath/javax/sound/sampled/spi/AudioFileReader.java @@ -0,0 +1,146 @@ +/* Audio file reader API + 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.spi; + +import java.io.File; +import java.io.IOException; +import java.io.InputStream; +import java.net.URL; + +import javax.sound.sampled.AudioFileFormat; +import javax.sound.sampled.AudioInputStream; +import javax.sound.sampled.UnsupportedAudioFileException; + +/** + * This abstract class defines the interface to audio file readers. + * A concrete provider subclass will implement the methods declared + * here. These methods can be used to determine the format of + * files, and to retrieve an AudioInputStream for a file. + * @since 1.3 + */ +public abstract class AudioFileReader +{ + /** + * The default constructor. Note that this class is abstract and + * thus not directly instantiable. + */ + public AudioFileReader() + { + } + + /** + * Return the format of the given file as deduced by this provider. + * If the format of the file is not recognized, throws an exception. + * This will also throw an exception if there is an I/O error when + * reading the file. + * @param file the file to examine + * @return the audio file format + * @throws UnsupportedAudioFileException if the file's format is not + * recognized + * @throws IOException if there is an I/O error while reading the file + */ + public abstract AudioFileFormat getAudioFileFormat(File file) + throws UnsupportedAudioFileException, IOException; + + /** + * Return the format of the given input stream as deduced by this provider. + * If the format of the stream is not recognized, throws an exception. + * This will also throw an exception if there is an I/O error when + * reading the stream. Note that providers typically use mark and reset + * on the stream when examining the data, and as a result an IOException + * may be thrown if the stream does not support these. + * @param is the stream to examine + * @return the audio file format + * @throws UnsupportedAudioFileException if the stream's format is not + * recognized + * @throws IOException if there is an I/O error while reading the stream + */ + public abstract AudioFileFormat getAudioFileFormat(InputStream is) + throws UnsupportedAudioFileException, IOException; + + /** + * Return the format of the given URL as deduced by this provider. + * If the format of the URL is not recognized, throws an exception. + * This will also throw an exception if there is an I/O error when + * reading the URL. + * @param url the URL to examine + * @return the audio file format + * @throws UnsupportedAudioFileException if the URL's format is not + * recognized + * @throws IOException if there is an I/O error while reading the URL + */ + public abstract AudioFileFormat getAudioFileFormat(URL url) + throws UnsupportedAudioFileException, IOException; + + /** + * Return an AudioInputStream for the given file. The file is assumed + * to hold valid audio data. + * @param file the file to read + * @return an AudioInputStream for the file + * @throws UnsupportedAudioFileException if the file's type is not + * recognized + * @throws IOException if there is an error while reading the file + */ + public abstract AudioInputStream getAudioInputStream(File file) + throws UnsupportedAudioFileException, IOException; + + /** + * Return an AudioInputStream wrapping the given input stream. The stream + * is assumed to hold valid audio data. + * @param is the input stream to wrap + * @return an AudioInputStream for the stream + * @throws UnsupportedAudioFileException if the stream's type is not + * recognized + * @throws IOException if there is an error while reading the stream + */ + public abstract AudioInputStream getAudioInputStream(InputStream is) + throws UnsupportedAudioFileException, IOException; + + /** + * Return an AudioInputStream for the given URL. The URL is assumed + * to hold valid audio data. + * @param url the URL to read + * @return an AudioInputStream for the URL + * @throws UnsupportedAudioFileException if the URL's type is not + * recognized + * @throws IOException if there is an error while reading the URL + */ + public abstract AudioInputStream getAudioInputStream(URL url) + throws UnsupportedAudioFileException, IOException; +} diff --git a/libjava/classpath/javax/sound/sampled/spi/AudioFileWriter.java b/libjava/classpath/javax/sound/sampled/spi/AudioFileWriter.java new file mode 100644 index 000000000..82f9b31b8 --- /dev/null +++ b/libjava/classpath/javax/sound/sampled/spi/AudioFileWriter.java @@ -0,0 +1,131 @@ +/* Audio file writer API + 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.spi; + +import java.io.File; +import java.io.IOException; +import java.io.OutputStream; + +import javax.sound.sampled.AudioFileFormat; +import javax.sound.sampled.AudioInputStream; + +/** + * This abstract class provides an API for writing audio files. Concrete + * subclasses implement the methods declared here. + * @since 1.3 + */ +public abstract class AudioFileWriter +{ + /** + * Creat a new audio file writer. + */ + public AudioFileWriter() + { + } + + /** + * Return an array of all audio file format types supported by this + * provider. + */ + public abstract AudioFileFormat.Type[] getAudioFileTypes(); + + /** + * Return an array of all the audio file format types supported by this + * provider, which can be written given the input stream. + * @param ais the audio input stream + */ + public abstract AudioFileFormat.Type[] getAudioFileTypes(AudioInputStream ais); + + /** + * Return true if the indicated type is supported by this provider. + * @param type the audio file format type + */ + public boolean isFileTypeSupported(AudioFileFormat.Type type) + { + AudioFileFormat.Type[] types = getAudioFileTypes(); + for (int i = 0; i < types.length; ++i) + { + if (type.equals(types[i])) + return true; + } + return false; + } + + /** + * Return true if the indicated type is supported by this provider, + * and can be written from the given audio input stream. + * @param type the audio file format type + * @param ais the audio input stream to write + */ + public boolean isFileTypeSupported(AudioFileFormat.Type type, + AudioInputStream ais) + { + AudioFileFormat.Type[] types = getAudioFileTypes(ais); + for (int i = 0; i < types.length; ++i) + { + if (type.equals(types[i])) + return true; + } + return false; + } + + /** + * Write audio data to a file. + * @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 when writing + */ + public abstract int write(AudioInputStream ais, AudioFileFormat.Type type, + File out) + throws IOException; + + /** + * Write audio data to an output stream. + * @param ais the audio input stream to write + * @param type the desired audio file format type + * @param os the output stream + * @return the number of bytes written + * @throws IOException if an I/O error occurs when writing + */ + public abstract int write(AudioInputStream ais, AudioFileFormat.Type type, + OutputStream os) + throws IOException; +} diff --git a/libjava/classpath/javax/sound/sampled/spi/FormatConversionProvider.java b/libjava/classpath/javax/sound/sampled/spi/FormatConversionProvider.java new file mode 100644 index 000000000..b9d3e9d10 --- /dev/null +++ b/libjava/classpath/javax/sound/sampled/spi/FormatConversionProvider.java @@ -0,0 +1,179 @@ +/* Format conversion API + 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.spi; + +import javax.sound.sampled.AudioFormat; +import javax.sound.sampled.AudioInputStream; + +/** + * A format conversion provider supplies methods for converting between + * different audio formats. This abstract class defines the interface + * to this functionality; concrete subclasses will implement the methods + * declared here. + * @since 1.3 + */ +public abstract class FormatConversionProvider +{ + /** + * Create a new format conversion provider. + */ + public FormatConversionProvider() + { + } + + /** + * Return an audio input stream given the desired target encoding and + * another audio input stream. The data in the given stream will be + * converted to the desired encoding. + * @param encoding the encoding + * @param source the source audio input stream + * @return a new audio input stream + * @throws IllegalArgumentException if the conversion is not supported + */ + public abstract AudioInputStream getAudioInputStream(AudioFormat.Encoding encoding, + AudioInputStream source); + + /** + * Return an audio input stream given the desired target format and + * another audio input stream. The data in the given stream will be + * converted to the desired format. + * @param format the format + * @param source the source audio input stream + * @return a new audio input stream + * @throws IllegalArgumentException if the conversion is not supported + */ + public abstract AudioInputStream getAudioInputStream(AudioFormat format, + AudioInputStream source); + + /** + * Return an array of all the source encodings supported by this conversion + * provider. + */ + public abstract AudioFormat.Encoding[] getSourceEncodings(); + + /** + * Return an array of all the target encodings supported by this conversion + * provider. + */ + public abstract AudioFormat.Encoding[] getTargetEncodings(); + + /** + * Return an array of all the target encodings that are available for a given + * source format. + * @param fmt the source format + * @return an array of supported target encodings + */ + public abstract AudioFormat.Encoding[] getTargetEncodings(AudioFormat fmt); + + /** + * Return a array of all the target formats that match given target encoding, + * and to which this provider can convert the source format. + * @param targ the target encoding to match + * @param src the source format + * @return an array of supported target formats + */ + public abstract AudioFormat[] getTargetFormats(AudioFormat.Encoding targ, + AudioFormat src); + + /** + * Return true if this provider supports conversion from the given + * source format to the given target encoding. + * @param targ the target encoding + * @param src the source format + * @return true if the conversion is supported + */ + public boolean isConversionSupported(AudioFormat.Encoding targ, + AudioFormat src) + { + AudioFormat.Encoding[] encodings = getTargetEncodings(src); + for (int i = 0; i < encodings.length; ++i) + { + if (targ.equals(encodings[i])) + return true; + } + return false; + } + + /** + * Return true if this provider supports conversions from the given + * source format to the given target format. + * @param targ the source format + * @param src the target format + * @return true if the conversion is supported + */ + public boolean isConversionSupported(AudioFormat targ, AudioFormat src) + { + AudioFormat[] encodings = getTargetFormats(targ.getEncoding(), src); + return encodings.length > 0; + } + + /** + * Return true if an encoding matching the argument is supported as a + * source encoding by this provider. + * @param src the source encoding + * @return true if it is supported + */ + public boolean isSourceEncodingSupported(AudioFormat.Encoding src) + { + AudioFormat.Encoding[] srcs = getSourceEncodings(); + for (int i = 0; i < srcs.length; ++i) + { + if (src.equals(srcs[i])) + return true; + } + return false; + } + + /** + * Return true if an encoding matching the argument is supported as a + * target encoding by this provider. + * @param targ the target encoding + * @return true if it is supported + */ + public boolean isTargetEncodingSupported(AudioFormat.Encoding targ) + { + AudioFormat.Encoding[] encodings = getTargetEncodings(); + for (int i = 0; i < encodings.length; ++i) + { + if (targ.equals(encodings[i])) + return true; + } + return false; + } +} diff --git a/libjava/classpath/javax/sound/sampled/spi/MixerProvider.java b/libjava/classpath/javax/sound/sampled/spi/MixerProvider.java new file mode 100644 index 000000000..72b972497 --- /dev/null +++ b/libjava/classpath/javax/sound/sampled/spi/MixerProvider.java @@ -0,0 +1,86 @@ +/* Mixer API + 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.spi; + +import javax.sound.sampled.Mixer; + +/** + * This abstract class defines an interface to mixer providers. + * Concrete subclasses will implement the methods in this class. + * @since 1.3 + */ +public abstract class MixerProvider +{ + /** + * Create a new mixer provider. + */ + public MixerProvider() + { + } + + /** + * Return a mixer that matches the given info object. + * @param info description of the mixer to match + * @return the mixer + * @throws IllegalArgumentException if no mixer matches the description + */ + public abstract Mixer getMixer(Mixer.Info info); + + /** + * Return an array of info objects describing all the mixers provided by + * this provider. + */ + public abstract Mixer.Info[] getMixerInfo(); + + /** + * Return true if a mixer matching the provided description is supported. + * @param info description of the mixer to match + * @return true if it is supported by this provider + */ + public boolean isMixerSupported(Mixer.Info info) + { + Mixer.Info[] infos = getMixerInfo(); + for (int i = 0; i < infos.length; ++i) + { + if (info.equals(infos[i])) + return true; + } + return false; + } +} -- cgit v1.2.3