MooNote.java

   1 import javax.sound.midi.*;
   2
   3 /**
   4  * Functional representation of a MIDI note, which adds functionality to the existent MidiEvent class.
   5  * Also provides a reference to the corresponding NoteOff event.
   6  *
   7  * @author  Einar Pehrson
   8  */
   9
  10 public class MooNote extends MidiEvent {
  11
  12         protected MidiEvent noteOffEvent;
  13         protected ShortMessage noteOnMsg, noteOffMsg;
  14
  15         /**
  16          * Creates a MooNote from the given NoteOn event in the current track.
  17          * @param noteOnEvent   the NoteOn event of the note
  18          */
  19         public MooNote (MidiEvent noteOnEvent) {
  20                 super(noteOnEvent.getMessage(), noteOnEvent.getTick());
  21                 noteOnMsg = (ShortMessage)getMessage();
  22         }
  23
  24         /**
  25          * Creates a MooNote from the given NoteOn event in the current track and creates a reference to
  26          * the corresponding NoteOff event.
  27          * @param noteOnEvent   the NoteOn event of the note
  28          * @param noteOffEvent  the NoteOff event of the note
  29          */
  30         public MooNote (MidiEvent noteOnEvent, MidiEvent noteOffEvent) {
  31                 super(noteOnEvent.getMessage(), noteOnEvent.getTick());
  32                 this.noteOffEvent = noteOffEvent;
  33                 noteOnMsg = (ShortMessage)getMessage();
  34                 noteOffMsg = (ShortMessage)noteOffEvent.getMessage();
  35         }
  36
  37         /**
  38          * Creates a MooNote of the given pitch, velocity and duration in the current track.
  39          * @param track         the track to which the MooNote was added
  40          * @param channel       the channel of the note (1-16)
  41          * @param pitch         the pitch of the note (0-127)
  42          * @param velocity      the velocity of the note (0-127)
  43          * @param timestamp     the timestamp of the note in ticks (96 per beat)
  44          * @param duration      the duration of the note in ticks (96 per beat)
  45          */
  46         public MooNote (int track, int channel, int pitch, int velocity, long timestamp, int duration) {
  47                 super(new ShortMessage(), timestamp);
  48                 noteOffEvent = new MidiEvent(new ShortMessage(), timestamp + duration);
  49                 noteOnMsg = (ShortMessage)getMessage();
  50                 noteOffMsg = (ShortMessage)noteOffEvent.getMessage();
  51                 try {
  52                         noteOnMsg.setMessage(ShortMessage.NOTE_ON, channel, pitch, velocity);
  53                         noteOffMsg.setMessage(ShortMessage.NOTE_OFF, channel, pitch, 0);
  54                 } catch (InvalidMidiDataException e) {}
  55         }
  56
  57         /**
  58          * Sets the channel of the current note.
  59          * @param channel       the channel of the note (1-16)
  60          */
  61         public void setChannel(int channel) {
  62                 try {
  63                         noteOnMsg.setMessage(noteOnMsg.getCommand(), (byte)channel, noteOnMsg.getData1(), noteOnMsg.getData2());
  64                         noteOffMsg.setMessage(noteOffMsg.getCommand(), (byte)channel, noteOffMsg.getData1(), noteOffMsg.getData2());
  65                 } catch (Exception e) {}
  66                 //} catch (InvalidMidiDataException e) {}
  67         }
  68
  69         /**
  70          * Sets the pitch of the current note.
  71          * @param pitch         the pitch of the note (0-127)
  72          */
  73         public void setPitch(int pitch) {
  74                 try {
  75                         noteOnMsg.setMessage(noteOnMsg.getCommand(), noteOnMsg.getChannel(), (byte)pitch, noteOnMsg.getData2());
  76                         noteOffMsg.setMessage(noteOffMsg.getCommand(), noteOffMsg.getChannel(), (byte)pitch, noteOffMsg.getData2());
  77                 } catch (Exception e) {}
  78                 //} catch (InvalidMidiDataException e) {}
  79         }
  80
  81         /**
  82          * Sets the velocity of the current note.
  83          * @param vel   the velocity of the note (0-127)
  84          */
  85         public void setVelocity(int vel) {
  86                 try {
  87                         noteOnMsg.setMessage(noteOnMsg.getCommand(), noteOnMsg.getChannel(), noteOnMsg.getData1(), (byte)vel);
  88                         noteOffMsg.setMessage(noteOffMsg.getCommand(), noteOffMsg.getChannel(), noteOffMsg.getData1(), noteOffMsg.getData2());
  89                 } catch (Exception e) {}
  90                 //} catch (InvalidMidiDataException e) {}
  91         }
  92
  93         /**
  94          * Sets the duration of the current note (or rather moves the note off event).
  95          * @param n     the duration of the note in ticks (96 per beat)
  96          */
  97         public void setDuration(int ticks) {
  98                 if (hasNoteOffEvent()) noteOffEvent.setTick(getTick() + ticks);
  99         }
 100
 101         /**
 102          * Sets the timestamp of the current note.
 103          * @param tick  the timestamp of the note in ticks (96 per beat)
 104          */
 105         public void setTick(long tick) {
 106                 if (hasNoteOffEvent()) noteOffEvent.setTick(tick +  getDuration());
 107                 super.setTick(tick);
 108         }
 109
 110         /**
 111          * Returns the channel of the current note.
 112          * @return the channel of the note (1-16)
 113          */
 114         public int getChannel() {
 115                 return noteOnMsg.getChannel();
 116         }
 117
 118         /**
 119          * Returns the pitch of the current note.
 120          * @return the pitch of the note (0-127)
 121          */
 122         public int getPitch() {
 123                 return noteOnMsg.getData1();
 124         }
 125
 126         /**
 127          * Returns the velocity of the current note.
 128          * @return the velocity of the note (0-127)
 129          */
 130         public int getVelocity() {
 131                 return noteOnMsg.getData2();
 132         }
 133
 134         /**
 135          * Returns the duration of the current note.
 136          * @return the duration of the note (in ticks)
 137          */
 138         public int getDuration() {
 139                 if (!hasNoteOffEvent()) return 0;
 140                 return (int)(noteOffEvent.getTick() - getTick());
 141         }
 142
 143         /**
 144          * Returns whether the NoteOff event was found.
 145          * @return      the note off MidiEvent
 146          */
 147         public boolean hasNoteOffEvent() {
 148                 return noteOffEvent != null;
 149         }
 150 }