juce/source/src/audio/midi/juce_MidiMessageSequence.cpp

   1 /*
   2   ==============================================================================
   3
   4    This file is part of the JUCE library - "Jules' Utility Class Extensions"
   5    Copyright 2004-11 by Raw Material Software Ltd.
   6
   7   ------------------------------------------------------------------------------
   8
   9    JUCE can be redistributed and/or modified under the terms of the GNU General
  10    Public License (Version 2), as published by the Free Software Foundation.
  11    A copy of the license is included in the JUCE distribution, or can be found
  12    online at www.gnu.org/licenses.
  13
  14    JUCE is distributed in the hope that it will be useful, but WITHOUT ANY
  15    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  16    A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
  17
  18   ------------------------------------------------------------------------------
  19
  20    To release a closed-source product which uses JUCE, commercial licenses are
  21    available: visit www.rawmaterialsoftware.com/juce for more information.
  22
  23   ==============================================================================
  24 */
  25
  26 #include "../../core/juce_StandardHeader.h"
  27
  28 BEGIN_JUCE_NAMESPACE
  29
  30 #include "juce_MidiMessageSequence.h"
  31 #include "../../containers/juce_Array.h"
  32
  33
  34 //==============================================================================
  35 MidiMessageSequence::MidiMessageSequence()
  36 {
  37 }
  38
  39 MidiMessageSequence::MidiMessageSequence (const MidiMessageSequence& other)
  40 {
  41     list.ensureStorageAllocated (other.list.size());
  42
  43     for (int i = 0; i < other.list.size(); ++i)
  44         list.add (new MidiEventHolder (other.list.getUnchecked(i)->message));
  45 }
  46
  47 MidiMessageSequence& MidiMessageSequence::operator= (const MidiMessageSequence& other)
  48 {
  49     MidiMessageSequence otherCopy (other);
  50     swapWith (otherCopy);
  51     return *this;
  52 }
  53
  54 void MidiMessageSequence::swapWith (MidiMessageSequence& other) noexcept
  55 {
  56     list.swapWithArray (other.list);
  57 }
  58
  59 MidiMessageSequence::~MidiMessageSequence()
  60 {
  61 }
  62
  63 void MidiMessageSequence::clear()
  64 {
  65     list.clear();
  66 }
  67
  68 int MidiMessageSequence::getNumEvents() const
  69 {
  70     return list.size();
  71 }
  72
  73 MidiMessageSequence::MidiEventHolder* MidiMessageSequence::getEventPointer (const int index) const
  74 {
  75     return list [index];
  76 }
  77
  78 double MidiMessageSequence::getTimeOfMatchingKeyUp (const int index) const
  79 {
  80     const MidiEventHolder* const meh = list [index];
  81
  82     if (meh != nullptr && meh->noteOffObject != nullptr)
  83         return meh->noteOffObject->message.getTimeStamp();
  84     else
  85         return 0.0;
  86 }
  87
  88 int MidiMessageSequence::getIndexOfMatchingKeyUp (const int index) const
  89 {
  90     const MidiEventHolder* const meh = list [index];
  91
  92     return meh != nullptr ? list.indexOf (meh->noteOffObject) : -1;
  93 }
  94
  95 int MidiMessageSequence::getIndexOf (MidiEventHolder* const event) const
  96 {
  97     return list.indexOf (event);
  98 }
  99
 100 int MidiMessageSequence::getNextIndexAtTime (const double timeStamp) const
 101 {
 102     const int numEvents = list.size();
 103
 104     int i;
 105     for (i = 0; i < numEvents; ++i)
 106         if (list.getUnchecked(i)->message.getTimeStamp() >= timeStamp)
 107             break;
 108
 109     return i;
 110 }
 111
 112 //==============================================================================
 113 double MidiMessageSequence::getStartTime() const
 114 {
 115     if (list.size() > 0)
 116         return list.getUnchecked(0)->message.getTimeStamp();
 117     else
 118         return 0;
 119 }
 120
 121 double MidiMessageSequence::getEndTime() const
 122 {
 123     if (list.size() > 0)
 124         return list.getLast()->message.getTimeStamp();
 125     else
 126         return 0;
 127 }
 128
 129 double MidiMessageSequence::getEventTime (const int index) const
 130 {
 131     if (isPositiveAndBelow (index, list.size()))
 132         return list.getUnchecked (index)->message.getTimeStamp();
 133
 134     return 0.0;
 135 }
 136
 137 //==============================================================================
 138 void MidiMessageSequence::addEvent (const MidiMessage& newMessage,
 139                                     double timeAdjustment)
 140 {
 141     MidiEventHolder* const newOne = new MidiEventHolder (newMessage);
 142
 143     timeAdjustment += newMessage.getTimeStamp();
 144     newOne->message.setTimeStamp (timeAdjustment);
 145
 146     int i;
 147     for (i = list.size(); --i >= 0;)
 148         if (list.getUnchecked(i)->message.getTimeStamp() <= timeAdjustment)
 149             break;
 150
 151     list.insert (i + 1, newOne);
 152 }
 153
 154 void MidiMessageSequence::deleteEvent (const int index,
 155                                        const bool deleteMatchingNoteUp)
 156 {
 157     if (isPositiveAndBelow (index, list.size()))
 158     {
 159         if (deleteMatchingNoteUp)
 160             deleteEvent (getIndexOfMatchingKeyUp (index), false);
 161
 162         list.remove (index);
 163     }
 164 }
 165
 166 void MidiMessageSequence::addSequence (const MidiMessageSequence& other,
 167                                        double timeAdjustment,
 168                                        double firstAllowableTime,
 169                                        double endOfAllowableDestTimes)
 170 {
 171     firstAllowableTime -= timeAdjustment;
 172     endOfAllowableDestTimes -= timeAdjustment;
 173
 174     for (int i = 0; i < other.list.size(); ++i)
 175     {
 176         const MidiMessage& m = other.list.getUnchecked(i)->message;
 177         const double t = m.getTimeStamp();
 178
 179         if (t >= firstAllowableTime && t < endOfAllowableDestTimes)
 180         {
 181             MidiEventHolder* const newOne = new MidiEventHolder (m);
 182             newOne->message.setTimeStamp (timeAdjustment + t);
 183
 184             list.add (newOne);
 185         }
 186     }
 187
 188     sort();
 189 }
 190
 191 //==============================================================================
 192 int MidiMessageSequence::compareElements (const MidiMessageSequence::MidiEventHolder* const first,
 193                                           const MidiMessageSequence::MidiEventHolder* const second) noexcept
 194 {
 195     const double diff = first->message.getTimeStamp()
 196                          - second->message.getTimeStamp();
 197
 198     return (diff > 0) - (diff < 0);
 199 }
 200
 201 void MidiMessageSequence::sort()
 202 {
 203     list.sort (*this, true);
 204 }
 205
 206 //==============================================================================
 207 void MidiMessageSequence::updateMatchedPairs()
 208 {
 209     for (int i = 0; i < list.size(); ++i)
 210     {
 211         const MidiMessage& m1 = list.getUnchecked(i)->message;
 212
 213         if (m1.isNoteOn())
 214         {
 215             list.getUnchecked(i)->noteOffObject = nullptr;
 216             const int note = m1.getNoteNumber();
 217             const int chan = m1.getChannel();
 218             const int len = list.size();
 219
 220             for (int j = i + 1; j < len; ++j)
 221             {
 222                 const MidiMessage& m = list.getUnchecked(j)->message;
 223
 224                 if (m.getNoteNumber() == note && m.getChannel() == chan)
 225                 {
 226                     if (m.isNoteOff())
 227                     {
 228                         list.getUnchecked(i)->noteOffObject = list[j];
 229                         break;
 230                     }
 231                     else if (m.isNoteOn())
 232                     {
 233                         list.insert (j, new MidiEventHolder (MidiMessage::noteOff (chan, note)));
 234                         list.getUnchecked(j)->message.setTimeStamp (m.getTimeStamp());
 235                         list.getUnchecked(i)->noteOffObject = list[j];
 236                         break;
 237                     }
 238                 }
 239             }
 240         }
 241     }
 242 }
 243
 244 void MidiMessageSequence::addTimeToMessages (const double delta)
 245 {
 246     for (int i = list.size(); --i >= 0;)
 247         list.getUnchecked (i)->message.setTimeStamp (list.getUnchecked (i)->message.getTimeStamp()
 248                                                       + delta);
 249 }
 250
 251 //==============================================================================
 252 void MidiMessageSequence::extractMidiChannelMessages (const int channelNumberToExtract,
 253                                                       MidiMessageSequence& destSequence,
 254                                                       const bool alsoIncludeMetaEvents) const
 255 {
 256     for (int i = 0; i < list.size(); ++i)
 257     {
 258         const MidiMessage& mm = list.getUnchecked(i)->message;
 259
 260         if (mm.isForChannel (channelNumberToExtract)
 261              || (alsoIncludeMetaEvents && mm.isMetaEvent()))
 262         {
 263             destSequence.addEvent (mm);
 264         }
 265     }
 266 }
 267
 268 void MidiMessageSequence::extractSysExMessages (MidiMessageSequence& destSequence) const
 269 {
 270     for (int i = 0; i < list.size(); ++i)
 271     {
 272         const MidiMessage& mm = list.getUnchecked(i)->message;
 273
 274         if (mm.isSysEx())
 275             destSequence.addEvent (mm);
 276     }
 277 }
 278
 279 void MidiMessageSequence::deleteMidiChannelMessages (const int channelNumberToRemove)
 280 {
 281     for (int i = list.size(); --i >= 0;)
 282         if (list.getUnchecked(i)->message.isForChannel (channelNumberToRemove))
 283             list.remove(i);
 284 }
 285
 286 void MidiMessageSequence::deleteSysExMessages()
 287 {
 288     for (int i = list.size(); --i >= 0;)
 289         if (list.getUnchecked(i)->message.isSysEx())
 290             list.remove(i);
 291 }
 292
 293 //==============================================================================
 294 void MidiMessageSequence::createControllerUpdatesForTime (const int channelNumber,
 295                                                           const double time,
 296                                                           OwnedArray<MidiMessage>& dest)
 297 {
 298     bool doneProg = false;
 299     bool donePitchWheel = false;
 300     Array <int> doneControllers;
 301     doneControllers.ensureStorageAllocated (32);
 302
 303     for (int i = list.size(); --i >= 0;)
 304     {
 305         const MidiMessage& mm = list.getUnchecked(i)->message;
 306
 307         if (mm.isForChannel (channelNumber)
 308              && mm.getTimeStamp() <= time)
 309         {
 310             if (mm.isProgramChange())
 311             {
 312                 if (! doneProg)
 313                 {
 314                     dest.add (new MidiMessage (mm, 0.0));
 315                     doneProg = true;
 316                 }
 317             }
 318             else if (mm.isController())
 319             {
 320                 if (! doneControllers.contains (mm.getControllerNumber()))
 321                 {
 322                     dest.add (new MidiMessage (mm, 0.0));
 323                     doneControllers.add (mm.getControllerNumber());
 324                 }
 325             }
 326             else if (mm.isPitchWheel())
 327             {
 328                 if (! donePitchWheel)
 329                 {
 330                     dest.add (new MidiMessage (mm, 0.0));
 331                     donePitchWheel = true;
 332                 }
 333             }
 334         }
 335     }
 336 }
 337
 338
 339 //==============================================================================
 340 MidiMessageSequence::MidiEventHolder::MidiEventHolder (const MidiMessage& message_)
 341    : message (message_),
 342      noteOffObject (nullptr)
 343 {
 344 }
 345
 346 MidiMessageSequence::MidiEventHolder::~MidiEventHolder()
 347 {
 348 }
 349
 350 END_JUCE_NAMESPACE