source/native-plugins/midi-queue.hpp

   1 /*
   2  * MIDI Event Queue
   3  * Copyright (C) 2012-2020 Filipe Coelho <falktx@falktx.com>
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * For a full copy of the GNU General Public License see the COPYING file
  16  */
  17
  18 #ifndef MIDI_QUEUE_HPP_INCLUDED
  19 #define MIDI_QUEUE_HPP_INCLUDED
  20
  21 #include "CarlaMutex.hpp"
  22
  23 template<uint16_t MAX_SIZE>
  24 class MIDIEventQueue
  25 {
  26 public:
  27     MIDIEventQueue() noexcept
  28         : index(0),
  29           empty(true),
  30           full(false),
  31           mutex() {}
  32
  33     bool isEmpty() const noexcept
  34     {
  35         return empty;
  36     }
  37
  38     bool isNotEmpty() const noexcept
  39     {
  40         return !empty;
  41     }
  42
  43     bool isFull() const noexcept
  44     {
  45         return full;
  46     }
  47
  48     CarlaMutex& getMutex() noexcept
  49     {
  50         return mutex;
  51     }
  52
  53     bool put(unsigned char d1, unsigned char d2, unsigned char d3)
  54     {
  55         CARLA_SAFE_ASSERT_RETURN(d1 != 0, false);
  56
  57         if (full)
  58             return false;
  59
  60         for (unsigned short i=0; i < MAX_SIZE; i++)
  61         {
  62             if (data[i].d1 == 0)
  63             {
  64                 data[i].d1 = d1;
  65                 data[i].d2 = d2;
  66                 data[i].d3 = d3;
  67                 empty = false;
  68                 full  = (i == MAX_SIZE-1);
  69                 break;
  70             }
  71         }
  72
  73         return true;
  74     }
  75
  76     bool get(uint8_t& d1, uint8_t& d2, uint8_t& d3)
  77     {
  78         if (empty)
  79             return false;
  80
  81         full = false;
  82
  83         if (data[index].d1 == 0)
  84         {
  85             index = 0;
  86             empty = true;
  87
  88             return false;
  89         }
  90
  91         d1 = data[index].d1;
  92         d2 = data[index].d2;
  93         d3 = data[index].d3;
  94
  95         data[index].d1 = data[index].d2 = data[index].d3 = 0;
  96         empty = false;
  97         ++index;
  98
  99         return true;
 100     }
 101
 102     bool tryToCopyDataFrom(MIDIEventQueue& queue) noexcept
 103     {
 104         const CarlaMutexTryLocker cml(queue.mutex);
 105
 106         if (cml.wasNotLocked())
 107             return false;
 108
 109         // copy data from queue
 110         carla_copyStruct(data, queue.data);
 111         index = queue.index;
 112         empty = queue.empty;
 113         full  = queue.full;
 114
 115         // reset queque
 116         carla_zeroStruct(queue.data);
 117         queue.index = 0;
 118         queue.empty = true;
 119         queue.full  = false;
 120
 121         return true;
 122     }
 123
 124 private:
 125     struct MIDIEvent {
 126         uint8_t d1, d2, d3;
 127
 128         MIDIEvent() noexcept
 129             : d1(0), d2(0), d3(0) {}
 130     };
 131
 132     MIDIEvent data[MAX_SIZE];
 133     uint16_t index;
 134     volatile bool empty, full;
 135
 136     CarlaMutex mutex;
 137 };
 138
 139 #endif // MIDI_QUEUE_HPP_INCLUDED