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.
3702 Commits
16 Branches
275MB
Tree: be28e463e3
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'be28e463e3'
${ noResults }
Carla/source/modules/water/midi/juce_MidiMessage.cpp

1159 lines
44KB
Raw Blame History 

  1. /*

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

  3. 

  4.    This file is part of the JUCE library.

  5.    Copyright (c) 2016 - ROLI Ltd.

  6. 

  7.    Permission is granted to use this software under the terms of the ISC license

  8.    http://www.isc.org/downloads/software-support-policy/isc-license/

  9. 

  10.    Permission to use, copy, modify, and/or distribute this software for any

  11.    purpose with or without fee is hereby granted, provided that the above

  12.    copyright notice and this permission notice appear in all copies.

  13. 

  14.    THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH REGARD

  15.    TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND

  16.    FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT,

  17.    OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF

  18.    USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER

  19.    TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE

  20.    OF THIS SOFTWARE.

  21. 

  22.    -----------------------------------------------------------------------------

  23. 

  24.    To release a closed-source product which uses other parts of JUCE not

  25.    licensed under the ISC terms, commercial licenses are available: visit

  26.    www.juce.com for more information.

  27. 

  28.   ==============================================================================

  29. */

  30. 

  31. #include "juce_MidiMessage.h"

  32. #include "../maths/juce_MathsFunctions.h"

  33. #include "../memory/juce_HeapBlock.h"

  34. 

  35. namespace water {

  36. 

  37. namespace MidiHelpers

  38. {

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

  40.     {

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

  42.     }

  43. 

  44.     inline uint8 validVelocity (const int v) noexcept

  45.     {

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

  47.     }

  48. }

  49. 

  50. //==============================================================================

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

  52. {

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

  54. }

  55. 

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

  57.                                  const float pitchbendRange) noexcept

  58. {

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

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

  61. 

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

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

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

  65. }

  66. 

  67. //==============================================================================

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

  69. {

  70.     numBytesUsed = 0;

  71.     int v = 0, i;

  72. 

  73.     do

  74.     {

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

  76. 

  77.         if (++numBytesUsed > 6)

  78.             break;

  79. 

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

  81. 

  82.     } while (i & 0x80);

  83. 

  84.     return v;

  85. }

  86. 

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

  88. {

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

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

  91. 

  92.     static const char messageLengths[] =

  93.     {

  94.         3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,

  95.         3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,

  96.         3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,

  97.         3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,

  98.         2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

  99.         2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

  100.         3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,

  101.         1, 2, 3, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1

  102.     };

  103. 

  104.     return messageLengths [firstByte & 0x7f];

  105. }

  106. 

  107. //==============================================================================

  108. MidiMessage::MidiMessage() noexcept

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

  110. {

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

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

  113. }

  114. 

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

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

  117. {

  118.     jassert (dataSize > 0);

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

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

  121. 

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

  123. }

  124. 

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

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

  127. {

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

  129. 

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

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

  132. }

  133. 

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

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

  136. {

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

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

  139. 

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

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

  142. }

  143. 

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

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

  146. {

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

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

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

  150. 

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

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

  153. }

  154. 

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

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

  157. {

  158.     if (isHeapAllocated())

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

  160.     else

  161.         packedData.allocatedData = other.packedData.allocatedData;

  162. }

  163. 

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

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

  166. {

  167.     if (isHeapAllocated())

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

  169.     else

  170.         packedData.allocatedData = other.packedData.allocatedData;

  171. }

  172. 

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

  174.                           double t, bool sysexHasEmbeddedLength)

  175.     : timeStamp (t)

  176. {

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

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

  179. 

  180.     if (byte < 0x80)

  181.     {

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

  183.         numBytesUsed = -1;

  184.     }

  185.     else

  186.     {

  187.         numBytesUsed = 0;

  188.         --sz;

  189.         ++src;

  190.     }

  191. 

  192.     if (byte >= 0x80)

  193.     {

  194.         if (byte == 0xf0)

  195.         {

  196.             const uint8* d = src;

  197.             bool haveReadAllLengthBytes = ! sysexHasEmbeddedLength;

  198.             int numVariableLengthSysexBytes = 0;

  199. 

  200.             while (d < src + sz)

  201.             {

  202.                 if (*d >= 0x80)

  203.                 {

  204.                     if (*d == 0xf7)

  205.                     {

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

  207.                         break;

  208.                     }

  209. 

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

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

  212. 

  213.                     ++numVariableLengthSysexBytes;

  214.                 }

  215.                 else if (! haveReadAllLengthBytes)

  216.                 {

  217.                     haveReadAllLengthBytes = true;

  218.                     ++numVariableLengthSysexBytes;

  219.                 }

  220. 

  221.                 ++d;

  222.             }

  223. 

  224.             src += numVariableLengthSysexBytes;

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

  226. 

  227.             uint8* dest = allocateSpace (size);

  228.             *dest = (uint8) byte;

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

  230. 

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

  232.         }

  233.         else if (byte == 0xff)

  234.         {

  235.             int n;

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

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

  238. 

  239.             uint8* dest = allocateSpace (size);

  240.             *dest = (uint8) byte;

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

  242.         }

  243.         else

  244.         {

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

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

  247. 

  248.             if (size > 1)

  249.             {

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

  251. 

  252.                 if (size > 2)

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

  254.             }

  255.         }

  256. 

  257.         numBytesUsed += size;

  258.     }

  259.     else

  260.     {

  261.         packedData.allocatedData = nullptr;

  262.         size = 0;

  263.     }

  264. }

  265. 

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

  267. {

  268.     if (this != &other)

  269.     {

  270.         if (other.isHeapAllocated())

  271.         {

  272.             if (isHeapAllocated())

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

  274.             else

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

  276. 

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

  278.         }

  279.         else

  280.         {

  281.             if (isHeapAllocated())

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

  283. 

  284.             packedData.allocatedData = other.packedData.allocatedData;

  285.         }

  286. 

  287.         timeStamp = other.timeStamp;

  288.         size = other.size;

  289.     }

  290. 

  291.     return *this;

  292. }

  293. 

  294. #if JUCE_COMPILER_SUPPORTS_MOVE_SEMANTICS

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

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

  297. {

  298.     packedData.allocatedData = other.packedData.allocatedData;

  299.     other.size = 0;

  300. }

  301. 

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

  303. {

  304.     packedData.allocatedData = other.packedData.allocatedData;

  305.     timeStamp = other.timeStamp;

  306.     size = other.size;

  307.     other.size = 0;

  308.     return *this;

  309. }

  310. #endif

  311. 

  312. MidiMessage::~MidiMessage() noexcept

  313. {

  314.     if (isHeapAllocated())

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

  316. }

  317. 

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

  319. {

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

  321.     {

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

  323.         packedData.allocatedData = d;

  324.         return d;

  325.     }

  326. 

  327.     return packedData.asBytes;

  328. }

  329. 

  330. String MidiMessage::getDescription() const

  331. {

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

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

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

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

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

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

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

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

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

  341. 

  342.     if (isController())

  343.     {

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

  345. 

  346.         if (name.isEmpty())

  347.             name = String (getControllerNumber());

  348. 

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

  350.     }

  351. 

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

  353. }

  354. 

  355. int MidiMessage::getChannel() const noexcept

  356. {

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

  358. 

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

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

  361. 

  362.     return 0;

  363. }

  364. 

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

  366. {

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

  368. 

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

  370. 

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

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

  373. }

  374. 

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

  376. {

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

  378. 

  379.     uint8* const data = getData();

  380. 

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

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

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

  384. }

  385. 

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

  387. {

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

  389. 

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

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

  392. }

  393. 

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

  395. {

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

  397. 

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

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

  400. }

  401. 

  402. bool MidiMessage::isNoteOnOrOff() const noexcept

  403. {

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

  405. 

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

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

  408. }

  409. 

  410. int MidiMessage::getNoteNumber() const noexcept

  411. {

  412.     return getRawData()[1];

  413. }

  414. 

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

  416. {

  417.     if (isNoteOnOrOff() || isAftertouch())

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

  419. }

  420. 

  421. uint8 MidiMessage::getVelocity() const noexcept

  422. {

  423.     if (isNoteOnOrOff())

  424.         return getRawData()[2];

  425. 

  426.     return 0;

  427. }

  428. 

  429. float MidiMessage::getFloatVelocity() const noexcept

  430. {

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

  432. }

  433. 

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

  435. {

  436.     if (isNoteOnOrOff())

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

  438. }

  439. 

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

  441. {

  442.     if (isNoteOnOrOff())

  443.     {

  444.         uint8* const data = getData();

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

  446.     }

  447. }

  448. 

  449. bool MidiMessage::isAftertouch() const noexcept

  450. {

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

  452. }

  453. 

  454. int MidiMessage::getAfterTouchValue() const noexcept

  455. {

  456.     jassert (isAftertouch());

  457.     return getRawData()[2];

  458. }

  459. 

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

  461.                                            const int noteNum,

  462.                                            const int aftertouchValue) noexcept

  463. {

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

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

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

  467. 

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

  469.                         noteNum & 0x7f,

  470.                         aftertouchValue & 0x7f);

  471. }

  472. 

  473. bool MidiMessage::isChannelPressure() const noexcept

  474. {

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

  476. }

  477. 

  478. int MidiMessage::getChannelPressureValue() const noexcept

  479. {

  480.     jassert (isChannelPressure());

  481.     return getRawData()[1];

  482. }

  483. 

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

  485. {

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

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

  488. 

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

  490. }

  491. 

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

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

  494. 

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

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

  497. 

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

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

  500. 

  501. 

  502. bool MidiMessage::isProgramChange() const noexcept

  503. {

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

  505. }

  506. 

  507. int MidiMessage::getProgramChangeNumber() const noexcept

  508. {

  509.     jassert (isProgramChange());

  510.     return getRawData()[1];

  511. }

  512. 

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

  514. {

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

  516. 

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

  518. }

  519. 

  520. bool MidiMessage::isPitchWheel() const noexcept

  521. {

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

  523. }

  524. 

  525. int MidiMessage::getPitchWheelValue() const noexcept

  526. {

  527.     jassert (isPitchWheel());

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

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

  530. }

  531. 

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

  533. {

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

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

  536. 

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

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

  539. }

  540. 

  541. bool MidiMessage::isController() const noexcept

  542. {

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

  544. }

  545. 

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

  547. {

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

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

  550. }

  551. 

  552. int MidiMessage::getControllerNumber() const noexcept

  553. {

  554.     jassert (isController());

  555.     return getRawData()[1];

  556. }

  557. 

  558. int MidiMessage::getControllerValue() const noexcept

  559. {

  560.     jassert (isController());

  561.     return getRawData()[2];

  562. }

  563. 

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

  565. {

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

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

  568. 

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

  570.                         controllerType & 127, value & 127);

  571. }

  572. 

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

  574. {

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

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

  577. 

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

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

  580. }

  581. 

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

  583. {

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

  585. }

  586. 

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

  588. {

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

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

  591. 

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

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

  594. }

  595. 

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

  597. {

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

  599. }

  600. 

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

  602. {

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

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

  605. 

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

  607. }

  608. 

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

  610. {

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

  612. }

  613. 

  614. bool MidiMessage::isAllNotesOff() const noexcept

  615. {

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

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

  618. }

  619. 

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

  621. {

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

  623. }

  624. 

  625. bool MidiMessage::isAllSoundOff() const noexcept

  626. {

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

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

  629. }

  630. 

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

  632. {

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

  634. }

  635. 

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

  637. {

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

  639. 

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

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

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

  643.                           0xf7 };

  644. 

  645.     return MidiMessage (buf, 8);

  646. }

  647. 

  648. //==============================================================================

  649. bool MidiMessage::isSysEx() const noexcept

  650. {

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

  652. }

  653. 

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

  655. {

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

  657. 

  658.     m[0] = 0xf0;

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

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

  661. 

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

  663. }

  664. 

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

  666. {

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

  668. }

  669. 

  670. int MidiMessage::getSysExDataSize() const noexcept

  671. {

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

  673. }

  674. 

  675. //==============================================================================

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

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

  678. 

  679. int MidiMessage::getMetaEventType() const noexcept

  680. {

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

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

  683. }

  684. 

  685. int MidiMessage::getMetaEventLength() const noexcept

  686. {

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

  688.     if (*data == 0xff)

  689.     {

  690.         int n;

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

  692.     }

  693. 

  694.     return 0;

  695. }

  696. 

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

  698. {

  699.     jassert (isMetaEvent());

  700. 

  701.     int n;

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

  703.     readVariableLengthVal (d, n);

  704.     return d + n;

  705. }

  706. 

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

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

  709. 

  710. bool MidiMessage::isTextMetaEvent() const noexcept

  711. {

  712.     const int t = getMetaEventType();

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

  714. }

  715. 

  716. String MidiMessage::getTextFromTextMetaEvent() const

  717. {

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

  719.     return String (CharPointer_UTF8 (textData),

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

  721. }

  722. 

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

  724. {

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

  726. 

  727.     MidiMessage result;

  728. 

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

  730. 

  731.     uint8 header[8];

  732.     size_t n = sizeof (header);

  733. 

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

  735. 

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

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

  738. 

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

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

  741. 

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

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

  744. 

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

  746.     result.size = totalSize;

  747. 

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

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

  750. 

  751.     return result;

  752. }

  753. 

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

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

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

  757. 

  758. int MidiMessage::getMidiChannelMetaEventChannel() const noexcept

  759. {

  760.     jassert (isMidiChannelMetaEvent());

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

  762. }

  763. 

  764. double MidiMessage::getTempoSecondsPerQuarterNote() const noexcept

  765. {

  766.     if (! isTempoMetaEvent())

  767.         return 0.0;

  768. 

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

  770. 

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

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

  773.              | d[2])

  774.             / 1000000.0;

  775. }

  776. 

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

  778. {

  779.     if (timeFormat > 0)

  780.     {

  781.         if (! isTempoMetaEvent())

  782.             return 0.5 / timeFormat;

  783. 

  784.         return getTempoSecondsPerQuarterNote() / timeFormat;

  785.     }

  786.     else

  787.     {

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

  789.         double framesPerSecond;

  790. 

  791.         switch (frameCode)

  792.         {

  793.             case 24: framesPerSecond = 24.0;   break;

  794.             case 25: framesPerSecond = 25.0;   break;

  795.             case 29: framesPerSecond = 29.97;  break;

  796.             case 30: framesPerSecond = 30.0;   break;

  797.             default: framesPerSecond = 30.0;   break;

  798.         }

  799. 

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

  801.     }

  802. }

  803. 

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

  805. {

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

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

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

  809.                         (uint8) microsecondsPerQuarterNote };

  810. 

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

  812. }

  813. 

  814. bool MidiMessage::isTimeSignatureMetaEvent() const noexcept

  815. {

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

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

  818. }

  819. 

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

  821. {

  822.     if (isTimeSignatureMetaEvent())

  823.     {

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

  825.         numerator = d[0];

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

  827.     }

  828.     else

  829.     {

  830.         numerator = 4;

  831.         denominator = 4;

  832.     }

  833. }

  834. 

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

  836. {

  837.     int n = 1;

  838.     int powerOfTwo = 0;

  839. 

  840.     while (n < denominator)

  841.     {

  842.         n <<= 1;

  843.         ++powerOfTwo;

  844.     }

  845. 

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

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

  848. }

  849. 

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

  851. {

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

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

  854. }

  855. 

  856. bool MidiMessage::isKeySignatureMetaEvent() const noexcept

  857. {

  858.     return getMetaEventType() == 0x59;

  859. }

  860. 

  861. int MidiMessage::getKeySignatureNumberOfSharpsOrFlats() const noexcept

  862. {

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

  864. }

  865. 

  866. bool MidiMessage::isKeySignatureMajorKey() const noexcept

  867. {

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

  869. }

  870. 

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

  872. {

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

  874. 

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

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

  877. }

  878. 

  879. MidiMessage MidiMessage::endOfTrack() noexcept

  880. {

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

  882. }

  883. 

  884. //==============================================================================

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

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

  887. 

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

  889. {

  890.     return MidiMessage (0xf2,

  891.                         positionInMidiBeats & 127,

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

  893. }

  894. 

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

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

  897. 

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

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

  900. 

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

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

  903. 

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

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

  906. 

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

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

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

  910. 

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

  912. {

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

  914. }

  915. 

  916. bool MidiMessage::isFullFrame() const noexcept

  917. {

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

  919. 

  920.     return data[0] == 0xf0

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

  922.             && size >= 10

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

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

  925. }

  926. 

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

  928.                                           MidiMessage::SmpteTimecodeType& timecodeType) const noexcept

  929. {

  930.     jassert (isFullFrame());

  931. 

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

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

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

  935.     minutes = data[6];

  936.     seconds = data[7];

  937.     frames  = data[8];

  938. }

  939. 

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

  941.                                     const int seconds, const int frames,

  942.                                     MidiMessage::SmpteTimecodeType timecodeType)

  943. {

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

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

  946.                         (uint8) minutes,

  947.                         (uint8) seconds,

  948.                         (uint8) frames,

  949.                         0xf7 };

  950. 

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

  952. }

  953. 

  954. bool MidiMessage::isMidiMachineControlMessage() const noexcept

  955. {

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

  957.     return data[0] == 0xf0

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

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

  960.         && size > 5;

  961. }

  962. 

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

  964. {

  965.     jassert (isMidiMachineControlMessage());

  966. 

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

  968. }

  969. 

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

  971. {

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

  973. 

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

  975. }

  976. 

  977. //==============================================================================

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

  979. {

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

  981.     if (size >= 12

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

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

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

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

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

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

  988.     {

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

  990.         minutes = data[8];

  991.         seconds = data[9];

  992.         frames = data[10];

  993. 

  994.         return true;

  995.     }

  996. 

  997.     return false;

  998. }

  999. 

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

  1001. {

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

  1003.                         (uint8) hours,

  1004.                         (uint8) minutes,

  1005.                         (uint8) seconds,

  1006.                         (uint8) frames,

  1007.                         0xf7 };

  1008. 

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

  1010. }

  1011. 

  1012. //==============================================================================

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

  1014. {

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

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

  1017. 

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

  1019.     {

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

  1021.                             : flatNoteNames  [note % 12]);

  1022. 

  1023.         if (includeOctaveNumber)

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

  1025. 

  1026.         return s;

  1027.     }

  1028. 

  1029.     return String();

  1030. }

  1031. 

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

  1033. {

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

  1035. }

  1036. 

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

  1038. {

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

  1040. }

  1041. 

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

  1043. {

  1044.     static const char* names[] =

  1045.     {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  1078.     };

  1079. 

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

  1081. }

  1082. 

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

  1084. {

  1085.     static const char* names[] =

  1086.     {

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

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

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

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

  1091.     };

  1092. 

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

  1094. }

  1095. 

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

  1097. {

  1098.     static const char* names[] =

  1099.     {

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

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

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

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

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

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

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

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

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

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

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

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

  1112.     };

  1113. 

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

  1115. }

  1116. 

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

  1118. {

  1119.     static const char* names[] =

  1120.     {

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

  1122.         nullptr,

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

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

  1125.         nullptr,

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

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

  1128.         nullptr, nullptr,

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

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

  1131.         nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,

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

  1133.         nullptr,

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

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

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

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

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

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

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

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

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

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

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

  1145.         nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,

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

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

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

  1149.         nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,

  1150.         nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,

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

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

  1153.     };

  1154. 

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

  1156. }

  1157. 

  1158. }