My Midiplayer isn't looping

[John Quach]

I can only figure it has something to do with the methods I'm using. The music would play, then when it reaches the end of the track, the looping method picks that up.

But for some reason, it executes both the if and else blocks.

In other words, the music plays, then when its supposed to loop again, it stops and terminates.


Here are the codes. This is the client class where the looping fails.

import javax.sound.midi.*;

import com.brackeen.javagamebook.sound.MidiPlayer;

/**
    An example that plays a Midi sequence. First, the sequence
    is played once with track 1 turned off. Then the sequence is
    played once with track 1 turned on. Track 1 is the drum track
    in the example midi file.
*/
public class MidiTest implements MetaEventListener
{

    // The drum track in the example Midi file
    private static final int DRUM_TRACK = 1;

    public static void main(String[] args) 
    {
        new MidiTest().run();
    }

    private MidiPlayer player;

    public void run()
    {

        player = new MidiPlayer();

        // load a sequence
        Sequence sequence =
            player.getSequence("sounds/music.midi");

        // play the sequence
        player.play(sequence, true);

        // turn off the drums
        System.out.println("Playing (without drums)...");
        Sequencer sequencer = player.getSequencer();
        sequencer.setTrackMute(DRUM_TRACK, true);
        sequencer.addMetaEventListener(this);
    }


    /**
        This method is called by the sound system when a meta
        event occurs. In this case, when the end-of-track meta
        event is received, the drum track is turned on.
    */
    public void meta(MetaMessage event) 
    {
        if (event.getType() == MidiPlayer.END_OF_TRACK_MESSAGE)
        {
            Sequencer sequencer = player.getSequencer();
            if (sequencer.getTrackMute(DRUM_TRACK))
            {
                // turn on the drum track
                System.out.println("Turning on drums...");  // this statement runs
                sequencer.setTrackMute(DRUM_TRACK, false); //this statement sets boolean to false
                
                //for some reason, the music doesn't loop.  Its as if it stops playing
            }
            else 
            {
                // close the sequencer and exit
                System.out.println("Exiting...");
                player.close();
                System.exit(0);
            }
        }
    }

}

And this is the utility class.

package com.brackeen.javagamebook.sound;

import java.io.*;
import javax.sound.midi.*;

public class MidiPlayer implements MetaEventListener {

    // Midi meta event
    public static final int END_OF_TRACK_MESSAGE = 47;

    private Sequencer sequencer;
    private boolean loop;
    private boolean paused;

    /**
        Creates a new MidiPlayer object.
    */
    public MidiPlayer() {
        try {
            sequencer = MidiSystem.getSequencer();
            sequencer.open();
            sequencer.addMetaEventListener(this);
        }
        catch ( MidiUnavailableException ex) {
            sequencer = null;
        }
    }


    /**
        Loads a sequence from the file system. Returns null if
        an error occurs.
    */
    public Sequence getSequence(String filename) {
        try {
            return getSequence(new FileInputStream(filename));
        }
        catch (IOException ex) {
            ex.printStackTrace();
            return null;
        }
    }


    /**
        Loads a sequence from an input stream. Returns null if
        an error occurs.
    */
    public Sequence getSequence(InputStream is) {
        try {
            if (!is.markSupported()) {
                is = new BufferedInputStream(is);
            }
            Sequence s = MidiSystem.getSequence(is);
            is.close();
            return s;
        }
        catch (InvalidMidiDataException ex) {
            ex.printStackTrace();
            return null;
        }
        catch (IOException ex) {
            ex.printStackTrace();
            return null;
        }
    }


    /**
        Plays a sequence, optionally looping. This method returns
        immediately. The sequence is not played if it is invalid.
    */
    public void play(Sequence sequence, boolean loop) {
        if (sequencer != null && sequence != null && sequencer.isOpen()) {
            try {
                sequencer.setSequence(sequence);
                sequencer.start();
                this.loop = loop;
            }
            catch (InvalidMidiDataException ex) {
                ex.printStackTrace();
            }
        }
    }


    /**
        This method is called by the sound system when a meta
        event occurs. In this case, when the end-of-track meta
        event is received, the sequence is restarted if
        looping is on.
    */
    public void meta(MetaMessage event) {
        if (event.getType() == END_OF_TRACK_MESSAGE) {
            if (sequencer != null && sequencer.isOpen() && loop) {
                sequencer.start();
            }
        }
    }


    /**
        Stops the sequencer and resets its position to 0.
    */
    public void stop() {
         if (sequencer != null && sequencer.isOpen()) {
             sequencer.stop();
             sequencer.setMicrosecondPosition(0);
         }
    }


    /**
        Closes the sequencer.
    */
    public void close() {
         if (sequencer != null && sequencer.isOpen()) {
             sequencer.close();
         }
    }


    /**
        Gets the sequencer.
    */
    public Sequencer getSequencer() {
        return sequencer;
    }


    /**
        Sets the paused state. Music may not immediately pause.
    */
    public void setPaused(boolean paused) {
        if (this.paused != paused && sequencer != null && sequencer.isOpen()) {
            this.paused = paused;
            if (paused) {
                sequencer.stop();
            }
            else {
                sequencer.start();
            }
        }
    }


    /**
        Returns the paused state.
    */
    public boolean isPaused() {
        return paused;
    }

}

[Steve Luke]

In the utility class where you control the looping, you simply call sequence.start(). The start method API says this:

Starts playback of the MIDI data in the currently loaded sequence. Playback will begin from the current position. 

Since the playback has just completed, the current position would be at the end of your MIDI sequence. You need to re-set the sequence. I think the best way to do that is to use:

setTickPosition(0);

But I wonder why you don't use the MIDI Sequencer's inbuilt looping?

    public void play(Sequence sequence, boolean loop) {
        if (sequencer != null && sequence != null && sequencer.isOpen()) {
            try {
                sequencer.setSequence(sequence);
                if(loop) {
                    sequencer.setLoopStartPoint(0);
                    sequencer.setLoopEndPoint(-1);
                    sequencer.setLoopCount(Sequencer.LOOP_CONTINUOUSLY);
                }
                sequencer.start();
                this.loop = loop;
            }
            catch (InvalidMidiDataException ex) {
                ex.printStackTrace();
            }
        }
    }