DISTRHO
/
JUCE
mirror of https://github.com/DISTRHO/JUCE
1
0
Fork 0
Code Releases 1 Activity
The JUCE cross-platform C++ framework, with DISTRHO/KXStudio specific changes
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.
6278 Commits
9 Branches
401MB
Tree: 07bc151ce3
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '07bc151ce3'
${ noResults }
JUCE/modules/juce_audio_basics/midi/juce_MidiMessage.cpp

1149 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 pitchbend > 0.0f ? jmap (pitchbend, 0.0f, pitchbendRange, 8192.0f, 16383.0f)

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

  52. }

  53. 

  54. //==============================================================================

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

  56. {

  57.     numBytesUsed = 0;

  58.     int v = 0, i;

  59. 

  60.     do

  61.     {

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

  63. 

  64.         if (++numBytesUsed > 6)

  65.             break;

  66. 

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

  68. 

  69.     } while (i & 0x80);

  70. 

  71.     return v;

  72. }

  73. 

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

  75. {

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

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

  78. 

  79.     static const char messageLengths[] =

  80.     {

  81.         3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,

  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.         2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

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

  87.         3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,

  88.         1, 2, 3, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1

  89.     };

  90. 

  91.     return messageLengths [firstByte & 0x7f];

  92. }

  93. 

  94. //==============================================================================

  95. MidiMessage::MidiMessage() noexcept

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

  97. {

  98.     preallocatedData.asBytes[0] = 0xf0;

  99.     preallocatedData.asBytes[1] = 0xf7;

  100. }

  101. 

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

  103.    : timeStamp (t),

  104.      size (dataSize)

  105. {

  106.     jassert (dataSize > 0);

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

  108. 

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

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

  111. }

  112. 

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

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

  115. {

  116.     preallocatedData.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.     preallocatedData.asBytes[0] = (uint8) byte1;

  126.     preallocatedData.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.     preallocatedData.asBytes[0] = (uint8) byte1;

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

  137.     preallocatedData.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 (other.allocatedData != nullptr)

  147.     {

  148.         allocatedData.malloc ((size_t) size);

  149.         memcpy (allocatedData, other.allocatedData, (size_t) size);

  150.     }

  151.     else

  152.     {

  153.         preallocatedData.asInt32 = other.preallocatedData.asInt32;

  154.     }

  155. }

  156. 

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

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

  159. {

  160.     if (other.allocatedData != nullptr)

  161.     {

  162.         allocatedData.malloc ((size_t) size);

  163.         memcpy (allocatedData, other.allocatedData, (size_t) size);

  164.     }

  165.     else

  166.     {

  167.         preallocatedData.asInt32 = other.preallocatedData.asInt32;

  168.     }

  169. }

  170. 

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

  172.                           double t, bool sysexHasEmbeddedLength)

  173.     : timeStamp (t)

  174. {

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

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

  177. 

  178.     if (byte < 0x80)

  179.     {

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

  181.         numBytesUsed = -1;

  182.     }

  183.     else

  184.     {

  185.         numBytesUsed = 0;

  186.         --sz;

  187.         ++src;

  188.     }

  189. 

  190.     if (byte >= 0x80)

  191.     {

  192.         if (byte == 0xf0)

  193.         {

  194.             const uint8* d = src;

  195.             bool haveReadAllLengthBytes = ! sysexHasEmbeddedLength;

  196.             int numVariableLengthSysexBytes = 0;

  197. 

  198.             while (d < src + sz)

  199.             {

  200.                 if (*d >= 0x80)

  201.                 {

  202.                     if (*d == 0xf7)

  203.                     {

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

  205.                         break;

  206.                     }

  207. 

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

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

  210. 

  211.                     ++numVariableLengthSysexBytes;

  212.                 }

  213.                 else if (! haveReadAllLengthBytes)

  214.                 {

  215.                     haveReadAllLengthBytes = true;

  216.                     ++numVariableLengthSysexBytes;

  217.                 }

  218. 

  219.                 ++d;

  220.             }

  221. 

  222.             src += numVariableLengthSysexBytes;

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

  224. 

  225.             uint8* dest = allocateSpace (size);

  226.             *dest = (uint8) byte;

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

  228. 

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

  230.         }

  231.         else if (byte == 0xff)

  232.         {

  233.             int n;

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

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

  236. 

  237.             uint8* dest = allocateSpace (size);

  238.             *dest = (uint8) byte;

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

  240.         }

  241.         else

  242.         {

  243.             preallocatedData.asInt32 = 0;

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

  245.             preallocatedData.asBytes[0] = (uint8) byte;

  246. 

  247.             if (size > 1)

  248.             {

  249.                 preallocatedData.asBytes[1] = src[0];

  250. 

  251.                 if (size > 2)

  252.                     preallocatedData.asBytes[2] = src[1];

  253.             }

  254.         }

  255. 

  256.         numBytesUsed += size;

  257.     }

  258.     else

  259.     {

  260.         preallocatedData.asInt32 = 0;

  261.         size = 0;

  262.     }

  263. }

  264. 

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

  266. {

  267.     if (this != &other)

  268.     {

  269.         timeStamp = other.timeStamp;

  270.         size = other.size;

  271. 

  272.         if (other.allocatedData != nullptr)

  273.         {

  274.             allocatedData.malloc ((size_t) size);

  275.             memcpy (allocatedData, other.allocatedData, (size_t) size);

  276.         }

  277.         else

  278.         {

  279.             allocatedData.free();

  280.             preallocatedData.asInt32 = other.preallocatedData.asInt32;

  281.         }

  282.     }

  283. 

  284.     return *this;

  285. }

  286. 

  287. #if JUCE_COMPILER_SUPPORTS_MOVE_SEMANTICS

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

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

  290. {

  291.     if (other.allocatedData != nullptr)

  292.         allocatedData.swapWith (other.allocatedData);

  293.     else

  294.         preallocatedData.asInt32 = other.preallocatedData.asInt32;

  295. }

  296. 

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

  298. {

  299.     jassert (this != &other); // shouldn't be possible

  300. 

  301.     timeStamp = other.timeStamp;

  302.     size = other.size;

  303.     allocatedData.swapWith (other.allocatedData);

  304.     preallocatedData.asInt32 = other.preallocatedData.asInt32;

  305. 

  306.     return *this;

  307. }

  308. #endif

  309. 

  310. MidiMessage::~MidiMessage() {}

  311. 

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

  313. {

  314.     if (bytes > 4)

  315.     {

  316.         allocatedData.malloc ((size_t) bytes);

  317.         return allocatedData;

  318.     }

  319. 

  320.     return preallocatedData.asBytes;

  321. }

  322. 

  323. String MidiMessage::getDescription() const

  324. {

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

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

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

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

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

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

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

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

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

  334. 

  335.     if (isController())

  336.     {

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

  338. 

  339.         if (name.isEmpty())

  340.             name = String (getControllerNumber());

  341. 

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

  343.     }

  344. 

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

  346. }

  347. 

  348. int MidiMessage::getChannel() const noexcept

  349. {

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

  351. 

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

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

  354. 

  355.     return 0;

  356. }

  357. 

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

  359. {

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

  361. 

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

  363. 

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

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

  366. }

  367. 

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

  369. {

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

  371. 

  372.     uint8* const data = getData();

  373. 

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

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

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

  377. }

  378. 

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

  380. {

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

  382. 

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

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

  385. }

  386. 

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

  388. {

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

  390. 

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

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

  393. }

  394. 

  395. bool MidiMessage::isNoteOnOrOff() const noexcept

  396. {

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

  398. 

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

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

  401. }

  402. 

  403. int MidiMessage::getNoteNumber() const noexcept

  404. {

  405.     return getRawData()[1];

  406. }

  407. 

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

  409. {

  410.     if (isNoteOnOrOff() || isAftertouch())

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

  412. }

  413. 

  414. uint8 MidiMessage::getVelocity() const noexcept

  415. {

  416.     if (isNoteOnOrOff())

  417.         return getRawData()[2];

  418. 

  419.     return 0;

  420. }

  421. 

  422. float MidiMessage::getFloatVelocity() const noexcept

  423. {

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

  425. }

  426. 

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

  428. {

  429.     if (isNoteOnOrOff())

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

  431. }

  432. 

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

  434. {

  435.     if (isNoteOnOrOff())

  436.     {

  437.         uint8* const data = getData();

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

  439.     }

  440. }

  441. 

  442. bool MidiMessage::isAftertouch() const noexcept

  443. {

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

  445. }

  446. 

  447. int MidiMessage::getAfterTouchValue() const noexcept

  448. {

  449.     jassert (isAftertouch());

  450.     return getRawData()[2];

  451. }

  452. 

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

  454.                                            const int noteNum,

  455.                                            const int aftertouchValue) noexcept

  456. {

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

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

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

  460. 

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

  462.                         noteNum & 0x7f,

  463.                         aftertouchValue & 0x7f);

  464. }

  465. 

  466. bool MidiMessage::isChannelPressure() const noexcept

  467. {

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

  469. }

  470. 

  471. int MidiMessage::getChannelPressureValue() const noexcept

  472. {

  473.     jassert (isChannelPressure());

  474.     return getRawData()[1];

  475. }

  476. 

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

  478. {

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

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

  481. 

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

  483. }

  484. 

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

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

  487. 

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

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

  490. 

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

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

  493. 

  494. 

  495. bool MidiMessage::isProgramChange() const noexcept

  496. {

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

  498. }

  499. 

  500. int MidiMessage::getProgramChangeNumber() const noexcept

  501. {

  502.     jassert (isProgramChange());

  503.     return getRawData()[1];

  504. }

  505. 

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

  507. {

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

  509. 

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

  511. }

  512. 

  513. bool MidiMessage::isPitchWheel() const noexcept

  514. {

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

  516. }

  517. 

  518. int MidiMessage::getPitchWheelValue() const noexcept

  519. {

  520.     jassert (isPitchWheel());

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

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

  523. }

  524. 

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

  526. {

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

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

  529. 

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

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

  532. }

  533. 

  534. bool MidiMessage::isController() const noexcept

  535. {

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

  537. }

  538. 

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

  540. {

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

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

  543. }

  544. 

  545. int MidiMessage::getControllerNumber() const noexcept

  546. {

  547.     jassert (isController());

  548.     return getRawData()[1];

  549. }

  550. 

  551. int MidiMessage::getControllerValue() const noexcept

  552. {

  553.     jassert (isController());

  554.     return getRawData()[2];

  555. }

  556. 

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

  558. {

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

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

  561. 

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

  563.                         controllerType & 127, value & 127);

  564. }

  565. 

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

  567. {

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

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

  570. 

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

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

  573. }

  574. 

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

  576. {

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

  578. }

  579. 

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

  581. {

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

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

  584. 

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

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

  587. }

  588. 

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

  590. {

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

  592. }

  593. 

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

  595. {

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

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

  598. 

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

  600. }

  601. 

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

  603. {

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

  605. }

  606. 

  607. bool MidiMessage::isAllNotesOff() const noexcept

  608. {

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

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

  611. }

  612. 

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

  614. {

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

  616. }

  617. 

  618. bool MidiMessage::isAllSoundOff() const noexcept

  619. {

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

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

  622. }

  623. 

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

  625. {

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

  627. }

  628. 

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

  630. {

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

  632. 

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

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

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

  636.                           0xf7 };

  637. 

  638.     return MidiMessage (buf, 8);

  639. }

  640. 

  641. //==============================================================================

  642. bool MidiMessage::isSysEx() const noexcept

  643. {

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

  645. }

  646. 

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

  648. {

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

  650. 

  651.     m[0] = 0xf0;

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

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

  654. 

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

  656. }

  657. 

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

  659. {

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

  661. }

  662. 

  663. int MidiMessage::getSysExDataSize() const noexcept

  664. {

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

  666. }

  667. 

  668. //==============================================================================

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

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

  671. 

  672. int MidiMessage::getMetaEventType() const noexcept

  673. {

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

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

  676. }

  677. 

  678. int MidiMessage::getMetaEventLength() const noexcept

  679. {

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

  681.     if (*data == 0xff)

  682.     {

  683.         int n;

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

  685.     }

  686. 

  687.     return 0;

  688. }

  689. 

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

  691. {

  692.     jassert (isMetaEvent());

  693. 

  694.     int n;

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

  696.     readVariableLengthVal (d, n);

  697.     return d + n;

  698. }

  699. 

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

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

  702. 

  703. bool MidiMessage::isTextMetaEvent() const noexcept

  704. {

  705.     const int t = getMetaEventType();

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

  707. }

  708. 

  709. String MidiMessage::getTextFromTextMetaEvent() const

  710. {

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

  712.     return String (CharPointer_UTF8 (textData),

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

  714. }

  715. 

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

  717. {

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

  719. 

  720.     MidiMessage result;

  721. 

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

  723. 

  724.     uint8 header[8];

  725.     size_t n = sizeof (header);

  726. 

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

  728. 

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

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

  731. 

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

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

  734. 

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

  736. 

  737.     uint8* const dest = result.allocateSpace ((int) (headerLen + textSize));

  738.     result.size = (int) (headerLen + textSize);

  739. 

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

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

  742. 

  743.     return result;

  744. }

  745. 

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

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

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

  749. 

  750. int MidiMessage::getMidiChannelMetaEventChannel() const noexcept

  751. {

  752.     jassert (isMidiChannelMetaEvent());

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

  754. }

  755. 

  756. double MidiMessage::getTempoSecondsPerQuarterNote() const noexcept

  757. {

  758.     if (! isTempoMetaEvent())

  759.         return 0.0;

  760. 

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

  762. 

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

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

  765.              | d[2])

  766.             / 1000000.0;

  767. }

  768. 

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

  770. {

  771.     if (timeFormat > 0)

  772.     {

  773.         if (! isTempoMetaEvent())

  774.             return 0.5 / timeFormat;

  775. 

  776.         return getTempoSecondsPerQuarterNote() / timeFormat;

  777.     }

  778.     else

  779.     {

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

  781.         double framesPerSecond;

  782. 

  783.         switch (frameCode)

  784.         {

  785.             case 24: framesPerSecond = 24.0;   break;

  786.             case 25: framesPerSecond = 25.0;   break;

  787.             case 29: framesPerSecond = 29.97;  break;

  788.             case 30: framesPerSecond = 30.0;   break;

  789.             default: framesPerSecond = 30.0;   break;

  790.         }

  791. 

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

  793.     }

  794. }

  795. 

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

  797. {

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

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

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

  801.                         (uint8) microsecondsPerQuarterNote };

  802. 

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

  804. }

  805. 

  806. bool MidiMessage::isTimeSignatureMetaEvent() const noexcept

  807. {

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

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

  810. }

  811. 

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

  813. {

  814.     if (isTimeSignatureMetaEvent())

  815.     {

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

  817.         numerator = d[0];

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

  819.     }

  820.     else

  821.     {

  822.         numerator = 4;

  823.         denominator = 4;

  824.     }

  825. }

  826. 

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

  828. {

  829.     int n = 1;

  830.     int powerOfTwo = 0;

  831. 

  832.     while (n < denominator)

  833.     {

  834.         n <<= 1;

  835.         ++powerOfTwo;

  836.     }

  837. 

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

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

  840. }

  841. 

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

  843. {

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

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

  846. }

  847. 

  848. bool MidiMessage::isKeySignatureMetaEvent() const noexcept

  849. {

  850.     return getMetaEventType() == 0x59;

  851. }

  852. 

  853. int MidiMessage::getKeySignatureNumberOfSharpsOrFlats() const noexcept

  854. {

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

  856. }

  857. 

  858. bool MidiMessage::isKeySignatureMajorKey() const noexcept

  859. {

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

  861. }

  862. 

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

  864. {

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

  866. 

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

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

  869. }

  870. 

  871. MidiMessage MidiMessage::endOfTrack() noexcept

  872. {

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

  874. }

  875. 

  876. //==============================================================================

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

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

  879. 

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

  881. {

  882.     return MidiMessage (0xf2,

  883.                         positionInMidiBeats & 127,

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

  885. }

  886. 

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

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

  889. 

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

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

  892. 

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

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

  895. 

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

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

  898. 

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

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

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

  902. 

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

  904. {

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

  906. }

  907. 

  908. bool MidiMessage::isFullFrame() const noexcept

  909. {

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

  911. 

  912.     return data[0] == 0xf0

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

  914.             && size >= 10

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

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

  917. }

  918. 

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

  920.                                           MidiMessage::SmpteTimecodeType& timecodeType) const noexcept

  921. {

  922.     jassert (isFullFrame());

  923. 

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

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

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

  927.     minutes = data[6];

  928.     seconds = data[7];

  929.     frames  = data[8];

  930. }

  931. 

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

  933.                                     const int seconds, const int frames,

  934.                                     MidiMessage::SmpteTimecodeType timecodeType)

  935. {

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

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

  938.                         (uint8) minutes,

  939.                         (uint8) seconds,

  940.                         (uint8) frames,

  941.                         0xf7 };

  942. 

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

  944. }

  945. 

  946. bool MidiMessage::isMidiMachineControlMessage() const noexcept

  947. {

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

  949.     return data[0] == 0xf0

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

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

  952.         && size > 5;

  953. }

  954. 

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

  956. {

  957.     jassert (isMidiMachineControlMessage());

  958. 

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

  960. }

  961. 

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

  963. {

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

  965. 

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

  967. }

  968. 

  969. //==============================================================================

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

  971. {

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

  973.     if (size >= 12

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

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

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

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

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

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

  980.     {

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

  982.         minutes = data[8];

  983.         seconds = data[9];

  984.         frames = data[10];

  985. 

  986.         return true;

  987.     }

  988. 

  989.     return false;

  990. }

  991. 

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

  993. {

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

  995.                         (uint8) hours,

  996.                         (uint8) minutes,

  997.                         (uint8) seconds,

  998.                         (uint8) frames,

  999.                         0xf7 };

  1000. 

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

  1002. }

  1003. 

  1004. //==============================================================================

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

  1006. {

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

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

  1009. 

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

  1011.     {

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

  1013.                             : flatNoteNames  [note % 12]);

  1014. 

  1015.         if (includeOctaveNumber)

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

  1017. 

  1018.         return s;

  1019.     }

  1020. 

  1021.     return String();

  1022. }

  1023. 

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

  1025. {

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

  1027. }

  1028. 

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

  1030. {

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

  1032. }

  1033. 

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

  1035. {

  1036.     static const char* names[] =

  1037.     {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  1070.     };

  1071. 

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

  1073. }

  1074. 

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

  1076. {

  1077.     static const char* names[] =

  1078.     {

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

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

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

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

  1083.     };

  1084. 

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

  1086. }

  1087. 

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

  1089. {

  1090.     static const char* names[] =

  1091.     {

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

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

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

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

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

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

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

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

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

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

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

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

  1104.     };

  1105. 

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

  1107. }

  1108. 

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

  1110. {

  1111.     static const char* names[] =

  1112.     {

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

  1114.         nullptr,

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

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

  1117.         nullptr,

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

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

  1120.         nullptr, nullptr,

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

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

  1123.         nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,

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

  1125.         nullptr,

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

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

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

  1129.         nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,

  1130.         nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,

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

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

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

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

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

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

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

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

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

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

  1141.         nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,

  1142.         nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,

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

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

  1145.     };

  1146. 

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

  1148. }