falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 42 Activity
Audio plugin host https://kx.studio/carla
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3441 Commits
16 Branches
260MB
Tree: f9387f9a34
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'f9387f9a34'
${ noResults }
Carla/source/modules/juce_audio_basics/midi/juce_MidiMessage.cpp

1145 lines
43KB
Raw Blame History 

  1. /*

  2.   ==============================================================================

  3. 

  4.    This file is part of the JUCE library.

  5.    Copyright (c) 2015 - ROLI Ltd.

  6. 

  7.    Permission is granted to use this software under the terms of either:

  8.    a) the GPL v2 (or any later version)

  9.    b) the Affero GPL v3

  10. 

  11.    Details of these licenses can be found at: www.gnu.org/licenses

  12. 

  13.    JUCE is distributed in the hope that it will be useful, but WITHOUT ANY

  14.    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR

  15.    A PARTICULAR PURPOSE.  See the GNU General Public License for more details.

  16. 

  17.    ------------------------------------------------------------------------------

  18. 

  19.    To release a closed-source product which uses JUCE, commercial licenses are

  20.    available: visit www.juce.com for more information.

  21. 

  22.   ==============================================================================

  23. */

  24. 

  25. namespace MidiHelpers

  26. {

  27.     inline uint8 initialByte (const int type, const int channel) noexcept

  28.     {

  29.         return (uint8) (type | jlimit (0, 15, channel - 1));

  30.     }

  31. 

  32.     inline uint8 validVelocity (const int v) noexcept

  33.     {

  34.         return (uint8) jlimit (0, 127, v);

  35.     }

  36. }

  37. 

  38. //==============================================================================

  39. uint8 MidiMessage::floatValueToMidiByte (const float v) noexcept

  40. {

  41.     return MidiHelpers::validVelocity (roundToInt (v * 127.0f));

  42. }

  43. 

  44. uint16 MidiMessage::pitchbendToPitchwheelPos (const float pitchbend,

  45.                                  const float pitchbendRange) noexcept

  46. {

  47.     // can't translate a pitchbend value that is outside of the given range!

  48.     jassert (std::abs (pitchbend) <= pitchbendRange);

  49. 

  50.     return static_cast<uint16> (pitchbend > 0.0f

  51.                                   ? jmap (pitchbend, 0.0f, pitchbendRange, 8192.0f, 16383.0f)

  52.                                   : jmap (pitchbend, -pitchbendRange, 0.0f, 0.0f, 8192.0f));

  53. }

  54. 

  55. //==============================================================================

  56. int MidiMessage::readVariableLengthVal (const uint8* data, int& numBytesUsed) noexcept

  57. {

  58.     numBytesUsed = 0;

  59.     int v = 0, i;

  60. 

  61.     do

  62.     {

  63.         i = (int) *data++;

  64. 

  65.         if (++numBytesUsed > 6)

  66.             break;

  67. 

  68.         v = (v << 7) + (i & 0x7f);

  69. 

  70.     } while (i & 0x80);

  71. 

  72.     return v;

  73. }

  74. 

  75. int MidiMessage::getMessageLengthFromFirstByte (const uint8 firstByte) noexcept

  76. {

  77.     // this method only works for valid starting bytes of a short midi message

  78.     jassert (firstByte >= 0x80 && firstByte != 0xf0 && firstByte != 0xf7);

  79. 

  80.     static const char messageLengths[] =

  81.     {

  82.         3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,

  83.         3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,

  84.         3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,

  85.         3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,

  86.         2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

  87.         2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

  88.         3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,

  89.         1, 2, 3, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1

  90.     };

  91. 

  92.     return messageLengths [firstByte & 0x7f];

  93. }

  94. 

  95. //==============================================================================

  96. MidiMessage::MidiMessage() noexcept

  97.    : timeStamp (0), size (2)

  98. {

  99.     packedData.asBytes[0] = 0xf0;

  100.     packedData.asBytes[1] = 0xf7;

  101. }

  102. 

  103. MidiMessage::MidiMessage (const void* const d, const int dataSize, const double t)

  104.    : timeStamp (t), size (dataSize)

  105. {

  106.     jassert (dataSize > 0);

  107.     // this checks that the length matches the data..

  108.     jassert (dataSize > 3 || *(uint8*)d >= 0xf0 || getMessageLengthFromFirstByte (*(uint8*)d) == size);

  109. 

  110.     memcpy (allocateSpace (dataSize), d, (size_t) dataSize);

  111. }

  112. 

  113. MidiMessage::MidiMessage (const int byte1, const double t) noexcept

  114.    : timeStamp (t), size (1)

  115. {

  116.     packedData.asBytes[0] = (uint8) byte1;

  117. 

  118.     // check that the length matches the data..

  119.     jassert (byte1 >= 0xf0 || getMessageLengthFromFirstByte ((uint8) byte1) == 1);

  120. }

  121. 

  122. MidiMessage::MidiMessage (const int byte1, const int byte2, const double t) noexcept

  123.    : timeStamp (t), size (2)

  124. {

  125.     packedData.asBytes[0] = (uint8) byte1;

  126.     packedData.asBytes[1] = (uint8) byte2;

  127. 

  128.     // check that the length matches the data..

  129.     jassert (byte1 >= 0xf0 || getMessageLengthFromFirstByte ((uint8) byte1) == 2);

  130. }

  131. 

  132. MidiMessage::MidiMessage (const int byte1, const int byte2, const int byte3, const double t) noexcept

  133.    : timeStamp (t), size (3)

  134. {

  135.     packedData.asBytes[0] = (uint8) byte1;

  136.     packedData.asBytes[1] = (uint8) byte2;

  137.     packedData.asBytes[2] = (uint8) byte3;

  138. 

  139.     // check that the length matches the data..

  140.     jassert (byte1 >= 0xf0 || getMessageLengthFromFirstByte ((uint8) byte1) == 3);

  141. }

  142. 

  143. MidiMessage::MidiMessage (const MidiMessage& other)

  144.    : timeStamp (other.timeStamp), size (other.size)

  145. {

  146.     if (isHeapAllocated())

  147.         memcpy (allocateSpace (size), other.getData(), (size_t) size);

  148.     else

  149.         packedData.allocatedData = other.packedData.allocatedData;

  150. }

  151. 

  152. MidiMessage::MidiMessage (const MidiMessage& other, const double newTimeStamp)

  153.    : timeStamp (newTimeStamp), size (other.size)

  154. {

  155.     if (isHeapAllocated())

  156.         memcpy (allocateSpace (size), other.getData(), (size_t) size);

  157.     else

  158.         packedData.allocatedData = other.packedData.allocatedData;

  159. }

  160. 

  161. MidiMessage::MidiMessage (const void* srcData, int sz, int& numBytesUsed, const uint8 lastStatusByte,

  162.                           double t, bool sysexHasEmbeddedLength)

  163.     : timeStamp (t)

  164. {

  165.     const uint8* src = static_cast<const uint8*> (srcData);

  166.     unsigned int byte = (unsigned int) *src;

  167. 

  168.     if (byte < 0x80)

  169.     {

  170.         byte = (unsigned int) (uint8) lastStatusByte;

  171.         numBytesUsed = -1;

  172.     }

  173.     else

  174.     {

  175.         numBytesUsed = 0;

  176.         --sz;

  177.         ++src;

  178.     }

  179. 

  180.     if (byte >= 0x80)

  181.     {

  182.         if (byte == 0xf0)

  183.         {

  184.             const uint8* d = src;

  185.             bool haveReadAllLengthBytes = ! sysexHasEmbeddedLength;

  186.             int numVariableLengthSysexBytes = 0;

  187. 

  188.             while (d < src + sz)

  189.             {

  190.                 if (*d >= 0x80)

  191.                 {

  192.                     if (*d == 0xf7)

  193.                     {

  194.                         ++d;  // include the trailing 0xf7 when we hit it

  195.                         break;

  196.                     }

  197. 

  198.                     if (haveReadAllLengthBytes) // if we see a 0x80 bit set after the initial data length

  199.                         break;                  // bytes, assume it's the end of the sysex

  200. 

  201.                     ++numVariableLengthSysexBytes;

  202.                 }

  203.                 else if (! haveReadAllLengthBytes)

  204.                 {

  205.                     haveReadAllLengthBytes = true;

  206.                     ++numVariableLengthSysexBytes;

  207.                 }

  208. 

  209.                 ++d;

  210.             }

  211. 

  212.             src += numVariableLengthSysexBytes;

  213.             size = 1 + (int) (d - src);

  214. 

  215.             uint8* dest = allocateSpace (size);

  216.             *dest = (uint8) byte;

  217.             memcpy (dest + 1, src, (size_t) (size - 1));

  218. 

  219.             numBytesUsed += numVariableLengthSysexBytes;  // (these aren't counted in the size)

  220.         }

  221.         else if (byte == 0xff)

  222.         {

  223.             int n;

  224.             const int bytesLeft = readVariableLengthVal (src + 1, n);

  225.             size = jmin (sz + 1, n + 2 + bytesLeft);

  226. 

  227.             uint8* dest = allocateSpace (size);

  228.             *dest = (uint8) byte;

  229.             memcpy (dest + 1, src, (size_t) size - 1);

  230.         }

  231.         else

  232.         {

  233.             size = getMessageLengthFromFirstByte ((uint8) byte);

  234.             packedData.asBytes[0] = (uint8) byte;

  235. 

  236.             if (size > 1)

  237.             {

  238.                 packedData.asBytes[1] = src[0];

  239. 

  240.                 if (size > 2)

  241.                     packedData.asBytes[2] = src[1];

  242.             }

  243.         }

  244. 

  245.         numBytesUsed += size;

  246.     }

  247.     else

  248.     {

  249.         packedData.allocatedData = nullptr;

  250.         size = 0;

  251.     }

  252. }

  253. 

  254. MidiMessage& MidiMessage::operator= (const MidiMessage& other)

  255. {

  256.     if (this != &other)

  257.     {

  258.         if (other.isHeapAllocated())

  259.         {

  260.             if (isHeapAllocated())

  261.                 packedData.allocatedData = static_cast<uint8*> (std::realloc (packedData.allocatedData, (size_t) other.size));

  262.             else

  263.                 packedData.allocatedData = static_cast<uint8*> (std::malloc ((size_t) other.size));

  264. 

  265.             memcpy (packedData.allocatedData, other.packedData.allocatedData, (size_t) other.size);

  266.         }

  267.         else

  268.         {

  269.             if (isHeapAllocated())

  270.                 std::free (packedData.allocatedData);

  271. 

  272.             packedData.allocatedData = other.packedData.allocatedData;

  273.         }

  274. 

  275.         timeStamp = other.timeStamp;

  276.         size = other.size;

  277.     }

  278. 

  279.     return *this;

  280. }

  281. 

  282. #if JUCE_COMPILER_SUPPORTS_MOVE_SEMANTICS

  283. MidiMessage::MidiMessage (MidiMessage&& other) noexcept

  284.    : timeStamp (other.timeStamp), size (other.size)

  285. {

  286.     packedData.allocatedData = other.packedData.allocatedData;

  287.     other.size = 0;

  288. }

  289. 

  290. MidiMessage& MidiMessage::operator= (MidiMessage&& other) noexcept

  291. {

  292.     packedData.allocatedData = other.packedData.allocatedData;

  293.     timeStamp = other.timeStamp;

  294.     size = other.size;

  295.     other.size = 0;

  296.     return *this;

  297. }

  298. #endif

  299. 

  300. MidiMessage::~MidiMessage() noexcept

  301. {

  302.     if (isHeapAllocated())

  303.         std::free (packedData.allocatedData);

  304. }

  305. 

  306. uint8* MidiMessage::allocateSpace (int bytes)

  307. {

  308.     if (bytes > (int) sizeof (packedData))

  309.     {

  310.         uint8* d = static_cast<uint8*> (std::malloc ((size_t) bytes));

  311.         packedData.allocatedData = d;

  312.         return d;

  313.     }

  314. 

  315.     return packedData.asBytes;

  316. }

  317. 

  318. String MidiMessage::getDescription() const

  319. {

  320.     if (isNoteOn())           return "Note on "  + MidiMessage::getMidiNoteName (getNoteNumber(), true, true, 3) + " Velocity " + String (getVelocity()) + " Channel " + String (getChannel());

  321.     if (isNoteOff())          return "Note off " + MidiMessage::getMidiNoteName (getNoteNumber(), true, true, 3) + " Velocity " + String (getVelocity()) + " Channel " + String (getChannel());

  322.     if (isProgramChange())    return "Program change " + String (getProgramChangeNumber()) + " Channel " + String (getChannel());

  323.     if (isPitchWheel())       return "Pitch wheel " + String (getPitchWheelValue()) + " Channel " + String (getChannel());

  324.     if (isAftertouch())       return "Aftertouch " + MidiMessage::getMidiNoteName (getNoteNumber(), true, true, 3) +  ": " + String (getAfterTouchValue()) + " Channel " + String (getChannel());

  325.     if (isChannelPressure())  return "Channel pressure " + String (getChannelPressureValue()) + " Channel " + String (getChannel());

  326.     if (isAllNotesOff())      return "All notes off Channel " + String (getChannel());

  327.     if (isAllSoundOff())      return "All sound off Channel " + String (getChannel());

  328.     if (isMetaEvent())        return "Meta event";

  329. 

  330.     if (isController())

  331.     {

  332.         String name (MidiMessage::getControllerName (getControllerNumber()));

  333. 

  334.         if (name.isEmpty())

  335.             name = String (getControllerNumber());

  336. 

  337.         return "Controller " + name + ": " + String (getControllerValue()) + " Channel " + String (getChannel());

  338.     }

  339. 

  340.     return String::toHexString (getRawData(), getRawDataSize());

  341. }

  342. 

  343. int MidiMessage::getChannel() const noexcept

  344. {

  345.     const uint8* const data = getRawData();

  346. 

  347.     if ((data[0] & 0xf0) != 0xf0)

  348.         return (data[0] & 0xf) + 1;

  349. 

  350.     return 0;

  351. }

  352. 

  353. bool MidiMessage::isForChannel (const int channel) const noexcept

  354. {

  355.     jassert (channel > 0 && channel <= 16); // valid channels are numbered 1 to 16

  356. 

  357.     const uint8* const data = getRawData();

  358. 

  359.     return ((data[0] & 0xf) == channel - 1)

  360.              && ((data[0] & 0xf0) != 0xf0);

  361. }

  362. 

  363. void MidiMessage::setChannel (const int channel) noexcept

  364. {

  365.     jassert (channel > 0 && channel <= 16); // valid channels are numbered 1 to 16

  366. 

  367.     uint8* const data = getData();

  368. 

  369.     if ((data[0] & 0xf0) != (uint8) 0xf0)

  370.         data[0] = (uint8) ((data[0] & (uint8) 0xf0)

  371.                             | (uint8)(channel - 1));

  372. }

  373. 

  374. bool MidiMessage::isNoteOn (const bool returnTrueForVelocity0) const noexcept

  375. {

  376.     const uint8* const data = getRawData();

  377. 

  378.     return ((data[0] & 0xf0) == 0x90)

  379.              && (returnTrueForVelocity0 || data[2] != 0);

  380. }

  381. 

  382. bool MidiMessage::isNoteOff (const bool returnTrueForNoteOnVelocity0) const noexcept

  383. {

  384.     const uint8* const data = getRawData();

  385. 

  386.     return ((data[0] & 0xf0) == 0x80)

  387.             || (returnTrueForNoteOnVelocity0 && (data[2] == 0) && ((data[0] & 0xf0) == 0x90));

  388. }

  389. 

  390. bool MidiMessage::isNoteOnOrOff() const noexcept

  391. {

  392.     const uint8* const data = getRawData();

  393. 

  394.     const int d = data[0] & 0xf0;

  395.     return (d == 0x90) || (d == 0x80);

  396. }

  397. 

  398. int MidiMessage::getNoteNumber() const noexcept

  399. {

  400.     return getRawData()[1];

  401. }

  402. 

  403. void MidiMessage::setNoteNumber (const int newNoteNumber) noexcept

  404. {

  405.     if (isNoteOnOrOff() || isAftertouch())

  406.         getData()[1] = (uint8) (newNoteNumber & 127);

  407. }

  408. 

  409. uint8 MidiMessage::getVelocity() const noexcept

  410. {

  411.     if (isNoteOnOrOff())

  412.         return getRawData()[2];

  413. 

  414.     return 0;

  415. }

  416. 

  417. float MidiMessage::getFloatVelocity() const noexcept

  418. {

  419.     return getVelocity() * (1.0f / 127.0f);

  420. }

  421. 

  422. void MidiMessage::setVelocity (const float newVelocity) noexcept

  423. {

  424.     if (isNoteOnOrOff())

  425.         getData()[2] = floatValueToMidiByte (newVelocity);

  426. }

  427. 

  428. void MidiMessage::multiplyVelocity (const float scaleFactor) noexcept

  429. {

  430.     if (isNoteOnOrOff())

  431.     {

  432.         uint8* const data = getData();

  433.         data[2] = MidiHelpers::validVelocity (roundToInt (scaleFactor * data[2]));

  434.     }

  435. }

  436. 

  437. bool MidiMessage::isAftertouch() const noexcept

  438. {

  439.     return (getRawData()[0] & 0xf0) == 0xa0;

  440. }

  441. 

  442. int MidiMessage::getAfterTouchValue() const noexcept

  443. {

  444.     jassert (isAftertouch());

  445.     return getRawData()[2];

  446. }

  447. 

  448. MidiMessage MidiMessage::aftertouchChange (const int channel,

  449.                                            const int noteNum,

  450.                                            const int aftertouchValue) noexcept

  451. {

  452.     jassert (channel > 0 && channel <= 16); // valid channels are numbered 1 to 16

  453.     jassert (isPositiveAndBelow (noteNum, (int) 128));

  454.     jassert (isPositiveAndBelow (aftertouchValue, (int) 128));

  455. 

  456.     return MidiMessage (MidiHelpers::initialByte (0xa0, channel),

  457.                         noteNum & 0x7f,

  458.                         aftertouchValue & 0x7f);

  459. }

  460. 

  461. bool MidiMessage::isChannelPressure() const noexcept

  462. {

  463.     return (getRawData()[0] & 0xf0) == 0xd0;

  464. }

  465. 

  466. int MidiMessage::getChannelPressureValue() const noexcept

  467. {

  468.     jassert (isChannelPressure());

  469.     return getRawData()[1];

  470. }

  471. 

  472. MidiMessage MidiMessage::channelPressureChange (const int channel, const int pressure) noexcept

  473. {

  474.     jassert (channel > 0 && channel <= 16); // valid channels are numbered 1 to 16

  475.     jassert (isPositiveAndBelow (pressure, (int) 128));

  476. 

  477.     return MidiMessage (MidiHelpers::initialByte (0xd0, channel), pressure & 0x7f);

  478. }

  479. 

  480. bool MidiMessage::isSustainPedalOn() const noexcept     { return isControllerOfType (0x40) && getRawData()[2] >= 64; }

  481. bool MidiMessage::isSustainPedalOff() const noexcept    { return isControllerOfType (0x40) && getRawData()[2] <  64; }

  482. 

  483. bool MidiMessage::isSostenutoPedalOn() const noexcept   { return isControllerOfType (0x42) && getRawData()[2] >= 64; }

  484. bool MidiMessage::isSostenutoPedalOff() const noexcept  { return isControllerOfType (0x42) && getRawData()[2] <  64; }

  485. 

  486. bool MidiMessage::isSoftPedalOn() const noexcept        { return isControllerOfType (0x43) && getRawData()[2] >= 64; }

  487. bool MidiMessage::isSoftPedalOff() const noexcept       { return isControllerOfType (0x43) && getRawData()[2] <  64; }

  488. 

  489. 

  490. bool MidiMessage::isProgramChange() const noexcept

  491. {

  492.     return (getRawData()[0] & 0xf0) == 0xc0;

  493. }

  494. 

  495. int MidiMessage::getProgramChangeNumber() const noexcept

  496. {

  497.     jassert (isProgramChange());

  498.     return getRawData()[1];

  499. }

  500. 

  501. MidiMessage MidiMessage::programChange (const int channel, const int programNumber) noexcept

  502. {

  503.     jassert (channel > 0 && channel <= 16); // valid channels are numbered 1 to 16

  504. 

  505.     return MidiMessage (MidiHelpers::initialByte (0xc0, channel), programNumber & 0x7f);

  506. }

  507. 

  508. bool MidiMessage::isPitchWheel() const noexcept

  509. {

  510.     return (getRawData()[0] & 0xf0) == 0xe0;

  511. }

  512. 

  513. int MidiMessage::getPitchWheelValue() const noexcept

  514. {

  515.     jassert (isPitchWheel());

  516.     const uint8* const data = getRawData();

  517.     return data[1] | (data[2] << 7);

  518. }

  519. 

  520. MidiMessage MidiMessage::pitchWheel (const int channel, const int position) noexcept

  521. {

  522.     jassert (channel > 0 && channel <= 16); // valid channels are numbered 1 to 16

  523.     jassert (isPositiveAndBelow (position, (int) 0x4000));

  524. 

  525.     return MidiMessage (MidiHelpers::initialByte (0xe0, channel),

  526.                         position & 127, (position >> 7) & 127);

  527. }

  528. 

  529. bool MidiMessage::isController() const noexcept

  530. {

  531.     return (getRawData()[0] & 0xf0) == 0xb0;

  532. }

  533. 

  534. bool MidiMessage::isControllerOfType (const int controllerType) const noexcept

  535. {

  536.     const uint8* const data = getRawData();

  537.     return (data[0] & 0xf0) == 0xb0 && data[1] == controllerType;

  538. }

  539. 

  540. int MidiMessage::getControllerNumber() const noexcept

  541. {

  542.     jassert (isController());

  543.     return getRawData()[1];

  544. }

  545. 

  546. int MidiMessage::getControllerValue() const noexcept

  547. {

  548.     jassert (isController());

  549.     return getRawData()[2];

  550. }

  551. 

  552. MidiMessage MidiMessage::controllerEvent (const int channel, const int controllerType, const int value) noexcept

  553. {

  554.     // the channel must be between 1 and 16 inclusive

  555.     jassert (channel > 0 && channel <= 16);

  556. 

  557.     return MidiMessage (MidiHelpers::initialByte (0xb0, channel),

  558.                         controllerType & 127, value & 127);

  559. }

  560. 

  561. MidiMessage MidiMessage::noteOn (const int channel, const int noteNumber, const uint8 velocity) noexcept

  562. {

  563.     jassert (channel > 0 && channel <= 16);

  564.     jassert (isPositiveAndBelow (noteNumber, (int) 128));

  565. 

  566.     return MidiMessage (MidiHelpers::initialByte (0x90, channel),

  567.                         noteNumber & 127, MidiHelpers::validVelocity (velocity));

  568. }

  569. 

  570. MidiMessage MidiMessage::noteOn (const int channel, const int noteNumber, const float velocity) noexcept

  571. {

  572.     return noteOn (channel, noteNumber, floatValueToMidiByte (velocity));

  573. }

  574. 

  575. MidiMessage MidiMessage::noteOff (const int channel, const int noteNumber, uint8 velocity) noexcept

  576. {

  577.     jassert (channel > 0 && channel <= 16);

  578.     jassert (isPositiveAndBelow (noteNumber, (int) 128));

  579. 

  580.     return MidiMessage (MidiHelpers::initialByte (0x80, channel),

  581.                         noteNumber & 127, MidiHelpers::validVelocity (velocity));

  582. }

  583. 

  584. MidiMessage MidiMessage::noteOff (const int channel, const int noteNumber, float velocity) noexcept

  585. {

  586.     return noteOff (channel, noteNumber, floatValueToMidiByte (velocity));

  587. }

  588. 

  589. MidiMessage MidiMessage::noteOff (const int channel, const int noteNumber) noexcept

  590. {

  591.     jassert (channel > 0 && channel <= 16);

  592.     jassert (isPositiveAndBelow (noteNumber, (int) 128));

  593. 

  594.     return MidiMessage (MidiHelpers::initialByte (0x80, channel), noteNumber & 127, 0);

  595. }

  596. 

  597. MidiMessage MidiMessage::allNotesOff (const int channel) noexcept

  598. {

  599.     return controllerEvent (channel, 123, 0);

  600. }

  601. 

  602. bool MidiMessage::isAllNotesOff() const noexcept

  603. {

  604.     const uint8* const data = getRawData();

  605.     return (data[0] & 0xf0) == 0xb0 && data[1] == 123;

  606. }

  607. 

  608. MidiMessage MidiMessage::allSoundOff (const int channel) noexcept

  609. {

  610.     return controllerEvent (channel, 120, 0);

  611. }

  612. 

  613. bool MidiMessage::isAllSoundOff() const noexcept

  614. {

  615.     const uint8* const data = getRawData();

  616.     return (data[0] & 0xf0) == 0xb0 && data[1] == 120;

  617. }

  618. 

  619. MidiMessage MidiMessage::allControllersOff (const int channel) noexcept

  620. {

  621.     return controllerEvent (channel, 121, 0);

  622. }

  623. 

  624. MidiMessage MidiMessage::masterVolume (const float volume)

  625. {

  626.     const int vol = jlimit (0, 0x3fff, roundToInt (volume * 0x4000));

  627. 

  628.     const uint8 buf[] = { 0xf0, 0x7f, 0x7f, 0x04, 0x01,

  629.                           (uint8) (vol & 0x7f),

  630.                           (uint8) (vol >> 7),

  631.                           0xf7 };

  632. 

  633.     return MidiMessage (buf, 8);

  634. }

  635. 

  636. //==============================================================================

  637. bool MidiMessage::isSysEx() const noexcept

  638. {

  639.     return *getRawData() == 0xf0;

  640. }

  641. 

  642. MidiMessage MidiMessage::createSysExMessage (const void* sysexData, const int dataSize)

  643. {

  644.     HeapBlock<uint8> m ((size_t) dataSize + 2);

  645. 

  646.     m[0] = 0xf0;

  647.     memcpy (m + 1, sysexData, (size_t) dataSize);

  648.     m[dataSize + 1] = 0xf7;

  649. 

  650.     return MidiMessage (m, dataSize + 2);

  651. }

  652. 

  653. const uint8* MidiMessage::getSysExData() const noexcept

  654. {

  655.     return isSysEx() ? getRawData() + 1 : nullptr;

  656. }

  657. 

  658. int MidiMessage::getSysExDataSize() const noexcept

  659. {

  660.     return isSysEx() ? size - 2 : 0;

  661. }

  662. 

  663. //==============================================================================

  664. bool MidiMessage::isMetaEvent() const noexcept      { return *getRawData() == 0xff; }

  665. bool MidiMessage::isActiveSense() const noexcept    { return *getRawData() == 0xfe; }

  666. 

  667. int MidiMessage::getMetaEventType() const noexcept

  668. {

  669.     const uint8* const data = getRawData();

  670.     return *data != 0xff ? -1 : data[1];

  671. }

  672. 

  673. int MidiMessage::getMetaEventLength() const noexcept

  674. {

  675.     const uint8* const data = getRawData();

  676.     if (*data == 0xff)

  677.     {

  678.         int n;

  679.         return jmin (size - 2, readVariableLengthVal (data + 2, n));

  680.     }

  681. 

  682.     return 0;

  683. }

  684. 

  685. const uint8* MidiMessage::getMetaEventData() const noexcept

  686. {

  687.     jassert (isMetaEvent());

  688. 

  689.     int n;

  690.     const uint8* d = getRawData() + 2;

  691.     readVariableLengthVal (d, n);

  692.     return d + n;

  693. }

  694. 

  695. bool MidiMessage::isTrackMetaEvent() const noexcept         { return getMetaEventType() == 0; }

  696. bool MidiMessage::isEndOfTrackMetaEvent() const noexcept    { return getMetaEventType() == 47; }

  697. 

  698. bool MidiMessage::isTextMetaEvent() const noexcept

  699. {

  700.     const int t = getMetaEventType();

  701.     return t > 0 && t < 16;

  702. }

  703. 

  704. String MidiMessage::getTextFromTextMetaEvent() const

  705. {

  706.     const char* const textData = reinterpret_cast<const char*> (getMetaEventData());

  707.     return String (CharPointer_UTF8 (textData),

  708.                    CharPointer_UTF8 (textData + getMetaEventLength()));

  709. }

  710. 

  711. MidiMessage MidiMessage::textMetaEvent (int type, StringRef text)

  712. {

  713.     jassert (type > 0 && type < 16);

  714. 

  715.     MidiMessage result;

  716. 

  717.     const size_t textSize = text.text.sizeInBytes() - 1;

  718. 

  719.     uint8 header[8];

  720.     size_t n = sizeof (header);

  721. 

  722.     header[--n] = (uint8) (textSize & 0x7f);

  723. 

  724.     for (size_t i = textSize; (i >>= 7) != 0;)

  725.         header[--n] = (uint8) ((i & 0x7f) | 0x80);

  726. 

  727.     header[--n] = (uint8) type;

  728.     header[--n] = 0xff;

  729. 

  730.     const size_t headerLen = sizeof (header) - n;

  731.     const int totalSize = (int) (headerLen + textSize);

  732. 

  733.     uint8* const dest = result.allocateSpace (totalSize);

  734.     result.size = totalSize;

  735. 

  736.     memcpy (dest, header + n, headerLen);

  737.     memcpy (dest + headerLen, text.text.getAddress(), textSize);

  738. 

  739.     return result;

  740. }

  741. 

  742. bool MidiMessage::isTrackNameEvent() const noexcept         { const uint8* data = getRawData(); return (data[1] == 3)    && (*data == 0xff); }

  743. bool MidiMessage::isTempoMetaEvent() const noexcept         { const uint8* data = getRawData(); return (data[1] == 81)   && (*data == 0xff); }

  744. bool MidiMessage::isMidiChannelMetaEvent() const noexcept   { const uint8* data = getRawData(); return (data[1] == 0x20) && (*data == 0xff) && (data[2] == 1); }

  745. 

  746. int MidiMessage::getMidiChannelMetaEventChannel() const noexcept

  747. {

  748.     jassert (isMidiChannelMetaEvent());

  749.     return getRawData()[3] + 1;

  750. }

  751. 

  752. double MidiMessage::getTempoSecondsPerQuarterNote() const noexcept

  753. {

  754.     if (! isTempoMetaEvent())

  755.         return 0.0;

  756. 

  757.     const uint8* const d = getMetaEventData();

  758. 

  759.     return (((unsigned int) d[0] << 16)

  760.              | ((unsigned int) d[1] << 8)

  761.              | d[2])

  762.             / 1000000.0;

  763. }

  764. 

  765. double MidiMessage::getTempoMetaEventTickLength (const short timeFormat) const noexcept

  766. {

  767.     if (timeFormat > 0)

  768.     {

  769.         if (! isTempoMetaEvent())

  770.             return 0.5 / timeFormat;

  771. 

  772.         return getTempoSecondsPerQuarterNote() / timeFormat;

  773.     }

  774.     else

  775.     {

  776.         const int frameCode = (-timeFormat) >> 8;

  777.         double framesPerSecond;

  778. 

  779.         switch (frameCode)

  780.         {

  781.             case 24: framesPerSecond = 24.0;   break;

  782.             case 25: framesPerSecond = 25.0;   break;

  783.             case 29: framesPerSecond = 29.97;  break;

  784.             case 30: framesPerSecond = 30.0;   break;

  785.             default: framesPerSecond = 30.0;   break;

  786.         }

  787. 

  788.         return (1.0 / framesPerSecond) / (timeFormat & 0xff);

  789.     }

  790. }

  791. 

  792. MidiMessage MidiMessage::tempoMetaEvent (int microsecondsPerQuarterNote) noexcept

  793. {

  794.     const uint8 d[] = { 0xff, 81, 3,

  795.                         (uint8) (microsecondsPerQuarterNote >> 16),

  796.                         (uint8) (microsecondsPerQuarterNote >> 8),

  797.                         (uint8) microsecondsPerQuarterNote };

  798. 

  799.     return MidiMessage (d, 6, 0.0);

  800. }

  801. 

  802. bool MidiMessage::isTimeSignatureMetaEvent() const noexcept

  803. {

  804.     const uint8* const data = getRawData();

  805.     return (data[1] == 0x58) && (*data == (uint8) 0xff);

  806. }

  807. 

  808. void MidiMessage::getTimeSignatureInfo (int& numerator, int& denominator) const noexcept

  809. {

  810.     if (isTimeSignatureMetaEvent())

  811.     {

  812.         const uint8* const d = getMetaEventData();

  813.         numerator = d[0];

  814.         denominator = 1 << d[1];

  815.     }

  816.     else

  817.     {

  818.         numerator = 4;

  819.         denominator = 4;

  820.     }

  821. }

  822. 

  823. MidiMessage MidiMessage::timeSignatureMetaEvent (const int numerator, const int denominator)

  824. {

  825.     int n = 1;

  826.     int powerOfTwo = 0;

  827. 

  828.     while (n < denominator)

  829.     {

  830.         n <<= 1;

  831.         ++powerOfTwo;

  832.     }

  833. 

  834.     const uint8 d[] = { 0xff, 0x58, 0x04, (uint8) numerator, (uint8) powerOfTwo, 1, 96 };

  835.     return MidiMessage (d, 7, 0.0);

  836. }

  837. 

  838. MidiMessage MidiMessage::midiChannelMetaEvent (const int channel) noexcept

  839. {

  840.     const uint8 d[] = { 0xff, 0x20, 0x01, (uint8) jlimit (0, 0xff, channel - 1) };

  841.     return MidiMessage (d, 4, 0.0);

  842. }

  843. 

  844. bool MidiMessage::isKeySignatureMetaEvent() const noexcept

  845. {

  846.     return getMetaEventType() == 0x59;

  847. }

  848. 

  849. int MidiMessage::getKeySignatureNumberOfSharpsOrFlats() const noexcept

  850. {

  851.     return (int) (int8) getMetaEventData()[0];

  852. }

  853. 

  854. bool MidiMessage::isKeySignatureMajorKey() const noexcept

  855. {

  856.     return getMetaEventData()[1] == 0;

  857. }

  858. 

  859. MidiMessage MidiMessage::keySignatureMetaEvent (int numberOfSharpsOrFlats, bool isMinorKey)

  860. {

  861.     jassert (numberOfSharpsOrFlats >= -7 && numberOfSharpsOrFlats <= 7);

  862. 

  863.     const uint8 d[] = { 0xff, 0x59, 0x02, (uint8) numberOfSharpsOrFlats, isMinorKey ? (uint8) 1 : (uint8) 0 };

  864.     return MidiMessage (d, 5, 0.0);

  865. }

  866. 

  867. MidiMessage MidiMessage::endOfTrack() noexcept

  868. {

  869.     return MidiMessage (0xff, 0x2f, 0, 0.0);

  870. }

  871. 

  872. //==============================================================================

  873. bool MidiMessage::isSongPositionPointer() const noexcept         { return *getRawData() == 0xf2; }

  874. int MidiMessage::getSongPositionPointerMidiBeat() const noexcept { const uint8* data = getRawData(); return data[1] | (data[2] << 7); }

  875. 

  876. MidiMessage MidiMessage::songPositionPointer (const int positionInMidiBeats) noexcept

  877. {

  878.     return MidiMessage (0xf2,

  879.                         positionInMidiBeats & 127,

  880.                         (positionInMidiBeats >> 7) & 127);

  881. }

  882. 

  883. bool MidiMessage::isMidiStart() const noexcept            { return *getRawData() == 0xfa; }

  884. MidiMessage MidiMessage::midiStart() noexcept             { return MidiMessage (0xfa); }

  885. 

  886. bool MidiMessage::isMidiContinue() const noexcept         { return *getRawData() == 0xfb; }

  887. MidiMessage MidiMessage::midiContinue() noexcept          { return MidiMessage (0xfb); }

  888. 

  889. bool MidiMessage::isMidiStop() const noexcept             { return *getRawData() == 0xfc; }

  890. MidiMessage MidiMessage::midiStop() noexcept              { return MidiMessage (0xfc); }

  891. 

  892. bool MidiMessage::isMidiClock() const noexcept            { return *getRawData() == 0xf8; }

  893. MidiMessage MidiMessage::midiClock() noexcept             { return MidiMessage (0xf8); }

  894. 

  895. bool MidiMessage::isQuarterFrame() const noexcept               { return *getRawData() == 0xf1; }

  896. int MidiMessage::getQuarterFrameSequenceNumber() const noexcept { return ((int) getRawData()[1]) >> 4; }

  897. int MidiMessage::getQuarterFrameValue() const noexcept          { return ((int) getRawData()[1]) & 0x0f; }

  898. 

  899. MidiMessage MidiMessage::quarterFrame (const int sequenceNumber, const int value) noexcept

  900. {

  901.     return MidiMessage (0xf1, (sequenceNumber << 4) | value);

  902. }

  903. 

  904. bool MidiMessage::isFullFrame() const noexcept

  905. {

  906.     const uint8* const data = getRawData();

  907. 

  908.     return data[0] == 0xf0

  909.             && data[1] == 0x7f

  910.             && size >= 10

  911.             && data[3] == 0x01

  912.             && data[4] == 0x01;

  913. }

  914. 

  915. void MidiMessage::getFullFrameParameters (int& hours, int& minutes, int& seconds, int& frames,

  916.                                           MidiMessage::SmpteTimecodeType& timecodeType) const noexcept

  917. {

  918.     jassert (isFullFrame());

  919. 

  920.     const uint8* const data = getRawData();

  921.     timecodeType = (SmpteTimecodeType) (data[5] >> 5);

  922.     hours   = data[5] & 0x1f;

  923.     minutes = data[6];

  924.     seconds = data[7];

  925.     frames  = data[8];

  926. }

  927. 

  928. MidiMessage MidiMessage::fullFrame (const int hours, const int minutes,

  929.                                     const int seconds, const int frames,

  930.                                     MidiMessage::SmpteTimecodeType timecodeType)

  931. {

  932.     const uint8 d[] = { 0xf0, 0x7f, 0x7f, 0x01, 0x01,

  933.                         (uint8) ((hours & 0x01f) | (timecodeType << 5)),

  934.                         (uint8) minutes,

  935.                         (uint8) seconds,

  936.                         (uint8) frames,

  937.                         0xf7 };

  938. 

  939.     return MidiMessage (d, 10, 0.0);

  940. }

  941. 

  942. bool MidiMessage::isMidiMachineControlMessage() const noexcept

  943. {

  944.     const uint8* const data = getRawData();

  945.     return data[0] == 0xf0

  946.         && data[1] == 0x7f

  947.         && data[3] == 0x06

  948.         && size > 5;

  949. }

  950. 

  951. MidiMessage::MidiMachineControlCommand MidiMessage::getMidiMachineControlCommand() const noexcept

  952. {

  953.     jassert (isMidiMachineControlMessage());

  954. 

  955.     return (MidiMachineControlCommand) getRawData()[4];

  956. }

  957. 

  958. MidiMessage MidiMessage::midiMachineControlCommand (MidiMessage::MidiMachineControlCommand command)

  959. {

  960.     const uint8 d[] = { 0xf0, 0x7f, 0, 6, (uint8) command, 0xf7 };

  961. 

  962.     return MidiMessage (d, 6, 0.0);

  963. }

  964. 

  965. //==============================================================================

  966. bool MidiMessage::isMidiMachineControlGoto (int& hours, int& minutes, int& seconds, int& frames) const noexcept

  967. {

  968.     const uint8* const data = getRawData();

  969.     if (size >= 12

  970.          && data[0] == 0xf0

  971.          && data[1] == 0x7f

  972.          && data[3] == 0x06

  973.          && data[4] == 0x44

  974.          && data[5] == 0x06

  975.          && data[6] == 0x01)

  976.     {

  977.         hours = data[7] % 24;   // (that some machines send out hours > 24)

  978.         minutes = data[8];

  979.         seconds = data[9];

  980.         frames = data[10];

  981. 

  982.         return true;

  983.     }

  984. 

  985.     return false;

  986. }

  987. 

  988. MidiMessage MidiMessage::midiMachineControlGoto (int hours, int minutes, int seconds, int frames)

  989. {

  990.     const uint8 d[] = { 0xf0, 0x7f, 0, 6, 0x44, 6, 1,

  991.                         (uint8) hours,

  992.                         (uint8) minutes,

  993.                         (uint8) seconds,

  994.                         (uint8) frames,

  995.                         0xf7 };

  996. 

  997.     return MidiMessage (d, 12, 0.0);

  998. }

  999. 

  1000. //==============================================================================

  1001. String MidiMessage::getMidiNoteName (int note, bool useSharps, bool includeOctaveNumber, int octaveNumForMiddleC)

  1002. {

  1003.     static const char* const sharpNoteNames[] = { "C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B" };

  1004.     static const char* const flatNoteNames[]  = { "C", "Db", "D", "Eb", "E", "F", "Gb", "G", "Ab", "A", "Bb", "B" };

  1005. 

  1006.     if (isPositiveAndBelow (note, (int) 128))

  1007.     {

  1008.         String s (useSharps ? sharpNoteNames [note % 12]

  1009.                             : flatNoteNames  [note % 12]);

  1010. 

  1011.         if (includeOctaveNumber)

  1012.             s << (note / 12 + (octaveNumForMiddleC - 5));

  1013. 

  1014.         return s;

  1015.     }

  1016. 

  1017.     return String();

  1018. }

  1019. 

  1020. double MidiMessage::getMidiNoteInHertz (const int noteNumber, const double frequencyOfA) noexcept

  1021. {

  1022.     return frequencyOfA * pow (2.0, (noteNumber - 69) / 12.0);

  1023. }

  1024. 

  1025. bool MidiMessage::isMidiNoteBlack (int noteNumber) noexcept

  1026. {

  1027.     return ((1 << (noteNumber % 12)) & 0x054a) != 0;

  1028. }

  1029. 

  1030. const char* MidiMessage::getGMInstrumentName (const int n)

  1031. {

  1032.     static const char* names[] =

  1033.     {

  1034.         NEEDS_TRANS("Acoustic Grand Piano"),    NEEDS_TRANS("Bright Acoustic Piano"),   NEEDS_TRANS("Electric Grand Piano"),    NEEDS_TRANS("Honky-tonk Piano"),

  1035.         NEEDS_TRANS("Electric Piano 1"),        NEEDS_TRANS("Electric Piano 2"),        NEEDS_TRANS("Harpsichord"),             NEEDS_TRANS("Clavinet"),

  1036.         NEEDS_TRANS("Celesta"),                 NEEDS_TRANS("Glockenspiel"),            NEEDS_TRANS("Music Box"),               NEEDS_TRANS("Vibraphone"),

  1037.         NEEDS_TRANS("Marimba"),                 NEEDS_TRANS("Xylophone"),               NEEDS_TRANS("Tubular Bells"),           NEEDS_TRANS("Dulcimer"),

  1038.         NEEDS_TRANS("Drawbar Organ"),           NEEDS_TRANS("Percussive Organ"),        NEEDS_TRANS("Rock Organ"),              NEEDS_TRANS("Church Organ"),

  1039.         NEEDS_TRANS("Reed Organ"),              NEEDS_TRANS("Accordion"),               NEEDS_TRANS("Harmonica"),               NEEDS_TRANS("Tango Accordion"),

  1040.         NEEDS_TRANS("Acoustic Guitar (nylon)"), NEEDS_TRANS("Acoustic Guitar (steel)"), NEEDS_TRANS("Electric Guitar (jazz)"),  NEEDS_TRANS("Electric Guitar (clean)"),

  1041.         NEEDS_TRANS("Electric Guitar (mute)"),  NEEDS_TRANS("Overdriven Guitar"),       NEEDS_TRANS("Distortion Guitar"),       NEEDS_TRANS("Guitar Harmonics"),

  1042.         NEEDS_TRANS("Acoustic Bass"),           NEEDS_TRANS("Electric Bass (finger)"),  NEEDS_TRANS("Electric Bass (pick)"),    NEEDS_TRANS("Fretless Bass"),

  1043.         NEEDS_TRANS("Slap Bass 1"),             NEEDS_TRANS("Slap Bass 2"),             NEEDS_TRANS("Synth Bass 1"),            NEEDS_TRANS("Synth Bass 2"),

  1044.         NEEDS_TRANS("Violin"),                  NEEDS_TRANS("Viola"),                   NEEDS_TRANS("Cello"),                   NEEDS_TRANS("Contrabass"),

  1045.         NEEDS_TRANS("Tremolo Strings"),         NEEDS_TRANS("Pizzicato Strings"),       NEEDS_TRANS("Orchestral Harp"),         NEEDS_TRANS("Timpani"),

  1046.         NEEDS_TRANS("String Ensemble 1"),       NEEDS_TRANS("String Ensemble 2"),       NEEDS_TRANS("SynthStrings 1"),          NEEDS_TRANS("SynthStrings 2"),

  1047.         NEEDS_TRANS("Choir Aahs"),              NEEDS_TRANS("Voice Oohs"),              NEEDS_TRANS("Synth Voice"),             NEEDS_TRANS("Orchestra Hit"),

  1048.         NEEDS_TRANS("Trumpet"),                 NEEDS_TRANS("Trombone"),                NEEDS_TRANS("Tuba"),                    NEEDS_TRANS("Muted Trumpet"),

  1049.         NEEDS_TRANS("French Horn"),             NEEDS_TRANS("Brass Section"),           NEEDS_TRANS("SynthBrass 1"),            NEEDS_TRANS("SynthBrass 2"),

  1050.         NEEDS_TRANS("Soprano Sax"),             NEEDS_TRANS("Alto Sax"),                NEEDS_TRANS("Tenor Sax"),               NEEDS_TRANS("Baritone Sax"),

  1051.         NEEDS_TRANS("Oboe"),                    NEEDS_TRANS("English Horn"),            NEEDS_TRANS("Bassoon"),                 NEEDS_TRANS("Clarinet"),

  1052.         NEEDS_TRANS("Piccolo"),                 NEEDS_TRANS("Flute"),                   NEEDS_TRANS("Recorder"),                NEEDS_TRANS("Pan Flute"),

  1053.         NEEDS_TRANS("Blown Bottle"),            NEEDS_TRANS("Shakuhachi"),              NEEDS_TRANS("Whistle"),                 NEEDS_TRANS("Ocarina"),

  1054.         NEEDS_TRANS("Lead 1 (square)"),         NEEDS_TRANS("Lead 2 (sawtooth)"),       NEEDS_TRANS("Lead 3 (calliope)"),       NEEDS_TRANS("Lead 4 (chiff)"),

  1055.         NEEDS_TRANS("Lead 5 (charang)"),        NEEDS_TRANS("Lead 6 (voice)"),          NEEDS_TRANS("Lead 7 (fifths)"),         NEEDS_TRANS("Lead 8 (bass+lead)"),

  1056.         NEEDS_TRANS("Pad 1 (new age)"),         NEEDS_TRANS("Pad 2 (warm)"),            NEEDS_TRANS("Pad 3 (polysynth)"),       NEEDS_TRANS("Pad 4 (choir)"),

  1057.         NEEDS_TRANS("Pad 5 (bowed)"),           NEEDS_TRANS("Pad 6 (metallic)"),        NEEDS_TRANS("Pad 7 (halo)"),            NEEDS_TRANS("Pad 8 (sweep)"),

  1058.         NEEDS_TRANS("FX 1 (rain)"),             NEEDS_TRANS("FX 2 (soundtrack)"),       NEEDS_TRANS("FX 3 (crystal)"),          NEEDS_TRANS("FX 4 (atmosphere)"),

  1059.         NEEDS_TRANS("FX 5 (brightness)"),       NEEDS_TRANS("FX 6 (goblins)"),          NEEDS_TRANS("FX 7 (echoes)"),           NEEDS_TRANS("FX 8 (sci-fi)"),

  1060.         NEEDS_TRANS("Sitar"),                   NEEDS_TRANS("Banjo"),                   NEEDS_TRANS("Shamisen"),                NEEDS_TRANS("Koto"),

  1061.         NEEDS_TRANS("Kalimba"),                 NEEDS_TRANS("Bag pipe"),                NEEDS_TRANS("Fiddle"),                  NEEDS_TRANS("Shanai"),

  1062.         NEEDS_TRANS("Tinkle Bell"),             NEEDS_TRANS("Agogo"),                   NEEDS_TRANS("Steel Drums"),             NEEDS_TRANS("Woodblock"),

  1063.         NEEDS_TRANS("Taiko Drum"),              NEEDS_TRANS("Melodic Tom"),             NEEDS_TRANS("Synth Drum"),              NEEDS_TRANS("Reverse Cymbal"),

  1064.         NEEDS_TRANS("Guitar Fret Noise"),       NEEDS_TRANS("Breath Noise"),            NEEDS_TRANS("Seashore"),                NEEDS_TRANS("Bird Tweet"),

  1065.         NEEDS_TRANS("Telephone Ring"),          NEEDS_TRANS("Helicopter"),              NEEDS_TRANS("Applause"),                NEEDS_TRANS("Gunshot")

  1066.     };

  1067. 

  1068.     return isPositiveAndBelow (n, numElementsInArray (names)) ? names[n] : nullptr;

  1069. }

  1070. 

  1071. const char* MidiMessage::getGMInstrumentBankName (const int n)

  1072. {

  1073.     static const char* names[] =

  1074.     {

  1075.         NEEDS_TRANS("Piano"),           NEEDS_TRANS("Chromatic Percussion"),    NEEDS_TRANS("Organ"),       NEEDS_TRANS("Guitar"),

  1076.         NEEDS_TRANS("Bass"),            NEEDS_TRANS("Strings"),                 NEEDS_TRANS("Ensemble"),    NEEDS_TRANS("Brass"),

  1077.         NEEDS_TRANS("Reed"),            NEEDS_TRANS("Pipe"),                    NEEDS_TRANS("Synth Lead"),  NEEDS_TRANS("Synth Pad"),

  1078.         NEEDS_TRANS("Synth Effects"),   NEEDS_TRANS("Ethnic"),                  NEEDS_TRANS("Percussive"),  NEEDS_TRANS("Sound Effects")

  1079.     };

  1080. 

  1081.     return isPositiveAndBelow (n, numElementsInArray (names)) ? names[n] : nullptr;

  1082. }

  1083. 

  1084. const char* MidiMessage::getRhythmInstrumentName (const int n)

  1085. {

  1086.     static const char* names[] =

  1087.     {

  1088.         NEEDS_TRANS("Acoustic Bass Drum"),  NEEDS_TRANS("Bass Drum 1"),     NEEDS_TRANS("Side Stick"),      NEEDS_TRANS("Acoustic Snare"),

  1089.         NEEDS_TRANS("Hand Clap"),           NEEDS_TRANS("Electric Snare"),  NEEDS_TRANS("Low Floor Tom"),   NEEDS_TRANS("Closed Hi-Hat"),

  1090.         NEEDS_TRANS("High Floor Tom"),      NEEDS_TRANS("Pedal Hi-Hat"),    NEEDS_TRANS("Low Tom"),         NEEDS_TRANS("Open Hi-Hat"),

  1091.         NEEDS_TRANS("Low-Mid Tom"),         NEEDS_TRANS("Hi-Mid Tom"),      NEEDS_TRANS("Crash Cymbal 1"),  NEEDS_TRANS("High Tom"),

  1092.         NEEDS_TRANS("Ride Cymbal 1"),       NEEDS_TRANS("Chinese Cymbal"),  NEEDS_TRANS("Ride Bell"),       NEEDS_TRANS("Tambourine"),

  1093.         NEEDS_TRANS("Splash Cymbal"),       NEEDS_TRANS("Cowbell"),         NEEDS_TRANS("Crash Cymbal 2"),  NEEDS_TRANS("Vibraslap"),

  1094.         NEEDS_TRANS("Ride Cymbal 2"),       NEEDS_TRANS("Hi Bongo"),        NEEDS_TRANS("Low Bongo"),       NEEDS_TRANS("Mute Hi Conga"),

  1095.         NEEDS_TRANS("Open Hi Conga"),       NEEDS_TRANS("Low Conga"),       NEEDS_TRANS("High Timbale"),    NEEDS_TRANS("Low Timbale"),

  1096.         NEEDS_TRANS("High Agogo"),          NEEDS_TRANS("Low Agogo"),       NEEDS_TRANS("Cabasa"),          NEEDS_TRANS("Maracas"),

  1097.         NEEDS_TRANS("Short Whistle"),       NEEDS_TRANS("Long Whistle"),    NEEDS_TRANS("Short Guiro"),     NEEDS_TRANS("Long Guiro"),

  1098.         NEEDS_TRANS("Claves"),              NEEDS_TRANS("Hi Wood Block"),   NEEDS_TRANS("Low Wood Block"),  NEEDS_TRANS("Mute Cuica"),

  1099.         NEEDS_TRANS("Open Cuica"),          NEEDS_TRANS("Mute Triangle"),   NEEDS_TRANS("Open Triangle")

  1100.     };

  1101. 

  1102.     return (n >= 35 && n <= 81) ? names [n - 35] : nullptr;

  1103. }

  1104. 

  1105. const char* MidiMessage::getControllerName (const int n)

  1106. {

  1107.     static const char* names[] =

  1108.     {

  1109.         NEEDS_TRANS("Bank Select"), NEEDS_TRANS("Modulation Wheel (coarse)"), NEEDS_TRANS("Breath controller (coarse)"),

  1110.         nullptr,

  1111.         NEEDS_TRANS("Foot Pedal (coarse)"), NEEDS_TRANS("Portamento Time (coarse)"), NEEDS_TRANS("Data Entry (coarse)"),

  1112.         NEEDS_TRANS("Volume (coarse)"), NEEDS_TRANS("Balance (coarse)"),

  1113.         nullptr,

  1114.         NEEDS_TRANS("Pan position (coarse)"), NEEDS_TRANS("Expression (coarse)"), NEEDS_TRANS("Effect Control 1 (coarse)"),

  1115.         NEEDS_TRANS("Effect Control 2 (coarse)"),

  1116.         nullptr, nullptr,

  1117.         NEEDS_TRANS("General Purpose Slider 1"), NEEDS_TRANS("General Purpose Slider 2"),

  1118.         NEEDS_TRANS("General Purpose Slider 3"), NEEDS_TRANS("General Purpose Slider 4"),

  1119.         nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,

  1120.         NEEDS_TRANS("Bank Select (fine)"), NEEDS_TRANS("Modulation Wheel (fine)"), NEEDS_TRANS("Breath controller (fine)"),

  1121.         nullptr,

  1122.         NEEDS_TRANS("Foot Pedal (fine)"), NEEDS_TRANS("Portamento Time (fine)"), NEEDS_TRANS("Data Entry (fine)"), NEEDS_TRANS("Volume (fine)"),

  1123.         NEEDS_TRANS("Balance (fine)"), nullptr, NEEDS_TRANS("Pan position (fine)"), NEEDS_TRANS("Expression (fine)"),

  1124.         NEEDS_TRANS("Effect Control 1 (fine)"), NEEDS_TRANS("Effect Control 2 (fine)"),

  1125.         nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,

  1126.         nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,

  1127.         NEEDS_TRANS("Hold Pedal (on/off)"), NEEDS_TRANS("Portamento (on/off)"), NEEDS_TRANS("Sustenuto Pedal (on/off)"), NEEDS_TRANS("Soft Pedal (on/off)"),

  1128.         NEEDS_TRANS("Legato Pedal (on/off)"), NEEDS_TRANS("Hold 2 Pedal (on/off)"), NEEDS_TRANS("Sound Variation"), NEEDS_TRANS("Sound Timbre"),

  1129.         NEEDS_TRANS("Sound Release Time"), NEEDS_TRANS("Sound Attack Time"), NEEDS_TRANS("Sound Brightness"), NEEDS_TRANS("Sound Control 6"),

  1130.         NEEDS_TRANS("Sound Control 7"), NEEDS_TRANS("Sound Control 8"), NEEDS_TRANS("Sound Control 9"), NEEDS_TRANS("Sound Control 10"),

  1131.         NEEDS_TRANS("General Purpose Button 1 (on/off)"), NEEDS_TRANS("General Purpose Button 2 (on/off)"),

  1132.         NEEDS_TRANS("General Purpose Button 3 (on/off)"), NEEDS_TRANS("General Purpose Button 4 (on/off)"),

  1133.         nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,

  1134.         NEEDS_TRANS("Reverb Level"), NEEDS_TRANS("Tremolo Level"), NEEDS_TRANS("Chorus Level"), NEEDS_TRANS("Celeste Level"),

  1135.         NEEDS_TRANS("Phaser Level"), NEEDS_TRANS("Data Button increment"), NEEDS_TRANS("Data Button decrement"), NEEDS_TRANS("Non-registered Parameter (fine)"),

  1136.         NEEDS_TRANS("Non-registered Parameter (coarse)"), NEEDS_TRANS("Registered Parameter (fine)"), NEEDS_TRANS("Registered Parameter (coarse)"),

  1137.         nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,

  1138.         nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,

  1139.         NEEDS_TRANS("All Sound Off"), NEEDS_TRANS("All Controllers Off"), NEEDS_TRANS("Local Keyboard (on/off)"), NEEDS_TRANS("All Notes Off"),

  1140.         NEEDS_TRANS("Omni Mode Off"), NEEDS_TRANS("Omni Mode On"), NEEDS_TRANS("Mono Operation"), NEEDS_TRANS("Poly Operation")

  1141.     };

  1142. 

  1143.     return isPositiveAndBelow (n, numElementsInArray (names)) ? names[n] : nullptr;

  1144. }