From b29c78f818ac92f42621c69c29736fe5c8e32c6f Mon Sep 17 00:00:00 2001 From: Matthias Vogelgesang Date: Thu, 1 Mar 2012 12:32:10 +0100 Subject: Initial prototype of GObject-based libuca --- src/CMakeLists.txt | 18 ++++++ src/cameras/uca-mock-camera.c | 125 ++++++++++++++++++++++++++++++++++++++ src/cameras/uca-mock-camera.h | 60 ++++++++++++++++++ src/cameras/uca-pco-camera.c | 138 ++++++++++++++++++++++++++++++++++++++++++ src/cameras/uca-pco-camera.h | 62 +++++++++++++++++++ src/uca-camera.c | 115 +++++++++++++++++++++++++++++++++++ src/uca-camera.h | 51 ++++++++++++++++ 7 files changed, 569 insertions(+) create mode 100644 src/cameras/uca-mock-camera.c create mode 100644 src/cameras/uca-mock-camera.h create mode 100644 src/cameras/uca-pco-camera.c create mode 100644 src/cameras/uca-pco-camera.h create mode 100644 src/uca-camera.c create mode 100644 src/uca-camera.h (limited to 'src') diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 3bb668a..7bb66aa 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -121,6 +121,24 @@ set_target_properties(uca PROPERTIES target_link_libraries(uca ${uca_LIBS}) + +# >>>> TEMPORARY BUILD TARGET <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< +pkg_check_modules(GLIB2 glib-2.0>=2.24 REQUIRED) +pkg_check_modules(GOBJECT2 gobject-2.0>=2.24 REQUIRED) + +include_directories( + ${GLIB2_INCLUDE_DIRS} + ${GOBJECT2_INCLUDE_DIRS} + ${PCO_INCLUDE_DIRS} + ${CMAKE_CURRENT_SOURCE_DIR}/cameras + ) + +add_library(uca-gobject SHARED uca-camera.c cameras/uca-pco-camera.c cameras/uca-mock-camera.c) + +target_link_libraries(uca-gobject ${GLIB2_LIBRARIES} ${GOBJECT2_LIBRARIES} + ${PCO_LIBRARIES}) + + # --- Install target ---------------------------------------------------------- set(LIB_INSTALL_DIR "lib${LIB_SUFFIX}") diff --git a/src/cameras/uca-mock-camera.c b/src/cameras/uca-mock-camera.c new file mode 100644 index 0000000..feae389 --- /dev/null +++ b/src/cameras/uca-mock-camera.c @@ -0,0 +1,125 @@ +/* Copyright (C) 2011, 2012 Matthias Vogelgesang + (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 "uca-camera.h" +#include "uca-mock-camera.h" + +#define UCA_MOCK_CAMERA_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE((obj), UCA_TYPE_MOCK_CAMERA, UcaMockCameraPrivate)) + +static void uca_mock_camera_interface_init(UcaCameraInterface *iface); + +G_DEFINE_TYPE_WITH_CODE(UcaMockCamera, uca_mock_camera, G_TYPE_OBJECT, + G_IMPLEMENT_INTERFACE(UCA_TYPE_CAMERA, + uca_mock_camera_interface_init)); + +enum { + PROP_0, + PROP_SENSOR_WIDTH, + PROP_SENSOR_HEIGHT, + N_PROPERTIES +}; + +static const gchar *mock_overrideables[N_PROPERTIES] = { + "sensor-width", + "sensor-height" +}; + +struct _UcaMockCameraPrivate { + guint width; + guint height; + guint16 *dummy_data; +}; + +static void uca_mock_camera_start_recording(UcaCamera *camera) +{ + g_return_if_fail(UCA_IS_MOCK_CAMERA(camera)); + g_print("start recording\n"); +} + +static void uca_mock_camera_stop_recording(UcaCamera *camera) +{ + g_return_if_fail(UCA_IS_MOCK_CAMERA(camera)); + g_print("stop recording\n"); +} + +static void uca_mock_camera_grab(UcaCamera *camera, gchar *data) +{ + g_return_if_fail(UCA_IS_MOCK_CAMERA(camera)); + /* g_memmove(data, camera->priv->dummy_data, camera->priv->width * camera->priv->height * 2); */ +} + +static void uca_mock_camera_set_property(GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) +{ + UcaMockCameraPrivate *priv = UCA_MOCK_CAMERA_GET_PRIVATE(object); + + switch (property_id) { + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec); + break; + } +} + +static void uca_mock_camera_get_property(GObject *object, guint property_id, GValue *value, GParamSpec *pspec) +{ + UcaMockCameraPrivate *priv = UCA_MOCK_CAMERA_GET_PRIVATE(object); + + switch (property_id) { + case PROP_SENSOR_WIDTH: + g_value_set_uint(value, 1024); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec); + break; + } +} + +static void uca_mock_camera_finalize(GObject *object) +{ + UcaMockCameraPrivate *priv = UCA_MOCK_CAMERA_GET_PRIVATE(object); + + g_free(priv->dummy_data); + + G_OBJECT_CLASS(uca_mock_camera_parent_class)->finalize(object); +} + +static void uca_mock_camera_interface_init(UcaCameraInterface *iface) +{ + iface->start_recording = uca_mock_camera_start_recording; + iface->stop_recording = uca_mock_camera_stop_recording; + iface->grab = uca_mock_camera_grab; +} + +static void uca_mock_camera_class_init(UcaMockCameraClass *klass) +{ + GObjectClass *gobject_class = G_OBJECT_CLASS(klass); + gobject_class->set_property = uca_mock_camera_set_property; + gobject_class->get_property = uca_mock_camera_get_property; + gobject_class->finalize = uca_mock_camera_finalize; + + for (guint property_id = PROP_0+1; property_id < N_PROPERTIES; property_id++) + g_object_class_override_property(gobject_class, property_id, mock_overrideables[property_id-1]); + + g_type_class_add_private(klass, sizeof(UcaMockCameraPrivate)); +} + +static void uca_mock_camera_init(UcaMockCamera *self) +{ + self->priv = UCA_MOCK_CAMERA_GET_PRIVATE(self); + self->priv->width = 1024; + self->priv->height = 768; + self->priv->dummy_data = (guint16 *) g_malloc0(self->priv->width * self->priv->height * 2); +} diff --git a/src/cameras/uca-mock-camera.h b/src/cameras/uca-mock-camera.h new file mode 100644 index 0000000..708542a --- /dev/null +++ b/src/cameras/uca-mock-camera.h @@ -0,0 +1,60 @@ +/* Copyright (C) 2011, 2012 Matthias Vogelgesang + (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 */ + +#ifndef __UCA_MOCK_CAMERA_H +#define __UCA_MOCK_CAMERA_H + +#include + +#define UCA_TYPE_MOCK_CAMERA (uca_mock_camera_get_type()) +#define UCA_MOCK_CAMERA(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), UCA_TYPE_MOCK_CAMERA, UcaMockCamera)) +#define UCA_IS_MOCK_CAMERA(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), UCA_TYPE_MOCK_CAMERA)) +#define UCA_MOCK_CAMERA_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), UFO_TYPE_MOCK_CAMERA, UfoMockCameraClass)) +#define UCA_IS_MOCK_CAMERA_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), UCA_TYPE_MOCK_CAMERA)) +#define UCA_MOCK_CAMERA_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), UCA_TYPE_MOCK_CAMERA, UcaMockCameraClass)) + +typedef struct _UcaMockCamera UcaMockCamera; +typedef struct _UcaMockCameraClass UcaMockCameraClass; +typedef struct _UcaMockCameraPrivate UcaMockCameraPrivate; + +/** + * UcaMockCamera: + * + * Creates #UcaMockCamera instances by loading corresponding shared objects. The + * contents of the #UcaMockCamera structure are private and should only be + * accessed via the provided API. + */ +struct _UcaMockCamera { + /*< private >*/ + GObject parent; + + UcaMockCameraPrivate *priv; +}; + +/** + * UcaMockCameraClass: + * + * #UcaMockCamera class + */ +struct _UcaMockCameraClass { + /*< private >*/ + GObjectClass parent; +}; + +GType uca_mock_camera_get_type(void); + +#endif diff --git a/src/cameras/uca-pco-camera.c b/src/cameras/uca-pco-camera.c new file mode 100644 index 0000000..9ca52cf --- /dev/null +++ b/src/cameras/uca-pco-camera.c @@ -0,0 +1,138 @@ +/* Copyright (C) 2011, 2012 Matthias Vogelgesang + (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 +#include +#include +#include "uca-camera.h" +#include "uca-pco-camera.h" + +#define UCA_PCO_CAMERA_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE((obj), UCA_TYPE_PCO_CAMERA, UcaPcoCameraPrivate)) + +static void uca_pco_camera_interface_init(UcaCameraInterface *iface); + +G_DEFINE_TYPE_WITH_CODE(UcaPcoCamera, uca_pco_camera, G_TYPE_OBJECT, + G_IMPLEMENT_INTERFACE(UCA_TYPE_CAMERA, + uca_pco_camera_interface_init)); + +enum { + PROP_0, + PROP_SENSOR_WIDTH, + PROP_SENSOR_HEIGHT, + N_PROPERTIES +}; + +static const gchar *pco_overrideables[N_PROPERTIES] = { + "sensor-width", + "sensor-height" +}; + +struct _UcaPcoCameraPrivate { + pco_handle pco; +}; + +UcaPcoCamera *uca_pco_camera_new(GError **error) +{ + pco_handle pco = pco_init(); + + if (pco == NULL) { + /* TODO: throw error */ + return NULL; + } + + UcaPcoCamera *camera = g_object_new(UCA_TYPE_PCO_CAMERA, NULL); + camera->priv->pco = pco; + return camera; +} + +static void uca_pco_camera_start_recording(UcaCamera *camera) +{ + g_return_if_fail(UCA_IS_PCO_CAMERA(camera)); +} + +static void uca_pco_camera_stop_recording(UcaCamera *camera) +{ + g_return_if_fail(UCA_IS_PCO_CAMERA(camera)); +} + +static void uca_pco_camera_grab(UcaCamera *camera, gchar *data) +{ + g_return_if_fail(UCA_IS_PCO_CAMERA(camera)); +} + +static void uca_pco_camera_set_property(GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) +{ + UcaPcoCameraPrivate *priv = UCA_PCO_CAMERA_GET_PRIVATE(object); + + switch (property_id) { + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec); + break; + } +} + +static void uca_pco_camera_get_property(GObject *object, guint property_id, GValue *value, GParamSpec *pspec) +{ + UcaPcoCameraPrivate *priv = UCA_PCO_CAMERA_GET_PRIVATE(object); + + switch (property_id) { + case PROP_SENSOR_WIDTH: + { + uint16_t width_std, height_std, width_ex, height_ex; + if (pco_get_resolution(priv->pco, &width_std, &height_std, &width_ex, &height_ex) == PCO_NOERROR) + g_value_set_uint(value, width_std); + } + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec); + break; + } +} + +static void uca_pco_camera_finalize(GObject *object) +{ + UcaPcoCameraPrivate *priv = UCA_PCO_CAMERA_GET_PRIVATE(object); + + pco_destroy(priv->pco); + + G_OBJECT_CLASS(uca_pco_camera_parent_class)->finalize(object); +} + +static void uca_pco_camera_interface_init(UcaCameraInterface *iface) +{ + iface->start_recording = uca_pco_camera_start_recording; + iface->stop_recording = uca_pco_camera_stop_recording; + iface->grab = uca_pco_camera_grab; +} + +static void uca_pco_camera_class_init(UcaPcoCameraClass *klass) +{ + GObjectClass *gobject_class = G_OBJECT_CLASS(klass); + gobject_class->set_property = uca_pco_camera_set_property; + gobject_class->get_property = uca_pco_camera_get_property; + gobject_class->finalize = uca_pco_camera_finalize; + + for (guint property_id = PROP_0+1; property_id < N_PROPERTIES; property_id++) + g_object_class_override_property(gobject_class, property_id, pco_overrideables[property_id-1]); + + g_type_class_add_private(klass, sizeof(UcaPcoCameraPrivate)); +} + +static void uca_pco_camera_init(UcaPcoCamera *self) +{ + self->priv = UCA_PCO_CAMERA_GET_PRIVATE(self); +} diff --git a/src/cameras/uca-pco-camera.h b/src/cameras/uca-pco-camera.h new file mode 100644 index 0000000..336cbf6 --- /dev/null +++ b/src/cameras/uca-pco-camera.h @@ -0,0 +1,62 @@ +/* Copyright (C) 2011, 2012 Matthias Vogelgesang + (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 */ + +#ifndef __UCA_PCO_CAMERA_H +#define __UCA_PCO_CAMERA_H + +#include + +#define UCA_TYPE_PCO_CAMERA (uca_pco_camera_get_type()) +#define UCA_PCO_CAMERA(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), UCA_TYPE_PCO_CAMERA, UcaPcoCamera)) +#define UCA_IS_PCO_CAMERA(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), UCA_TYPE_PCO_CAMERA)) +#define UCA_PCO_CAMERA_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), UFO_TYPE_PCO_CAMERA, UfoPcoCameraClass)) +#define UCA_IS_PCO_CAMERA_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), UCA_TYPE_PCO_CAMERA)) +#define UCA_PCO_CAMERA_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), UCA_TYPE_PCO_CAMERA, UcaPcoCameraClass)) + +typedef struct _UcaPcoCamera UcaPcoCamera; +typedef struct _UcaPcoCameraClass UcaPcoCameraClass; +typedef struct _UcaPcoCameraPrivate UcaPcoCameraPrivate; + +/** + * UcaPcoCamera: + * + * Creates #UcaPcoCamera instances by loading corresponding shared objects. The + * contents of the #UcaPcoCamera structure are private and should only be + * accessed via the provided API. + */ +struct _UcaPcoCamera { + /*< private >*/ + GObject parent; + + UcaPcoCameraPrivate *priv; +}; + +/** + * UcaPcoCameraClass: + * + * #UcaPcoCamera class + */ +struct _UcaPcoCameraClass { + /*< private >*/ + GObjectClass parent; +}; + +UcaPcoCamera *uca_pco_camera_new(GError **error); + +GType uca_pco_camera_get_type(void); + +#endif diff --git a/src/uca-camera.c b/src/uca-camera.c new file mode 100644 index 0000000..9fa0666 --- /dev/null +++ b/src/uca-camera.c @@ -0,0 +1,115 @@ +/* Copyright (C) 2011, 2012 Matthias Vogelgesang + (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 +#include "uca-camera.h" + +G_DEFINE_INTERFACE(UcaCamera, uca_camera, G_TYPE_OBJECT) + +enum { + PROP_0 = 0, + PROP_SENSOR_WIDTH, + PROP_SENSOR_HEIGHT, + PROP_SENSOR_BITDEPTH, + PROP_SENSOR_HORIZONTAL_BINNING, + PROP_SENSOR_VERTICAL_BINNING, + N_PROPERTIES +}; + +static GParamSpec *uca_camera_properties[N_PROPERTIES] = { NULL, }; + +static void uca_camera_default_init(UcaCameraInterface *klass) +{ + klass->start_recording = NULL; + klass->stop_recording = NULL; + klass->grab = NULL; + + uca_camera_properties[PROP_SENSOR_WIDTH] = + g_param_spec_uint("sensor-width", + "Width of sensor", + "Width of the sensor in pixels", + 1, G_MAXUINT, 1, + G_PARAM_READABLE); + + uca_camera_properties[PROP_SENSOR_HEIGHT] = + g_param_spec_uint("sensor-height", + "Height of sensor", + "Height of the sensor in pixels", + 1, G_MAXUINT, 1, + G_PARAM_READABLE); + + uca_camera_properties[PROP_SENSOR_BITDEPTH] = + g_param_spec_uint("sensor-bitdepth", + "Number of bits per pixel", + "Number of bits per pixel", + 1, 32, 1, + G_PARAM_READABLE); + + uca_camera_properties[PROP_SENSOR_HORIZONTAL_BINNING] = + g_param_spec_uint("sensor-horizontal-binning", + "Horizontal binning", + "Number of sensor ADCs that are combined to one pixel in horizontal direction", + 1, G_MAXUINT, 1, + G_PARAM_READWRITE); + + uca_camera_properties[PROP_SENSOR_VERTICAL_BINNING] = + g_param_spec_uint("sensor-vertical-binning", + "Vertical binning", + "Number of sensor ADCs that are combined to one pixel in vertical direction", + 1, G_MAXUINT, 1, + G_PARAM_READWRITE); + + for (int i = PROP_0 + 1; i < N_PROPERTIES; i++) + g_object_interface_install_property(klass, uca_camera_properties[i]); +} + +void uca_camera_start_recording(UcaCamera *camera) +{ + g_return_if_fail(UCA_IS_CAMERA(camera)); + + UcaCameraInterface *iface = UCA_CAMERA_GET_INTERFACE(camera); + + g_return_if_fail(iface != NULL); + g_return_if_fail(iface->start_recording != NULL); + + (*iface->start_recording)(camera); +} + +void uca_camera_stop_recording(UcaCamera *camera) +{ + g_return_if_fail(UCA_IS_CAMERA(camera)); + + UcaCameraInterface *iface = UCA_CAMERA_GET_INTERFACE(camera); + + g_return_if_fail(iface != NULL); + g_return_if_fail(iface->start_recording != NULL); + + (*iface->stop_recording)(camera); +} + +void uca_camera_grab(UcaCamera *camera, gchar *data) +{ + g_return_if_fail(UCA_IS_CAMERA(camera)); + + UcaCameraInterface *iface = UCA_CAMERA_GET_INTERFACE(camera); + + g_return_if_fail(iface != NULL); + g_return_if_fail(iface->start_recording != NULL); + + (*iface->grab)(camera, data); +} + diff --git a/src/uca-camera.h b/src/uca-camera.h new file mode 100644 index 0000000..29010c6 --- /dev/null +++ b/src/uca-camera.h @@ -0,0 +1,51 @@ +/* Copyright (C) 2011, 2012 Matthias Vogelgesang + (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 */ + +#ifndef __UCA_CAMERA_H +#define __UCA_CAMERA_H + +#include + +#define UCA_TYPE_CAMERA (uca_camera_get_type()) +#define UCA_CAMERA(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), UCA_TYPE_CAMERA, UcaCamera)) +#define UCA_IS_CAMERA(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), UCA_TYPE_CAMERA)) +#define UCA_CAMERA_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE((obj), UCA_TYPE_CAMERA, UcaCameraInterface)) + +typedef struct _UcaCamera UcaCamera; +typedef struct _UcaCameraInterface UcaCameraInterface; + +/** + * UcaCameraInterface: + * + * Base interface for cameras. + */ +struct _UcaCameraInterface { + /*< private >*/ + GTypeInterface parent; + + void (*start_recording) (UcaCamera *camera); + void (*stop_recording) (UcaCamera *camera); + void (*grab) (UcaCamera *camera, gchar *data); +}; + +void uca_camera_start_recording(UcaCamera *camera); +void uca_camera_stop_recording(UcaCamera *camera); +void uca_camera_grab(UcaCamera *camera, gchar *data); + +GType uca_camera_get_type(void); + +#endif -- cgit v1.2.3