X-Git-Url: https://ruin.nu/git/?p=moosique.git;a=blobdiff_plain;f=Moosique.java;h=160380d5bb88be74d642efcc222d9d4cad88b411;hp=e2b7f3e490821832347b01fae8c9289f9eff228a;hb=HEAD;hpb=1d2d2bfd14ba0addab97692527d4414d3a87e13d diff --git a/Moosique.java b/Moosique.java index e2b7f3e..160380d 100644 --- a/Moosique.java +++ b/Moosique.java @@ -13,6 +13,7 @@ import java.util.*; public class Moosique { + // GUI and MIDI device variables private static MooGUI gui; private static Sequence seq; private static Sequencer sequencer; @@ -21,16 +22,29 @@ public class Moosique { private static MidiChannel[] channels; private static MidiChannel activeChannel; + // Recording variables + private static Track recordTrack = null; + private static MooTrackView recordTrackView = null; + private static boolean[] quantizers = {false, false, false}; + private static int quantizeResolution; + + // Collections private static ArrayList copyBuffer, emptyTracks, timeSignatures, tempoChanges; + private static TreeSet selection; private static Map trackMute = new HashMap(); private static Map trackSolo = new HashMap(); - private static Thread player; + // Various... private static File file = null; private static long editPosition; + private static Thread player; + + // Preferences private static boolean makeGUI = true, initSound = true, edited = false, drawEmptyTracks = false; + + // Constants public static final int DEFAULT_RESOLUTION = 96, DEFAULT_TRACKS = 4; - public static final int WHOLE_NOTE = 0, HALF_NOTE = 1, QUARTER_NOTE = 2, EIGHTH_NOTE = 3, SIXTEENTH_NOTE = 4; + public static final int WHOLE_NOTE = 16, HALF_NOTE = 8, QUARTER_NOTE = 4, EIGHTH_NOTE = 2, SIXTEENTH_NOTE = 1; /** * Starts the application. @@ -39,7 +53,7 @@ public class Moosique { * loads a sequence and creates the GUI. */ public static void main (String[] args) { - out("\nMoosique version 1.0\n"); + out("\nMoosique version 1.0\n", true); // Parses command-line arguments. String fileArg = null; @@ -49,41 +63,43 @@ public class Moosique { } // Acquires MIDI devices and connects them. - System.out.print("Initializing MIDI devices."); + out("Initializing MIDI devices.", false); try { - // Configures sequencer + // Configures sequencer. sequencer = MidiSystem.getSequencer(); - System.out.print("."); + advanceStatus(); sequencer.open(); sequencer.addMetaEventListener(new SongEndListener()); - // Configures synthesizer + // Configures synthesizer. synthesizer = MidiSystem.getSynthesizer(); - System.out.print("."); + advanceStatus(); synthesizer.open(); - // Configures receiver, transmitter and channels. + // Connects devices. receiver = synthesizer.getReceiver(); sequencer.getTransmitter().setReceiver(receiver); + + // Configures channels. channels = synthesizer.getChannels(); setActiveChannel(0); } catch (MidiUnavailableException e) { - out("Failed, quitting."); + out("Failed, quitting.", true); System.exit(1); } - out("Done"); + out("Done", true); // Loads user preferences (work directory, last opened files etc). loadPreferences(); //If a filename is given as the command-line argument, attempts to load a sequence from the file. if (fileArg != null) { - System.out.print("Loading MIDI sequence from " + fileArg + "..."); + out("Loading MIDI sequence from " + fileArg + "...", false); if (!load(new File(fileArg))) { - out("Failed, creating new sequence"); + out("Failed, creating new sequence", true); clearSequence(); } else { - out("Done"); + out("Done", true); } } else { // Otherwise creates a new empty one. @@ -92,17 +108,17 @@ public class Moosique { // Builds GUI, unless n-flag is set. if (makeGUI) { - System.out.print("Building GUI."); + out("Building GUI.", false); try { UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName()); } catch (Exception e) {} gui = new MooGUI(seq, file); - out("Done"); + out("Done", true); } else { - System.out.print("Playing..."); + out("Playing...", false); play(); while (sequencer.isRunning()) {} - out("Done"); + out("Done", true); quit(); } } @@ -165,22 +181,6 @@ public class Moosique { return gui; } - /** - * Calculates the position (measures, beats, ticks) in the current sequence for the given tick position. - * @return an array of integers where index 0 is measures, 1 is beats and 2 is ticks. - */ - public static int[] getPositionForTicks(long ticks) { - /* - int measures, beats, ticks; - for (int i = 0; i < timeSignatures.length; i++) { - long tick = timeSignatures[i].getTick(); - // Split the ticks in the interval into measures, beats and ticks. - } - */ - int[] pos = {1, 1, 1}; - return pos; - } - /** * Returns the receiver of the current sequencer. * @return the receiver @@ -205,58 +205,6 @@ public class Moosique { return sequencer; } - /** - * Returns the tempo in the given tick position. - * @param tick the tick position for which to return the tempo - * @return the tempo at the specified tick position - */ - public static int getTempo(long tick) { - if (tempoChanges.size() == 0) return 120; - MidiEvent tempoEvent = (MidiEvent)tempoChanges.get(0); - if (tempoChanges.size() > 1) { - for (int i = 1; i < tempoChanges.size(); i++) { - MidiEvent nextTempoEvent = (MidiEvent)tempoChanges.get(i); - if (nextTempoEvent.getTick() < tick && nextTempoEvent.getTick() > tempoEvent.getTick()) - tempoEvent = nextTempoEvent; - } - } - return decodeTempo(((MetaMessage)tempoEvent.getMessage()).getData()); - } - - /** - * Calculates the tick position in the current sequence for the given position (measures, beats, ticks). - * @return the tick position. - */ - public static long getTicksForPosition(int measures, int beats, int ticks) { - long tickPos = 0; - /* - for (int i = 0; i < timeSignatures.length; i++) { - long tick = timeSignatures[i].getTick(); - // Add the measures, beats and ticks in the interval. - } - */ - return tickPos; - } - - /** - * Returns the time signature in the given tick position. - * @param tick the tick position for which to return the time signature - * @return an array of two integers where [0] is the numerator and [1] the denominator - */ - public static int[] getTimeSig(long tick) { - int[] ts = {4, 4}; - if (timeSignatures.size() == 0) return ts; - MidiEvent timeSigEvent = (MidiEvent)timeSignatures.get(0); - if (timeSignatures.size() > 1) { - for (int i = 1; i < timeSignatures.size(); i++) { - MidiEvent nextTimeSigEvent = (MidiEvent)timeSignatures.get(i); - if (nextTimeSigEvent.getTick() < tick && nextTimeSigEvent.getTick() > timeSigEvent.getTick()) - timeSigEvent = nextTimeSigEvent; - } - } - return decodeTimeSig(((MetaMessage)timeSigEvent.getMessage()).getData()); - } - /** * Returns true if the current sequence has been edited. * @return the tick position @@ -347,22 +295,6 @@ public class Moosique { editPosition = ticks; } - /** - * Sets the current editing position of the sequencer. - * @param ticks the tick position - */ - public static void setTempo(int bpm) { - // tempoMsg - } - - /** - * Sets the current editing position of the sequencer. - * @param ticks the tick position - */ - public static void setTimeSig(int bpm) { - // timeSigMsg - } - /** * Sets the solo setting of the given track. * @param on true for solo, false for not @@ -397,7 +329,7 @@ public class Moosique { /* *** - ** ENCODING / DECODING METHODS ** + ** SELECTION METHODS ** *** */ @@ -408,54 +340,50 @@ public class Moosique { /** - * Returns the byte array for the given tempo. - * @param tempo the tempo in beats per minute - * @return an array of bytes representing the given tempo + * Returns the current selection. + * @return the current selection */ - public static byte[] encodeTempo(int tempo) { - int microSecsPerQuarter = 60000000 / tempo; - byte[] b = new byte[3]; - b[0] = (byte)(microSecsPerQuarter / 65536); - b[1] = (byte)((microSecsPerQuarter - (b[0] * 65536)) / 256); - b[2] = (byte)(microSecsPerQuarter - (b[0] * 65536) - (b[1] * 256)); - return b; + public static TreeSet getSelection() { + return selection; } - /** - * Returns the tempo for the given byte array. - * @param an array of three bytes representing the tempo - * @return the tempo in beats per minute + /** + * Selects the given note + * @param the note to select */ - public static int decodeTempo(byte[] bytes) { - return 60000000 / (bytes[0] * 65536 + bytes[1] * 256 + bytes[2]); // bytes[0] & 0xFF ??? + public static void selectNote(MooNoteElement elem) { + selection.add(elem); } - /** - * Returns the byte array for the given time signature. - * @param numerator the numerator of the time signature - * @param denominator the denominator of the time signature - * @return an array of bytes representing the given time signature + /** + * Deselects the given note + * @param the note to deselect */ - public static byte[] encodeTimeSig(int numerator, int denominator) { - byte[] b = { - (byte)numerator, - (byte)(Math.log(denominator) / Math.log(2)), - (byte)96, - (byte)8 - }; - return b; + public static void deselectNote(MooNoteElement elem) { + selection.remove(elem); } - /** - * Returns the time signature for the given byte array. - * @param an array of four bytes representing the time signature - * @return an array of two integers where [0] is the numerator and [1] the denominator + + /** + * Deselects all notes. */ - public static int[] decodeTimeSig(byte[] bytes) { - int[] t = { - (int)bytes[0], - (int)(1 << bytes[1]) - }; - return t; + public static void deselectAllNotes() { + Iterator it = selection.iterator(); + while(it.hasNext()) { + ((MooNoteElement)it.next()).deselect(); + } + selection.clear(); + } + + /** + * Determines if the given MooNoteElement is the only one in the track view that is selected. + * @return if the given element is the only selected one + */ + public static boolean isTheOnlySelected(MooNoteElement elem) { + Iterator it = selection.iterator(); + while(it.hasNext()) { + if (!it.next().equals(elem)) return false; + } + return true; } @@ -524,7 +452,7 @@ public class Moosique { if (sequencer.isRunning()) { sequencer.stop(); } - if (player != null) player.interrupt(); + player = null; } /** @@ -535,8 +463,291 @@ public class Moosique { sequencer.stop(); } sequencer.setTickPosition(editPosition); - if (player != null) player.interrupt(); + player = null; gui.update((long)0); + + if (recordTrack != null && recordTrackView != null) { + recordTrackView.disableKeyboardRecording(); + sequencer.stopRecording(); + sequencer.recordDisable(recordTrack); + if (quantizers[0]) recordTrackView.placeNewNotes(quantize( + convertTrack(recordTrack), quantizeResolution, quantizers[1], quantizers[2])); + else recordTrackView.placeNewNotes(Moosique.convertTrack(recordTrack)); + } + } + + /** + * Enables recording to the given track. + * @param track the track in which to store the recorded data + * @param tempo the channel from which to record data + * @param quantizers an array of booleans where 0 = quantize?, 1 = location, 2 = duration + * @param resolution the note size to round each note to + * @return if the recording was initialised successfully + */ + public static boolean record(Track track, int channel, boolean[] quants, int resolution) { + try { + sequencer.recordEnable(track, channel); + sequencer.startRecording(); + } catch(Exception e) { + e.printStackTrace(); + return false; + } + quantizers = quants; + quantizeResolution = resolution; + recordTrack = track; + recordTrackView = gui.getView().getTrackView(track); + recordTrackView.enableKeyboardRecording(); + Moosique.setEdited(); + return true; + } + + + + + + + + + /* *** + ** TEMPO & TIME SIGNATURE METHODS ** + *** */ + + + + + + + + + /** + * Returns the byte array for the given tempo. + * @param tempo the tempo in beats per minute + * @return an array of bytes representing the given tempo + */ + public static byte[] encodeTempo(int tempo) { + int microSecsPerQuarter = 60000000 / tempo; + byte[] b = new byte[3]; + b[0] = (byte)(microSecsPerQuarter / 65536); + b[1] = (byte)((microSecsPerQuarter - (b[0] * 65536)) / 256); + b[2] = (byte)(microSecsPerQuarter - (b[0] * 65536) - (b[1] * 256)); + return b; + } + + /** + * Returns the tempo for the given byte array. + * @param an array of three bytes representing the tempo + * @return the tempo in beats per minute + */ + public static int decodeTempo(byte[] bytes) { + return 60000000 / (bytes[0] * 65536 + bytes[1] * 256 + bytes[2]); + } + + /** + * Returns the tempo in the given tick position. + * @param tick the tick position for which to return the tempo + * @return the tempo at the specified tick position + */ + public static int getTempo(long tick) { + if (tempoChanges.size() == 0) return 120; + MidiEvent tempoEvent = (MidiEvent)tempoChanges.get(0); + if (tempoChanges.size() > 1) { + for (int i = 1; i < tempoChanges.size(); i++) { + MidiEvent nextTempoEvent = (MidiEvent)tempoChanges.get(i); + if (nextTempoEvent.getTick() < tick && nextTempoEvent.getTick() > tempoEvent.getTick()) + tempoEvent = nextTempoEvent; + } + } + return decodeTempo(((MetaMessage)tempoEvent.getMessage()).getData()); + } + + /** + * Sets the tempo at the given tick position. + * @param ticks the tick position + */ + public static void setTempo(long tick, int bpm) { + // Checks for a tempo event at the given tick position. + MidiEvent tempoEvent = null; + Iterator it = tempoChanges.iterator(); + while(it.hasNext()) { + MidiEvent nextTempoEvent = (MidiEvent)it.next(); + if (nextTempoEvent.getTick() == tick) { + tempoEvent = nextTempoEvent; + break; + } + } + + // If none was found, creates and adds a new one. + if (tempoEvent == null) { + tempoEvent = new MidiEvent(new MetaMessage(), tick); + (seq.getTracks())[0].add(tempoEvent); + tempoChanges.add(tempoEvent); + Collections.sort(tempoChanges, new MidiEventComparator()); + } + + // Sets the tempo of the event (found or created). + try { + ((MetaMessage)tempoEvent.getMessage()).setMessage(81, encodeTempo(bpm), 3); + } catch (InvalidMidiDataException e) {} + } + + /** + * Returns the byte array for the given time signature. + * @param numerator the numerator of the time signature + * @param denominator the denominator of the time signature + * @return an array of bytes representing the given time signature + */ + public static byte[] encodeTimeSig(int numerator, int denominator) { + byte[] b = { + (byte)numerator, + (byte)(Math.log(denominator) / Math.log(2)), // logarithm of denominator in base 2 + (byte)96, + (byte)8 + }; + return b; + } + /** + * Returns the time signature for the given byte array. + * @param an array of four bytes representing the time signature + * @return an array of two integers where [0] is the numerator and [1] the denominator + */ + public static int[] decodeTimeSig(byte[] bytes) { + int[] t = { + (int)bytes[0], + (int)(1 << bytes[1]) + }; + return t; + } + + /** + * Returns the time signature in the given tick position. + * @param tick the tick position for which to return the time signature + * @return an array of two integers where [0] is the numerator and [1] the denominator + */ + public static int[] getTimeSig(long tick) { + int[] ts = {4, 4}; + if (timeSignatures.size() == 0) return ts; + MidiEvent timeSigEvent = (MidiEvent)timeSignatures.get(0); + if (timeSignatures.size() > 1) { + for (int i = 1; i < timeSignatures.size(); i++) { + MidiEvent nextTimeSigEvent = (MidiEvent)timeSignatures.get(i); + if (nextTimeSigEvent.getTick() <= tick && nextTimeSigEvent.getTick() > timeSigEvent.getTick()) + timeSigEvent = nextTimeSigEvent; + } + } + return decodeTimeSig(((MetaMessage)timeSigEvent.getMessage()).getData()); + } + + /** + * Sets the time signature at the given tick position. + * @param ticks the tick position + */ + public static void setTimeSig(long tick, int numerator, int denominator) { + // Checks for a time signature event at the given tick position. + MidiEvent timeSigEvent = null; + Iterator it = timeSignatures.iterator(); + while(it.hasNext()) { + MidiEvent nextTimeSigEvent = (MidiEvent)it.next(); + if (nextTimeSigEvent.getTick() == tick) { + timeSigEvent = nextTimeSigEvent; + break; + } + } + + // If none was found, creates and adds a new one. + if (timeSigEvent == null) { + timeSigEvent = new MidiEvent(new MetaMessage(), tick); + (seq.getTracks())[0].add(timeSigEvent); + timeSignatures.add(timeSigEvent); + Collections.sort(timeSignatures, new MidiEventComparator()); + } + + // Sets the time signature of the event (found or created). + try { + ((MetaMessage)timeSigEvent.getMessage()).setMessage(88, encodeTimeSig(numerator, denominator), 4); + } catch (InvalidMidiDataException e) {} + } + + /** + * Calculates the position (measures, beats, ticks) in the current sequence for the given tick position. + * @param tickPosition the tick position for which to calculate the position + * @return an array of integers where index 0 is measures, 1 is beats and 2 is ticks. + */ + public static int[] getPositionForTicks(long tickPosition) { + int ticksPerBeat = seq.getResolution(); + long measures = 0, beats = 0, ticks = 0; + + // Counts for each time signature change up to the last one before the given tick position. + Iterator it = timeSignatures.iterator(); + MidiEvent lastTSEvent = (MidiEvent)it.next(); + while(it.hasNext()) { + MidiEvent nextTSEvent = (MidiEvent)it.next(); + if (nextTSEvent.getTick() > tickPosition) break; + long tickDiff = nextTSEvent.getTick() - lastTSEvent.getTick(); + int[] ts = decodeTimeSig(((MetaMessage)lastTSEvent.getMessage()).getData()); + int beatsPerMeasure = ts[0] * (4 / ts[1]); + long thisTSMeasures = tickDiff / (beatsPerMeasure * ticksPerBeat); + measures += thisTSMeasures; + long thisTSBeats = (tickDiff - thisTSMeasures * beatsPerMeasure * ticksPerBeat) / ticksPerBeat; + beats += thisTSBeats; + ticks += tickDiff - thisTSMeasures * beatsPerMeasure * ticksPerBeat - thisTSBeats * ticksPerBeat; + lastTSEvent = nextTSEvent; + } + + // Counts from the given tick position to the last time signature change before it. + long tickDiff = tickPosition - lastTSEvent.getTick(); + int[] ts = decodeTimeSig(((MetaMessage)lastTSEvent.getMessage()).getData()); + int beatsPerMeasure = ts[0] * (4 / ts[1]); + long thisTSMeasures = tickDiff / (beatsPerMeasure * ticksPerBeat); + measures += thisTSMeasures; + long thisTSBeats = (tickDiff - thisTSMeasures * beatsPerMeasure * ticksPerBeat) / ticksPerBeat; + beats += thisTSBeats; + ticks += tickDiff - thisTSMeasures * beatsPerMeasure * ticksPerBeat - thisTSBeats * ticksPerBeat; + + // Corrects any overflows. + if (ticks > ticksPerBeat) { + beats += Math.floor(ticks / ticksPerBeat); + ticks = ticks % ticksPerBeat; + } + if (beats > beatsPerMeasure) { + measures += Math.floor(beats / beatsPerMeasure); + beats = beats % beatsPerMeasure; + } + + // Returns the calculated values. + int[] pos = {(int)measures, (int)beats, (int)ticks}; + return pos; + } + + /** + * Calculates the tick position in the current sequence for the given position (measures, beats, ticks). + * @param measures the measure of the current position + * @param beats the beat of the current position + * @param tick the tick of the current position + * @return the tick position. + */ + public static long getTicksForPosition(int measures, int beats, int ticks) { + int res = seq.getResolution(); + int[] lastTSPos = new int[3]; + long tickPosition = 0; + + // Counts for each time signature change up to the last one before the given tick position. + Iterator it = timeSignatures.iterator(); + MidiEvent lastTSEvent = (MidiEvent)it.next(); + while(it.hasNext()) { + MidiEvent nextTSEvent = (MidiEvent)it.next(); + int[] nextTSPos = getPositionForTicks(nextTSEvent.getTick()); + if (nextTSPos[0] >= measures) break; + lastTSPos = nextTSPos; + lastTSEvent = nextTSEvent; + } + + // Counts from the given tick position to the last time signature change before it. + int measdiff = measures - lastTSPos[0]; + int[] ts = decodeTimeSig(((MetaMessage)lastTSEvent.getMessage()).getData()); + int beatsPerMeasure = ts[0] * (4 / ts[1]); + tickPosition = lastTSEvent.getTick() + (beatsPerMeasure * measures + beats) * res + ticks; + + return tickPosition; } @@ -561,38 +772,27 @@ public class Moosique { * Replaces the current sequence with a new one, holding three empty tracks. */ public static void clearSequence() { + // Reinitializes sequence variables + file = null; + reinitializeLists(); + try { // Creates a new sequence. seq = new Sequence(Sequence.PPQ, DEFAULT_RESOLUTION, DEFAULT_TRACKS); Track[] tracks = seq.getTracks(); - // Creates messages for default tempo (120) and time signature (4/4). - MetaMessage timeSigMsg = new MetaMessage(); - MetaMessage tempoMsg = new MetaMessage(); - try { - timeSigMsg.setMessage(88, encodeTimeSig(4, 4), 4); - tempoMsg.setMessage(81, encodeTempo(120), 3); - } catch (InvalidMidiDataException e) {} - - // Adds them to track 0. - tracks[0].add(new MidiEvent(timeSigMsg, (long)0)); - tracks[0].add(new MidiEvent(tempoMsg, (long)0)); + // Sets default tempo (120) and time signature (4/4) at the beginning of the sequence. + setTempo(0, 120); + setTimeSig(0, 4, 4); // Sets program and title for the tracks. initializeTrack(tracks[1], 0, 24, "Guitar"); initializeTrack(tracks[2], 1, 33, "Bass"); initializeTrack(tracks[3], 9, 0, "Drums"); - - file = null; - emptyTracks = new ArrayList(); - timeSignatures = new ArrayList(); - tempoChanges = new ArrayList(); - trackSolo = new HashMap(); - trackMute = new HashMap(); - copyBuffer = new ArrayList(); } catch (InvalidMidiDataException e) {} + // Sends the sequence to the GUI. - if (gui != null) gui.setSequence(seq); + if (gui != null) gui.setSequence(seq, null); } /** @@ -609,6 +809,9 @@ public class Moosique { titleMsg.setMessage(3, title.getBytes(), title.length()); } catch (InvalidMidiDataException e) {} + // Sends the program change to the channel + getChannel(channel).programChange(program); + // Adds them to the track. track.add(new MidiEvent(programMsg, (long)0)); track.add(new MidiEvent(titleMsg, (long)0)); @@ -620,7 +823,7 @@ public class Moosique { * @param quantize whether to round locations and durations in the track to nearest 16th * @return a list of the created MooNotes */ - public static List convertTrack(Track track, boolean quantize) { + public static List convertTrack(Track track) { // Searches the track for NoteOn and NoteOff events ArrayList noteOns = new ArrayList(track.size() / 2); ArrayList noteOffs = new ArrayList(track.size() / 2); @@ -675,7 +878,6 @@ public class Moosique { iOn.remove(); } } - if (quantize) quantize(newMooNotes, SIXTEENTH_NOTE, true, true); return newMooNotes; } @@ -691,17 +893,11 @@ public class Moosique { edited = false; Track[] tracks = seq.getTracks(); - emptyTracks = new ArrayList(); - timeSignatures = new ArrayList(); - tempoChanges = new ArrayList(); - trackMute = new HashMap(); - trackSolo = new HashMap(); - copyBuffer = new ArrayList(); + reinitializeLists(); // Searches track 0 for changes in tempo and time signature. MidiEvent event; MetaMessage metaMsg; - ArrayList ts = new ArrayList(), tc = new ArrayList(); for (int i = 0; i < tracks[0].size(); i++) { event = tracks[0].get(i); if (event.getMessage().getStatus() == MetaMessage.META) { @@ -712,14 +908,33 @@ public class Moosique { } } } + Comparator c = new MidiEventComparator(); + Collections.sort(tempoChanges, c); + Collections.sort(timeSignatures, c); + + try { + // If no time signature specified at tick 0, adds the standard one. + if (timeSignatures.size() == 0 || ((MidiEvent)timeSignatures.get(0)).getTick() != 0) { + MetaMessage timeSigMsg = new MetaMessage(); + timeSigMsg.setMessage(88, encodeTimeSig(4, 4), 4); + timeSignatures.add(0, new MidiEvent(timeSigMsg, (long)0)); + } + + // If no tempo specified at tick 0, adds the standard one. + if (tempoChanges.size() == 0 || ((MidiEvent)tempoChanges.get(0)).getTick() != 0) { + MetaMessage tempoMsg = new MetaMessage(); + tempoMsg.setMessage(81, encodeTempo(120), 3); + tempoChanges.add(0, new MidiEvent(tempoMsg, (long)0)); + } + } catch (Exception e) {} // Converts tracks. for (int i = 0; i < tracks.length; i++) { - convertTrack(tracks[i], false); + convertTrack(tracks[i]); } // Sends sequence to GUI and sequencer, then returns - if (gui != null) gui.setSequence(seq); + if (gui != null) gui.setSequence(seq, file); try { sequencer.setSequence(seq); } catch (InvalidMidiDataException e) {} @@ -733,8 +948,35 @@ public class Moosique { * @param location whether the quantize should affect the location of the note * @param duration whether the quantize should affect the duration of the note */ - public static void quantize(List notes, int resolution, boolean location, boolean duration) { - // Math.round(mn.getTick() / ticksPerSixteenth); + public static List quantize(List notes, int resolution, boolean location, boolean duration) { + Iterator it = notes.iterator(); + int noteSize = resolution * seq.getResolution() / 4; + while(it.hasNext()) { + MidiEvent note = (MidiEvent)it.next(); + if (note instanceof MooNote) { + MooNote mn = (MooNote)note; + if (location) mn.setTick(Math.round(mn.getTick() / noteSize) * noteSize); + if (duration) { + int length = Math.round(mn.getDuration() / noteSize) * noteSize; + if (length < noteSize) length = noteSize; + mn.setDuration(length); + } + } + } + return notes; + } + + /** + * Reinitializes sequence-specific collections. + */ + private static void reinitializeLists() { + emptyTracks = new ArrayList(); + timeSignatures = new ArrayList(); + tempoChanges = new ArrayList(); + copyBuffer = new ArrayList(); + trackSolo = new HashMap(); + trackMute = new HashMap(); + selection = new TreeSet(); } /** @@ -752,7 +994,7 @@ public class Moosique { } /** - * Prompts the user . + * Prompts the user to save any unsaved changes. */ public static boolean promptOnUnsavedChanges() { if (!edited) return false; @@ -796,8 +1038,16 @@ public class Moosique { /** * Prints the given string to the System output. */ - private static void out(String text) { - System.out.println(text); + private static void out(String text, boolean newLine) { + if (newLine) System.out.println(text); + else System.out.print(text); + } + + /** + * Advances the current progress counter by printing a "." to the System output. + */ + private static void advanceStatus() { + out(".", false); } /** @@ -829,28 +1079,25 @@ public class Moosique { */ public static class PlayThread extends Thread { public void run() { - // 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)((15000 / getTempo()) * (tickDiff / ticksPerSixteenth))); - sleep (10); - } catch (InterruptedException e) { - Moosique.stop(); + Thread currentThread = Thread.currentThread(); + while(currentThread == player) { + gui.update(sequencer.getTickPosition()); + try { + sleep(10); + } catch (InterruptedException e) { + Moosique.stop(); + } } } } /** - * A listener for detecting the end of the sequence. + * A listener for detecting the Meta event signifying the end of the sequence. */ public static class SongEndListener implements MetaEventListener { public void meta(MetaMessage event) { if (event.getType() == 47) - // End of sequence stop(); - } + } } }