Use direct UDP communication for xkit

3 files changed, 675 insertions, 377 deletions

diff --git a/plugins/xkit/CMakeLists.txt b/plugins/xkit/CMakeLists.txt
index 6441c46..e4f6a39 100644
--- a/plugins/xkit/CMakeLists.txt
+++ b/plugins/xkit/CMakeLists.txt
@@ -1,33 +1,23 @@
 cmake_minimum_required(VERSION 2.6)
-project(ucaxkit CXX)
+project(ucaxkit C)
 
 set(UCA_CAMERA_NAME "xkit")
 set(PLUGIN_VERSION "0.1.0")
 set(PLUGIN_REVISION "1")
 set(PLUGIN_REQUIRES "libuca >= 1.2.0")
 
-find_package(PkgConfig)
-pkg_check_modules(XKIT xkit>=0.1.0)
 
-if (XKIT_FOUND)
-    configure_file(${CMAKE_CURRENT_SOURCE_DIR}/../package-plugin.sh.in
-                   ${CMAKE_CURRENT_BINARY_DIR}/../../package-plugin-${UCA_CAMERA_NAME}.sh)
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fopenmp")
 
-    message("includedir: ${XKIT_LIBRARIES}")
+configure_file(${CMAKE_CURRENT_SOURCE_DIR}/../package-plugin.sh.in
+               ${CMAKE_CURRENT_BINARY_DIR}/../../package-plugin-${UCA_CAMERA_NAME}.sh)
 
-    include_directories(${XKIT_INCLUDEDIR}
-                        ${UCA_CONFIGDIR})
+include_directories(${UCA_CONFIGDIR})
 
-    # We have to compile with g++ because the included header files have C++
-    # style comments ...
-    add_library(ucaxkit SHARED
-                uca-xkit-camera.cc)
+add_library(ucaxkit SHARED uca-xkit-camera.c)
 
-    target_link_libraries(ucaxkit
-                          ${UCA_DEPS}
-                          ${XKIT_LIBRARIES})
+target_link_libraries(ucaxkit ${UCA_DEPS})
 
-    install(TARGETS ucaxkit
-            LIBRARY DESTINATION ${UCA_PLUGINDIR}
-            COMPONENT ${UCA_CAMERA_NAME})
-endif ()
+install(TARGETS ucaxkit
+        LIBRARY DESTINATION ${UCA_PLUGINDIR}
+        COMPONENT ${UCA_CAMERA_NAME})
diff --git a/plugins/xkit/uca-xkit-camera.c b/plugins/xkit/uca-xkit-camera.c
new file mode 100644
index 0000000..2386dff
--- /dev/null
+++ b/plugins/xkit/uca-xkit-camera.c
@@ -0,0 +1,665 @@
+/* Copyright (C) 2011-2013 Matthias Vogelgesang <matthias.vogelgesang@kit.edu>
+   (Karlsruhe Institute of Technology)
+
+   This library is free software; you can redistribute it and/or modify it
+   under the terms of the GNU Lesser General Public License as published by the
+   Free Software Foundation; either version 2.1 of the License, or (at your
+   option) any later version.
+
+   This library is distributed in the hope that it will be useful, but WITHOUT
+   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+   FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
+   details.
+
+   You should have received a copy of the GNU Lesser General Public License along
+   with this library; if not, write to the Free Software Foundation, Inc., 51
+   Franklin St, Fifth Floor, Boston, MA 02110, USA */
+
+#include <stdlib.h>
+#include <gio/gio.h>
+#include <gmodule.h>
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+
+#include "uca-camera.h"
+#include "uca-xkit-camera.h"
+
+
+#define UCA_XKIT_CAMERA_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE((obj), UCA_TYPE_XKIT_CAMERA, UcaXkitCameraPrivate))
+
+#define XKIT_DEFAULT_IP         "192.168.1.115"
+#define XKIT_DEFAULT_PORT       5002
+#define XKIT_MESSAGE_SIZE       512
+
+#define MEDIPIX_SENSOR_SIZE     256
+#define CHIPS_PER_ROW           3
+#define CHIPS_PER_COLUMN        1
+#define NUM_CHIPS               CHIPS_PER_ROW * CHIPS_PER_COLUMN
+#define NUM_FSRS                256
+
+static void uca_xkit_camera_initable_iface_init (GInitableIface *iface);
+
+G_DEFINE_TYPE_WITH_CODE (UcaXkitCamera, uca_xkit_camera, UCA_TYPE_CAMERA,
+                         G_IMPLEMENT_INTERFACE (G_TYPE_INITABLE,
+                                                uca_xkit_camera_initable_iface_init))
+
+GQuark uca_xkit_camera_error_quark()
+{
+    return g_quark_from_static_string("uca-xkit-camera-error-quark");
+}
+
+enum {
+    PROP_NUM_CHIPS = N_BASE_PROPERTIES,
+    PROP_ADDR,
+    PROP_PORT_CHIP_0,
+    PROP_PORT_CHIP_1,
+    PROP_PORT_CHIP_2,
+    PROP_FLIP_CHIP_0,
+    PROP_FLIP_CHIP_1,
+    PROP_FLIP_CHIP_2,
+    /* PROP_FLIP_CHIP_3, */
+    /* PROP_FLIP_CHIP_4, */
+    /* PROP_FLIP_CHIP_5, */
+    PROP_READOUT_BIG_ENDIAN,
+    PROP_READOUT_MIRRORED,
+    PROP_READOUT_INCREMENTAL_GREYSCALE,
+    N_PROPERTIES
+};
+
+static gint base_overrideables[] = {
+    PROP_NAME,
+    PROP_SENSOR_WIDTH,
+    PROP_SENSOR_HEIGHT,
+    PROP_SENSOR_MAX_FRAME_RATE,
+    PROP_SENSOR_BITDEPTH,
+    PROP_EXPOSURE_TIME,
+    PROP_ROI_X,
+    PROP_ROI_Y,
+    PROP_ROI_WIDTH,
+    PROP_ROI_HEIGHT,
+    PROP_HAS_STREAMING,
+    PROP_HAS_CAMRAM_RECORDING,
+    0,
+};
+
+static GParamSpec *xkit_properties[N_PROPERTIES] = { NULL, };
+
+enum {
+    X_KIT_ACQUIRE_NORMAL                = 0x0,
+    X_KIT_ACQUIRE_CONTINUOUS            = 0x1,
+    X_KIT_ACQUIRE_TRIGGERED             = 0x2,
+    X_KIT_ACQUIRE_CONTINUOUS_TRIGGERED  = 0x3,
+};
+
+enum {
+    X_KIT_READOUT_DEFAULT               = 0,
+    X_KIT_READOUT_BIG_ENDIAN            = 1 << 2,
+    X_KIT_READOUT_MIRRORED              = 1 << 3,
+    X_KIT_READOUT_INCREMENTAL_GREYSCALE = 1 << 4,
+};
+
+struct _UcaXkitCameraPrivate {
+    GError *construct_error;
+    gsize n_chips;
+    gsize n_max_chips;
+    guint16 **buffers;
+    gboolean flip[NUM_CHIPS];
+
+    gchar *addr;
+    guint ports[NUM_CHIPS];
+    GSocket* sockets[NUM_CHIPS];
+
+    guint8 readout_mode;
+    guint8 acquisition_mode;
+
+    gdouble exposure_time;
+    guint acq_time_cycles;
+};
+
+static gboolean
+xkit_send_recv_ackd (GSocket *socket, gchar *buffer, gsize size, GError **error)
+{
+    gchar ack;
+
+    g_socket_send (socket, buffer, size, NULL, error);
+    g_socket_receive (socket, &ack, 1, NULL, error);
+    return ack == 0x21;
+}
+
+static void
+xkit_recv_chunked (GSocket *socket, gchar *buffer, gsize size, GError **error)
+{
+    gsize total_read = 0;
+
+    while (total_read < size) {
+        gssize read;
+
+        read = g_socket_receive_with_blocking (socket, buffer + total_read, size - total_read,
+                                               FALSE, NULL, NULL);
+
+        if (read > 0)
+            total_read += read;
+    }
+}
+
+static gboolean
+xkit_reset (GSocket *socket, GError **error)
+{
+    gchar buffer = 0x32;
+    return xkit_send_recv_ackd (socket, &buffer, 1, error);
+}
+
+static gboolean
+xkit_set_exposure_time (GSocket *socket, guint32 exposure_time, GError **error)
+{
+    struct {
+        guint8 msg;
+        guint32 time;
+    } __attribute__((packed))
+    buffer = {
+        .msg = 0x38,
+        .time = exposure_time
+    };
+
+    return xkit_send_recv_ackd (socket, (gchar *) &buffer, sizeof (buffer), error);
+}
+
+static gboolean
+xkit_start_acquisition (GSocket *socket, guint8 acquisition_mode, GError **error)
+{
+    gchar msg[] = { 0x34, 0x00, acquisition_mode };
+    return xkit_send_recv_ackd (socket, msg, 3, error);
+}
+
+static gboolean
+xkit_serial_matrix_readout (GSocket *socket, gchar *data, guint8 acquisition_mode, GError **error)
+{
+    gchar msg[] = { 0x35, acquisition_mode };
+    gchar ack;
+
+    g_socket_send (socket, msg, 2, NULL, error);
+    xkit_recv_chunked (socket, data, MEDIPIX_SENSOR_SIZE * MEDIPIX_SENSOR_SIZE * 2, error);
+    g_socket_receive (socket, &ack, 1, NULL, error);
+    return ack == 0x21;
+}
+
+static gboolean
+connect_xkit (UcaXkitCameraPrivate *priv)
+{
+    GInetAddress *local_addr;
+
+    local_addr = g_inet_address_new_from_string (priv->addr);
+
+    for (guint i = 0; i < NUM_CHIPS; i++) {
+        GSocketAddress *socket_addr;
+
+        socket_addr = g_inet_socket_address_new (local_addr, priv->ports[i]);
+
+        priv->sockets[i] = g_socket_new (G_SOCKET_FAMILY_IPV4,
+                                         G_SOCKET_TYPE_DATAGRAM,
+                                         G_SOCKET_PROTOCOL_UDP,
+                                         &priv->construct_error);
+
+        if (priv->sockets[i] == NULL)
+            return FALSE;
+
+        if (!g_socket_connect (priv->sockets[i], socket_addr, NULL, &priv->construct_error))
+            return FALSE;
+    }
+
+    return TRUE;
+}
+
+static gboolean
+setup_xkit (UcaXkitCameraPrivate *priv)
+{
+    priv->n_max_chips = priv->n_chips = NUM_CHIPS;
+    priv->buffers = g_new0 (guint16 *, priv->n_max_chips);
+
+    for (guint i = 0; i < priv->n_max_chips; i++)
+        priv->buffers[i] = (guint16 *) g_malloc0 (MEDIPIX_SENSOR_SIZE * MEDIPIX_SENSOR_SIZE * sizeof(guint16));
+
+    return connect_xkit (priv);
+}
+
+static void
+compose_image (guint16 *output, guint16 **buffers, gboolean *flip, gsize n)
+{
+    gsize dst_stride;
+    gsize cx = 0;
+    gsize cy = 0;
+
+    dst_stride = CHIPS_PER_ROW * MEDIPIX_SENSOR_SIZE;
+
+    for (gsize i = 0; i < n; i++) {
+        guint16 *dst;
+        guint16 *src;
+        gsize src_stride;
+
+        if (cx == CHIPS_PER_ROW) {
+            cx = 0;
+            cy++;
+        }
+
+        if (flip[i]) {
+            src = buffers[i] + MEDIPIX_SENSOR_SIZE * MEDIPIX_SENSOR_SIZE;
+            src_stride = -MEDIPIX_SENSOR_SIZE;
+        }
+        else {
+            src = buffers[i];
+            src_stride = MEDIPIX_SENSOR_SIZE;
+        }
+
+        dst = output + (cy * MEDIPIX_SENSOR_SIZE * dst_stride + cx * MEDIPIX_SENSOR_SIZE);
+
+        for (gsize row = 0; row < 256; row++) {
+            memcpy (dst, src, MEDIPIX_SENSOR_SIZE * sizeof (guint16));
+            dst += dst_stride;
+            src += src_stride;
+        }
+
+        cx++;
+    }
+}
+
+static void
+uca_xkit_camera_start_recording (UcaCamera *camera,
+                                 GError **error)
+{
+    UcaXkitCameraPrivate *priv;
+    UcaCameraTrigger trigger_mode;
+
+    g_return_if_fail (UCA_IS_XKIT_CAMERA (camera));
+
+    priv = UCA_XKIT_CAMERA_GET_PRIVATE (camera);
+    g_object_get (camera, "trigger-mode", &trigger_mode, NULL);
+
+    if (trigger_mode == UCA_CAMERA_TRIGGER_AUTO)
+        priv->acquisition_mode = X_KIT_ACQUIRE_NORMAL;
+    else if (trigger_mode == UCA_CAMERA_TRIGGER_SOFTWARE)
+        priv->acquisition_mode = X_KIT_ACQUIRE_NORMAL;
+    else if (trigger_mode == UCA_CAMERA_TRIGGER_EXTERNAL)
+        priv->acquisition_mode = X_KIT_ACQUIRE_TRIGGERED;
+
+    priv->acquisition_mode |= priv->readout_mode;
+
+    if (!xkit_reset (priv->sockets[0], error))
+        return;
+
+    if (!xkit_set_exposure_time (priv->sockets[0], 0x1000, error))
+        return;
+
+    xkit_start_acquisition (priv->sockets[0], priv->acquisition_mode, error);
+}
+
+static void
+uca_xkit_camera_stop_recording (UcaCamera *camera,
+                                GError **error)
+{
+    g_return_if_fail (UCA_IS_XKIT_CAMERA (camera));
+}
+
+static void
+uca_xkit_camera_start_readout (UcaCamera *camera,
+                               GError **error)
+{
+    g_return_if_fail( UCA_IS_XKIT_CAMERA (camera));
+}
+
+static void
+uca_xkit_camera_stop_readout (UcaCamera *camera,
+                              GError **error)
+{
+    g_return_if_fail (UCA_IS_XKIT_CAMERA (camera));
+}
+
+static gboolean
+uca_xkit_camera_grab (UcaCamera *camera,
+                      gpointer data,
+                      GError **error)
+{
+    g_return_val_if_fail (UCA_IS_XKIT_CAMERA (camera), FALSE);
+    UcaXkitCameraPrivate *priv;
+    GTimer *timer;
+
+
+    priv = UCA_XKIT_CAMERA_GET_PRIVATE (camera);
+    timer = g_timer_new ();
+
+    #pragma omp parallel for num_threads(NUM_CHIPS)
+    for (guint i = 0; i < NUM_CHIPS; i++) {
+        GError *local_error = NULL;
+
+        xkit_serial_matrix_readout (priv->sockets[i],
+                                    (gchar *) priv->buffers[i],
+                                    priv->acquisition_mode,
+                                    &local_error);
+
+        if (local_error != NULL) {
+            g_error_free (local_error);
+            local_error = NULL;
+        }
+    }
+
+    compose_image ((guint16 *) data, priv->buffers, priv->flip, priv->n_chips);
+    g_timer_destroy (timer);
+
+    return TRUE;
+}
+
+static void
+uca_xkit_camera_trigger (UcaCamera *camera,
+                         GError **error)
+{
+    g_return_if_fail (UCA_IS_XKIT_CAMERA (camera));
+}
+
+static void
+uca_xkit_camera_set_property (GObject *object,
+                              guint property_id,
+                              const GValue *value,
+                              GParamSpec *pspec)
+{
+    UcaXkitCameraPrivate *priv;
+
+    priv = UCA_XKIT_CAMERA_GET_PRIVATE (object);
+
+    switch (property_id) {
+        case PROP_EXPOSURE_TIME:
+            priv->exposure_time = g_value_get_double(value);
+            break;
+        case PROP_FLIP_CHIP_0:
+        case PROP_FLIP_CHIP_1:
+        case PROP_FLIP_CHIP_2:
+        /* case PROP_FLIP_CHIP_3: */
+        /* case PROP_FLIP_CHIP_4: */
+        /* case PROP_FLIP_CHIP_5: */
+            priv->flip[property_id - PROP_FLIP_CHIP_0] = g_value_get_boolean (value);
+            break;
+
+        case PROP_READOUT_BIG_ENDIAN:
+            if (g_value_get_boolean (value))
+                priv->readout_mode |= X_KIT_READOUT_BIG_ENDIAN;
+            else
+                priv->readout_mode &= ~X_KIT_READOUT_BIG_ENDIAN;
+            break;
+
+        case PROP_READOUT_MIRRORED:
+            if (g_value_get_boolean (value))
+                priv->readout_mode |= X_KIT_READOUT_MIRRORED;
+            else
+                priv->readout_mode &= ~X_KIT_READOUT_MIRRORED;
+            break;
+
+        case PROP_READOUT_INCREMENTAL_GREYSCALE:
+            if (g_value_get_boolean (value))
+                priv->readout_mode |= X_KIT_READOUT_INCREMENTAL_GREYSCALE;
+            else
+                priv->readout_mode &= ~X_KIT_READOUT_INCREMENTAL_GREYSCALE;
+            break;
+
+        default:
+            G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+            return;
+    }
+}
+
+static void
+uca_xkit_camera_get_property (GObject *object,
+                              guint property_id,
+                              GValue *value,
+                              GParamSpec *pspec)
+{
+    UcaXkitCameraPrivate *priv;
+
+    priv = UCA_XKIT_CAMERA_GET_PRIVATE (object);
+
+    switch (property_id) {
+        case PROP_NAME:
+            g_value_set_string (value, "xkit");
+            break;
+        case PROP_SENSOR_MAX_FRAME_RATE:
+            g_value_set_float (value, 150.0f);
+            break;
+        case PROP_SENSOR_WIDTH:
+            g_value_set_uint (value, CHIPS_PER_ROW * MEDIPIX_SENSOR_SIZE);
+            break;
+        case PROP_SENSOR_HEIGHT:
+            g_value_set_uint (value, CHIPS_PER_COLUMN * MEDIPIX_SENSOR_SIZE);
+            break;
+        case PROP_SENSOR_BITDEPTH:
+            g_value_set_uint (value, 14);
+            break;
+        case PROP_EXPOSURE_TIME:
+            g_value_set_double (value, priv->exposure_time);
+            break;
+        case PROP_HAS_STREAMING:
+            g_value_set_boolean (value, TRUE);
+            break;
+        case PROP_HAS_CAMRAM_RECORDING:
+            g_value_set_boolean (value, FALSE);
+            break;
+        case PROP_ROI_X:
+            g_value_set_uint (value, 0);
+            break;
+        case PROP_ROI_Y:
+            g_value_set_uint (value, 0);
+            break;
+        case PROP_ROI_WIDTH:
+            g_value_set_uint (value, CHIPS_PER_ROW * MEDIPIX_SENSOR_SIZE);
+            break;
+        case PROP_ROI_HEIGHT:
+            g_value_set_uint (value, CHIPS_PER_COLUMN * MEDIPIX_SENSOR_SIZE);
+            break;
+        case PROP_NUM_CHIPS:
+            g_value_set_uint (value, priv->n_chips);
+            break;
+        case PROP_ADDR:
+            g_value_set_string (value, priv->addr);
+            break;
+        case PROP_FLIP_CHIP_0:
+        case PROP_FLIP_CHIP_1:
+        case PROP_FLIP_CHIP_2:
+        /* case PROP_FLIP_CHIP_3: */
+        /* case PROP_FLIP_CHIP_4: */
+        /* case PROP_FLIP_CHIP_5: */
+            g_value_set_boolean (value, priv->flip[property_id - PROP_FLIP_CHIP_0]);
+            break;
+        case PROP_PORT_CHIP_0:
+        case PROP_PORT_CHIP_1:
+        case PROP_PORT_CHIP_2:
+        /* case PROP_FLIP_CHIP_3: */
+        /* case PROP_FLIP_CHIP_4: */
+        /* case PROP_FLIP_CHIP_5: */
+            g_value_set_uint (value, priv->ports[property_id - PROP_PORT_CHIP_0]);
+            break;
+        case PROP_READOUT_BIG_ENDIAN:
+            g_value_set_boolean (value, priv->readout_mode & X_KIT_READOUT_BIG_ENDIAN);
+            break;
+        case PROP_READOUT_MIRRORED:
+            g_value_set_boolean (value, priv->readout_mode & X_KIT_READOUT_MIRRORED);
+            break;
+        case PROP_READOUT_INCREMENTAL_GREYSCALE:
+            g_value_set_boolean (value, priv->readout_mode & X_KIT_READOUT_INCREMENTAL_GREYSCALE);
+            break;
+        default:
+            G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+            break;
+    }
+}
+
+static void
+uca_xkit_camera_dispose (GObject *object)
+{
+    UcaXkitCameraPrivate *priv;
+
+    priv = UCA_XKIT_CAMERA_GET_PRIVATE (object);
+
+    for (guint i = 0; i < NUM_CHIPS; i++) {
+        if (priv->sockets[i] != NULL) {
+            g_object_unref (priv->sockets[i]);
+            priv->sockets[i] = NULL;
+        }
+    }
+
+    G_OBJECT_CLASS (uca_xkit_camera_parent_class)->dispose (object);
+}
+
+static void
+uca_xkit_camera_finalize (GObject *object)
+{
+    UcaXkitCameraPrivate *priv;
+
+    priv = UCA_XKIT_CAMERA_GET_PRIVATE (object);
+    g_clear_error (&priv->construct_error);
+
+    for (guint i = 0; i < priv->n_max_chips; i++)
+        g_free (priv->buffers[i]);
+
+    g_free (priv->buffers);
+    g_free (priv->addr);
+
+    G_OBJECT_CLASS (uca_xkit_camera_parent_class)->finalize (object);
+}
+
+static gboolean
+ufo_xkit_camera_initable_init (GInitable *initable,
+                               GCancellable *cancellable,
+                               GError **error)
+{
+    UcaXkitCamera *camera;
+    UcaXkitCameraPrivate *priv;
+
+    g_return_val_if_fail (UCA_IS_XKIT_CAMERA (initable), FALSE);
+
+    if (cancellable != NULL) {
+        g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
+                             "Cancellable initialization not supported");
+        return FALSE;
+    }
+
+    camera = UCA_XKIT_CAMERA (initable);
+    priv = camera->priv;
+
+    if (priv->construct_error != NULL) {
+        if (error)
+            *error = g_error_copy (priv->construct_error);
+
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+static void
+uca_xkit_camera_initable_iface_init (GInitableIface *iface)
+{
+    iface->init = ufo_xkit_camera_initable_init;
+}
+
+static void
+uca_xkit_camera_class_init (UcaXkitCameraClass *klass)
+{
+    GObjectClass *oclass = G_OBJECT_CLASS (klass);
+    UcaCameraClass *camera_class = UCA_CAMERA_CLASS (klass);
+
+    oclass->set_property = uca_xkit_camera_set_property;
+    oclass->get_property = uca_xkit_camera_get_property;
+    oclass->dispose = uca_xkit_camera_dispose;
+    oclass->finalize = uca_xkit_camera_finalize;
+
+    camera_class->start_recording = uca_xkit_camera_start_recording;
+    camera_class->stop_recording = uca_xkit_camera_stop_recording;
+    camera_class->start_readout = uca_xkit_camera_start_readout;
+    camera_class->stop_readout = uca_xkit_camera_stop_readout;
+    camera_class->grab = uca_xkit_camera_grab;
+    camera_class->trigger = uca_xkit_camera_trigger;
+
+    for (guint i = 0; base_overrideables[i] != 0; i++)
+        g_object_class_override_property (oclass, base_overrideables[i], uca_camera_props[base_overrideables[i]]);
+
+    xkit_properties[PROP_NUM_CHIPS] =
+        g_param_spec_uint("num-sensor-chips",
+            "Number of sensor chips",
+            "Number of sensor chips",
+            1, 6, 6,
+            G_PARAM_READABLE);
+
+    xkit_properties[PROP_ADDR] =
+        g_param_spec_string ("address",
+                             "Address of board",
+                             "Address of board",
+                             "192.168.1.115",
+                             G_PARAM_READWRITE);
+
+    xkit_properties[PROP_READOUT_BIG_ENDIAN] =
+        g_param_spec_boolean("big-endian",
+            "Big Endian Readout",
+            "Big Endian Readout",
+            FALSE,
+            (GParamFlags) G_PARAM_READWRITE);
+
+    xkit_properties[PROP_READOUT_MIRRORED] =
+        g_param_spec_boolean("mirrored",
+            "Mirrored Readout",
+            "Mirrored Readout",
+            FALSE,
+            (GParamFlags) G_PARAM_READWRITE);
+
+    xkit_properties[PROP_READOUT_INCREMENTAL_GREYSCALE] =
+        g_param_spec_boolean("incremental-greyscale",
+            "Incremental Greyscale Readout",
+            "Incremental Greyscale Readout",
+            FALSE,
+            (GParamFlags) G_PARAM_READWRITE);
+
+    for (guint i = 0; i < NUM_CHIPS; i++) {
+        gchar *prop_name;
+
+        prop_name = g_strdup_printf ("flip-chip-%i", i);
+
+        xkit_properties[PROP_FLIP_CHIP_0 + i] =
+            g_param_spec_boolean (prop_name, "Flip chip", "Flip chip", FALSE, (GParamFlags) G_PARAM_READWRITE);
+
+        g_free (prop_name);
+
+        prop_name = g_strdup_printf ("port-chip-%i", i);
+
+        xkit_properties[PROP_PORT_CHIP_0 + i] =
+            g_param_spec_uint (prop_name, "Connection port", "Connection port", 0, 65535, 5002 + i, (GParamFlags) G_PARAM_READWRITE);
+
+        g_free (prop_name);
+    }
+
+    for (guint id = N_BASE_PROPERTIES; id < N_PROPERTIES; id++)
+        g_object_class_install_property (oclass, id, xkit_properties[id]);
+
+    g_type_class_add_private (klass, sizeof(UcaXkitCameraPrivate));
+}
+
+static void
+uca_xkit_camera_init (UcaXkitCamera *self)
+{
+    UcaXkitCameraPrivate *priv;
+
+    self->priv = priv = UCA_XKIT_CAMERA_GET_PRIVATE (self);
+    priv->exposure_time = 0.5;
+    priv->addr = g_strdup (XKIT_DEFAULT_IP);
+    priv->construct_error = NULL;
+
+    for (guint i = 0; i < NUM_CHIPS; i++) {
+        priv->sockets[i] = NULL;
+        priv->flip[i] = FALSE;
+        priv->ports[i] = XKIT_DEFAULT_PORT + i;
+    }
+
+    if (!setup_xkit (priv))
+        return;
+}
+
+G_MODULE_EXPORT GType
+uca_camera_get_type (void)
+{
+    return UCA_TYPE_XKIT_CAMERA;
+}
diff --git a/plugins/xkit/uca-xkit-camera.cc b/plugins/xkit/uca-xkit-camera.cc
deleted file mode 100644
index 17d52d4..0000000
--- a/plugins/xkit/uca-xkit-camera.cc
+++ /dev/null
@@ -1,357 +0,0 @@
-/* Copyright (C) 2011-2013 Matthias Vogelgesang <matthias.vogelgesang@kit.edu>
-   (Karlsruhe Institute of Technology)
-
-   This library is free software; you can redistribute it and/or modify it
-   under the terms of the GNU Lesser General Public License as published by the
-   Free Software Foundation; either version 2.1 of the License, or (at your
-   option) any later version.
-
-   This library is distributed in the hope that it will be useful, but WITHOUT
-   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-   FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
-   details.
-
-   You should have received a copy of the GNU Lesser General Public License along
-   with this library; if not, write to the Free Software Foundation, Inc., 51
-   Franklin St, Fifth Floor, Boston, MA 02110, USA */
-
-#include <stdlib.h>
-#include <xkit/dll_api.h>
-
-#undef FALSE
-#undef TRUE
-
-#include <gio/gio.h>
-#include <gmodule.h>
-#include <stdio.h>
-#include <string.h>
-#include <errno.h>
-
-#include "uca-camera.h"
-#include "uca-xkit-camera.h"
-
-
-#define UCA_XKIT_CAMERA_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE((obj), UCA_TYPE_XKIT_CAMERA, UcaXkitCameraPrivate))
-
-#define MEDIPIX_SENSOR_HEIGHT   256
-
-static void uca_xkit_camera_initable_iface_init (GInitableIface *iface);
-
-G_DEFINE_TYPE_WITH_CODE (UcaXkitCamera, uca_xkit_camera, UCA_TYPE_CAMERA,
-                         G_IMPLEMENT_INTERFACE (G_TYPE_INITABLE,
-                                                uca_xkit_camera_initable_iface_init))
-
-GQuark uca_xkit_camera_error_quark()
-{
-    return g_quark_from_static_string("uca-xkit-camera-error-quark");
-}
-
-enum {
-    PROP_POSITIVE_POLARITY = N_BASE_PROPERTIES,
-    N_PROPERTIES
-};
-
-static gint base_overrideables[] = {
-    PROP_NAME,
-    PROP_SENSOR_WIDTH,
-    PROP_SENSOR_HEIGHT,
-    PROP_SENSOR_MAX_FRAME_RATE,
-    PROP_SENSOR_BITDEPTH,
-    PROP_EXPOSURE_TIME,
-    PROP_ROI_X,
-    PROP_ROI_Y,
-    PROP_ROI_WIDTH,
-    PROP_ROI_HEIGHT,
-    PROP_HAS_STREAMING,
-    PROP_HAS_CAMRAM_RECORDING,
-    0,
-};
-
-static GParamSpec *xkit_properties[N_PROPERTIES] = { NULL, };
-
-struct _UcaXkitCameraPrivate {
-    GError  *construct_error;
-    Mpx2Interface *interface;
-    gint devices[4];
-    gint n_devices;
-    gint device;
-
-    DevInfo info;
-    AcqParams acq;
-};
-
-
-static gboolean
-setup_xkit (UcaXkitCameraPrivate *priv)
-{
-
-    priv->interface = getMpx2Interface();
-    priv->interface->findDevices (priv->devices, &priv->n_devices);
-
-    if (priv->n_devices > 0)
-        priv->interface->init (priv->devices[0]);
-
-    priv->device = priv->devices[0];
-    priv->interface->getDevInfo (priv->device, &priv->info);
-
-    /* TODO: find some sensible defaults */
-    priv->acq.useHwTimer = TRUE;
-    priv->acq.enableCst = FALSE;
-    priv->acq.polarityPositive = TRUE;
-    priv->acq.mode = ACQMODE_ACQSTART_TIMERSTOP;
-    priv->acq.acqCount = 1;
-    priv->acq.time = 1.0;
-
-    return TRUE;
-}
-
-static void
-uca_xkit_camera_start_recording (UcaCamera *camera,
-                                 GError **error)
-{
-    UcaXkitCameraPrivate *priv;
-
-    g_return_if_fail (UCA_IS_XKIT_CAMERA (camera));
-    priv = UCA_XKIT_CAMERA_GET_PRIVATE (camera);
-
-    if (priv->interface->setAcqPars (priv->device, &priv->acq)) {
-        g_set_error_literal (error, UCA_CAMERA_ERROR, UCA_CAMERA_ERROR_RECORDING,
-                             "Could not set acquisition parameters");
-    }
-}
-
-static void
-uca_xkit_camera_stop_recording (UcaCamera *camera,
-                                GError **error)
-{
-    g_return_if_fail (UCA_IS_XKIT_CAMERA (camera));
-}
-
-static void
-uca_xkit_camera_start_readout (UcaCamera *camera,
-                               GError **error)
-{
-    g_return_if_fail( UCA_IS_XKIT_CAMERA (camera));
-}
-
-static void
-uca_xkit_camera_stop_readout (UcaCamera *camera,
-                              GError **error)
-{
-    g_return_if_fail (UCA_IS_XKIT_CAMERA (camera));
-}
-
-static gboolean
-uca_xkit_camera_grab (UcaCamera *camera,
-                      gpointer data,
-                      GError **error)
-{
-    UcaXkitCameraPrivate *priv;
-    guint32 size;
-    g_return_val_if_fail (UCA_IS_XKIT_CAMERA (camera), FALSE);
-
-    /* XXX: For now we trigger on our own because the X-KIT chip does not
-     * provide auto triggering */
-
-    priv = UCA_XKIT_CAMERA_GET_PRIVATE (camera);
-    size = priv->info.pixCount;
-
-    if (priv->interface->startAcquisition (priv->device)) {
-        g_set_error_literal (error, UCA_CAMERA_ERROR, UCA_CAMERA_ERROR_RECORDING,
-                             "Could not pre-trigger");
-        return FALSE;
-    }
-
-    if (priv->interface->readMatrix (priv->device, (gint16 *) data, size)) {
-        g_set_error_literal (error, UCA_CAMERA_ERROR, UCA_CAMERA_ERROR_RECORDING,
-                             "Could not grab frame");
-        return FALSE;
-    }
-
-    if (priv->interface->stopAcquisition (priv->device)) {
-        g_set_error_literal (error, UCA_CAMERA_ERROR, UCA_CAMERA_ERROR_RECORDING,
-                             "Could stop acquisition");
-        return FALSE;
-    }
-
-    return TRUE;
-}
-
-static void
-uca_xkit_camera_trigger (UcaCamera *camera,
-                         GError **error)
-{
-    g_return_if_fail (UCA_IS_XKIT_CAMERA (camera));
-}
-
-static void
-uca_xkit_camera_set_property (GObject *object,
-                              guint property_id,
-                              const GValue *value,
-                              GParamSpec *pspec)
-{
-    UcaXkitCameraPrivate *priv = UCA_XKIT_CAMERA_GET_PRIVATE(object);
-
-    switch (property_id) {
-        case PROP_EXPOSURE_TIME:
-            priv->acq.time = g_value_get_double (value);
-            break;
-        case PROP_POSITIVE_POLARITY:
-            priv->acq.polarityPositive = g_value_get_boolean (value);
-            break;
-        default:
-            G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
-            return;
-    }
-}
-
-static void
-uca_xkit_camera_get_property (GObject *object,
-                              guint property_id,
-                              GValue *value,
-                              GParamSpec *pspec)
-{
-    UcaXkitCameraPrivate *priv = UCA_XKIT_CAMERA_GET_PRIVATE (object);
-
-    switch (property_id) {
-        case PROP_NAME:
-            g_value_set_string (value, priv->info.ifaceName);
-            break;
-        case PROP_SENSOR_MAX_FRAME_RATE:
-            /* TODO: pretty arbitrary, huh? */
-            g_value_set_float (value, 150.0f);
-            break;
-        case PROP_SENSOR_WIDTH:
-            g_value_set_uint (value, priv->info.rowLen);
-            break;
-        case PROP_SENSOR_HEIGHT:
-            g_value_set_uint (value, priv->info.numberOfRows * MEDIPIX_SENSOR_HEIGHT);
-            break;
-        case PROP_SENSOR_BITDEPTH:
-            g_value_set_uint (value, 11);
-            break;
-        case PROP_EXPOSURE_TIME:
-            g_value_set_double (value, priv->acq.time);
-            break;
-        case PROP_HAS_STREAMING:
-            g_value_set_boolean (value, TRUE);
-            break;
-        case PROP_HAS_CAMRAM_RECORDING:
-            g_value_set_boolean (value, FALSE);
-            break;
-        case PROP_ROI_X:
-            g_value_set_uint (value, 0);
-            break;
-        case PROP_ROI_Y:
-            g_value_set_uint (value, 0);
-            break;
-        case PROP_ROI_WIDTH:
-            g_value_set_uint (value, priv->info.rowLen);
-            break;
-        case PROP_ROI_HEIGHT:
-            g_value_set_uint (value, priv->info.numberOfRows * MEDIPIX_SENSOR_HEIGHT);
-            break;
-        case PROP_POSITIVE_POLARITY:
-            g_value_set_boolean (value, priv->acq.polarityPositive);
-            break;
-        default:
-            G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
-            break;
-    }
-}
-
-static void
-uca_xkit_camera_finalize(GObject *object)
-{
-    UcaXkitCameraPrivate *priv;
-
-    priv = UCA_XKIT_CAMERA_GET_PRIVATE (object);
-    g_clear_error (&priv->construct_error);
-
-    G_OBJECT_CLASS (uca_xkit_camera_parent_class)->finalize (object);
-}
-
-static gboolean
-ufo_xkit_camera_initable_init (GInitable *initable,
-                               GCancellable *cancellable,
-                               GError **error)
-{
-    UcaXkitCamera *camera;
-    UcaXkitCameraPrivate *priv;
-
-    g_return_val_if_fail (UCA_IS_XKIT_CAMERA (initable), FALSE);
-
-    if (cancellable != NULL) {
-        g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
-                             "Cancellable initialization not supported");
-        return FALSE;
-    }
-
-    camera = UCA_XKIT_CAMERA (initable);
-    priv = camera->priv;
-
-    if (priv->construct_error != NULL) {
-        if (error)
-            *error = g_error_copy (priv->construct_error);
-
-        return FALSE;
-    }
-
-    return TRUE;
-}
-
-static void
-uca_xkit_camera_initable_iface_init (GInitableIface *iface)
-{
-    iface->init = ufo_xkit_camera_initable_init;
-}
-
-static void
-uca_xkit_camera_class_init (UcaXkitCameraClass *klass)
-{
-    GObjectClass *oclass = G_OBJECT_CLASS (klass);
-    UcaCameraClass *camera_class = UCA_CAMERA_CLASS (klass);
-
-    oclass->set_property = uca_xkit_camera_set_property;
-    oclass->get_property = uca_xkit_camera_get_property;
-    oclass->finalize = uca_xkit_camera_finalize;
-
-    camera_class->start_recording = uca_xkit_camera_start_recording;
-    camera_class->stop_recording = uca_xkit_camera_stop_recording;
-    camera_class->start_readout = uca_xkit_camera_start_readout;
-    camera_class->stop_readout = uca_xkit_camera_stop_readout;
-    camera_class->grab = uca_xkit_camera_grab;
-    camera_class->trigger = uca_xkit_camera_trigger;
-
-    for (guint i = 0; base_overrideables[i] != 0; i++)
-        g_object_class_override_property (oclass, base_overrideables[i], uca_camera_props[base_overrideables[i]]);
-
-    xkit_properties[PROP_POSITIVE_POLARITY] =
-        g_param_spec_boolean ("positive-polarity",
-                              "Is polarity positive",
-                              "Is polarity positive",
-                              TRUE, (GParamFlags) G_PARAM_READWRITE);
-
-    for (guint id = N_BASE_PROPERTIES; id < N_PROPERTIES; id++)
-        g_object_class_install_property (oclass, id, xkit_properties[id]);
-
-    g_type_class_add_private (klass, sizeof(UcaXkitCameraPrivate));
-}
-
-static void
-uca_xkit_camera_init (UcaXkitCamera *self)
-{
-    UcaXkitCameraPrivate *priv;
-
-    self->priv = priv = UCA_XKIT_CAMERA_GET_PRIVATE (self);
-    priv->construct_error = NULL;
-
-    if (!setup_xkit (priv))
-        return;
-}
-
-G_MODULE_EXPORT GType
-uca_camera_get_type (void)
-{
-    return UCA_TYPE_XKIT_CAMERA;
-}