Add matriseq, a step sequencer for the Novation Launchpad.

git-svn-id: http://svn.drobilla.net/lad/trunk/plugins/matriseq@4512 a436a847-0d15-0410-975c-d299462d15a1

4 files changed, 571 insertions, 0 deletions

diff --git a/zix/common.h b/zix/common.h
new file mode 100644
index 0000000..59e1f55
--- /dev/null
+++ b/zix/common.h
@@ -0,0 +1,83 @@
+/*
+  Copyright 2011 David Robillard <http://drobilla.net>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#ifndef ZIX_COMMON_H
+#define ZIX_COMMON_H
+
+/**
+   @addtogroup zix
+   @{
+*/
+
+/** @cond */
+#ifdef ZIX_SHARED
+#    ifdef _WIN32
+#        define ZIX_LIB_IMPORT __declspec(dllimport)
+#        define ZIX_LIB_EXPORT __declspec(dllexport)
+#    else
+#        define ZIX_LIB_IMPORT __attribute__((visibility("default")))
+#        define ZIX_LIB_EXPORT __attribute__((visibility("default")))
+#    endif
+#    ifdef ZIX_INTERNAL
+#        define ZIX_API ZIX_LIB_EXPORT
+#    else
+#        define ZIX_API ZIX_LIB_IMPORT
+#    endif
+#else
+#    define ZIX_API
+#endif
+/** @endcond */
+
+#ifdef __cplusplus
+extern "C" {
+#else
+#    include <stdbool.h>
+#endif
+
+typedef enum {
+	ZIX_STATUS_SUCCESS,
+	ZIX_STATUS_ERROR,
+	ZIX_STATUS_NO_MEM,
+	ZIX_STATUS_NOT_FOUND,
+	ZIX_STATUS_EXISTS,
+	ZIX_STATUS_BAD_ARG,
+	ZIX_STATUS_BAD_PERMS,
+} ZixStatus;
+
+/**
+   Function for comparing two elements.
+*/
+typedef int (*ZixComparator)(const void* a, const void* b, void* user_data);
+
+/**
+   Function for testing equality of two elements.
+*/
+typedef bool (*ZixEqualFunc)(const void* a, const void* b);
+
+/**
+   Function to destroy an element.
+*/
+typedef void (*ZixDestroyFunc)(void* ptr);
+
+/**
+   @}
+*/
+
+#ifdef __cplusplus
+}  /* extern "C" */
+#endif
+
+#endif  /* ZIX_COMMON_H */
diff --git a/zix/ring.c b/zix/ring.c
new file mode 100644
index 0000000..7ebbe67
--- /dev/null
+++ b/zix/ring.c
@@ -0,0 +1,225 @@
+/*
+  Copyright 2011 David Robillard <http://drobilla.net>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#ifdef HAVE_MLOCK
+#    include <sys/mman.h>
+#    define ZIX_MLOCK(ptr, size) mlock((ptr), (size))
+#elif defined(_WIN32)
+#    include <windows.h>
+#    define ZIX_MLOCK(ptr, size) VirtualLock((ptr), (size))
+#else
+#    pragma message("warning: No memory locking, possible RT violations")
+#    define ZIX_MLOCK(ptr, size)
+#endif
+
+#if defined(__APPLE__)
+#    include <libkern/OSAtomic.h>
+#    define ZIX_FULL_BARRIER() OSMemoryBarrier()
+#elif defined(_WIN32)
+#    include <windows.h>
+#    define ZIX_FULL_BARRIER() MemoryBarrier()
+#elif (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 1)
+#    define ZIX_FULL_BARRIER() __sync_synchronize()
+#else
+#    pragma message("warning: No memory barriers, possible SMP bugs")
+#    define ZIX_FULL_BARRIER()
+#endif
+
+/* No support for any systems with separate read and write barriers */
+#define ZIX_READ_BARRIER() ZIX_FULL_BARRIER()
+#define ZIX_WRITE_BARRIER() ZIX_FULL_BARRIER()
+
+#include "zix/ring.h"
+
+struct ZixRingImpl {
+	uint32_t write_head;  ///< Read index into buf
+	uint32_t read_head;   ///< Write index into buf
+	uint32_t size;        ///< Size (capacity) in bytes
+	uint32_t size_mask;   ///< Mask for fast modulo
+	char*    buf;         ///< Contents
+};
+
+static inline uint32_t
+next_power_of_two(uint32_t size)
+{
+	// http://graphics.stanford.edu/~seander/bithacks.html#RoundUpPowerOf2
+	size--;
+	size |= size >> 1;
+	size |= size >> 2;
+	size |= size >> 4;
+	size |= size >> 8;
+	size |= size >> 16;
+	size++;
+	return size;
+}
+
+ZixRing*
+zix_ring_new(uint32_t size)
+{
+	ZixRing* ring = (ZixRing*)malloc(sizeof(ZixRing));
+	ring->write_head = 0;
+	ring->read_head  = 0;
+	ring->size       = next_power_of_two(size);
+	ring->size_mask  = ring->size - 1;
+	ring->buf        = (char*)malloc(ring->size);
+	return ring;
+}
+
+void
+zix_ring_free(ZixRing* ring)
+{
+	free(ring->buf);
+	free(ring);
+}
+
+void
+zix_ring_mlock(ZixRing* ring)
+{
+	ZIX_MLOCK(ring, sizeof(ZixRing));
+	ZIX_MLOCK(ring->buf, ring->size);
+}
+
+void
+zix_ring_reset(ZixRing* ring)
+{
+	ring->write_head = 0;
+	ring->read_head  = 0;
+}
+
+static inline uint32_t
+read_space_internal(const ZixRing* ring, uint32_t r, uint32_t w)
+{
+	if (r < w) {
+		return w - r;
+	} else {
+		return (w - r + ring->size) & ring->size_mask;
+	}
+}
+
+uint32_t
+zix_ring_read_space(const ZixRing* ring)
+{
+	return read_space_internal(ring, ring->read_head, ring->write_head);
+}
+
+static inline uint32_t
+write_space_internal(const ZixRing* ring, uint32_t r, uint32_t w)
+{
+	if (r == w) {
+		return ring->size - 1;
+	} else if (r < w) {
+		return ((r - w + ring->size) & ring->size_mask) - 1;
+	} else {
+		return (r - w) - 1;
+	}
+}
+
+uint32_t
+zix_ring_write_space(const ZixRing* ring)
+{
+	return write_space_internal(ring, ring->read_head, ring->write_head);
+}
+
+uint32_t
+zix_ring_capacity(const ZixRing* ring)
+{
+	return ring->size - 1;
+}
+
+static inline uint32_t
+peek_internal(const ZixRing* ring, uint32_t r, uint32_t w,
+              uint32_t size, void* dst)
+{
+	if (read_space_internal(ring, r, w) < size) {
+		return 0;
+	}
+
+	if (r + size < ring->size) {
+		memcpy(dst, &ring->buf[r], size);
+	} else {
+		const uint32_t first_size = ring->size - r;
+		memcpy(dst, &ring->buf[r], first_size);
+		memcpy((char*)dst + first_size, &ring->buf[0], size - first_size);
+	}
+
+	return size;
+}
+
+uint32_t
+zix_ring_peek(ZixRing* ring, void* dst, uint32_t size)
+{
+	const uint32_t r = ring->read_head;
+	const uint32_t w = ring->write_head;
+
+	return peek_internal(ring, r, w, size, dst);
+}
+
+uint32_t
+zix_ring_read(ZixRing* ring, void* dst, uint32_t size)
+{
+	const uint32_t r = ring->read_head;
+	const uint32_t w = ring->write_head;
+
+	if (peek_internal(ring, r, w, size, dst)) {
+		ZIX_READ_BARRIER();
+		ring->read_head = (r + size) & ring->size_mask;
+		return size;
+	} else {
+		return 0;
+	}
+}
+
+uint32_t
+zix_ring_skip(ZixRing* ring, uint32_t size)
+{
+	const uint32_t r = ring->read_head;
+	const uint32_t w = ring->write_head;
+	if (read_space_internal(ring, r, w) < size) {
+		return 0;
+	}
+
+	ZIX_READ_BARRIER();
+	ring->read_head = (r + size) & ring->size_mask;
+	return size;
+}
+
+uint32_t
+zix_ring_write(ZixRing* ring, const void* src, uint32_t size)
+{
+	const uint32_t r = ring->read_head;
+	const uint32_t w = ring->write_head;
+	if (write_space_internal(ring, r, w) < size) {
+		return 0;
+	}
+
+	if (w + size <= ring->size) {
+		memcpy(&ring->buf[w], src, size);
+		ZIX_WRITE_BARRIER();
+		ring->write_head = (w + size) & ring->size_mask;
+	} else {
+		const uint32_t this_size = ring->size - w;
+		memcpy(&ring->buf[w], src, this_size);
+		memcpy(&ring->buf[0], (char*)src + this_size, size - this_size);
+		ZIX_WRITE_BARRIER();
+		ring->write_head = size - this_size;
+	}
+
+	return size;
+}
diff --git a/zix/ring.h b/zix/ring.h
new file mode 100644
index 0000000..34ba2fa
--- /dev/null
+++ b/zix/ring.h
@@ -0,0 +1,130 @@
+/*
+  Copyright 2011 David Robillard <http://drobilla.net>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#ifndef ZIX_RING_H
+#define ZIX_RING_H
+
+#include <stdint.h>
+
+#include "zix/common.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+   @addtogroup zix
+   @{
+   @name Ring
+   @{
+*/
+
+/**
+   A lock-free ring buffer.
+
+   Thread-safe with a single reader and single writer, and realtime safe
+   on both ends.
+*/
+typedef struct ZixRingImpl ZixRing;
+
+/**
+   Create a new ring.
+   @param size Size in bytes (note this may be rounded up).
+
+   At most @c size - 1 bytes may be stored in the ring at once.
+*/
+ZixRing*
+zix_ring_new(uint32_t size);
+
+/**
+   Destroy a ring.
+*/
+void
+zix_ring_free(ZixRing* ring);
+
+/**
+   Lock the ring data into physical memory.
+
+   This function is NOT thread safe or real-time safe, but it should be called
+   after zix_ring_new() to lock all ring memory to avoid page faults while
+   using the ring (i.e. this function MUST be called first in order for the
+   ring to be truly real-time safe).
+
+*/
+void
+zix_ring_mlock(ZixRing* ring);
+
+/**
+   Reset (empty) a ring.
+
+   This function is NOT thread-safe, it may only be called when there are no
+   readers or writers.
+*/
+void
+zix_ring_reset(ZixRing* ring);
+
+/**
+   Return the number of bytes of space available for reading.
+*/
+uint32_t
+zix_ring_read_space(const ZixRing* ring);
+
+/**
+   Return the number of bytes of space available for writing.
+*/
+uint32_t
+zix_ring_write_space(const ZixRing* ring);
+
+/**
+   Return the capacity (i.e. total write space when empty).
+*/
+uint32_t
+zix_ring_capacity(const ZixRing* ring);
+
+/**
+   Read from the ring without advancing the read head.
+*/
+uint32_t
+zix_ring_peek(ZixRing* ring, void* dst, uint32_t size);
+
+/**
+   Read from the ring and advance the read head.
+*/
+uint32_t
+zix_ring_read(ZixRing* ring, void* dst, uint32_t size);
+
+/**
+   Skip data in the ring (advance read head without reading).
+*/
+uint32_t
+zix_ring_skip(ZixRing* ring, uint32_t size);
+
+/**
+   Write data to the ring.
+*/
+uint32_t
+zix_ring_write(ZixRing* ring, const void* src, uint32_t size);
+
+/**
+   @}
+   @}
+*/
+
+#ifdef __cplusplus
+}  /* extern "C" */
+#endif
+
+#endif  /* ZIX_RING_H */
diff --git a/zix/thread.h b/zix/thread.h
new file mode 100644
index 0000000..ff5a727
--- /dev/null
+++ b/zix/thread.h
@@ -0,0 +1,133 @@
+/*
+  Copyright 2012 David Robillard <http://drobilla.net>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#ifndef ZIX_THREAD_H
+#define ZIX_THREAD_H
+
+#ifdef _WIN32
+#    include <windows.h>
+#else
+#    include <errno.h>
+#    include <pthread.h>
+#endif
+
+#include "zix/common.h"
+
+#ifdef __cplusplus
+extern "C" {
+#else
+#    include <stdbool.h>
+#endif
+
+/**
+   @addtogroup zix
+   @{
+   @name Thread
+   @{
+*/
+
+#ifdef _WIN32
+typedef HANDLE ZixThread;
+#else
+typedef pthread_t ZixThread;
+#endif
+
+/**
+   Initialize @c thread to a new thread.
+
+   The thread will immediately be launched, calling @c function with @c arg
+   as the only parameter.
+*/
+static inline ZixStatus
+zix_thread_create(ZixThread* thread,
+                  size_t     stack_size,
+                  void*      (*function)(void*),
+                  void*      arg);
+
+/**
+   Join @c thread (block until @c thread exits).
+*/
+static inline ZixStatus
+zix_thread_join(ZixThread thread, void** retval);
+
+#ifdef _WIN32
+
+static inline ZixStatus
+zix_thread_create(ZixThread* thread,
+                  size_t     stack_size,
+                  void*      (*function)(void*),
+                  void*      arg)
+{
+	*thread = CreateThread(NULL, stack_size,
+	                       (LPTHREAD_START_ROUTINE)function, arg,
+	                       0, NULL);
+	return *thread ? ZIX_STATUS_SUCCESS : ZIX_STATUS_ERROR;
+}
+
+static inline ZixStatus
+zix_thread_join(ZixThread thread, void** retval)
+{
+	return WaitForSingleObject(thread, INFINITE)
+		? ZIX_STATUS_SUCCESS : ZIX_STATUS_ERROR;
+}
+
+#else  /* !defined(_WIN32) */
+
+static inline ZixStatus
+zix_thread_create(ZixThread* thread,
+                  size_t     stack_size,
+                  void*      (*function)(void*),
+                  void*      arg)
+{
+	pthread_attr_t attr;
+	pthread_attr_init(&attr);
+	pthread_attr_setstacksize(&attr, stack_size);
+
+	const int ret = pthread_create(thread, NULL, function, arg);
+	pthread_attr_destroy(&attr);
+
+	if (ret == EAGAIN) {
+		return ZIX_STATUS_NO_MEM;
+	} else if (ret == EINVAL) {
+		return ZIX_STATUS_BAD_ARG;
+	} else if (ret == EPERM) {
+		return ZIX_STATUS_BAD_PERMS;
+	} else if (ret) {
+		return ZIX_STATUS_ERROR;
+	}
+
+	return ZIX_STATUS_SUCCESS;
+}
+
+static inline ZixStatus
+zix_thread_join(ZixThread thread, void** retval)
+{
+	return pthread_join(thread, retval)
+		? ZIX_STATUS_ERROR : ZIX_STATUS_SUCCESS;
+}
+
+#endif
+
+/**
+   @}
+   @}
+*/
+
+#ifdef __cplusplus
+}  /* extern "C" */
+#endif
+
+#endif  /* ZIX_THREAD_H */