package sound.paulscode;
import java.io.IOException;
import java.net.URL;
import java.util.LinkedList;
import java.util.ListIterator;
import javax.sound.midi.InvalidMidiDataException;
import javax.sound.midi.MetaEventListener;
import javax.sound.midi.MetaMessage;
import javax.sound.midi.MidiDevice;
import javax.sound.midi.MidiSystem;
import javax.sound.midi.MidiUnavailableException;
import javax.sound.midi.Receiver;
import javax.sound.midi.Sequence;
import javax.sound.midi.Sequencer;
import javax.sound.midi.ShortMessage;
import javax.sound.midi.Synthesizer;
/**
* The MidiChannel class provides an interface for playing MIDI files, using
* the JavaSound API. For more information about the JavaSound API, visit
* http://java.sun.com/products/java-media/sound/
*<br><br>
*<b><i> SoundSystem License:</b></i><br><b><br>
* You are free to use this library for any purpose, commercial or otherwise.
* You may modify this library or source code, and distribute it any way you
* like, provided the following conditions are met:
*<br>
* 1) You may not falsely claim to be the author of this library or any
* unmodified portion of it.
*<br>
* 2) You may not copyright this library or a modified version of it and then
* sue me for copyright infringement.
*<br>
* 3) If you modify the source code, you must clearly document the changes
* made before redistributing the modified source code, so other users know
* it is not the original code.
*<br>
* 4) You are not required to give me credit for this library in any derived
* work, but if you do, you must also mention my website:
* http://www.paulscode.com
*<br>
* 5) I the author will not be responsible for any damages (physical,
* financial, or otherwise) caused by the use if this library or any part
* of it.
*<br>
* 6) I the author do not guarantee, warrant, or make any representations,
* either expressed or implied, regarding the use of this library or any
* part of it.
* <br><br>
* Author: Paul Lamb
* <br>
* http://www.paulscode.com
* </b>
*/
public class MidiChannel implements MetaEventListener
{
/**
* Processes status messages, warnings, and error messages.
*/
private SoundSystemLogger logger;
/**
* Filename/URL to the file:
*/
private FilenameURL filenameURL;
/**
* Unique source identifier for this MIDI source.
*/
private String sourcename;
/**
* Global identifier for the MIDI "change volume" event.
*/
private static final int CHANGE_VOLUME = 7;
/**
* Global identifier for the MIDI "end of track" event.
*/
private static final int END_OF_TRACK = 47;
/**
* Used to return a current value from one of the synchronized
* boolean-interface methods.
*/
private static final boolean GET = false;
/**
* Used to set the value in one of the synchronized boolean-interface methods.
*/
private static final boolean SET = true;
/**
* Used when a parameter for one of the synchronized boolean-interface methods
* is not aplicable.
*/
private static final boolean XXX = false;
/**
* Runs the assigned sequence, passing information on to the synthesizer for
* playback.
*/
private Sequencer sequencer = null;
/**
* Converts MIDI events into audio.
*/
private Synthesizer synthesizer = null;
/**
* Converts MIDI events into audio if there is no default Synthesizer.
*/
private MidiDevice synthDevice = null;
/**
* Sequence of MIDI events defining sound.
*/
private Sequence sequence = null;
/**
* Should playback loop or play only once.
*/
private boolean toLoop = true;
/**
* Playback volume, float value (0.0f - 1.0f).
*/
private float gain = 1.0f;
/**
* True while sequencer is busy being set up.
*/
private boolean loading = true;
/**
* The list of MIDI files to play when the current sequence finishes.
*/
private LinkedList<FilenameURL> sequenceQueue = null;
/**
* Ensures that only one thread accesses the sequenceQueue at a time.
*/
private final Object sequenceQueueLock = new Object();
/**
* Specifies the gain factor used for the fade-out effect, or -1 when
* playback is not currently fading out.
*/
protected float fadeOutGain = -1.0f;
/**
* Specifies the gain factor used for the fade-in effect, or 1 when
* playback is not currently fading in.
*/
protected float fadeInGain = 1.0f;
/**
* Specifies the number of miliseconds it should take to fade out.
*/
protected long fadeOutMilis = 0;
/**
* Specifies the number of miliseconds it should take to fade in.
*/
protected long fadeInMilis = 0;
/**
* System time in miliseconds when the last fade in/out volume check occurred.
*/
protected long lastFadeCheck = 0;
/**
* Used for fading in and out effects.
*/
private FadeThread fadeThread = null;
/**
* Constructor: Defines the basic source information.
* @param toLoop Should playback loop or play only once?
* @param sourcename Unique identifier for this source.
* @param filename Name of the MIDI file to play.
*/
public MidiChannel( boolean toLoop, String sourcename, String filename )
{
// let others know we are busy loading:
loading( SET, true );
// grab a handle to the message logger:
logger = SoundSystemConfig.getLogger();
// save information about the source:
filenameURL( SET, new FilenameURL( filename ) );
sourcename( SET, sourcename );
setLooping( toLoop );
// initialize the MIDI channel:
init();
// finished loading:
loading( SET, false );
}
/**
* Constructor: Defines the basic source information. The fourth parameter,
* 'identifier' should look like a filename, and it must have the correct
* extension (.mid or .midi).
* @param toLoop Should playback loop or play only once?
* @param sourcename Unique identifier for this source.
* @param midiFile URL to the MIDI file to play.
* @param identifier Filename/identifier for the MIDI file.
*/
public MidiChannel( boolean toLoop, String sourcename, URL midiFile,
String identifier )
{
// let others know we are busy loading
loading( SET, true );
// grab a handle to the message logger:
logger = SoundSystemConfig.getLogger();
// save information about the source:
filenameURL( SET, new FilenameURL( midiFile, identifier ) );
sourcename( SET, sourcename );
setLooping( toLoop );
// initialize the MIDI channel:
init();
// finished loading:
loading( SET, false );
}
/**
* Constructor: Defines the basic source information.
* @param toLoop Should playback loop or play only once?
* @param sourcename Unique identifier for this source.
* @param midiFilenameURL Filename/URL to the MIDI file to play.
*/
public MidiChannel( boolean toLoop, String sourcename,
FilenameURL midiFilenameURL )
{
// let others know we are busy loading
loading( SET, true );
// grab a handle to the message logger:
logger = SoundSystemConfig.getLogger();
// save information about the source:
filenameURL( SET, midiFilenameURL );
sourcename( SET, sourcename );
setLooping( toLoop );
// initialize the MIDI channel:
init();
// finished loading:
loading( SET, false );
}
/**
* Initializes the sequencer, loads the sequence, and sets up the synthesizer.
*/
private void init()
{
// Load a sequencer:
getSequencer();
// Load the sequence to play:
setSequence( filenameURL( GET, null).getURL() );
// Load a synthesizer to play the sequence on:
getSynthesizer();
// Ensure the initial volume is correct:
// (TODO: doesn't always work??)
resetGain();
}
/**
* Shuts the channel down and removes references to all instantiated objects.
*/
public void cleanup()
{
loading( SET, true );
setLooping( true );
if( sequencer != null )
{
try
{
sequencer.stop();
sequencer.close();
sequencer.removeMetaEventListener( this );
}
catch( Exception e )
{}
}
logger = null;
sequencer = null;
synthesizer = null;
sequence = null;
synchronized( sequenceQueueLock )
{
if( sequenceQueue != null )
sequenceQueue.clear();
sequenceQueue = null;
}
// End the fade effects thread if it exists:
if( fadeThread != null )
{
boolean killException = false;
try
{
fadeThread.kill(); // end the fade effects thread.
fadeThread.interrupt(); // wake the thread up so it can end.
}
catch( Exception e )
{
killException = true;
}
if( !killException )
{
// wait up to 5 seconds for fade effects thread to end:
for( int i = 0; i < 50; i++ )
{
if( !fadeThread.alive() )
break;
try{Thread.sleep( 100 );}catch(InterruptedException e){}
}
}
// Let user know if there was a problem ending the fade thread
if( killException || fadeThread.alive() )
{
errorMessage( "MIDI fade effects thread did not die!" );
message( "Ignoring errors... continuing clean-up." );
}
}
fadeThread = null;
loading( SET, false );
}
/**
* Queues up the next MIDI sequence to play when the previous sequence ends.
* @param filenameURL MIDI sequence to play next.
*/
public void queueSound( FilenameURL filenameURL )
{
if( filenameURL == null )
{
errorMessage( "Filename/URL not specified in method 'queueSound'" );
return;
}
synchronized( sequenceQueueLock )
{
if( sequenceQueue == null )
sequenceQueue = new LinkedList<FilenameURL>();
sequenceQueue.add( filenameURL );
}
}
/**
* Removes the first occurrence of the specified filename/identifier from the
* list of MIDI sequences to play when the previous sequence ends.
* @param filename Filename or identifier of a MIDI sequence to remove from the
* queue.
*/
public void dequeueSound( String filename )
{
if( filename == null || filename.equals( "" ) )
{
errorMessage( "Filename not specified in method 'dequeueSound'" );
return;
}
synchronized( sequenceQueueLock )
{
if( sequenceQueue != null )
{
ListIterator<FilenameURL> i = sequenceQueue.listIterator();
while( i.hasNext() )
{
if( i.next().getFilename().equals( filename ) )
{
i.remove();
break;
}
}
}
}
}
/**
* Fades out the volume of whatever sequence is currently playing, then
* begins playing the specified MIDI file at the previously assigned
* volume level. If the filenameURL parameter is null or empty, playback will
* simply fade out and stop. The miliseconds parameter must be non-negative or
* zero. This method will remove anything that is currently in the list of
* queued MIDI sequences that would have played next when current playback
* finished.
* @param filenameURL MIDI file to play next, or null for none.
* @param milis Number of miliseconds the fadeout should take.
*/
public void fadeOut( FilenameURL filenameURL, long milis )
{
if( milis < 0 )
{
errorMessage( "Miliseconds may not be negative in method " +
"'fadeOut'." );
return;
}
fadeOutMilis = milis;
fadeInMilis = 0;
fadeOutGain = 1.0f;
lastFadeCheck = System.currentTimeMillis();
synchronized( sequenceQueueLock )
{
if( sequenceQueue != null )
sequenceQueue.clear();
if( filenameURL != null )
{
if( sequenceQueue == null )
sequenceQueue = new LinkedList<FilenameURL>();
sequenceQueue.add( filenameURL );
}
}
if( fadeThread == null )
{
fadeThread = new FadeThread();
fadeThread.start();
}
fadeThread.interrupt();
}
/**
* Fades out the volume of whatever sequence is currently playing, then
* fades the volume back in playing the specified MIDI file. Final volume
* after fade-in completes will be equal to the previously assigned volume
* level. The filenameURL parameter may not be null or empty. The miliseconds
* parameters must be non-negative or zero. This method will remove anything
* that is currently in the list of queued MIDI sequences that would have
* played next when current playback finished.
* @param filenameURL MIDI file to play next, or null for none.
* @param milisOut Number of miliseconds the fadeout should take.
* @param milisIn Number of miliseconds the fadein should take.
*/
public void fadeOutIn( FilenameURL filenameURL, long milisOut,
long milisIn )
{
if( filenameURL == null )
{
errorMessage( "Filename/URL not specified in method 'fadeOutIn'." );
return;
}
if( milisOut < 0 || milisIn < 0 )
{
errorMessage( "Miliseconds may not be negative in method " +
"'fadeOutIn'." );
return;
}
fadeOutMilis = milisOut;
fadeInMilis = milisIn;
fadeOutGain = 1.0f;
lastFadeCheck = System.currentTimeMillis();
synchronized( sequenceQueueLock )
{
if( sequenceQueue == null )
sequenceQueue = new LinkedList<FilenameURL>();
sequenceQueue.clear();
sequenceQueue.add( filenameURL );
}
if( fadeThread == null )
{
fadeThread = new FadeThread();
fadeThread.start();
}
fadeThread.interrupt();
}
/**
* Resets this source's volume if it is fading out or in. Returns true if this
* source is currently in the process of fading out. When fade-out completes,
* this method transitions the source to the next sound in the sound sequence
* queue if there is one. This method has no effect on non-streaming sources.
* @return True if this source is in the process of fading out.
*/
private synchronized boolean checkFadeOut()
{
if( fadeOutGain == -1.0f && fadeInGain == 1.0f )
return false;
long currentTime = System.currentTimeMillis();
long milisPast = currentTime - lastFadeCheck;
lastFadeCheck = currentTime;
if( fadeOutGain >= 0.0f )
{
if( fadeOutMilis == 0 )
{
fadeOutGain = 0.0f;
fadeInGain = 0.0f;
if( !incrementSequence() )
stop();
rewind();
resetGain();
return false;
}
else
{
float fadeOutReduction = ((float)milisPast) / ((float)fadeOutMilis);
fadeOutGain -= fadeOutReduction;
if( fadeOutGain <= 0.0f )
{
fadeOutGain = -1.0f;
fadeInGain = 0.0f;
if( !incrementSequence() )
stop();
rewind();
resetGain();
return false;
}
}
resetGain();
return true;
}
if( fadeInGain < 1.0f )
{
fadeOutGain = -1.0f;
if( fadeInMilis == 0 )
{
fadeOutGain = -1.0f;
fadeInGain = 1.0f;
}
else
{
float fadeInIncrease = ((float)milisPast) / ((float)fadeInMilis);
fadeInGain += fadeInIncrease;
if( fadeInGain >= 1.0f )
{
fadeOutGain = -1.0f;
fadeInGain = 1.0f;
}
}
resetGain();
}
return false;
}
/**
* Removes the next sequence from the queue and assigns it to the sequencer.
* @return True if there was something in the queue.
*/
private boolean incrementSequence()
{
synchronized( sequenceQueueLock )
{
// Is there a queue, and if so, is there anything in it:
if( sequenceQueue != null && sequenceQueue.size() > 0 )
{
// grab the next filename/URL from the queue:
filenameURL( SET, sequenceQueue.remove( 0 ) );
// Let everyone know we are busy loading:
loading( SET, true );
// Check if we have a sequencer:
if( sequencer == null )
{
// nope, try and get one now:
getSequencer();
}
else
{
// We have a sequencer. Stop it now:
sequencer.stop();
// rewind to the beginning:
sequencer.setMicrosecondPosition( 0 );
// Stop listening for a moment:
sequencer.removeMetaEventListener( this );
// wait a bit for the sequencer to shut down and rewind:
try{ Thread.sleep( 100 ); }catch( InterruptedException e ){}
}
// We need to have a sequencer at this point:
if( sequencer == null )
{
errorMessage( "Unable to set the sequence in method " +
"'incrementSequence', because there wasn't " +
"a sequencer to use." );
// Finished loading:
loading( SET, false );
// failure:
return false;
}
// set the new sequence to be played:
setSequence( filenameURL( GET, null ).getURL() );
// start playing again:
sequencer.start();
// make sure we play at the correct volume:
// (TODO: This doesn't always work??)
resetGain();
// start listening for end of track event again:
sequencer.addMetaEventListener( this );
// Finished loading:
loading( SET, false );
// We successfully moved to the next sequence:
return true;
}
}
// Nothing left to load
return false;
}
/**
* Plays the MIDI file from the beginning, or from where it left off if it was
* paused.
*/
public void play()
{
if( !loading() )
{
// Make sure there is a sequencer:
if( sequencer == null )
return;
try
{
// start playing:
sequencer.start();
// event will be sent when end of track is reached:
sequencer.addMetaEventListener( this );
}
catch( Exception e )
{
errorMessage( "Exception in method 'play'" );
printStackTrace( e );
SoundSystemException sse = new SoundSystemException(
e.getMessage() );
SoundSystem.setException( sse );
}
}
}
/**
* Stops playback and rewinds to the beginning.
*/
public void stop()
{
if( !loading() )
{
// Make sure there is a sequencer:
if( sequencer == null )
return;
try
{
// stop playback:
sequencer.stop();
// rewind to the beginning:
sequencer.setMicrosecondPosition( 0 );
// No need to listen any more:
sequencer.removeMetaEventListener( this );
}
catch( Exception e )
{
errorMessage( "Exception in method 'stop'" );
printStackTrace( e );
SoundSystemException sse = new SoundSystemException(
e.getMessage() );
SoundSystem.setException( sse );
}
}
}
/**
* Temporarily stops playback without rewinding.
*/
public void pause()
{
if( !loading() )
{
// Make sure there is a sequencer:
if( sequencer == null )
return;
try
{
//stop playback. Will resume from this location next play.
sequencer.stop();
}
catch( Exception e )
{
errorMessage( "Exception in method 'pause'" );
printStackTrace( e );
SoundSystemException sse = new SoundSystemException(
e.getMessage() );
SoundSystem.setException( sse );
}
}
}
/**
* Returns playback to the beginning.
*/
public void rewind()
{
if( !loading() )
{
// Make sure there is a sequencer:
if( sequencer == null )
return;
try
{
// rewind to the beginning:
sequencer.setMicrosecondPosition( 0 );
}
catch( Exception e )
{
errorMessage( "Exception in method 'rewind'" );
printStackTrace( e );
SoundSystemException sse = new SoundSystemException(
e.getMessage() );
SoundSystem.setException( sse );
}
}
}
/**
* Changes the volume of MIDI playback.
* @param value Float value (0.0f - 1.0f).
*/
public void setVolume( float value )
{
gain = value;
resetGain();
}
/**
* Returns the current volume for the MIDI source.
* @return Float value (0.0f - 1.0f).
*/
public float getVolume()
{
return gain;
}
/**
* Changes the basic information about the MIDI source. This method removes
* any queued filenames/URLs from the list of MIDI sequences that would have
* played after the current sequence ended.
* @param toLoop Should playback loop or play only once?
* @param sourcename Unique identifier for this source.
* @param filename Name of the MIDI file to play.
*/
public void switchSource( boolean toLoop, String sourcename,
String filename )
{
// Let everyone know we are busy loading:
loading( SET, true );
// save information about the source:
filenameURL( SET, new FilenameURL( filename ) );
sourcename( SET, sourcename );
setLooping( toLoop );
reset();
// Finished loading:
loading( SET, false );
}
/**
* Changes the basic information about the MIDI source. This method removes
* any queued filenames/URLs from the list of MIDI sequences that would have
* played after the current sequence ended. The fourth parameter,
* 'identifier' should look like a filename, and it must have the correct
* extension (.mid or .midi).
* @param toLoop Should playback loop or play only once?
* @param sourcename Unique identifier for this source.
* @param midiFile URL to the MIDI file to play.
* @param identifier Filename/identifier for the MIDI file.
*/
public void switchSource( boolean toLoop, String sourcename, URL midiFile,
String identifier )
{
// Let everyone know we are busy loading:
loading( SET, true );
// save information about the source:
filenameURL( SET, new FilenameURL( midiFile, identifier ) );
sourcename( SET, sourcename );
setLooping( toLoop );
reset();
// Finished loading:
loading( SET, false );
}
/**
* Changes the basic information about the MIDI source. This method removes
* any queued filenames/URLs from the list of MIDI sequences that would have
* played after the current sequence ended.
* @param toLoop Should playback loop or play only once?
* @param sourcename Unique identifier for this source.
* @param filenameURL Filename/URL of the MIDI file to play.
*/
public void switchSource( boolean toLoop, String sourcename,
FilenameURL filenameURL )
{
// Let everyone know we are busy loading:
loading( SET, true );
// save information about the source:
filenameURL( SET, filenameURL );
sourcename( SET, sourcename );
setLooping( toLoop );
reset();
// Finished loading:
loading( SET, false );
}
/**
* Stops and rewinds the sequencer, and resets the sequence.
*/
private void reset()
{
synchronized( sequenceQueueLock )
{
if( sequenceQueue != null )
sequenceQueue.clear();
}
// Check if we have a sequencer:
if( sequencer == null )
{
// nope, try and get one now:
getSequencer();
}
else
{
// We have a sequencer. Stop it now:
sequencer.stop();
// rewind to the beginning:
sequencer.setMicrosecondPosition( 0 );
// Stop listening for a moment:
sequencer.removeMetaEventListener( this );
// wait a bit for the sequencer to shut down and rewind:
try{ Thread.sleep( 100 ); }catch( InterruptedException e ){}
}
// We need to have a sequencer at this point:
if( sequencer == null )
{
errorMessage( "Unable to set the sequence in method " +
"'reset', because there wasn't " +
"a sequencer to use." );
return;
}
// set the new sequence to be played:
setSequence( filenameURL( GET, null ).getURL() );
// start playing again:
sequencer.start();
// make sure we play at the correct volume:
// (TODO: This doesn't always work??)
resetGain();
// start listening for end of track event again:
sequencer.addMetaEventListener( this );
}
/**
* Sets the value of boolean 'toLoop'.
* @param value True or False.
*/
public void setLooping( boolean value )
{
toLoop( SET, value );
}
/**
* Returns the value of boolean 'toLoop'.
* @return True while looping.
*/
public boolean getLooping()
{
return toLoop( GET, XXX );
}
/**
* Sets or returns the value of boolean 'toLoop'.
* @param action GET or SET.
* @param value New value if action == SET, or XXX if action == GET.
* @return True while looping.
*/
private synchronized boolean toLoop( boolean action, boolean value )
{
if( action == SET )
toLoop = value;
return toLoop;
}
/**
* Check if a MIDI file is in the process of loading.
*/
public boolean loading()
{
return( loading( GET, XXX ) );
}
/**
* Sets or returns the value of boolean 'loading'.
* @param action GET or SET.
* @param value New value if action == SET, or XXX if action == GET.
* @return True while a MIDI file is in the process of loading.
*/
private synchronized boolean loading( boolean action, boolean value )
{
if( action == SET )
loading = value;
return loading;
}
/**
* Defines the unique identifier for this source
* @param value New source name.
*/
public void setSourcename( String value )
{
sourcename( SET, value );
}
/**
* Returns the unique identifier for this source.
* @return The source's name.
*/
public String getSourcename()
{
return sourcename( GET, null );
}
/**
* Sets or returns the value of String 'sourcename'.
* @param action GET or SET.
* @param value New value if action == SET, or null if action == GET.
* @return The source's name.
*/
private synchronized String sourcename( boolean action, String value )
{
if( action == SET )
sourcename = value;
return sourcename;
}
/**
* Defines which MIDI file to play.
* @param value Path to the MIDI file.
*/
public void setFilenameURL( FilenameURL value )
{
filenameURL( SET, value );
}
/**
* Returns the filename/identifier of the MIDI file being played.
* @return Filename of identifier of the MIDI file.
*/
public String getFilename()
{
return filenameURL( GET, null ).getFilename();
}
/**
* Returns the MIDI file being played.
* @return Filename/URL of the MIDI file.
*/
public FilenameURL getFilenameURL()
{
return filenameURL( GET, null );
}
/**
* Sets or returns the value of filenameURL.
* @param action GET or SET.
* @param value New value if action == SET, or null if action == GET.
* @return Path to the MIDI file.
*/
private synchronized FilenameURL filenameURL( boolean action,
FilenameURL value )
{
if( action == SET )
filenameURL = value;
return filenameURL;
}
/**
* Called when MIDI events occur.
* @param message Meta mssage describing the MIDI event.
*/
public void meta( MetaMessage message )
{
if( message.getType() == END_OF_TRACK )
{
// Generate an EOS event:
SoundSystemConfig.notifyEOS( sourcename, sequenceQueue.size() );
// check if we should loop or not:
if( toLoop )
{
// looping
// Check if playback is in the process of fading out.
if( !checkFadeOut() )
{
// Not fading out, progress to the next MIDI sequence if
// any are queued.
if( !incrementSequence() )
{
try
{
// Rewind to the beginning.
sequencer.setMicrosecondPosition( 0 );
sequencer.start();
// Make sure playback volume is correct.
resetGain();
}
catch( Exception e ){}
}
}
else if( sequencer != null )
{
try
{
// Rewind to the beginning.
sequencer.setMicrosecondPosition( 0 );
sequencer.start();
// Make sure playback volume is correct.
resetGain();
}
catch( Exception e ){}
}
}
else
{
//non-looping
if( !checkFadeOut() )
{
if( !incrementSequence() )
{
try
{
// stop playback:
sequencer.stop();
// rewind to the beginning:
sequencer.setMicrosecondPosition( 0 );
// stop looping:
sequencer.removeMetaEventListener( this );
}
catch( Exception e ){}
}
}
else
{
try
{
// stop playback:
sequencer.stop();
// rewind to the beginning:
sequencer.setMicrosecondPosition( 0 );
// stop looping:
sequencer.removeMetaEventListener( this );
}
catch( Exception e ){}
}
}
}
}
/**
* Resets playback volume to the correct level.
*/
public void resetGain()
{
// make sure the value for gain is valid (between 0 and 1)
if( gain < 0.0f )
gain = 0.0f;
if( gain > 1.0f )
gain = 1.0f;
int midiVolume = (int) ( gain * SoundSystemConfig.getMasterGain()
* (float) Math.abs( fadeOutGain ) * fadeInGain
* 127.0f );
if( synthesizer != null )
{
javax.sound.midi.MidiChannel[] channels = synthesizer.getChannels();
for( int c = 0; channels != null && c < channels.length; c++ )
{
channels[c].controlChange( CHANGE_VOLUME, midiVolume );
}
}
else if( synthDevice != null )
{
try
{
ShortMessage volumeMessage = new ShortMessage();
for( int i = 0; i < 16; i++ )
{
volumeMessage.setMessage( ShortMessage.CONTROL_CHANGE, i,
CHANGE_VOLUME, midiVolume );
synthDevice.getReceiver().send( volumeMessage, -1 );
}
}
catch( Exception e )
{
errorMessage( "Error resetting gain on MIDI device" );
printStackTrace( e );
}
}
else if( sequencer != null && sequencer instanceof Synthesizer )
{
synthesizer = (Synthesizer) sequencer;
javax.sound.midi.MidiChannel[] channels = synthesizer.getChannels();
for( int c = 0; channels != null && c < channels.length; c++ )
{
channels[c].controlChange( CHANGE_VOLUME, midiVolume );
}
}
else
{
try
{
Receiver receiver = MidiSystem.getReceiver();
ShortMessage volumeMessage= new ShortMessage();
for( int c = 0; c < 16; c++ )
{
volumeMessage.setMessage( ShortMessage.CONTROL_CHANGE, c,
CHANGE_VOLUME, midiVolume );
receiver.send( volumeMessage, -1 );
}
}
catch( Exception e )
{
errorMessage( "Error resetting gain on default receiver" );
printStackTrace( e );
}
}
}
/**
* Attempts to load the default sequencer. If it fails, then other common
* sequencers are tried. If none can be loaded, then variable 'sequencer'
* remains null.
*/
private void getSequencer()
{
try
{
sequencer = MidiSystem.getSequencer();
if( sequencer != null )
{
try
{
sequencer.getTransmitter();
}
catch( MidiUnavailableException mue )
{
message( "Unable to get a transmitter from the " +
"default MIDI sequencer" );
}
sequencer.open();
}
}
catch( MidiUnavailableException mue )
{
message( "Unable to open the default MIDI sequencer" );
sequencer = null;
}
catch( Exception e )
{
if( e instanceof InterruptedException )
{
message( "Caught InterruptedException while attempting to " +
"open the default MIDI sequencer. Trying again." );
sequencer = null;
}
try
{
sequencer = MidiSystem.getSequencer();
if( sequencer != null )
{
try
{
sequencer.getTransmitter();
}
catch( MidiUnavailableException mue )
{
message( "Unable to get a transmitter from the " +
"default MIDI sequencer" );
}
sequencer.open();
}
}
catch( MidiUnavailableException mue )
{
message( "Unable to open the default MIDI sequencer" );
sequencer = null;
}
catch( Exception e2 )
{
message( "Unknown error opening the default MIDI sequencer" );
sequencer = null;
}
}
if( sequencer == null )
sequencer = openSequencer( "Real Time Sequencer" );
if( sequencer == null )
sequencer = openSequencer( "Java Sound Sequencer");
if( sequencer == null )
{
errorMessage( "Failed to find an available MIDI sequencer" );
return;
}
}
/**
* Loads the MIDI sequence form the specified URL, and sets the sequence. If
* variable 'sequencer' is null or an error occurs, then variable 'sequence'
* remains null.
* @param midiSource URL to a MIDI file.
*/
private void setSequence( URL midiSource )
{
if( sequencer == null )
{
errorMessage( "Unable to update the sequence in method " +
"'setSequence', because variable 'sequencer' " +
"is null" );
return;
}
if( midiSource == null )
{
errorMessage( "Unable to load Midi file in method 'setSequence'." );
return;
}
try
{
sequence = MidiSystem.getSequence( midiSource );
}
catch( IOException ioe )
{
errorMessage( "Input failed while reading from MIDI file in " +
"method 'setSequence'." );
printStackTrace( ioe );
return;
}
catch( InvalidMidiDataException imde )
{
errorMessage( "Invalid MIDI data encountered, or not a MIDI " +
"file in method 'setSequence' (1)." );
printStackTrace( imde );
return;
}
if( sequence == null )
{
errorMessage( "MidiSystem 'getSequence' method returned null " +
"in method 'setSequence'." );
}
else
{
try
{
sequencer.setSequence( sequence );
}
catch( InvalidMidiDataException imde )
{
errorMessage( "Invalid MIDI data encountered, or not a MIDI " +
"file in method 'setSequence' (2)." );
printStackTrace( imde );
return;
}
catch( Exception e )
{
errorMessage( "Problem setting sequence from MIDI file in " +
"method 'setSequence'." );
printStackTrace( e );
return;
}
}
}
/**
* First attempts to load the specified "override MIDI synthesizer" if one was
* defined. If none was defined or unable to use it, then attempts to load the
* default synthesizer. If that fails, then other common synthesizers are
* attempted. If none can be loaded, then MIDI is not possible on this system.
*/
private void getSynthesizer()
{
if( sequencer == null )
{
errorMessage( "Unable to load a Synthesizer in method " +
"'getSynthesizer', because variable 'sequencer' " +
"is null" );
return;
}
// Check if an alternate MIDI synthesizer was specified to use
String overrideMIDISynthesizer =
SoundSystemConfig.getOverrideMIDISynthesizer();
if( overrideMIDISynthesizer != null
&& !overrideMIDISynthesizer.equals( "" ) )
{
// Try and open the specified device:
synthDevice = openMidiDevice( overrideMIDISynthesizer );
// See if we got it:
if( synthDevice != null )
{
// Got it, try and link it to the sequencer:
try
{
sequencer.getTransmitter().setReceiver(
synthDevice.getReceiver() );
// Success!
return;
}
catch( MidiUnavailableException mue )
{
// Problem linking the two, let the user know
errorMessage( "Unable to link sequencer transmitter " +
"with receiver for MIDI device '" +
overrideMIDISynthesizer + "'" );
}
}
}
// No alternate MIDI synthesizer was specified, or unable to use it.
// If the squencer were also a synthesizer, that would make things easy:
if( sequencer instanceof Synthesizer )
{
synthesizer = (Synthesizer) sequencer;
}
else
{
// Try getting the default synthesizer first:
try
{
synthesizer = MidiSystem.getSynthesizer();
synthesizer.open();
}
catch( MidiUnavailableException mue )
{
message( "Unable to open the default synthesizer" );
synthesizer = null;
}
// See if we were sucessful:
if( synthesizer == null )
{
// Try for the common MIDI synthesizers:
synthDevice = openMidiDevice( "Java Sound Synthesizer" );
if( synthDevice == null )
synthDevice = openMidiDevice( "Microsoft GS Wavetable" );
if( synthDevice == null )
synthDevice = openMidiDevice( "Gervill" );
if( synthDevice == null )
{
// Still nothing, MIDI is not going to work
errorMessage( "Failed to find an available MIDI " +
"synthesizer" );
return;
}
}
// Are we using the default synthesizer or something else?
if( synthesizer == null )
{
// Link the sequencer and synthesizer:
try
{
sequencer.getTransmitter().setReceiver(
synthDevice.getReceiver() );
}
catch( MidiUnavailableException mue )
{
errorMessage( "Unable to link sequencer transmitter " +
"with MIDI device receiver" );
}
}
else
{
// Bug-fix for multiple-receivers playing simultaneously
if( synthesizer.getDefaultSoundbank() == null )
{
// Link the sequencer to the default receiver:
try
{
sequencer.getTransmitter().setReceiver(
MidiSystem.getReceiver() );
}
catch( MidiUnavailableException mue )
{
errorMessage( "Unable to link sequencer transmitter " +
"with default receiver" );
}
}
else
{
// Link the sequencer to the default synthesizer:
try
{
sequencer.getTransmitter().setReceiver(
synthesizer.getReceiver() );
}
catch( MidiUnavailableException mue )
{
errorMessage( "Unable to link sequencer transmitter " +
"with synthesizer receiver" );
}
}
// End bug-fix
}
}
}
/**
* Attempts to open the Sequencer with a name containing the specified string.
* @param containsString Part or all of a Sequencer's name.
* @return Handle to the Sequencer, or null if not found or error.
*/
private Sequencer openSequencer( String containsString )
{
Sequencer s = null;
s = (Sequencer) openMidiDevice( containsString );
if( s == null )
return null;
try
{
s.getTransmitter();
}
catch( MidiUnavailableException mue )
{
message( " Unable to get a transmitter from this sequencer" );
s = null;
return null;
}
return s;
}
/**
* Attempts to open the MIDI device with a name containing the specified
* string.
* @param containsString Part or all of a MIDI device's name.
* @return Handle to the MIDI device, or null if not found or error.
*/
private MidiDevice openMidiDevice( String containsString )
{
message( "Searching for MIDI device with name containing '" +
containsString + "'" );
MidiDevice device = null;
MidiDevice.Info[] midiDevices = MidiSystem.getMidiDeviceInfo();
for( int i = 0; i < midiDevices.length; i++ )
{
device = null;
try
{
device = MidiSystem.getMidiDevice( midiDevices[i] );
}
catch( MidiUnavailableException e )
{
message( " Problem in method 'getMidiDevice': " +
"MIDIUnavailableException was thrown" );
device = null;
}
if( device != null && midiDevices[i].getName().contains(
containsString ) )
{
message( " Found MIDI device named '" +
midiDevices[i].getName() + "'" );
if( device instanceof Synthesizer )
message( " *this is a Synthesizer instance" );
if( device instanceof Sequencer )
message( " *this is a Sequencer instance" );
try
{
device.open();
}
catch( MidiUnavailableException mue )
{
message( " Unable to open this MIDI device" );
device = null;
}
return device;
}
}
message( " MIDI device not found" );
return null;
}
/**
* Prints a message.
* @param message Message to print.
*/
protected void message( String message )
{
logger.message( message, 0 );
}
/**
* Prints an important message.
* @param message Message to print.
*/
protected void importantMessage( String message )
{
logger.importantMessage( message, 0 );
}
/**
* Prints the specified message if error is true.
* @param error True or False.
* @param message Message to print if error is true.
* @return True if error is true.
*/
protected boolean errorCheck( boolean error, String message )
{
return logger.errorCheck( error, "MidiChannel", message, 0 );
}
/**
* Prints an error message.
* @param message Message to print.
*/
protected void errorMessage( String message )
{
logger.errorMessage( "MidiChannel", message, 0 );
}
/**
* Prints an exception's error message followed by the stack trace.
* @param e Exception containing the information to print.
*/
protected void printStackTrace( Exception e )
{
logger.printStackTrace( e, 1 );
}
/**
* The FadeThread class handles sequence changing, timing, and volume change
* messages in the background.
*/
private class FadeThread extends SimpleThread
{
@Override
/**
* Runs in the background, timing fade in and fade out, changing the sequence,
* and issuing the appropriate volume change messages.
*/
public void run()
{
while( !dying() )
{
// if not currently fading in or out, put the thread to sleep
if( fadeOutGain == -1.0f && fadeInGain == 1.0f )
snooze( 3600000 );
checkFadeOut();
// only update every 50 miliseconds (no need to peg the cpu)
snooze( 50 );
}
// Important!
cleanup();
}
}
}