Make ipedec a lib and executable

CMakeLists.txt

@@ -0,0 +1,71 @@
+cmake_minimum_required(VERSION 2.8)
+set(TARNAME "libipe")
+
+set(LIBIPE_API_VERSION "0.1.0")
+set(LIBIPE_ABI_VERSION "0.1.0")
+set(LIBIPE_ABI_MAJOR_VERSION "0")
+
+set(PACKAGE_VERSION "0.1.0")
+set(PACKAGE_NAME "${TARNAME}")
+set(PACKAGE_TARNAME "${TARNAME}")
+set(PACKAGE_STRING "${PACKAGE_NAME} ${PACKAGE_VERSION}")
+set(PACKAGE_BUGREPORT "http://ufo.kit.edu/ufo/newticket")
+
+if(NOT DEFINED BIN_INSTALL_DIR)
+    set(BIN_INSTALL_DIR "${CMAKE_INSTALL_PREFIX}/bin")
+endif(NOT DEFINED BIN_INSTALL_DIR)
+
+if(NOT DEFINED LIB_INSTALL_DIR)
+    set(LIB_INSTALL_DIR "${CMAKE_INSTALL_PREFIX}/lib")
+endif(NOT DEFINED LIB_INSTALL_DIR)
+
+if(NOT DEFINED INCLUDE_INSTALL_DIR)
+    set(INCLUDE_INSTALL_DIR "${CMAKE_INSTALL_PREFIX}/include/${PACKAGE_TARNAME}")
+endif(NOT DEFINED INCLUDE_INSTALL_DIR)
+
+if(NOT DEFINED LOCALE_INSTALL_DIR)
+    set(LOCALE_INSTALL_DIR "${DATA_INSTALL_DIR}/locale/")
+endif(NOT DEFINED LOCALE_INSTALL_DIR)
+
+
+# --- Build library and install ---------------------------------------------
+include_directories(
+    ${CMAKE_SOURCE_DIR}/src 
+    ${CMAKE_CURRENT_BINARY_DIR}
+)
+
+add_definitions("--std=c99 -Wall -O2")
+
+add_library(ipe SHARED src/libipe.c)
+
+set_target_properties(ipe PROPERTIES
+    VERSION ${LIBIPE_ABI_VERSION}
+    SOVERSION ${LIBIPE_ABI_MAJOR_VERSION}
+)
+
+install(TARGETS ipe
+    LIBRARY DESTINATION lib${LIB_SUFFIX}
+)
+
+install(FILES
+    src/libipe.h 
+    DESTINATION include
+)
+
+configure_file(ipe.pc.in ${CMAKE_CURRENT_BINARY_DIR}/ipe.pc)
+
+if ("${CMAKE_BUILD_TYPE}" MATCHES "Debug")
+    set(DEBUG "1")
+endif()
+configure_file(src/config.h.in ${CMAKE_CURRENT_BINARY_DIR}/config.h)
+
+install(FILES 
+    ${CMAKE_CURRENT_BINARY_DIR}/ipe.pc 
+    DESTINATION ${LIB_INSTALL_DIR}/pkgconfig)
+
+
+# --- Build test executable -------------------------------------------------
+add_executable(ipedec test/ipedec.c)
+target_link_libraries(ipedec ipe)
+
+install(TARGETS ipedec DESTINATION ${BIN_INSTALL_DIR})

ipe.pc.in

@@ -0,0 +1,10 @@
+prefix=${CMAKE_INSTALL_PREFIX}
+exec_prefix=${BIN_INSTALL_DIR}
+libdir=${LIB_INSTALL_DIR}
+includedir=${INCLUDE_INSTALL_DIR}
+
+Name: libipe
+Description: Decoding routines for the UFO camera
+Version: ${PACKAGE_VERSION}
+Libs: -L${LIB_INSTALL_DIR} -lipe
+Cflags: -I${INCLUDE_INSTALL_DIR}

src/config.h.in

@@ -0,0 +1 @@
+#cmakedefine DEBUG

src/libipe-private.h

@@ -0,0 +1,15 @@
+#ifndef LIB_IPE_PRIVATE_H
+#define LIB_IPE_PRIVATE_H
+
+#include <stdbool.h>
+
+struct ipe_decoder_t {
+    uint32_t height;
+    uint32_t *raw;
+    size_t num_bytes; 
+    uint32_t current_pos;
+};
+
+
+#endif
+

src/libipe.c

@@ -0,0 +1,294 @@
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include "libipe.h"
+#include "libipe-private.h"
+#include "config.h"
+
+#define IPECAMERA_NUM_CHANNELS 16
+#define IPECAMERA_PIXELS_PER_CHANNEL 128
+#define IPECAMERA_WIDTH (IPECAMERA_NUM_CHANNELS * IPECAMERA_PIXELS_PER_CHANNEL)
+
+
+#define CHECK_VALUE(value, expected) \
+    if (value != expected) { \
+        fprintf(stderr, "<%s:%i> 0x%x != 0x%x\n", __FILE__, __LINE__, value, expected); \
+        err = 1; \
+    }
+
+#define CHECK_FLAG(flag, check, ...) \
+    if (!(check)) { \
+        fprintf(stderr, "<%s:%i> Unexpected value 0x%x of " flag "\n", __FILE__, __LINE__,  __VA_ARGS__); \
+        err = 1; \
+    }
+
+
+/**
+ * \brief Setup a new decoder instance
+ *
+ * \param height Number of rows that are expected in the data stream
+ * \param raw The data stream from the camera or NULL if set later with
+ * ipe_decoder_set_raw_data.
+ * \param num_bytes Size of the data stream buffer in bytes
+ *
+ * \return A new decoder instance that can be used to iterate over the frames
+ * using ipe_decoder_get_next_frame.
+ */
+ipe_decoder ipe_decoder_new(uint32_t height, uint32_t *raw, size_t num_bytes)
+{
+    ipe_decoder decoder = malloc(sizeof(struct ipe_decoder_t));
+    if (decoder == NULL)
+        return NULL;
+
+    decoder->height = height;
+    ipe_decoder_set_raw_data(decoder, raw, num_bytes);
+    return decoder;
+}
+
+
+/**
+ * \brief Release decoder instance
+ *
+ * \param decoder An ipe_decoder instance
+ */
+void ipe_decoder_free(ipe_decoder decoder)
+{
+    free(decoder);
+}
+
+
+/**
+ * \brief Set raw data stream
+ *
+ * \param decoder An ipe_decoder instance
+ * \param raw Raw data stream
+ * \param num_bytes Size of data stream buffer in bytes
+ */
+void ipe_decoder_set_raw_data(ipe_decoder decoder, uint32_t *raw, size_t num_bytes)
+{
+    decoder->raw = raw;
+    decoder->num_bytes = num_bytes;
+    decoder->current_pos = 0;
+}
+
+
+static int ipe_decode_frame(uint16_t *pixel_buffer, uint32_t *raw, int num_rows, int *offset)
+{
+    static int channel_order[IPECAMERA_NUM_CHANNELS] = { 15, 13, 14, 12, 10, 8, 11, 7, 9, 6, 5, 2, 4, 3, 0, 1 };
+
+    int info;
+    int row = 0;
+    int channel = 0;
+    int pos = 0;
+    uint32_t data;
+
+    do {
+        info = raw[0];
+        channel = info & 0x0F;
+        row = (info >> 4) & 0x7FF;
+        int pixels = (info >> 20) & 0xFF;
+
+        channel = channel_order[channel];
+        int base = row * IPECAMERA_WIDTH + channel * IPECAMERA_PIXELS_PER_CHANNEL;
+
+#ifdef DEBUG
+        int err = 0;
+        int header = (info >> 30) & 0x03;   // 2 bits
+        const int bpp = (info >> 16) & 0x0F;      // 4 bits
+        CHECK_FLAG("raw header magick", header == 2, header);
+        CHECK_FLAG("pixel size, only 10 bits are supported", bpp == 10, bpp);
+        CHECK_FLAG("channel, limited by %i output channels", channel < IPECAMERA_NUM_CHANNELS, channel, IPECAMERA_NUM_CHANNELS);
+#endif
+
+        /* "Correct" missing pixel */
+        if ((row < 2) && (pixels == (IPECAMERA_PIXELS_PER_CHANNEL - 1))) {
+            pixel_buffer[base] = 0;
+            base++;
+        } 
+#ifdef DEBUG
+        else 
+            CHECK_FLAG("number of pixels, %i is expected", pixels == IPECAMERA_PIXELS_PER_CHANNEL, pixels, IPECAMERA_PIXELS_PER_CHANNEL);
+#endif
+
+        int bytes = 43;
+        /* bytes = pixels / 3; */
+        /* int ppw = pixels - bytes * 3; */
+        /* if (ppw) */ 
+        /*     ++bytes; */
+
+        for (int i = 1; i < bytes; i++) {
+            data = raw[i];
+
+#ifdef DEBUG
+            header = (data >> 30) & 0x03;   
+            CHECK_FLAG("raw data magick", header == 3, header);
+            if (err) 
+                return err;
+#endif
+            pixel_buffer[base++] = (data >> 20) & 0x3FF;
+            pixel_buffer[base++] = (data >> 10) & 0x3FF;
+            pixel_buffer[base++] = data & 0x3FF;
+        }
+
+        data = raw[bytes];
+
+#ifdef DEBUG
+        header = (data >> 30) & 0x03;
+        CHECK_FLAG("raw data magick", header == 3, header);
+        CHECK_FLAG("raw footer magick", (data & 0x3FF) == 0x55, (data & 0x3FF));
+        if (err) 
+            return err;
+#endif
+
+        int ppw = pixels >> 6;
+        for (int j = 0; j < ppw; j++)
+            pixel_buffer[base++] = (data >> (10 * (ppw - j))) & 0x3FF;
+
+        pos += bytes + 1;
+        raw += bytes + 1;
+    } while ((row < (num_rows - 1)) || (channel != 1));
+
+    *offset = pos;
+    return 0;
+}
+
+
+/**
+ * \brief Deinterlace by interpolating between two rows
+ *
+ * \param in Input frame
+ * \param out Destination of interpolated frame
+ * \param width Width of frame in pixels
+ * \param heigh Height of frame in pixels
+ */
+void ipe_deinterlace_interpolate(const uint16_t *in, uint16_t *out, int width, int height)
+{
+    const size_t row_size_bytes = width * sizeof(uint16_t);
+
+    for (int row = 0; row < height; row++) {
+        /* Copy one line */
+        memcpy(out, in + row*width, row_size_bytes);
+        out += width;
+
+        /* Interpolate between source row and row+1 */ 
+        for (int x = 0; x < width; x++) {
+            out[x] = (int) (0.5 * in[row*width + x] + 0.5 * in[(row+1)*width + x]);
+        }
+        out += width;
+    }
+
+    /* Copy last row */
+    memcpy(out, in + width * (height - 1), row_size_bytes);
+}
+
+
+/**
+ * \brief Deinterlace by "weaving" the rows of two frames
+ *
+ * \param in1 First frame
+ * \param in2 Second frame
+ * \param out Destination of weaved frame
+ * \param width Width of frame in pixels
+ * \param heigh Height of frame in pixels
+ */
+void ipe_deinterlace_weave(const uint16_t *in1, const uint16_t *in2, uint16_t *out, int width, int height)
+{
+    const size_t row_size_bytes = width * sizeof(uint16_t);
+    for (int row = 0; row < height; row++) {
+        memcpy(out, in1 + row*width, row_size_bytes); 
+        out += width;
+        memcpy(out, in2 + row*width, row_size_bytes); 
+        out += width;
+    }
+}
+
+
+/**
+ * \brief Iterate and decode next frame
+ *
+ * This function tries to decode the next frame in the currently set raw data
+ * stream. 
+ *
+ * \param decoder An ipe_decoder instance
+ * \param pixels If pointer with NULL content is passed, a new buffer is
+ * allocated otherwise, this user-supplied buffer is used.
+ * \param frame_number Frame number as reported in the header
+ * \param time_stamp Time stamp of the frame as reported in the header
+ *
+ * \return 0 in case of no error, ENOSR if end of stream was reached, ENOMEM if
+ * NULL was passed but no memory could be allocated, EILSEQ if data stream is
+ * corrupt and EFAULT if pixels is a NULL-pointer.
+ */
+int ipe_decoder_get_next_frame(ipe_decoder decoder, uint16_t **pixels, uint32_t *frame_number, uint32_t *time_stamp)
+{
+
+    uint32_t *raw = decoder->raw;
+    int err = 0;
+    int pos = decoder->current_pos;
+    int advance;
+    const int num_words = decoder->num_bytes / 4;
+
+    if (pixels == NULL)
+        return EFAULT;
+
+    if (pos >= num_words)
+        return ENOSR; 
+
+    if (num_words < 16)
+        return EILSEQ;
+
+    if (*pixels == NULL) {
+        *pixels = (uint16_t *) malloc(IPECAMERA_WIDTH * decoder->height * sizeof(uint16_t));
+        if (*pixels == NULL)
+            return ENOMEM;
+    }
+
+#ifdef DEBUG
+    CHECK_VALUE(raw[pos++], 0x51111111);
+    CHECK_VALUE(raw[pos++], 0x52222222);
+    CHECK_VALUE(raw[pos++], 0x53333333);
+    CHECK_VALUE(raw[pos++], 0x54444444);
+    CHECK_VALUE(raw[pos++], 0x55555555);
+    CHECK_VALUE(raw[pos++], 0x56666666);
+    CHECK_VALUE(raw[pos] >> 28, 0x5);
+    *frame_number = raw[pos++] & 0xF0000000;
+    CHECK_VALUE(raw[pos] >> 28, 0x5);
+    *time_stamp = raw[pos++] & 0xF0000000;
+    if (err)
+        return EILSEQ;
+#else
+    pos += 8;
+#endif
+
+    err = ipe_decode_frame(*pixels, raw + pos, decoder->height, &advance);
+    if (err) 
+        return EILSEQ;
+
+    pos += advance;
+
+#ifdef DEBUG
+    CHECK_VALUE(raw[pos++], 0x0AAAAAAA);
+    CHECK_VALUE(raw[pos++], 0x0BBBBBBB);
+    CHECK_VALUE(raw[pos++], 0x0CCCCCCC);
+    CHECK_VALUE(raw[pos++], 0x0DDDDDDD);
+    CHECK_VALUE(raw[pos++], 0x0EEEEEEE);
+    CHECK_VALUE(raw[pos++], 0x0FFFFFFF);
+    CHECK_VALUE(raw[pos++], 0x00000000);
+    CHECK_VALUE(raw[pos++], 0x01111111);
+#else
+    pos += 8;
+#endif
+
+    /* if bytes left and we see fill bytes, skip them */
+    if ((raw[pos] == 0x0) && (raw[pos+1] == 0x1111111)) {
+        pos += 2;
+        while ((pos < num_words) && ((raw[pos] == 0x89abcdef) || (raw[pos] == 0x1234567)))
+            pos++;
+    }
+
+    decoder->current_pos = pos;
+    return 0;
+}
+

src/libipe.h

@@ -0,0 +1,27 @@
+#ifndef LIB_IPE_H
+#define LIB_IPE_H
+
+#include <inttypes.h>
+
+typedef struct ipe_decoder_t *ipe_decoder;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+ipe_decoder ipe_decoder_new(uint32_t height, uint32_t *raw, size_t num_bytes);
+void ipe_decoder_free(ipe_decoder decoder);
+void ipe_decoder_set_raw_data(ipe_decoder decoder, uint32_t *raw, size_t num_bytes);
+int ipe_decoder_get_next_frame(ipe_decoder decoder, uint16_t **pixels, uint32_t *frame_number, uint32_t *time_stamp);
+
+void ipe_deinterlace_interpolate(const uint16_t *frame_in, uint16_t *frame_out, int width, int height);
+void ipe_deinterlace_weave(const uint16_t *in1, const uint16_t *in2, uint16_t *out, int width, int height);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+

src/versions.ldscript

@@ -0,0 +1,9 @@
+libipe_0.1 {
+    global:
+        ipe_decoder ipe_decoder_new;
+        ipe_decoder_free;
+        ipe_decoder_set_raw_data;
+        ipe_decoder_next_frame;
+    local:
+        *;
+};

test/ipedec.c

@@ -0,0 +1,83 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <unistd.h>
+#include <sys/time.h>
+#include <errno.h>
+#include <libipe.h>
+
+
+int read_raw_file(const char *filename, char **buffer, size_t *length)
+{
+    FILE *fp = fopen(filename, "rb"); 
+    if (fp == NULL)
+        return ENOENT;
+
+    fseek(fp, 0, SEEK_END);
+    *length = ftell(fp);
+    rewind(fp);
+
+    *buffer = (char *) malloc(*length);
+    if (*buffer == NULL) {
+        fclose(fp);
+        return ENOMEM;
+    }
+
+    size_t buffer_length = fread(*buffer, 1, *length, fp);
+    fclose(fp);
+    if (buffer_length != *length) {
+        free(buffer);
+        return ERANGE;
+    }
+    return 0;
+}
+
+
+int main(int argc, char const* argv[])
+{
+    if (argc < 3) {
+        fprintf(stderr, "Usage: ipedec <filename> <number of lines per frame>\n");
+        return EXIT_FAILURE;
+    }
+
+    char *buffer = NULL;
+    size_t num_bytes = 0;
+    if (read_raw_file(argv[1], &buffer, &num_bytes))
+        return EXIT_FAILURE;
+
+    const int rows = atoi(argv[2]);
+
+    ipe_decoder decoder = ipe_decoder_new(rows, (uint32_t *) buffer, num_bytes);
+    int err = 0;
+    uint16_t *pixels = (uint16_t *) malloc(2048 * rows * sizeof(uint16_t));
+    uint32_t frame_number, time_stamp;
+    int num_frames = 0;
+    struct timeval start, end;
+    long seconds = 0L, useconds = 0L;
+
+    /* FILE *fp = fopen("test.raw", "wb"); */
+
+    while (!err) {
+        gettimeofday(&start, NULL);
+        err = ipe_decoder_get_next_frame(decoder, &pixels, &frame_number, &time_stamp);
+        gettimeofday(&end, NULL);
+
+        if (!err) {
+            num_frames++;
+            seconds += end.tv_sec - start.tv_sec;
+            useconds += end.tv_usec - start.tv_usec;
+            /* fwrite(pixels, sizeof(uint16_t), 2048 * 1088, fp); */
+        }
+    }
+    /* fclose(fp); */
+
+    float mtime = seconds * 1000.0 + useconds / 1000.0;
+    printf("Decoded %i frames in %.5fms\n", num_frames, mtime);
+
+    free(pixels);
+    ipe_decoder_free(decoder);
+    free(buffer);
+
+    return 0;
+}
+