libs/ardour/midi_buffer.cc

   1 /*
   2     Copyright (C) 2006-2007 Paul Davis
   3         Author: Dave Robillard
   4
   5     This program is free software; you can redistribute it and/or modify it
   6     under the terms of the GNU General Public License as published by the Free
   7     Software Foundation; either version 2 of the License, or (at your option)
   8     any later version.
   9
  10     This program is distributed in the hope that it will be useful, but WITHOUT
  11     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  12     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  13     for more details.
  14
  15     You should have received a copy of the GNU General Public License along
  16     with this program; if not, write to the Free Software Foundation, Inc.,
  17     675 Mass Ave, Cambridge, MA 02139, USA.
  18 */
  19
  20 #include <iostream>
  21
  22 #include "pbd/malign.h"
  23 #include "pbd/compose.h"
  24 #include "pbd/debug.h"
  25
  26 #include "ardour/debug.h"
  27 #include "ardour/midi_buffer.h"
  28
  29 using namespace std;
  30 using namespace ARDOUR;
  31 using namespace PBD;
  32
  33 // FIXME: mirroring for MIDI buffers?
  34 MidiBuffer::MidiBuffer(size_t capacity)
  35         : Buffer(DataType::MIDI, capacity)
  36         , _data(0)
  37 {
  38         if (capacity) {
  39                 resize(_capacity);
  40                 silence(_capacity);
  41         }
  42 }
  43
  44 MidiBuffer::~MidiBuffer()
  45 {
  46         free(_data);
  47 }
  48
  49 void
  50 MidiBuffer::resize(size_t size)
  51 {
  52         assert(size > 0);
  53
  54         if (size < _capacity) {
  55                 return;
  56         }
  57
  58         free(_data);
  59
  60         _size = 0;
  61         _capacity = size;
  62         cache_aligned_malloc ((void**) &_data, _capacity);
  63
  64         assert(_data);
  65 }
  66
  67 void
  68 MidiBuffer::copy(const MidiBuffer& copy)
  69 {
  70         assert(_capacity >= copy._size);
  71         _size = copy._size;
  72         memcpy(_data, copy._data, copy._size);
  73 }
  74
  75
  76 /** Read events from @a src starting at time @a offset into the START of this buffer, for
  77  * time duration @a nframes.  Relative time, where 0 = start of buffer.
  78  *
  79  * Note that offset and nframes refer to sample time, NOT buffer offsets or event counts.
  80  */
  81 void
  82 MidiBuffer::read_from (const Buffer& src, nframes_t nframes, nframes_t dst_offset, nframes_t src_offset)
  83 {
  84         assert (src.type() == DataType::MIDI);
  85         assert (&src != this);
  86
  87         const MidiBuffer& msrc = (MidiBuffer&) src;
  88
  89         assert (_capacity >= msrc.size());
  90
  91         if (dst_offset == 0) {
  92                 clear ();
  93                 assert (_size == 0);
  94         }
  95
  96         /* XXX use dst_offset somehow */
  97
  98         for (MidiBuffer::const_iterator i = msrc.begin(); i != msrc.end(); ++i) {
  99                 const Evoral::MIDIEvent<TimeType> ev(*i, false);
 100                 if (ev.time() >= src_offset && ev.time() < (nframes+src_offset)) {
 101                         push_back (ev);
 102                 } else {
 103                         cerr << "MIDI event @ " <<  ev.time() << " skipped, not within range " << src_offset << " .. "
 104                              << (nframes + src_offset) << endl;
 105                 }
 106         }
 107
 108         _silent = src.silent();
 109 }
 110
 111 void
 112 MidiBuffer::merge_from (const Buffer& src, nframes_t /*nframes*/, nframes_t /*dst_offset*/, nframes_t /*src_offset*/)
 113 {
 114         const MidiBuffer* mbuf = dynamic_cast<const MidiBuffer*>(&src);
 115         assert (mbuf);
 116         assert (mbuf != this);
 117
 118         /* XXX use nframes, and possible offsets */
 119         merge_in_place (*mbuf);
 120 }
 121
 122 /** Push an event into the buffer.
 123  *
 124  * Note that the raw MIDI pointed to by ev will be COPIED and unmodified.
 125  * That is, the caller still owns it, if it needs freeing it's Not My Problem(TM).
 126  * Realtime safe.
 127  * @return false if operation failed (not enough room)
 128  */
 129 bool
 130 MidiBuffer::push_back(const Evoral::MIDIEvent<TimeType>& ev)
 131 {
 132         const size_t stamp_size = sizeof(TimeType);
 133         /*cerr << "MidiBuffer: pushing event @ " << ev.time()
 134                 << " size = " << ev.size() << endl;*/
 135
 136         if (_size + stamp_size + ev.size() >= _capacity) {
 137                 cerr << "MidiBuffer::push_back failed (buffer is full)" << endl;
 138                 return false;
 139         }
 140
 141         if (!Evoral::midi_event_is_valid(ev.buffer(), ev.size())) {
 142                 cerr << "WARNING: MidiBuffer ignoring illegal MIDI event" << endl;
 143                 return false;
 144         }
 145
 146         push_back(ev.time(), ev.size(), ev.buffer());
 147
 148         return true;
 149 }
 150
 151
 152 /** Push an event into the buffer.
 153  * @return false if operation failed (not enough room)
 154  */
 155 bool
 156 MidiBuffer::push_back(TimeType time, size_t size, const uint8_t* data)
 157 {
 158         const size_t stamp_size = sizeof(TimeType);
 159
 160 #ifndef NDEBUG
 161                 DEBUG_STR_DECL(a);
 162                 DEBUG_STR_APPEND(a, string_compose ("midibuffer %1 push event @ %2 sz %3 ", this, time, size));
 163                 for (size_t i=0; i < size; ++i) {
 164                         DEBUG_STR_APPEND(a,hex);
 165                         DEBUG_STR_APPEND(a,"0x");
 166                         DEBUG_STR_APPEND(a,(int)data[i]);
 167                         DEBUG_STR_APPEND(a,' ');
 168                 }
 169                 DEBUG_STR_APPEND(a,'\n');
 170                 DEBUG_TRACE (DEBUG::MidiIO, DEBUG_STR(a).str());
 171 #endif
 172
 173         // cerr << "MidiBuffer: pushing event @ " << time
 174         // << " size = " << size << endl;
 175
 176         if (_size + stamp_size + size >= _capacity) {
 177                 cerr << "MidiBuffer::push_back failed (buffer is full)" << endl;
 178                 return false;
 179         }
 180
 181         if (!Evoral::midi_event_is_valid(data, size)) {
 182                 cerr << "WARNING: MidiBuffer ignoring illegal MIDI event" << endl;
 183                 return false;
 184         }
 185
 186         uint8_t* const write_loc = _data + _size;
 187         *((TimeType*)write_loc) = time;
 188         memcpy(write_loc + stamp_size, data, size);
 189
 190         _size += stamp_size + size;
 191         _silent = false;
 192
 193         return true;
 194 }
 195
 196
 197 /** Push an event into the buffer.
 198  *
 199  * Note that the raw MIDI pointed to by ev will be COPIED and unmodified.
 200  * That is, the caller still owns it, if it needs freeing it's Not My Problem(TM).
 201  * Realtime safe.
 202  * @return false if operation failed (not enough room)
 203  */
 204 bool
 205 MidiBuffer::push_back(const jack_midi_event_t& ev)
 206 {
 207         const size_t stamp_size = sizeof(TimeType);
 208         if (_size + stamp_size + ev.size >= _capacity) {
 209                 cerr << "MidiBuffer::push_back failed (buffer is full)" << endl;
 210                 return false;
 211         }
 212
 213         if (!Evoral::midi_event_is_valid(ev.buffer, ev.size)) {
 214                 cerr << "WARNING: MidiBuffer ignoring illegal MIDI event" << endl;
 215                 return false;
 216         }
 217
 218         uint8_t* const write_loc = _data + _size;
 219         *((TimeType*)write_loc) = ev.time;
 220         memcpy(write_loc + stamp_size, ev.buffer, ev.size);
 221
 222         _size += stamp_size + ev.size;
 223         _silent = false;
 224
 225         return true;
 226 }
 227
 228
 229 /** Reserve space for a new event in the buffer.
 230  *
 231  * This call is for copying MIDI directly into the buffer, the data location
 232  * (of sufficient size to write \a size bytes) is returned, or 0 on failure.
 233  * This call MUST be immediately followed by a write to the returned data
 234  * location, or the buffer will be corrupted and very nasty things will happen.
 235  */
 236 uint8_t*
 237 MidiBuffer::reserve(TimeType time, size_t size)
 238 {
 239         const size_t stamp_size = sizeof(TimeType);
 240         if (_size + stamp_size + size >= _capacity) {
 241                 return 0;
 242         }
 243
 244         // write timestamp
 245         uint8_t* write_loc = _data + _size;
 246         *((TimeType*)write_loc) = time;
 247
 248         // move write_loc to begin of MIDI buffer data to write to
 249         write_loc += stamp_size;
 250
 251         _size += stamp_size + size;
 252         _silent = false;
 253
 254         return write_loc;
 255 }
 256
 257
 258 void
 259 MidiBuffer::silence (nframes_t /*nframes*/, nframes_t /*offset*/)
 260 {
 261         /* XXX iterate over existing events, find all in range given by offset & nframes,
 262            and delete them.
 263         */
 264
 265         _size = 0;
 266         _silent = true;
 267 }
 268
 269 /** Merge \a other into this buffer.  Realtime safe. */
 270 bool
 271 MidiBuffer::merge_in_place(const MidiBuffer &other)
 272 {
 273         if (other.size() == 0) {
 274                 return true;
 275         }
 276
 277         if (_size == 0) {
 278                 copy(other);
 279                 return true;
 280         }
 281
 282         if (_size + other.size() > _capacity) {
 283                 cerr << "MidiBuffer::merge failed (no space)" << endl;
 284                 return false;
 285         }
 286
 287 #ifndef NDEBUG
 288         size_t   test_orig_us_size   = _size;
 289         size_t   test_orig_them_size = other._size;
 290         TimeType test_time           = 0;
 291         size_t   test_us_count       = 0;
 292         size_t   test_them_count     = 0;
 293         for (iterator i = begin(); i != end(); ++i) {
 294                 assert(Evoral::midi_event_is_valid((*i).buffer(), (*i).size()));
 295                 assert((*i).time() >= test_time);
 296                 test_time = (*i).time();
 297                 ++test_us_count;
 298         }
 299         test_time = 0;
 300         for (const_iterator i = other.begin(); i != other.end(); ++i) {
 301                 assert(Evoral::midi_event_is_valid((*i).buffer(), (*i).size()));
 302                 assert((*i).time() >= test_time);
 303                 test_time = (*i).time();
 304                 ++test_them_count;
 305         }
 306 #endif
 307
 308         const_iterator them = other.begin();
 309         iterator us = begin();
 310
 311         while (them != other.end()) {
 312
 313                 size_t sz = 0;
 314                 ssize_t src = -1;
 315
 316                 /* gather up total size of events that are earlier than
 317                    the event referenced by "us"
 318                 */
 319
 320                 while (them != other.end() && (*them).time() <= (*us).time()) {
 321                         if (src == -1) {
 322                                 src = them.offset;
 323                         }
 324                         sz += sizeof (TimeType) + (*them).size();
 325                         ++them;
 326                 }
 327
 328 #if 0
 329                 if (us != end())
 330                         cerr << "us @ " << (*us).time() << endl;
 331                 if (them != other.end())
 332                         cerr << "them @ " << (*them).time() << endl;
 333 #endif
 334
 335                 if (sz) {
 336                         assert(src >= 0);
 337                         /* move existing */
 338                         memmove (_data + us.offset + sz, _data + us.offset, _size - us.offset);
 339                         /* increase _size */
 340                         _size += sz;
 341                         assert(_size <= _capacity);
 342                         /* insert new stuff */
 343                         memcpy  (_data + us.offset, other._data + src, sz);
 344                         /* update iterator to our own events. this is a miserable hack */
 345                         us.offset += sz;
 346                 } else {
 347
 348                         /* advance past our own events to get to the correct insertion
 349                            point for the next event(s) from "other"
 350                         */
 351
 352                         while (us != end() && (*us).time() < (*them).time()) {
 353                                 ++us;
 354                         }
 355                 }
 356
 357                 if (!(us != end())) {
 358                         /* just append the rest of other */
 359                         memcpy (_data + us.offset, other._data + them.offset, other._size - them.offset);
 360                         _size += other._size - them.offset;
 361                         break;
 362                 }
 363         }
 364
 365 #ifndef NDEBUG
 366         assert(_size == test_orig_us_size + test_orig_them_size);
 367         size_t test_final_count = 0;
 368         test_time = 0;
 369         for (iterator i = begin(); i != end(); ++i) {
 370                 // cerr << "CHECK " << test_final_count << " / " << test_us_count + test_them_count << endl;
 371                 assert(Evoral::midi_event_is_valid((*i).buffer(), (*i).size()));
 372                 assert((*i).time() >= test_time);
 373                 test_time = (*i).time();
 374                 ++test_final_count;
 375         }
 376         assert(test_final_count = test_us_count + test_them_count);
 377 #endif
 378
 379         return true;
 380 }
 381
 382 /** Clear, and merge \a a and \a b into this buffer.
 383  *
 384  * \return true if complete merge was successful
 385  */
 386 bool
 387 MidiBuffer::merge(const MidiBuffer& a, const MidiBuffer& b)
 388 {
 389         _size = 0;
 390
 391         if (this == &a) {
 392             return merge_in_place(b);
 393         } else if (this == &b) {
 394             return merge_in_place(a);
 395         }
 396
 397         const_iterator ai = a.begin();
 398         const_iterator bi = b.begin();
 399
 400         resize(a.size() + b.size());
 401         while (ai != a.end() && bi != b.end()) {
 402                 if ((*ai).time() < (*bi).time()) {
 403                         memcpy(_data + _size, (*ai).buffer(), (*ai).size());
 404                         _size += (*ai).size();
 405                         ++ai;
 406                 } else {
 407                         memcpy(_data + _size, (*bi).buffer(), (*bi).size());
 408                         _size += (*bi).size();
 409                         ++bi;
 410                 }
 411         }
 412
 413         while (ai != a.end()) {
 414                 memcpy(_data + _size, (*ai).buffer(), (*ai).size());
 415                 _size += (*ai).size();
 416                 ++ai;
 417         }
 418
 419         while (bi != b.end()) {
 420                 memcpy(_data + _size, (*bi).buffer(), (*bi).size());
 421                 _size += (*bi).size();
 422                 ++bi;
 423         }
 424
 425         return true;
 426 }
 427