libs/ardour/midi_ring_buffer.cc

   1 /*
   2     Copyright (C) 2006-2008 Paul Davis
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17 */
  18
  19 #include "pbd/compose.h"
  20 #include "pbd/enumwriter.h"
  21 #include "pbd/error.h"
  22
  23 #include "ardour/debug.h"
  24 #include "ardour/midi_ring_buffer.h"
  25 #include "ardour/midi_buffer.h"
  26 #include "ardour/event_type_map.h"
  27
  28 using namespace std;
  29 using namespace PBD;
  30
  31 namespace ARDOUR {
  32
  33 /** Read a block of MIDI events from this buffer into a MidiBuffer.
  34  *
  35  * Timestamps of events returned are relative to start (i.e. event with stamp 0
  36  * occurred at start), with offset added.
  37  */
  38 template<typename T>
  39 size_t
  40 MidiRingBuffer<T>::read(MidiBuffer& dst, framepos_t start, framepos_t end, framecnt_t offset, bool stop_on_overflow_in_dst)
  41 {
  42         if (this->read_space() == 0) {
  43                 return 0;
  44         }
  45
  46         T                 ev_time;
  47         uint32_t          ev_size;
  48         size_t            count = 0;
  49         const size_t      prefix_size = sizeof(T) + sizeof(Evoral::EventType) + sizeof(uint32_t);
  50
  51         while (this->read_space() >= prefix_size) {
  52
  53                 uint8_t peekbuf[prefix_size];
  54
  55                 /* this cannot fail, because we've already verified that there
  56                    is prefix_space to read
  57                 */
  58                 this->peek (peekbuf, prefix_size);
  59
  60                 ev_time = *(reinterpret_cast<T*>((uintptr_t)peekbuf));
  61                 ev_size = *(reinterpret_cast<uint32_t*>((uintptr_t)(peekbuf + sizeof(T) + sizeof (Evoral::EventType))));
  62
  63                 if (this->read_space() < ev_size) {
  64                         break;;
  65                 }
  66
  67                 if (ev_time >= end) {
  68                         DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("MRB event @ %1 past end @ %2\n", ev_time, end));
  69                         break;
  70                 } else if (ev_time < start) {
  71                         DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("MRB event @ %1 before start @ %2\n", ev_time, start));
  72                         break;
  73                 } else {
  74                         DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("MRB event @ %1 in range %2 .. %3\n", ev_time, start, end));
  75                 }
  76
  77                 ev_time -= start;
  78                 ev_time += offset;
  79
  80                 /* we're good to go ahead and read the data now but since we
  81                  * have the prefix data already, just skip over that
  82                  */
  83                 this->increment_read_ptr (prefix_size);
  84
  85                 uint8_t status;
  86                 bool r = this->peek (&status, sizeof(uint8_t));
  87                 assert (r); // If this failed, buffer is corrupt, all hope is lost
  88
  89                 /* lets see if we are going to be able to write this event into dst.
  90                  */
  91                 uint8_t* write_loc = dst.reserve (ev_time, ev_size);
  92                 if (write_loc == 0) {
  93                         if (stop_on_overflow_in_dst) {
  94                                 DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("MidiRingBuffer: overflow in destination MIDI buffer, stopped after %1 events\n", count));
  95                                 break;
  96                         }
  97                         error << "MRB: Unable to reserve space in buffer, event skipped" << endmsg;
  98                         this->increment_read_ptr (ev_size); // Advance read pointer to next event
  99                         continue;
 100                 }
 101
 102                 // write MIDI buffer contents
 103                 bool success = read_contents (ev_size, write_loc);
 104
 105 #ifndef NDEBUG
 106                 if (DEBUG::MidiDiskstreamIO && PBD::debug_bits) {
 107                         DEBUG_STR_DECL(a);
 108                         DEBUG_STR_APPEND(a, string_compose ("wrote MidiEvent to Buffer (time=%1, start=%2 offset=%3)", ev_time, start, offset));
 109                         for (size_t i=0; i < ev_size; ++i) {
 110                                 DEBUG_STR_APPEND(a,hex);
 111                                 DEBUG_STR_APPEND(a,"0x");
 112                                 DEBUG_STR_APPEND(a,(int)write_loc[i]);
 113                                 DEBUG_STR_APPEND(a,' ');
 114                         }
 115                         DEBUG_STR_APPEND(a,'\n');
 116                         DEBUG_TRACE (DEBUG::MidiDiskstreamIO, DEBUG_STR(a).str());
 117                 }
 118 #endif
 119
 120                 if (success) {
 121                         _tracker.track(write_loc);
 122                         ++count;
 123                 } else {
 124                         cerr << "WARNING: error reading event contents from MIDI ring" << endl;
 125                 }
 126         }
 127
 128         return count;
 129 }
 130
 131 template<typename T>
 132 size_t
 133 MidiRingBuffer<T>::skip_to(framepos_t start)
 134 {
 135         if (this->read_space() == 0) {
 136                 return 0;
 137         }
 138
 139         T                 ev_time;
 140         uint32_t          ev_size;
 141         size_t            count = 0;
 142         const size_t      prefix_size = sizeof(T) + sizeof(Evoral::EventType) + sizeof(uint32_t);
 143
 144         while (this->read_space() >= prefix_size) {
 145
 146                 uint8_t peekbuf[prefix_size];
 147                 this->peek (peekbuf, prefix_size);
 148
 149                 ev_time = *(reinterpret_cast<T*>((uintptr_t)peekbuf));
 150                 ev_size = *(reinterpret_cast<uint32_t*>((uintptr_t)(peekbuf + sizeof(T) + sizeof (Evoral::EventType))));
 151
 152                 if (ev_time >= start) {
 153                         return count;
 154                 }
 155
 156                 if (this->read_space() < ev_size) {
 157                         continue;
 158                 }
 159
 160                 this->increment_read_ptr (prefix_size);
 161
 162                 uint8_t status;
 163                 bool r = this->peek (&status, sizeof(uint8_t));
 164                 assert (r); // If this failed, buffer is corrupt, all hope is lost
 165
 166                 ++count;
 167
 168                 if (ev_size < 8) {
 169                         this->increment_read_ptr (ev_size);
 170                 } else {
 171                         // we only track note on/off, 8 bytes are plenty.
 172                         uint8_t write_loc[8];
 173                         bool success = read_contents (ev_size, write_loc);
 174                         if (success) {
 175                                 _tracker.track(write_loc);
 176                         }
 177                 }
 178         }
 179         return count;
 180 }
 181
 182
 183
 184 template<typename T>
 185 void
 186 MidiRingBuffer<T>::flush (framepos_t /*start*/, framepos_t end)
 187 {
 188         const size_t prefix_size = sizeof(T) + sizeof(Evoral::EventType) + sizeof(uint32_t);
 189
 190         while (this->read_space() >= prefix_size) {
 191                 uint8_t  peekbuf[prefix_size];
 192                 bool     success;
 193                 uint32_t ev_size;
 194                 T        ev_time;
 195
 196                 success = this->peek (peekbuf, prefix_size);
 197                 /* this cannot fail, because we've already verified that there
 198                    is prefix_space to read
 199                 */
 200                 assert (success);
 201
 202                 ev_time = *(reinterpret_cast<T*>((uintptr_t)peekbuf));
 203
 204                 if (ev_time >= end) {
 205                         break;
 206                 }
 207
 208                 ev_size = *(reinterpret_cast<uint32_t*>((uintptr_t)(peekbuf + sizeof(T) + sizeof (Evoral::EventType))));
 209                 this->increment_read_ptr (prefix_size);
 210                 this->increment_read_ptr (ev_size);
 211         }
 212 }
 213
 214 template<typename T>
 215 void
 216 MidiRingBuffer<T>::dump(ostream& str)
 217 {
 218         size_t rspace;
 219
 220         if ((rspace = this->read_space()) == 0) {
 221                 str << "MRB::dump: empty\n";
 222                 return;
 223         }
 224
 225         T                 ev_time;
 226         Evoral::EventType ev_type;
 227         uint32_t          ev_size;
 228
 229         RingBufferNPT<uint8_t>::rw_vector vec;
 230         RingBufferNPT<uint8_t>::get_read_vector (&vec);
 231
 232         if (vec.len[0] == 0) {
 233                 return;
 234         }
 235
 236         str << this << ": Dump size = " << vec.len[0] + vec.len[1]
 237             << " r@ " << RingBufferNPT<uint8_t>::get_read_ptr()
 238             << " w@" << RingBufferNPT<uint8_t>::get_write_ptr() << endl;
 239
 240
 241         uint8_t *buf = new uint8_t[vec.len[0] + vec.len[1]];
 242         memcpy (buf, vec.buf[0], vec.len[0]);
 243
 244         if (vec.len[1]) {
 245                 memcpy (buf+vec.len[1], vec.buf[1], vec.len[1]);
 246         }
 247
 248         uint8_t* data = buf;
 249         const uint8_t* end = buf + vec.len[0] + vec.len[1];
 250
 251         while (data < end) {
 252
 253                 memcpy (&ev_time, data, sizeof (T));
 254                 data += sizeof (T);
 255                 str << "\ttime " << ev_time;
 256
 257                 if (data >= end) {
 258                         str << "(incomplete)\n ";
 259                         break;
 260                 }
 261
 262                 memcpy (&ev_type, data, sizeof (ev_type));
 263                 data += sizeof (ev_type);
 264                 str << " type " << ev_type;
 265
 266                 if (data >= end) {
 267                         str << "(incomplete)\n";
 268                         break;
 269                 }
 270
 271                 memcpy (&ev_size, data, sizeof (ev_size));
 272                 data += sizeof (ev_size);
 273                 str << " size " << ev_size;
 274
 275                 if (data >= end) {
 276                         str << "(incomplete)\n";
 277                         break;
 278                 }
 279
 280                 for (uint32_t i = 0; i != ev_size && data < end; ++i) {
 281                         str << ' ' << hex << (int) data[i] << dec;
 282                 }
 283
 284                 data += ev_size;
 285
 286                 str << endl;
 287         }
 288
 289         delete [] buf;
 290 }
 291
 292 template<typename T>
 293 void
 294 MidiRingBuffer<T>::reset_tracker ()
 295 {
 296         _tracker.reset ();
 297 }
 298
 299 template<typename T>
 300 void
 301 MidiRingBuffer<T>::resolve_tracker (MidiBuffer& dst, framepos_t t)
 302 {
 303         _tracker.resolve_notes (dst, t);
 304 }
 305
 306 template class MidiRingBuffer<framepos_t>;
 307
 308 }  // namespace ARDOUR