common/JackMidiPort.cpp

   1 /*
   2 Copyright (C) 2007 Dmitry Baikov
   3 Original JACK MIDI implementation Copyright (C) 2004 Ian Esten
   4
   5 This program is free software; you can redistribute it and/or modify
   6 it under the terms of the GNU Lesser General Public License as published by
   7 the Free Software Foundation; either version 2.1 of the License, or
   8 (at your option) 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 Lesser General Public License for more details.
  14
  15 You should have received a copy of the GNU Lesser General Public License
  16 along with this program; if not, write to the Free Software
  17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18
  19 */
  20
  21 #include "JackError.h"
  22 #include "JackPortType.h"
  23 #include "JackMidiPort.h"
  24 #include <assert.h>
  25 #include <string.h>
  26
  27 namespace Jack
  28 {
  29
  30 SERVER_EXPORT void JackMidiBuffer::Reset(jack_nframes_t nframes)
  31 {
  32     /* This line ate 1 hour of my life... dsbaikov */
  33     this->nframes = nframes;
  34     write_pos = 0;
  35     event_count = 0;
  36     lost_events = 0;
  37     mix_index = 0;
  38 }
  39
  40 SERVER_EXPORT jack_shmsize_t JackMidiBuffer::MaxEventSize() const
  41 {
  42     assert (((jack_shmsize_t) - 1) < 0); // jack_shmsize_t should be signed
  43     jack_shmsize_t left = buffer_size - (sizeof(JackMidiBuffer) + sizeof(JackMidiEvent) * (event_count + 1) + write_pos);
  44     if (left < 0)
  45         return 0;
  46     if (left <= JackMidiEvent::INLINE_SIZE_MAX)
  47         return JackMidiEvent::INLINE_SIZE_MAX;
  48     return left;
  49 }
  50
  51 SERVER_EXPORT jack_midi_data_t* JackMidiBuffer::ReserveEvent(jack_nframes_t time, jack_shmsize_t size)
  52 {
  53     jack_shmsize_t space = MaxEventSize();
  54     if (space == 0 || size > space) {
  55         lost_events++;
  56         return 0;
  57     }
  58     JackMidiEvent* event = &events[event_count++];
  59     event->time = time;
  60     event->size = size;
  61     if (size <= JackMidiEvent::INLINE_SIZE_MAX)
  62         return event->data;
  63
  64     write_pos += size;
  65     event->offset = buffer_size - write_pos;
  66     return (jack_midi_data_t*)this + event->offset;
  67 }
  68
  69 static void MidiBufferInit(void* buffer, size_t buffer_size, jack_nframes_t nframes)
  70 {
  71     JackMidiBuffer* midi = (JackMidiBuffer*)buffer;
  72     midi->magic = JackMidiBuffer::MAGIC;
  73     /* Since port buffer has actually always BUFFER_SIZE_MAX frames, we can safely use all the size */
  74     midi->buffer_size = BUFFER_SIZE_MAX * sizeof(jack_default_audio_sample_t);
  75     midi->Reset(nframes);
  76 }
  77
  78 /*
  79  * The mixdown function below, is a simplest (read slowest) implementation possible.
  80  * But, since it is unlikely that it will mix many buffers with many events,
  81  * it should perform quite good.
  82  * More efficient (and possibly, fastest possible) implementation (it exists),
  83  * using calendar queue algorithm is about 3 times bigger, and uses alloca().
  84  * So, let's listen to D.Knuth about premature optimisation, a leave the current
  85  * implementation as is, until it is proved to be a bottleneck.
  86  * Dmitry Baikov.
  87  */
  88 static void MidiBufferMixdown(void* mixbuffer, void** src_buffers, int src_count, jack_nframes_t nframes)
  89 {
  90     JackMidiBuffer* mix = static_cast<JackMidiBuffer*>(mixbuffer);
  91     if (!mix->IsValid()) {
  92         jack_error("Jack::MidiBufferMixdown - invalid mix buffer");
  93         return;
  94     }
  95     mix->Reset(nframes);
  96
  97     int event_count = 0;
  98     for (int i = 0; i < src_count; ++i) {
  99         JackMidiBuffer* buf = static_cast<JackMidiBuffer*>(src_buffers[i]);
 100         if (!buf->IsValid()) {
 101             jack_error("Jack::MidiBufferMixdown - invalid source buffer");
 102             return;
 103         }
 104         buf->mix_index = 0;
 105         event_count += buf->event_count;
 106         mix->lost_events += buf->lost_events;
 107     }
 108
 109     int events_done;
 110     for (events_done = 0; events_done < event_count; ++events_done) {
 111         JackMidiBuffer* next_buf = 0;
 112         JackMidiEvent* next_event = 0;
 113
 114         // find the earliest event
 115         for (int i = 0; i < src_count; ++i) {
 116             JackMidiBuffer* buf = static_cast<JackMidiBuffer*>(src_buffers[i]);
 117             if (buf->mix_index >= buf->event_count)
 118                 continue;
 119             JackMidiEvent* e = &buf->events[buf->mix_index];
 120             if (!next_event || e->time < next_event->time) {
 121                 next_event = e;
 122                 next_buf = buf;
 123             }
 124         }
 125         assert(next_event != 0);
 126
 127         // write the event
 128         jack_midi_data_t* dest = mix->ReserveEvent(next_event->time, next_event->size);
 129         if (!dest)
 130             break;
 131         memcpy(dest, next_event->GetData(next_buf), next_event->size);
 132         next_buf->mix_index++;
 133     }
 134     mix->lost_events += event_count - events_done;
 135 }
 136
 137 static size_t MidiBufferSize()
 138 {
 139     return BUFFER_SIZE_MAX * sizeof(jack_default_audio_sample_t);
 140 }
 141
 142 const JackPortType gMidiPortType =
 143 {
 144     JACK_DEFAULT_MIDI_TYPE,
 145     MidiBufferSize,
 146     MidiBufferInit,
 147     MidiBufferMixdown
 148 };
 149
 150 } // namespace Jack