X-Git-Url: https://ruin.nu/git/?p=moosique.git;a=blobdiff_plain;f=Moosique.java;h=46efc7dc41e6acbadeba89067a09df0d566a3ec1;hp=32c4d375d7e43b0f7b502d0b6b25730f8b0e6771;hb=948e069926266ead58bc5466520e131941f2466c;hpb=4ac3b6210979ea78dceb609a0501cb0265d00065 diff --git a/Moosique.java b/Moosique.java index 32c4d37..46efc7d 100644 --- a/Moosique.java +++ b/Moosique.java @@ -1,8 +1,9 @@ import javax.sound.midi.*; -import javax.swing.*; import java.io.*; +import javax.swing.*; +import java.util.*; -/* +/** * Moosique - The MIDI Tracker * * Main class that handles initiation, IO and sound. @@ -12,22 +13,32 @@ import java.io.*; public class Moosique { - protected static MooGUI gui; - protected static Sequence seq; - - protected static Sequencer sequencer = null; - protected static Synthesizer synthesizer = null; - protected static MidiChannel[] channels; - protected static MidiChannel activeChannel; + private static MooGUI gui; + private static Sequence seq; + private static Sequencer sequencer; + private static Synthesizer synthesizer; + private static MidiChannel[] channels; + private static MidiChannel activeChannel; + private static MetaMessage tempoMsg, timeSigMsg; - protected static String filename; - protected static long position; + private static String filename, fileArg; + private static long editPosition; + private static boolean makeGUI = true, isEdited; + private static Thread player; + public static final int DEFAULT_RESOLUTION = 96, DEFAULT_TRACKS = 4; - /* + /** * Starts the application. */ public static void main (String[] args) { System.out.println("\nMoosique version 1.0\n"); + + // Parses command-line arguments. + for (int i = 0; i < args.length; i++) { + if (args[i].equals("-n")) {makeGUI = false;} + else if (fileArg == null) {fileArg = args[i];} + } + // Acquires MIDI devices and connects them. System.out.print("Initializing MIDI devices."); try { @@ -42,51 +53,90 @@ public class Moosique { setActiveChannel(0); } catch (MidiUnavailableException e) { System.out.println("Failed, quitting."); - quit(); +// System.exit(1); } System.out.println("Done"); //If a filename is given as the command-line argument, attempts to load a sequence from the file. - System.out.print("Loading MIDI sequence..."); - if (args.length == 1) { - if (!load(args[0])) clearSequence(); + if (fileArg != null) { + System.out.print("Loading MIDI sequence from " + fileArg + "..."); + if (!load(fileArg)) { + System.out.println("Failed"); + clearSequence(); + } else { + System.out.println("Done"); + } } else { // Otherwise creates a new empty one. clearSequence(); } - System.out.println("Done"); - // Sets up channels and GUI. - System.out.print("Creating GUI..."); - gui = new MooGUI(seq); - System.out.println("Done"); + // Builds GUI, unless n-flag is set. + if (makeGUI) { + System.out.print("Building GUI..."); + try { + UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName()); + } catch (Exception e) {} + gui = new MooGUI(seq); + System.out.println("Done"); + } else { + System.out.print("Playing..."); + play(); + while (sequencer.isRunning()) {} + System.out.println("Done"); + quit(); + } + } + + /** + * Returns the GUI. + * @return the GUI + */ + public static MooGUI getGUI() { + return gui; } - /* - * Returns a pointer to the current sequence. + /** + * Returns the current sequence. * @return the current sequence */ public static Sequence getSequence() { return seq; } - /* - * Returns a pointer to the MidiChannels of the selected synthesizer. + /** + * Returns the current sequencer. + * @return the current sequencer + */ + public static Sequencer getSequencer() { + return sequencer; + } + + /** + * Returns the MidiChannels of the selected synthesizer. * @return the available MidiChannels */ public static MidiChannel[] getChannels() { return channels; } - /* - * Returns a pointer to the currently active MidiChannel. + /** + * Returns the MidiChannels of the selected synthesizer. + * @return the available MidiChannels + */ + public static MidiChannel getChannel(int i) { + return channels[i]; + } + + /** + * Returns the currently active MidiChannel. * @return the active MidiChannel */ public static MidiChannel getActiveChannel() { return activeChannel; } - /* + /** * Sets the currently active MidiChannel. * @param channel the number of the MidiChannel to activate */ @@ -94,85 +144,163 @@ public class Moosique { activeChannel = channels[channel]; } - /* + /** * Replaces the current sequence with a new one, holding three empty tracks. */ public static void clearSequence() { - // Creates sequence. + // Creates a new sequence and sends it to the sequencer. try { - seq = new Sequence(Sequence.PPQ, 96, 3); + seq = new Sequence(Sequence.PPQ, DEFAULT_RESOLUTION, DEFAULT_TRACKS); + sequencer.setSequence(seq); } catch (InvalidMidiDataException e) {} // Sends sequence to GUI. if (gui != null) gui.setSequence(seq); - } - /* + /** * Starts playback of the current sequence. */ public static void play() { - try { - sequencer.setSequence(seq); - sequencer.setTickPosition(position); - } catch (InvalidMidiDataException e) {} - sequencer.start(); + sequencer.setTickPosition(editPosition); + resume(); } - /* + /** * Pauses playback of the current sequence. */ public static void pause() { - sequencer.stop(); + if (sequencer.isRunning()) { + sequencer.stop(); + } + if (player != null) player.interrupt(); } - /* + /** * Resumes playback of the current sequence. */ public static void resume() { + gui.update(0); sequencer.start(); + + // Disables input to volatile components + // gui.disable(); + + // Creates the visualization thread and starts it. + player = new Thread () { + public void run() { + while(sequencer.isRunning()) { + // Updates the GUI with the current tick position. + gui.update(sequencer.getTickPosition()); + + // Puts the thread to sleep for as long as it takes + // the sequencer to reach the next sixteenth. + try { + sleep((long)((1000 * 60 * 1) / (getTempo() * 4))); + } catch (InterruptedException e) { + Moosique.stop(); + } + } + Moosique.stop(); + } + }; + player.start(); } - /* + /** * Stops playback of the current sequence. */ public static void stop() { - sequencer.stop(); - sequencer.setTickPosition(position); + if (sequencer.isRunning()) { + sequencer.stop(); + } + sequencer.setTickPosition(editPosition); + if (player != null) player.interrupt(); + gui.update((long)0); } - /* - * Rewinds the current sequence the given number of measures. - * @param measures the number of measures to rewind + /** + * Returns the current editing position of the sequencer. + * @return the tick position */ public static long getPosition() { - return position; + return editPosition; } - /* - * Rewinds the current sequence the given number of measures. - * @param measures the number of measures to rewind + /** + * Sets the current editing position of the sequencer. + * @param ticks the tick position */ public static void setPosition(long ticks) { - position = ticks; + editPosition = ticks; + } + + /** + * Returns the tempo of the current sequence. + * @return the tick position + */ + public static int getTempo() { + return 120; + // if (tempoMsg == null) return 0; + } + + /** + * Sets the current editing position of the sequencer. + * @param ticks the tick position + */ + public static void setTempo(int bpm) { + // tempoMsg + } + + /** + * Returns the tempo of the current sequence. + * @return the tick position + */ + public static int[] getTimeSig() { + int[] ts = {4, 4}; + return ts; + // if (timeSigMsg == null) return 0; } - /* + /** + * Sets the current editing position of the sequencer. + * @param ticks the tick position + */ + public static void setTimeSig(int bpm) { + // timeSigMsg + } + + /** + * Returns true if the current sequence has been edited. + * @return the tick position + */ + public static boolean isEdited() { + return isEdited; + } + + /** + * Sets the current sequence as edited, which implies prompts when loading a new sequence. + */ + public static void setEdited() { + isEdited = true; + } + + /** * Rewinds the current sequence the given number of measures. * @param measures the number of measures to rewind */ public static void rewind(long ticks) { - position -= ticks; + editPosition -= ticks; } - /* + /** * Fast forwards the current sequence the given number of measures. * @param measures the number of measures to fast forward */ public static void forward(long ticks) { - position += ticks; + editPosition += ticks; } - /* + /** * Loads the MooSequence in the given file. * @param filename the filename to use */ @@ -184,74 +312,100 @@ public class Moosique { } catch (InvalidMidiDataException e) { return false; } catch (IOException e) { - JOptionPane.showMessageDialog(null, "File", "alert", JOptionPane.ERROR_MESSAGE); return false; } + isEdited = false; - // Sends sequence to GUI - if (gui != null) gui.setSequence(seq); + Track[] tracks = seq.getTracks(); + + // Stores tempo and time signature. + MidiMessage msg; + MetaMessage metaMsg; + for (int i = 0; i < tracks[0].size(); i++) { + msg = tracks[0].get(i).getMessage(); + if (msg.getStatus() == MetaMessage.META) { + metaMsg = (MetaMessage)msg; + if (metaMsg.getType() == 81) { + tempoMsg = metaMsg; + } else if (metaMsg.getType() == 88) { + timeSigMsg = (MetaMessage)msg; + } + + } + } // Searches the sequence for NoteOn events - Track[] tracks = seq.getTracks(); MidiEvent noteOn, noteOff = null, nextEvent; MidiMessage nextMsg; ShortMessage shortMsg; + ArrayList noteOns, noteOffs; for (int i = 0; i < tracks.length; i++) { + noteOns = new ArrayList(tracks.length); + /* + Collections.sort(track[i].events, new Comparator() { + public int compare(Object o1, Object o2) { + return ((MidiEvent)o2).getTick() - ((MidiEvent)o1).getTick(); + } + }); + */ for (int j = 0; j < tracks[i].size(); j++) { noteOn = tracks[i].get(j); - if (noteOn.getMessage() instanceof ShortMessage) { - if (((ShortMessage)noteOn.getMessage()).getCommand() == ShortMessage.NOTE_ON) { - // Finds the corresponding NoteOff event - for (int k = j + 1; k < tracks[i].size(); k++) { - nextEvent = tracks[i].get(k); - nextMsg = nextEvent.getMessage(); - if (nextMsg instanceof ShortMessage) { - shortMsg = (ShortMessage) nextMsg; - if (shortMsg.getCommand() == ShortMessage.NOTE_OFF && shortMsg.getChannel() == ((ShortMessage)noteOn.getMessage()).getChannel() && shortMsg.getData1() == ((ShortMessage)noteOn.getMessage()).getData1()) { - noteOff = nextEvent; - break; - } + if (noteOn.getMessage().getStatus() == ShortMessage.NOTE_ON) { + // Finds the corresponding NoteOff event + for (int k = j + 1; k < tracks[i].size(); k++) { + nextEvent = tracks[i].get(k); + nextMsg = nextEvent.getMessage(); + if (nextMsg instanceof ShortMessage) { + shortMsg = (ShortMessage) nextMsg; + if (shortMsg.getCommand() == ShortMessage.NOTE_OFF && shortMsg.getChannel() == ((ShortMessage)noteOn.getMessage()).getChannel() && shortMsg.getData1() == ((ShortMessage)noteOn.getMessage()).getData1()) { + noteOff = nextEvent; + break; } - } - // Replaces the NoteOn event with a MooNote, if possible with the corresponding NoteOff event - tracks[i].remove(noteOn); - if (noteOff != null) { - tracks[i].add(new MooNote(noteOn, noteOff)); - } else { - tracks[i].add(new MooNote(noteOn)); } } + // Replaces the NoteOn event with a MooNote, if possible with the corresponding NoteOff event + tracks[i].remove(noteOn); + if (noteOff != null) { + tracks[i].add(new MooNote(noteOn, noteOff)); + } else { + tracks[i].add(new MooNote(noteOn)); + } } } } + // Sends sequence to GUI and sequencer, then returns + if (gui != null) gui.setSequence(seq); + try { + sequencer.setSequence(seq); + } catch (InvalidMidiDataException e) {} return true; } - /* + /** * Saves the current sequence to the given filename - * @param filename the filename to use + * @param file the filename to use */ - public static void saveAs(String filename) throws IOException { - MidiSystem.write(seq, 1, new File(filename)); - + public static void saveAs(String file) { + try { + MidiSystem.write(seq, 1, new File(filename)); + } catch (IOException e) {} + filename = file; + gui.setStatus("Saved " + file); } - /* + /** * Saves the current sequence to the previously given filename. */ - public static void save() throws IOException { + public static void save() { saveAs(filename); } - /* + /** * Releases all reserved devices and exits the program. */ public static void quit() { - if (sequencer.isOpen()) { - try { - sequencer.open(); - } catch (MidiUnavailableException e) {} - } + if (sequencer.isOpen()) sequencer.close(); + if (synthesizer.isOpen()) synthesizer.close(); System.exit(0); } -} \ No newline at end of file +}