libjack/midiport.c

   1 /*
   2     Copyright (C) 2004-2006 Ian Esten
   3     Copyright (C) 2006 Dave Robillard
   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 #include <assert.h>
  21 #include <stdio.h>
  22 #include <string.h>
  23 #include <errno.h>
  24
  25 #include <jack/jack.h>
  26 #include <jack/midiport.h>
  27 #include <jack/port.h>
  28
  29
  30 enum { MIDI_INLINE_MAX = sizeof(jack_shmsize_t) };
  31
  32
  33 typedef struct _jack_midi_port_info_private {
  34         jack_nframes_t        nframes; /**< Number of frames in buffer */
  35         uint32_t                buffer_size; /**< Size of buffer in bytes */
  36         jack_nframes_t        event_count; /**< Number of events stored in this buffer */
  37         jack_nframes_t        last_write_loc; /**< Used for both writing and mixdown */
  38         jack_nframes_t        events_lost;        /**< Number of events lost in this buffer */
  39 } POST_PACKED_STRUCTURE jack_midi_port_info_private_t;
  40
  41 typedef struct _jack_midi_port_internal_event {
  42         int32_t        time;
  43         jack_shmsize_t size;
  44         union {
  45                 jack_shmsize_t byte_offset;
  46                 jack_midi_data_t inline_data[MIDI_INLINE_MAX];
  47         } POST_PACKED_STRUCTURE;
  48 } POST_PACKED_STRUCTURE jack_midi_port_internal_event_t;
  49
  50
  51 static inline jack_midi_data_t*
  52 jack_midi_event_data(void* port_buffer,
  53                      const jack_midi_port_internal_event_t* event)
  54 {
  55         if (event->size <= MIDI_INLINE_MAX)
  56                 return (jack_midi_data_t*) event->inline_data;
  57         else
  58                 return ((jack_midi_data_t *)port_buffer) + event->byte_offset;
  59 }
  60
  61
  62 /* jack_midi_port_functions.buffer_init */
  63 static void
  64 jack_midi_buffer_init(void  *port_buffer,
  65                        size_t buffer_size,
  66                        jack_nframes_t nframes)
  67 {
  68         jack_midi_port_info_private_t *info =
  69                 (jack_midi_port_info_private_t *) port_buffer;
  70         /* We can also add some magic field to midi buffer to validate client calls */
  71         info->nframes = nframes;
  72         info->buffer_size = buffer_size;
  73         info->event_count = 0;
  74         info->last_write_loc = 0;
  75         info->events_lost = 0;
  76 }
  77
  78
  79 jack_nframes_t
  80 jack_midi_get_event_count(void           *port_buffer)
  81 {
  82         jack_midi_port_info_private_t *info =
  83                 (jack_midi_port_info_private_t *) port_buffer;
  84         return info->event_count;
  85 }
  86
  87
  88 int
  89 jack_midi_event_get(jack_midi_event_t *event,
  90                     void              *port_buffer,
  91                     jack_nframes_t     event_idx)
  92 {
  93         jack_midi_port_internal_event_t *port_event;
  94         jack_midi_port_info_private_t *info =
  95                 (jack_midi_port_info_private_t *) port_buffer;
  96
  97         if (event_idx >= info->event_count)
  98 #ifdef ENODATA
  99                 return ENODATA;
 100 #else
 101                 return ENOMSG;
 102 #endif
 103
 104         port_event = (jack_midi_port_internal_event_t *) (info + 1);
 105         port_event += event_idx;
 106         event->time = port_event->time;
 107         event->size = port_event->size;
 108         event->buffer = jack_midi_event_data(port_buffer, port_event);
 109
 110         return 0;
 111 }
 112
 113
 114 size_t
 115 jack_midi_max_event_size(void           *port_buffer)
 116 {
 117         jack_midi_port_info_private_t *info =
 118                 (jack_midi_port_info_private_t *) port_buffer;
 119         size_t buffer_size =
 120                 info->buffer_size;
 121
 122         /* (event_count + 1) below accounts for jack_midi_port_internal_event_t
 123          * which would be needed to store the next event */
 124         size_t used_size = sizeof(jack_midi_port_info_private_t)
 125                 + info->last_write_loc
 126                 + ((info->event_count + 1)
 127                    * sizeof(jack_midi_port_internal_event_t));
 128
 129         if (used_size > buffer_size)
 130                 return 0;
 131         else if ((buffer_size - used_size) < MIDI_INLINE_MAX)
 132                 return MIDI_INLINE_MAX;
 133         else
 134                 return (buffer_size - used_size);
 135 }
 136
 137
 138 jack_midi_data_t*
 139 jack_midi_event_reserve(void           *port_buffer,
 140                         jack_nframes_t  time,
 141                         size_t          data_size)
 142 {
 143         jack_midi_data_t *retbuf = (jack_midi_data_t *) port_buffer;
 144
 145         jack_midi_port_info_private_t *info =
 146                 (jack_midi_port_info_private_t *) port_buffer;
 147         jack_midi_port_internal_event_t *event_buffer =
 148                 (jack_midi_port_internal_event_t *) (info + 1);
 149         size_t buffer_size =
 150                 info->buffer_size;
 151
 152         if (time < 0 || time >= info->nframes)
 153                 goto failed;
 154
 155         if (info->event_count > 0 && time < event_buffer[info->event_count-1].time)
 156                 goto failed;
 157
 158         /* Check if data_size is >0 and there is enough space in the buffer for the event. */
 159         if (data_size <=0) {
 160                 goto failed; // return NULL?
 161         } else if (jack_midi_max_event_size (port_buffer) < data_size) {
 162                 goto failed;
 163         } else {
 164                 jack_midi_port_internal_event_t *event = &event_buffer[info->event_count];
 165
 166                 event->time = time;
 167                 event->size = data_size;
 168                 if (data_size <= MIDI_INLINE_MAX) {
 169                         retbuf = event->inline_data;
 170                 } else {
 171                         info->last_write_loc += data_size;
 172                         retbuf = &retbuf[buffer_size - 1 - info->last_write_loc];
 173                         event->byte_offset =
 174                                 buffer_size - 1 - info->last_write_loc;
 175                 }
 176                 info->event_count += 1;
 177                 return retbuf;
 178         }
 179  failed:
 180         info->events_lost++;
 181         return NULL;
 182 }
 183
 184
 185 int
 186 jack_midi_event_write(void                   *port_buffer,
 187                       jack_nframes_t          time,
 188                       const jack_midi_data_t *data,
 189                       size_t                  data_size)
 190 {
 191         jack_midi_data_t *retbuf =
 192                 jack_midi_event_reserve(port_buffer, time, data_size);
 193
 194         if (retbuf) {
 195                 memcpy(retbuf, data, data_size);
 196                 return 0;
 197         } else {
 198                 return ENOBUFS;
 199         }
 200 }
 201
 202
 203 /* Can't check to make sure this port is an output anymore.  If this gets
 204  * called on an input port, all clients after the client that calls it
 205  * will think there are no events in the buffer as the event count has
 206  * been reset.
 207  */
 208 void
 209 jack_midi_clear_buffer(void           *port_buffer)
 210 {
 211         jack_midi_port_info_private_t *info =
 212                 (jack_midi_port_info_private_t *) port_buffer;
 213
 214         info->event_count = 0;
 215         info->last_write_loc = 0;
 216         info->events_lost = 0;
 217 }
 218
 219
 220 /* jack_midi_port_functions.mixdown */
 221 static void
 222 jack_midi_port_mixdown(jack_port_t    *port, jack_nframes_t nframes)
 223 {
 224         JSList         *node;
 225         jack_port_t    *input;
 226         jack_nframes_t  num_events = 0;
 227         jack_nframes_t  i          = 0;
 228         int             err        = 0;
 229         jack_nframes_t  lost_events = 0;
 230
 231         /* The next (single) event to mix in to the buffer */
 232         jack_midi_port_info_private_t   *earliest_info;
 233         jack_midi_port_internal_event_t *earliest_event;
 234         jack_midi_data_t                *earliest_buffer;
 235
 236         jack_midi_port_info_private_t   *in_info;   /* For finding next event */
 237         jack_midi_port_internal_event_t *in_events; /* Corresponds to in_info */
 238         jack_midi_port_info_private_t   *out_info;  /* Output 'buffer' */
 239
 240         jack_midi_clear_buffer(port->mix_buffer);
 241
 242         out_info = (jack_midi_port_info_private_t *) port->mix_buffer;
 243
 244         /* This function uses jack_midi_port_info_private_t.last_write_loc of the
 245          * source ports to store indices of the last event read from that buffer
 246          * so far.  This is OK because last_write_loc is used when writing events
 247          * to a buffer, which at this stage is already complete so the value
 248          * can be safely smashed. */
 249
 250         /* Iterate through all connections to see how many events we need to mix,
 251          * and initialise their 'last event read' (last_write_loc) to 0 */
 252         for (node = port->connections; node; node = jack_slist_next(node)) {
 253                 input = (jack_port_t *) node->data;
 254                 in_info =
 255                         (jack_midi_port_info_private_t *) jack_output_port_buffer(input);
 256                 num_events += in_info->event_count;
 257                 lost_events += in_info->events_lost;
 258                 in_info->last_write_loc = 0;
 259         }
 260
 261         /* Write the events in the order of their timestamps */
 262         for (i = 0; i < num_events; ++i) {
 263                 earliest_info = NULL;
 264                 earliest_event = NULL;
 265                 earliest_buffer = NULL;
 266
 267                 /* Find the earliest unread event, to mix next
 268                  * (search for an event earlier than earliest_event) */
 269                 for (node = port->connections; node; node = jack_slist_next(node)) {
 270                         in_info = (jack_midi_port_info_private_t *)
 271                                 jack_output_port_buffer(((jack_port_t *) node->data));
 272                         in_events = (jack_midi_port_internal_event_t *) (in_info + 1);
 273
 274                         /* If there are unread events left in this port.. */
 275                         if (in_info->event_count > in_info->last_write_loc) {
 276                                 /* .. and this event is the new earliest .. */
 277                                 /* NOTE: that's why we compare time with <, not <= */
 278                                 if (earliest_info == NULL
 279                                                 || in_events[in_info->last_write_loc].time
 280                                                < earliest_event->time) {
 281                                         /* .. then set this event as the next earliest */
 282                                         earliest_info = in_info;
 283                                         earliest_event = (jack_midi_port_internal_event_t *)
 284                                                 (&in_events[in_info->last_write_loc]);
 285                                 }
 286                         }
 287                 }
 288
 289                 if (earliest_info && earliest_event) {
 290                         earliest_buffer = (jack_midi_data_t *) earliest_info;
 291
 292                         /* Write event to output */
 293                         err = jack_midi_event_write(
 294                                 jack_port_buffer(port),
 295                                 earliest_event->time,
 296                                 jack_midi_event_data(earliest_buffer, earliest_event),
 297                                 earliest_event->size);
 298
 299                         earliest_info->last_write_loc++;
 300
 301                         if (err) {
 302                                 out_info->events_lost = num_events - i;
 303                                 break;
 304                         }
 305                 }
 306         }
 307         assert(out_info->event_count == num_events - out_info->events_lost);
 308
 309         // inherit total lost events count from all connected ports.
 310         out_info->events_lost += lost_events;
 311 }
 312
 313
 314 jack_nframes_t
 315 jack_midi_get_lost_event_count(void           *port_buffer)
 316 {
 317         return ((jack_midi_port_info_private_t *) port_buffer)->events_lost;
 318 }
 319
 320 jack_port_functions_t jack_builtin_midi_functions = {
 321         .buffer_init    = jack_midi_buffer_init,
 322         .mixdown = jack_midi_port_mixdown,
 323 };