source/modules/juce_audio_basics/midi/ump/juce_UMPacket.h

   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
  26 {
  27 namespace universal_midi_packets
  28 {
  29
  30 /**
  31     Holds a single Universal MIDI Packet.
  32
  33     @tags{Audio}
  34 */
  35 template <size_t numWords>
  36 class Packet
  37 {
  38 public:
  39     Packet() = default;
  40
  41     template <size_t w = numWords, typename std::enable_if<w == 1, int>::type = 0>
  42     Packet (uint32_t a)
  43         : contents { { a } }
  44     {
  45         jassert (Utils::getNumWordsForMessageType (a) == 1);
  46     }
  47
  48     template <size_t w = numWords, typename std::enable_if<w == 2, int>::type = 0>
  49     Packet (uint32_t a, uint32_t b)
  50         : contents { { a, b } }
  51     {
  52         jassert (Utils::getNumWordsForMessageType (a) == 2);
  53     }
  54
  55     template <size_t w = numWords, typename std::enable_if<w == 3, int>::type = 0>
  56     Packet (uint32_t a, uint32_t b, uint32_t c)
  57         : contents { { a, b, c } }
  58     {
  59         jassert (Utils::getNumWordsForMessageType (a) == 3);
  60     }
  61
  62     template <size_t w = numWords, typename std::enable_if<w == 4, int>::type = 0>
  63     Packet (uint32_t a, uint32_t b, uint32_t c, uint32_t d)
  64         : contents { { a, b, c, d } }
  65     {
  66         jassert (Utils::getNumWordsForMessageType (a) == 4);
  67     }
  68
  69     template <size_t w, typename std::enable_if<w == numWords, int>::type = 0>
  70     explicit Packet (const std::array<uint32_t, w>& fullPacket)
  71         : contents (fullPacket)
  72     {
  73         jassert (Utils::getNumWordsForMessageType (fullPacket.front()) == numWords);
  74     }
  75
  76     Packet withMessageType (uint8_t type) const noexcept
  77     {
  78         return withU4<0> (type);
  79     }
  80
  81     Packet withGroup (uint8_t group) const noexcept
  82     {
  83         return withU4<1> (group);
  84     }
  85
  86     Packet withStatus (uint8_t status) const noexcept
  87     {
  88         return withU4<2> (status);
  89     }
  90
  91     Packet withChannel (uint8_t channel) const noexcept
  92     {
  93         return withU4<3> (channel);
  94     }
  95
  96     uint8_t getMessageType() const noexcept { return getU4<0>(); }
  97
  98     uint8_t getGroup() const noexcept { return getU4<1>(); }
  99
 100     uint8_t getStatus() const noexcept { return getU4<2>(); }
 101
 102     uint8_t getChannel() const noexcept { return getU4<3>(); }
 103
 104     template <size_t index>
 105     Packet withU4 (uint8_t value) const noexcept
 106     {
 107         constexpr auto word = index / 8;
 108         auto copy = *this;
 109         std::get<word> (copy.contents) = Utils::U4<index % 8>::set (copy.template getU32<word>(), value);
 110         return copy;
 111     }
 112
 113     template <size_t index>
 114     Packet withU8 (uint8_t value) const noexcept
 115     {
 116         constexpr auto word = index / 4;
 117         auto copy = *this;
 118         std::get<word> (copy.contents) = Utils::U8<index % 4>::set (copy.template getU32<word>(), value);
 119         return copy;
 120     }
 121
 122     template <size_t index>
 123     Packet withU16 (uint16_t value) const noexcept
 124     {
 125         constexpr auto word = index / 2;
 126         auto copy = *this;
 127         std::get<word> (copy.contents) = Utils::U16<index % 2>::set (copy.template getU32<word>(), value);
 128         return copy;
 129     }
 130
 131     template <size_t index>
 132     Packet withU32 (uint32_t value) const noexcept
 133     {
 134         auto copy = *this;
 135         std::get<index> (copy.contents) = value;
 136         return copy;
 137     }
 138
 139     template <size_t index>
 140     uint8_t getU4() const noexcept
 141     {
 142         return Utils::U4<index % 8>::get (this->template getU32<index / 8>());
 143     }
 144
 145     template <size_t index>
 146     uint8_t getU8() const noexcept
 147     {
 148         return Utils::U8<index % 4>::get (this->template getU32<index / 4>());
 149     }
 150
 151     template <size_t index>
 152     uint16_t getU16() const noexcept
 153     {
 154         return Utils::U16<index % 2>::get (this->template getU32<index / 2>());
 155     }
 156
 157     template <size_t index>
 158     uint32_t getU32() const noexcept
 159     {
 160         return std::get<index> (contents);
 161     }
 162
 163     //==============================================================================
 164     using Contents = std::array<uint32_t, numWords>;
 165
 166     using const_iterator    = typename Contents::const_iterator;
 167
 168     const_iterator  begin()                   const noexcept { return contents.begin(); }
 169     const_iterator cbegin()                   const noexcept { return contents.begin(); }
 170
 171     const_iterator  end()                     const noexcept { return contents.end(); }
 172     const_iterator cend()                     const noexcept { return contents.end(); }
 173
 174     const uint32_t* data()                    const noexcept { return contents.data(); }
 175
 176     const uint32_t& front()                   const noexcept { return contents.front(); }
 177     const uint32_t& back()                    const noexcept { return contents.back(); }
 178
 179     const uint32_t& operator[] (size_t index) const noexcept { return contents[index]; }
 180
 181 private:
 182     Contents contents { {} };
 183 };
 184
 185 using PacketX1 = Packet<1>;
 186 using PacketX2 = Packet<2>;
 187 using PacketX3 = Packet<3>;
 188 using PacketX4 = Packet<4>;
 189
 190 }
 191 }
 192
 193 #endif