juce/source/src/audio/midi/juce_MidiBuffer.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_MidiBuffer.h"
  31
  32
  33 //==============================================================================
  34 MidiBuffer::MidiBuffer() noexcept
  35     : bytesUsed (0)
  36 {
  37 }
  38
  39 MidiBuffer::MidiBuffer (const MidiMessage& message) noexcept
  40     : bytesUsed (0)
  41 {
  42     addEvent (message, 0);
  43 }
  44
  45 MidiBuffer::MidiBuffer (const MidiBuffer& other) noexcept
  46     : data (other.data),
  47       bytesUsed (other.bytesUsed)
  48 {
  49 }
  50
  51 MidiBuffer& MidiBuffer::operator= (const MidiBuffer& other) noexcept
  52 {
  53     bytesUsed = other.bytesUsed;
  54     data = other.data;
  55
  56     return *this;
  57 }
  58
  59 void MidiBuffer::swapWith (MidiBuffer& other) noexcept
  60 {
  61     data.swapWith (other.data);
  62     std::swap (bytesUsed, other.bytesUsed);
  63 }
  64
  65 MidiBuffer::~MidiBuffer()
  66 {
  67 }
  68
  69 inline uint8* MidiBuffer::getData() const noexcept
  70 {
  71     return static_cast <uint8*> (data.getData());
  72 }
  73
  74 inline int MidiBuffer::getEventTime (const void* const d) noexcept
  75 {
  76     return *static_cast <const int*> (d);
  77 }
  78
  79 inline uint16 MidiBuffer::getEventDataSize (const void* const d) noexcept
  80 {
  81     return *reinterpret_cast <const uint16*> (static_cast <const char*> (d) + sizeof (int));
  82 }
  83
  84 inline uint16 MidiBuffer::getEventTotalSize (const void* const d) noexcept
  85 {
  86     return getEventDataSize (d) + sizeof (int) + sizeof (uint16);
  87 }
  88
  89 void MidiBuffer::clear() noexcept
  90 {
  91     bytesUsed = 0;
  92 }
  93
  94 void MidiBuffer::clear (const int startSample, const int numSamples)
  95 {
  96     uint8* const start = findEventAfter (getData(), startSample - 1);
  97     uint8* const end   = findEventAfter (start, startSample + numSamples - 1);
  98
  99     if (end > start)
 100     {
 101         const int bytesToMove = bytesUsed - (int) (end - getData());
 102
 103         if (bytesToMove > 0)
 104             memmove (start, end, bytesToMove);
 105
 106         bytesUsed -= (int) (end - start);
 107     }
 108 }
 109
 110 void MidiBuffer::addEvent (const MidiMessage& m, const int sampleNumber)
 111 {
 112     addEvent (m.getRawData(), m.getRawDataSize(), sampleNumber);
 113 }
 114
 115 namespace MidiBufferHelpers
 116 {
 117     int findActualEventLength (const uint8* const data, const int maxBytes) noexcept
 118     {
 119         unsigned int byte = (unsigned int) *data;
 120         int size = 0;
 121
 122         if (byte == 0xf0 || byte == 0xf7)
 123         {
 124             const uint8* d = data + 1;
 125
 126             while (d < data + maxBytes)
 127                 if (*d++ == 0xf7)
 128                     break;
 129
 130             size = (int) (d - data);
 131         }
 132         else if (byte == 0xff)
 133         {
 134             int n;
 135             const int bytesLeft = MidiMessage::readVariableLengthVal (data + 1, n);
 136             size = jmin (maxBytes, n + 2 + bytesLeft);
 137         }
 138         else if (byte >= 0x80)
 139         {
 140             size = jmin (maxBytes, MidiMessage::getMessageLengthFromFirstByte ((uint8) byte));
 141         }
 142
 143         return size;
 144     }
 145 }
 146
 147 void MidiBuffer::addEvent (const void* const newData, const int maxBytes, const int sampleNumber)
 148 {
 149     const int numBytes = MidiBufferHelpers::findActualEventLength (static_cast <const uint8*> (newData), maxBytes);
 150
 151     if (numBytes > 0)
 152     {
 153         int spaceNeeded = bytesUsed + numBytes + sizeof (int) + sizeof (uint16);
 154         data.ensureSize ((spaceNeeded + spaceNeeded / 2 + 8) & ~7);
 155
 156         uint8* d = findEventAfter (getData(), sampleNumber);
 157         const int bytesToMove = bytesUsed - (int) (d - getData());
 158
 159         if (bytesToMove > 0)
 160             memmove (d + numBytes + sizeof (int) + sizeof (uint16), d, bytesToMove);
 161
 162         *reinterpret_cast <int*> (d) = sampleNumber;
 163         d += sizeof (int);
 164         *reinterpret_cast <uint16*> (d) = (uint16) numBytes;
 165         d += sizeof (uint16);
 166
 167         memcpy (d, newData, numBytes);
 168
 169         bytesUsed += numBytes + sizeof (int) + sizeof (uint16);
 170     }
 171 }
 172
 173 void MidiBuffer::addEvents (const MidiBuffer& otherBuffer,
 174                             const int startSample,
 175                             const int numSamples,
 176                             const int sampleDeltaToAdd)
 177 {
 178     Iterator i (otherBuffer);
 179     i.setNextSamplePosition (startSample);
 180
 181     const uint8* eventData;
 182     int eventSize, position;
 183
 184     while (i.getNextEvent (eventData, eventSize, position)
 185             && (position < startSample + numSamples || numSamples < 0))
 186     {
 187         addEvent (eventData, eventSize, position + sampleDeltaToAdd);
 188     }
 189 }
 190
 191 void MidiBuffer::ensureSize (size_t minimumNumBytes)
 192 {
 193     data.ensureSize (minimumNumBytes);
 194 }
 195
 196 bool MidiBuffer::isEmpty() const noexcept
 197 {
 198     return bytesUsed == 0;
 199 }
 200
 201 int MidiBuffer::getNumEvents() const noexcept
 202 {
 203     int n = 0;
 204     const uint8* d = getData();
 205     const uint8* const end = d + bytesUsed;
 206
 207     while (d < end)
 208     {
 209         d += getEventTotalSize (d);
 210         ++n;
 211     }
 212
 213     return n;
 214 }
 215
 216 int MidiBuffer::getFirstEventTime() const noexcept
 217 {
 218     return bytesUsed > 0 ? getEventTime (data.getData()) : 0;
 219 }
 220
 221 int MidiBuffer::getLastEventTime() const noexcept
 222 {
 223     if (bytesUsed == 0)
 224         return 0;
 225
 226     const uint8* d = getData();
 227     const uint8* const endData = d + bytesUsed;
 228
 229     for (;;)
 230     {
 231         const uint8* const nextOne = d + getEventTotalSize (d);
 232
 233         if (nextOne >= endData)
 234             return getEventTime (d);
 235
 236         d = nextOne;
 237     }
 238 }
 239
 240 uint8* MidiBuffer::findEventAfter (uint8* d, const int samplePosition) const noexcept
 241 {
 242     const uint8* const endData = getData() + bytesUsed;
 243
 244     while (d < endData && getEventTime (d) <= samplePosition)
 245         d += getEventTotalSize (d);
 246
 247     return d;
 248 }
 249
 250 //==============================================================================
 251 MidiBuffer::Iterator::Iterator (const MidiBuffer& buffer_) noexcept
 252     : buffer (buffer_),
 253       data (buffer_.getData())
 254 {
 255 }
 256
 257 MidiBuffer::Iterator::~Iterator() noexcept
 258 {
 259 }
 260
 261 //==============================================================================
 262 void MidiBuffer::Iterator::setNextSamplePosition (const int samplePosition) noexcept
 263 {
 264     data = buffer.getData();
 265     const uint8* dataEnd = data + buffer.bytesUsed;
 266
 267     while (data < dataEnd && getEventTime (data) < samplePosition)
 268         data += getEventTotalSize (data);
 269 }
 270
 271 bool MidiBuffer::Iterator::getNextEvent (const uint8* &midiData, int& numBytes, int& samplePosition) noexcept
 272 {
 273     if (data >= buffer.getData() + buffer.bytesUsed)
 274         return false;
 275
 276     samplePosition = getEventTime (data);
 277     numBytes = getEventDataSize (data);
 278     data += sizeof (int) + sizeof (uint16);
 279     midiData = data;
 280     data += numBytes;
 281
 282     return true;
 283 }
 284
 285 bool MidiBuffer::Iterator::getNextEvent (MidiMessage& result, int& samplePosition) noexcept
 286 {
 287     if (data >= buffer.getData() + buffer.bytesUsed)
 288         return false;
 289
 290     samplePosition = getEventTime (data);
 291     const int numBytes = getEventDataSize (data);
 292     data += sizeof (int) + sizeof (uint16);
 293     result = MidiMessage (data, numBytes, samplePosition);
 294     data += numBytes;
 295
 296     return true;
 297 }
 298
 299
 300 END_JUCE_NAMESPACE