Use direct UDP communication for xkit

1 files changed, 665 insertions, 0 deletions

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;
+}