Added USB transport for native MIDI through USB.

#52

src/midi_UsbTransport.h

@@ -29,19 +29,45 @@
 #pragma once
 
 #include "midi_Defs.h"
+#include "midi_RingBuffer.h"
+#include <MIDIUSB.h>
 
 BEGIN_MIDI_NAMESPACE
 
+template<unsigned BuffersSize>
 class UsbTransport
 {
 public:
     inline UsbTransport();
+    inline ~UsbTransport();
 
 public: // Serial / Stream API required for template compatibility
     inline void begin(unsigned inBaudrate);
-    inline int available() const;
+    inline unsigned available();
     inline byte read();
-    inline void write(byte);
+    inline void write(byte inData);
+
+private:
+    inline bool pollUsbMidi();
+    inline void recomposeAndSendTxPackets();
+    inline void resetTx();
+    static inline byte encodePacketHeader(StatusByte inStatusByte);
+    static inline int getPacketLength(const midiEventPacket_t& inPacket);
+
+private:
+    typedef RingBuffer<byte, BuffersSize> Buffer;
+    Buffer mTxBuffer;
+    Buffer mRxBuffer;
+
+    union TxPacket
+    {
+        byte mDataArray[4];
+        midiEventPacket_t mPacket;
+    };
+    TxPacket mCurrentTxPacket;
+    int mCurrentTxPacketByteIndex;
 };
 
 END_MIDI_NAMESPACE
+
+#include "midi_UsbTransport.hpp"

src/midi_UsbTransport.hpp

@@ -0,0 +1,153 @@
+#pragma once
+
+BEGIN_MIDI_NAMESPACE
+
+template<unsigned BufferSize>
+inline UsbTransport<BufferSize>::UsbTransport()
+{
+
+}
+
+template<unsigned BufferSize>
+inline UsbTransport<BufferSize>::~UsbTransport()
+{
+
+}
+
+// -----------------------------------------------------------------------------
+
+template<unsigned BufferSize>
+inline void UsbTransport<BufferSize>::begin(unsigned inBaudrate)
+{
+    mTxBuffer.clear();
+    mRxBuffer.clear();
+}
+
+template<unsigned BufferSize>
+inline unsigned UsbTransport<BufferSize>::available()
+{
+    pollUsbMidi();
+    return mRxBuffer.getLength();
+}
+
+template<unsigned BufferSize>
+inline byte UsbTransport<BufferSize>::read()
+{
+    return mRxBuffer.read();
+}
+
+template<unsigned BufferSize>
+inline void UsbTransport<BufferSize>::write(byte inData)
+{
+    mTxBuffer.write(inData);
+    recomposeAndSendTxPackets();
+}
+
+// -----------------------------------------------------------------------------
+
+template<unsigned BufferSize>
+inline bool UsbTransport<BufferSize>::pollUsbMidi()
+{
+    bool received = false;
+    midiEventPacket_t packet = MidiUSB.read();
+    while (packet.header != 0)
+    {
+        received = true;
+
+        switch (packet.header << 4)
+        {
+                // 3 bytes messages
+            case midi::NoteOff:
+            case midi::NoteOn:
+            case midi::AfterTouchPoly:
+            case midi::ControlChange:
+            case midi::PitchBend:
+                mRxBuffer.write(packet.byte1);
+                mRxBuffer.write(packet.byte2);
+                mRxBuffer.write(packet.byte3);
+                break;
+
+                // 2 bytes messages
+            case midi::ProgramChange:
+            case midi::AfterTouchChannel:
+                mRxBuffer.write(packet.byte1);
+                mRxBuffer.write(packet.byte2);
+                break;
+
+                // 1 byte message
+            case midi::TuneRequest:
+            case midi::Clock:
+            case midi::Start:
+            case midi::Continue:
+            case midi::Stop:
+            case midi::ActiveSensing:
+            case midi::SystemReset:
+                mRxBuffer.write(packet.byte1);
+                break;
+
+                // Special cases
+                // case midi::SystemExclusive:
+                // case midi::TimeCodeQuarterFrame:
+                // case midi::SongPosition:
+                // case midi::SongSelect:
+                //   break;
+
+            default:
+                break;
+        }
+
+        packet = MidiUSB.read();
+    }
+    return received;
+}
+
+template<unsigned BufferSize>
+inline void UsbTransport<BufferSize>::recomposeAndSendTxPackets()
+{
+    while (!mTxBuffer.isEmpty())
+    {
+        const byte data = mTxBuffer.read();
+        if (mCurrentTxPacketByteIndex == 0)
+        {
+            mCurrentTxPacket.mPacket.header = encodePacketHeader(data);
+        }
+        else
+        {
+            mCurrentTxPacket.mDataArray[mCurrentTxPacketByteIndex] = data;
+        }
+        mCurrentTxPacketByteIndex++;
+
+        const int packetLength = getPacketLength(mCurrentTxPacket.mPacket);
+
+        if (mCurrentTxPacketByteIndex == packetLength)
+        {
+            MidiUSB.write(mCurrentTxPacket.mDataArray, packetLength);
+            resetTx();
+        }
+    }
+}
+
+template<unsigned BufferSize>
+inline void UsbTransport<BufferSize>::resetTx()
+{
+    mCurrentTxPacket.mPacket.header = 0;
+    mCurrentTxPacket.mPacket.byte1  = 0;
+    mCurrentTxPacket.mPacket.byte2  = 0;
+    mCurrentTxPacket.mPacket.byte3  = 0;
+    mCurrentTxPacketByteIndex = 0;
+}
+
+template<unsigned BufferSize>
+inline byte UsbTransport<BufferSize>::encodePacketHeader(StatusByte inStatusByte)
+{
+    // todo: fix me for other types than channel
+    return inStatusByte >> 4;
+}
+
+template<unsigned BufferSize>
+inline int UsbTransport<BufferSize>::getPacketLength(const midiEventPacket_t& inPacket)
+{
+    return 3;
+}
+
+END_MIDI_NAMESPACE