public Mixer getMixer(Mixer.Info info) {
if (TDebug.TraceMixerProvider) {
TDebug.out("TMixerProvider.getMixer(): begin");
}
MixerProviderStruct struct = getMixerProviderStruct();
Mixer mixerResult = null;
synchronized (struct) {
if (info == null) {
mixerResult = struct.m_defaultMixer;
} else {
Iterator mixers = struct.m_mixers.iterator();
while (mixers.hasNext()) {
Mixer mixer = (Mixer) mixers.next();
if (mixer.getMixerInfo().equals(info)) {
mixerResult = mixer;
break;
}
}
}
}
if (mixerResult == null) {
throw new IllegalArgumentException("no mixer available for " + info);
}
if (TDebug.TraceMixerProvider) {
TDebug.out("TMixerProvider.getMixer(): end");
}
return mixerResult;
}
public void storePreferences() {
ISettingsManager props = properties;
props.setOptionsSoundEnableSound(getEnableSoundCheckBox().isSelected());
props.setOptionsSoundEnableGunshot(getEnableGunshotCheckBox().isSelected());
props.setOptionsSoundEnableBulletHit(getEnableBulletHitCheckBox().isSelected());
props.setOptionsSoundEnableRobotDeath(getEnableRobotDeathCheckBox().isSelected());
props.setOptionsSoundEnableRobotCollision(getEnableRobotCollisionCheckBox().isSelected());
props.setOptionsSoundEnableWallCollision(getEnableWallCollisionCheckBox().isSelected());
props.setOptionsSoundEnableMixerVolume(getEnableMixerVolumeCheckBox().isSelected());
props.setOptionsSoundEnableMixerPan(getEnableMixerPanCheckBox().isSelected());
String mixerClassName = null;
Mixer.Info mixerInfo = (Mixer.Info) getMixerComboBox().getSelectedItem();
if (mixerInfo != null) {
Mixer mixer = AudioSystem.getMixer((Mixer.Info) getMixerComboBox().getSelectedItem());
if (mixer != null) {
mixerClassName = mixer.getClass().getSimpleName();
}
}
if (mixerClassName != null) {
props.setOptionsSoundMixer(mixerClassName);
}
properties.saveProperties();
}
public SonarSoundEngine(int maxChannels) throws LineUnavailableException {
silentSample = new SonarSample(new float[] {0}, 44100);
Mixer mixer = AudioSystem.getMixer(null);
sdl = (SourceDataLine) mixer.getLine(new Line.Info(SourceDataLine.class));
sdl.open(new AudioFormat(rate, 16, 2, true, false), bufferSize * 2 * 2 * 2 * 2 * 2);
soundBuffer.order(ByteOrder.LITTLE_ENDIAN);
sdl.start();
try {
/* FloatControl volumeControl = (FloatControl) sdl.getControl(FloatControl.Type.MASTER_GAIN);
volumeControl.setValue(volumeControl.getMaximum());*/
} catch (IllegalArgumentException e) {
// System.out.println("Failed to set the sound volume");
}
listenerMixer = new ListenerMixer(maxChannels);
leftBuf = new float[bufferSize];
rightBuf = new float[bufferSize];
Thread thread = new Thread(this);
thread.setDaemon(true);
thread.setPriority(10);
thread.start();
}
/** Does any clean up before closing. */
protected void cleanUp() {
// signal to unpause
setPaused(false);
// close the mixer (stops any running sounds)
Mixer mixer = AudioSystem.getMixer(null);
if (mixer.isOpen()) {
mixer.close();
}
}
// Constructor takes the name to save decoded track as in the form of a string ex:"track1.wav"
public FlacTrackPlayer(String trackName) {
player = null;
track = new File(trackName);
Mixer mixer = AudioSystem.getMixer(AudioSystem.getMixerInfo()[0]);
try {
mixer.open();
} catch (LineUnavailableException e) {
// TODO Auto-generated catch block
System.out.println("huh?");
e.printStackTrace();
}
}
@Ignore
@Test
public void testSilenceWriter()
throws UnsupportedAudioFileException, InterruptedException, LineUnavailableException,
FileNotFoundException {
float sampleRate = 44100;
int bufferSize = 1024;
int overlap = 0;
// available mixers
int index = 0;
int selectedMixerIndex = 4;
for (Mixer.Info mixer : AudioSystem.getMixerInfo()) {
System.out.println(index + ": " + Shared.toLocalString(mixer));
index++;
}
Mixer.Info selectedMixer = AudioSystem.getMixerInfo()[selectedMixerIndex];
System.out.println("Selected mixer: " + Shared.toLocalString(selectedMixer));
// open a line
final Mixer mixer = AudioSystem.getMixer(selectedMixer);
final AudioFormat format = new AudioFormat(sampleRate, 16, 1, true, true);
final DataLine.Info dataLineInfo = new DataLine.Info(TargetDataLine.class, format);
TargetDataLine line;
line = (TargetDataLine) mixer.getLine(dataLineInfo);
final int numberOfSamples = bufferSize;
line.open(format, numberOfSamples);
line.start();
final AudioInputStream stream = new AudioInputStream(line);
// create a new dispatcher
AudioDispatcher dispatcher = new AudioDispatcher(stream, bufferSize, overlap);
WaveformWriter writer = new WaveformWriter(format, "01.file.wav");
// add a processor, handle percussion event.
dispatcher.addAudioProcessor(new SilenceDetector());
dispatcher.addAudioProcessor(writer);
// run the dispatcher (on the same thread, use start() to run it on
// another thread).
new Thread(dispatcher).start();
Thread.sleep(3000);
dispatcher.removeAudioProcessor(writer);
writer = new WaveformWriter(format, "02.file.wav");
dispatcher.addAudioProcessor(writer);
Thread.sleep(3000);
dispatcher.stop();
}
/**
* Inits a DateLine.<br>
* We check if the line supports Gain and Pan controls.
*
* <p>From the AudioInputStream, i.e. from the sound file, we fetch information about the format
* of the audio data. These information include the sampling frequency, the number of channels and
* the size of the samples. There information are needed to ask JavaSound for a suitable output
* line for this audio file. Furthermore, we have to give JavaSound a hint about how big the
* internal buffer for the line should be. Here, we say AudioSystem.NOT_SPECIFIED, signaling that
* we don't care about the exact size. JavaSound will use some default value for the buffer size.
*/
protected void createLine() throws LineUnavailableException {
log.info("Create Line");
if (m_line == null) {
AudioFormat sourceFormat = m_audioInputStream.getFormat();
log.info("Create Line : Source format : " + sourceFormat.toString());
int nSampleSizeInBits = sourceFormat.getSampleSizeInBits();
if (nSampleSizeInBits <= 0) {
nSampleSizeInBits = 16;
}
if ((sourceFormat.getEncoding() == AudioFormat.Encoding.ULAW)
|| (sourceFormat.getEncoding() == AudioFormat.Encoding.ALAW)) {
nSampleSizeInBits = 16;
}
if (nSampleSizeInBits != 8) {
nSampleSizeInBits = 16;
}
AudioFormat targetFormat =
new AudioFormat(
AudioFormat.Encoding.PCM_SIGNED,
sourceFormat.getSampleRate(),
nSampleSizeInBits,
sourceFormat.getChannels(),
sourceFormat.getChannels() * (nSampleSizeInBits / 8),
sourceFormat.getSampleRate(),
false);
log.info("Create Line : Target format: " + targetFormat);
// Keep a reference on encoded stream to progress notification.
m_encodedaudioInputStream = m_audioInputStream;
try {
// Get total length in bytes of the encoded stream.
encodedLength = m_encodedaudioInputStream.available();
} catch (IOException e) {
log.log(Level.SEVERE, "Cannot get m_encodedaudioInputStream.available()", e);
}
// Create decoded stream.
m_audioInputStream = AudioSystem.getAudioInputStream(targetFormat, m_audioInputStream);
AudioFormat audioFormat = m_audioInputStream.getFormat();
DataLine.Info info = new DataLine.Info(SourceDataLine.class, audioFormat, -1);
Mixer mixer = getMixer(m_mixerName);
if (mixer != null) {
log.info("Mixer : " + mixer.getMixerInfo().toString());
m_line = (SourceDataLine) mixer.getLine(info);
} else {
m_line = (SourceDataLine) AudioSystem.getLine(info);
m_mixerName = null;
}
log.info("Line : " + m_line.toString());
log.info("Line Info : " + m_line.getLineInfo().toString());
log.info("Line AudioFormat: " + m_line.getFormat().toString());
}
}
public List getMixers() {
ArrayList mixers = new ArrayList();
Mixer.Info[] mInfos = AudioSystem.getMixerInfo();
if (mInfos != null) {
for (int i = 0; i < mInfos.length; i++) {
Line.Info lineInfo = new Line.Info(SourceDataLine.class);
Mixer mixer = AudioSystem.getMixer(mInfos[i]);
if (mixer.isLineSupported(lineInfo)) {
mixers.add(mInfos[i].getName());
}
}
}
return mixers;
}
TargetDataLine getTargetDataLine(AudioFormat format, int bufferSize) {
TargetDataLine line = null;
DataLine.Info info = new DataLine.Info(TargetDataLine.class, format);
if (AudioSystem.isLineSupported(info)) {
try {
if (inputMixer == null) {
line = (TargetDataLine) AudioSystem.getLine(info);
} else {
line = (TargetDataLine) inputMixer.getLine(info);
}
line.open(format, bufferSize * format.getFrameSize());
debug(
"TargetDataLine buffer size is "
+ line.getBufferSize()
+ "\n"
+ "TargetDataLine format is "
+ line.getFormat().toString()
+ "\n"
+ "TargetDataLine info is "
+ line.getLineInfo().toString());
} catch (Exception e) {
error("Error acquiring TargetDataLine: " + e.getMessage());
}
} else {
error("Unable to return a TargetDataLine: unsupported format - " + format.toString());
}
return line;
}
SourceDataLine getSourceDataLine(AudioFormat format, int bufferSize) {
SourceDataLine line = null;
DataLine.Info info = new DataLine.Info(SourceDataLine.class, format);
if (AudioSystem.isLineSupported(info)) {
try {
if (outputMixer == null) {
line = (SourceDataLine) AudioSystem.getLine(info);
} else {
line = (SourceDataLine) outputMixer.getLine(info);
}
// remember that time you spent, like, an entire afternoon fussing
// with this buffer size to try to get the latency decent on Linux?
// Yah, don't fuss with this anymore, ok?
line.open(format, bufferSize * format.getFrameSize() * 4);
if (line.isOpen()) {
debug(
"SourceDataLine is "
+ line.getClass().toString()
+ "\n"
+ "Buffer size is "
+ line.getBufferSize()
+ " bytes.\n"
+ "Format is "
+ line.getFormat().toString()
+ ".");
return line;
}
} catch (LineUnavailableException e) {
error("Couldn't open the line: " + e.getMessage());
}
}
error("Unable to return a SourceDataLine: unsupported format - " + format.toString());
return line;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((mMixer == null) ? 0 : mMixer.hashCode());
result = prime * result + ((mMixerChannel == null) ? 0 : mMixerChannel.hashCode());
return result;
}
public TargetDataLine getInputLine(AudioFormat format) throws LineUnavailableException {
TargetDataLine in;
DataLine.Info info = new DataLine.Info(TargetDataLine.class, format);
in = (TargetDataLine) mixer.getLine(info);
in.open(format, in.getBufferSize());
return in;
}
private Line.Info[] getPortInfo(Mixer mixer) {
Line.Info[] infos;
List<Line.Info> portInfoList = new ArrayList<>();
infos = mixer.getSourceLineInfo();
for (Line.Info info : infos) {
if (info instanceof Port.Info || info instanceof DataLine.Info) {
portInfoList.add(info);
}
}
infos = mixer.getTargetLineInfo();
for (Line.Info info1 : infos) {
if (info1 instanceof Port.Info || info1 instanceof DataLine.Info) {
portInfoList.add(info1);
}
}
return portInfoList.toArray(EMPTY_PORT_INFO_ARRAY);
}
public SourceDataLine getOutputLine(AudioFormat format) throws LineUnavailableException {
SourceDataLine out;
DataLine.Info info = new DataLine.Info(SourceDataLine.class, format);
out = (SourceDataLine) mixer.getLine(info);
out.open(format, out.getBufferSize());
return out;
}
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append(mMixer.getMixerInfo().getName());
sb.append(" - ");
sb.append(mMixerChannel.name());
return sb.toString();
}
public Mixer.Info[] getMixerInfo() {
if (TDebug.TraceMixerProvider) {
TDebug.out("TMixerProvider.getMixerInfo(): begin");
}
Set<Mixer.Info> mixerInfos = new HashSet<Mixer.Info>();
MixerProviderStruct struct = getMixerProviderStruct();
synchronized (struct) {
Iterator<Mixer> mixers = struct.m_mixers.iterator();
while (mixers.hasNext()) {
Mixer mixer = mixers.next();
mixerInfos.add(mixer.getMixerInfo());
}
}
if (TDebug.TraceMixerProvider) {
TDebug.out("TMixerProvider.getMixerInfo(): end");
}
return mixerInfos.toArray(EMPTY_MIXER_INFO_ARRAY);
}
private boolean arePortsSupported(Mixer mixer) {
Line.Info[] infos;
infos = mixer.getSourceLineInfo();
for (Line.Info info : infos) {
if (info instanceof Port.Info) {
return true;
} else if (info instanceof DataLine.Info) {
return true;
}
}
infos = mixer.getTargetLineInfo();
for (Line.Info info : infos) {
if (info instanceof Port.Info) {
return true;
} else if (info instanceof DataLine.Info) {
return true;
}
}
return false;
}
private static void runVolumeCommand(Closure closure) {
Mixer.Info[] infos = AudioSystem.getMixerInfo();
for (Mixer.Info info : infos) {
Mixer mixer = AudioSystem.getMixer(info);
if (mixer.isLineSupported(Port.Info.SPEAKER)) {
Port port;
try {
port = (Port) mixer.getLine(Port.Info.SPEAKER);
port.open();
if (port.isControlSupported(FloatControl.Type.VOLUME)) {
FloatControl volume = (FloatControl) port.getControl(FloatControl.Type.VOLUME);
closure.execute(volume);
}
port.close();
} catch (LineUnavailableException e) {
logger.error("Cannot access master volume control", e);
}
}
}
}
private boolean setupSpeaker(String device) throws LineUnavailableException {
Mixer.Info[] aInfos = AudioSystem.getMixerInfo();
for (int i = 0; i < aInfos.length; i++) {
Mixer.Info mixerInfo = aInfos[i];
if (GetDataLines.equals(device, mixerInfo) == false) {
if (Logger.logLevel >= Logger.LOG_MOREINFO) {
Logger.println("Skipping: " + mixerInfo.getName() + "," + mixerInfo.getDescription());
}
continue;
}
try {
Mixer mixer = AudioSystem.getMixer(mixerInfo);
Line.Info[] infos = mixer.getSourceLineInfo();
for (int j = 0; j < infos.length; j++) {
Line line = (Line) mixer.getLine(infos[j]);
if (line instanceof SourceDataLine) {
speaker = (SourceDataLine) line;
if (Logger.logLevel >= Logger.LOG_INFO) {
Logger.println("Found speaker: " + j);
}
break;
}
}
} catch (Exception e) {
if (Logger.logLevel >= Logger.LOG_MOREINFO) {
Logger.println("Exception: " + e.getMessage());
}
}
}
return speaker != null;
}
private void mixerComboBoxActionPerformed() {
Mixer mixer = AudioSystem.getMixer((Mixer.Info) mixerComboBox.getSelectedItem());
Line.Info lineInfo = mixer.getSourceLineInfo(new Line.Info(Clip.class))[0];
boolean volumeSupported;
boolean panSupported;
try {
Line line = mixer.getLine(lineInfo);
volumeSupported = line.isControlSupported(FloatControl.Type.MASTER_GAIN);
panSupported = line.isControlSupported(FloatControl.Type.PAN);
} catch (LineUnavailableException e) {
volumeSupported = false;
panSupported = false;
}
enableMixerVolumeCheckBox.setEnabled(volumeSupported);
enableMixerPanCheckBox.setEnabled(panSupported);
}
private static void d1() {
Mixer.Info[] fmi = AudioSystem.getMixerInfo();
for (Mixer.Info mi : fmi) {
Mixer mixer = AudioSystem.getMixer(mi);
Line.Info[] isl = mixer.getSourceLineInfo();
Line.Info[] itl = mixer.getTargetLineInfo();
// if( itl.length > 0)
{
error.log("--------------------------------------------------------------");
error.log("Src Count " + isl.length + " Target size " + itl.length);
error.log(mi.toString());
error.log("Name " + mi.getName());
error.log("Version " + mi.getVersion());
error.log("Vendor " + mi.getVendor());
error.log("Description " + mi.getDescription());
error.log("~~~");
dumpLines(isl, " >> SourceLine : ");
dumpLines(itl, " >> TargetLine : ");
}
}
}
/**
* Close the audio clip. There is a bunch of code here attempting to close the audio stream. Turns
* out there is a a bug and the only way to close out the background audio threads is to do a
* System.exit().
*/
public void close() {
if (audioClip == null) return;
synchronized (audioClip) {
audioClip.removeLineListener(this);
audioClip.close();
try {
audioStream.close();
} catch (IOException e) {
System.out.println(e.getMessage());
}
// close the mixer (stops any running sounds)
Mixer mixer = AudioSystem.getMixer(null);
if (mixer.isOpen()) {
mixer.close();
}
audioState = AudioState.DEAD;
}
}
@Override
public boolean equals(Object obj) {
if (this == obj) return true;
if (obj == null) return false;
if (getClass() != obj.getClass()) return false;
MixerChannelConfiguration other = (MixerChannelConfiguration) obj;
if (mMixer == null) {
if (other.mMixer != null) return false;
} else if (!mMixer.equals(other.mMixer)) return false;
if (mMixerChannel != other.mMixerChannel) return false;
return true;
}
public Mixer getMixer(Mixer.Info info) {
// if the default device is asked, we provide the mixer
// with SourceDataLine's
if (info == null) {
for (int i = 0; i < infos.length; i++) {
Mixer mixer = getDevice(infos[i]);
if (mixer.getSourceLineInfo().length > 0) {
return mixer;
}
}
}
// otherwise get the first mixer that matches
// the requested info object
for (int i = 0; i < infos.length; i++) {
if (infos[i].equals(info)) {
return getDevice(infos[i]);
}
}
throw new IllegalArgumentException(
"Mixer " + info.toString() + " not supported by this provider.");
}
private static Mixer.Info[] getAvailableMixers(boolean isTarget) {
ArrayList<Mixer.Info> mixers =
new ArrayList<Mixer.Info>(Arrays.asList((Mixer.Info[]) AudioSystem.getMixerInfo()));
for (Iterator<Mixer.Info> it = mixers.iterator(); it.hasNext(); ) {
Mixer.Info minfo = it.next();
Mixer mixer = AudioSystem.getMixer(minfo);
Line.Info[] linfo = (isTarget) ? mixer.getTargetLineInfo() : mixer.getSourceLineInfo();
boolean hasDataLine = false;
for (int j = 0; j < linfo.length; j++) {
if (linfo[j] instanceof DataLine.Info) {
hasDataLine = true;
break;
}
}
if (!hasDataLine) {
it.remove();
}
}
return mixers.toArray(new Mixer.Info[mixers.size()]);
}
private void createMixerChildren(JavaMixer.MixerNode mixerNode) {
Mixer mixer = mixerNode.getMixer();
Line.Info[] infosToCheck = getPortInfo(mixer);
for (Line.Info anInfosToCheck : infosToCheck) {
if (mixer.isLineSupported(anInfosToCheck)) {
Port port = null;
DataLine dLine = null;
int maxLines = mixer.getMaxLines(anInfosToCheck);
// Workaround to prevent a JVM crash on Mac OS X (Intel) 1.5.0_07 JVM
if (maxLines > 0) {
try {
if (anInfosToCheck instanceof Port.Info) {
port = (Port) mixer.getLine(anInfosToCheck);
port.open();
} else if (anInfosToCheck instanceof DataLine.Info) {
dLine = (DataLine) mixer.getLine(anInfosToCheck);
if (!dLine.isOpen()) {
dLine.open();
}
}
} catch (LineUnavailableException e) {
e.printStackTrace();
} catch (Exception e) {
// Do Nothing
}
}
if (port != null) {
JavaMixer.PortNode portNode = new JavaMixer.PortNode(port);
createPortChildren(portNode);
mixerNode.add(portNode);
} else if (dLine != null) {
JavaMixer.PortNode portNode = new JavaMixer.PortNode(dLine);
createPortChildren(portNode);
mixerNode.add(portNode);
}
}
}
}
private void setNewMixer(Mixer mixer)
throws LineUnavailableException, UnsupportedAudioFileException {
if (dispatcher != null) {
dispatcher.stop();
}
if (fileName == null) {
final AudioFormat format = new AudioFormat(sampleRate, 16, 1, true, false);
final DataLine.Info dataLineInfo = new DataLine.Info(TargetDataLine.class, format);
TargetDataLine line;
line = (TargetDataLine) mixer.getLine(dataLineInfo);
final int numberOfSamples = bufferSize;
line.open(format, numberOfSamples);
line.start();
final AudioInputStream stream = new AudioInputStream(line);
// create a new dispatcher
dispatcher = new AudioDispatcher(stream, bufferSize, overlap);
} else {
try {
File audioFile = new File(fileName);
dispatcher = AudioDispatcher.fromFile(audioFile, bufferSize, overlap);
AudioFormat format = AudioSystem.getAudioFileFormat(audioFile).getFormat();
dispatcher.addAudioProcessor(new AudioPlayer(format));
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
currentMixer = mixer;
// add a processor, handle pitch event.
dispatcher.addAudioProcessor(new PitchProcessor(algo, sampleRate, bufferSize, this));
dispatcher.addAudioProcessor(fftProcessor);
// run the dispatcher (on a new thread).
new Thread(dispatcher, "Audio dispatching").start();
}
/**
* Gets the maximum number of simultaneous sounds with the specified AudioFormat that the default
* mixer can play.
*/
public static int getMaxSimultaneousSounds(AudioFormat playbackFormat) {
DataLine.Info lineInfo = new DataLine.Info(SourceDataLine.class, playbackFormat);
Mixer mixer = AudioSystem.getMixer(null);
return mixer.getMaxLines(lineInfo);
}
/**
* Single audio channel playback with automatic starting and stopping of the underlying
* sourcedataline specified by the mixer and mixer channel arguments.
*
* <p>Maintains an internal non-blocking audio packet queue and processes this queue 25 times a
* second (every 40 ms).
*
* @param threadPoolManager for assigning buffer processing schedule task
* @param mixer to obtain source data line
* @param mixerChannel either mono or left/right stereo
* @param audioFormat to use during playback
* @param lineInfo to use when obtaining the source data line
* @param requestedBufferSize of approximately 1 second of audio
*/
public AudioOutput(
ThreadPoolManager threadPoolManager,
Mixer mixer,
MixerChannel mixerChannel,
AudioFormat audioFormat,
Line.Info lineInfo,
int requestedBufferSize) {
mThreadPoolManager = threadPoolManager;
mMixer = mixer;
mMixerChannel = mixerChannel;
try {
mOutput = (SourceDataLine) mMixer.getLine(lineInfo);
if (mOutput != null) {
mOutput.open(audioFormat, requestedBufferSize);
// Start threshold: buffer is full with 10% or less of capacity remaining
mBufferStartThreshold = (int) (mOutput.getBufferSize() * 0.10);
// Stop threshold: buffer is empty with 90% or more capacity available
mBufferStopThreshold = (int) (mOutput.getBufferSize() * 0.90);
mOutput.addLineListener(this);
if (mOutput != null) {
try {
Control gain = mOutput.getControl(FloatControl.Type.MASTER_GAIN);
mGainControl = (FloatControl) gain;
} catch (IllegalArgumentException iae) {
mLog.warn(
"Couldn't obtain MASTER GAIN control for stereo line ["
+ mixer.getMixerInfo().getName()
+ " | "
+ getChannelName()
+ "]");
}
try {
Control mute = mOutput.getControl(BooleanControl.Type.MUTE);
mMuteControl = (BooleanControl) mute;
} catch (IllegalArgumentException iae) {
mLog.warn(
"Couldn't obtain MUTE control for stereo line ["
+ mixer.getMixerInfo().getName()
+ " | "
+ getChannelName()
+ "]");
}
/* Run the queue processor task every 40 milliseconds or 25 times a second */
mProcessorTask =
mThreadPoolManager.scheduleFixedRate(
ThreadType.AUDIO_PROCESSING, new BufferProcessor(), 40, TimeUnit.MILLISECONDS);
}
mAudioStartEvent = new AudioEvent(AudioEvent.Type.AUDIO_STARTED, getChannelName());
mAudioStopEvent = new AudioEvent(AudioEvent.Type.AUDIO_STOPPED, getChannelName());
mCanProcessAudio = true;
}
} catch (LineUnavailableException e) {
mLog.error(
"Couldn't obtain audio source data line for "
+ "audio output - mixer ["
+ mMixer.getMixerInfo().getName()
+ "]");
}
}
@SuppressWarnings("SleepWhileInLoop")
@Override
boolean bindAudioBuffer(AudioBuffer audioBuffer) {
// First check we've been initialised
if (!initialised) {
return false;
}
// Wait for AudioBuffer to be loaded, or 20 seconds
long startTime = System.currentTimeMillis();
while (audioBuffer.getState() != AudioBuffer.STATE_LOADED
&& System.currentTimeMillis() - startTime < 20000) {
try {
Thread.sleep(50);
} catch (InterruptedException ex) {
}
}
if (audioBuffer instanceof JavaSoundAudioBuffer
&& audioBuffer.getState() == AudioBuffer.STATE_LOADED) {
// Cast to JavaSoundAudioBuffer to enable easier access to specific methods
JavaSoundAudioBuffer buffer = (JavaSoundAudioBuffer) audioBuffer;
// Get a JavaSound DataLine and Clip
DataLine.Info lineInfo;
lineInfo = new DataLine.Info(Clip.class, buffer.getAudioFormat());
Clip newClip;
try {
newClip = (Clip) mixer.getLine(lineInfo);
} catch (LineUnavailableException ex) {
log.warn(
"Error binding JavaSoundSource ("
+ this.getSystemName()
+ ") to AudioBuffer ("
+ this.getAssignedBufferName()
+ ") "
+ ex);
return false;
}
this.clip = newClip;
try {
clip.open(
buffer.getAudioFormat(),
buffer.getDataStorageBuffer(),
0,
buffer.getDataStorageBuffer().length);
} catch (LineUnavailableException ex) {
log.warn(
"Error binding JavaSoundSource ("
+ this.getSystemName()
+ ") to AudioBuffer ("
+ this.getAssignedBufferName()
+ ")"
+ ex);
}
if (log.isDebugEnabled()) {
log.debug(
"Bind JavaSoundAudioSource ("
+ this.getSystemName()
+ ") to JavaSoundAudioBuffer ("
+ audioBuffer.getSystemName()
+ ")");
}
return true;
} else {
log.warn(
"AudioBuffer not loaded error when binding JavaSoundSource ("
+ this.getSystemName()
+ ") to AudioBuffer ("
+ this.getAssignedBufferName()
+ ")");
return false;
}
}