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.
13953 Commits
9 Branches
3.6GB
Tree: 158220ddfa
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '158220ddfa'
${ noResults }
JUCE/modules/juce_audio_basics/midi/ump/juce_UMPFactory.h

536 lines
21KB
Raw Blame History 

  1. /*

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

  3. 

  4.    This file is part of the JUCE library.

  5.    Copyright (c) 2022 - Raw Material Software Limited

  6. 

  7.    JUCE is an open source library subject to commercial or open-source

  8.    licensing.

  9. 

  10.    The code included in this file is provided under the terms of the ISC license

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

  12.    To use, copy, modify, and/or distribute this software for any purpose with or

  13.    without fee is hereby granted provided that the above copyright notice and

  14.    this permission notice appear in all copies.

  15. 

  16.    JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER

  17.    EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE

  18.    DISCLAIMED.

  19. 

  20.   ==============================================================================

  21. */

  22. 

  23. #ifndef DOXYGEN

  24. 

  25. namespace juce::universal_midi_packets

  26. {

  27. 

  28. /**

  29.     This struct holds functions that can be used to create different kinds

  30.     of Universal MIDI Packet.

  31. 

  32.     @tags{Audio}

  33. */

  34. struct Factory

  35. {

  36.     /** @internal */

  37.     struct Detail

  38.     {

  39.         static PacketX1 makeSystem()   { return PacketX1{}.withMessageType (1); }

  40.         static PacketX1 makeV1()       { return PacketX1{}.withMessageType (2); }

  41.         static PacketX2 makeV2()       { return PacketX2{}.withMessageType (4); }

  42. 

  43.         static PacketX2 makeSysEx (uint8_t group,

  44.                                    uint8_t status,

  45.                                    uint8_t numBytes,

  46.                                    const std::byte* data)

  47.         {

  48.             jassert (numBytes <= 6);

  49. 

  50.             std::array<uint8_t, 8> bytes{{}};

  51.             bytes[0] = (0x3 << 0x4) | group;

  52.             bytes[1] = (uint8_t) (status << 0x4) | numBytes;

  53. 

  54.             std::memcpy (bytes.data() + 2, data, numBytes);

  55. 

  56.             std::array<uint32_t, 2> words;

  57. 

  58.             size_t index = 0;

  59. 

  60.             for (auto& word : words)

  61.                 word = ByteOrder::bigEndianInt (bytes.data() + 4 * index++);

  62. 

  63.             return PacketX2 { words };

  64.         }

  65. 

  66.         static PacketX4 makeSysEx8 (uint8_t group,

  67.                                     uint8_t status,

  68.                                     uint8_t numBytes,

  69.                                     uint8_t dataStart,

  70.                                     const uint8_t* data)

  71.         {

  72.             jassert (numBytes <= 16 - dataStart);

  73. 

  74.             std::array<uint8_t, 16> bytes{{}};

  75.             bytes[0] = (0x5 << 0x4) | group;

  76.             bytes[1] = (uint8_t) (status << 0x4) | numBytes;

  77. 

  78.             std::memcpy (bytes.data() + dataStart, data, numBytes);

  79. 

  80.             std::array<uint32_t, 4> words;

  81. 

  82.             size_t index = 0;

  83. 

  84.             for (auto& word : words)

  85.                 word = ByteOrder::bigEndianInt (bytes.data() + 4 * index++);

  86. 

  87.             return PacketX4 { words };

  88.         }

  89.     };

  90. 

  91.     static PacketX1 makeNoop (uint8_t group)

  92.     {

  93.         return PacketX1{}.withGroup (group);

  94.     }

  95. 

  96.     static PacketX1 makeJRClock (uint8_t group, uint16_t time)

  97.     {

  98.         return PacketX1 { time }.withStatus (1).withGroup (group);

  99.     }

  100. 

  101.     static PacketX1 makeJRTimestamp (uint8_t group, uint16_t time)

  102.     {

  103.         return PacketX1 { time }.withStatus (2).withGroup (group);

  104.     }

  105. 

  106.     static PacketX1 makeTimeCode (uint8_t group, uint8_t code)

  107.     {

  108.         return Detail::makeSystem().withGroup (group)

  109.                                    .withU8<1> (0xf1)

  110.                                    .withU8<2> (code & 0x7f);

  111.     }

  112. 

  113.     static PacketX1 makeSongPositionPointer (uint8_t group, uint16_t pos)

  114.     {

  115.         return Detail::makeSystem().withGroup (group)

  116.                                    .withU8<1> (0xf2)

  117.                                    .withU8<2> (pos & 0x7f)

  118.                                    .withU8<3> ((pos >> 7) & 0x7f);

  119.     }

  120. 

  121.     static PacketX1 makeSongSelect (uint8_t group, uint8_t song)

  122.     {

  123.         return Detail::makeSystem().withGroup (group)

  124.                                    .withU8<1> (0xf3)

  125.                                    .withU8<2> (song & 0x7f);

  126.     }

  127. 

  128.     static PacketX1 makeTuneRequest (uint8_t group)

  129.     {

  130.         return Detail::makeSystem().withGroup (group)

  131.                                    .withU8<1> (0xf6);

  132.     }

  133. 

  134.     static PacketX1 makeTimingClock (uint8_t group)

  135.     {

  136.         return Detail::makeSystem().withGroup (group)

  137.                                    .withU8<1> (0xf8);

  138.     }

  139. 

  140.     static PacketX1 makeStart (uint8_t group)

  141.     {

  142.         return Detail::makeSystem().withGroup (group)

  143.                                    .withU8<1> (0xfa);

  144.     }

  145. 

  146.     static PacketX1 makeContinue (uint8_t group)

  147.     {

  148.         return Detail::makeSystem().withGroup (group)

  149.                                    .withU8<1> (0xfb);

  150.     }

  151. 

  152.     static PacketX1 makeStop (uint8_t group)

  153.     {

  154.         return Detail::makeSystem().withGroup (group)

  155.                                    .withU8<1> (0xfc);

  156.     }

  157. 

  158.     static PacketX1 makeActiveSensing (uint8_t group)

  159.     {

  160.         return Detail::makeSystem().withGroup (group)

  161.                                    .withU8<1> (0xfe);

  162.     }

  163. 

  164.     static PacketX1 makeReset (uint8_t group)

  165.     {

  166.         return Detail::makeSystem().withGroup (group)

  167.                                    .withU8<1> (0xff);

  168.     }

  169. 

  170.     static PacketX1 makeNoteOffV1 (uint8_t group,

  171.                                    uint8_t channel,

  172.                                    uint8_t note,

  173.                                    uint8_t velocity)

  174.     {

  175.         return Detail::makeV1().withGroup (group)

  176.                                .withStatus (0x8)

  177.                                .withChannel (channel)

  178.                                .withU8<2> (note & 0x7f)

  179.                                .withU8<3> (velocity & 0x7f);

  180.     }

  181. 

  182.     static PacketX1 makeNoteOnV1 (uint8_t group,

  183.                                   uint8_t channel,

  184.                                   uint8_t note,

  185.                                   uint8_t velocity)

  186.     {

  187.         return Detail::makeV1().withGroup (group)

  188.                                .withStatus (0x9)

  189.                                .withChannel (channel)

  190.                                .withU8<2> (note & 0x7f)

  191.                                .withU8<3> (velocity & 0x7f);

  192.     }

  193. 

  194.     static PacketX1 makePolyPressureV1 (uint8_t group,

  195.                                         uint8_t channel,

  196.                                         uint8_t note,

  197.                                         uint8_t pressure)

  198.     {

  199.         return Detail::makeV1().withGroup (group)

  200.                                .withStatus (0xa)

  201.                                .withChannel (channel)

  202.                                .withU8<2> (note & 0x7f)

  203.                                .withU8<3> (pressure & 0x7f);

  204.     }

  205. 

  206.     static PacketX1 makeControlChangeV1 (uint8_t group,

  207.                                          uint8_t channel,

  208.                                          uint8_t controller,

  209.                                          uint8_t value)

  210.     {

  211.         return Detail::makeV1().withGroup (group)

  212.                                .withStatus (0xb)

  213.                                .withChannel (channel)

  214.                                .withU8<2> (controller & 0x7f)

  215.                                .withU8<3> (value & 0x7f);

  216.     }

  217. 

  218.     static PacketX1 makeProgramChangeV1 (uint8_t group,

  219.                                          uint8_t channel,

  220.                                          uint8_t program)

  221.     {

  222.         return Detail::makeV1().withGroup (group)

  223.                                .withStatus (0xc)

  224.                                .withChannel (channel)

  225.                                .withU8<2> (program & 0x7f);

  226.     }

  227. 

  228.     static PacketX1 makeChannelPressureV1 (uint8_t group,

  229.                                            uint8_t channel,

  230.                                            uint8_t pressure)

  231.     {

  232.         return Detail::makeV1().withGroup (group)

  233.                                .withStatus (0xd)

  234.                                .withChannel (channel)

  235.                                .withU8<2> (pressure & 0x7f);

  236.     }

  237. 

  238.     static PacketX1 makePitchBend (uint8_t group,

  239.                                    uint8_t channel,

  240.                                    uint16_t pitchbend)

  241.     {

  242.         return Detail::makeV1().withGroup (group)

  243.                                .withStatus (0xe)

  244.                                .withChannel (channel)

  245.                                .withU8<2> (pitchbend & 0x7f)

  246.                                .withU8<3> ((pitchbend >> 7) & 0x7f);

  247.     }

  248. 

  249.     static PacketX2 makeSysExIn1Packet (uint8_t group,

  250.                                         uint8_t numBytes,

  251.                                         const std::byte* data)

  252.     {

  253.         return Detail::makeSysEx (group, 0x0, numBytes, data);

  254.     }

  255. 

  256.     static PacketX2 makeSysExStart (uint8_t group,

  257.                                     uint8_t numBytes,

  258.                                     const std::byte* data)

  259.     {

  260.         return Detail::makeSysEx (group, 0x1, numBytes, data);

  261.     }

  262. 

  263.     static PacketX2 makeSysExContinue (uint8_t group,

  264.                                        uint8_t numBytes,

  265.                                        const std::byte* data)

  266.     {

  267.         return Detail::makeSysEx (group, 0x2, numBytes, data);

  268.     }

  269. 

  270.     static PacketX2 makeSysExEnd (uint8_t group,

  271.                                   uint8_t numBytes,

  272.                                   const std::byte* data)

  273.     {

  274.         return Detail::makeSysEx (group, 0x3, numBytes, data);

  275.     }

  276. 

  277.     static PacketX2 makeRegisteredPerNoteControllerV2 (uint8_t group,

  278.                                                        uint8_t channel,

  279.                                                        uint8_t note,

  280.                                                        uint8_t controller,

  281.                                                        uint32_t data)

  282.     {

  283.         return Detail::makeV2().withGroup (group)

  284.                                .withStatus (0x0)

  285.                                .withChannel (channel)

  286.                                .withU8<2> (note & 0x7f)

  287.                                .withU8<3> (controller & 0x7f)

  288.                                .withU32<1> (data);

  289.     }

  290. 

  291.     static PacketX2 makeAssignablePerNoteControllerV2 (uint8_t group,

  292.                                                        uint8_t channel,

  293.                                                        uint8_t note,

  294.                                                        uint8_t controller,

  295.                                                        uint32_t data)

  296.     {

  297.         return Detail::makeV2().withGroup (group)

  298.                                .withStatus (0x1)

  299.                                .withChannel (channel)

  300.                                .withU8<2> (note & 0x7f)

  301.                                .withU8<3> (controller & 0x7f)

  302.                                .withU32<1> (data);

  303.     }

  304. 

  305.     static PacketX2 makeRegisteredControllerV2 (uint8_t group,

  306.                                                 uint8_t channel,

  307.                                                 uint8_t bank,

  308.                                                 uint8_t index,

  309.                                                 uint32_t data)

  310.     {

  311.         return Detail::makeV2().withGroup (group)

  312.                                .withStatus (0x2)

  313.                                .withChannel (channel)

  314.                                .withU8<2> (bank & 0x7f)

  315.                                .withU8<3> (index & 0x7f)

  316.                                .withU32<1> (data);

  317.     }

  318. 

  319.     static PacketX2 makeAssignableControllerV2 (uint8_t group,

  320.                                                 uint8_t channel,

  321.                                                 uint8_t bank,

  322.                                                 uint8_t index,

  323.                                                 uint32_t data)

  324.     {

  325.         return Detail::makeV2().withGroup (group)

  326.                                .withStatus (0x3)

  327.                                .withChannel (channel)

  328.                                .withU8<2> (bank & 0x7f)

  329.                                .withU8<3> (index & 0x7f)

  330.                                .withU32<1> (data);

  331.     }

  332. 

  333.     static PacketX2 makeRelativeRegisteredControllerV2 (uint8_t group,

  334.                                                         uint8_t channel,

  335.                                                         uint8_t bank,

  336.                                                         uint8_t index,

  337.                                                         uint32_t data)

  338.     {

  339.         return Detail::makeV2().withGroup (group)

  340.                                .withStatus (0x4)

  341.                                .withChannel (channel)

  342.                                .withU8<2> (bank & 0x7f)

  343.                                .withU8<3> (index & 0x7f)

  344.                                .withU32<1> (data);

  345.     }

  346. 

  347.     static PacketX2 makeRelativeAssignableControllerV2 (uint8_t group,

  348.                                                         uint8_t channel,

  349.                                                         uint8_t bank,

  350.                                                         uint8_t index,

  351.                                                         uint32_t data)

  352.     {

  353.         return Detail::makeV2().withGroup (group)

  354.                                .withStatus (0x5)

  355.                                .withChannel (channel)

  356.                                .withU8<2> (bank & 0x7f)

  357.                                .withU8<3> (index & 0x7f)

  358.                                .withU32<1> (data);

  359.     }

  360. 

  361.     static PacketX2 makePerNotePitchBendV2 (uint8_t group,

  362.                                             uint8_t channel,

  363.                                             uint8_t note,

  364.                                             uint32_t data)

  365.     {

  366.         return Detail::makeV2().withGroup (group)

  367.                                .withStatus (0x6)

  368.                                .withChannel (channel)

  369.                                .withU8<2> (note & 0x7f)

  370.                                .withU32<1> (data);

  371.     }

  372. 

  373.     enum class NoteAttributeKind : uint8_t

  374.     {

  375.         none            = 0x00,

  376.         manufacturer    = 0x01,

  377.         profile         = 0x02,

  378.         pitch7_9        = 0x03

  379.     };

  380. 

  381.     static PacketX2 makeNoteOffV2 (uint8_t group,

  382.                                    uint8_t channel,

  383.                                    uint8_t note,

  384.                                    NoteAttributeKind attribute,

  385.                                    uint16_t velocity,

  386.                                    uint16_t attributeValue)

  387.     {

  388.         return Detail::makeV2().withGroup (group)

  389.                                .withStatus (0x8)

  390.                                .withChannel (channel)

  391.                                .withU8<2> (note & 0x7f)

  392.                                .withU8<3> ((uint8_t) attribute)

  393.                                .withU16<2> (velocity)

  394.                                .withU16<3> (attributeValue);

  395.     }

  396. 

  397.     static PacketX2 makeNoteOnV2 (uint8_t group,

  398.                                   uint8_t channel,

  399.                                   uint8_t note,

  400.                                   NoteAttributeKind attribute,

  401.                                   uint16_t velocity,

  402.                                   uint16_t attributeValue)

  403.     {

  404.         return Detail::makeV2().withGroup (group)

  405.                                .withStatus (0x9)

  406.                                .withChannel (channel)

  407.                                .withU8<2> (note & 0x7f)

  408.                                .withU8<3> ((uint8_t) attribute)

  409.                                .withU16<2> (velocity)

  410.                                .withU16<3> (attributeValue);

  411.     }

  412. 

  413.     static PacketX2 makePolyPressureV2 (uint8_t group,

  414.                                         uint8_t channel,

  415.                                         uint8_t note,

  416.                                         uint32_t data)

  417.     {

  418.         return Detail::makeV2().withGroup (group)

  419.                                .withStatus (0xa)

  420.                                .withChannel (channel)

  421.                                .withU8<2> (note & 0x7f)

  422.                                .withU32<1> (data);

  423.     }

  424. 

  425.     static PacketX2 makeControlChangeV2 (uint8_t group,

  426.                                          uint8_t channel,

  427.                                          uint8_t controller,

  428.                                          uint32_t data)

  429.     {

  430.         return Detail::makeV2().withGroup (group)

  431.                                .withStatus (0xb)

  432.                                .withChannel (channel)

  433.                                .withU8<2> (controller & 0x7f)

  434.                                .withU32<1> (data);

  435.     }

  436. 

  437.     static PacketX2 makeProgramChangeV2 (uint8_t group,

  438.                                          uint8_t channel,

  439.                                          uint8_t optionFlags,

  440.                                          uint8_t program,

  441.                                          uint8_t bankMsb,

  442.                                          uint8_t bankLsb)

  443.     {

  444.         return Detail::makeV2().withGroup (group)

  445.                                .withStatus (0xc)

  446.                                .withChannel (channel)

  447.                                .withU8<3> (optionFlags)

  448.                                .withU8<4> (program)

  449.                                .withU8<6> (bankMsb)

  450.                                .withU8<7> (bankLsb);

  451.     }

  452. 

  453.     static PacketX2 makeChannelPressureV2 (uint8_t group,

  454.                                            uint8_t channel,

  455.                                            uint32_t data)

  456.     {

  457.         return Detail::makeV2().withGroup (group)

  458.                                .withStatus (0xd)

  459.                                .withChannel (channel)

  460.                                .withU32<1> (data);

  461.     }

  462. 

  463.     static PacketX2 makePitchBendV2 (uint8_t group,

  464.                                      uint8_t channel,

  465.                                      uint32_t data)

  466.     {

  467.         return Detail::makeV2().withGroup (group)

  468.                                .withStatus (0xe)

  469.                                .withChannel (channel)

  470.                                .withU32<1> (data);

  471.     }

  472. 

  473.     static PacketX2 makePerNoteManagementV2 (uint8_t group,

  474.                                              uint8_t channel,

  475.                                              uint8_t note,

  476.                                              uint8_t optionFlags)

  477.     {

  478.         return Detail::makeV2().withGroup (group)

  479.                                .withStatus (0xf)

  480.                                .withChannel (channel)

  481.                                .withU8<2> (note)

  482.                                .withU8<3> (optionFlags);

  483.     }

  484. 

  485. 

  486.     static PacketX4 makeSysEx8in1Packet (uint8_t group,

  487.                                          uint8_t numBytes,

  488.                                          uint8_t streamId,

  489.                                          const uint8_t* data)

  490.     {

  491.         return Detail::makeSysEx8 (group, 0x0, numBytes, 3, data).withU8<2> (streamId);

  492.     }

  493. 

  494.     static PacketX4 makeSysEx8Start (uint8_t group,

  495.                                      uint8_t numBytes,

  496.                                      uint8_t streamId,

  497.                                      const uint8_t* data)

  498.     {

  499.         return Detail::makeSysEx8 (group, 0x1, numBytes, 3, data).withU8<2> (streamId);

  500.     }

  501. 

  502.     static PacketX4 makeSysEx8Continue (uint8_t group,

  503.                                         uint8_t numBytes,

  504.                                         uint8_t streamId,

  505.                                         const uint8_t* data)

  506.     {

  507.         return Detail::makeSysEx8 (group, 0x2, numBytes, 3, data).withU8<2> (streamId);

  508.     }

  509. 

  510.     static PacketX4 makeSysEx8End (uint8_t group,

  511.                                    uint8_t numBytes,

  512.                                    uint8_t streamId,

  513.                                    const uint8_t* data)

  514.     {

  515.         return Detail::makeSysEx8 (group, 0x3, numBytes, 3, data).withU8<2> (streamId);

  516.     }

  517. 

  518.     static PacketX4 makeMixedDataSetHeader (uint8_t group,

  519.                                             uint8_t dataSetId,

  520.                                             const uint8_t* data)

  521.     {

  522.         return Detail::makeSysEx8 (group, 0x8, 14, 2, data).withChannel (dataSetId);

  523.     }

  524. 

  525.     static PacketX4 makeDataSetPayload (uint8_t group,

  526.                                         uint8_t dataSetId,

  527.                                         const uint8_t* data)

  528.     {

  529.         return Detail::makeSysEx8 (group, 0x9, 14, 2, data).withChannel (dataSetId);

  530.     }

  531. };

  532. 

  533. } // namespace juce::universal_midi_packets

  534. 

  535. #endif